libnetfilterqueue.c

#include <Python.h>
#include <structmember.h>

#include <string.h>
#include <sys/time.h>

#include <linux/netfilter.h>
#include <libnetfilter_queue/libnetfilter_queue.h>

// START: NetfilterQueueData

typedef struct {
 PyObject_HEAD
 struct nfq_data* data;
 PyIntObject* verdict;
 PyIntObject* mark;
} NetfilterQueueData;

static PyObject* NetfilterQueueData_new (PyTypeObject* type, PyTupleObject* args) {
 NetfilterQueueData* self;
 self = (NetfilterQueueData*) type->tp_alloc(type, 0);
 self->data = NULL;
 self->verdict = NULL;
 self->mark = NULL;
 return (PyObject*) self;
}

static int NetfilterQueueData_init (NetfilterQueueData* self, PyTupleObject* args) {
 return 0;
}

static void NetfilterQueueData_dealloc (NetfilterQueueData* self) {
 Py_TYPE(self)->tp_free((PyObject*) self);
}

static PyObject* NetfilterQueueData_get_packet_hw (NetfilterQueueData* self) {
 struct nfqnl_msg_packet_hw* msg_packet_hw = nfq_get_packet_hw(self->data);
 if (msg_packet_hw)
 return PyString_FromStringAndSize((char*) msg_packet_hw->hw_addr, 8);
 Py_RETURN_NONE;
}

static PyObject* NetfilterQueueData_get_nfmark (NetfilterQueueData* self) {
 return PyInt_FromLong((long) nfq_get_nfmark(self->data));
}

static PyObject* NetfilterQueueData_get_timestamp (NetfilterQueueData* self) {
 PyLongObject* tv_sec_object;
 PyLongObject* tv_usec_object;
 PyTupleObject* tv_object;
 struct timeval tv;
 if (nfq_get_timestamp(self->data, &tv)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_get_timestamp failed");
 return NULL;
 }
 tv_sec_object = (PyLongObject*) PyLong_FromLong((long) tv.tv_sec);
 tv_usec_object = (PyLongObject*) PyLong_FromLong((long) tv.tv_usec);
 tv_object = (PyTupleObject*) PyTuple_Pack(2, tv_sec_object, tv_usec_object);
 Py_DECREF(tv_sec_object);
 Py_DECREF(tv_usec_object);
 return (PyObject*) tv_object;
}

static PyObject* NetfilterQueueData_get_indev (NetfilterQueueData* self) {
 return PyInt_FromLong((long) nfq_get_indev(self->data));
}

static PyObject* NetfilterQueueData_get_physindev (NetfilterQueueData* self) {
 return PyInt_FromLong((long) nfq_get_physindev(self->data));
}

static PyObject* NetfilterQueueData_get_outdev (NetfilterQueueData* self) {
 return PyInt_FromLong((long) nfq_get_outdev(self->data));
}

static PyObject* NetfilterQueueData_get_physoutdev (NetfilterQueueData* self) {
 return PyInt_FromLong((long) nfq_get_physoutdev(self->data));
}

static PyObject* NetfilterQueueData_get_payload (NetfilterQueueData* self) {
 int length;
 char* data;
 length = nfq_get_payload(self->data, &data);
 if (length < 0) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_get_payload failed");
 return NULL;
 }
 return PyString_FromStringAndSize(data, length);
}

static PyObject* NetfilterQueueData_get_uid (NetfilterQueueData* self) {
 uint32_t uid;
 if (nfq_get_uid(self->data, &uid)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_get_uid failed");
 return NULL;
 }
 return PyInt_FromLong((long) uid);
}

static PyObject* NetfilterQueueData_get_gid (NetfilterQueueData* self) {
 uint32_t gid;
 if (nfq_get_gid(self->data, &gid)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_get_gid failed");
 return NULL;
 }
 return PyInt_FromLong((long) gid);
}

