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