source4/lib/ldb/ldb.i

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Swig interface to ldb.
   5
   6    Copyright (C) 2005,2006 Tim Potter <tpot@samba.org>
   7    Copyright (C) 2006 Simo Sorce <idra@samba.org>
   8    Copyright (C) 2007-2008 Jelmer Vernooij <jelmer@samba.org>
   9
  10      ** NOTE! The following LGPL license applies to the ldb
  11      ** library. This does NOT imply that all of Samba is released
  12      ** under the LGPL
  13
  14    This library is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU Lesser General Public
  16    License as published by the Free Software Foundation; either
  17    version 3 of the License, or (at your option) any later version.
  18
  19    This library is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22    Lesser General Public License for more details.
  23
  24    You should have received a copy of the GNU Lesser General Public
  25    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  26 */
  27
  28 %module ldb
  29
  30 %{
  31
  32 #include <stdint.h>
  33 #include <stdbool.h>
  34 #include "talloc.h"
  35 #include "ldb.h"
  36 #include "ldb_errors.h"
  37 #include "ldb_private.h"
  38
  39 typedef struct ldb_message ldb_msg;
  40 typedef struct ldb_context ldb;
  41 typedef struct ldb_dn ldb_dn;
  42 typedef struct ldb_ldif ldb_ldif;
  43 typedef struct ldb_message_element ldb_msg_element;
  44 typedef int ldb_error;
  45 typedef int ldb_int_error;
  46
  47 %}
  48
  49 %import "carrays.i"
  50 %import "typemaps.i"
  51 %include "exception.i"
  52 %import "stdint.i"
  53
  54 /* Don't expose talloc contexts in Python code. Python does reference
  55    counting for us, so just create a new top-level talloc context.
  56  */
  57 %typemap(in, numinputs=0, noblock=1) TALLOC_CTX * {
  58     $1 = NULL;
  59 }
  60
  61
  62
  63 %constant int SCOPE_DEFAULT = LDB_SCOPE_DEFAULT;
  64 %constant int SCOPE_BASE = LDB_SCOPE_BASE;
  65 %constant int SCOPE_ONELEVEL = LDB_SCOPE_ONELEVEL;
  66 %constant int SCOPE_SUBTREE = LDB_SCOPE_SUBTREE;
  67
  68 %constant int CHANGETYPE_NONE = LDB_CHANGETYPE_NONE;
  69 %constant int CHANGETYPE_ADD = LDB_CHANGETYPE_ADD;
  70 %constant int CHANGETYPE_DELETE = LDB_CHANGETYPE_DELETE;
  71 %constant int CHANGETYPE_MODIFY = LDB_CHANGETYPE_MODIFY;
  72
  73 /*
  74  * Wrap struct ldb_context
  75  */
  76
  77 /* The ldb functions will crash if a NULL ldb context is passed so
  78    catch this before it happens. */
  79
  80 %typemap(check,noblock=1) struct ldb_context* {
  81         if ($1 == NULL)
  82                 SWIG_exception(SWIG_ValueError,
  83                         "ldb context must be non-NULL");
  84 }
  85
  86 %typemap(check,noblock=1) ldb_msg * {
  87         if ($1 == NULL)
  88                 SWIG_exception(SWIG_ValueError,
  89                         "Message can not be None");
  90 }
  91
  92 /*
  93  * Wrap struct ldb_val
  94  */
  95
  96 %typemap(in,noblock=1) struct ldb_val *INPUT (struct ldb_val temp) {
  97         $1 = &temp;
  98         if (!PyString_Check($input)) {
  99                 PyErr_SetString(PyExc_TypeError, "string arg expected");
 100                 return NULL;
 101         }
 102         $1->length = PyString_Size($input);
 103         $1->data = PyString_AsString($input);
 104 }
 105
 106 %inline %{
 107 PyObject *ldb_val_to_py_object(struct ldb_context *ldb_ctx,
 108                                struct ldb_message_element *el,
 109                                struct ldb_val *val)
 110 {
 111         const struct ldb_schema_attribute *a;
 112         struct ldb_val new_val;
 113         TALLOC_CTX *mem_ctx = talloc_new(NULL);
 114         PyObject *ret;
 115
 116         new_val = *val;
 117
 118         if (ldb_ctx != NULL) {
 119                 a = ldb_schema_attribute_by_name(ldb_ctx, el->name);
 120
 121                 if (a != NULL) {
 122                         if (a->syntax->ldif_write_fn(ldb_ctx, mem_ctx, val, &new_val) != 0) {
 123                                 talloc_free(mem_ctx);
 124                                 return NULL;
 125                         }
 126                 }
 127         }
 128
 129         ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
 130
 131         talloc_free(mem_ctx);
 132
 133         return ret;
 134 }
 135
 136 %}
 137
 138 %typemap(out,noblock=1) struct ldb_val * {
 139         $result = PyString_FromStringAndSize((const char *)$1->data, $1->length)
 140 }
 141
 142 %typemap(out,noblock=1) struct ldb_val {
 143         $result = PyString_FromStringAndSize((const char *)$1.data, $1.length)
 144 }
 145
 146 /*
 147  * Wrap struct ldb_result
 148  */
 149
 150 %typemap(in,noblock=1,numinputs=0) struct ldb_result **OUT (struct ldb_result *temp_ldb_result) {
 151         $1 = &temp_ldb_result;
 152 }
 153
 154 #ifdef SWIGPYTHON
 155 %typemap(argout,noblock=1) struct ldb_result ** (int i) {
 156         $result = PyList_New((*$1)->count);
 157     for (i = 0; i < (*$1)->count; i++) {
 158         PyList_SetItem($result, i,
 159             SWIG_NewPointerObj((*$1)->msgs[i], SWIGTYPE_p_ldb_message, 0)
 160         );
 161     }
 162 }
 163
 164 %typemap(in,noblock=1,numinputs=1) const char * const *NULL_STR_LIST {
 165     if ($input == Py_None) {
 166         $1 = NULL;
 167     } else if (PySequence_Check($input)) {
 168         int i;
 169         $1 = talloc_array(NULL, char *, PySequence_Size($input)+1);
 170         for(i = 0; i < PySequence_Size($input); i++)
 171             $1[i] = PyString_AsString(PySequence_GetItem($input, i));
 172         $1[i] = NULL;
 173     } else {
 174         SWIG_exception(SWIG_TypeError, "expected sequence");
 175     }
 176 }
 177
 178 %typemap(freearg,noblock=1) const char * const *NULL_STR_LIST {
 179     talloc_free($1);
 180 }
 181
 182 %apply const char * const *NULL_STR_LIST { const char * const *attrs }
 183 %apply const char * const *NULL_STR_LIST { const char * const *control_strings }
 184
 185 #endif
 186
 187 %types(struct ldb_result *);
 188
 189 /*
 190  * Wrap struct ldb_dn
 191  */
 192
 193 %rename(__str__) ldb_dn::get_linearized;
 194 %rename(__cmp__) ldb_dn::compare;
 195 %rename(__len__) ldb_dn::get_comp_num;
 196 %rename(Dn) ldb_dn;
 197 typedef struct ldb_dn {
 198     %extend {
 199         ldb_dn(ldb *ldb_ctx, const char *str)
 200         {
 201             ldb_dn *ret = ldb_dn_new(ldb_ctx, ldb_ctx, str);
 202             /* ldb_dn_new() doesn't accept NULL as memory context, so
 203                we do it this way... */
 204             talloc_steal(NULL, ret);
 205
 206             if (ret == NULL)
 207                 SWIG_exception(SWIG_ValueError,
 208                                 "unable to parse dn string");
 209 fail:
 210             return ret;
 211         }
 212         ~ldb_dn() { talloc_free($self); }
 213         bool validate();
 214         const char *get_casefold();
 215         const char *get_linearized();
 216         ldb_dn *parent() { return ldb_dn_get_parent(NULL, $self); }
 217         int compare(ldb_dn *other);
 218         bool is_valid();
 219         bool is_special();
 220         bool is_null();
 221         bool check_special(const char *name);
 222         int get_comp_num();
 223         bool add_child(ldb_dn *child);
 224         bool add_base(ldb_dn *base);
 225         const char *canonical_str() {
 226             return ldb_dn_canonical_string($self, $self);
 227         }
 228         const char *canonical_ex_str() {
 229             return ldb_dn_canonical_ex_string($self, $self);
 230         }
 231 #ifdef SWIGPYTHON
 232         char *__repr__(void)
 233         {
 234             char *dn = ldb_dn_get_linearized($self), *ret;
 235             asprintf(&ret, "Dn('%s')", dn);
 236             talloc_free(dn);
 237             return ret;
 238         }
 239
 240         ldb_dn *__add__(ldb_dn *other)
 241         {
 242             ldb_dn *ret = ldb_dn_copy(NULL, $self);
 243             ldb_dn_add_child(ret, other);
 244             return ret;
 245         }
 246
 247         /* FIXME: implement __getslice__ */
 248 #endif
 249     %pythoncode {
 250         def __eq__(self, other):
 251             if isinstance(other, self.__class__):
 252                 return self.__cmp__(other) == 0
 253             if isinstance(other, str):
 254                 return str(self) == other
 255             return False
 256     }
 257     }
 258 } ldb_dn;
 259
 260 #ifdef SWIGPYTHON
 261 %{
 262 struct ldb_context *ldb_context_from_py_object(PyObject *py_obj)
 263 {
 264         struct ldb_context *ldb_ctx;
 265     if (SWIG_ConvertPtr(py_obj, (void *)&ldb_ctx, SWIGTYPE_p_ldb_context, 0 |  0 ) < 0)
 266         return NULL;
 267     return ldb_ctx;
 268 }
 269
 270 int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object,
 271                          struct ldb_context *ldb_ctx, ldb_dn **dn)
 272 {
 273     int ret;
 274     struct ldb_dn *odn;
 275     if (ldb_ctx != NULL && PyString_Check(object)) {
 276         odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
 277         if (!odn) {
 278                 return SWIG_ERROR;
 279         }
 280         *dn = odn;
 281         return 0;
 282     }
 283     ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn,
 284                            SWIG_POINTER_EXCEPTION);
 285     *dn = ldb_dn_copy(mem_ctx, odn);
 286     if (odn && !*dn) {
 287         return SWIG_ERROR;
 288     }
 289     return ret;
 290 }
 291
 292 ldb_msg_element *ldb_msg_element_from_pyobject(TALLOC_CTX *mem_ctx,
 293                                                PyObject *set_obj, int flags,
 294                                                const char *attr_name)
 295 {
 296     struct ldb_message_element *me = talloc(mem_ctx, struct ldb_message_element);
 297     me->name = attr_name;
 298     me->flags = flags;
 299     if (PyString_Check(set_obj)) {
 300         me->num_values = 1;
 301         me->values = talloc_array(me, struct ldb_val, me->num_values);
 302         me->values[0].length = PyString_Size(set_obj);
 303         me->values[0].data = (uint8_t *)talloc_strdup(me->values,
 304                                            PyString_AsString(set_obj));
 305     } else if (PySequence_Check(set_obj)) {
 306         int i;
 307         me->num_values = PySequence_Size(set_obj);
 308         me->values = talloc_array(me, struct ldb_val, me->num_values);
 309         for (i = 0; i < me->num_values; i++) {
 310             PyObject *obj = PySequence_GetItem(set_obj, i);
 311             me->values[i].length = PyString_Size(obj);
 312             me->values[i].data = (uint8_t *)PyString_AsString(obj);
 313         }
 314     } else {
 315         talloc_free(me);
 316         me = NULL;
 317     }
 318
 319     return me;
 320 }
 321
 322 PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
 323                                  ldb_msg_element *me)
 324 {
 325     int i;
 326     PyObject *result;
 327
 328     /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
 329     result = PyList_New(me->num_values);
 330
 331     for (i = 0; i < me->num_values; i++) {
 332         PyList_SetItem(result, i,
 333             ldb_val_to_py_object(ldb_ctx, me, &me->values[i]));
 334     }
 335
 336     return result;
 337 }
 338
 339 %}
 340 #endif
 341
 342 /* ldb_message_element */
 343 %rename(__cmp__) ldb_message_element::compare;
 344 %rename(MessageElement) ldb_msg_element;
 345 typedef struct ldb_message_element {
 346     %extend {
 347 #ifdef SWIGPYTHON
 348         PyObject *__iter__(void)
 349         {
 350             return PyObject_GetIter(ldb_msg_element_to_set(NULL, $self));
 351         }
 352
 353         PyObject *__set__(void)
 354         {
 355             return ldb_msg_element_to_set(NULL, $self);
 356         }
 357
 358         ldb_msg_element(PyObject *set_obj, int flags=0, const char *name = NULL)
 359         {
 360             return ldb_msg_element_from_pyobject(NULL, set_obj, flags, name);
 361         }
 362
 363         int __len__()
 364         {
 365             return $self->num_values;
 366         }
 367 #endif
 368
 369         PyObject *get(int i)
 370         {
 371             if (i < 0 || i >= $self->num_values)
 372                 return Py_None;
 373
 374             return ldb_val_to_py_object(NULL, $self, &$self->values[i]);
 375         }
 376
 377         ~ldb_msg_element() { talloc_free($self); }
 378         int compare(ldb_msg_element *);
 379     }
 380     %pythoncode {
 381         def __getitem__(self, i):
 382             ret = self.get(i)
 383             if ret is None:
 384                 raise KeyError("no such value")
 385             return ret
 386
 387         def __repr__(self):
 388             return "MessageElement([%s])" % (",".join(repr(x) for x in self.__set__()))
 389
 390         def __eq__(self, other):
 391             if (len(self) == 1 and self.get(0) == other):
 392                 return True
 393             if isinstance(other, self.__class__):
 394                 return self.__cmp__(other) == 0
 395             o = iter(other)
 396             for i in range(len(self)):
 397                 if self.get(i) != o.next():
 398                     return False
 399             return True
 400     }
 401 } ldb_msg_element;
 402
 403 /* ldb_message */
 404
 405 %rename(Message) ldb_message;
 406 #ifdef SWIGPYTHON
 407 %rename(__delitem__) ldb_message::remove_attr;
 408 %typemap(out) ldb_msg_element * {
 409         if ($1 == NULL)
 410                 PyErr_SetString(PyExc_KeyError, "no such element");
 411     else
 412         $result = SWIG_NewPointerObj($1, SWIGTYPE_p_ldb_message_element, 0);
 413 }
 414 //%typemap(out) ldb_msg_element *;
 415
 416
 417 %inline {
 418     PyObject *ldb_msg_list_elements(ldb_msg *msg)
 419     {
 420         int i, j = 0;
 421         PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
 422         if (msg->dn != NULL) {
 423             PyList_SetItem(obj, j, PyString_FromString("dn"));
 424             j++;
 425         }
 426         for (i = 0; i < msg->num_elements; i++) {
 427             PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
 428             j++;
 429         }
 430         return obj;
 431     }
 432 }
 433
 434 #endif
 435
 436 typedef struct ldb_message {
 437         ldb_dn *dn;
 438
 439     %extend {
 440         ldb_msg(ldb_dn *dn = NULL) {
 441             ldb_msg *ret = ldb_msg_new(NULL);
 442             ret->dn = talloc_reference(ret, dn);
 443             return ret;
 444         }
 445         ~ldb_msg() { talloc_free($self); }
 446         ldb_msg_element *find_element(const char *name);
 447
 448 #ifdef SWIGPYTHON
 449         void __setitem__(const char *attr_name, ldb_msg_element *val)
 450         {
 451             struct ldb_message_element *el;
 452
 453             ldb_msg_remove_attr($self, attr_name);
 454
 455             el = talloc($self, struct ldb_message_element);
 456             el->name = talloc_strdup(el, attr_name);
 457             el->num_values = val->num_values;
 458             el->values = talloc_reference(el, val->values);
 459
 460             ldb_msg_add($self, el, val->flags);
 461         }
 462
 463         void __setitem__(const char *attr_name, PyObject *val)
 464         {
 465             struct ldb_message_element *el = ldb_msg_element_from_pyobject(NULL,
 466                                                 val, 0, attr_name);
 467             talloc_steal($self, el);
 468             ldb_msg_remove_attr($self, attr_name);
 469             ldb_msg_add($self, el, el->flags);
 470         }
 471
 472         unsigned int __len__() { return $self->num_elements; }
 473
 474         PyObject *keys(void)
 475         {
 476             return ldb_msg_list_elements($self);
 477         }
 478
 479         PyObject *__iter__(void)
 480         {
 481             return PyObject_GetIter(ldb_msg_list_elements($self));
 482         }
 483 #endif
 484         void remove_attr(const char *name);
 485 %pythoncode {
 486     def get(self, key, default=None):
 487         if key == "dn":
 488             return self.dn
 489         return self.find_element(key)
 490
 491     def __getitem__(self, key):
 492         ret = self.get(key, None)
 493         if ret is None:
 494             raise KeyError("No such element")
 495         return ret
 496
 497     def iteritems(self):
 498         for k in self.keys():
 499             yield k, self[k]
 500
 501     def items(self):
 502         return list(self.iteritems())
 503
 504     def __repr__(self):
 505         return "Message(%s)" % repr(dict(self.iteritems()))
 506 }
 507     }
 508 } ldb_msg;
 509
 510 /* FIXME: Convert ldb_result to 3-tuple:
 511    (msgs, refs, controls)
 512  */
 513
 514 typedef struct ldb_ldif ldb_ldif;
 515
 516 #ifdef SWIGPYTHON
 517 %{
 518 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
 519
 520 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
 521 {
 522     char *text;
 523     PyObject *fn = context;
 524
 525     vasprintf(&text, fmt, ap);
 526     PyObject_CallFunction(fn, (char *)"(i,s)", level, text);
 527     free(text);
 528 }
 529 %}
 530
 531 %typemap(in,numinputs=1,noblock=1) (void (*debug)(void *context, enum ldb_debug_level level, const char *fmt, va_list ap), void *context) {
 532     $1 = py_ldb_debug;
 533     /* FIXME: Should be decreased somewhere as well. Perhaps register a
 534        destructor and tie it to the ldb context ? */
 535     Py_INCREF($input);
 536     $2 = $input;
 537 }
 538 #endif
 539
 540 %inline {
 541     static PyObject *ldb_ldif_to_pyobject(ldb_ldif *ldif)
 542     {
 543         if (ldif == NULL) {
 544             return Py_None;
 545         } else {
 546             return Py_BuildValue((char *)"(iO)", ldif->changetype,
 547                    SWIG_NewPointerObj(ldif->msg, SWIGTYPE_p_ldb_message, 0));
 548         }
 549     }
 550 }
 551
 552 /*
 553  * Wrap ldb errors
 554  */
 555
 556 %{
 557 PyObject *PyExc_LdbError;
 558 %}
 559
 560 %pythoncode %{
 561     LdbError = _ldb.LdbError
 562 %}
 563
 564 %init %{
 565     PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
 566     PyDict_SetItemString(d, "LdbError", PyExc_LdbError);
 567 %}
 568
 569 %ignore _LDB_ERRORS_H_;
 570 %ignore LDB_SUCCESS;
 571 %include "include/ldb_errors.h"
 572
 573 /*
 574  * Wrap ldb functions
 575  */
 576
 577
 578 %typemap(out,noblock=1) ldb_error {
 579     if ($1 != LDB_SUCCESS) {
 580         PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", $1, ldb_errstring(arg1)));
 581         SWIG_fail;
 582     }
 583     $result = Py_None;
 584 };
 585
 586 %typemap(out,noblock=1) ldb_int_error {
 587     if ($1 != LDB_SUCCESS) {
 588         PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", $1, ldb_strerror($1)));
 589         SWIG_fail;
 590     }
 591     $result = Py_None;
 592 };
 593
 594 %typemap(out,noblock=1) struct ldb_control ** {
 595     if ($1 == NULL) {
 596         PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(s)", ldb_errstring(arg1)));
 597         SWIG_fail;
 598     }
 599     $result = SWIG_NewPointerObj($1, $1_descriptor, 0);
 600 }
 601
 602 %rename(Ldb) ldb_context;
 603
 604 %typemap(in,noblock=1) struct ldb_dn * {
 605     if (ldb_dn_from_pyobject(NULL, $input, arg1, &$1) != 0) {
 606         SWIG_fail;
 607     }
 608 };
 609
 610 %typemap(freearg,noblock=1) struct ldb_dn * {
 611     talloc_free($1);
 612 };
 613
 614 %typemap(in,numinputs=1) ldb_msg *add_msg {
 615     Py_ssize_t dict_pos, msg_pos;
 616     ldb_msg_element *msgel;
 617     PyObject *key, *value;
 618
 619     if (PyDict_Check($input)) {
 620         PyObject *dn_value = PyDict_GetItemString($input, "dn");
 621         $1 = ldb_msg_new(NULL);
 622         $1->elements = talloc_zero_array($1, struct ldb_message_element, PyDict_Size($input));
 623         msg_pos = dict_pos = 0;
 624         if (dn_value) {
 625                 /* using argp1 (magic SWIG value) here is a hack */
 626                 if (ldb_dn_from_pyobject($1, dn_value, argp1, &$1->dn) != 0) {
 627                     SWIG_exception(SWIG_TypeError, "unable to import dn object");
 628                 }
 629                 if ($1->dn == NULL) {
 630                     SWIG_exception(SWIG_TypeError, "dn set but not found");
 631                 }
 632         }
 633
 634         while (PyDict_Next($input, &dict_pos, &key, &value)) {
 635             char *key_str = PyString_AsString(key);
 636             if (strcmp(key_str, "dn") != 0) {
 637                 msgel = ldb_msg_element_from_pyobject($1->elements, value, 0, key_str);
 638                 if (msgel == NULL) {
 639                     SWIG_exception(SWIG_TypeError, "unable to import element");
 640                 }
 641                 memcpy(&$1->elements[msg_pos], msgel, sizeof(*msgel));
 642                 msg_pos++;
 643             }
 644         }
 645
 646         if ($1->dn == NULL) {
 647             SWIG_exception(SWIG_TypeError, "no dn set");
 648         }
 649
 650         $1->num_elements = msg_pos;
 651     } else {
 652         if (SWIG_ConvertPtr($input, (void **)&$1, SWIGTYPE_p_ldb_message, 0) != 0) {
 653             SWIG_exception(SWIG_TypeError, "unable to convert ldb message");
 654         }
 655     }
 656 }
 657
 658 /* Top-level ldb operations */
 659 typedef struct ldb_context {
 660     %extend {
 661         ldb(void) { return ldb_init(NULL); }
 662
 663         ldb_error connect(const char *url, unsigned int flags = 0,
 664             const char *options[] = NULL);
 665
 666         ~ldb() { talloc_free($self); }
 667         ldb_error search_ex(TALLOC_CTX *mem_ctx,
 668                    ldb_dn *base = NULL,
 669                    enum ldb_scope scope = LDB_SCOPE_DEFAULT,
 670                    const char *expression = NULL,
 671                    const char *const *attrs = NULL,
 672                    struct ldb_control **controls = NULL,
 673                    struct ldb_result **OUT) {
 674             int ret;
 675             struct ldb_result *res;
 676             struct ldb_request *req;
 677             res = talloc_zero(mem_ctx, struct ldb_result);
 678             if (!res) {
 679                 return LDB_ERR_OPERATIONS_ERROR;
 680             }
 681
 682             ret = ldb_build_search_req(&req, $self, mem_ctx,
 683                            base?base:ldb_get_default_basedn($self),
 684                            scope,
 685                            expression,
 686                            attrs,
 687                            controls,
 688                            res,
 689                            ldb_search_default_callback);
 690
 691             if (ret != LDB_SUCCESS) {
 692                 talloc_free(res);
 693                 return ret;
 694             }
 695
 696             ldb_set_timeout($self, req, 0); /* use default timeout */
 697
 698             ret = ldb_request($self, req);
 699
 700             if (ret == LDB_SUCCESS) {
 701                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 702             }
 703
 704             talloc_free(req);
 705
 706             *OUT = res;
 707             return ret;
 708         }
 709
 710         ldb_error delete(ldb_dn *dn);
 711         ldb_error rename(ldb_dn *olddn, ldb_dn *newdn);
 712         struct ldb_control **parse_control_strings(TALLOC_CTX *mem_ctx,
 713                                                    const char * const*control_strings);
 714         ldb_error add(ldb_msg *add_msg);
 715         ldb_error modify(ldb_msg *message);
 716         ldb_dn *get_config_basedn();
 717         ldb_dn *get_root_basedn();
 718         ldb_dn *get_schema_basedn();
 719         ldb_dn *get_default_basedn();
 720         PyObject *schema_format_value(const char *element_name, PyObject *val)
 721         {
 722                 const struct ldb_schema_attribute *a;
 723                 struct ldb_val old_val;
 724                 struct ldb_val new_val;
 725                 TALLOC_CTX *mem_ctx = talloc_new(NULL);
 726                 PyObject *ret;
 727
 728                 old_val.data = PyString_AsString(val);
 729                 old_val.length = PyString_Size(val);
 730
 731                 a = ldb_schema_attribute_by_name($self, element_name);
 732
 733                 if (a == NULL) {
 734                         return Py_None;
 735                 }
 736
 737                 if (a->syntax->ldif_write_fn($self, mem_ctx, &old_val, &new_val) != 0) {
 738                         talloc_free(mem_ctx);
 739                         return Py_None;
 740                  }
 741
 742                 ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
 743
 744                 talloc_free(mem_ctx);
 745
 746                 return ret;
 747         }
 748
 749         const char *errstring();
 750         void set_create_perms(unsigned int perms);
 751         void set_modules_dir(const char *path);
 752         ldb_error set_debug(void (*debug)(void *context, enum ldb_debug_level level,
 753                                           const char *fmt, va_list ap),
 754                             void *context);
 755         ldb_error set_opaque(const char *name, void *value);
 756         void *get_opaque(const char *name);
 757         ldb_error transaction_start();
 758         ldb_error transaction_commit();
 759         ldb_error transaction_cancel();
 760         void schema_attribute_remove(const char *name);
 761         ldb_error schema_attribute_add(const char *attribute, unsigned flags, const char *syntax);
 762         ldb_error setup_wellknown_attributes(void);
 763
 764 #ifdef SWIGPYTHON
 765         %typemap(in,numinputs=0,noblock=1) struct ldb_result **result_as_bool (struct ldb_result *tmp) { $1 = &tmp; }
 766         %typemap(argout,noblock=1) struct ldb_result **result_as_bool { $result = ((*$1)->count > 0)?Py_True:Py_False; }
 767         %typemap(freearg,noblock=1) struct ldb_result **result_as_bool { talloc_free(*$1); }
 768         ldb_error __contains__(ldb_dn *dn, struct ldb_result **result_as_bool)
 769         {
 770             return ldb_search($self, dn, LDB_SCOPE_BASE, NULL, NULL,
 771                              result_as_bool);
 772         }
 773
 774         PyObject *parse_ldif(const char *s)
 775         {
 776             PyObject *list = PyList_New(0);
 777             struct ldb_ldif *ldif;
 778             while ((ldif = ldb_ldif_read_string($self, &s)) != NULL) {
 779                 PyList_Append(list, ldb_ldif_to_pyobject(ldif));
 780             }
 781             return PyObject_GetIter(list);
 782         }
 783
 784         char *__repr__(void)
 785         {
 786             char *ret;
 787             asprintf(&ret, "<ldb connection at 0x%x>", ret);
 788             return ret;
 789         }
 790 #endif
 791     }
 792     %pythoncode {
 793         def __init__(self, url=None, flags=0, options=None):
 794             _ldb.Ldb_swiginit(self,_ldb.new_Ldb())
 795             if url is not None:
 796                 self.connect(url, flags, options)
 797
 798         def search(self, base=None, scope=SCOPE_DEFAULT, expression=None,
 799                    attrs=None, controls=None):
 800             if not (attrs is None or isinstance(attrs, list)):
 801                 raise TypeError("attributes not a list")
 802             parsed_controls = None
 803             if controls is not None:
 804                 parsed_controls = self.parse_control_strings(controls)
 805             return self.search_ex(base, scope, expression, attrs,
 806                                   parsed_controls)
 807     }
 808
 809 } ldb;
 810
 811 %typemap(in,noblock=1) struct ldb_dn *;
 812 %typemap(freearg,noblock=1) struct ldb_dn *;
 813
 814 %nodefault ldb_message;
 815 %nodefault ldb_context;
 816 %nodefault Dn;
 817
 818 %rename(valid_attr_name) ldb_valid_attr_name;
 819 int ldb_valid_attr_name(const char *s);
 820
 821 typedef unsigned long time_t;
 822
 823 %inline %{
 824 static char *timestring(time_t t)
 825 {
 826     char *tresult = ldb_timestring(NULL, t);
 827     char *result = strdup(tresult);
 828     talloc_free(tresult);
 829     return result;
 830 }
 831 %}
 832
 833 %rename(string_to_time) ldb_string_to_time;
 834 time_t ldb_string_to_time(const char *s);
 835
 836 %typemap(in,noblock=1) const struct ldb_module_ops * {
 837     $1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
 838
 839     $1->name = (char *)PyObject_GetAttrString($input, (char *)"name");
 840 }
 841
 842 %rename(register_module) ldb_register_module;
 843 ldb_int_error ldb_register_module(const struct ldb_module_ops *);