?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert broken destructor changes.
[Samba/gbeck.git] / source4 / lib / ldb / pyldb.c
blobe74cae2d204c999abb3ccd9d4b3c7042ec68754c
1 /*
2 Unix SMB/CIFS implementation.
3
4 Python interface to ldb.
5
6 Copyright (C) 2005,2006 Tim Potter <tpot@samba.org>
7 Copyright (C) 2006 Simo Sorce <idra@samba.org>
8 Copyright (C) 2007-2010 Jelmer Vernooij <jelmer@samba.org>
9 Copyright (C) 2009-2010 Matthias Dieter Wallnöfer
10
11 ** NOTE! The following LGPL license applies to the ldb
12 ** library. This does NOT imply that all of Samba is released
13 ** under the LGPL
14
15 This library is free software; you can redistribute it and/or
16 modify it under the terms of the GNU Lesser General Public
17 License as published by the Free Software Foundation; either
18 version 3 of the License, or (at your option) any later version.
19
20 This library is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 Lesser General Public License for more details.
24
25 You should have received a copy of the GNU Lesser General Public
26 License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 */
28
29 #include <Python.h>
30 #include <pytalloc.h>
31 #include "ldb_private.h"
32 #include "pyldb.h"
33
34 void initldb(void);
35 static PyObject *PyLdbMessage_FromMessage(struct ldb_message *msg);
36 static PyObject *PyExc_LdbError;
37
38 staticforward PyTypeObject PyLdbMessage;
39 staticforward PyTypeObject PyLdbModule;
40 staticforward PyTypeObject PyLdbDn;
41 staticforward PyTypeObject PyLdb;
42 staticforward PyTypeObject PyLdbMessageElement;
43 staticforward PyTypeObject PyLdbTree;
44 static PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx);
45 static PyObject *PyLdbModule_FromModule(struct ldb_module *mod);
46 static struct ldb_message_element *PyObject_AsMessageElement(
47 TALLOC_CTX *mem_ctx,
48 PyObject *set_obj,
49 int flags,
50 const char *attr_name);
51
52 /* There's no Py_ssize_t in 2.4, apparently */
53 #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 5
54 typedef int Py_ssize_t;
55 typedef inquiry lenfunc;
56 typedef intargfunc ssizeargfunc;
57 #endif
58
59 #ifndef Py_RETURN_NONE
60 #define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
61 #endif
62
63 static void PyErr_SetLdbError(PyObject *error, int ret, struct ldb_context *ldb_ctx)
64 {
65 if (ret == LDB_ERR_PYTHON_EXCEPTION)
66 return; /* Python exception should already be set, just keep that */
67
68 PyErr_SetObject(error,
69 Py_BuildValue(discard_const_p(char, "(i,s)"), ret,
70 ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx)));
71 }
72
73 static PyObject *PyObject_FromLdbValue(struct ldb_context *ldb_ctx,
74 struct ldb_message_element *el,
75 struct ldb_val *val)
76 {
77 struct ldb_val new_val;
78 TALLOC_CTX *mem_ctx = talloc_new(NULL);
79 PyObject *ret;
80
81 new_val = *val;
82
83 ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
84
85 talloc_free(mem_ctx);
86
87 return ret;
88 }
89
90 /**
91 * Create a Python object from a ldb_result.
92 *
93 * @param result LDB result to convert
94 * @return Python object with converted result (a list object)
95 */
96 static PyObject *PyLdbResult_FromResult(struct ldb_result *result)
97 {
98 PyObject *ret;
99 Py_ssize_t i;
100 if (result == NULL) {
101 Py_RETURN_NONE;
102 }
103 ret = PyList_New(result->count);
104 for (i = 0; i < result->count; i++) {
105 PyList_SetItem(ret, i, PyLdbMessage_FromMessage(result->msgs[i]));
106 }
107 return ret;
108 }
109
110 /**
111 * Create a LDB Result from a Python object.
112 * If conversion fails, NULL will be returned and a Python exception set.
113 *
114 * @param mem_ctx Memory context in which to allocate the LDB Result
115 * @param obj Python object to convert
116 * @return a ldb_result, or NULL if the conversion failed
117 */
118 static struct ldb_result *PyLdbResult_AsResult(TALLOC_CTX *mem_ctx,
119 PyObject *obj)
120 {
121 struct ldb_result *res;
122 Py_ssize_t i;
123
124 if (obj == Py_None)
125 return NULL;
126
127 res = talloc_zero(mem_ctx, struct ldb_result);
128 res->count = PyList_Size(obj);
129 res->msgs = talloc_array(res, struct ldb_message *, res->count);
130 for (i = 0; i < res->count; i++) {
131 PyObject *item = PyList_GetItem(obj, i);
132 res->msgs[i] = PyLdbMessage_AsMessage(item);
133 }
134 return res;
135 }
136
137 static PyObject *py_ldb_dn_validate(PyLdbDnObject *self)
138 {
139 return PyBool_FromLong(ldb_dn_validate(self->dn));
140 }
141
142 static PyObject *py_ldb_dn_is_valid(PyLdbDnObject *self)
143 {
144 return PyBool_FromLong(ldb_dn_is_valid(self->dn));
145 }
146
147 static PyObject *py_ldb_dn_is_special(PyLdbDnObject *self)
148 {
149 return PyBool_FromLong(ldb_dn_is_special(self->dn));
150 }
151
152 static PyObject *py_ldb_dn_is_null(PyLdbDnObject *self)
153 {
154 return PyBool_FromLong(ldb_dn_is_null(self->dn));
155 }
156
157 static PyObject *py_ldb_dn_get_casefold(PyLdbDnObject *self)
158 {
159 return PyString_FromString(ldb_dn_get_casefold(self->dn));
160 }
161
162 static PyObject *py_ldb_dn_get_linearized(PyLdbDnObject *self)
163 {
164 return PyString_FromString(ldb_dn_get_linearized(self->dn));
165 }
166
167 static PyObject *py_ldb_dn_canonical_str(PyLdbDnObject *self)
168 {
169 return PyString_FromString(ldb_dn_canonical_string(self->dn, self->dn));
170 }
171
172 static PyObject *py_ldb_dn_canonical_ex_str(PyLdbDnObject *self)
173 {
174 return PyString_FromString(ldb_dn_canonical_ex_string(self->dn, self->dn));
175 }
176
177 static PyObject *py_ldb_dn_repr(PyLdbDnObject *self)
178 {
179 return PyString_FromFormat("Dn(%s)", PyObject_REPR(PyString_FromString(ldb_dn_get_linearized(self->dn))));
180 }
181
182 static PyObject *py_ldb_dn_check_special(PyLdbDnObject *self, PyObject *args)
183 {
184 char *name;
185
186 if (!PyArg_ParseTuple(args, "s", &name))
187 return NULL;
188
189 return ldb_dn_check_special(self->dn, name)?Py_True:Py_False;
190 }
191
192 static int py_ldb_dn_compare(PyLdbDnObject *dn1, PyLdbDnObject *dn2)
193 {
194 int ret;
195 ret = ldb_dn_compare(dn1->dn, dn2->dn);
196 if (ret < 0) ret = -1;
197 if (ret > 0) ret = 1;
198 return ret;
199 }
200
201 static PyObject *py_ldb_dn_get_parent(PyLdbDnObject *self)
202 {
203 struct ldb_dn *dn = PyLdbDn_AsDn((PyObject *)self);
204 struct ldb_dn *parent;
205 PyLdbDnObject *py_ret;
206 TALLOC_CTX *mem_ctx = talloc_new(NULL);
207
208 parent = ldb_dn_get_parent(mem_ctx, dn);
209 if (parent == NULL) {
210 talloc_free(mem_ctx);
211 Py_RETURN_NONE;
212 }
213
214 py_ret = (PyLdbDnObject *)PyLdbDn.tp_alloc(&PyLdbDn, 0);
215 if (py_ret == NULL) {
216 PyErr_NoMemory();
217 talloc_free(mem_ctx);
218 return NULL;
219 }
220 py_ret->mem_ctx = mem_ctx;
221 py_ret->dn = parent;
222 return (PyObject *)py_ret;
223 }
224
225 #define dn_ldb_ctx(dn) ((struct ldb_context *)dn)
226
227 static PyObject *py_ldb_dn_add_child(PyLdbDnObject *self, PyObject *args)
228 {
229 PyObject *py_other;
230 struct ldb_dn *dn, *other;
231 if (!PyArg_ParseTuple(args, "O", &py_other))
232 return NULL;
233
234 dn = PyLdbDn_AsDn((PyObject *)self);
235
236 if (!PyObject_AsDn(NULL, py_other, dn_ldb_ctx(dn), &other))
237 return NULL;
238
239 return ldb_dn_add_child(dn, other)?Py_True:Py_False;
240 }
241
242 static PyObject *py_ldb_dn_add_base(PyLdbDnObject *self, PyObject *args)
243 {
244 PyObject *py_other;
245 struct ldb_dn *other, *dn;
246 if (!PyArg_ParseTuple(args, "O", &py_other))
247 return NULL;
248
249 dn = PyLdbDn_AsDn((PyObject *)self);
250
251 if (!PyObject_AsDn(NULL, py_other, dn_ldb_ctx(dn), &other))
252 return NULL;
253
254 return ldb_dn_add_base(dn, other)?Py_True:Py_False;
255 }
256
257 static PyMethodDef py_ldb_dn_methods[] = {
258 { "validate", (PyCFunction)py_ldb_dn_validate, METH_NOARGS,
259 "S.validate() -> bool\n"
260 "Validate DN is correct." },
261 { "is_valid", (PyCFunction)py_ldb_dn_is_valid, METH_NOARGS,
262 "S.is_valid() -> bool\n" },
263 { "is_special", (PyCFunction)py_ldb_dn_is_special, METH_NOARGS,
264 "S.is_special() -> bool\n"
265 "Check whether this is a special LDB DN." },
266 { "is_null", (PyCFunction)py_ldb_dn_is_null, METH_NOARGS,
267 "Check whether this is a null DN." },
268 { "get_casefold", (PyCFunction)py_ldb_dn_get_casefold, METH_NOARGS,
269 NULL },
270 { "get_linearized", (PyCFunction)py_ldb_dn_get_linearized, METH_NOARGS,
271 NULL },
272 { "canonical_str", (PyCFunction)py_ldb_dn_canonical_str, METH_NOARGS,
273 "S.canonical_str() -> string\n"
274 "Canonical version of this DN (like a posix path)." },
275 { "canonical_ex_str", (PyCFunction)py_ldb_dn_canonical_ex_str, METH_NOARGS,
276 "S.canonical_ex_str() -> string\n"
277 "Canonical version of this DN (like a posix path, with terminating newline)." },
278 { "parent", (PyCFunction)py_ldb_dn_get_parent, METH_NOARGS,
279 "S.parent() -> dn\n"
280 "Get the parent for this DN." },
281 { "add_child", (PyCFunction)py_ldb_dn_add_child, METH_VARARGS,
282 "S.add_child(dn) -> None\n"
283 "Add a child DN to this DN." },
284 { "add_base", (PyCFunction)py_ldb_dn_add_base, METH_VARARGS,
285 "S.add_base(dn) -> None\n"
286 "Add a base DN to this DN." },
287 { "check_special", (PyCFunction)py_ldb_dn_check_special, METH_VARARGS,
288 "S.check_special(name) -> bool\n\n"
289 "Check if name is a special DN name"},
290 { NULL }
291 };
292
293 static Py_ssize_t py_ldb_dn_len(PyLdbDnObject *self)
294 {
295 return ldb_dn_get_comp_num(PyLdbDn_AsDn((PyObject *)self));
296 }
297
298 static PyObject *py_ldb_dn_concat(PyLdbDnObject *self, PyObject *py_other)
299 {
300 struct ldb_dn *dn = PyLdbDn_AsDn((PyObject *)self),
301 *other;
302 PyLdbDnObject *py_ret;
303
304 if (!PyObject_AsDn(NULL, py_other, NULL, &other))
305 return NULL;
306
307 py_ret = (PyLdbDnObject *)PyLdbDn.tp_alloc(&PyLdbDn, 0);
308 if (py_ret == NULL) {
309 PyErr_NoMemory();
310 return NULL;
311 }
312 py_ret->mem_ctx = talloc_new(NULL);
313 py_ret->dn = ldb_dn_copy(py_ret->mem_ctx, dn);
314 ldb_dn_add_child(py_ret->dn, other);
315 return (PyObject *)py_ret;
316 }
317
318 static PySequenceMethods py_ldb_dn_seq = {
319 .sq_length = (lenfunc)py_ldb_dn_len,
320 .sq_concat = (binaryfunc)py_ldb_dn_concat,
321 };
322
323 static PyObject *py_ldb_dn_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
324 {
325 struct ldb_dn *ret;
326 char *str;
327 PyObject *py_ldb;
328 struct ldb_context *ldb_ctx;
329 TALLOC_CTX *mem_ctx;
330 PyLdbDnObject *py_ret;
331 const char * const kwnames[] = { "ldb", "dn", NULL };
332
333 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Os",
334 discard_const_p(char *, kwnames),
335 &py_ldb, &str))
336 return NULL;
337
338 ldb_ctx = PyLdb_AsLdbContext(py_ldb);
339
340 mem_ctx = talloc_new(NULL);
341 if (mem_ctx == NULL) {
342 PyErr_NoMemory();
343 return NULL;
344 }
345
346 ret = ldb_dn_new(mem_ctx, ldb_ctx, str);
347
348 if (ret == NULL || !ldb_dn_validate(ret)) {
349 talloc_free(mem_ctx);
350 PyErr_SetString(PyExc_ValueError, "unable to parse dn string");
351 return NULL;
352 }
353
354 py_ret = (PyLdbDnObject *)type->tp_alloc(type, 0);
355 if (ret == NULL) {
356 talloc_free(mem_ctx);
357 PyErr_NoMemory();
358 return NULL;
359 }
360 py_ret->mem_ctx = mem_ctx;
361 py_ret->dn = ret;
362 return (PyObject *)py_ret;
363 }
364
365 static void py_ldb_dn_dealloc(PyLdbDnObject *self)
366 {
367 talloc_free(self->mem_ctx);
368 PyObject_Del(self);
369 }
370
371 static PyTypeObject PyLdbDn = {
372 .tp_name = "ldb.Dn",
373 .tp_methods = py_ldb_dn_methods,
374 .tp_str = (reprfunc)py_ldb_dn_get_linearized,
375 .tp_repr = (reprfunc)py_ldb_dn_repr,
376 .tp_compare = (cmpfunc)py_ldb_dn_compare,
377 .tp_as_sequence = &py_ldb_dn_seq,
378 .tp_doc = "A LDB distinguished name.",
379 .tp_new = py_ldb_dn_new,
380 .tp_dealloc = (destructor)py_ldb_dn_dealloc,
381 .tp_basicsize = sizeof(PyLdbObject),
382 .tp_flags = Py_TPFLAGS_DEFAULT,
383 };
384
385 /* Debug */
386 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
387 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
388 {
389 PyObject *fn = (PyObject *)context;
390 PyObject_CallFunction(fn, discard_const_p(char, "(i,O)"), level, PyString_FromFormatV(fmt, ap));
391 }
392
393 static PyObject *py_ldb_set_debug(PyLdbObject *self, PyObject *args)
394 {
395 PyObject *cb;
396
397 if (!PyArg_ParseTuple(args, "O", &cb))
398 return NULL;
399
400 Py_INCREF(cb);
401 /* FIXME: Where do we DECREF cb ? */
402 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ldb_set_debug(self->ldb_ctx, py_ldb_debug, cb), PyLdb_AsLdbContext(self));
403
404 Py_RETURN_NONE;
405 }
406
407 static PyObject *py_ldb_set_create_perms(PyTypeObject *self, PyObject *args)
408 {
409 unsigned int perms;
410 if (!PyArg_ParseTuple(args, "I", &perms))
411 return NULL;
412
413 ldb_set_create_perms(PyLdb_AsLdbContext(self), perms);
414
415 Py_RETURN_NONE;
416 }
417
418 static PyObject *py_ldb_set_modules_dir(PyTypeObject *self, PyObject *args)
419 {
420 char *modules_dir;
421 if (!PyArg_ParseTuple(args, "s", &modules_dir))
422 return NULL;
423
424 ldb_set_modules_dir(PyLdb_AsLdbContext(self), modules_dir);
425
426 Py_RETURN_NONE;
427 }
428
429 static PyObject *py_ldb_transaction_start(PyLdbObject *self)
430 {
431 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ldb_transaction_start(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
432 Py_RETURN_NONE;
433 }
434
435 static PyObject *py_ldb_transaction_commit(PyLdbObject *self)
436 {
437 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ldb_transaction_commit(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
438 Py_RETURN_NONE;
439 }
440
441 static PyObject *py_ldb_transaction_prepare_commit(PyLdbObject *self)
442 {
443 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ldb_transaction_prepare_commit(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
444 Py_RETURN_NONE;
445 }
446
447 static PyObject *py_ldb_transaction_cancel(PyLdbObject *self)
448 {
449 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ldb_transaction_cancel(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
450 Py_RETURN_NONE;
451 }
452
453 static PyObject *py_ldb_setup_wellknown_attributes(PyLdbObject *self)
454 {
455 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ldb_setup_wellknown_attributes(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
456 Py_RETURN_NONE;
457 }
458
459 static PyObject *py_ldb_repr(PyLdbObject *self)
460 {
461 return PyString_FromFormat("<ldb connection>");
462 }
463
464 static PyObject *py_ldb_get_root_basedn(PyLdbObject *self)
465 {
466 struct ldb_dn *dn = ldb_get_root_basedn(PyLdb_AsLdbContext(self));
467 if (dn == NULL)
468 Py_RETURN_NONE;
469 return PyLdbDn_FromDn(dn);
470 }
471
472
473 static PyObject *py_ldb_get_schema_basedn(PyLdbObject *self)
474 {
475 struct ldb_dn *dn = ldb_get_schema_basedn(PyLdb_AsLdbContext(self));
476 if (dn == NULL)
477 Py_RETURN_NONE;
478 return PyLdbDn_FromDn(dn);
479 }
480
481 static PyObject *py_ldb_get_config_basedn(PyLdbObject *self)
482 {
483 struct ldb_dn *dn = ldb_get_config_basedn(PyLdb_AsLdbContext(self));
484 if (dn == NULL)
485 Py_RETURN_NONE;
486 return PyLdbDn_FromDn(dn);
487 }
488
489 static PyObject *py_ldb_get_default_basedn(PyLdbObject *self)
490 {
491 struct ldb_dn *dn = ldb_get_default_basedn(PyLdb_AsLdbContext(self));
492 if (dn == NULL)
493 Py_RETURN_NONE;
494 return PyLdbDn_FromDn(dn);
495 }
496
497 static const char **PyList_AsStringList(TALLOC_CTX *mem_ctx, PyObject *list,
498 const char *paramname)
499 {
500 const char **ret;
501 Py_ssize_t i;
502 if (!PyList_Check(list)) {
503 PyErr_Format(PyExc_TypeError, "%s is not a list", paramname);
504 return NULL;
505 }
506 ret = talloc_array(NULL, const char *, PyList_Size(list)+1);
507 if (ret == NULL) {
508 PyErr_NoMemory();
509 return NULL;
510 }
511
512 for (i = 0; i < PyList_Size(list); i++) {
513 PyObject *item = PyList_GetItem(list, i);
514 if (!PyString_Check(item)) {
515 PyErr_Format(PyExc_TypeError, "%s should be strings", paramname);
516 return NULL;
517 }
518 ret[i] = talloc_strndup(ret, PyString_AsString(item),
519 PyString_Size(item));
520 }
521 ret[i] = NULL;
522 return ret;
523 }
524
525 static int py_ldb_init(PyLdbObject *self, PyObject *args, PyObject *kwargs)
526 {
527 const char * const kwnames[] = { "url", "flags", "options", NULL };
528 char *url = NULL;
529 PyObject *py_options = Py_None;
530 const char **options;
531 int flags = 0;
532 int ret;
533 struct ldb_context *ldb;
534
535 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ziO:Ldb.__init__",
536 discard_const_p(char *, kwnames),
537 &url, &flags, &py_options))
538 return -1;
539
540 ldb = PyLdb_AsLdbContext(self);
541
542 if (py_options == Py_None) {
543 options = NULL;
544 } else {
545 options = PyList_AsStringList(ldb, py_options, "options");
546 if (options == NULL)
547 return -1;
548 }
549
550 if (url != NULL) {
551 ret = ldb_connect(ldb, url, flags, options);
552 if (ret != LDB_SUCCESS) {
553 PyErr_SetLdbError(PyExc_LdbError, ret, ldb);
554 return -1;
555 }
556 }
557
558 talloc_free(options);
559 return 0;
560 }
561
562 static PyObject *py_ldb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
563 {
564 PyLdbObject *ret;
565 struct ldb_context *ldb;
566 ret = (PyLdbObject *)type->tp_alloc(type, 0);
567 if (ret == NULL) {
568 PyErr_NoMemory();
569 return NULL;
570 }
571 ret->mem_ctx = talloc_new(NULL);
572 ldb = ldb_init(ret->mem_ctx, NULL);
573
574 if (ldb == NULL) {
575 PyErr_NoMemory();
576 return NULL;
577 }
578
579 ret->ldb_ctx = ldb;
580 return (PyObject *)ret;
581 }
582
583 static PyObject *py_ldb_connect(PyLdbObject *self, PyObject *args, PyObject *kwargs)
584 {
585 char *url;
586 int flags = 0;
587 PyObject *py_options = Py_None;
588 int ret;
589 const char **options;
590 const char * const kwnames[] = { "url", "flags", "options", NULL };
591
592 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ziO",
593 discard_const_p(char *, kwnames),
594 &url, &flags, &py_options))
595 return NULL;
596
597 if (py_options == Py_None) {
598 options = NULL;
599 } else {
600 options = PyList_AsStringList(NULL, py_options, "options");
601 if (options == NULL)
602 return NULL;
603 }
604
605 ret = ldb_connect(PyLdb_AsLdbContext(self), url, flags, options);
606 talloc_free(options);
607
608 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, PyLdb_AsLdbContext(self));
609
610 Py_RETURN_NONE;
611 }
612
613 static PyObject *py_ldb_modify(PyLdbObject *self, PyObject *args)
614 {
615 PyObject *py_msg;
616 PyObject *py_controls = Py_None;
617 struct ldb_context *ldb_ctx;
618 struct ldb_request *req;
619 struct ldb_control **parsed_controls;
620 struct ldb_message *msg;
621 int ret;
622 TALLOC_CTX *mem_ctx;
623
624 if (!PyArg_ParseTuple(args, "O|O", &py_msg, &py_controls))
625 return NULL;
626
627 mem_ctx = talloc_new(NULL);
628 if (mem_ctx == NULL) {
629 PyErr_NoMemory();
630 return NULL;
631 }
632 ldb_ctx = PyLdb_AsLdbContext(self);
633
634 if (py_controls == Py_None) {
635 parsed_controls = NULL;
636 } else {
637 const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
638 parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
639 talloc_free(controls);
640 }
641
642 if (!PyLdbMessage_Check(py_msg)) {
643 PyErr_SetString(PyExc_TypeError, "Expected Ldb Message");
644 talloc_free(mem_ctx);
645 return NULL;
646 }
647 msg = PyLdbMessage_AsMessage(py_msg);
648
649 ret = ldb_msg_sanity_check(ldb_ctx, msg);
650 if (ret != LDB_SUCCESS) {
651 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
652 talloc_free(mem_ctx);
653 return NULL;
654 }
655
656 ret = ldb_build_mod_req(&req, ldb_ctx, mem_ctx, msg, parsed_controls,
657 NULL, ldb_op_default_callback, NULL);
658 if (ret != LDB_SUCCESS) {
659 PyErr_SetString(PyExc_TypeError, "failed to build request");
660 talloc_free(mem_ctx);
661 return NULL;
662 }
663
664 /* do request and autostart a transaction */
665 /* Then let's LDB handle the message error in case of pb as they are meaningful */
666
667 ret = ldb_transaction_start(ldb_ctx);
668 if (ret != LDB_SUCCESS) {
669 talloc_free(mem_ctx);
670 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
671 }
672
673 ret = ldb_request(ldb_ctx, req);
674 if (ret == LDB_SUCCESS) {
675 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
676 }
677
678 if (ret == LDB_SUCCESS) {
679 ret = ldb_transaction_commit(ldb_ctx);
680 } else {
681 ldb_transaction_cancel(ldb_ctx);
682 if (ldb_ctx->err_string == NULL) {
683 /* no error string was setup by the backend */
684 ldb_asprintf_errstring(ldb_ctx, "%s (%d)", ldb_strerror(ret), ret);
685 }
686 }
687
688 talloc_free(mem_ctx);
689 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
690
691 Py_RETURN_NONE;
692 }
693
694
695 /**
696 * Obtain a ldb message from a Python Dictionary object.
697 *
698 * @param mem_ctx Memory context
699 * @param py_obj Python Dictionary object
700 * @param ldb_ctx LDB context
701 * @param mod_flags Flags to be set on every message element
702 * @return ldb_message on success or NULL on failure
703 */
704 static struct ldb_message *PyDict_AsMessage(TALLOC_CTX *mem_ctx,
705 PyObject *py_obj,
706 struct ldb_context *ldb_ctx,
707 unsigned int mod_flags)
708 {
709 struct ldb_message *msg;
710 unsigned int msg_pos = 0;
711 Py_ssize_t dict_pos = 0;
712 PyObject *key, *value;
713 struct ldb_message_element *msg_el;
714 PyObject *dn_value = PyDict_GetItemString(py_obj, "dn");
715
716 msg = ldb_msg_new(mem_ctx);
717 msg->elements = talloc_zero_array(msg, struct ldb_message_element, PyDict_Size(py_obj));
718
719 if (dn_value) {
720 if (!PyObject_AsDn(msg, dn_value, ldb_ctx, &msg->dn)) {
721 PyErr_SetString(PyExc_TypeError, "unable to import dn object");
722 return NULL;
723 }
724 if (msg->dn == NULL) {
725 PyErr_SetString(PyExc_TypeError, "dn set but not found");
726 return NULL;
727 }
728 } else {
729 PyErr_SetString(PyExc_TypeError, "no dn set");
730 return NULL;
731 }
732
733 while (PyDict_Next(py_obj, &dict_pos, &key, &value)) {
734 char *key_str = PyString_AsString(key);
735 if (strcmp(key_str, "dn") != 0) {
736 msg_el = PyObject_AsMessageElement(msg->elements, value,
737 mod_flags, key_str);
738 if (msg_el == NULL) {
739 PyErr_SetString(PyExc_TypeError, "unable to import element");
740 return NULL;
741 }
742 memcpy(&msg->elements[msg_pos], msg_el, sizeof(*msg_el));
743 msg_pos++;
744 }
745 }
746
747 msg->num_elements = msg_pos;
748
749 return msg;
750 }
751
752 static PyObject *py_ldb_add(PyLdbObject *self, PyObject *args)
753 {
754 PyObject *py_obj;
755 int ret;
756 struct ldb_context *ldb_ctx;
757 struct ldb_request *req;
758 struct ldb_message *msg = NULL;
759 PyObject *py_controls = Py_None;
760 TALLOC_CTX *mem_ctx;
761 struct ldb_control **parsed_controls;
762
763 if (!PyArg_ParseTuple(args, "O|O", &py_obj, &py_controls ))
764 return NULL;
765
766 mem_ctx = talloc_new(NULL);
767 if (mem_ctx == NULL) {
768 PyErr_NoMemory();
769 return NULL;
770 }
771 ldb_ctx = PyLdb_AsLdbContext(self);
772
773 if (py_controls == Py_None) {
774 parsed_controls = NULL;
775 } else {
776 const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
777 parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
778 talloc_free(controls);
779 }
780
781 if (PyLdbMessage_Check(py_obj)) {
782 msg = PyLdbMessage_AsMessage(py_obj);
783 } else if (PyDict_Check(py_obj)) {
784 msg = PyDict_AsMessage(mem_ctx, py_obj, ldb_ctx, LDB_FLAG_MOD_ADD);
785 } else {
786 PyErr_SetString(PyExc_TypeError,
787 "Dictionary or LdbMessage object expected!");
788 }
789
790 if (!msg) {
791 /* we should have a PyErr already set */
792 talloc_free(mem_ctx);
793 return NULL;
794 }
795
796 ret = ldb_msg_sanity_check(ldb_ctx, msg);
797 if (ret != LDB_SUCCESS) {
798 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
799 talloc_free(mem_ctx);
800 return NULL;
801 }
802
803 ret = ldb_build_add_req(&req, ldb_ctx, mem_ctx, msg, parsed_controls,
804 NULL, ldb_op_default_callback, NULL);
805 if (ret != LDB_SUCCESS) {
806 PyErr_SetString(PyExc_TypeError, "failed to build request");
807 talloc_free(mem_ctx);
808 return NULL;
809 }
810
811 /* do request and autostart a transaction */
812 /* Then let's LDB handle the message error in case of pb as they are meaningful */
813
814 ret = ldb_transaction_start(ldb_ctx);
815 if (ret != LDB_SUCCESS) {
816 talloc_free(mem_ctx);
817 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
818 }
819
820 ret = ldb_request(ldb_ctx, req);
821 if (ret == LDB_SUCCESS) {
822 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
823 }
824
825 if (ret == LDB_SUCCESS) {
826 ret = ldb_transaction_commit(ldb_ctx);
827 } else {
828 ldb_transaction_cancel(ldb_ctx);
829 if (ldb_ctx->err_string == NULL) {
830 /* no error string was setup by the backend */
831 ldb_asprintf_errstring(ldb_ctx, "%s (%d)", ldb_strerror(ret), ret);
832 }
833 }
834
835 talloc_free(mem_ctx);
836 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
837
838 Py_RETURN_NONE;
839 }
840
841 static PyObject *py_ldb_delete(PyLdbObject *self, PyObject *args)
842 {
843 PyObject *py_dn;
844 struct ldb_dn *dn;
845 int ret;
846 struct ldb_context *ldb_ctx;
847 struct ldb_request *req;
848 PyObject *py_controls = Py_None;
849 TALLOC_CTX *mem_ctx;
850 struct ldb_control **parsed_controls;
851
852 if (!PyArg_ParseTuple(args, "O|O", &py_dn, &py_controls))
853 return NULL;
854
855 mem_ctx = talloc_new(NULL);
856 if (mem_ctx == NULL) {
857 PyErr_NoMemory();
858 return NULL;
859 }
860 ldb_ctx = PyLdb_AsLdbContext(self);
861
862 if (py_controls == Py_None) {
863 parsed_controls = NULL;
864 } else {
865 const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
866 parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
867 talloc_free(controls);
868 }
869
870 if (!PyObject_AsDn(mem_ctx, py_dn, ldb_ctx, &dn)) {
871 talloc_free(mem_ctx);
872 return NULL;
873 }
874
875 ret = ldb_build_del_req(&req, ldb_ctx, mem_ctx, dn, parsed_controls,
876 NULL, ldb_op_default_callback, NULL);
877 if (ret != LDB_SUCCESS) {
878 PyErr_SetString(PyExc_TypeError, "failed to build request");
879 talloc_free(mem_ctx);
880 return NULL;
881 }
882
883 /* do request and autostart a transaction */
884 /* Then let's LDB handle the message error in case of pb as they are meaningful */
885
886 ret = ldb_transaction_start(ldb_ctx);
887 if (ret != LDB_SUCCESS) {
888 talloc_free(mem_ctx);
889 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
890 }
891
892 ret = ldb_request(ldb_ctx, req);
893 if (ret == LDB_SUCCESS) {
894 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
895 }
896
897 if (ret == LDB_SUCCESS) {
898 ret = ldb_transaction_commit(ldb_ctx);
899 } else {
900 ldb_transaction_cancel(ldb_ctx);
901 if (ldb_ctx->err_string == NULL) {
902 /* no error string was setup by the backend */
903 ldb_asprintf_errstring(ldb_ctx, "%s (%d)", ldb_strerror(ret), ret);
904 }
905 }
906
907 talloc_free(mem_ctx);
908 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
909
910 Py_RETURN_NONE;
911 }
912
913 static PyObject *py_ldb_rename(PyLdbObject *self, PyObject *args)
914 {
915 PyObject *py_dn1, *py_dn2;
916 struct ldb_dn *dn1, *dn2;
917 int ret;
918 struct ldb_context *ldb;
919 TALLOC_CTX *mem_ctx;
920 PyObject *py_controls = Py_None;
921 struct ldb_control **parsed_controls;
922 struct ldb_context *ldb_ctx;
923 struct ldb_request *req;
924
925 ldb_ctx = PyLdb_AsLdbContext(self);
926
927 if (!PyArg_ParseTuple(args, "OO|O", &py_dn1, &py_dn2, &py_controls))
928 return NULL;
929
930
931 mem_ctx = talloc_new(NULL);
932 if (mem_ctx == NULL) {
933 PyErr_NoMemory();
934 return NULL;
935 }
936 ldb = PyLdb_AsLdbContext(self);
937
938 if (py_controls == Py_None) {
939 parsed_controls = NULL;
940 } else {
941 const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
942 parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
943 talloc_free(controls);
944 }
945
946
947 if (!PyObject_AsDn(mem_ctx, py_dn1, ldb, &dn1)) {
948 talloc_free(mem_ctx);
949 return NULL;
950 }
951
952 if (!PyObject_AsDn(mem_ctx, py_dn2, ldb, &dn2)) {
953 talloc_free(mem_ctx);
954 return NULL;
955 }
956
957 ret = ldb_build_rename_req(&req, ldb_ctx, mem_ctx, dn1, dn2, parsed_controls,
958 NULL, ldb_op_default_callback, NULL);
959 if (ret != LDB_SUCCESS) {
960 PyErr_SetString(PyExc_TypeError, "failed to build request");
961 talloc_free(mem_ctx);
962 return NULL;
963 }
964
965 /* do request and autostart a transaction */
966 /* Then let's LDB handle the message error in case of pb as they are meaningful */
967
968 ret = ldb_transaction_start(ldb_ctx);
969 if (ret != LDB_SUCCESS) {
970 talloc_free(mem_ctx);
971 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
972 }
973
974 ret = ldb_request(ldb_ctx, req);
975 if (ret == LDB_SUCCESS) {
976 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
977 }
978
979 if (ret == LDB_SUCCESS) {
980 ret = ldb_transaction_commit(ldb_ctx);
981 } else {
982 ldb_transaction_cancel(ldb_ctx);
983 if (ldb_ctx->err_string == NULL) {
984 /* no error string was setup by the backend */
985 ldb_asprintf_errstring(ldb_ctx, "%s (%d)", ldb_strerror(ret), ret);
986 }
987 }
988
989 talloc_free(mem_ctx);
990 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
991
992 Py_RETURN_NONE;
993 }
994
995 static PyObject *py_ldb_schema_attribute_remove(PyLdbObject *self, PyObject *args)
996 {
997 char *name;
998 if (!PyArg_ParseTuple(args, "s", &name))
999 return NULL;
1000
1001 ldb_schema_attribute_remove(PyLdb_AsLdbContext(self), name);
1002
1003 Py_RETURN_NONE;
1004 }
1005
1006 static PyObject *py_ldb_schema_attribute_add(PyLdbObject *self, PyObject *args)
1007 {
1008 char *attribute, *syntax;
1009 unsigned int flags;
1010 int ret;
1011 if (!PyArg_ParseTuple(args, "sIs", &attribute, &flags, &syntax))
1012 return NULL;
1013
1014 ret = ldb_schema_attribute_add(PyLdb_AsLdbContext(self), attribute, flags, syntax);
1015
1016 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, PyLdb_AsLdbContext(self));
1017
1018 Py_RETURN_NONE;
1019 }
1020
1021 static PyObject *ldb_ldif_to_pyobject(struct ldb_ldif *ldif)
1022 {
1023 if (ldif == NULL) {
1024 Py_RETURN_NONE;
1025 } else {
1026 /* We don't want this attached to the 'ldb' any more */
1027 return Py_BuildValue(discard_const_p(char, "(iO)"),
1028 ldif->changetype,
1029 PyLdbMessage_FromMessage(ldif->msg));
1030 }
1031 }
1032
1033
1034 static PyObject *py_ldb_write_ldif(PyLdbObject *self, PyObject *args)
1035 {
1036 int changetype;
1037 PyObject *py_msg;
1038 struct ldb_ldif ldif;
1039 PyObject *ret;
1040 char *string;
1041 TALLOC_CTX *mem_ctx;
1042
1043 if (!PyArg_ParseTuple(args, "Oi", &py_msg, &changetype))
1044 return NULL;
1045
1046 if (!PyLdbMessage_Check(py_msg)) {
1047 PyErr_SetString(PyExc_TypeError, "Expected Ldb Message for msg");
1048 return NULL;
1049 }
1050
1051 ldif.msg = PyLdbMessage_AsMessage(py_msg);
1052 ldif.changetype = changetype;
1053
1054 mem_ctx = talloc_new(NULL);
1055
1056 string = ldb_ldif_write_string(PyLdb_AsLdbContext(self), mem_ctx, &ldif);
1057 if (!string) {
1058 PyErr_SetString(PyExc_KeyError, "Failed to generate LDIF");
1059 return NULL;
1060 }
1061
1062 ret = PyString_FromString(string);
1063
1064 talloc_free(mem_ctx);
1065
1066 return ret;
1067 }
1068
1069 static PyObject *py_ldb_parse_ldif(PyLdbObject *self, PyObject *args)
1070 {
1071 PyObject *list;
1072 struct ldb_ldif *ldif;
1073 const char *s;
1074
1075 TALLOC_CTX *mem_ctx;
1076
1077 if (!PyArg_ParseTuple(args, "s", &s))
1078 return NULL;
1079
1080 mem_ctx = talloc_new(NULL);
1081 if (!mem_ctx) {
1082 Py_RETURN_NONE;
1083 }
1084
1085 list = PyList_New(0);
1086 while (s && *s != '\0') {
1087 ldif = ldb_ldif_read_string(self->ldb_ctx, &s);
1088 talloc_steal(mem_ctx, ldif);
1089 if (ldif) {
1090 PyList_Append(list, ldb_ldif_to_pyobject(ldif));
1091 } else {
1092 PyErr_SetString(PyExc_ValueError, "unable to parse ldif string");
1093 talloc_free(mem_ctx);
1094 return NULL;
1095 }
1096 }
1097 talloc_free(mem_ctx); /* The pyobject already has a reference to the things it needs */
1098 return PyObject_GetIter(list);
1099 }
1100
1101 static PyObject *py_ldb_msg_diff(PyLdbObject *self, PyObject *args)
1102 {
1103 int ldb_ret;
1104 PyObject *py_msg_old;
1105 PyObject *py_msg_new;
1106 struct ldb_message *diff;
1107 struct ldb_context *ldb;
1108 PyObject *py_ret;
1109
1110 if (!PyArg_ParseTuple(args, "OO", &py_msg_old, &py_msg_new))
1111 return NULL;
1112
1113 if (!PyLdbMessage_Check(py_msg_old)) {
1114 PyErr_SetString(PyExc_TypeError, "Expected Ldb Message for old message");
1115 return NULL;
1116 }
1117
1118 if (!PyLdbMessage_Check(py_msg_new)) {
1119 PyErr_SetString(PyExc_TypeError, "Expected Ldb Message for new message");
1120 return NULL;
1121 }
1122
1123 ldb = PyLdb_AsLdbContext(self);
1124 ldb_ret = ldb_msg_difference(ldb, ldb,
1125 PyLdbMessage_AsMessage(py_msg_old),
1126 PyLdbMessage_AsMessage(py_msg_new),
1127 &diff);
1128 if (ldb_ret != LDB_SUCCESS) {
1129 PyErr_SetString(PyExc_RuntimeError, "Failed to generate the Ldb Message diff");
1130 return NULL;
1131 }
1132
1133 py_ret = PyLdbMessage_FromMessage(diff);
1134
1135 talloc_unlink(ldb, diff);
1136
1137 return py_ret;
1138 }
1139
1140 static PyObject *py_ldb_schema_format_value(PyLdbObject *self, PyObject *args)
1141 {
1142 const struct ldb_schema_attribute *a;
1143 struct ldb_val old_val;
1144 struct ldb_val new_val;
1145 TALLOC_CTX *mem_ctx;
1146 PyObject *ret;
1147 char *element_name;
1148 PyObject *val;
1149
1150 if (!PyArg_ParseTuple(args, "sO", &element_name, &val))
1151 return NULL;
1152
1153 mem_ctx = talloc_new(NULL);
1154
1155 old_val.data = (uint8_t *)PyString_AsString(val);
1156 old_val.length = PyString_Size(val);
1157
1158 a = ldb_schema_attribute_by_name(PyLdb_AsLdbContext(self), element_name);
1159
1160 if (a == NULL) {
1161 Py_RETURN_NONE;
1162 }
1163
1164 if (a->syntax->ldif_write_fn(PyLdb_AsLdbContext(self), mem_ctx, &old_val, &new_val) != 0) {
1165 talloc_free(mem_ctx);
1166 Py_RETURN_NONE;
1167 }
1168
1169 ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
1170
1171 talloc_free(mem_ctx);
1172
1173 return ret;
1174 }
1175
1176 static PyObject *py_ldb_search(PyLdbObject *self, PyObject *args, PyObject *kwargs)
1177 {
1178 PyObject *py_base = Py_None;
1179 int scope = LDB_SCOPE_DEFAULT;
1180 char *expr = NULL;
1181 PyObject *py_attrs = Py_None;
1182 PyObject *py_controls = Py_None;
1183 const char * const kwnames[] = { "base", "scope", "expression", "attrs", "controls", NULL };
1184 int ret;
1185 struct ldb_result *res;
1186 struct ldb_request *req;
1187 const char **attrs;
1188 struct ldb_context *ldb_ctx;
1189 struct ldb_control **parsed_controls;
1190 struct ldb_dn *base;
1191 PyObject *py_ret;
1192 TALLOC_CTX *mem_ctx;
1193
1194 /* type "int" rather than "enum" for "scope" is intentional */
1195 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OizOO",
1196 discard_const_p(char *, kwnames),
1197 &py_base, &scope, &expr, &py_attrs, &py_controls))
1198 return NULL;
1199
1200
1201 mem_ctx = talloc_new(NULL);
1202 if (mem_ctx == NULL) {
1203 PyErr_NoMemory();
1204 return NULL;
1205 }
1206 ldb_ctx = PyLdb_AsLdbContext(self);
1207
1208 if (py_attrs == Py_None) {
1209 attrs = NULL;
1210 } else {
1211 attrs = PyList_AsStringList(mem_ctx, py_attrs, "attrs");
1212 if (attrs == NULL) {
1213 talloc_free(mem_ctx);
1214 return NULL;
1215 }
1216 }
1217
1218 if (py_base == Py_None) {
1219 base = ldb_get_default_basedn(ldb_ctx);
1220 } else {
1221 if (!PyObject_AsDn(ldb_ctx, py_base, ldb_ctx, &base)) {
1222 talloc_free(attrs);
1223 return NULL;
1224 }
1225 }
1226
1227 if (py_controls == Py_None) {
1228 parsed_controls = NULL;
1229 } else {
1230 const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
1231 parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
1232 talloc_free(controls);
1233 }
1234
1235 res = talloc_zero(mem_ctx, struct ldb_result);
1236 if (res == NULL) {
1237 PyErr_NoMemory();
1238 talloc_free(mem_ctx);
1239 return NULL;
1240 }
1241
1242 ret = ldb_build_search_req(&req, ldb_ctx, mem_ctx,
1243 base,
1244 scope,
1245 expr,
1246 attrs,
1247 parsed_controls,
1248 res,
1249 ldb_search_default_callback,
1250 NULL);
1251
1252 if (ret != LDB_SUCCESS) {
1253 talloc_free(mem_ctx);
1254 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
1255 return NULL;
1256 }
1257
1258 talloc_steal(req, attrs);
1259
1260 ret = ldb_request(ldb_ctx, req);
1261
1262 if (ret == LDB_SUCCESS) {
1263 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
1264 }
1265
1266 if (ret != LDB_SUCCESS) {
1267 talloc_free(mem_ctx);
1268 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
1269 return NULL;
1270 }
1271
1272 py_ret = PyLdbResult_FromResult(res);
1273
1274 talloc_free(mem_ctx);
1275
1276 return py_ret;
1277 }
1278
1279 static PyObject *py_ldb_get_opaque(PyLdbObject *self, PyObject *args)
1280 {
1281 char *name;
1282 void *data;
1283
1284 if (!PyArg_ParseTuple(args, "s", &name))
1285 return NULL;
1286
1287 data = ldb_get_opaque(PyLdb_AsLdbContext(self), name);
1288
1289 if (data == NULL)
1290 Py_RETURN_NONE;
1291
1292 /* FIXME: More interpretation */
1293
1294 return Py_True;
1295 }
1296
1297 static PyObject *py_ldb_set_opaque(PyLdbObject *self, PyObject *args)
1298 {
1299 char *name;
1300 PyObject *data;
1301
1302 if (!PyArg_ParseTuple(args, "sO", &name, &data))
1303 return NULL;
1304
1305 /* FIXME: More interpretation */
1306
1307 ldb_set_opaque(PyLdb_AsLdbContext(self), name, data);
1308
1309 Py_RETURN_NONE;
1310 }
1311
1312 static PyObject *py_ldb_modules(PyLdbObject *self)
1313 {
1314 struct ldb_context *ldb = PyLdb_AsLdbContext(self);
1315 PyObject *ret = PyList_New(0);
1316 struct ldb_module *mod;
1317
1318 for (mod = ldb->modules; mod; mod = mod->next) {
1319 PyList_Append(ret, PyLdbModule_FromModule(mod));
1320 }
1321
1322 return ret;
1323 }
1324
1325 static PyObject *py_ldb_sequence_number(PyLdbObject *self, PyObject *args)
1326 {
1327 struct ldb_context *ldb = PyLdb_AsLdbContext(self);
1328 int type, ret;
1329 uint64_t value;
1330
1331 if (!PyArg_ParseTuple(args, "i", &type))
1332 return NULL;
1333
1334 /* FIXME: More interpretation */
1335
1336 ret = ldb_sequence_number(ldb, type, &value);
1337
1338 if (ret != LDB_SUCCESS) {
1339 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb);
1340 return NULL;
1341 }
1342 return PyLong_FromLongLong(value);
1343 }
1344 static PyMethodDef py_ldb_methods[] = {
1345 { "set_debug", (PyCFunction)py_ldb_set_debug, METH_VARARGS,
1346 "S.set_debug(callback) -> None\n"
1347 "Set callback for LDB debug messages.\n"
1348 "The callback should accept a debug level and debug text." },
1349 { "set_create_perms", (PyCFunction)py_ldb_set_create_perms, METH_VARARGS,
1350 "S.set_create_perms(mode) -> None\n"
1351 "Set mode to use when creating new LDB files." },
1352 { "set_modules_dir", (PyCFunction)py_ldb_set_modules_dir, METH_VARARGS,
1353 "S.set_modules_dir(path) -> None\n"
1354 "Set path LDB should search for modules" },
1355 { "transaction_start", (PyCFunction)py_ldb_transaction_start, METH_NOARGS,
1356 "S.transaction_start() -> None\n"
1357 "Start a new transaction." },
1358 { "transaction_prepare_commit", (PyCFunction)py_ldb_transaction_prepare_commit, METH_NOARGS,
1359 "S.transaction_prepare_commit() -> None\n"
1360 "prepare to commit a new transaction (2-stage commit)." },
1361 { "transaction_commit", (PyCFunction)py_ldb_transaction_commit, METH_NOARGS,
1362 "S.transaction_commit() -> None\n"
1363 "commit a new transaction." },
1364 { "transaction_cancel", (PyCFunction)py_ldb_transaction_cancel, METH_NOARGS,
1365 "S.transaction_cancel() -> None\n"
1366 "cancel a new transaction." },
1367 { "setup_wellknown_attributes", (PyCFunction)py_ldb_setup_wellknown_attributes, METH_NOARGS,
1368 NULL },
1369 { "get_root_basedn", (PyCFunction)py_ldb_get_root_basedn, METH_NOARGS,
1370 NULL },
1371 { "get_schema_basedn", (PyCFunction)py_ldb_get_schema_basedn, METH_NOARGS,
1372 NULL },
1373 { "get_default_basedn", (PyCFunction)py_ldb_get_default_basedn, METH_NOARGS,
1374 NULL },
1375 { "get_config_basedn", (PyCFunction)py_ldb_get_config_basedn, METH_NOARGS,
1376 NULL },
1377 { "connect", (PyCFunction)py_ldb_connect, METH_VARARGS|METH_KEYWORDS,
1378 "S.connect(url, flags=0, options=None) -> None\n"
1379 "Connect to a LDB URL." },
1380 { "modify", (PyCFunction)py_ldb_modify, METH_VARARGS,
1381 "S.modify(message) -> None\n"
1382 "Modify an entry." },
1383 { "add", (PyCFunction)py_ldb_add, METH_VARARGS,
1384 "S.add(message) -> None\n"
1385 "Add an entry." },
1386 { "delete", (PyCFunction)py_ldb_delete, METH_VARARGS,
1387 "S.delete(dn) -> None\n"
1388 "Remove an entry." },
1389 { "rename", (PyCFunction)py_ldb_rename, METH_VARARGS,
1390 "S.rename(old_dn, new_dn) -> None\n"
1391 "Rename an entry." },
1392 { "search", (PyCFunction)py_ldb_search, METH_VARARGS|METH_KEYWORDS,
1393 "S.search(base=None, scope=None, expression=None, attrs=None, controls=None) -> msgs\n"
1394 "Search in a database.\n"
1395 "\n"
1396 ":param base: Optional base DN to search\n"
1397 ":param scope: Search scope (SCOPE_BASE, SCOPE_ONELEVEL or SCOPE_SUBTREE)\n"
1398 ":param expression: Optional search expression\n"
1399 ":param attrs: Attributes to return (defaults to all)\n"
1400 ":param controls: Optional list of controls\n"
1401 ":return: Iterator over Message objects\n"
1402 },
1403 { "schema_attribute_remove", (PyCFunction)py_ldb_schema_attribute_remove, METH_VARARGS,
1404 NULL },
1405 { "schema_attribute_add", (PyCFunction)py_ldb_schema_attribute_add, METH_VARARGS,
1406 NULL },
1407 { "schema_format_value", (PyCFunction)py_ldb_schema_format_value, METH_VARARGS,
1408 NULL },
1409 { "parse_ldif", (PyCFunction)py_ldb_parse_ldif, METH_VARARGS,
1410 "S.parse_ldif(ldif) -> iter(messages)\n"
1411 "Parse a string formatted using LDIF." },
1412 { "write_ldif", (PyCFunction)py_ldb_write_ldif, METH_VARARGS,
1413 "S.write_ldif(message, changetype) -> ldif\n"
1414 "Print the message as a string formatted using LDIF." },
1415 { "msg_diff", (PyCFunction)py_ldb_msg_diff, METH_VARARGS,
1416 "S.msg_diff(Message) -> Message\n"
1417 "Return an LDB Message of the difference between two Message objects." },
1418 { "get_opaque", (PyCFunction)py_ldb_get_opaque, METH_VARARGS,
1419 "S.get_opaque(name) -> value\n"
1420 "Get an opaque value set on this LDB connection. \n"
1421 ":note: The returned value may not be useful in Python."
1422 },
1423 { "set_opaque", (PyCFunction)py_ldb_set_opaque, METH_VARARGS,
1424 "S.set_opaque(name, value) -> None\n"
1425 "Set an opaque value on this LDB connection. \n"
1426 ":note: Passing incorrect values may cause crashes." },
1427 { "modules", (PyCFunction)py_ldb_modules, METH_NOARGS,
1428 "S.modules() -> list\n"
1429 "Return the list of modules on this LDB connection " },
1430 { "sequence_number", (PyCFunction)py_ldb_sequence_number, METH_VARARGS,
1431 "S.sequence_number(type) -> value\n"
1432 "Return the value of the sequence according to the requested type" },
1433 { NULL },
1434 };
1435
1436 static PyObject *PyLdbModule_FromModule(struct ldb_module *mod)
1437 {
1438 PyLdbModuleObject *ret;
1439
1440 ret = (PyLdbModuleObject *)PyLdbModule.tp_alloc(&PyLdbModule, 0);
1441 if (ret == NULL) {
1442 PyErr_NoMemory();
1443 return NULL;
1444 }
1445 ret->mem_ctx = talloc_new(NULL);
1446 ret->mod = talloc_reference(ret->mem_ctx, mod);
1447 return (PyObject *)ret;
1448 }
1449
1450 static PyObject *py_ldb_get_firstmodule(PyLdbObject *self, void *closure)
1451 {
1452 return PyLdbModule_FromModule(PyLdb_AsLdbContext(self)->modules);
1453 }
1454
1455 static PyGetSetDef py_ldb_getset[] = {
1456 { discard_const_p(char, "firstmodule"), (getter)py_ldb_get_firstmodule, NULL, NULL },
1457 { NULL }
1458 };
1459
1460 static int py_ldb_contains(PyLdbObject *self, PyObject *obj)
1461 {
1462 struct ldb_context *ldb_ctx = PyLdb_AsLdbContext(self);
1463 struct ldb_dn *dn;
1464 struct ldb_result *result;
1465 unsigned int count;
1466 int ret;
1467
1468 if (!PyObject_AsDn(ldb_ctx, obj, ldb_ctx, &dn)) {
1469 return -1;
1470 }
1471
1472 ret = ldb_search(ldb_ctx, ldb_ctx, &result, dn, LDB_SCOPE_BASE, NULL,
1473 NULL);
1474 if (ret != LDB_SUCCESS) {
1475 PyErr_SetLdbError(PyExc_LdbError, ret, ldb_ctx);
1476 return -1;
1477 }
1478
1479 count = result->count;
1480
1481 talloc_free(result);
1482
1483 if (count > 1) {
1484 PyErr_Format(PyExc_RuntimeError,
1485 "Searching for [%s] dn gave %u results!",
1486 ldb_dn_get_linearized(dn),
1487 count);
1488 return -1;
1489 }
1490
1491 return count;
1492 }
1493
1494 static PySequenceMethods py_ldb_seq = {
1495 .sq_contains = (objobjproc)py_ldb_contains,
1496 };
1497
1498 static PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx)
1499 {
1500 PyLdbObject *ret;
1501
1502 ret = (PyLdbObject *)PyLdb.tp_alloc(&PyLdb, 0);
1503 if (ret == NULL) {
1504 PyErr_NoMemory();
1505 return NULL;
1506 }
1507 ret->mem_ctx = talloc_new(NULL);
1508 ret->ldb_ctx = talloc_reference(ret->mem_ctx, ldb_ctx);
1509 return (PyObject *)ret;
1510 }
1511
1512 static void py_ldb_dealloc(PyLdbObject *self)
1513 {
1514 talloc_free(self->mem_ctx);
1515 self->ob_type->tp_free(self);
1516 }
1517
1518 static PyTypeObject PyLdb = {
1519 .tp_name = "ldb.Ldb",
1520 .tp_methods = py_ldb_methods,
1521 .tp_repr = (reprfunc)py_ldb_repr,
1522 .tp_new = py_ldb_new,
1523 .tp_init = (initproc)py_ldb_init,
1524 .tp_dealloc = (destructor)py_ldb_dealloc,
1525 .tp_getset = py_ldb_getset,
1526 .tp_getattro = PyObject_GenericGetAttr,
1527 .tp_basicsize = sizeof(PyLdbObject),
1528 .tp_doc = "Connection to a LDB database.",
1529 .tp_as_sequence = &py_ldb_seq,
1530 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
1531 };
1532
1533 static PyObject *py_ldb_module_repr(PyLdbModuleObject *self)
1534 {
1535 return PyString_FromFormat("<ldb module '%s'>", PyLdbModule_AsModule(self)->ops->name);
1536 }
1537
1538 static PyObject *py_ldb_module_str(PyLdbModuleObject *self)
1539 {
1540 return PyString_FromString(PyLdbModule_AsModule(self)->ops->name);
1541 }
1542
1543 static PyObject *py_ldb_module_start_transaction(PyLdbModuleObject *self)
1544 {
1545 PyLdbModule_AsModule(self)->ops->start_transaction(PyLdbModule_AsModule(self));
1546 Py_RETURN_NONE;
1547 }
1548
1549 static PyObject *py_ldb_module_end_transaction(PyLdbModuleObject *self)
1550 {
1551 PyLdbModule_AsModule(self)->ops->end_transaction(PyLdbModule_AsModule(self));
1552 Py_RETURN_NONE;
1553 }
1554
1555 static PyObject *py_ldb_module_del_transaction(PyLdbModuleObject *self)
1556 {
1557 PyLdbModule_AsModule(self)->ops->del_transaction(PyLdbModule_AsModule(self));
1558 Py_RETURN_NONE;
1559 }
1560
1561 static PyObject *py_ldb_module_search(PyLdbModuleObject *self, PyObject *args, PyObject *kwargs)
1562 {
1563 PyObject *py_base, *py_tree, *py_attrs, *py_ret;
1564 int ret, scope;
1565 struct ldb_request *req;
1566 const char * const kwnames[] = { "base", "scope", "tree", "attrs", NULL };
1567 struct ldb_module *mod;
1568 const char * const*attrs;
1569
1570 /* type "int" rather than "enum" for "scope" is intentional */
1571 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiOO",
1572 discard_const_p(char *, kwnames),
1573 &py_base, &scope, &py_tree, &py_attrs))
1574 return NULL;
1575
1576 mod = self->mod;
1577
1578 if (py_attrs == Py_None) {
1579 attrs = NULL;
1580 } else {
1581 attrs = PyList_AsStringList(NULL, py_attrs, "attrs");
1582 if (attrs == NULL)
1583 return NULL;
1584 }
1585
1586 ret = ldb_build_search_req(&req, mod->ldb, NULL, PyLdbDn_AsDn(py_base),
1587 scope, NULL /* expr */, attrs,
1588 NULL /* controls */, NULL, NULL, NULL);
1589
1590 talloc_steal(req, attrs);
1591
1592 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, mod->ldb);
1593
1594 req->op.search.res = NULL;
1595
1596 ret = mod->ops->search(mod, req);
1597
1598 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, mod->ldb);
1599
1600 py_ret = PyLdbResult_FromResult(req->op.search.res);
1601
1602 talloc_free(req);
1603
1604 return py_ret;
1605 }
1606
1607
1608 static PyObject *py_ldb_module_add(PyLdbModuleObject *self, PyObject *args)
1609 {
1610 struct ldb_request *req;
1611 PyObject *py_message;
1612 int ret;
1613 struct ldb_module *mod;
1614
1615 if (!PyArg_ParseTuple(args, "O", &py_message))
1616 return NULL;
1617
1618 req = talloc_zero(NULL, struct ldb_request);
1619 req->operation = LDB_ADD;
1620 req->op.add.message = PyLdbMessage_AsMessage(py_message);
1621
1622 mod = PyLdbModule_AsModule(self);
1623 ret = mod->ops->add(mod, req);
1624
1625 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, mod->ldb);
1626
1627 Py_RETURN_NONE;
1628 }
1629
1630 static PyObject *py_ldb_module_modify(PyLdbModuleObject *self, PyObject *args)
1631 {
1632 int ret;
1633 struct ldb_request *req;
1634 PyObject *py_message;
1635 struct ldb_module *mod;
1636
1637 if (!PyArg_ParseTuple(args, "O", &py_message))
1638 return NULL;
1639
1640 req = talloc_zero(NULL, struct ldb_request);
1641 req->operation = LDB_MODIFY;
1642 req->op.mod.message = PyLdbMessage_AsMessage(py_message);
1643
1644 mod = PyLdbModule_AsModule(self);
1645 ret = mod->ops->modify(mod, req);
1646
1647 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, mod->ldb);
1648
1649 Py_RETURN_NONE;
1650 }
1651
1652 static PyObject *py_ldb_module_delete(PyLdbModuleObject *self, PyObject *args)
1653 {
1654 int ret;
1655 struct ldb_request *req;
1656 PyObject *py_dn;
1657
1658 if (!PyArg_ParseTuple(args, "O", &py_dn))
1659 return NULL;
1660
1661 req = talloc_zero(NULL, struct ldb_request);
1662 req->operation = LDB_DELETE;
1663 req->op.del.dn = PyLdbDn_AsDn(py_dn);
1664
1665 ret = PyLdbModule_AsModule(self)->ops->del(PyLdbModule_AsModule(self), req);
1666
1667 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, NULL);
1668
1669 Py_RETURN_NONE;
1670 }
1671
1672 static PyObject *py_ldb_module_rename(PyLdbModuleObject *self, PyObject *args)
1673 {
1674 int ret;
1675 struct ldb_request *req;
1676 PyObject *py_dn1, *py_dn2;
1677
1678 if (!PyArg_ParseTuple(args, "OO", &py_dn1, &py_dn2))
1679 return NULL;
1680
1681 req = talloc_zero(NULL, struct ldb_request);
1682
1683 req->operation = LDB_RENAME;
1684 req->op.rename.olddn = PyLdbDn_AsDn(py_dn1);
1685 req->op.rename.newdn = PyLdbDn_AsDn(py_dn2);
1686
1687 ret = PyLdbModule_AsModule(self)->ops->rename(PyLdbModule_AsModule(self), req);
1688
1689 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, NULL);
1690
1691 Py_RETURN_NONE;
1692 }
1693
1694 static PyMethodDef py_ldb_module_methods[] = {
1695 { "search", (PyCFunction)py_ldb_module_search, METH_VARARGS|METH_KEYWORDS, NULL },
1696 { "add", (PyCFunction)py_ldb_module_add, METH_VARARGS, NULL },
1697 { "modify", (PyCFunction)py_ldb_module_modify, METH_VARARGS, NULL },
1698 { "rename", (PyCFunction)py_ldb_module_rename, METH_VARARGS, NULL },
1699 { "delete", (PyCFunction)py_ldb_module_delete, METH_VARARGS, NULL },
1700 { "start_transaction", (PyCFunction)py_ldb_module_start_transaction, METH_NOARGS, NULL },
1701 { "end_transaction", (PyCFunction)py_ldb_module_end_transaction, METH_NOARGS, NULL },
1702 { "del_transaction", (PyCFunction)py_ldb_module_del_transaction, METH_NOARGS, NULL },
1703 { NULL },
1704 };
1705
1706 static void py_ldb_module_dealloc(PyLdbModuleObject *self)
1707 {
1708 talloc_free(self->mem_ctx);
1709 PyObject_Del(self);
1710 }
1711
1712 static PyTypeObject PyLdbModule = {
1713 .tp_name = "ldb.LdbModule",
1714 .tp_methods = py_ldb_module_methods,
1715 .tp_repr = (reprfunc)py_ldb_module_repr,
1716 .tp_str = (reprfunc)py_ldb_module_str,
1717 .tp_basicsize = sizeof(PyLdbModuleObject),
1718 .tp_dealloc = (destructor)py_ldb_module_dealloc,
1719 .tp_flags = Py_TPFLAGS_DEFAULT,
1720 };
1721
1722
1723 /**
1724 * Create a ldb_message_element from a Python object.
1725 *
1726 * This will accept any sequence objects that contains strings, or
1727 * a string object.
1728 *
1729 * A reference to set_obj will be borrowed.
1730 *
1731 * @param mem_ctx Memory context
1732 * @param set_obj Python object to convert
1733 * @param flags ldb_message_element flags to set
1734 * @param attr_name Name of the attribute
1735 * @return New ldb_message_element, allocated as child of mem_ctx
1736 */
1737 static struct ldb_message_element *PyObject_AsMessageElement(
1738 TALLOC_CTX *mem_ctx,
1739 PyObject *set_obj,
1740 int flags,
1741 const char *attr_name)
1742 {
1743 struct ldb_message_element *me;
1744
1745 if (PyLdbMessageElement_Check(set_obj)) {
1746 PyLdbMessageElementObject *set_obj_as_me = (PyLdbMessageElementObject *)set_obj;
1747 /* We have to talloc_reference() the memory context, not the pointer
1748 * which may not actually be it's own context */
1749 if (talloc_reference(mem_ctx, set_obj_as_me->mem_ctx)) {
1750 return PyLdbMessageElement_AsMessageElement(set_obj);
1751 }
1752 return NULL;
1753 }
1754
1755 me = talloc(mem_ctx, struct ldb_message_element);
1756 if (me == NULL) {
1757 PyErr_NoMemory();
1758 return NULL;
1759 }
1760
1761 me->name = talloc_strdup(me, attr_name);
1762 me->flags = flags;
1763 if (PyString_Check(set_obj)) {
1764 me->num_values = 1;
1765 me->values = talloc_array(me, struct ldb_val, me->num_values);
1766 me->values[0].length = PyString_Size(set_obj);
1767 me->values[0].data = talloc_memdup(me,
1768 (uint8_t *)PyString_AsString(set_obj), me->values[0].length+1);
1769 } else if (PySequence_Check(set_obj)) {
1770 Py_ssize_t i;
1771 me->num_values = PySequence_Size(set_obj);
1772 me->values = talloc_array(me, struct ldb_val, me->num_values);
1773 for (i = 0; i < me->num_values; i++) {
1774 PyObject *obj = PySequence_GetItem(set_obj, i);
1775 if (!PyString_Check(obj)) {
1776 PyErr_Format(PyExc_TypeError,
1777 "Expected string as element %zd in list", i);
1778 talloc_free(me);
1779 return NULL;
1780 }
1781
1782 me->values[i].length = PyString_Size(obj);
1783 me->values[i].data = talloc_memdup(me,
1784 (uint8_t *)PyString_AsString(obj), me->values[i].length+1);
1785 }
1786 } else {
1787 talloc_free(me);
1788 me = NULL;
1789 }
1790
1791 return me;
1792 }
1793
1794
1795 static PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
1796 struct ldb_message_element *me)
1797 {
1798 Py_ssize_t i;
1799 PyObject *result;
1800
1801 /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
1802 result = PyList_New(me->num_values);
1803
1804 for (i = 0; i < me->num_values; i++) {
1805 PyList_SetItem(result, i,
1806 PyObject_FromLdbValue(ldb_ctx, me, &me->values[i]));
1807 }
1808
1809 return result;
1810 }
1811
1812 static PyObject *py_ldb_msg_element_get(PyLdbMessageElementObject *self, PyObject *args)
1813 {
1814 unsigned int i;
1815 if (!PyArg_ParseTuple(args, "I", &i))
1816 return NULL;
1817 if (i >= PyLdbMessageElement_AsMessageElement(self)->num_values)
1818 Py_RETURN_NONE;
1819
1820 return PyObject_FromLdbValue(NULL, PyLdbMessageElement_AsMessageElement(self),
1821 &(PyLdbMessageElement_AsMessageElement(self)->values[i]));
1822 }
1823
1824 static PyObject *py_ldb_msg_element_flags(PyLdbMessageElementObject *self, PyObject *args)
1825 {
1826 struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
1827 return PyInt_FromLong(el->flags);
1828 }
1829
1830 static PyObject *py_ldb_msg_element_set_flags(PyLdbMessageElementObject *self, PyObject *args)
1831 {
1832 int flags;
1833 struct ldb_message_element *el;
1834 if (!PyArg_ParseTuple(args, "i", &flags))
1835 return NULL;
1836
1837 el = PyLdbMessageElement_AsMessageElement(self);
1838 el->flags = flags;
1839 Py_RETURN_NONE;
1840 }
1841
1842 static PyMethodDef py_ldb_msg_element_methods[] = {
1843 { "get", (PyCFunction)py_ldb_msg_element_get, METH_VARARGS, NULL },
1844 { "set_flags", (PyCFunction)py_ldb_msg_element_set_flags, METH_VARARGS, NULL },
1845 { "flags", (PyCFunction)py_ldb_msg_element_flags, METH_NOARGS, NULL },
1846 { NULL },
1847 };
1848
1849 static Py_ssize_t py_ldb_msg_element_len(PyLdbMessageElementObject *self)
1850 {
1851 return PyLdbMessageElement_AsMessageElement(self)->num_values;
1852 }
1853
1854 static PyObject *py_ldb_msg_element_find(PyLdbMessageElementObject *self, Py_ssize_t idx)
1855 {
1856 struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
1857 if (idx < 0 || idx >= el->num_values) {
1858 PyErr_SetString(PyExc_IndexError, "Out of range");
1859 return NULL;
1860 }
1861 return PyString_FromStringAndSize((char *)el->values[idx].data, el->values[idx].length);
1862 }
1863
1864 static PySequenceMethods py_ldb_msg_element_seq = {
1865 .sq_length = (lenfunc)py_ldb_msg_element_len,
1866 .sq_item = (ssizeargfunc)py_ldb_msg_element_find,
1867 };
1868
1869 static int py_ldb_msg_element_cmp(PyLdbMessageElementObject *self, PyLdbMessageElementObject *other)
1870 {
1871 return ldb_msg_element_compare(PyLdbMessageElement_AsMessageElement(self),
1872 PyLdbMessageElement_AsMessageElement(other));
1873 }
1874
1875 static PyObject *py_ldb_msg_element_iter(PyLdbMessageElementObject *self)
1876 {
1877 return PyObject_GetIter(ldb_msg_element_to_set(NULL, PyLdbMessageElement_AsMessageElement(self)));
1878 }
1879
1880 static PyObject *PyLdbMessageElement_FromMessageElement(struct ldb_message_element *el, TALLOC_CTX *mem_ctx)
1881 {
1882 PyLdbMessageElementObject *ret;
1883 ret = PyObject_New(PyLdbMessageElementObject, &PyLdbMessageElement);
1884 if (ret == NULL) {
1885 PyErr_NoMemory();
1886 return NULL;
1887 }
1888 ret->mem_ctx = talloc_new(NULL);
1889 if (talloc_reference(ret->mem_ctx, mem_ctx) == NULL) {
1890 PyErr_NoMemory();
1891 return NULL;
1892 }
1893 ret->el = el;
1894 return (PyObject *)ret;
1895 }
1896
1897 static PyObject *py_ldb_msg_element_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1898 {
1899 PyObject *py_elements = NULL;
1900 struct ldb_message_element *el;
1901 int flags = 0;
1902 char *name = NULL;
1903 const char * const kwnames[] = { "elements", "flags", "name", NULL };
1904 PyLdbMessageElementObject *ret;
1905 TALLOC_CTX *mem_ctx;
1906
1907 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Ois",
1908 discard_const_p(char *, kwnames),
1909 &py_elements, &flags, &name))
1910 return NULL;
1911
1912 mem_ctx = talloc_new(NULL);
1913 if (mem_ctx == NULL) {
1914 PyErr_NoMemory();
1915 return NULL;
1916 }
1917
1918 el = talloc_zero(mem_ctx, struct ldb_message_element);
1919 if (el == NULL) {
1920 PyErr_NoMemory();
1921 talloc_free(mem_ctx);
1922 return NULL;
1923 }
1924
1925 if (py_elements != NULL) {
1926 Py_ssize_t i;
1927 if (PyString_Check(py_elements)) {
1928 el->num_values = 1;
1929 el->values = talloc_array(el, struct ldb_val, 1);
1930 if (el->values == NULL) {
1931 talloc_free(mem_ctx);
1932 PyErr_NoMemory();
1933 return NULL;
1934 }
1935 el->values[0].length = PyString_Size(py_elements);
1936 el->values[0].data = talloc_memdup(el->values,
1937 (uint8_t *)PyString_AsString(py_elements), el->values[0].length+1);
1938 } else if (PySequence_Check(py_elements)) {
1939 el->num_values = PySequence_Size(py_elements);
1940 el->values = talloc_array(el, struct ldb_val, el->num_values);
1941 if (el->values == NULL) {
1942 talloc_free(mem_ctx);
1943 PyErr_NoMemory();
1944 return NULL;
1945 }
1946 for (i = 0; i < el->num_values; i++) {
1947 PyObject *item = PySequence_GetItem(py_elements, i);
1948 if (item == NULL) {
1949 talloc_free(mem_ctx);
1950 return NULL;
1951 }
1952 if (!PyString_Check(item)) {
1953 PyErr_Format(PyExc_TypeError,
1954 "Expected string as element %zd in list", i);
1955 talloc_free(mem_ctx);
1956 return NULL;
1957 }
1958 el->values[i].length = PyString_Size(item);
1959 el->values[i].data = talloc_memdup(el,
1960 (uint8_t *)PyString_AsString(item), el->values[i].length+1);
1961 }
1962 } else {
1963 PyErr_SetString(PyExc_TypeError,
1964 "Expected string or list");
1965 talloc_free(mem_ctx);
1966 return NULL;
1967 }
1968 }
1969
1970 el->flags = flags;
1971 el->name = talloc_strdup(el, name);
1972
1973 ret = PyObject_New(PyLdbMessageElementObject, type);
1974 if (ret == NULL) {
1975 talloc_free(mem_ctx);
1976 return NULL;
1977 }
1978
1979 ret->mem_ctx = mem_ctx;
1980 ret->el = el;
1981 return (PyObject *)ret;
1982 }
1983
1984 static PyObject *py_ldb_msg_element_repr(PyLdbMessageElementObject *self)
1985 {
1986 char *element_str = NULL;
1987 Py_ssize_t i;
1988 struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
1989 PyObject *ret;
1990
1991 for (i = 0; i < el->num_values; i++) {
1992 PyObject *o = py_ldb_msg_element_find(self, i);
1993 if (element_str == NULL)
1994 element_str = talloc_strdup(NULL, PyObject_REPR(o));
1995 else
1996 element_str = talloc_asprintf_append(element_str, ",%s", PyObject_REPR(o));
1997 }
1998
1999 if (element_str != NULL) {
2000 ret = PyString_FromFormat("MessageElement([%s])", element_str);
2001 talloc_free(element_str);
2002 } else {
2003 ret = PyString_FromString("MessageElement([])");
2004 }
2005
2006 return ret;
2007 }
2008
2009 static PyObject *py_ldb_msg_element_str(PyLdbMessageElementObject *self)
2010 {
2011 struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
2012
2013 if (el->num_values == 1)
2014 return PyString_FromStringAndSize((char *)el->values[0].data, el->values[0].length);
2015 else
2016 Py_RETURN_NONE;
2017 }
2018
2019 static void py_ldb_msg_element_dealloc(PyLdbMessageElementObject *self)
2020 {
2021 talloc_free(self->mem_ctx);
2022 PyObject_Del(self);
2023 }
2024
2025 static PyTypeObject PyLdbMessageElement = {
2026 .tp_name = "ldb.MessageElement",
2027 .tp_basicsize = sizeof(PyLdbMessageElementObject),
2028 .tp_dealloc = (destructor)py_ldb_msg_element_dealloc,
2029 .tp_repr = (reprfunc)py_ldb_msg_element_repr,
2030 .tp_str = (reprfunc)py_ldb_msg_element_str,
2031 .tp_methods = py_ldb_msg_element_methods,
2032 .tp_compare = (cmpfunc)py_ldb_msg_element_cmp,
2033 .tp_iter = (getiterfunc)py_ldb_msg_element_iter,
2034 .tp_as_sequence = &py_ldb_msg_element_seq,
2035 .tp_new = py_ldb_msg_element_new,
2036 .tp_flags = Py_TPFLAGS_DEFAULT,
2037 };
2038
2039
2040 static PyObject *py_ldb_msg_from_dict(PyTypeObject *type, PyObject *args)
2041 {
2042 PyObject *py_ldb;
2043 PyObject *py_dict;
2044 PyObject *py_ret;
2045 struct ldb_message *msg;
2046 struct ldb_context *ldb_ctx;
2047 unsigned int mod_flags = LDB_FLAG_MOD_REPLACE;
2048
2049 if (!PyArg_ParseTuple(args, "O!O!|I",
2050 &PyLdb, &py_ldb, &PyDict_Type, &py_dict,
2051 &mod_flags)) {
2052 return NULL;
2053 }
2054
2055 /* mask only flags we are going to use */
2056 mod_flags = LDB_FLAG_MOD_TYPE(mod_flags);
2057 if (!mod_flags) {
2058 PyErr_SetString(PyExc_ValueError,
2059 "FLAG_MOD_ADD, FLAG_MOD_REPLACE or FLAG_MOD_DELETE"
2060 " expected as mod_flag value");
2061 return NULL;
2062 }
2063
2064 ldb_ctx = PyLdb_AsLdbContext(py_ldb);
2065
2066 msg = PyDict_AsMessage(ldb_ctx, py_dict, ldb_ctx, mod_flags);
2067 if (!msg) {
2068 return NULL;
2069 }
2070
2071 py_ret = PyLdbMessage_FromMessage(msg);
2072
2073 talloc_unlink(ldb_ctx, msg);
2074
2075 return py_ret;
2076 }
2077
2078 static PyObject *py_ldb_msg_remove_attr(PyLdbMessageObject *self, PyObject *args)
2079 {
2080 char *name;
2081 if (!PyArg_ParseTuple(args, "s", &name))
2082 return NULL;
2083
2084 ldb_msg_remove_attr(self->msg, name);
2085
2086 Py_RETURN_NONE;
2087 }
2088
2089 static PyObject *py_ldb_msg_keys(PyLdbMessageObject *self)
2090 {
2091 struct ldb_message *msg = PyLdbMessage_AsMessage(self);
2092 Py_ssize_t i, j = 0;
2093 PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
2094 if (msg->dn != NULL) {
2095 PyList_SetItem(obj, j, PyString_FromString("dn"));
2096 j++;
2097 }
2098 for (i = 0; i < msg->num_elements; i++) {
2099 PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
2100 j++;
2101 }
2102 return obj;
2103 }
2104
2105 static PyObject *py_ldb_msg_getitem_helper(PyLdbMessageObject *self, PyObject *py_name)
2106 {
2107 struct ldb_message_element *el;
2108 char *name;
2109 struct ldb_message *msg = PyLdbMessage_AsMessage(self);
2110 if (!PyString_Check(py_name)) {
2111 PyErr_SetNone(PyExc_TypeError);
2112 return NULL;
2113 }
2114 name = PyString_AsString(py_name);
2115 if (!strcmp(name, "dn"))
2116 return PyLdbDn_FromDn(msg->dn);
2117 el = ldb_msg_find_element(msg, name);
2118 if (el == NULL) {
2119 return NULL;
2120 }
2121 return (PyObject *)PyLdbMessageElement_FromMessageElement(el, msg->elements);
2122 }
2123
2124 static PyObject *py_ldb_msg_getitem(PyLdbMessageObject *self, PyObject *py_name)
2125 {
2126 PyObject *ret = py_ldb_msg_getitem_helper(self, py_name);
2127 if (ret == NULL) {
2128 PyErr_SetString(PyExc_KeyError, "No such element");
2129 return NULL;
2130 }
2131 return ret;
2132 }
2133
2134 static PyObject *py_ldb_msg_get(PyLdbMessageObject *self, PyObject *args)
2135 {
2136 PyObject *name, *ret;
2137 if (!PyArg_ParseTuple(args, "O", &name))
2138 return NULL;
2139
2140 ret = py_ldb_msg_getitem_helper(self, name);
2141 if (ret == NULL) {
2142 if (PyErr_Occurred())
2143 return NULL;
2144 Py_RETURN_NONE;
2145 }
2146 return ret;
2147 }
2148
2149 static PyObject *py_ldb_msg_items(PyLdbMessageObject *self)
2150 {
2151 struct ldb_message *msg = PyLdbMessage_AsMessage(self);
2152 Py_ssize_t i, j = 0;
2153 PyObject *l = PyList_New(msg->num_elements + (msg->dn == NULL?0:1));
2154 if (msg->dn != NULL) {
2155 PyList_SetItem(l, 0, Py_BuildValue("(sO)", "dn", PyLdbDn_FromDn(msg->dn)));
2156 j++;
2157 }
2158 for (i = 0; i < msg->num_elements; i++, j++) {
2159 PyObject *py_el = PyLdbMessageElement_FromMessageElement(&msg->elements[i], msg->elements);
2160 PyObject *value = Py_BuildValue("(sO)", msg->elements[i].name, py_el);
2161 PyList_SetItem(l, j, value);
2162 }
2163 return l;
2164 }
2165
2166 static PyObject *py_ldb_msg_elements(PyLdbMessageObject *self)
2167 {
2168 struct ldb_message *msg = PyLdbMessage_AsMessage(self);
2169 Py_ssize_t i = 0;
2170 PyObject *l = PyList_New(msg->num_elements);
2171 for (i = 0; i < msg->num_elements; i++) {
2172 PyList_SetItem(l, i, PyLdbMessageElement_FromMessageElement(&msg->elements[i], msg->elements));
2173 }
2174 return l;
2175 }
2176
2177 static PyObject *py_ldb_msg_add(PyLdbMessageObject *self, PyObject *args)
2178 {
2179 struct ldb_message *msg = PyLdbMessage_AsMessage(self);
2180 PyLdbMessageElementObject *py_element;
2181 int ret;
2182 struct ldb_message_element *el;
2183
2184 if (!PyArg_ParseTuple(args, "O!", &PyLdbMessageElement, &py_element))
2185 return NULL;
2186
2187 el = talloc_reference(msg, py_element->mem_ctx);
2188 if (el == NULL) {
2189 PyErr_NoMemory();
2190 return NULL;
2191 }
2192
2193 ret = ldb_msg_add(msg, el, el->flags);
2194 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, NULL);
2195
2196 Py_RETURN_NONE;
2197 }
2198
2199 static PyMethodDef py_ldb_msg_methods[] = {
2200 { "from_dict", (PyCFunction)py_ldb_msg_from_dict, METH_CLASS | METH_VARARGS,
2201 "Message.from_dict(ldb, dict, mod_flag=FLAG_MOD_REPLACE) -> ldb.Message\n"
2202 "Class method to create ldb.Message object from Dictionary.\n"
2203 "mod_flag is one of FLAG_MOD_ADD, FLAG_MOD_REPLACE or FLAG_MOD_DELETE."},
2204 { "keys", (PyCFunction)py_ldb_msg_keys, METH_NOARGS,
2205 "S.keys() -> list\n\n"
2206 "Return sequence of all attribute names." },
2207 { "remove", (PyCFunction)py_ldb_msg_remove_attr, METH_VARARGS,
2208 "S.remove(name)\n\n"
2209 "Remove all entries for attributes with the specified name."},
2210 { "get", (PyCFunction)py_ldb_msg_get, METH_VARARGS, NULL },
2211 { "items", (PyCFunction)py_ldb_msg_items, METH_NOARGS, NULL },
2212 { "elements", (PyCFunction)py_ldb_msg_elements, METH_NOARGS, NULL },
2213 { "add", (PyCFunction)py_ldb_msg_add, METH_VARARGS,
2214 "S.append(element)\n\n"
2215 "Add an element to this message." },
2216 { NULL },
2217 };
2218
2219 static PyObject *py_ldb_msg_iter(PyLdbMessageObject *self)
2220 {
2221 PyObject *list, *iter;
2222
2223 list = py_ldb_msg_keys(self);
2224 iter = PyObject_GetIter(list);
2225 Py_DECREF(list);
2226 return iter;
2227 }
2228
2229 static int py_ldb_msg_setitem(PyLdbMessageObject *self, PyObject *name, PyObject *value)
2230 {
2231 char *attr_name;
2232
2233 if (!PyString_Check(name)) {
2234 PyErr_SetNone(PyExc_TypeError);
2235 return -1;
2236 }
2237
2238 attr_name = PyString_AsString(name);
2239 if (value == NULL) {
2240 /* delitem */
2241 ldb_msg_remove_attr(self->msg, attr_name);
2242 } else {
2243 struct ldb_message_element *el = PyObject_AsMessageElement(self->msg,
2244 value, 0, attr_name);
2245 if (el == NULL)
2246 return -1;
2247 ldb_msg_remove_attr(PyLdbMessage_AsMessage(self), attr_name);
2248 ldb_msg_add(PyLdbMessage_AsMessage(self), el, el->flags);
2249 }
2250 return 0;
2251 }
2252
2253 static Py_ssize_t py_ldb_msg_length(PyLdbMessageObject *self)
2254 {
2255 return PyLdbMessage_AsMessage(self)->num_elements;
2256 }
2257
2258 static PyMappingMethods py_ldb_msg_mapping = {
2259 .mp_length = (lenfunc)py_ldb_msg_length,
2260 .mp_subscript = (binaryfunc)py_ldb_msg_getitem,
2261 .mp_ass_subscript = (objobjargproc)py_ldb_msg_setitem,
2262 };
2263
2264 static PyObject *py_ldb_msg_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2265 {
2266 const char * const kwnames[] = { "dn", NULL };
2267 struct ldb_message *ret;
2268 TALLOC_CTX *mem_ctx;
2269 PyObject *pydn = NULL;
2270 PyLdbMessageObject *py_ret;
2271
2272 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O",
2273 discard_const_p(char *, kwnames),
2274 &pydn))
2275 return NULL;
2276
2277 mem_ctx = talloc_new(NULL);
2278 if (mem_ctx == NULL) {
2279 PyErr_NoMemory();
2280 return NULL;
2281 }
2282
2283 ret = ldb_msg_new(mem_ctx);
2284 if (ret == NULL) {
2285 talloc_free(mem_ctx);
2286 PyErr_NoMemory();
2287 return NULL;
2288 }
2289
2290 if (pydn != NULL) {
2291 struct ldb_dn *dn;
2292 if (!PyObject_AsDn(NULL, pydn, NULL, &dn)) {
2293 talloc_free(mem_ctx);
2294 return NULL;
2295 }
2296 ret->dn = talloc_reference(ret, dn);
2297 }
2298
2299 py_ret = (PyLdbMessageObject *)type->tp_alloc(type, 0);
2300 if (py_ret == NULL) {
2301 PyErr_NoMemory();
2302 talloc_free(mem_ctx);
2303 return NULL;
2304 }
2305
2306 py_ret->mem_ctx = mem_ctx;
2307 py_ret->msg = ret;
2308 return (PyObject *)py_ret;
2309 }
2310
2311 static PyObject *PyLdbMessage_FromMessage(struct ldb_message *msg)
2312 {
2313 PyLdbMessageObject *ret;
2314
2315 ret = (PyLdbMessageObject *)PyLdbMessage.tp_alloc(&PyLdbMessage, 0);
2316 if (ret == NULL) {
2317 PyErr_NoMemory();
2318 return NULL;
2319 }
2320 ret->mem_ctx = talloc_new(NULL);
2321 ret->msg = talloc_reference(ret->mem_ctx, msg);
2322 return (PyObject *)ret;
2323 }
2324
2325 static PyObject *py_ldb_msg_get_dn(PyLdbMessageObject *self, void *closure)
2326 {
2327 struct ldb_message *msg = PyLdbMessage_AsMessage(self);
2328 return PyLdbDn_FromDn(msg->dn);
2329 }
2330
2331 static int py_ldb_msg_set_dn(PyLdbMessageObject *self, PyObject *value, void *closure)
2332 {
2333 struct ldb_message *msg = PyLdbMessage_AsMessage(self);
2334 if (!PyLdbDn_Check(value)) {
2335 PyErr_SetNone(PyExc_TypeError);
2336 return -1;
2337 }
2338
2339 msg->dn = talloc_reference(msg, PyLdbDn_AsDn(value));
2340 return 0;
2341 }
2342
2343 static PyGetSetDef py_ldb_msg_getset[] = {
2344 { discard_const_p(char, "dn"), (getter)py_ldb_msg_get_dn, (setter)py_ldb_msg_set_dn, NULL },
2345 { NULL }
2346 };
2347
2348 static PyObject *py_ldb_msg_repr(PyLdbMessageObject *self)
2349 {
2350 PyObject *dict = PyDict_New(), *ret;
2351 if (PyDict_Update(dict, (PyObject *)self) != 0)
2352 return NULL;
2353 ret = PyString_FromFormat("Message(%s)", PyObject_REPR(dict));
2354 Py_DECREF(dict);
2355 return ret;
2356 }
2357
2358 static void py_ldb_msg_dealloc(PyLdbMessageObject *self)
2359 {
2360 talloc_free(self->mem_ctx);
2361 PyObject_Del(self);
2362 }
2363
2364 static int py_ldb_msg_compare(PyLdbMessageObject *py_msg1,
2365 PyLdbMessageObject *py_msg2)
2366 {
2367 struct ldb_message *msg1 = PyLdbMessage_AsMessage(py_msg1),
2368 *msg2 = PyLdbMessage_AsMessage(py_msg2);
2369 unsigned int i;
2370 int ret;
2371
2372 if ((msg1->dn != NULL) || (msg2->dn != NULL)) {
2373 ret = ldb_dn_compare(msg1->dn, msg2->dn);
2374 if (ret != 0) {
2375 return ret;
2376 }
2377 }
2378
2379 ret = msg1->num_elements - msg2->num_elements;
2380 if (ret != 0) {
2381 return ret;
2382 }
2383
2384 for (i = 0; i < msg1->num_elements; i++) {
2385 ret = ldb_msg_element_compare_name(&msg1->elements[i],
2386 &msg2->elements[i]);
2387 if (ret != 0) {
2388 return ret;
2389 }
2390
2391 ret = ldb_msg_element_compare(&msg1->elements[i],
2392 &msg2->elements[i]);
2393 if (ret != 0) {
2394 return ret;
2395 }
2396 }
2397
2398 return 0;
2399 }
2400
2401 static PyTypeObject PyLdbMessage = {
2402 .tp_name = "ldb.Message",
2403 .tp_methods = py_ldb_msg_methods,
2404 .tp_getset = py_ldb_msg_getset,
2405 .tp_as_mapping = &py_ldb_msg_mapping,
2406 .tp_basicsize = sizeof(PyLdbMessageObject),
2407 .tp_dealloc = (destructor)py_ldb_msg_dealloc,
2408 .tp_new = py_ldb_msg_new,
2409 .tp_repr = (reprfunc)py_ldb_msg_repr,
2410 .tp_flags = Py_TPFLAGS_DEFAULT,
2411 .tp_iter = (getiterfunc)py_ldb_msg_iter,
2412 .tp_compare = (cmpfunc)py_ldb_msg_compare,
2413 };
2414
2415 static PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *tree)
2416 {
2417 PyLdbTreeObject *ret;
2418
2419 ret = (PyLdbTreeObject *)PyLdbTree.tp_alloc(&PyLdbTree, 0);
2420 if (ret == NULL) {
2421 PyErr_NoMemory();
2422 return NULL;
2423 }
2424
2425 ret->mem_ctx = talloc_new(NULL);
2426 ret->tree = talloc_reference(ret->mem_ctx, tree);
2427 return (PyObject *)ret;
2428 }
2429
2430 static void py_ldb_tree_dealloc(PyLdbTreeObject *self)
2431 {
2432 talloc_free(self->mem_ctx);
2433 PyObject_Del(self);
2434 }
2435
2436 static PyTypeObject PyLdbTree = {
2437 .tp_name = "ldb.Tree",
2438 .tp_basicsize = sizeof(PyLdbTreeObject),
2439 .tp_dealloc = (destructor)py_ldb_tree_dealloc,
2440 .tp_flags = Py_TPFLAGS_DEFAULT,
2441 };
2442
2443 /* Ldb_module */
2444 static int py_module_search(struct ldb_module *mod, struct ldb_request *req)
2445 {
2446 PyObject *py_ldb = (PyObject *)mod->private_data;
2447 PyObject *py_result, *py_base, *py_attrs, *py_tree;
2448
2449 py_base = PyLdbDn_FromDn(req->op.search.base);
2450
2451 if (py_base == NULL)
2452 return LDB_ERR_OPERATIONS_ERROR;
2453
2454 py_tree = PyLdbTree_FromTree(req->op.search.tree);
2455
2456 if (py_tree == NULL)
2457 return LDB_ERR_OPERATIONS_ERROR;
2458
2459 if (req->op.search.attrs == NULL) {
2460 py_attrs = Py_None;
2461 } else {
2462 int i, len;
2463 for (len = 0; req->op.search.attrs[len]; len++);
2464 py_attrs = PyList_New(len);
2465 for (i = 0; i < len; i++)
2466 PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
2467 }
2468
2469 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "search"),
2470 discard_const_p(char, "OiOO"),
2471 py_base, req->op.search.scope, py_tree, py_attrs);
2472
2473 Py_DECREF(py_attrs);
2474 Py_DECREF(py_tree);
2475 Py_DECREF(py_base);
2476
2477 if (py_result == NULL) {
2478 return LDB_ERR_PYTHON_EXCEPTION;
2479 }
2480
2481 req->op.search.res = PyLdbResult_AsResult(NULL, py_result);
2482 if (req->op.search.res == NULL) {
2483 return LDB_ERR_PYTHON_EXCEPTION;
2484 }
2485
2486 Py_DECREF(py_result);
2487
2488 return LDB_SUCCESS;
2489 }
2490
2491 static int py_module_add(struct ldb_module *mod, struct ldb_request *req)
2492 {
2493 PyObject *py_ldb = (PyObject *)mod->private_data;
2494 PyObject *py_result, *py_msg;
2495
2496 py_msg = PyLdbMessage_FromMessage(discard_const_p(struct ldb_message, req->op.add.message));
2497
2498 if (py_msg == NULL) {
2499 return LDB_ERR_OPERATIONS_ERROR;
2500 }
2501
2502 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "add"),
2503 discard_const_p(char, "O"),
2504 py_msg);
2505
2506 Py_DECREF(py_msg);
2507
2508 if (py_result == NULL) {
2509 return LDB_ERR_PYTHON_EXCEPTION;
2510 }
2511
2512 Py_DECREF(py_result);
2513
2514 return LDB_SUCCESS;
2515 }
2516
2517 static int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
2518 {
2519 PyObject *py_ldb = (PyObject *)mod->private_data;
2520 PyObject *py_result, *py_msg;
2521
2522 py_msg = PyLdbMessage_FromMessage(discard_const_p(struct ldb_message, req->op.mod.message));
2523
2524 if (py_msg == NULL) {
2525 return LDB_ERR_OPERATIONS_ERROR;
2526 }
2527
2528 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "modify"),
2529 discard_const_p(char, "O"),
2530 py_msg);
2531
2532 Py_DECREF(py_msg);
2533
2534 if (py_result == NULL) {
2535 return LDB_ERR_PYTHON_EXCEPTION;
2536 }
2537
2538 Py_DECREF(py_result);
2539
2540 return LDB_SUCCESS;
2541 }
2542
2543 static int py_module_del(struct ldb_module *mod, struct ldb_request *req)
2544 {
2545 PyObject *py_ldb = (PyObject *)mod->private_data;
2546 PyObject *py_result, *py_dn;
2547
2548 py_dn = PyLdbDn_FromDn(req->op.del.dn);
2549
2550 if (py_dn == NULL)
2551 return LDB_ERR_OPERATIONS_ERROR;
2552
2553 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "delete"),
2554 discard_const_p(char, "O"),
2555 py_dn);
2556
2557 if (py_result == NULL) {
2558 return LDB_ERR_PYTHON_EXCEPTION;
2559 }
2560
2561 Py_DECREF(py_result);
2562
2563 return LDB_SUCCESS;
2564 }
2565
2566 static int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
2567 {
2568 PyObject *py_ldb = (PyObject *)mod->private_data;
2569 PyObject *py_result, *py_olddn, *py_newdn;
2570
2571 py_olddn = PyLdbDn_FromDn(req->op.rename.olddn);
2572
2573 if (py_olddn == NULL)
2574 return LDB_ERR_OPERATIONS_ERROR;
2575
2576 py_newdn = PyLdbDn_FromDn(req->op.rename.newdn);
2577
2578 if (py_newdn == NULL)
2579 return LDB_ERR_OPERATIONS_ERROR;
2580
2581 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "rename"),
2582 discard_const_p(char, "OO"),
2583 py_olddn, py_newdn);
2584
2585 Py_DECREF(py_olddn);
2586 Py_DECREF(py_newdn);
2587
2588 if (py_result == NULL) {
2589 return LDB_ERR_PYTHON_EXCEPTION;
2590 }
2591
2592 Py_DECREF(py_result);
2593
2594 return LDB_SUCCESS;
2595 }
2596
2597 static int py_module_request(struct ldb_module *mod, struct ldb_request *req)
2598 {
2599 PyObject *py_ldb = (PyObject *)mod->private_data;
2600 PyObject *py_result;
2601
2602 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "request"),
2603 discard_const_p(char, ""));
2604
2605 return LDB_ERR_OPERATIONS_ERROR;
2606 }
2607
2608 static int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
2609 {
2610 PyObject *py_ldb = (PyObject *)mod->private_data;
2611 PyObject *py_result;
2612
2613 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "extended"),
2614 discard_const_p(char, ""));
2615
2616 return LDB_ERR_OPERATIONS_ERROR;
2617 }
2618
2619 static int py_module_start_transaction(struct ldb_module *mod)
2620 {
2621 PyObject *py_ldb = (PyObject *)mod->private_data;
2622 PyObject *py_result;
2623
2624 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "start_transaction"),
2625 discard_const_p(char, ""));
2626
2627 if (py_result == NULL) {
2628 return LDB_ERR_PYTHON_EXCEPTION;
2629 }
2630
2631 Py_DECREF(py_result);
2632
2633 return LDB_SUCCESS;
2634 }
2635
2636 static int py_module_end_transaction(struct ldb_module *mod)
2637 {
2638 PyObject *py_ldb = (PyObject *)mod->private_data;
2639 PyObject *py_result;
2640
2641 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "end_transaction"),
2642 discard_const_p(char, ""));
2643
2644 if (py_result == NULL) {
2645 return LDB_ERR_PYTHON_EXCEPTION;
2646 }
2647
2648 Py_DECREF(py_result);
2649
2650 return LDB_SUCCESS;
2651 }
2652
2653 static int py_module_del_transaction(struct ldb_module *mod)
2654 {
2655 PyObject *py_ldb = (PyObject *)mod->private_data;
2656 PyObject *py_result;
2657
2658 py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "del_transaction"),
2659 discard_const_p(char, ""));
2660
2661 if (py_result == NULL) {
2662 return LDB_ERR_PYTHON_EXCEPTION;
2663 }
2664
2665 Py_DECREF(py_result);
2666
2667 return LDB_SUCCESS;
2668 }
2669
2670 static int py_module_destructor(struct ldb_module *mod)
2671 {
2672 Py_DECREF((PyObject *)mod->private_data);
2673 return 0;
2674 }
2675
2676 static int py_module_init(struct ldb_module *mod)
2677 {
2678 PyObject *py_class = (PyObject *)mod->ops->private_data;
2679 PyObject *py_result, *py_next, *py_ldb;
2680
2681 py_ldb = PyLdb_FromLdbContext(mod->ldb);
2682
2683 if (py_ldb == NULL)
2684 return LDB_ERR_OPERATIONS_ERROR;
2685
2686 py_next = PyLdbModule_FromModule(mod->next);
2687
2688 if (py_next == NULL)
2689 return LDB_ERR_OPERATIONS_ERROR;
2690
2691 py_result = PyObject_CallFunction(py_class, discard_const_p(char, "OO"),
2692 py_ldb, py_next);
2693
2694 if (py_result == NULL) {
2695 return LDB_ERR_PYTHON_EXCEPTION;
2696 }
2697
2698 mod->private_data = py_result;
2699
2700 talloc_set_destructor(mod, py_module_destructor);
2701
2702 return ldb_next_init(mod);
2703 }
2704
2705 static PyObject *py_register_module(PyObject *module, PyObject *args)
2706 {
2707 int ret;
2708 struct ldb_module_ops *ops;
2709 PyObject *input;
2710
2711 if (!PyArg_ParseTuple(args, "O", &input))
2712 return NULL;
2713
2714 ops = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
2715 if (ops == NULL) {
2716 PyErr_NoMemory();
2717 return NULL;
2718 }
2719
2720 ops->name = talloc_strdup(ops, PyString_AsString(PyObject_GetAttrString(input, discard_const_p(char, "name"))));
2721
2722 Py_INCREF(input);
2723 ops->private_data = input;
2724 ops->init_context = py_module_init;
2725 ops->search = py_module_search;
2726 ops->add = py_module_add;
2727 ops->modify = py_module_modify;
2728 ops->del = py_module_del;
2729 ops->rename = py_module_rename;
2730 ops->request = py_module_request;
2731 ops->extended = py_module_extended;
2732 ops->start_transaction = py_module_start_transaction;
2733 ops->end_transaction = py_module_end_transaction;
2734 ops->del_transaction = py_module_del_transaction;
2735
2736 ret = ldb_register_module(ops);
2737
2738 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, NULL);
2739
2740 Py_RETURN_NONE;
2741 }
2742
2743 static PyObject *py_timestring(PyObject *module, PyObject *args)
2744 {
2745 /* most times "time_t" is a signed integer type with 32 or 64 bit:
2746 * http://stackoverflow.com/questions/471248/what-is-ultimately-a-time-t-typedef-to */
2747 long int t_val;
2748 char *tresult;
2749 PyObject *ret;
2750 if (!PyArg_ParseTuple(args, "l", &t_val))
2751 return NULL;
2752 tresult = ldb_timestring(NULL, (time_t) t_val);
2753 ret = PyString_FromString(tresult);
2754 talloc_free(tresult);
2755 return ret;
2756 }
2757
2758 static PyObject *py_string_to_time(PyObject *module, PyObject *args)
2759 {
2760 char *str;
2761 if (!PyArg_ParseTuple(args, "s", &str))
2762 return NULL;
2763
2764 return PyInt_FromLong(ldb_string_to_time(str));
2765 }
2766
2767 static PyObject *py_valid_attr_name(PyObject *self, PyObject *args)
2768 {
2769 char *name;
2770 if (!PyArg_ParseTuple(args, "s", &name))
2771 return NULL;
2772 return PyBool_FromLong(ldb_valid_attr_name(name));
2773 }
2774
2775 static PyMethodDef py_ldb_global_methods[] = {
2776 { "register_module", py_register_module, METH_VARARGS,
2777 "S.register_module(module) -> None\n"
2778 "Register a LDB module."},
2779 { "timestring", py_timestring, METH_VARARGS,
2780 "S.timestring(int) -> string\n"
2781 "Generate a LDAP time string from a UNIX timestamp" },
2782 { "string_to_time", py_string_to_time, METH_VARARGS,
2783 "S.string_to_time(string) -> int\n"
2784 "Parse a LDAP time string into a UNIX timestamp." },
2785 { "valid_attr_name", py_valid_attr_name, METH_VARARGS,
2786 "S.valid_attr_name(name) -> bool\n"
2787 "Check whether the supplied name is a valid attribute name." },
2788 { "open", (PyCFunction)py_ldb_new, METH_VARARGS|METH_KEYWORDS,
2789 NULL },
2790 { NULL }
2791 };
2792
2793 void initldb(void)
2794 {
2795 PyObject *m;
2796
2797 if (PyType_Ready(&PyLdbDn) < 0)
2798 return;
2799
2800 if (PyType_Ready(&PyLdbMessage) < 0)
2801 return;
2802
2803 if (PyType_Ready(&PyLdbMessageElement) < 0)
2804 return;
2805
2806 if (PyType_Ready(&PyLdb) < 0)
2807 return;
2808
2809 if (PyType_Ready(&PyLdbModule) < 0)
2810 return;
2811
2812 if (PyType_Ready(&PyLdbTree) < 0)
2813 return;
2814
2815 m = Py_InitModule3("ldb", py_ldb_global_methods,
2816 "An interface to LDB, a LDAP-like API that can either to talk an embedded database (TDB-based) or a standards-compliant LDAP server.");
2817 if (m == NULL)
2818 return;
2819
2820 PyModule_AddObject(m, "SEQ_HIGHEST_SEQ", PyInt_FromLong(LDB_SEQ_HIGHEST_SEQ));
2821 PyModule_AddObject(m, "SEQ_HIGHEST_TIMESTAMP", PyInt_FromLong(LDB_SEQ_HIGHEST_TIMESTAMP));
2822 PyModule_AddObject(m, "SEQ_NEXT", PyInt_FromLong(LDB_SEQ_NEXT));
2823 PyModule_AddObject(m, "SCOPE_DEFAULT", PyInt_FromLong(LDB_SCOPE_DEFAULT));
2824 PyModule_AddObject(m, "SCOPE_BASE", PyInt_FromLong(LDB_SCOPE_BASE));
2825 PyModule_AddObject(m, "SCOPE_ONELEVEL", PyInt_FromLong(LDB_SCOPE_ONELEVEL));
2826 PyModule_AddObject(m, "SCOPE_SUBTREE", PyInt_FromLong(LDB_SCOPE_SUBTREE));
2827
2828 PyModule_AddObject(m, "CHANGETYPE_NONE", PyInt_FromLong(LDB_CHANGETYPE_NONE));
2829 PyModule_AddObject(m, "CHANGETYPE_ADD", PyInt_FromLong(LDB_CHANGETYPE_ADD));
2830 PyModule_AddObject(m, "CHANGETYPE_DELETE", PyInt_FromLong(LDB_CHANGETYPE_DELETE));
2831 PyModule_AddObject(m, "CHANGETYPE_MODIFY", PyInt_FromLong(LDB_CHANGETYPE_MODIFY));
2832
2833 PyModule_AddObject(m, "FLAG_MOD_ADD", PyInt_FromLong(LDB_FLAG_MOD_ADD));
2834 PyModule_AddObject(m, "FLAG_MOD_REPLACE", PyInt_FromLong(LDB_FLAG_MOD_REPLACE));
2835 PyModule_AddObject(m, "FLAG_MOD_DELETE", PyInt_FromLong(LDB_FLAG_MOD_DELETE));
2836
2837 PyModule_AddObject(m, "SUCCESS", PyInt_FromLong(LDB_SUCCESS));
2838 PyModule_AddObject(m, "ERR_OPERATIONS_ERROR", PyInt_FromLong(LDB_ERR_OPERATIONS_ERROR));
2839 PyModule_AddObject(m, "ERR_PROTOCOL_ERROR", PyInt_FromLong(LDB_ERR_PROTOCOL_ERROR));
2840 PyModule_AddObject(m, "ERR_TIME_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_TIME_LIMIT_EXCEEDED));
2841 PyModule_AddObject(m, "ERR_SIZE_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_SIZE_LIMIT_EXCEEDED));
2842 PyModule_AddObject(m, "ERR_COMPARE_FALSE", PyInt_FromLong(LDB_ERR_COMPARE_FALSE));
2843 PyModule_AddObject(m, "ERR_COMPARE_TRUE", PyInt_FromLong(LDB_ERR_COMPARE_TRUE));
2844 PyModule_AddObject(m, "ERR_AUTH_METHOD_NOT_SUPPORTED", PyInt_FromLong(LDB_ERR_AUTH_METHOD_NOT_SUPPORTED));
2845 PyModule_AddObject(m, "ERR_STRONG_AUTH_REQUIRED", PyInt_FromLong(LDB_ERR_STRONG_AUTH_REQUIRED));
2846 PyModule_AddObject(m, "ERR_REFERRAL", PyInt_FromLong(LDB_ERR_REFERRAL));
2847 PyModule_AddObject(m, "ERR_ADMIN_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_ADMIN_LIMIT_EXCEEDED));
2848 PyModule_AddObject(m, "ERR_UNSUPPORTED_CRITICAL_EXTENSION", PyInt_FromLong(LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION));
2849 PyModule_AddObject(m, "ERR_CONFIDENTIALITY_REQUIRED", PyInt_FromLong(LDB_ERR_CONFIDENTIALITY_REQUIRED));
2850 PyModule_AddObject(m, "ERR_SASL_BIND_IN_PROGRESS", PyInt_FromLong(LDB_ERR_SASL_BIND_IN_PROGRESS));
2851 PyModule_AddObject(m, "ERR_NO_SUCH_ATTRIBUTE", PyInt_FromLong(LDB_ERR_NO_SUCH_ATTRIBUTE));
2852 PyModule_AddObject(m, "ERR_UNDEFINED_ATTRIBUTE_TYPE", PyInt_FromLong(LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE));
2853 PyModule_AddObject(m, "ERR_INAPPROPRIATE_MATCHING", PyInt_FromLong(LDB_ERR_INAPPROPRIATE_MATCHING));
2854 PyModule_AddObject(m, "ERR_CONSTRAINT_VIOLATION", PyInt_FromLong(LDB_ERR_CONSTRAINT_VIOLATION));
2855 PyModule_AddObject(m, "ERR_ATTRIBUTE_OR_VALUE_EXISTS", PyInt_FromLong(LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS));
2856 PyModule_AddObject(m, "ERR_INVALID_ATTRIBUTE_SYNTAX", PyInt_FromLong(LDB_ERR_INVALID_ATTRIBUTE_SYNTAX));
2857 PyModule_AddObject(m, "ERR_NO_SUCH_OBJECT", PyInt_FromLong(LDB_ERR_NO_SUCH_OBJECT));
2858 PyModule_AddObject(m, "ERR_ALIAS_PROBLEM", PyInt_FromLong(LDB_ERR_ALIAS_PROBLEM));
2859 PyModule_AddObject(m, "ERR_INVALID_DN_SYNTAX", PyInt_FromLong(LDB_ERR_INVALID_DN_SYNTAX));
2860 PyModule_AddObject(m, "ERR_ALIAS_DEREFERINCING_PROBLEM", PyInt_FromLong(LDB_ERR_ALIAS_DEREFERENCING_PROBLEM));
2861 PyModule_AddObject(m, "ERR_INAPPROPRIATE_AUTHENTICATION", PyInt_FromLong(LDB_ERR_INAPPROPRIATE_AUTHENTICATION));
2862 PyModule_AddObject(m, "ERR_INVALID_CREDENTIALS", PyInt_FromLong(LDB_ERR_INVALID_CREDENTIALS));
2863 PyModule_AddObject(m, "ERR_INSUFFICIENT_ACCESS_RIGHTS", PyInt_FromLong(LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS));
2864 PyModule_AddObject(m, "ERR_BUSY", PyInt_FromLong(LDB_ERR_BUSY));
2865 PyModule_AddObject(m, "ERR_UNAVAILABLE", PyInt_FromLong(LDB_ERR_UNAVAILABLE));
2866 PyModule_AddObject(m, "ERR_UNWILLING_TO_PERFORM", PyInt_FromLong(LDB_ERR_UNWILLING_TO_PERFORM));
2867 PyModule_AddObject(m, "ERR_LOOP_DETECT", PyInt_FromLong(LDB_ERR_LOOP_DETECT));
2868 PyModule_AddObject(m, "ERR_NAMING_VIOLATION", PyInt_FromLong(LDB_ERR_NAMING_VIOLATION));
2869 PyModule_AddObject(m, "ERR_OBJECT_CLASS_VIOLATION", PyInt_FromLong(LDB_ERR_OBJECT_CLASS_VIOLATION));
2870 PyModule_AddObject(m, "ERR_NOT_ALLOWED_ON_NON_LEAF", PyInt_FromLong(LDB_ERR_NOT_ALLOWED_ON_NON_LEAF));
2871 PyModule_AddObject(m, "ERR_NOT_ALLOWED_ON_RDN", PyInt_FromLong(LDB_ERR_NOT_ALLOWED_ON_RDN));
2872 PyModule_AddObject(m, "ERR_ENTRY_ALREADY_EXISTS", PyInt_FromLong(LDB_ERR_ENTRY_ALREADY_EXISTS));
2873 PyModule_AddObject(m, "ERR_OBJECT_CLASS_MODS_PROHIBITED", PyInt_FromLong(LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED));
2874 PyModule_AddObject(m, "ERR_AFFECTS_MULTIPLE_DSAS", PyInt_FromLong(LDB_ERR_AFFECTS_MULTIPLE_DSAS));
2875 PyModule_AddObject(m, "ERR_OTHER", PyInt_FromLong(LDB_ERR_OTHER));
2876
2877 PyModule_AddObject(m, "FLG_RDONLY", PyInt_FromLong(LDB_FLG_RDONLY));
2878 PyModule_AddObject(m, "FLG_NOSYNC", PyInt_FromLong(LDB_FLG_NOSYNC));
2879 PyModule_AddObject(m, "FLG_RECONNECT", PyInt_FromLong(LDB_FLG_RECONNECT));
2880 PyModule_AddObject(m, "FLG_NOMMAP", PyInt_FromLong(LDB_FLG_NOMMAP));
2881
2882 PyModule_AddObject(m, "__docformat__", PyString_FromString("restructuredText"));
2883
2884 PyExc_LdbError = PyErr_NewException(discard_const_p(char, "_ldb.LdbError"), NULL, NULL);
2885 PyModule_AddObject(m, "LdbError", PyExc_LdbError);
2886
2887 Py_INCREF(&PyLdb);
2888 Py_INCREF(&PyLdbDn);
2889 Py_INCREF(&PyLdbModule);
2890 Py_INCREF(&PyLdbMessage);
2891 Py_INCREF(&PyLdbMessageElement);
2892 Py_INCREF(&PyLdbTree);
2893
2894 PyModule_AddObject(m, "Ldb", (PyObject *)&PyLdb);
2895 PyModule_AddObject(m, "Dn", (PyObject *)&PyLdbDn);
2896 PyModule_AddObject(m, "Message", (PyObject *)&PyLdbMessage);
2897 PyModule_AddObject(m, "MessageElement", (PyObject *)&PyLdbMessageElement);
2898 PyModule_AddObject(m, "Module", (PyObject *)&PyLdbModule);
2899 PyModule_AddObject(m, "Tree", (PyObject *)&PyLdbTree);
2900
2901 PyModule_AddObject(m, "__version__", PyString_FromString(PACKAGE_VERSION));
2902 }
WIP