source4/dsdb/samdb/ldb_modules/subtree_delete.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    Copyright (C) Simo Sorce <idra@samba.org> 2008
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 /*
  23  *  Name: ldb
  24  *
  25  *  Component: ldb subtree delete (prevention) module
  26  *
  27  *  Description: Prevent deletion of a subtree in LDB
  28  *
  29  *  Author: Andrew Bartlett
  30  */
  31
  32 #include "ldb_module.h"
  33
  34 struct subtree_delete_context {
  35         struct ldb_module *module;
  36         struct ldb_request *req;
  37
  38         int num_children;
  39 };
  40
  41 static struct subtree_delete_context *subdel_ctx_init(struct ldb_module *module,
  42                                                       struct ldb_request *req)
  43 {
  44         struct ldb_context *ldb;
  45         struct subtree_delete_context *ac;
  46
  47         ldb = ldb_module_get_ctx(module);
  48
  49         ac = talloc_zero(req, struct subtree_delete_context);
  50         if (ac == NULL) {
  51                 ldb_oom(ldb);
  52                 return NULL;
  53         }
  54
  55         ac->module = module;
  56         ac->req = req;
  57
  58         return ac;
  59 }
  60
  61 static int subtree_delete_search_callback(struct ldb_request *req,
  62                                           struct ldb_reply *ares)
  63 {
  64         struct ldb_context *ldb;
  65         struct subtree_delete_context *ac;
  66         int ret;
  67
  68         ac = talloc_get_type(req->context, struct subtree_delete_context);
  69         ldb = ldb_module_get_ctx(ac->module);
  70
  71         if (!ares) {
  72                 ret = LDB_ERR_OPERATIONS_ERROR;
  73                 goto done;
  74         }
  75         if (ares->error != LDB_SUCCESS) {
  76                 return ldb_module_done(ac->req, ares->controls,
  77                                         ares->response, ares->error);
  78         }
  79
  80         switch (ares->type) {
  81         case LDB_REPLY_ENTRY:
  82                 /* count entry */
  83                 ++(ac->num_children);
  84
  85                 talloc_free(ares);
  86                 ret = LDB_SUCCESS;
  87                 break;
  88
  89         case LDB_REPLY_REFERRAL:
  90                 /* ignore */
  91                 talloc_free(ares);
  92                 ret = LDB_SUCCESS;
  93                 break;
  94
  95         case LDB_REPLY_DONE:
  96                 talloc_free(ares);
  97
  98                 if (ac->num_children > 0) {
  99                         ldb_asprintf_errstring(ldb,
 100                                 "Cannot delete %s, not a leaf node "
 101                                 "(has %d children)\n",
 102                                 ldb_dn_get_linearized(ac->req->op.del.dn),
 103                                 ac->num_children);
 104                         return ldb_module_done(ac->req, NULL, NULL,
 105                                                LDB_ERR_NOT_ALLOWED_ON_NON_LEAF);
 106                 }
 107
 108                 /* ok no children, let the original request through */
 109                 ret = ldb_next_request(ac->module, ac->req);
 110                 break;
 111         }
 112
 113 done:
 114         if (ret != LDB_SUCCESS) {
 115                 return ldb_module_done(ac->req, NULL, NULL, ret);
 116         }
 117
 118         return LDB_SUCCESS;
 119 }
 120
 121 static int subtree_delete(struct ldb_module *module, struct ldb_request *req)
 122 {
 123         struct ldb_context *ldb;
 124         static const char * const attrs[2] = { "distinguishedName", NULL };
 125         struct ldb_request *search_req;
 126         struct subtree_delete_context *ac;
 127         int ret;
 128
 129         if (ldb_dn_is_special(req->op.rename.olddn)) {
 130                 /* do not manipulate our control entries */
 131                 return ldb_next_request(module, req);
 132         }
 133
 134         ldb = ldb_module_get_ctx(module);
 135
 136         /* This gets complex:  We need to:
 137            - Do a search for all entires under this entry
 138            - Wait for these results to appear
 139            - In the callback for each result, count the children (if any)
 140            - return an error if there are any
 141         */
 142
 143         ac = subdel_ctx_init(module, req);
 144         if (!ac) {
 145                 return LDB_ERR_OPERATIONS_ERROR;
 146         }
 147
 148         /* we do not really need to find all descendents,
 149          * if there is even one single direct child, that's
 150          * enough to bail out */
 151         ret = ldb_build_search_req(&search_req, ldb, ac,
 152                                    req->op.del.dn, LDB_SCOPE_ONELEVEL,
 153                                    "(objectClass=*)", attrs,
 154                                    req->controls,
 155                                    ac, subtree_delete_search_callback,
 156                                    req);
 157         if (ret != LDB_SUCCESS) {
 158                 return ret;
 159         }
 160
 161         return ldb_next_request(module, search_req);
 162 }
 163
 164 const struct ldb_module_ops ldb_subtree_delete_module_ops = {
 165         .name              = "subtree_delete",
 166         .del               = subtree_delete,
 167 };