Sync ldb with upstream (includes uncommitted ldb async patches)

5 files changed, 744 insertions, 902 deletions

diff --git a/ldb/ldb_map/ldb_map.c b/ldb/ldb_map/ldb_map.c
index b3f639dc..fafbb63b 100644
--- a/ldb/ldb_map/ldb_map.c
+++ b/ldb/ldb_map/ldb_map.c
@@ -3,6 +3,7 @@
 
    Copyright (C) Jelmer Vernooij 2005
    Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
+   Copyright (C) Simo Sorce 2008
 
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
@@ -106,69 +107,23 @@ const struct ldb_map_context *map_get_context(struct ldb_module *module)
 }
 
 /* Create a generic request context. */
-static struct map_context *map_init_context(struct ldb_handle *h, struct ldb_request *req)
+struct map_context *map_init_context(struct ldb_module *module,
+					struct ldb_request *req)
 {
 	struct map_context *ac;
 
-	ac = talloc_zero(h, struct map_context);
+	ac = talloc_zero(req, struct map_context);
 	if (ac == NULL) {
-		map_oom(h->module);
+		ldb_set_errstring(module->ldb, "Out of Memory");
 		return NULL;
 	}
 
-	ac->module = h->module;
-	ac->orig_req = req;
+	ac->module = module;
+	ac->req = req;
 
 	return ac;
 }
 
-/* Create a search request context. */
-struct map_search_context *map_init_search_context(struct map_context *ac, struct ldb_reply *ares)
-{
-	struct map_search_context *sc;
-
-	sc = talloc_zero(ac, struct map_search_context);
-	if (sc == NULL) {
-		map_oom(ac->module);
-		return NULL;
-	}
-
-	sc->ac = ac;
-	sc->local_res = NULL;
-	sc->remote_res = ares;
-
-	return sc;
-}
-
-/* Create a request context and handle. */
-struct ldb_handle *map_init_handle(struct ldb_request *req, struct ldb_module *module)
-{
-	struct map_context *ac;
-	struct ldb_handle *h;
-
-	h = talloc_zero(req, struct ldb_handle);
-	if (h == NULL) {
-		map_oom(module);
-		return NULL;
-	}
-
-	h->module = module;
-
-	ac = map_init_context(h, req);
-	if (ac == NULL) {
-		talloc_free(h);
-		return NULL;
-	}
-
-	h->private_data = (void *)ac;
-
-	h->state = LDB_ASYNC_INIT;
-	h->status = LDB_SUCCESS;
-
-	return h;
-}
-
-
 /* Dealing with DNs for different partitions
  * ========================================= */
 
