name : _nl80211module.c #define PY_SSIZE_T_CLEAN #include <Python.h> #include <ctype.h> #include <errno.h> #include <linux/genetlink.h> #include <linux/nl80211.h> #include <netlink/genl/ctrl.h> #include <netlink/genl/genl.h> #define NL_CB_me NL_CB_DEFAULT struct Listener { PyObject_HEAD PyObject *observer; struct nl_sock* event_sock; struct nl_sock* genl_sock; PyObject *exc_typ, *exc_val, *exc_tb; int err; int nl80211_id; }; static void listener_dealloc(PyObject *self) { struct Listener* v = (struct Listener*)self; PyObject_GC_UnTrack(v); Py_CLEAR(v->observer); Py_CLEAR(v->exc_typ); Py_CLEAR(v->exc_val); Py_CLEAR(v->exc_tb); nl_socket_free(v->event_sock); PyObject_GC_Del(v); } static int listener_traverse(PyObject *self, visitproc visit, void *arg) { struct Listener* v = (struct Listener*)self; Py_VISIT(v->observer); Py_VISIT(v->exc_typ); Py_VISIT(v->exc_val); Py_VISIT(v->exc_tb); return 0; } static PyTypeObject ListenerType; static int ack_handler(struct nl_msg *msg, void *arg) { int *err = arg; *err = 0; return NL_STOP; } static int finish_handler(struct nl_msg *msg, void *arg) { int *ret = arg; *ret = 0; return NL_SKIP; } static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg) { int *ret = arg; *ret = err->error; return NL_STOP; } static int no_seq_check(struct nl_msg *msg, void *arg) { return NL_OK; } struct nl80211_multicast_ids { int mlme_id; int scan_id; }; static int family_handler(struct nl_msg *msg, void *arg) { struct nl80211_multicast_ids *res = arg; struct nlattr *tb[CTRL_ATTR_MAX + 1]; struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg)); struct nlattr *mcgrp; int i; nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL); if (!tb[CTRL_ATTR_MCAST_GROUPS]) return NL_SKIP; nla_for_each_nested(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], i) { struct nlattr *tb2[CTRL_ATTR_MCAST_GRP_MAX + 1]; char *name; int len; nla_parse(tb2, CTRL_ATTR_MCAST_GRP_MAX, nla_data(mcgrp), nla_len(mcgrp), NULL); if (!tb2[CTRL_ATTR_MCAST_GRP_NAME] || !tb2[CTRL_ATTR_MCAST_GRP_ID]) { continue; } name = nla_data(tb2[CTRL_ATTR_MCAST_GRP_NAME]); len = nla_len(tb2[CTRL_ATTR_MCAST_GRP_NAME]); if (strncmp(name, "scan", len) == 0) { res->scan_id = nla_get_u32(tb2[CTRL_ATTR_MCAST_GRP_ID]); } if (strncmp(name, "mlme", len) == 0) { res->mlme_id = nla_get_u32(tb2[CTRL_ATTR_MCAST_GRP_ID]); } }; return NL_SKIP; } static int send_and_recv( struct nl_sock *sock, struct nl_msg *msg, int (*valid_handler)(struct nl_msg *, void *), void *valid_data) { struct nl_cb *cb; int err = -ENOMEM; cb = nl_cb_alloc(NL_CB_me); if (!cb) goto out; err = nl_send_auto(sock, msg); if (err < 0) goto out; err = 1; nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err); nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err); nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err); if (valid_handler) { nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, valid_data); } while (err > 0) { int res = nl_recvmsgs(sock, cb); if (res < 0 && err > 0) { err = res; } } out: nl_cb_put(cb); nlmsg_free(msg); return err; } static int nl_get_multicast_ids( struct nl_sock *genl_sock, struct nl80211_multicast_ids *res) { struct nl_msg *msg; int ret = -1; msg = nlmsg_alloc(); if (!msg) return -ENOMEM; genlmsg_put(msg, 0, 0, genl_ctrl_resolve(genl_sock, "nlctrl"), 0, 0, CTRL_CMD_GETFAMILY, 0); NLA_PUT_STRING(msg, CTRL_ATTR_FAMILY_NAME, "nl80211"); ret = send_and_recv(genl_sock, msg, family_handler, res); msg = NULL; nla_put_failure: nlmsg_free(msg); return ret; } static const char *nl80211_command_to_string(enum nl80211_commands cmd) { #define C2S(x) \ case x: \ return &#x[12] switch (cmd) { C2S(NL80211_CMD_UNSPEC); C2S(NL80211_CMD_GET_WIPHY); C2S(NL80211_CMD_SET_WIPHY); C2S(NL80211_CMD_NEW_WIPHY); C2S(NL80211_CMD_DEL_WIPHY); C2S(NL80211_CMD_GET_INTERFACE); C2S(NL80211_CMD_SET_INTERFACE); C2S(NL80211_CMD_NEW_INTERFACE); C2S(NL80211_CMD_DEL_INTERFACE); C2S(NL80211_CMD_GET_KEY); C2S(NL80211_CMD_SET_KEY); C2S(NL80211_CMD_NEW_KEY); C2S(NL80211_CMD_DEL_KEY); C2S(NL80211_CMD_GET_BEACON); C2S(NL80211_CMD_SET_BEACON); C2S(NL80211_CMD_START_AP); C2S(NL80211_CMD_STOP_AP); C2S(NL80211_CMD_GET_STATION); C2S(NL80211_CMD_SET_STATION); C2S(NL80211_CMD_NEW_STATION); C2S(NL80211_CMD_DEL_STATION); C2S(NL80211_CMD_GET_MPATH); C2S(NL80211_CMD_SET_MPATH); C2S(NL80211_CMD_NEW_MPATH); C2S(NL80211_CMD_DEL_MPATH); C2S(NL80211_CMD_SET_BSS); C2S(NL80211_CMD_SET_REG); C2S(NL80211_CMD_REQ_SET_REG); C2S(NL80211_CMD_GET_MESH_CONFIG); C2S(NL80211_CMD_SET_MESH_CONFIG); C2S(NL80211_CMD_SET_MGMT_EXTRA_IE); C2S(NL80211_CMD_GET_REG); C2S(NL80211_CMD_GET_SCAN); C2S(NL80211_CMD_TRIGGER_SCAN); C2S(NL80211_CMD_NEW_SCAN_RESULTS); C2S(NL80211_CMD_SCAN_ABORTED); C2S(NL80211_CMD_REG_CHANGE); C2S(NL80211_CMD_AUTHENTICATE); C2S(NL80211_CMD_ASSOCIATE); C2S(NL80211_CMD_DEAUTHENTICATE); C2S(NL80211_CMD_DISASSOCIATE); C2S(NL80211_CMD_MICHAEL_MIC_FAILURE); C2S(NL80211_CMD_REG_BEACON_HINT); C2S(NL80211_CMD_JOIN_IBSS); C2S(NL80211_CMD_LEAVE_IBSS); C2S(NL80211_CMD_TESTMODE); C2S(NL80211_CMD_CONNECT); C2S(NL80211_CMD_ROAM); C2S(NL80211_CMD_DISCONNECT); C2S(NL80211_CMD_SET_WIPHY_NETNS); C2S(NL80211_CMD_GET_SURVEY); C2S(NL80211_CMD_NEW_SURVEY_RESULTS); C2S(NL80211_CMD_SET_PMKSA); C2S(NL80211_CMD_DEL_PMKSA); C2S(NL80211_CMD_FLUSH_PMKSA); C2S(NL80211_CMD_REMAIN_ON_CHANNEL); C2S(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL); C2S(NL80211_CMD_SET_TX_BITRATE_MASK); C2S(NL80211_CMD_REGISTER_FRAME); C2S(NL80211_CMD_FRAME); C2S(NL80211_CMD_FRAME_TX_STATUS); C2S(NL80211_CMD_SET_POWER_SAVE); C2S(NL80211_CMD_GET_POWER_SAVE); C2S(NL80211_CMD_SET_CQM); C2S(NL80211_CMD_NOTIFY_CQM); C2S(NL80211_CMD_SET_CHANNEL); C2S(NL80211_CMD_SET_WDS_PEER); C2S(NL80211_CMD_FRAME_WAIT_CANCEL); C2S(NL80211_CMD_JOIN_MESH); C2S(NL80211_CMD_LEAVE_MESH); C2S(NL80211_CMD_UNPROT_DEAUTHENTICATE); C2S(NL80211_CMD_UNPROT_DISASSOCIATE); C2S(NL80211_CMD_NEW_PEER_CANDIDATE); C2S(NL80211_CMD_GET_WOWLAN); C2S(NL80211_CMD_SET_WOWLAN); C2S(NL80211_CMD_START_SCHED_SCAN); C2S(NL80211_CMD_STOP_SCHED_SCAN); C2S(NL80211_CMD_SCHED_SCAN_RESULTS); C2S(NL80211_CMD_SCHED_SCAN_STOPPED); C2S(NL80211_CMD_SET_REKEY_OFFLOAD); C2S(NL80211_CMD_PMKSA_CANDIDATE); C2S(NL80211_CMD_TDLS_OPER); C2S(NL80211_CMD_TDLS_MGMT); C2S(NL80211_CMD_UNEXPECTED_FRAME); C2S(NL80211_CMD_PROBE_CLIENT); C2S(NL80211_CMD_REGISTER_BEACONS); C2S(NL80211_CMD_UNEXPECTED_4ADDR_FRAME); C2S(NL80211_CMD_SET_NOACK_MAP); C2S(NL80211_CMD_CH_SWITCH_NOTIFY); C2S(NL80211_CMD_START_P2P_DEVICE); C2S(NL80211_CMD_STOP_P2P_DEVICE); C2S(NL80211_CMD_CONN_FAILED); C2S(NL80211_CMD_SET_MCAST_RATE); C2S(NL80211_CMD_SET_MAC_ACL); C2S(NL80211_CMD_RADAR_DETECT); C2S(NL80211_CMD_GET_PROTOCOL_FEATURES); C2S(NL80211_CMD_UPDATE_FT_IES); C2S(NL80211_CMD_FT_EVENT); C2S(NL80211_CMD_CRIT_PROTOCOL_START); C2S(NL80211_CMD_CRIT_PROTOCOL_STOP); C2S(NL80211_CMD_GET_COALESCE); C2S(NL80211_CMD_SET_COALESCE); C2S(NL80211_CMD_CHANNEL_SWITCH); C2S(NL80211_CMD_VENDOR); C2S(NL80211_CMD_SET_QOS_MAP); default: return "NL80211_CMD_UNKNOWN"; } #undef C2S } static int observe_wlan_event(struct Listener* listener, int ifindex, const char* cmd, PyObject* extra) { if (listener->exc_typ != NULL || listener->observer == Py_None) { return NL_STOP; } PyObject *arg = PyDict_New(); PyObject *ob = NULL; if (arg == NULL) { goto exit; } ob = PyUnicode_FromString(cmd); if (ob == NULL || PyDict_SetItemString(arg, "cmd", ob) < 0) { goto exit; } Py_DECREF(ob); ob = NULL; ob = PyLong_FromLong(ifindex); if (ob == NULL || PyDict_SetItemString(arg, "ifindex", ob) < 0) { goto exit; } Py_DECREF(ob); ob = NULL; if (extra != NULL) { PyDict_Update(arg, extra); } PyObject *r = PyObject_CallMethod(listener->observer, "wlan_event", "O", arg); Py_XDECREF(r); exit: Py_XDECREF(arg); Py_XDECREF(ob); if (PyErr_Occurred()) { PyErr_Fetch(&listener->exc_typ, &listener->exc_val, &listener->exc_tb); return NL_STOP; } return NL_SKIP; } static int nl80211_trigger_scan(struct Listener *listener, int ifidx) { struct nl_msg *msg = NULL; struct nl_msg *ssids = NULL; int r; struct nl_sock *genl_sock = nl_socket_alloc(); if (genl_sock == NULL) { r = -1; goto nla_put_failure; } r = genl_connect(genl_sock); if (r < 0) { goto nla_put_failure; } msg = nlmsg_alloc(); if (!msg) { goto nla_put_failure; } genlmsg_put(msg, 0, 0, listener->nl80211_id, 0, 0, NL80211_CMD_TRIGGER_SCAN, 0); NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifidx); ssids = nlmsg_alloc(); if (!ssids) { goto nla_put_failure; } NLA_PUT(ssids, 1, 0, ""); nla_put_nested(msg, NL80211_ATTR_SCAN_SSIDS, ssids); r = send_and_recv(genl_sock, msg, NULL, NULL); msg = NULL; nla_put_failure: nlmsg_free(msg); nlmsg_free(ssids); nl_socket_free(genl_sock); return r; } static char *nl80211_get_ie(char *ies, size_t ies_len, char ie) { char *end, *pos; if (ies == NULL) return NULL; pos = ies; end = ies + ies_len; while (pos + 1 < end) { if (pos + 2 + pos[1] > end) break; if (pos[0] == ie) return pos; pos += 2 + pos[1]; } return NULL; } struct scan_handler_params { PyObject* ssid_list; int only_connected; }; static void extract_ssid(struct nlattr *data, struct scan_handler_params *p) { struct nlattr *bss[NL80211_BSS_MAX + 1]; static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = { [NL80211_BSS_INFORMATION_ELEMENTS] = {}, [NL80211_BSS_STATUS] = {.type = NLA_U32}, [NL80211_BSS_BSSID] = {}, }; if (nla_parse_nested(bss, NL80211_BSS_MAX, data, bss_policy)) return; char *cstatus = "no status"; if (bss[NL80211_BSS_STATUS]) { int status = -1; status = nla_get_u32(bss[NL80211_BSS_STATUS]); switch (status) { case NL80211_BSS_STATUS_ASSOCIATED: cstatus = "Connected"; break; case NL80211_BSS_STATUS_AUTHENTICATED: cstatus = "Authenticated"; break; case NL80211_BSS_STATUS_IBSS_JOINED: cstatus = "Joined"; break; } } else if (p->only_connected) { return; } char *ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]); size_t ie_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]); char *ssid = nl80211_get_ie(ie, ie_len, 0); ssize_t ssid_len = (ssize_t)ssid[1]; PyObject* v = Py_BuildValue("(y#s)", ssid + 2, ssid_len, cstatus); if (v == NULL) { Py_CLEAR(p->ssid_list); return; } if (PyList_Append(p->ssid_list, v) < 0) { Py_CLEAR(p->ssid_list); } Py_DECREF(v); } static int nl80211_scan_handler(struct nl_msg *msg, void *arg) { struct scan_handler_params *p = (struct scan_handler_params *)arg; struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg)); struct nlattr *tb[NL80211_ATTR_MAX + 1]; int ifidx = -1; nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL); if (tb[NL80211_ATTR_IFINDEX]) { ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]); } if (ifidx < 0) { return NL_SKIP; } if (tb[NL80211_ATTR_BSS]) { extract_ssid(tb[NL80211_ATTR_BSS], p); } if (p->ssid_list == NULL) { return NL_STOP; } return NL_SKIP; } static PyObject* dump_scan_results(struct Listener* listener, int ifidx, int only_connected) { struct nl_msg *msg = NULL; struct scan_handler_params p = { .ssid_list = NULL }; p.only_connected = only_connected; struct nl_sock *genl_sock = nl_socket_alloc(); int r; if (genl_sock == NULL) { PyErr_SetString(PyExc_MemoryError, "nl_socket_alloc failed"); goto nla_put_failure; } r = genl_connect(genl_sock); if (r < 0) { PyErr_Format(PyExc_MemoryError, "genl_connect failed %d", r); goto nla_put_failure; } p.ssid_list = PyList_New(0); if (p.ssid_list == NULL) { goto nla_put_failure; } msg = nlmsg_alloc(); if (!msg) { goto nla_put_failure; } genlmsg_put(msg, 0, 0, listener->nl80211_id, 0, NLM_F_DUMP, NL80211_CMD_GET_SCAN, 0); NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifidx); send_and_recv(genl_sock, msg, nl80211_scan_handler, &p); msg = NULL; nla_put_failure: nlmsg_free(msg); nl_socket_free(genl_sock); return p.ssid_list; } static int event_handler(struct nl_msg *msg, void *arg) { struct Listener* listener = (struct Listener*)arg; struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg)); struct nlattr *tb[NL80211_ATTR_MAX + 1]; int ifidx = -1; PyObject* extra = NULL; int r; nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL); if (tb[NL80211_ATTR_IFINDEX]) { ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]); } if (ifidx > 0) { if (gnlh->cmd == NL80211_CMD_NEW_SCAN_RESULTS) { PyObject* ssids = dump_scan_results(listener, ifidx, 0); if (ssids == NULL) { return NL_STOP; } extra = Py_BuildValue("{sO}", "ssids", ssids); } if (gnlh->cmd == NL80211_CMD_ASSOCIATE || gnlh->cmd == NL80211_CMD_NEW_INTERFACE) { PyObject* ssids = dump_scan_results(listener, ifidx, 1); if (ssids == NULL) { return NL_STOP; } extra = Py_BuildValue("{sO}", "ssids", ssids); } } r = observe_wlan_event(listener, ifidx, nl80211_command_to_string(gnlh->cmd), extra); Py_XDECREF(extra); return r; } static PyObject * listener_new(PyTypeObject *type, PyObject *args, PyObject *kw) { struct nl_sock *event_sock, *genl_sock; struct nl_cb *event_cb; struct Listener* listener = (struct Listener*)type->tp_alloc(type, 0); event_cb = nl_cb_alloc(NL_CB_me); nl_cb_err(event_cb, NL_CB_CUSTOM, error_handler, &listener->err); nl_cb_set(event_cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &listener->err); nl_cb_set(event_cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &listener->err); nl_cb_set(event_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, &listener->err); nl_cb_set(event_cb, NL_CB_VALID, NL_CB_CUSTOM, event_handler, listener); event_sock = nl_socket_alloc_cb(event_cb); if (event_sock == NULL) { PyErr_SetString(PyExc_MemoryError, "nl_socket_alloc_cb"); return NULL; } genl_sock = nl_socket_alloc(); if (genl_sock == NULL) { nl_socket_free(event_sock); PyErr_SetString(PyExc_MemoryError, "nl_socket_alloc"); return NULL; } // XXX is this really needed? nl_socket_set_cb(genl_sock, nl_cb_alloc(NL_CB_me)); listener->event_sock = event_sock; listener->genl_sock = genl_sock; Py_INCREF(Py_None); listener->observer = Py_None; return (PyObject*)listener; } static int listener_init(PyObject *self, PyObject *args, PyObject *kw) { PyObject* observer; char *kwlist[] = {"observer", 0}; if (!PyArg_ParseTupleAndKeywords(args, kw, "O:listener", kwlist, &observer)) return -1; struct Listener* listener = (struct Listener*)self; Py_CLEAR(listener->observer); Py_INCREF(observer); listener->observer = observer; return 0; } static PyObject* maybe_restore(struct Listener* listener) { if (listener->exc_typ != NULL) { PyErr_Restore(listener->exc_typ, listener->exc_val, listener->exc_tb); listener->exc_typ = listener->exc_val = listener->exc_tb = NULL; return NULL; } if (listener->err != 0) { PyErr_Format(PyExc_RuntimeError, "random netlink error: %d", listener->err); } Py_RETURN_NONE; } static PyObject* listener_start(PyObject *self, PyObject* args) { int r; struct nl80211_multicast_ids ids; struct Listener* listener = (struct Listener*)self; r = genl_connect(listener->genl_sock); if (r < 0) { PyErr_Format(PyExc_RuntimeError, "genl_connect failed: %d", r); return NULL; } listener->nl80211_id = genl_ctrl_resolve(listener->genl_sock, "nl80211"); r = nl_get_multicast_ids(listener->genl_sock, &ids); if (r < 0) { PyErr_Format(PyExc_RuntimeError, "nl_get_multicast_ids failed: %d", r); return NULL; } r = genl_connect(listener->event_sock); if (r < 0) { PyErr_Format(PyExc_RuntimeError, "genl_connect failed: %d", r); return NULL; } r = nl_socket_set_nonblocking(listener->event_sock); if (r < 0) { PyErr_Format(PyExc_RuntimeError, "nl_socket_set_nonblocking failed: %d", r); return NULL; } r = nl_socket_add_memberships(listener->event_sock, ids.mlme_id, ids.scan_id, 0); if (r < 0) { PyErr_Format(PyExc_RuntimeError, "nl_socket_add_memberships: %d", r); return NULL; } // Request a dump of all wlan interfaces to get us started. struct nl_msg *msg; msg = nlmsg_alloc(); if (!msg) return NULL; genlmsg_put(msg, 0, 0, listener->nl80211_id, 0, NLM_F_DUMP, NL80211_CMD_GET_INTERFACE, 0); send_and_recv(listener->genl_sock, msg, event_handler, listener); return maybe_restore(listener); } static PyObject* listener_fileno(PyObject *self, PyObject* args) { struct Listener* listener = (struct Listener*)self; return PyLong_FromLong(nl_socket_get_fd(listener->event_sock)); } static PyObject* listener_data_ready(PyObject *self, PyObject* args) { struct Listener* listener = (struct Listener*)self; nl_recvmsgs_default(listener->event_sock); return maybe_restore(listener); } static PyObject* listener_trigger_scan(PyObject *self, PyObject* args, PyObject* kw) { struct Listener* listener = (struct Listener*)self; long ifindex; char *kwlist[] = {"ifindex", 0}; if (!PyArg_ParseTupleAndKeywords(args, kw, "i:listener", kwlist, &ifindex)) return NULL; int r = 0; r = nl80211_trigger_scan(listener, ifindex); if (r < 0) { PyErr_Format(PyExc_RuntimeError, "triggering scan failed %d\n", r); return NULL; } Py_RETURN_NONE; } static PyMethodDef ListenerMethods[] = { {"start", listener_start, METH_NOARGS, "XXX."}, {"fileno", listener_fileno, METH_NOARGS, "XXX."}, {"data_ready", listener_data_ready, METH_VARARGS, "XXX."}, {"trigger_scan", (PyCFunction)listener_trigger_scan, METH_VARARGS|METH_KEYWORDS, "XXX."}, {}, }; static PyTypeObject ListenerType = { .ob_base = PyVarObject_HEAD_INIT(&PyType_Type, 0) .tp_name = "_nl80211.listener", .tp_basicsize = sizeof(struct Listener), .tp_dealloc = listener_dealloc, .tp_new = listener_new, .tp_init = listener_init, .tp_traverse = listener_traverse, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_methods = ListenerMethods, }; static struct PyModuleDef nl80211_module = { PyModuleDef_HEAD_INIT, "_nl80211", }; PyMODINIT_FUNC PyInit__nl80211(void) { PyObject *m = PyModule_Create(&nl80211_module); if (m == NULL) return NULL; if (PyType_Ready(&ListenerType) < 0) return NULL; PyModule_AddObject(m, "listener", (PyObject *)&ListenerType); return m; }