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