Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006-2007
Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
- ** NOTE! The following LGPL license applies to the ldb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Author: Andrew Bartlett
*/
-#include "ldb_includes.h"
+#include "ldb_module.h"
+
+struct subren_msg_store {
+ struct subren_msg_store *next;
+ struct ldb_dn *olddn;
+ struct ldb_dn *newdn;
+};
struct subtree_rename_context {
struct ldb_module *module;
- struct ldb_handle *handle;
- struct ldb_request *orig_req;
+ struct ldb_request *req;
- struct ldb_request **down_req;
- int num_requests;
- int finished_requests;
+ struct subren_msg_store *list;
+ struct subren_msg_store *current;
};
-static struct subtree_rename_context *subtree_rename_init_handle(struct ldb_request *req,
- struct ldb_module *module)
+static struct subtree_rename_context *subren_ctx_init(struct ldb_module *module,
+ struct ldb_request *req)
{
+ struct ldb_context *ldb;
struct subtree_rename_context *ac;
- struct ldb_handle *h;
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
+ ldb = ldb_module_get_ctx(module);
- h->module = module;
-
- ac = talloc_zero(h, struct subtree_rename_context);
+ ac = talloc_zero(req, struct subtree_rename_context);
if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
+ ldb_oom(ldb);
return NULL;
}
- h->private_data = ac;
-
ac->module = module;
- ac->handle = h;
- ac->orig_req = req;
-
- req->handle = h;
+ ac->req = req;
return ac;
}
+static int subtree_rename_next_request(struct subtree_rename_context *ac);
-static int subtree_rename_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int subtree_rename_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
- struct ldb_request *req;
- struct subtree_rename_context *ac = talloc_get_type(context, struct subtree_rename_context);
- TALLOC_CTX *mem_ctx = talloc_new(ac);
-
- if (!mem_ctx) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- /* OK, we have one of *many* search results here:
-
- We should also get the entry we tried to rename. This
- callback handles this and everything below it.
- */
-
- /* Only entries are interesting, and we handle the case of the parent seperatly */
- if (ares->type == LDB_REPLY_ENTRY
- && ldb_dn_compare(ares->message->dn, ac->orig_req->op.rename.olddn) != 0) {
- /* And it is an actual entry: now create a rename from it */
- int ret;
-
- struct ldb_dn *newdn = ldb_dn_copy(mem_ctx, ares->message->dn);
- if (!newdn) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ldb_dn_remove_base_components(newdn, ldb_dn_get_comp_num(ac->orig_req->op.rename.olddn));
+ struct ldb_context *ldb;
+ struct subtree_rename_context *ac;
+ int ret;
- if (!ldb_dn_add_base(newdn, ac->orig_req->op.rename.newdn)) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ ac = talloc_get_type(req->context, struct subtree_rename_context);
+ ldb = ldb_module_get_ctx(ac->module);
- ret = ldb_build_rename_req(&req, ldb, mem_ctx,
- ares->message->dn,
- newdn,
- NULL,
- NULL,
- NULL);
-
- if (ret != LDB_SUCCESS) return ret;
-
- talloc_steal(req, newdn);
-
- talloc_steal(req, ares->message->dn);
-
- talloc_free(ares);
-
- } else if (ares->type == LDB_REPLY_DONE) {
- req = talloc(mem_ctx, struct ldb_request);
- *req = *ac->orig_req;
- talloc_free(ares);
-
- } else {
- talloc_free(ares);
- return LDB_SUCCESS;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-
- ac->down_req = talloc_realloc(ac, ac->down_req,
- struct ldb_request *, ac->num_requests + 1);
- if (!ac->down_req) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac->down_req[ac->num_requests] = req;
- ac->num_requests++;
-
- return ldb_next_request(ac->module, req);
-
-}
-/* rename */
-static int subtree_rename(struct ldb_module *module, struct ldb_request *req)
-{
- const char *attrs[] = { NULL };
- struct ldb_request *new_req;
- struct subtree_rename_context *ac;
- int ret;
- struct ldb_search_options_control *search_options;
- if (ldb_dn_is_special(req->op.rename.olddn)) { /* do not manipulate our control entries */
- return ldb_next_request(module, req);
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- /* This gets complex: We need to:
- - Do a search for all entires under this entry
- - Wait for these results to appear
- - In the callback for each result, issue a modify request
- - That will include this rename, we hope
- - Wait for each modify result
- - Regain our sainity
- */
-
- ac = subtree_rename_init_handle(req, module);
- if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ldb, "Invalid reply type!\n");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- ret = ldb_build_search_req(&new_req, module->ldb, req,
- req->op.rename.olddn,
- LDB_SCOPE_SUBTREE,
- "(objectClass=*)",
- attrs,
- req->controls,
- ac,
- subtree_rename_search_callback);
+ if (ac->current == NULL) {
+ /* this was the last one */
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+ }
+ ret = subtree_rename_next_request(ac);
if (ret != LDB_SUCCESS) {
- return ret;
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- /* We want to find any partitions under this entry. That way,
- * if we try and rename a whole partition, the partitions
- * module should cause us to fail the lot */
- search_options = talloc(ac, struct ldb_search_options_control);
- if (!search_options) {
- ldb_oom(ac->module->ldb);
+ talloc_free(ares);
+ return LDB_SUCCESS;
+}
+
+static int subtree_rename_next_request(struct subtree_rename_context *ac)
+{
+ struct ldb_context *ldb;
+ struct ldb_request *req;
+ int ret;
+
+ ldb = ldb_module_get_ctx(ac->module);
+
+ if (ac->current == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- search_options->search_options = LDB_SEARCH_OPTION_PHANTOM_ROOT;
- ret = ldb_request_add_control(new_req, LDB_CONTROL_SEARCH_OPTIONS_OID, false, search_options);
+ ret = ldb_build_rename_req(&req, ldb, ac->current,
+ ac->current->olddn,
+ ac->current->newdn,
+ ac->req->controls,
+ ac, subtree_rename_callback,
+ ac->req);
if (ret != LDB_SUCCESS) {
return ret;
}
- ac->down_req = talloc_realloc(ac, ac->down_req,
- struct ldb_request *, ac->num_requests + 1);
- if (!ac->down_req) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac->down_req[ac->num_requests] = new_req;
- if (req == NULL) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac->num_requests++;
- return ldb_next_request(module, new_req);
+ ac->current = ac->current->next;
+
+ return ldb_next_request(ac->module, req);
}
-static int subtree_rename_wait_none(struct ldb_handle *handle) {
+static int subtree_rename_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct subren_msg_store *store;
struct subtree_rename_context *ac;
- int i, ret;
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ int ret;
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
+ ac = talloc_get_type(req->context, struct subtree_rename_context);
+
+ if (!ares || !ac->current) {
+ 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);
}
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
- ac = talloc_get_type(handle->private_data, struct subtree_rename_context);
+ if (ldb_dn_compare(ares->message->dn, ac->list->olddn) == 0) {
+ /* this was already stored by the
+ * subtree_rename_search() */
+ talloc_free(ares);
+ return LDB_SUCCESS;
+ }
- for (i=0; i < ac->num_requests; i++) {
- ret = ldb_wait(ac->down_req[i]->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
+ store = talloc_zero(ac, struct subren_msg_store);
+ if (store == NULL) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- if (ac->down_req[i]->handle->status != LDB_SUCCESS) {
- handle->status = ac->down_req[i]->handle->status;
- goto done;
+ ac->current->next = store;
+ ac->current = store;
+
+ /* the first list element contains the base for the rename */
+ store->olddn = talloc_steal(store, ares->message->dn);
+ store->newdn = ldb_dn_copy(store, store->olddn);
+
+ if ( ! ldb_dn_remove_base_components(store->newdn,
+ ldb_dn_get_comp_num(ac->list->olddn))) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-
- if (ac->down_req[i]->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
+
+ if ( ! ldb_dn_add_base(store->newdn, ac->list->newdn)) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- }
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
+ break;
-}
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ break;
-static int subtree_rename_wait_all(struct ldb_handle *handle) {
+ case LDB_REPLY_DONE:
- int ret;
+ /* rewind ac->current */
+ ac->current = ac->list;
+
+ /* All dns set up, start with the first one */
+ ret = subtree_rename_next_request(ac);
- while (handle->state != LDB_ASYNC_DONE) {
- ret = subtree_rename_wait_none(handle);
if (ret != LDB_SUCCESS) {
- return ret;
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
+ break;
}
- return handle->status;
+ talloc_free(ares);
+ return LDB_SUCCESS;
}
-static int subtree_rename_wait(struct ldb_handle *handle, enum ldb_wait_type type)
+/* rename */
+static int subtree_rename(struct ldb_module *module, struct ldb_request *req)
{
- if (type == LDB_WAIT_ALL) {
- return subtree_rename_wait_all(handle);
- } else {
- return subtree_rename_wait_none(handle);
+ struct ldb_context *ldb;
+ static const char *attrs[2] = { "distinguishedName", NULL };
+ struct ldb_request *search_req;
+ struct subtree_rename_context *ac;
+ int ret;
+ if (ldb_dn_is_special(req->op.rename.olddn)) { /* do not manipulate our control entries */
+ return ldb_next_request(module, req);
+ }
+
+ ldb = ldb_module_get_ctx(module);
+
+ /* This gets complex: We need to:
+ - Do a search for all entires under this entry
+ - Wait for these results to appear
+ - In the callback for each result, issue a modify request
+ - That will include this rename, we hope
+ - Wait for each modify result
+ - Regain our sainity
+ */
+
+ ac = subren_ctx_init(module, req);
+ if (!ac) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ /* add this entry as the first to do */
+ ac->current = talloc_zero(ac, struct subren_msg_store);
+ if (ac->current == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ac->current->olddn = req->op.rename.olddn;
+ ac->current->newdn = req->op.rename.newdn;
+ ac->list = ac->current;
+
+ ret = ldb_build_search_req(&search_req, ldb, ac,
+ req->op.rename.olddn,
+ LDB_SCOPE_SUBTREE,
+ "(objectClass=*)",
+ attrs,
+ NULL,
+ ac,
+ subtree_rename_search_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
+
+ return ldb_next_request(module, search_req);
}
-static const struct ldb_module_ops subtree_rename_ops = {
+const struct ldb_module_ops ldb_subtree_rename_module_ops = {
.name = "subtree_rename",
.rename = subtree_rename,
- .wait = subtree_rename_wait,
};
-
-int ldb_subtree_rename_init(void)
-{
- return ldb_register_module(&subtree_rename_ops);
-}
git.samba.org / metze / samba / wip.git / blobdiff