From 341a00311680a440d7f979f06c34c70d86c9367a Mon Sep 17 00:00:00 2001 From: Bohuslav Kabrda Date: Fri, 12 Dec 2014 11:04:40 +0100 Subject: Python3 support in SSSD https://fedorahosted.org/sssd/ticket/2017 --- src/python/pyhbac.c | 117 +++++++++++++++++++++++++++---------------- src/python/pysss.c | 68 ++++++++++++++++++++----- src/python/pysss_murmur.c | 28 ++++++++++- src/python/pysss_nss_idmap.c | 62 ++++++++++++++++------- 4 files changed, 200 insertions(+), 75 deletions(-) (limited to 'src/python') diff --git a/src/python/pyhbac.c b/src/python/pyhbac.c index dd345a6eb..c46f7c6b3 100644 --- a/src/python/pyhbac.c +++ b/src/python/pyhbac.c @@ -78,7 +78,7 @@ get_utf8_string(PyObject *obj, const char *attrname) const char *a = attrname ? attrname : "attribute"; PyObject *obj_utf8 = NULL; - if (PyString_Check(obj)) { + if (PyBytes_Check(obj)) { obj_utf8 = obj; Py_INCREF(obj_utf8); /* Make sure we can DECREF later */ } else if (PyUnicode_Check(obj)) { @@ -143,7 +143,7 @@ sequence_as_string_list(PyObject *seq, const char *paramname) return NULL; } - ret[i] = py_strdup(PyString_AsString(utf_item)); + ret[i] = py_strdup(PyBytes_AsString(utf_item)); Py_DECREF(utf_item); if (!ret[i]) { Py_DECREF(item); @@ -172,9 +172,9 @@ verify_sequence(PyObject *seq, const char *attrname) static int pyobject_to_category(PyObject *o) { - int c; + long c; - c = PyInt_AsLong(o); + c = PYNUMBER_ASLONG(o); if (c == -1 && PyErr_Occurred()) { PyErr_Format(PyExc_TypeError, "Invalid type for category element - must be an int\n"); @@ -187,7 +187,7 @@ pyobject_to_category(PyObject *o) return c; } - PyErr_Format(PyExc_ValueError, "Invalid value %d for category\n", c); + PyErr_Format(PyExc_ValueError, "Invalid value %ld for category\n", c); return -1; } @@ -244,8 +244,11 @@ str_concat_sequence(PyObject *seq, const char *delim) item = PySequence_GetItem(seq, i); if (item == NULL) goto fail; +#ifdef IS_PY3K + part = PyUnicode_AsUTF8(item); +#else part = PyString_AsString(item); - if (part == NULL) goto fail; +#endif if (s) { s = py_strcat_realloc(s, delim); @@ -325,7 +328,7 @@ static void HbacRuleElement_dealloc(HbacRuleElement *self) { HbacRuleElement_clear(self); - self->ob_type->tp_free((PyObject*) self); + Py_TYPE(self)->tp_free((PyObject*) self); } static int @@ -380,7 +383,7 @@ HbacRuleElement_init(HbacRuleElement *self, PyObject *args, PyObject *kwargs) return -1; } } else { - tmp = PyInt_FromLong(HBAC_CATEGORY_NULL); + tmp = PYNUMBER_FROMLONG(HBAC_CATEGORY_NULL); if (!tmp) { return -1; } @@ -561,7 +564,7 @@ PyDoc_STRVAR(HbacRuleElement__doc__, "names and/or groups and/or category\n"); static PyTypeObject pyhbac_hbacrule_element_type = { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) .tp_name = sss_py_const_p(char, "pyhbac.HbacRuleElement"), .tp_basicsize = sizeof(HbacRuleElement), .tp_new = HbacRuleElement_new, @@ -699,7 +702,7 @@ static void HbacRule_dealloc(HbacRuleObject *self) { HbacRule_clear(self); - self->ob_type->tp_free((PyObject*) self); + Py_TYPE(self)->tp_free((PyObject*) self); } static int @@ -765,13 +768,13 @@ hbac_rule_set_enabled(HbacRuleObject *self, PyObject *enabled, void *closure) { CHECK_ATTRIBUTE_DELETE(enabled, "enabled"); - if (PyString_Check(enabled) || PyUnicode_Check(enabled)) { + if (PyBytes_Check(enabled) || PyUnicode_Check(enabled)) { PyObject *utf8_str; char *str; utf8_str = get_utf8_string(enabled, "enabled"); if (!utf8_str) return -1; - str = PyString_AsString(utf8_str); + str = PyBytes_AsString(utf8_str); if (!str) { Py_DECREF(utf8_str); return -1; @@ -794,8 +797,8 @@ hbac_rule_set_enabled(HbacRuleObject *self, PyObject *enabled, void *closure) } else if (PyBool_Check(enabled)) { self->enabled = (enabled == Py_True); return 0; - } else if (PyInt_Check(enabled)) { - switch(PyInt_AsLong(enabled)) { + } else if (PYNUMBER_CHECK(enabled)) { + switch(PYNUMBER_ASLONG(enabled)) { case 0: self->enabled = false; break; @@ -832,7 +835,7 @@ hbac_rule_set_name(HbacRuleObject *self, PyObject *name, void *closure) { CHECK_ATTRIBUTE_DELETE(name, "name"); - if (!PyString_Check(name) && !PyUnicode_Check(name)) { + if (!PyBytes_Check(name) && !PyUnicode_Check(name)) { PyErr_Format(PyExc_TypeError, "name must be a string or Unicode"); return -1; } @@ -847,7 +850,7 @@ hbac_rule_get_name(HbacRuleObject *self, void *closure) if (PyUnicode_Check(self->name)) { Py_INCREF(self->name); return self->name; - } else if (PyString_Check(self->name)) { + } else if (PyBytes_Check(self->name)) { return PyUnicode_FromEncodedObject(self->name, PYHBAC_ENCODING, PYHBAC_ENCODING_ERRORS); } @@ -953,7 +956,7 @@ py_hbac_rule_validate(HbacRuleObject *self, PyObject *args) attr <<= 1) { if (!(missing & attr)) continue; - py_attr = PyInt_FromLong(attr); + py_attr = PYNUMBER_FROMLONG(attr); if (!py_attr) { PyErr_NoMemory(); goto fail; @@ -1050,7 +1053,7 @@ PyDoc_STRVAR(HbacRuleObject__doc__, "and srchosts attributes.\n"); static PyTypeObject pyhbac_hbacrule_type = { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) .tp_name = sss_py_const_p(char, "pyhbac.HbacRule"), .tp_basicsize = sizeof(HbacRuleObject), .tp_new = HbacRule_new, @@ -1104,7 +1107,7 @@ HbacRule_to_native(HbacRuleObject *pyrule) return NULL; } - rule->name = py_strdup(PyString_AsString(utf_name)); + rule->name = py_strdup(PyBytes_AsString(utf_name)); Py_DECREF(utf_name); if (rule->name == NULL) { goto fail; @@ -1176,7 +1179,7 @@ static void HbacRequestElement_dealloc(HbacRequestElement *self) { HbacRequestElement_clear(self); - self->ob_type->tp_free((PyObject*) self); + Py_TYPE(self)->tp_free((PyObject*) self); } static int @@ -1235,7 +1238,7 @@ hbac_request_element_set_name(HbacRequestElement *self, { CHECK_ATTRIBUTE_DELETE(name, "name"); - if (!PyString_Check(name) && !PyUnicode_Check(name)) { + if (!PyBytes_Check(name) && !PyUnicode_Check(name)) { PyErr_Format(PyExc_TypeError, "name must be a string or Unicode"); return -1; } @@ -1250,7 +1253,7 @@ hbac_request_element_get_name(HbacRequestElement *self, void *closure) if (PyUnicode_Check(self->name)) { Py_INCREF(self->name); return self->name; - } else if (PyString_Check(self->name)) { + } else if (PyBytes_Check(self->name)) { return PyUnicode_FromEncodedObject(self->name, PYHBAC_ENCODING, PYHBAC_ENCODING_ERRORS); } @@ -1341,7 +1344,7 @@ PyDoc_STRVAR(HbacRequestElement__doc__, "groups\n"); static PyTypeObject pyhbac_hbacrequest_element_type = { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) .tp_name = sss_py_const_p(char, "pyhbac.HbacRequestElement"), .tp_basicsize = sizeof(HbacRequestElement), .tp_new = HbacRequestElement_new, @@ -1389,7 +1392,7 @@ HbacRequestElement_to_native(HbacRequestElement *pyel) return NULL; } - el->name = py_strdup(PyString_AsString(utf_name)); + el->name = py_strdup(PyBytes_AsString(utf_name)); Py_DECREF(utf_name); if (!el->name) { goto fail; @@ -1471,7 +1474,7 @@ static void HbacRequest_dealloc(HbacRequest *self) { HbacRequest_clear(self); - self->ob_type->tp_free((PyObject*) self); + Py_TYPE(self)->tp_free((PyObject*) self); } static int @@ -1613,7 +1616,7 @@ py_hbac_evaluate(HbacRequest *self, PyObject *args) } /* FALLTHROUGH */ case HBAC_EVAL_DENY: - ret = PyInt_FromLong(eres); + ret = PYNUMBER_FROMLONG(eres); break; case HBAC_EVAL_ERROR: set_hbac_exception(PyExc_HbacError, info); @@ -1766,7 +1769,7 @@ PyDoc_STRVAR(HbacRequest__doc__, "HbacRequest() -> new empty HBAC request"); static PyTypeObject pyhbac_hbacrequest_type = { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) .tp_name = sss_py_const_p(char, "pyhbac.HbacRequest"), .tp_basicsize = sizeof(HbacRequest), .tp_new = HbacRequest_new, @@ -1901,14 +1904,36 @@ PyDoc_STRVAR(HbacError__doc__, "the name of the rule that was being processed. Use hbac_error_string()\n" "to get the text representation of the HBAC error"); +#ifdef IS_PY3K +static struct PyModuleDef pyhbacdef = { + PyModuleDef_HEAD_INIT, + PYTHON_MODULE_NAME, + NULL, + -1, + pyhbac_module_methods, + NULL, + NULL, + NULL, + NULL +}; + +PyMODINIT_FUNC +PyInit_pyhbac(void) +#else PyMODINIT_FUNC initpyhbac(void) +#endif { PyObject *m; int ret; - m = Py_InitModule(sss_py_const_p(char, PYTHON_MODULE_NAME), pyhbac_module_methods); - if (m == NULL) return; +#ifdef IS_PY3K + m = PyModule_Create(&pyhbacdef); +#else + m = Py_InitModule(sss_py_const_p(char, PYTHON_MODULE_NAME), + pyhbac_module_methods); +#endif + if (m == NULL) MODINITERROR; /* The HBAC module exception */ PyExc_HbacError = sss_exception_with_doc( @@ -1917,46 +1942,50 @@ initpyhbac(void) PyExc_EnvironmentError, NULL); Py_INCREF(PyExc_HbacError); ret = PyModule_AddObject(m, sss_py_const_p(char, "HbacError"), PyExc_HbacError); - if (ret == -1) return; + if (ret == -1) MODINITERROR; /* HBAC rule categories */ ret = PyModule_AddIntMacro(m, HBAC_CATEGORY_NULL); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_CATEGORY_ALL); - if (ret == -1) return; + if (ret == -1) MODINITERROR; /* HBAC rule elements */ ret = PyModule_AddIntMacro(m, HBAC_RULE_ELEMENT_USERS); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_RULE_ELEMENT_SERVICES); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_RULE_ELEMENT_TARGETHOSTS); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_RULE_ELEMENT_SOURCEHOSTS); - if (ret == -1) return; + if (ret == -1) MODINITERROR; /* enum hbac_eval_result */ ret = PyModule_AddIntMacro(m, HBAC_EVAL_ALLOW); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_EVAL_DENY); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_EVAL_ERROR); - if (ret == -1) return; + if (ret == -1) MODINITERROR; /* enum hbac_error_code */ ret = PyModule_AddIntMacro(m, HBAC_ERROR_UNKNOWN); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_SUCCESS); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_ERROR_NOT_IMPLEMENTED); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_ERROR_OUT_OF_MEMORY); - if (ret == -1) return; + if (ret == -1) MODINITERROR; ret = PyModule_AddIntMacro(m, HBAC_ERROR_UNPARSEABLE_RULE); - if (ret == -1) return; + if (ret == -1) MODINITERROR; TYPE_READY(m, pyhbac_hbacrule_type, "HbacRule"); TYPE_READY(m, pyhbac_hbacrule_element_type, "HbacRuleElement"); TYPE_READY(m, pyhbac_hbacrequest_element_type, "HbacRequestElement"); TYPE_READY(m, pyhbac_hbacrequest_type, "HbacRequest"); + +#ifdef IS_PY3K + return m; +#endif } diff --git a/src/python/pysss.c b/src/python/pysss.c index 9e899f139..684ad72b1 100644 --- a/src/python/pysss.c +++ b/src/python/pysss.c @@ -43,13 +43,24 @@ static char **PyList_AsStringList(TALLOC_CTX *mem_ctx, PyObject *list, ret = talloc_array(mem_ctx, char *, PyList_Size(list)+1); for (i = 0; i < PyList_Size(list); i++) { + char *itemstr; + Py_ssize_t itemlen; PyObject *item = PyList_GetItem(list, i); +#ifdef IS_PY3K + if (!PyUnicode_Check(item)) { +#else if (!PyString_Check(item)) { +#endif PyErr_Format(PyExc_TypeError, "%s should be strings", paramname); return NULL; } - ret[i] = talloc_strndup(ret, PyString_AsString(item), - PyString_Size(item)); +#ifdef IS_PY3K + itemstr = PyUnicode_AsUTF8AndSize(item, &itemlen); +#else + itemstr = PyString_AsString(item); + itemlen = strlen(itemstr); +#endif + ret[i] = talloc_strndup(ret, itemstr, itemlen); } ret[i] = NULL; @@ -791,7 +802,13 @@ static PyObject *py_sss_getgrouplist(PyObject *self, PyObject *args) for (i = 0; i < ngroups; i++) { gr = getgrgid(groups[i]); if (gr) { - PyTuple_SetItem(groups_tuple, idx, PyString_FromString(gr->gr_name)); + PyTuple_SetItem(groups_tuple, idx, +#ifdef IS_PY3K + PyUnicode_FromString(gr->gr_name) +#else + PyString_FromString(gr->gr_name) +#endif + ); idx++; } } @@ -817,7 +834,7 @@ fail: static void PySssLocalObject_dealloc(PySssLocalObject *self) { talloc_free(self->mem_ctx); - self->ob_type->tp_free((PyObject*) self); + Py_TYPE(self)->tp_free((PyObject *)self); } /* @@ -909,9 +926,9 @@ static PyMethodDef sss_local_methods[] = { static PyMemberDef sss_local_members[] = { { discard_const_p(char, "lock"), T_INT, - offsetof(PySssLocalObject, lock), RO, NULL}, + offsetof(PySssLocalObject, lock), READONLY, NULL}, { discard_const_p(char, "unlock"), T_INT, - offsetof(PySssLocalObject, unlock), RO, NULL}, + offsetof(PySssLocalObject, unlock), READONLY, NULL}, {NULL, 0, 0, 0, NULL} /* Sentinel */ }; @@ -919,7 +936,7 @@ static PyMemberDef sss_local_members[] = { * sss.local object properties */ static PyTypeObject pysss_local_type = { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) .tp_name = sss_py_const_p(char, "sss.local"), .tp_basicsize = sizeof(PySssLocalObject), .tp_new = PySssLocalObject_new, @@ -1036,7 +1053,7 @@ fail: */ static void PySssPasswordObject_dealloc(PySssPasswordObject *self) { - self->ob_type->tp_free((PyObject*) self); + Py_TYPE(self)->tp_free((PyObject*) self); } /* @@ -1079,7 +1096,7 @@ static PyMethodDef sss_password_methods[] = { */ static PyMemberDef sss_password_members[] = { { discard_const_p(char, "AES_256"), T_INT, - offsetof(PySssPasswordObject, aes_256), RO, NULL}, + offsetof(PySssPasswordObject, aes_256), READONLY, NULL}, {NULL, 0, 0, 0, NULL} /* Sentinel */ }; @@ -1087,7 +1104,7 @@ static PyMemberDef sss_password_members[] = { * sss.password object properties */ static PyTypeObject pysss_password_type = { - PyObject_HEAD_INIT(NULL) + PyVarObject_HEAD_INIT(NULL, 0) .tp_name = sss_py_const_p(char, "sss.password"), .tp_basicsize = sizeof(PySssPasswordObject), .tp_new = PySssPasswordObject_new, @@ -1111,23 +1128,48 @@ static PyMethodDef module_methods[] = { /* * Module initialization */ +#ifdef IS_PY3K +static struct PyModuleDef pysssdef = { + PyModuleDef_HEAD_INIT, + "pysss", + NULL, + -1, + module_methods, + NULL, + NULL, + NULL, + NULL +}; + +PyMODINIT_FUNC +PyInit_pysss(void) +#else PyMODINIT_FUNC initpysss(void) +#endif { PyObject *m; if (PyType_Ready(&pysss_local_type) < 0) - return; + MODINITERROR; if (PyType_Ready(&pysss_password_type) < 0) - return; + MODINITERROR; +#ifdef IS_PY3K + m = PyModule_Create(&pysssdef); +#else m = Py_InitModule(discard_const_p(char, "pysss"), module_methods); +#endif if (m == NULL) - return; + MODINITERROR; Py_INCREF(&pysss_local_type); PyModule_AddObject(m, discard_const_p(char, "local"), (PyObject *)&pysss_local_type); Py_INCREF(&pysss_password_type); PyModule_AddObject(m, discard_const_p(char, "password"), (PyObject *)&pysss_password_type); + +#ifdef IS_PY3K + return m; +#endif } diff --git a/src/python/pysss_murmur.c b/src/python/pysss_murmur.c index a193c56da..97d752b2a 100644 --- a/src/python/pysss_murmur.c +++ b/src/python/pysss_murmur.c @@ -60,10 +60,36 @@ static PyMethodDef methods[] = { { NULL,NULL, 0, NULL } }; +#ifdef IS_PY3K +static struct PyModuleDef pysss_murmurdef = { + PyModuleDef_HEAD_INIT, + "pysss_murmur", + NULL, + -1, + methods, + NULL, + NULL, + NULL, + NULL +}; +PyMODINIT_FUNC +PyInit_pysss_murmur(void) +#else PyMODINIT_FUNC initpysss_murmur(void) +#endif { - Py_InitModule3(sss_py_const_p(char, "pysss_murmur"), + PyObject *m; +#ifdef IS_PY3K + m = PyModule_Create(&pysss_murmurdef); +#else + m = Py_InitModule3(sss_py_const_p(char, "pysss_murmur"), methods, sss_py_const_p(char, "murmur hash functions")); +#endif + if (m == NULL) + MODINITERROR; +#ifdef IS_PY3K + return m; +#endif } diff --git a/src/python/pysss_nss_idmap.c b/src/python/pysss_nss_idmap.c index 0870b0da6..36d66f405 100644 --- a/src/python/pysss_nss_idmap.c +++ b/src/python/pysss_nss_idmap.c @@ -53,7 +53,7 @@ static int add_dict(PyObject *py_result, PyObject *key, PyObject *res_type, return ret; } - ret = PyDict_SetItem(py_dict, PyString_FromString(SSS_TYPE_KEY), id_type); + ret = PyDict_SetItem(py_dict, PyBytes_FromString(SSS_TYPE_KEY), id_type); if (ret != 0) { Py_XDECREF(py_dict); return ret; @@ -70,14 +70,14 @@ static char *py_string_or_unicode_as_string(PyObject *inp) if (PyUnicode_Check(inp)) { py_str = PyUnicode_AsUTF8String(inp); - } else if (PyString_Check(inp)) { + } else if (PyBytes_Check(inp)) { py_str = inp; } else { PyErr_Format(PyExc_TypeError, "input must be unicode or a string"); return NULL; } - return PyString_AS_STRING(py_str); + return PyBytes_AS_STRING(py_str); } static int do_getsidbyname(PyObject *py_result, PyObject *py_name) @@ -94,8 +94,8 @@ static int do_getsidbyname(PyObject *py_result, PyObject *py_name) ret = sss_nss_getsidbyname(name, &sid, &id_type); if (ret == 0) { - ret = add_dict(py_result, py_name, PyString_FromString(SSS_SID_KEY), - PyUnicode_FromString(sid), PyInt_FromLong(id_type)); + ret = add_dict(py_result, py_name, PyBytes_FromString(SSS_SID_KEY), + PyUnicode_FromString(sid), PYNUMBER_FROMLONG(id_type)); } free(sid); @@ -116,8 +116,8 @@ static int do_getnamebysid(PyObject *py_result, PyObject *py_sid) ret = sss_nss_getnamebysid(sid, &name, &id_type); if (ret == 0) { - ret = add_dict(py_result, py_sid, PyString_FromString(SSS_NAME_KEY), - PyUnicode_FromString(name), PyInt_FromLong(id_type)); + ret = add_dict(py_result, py_sid, PyBytes_FromString(SSS_NAME_KEY), + PyUnicode_FromString(name), PYNUMBER_FROMLONG(id_type)); } free(name); @@ -133,9 +133,12 @@ static int do_getsidbyid(PyObject *py_result, PyObject *py_id) int ret; enum sss_id_type id_type; +#ifndef IS_PY3K if (PyInt_Check(py_id)) { id = PyInt_AS_LONG(py_id); - } else if (PyLong_Check(py_id)) { + } else +#endif + if (PyLong_Check(py_id)) { id = PyLong_AsLong(py_id); } else { id_str = py_string_or_unicode_as_string(py_id); @@ -155,8 +158,8 @@ static int do_getsidbyid(PyObject *py_result, PyObject *py_id) ret = sss_nss_getsidbyid((uint32_t) id, &sid, &id_type); if (ret == 0) { - ret = add_dict(py_result, py_id, PyString_FromString(SSS_SID_KEY), - PyUnicode_FromString(sid), PyInt_FromLong(id_type)); + ret = add_dict(py_result, py_id, PyBytes_FromString(SSS_SID_KEY), + PyUnicode_FromString(sid), PYNUMBER_FROMLONG(id_type)); } free(sid); @@ -177,8 +180,8 @@ static int do_getidbysid(PyObject *py_result, PyObject *py_sid) ret = sss_nss_getidbysid(sid, &id, &id_type); if (ret == 0) { - ret = add_dict(py_result, py_sid, PyString_FromString(SSS_ID_KEY), - PyInt_FromLong(id), PyInt_FromLong(id_type)); + ret = add_dict(py_result, py_sid, PyBytes_FromString(SSS_ID_KEY), + PYNUMBER_FROMLONG(id), PYNUMBER_FROMLONG(id_type)); } return ret; @@ -220,8 +223,8 @@ static PyObject *check_args(enum lookup_type type, PyObject *args) } if (!(PyList_Check(obj) || PyTuple_Check(obj) || - PyString_Check(obj) || PyUnicode_Check(obj) || - (type == SIDBYID && (PyInt_Check(obj) || PyLong_Check(obj))))) { + PyBytes_Check(obj) || PyUnicode_Check(obj) || + (type == SIDBYID && (PYNUMBER_CHECK(obj))))) { PyErr_Format(PyExc_ValueError, "Only string, long or list or tuples of them " \ "are accepted\n"); @@ -241,9 +244,8 @@ static PyObject *check_args(enum lookup_type type, PyObject *args) for(i=0; i < len; i++) { py_value = PySequence_GetItem(obj, i); if ((py_value != NULL) && - (PyString_Check(py_value) || PyUnicode_Check(py_value) || - (type == SIDBYID && - (PyInt_Check(py_value) || PyLong_Check(py_value))))) { + (PyBytes_Check(py_value) || PyUnicode_Check(py_value) || + (type == SIDBYID && PYNUMBER_CHECK(py_value)))) { ret = do_lookup(type, py_result, py_value); if (ret != 0) { /* Skip this name */ @@ -349,15 +351,37 @@ static PyMethodDef methods[] = { { NULL,NULL, 0, NULL } }; +#ifdef IS_PY3K +static struct PyModuleDef pysss_nss_idmap_def = { + PyModuleDef_HEAD_INIT, + "pysss_nss_idmap", + NULL, + -1, + methods, + NULL, + NULL, + NULL, + NULL +}; +PyMODINIT_FUNC +PyInit_pysss_nss_idmap(void) +#else PyMODINIT_FUNC initpysss_nss_idmap(void) +#endif { PyObject *module; +#ifdef IS_PY3K + module = PyModule_Create(&pysss_nss_idmap_def); +#else module = Py_InitModule3(sss_py_const_p(char, "pysss_nss_idmap"), methods, sss_py_const_p(char, "SSSD ID-mapping functions")); +#endif + if (module == NULL) + MODINITERROR; PyModule_AddIntConstant(module, "ID_NOT_SPECIFIED", SSS_ID_TYPE_NOT_SPECIFIED); @@ -369,4 +393,8 @@ initpysss_nss_idmap(void) PyModule_AddStringConstant(module, "NAME_KEY", SSS_NAME_KEY); PyModule_AddStringConstant(module, "ID_KEY", SSS_ID_KEY); PyModule_AddStringConstant(module, "TYPE_KEY", SSS_TYPE_KEY); + +#ifdef IS_PY3K + return module; +#endif } -- cgit