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