241cc5f7d6fe85f7f450c09a95d45ae49035ae8d
[ira/wip.git] / 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 };