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