source4/lib/ldb/pyldb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Swig 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-2008 Jelmer Vernooij <jelmer@samba.org>
   9
  10          ** NOTE! The following LGPL license applies to the ldb
  11          ** library. This does NOT imply that all of Samba is released
  12          ** under the LGPL
  13
  14    This library is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU Lesser General Public
  16    License as published by the Free Software Foundation; either
  17    version 3 of the License, or (at your option) any later version.
  18
  19    This library is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22    Lesser General Public License for more details.
  23
  24    You should have received a copy of the GNU Lesser General Public
  25    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  26 */
  27
  28 #include <stdint.h>
  29 #include <stdbool.h>
  30 #include "pyldb.h"
  31 #include "events.h"
  32 #include "ldb.h"
  33 #include "ldb_errors.h"
  34 #include "ldb_private.h"
  35
  36 PyObject *PyExc_LdbError;
  37
  38 void PyErr_SetLdbError(int ret, struct ldb_context *ldb_ctx)
  39 {
  40         PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", ret, ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx)));
  41 }
  42 PyObject *PyObject_FromLdbValue(struct ldb_context *ldb_ctx,
  43                                                            struct ldb_message_element *el,
  44                                                            struct ldb_val *val)
  45 {
  46         const struct ldb_schema_attribute *a;
  47         struct ldb_val new_val;
  48         TALLOC_CTX *mem_ctx = talloc_new(NULL);
  49         PyObject *ret;
  50
  51         new_val = *val;
  52
  53         if (ldb_ctx != NULL) {
  54                 a = ldb_schema_attribute_by_name(ldb_ctx, el->name);
  55
  56                 if (a != NULL) {
  57                         if (a->syntax->ldif_write_fn(ldb_ctx, mem_ctx, val, &new_val) != 0) {
  58                                 talloc_free(mem_ctx);
  59                                 return NULL;
  60                         }
  61                 }
  62         }
  63
  64         ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
  65
  66         talloc_free(mem_ctx);
  67
  68         return ret;
  69 }
  70
  71 bool PyObject_AsDn(TALLOC_CTX *mem_ctx, PyObject *object,
  72                    struct ldb_context *ldb_ctx, struct ldb_dn **dn)
  73 {
  74         struct ldb_dn *odn;
  75
  76         if (ldb_ctx != NULL && PyString_Check(object)) {
  77                 odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
  78                 *dn = odn;
  79                 return true;
  80         }
  81
  82         if (PyLdbDn_Check(object)) {
  83                 *dn = PyLdbDn_AsDn(object);
  84                 return true;
  85         }
  86
  87         PyErr_SetString(PyExc_TypeError, "Expected DN");
  88         return false;
  89 }
  90
  91 static PyObject *PyLdbResult_FromResult(struct ldb_result *result)
  92 {
  93         PyObject *ret;
  94         int i;
  95         if (result == NULL) {
  96                 return Py_None;
  97         }
  98         ret = PyList_New(result->count);
  99         for (i = 0; i < result->count; i++) {
 100                 PyList_SetItem(ret, i,
 101                                            PyLdbMessage_FromMessage(result->msgs[i])
 102                 );
 103         }
 104         return ret;
 105 }
 106
 107 static struct ldb_result *PyLdbResult_AsResult(TALLOC_CTX *mem_ctx, PyObject *obj)
 108 {
 109         struct ldb_result *res;
 110         int i;
 111
 112         if (obj == Py_None)
 113                 return NULL;
 114
 115         res = talloc_zero(mem_ctx, struct ldb_result);
 116         res->count = PyList_Size(obj);
 117         res->msgs = talloc_array(res, struct ldb_message *, res->count);
 118         for (i = 0; i < res->count; i++) {
 119                 PyObject *item = PyList_GetItem(obj, i);
 120                 res->msgs[i] = PyLdbMessage_AsMessage(item);
 121         }
 122         return res;
 123 }
 124
 125 static PyObject *py_ldb_dn_validate(PyLdbDnObject *self)
 126 {
 127         return PyBool_FromLong(ldb_dn_validate(self->ptr));
 128 }
 129
 130 static PyObject *py_ldb_dn_is_valid(PyLdbDnObject *self)
 131 {
 132         return PyBool_FromLong(ldb_dn_is_valid(self->ptr));
 133 }
 134
 135 static PyObject *py_ldb_dn_is_special(PyLdbDnObject *self)
 136 {
 137         return PyBool_FromLong(ldb_dn_is_special(self->ptr));
 138 }
 139
 140 static PyObject *py_ldb_dn_is_null(PyLdbDnObject *self)
 141 {
 142         return PyBool_FromLong(ldb_dn_is_null(self->ptr));
 143 }
 144
 145 static PyObject *py_ldb_dn_get_casefold(PyLdbDnObject *self)
 146 {
 147         return PyString_FromString(ldb_dn_get_casefold(self->ptr));
 148 }
 149
 150 static PyObject *py_ldb_dn_get_linearized(PyLdbDnObject *self)
 151 {
 152         return PyString_FromString(ldb_dn_get_linearized(self->ptr));
 153 }
 154
 155 static PyObject *py_ldb_dn_canonical_str(PyLdbDnObject *self)
 156 {
 157         return PyString_FromString(ldb_dn_canonical_string(self->ptr, self->ptr));
 158 }
 159
 160 static PyObject *py_ldb_dn_canonical_ex_str(PyLdbDnObject *self)
 161 {
 162         return PyString_FromString(ldb_dn_canonical_ex_string(self->ptr, self->ptr));
 163 }
 164
 165 static PyObject *py_ldb_dn_repr(PyLdbDnObject *self)
 166 {
 167         return PyString_FromFormat("Dn(%s)", PyObject_REPR(PyString_FromString(ldb_dn_get_linearized(self->ptr))));
 168 }
 169
 170 static PyObject *py_ldb_dn_check_special(PyLdbDnObject *self, PyObject *args)
 171 {
 172         char *name;
 173
 174         if (!PyArg_ParseTuple(args, "s", &name))
 175                 return NULL;
 176
 177         return ldb_dn_check_special(self->ptr, name)?Py_True:Py_False;
 178 }
 179
 180 static int py_ldb_dn_compare(PyLdbDnObject *dn1, PyLdbDnObject *dn2)
 181 {
 182         return ldb_dn_compare(dn1->ptr, dn2->ptr);
 183 }
 184
 185 static PyObject *py_ldb_dn_get_parent(PyLdbDnObject *self)
 186 {
 187         struct ldb_dn *dn = PyLdbDn_AsDn((PyObject *)self);
 188         return PyLdbDn_FromDn(ldb_dn_get_parent(NULL, dn));
 189 }
 190
 191 #define dn_ldb_ctx(dn) ((struct ldb_context *)dn)
 192
 193 static PyObject *py_ldb_dn_add_child(PyLdbDnObject *self, PyObject *args)
 194 {
 195         PyObject *py_other;
 196         struct ldb_dn *dn, *other;
 197         if (!PyArg_ParseTuple(args, "O", &py_other))
 198                 return NULL;
 199
 200         dn = PyLdbDn_AsDn((PyObject *)self);
 201
 202         if (!PyObject_AsDn(NULL, py_other, dn_ldb_ctx(dn), &other))
 203                 return NULL;
 204
 205         return ldb_dn_add_child(dn, other)?Py_True:Py_False;
 206 }
 207
 208 static PyObject *py_ldb_dn_add_base(PyLdbDnObject *self, PyObject *args)
 209 {
 210         PyObject *py_other;
 211         struct ldb_dn *other, *dn;
 212         if (!PyArg_ParseTuple(args, "O", &py_other))
 213                 return NULL;
 214
 215         dn = PyLdbDn_AsDn((PyObject *)self);
 216
 217         if (!PyObject_AsDn(NULL, py_other, dn_ldb_ctx(dn), &other))
 218                 return NULL;
 219
 220         return ldb_dn_add_base(dn, other)?Py_True:Py_False;
 221 }
 222
 223 static PyMethodDef py_ldb_dn_methods[] = {
 224         { "validate", (PyCFunction)py_ldb_dn_validate, METH_NOARGS,
 225                 "S.validate() -> bool\n"
 226                 "Validate DN is correct." },
 227         { "is_valid", (PyCFunction)py_ldb_dn_is_valid, METH_NOARGS,
 228                 "S.is_valid() -> bool\n" },
 229         { "is_special", (PyCFunction)py_ldb_dn_is_special, METH_NOARGS,
 230                 "S.is_special() -> bool\n"
 231                 "Check whether this is a special LDB DN." },
 232         { "is_null", (PyCFunction)py_ldb_dn_is_null, METH_NOARGS,
 233                 "Check whether this is a null DN." },
 234         { "get_casefold", (PyCFunction)py_ldb_dn_get_casefold, METH_NOARGS,
 235                 NULL },
 236         { "get_linearized", (PyCFunction)py_ldb_dn_get_linearized, METH_NOARGS,
 237                 NULL },
 238         { "canonical_str", (PyCFunction)py_ldb_dn_canonical_str, METH_NOARGS,
 239                 "S.canonical_str() -> string\n"
 240                 "Canonical version of this DN (like a posix path)." },
 241         { "canonical_ex_str", (PyCFunction)py_ldb_dn_canonical_ex_str, METH_NOARGS,
 242                 "S.canonical_ex_str() -> string\n"
 243                 "Canonical version of this DN (like a posix path, with terminating newline)." },
 244         { "check_special", (PyCFunction)py_ldb_dn_is_special, METH_VARARGS,
 245                 NULL },
 246         { "parent", (PyCFunction)py_ldb_dn_get_parent, METH_NOARGS,
 247                 "S.parent() -> dn\n"
 248                 "Get the parent for this DN." },
 249         { "add_child", (PyCFunction)py_ldb_dn_add_child, METH_VARARGS,
 250                 "S.add_child(dn) -> None\n"
 251                 "Add a child DN to this DN." },
 252         { "add_base", (PyCFunction)py_ldb_dn_add_base, METH_VARARGS,
 253                 "S.add_base(dn) -> None\n"
 254                 "Add a base DN to this DN." },
 255         { "check_special", (PyCFunction)py_ldb_dn_check_special, METH_VARARGS,
 256                 NULL },
 257         { NULL }
 258 };
 259
 260 static Py_ssize_t py_ldb_dn_len(PyLdbDnObject *self)
 261 {
 262         return ldb_dn_get_comp_num(PyLdbDn_AsDn((PyObject *)self));
 263 }
 264
 265 static PyObject *py_ldb_dn_concat(PyLdbDnObject *self, PyObject *py_other)
 266 {
 267         struct ldb_dn *dn = PyLdbDn_AsDn((PyObject *)self),
 268                                   *other;
 269         struct ldb_dn *ret = ldb_dn_copy(NULL, dn);
 270         if (!PyObject_AsDn(NULL, py_other, NULL, &other))
 271                 return NULL;
 272         ldb_dn_add_child(ret, other);
 273         return PyLdbDn_FromDn(ret);
 274 }
 275
 276 static PySequenceMethods py_ldb_dn_seq = {
 277         .sq_length = (lenfunc)py_ldb_dn_len,
 278         .sq_concat = (binaryfunc)py_ldb_dn_concat,
 279 };
 280
 281 static PyObject *py_ldb_dn_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 282 {
 283         struct ldb_dn *ret;
 284         char *str;
 285         PyObject *py_ldb;
 286         struct ldb_context *ldb_ctx;
 287         const char *kwnames[] = { "ldb", "dn", NULL };
 288
 289         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Os", (char **)kwnames, &py_ldb, &str))
 290                 return NULL;
 291
 292         ldb_ctx = PyLdb_AsLdbContext(py_ldb);
 293
 294         ret = ldb_dn_new(ldb_ctx, ldb_ctx, str);
 295         /* ldb_dn_new() doesn't accept NULL as memory context, so
 296            we do it this way... */
 297         talloc_steal(NULL, ret);
 298
 299         if (ret == NULL || !ldb_dn_validate(ret)) {
 300                 PyErr_SetString(PyExc_ValueError, "unable to parse dn string");
 301                 return NULL;
 302         }
 303
 304         return py_talloc_import(&PyLdbDn, ret);
 305 }
 306
 307 PyObject *PyLdbDn_FromDn(struct ldb_dn *dn)
 308 {
 309         return py_talloc_import(&PyLdbDn, dn);
 310 }
 311
 312 PyTypeObject PyLdbDn = {
 313         .tp_name = "Dn",
 314         .tp_methods = py_ldb_dn_methods,
 315         .tp_str = (reprfunc)py_ldb_dn_get_linearized,
 316         .tp_repr = (reprfunc)py_ldb_dn_repr,
 317         .tp_compare = (cmpfunc)py_ldb_dn_compare,
 318         .tp_as_sequence = &py_ldb_dn_seq,
 319         .tp_doc = "A LDB distinguished name.",
 320         .tp_new = py_ldb_dn_new,
 321         .tp_dealloc = py_talloc_dealloc,
 322         .tp_basicsize = sizeof(PyLdbObject),
 323         .tp_flags = Py_TPFLAGS_DEFAULT,
 324 };
 325
 326 /* Debug */
 327 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
 328 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
 329 {
 330         PyObject *fn = context;
 331         PyObject_CallFunction(fn, (char *)"(i,O)", level, PyString_FromFormatV(fmt, ap));
 332 }
 333
 334 static PyObject *py_ldb_set_debug(PyLdbObject *self, PyObject *args)
 335 {
 336         PyObject *cb;
 337
 338         if (!PyArg_ParseTuple(args, "O", &cb))
 339                 return NULL;
 340
 341         Py_INCREF(cb);
 342         /* FIXME: Where do we DECREF cb ? */
 343         PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_set_debug(self->ptr, py_ldb_debug, cb), PyLdb_AsLdbContext(self));
 344
 345         return Py_None;
 346 }
 347
 348 static PyObject *py_ldb_set_create_perms(PyTypeObject *self, PyObject *args)
 349 {
 350         unsigned int perms;
 351         if (!PyArg_ParseTuple(args, "I", &perms))
 352                 return NULL;
 353
 354         ldb_set_create_perms(PyLdb_AsLdbContext(self), perms);
 355
 356         return Py_None;
 357 }
 358
 359 static PyObject *py_ldb_set_modules_dir(PyTypeObject *self, PyObject *args)
 360 {
 361         char *modules_dir;
 362         if (!PyArg_ParseTuple(args, "s", &modules_dir))
 363                 return NULL;
 364
 365         ldb_set_modules_dir(PyLdb_AsLdbContext(self), modules_dir);
 366
 367         return Py_None;
 368 }
 369
 370 static PyObject *py_ldb_transaction_start(PyLdbObject *self)
 371 {
 372         PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_transaction_start(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
 373         return Py_None;
 374 }
 375
 376 static PyObject *py_ldb_transaction_commit(PyLdbObject *self)
 377 {
 378         PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_transaction_commit(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
 379         return Py_None;
 380 }
 381
 382 static PyObject *py_ldb_transaction_cancel(PyLdbObject *self)
 383 {
 384         PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_transaction_cancel(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
 385         return Py_None;
 386 }
 387
 388 static PyObject *py_ldb_setup_wellknown_attributes(PyLdbObject *self)
 389 {
 390         PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_setup_wellknown_attributes(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
 391         return Py_None;
 392 }
 393
 394 static PyObject *py_ldb_repr(PyLdbObject *self)
 395 {
 396         return PyString_FromFormat("<ldb connection>");
 397 }
 398
 399 static PyObject *py_ldb_get_root_basedn(PyLdbObject *self)
 400 {
 401         struct ldb_dn *dn = ldb_get_root_basedn(PyLdb_AsLdbContext(self));
 402         if (dn == NULL)
 403                 return Py_None;
 404         return PyLdbDn_FromDn(dn);
 405 }
 406
 407
 408 static PyObject *py_ldb_get_schema_basedn(PyLdbObject *self)
 409 {
 410         struct ldb_dn *dn = ldb_get_schema_basedn(PyLdb_AsLdbContext(self));
 411         if (dn == NULL)
 412                 return Py_None;
 413         return PyLdbDn_FromDn(dn);
 414 }
 415
 416
 417 static PyObject *py_ldb_get_config_basedn(PyLdbObject *self)
 418 {
 419         struct ldb_dn *dn = ldb_get_config_basedn(PyLdb_AsLdbContext(self));
 420         if (dn == NULL)
 421                 return Py_None;
 422         return PyLdbDn_FromDn(dn);
 423 }
 424
 425
 426 static PyObject *py_ldb_get_default_basedn(PyLdbObject *self)
 427 {
 428         struct ldb_dn *dn = ldb_get_default_basedn(PyLdb_AsLdbContext(self));
 429         if (dn == NULL)
 430                 return Py_None;
 431         return PyLdbDn_FromDn(dn);
 432 }
 433
 434 static const char **PyList_AsStringList(TALLOC_CTX *mem_ctx, PyObject *list)
 435 {
 436         const char **ret;
 437         int i;
 438         if (!PyList_Check(list)) {
 439                 PyErr_SetString(PyExc_TypeError, "options is not a list");
 440                 return NULL;
 441         }
 442         ret = talloc_array(NULL, const char *, PyList_Size(list)+1);
 443         for (i = 0; i < PyList_Size(list); i++) {
 444                 PyObject *item = PyList_GetItem(list, i);
 445                 if (!PyString_Check(item)) {
 446                         PyErr_SetString(PyExc_TypeError, "options should be strings");
 447                         return NULL;
 448                 }
 449                 ret[i] = PyString_AsString(item);
 450         }
 451         ret[i] = NULL;
 452         return ret;
 453 }
 454
 455 static int py_ldb_init(PyLdbObject *self, PyObject *args, PyObject *kwargs)
 456 {
 457         const char *kwnames[] = { "url", "flags", "options", NULL };
 458         char *url = NULL;
 459         PyObject *py_options = Py_None;
 460         const char **options;
 461         int flags = 0;
 462         int ret;
 463         struct ldb_context *ldb;
 464
 465         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ziO:Ldb.__init__", (char **)kwnames,
 466                                                                          &url, &flags, &py_options))
 467                 return -1;
 468
 469         ldb = PyLdb_AsLdbContext(self);
 470
 471         if (py_options == Py_None) {
 472                 options = NULL;
 473         } else {
 474                 options = PyList_AsStringList(ldb, py_options);
 475                 if (options == NULL)
 476                         return -1;
 477         }
 478
 479         if (url != NULL) {
 480                 ret = ldb_connect(ldb, url, flags, options);
 481                 if (ret != LDB_SUCCESS) {
 482                         PyErr_SetLdbError(ret, ldb);
 483                         return -1;
 484                 }
 485         }
 486
 487         talloc_free(options);
 488         return 0;
 489 }
 490
 491 static PyObject *py_ldb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 492 {
 493         struct ldb_context *ldb;
 494         ldb = ldb_init(NULL, event_context_init(NULL));
 495         if (ldb == NULL) {
 496                 PyErr_NoMemory();
 497                 return NULL;
 498         }
 499
 500         return py_talloc_import(type, ldb);
 501 }
 502
 503 static PyObject *py_ldb_connect(PyLdbObject *self, PyObject *args, PyObject *kwargs)
 504 {
 505         char *url;
 506         int flags;
 507         PyObject *py_options = Py_None;
 508         int ret;
 509         const char **options;
 510         const char *kwnames[] = { "url", "flags", "options", NULL };
 511         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|iO", (char **)kwnames, &url, &flags,
 512                                                                          &py_options))
 513                 return NULL;
 514
 515         if (py_options == Py_None) {
 516                 options = NULL;
 517         } else {
 518                 options = PyList_AsStringList(NULL, py_options);
 519                 if (options == NULL)
 520                         return NULL;
 521         }
 522
 523         ret = ldb_connect(PyLdb_AsLdbContext(self), url, flags, options);
 524         talloc_free(options);
 525
 526         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
 527
 528         return Py_None;
 529 }
 530
 531 static PyObject *py_ldb_modify(PyLdbObject *self, PyObject *args)
 532 {
 533         PyObject *py_msg;
 534         int ret;
 535         if (!PyArg_ParseTuple(args, "O", &py_msg))
 536                 return NULL;
 537
 538         if (!PyLdbMessage_Check(py_msg)) {
 539                 PyErr_SetString(PyExc_TypeError, "Expected Ldb Message");
 540                 return NULL;
 541         }
 542
 543         ret = ldb_modify(PyLdb_AsLdbContext(self), PyLdbMessage_AsMessage(py_msg));
 544         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
 545
 546         return Py_None;
 547 }
 548
 549 static PyObject *py_ldb_add(PyLdbObject *self, PyObject *args)
 550 {
 551         PyObject *py_msg;
 552         int ret;
 553         Py_ssize_t dict_pos, msg_pos;
 554         struct ldb_message_element *msgel;
 555         struct ldb_message *msg;
 556         PyObject *key, *value;
 557
 558         if (!PyArg_ParseTuple(args, "O", &py_msg))
 559                 return NULL;
 560
 561         if (PyDict_Check(py_msg)) {
 562                 PyObject *dn_value = PyDict_GetItemString(py_msg, "dn");
 563                 msg = ldb_msg_new(NULL);
 564                 msg->elements = talloc_zero_array(msg, struct ldb_message_element, PyDict_Size(py_msg));
 565                 msg_pos = dict_pos = 0;
 566                 if (dn_value) {
 567                         if (!PyObject_AsDn(msg, dn_value, PyLdb_AsLdbContext(self), &msg->dn)) {
 568                                 PyErr_SetString(PyExc_TypeError, "unable to import dn object");
 569                                 return NULL;
 570                         }
 571                         if (msg->dn == NULL) {
 572                                 PyErr_SetString(PyExc_TypeError, "dn set but not found");
 573                                 return NULL;
 574                         }
 575                 }
 576
 577                 while (PyDict_Next(py_msg, &dict_pos, &key, &value)) {
 578                         char *key_str = PyString_AsString(key);
 579                         if (strcmp(key_str, "dn") != 0) {
 580                                 msgel = PyObject_AsMessageElement(msg->elements, value, 0, key_str);
 581                                 if (msgel == NULL) {
 582                                         PyErr_SetString(PyExc_TypeError, "unable to import element");
 583                                         return NULL;
 584                                 }
 585                                 memcpy(&msg->elements[msg_pos], msgel, sizeof(*msgel));
 586                                 msg_pos++;
 587                         }
 588                 }
 589
 590                 if (msg->dn == NULL) {
 591                         PyErr_SetString(PyExc_TypeError, "no dn set");
 592                         return NULL;
 593                 }
 594
 595                 msg->num_elements = msg_pos;
 596         } else {
 597                 msg = PyLdbMessage_AsMessage(py_msg);
 598         }
 599
 600         ret = ldb_add(PyLdb_AsLdbContext(self), msg);
 601         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
 602
 603         return Py_None;
 604 }
 605
 606
 607
 608 static PyObject *py_ldb_delete(PyLdbObject *self, PyObject *args)
 609 {
 610         PyObject *py_dn;
 611         struct ldb_dn *dn;
 612         int ret;
 613         if (!PyArg_ParseTuple(args, "O", &py_dn))
 614                 return NULL;
 615
 616         if (!PyObject_AsDn(NULL, py_dn, PyLdb_AsLdbContext(self), &dn))
 617                 return NULL;
 618
 619         ret = ldb_delete(PyLdb_AsLdbContext(self), dn);
 620         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
 621
 622         return Py_None;
 623 }
 624
 625 static PyObject *py_ldb_rename(PyLdbObject *self, PyObject *args)
 626 {
 627         PyObject *py_dn1, *py_dn2;
 628         struct ldb_dn *dn1, *dn2;
 629         int ret;
 630         if (!PyArg_ParseTuple(args, "OO", &py_dn1, &py_dn2))
 631                 return NULL;
 632
 633         if (!PyLdbDn_Check(py_dn1) || !PyLdbDn_Check(py_dn2)) {
 634                 PyErr_SetString(PyExc_TypeError, "Expected Ldb Dn");
 635                 return NULL;
 636         }
 637
 638         if (!PyObject_AsDn(NULL, py_dn1, PyLdb_AsLdbContext(self), &dn1))
 639                 return NULL;
 640
 641         if (!PyObject_AsDn(NULL, py_dn2, PyLdb_AsLdbContext(self), &dn2))
 642                 return NULL;
 643
 644         ret = ldb_rename(PyLdb_AsLdbContext(self), dn1, dn2);
 645         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
 646
 647         return Py_None;
 648 }
 649
 650 static PyObject *py_ldb_schema_attribute_remove(PyLdbObject *self, PyObject *args)
 651 {
 652         char *name;
 653         if (!PyArg_ParseTuple(args, "s", &name))
 654                 return NULL;
 655
 656         ldb_schema_attribute_remove(PyLdb_AsLdbContext(self), name);
 657
 658         return Py_None;
 659 }
 660
 661 static PyObject *py_ldb_schema_attribute_add(PyLdbObject *self, PyObject *args)
 662 {
 663         char *attribute, *syntax;
 664         unsigned int flags;
 665         int ret;
 666         if (!PyArg_ParseTuple(args, "sIs", &attribute, &flags, &syntax))
 667                 return NULL;
 668
 669         ret = ldb_schema_attribute_add(PyLdb_AsLdbContext(self), attribute, flags, syntax);
 670
 671         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
 672
 673         return Py_None;
 674 }
 675
 676 static PyObject *ldb_ldif_to_pyobject(struct ldb_ldif *ldif)
 677 {
 678         if (ldif == NULL) {
 679                 return Py_None;
 680         } else {
 681         /* We don't want this attached to the 'ldb' any more */
 682                 talloc_steal(NULL, ldif);
 683                 return Py_BuildValue((char *)"(iO)", ldif->changetype,
 684                                                          PyLdbMessage_FromMessage(ldif->msg));
 685         }
 686 }
 687
 688
 689 static PyObject *py_ldb_parse_ldif(PyLdbObject *self, PyObject *args)
 690 {
 691         PyObject *list;
 692         struct ldb_ldif *ldif;
 693         const char *s;
 694
 695         if (!PyArg_ParseTuple(args, "s", &s))
 696                 return NULL;
 697
 698         list = PyList_New(0);
 699         while ((ldif = ldb_ldif_read_string(self->ptr, &s)) != NULL) {
 700                 PyList_Append(list, ldb_ldif_to_pyobject(ldif));
 701         }
 702         return PyObject_GetIter(list);
 703 }
 704
 705 static PyObject *py_ldb_schema_format_value(PyLdbObject *self, PyObject *args)
 706 {
 707         const struct ldb_schema_attribute *a;
 708         struct ldb_val old_val;
 709         struct ldb_val new_val;
 710         TALLOC_CTX *mem_ctx;
 711         PyObject *ret;
 712         char *element_name;
 713         PyObject *val;
 714
 715         if (!PyArg_ParseTuple(args, "sO", &element_name, &val))
 716                 return NULL;
 717
 718         mem_ctx = talloc_new(NULL);
 719
 720         old_val.data = (uint8_t *)PyString_AsString(val);
 721         old_val.length = PyString_Size(val);
 722
 723         a = ldb_schema_attribute_by_name(PyLdb_AsLdbContext(self), element_name);
 724
 725         if (a == NULL) {
 726                 return Py_None;
 727         }
 728
 729         if (a->syntax->ldif_write_fn(PyLdb_AsLdbContext(self), mem_ctx, &old_val, &new_val) != 0) {
 730                 talloc_free(mem_ctx);
 731                 return Py_None;
 732         }
 733
 734         ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
 735
 736         talloc_free(mem_ctx);
 737
 738         return ret;
 739 }
 740
 741 static PyObject *py_ldb_search(PyLdbObject *self, PyObject *args, PyObject *kwargs)
 742 {
 743         PyObject *py_base = Py_None;
 744         enum ldb_scope scope = LDB_SCOPE_DEFAULT;
 745         char *expr = NULL;
 746         PyObject *py_attrs = Py_None;
 747         PyObject *py_controls = Py_None;
 748         const char *kwnames[] = { "base", "scope", "expression", "attrs", "controls", NULL };
 749         int ret;
 750         struct ldb_result *res;
 751         struct ldb_request *req;
 752         const char **attrs;
 753         struct ldb_context *ldb_ctx;
 754         struct ldb_control **parsed_controls;
 755         struct ldb_dn *base;
 756
 757         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OisOO", (char **)kwnames,
 758                                                                          &py_base, &scope, &expr, &py_attrs, &py_controls))
 759                 return NULL;
 760
 761         ldb_ctx = PyLdb_AsLdbContext(self);
 762
 763         if (py_attrs == Py_None) {
 764                 attrs = NULL;
 765         } else {
 766                 attrs = PyList_AsStringList(ldb_ctx, py_attrs);
 767                 if (attrs == NULL)
 768                         return NULL;
 769         }
 770
 771         if (py_base == Py_None) {
 772                 base = ldb_get_default_basedn(ldb_ctx);
 773         } else {
 774                 if (!PyObject_AsDn(ldb_ctx, py_base, ldb_ctx, &base))
 775                         return NULL;
 776         }
 777
 778         if (py_controls == Py_None) {
 779                 parsed_controls = NULL;
 780         } else {
 781                 const char **controls = PyList_AsStringList(ldb_ctx, py_controls);
 782                 parsed_controls = ldb_parse_control_strings(ldb_ctx, ldb_ctx, controls);
 783                 talloc_free(controls);
 784         }
 785
 786         res = talloc_zero(ldb_ctx, struct ldb_result);
 787         if (res == NULL) {
 788                 PyErr_NoMemory();
 789                 return NULL;
 790         }
 791
 792         ret = ldb_build_search_req(&req, ldb_ctx, ldb_ctx,
 793                                    base,
 794                                    scope,
 795                                    expr,
 796                                    attrs,
 797                                    parsed_controls,
 798                                    res,
 799                                    ldb_search_default_callback,
 800                                    NULL);
 801
 802         if (ret != LDB_SUCCESS) {
 803                 talloc_free(res);
 804                 PyErr_LDB_ERROR_IS_ERR_RAISE(ret, ldb_ctx);
 805                 return NULL;
 806         }
 807
 808         ret = ldb_request(ldb_ctx, req);
 809
 810         if (ret == LDB_SUCCESS) {
 811                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 812         }
 813
 814         talloc_free(req);
 815
 816         return PyLdbResult_FromResult(res);
 817 }
 818
 819 static PyObject *py_ldb_get_opaque(PyLdbObject *self, PyObject *args)
 820 {
 821         char *name;
 822         void *data;
 823
 824         if (!PyArg_ParseTuple(args, "s", &name))
 825                 return NULL;
 826
 827         data = ldb_get_opaque(PyLdb_AsLdbContext(self), name);
 828
 829         /* FIXME: More interpretation */
 830
 831         return Py_None;
 832 }
 833
 834 static PyObject *py_ldb_set_opaque(PyLdbObject *self, PyObject *args)
 835 {
 836         char *name;
 837         PyObject *data;
 838
 839         if (!PyArg_ParseTuple(args, "sO", &name, &data))
 840                 return NULL;
 841
 842         /* FIXME: More interpretation */
 843
 844         ldb_set_opaque(PyLdb_AsLdbContext(self), name, data);
 845
 846         return Py_None;
 847 }
 848
 849 static PyMethodDef py_ldb_methods[] = {
 850         { "set_debug", (PyCFunction)py_ldb_set_debug, METH_VARARGS,
 851                 "S.set_debug(callback) -> None\n"
 852                 "Set callback for LDB debug messages.\n"
 853                 "The callback should accept a debug level and debug text." },
 854         { "set_create_perms", (PyCFunction)py_ldb_set_create_perms, METH_VARARGS,
 855                 "S.set_create_perms(mode) -> None\n"
 856                 "Set mode to use when creating new LDB files." },
 857         { "set_modules_dir", (PyCFunction)py_ldb_set_modules_dir, METH_VARARGS,
 858                 "S.set_modules_dir(path) -> None\n"
 859                 "Set path LDB should search for modules" },
 860         { "transaction_start", (PyCFunction)py_ldb_transaction_start, METH_NOARGS,
 861                 "S.transaction_start() -> None\n"
 862                 "Start a new transaction." },
 863         { "transaction_commit", (PyCFunction)py_ldb_transaction_commit, METH_NOARGS,
 864                 "S.transaction_commit() -> None\n"
 865                 "commit a new transaction." },
 866         { "transaction_cancel", (PyCFunction)py_ldb_transaction_cancel, METH_NOARGS,
 867                 "S.transaction_cancel() -> None\n"
 868                 "cancel a new transaction." },
 869         { "setup_wellknown_attributes", (PyCFunction)py_ldb_setup_wellknown_attributes, METH_NOARGS,
 870                 NULL },
 871         { "get_root_basedn", (PyCFunction)py_ldb_get_root_basedn, METH_NOARGS,
 872                 NULL },
 873         { "get_schema_basedn", (PyCFunction)py_ldb_get_schema_basedn, METH_NOARGS,
 874                 NULL },
 875         { "get_default_basedn", (PyCFunction)py_ldb_get_default_basedn, METH_NOARGS,
 876                 NULL },
 877         { "get_config_basedn", (PyCFunction)py_ldb_get_config_basedn, METH_NOARGS,
 878                 NULL },
 879         { "connect", (PyCFunction)py_ldb_connect, METH_VARARGS|METH_KEYWORDS,
 880                 "S.connect(url, flags=0, options=None) -> None\n"
 881                 "Connect to a LDB URL." },
 882         { "modify", (PyCFunction)py_ldb_modify, METH_VARARGS,
 883                 "S.modify(message) -> None\n"
 884                 "Modify an entry." },
 885         { "add", (PyCFunction)py_ldb_add, METH_VARARGS,
 886                 "S.add(message) -> None\n"
 887                 "Add an entry." },
 888         { "delete", (PyCFunction)py_ldb_delete, METH_VARARGS,
 889                 "S.delete(dn) -> None\n"
 890                 "Remove an entry." },
 891         { "rename", (PyCFunction)py_ldb_rename, METH_VARARGS,
 892                 "S.rename(old_dn, new_dn) -> None\n"
 893                 "Rename an entry." },
 894         { "search", (PyCFunction)py_ldb_search, METH_VARARGS|METH_KEYWORDS,
 895                 "S.search(base=None, scope=None, expression=None, attrs=None, controls=None) -> msgs\n"
 896                 "Search in a database.\n"
 897                 "\n"
 898                 ":param base: Optional base DN to search\n"
 899                 ":param scope: Search scope (SCOPE_BASE, SCOPE_ONELEVEL or SCOPE_SUBTREE)\n"
 900                 ":param expression: Optional search expression\n"
 901                 ":param attrs: Attributes to return (defaults to all)\n"
 902                 ":param controls: Optional list of controls\n"
 903                 ":return: Iterator over Message objects\n"
 904         },
 905         { "schema_attribute_remove", (PyCFunction)py_ldb_schema_attribute_remove, METH_VARARGS,
 906                 NULL },
 907         { "schema_attribute_add", (PyCFunction)py_ldb_schema_attribute_add, METH_VARARGS,
 908                 NULL },
 909         { "schema_format_value", (PyCFunction)py_ldb_schema_format_value, METH_VARARGS,
 910                 NULL },
 911         { "parse_ldif", (PyCFunction)py_ldb_parse_ldif, METH_VARARGS,
 912                 "S.parse_ldif(ldif) -> iter(messages)\n"
 913                 "Parse a string formatted using LDIF." },
 914         { "get_opaque", (PyCFunction)py_ldb_set_opaque, METH_VARARGS,
 915                 "S.get_opaque(name) -> value\n"
 916                 "Get an opaque value set on this LDB connection. \n"
 917                 ":note: The returned value may not be useful in Python."
 918         },
 919         { "set_opaque", (PyCFunction)py_ldb_get_opaque, METH_VARARGS,
 920                 "S.set_opaque(name, value) -> None\n"
 921                 "Set an opaque value on this LDB connection. \n"
 922                 ":note: Passing incorrect values may cause crashes." },
 923         { NULL },
 924 };
 925
 926 PyObject *PyLdbModule_FromModule(struct ldb_module *mod)
 927 {
 928         return py_talloc_import(&PyLdbModule, mod);
 929 }
 930
 931 static PyObject *py_ldb_get_firstmodule(PyLdbObject *self, void *closure)
 932 {
 933         return PyLdbModule_FromModule(PyLdb_AsLdbContext(self)->modules);
 934 }
 935
 936 static PyGetSetDef py_ldb_getset[] = {
 937         { (char *)"firstmodule", (getter)py_ldb_get_firstmodule, NULL, NULL },
 938         { NULL }
 939 };
 940
 941 static int py_ldb_contains(PyLdbObject *self, PyObject *obj)
 942 {
 943         struct ldb_context *ldb_ctx = PyLdb_AsLdbContext(self);
 944         struct ldb_dn *dn;
 945         struct ldb_result *result;
 946         int ret;
 947         int count;
 948
 949         if (!PyObject_AsDn(ldb_ctx, obj, ldb_ctx, &dn))
 950                 return -1;
 951
 952         ret = ldb_search(ldb_ctx, ldb_ctx, &result, dn, LDB_SCOPE_BASE, NULL, NULL);
 953         if (ret != LDB_SUCCESS) {
 954                 PyErr_SetLdbError(ret, ldb_ctx);
 955                 return -1;
 956         }
 957
 958         count = result->count;
 959
 960         talloc_free(result);
 961
 962         return count;
 963 }
 964
 965 static PySequenceMethods py_ldb_seq = {
 966         .sq_contains = (objobjproc)py_ldb_contains,
 967 };
 968
 969 PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx)
 970 {
 971         return py_talloc_import(&PyLdb, ldb_ctx);
 972 }
 973
 974 PyTypeObject PyLdb = {
 975         .tp_name = "Ldb",
 976         .tp_methods = py_ldb_methods,
 977         .tp_repr = (reprfunc)py_ldb_repr,
 978         .tp_new = py_ldb_new,
 979         .tp_init = (initproc)py_ldb_init,
 980         .tp_dealloc = py_talloc_dealloc,
 981         .tp_getset = py_ldb_getset,
 982         .tp_getattro = PyObject_GenericGetAttr,
 983         .tp_basicsize = sizeof(PyLdbObject),
 984         .tp_doc = "Connection to a LDB database.",
 985         .tp_as_sequence = &py_ldb_seq,
 986         .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 987 };
 988
 989 static PyObject *py_ldb_module_repr(PyLdbModuleObject *self)
 990 {
 991         return PyString_FromFormat("<ldb module '%s'>", PyLdbModule_AsModule(self)->ops->name);
 992 }
 993
 994 static PyObject *py_ldb_module_str(PyLdbModuleObject *self)
 995 {
 996         return PyString_FromString(PyLdbModule_AsModule(self)->ops->name);
 997 }
 998
 999 static PyObject *py_ldb_module_start_transaction(PyLdbModuleObject *self)
