python C API: метод класса в качестве callback'а

import lapb
from binascii import hexlify

class PackStuff:
   def __init__(self):
         lapb.register(self.rcv)
         lapb.loop()
   def rcv(self, data, len):
         # processing data
         print hexlify(data)
...
         if ord(data[0] == 0x01:
             self.hande_adc(data[1:])
         if ord(data[0] == 0x02:
             self.hande_test_req(data[1:])
...

if __name__ == "__main__":
    data = PackStuff()

import lapb
from binascii import hexlify
import time

def rdata(s, l):
    hexlify(s)

lapb.init("/dev/ttyS0")
lapb.cb(myfunc)
while True:
    lapb.get_next_data()
    lapb.send("hello")
    time.sleep(0.01)

#include <Python.h>

static PyObject *rcv = NULL;

extern int op_ok(void);

#define NEEDS_NL()                                              \
        do {                                                    \
                if (op_ok() < 0) {                              \
                        PyErr_SetString(PyExc_TypeError,        \
                                "panic: not initialized");      \
                        return 0;                               \
                }                                               \
        } while(0)
static PyObject *cb(PyObject *self, PyObject *args)
{
        PyObject *temp;
        NEEDS_NL();
        if (PyArg_ParseTuple(args, "O", &temp)) {
                if (!PyCallable_Check(temp)) {
                        PyErr_SetString(PyExc_TypeError, "parameter must be callable");
                        return NULL;
                }
        }
        if (op_ok() < 0) {

        }
        Py_XINCREF(temp);
        Py_XDECREF(rcv);
        rcv = temp;
        Py_INCREF(Py_None);
        return Py_None;
}
int call_rcv(int type, unsigned char *data, int len)
{
        PyObject *result;
        PyObject *arglist;
        NEEDS_NL();
        if (data == NULL || len == 0) {
                arglist = Py_BuildValue("(i)", type);
        } else {
                arglist = Py_BuildValue("(is#)", type, data, len);
        }
        printf("Calling callback %p %p\n", rcv, arglist);
        if (!arglist) {
                /* FIXME: raise exception here or something */
                printf("Exception: unable to build value type = %d, data = %p, len = %d\n",
                        type, data, len);
                return 0;
        }
        result = PyObject_CallObject(rcv, arglist);
        printf("Called callback %p %p\n", rcv, result);
        Py_XDECREF(arglist);
        Py_XDECREF(result);
        return 0;
}

static PyObject *busyloop(PyObject *self, PyObject *args)
{
        extern void test(void);
        NEEDS_NL();
        test();
        Py_INCREF(Py_None);
        return Py_None;
}

static PyObject *init(PyObject *self, PyObject *args)
{
        extern void lapb_nl_init(char *tty);
        char *tty;
        if (PyArg_ParseTuple(args, "s", &tty))
                lapb_nl_init(tty);
        else {
                PyErr_SetString(PyExc_TypeError, "need string parameter");
                return NULL;
        }

        Py_INCREF(Py_None);
        return Py_None;
}

static PyObject *py_get_next_data(PyObject *self, PyObject *args)
{
        extern void get_next_data(void);
        NEEDS_NL();
        get_next_data();
        Py_INCREF(Py_None);
        return Py_None;
}
static PyObject *py_send_data(PyObject *self, PyObject *args)
{
        unsigned char *data = NULL;
        int size = 0;
        extern void send_data(unsigned char *data, int size);
        NEEDS_NL();
        if (PyArg_ParseTuple(args, "s#", &data, &size)) {
                if (data != NULL && size > 0)
                        send_data(data, size);
                else {
                        PyErr_SetString(PyExc_TypeError,
                                "Too little data during submit");
                        return NULL;
                }
        }
        Py_INCREF(Py_None);
        return Py_None;
}


static PyMethodDef LAPBMethods[] = {
        {"busyloop", busyloop, METH_VARARGS, "Run netlink busyloop"},
        {"cb", cb, METH_VARARGS, "Configure callback"},
        {"init", init, METH_VARARGS, "Init netlink"},
        {"send", py_send_data, METH_VARARGS, "Send data over netlink"},
        {"get_next_data", py_get_next_data, METH_VARARGS, "Get netlink data"},
        {NULL, NULL, 0, NULL},
};

PyMODINIT_FUNC initlapb(void)
{
        Py_InitModule("lapb", LAPBMethods);
}