s4: dsdb Avoid using the internal ldb_private.h header

This job is not complete (the partition module remains a unfinished
task), but now we do use the private ldb headers much less.

Andrew Bartlett

4 files changed, 120 insertions, 117 deletions

diff --git a/source4/dsdb/samdb/ldb_modules/extended_dn_in.c b/source4/dsdb/samdb/ldb_modules/extended_dn_in.c
index c3db4fa588..e6b0220242 100644
--- a/source4/dsdb/samdb/ldb_modules/extended_dn_in.c
+++ b/source4/dsdb/samdb/ldb_modules/extended_dn_in.c
@@ -32,7 +32,7 @@
 #include "includes.h"
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
+#include "ldb/include/ldb_module.h"
 
 /* search */
 struct extended_search_context {
@@ -116,7 +116,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 						(const char *)el->values[i].data,
 						el->values[i].length);
 			if (!valstr) {
-				ldb_oom(ac->module->ldb);
+				ldb_oom(ldb_module_get_ctx(ac->module));
 				return ldb_module_done(ac->req, NULL, NULL,
 						       LDB_ERR_OPERATIONS_ERROR);
 			}
@@ -134,10 +134,10 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 			break;
 		}
 
-		ac->basedn = ldb_dn_new(ac, ac->module->ldb, found);
+		ac->basedn = ldb_dn_new(ac, ldb_module_get_ctx(ac->module), found);
 		talloc_free(valstr);
 		if (!ac->basedn) {
-			ldb_oom(ac->module->ldb);
+			ldb_oom(ldb_module_get_ctx(ac->module));
 			return ldb_module_done(ac->req, NULL, NULL,
 					       LDB_ERR_OPERATIONS_ERROR);
 		}
@@ -152,7 +152,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 		if (!ac->basedn) {
 			const char *str = talloc_asprintf(req, "Base-DN '%s' not found",
 							  ldb_dn_get_linearized(ac->req->op.search.base));
-			ldb_set_errstring(ac->module->ldb, str);
+			ldb_set_errstring(ldb_module_get_ctx(ac->module), str);
 			return ldb_module_done(ac->req, NULL, NULL,
 					       LDB_ERR_NO_SUCH_OBJECT);
 		}