1000 {
1001         PyLdbModule_AsModule(self)->ops->start_transaction(PyLdbModule_AsModule(self));
1002         return Py_None;
1003 }
1004
1005 static PyObject *py_ldb_module_end_transaction(PyLdbModuleObject *self)
1006 {
1007         PyLdbModule_AsModule(self)->ops->end_transaction(PyLdbModule_AsModule(self));
1008         return Py_None;
1009 }
1010
1011 static PyObject *py_ldb_module_del_transaction(PyLdbModuleObject *self)
1012 {
1013         PyLdbModule_AsModule(self)->ops->del_transaction(PyLdbModule_AsModule(self));
1014         return Py_None;
1015 }
1016
1017 static PyObject *py_ldb_module_search(PyLdbModuleObject *self, PyObject *args, PyObject *kwargs)
1018 {
1019         PyObject *py_base, *py_tree, *py_attrs;
1020         int ret, scope;
1021         struct ldb_request *req;
1022         const char *kwnames[] = { "base", "scope", "tree", "attrs", NULL };
1023         struct ldb_module *mod;
1024         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiOO", (char **)kwnames,
1025                                                                          &py_base, &scope, &py_tree, &py_attrs))
1026                 return NULL;
1027
1028         req = talloc_zero(NULL, struct ldb_request);
1029
1030         req->operation = LDB_SEARCH;
1031         req->op.search.base = PyLdbDn_AsDn(py_base);
1032         req->op.search.scope = scope;
1033         req->op.search.tree = PyLdbTree_AsTree(py_tree);
1034         if (py_attrs == Py_None) {
1035                 req->op.search.attrs = NULL;
1036         } else {
1037                 req->op.search.attrs = PyList_AsStringList(req, py_attrs);
1038         }
1039
1040         req->op.search.res = talloc_zero(NULL, struct ldb_result);
1041
1042         mod = self->ptr;
1043
1044         ret = mod->ops->search(mod, req);
1045         talloc_free(req);
1046
1047         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, NULL);
1048
1049         return PyLdbResult_FromResult(req->op.search.res);
1050 }
1051
1052
1053 static PyObject *py_ldb_module_add(PyLdbModuleObject *self, PyObject *args)
1054 {
1055         struct ldb_request *req;
1056         PyObject *py_message;
1057         int ret;
1058
1059         if (!PyArg_ParseTuple(args, "O", &py_message))
1060                 return NULL;
1061
1062         req = talloc_zero(NULL, struct ldb_request);
1063         req->operation = LDB_ADD;
1064         req->op.add.message = PyLdbMessage_AsMessage(py_message);
1065
1066         ret = PyLdbModule_AsModule(self)->ops->add(PyLdbModule_AsModule(self), req);
1067
1068         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, NULL);
1069
1070         return Py_None;
1071 }
1072
1073 static PyObject *py_ldb_module_modify(PyLdbModuleObject *self, PyObject *args)
1074 {
1075         int ret;
1076         struct ldb_request *req;
1077         PyObject *py_message;
1078
1079         if (!PyArg_ParseTuple(args, "O", &py_message))
1080                 return NULL;
1081
1082         req = talloc_zero(NULL, struct ldb_request);
1083         req->operation = LDB_MODIFY;
1084         req->op.mod.message = PyLdbMessage_AsMessage(py_message);
1085
1086         ret = PyLdbModule_AsModule(self)->ops->modify(PyLdbModule_AsModule(self), req);
1087
1088         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, NULL);
1089
1090         return Py_None;
1091 }
1092
1093 static PyObject *py_ldb_module_delete(PyLdbModuleObject *self, PyObject *args)
1094 {
1095         int ret;
1096         struct ldb_request *req;
1097         PyObject *py_dn;
1098
1099         if (!PyArg_ParseTuple(args, "O", &py_dn))
1100                 return NULL;
1101
1102         req = talloc_zero(NULL, struct ldb_request);
1103         req->operation = LDB_DELETE;
1104         req->op.del.dn = PyLdbDn_AsDn(py_dn);
1105
1106         ret = PyLdbModule_AsModule(self)->ops->del(PyLdbModule_AsModule(self), req);
1107
1108         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, NULL);
1109
1110         return Py_None;
1111 }
1112
1113 static PyObject *py_ldb_module_rename(PyLdbModuleObject *self, PyObject *args)
1114 {
1115         int ret;
1116         struct ldb_request *req;
1117         PyObject *py_dn1, *py_dn2;
1118
1119         if (!PyArg_ParseTuple(args, "OO", &py_dn1, &py_dn2))
1120                 return NULL;
1121
1122         req = talloc_zero(NULL, struct ldb_request);
1123
1124         req->operation = LDB_RENAME;
1125         req->op.rename.olddn = PyLdbDn_AsDn(py_dn1);
1126         req->op.rename.newdn = PyLdbDn_AsDn(py_dn2);
1127
1128         ret = PyLdbModule_AsModule(self)->ops->rename(PyLdbModule_AsModule(self), req);
1129
1130         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, NULL);
1131
1132         return Py_None;
1133 }
1134
1135 static PyMethodDef py_ldb_module_methods[] = {
1136         { "search", (PyCFunction)py_ldb_module_search, METH_VARARGS|METH_KEYWORDS, NULL },
1137         { "add", (PyCFunction)py_ldb_module_add, METH_VARARGS, NULL },
1138         { "modify", (PyCFunction)py_ldb_module_modify, METH_VARARGS, NULL },
1139         { "rename", (PyCFunction)py_ldb_module_rename, METH_VARARGS, NULL },
1140         { "delete", (PyCFunction)py_ldb_module_delete, METH_VARARGS, NULL },
1141         { "start_transaction", (PyCFunction)py_ldb_module_start_transaction, METH_NOARGS, NULL },
1142         { "end_transaction", (PyCFunction)py_ldb_module_end_transaction, METH_NOARGS, NULL },
1143         { "del_transaction", (PyCFunction)py_ldb_module_del_transaction, METH_NOARGS, NULL },
1144         { NULL },
1145 };
1146
1147 PyTypeObject PyLdbModule = {
1148         .tp_name = "LdbModule",
1149         .tp_methods = py_ldb_module_methods,
1150         .tp_repr = (reprfunc)py_ldb_module_repr,
1151         .tp_str = (reprfunc)py_ldb_module_str,
1152         .tp_basicsize = sizeof(py_talloc_Object),
1153         .tp_dealloc = py_talloc_dealloc,
1154         .tp_flags = Py_TPFLAGS_DEFAULT,
1155 };
1156
1157 struct ldb_message_element *PyObject_AsMessageElement(TALLOC_CTX *mem_ctx,
1158                                                                                            PyObject *set_obj, int flags,
1159                                                                                            const char *attr_name)
1160 {
1161         struct ldb_message_element *me;
1162
1163         if (PyLdbMessageElement_Check(set_obj))
1164                 return PyLdbMessageElement_AsMessageElement(set_obj);
1165
1166         me = talloc(mem_ctx, struct ldb_message_element);
1167
1168         me->name = attr_name;
1169         me->flags = flags;
1170         if (PyString_Check(set_obj)) {
1171                 me->num_values = 1;
1172                 me->values = talloc_array(me, struct ldb_val, me->num_values);
1173                 me->values[0].length = PyString_Size(set_obj);
1174                 me->values[0].data = (uint8_t *)talloc_strdup(me->values,
1175                                                                                    PyString_AsString(set_obj));
1176         } else if (PySequence_Check(set_obj)) {
1177                 int i;
1178                 me->num_values = PySequence_Size(set_obj);
1179                 me->values = talloc_array(me, struct ldb_val, me->num_values);
1180                 for (i = 0; i < me->num_values; i++) {
1181                         PyObject *obj = PySequence_GetItem(set_obj, i);
1182                         me->values[i].length = PyString_Size(obj);
1183                         me->values[i].data = (uint8_t *)PyString_AsString(obj);
1184                 }
1185         } else {
1186                 talloc_free(me);
1187                 me = NULL;
1188         }
1189
1190         return me;
1191 }
1192
1193
1194 PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
1195                                                                  struct ldb_message_element *me)
1196 {
1197         int i;
1198         PyObject *result;
1199
1200         /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
1201         result = PyList_New(me->num_values);
1202
1203         for (i = 0; i < me->num_values; i++) {
1204                 PyList_SetItem(result, i,
1205                         PyObject_FromLdbValue(ldb_ctx, me, &me->values[i]));
1206         }
1207
1208         return result;
1209 }
1210
1211 PyObject *py_ldb_msg_element_get(PyLdbMessageElementObject *self, PyObject *args)
1212 {
1213         int i;
1214         if (!PyArg_ParseTuple(args, "i", &i))
1215                 return NULL;
1216         if (i < 0 || i >= PyLdbMessageElement_AsMessageElement(self)->num_values)
1217                 return Py_None;
1218
1219         return PyObject_FromLdbValue(NULL, PyLdbMessageElement_AsMessageElement(self),
1220                                                                  &(PyLdbMessageElement_AsMessageElement(self)->values[i]));
1221 }
1222
1223 static PyMethodDef py_ldb_msg_element_methods[] = {
1224         { "get", (PyCFunction)py_ldb_msg_element_get, METH_VARARGS, NULL },
1225         { NULL },
1226 };
1227
1228 static Py_ssize_t py_ldb_msg_element_len(PyLdbMessageElementObject *self)
1229 {
1230         return PyLdbMessageElement_AsMessageElement(self)->num_values;
1231 }
1232
1233 static PyObject *py_ldb_msg_element_find(PyLdbMessageElementObject *self, Py_ssize_t idx)
1234 {
1235         struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
1236         if (idx < 0 || idx >= el->num_values) {
1237                 PyErr_SetString(PyExc_IndexError, "Out of range");
1238                 return NULL;
1239         }
1240         return PyString_FromStringAndSize((char *)el->values[idx].data, el->values[idx].length);
1241 }
1242
1243 static PySequenceMethods py_ldb_msg_element_seq = {
1244         .sq_length = (lenfunc)py_ldb_msg_element_len,
1245         .sq_item = (ssizeargfunc)py_ldb_msg_element_find,
1246 };
1247
1248 static int py_ldb_msg_element_cmp(PyLdbMessageElementObject *self, PyLdbMessageElementObject *other)
1249 {
1250         return ldb_msg_element_compare(PyLdbMessageElement_AsMessageElement(self),
1251                                                                    PyLdbMessageElement_AsMessageElement(other));
1252 }
1253
1254 static PyObject *py_ldb_msg_element_iter(PyLdbMessageElementObject *self)
1255 {
1256         return PyObject_GetIter(ldb_msg_element_to_set(NULL, PyLdbMessageElement_AsMessageElement(self)));
1257 }
1258
1259 PyObject *PyLdbMessageElement_FromMessageElement(struct ldb_message_element *el)
1260 {
1261         return py_talloc_import(&PyLdbMessageElement, el);
1262 }
1263
1264 static PyObject *py_ldb_msg_element_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1265 {
1266         PyObject *py_elements = NULL;
1267         struct ldb_message_element *el;
1268         int flags = 0;
1269         char *name = NULL;
1270         const char *kwnames[] = { "elements", "flags", "name", NULL };
1271         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Ois", (char **)kwnames, &py_elements, &flags, &name))
1272                 return NULL;
1273
1274         el = talloc_zero(NULL, struct ldb_message_element);
1275
1276         if (py_elements != NULL) {
1277                 int i;
1278                 if (!PySequence_Check(py_elements)) {
1279                         el->num_values = 1;
1280                         el->values = talloc_array(el, struct ldb_val, 1);
1281                         el->values[0].data = (uint8_t *)PyString_AsString(py_elements);
1282                         el->values[0].length = PyString_Size(py_elements);
1283                 } else {
1284                         el->num_values = PySequence_Size(py_elements);
1285                         el->values = talloc_array(el, struct ldb_val, el->num_values);
1286                         for (i = 0; i < el->num_values; i++) {
1287                                 PyObject *item = PySequence_GetItem(py_elements, i);
1288                                 el->values[i].data = (uint8_t *)PyString_AsString(item);
1289                                 el->values[i].length = PyString_Size(item);
1290                         }
1291                 }
1292         }
1293
1294         el->flags = flags;
1295         el->name = talloc_strdup(el, name);
1296
1297         return py_talloc_import(&PyLdbMessageElement, el);
1298 }
1299
1300 static PyObject *py_ldb_msg_element_repr(PyLdbMessageElementObject *self)
1301 {
1302         char *element_str = NULL;
1303         int i;
1304         struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
1305         PyObject *ret;
1306
1307         for (i = 0; i < el->num_values; i++) {
1308                 PyObject *o = py_ldb_msg_element_find(self, i);
1309                 if (element_str == NULL)
1310                         element_str = talloc_strdup(NULL, PyObject_REPR(o));
1311                 else
1312                         element_str = talloc_asprintf_append(element_str, ",%s", PyObject_REPR(o));
1313         }
1314
1315         ret = PyString_FromFormat("MessageElement([%s])", element_str);
1316
1317         talloc_free(element_str);
1318
1319         return ret;
1320 }
1321
1322 PyTypeObject PyLdbMessageElement = {
1323         .tp_name = "MessageElement",
1324         .tp_basicsize = sizeof(PyLdbMessageElementObject),
1325         .tp_dealloc = py_talloc_dealloc,
1326         .tp_repr = (reprfunc)py_ldb_msg_element_repr,
1327         .tp_methods = py_ldb_msg_element_methods,
1328         .tp_compare = (cmpfunc)py_ldb_msg_element_cmp,
1329         .tp_iter = (getiterfunc)py_ldb_msg_element_iter,
1330         .tp_as_sequence = &py_ldb_msg_element_seq,
1331         .tp_new = py_ldb_msg_element_new,
1332         .tp_flags = Py_TPFLAGS_DEFAULT,
1333 };
1334
1335 static PyObject *py_ldb_msg_remove_attr(PyLdbMessageObject *self, PyObject *args)
1336 {
1337         char *name;
1338         if (!PyArg_ParseTuple(args, "s", &name))
1339                 return NULL;
1340
1341         ldb_msg_remove_attr(self->ptr, name);
1342
1343         return Py_None;
1344 }
1345
1346 static PyObject *py_ldb_msg_keys(PyLdbMessageObject *self)
1347 {
1348         struct ldb_message *msg = PyLdbMessage_AsMessage(self);
1349         int i, j = 0;
1350         PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
1351         if (msg->dn != NULL) {
1352                 PyList_SetItem(obj, j, PyString_FromString("dn"));
1353                 j++;
1354         }
1355         for (i = 0; i < msg->num_elements; i++) {
1356                 PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
1357                 j++;
1358         }
1359         return obj;
1360 }
1361
1362 static PyObject *py_ldb_msg_getitem_helper(PyLdbMessageObject *self, PyObject *py_name)
1363 {
1364         struct ldb_message_element *el;
1365         char *name = PyString_AsString(py_name);
1366         if (!strcmp(name, "dn"))
1367                 return PyLdbDn_FromDn(PyLdbMessage_AsMessage(self)->dn);
1368         el = ldb_msg_find_element(PyLdbMessage_AsMessage(self), name);
1369         if (el == NULL) {
1370                 return NULL;
1371         }
1372         return (PyObject *)PyLdbMessageElement_FromMessageElement(el);
1373 }
1374
1375 static PyObject *py_ldb_msg_getitem(PyLdbMessageObject *self, PyObject *py_name)
1376 {
1377         PyObject *ret = py_ldb_msg_getitem_helper(self, py_name);
1378         if (ret == NULL) {
1379                 PyErr_SetString(PyExc_KeyError, "No such element");
1380                 return NULL;
1381         }
1382         return ret;
1383 }
1384
1385 static PyObject *py_ldb_msg_get(PyLdbMessageObject *self, PyObject *args)
1386 {
1387         PyObject *name, *ret;
1388         if (!PyArg_ParseTuple(args, "O", &name))
1389                 return NULL;
1390
1391         ret = py_ldb_msg_getitem_helper(self, name);
1392         if (ret == NULL)
1393                 return Py_None;
1394         return ret;
1395 }
1396
1397 static PyObject *py_ldb_msg_items(PyLdbMessageObject *self)
1398 {
1399         struct ldb_message *msg = PyLdbMessage_AsMessage(self);
1400         int i, j;
1401         PyObject *l = PyList_New(msg->num_elements + (msg->dn == NULL?0:1));
1402         j = 0;
1403         if (msg->dn != NULL) {
1404                 PyList_SetItem(l, 0, Py_BuildValue("(sO)", "dn", PyLdbDn_FromDn(msg->dn)));
1405                 j++;
1406         }
1407         for (i = 0; i < msg->num_elements; i++, j++) {
1408                 PyList_SetItem(l, j, Py_BuildValue("(sO)", msg->elements[i].name, PyLdbMessageElement_FromMessageElement(&msg->elements[i])));
1409         }
1410         return l;
1411 }
1412
1413 static PyMethodDef py_ldb_msg_methods[] = {
1414         { "keys", (PyCFunction)py_ldb_msg_keys, METH_NOARGS, NULL },
1415         { "remove", (PyCFunction)py_ldb_msg_remove_attr, METH_VARARGS, NULL },
1416         { "get", (PyCFunction)py_ldb_msg_get, METH_VARARGS, NULL },
1417         { "items", (PyCFunction)py_ldb_msg_items, METH_NOARGS, NULL },
1418         { NULL },
1419 };
1420
1421 static int py_ldb_msg_setitem(PyLdbMessageObject *self, PyObject *name, PyObject *value)
1422 {
1423         char *attr_name = PyString_AsString(name);
1424         if (value == NULL) {
1425                 ldb_msg_remove_attr(self->ptr, attr_name);
1426         } else {
1427                 struct ldb_message_element *el = PyObject_AsMessageElement(NULL,
1428                                                                                         value, 0, attr_name);
1429                 if (el == NULL)
1430                         return -1;
1431                 talloc_steal(self->ptr, el);
1432                 ldb_msg_remove_attr(PyLdbMessage_AsMessage(self), attr_name);
1433                 ldb_msg_add(PyLdbMessage_AsMessage(self), el, el->flags);
1434         }
1435         return 0;
1436 }
1437
1438 static Py_ssize_t py_ldb_msg_length(PyLdbMessageObject *self)
1439 {
1440         return PyLdbMessage_AsMessage(self)->num_elements;
1441 }
1442
1443 static PyMappingMethods py_ldb_msg_mapping = {
1444         .mp_length = (lenfunc)py_ldb_msg_length,
1445         .mp_subscript = (binaryfunc)py_ldb_msg_getitem,
1446         .mp_ass_subscript = (objobjargproc)py_ldb_msg_setitem,
1447 };
1448
1449 static PyObject *py_ldb_msg_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1450 {
1451         const char *kwnames[] = { "dn", NULL };
1452         struct ldb_message *ret;
1453         PyObject *pydn = NULL;
1454         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", (char **)kwnames, &pydn))
1455                 return NULL;
1456
1457         ret = ldb_msg_new(NULL);
1458         if (ret == NULL) {
1459                 PyErr_NoMemory();
1460                 return NULL;
1461         }
1462
1463         if (pydn != NULL)
1464                 if (!PyObject_AsDn(NULL, pydn, NULL, &ret->dn))
1465                         return NULL;
1466
1467         return py_talloc_import(type, ret);
1468 }
1469
1470 PyObject *PyLdbMessage_FromMessage(struct ldb_message *msg)
1471 {
1472         return py_talloc_import(&PyLdbMessage, msg);
1473 }
1474
1475 static PyObject *py_ldb_msg_get_dn(PyLdbMessageObject *self, void *closure)
1476 {
1477         return PyLdbDn_FromDn(PyLdbMessage_AsMessage(self)->dn);
1478 }
1479
1480 static int py_ldb_msg_set_dn(PyLdbMessageObject *self, PyObject *value, void *closure)
1481 {
1482         PyLdbMessage_AsMessage(self)->dn = PyLdbDn_AsDn(value);
1483         return 0;
1484 }
1485
1486 static PyGetSetDef py_ldb_msg_getset[] = {
1487         { (char *)"dn", (getter)py_ldb_msg_get_dn, (setter)py_ldb_msg_set_dn, NULL },
1488         { NULL }
1489 };
1490
1491 static PyObject *py_ldb_msg_repr(PyLdbMessageObject *self)
1492 {
1493         PyObject *dict = PyDict_New(), *ret;
1494         if (PyDict_Update(dict, (PyObject *)self) != 0)
1495                 return NULL;
1496         ret = PyString_FromFormat("Message(%s)", PyObject_REPR(dict));
1497         Py_DECREF(dict);
1498         return ret;
1499 }
1500
1501 PyTypeObject PyLdbMessage = {
1502         .tp_name = "Message",
1503         .tp_methods = py_ldb_msg_methods,
1504         .tp_getset = py_ldb_msg_getset,
1505         .tp_as_mapping = &py_ldb_msg_mapping,
1506         .tp_basicsize = sizeof(PyLdbMessageObject),
1507         .tp_dealloc = py_talloc_dealloc,
1508         .tp_new = py_ldb_msg_new,
1509         .tp_repr = (reprfunc)py_ldb_msg_repr,
1510         .tp_flags = Py_TPFLAGS_DEFAULT,
1511 };
1512
1513 PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *tree)
1514 {
1515         return py_talloc_import(&PyLdbTree, tree);
1516 }
1517
1518 PyTypeObject PyLdbTree = {
1519         .tp_name = "Tree",
1520         .tp_basicsize = sizeof(PyLdbTreeObject),
1521         .tp_dealloc = py_talloc_dealloc,
1522         .tp_flags = Py_TPFLAGS_DEFAULT,
1523 };
1524
1525 /* Ldb_module */
1526 int py_module_search(struct ldb_module *mod, struct ldb_request *req)
1527 {
1528         PyObject *py_ldb = mod->private_data;
1529         PyObject *py_result, *py_base, *py_attrs, *py_tree;
1530
1531         py_base = PyLdbDn_FromDn(req->op.search.base);
1532
1533         if (py_base == NULL)
1534                 return LDB_ERR_OPERATIONS_ERROR;
1535
1536         py_tree = PyLdbTree_FromTree(req->op.search.tree);
1537
1538         if (py_tree == NULL)
1539                 return LDB_ERR_OPERATIONS_ERROR;
1540
1541         if (req->op.search.attrs == NULL) {
1542                 py_attrs = Py_None;
1543         } else {
1544                 int i, len;
1545                 for (len = 0; req->op.search.attrs[len]; len++);
1546                 py_attrs = PyList_New(len);
1547                 for (i = 0; i < len; i++)
1548                         PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
1549         }
1550
1551         py_result = PyObject_CallMethod(py_ldb, (char *)"search", (char *)"OiOO", py_base, req->op.search.scope, py_tree, py_attrs);
1552
1553         Py_DECREF(py_attrs);
1554         Py_DECREF(py_tree);
1555         Py_DECREF(py_base);
1556
1557         if (py_result == NULL) {
1558                 return LDB_ERR_OPERATIONS_ERROR;
1559         }
1560
1561         req->op.search.res = PyLdbResult_AsResult(NULL, py_result);
1562         if (req->op.search.res == NULL) {
1563                 return LDB_ERR_OPERATIONS_ERROR;
1564         }
1565
1566         Py_DECREF(py_result);
1567
1568         return LDB_SUCCESS;
1569 }
1570
1571 int py_module_add(struct ldb_module *mod, struct ldb_request *req)
1572 {
1573         PyObject *py_ldb = mod->private_data;
1574         PyObject *py_result, *py_msg;
1575
1576         py_msg = PyLdbMessage_FromMessage((struct ldb_message *)req->op.add.message);
1577
1578         if (py_msg == NULL) {
1579                 return LDB_ERR_OPERATIONS_ERROR;
1580         }
1581
1582         py_result = PyObject_CallMethod(py_ldb, (char *)"add", (char *)"O", py_msg);
1583
1584         Py_DECREF(py_msg);
1585
1586         if (py_result == NULL) {
1587                 return LDB_ERR_OPERATIONS_ERROR;
1588         }
1589
1590         Py_DECREF(py_result);
1591
1592         return LDB_SUCCESS;
1593 }
1594
1595 int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
1596 {
1597         PyObject *py_ldb = mod->private_data;
1598         PyObject *py_result, *py_msg;
1599
1600         py_msg = PyLdbMessage_FromMessage((struct ldb_message *)req->op.mod.message);
1601
1602         if (py_msg == NULL) {
1603                 return LDB_ERR_OPERATIONS_ERROR;
1604         }
1605
1606         py_result = PyObject_CallMethod(py_ldb, (char *)"modify", (char *)"O", py_msg);
1607
1608         Py_DECREF(py_msg);
1609
1610         if (py_result == NULL) {
1611                 return LDB_ERR_OPERATIONS_ERROR;
1612         }
1613
1614         Py_DECREF(py_result);
1615
1616         return LDB_SUCCESS;
1617 }
1618
1619 int py_module_del(struct ldb_module *mod, struct ldb_request *req)
1620 {
1621         PyObject *py_ldb = mod->private_data;
1622         PyObject *py_result, *py_dn;
1623
1624         py_dn = PyLdbDn_FromDn(req->op.del.dn);
1625
1626         if (py_dn == NULL)
1627                 return LDB_ERR_OPERATIONS_ERROR;
1628
1629         py_result = PyObject_CallMethod(py_ldb, (char *)"delete", (char *)"O", py_dn);
1630
1631         if (py_result == NULL) {
1632                 return LDB_ERR_OPERATIONS_ERROR;
1633         }
1634
1635         Py_DECREF(py_result);
1636
1637         return LDB_SUCCESS;
1638 }
1639
1640 int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
1641 {
1642         PyObject *py_ldb = mod->private_data;
1643         PyObject *py_result, *py_olddn, *py_newdn;
1644
1645         py_olddn = PyLdbDn_FromDn(req->op.rename.olddn);
1646
1647         if (py_olddn == NULL)
1648                 return LDB_ERR_OPERATIONS_ERROR;
1649
1650         py_newdn = PyLdbDn_FromDn(req->op.rename.newdn);
1651
1652         if (py_newdn == NULL)
1653                 return LDB_ERR_OPERATIONS_ERROR;
1654
1655         py_result = PyObject_CallMethod(py_ldb, (char *)"rename", (char *)"OO", py_olddn, py_newdn);
1656
1657         Py_DECREF(py_olddn);
1658         Py_DECREF(py_newdn);
1659
1660         if (py_result == NULL) {
1661                 return LDB_ERR_OPERATIONS_ERROR;
1662         }
1663
1664         Py_DECREF(py_result);
1665
1666         return LDB_SUCCESS;
1667 }
1668
1669 int py_module_request(struct ldb_module *mod, struct ldb_request *req)
1670 {
1671         PyObject *py_ldb = mod->private_data;
1672         PyObject *py_result;
1673
1674         py_result = PyObject_CallMethod(py_ldb, (char *)"request", (char *)"");
1675
1676         return LDB_ERR_OPERATIONS_ERROR;
1677 }
1678
1679 int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
1680 {
1681         PyObject *py_ldb = mod->private_data;
1682         PyObject *py_result;
1683
1684         py_result = PyObject_CallMethod(py_ldb, (char *)"extended", (char *)"");
1685
1686         return LDB_ERR_OPERATIONS_ERROR;
1687 }
1688
1689 int py_module_start_transaction(struct ldb_module *mod)
1690 {
1691         PyObject *py_ldb = mod->private_data;
1692         PyObject *py_result;
1693
1694         py_result = PyObject_CallMethod(py_ldb, (char *)"start_transaction", (char *)"");
1695
1696         if (py_result == NULL) {
1697                 return LDB_ERR_OPERATIONS_ERROR;
1698         }
1699
1700         Py_DECREF(py_result);
1701
1702         return LDB_SUCCESS;
1703 }
1704
1705 int py_module_end_transaction(struct ldb_module *mod)
1706 {
1707         PyObject *py_ldb = mod->private_data;
1708         PyObject *py_result;
1709
1710         py_result = PyObject_CallMethod(py_ldb, (char *)"end_transaction", (char *)"");
1711
1712         if (py_result == NULL) {
1713                 return LDB_ERR_OPERATIONS_ERROR;
1714         }
1715
1716         Py_DECREF(py_result);
1717
1718         return LDB_SUCCESS;
1719 }
1720
1721 int py_module_del_transaction(struct ldb_module *mod)
1722 {
1723         PyObject *py_ldb = mod->private_data;
1724         PyObject *py_result;
1725
1726         py_result = PyObject_CallMethod(py_ldb, (char *)"del_transaction", (char *)"");
1727
1728         if (py_result == NULL) {
1729                 return LDB_ERR_OPERATIONS_ERROR;
1730         }
1731
1732         Py_DECREF(py_result);
1733
1734         return LDB_SUCCESS;
1735 }
1736
1737 static int py_module_destructor(struct ldb_module *mod)
1738 {
1739         Py_DECREF((PyObject *)mod->private_data);
1740         return 0;
1741 }
1742
1743 int py_module_init (struct ldb_module *mod)
1744 {
1745         PyObject *py_class = mod->ops->private_data;
1746         PyObject *py_result, *py_next, *py_ldb;
1747
1748         py_ldb = PyLdb_FromLdbContext(mod->ldb);
1749
1750         if (py_ldb == NULL)
1751                 return LDB_ERR_OPERATIONS_ERROR;
1752
1753         py_next = PyLdbModule_FromModule(mod->next);
1754
1755         if (py_next == NULL)
1756                 return LDB_ERR_OPERATIONS_ERROR;
1757
1758         py_result = PyObject_CallFunction(py_class, (char *)"OO", py_ldb, py_next);
1759
1760         if (py_result == NULL) {
1761                 return LDB_ERR_OPERATIONS_ERROR;
1762         }
1763
1764         mod->private_data = py_result;
1765
1766         talloc_set_destructor(mod, py_module_destructor);
1767
1768         return ldb_next_init(mod);
1769 }
1770
1771 static PyObject *py_register_module(PyObject *module, PyObject *args)
1772 {
1773         int ret;
1774         struct ldb_module_ops *ops;
1775         PyObject *input;
1776
1777         if (!PyArg_ParseTuple(args, "O", &input))
1778                 return NULL;
1779
1780         ops = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
1781         if (ops == NULL) {
1782                 PyErr_NoMemory();
1783                 return NULL;
1784         }
1785
1786         ops->name = talloc_strdup(ops, PyString_AsString(PyObject_GetAttrString(input, (char *)"name")));
1787
1788         Py_INCREF(input);
1789         ops->private_data = input;
1790         ops->init_context = py_module_init;
1791         ops->search = py_module_search;
1792         ops->add = py_module_add;
1793         ops->modify = py_module_modify;
1794         ops->del = py_module_del;
1795         ops->rename = py_module_rename;
1796         ops->request = py_module_request;
1797         ops->extended = py_module_extended;
1798         ops->start_transaction = py_module_start_transaction;
1799         ops->end_transaction = py_module_end_transaction;
1800         ops->del_transaction = py_module_del_transaction;
1801
1802         ret = ldb_register_module(ops);
1803
1804         PyErr_LDB_ERROR_IS_ERR_RAISE(ret, NULL);
1805
1806         return Py_None;
1807 }
1808
1809 static PyObject *py_timestring(PyObject *module, PyObject *args)
1810 {
1811         time_t t;
1812         char *tresult;
1813         PyObject *ret;
1814         if (!PyArg_ParseTuple(args, "L", &t))
1815                 return NULL;
1816         tresult = ldb_timestring(NULL, t);
1817         ret = PyString_FromString(tresult);
1818         talloc_free(tresult);
1819         return ret;
1820 }
1821
1822 static PyObject *py_string_to_time(PyObject *module, PyObject *args)
1823 {
1824         char *str;
1825         if (!PyArg_ParseTuple(args, "s", &str))
1826                 return NULL;
1827
1828         return PyInt_FromLong(ldb_string_to_time(str));
1829 }
1830
1831 static PyObject *py_valid_attr_name(PyObject *self, PyObject *args)
1832 {
1833         char *name;
1834         if (!PyArg_ParseTuple(args, "s", &name))
1835                 return NULL;
1836         return PyBool_FromLong(ldb_valid_attr_name(name));
1837 }
1838
1839 static PyMethodDef py_ldb_global_methods[] = {
1840         { "register_module", py_register_module, METH_VARARGS,
1841                 "S.register_module(module) -> None\n"
1842                 "Register a LDB module."},
1843         { "timestring", py_timestring, METH_VARARGS,
1844                 "S.timestring(int) -> string\n"
1845                 "Generate a LDAP time string from a UNIX timestamp" },
1846         { "string_to_time", py_string_to_time, METH_VARARGS,
1847                 "S.string_to_time(string) -> int\n"
1848                 "Parse a LDAP time string into a UNIX timestamp." },
1849         { "valid_attr_name", py_valid_attr_name, METH_VARARGS,
1850                 "S.valid_attr_name(name) -> bool\n"
1851                 "Check whether the supplied name is a valid attribute name." },
1852         { "open", (PyCFunction)py_ldb_new, METH_VARARGS|METH_KEYWORDS,
1853                 NULL },
1854         { NULL }
1855 };
1856
1857 void initldb(void)
1858 {
1859         PyObject *m;
1860
1861         if (PyType_Ready(&PyLdbDn) < 0)
1862                 return;
1863
1864         if (PyType_Ready(&PyLdbMessage) < 0)
1865                 return;
1866
1867         if (PyType_Ready(&PyLdbMessageElement) < 0)
1868                 return;
1869
1870         if (PyType_Ready(&PyLdb) < 0)
1871                 return;
1872
1873         if (PyType_Ready(&PyLdbModule) < 0)
1874                 return;
1875
1876         if (PyType_Ready(&PyLdbTree) < 0)
1877                 return;
1878
1879         m = Py_InitModule3("ldb", py_ldb_global_methods,
1880                 "An interface to LDB, a LDAP-like API that can either to talk an embedded database (TDB-based) or a standards-compliant LDAP server.");
1881         if (m == NULL)
1882                 return;
1883
1884         PyModule_AddObject(m, "SCOPE_DEFAULT", PyInt_FromLong(LDB_SCOPE_DEFAULT));
1885         PyModule_AddObject(m, "SCOPE_BASE", PyInt_FromLong(LDB_SCOPE_BASE));
1886         PyModule_AddObject(m, "SCOPE_ONELEVEL", PyInt_FromLong(LDB_SCOPE_ONELEVEL));
1887         PyModule_AddObject(m, "SCOPE_SUBTREE", PyInt_FromLong(LDB_SCOPE_SUBTREE));
1888
1889         PyModule_AddObject(m, "CHANGETYPE_NONE", PyInt_FromLong(LDB_CHANGETYPE_NONE));
1890         PyModule_AddObject(m, "CHANGETYPE_ADD", PyInt_FromLong(LDB_CHANGETYPE_ADD));
1891         PyModule_AddObject(m, "CHANGETYPE_DELETE", PyInt_FromLong(LDB_CHANGETYPE_DELETE));
1892         PyModule_AddObject(m, "CHANGETYPE_MODIFY", PyInt_FromLong(LDB_CHANGETYPE_MODIFY));
1893
1894         PyModule_AddObject(m, "SUCCESS", PyInt_FromLong(LDB_SUCCESS));
1895         PyModule_AddObject(m, "ERR_OPERATIONS_ERROR", PyInt_FromLong(LDB_ERR_OPERATIONS_ERROR));
1896         PyModule_AddObject(m, "ERR_PROTOCOL_ERROR", PyInt_FromLong(LDB_ERR_PROTOCOL_ERROR));
1897         PyModule_AddObject(m, "ERR_TIME_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_TIME_LIMIT_EXCEEDED));
1898         PyModule_AddObject(m, "ERR_SIZE_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_SIZE_LIMIT_EXCEEDED));
1899         PyModule_AddObject(m, "ERR_COMPARE_FALSE", PyInt_FromLong(LDB_ERR_COMPARE_FALSE));
1900         PyModule_AddObject(m, "ERR_COMPARE_TRUE", PyInt_FromLong(LDB_ERR_COMPARE_TRUE));
1901         PyModule_AddObject(m, "ERR_AUTH_METHOD_NOT_SUPPORTED", PyInt_FromLong(LDB_ERR_AUTH_METHOD_NOT_SUPPORTED));
1902         PyModule_AddObject(m, "ERR_STRONG_AUTH_REQUIRED", PyInt_FromLong(LDB_ERR_STRONG_AUTH_REQUIRED));
1903         PyModule_AddObject(m, "ERR_REFERRAL", PyInt_FromLong(LDB_ERR_REFERRAL));
1904         PyModule_AddObject(m, "ERR_ADMIN_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_ADMIN_LIMIT_EXCEEDED));
1905         PyModule_AddObject(m, "ERR_UNSUPPORTED_CRITICAL_EXTENSION", PyInt_FromLong(LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION));
1906         PyModule_AddObject(m, "ERR_CONFIDENTIALITY_REQUIRED", PyInt_FromLong(LDB_ERR_CONFIDENTIALITY_REQUIRED));
1907         PyModule_AddObject(m, "ERR_SASL_BIND_IN_PROGRESS", PyInt_FromLong(LDB_ERR_SASL_BIND_IN_PROGRESS));
1908         PyModule_AddObject(m, "ERR_NO_SUCH_ATTRIBUTE", PyInt_FromLong(LDB_ERR_NO_SUCH_ATTRIBUTE));
1909         PyModule_AddObject(m, "ERR_UNDEFINED_ATTRIBUTE_TYPE", PyInt_FromLong(LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE));
1910         PyModule_AddObject(m, "ERR_INAPPROPRIATE_MATCHING", PyInt_FromLong(LDB_ERR_INAPPROPRIATE_MATCHING));
1911         PyModule_AddObject(m, "ERR_CONSTRAINT_VIOLATION", PyInt_FromLong(LDB_ERR_CONSTRAINT_VIOLATION));
1912         PyModule_AddObject(m, "ERR_ATTRIBUTE_OR_VALUE_EXISTS", PyInt_FromLong(LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS));
1913         PyModule_AddObject(m, "ERR_INVALID_ATTRIBUTE_SYNTAX", PyInt_FromLong(LDB_ERR_INVALID_ATTRIBUTE_SYNTAX));
1914         PyModule_AddObject(m, "ERR_NO_SUCH_OBJECT", PyInt_FromLong(LDB_ERR_NO_SUCH_OBJECT));
1915         PyModule_AddObject(m, "ERR_ALIAS_PROBLEM", PyInt_FromLong(LDB_ERR_ALIAS_PROBLEM));
1916         PyModule_AddObject(m, "ERR_INVALID_DN_SYNTAX", PyInt_FromLong(LDB_ERR_INVALID_DN_SYNTAX));
1917         PyModule_AddObject(m, "ERR_ALIAS_DEREFERINCING_PROBLEM", PyInt_FromLong(LDB_ERR_ALIAS_DEREFERENCING_PROBLEM));
1918         PyModule_AddObject(m, "ERR_INAPPROPRIATE_AUTHENTICATION", PyInt_FromLong(LDB_ERR_INAPPROPRIATE_AUTHENTICATION));
1919         PyModule_AddObject(m, "ERR_INVALID_CREDENTIALS", PyInt_FromLong(LDB_ERR_INVALID_CREDENTIALS));
1920         PyModule_AddObject(m, "ERR_INSUFFICIENT_ACCESS_RIGHTS", PyInt_FromLong(LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS));
1921         PyModule_AddObject(m, "ERR_BUSY", PyInt_FromLong(LDB_ERR_BUSY));
1922         PyModule_AddObject(m, "ERR_UNAVAILABLE", PyInt_FromLong(LDB_ERR_UNAVAILABLE));
1923         PyModule_AddObject(m, "ERR_UNWILLING_TO_PERFORM", PyInt_FromLong(LDB_ERR_UNWILLING_TO_PERFORM));
1924         PyModule_AddObject(m, "ERR_LOOP_DETECT", PyInt_FromLong(LDB_ERR_LOOP_DETECT));
1925         PyModule_AddObject(m, "ERR_NAMING_VIOLATION", PyInt_FromLong(LDB_ERR_NAMING_VIOLATION));
1926         PyModule_AddObject(m, "ERR_OBJECT_CLASS_VIOLATION", PyInt_FromLong(LDB_ERR_OBJECT_CLASS_VIOLATION));
1927         PyModule_AddObject(m, "ERR_NOT_ALLOWED_ON_NON_LEAF", PyInt_FromLong(LDB_ERR_NOT_ALLOWED_ON_NON_LEAF));
1928         PyModule_AddObject(m, "ERR_NOT_ALLOWED_ON_RDN", PyInt_FromLong(LDB_ERR_NOT_ALLOWED_ON_RDN));
1929         PyModule_AddObject(m, "ERR_ENTYR_ALREADY_EXISTS", PyInt_FromLong(LDB_ERR_ENTRY_ALREADY_EXISTS));
1930         PyModule_AddObject(m, "ERR_OBJECT_CLASS_MODS_PROHIBITED", PyInt_FromLong(LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED));
1931         PyModule_AddObject(m, "ERR_AFFECTS_MULTIPLE_DSAS", PyInt_FromLong(LDB_ERR_AFFECTS_MULTIPLE_DSAS));
1932
1933         PyModule_AddObject(m, "ERR_OTHER", PyInt_FromLong(LDB_ERR_OTHER));
1934
1935         PyModule_AddObject(m, "__docformat__", PyString_FromString("restructuredText"));
1936
1937         PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
1938         PyModule_AddObject(m, "LdbError", PyExc_LdbError);
1939
1940         Py_INCREF(&PyLdb);
1941         Py_INCREF(&PyLdbDn);
1942         Py_INCREF(&PyLdbModule);
1943         Py_INCREF(&PyLdbMessage);
1944         Py_INCREF(&PyLdbMessageElement);
1945         Py_INCREF(&PyLdbTree);
1946
1947         PyModule_AddObject(m, "Ldb", (PyObject *)&PyLdb);
1948         PyModule_AddObject(m, "Dn", (PyObject *)&PyLdbDn);
1949         PyModule_AddObject(m, "Message", (PyObject *)&PyLdbMessage);
1950         PyModule_AddObject(m, "MessageElement", (PyObject *)&PyLdbMessageElement);
1951         PyModule_AddObject(m, "Module", (PyObject *)&PyLdbModule);
1952         PyModule_AddObject(m, "Tree", (PyObject *)&PyLdbTree);
1953 }
1954
1955 #if 0
1956
1957 /* ldb_message_element */
1958 %rename(MessageElement) ldb_message_element;
1959 %feature("docstring") ldb_message_element "Message element.";
1960 typedef struct ldb_message_element {
1961         %extend {
1962                         PyObject *__set__(void)
1963                 {
1964                         return ldb_msg_element_to_set(NULL, $self);
1965                 }
1966
1967                 ldb_message_element(PyObject *set_obj, int flags=0, const char *name = NULL)
1968                 {
1969                         return PyObject_AsMessageElement(NULL, set_obj, flags, name);
1970                 }
1971
1972         }
1973         %pythoncode {
1974                 def __getitem__(self, i):
1975                         ret = self.get(i)
1976                         if ret is None:
1977                                 raise KeyError("no such value")
1978                         return ret
1979
1980                 def __repr__(self):
1981                         return "MessageElement([%s])" % (",".join(repr(x) for x in self.__set__()))
1982         }
1983 } ldb_message_element;
1984
1985 /* ldb_message */
1986
1987 typedef struct ldb_message {
1988         ldb_dn *dn;
1989
1990         %extend {
1991                 ldb_msg(ldb_dn *dn = NULL) {
1992                         ret->dn = talloc_reference(ret, dn);
1993                         return ret;
1994                 }
1995
1996                 void __setitem__(const char *attr_name, ldb_message_element *val)
1997                 {
1998                         struct ldb_message_element *el;
1999
2000                         ldb_msg_remove_attr($self, attr_name);
2001
2002                         el = talloc($self, struct ldb_message_element);
2003                         el->name = talloc_strdup(el, attr_name);
2004                         el->num_values = val->num_values;
2005                         el->values = talloc_reference(el, val->values);
2006
2007                         ldb_msg_add($self, el, val->flags);
2008                 }
2009
2010                 void __setitem__(const char *attr_name, PyObject *val)
2011                 {
2012                 }
2013 %pythoncode {
2014         def get(self, key, default=None):
2015                 if key == "dn":
2016                         return self.dn
2017                 return self.find_element(key)
2018
2019         def iteritems(self):
2020                 for k in self.keys():
2021                         yield k, self[k]
2022
2023         def items(self):
2024                 return list(self.iteritems())
2025
2026         def __repr__(self):
2027                 return "Message(%s)" % repr(dict(self.iteritems()))
2028 }
2029         }
2030 } ldb_msg;
2031
2032 typedef struct ldb_context {
2033         %pythoncode {
2034                 def itermodules(self):
2035                         m = self.firstmodule
2036                         while m is not None:
2037                                 yield m
2038                                 m = m.next
2039
2040                 def modules(self):
2041                         return list(self.itermodules())
2042         }
2043 } ldb;
2044 #endif