diff options
Diffstat (limited to 'source4/lib/ldb')
| -rw-r--r-- | source4/lib/ldb/pyldb.c | 627 |
1 files changed, 337 insertions, 290 deletions
diff --git a/source4/lib/ldb/pyldb.c b/source4/lib/ldb/pyldb.c index 8d8cf1b529..e09b814ac3 100644 --- a/source4/lib/ldb/pyldb.c +++ b/source4/lib/ldb/pyldb.c @@ -170,6 +170,36 @@ static int py_ldb_dn_compare(PyLdbDnObject *dn1, PyLdbDnObject *dn2) return ldb_dn_compare(dn1->ptr, dn2->ptr); } +static PyObject *py_ldb_dn_get_parent(PyLdbDnObject *self) +{ + struct ldb_dn *dn = PyLdbDn_AsDn((PyObject *)self); + return PyLdbDn_FromDn(ldb_dn_get_parent(NULL, dn)); +} + +static PyObject *py_ldb_dn_add_child(PyLdbDnObject *self, PyObject *args) +{ + PyObject *py_other; + struct ldb_dn *other; + if (!PyArg_ParseTuple(args, "O", &other)) + return NULL; + + other = PyLdbDn_AsDn(py_other); + + return ldb_dn_add_child(PyLdbDn_AsDn((PyObject *)self), other)?Py_True:Py_False; +} + +static PyObject *py_ldb_dn_add_base(PyLdbDnObject *self, PyObject *args) +{ + PyObject *py_other; + struct ldb_dn *other; + if (!PyArg_ParseTuple(args, "O", &other)) + return NULL; + + other = PyLdbDn_AsDn(py_other); + + return ldb_dn_add_base(PyLdbDn_AsDn((PyObject *)self), other)?Py_True:Py_False; +} + static PyMethodDef py_ldb_dn_methods[] = { { "validate", (PyCFunction)py_ldb_dn_validate, METH_NOARGS, "S.validate() -> bool\n" @@ -193,16 +223,63 @@ static PyMethodDef py_ldb_dn_methods[] = { "Canonical version of this DN (like a posix path, with terminating newline)." }, { "check_special", (PyCFunction)py_ldb_dn_is_special, METH_VARARGS, NULL }, + { "parent", (PyCFunction)py_ldb_dn_get_parent, METH_NOARGS, + "S.parent() -> dn\n" + "Get the parent for this DN." }, + { "add_child", (PyCFunction)py_ldb_dn_add_child, METH_VARARGS, + "S.add_child(dn) -> None\n" + "Add a child DN to this DN." }, + { "add_base", (PyCFunction)py_ldb_dn_add_base, METH_VARARGS, + "S.add_base(dn) -> None\n" + "Add a base DN to this DN." }, { NULL } }; +static Py_ssize_t py_ldb_dn_len(PyLdbDnObject *self) +{ + return ldb_dn_get_comp_num(PyLdbDn_AsDn((PyObject *)self)); +} + +static PyObject *py_ldb_dn_concat(PyLdbDnObject *self, PyObject *py_other) +{ + struct ldb_dn *dn = PyLdbDn_AsDn((PyObject *)self), + *other = PyLdbDn_AsDn(py_other); + struct ldb_dn *ret = ldb_dn_copy(NULL, dn); + ldb_dn_add_child(ret, other); + return PyLdbDn_FromDn(ret); +} + +static PySequenceMethods py_ldb_dn_seq = { + .sq_length = (lenfunc)py_ldb_dn_len, + .sq_concat = (binaryfunc)py_ldb_dn_concat, +}; + +static PyObject *py_ldb_dn_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) +{ + struct ldb_dn *ret = ldb_dn_new(ldb_ctx, ldb_ctx, str); + /* ldb_dn_new() doesn't accept NULL as memory context, so + we do it this way... */ + talloc_steal(NULL, ret); + + if (ret == NULL || !ldb_dn_validate(ret)) { + PyErr_SetString(PyExc_ValueError, "unable to parse dn string"); + return NULL; + } + + return py_talloc_import(&PyLdbDn, ret); +} + PyTypeObject PyLdbDn = { .tp_name = "Dn", .tp_methods = py_ldb_dn_methods, .tp_str = (reprfunc)py_ldb_dn_get_linearized, .tp_repr = (reprfunc)py_ldb_dn_repr, .tp_compare = (cmpfunc)py_ldb_dn_compare, + .tp_as_sequence = &py_ldb_dn_seq, .tp_doc = "A LDB distinguished name.", + .tp_new = py_ldb_dn_new, + .tp_dealloc = py_talloc_dealloc, + .tp_basicsize = sizeof(PyLdbObject), }; /* Debug */ @@ -312,11 +389,38 @@ static PyObject *py_ldb_get_default_basedn(PyLdbObject *self) return PyLdbDn_FromDn(dn); } +static const char **PyList_AsStringList(TALLOC_CTX *mem_ctx, PyObject *list) +{ + const char **ret; + int i; + if (!PyList_Check(list)) { + PyErr_SetString(PyExc_TypeError, "options is not a list"); + return NULL; + } + ret = talloc_array(NULL, const char *, PyList_Size(list)); + for (i = 0; i < PyList_Size(list); i++) { + PyObject *item = PyList_GetItem(list, i); + if (!PyString_Check(item)) { + PyErr_SetString(PyExc_TypeError, "options should be strings"); + return NULL; + } + ret[i] = PyString_AsString(item); + } + return ret; +} + static PyObject *py_ldb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { struct ldb_context *ldb; - char *kwnames[] = { NULL }; - if (!PyArg_ParseTupleAndKeywords(args, kwargs, "", kwnames)) + const char *kwnames[] = { "url", "flags", "options", NULL }; + char *url = NULL; + PyObject *py_options = Py_None; + const char **options; + int flags = 0; + int ret; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ziO", (char **)kwnames, + &url, &flags, &py_options)) return NULL; ldb = ldb_init(NULL, event_context_init(NULL)); @@ -325,6 +429,21 @@ static PyObject *py_ldb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs return NULL; } + if (py_options == Py_None) { + options = NULL; + } else { + options = PyList_AsStringList(ldb, py_options); + if (options == NULL) + return NULL; + } + + if (url != NULL) { + ret = ldb_connect(ldb, url, flags, options); + PyErr_LDB_ERROR_IS_ERR_RAISE(ret, ldb); + } + + talloc_free(options); + return py_talloc_import(&PyLdb, ldb); } @@ -334,7 +453,6 @@ static PyObject *py_ldb_connect(PyLdbObject *self, PyObject *args, PyObject *kwa int flags; PyObject *py_options = Py_None; int ret; - int i; const char **options; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|iO", &url, &flags, &py_options)) @@ -343,13 +461,9 @@ static PyObject *py_ldb_connect(PyLdbObject *self, PyObject *args, PyObject *kwa if (py_options == Py_None) { options = NULL; } else { - if (!PyList_Check(py_options)) { - PyErr_SetString(PyExc_TypeError, "options is not a list"); + options = PyList_AsStringList(NULL, py_options); + if (options == NULL) return NULL; - } - options = talloc_array(NULL, const char *, PyList_Size(py_options)); - for (i = 0; i < PyList_Size(py_options); i++) - options[i] = PyString_AsString(PyList_GetItem(py_options, i)); } ret = ldb_connect(PyLdb_AsLdbContext(self), url, flags, options); @@ -574,6 +688,115 @@ static PyObject *py_ldb_schema_format_value(PyLdbObject *self, PyObject *args) return ret; } +static PyObject *py_ldb_search(PyLdbObject *self, PyObject *args, PyObject *kwargs) +{ + PyObject *py_base = Py_None; + enum ldb_scope scope = LDB_SCOPE_DEFAULT; + char *expr = NULL; + PyObject *py_attrs = Py_None; + PyObject *py_controls = Py_None; + const char *kwnames[] = { "base", "scope", "expression", "attrs", "controls", NULL }; + int ret; + struct ldb_result *res; + struct ldb_request *req; + const char **attrs; + struct ldb_context *ldb_ctx; + struct ldb_control **parsed_controls; + struct ldb_dn *base; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OisOO", (char **)kwnames, + &py_base, &scope, &expr, &py_attrs, &py_controls)) + return NULL; + + ldb_ctx = PyLdb_AsLdbContext(self); + + if (py_attrs == Py_None) { + attrs = NULL; + } else { + attrs = PyList_AsStringList(ldb_ctx, py_attrs); + if (attrs == NULL) + return NULL; + } + + if (py_base == Py_None) { + base = ldb_get_default_basedn(ldb_ctx); + } else { + base = PyLdbDn_AsDn(py_base); + if (base == NULL) + return NULL; + } + + if (py_controls == Py_None) { + parsed_controls = NULL; + } else { + const char **controls = PyList_AsStringList(mem_ctx, py_controls); + parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls); + talloc_free(controls); + } + + res = talloc_zero(mem_ctx, struct ldb_result); + if (!res) { + PyErr_NoMemory(); + return NULL; + } + + ret = ldb_build_search_req(&req, ldb_ctx, mem_ctx, + base, + scope, + expr, + attrs, + parsed_controls, + res, + ldb_search_default_callback, + NULL); + + if (ret != LDB_SUCCESS) { + talloc_free(res); + PyErr_LDB_ERROR_IS_ERR_RAISE(ret, ldb_ctx); + return NULL; + } + + ret = ldb_request(ldb_ctx, req); + + if (ret == LDB_SUCCESS) { + ret = ldb_wait(req->handle, LDB_WAIT_ALL); + } + + talloc_free(req); + + return PyLdbResult_FromResult(res); +} + +static PyObject *py_ldb_get_opaque(PyLdbObject *self, PyObject *args) +{ + char *name; + void *data; + + if (!PyArg_ParseTuple("s", &name)) + return NULL; + + data = ldb_get_opaque(PyLdb_AsLdbContext(self), name); + + /* FIXME: More interpretation */ + + return Py_None; +} + +static PyObject *py_ldb_set_opaque(PyLdbObject *self, PyObject *args) +{ + char *name; + PyObject *data; + + if (!PyArg_ParseTuple("sO", &name, &data)) + return NULL; + + /* FIXME: More interpretation */ + + ldb_set_opaque(PyLdb_AsLdbContext(self), name, data); + + return Py_None; +} + static PyMethodDef py_ldb_methods[] = { { "set_debug", (PyCFunction)py_ldb_set_debug, METH_VARARGS, "S.set_debug(callback) -> None\n" @@ -605,7 +828,7 @@ static PyMethodDef py_ldb_methods[] = { { "get_config_basedn", (PyCFunction)py_ldb_get_config_basedn, METH_NOARGS, NULL }, { "connect", (PyCFunction)py_ldb_connect, METH_VARARGS|METH_KEYWORDS, - "S.connect(url,flags=0,options=None) -> None\n" + "S.connect(url, flags=0, options=None) -> None\n" "Connect to a LDB URL." }, { "modify", (PyCFunction)py_ldb_modify, METH_VARARGS, "S.modify(message) -> None\n" @@ -619,6 +842,16 @@ static PyMethodDef py_ldb_methods[] = { { "rename", (PyCFunction)py_ldb_rename, METH_VARARGS, "S.rename(old_dn, new_dn) -> None\n" "Rename an entry." }, + { "search", (PyCFunction)py_ldb_search, METH_VARARGS|METH_KEYWORDS, + "Search in a database.\n" + "\n" + ":param base: Optional base DN to search\n" + ":param scope: Search scope (SCOPE_BASE, SCOPE_ONELEVEL or SCOPE_SUBTREE)\n" + ":param expression: Optional search expression\n" + ":param attrs: Attributes to return (defaults to all)\n" + ":param controls: Optional list of controls\n" + ":return: Iterator over Message objects\n" + }, { "schema_attribute_remove", (PyCFunction)py_ldb_schema_attribute_remove, METH_VARARGS, NULL }, { "schema_attribute_add", (PyCFunction)py_ldb_schema_attribute_add, METH_VARARGS, @@ -628,6 +861,15 @@ static PyMethodDef py_ldb_methods[] = { { "parse_ldif", (PyCFunction)py_ldb_parse_ldif, METH_VARARGS, "S.parse_ldif(ldif) -> iter(messages)\n" "Parse a string formatted using LDIF." }, + { "get_opaque", (PyCFunction)py_ldb_set_opaque, METH_VARARGS, + "S.get_opaque(name) -> value\n" + "Get an opaque value set on this LDB connection. \n" + ":note: The returned value may not be useful in Python." + }, + { "set_opaque", (PyCFunction)py_ldb_get_opaque, METH_VARARGS, + "S.set_opaque(name, value) -> None\n" + "Set an opaque value on this LDB connection. \n" + ":note: Passing incorrect values may cause crashes." }, { NULL }, }; @@ -646,6 +888,27 @@ static PyGetSetDef py_ldb_getset[] = { { NULL } }; +static int py_ldb_contains(PyLdbObject *self, PyObject *obj) +{ + struct ldb_context *ldb_ctx = PyLdb_AsLdbContext(self); + struct ldb_dn *dn = PyLdbDn_AsDn(obj); + struct ldb_result *result; + int ret; + int count; + ret = ldb_search(ldb_ctx, ldb_ctx, &result, dn, LDB_SCOPE_BASE, NULL, NULL); + PyErr_LDB_ERROR_IS_ERR_RAISE(ret, ldb_ctx); + + count = result->count; + + talloc_free(result); + + return count; +} + +static PySequenceMethods py_ldb_seq = { + .sq_contains = (objobjproc)py_ldb_contains, +}; + PyTypeObject PyLdb = { .tp_name = "Ldb", .tp_methods = py_ldb_methods, @@ -655,6 +918,7 @@ PyTypeObject PyLdb = { .tp_getset = py_ldb_getset, .tp_basicsize = sizeof(PyLdbObject), .tp_doc = "Connection to a LDB database.", + .tp_as_sequence = &py_ldb_seq, }; static PyObject *py_ldb_module_repr(PyLdbModuleObject *self) @@ -701,7 +965,11 @@ static PyObject *py_ldb_module_search(PyLdbModuleObject *self, PyObject *args, P req->op.search.base = PyLdbDn_AsDn(py_base); req->op.search.scope = scope; req->op.search.tree = PyLdbTree_AsTree(py_tree); - req->op.search.attrs = attrs; + if (py_attrs == Py_None) { + req->op.search.attrs = NULL; + } else { + req->op.search.attrs = PyList_AsStringList(req, py_attrs); + } req->op.search.res = talloc_zero(NULL, struct ldb_result); @@ -883,11 +1151,34 @@ static PyMethodDef py_ldb_msg_element_methods[] = { { NULL }, }; +static Py_ssize_t py_ldb_msg_element_len(PyLdbMessageElementObject *self) +{ + return PyLdbMessageElement_AsMessageElement(self)->num_values; +} + +static PySequenceMethods py_ldb_msg_element_seq = { + .sq_length = (lenfunc)py_ldb_msg_element_len, +}; + +static int py_ldb_msg_element_cmp(PyLdbMessageElementObject *self, PyLdbMessageElementObject *other) +{ + return ldb_msg_element_compare(PyLdbMessageElement_AsMessageElement(self), + PyLdbMessageElement_AsMessageElement(other)); +} + +static PyObject *py_ldb_msg_element_iter(PyLdbMessageElement *self) +{ + return PyObject_GetIter(ldb_msg_element_to_set(NULL, PyLdbMessageElement_AsMessageElement(self))); +} + PyTypeObject PyLdbMessageElement = { .tp_name = "MessageElement", .tp_basicsize = sizeof(PyLdbMessageElementObject), .tp_dealloc = py_talloc_dealloc, .tp_methods = py_ldb_msg_element_methods, + .tp_compare = (cmpfunc)py_ldb_msg_element_cmp, + .tp_iter = py_ldb_msg_element_iter, + .tp_as_sequence = &py_ldb_msg_element_seq, }; static PyObject *py_ldb_msg_remove_attr(PyLdbMessageObject *self, PyObject *args) @@ -901,7 +1192,24 @@ static PyObject *py_ldb_msg_remove_attr(PyLdbMessageObject *self, PyObject *args return Py_None; } +static PyObject *py_ldb_msg_keys(PyLdbMessageObject *self) +{ + struct ldb_message *msg = PyLdbMessage_AsMessage(self); + int i, j = 0; + PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0)); + if (msg->dn != NULL) { + PyList_SetItem(obj, j, PyString_FromString("dn")); + j++; + } + for (i = 0; i < msg->num_elements; i++) { + PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name)); + j++; + } + return obj; +} + static PyMethodDef py_ldb_msg_methods[] = { + { "keys", (PyCFunction)py_ldb_msg_keys, METH_NOARGS, NULL }, { "remove", (PyCFunction)py_ldb_msg_remove_attr, METH_VARARGS, NULL }, { NULL }, }; @@ -925,7 +1233,13 @@ static PyObject *py_ldb_msg_setitem(PyLdbMessageObject *self, PyObject *name, Py return Py_None; } +static Py_ssize_t py_ldb_msg_length(PyLdbMessageObject *self) +{ + return PyLdbMessage_AsMessage(self)->num_elements; +} + static PyMappingMethods py_ldb_msg_mapping = { + .mp_length = (lenfunc)py_ldb_msg_length, .mp_subscript = (binaryfunc)py_ldb_msg_getitem, .mp_ass_subscript = (objobjargproc)py_ldb_msg_setitem, }; @@ -1324,139 +1638,28 @@ void initldb(void) PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL); PyModule_AddObject(m, "LdbError", PyExc_LdbError); -} - -#if 0 - -/* - * Wrap struct ldb_val - */ - -%typemap(in,noblock=1) struct ldb_val *INPUT (struct ldb_val temp) { - $1 = &temp; - if (!PyString_Check($input)) { - PyErr_SetString(PyExc_TypeError, "string arg expected"); - return NULL; - } - $1->length = PyString_Size($input); - $1->data = PyString_AsString($input); -} - -%inline %{ - - -%} - -%typemap(out,noblock=1) struct ldb_val * { - $result = PyString_FromStringAndSize((const char *)$1->data, $1->length) -} - -%typemap(out,noblock=1) struct ldb_val { - $result = PyString_FromStringAndSize((const char *)$1.data, $1.length) -} - -/* - * Wrap struct ldb_result - */ - -%typemap(in,noblock=1,numinputs=0) struct ldb_result ** (struct ldb_result *temp_ldb_result) { - $1 = &temp_ldb_result; -} - -%typemap(in,noblock=1,numinputs=1) const char * const *NULL_STR_LIST { - if ($input == Py_None) { - $1 = NULL; - } else if (PySequence_Check($input)) { - int i; - $1 = talloc_array(NULL, char *, PySequence_Size($input)+1); - for(i = 0; i < PySequence_Size($input); i++) - $1[i] = PyString_AsString(PySequence_GetItem($input, i)); - $1[i] = NULL; - } else { - SWIG_exception(SWIG_TypeError, "expected sequence"); - } -} -%typemap(freearg,noblock=1) const char * const *NULL_STR_LIST { - talloc_free($1); -} - -%apply const char * const *NULL_STR_LIST { const char * const *attrs } -%apply const char * const *NULL_STR_LIST { const char * const *options } -%apply const char * const *NULL_STR_LIST { const char * const *control_strings } - -/* - * Wrap struct ldb_dn - */ - -%rename(__len__) ldb_dn::get_comp_num; -typedef struct ldb_dn { - %extend { - %feature("docstring") ldb_dn "S.__init__(ldb, string)\n" \ - "Create a new DN."; - ldb_dn(ldb *ldb_ctx, const char *str) - { - ldb_dn *ret = ldb_dn_new(ldb_ctx, ldb_ctx, str); - /* ldb_dn_new() doesn't accept NULL as memory context, so - we do it this way... */ - talloc_steal(NULL, ret); - - if (ret == NULL || !ldb_dn_validate(ret)) - SWIG_exception(SWIG_ValueError, - "unable to parse dn string"); -fail: - return ret; - } - ~ldb_dn() { talloc_free($self); } - %feature("docstring") parent "S.parent() -> dn\n" \ - "Get the parent for this DN."; - ldb_dn *parent() { return ldb_dn_get_parent(NULL, $self); } - int get_comp_num(); - %feature("docstring") add_child "S.add_child(dn) -> None\n" \ - "Add a child DN to this DN."; - bool add_child(ldb_dn *child); - %feature("docstring") add_base "S.add_base(dn) -> None\n" \ - "Add a base DN to this DN."; - bool add_base(ldb_dn *base); - ldb_dn *__add__(ldb_dn *other) - { - ldb_dn *ret = ldb_dn_copy(NULL, $self); - ldb_dn_add_child(ret, other); - return ret; - } - - /* FIXME: implement __getslice__ */ - } -} ldb_dn; + Py_INCREF(&PyLdb); + Py_INCREF(&PyLdbDn); + Py_INCREF(&PyLdbModule); + Py_INCREF(&PyLdbMessage); + Py_INCREF(&PyLdbMessageElement); -%{ -struct ldb_context *ldb_context_from_py_object(PyObject *py_obj) -{ - struct ldb_context *ldb_ctx; - if (SWIG_ConvertPtr(py_obj, (void *)&ldb_ctx, SWIGTYPE_p_ldb_context, 0 | 0 ) < 0) - return NULL; - return ldb_ctx; + PyModule_AddObject(m, "Ldb", (PyObject *)&PyLdb); + PyModule_AddObject(m, "Dn", (PyObject *)&PyLdbDn); + PyModule_AddObject(m, "Message", (PyObject *)&PyLdbMessage); + PyModule_AddObject(m, "MessageElement", (PyObject *)&PyLdbMessageElement); + PyModule_AddObject(m, "Module", (PyObject *)&PyLdbModule); } - -%} +#if 0 /* ldb_message_element */ %rename(MessageElement) ldb_message_element; %feature("docstring") ldb_message_element "Message element."; typedef struct ldb_message_element { %extend { - int __cmp__(ldb_message_element *other) - { - return ldb_msg_element_compare($self, other); - } - - PyObject *__iter__(void) - { - return PyObject_GetIter(ldb_msg_element_to_set(NULL, $self)); - } - - PyObject *__set__(void) + PyObject *__set__(void) { return ldb_msg_element_to_set(NULL, $self); } @@ -1466,11 +1669,6 @@ typedef struct ldb_message_element { return PyObject_AsMessageElement(NULL, set_obj, flags, name); } - int __len__() - { - return $self->num_values; - } - ~ldb_message_element() { talloc_free($self); } } %pythoncode { def __getitem__(self, i): @@ -1499,31 +1697,6 @@ typedef struct ldb_message_element { %feature("docstring") ldb_message "Message."; %rename(Message) ldb_message; -%rename(__delitem__) ldb_message::remove_attr; -%typemap(out) ldb_message_element * { - if ($1 == NULL) - PyErr_SetString(PyExc_KeyError, "no such element"); - else - $result = SWIG_NewPointerObj($1, SWIGTYPE_p_ldb_message_element, 0); -} - -%inline { - PyObject *ldb_msg_list_elements(ldb_msg *msg) - { - int i, j = 0; - PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0)); - if (msg->dn != NULL) { - PyList_SetItem(obj, j, PyString_FromString("dn")); - j++; - } - for (i = 0; i < msg->num_elements; i++) { - PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name)); - j++; - } - return obj; - } -} - typedef struct ldb_message { ldb_dn *dn; @@ -1533,7 +1706,6 @@ typedef struct ldb_message { ret->dn = talloc_reference(ret, dn); return ret; } - ~ldb_msg() { talloc_free($self); } void __setitem__(const char *attr_name, ldb_message_element *val) { @@ -1558,13 +1730,6 @@ typedef struct ldb_message { ldb_msg_add($self, el, el->flags); } - unsigned int __len__() { return $self->num_elements; } - - PyObject *keys(void) - { - return ldb_msg_list_elements($self); - } - PyObject *__iter__(void) { return PyObject_GetIter(ldb_msg_list_elements($self)); @@ -1575,12 +1740,6 @@ typedef struct ldb_message { return self.dn return self.find_element(key) - def __getitem__(self, key): - ret = self.get(key, None) - if ret is None: - raise KeyError("No such element") - return ret - def iteritems(self): for k in self.keys(): yield k, self[k] @@ -1594,24 +1753,6 @@ typedef struct ldb_message { } } ldb_msg; -/* FIXME: Convert ldb_result to 3-tuple: - (msgs, refs, controls) - */ - -typedef struct ldb_ldif ldb_ldif; - -%inline { -} - -%typemap(out,noblock=1) struct ldb_control ** { - if ($1 == NULL) { - PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(s)", ldb_errstring(arg1))); - SWIG_fail; - } - $result = SWIG_NewPointerObj($1, $1_descriptor, 0); -} - -/* Top-level ldb operations */ typedef struct ldb_context { %pythoncode { def itermodules(self): @@ -1623,99 +1764,5 @@ typedef struct ldb_context { def modules(self): return list(self.itermodules()) } - - %extend { - ldb_error search_ex(TALLOC_CTX *mem_ctx, - ldb_dn *base = NULL, - enum ldb_scope scope = LDB_SCOPE_DEFAULT, - const char *expression = NULL, - const char *const *attrs = NULL, - struct ldb_control **controls = NULL, - struct ldb_result **OUT) { - int ret; - struct ldb_result *res; - struct ldb_request *req; - res = talloc_zero(mem_ctx, struct ldb_result); - if (!res) { - return LDB_ERR_OPERATIONS_ERROR; - } - - ret = ldb_build_search_req(&req, $self, mem_ctx, - base?base:ldb_get_default_basedn($self), - scope, - expression, - attrs, - controls, - res, - ldb_search_default_callback, - NULL); - - if (ret != LDB_SUCCESS) { - talloc_free(res); - return ret; - } - - ret = ldb_request($self, req); - - if (ret == LDB_SUCCESS) { - ret = ldb_wait(req->handle, LDB_WAIT_ALL); - } - - talloc_free(req); - - *OUT = res; - return ret; - } - - struct ldb_control **parse_control_strings(TALLOC_CTX *mem_ctx, - const char * const*control_strings); - const char *errstring(); - %feature("docstring") set_opaque "S.set_opaque(name, value) -> None\n" \ - "Set an opaque value on this LDB connection. \n" - ":note: Passing incorrect values may cause crashes."; - ldb_error set_opaque(const char *name, void *value); - %feature("docstring") get_opaque "S.get_opaque(name) -> value\n" \ - "Get an opaque value set on this LDB connection. \n" - ":note: The returned value may not be useful in Python."; - void *get_opaque(const char *name); - - %typemap(in,numinputs=0,noblock=1) struct ldb_result **result_as_bool (struct ldb_result *tmp) { $1 = &tmp; } - %typemap(argout,noblock=1) struct ldb_result **result_as_bool { $result = ((*$1)->count > 0)?Py_True:Py_False; } - %typemap(freearg,noblock=1) struct ldb_result **result_as_bool { talloc_free(*$1); } - ldb_error __contains__(ldb_dn *dn, struct ldb_result **result_as_bool) - { - return ldb_search($self, $self, result_as_bool, dn, LDB_SCOPE_BASE, NULL, NULL); - } - } - %pythoncode { - def __init__(self, url=None, flags=0, options=None): - """Create a new LDB object. - - Will also connect to the specified URL if one was given. - """ - _ldb.Ldb_swiginit(self,_ldb.new_Ldb()) - if url is not None: - self.connect(url, flags, options) - - def search(self, base=None, scope=SCOPE_DEFAULT, expression=None, - attrs=None, controls=None): - """Search in a database. - - :param base: Optional base DN to search - :param scope: Search scope (SCOPE_BASE, SCOPE_ONELEVEL or SCOPE_SUBTREE) - :param expression: Optional search expression - :param attrs: Attributes to return (defaults to all) - :param controls: Optional list of controls - :return: Iterator over Message objects - """ - if not (attrs is None or isinstance(attrs, list)): - raise TypeError("attributes not a list") - parsed_controls = None - if controls is not None: - parsed_controls = self.parse_control_strings(controls) - return self.search_ex(base, scope, expression, attrs, - parsed_controls) - } - } ldb; #endif |