@@ -160,7 +160,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 		switch (ac->req->operation) {
 		case LDB_SEARCH:
 			ret = ldb_build_search_req_ex(&down_req,
-						      ac->module->ldb, ac->req,
+						      ldb_module_get_ctx(ac->module), ac->req,
 						      ac->basedn,
 						      ac->req->op.search.scope,
 						      ac->req->op.search.tree,
@@ -173,7 +173,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 		{
 			struct ldb_message *add_msg = ldb_msg_copy_shallow(ac, ac->req->op.add.message);
 			if (!add_msg) {
-				ldb_oom(ac->module->ldb);
+				ldb_oom(ldb_module_get_ctx(ac->module));
 				return ldb_module_done(ac->req, NULL, NULL,
 						       LDB_ERR_OPERATIONS_ERROR);
 			}
@@ -181,7 +181,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 			add_msg->dn = ac->basedn;
 
 			ret = ldb_build_add_req(&down_req,
-						ac->module->ldb, ac->req,
+						ldb_module_get_ctx(ac->module), ac->req,
 						add_msg, 
 						ac->req->controls,
 						ac, extended_final_callback, 
@@ -192,7 +192,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 		{
 			struct ldb_message *mod_msg = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
 			if (!mod_msg) {
-				ldb_oom(ac->module->ldb);
+				ldb_oom(ldb_module_get_ctx(ac->module));
 				return ldb_module_done(ac->req, NULL, NULL,
 						       LDB_ERR_OPERATIONS_ERROR);
 			}
@@ -200,7 +200,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 			mod_msg->dn = ac->basedn;
 
 			ret = ldb_build_mod_req(&down_req,
-						ac->module->ldb, ac->req,
+						ldb_module_get_ctx(ac->module), ac->req,
 						mod_msg, 
 						ac->req->controls,
 						ac, extended_final_callback, 
@@ -209,7 +209,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 		}
 		case LDB_DELETE:
 			ret = ldb_build_del_req(&down_req,
-						ac->module->ldb, ac->req,
+						ldb_module_get_ctx(ac->module), ac->req,
 						ac->basedn, 
 						ac->req->controls,
 						ac, extended_final_callback, 
@@ -217,7 +217,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
 			break;
 		case LDB_RENAME:
 			ret = ldb_build_rename_req(&down_req,
-						   ac->module->ldb, ac->req,
+						   ldb_module_get_ctx(ac->module), ac->req,
 						   ac->basedn, 
 						   ac->req->op.rename.newdn,
 						   ac->req->controls,
@@ -269,11 +269,11 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
 
 		if (sid_val) {
 			/* TODO: do a search over all partitions */
-			base_dn = ldb_get_default_basedn(module->ldb);
+			base_dn = ldb_get_default_basedn(ldb_module_get_ctx(module));
 			base_dn_filter = talloc_asprintf(req, "(objectSid=%s)", 
 							 ldb_binary_encode(req, *sid_val));
 			if (!base_dn_filter) {
-				ldb_oom(module->ldb);
+				ldb_oom(ldb_module_get_ctx(module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 			base_dn_scope = LDB_SCOPE_SUBTREE;
@@ -282,11 +282,11 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
 		} else if (guid_val) {
 
 			/* TODO: do a search over all partitions */
-			base_dn = ldb_get_default_basedn(module->ldb);
+			base_dn = ldb_get_default_basedn(ldb_module_get_ctx(module));
 			base_dn_filter = talloc_asprintf(req, "(objectGUID=%s)", 
 							 ldb_binary_encode(req, *guid_val));
 			if (!base_dn_filter) {
-				ldb_oom(module->ldb);
+				ldb_oom(ldb_module_get_ctx(module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 			base_dn_scope = LDB_SCOPE_SUBTREE;
@@ -310,21 +310,21 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
 
 			wellknown_object = talloc_asprintf(req, "B:32:%s:", wkguid_dup);
 			if (!wellknown_object) {
-				ldb_oom(module->ldb);
+				ldb_oom(ldb_module_get_ctx(module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 
 			tail_str = p;
 
-			base_dn = ldb_dn_new(req, module->ldb, tail_str);
+			base_dn = ldb_dn_new(req, ldb_module_get_ctx(module), tail_str);
 			talloc_free(wkguid_dup);
 			if (!base_dn) {
-				ldb_oom(module->ldb);
+				ldb_oom(ldb_module_get_ctx(module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 			base_dn_filter = talloc_strdup(req, "(objectClass=*)");
 			if (!base_dn_filter) {
-				ldb_oom(module->ldb);
+				ldb_oom(ldb_module_get_ctx(module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 			base_dn_scope = LDB_SCOPE_BASE;
@@ -335,7 +335,7 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
 
 		ac = talloc_zero(req, struct extended_search_context);
 		if (ac == NULL) {
-			ldb_oom(module->ldb);
+			ldb_oom(ldb_module_get_ctx(module));
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		
@@ -348,7 +348,7 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
 		 * GUID) then search for that, so we can proceed with the original operation */
 
 		ret = ldb_build_search_req(&down_req,
-					   module->ldb, ac,
+					   ldb_module_get_ctx(module), ac,
 					   base_dn,
 					   base_dn_scope,
 					   base_dn_filter,
diff --git a/source4/dsdb/samdb/ldb_modules/extended_dn_out.c b/source4/dsdb/samdb/ldb_modules/extended_dn_out.c
index f8526faf3b..f93090ace9 100644
--- a/source4/dsdb/samdb/ldb_modules/extended_dn_out.c
+++ b/source4/dsdb/samdb/ldb_modules/extended_dn_out.c
@@ -34,7 +34,7 @@
 #include "includes.h"
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
+#include "ldb/include/ldb_module.h"
 #include "librpc/gen_ndr/ndr_misc.h"
 #include "librpc/ndr/libndr.h"
 #include "dsdb/samdb/samdb.h"
@@ -249,7 +249,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
 	struct extended_dn_out_private *p;
 
 	ac = talloc_get_type(req->context, struct extended_search_context);
-	p = talloc_get_type(ac->module->private_data, struct extended_dn_out_private);
+	p = talloc_get_type(ldb_module_get_private(ac->module), struct extended_dn_out_private);
 
 	if (!ares) {
 		return ldb_module_done(ac->req, NULL, NULL,
@@ -281,7 +281,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
 	if (ac->inject) {
 		/* for each record returned post-process to add any derived
 		   attributes that have been asked for */
-		ret = inject_extended_dn_out(ares, ac->module->ldb,
+		ret = inject_extended_dn_out(ares, ldb_module_get_ctx(ac->module),
 					     ac->extended_type, ac->remove_guid,
 					     ac->remove_sid);
 		if (ret != LDB_SUCCESS) {
@@ -301,7 +301,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
 							 ldb_dn_get_linearized(ares->message->dn));
 			}
 			if (ret != LDB_SUCCESS) {
-				ldb_oom(ac->module->ldb);
+				ldb_oom(ldb_module_get_ctx(ac->module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 		}
@@ -329,7 +329,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
 			 * correct case */
 			msg->elements[i].name = talloc_strdup(msg->elements, attribute->lDAPDisplayName);
 			if (!msg->elements[i].name) {
-				ldb_oom(ac->module->ldb);
+				ldb_oom(ldb_module_get_ctx(ac->module));
 				return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
 			}
 		}
@@ -346,7 +346,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
 
 		for (j = 0; j < msg->elements[i].num_values; j++) {
 			const char *dn_str;
-			struct ldb_dn *dn = ldb_dn_from_ldb_val(ac, ac->module->ldb, &msg->elements[i].values[j]);
+			struct ldb_dn *dn = ldb_dn_from_ldb_val(ac, ldb_module_get_ctx(ac->module), &msg->elements[i].values[j]);
 			if (!dn || !ldb_dn_validate(dn)) {
 				return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_INVALID_DN_SYNTAX);
 			}
@@ -385,7 +385,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
 										     dn, ac->extended_type));
 			}
 			if (!dn_str) {
-				ldb_oom(ac->module->ldb);
+				ldb_oom(ldb_module_get_ctx(ac->module));
 				return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
 			}
 			msg->elements[i].values[j] = data_blob_string_const(dn_str);
@@ -408,7 +408,7 @@ static int extended_dn_out_search(struct ldb_module *module, struct ldb_request
 	const char * const *const_attrs;
 	int ret;
 
-	struct extended_dn_out_private *p = talloc_get_type(module->private_data, struct extended_dn_out_private);
+	struct extended_dn_out_private *p = talloc_get_type(ldb_module_get_private(module), struct extended_dn_out_private);
 
 	/* check if there's an extended dn control */
 	control = ldb_request_get_control(req, LDB_CONTROL_EXTENDED_DN_OID);
@@ -426,19 +426,19 @@ static int extended_dn_out_search(struct ldb_module *module, struct ldb_request
 	if (!control && storage_format_control && storage_format_control->data) {
 		extended_ctrl = talloc_get_type(storage_format_control->data, struct ldb_extended_dn_control);
 		if (!extended_ctrl) {
-			ldb_set_errstring(module->ldb, "extended_dn_out: extended_ctrl was of the wrong data type");
+			ldb_set_errstring(ldb_module_get_ctx(module), "extended_dn_out: extended_ctrl was of the wrong data type");
 			return LDB_ERR_PROTOCOL_ERROR;
 		}
 	}
 
 	ac = talloc_zero(req, struct extended_search_context);
 	if (ac == NULL) {
-		ldb_oom(module->ldb);
+		ldb_oom(ldb_module_get_ctx(module));
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	ac->module = module;
-	ac->schema = dsdb_get_schema(module->ldb);
+	ac->schema = dsdb_get_schema(ldb_module_get_ctx(module));
 	ac->req = req;
 	ac->inject = false;
 	ac->remove_guid = false;
@@ -469,7 +469,7 @@ static int extended_dn_out_search(struct ldb_module *module, struct ldb_request
 			if (ac->remove_guid || ac->remove_sid) {
 				new_attrs = copy_attrs(ac, req->op.search.attrs);
 				if (new_attrs == NULL) {
-					ldb_oom(module->ldb);
+					ldb_oom(ldb_module_get_ctx(module));
 					return LDB_ERR_OPERATIONS_ERROR;
 				}
 
@@ -487,7 +487,7 @@ static int extended_dn_out_search(struct ldb_module *module, struct ldb_request
 	}
 
 	ret = ldb_build_search_req_ex(&down_req,
-				      module->ldb, ac,
+				      ldb_module_get_ctx(module), ac,
 				      req->op.search.base,
 				      req->op.search.scope,
 				      req->op.search.tree,
@@ -541,10 +541,10 @@ static int extended_dn_out_ldb_init(struct ldb_module *module)
 
 	struct extended_dn_out_private *p = talloc(module, struct extended_dn_out_private);
 
-	module->private_data = p;
+	ldb_module_set_private(module, p);
 
 	if (!p) {
-		ldb_oom(module->ldb);
+		ldb_oom(ldb_module_get_ctx(module));
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -553,7 +553,7 @@ static int extended_dn_out_ldb_init(struct ldb_module *module)
 
 	ret = ldb_mod_register_control(module, LDB_CONTROL_EXTENDED_DN_OID);
 	if (ret != LDB_SUCCESS) {
-		ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+		ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
 			"extended_dn_out: Unable to register control with rootdse!\n");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -564,16 +564,16 @@ static int extended_dn_out_ldb_init(struct ldb_module *module)
 static int extended_dn_out_dereference_init(struct ldb_module *module)
 {
 	int ret, i = 0;
-	struct extended_dn_out_private *p;
+	struct extended_dn_out_private *p = talloc_zero(module, struct extended_dn_out_private);
 	struct dsdb_openldap_dereference_control *dereference_control;
 	struct dsdb_attribute *cur;
 
 	struct dsdb_schema *schema;
 
-	module->private_data = p = talloc_zero(module, struct extended_dn_out_private);
+	ldb_module_set_private(module, p);
 
 	if (!p) {
-		ldb_oom(module->ldb);
+		ldb_oom(ldb_module_get_ctx(module));
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -585,7 +585,7 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
 
 	ret = ldb_mod_register_control(module, LDB_CONTROL_EXTENDED_DN_OID);
 	if (ret != LDB_SUCCESS) {
-		ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+		ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
 			"extended_dn_out: Unable to register control with rootdse!\n");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -596,7 +596,7 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
 		return ret;
 	}
 
-	schema = dsdb_get_schema(module->ldb);
+	schema = dsdb_get_schema(ldb_module_get_ctx(module));
 	if (!schema) {
 		/* No schema on this DB (yet) */
 		return LDB_SUCCESS;
@@ -606,7 +606,7 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
 		= talloc_zero(p, struct dsdb_openldap_dereference_control);
 
 	if (!p->dereference_control) {
-		ldb_oom(module->ldb);
+		ldb_oom(ldb_module_get_ctx(module));
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	
@@ -624,13 +624,13 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
 			= talloc_realloc(p, dereference_control->dereference,
 					 struct dsdb_openldap_dereference *, i + 2);
 		if (!dereference_control) {
-			ldb_oom(module->ldb);
+			ldb_oom(ldb_module_get_ctx(module));
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		dereference_control->dereference[i] = talloc(dereference_control->dereference,  
 					 struct dsdb_openldap_dereference);
 		if (!dereference_control->dereference[i]) {
-			ldb_oom(module->ldb);
+			ldb_oom(ldb_module_get_ctx(module));
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		dereference_control->dereference[i]->source_attribute = cur->lDAPDisplayName;
diff --git a/source4/dsdb/samdb/ldb_modules/extended_dn_store.c b/source4/dsdb/samdb/ldb_modules/extended_dn_store.c
index 4f4e9d0fd7..3234f6f269 100644
--- a/source4/dsdb/samdb/ldb_modules/extended_dn_store.c
+++ b/source4/dsdb/samdb/ldb_modules/extended_dn_store.c
@@ -38,7 +38,7 @@
 #include "includes.h"
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
+#include "ldb/include/ldb_module.h"
 #include "librpc/gen_ndr/ndr_misc.h"
 #include "dsdb/samdb/samdb.h"
 #include "libcli/security/security.h"
@@ -73,11 +73,11 @@ static struct extended_dn_context *extended_dn_context_init(struct ldb_module *m
 
 	ac = talloc_zero(req, struct extended_dn_context);
 	if (ac == NULL) {
-		ldb_oom(module->ldb);
+		ldb_oom(ldb_module_get_ctx(module));
 		return NULL;
 	}
 
-	ac->schema = dsdb_get_schema(module->ldb);
+	ac->schema = dsdb_get_schema(ldb_module_get_ctx(module));
 	ac->module = module;
 	ac->req = req;
 
@@ -127,7 +127,7 @@ static int extended_replace_dn(struct ldb_request *req, struct ldb_reply *ares)
 	if (ares->error == LDB_ERR_NO_SUCH_OBJECT) {
 		/* Don't worry too much about dangling references */
 
-		ldb_reset_err_string(os->ac->module->ldb);
+		ldb_reset_err_string(ldb_module_get_ctx(os->ac->module));
 		if (os->next) {
 			struct extended_dn_replace_list *next;
 
@@ -228,10 +228,10 @@ static int extended_store_replace(struct extended_dn_context *ac,
 	
 	os->mem_ctx = callback_mem_ctx;
 
-	os->dn = ldb_dn_from_ldb_val(os, ac->module->ldb, plain_dn);
+	os->dn = ldb_dn_from_ldb_val(os, ldb_module_get_ctx(ac->module), plain_dn);
 	if (!os->dn || !ldb_dn_validate(os->dn)) {
 		talloc_free(os);
-		ldb_asprintf_errstring(ac->module->ldb, 
+		ldb_asprintf_errstring(ldb_module_get_ctx(ac->module), 
 				       "could not parse %.*s as a DN", (int)plain_dn->length, plain_dn->data);
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
@@ -243,7 +243,7 @@ static int extended_store_replace(struct extended_dn_context *ac,
 	 * module in the stack will convert this into a normal DN for
 	 * processing */
 	ret = ldb_build_search_req(&os->search_req,
-				   ac->module->ldb, os, os->dn, LDB_SCOPE_BASE, NULL, 
+				   ldb_module_get_ctx(ac->module), os, os->dn, LDB_SCOPE_BASE, NULL, 
 				   attrs, NULL, os, extended_replace_dn,
 				   ac->req);
 
@@ -311,11 +311,11 @@ static int extended_dn_add(struct ldb_module *module, struct ldb_request *req)
 		if (!ac->new_req) {
 			struct ldb_message *msg = ldb_msg_copy(ac, req->op.add.message);
 			if (!msg) {
-				ldb_oom(module->ldb);
+				ldb_oom(ldb_module_get_ctx(module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 		   
-			ret = ldb_build_add_req(&ac->new_req, module->ldb, ac, msg, req->controls, ac, extended_final_callback, req);
+			ret = ldb_build_add_req(&ac->new_req, ldb_module_get_ctx(module), ac, msg, req->controls, ac, extended_final_callback, req);
 			if (ret != LDB_SUCCESS) {
 				return ret;
 			}
@@ -384,11 +384,11 @@ static int extended_dn_modify(struct ldb_module *module, struct ldb_request *req
 		if (!ac->new_req) {
 			struct ldb_message *msg = ldb_msg_copy(ac, req->op.mod.message);
 			if (!msg) {
-				ldb_oom(module->ldb);
+				ldb_oom(ldb_module_get_ctx(module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 		   
-			ret = ldb_build_mod_req(&ac->new_req, module->ldb, ac, msg, req->controls, ac, extended_final_callback, req);
+			ret = ldb_build_mod_req(&ac->new_req, ldb_module_get_ctx(module), ac, msg, req->controls, ac, extended_final_callback, req);
 			if (ret != LDB_SUCCESS) {
 				return ret;
 			}
@@ -397,9 +397,9 @@ static int extended_dn_modify(struct ldb_module *module, struct ldb_request *req
 		el = &ac->new_req->op.mod.message->elements[i];
 		/* For each value being added, we need to setup the lookups to fill in the extended DN */
 		for (j = 0; j < el->num_values; j++) {
-			struct ldb_dn *dn = ldb_dn_from_ldb_val(ac, module->ldb, &el->values[j]);
+			struct ldb_dn *dn = ldb_dn_from_ldb_val(ac, ldb_module_get_ctx(module), &el->values[j]);
 			if (!dn || !ldb_dn_validate(dn)) {
-				ldb_asprintf_errstring(module->ldb, 
+				ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 						       "could not parse attribute %s as a DN", el->name);
 				return LDB_ERR_INVALID_DN_SYNTAX;
 			}
diff --git a/source4/dsdb/samdb/ldb_modules/partition.c b/source4/dsdb/samdb/ldb_modules/partition.c
index d4269b631b..9763664940 100644
--- a/source4/dsdb/samdb/ldb_modules/partition.c
+++ b/source4/dsdb/samdb/ldb_modules/partition.c
@@ -34,6 +34,9 @@
  */
 
 #include "includes.h"
+#include "lib/ldb/include/ldb.h"
+#include "lib/ldb/include/ldb_errors.h"
+#include "lib/ldb/include/ldb_module.h"
 #include "lib/ldb/include/ldb_private.h"
 #include "dsdb/samdb/samdb.h"
 
@@ -63,7 +66,7 @@ static struct partition_context *partition_init_ctx(struct ldb_module *module, s
 
 	ac = talloc_zero(req, struct partition_context);
 	if (ac == NULL) {
-		ldb_set_errstring(module->ldb, "Out of Memory");
+		ldb_set_errstring(ldb_module_get_ctx(module), "Out of Memory");
 		return NULL;
 	}
 
@@ -80,7 +83,7 @@ static struct partition_context *partition_init_ctx(struct ldb_module *module, s
 #define PARTITION_FIND_OP(module, op) do { \
 	PARTITION_FIND_OP_NOERROR(module, op); \
         if (module == NULL) { \
-                ldb_asprintf_errstring(module->ldb, \
+                ldb_asprintf_errstring(ldb_module_get_ctx(module), \
 			"Unable to find backend operation for " #op ); \
                 return LDB_ERR_OPERATIONS_ERROR; \
         } \
@@ -126,9 +129,9 @@ static int partition_request(struct ldb_module *module, struct ldb_request *requ
 	if (ret == LDB_SUCCESS) {
 		return ret;
 	}
-	if (!ldb_errstring(module->ldb)) {
+	if (!ldb_errstring(ldb_module_get_ctx(module))) {
 		/* Set a default error string, to place the blame somewhere */
-		ldb_asprintf_errstring(module->ldb,
+		ldb_asprintf_errstring(ldb_module_get_ctx(module),
 					"error in module %s: %s (%d)",
 					module->ops->name,
 					ldb_strerror(ret), ret);
@@ -183,7 +186,7 @@ static int partition_req_callback(struct ldb_request *req,
 
 	case LDB_REPLY_ENTRY:
 		if (ac->req->operation != LDB_SEARCH) {
-			ldb_set_errstring(ac->module->ldb,
+			ldb_set_errstring(ldb_module_get_ctx(ac->module),
 				"partition_req_callback:"
 				" Unsupported reply type for this request");
 			return ldb_module_done(ac->req, NULL, NULL,
@@ -199,7 +202,7 @@ static int partition_req_callback(struct ldb_request *req,
 			/* FIXME: check for ares->response, replmd does not fill it ! */
 			if (ares->response) {
 				if (strcmp(ares->response->oid, LDB_EXTENDED_START_TLS_OID) != 0) {
-					ldb_set_errstring(ac->module->ldb,
+					ldb_set_errstring(ldb_module_get_ctx(ac->module),
 							  "partition_req_callback:"
 							  " Unknown extended reply, "
 							  "only supports START_TLS");
@@ -245,13 +248,13 @@ static int partition_prep_request(struct partition_context *ac,
 					struct part_request,
 					ac->num_requests + 1);
 	if (ac->part_req == NULL) {
-		ldb_oom(ac->module->ldb);
+		ldb_oom(ldb_module_get_ctx(ac->module));
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	switch (ac->req->operation) {
 	case LDB_SEARCH:
-		ret = ldb_build_search_req_ex(&req, ac->module->ldb,
+		ret = ldb_build_search_req_ex(&req, ldb_module_get_ctx(ac->module),
 					ac->part_req,
 					ac->req->op.search.base,
 					ac->req->op.search.scope,
@@ -262,28 +265,28 @@ static int partition_prep_request(struct partition_context *ac,
 					ac->req);
 		break;
 	case LDB_ADD:
-		ret = ldb_build_add_req(&req, ac->module->ldb, ac->part_req,
+		ret = ldb_build_add_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
 					ac->req->op.add.message,
 					ac->req->controls,
 					ac, partition_req_callback,
 					ac->req);
 		break;
 	case LDB_MODIFY:
-		ret = ldb_build_mod_req(&req, ac->module->ldb, ac->part_req,
+		ret = ldb_build_mod_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
 					ac->req->op.mod.message,
 					ac->req->controls,
 					ac, partition_req_callback,
 					ac->req);
 		break;
 	case LDB_DELETE:
-		ret = ldb_build_del_req(&req, ac->module->ldb, ac->part_req,
+		ret = ldb_build_del_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
 					ac->req->op.del.dn,
 					ac->req->controls,
 					ac, partition_req_callback,
 					ac->req);
 		break;
 	case LDB_RENAME:
-		ret = ldb_build_rename_req(&req, ac->module->ldb, ac->part_req,
+		ret = ldb_build_rename_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
 					ac->req->op.rename.olddn,
 					ac->req->op.rename.newdn,
 					ac->req->controls,
@@ -291,7 +294,7 @@ static int partition_prep_request(struct partition_context *ac,
 					ac->req);
 		break;
 	case LDB_EXTENDED:
-		ret = ldb_build_extended_req(&req, ac->module->ldb,
+		ret = ldb_build_extended_req(&req, ldb_module_get_ctx(ac->module),
 					ac->part_req,
 					ac->req->op.extended.oid,
 					ac->req->op.extended.data,
@@ -300,7 +303,7 @@ static int partition_prep_request(struct partition_context *ac,
 					ac->req);
 		break;
 	default:
-		ldb_set_errstring(ac->module->ldb,
+		ldb_set_errstring(ldb_module_get_ctx(ac->module),
 				  "Unsupported request type!");
 		ret = LDB_ERR_UNWILLING_TO_PERFORM;
 	}
@@ -315,7 +318,7 @@ static int partition_prep_request(struct partition_context *ac,
 		req->controls = talloc_memdup(req, ac->req->controls,
 					talloc_get_size(ac->req->controls));
 		if (req->controls == NULL) {
-			ldb_oom(ac->module->ldb);
+			ldb_oom(ldb_module_get_ctx(ac->module));
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
 	}
@@ -467,7 +470,7 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
 
 	/* Remove the domain_scope control, so we don't confuse a backend server */
 	if (domain_scope_control && !save_controls(domain_scope_control, req, &saved_controls)) {
-		ldb_oom(module->ldb);
+		ldb_oom(ldb_module_get_ctx(module));
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -491,7 +494,7 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
 
 			/* Remove search control, so we don't confuse a backend server */
 			if (search_control && !save_controls(search_control, req, &saved_controls)) {
-				ldb_oom(module->ldb);
+				ldb_oom(ldb_module_get_ctx(module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 		}
@@ -558,7 +561,7 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
 
 			/* Remove search control, so we don't confuse a backend server */
 			if (search_control && !save_controls(search_control, req, &saved_controls)) {
-				ldb_oom(module->ldb);
+				ldb_oom(ldb_module_get_ctx(module));
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
 		}
@@ -607,7 +610,7 @@ static int partition_rename(struct ldb_module *module, struct ldb_request *req)
 	}
 
 	if (backend != backend2) {
-		ldb_asprintf_errstring(module->ldb, 
+		ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 				       "Cannot rename from %s in %s to %s in %s: %s",
 				       ldb_dn_get_linearized(req->op.rename.olddn),
 				       ldb_dn_get_linearized(backend->dn),
@@ -681,7 +684,7 @@ static int partition_end_trans(struct ldb_module *module)
 		PARTITION_FIND_OP(next_del, del_transaction);
 
 		if (next_end != next_prepare || next_del != next_end) {
-			ldb_asprintf_errstring(module->ldb, "ERROR: Mismatch between prepare and commit ops in ldb module");
+			ldb_asprintf_errstring(ldb_module_get_ctx(module), "ERROR: Mismatch between prepare and commit ops in ldb module");
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		
@@ -713,7 +716,7 @@ static int partition_end_trans(struct ldb_module *module)
 		if (ret != LDB_SUCCESS) {
 			/* this should only be happening if we had a serious 
 			   OS or hardware error */
-			ldb_asprintf_errstring(module->ldb, "ERROR: partition commit error");
+			ldb_asprintf_errstring(ldb_module_get_ctx(module), "ERROR: partition commit error");
 			final_ret = ret;
 		}
 	}
@@ -781,7 +784,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
 		}
 		tseq->type = seq->type;
 
-		ret = ldb_build_extended_req(&treq, module->ldb, res,
+		ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
 					     LDB_EXTENDED_SEQUENCE_NUMBER,
 					     tseq,
 					     NULL,
@@ -819,7 +822,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
 			}
 			tseq->type = seq->type;
 
-			ret = ldb_build_extended_req(&treq, module->ldb, res,
+			ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
 						     LDB_EXTENDED_SEQUENCE_NUMBER,
 						     tseq,
 						     NULL,
@@ -874,7 +877,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
 		}
 		tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
 
-		ret = ldb_build_extended_req(&treq, module->ldb, res,
+		ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
 					     LDB_EXTENDED_SEQUENCE_NUMBER,
 					     tseq,
 					     NULL,
@@ -918,7 +921,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
 			}
 			tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
 
-			ret = ldb_build_extended_req(&treq, module->ldb, res,
+			ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
 						     LDB_EXTENDED_SEQUENCE_NUMBER,
 						     tseq,
 						     NULL,
@@ -1008,12 +1011,12 @@ static int partition_extended_replicated_objects(struct ldb_module *module, stru
 
 	ext = talloc_get_type(req->op.extended.data, struct dsdb_extended_replicated_objects);
 	if (!ext) {
-		ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended_replicated_objects: invalid extended data\n");
+		ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_FATAL, "partition_extended_replicated_objects: invalid extended data\n");
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
 
 	if (ext->version != DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION) {
-		ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended_replicated_objects: extended data invalid version [%u != %u]\n",
+		ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_FATAL, "partition_extended_replicated_objects: extended data invalid version [%u != %u]\n",
 			  ext->version, DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION);
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
@@ -1031,7 +1034,7 @@ static int partition_extended_schema_update_now(struct ldb_module *module, struc
 
 	schema_dn = talloc_get_type(req->op.extended.data, struct ldb_dn);
 	if (!schema_dn) {
-		ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended: invalid extended data\n");
+		ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_FATAL, "partition_extended: invalid extended data\n");
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
 
@@ -1131,8 +1134,8 @@ static int partition_init(struct ldb_module *module)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = ldb_search(module->ldb, mem_ctx, &res,
-			 ldb_dn_new(mem_ctx, module->ldb, "@PARTITION"),
+	ret = ldb_search(ldb_module_get_ctx(module), mem_ctx, &res,
+			 ldb_dn_new(mem_ctx, ldb_module_get_ctx(module), "@PARTITION"),
 			 LDB_SCOPE_BASE, attrs, NULL);
 	if (ret != LDB_SUCCESS) {
 		talloc_free(mem_ctx);
@@ -1152,7 +1155,7 @@ static int partition_init(struct ldb_module *module)
 
 	partition_attributes = ldb_msg_find_element(msg, "partition");
 	if (!partition_attributes) {
-		ldb_set_errstring(module->ldb, "partition_init: no partitions specified");
+		ldb_set_errstring(ldb_module_get_ctx(module), "partition_init: no partitions specified");
 		talloc_free(mem_ctx);
 		return LDB_ERR_CONSTRAINT_VIOLATION;
 	}
@@ -1165,7 +1168,7 @@ static int partition_init(struct ldb_module *module)
 		char *base = talloc_strdup(data->partitions, (char *)partition_attributes->values[i].data);
 		char *p = strchr(base, ':');
 		if (!p) {
-			ldb_asprintf_errstring(module->ldb, 
+			ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 						"partition_init: "
 						"invalid form for partition record (missing ':'): %s", base);
 			talloc_free(mem_ctx);
@@ -1174,7 +1177,7 @@ static int partition_init(struct ldb_module *module)
 		p[0] = '\0';
 		p++;
 		if (!p[0]) {
-			ldb_asprintf_errstring(module->ldb, 
+			ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 						"partition_init: "
 						"invalid form for partition record (missing backend database): %s", base);
 			talloc_free(mem_ctx);
@@ -1187,23 +1190,23 @@ static int partition_init(struct ldb_module *module)
 		}
 		data->partitions[i]->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
 
-		data->partitions[i]->dn = ldb_dn_new(data->partitions[i], module->ldb, base);
+		data->partitions[i]->dn = ldb_dn_new(data->partitions[i], ldb_module_get_ctx(module), base);
 		if (!data->partitions[i]->dn) {
-			ldb_asprintf_errstring(module->ldb, 
+			ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 						"partition_init: invalid DN in partition record: %s", base);
 			talloc_free(mem_ctx);
 			return LDB_ERR_CONSTRAINT_VIOLATION;
 		}
 
-		data->partitions[i]->backend = samdb_relative_path(module->ldb, 
+		data->partitions[i]->backend = samdb_relative_path(ldb_module_get_ctx(module), 
 								   data->partitions[i], 
 								   p);
 		if (!data->partitions[i]->backend) {
-			ldb_asprintf_errstring(module->ldb, 
+			ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 						"partition_init: unable to determine an relative path for partition: %s", base);
 			talloc_free(mem_ctx);			
 		}
-		ret = ldb_connect_backend(module->ldb, data->partitions[i]->backend, NULL, &data->partitions[i]->module);
+		ret = ldb_connect_backend(ldb_module_get_ctx(module), data->partitions[i]->backend, NULL, &data->partitions[i]->module);
 		if (ret != LDB_SUCCESS) {
 			talloc_free(mem_ctx);
 			return ret;
@@ -1219,7 +1222,7 @@ static int partition_init(struct ldb_module *module)
 		struct ldb_request *req;
 		req = talloc_zero(mem_ctx, struct ldb_request);
 		if (req == NULL) {
-			ldb_debug(module->ldb, LDB_DEBUG_ERROR, "partition: Out of memory!\n");
+			ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR, "partition: Out of memory!\n");
 			talloc_free(mem_ctx);
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
@@ -1228,19 +1231,19 @@ static int partition_init(struct ldb_module *module)
 		req->op.reg_partition.dn = data->partitions[i]->dn;
 		req->callback = ldb_op_default_callback;
 
-		ldb_set_timeout(module->ldb, req, 0);
+		ldb_set_timeout(ldb_module_get_ctx(module), req, 0);
 
-		req->handle = ldb_handle_new(req, module->ldb);
+		req->handle = ldb_handle_new(req, ldb_module_get_ctx(module));
 		if (req->handle == NULL) {
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		
-		ret = ldb_request(module->ldb, req);
+		ret = ldb_request(ldb_module_get_ctx(module), req);
 		if (ret == LDB_SUCCESS) {
 			ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 		}
 		if (ret != LDB_SUCCESS) {
-			ldb_debug(module->ldb, LDB_DEBUG_ERROR, "partition: Unable to register partition with rootdse!\n");
+			ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR, "partition: Unable to register partition with rootdse!\n");
 			talloc_free(mem_ctx);
 			return LDB_ERR_OTHER;
 		}
@@ -1258,9 +1261,9 @@ static int partition_init(struct ldb_module *module)
 		}
 
 		for (i=0; i < replicate_attributes->num_values; i++) {
-			data->replicate[i] = ldb_dn_from_ldb_val(data->replicate, module->ldb, &replicate_attributes->values[i]);
+			data->replicate[i] = ldb_dn_from_ldb_val(data->replicate, ldb_module_get_ctx(module), &replicate_attributes->values[i]);
 			if (!ldb_dn_validate(data->replicate[i])) {
-				ldb_asprintf_errstring(module->ldb, 
+				ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 							"partition_init: "
 							"invalid DN in partition replicate record: %s", 
 							replicate_attributes->values[i].data);
@@ -1286,7 +1289,7 @@ static int partition_init(struct ldb_module *module)
 			char *base = talloc_strdup(data->partitions, (char *)modules_attributes->values[i].data);
 			char *p = strchr(base, ':');
 			if (!p) {
-				ldb_asprintf_errstring(module->ldb, 
+				ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 							"partition_init: "
 							"invalid form for partition module record (missing ':'): %s", base);
 				talloc_free(mem_ctx);
@@ -1295,17 +1298,17 @@ static int partition_init(struct ldb_module *module)
 			p[0] = '\0';
 			p++;
 			if (!p[0]) {
-				ldb_asprintf_errstring(module->ldb, 
+				ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 							"partition_init: "
 							"invalid form for partition module record (missing backend database): %s", base);
 				talloc_free(mem_ctx);
 				return LDB_ERR_CONSTRAINT_VIOLATION;
 			}
 
-			modules = ldb_modules_list_from_string(module->ldb, mem_ctx,
+			modules = ldb_modules_list_from_string(ldb_module_get_ctx(module), mem_ctx,
 							       p);
 			
-			base_dn = ldb_dn_new(mem_ctx, module->ldb, base);
+			base_dn = ldb_dn_new(mem_ctx, ldb_module_get_ctx(module), base);
 			if (!ldb_dn_validate(base_dn)) {
 				talloc_free(mem_ctx);
 				return LDB_ERR_OPERATIONS_ERROR;
@@ -1319,28 +1322,28 @@ static int partition_init(struct ldb_module *module)
 			}
 			
 			if (!partition) {
-				ldb_asprintf_errstring(module->ldb, 
+				ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 							"partition_init: "
 							"invalid form for partition module record (no such partition): %s", base);
 				talloc_free(mem_ctx);
 				return LDB_ERR_CONSTRAINT_VIOLATION;
 			}
 			
-			ret = ldb_load_modules_list(module->ldb, modules, partition->module, &partition->module);
+			ret = ldb_load_modules_list(ldb_module_get_ctx(module), modules, partition->module, &partition->module);
 			if (ret != LDB_SUCCESS) {
-				ldb_asprintf_errstring(module->ldb, 
+				ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 						       "partition_init: "
 						       "loading backend for %s failed: %s", 
-						       base, ldb_errstring(module->ldb));
+						       base, ldb_errstring(ldb_module_get_ctx(module)));
 				talloc_free(mem_ctx);
 				return ret;
 			}
-			ret = ldb_init_module_chain(module->ldb, partition->module);
+			ret = ldb_init_module_chain(ldb_module_get_ctx(module), partition->module);
 			if (ret != LDB_SUCCESS) {
-				ldb_asprintf_errstring(module->ldb, 
+				ldb_asprintf_errstring(ldb_module_get_ctx(module), 
 						       "partition_init: "
 						       "initialising backend for %s failed: %s", 
-						       base, ldb_errstring(module->ldb));
+						       base, ldb_errstring(ldb_module_get_ctx(module)));
 				talloc_free(mem_ctx);
 				return ret;
 			}
@@ -1349,14 +1352,14 @@ static int partition_init(struct ldb_module *module)
 
 	ret = ldb_mod_register_control(module, LDB_CONTROL_DOMAIN_SCOPE_OID);
 	if (ret != LDB_SUCCESS) {
-		ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+		ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
 			"partition: Unable to register control with rootdse!\n");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	ret = ldb_mod_register_control(module, LDB_CONTROL_SEARCH_OPTIONS_OID);
 	if (ret != LDB_SUCCESS) {
-		ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+		ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
 			"partition: Unable to register control with rootdse!\n");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}