static PyObject* NetfilterQueueData_set_verdict (NetfilterQueueData* self, PyTupleObject* args, PyDictObject* kwargs) {
 static char* kwlist[] = {"verdict", "mark", NULL};
 PyObject* verdict;
 PyObject* mark = Py_None;
 if (!PyArg_ParseTupleAndKeywords((PyObject*) args, (PyObject*) kwargs, "O|O", kwlist, &verdict, &mark)) {
 PyErr_SetString(PyExc_ValueError, "Parameters must be (uint32_t verdict, uint32_t mask)");
 return NULL;
 }
 if (PyInt_Check(verdict)) {
 switch ((uint32_t) PyInt_AsUnsignedLongMask(verdict)) {
 case NF_DROP:
 case NF_ACCEPT:
 case NF_STOLEN:
 case NF_QUEUE:
 case NF_REPEAT:
 case NF_STOP:
 self->verdict = verdict;
 Py_INCREF(verdict);
 if (PyInt_Check(mark)) {
 self->mark = mark;
 Py_INCREF(mark);
 }
 Py_RETURN_NONE;
 }
 }
 PyErr_SetString(PyExc_ValueError, "Parameters must be either NF_DROP, NF_ACCEPT, NF_STOLEN, NF_QUEUE, NF_REPEAT, NF_STOP");
 return NULL;
}

static PyMemberDef NetfilterQueueData_members[] = {
 {NULL}
};

static PyMethodDef NetfilterQueueData_methods[] = {
 {"get_packet_hw", (PyCFunction) NetfilterQueueData_get_packet_hw, METH_NOARGS, NULL},
 {"get_nfmark", (PyCFunction) NetfilterQueueData_get_nfmark, METH_NOARGS, NULL},
 {"get_timestamp", (PyCFunction) NetfilterQueueData_get_timestamp, METH_NOARGS, NULL},
 {"get_indev", (PyCFunction) NetfilterQueueData_get_indev, METH_NOARGS, NULL},
 {"get_physindev", (PyCFunction) NetfilterQueueData_get_physindev, METH_NOARGS, NULL},
 {"get_outdev", (PyCFunction) NetfilterQueueData_get_outdev, METH_NOARGS, NULL},
 {"get_physoutdev", (PyCFunction) NetfilterQueueData_get_physoutdev, METH_NOARGS, NULL},
 {"get_payload", (PyCFunction) NetfilterQueueData_get_payload, METH_NOARGS, NULL},
 {"get_uid", (PyCFunction) NetfilterQueueData_get_uid, METH_NOARGS, NULL},
 {"get_gid", (PyCFunction) NetfilterQueueData_get_gid, METH_NOARGS, NULL},
 {"set_verdict", (PyCFunction) NetfilterQueueData_set_verdict, METH_VARARGS | METH_KEYWORDS, NULL},
 {NULL}
};

static PyTypeObject NetfilterQueueDataType = {
 PyVarObject_HEAD_INIT(NULL, 0)
 "libnetfilterqueue.NetfilterQueueData", /* tp_name */
 sizeof(NetfilterQueueData), /* tp_basicsize */
 0, /* tp_itemsize */
 (destructor) NetfilterQueueData_dealloc, /* tp_dealloc */
 0, /* tp_print */
 0, /* tp_getattr */
 0, /* tp_setattr */
 0, /* tp_compare */
 0, /* tp_repr */
 0, /* tp_as_number */
 0, /* tp_as_sequence */
 0, /* tp_as_mapping */
 0, /* tp_hash */
 0, /* tp_call */
 0, /* tp_str */
 0, /* tp_getattro */
 0, /* tp_setattro */
 0, /* tp_as_buffer */
 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 "Wrapper for (struct nfq_data *)", /* tp_doc */
 0, /* tp_traverse */
 0, /* tp_clear */
 0, /* tp_richcompare */
 0, /* tp_weaklistoffset */
 0, /* tp_iter */
 0, /* tp_iternext */
 NetfilterQueueData_methods, /* tp_methods */
 NetfilterQueueData_members, /* tp_members */
 0, /* tp_getset */
 0, /* tp_base */
 0, /* tp_dict */
 0, /* tp_descr_get */
 0, /* tp_descr_set */
 0, /* tp_dictoffset */
 (initproc) NetfilterQueueData_init, /* tp_init */
 0, /* tp_alloc */
 (newfunc) NetfilterQueueData_new, /* tp_new */
};

// END: NetfilterQueueData

// BEGIN: NetfilterQueueQueueHandle

typedef struct {
 PyObject_HEAD
 struct nfq_q_handle* queue;
 PyObject* callback;
} NetfilterQueueQueueHandle;

