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