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