static PyObject* NetfilterQueueQueueHandle_new (PyTypeObject* type, PyTupleObject* args) {
 NetfilterQueueQueueHandle* self;
 self = (NetfilterQueueQueueHandle*) type->tp_alloc(type, 0);
 self->queue = NULL;
 self->callback = NULL;
 return (PyObject*) self;
}

static int NetfilterQueueQueueHandle_init (NetfilterQueueQueueHandle* self, PyTupleObject* args) {
 return 0;
}

static void NetfilterQueueQueueHandle_dealloc (NetfilterQueueQueueHandle* self) {
 Py_TYPE(self)->tp_free((PyObject*) self);
}

static int NetfilterQueueQueueHandle_callback (struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, struct nfq_data *nfa, void *data) {
 PyObject* args;
 NetfilterQueueQueueHandle* self;
 NetfilterQueueData* data_object;
 PyObject* result_object;
 struct nfqnl_msg_packet_hdr* packet_header;
 uint32_t packet_id;
 uint32_t verdict;
 uint32_t mark;

 self = (NetfilterQueueQueueHandle*) data;

 if (self->callback) {
 args = PyTuple_New(0);
 data_object = (NetfilterQueueData*) PyObject_CallObject((PyObject*) &NetfilterQueueDataType, args);
 Py_DECREF(args);

 data_object->data = nfa;

 args = PyTuple_Pack(1, data_object);
 result_object = PyObject_CallObject(self->callback, args);
 Py_DECREF(args);

 if (data_object->verdict) {
 verdict = PyInt_AsUnsignedLongMask(data_object->verdict);
 Py_DECREF(data_object->verdict);
 data_object->verdict = NULL;

 packet_header = nfq_get_msg_packet_hdr(nfa);
 packet_id = ntohl(packet_header->packet_id);

 if (data_object->mark) {
 mark = PyInt_AsUnsignedLongMask(data_object->mark);
 Py_DECREF(data_object->mark);
 data_object->mark = NULL;

 nfq_set_verdict2(self->queue, packet_id, verdict, mark, 0, NULL);
 Py_DECREF(data_object);

 if (PyErr_Occurred()) {
 PyErr_PrintEx(1);
 return -1;
 }

 Py_DECREF(result_object);
 return 0;
 }

 nfq_set_verdict(self->queue, packet_id, verdict, 0, NULL);
 Py_DECREF(data_object);

 if (PyErr_Occurred()) {
 PyErr_PrintEx(1);
 return -1;
 }

 Py_DECREF(result_object);
 return 0;
 }
 Py_DECREF(data_object);

 if (PyErr_Occurred()) {
 PyErr_PrintEx(1);
 return -1;
 }

 Py_DECREF(result_object);
 return 0;
 }
 return 0;
}

static PyObject* NetfilterQueueQueueHandle_set_mode (NetfilterQueueQueueHandle* self, PyTupleObject* args) {
 uint8_t mode;
 uint32_t range;
 if (!PyArg_ParseTuple((PyObject*) args, "bI", &mode, &range)) {
 PyErr_SetString(PyExc_ValueError, "Parameters must be (uint8_t mode, uint32_t range)");
 return NULL;
 }
 if (nfq_set_mode(self->queue, mode, range)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_set_mode failed");
 return NULL;
 }
 Py_RETURN_NONE;
}

static PyObject* NetfilterQueueQueueHandle_set_flags (NetfilterQueueQueueHandle* self, PyTupleObject* args) {
 uint32_t mask;
 uint32_t flags;
 if (!PyArg_ParseTuple((PyObject*) args, "II", &mask, &flags)) {
 PyErr_SetString(PyExc_ValueError, "Parameters must be (uint32_t mask, uint32_t flags)");
 return NULL;
 }
 if (nfq_set_queue_flags(self->queue, mask, flags)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_set_queue_flags failed");
 return NULL;
 }
 Py_RETURN_NONE;
}

static PyObject* NetfilterQueueQueueHandle_set_maxlen (NetfilterQueueQueueHandle* self, PyTupleObject* args) {
 uint32_t queuelen;
 if (!PyArg_ParseTuple((PyObject*) args, "I", &queuelen)) {
 PyErr_SetString(PyExc_ValueError, "Parameters must be (uint32_t queuelen)");
 return NULL;
 }
 if (nfq_set_queue_maxlen(self->queue, queuelen)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_set_queue_maxlen failed");
 return NULL;
 }
 Py_RETURN_NONE;
}

