lib/ldb/pyldb.c

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