@@ -888,113 +843,52 @@ static int map_objectclass_convert_operator(struct ldb_module *module, void *mem
 /* Auxiliary request construction
  * ============================== */
 
-/* Store the DN of a single search result in context. */
-static int map_search_self_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
-{
-	struct map_context *ac;
-
-	if (context == NULL || ares == NULL) {
-		ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context or Result in callback"));
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	ac = talloc_get_type(context, struct map_context);
-
-	/* We are interested only in the single reply */
-	if (ares->type != LDB_REPLY_ENTRY) {
-		talloc_free(ares);
-		return LDB_SUCCESS;
-	}
-
-	/* We have already found a remote DN */
-	if (ac->local_dn) {
-		ldb_set_errstring(ldb, talloc_asprintf(ldb, "Too many results to base search"));
-		talloc_free(ares);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	/* Store local DN */
-	ac->local_dn = ares->message->dn;
-
-	return LDB_SUCCESS;
-}
-
 /* Build a request to search a record by its DN. */
-struct ldb_request *map_search_base_req(struct map_context *ac, struct ldb_dn *dn, const char * const *attrs, const struct ldb_parse_tree *tree, void *context, ldb_search_callback callback)
+struct ldb_request *map_search_base_req(struct map_context *ac, struct ldb_dn *dn, const char * const *attrs, const struct ldb_parse_tree *tree, void *context, ldb_map_callback_t callback)
 {
+	const struct ldb_parse_tree *search_tree;
 	struct ldb_request *req;
-
-	req = talloc_zero(ac, struct ldb_request);
-	if (req == NULL) {
-		map_oom(ac->module);
-		return NULL;
-	}
-
-	req->operation = LDB_SEARCH;
-	req->op.search.base = dn;
-	req->op.search.scope = LDB_SCOPE_BASE;
-	req->op.search.attrs = attrs;
+	int ret;
 
 	if (tree) {
-		req->op.search.tree = tree;
+		search_tree = tree;
 	} else {
-		req->op.search.tree = ldb_parse_tree(req, NULL);
-		if (req->op.search.tree == NULL) {
-			talloc_free(req);
+		search_tree = ldb_parse_tree(ac, NULL);
+		if (search_tree == NULL) {
 			return NULL;
 		}
 	}
 
-	req->controls = NULL;
-	req->context = context;
-	req->callback = callback;
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, req);
-
-	return req;
-}
-
-/* Build a request to search the local record by its DN. */
-struct ldb_request *map_search_self_req(struct map_context *ac, struct ldb_dn *dn)
-{
-	/* attrs[] is returned from this function in
-	 * ac->search_req->op.search.attrs, so it must be static, as
-	 * otherwise the compiler can put it on the stack */
-	static const char * const attrs[] = { IS_MAPPED, NULL };
-	struct ldb_parse_tree *tree;
-
-	/* Limit search to records with 'IS_MAPPED' present */
-	/* TODO: `tree = ldb_parse_tree(ac, IS_MAPPED);' won't do. */
-	tree = talloc_zero(ac, struct ldb_parse_tree);
-	if (tree == NULL) {
-		map_oom(ac->module);
+	ret = ldb_build_search_req_ex(&req, ac->module->ldb, ac,
+					dn, LDB_SCOPE_BASE,
+					search_tree, attrs,
+					NULL,
+					context, callback,
+					ac->req);
+	if (ret != LDB_SUCCESS) {
 		return NULL;
 	}
 
-	tree->operation = LDB_OP_PRESENT;
-	tree->u.present.attr = talloc_strdup(tree, IS_MAPPED);
-
-	return map_search_base_req(ac, dn, attrs, tree, ac, map_search_self_callback);
+	return req;
 }
 
 /* Build a request to update the 'IS_MAPPED' attribute */
-struct ldb_request *map_build_fixup_req(struct map_context *ac, struct ldb_dn *olddn, struct ldb_dn *newdn)
+struct ldb_request *map_build_fixup_req(struct map_context *ac,
+					struct ldb_dn *olddn,
+					struct ldb_dn *newdn,
+					void *context,
+					ldb_map_callback_t callback)
 {
 	struct ldb_request *req;
 	struct ldb_message *msg;
 	const char *dn;
-
-	/* Prepare request */
-	req = talloc_zero(ac, struct ldb_request);
-	if (req == NULL) {
-		map_oom(ac->module);
-		return NULL;
-	}
+	int ret;
 
 	/* Prepare message */
-	msg = ldb_msg_new(req);
+	msg = ldb_msg_new(ac);
 	if (msg == NULL) {
 		map_oom(ac->module);
-		goto failed;
+		return NULL;
 	}
 
 	/* Update local 'IS_MAPPED' to the new remote DN */
@@ -1010,193 +904,22 @@ struct ldb_request *map_build_fixup_req(struct map_context *ac, struct ldb_dn *o
 		goto failed;
 	}
 
-	req->operation = LDB_MODIFY;
-	req->op.mod.message = msg;
-	req->controls = NULL;
-	req->handle = NULL;
-	req->context = NULL;
-	req->callback = NULL;
+	/* Prepare request */
+	ret = ldb_build_mod_req(&req, ac->module->ldb,
+				ac, msg, NULL,
+				context, callback,
+				ac->req);
+	if (ret != LDB_SUCCESS) {
+		goto failed;
+	}
+	talloc_steal(req, msg);
 
 	return req;
-
 failed:
-	talloc_free(req);
+	talloc_free(msg);
 	return NULL;
 }
 
-
-/* Asynchronous call structure
- * =========================== */
-
-/* Figure out which request is currently pending. */
-static struct ldb_request *map_get_req(struct map_context *ac)
-{
-	switch (ac->step) {
-	case MAP_SEARCH_SELF_MODIFY:
-	case MAP_SEARCH_SELF_DELETE:
-	case MAP_SEARCH_SELF_RENAME:
-		return ac->search_req;
-
-	case MAP_ADD_REMOTE:
-	case MAP_MODIFY_REMOTE:
-	case MAP_DELETE_REMOTE:
-	case MAP_RENAME_REMOTE:
-		return ac->remote_req;
-
-	case MAP_RENAME_FIXUP:
-		return ac->down_req;
-
-	case MAP_ADD_LOCAL:
-	case MAP_MODIFY_LOCAL:
-	case MAP_DELETE_LOCAL:
-	case MAP_RENAME_LOCAL:
-		return ac->local_req;
-
-	case MAP_SEARCH_REMOTE:
-		/* Can't happen */
-		break;
-	}
-
-	return NULL;		/* unreachable; silences a warning */
-}
-
-typedef int (*map_next_function)(struct ldb_handle *handle);
-
-/* Figure out the next request to run. */
-static map_next_function map_get_next(struct map_context *ac)
-{
-	switch (ac->step) {
-	case MAP_SEARCH_REMOTE:
-		return NULL;
-
-	case MAP_ADD_LOCAL:
-		return map_add_do_remote;
-	case MAP_ADD_REMOTE:
-		return NULL;
-
-	case MAP_SEARCH_SELF_MODIFY:
-		return map_modify_do_local;
-	case MAP_MODIFY_LOCAL:
-		return map_modify_do_remote;
-	case MAP_MODIFY_REMOTE:
-		return NULL;
-
-	case MAP_SEARCH_SELF_DELETE:
-		return map_delete_do_local;
-	case MAP_DELETE_LOCAL:
-		return map_delete_do_remote;
-	case MAP_DELETE_REMOTE:
-		return NULL;
-
-	case MAP_SEARCH_SELF_RENAME:
-		return map_rename_do_local;
-	case MAP_RENAME_LOCAL:
-		return map_rename_do_fixup;
-	case MAP_RENAME_FIXUP:
-		return map_rename_do_remote;
-	case MAP_RENAME_REMOTE:
-		return NULL;
-	}
-
-	return NULL;		/* unreachable; silences a warning */
-}
-
-/* Wait for the current pending request to finish and continue with the next. */
-static int map_wait_next(struct ldb_handle *handle)
-{
-	struct map_context *ac;
-	struct ldb_request *req;
-	map_next_function next;
-	int ret;
-
-	if (handle == NULL || handle->private_data == NULL) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	if (handle->state == LDB_ASYNC_DONE) {
-		return handle->status;
-	}
-
-	handle->state = LDB_ASYNC_PENDING;
-	handle->status = LDB_SUCCESS;
-
-	ac = talloc_get_type(handle->private_data, struct map_context);
-
-	if (ac->step == MAP_SEARCH_REMOTE) {
-		int i;
-		for (i = 0; i < ac->num_searches; i++) {
-			req = ac->search_reqs[i];
-			ret = ldb_wait(req->handle, LDB_WAIT_NONE);
-
-			if (ret != LDB_SUCCESS) {
-				handle->status = ret;
-				goto done;
-			}
-			if (req->handle->status != LDB_SUCCESS) {
-				handle->status = req->handle->status;
-				goto done;
-			}
-			if (req->handle->state != LDB_ASYNC_DONE) {
-				return LDB_SUCCESS;
-			}
-		}
-	} else {
-
-		req = map_get_req(ac);
-
-		ret = ldb_wait(req->handle, LDB_WAIT_NONE);
-
-		if (ret != LDB_SUCCESS) {
-			handle->status = ret;
-			goto done;
-		}
-		if (req->handle->status != LDB_SUCCESS) {
-			handle->status = req->handle->status;
-			goto done;
-		}
-		if (req->handle->state != LDB_ASYNC_DONE) {
-			return LDB_SUCCESS;
-		}
-
-		next = map_get_next(ac);
-		if (next) {
-			return next(handle);
-		}
-	}
-
-	ret = LDB_SUCCESS;
-
-done:
-	handle->state = LDB_ASYNC_DONE;
-	return ret;
-}
-
-/* Wait for all current pending requests to finish. */
-static int map_wait_all(struct ldb_handle *handle)
-{
-	int ret;
-
-	while (handle->state != LDB_ASYNC_DONE) {
-		ret = map_wait_next(handle);
-		if (ret != LDB_SUCCESS) {
-			return ret;
-		}
-	}
-
-	return handle->status;
-}
-
-/* Wait for pending requests to finish. */
-int map_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
-	if (type == LDB_WAIT_ALL) {
-		return map_wait_all(handle);
-	} else {
-		return map_wait_next(handle);
-	}
-}
-
-
 /* Module initialization
  * ===================== */
 
@@ -1256,7 +979,7 @@ static int map_init_dns(struct ldb_module *module, struct ldb_map_context *data,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = ldb_search(module->ldb, dn, LDB_SCOPE_BASE, NULL, attrs, &res);
+	ret = ldb_search(module->ldb, data, &res, dn, LDB_SCOPE_BASE, attrs, NULL);
 	talloc_free(dn);
 	if (ret != LDB_SUCCESS) {
 		return ret;
diff --git a/ldb/ldb_map/ldb_map.h b/ldb/ldb_map/ldb_map.h
index e40bb9cd..7f92c15b 100644
--- a/ldb/ldb_map/ldb_map.h
+++ b/ldb/ldb_map/ldb_map.h
@@ -160,14 +160,12 @@ int map_search(struct ldb_module *module, struct ldb_request *req);
 int map_rename(struct ldb_module *module, struct ldb_request *req);
 int map_delete(struct ldb_module *module, struct ldb_request *req);
 int map_modify(struct ldb_module *module, struct ldb_request *req);
-int map_wait(struct ldb_handle *handle, enum ldb_wait_type type);
 
 #define LDB_MAP_OPS \
 	.add		= map_add, \
 	.modify		= map_modify, \
 	.del		= map_delete, \
 	.rename		= map_rename, \
-	.search		= map_search, \
-	.wait		= map_wait,
+	.search		= map_search,
 
 #endif /* __LDB_MAP_H__ */
diff --git a/ldb/ldb_map/ldb_map_inbound.c b/ldb/ldb_map/ldb_map_inbound.c
index 7fc3ac4e..96605f23 100644
--- a/ldb/ldb_map/ldb_map_inbound.c
+++ b/ldb/ldb_map/ldb_map_inbound.c
@@ -3,6 +3,7 @@
 
    Copyright (C) Jelmer Vernooij 2005
    Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
+   Copyright (C) Simo Sorce <idra@samba.org> 2008
 
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
@@ -178,51 +179,181 @@ static int ldb_msg_partition(struct ldb_module *module, struct ldb_message *loca
 }
 
 
-/* Inbound requests: add, modify, rename, delete
- * ============================================= */
+static int map_add_do_local(struct map_context *ac);
+static int map_modify_do_local(struct map_context *ac);
+static int map_delete_do_local(struct map_context *ac);
+static int map_rename_do_local(struct map_context *ac);
+static int map_rename_do_fixup(struct map_context *ac);
+static int map_rename_local_callback(struct ldb_request *req,
+				     struct ldb_reply *ares);
 
-/* Add the remote record. */
-int map_add_do_remote(struct ldb_handle *handle)
+
+/*****************************************************************************
+ * COMMON INBOUND functions
+*****************************************************************************/
+
+/* Store the DN of a single search result in context. */
+static int map_search_self_callback(struct ldb_request *req, struct ldb_reply *ares)
 {
 	struct map_context *ac;
+	int ret;
 
-	ac = talloc_get_type(handle->private_data, struct map_context);
+	ac = talloc_get_type(req->context, struct map_context);
 
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->remote_req);
+	if (!ares) {
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
+	}
+	if (ares->error != LDB_SUCCESS) {
+		return ldb_module_done(ac->req, ares->controls,
+					ares->response, ares->error);
+	}
 
-	ac->step = MAP_ADD_REMOTE;
+	/* We are interested only in the single reply */
+	switch(ares->type) {
+	case LDB_REPLY_ENTRY:
+		/* We have already found a remote DN */
+		if (ac->local_dn) {
+			ldb_set_errstring(ac->module->ldb,
+					  "Too many results!");
+			return ldb_module_done(ac->req, NULL, NULL,
+						LDB_ERR_OPERATIONS_ERROR);
+		}
 
-	handle->state = LDB_ASYNC_INIT;
-	handle->status = LDB_SUCCESS;
+		/* Store local DN */
+		ac->local_dn = talloc_steal(ac, ares->message->dn);
+		break;
 
-	return ldb_next_remote_request(ac->module, ac->remote_req);
+	case LDB_REPLY_DONE:
+
+		switch (ac->req->operation) {
+		case LDB_MODIFY:
+			ret = map_modify_do_local(ac);
+			break;
+		case LDB_DELETE:
+			ret = map_delete_do_local(ac);
+			break;
+		case LDB_RENAME:
+			ret = map_rename_do_local(ac);
+			break;
+		default:
+			/* if we get here we have definitely a problem */
+			ret = LDB_ERR_OPERATIONS_ERROR;
+		}
+		if (ret != LDB_SUCCESS) {
+			return ldb_module_done(ac->req, NULL, NULL,
+						LDB_ERR_OPERATIONS_ERROR);
+		}
+
+	default:
+		/* ignore referrals */
+		break;
+	}
+
+	talloc_free(ares);
+	return LDB_SUCCESS;
 }
 
-/* Add the local record. */
-int map_add_do_local(struct ldb_handle *handle)
+/* Build a request to search the local record by its DN. */
+static int map_search_self_req(struct ldb_request **req,
+				struct map_context *ac,
+				struct ldb_dn *dn)
+{
+	/* attrs[] is returned from this function in
+	 * ac->search_req->op.search.attrs, so it must be static, as
+	 * otherwise the compiler can put it on the stack */
+	static const char * const attrs[] = { IS_MAPPED, NULL };
+	struct ldb_parse_tree *tree;
+
+	/* Limit search to records with 'IS_MAPPED' present */
+	tree = ldb_parse_tree(ac, "(" IS_MAPPED "=*)");
+	if (tree == NULL) {
+		map_oom(ac->module);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	*req = map_search_base_req(ac, dn, attrs, tree,
+				   ac, map_search_self_callback);
+	if (*req == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	return LDB_SUCCESS;
+}
+
+static int map_op_local_callback(struct ldb_request *req,
+				 struct ldb_reply *ares)
 {
 	struct map_context *ac;
+	int ret;
 
-	ac = talloc_get_type(handle->private_data, struct map_context);
+	ac = talloc_get_type(req->context, struct map_context);
 
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
+	if (!ares) {
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
+	}
+	if (ares->error != LDB_SUCCESS) {
+		return ldb_module_done(ac->req, ares->controls,
+					ares->response, ares->error);
+	}
 
-	ac->step = MAP_ADD_LOCAL;
+	if (ares->type != LDB_REPLY_DONE) {
+		ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
+	}
 
-	handle->state = LDB_ASYNC_INIT;
-	handle->status = LDB_SUCCESS;
+	/* Do the remote request. */
+	ret = ldb_next_remote_request(ac->module, ac->remote_req);
+	if (ret != LDB_SUCCESS) {
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
+	}
 
-	return ldb_next_request(ac->module, ac->local_req);
+	return LDB_SUCCESS;
 }
 
+static int map_op_remote_callback(struct ldb_request *req,
+				  struct ldb_reply *ares)
+{
+	struct map_context *ac;
+
+	ac = talloc_get_type(req->context, struct map_context);
+
+	if (!ares) {
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
+	}
+	if (ares->error != LDB_SUCCESS) {
+		return ldb_module_done(ac->req, ares->controls,
+					ares->response, ares->error);
+	}
+
+	if (ares->type != LDB_REPLY_DONE) {
+		ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
+	}
+
+	return ldb_module_done(ac->req, ares->controls,
+					ares->response, ares->error);
+}
+
+
+/*****************************************************************************
+ * ADD operations
+*****************************************************************************/
+
+
 /* Add a record. */
 int map_add(struct ldb_module *module, struct ldb_request *req)
 {
 	const struct ldb_message *msg = req->op.add.message;
-	struct ldb_handle *h;
 	struct map_context *ac;
-	struct ldb_message *local, *remote;
+	struct ldb_message *remote_msg;
 	const char *dn;
+	int ret;
 
 	/* Do not manipulate our control entries */
 	if (ldb_dn_is_special(msg->dn)) {
@@ -240,141 +371,88 @@ int map_add(struct ldb_module *module, struct ldb_request *req)
 	}
 
 	/* Prepare context and handle */
-	h = map_init_handle(req, module);
-	if (h == NULL) {
+	ac = map_init_context(module, req);
+	if (ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	ac = talloc_get_type(h->private_data, struct map_context);
-
-	/* Prepare the local operation */
-	ac->local_req = talloc(ac, struct ldb_request);
-	if (ac->local_req == NULL) {
-		goto oom;
-	}
 
-	*(ac->local_req) = *req;	/* copy the request */
-
-	ac->local_req->context = NULL;
-	ac->local_req->callback = NULL;
-
-	/* Prepare the remote operation */
-	ac->remote_req = talloc(ac, struct ldb_request);
-	if (ac->remote_req == NULL) {
-		goto oom;
-	}
-
-	*(ac->remote_req) = *req;	/* copy the request */
-
-	ac->remote_req->context = NULL;
-	ac->remote_req->callback = NULL;
 
 	/* Prepare the local message */
-	local = ldb_msg_new(ac->local_req);
-	if (local == NULL) {
-		goto oom;
+	ac->local_msg = ldb_msg_new(ac);
+	if (ac->local_msg == NULL) {
+		map_oom(module);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	local->dn = msg->dn;
+	ac->local_msg->dn = msg->dn;
 
 	/* Prepare the remote message */
-	remote = ldb_msg_new(ac->remote_req);
-	if (remote == NULL) {
-		goto oom;
+	remote_msg = ldb_msg_new(ac);
+	if (remote_msg == NULL) {
+		map_oom(module);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	remote->dn = ldb_dn_map_local(ac->module, remote, msg->dn);
+	remote_msg->dn = ldb_dn_map_local(ac->module, remote_msg, msg->dn);
 
 	/* Split local from remote message */
-	ldb_msg_partition(module, local, remote, msg);
-	ac->local_req->op.add.message = local;
-	ac->remote_req->op.add.message = remote;
+	ldb_msg_partition(module, ac->local_msg, remote_msg, msg);
+
+	/* Prepare the remote operation */
+	ret = ldb_build_add_req(&ac->remote_req, module->ldb,
+				ac, remote_msg,
+				req->controls,
+				ac, map_op_remote_callback,
+				req);
+	if (ret != LDB_SUCCESS) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	if ((local->num_elements == 0) || (!map_check_local_db(ac->module))) {
+	if ((ac->local_msg->num_elements == 0) ||
+	    ( ! map_check_local_db(ac->module))) {
 		/* No local data or db, just run the remote request */
-		talloc_free(ac->local_req);
-		req->handle = h;	/* return our own handle to deal with this call */
-		return map_add_do_remote(h);
+		return ldb_next_remote_request(ac->module, ac->remote_req);
 	}
 
 	/* Store remote DN in 'IS_MAPPED' */
 	/* TODO: use GUIDs here instead */
-	dn = ldb_dn_alloc_linearized(local, remote->dn);
-	if (ldb_msg_add_string(local, IS_MAPPED, dn) != 0) {
-		goto failed;
+	dn = ldb_dn_alloc_linearized(ac->local_msg, remote_msg->dn);
+	if (ldb_msg_add_string(ac->local_msg, IS_MAPPED, dn) != 0) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->handle = h;		/* return our own handle to deal with this call */
-	return map_add_do_local(h);
-
-oom:
-	map_oom(module);
-failed:
-	talloc_free(h);
-	return LDB_ERR_OPERATIONS_ERROR;
-}
-
-/* Modify the remote record. */
-int map_modify_do_remote(struct ldb_handle *handle)
-{
-	struct map_context *ac;
-
-	ac = talloc_get_type(handle->private_data, struct map_context);
-
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->remote_req);
-
-	ac->step = MAP_MODIFY_REMOTE;
-
-	handle->state = LDB_ASYNC_INIT;
-	handle->status = LDB_SUCCESS;
-
-	return ldb_next_remote_request(ac->module, ac->remote_req);
+	return map_add_do_local(ac);
 }
 
-/* Modify the local record. */
-int map_modify_do_local(struct ldb_handle *handle)
+/* Add the local record. */
+static int map_add_do_local(struct map_context *ac)
 {
-	struct map_context *ac;
-	struct ldb_message *msg;
-	char *dn;
-
-	ac = talloc_get_type(handle->private_data, struct map_context);
-
-	if (ac->local_dn == NULL) {
-		/* No local record present, add it instead */
-		msg = discard_const_p(struct ldb_message, ac->local_req->op.mod.message);
-
-		/* Add local 'IS_MAPPED' */
-		/* TODO: use GUIDs here instead */
-		if (ldb_msg_add_empty(msg, IS_MAPPED, LDB_FLAG_MOD_ADD, NULL) != 0) {
-			return LDB_ERR_OPERATIONS_ERROR;
-		}
-		dn = ldb_dn_alloc_linearized(msg, ac->remote_req->op.mod.message->dn);
-		if (ldb_msg_add_string(msg, IS_MAPPED, dn) != 0) {
-			return LDB_ERR_OPERATIONS_ERROR;
-		}
+	struct ldb_request *local_req;
+	int ret;
 
-		/* Turn request into 'add' */
-		ac->local_req->operation = LDB_ADD;
-		ac->local_req->op.add.message = msg;
-		/* TODO: Could I just leave msg in there?  I think so,
-		 *	 but it looks clearer this way. */
+	/* Prepare the local operation */
+	ret = ldb_build_add_req(&local_req, ac->module->ldb, ac,
+				ac->local_msg,
+				ac->req->controls,
+				ac,
+				map_op_local_callback,
+				ac->req);
+	if (ret != LDB_SUCCESS) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
-
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
-
-	ac->step = MAP_MODIFY_LOCAL;
-
-	handle->state = LDB_ASYNC_INIT;
-	handle->status = LDB_SUCCESS;
-
-	return ldb_next_request(ac->module, ac->local_req);
+	return ldb_next_request(ac->module, local_req);
 }
 
+/*****************************************************************************
+ * MODIFY operations
+*****************************************************************************/
+
 /* Modify a record. */
 int map_modify(struct ldb_module *module, struct ldb_request *req)
 {
 	const struct ldb_message *msg = req->op.mod.message;
-	struct ldb_handle *h;
+	struct ldb_request *search_req;
+	struct ldb_message *remote_msg;
 	struct map_context *ac;
-	struct ldb_message *local, *remote;
+	int ret;
 
 	/* Do not manipulate our control entries */
 	if (ldb_dn_is_special(msg->dn)) {
@@ -395,257 +473,200 @@ int map_modify(struct ldb_module *module, struct ldb_request *req)
 	}
 
 	/* Prepare context and handle */
-	h = map_init_handle(req, module);
-	if (h == NULL) {
+	ac = map_init_context(module, req);
+	if (ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	ac = talloc_get_type(h->private_data, struct map_context);
-
-	/* Prepare the local operation */
-	ac->local_req = talloc(ac, struct ldb_request);
-	if (ac->local_req == NULL) {
-		goto oom;
-	}
-
-	*(ac->local_req) = *req;	/* copy the request */
-
-	ac->local_req->context = NULL;
-	ac->local_req->callback = NULL;
-
-	/* Prepare the remote operation */
-	ac->remote_req = talloc(ac, struct ldb_request);
-	if (ac->remote_req == NULL) {
-		goto oom;
-	}
-
-	*(ac->remote_req) = *req;	/* copy the request */
-
-	ac->remote_req->context = NULL;
-	ac->remote_req->callback = NULL;
 
 	/* Prepare the local message */
-	local = ldb_msg_new(ac->local_req);
-	if (local == NULL) {
-		goto oom;
+	ac->local_msg = ldb_msg_new(ac);
+	if (ac->local_msg == NULL) {
+		map_oom(module);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	local->dn = msg->dn;
+	ac->local_msg->dn = msg->dn;
 
 	/* Prepare the remote message */
-	remote = ldb_msg_new(ac->remote_req);
-	if (remote == NULL) {
-		goto oom;
+	remote_msg = ldb_msg_new(ac->remote_req);
+	if (remote_msg == NULL) {
+		map_oom(module);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	remote->dn = ldb_dn_map_local(ac->module, remote, msg->dn);
+	remote_msg->dn = ldb_dn_map_local(ac->module, remote_msg, msg->dn);
 
 	/* Split local from remote message */
-	ldb_msg_partition(module, local, remote, msg);
-	ac->local_req->op.mod.message = local;
-	ac->remote_req->op.mod.message = remote;
+	ldb_msg_partition(module, ac->local_msg, remote_msg, msg);
+
+	/* Prepare the remote operation */
+	ret = ldb_build_mod_req(&ac->remote_req, module->ldb,
+				ac, remote_msg,
+				req->controls,
+				ac, map_op_remote_callback,
+				req);
+	if (ret != LDB_SUCCESS) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	if ((local->num_elements == 0) || (!map_check_local_db(ac->module))) {
+	if ((ac->local_msg->num_elements == 0) ||
+	    ( ! map_check_local_db(ac->module))) {
 		/* No local data or db, just run the remote request */
-		talloc_free(ac->local_req);
-		req->handle = h;	/* return our own handle to deal with this call */
-		return map_modify_do_remote(h);
+		return ldb_next_remote_request(ac->module, ac->remote_req);
 	}
 
 	/* prepare the search operation */
-	ac->search_req = map_search_self_req(ac, msg->dn);
-	if (ac->search_req == NULL) {
-		goto failed;
+	ret = map_search_self_req(&search_req, ac, msg->dn);
+	if (ret != LDB_SUCCESS) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ac->step = MAP_SEARCH_SELF_MODIFY;
-
-	req->handle = h;		/* return our own handle to deal with this call */
-	return ldb_next_request(module, ac->search_req);
-
-oom:
-	map_oom(module);
-failed:
-	talloc_free(h);
-	return LDB_ERR_OPERATIONS_ERROR;
-}
-
-/* Delete the remote record. */
-int map_delete_do_remote(struct ldb_handle *handle)
-{
-	struct map_context *ac;
-
-	ac = talloc_get_type(handle->private_data, struct map_context);
-
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->remote_req);
-
-	ac->step = MAP_DELETE_REMOTE;
-
-	handle->state = LDB_ASYNC_INIT;
-	handle->status = LDB_SUCCESS;
-
-	return ldb_next_remote_request(ac->module, ac->remote_req);
+	return ldb_next_request(module, search_req);
 }
 
-/* Delete the local record. */
-int map_delete_do_local(struct ldb_handle *handle)
+/* Modify the local record. */
+static int map_modify_do_local(struct map_context *ac)
 {
-	struct map_context *ac;
-
-	ac = talloc_get_type(handle->private_data, struct map_context);
+	struct ldb_request *local_req;
+	char *dn;
+	int ret;
 
-	/* No local record, continue remotely */
 	if (ac->local_dn == NULL) {
-		return map_delete_do_remote(handle);
-	}
-
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
-
-	ac->step = MAP_DELETE_LOCAL;
+		/* No local record present, add it instead */
+		/* Add local 'IS_MAPPED' */
+		/* TODO: use GUIDs here instead */
+		if (ldb_msg_add_empty(ac->local_msg, IS_MAPPED,
+					LDB_FLAG_MOD_ADD, NULL) != 0) {
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+		dn = ldb_dn_alloc_linearized(ac->local_msg,
+					ac->remote_req->op.mod.message->dn);
+		if (ldb_msg_add_string(ac->local_msg, IS_MAPPED, dn) != 0) {
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
 
-	handle->state = LDB_ASYNC_INIT;
-	handle->status = LDB_SUCCESS;
+		/* Prepare the local operation */
+		ret = ldb_build_add_req(&local_req, ac->module->ldb, ac,
+					ac->local_msg,
+					ac->req->controls,
+					ac,
+					map_op_local_callback,
+					ac->req);
+		if (ret != LDB_SUCCESS) {
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+	} else {
+		/* Prepare the local operation */
+		ret = ldb_build_mod_req(&local_req, ac->module->ldb, ac,
+					ac->local_msg,
+					ac->req->controls,
+					ac,
+					map_op_local_callback,
+					ac->req);
+		if (ret != LDB_SUCCESS) {
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+	}
 
-	return ldb_next_request(ac->module, ac->local_req);
+	return ldb_next_request(ac->module, local_req);
 }
 
+/*****************************************************************************
+ * DELETE operations
+*****************************************************************************/
+
 /* Delete a record. */
 int map_delete(struct ldb_module *module, struct ldb_request *req)
 {
-	struct ldb_handle *h;
+	struct ldb_request *search_req;
 	struct map_context *ac;
+	int ret;
 
 	/* Do not manipulate our control entries */
 	if (ldb_dn_is_special(req->op.del.dn)) {
 		return ldb_next_request(module, req);
 	}
 
-	/* No mapping requested (perhaps no DN mapping specified), skip to next module */
+	/* No mapping requested (perhaps no DN mapping specified).
+	 * Skip to next module */
 	if (!ldb_dn_check_local(module, req->op.del.dn)) {
 		return ldb_next_request(module, req);
 	}
 
 	/* Prepare context and handle */
-	h = map_init_handle(req, module);
-	if (h == NULL) {
+	ac = map_init_context(module, req);
+	if (ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	ac = talloc_get_type(h->private_data, struct map_context);
-
-	/* Prepare the local operation */
-	ac->local_req = talloc(ac, struct ldb_request);
-	if (ac->local_req == NULL) {
-		goto oom;
-	}
-
-	*(ac->local_req) = *req;	/* copy the request */
-	ac->local_req->op.del.dn = req->op.del.dn;
-
-	ac->local_req->context = NULL;
-	ac->local_req->callback = NULL;
 
 	/* Prepare the remote operation */
-	ac->remote_req = talloc(ac, struct ldb_request);
-	if (ac->remote_req == NULL) {
-		goto oom;
+	ret = ldb_build_del_req(&ac->remote_req, module->ldb, ac,
+				   ldb_dn_map_local(module, ac, req->op.del.dn),
+				   req->controls,
+				   ac,
+				   map_op_remote_callback,
+				   req);
+	if (ret != LDB_SUCCESS) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	*(ac->remote_req) = *req;	/* copy the request */
-	ac->remote_req->op.del.dn = ldb_dn_map_local(module, ac->remote_req, req->op.del.dn);
-
 	/* No local db, just run the remote request */
 	if (!map_check_local_db(ac->module)) {
-		req->handle = h;	/* return our own handle to deal with this call */
-		return map_delete_do_remote(h);
+		/* Do the remote request. */
+		return ldb_next_remote_request(ac->module, ac->remote_req);
 	}
 
-	ac->remote_req->context = NULL;
-	ac->remote_req->callback = NULL;
-
 	/* Prepare the search operation */
-	ac->search_req = map_search_self_req(ac, req->op.del.dn);
-	if (ac->search_req == NULL) {
-		goto failed;
+	ret = map_search_self_req(&search_req, ac, req->op.del.dn);
+	if (ret != LDB_SUCCESS) {
+		map_oom(module);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->handle = h;		/* return our own handle to deal with this call */
-
-	ac->step = MAP_SEARCH_SELF_DELETE;
-
-	return ldb_next_request(module, ac->search_req);
-
-oom:
-	map_oom(module);
-failed:
-	talloc_free(h);
-	return LDB_ERR_OPERATIONS_ERROR;
+	return ldb_next_request(module, search_req);
 }
 
-/* Rename the remote record. */
-int map_rename_do_remote(struct ldb_handle *handle)
-{
-	struct map_context *ac;
-
-	ac = talloc_get_type(handle->private_data, struct map_context);
-
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->remote_req);
-
-	ac->step = MAP_RENAME_REMOTE;
-
-	handle->state = LDB_ASYNC_INIT;
-	handle->status = LDB_SUCCESS;
-
-	return ldb_next_remote_request(ac->module, ac->remote_req);
-}
-
-/* Update the local 'IS_MAPPED' attribute. */
-int map_rename_do_fixup(struct ldb_handle *handle)
-{
-	struct map_context *ac;
-
-	ac = talloc_get_type(handle->private_data, struct map_context);
-
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->down_req);
-
-	ac->step = MAP_RENAME_FIXUP;
-
-	handle->state = LDB_ASYNC_INIT;
-	handle->status = LDB_SUCCESS;
-
-	return ldb_next_request(ac->module, ac->down_req);
-}
-
-/* Rename the local record. */
-int map_rename_do_local(struct ldb_handle *handle)
+/* Delete the local record. */
+static int map_delete_do_local(struct map_context *ac)
 {
-	struct map_context *ac;
-
-	ac = talloc_get_type(handle->private_data, struct map_context);
+	struct ldb_request *local_req;
+	int ret;
 
 	/* No local record, continue remotely */
 	if (ac->local_dn == NULL) {
-		return map_rename_do_remote(handle);
+		/* Do the remote request. */
+		return ldb_next_remote_request(ac->module, ac->remote_req);
 	}
 
-	ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
-
-	ac->step = MAP_RENAME_LOCAL;
-
-	handle->state = LDB_ASYNC_INIT;
-	handle->status = LDB_SUCCESS;
-
-	return ldb_next_request(ac->module, ac->local_req);
+	/* Prepare the local operation */
+	ret = ldb_build_del_req(&local_req, ac->module->ldb, ac,
+				   ac->req->op.del.dn,
+				   ac->req->controls,
+				   ac,
+				   map_op_local_callback,
+				   ac->req);
+	if (ret != LDB_SUCCESS) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	return ldb_next_request(ac->module, local_req);
 }
 
+/*****************************************************************************
+ * RENAME operations
+*****************************************************************************/
+
 /* Rename a record. */
 int map_rename(struct ldb_module *module, struct ldb_request *req)
 {
-	struct ldb_handle *h;
+	struct ldb_request *search_req;
 	struct map_context *ac;
+	int ret;
 
 	/* Do not manipulate our control entries */
 	if (ldb_dn_is_special(req->op.rename.olddn)) {
 		return ldb_next_request(module, req);
 	}
 
-	/* No mapping requested (perhaps no DN mapping specified), skip to next module */
+	/* No mapping requested (perhaps no DN mapping specified).
+	 * Skip to next module */
 	if ((!ldb_dn_check_local(module, req->op.rename.olddn)) &&
 	    (!ldb_dn_check_local(module, req->op.rename.newdn))) {
 		return ldb_next_request(module, req);
@@ -658,66 +679,113 @@ int map_rename(struct ldb_module *module, struct ldb_request *req)
 	}
 
 	/* Prepare context and handle */
-	h = map_init_handle(req, module);
-	if (h == NULL) {
+	ac = map_init_context(module, req);
+	if (ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	ac = talloc_get_type(h->private_data, struct map_context);
 
-	/* Prepare the local operation */
-	ac->local_req = talloc(ac, struct ldb_request);
-	if (ac->local_req == NULL) {
-		goto oom;
+	/* Prepare the remote operation */
+	ret = ldb_build_rename_req(&ac->remote_req, module->ldb, ac,
+				   ldb_dn_map_local(module, ac, req->op.rename.olddn),
+				   ldb_dn_map_local(module, ac, req->op.rename.newdn),
+				   req->controls,
+				   ac, map_op_remote_callback,
+				   req);
+	if (ret != LDB_SUCCESS) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	*(ac->local_req) = *req;	/* copy the request */
-	ac->local_req->op.rename.olddn = req->op.rename.olddn;
-	ac->local_req->op.rename.newdn = req->op.rename.newdn;
+	/* No local db, just run the remote request */
+	if (!map_check_local_db(ac->module)) {
+		/* Do the remote request. */
+		return ldb_next_remote_request(ac->module, ac->remote_req);
+	}
 
-	ac->local_req->context = NULL;
-	ac->local_req->callback = NULL;
+	/* Prepare the search operation */
+	ret = map_search_self_req(&search_req, ac, req->op.rename.olddn);
+	if (ret != LDB_SUCCESS) {
+		map_oom(module);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	/* Prepare the remote operation */
-	ac->remote_req = talloc(ac, struct ldb_request);
-	if (ac->remote_req == NULL) {
-		goto oom;
+	return ldb_next_request(module, search_req);
+}
+
+/* Rename the local record. */
+static int map_rename_do_local(struct map_context *ac)
+{
+	struct ldb_request *local_req;
+	int ret;
+
+	/* No local record, continue remotely */
+	if (ac->local_dn == NULL) {
+		/* Do the remote request. */
+		return ldb_next_remote_request(ac->module, ac->remote_req);
 	}
 
-	*(ac->remote_req) = *req;	/* copy the request */
-	ac->remote_req->op.rename.olddn = ldb_dn_map_local(module, ac->remote_req, req->op.rename.olddn);
-	ac->remote_req->op.rename.newdn = ldb_dn_map_local(module, ac->remote_req, req->op.rename.newdn);
+	/* Prepare the local operation */
+	ret = ldb_build_rename_req(&local_req, ac->module->ldb, ac,
+				   ac->req->op.rename.olddn,
+				   ac->req->op.rename.newdn,
+				   ac->req->controls,
+				   ac,
+				   map_rename_local_callback,
+				   ac->req);
+	if (ret != LDB_SUCCESS) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	ac->remote_req->context = NULL;
-	ac->remote_req->callback = NULL;
+	return ldb_next_request(ac->module, local_req);
+}
 
-	/* No local db, just run the remote request */
-	if (!map_check_local_db(ac->module)) {
-		req->handle = h;	/* return our own handle to deal with this call */
-		return map_rename_do_remote(h);
+static int map_rename_local_callback(struct ldb_request *req,
+				     struct ldb_reply *ares)
+{
+	struct map_context *ac;
+	int ret;
+
+	ac = talloc_get_type(req->context, struct map_context);
+
+	if (!ares) {
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
+	}
+	if (ares->error != LDB_SUCCESS) {
+		return ldb_module_done(ac->req, ares->controls,
+					ares->response, ares->error);
 	}
 
-	/* Prepare the fixup operation */
-	/* TODO: use GUIDs here instead -- or skip it when GUIDs are used. */
-	ac->down_req = map_build_fixup_req(ac, req->op.rename.newdn, ac->remote_req->op.rename.newdn);
-	if (ac->down_req == NULL) {
-		goto failed;
+	if (ares->type != LDB_REPLY_DONE) {
+		ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
 	}
 
-	/* Prepare the search operation */
-	ac->search_req = map_search_self_req(ac, req->op.rename.olddn);
-	if (ac->search_req == NULL) {
-		goto failed;
+	/* proceed with next step */
+	ret = map_rename_do_fixup(ac);
+	if (ret != LDB_SUCCESS) {
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
 	}
 
-	req->handle = h;		/* return our own handle to deal with this call */
+	return LDB_SUCCESS;
+}
 
-	ac->step = MAP_SEARCH_SELF_RENAME;
+/* Update the local 'IS_MAPPED' attribute. */
+static int map_rename_do_fixup(struct map_context *ac)
+{
+	struct ldb_request *local_req;
 
-	return ldb_next_request(module, ac->search_req);
+	/* Prepare the fixup operation */
+	/* TODO: use GUIDs here instead -- or skip it when GUIDs are used. */
+	local_req = map_build_fixup_req(ac,
+					ac->req->op.rename.newdn,
+					ac->remote_req->op.rename.newdn,
+					ac,
+					map_op_local_callback);
+	if (local_req == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-oom:
-	map_oom(module);
-failed:
-	talloc_free(h);
-	return LDB_ERR_OPERATIONS_ERROR;
+	return ldb_next_request(ac->module, local_req);
 }
diff --git a/ldb/ldb_map/ldb_map_outbound.c b/ldb/ldb_map/ldb_map_outbound.c
index fbc097f3..5f524a8b 100644
--- a/ldb/ldb_map/ldb_map_outbound.c
+++ b/ldb/ldb_map/ldb_map_outbound.c
@@ -4,6 +4,7 @@
    Copyright (C) Jelmer Vernooij 2005
    Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006
+   Copyright (C) Simo Sorce <idra@samba.org> 2008
 
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
@@ -905,7 +906,11 @@ static int map_subtree_collect_remote(struct ldb_module *module, void *mem_ctx,
 
 /* Split subtrees that query attributes in the local partition from
  * those that query the remote partition. */
-static int ldb_parse_tree_partition(struct ldb_module *module, void *local_ctx, void *remote_ctx, struct ldb_parse_tree **local_tree, struct ldb_parse_tree **remote_tree, const struct ldb_parse_tree *tree)
+static int ldb_parse_tree_partition(struct ldb_module *module,
+					void *mem_ctx,
+					struct ldb_parse_tree **local_tree,
+					struct ldb_parse_tree **remote_tree,
+					const struct ldb_parse_tree *tree)
 {
 	int ret;
 
@@ -918,13 +923,13 @@ static int ldb_parse_tree_partition(struct ldb_module *module, void *local_ctx,
 	}
 
 	/* Generate local tree */
-	ret = map_subtree_select_local(module, local_ctx, local_tree, tree);
+	ret = map_subtree_select_local(module, mem_ctx, local_tree, tree);
 	if (ret) {
 		return ret;
 	}
 
 	/* Generate remote tree */
-	ret = map_subtree_collect_remote(module, remote_ctx, remote_tree, tree);
+	ret = map_subtree_collect_remote(module, mem_ctx, remote_tree, tree);
 	if (ret) {
 		talloc_free(*local_tree);
 		return ret;
@@ -1008,24 +1013,46 @@ oom:
 /* Outbound requests: search
  * ========================= */
 
-/* Pass a merged search result up the callback chain. */
-int map_up_callback(struct ldb_context *ldb, const struct ldb_request *req, struct ldb_reply *ares)
+static int map_remote_search_callback(struct ldb_request *req,
+					struct ldb_reply *ares);
+static int map_local_merge_callback(struct ldb_request *req,
+					struct ldb_reply *ares);
+static int map_search_local(struct map_context *ac);
+
+static int map_save_entry(struct map_context *ac, struct ldb_reply *ares)
 {
-	int i;
+	struct map_reply *mr;
 
-	/* No callback registered, stop */
-	if (req->callback == NULL) {
-		return LDB_SUCCESS;
+	mr = talloc_zero(ac, struct map_reply);
+	if (mr == NULL) {
+		map_oom(ac->module);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
-
-	/* Only records need special treatment */
-	if (ares->type != LDB_REPLY_ENTRY) {
-		return req->callback(ldb, req->context, ares);
+	mr->remote = talloc_steal(mr, ares);
+	if (ac->r_current) {
+		ac->r_current->next = mr;
+	} else {
+		/* first entry */
+		ac->r_list = mr;
 	}
+	ac->r_current = mr;
+
+	return LDB_SUCCESS;
+}
+
+/* Pass a merged search result up the callback chain. */
+int map_return_entry(struct map_context *ac, struct ldb_reply *ares)
+{
+	struct ldb_message_element *el;
+	const char * const *attrs;
+	int i;
 
 	/* Merged result doesn't match original query, skip */
-	if (!ldb_match_msg(ldb, ares->message, req->op.search.tree, req->op.search.base, req->op.search.scope)) {
-		ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_map: "
+	if (!ldb_match_msg(ac->module->ldb, ares->message,
+			   ac->req->op.search.tree,
+			   ac->req->op.search.base,
+			   ac->req->op.search.scope)) {
+		ldb_debug(ac->module->ldb, LDB_DEBUG_TRACE, "ldb_map: "
 			  "Skipping record '%s': "
 			  "doesn't match original search\n",
 			  ldb_dn_get_linearized(ares->message->dn));
@@ -1033,10 +1060,16 @@ int map_up_callback(struct ldb_context *ldb, const struct ldb_request *req, stru
 	}
 
 	/* Limit result to requested attrs */
-	if ((req->op.search.attrs) && (!ldb_attr_in_list(req->op.search.attrs, "*"))) {
-		for (i = 0; i < ares->message->num_elements; ) {
-			struct ldb_message_element *el = &ares->message->elements[i];
-			if (!ldb_attr_in_list(req->op.search.attrs, el->name)) {
+	if (ac->req->op.search.attrs &&
+	    (! ldb_attr_in_list(ac->req->op.search.attrs, "*"))) {
+
+		attrs = ac->req->op.search.attrs;
+		i = 0;
+
+		while (i < ares->message->num_elements) {
+
+			el = &ares->message->elements[i];
+			if ( ! ldb_attr_in_list(attrs, el->name)) {
 				ldb_msg_remove_element(ares->message, el);
 			} else {
 				i++;
@@ -1044,129 +1077,16 @@ int map_up_callback(struct ldb_context *ldb, const struct ldb_request *req, stru
 		}
 	}
 
-	return req->callback(ldb, req->context, ares);
-}
-
-/* Merge the remote and local parts of a search result. */
-int map_local_merge_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
-{
-	struct map_search_context *sc;
-	int ret;
-
-	if (context == NULL || ares == NULL) {
-		ldb_set_errstring(ldb, talloc_asprintf(ldb, "ldb_map: "
-						       "NULL Context or Result in `map_local_merge_callback`"));
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	sc = talloc_get_type(context, struct map_search_context);
-
-	switch (ares->type) {
-	case LDB_REPLY_ENTRY:
-		/* We have already found a local record */
-		if (sc->local_res) {
-			ldb_set_errstring(ldb, talloc_asprintf(ldb, "ldb_map: "
-							       "Too many results to base search for local entry"));
-			talloc_free(ares);
-			return LDB_ERR_OPERATIONS_ERROR;
-		}
-
-		/* Store local result */
-		sc->local_res = ares;
-
-		/* Merge remote into local message */
-		ret = ldb_msg_merge_local(sc->ac->module, ares->message, sc->remote_res->message);
-		if (ret) {
-			talloc_free(ares);
-			return LDB_ERR_OPERATIONS_ERROR;
-		}
-
-		return map_up_callback(ldb, sc->ac->orig_req, ares);
-
-	case LDB_REPLY_DONE:
-		/* No local record found, continue with remote record */
-		if (sc->local_res == NULL) {
-			return map_up_callback(ldb, sc->ac->orig_req, sc->remote_res);
-		}
-		return LDB_SUCCESS;
-
-	default:
-		ldb_set_errstring(ldb, talloc_asprintf(ldb, "ldb_map: "
-						       "Unexpected result type in base search for local entry"));
-		talloc_free(ares);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-}
-
-/* Search the local part of a remote search result. */
-int map_remote_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
-{
-	struct map_context *ac;
-	struct map_search_context *sc;
-	struct ldb_request *req;
-	int ret;
-
-	if (context == NULL || ares == NULL) {
-		ldb_set_errstring(ldb, talloc_asprintf(ldb, "ldb_map: "
-						       "NULL Context or Result in `map_remote_search_callback`"));
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	ac = talloc_get_type(context, struct map_context);
-
-	/* It's not a record, stop searching */
-	if (ares->type != LDB_REPLY_ENTRY) {
-		return map_up_callback(ldb, ac->orig_req, ares);
-	}
-
-	/* Map result record into a local message */
-	ret = map_reply_remote(ac, ares);
-	if (ret) {
-		talloc_free(ares);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	/* There is no local db, stop searching */
-	if (!map_check_local_db(ac->module)) {
-		return map_up_callback(ldb, ac->orig_req, ares);
-	}
-
-	/* Prepare local search context */
-	sc = map_init_search_context(ac, ares);
-	if (sc == NULL) {
-		talloc_free(ares);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	/* Prepare local search request */
-	/* TODO: use GUIDs here instead? */
-
-	ac->search_reqs = talloc_realloc(ac, ac->search_reqs, struct ldb_request *, ac->num_searches + 2);
-	if (ac->search_reqs == NULL) {
-		talloc_free(ares);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	ac->search_reqs[ac->num_searches]
-		= req = map_search_base_req(ac, ares->message->dn, 
-					    NULL, NULL, sc, map_local_merge_callback);
-	if (req == NULL) {
-		talloc_free(sc);
-		talloc_free(ares);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-	ac->num_searches++;
-	ac->search_reqs[ac->num_searches] = NULL;
-
-	return ldb_next_request(ac->module, req);
+	return ldb_module_send_entry(ac->req, ares->message);
 }
 
 /* Search a record. */
 int map_search(struct ldb_module *module, struct ldb_request *req)
 {
-	struct ldb_handle *h;
+	struct ldb_parse_tree *remote_tree;
+	struct ldb_parse_tree *local_tree;
+	struct ldb_request *remote_req;
 	struct map_context *ac;
-	struct ldb_parse_tree *local_tree, *remote_tree;
 	int ret;
 
 	const char *wildcard[] = { "*", NULL };
@@ -1176,8 +1096,9 @@ int map_search(struct ldb_module *module, struct ldb_request *req)
 		return ldb_next_request(module, req);
 
 	/* Do not manipulate our control entries */
-	if (ldb_dn_is_special(req->op.search.base))
+	if (ldb_dn_is_special(req->op.search.base)) {
 		return ldb_next_request(module, req);
+	}
 
 	/* No mapping requested, skip to next module */
 	if ((req->op.search.base) && (!ldb_dn_check_local(module, req->op.search.base))) {
@@ -1188,32 +1109,10 @@ int map_search(struct ldb_module *module, struct ldb_request *req)
 	 *	 targetting when there is no search base? */
 
 	/* Prepare context and handle */
-	h = map_init_handle(req, module);
-	if (h == NULL) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-	ac = talloc_get_type(h->private_data, struct map_context);
-
-	ac->search_reqs = talloc_array(ac, struct ldb_request *, 2);
-	if (ac->search_reqs == NULL) {
-		talloc_free(h);
+	ac = map_init_context(module, req);
+	if (ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	ac->num_searches = 1;
-	ac->search_reqs[1] = NULL;
-
-	/* Prepare the remote operation */
-	ac->search_reqs[0] = talloc(ac, struct ldb_request);
-	if (ac->search_reqs[0] == NULL) {
-		goto oom;
-	}
-
-	*(ac->search_reqs[0]) = *req;	/* copy the request */
-
-	ac->search_reqs[0]->handle = h;	/* return our own handle to deal with this call */
-
-	ac->search_reqs[0]->context = ac;
-	ac->search_reqs[0]->callback = map_remote_search_callback;
 
 	/* It is easier to deal with the two different ways of
 	 * expressing the wildcard in the same codepath */
@@ -1226,17 +1125,15 @@ int map_search(struct ldb_module *module, struct ldb_request *req)
 	ret = map_attrs_collect_and_partition(module, ac, 
 					      attrs, req->op.search.tree);
 	if (ret) {
-		goto failed;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ac->search_reqs[0]->op.search.attrs = ac->remote_attrs;
-
 	/* Split local from remote tree */
-	ret = ldb_parse_tree_partition(module, ac, ac->search_reqs[0], 
-				       &local_tree, &remote_tree, 
+	ret = ldb_parse_tree_partition(module, ac,
+				       &local_tree, &remote_tree,
 				       req->op.search.tree);
 	if (ret) {
-		goto failed;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	if (((local_tree != NULL) && (remote_tree != NULL)) &&
@@ -1251,7 +1148,7 @@ int map_search(struct ldb_module *module, struct ldb_request *req)
 		local_tree = talloc_zero(ac, struct ldb_parse_tree);
 		if (local_tree == NULL) {
 			map_oom(ac->module);
-			goto failed;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
 		local_tree->operation = LDB_OP_PRESENT;
@@ -1259,31 +1156,209 @@ int map_search(struct ldb_module *module, struct ldb_request *req)
 	}
 	if (remote_tree == NULL) {
 		/* Construct default remote parse tree */
-		remote_tree = ldb_parse_tree(ac->search_reqs[0], NULL);
+		remote_tree = ldb_parse_tree(ac, NULL);
 		if (remote_tree == NULL) {
-			goto failed;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 	}
 
 	ac->local_tree = local_tree;
-	ac->search_reqs[0]->op.search.tree = remote_tree;
 
-	ldb_set_timeout_from_prev_req(module->ldb, req, ac->search_reqs[0]);
+	/* Prepare the remote operation */
+	ret = ldb_build_search_req_ex(&remote_req, module->ldb, ac,
+				      req->op.search.base,
+				      req->op.search.scope,
+				      remote_tree,
+				      ac->remote_attrs,
+				      req->controls,
+				      ac, map_remote_search_callback,
+				      req);
+	if (ret != LDB_SUCCESS) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	h->state = LDB_ASYNC_INIT;
-	h->status = LDB_SUCCESS;
+	return ldb_next_remote_request(module, remote_req);
+}
+
+/* Now, search the local part of a remote search result. */
+static int map_remote_search_callback(struct ldb_request *req,
+					struct ldb_reply *ares)
+{
+	struct map_context *ac;
+	int ret;
 
-	ac->step = MAP_SEARCH_REMOTE;
+	ac = talloc_get_type(req->context, struct map_context);
 
-	ret = ldb_next_remote_request(module, ac->search_reqs[0]);
-	if (ret == LDB_SUCCESS) {
-		req->handle = h;
+	if (!ares) {
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
+	}
+	if (ares->error != LDB_SUCCESS) {
+		return ldb_module_done(ac->req, ares->controls,
+					ares->response, ares->error);
 	}
-	return ret;
 
-oom:
-	map_oom(module);
-failed:
-	talloc_free(h);
-	return LDB_ERR_OPERATIONS_ERROR;
+	switch (ares->type) {
+	case LDB_REPLY_REFERRAL:
+
+		/* ignore referrals */
+		talloc_free(ares);
+		return LDB_SUCCESS;
+
+	case LDB_REPLY_ENTRY:
+
+		/* Map result record into a local message */
+		ret = map_reply_remote(ac, ares);
+		if (ret) {
+			talloc_free(ares);
+			return ldb_module_done(ac->req, NULL, NULL,
+						LDB_ERR_OPERATIONS_ERROR);
+		}
+
+		/* if we have no local db, then we can just return the reply to
+		 * the upper layer, otherwise we must save it and process it
+		 * when all replies ahve been gathered */
+		if ( ! map_check_local_db(ac->module)) {
+			ret = map_return_entry(ac, ares);
+		} else {
+			ret = map_save_entry(ac,ares);
+		}
+
+		if (ret != LDB_SUCCESS) {
+			talloc_free(ares);
+			return ldb_module_done(ac->req, NULL, NULL,
+						LDB_ERR_OPERATIONS_ERROR);
+		}
+		break;
+
+	case LDB_REPLY_DONE:
+
+		if ( ! map_check_local_db(ac->module)) {
+			return ldb_module_done(ac->req, ares->controls,
+						ares->response, LDB_SUCCESS);
+		}
+
+		talloc_free(ares);
+
+		/* reset the pointer to the start of the list */
+		ac->r_current = ac->r_list;
+
+		/* no entry just return */
+		if (ac->r_current == NULL) {
+			return ldb_module_done(ac->req, ares->controls,
+						ares->response, LDB_SUCCESS);
+		}
+
+		ret = map_search_local(ac);
+		if (ret != LDB_SUCCESS) {
+			return ldb_module_done(ac->req, NULL, NULL, ret);
+		}
+	}
+
+	return LDB_SUCCESS;
+}
+
+static int map_search_local(struct map_context *ac)
+{
+	struct ldb_request *search_req;
+
+	if (ac->r_current == NULL || ac->r_current->remote == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	/* Prepare local search request */
+	/* TODO: use GUIDs here instead? */
+	search_req = map_search_base_req(ac,
+					 ac->r_current->remote->message->dn,
+					 NULL, NULL,
+					 ac, map_local_merge_callback);
+	if (search_req == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	return ldb_next_request(ac->module, search_req);
+}
+
+/* Merge the remote and local parts of a search result. */
+int map_local_merge_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+	struct map_context *ac;
+	int ret;
+
+	ac = talloc_get_type(req->context, struct map_context);
+
+	if (!ares) {
+		return ldb_module_done(ac->req, NULL, NULL,
+					LDB_ERR_OPERATIONS_ERROR);
+	}
+	if (ares->error != LDB_SUCCESS) {
+		return ldb_module_done(ac->req, ares->controls,
+					ares->response, ares->error);
+	}
+
+	switch (ares->type) {
+	case LDB_REPLY_ENTRY:
+		/* We have already found a local record */
+		if (ac->r_current->local) {
+			talloc_free(ares);
+			ldb_set_errstring(ac->module->ldb, "ldb_map: Too many results!");
+			return ldb_module_done(ac->req, NULL, NULL,
+						LDB_ERR_OPERATIONS_ERROR);
+		}
+
+		/* Store local result */
+		ac->r_current->local = talloc_steal(ac->r_current, ares);
+
+		break;
+
+	case LDB_REPLY_REFERRAL:
+		/* ignore referrals */
+		talloc_free(ares);
+		break;
+
+	case LDB_REPLY_DONE:
+		talloc_free(ares);
+
+		/* No local record found, map and send remote record */
+		if (ac->r_current->local != NULL) {
+			/* Merge remote into local message */
+			ret = ldb_msg_merge_local(ac->module,
+						  ac->r_current->local->message,
+						  ac->r_current->remote->message);
+			if (ret == LDB_SUCCESS) {
+				ret = map_return_entry(ac, ac->r_current->local);
+			}
+			if (ret != LDB_SUCCESS) {
+				return ldb_module_done(ac->req, NULL, NULL,
+							LDB_ERR_OPERATIONS_ERROR);
+			}
+		} else {
+			ret = map_return_entry(ac, ac->r_current->remote);
+			if (ret != LDB_SUCCESS) {
+				return ldb_module_done(ac->req,
+							NULL, NULL, ret);
+			}
+		}
+
+		if (ac->r_current->next != NULL) {
+			ac->r_current = ac->r_current->next;
+			if (ac->r_current->remote->type == LDB_REPLY_ENTRY) {
+				ret = map_search_local(ac);
+				if (ret != LDB_SUCCESS) {
+					return ldb_module_done(ac->req,
+							       NULL, NULL, ret);
+				}
+				break;
+			}
+		}
+
+		/* ok we are done with all search, finally it is time to
+		 * finish operations for this module */
+		return ldb_module_done(ac->req,
+					ac->r_current->remote->controls,
+					ac->r_current->remote->response,
+					ac->r_current->remote->error);
+	}
+
+	return LDB_SUCCESS;
 }
diff --git a/ldb/ldb_map/ldb_map_private.h b/ldb/ldb_map/ldb_map_private.h
index 58a9f270..55221253 100644
--- a/ldb/ldb_map/ldb_map_private.h
+++ b/ldb/ldb_map/ldb_map_private.h
@@ -3,7 +3,7 @@
 #define map_oom(module) ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
 
 /* The type of search callback functions */
-typedef int (*ldb_search_callback)(struct ldb_context *, void *, struct ldb_reply *);
+typedef int (*ldb_map_callback_t)(struct ldb_request *, struct ldb_reply *);
 
 /* The special DN from which the local and remote base DNs are fetched */
 #define MAP_DN_NAME	"@MAP"
@@ -13,25 +13,17 @@ typedef int (*ldb_search_callback)(struct ldb_context *, void *, struct ldb_repl
 /* Private data structures
  * ======================= */
 
+struct map_reply {
+	struct map_reply *next;
+	struct ldb_reply *remote;
+	struct ldb_reply *local;
+};
+
 /* Context data for mapped requests */
 struct map_context {
-	enum map_step {
-		MAP_SEARCH_REMOTE,
-		MAP_ADD_REMOTE,
-		MAP_ADD_LOCAL,
-		MAP_SEARCH_SELF_MODIFY,
-		MAP_MODIFY_REMOTE,
-		MAP_MODIFY_LOCAL,
-		MAP_SEARCH_SELF_DELETE,
-		MAP_DELETE_REMOTE,
-		MAP_DELETE_LOCAL,
-		MAP_SEARCH_SELF_RENAME,
-		MAP_RENAME_REMOTE,
-		MAP_RENAME_FIXUP,
-		MAP_RENAME_LOCAL
-	} step;
 
 	struct ldb_module *module;
+	struct ldb_request *req;
 
 	struct ldb_dn *local_dn;
 	const struct ldb_parse_tree *local_tree;
@@ -39,32 +31,20 @@ struct map_context {
 	const char * const *remote_attrs;
 	const char * const *all_attrs;
 
-	struct ldb_request *orig_req;
-	struct ldb_request *local_req;
+	struct ldb_message *local_msg;
 	struct ldb_request *remote_req;
-	struct ldb_request *down_req;
-	struct ldb_request *search_req;
-
-	/* for search, we may have a lot of contexts */
-	int num_searches;
-	struct ldb_request **search_reqs;
-};
 
-/* Context data for mapped search requests */
-struct map_search_context {
-	struct map_context *ac;
-	struct ldb_reply *local_res;
-	struct ldb_reply *remote_res;
+	struct map_reply *r_list;
+	struct map_reply *r_current;
 };
 
-
 /* Common operations
  * ================= */
 
 /* The following definitions come from lib/ldb/modules/ldb_map.c */
 const struct ldb_map_context *map_get_context(struct ldb_module *module);
-struct map_search_context *map_init_search_context(struct map_context *ac, struct ldb_reply *ares);
-struct ldb_handle *map_init_handle(struct ldb_request *req, struct ldb_module *module);
+struct map_context *map_init_context(struct ldb_module *module,
+					struct ldb_request *req);
 
 int ldb_next_remote_request(struct ldb_module *module, struct ldb_request *request);
 
@@ -86,25 +66,23 @@ struct ldb_dn *ldb_dn_map_local(struct ldb_module *module, void *mem_ctx, struct
 struct ldb_dn *ldb_dn_map_remote(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn);
 struct ldb_dn *ldb_dn_map_rebase_remote(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn);
 
-struct ldb_request *map_search_base_req(struct map_context *ac, struct ldb_dn *dn, const char * const *attrs, const struct ldb_parse_tree *tree, void *context, ldb_search_callback callback);
-struct ldb_request *map_search_self_req(struct map_context *ac, struct ldb_dn *dn);
-struct ldb_request *map_build_fixup_req(struct map_context *ac, struct ldb_dn *olddn, struct ldb_dn *newdn);
-
-int map_subtree_collect_remote_simple(struct ldb_module *module, void *mem_ctx, struct ldb_parse_tree **new, const struct ldb_parse_tree *tree, const struct ldb_map_attribute *map);
-
-/* LDB Requests
- * ============ */
-
-/* The following definitions come from lib/ldb/modules/ldb_map_inbound.c */
-int map_add_do_remote(struct ldb_handle *handle);
-int map_add_do_local(struct ldb_handle *handle);
-
-int map_modify_do_remote(struct ldb_handle *handle);
-int map_modify_do_local(struct ldb_handle *handle);
-
-int map_delete_do_remote(struct ldb_handle *handle);
-int map_delete_do_local(struct ldb_handle *handle);
-
-int map_rename_do_remote(struct ldb_handle *handle);
-int map_rename_do_fixup(struct ldb_handle *handle);
-int map_rename_do_local(struct ldb_handle *handle);
+struct ldb_request *map_search_base_req(struct map_context *ac,
+					struct ldb_dn *dn,
+					const char * const *attrs,
+					const struct ldb_parse_tree *tree,
+					void *context,
+					ldb_map_callback_t callback);
+struct ldb_request *map_build_fixup_req(struct map_context *ac,
+					struct ldb_dn *olddn,
+					struct ldb_dn *newdn,
+					void *context,
+					ldb_map_callback_t callback);
+int map_subtree_collect_remote_simple(struct ldb_module *module, void *mem_ctx,
+					struct ldb_parse_tree **new,
+					const struct ldb_parse_tree *tree,
+					const struct ldb_map_attribute *map);
+int map_return_fatal_error(struct ldb_request *req,
+			   struct ldb_reply *ares);
+int map_return_normal_error(struct ldb_request *req,
+			    struct ldb_reply *ares,
+			    int error);