static PyObject* NetfilterQueueQueueHandle_destroy (NetfilterQueueQueueHandle* self) {
 if (self->queue == NULL) {
 PyErr_SetString(PyExc_ValueError, "Queue handle pointer not initialized");
 return NULL;
 }
 if (nfq_destroy_queue(self->queue)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_destroy_queue failed");
 return NULL;
 }
 self->queue = NULL;
 if (self->callback) {
 Py_DECREF(self->callback);
 self->callback = NULL;
 }
 Py_RETURN_NONE;
}

static PyMemberDef NetfilterQueueQueueHandle_members[] = {
 {NULL}
};

static PyMethodDef NetfilterQueueQueueHandle_methods[] = {
 {"set_mode", (PyCFunction) NetfilterQueueQueueHandle_set_mode, METH_VARARGS, NULL},
 {"set_flags", (PyCFunction) NetfilterQueueQueueHandle_set_flags, METH_VARARGS, NULL},
 {"set_maxlen", (PyCFunction) NetfilterQueueQueueHandle_set_maxlen, METH_VARARGS, NULL},
 {"destroy", (PyCFunction) NetfilterQueueQueueHandle_destroy, METH_NOARGS, NULL},
 {NULL}
};

static PyTypeObject NetfilterQueueQueueHandleType = {
 PyVarObject_HEAD_INIT(NULL, 0)
 "libnetfilterqueue.NetfilterQueueQueueHandle", /* tp_name */
 sizeof(NetfilterQueueQueueHandle), /* tp_basicsize */
 0, /* tp_itemsize */
 (destructor) NetfilterQueueQueueHandle_dealloc, /* tp_dealloc */
 0, /* tp_print */
 0, /* tp_getattr */
 0, /* tp_setattr */
 0, /* tp_compare */
 0, /* tp_repr */
 0, /* tp_as_number */
 0, /* tp_as_sequence */
 0, /* tp_as_mapping */
 0, /* tp_hash */
 0, /* tp_call */
 0, /* tp_str */
 0, /* tp_getattro */
 0, /* tp_setattro */
 0, /* tp_as_buffer */
 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 "Wrapper for (struct nfq_q_handle *)", /* tp_doc */
 0, /* tp_traverse */
 0, /* tp_clear */
 0, /* tp_richcompare */
 0, /* tp_weaklistoffset */
 0, /* tp_iter */
 0, /* tp_iternext */
 NetfilterQueueQueueHandle_methods, /* tp_methods */
 NetfilterQueueQueueHandle_members, /* tp_members */
 0, /* tp_getset */
 0, /* tp_base */
 0, /* tp_dict */
 0, /* tp_descr_get */
 0, /* tp_descr_set */
 0, /* tp_dictoffset */
 (initproc) NetfilterQueueQueueHandle_init, /* tp_init */
 0, /* tp_alloc */
 (newfunc) NetfilterQueueQueueHandle_new, /* tp_new */
};

// END: NetfilterQueueQueueHandle

// BEGIN: NetfilterQueueHandle

typedef struct {
 PyObject_HEAD
 struct nfq_handle* handle;
} NetfilterQueueHandle;

static PyObject* NetfilterQueueHandle_new (PyTypeObject* type, PyTupleObject* args) {
 NetfilterQueueHandle* self;
 self = (NetfilterQueueHandle*) type->tp_alloc(type, 0);
 self->handle = NULL;
 return (PyObject*) self;
}

static int NetfilterQueueHandle_init (NetfilterQueueHandle* self, PyTupleObject* args) {
 return 0;
}

static void NetfilterQueueHandle_dealloc (NetfilterQueueHandle* self) {
 Py_TYPE(self)->tp_free((PyObject*) self);
}

static PyObject* NetfilterQueueHandle_bind_pf (NetfilterQueueHandle* self, PyTupleObject* args) {
 uint16_t pf;
 if (!PyArg_ParseTuple((PyObject*) args, "H", &pf)) {
 PyErr_SetString(PyExc_ValueError, "Parameters must be (uint16_t pf)");
 return NULL;
 }
 if (nfq_bind_pf(self->handle, pf)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_bind_pf failed");
 return NULL;
 }
 Py_RETURN_NONE;
}

