source4/dsdb/samdb/ldb_modules/subtree_rename.c

   1 /*
   2    ldb database library
   3
   4    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006-2007
   5    Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 /*
  22  *  Name: ldb
  23  *
  24  *  Component: ldb subtree rename module
  25  *
  26  *  Description: Rename a subtree in LDB
  27  *
  28  *  Author: Andrew Bartlett
  29  */
  30
  31 #include "ldb_module.h"
  32
  33 struct subren_msg_store {
  34         struct subren_msg_store *next;
  35         struct ldb_dn *olddn;
  36         struct ldb_dn *newdn;
  37 };
  38
  39 struct subtree_rename_context {
  40         struct ldb_module *module;
  41         struct ldb_request *req;
  42
  43         struct subren_msg_store *list;
  44         struct subren_msg_store *current;
  45 };
  46
  47 static struct subtree_rename_context *subren_ctx_init(struct ldb_module *module,
  48                                          struct ldb_request *req)
  49 {
  50         struct ldb_context *ldb;
  51         struct subtree_rename_context *ac;
  52
  53         ldb = ldb_module_get_ctx(module);
  54
  55         ac = talloc_zero(req, struct subtree_rename_context);
  56         if (ac == NULL) {
  57                 ldb_oom(ldb);
  58                 return NULL;
  59         }
  60
  61         ac->module = module;
  62         ac->req = req;
  63
  64         return ac;
  65 }
  66
  67 static int subtree_rename_next_request(struct subtree_rename_context *ac);
  68
  69 static int subtree_rename_callback(struct ldb_request *req,
  70                                    struct ldb_reply *ares)
  71 {
  72         struct ldb_context *ldb;
  73         struct subtree_rename_context *ac;
  74         int ret;
  75
  76         ac = talloc_get_type(req->context, struct subtree_rename_context);
  77         ldb = ldb_module_get_ctx(ac->module);
  78
  79         if (!ares) {
  80                 return ldb_module_done(ac->req, NULL, NULL,
  81                                         LDB_ERR_OPERATIONS_ERROR);
  82         }
  83
  84         if (ares->type == LDB_REPLY_REFERRAL) {
  85                 return ldb_module_send_referral(ac->req, ares->referral);
  86         }
  87
  88         if (ares->error != LDB_SUCCESS) {
  89                 return ldb_module_done(ac->req, ares->controls,
  90                                         ares->response, ares->error);
  91         }
  92
  93         if (ares->type != LDB_REPLY_DONE) {
  94                 ldb_set_errstring(ldb, "Invalid reply type!\n");
  95                 return ldb_module_done(ac->req, NULL, NULL,
  96                                         LDB_ERR_OPERATIONS_ERROR);
  97         }
  98
  99         if (ac->current == NULL) {
 100                 /* this was the last one */
 101                 return ldb_module_done(ac->req, ares->controls,
 102                                         ares->response, LDB_SUCCESS);
 103         }
 104
 105         ret = subtree_rename_next_request(ac);
 106         if (ret != LDB_SUCCESS) {
 107                 return ldb_module_done(ac->req, NULL, NULL, ret);
 108         }
 109
 110         talloc_free(ares);
 111         return LDB_SUCCESS;
 112 }
 113
 114 static int subtree_rename_next_request(struct subtree_rename_context *ac)
 115 {
 116         struct ldb_context *ldb;
 117         struct ldb_request *req;
 118         int ret;
 119
 120         ldb = ldb_module_get_ctx(ac->module);
 121
 122         if (ac->current == NULL) {
 123                 return LDB_ERR_OPERATIONS_ERROR;
 124         }
 125
 126         ret = ldb_build_rename_req(&req, ldb, ac->current,
 127                                    ac->current->olddn,
 128                                    ac->current->newdn,
 129                                    ac->req->controls,
 130                                    ac, subtree_rename_callback,
 131                                    ac->req);
 132         if (ret != LDB_SUCCESS) {
 133                 return ret;
 134         }
 135
 136         ac->current = ac->current->next;
 137
 138         return ldb_next_request(ac->module, req);
 139 }
 140
 141 static int subtree_rename_search_callback(struct ldb_request *req,
 142                                           struct ldb_reply *ares)
 143 {
 144         struct subren_msg_store *store;
 145         struct subtree_rename_context *ac;
 146         int ret;
 147
 148         ac = talloc_get_type(req->context, struct subtree_rename_context);
 149
 150         if (!ares || !ac->current) {
 151                 return ldb_module_done(ac->req, NULL, NULL,
 152                                         LDB_ERR_OPERATIONS_ERROR);
 153         }
 154         if (ares->error != LDB_SUCCESS) {
 155                 return ldb_module_done(ac->req, ares->controls,
 156                                         ares->response, ares->error);
 157         }
 158
 159         switch (ares->type) {
 160         case LDB_REPLY_ENTRY:
 161
 162                 if (ldb_dn_compare(ares->message->dn, ac->list->olddn) == 0) {
 163                         /* this was already stored by the
 164                          * subtree_rename_search() */
 165                         talloc_free(ares);
 166                         return LDB_SUCCESS;
 167                 }
 168
 169                 store = talloc_zero(ac, struct subren_msg_store);
 170                 if (store == NULL) {
 171                         return ldb_module_done(ac->req, NULL, NULL,
 172                                                 LDB_ERR_OPERATIONS_ERROR);
 173                 }
 174                 ac->current->next = store;
 175                 ac->current = store;
 176
 177                 /* the first list element contains the base for the rename */
 178                 store->olddn = talloc_steal(store, ares->message->dn);
 179                 store->newdn = ldb_dn_copy(store, store->olddn);
 180
 181                 if ( ! ldb_dn_remove_base_components(store->newdn,
 182                                 ldb_dn_get_comp_num(ac->list->olddn))) {
 183                         return ldb_module_done(ac->req, NULL, NULL,
 184                                                 LDB_ERR_OPERATIONS_ERROR);
 185                 }
 186
 187                 if ( ! ldb_dn_add_base(store->newdn, ac->list->newdn)) {
 188                         return ldb_module_done(ac->req, NULL, NULL,
 189                                                 LDB_ERR_OPERATIONS_ERROR);
 190                 }
 191
 192                 break;
 193
 194         case LDB_REPLY_REFERRAL:
 195                 /* ignore */
 196                 break;
 197
 198         case LDB_REPLY_DONE:
 199
 200                 /* rewind ac->current */
 201                 ac->current = ac->list;
 202
 203                 /* All dns set up, start with the first one */
 204                 ret = subtree_rename_next_request(ac);
 205
 206                 if (ret != LDB_SUCCESS) {
 207                         return ldb_module_done(ac->req, NULL, NULL, ret);
 208                 }
 209                 break;
 210         }
 211
 212         talloc_free(ares);
 213         return LDB_SUCCESS;
 214 }
 215
 216 /* rename */
 217 static int subtree_rename(struct ldb_module *module, struct ldb_request *req)
 218 {
 219         struct ldb_context *ldb;
 220         static const char *attrs[2] = { "distinguishedName", NULL };
 221         struct ldb_request *search_req;
 222         struct subtree_rename_context *ac;
 223         int ret;
 224         if (ldb_dn_is_special(req->op.rename.olddn)) { /* do not manipulate our control entries */
 225                 return ldb_next_request(module, req);
 226         }
 227
 228         ldb = ldb_module_get_ctx(module);
 229
 230         /* This gets complex:  We need to:
 231            - Do a search for all entires under this entry
 232            - Wait for these results to appear
 233            - In the callback for each result, issue a modify request
 234             - That will include this rename, we hope
 235            - Wait for each modify result
 236            - Regain our sainity
 237         */
 238
 239         ac = subren_ctx_init(module, req);
 240         if (!ac) {
 241                 return LDB_ERR_OPERATIONS_ERROR;
 242         }
 243
 244         /* add this entry as the first to do */
 245         ac->current = talloc_zero(ac, struct subren_msg_store);
 246         if (ac->current == NULL) {
 247                 return LDB_ERR_OPERATIONS_ERROR;
 248         }
 249         ac->current->olddn = req->op.rename.olddn;
 250         ac->current->newdn = req->op.rename.newdn;
 251         ac->list = ac->current;
 252
 253         ret = ldb_build_search_req(&search_req, ldb, ac,
 254                                    req->op.rename.olddn,
 255                                    LDB_SCOPE_SUBTREE,
 256                                    "(objectClass=*)",
 257                                    attrs,
 258                                    NULL,
 259                                    ac,
 260                                    subtree_rename_search_callback,
 261                                    req);
 262         if (ret != LDB_SUCCESS) {
 263                 return ret;
 264         }
 265
 266         return ldb_next_request(module, search_req);
 267 }
 268
 269 const struct ldb_module_ops ldb_subtree_rename_module_ops = {
 270         .name              = "subtree_rename",
 271         .rename            = subtree_rename,
 272 };