summaryrefslogtreecommitdiff
path: root/ldb/ldb_map/ldb_map_inbound.c
diff options
context:
space:
mode:
Diffstat (limited to 'ldb/ldb_map/ldb_map_inbound.c')
-rw-r--r--ldb/ldb_map/ldb_map_inbound.c754
1 files changed, 411 insertions, 343 deletions
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);
}