static PyObject* NetfilterQueueHandle_unbind_pf (NetfilterQueueHandle* self, PyTupleObject* args) {
 uint16_t pf;
 if (!PyArg_ParseTuple((PyObject*) args, "H", &pf)) {
 PyErr_SetString(PyExc_ValueError, "Parameters must be (uint16_t pf)");
 return NULL;
 }
 if (nfq_unbind_pf(self->handle, pf)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_unbind_pf failed");
 return NULL;
 }
 Py_RETURN_NONE;
}

static PyObject* NetfilterQueueHandle_create_queue (NetfilterQueueHandle* self, PyTupleObject* args) {
 PyObject* empty;
 NetfilterQueueQueueHandle* queue_object;
 struct nfq_q_handle* queue_struct;
 uint16_t num;
 PyObject* callback;
 if (!PyArg_ParseTuple((PyObject*) args, "HO", &num, &callback)) {
 PyErr_SetString(PyExc_ValueError, "Parameters must be (uint16_t num, function callback)");
 return NULL;
 }
 if (!PyCallable_Check(callback)) {
 PyErr_SetString(PyExc_ValueError, "Parameters must be (uint16_t num, function callback)");
 return NULL;
 }
 empty = PyTuple_New(0);
 queue_object = (NetfilterQueueQueueHandle*) PyObject_CallObject((PyObject*) &NetfilterQueueQueueHandleType, empty);
 Py_DECREF(empty);
 queue_object->callback = callback;
 Py_INCREF(callback);
 queue_struct = nfq_create_queue(self->handle, num, &NetfilterQueueQueueHandle_callback, queue_object);
 if (!queue_struct) {
 Py_DECREF(callback);
 queue_object->callback = NULL;
 Py_DECREF(queue_object);
 queue_object = NULL;
 PyErr_SetString(PyExc_OSError, "Call to nfq_create_queue failed");
 return NULL;
 }
 queue_object->queue = queue_struct;
 return (PyObject*) queue_object;
}

static PyObject* NetfilterQueueHandle_handle_packet (NetfilterQueueHandle* self, PyTupleObject* args) {
 char* data;
 int length;
 if (!PyArg_ParseTuple((PyObject*) args, "s#", &data, &length)) {
 PyErr_SetString(PyExc_ValueError, "Parameters must be (char* data)");
 return NULL;
 }
 nfq_handle_packet(self->handle, data, length);
 Py_RETURN_NONE;
}

static PyObject* NetfilterQueueHandle_fd (NetfilterQueueHandle* self) {
 return PyInt_FromLong(nfq_fd(self->handle));
}

static PyObject* NetfilterQueueHandle_close (NetfilterQueueHandle* self) {
 if (nfq_close(self->handle)) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_close failed");
 return NULL;
 }
 Py_RETURN_NONE;
}

static PyMemberDef NetfilterQueueHandle_members[] = {
 {NULL}
};

static PyMethodDef NetfilterQueueHandle_methods[] = {
 {"bind_pf", (PyCFunction) NetfilterQueueHandle_bind_pf, METH_VARARGS, NULL},
 {"unbind_pf", (PyCFunction) NetfilterQueueHandle_unbind_pf, METH_VARARGS, NULL},
 {"create_queue", (PyCFunction) NetfilterQueueHandle_create_queue, METH_VARARGS, NULL},
 {"handle_packet", (PyCFunction) NetfilterQueueHandle_handle_packet, METH_VARARGS, NULL},
 {"fd", (PyCFunction) NetfilterQueueHandle_fd, METH_NOARGS, NULL},
 {"close", (PyCFunction) NetfilterQueueHandle_close, METH_NOARGS, NULL},
 {NULL}
};

