The branch, master has been updated via ab379dd s4-ldb.python: Use $SELFTEST_PREFIX/tmp as a temporary directory for testing via 05c0bfa s4-ldb.python: add test for ldb.Message.from_dict() method via a403d77 s4-pyldb: ldb.Message.from_dict class method to create LdbMessage object from dictionary via a09a41f s4-pyldb: Move code to create a ldb_message from a Python Dictionary object into a separate function via c29a8c7 s4-samdb.py: Use ldb.get_default_basedn() to avoid RootDSE search via b4809e4 s4-pyldb_util: Move ldb Type searching into separate function via 88e4601 s4-pyldb: Few miss-alignments aligned via 72fcfed s4-pyldb: Move PyLdbMessage_FromMessage() in PyMessage group of functions via d42ea32 s4-pyldb: Fix wrong type of 'self' parameter from f992dbb s4-tests: Modified descriptor tests to use pyldb api to retrieve configuration and schema dn.
http://gitweb.samba.org/?p=samba.git;a=shortlog;h=master - Log ----------------------------------------------------------------- commit ab379ddd516bf2b77ccf77f542faf6e694ab5d4d Author: Kamen Mazdrashki <kame...@samba.org> Date: Thu Nov 18 21:42:26 2010 +0200 s4-ldb.python: Use $SELFTEST_PREFIX/tmp as a temporary directory for testing This way we won't flood /tmp directory with temp files Autobuild-User: Kamen Mazdrashki <kame...@samba.org> Autobuild-Date: Thu Nov 18 23:11:18 CET 2010 on sn-devel-104 commit 05c0bface19e8dfb395da82de6b889744768f8c6 Author: Kamen Mazdrashki <kame...@samba.org> Date: Thu Nov 18 17:46:33 2010 +0200 s4-ldb.python: add test for ldb.Message.from_dict() method commit a403d7777e94ffdcdb57045e8a4755aced0e8484 Author: Kamen Mazdrashki <kame...@samba.org> Date: Thu Nov 18 22:11:30 2010 +0200 s4-pyldb: ldb.Message.from_dict class method to create LdbMessage object from dictionary commit a09a41f300a4d721c117a95822d272cc5866ac92 Author: Kamen Mazdrashki <kame...@samba.org> Date: Thu Nov 18 22:09:01 2010 +0200 s4-pyldb: Move code to create a ldb_message from a Python Dictionary object into a separate function commit c29a8c7ec55b6961a51f52bf75671f7af8abf2df Author: Kamen Mazdrashki <kame...@samba.org> Date: Mon Nov 15 07:41:59 2010 +0200 s4-samdb.py: Use ldb.get_default_basedn() to avoid RootDSE search commit b4809e4a8240de5faa311bf55ade3d63fd376aa5 Author: Kamen Mazdrashki <kame...@samba.org> Date: Mon Nov 15 07:41:50 2010 +0200 s4-pyldb_util: Move ldb Type searching into separate function commit 88e460190014880d6e4a4eae063a773d9ff5a09c Author: Kamen Mazdrashki <kame...@samba.org> Date: Mon Nov 15 05:30:54 2010 +0200 s4-pyldb: Few miss-alignments aligned commit 72fcfedd89b3b8c41b527c4f25fdac518e20c8f2 Author: Kamen Mazdrashki <kame...@samba.org> Date: Mon Nov 15 04:53:05 2010 +0200 s4-pyldb: Move PyLdbMessage_FromMessage() in PyMessage group of functions commit d42ea3263af581bc3c533ad83b71710fa0b2fa39 Author: Kamen Mazdrashki <kame...@samba.org> Date: Mon Nov 15 04:20:31 2010 +0200 s4-pyldb: Fix wrong type of 'self' parameter ----------------------------------------------------------------------- Summary of changes: source4/lib/ldb/pyldb.c | 182 +++++++++++++++++++++---------- source4/lib/ldb/pyldb.h | 2 +- source4/lib/ldb/pyldb_util.c | 46 +++++--- source4/lib/ldb/tests/python/api.py | 24 ++++- source4/scripting/python/samba/samdb.py | 7 +- 5 files changed, 179 insertions(+), 82 deletions(-) Changeset truncated at 500 lines: diff --git a/source4/lib/ldb/pyldb.c b/source4/lib/ldb/pyldb.c index 1f5bd1e..d4b6300 100644 --- a/source4/lib/ldb/pyldb.c +++ b/source4/lib/ldb/pyldb.c @@ -48,8 +48,8 @@ static void PyErr_SetLdbError(PyObject *error, int ret, struct ldb_context *ldb_ return; /* Python exception should already be set, just keep that */ PyErr_SetObject(error, - Py_BuildValue(discard_const_p(char, "(i,s)"), ret, - ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx))); + Py_BuildValue(discard_const_p(char, "(i,s)"), ret, + ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx))); } static PyObject *PyExc_LdbError; @@ -64,8 +64,8 @@ PyAPI_DATA(PyTypeObject) PyLdbTree; static PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx); static PyObject *PyObject_FromLdbValue(struct ldb_context *ldb_ctx, - struct ldb_message_element *el, - struct ldb_val *val) + struct ldb_message_element *el, + struct ldb_val *val) { struct ldb_val new_val; TALLOC_CTX *mem_ctx = talloc_new(NULL); @@ -95,8 +95,7 @@ static PyObject *PyLdbResult_FromResult(struct ldb_result *result) } ret = PyList_New(result->count); for (i = 0; i < result->count; i++) { - PyList_SetItem(ret, i, PyLdbMessage_FromMessage(result->msgs[i]) - ); + PyList_SetItem(ret, i, PyLdbMessage_FromMessage(result->msgs[i])); } return ret; } @@ -110,7 +109,7 @@ static PyObject *PyLdbResult_FromResult(struct ldb_result *result) * @return a ldb_result, or NULL if the conversion failed */ static struct ldb_result *PyLdbResult_AsResult(TALLOC_CTX *mem_ctx, - PyObject *obj) + PyObject *obj) { struct ldb_result *res; Py_ssize_t i; @@ -490,7 +489,7 @@ static PyObject *py_ldb_get_default_basedn(PyLdbObject *self) } static const char **PyList_AsStringList(TALLOC_CTX *mem_ctx, PyObject *list, - const char *paramname) + const char *paramname) { const char **ret; Py_ssize_t i; @@ -506,7 +505,7 @@ static const char **PyList_AsStringList(TALLOC_CTX *mem_ctx, PyObject *list, return NULL; } ret[i] = talloc_strndup(ret, PyString_AsString(item), - PyString_Size(item)); + PyString_Size(item)); } ret[i] = NULL; return ret; @@ -682,21 +681,75 @@ static PyObject *py_ldb_modify(PyLdbObject *self, PyObject *args) } +/** + * Obtain a ldb message from a Python Dictionary object. + * + * @param mem_ctx Memory context + * @param py_obj Python Dictionary object + * @param ldb_ctx LDB context + * @param mod_flags Flags to be set on every message element + * @return ldb_message on success or NULL on failure + */ +static struct ldb_message *PyDict_AsMessage(TALLOC_CTX *mem_ctx, + PyObject *py_obj, + struct ldb_context *ldb_ctx, + unsigned int mod_flags) +{ + struct ldb_message *msg; + unsigned int msg_pos = 0; + Py_ssize_t dict_pos = 0; + PyObject *key, *value; + struct ldb_message_element *msg_el; + PyObject *dn_value = PyDict_GetItemString(py_obj, "dn"); + + msg = ldb_msg_new(mem_ctx); + msg->elements = talloc_zero_array(msg, struct ldb_message_element, PyDict_Size(py_obj)); + + if (dn_value) { + if (!PyObject_AsDn(msg, dn_value, ldb_ctx, &msg->dn)) { + PyErr_SetString(PyExc_TypeError, "unable to import dn object"); + return NULL; + } + if (msg->dn == NULL) { + PyErr_SetString(PyExc_TypeError, "dn set but not found"); + return NULL; + } + } else { + PyErr_SetString(PyExc_TypeError, "no dn set"); + return NULL; + } + + while (PyDict_Next(py_obj, &dict_pos, &key, &value)) { + char *key_str = PyString_AsString(key); + if (strcmp(key_str, "dn") != 0) { + msg_el = PyObject_AsMessageElement(msg->elements, value, + mod_flags, key_str); + if (msg_el == NULL) { + PyErr_SetString(PyExc_TypeError, "unable to import element"); + return NULL; + } + memcpy(&msg->elements[msg_pos], msg_el, sizeof(*msg_el)); + msg_pos++; + } + } + + msg->num_elements = msg_pos; + + return msg; +} + static PyObject *py_ldb_add(PyLdbObject *self, PyObject *args) { - PyObject *py_msg; + PyObject *py_obj; int ret; - Py_ssize_t dict_pos, msg_pos; - struct ldb_message_element *msgel; - struct ldb_message *msg; struct ldb_context *ldb_ctx; struct ldb_request *req; - PyObject *key, *value; + struct ldb_message *msg = NULL; PyObject *py_controls = Py_None; TALLOC_CTX *mem_ctx; struct ldb_control **parsed_controls; - if (!PyArg_ParseTuple(args, "O|O", &py_msg, &py_controls )) + if (!PyArg_ParseTuple(args, "O|O", &py_obj, &py_controls )) return NULL; mem_ctx = talloc_new(NULL); @@ -713,49 +766,22 @@ static PyObject *py_ldb_add(PyLdbObject *self, PyObject *args) parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls); talloc_free(controls); } - if (PyDict_Check(py_msg)) { - PyObject *dn_value = PyDict_GetItemString(py_msg, "dn"); - msg = ldb_msg_new(mem_ctx); - msg->elements = talloc_zero_array(msg, struct ldb_message_element, PyDict_Size(py_msg)); - msg_pos = dict_pos = 0; - if (dn_value) { - if (!PyObject_AsDn(msg, dn_value, ldb_ctx, &msg->dn)) { - PyErr_SetString(PyExc_TypeError, "unable to import dn object"); - talloc_free(mem_ctx); - return NULL; - } - if (msg->dn == NULL) { - PyErr_SetString(PyExc_TypeError, "dn set but not found"); - talloc_free(mem_ctx); - return NULL; - } - } - while (PyDict_Next(py_msg, &dict_pos, &key, &value)) { - char *key_str = PyString_AsString(key); - if (strcmp(key_str, "dn") != 0) { - msgel = PyObject_AsMessageElement(msg->elements, value, 0, key_str); - if (msgel == NULL) { - PyErr_SetString(PyExc_TypeError, "unable to import element"); - talloc_free(mem_ctx); - return NULL; - } - memcpy(&msg->elements[msg_pos], msgel, sizeof(*msgel)); - msg_pos++; - } - } - - if (msg->dn == NULL) { - PyErr_SetString(PyExc_TypeError, "no dn set"); - talloc_free(mem_ctx); - return NULL; - } - - msg->num_elements = msg_pos; + if (PyLdbMessage_Check(py_obj)) { + msg = PyLdbMessage_AsMessage(py_obj); + } else if (PyDict_Check(py_obj)) { + msg = PyDict_AsMessage(mem_ctx, py_obj, ldb_ctx, LDB_FLAG_MOD_ADD); } else { - msg = PyLdbMessage_AsMessage(py_msg); + PyErr_SetString(PyExc_TypeError, + "Dictionary or LdbMessage object expected!"); + } + + if (!msg) { + /* we should have a PyErr already set */ + talloc_free(mem_ctx); + return NULL; } - + ret = ldb_msg_sanity_check(ldb_ctx, msg); if (ret != LDB_SUCCESS) { PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx); @@ -994,7 +1020,7 @@ static PyObject *ldb_ldif_to_pyobject(struct ldb_ldif *ldif) } -static PyObject *py_ldb_write_ldif(PyLdbMessageObject *self, PyObject *args) +static PyObject *py_ldb_write_ldif(PyLdbObject *self, PyObject *args) { int changetype; PyObject *py_msg; @@ -1977,6 +2003,45 @@ PyTypeObject PyLdbMessageElement = { .tp_flags = Py_TPFLAGS_DEFAULT, }; + +static PyObject *py_ldb_msg_from_dict(PyTypeObject *type, PyObject *args) +{ + PyObject *py_ldb; + PyObject *py_dict; + PyObject *py_ret; + struct ldb_message *msg; + struct ldb_context *ldb_ctx; + unsigned int mod_flags = LDB_FLAG_MOD_REPLACE; + + if (!PyArg_ParseTuple(args, "O!O!|I", + &PyLdb, &py_ldb, &PyDict_Type, &py_dict, + &mod_flags)) { + return NULL; + } + + /* mask only flags we are going to use */ + mod_flags = LDB_FLAG_MOD_TYPE(mod_flags); + if (!mod_flags) { + PyErr_SetString(PyExc_ValueError, + "FLAG_MOD_ADD, FLAG_MOD_REPLACE or FLAG_MOD_DELETE" + " expected as mod_flag value"); + return NULL; + } + + ldb_ctx = PyLdb_AsLdbContext(py_ldb); + + msg = PyDict_AsMessage(ldb_ctx, py_dict, ldb_ctx, mod_flags); + if (!msg) { + return NULL; + } + + py_ret = PyLdbMessage_FromMessage(msg); + + talloc_unlink(ldb_ctx, msg); + + return py_ret; +} + static PyObject *py_ldb_msg_remove_attr(PyLdbMessageObject *self, PyObject *args) { char *name; @@ -2064,6 +2129,11 @@ static PyObject *py_ldb_msg_items(PyLdbMessageObject *self) } static PyMethodDef py_ldb_msg_methods[] = { + { "from_dict", (PyCFunction)py_ldb_msg_from_dict, METH_CLASS | METH_VARARGS, + "Message.from_dict(ldb, dict, mod_flag) -> ldb.Message\n" + "Class method to create ldb.Message object from Dictionary.\n" + "mod_flag is one of FLAG_MOD_ADD, FLAG_MOD_REPLACE or FLAG_MOD_DELETE.\n" + "mod_flag defaults to FLAG_MOD_REPLACE"}, { "keys", (PyCFunction)py_ldb_msg_keys, METH_NOARGS, NULL }, { "remove", (PyCFunction)py_ldb_msg_remove_attr, METH_VARARGS, NULL }, { "get", (PyCFunction)py_ldb_msg_get, METH_VARARGS, NULL }, diff --git a/source4/lib/ldb/pyldb.h b/source4/lib/ldb/pyldb.h index 545011e..1f4bdf7 100644 --- a/source4/lib/ldb/pyldb.h +++ b/source4/lib/ldb/pyldb.h @@ -54,6 +54,7 @@ typedef struct { TALLOC_CTX *mem_ctx; struct ldb_message *msg; } PyLdbMessageObject; +PyObject *PyLdbMessage_FromMessage(struct ldb_message *message); #define PyLdbMessage_Check(ob) PyObject_TypeCheck(ob, &PyLdbMessage) #define PyLdbMessage_AsMessage(pyobj) ((PyLdbMessageObject *)pyobj)->msg @@ -62,7 +63,6 @@ typedef struct { TALLOC_CTX *mem_ctx; struct ldb_module *mod; } PyLdbModuleObject; -PyObject *PyLdbMessage_FromMessage(struct ldb_message *message); PyObject *PyLdbModule_FromModule(struct ldb_module *mod); #define PyLdbModule_AsModule(pyobj) ((PyLdbModuleObject *)pyobj)->mod diff --git a/source4/lib/ldb/pyldb_util.c b/source4/lib/ldb/pyldb_util.c index 170c291..3e015d0 100644 --- a/source4/lib/ldb/pyldb_util.c +++ b/source4/lib/ldb/pyldb_util.c @@ -41,6 +41,26 @@ typedef intargfunc ssizeargfunc; #define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None #endif + +/** + * Find out PyTypeObject in ldb module for a given typename + */ +static PyTypeObject * PyLdb_GetPyType(const char *typename) +{ + PyObject *py_obj = NULL; + + if (ldb_module == NULL) { + ldb_module = PyImport_ImportModule("ldb"); + if (ldb_module == NULL) { + return NULL; + } + } + + py_obj = PyObject_GetAttrString(ldb_module, typename); + + return (PyTypeObject*)py_obj; +} + /** * Obtain a ldb DN from a Python object. * @@ -53,7 +73,7 @@ bool PyObject_AsDn(TALLOC_CTX *mem_ctx, PyObject *object, struct ldb_context *ldb_ctx, struct ldb_dn **dn) { struct ldb_dn *odn; - PyObject *PyLdb_Dn_Type; + PyTypeObject *PyLdb_Dn_Type; if (ldb_ctx != NULL && PyString_Check(object)) { odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object)); @@ -61,17 +81,12 @@ bool PyObject_AsDn(TALLOC_CTX *mem_ctx, PyObject *object, return true; } - if (ldb_module == NULL) { - ldb_module = PyImport_ImportModule("ldb"); - if (ldb_module == NULL) - return false; - } - - PyLdb_Dn_Type = PyObject_GetAttrString(ldb_module, "Dn"); - if (PyLdb_Dn_Type == NULL) + PyLdb_Dn_Type = PyLdb_GetPyType("Dn"); + if (PyLdb_Dn_Type == NULL) { return false; + } - if (PyObject_TypeCheck(object, (PyTypeObject *) PyLdb_Dn_Type)) { + if (PyObject_TypeCheck(object, PyLdb_Dn_Type)) { *dn = PyLdbDn_AsDn(object); return true; } @@ -89,15 +104,10 @@ PyObject *PyLdbDn_FromDn(struct ldb_dn *dn) Py_RETURN_NONE; } - if (ldb_module == NULL) { - ldb_module = PyImport_ImportModule("ldb"); - if (ldb_module == NULL) - return NULL; - } - - PyLdb_Dn_Type = (PyTypeObject *)PyObject_GetAttrString(ldb_module, "Dn"); - if (PyLdb_Dn_Type == NULL) + PyLdb_Dn_Type = PyLdb_GetPyType("Dn"); + if (PyLdb_Dn_Type == NULL) { return NULL; + } py_ret = (PyLdbDnObject *)PyLdb_Dn_Type->tp_alloc(PyLdb_Dn_Type, 0); if (py_ret == NULL) { diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index 3e43d4a..31d1319 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -9,7 +9,12 @@ import ldb def filename(): - return os.tempnam() + import tempfile + try: + dir_prefix = os.path.join(os.environ["SELFTEST_PREFIX"], "tmp") + except KeyError: + dir_prefix = None + return tempfile.mktemp(dir=dir_prefix) class NoContextTests(unittest.TestCase): @@ -532,6 +537,23 @@ class LdbMsgTests(unittest.TestCase): self.assertNotEquals(msg1, msg2) msg2['foo'] = 'blie' + def test_from_dict(self): + rec = {"dn": "dc=fromdict", + "a1": ["a1-val1", "a1-val1"]} + l = ldb.Ldb() + # check different types of input Flags + for flags in [ldb.FLAG_MOD_ADD, ldb.FLAG_MOD_REPLACE, ldb.FLAG_MOD_DELETE]: + m = ldb.Message.from_dict(l, rec, flags) + self.assertEquals(rec["a1"], list(m["a1"])) + self.assertEquals(flags, m["a1"].flags()) + # check input params + self.assertRaises(TypeError, ldb.Message.from_dict, dict(), rec, ldb.FLAG_MOD_REPLACE) + self.assertRaises(TypeError, ldb.Message.from_dict, l, list(), ldb.FLAG_MOD_REPLACE) + self.assertRaises(ValueError, ldb.Message.from_dict, l, rec, 0) + # Message.from_dict expects dictionary with 'dn' + err_rec = {"a1": ["a1-val1", "a1-val1"]} + self.assertRaises(TypeError, ldb.Message.from_dict, l, err_rec, ldb.FLAG_MOD_REPLACE) + class MessageElementTests(unittest.TestCase): diff --git a/source4/scripting/python/samba/samdb.py b/source4/scripting/python/samba/samdb.py index 38f018f..61d7c3e 100644 --- a/source4/scripting/python/samba/samdb.py +++ b/source4/scripting/python/samba/samdb.py @@ -68,12 +68,7 @@ class SamDB(samba.Ldb): return dsdb._am_rodc(self) def domain_dn(self): - res = self.search(base="", - scope=ldb.SCOPE_BASE, - expression="(defaultNamingContext=*)", - attrs=["defaultNamingContext"]) - assert(len(res) == 1 and res[0]["defaultNamingContext"] is not None) - return res[0]["defaultNamingContext"][0] + return str(self.get_default_basedn()) def enable_account(self, search_filter): """Enables an account -- Samba Shared Repository