Rebase ldb code with all changes in samba master

40 files changed, 3303 insertions, 9628 deletions

diff --git a/ldb/Makefile.in b/ldb/Makefile.in
index b8010150a..d97ca8bde 100644
--- a/ldb/Makefile.in
+++ b/ldb/Makefile.in
@@ -17,7 +17,6 @@ builddir = @builddir@
 sharedbuilddir = @sharedbuilddir@
 INSTALLCMD = @INSTALL@
 SLAPD = @SLAPD@
-SWIG = swig
 EXTRA_OBJ=@EXTRA_OBJ@
 TESTS=test-tdb.sh @TESTS@
 PACKAGE_VERSION = @PACKAGE_VERSION@
@@ -51,11 +50,11 @@ LD_EXPORT_DYNAMIC = @LD_EXPORT_DYNAMIC@
 SHLD = @SHLD@
 SHLD_FLAGS = @SHLD_FLAGS@
 
-LDFLAGS += @LDFLAGS@
+LDFLAGS = @LDFLAGS@
 LIBS = @LIBS@
 
 PICFLAG = @PICFLAG@
-CFLAGS += -I$(srcdir)/include -Iinclude -I$(srcdir) -I$(srcdir)/.. \
+CFLAGS=-g -I$(srcdir)/include -Iinclude -I$(srcdir) -I$(srcdir)/.. \
        $(POPT_CFLAGS) $(TALLOC_CFLAGS) $(TDB_CFLAGS) $(EVENTS_CFLAGS) \
 	-DLIBDIR=\"$(libdir)\" -DSHLIBEXT=\"$(SHLIBEXT)\" -DUSE_MMAP=1 @CFLAGS@
 
diff --git a/ldb/autogen.sh b/ldb/autogen.sh
index 52fc8b63e..e4d367dc1 100755
--- a/ldb/autogen.sh
+++ b/ldb/autogen.sh
@@ -11,8 +11,6 @@ autoconf $IPATHS || exit 1
 
 rm -rf autom4te.cache
 
-swig -O -Wall -python -keyword ldb.i # Ignore errors, for now
-
 echo "Now run ./configure and then make."
 exit 0
 
diff --git a/ldb/common/attrib_handlers.c b/ldb/common/attrib_handlers.c
index fb57e2dad..5ec86b5b8 100644
--- a/ldb/common/attrib_handlers.c
+++ b/ldb/common/attrib_handlers.c
@@ -240,7 +240,7 @@ int ldb_canonicalise_dn(struct ldb_context *ldb, void *mem_ctx,
 	out->length = 0;
 	out->data = NULL;
 
-	dn = ldb_dn_new(ldb, mem_ctx, (char *)in->data);
+	dn = ldb_dn_from_ldb_val(ldb, mem_ctx, in);
 	if ( ! ldb_dn_validate(dn)) {
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
@@ -268,10 +268,10 @@ int ldb_comparison_dn(struct ldb_context *ldb, void *mem_ctx,
 	struct ldb_dn *dn1 = NULL, *dn2 = NULL;
 	int ret;
 
-	dn1 = ldb_dn_new(ldb, mem_ctx, (char *)v1->data);
+	dn1 = ldb_dn_from_ldb_val(ldb, mem_ctx, v1);
 	if ( ! ldb_dn_validate(dn1)) return -1;
 
-	dn2 = ldb_dn_new(ldb, mem_ctx, (char *)v2->data);
+	dn2 = ldb_dn_from_ldb_val(ldb, mem_ctx, v2);
 	if ( ! ldb_dn_validate(dn2)) {
 		talloc_free(dn1);
 		return -1;
diff --git a/ldb/common/ldb.c b/ldb/common/ldb.c
index bb7103345..c013565da 100644
--- a/ldb/common/ldb.c
+++ b/ldb/common/ldb.c
@@ -394,7 +394,6 @@ static int ldb_autotransaction_request(struct ldb_context *ldb,
 int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 {
 	struct event_context *ev;
-	int ret;
 
 	if (!handle) {
 		return LDB_ERR_UNAVAILABLE;
@@ -411,8 +410,7 @@ int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 
 	switch (type) {
 	case LDB_WAIT_NONE:
-		ret = event_loop_once(ev);
-		if (ret) return LDB_ERR_OPERATIONS_ERROR;
+		event_loop_once(ev);
 		if (handle->state == LDB_ASYNC_DONE ||
 		    handle->status != LDB_SUCCESS) {
 			return handle->status;
@@ -421,8 +419,7 @@ int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 
 	case LDB_WAIT_ALL:
 		while (handle->state != LDB_ASYNC_DONE) {
-			ret = event_loop_once(ev);
-			if (ret) return LDB_ERR_OPERATIONS_ERROR;
+			event_loop_once(ev);
 			if (handle->status != LDB_SUCCESS) {
 				return handle->status;
 			}
diff --git a/ldb/common/ldb_attributes.c b/ldb/common/ldb_attributes.c
index 747f24178..001bc45ee 100644
--- a/ldb/common/ldb_attributes.c
+++ b/ldb/common/ldb_attributes.c
@@ -225,3 +225,50 @@ int ldb_setup_wellknown_attributes(struct ldb_context *ldb)
 	return LDB_SUCCESS;
 }
 
+
+/*
+  add a extended dn syntax to the ldb_schema
+*/
+int ldb_dn_extended_add_syntax(struct ldb_context *ldb, 
+			       unsigned flags,
+			       const struct ldb_dn_extended_syntax *syntax)
+{
+	int n;
+	struct ldb_dn_extended_syntax *a;
+
+	if (!syntax) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	n = ldb->schema.num_dn_extended_syntax + 1;
+
+	a = talloc_realloc(ldb, ldb->schema.dn_extended_syntax,
+			   struct ldb_dn_extended_syntax, n);
+
+	if (!a) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	a[ldb->schema.num_dn_extended_syntax] = *syntax;
+	ldb->schema.dn_extended_syntax = a;
+
+	ldb->schema.num_dn_extended_syntax = n;
+
+	return LDB_SUCCESS;
+}
+
+/*
+  return the extended dn syntax for a given name
+*/
+const struct ldb_dn_extended_syntax *ldb_dn_extended_syntax_by_name(struct ldb_context *ldb,
+								    const char *name)
+{
+	int i;
+	for (i=0; i < ldb->schema.num_dn_extended_syntax; i++) {
+		if (ldb_attr_cmp(ldb->schema.dn_extended_syntax[i].name, name) == 0) {
+			return &ldb->schema.dn_extended_syntax[i];
+		}
+	}
+	return NULL;
+}
+
diff --git a/ldb/common/ldb_controls.c b/ldb/common/ldb_controls.c
index e3f855140..6fad5012b 100644
--- a/ldb/common/ldb_controls.c
+++ b/ldb/common/ldb_controls.c
@@ -53,6 +53,26 @@ struct ldb_control *ldb_request_get_control(struct ldb_request *req, const char
 	return NULL;
 }
 
+/* check if a control with the specified "oid" exist and return it */
+/* returns NULL if not found */
+struct ldb_control *ldb_reply_get_control(struct ldb_reply *rep, const char *oid)
+{
+	int i;
+
+	/* check if there's a paged request control */
+	if (rep->controls != NULL) {
+		for (i = 0; rep->controls[i]; i++) {
+			if (strcmp(oid, rep->controls[i]->oid) == 0) {
+				break;
+			}
+		}
+
+		return rep->controls[i];
+	}
+
+	return NULL;
+}
+
 /* saves the current controls list into the "saver" and replace the one in req with a new one excluding
 the "exclude" control */
 /* returns False on error */
diff --git a/ldb/common/ldb_dn.c b/ldb/common/ldb_dn.c
index c0d36cfbf..02e21a2b2 100644
--- a/ldb/common/ldb_dn.c
+++ b/ldb/common/ldb_dn.c
@@ -52,6 +52,12 @@ struct ldb_dn_component {
 	struct ldb_val cf_value;
 };
 
+struct ldb_dn_extended_component {
+
+	char *name;
+	struct ldb_val value;
+};
+
 struct ldb_dn {
 
 	struct ldb_context *ldb;
@@ -63,11 +69,14 @@ struct ldb_dn {
 	bool valid_case;
 
 	char *linearized;
+	char *extended_linearized;
 	char *casefold;
 
 	unsigned int comp_num;
 	struct ldb_dn_component *components;
 
+	unsigned int extended_comp_num;
+	struct ldb_dn_extended_component *extended_components;
 };
 
 /* strdn may be NULL */
@@ -85,28 +94,34 @@ struct ldb_dn *ldb_dn_from_ldb_val(void *mem_ctx, struct ldb_context *ldb, const
 	if (strdn->data && strdn->length) {
 		if (strdn->data[0] == '@') {
 			dn->special = true;
+		} 
+		dn->extended_linearized = talloc_strndup(dn, (const char *)strdn->data, strdn->length);
+		LDB_DN_NULL_FAILED(dn->extended_linearized);
+	
+		if (strdn->data[0] == '<') {
+			const char *p_save, *p = dn->extended_linearized;
+			do {
+				p_save = p;
+				p = strstr(p, ">;");
+				if (p) {
+					p = p + 2;
+				}
+			} while (p);
+			
+			if (p_save == dn->extended_linearized) {
+				dn->linearized = talloc_strdup(dn, "");
+			} else {
+				dn->linearized = talloc_strdup(dn, p_save);
+			}
+			LDB_DN_NULL_FAILED(dn->linearized);
+		} else {
+			dn->linearized = dn->extended_linearized;
+			dn->extended_linearized = NULL;
 		}
-		if (strdn->length >= 6 && strncasecmp((const char *)strdn->data, "<GUID=", 6) == 0) {
-			/* this is special DN returned when the
-			 * exploded_dn control is used */
-			dn->special = true;
-			/* FIXME: add a GUID string to ldb_dn structure */
-		} else if (strdn->length >= 8 && strncasecmp((const char *)strdn->data, "<SID=", 8) == 0) {
-			/* this is special DN returned when the
-			 * exploded_dn control is used */
-			dn->special = true;
-			/* FIXME: add a SID string to ldb_dn structure */
-		} else if (strdn->length >= 8 && strncasecmp((const char *)strdn->data, "<WKGUID=", 8) == 0) {
-			/* this is special DN returned when the
-			 * exploded_dn control is used */
-			dn->special = true;
-			/* FIXME: add a WKGUID string to ldb_dn structure */
-		}
-		dn->linearized = talloc_strndup(dn, (const char *)strdn->data, strdn->length);
 	} else {
 		dn->linearized = talloc_strdup(dn, "");
+		LDB_DN_NULL_FAILED(dn->linearized);
 	}
-	LDB_DN_NULL_FAILED(dn->linearized);
 
 	return dn;
 
@@ -126,47 +141,21 @@ struct ldb_dn *ldb_dn_new(void *mem_ctx, struct ldb_context *ldb, const char *st
 
 struct ldb_dn *ldb_dn_new_fmt(void *mem_ctx, struct ldb_context *ldb, const char *new_fmt, ...)
 {
-	struct ldb_dn *dn;
 	char *strdn;
 	va_list ap;
 
 	if ( (! mem_ctx) || (! ldb)) return NULL;
 
-	dn = talloc_zero(mem_ctx, struct ldb_dn);
-	LDB_DN_NULL_FAILED(dn);
-
-	dn->ldb = ldb;
-
 	va_start(ap, new_fmt);
-	strdn = talloc_vasprintf(dn, new_fmt, ap);
+	strdn = talloc_vasprintf(mem_ctx, new_fmt, ap);
 	va_end(ap);
-	LDB_DN_NULL_FAILED(strdn);
-
-	if (strdn[0] == '@') {
-		dn->special = true;
-	}
-	if (strncasecmp(strdn, "<GUID=", 6) == 0) {
-		/* this is special DN returned when the
-		 * exploded_dn control is used */
-		dn->special = true;
-		/* FIXME: add a GUID string to ldb_dn structure */
-	} else if (strncasecmp(strdn, "<SID=", 8) == 0) {
-		/* this is special DN returned when the
-		 * exploded_dn control is used */
-		dn->special = true;
-		/* FIXME: add a SID string to ldb_dn structure */
-	} else if (strncasecmp(strdn, "<WKGUID=", 8) == 0) {
-		/* this is special DN returned when the
-		 * exploded_dn control is used */
-		dn->special = true;
-		/* FIXME: add a WKGUID string to ldb_dn structure */
-	}
-	dn->linearized = strdn;
 
-	return dn;
-
-failed:
-	talloc_free(dn);
+	if (strdn) {
+		struct ldb_dn *dn = ldb_dn_new(mem_ctx, ldb, strdn);
+		talloc_free(strdn);
+		return dn;
+	}
+	
 	return NULL;
 }
 
@@ -235,15 +224,19 @@ char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
 */
 static bool ldb_dn_explode(struct ldb_dn *dn)
 {
-	char *p, *data, *d, *dt, *t;
+	char *p, *ex_name, *ex_value, *data, *d, *dt, *t;
 	bool trim = false;
+	bool in_extended = false;
+	bool in_ex_name = false;
+	bool in_ex_value = false;
 	bool in_attr = false;
 	bool in_value = false;
 	bool in_quote = false;
 	bool is_oid = false;
 	bool escape = false;
 	unsigned x;
-	int l;
+	int l, ret;
+	char *parse_dn;
 
 	if ( ! dn || dn->invalid) return false;
 
@@ -251,12 +244,18 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 		return true;
 	}
 
-	if ( ! dn->linearized) {
+	if (dn->extended_linearized) {
+		parse_dn = dn->extended_linearized;
+	} else {
+		parse_dn = dn->linearized;
+	}
+
+	if ( ! parse_dn ) {
 		return false;
 	}
 
 	/* Empty DNs */
-	if (dn->linearized[0] == '\0') {
+	if (parse_dn[0] == '\0') {
 		return true;
 	}
 
@@ -268,6 +267,9 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 	/* make sure we free this if alloced previously before replacing */
 	talloc_free(dn->components);
 
+	talloc_free(dn->extended_components);
+	dn->extended_components = NULL;
+
 	/* in the common case we have 3 or more components */
 	/* make sure all components are zeroed, other functions depend on this */
 	dn->components = talloc_zero_array(dn, struct ldb_dn_component, 3);
@@ -277,19 +279,109 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 	dn->comp_num = 0;
 
 	/* Components data space is allocated here once */
-	data = talloc_array(dn->components, char, strlen(dn->linearized) + 1);
+	data = talloc_array(dn->components, char, strlen(parse_dn) + 1);
 	if (!data) {
 		return false;
 	}
 
-	p = dn->linearized;
-	in_attr = true;
+	p = parse_dn;
+	in_extended = true;
+	in_ex_name = false;
+	in_ex_value = false;
 	trim = true;
 	t = NULL;
 	d = dt = data;
 
 	while (*p) {
+		if (in_extended) {
+
+			if (!in_ex_name && !in_ex_value) {
+
+				if (p[0] == '<') {
+					p++;
+					ex_name = d;
+					in_ex_name = true;
+					continue;
+				} else if (p[0] == '\0') {
+					p++;
+					continue;
+				} else {
+					in_extended = false;
+					in_attr = true;
+					dt = d;
+
+					continue;
+				}
+			}
+			
+			if (in_ex_name && *p == '=') {
+				*d++ = '\0';
+				p++;
+				ex_value = d;
+				in_ex_name = false;
+				in_ex_value = true;
+				continue;
+			}
+
+			if (in_ex_value && *p == '>') {
+				const struct ldb_dn_extended_syntax *extended_syntax;
+				struct ldb_val ex_val = {
+					.data = ex_value,
+					.length = d - ex_value
+				};
+					
+				*d++ = '\0';
+				p++;
+				in_ex_value = false;
+
+				/* Process name and ex_value */
+
+				dn->extended_components = talloc_realloc(dn,
+									 dn->extended_components,
+									 struct ldb_dn_extended_component,
+									 dn->extended_comp_num + 1);
+				if ( ! dn->extended_components) {
+					/* ouch ! */
+					goto failed;
+				}
+
+				extended_syntax = ldb_dn_extended_syntax_by_name(dn->ldb, ex_name);
+				if (!extended_syntax) {
+					/* We don't know about this type of extended DN */
+					goto failed;
+				}
+
+				dn->extended_components[dn->extended_comp_num].name = talloc_strdup(dn->extended_components, ex_name);
+				if (!dn->extended_components[dn->extended_comp_num].name) {
+					/* ouch */
+					goto failed;
+				}
+				ret = extended_syntax->read_fn(dn->ldb, dn->extended_components,
+							       &ex_val, &dn->extended_components[dn->extended_comp_num].value);
+				if (ret != LDB_SUCCESS) {
+					dn->invalid = true;
+					goto failed;
+				}
+
+				dn->extended_comp_num++;
 
+				if (*p == '\0') {
+					/* We have reached the end (extended component only)! */
+					talloc_free(data);
+					return true;
+
+				} else if (*p == ';') {
+					p++;
+					continue;
+				} else {
+					dn->invalid = true;
+					goto failed;
+				}
+			}
+
+			*d++ = *p++;
+			continue;
+		}
 		if (in_attr) {
 			if (trim) {
 				if (*p == ' ') {
@@ -315,6 +407,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 					goto failed;
 				}
 				
+				/* Copy this character across from parse_dn, now we have trimmed out spaces */
 				*d++ = *p++;
 				continue;
 			}
@@ -339,6 +432,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 				trim = true;
 				l = 0;
 
+				/* Terminate this string in d (which is a copy of parse_dn with spaces trimmed) */
 				*d++ = '\0';
 				dn->components[dn->comp_num].name = talloc_strdup(dn->components, dt);
 				if ( ! dn->components[dn->comp_num].name) {
@@ -614,6 +708,74 @@ const char *ldb_dn_get_linearized(struct ldb_dn *dn)
 	return dn->linearized;
 }
 
+char *ldb_dn_get_extended_linearized(void *mem_ctx, struct ldb_dn *dn, int mode)
+{
+	const char *linearized = ldb_dn_get_linearized(dn);
+	char *p;
+	int i;
+
+	if (!linearized) {
+		return NULL;
+	}
+
+	if (!ldb_dn_has_extended(dn)) {
+		return talloc_strdup(mem_ctx, linearized);
+	}
+	
+	if (!ldb_dn_validate(dn)) {
+		return NULL;
+	}
+
+	for (i=0; i < dn->extended_comp_num; i++) {
+		struct ldb_val val;
+		int ret;
+		const struct ldb_dn_extended_syntax *extended_syntax;
+		const char *name = dn->extended_components[i].name;
+		
+		extended_syntax = ldb_dn_extended_syntax_by_name(dn->ldb, name);
+
+		if (mode == 1) {
+			ret = extended_syntax->write_clear_fn(dn->ldb, mem_ctx,
+							      &dn->extended_components[i].value,
+							      &val);
+		} else if (mode == 0) {
+			ret = extended_syntax->write_hex_fn(dn->ldb, mem_ctx,
+							      &dn->extended_components[i].value,
+							      &val);
+		} else {
+			ret = -1;
+		}
+
+		if (ret != LDB_SUCCESS) {
+			return NULL;
+		}
+
+		if (i == 0) {
+			p = talloc_asprintf(mem_ctx, "<%s=%s>", dn->extended_components[i].name, val.data);
+		} else {
+			p = talloc_asprintf_append(p, ";<%s=%s>",  dn->extended_components[i].name, val.data);
+		}
+
+		talloc_free(val.data);
+
+		if (!p) {
+			return NULL;
+		}
+	}
+
+	if (dn->extended_comp_num && *linearized) {
+		p = talloc_asprintf_append(p, ";%s", linearized);
+	}
+
+	if (!p) {
+		return NULL;
+	}
+
+	return p;
+}
+
+
+
 char *ldb_dn_alloc_linearized(void *mem_ctx, struct ldb_dn *dn)
 {
 	return talloc_strdup(mem_ctx, ldb_dn_get_linearized(dn));
@@ -909,6 +1071,30 @@ static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_d
 	return dst;
 }
 
+static struct ldb_dn_extended_component ldb_dn_extended_copy_component(void *mem_ctx, struct ldb_dn_extended_component *src)
+{
+	struct ldb_dn_extended_component dst;
+
+	memset(&dst, 0, sizeof(dst));
+
+	if (src == NULL) {
+		return dst;
+	}
+
+	dst.value = ldb_val_dup(mem_ctx, &(src->value));
+	if (dst.value.data == NULL) {
+		return dst;
+	}
+
+	dst.name = talloc_strdup(mem_ctx, src->name);
+	if (dst.name == NULL) {
+		LDB_FREE(dst.value.data);
+		return dst;
+	}
+
+	return dst;
+}
+
 struct ldb_dn *ldb_dn_copy(void *mem_ctx, struct ldb_dn *dn)
 {
 	struct ldb_dn *new_dn;
@@ -942,6 +1128,24 @@ struct ldb_dn *ldb_dn_copy(void *mem_ctx, struct ldb_dn *dn)
 		}
 	}
 
+	if (dn->extended_components) {
+		int i;
+
+		new_dn->extended_components = talloc_zero_array(new_dn, struct ldb_dn_extended_component, dn->extended_comp_num);
+		if ( ! new_dn->extended_components) {
+			talloc_free(new_dn);
+			return NULL;
+		}
+
+		for (i = 0; i < dn->extended_comp_num; i++) {
+			new_dn->extended_components[i] = ldb_dn_extended_copy_component(new_dn->extended_components, &dn->extended_components[i]);
+			if ( ! new_dn->extended_components[i].value.data) {
+				talloc_free(new_dn);
+				return NULL;
+			}
+		}
+	}
+
 	if (dn->casefold) {
 		new_dn->casefold = talloc_strdup(new_dn, dn->casefold);
 		if ( ! new_dn->casefold) {
@@ -958,6 +1162,14 @@ struct ldb_dn *ldb_dn_copy(void *mem_ctx, struct ldb_dn *dn)
 		}
 	}
 
+	if (dn->extended_linearized) {
+		new_dn->extended_linearized = talloc_strdup(new_dn, dn->extended_linearized);
+		if ( ! new_dn->extended_linearized) {
+			talloc_free(new_dn);
+			return NULL;
+		}
+	}
+
 	return new_dn;
 }
 
@@ -1037,6 +1249,13 @@ bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
 		dn->linearized = t;
 	}
 
+	/* Wipe the extended_linearized DN, as the GUID and SID are almost certainly no longer valid */
+	if (dn->extended_linearized) {
+		LDB_FREE(dn->extended_linearized);
+	}
+
+	LDB_FREE(dn->extended_components);
+	dn->extended_comp_num = 0;
 	return true;
 }
 
@@ -1149,6 +1368,12 @@ bool ldb_dn_add_child(struct ldb_dn *dn, struct ldb_dn *child)
 		dn->linearized = t;
 	}
 
+	/* Wipe the extended_linearized DN, as the GUID and SID are almost certainly no longer valid */
+	LDB_FREE(dn->extended_linearized);
+
+	LDB_FREE(dn->extended_components);
+	dn->extended_comp_num = 0;
+
 	return true;
 }
 
@@ -1218,6 +1443,12 @@ bool ldb_dn_remove_base_components(struct ldb_dn *dn, unsigned int num)
 	LDB_FREE(dn->casefold);
 	LDB_FREE(dn->linearized);
 
+	/* Wipe the extended_linearized DN, as the GUID and SID are almost certainly no longer valid */
+	LDB_FREE(dn->extended_linearized);
+
+	LDB_FREE(dn->extended_components);
+	dn->extended_comp_num = 0;
+
 	return true;
 }
 
@@ -1256,6 +1487,11 @@ bool ldb_dn_remove_child_components(struct ldb_dn *dn, unsigned int num)
 	LDB_FREE(dn->casefold);
 	LDB_FREE(dn->linearized);
 
+	/* Wipe the extended_linearized DN, as the GUID and SID are almost certainly no longer valid */
+	LDB_FREE(dn->extended_linearized);
+
+	LDB_FREE(dn->extended_components);
+	dn->extended_comp_num = 0;
 	return true;
 }
 
@@ -1273,6 +1509,11 @@ struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, struct ldb_dn *dn)
 		return NULL;
 	}
 
+	/* Wipe the extended_linearized DN, as the GUID and SID are almost certainly no longer valid */
+	LDB_FREE(dn->extended_linearized);
+
+	LDB_FREE(dn->extended_components);
+	dn->extended_comp_num = 0;
 	return new_dn;
 }
 
@@ -1434,9 +1675,97 @@ int ldb_dn_set_component(struct ldb_dn *dn, int num, const char *name, const str
 	LDB_FREE(dn->casefold);
 	LDB_FREE(dn->linearized);
 
+	/* Wipe the extended_linearized DN, as the GUID and SID are almost certainly no longer valid */
+	LDB_FREE(dn->extended_linearized);
+
+	dn->extended_comp_num = 0;
+	LDB_FREE(dn->extended_components);
 	return LDB_SUCCESS;
 }
 
+const struct ldb_val *ldb_dn_get_extended_component(struct ldb_dn *dn, const char *name)
+{
+	int i;
+	if ( ! ldb_dn_validate(dn)) {
+		return NULL;
+	}
+	for (i=0; i < dn->extended_comp_num; i++) {
+		if (ldb_attr_cmp(dn->extended_components[i].name, name) == 0) {
+			return &dn->extended_components[i].value;
+		}
+	}
+	return NULL;
+}
+
+int ldb_dn_set_extended_component(struct ldb_dn *dn, const char *name, const struct ldb_val *val)
+{
+	struct ldb_dn_extended_component *p;
+	int i;
+				
+	if ( ! ldb_dn_validate(dn)) {
+		return LDB_ERR_OTHER;
+	}
+
+	for (i=0; i < dn->extended_comp_num; i++) {
+		if (ldb_attr_cmp(dn->extended_components[i].name, name) == 0) {
+			if (val) {
+				dn->extended_components[i].value = ldb_val_dup(dn->extended_components, val);
+
+				dn->extended_components[i].name = talloc_strdup(dn->extended_components, name);
+				if (!dn->extended_components[i].name || !dn->extended_components[i].value.data) {
+					dn->invalid = true;
+					return LDB_ERR_OPERATIONS_ERROR;
+				}
+	
+			} else {
+				if (i != (dn->extended_comp_num - 1)) {
+					memmove(&dn->extended_components[i], &dn->extended_components[i+1],
+						((dn->extended_comp_num-1) - i)*sizeof(*dn->extended_components));
+				}
+				dn->extended_comp_num--;
+				
+				dn->extended_components = talloc_realloc(dn,
+						   dn->extended_components,
+						   struct ldb_dn_extended_component,
+						   dn->extended_comp_num);
+				if (!dn->extended_components) {
+					dn->invalid = true;
+					return LDB_ERR_OPERATIONS_ERROR;
+				}
+				return LDB_SUCCESS;
+			}
+		}
+	}
+
+	p = dn->extended_components
+		= talloc_realloc(dn,
+				 dn->extended_components,
+				 struct ldb_dn_extended_component,
+				 dn->extended_comp_num + 1);
+	if (!dn->extended_components) {
+		dn->invalid = true;
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	
+	p[dn->extended_comp_num].value = ldb_val_dup(dn->extended_components, val);
+	p[dn->extended_comp_num].name = talloc_strdup(p, name);
+	
+	if (!dn->extended_components[i].name || !dn->extended_components[i].value.data) {
+		dn->invalid = true;
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	dn->extended_components = p;
+	dn->extended_comp_num++;
+	
+	return LDB_SUCCESS;
+}
+
+void ldb_dn_remove_extended_components(struct ldb_dn *dn)
+{
+	dn->extended_comp_num = 0;
+	LDB_FREE(dn->extended_components);	
+}
+
 bool ldb_dn_is_valid(struct ldb_dn *dn)
 {
 	if ( ! dn) return false;
@@ -1449,6 +1778,13 @@ bool ldb_dn_is_special(struct ldb_dn *dn)
 	return dn->special;
 }
 
+bool ldb_dn_has_extended(struct ldb_dn *dn)
+{
+	if ( ! dn || dn->invalid) return false;
+	if (dn->extended_linearized && (dn->extended_linearized[0] == '<')) return true;
+	return dn->extended_comp_num != 0;
+}
+
 bool ldb_dn_check_special(struct ldb_dn *dn, const char *check)
 {
 	if ( ! dn || dn->invalid) return false;
@@ -1458,6 +1794,7 @@ bool ldb_dn_check_special(struct ldb_dn *dn, const char *check)
 bool ldb_dn_is_null(struct ldb_dn *dn)
 {
 	if ( ! dn || dn->invalid) return false;
+	if (ldb_dn_has_extended(dn)) return false;
 	if (dn->linearized && (dn->linearized[0] == '\0')) return true;
 	return false;
 }
diff --git a/ldb/common/ldb_ldif.c b/ldb/common/ldb_ldif.c
index fb93e17c6..619c10e11 100644
--- a/ldb/common/ldb_ldif.c
+++ b/ldb/common/ldb_ldif.c
@@ -278,13 +278,15 @@ int ldb_ldif_write(struct ldb_context *ldb,
 	TALLOC_CTX *mem_ctx;
 	unsigned int i, j;
 	int total=0, ret;
+	char *p;
 	const struct ldb_message *msg;
 
 	mem_ctx = talloc_named_const(NULL, 0, "ldb_ldif_write");
 
 	msg = ldif->msg;
-
-	ret = fprintf_fn(private_data, "dn: %s\n", ldb_dn_get_linearized(msg->dn));
+	p = ldb_dn_get_extended_linearized(mem_ctx, msg->dn, 1);
+	ret = fprintf_fn(private_data, "dn: %s\n", p);
+	talloc_free(p);
 	CHECK_RET;
 
 	if (ldif->changetype != LDB_CHANGETYPE_NONE) {
@@ -328,8 +330,10 @@ int ldb_ldif_write(struct ldb_context *ldb,
 		for (j=0;j<msg->elements[i].num_values;j++) {
 			struct ldb_val v;
 			ret = a->syntax->ldif_write_fn(ldb, mem_ctx, &msg->elements[i].values[j], &v);
-			CHECK_RET;
-			if (ldb_should_b64_encode(&v)) {
+			if (ret != LDB_SUCCESS) {
+				v = msg->elements[i].values[j];
+			}
+			if (ret != LDB_SUCCESS || ldb_should_b64_encode(&v)) {
 				ret = fprintf_fn(private_data, "%s:: ", 
 						 msg->elements[i].name);
 				CHECK_RET;
@@ -562,11 +566,11 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		goto failed;
 	}
 
-	msg->dn = ldb_dn_new(msg, ldb, (char *)value.data);
+	msg->dn = ldb_dn_from_ldb_val(msg, ldb, &value);
 
 	if ( ! ldb_dn_validate(msg->dn)) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: Unable to parse dn '%s'\n", 
-				  value.data);
+			  (char *)value.data);
 		goto failed;
 	}
 
diff --git a/ldb/common/ldb_match.c b/ldb/common/ldb_match.c
index 64d0e5476..4cde739d6 100644
--- a/ldb/common/ldb_match.c
+++ b/ldb/common/ldb_match.c
@@ -147,7 +147,7 @@ static int ldb_match_equality(struct ldb_context *ldb,
 	int ret;
 
 	if (ldb_attr_dn(tree->u.equality.attr) == 0) {
-		valuedn = ldb_dn_new(ldb, ldb, (char *)tree->u.equality.value.data);
+		valuedn = ldb_dn_from_ldb_val(ldb, ldb, &tree->u.equality.value);
 		if (valuedn == NULL) {
 			return 0;
 		}
diff --git a/ldb/common/ldb_modules.c b/ldb/common/ldb_modules.c
index 2b453bb0c..8db28d262 100644
--- a/ldb/common/ldb_modules.c
+++ b/ldb/common/ldb_modules.c
@@ -40,6 +40,9 @@
 #define LDB_MODULE_PREFIX	"modules:"
 #define LDB_MODULE_PREFIX_LEN	8
 
+static void *ldb_dso_load_symbol(struct ldb_context *ldb, const char *name,
+				 const char *symbol);
+
 void ldb_set_modules_dir(struct ldb_context *ldb, const char *path)
 {
 	talloc_free(ldb->modules_dir);
@@ -291,8 +294,8 @@ int ldb_register_module(const struct ldb_module_ops *ops)
 	return 0;
 }
 
-void *ldb_dso_load_symbol(struct ldb_context *ldb, const char *name,
-			    const char *symbol)
+static void *ldb_dso_load_symbol(struct ldb_context *ldb, const char *name,
+				 const char *symbol)
 {
 	char *path;
 	void *handle;
@@ -334,6 +337,10 @@ int ldb_load_modules_list(struct ldb_context *ldb, const char **module_list, str
 	for (i = 0; module_list[i] != NULL; i++) {
 		struct ldb_module *current;
 		const struct ldb_module_ops *ops;
+
+		if (strcmp(module_list[i], "") == 0) {
+			continue;
+		}
 		
 		ops = ldb_find_module_ops(module_list[i]);
 		if (ops == NULL) {
@@ -580,10 +587,13 @@ struct ldb_handle *ldb_handle_new(TALLOC_CTX *mem_ctx, struct ldb_context *ldb)
  *      req: the original request passed to your module
  *      msg: reply message (must be a talloc pointer, and it will be stolen
  *           on the ldb_reply that is sent to the callback)
+ * 	ctrls: controls to send in the reply  (must be a talloc pointer, and it will be stolen
+ *           on the ldb_reply that is sent to the callback)
  */
 
 int ldb_module_send_entry(struct ldb_request *req,
-			  struct ldb_message *msg)
+			  struct ldb_message *msg,
+			  struct ldb_control **ctrls)
 {
 	struct ldb_reply *ares;
 
@@ -595,6 +605,7 @@ int ldb_module_send_entry(struct ldb_request *req,
 	}
 	ares->type = LDB_REPLY_ENTRY;
 	ares->message = talloc_steal(ares, msg);
+	ares->controls = talloc_steal(ares, ctrls);
 	ares->error = LDB_SUCCESS;
 
 	return req->callback(req, ares);
diff --git a/ldb/include/ldb.h b/ldb/include/ldb.h
index 7208dd5db..e2ec86987 100644
--- a/ldb/include/ldb.h
+++ b/ldb/include/ldb.h
@@ -43,13 +43,9 @@
 #ifndef _LDB_H_
 
 /*! \cond DOXYGEN_IGNORE */
-#define _LDB_H_
+#define _LDB_H_ 1
 /*! \endcond */
 
-#include <stdbool.h>
-#include <talloc.h>
-#include <events.h>
-
 /*
   major restrictions as compared to normal LDAP:
 
@@ -185,6 +181,7 @@ enum ldb_scope {LDB_SCOPE_DEFAULT=-1,
 		LDB_SCOPE_SUBTREE=2};
 
 struct ldb_context;
+struct event_context;
 
 /* debugging uses one of the following levels */
 enum ldb_debug_level {LDB_DEBUG_FATAL, LDB_DEBUG_ERROR, 
@@ -329,7 +326,6 @@ typedef int (*ldb_attr_comparison_t)(struct ldb_context *, TALLOC_CTX *mem_ctx,
   attribute handler structure
 
   attr			-> The attribute name
-  flags			-> LDB_ATTR_FLAG_*
   ldif_read_fn		-> convert from ldif to binary format
   ldif_write_fn		-> convert from binary to ldif format
   canonicalise_fn	-> canonicalise a value, for use by indexing and dn construction
@@ -353,6 +349,16 @@ struct ldb_schema_attribute {
 const struct ldb_schema_attribute *ldb_schema_attribute_by_name(struct ldb_context *ldb,
 								const char *name);
 
+struct ldb_dn_extended_syntax {
+	const char *name;
+	ldb_attr_handler_t read_fn;
+	ldb_attr_handler_t write_clear_fn;
+	ldb_attr_handler_t write_hex_fn;
+};
+
+const struct ldb_dn_extended_syntax *ldb_dn_extended_syntax_by_name(struct ldb_context *ldb,
+								    const char *name);
+
 /**
    The attribute is not returned by default
 */
@@ -789,6 +795,7 @@ int ldb_set_timeout(struct ldb_context *ldb, struct ldb_request *req, int timeou
 int ldb_set_timeout_from_prev_req(struct ldb_context *ldb, struct ldb_request *oldreq, struct ldb_request *newreq);
 void ldb_set_create_perms(struct ldb_context *ldb, unsigned int perms);
 void ldb_set_modules_dir(struct ldb_context *ldb, const char *path);
+struct event_context;
 void ldb_set_event_context(struct ldb_context *ldb, struct event_context *ev);
 struct event_context * ldb_get_event_context(struct ldb_context *ldb);
 
@@ -1068,6 +1075,15 @@ int ldb_request_add_control(struct ldb_request *req, const char *oid, bool criti
 struct ldb_control *ldb_request_get_control(struct ldb_request *req, const char *oid);
 
 /**
+   check if a control with the specified "oid" exist and return it 
+  \param rep the reply struct where to add the control
+  \param oid the object identifier of the control as string
+
+  \return the control, NULL if not found 
+*/
+struct ldb_control *ldb_reply_get_control(struct ldb_reply *rep, const char *oid);
+
+/**
   Search the database
 
   This function searches the database, and returns 
@@ -1423,15 +1439,82 @@ int ldb_base64_decode(char *s);
 
 /* The following definitions come from lib/ldb/common/ldb_dn.c  */
 
+/**
+  Get the linear form of a DN (without any extended components)
+  
+  \param dn The DN to linearize
+*/
+
+const char *ldb_dn_get_linearized(struct ldb_dn *dn);
+
+/**
+  Allocate a copy of the linear form of a DN (without any extended components) onto the supplied memory context 
+  
+  \param dn The DN to linearize
+  \param mem_ctx TALLOC context to return result on
+*/
+
+char *ldb_dn_alloc_linearized(TALLOC_CTX *mem_ctx, struct ldb_dn *dn);
+
+/**
+  Get the linear form of a DN (with any extended components)
+  
+  \param mem_ctx TALLOC context to return result on
+  \param dn The DN to linearize
+  \param mode Style of extended DN to return (0 is HEX representation of binary form, 1 is a string form)
+*/
+char *ldb_dn_get_extended_linearized(void *mem_ctx, struct ldb_dn *dn, int mode);
+const struct ldb_val *ldb_dn_get_extended_component(struct ldb_dn *dn, const char *name);
+int ldb_dn_set_extended_component(struct ldb_dn *dn, const char *name, const struct ldb_val *val);
+
+void ldb_dn_remove_extended_components(struct ldb_dn *dn);
+bool ldb_dn_has_extended(struct ldb_dn *dn);
+
+int ldb_dn_extended_add_syntax(struct ldb_context *ldb, 
+			       unsigned flags,
+			       const struct ldb_dn_extended_syntax *syntax);
+
+/** 
+  Allocate a new DN from a string
+
+  \param mem_ctx TALLOC context to return resulting ldb_dn structure on
+  \param dn The new DN 
+
+  \note The DN will not be parsed at this time.  Use ldb_dn_validate to tell if the DN is syntacticly correct
+*/
+
 struct ldb_dn *ldb_dn_new(TALLOC_CTX *mem_ctx, struct ldb_context *ldb, const char *dn);
+/** 
+  Allocate a new DN from a printf style format string and arguments
+
+  \param mem_ctx TALLOC context to return resulting ldb_dn structure on
+  \param new_fms The new DN as a format string (plus arguments)
+
+  \note The DN will not be parsed at this time.  Use ldb_dn_validate to tell if the DN is syntacticly correct
+*/
+
 struct ldb_dn *ldb_dn_new_fmt(TALLOC_CTX *mem_ctx, struct ldb_context *ldb, const char *new_fmt, ...) PRINTF_ATTRIBUTE(3,4);
+/** 
+  Allocate a new DN from a struct ldb_val (useful to avoid buffer overrun)
+
+  \param mem_ctx TALLOC context to return resulting ldb_dn structure on
+  \param dn The new DN 
+
+  \note The DN will not be parsed at this time.  Use ldb_dn_validate to tell if the DN is syntacticly correct
+*/
+
 struct ldb_dn *ldb_dn_from_ldb_val(void *mem_ctx, struct ldb_context *ldb, const struct ldb_val *strdn);
+
+/**
+  Determine if this DN is syntactically valid 
+
+  \param dn The DN to validate
+*/
+
 bool ldb_dn_validate(struct ldb_dn *dn);
 
 char *ldb_dn_escape_value(TALLOC_CTX *mem_ctx, struct ldb_val value);
-const char *ldb_dn_get_linearized(struct ldb_dn *dn);
 const char *ldb_dn_get_casefold(struct ldb_dn *dn);
-char *ldb_dn_alloc_linearized(TALLOC_CTX *mem_ctx, struct ldb_dn *dn);
 char *ldb_dn_alloc_casefold(TALLOC_CTX *mem_ctx, struct ldb_dn *dn);
 
 int ldb_dn_compare_base(struct ldb_dn *base, struct ldb_dn *dn);
diff --git a/ldb/include/ldb_private.h b/ldb/include/ldb_private.h
index a92549d9c..c06528827 100644
--- a/ldb/include/ldb_private.h
+++ b/ldb/include/ldb_private.h
@@ -84,6 +84,9 @@ struct ldb_schema {
 	/* attribute handling table */
 	unsigned num_attributes;
 	struct ldb_schema_attribute *attributes;
+
+	unsigned num_dn_extended_syntax;
+	struct ldb_dn_extended_syntax *dn_extended_syntax;
 };
 
 /*
@@ -211,6 +214,10 @@ char *ldb_casefold_default(void *context, void *mem_ctx, const char *s, size_t n
 
 void ldb_msg_remove_element(struct ldb_message *msg, struct ldb_message_element *el);
 
+int ldb_msg_element_compare_name(struct ldb_message_element *el1, 
+				 struct ldb_message_element *el2);
+void ldb_dump_results(struct ldb_context *ldb, struct ldb_result *result, FILE *f);
+
 /**
   Obtain current/next database sequence number
 */
@@ -255,13 +262,11 @@ const char *ldb_default_modules_dir(void);
 
 int ldb_register_backend(const char *url_prefix, ldb_connect_fn);
 
-void *ldb_dso_load_symbol(struct ldb_context *ldb, const char *name,
-			    const char *symbol);
-
 struct ldb_handle *ldb_handle_new(TALLOC_CTX *mem_ctx, struct ldb_context *ldb);
 
 int ldb_module_send_entry(struct ldb_request *req,
-			  struct ldb_message *msg);
+			  struct ldb_message *msg,
+			  struct ldb_control **ctrls);
 
 int ldb_module_send_referral(struct ldb_request *req,
 					   char *ref);
@@ -273,4 +278,7 @@ int ldb_module_done(struct ldb_request *req,
 
 int ldb_mod_register_control(struct ldb_module *module, const char *oid);
 
+
+struct ldb_val ldb_binary_decode(void *mem_ctx, const char *str);
+
 #endif
diff --git a/ldb/ldb.i b/ldb/ldb.i
deleted file mode 100644
index 601346222..000000000
--- a/ldb/ldb.i
+++ /dev/null
@@ -1,1286 +0,0 @@
-/*
-   Unix SMB/CIFS implementation.
-
-   Swig interface to ldb.
-
-   Copyright (C) 2005,2006 Tim Potter <tpot@samba.org>
-   Copyright (C) 2006 Simo Sorce <idra@samba.org>
-   Copyright (C) 2007-2008 Jelmer Vernooij <jelmer@samba.org>
-
-     ** NOTE! The following LGPL license applies to the ldb
-     ** library. This does NOT imply that all of Samba is released
-     ** under the LGPL
-   
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 3 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-%define DOCSTRING
-"An interface to LDB, a LDAP-like API that can either to talk an embedded database (TDB-based) or a standards-compliant LDAP server."
-%enddef
-
-%module(docstring=DOCSTRING) ldb
-
-%{
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "talloc.h"
-#include "events.h"
-#include "ldb.h"
-#include "ldb_errors.h"
-#include "ldb_private.h"
-
-typedef struct ldb_message ldb_msg;
-typedef struct ldb_context ldb;
-typedef struct ldb_dn ldb_dn;
-typedef struct ldb_ldif ldb_ldif;
-typedef struct ldb_message_element ldb_message_element;
-typedef struct ldb_module ldb_module;
-typedef int ldb_error;
-typedef int ldb_int_error;
-
-%}
-
-%import "carrays.i"
-%import "typemaps.i"
-%include "exception.i"
-%import "stdint.i"
-
-/* Don't expose talloc contexts in Python code. Python does reference 
-   counting for us, so just create a new top-level talloc context.
- */
-%typemap(in, numinputs=0, noblock=1) TALLOC_CTX * {
-    $1 = NULL;
-}
-
-
-
-%constant int SCOPE_DEFAULT = LDB_SCOPE_DEFAULT;
-%constant int SCOPE_BASE = LDB_SCOPE_BASE;
-%constant int SCOPE_ONELEVEL = LDB_SCOPE_ONELEVEL;
-%constant int SCOPE_SUBTREE = LDB_SCOPE_SUBTREE;
-
-%constant int CHANGETYPE_NONE = LDB_CHANGETYPE_NONE;
-%constant int CHANGETYPE_ADD = LDB_CHANGETYPE_ADD;
-%constant int CHANGETYPE_DELETE = LDB_CHANGETYPE_DELETE;
-%constant int CHANGETYPE_MODIFY = LDB_CHANGETYPE_MODIFY;
-
-/* 
- * Wrap struct ldb_context
- */
-
-/* The ldb functions will crash if a NULL ldb context is passed so
-   catch this before it happens. */
-
-%typemap(check,noblock=1) struct ldb_context* {
-	if ($1 == NULL)
-		SWIG_exception(SWIG_ValueError, 
-			"ldb context must be non-NULL");
-}
-
-%typemap(check,noblock=1) ldb_msg * {
-	if ($1 == NULL)
-		SWIG_exception(SWIG_ValueError, 
-			"Message can not be None");
-}
-
-/*
- * Wrap struct ldb_val
- */
-
-%typemap(in,noblock=1) struct ldb_val *INPUT (struct ldb_val temp) {
-	$1 = &temp;
-	if (!PyString_Check($input)) {
-		PyErr_SetString(PyExc_TypeError, "string arg expected");
-		return NULL;
-	}
-	$1->length = PyString_Size($input);
-	$1->data = PyString_AsString($input);
-}
-
-%inline %{
-PyObject *ldb_val_to_py_object(struct ldb_context *ldb_ctx, 
-                               struct ldb_message_element *el, 
-                               struct ldb_val *val)
-{
-        const struct ldb_schema_attribute *a;
-        struct ldb_val new_val;
-        TALLOC_CTX *mem_ctx = talloc_new(NULL);
-        PyObject *ret;
-        
-        new_val = *val;
-        
-        if (ldb_ctx != NULL) {        
-        	a = ldb_schema_attribute_by_name(ldb_ctx, el->name);
-        
-        	if (a != NULL) {
-        		if (a->syntax->ldif_write_fn(ldb_ctx, mem_ctx, val, &new_val) != 0) {
-        			talloc_free(mem_ctx);
-        			return NULL;
-        		}
-        	}
-        } 
-        
-	ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
-	
-	talloc_free(mem_ctx);
-	
-	return ret;
-}
-
-%}
-
-%typemap(out,noblock=1) struct ldb_val * {
-	$result = PyString_FromStringAndSize((const char *)$1->data, $1->length)
-}
-
-%typemap(out,noblock=1) struct ldb_val {
-	$result = PyString_FromStringAndSize((const char *)$1.data, $1.length)
-}
-
-/*
- * Wrap struct ldb_result
- */
-
-%typemap(in,noblock=1,numinputs=0) struct ldb_result ** (struct ldb_result *temp_ldb_result) {
-	$1 = &temp_ldb_result;
-}
-
-#ifdef SWIGPYTHON
-%typemap(argout,noblock=1) struct ldb_result ** (int i) {
-    if ($1 == NULL) {
-        $result = Py_None;
-    } else {
-        $result = PyList_New((*$1)->count);
-        for (i = 0; i < (*$1)->count; i++) {
-            PyList_SetItem($result, i, 
-                SWIG_NewPointerObj((*$1)->msgs[i], SWIGTYPE_p_ldb_message, 0)
-            );
-        }
-    }
-}
-
-%typemap(in,noblock=1,numinputs=1) const char * const *NULL_STR_LIST {
-    if ($input == Py_None) {
-        $1 = NULL;
-    } else if (PySequence_Check($input)) {
-        int i;
-        $1 = talloc_array(NULL, char *, PySequence_Size($input)+1);
-        for(i = 0; i < PySequence_Size($input); i++)
-            $1[i] = PyString_AsString(PySequence_GetItem($input, i));
-        $1[i] = NULL;
-    } else {
-        SWIG_exception(SWIG_TypeError, "expected sequence");
-    }
-}
-
-%typemap(freearg,noblock=1) const char * const *NULL_STR_LIST {
-    talloc_free($1);
-}
-
-%apply const char * const *NULL_STR_LIST { const char * const *attrs }
-%apply const char * const *NULL_STR_LIST { const char * const *control_strings }
-
-#endif
-
-%types(struct ldb_result *, struct ldb_parse_tree *);
-
-/*
- * Wrap struct ldb_dn
- */
-
-%rename(__str__) ldb_dn::get_linearized;
-%rename(__cmp__) ldb_dn::compare;
-%rename(__len__) ldb_dn::get_comp_num;
-%rename(Dn) ldb_dn;
-%feature("docstring") ldb_dn "A LDB distinguished name.";
-typedef struct ldb_dn {
-    %extend {
-        %feature("docstring") ldb_dn "S.__init__(ldb, string)\n" \
-                 "Create a new DN.";
-        ldb_dn(ldb *ldb_ctx, const char *str)
-        {
-            ldb_dn *ret = ldb_dn_new(ldb_ctx, ldb_ctx, str);
-            /* ldb_dn_new() doesn't accept NULL as memory context, so 
-               we do it this way... */
-            talloc_steal(NULL, ret);
-
-            if (ret == NULL)
-                SWIG_exception(SWIG_ValueError, 
-                                "unable to parse dn string");
-fail:
-            return ret;
-        }
-        ~ldb_dn() { talloc_free($self); }
-        %feature("docstring") validate "S.validate() -> bool\n" \
-                                       "Validate DN is correct.";
-        bool validate();
-        const char *get_casefold();
-        const char *get_linearized();
-        %feature("docstring") parent "S.parent() -> dn\n" \
-                                     "Get the parent for this DN.";
-        ldb_dn *parent() { return ldb_dn_get_parent(NULL, $self); }
-        int compare(ldb_dn *other);
-        bool is_valid();
-        %feature("docstring") is_special "S.is_special() -> bool\n" \
-                                         "Check whether this is a special LDB DN.";
-        bool is_special();
-        %feature("docstring") is_null "S.is_null() -> bool\n" \
-                                         "Check whether this is a null DN.";
-        bool is_null();
-        bool check_special(const char *name);
-        int get_comp_num();
-        %feature("docstring") add_child "S.add_child(dn) -> None\n" \
-                                         "Add a child DN to this DN.";
-        bool add_child(ldb_dn *child);
-        %feature("docstring") add_base "S.add_base(dn) -> None\n" \
-                                         "Add a base DN to this DN.";
-        bool add_base(ldb_dn *base);
-        %feature("docstring") canonical_str "S.canonical_str() -> string\n" \
-                                         "Canonical version of this DN (like a posix path).";
-        const char *canonical_str() {
-            return ldb_dn_canonical_string($self, $self);
-        }
-        %feature("docstring") canonical_ex_str "S.canonical_ex_str() -> string\n" \
-                                               "Canonical version of this DN (like a posix path, with terminating newline).";
-        const char *canonical_ex_str() {
-            return ldb_dn_canonical_ex_string($self, $self);
-        }
-#ifdef SWIGPYTHON
-        char *__repr__(void)
-        {
-            char *dn = ldb_dn_get_linearized($self), *ret;
-            asprintf(&ret, "Dn('%s')", dn);
-            talloc_free(dn);
-            return ret;
-        }
-
-        ldb_dn *__add__(ldb_dn *other)
-        {
-            ldb_dn *ret = ldb_dn_copy(NULL, $self);
-            ldb_dn_add_child(ret, other);
-            return ret;
-        }
-
-        /* FIXME: implement __getslice__ */
-#endif
-    %pythoncode {
-        def __eq__(self, other):
-            if isinstance(other, self.__class__):
-                return self.__cmp__(other) == 0
-            if isinstance(other, str):
-                return str(self) == other
-            return False
-    }
-    }
-} ldb_dn;
-
-#ifdef SWIGPYTHON
-%{
-struct ldb_context *ldb_context_from_py_object(PyObject *py_obj)
-{
-        struct ldb_context *ldb_ctx;
-    if (SWIG_ConvertPtr(py_obj, (void *)&ldb_ctx, SWIGTYPE_p_ldb_context, 0 |  0 ) < 0)
-        return NULL;
-    return ldb_ctx;
-}
-
-int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object, 
-                         struct ldb_context *ldb_ctx, ldb_dn **dn)
-{
-    int ret;
-    struct ldb_dn *odn;
-    if (ldb_ctx != NULL && PyString_Check(object)) {
-        odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
-	if (!odn) {
-		return SWIG_ERROR;
-	}
-	*dn = odn;
-        return 0;
-    }
-    ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn, 
-                           SWIG_POINTER_EXCEPTION);
-    *dn = ldb_dn_copy(mem_ctx, odn);
-    if (odn && !*dn) {
- 	return SWIG_ERROR;
-    }
-    return ret;
-}
-
-ldb_message_element *ldb_msg_element_from_pyobject(TALLOC_CTX *mem_ctx,
-                                               PyObject *set_obj, int flags,
-                                               const char *attr_name)
-{
-    struct ldb_message_element *me = talloc(mem_ctx, struct ldb_message_element);
-    me->name = attr_name;
-    me->flags = flags;
-    if (PyString_Check(set_obj)) {
-        me->num_values = 1;
-        me->values = talloc_array(me, struct ldb_val, me->num_values);
-        me->values[0].length = PyString_Size(set_obj);
-        me->values[0].data = (uint8_t *)talloc_strdup(me->values, 
-                                           PyString_AsString(set_obj));
-    } else if (PySequence_Check(set_obj)) {
-        int i;
-        me->num_values = PySequence_Size(set_obj);
-        me->values = talloc_array(me, struct ldb_val, me->num_values);
-        for (i = 0; i < me->num_values; i++) {
-            PyObject *obj = PySequence_GetItem(set_obj, i);
-            me->values[i].length = PyString_Size(obj);
-            me->values[i].data = (uint8_t *)PyString_AsString(obj);
-        }
-    } else {
-        talloc_free(me);
-        me = NULL;
-    }
-
-    return me;
-}
-
-PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx, 
-                                 ldb_message_element *me)
-{
-    int i;
-    PyObject *result;
-
-    /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
-    result = PyList_New(me->num_values);
-
-    for (i = 0; i < me->num_values; i++) {
-        PyList_SetItem(result, i,
-            ldb_val_to_py_object(ldb_ctx, me, &me->values[i]));
-    }
-
-    return result;
-}
-
-%}
-#endif
-
-/* ldb_message_element */
-%rename(MessageElement) ldb_message_element;
-%feature("docstring") ldb_message_element "Message element.";
-typedef struct ldb_message_element {
-    %extend {
-#ifdef SWIGPYTHON
-        int __cmp__(ldb_message_element *other)
-        {
-            return ldb_msg_element_compare($self, other);
-        }
-
-        PyObject *__iter__(void)
-        {
-            return PyObject_GetIter(ldb_msg_element_to_set(NULL, $self));
-        }
-
-        PyObject *__set__(void)
-        {
-            return ldb_msg_element_to_set(NULL, $self);
-        }
-
-        ldb_message_element(PyObject *set_obj, int flags=0, const char *name = NULL)
-        {
-            return ldb_msg_element_from_pyobject(NULL, set_obj, flags, name);
-        }
-
-        int __len__()
-        {
-            return $self->num_values;
-        }
-#endif
-
-        PyObject *get(int i)
-        {
-            if (i < 0 || i >= $self->num_values)
-                return Py_None;
-
-            return ldb_val_to_py_object(NULL, $self, &$self->values[i]);
-        }
-
-        ~ldb_message_element() { talloc_free($self); }
-    }
-    %pythoncode {
-        def __getitem__(self, i):
-            ret = self.get(i)
-            if ret is None:
-                raise KeyError("no such value")
-            return ret
-
-        def __repr__(self):
-            return "MessageElement([%s])" % (",".join(repr(x) for x in self.__set__()))
-
-        def __eq__(self, other):
-            if (len(self) == 1 and self.get(0) == other):
-                return True
-            if isinstance(other, self.__class__):
-                return self.__cmp__(other) == 0
-            o = iter(other)
-            for i in range(len(self)):
-                if self.get(i) != o.next():
-                    return False
-            return True
-    }
-} ldb_message_element;
-
-/* ldb_message */
-
-%feature("docstring") ldb_message "Message.";
-%rename(Message) ldb_message;
-#ifdef SWIGPYTHON
-%rename(__delitem__) ldb_message::remove_attr;
-%typemap(out) ldb_message_element * {
-	if ($1 == NULL)
-		PyErr_SetString(PyExc_KeyError, "no such element");
-    else
-        $result = SWIG_NewPointerObj($1, SWIGTYPE_p_ldb_message_element, 0);
-}
-
-%inline {
-    PyObject *ldb_msg_list_elements(ldb_msg *msg)
-    {
-        int i, j = 0;
-        PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
-        if (msg->dn != NULL) {
-            PyList_SetItem(obj, j, PyString_FromString("dn"));
-            j++;
-        }
-        for (i = 0; i < msg->num_elements; i++) {
-            PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
-            j++;
-        }
-        return obj;
-    }
-}
-
-#endif
-
-typedef struct ldb_message {
-	ldb_dn *dn;
-
-    %extend {
-        ldb_msg(ldb_dn *dn = NULL) { 
-            ldb_msg *ret = ldb_msg_new(NULL); 
-            ret->dn = talloc_reference(ret, dn);
-            return ret;
-        }
-        ~ldb_msg() { talloc_free($self); }
-        ldb_message_element *find_element(const char *name);
-        
-#ifdef SWIGPYTHON
-        void __setitem__(const char *attr_name, ldb_message_element *val)
-        {
-            struct ldb_message_element *el;
-            
-            ldb_msg_remove_attr($self, attr_name);
-
-            el = talloc($self, struct ldb_message_element);
-            el->name = talloc_strdup(el, attr_name);
-            el->num_values = val->num_values;
-            el->values = talloc_reference(el, val->values);
-
-            ldb_msg_add($self, el, val->flags);
-        }
-
-        void __setitem__(const char *attr_name, PyObject *val)
-        {
-            struct ldb_message_element *el = ldb_msg_element_from_pyobject(NULL,
-                                                val, 0, attr_name);
-            talloc_steal($self, el);
-            ldb_msg_remove_attr($self, attr_name);
-            ldb_msg_add($self, el, el->flags);
-        }
-
-        unsigned int __len__() { return $self->num_elements; }
-
-        PyObject *keys(void)
-        {
-            return ldb_msg_list_elements($self);
-        }
-
-        PyObject *__iter__(void)
-        {
-            return PyObject_GetIter(ldb_msg_list_elements($self));
-        }
-#endif
-        void remove_attr(const char *name);
-%pythoncode {
-    def get(self, key, default=None):
-        if key == "dn":
-            return self.dn
-        return self.find_element(key)
-
-    def __getitem__(self, key):
-        ret = self.get(key, None)
-        if ret is None:
-            raise KeyError("No such element")
-        return ret
-
-    def iteritems(self):
-        for k in self.keys():
-            yield k, self[k]
-    
-    def items(self):
-        return list(self.iteritems())
-
-    def __repr__(self):
-        return "Message(%s)" % repr(dict(self.iteritems()))
-}
-    }
-} ldb_msg;
-
-/* FIXME: Convert ldb_result to 3-tuple:
-   (msgs, refs, controls)
- */
-
-typedef struct ldb_ldif ldb_ldif;
-
-#ifdef SWIGPYTHON
-%{
-static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
-
-static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
-{
-    char *text;
-    PyObject *fn = context;
-
-    vasprintf(&text, fmt, ap);
-    PyObject_CallFunction(fn, (char *)"(i,s)", level, text);
-    free(text);
-}
-%}
-
-%typemap(in,numinputs=1,noblock=1) (void (*debug)(void *context, enum ldb_debug_level level, const char *fmt, va_list ap), void *context) {
-    $1 = py_ldb_debug;
-    /* FIXME: Should be decreased somewhere as well. Perhaps register a 
-       destructor and tie it to the ldb context ? */
-    Py_INCREF($input);
-    $2 = $input;
-}
-#endif
-
-%inline {
-    static PyObject *ldb_ldif_to_pyobject(ldb_ldif *ldif)
-    {
-        if (ldif == NULL) {
-            return Py_None;
-        } else {
-            return Py_BuildValue((char *)"(iO)", ldif->changetype, 
-                   SWIG_NewPointerObj(ldif->msg, SWIGTYPE_p_ldb_message, 0));
-        }
-    }
-}
-
-/*
- * Wrap ldb errors
- */
-
-%{
-PyObject *PyExc_LdbError;
-%}
-
-%pythoncode %{
-    LdbError = _ldb.LdbError
-%}
-
-%init %{
-    PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
-    PyDict_SetItemString(d, "LdbError", PyExc_LdbError);
-%}
-
-%ignore _LDB_ERRORS_H_;
-%ignore LDB_SUCCESS;
-%include "include/ldb_errors.h"
-
-/*
- * Wrap ldb functions 
- */
-
-
-%typemap(out,noblock=1) ldb_error {
-    if ($1 != LDB_SUCCESS) {
-        PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", $1, ldb_errstring(arg1)));
-        SWIG_fail;
-    }
-    $result = Py_None;
-};
-
-%typemap(out,noblock=1) ldb_int_error {
-    if ($1 != LDB_SUCCESS) {
-        PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", $1, ldb_strerror($1)));
-        SWIG_fail;
-    }
-    $result = Py_None;
-};
-
-%typemap(out,noblock=1) struct ldb_control ** {
-    if ($1 == NULL) {
-        PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(s)", ldb_errstring(arg1)));
-        SWIG_fail;
-    }
-    $result = SWIG_NewPointerObj($1, $1_descriptor, 0);
-}
-
-%rename(Ldb) ldb_context;
-%feature("docstring") ldb_context "Connection to a LDB database.";
-
-%typemap(in,noblock=1) struct ldb_dn * {
-    if (ldb_dn_from_pyobject(NULL, $input, arg1, &$1) != 0) {
-        SWIG_fail;
-    }
-};
-
-%typemap(freearg,noblock=1) struct ldb_dn * {
-    talloc_free($1);
-};
-
-%typemap(in,numinputs=1) ldb_msg *add_msg {
-    Py_ssize_t dict_pos, msg_pos;
-    ldb_message_element *msgel;
-    PyObject *key, *value;
-
-    if (PyDict_Check($input)) {
- 	PyObject *dn_value = PyDict_GetItemString($input, "dn");
-        $1 = ldb_msg_new(NULL);
-        $1->elements = talloc_zero_array($1, struct ldb_message_element, PyDict_Size($input));
-        msg_pos = dict_pos = 0;
-	if (dn_value) {
-                /* using argp1 (magic SWIG value) here is a hack */
-                if (ldb_dn_from_pyobject($1, dn_value, argp1, &$1->dn) != 0) {
-                    SWIG_exception(SWIG_TypeError, "unable to import dn object");
-                }
-		if ($1->dn == NULL) {
-		    SWIG_exception(SWIG_TypeError, "dn set but not found");
-		}
-	}
-
-	while (PyDict_Next($input, &dict_pos, &key, &value)) {
-	    char *key_str = PyString_AsString(key);
-            if (strcmp(key_str, "dn") != 0) {
-                msgel = ldb_msg_element_from_pyobject($1->elements, value, 0, key_str);
-                if (msgel == NULL) {
-                    SWIG_exception(SWIG_TypeError, "unable to import element");
-                }
-                memcpy(&$1->elements[msg_pos], msgel, sizeof(*msgel));
-                msg_pos++;
-            }
-        }
-
-        if ($1->dn == NULL) {
-            SWIG_exception(SWIG_TypeError, "no dn set");
-        }
-
-        $1->num_elements = msg_pos;
-    } else {
-        if (SWIG_ConvertPtr($input, (void **)&$1, SWIGTYPE_p_ldb_message, 0) != 0) {
-            SWIG_exception(SWIG_TypeError, "unable to convert ldb message");
-        }
-    }
-}
-
-/* Top-level ldb operations */
-typedef struct ldb_context {
-    %rename(firstmodule) modules;
-    struct ldb_module *modules;
-
-    %pythoncode {
-        def itermodules(self):
-            m = self.firstmodule
-            while m is not None:
-                yield m
-                m = m.next
-
-        def modules(self):
-            return list(self.itermodules())
-    }
-
-    %extend {
-        ldb(void) { 
-            return ldb_init(NULL, event_context_init(NULL)); 
-        }
-
-        %feature("docstring") connect "S.connect(url,flags=0,options=None) -> None\n" \
-                                      "Connect to a LDB URL.";
-        ldb_error connect(const char *url, unsigned int flags = 0, 
-            const char *options[] = NULL);
-
-        ~ldb() { talloc_free($self); }
-        ldb_error search_ex(TALLOC_CTX *mem_ctx,
-                   ldb_dn *base = NULL, 
-                   enum ldb_scope scope = LDB_SCOPE_DEFAULT, 
-                   const char *expression = NULL, 
-                   const char *const *attrs = NULL, 
-                   struct ldb_control **controls = NULL,
-                   struct ldb_result **OUT) {
-            int ret;
-            struct ldb_result *res;
-            struct ldb_request *req;
-            res = talloc_zero(mem_ctx, struct ldb_result);
-            if (!res) {
-                return LDB_ERR_OPERATIONS_ERROR;
-            }
-
-            ret = ldb_build_search_req(&req, $self, mem_ctx,
-                           base?base:ldb_get_default_basedn($self),
-                           scope,
-                           expression,
-                           attrs,
-                           controls,
-                           res,
-                           ldb_search_default_callback,
-                           NULL);
-
-            if (ret != LDB_SUCCESS) {
-                talloc_free(res);
-                return ret;
-            }
-
-            ret = ldb_request($self, req);
-                
-            if (ret == LDB_SUCCESS) {
-                ret = ldb_wait(req->handle, LDB_WAIT_ALL);
-            }
-
-            talloc_free(req);
-
-            *OUT = res;
-            return ret;
-        }
-
-        %feature("docstring") delete "S.delete(dn) -> None\n" \
-                                     "Remove an entry.";
-        ldb_error delete(ldb_dn *dn);
-        %feature("docstring") rename "S.rename(old_dn, new_dn) -> None\n" \
-                                     "Rename an entry.";
-        ldb_error rename(ldb_dn *olddn, ldb_dn *newdn);
-        struct ldb_control **parse_control_strings(TALLOC_CTX *mem_ctx, 
-                                                   const char * const*control_strings);
-        %feature("docstring") add "S.add(message) -> None\n" \
-                                  "Add an entry.";
-        ldb_error add(ldb_msg *add_msg);
-        %feature("docstring") modify "S.modify(message) -> None\n" \
-                                  "Modify an entry.";
-        ldb_error modify(ldb_msg *message);
-        ldb_dn *get_config_basedn();
-        ldb_dn *get_root_basedn();
-        ldb_dn *get_schema_basedn();
-        ldb_dn *get_default_basedn();
-        PyObject *schema_format_value(const char *element_name, PyObject *val)
-        {
-        	const struct ldb_schema_attribute *a;
-        	struct ldb_val old_val;
-        	struct ldb_val new_val;
-        	TALLOC_CTX *mem_ctx = talloc_new(NULL);
-        	PyObject *ret;
-        	
-        	old_val.data = PyString_AsString(val);
-        	old_val.length = PyString_Size(val);
-                
-        	a = ldb_schema_attribute_by_name($self, element_name);
-        
-        	if (a == NULL) {
-        		return Py_None;
-        	}
-        	
-        	if (a->syntax->ldif_write_fn($self, mem_ctx, &old_val, &new_val) != 0) {
-        		talloc_free(mem_ctx);
-        		return Py_None;
-        	 }
-        
-		ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
-		
-		talloc_free(mem_ctx);
-		
-		return ret;
-        }
-
-        const char *errstring();
-        %feature("docstring") set_create_perms "S.set_create_perms(mode) -> None\n" \
-                                               "Set mode to use when creating new LDB files.";
-        void set_create_perms(unsigned int perms);
-        %feature("docstring") set_modules_dir "S.set_modules_dir(path) -> None\n" \
-                                              "Set path LDB should search for modules";
-        void set_modules_dir(const char *path);
-        %feature("docstring") set_debug "S.set_debug(callback) -> None\n" \
-                                        "Set callback for LDB debug messages.\n" \
-                                        "The callback should accept a debug level and debug text.";
-        ldb_error set_debug(void (*debug)(void *context, enum ldb_debug_level level, 
-                                          const char *fmt, va_list ap),
-                            void *context);
-        %feature("docstring") set_opaque "S.set_opaque(name, value) -> None\n" \
-            "Set an opaque value on this LDB connection. \n"
-            ":note: Passing incorrect values may cause crashes.";
-        ldb_error set_opaque(const char *name, void *value);
-        %feature("docstring") get_opaque "S.get_opaque(name) -> value\n" \
-            "Get an opaque value set on this LDB connection. \n"
-            ":note: The returned value may not be useful in Python.";
-        void *get_opaque(const char *name);
-        %feature("docstring") transaction_start "S.transaction_start() -> None\n" \
-                                                "Start a new transaction.";
-        ldb_error transaction_start();
-        %feature("docstring") transaction_commit "S.transaction_commit() -> None\n" \
-                                                 "Commit currently active transaction.";
-        ldb_error transaction_commit();
-        %feature("docstring") transaction_cancel "S.transaction_cancel() -> None\n" \
-                                                 "Cancel currently active transaction.";
-        ldb_error transaction_cancel();
-        void schema_attribute_remove(const char *name);
-        ldb_error schema_attribute_add(const char *attribute, unsigned flags, const char *syntax);
-        ldb_error setup_wellknown_attributes(void);
- 
-#ifdef SWIGPYTHON
-        %typemap(in,numinputs=0,noblock=1) struct ldb_result **result_as_bool (struct ldb_result *tmp) { $1 = &tmp; }
-        %typemap(argout,noblock=1) struct ldb_result **result_as_bool { $result = ((*$1)->count > 0)?Py_True:Py_False; }
-        %typemap(freearg,noblock=1) struct ldb_result **result_as_bool { talloc_free(*$1); }
-        ldb_error __contains__(ldb_dn *dn, struct ldb_result **result_as_bool)
-        {
-            return ldb_search($self, $self, result_as_bool, dn, LDB_SCOPE_BASE, NULL, NULL);
-        }
-
-        %feature("docstring") parse_ldif "S.parse_ldif(ldif) -> iter(messages)\n" \
-            "Parse a string formatted using LDIF.";
-
-        PyObject *parse_ldif(const char *s)
-        {
-            PyObject *list = PyList_New(0);
-            struct ldb_ldif *ldif;
-            while ((ldif = ldb_ldif_read_string($self, &s)) != NULL) {
-                PyList_Append(list, ldb_ldif_to_pyobject(ldif));
-            }
-            return PyObject_GetIter(list);
-        }
-
-        char *__repr__(void)
-        {
-            char *ret;
-            asprintf(&ret, "<ldb connection at 0x%x>", ret); 
-            return ret;
-        }
-#endif
-    }
-    %pythoncode {
-        def __init__(self, url=None, flags=0, options=None):
-            """Create a new LDB object.
-
-            Will also connect to the specified URL if one was given.
-            """
-            _ldb.Ldb_swiginit(self,_ldb.new_Ldb())
-            if url is not None:
-                self.connect(url, flags, options)
-
-        def search(self, base=None, scope=SCOPE_DEFAULT, expression=None, 
-                   attrs=None, controls=None):
-            """Search in a database.
-
-            :param base: Optional base DN to search
-            :param scope: Search scope (SCOPE_BASE, SCOPE_ONELEVEL or SCOPE_SUBTREE)
-            :param expression: Optional search expression
-            :param attrs: Attributes to return (defaults to all)
-            :param controls: Optional list of controls
-            :return: Iterator over Message objects
-            """
-            if not (attrs is None or isinstance(attrs, list)):
-                raise TypeError("attributes not a list")
-            parsed_controls = None
-            if controls is not None:
-                parsed_controls = self.parse_control_strings(controls)
-            return self.search_ex(base, scope, expression, attrs, 
-                                  parsed_controls)
-    }
-
-} ldb;
-
-%typemap(in,noblock=1) struct ldb_dn *;
-%typemap(freearg,noblock=1) struct ldb_dn *;
-
-%nodefault ldb_message;
-%nodefault ldb_context;
-%nodefault Dn;
-
-%rename(valid_attr_name) ldb_valid_attr_name;
-%feature("docstring") ldb_valid_attr_name "S.valid_attr_name(name) -> bool\n"
-                                          "Check whether the supplied name is a valid attribute name.";
-int ldb_valid_attr_name(const char *s);
-
-typedef unsigned long time_t;
-
-%feature("docstring") timestring "S.timestring(int) -> string\n"
-                                 "Generate a LDAP time string from a UNIX timestamp";
-
-%inline %{
-static char *timestring(time_t t)
-{
-    char *tresult = ldb_timestring(NULL, t);
-    char *result = strdup(tresult);
-    talloc_free(tresult);
-    return result; 
-}
-%}
-
-%rename(string_to_time) ldb_string_to_time;
-%feature("docstring") ldb_string_to_time "S.string_to_time(string) -> int\n"
-                                     "Parse a LDAP time string into a UNIX timestamp.";
-time_t ldb_string_to_time(const char *s);
-
-typedef struct ldb_module {
-    struct ldb_module *prev, *next;
-
-    %extend {
-#ifdef SWIGPYTHON
-        const char *__str__() {
-            return $self->ops->name;
-        }
-        char *__repr__() {
-            char *ret;
-            asprintf(&ret, "<ldb module '%s'>", $self->ops->name);
-            return ret;
-        }
-#endif
-        int search(struct ldb_dn *base, enum ldb_scope scope, struct ldb_parse_tree *tree, const char * const * attrs, struct ldb_result **res) {
-            int ret;
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-
-            req->operation = LDB_SEARCH;
-            req->op.search.base = base;
-            req->op.search.scope = scope;
-            req->op.search.tree = tree;
-            req->op.search.attrs = attrs;
-
-            req->op.search.res = talloc_zero(NULL, struct ldb_result);
-
-            ret = $self->ops->search($self, req);
-
-            *res = req->op.search.res;
-
-            talloc_free(req);
-
-            return ret;
-        }
-        ldb_error add(struct ldb_message *message) {
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-            req->operation = LDB_ADD;
-            req->op.add.message = message;
-            
-            return $self->ops->add($self, &req);
-        }
-        ldb_error modify(struct ldb_message *message) {
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-            req->operation = LDB_MODIFY;
-            req->op.mod.message = message;
-            
-            return $self->ops->modify($self, &req);
-        }
-        ldb_error delete(struct ldb_dn *dn) {
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-            req->operation = LDB_DELETE;
-            req->op.del.dn = dn;
-            
-            return $self->ops->del($self, &req);
-
-        }
-        ldb_error rename(struct ldb_dn *olddn, struct ldb_dn *newdn) {
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-            req->operation = LDB_RENAME;
-            req->op.rename.olddn = olddn;
-            req->op.rename.olddn = newdn;
-            
-            return $self->ops->rename($self, &req);
-        }
-        ldb_error start_transaction() {
-            return $self->ops->start_transaction($self);
-        }
-        ldb_error end_transaction() {
-            return $self->ops->end_transaction($self);
-        }
-        ldb_error del_transaction() {
-            return $self->ops->del_transaction($self);
-        }
-    }
-} ldb_module;
-
-%{
-int py_module_search(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_base, *py_attrs, *py_tree;
-
-    py_base = SWIG_NewPointerObj(req->op.search.base, SWIGTYPE_p_ldb_dn, 0);
-
-    if (py_base == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_tree = SWIG_NewPointerObj(req->op.search.tree, SWIGTYPE_p_ldb_parse_tree, 0);
-
-    if (py_tree == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    if (req->op.search.attrs == NULL) {
-        py_attrs = Py_None;
-    } else {
-        int i, len;
-        for (len = 0; req->op.search.attrs[len]; len++);
-        py_attrs = PyList_New(len);
-        for (i = 0; i < len; i++)
-            PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
-    }
-
-    py_result = PyObject_CallMethod(py_ldb, "search", "OiOO", py_base, req->op.search.scope, py_tree, py_attrs);
-
-    Py_DECREF(py_attrs);
-    Py_DECREF(py_tree);
-    Py_DECREF(py_base);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    if (SWIG_ConvertPtr(py_result, &req->op.search.res, SWIGTYPE_p_ldb_result, 0) != 0) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_add(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_msg;
-
-    py_msg = SWIG_NewPointerObj(req->op.add.message, SWIGTYPE_p_ldb_message, 0);
-
-    if (py_msg == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    py_result = PyObject_CallMethod(py_ldb, "add", "O", py_msg);
-
-    Py_DECREF(py_msg);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_msg;
-
-    py_msg = SWIG_NewPointerObj(req->op.mod.message, SWIGTYPE_p_ldb_message, 0);
-
-    if (py_msg == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    py_result = PyObject_CallMethod(py_ldb, "modify", "O", py_msg);
-
-    Py_DECREF(py_msg);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_del(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_dn;
-
-    py_dn = SWIG_NewPointerObj(req->op.del.dn, SWIGTYPE_p_ldb_dn, 0);
-
-    if (py_dn == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_result = PyObject_CallMethod(py_ldb, "delete", "O", py_dn);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_olddn, *py_newdn;
-
-    py_olddn = SWIG_NewPointerObj(req->op.rename.olddn, SWIGTYPE_p_ldb_dn, 0);
-
-    if (py_olddn == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_newdn = SWIG_NewPointerObj(req->op.rename.newdn, SWIGTYPE_p_ldb_dn, 0);
-
-    if (py_newdn == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_result = PyObject_CallMethod(py_ldb, "rename", "OO", py_olddn, py_newdn);
-
-    Py_DECREF(py_olddn);
-    Py_DECREF(py_newdn);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_request(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "request", "");
-
-    return LDB_ERR_OPERATIONS_ERROR;
-}
-
-int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "extended", "");
-
-    return LDB_ERR_OPERATIONS_ERROR;
-}
-
-int py_module_start_transaction(struct ldb_module *mod)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "start_transaction", "");
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_end_transaction(struct ldb_module *mod)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "end_transaction", "");
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_del_transaction(struct ldb_module *mod)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "del_transaction", "");
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-static int py_module_destructor(void *_mod)
-{
-    struct ldb_module *mod = _mod;
-    Py_DECREF((PyObject *)mod->private_data);
-    return 0;
-}
-
-int py_module_init (struct ldb_module *mod)
-{
-    PyObject *py_class = mod->ops->private_data;
-    PyObject *py_result, *py_next, *py_ldb;
-
-    py_ldb = SWIG_NewPointerObj(mod->ldb, SWIGTYPE_p_ldb_context, 0);
-
-    if (py_ldb == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_next = SWIG_NewPointerObj(mod->next, SWIGTYPE_p_ldb_module, 0);
-
-    if (py_next == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_result = PyObject_CallFunction(py_class, "OO", py_ldb, py_next);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    mod->private_data = py_result;
-
-    talloc_set_destructor (mod, py_module_destructor);
-
-    return ldb_next_init(mod);
-}
-%}
-
-%typemap(in,noblock=1) const struct ldb_module_ops * {
-    $1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
-
-    $1->name = talloc_strdup($1, PyString_AsString(PyObject_GetAttrString($input, (char *)"name")));
-
-    Py_INCREF($input);
-    $1->private_data = $input;
-    $1->init_context = py_module_init;
-    $1->search = py_module_search;
-    $1->add = py_module_add;
-    $1->modify = py_module_modify;
-    $1->del = py_module_del;
-    $1->rename = py_module_rename;
-    $1->request = py_module_request;
-    $1->extended = py_module_extended;
-    $1->start_transaction = py_module_start_transaction;
-    $1->end_transaction = py_module_end_transaction;
-    $1->del_transaction = py_module_del_transaction;
-}
-
-%feature("docstring") ldb_register_module "S.register_module(module) -> None\n"
-                                          "Register a LDB module.";
-%rename(register_module) ldb_register_module;
-ldb_int_error ldb_register_module(const struct ldb_module_ops *);
-
-%pythoncode {
-__docformat__ = "restructuredText"
-open = Ldb
-}
diff --git a/ldb/ldb.mk b/ldb/ldb.mk
index a7b1cb0c6..9d94434dc 100644
--- a/ldb/ldb.mk
+++ b/ldb/ldb.mk
@@ -62,25 +62,20 @@ examples/ldifreader: examples/ldifreader.o
 	$(CC) -o examples/ldifreader examples/ldifreader.o $(LIB_FLAGS)
 
 # Python bindings
-build-python:: _ldb.$(SHLIBEXT)
+build-python:: ldb.$(SHLIBEXT)
 
 ldb_wrap.o: $(ldbdir)/ldb_wrap.c
 	$(CC) $(PICFLAG) -c $(ldbdir)/ldb_wrap.c $(CFLAGS) `$(PYTHON_CONFIG) --cflags`
 	
-_ldb.$(SHLIBEXT): ldb_wrap.o
-	$(SHLD) $(SHLD_FLAGS) -o _ldb.$(SHLIBEXT) ldb_wrap.o $(LIB_FLAGS) `$(PYTHON_CONFIG) --ldflags`
+ldb.$(SHLIBEXT): ldb_wrap.o
+	$(SHLD) $(SHLD_FLAGS) -o ldb.$(SHLIBEXT) ldb_wrap.o $(LIB_FLAGS) `$(PYTHON_CONFIG) --ldflags`
 
 install-python:: build-python
-	mkdir -p $(DESTDIR)`$(PYTHON) -c "import distutils.sysconfig; print distutils.sysconfig.get_python_lib(0, prefix='$(prefix)')"` \
-		$(DESTDIR)`$(PYTHON) -c "import distutils.sysconfig; print distutils.sysconfig.get_python_lib(1, prefix='$(prefix)')"`
-	cp $(ldbdir)/ldb.py $(DESTDIR)`$(PYTHON) -c "import distutils.sysconfig; print distutils.sysconfig.get_python_lib(0, prefix='$(prefix)')"`
-	cp _ldb.$(SHLIBEXT) $(DESTDIR)`$(PYTHON) -c "import distutils.sysconfig; print distutils.sysconfig.get_python_lib(1, prefix='$(prefix)')"`
-
-install-swig::
-	cp ldb.i `$(SWIG) -swiglib`
+	mkdir -p $(DESTDIR)`$(PYTHON) -c "import distutils.sysconfig; print distutils.sysconfig.get_python_lib(1, prefix='$(prefix)')"`
+	cp ldb.$(SHLIBEXT) $(DESTDIR)`$(PYTHON) -c "import distutils.sysconfig; print distutils.sysconfig.get_python_lib(1, prefix='$(prefix)')"`
 
 check-python:: build-python
 	LD_LIBRARY_PATH=lib PYTHONPATH=.:$(ldbdir) $(PYTHON) $(ldbdir)/tests/python/api.py
 
 clean::
-	rm -f _ldb.$(SHLIBEXT)
+	rm -f ldb.$(SHLIBEXT)
diff --git a/ldb/ldb.py b/ldb/ldb.py
deleted file mode 100644
index 4cf36441f..000000000
--- a/ldb/ldb.py
+++ /dev/null
@@ -1,508 +0,0 @@
-# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.36
-#
-# Don't modify this file, modify the SWIG interface instead.
-
-"""
-An interface to LDB, a LDAP-like API that can either to talk an embedded database (TDB-based) or a standards-compliant LDAP server.
-"""
-
-import _ldb
-import new
-new_instancemethod = new.instancemethod
-try:
-    _swig_property = property
-except NameError:
-    pass # Python < 2.2 doesn't have 'property'.
-def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
-    if (name == "thisown"): return self.this.own(value)
-    if (name == "this"):
-        if type(value).__name__ == 'PySwigObject':
-            self.__dict__[name] = value
-            return
-    method = class_type.__swig_setmethods__.get(name,None)
-    if method: return method(self,value)
-    if (not static) or hasattr(self,name):
-        self.__dict__[name] = value
-    else:
-        raise AttributeError("You cannot add attributes to %s" % self)
-
-def _swig_setattr(self,class_type,name,value):
-    return _swig_setattr_nondynamic(self,class_type,name,value,0)
-
-def _swig_getattr(self,class_type,name):
-    if (name == "thisown"): return self.this.own()
-    method = class_type.__swig_getmethods__.get(name,None)
-    if method: return method(self)
-    raise AttributeError,name
-
-def _swig_repr(self):
-    try: strthis = "proxy of " + self.this.__repr__()
-    except: strthis = ""
-    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
-
-import types
-try:
-    _object = types.ObjectType
-    _newclass = 1
-except AttributeError:
-    class _object : pass
-    _newclass = 0
-del types
-
-
-def _swig_setattr_nondynamic_method(set):
-    def set_attr(self,name,value):
-        if (name == "thisown"): return self.this.own(value)
-        if hasattr(self,name) or (name == "this"):
-            set(self,name,value)
-        else:
-            raise AttributeError("You cannot add attributes to %s" % self)
-    return set_attr
-
-
-SCOPE_DEFAULT = _ldb.SCOPE_DEFAULT
-SCOPE_BASE = _ldb.SCOPE_BASE
-SCOPE_ONELEVEL = _ldb.SCOPE_ONELEVEL
-SCOPE_SUBTREE = _ldb.SCOPE_SUBTREE
-CHANGETYPE_NONE = _ldb.CHANGETYPE_NONE
-CHANGETYPE_ADD = _ldb.CHANGETYPE_ADD
-CHANGETYPE_DELETE = _ldb.CHANGETYPE_DELETE
-CHANGETYPE_MODIFY = _ldb.CHANGETYPE_MODIFY
-ldb_val_to_py_object = _ldb.ldb_val_to_py_object
-class Dn(object):
-    """A LDB distinguished name."""
-    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    def __init__(self, *args, **kwargs): 
-        """
-        S.__init__(ldb, string)
-        Create a new DN.
-        """
-        _ldb.Dn_swiginit(self,_ldb.new_Dn(*args, **kwargs))
-    __swig_destroy__ = _ldb.delete_Dn
-    def validate(*args, **kwargs):
-        """
-        S.validate() -> bool
-        Validate DN is correct.
-        """
-        return _ldb.Dn_validate(*args, **kwargs)
-
-    def parent(*args, **kwargs):
-        """
-        S.parent() -> dn
-        Get the parent for this DN.
-        """
-        return _ldb.Dn_parent(*args, **kwargs)
-
-    def is_special(*args, **kwargs):
-        """
-        S.is_special() -> bool
-        Check whether this is a special LDB DN.
-        """
-        return _ldb.Dn_is_special(*args, **kwargs)
-
-    def is_null(*args, **kwargs):
-        """
-        S.is_null() -> bool
-        Check whether this is a null DN.
-        """
-        return _ldb.Dn_is_null(*args, **kwargs)
-
-    def add_child(*args, **kwargs):
-        """
-        S.add_child(dn) -> None
-        Add a child DN to this DN.
-        """
-        return _ldb.Dn_add_child(*args, **kwargs)
-
-    def add_base(*args, **kwargs):
-        """
-        S.add_base(dn) -> None
-        Add a base DN to this DN.
-        """
-        return _ldb.Dn_add_base(*args, **kwargs)
-
-    def canonical_str(*args, **kwargs):
-        """
-        S.canonical_str() -> string
-        Canonical version of this DN (like a posix path).
-        """
-        return _ldb.Dn_canonical_str(*args, **kwargs)
-
-    def canonical_ex_str(*args, **kwargs):
-        """
-        S.canonical_ex_str() -> string
-        Canonical version of this DN (like a posix path, with terminating newline).
-        """
-        return _ldb.Dn_canonical_ex_str(*args, **kwargs)
-
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            return self.__cmp__(other) == 0
-        if isinstance(other, str):
-            return str(self) == other
-        return False
-
-Dn.validate = new_instancemethod(_ldb.Dn_validate,None,Dn)
-Dn.get_casefold = new_instancemethod(_ldb.Dn_get_casefold,None,Dn)
-Dn.__str__ = new_instancemethod(_ldb.Dn___str__,None,Dn)
-Dn.parent = new_instancemethod(_ldb.Dn_parent,None,Dn)
-Dn.__cmp__ = new_instancemethod(_ldb.Dn___cmp__,None,Dn)
-Dn.is_valid = new_instancemethod(_ldb.Dn_is_valid,None,Dn)
-Dn.is_special = new_instancemethod(_ldb.Dn_is_special,None,Dn)
-Dn.is_null = new_instancemethod(_ldb.Dn_is_null,None,Dn)
-Dn.check_special = new_instancemethod(_ldb.Dn_check_special,None,Dn)
-Dn.__len__ = new_instancemethod(_ldb.Dn___len__,None,Dn)
-Dn.add_child = new_instancemethod(_ldb.Dn_add_child,None,Dn)
-Dn.add_base = new_instancemethod(_ldb.Dn_add_base,None,Dn)
-Dn.canonical_str = new_instancemethod(_ldb.Dn_canonical_str,None,Dn)
-Dn.canonical_ex_str = new_instancemethod(_ldb.Dn_canonical_ex_str,None,Dn)
-Dn.__repr__ = new_instancemethod(_ldb.Dn___repr__,None,Dn)
-Dn.__add__ = new_instancemethod(_ldb.Dn___add__,None,Dn)
-Dn_swigregister = _ldb.Dn_swigregister
-Dn_swigregister(Dn)
-
-class MessageElement(object):
-    """Message element."""
-    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args, **kwargs): 
-        """Message element."""
-        _ldb.MessageElement_swiginit(self,_ldb.new_MessageElement(*args, **kwargs))
-    __swig_destroy__ = _ldb.delete_MessageElement
-    def __getitem__(self, i):
-        ret = self.get(i)
-        if ret is None:
-            raise KeyError("no such value")
-        return ret
-
-    def __repr__(self):
-        return "MessageElement([%s])" % (",".join(repr(x) for x in self.__set__()))
-
-    def __eq__(self, other):
-        if (len(self) == 1 and self.get(0) == other):
-            return True
-        if isinstance(other, self.__class__):
-            return self.__cmp__(other) == 0
-        o = iter(other)
-        for i in range(len(self)):
-            if self.get(i) != o.next():
-                return False
-        return True
-
-MessageElement.__cmp__ = new_instancemethod(_ldb.MessageElement___cmp__,None,MessageElement)
-MessageElement.__iter__ = new_instancemethod(_ldb.MessageElement___iter__,None,MessageElement)
-MessageElement.__set__ = new_instancemethod(_ldb.MessageElement___set__,None,MessageElement)
-MessageElement.__len__ = new_instancemethod(_ldb.MessageElement___len__,None,MessageElement)
-MessageElement.get = new_instancemethod(_ldb.MessageElement_get,None,MessageElement)
-MessageElement_swigregister = _ldb.MessageElement_swigregister
-MessageElement_swigregister(MessageElement)
-
-ldb_msg_list_elements = _ldb.ldb_msg_list_elements
-class Message(object):
-    """Message."""
-    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    dn = _swig_property(_ldb.Message_dn_get, _ldb.Message_dn_set)
-    def __init__(self, *args, **kwargs): 
-        _ldb.Message_swiginit(self,_ldb.new_Message(*args, **kwargs))
-    __swig_destroy__ = _ldb.delete_Message
-    def get(self, key, default=None):
-        if key == "dn":
-            return self.dn
-        return self.find_element(key)
-
-    def __getitem__(self, key):
-        ret = self.get(key, None)
-        if ret is None:
-            raise KeyError("No such element")
-        return ret
-
-    def iteritems(self):
-        for k in self.keys():
-            yield k, self[k]
-
-    def items(self):
-        return list(self.iteritems())
-
-    def __repr__(self):
-        return "Message(%s)" % repr(dict(self.iteritems()))
-
-Message.find_element = new_instancemethod(_ldb.Message_find_element,None,Message)
-Message.__setitem__ = new_instancemethod(_ldb.Message___setitem__,None,Message)
-Message.__len__ = new_instancemethod(_ldb.Message___len__,None,Message)
-Message.keys = new_instancemethod(_ldb.Message_keys,None,Message)
-Message.__iter__ = new_instancemethod(_ldb.Message___iter__,None,Message)
-Message.__delitem__ = new_instancemethod(_ldb.Message___delitem__,None,Message)
-Message_swigregister = _ldb.Message_swigregister
-Message_swigregister(Message)
-
-ldb_ldif_to_pyobject = _ldb.ldb_ldif_to_pyobject
-LdbError = _ldb.LdbError
-
-LDB_ERR_OPERATIONS_ERROR = _ldb.LDB_ERR_OPERATIONS_ERROR
-LDB_ERR_PROTOCOL_ERROR = _ldb.LDB_ERR_PROTOCOL_ERROR
-LDB_ERR_TIME_LIMIT_EXCEEDED = _ldb.LDB_ERR_TIME_LIMIT_EXCEEDED
-LDB_ERR_SIZE_LIMIT_EXCEEDED = _ldb.LDB_ERR_SIZE_LIMIT_EXCEEDED
-LDB_ERR_COMPARE_FALSE = _ldb.LDB_ERR_COMPARE_FALSE
-LDB_ERR_COMPARE_TRUE = _ldb.LDB_ERR_COMPARE_TRUE
-LDB_ERR_AUTH_METHOD_NOT_SUPPORTED = _ldb.LDB_ERR_AUTH_METHOD_NOT_SUPPORTED
-LDB_ERR_STRONG_AUTH_REQUIRED = _ldb.LDB_ERR_STRONG_AUTH_REQUIRED
-LDB_ERR_REFERRAL = _ldb.LDB_ERR_REFERRAL
-LDB_ERR_ADMIN_LIMIT_EXCEEDED = _ldb.LDB_ERR_ADMIN_LIMIT_EXCEEDED
-LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION = _ldb.LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION
-LDB_ERR_CONFIDENTIALITY_REQUIRED = _ldb.LDB_ERR_CONFIDENTIALITY_REQUIRED
-LDB_ERR_SASL_BIND_IN_PROGRESS = _ldb.LDB_ERR_SASL_BIND_IN_PROGRESS
-LDB_ERR_NO_SUCH_ATTRIBUTE = _ldb.LDB_ERR_NO_SUCH_ATTRIBUTE
-LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE = _ldb.LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE
-LDB_ERR_INAPPROPRIATE_MATCHING = _ldb.LDB_ERR_INAPPROPRIATE_MATCHING
-LDB_ERR_CONSTRAINT_VIOLATION = _ldb.LDB_ERR_CONSTRAINT_VIOLATION
-LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS = _ldb.LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS
-LDB_ERR_INVALID_ATTRIBUTE_SYNTAX = _ldb.LDB_ERR_INVALID_ATTRIBUTE_SYNTAX
-LDB_ERR_NO_SUCH_OBJECT = _ldb.LDB_ERR_NO_SUCH_OBJECT
-LDB_ERR_ALIAS_PROBLEM = _ldb.LDB_ERR_ALIAS_PROBLEM
-LDB_ERR_INVALID_DN_SYNTAX = _ldb.LDB_ERR_INVALID_DN_SYNTAX
-LDB_ERR_ALIAS_DEREFERENCING_PROBLEM = _ldb.LDB_ERR_ALIAS_DEREFERENCING_PROBLEM
-LDB_ERR_INAPPROPRIATE_AUTHENTICATION = _ldb.LDB_ERR_INAPPROPRIATE_AUTHENTICATION
-LDB_ERR_INVALID_CREDENTIALS = _ldb.LDB_ERR_INVALID_CREDENTIALS
-LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS = _ldb.LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS
-LDB_ERR_BUSY = _ldb.LDB_ERR_BUSY
-LDB_ERR_UNAVAILABLE = _ldb.LDB_ERR_UNAVAILABLE
-LDB_ERR_UNWILLING_TO_PERFORM = _ldb.LDB_ERR_UNWILLING_TO_PERFORM
-LDB_ERR_LOOP_DETECT = _ldb.LDB_ERR_LOOP_DETECT
-LDB_ERR_NAMING_VIOLATION = _ldb.LDB_ERR_NAMING_VIOLATION
-LDB_ERR_OBJECT_CLASS_VIOLATION = _ldb.LDB_ERR_OBJECT_CLASS_VIOLATION
-LDB_ERR_NOT_ALLOWED_ON_NON_LEAF = _ldb.LDB_ERR_NOT_ALLOWED_ON_NON_LEAF
-LDB_ERR_NOT_ALLOWED_ON_RDN = _ldb.LDB_ERR_NOT_ALLOWED_ON_RDN
-LDB_ERR_ENTRY_ALREADY_EXISTS = _ldb.LDB_ERR_ENTRY_ALREADY_EXISTS
-LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED = _ldb.LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED
-LDB_ERR_AFFECTS_MULTIPLE_DSAS = _ldb.LDB_ERR_AFFECTS_MULTIPLE_DSAS
-LDB_ERR_OTHER = _ldb.LDB_ERR_OTHER
-class Ldb(object):
-    """Connection to a LDB database."""
-    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    firstmodule = _swig_property(_ldb.Ldb_firstmodule_get, _ldb.Ldb_firstmodule_set)
-    def itermodules(self):
-        m = self.firstmodule
-        while m is not None:
-            yield m
-            m = m.next
-
-    def modules(self):
-        return list(self.itermodules())
-
-    def __init__(self, *args, **kwargs): 
-        _ldb.Ldb_swiginit(self,_ldb.new_Ldb(*args, **kwargs))
-    def connect(*args, **kwargs):
-        """
-        S.connect(url,flags=0,options=None) -> None
-        Connect to a LDB URL.
-        """
-        return _ldb.Ldb_connect(*args, **kwargs)
-
-    __swig_destroy__ = _ldb.delete_Ldb
-    def delete(*args, **kwargs):
-        """
-        S.delete(dn) -> None
-        Remove an entry.
-        """
-        return _ldb.Ldb_delete(*args, **kwargs)
-
-    def rename(*args, **kwargs):
-        """
-        S.rename(old_dn, new_dn) -> None
-        Rename an entry.
-        """
-        return _ldb.Ldb_rename(*args, **kwargs)
-
-    def add(*args, **kwargs):
-        """
-        S.add(message) -> None
-        Add an entry.
-        """
-        return _ldb.Ldb_add(*args, **kwargs)
-
-    def modify(*args, **kwargs):
-        """
-        S.modify(message) -> None
-        Modify an entry.
-        """
-        return _ldb.Ldb_modify(*args, **kwargs)
-
-    def set_create_perms(*args, **kwargs):
-        """
-        S.set_create_perms(mode) -> None
-        Set mode to use when creating new LDB files.
-        """
-        return _ldb.Ldb_set_create_perms(*args, **kwargs)
-
-    def set_modules_dir(*args, **kwargs):
-        """
-        S.set_modules_dir(path) -> None
-        Set path LDB should search for modules
-        """
-        return _ldb.Ldb_set_modules_dir(*args, **kwargs)
-
-    def set_debug(*args, **kwargs):
-        """
-        S.set_debug(callback) -> None
-        Set callback for LDB debug messages.
-        The callback should accept a debug level and debug text.
-        """
-        return _ldb.Ldb_set_debug(*args, **kwargs)
-
-    def set_opaque(*args, **kwargs):
-        """
-        S.set_opaque(name, value) -> None
-        Set an opaque value on this LDB connection. 
-        :note: Passing incorrect values may cause crashes.
-        """
-        return _ldb.Ldb_set_opaque(*args, **kwargs)
-
-    def get_opaque(*args, **kwargs):
-        """
-        S.get_opaque(name) -> value
-        Get an opaque value set on this LDB connection. 
-        :note: The returned value may not be useful in Python.
-        """
-        return _ldb.Ldb_get_opaque(*args, **kwargs)
-
-    def transaction_start(*args, **kwargs):
-        """
-        S.transaction_start() -> None
-        Start a new transaction.
-        """
-        return _ldb.Ldb_transaction_start(*args, **kwargs)
-
-    def transaction_commit(*args, **kwargs):
-        """
-        S.transaction_commit() -> None
-        Commit currently active transaction.
-        """
-        return _ldb.Ldb_transaction_commit(*args, **kwargs)
-
-    def transaction_cancel(*args, **kwargs):
-        """
-        S.transaction_cancel() -> None
-        Cancel currently active transaction.
-        """
-        return _ldb.Ldb_transaction_cancel(*args, **kwargs)
-
-    def parse_ldif(*args, **kwargs):
-        """
-        S.parse_ldif(ldif) -> iter(messages)
-        Parse a string formatted using LDIF.
-        """
-        return _ldb.Ldb_parse_ldif(*args, **kwargs)
-
-    def __init__(self, url=None, flags=0, options=None):
-        """Create a new LDB object.
-
-        Will also connect to the specified URL if one was given.
-        """
-        _ldb.Ldb_swiginit(self,_ldb.new_Ldb())
-        if url is not None:
-            self.connect(url, flags, options)
-
-    def search(self, base=None, scope=SCOPE_DEFAULT, expression=None, 
-               attrs=None, controls=None):
-        """Search in a database.
-
-        :param base: Optional base DN to search
-        :param scope: Search scope (SCOPE_BASE, SCOPE_ONELEVEL or SCOPE_SUBTREE)
-        :param expression: Optional search expression
-        :param attrs: Attributes to return (defaults to all)
-        :param controls: Optional list of controls
-        :return: Iterator over Message objects
-        """
-        if not (attrs is None or isinstance(attrs, list)):
-            raise TypeError("attributes not a list")
-        parsed_controls = None
-        if controls is not None:
-            parsed_controls = self.parse_control_strings(controls)
-        return self.search_ex(base, scope, expression, attrs, 
-                              parsed_controls)
-
-Ldb.connect = new_instancemethod(_ldb.Ldb_connect,None,Ldb)
-Ldb.search_ex = new_instancemethod(_ldb.Ldb_search_ex,None,Ldb)
-Ldb.delete = new_instancemethod(_ldb.Ldb_delete,None,Ldb)
-Ldb.rename = new_instancemethod(_ldb.Ldb_rename,None,Ldb)
-Ldb.parse_control_strings = new_instancemethod(_ldb.Ldb_parse_control_strings,None,Ldb)
-Ldb.add = new_instancemethod(_ldb.Ldb_add,None,Ldb)
-Ldb.modify = new_instancemethod(_ldb.Ldb_modify,None,Ldb)
-Ldb.get_config_basedn = new_instancemethod(_ldb.Ldb_get_config_basedn,None,Ldb)
-Ldb.get_root_basedn = new_instancemethod(_ldb.Ldb_get_root_basedn,None,Ldb)
-Ldb.get_schema_basedn = new_instancemethod(_ldb.Ldb_get_schema_basedn,None,Ldb)
-Ldb.get_default_basedn = new_instancemethod(_ldb.Ldb_get_default_basedn,None,Ldb)
-Ldb.schema_format_value = new_instancemethod(_ldb.Ldb_schema_format_value,None,Ldb)
-Ldb.errstring = new_instancemethod(_ldb.Ldb_errstring,None,Ldb)
-Ldb.set_create_perms = new_instancemethod(_ldb.Ldb_set_create_perms,None,Ldb)
-Ldb.set_modules_dir = new_instancemethod(_ldb.Ldb_set_modules_dir,None,Ldb)
-Ldb.set_debug = new_instancemethod(_ldb.Ldb_set_debug,None,Ldb)
-Ldb.set_opaque = new_instancemethod(_ldb.Ldb_set_opaque,None,Ldb)
-Ldb.get_opaque = new_instancemethod(_ldb.Ldb_get_opaque,None,Ldb)
-Ldb.transaction_start = new_instancemethod(_ldb.Ldb_transaction_start,None,Ldb)
-Ldb.transaction_commit = new_instancemethod(_ldb.Ldb_transaction_commit,None,Ldb)
-Ldb.transaction_cancel = new_instancemethod(_ldb.Ldb_transaction_cancel,None,Ldb)
-Ldb.schema_attribute_remove = new_instancemethod(_ldb.Ldb_schema_attribute_remove,None,Ldb)
-Ldb.schema_attribute_add = new_instancemethod(_ldb.Ldb_schema_attribute_add,None,Ldb)
-Ldb.setup_wellknown_attributes = new_instancemethod(_ldb.Ldb_setup_wellknown_attributes,None,Ldb)
-Ldb.__contains__ = new_instancemethod(_ldb.Ldb___contains__,None,Ldb)
-Ldb.parse_ldif = new_instancemethod(_ldb.Ldb_parse_ldif,None,Ldb)
-Ldb.__repr__ = new_instancemethod(_ldb.Ldb___repr__,None,Ldb)
-Ldb_swigregister = _ldb.Ldb_swigregister
-Ldb_swigregister(Ldb)
-
-
-def valid_attr_name(*args, **kwargs):
-  """
-    S.valid_attr_name(name) -> bool
-    Check whether the supplied name is a valid attribute name.
-    """
-  return _ldb.valid_attr_name(*args, **kwargs)
-
-def timestring(*args, **kwargs):
-  """
-    S.timestring(int) -> string
-    Generate a LDAP time string from a UNIX timestamp
-    """
-  return _ldb.timestring(*args, **kwargs)
-
-def string_to_time(*args, **kwargs):
-  """
-    S.string_to_time(string) -> int
-    Parse a LDAP time string into a UNIX timestamp.
-    """
-  return _ldb.string_to_time(*args, **kwargs)
-class ldb_module(object):
-    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    prev = _swig_property(_ldb.ldb_module_prev_get, _ldb.ldb_module_prev_set)
-    next = _swig_property(_ldb.ldb_module_next_get, _ldb.ldb_module_next_set)
-    def __init__(self, *args, **kwargs): 
-        _ldb.ldb_module_swiginit(self,_ldb.new_ldb_module(*args, **kwargs))
-    __swig_destroy__ = _ldb.delete_ldb_module
-ldb_module.__str__ = new_instancemethod(_ldb.ldb_module___str__,None,ldb_module)
-ldb_module.__repr__ = new_instancemethod(_ldb.ldb_module___repr__,None,ldb_module)
-ldb_module.search = new_instancemethod(_ldb.ldb_module_search,None,ldb_module)
-ldb_module.add = new_instancemethod(_ldb.ldb_module_add,None,ldb_module)
-ldb_module.modify = new_instancemethod(_ldb.ldb_module_modify,None,ldb_module)
-ldb_module.delete = new_instancemethod(_ldb.ldb_module_delete,None,ldb_module)
-ldb_module.rename = new_instancemethod(_ldb.ldb_module_rename,None,ldb_module)
-ldb_module.start_transaction = new_instancemethod(_ldb.ldb_module_start_transaction,None,ldb_module)
-ldb_module.end_transaction = new_instancemethod(_ldb.ldb_module_end_transaction,None,ldb_module)
-ldb_module.del_transaction = new_instancemethod(_ldb.ldb_module_del_transaction,None,ldb_module)
-ldb_module_swigregister = _ldb.ldb_module_swigregister
-ldb_module_swigregister(ldb_module)
-
-
-def register_module(*args, **kwargs):
-  """
-    S.register_module(module) -> None
-    Register a LDB module.
-    """
-  return _ldb.register_module(*args, **kwargs)
-__docformat__ = "restructuredText"
-open = Ldb
-
-
-
diff --git a/ldb/ldb_ildap/ldb_ildap.c b/ldb/ldb_ildap/ldb_ildap.c
index 4aa71e603..b17d063c0 100644
--- a/ldb/ldb_ildap/ldb_ildap.c
+++ b/ldb/ldb_ildap/ldb_ildap.c
@@ -49,7 +49,6 @@
 #include "libcli/ldap/ldap_client.h"
 #include "auth/auth.h"
 #include "auth/credentials/credentials.h"
-#include "param/param.h"
 
 struct ildb_private {
 	struct ldap_connection *ldap;
@@ -312,7 +311,9 @@ static void ildb_callback(struct ldap_request *req)
 				ldbmsg->num_elements = search->num_attributes;
 				ldbmsg->elements = talloc_move(ldbmsg, &search->attributes);
 
-				ret = ldb_module_send_entry(ac->req, ldbmsg);
+				controls = talloc_steal(ac, msg->controls);
+				
+				ret = ldb_module_send_entry(ac->req, ldbmsg, controls);
 				if (ret != LDB_SUCCESS) {
 					callback_failed = true;
 				}
@@ -429,7 +430,7 @@ static int ildb_search(struct ildb_context *ac)
 	if (req->op.search.base == NULL) {
 		msg->r.SearchRequest.basedn = talloc_strdup(msg, "");
 	} else {
-		msg->r.SearchRequest.basedn  = ldb_dn_alloc_linearized(msg, req->op.search.base);
+		msg->r.SearchRequest.basedn  = ldb_dn_get_extended_linearized(msg, req->op.search.base, 0);
 	}
 	if (msg->r.SearchRequest.basedn == NULL) {
 		ldb_set_errstring(ac->module->ldb, "Unable to determine baseDN");
@@ -474,7 +475,7 @@ static int ildb_add(struct ildb_context *ac)
 
 	msg->type = LDAP_TAG_AddRequest;
 
-	msg->r.AddRequest.dn = ldb_dn_alloc_linearized(msg, req->op.add.message->dn);
+	msg->r.AddRequest.dn = ldb_dn_get_extended_linearized(msg, req->op.add.message->dn, 0);
 	if (msg->r.AddRequest.dn == NULL) {
 		talloc_free(msg);
 		return LDB_ERR_INVALID_DN_SYNTAX;
@@ -517,7 +518,7 @@ static int ildb_modify(struct ildb_context *ac)
 
 	msg->type = LDAP_TAG_ModifyRequest;
 
-	msg->r.ModifyRequest.dn = ldb_dn_alloc_linearized(msg, req->op.mod.message->dn);
+	msg->r.ModifyRequest.dn = ldb_dn_get_extended_linearized(msg, req->op.mod.message->dn, 0);
 	if (msg->r.ModifyRequest.dn == NULL) {
 		talloc_free(msg);
 		return LDB_ERR_INVALID_DN_SYNTAX;
@@ -558,7 +559,7 @@ static int ildb_delete(struct ildb_context *ac)
 
 	msg->type = LDAP_TAG_DelRequest;
 
-	msg->r.DelRequest.dn = ldb_dn_alloc_linearized(msg, req->op.del.dn);
+	msg->r.DelRequest.dn = ldb_dn_get_extended_linearized(msg, req->op.del.dn, 0);
 	if (msg->r.DelRequest.dn == NULL) {
 		talloc_free(msg);
 		return LDB_ERR_INVALID_DN_SYNTAX;
@@ -581,7 +582,7 @@ static int ildb_rename(struct ildb_context *ac)
 	}
 
 	msg->type = LDAP_TAG_ModifyDNRequest;
-	msg->r.ModifyDNRequest.dn = ldb_dn_alloc_linearized(msg, req->op.rename.olddn);
+	msg->r.ModifyDNRequest.dn = ldb_dn_get_extended_linearized(msg, req->op.rename.olddn, 0);
 	if (msg->r.ModifyDNRequest.dn == NULL) {
 		talloc_free(msg);
 		return LDB_ERR_INVALID_DN_SYNTAX;
diff --git a/ldb/ldb_ldap/ldb_ldap.c b/ldb/ldb_ldap/ldb_ldap.c
index 7caee10b4..9f8b3e9f3 100644
--- a/ldb/ldb_ldap/ldb_ldap.c
+++ b/ldb/ldb_ldap/ldb_ldap.c
@@ -515,7 +515,7 @@ static bool lldb_parse_result(struct lldb_context *ac, LDAPMessage *result)
 			}
 			if (berptr) ber_free(berptr, 0);
 
-			ret = ldb_module_send_entry(ac->req, ldbmsg);
+			ret = ldb_module_send_entry(ac->req, ldbmsg, NULL /* controls not yet supported */);
 			if (ret != LDB_SUCCESS) {
 
 				callback_failed = true;
diff --git a/ldb/ldb_map/ldb_map.c b/ldb/ldb_map/ldb_map.c
index fafbb63b0..72d8378a0 100644
--- a/ldb/ldb_map/ldb_map.c
+++ b/ldb/ldb_map/ldb_map.c
@@ -626,7 +626,7 @@ static struct ldb_val ldb_dn_convert_local(struct ldb_module *module, void *mem_
 	struct ldb_dn *dn, *newdn;
 	struct ldb_val newval;
 
-	dn = ldb_dn_new(mem_ctx, module->ldb, (char *)val->data);
+	dn = ldb_dn_from_ldb_val(mem_ctx, module->ldb, val);
 	if (! ldb_dn_validate(dn)) {
 		newval.length = 0;
 		newval.data = NULL;
@@ -652,7 +652,7 @@ static struct ldb_val ldb_dn_convert_remote(struct ldb_module *module, void *mem
 	struct ldb_dn *dn, *newdn;
 	struct ldb_val newval;
 
-	dn = ldb_dn_new(mem_ctx, module->ldb, (char *)val->data);
+	dn = ldb_dn_from_ldb_val(mem_ctx, module->ldb, val);
 	if (! ldb_dn_validate(dn)) {
 		newval.length = 0;
 		newval.data = NULL;
diff --git a/ldb/ldb_map/ldb_map_outbound.c b/ldb/ldb_map/ldb_map_outbound.c
index 5f524a8be..5588eaaf4 100644
--- a/ldb/ldb_map/ldb_map_outbound.c
+++ b/ldb/ldb_map/ldb_map_outbound.c
@@ -1077,7 +1077,7 @@ int map_return_entry(struct map_context *ac, struct ldb_reply *ares)
 		}
 	}
 
-	return ldb_module_send_entry(ac->req, ares->message);
+	return ldb_module_send_entry(ac->req, ares->message, ares->controls);
 }
 
 /* Search a record. */
diff --git a/ldb/ldb_map/ldb_map_private.h b/ldb/ldb_map/ldb_map_private.h
index 552212534..0543ba71b 100644
--- a/ldb/ldb_map/ldb_map_private.h
+++ b/ldb/ldb_map/ldb_map_private.h
@@ -86,3 +86,5 @@ int map_return_fatal_error(struct ldb_request *req,
 int map_return_normal_error(struct ldb_request *req,
 			    struct ldb_reply *ares,
 			    int error);
+
+int map_return_entry(struct map_context *ac, struct ldb_reply *ares);
diff --git a/ldb/ldb_tdb/ldb_index.c b/ldb/ldb_tdb/ldb_index.c
index 65711d9f4..c4c23022f 100644
--- a/ldb/ldb_tdb/ldb_index.c
+++ b/ldb/ldb_tdb/ldb_index.c
@@ -1,4 +1,4 @@
-/* 
+/*
    ldb database library
 
    Copyright (C) Andrew Tridgell  2004
@@ -6,7 +6,7 @@
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
@@ -36,13 +36,335 @@
 #include "ldb_tdb.h"
 
 /*
+  the idxptr code is a bit unusual. The way it works is to replace
+  @IDX elements in records during a transaction with @IDXPTR
+  elements. The @IDXPTR elements don't contain the actual index entry
+  values, but contain a pointer to a linked list of values.
+
+  This means we are storing pointers in a database, which is normally
+  not allowed, but in this case we are storing them only for the
+  duration of a transaction, and re-writing them into the normal @IDX
+  format at the end of the transaction. That means no other processes
+  are ever exposed to the @IDXPTR values.
+
+  The advantage is that the linked list doesn't cause huge
+  fragmentation during a transaction. Without the @IDXPTR method we
+  often ended up with a ldb that was between 10x and 100x larger then
+  it needs to be due to massive fragmentation caused by re-writing
+  @INDEX records many times during indexing.
+ */
+struct ldb_index_pointer {
+	struct ldb_index_pointer *next, *prev;
+	struct ldb_val value;
+};
+
+struct ltdb_idxptr {
+	int num_dns;
+	const char **dn_list;
+	bool repack;
+};
+
+/*
+  add to the list of DNs that need to be fixed on transaction end
+ */
+static int ltdb_idxptr_add(struct ldb_module *module, const struct ldb_message *msg)
+{
+	struct ltdb_private *ltdb =
+		talloc_get_type(module->private_data, struct ltdb_private);
+	ltdb->idxptr->dn_list = talloc_realloc(ltdb->idxptr, ltdb->idxptr->dn_list, 
+					       const char *, ltdb->idxptr->num_dns+1);
+	if (ltdb->idxptr->dn_list == NULL) {
+		ltdb->idxptr->num_dns = 0;
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	ltdb->idxptr->dn_list[ltdb->idxptr->num_dns] =
+		talloc_strdup(ltdb->idxptr->dn_list, ldb_dn_get_linearized(msg->dn));
+	if (ltdb->idxptr->dn_list[ltdb->idxptr->num_dns] == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	ltdb->idxptr->num_dns++;
+	return LDB_SUCCESS;
+}
+
+/* free an idxptr record */
+static int ltdb_free_idxptr(struct ldb_module *module, struct ldb_message_element *el)
+{
+	struct ldb_val val;
+	struct ldb_index_pointer *ptr;
+
+	if (el->num_values != 1) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	val = el->values[0];
+	if (val.length != sizeof(void *)) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	ptr = *(struct ldb_index_pointer **)val.data;
+	if (talloc_get_type(ptr, struct ldb_index_pointer) != ptr) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	while (ptr) {
+		struct ldb_index_pointer *tmp = ptr;
+		DLIST_REMOVE(ptr, ptr);
+		talloc_free(tmp);
+	}
+
+	return LDB_SUCCESS;
+}
+
+
+/* convert from the IDXPTR format to a ldb_message_element format */
+static int ltdb_convert_from_idxptr(struct ldb_module *module, struct ldb_message_element *el)
+{
+	struct ldb_val val;
+	struct ldb_index_pointer *ptr, *tmp;
+	int i;
+	struct ldb_val *val2;
+
+	if (el->num_values != 1) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	val = el->values[0];
+	if (val.length != sizeof(void *)) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	ptr = *(struct ldb_index_pointer **)val.data;
+	if (talloc_get_type(ptr, struct ldb_index_pointer) != ptr) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	/* count the length of the list */
+	for (i=0, tmp = ptr; tmp; tmp=tmp->next) {
+		i++;
+	}
+
+	/* allocate the new values array */
+	val2 = talloc_realloc(NULL, el->values, struct ldb_val, i);
+	if (val2 == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	el->values = val2;
+	el->num_values = i;
+
+	/* populate the values array */
+	for (i=0, tmp = ptr; tmp; tmp=tmp->next, i++) {
+		el->values[i].length = tmp->value.length;
+		/* we need to over-allocate here as there are still some places
+		   in ldb that rely on null termination. */
+		el->values[i].data = talloc_size(el->values, tmp->value.length+1);
+		if (el->values[i].data == NULL) {
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+		memcpy(el->values[i].data, tmp->value.data, tmp->value.length);
+		el->values[i].data[tmp->value.length] = 0;
+	}
+
+	/* update the name */
+	el->name = LTDB_IDX;
+
+       	return LDB_SUCCESS;
+}
+
+
+/* convert to the IDXPTR format from a ldb_message_element format */
+static int ltdb_convert_to_idxptr(struct ldb_module *module, struct ldb_message_element *el)
+{
+	struct ldb_index_pointer *ptr, *tmp;
+	int i;
+	struct ldb_val *val2;
+	struct ltdb_private *ltdb =
+		talloc_get_type(module->private_data, struct ltdb_private);
+
+	ptr = NULL;
+
+	for (i=0;i<el->num_values;i++) {
+		tmp = talloc(ltdb->idxptr, struct ldb_index_pointer);
+		if (tmp == NULL) {
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+		tmp->value = el->values[i];
+		tmp->value.data = talloc_memdup(tmp, tmp->value.data, tmp->value.length);
+		if (tmp->value.data == NULL) {
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+		DLIST_ADD(ptr, tmp);
+	}
+
+	/* allocate the new values array */
+	val2 = talloc_realloc(NULL, el->values, struct ldb_val, 1);
+	if (val2 == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	el->values = val2;
+	el->num_values = 1;
+
+	el->values[0].data = talloc_memdup(el->values, &ptr, sizeof(ptr));
+	el->values[0].length = sizeof(ptr);
+
+	/* update the name */
+	el->name = LTDB_IDXPTR;
+
+       	return LDB_SUCCESS;
+}
+
+
+/* enable the idxptr mode when transactions start */
+int ltdb_index_transaction_start(struct ldb_module *module)
+{
+	struct ltdb_private *ltdb =
+		talloc_get_type(module->private_data, struct ltdb_private);
+	ltdb->idxptr = talloc_zero(module, struct ltdb_idxptr);
+	return LDB_SUCCESS;
+}
+
+/*
+  a wrapper around ltdb_search_dn1() which translates pointer based index records
+  and maps them into normal ldb message structures
+ */
+static int ltdb_search_dn1_index(struct ldb_module *module,
+				struct ldb_dn *dn, struct ldb_message *msg)
+{
+	int ret, i;
+	ret = ltdb_search_dn1(module, dn, msg);
+	if (ret != LDB_SUCCESS) {
+		return ret;
+	}
+
+	/* if this isn't a @INDEX record then don't munge it */
+	if (strncmp(ldb_dn_get_linearized(msg->dn), LTDB_INDEX ":", strlen(LTDB_INDEX) + 1) != 0) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	for (i=0;i<msg->num_elements;i++) {
+		struct ldb_message_element *el = &msg->elements[i];
+		if (strcmp(el->name, LTDB_IDXPTR) == 0) {
+			ret = ltdb_convert_from_idxptr(module, el);
+			if (ret != LDB_SUCCESS) {
+				return ret;
+			}
+		}
+	}
+
+	return ret;
+}
+
+
+
+/*
+  fixup the idxptr for one DN
+ */
+static int ltdb_idxptr_fix_dn(struct ldb_module *module, const char *strdn)
+{
+	struct ldb_dn *dn;
+	struct ldb_message *msg = ldb_msg_new(module);
+	int ret;
+
+	dn = ldb_dn_new(msg, module->ldb, strdn);
+	if (ltdb_search_dn1_index(module, dn, msg) == LDB_SUCCESS) {
+		ret = ltdb_store(module, msg, TDB_REPLACE);
+	}
+	talloc_free(msg);
+	return ret;
+}
+
+/* cleanup the idxptr mode when transaction commits */
+int ltdb_index_transaction_commit(struct ldb_module *module)
+{
+	int i;
+	struct ltdb_private *ltdb =
+		talloc_get_type(module->private_data, struct ltdb_private);
+
+	/* fix all the DNs that we have modified */
+	if (ltdb->idxptr) {
+		for (i=0;i<ltdb->idxptr->num_dns;i++) {
+			ltdb_idxptr_fix_dn(module, ltdb->idxptr->dn_list[i]);
+		}
+
+		if (ltdb->idxptr->repack) {
+			tdb_repack(ltdb->tdb);
+		}
+	}
+
+	talloc_free(ltdb->idxptr);
+	ltdb->idxptr = NULL;
+	return LDB_SUCCESS;
+}
+
+/* cleanup the idxptr mode when transaction cancels */
+int ltdb_index_transaction_cancel(struct ldb_module *module)
+{
+	struct ltdb_private *ltdb =
+		talloc_get_type(module->private_data, struct ltdb_private);
+	talloc_free(ltdb->idxptr);
+	ltdb->idxptr = NULL;
+	return LDB_SUCCESS;
+}
+
+
+
+/* a wrapper around ltdb_store() for the index code which
+   stores in IDXPTR format when idxptr mode is enabled
+
+   WARNING: This modifies the msg which is passed in
+*/
+int ltdb_store_idxptr(struct ldb_module *module, const struct ldb_message *msg, int flgs)
+{
+	struct ltdb_private *ltdb =
+		talloc_get_type(module->private_data, struct ltdb_private);
+	int ret;
+
+	if (ltdb->idxptr) {
+		int i;
+		struct ldb_message *msg2 = ldb_msg_new(module);
+
+		/* free any old pointer */
+		ret = ltdb_search_dn1(module, msg->dn, msg2);
+		if (ret == 0) {
+			for (i=0;i<msg2->num_elements;i++) {
+				struct ldb_message_element *el = &msg2->elements[i];
+				if (strcmp(el->name, LTDB_IDXPTR) == 0) {
+					ret = ltdb_free_idxptr(module, el);
+					if (ret != LDB_SUCCESS) {
+						return ret;
+					}
+				}
+			}
+		}
+		talloc_free(msg2);
+
+		for (i=0;i<msg->num_elements;i++) {
+			struct ldb_message_element *el = &msg->elements[i];
+			if (strcmp(el->name, LTDB_IDX) == 0) {
+				ret = ltdb_convert_to_idxptr(module, el);
+				if (ret != LDB_SUCCESS) {
+					return ret;
+				}
+			}
+		}
+
+		if (ltdb_idxptr_add(module, msg) != 0) {
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+	}
+
+	ret = ltdb_store(module, msg, flgs);
+	return ret;
+}
+
+
+/*
   find an element in a list, using the given comparison function and
   assuming that the list is already sorted using comp_fn
 
   return -1 if not found, or the index of the first occurance of needle if found
 */
-static int ldb_list_find(const void *needle, 
-			 const void *base, size_t nmemb, size_t size, 
+static int ldb_list_find(const void *needle,
+			 const void *base, size_t nmemb, size_t size,
 			 comparison_fn_t comp_fn)
 {
 	const char *base_p = (const char *)base;
@@ -183,7 +505,7 @@ static int list_cmp(const char **s1, const char **s2)
 /*
   return a list of dn's that might match a simple indexed search or
  */
-static int ltdb_index_dn_simple(struct ldb_module *module, 
+static int ltdb_index_dn_simple(struct ldb_module *module,
 				const struct ldb_parse_tree *tree,
 				const struct ldb_message *index_list,
 				struct dn_list *list)
@@ -213,7 +535,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = ltdb_search_dn1(module, dn, msg);
+	ret = ltdb_search_dn1_index(module, dn, msg);
 	talloc_free(dn);
 	if (ret != LDB_SUCCESS) {
 		return ret;
@@ -235,7 +557,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 		}
 
 		for (j=0;j<el->num_values;j++) {
-			list->dn[list->count] = 
+			list->dn[list->count] =
 				talloc_strdup(list->dn, (char *)el->values[j].data);
 			if (!list->dn[list->count]) {
 				talloc_free(msg);
@@ -260,7 +582,7 @@ static int list_union(struct ldb_context *, struct dn_list *, const struct dn_li
 /*
   return a list of dn's that might match a leaf indexed search
  */
-static int ltdb_index_dn_leaf(struct ldb_module *module, 
+static int ltdb_index_dn_leaf(struct ldb_module *module,
 			      const struct ldb_parse_tree *tree,
 			      const struct ldb_message *index_list,
 			      struct dn_list *list)
@@ -312,13 +634,13 @@ static int list_intersect(struct ldb_context *ldb,
 	list3->count = 0;
 
 	for (i=0;i<list->count;i++) {
-		if (ldb_list_find(list->dn[i], list2->dn, list2->count, 
+		if (ldb_list_find(list->dn[i], list2->dn, list2->count,
 			      sizeof(char *), (comparison_fn_t)strcmp) != -1) {
 			list3->dn[list3->count] = talloc_move(list3->dn, &list->dn[i]);
 			list3->count++;
 		} else {
 			talloc_free(list->dn[i]);
-		}		
+		}
 	}
 
 	talloc_free(list->dn);
@@ -335,7 +657,7 @@ static int list_intersect(struct ldb_context *ldb,
   list = list | list2
   relies on the lists being sorted
 */
-static int list_union(struct ldb_context *ldb, 
+static int list_union(struct ldb_context *ldb,
 		      struct dn_list *list, const struct dn_list *list2)
 {
 	unsigned int i;
@@ -354,14 +676,14 @@ static int list_union(struct ldb_context *ldb,
 	list->dn = d;
 
 	for (i=0;i<list2->count;i++) {
-		if (ldb_list_find(list2->dn[i], list->dn, count, 
+		if (ldb_list_find(list2->dn[i], list->dn, count,
 			      sizeof(char *), (comparison_fn_t)strcmp) == -1) {
 			list->dn[list->count] = talloc_strdup(list->dn, list2->dn[i]);
 			if (!list->dn[list->count]) {
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 			list->count++;
-		}		
+		}
 	}
 
 	if (list->count != count) {
@@ -371,7 +693,7 @@ static int list_union(struct ldb_context *ldb,
 	return LDB_ERR_NO_SUCH_OBJECT;
 }
 
-static int ltdb_index_dn(struct ldb_module *module, 
+static int ltdb_index_dn(struct ldb_module *module,
 			 const struct ldb_parse_tree *tree,
 			 const struct ldb_message *index_list,
 			 struct dn_list *list);
@@ -380,7 +702,7 @@ static int ltdb_index_dn(struct ldb_module *module,
 /*
   OR two index results
  */
-static int ltdb_index_dn_or(struct ldb_module *module, 
+static int ltdb_index_dn_or(struct ldb_module *module,
 			    const struct ldb_parse_tree *tree,
 			    const struct ldb_message *index_list,
 			    struct dn_list *list)
@@ -388,7 +710,7 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 	struct ldb_context *ldb = module->ldb;
 	unsigned int i;
 	int ret;
-	
+
 	ret = LDB_ERR_OPERATIONS_ERROR;
 	list->dn = NULL;
 	list->count = 0;
@@ -445,7 +767,7 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 /*
   NOT an index results
  */
-static int ltdb_index_dn_not(struct ldb_module *module, 
+static int ltdb_index_dn_not(struct ldb_module *module,
 			     const struct ldb_parse_tree *tree,
 			     const struct ldb_message *index_list,
 			     struct dn_list *list)
@@ -453,8 +775,8 @@ static int ltdb_index_dn_not(struct ldb_module *module,
 	/* the only way to do an indexed not would be if we could
 	   negate the not via another not or if we knew the total
 	   number of database elements so we could know that the
-	   existing expression covered the whole database. 
-	   
+	   existing expression covered the whole database.
+
 	   instead, we just give up, and rely on a full index scan
 	   (unless an outer & manages to reduce the list)
 	*/
@@ -464,7 +786,7 @@ static int ltdb_index_dn_not(struct ldb_module *module,
 /*
   AND two index results
  */
-static int ltdb_index_dn_and(struct ldb_module *module, 
+static int ltdb_index_dn_and(struct ldb_module *module,
 			     const struct ldb_parse_tree *tree,
 			     const struct ldb_message *index_list,
 			     struct dn_list *list)
@@ -472,7 +794,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 	struct ldb_context *ldb = module->ldb;
 	unsigned int i;
 	int ret;
-	
+
 	ret = LDB_ERR_OPERATIONS_ERROR;
 	list->dn = NULL;
 	list->count = 0;
@@ -526,7 +848,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 /*
   AND index results and ONE level special index
  */
-static int ltdb_index_dn_one(struct ldb_module *module, 
+static int ltdb_index_dn_one(struct ldb_module *module,
 			     struct ldb_dn *parent_dn,
 			     struct dn_list *list)
 {
@@ -537,13 +859,13 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 	struct ldb_val val;
 	unsigned int i, j;
 	int ret;
-	
+
 	list2 = talloc_zero(module, struct dn_list);
 	if (list2 == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	/* the attribute is indexed. Pull the list of DNs that match the 
+	/* the attribute is indexed. Pull the list of DNs that match the
 	   search criterion */
 	val.data = (uint8_t *)((uintptr_t)ldb_dn_get_casefold(parent_dn));
 	val.length = strlen((char *)val.data);
@@ -559,7 +881,7 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = ltdb_search_dn1(module, key, msg);
+	ret = ltdb_search_dn1_index(module, key, msg);
 	talloc_free(key);
 	if (ret != LDB_SUCCESS) {
 		return ret;
@@ -624,7 +946,7 @@ static int ltdb_index_dn_one(struct ldb_module *module,
   return a list of dn's that might match a indexed search or
   an error. return LDB_ERR_NO_SUCH_OBJECT for no matches, or LDB_SUCCESS for matches
  */
-static int ltdb_index_dn(struct ldb_module *module, 
+static int ltdb_index_dn(struct ldb_module *module,
 			 const struct ldb_parse_tree *tree,
 			 const struct ldb_message *index_list,
 			 struct dn_list *list)
@@ -666,7 +988,7 @@ static int ltdb_index_dn(struct ldb_module *module,
   filter a candidate dn_list from an indexed search into a set of results
   extracting just the given attributes
 */
-static int ltdb_index_filter(const struct dn_list *dn_list, 
+static int ltdb_index_filter(const struct dn_list *dn_list,
 			     struct ltdb_context *ac)
 {
 	struct ldb_message *msg;
@@ -715,7 +1037,7 @@ static int ltdb_index_filter(const struct dn_list *dn_list,
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
-		ret = ldb_module_send_entry(ac->req, msg);
+		ret = ldb_module_send_entry(ac->req, msg, NULL);
 		if (ret != LDB_SUCCESS) {
 			ac->callback_failed = true;
 			return ret;
@@ -728,7 +1050,7 @@ static int ltdb_index_filter(const struct dn_list *dn_list,
 /*
   search the database with a LDAP-like expression using indexes
   returns -1 if an indexed search is not possible, in which
-  case the caller should call ltdb_search_full() 
+  case the caller should call ltdb_search_full()
 */
 int ltdb_search_indexed(struct ltdb_context *ac)
 {
@@ -804,14 +1126,14 @@ int ltdb_search_indexed(struct ltdb_context *ac)
 /*
   add a index element where this is the first indexed DN for this value
 */
-static int ltdb_index_add1_new(struct ldb_context *ldb, 
+static int ltdb_index_add1_new(struct ldb_context *ldb,
 			       struct ldb_message *msg,
 			       const char *dn)
 {
 	struct ldb_message_element *el;
 
 	/* add another entry */
-	el = talloc_realloc(msg, msg->elements, 
+	el = talloc_realloc(msg, msg->elements,
 			       struct ldb_message_element, msg->num_elements+1);
 	if (!el) {
 		return LDB_ERR_OPERATIONS_ERROR;
@@ -840,7 +1162,7 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
   add a index element where this is not the first indexed DN for this
   value
 */
-static int ltdb_index_add1_add(struct ldb_context *ldb, 
+static int ltdb_index_add1_add(struct ldb_context *ldb,
 			       struct ldb_message *msg,
 			       int idx,
 			       const char *dn)
@@ -856,7 +1178,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 	}
 
 	v2 = talloc_realloc(msg->elements, msg->elements[idx].values,
-			      struct ldb_val, 
+			      struct ldb_val,
 			      msg->elements[idx].num_values+1);
 	if (!v2) {
 		return LDB_ERR_OPERATIONS_ERROR;
@@ -873,7 +1195,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 /*
   add an index entry for one message element
 */
-static int ltdb_index_add1(struct ldb_module *module, const char *dn, 
+static int ltdb_index_add1(struct ldb_module *module, const char *dn,
 			   struct ldb_message_element *el, int v_idx)
 {
 	struct ldb_context *ldb = module->ldb;
@@ -895,7 +1217,7 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
 	}
 	talloc_steal(msg, dn_key);
 
-	ret = ltdb_search_dn1(module, dn_key, msg);
+	ret = ltdb_search_dn1_index(module, dn_key, msg);
 	if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
 		talloc_free(msg);
 		return ret;
@@ -920,7 +1242,7 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
 	}
 
 	if (ret == LDB_SUCCESS) {
-		ret = ltdb_store(module, msg, TDB_REPLACE);
+		ret = ltdb_store_idxptr(module, msg, TDB_REPLACE);
 	}
 
 	talloc_free(msg);
@@ -945,7 +1267,7 @@ static int ltdb_index_add0(struct ldb_module *module, const char *dn,
 	}
 
 	for (i = 0; i < num_el; i++) {
-		ret = ldb_msg_find_idx(ltdb->cache->indexlist, elements[i].name, 
+		ret = ldb_msg_find_idx(ltdb->cache->indexlist, elements[i].name,
 				       NULL, LTDB_IDXATTR);
 		if (ret == -1) {
 			continue;
@@ -983,7 +1305,7 @@ int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 /*
   delete an index entry for one message element
 */
-int ltdb_index_del_value(struct ldb_module *module, const char *dn, 
+int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 			 struct ldb_message_element *el, int v_idx)
 {
 	struct ldb_context *ldb = module->ldb;
@@ -1007,7 +1329,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = ltdb_search_dn1(module, dn_key, msg);
+	ret = ltdb_search_dn1_index(module, dn_key, msg);
 	if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
 		talloc_free(dn_key);
 		return ret;
@@ -1022,18 +1344,24 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 
 	i = ldb_msg_find_idx(msg, dn, &j, LTDB_IDX);
 	if (i == -1) {
+		struct ldb_ldif ldif;
+
 		ldb_debug(ldb, LDB_DEBUG_ERROR,
 				"ERROR: dn %s not found in %s\n", dn,
 				ldb_dn_get_linearized(dn_key));
+		ldif.changetype = LDB_CHANGETYPE_NONE;
+		ldif.msg = msg;
+		ldb_ldif_write_file(module->ldb, stdout, &ldif);
+		sleep(100);
 		/* it ain't there. hmmm */
 		talloc_free(dn_key);
 		return LDB_SUCCESS;
 	}
 
 	if (j != msg->elements[i].num_values - 1) {
-		memmove(&msg->elements[i].values[j], 
-			&msg->elements[i].values[j+1], 
-			(msg->elements[i].num_values-(j+1)) * 
+		memmove(&msg->elements[i].values[j],
+			&msg->elements[i].values[j+1],
+			(msg->elements[i].num_values-(j+1)) *
 			sizeof(msg->elements[i].values[0]));
 	}
 	msg->elements[i].num_values--;
@@ -1041,7 +1369,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 	if (msg->elements[i].num_values == 0) {
 		ret = ltdb_delete_noindex(module, dn_key);
 	} else {
-		ret = ltdb_store(module, msg, TDB_REPLACE);
+		ret = ltdb_store_idxptr(module, msg, TDB_REPLACE);
 	}
 
 	talloc_free(dn_key);
@@ -1060,7 +1388,7 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 	const char *dn;
 	unsigned int i, j;
 
-	/* find the list of indexed fields */	
+	/* find the list of indexed fields */
 	if (ltdb->cache->indexlist->num_elements == 0) {
 		/* no indexed fields */
 		return LDB_SUCCESS;
@@ -1092,7 +1420,7 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 	return LDB_SUCCESS;
 }
 
-/* 
+/*
   handle special index for one level searches
 */
 int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int add)
@@ -1183,7 +1511,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		return -1;
 	}
 
-	/* check if the DN key has changed, perhaps due to the 
+	/* check if the DN key has changed, perhaps due to the
 	   case insensitivity of an element changing */
 	key2 = ltdb_key(module, msg->dn);
 	if (key2.dptr == NULL) {
@@ -1250,5 +1578,9 @@ int ltdb_reindex(struct ldb_module *module)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
+	if (ltdb->idxptr) {
+		ltdb->idxptr->repack = true;
+	}
+
 	return LDB_SUCCESS;
 }
diff --git a/ldb/ldb_tdb/ldb_search.c b/ldb/ldb_tdb/ldb_search.c
index 1c76411db..35149c4b7 100644
--- a/ldb/ldb_tdb/ldb_search.c
+++ b/ldb/ldb_tdb/ldb_search.c
@@ -205,7 +205,7 @@ static struct ldb_message *ltdb_pull_attrs(struct ldb_module *module,
   return LDB_ERR_NO_SUCH_OBJECT on record-not-found
   and LDB_SUCCESS on success
 */
-int ltdb_search_base(struct ldb_module *module, struct ldb_dn *dn)
+static int ltdb_search_base(struct ldb_module *module, struct ldb_dn *dn)
 {
 	struct ltdb_private *ltdb = (struct ltdb_private *)module->private_data;
 	TDB_DATA tdb_key, tdb_data;
@@ -418,7 +418,7 @@ static int search_func(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, voi
 		return -1;
 	}
 
-	ret = ldb_module_send_entry(ac->req, msg);
+	ret = ldb_module_send_entry(ac->req, msg, NULL);
 	if (ret != LDB_SUCCESS) {
 		ac->callback_failed = true;
 		/* the callback failed, abort the operation */
diff --git a/ldb/ldb_tdb/ldb_tdb.c b/ldb/ldb_tdb/ldb_tdb.c
index 2282f61d4..ea460def6 100644
--- a/ldb/ldb_tdb/ldb_tdb.c
+++ b/ldb/ldb_tdb/ldb_tdb.c
@@ -161,7 +161,7 @@ failed:
   check special dn's have valid attributes
   currently only @ATTRIBUTES is checked
 */
-int ltdb_check_special_dn(struct ldb_module *module,
+static int ltdb_check_special_dn(struct ldb_module *module,
 			  const struct ldb_message *msg)
 {
 	int i, j;
@@ -850,6 +850,8 @@ static int ltdb_start_trans(struct ldb_module *module)
 
 	ltdb->in_transaction++;
 
+	ltdb_index_transaction_start(module);
+
 	return LDB_SUCCESS;
 }
 
@@ -860,6 +862,10 @@ static int ltdb_end_trans(struct ldb_module *module)
 
 	ltdb->in_transaction--;
 
+	if (ltdb_index_transaction_commit(module) != 0) {
+		return ltdb_err_map(tdb_error(ltdb->tdb));
+	}
+
 	if (tdb_transaction_commit(ltdb->tdb) != 0) {
 		return ltdb_err_map(tdb_error(ltdb->tdb));
 	}
@@ -874,6 +880,10 @@ static int ltdb_del_trans(struct ldb_module *module)
 
 	ltdb->in_transaction--;
 
+	if (ltdb_index_transaction_cancel(module) != 0) {
+		return ltdb_err_map(tdb_error(ltdb->tdb));
+	}
+
 	if (tdb_transaction_cancel(ltdb->tdb) != 0) {
 		return ltdb_err_map(tdb_error(ltdb->tdb));
 	}
@@ -968,7 +978,7 @@ done:
 	return ret;
 }
 
-void ltdb_request_done(struct ldb_request *req, int error)
+static void ltdb_request_done(struct ldb_request *req, int error)
 {
 	struct ldb_reply *ares;
 
@@ -1076,12 +1086,14 @@ static void ltdb_callback(struct event_context *ev,
 	}
 
 	if (!ctx->callback_failed) {
+		/* Once we are done, we do not need timeout events */
+		talloc_free(ctx->timeout_event);
 		ltdb_request_done(ctx->req, ret);
 	}
 }
 
 static int ltdb_handle_request(struct ldb_module *module,
-				struct ldb_request *req)
+			       struct ldb_request *req)
 {
 	struct event_context *ev;
 	struct ltdb_context *ac;
@@ -1115,10 +1127,9 @@ static int ltdb_handle_request(struct ldb_module *module,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-
 	tv.tv_sec = req->starttime + req->timeout;
-	te = event_add_timed(ev, ac, tv, ltdb_timeout, ac);
-	if (NULL == te) {
+	ac->timeout_event = event_add_timed(ev, ac, tv, ltdb_timeout, ac);
+	if (NULL == ac->timeout_event) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
diff --git a/ldb/ldb_tdb/ldb_tdb.h b/ldb/ldb_tdb/ldb_tdb.h
index 61e90bccc..7b9a76501 100644
--- a/ldb/ldb_tdb/ldb_tdb.h
+++ b/ldb/ldb_tdb/ldb_tdb.h
@@ -33,6 +33,7 @@ struct ltdb_private {
 	int in_transaction;
 
 	bool check_base;
+	struct ltdb_idxptr *idxptr;
 };
 
 /*
@@ -50,12 +51,14 @@ struct ltdb_context {
 	struct ldb_dn *base;
 	enum ldb_scope scope;
 	const char * const *attrs;
+	struct timed_event *timeout_event;
 };
 
 /* special record types */
 #define LTDB_INDEX      "@INDEX"
 #define LTDB_INDEXLIST  "@INDEXLIST"
 #define LTDB_IDX        "@IDX"
+#define LTDB_IDXPTR     "@IDXPTR"
 #define LTDB_IDXATTR    "@IDXATTR"
 #define LTDB_IDXONE     "@IDXONE"
 #define LTDB_BASEINFO   "@BASEINFO"
@@ -84,6 +87,9 @@ int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg);
 int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg);
 int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int add);
 int ltdb_reindex(struct ldb_module *module);
+int ltdb_index_transaction_start(struct ldb_module *module);
+int ltdb_index_transaction_commit(struct ldb_module *module);
+int ltdb_index_transaction_cancel(struct ldb_module *module);
 
 /* The following definitions come from lib/ldb/ldb_tdb/ldb_pack.c  */
 
diff --git a/ldb/ldb_wrap.c b/ldb/ldb_wrap.c
deleted file mode 100644
index bc9266a30..000000000
--- a/ldb/ldb_wrap.c
+++ /dev/null
@@ -1,7524 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.36
- * 
- * This file is not intended to be easily readable and contains a number of 
- * coding conventions designed to improve portability and efficiency. Do not make
- * changes to this file unless you know what you are doing--modify the SWIG 
- * interface file instead. 
- * ----------------------------------------------------------------------------- */
-
-#define SWIGPYTHON
-#define SWIG_PYTHON_NO_BUILD_NONE
-/* -----------------------------------------------------------------------------
- *  This section contains generic SWIG labels for method/variable
- *  declarations/attributes, and other compiler dependent labels.
- * ----------------------------------------------------------------------------- */
-
-/* template workaround for compilers that cannot correctly implement the C++ standard */
-#ifndef SWIGTEMPLATEDISAMBIGUATOR
-# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
-#  define SWIGTEMPLATEDISAMBIGUATOR template
-# elif defined(__HP_aCC)
-/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
-/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
-#  define SWIGTEMPLATEDISAMBIGUATOR template
-# else
-#  define SWIGTEMPLATEDISAMBIGUATOR
-# endif
-#endif
-
-/* inline attribute */
-#ifndef SWIGINLINE
-# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
-#   define SWIGINLINE inline
-# else
-#   define SWIGINLINE
-# endif
-#endif
-
-/* attribute recognised by some compilers to avoid 'unused' warnings */
-#ifndef SWIGUNUSED
-# if defined(__GNUC__)
-#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-#     define SWIGUNUSED __attribute__ ((__unused__)) 
-#   else
-#     define SWIGUNUSED
-#   endif
-# elif defined(__ICC)
-#   define SWIGUNUSED __attribute__ ((__unused__)) 
-# else
-#   define SWIGUNUSED 
-# endif
-#endif
-
-#ifndef SWIG_MSC_UNSUPPRESS_4505
-# if defined(_MSC_VER)
-#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
-# endif 
-#endif
-
-#ifndef SWIGUNUSEDPARM
-# ifdef __cplusplus
-#   define SWIGUNUSEDPARM(p)
-# else
-#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
-# endif
-#endif
-
-/* internal SWIG method */
-#ifndef SWIGINTERN
-# define SWIGINTERN static SWIGUNUSED
-#endif
-
-/* internal inline SWIG method */
-#ifndef SWIGINTERNINLINE
-# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
-#endif
-
-/* exporting methods */
-#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
-#  ifndef GCC_HASCLASSVISIBILITY
-#    define GCC_HASCLASSVISIBILITY
-#  endif
-#endif
-
-#ifndef SWIGEXPORT
-# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-#   if defined(STATIC_LINKED)
-#     define SWIGEXPORT
-#   else
-#     define SWIGEXPORT __declspec(dllexport)
-#   endif
-# else
-#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
-#     define SWIGEXPORT __attribute__ ((visibility("default")))
-#   else
-#     define SWIGEXPORT
-#   endif
-# endif
-#endif
-
-/* calling conventions for Windows */
-#ifndef SWIGSTDCALL
-# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-#   define SWIGSTDCALL __stdcall
-# else
-#   define SWIGSTDCALL
-# endif 
-#endif
-
-/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
-#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
-# define _CRT_SECURE_NO_DEPRECATE
-#endif
-
-/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
-#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
-# define _SCL_SECURE_NO_DEPRECATE
-#endif
-
-
-
-/* Python.h has to appear first */
-#include <Python.h>
-
-/* -----------------------------------------------------------------------------
- * swigrun.swg
- *
- * This file contains generic CAPI SWIG runtime support for pointer
- * type checking.
- * ----------------------------------------------------------------------------- */
-
-/* This should only be incremented when either the layout of swig_type_info changes,
-   or for whatever reason, the runtime changes incompatibly */
-#define SWIG_RUNTIME_VERSION "4"
-
-/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
-#ifdef SWIG_TYPE_TABLE
-# define SWIG_QUOTE_STRING(x) #x
-# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
-# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
-#else
-# define SWIG_TYPE_TABLE_NAME
-#endif
-
-/*
-  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
-  creating a static or dynamic library from the swig runtime code.
-  In 99.9% of the cases, swig just needs to declare them as 'static'.
-  
-  But only do this if is strictly necessary, ie, if you have problems
-  with your compiler or so.
-*/
-
-#ifndef SWIGRUNTIME
-# define SWIGRUNTIME SWIGINTERN
-#endif
-
-#ifndef SWIGRUNTIMEINLINE
-# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
-#endif
-
-/*  Generic buffer size */
-#ifndef SWIG_BUFFER_SIZE
-# define SWIG_BUFFER_SIZE 1024
-#endif
-
-/* Flags for pointer conversions */
-#define SWIG_POINTER_DISOWN        0x1
-#define SWIG_CAST_NEW_MEMORY       0x2
-
-/* Flags for new pointer objects */
-#define SWIG_POINTER_OWN           0x1
-
-
-/* 
-   Flags/methods for returning states.
-   
-   The swig conversion methods, as ConvertPtr, return and integer 
-   that tells if the conversion was successful or not. And if not,
-   an error code can be returned (see swigerrors.swg for the codes).
-   
-   Use the following macros/flags to set or process the returning
-   states.
-   
-   In old swig versions, you usually write code as:
-
-     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
-       // success code
-     } else {
-       //fail code
-     }
-
-   Now you can be more explicit as:
-
-    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
-    if (SWIG_IsOK(res)) {
-      // success code
-    } else {
-      // fail code
-    }
-
-   that seems to be the same, but now you can also do
-
-    Type *ptr;
-    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
-    if (SWIG_IsOK(res)) {
-      // success code
-      if (SWIG_IsNewObj(res) {
-        ...
-	delete *ptr;
-      } else {
-        ...
-      }
-    } else {
-      // fail code
-    }
-    
-   I.e., now SWIG_ConvertPtr can return new objects and you can
-   identify the case and take care of the deallocation. Of course that
-   requires also to SWIG_ConvertPtr to return new result values, as
-
-      int SWIG_ConvertPtr(obj, ptr,...) {         
-        if (<obj is ok>) {			       
-          if (<need new object>) {		       
-            *ptr = <ptr to new allocated object>; 
-            return SWIG_NEWOBJ;		       
-          } else {				       
-            *ptr = <ptr to old object>;	       
-            return SWIG_OLDOBJ;		       
-          } 				       
-        } else {				       
-          return SWIG_BADOBJ;		       
-        }					       
-      }
-
-   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
-   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
-   swig errors code.
-
-   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
-   allows to return the 'cast rank', for example, if you have this
-
-       int food(double)
-       int fooi(int);
-
-   and you call
- 
-      food(1)   // cast rank '1'  (1 -> 1.0)
-      fooi(1)   // cast rank '0'
-
-   just use the SWIG_AddCast()/SWIG_CheckState()
-
-
- */
-#define SWIG_OK                    (0) 
-#define SWIG_ERROR                 (-1)
-#define SWIG_IsOK(r)               (r >= 0)
-#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
-
-/* The CastRankLimit says how many bits are used for the cast rank */
-#define SWIG_CASTRANKLIMIT         (1 << 8)
-/* The NewMask denotes the object was created (using new/malloc) */
-#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
-/* The TmpMask is for in/out typemaps that use temporal objects */
-#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
-/* Simple returning values */
-#define SWIG_BADOBJ                (SWIG_ERROR)
-#define SWIG_OLDOBJ                (SWIG_OK)
-#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
-#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
-/* Check, add and del mask methods */
-#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
-#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
-#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
-#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
-#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
-#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
-
-
-/* Cast-Rank Mode */
-#if defined(SWIG_CASTRANK_MODE)
-#  ifndef SWIG_TypeRank
-#    define SWIG_TypeRank             unsigned long
-#  endif
-#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
-#    define SWIG_MAXCASTRANK          (2)
-#  endif
-#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
-#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
-SWIGINTERNINLINE int SWIG_AddCast(int r) { 
-  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
-}
-SWIGINTERNINLINE int SWIG_CheckState(int r) { 
-  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
-}
-#else /* no cast-rank mode */
-#  define SWIG_AddCast
-#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
-#endif
-
-
-
-
-#include <string.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void *(*swig_converter_func)(void *, int *);
-typedef struct swig_type_info *(*swig_dycast_func)(void **);
-
-/* Structure to store information on one type */
-typedef struct swig_type_info {
-  const char             *name;			/* mangled name of this type */
-  const char             *str;			/* human readable name of this type */
-  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
-  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
-  void                   *clientdata;		/* language specific type data */
-  int                    owndata;		/* flag if the structure owns the clientdata */
-} swig_type_info;
-
-/* Structure to store a type and conversion function used for casting */
-typedef struct swig_cast_info {
-  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
-  swig_converter_func     converter;		/* function to cast the void pointers */
-  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
-  struct swig_cast_info  *prev;			/* pointer to the previous cast */
-} swig_cast_info;
-
-/* Structure used to store module information
- * Each module generates one structure like this, and the runtime collects
- * all of these structures and stores them in a circularly linked list.*/
-typedef struct swig_module_info {
-  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
-  size_t                 size;		        /* Number of types in this module */
-  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
-  swig_type_info         **type_initial;	/* Array of initially generated type structures */
-  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
-  void                    *clientdata;		/* Language specific module data */
-} swig_module_info;
-
-/* 
-  Compare two type names skipping the space characters, therefore
-  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
-
-  Return 0 when the two name types are equivalent, as in
-  strncmp, but skipping ' '.
-*/
-SWIGRUNTIME int
-SWIG_TypeNameComp(const char *f1, const char *l1,
-		  const char *f2, const char *l2) {
-  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
-    while ((*f1 == ' ') && (f1 != l1)) ++f1;
-    while ((*f2 == ' ') && (f2 != l2)) ++f2;
-    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
-  }
-  return (int)((l1 - f1) - (l2 - f2));
-}
-
-/*
-  Check type equivalence in a name list like <name1>|<name2>|...
-  Return 0 if not equal, 1 if equal
-*/
-SWIGRUNTIME int
-SWIG_TypeEquiv(const char *nb, const char *tb) {
-  int equiv = 0;
-  const char* te = tb + strlen(tb);
-  const char* ne = nb;
-  while (!equiv && *ne) {
-    for (nb = ne; *ne; ++ne) {
-      if (*ne == '|') break;
-    }
-    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
-    if (*ne) ++ne;
-  }
-  return equiv;
-}
-
-/*
-  Check type equivalence in a name list like <name1>|<name2>|...
-  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
-*/
-SWIGRUNTIME int
-SWIG_TypeCompare(const char *nb, const char *tb) {
-  int equiv = 0;
-  const char* te = tb + strlen(tb);
-  const char* ne = nb;
-  while (!equiv && *ne) {
-    for (nb = ne; *ne; ++ne) {
-      if (*ne == '|') break;
-    }
-    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
-    if (*ne) ++ne;
-  }
-  return equiv;
-}
-
-
-/* think of this as a c++ template<> or a scheme macro */
-#define SWIG_TypeCheck_Template(comparison, ty)         \
-  if (ty) {                                             \
-    swig_cast_info *iter = ty->cast;                    \
-    while (iter) {                                      \
-      if (comparison) {                                 \
-        if (iter == ty->cast) return iter;              \
-        /* Move iter to the top of the linked list */   \
-        iter->prev->next = iter->next;                  \
-        if (iter->next)                                 \
-          iter->next->prev = iter->prev;                \
-        iter->next = ty->cast;                          \
-        iter->prev = 0;                                 \
-        if (ty->cast) ty->cast->prev = iter;            \
-        ty->cast = iter;                                \
-        return iter;                                    \
-      }                                                 \
-      iter = iter->next;                                \
-    }                                                   \
-  }                                                     \
-  return 0
-
-/*
-  Check the typename
-*/
-SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheck(const char *c, swig_type_info *ty) {
-  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
-}
-
-/* Same as previous function, except strcmp is replaced with a pointer comparison */
-SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
-  SWIG_TypeCheck_Template(iter->type == from, into);
-}
-
-/*
-  Cast a pointer up an inheritance hierarchy
-*/
-SWIGRUNTIMEINLINE void *
-SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
-  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
-}
-
-/* 
-   Dynamic pointer casting. Down an inheritance hierarchy
-*/
-SWIGRUNTIME swig_type_info *
-SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
-  swig_type_info *lastty = ty;
-  if (!ty || !ty->dcast) return ty;
-  while (ty && (ty->dcast)) {
-    ty = (*ty->dcast)(ptr);
-    if (ty) lastty = ty;
-  }
-  return lastty;
-}
-
-/*
-  Return the name associated with this type
-*/
-SWIGRUNTIMEINLINE const char *
-SWIG_TypeName(const swig_type_info *ty) {
-  return ty->name;
-}
-
-/*
-  Return the pretty name associated with this type,
-  that is an unmangled type name in a form presentable to the user.
-*/
-SWIGRUNTIME const char *
-SWIG_TypePrettyName(const swig_type_info *type) {
-  /* The "str" field contains the equivalent pretty names of the
-     type, separated by vertical-bar characters.  We choose
-     to print the last name, as it is often (?) the most
-     specific. */
-  if (!type) return NULL;
-  if (type->str != NULL) {
-    const char *last_name = type->str;
-    const char *s;
-    for (s = type->str; *s; s++)
-      if (*s == '|') last_name = s+1;
-    return last_name;
-  }
-  else
-    return type->name;
-}
-
-/* 
-   Set the clientdata field for a type
-*/
-SWIGRUNTIME void
-SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
-  swig_cast_info *cast = ti->cast;
-  /* if (ti->clientdata == clientdata) return; */
-  ti->clientdata = clientdata;
-  
-  while (cast) {
-    if (!cast->converter) {
-      swig_type_info *tc = cast->type;
-      if (!tc->clientdata) {
-	SWIG_TypeClientData(tc, clientdata);
-      }
-    }    
-    cast = cast->next;
-  }
-}
-SWIGRUNTIME void
-SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
-  SWIG_TypeClientData(ti, clientdata);
-  ti->owndata = 1;
-}
-  
-/*
-  Search for a swig_type_info structure only by mangled name
-  Search is a O(log #types)
-  
-  We start searching at module start, and finish searching when start == end.  
-  Note: if start == end at the beginning of the function, we go all the way around
-  the circular list.
-*/
-SWIGRUNTIME swig_type_info *
-SWIG_MangledTypeQueryModule(swig_module_info *start, 
-                            swig_module_info *end, 
-		            const char *name) {
-  swig_module_info *iter = start;
-  do {
-    if (iter->size) {
-      register size_t l = 0;
-      register size_t r = iter->size - 1;
-      do {
-	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
-	register size_t i = (l + r) >> 1; 
-	const char *iname = iter->types[i]->name;
-	if (iname) {
-	  register int compare = strcmp(name, iname);
-	  if (compare == 0) {	    
-	    return iter->types[i];
-	  } else if (compare < 0) {
-	    if (i) {
-	      r = i - 1;
-	    } else {
-	      break;
-	    }
-	  } else if (compare > 0) {
-	    l = i + 1;
-	  }
-	} else {
-	  break; /* should never happen */
-	}
-      } while (l <= r);
-    }
-    iter = iter->next;
-  } while (iter != end);
-  return 0;
-}
-
-/*
-  Search for a swig_type_info structure for either a mangled name or a human readable name.
-  It first searches the mangled names of the types, which is a O(log #types)
-  If a type is not found it then searches the human readable names, which is O(#types).
-  
-  We start searching at module start, and finish searching when start == end.  
-  Note: if start == end at the beginning of the function, we go all the way around
-  the circular list.
-*/
-SWIGRUNTIME swig_type_info *
-SWIG_TypeQueryModule(swig_module_info *start, 
-                     swig_module_info *end, 
-		     const char *name) {
-  /* STEP 1: Search the name field using binary search */
-  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
-  if (ret) {
-    return ret;
-  } else {
-    /* STEP 2: If the type hasn't been found, do a complete search
-       of the str field (the human readable name) */
-    swig_module_info *iter = start;
-    do {
-      register size_t i = 0;
-      for (; i < iter->size; ++i) {
-	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
-	  return iter->types[i];
-      }
-      iter = iter->next;
-    } while (iter != end);
-  }
-  
-  /* neither found a match */
-  return 0;
-}
-
-/* 
-   Pack binary data into a string
-*/
-SWIGRUNTIME char *
-SWIG_PackData(char *c, void *ptr, size_t sz) {
-  static const char hex[17] = "0123456789abcdef";
-  register const unsigned char *u = (unsigned char *) ptr;
-  register const unsigned char *eu =  u + sz;
-  for (; u != eu; ++u) {
-    register unsigned char uu = *u;
-    *(c++) = hex[(uu & 0xf0) >> 4];
-    *(c++) = hex[uu & 0xf];
-  }
-  return c;
-}
-
-/* 
-   Unpack binary data from a string
-*/
-SWIGRUNTIME const char *
-SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
-  register unsigned char *u = (unsigned char *) ptr;
-  register const unsigned char *eu = u + sz;
-  for (; u != eu; ++u) {
-    register char d = *(c++);
-    register unsigned char uu;
-    if ((d >= '0') && (d <= '9'))
-      uu = ((d - '0') << 4);
-    else if ((d >= 'a') && (d <= 'f'))
-      uu = ((d - ('a'-10)) << 4);
-    else 
-      return (char *) 0;
-    d = *(c++);
-    if ((d >= '0') && (d <= '9'))
-      uu |= (d - '0');
-    else if ((d >= 'a') && (d <= 'f'))
-      uu |= (d - ('a'-10));
-    else 
-      return (char *) 0;
-    *u = uu;
-  }
-  return c;
-}
-
-/* 
-   Pack 'void *' into a string buffer.
-*/
-SWIGRUNTIME char *
-SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
-  char *r = buff;
-  if ((2*sizeof(void *) + 2) > bsz) return 0;
-  *(r++) = '_';
-  r = SWIG_PackData(r,&ptr,sizeof(void *));
-  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
-  strcpy(r,name);
-  return buff;
-}
-
-SWIGRUNTIME const char *
-SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
-  if (*c != '_') {
-    if (strcmp(c,"NULL") == 0) {
-      *ptr = (void *) 0;
-      return name;
-    } else {
-      return 0;
-    }
-  }
-  return SWIG_UnpackData(++c,ptr,sizeof(void *));
-}
-
-SWIGRUNTIME char *
-SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
-  char *r = buff;
-  size_t lname = (name ? strlen(name) : 0);
-  if ((2*sz + 2 + lname) > bsz) return 0;
-  *(r++) = '_';
-  r = SWIG_PackData(r,ptr,sz);
-  if (lname) {
-    strncpy(r,name,lname+1);
-  } else {
-    *r = 0;
-  }
-  return buff;
-}
-
-SWIGRUNTIME const char *
-SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
-  if (*c != '_') {
-    if (strcmp(c,"NULL") == 0) {
-      memset(ptr,0,sz);
-      return name;
-    } else {
-      return 0;
-    }
-  }
-  return SWIG_UnpackData(++c,ptr,sz);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-/*  Errors in SWIG */
-#define  SWIG_UnknownError    	   -1 
-#define  SWIG_IOError        	   -2 
-#define  SWIG_RuntimeError   	   -3 
-#define  SWIG_IndexError     	   -4 
-#define  SWIG_TypeError      	   -5 
-#define  SWIG_DivisionByZero 	   -6 
-#define  SWIG_OverflowError  	   -7 
-#define  SWIG_SyntaxError    	   -8 
-#define  SWIG_ValueError     	   -9 
-#define  SWIG_SystemError    	   -10
-#define  SWIG_AttributeError 	   -11
-#define  SWIG_MemoryError    	   -12 
-#define  SWIG_NullReferenceError   -13
-
-
-
-
-/* Add PyOS_snprintf for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
-#  define PyOS_snprintf _snprintf
-# else
-#  define PyOS_snprintf snprintf
-# endif
-#endif
-
-/* A crude PyString_FromFormat implementation for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-
-#ifndef SWIG_PYBUFFER_SIZE
-# define SWIG_PYBUFFER_SIZE 1024
-#endif
-
-static PyObject *
-PyString_FromFormat(const char *fmt, ...) {
-  va_list ap;
-  char buf[SWIG_PYBUFFER_SIZE * 2];
-  int res;
-  va_start(ap, fmt);
-  res = vsnprintf(buf, sizeof(buf), fmt, ap);
-  va_end(ap);
-  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
-}
-#endif
-
-/* Add PyObject_Del for old Pythons */
-#if PY_VERSION_HEX < 0x01060000
-# define PyObject_Del(op) PyMem_DEL((op))
-#endif
-#ifndef PyObject_DEL
-# define PyObject_DEL PyObject_Del
-#endif
-
-/* A crude PyExc_StopIteration exception for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-# ifndef PyExc_StopIteration
-#  define PyExc_StopIteration PyExc_RuntimeError
-# endif
-# ifndef PyObject_GenericGetAttr
-#  define PyObject_GenericGetAttr 0
-# endif
-#endif
-/* Py_NotImplemented is defined in 2.1 and up. */
-#if PY_VERSION_HEX < 0x02010000
-# ifndef Py_NotImplemented
-#  define Py_NotImplemented PyExc_RuntimeError
-# endif
-#endif
-
-
-/* A crude PyString_AsStringAndSize implementation for old Pythons */
-#if PY_VERSION_HEX < 0x02010000
-# ifndef PyString_AsStringAndSize
-#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
-# endif
-#endif
-
-/* PySequence_Size for old Pythons */
-#if PY_VERSION_HEX < 0x02000000
-# ifndef PySequence_Size
-#  define PySequence_Size PySequence_Length
-# endif
-#endif
-
-
-/* PyBool_FromLong for old Pythons */
-#if PY_VERSION_HEX < 0x02030000
-static
-PyObject *PyBool_FromLong(long ok)
-{
-  PyObject *result = ok ? Py_True : Py_False;
-  Py_INCREF(result);
-  return result;
-}
-#endif
-
-/* Py_ssize_t for old Pythons */
-/* This code is as recommended by: */
-/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
-#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
-typedef int Py_ssize_t;
-# define PY_SSIZE_T_MAX INT_MAX
-# define PY_SSIZE_T_MIN INT_MIN
-#endif
-
-/* -----------------------------------------------------------------------------
- * error manipulation
- * ----------------------------------------------------------------------------- */
-
-SWIGRUNTIME PyObject*
-SWIG_Python_ErrorType(int code) {
-  PyObject* type = 0;
-  switch(code) {
-  case SWIG_MemoryError:
-    type = PyExc_MemoryError;
-    break;
-  case SWIG_IOError:
-    type = PyExc_IOError;
-    break;
-  case SWIG_RuntimeError:
-    type = PyExc_RuntimeError;
-    break;
-  case SWIG_IndexError:
-    type = PyExc_IndexError;
-    break;
-  case SWIG_TypeError:
-    type = PyExc_TypeError;
-    break;
-  case SWIG_DivisionByZero:
-    type = PyExc_ZeroDivisionError;
-    break;
-  case SWIG_OverflowError:
-    type = PyExc_OverflowError;
-    break;
-  case SWIG_SyntaxError:
-    type = PyExc_SyntaxError;
-    break;
-  case SWIG_ValueError:
-    type = PyExc_ValueError;
-    break;
-  case SWIG_SystemError:
-    type = PyExc_SystemError;
-    break;
-  case SWIG_AttributeError:
-    type = PyExc_AttributeError;
-    break;
-  default:
-    type = PyExc_RuntimeError;
-  }
-  return type;
-}
-
-
-SWIGRUNTIME void
-SWIG_Python_AddErrorMsg(const char* mesg)
-{
-  PyObject *type = 0;
-  PyObject *value = 0;
-  PyObject *traceback = 0;
-
-  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
-  if (value) {
-    PyObject *old_str = PyObject_Str(value);
-    PyErr_Clear();
-    Py_XINCREF(type);
-    PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
-    Py_DECREF(old_str);
-    Py_DECREF(value);
-  } else {
-    PyErr_SetString(PyExc_RuntimeError, mesg);
-  }
-}
-
-
-
-#if defined(SWIG_PYTHON_NO_THREADS)
-#  if defined(SWIG_PYTHON_THREADS)
-#    undef SWIG_PYTHON_THREADS
-#  endif
-#endif
-#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
-#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
-#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
-#      define SWIG_PYTHON_USE_GIL
-#    endif
-#  endif
-#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
-#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
-#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
-#    endif
-#    ifdef __cplusplus /* C++ code */
-       class SWIG_Python_Thread_Block {
-         bool status;
-         PyGILState_STATE state;
-       public:
-         void end() { if (status) { PyGILState_Release(state); status = false;} }
-         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
-         ~SWIG_Python_Thread_Block() { end(); }
-       };
-       class SWIG_Python_Thread_Allow {
-         bool status;
-         PyThreadState *save;
-       public:
-         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
-         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
-         ~SWIG_Python_Thread_Allow() { end(); }
-       };
-#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
-#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
-#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
-#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
-#    else /* C code */
-#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
-#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
-#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
-#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
-#    endif
-#  else /* Old thread way, not implemented, user must provide it */
-#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
-#      define SWIG_PYTHON_INITIALIZE_THREADS
-#    endif
-#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
-#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
-#    endif
-#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
-#      define SWIG_PYTHON_THREAD_END_BLOCK
-#    endif
-#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
-#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
-#    endif
-#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
-#      define SWIG_PYTHON_THREAD_END_ALLOW
-#    endif
-#  endif
-#else /* No thread support */
-#  define SWIG_PYTHON_INITIALIZE_THREADS
-#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
-#  define SWIG_PYTHON_THREAD_END_BLOCK
-#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
-#  define SWIG_PYTHON_THREAD_END_ALLOW
-#endif
-
-/* -----------------------------------------------------------------------------
- * Python API portion that goes into the runtime
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-extern "C" {
-#if 0
-} /* cc-mode */
-#endif
-#endif
-
-/* -----------------------------------------------------------------------------
- * Constant declarations
- * ----------------------------------------------------------------------------- */
-
-/* Constant Types */
-#define SWIG_PY_POINTER 4
-#define SWIG_PY_BINARY  5
-
-/* Constant information structure */
-typedef struct swig_const_info {
-  int type;
-  char *name;
-  long lvalue;
-  double dvalue;
-  void   *pvalue;
-  swig_type_info **ptype;
-} swig_const_info;
-
-#ifdef __cplusplus
-#if 0
-{ /* cc-mode */
-#endif
-}
-#endif
-
-
-/* -----------------------------------------------------------------------------
- * See the LICENSE file for information on copyright, usage and redistribution
- * of SWIG, and the README file for authors - http://www.swig.org/release.html.
- *
- * pyrun.swg
- *
- * This file contains the runtime support for Python modules
- * and includes code for managing global variables and pointer
- * type checking.
- *
- * ----------------------------------------------------------------------------- */
-
-/* Common SWIG API */
-
-/* for raw pointers */
-#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
-#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
-#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
-#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
-#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
-#define swig_owntype                                    int
-
-/* for raw packed data */
-#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
-
-/* for class or struct pointers */
-#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
-
-/* for C or C++ function pointers */
-#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
-#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
-
-/* for C++ member pointers, ie, member methods */
-#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
-
-
-/* Runtime API */
-
-#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
-#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
-#define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
-
-#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
-#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
-#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
-#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
-#define SWIG_fail                        		goto fail					   
-
-
-/* Runtime API implementation */
-
-/* Error manipulation */
-
-SWIGINTERN void 
-SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
-  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
-  PyErr_SetObject(errtype, obj);
-  Py_DECREF(obj);
-  SWIG_PYTHON_THREAD_END_BLOCK;
-}
-
-SWIGINTERN void 
-SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
-  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-  PyErr_SetString(errtype, (char *) msg);
-  SWIG_PYTHON_THREAD_END_BLOCK;
-}
-
-#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
-
-/* Set a constant value */
-
-SWIGINTERN void
-SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
-  PyDict_SetItemString(d, (char*) name, obj);
-  Py_DECREF(obj);                            
-}
-
-/* Append a value to the result obj */
-
-SWIGINTERN PyObject*
-SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
-#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
-  if (!result) {
-    result = obj;
-  } else if (result == Py_None) {
-    Py_DECREF(result);
-    result = obj;
-  } else {
-    if (!PyList_Check(result)) {
-      PyObject *o2 = result;
-      result = PyList_New(1);
-      PyList_SetItem(result, 0, o2);
-    }
-    PyList_Append(result,obj);
-    Py_DECREF(obj);
-  }
-  return result;
-#else
-  PyObject*   o2;
-  PyObject*   o3;
-  if (!result) {
-    result = obj;
-  } else if (result == Py_None) {
-    Py_DECREF(result);
-    result = obj;
-  } else {
-    if (!PyTuple_Check(result)) {
-      o2 = result;
-      result = PyTuple_New(1);
-      PyTuple_SET_ITEM(result, 0, o2);
-    }
-    o3 = PyTuple_New(1);
-    PyTuple_SET_ITEM(o3, 0, obj);
-    o2 = result;
-    result = PySequence_Concat(o2, o3);
-    Py_DECREF(o2);
-    Py_DECREF(o3);
-  }
-  return result;
-#endif
-}
-
-/* Unpack the argument tuple */
-
-SWIGINTERN int
-SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
-{
-  if (!args) {
-    if (!min && !max) {
-      return 1;
-    } else {
-      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
-		   name, (min == max ? "" : "at least "), (int)min);
-      return 0;
-    }
-  }  
-  if (!PyTuple_Check(args)) {
-    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
-    return 0;
-  } else {
-    register Py_ssize_t l = PyTuple_GET_SIZE(args);
-    if (l < min) {
-      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
-		   name, (min == max ? "" : "at least "), (int)min, (int)l);
-      return 0;
-    } else if (l > max) {
-      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
-		   name, (min == max ? "" : "at most "), (int)max, (int)l);
-      return 0;
-    } else {
-      register int i;
-      for (i = 0; i < l; ++i) {
-	objs[i] = PyTuple_GET_ITEM(args, i);
-      }
-      for (; l < max; ++l) {
-	objs[l] = 0;
-      }
-      return i + 1;
-    }    
-  }
-}
-
-/* A functor is a function object with one single object argument */
-#if PY_VERSION_HEX >= 0x02020000
-#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
-#else
-#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
-#endif
-
-/*
-  Helper for static pointer initialization for both C and C++ code, for example
-  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
-*/
-#ifdef __cplusplus
-#define SWIG_STATIC_POINTER(var)  var
-#else
-#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
-#endif
-
-/* -----------------------------------------------------------------------------
- * Pointer declarations
- * ----------------------------------------------------------------------------- */
-
-/* Flags for new pointer objects */
-#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
-#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
-
-#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
-
-#ifdef __cplusplus
-extern "C" {
-#if 0
-} /* cc-mode */
-#endif
-#endif
-
-/*  How to access Py_None */
-#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-#  ifndef SWIG_PYTHON_NO_BUILD_NONE
-#    ifndef SWIG_PYTHON_BUILD_NONE
-#      define SWIG_PYTHON_BUILD_NONE
-#    endif
-#  endif
-#endif
-
-#ifdef SWIG_PYTHON_BUILD_NONE
-#  ifdef Py_None
-#   undef Py_None
-#   define Py_None SWIG_Py_None()
-#  endif
-SWIGRUNTIMEINLINE PyObject * 
-_SWIG_Py_None(void)
-{
-  PyObject *none = Py_BuildValue((char*)"");
-  Py_DECREF(none);
-  return none;
-}
-SWIGRUNTIME PyObject * 
-SWIG_Py_None(void)
-{
-  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
-  return none;
-}
-#endif
-
-/* The python void return value */
-
-SWIGRUNTIMEINLINE PyObject * 
-SWIG_Py_Void(void)
-{
-  PyObject *none = Py_None;
-  Py_INCREF(none);
-  return none;
-}
-
-/* PySwigClientData */
-
-typedef struct {
-  PyObject *klass;
-  PyObject *newraw;
-  PyObject *newargs;
-  PyObject *destroy;
-  int delargs;
-  int implicitconv;
-} PySwigClientData;
-
-SWIGRUNTIMEINLINE int 
-SWIG_Python_CheckImplicit(swig_type_info *ty)
-{
-  PySwigClientData *data = (PySwigClientData *)ty->clientdata;
-  return data ? data->implicitconv : 0;
-}
-
-SWIGRUNTIMEINLINE PyObject *
-SWIG_Python_ExceptionType(swig_type_info *desc) {
-  PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
-  PyObject *klass = data ? data->klass : 0;
-  return (klass ? klass : PyExc_RuntimeError);
-}
-
-
-SWIGRUNTIME PySwigClientData * 
-PySwigClientData_New(PyObject* obj)
-{
-  if (!obj) {
-    return 0;
-  } else {
-    PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
-    /* the klass element */
-    data->klass = obj;
-    Py_INCREF(data->klass);
-    /* the newraw method and newargs arguments used to create a new raw instance */
-    if (PyClass_Check(obj)) {
-      data->newraw = 0;
-      data->newargs = obj;
-      Py_INCREF(obj);
-    } else {
-#if (PY_VERSION_HEX < 0x02020000)
-      data->newraw = 0;
-#else
-      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
-#endif
-      if (data->newraw) {
-	Py_INCREF(data->newraw);
-	data->newargs = PyTuple_New(1);
-	PyTuple_SetItem(data->newargs, 0, obj);
-      } else {
-	data->newargs = obj;
-      }
-      Py_INCREF(data->newargs);
-    }
-    /* the destroy method, aka as the C++ delete method */
-    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
-    if (PyErr_Occurred()) {
-      PyErr_Clear();
-      data->destroy = 0;
-    }
-    if (data->destroy) {
-      int flags;
-      Py_INCREF(data->destroy);
-      flags = PyCFunction_GET_FLAGS(data->destroy);
-#ifdef METH_O
-      data->delargs = !(flags & (METH_O));
-#else
-      data->delargs = 0;
-#endif
-    } else {
-      data->delargs = 0;
-    }
-    data->implicitconv = 0;
-    return data;
-  }
-}
-
-SWIGRUNTIME void 
-PySwigClientData_Del(PySwigClientData* data)
-{
-  Py_XDECREF(data->newraw);
-  Py_XDECREF(data->newargs);
-  Py_XDECREF(data->destroy);
-}
-
-/* =============== PySwigObject =====================*/
-
-typedef struct {
-  PyObject_HEAD
-  void *ptr;
-  swig_type_info *ty;
-  int own;
-  PyObject *next;
-} PySwigObject;
-
-SWIGRUNTIME PyObject *
-PySwigObject_long(PySwigObject *v)
-{
-  return PyLong_FromVoidPtr(v->ptr);
-}
-
-SWIGRUNTIME PyObject *
-PySwigObject_format(const char* fmt, PySwigObject *v)
-{
-  PyObject *res = NULL;
-  PyObject *args = PyTuple_New(1);
-  if (args) {
-    if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
-      PyObject *ofmt = PyString_FromString(fmt);
-      if (ofmt) {
-	res = PyString_Format(ofmt,args);
-	Py_DECREF(ofmt);
-      }
-      Py_DECREF(args);
-    }
-  }
-  return res;
-}
-
-SWIGRUNTIME PyObject *
-PySwigObject_oct(PySwigObject *v)
-{
-  return PySwigObject_format("%o",v);
-}
-
-SWIGRUNTIME PyObject *
-PySwigObject_hex(PySwigObject *v)
-{
-  return PySwigObject_format("%x",v);
-}
-
-SWIGRUNTIME PyObject *
-#ifdef METH_NOARGS
-PySwigObject_repr(PySwigObject *v)
-#else
-PySwigObject_repr(PySwigObject *v, PyObject *args)
-#endif
-{
-  const char *name = SWIG_TypePrettyName(v->ty);
-  PyObject *hex = PySwigObject_hex(v);    
-  PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
-  Py_DECREF(hex);
-  if (v->next) {
-#ifdef METH_NOARGS
-    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
-#else
-    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
-#endif
-    PyString_ConcatAndDel(&repr,nrep);
-  }
-  return repr;  
-}
-
-SWIGRUNTIME int
-PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
-{
-#ifdef METH_NOARGS
-  PyObject *repr = PySwigObject_repr(v);
-#else
-  PyObject *repr = PySwigObject_repr(v, NULL);
-#endif
-  if (repr) {
-    fputs(PyString_AsString(repr), fp);
-    Py_DECREF(repr);
-    return 0; 
-  } else {
-    return 1; 
-  }
-}
-
-SWIGRUNTIME PyObject *
-PySwigObject_str(PySwigObject *v)
-{
-  char result[SWIG_BUFFER_SIZE];
-  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
-    PyString_FromString(result) : 0;
-}
-
-SWIGRUNTIME int
-PySwigObject_compare(PySwigObject *v, PySwigObject *w)
-{
-  void *i = v->ptr;
-  void *j = w->ptr;
-  return (i < j) ? -1 : ((i > j) ? 1 : 0);
-}
-
-SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
-
-SWIGRUNTIME PyTypeObject*
-PySwigObject_type(void) {
-  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
-  return type;
-}
-
-SWIGRUNTIMEINLINE int
-PySwigObject_Check(PyObject *op) {
-  return ((op)->ob_type == PySwigObject_type())
-    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
-}
-
-SWIGRUNTIME PyObject *
-PySwigObject_New(void *ptr, swig_type_info *ty, int own);
-
-SWIGRUNTIME void
-PySwigObject_dealloc(PyObject *v)
-{
-  PySwigObject *sobj = (PySwigObject *) v;
-  PyObject *next = sobj->next;
-  if (sobj->own == SWIG_POINTER_OWN) {
-    swig_type_info *ty = sobj->ty;
-    PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
-    PyObject *destroy = data ? data->destroy : 0;
-    if (destroy) {
-      /* destroy is always a VARARGS method */
-      PyObject *res;
-      if (data->delargs) {
-	/* we need to create a temporal object to carry the destroy operation */
-	PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
-	res = SWIG_Python_CallFunctor(destroy, tmp);
-	Py_DECREF(tmp);
-      } else {
-	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
-	PyObject *mself = PyCFunction_GET_SELF(destroy);
-	res = ((*meth)(mself, v));
-      }
-      Py_XDECREF(res);
-    } 
-#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
-    else {
-      const char *name = SWIG_TypePrettyName(ty);
-      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
-    }
-#endif
-  } 
-  Py_XDECREF(next);
-  PyObject_DEL(v);
-}
-
-SWIGRUNTIME PyObject* 
-PySwigObject_append(PyObject* v, PyObject* next)
-{
-  PySwigObject *sobj = (PySwigObject *) v;
-#ifndef METH_O
-  PyObject *tmp = 0;
-  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
-  next = tmp;
-#endif
-  if (!PySwigObject_Check(next)) {
-    return NULL;
-  }
-  sobj->next = next;
-  Py_INCREF(next);
-  return SWIG_Py_Void();
-}
-
-SWIGRUNTIME PyObject* 
-#ifdef METH_NOARGS
-PySwigObject_next(PyObject* v)
-#else
-PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
-{
-  PySwigObject *sobj = (PySwigObject *) v;
-  if (sobj->next) {    
-    Py_INCREF(sobj->next);
-    return sobj->next;
-  } else {
-    return SWIG_Py_Void();
-  }
-}
-
-SWIGINTERN PyObject*
-#ifdef METH_NOARGS
-PySwigObject_disown(PyObject *v)
-#else
-PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
-{
-  PySwigObject *sobj = (PySwigObject *)v;
-  sobj->own = 0;
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject*
-#ifdef METH_NOARGS
-PySwigObject_acquire(PyObject *v)
-#else
-PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
-{
-  PySwigObject *sobj = (PySwigObject *)v;
-  sobj->own = SWIG_POINTER_OWN;
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject*
-PySwigObject_own(PyObject *v, PyObject *args)
-{
-  PyObject *val = 0;
-#if (PY_VERSION_HEX < 0x02020000)
-  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
-#else
-  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
-#endif
-    {
-      return NULL;
-    } 
-  else
-    {
-      PySwigObject *sobj = (PySwigObject *)v;
-      PyObject *obj = PyBool_FromLong(sobj->own);
-      if (val) {
-#ifdef METH_NOARGS
-	if (PyObject_IsTrue(val)) {
-	  PySwigObject_acquire(v);
-	} else {
-	  PySwigObject_disown(v);
-	}
-#else
-	if (PyObject_IsTrue(val)) {
-	  PySwigObject_acquire(v,args);
-	} else {
-	  PySwigObject_disown(v,args);
-	}
-#endif
-      } 
-      return obj;
-    }
-}
-
-#ifdef METH_O
-static PyMethodDef
-swigobject_methods[] = {
-  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
-  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
-  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
-  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
-  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
-  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
-  {0, 0, 0, 0}  
-};
-#else
-static PyMethodDef
-swigobject_methods[] = {
-  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
-  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
-  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
-  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
-  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
-  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
-  {0, 0, 0, 0}  
-};
-#endif
-
-#if PY_VERSION_HEX < 0x02020000
-SWIGINTERN PyObject *
-PySwigObject_getattr(PySwigObject *sobj,char *name)
-{
-  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
-}
-#endif
-
-SWIGRUNTIME PyTypeObject*
-_PySwigObject_type(void) {
-  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
-  
-  static PyNumberMethods PySwigObject_as_number = {
-    (binaryfunc)0, /*nb_add*/
-    (binaryfunc)0, /*nb_subtract*/
-    (binaryfunc)0, /*nb_multiply*/
-    (binaryfunc)0, /*nb_divide*/
-    (binaryfunc)0, /*nb_remainder*/
-    (binaryfunc)0, /*nb_divmod*/
-    (ternaryfunc)0,/*nb_power*/
-    (unaryfunc)0,  /*nb_negative*/
-    (unaryfunc)0,  /*nb_positive*/
-    (unaryfunc)0,  /*nb_absolute*/
-    (inquiry)0,    /*nb_nonzero*/
-    0,		   /*nb_invert*/
-    0,		   /*nb_lshift*/
-    0,		   /*nb_rshift*/
-    0,		   /*nb_and*/
-    0,		   /*nb_xor*/
-    0,		   /*nb_or*/
-    (coercion)0,   /*nb_coerce*/
-    (unaryfunc)PySwigObject_long, /*nb_int*/
-    (unaryfunc)PySwigObject_long, /*nb_long*/
-    (unaryfunc)0,                 /*nb_float*/
-    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
-    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
-#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
-#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
-#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
-    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
-#endif
-  };
-
-  static PyTypeObject pyswigobject_type;  
-  static int type_init = 0;
-  if (!type_init) {
-    const PyTypeObject tmp
-      = {
-	PyObject_HEAD_INIT(NULL)
-	0,				    /* ob_size */
-	(char *)"PySwigObject",		    /* tp_name */
-	sizeof(PySwigObject),		    /* tp_basicsize */
-	0,			            /* tp_itemsize */
-	(destructor)PySwigObject_dealloc,   /* tp_dealloc */
-	(printfunc)PySwigObject_print,	    /* tp_print */
-#if PY_VERSION_HEX < 0x02020000
-	(getattrfunc)PySwigObject_getattr,  /* tp_getattr */ 
-#else
-	(getattrfunc)0,			    /* tp_getattr */ 
-#endif
-	(setattrfunc)0,			    /* tp_setattr */ 
-	(cmpfunc)PySwigObject_compare,	    /* tp_compare */ 
-	(reprfunc)PySwigObject_repr,	    /* tp_repr */    
-	&PySwigObject_as_number,	    /* tp_as_number */
-	0,				    /* tp_as_sequence */
-	0,				    /* tp_as_mapping */
-	(hashfunc)0,			    /* tp_hash */
-	(ternaryfunc)0,			    /* tp_call */
-	(reprfunc)PySwigObject_str,	    /* tp_str */
-	PyObject_GenericGetAttr,            /* tp_getattro */
-	0,				    /* tp_setattro */
-	0,		                    /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT,	            /* tp_flags */
-	swigobject_doc, 	            /* tp_doc */        
-	0,                                  /* tp_traverse */
-	0,                                  /* tp_clear */
-	0,                                  /* tp_richcompare */
-	0,                                  /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
-	0,                                  /* tp_iter */
-	0,                                  /* tp_iternext */
-	swigobject_methods,		    /* tp_methods */ 
-	0,			            /* tp_members */
-	0,				    /* tp_getset */	    	
-	0,			            /* tp_base */	        
-	0,				    /* tp_dict */	    	
-	0,				    /* tp_descr_get */  	
-	0,				    /* tp_descr_set */  	
-	0,				    /* tp_dictoffset */ 	
-	0,				    /* tp_init */	    	
-	0,				    /* tp_alloc */	    	
-	0,			            /* tp_new */	    	
-	0,	                            /* tp_free */	   
-        0,                                  /* tp_is_gc */  
-	0,				    /* tp_bases */   
-	0,				    /* tp_mro */
-	0,				    /* tp_cache */   
- 	0,				    /* tp_subclasses */
-	0,				    /* tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
-	0,                                  /* tp_del */
-#endif
-#ifdef COUNT_ALLOCS
-	0,0,0,0                             /* tp_alloc -> tp_next */
-#endif
-      };
-    pyswigobject_type = tmp;
-    pyswigobject_type.ob_type = &PyType_Type;
-    type_init = 1;
-  }
-  return &pyswigobject_type;
-}
-
-SWIGRUNTIME PyObject *
-PySwigObject_New(void *ptr, swig_type_info *ty, int own)
-{
-  PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
-  if (sobj) {
-    sobj->ptr  = ptr;
-    sobj->ty   = ty;
-    sobj->own  = own;
-    sobj->next = 0;
-  }
-  return (PyObject *)sobj;
-}
-
-/* -----------------------------------------------------------------------------
- * Implements a simple Swig Packed type, and use it instead of string
- * ----------------------------------------------------------------------------- */
-
-typedef struct {
-  PyObject_HEAD
-  void *pack;
-  swig_type_info *ty;
-  size_t size;
-} PySwigPacked;
-
-SWIGRUNTIME int
-PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
-{
-  char result[SWIG_BUFFER_SIZE];
-  fputs("<Swig Packed ", fp); 
-  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
-    fputs("at ", fp); 
-    fputs(result, fp); 
-  }
-  fputs(v->ty->name,fp); 
-  fputs(">", fp);
-  return 0; 
-}
-  
-SWIGRUNTIME PyObject *
-PySwigPacked_repr(PySwigPacked *v)
-{
-  char result[SWIG_BUFFER_SIZE];
-  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
-    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
-  } else {
-    return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
-  }  
-}
-
-SWIGRUNTIME PyObject *
-PySwigPacked_str(PySwigPacked *v)
-{
-  char result[SWIG_BUFFER_SIZE];
-  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
-    return PyString_FromFormat("%s%s", result, v->ty->name);
-  } else {
-    return PyString_FromString(v->ty->name);
-  }  
-}
-
-SWIGRUNTIME int
-PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
-{
-  size_t i = v->size;
-  size_t j = w->size;
-  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
-  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
-}
-
-SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
-
-SWIGRUNTIME PyTypeObject*
-PySwigPacked_type(void) {
-  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
-  return type;
-}
-
-SWIGRUNTIMEINLINE int
-PySwigPacked_Check(PyObject *op) {
-  return ((op)->ob_type == _PySwigPacked_type()) 
-    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
-}
-
-SWIGRUNTIME void
-PySwigPacked_dealloc(PyObject *v)
-{
-  if (PySwigPacked_Check(v)) {
-    PySwigPacked *sobj = (PySwigPacked *) v;
-    free(sobj->pack);
-  }
-  PyObject_DEL(v);
-}
-
-SWIGRUNTIME PyTypeObject*
-_PySwigPacked_type(void) {
-  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
-  static PyTypeObject pyswigpacked_type;
-  static int type_init = 0;  
-  if (!type_init) {
-    const PyTypeObject tmp
-      = {
-	PyObject_HEAD_INIT(NULL)
-	0,				    /* ob_size */	
-	(char *)"PySwigPacked",		    /* tp_name */	
-	sizeof(PySwigPacked),		    /* tp_basicsize */	
-	0,				    /* tp_itemsize */	
-	(destructor)PySwigPacked_dealloc,   /* tp_dealloc */	
-	(printfunc)PySwigPacked_print,	    /* tp_print */   	
-	(getattrfunc)0,			    /* tp_getattr */ 	
-	(setattrfunc)0,			    /* tp_setattr */ 	
-	(cmpfunc)PySwigPacked_compare,	    /* tp_compare */ 	
-	(reprfunc)PySwigPacked_repr,	    /* tp_repr */    	
-	0,	                            /* tp_as_number */	
-	0,				    /* tp_as_sequence */
-	0,				    /* tp_as_mapping */	
-	(hashfunc)0,			    /* tp_hash */	
-	(ternaryfunc)0,			    /* tp_call */	
-	(reprfunc)PySwigPacked_str,	    /* tp_str */	
-	PyObject_GenericGetAttr,            /* tp_getattro */
-	0,				    /* tp_setattro */
-	0,		                    /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT,	            /* tp_flags */
-	swigpacked_doc, 	            /* tp_doc */
-	0,                                  /* tp_traverse */
-	0,                                  /* tp_clear */
-	0,                                  /* tp_richcompare */
-	0,                                  /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
-	0,                                  /* tp_iter */
-	0,                                  /* tp_iternext */
-	0,		                    /* tp_methods */ 
-	0,			            /* tp_members */
-	0,				    /* tp_getset */	    	
-	0,			            /* tp_base */	        
-	0,				    /* tp_dict */	    	
-	0,				    /* tp_descr_get */  	
-	0,				    /* tp_descr_set */  	
-	0,				    /* tp_dictoffset */ 	
-	0,				    /* tp_init */	    	
-	0,				    /* tp_alloc */	    	
-	0,			            /* tp_new */	    	
-	0, 	                            /* tp_free */	   
-        0,                                  /* tp_is_gc */  
-	0,				    /* tp_bases */   
-	0,				    /* tp_mro */
-	0,				    /* tp_cache */   
- 	0,				    /* tp_subclasses */
-	0,				    /* tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
-	0,                                  /* tp_del */
-#endif
-#ifdef COUNT_ALLOCS
-	0,0,0,0                             /* tp_alloc -> tp_next */
-#endif
-      };
-    pyswigpacked_type = tmp;
-    pyswigpacked_type.ob_type = &PyType_Type;
-    type_init = 1;
-  }
-  return &pyswigpacked_type;
-}
-
-SWIGRUNTIME PyObject *
-PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
-{
-  PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
-  if (sobj) {
-    void *pack = malloc(size);
-    if (pack) {
-      memcpy(pack, ptr, size);
-      sobj->pack = pack;
-      sobj->ty   = ty;
-      sobj->size = size;
-    } else {
-      PyObject_DEL((PyObject *) sobj);
-      sobj = 0;
-    }
-  }
-  return (PyObject *) sobj;
-}
-
-SWIGRUNTIME swig_type_info *
-PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
-{
-  if (PySwigPacked_Check(obj)) {
-    PySwigPacked *sobj = (PySwigPacked *)obj;
-    if (sobj->size != size) return 0;
-    memcpy(ptr, sobj->pack, size);
-    return sobj->ty;
-  } else {
-    return 0;
-  }
-}
-
-/* -----------------------------------------------------------------------------
- * pointers/data manipulation
- * ----------------------------------------------------------------------------- */
-
-SWIGRUNTIMEINLINE PyObject *
-_SWIG_This(void)
-{
-  return PyString_FromString("this");
-}
-
-SWIGRUNTIME PyObject *
-SWIG_This(void)
-{
-  static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
-  return swig_this;
-}
-
-/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
-
-SWIGRUNTIME PySwigObject *
-SWIG_Python_GetSwigThis(PyObject *pyobj) 
-{
-  if (PySwigObject_Check(pyobj)) {
-    return (PySwigObject *) pyobj;
-  } else {
-    PyObject *obj = 0;
-#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
-    if (PyInstance_Check(pyobj)) {
-      obj = _PyInstance_Lookup(pyobj, SWIG_This());      
-    } else {
-      PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
-      if (dictptr != NULL) {
-	PyObject *dict = *dictptr;
-	obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
-      } else {
-#ifdef PyWeakref_CheckProxy
-	if (PyWeakref_CheckProxy(pyobj)) {
-	  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
-	  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
-	}
-#endif
-	obj = PyObject_GetAttr(pyobj,SWIG_This());
-	if (obj) {
-	  Py_DECREF(obj);
-	} else {
-	  if (PyErr_Occurred()) PyErr_Clear();
-	  return 0;
-	}
-      }
-    }
-#else
-    obj = PyObject_GetAttr(pyobj,SWIG_This());
-    if (obj) {
-      Py_DECREF(obj);
-    } else {
-      if (PyErr_Occurred()) PyErr_Clear();
-      return 0;
-    }
-#endif
-    if (obj && !PySwigObject_Check(obj)) {
-      /* a PyObject is called 'this', try to get the 'real this'
-	 PySwigObject from it */ 
-      return SWIG_Python_GetSwigThis(obj);
-    }
-    return (PySwigObject *)obj;
-  }
-}
-
-/* Acquire a pointer value */
-
-SWIGRUNTIME int
-SWIG_Python_AcquirePtr(PyObject *obj, int own) {
-  if (own == SWIG_POINTER_OWN) {
-    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
-    if (sobj) {
-      int oldown = sobj->own;
-      sobj->own = own;
-      return oldown;
-    }
-  }
-  return 0;
-}
-
-/* Convert a pointer value */
-
-SWIGRUNTIME int
-SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
-  if (!obj) return SWIG_ERROR;
-  if (obj == Py_None) {
-    if (ptr) *ptr = 0;
-    return SWIG_OK;
-  } else {
-    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
-    if (own)
-      *own = 0;
-    while (sobj) {
-      void *vptr = sobj->ptr;
-      if (ty) {
-	swig_type_info *to = sobj->ty;
-	if (to == ty) {
-	  /* no type cast needed */
-	  if (ptr) *ptr = vptr;
-	  break;
-	} else {
-	  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
-	  if (!tc) {
-	    sobj = (PySwigObject *)sobj->next;
-	  } else {
-	    if (ptr) {
-              int newmemory = 0;
-              *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
-              if (newmemory == SWIG_CAST_NEW_MEMORY) {
-                assert(own);
-                if (own)
-                  *own = *own | SWIG_CAST_NEW_MEMORY;
-              }
-            }
-	    break;
-	  }
-	}
-      } else {
-	if (ptr) *ptr = vptr;
-	break;
-      }
-    }
-    if (sobj) {
-      if (own)
-        *own = *own | sobj->own;
-      if (flags & SWIG_POINTER_DISOWN) {
-	sobj->own = 0;
-      }
-      return SWIG_OK;
-    } else {
-      int res = SWIG_ERROR;
-      if (flags & SWIG_POINTER_IMPLICIT_CONV) {
-	PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
-	if (data && !data->implicitconv) {
-	  PyObject *klass = data->klass;
-	  if (klass) {
-	    PyObject *impconv;
-	    data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
-	    impconv = SWIG_Python_CallFunctor(klass, obj);
-	    data->implicitconv = 0;
-	    if (PyErr_Occurred()) {
-	      PyErr_Clear();
-	      impconv = 0;
-	    }
-	    if (impconv) {
-	      PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
-	      if (iobj) {
-		void *vptr;
-		res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
-		if (SWIG_IsOK(res)) {
-		  if (ptr) {
-		    *ptr = vptr;
-		    /* transfer the ownership to 'ptr' */
-		    iobj->own = 0;
-		    res = SWIG_AddCast(res);
-		    res = SWIG_AddNewMask(res);
-		  } else {
-		    res = SWIG_AddCast(res);		    
-		  }
-		}
-	      }
-	      Py_DECREF(impconv);
-	    }
-	  }
-	}
-      }
-      return res;
-    }
-  }
-}
-
-/* Convert a function ptr value */
-
-SWIGRUNTIME int
-SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
-  if (!PyCFunction_Check(obj)) {
-    return SWIG_ConvertPtr(obj, ptr, ty, 0);
-  } else {
-    void *vptr = 0;
-    
-    /* here we get the method pointer for callbacks */
-    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
-    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
-    if (desc) {
-      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
-      if (!desc) return SWIG_ERROR;
-    }
-    if (ty) {
-      swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
-      if (tc) {
-        int newmemory = 0;
-        *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
-        assert(!newmemory); /* newmemory handling not yet implemented */
-      } else {
-        return SWIG_ERROR;
-      }
-    } else {
-      *ptr = vptr;
-    }
-    return SWIG_OK;
-  }
-}
-
-/* Convert a packed value value */
-
-SWIGRUNTIME int
-SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
-  swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
-  if (!to) return SWIG_ERROR;
-  if (ty) {
-    if (to != ty) {
-      /* check type cast? */
-      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
-      if (!tc) return SWIG_ERROR;
-    }
-  }
-  return SWIG_OK;
-}  
-
-/* -----------------------------------------------------------------------------
- * Create a new pointer object
- * ----------------------------------------------------------------------------- */
-
-/*
-  Create a new instance object, whitout calling __init__, and set the
-  'this' attribute.
-*/
-
-SWIGRUNTIME PyObject* 
-SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
-{
-#if (PY_VERSION_HEX >= 0x02020000)
-  PyObject *inst = 0;
-  PyObject *newraw = data->newraw;
-  if (newraw) {
-    inst = PyObject_Call(newraw, data->newargs, NULL);
-    if (inst) {
-#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
-      PyObject **dictptr = _PyObject_GetDictPtr(inst);
-      if (dictptr != NULL) {
-	PyObject *dict = *dictptr;
-	if (dict == NULL) {
-	  dict = PyDict_New();
-	  *dictptr = dict;
-	  PyDict_SetItem(dict, SWIG_This(), swig_this);
-	}
-      }
-#else
-      PyObject *key = SWIG_This();
-      PyObject_SetAttr(inst, key, swig_this);
-#endif
-    }
-  } else {
-    PyObject *dict = PyDict_New();
-    PyDict_SetItem(dict, SWIG_This(), swig_this);
-    inst = PyInstance_NewRaw(data->newargs, dict);
-    Py_DECREF(dict);
-  }
-  return inst;
-#else
-#if (PY_VERSION_HEX >= 0x02010000)
-  PyObject *inst;
-  PyObject *dict = PyDict_New();
-  PyDict_SetItem(dict, SWIG_This(), swig_this);
-  inst = PyInstance_NewRaw(data->newargs, dict);
-  Py_DECREF(dict);
-  return (PyObject *) inst;
-#else
-  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
-  if (inst == NULL) {
-    return NULL;
-  }
-  inst->in_class = (PyClassObject *)data->newargs;
-  Py_INCREF(inst->in_class);
-  inst->in_dict = PyDict_New();
-  if (inst->in_dict == NULL) {
-    Py_DECREF(inst);
-    return NULL;
-  }
-#ifdef Py_TPFLAGS_HAVE_WEAKREFS
-  inst->in_weakreflist = NULL;
-#endif
-#ifdef Py_TPFLAGS_GC
-  PyObject_GC_Init(inst);
-#endif
-  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
-  return (PyObject *) inst;
-#endif
-#endif
-}
-
-SWIGRUNTIME void
-SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
-{
- PyObject *dict;
-#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
- PyObject **dictptr = _PyObject_GetDictPtr(inst);
- if (dictptr != NULL) {
-   dict = *dictptr;
-   if (dict == NULL) {
-     dict = PyDict_New();
-     *dictptr = dict;
-   }
-   PyDict_SetItem(dict, SWIG_This(), swig_this);
-   return;
- }
-#endif
- dict = PyObject_GetAttrString(inst, (char*)"__dict__");
- PyDict_SetItem(dict, SWIG_This(), swig_this);
- Py_DECREF(dict);
-} 
-
-
-SWIGINTERN PyObject *
-SWIG_Python_InitShadowInstance(PyObject *args) {
-  PyObject *obj[2];
-  if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
-    return NULL;
-  } else {
-    PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
-    if (sthis) {
-      PySwigObject_append((PyObject*) sthis, obj[1]);
-    } else {
-      SWIG_Python_SetSwigThis(obj[0], obj[1]);
-    }
-    return SWIG_Py_Void();
-  }
-}
-
-/* Create a new pointer object */
-
-SWIGRUNTIME PyObject *
-SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
-  if (!ptr) {
-    return SWIG_Py_Void();
-  } else {
-    int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
-    PyObject *robj = PySwigObject_New(ptr, type, own);
-    PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
-    if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
-      PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
-      if (inst) {
-	Py_DECREF(robj);
-	robj = inst;
-      }
-    }
-    return robj;
-  }
-}
-
-/* Create a new packed object */
-
-SWIGRUNTIMEINLINE PyObject *
-SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
-  return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
-}
-
-/* -----------------------------------------------------------------------------*
- *  Get type list 
- * -----------------------------------------------------------------------------*/
-
-#ifdef SWIG_LINK_RUNTIME
-void *SWIG_ReturnGlobalTypeList(void *);
-#endif
-
-SWIGRUNTIME swig_module_info *
-SWIG_Python_GetModule(void) {
-  static void *type_pointer = (void *)0;
-  /* first check if module already created */
-  if (!type_pointer) {
-#ifdef SWIG_LINK_RUNTIME
-    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
-#else
-    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
-				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
-    if (PyErr_Occurred()) {
-      PyErr_Clear();
-      type_pointer = (void *)0;
-    }
-#endif
-  }
-  return (swig_module_info *) type_pointer;
-}
-
-#if PY_MAJOR_VERSION < 2
-/* PyModule_AddObject function was introduced in Python 2.0.  The following function
-   is copied out of Python/modsupport.c in python version 2.3.4 */
-SWIGINTERN int
-PyModule_AddObject(PyObject *m, char *name, PyObject *o)
-{
-  PyObject *dict;
-  if (!PyModule_Check(m)) {
-    PyErr_SetString(PyExc_TypeError,
-		    "PyModule_AddObject() needs module as first arg");
-    return SWIG_ERROR;
-  }
-  if (!o) {
-    PyErr_SetString(PyExc_TypeError,
-		    "PyModule_AddObject() needs non-NULL value");
-    return SWIG_ERROR;
-  }
-  
-  dict = PyModule_GetDict(m);
-  if (dict == NULL) {
-    /* Internal error -- modules must have a dict! */
-    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
-		 PyModule_GetName(m));
-    return SWIG_ERROR;
-  }
-  if (PyDict_SetItemString(dict, name, o))
-    return SWIG_ERROR;
-  Py_DECREF(o);
-  return SWIG_OK;
-}
-#endif
-
-SWIGRUNTIME void
-SWIG_Python_DestroyModule(void *vptr)
-{
-  swig_module_info *swig_module = (swig_module_info *) vptr;
-  swig_type_info **types = swig_module->types;
-  size_t i;
-  for (i =0; i < swig_module->size; ++i) {
-    swig_type_info *ty = types[i];
-    if (ty->owndata) {
-      PySwigClientData *data = (PySwigClientData *) ty->clientdata;
-      if (data) PySwigClientData_Del(data);
-    }
-  }
-  Py_DECREF(SWIG_This());
-}
-
-SWIGRUNTIME void
-SWIG_Python_SetModule(swig_module_info *swig_module) {
-  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
-
-  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
-				   swig_empty_runtime_method_table);
-  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
-  if (pointer && module) {
-    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
-  } else {
-    Py_XDECREF(pointer);
-  }
-}
-
-/* The python cached type query */
-SWIGRUNTIME PyObject *
-SWIG_Python_TypeCache(void) {
-  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
-  return cache;
-}
-
-SWIGRUNTIME swig_type_info *
-SWIG_Python_TypeQuery(const char *type)
-{
-  PyObject *cache = SWIG_Python_TypeCache();
-  PyObject *key = PyString_FromString(type); 
-  PyObject *obj = PyDict_GetItem(cache, key);
-  swig_type_info *descriptor;
-  if (obj) {
-    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
-  } else {
-    swig_module_info *swig_module = SWIG_Python_GetModule();
-    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
-    if (descriptor) {
-      obj = PyCObject_FromVoidPtr(descriptor, NULL);
-      PyDict_SetItem(cache, key, obj);
-      Py_DECREF(obj);
-    }
-  }
-  Py_DECREF(key);
-  return descriptor;
-}
-
-/* 
-   For backward compatibility only
-*/
-#define SWIG_POINTER_EXCEPTION  0
-#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
-#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
-
-SWIGRUNTIME int
-SWIG_Python_AddErrMesg(const char* mesg, int infront)
-{
-  if (PyErr_Occurred()) {
-    PyObject *type = 0;
-    PyObject *value = 0;
-    PyObject *traceback = 0;
-    PyErr_Fetch(&type, &value, &traceback);
-    if (value) {
-      PyObject *old_str = PyObject_Str(value);
-      Py_XINCREF(type);
-      PyErr_Clear();
-      if (infront) {
-	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
-      } else {
-	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
-      }
-      Py_DECREF(old_str);
-    }
-    return 1;
-  } else {
-    return 0;
-  }
-}
-  
-SWIGRUNTIME int
-SWIG_Python_ArgFail(int argnum)
-{
-  if (PyErr_Occurred()) {
-    /* add information about failing argument */
-    char mesg[256];
-    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
-    return SWIG_Python_AddErrMesg(mesg, 1);
-  } else {
-    return 0;
-  }
-}
-
-SWIGRUNTIMEINLINE const char *
-PySwigObject_GetDesc(PyObject *self)
-{
-  PySwigObject *v = (PySwigObject *)self;
-  swig_type_info *ty = v ? v->ty : 0;
-  return ty ? ty->str : (char*)"";
-}
-
-SWIGRUNTIME void
-SWIG_Python_TypeError(const char *type, PyObject *obj)
-{
-  if (type) {
-#if defined(SWIG_COBJECT_TYPES)
-    if (obj && PySwigObject_Check(obj)) {
-      const char *otype = (const char *) PySwigObject_GetDesc(obj);
-      if (otype) {
-	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
-		     type, otype);
-	return;
-      }
-    } else 
-#endif      
-    {
-      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
-      if (otype) {
-	PyObject *str = PyObject_Str(obj);
-	const char *cstr = str ? PyString_AsString(str) : 0;
-	if (cstr) {
-	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
-		       type, otype, cstr);
-	} else {
-	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
-		       type, otype);
-	}
-	Py_XDECREF(str);
-	return;
-      }
-    }   
-    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
-  } else {
-    PyErr_Format(PyExc_TypeError, "unexpected type is received");
-  }
-}
-
-
-/* Convert a pointer value, signal an exception on a type mismatch */
-SWIGRUNTIME void *
-SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
-  void *result;
-  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
-    PyErr_Clear();
-    if (flags & SWIG_POINTER_EXCEPTION) {
-      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
-      SWIG_Python_ArgFail(argnum);
-    }
-  }
-  return result;
-}
-
-
-#ifdef __cplusplus
-#if 0
-{ /* cc-mode */
-#endif
-}
-#endif
-
-
-
-#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
-
-#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
-
-
-
-  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 
-
-
-/* -------- TYPES TABLE (BEGIN) -------- */
-
-#define SWIGTYPE_p_TALLOC_CTX swig_types[0]
-#define SWIGTYPE_p_char swig_types[1]
-#define SWIGTYPE_p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void swig_types[2]
-#define SWIGTYPE_p_int swig_types[3]
-#define SWIGTYPE_p_ldb_context swig_types[4]
-#define SWIGTYPE_p_ldb_dn swig_types[5]
-#define SWIGTYPE_p_ldb_ldif swig_types[6]
-#define SWIGTYPE_p_ldb_message swig_types[7]
-#define SWIGTYPE_p_ldb_message_element swig_types[8]
-#define SWIGTYPE_p_ldb_module swig_types[9]
-#define SWIGTYPE_p_ldb_module_ops swig_types[10]
-#define SWIGTYPE_p_ldb_parse_tree swig_types[11]
-#define SWIGTYPE_p_ldb_result swig_types[12]
-#define SWIGTYPE_p_ldb_val swig_types[13]
-#define SWIGTYPE_p_long_long swig_types[14]
-#define SWIGTYPE_p_p_char swig_types[15]
-#define SWIGTYPE_p_p_ldb_control swig_types[16]
-#define SWIGTYPE_p_p_ldb_result swig_types[17]
-#define SWIGTYPE_p_short swig_types[18]
-#define SWIGTYPE_p_signed_char swig_types[19]
-#define SWIGTYPE_p_unsigned_char swig_types[20]
-#define SWIGTYPE_p_unsigned_int swig_types[21]
-#define SWIGTYPE_p_unsigned_long swig_types[22]
-#define SWIGTYPE_p_unsigned_long_long swig_types[23]
-#define SWIGTYPE_p_unsigned_short swig_types[24]
-#define SWIGTYPE_p_void swig_types[25]
-static swig_type_info *swig_types[27];
-static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0};
-#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
-#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
-
-/* -------- TYPES TABLE (END) -------- */
-
-#if (PY_VERSION_HEX <= 0x02000000)
-# if !defined(SWIG_PYTHON_CLASSIC)
-#  error "This python version requires swig to be run with the '-classic' option"
-# endif
-#endif
-#if (PY_VERSION_HEX <= 0x02020000)
-# error "This python version requires swig to be run with the '-nomodern' option"
-#endif
-#if (PY_VERSION_HEX <= 0x02020000)
-# error "This python version requires swig to be run with the '-nomodernargs' option"
-#endif
-#ifndef METH_O
-# error "This python version requires swig to be run with the '-nofastunpack' option"
-#endif
-#ifdef SWIG_TypeQuery
-# undef SWIG_TypeQuery
-#endif
-#define SWIG_TypeQuery SWIG_Python_TypeQuery
-
-/*-----------------------------------------------
-              @(target):= _ldb.so
-  ------------------------------------------------*/
-#define SWIG_init    init_ldb
-
-#define SWIG_name    "_ldb"
-
-#define SWIGVERSION 0x010336 
-#define SWIG_VERSION SWIGVERSION
-
-
-#define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
-#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 
-
-
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "talloc.h"
-#include "events.h"
-#include "ldb.h"
-#include "ldb_errors.h"
-#include "ldb_private.h"
-
-typedef struct ldb_message ldb_msg;
-typedef struct ldb_context ldb;
-typedef struct ldb_dn ldb_dn;
-typedef struct ldb_ldif ldb_ldif;
-typedef struct ldb_message_element ldb_message_element;
-typedef struct ldb_module ldb_module;
-typedef int ldb_error;
-typedef int ldb_int_error;
-
-
-
-  #define SWIG_From_long   PyInt_FromLong 
-
-
-SWIGINTERNINLINE PyObject *
-SWIG_From_int  (int value)
-{    
-  return SWIG_From_long  (value);
-}
-
-
-PyObject *ldb_val_to_py_object(struct ldb_context *ldb_ctx, 
-                               struct ldb_message_element *el, 
-                               struct ldb_val *val)
-{
-        const struct ldb_schema_attribute *a;
-        struct ldb_val new_val;
-        TALLOC_CTX *mem_ctx = talloc_new(NULL);
-        PyObject *ret;
-        
-        new_val = *val;
-        
-        if (ldb_ctx != NULL) {        
-        	a = ldb_schema_attribute_by_name(ldb_ctx, el->name);
-        
-        	if (a != NULL) {
-        		if (a->syntax->ldif_write_fn(ldb_ctx, mem_ctx, val, &new_val) != 0) {
-        			talloc_free(mem_ctx);
-        			return NULL;
-        		}
-        	}
-        } 
-        
-	ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
-	
-	talloc_free(mem_ctx);
-	
-	return ret;
-}
-
-
-
-SWIGINTERN swig_type_info*
-SWIG_pchar_descriptor(void)
-{
-  static int init = 0;
-  static swig_type_info* info = 0;
-  if (!init) {
-    info = SWIG_TypeQuery("_p_char");
-    init = 1;
-  }
-  return info;
-}
-
-
-SWIGINTERN int
-SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
-{
-  if (PyString_Check(obj)) {
-    char *cstr; Py_ssize_t len;
-    PyString_AsStringAndSize(obj, &cstr, &len);
-    if (cptr)  {
-      if (alloc) {
-	/* 
-	   In python the user should not be able to modify the inner
-	   string representation. To warranty that, if you define
-	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
-	   buffer is always returned.
-
-	   The default behavior is just to return the pointer value,
-	   so, be careful.
-	*/ 
-#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
-	if (*alloc != SWIG_OLDOBJ) 
-#else
-	if (*alloc == SWIG_NEWOBJ) 
-#endif
-	  {
-	    *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
-	    *alloc = SWIG_NEWOBJ;
-	  }
-	else {
-	  *cptr = cstr;
-	  *alloc = SWIG_OLDOBJ;
-	}
-      } else {
-	*cptr = PyString_AsString(obj);
-      }
-    }
-    if (psize) *psize = len + 1;
-    return SWIG_OK;
-  } else {
-    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
-    if (pchar_descriptor) {
-      void* vptr = 0;
-      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
-	if (cptr) *cptr = (char *) vptr;
-	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
-	if (alloc) *alloc = SWIG_OLDOBJ;
-	return SWIG_OK;
-      }
-    }
-  }
-  return SWIG_TypeError;
-}
-
-
-
-
-SWIGINTERN ldb_dn *new_ldb_dn(ldb *ldb_ctx,char const *str){
-            ldb_dn *ret = ldb_dn_new(ldb_ctx, ldb_ctx, str);
-            /* ldb_dn_new() doesn't accept NULL as memory context, so 
-               we do it this way... */
-            talloc_steal(NULL, ret);
-
-            if (ret == NULL)
-                SWIG_exception(SWIG_ValueError, 
-                                "unable to parse dn string");
-fail:
-            return ret;
-        }
-SWIGINTERN void delete_ldb_dn(ldb_dn *self){ talloc_free(self); }
-
-SWIGINTERNINLINE PyObject*
-  SWIG_From_bool  (bool value)
-{
-  return PyBool_FromLong(value ? 1 : 0);
-}
-
-
-SWIGINTERNINLINE PyObject *
-SWIG_FromCharPtrAndSize(const char* carray, size_t size)
-{
-  if (carray) {
-    if (size > INT_MAX) {
-      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
-      return pchar_descriptor ? 
-	SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
-    } else {
-      return PyString_FromStringAndSize(carray, (int)(size));
-    }
-  } else {
-    return SWIG_Py_Void();
-  }
-}
-
-
-SWIGINTERNINLINE PyObject * 
-SWIG_FromCharPtr(const char *cptr)
-{ 
-  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
-}
-
-SWIGINTERN ldb_dn *ldb_dn_parent(ldb_dn *self){ return ldb_dn_get_parent(NULL, self); }
-SWIGINTERN char const *ldb_dn_canonical_str(ldb_dn *self){
-            return ldb_dn_canonical_string(self, self);
-        }
-SWIGINTERN char const *ldb_dn_canonical_ex_str(ldb_dn *self){
-            return ldb_dn_canonical_ex_string(self, self);
-        }
-SWIGINTERN char *ldb_dn___repr__(ldb_dn *self){
-            char *dn = ldb_dn_get_linearized(self), *ret;
-            asprintf(&ret, "Dn('%s')", dn);
-            talloc_free(dn);
-            return ret;
-        }
-SWIGINTERN ldb_dn *ldb_dn___add__(ldb_dn *self,ldb_dn *other){
-            ldb_dn *ret = ldb_dn_copy(NULL, self);
-            ldb_dn_add_child(ret, other);
-            return ret;
-        }
-
-struct ldb_context *ldb_context_from_py_object(PyObject *py_obj)
-{
-        struct ldb_context *ldb_ctx;
-    if (SWIG_ConvertPtr(py_obj, (void *)&ldb_ctx, SWIGTYPE_p_ldb_context, 0 |  0 ) < 0)
-        return NULL;
-    return ldb_ctx;
-}
-
-int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object, 
-                         struct ldb_context *ldb_ctx, ldb_dn **dn)
-{
-    int ret;
-    struct ldb_dn *odn;
-    if (ldb_ctx != NULL && PyString_Check(object)) {
-        odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
-	if (!odn) {
-		return SWIG_ERROR;
-	}
-	*dn = odn;
-        return 0;
-    }
-    ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn, 
-                           SWIG_POINTER_EXCEPTION);
-    *dn = ldb_dn_copy(mem_ctx, odn);
-    if (odn && !*dn) {
- 	return SWIG_ERROR;
-    }
-    return ret;
-}
-
-ldb_message_element *ldb_msg_element_from_pyobject(TALLOC_CTX *mem_ctx,
-                                               PyObject *set_obj, int flags,
-                                               const char *attr_name)
-{
-    struct ldb_message_element *me = talloc(mem_ctx, struct ldb_message_element);
-    me->name = attr_name;
-    me->flags = flags;
-    if (PyString_Check(set_obj)) {
-        me->num_values = 1;
-        me->values = talloc_array(me, struct ldb_val, me->num_values);
-        me->values[0].length = PyString_Size(set_obj);
-        me->values[0].data = (uint8_t *)talloc_strdup(me->values, 
-                                           PyString_AsString(set_obj));
-    } else if (PySequence_Check(set_obj)) {
-        int i;
-        me->num_values = PySequence_Size(set_obj);
-        me->values = talloc_array(me, struct ldb_val, me->num_values);
-        for (i = 0; i < me->num_values; i++) {
-            PyObject *obj = PySequence_GetItem(set_obj, i);
-            me->values[i].length = PyString_Size(obj);
-            me->values[i].data = (uint8_t *)PyString_AsString(obj);
-        }
-    } else {
-        talloc_free(me);
-        me = NULL;
-    }
-
-    return me;
-}
-
-PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx, 
-                                 ldb_message_element *me)
-{
-    int i;
-    PyObject *result;
-
-    /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
-    result = PyList_New(me->num_values);
-
-    for (i = 0; i < me->num_values; i++) {
-        PyList_SetItem(result, i,
-            ldb_val_to_py_object(ldb_ctx, me, &me->values[i]));
-    }
-
-    return result;
-}
-
-
-SWIGINTERN int ldb_message_element___cmp__(ldb_message_element *self,ldb_message_element *other){
-            return ldb_msg_element_compare(self, other);
-        }
-SWIGINTERN PyObject *ldb_message_element___iter__(ldb_message_element *self){
-            return PyObject_GetIter(ldb_msg_element_to_set(NULL, self));
-        }
-SWIGINTERN PyObject *ldb_message_element___set__(ldb_message_element *self){
-            return ldb_msg_element_to_set(NULL, self);
-        }
-
-#include <limits.h>
-#if !defined(SWIG_NO_LLONG_MAX)
-# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
-#   define LLONG_MAX __LONG_LONG_MAX__
-#   define LLONG_MIN (-LLONG_MAX - 1LL)
-#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
-# endif
-#endif
-
-
-SWIGINTERN int
-SWIG_AsVal_double (PyObject *obj, double *val)
-{
-  int res = SWIG_TypeError;
-  if (PyFloat_Check(obj)) {
-    if (val) *val = PyFloat_AsDouble(obj);
-    return SWIG_OK;
-  } else if (PyInt_Check(obj)) {
-    if (val) *val = PyInt_AsLong(obj);
-    return SWIG_OK;
-  } else if (PyLong_Check(obj)) {
-    double v = PyLong_AsDouble(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      PyErr_Clear();
-    }
-  }
-#ifdef SWIG_PYTHON_CAST_MODE
-  {
-    int dispatch = 0;
-    double d = PyFloat_AsDouble(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = d;
-      return SWIG_AddCast(SWIG_OK);
-    } else {
-      PyErr_Clear();
-    }
-    if (!dispatch) {
-      long v = PyLong_AsLong(obj);
-      if (!PyErr_Occurred()) {
-	if (val) *val = v;
-	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
-      } else {
-	PyErr_Clear();
-      }
-    }
-  }
-#endif
-  return res;
-}
-
-
-#include <float.h>
-
-
-#include <math.h>
-
-
-SWIGINTERNINLINE int
-SWIG_CanCastAsInteger(double *d, double min, double max) {
-  double x = *d;
-  if ((min <= x && x <= max)) {
-   double fx = floor(x);
-   double cx = ceil(x);
-   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
-   if ((errno == EDOM) || (errno == ERANGE)) {
-     errno = 0;
-   } else {
-     double summ, reps, diff;
-     if (rd < x) {
-       diff = x - rd;
-     } else if (rd > x) {
-       diff = rd - x;
-     } else {
-       return 1;
-     }
-     summ = rd + x;
-     reps = diff/summ;
-     if (reps < 8*DBL_EPSILON) {
-       *d = rd;
-       return 1;
-     }
-   }
-  }
-  return 0;
-}
-
-
-SWIGINTERN int
-SWIG_AsVal_long (PyObject *obj, long* val)
-{
-  if (PyInt_Check(obj)) {
-    if (val) *val = PyInt_AsLong(obj);
-    return SWIG_OK;
-  } else if (PyLong_Check(obj)) {
-    long v = PyLong_AsLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      PyErr_Clear();
-    }
-  }
-#ifdef SWIG_PYTHON_CAST_MODE
-  {
-    int dispatch = 0;
-    long v = PyInt_AsLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_AddCast(SWIG_OK);
-    } else {
-      PyErr_Clear();
-    }
-    if (!dispatch) {
-      double d;
-      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
-      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
-	if (val) *val = (long)(d);
-	return res;
-      }
-    }
-  }
-#endif
-  return SWIG_TypeError;
-}
-
-
-SWIGINTERN int
-SWIG_AsVal_int (PyObject * obj, int *val)
-{
-  long v;
-  int res = SWIG_AsVal_long (obj, &v);
-  if (SWIG_IsOK(res)) {
-    if ((v < INT_MIN || v > INT_MAX)) {
-      return SWIG_OverflowError;
-    } else {
-      if (val) *val = (int)(v);
-    }
-  }  
-  return res;
-}
-
-SWIGINTERN ldb_message_element *new_ldb_message_element(PyObject *set_obj,int flags,char const *name){
-            return ldb_msg_element_from_pyobject(NULL, set_obj, flags, name);
-        }
-SWIGINTERN int ldb_message_element___len__(ldb_message_element *self){
-            return self->num_values;
-        }
-SWIGINTERN PyObject *ldb_message_element_get(ldb_message_element *self,int i){
-            if (i < 0 || i >= self->num_values)
-                return Py_None;
-
-            return ldb_val_to_py_object(NULL, self, &self->values[i]);
-        }
-SWIGINTERN void delete_ldb_message_element(ldb_message_element *self){ talloc_free(self); }
-
-    PyObject *ldb_msg_list_elements(ldb_msg *msg)
-    {
-        int i, j = 0;
-        PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
-        if (msg->dn != NULL) {
-            PyList_SetItem(obj, j, PyString_FromString("dn"));
-            j++;
-        }
-        for (i = 0; i < msg->num_elements; i++) {
-            PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
-            j++;
-        }
-        return obj;
-    }
-
-SWIGINTERN ldb_msg *new_ldb_msg(ldb_dn *dn){ 
-            ldb_msg *ret = ldb_msg_new(NULL); 
-            ret->dn = talloc_reference(ret, dn);
-            return ret;
-        }
-SWIGINTERN void delete_ldb_msg(ldb_msg *self){ talloc_free(self); }
-SWIGINTERN void ldb_msg___setitem____SWIG_0(ldb_msg *self,char const *attr_name,ldb_message_element *val){
-            struct ldb_message_element *el;
-            
-            ldb_msg_remove_attr(self, attr_name);
-
-            el = talloc(self, struct ldb_message_element);
-            el->name = talloc_strdup(el, attr_name);
-            el->num_values = val->num_values;
-            el->values = talloc_reference(el, val->values);
-
-            ldb_msg_add(self, el, val->flags);
-        }
-SWIGINTERN void ldb_msg___setitem____SWIG_1(ldb_msg *self,char const *attr_name,PyObject *val){
-            struct ldb_message_element *el = ldb_msg_element_from_pyobject(NULL,
-                                                val, 0, attr_name);
-            talloc_steal(self, el);
-            ldb_msg_remove_attr(self, attr_name);
-            ldb_msg_add(self, el, el->flags);
-        }
-SWIGINTERN unsigned int ldb_msg___len__(ldb_msg *self){ return self->num_elements; }
-
-SWIGINTERNINLINE PyObject* 
-SWIG_From_unsigned_SS_long  (unsigned long value)
-{
-  return (value > LONG_MAX) ?
-    PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value)); 
-}
-
-
-SWIGINTERNINLINE PyObject *
-SWIG_From_unsigned_SS_int  (unsigned int value)
-{    
-  return SWIG_From_unsigned_SS_long  (value);
-}
-
-SWIGINTERN PyObject *ldb_msg_keys(ldb_msg *self){
-            return ldb_msg_list_elements(self);
-        }
-SWIGINTERN PyObject *ldb_msg___iter__(ldb_msg *self){
-            return PyObject_GetIter(ldb_msg_list_elements(self));
-        }
-
-static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
-
-static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
-{
-    char *text;
-    PyObject *fn = context;
-
-    vasprintf(&text, fmt, ap);
-    PyObject_CallFunction(fn, (char *)"(i,s)", level, text);
-    free(text);
-}
-
-
-    static PyObject *ldb_ldif_to_pyobject(ldb_ldif *ldif)
-    {
-        if (ldif == NULL) {
-            return Py_None;
-        } else {
-            return Py_BuildValue((char *)"(iO)", ldif->changetype, 
-                   SWIG_NewPointerObj(ldif->msg, SWIGTYPE_p_ldb_message, 0));
-        }
-    }
-
-
-PyObject *PyExc_LdbError;
-
-SWIGINTERN ldb *new_ldb(){ 
-            return ldb_init(NULL, event_context_init(NULL)); 
-        }
-
-SWIGINTERN int
-SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
-{
-  if (PyInt_Check(obj)) {
-    long v = PyInt_AsLong(obj);
-    if (v >= 0) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      return SWIG_OverflowError;
-    }
-  } else if (PyLong_Check(obj)) {
-    unsigned long v = PyLong_AsUnsignedLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      PyErr_Clear();
-    }
-  }
-#ifdef SWIG_PYTHON_CAST_MODE
-  {
-    int dispatch = 0;
-    unsigned long v = PyLong_AsUnsignedLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_AddCast(SWIG_OK);
-    } else {
-      PyErr_Clear();
-    }
-    if (!dispatch) {
-      double d;
-      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
-      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
-	if (val) *val = (unsigned long)(d);
-	return res;
-      }
-    }
-  }
-#endif
-  return SWIG_TypeError;
-}
-
-
-SWIGINTERN int
-SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
-{
-  unsigned long v;
-  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
-  if (SWIG_IsOK(res)) {
-    if ((v > UINT_MAX)) {
-      return SWIG_OverflowError;
-    } else {
-      if (val) *val = (unsigned int)(v);
-    }
-  }  
-  return res;
-}
-
-SWIGINTERN void delete_ldb(ldb *self){ talloc_free(self); }
-SWIGINTERN ldb_error ldb_search_ex(ldb *self,TALLOC_CTX *mem_ctx,ldb_dn *base,enum ldb_scope scope,char const *expression,char const *const *attrs,struct ldb_control **controls,struct ldb_result **OUT){
-            int ret;
-            struct ldb_result *res;
-            struct ldb_request *req;
-            res = talloc_zero(mem_ctx, struct ldb_result);
-            if (!res) {
-                return 1;
-            }
-
-            ret = ldb_build_search_req(&req, self, mem_ctx,
-                           base?base:ldb_get_default_basedn(self),
-                           scope,
-                           expression,
-                           attrs,
-                           controls,
-                           res,
-                           ldb_search_default_callback,
-                           NULL);
-
-            if (ret != 0) {
-                talloc_free(res);
-                return ret;
-            }
-
-            ret = ldb_request(self, req);
-                
-            if (ret == 0) {
-                ret = ldb_wait(req->handle, LDB_WAIT_ALL);
-            }
-
-            talloc_free(req);
-
-            *OUT = res;
-            return ret;
-        }
-SWIGINTERN PyObject *ldb_schema_format_value(ldb *self,char const *element_name,PyObject *val){
-        	const struct ldb_schema_attribute *a;
-        	struct ldb_val old_val;
-        	struct ldb_val new_val;
-        	TALLOC_CTX *mem_ctx = talloc_new(NULL);
-        	PyObject *ret;
-        	
-        	old_val.data = PyString_AsString(val);
-        	old_val.length = PyString_Size(val);
-                
-        	a = ldb_schema_attribute_by_name(self, element_name);
-        
-        	if (a == NULL) {
-        		return Py_None;
-        	}
-        	
-        	if (a->syntax->ldif_write_fn(self, mem_ctx, &old_val, &new_val) != 0) {
-        		talloc_free(mem_ctx);
-        		return Py_None;
-        	 }
-        
-		ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
-		
-		talloc_free(mem_ctx);
-		
-		return ret;
-        }
-SWIGINTERN ldb_error ldb___contains__(ldb *self,ldb_dn *dn,struct ldb_result **result_as_bool){
-            return ldb_search(self, self, result_as_bool, dn, LDB_SCOPE_BASE, NULL, NULL);
-        }
-SWIGINTERN PyObject *ldb_parse_ldif(ldb *self,char const *s){
-            PyObject *list = PyList_New(0);
-            struct ldb_ldif *ldif;
-            while ((ldif = ldb_ldif_read_string(self, &s)) != NULL) {
-                PyList_Append(list, ldb_ldif_to_pyobject(ldif));
-            }
-            return PyObject_GetIter(list);
-        }
-SWIGINTERN char *ldb___repr__(ldb *self){
-            char *ret;
-            asprintf(&ret, "<ldb connection at 0x%x>", ret); 
-            return ret;
-        }
-
-static char *timestring(time_t t)
-{
-    char *tresult = ldb_timestring(NULL, t);
-    char *result = strdup(tresult);
-    talloc_free(tresult);
-    return result; 
-}
-
-SWIGINTERN char const *ldb_module___str__(ldb_module *self){
-            return self->ops->name;
-        }
-SWIGINTERN char *ldb_module___repr__(ldb_module *self){
-            char *ret;
-            asprintf(&ret, "<ldb module '%s'>", self->ops->name);
-            return ret;
-        }
-SWIGINTERN int ldb_module_search(ldb_module *self,struct ldb_dn *base,enum ldb_scope scope,struct ldb_parse_tree *tree,char const *const *attrs,struct ldb_result **res){
-            int ret;
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-
-            req->operation = LDB_SEARCH;
-            req->op.search.base = base;
-            req->op.search.scope = scope;
-            req->op.search.tree = tree;
-            req->op.search.attrs = attrs;
-
-            req->op.search.res = talloc_zero(NULL, struct ldb_result);
-
-            ret = self->ops->search(self, req);
-
-            *res = req->op.search.res;
-
-            talloc_free(req);
-
-            return ret;
-        }
-SWIGINTERN ldb_error ldb_module_add(ldb_module *self,struct ldb_message *message){
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-            req->operation = LDB_ADD;
-            req->op.add.message = message;
-            
-            return self->ops->add(self, &req);
-        }
-SWIGINTERN ldb_error ldb_module_modify(ldb_module *self,struct ldb_message *message){
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-            req->operation = LDB_MODIFY;
-            req->op.mod.message = message;
-            
-            return self->ops->modify(self, &req);
-        }
-SWIGINTERN ldb_error ldb_module_delete(ldb_module *self,struct ldb_dn *dn){
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-            req->operation = LDB_DELETE;
-            req->op.del.dn = dn;
-            
-            return self->ops->del(self, &req);
-
-        }
-SWIGINTERN ldb_error ldb_module_rename(ldb_module *self,struct ldb_dn *olddn,struct ldb_dn *newdn){
-            struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
-            req->operation = LDB_RENAME;
-            req->op.rename.olddn = olddn;
-            req->op.rename.olddn = newdn;
-            
-            return self->ops->rename(self, &req);
-        }
-SWIGINTERN ldb_error ldb_module_start_transaction(ldb_module *self){
-            return self->ops->start_transaction(self);
-        }
-SWIGINTERN ldb_error ldb_module_end_transaction(ldb_module *self){
-            return self->ops->end_transaction(self);
-        }
-SWIGINTERN ldb_error ldb_module_del_transaction(ldb_module *self){
-            return self->ops->del_transaction(self);
-        }
-
-int py_module_search(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_base, *py_attrs, *py_tree;
-
-    py_base = SWIG_NewPointerObj(req->op.search.base, SWIGTYPE_p_ldb_dn, 0);
-
-    if (py_base == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_tree = SWIG_NewPointerObj(req->op.search.tree, SWIGTYPE_p_ldb_parse_tree, 0);
-
-    if (py_tree == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    if (req->op.search.attrs == NULL) {
-        py_attrs = Py_None;
-    } else {
-        int i, len;
-        for (len = 0; req->op.search.attrs[len]; len++);
-        py_attrs = PyList_New(len);
-        for (i = 0; i < len; i++)
-            PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
-    }
-
-    py_result = PyObject_CallMethod(py_ldb, "search", "OiOO", py_base, req->op.search.scope, py_tree, py_attrs);
-
-    Py_DECREF(py_attrs);
-    Py_DECREF(py_tree);
-    Py_DECREF(py_base);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    if (SWIG_ConvertPtr(py_result, &req->op.search.res, SWIGTYPE_p_ldb_result, 0) != 0) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_add(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_msg;
-
-    py_msg = SWIG_NewPointerObj(req->op.add.message, SWIGTYPE_p_ldb_message, 0);
-
-    if (py_msg == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    py_result = PyObject_CallMethod(py_ldb, "add", "O", py_msg);
-
-    Py_DECREF(py_msg);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_msg;
-
-    py_msg = SWIG_NewPointerObj(req->op.mod.message, SWIGTYPE_p_ldb_message, 0);
-
-    if (py_msg == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    py_result = PyObject_CallMethod(py_ldb, "modify", "O", py_msg);
-
-    Py_DECREF(py_msg);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_del(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_dn;
-
-    py_dn = SWIG_NewPointerObj(req->op.del.dn, SWIGTYPE_p_ldb_dn, 0);
-
-    if (py_dn == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_result = PyObject_CallMethod(py_ldb, "delete", "O", py_dn);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result, *py_olddn, *py_newdn;
-
-    py_olddn = SWIG_NewPointerObj(req->op.rename.olddn, SWIGTYPE_p_ldb_dn, 0);
-
-    if (py_olddn == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_newdn = SWIG_NewPointerObj(req->op.rename.newdn, SWIGTYPE_p_ldb_dn, 0);
-
-    if (py_newdn == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_result = PyObject_CallMethod(py_ldb, "rename", "OO", py_olddn, py_newdn);
-
-    Py_DECREF(py_olddn);
-    Py_DECREF(py_newdn);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_request(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "request", "");
-
-    return LDB_ERR_OPERATIONS_ERROR;
-}
-
-int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "extended", "");
-
-    return LDB_ERR_OPERATIONS_ERROR;
-}
-
-int py_module_start_transaction(struct ldb_module *mod)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "start_transaction", "");
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_end_transaction(struct ldb_module *mod)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "end_transaction", "");
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-int py_module_del_transaction(struct ldb_module *mod)
-{
-    PyObject *py_ldb = mod->private_data;
-    PyObject *py_result;
-
-    py_result = PyObject_CallMethod(py_ldb, "del_transaction", "");
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    Py_DECREF(py_result);
-
-    return LDB_SUCCESS;
-}
-
-static int py_module_destructor(void *_mod)
-{
-    struct ldb_module *mod = _mod;
-    Py_DECREF((PyObject *)mod->private_data);
-    return 0;
-}
-
-int py_module_init (struct ldb_module *mod)
-{
-    PyObject *py_class = mod->ops->private_data;
-    PyObject *py_result, *py_next, *py_ldb;
-
-    py_ldb = SWIG_NewPointerObj(mod->ldb, SWIGTYPE_p_ldb_context, 0);
-
-    if (py_ldb == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_next = SWIG_NewPointerObj(mod->next, SWIGTYPE_p_ldb_module, 0);
-
-    if (py_next == NULL)
-        return LDB_ERR_OPERATIONS_ERROR;
-
-    py_result = PyObject_CallFunction(py_class, "OO", py_ldb, py_next);
-
-    if (py_result == NULL) {
-        return LDB_ERR_OPERATIONS_ERROR;
-    }
-
-    mod->private_data = py_result;
-
-    talloc_set_destructor (mod, py_module_destructor);
-
-    return ldb_next_init(mod);
-}
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-SWIGINTERN PyObject *_wrap_ldb_val_to_py_object(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  struct ldb_context *arg1 = (struct ldb_context *) 0 ;
-  struct ldb_message_element *arg2 = (struct ldb_message_element *) 0 ;
-  struct ldb_val *arg3 = (struct ldb_val *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  char *  kwnames[] = {
-    (char *) "ldb_ctx",(char *) "el",(char *) "val", NULL 
-  };
-  PyObject *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ldb_val_to_py_object",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_val_to_py_object" "', argument " "1"" of type '" "struct ldb_context *""'"); 
-  }
-  arg1 = (struct ldb_context *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_val_to_py_object" "', argument " "2"" of type '" "struct ldb_message_element *""'"); 
-  }
-  arg2 = (struct ldb_message_element *)(argp2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_val, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ldb_val_to_py_object" "', argument " "3"" of type '" "struct ldb_val *""'"); 
-  }
-  arg3 = (struct ldb_val *)(argp3);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (PyObject *)ldb_val_to_py_object(arg1,arg2,arg3);
-  resultobj = result;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "ldb_ctx",(char *) "str", NULL 
-  };
-  ldb_dn *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Dn",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Dn" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Dn" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (ldb_dn *)new_ldb_dn(arg1,(char const *)arg2);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, SWIG_POINTER_NEW |  0 );
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dn" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  delete_ldb_dn(arg1);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  bool result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_validate" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (bool)ldb_dn_validate(arg1);
-  resultobj = SWIG_From_bool((bool)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_get_casefold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  char *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_get_casefold" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (char *)ldb_dn_get_casefold(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  char *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___str__" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (char *)ldb_dn_get_linearized(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_parent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_dn *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_parent" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (ldb_dn *)ldb_dn_parent(arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  ldb_dn *arg2 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "other", NULL 
-  };
-  int result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___cmp__" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___cmp__" "', argument " "2"" of type '" "ldb_dn *""'"); 
-  }
-  arg2 = (ldb_dn *)(argp2);
-  result = (int)ldb_dn_compare(arg1,arg2);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_is_valid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  bool result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_valid" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (bool)ldb_dn_is_valid(arg1);
-  resultobj = SWIG_From_bool((bool)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_is_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  bool result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_special" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (bool)ldb_dn_is_special(arg1);
-  resultobj = SWIG_From_bool((bool)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_is_null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  bool result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_null" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (bool)ldb_dn_is_null(arg1);
-  resultobj = SWIG_From_bool((bool)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_check_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "name", NULL 
-  };
-  bool result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_check_special",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_check_special" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_check_special" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  result = (bool)ldb_dn_check_special(arg1,(char const *)arg2);
-  resultobj = SWIG_From_bool((bool)(result));
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  int result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___len__" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (int)ldb_dn_get_comp_num(arg1);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_add_child(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  ldb_dn *arg2 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "child", NULL 
-  };
-  bool result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_child",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_child" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_child" "', argument " "2"" of type '" "ldb_dn *""'"); 
-  }
-  arg2 = (ldb_dn *)(argp2);
-  result = (bool)ldb_dn_add_child(arg1,arg2);
-  resultobj = SWIG_From_bool((bool)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_add_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  ldb_dn *arg2 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "base", NULL 
-  };
-  bool result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_base",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_base" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_base" "', argument " "2"" of type '" "ldb_dn *""'"); 
-  }
-  arg2 = (ldb_dn *)(argp2);
-  result = (bool)ldb_dn_add_base(arg1,arg2);
-  resultobj = SWIG_From_bool((bool)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_canonical_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  char *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_str" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (char *)ldb_dn_canonical_str(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn_canonical_ex_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  char *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_ex_str" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (char *)ldb_dn_canonical_ex_str(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  char *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___repr__" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  result = (char *)ldb_dn___repr__(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Dn___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) 0 ;
-  ldb_dn *arg2 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "other", NULL 
-  };
-  ldb_dn *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___add__",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___add__" "', argument " "1"" of type '" "ldb_dn *""'"); 
-  }
-  arg1 = (ldb_dn *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___add__" "', argument " "2"" of type '" "ldb_dn *""'"); 
-  }
-  arg2 = (ldb_dn *)(argp2);
-  result = (ldb_dn *)ldb_dn___add__(arg1,arg2);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *Dn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_ldb_dn, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *Dn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  return SWIG_Python_InitShadowInstance(args);
-}
-
-SWIGINTERN PyObject *_wrap_MessageElement___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_message_element *arg1 = (ldb_message_element *) 0 ;
-  ldb_message_element *arg2 = (ldb_message_element *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "other", NULL 
-  };
-  int result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___cmp__" "', argument " "1"" of type '" "ldb_message_element *""'"); 
-  }
-  arg1 = (ldb_message_element *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageElement___cmp__" "', argument " "2"" of type '" "ldb_message_element *""'"); 
-  }
-  arg2 = (ldb_message_element *)(argp2);
-  result = (int)ldb_message_element___cmp__(arg1,arg2);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_MessageElement___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_message_element *arg1 = (ldb_message_element *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  PyObject *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___iter__" "', argument " "1"" of type '" "ldb_message_element *""'"); 
-  }
-  arg1 = (ldb_message_element *)(argp1);
-  result = (PyObject *)ldb_message_element___iter__(arg1);
-  resultobj = result;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_MessageElement___set__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_message_element *arg1 = (ldb_message_element *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  PyObject *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___set__" "', argument " "1"" of type '" "ldb_message_element *""'"); 
-  }
-  arg1 = (ldb_message_element *)(argp1);
-  result = (PyObject *)ldb_message_element___set__(arg1);
-  resultobj = result;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  PyObject *arg1 = (PyObject *) 0 ;
-  int arg2 = (int) 0 ;
-  char *arg3 = (char *) NULL ;
-  int val2 ;
-  int ecode2 = 0 ;
-  int res3 ;
-  char *buf3 = 0 ;
-  int alloc3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  char *  kwnames[] = {
-    (char *) "set_obj",(char *) "flags",(char *) "name", NULL 
-  };
-  ldb_message_element *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_MessageElement",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
-  arg1 = obj0;
-  if (obj1) {
-    ecode2 = SWIG_AsVal_int(obj1, &val2);
-    if (!SWIG_IsOK(ecode2)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MessageElement" "', argument " "2"" of type '" "int""'");
-    } 
-    arg2 = (int)(val2);
-  }
-  if (obj2) {
-    res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MessageElement" "', argument " "3"" of type '" "char const *""'");
-    }
-    arg3 = (char *)(buf3);
-  }
-  result = (ldb_message_element *)new_ldb_message_element(arg1,arg2,(char const *)arg3);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message_element, SWIG_POINTER_NEW |  0 );
-  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
-  return resultobj;
-fail:
-  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_MessageElement___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_message_element *arg1 = (ldb_message_element *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  int result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___len__" "', argument " "1"" of type '" "ldb_message_element *""'"); 
-  }
-  arg1 = (ldb_message_element *)(argp1);
-  result = (int)ldb_message_element___len__(arg1);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_MessageElement_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_message_element *arg1 = (ldb_message_element *) 0 ;
-  int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "i", NULL 
-  };
-  PyObject *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement_get",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement_get" "', argument " "1"" of type '" "ldb_message_element *""'"); 
-  }
-  arg1 = (ldb_message_element *)(argp1);
-  ecode2 = SWIG_AsVal_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageElement_get" "', argument " "2"" of type '" "int""'");
-  } 
-  arg2 = (int)(val2);
-  result = (PyObject *)ldb_message_element_get(arg1,arg2);
-  resultobj = result;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_message_element *arg1 = (ldb_message_element *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageElement" "', argument " "1"" of type '" "ldb_message_element *""'"); 
-  }
-  arg1 = (ldb_message_element *)(argp1);
-  delete_ldb_message_element(arg1);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *MessageElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message_element, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *MessageElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  return SWIG_Python_InitShadowInstance(args);
-}
-
-SWIGINTERN PyObject *_wrap_ldb_msg_list_elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  char *  kwnames[] = {
-    (char *) "msg", NULL 
-  };
-  PyObject *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_msg_list_elements",kwnames,&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_list_elements" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  result = (PyObject *)ldb_msg_list_elements(arg1);
-  resultobj = result;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message_dn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  ldb_dn *arg2 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject *swig_obj[2] ;
-  
-  if (!SWIG_Python_UnpackTuple(args,"Message_dn_set",2,2,swig_obj)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_set" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_dn_set" "', argument " "2"" of type '" "ldb_dn *""'"); 
-  }
-  arg2 = (ldb_dn *)(argp2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  if (arg1) (arg1)->dn = arg2;
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message_dn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_dn *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_get" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  result = (ldb_dn *) ((arg1)->dn);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_dn *arg1 = (ldb_dn *) NULL ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  char *  kwnames[] = {
-    (char *) "dn", NULL 
-  };
-  ldb_msg *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Message",kwnames,&obj0)) SWIG_fail;
-  if (obj0) {
-    res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "ldb_dn *""'"); 
-    }
-    arg1 = (ldb_dn *)(argp1);
-  }
-  result = (ldb_msg *)new_ldb_msg(arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Message" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  delete_ldb_msg(arg1);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message_find_element(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "name", NULL 
-  };
-  ldb_message_element *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message_find_element",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_find_element" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_find_element" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  result = (ldb_message_element *)ldb_msg_find_element(arg1,(char const *)arg2);
-  {
-    if (result == NULL)
-    PyErr_SetString(PyExc_KeyError, "no such element");
-    else
-    resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_ldb_message_element, 0);
-  }
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  char *arg2 = (char *) 0 ;
-  ldb_message_element *arg3 = (ldb_message_element *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  
-  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ldb_message_element, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message___setitem__" "', argument " "3"" of type '" "ldb_message_element *""'"); 
-  }
-  arg3 = (ldb_message_element *)(argp3);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  ldb_msg___setitem____SWIG_0(arg1,(char const *)arg2,arg3);
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  char *arg2 = (char *) 0 ;
-  PyObject *arg3 = (PyObject *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  
-  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  arg3 = swig_obj[2];
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  ldb_msg___setitem____SWIG_1(arg1,(char const *)arg2,arg3);
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message___setitem__(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[4];
-  
-  if (!(argc = SWIG_Python_UnpackTuple(args,"Message___setitem__",0,3,argv))) SWIG_fail;
-  --argc;
-  if (argc == 3) {
-    int _v = 0;
-    {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ldb_message_element, 0);
-      _v = SWIG_CheckState(res);
-    }
-    if (!_v) goto check_1;
-    return _wrap_Message___setitem____SWIG_0(self, argc, argv);
-  }
-check_1:
-  
-  if (argc == 3) {
-    return _wrap_Message___setitem____SWIG_1(self, argc, argv);
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message___setitem__'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    __setitem__(ldb_msg *,char const *,ldb_message_element *)\n"
-    "    __setitem__(ldb_msg *,char const *,PyObject *)\n");
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  unsigned int result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___len__" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  result = (unsigned int)ldb_msg___len__(arg1);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  PyObject *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_keys" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  result = (PyObject *)ldb_msg_keys(arg1);
-  resultobj = result;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  PyObject *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___iter__" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  result = (PyObject *)ldb_msg___iter__(arg1);
-  resultobj = result;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Message___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_msg *arg1 = (ldb_msg *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "name", NULL 
-  };
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message___delitem__",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___delitem__" "', argument " "1"" of type '" "ldb_msg *""'"); 
-  }
-  arg1 = (ldb_msg *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___delitem__" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  ldb_msg_remove_attr(arg1,(char const *)arg2);
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *Message_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *Message_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  return SWIG_Python_InitShadowInstance(args);
-}
-
-SWIGINTERN PyObject *_wrap_ldb_ldif_to_pyobject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_ldif *arg1 = (ldb_ldif *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  char *  kwnames[] = {
-    (char *) "ldif", NULL 
-  };
-  PyObject *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_ldif_to_pyobject",kwnames,&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_ldif, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_ldif_to_pyobject" "', argument " "1"" of type '" "ldb_ldif *""'"); 
-  }
-  arg1 = (ldb_ldif *)(argp1);
-  result = (PyObject *)ldb_ldif_to_pyobject(arg1);
-  resultobj = result;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_firstmodule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  struct ldb_module *arg2 = (struct ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject *swig_obj[2] ;
-  
-  if (!SWIG_Python_UnpackTuple(args,"Ldb_firstmodule_set",2,2,swig_obj)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_firstmodule_set" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_firstmodule_set" "', argument " "2"" of type '" "struct ldb_module *""'"); 
-  }
-  arg2 = (struct ldb_module *)(argp2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  if (arg1) (arg1)->modules = arg2;
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_firstmodule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  struct ldb_module *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_firstmodule_get" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (struct ldb_module *) ((arg1)->modules);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *result = 0 ;
-  
-  if (!SWIG_Python_UnpackTuple(args,"new_Ldb",0,0,0)) SWIG_fail;
-  result = (ldb *)new_ldb();
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_context, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  char *arg2 = (char *) 0 ;
-  unsigned int arg3 = (unsigned int) 0 ;
-  char **arg4 = (char **) (char **)NULL ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  unsigned int val3 ;
-  int ecode3 = 0 ;
-  void *argp4 = 0 ;
-  int res4 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "url",(char *) "flags",(char *) "options", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Ldb_connect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_connect" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_connect" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  if (obj2) {
-    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
-    if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_connect" "', argument " "3"" of type '" "unsigned int""'");
-    } 
-    arg3 = (unsigned int)(val3);
-  }
-  if (obj3) {
-    res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_char, 0 |  0 );
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_connect" "', argument " "4"" of type '" "char const *[]""'"); 
-    } 
-    arg4 = (char **)(argp4);
-  }
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_connect(arg1,(char const *)arg2,arg3,(char const *(*))arg4);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ldb" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  delete_ldb(arg1);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_search_ex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
-  ldb_dn *arg3 = (ldb_dn *) NULL ;
-  enum ldb_scope arg4 = (enum ldb_scope) LDB_SCOPE_DEFAULT ;
-  char *arg5 = (char *) NULL ;
-  char **arg6 = (char **) NULL ;
-  struct ldb_control **arg7 = (struct ldb_control **) NULL ;
-  struct ldb_result **arg8 = (struct ldb_result **) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int val4 ;
-  int ecode4 = 0 ;
-  int res5 ;
-  char *buf5 = 0 ;
-  int alloc5 = 0 ;
-  void *argp7 = 0 ;
-  int res7 = 0 ;
-  struct ldb_result *temp_ldb_result8 ;
-  int i8 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "base",(char *) "scope",(char *) "expression",(char *) "attrs",(char *) "controls", NULL 
-  };
-  ldb_error result;
-  
-  arg2 = NULL;
-  arg8 = &temp_ldb_result8;
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:Ldb_search_ex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_search_ex" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (obj1) {
-    if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg3) != 0) {
-      SWIG_fail;
-    }
-  }
-  if (obj2) {
-    ecode4 = SWIG_AsVal_int(obj2, &val4);
-    if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ldb_search_ex" "', argument " "4"" of type '" "enum ldb_scope""'");
-    } 
-    arg4 = (enum ldb_scope)(val4);
-  }
-  if (obj3) {
-    res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
-    if (!SWIG_IsOK(res5)) {
-      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Ldb_search_ex" "', argument " "5"" of type '" "char const *""'");
-    }
-    arg5 = (char *)(buf5);
-  }
-  if (obj4) {
-    if (obj4 == Py_None) {
-      arg6 = NULL;
-    } else if (PySequence_Check(obj4)) {
-      int i;
-      arg6 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
-      for(i = 0; i < PySequence_Size(obj4); i++)
-      arg6[i] = PyString_AsString(PySequence_GetItem(obj4, i));
-      arg6[i] = NULL;
-    } else {
-      SWIG_exception(SWIG_TypeError, "expected sequence");
-    }
-  }
-  if (obj5) {
-    res7 = SWIG_ConvertPtr(obj5, &argp7,SWIGTYPE_p_p_ldb_control, 0 |  0 );
-    if (!SWIG_IsOK(res7)) {
-      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Ldb_search_ex" "', argument " "7"" of type '" "struct ldb_control **""'"); 
-    }
-    arg7 = (struct ldb_control **)(argp7);
-  }
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_search_ex(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *const *)arg6,arg7,arg8);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  if (arg8 == NULL) {
-    resultobj = Py_None;
-  } else {
-    resultobj = PyList_New((*arg8)->count);
-    for (i8 = 0; i8 < (*arg8)->count; i8++) {
-      PyList_SetItem(resultobj, i8, 
-        SWIG_NewPointerObj((*arg8)->msgs[i8], SWIGTYPE_p_ldb_message, 0)
-        );
-    }
-  }
-  talloc_free(arg3);
-  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
-  talloc_free(arg6);
-  return resultobj;
-fail:
-  talloc_free(arg3);
-  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
-  talloc_free(arg6);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  ldb_dn *arg2 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "dn", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_delete",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_delete" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
-    SWIG_fail;
-  }
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_delete(arg1,arg2);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  talloc_free(arg2);
-  return resultobj;
-fail:
-  talloc_free(arg2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  ldb_dn *arg2 = (ldb_dn *) 0 ;
-  ldb_dn *arg3 = (ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "olddn",(char *) "newdn", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_rename",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_rename" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
-    SWIG_fail;
-  }
-  if (ldb_dn_from_pyobject(NULL, obj2, arg1, &arg3) != 0) {
-    SWIG_fail;
-  }
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_rename(arg1,arg2,arg3);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  talloc_free(arg2);
-  talloc_free(arg3);
-  return resultobj;
-fail:
-  talloc_free(arg2);
-  talloc_free(arg3);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_parse_control_strings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
-  char **arg3 = (char **) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "control_strings", NULL 
-  };
-  struct ldb_control **result = 0 ;
-  
-  arg2 = NULL;
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_control_strings",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_control_strings" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (obj1 == Py_None) {
-    arg3 = NULL;
-  } else if (PySequence_Check(obj1)) {
-    int i;
-    arg3 = talloc_array(NULL, char *, PySequence_Size(obj1)+1);
-    for(i = 0; i < PySequence_Size(obj1); i++)
-    arg3[i] = PyString_AsString(PySequence_GetItem(obj1, i));
-    arg3[i] = NULL;
-  } else {
-    SWIG_exception(SWIG_TypeError, "expected sequence");
-  }
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (struct ldb_control **)ldb_parse_control_strings(arg1,arg2,(char const *const *)arg3);
-  if (result == NULL) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(s)", ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_p_ldb_control, 0);
-  talloc_free(arg3);
-  return resultobj;
-fail:
-  talloc_free(arg3);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  ldb_msg *arg2 = (ldb_msg *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "add_msg", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_add",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_add" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  {
-    Py_ssize_t dict_pos, msg_pos;
-    ldb_message_element *msgel;
-    PyObject *key, *value;
-    
-    if (PyDict_Check(obj1)) {
-      PyObject *dn_value = PyDict_GetItemString(obj1, "dn");
-      arg2 = ldb_msg_new(NULL);
-      arg2->elements = talloc_zero_array(arg2, struct ldb_message_element, PyDict_Size(obj1));
-      msg_pos = dict_pos = 0;
-      if (dn_value) {
-        /* using argp1 (magic SWIG value) here is a hack */
-        if (ldb_dn_from_pyobject(arg2, dn_value, argp1, &arg2->dn) != 0) {
-          SWIG_exception(SWIG_TypeError, "unable to import dn object");
-        }
-        if (arg2->dn == NULL) {
-          SWIG_exception(SWIG_TypeError, "dn set but not found");
-        }
-      }
-      
-      while (PyDict_Next(obj1, &dict_pos, &key, &value)) {
-        char *key_str = PyString_AsString(key);
-        if (strcmp(key_str, "dn") != 0) {
-          msgel = ldb_msg_element_from_pyobject(arg2->elements, value, 0, key_str);
-          if (msgel == NULL) {
-            SWIG_exception(SWIG_TypeError, "unable to import element");
-          }
-          memcpy(&arg2->elements[msg_pos], msgel, sizeof(*msgel));
-          msg_pos++;
-        }
-      }
-      
-      if (arg2->dn == NULL) {
-        SWIG_exception(SWIG_TypeError, "no dn set");
-      }
-      
-      arg2->num_elements = msg_pos;
-    } else {
-      if (SWIG_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_ldb_message, 0) != 0) {
-        SWIG_exception(SWIG_TypeError, "unable to convert ldb message");
-      }
-    }
-  }
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  if (arg2 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  result = ldb_add(arg1,arg2);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  ldb_msg *arg2 = (ldb_msg *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "message", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_modify",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_modify" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_modify" "', argument " "2"" of type '" "ldb_msg *""'"); 
-  }
-  arg2 = (ldb_msg *)(argp2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  if (arg2 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "Message can not be None");
-  result = ldb_modify(arg1,arg2);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_get_config_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_dn *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_config_basedn" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (ldb_dn *)ldb_get_config_basedn(arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_get_root_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_dn *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_root_basedn" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (ldb_dn *)ldb_get_root_basedn(arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_get_schema_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_dn *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_schema_basedn" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (ldb_dn *)ldb_get_schema_basedn(arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_get_default_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_dn *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_default_basedn" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (ldb_dn *)ldb_get_default_basedn(arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_schema_format_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  char *arg2 = (char *) 0 ;
-  PyObject *arg3 = (PyObject *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "element_name",(char *) "val", NULL 
-  };
-  PyObject *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_schema_format_value",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_format_value" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_format_value" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  arg3 = obj2;
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (PyObject *)ldb_schema_format_value(arg1,(char const *)arg2,arg3);
-  resultobj = result;
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_errstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  char *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_errstring" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (char *)ldb_errstring(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_set_create_perms(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "perms", NULL 
-  };
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_create_perms",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_create_perms" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ldb_set_create_perms" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  ldb_set_create_perms(arg1,arg2);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_set_modules_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "path", NULL 
-  };
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_modules_dir",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_modules_dir" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_modules_dir" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  ldb_set_modules_dir(arg1,(char const *)arg2);
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_set_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void (*arg2)(void *,enum ldb_debug_level,char const *,va_list) = (void (*)(void *,enum ldb_debug_level,char const *,va_list)) 0 ;
-  void *arg3 = (void *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "debug", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_debug",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_debug" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  arg2 = py_ldb_debug;
-  /* FIXME: Should be decreased somewhere as well. Perhaps register a 
-         destructor and tie it to the ldb context ? */
-  Py_INCREF(obj1);
-  arg3 = obj1;
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_set_debug(arg1,arg2,arg3);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_set_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *arg3 = (void *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  int res3 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "name",(char *) "value", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_set_opaque",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_opaque" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_opaque" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ldb_set_opaque" "', argument " "3"" of type '" "void *""'"); 
-  }
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_set_opaque(arg1,(char const *)arg2,arg3);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_get_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "name", NULL 
-  };
-  void *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_get_opaque",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_opaque" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_get_opaque" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (void *)ldb_get_opaque(arg1,(char const *)arg2);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_transaction_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_error result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_start" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_transaction_start(arg1);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_transaction_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_error result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_commit" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_transaction_commit(arg1);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_transaction_cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_error result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_cancel" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_transaction_cancel(arg1);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "name", NULL 
-  };
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_schema_attribute_remove",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_remove" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_remove" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  ldb_schema_attribute_remove(arg1,(char const *)arg2);
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  char *arg2 = (char *) 0 ;
-  unsigned int arg3 ;
-  char *arg4 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  unsigned int val3 ;
-  int ecode3 = 0 ;
-  int res4 ;
-  char *buf4 = 0 ;
-  int alloc4 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "attribute",(char *) "flags",(char *) "syntax", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Ldb_schema_attribute_add",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_add" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_add" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_schema_attribute_add" "', argument " "3"" of type '" "unsigned int""'");
-  } 
-  arg3 = (unsigned int)(val3);
-  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_schema_attribute_add" "', argument " "4"" of type '" "char const *""'");
-  }
-  arg4 = (char *)(buf4);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_schema_attribute_add(arg1,(char const *)arg2,arg3,(char const *)arg4);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_setup_wellknown_attributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_error result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_setup_wellknown_attributes" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb_setup_wellknown_attributes(arg1);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  ldb_dn *arg2 = (ldb_dn *) 0 ;
-  struct ldb_result **arg3 = (struct ldb_result **) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  struct ldb_result *tmp3 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "dn", NULL 
-  };
-  ldb_error result;
-  
-  arg3 = &tmp3;
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb___contains__",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___contains__" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
-    SWIG_fail;
-  }
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = ldb___contains__(arg1,arg2,arg3);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  resultobj = ((*arg3)->count > 0)?Py_True:Py_False;
-  talloc_free(arg2);
-  talloc_free(*arg3);
-  return resultobj;
-fail:
-  talloc_free(arg2);
-  talloc_free(*arg3);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb_parse_ldif(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "s", NULL 
-  };
-  PyObject *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_ldif",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_ldif" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_parse_ldif" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = (char *)(buf2);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (PyObject *)ldb_parse_ldif(arg1,(char const *)arg2);
-  resultobj = result;
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Ldb___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb *arg1 = (ldb *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  char *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___repr__" "', argument " "1"" of type '" "ldb *""'"); 
-  }
-  arg1 = (ldb *)(argp1);
-  if (arg1 == NULL)
-  SWIG_exception(SWIG_ValueError, 
-    "ldb context must be non-NULL");
-  result = (char *)ldb___repr__(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *Ldb_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_ldb_context, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *Ldb_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  return SWIG_Python_InitShadowInstance(args);
-}
-
-SWIGINTERN PyObject *_wrap_valid_attr_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  char *arg1 = (char *) 0 ;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  PyObject * obj0 = 0 ;
-  char *  kwnames[] = {
-    (char *) "s", NULL 
-  };
-  int result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:valid_attr_name",kwnames,&obj0)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "valid_attr_name" "', argument " "1"" of type '" "char const *""'");
-  }
-  arg1 = (char *)(buf1);
-  result = (int)ldb_valid_attr_name((char const *)arg1);
-  resultobj = SWIG_From_int((int)(result));
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_timestring(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  time_t arg1 ;
-  unsigned long val1 ;
-  int ecode1 = 0 ;
-  PyObject * obj0 = 0 ;
-  char *  kwnames[] = {
-    (char *) "t", NULL 
-  };
-  char *result = 0 ;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:timestring",kwnames,&obj0)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "timestring" "', argument " "1"" of type '" "time_t""'");
-  } 
-  arg1 = (time_t)(val1);
-  result = (char *)timestring(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_string_to_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  char *arg1 = (char *) 0 ;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  PyObject * obj0 = 0 ;
-  char *  kwnames[] = {
-    (char *) "s", NULL 
-  };
-  time_t result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:string_to_time",kwnames,&obj0)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_to_time" "', argument " "1"" of type '" "char const *""'");
-  }
-  arg1 = (char *)(buf1);
-  result = (time_t)ldb_string_to_time((char const *)arg1);
-  resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  struct ldb_module *arg2 = (struct ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject *swig_obj[2] ;
-  
-  if (!SWIG_Python_UnpackTuple(args,"ldb_module_prev_set",2,2,swig_obj)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_prev_set" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_prev_set" "', argument " "2"" of type '" "struct ldb_module *""'"); 
-  }
-  arg2 = (struct ldb_module *)(argp2);
-  if (arg1) (arg1)->prev = arg2;
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  struct ldb_module *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_prev_get" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  result = (struct ldb_module *) ((arg1)->prev);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  struct ldb_module *arg2 = (struct ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject *swig_obj[2] ;
-  
-  if (!SWIG_Python_UnpackTuple(args,"ldb_module_next_set",2,2,swig_obj)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_next_set" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_next_set" "', argument " "2"" of type '" "struct ldb_module *""'"); 
-  }
-  arg2 = (struct ldb_module *)(argp2);
-  if (arg1) (arg1)->next = arg2;
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  struct ldb_module *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_next_get" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  result = (struct ldb_module *) ((arg1)->next);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  char *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module___str__" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  result = (char *)ldb_module___str__(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  char *result = 0 ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module___repr__" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  result = (char *)ldb_module___repr__(arg1);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_search(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  struct ldb_dn *arg2 = (struct ldb_dn *) 0 ;
-  enum ldb_scope arg3 ;
-  struct ldb_parse_tree *arg4 = (struct ldb_parse_tree *) 0 ;
-  char **arg5 = (char **) 0 ;
-  struct ldb_result **arg6 = (struct ldb_result **) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
-  void *argp4 = 0 ;
-  int res4 = 0 ;
-  struct ldb_result *temp_ldb_result6 ;
-  int i6 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "base",(char *) "scope",(char *) "tree",(char *) "attrs", NULL 
-  };
-  int result;
-  
-  arg6 = &temp_ldb_result6;
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ldb_module_search",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_search" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_search" "', argument " "2"" of type '" "struct ldb_dn *""'"); 
-  }
-  arg2 = (struct ldb_dn *)(argp2);
-  ecode3 = SWIG_AsVal_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ldb_module_search" "', argument " "3"" of type '" "enum ldb_scope""'");
-  } 
-  arg3 = (enum ldb_scope)(val3);
-  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_ldb_parse_tree, 0 |  0 );
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ldb_module_search" "', argument " "4"" of type '" "struct ldb_parse_tree *""'"); 
-  }
-  arg4 = (struct ldb_parse_tree *)(argp4);
-  if (obj4 == Py_None) {
-    arg5 = NULL;
-  } else if (PySequence_Check(obj4)) {
-    int i;
-    arg5 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
-    for(i = 0; i < PySequence_Size(obj4); i++)
-    arg5[i] = PyString_AsString(PySequence_GetItem(obj4, i));
-    arg5[i] = NULL;
-  } else {
-    SWIG_exception(SWIG_TypeError, "expected sequence");
-  }
-  result = (int)ldb_module_search(arg1,arg2,arg3,arg4,(char const *const *)arg5,arg6);
-  resultobj = SWIG_From_int((int)(result));
-  if (arg6 == NULL) {
-    resultobj = Py_None;
-  } else {
-    resultobj = PyList_New((*arg6)->count);
-    for (i6 = 0; i6 < (*arg6)->count; i6++) {
-      PyList_SetItem(resultobj, i6, 
-        SWIG_NewPointerObj((*arg6)->msgs[i6], SWIGTYPE_p_ldb_message, 0)
-        );
-    }
-  }
-  talloc_free(arg5);
-  return resultobj;
-fail:
-  talloc_free(arg5);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  struct ldb_message *arg2 = (struct ldb_message *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "message", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_add",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_add" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_add" "', argument " "2"" of type '" "struct ldb_message *""'"); 
-  }
-  arg2 = (struct ldb_message *)(argp2);
-  result = ldb_module_add(arg1,arg2);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  struct ldb_message *arg2 = (struct ldb_message *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "message", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_modify",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_modify" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_modify" "', argument " "2"" of type '" "struct ldb_message *""'"); 
-  }
-  arg2 = (struct ldb_message *)(argp2);
-  result = ldb_module_modify(arg1,arg2);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  struct ldb_dn *arg2 = (struct ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "dn", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_delete",kwnames,&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_delete" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_delete" "', argument " "2"" of type '" "struct ldb_dn *""'"); 
-  }
-  arg2 = (struct ldb_dn *)(argp2);
-  result = ldb_module_delete(arg1,arg2);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  struct ldb_dn *arg2 = (struct ldb_dn *) 0 ;
-  struct ldb_dn *arg3 = (struct ldb_dn *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  char *  kwnames[] = {
-    (char *) "self",(char *) "olddn",(char *) "newdn", NULL 
-  };
-  ldb_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ldb_module_rename",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_rename" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_rename" "', argument " "2"" of type '" "struct ldb_dn *""'"); 
-  }
-  arg2 = (struct ldb_dn *)(argp2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ldb_module_rename" "', argument " "3"" of type '" "struct ldb_dn *""'"); 
-  }
-  arg3 = (struct ldb_dn *)(argp3);
-  result = ldb_module_rename(arg1,arg2,arg3);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_start_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_error result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_start_transaction" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  result = ldb_module_start_transaction(arg1);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_end_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_error result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_end_transaction" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  result = ldb_module_end_transaction(arg1);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_ldb_module_del_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  ldb_error result;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_del_transaction" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  result = ldb_module_del_transaction(arg1);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_ldb_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *result = 0 ;
-  
-  if (!SWIG_Python_UnpackTuple(args,"new_ldb_module",0,0,0)) SWIG_fail;
-  result = (ldb_module *)calloc(1, sizeof(ldb_module));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_ldb_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  ldb_module *arg1 = (ldb_module *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject *swig_obj[1] ;
-  
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ldb_module" "', argument " "1"" of type '" "ldb_module *""'"); 
-  }
-  arg1 = (ldb_module *)(argp1);
-  free((char *) arg1);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *ldb_module_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_ldb_module, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *ldb_module_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  return SWIG_Python_InitShadowInstance(args);
-}
-
-SWIGINTERN PyObject *_wrap_register_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
-  PyObject *resultobj = 0;
-  struct ldb_module_ops *arg1 = (struct ldb_module_ops *) 0 ;
-  PyObject * obj0 = 0 ;
-  char *  kwnames[] = {
-    (char *)"arg1", NULL 
-  };
-  ldb_int_error result;
-  
-  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:register_module",kwnames,&obj0)) SWIG_fail;
-  arg1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
-  
-  arg1->name = talloc_strdup(arg1, PyString_AsString(PyObject_GetAttrString(obj0, (char *)"name")));
-  
-  Py_INCREF(obj0);
-  arg1->private_data = obj0;
-  arg1->init_context = py_module_init;
-  arg1->search = py_module_search;
-  arg1->add = py_module_add;
-  arg1->modify = py_module_modify;
-  arg1->del = py_module_del;
-  arg1->rename = py_module_rename;
-  arg1->request = py_module_request;
-  arg1->extended = py_module_extended;
-  arg1->start_transaction = py_module_start_transaction;
-  arg1->end_transaction = py_module_end_transaction;
-  arg1->del_transaction = py_module_del_transaction;
-  result = ldb_register_module((struct ldb_module_ops const *)arg1);
-  if (result != 0) {
-    PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
-    SWIG_fail;
-  }
-  resultobj = Py_None;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-static PyMethodDef SwigMethods[] = {
-	 { (char *)"ldb_val_to_py_object", (PyCFunction) _wrap_ldb_val_to_py_object, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"new_Dn", (PyCFunction) _wrap_new_Dn, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.__init__(ldb, string)\n"
-		"Create a new DN.\n"
-		""},
-	 { (char *)"delete_Dn", (PyCFunction)_wrap_delete_Dn, METH_O, NULL},
-	 { (char *)"Dn_validate", (PyCFunction)_wrap_Dn_validate, METH_O, (char *)"\n"
-		"S.validate() -> bool\n"
-		"Validate DN is correct.\n"
-		""},
-	 { (char *)"Dn_get_casefold", (PyCFunction)_wrap_Dn_get_casefold, METH_O, NULL},
-	 { (char *)"Dn___str__", (PyCFunction)_wrap_Dn___str__, METH_O, NULL},
-	 { (char *)"Dn_parent", (PyCFunction)_wrap_Dn_parent, METH_O, (char *)"\n"
-		"S.parent() -> dn\n"
-		"Get the parent for this DN.\n"
-		""},
-	 { (char *)"Dn___cmp__", (PyCFunction) _wrap_Dn___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Dn_is_valid", (PyCFunction)_wrap_Dn_is_valid, METH_O, NULL},
-	 { (char *)"Dn_is_special", (PyCFunction)_wrap_Dn_is_special, METH_O, (char *)"\n"
-		"S.is_special() -> bool\n"
-		"Check whether this is a special LDB DN.\n"
-		""},
-	 { (char *)"Dn_is_null", (PyCFunction)_wrap_Dn_is_null, METH_O, (char *)"\n"
-		"S.is_null() -> bool\n"
-		"Check whether this is a null DN.\n"
-		""},
-	 { (char *)"Dn_check_special", (PyCFunction) _wrap_Dn_check_special, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Dn___len__", (PyCFunction)_wrap_Dn___len__, METH_O, NULL},
-	 { (char *)"Dn_add_child", (PyCFunction) _wrap_Dn_add_child, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.add_child(dn) -> None\n"
-		"Add a child DN to this DN.\n"
-		""},
-	 { (char *)"Dn_add_base", (PyCFunction) _wrap_Dn_add_base, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.add_base(dn) -> None\n"
-		"Add a base DN to this DN.\n"
-		""},
-	 { (char *)"Dn_canonical_str", (PyCFunction)_wrap_Dn_canonical_str, METH_O, (char *)"\n"
-		"S.canonical_str() -> string\n"
-		"Canonical version of this DN (like a posix path).\n"
-		""},
-	 { (char *)"Dn_canonical_ex_str", (PyCFunction)_wrap_Dn_canonical_ex_str, METH_O, (char *)"\n"
-		"S.canonical_ex_str() -> string\n"
-		"Canonical version of this DN (like a posix path, with terminating newline).\n"
-		""},
-	 { (char *)"Dn___repr__", (PyCFunction)_wrap_Dn___repr__, METH_O, NULL},
-	 { (char *)"Dn___add__", (PyCFunction) _wrap_Dn___add__, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Dn_swigregister", Dn_swigregister, METH_VARARGS, NULL},
-	 { (char *)"Dn_swiginit", Dn_swiginit, METH_VARARGS, NULL},
-	 { (char *)"MessageElement___cmp__", (PyCFunction) _wrap_MessageElement___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"MessageElement___iter__", (PyCFunction)_wrap_MessageElement___iter__, METH_O, NULL},
-	 { (char *)"MessageElement___set__", (PyCFunction)_wrap_MessageElement___set__, METH_O, NULL},
-	 { (char *)"new_MessageElement", (PyCFunction) _wrap_new_MessageElement, METH_VARARGS | METH_KEYWORDS, (char *)"Message element."},
-	 { (char *)"MessageElement___len__", (PyCFunction)_wrap_MessageElement___len__, METH_O, NULL},
-	 { (char *)"MessageElement_get", (PyCFunction) _wrap_MessageElement_get, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"delete_MessageElement", (PyCFunction)_wrap_delete_MessageElement, METH_O, NULL},
-	 { (char *)"MessageElement_swigregister", MessageElement_swigregister, METH_VARARGS, NULL},
-	 { (char *)"MessageElement_swiginit", MessageElement_swiginit, METH_VARARGS, NULL},
-	 { (char *)"ldb_msg_list_elements", (PyCFunction) _wrap_ldb_msg_list_elements, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Message_dn_set", _wrap_Message_dn_set, METH_VARARGS, NULL},
-	 { (char *)"Message_dn_get", (PyCFunction)_wrap_Message_dn_get, METH_O, NULL},
-	 { (char *)"new_Message", (PyCFunction) _wrap_new_Message, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"delete_Message", (PyCFunction)_wrap_delete_Message, METH_O, NULL},
-	 { (char *)"Message_find_element", (PyCFunction) _wrap_Message_find_element, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Message___setitem__", _wrap_Message___setitem__, METH_VARARGS, NULL},
-	 { (char *)"Message___len__", (PyCFunction)_wrap_Message___len__, METH_O, NULL},
-	 { (char *)"Message_keys", (PyCFunction)_wrap_Message_keys, METH_O, NULL},
-	 { (char *)"Message___iter__", (PyCFunction)_wrap_Message___iter__, METH_O, NULL},
-	 { (char *)"Message___delitem__", (PyCFunction) _wrap_Message___delitem__, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Message_swigregister", Message_swigregister, METH_VARARGS, NULL},
-	 { (char *)"Message_swiginit", Message_swiginit, METH_VARARGS, NULL},
-	 { (char *)"ldb_ldif_to_pyobject", (PyCFunction) _wrap_ldb_ldif_to_pyobject, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Ldb_firstmodule_set", _wrap_Ldb_firstmodule_set, METH_VARARGS, NULL},
-	 { (char *)"Ldb_firstmodule_get", (PyCFunction)_wrap_Ldb_firstmodule_get, METH_O, NULL},
-	 { (char *)"new_Ldb", (PyCFunction)_wrap_new_Ldb, METH_NOARGS, NULL},
-	 { (char *)"Ldb_connect", (PyCFunction) _wrap_Ldb_connect, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.connect(url,flags=0,options=None) -> None\n"
-		"Connect to a LDB URL.\n"
-		""},
-	 { (char *)"delete_Ldb", (PyCFunction)_wrap_delete_Ldb, METH_O, NULL},
-	 { (char *)"Ldb_search_ex", (PyCFunction) _wrap_Ldb_search_ex, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Ldb_delete", (PyCFunction) _wrap_Ldb_delete, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.delete(dn) -> None\n"
-		"Remove an entry.\n"
-		""},
-	 { (char *)"Ldb_rename", (PyCFunction) _wrap_Ldb_rename, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.rename(old_dn, new_dn) -> None\n"
-		"Rename an entry.\n"
-		""},
-	 { (char *)"Ldb_parse_control_strings", (PyCFunction) _wrap_Ldb_parse_control_strings, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Ldb_add", (PyCFunction) _wrap_Ldb_add, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.add(message) -> None\n"
-		"Add an entry.\n"
-		""},
-	 { (char *)"Ldb_modify", (PyCFunction) _wrap_Ldb_modify, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.modify(message) -> None\n"
-		"Modify an entry.\n"
-		""},
-	 { (char *)"Ldb_get_config_basedn", (PyCFunction)_wrap_Ldb_get_config_basedn, METH_O, NULL},
-	 { (char *)"Ldb_get_root_basedn", (PyCFunction)_wrap_Ldb_get_root_basedn, METH_O, NULL},
-	 { (char *)"Ldb_get_schema_basedn", (PyCFunction)_wrap_Ldb_get_schema_basedn, METH_O, NULL},
-	 { (char *)"Ldb_get_default_basedn", (PyCFunction)_wrap_Ldb_get_default_basedn, METH_O, NULL},
-	 { (char *)"Ldb_schema_format_value", (PyCFunction) _wrap_Ldb_schema_format_value, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Ldb_errstring", (PyCFunction)_wrap_Ldb_errstring, METH_O, NULL},
-	 { (char *)"Ldb_set_create_perms", (PyCFunction) _wrap_Ldb_set_create_perms, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.set_create_perms(mode) -> None\n"
-		"Set mode to use when creating new LDB files.\n"
-		""},
-	 { (char *)"Ldb_set_modules_dir", (PyCFunction) _wrap_Ldb_set_modules_dir, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.set_modules_dir(path) -> None\n"
-		"Set path LDB should search for modules\n"
-		""},
-	 { (char *)"Ldb_set_debug", (PyCFunction) _wrap_Ldb_set_debug, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.set_debug(callback) -> None\n"
-		"Set callback for LDB debug messages.\n"
-		"The callback should accept a debug level and debug text.\n"
-		""},
-	 { (char *)"Ldb_set_opaque", (PyCFunction) _wrap_Ldb_set_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.set_opaque(name, value) -> None\n"
-		"Set an opaque value on this LDB connection. \n"
-		":note: Passing incorrect values may cause crashes.\n"
-		""},
-	 { (char *)"Ldb_get_opaque", (PyCFunction) _wrap_Ldb_get_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.get_opaque(name) -> value\n"
-		"Get an opaque value set on this LDB connection. \n"
-		":note: The returned value may not be useful in Python.\n"
-		""},
-	 { (char *)"Ldb_transaction_start", (PyCFunction)_wrap_Ldb_transaction_start, METH_O, (char *)"\n"
-		"S.transaction_start() -> None\n"
-		"Start a new transaction.\n"
-		""},
-	 { (char *)"Ldb_transaction_commit", (PyCFunction)_wrap_Ldb_transaction_commit, METH_O, (char *)"\n"
-		"S.transaction_commit() -> None\n"
-		"Commit currently active transaction.\n"
-		""},
-	 { (char *)"Ldb_transaction_cancel", (PyCFunction)_wrap_Ldb_transaction_cancel, METH_O, (char *)"\n"
-		"S.transaction_cancel() -> None\n"
-		"Cancel currently active transaction.\n"
-		""},
-	 { (char *)"Ldb_schema_attribute_remove", (PyCFunction) _wrap_Ldb_schema_attribute_remove, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Ldb_schema_attribute_add", (PyCFunction) _wrap_Ldb_schema_attribute_add, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Ldb_setup_wellknown_attributes", (PyCFunction)_wrap_Ldb_setup_wellknown_attributes, METH_O, NULL},
-	 { (char *)"Ldb___contains__", (PyCFunction) _wrap_Ldb___contains__, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"Ldb_parse_ldif", (PyCFunction) _wrap_Ldb_parse_ldif, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.parse_ldif(ldif) -> iter(messages)\n"
-		"Parse a string formatted using LDIF.\n"
-		""},
-	 { (char *)"Ldb___repr__", (PyCFunction)_wrap_Ldb___repr__, METH_O, NULL},
-	 { (char *)"Ldb_swigregister", Ldb_swigregister, METH_VARARGS, NULL},
-	 { (char *)"Ldb_swiginit", Ldb_swiginit, METH_VARARGS, NULL},
-	 { (char *)"valid_attr_name", (PyCFunction) _wrap_valid_attr_name, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.valid_attr_name(name) -> bool\n"
-		"Check whether the supplied name is a valid attribute name.\n"
-		""},
-	 { (char *)"timestring", (PyCFunction) _wrap_timestring, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.timestring(int) -> string\n"
-		"Generate a LDAP time string from a UNIX timestamp\n"
-		""},
-	 { (char *)"string_to_time", (PyCFunction) _wrap_string_to_time, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.string_to_time(string) -> int\n"
-		"Parse a LDAP time string into a UNIX timestamp.\n"
-		""},
-	 { (char *)"ldb_module_prev_set", _wrap_ldb_module_prev_set, METH_VARARGS, NULL},
-	 { (char *)"ldb_module_prev_get", (PyCFunction)_wrap_ldb_module_prev_get, METH_O, NULL},
-	 { (char *)"ldb_module_next_set", _wrap_ldb_module_next_set, METH_VARARGS, NULL},
-	 { (char *)"ldb_module_next_get", (PyCFunction)_wrap_ldb_module_next_get, METH_O, NULL},
-	 { (char *)"ldb_module___str__", (PyCFunction)_wrap_ldb_module___str__, METH_O, NULL},
-	 { (char *)"ldb_module___repr__", (PyCFunction)_wrap_ldb_module___repr__, METH_O, NULL},
-	 { (char *)"ldb_module_search", (PyCFunction) _wrap_ldb_module_search, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"ldb_module_add", (PyCFunction) _wrap_ldb_module_add, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"ldb_module_modify", (PyCFunction) _wrap_ldb_module_modify, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"ldb_module_delete", (PyCFunction) _wrap_ldb_module_delete, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"ldb_module_rename", (PyCFunction) _wrap_ldb_module_rename, METH_VARARGS | METH_KEYWORDS, NULL},
-	 { (char *)"ldb_module_start_transaction", (PyCFunction)_wrap_ldb_module_start_transaction, METH_O, NULL},
-	 { (char *)"ldb_module_end_transaction", (PyCFunction)_wrap_ldb_module_end_transaction, METH_O, NULL},
-	 { (char *)"ldb_module_del_transaction", (PyCFunction)_wrap_ldb_module_del_transaction, METH_O, NULL},
-	 { (char *)"new_ldb_module", (PyCFunction)_wrap_new_ldb_module, METH_NOARGS, NULL},
-	 { (char *)"delete_ldb_module", (PyCFunction)_wrap_delete_ldb_module, METH_O, NULL},
-	 { (char *)"ldb_module_swigregister", ldb_module_swigregister, METH_VARARGS, NULL},
-	 { (char *)"ldb_module_swiginit", ldb_module_swiginit, METH_VARARGS, NULL},
-	 { (char *)"register_module", (PyCFunction) _wrap_register_module, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
-		"S.register_module(module) -> None\n"
-		"Register a LDB module.\n"
-		""},
-	 { NULL, NULL, 0, NULL }
-};
-
-
-/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
-
-static swig_type_info _swigt__p_TALLOC_CTX = {"_p_TALLOC_CTX", "TALLOC_CTX *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void = {"_p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void", "void (*)(void *,enum ldb_debug_level,char const *,va_list)", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_context = {"_p_ldb_context", "struct ldb_context *|ldb *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_dn = {"_p_ldb_dn", "struct ldb_dn *|ldb_dn *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_ldif = {"_p_ldb_ldif", "struct ldb_ldif *|ldb_ldif *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_message = {"_p_ldb_message", "ldb_msg *|struct ldb_message *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_message_element = {"_p_ldb_message_element", "struct ldb_message_element *|ldb_message_element *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_module = {"_p_ldb_module", "struct ldb_module *|ldb_module *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_module_ops = {"_p_ldb_module_ops", "struct ldb_module_ops *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_parse_tree = {"_p_ldb_parse_tree", "struct ldb_parse_tree *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_result = {"_p_ldb_result", "struct ldb_result *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ldb_val = {"_p_ldb_val", "struct ldb_val *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_p_ldb_control = {"_p_p_ldb_control", "struct ldb_control **", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_p_ldb_result = {"_p_p_ldb_result", "struct ldb_result **", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|time_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
-
-static swig_type_info *swig_type_initial[] = {
-  &_swigt__p_TALLOC_CTX,
-  &_swigt__p_char,
-  &_swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
-  &_swigt__p_int,
-  &_swigt__p_ldb_context,
-  &_swigt__p_ldb_dn,
-  &_swigt__p_ldb_ldif,
-  &_swigt__p_ldb_message,
-  &_swigt__p_ldb_message_element,
-  &_swigt__p_ldb_module,
-  &_swigt__p_ldb_module_ops,
-  &_swigt__p_ldb_parse_tree,
-  &_swigt__p_ldb_result,
-  &_swigt__p_ldb_val,
-  &_swigt__p_long_long,
-  &_swigt__p_p_char,
-  &_swigt__p_p_ldb_control,
-  &_swigt__p_p_ldb_result,
-  &_swigt__p_short,
-  &_swigt__p_signed_char,
-  &_swigt__p_unsigned_char,
-  &_swigt__p_unsigned_int,
-  &_swigt__p_unsigned_long,
-  &_swigt__p_unsigned_long_long,
-  &_swigt__p_unsigned_short,
-  &_swigt__p_void,
-};
-
-static swig_cast_info _swigc__p_TALLOC_CTX[] = {  {&_swigt__p_TALLOC_CTX, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void[] = {  {&_swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_context[] = {  {&_swigt__p_ldb_context, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_dn[] = {  {&_swigt__p_ldb_dn, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_ldif[] = {  {&_swigt__p_ldb_ldif, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_message[] = {  {&_swigt__p_ldb_message, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_message_element[] = {  {&_swigt__p_ldb_message_element, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_module[] = {  {&_swigt__p_ldb_module, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_module_ops[] = {  {&_swigt__p_ldb_module_ops, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_parse_tree[] = {  {&_swigt__p_ldb_parse_tree, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_result[] = {  {&_swigt__p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ldb_val[] = {  {&_swigt__p_ldb_val, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_p_ldb_control[] = {  {&_swigt__p_p_ldb_control, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_p_ldb_result[] = {  {&_swigt__p_p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
-
-static swig_cast_info *swig_cast_initial[] = {
-  _swigc__p_TALLOC_CTX,
-  _swigc__p_char,
-  _swigc__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
-  _swigc__p_int,
-  _swigc__p_ldb_context,
-  _swigc__p_ldb_dn,
-  _swigc__p_ldb_ldif,
-  _swigc__p_ldb_message,
-  _swigc__p_ldb_message_element,
-  _swigc__p_ldb_module,
-  _swigc__p_ldb_module_ops,
-  _swigc__p_ldb_parse_tree,
-  _swigc__p_ldb_result,
-  _swigc__p_ldb_val,
-  _swigc__p_long_long,
-  _swigc__p_p_char,
-  _swigc__p_p_ldb_control,
-  _swigc__p_p_ldb_result,
-  _swigc__p_short,
-  _swigc__p_signed_char,
-  _swigc__p_unsigned_char,
-  _swigc__p_unsigned_int,
-  _swigc__p_unsigned_long,
-  _swigc__p_unsigned_long_long,
-  _swigc__p_unsigned_short,
-  _swigc__p_void,
-};
-
-
-/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
-
-static swig_const_info swig_const_table[] = {
-{0, 0, 0, 0.0, 0, 0}};
-
-#ifdef __cplusplus
-}
-#endif
-/* -----------------------------------------------------------------------------
- * Type initialization:
- * This problem is tough by the requirement that no dynamic 
- * memory is used. Also, since swig_type_info structures store pointers to 
- * swig_cast_info structures and swig_cast_info structures store pointers back
- * to swig_type_info structures, we need some lookup code at initialization. 
- * The idea is that swig generates all the structures that are needed. 
- * The runtime then collects these partially filled structures. 
- * The SWIG_InitializeModule function takes these initial arrays out of 
- * swig_module, and does all the lookup, filling in the swig_module.types
- * array with the correct data and linking the correct swig_cast_info
- * structures together.
- *
- * The generated swig_type_info structures are assigned staticly to an initial 
- * array. We just loop through that array, and handle each type individually.
- * First we lookup if this type has been already loaded, and if so, use the
- * loaded structure instead of the generated one. Then we have to fill in the
- * cast linked list. The cast data is initially stored in something like a
- * two-dimensional array. Each row corresponds to a type (there are the same
- * number of rows as there are in the swig_type_initial array). Each entry in
- * a column is one of the swig_cast_info structures for that type.
- * The cast_initial array is actually an array of arrays, because each row has
- * a variable number of columns. So to actually build the cast linked list,
- * we find the array of casts associated with the type, and loop through it 
- * adding the casts to the list. The one last trick we need to do is making
- * sure the type pointer in the swig_cast_info struct is correct.
- *
- * First off, we lookup the cast->type name to see if it is already loaded. 
- * There are three cases to handle:
- *  1) If the cast->type has already been loaded AND the type we are adding
- *     casting info to has not been loaded (it is in this module), THEN we
- *     replace the cast->type pointer with the type pointer that has already
- *     been loaded.
- *  2) If BOTH types (the one we are adding casting info to, and the 
- *     cast->type) are loaded, THEN the cast info has already been loaded by
- *     the previous module so we just ignore it.
- *  3) Finally, if cast->type has not already been loaded, then we add that
- *     swig_cast_info to the linked list (because the cast->type) pointer will
- *     be correct.
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-extern "C" {
-#if 0
-} /* c-mode */
-#endif
-#endif
-
-#if 0
-#define SWIGRUNTIME_DEBUG
-#endif
-
-
-SWIGRUNTIME void
-SWIG_InitializeModule(void *clientdata) {
-  size_t i;
-  swig_module_info *module_head, *iter;
-  int found, init;
-  
-  clientdata = clientdata;
-  
-  /* check to see if the circular list has been setup, if not, set it up */
-  if (swig_module.next==0) {
-    /* Initialize the swig_module */
-    swig_module.type_initial = swig_type_initial;
-    swig_module.cast_initial = swig_cast_initial;
-    swig_module.next = &swig_module;
-    init = 1;
-  } else {
-    init = 0;
-  }
-  
-  /* Try and load any already created modules */
-  module_head = SWIG_GetModule(clientdata);
-  if (!module_head) {
-    /* This is the first module loaded for this interpreter */
-    /* so set the swig module into the interpreter */
-    SWIG_SetModule(clientdata, &swig_module);
-    module_head = &swig_module;
-  } else {
-    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
-    found=0;
-    iter=module_head;
-    do {
-      if (iter==&swig_module) {
-        found=1;
-        break;
-      }
-      iter=iter->next;
-    } while (iter!= module_head);
-    
-    /* if the is found in the list, then all is done and we may leave */
-    if (found) return;
-    /* otherwise we must add out module into the list */
-    swig_module.next = module_head->next;
-    module_head->next = &swig_module;
-  }
-  
-  /* When multiple interpeters are used, a module could have already been initialized in
-       a different interpreter, but not yet have a pointer in this interpreter.
-       In this case, we do not want to continue adding types... everything should be
-       set up already */
-  if (init == 0) return;
-  
-  /* Now work on filling in swig_module.types */
-#ifdef SWIGRUNTIME_DEBUG
-  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
-#endif
-  for (i = 0; i < swig_module.size; ++i) {
-    swig_type_info *type = 0;
-    swig_type_info *ret;
-    swig_cast_info *cast;
-    
-#ifdef SWIGRUNTIME_DEBUG
-    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
-#endif
-    
-    /* if there is another module already loaded */
-    if (swig_module.next != &swig_module) {
-      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
-    }
-    if (type) {
-      /* Overwrite clientdata field */
-#ifdef SWIGRUNTIME_DEBUG
-      printf("SWIG_InitializeModule: found type %s\n", type->name);
-#endif
-      if (swig_module.type_initial[i]->clientdata) {
-        type->clientdata = swig_module.type_initial[i]->clientdata;
-#ifdef SWIGRUNTIME_DEBUG
-        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
-#endif
-      }
-    } else {
-      type = swig_module.type_initial[i];
-    }
-    
-    /* Insert casting types */
-    cast = swig_module.cast_initial[i];
-    while (cast->type) {
-      /* Don't need to add information already in the list */
-      ret = 0;
-#ifdef SWIGRUNTIME_DEBUG
-      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
-#endif
-      if (swig_module.next != &swig_module) {
-        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
-#ifdef SWIGRUNTIME_DEBUG
-        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
-#endif
-      }
-      if (ret) {
-        if (type == swig_module.type_initial[i]) {
-#ifdef SWIGRUNTIME_DEBUG
-          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
-#endif
-          cast->type = ret;
-          ret = 0;
-        } else {
-          /* Check for casting already in the list */
-          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
-#ifdef SWIGRUNTIME_DEBUG
-          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
-#endif
-          if (!ocast) ret = 0;
-        }
-      }
-      
-      if (!ret) {
-#ifdef SWIGRUNTIME_DEBUG
-        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
-#endif
-        if (type->cast) {
-          type->cast->prev = cast;
-          cast->next = type->cast;
-        }
-        type->cast = cast;
-      }
-      cast++;
-    }
-    /* Set entry in modules->types array equal to the type */
-    swig_module.types[i] = type;
-  }
-  swig_module.types[i] = 0;
-  
-#ifdef SWIGRUNTIME_DEBUG
-  printf("**** SWIG_InitializeModule: Cast List ******\n");
-  for (i = 0; i < swig_module.size; ++i) {
-    int j = 0;
-    swig_cast_info *cast = swig_module.cast_initial[i];
-    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
-    while (cast->type) {
-      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
-      cast++;
-      ++j;
-    }
-    printf("---- Total casts: %d\n",j);
-  }
-  printf("**** SWIG_InitializeModule: Cast List ******\n");
-#endif
-}
-
-/* This function will propagate the clientdata field of type to
-* any new swig_type_info structures that have been added into the list
-* of equivalent types.  It is like calling
-* SWIG_TypeClientData(type, clientdata) a second time.
-*/
-SWIGRUNTIME void
-SWIG_PropagateClientData(void) {
-  size_t i;
-  swig_cast_info *equiv;
-  static int init_run = 0;
-  
-  if (init_run) return;
-  init_run = 1;
-  
-  for (i = 0; i < swig_module.size; i++) {
-    if (swig_module.types[i]->clientdata) {
-      equiv = swig_module.types[i]->cast;
-      while (equiv) {
-        if (!equiv->converter) {
-          if (equiv->type && !equiv->type->clientdata)
-          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
-        }
-        equiv = equiv->next;
-      }
-    }
-  }
-}
-
-#ifdef __cplusplus
-#if 0
-{
-  /* c-mode */
-#endif
-}
-#endif
-
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-  
-  /* Python-specific SWIG API */
-#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
-#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
-#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
-  
-  /* -----------------------------------------------------------------------------
-   * global variable support code.
-   * ----------------------------------------------------------------------------- */
-  
-  typedef struct swig_globalvar {
-    char       *name;                  /* Name of global variable */
-    PyObject *(*get_attr)(void);       /* Return the current value */
-    int       (*set_attr)(PyObject *); /* Set the value */
-    struct swig_globalvar *next;
-  } swig_globalvar;
-  
-  typedef struct swig_varlinkobject {
-    PyObject_HEAD
-    swig_globalvar *vars;
-  } swig_varlinkobject;
-  
-  SWIGINTERN PyObject *
-  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
-    return PyString_FromString("<Swig global variables>");
-  }
-  
-  SWIGINTERN PyObject *
-  swig_varlink_str(swig_varlinkobject *v) {
-    PyObject *str = PyString_FromString("(");
-    swig_globalvar  *var;
-    for (var = v->vars; var; var=var->next) {
-      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
-      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
-    }
-    PyString_ConcatAndDel(&str,PyString_FromString(")"));
-    return str;
-  }
-  
-  SWIGINTERN int
-  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
-    PyObject *str = swig_varlink_str(v);
-    fprintf(fp,"Swig global variables ");
-    fprintf(fp,"%s\n", PyString_AsString(str));
-    Py_DECREF(str);
-    return 0;
-  }
-  
-  SWIGINTERN void
-  swig_varlink_dealloc(swig_varlinkobject *v) {
-    swig_globalvar *var = v->vars;
-    while (var) {
-      swig_globalvar *n = var->next;
-      free(var->name);
-      free(var);
-      var = n;
-    }
-  }
-  
-  SWIGINTERN PyObject *
-  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
-    PyObject *res = NULL;
-    swig_globalvar *var = v->vars;
-    while (var) {
-      if (strcmp(var->name,n) == 0) {
-        res = (*var->get_attr)();
-        break;
-      }
-      var = var->next;
-    }
-    if (res == NULL && !PyErr_Occurred()) {
-      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
-    }
-    return res;
-  }
-  
-  SWIGINTERN int
-  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
-    int res = 1;
-    swig_globalvar *var = v->vars;
-    while (var) {
-      if (strcmp(var->name,n) == 0) {
-        res = (*var->set_attr)(p);
-        break;
-      }
-      var = var->next;
-    }
-    if (res == 1 && !PyErr_Occurred()) {
-      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
-    }
-    return res;
-  }
-  
-  SWIGINTERN PyTypeObject*
-  swig_varlink_type(void) {
-    static char varlink__doc__[] = "Swig var link object";
-    static PyTypeObject varlink_type;
-    static int type_init = 0;  
-    if (!type_init) {
-      const PyTypeObject tmp
-      = {
-        PyObject_HEAD_INIT(NULL)
-        0,                                  /* Number of items in variable part (ob_size) */
-        (char *)"swigvarlink",              /* Type name (tp_name) */
-        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
-        0,                                  /* Itemsize (tp_itemsize) */
-        (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */ 
-        (printfunc) swig_varlink_print,     /* Print (tp_print) */
-        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
-        (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
-        0,                                  /* tp_compare */
-        (reprfunc) swig_varlink_repr,       /* tp_repr */
-        0,                                  /* tp_as_number */
-        0,                                  /* tp_as_sequence */
-        0,                                  /* tp_as_mapping */
-        0,                                  /* tp_hash */
-        0,                                  /* tp_call */
-        (reprfunc)swig_varlink_str,        /* tp_str */
-        0,                                  /* tp_getattro */
-        0,                                  /* tp_setattro */
-        0,                                  /* tp_as_buffer */
-        0,                                  /* tp_flags */
-        varlink__doc__,                     /* tp_doc */
-        0,                                  /* tp_traverse */
-        0,                                  /* tp_clear */
-        0,                                  /* tp_richcompare */
-        0,                                  /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
-        0,                                  /* tp_del */
-#endif
-#ifdef COUNT_ALLOCS
-        0,0,0,0                             /* tp_alloc -> tp_next */
-#endif
-      };
-      varlink_type = tmp;
-      varlink_type.ob_type = &PyType_Type;
-      type_init = 1;
-    }
-    return &varlink_type;
-  }
-  
-  /* Create a variable linking object for use later */
-  SWIGINTERN PyObject *
-  SWIG_Python_newvarlink(void) {
-    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
-    if (result) {
-      result->vars = 0;
-    }
-    return ((PyObject*) result);
-  }
-  
-  SWIGINTERN void 
-  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
-    swig_varlinkobject *v = (swig_varlinkobject *) p;
-    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
-    if (gv) {
-      size_t size = strlen(name)+1;
-      gv->name = (char *)malloc(size);
-      if (gv->name) {
-        strncpy(gv->name,name,size);
-        gv->get_attr = get_attr;
-        gv->set_attr = set_attr;
-        gv->next = v->vars;
-      }
-    }
-    v->vars = gv;
-  }
-  
-  SWIGINTERN PyObject *
-  SWIG_globals(void) {
-    static PyObject *_SWIG_globals = 0; 
-    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
-    return _SWIG_globals;
-  }
-  
-  /* -----------------------------------------------------------------------------
-   * constants/methods manipulation
-   * ----------------------------------------------------------------------------- */
-  
-  /* Install Constants */
-  SWIGINTERN void
-  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
-    PyObject *obj = 0;
-    size_t i;
-    for (i = 0; constants[i].type; ++i) {
-      switch(constants[i].type) {
-      case SWIG_PY_POINTER:
-        obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
-        break;
-      case SWIG_PY_BINARY:
-        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
-        break;
-      default:
-        obj = 0;
-        break;
-      }
-      if (obj) {
-        PyDict_SetItemString(d, constants[i].name, obj);
-        Py_DECREF(obj);
-      }
-    }
-  }
-  
-  /* -----------------------------------------------------------------------------*/
-  /* Fix SwigMethods to carry the callback ptrs when needed */
-  /* -----------------------------------------------------------------------------*/
-  
-  SWIGINTERN void
-  SWIG_Python_FixMethods(PyMethodDef *methods,
-    swig_const_info *const_table,
-    swig_type_info **types,
-    swig_type_info **types_initial) {
-    size_t i;
-    for (i = 0; methods[i].ml_name; ++i) {
-      const char *c = methods[i].ml_doc;
-      if (c && (c = strstr(c, "swig_ptr: "))) {
-        int j;
-        swig_const_info *ci = 0;
-        const char *name = c + 10;
-        for (j = 0; const_table[j].type; ++j) {
-          if (strncmp(const_table[j].name, name, 
-              strlen(const_table[j].name)) == 0) {
-            ci = &(const_table[j]);
-            break;
-          }
-        }
-        if (ci) {
-          size_t shift = (ci->ptype) - types;
-          swig_type_info *ty = types_initial[shift];
-          size_t ldoc = (c - methods[i].ml_doc);
-          size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
-          char *ndoc = (char*)malloc(ldoc + lptr + 10);
-          if (ndoc) {
-            char *buff = ndoc;
-            void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
-            if (ptr) {
-              strncpy(buff, methods[i].ml_doc, ldoc);
-              buff += ldoc;
-              strncpy(buff, "swig_ptr: ", 10);
-              buff += 10;
-              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
-              methods[i].ml_doc = ndoc;
-            }
-          }
-        }
-      }
-    }
-  } 
-  
-#ifdef __cplusplus
-}
-#endif
-
-/* -----------------------------------------------------------------------------*
- *  Partial Init method
- * -----------------------------------------------------------------------------*/
-
-#ifdef __cplusplus
-extern "C"
-#endif
-SWIGEXPORT void SWIG_init(void) {
-  PyObject *m, *d;
-  
-  /* Fix SwigMethods to carry the callback ptrs when needed */
-  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
-  
-  m = Py_InitModule((char *) SWIG_name, SwigMethods);
-  d = PyModule_GetDict(m);
-  
-  SWIG_InitializeModule(0);
-  SWIG_InstallConstants(d,swig_const_table);
-  
-  
-  SWIG_Python_SetConstant(d, "SCOPE_DEFAULT",SWIG_From_int((int)(LDB_SCOPE_DEFAULT)));
-  SWIG_Python_SetConstant(d, "SCOPE_BASE",SWIG_From_int((int)(LDB_SCOPE_BASE)));
-  SWIG_Python_SetConstant(d, "SCOPE_ONELEVEL",SWIG_From_int((int)(LDB_SCOPE_ONELEVEL)));
-  SWIG_Python_SetConstant(d, "SCOPE_SUBTREE",SWIG_From_int((int)(LDB_SCOPE_SUBTREE)));
-  SWIG_Python_SetConstant(d, "CHANGETYPE_NONE",SWIG_From_int((int)(LDB_CHANGETYPE_NONE)));
-  SWIG_Python_SetConstant(d, "CHANGETYPE_ADD",SWIG_From_int((int)(LDB_CHANGETYPE_ADD)));
-  SWIG_Python_SetConstant(d, "CHANGETYPE_DELETE",SWIG_From_int((int)(LDB_CHANGETYPE_DELETE)));
-  SWIG_Python_SetConstant(d, "CHANGETYPE_MODIFY",SWIG_From_int((int)(LDB_CHANGETYPE_MODIFY)));
-  
-  PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
-  PyDict_SetItemString(d, "LdbError", PyExc_LdbError);
-  
-  SWIG_Python_SetConstant(d, "LDB_ERR_OPERATIONS_ERROR",SWIG_From_int((int)(1)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_PROTOCOL_ERROR",SWIG_From_int((int)(2)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_TIME_LIMIT_EXCEEDED",SWIG_From_int((int)(3)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_SIZE_LIMIT_EXCEEDED",SWIG_From_int((int)(4)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_FALSE",SWIG_From_int((int)(5)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_TRUE",SWIG_From_int((int)(6)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_AUTH_METHOD_NOT_SUPPORTED",SWIG_From_int((int)(7)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_STRONG_AUTH_REQUIRED",SWIG_From_int((int)(8)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_REFERRAL",SWIG_From_int((int)(10)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_ADMIN_LIMIT_EXCEEDED",SWIG_From_int((int)(11)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION",SWIG_From_int((int)(12)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_CONFIDENTIALITY_REQUIRED",SWIG_From_int((int)(13)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_SASL_BIND_IN_PROGRESS",SWIG_From_int((int)(14)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_ATTRIBUTE",SWIG_From_int((int)(16)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE",SWIG_From_int((int)(17)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_MATCHING",SWIG_From_int((int)(18)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_CONSTRAINT_VIOLATION",SWIG_From_int((int)(19)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS",SWIG_From_int((int)(20)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_ATTRIBUTE_SYNTAX",SWIG_From_int((int)(21)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_OBJECT",SWIG_From_int((int)(32)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_PROBLEM",SWIG_From_int((int)(33)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_DN_SYNTAX",SWIG_From_int((int)(34)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_DEREFERENCING_PROBLEM",SWIG_From_int((int)(36)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_AUTHENTICATION",SWIG_From_int((int)(48)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_CREDENTIALS",SWIG_From_int((int)(49)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS",SWIG_From_int((int)(50)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_BUSY",SWIG_From_int((int)(51)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_UNAVAILABLE",SWIG_From_int((int)(52)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_UNWILLING_TO_PERFORM",SWIG_From_int((int)(53)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_LOOP_DETECT",SWIG_From_int((int)(54)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_NAMING_VIOLATION",SWIG_From_int((int)(64)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_VIOLATION",SWIG_From_int((int)(65)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_NON_LEAF",SWIG_From_int((int)(66)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_RDN",SWIG_From_int((int)(67)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_ENTRY_ALREADY_EXISTS",SWIG_From_int((int)(68)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED",SWIG_From_int((int)(69)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_AFFECTS_MULTIPLE_DSAS",SWIG_From_int((int)(71)));
-  SWIG_Python_SetConstant(d, "LDB_ERR_OTHER",SWIG_From_int((int)(80)));
-}
-
diff --git a/ldb/libldb.m4 b/ldb/libldb.m4
index 77ebcc5ff..5653794a8 100644
--- a/ldb/libldb.m4
+++ b/ldb/libldb.m4
@@ -2,6 +2,6 @@
 # disable ldb_sqlite3 by default
 SMB_ENABLE(ldb_sqlite3, NO)
 
-if test x"$with_sqlite3_support" = x"yes"; then
-	SMB_ENABLE(ldb_sqlite3, YES)
-fi
+#if test x"$with_sqlite3_support" = x"yes"; then
+#	SMB_ENABLE(ldb_sqlite3, YES)
+#fi
diff --git a/ldb/modules/asq.c b/ldb/modules/asq.c
index 835715e7d..c650970af 100644
--- a/ldb/modules/asq.c
+++ b/ldb/modules/asq.c
@@ -178,7 +178,7 @@ static int asq_reqs_callback(struct ldb_request *req, struct ldb_reply *ares)
 	case LDB_REPLY_ENTRY:
 		/* pass the message up to the original callback as we
 		 * do not have to elaborate on it any further */
-		ret = ldb_module_send_entry(ac->req, ares->message);
+		ret = ldb_module_send_entry(ac->req, ares->message, ares->controls);
 		if (ret != LDB_SUCCESS) {
 			return ldb_module_done(ac->req, NULL, NULL, ret);
 		}
diff --git a/ldb/modules/operational.c b/ldb/modules/operational.c
index abb1d4ca1..345441b5e 100644
--- a/ldb/modules/operational.c
+++ b/ldb/modules/operational.c
@@ -206,7 +206,7 @@ static int operational_callback(struct ldb_request *req, struct ldb_reply *ares)
 			return ldb_module_done(ac->req, NULL, NULL,
 						LDB_ERR_OPERATIONS_ERROR);
 		}
-		return ldb_module_send_entry(ac->req, ares->message);
+		return ldb_module_send_entry(ac->req, ares->message, ares->controls);
 
 	case LDB_REPLY_REFERRAL:
 		/* ignore referrals */
diff --git a/ldb/modules/paged_results.c b/ldb/modules/paged_results.c
index d3bb83bbc..dfc565fef 100644
--- a/ldb/modules/paged_results.c
+++ b/ldb/modules/paged_results.c
@@ -70,7 +70,7 @@ struct private_data {
 	
 };
 
-int store_destructor(struct results_store *del)
+static int store_destructor(struct results_store *del)
 {
 	struct private_data *priv = del->priv;
 	struct results_store *loop;
@@ -147,7 +147,7 @@ static int paged_results(struct paged_context *ac)
 
 	while (ac->store->num_entries > 0 && ac->size > 0) {
 		msg = ac->store->first;
-		ret = ldb_module_send_entry(ac->req, msg->r->message);
+		ret = ldb_module_send_entry(ac->req, msg->r->message, msg->r->controls);
 		if (ret != LDB_SUCCESS) {
 			return ret;
 		}
diff --git a/ldb/modules/paged_searches.c b/ldb/modules/paged_searches.c
index 7a728e3bb..56f9b1cac 100644
--- a/ldb/modules/paged_searches.c
+++ b/ldb/modules/paged_searches.c
@@ -161,7 +161,7 @@ static int ps_callback(struct ldb_request *req, struct ldb_reply *ares)
 
 	switch (ares->type) {
 	case LDB_REPLY_ENTRY:
-		ret = ldb_module_send_entry(ac->req, ares->message);
+		ret = ldb_module_send_entry(ac->req, ares->message, ares->controls);
 		if (ret != LDB_SUCCESS) {
 			return ldb_module_done(ac->req, NULL, NULL, ret);
 		}
diff --git a/ldb/modules/sort.c b/ldb/modules/sort.c
index 64d60f370..25e56b24c 100644
--- a/ldb/modules/sort.c
+++ b/ldb/modules/sort.c
@@ -152,7 +152,7 @@ static int server_sort_results(struct sort_context *ac)
 		ares->type = LDB_REPLY_ENTRY;
 		ares->message = talloc_move(ares, &ac->msgs[i]);
 
-		ret = ldb_module_send_entry(ac->req, ares->message);
+		ret = ldb_module_send_entry(ac->req, ares->message, ares->controls);
 		if (ret != LDB_SUCCESS) {
 			return ret;
 		}
diff --git a/ldb/pyldb.c b/ldb/pyldb.c
new file mode 100644
index 000000000..dfabed54e
--- /dev/null
+++ b/ldb/pyldb.c
@@ -0,0 +1,1994 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   Swig interface to ldb.
+
+   Copyright (C) 2005,2006 Tim Potter <tpot@samba.org>
+   Copyright (C) 2006 Simo Sorce <idra@samba.org>
+   Copyright (C) 2007-2008 Jelmer Vernooij <jelmer@samba.org>
+
+	 ** NOTE! The following LGPL license applies to the ldb
+	 ** library. This does NOT imply that all of Samba is released
+	 ** under the LGPL
+   
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "pyldb.h"
+#include "events.h"
+#include "ldb.h"
+#include "ldb_errors.h"
+#include "ldb_private.h"
+
+/* Picked out of thin air. To do this properly, we should probably have some part of the 
+ * errors in LDB be allocated to bindings ? */
+#define LDB_ERR_PYTHON_EXCEPTION	142
+
+PyObject *PyExc_LdbError;
+
+void PyErr_SetLdbError(int ret, struct ldb_context *ldb_ctx)
+{
+	if (ret == LDB_ERR_PYTHON_EXCEPTION)
+		return; /* Python exception should already be set, just keep that */
+	PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", ret, ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx)));
+}
+PyObject *PyObject_FromLdbValue(struct ldb_context *ldb_ctx, 
+							   struct ldb_message_element *el, 
+							   struct ldb_val *val)
+{
+	const struct ldb_schema_attribute *a;
+	struct ldb_val new_val;
+	TALLOC_CTX *mem_ctx = talloc_new(NULL);
+	PyObject *ret;
+	
+	new_val = *val;
+	
+	if (ldb_ctx != NULL) {		
+		a = ldb_schema_attribute_by_name(ldb_ctx, el->name);
+	
+		if (a != NULL) {
+			if (a->syntax->ldif_write_fn(ldb_ctx, mem_ctx, val, &new_val) != 0) {
+				talloc_free(mem_ctx);
+				return NULL;
+			}
+		}
+	} 
+	
+	ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
+	
+	talloc_free(mem_ctx);
+	
+	return ret;
+}
+
+bool PyObject_AsDn(TALLOC_CTX *mem_ctx, PyObject *object, 
+		   struct ldb_context *ldb_ctx, struct ldb_dn **dn)
+{
+	struct ldb_dn *odn;
+
+	if (ldb_ctx != NULL && PyString_Check(object)) {
+		odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
+		*dn = odn;
+		return true;
+	}
+
+	if (PyLdbDn_Check(object)) {
+		*dn = PyLdbDn_AsDn(object);
+		return true;
+	}
+
+	PyErr_SetString(PyExc_TypeError, "Expected DN");
+	return false;
+}
+
+static PyObject *PyLdbResult_FromResult(struct ldb_result *result)
+{
+	PyObject *ret;
+	int i;
+	if (result == NULL) {
+		return Py_None;
+	} 
+	ret = PyList_New(result->count);
+	for (i = 0; i < result->count; i++) {
+		PyList_SetItem(ret, i, PyLdbMessage_FromMessage(result->msgs[i])
+		);
+	}
+	return ret;
+}
+
+static struct ldb_result *PyLdbResult_AsResult(TALLOC_CTX *mem_ctx, PyObject *obj)
+{
+	struct ldb_result *res;
+	int i;
+	
+	if (obj == Py_None)
+		return NULL;
+
+	res = talloc_zero(mem_ctx, struct ldb_result);
+	res->count = PyList_Size(obj);
+	res->msgs = talloc_array(res, struct ldb_message *, res->count);
+	for (i = 0; i < res->count; i++) {
+		PyObject *item = PyList_GetItem(obj, i);
+		res->msgs[i] = PyLdbMessage_AsMessage(item);
+	}
+	return res;
+}
+
+static PyObject *py_ldb_dn_validate(PyLdbDnObject *self)
+{
+	return PyBool_FromLong(ldb_dn_validate(self->ptr));
+}
+
+static PyObject *py_ldb_dn_is_valid(PyLdbDnObject *self)
+{
+	return PyBool_FromLong(ldb_dn_is_valid(self->ptr));
+}
+
+static PyObject *py_ldb_dn_is_special(PyLdbDnObject *self)
+{
+	return PyBool_FromLong(ldb_dn_is_special(self->ptr));
+}
+
+static PyObject *py_ldb_dn_is_null(PyLdbDnObject *self)
+{
+	return PyBool_FromLong(ldb_dn_is_null(self->ptr));
+}
+ 
+static PyObject *py_ldb_dn_get_casefold(PyLdbDnObject *self)
+{
+	return PyString_FromString(ldb_dn_get_casefold(self->ptr));
+}
+
+static PyObject *py_ldb_dn_get_linearized(PyLdbDnObject *self)
+{
+	return PyString_FromString(ldb_dn_get_linearized(self->ptr));
+}
+
+static PyObject *py_ldb_dn_canonical_str(PyLdbDnObject *self)
+{
+	return PyString_FromString(ldb_dn_canonical_string(self->ptr, self->ptr));
+}
+
+static PyObject *py_ldb_dn_canonical_ex_str(PyLdbDnObject *self)
+{
+	return PyString_FromString(ldb_dn_canonical_ex_string(self->ptr, self->ptr));
+}
+
+static PyObject *py_ldb_dn_repr(PyLdbDnObject *self)
+{
+	return PyString_FromFormat("Dn(%s)", PyObject_REPR(PyString_FromString(ldb_dn_get_linearized(self->ptr))));
+}
+
+static PyObject *py_ldb_dn_check_special(PyLdbDnObject *self, PyObject *args)
+{
+	char *name;
+
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return NULL;
+
+	return ldb_dn_check_special(self->ptr, name)?Py_True:Py_False;
+}
+
+static int py_ldb_dn_compare(PyLdbDnObject *dn1, PyLdbDnObject *dn2)
+{
+	return ldb_dn_compare(dn1->ptr, dn2->ptr);
+}
+
+static PyObject *py_ldb_dn_get_parent(PyLdbDnObject *self)
+{
+	struct ldb_dn *dn = PyLdbDn_AsDn((PyObject *)self);
+	return PyLdbDn_FromDn(ldb_dn_get_parent(NULL, dn));
+}
+
+#define dn_ldb_ctx(dn) ((struct ldb_context *)dn)
+
+static PyObject *py_ldb_dn_add_child(PyLdbDnObject *self, PyObject *args)
+{
+	PyObject *py_other;
+	struct ldb_dn *dn, *other;
+	if (!PyArg_ParseTuple(args, "O", &py_other))
+		return NULL;
+
+	dn = PyLdbDn_AsDn((PyObject *)self);
+
+	if (!PyObject_AsDn(NULL, py_other, dn_ldb_ctx(dn), &other))
+		return NULL;
+
+	return ldb_dn_add_child(dn, other)?Py_True:Py_False;
+}
+
+static PyObject *py_ldb_dn_add_base(PyLdbDnObject *self, PyObject *args)
+{
+	PyObject *py_other;
+	struct ldb_dn *other, *dn;
+	if (!PyArg_ParseTuple(args, "O", &py_other))
+		return NULL;
+
+	dn = PyLdbDn_AsDn((PyObject *)self);
+
+	if (!PyObject_AsDn(NULL, py_other, dn_ldb_ctx(dn), &other))
+		return NULL;
+
+	return ldb_dn_add_base(dn, other)?Py_True:Py_False;
+}
+
+static PyMethodDef py_ldb_dn_methods[] = {
+	{ "validate", (PyCFunction)py_ldb_dn_validate, METH_NOARGS, 
+		"S.validate() -> bool\n"
+		"Validate DN is correct." },
+	{ "is_valid", (PyCFunction)py_ldb_dn_is_valid, METH_NOARGS,
+		"S.is_valid() -> bool\n" },
+	{ "is_special", (PyCFunction)py_ldb_dn_is_special, METH_NOARGS,
+		"S.is_special() -> bool\n"
+		"Check whether this is a special LDB DN." },
+	{ "is_null", (PyCFunction)py_ldb_dn_is_null, METH_NOARGS,
+		"Check whether this is a null DN." },
+	{ "get_casefold", (PyCFunction)py_ldb_dn_get_casefold, METH_NOARGS,
+		NULL },
+	{ "get_linearized", (PyCFunction)py_ldb_dn_get_linearized, METH_NOARGS,
+		NULL },
+	{ "canonical_str", (PyCFunction)py_ldb_dn_canonical_str, METH_NOARGS,
+		"S.canonical_str() -> string\n"
+		"Canonical version of this DN (like a posix path)." },
+	{ "canonical_ex_str", (PyCFunction)py_ldb_dn_canonical_ex_str, METH_NOARGS,
+		"S.canonical_ex_str() -> string\n"
+		"Canonical version of this DN (like a posix path, with terminating newline)." },
+	{ "check_special", (PyCFunction)py_ldb_dn_is_special, METH_VARARGS, 
+		NULL },
+	{ "parent", (PyCFunction)py_ldb_dn_get_parent, METH_NOARGS,
+   		"S.parent() -> dn\n"
+		"Get the parent for this DN." },
+	{ "add_child", (PyCFunction)py_ldb_dn_add_child, METH_VARARGS, 
+		"S.add_child(dn) -> None\n"
+		"Add a child DN to this DN." },
+	{ "add_base", (PyCFunction)py_ldb_dn_add_base, METH_VARARGS,
+		"S.add_base(dn) -> None\n"
+		"Add a base DN to this DN." },
+	{ "check_special", (PyCFunction)py_ldb_dn_check_special, METH_VARARGS,
+		NULL },
+	{ NULL }
+};
+
+static Py_ssize_t py_ldb_dn_len(PyLdbDnObject *self)
+{
+	return ldb_dn_get_comp_num(PyLdbDn_AsDn((PyObject *)self));
+}
+
+static PyObject *py_ldb_dn_concat(PyLdbDnObject *self, PyObject *py_other)
+{
+	struct ldb_dn *dn = PyLdbDn_AsDn((PyObject *)self), 
+				  *other;
+	struct ldb_dn *ret = ldb_dn_copy(NULL, dn);
+	if (!PyObject_AsDn(NULL, py_other, NULL, &other))
+		return NULL;
+	ldb_dn_add_child(ret, other);
+	return PyLdbDn_FromDn(ret);
+}
+
+static PySequenceMethods py_ldb_dn_seq = {
+	.sq_length = (lenfunc)py_ldb_dn_len,
+	.sq_concat = (binaryfunc)py_ldb_dn_concat,
+};
+
+static PyObject *py_ldb_dn_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+	struct ldb_dn *ret;
+	char *str;
+	PyObject *py_ldb;
+	struct ldb_context *ldb_ctx;
+	const char *kwnames[] = { "ldb", "dn", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Os", (char **)kwnames, &py_ldb, &str))
+		return NULL;
+
+	ldb_ctx = PyLdb_AsLdbContext(py_ldb);
+	
+	ret = ldb_dn_new(ldb_ctx, ldb_ctx, str);
+	/* ldb_dn_new() doesn't accept NULL as memory context, so 
+	   we do it this way... */
+	talloc_steal(NULL, ret);
+
+	if (ret == NULL || !ldb_dn_validate(ret)) {
+		PyErr_SetString(PyExc_ValueError, "unable to parse dn string");
+		return NULL;
+	}
+
+	return py_talloc_import(&PyLdbDn, ret);
+}
+
+PyObject *PyLdbDn_FromDn(struct ldb_dn *dn)
+{
+	return py_talloc_import(&PyLdbDn, dn);
+}
+
+PyTypeObject PyLdbDn = {
+	.tp_name = "Dn",
+	.tp_methods = py_ldb_dn_methods,
+	.tp_str = (reprfunc)py_ldb_dn_get_linearized,
+	.tp_repr = (reprfunc)py_ldb_dn_repr,
+	.tp_compare = (cmpfunc)py_ldb_dn_compare,
+	.tp_as_sequence = &py_ldb_dn_seq,
+	.tp_doc = "A LDB distinguished name.",
+	.tp_new = py_ldb_dn_new,
+	.tp_dealloc = py_talloc_dealloc,
+	.tp_basicsize = sizeof(PyLdbObject),
+	.tp_flags = Py_TPFLAGS_DEFAULT,
+};
+
+/* Debug */
+static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
+static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
+{
+	PyObject *fn = context;
+	PyObject_CallFunction(fn, (char *)"(i,O)", level, PyString_FromFormatV(fmt, ap));
+}
+
+static PyObject *py_ldb_set_debug(PyLdbObject *self, PyObject *args)
+{
+	PyObject *cb;
+	
+	if (!PyArg_ParseTuple(args, "O", &cb))
+		return NULL;
+
+	Py_INCREF(cb);
+	/* FIXME: Where do we DECREF cb ? */
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_set_debug(self->ptr, py_ldb_debug, cb), PyLdb_AsLdbContext(self));
+	
+	return Py_None;
+}
+
+static PyObject *py_ldb_set_create_perms(PyTypeObject *self, PyObject *args)
+{
+	unsigned int perms;
+	if (!PyArg_ParseTuple(args, "I", &perms))
+		return NULL;
+
+	ldb_set_create_perms(PyLdb_AsLdbContext(self), perms);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_set_modules_dir(PyTypeObject *self, PyObject *args)
+{
+	char *modules_dir;
+	if (!PyArg_ParseTuple(args, "s", &modules_dir))
+		return NULL;
+
+	ldb_set_modules_dir(PyLdb_AsLdbContext(self), modules_dir);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_transaction_start(PyLdbObject *self)
+{
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_transaction_start(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
+	return Py_None;
+}
+
+static PyObject *py_ldb_transaction_commit(PyLdbObject *self)
+{
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_transaction_commit(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
+	return Py_None;
+}
+
+static PyObject *py_ldb_transaction_cancel(PyLdbObject *self)
+{
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_transaction_cancel(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
+	return Py_None;
+}
+
+static PyObject *py_ldb_setup_wellknown_attributes(PyLdbObject *self)
+{
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ldb_setup_wellknown_attributes(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
+	return Py_None;
+}
+
+static PyObject *py_ldb_repr(PyLdbObject *self)
+{
+	return PyString_FromFormat("<ldb connection>");
+}
+
+static PyObject *py_ldb_get_root_basedn(PyLdbObject *self)
+{
+	struct ldb_dn *dn = ldb_get_root_basedn(PyLdb_AsLdbContext(self));
+	if (dn == NULL)
+		return Py_None;
+	return PyLdbDn_FromDn(dn);
+}
+
+
+static PyObject *py_ldb_get_schema_basedn(PyLdbObject *self)
+{
+	struct ldb_dn *dn = ldb_get_schema_basedn(PyLdb_AsLdbContext(self));
+	if (dn == NULL)
+		return Py_None;
+	return PyLdbDn_FromDn(dn);
+}
+
+
+static PyObject *py_ldb_get_config_basedn(PyLdbObject *self)
+{
+	struct ldb_dn *dn = ldb_get_config_basedn(PyLdb_AsLdbContext(self));
+	if (dn == NULL)
+		return Py_None;
+	return PyLdbDn_FromDn(dn);
+}
+
+
+static PyObject *py_ldb_get_default_basedn(PyLdbObject *self)
+{
+	struct ldb_dn *dn = ldb_get_default_basedn(PyLdb_AsLdbContext(self));
+	if (dn == NULL)
+		return Py_None;
+	return PyLdbDn_FromDn(dn);
+}
+
+static const char **PyList_AsStringList(TALLOC_CTX *mem_ctx, PyObject *list)
+{
+	const char **ret;
+	int i;
+	if (!PyList_Check(list)) {
+		PyErr_SetString(PyExc_TypeError, "options is not a list");
+		return NULL;
+	}
+	ret = talloc_array(NULL, const char *, PyList_Size(list)+1);
+	for (i = 0; i < PyList_Size(list); i++) {
+		PyObject *item = PyList_GetItem(list, i);
+		if (!PyString_Check(item)) {
+			PyErr_SetString(PyExc_TypeError, "options should be strings");
+			return NULL;
+		}
+		ret[i] = PyString_AsString(item);
+	}
+	ret[i] = NULL;
+	return ret;
+}
+
+static int py_ldb_init(PyLdbObject *self, PyObject *args, PyObject *kwargs)
+{
+	const char *kwnames[] = { "url", "flags", "options", NULL };
+	char *url = NULL;
+	PyObject *py_options = Py_None;
+	const char **options;
+	int flags = 0;
+	int ret;
+	struct ldb_context *ldb;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ziO:Ldb.__init__", (char **)kwnames,
+									 &url, &flags, &py_options))
+		return -1;
+
+	ldb = PyLdb_AsLdbContext(self);
+
+	if (py_options == Py_None) {
+		options = NULL;
+	} else {
+		options = PyList_AsStringList(ldb, py_options);
+		if (options == NULL)
+			return -1;
+	}
+	
+	if (url != NULL) {
+		ret = ldb_connect(ldb, url, flags, options);
+		if (ret != LDB_SUCCESS) {
+			PyErr_SetLdbError(ret, ldb);
+			return -1;
+		}
+	}
+
+	talloc_free(options);
+	return 0;
+}
+
+static PyObject *py_ldb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+	struct ldb_context *ldb;
+	ldb = ldb_init(NULL, event_context_init(NULL)); 
+	if (ldb == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	return py_talloc_import(type, ldb);
+}
+
+static PyObject *py_ldb_connect(PyLdbObject *self, PyObject *args, PyObject *kwargs)
+{
+	char *url;
+	int flags;
+	PyObject *py_options = Py_None;
+	int ret;
+	const char **options;
+	const char *kwnames[] = { "url", "flags", "options", NULL };
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|iO", (char **)kwnames, &url, &flags,
+									 &py_options))
+		return NULL;
+
+	if (py_options == Py_None) {
+		options = NULL;
+	} else {
+		options = PyList_AsStringList(NULL, py_options);
+		if (options == NULL)
+			return NULL;
+	}
+	
+	ret = ldb_connect(PyLdb_AsLdbContext(self), url, flags, options);
+	talloc_free(options);
+
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_modify(PyLdbObject *self, PyObject *args)
+{
+	PyObject *py_msg;
+	int ret;
+	if (!PyArg_ParseTuple(args, "O", &py_msg))
+		return NULL;
+
+	if (!PyLdbMessage_Check(py_msg)) {
+		PyErr_SetString(PyExc_TypeError, "Expected Ldb Message");
+		return NULL;
+	}
+
+	ret = ldb_modify(PyLdb_AsLdbContext(self), PyLdbMessage_AsMessage(py_msg));
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_add(PyLdbObject *self, PyObject *args)
+{
+	PyObject *py_msg;
+	int ret;
+	Py_ssize_t dict_pos, msg_pos;
+	struct ldb_message_element *msgel;
+	struct ldb_message *msg;
+	PyObject *key, *value;
+
+	if (!PyArg_ParseTuple(args, "O", &py_msg))
+		return NULL;
+
+	if (PyDict_Check(py_msg)) {
+		PyObject *dn_value = PyDict_GetItemString(py_msg, "dn");
+		msg = ldb_msg_new(NULL);
+		msg->elements = talloc_zero_array(msg, struct ldb_message_element, PyDict_Size(py_msg));
+		msg_pos = dict_pos = 0;
+		if (dn_value) {
+		   	if (!PyObject_AsDn(msg, dn_value, PyLdb_AsLdbContext(self), &msg->dn)) {
+		   		PyErr_SetString(PyExc_TypeError, "unable to import dn object");
+				return NULL;
+			}
+			if (msg->dn == NULL) {
+				PyErr_SetString(PyExc_TypeError, "dn set but not found");
+				return NULL;
+			}
+		}
+
+		while (PyDict_Next(py_msg, &dict_pos, &key, &value)) {
+			char *key_str = PyString_AsString(key);
+			if (strcmp(key_str, "dn") != 0) {
+				msgel = PyObject_AsMessageElement(msg->elements, value, 0, key_str);
+				if (msgel == NULL) {
+					PyErr_SetString(PyExc_TypeError, "unable to import element");
+					return NULL;
+				}
+				memcpy(&msg->elements[msg_pos], msgel, sizeof(*msgel));
+				msg_pos++;
+			}
+		}
+
+		if (msg->dn == NULL) {
+			PyErr_SetString(PyExc_TypeError, "no dn set");
+			return NULL;
+		}
+
+		msg->num_elements = msg_pos;
+	} else {
+		msg = PyLdbMessage_AsMessage(py_msg);
+	}
+	
+	ret = ldb_add(PyLdb_AsLdbContext(self), msg);
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
+
+	return Py_None;
+}
+
+
+
+static PyObject *py_ldb_delete(PyLdbObject *self, PyObject *args)
+{
+	PyObject *py_dn;
+	struct ldb_dn *dn;
+	int ret;
+	struct ldb_context *ldb;
+	if (!PyArg_ParseTuple(args, "O", &py_dn))
+		return NULL;
+
+	ldb = PyLdb_AsLdbContext(self);
+
+	if (!PyObject_AsDn(NULL, py_dn, ldb, &dn))
+		return NULL;
+
+	ret = ldb_delete(ldb, dn);
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, ldb);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_rename(PyLdbObject *self, PyObject *args)
+{
+	PyObject *py_dn1, *py_dn2;
+	struct ldb_dn *dn1, *dn2;
+	int ret;
+	struct ldb_context *ldb;
+	if (!PyArg_ParseTuple(args, "OO", &py_dn1, &py_dn2))
+		return NULL;
+
+	ldb = PyLdb_AsLdbContext(self);
+	if (!PyObject_AsDn(NULL, py_dn1, ldb, &dn1))
+		return NULL;
+
+	if (!PyObject_AsDn(NULL, py_dn2, ldb, &dn2))
+		return NULL;
+
+	ret = ldb_rename(ldb, dn1, dn2);
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, ldb);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_schema_attribute_remove(PyLdbObject *self, PyObject *args)
+{
+	char *name;
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return NULL;
+
+	ldb_schema_attribute_remove(PyLdb_AsLdbContext(self), name);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_schema_attribute_add(PyLdbObject *self, PyObject *args)
+{
+	char *attribute, *syntax;
+	unsigned int flags;
+	int ret;
+	if (!PyArg_ParseTuple(args, "sIs", &attribute, &flags, &syntax))
+		return NULL;
+
+	ret = ldb_schema_attribute_add(PyLdb_AsLdbContext(self), attribute, flags, syntax);
+
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, PyLdb_AsLdbContext(self));
+
+	return Py_None;
+}
+
+static PyObject *ldb_ldif_to_pyobject(struct ldb_ldif *ldif)
+{
+	if (ldif == NULL) {
+		return Py_None;
+	} else {
+	/* We don't want this attached to the 'ldb' any more */
+		talloc_steal(NULL, ldif);
+		return Py_BuildValue((char *)"(iO)", ldif->changetype, 
+							 PyLdbMessage_FromMessage(ldif->msg));
+	}
+}
+
+
+static PyObject *py_ldb_parse_ldif(PyLdbObject *self, PyObject *args)
+{
+	PyObject *list;
+	struct ldb_ldif *ldif;
+	const char *s;
+
+	if (!PyArg_ParseTuple(args, "s", &s))
+		return NULL;
+
+	list = PyList_New(0);
+	while ((ldif = ldb_ldif_read_string(self->ptr, &s)) != NULL) {
+		PyList_Append(list, ldb_ldif_to_pyobject(ldif));
+	}
+	return PyObject_GetIter(list);
+}
+
+static PyObject *py_ldb_schema_format_value(PyLdbObject *self, PyObject *args)
+{
+	const struct ldb_schema_attribute *a;
+	struct ldb_val old_val;
+	struct ldb_val new_val;
+	TALLOC_CTX *mem_ctx;
+	PyObject *ret;
+	char *element_name;
+	PyObject *val;
+
+	if (!PyArg_ParseTuple(args, "sO", &element_name, &val))
+		return NULL;
+	
+	mem_ctx = talloc_new(NULL);
+	
+	old_val.data = (uint8_t *)PyString_AsString(val);
+	old_val.length = PyString_Size(val);
+		
+	a = ldb_schema_attribute_by_name(PyLdb_AsLdbContext(self), element_name);
+
+	if (a == NULL) {
+		return Py_None;
+	}
+	
+	if (a->syntax->ldif_write_fn(PyLdb_AsLdbContext(self), mem_ctx, &old_val, &new_val) != 0) {
+		talloc_free(mem_ctx);
+		return Py_None;
+	}
+
+	ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
+
+	talloc_free(mem_ctx);
+
+	return ret;
+}
+
+static PyObject *py_ldb_search(PyLdbObject *self, PyObject *args, PyObject *kwargs)
+{
+	PyObject *py_base = Py_None;
+	enum ldb_scope scope = LDB_SCOPE_DEFAULT;
+	char *expr = NULL;
+	PyObject *py_attrs = Py_None;
+	PyObject *py_controls = Py_None;
+	const char *kwnames[] = { "base", "scope", "expression", "attrs", "controls", NULL };
+	int ret;
+	struct ldb_result *res;
+	struct ldb_request *req;
+	const char **attrs;
+	struct ldb_context *ldb_ctx;
+	struct ldb_control **parsed_controls;
+	struct ldb_dn *base;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OizOO", (char **)kwnames,
+									 &py_base, &scope, &expr, &py_attrs, &py_controls))
+		return NULL;
+
+	ldb_ctx = PyLdb_AsLdbContext(self);
+
+	if (py_attrs == Py_None) {
+		attrs = NULL;
+	} else {
+		attrs = PyList_AsStringList(ldb_ctx, py_attrs);
+		if (attrs == NULL)
+			return NULL;
+	}
+
+	if (py_base == Py_None) {
+		base = ldb_get_default_basedn(ldb_ctx);
+	} else {
+		if (!PyObject_AsDn(ldb_ctx, py_base, ldb_ctx, &base))
+			return NULL;
+	}
+
+	if (py_controls == Py_None) {
+		parsed_controls = NULL;
+	} else {
+		const char **controls = PyList_AsStringList(ldb_ctx, py_controls);
+		parsed_controls = ldb_parse_control_strings(ldb_ctx, ldb_ctx, controls);
+		talloc_free(controls);
+	}
+
+	res = talloc_zero(ldb_ctx, struct ldb_result);
+	if (res == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	ret = ldb_build_search_req(&req, ldb_ctx, ldb_ctx,
+				   base,
+				   scope,
+				   expr,
+				   attrs,
+				   parsed_controls,
+				   res,
+				   ldb_search_default_callback,
+				   NULL);
+
+	if (ret != LDB_SUCCESS) {
+		talloc_free(res);
+		PyErr_LDB_ERROR_IS_ERR_RAISE(ret, ldb_ctx);
+		return NULL;
+	}
+
+	ret = ldb_request(ldb_ctx, req);
+		
+	if (ret == LDB_SUCCESS) {
+		ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+	}
+
+	talloc_free(req);
+
+	return PyLdbResult_FromResult(res);
+}
+
+static PyObject *py_ldb_get_opaque(PyLdbObject *self, PyObject *args)
+{
+	char *name;
+	void *data;
+
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return NULL;
+
+	data = ldb_get_opaque(PyLdb_AsLdbContext(self), name);
+
+	if (data == NULL)
+		return Py_None;
+
+	/* FIXME: More interpretation */
+
+	return Py_True;
+}
+
+static PyObject *py_ldb_set_opaque(PyLdbObject *self, PyObject *args)
+{
+	char *name;
+	PyObject *data;
+
+	if (!PyArg_ParseTuple(args, "sO", &name, &data))
+		return NULL;
+
+	/* FIXME: More interpretation */
+
+	ldb_set_opaque(PyLdb_AsLdbContext(self), name, data);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_modules(PyLdbObject *self)
+{
+	struct ldb_context *ldb = PyLdb_AsLdbContext(self);
+	PyObject *ret = PyList_New(0);
+	struct ldb_module *mod;
+
+	for (mod = ldb->modules; mod; mod = mod->next) {
+		PyList_Append(ret, PyLdbModule_FromModule(mod));
+	}
+
+	return ret;
+}
+
+static PyMethodDef py_ldb_methods[] = {
+	{ "set_debug", (PyCFunction)py_ldb_set_debug, METH_VARARGS, 
+		"S.set_debug(callback) -> None\n"
+		"Set callback for LDB debug messages.\n"
+		"The callback should accept a debug level and debug text." },
+	{ "set_create_perms", (PyCFunction)py_ldb_set_create_perms, METH_VARARGS, 
+		"S.set_create_perms(mode) -> None\n"
+		"Set mode to use when creating new LDB files." },
+	{ "set_modules_dir", (PyCFunction)py_ldb_set_modules_dir, METH_VARARGS,
+		"S.set_modules_dir(path) -> None\n"
+		"Set path LDB should search for modules" },
+	{ "transaction_start", (PyCFunction)py_ldb_transaction_start, METH_NOARGS, 
+		"S.transaction_start() -> None\n"
+		"Start a new transaction." },
+	{ "transaction_commit", (PyCFunction)py_ldb_transaction_commit, METH_NOARGS, 
+		"S.transaction_commit() -> None\n"
+		"commit a new transaction." },
+	{ "transaction_cancel", (PyCFunction)py_ldb_transaction_cancel, METH_NOARGS, 
+		"S.transaction_cancel() -> None\n"
+		"cancel a new transaction." },
+	{ "setup_wellknown_attributes", (PyCFunction)py_ldb_setup_wellknown_attributes, METH_NOARGS, 
+		NULL },
+	{ "get_root_basedn", (PyCFunction)py_ldb_get_root_basedn, METH_NOARGS,
+		NULL },
+	{ "get_schema_basedn", (PyCFunction)py_ldb_get_schema_basedn, METH_NOARGS,
+		NULL },
+	{ "get_default_basedn", (PyCFunction)py_ldb_get_default_basedn, METH_NOARGS,
+		NULL },
+	{ "get_config_basedn", (PyCFunction)py_ldb_get_config_basedn, METH_NOARGS,
+		NULL },
+	{ "connect", (PyCFunction)py_ldb_connect, METH_VARARGS|METH_KEYWORDS, 
+		"S.connect(url, flags=0, options=None) -> None\n"
+		"Connect to a LDB URL." },
+	{ "modify", (PyCFunction)py_ldb_modify, METH_VARARGS, 
+		"S.modify(message) -> None\n"
+		"Modify an entry." },
+	{ "add", (PyCFunction)py_ldb_add, METH_VARARGS, 
+		"S.add(message) -> None\n"
+		"Add an entry." },
+	{ "delete", (PyCFunction)py_ldb_delete, METH_VARARGS,
+		"S.delete(dn) -> None\n"
+		"Remove an entry." },
+	{ "rename", (PyCFunction)py_ldb_rename, METH_VARARGS,
+		"S.rename(old_dn, new_dn) -> None\n"
+		"Rename an entry." },
+	{ "search", (PyCFunction)py_ldb_search, METH_VARARGS|METH_KEYWORDS,
+		"S.search(base=None, scope=None, expression=None, attrs=None, controls=None) -> msgs\n"
+		"Search in a database.\n"
+		"\n"
+		":param base: Optional base DN to search\n"
+		":param scope: Search scope (SCOPE_BASE, SCOPE_ONELEVEL or SCOPE_SUBTREE)\n"
+		":param expression: Optional search expression\n"
+		":param attrs: Attributes to return (defaults to all)\n"
+		":param controls: Optional list of controls\n"
+		":return: Iterator over Message objects\n"
+	},
+	{ "schema_attribute_remove", (PyCFunction)py_ldb_schema_attribute_remove, METH_VARARGS,
+		NULL },
+	{ "schema_attribute_add", (PyCFunction)py_ldb_schema_attribute_add, METH_VARARGS,
+		NULL },
+	{ "schema_format_value", (PyCFunction)py_ldb_schema_format_value, METH_VARARGS,
+		NULL },
+	{ "parse_ldif", (PyCFunction)py_ldb_parse_ldif, METH_VARARGS,
+		"S.parse_ldif(ldif) -> iter(messages)\n"
+		"Parse a string formatted using LDIF." },
+	{ "get_opaque", (PyCFunction)py_ldb_get_opaque, METH_VARARGS,
+		"S.get_opaque(name) -> value\n"
+		"Get an opaque value set on this LDB connection. \n"
+		":note: The returned value may not be useful in Python."
+	},
+	{ "set_opaque", (PyCFunction)py_ldb_set_opaque, METH_VARARGS,
+		"S.set_opaque(name, value) -> None\n"
+		"Set an opaque value on this LDB connection. \n"
+		":note: Passing incorrect values may cause crashes." },
+	{ "modules", (PyCFunction)py_ldb_modules, METH_NOARGS,
+		"S.modules() -> list\n"
+		"Return the list of modules on this LDB connection " },
+	{ NULL },
+};
+
+PyObject *PyLdbModule_FromModule(struct ldb_module *mod)
+{
+	return py_talloc_import(&PyLdbModule, mod);
+}
+
+static PyObject *py_ldb_get_firstmodule(PyLdbObject *self, void *closure)
+{
+	return PyLdbModule_FromModule(PyLdb_AsLdbContext(self)->modules);
+}
+
+static PyGetSetDef py_ldb_getset[] = {
+	{ (char *)"firstmodule", (getter)py_ldb_get_firstmodule, NULL, NULL },
+	{ NULL }
+};
+
+static int py_ldb_contains(PyLdbObject *self, PyObject *obj)
+{
+	struct ldb_context *ldb_ctx = PyLdb_AsLdbContext(self);
+	struct ldb_dn *dn;
+	struct ldb_result *result;
+	int ret;
+	int count;
+
+	if (!PyObject_AsDn(ldb_ctx, obj, ldb_ctx, &dn))
+		return -1;
+
+	ret = ldb_search(ldb_ctx, ldb_ctx, &result, dn, LDB_SCOPE_BASE, NULL, NULL);
+	if (ret != LDB_SUCCESS) {
+		PyErr_SetLdbError(ret, ldb_ctx);
+		return -1;
+	}
+
+	count = result->count;
+
+	talloc_free(result);
+
+	return count;
+}
+
+static PySequenceMethods py_ldb_seq = {
+	.sq_contains = (objobjproc)py_ldb_contains,
+};
+
+PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx)
+{
+	return py_talloc_import(&PyLdb, ldb_ctx);
+}
+
+PyTypeObject PyLdb = {
+	.tp_name = "Ldb",
+	.tp_methods = py_ldb_methods,
+	.tp_repr = (reprfunc)py_ldb_repr,
+	.tp_new = py_ldb_new,
+	.tp_init = (initproc)py_ldb_init,
+	.tp_dealloc = py_talloc_dealloc,
+	.tp_getset = py_ldb_getset,
+	.tp_getattro = PyObject_GenericGetAttr,
+	.tp_basicsize = sizeof(PyLdbObject),
+	.tp_doc = "Connection to a LDB database.",
+	.tp_as_sequence = &py_ldb_seq,
+	.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+};
+
+static PyObject *py_ldb_module_repr(PyLdbModuleObject *self)
+{
+	return PyString_FromFormat("<ldb module '%s'>", PyLdbModule_AsModule(self)->ops->name);
+}
+
+static PyObject *py_ldb_module_str(PyLdbModuleObject *self)
+{
+	return PyString_FromString(PyLdbModule_AsModule(self)->ops->name);
+}
+
+static PyObject *py_ldb_module_start_transaction(PyLdbModuleObject *self)
+{
+	PyLdbModule_AsModule(self)->ops->start_transaction(PyLdbModule_AsModule(self));
+	return Py_None;
+}
+
+static PyObject *py_ldb_module_end_transaction(PyLdbModuleObject *self)
+{
+	PyLdbModule_AsModule(self)->ops->end_transaction(PyLdbModule_AsModule(self));
+	return Py_None;
+}
+
+static PyObject *py_ldb_module_del_transaction(PyLdbModuleObject *self)
+{
+	PyLdbModule_AsModule(self)->ops->del_transaction(PyLdbModule_AsModule(self));
+	return Py_None;
+}
+
+static PyObject *py_ldb_module_search(PyLdbModuleObject *self, PyObject *args, PyObject *kwargs)
+{
+	PyObject *py_base, *py_tree, *py_attrs;
+	int ret, scope;
+	struct ldb_request *req;
+	const char *kwnames[] = { "base", "scope", "tree", "attrs", NULL };
+	struct ldb_module *mod;
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiOO", (char **)kwnames, 
+									 &py_base, &scope, &py_tree, &py_attrs))
+		return NULL;
+
+	mod = self->ptr;
+
+	ret = ldb_build_search_req(&req, mod->ldb, NULL, PyLdbDn_AsDn(py_base), 
+			     scope, NULL /* expr */, py_attrs == Py_None?NULL:PyList_AsStringList(req, py_attrs),
+			     NULL /* controls */, NULL, NULL, NULL);
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, mod->ldb);
+
+	ret = mod->ops->search(mod, req);
+	talloc_free(req);
+
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, mod->ldb);
+
+	return PyLdbResult_FromResult(req->op.search.res);
+}
+
+
+static PyObject *py_ldb_module_add(PyLdbModuleObject *self, PyObject *args)
+{
+	struct ldb_request *req;
+	PyObject *py_message;
+	int ret;
+	struct ldb_module *mod;
+
+	if (!PyArg_ParseTuple(args, "O", &py_message))
+		return NULL;
+
+	req = talloc_zero(NULL, struct ldb_request);
+	req->operation = LDB_ADD;
+	req->op.add.message = PyLdbMessage_AsMessage(py_message);
+
+	mod = PyLdbModule_AsModule(self);
+	ret = mod->ops->add(mod, req);
+
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, mod->ldb);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_module_modify(PyLdbModuleObject *self, PyObject *args) 
+{
+	int ret;
+	struct ldb_request *req;
+	PyObject *py_message;
+	struct ldb_module *mod;
+
+	if (!PyArg_ParseTuple(args, "O", &py_message))
+		return NULL;
+	
+	req = talloc_zero(NULL, struct ldb_request);
+	req->operation = LDB_MODIFY;
+	req->op.mod.message = PyLdbMessage_AsMessage(py_message);
+	
+	mod = PyLdbModule_AsModule(self);
+	ret = mod->ops->modify(mod, req);
+
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, mod->ldb);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_module_delete(PyLdbModuleObject *self, PyObject *args) 
+{
+	int ret;
+	struct ldb_request *req;
+	PyObject *py_dn;
+
+	if (!PyArg_ParseTuple(args, "O", &py_dn))
+		return NULL;
+	
+	req = talloc_zero(NULL, struct ldb_request);
+	req->operation = LDB_DELETE;
+	req->op.del.dn = PyLdbDn_AsDn(py_dn);
+	
+	ret = PyLdbModule_AsModule(self)->ops->del(PyLdbModule_AsModule(self), req);
+
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, NULL);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_module_rename(PyLdbModuleObject *self, PyObject *args)
+{
+	int ret;
+	struct ldb_request *req;
+	PyObject *py_dn1, *py_dn2;
+
+	if (!PyArg_ParseTuple(args, "OO", &py_dn1, &py_dn2))
+		return NULL;
+	
+	req = talloc_zero(NULL, struct ldb_request);
+
+	req->operation = LDB_RENAME;
+	req->op.rename.olddn = PyLdbDn_AsDn(py_dn1);
+	req->op.rename.newdn = PyLdbDn_AsDn(py_dn2);
+	
+	ret = PyLdbModule_AsModule(self)->ops->rename(PyLdbModule_AsModule(self), req);
+
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, NULL);
+
+	return Py_None;
+}
+
+static PyMethodDef py_ldb_module_methods[] = {
+	{ "search", (PyCFunction)py_ldb_module_search, METH_VARARGS|METH_KEYWORDS, NULL },
+	{ "add", (PyCFunction)py_ldb_module_add, METH_VARARGS, NULL },
+	{ "modify", (PyCFunction)py_ldb_module_modify, METH_VARARGS, NULL },
+	{ "rename", (PyCFunction)py_ldb_module_rename, METH_VARARGS, NULL },
+	{ "delete", (PyCFunction)py_ldb_module_delete, METH_VARARGS, NULL },
+	{ "start_transaction", (PyCFunction)py_ldb_module_start_transaction, METH_NOARGS, NULL },
+	{ "end_transaction", (PyCFunction)py_ldb_module_end_transaction, METH_NOARGS, NULL },
+	{ "del_transaction", (PyCFunction)py_ldb_module_del_transaction, METH_NOARGS, NULL },
+	{ NULL },
+};
+
+PyTypeObject PyLdbModule = {
+	.tp_name = "LdbModule",
+	.tp_methods = py_ldb_module_methods,
+	.tp_repr = (reprfunc)py_ldb_module_repr,
+	.tp_str = (reprfunc)py_ldb_module_str,
+	.tp_basicsize = sizeof(py_talloc_Object),
+	.tp_dealloc = py_talloc_dealloc,
+	.tp_flags = Py_TPFLAGS_DEFAULT,
+};
+
+struct ldb_message_element *PyObject_AsMessageElement(TALLOC_CTX *mem_ctx,
+											   PyObject *set_obj, int flags,
+											   const char *attr_name)
+{
+	struct ldb_message_element *me;
+
+	if (PyLdbMessageElement_Check(set_obj))
+		return PyLdbMessageElement_AsMessageElement(set_obj);
+
+	me = talloc(mem_ctx, struct ldb_message_element);
+
+	me->name = attr_name;
+	me->flags = flags;
+	if (PyString_Check(set_obj)) {
+		me->num_values = 1;
+		me->values = talloc_array(me, struct ldb_val, me->num_values);
+		me->values[0].length = PyString_Size(set_obj);
+		me->values[0].data = (uint8_t *)talloc_strdup(me->values, 
+										   PyString_AsString(set_obj));
+	} else if (PySequence_Check(set_obj)) {
+		int i;
+		me->num_values = PySequence_Size(set_obj);
+		me->values = talloc_array(me, struct ldb_val, me->num_values);
+		for (i = 0; i < me->num_values; i++) {
+			PyObject *obj = PySequence_GetItem(set_obj, i);
+			me->values[i].length = PyString_Size(obj);
+			me->values[i].data = (uint8_t *)PyString_AsString(obj);
+		}
+	} else {
+		talloc_free(me);
+		me = NULL;
+	}
+
+	return me;
+}
+
+
+PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx, 
+								 struct ldb_message_element *me)
+{
+	int i;
+	PyObject *result;
+
+	/* Python << 2.5 doesn't have PySet_New and PySet_Add. */
+	result = PyList_New(me->num_values);
+
+	for (i = 0; i < me->num_values; i++) {
+		PyList_SetItem(result, i,
+			PyObject_FromLdbValue(ldb_ctx, me, &me->values[i]));
+	}
+
+	return result;
+}
+
+PyObject *py_ldb_msg_element_get(PyLdbMessageElementObject *self, PyObject *args)
+{
+	int i;
+	if (!PyArg_ParseTuple(args, "i", &i))
+		return NULL;
+	if (i < 0 || i >= PyLdbMessageElement_AsMessageElement(self)->num_values)
+		return Py_None;
+
+	return PyObject_FromLdbValue(NULL, PyLdbMessageElement_AsMessageElement(self), 
+								 &(PyLdbMessageElement_AsMessageElement(self)->values[i]));
+}
+
+static PyMethodDef py_ldb_msg_element_methods[] = {
+	{ "get", (PyCFunction)py_ldb_msg_element_get, METH_VARARGS, NULL },
+	{ NULL },
+};
+
+static Py_ssize_t py_ldb_msg_element_len(PyLdbMessageElementObject *self)
+{
+	return PyLdbMessageElement_AsMessageElement(self)->num_values;
+}
+
+static PyObject *py_ldb_msg_element_find(PyLdbMessageElementObject *self, Py_ssize_t idx)
+{
+	struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
+	if (idx < 0 || idx >= el->num_values) {
+		PyErr_SetString(PyExc_IndexError, "Out of range");
+		return NULL;
+	}
+	return PyString_FromStringAndSize((char *)el->values[idx].data, el->values[idx].length);
+}
+
+static PySequenceMethods py_ldb_msg_element_seq = {
+	.sq_length = (lenfunc)py_ldb_msg_element_len,
+	.sq_item = (ssizeargfunc)py_ldb_msg_element_find,
+};
+
+static int py_ldb_msg_element_cmp(PyLdbMessageElementObject *self, PyLdbMessageElementObject *other)
+{
+	return ldb_msg_element_compare(PyLdbMessageElement_AsMessageElement(self), 
+								   PyLdbMessageElement_AsMessageElement(other));
+}
+
+static PyObject *py_ldb_msg_element_iter(PyLdbMessageElementObject *self)
+{
+	return PyObject_GetIter(ldb_msg_element_to_set(NULL, PyLdbMessageElement_AsMessageElement(self)));
+}
+
+PyObject *PyLdbMessageElement_FromMessageElement(struct ldb_message_element *el, TALLOC_CTX *mem_ctx)
+{
+	return py_talloc_import_ex(&PyLdbMessageElement, mem_ctx, el);
+}
+
+static PyObject *py_ldb_msg_element_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+	PyObject *py_elements = NULL;
+	struct ldb_message_element *el;
+	int flags = 0;
+	char *name = NULL;
+	const char *kwnames[] = { "elements", "flags", "name", NULL };
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Ois", (char **)kwnames, &py_elements, &flags, &name))
+		return NULL;
+
+	el = talloc_zero(NULL, struct ldb_message_element);
+
+	if (py_elements != NULL) {
+		int i;
+		if (!PySequence_Check(py_elements)) {
+			el->num_values = 1;
+			el->values = talloc_array(el, struct ldb_val, 1);
+			el->values[0].data = (uint8_t *)PyString_AsString(py_elements);
+			el->values[0].length = PyString_Size(py_elements);
+		} else {
+			el->num_values = PySequence_Size(py_elements);
+			el->values = talloc_array(el, struct ldb_val, el->num_values);
+			for (i = 0; i < el->num_values; i++) {
+				PyObject *item = PySequence_GetItem(py_elements, i);
+				el->values[i].data = (uint8_t *)PyString_AsString(item);
+				el->values[i].length = PyString_Size(item);
+			}
+		}
+	}
+
+	el->flags = flags;
+	el->name = talloc_strdup(el, name);
+
+	return py_talloc_import(&PyLdbMessageElement, el);
+}
+
+static PyObject *py_ldb_msg_element_repr(PyLdbMessageElementObject *self)
+{
+	char *element_str = NULL;
+	int i;
+	struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
+	PyObject *ret;
+
+	for (i = 0; i < el->num_values; i++) {
+		PyObject *o = py_ldb_msg_element_find(self, i);
+		if (element_str == NULL)
+			element_str = talloc_strdup(NULL, PyObject_REPR(o));
+		else
+			element_str = talloc_asprintf_append(element_str, ",%s", PyObject_REPR(o));
+	}
+
+	ret = PyString_FromFormat("MessageElement([%s])", element_str);
+
+	talloc_free(element_str);
+
+	return ret;
+}
+
+static PyObject *py_ldb_msg_element_str(PyLdbMessageElementObject *self)
+{
+	struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
+
+	if (el->num_values == 1)
+		return PyString_FromStringAndSize((char *)el->values[0].data, el->values[0].length);
+	else 
+		return Py_None;
+}
+
+PyTypeObject PyLdbMessageElement = {
+	.tp_name = "MessageElement",
+	.tp_basicsize = sizeof(PyLdbMessageElementObject),
+	.tp_dealloc = py_talloc_dealloc,
+	.tp_repr = (reprfunc)py_ldb_msg_element_repr,
+	.tp_str = (reprfunc)py_ldb_msg_element_str,
+	.tp_methods = py_ldb_msg_element_methods,
+	.tp_compare = (cmpfunc)py_ldb_msg_element_cmp,
+	.tp_iter = (getiterfunc)py_ldb_msg_element_iter,
+	.tp_as_sequence = &py_ldb_msg_element_seq,
+	.tp_new = py_ldb_msg_element_new,
+	.tp_flags = Py_TPFLAGS_DEFAULT,
+};
+
+static PyObject *py_ldb_msg_remove_attr(PyLdbMessageObject *self, PyObject *args)
+{
+	char *name;
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return NULL;
+
+	ldb_msg_remove_attr(self->ptr, name);
+
+	return Py_None;
+}
+
+static PyObject *py_ldb_msg_keys(PyLdbMessageObject *self)
+{
+	struct ldb_message *msg = PyLdbMessage_AsMessage(self);
+	int i, j = 0;
+	PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
+	if (msg->dn != NULL) {
+		PyList_SetItem(obj, j, PyString_FromString("dn"));
+		j++;
+	}
+	for (i = 0; i < msg->num_elements; i++) {
+		PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
+		j++;
+	}
+	return obj;
+}
+
+static PyObject *py_ldb_msg_getitem_helper(PyLdbMessageObject *self, PyObject *py_name)
+{
+	struct ldb_message_element *el;
+	char *name = PyString_AsString(py_name);
+	if (!strcmp(name, "dn"))
+		return PyLdbDn_FromDn(PyLdbMessage_AsMessage(self)->dn);
+	el = ldb_msg_find_element(PyLdbMessage_AsMessage(self), name);
+	if (el == NULL) {
+		return NULL;
+	}
+	return (PyObject *)PyLdbMessageElement_FromMessageElement(el, self->talloc_ctx);
+}
+
+static PyObject *py_ldb_msg_getitem(PyLdbMessageObject *self, PyObject *py_name)
+{
+	PyObject *ret = py_ldb_msg_getitem_helper(self, py_name);
+	if (ret == NULL) {
+		PyErr_SetString(PyExc_KeyError, "No such element");
+		return NULL;
+	}
+	return ret;
+}
+
+static PyObject *py_ldb_msg_get(PyLdbMessageObject *self, PyObject *args)
+{
+	PyObject *name, *ret;
+	if (!PyArg_ParseTuple(args, "O", &name))
+		return NULL;
+
+	ret = py_ldb_msg_getitem_helper(self, name);
+	if (ret == NULL)
+		return Py_None;
+	return ret;
+}
+
+static PyObject *py_ldb_msg_items(PyLdbMessageObject *self)
+{
+	struct ldb_message *msg = PyLdbMessage_AsMessage(self);
+	int i, j;
+	PyObject *l = PyList_New(msg->num_elements + (msg->dn == NULL?0:1));
+	j = 0;
+	if (msg->dn != NULL) {
+		PyList_SetItem(l, 0, Py_BuildValue("(sO)", "dn", PyLdbDn_FromDn(msg->dn)));
+		j++;
+	}
+	for (i = 0; i < msg->num_elements; i++, j++) {
+		PyList_SetItem(l, j, Py_BuildValue("(sO)", msg->elements[i].name, PyLdbMessageElement_FromMessageElement(&msg->elements[i], self->talloc_ctx)));
+	}
+	return l;
+}
+
+static PyMethodDef py_ldb_msg_methods[] = { 
+	{ "keys", (PyCFunction)py_ldb_msg_keys, METH_NOARGS, NULL },
+	{ "remove", (PyCFunction)py_ldb_msg_remove_attr, METH_VARARGS, NULL },
+	{ "get", (PyCFunction)py_ldb_msg_get, METH_VARARGS, NULL },
+	{ "items", (PyCFunction)py_ldb_msg_items, METH_NOARGS, NULL },
+	{ NULL },
+};
+
+static PyObject *py_ldb_msg_iter(PyLdbMessageObject *self)
+{
+	PyObject *list, *iter;
+
+	list = py_ldb_msg_keys(self);
+	iter = PyObject_GetIter(list);
+	Py_DECREF(list);
+	return iter;
+}
+
+static int py_ldb_msg_setitem(PyLdbMessageObject *self, PyObject *name, PyObject *value)
+{
+	char *attr_name = PyString_AsString(name);
+	if (value == NULL) {
+		ldb_msg_remove_attr(self->ptr, attr_name);
+	} else {
+		struct ldb_message_element *el = PyObject_AsMessageElement(NULL,
+											value, 0, attr_name);
+		if (el == NULL)
+			return -1;
+		talloc_steal(self->ptr, el);
+		ldb_msg_remove_attr(PyLdbMessage_AsMessage(self), attr_name);
+		ldb_msg_add(PyLdbMessage_AsMessage(self), el, el->flags);
+	}
+	return 0;
+}
+
+static Py_ssize_t py_ldb_msg_length(PyLdbMessageObject *self)
+{
+	return PyLdbMessage_AsMessage(self)->num_elements;
+}
+
+static PyMappingMethods py_ldb_msg_mapping = {
+	.mp_length = (lenfunc)py_ldb_msg_length,
+	.mp_subscript = (binaryfunc)py_ldb_msg_getitem,
+	.mp_ass_subscript = (objobjargproc)py_ldb_msg_setitem,
+};
+
+static PyObject *py_ldb_msg_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+	const char *kwnames[] = { "dn", NULL };
+	struct ldb_message *ret;
+	PyObject *pydn = NULL;
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", (char **)kwnames, &pydn))
+		return NULL;
+
+	ret = ldb_msg_new(NULL);
+	if (ret == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	if (pydn != NULL)
+		if (!PyObject_AsDn(NULL, pydn, NULL, &ret->dn))
+			return NULL;
+
+	return py_talloc_import(type, ret); 
+}
+
+PyObject *PyLdbMessage_FromMessage(struct ldb_message *msg)
+{
+	return py_talloc_import(&PyLdbMessage, msg);
+}
+
+static PyObject *py_ldb_msg_get_dn(PyLdbMessageObject *self, void *closure)
+{
+	return PyLdbDn_FromDn(PyLdbMessage_AsMessage(self)->dn);
+}
+
+static int py_ldb_msg_set_dn(PyLdbMessageObject *self, PyObject *value, void *closure)
+{
+	PyLdbMessage_AsMessage(self)->dn = PyLdbDn_AsDn(value);
+	return 0;
+}
+
+static PyGetSetDef py_ldb_msg_getset[] = {
+	{ (char *)"dn", (getter)py_ldb_msg_get_dn, (setter)py_ldb_msg_set_dn, NULL },
+	{ NULL }
+};
+
+static PyObject *py_ldb_msg_repr(PyLdbMessageObject *self)
+{
+	PyObject *dict = PyDict_New(), *ret;
+	if (PyDict_Update(dict, (PyObject *)self) != 0)
+		return NULL;
+	ret = PyString_FromFormat("Message(%s)", PyObject_REPR(dict));
+	Py_DECREF(dict);
+	return ret;
+}
+
+PyTypeObject PyLdbMessage = {
+	.tp_name = "Message",
+	.tp_methods = py_ldb_msg_methods,
+	.tp_getset = py_ldb_msg_getset,
+	.tp_as_mapping = &py_ldb_msg_mapping,
+	.tp_basicsize = sizeof(PyLdbMessageObject),
+	.tp_dealloc = py_talloc_dealloc,
+	.tp_new = py_ldb_msg_new,
+	.tp_repr = (reprfunc)py_ldb_msg_repr,
+	.tp_flags = Py_TPFLAGS_DEFAULT,
+	.tp_iter = (getiterfunc)py_ldb_msg_iter,
+};
+
+PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *tree)
+{
+	return py_talloc_import(&PyLdbTree, tree);
+}
+
+PyTypeObject PyLdbTree = {
+	.tp_name = "Tree",
+	.tp_basicsize = sizeof(PyLdbTreeObject),
+	.tp_dealloc = py_talloc_dealloc,
+	.tp_flags = Py_TPFLAGS_DEFAULT,
+};
+
+/* Ldb_module */
+int py_module_search(struct ldb_module *mod, struct ldb_request *req)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result, *py_base, *py_attrs, *py_tree;
+
+	py_base = PyLdbDn_FromDn(req->op.search.base);
+
+	if (py_base == NULL)
+		return LDB_ERR_OPERATIONS_ERROR;
+
+	py_tree = PyLdbTree_FromTree(req->op.search.tree);
+
+	if (py_tree == NULL)
+		return LDB_ERR_OPERATIONS_ERROR;
+
+	if (req->op.search.attrs == NULL) {
+		py_attrs = Py_None;
+	} else {
+		int i, len;
+		for (len = 0; req->op.search.attrs[len]; len++);
+		py_attrs = PyList_New(len);
+		for (i = 0; i < len; i++)
+			PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
+	}
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"search", (char *)"OiOO", py_base, req->op.search.scope, py_tree, py_attrs);
+
+	Py_DECREF(py_attrs);
+	Py_DECREF(py_tree);
+	Py_DECREF(py_base);
+
+	if (py_result == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	req->op.search.res = PyLdbResult_AsResult(NULL, py_result);
+	if (req->op.search.res == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	Py_DECREF(py_result);
+
+	return LDB_SUCCESS;
+}
+
+int py_module_add(struct ldb_module *mod, struct ldb_request *req)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result, *py_msg;
+
+	py_msg = PyLdbMessage_FromMessage((struct ldb_message *)req->op.add.message);
+
+	if (py_msg == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"add", (char *)"O", py_msg);
+
+	Py_DECREF(py_msg);
+
+	if (py_result == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	Py_DECREF(py_result);
+
+	return LDB_SUCCESS;
+}
+
+int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result, *py_msg;
+
+	py_msg = PyLdbMessage_FromMessage((struct ldb_message *)req->op.mod.message);
+
+	if (py_msg == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"modify", (char *)"O", py_msg);
+
+	Py_DECREF(py_msg);
+
+	if (py_result == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	Py_DECREF(py_result);
+
+	return LDB_SUCCESS;
+}
+
+int py_module_del(struct ldb_module *mod, struct ldb_request *req)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result, *py_dn;
+
+	py_dn = PyLdbDn_FromDn(req->op.del.dn);
+
+	if (py_dn == NULL)
+		return LDB_ERR_OPERATIONS_ERROR;
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"delete", (char *)"O", py_dn);
+
+	if (py_result == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	Py_DECREF(py_result);
+
+	return LDB_SUCCESS;
+}
+
+int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result, *py_olddn, *py_newdn;
+
+	py_olddn = PyLdbDn_FromDn(req->op.rename.olddn);
+
+	if (py_olddn == NULL)
+		return LDB_ERR_OPERATIONS_ERROR;
+
+	py_newdn = PyLdbDn_FromDn(req->op.rename.newdn);
+
+	if (py_newdn == NULL)
+		return LDB_ERR_OPERATIONS_ERROR;
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"rename", (char *)"OO", py_olddn, py_newdn);
+
+	Py_DECREF(py_olddn);
+	Py_DECREF(py_newdn);
+
+	if (py_result == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	Py_DECREF(py_result);
+
+	return LDB_SUCCESS;
+}
+
+int py_module_request(struct ldb_module *mod, struct ldb_request *req)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result;
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"request", (char *)"");
+
+	return LDB_ERR_OPERATIONS_ERROR;
+}
+
+int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result;
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"extended", (char *)"");
+
+	return LDB_ERR_OPERATIONS_ERROR;
+}
+
+int py_module_start_transaction(struct ldb_module *mod)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result;
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"start_transaction", (char *)"");
+
+	if (py_result == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	Py_DECREF(py_result);
+
+	return LDB_SUCCESS;
+}
+
+int py_module_end_transaction(struct ldb_module *mod)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result;
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"end_transaction", (char *)"");
+
+	if (py_result == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	Py_DECREF(py_result);
+
+	return LDB_SUCCESS;
+}
+
+int py_module_del_transaction(struct ldb_module *mod)
+{
+	PyObject *py_ldb = mod->private_data;
+	PyObject *py_result;
+
+	py_result = PyObject_CallMethod(py_ldb, (char *)"del_transaction", (char *)"");
+
+	if (py_result == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	Py_DECREF(py_result);
+
+	return LDB_SUCCESS;
+}
+
+static int py_module_destructor(struct ldb_module *mod)
+{
+	Py_DECREF((PyObject *)mod->private_data);
+	return 0;
+}
+
+int py_module_init (struct ldb_module *mod)
+{
+	PyObject *py_class = mod->ops->private_data;
+	PyObject *py_result, *py_next, *py_ldb;
+
+	py_ldb = PyLdb_FromLdbContext(mod->ldb);
+
+	if (py_ldb == NULL)
+		return LDB_ERR_OPERATIONS_ERROR;
+
+	py_next = PyLdbModule_FromModule(mod->next);
+
+	if (py_next == NULL)
+		return LDB_ERR_OPERATIONS_ERROR;
+
+	py_result = PyObject_CallFunction(py_class, (char *)"OO", py_ldb, py_next);
+
+	if (py_result == NULL) {
+		return LDB_ERR_PYTHON_EXCEPTION;
+	}
+
+	mod->private_data = py_result;
+
+	talloc_set_destructor(mod, py_module_destructor);
+
+	return ldb_next_init(mod);
+}
+
+static PyObject *py_register_module(PyObject *module, PyObject *args)
+{
+	int ret;
+	struct ldb_module_ops *ops;
+	PyObject *input;
+
+	if (!PyArg_ParseTuple(args, "O", &input))
+		return NULL;
+
+	ops = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
+	if (ops == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	ops->name = talloc_strdup(ops, PyString_AsString(PyObject_GetAttrString(input, (char *)"name")));
+
+	Py_INCREF(input);
+	ops->private_data = input;
+	ops->init_context = py_module_init;
+	ops->search = py_module_search;
+	ops->add = py_module_add;
+	ops->modify = py_module_modify;
+	ops->del = py_module_del;
+	ops->rename = py_module_rename;
+	ops->request = py_module_request;
+	ops->extended = py_module_extended;
+	ops->start_transaction = py_module_start_transaction;
+	ops->end_transaction = py_module_end_transaction;
+	ops->del_transaction = py_module_del_transaction;
+
+	ret = ldb_register_module(ops);
+
+	PyErr_LDB_ERROR_IS_ERR_RAISE(ret, NULL);
+
+	return Py_None;
+}
+
+static PyObject *py_timestring(PyObject *module, PyObject *args)
+{
+	time_t t;
+	char *tresult;
+	PyObject *ret;
+	if (!PyArg_ParseTuple(args, "L", &t))
+		return NULL;
+	tresult = ldb_timestring(NULL, t);
+	ret = PyString_FromString(tresult);
+	talloc_free(tresult);
+	return ret;
+}
+
+static PyObject *py_string_to_time(PyObject *module, PyObject *args)
+{
+	char *str;
+	if (!PyArg_ParseTuple(args, "s", &str))
+		return NULL;
+
+	return PyInt_FromLong(ldb_string_to_time(str));
+}
+
+static PyObject *py_valid_attr_name(PyObject *self, PyObject *args)
+{
+	char *name;
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return NULL;
+	return PyBool_FromLong(ldb_valid_attr_name(name));
+}
+
+static PyMethodDef py_ldb_global_methods[] = {
+	{ "register_module", py_register_module, METH_VARARGS, 
+		"S.register_module(module) -> None\n"
+		"Register a LDB module."},
+	{ "timestring", py_timestring, METH_VARARGS, 
+		"S.timestring(int) -> string\n"
+		"Generate a LDAP time string from a UNIX timestamp" },
+	{ "string_to_time", py_string_to_time, METH_VARARGS,
+		"S.string_to_time(string) -> int\n"
+		"Parse a LDAP time string into a UNIX timestamp." },
+	{ "valid_attr_name", py_valid_attr_name, METH_VARARGS,
+		"S.valid_attr_name(name) -> bool\n"
+		"Check whether the supplied name is a valid attribute name." },
+	{ "open", (PyCFunction)py_ldb_new, METH_VARARGS|METH_KEYWORDS,
+		NULL },
+	{ NULL }
+};
+
+void initldb(void)
+{
+	PyObject *m;
+
+	if (PyType_Ready(&PyLdbDn) < 0)
+		return;
+
+	if (PyType_Ready(&PyLdbMessage) < 0)
+		return;
+
+	if (PyType_Ready(&PyLdbMessageElement) < 0)
+		return;
+
+	if (PyType_Ready(&PyLdb) < 0)
+		return;
+
+	if (PyType_Ready(&PyLdbModule) < 0)
+		return;
+
+	if (PyType_Ready(&PyLdbTree) < 0)
+		return;
+
+	m = Py_InitModule3("ldb", py_ldb_global_methods, 
+		"An interface to LDB, a LDAP-like API that can either to talk an embedded database (TDB-based) or a standards-compliant LDAP server.");
+	if (m == NULL)
+		return;
+
+	PyModule_AddObject(m, "SCOPE_DEFAULT", PyInt_FromLong(LDB_SCOPE_DEFAULT));
+	PyModule_AddObject(m, "SCOPE_BASE", PyInt_FromLong(LDB_SCOPE_BASE));
+	PyModule_AddObject(m, "SCOPE_ONELEVEL", PyInt_FromLong(LDB_SCOPE_ONELEVEL));
+	PyModule_AddObject(m, "SCOPE_SUBTREE", PyInt_FromLong(LDB_SCOPE_SUBTREE));
+
+	PyModule_AddObject(m, "CHANGETYPE_NONE", PyInt_FromLong(LDB_CHANGETYPE_NONE));
+	PyModule_AddObject(m, "CHANGETYPE_ADD", PyInt_FromLong(LDB_CHANGETYPE_ADD));
+	PyModule_AddObject(m, "CHANGETYPE_DELETE", PyInt_FromLong(LDB_CHANGETYPE_DELETE));
+	PyModule_AddObject(m, "CHANGETYPE_MODIFY", PyInt_FromLong(LDB_CHANGETYPE_MODIFY));
+
+	PyModule_AddObject(m, "SUCCESS", PyInt_FromLong(LDB_SUCCESS));
+	PyModule_AddObject(m, "ERR_OPERATIONS_ERROR", PyInt_FromLong(LDB_ERR_OPERATIONS_ERROR));
+	PyModule_AddObject(m, "ERR_PROTOCOL_ERROR", PyInt_FromLong(LDB_ERR_PROTOCOL_ERROR));
+	PyModule_AddObject(m, "ERR_TIME_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_TIME_LIMIT_EXCEEDED));
+	PyModule_AddObject(m, "ERR_SIZE_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_SIZE_LIMIT_EXCEEDED));
+	PyModule_AddObject(m, "ERR_COMPARE_FALSE", PyInt_FromLong(LDB_ERR_COMPARE_FALSE));
+	PyModule_AddObject(m, "ERR_COMPARE_TRUE", PyInt_FromLong(LDB_ERR_COMPARE_TRUE));
+	PyModule_AddObject(m, "ERR_AUTH_METHOD_NOT_SUPPORTED", PyInt_FromLong(LDB_ERR_AUTH_METHOD_NOT_SUPPORTED));
+	PyModule_AddObject(m, "ERR_STRONG_AUTH_REQUIRED", PyInt_FromLong(LDB_ERR_STRONG_AUTH_REQUIRED));
+	PyModule_AddObject(m, "ERR_REFERRAL", PyInt_FromLong(LDB_ERR_REFERRAL));
+	PyModule_AddObject(m, "ERR_ADMIN_LIMIT_EXCEEDED", PyInt_FromLong(LDB_ERR_ADMIN_LIMIT_EXCEEDED));
+	PyModule_AddObject(m, "ERR_UNSUPPORTED_CRITICAL_EXTENSION", PyInt_FromLong(LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION));
+	PyModule_AddObject(m, "ERR_CONFIDENTIALITY_REQUIRED", PyInt_FromLong(LDB_ERR_CONFIDENTIALITY_REQUIRED));
+	PyModule_AddObject(m, "ERR_SASL_BIND_IN_PROGRESS", PyInt_FromLong(LDB_ERR_SASL_BIND_IN_PROGRESS));
+	PyModule_AddObject(m, "ERR_NO_SUCH_ATTRIBUTE", PyInt_FromLong(LDB_ERR_NO_SUCH_ATTRIBUTE));
+	PyModule_AddObject(m, "ERR_UNDEFINED_ATTRIBUTE_TYPE", PyInt_FromLong(LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE));
+	PyModule_AddObject(m, "ERR_INAPPROPRIATE_MATCHING", PyInt_FromLong(LDB_ERR_INAPPROPRIATE_MATCHING));
+	PyModule_AddObject(m, "ERR_CONSTRAINT_VIOLATION", PyInt_FromLong(LDB_ERR_CONSTRAINT_VIOLATION));
+	PyModule_AddObject(m, "ERR_ATTRIBUTE_OR_VALUE_EXISTS", PyInt_FromLong(LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS));
+	PyModule_AddObject(m, "ERR_INVALID_ATTRIBUTE_SYNTAX", PyInt_FromLong(LDB_ERR_INVALID_ATTRIBUTE_SYNTAX));
+	PyModule_AddObject(m, "ERR_NO_SUCH_OBJECT", PyInt_FromLong(LDB_ERR_NO_SUCH_OBJECT));
+	PyModule_AddObject(m, "ERR_ALIAS_PROBLEM", PyInt_FromLong(LDB_ERR_ALIAS_PROBLEM));
+	PyModule_AddObject(m, "ERR_INVALID_DN_SYNTAX", PyInt_FromLong(LDB_ERR_INVALID_DN_SYNTAX));
+	PyModule_AddObject(m, "ERR_ALIAS_DEREFERINCING_PROBLEM", PyInt_FromLong(LDB_ERR_ALIAS_DEREFERENCING_PROBLEM));
+	PyModule_AddObject(m, "ERR_INAPPROPRIATE_AUTHENTICATION", PyInt_FromLong(LDB_ERR_INAPPROPRIATE_AUTHENTICATION));
+	PyModule_AddObject(m, "ERR_INVALID_CREDENTIALS", PyInt_FromLong(LDB_ERR_INVALID_CREDENTIALS));
+	PyModule_AddObject(m, "ERR_INSUFFICIENT_ACCESS_RIGHTS", PyInt_FromLong(LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS));
+	PyModule_AddObject(m, "ERR_BUSY", PyInt_FromLong(LDB_ERR_BUSY));
+	PyModule_AddObject(m, "ERR_UNAVAILABLE", PyInt_FromLong(LDB_ERR_UNAVAILABLE));
+	PyModule_AddObject(m, "ERR_UNWILLING_TO_PERFORM", PyInt_FromLong(LDB_ERR_UNWILLING_TO_PERFORM));
+	PyModule_AddObject(m, "ERR_LOOP_DETECT", PyInt_FromLong(LDB_ERR_LOOP_DETECT));
+	PyModule_AddObject(m, "ERR_NAMING_VIOLATION", PyInt_FromLong(LDB_ERR_NAMING_VIOLATION));
+	PyModule_AddObject(m, "ERR_OBJECT_CLASS_VIOLATION", PyInt_FromLong(LDB_ERR_OBJECT_CLASS_VIOLATION));
+	PyModule_AddObject(m, "ERR_NOT_ALLOWED_ON_NON_LEAF", PyInt_FromLong(LDB_ERR_NOT_ALLOWED_ON_NON_LEAF));
+	PyModule_AddObject(m, "ERR_NOT_ALLOWED_ON_RDN", PyInt_FromLong(LDB_ERR_NOT_ALLOWED_ON_RDN));
+	PyModule_AddObject(m, "ERR_ENTRY_ALREADY_EXISTS", PyInt_FromLong(LDB_ERR_ENTRY_ALREADY_EXISTS));
+	PyModule_AddObject(m, "ERR_OBJECT_CLASS_MODS_PROHIBITED", PyInt_FromLong(LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED));
+	PyModule_AddObject(m, "ERR_AFFECTS_MULTIPLE_DSAS", PyInt_FromLong(LDB_ERR_AFFECTS_MULTIPLE_DSAS));
+
+	PyModule_AddObject(m, "ERR_OTHER", PyInt_FromLong(LDB_ERR_OTHER));
+
+	PyModule_AddObject(m, "__docformat__", PyString_FromString("restructuredText"));
+
+	PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
+	PyModule_AddObject(m, "LdbError", PyExc_LdbError);
+
+	Py_INCREF(&PyLdb);
+	Py_INCREF(&PyLdbDn);
+	Py_INCREF(&PyLdbModule);
+	Py_INCREF(&PyLdbMessage);
+	Py_INCREF(&PyLdbMessageElement);
+	Py_INCREF(&PyLdbTree);
+
+	PyModule_AddObject(m, "Ldb", (PyObject *)&PyLdb);
+	PyModule_AddObject(m, "Dn", (PyObject *)&PyLdbDn);
+	PyModule_AddObject(m, "Message", (PyObject *)&PyLdbMessage);
+	PyModule_AddObject(m, "MessageElement", (PyObject *)&PyLdbMessageElement);
+	PyModule_AddObject(m, "Module", (PyObject *)&PyLdbModule);
+	PyModule_AddObject(m, "Tree", (PyObject *)&PyLdbTree);
+}
diff --git a/ldb/pyldb.h b/ldb/pyldb.h
new file mode 100644
index 000000000..b55bb6840
--- /dev/null
+++ b/ldb/pyldb.h
@@ -0,0 +1,81 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   Swig interface to ldb.
+
+   Copyright (C) 2007-2008 Jelmer Vernooij <jelmer@samba.org>
+
+     ** NOTE! The following LGPL license applies to the ldb
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
+   
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _PYLDB_H_
+#define _PYLDB_H_
+
+#include <Python.h>
+#include <pytalloc.h>
+#include <ldb.h>
+#include <ldb_private.h>
+#include <ldb_errors.h>
+
+typedef py_talloc_Object PyLdbObject;
+PyAPI_DATA(PyTypeObject) PyLdb;
+PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx);
+#define PyLdb_AsLdbContext(pyobj) py_talloc_get_type(pyobj, struct ldb_context)
+#define PyLdb_Check(ob) PyObject_TypeCheck(ob, &PyLdb)
+
+typedef py_talloc_Object PyLdbDnObject;
+PyAPI_DATA(PyTypeObject) PyLdbDn;
+struct ldb_dn *PyLdbDn_AsDn(PyObject *);
+PyObject *PyLdbDn_FromDn(struct ldb_dn *);
+bool PyObject_AsDn(TALLOC_CTX *mem_ctx, PyObject *object, struct ldb_context *ldb_ctx, struct ldb_dn **dn);
+#define PyLdbDn_AsDn(pyobj) py_talloc_get_type(pyobj, struct ldb_dn)
+#define PyLdbDn_Check(ob) PyObject_TypeCheck(ob, &PyLdbDn)
+
+typedef py_talloc_Object PyLdbMessageObject;
+PyAPI_DATA(PyTypeObject) PyLdbMessage;
+PyObject *PyLdbMessage_FromMessage(struct ldb_message *message);
+struct ldb_message *PyLdbMessage_AsMessage(PyObject *obj);
+#define PyLdbMessage_Check(ob) PyObject_TypeCheck(ob, &PyLdbMessage)
+#define PyLdbMessage_AsMessage(pyobj) py_talloc_get_type(pyobj, struct ldb_message)
+
+typedef py_talloc_Object PyLdbModuleObject;
+PyAPI_DATA(PyTypeObject) PyLdbModule;
+PyObject *PyLdbModule_FromModule(struct ldb_module *mod);
+#define PyLdbModule_AsModule(pyobj) ((struct ldb_module *)py_talloc_get_ptr(pyobj))
+
+typedef py_talloc_Object PyLdbMessageElementObject;
+PyAPI_DATA(PyTypeObject) PyLdbMessageElement;
+struct ldb_message_element *PyObject_AsMessageElement(TALLOC_CTX *mem_ctx, PyObject *obj, int flags, const char *name);
+PyObject *PyLdbMessageElement_FromMessageElement(struct ldb_message_element *, TALLOC_CTX *mem_ctx);
+#define PyLdbMessageElement_AsMessageElement(pyobj) ((struct ldb_message_element *)py_talloc_get_ptr(pyobj))
+#define PyLdbMessageElement_Check(ob) PyObject_TypeCheck(ob, &PyLdbMessageElement)
+
+typedef py_talloc_Object PyLdbTreeObject;
+PyAPI_DATA(PyTypeObject) PyLdbTree;
+PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *);
+#define PyLdbTree_AsTree(pyobj) py_talloc_get_type(pyobj, struct ldb_parse_tree)
+
+void PyErr_SetLdbError(int ret, struct ldb_context *ldb_ctx);
+#define PyErr_LDB_ERROR_IS_ERR_RAISE(ret,ldb) \
+	if (ret != LDB_SUCCESS) { \
+		PyErr_SetLdbError(ret, ldb); \
+		return NULL; \
+	}
+
+
+#endif /* _PYLDB_H_ */
diff --git a/ldb/python.mk b/ldb/python.mk
index 45f4f044b..a672c079a 100644
--- a/ldb/python.mk
+++ b/ldb/python.mk
@@ -1,10 +1,8 @@
 [PYTHON::swig_ldb]
-LIBRARY_REALNAME = _ldb.$(SHLIBEXT)
-PUBLIC_DEPENDENCIES = LIBLDB LIBEVENTS
+LIBRARY_REALNAME = ldb.$(SHLIBEXT)
+PUBLIC_DEPENDENCIES = LIBLDB LIBEVENTS PYTALLOC
 
-swig_ldb_OBJ_FILES = $(ldbsrcdir)/ldb_wrap.o
+swig_ldb_OBJ_FILES = $(ldbsrcdir)/pyldb.o
 $(swig_ldb_OBJ_FILES): CFLAGS+=-I$(ldbsrcdir)/include
 
-$(eval $(call python_py_module_template,ldb.py,$(ldbsrcdir)/ldb.py))
-
-$(swig_ldb_OBJ_FILES): CFLAGS+=$(CFLAG_NO_UNUSED_MACROS) $(CFLAG_NO_CAST_QUAL)
+$(swig_ldb_OBJ_FILES): CFLAGS+=$(CFLAG_NO_CAST_QUAL)
diff --git a/ldb/rules.mk b/ldb/rules.mk
index ff5dc0274..639271b76 100644
--- a/ldb/rules.mk
+++ b/ldb/rules.mk
@@ -4,11 +4,6 @@ etags:
 ctags:
 	ctags `find $(srcdir) -name "*.[ch]"`
 
-.SUFFIXES: _wrap.c .i
-
-.i_wrap.c:
-	[ "$(SWIG)" = "no" ] || $(SWIG) -O -Wall -python -keyword $<
-
 .SUFFIXES: .1 .1.xml .3 .3.xml .xml .html .c .o
 
 .c.o:
diff --git a/ldb/tests/python/api.py b/ldb/tests/python/api.py
index 4b3501839..c372b8fa7 100755
--- a/ldb/tests/python/api.py
+++ b/ldb/tests/python/api.py
@@ -6,11 +6,13 @@ import os, sys
 import unittest
 
 # Required for the standalone LDB build
-sys.path.append("swig")
 sys.path.append("build/lib.linux-i686-2.4")
 
 import ldb
 
+def filename():
+    return os.tempnam()
+
 class NoContextTests(unittest.TestCase):
     def test_valid_attr_name(self):
         self.assertTrue(ldb.valid_attr_name("foo"))
@@ -27,14 +29,14 @@ class NoContextTests(unittest.TestCase):
 
 class SimpleLdb(unittest.TestCase):
     def test_connect(self):
-        ldb.Ldb("foo.ldb")
+        ldb.Ldb(filename())
 
     def test_connect_none(self):
         ldb.Ldb()
 
     def test_connect_later(self):
         x = ldb.Ldb()
-        x.connect("foo.ldb")
+        x.connect(filename())
 
     def test_repr(self):
         x = ldb.Ldb()
@@ -57,19 +59,19 @@ class SimpleLdb(unittest.TestCase):
         self.assertEquals("[<ldb module 'tdb'>]", repr(x.modules()))
 
     def test_search(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertEquals(len(l.search()), 1)
 
     def test_search_controls(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertEquals(len(l.search(controls=["paged_results:0:5"])), 1)
 
     def test_search_attrs(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertEquals(len(l.search(ldb.Dn(l, ""), ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
 
     def test_search_string_dn(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertEquals(len(l.search("", ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
 
     def test_search_attr_string(self):
@@ -77,29 +79,24 @@ class SimpleLdb(unittest.TestCase):
         self.assertRaises(TypeError, l.search, attrs="dc")
 
     def test_opaque(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         l.set_opaque("my_opaque", l)
         self.assertTrue(l.get_opaque("my_opaque") is not None)
         self.assertEquals(None, l.get_opaque("unknown"))
 
-    def test_parse_control_strings(self):
-        l = ldb.Ldb("foo.ldb")
-        self.assertRaises(ldb.LdbError, l.parse_control_strings, ["foo", "bar"])
-        self.assertTrue(l.parse_control_strings(["paged_results:0:5"]) is not None)
-
     def test_search_scope_base(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertEquals(len(l.search(ldb.Dn(l, "dc=foo"), 
                           ldb.SCOPE_ONELEVEL)), 0)
 
     def test_delete(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo")))
 
     def test_contains(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertFalse(ldb.Dn(l, "dc=foo") in l)
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         m = ldb.Message()
         m.dn = ldb.Dn(l, "dc=foo")
         m["b"] = ["a"]
@@ -110,23 +107,23 @@ class SimpleLdb(unittest.TestCase):
             l.delete(m.dn)
 
     def test_get_config_basedn(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertEquals(None, l.get_config_basedn())
 
     def test_get_root_basedn(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertEquals(None, l.get_root_basedn())
 
     def test_get_schema_basedn(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertEquals(None, l.get_schema_basedn())
 
     def test_get_default_basedn(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         self.assertEquals(None, l.get_default_basedn())
 
     def test_add(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         m = ldb.Message()
         m.dn = ldb.Dn(l, "dc=foo")
         m["bla"] = "bla"
@@ -138,7 +135,7 @@ class SimpleLdb(unittest.TestCase):
             l.delete(ldb.Dn(l, "dc=foo"))
 
     def test_add_dict(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         m = {"dn": ldb.Dn(l, "dc=foo"),
              "bla": "bla"}
         self.assertEquals(len(l.search()), 1)
@@ -149,7 +146,7 @@ class SimpleLdb(unittest.TestCase):
             l.delete(ldb.Dn(l, "dc=foo"))
 
     def test_add_dict_string_dn(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         m = {"dn": "dc=foo", "bla": "bla"}
         self.assertEquals(len(l.search()), 1)
         l.add(m)
@@ -159,7 +156,7 @@ class SimpleLdb(unittest.TestCase):
             l.delete(ldb.Dn(l, "dc=foo"))
 
     def test_rename(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         m = ldb.Message()
         m.dn = ldb.Dn(l, "dc=foo")
         m["bla"] = "bla"
@@ -172,12 +169,13 @@ class SimpleLdb(unittest.TestCase):
             l.delete(ldb.Dn(l, "dc=bar"))
 
     def test_rename_string_dns(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         m = ldb.Message()
         m.dn = ldb.Dn(l, "dc=foo")
         m["bla"] = "bla"
         self.assertEquals(len(l.search()), 1)
         l.add(m)
+        self.assertEquals(len(l.search()), 2)
         try:
             l.rename("dc=foo", "dc=bar")
             self.assertEquals(len(l.search()), 2)
@@ -185,7 +183,7 @@ class SimpleLdb(unittest.TestCase):
             l.delete(ldb.Dn(l, "dc=bar"))
 
     def test_modify_delete(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         m = ldb.Message()
         m.dn = ldb.Dn(l, "dc=modifydelete")
         m["bla"] = ["1234"]
@@ -203,7 +201,7 @@ class SimpleLdb(unittest.TestCase):
             l.delete(ldb.Dn(l, "dc=modifydelete"))
 
     def test_modify_add(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         m = ldb.Message()
         m.dn = ldb.Dn(l, "dc=add")
         m["bla"] = ["1234"]
@@ -220,7 +218,7 @@ class SimpleLdb(unittest.TestCase):
             l.delete(ldb.Dn(l, "dc=add"))
 
     def test_modify_modify(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         m = ldb.Message()
         m.dn = ldb.Dn(l, "dc=modify2")
         m["bla"] = ["1234", "456"]
@@ -237,7 +235,7 @@ class SimpleLdb(unittest.TestCase):
             l.delete(ldb.Dn(l, "dc=modify2"))
 
     def test_transaction_commit(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         l.transaction_start()
         m = ldb.Message(ldb.Dn(l, "dc=foo"))
         m["foo"] = ["bar"]
@@ -246,7 +244,7 @@ class SimpleLdb(unittest.TestCase):
         l.delete(m.dn)
 
     def test_transaction_cancel(self):
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         l.transaction_start()
         m = ldb.Message(ldb.Dn(l, "dc=foo"))
         m["foo"] = ["bar"]
@@ -257,17 +255,18 @@ class SimpleLdb(unittest.TestCase):
     def test_set_debug(self):
         def my_report_fn(level, text):
             pass
-        l = ldb.Ldb("foo.ldb")
+        l = ldb.Ldb(filename())
         l.set_debug(my_report_fn)
 
 
 class DnTests(unittest.TestCase):
     def setUp(self):
-        self.ldb = ldb.Ldb("foo.ldb")
+        self.ldb = ldb.Ldb(filename())
 
-    def test_eq_str(self):
+    def test_eq(self):
         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
-        self.assertEquals("dc=foo,bar=bloe", x)
+        y = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        self.assertEquals(x, y)
 
     def test_str(self):
         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
@@ -329,7 +328,8 @@ class DnTests(unittest.TestCase):
 
     def test_add_base(self):
         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
-        self.assertTrue(x.add_base(ldb.Dn(self.ldb, "bla=bloe")))
+        base = ldb.Dn(self.ldb, "bla=bloe")
+        self.assertTrue(x.add_base(base))
         self.assertEquals("dc=foo,bar=bloe,bla=bloe", x.__str__())
 
     def test_add(self):
@@ -410,7 +410,7 @@ class LdbMsgTests(unittest.TestCase):
         self.assertEquals(["dn", "foo", "bar"], self.msg.keys())
 
     def test_dn(self):
-        self.msg.dn = ldb.Dn(ldb.Ldb("foo.ldb"), "@BASEINFO")
+        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "@BASEINFO")
         self.assertEquals("@BASEINFO", self.msg.dn.__str__())
 
     def test_get_dn(self):
@@ -422,7 +422,7 @@ class LdbMsgTests(unittest.TestCase):
         self.assertEquals("bar", self.msg.get("foo")[0])
 
     def test_get_unknown(self):
-        self.assertRaises(KeyError, self.msg.get, "lalalala")
+        self.assertEquals(None, self.msg.get("lalalala"))
 
 
 class MessageElementTests(unittest.TestCase):
@@ -441,13 +441,15 @@ class MessageElementTests(unittest.TestCase):
         x = ldb.MessageElement(["foo"])
         self.assertEquals("MessageElement(['foo'])", repr(x))
         x = ldb.MessageElement(["foo", "bla"])
+        self.assertEquals(2, len(x))
         self.assertEquals("MessageElement(['foo','bla'])", repr(x))
 
     def test_get_item(self):
         x = ldb.MessageElement(["foo", "bar"])
         self.assertEquals("foo", x[0])
         self.assertEquals("bar", x[1])
-        self.assertRaises(KeyError, lambda: x[-1])
+        self.assertEquals("bar", x[-1])
+        self.assertRaises(IndexError, lambda: x[45])
 
     def test_len(self):
         x = ldb.MessageElement(["foo", "bar"])
@@ -455,9 +457,13 @@ class MessageElementTests(unittest.TestCase):
 
     def test_eq(self):
         x = ldb.MessageElement(["foo", "bar"])
-        self.assertEquals(["foo", "bar"], x)
+        y = ldb.MessageElement(["foo", "bar"])
+        self.assertEquals(y, x)
         x = ldb.MessageElement(["foo"])
-        self.assertEquals("foo", x)
+        self.assertNotEquals(y, x)
+        y = ldb.MessageElement(["foo"])
+        self.assertEquals(y, x)
+
 
 class ModuleTests(unittest.TestCase):
     def test_register_module(self):
diff --git a/ldb/tests/python/ldap.py b/ldb/tests/python/ldap.py
index 6c910b63f..f9006dbd6 100755
--- a/ldb/tests/python/ldap.py
+++ b/ldb/tests/python/ldap.py
@@ -8,14 +8,15 @@ import sys
 import time
 
 sys.path.append("bin/python")
+sys.path.append("../lib/subunit/python")
 
 import samba.getopt as options
 
 from samba.auth import system_session
-from ldb import (SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError,
-                 LDB_ERR_NO_SUCH_OBJECT, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS,
-                 LDB_ERR_ENTRY_ALREADY_EXISTS, LDB_ERR_UNWILLING_TO_PERFORM,
-                 LDB_ERR_NOT_ALLOWED_ON_NON_LEAF, LDB_ERR_OTHER, LDB_ERR_INVALID_DN_SYNTAX)
+from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError
+from ldb import ERR_NO_SUCH_OBJECT, ERR_ATTRIBUTE_OR_VALUE_EXISTS
+from ldb import ERR_ENTRY_ALREADY_EXISTS, ERR_UNWILLING_TO_PERFORM
+from ldb import ERR_NOT_ALLOWED_ON_NON_LEAF, ERR_OTHER, ERR_INVALID_DN_SYNTAX
 from samba import Ldb
 from subunit import SubunitTestRunner
 from samba import param
@@ -44,7 +45,7 @@ class BasicTests(unittest.TestCase):
         try:
             ldb.delete(dn)
         except LdbError, (num, _): 
-            self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT)
+            self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 
     def find_basedn(self, ldb):
         res = ldb.search(base="", expression="", scope=SCOPE_BASE, 
@@ -73,7 +74,11 @@ class BasicTests(unittest.TestCase):
 
         self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
-
+        self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà ,cn=users," + self.base_dn)
+        self.delete_force(self.ldb, "cn=ldaptestutf8user2  èùéìòà ,cn=users," + self.base_dn)
+  
     def test_group_add_invalid_member(self):
         """Testing group add with invalid member"""
         try:
@@ -83,7 +88,7 @@ class BasicTests(unittest.TestCase):
                 "member": "cn=ldaptestuser,cn=useRs," + self.base_dn})
             self.fail()
         except LdbError, (num, _): 
-            self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT)
+            self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 
     def test_all(self):
         """Basic tests"""
@@ -124,7 +129,7 @@ class BasicTests(unittest.TestCase):
                      })
             self.fail()
         except LdbError, (num, _): 
-            self.assertEquals(num, LDB_ERR_INVALID_DN_SYNTAX)
+            self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
             
         self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
         try:
@@ -135,7 +140,7 @@ class BasicTests(unittest.TestCase):
                 })
             self.fail()
         except LdbError, (num, _): 
-            self.assertEquals(num, LDB_ERR_UNWILLING_TO_PERFORM)
+            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
             
         self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
         try:
@@ -146,7 +151,7 @@ class BasicTests(unittest.TestCase):
                 })
             self.fail()
         except LdbError, (num, _): 
-            self.assertEquals(num, LDB_ERR_UNWILLING_TO_PERFORM)
+            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
             
         self.delete_force(self.ldb, "cn=ldaptestuser7,cn=users," + self.base_dn)
         try:
@@ -157,7 +162,7 @@ class BasicTests(unittest.TestCase):
                 })
             self.fail()
         except LdbError, (num, _): 
-            self.assertEquals(num, LDB_ERR_UNWILLING_TO_PERFORM)
+            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
             
         self.delete_force(self.ldb, "cn=ldaptestuser7,cn=users," + self.base_dn)
 
@@ -208,7 +213,7 @@ servicePrincipalName: cifs/ldaptest2computer
 """)
             self.fail()
         except LdbError, (num, msg):
-            self.assertEquals(num, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+            self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 
         ldb.modify_ldif("""
 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
@@ -226,7 +231,7 @@ servicePrincipalName: host/ldaptest2computer
 """)
             self.fail()
         except LdbError, (num, msg):
-            self.assertEquals(num, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+            self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 
         print "Testing ranged results"
         ldb.modify_ldif("""
@@ -347,7 +352,7 @@ servicePrincipalName: host/ldaptest2computer29
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
         self.assertEquals(res[0]["cn"][0], "ldaptestuser")
-        self.assertEquals(res[0]["name"], "ldaptestuser")
+        self.assertEquals(str(res[0]["name"]), "ldaptestuser")
 
         # Testing ldb.search for (&(anr=testy)(objectClass=user))
         res = ldb.search(expression="(&(anr=testy)(objectClass=user))")
@@ -379,24 +384,24 @@ servicePrincipalName: host/ldaptest2computer29
         self.assertEquals(len(res), 1, "Could not find (&(anr=testy ldap user)(objectClass=user))")
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestuser2")
-        self.assertEquals(res[0]["name"], "ldaptestuser2")
+        self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
+        self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
 
         # Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user))
 #        res = ldb.search(expression="(&(anr==testy ldap user2)(objectClass=user))")
 #        self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))")
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestuser2")
-        self.assertEquals(res[0]["name"], "ldaptestuser2")
+        self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
+        self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
 
         # Testing ldb.search for (&(anr==ldap user2)(objectClass=user))
 #        res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))")
 #        self.assertEquals(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))")
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestuser2")
-        self.assertEquals(res[0]["name"], "ldaptestuser2")
+        self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
+        self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
 
         # Testing ldb.search for (&(anr==not ldap user2)(objectClass=user))
 #        res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))")
@@ -431,11 +436,17 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
 """)
             self.fail()
         except LdbError, (num, _):
-            self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT)
+            self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 
         print "Testing Renames"
 
-        ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
+        attrs = ["objectGUID", "objectSid"]
+        print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
+        res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
+        self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
+
+        #Check rename works with extended/alternate DN forms 
+        ldb.rename("<SID=" + ldb.schema_format_value("objectSID", res_user[0]["objectSID"][0]) + ">" , "cn=ldaptestuser3,cn=users," + self.base_dn)
 
         ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
 
@@ -446,24 +457,24 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))")
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestUSER3")
-        self.assertEquals(res[0]["name"], "ldaptestUSER3")
+        self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
+        self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
 
  	#"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))"
 	res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
         self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestUSER3")
-        self.assertEquals(res[0]["name"], "ldaptestUSER3")
+        self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
+        self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
 
  	#"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))"
 	res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
         self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestUSER3")
-        self.assertEquals(res[0]["name"], "ldaptestUSER3")
+        self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
+        self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
 
  	#"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))"
 	res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
@@ -484,8 +495,8 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
         res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
         self.assertEquals(len(res), 1, "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestUSER3")
-        self.assertEquals(res[0]["name"], "ldaptestUSER3")
+        self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
+        self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
 
         # ensure we cannot add it again
         try:
@@ -494,7 +505,7 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
                       "cn": "LDAPtestUSER3"})
             self.fail()
         except LdbError, (num, _):
-            self.assertEquals(num, LDB_ERR_ENTRY_ALREADY_EXISTS)
+            self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
 
         # rename back
         ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
@@ -505,7 +516,7 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
                        "cn=ldaptestuser2,cn=users," + self.base_dn)
             self.fail()
         except LdbError, (num, _): 
-            self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT)
+            self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 
         # ensure can now use that name
         ldb.add({"dn": "cn=ldaptestuser3,cn=users," + self.base_dn,
@@ -517,7 +528,7 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """
             ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
             self.fail()
         except LdbError, (num, _):
-            self.assertEquals(num, LDB_ERR_ENTRY_ALREADY_EXISTS)
+            self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
         try:
             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=configuration," + self.base_dn)
             self.fail()
@@ -558,12 +569,12 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
 
         print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
         try:
-            ldb.search("cn=ldaptestcontainer," + self.base_dn, 
+            res = ldb.search("cn=ldaptestcontainer," + self.base_dn, 
                     expression="(&(cn=ldaptestuser4)(objectClass=user))", 
                     scope=SCOPE_SUBTREE)
-            self.fail()
+            self.fail(res)
         except LdbError, (num, _):
-            self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT)
+            self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 
         print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
         try:
@@ -571,7 +582,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
                     expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL)
             self.fail()
         except LdbError, (num, _):
-            self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT)
+            self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 
         print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
         res = ldb.search("cn=ldaptestcontainer2," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
@@ -584,28 +595,28 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
 
         print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
         res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE)
-        self.assertEquals(len(res), 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)), perhaps linked attributes are not conistant with subtree renames?")
+        self.assertEquals(len(res), 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)), perhaps linked attributes are not consistant with subtree renames?")
 
         print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn
         try:
             ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn)
             self.fail()
         except LdbError, (num, _):
-            self.assertEquals(num, LDB_ERR_UNWILLING_TO_PERFORM)
+            self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 
         print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn
         try:
             ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn)
             self.fail()
         except LdbError, (num, _):
-            self.assertTrue(num in (LDB_ERR_UNWILLING_TO_PERFORM, LDB_ERR_OTHER))
+            self.assertTrue(num in (ERR_UNWILLING_TO_PERFORM, ERR_OTHER))
 
         print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + self.base_dn
         try:
             ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
             self.fail()
         except LdbError, (num, _):
-            self.assertEquals(num, LDB_ERR_NOT_ALLOWED_ON_NON_LEAF)
+            self.assertEquals(num, NOT_ALLOWED_ON_NON_LEAF)
 
         print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn
         res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
@@ -637,12 +648,12 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestuser")
-        self.assertEquals(res[0]["name"], "ldaptestuser")
-        self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"])
+        self.assertEquals(str(res[0]["cn"]), "ldaptestuser")
+        self.assertEquals(str(res[0]["name"]), "ldaptestuser")
+        self.assertEquals(str(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
         self.assertTrue("objectGUID" in res[0])
         self.assertTrue("whenCreated" in res[0])
-        self.assertEquals(res[0]["objectCategory"], ("CN=Person,CN=Schema,CN=Configuration," + self.base_dn))
+        self.assertEquals(str(res[0]["objectCategory"]), ("CN=Person,CN=Schema,CN=Configuration," + self.base_dn))
         self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368)
         self.assertEquals(int(res[0]["userAccountControl"][0]), 546)
         self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
@@ -681,9 +692,9 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
 
         self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestcomputer")
-        self.assertEquals(res[0]["name"], "ldaptestcomputer")
-        self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"])
+        self.assertEquals(str(res[0]["cn"]), "ldaptestcomputer")
+        self.assertEquals(str(res[0]["name"]), "ldaptestcomputer")
+        self.assertEquals(str(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user", "computer"])
         self.assertTrue("objectGUID" in res[0])
         self.assertTrue("whenCreated" in res[0])
         self.assertEquals(res[0]["objectCategory"], ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn))
@@ -736,56 +747,77 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
         self.assertEquals(len(res6), 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))")
 
         self.assertEquals(res[0].dn, res6[0].dn)
-
-        ldb.delete(res[0].dn)
+        
+        ldb.delete("<GUID=" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + ">")
 
         print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
         res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))")
         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))")
 
         self.assertEquals(res[0].dn, ("CN=ldaptest2computer,CN=Computers," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptest2computer")
-        self.assertEquals(res[0]["name"], "ldaptest2computer")
-        self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"])
+        self.assertEquals(str(res[0]["cn"]), "ldaptest2computer")
+        self.assertEquals(str(res[0]["name"]), "ldaptest2computer")
+        self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user", "computer"])
         self.assertTrue("objectGUID" in res[0])
         self.assertTrue("whenCreated" in res[0])
         self.assertEquals(res[0]["objectCategory"][0], "CN=Computer,CN=Schema,CN=Configuration," + self.base_dn)
         self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306369)
         self.assertEquals(int(res[0]["userAccountControl"][0]), 4096)
 
-        ldb.delete(res[0].dn)
+        ldb.delete("<SID=" + ldb.schema_format_value("objectSID", res[0]["objectSID"][0]) + ">")
 
-        attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "memberOf"]
+        attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "memberOf", "allowedAttributes", "allowedAttributesEffective"]
         print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
-        res = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
-        self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
-
-        self.assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestuser2")
-        self.assertEquals(res[0]["name"], "ldaptestuser2")
-        self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"])
-        self.assertTrue("objectGUID" in res[0])
-        self.assertTrue("whenCreated" in res[0])
-        self.assertTrue("nTSecurityDescriptor" in res[0])
-        self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
-
-        attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
+        res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
+        self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
+
+        self.assertEquals(res_user[0].dn, ("CN=ldaptestuser2,CN=Users," + self.base_dn))
+        self.assertEquals(str(res_user[0]["cn"]), "ldaptestuser2")
+        self.assertEquals(str(res_user[0]["name"]), "ldaptestuser2")
+        self.assertEquals(list(res_user[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
+        self.assertTrue("objectSid" in res_user[0])
+        self.assertTrue("objectGUID" in res_user[0])
+        self.assertTrue("whenCreated" in res_user[0])
+        self.assertTrue("nTSecurityDescriptor" in res_user[0])
+        self.assertTrue("allowedAttributes" in res_user[0])
+        self.assertTrue("allowedAttributesEffective" in res_user[0])
+        self.assertEquals(res_user[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
+
+        ldaptestuser2_sid = res_user[0]["objectSid"][0]
+        ldaptestuser2_guid = res_user[0]["objectGUID"][0]
+
+        attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "member", "allowedAttributes", "allowedAttributesEffective"]
         print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
 
         self.assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestgroup2")
-        self.assertEquals(res[0]["name"], "ldaptestgroup2")
-        self.assertEquals(res[0]["objectClass"], ["top", "group"])
-        self.assertTrue("objectGuid" not in res[0])
+        self.assertEquals(str(res[0]["cn"]), "ldaptestgroup2")
+        self.assertEquals(str(res[0]["name"]), "ldaptestgroup2")
+        self.assertEquals(list(res[0]["objectClass"]), ["top", "group"])
+        self.assertTrue("objectGUID" in res[0])
+        self.assertTrue("objectSid" in res[0])
         self.assertTrue("whenCreated" in res[0])
         self.assertTrue("nTSecurityDescriptor" in res[0])
+        self.assertTrue("allowedAttributes" in res[0])
+        self.assertTrue("allowedAttributesEffective" in res[0])
         memberUP = []
         for m in res[0]["member"]:
             memberUP.append(m.upper())
         self.assertTrue(("CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
 
+        res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs, controls=["extended_dn:1:1"])
+        self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
+
+        print res[0]["member"]
+        memberUP = []
+        for m in res[0]["member"]:
+            memberUP.append(m.upper())
+        print ("<GUID=" + ldb.schema_format_value("objectGUID", ldaptestuser2_guid) + ">;<SID=" + ldb.schema_format_value("objectSid", ldaptestuser2_sid) + ">;CN=ldaptestuser2,CN=Users," + self.base_dn).upper()
+
+        self.assertTrue(("<GUID=" + ldb.schema_format_value("objectGUID", ldaptestuser2_guid) + ">;<SID=" + ldb.schema_format_value("objectSid", ldaptestuser2_sid) + ">;CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
+
+        print "Testing Linked attribute behaviours"
         ldb.modify_ldif("""
 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
 changetype: modify
@@ -794,9 +826,15 @@ member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """
 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
 """)
         
-        print "Testing Linked attribute behaviours"
         ldb.modify_ldif("""
-dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
+dn: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
+changetype: modify
+replace: member
+member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
+""")
+        
+        ldb.modify_ldif("""
+dn: <SID=""" + ldb.schema_format_value("objectSid", res[0]["objectSid"][0]) + """>
 changetype: modify
 delete: member
 """)
@@ -805,7 +843,7 @@ delete: member
 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
 changetype: modify
 add: member
-member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """
+member: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
 """)
         
@@ -819,7 +857,7 @@ replace: member
 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
 changetype: modify
 add: member
-member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """
+member: <SID=""" + ldb.schema_format_value("objectSid", res_user[0]["objectSid"][0]) + """>
 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
 """)
         
@@ -854,9 +892,9 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
 
         self.assertEquals(res[0].dn, ("CN=ldaptestutf8user èùéìòà,CN=Users," + self.base_dn))
-        self.assertEquals(res[0]["cn"], "ldaptestutf8user èùéìòà")
-        self.assertEquals(res[0]["name"], "ldaptestutf8user èùéìòà")
-        self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"])
+        self.assertEquals(str(res[0]["cn"]), "ldaptestutf8user èùéìòà")
+        self.assertEquals(str(res[0]["name"]), "ldaptestutf8user èùéìòà")
+        self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
         self.assertTrue("objectGUID" in res[0])
         self.assertTrue("whenCreated" in res[0])
 
@@ -919,7 +957,7 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
                          scope=SCOPE_BASE, attrs=["objectClass"])
         self.assertEquals(len(res), 1)
 
-        self.assertEquals(res[0]["objectClass"], ["top", "domain", "domainDNS"])
+        self.assertEquals(list(res[0]["objectClass"]), ["top", "domain", "domainDNS"])
 
     #  check enumeration
 
diff --git a/ldb/tools/ldbadd.c b/ldb/tools/ldbadd.c
index 15376e734..f32a4fa9b 100644
--- a/ldb/tools/ldbadd.c
+++ b/ldb/tools/ldbadd.c
@@ -92,6 +92,11 @@ int main(int argc, const char **argv)
 
 	options = ldb_cmdline_process(ldb, argc, argv, usage);
 
+	if (ldb_transaction_start(ldb) != 0) {
+		printf("Failed to start transaction: %s\n", ldb_errstring(ldb));
+		exit(1);
+	}
+
 	if (options->argc == 0) {
 		ret = process_file(ldb, stdin, &count);
 	} else {
@@ -108,6 +113,11 @@ int main(int argc, const char **argv)
 		}
 	}
 
+	if (count != 0 && ldb_transaction_commit(ldb) != 0) {
+		printf("Failed to commit transaction: %s\n", ldb_errstring(ldb));
+		exit(1);
+	}
+
 	talloc_free(ldb);
 
 	printf("Added %d records with %d failures\n", count, failures);
diff --git a/ldb/tools/ldbedit.c b/ldb/tools/ldbedit.c
index b2a040cd0..1a684c5c2 100644
--- a/ldb/tools/ldbedit.c
+++ b/ldb/tools/ldbedit.c
@@ -112,6 +112,11 @@ static int merge_edits(struct ldb_context *ldb,
 	int ret = 0;
 	int adds=0, modifies=0, deletes=0;
 
+	if (ldb_transaction_start(ldb) != 0) {
+		fprintf(stderr, "Failed to start transaction: %s\n", ldb_errstring(ldb));
+		return -1;
+	}
+
 	/* do the adds and modifies */
 	for (i=0;i<count2;i++) {
 		msg = msg_find(ldb, msgs1, count1, msgs2[i]->dn);
@@ -150,6 +155,11 @@ static int merge_edits(struct ldb_context *ldb,
 		}
 	}
 
+	if (ldb_transaction_commit(ldb) != 0) {
+		fprintf(stderr, "Failed to commit transaction: %s\n", ldb_errstring(ldb));
+		return -1;
+	}
+
 	printf("# %d adds  %d modifies  %d deletes\n", adds, modifies, deletes);
 
 	return ret;
diff --git a/ldb/tools/ldbmodify.c b/ldb/tools/ldbmodify.c
index 6e355a10c..d73937cea 100644
--- a/ldb/tools/ldbmodify.c
+++ b/ldb/tools/ldbmodify.c
@@ -93,6 +93,11 @@ int main(int argc, const char **argv)
 
 	options = ldb_cmdline_process(ldb, argc, argv, usage);
 
+	if (ldb_transaction_start(ldb) != 0) {
+		printf("Failed to start transaction: %s\n", ldb_errstring(ldb));
+		exit(1);
+	}
+
 	if (options->argc == 0) {
 		ret = process_file(ldb, stdin, &count);
 	} else {
@@ -108,6 +113,11 @@ int main(int argc, const char **argv)
 		}
 	}
 
+	if (count != 0 && ldb_transaction_commit(ldb) != 0) {
+		printf("Failed to commit transaction: %s\n", ldb_errstring(ldb));
+		exit(1);
+	}
+
 	talloc_free(ldb);
 
 	printf("Modified %d records with %d failures\n", count, failures);