static PyTypeObject NetfilterQueueHandleType = {
 PyVarObject_HEAD_INIT(NULL, 0)
 "libnetfilterqueue.NetfilterQueueHandle", /* tp_name */
 sizeof(NetfilterQueueHandle), /* tp_basicsize */
 0, /* tp_itemsize */
 (destructor) NetfilterQueueHandle_dealloc, /* tp_dealloc */
 0, /* tp_print */
 0, /* tp_getattr */
 0, /* tp_setattr */
 0, /* tp_compare */
 0, /* tp_repr */
 0, /* tp_as_number */
 0, /* tp_as_sequence */
 0, /* tp_as_mapping */
 0, /* tp_hash */
 0, /* tp_call */
 0, /* tp_str */
 0, /* tp_getattro */
 0, /* tp_setattro */
 0, /* tp_as_buffer */
 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 "Wrapper for (struct nfq_handle *)", /* tp_doc */
 0, /* tp_traverse */
 0, /* tp_clear */
 0, /* tp_richcompare */
 0, /* tp_weaklistoffset */
 0, /* tp_iter */
 0, /* tp_iternext */
 NetfilterQueueHandle_methods, /* tp_methods */
 NetfilterQueueHandle_members, /* tp_members */
 0, /* tp_getset */
 0, /* tp_base */
 0, /* tp_dict */
 0, /* tp_descr_get */
 0, /* tp_descr_set */
 0, /* tp_dictoffset */
 (initproc) NetfilterQueueHandle_init, /* tp_init */
 0, /* tp_alloc */
 (newfunc) NetfilterQueueHandle_new, /* tp_new */
};

// END: NetfilterQueueHandle

static PyObject* libnetfilterqueue_open (PyObject *self) {
 PyObject* empty;
 NetfilterQueueHandle* handle_object;
 struct nfq_handle* handle_struct;
 handle_struct = nfq_open();
 if (!handle_struct) {
 PyErr_SetString(PyExc_OSError, "Call to nfq_open failed");
 return NULL;
 }
 empty = PyTuple_New(0);
 handle_object = (NetfilterQueueHandle*) PyObject_CallObject((PyObject*) &NetfilterQueueHandleType, empty);
 Py_DECREF(empty);
 handle_object->handle = handle_struct;
 return (PyObject*) handle_object;
}

static PyMethodDef libnetfilterqueue_methods[] = {
 {"open", (PyCFunction) libnetfilterqueue_open, METH_NOARGS, NULL},
 {NULL}
};

PyMODINIT_FUNC initlibnetfilterqueue (void) {
 PyObject* module;

 if (PyType_Ready(&NetfilterQueueDataType) < 0)
 return;
 if (PyType_Ready(&NetfilterQueueQueueHandleType) < 0)
 return;
 if (PyType_Ready(&NetfilterQueueHandleType) < 0)
 return;

 module = Py_InitModule("libnetfilterqueue", libnetfilterqueue_methods);
 if (module == NULL)
 return;

 Py_INCREF((PyObject*) &NetfilterQueueDataType);
 PyModule_AddObject(module, "NetfilterQueueData", (PyObject*) &NetfilterQueueDataType);

 Py_INCREF((PyObject*) &NetfilterQueueQueueHandleType);
 PyModule_AddObject(module, "NetfilterQueueQueueHandle", (PyObject*) &NetfilterQueueQueueHandleType);

 Py_INCREF((PyObject*) &NetfilterQueueHandleType);
 PyModule_AddObject(module, "NetfilterQueueHandle", (PyObject*) &NetfilterQueueHandleType);

 PyModule_AddIntConstant(module, "NFQNL_COPY_NONE", NFQNL_COPY_NONE);
 PyModule_AddIntConstant(module, "NFQNL_COPY_META", NFQNL_COPY_META);
 PyModule_AddIntConstant(module, "NFQNL_COPY_PACKET", NFQNL_COPY_PACKET);

 PyModule_AddIntConstant(module, "NFQA_CFG_F_FAIL_OPEN", NFQA_CFG_F_FAIL_OPEN);
 PyModule_AddIntConstant(module, "NFQA_CFG_F_CONNTRACK", NFQA_CFG_F_CONNTRACK);
 PyModule_AddIntConstant(module, "NFQA_CFG_F_GSO", NFQA_CFG_F_GSO);

 PyModule_AddIntConstant(module, "NF_DROP", NF_DROP);
 PyModule_AddIntConstant(module, "NF_ACCEPT", NF_ACCEPT);
 PyModule_AddIntConstant(module, "NF_STOLEN", NF_STOLEN);
 PyModule_AddIntConstant(module, "NF_QUEUE", NF_QUEUE);
 PyModule_AddIntConstant(module, "NF_REPEAT", NF_REPEAT);
 PyModule_AddIntConstant(module, "NF_STOP", NF_STOP);
}