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         .tp_doc = "LDB module (extension)",
2121 };
2122
2123
2124 /**
2125  * Create a ldb_message_element from a Python object.
2126  *
2127  * This will accept any sequence objects that contains strings, or
2128  * a string object.
2129  *
2130  * A reference to set_obj will be borrowed.
2131  *
2132  * @param mem_ctx Memory context
2133  * @param set_obj Python object to convert
2134  * @param flags ldb_message_element flags to set
2135  * @param attr_name Name of the attribute
2136  * @return New ldb_message_element, allocated as child of mem_ctx
2137  */
2138 static struct ldb_message_element *PyObject_AsMessageElement(
2139                                                       TALLOC_CTX *mem_ctx,
2140                                                       PyObject *set_obj,
2141                                                       unsigned int flags,
2142                                                       const char *attr_name)
2143 {
2144         struct ldb_message_element *me;
2145
2146         if (pyldb_MessageElement_Check(set_obj)) {
2147                 PyLdbMessageElementObject *set_obj_as_me = (PyLdbMessageElementObject *)set_obj;
2148                 /* We have to talloc_reference() the memory context, not the pointer
2149                  * which may not actually be it's own context */
2150                 if (talloc_reference(mem_ctx, set_obj_as_me->mem_ctx)) {
2151                         return pyldb_MessageElement_AsMessageElement(set_obj);
2152                 }
2153                 return NULL;
2154         }
2155
2156         me = talloc(mem_ctx, struct ldb_message_element);
2157         if (me == NULL) {
2158                 PyErr_NoMemory();
2159                 return NULL;
2160         }
2161
2162         me->name = talloc_strdup(me, attr_name);
2163         me->flags = flags;
2164         if (PyString_Check(set_obj)) {
2165                 me->num_values = 1;
2166                 me->values = talloc_array(me, struct ldb_val, me->num_values);
2167                 me->values[0].length = PyString_Size(set_obj);
2168                 me->values[0].data = talloc_memdup(me,
2169                         (uint8_t *)PyString_AsString(set_obj), me->values[0].length+1);
2170         } else if (PySequence_Check(set_obj)) {
2171                 Py_ssize_t i;
2172                 me->num_values = PySequence_Size(set_obj);
2173                 me->values = talloc_array(me, struct ldb_val, me->num_values);
2174                 for (i = 0; i < me->num_values; i++) {
2175                         PyObject *obj = PySequence_GetItem(set_obj, i);
2176                         if (!PyString_Check(obj)) {
2177                                 PyErr_Format(PyExc_TypeError,
2178                                              "Expected string as element %zd in list", i);
2179                                 talloc_free(me);
2180                                 return NULL;
2181                         }
2182
2183                         me->values[i].length = PyString_Size(obj);
2184                         me->values[i].data = talloc_memdup(me,
2185                                 (uint8_t *)PyString_AsString(obj), me->values[i].length+1);
2186                 }
2187         } else {
2188                 talloc_free(me);
2189                 me = NULL;
2190         }
2191
2192         return me;
2193 }
2194
2195
2196 static PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
2197                                         struct ldb_message_element *me)
2198 {
2199         Py_ssize_t i;
2200         PyObject *result;
2201
2202         /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
2203         result = PyList_New(me->num_values);
2204
2205         for (i = 0; i < me->num_values; i++) {
2206                 PyList_SetItem(result, i,
2207                         PyObject_FromLdbValue(&me->values[i]));
2208         }
2209
2210         return result;
2211 }
2212
2213 static PyObject *py_ldb_msg_element_get(PyLdbMessageElementObject *self, PyObject *args)
2214 {
2215         unsigned int i;
2216         if (!PyArg_ParseTuple(args, "I", &i))
2217                 return NULL;
2218         if (i >= pyldb_MessageElement_AsMessageElement(self)->num_values)
2219                 Py_RETURN_NONE;
2220
2221         return PyObject_FromLdbValue(&(pyldb_MessageElement_AsMessageElement(self)->values[i]));
2222 }
2223
2224 static PyObject *py_ldb_msg_element_flags(PyLdbMessageElementObject *self, PyObject *args)
2225 {
2226         struct ldb_message_element *el = pyldb_MessageElement_AsMessageElement(self);
2227         return PyInt_FromLong(el->flags);
2228 }
2229
2230 static PyObject *py_ldb_msg_element_set_flags(PyLdbMessageElementObject *self, PyObject *args)
2231 {
2232         unsigned int flags;
2233         struct ldb_message_element *el;
2234         if (!PyArg_ParseTuple(args, "I", &flags))
2235                 return NULL;
2236
2237         el = pyldb_MessageElement_AsMessageElement(self);
2238         el->flags = flags;
2239         Py_RETURN_NONE;
2240 }
2241
2242 static PyMethodDef py_ldb_msg_element_methods[] = {
2243         { "get", (PyCFunction)py_ldb_msg_element_get, METH_VARARGS, NULL },
2244         { "set_flags", (PyCFunction)py_ldb_msg_element_set_flags, METH_VARARGS, NULL },
2245         { "flags", (PyCFunction)py_ldb_msg_element_flags, METH_NOARGS, NULL },
2246         { NULL },
2247 };
2248
2249 static Py_ssize_t py_ldb_msg_element_len(PyLdbMessageElementObject *self)
2250 {
2251         return pyldb_MessageElement_AsMessageElement(self)->num_values;
2252 }
2253
2254 static PyObject *py_ldb_msg_element_find(PyLdbMessageElementObject *self, Py_ssize_t idx)
2255 {
2256         struct ldb_message_element *el = pyldb_MessageElement_AsMessageElement(self);
2257         if (idx < 0 || idx >= el->num_values) {
2258                 PyErr_SetString(PyExc_IndexError, "Out of range");
2259                 return NULL;
2260         }
2261         return PyString_FromStringAndSize((char *)el->values[idx].data, el->values[idx].length);
2262 }
2263
2264 static PySequenceMethods py_ldb_msg_element_seq = {
2265         .sq_length = (lenfunc)py_ldb_msg_element_len,
2266         .sq_item = (ssizeargfunc)py_ldb_msg_element_find,
2267 };
2268
2269 static int py_ldb_msg_element_cmp(PyLdbMessageElementObject *self, PyLdbMessageElementObject *other)
2270 {
2271         int ret = ldb_msg_element_compare(pyldb_MessageElement_AsMessageElement(self),
2272                                                                           pyldb_MessageElement_AsMessageElement(other));
2273         return SIGN(ret);
2274 }
2275
2276 static PyObject *py_ldb_msg_element_iter(PyLdbMessageElementObject *self)
2277 {
2278         PyObject *el = ldb_msg_element_to_set(NULL,
2279                                               pyldb_MessageElement_AsMessageElement(self));
2280         return PyObject_GetIter(el);
2281 }
2282
2283 static PyObject *PyLdbMessageElement_FromMessageElement(struct ldb_message_element *el, TALLOC_CTX *mem_ctx)
2284 {
2285         PyLdbMessageElementObject *ret;
2286         ret = PyObject_New(PyLdbMessageElementObject, &PyLdbMessageElement);
2287         if (ret == NULL) {
2288                 PyErr_NoMemory();
2289                 return NULL;
2290         }
2291         ret->mem_ctx = talloc_new(NULL);
2292         if (talloc_reference(ret->mem_ctx, mem_ctx) == NULL) {
2293                 PyErr_NoMemory();
2294                 return NULL;
2295         }
2296         ret->el = el;
2297         return (PyObject *)ret;
2298 }
2299
2300 static PyObject *py_ldb_msg_element_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2301 {
2302         PyObject *py_elements = NULL;
2303         struct ldb_message_element *el;
2304         unsigned int flags = 0;
2305         char *name = NULL;
2306         const char * const kwnames[] = { "elements", "flags", "name", NULL };
2307         PyLdbMessageElementObject *ret;
2308         TALLOC_CTX *mem_ctx;
2309
2310         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OIs",
2311                                          discard_const_p(char *, kwnames),
2312                                          &py_elements, &flags, &name))
2313                 return NULL;
2314
2315         mem_ctx = talloc_new(NULL);
2316         if (mem_ctx == NULL) {
2317                 PyErr_NoMemory();
2318                 return NULL;
2319         }
2320
2321         el = talloc_zero(mem_ctx, struct ldb_message_element);
2322         if (el == NULL) {
2323                 PyErr_NoMemory();
2324                 talloc_free(mem_ctx);
2325                 return NULL;
2326         }
2327
2328         if (py_elements != NULL) {
2329                 Py_ssize_t i;
2330                 if (PyString_Check(py_elements)) {
2331                         el->num_values = 1;
2332                         el->values = talloc_array(el, struct ldb_val, 1);
2333                         if (el->values == NULL) {
2334                                 talloc_free(mem_ctx);
2335                                 PyErr_NoMemory();
2336                                 return NULL;
2337                         }
2338                         el->values[0].length = PyString_Size(py_elements);
2339                         el->values[0].data = talloc_memdup(el->values,
2340                                 (uint8_t *)PyString_AsString(py_elements), el->values[0].length+1);
2341                 } else if (PySequence_Check(py_elements)) {
2342                         el->num_values = PySequence_Size(py_elements);
2343                         el->values = talloc_array(el, struct ldb_val, el->num_values);
2344                         if (el->values == NULL) {
2345                                 talloc_free(mem_ctx);
2346                                 PyErr_NoMemory();
2347                                 return NULL;
2348                         }
2349                         for (i = 0; i < el->num_values; i++) {
2350                                 PyObject *item = PySequence_GetItem(py_elements, i);
2351                                 if (item == NULL) {
2352                                         talloc_free(mem_ctx);
2353                                         return NULL;
2354                                 }
2355                                 if (!PyString_Check(item)) {
2356                                         PyErr_Format(PyExc_TypeError,
2357                                                      "Expected string as element %zd in list", i);
2358                                         talloc_free(mem_ctx);
2359                                         return NULL;
2360                                 }
2361                                 el->values[i].length = PyString_Size(item);
2362                                 el->values[i].data = talloc_memdup(el,
2363                                         (uint8_t *)PyString_AsString(item), el->values[i].length+1);
2364                         }
2365                 } else {
2366                         PyErr_SetString(PyExc_TypeError,
2367                                         "Expected string or list");
2368                         talloc_free(mem_ctx);
2369                         return NULL;
2370                 }
2371         }
2372
2373         el->flags = flags;
2374         el->name = talloc_strdup(el, name);
2375
2376         ret = PyObject_New(PyLdbMessageElementObject, type);
2377         if (ret == NULL) {
2378                 talloc_free(mem_ctx);
2379                 return NULL;
2380         }
2381
2382         ret->mem_ctx = mem_ctx;
2383         ret->el = el;
2384         return (PyObject *)ret;
2385 }
2386
2387 static PyObject *py_ldb_msg_element_repr(PyLdbMessageElementObject *self)
2388 {
2389         char *element_str = NULL;
2390         Py_ssize_t i;
2391         struct ldb_message_element *el = pyldb_MessageElement_AsMessageElement(self);
2392         PyObject *ret;
2393
2394         for (i = 0; i < el->num_values; i++) {
2395                 PyObject *o = py_ldb_msg_element_find(self, i);
2396                 if (element_str == NULL)
2397                         element_str = talloc_strdup(NULL, PyObject_REPR(o));
2398                 else
2399                         element_str = talloc_asprintf_append(element_str, ",%s", PyObject_REPR(o));
2400         }
2401
2402         if (element_str != NULL) {
2403                 ret = PyString_FromFormat("MessageElement([%s])", element_str);
2404                 talloc_free(element_str);
2405         } else {
2406                 ret = PyString_FromString("MessageElement([])");
2407         }
2408
2409         return ret;
2410 }
2411
2412 static PyObject *py_ldb_msg_element_str(PyLdbMessageElementObject *self)
2413 {
2414         struct ldb_message_element *el = pyldb_MessageElement_AsMessageElement(self);
2415
2416         if (el->num_values == 1)
2417                 return PyString_FromStringAndSize((char *)el->values[0].data, el->values[0].length);
2418         else
2419                 Py_RETURN_NONE;
2420 }
2421
2422 static void py_ldb_msg_element_dealloc(PyLdbMessageElementObject *self)
2423 {
2424         talloc_free(self->mem_ctx);
2425         PyObject_Del(self);
2426 }
2427
2428 static PyTypeObject PyLdbMessageElement = {
2429         .tp_name = "ldb.MessageElement",
2430         .tp_basicsize = sizeof(PyLdbMessageElementObject),
2431         .tp_dealloc = (destructor)py_ldb_msg_element_dealloc,
2432         .tp_repr = (reprfunc)py_ldb_msg_element_repr,
2433         .tp_str = (reprfunc)py_ldb_msg_element_str,
2434         .tp_methods = py_ldb_msg_element_methods,
2435         .tp_compare = (cmpfunc)py_ldb_msg_element_cmp,
2436         .tp_iter = (getiterfunc)py_ldb_msg_element_iter,
2437         .tp_as_sequence = &py_ldb_msg_element_seq,
2438         .tp_new = py_ldb_msg_element_new,
2439         .tp_flags = Py_TPFLAGS_DEFAULT,
2440         .tp_doc = "An element of a Message",
2441 };
2442
2443
2444 static PyObject *py_ldb_msg_from_dict(PyTypeObject *type, PyObject *args)
2445 {
2446         PyObject *py_ldb;
2447         PyObject *py_dict;
2448         PyObject *py_ret;
2449         struct ldb_message *msg;
2450         struct ldb_context *ldb_ctx;
2451         unsigned int mod_flags = LDB_FLAG_MOD_REPLACE;
2452
2453         if (!PyArg_ParseTuple(args, "O!O!|I",
2454                               &PyLdb, &py_ldb, &PyDict_Type, &py_dict,
2455                               &mod_flags)) {
2456                 return NULL;
2457         }
2458
2459         /* mask only flags we are going to use */
2460         mod_flags = LDB_FLAG_MOD_TYPE(mod_flags);
2461         if (!mod_flags) {
2462                 PyErr_SetString(PyExc_ValueError,
2463                                 "FLAG_MOD_ADD, FLAG_MOD_REPLACE or FLAG_MOD_DELETE"
2464                                 " expected as mod_flag value");
2465                 return NULL;
2466         }
2467
2468         ldb_ctx = pyldb_Ldb_AsLdbContext(py_ldb);
2469
2470         msg = PyDict_AsMessage(ldb_ctx, py_dict, ldb_ctx, mod_flags);
2471         if (!msg) {
2472                 return NULL;
2473         }
2474
2475         py_ret = PyLdbMessage_FromMessage(msg);
2476
2477         talloc_unlink(ldb_ctx, msg);
2478
2479         return py_ret;
2480 }
2481
2482 static PyObject *py_ldb_msg_remove_attr(PyLdbMessageObject *self, PyObject *args)
2483 {
2484         char *name;
2485         if (!PyArg_ParseTuple(args, "s", &name))
2486                 return NULL;
2487
2488         ldb_msg_remove_attr(self->msg, name);
2489
2490         Py_RETURN_NONE;
2491 }
2492
2493 static PyObject *py_ldb_msg_keys(PyLdbMessageObject *self)
2494 {
2495         struct ldb_message *msg = pyldb_Message_AsMessage(self);
2496         Py_ssize_t i, j = 0;
2497         PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
2498         if (msg->dn != NULL) {
2499                 PyList_SetItem(obj, j, PyString_FromString("dn"));
2500                 j++;
2501         }
2502         for (i = 0; i < msg->num_elements; i++) {
2503                 PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
2504                 j++;
2505         }
2506         return obj;
2507 }
2508
2509 static PyObject *py_ldb_msg_getitem_helper(PyLdbMessageObject *self, PyObject *py_name)
2510 {
2511         struct ldb_message_element *el;
2512         char *name;
2513         struct ldb_message *msg = pyldb_Message_AsMessage(self);
2514         if (!PyString_Check(py_name)) {
2515                 PyErr_SetNone(PyExc_TypeError);
2516                 return NULL;
2517         }
2518         name = PyString_AsString(py_name);
2519         if (!strcmp(name, "dn"))
2520                 return pyldb_Dn_FromDn(msg->dn);
2521         el = ldb_msg_find_element(msg, name);
2522         if (el == NULL) {
2523                 return NULL;
2524         }
2525         return (PyObject *)PyLdbMessageElement_FromMessageElement(el, msg->elements);
2526 }
2527
2528 static PyObject *py_ldb_msg_getitem(PyLdbMessageObject *self, PyObject *py_name)
2529 {
2530         PyObject *ret = py_ldb_msg_getitem_helper(self, py_name);
2531         if (ret == NULL) {
2532                 PyErr_SetString(PyExc_KeyError, "No such element");
2533                 return NULL;
2534         }
2535         return ret;
2536 }
2537
2538 static PyObject *py_ldb_msg_get(PyLdbMessageObject *self, PyObject *args, PyObject *kwargs)
2539 {
2540         PyObject *def = NULL;
2541         const char *kwnames[] = { "name", "default", "idx", NULL };
2542         const char *name = NULL;
2543         int idx = -1;
2544         struct ldb_message *msg = pyldb_Message_AsMessage(self);
2545         struct ldb_message_element *el;
2546
2547         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|Oi:msg",
2548                                          discard_const_p(char *, kwnames), &name, &def, &idx)) {
2549                 return NULL;
2550         }
2551
2552         if (strcasecmp(name, "dn") == 0) {
2553                 return pyldb_Dn_FromDn(msg->dn);
2554         }
2555
2556         el = ldb_msg_find_element(msg, name);
2557
2558         if (el == NULL || (idx != -1 && el->num_values <= idx)) {
2559                 if (def != NULL) {
2560                         return def;
2561                 }
2562                 Py_RETURN_NONE;
2563         }
2564
2565         if (idx == -1) {
2566                 return (PyObject *)PyLdbMessageElement_FromMessageElement(el, msg->elements);
2567         }
2568
2569         return PyObject_FromLdbValue(&el->values[idx]);
2570 }
2571
2572 static PyObject *py_ldb_msg_items(PyLdbMessageObject *self)
2573 {
2574         struct ldb_message *msg = pyldb_Message_AsMessage(self);
2575         Py_ssize_t i, j = 0;
2576         PyObject *l = PyList_New(msg->num_elements + (msg->dn == NULL?0:1));
2577         if (msg->dn != NULL) {
2578                 PyList_SetItem(l, 0, Py_BuildValue("(sO)", "dn", pyldb_Dn_FromDn(msg->dn)));
2579                 j++;
2580         }
2581         for (i = 0; i < msg->num_elements; i++, j++) {
2582                 PyObject *py_el = PyLdbMessageElement_FromMessageElement(&msg->elements[i], msg->elements);
2583                 PyObject *value = Py_BuildValue("(sO)", msg->elements[i].name, py_el);
2584                 PyList_SetItem(l, j, value);
2585         }
2586         return l;
2587 }
2588
2589 static PyObject *py_ldb_msg_elements(PyLdbMessageObject *self)
2590 {
2591         struct ldb_message *msg = pyldb_Message_AsMessage(self);
2592         Py_ssize_t i = 0;
2593         PyObject *l = PyList_New(msg->num_elements);
2594         for (i = 0; i < msg->num_elements; i++) {
2595                 PyList_SetItem(l, i, PyLdbMessageElement_FromMessageElement(&msg->elements[i], msg->elements));
2596         }
2597         return l;
2598 }
2599
2600 static PyObject *py_ldb_msg_add(PyLdbMessageObject *self, PyObject *args)
2601 {
2602         struct ldb_message *msg = pyldb_Message_AsMessage(self);
2603         PyLdbMessageElementObject *py_element;
2604         int ret;
2605         struct ldb_message_element *el;
2606
2607         if (!PyArg_ParseTuple(args, "O!", &PyLdbMessageElement, &py_element))
2608                 return NULL;
2609
2610         el = talloc_reference(msg, py_element->el);
2611         if (el == NULL) {
2612                 PyErr_NoMemory();
2613                 return NULL;
2614         }
2615
2616         ret = ldb_msg_add(msg, el, el->flags);
2617         PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, NULL);
2618
2619         Py_RETURN_NONE;
2620 }
2621
2622 static PyMethodDef py_ldb_msg_methods[] = {
2623         { "from_dict", (PyCFunction)py_ldb_msg_from_dict, METH_CLASS | METH_VARARGS,
2624                 "Message.from_dict(ldb, dict, mod_flag=FLAG_MOD_REPLACE) -> ldb.Message\n"
2625                 "Class method to create ldb.Message object from Dictionary.\n"
2626                 "mod_flag is one of FLAG_MOD_ADD, FLAG_MOD_REPLACE or FLAG_MOD_DELETE."},
2627         { "keys", (PyCFunction)py_ldb_msg_keys, METH_NOARGS,
2628                 "S.keys() -> list\n\n"
2629                 "Return sequence of all attribute names." },
2630         { "remove", (PyCFunction)py_ldb_msg_remove_attr, METH_VARARGS,
2631                 "S.remove(name)\n\n"
2632                 "Remove all entries for attributes with the specified name."},
2633         { "get", (PyCFunction)py_ldb_msg_get, METH_VARARGS | METH_KEYWORDS,
2634           "msg.get(name,default=None,idx=None) -> string\n"
2635           "idx is the index into the values array\n"
2636           "if idx is None, then a list is returned\n"
2637           "if idx is not None, then the element with that index is returned\n"
2638           "if you pass the special name 'dn' then the DN object is returned\n"},
2639         { "items", (PyCFunction)py_ldb_msg_items, METH_NOARGS, NULL },
2640         { "elements", (PyCFunction)py_ldb_msg_elements, METH_NOARGS, NULL },
2641         { "add", (PyCFunction)py_ldb_msg_add, METH_VARARGS,
2642                 "S.append(element)\n\n"
2643                 "Add an element to this message." },
2644         { NULL },
2645 };
2646
2647 static PyObject *py_ldb_msg_iter(PyLdbMessageObject *self)
2648 {
2649         PyObject *list, *iter;
2650
2651         list = py_ldb_msg_keys(self);
2652         iter = PyObject_GetIter(list);
2653         Py_DECREF(list);
2654         return iter;
2655 }
2656
2657 static int py_ldb_msg_setitem(PyLdbMessageObject *self, PyObject *name, PyObject *value)
2658 {
2659         char *attr_name;
2660
2661         if (!PyString_Check(name)) {
2662                 PyErr_SetNone(PyExc_TypeError);
2663                 return -1;
2664         }
2665
2666         attr_name = PyString_AsString(name);
2667         if (value == NULL) {
2668                 /* delitem */
2669                 ldb_msg_remove_attr(self->msg, attr_name);
2670         } else {
2671                 struct ldb_message_element *el = PyObject_AsMessageElement(self->msg,
2672                                                                            value, 0, attr_name);
2673                 if (el == NULL)
2674                         return -1;
2675                 ldb_msg_remove_attr(pyldb_Message_AsMessage(self), attr_name);
2676                 ldb_msg_add(pyldb_Message_AsMessage(self), el, el->flags);
2677         }
2678         return 0;
2679 }
2680
2681 static Py_ssize_t py_ldb_msg_length(PyLdbMessageObject *self)
2682 {
2683         return pyldb_Message_AsMessage(self)->num_elements;
2684 }
2685
2686 static PyMappingMethods py_ldb_msg_mapping = {
2687         .mp_length = (lenfunc)py_ldb_msg_length,
2688         .mp_subscript = (binaryfunc)py_ldb_msg_getitem,
2689         .mp_ass_subscript = (objobjargproc)py_ldb_msg_setitem,
2690 };
2691
2692 static PyObject *py_ldb_msg_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2693 {
2694         const char * const kwnames[] = { "dn", NULL };
2695         struct ldb_message *ret;
2696         TALLOC_CTX *mem_ctx;
2697         PyObject *pydn = NULL;
2698         PyLdbMessageObject *py_ret;
2699
2700         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O",
2701                                          discard_const_p(char *, kwnames),
2702                                          &pydn))
2703                 return NULL;
2704
2705         mem_ctx = talloc_new(NULL);
2706         if (mem_ctx == NULL) {
2707                 PyErr_NoMemory();
2708                 return NULL;
2709         }
2710
2711         ret = ldb_msg_new(mem_ctx);
2712         if (ret == NULL) {
2713                 talloc_free(mem_ctx);
2714                 PyErr_NoMemory();
2715                 return NULL;
2716         }
2717
2718         if (pydn != NULL) {
2719                 struct ldb_dn *dn;
2720                 if (!pyldb_Object_AsDn(NULL, pydn, NULL, &dn)) {
2721                         talloc_free(mem_ctx);
2722                         return NULL;
2723                 }
2724                 ret->dn = talloc_reference(ret, dn);
2725         }
2726
2727         py_ret = (PyLdbMessageObject *)type->tp_alloc(type, 0);
2728         if (py_ret == NULL) {
2729                 PyErr_NoMemory();
2730                 talloc_free(mem_ctx);
2731                 return NULL;
2732         }
2733
2734         py_ret->mem_ctx = mem_ctx;
2735         py_ret->msg = ret;
2736         return (PyObject *)py_ret;
2737 }
2738
2739 static PyObject *PyLdbMessage_FromMessage(struct ldb_message *msg)
2740 {
2741         PyLdbMessageObject *ret;
2742
2743         ret = (PyLdbMessageObject *)PyLdbMessage.tp_alloc(&PyLdbMessage, 0);
2744         if (ret == NULL) {
2745                 PyErr_NoMemory();
2746                 return NULL;
2747         }
2748         ret->mem_ctx = talloc_new(NULL);
2749         ret->msg = talloc_reference(ret->mem_ctx, msg);
2750         return (PyObject *)ret;
2751 }
2752
2753 static PyObject *py_ldb_msg_get_dn(PyLdbMessageObject *self, void *closure)
2754 {
2755         struct ldb_message *msg = pyldb_Message_AsMessage(self);
2756         return pyldb_Dn_FromDn(msg->dn);
2757 }
2758
2759 static int py_ldb_msg_set_dn(PyLdbMessageObject *self, PyObject *value, void *closure)
2760 {
2761         struct ldb_message *msg = pyldb_Message_AsMessage(self);
2762         if (!pyldb_Dn_Check(value)) {
2763                 PyErr_SetNone(PyExc_TypeError);
2764                 return -1;
2765         }
2766
2767         msg->dn = talloc_reference(msg, pyldb_Dn_AsDn(value));
2768         return 0;
2769 }
2770
2771 static PyGetSetDef py_ldb_msg_getset[] = {
2772         { discard_const_p(char, "dn"), (getter)py_ldb_msg_get_dn, (setter)py_ldb_msg_set_dn, NULL },
2773         { NULL }
2774 };
2775
2776 static PyObject *py_ldb_msg_repr(PyLdbMessageObject *self)
2777 {
2778         PyObject *dict = PyDict_New(), *ret;
2779         if (PyDict_Update(dict, (PyObject *)self) != 0)
2780                 return NULL;
2781         ret = PyString_FromFormat("Message(%s)", PyObject_REPR(dict));
2782         Py_DECREF(dict);
2783         return ret;
2784 }
2785
2786 static void py_ldb_msg_dealloc(PyLdbMessageObject *self)
2787 {
2788         talloc_free(self->mem_ctx);
2789         PyObject_Del(self);
2790 }
2791
2792 static int py_ldb_msg_compare(PyLdbMessageObject *py_msg1,
2793                               PyLdbMessageObject *py_msg2)
2794 {
2795         struct ldb_message *msg1 = pyldb_Message_AsMessage(py_msg1),
2796                            *msg2 = pyldb_Message_AsMessage(py_msg2);
2797         unsigned int i;
2798         int ret;
2799
2800         if ((msg1->dn != NULL) || (msg2->dn != NULL)) {
2801                 ret = ldb_dn_compare(msg1->dn, msg2->dn);
2802                 if (ret != 0) {
2803                         return SIGN(ret);
2804                 }
2805         }
2806
2807         ret = msg1->num_elements - msg2->num_elements;
2808         if (ret != 0) {
2809                 return SIGN(ret);
2810         }
2811
2812         for (i = 0; i < msg1->num_elements; i++) {
2813                 ret = ldb_msg_element_compare_name(&msg1->elements[i],
2814                                                    &msg2->elements[i]);
2815                 if (ret != 0) {
2816                         return SIGN(ret);
2817                 }
2818
2819                 ret = ldb_msg_element_compare(&msg1->elements[i],
2820                                               &msg2->elements[i]);
2821                 if (ret != 0) {
2822                         return SIGN(ret);
2823                 }
2824         }
2825
2826         return 0;
2827 }
2828
2829 static PyTypeObject PyLdbMessage = {
2830         .tp_name = "ldb.Message",
2831         .tp_methods = py_ldb_msg_methods,
2832         .tp_getset = py_ldb_msg_getset,
2833         .tp_as_mapping = &py_ldb_msg_mapping,
2834         .tp_basicsize = sizeof(PyLdbMessageObject),
2835         .tp_dealloc = (destructor)py_ldb_msg_dealloc,
2836         .tp_new = py_ldb_msg_new,
2837         .tp_repr = (reprfunc)py_ldb_msg_repr,
2838         .tp_flags = Py_TPFLAGS_DEFAULT,
2839         .tp_iter = (getiterfunc)py_ldb_msg_iter,
2840         .tp_compare = (cmpfunc)py_ldb_msg_compare,
2841         .tp_doc = "A LDB Message",
2842 };
2843
2844 static PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *tree)
2845 {
2846         PyLdbTreeObject *ret;
2847
2848         ret = (PyLdbTreeObject *)PyLdbTree.tp_alloc(&PyLdbTree, 0);
2849         if (ret == NULL) {
2850                 PyErr_NoMemory();
2851                 return NULL;
2852         }
2853
2854         ret->mem_ctx = talloc_new(NULL);
2855         ret->tree = talloc_reference(ret->mem_ctx, tree);
2856         return (PyObject *)ret;
2857 }
2858
2859 static void py_ldb_tree_dealloc(PyLdbTreeObject *self)
2860 {
2861         talloc_free(self->mem_ctx);
2862         PyObject_Del(self);
2863 }
2864
2865 static PyTypeObject PyLdbTree = {
2866         .tp_name = "ldb.Tree",
2867         .tp_basicsize = sizeof(PyLdbTreeObject),
2868         .tp_dealloc = (destructor)py_ldb_tree_dealloc,
2869         .tp_flags = Py_TPFLAGS_DEFAULT,
2870         .tp_doc = "A search tree",
2871 };
2872
2873 /* Ldb_module */
2874 static int py_module_search(struct ldb_module *mod, struct ldb_request *req)
2875 {
2876         PyObject *py_ldb = (PyObject *)mod->private_data;
2877         PyObject *py_result, *py_base, *py_attrs, *py_tree;
2878
2879         py_base = pyldb_Dn_FromDn(req->op.search.base);
2880
2881         if (py_base == NULL)
2882                 return LDB_ERR_OPERATIONS_ERROR;
2883
2884         py_tree = PyLdbTree_FromTree(req->op.search.tree);
2885
2886         if (py_tree == NULL)
2887                 return LDB_ERR_OPERATIONS_ERROR;
2888
2889         if (req->op.search.attrs == NULL) {
2890                 py_attrs = Py_None;
2891         } else {
2892                 int i, len;
2893                 for (len = 0; req->op.search.attrs[len]; len++);
2894                 py_attrs = PyList_New(len);
2895                 for (i = 0; i < len; i++)
2896                         PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
2897         }
2898
2899         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "search"),
2900                                         discard_const_p(char, "OiOO"),
2901                                         py_base, req->op.search.scope, py_tree, py_attrs);
2902
2903         Py_DECREF(py_attrs);
2904         Py_DECREF(py_tree);
2905         Py_DECREF(py_base);
2906
2907         if (py_result == NULL) {
2908                 return LDB_ERR_PYTHON_EXCEPTION;
2909         }
2910
2911         req->op.search.res = PyLdbResult_AsResult(NULL, py_result);
2912         if (req->op.search.res == NULL) {
2913                 return LDB_ERR_PYTHON_EXCEPTION;
2914         }
2915
2916         Py_DECREF(py_result);
2917
2918         return LDB_SUCCESS;
2919 }
2920
2921 static int py_module_add(struct ldb_module *mod, struct ldb_request *req)
2922 {
2923         PyObject *py_ldb = (PyObject *)mod->private_data;
2924         PyObject *py_result, *py_msg;
2925
2926         py_msg = PyLdbMessage_FromMessage(discard_const_p(struct ldb_message, req->op.add.message));
2927
2928         if (py_msg == NULL) {
2929                 return LDB_ERR_OPERATIONS_ERROR;
2930         }
2931
2932         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "add"),
2933                                         discard_const_p(char, "O"),
2934                                         py_msg);
2935
2936         Py_DECREF(py_msg);
2937
2938         if (py_result == NULL) {
2939                 return LDB_ERR_PYTHON_EXCEPTION;
2940         }
2941
2942         Py_DECREF(py_result);
2943
2944         return LDB_SUCCESS;
2945 }
2946
2947 static int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
2948 {
2949         PyObject *py_ldb = (PyObject *)mod->private_data;
2950         PyObject *py_result, *py_msg;
2951
2952         py_msg = PyLdbMessage_FromMessage(discard_const_p(struct ldb_message, req->op.mod.message));
2953
2954         if (py_msg == NULL) {
2955                 return LDB_ERR_OPERATIONS_ERROR;
2956         }
2957
2958         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "modify"),
2959                                         discard_const_p(char, "O"),
2960                                         py_msg);
2961
2962         Py_DECREF(py_msg);
2963
2964         if (py_result == NULL) {
2965                 return LDB_ERR_PYTHON_EXCEPTION;
2966         }
2967
2968         Py_DECREF(py_result);
2969
2970         return LDB_SUCCESS;
2971 }
2972
2973 static int py_module_del(struct ldb_module *mod, struct ldb_request *req)
2974 {
2975         PyObject *py_ldb = (PyObject *)mod->private_data;
2976         PyObject *py_result, *py_dn;
2977
2978         py_dn = pyldb_Dn_FromDn(req->op.del.dn);
2979
2980         if (py_dn == NULL)
2981                 return LDB_ERR_OPERATIONS_ERROR;
2982
2983         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "delete"),
2984                                         discard_const_p(char, "O"),
2985                                         py_dn);
2986
2987         if (py_result == NULL) {
2988                 return LDB_ERR_PYTHON_EXCEPTION;
2989         }
2990
2991         Py_DECREF(py_result);
2992
2993         return LDB_SUCCESS;
2994 }
2995
2996 static int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
2997 {
2998         PyObject *py_ldb = (PyObject *)mod->private_data;
2999         PyObject *py_result, *py_olddn, *py_newdn;
3000
3001         py_olddn = pyldb_Dn_FromDn(req->op.rename.olddn);
3002
3003         if (py_olddn == NULL)
3004                 return LDB_ERR_OPERATIONS_ERROR;
3005
3006         py_newdn = pyldb_Dn_FromDn(req->op.rename.newdn);
3007
3008         if (py_newdn == NULL)
3009                 return LDB_ERR_OPERATIONS_ERROR;
3010
3011         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "rename"),
3012                                         discard_const_p(char, "OO"),
3013                                         py_olddn, py_newdn);
3014
3015         Py_DECREF(py_olddn);
3016         Py_DECREF(py_newdn);
3017
3018         if (py_result == NULL) {
3019                 return LDB_ERR_PYTHON_EXCEPTION;
3020         }
3021
3022         Py_DECREF(py_result);
3023
3024         return LDB_SUCCESS;
3025 }
3026
3027 static int py_module_request(struct ldb_module *mod, struct ldb_request *req)
3028 {
3029         PyObject *py_ldb = (PyObject *)mod->private_data;
3030         PyObject *py_result;
3031
3032         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "request"),
3033                                         discard_const_p(char, ""));
3034
3035         return LDB_ERR_OPERATIONS_ERROR;
3036 }
3037
3038 static int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
3039 {
3040         PyObject *py_ldb = (PyObject *)mod->private_data;
3041         PyObject *py_result;
3042
3043         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "extended"),
3044                                         discard_const_p(char, ""));
3045
3046         return LDB_ERR_OPERATIONS_ERROR;
3047 }
3048
3049 static int py_module_start_transaction(struct ldb_module *mod)
3050 {
3051         PyObject *py_ldb = (PyObject *)mod->private_data;
3052         PyObject *py_result;
3053
3054         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "start_transaction"),
3055                                         discard_const_p(char, ""));
3056
3057         if (py_result == NULL) {
3058                 return LDB_ERR_PYTHON_EXCEPTION;
3059         }
3060
3061         Py_DECREF(py_result);
3062
3063         return LDB_SUCCESS;
3064 }
3065
3066 static int py_module_end_transaction(struct ldb_module *mod)
3067 {
3068         PyObject *py_ldb = (PyObject *)mod->private_data;
3069         PyObject *py_result;
3070
3071         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "end_transaction"),
3072                                         discard_const_p(char, ""));
3073
3074         if (py_result == NULL) {
3075                 return LDB_ERR_PYTHON_EXCEPTION;
3076         }
3077
3078         Py_DECREF(py_result);
3079
3080         return LDB_SUCCESS;
3081 }
3082
3083 static int py_module_del_transaction(struct ldb_module *mod)
3084 {
3085         PyObject *py_ldb = (PyObject *)mod->private_data;
3086         PyObject *py_result;
3087
3088         py_result = PyObject_CallMethod(py_ldb, discard_const_p(char, "del_transaction"),
3089                                         discard_const_p(char, ""));
3090
3091         if (py_result == NULL) {
3092                 return LDB_ERR_PYTHON_EXCEPTION;
3093         }
3094
3095         Py_DECREF(py_result);
3096
3097         return LDB_SUCCESS;
3098 }
3099
3100 static int py_module_destructor(struct ldb_module *mod)
3101 {
3102         Py_DECREF((PyObject *)mod->private_data);
3103         return 0;
3104 }
3105
3106 static int py_module_init(struct ldb_module *mod)
3107 {
3108         PyObject *py_class = (PyObject *)mod->ops->private_data;
3109         PyObject *py_result, *py_next, *py_ldb;
3110
3111         py_ldb = PyLdb_FromLdbContext(mod->ldb);
3112
3113         if (py_ldb == NULL)
3114                 return LDB_ERR_OPERATIONS_ERROR;
3115
3116         py_next = PyLdbModule_FromModule(mod->next);
3117
3118         if (py_next == NULL)
3119                 return LDB_ERR_OPERATIONS_ERROR;
3120
3121         py_result = PyObject_CallFunction(py_class, discard_const_p(char, "OO"),
3122                                           py_ldb, py_next);
3123
3124         if (py_result == NULL) {
3125                 return LDB_ERR_PYTHON_EXCEPTION;
3126         }
3127
3128         mod->private_data = py_result;
3129
3130         talloc_set_destructor(mod, py_module_destructor);
3131
3132         return ldb_next_init(mod);
3133 }
3134
3135 static PyObject *py_register_module(PyObject *module, PyObject *args)
3136 {
3137         int ret;
3138         struct ldb_module_ops *ops;
3139         PyObject *input;
3140
3141         if (!PyArg_ParseTuple(args, "O", &input))
3142                 return NULL;
3143
3144         ops = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
3145         if (ops == NULL) {
3146                 PyErr_NoMemory();
3147                 return NULL;
3148         }
3149
3150         ops->name = talloc_strdup(ops, PyString_AsString(PyObject_GetAttrString(input, discard_const_p(char, "name"))));
3151
3152         Py_INCREF(input);
3153         ops->private_data = input;
3154         ops->init_context = py_module_init;
3155         ops->search = py_module_search;
3156         ops->add = py_module_add;
3157         ops->modify = py_module_modify;
3158         ops->del = py_module_del;
3159         ops->rename = py_module_rename;
3160         ops->request = py_module_request;
3161         ops->extended = py_module_extended;
3162         ops->start_transaction = py_module_start_transaction;
3163         ops->end_transaction = py_module_end_transaction;
3164         ops->del_transaction = py_module_del_transaction;
3165
3166         ret = ldb_register_module(ops);
3167
3168         PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, NULL);
3169
3170         Py_RETURN_NONE;
3171 }
3172
3173 static PyObject *py_timestring(PyObject *module, PyObject *args)
3174 {
3175         /* most times "time_t" is a signed integer type with 32 or 64 bit:
3176          * http://stackoverflow.com/questions/471248/what-is-ultimately-a-time-t-typedef-to */
3177         long int t_val;
3178         char *tresult;
3179         PyObject *ret;
3180         if (!PyArg_ParseTuple(args, "l", &t_val))
3181                 return NULL;
3182         tresult = ldb_timestring(NULL, (time_t) t_val);
3183         ret = PyString_FromString(tresult);
3184         talloc_free(tresult);
3185         return ret;
3186 }
3187
3188 static PyObject *py_string_to_time(PyObject *module, PyObject *args)
3189 {
3190         char *str;
3191         if (!PyArg_ParseTuple(args, "s", &str))
3192                 return NULL;
3193
3194         return PyInt_FromLong(ldb_string_to_time(str));
3195 }
3196
3197 static PyObject *py_valid_attr_name(PyObject *self, PyObject *args)
3198 {
3199         char *name;
3200         if (!PyArg_ParseTuple(args, "s", &name))
3201                 return NULL;
3202         return PyBool_FromLong(ldb_valid_attr_name(name));
3203 }
3204
3205 /*
3206   encode a string using RFC2254 rules
3207  */
3208 static PyObject *py_binary_encode(PyObject *self, PyObject *args)
3209 {
3210         char *str, *encoded;
3211         int size = 0;
3212         struct ldb_val val;
3213         PyObject *ret;
3214
3215         if (!PyArg_ParseTuple(args, "s#", &str, &size))
3216                 return NULL;
3217         val.data = (uint8_t *)str;
3218         val.length = size;
3219
3220         encoded = ldb_binary_encode(NULL, val);
3221         if (encoded == NULL) {
3222                 PyErr_SetString(PyExc_TypeError, "unable to encode binary string");
3223                 return NULL;
3224         }
3225         ret = PyString_FromString(encoded);
3226         talloc_free(encoded);
3227         return ret;
3228 }
3229
3230 /*
3231   decode a string using RFC2254 rules
3232  */
3233 static PyObject *py_binary_decode(PyObject *self, PyObject *args)
3234 {
3235         char *str;
3236         struct ldb_val val;
3237         PyObject *ret;
3238
3239         if (!PyArg_ParseTuple(args, "s", &str))
3240                 return NULL;
3241
3242         val = ldb_binary_decode(NULL, str);
3243         if (val.data == NULL) {
3244                 PyErr_SetString(PyExc_TypeError, "unable to decode binary string");
3245                 return NULL;
3246         }
3247         ret = Py_BuildValue("s#", val.data, val.length);
3248         talloc_free(val.data);
3249         return ret;
3250 }
3251
3252 static PyMethodDef py_ldb_global_methods[] = {
3253         { "register_module", py_register_module, METH_VARARGS,
3254                 "S.register_module(module) -> None\n\n"
3255                 "Register a LDB module."},
3256         { "timestring", py_timestring, METH_VARARGS,
3257                 "S.timestring(int) -> string\n\n"
3258                 "Generate a LDAP time string from a UNIX timestamp" },
3259         { "string_to_time", py_string_to_time, METH_VARARGS,
3260                 "S.string_to_time(string) -> int\n\n"
3261                 "Parse a LDAP time string into a UNIX timestamp." },
3262         { "valid_attr_name", py_valid_attr_name, METH_VARARGS,
3263                 "S.valid_attr_name(name) -> bool\n\nn"
3264                 "Check whether the supplied name is a valid attribute name." },
3265         { "open", (PyCFunction)py_ldb_new, METH_VARARGS|METH_KEYWORDS,
3266                 "S.open() -> Ldb\n\n"
3267                 "Open a new LDB context." },
3268         { "binary_encode", py_binary_encode, METH_VARARGS,
3269                 "S.binary_encode(string) -> string\n\n"
3270                 "Perform a RFC2254 binary encoding on a string" },
3271         { "binary_decode", py_binary_decode, METH_VARARGS,
3272                 "S.binary_decode(string) -> string\n\n"
3273                 "Perform a RFC2254 binary decode on a string" },
3274         { NULL }
3275 };
3276
3277 void initldb(void)
3278 {
3279         PyObject *m;
3280
3281         if (PyType_Ready(&PyLdbDn) < 0)
3282                 return;
3283
3284         if (PyType_Ready(&PyLdbMessage) < 0)
3285                 return;
3286
3287         if (PyType_Ready(&PyLdbMessageElement) < 0)
3288                 return;
3289
3290         if (PyType_Ready(&PyLdb) < 0)
3291                 return;
3292
3293         if (PyType_Ready(&PyLdbModule) < 0)
3294                 return;
3295
3296         if (PyType_Ready(&PyLdbTree) < 0)
3297                 return;
3298
3299         if (PyType_Ready(&PyLdbResult) < 0)
3300                 return;
3301
3302         if (PyType_Ready(&PyLdbControl) < 0)
3303                 return;
3304
3305         m = Py_InitModule3("ldb", py_ldb_global_methods,
3306                 "An interface to LDB, a LDAP-like API that can either to talk an embedded database (TDB-based) or a standards-compliant LDAP server.");
3307         if (m == NULL)
3308                 return;
3309
3310         PyModule_AddObject(m, "SEQ_HIGHEST_SEQ", PyInt_FromLong(LDB_SEQ_HIGHEST_SEQ));
3311         PyModule_AddObject(m, "SEQ_HIGHEST_TIMESTAMP", PyInt_FromLong(LDB_SEQ_HIGHEST_TIMESTAMP));
3312         PyModule_AddObject(m, "SEQ_NEXT", PyInt_FromLong(LDB_SEQ_NEXT));
3313         PyModule_AddObject(m, "SCOPE_DEFAULT", PyInt_FromLong(LDB_SCOPE_DEFAULT));
3314         PyModule_AddObject(m, "SCOPE_BASE", PyInt_FromLong(LDB_SCOPE_BASE));
3315         PyModule_AddObject(m, "SCOPE_ONELEVEL", PyInt_FromLong(LDB_SCOPE_ONELEVEL));
3316         PyModule_AddObject(m, "SCOPE_SUBTREE", PyInt_FromLong(LDB_SCOPE_SUBTREE));
3317
3318         PyModule_AddObject(m, "CHANGETYPE_NONE", PyInt_FromLong(LDB_CHANGETYPE_NONE));
3319         PyModule_AddObject(m, "CHANGETYPE_ADD", PyInt_FromLong(LDB_CHANGETYPE_ADD));
3320         PyModule_AddObject(m, "CHANGETYPE_DELETE", PyInt_FromLong(LDB_CHANGETYPE_DELETE));
3321         PyModule_AddObject(m, "CHANGETYPE_MODIFY", PyInt_FromLong(LDB_CHANGETYPE_MODIFY));
3322
3323         PyModule_AddObject(m, "FLAG_MOD_ADD", PyInt_FromLong(LDB_FLAG_MOD_ADD));
3324         PyModule_AddObject(m, "FLAG_MOD_REPLACE", PyInt_FromLong(LDB_FLAG_MOD_REPLACE));
3325         PyModule_AddObject(m, "FLAG_MOD_DELETE", PyInt_FromLong(LDB_FLAG_MOD_DELETE));
3326
3327         PyModule_AddObject(m, "SUCCESS", PyInt_FromLong(LDB_SUCCESS));
3328         PyModule_AddObject(m, "ERR_OPERATIONS_ERROR", PyInt_FromLong(LDB_ERR_OPERATIONS_ERROR));
3329         PyModule_AddObject(m, "ERR_PROTOCOL_ERROR", PyInt_FromLong(LDB_ERR_PROTOCOL_ERROR));
3330         PyModule_AddObject(m, "ERR_TIME_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_TIME_LIMIT_EXCEEDED));
3331         PyModule_AddObject(m, "ERR_SIZE_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_SIZE_LIMIT_EXCEEDED));
3332         PyModule_AddObject(m, "ERR_COMPARE_FALSE", PyInt_FromLong(LDB_ERR_COMPARE_FALSE));
3333         PyModule_AddObject(m, "ERR_COMPARE_TRUE", PyInt_FromLong(LDB_ERR_COMPARE_TRUE));
3334         PyModule_AddObject(m, "ERR_AUTH_METHOD_NOT_SUPPORTED", PyInt_FromLong(LDB_ERR_AUTH_METHOD_NOT_SUPPORTED));
3335         PyModule_AddObject(m, "ERR_STRONG_AUTH_REQUIRED", PyInt_FromLong(LDB_ERR_STRONG_AUTH_REQUIRED));
3336         PyModule_AddObject(m, "ERR_REFERRAL", PyInt_FromLong(LDB_ERR_REFERRAL));
3337         PyModule_AddObject(m, "ERR_ADMIN_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_ADMIN_LIMIT_EXCEEDED));
3338         PyModule_AddObject(m, "ERR_UNSUPPORTED_CRITICAL_EXTENSION", PyInt_FromLong(LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION));
3339         PyModule_AddObject(m, "ERR_CONFIDENTIALITY_REQUIRED", PyInt_FromLong(LDB_ERR_CONFIDENTIALITY_REQUIRED));
3340         PyModule_AddObject(m, "ERR_SASL_BIND_IN_PROGRESS", PyInt_FromLong(LDB_ERR_SASL_BIND_IN_PROGRESS));
3341         PyModule_AddObject(m, "ERR_NO_SUCH_ATTRIBUTE", PyInt_FromLong(LDB_ERR_NO_SUCH_ATTRIBUTE));
3342         PyModule_AddObject(m, "ERR_UNDEFINED_ATTRIBUTE_TYPE", PyInt_FromLong(LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE));
3343         PyModule_AddObject(m, "ERR_INAPPROPRIATE_MATCHING", PyInt_FromLong(LDB_ERR_INAPPROPRIATE_MATCHING));
3344         PyModule_AddObject(m, "ERR_CONSTRAINT_VIOLATION", PyInt_FromLong(LDB_ERR_CONSTRAINT_VIOLATION));
3345         PyModule_AddObject(m, "ERR_ATTRIBUTE_OR_VALUE_EXISTS", PyInt_FromLong(LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS));
3346         PyModule_AddObject(m, "ERR_INVALID_ATTRIBUTE_SYNTAX", PyInt_FromLong(LDB_ERR_INVALID_ATTRIBUTE_SYNTAX));
3347         PyModule_AddObject(m, "ERR_NO_SUCH_OBJECT", PyInt_FromLong(LDB_ERR_NO_SUCH_OBJECT));
3348         PyModule_AddObject(m, "ERR_ALIAS_PROBLEM", PyInt_FromLong(LDB_ERR_ALIAS_PROBLEM));
3349         PyModule_AddObject(m, "ERR_INVALID_DN_SYNTAX", PyInt_FromLong(LDB_ERR_INVALID_DN_SYNTAX));
3350         PyModule_AddObject(m, "ERR_ALIAS_DEREFERINCING_PROBLEM", PyInt_FromLong(LDB_ERR_ALIAS_DEREFERENCING_PROBLEM));
3351         PyModule_AddObject(m, "ERR_INAPPROPRIATE_AUTHENTICATION", PyInt_FromLong(LDB_ERR_INAPPROPRIATE_AUTHENTICATION));
3352         PyModule_AddObject(m, "ERR_INVALID_CREDENTIALS", PyInt_FromLong(LDB_ERR_INVALID_CREDENTIALS));
3353         PyModule_AddObject(m, "ERR_INSUFFICIENT_ACCESS_RIGHTS", PyInt_FromLong(LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS));
3354         PyModule_AddObject(m, "ERR_BUSY", PyInt_FromLong(LDB_ERR_BUSY));
3355         PyModule_AddObject(m, "ERR_UNAVAILABLE", PyInt_FromLong(LDB_ERR_UNAVAILABLE));
3356         PyModule_AddObject(m, "ERR_UNWILLING_TO_PERFORM", PyInt_FromLong(LDB_ERR_UNWILLING_TO_PERFORM));
3357         PyModule_AddObject(m, "ERR_LOOP_DETECT", PyInt_FromLong(LDB_ERR_LOOP_DETECT));
3358         PyModule_AddObject(m, "ERR_NAMING_VIOLATION", PyInt_FromLong(LDB_ERR_NAMING_VIOLATION));
3359         PyModule_AddObject(m, "ERR_OBJECT_CLASS_VIOLATION", PyInt_FromLong(LDB_ERR_OBJECT_CLASS_VIOLATION));
3360         PyModule_AddObject(m, "ERR_NOT_ALLOWED_ON_NON_LEAF", PyInt_FromLong(LDB_ERR_NOT_ALLOWED_ON_NON_LEAF));
3361         PyModule_AddObject(m, "ERR_NOT_ALLOWED_ON_RDN", PyInt_FromLong(LDB_ERR_NOT_ALLOWED_ON_RDN));
3362         PyModule_AddObject(m, "ERR_ENTRY_ALREADY_EXISTS", PyInt_FromLong(LDB_ERR_ENTRY_ALREADY_EXISTS));
3363         PyModule_AddObject(m, "ERR_OBJECT_CLASS_MODS_PROHIBITED", PyInt_FromLong(LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED));
3364         PyModule_AddObject(m, "ERR_AFFECTS_MULTIPLE_DSAS", PyInt_FromLong(LDB_ERR_AFFECTS_MULTIPLE_DSAS));
3365         PyModule_AddObject(m, "ERR_OTHER", PyInt_FromLong(LDB_ERR_OTHER));
3366
3367         PyModule_AddObject(m, "FLG_RDONLY", PyInt_FromLong(LDB_FLG_RDONLY));
3368         PyModule_AddObject(m, "FLG_NOSYNC", PyInt_FromLong(LDB_FLG_NOSYNC));
3369         PyModule_AddObject(m, "FLG_RECONNECT", PyInt_FromLong(LDB_FLG_RECONNECT));
3370         PyModule_AddObject(m, "FLG_NOMMAP", PyInt_FromLong(LDB_FLG_NOMMAP));
3371
3372         PyModule_AddObject(m, "__docformat__", PyString_FromString("restructuredText"));
3373
3374         PyExc_LdbError = PyErr_NewException(discard_const_p(char, "_ldb.LdbError"), NULL, NULL);
3375         PyModule_AddObject(m, "LdbError", PyExc_LdbError);
3376
3377         Py_INCREF(&PyLdb);
3378         Py_INCREF(&PyLdbDn);
3379         Py_INCREF(&PyLdbModule);
3380         Py_INCREF(&PyLdbMessage);
3381         Py_INCREF(&PyLdbMessageElement);
3382         Py_INCREF(&PyLdbTree);
3383         Py_INCREF(&PyLdbResult);
3384         Py_INCREF(&PyLdbControl);
3385
3386         PyModule_AddObject(m, "Ldb", (PyObject *)&PyLdb);
3387         PyModule_AddObject(m, "Dn", (PyObject *)&PyLdbDn);
3388         PyModule_AddObject(m, "Message", (PyObject *)&PyLdbMessage);
3389         PyModule_AddObject(m, "MessageElement", (PyObject *)&PyLdbMessageElement);
3390         PyModule_AddObject(m, "Module", (PyObject *)&PyLdbModule);
3391         PyModule_AddObject(m, "Tree", (PyObject *)&PyLdbTree);
3392         PyModule_AddObject(m, "Control", (PyObject *)&PyLdbControl);
3393
3394         PyModule_AddObject(m, "__version__", PyString_FromString(PACKAGE_VERSION));
3395
3396 #define ADD_LDB_STRING(val)  PyModule_AddObject(m, #val, PyString_FromString(LDB_## val))
3397
3398         ADD_LDB_STRING(SYNTAX_DN);
3399         ADD_LDB_STRING(SYNTAX_DIRECTORY_STRING);
3400         ADD_LDB_STRING(SYNTAX_INTEGER);
3401         ADD_LDB_STRING(SYNTAX_BOOLEAN);
3402         ADD_LDB_STRING(SYNTAX_OCTET_STRING);
3403         ADD_LDB_STRING(SYNTAX_UTC_TIME);
3404         ADD_LDB_STRING(OID_COMPARATOR_AND);
3405         ADD_LDB_STRING(OID_COMPARATOR_OR);
3406 }