2a3c6fd1dcea0e3177c109fc4bdb3373c3abefa0
[ira/wip.git] / source4 / lib / ldb / modules / rdn_name.c
1 /* 
2    ldb database library
3
4    Copyright (C) Andrew Bartlett 2005-2009
5    Copyright (C) Simo Sorce 2006-2008
6
7      ** NOTE! The following LGPL license applies to the ldb
8      ** library. This does NOT imply that all of Samba is released
9      ** under the LGPL
10    
11    This library is free software; you can redistribute it and/or
12    modify it under the terms of the GNU Lesser General Public
13    License as published by the Free Software Foundation; either
14    version 3 of the License, or (at your option) any later version.
15
16    This library is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19    Lesser General Public License for more details.
20
21    You should have received a copy of the GNU Lesser General Public
22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
23 */
24
25 /*
26  *  Name: rdn_name
27  *
28  *  Component: ldb rdn name module
29  *
30  *  Description: keep a consistent name attribute on objects manpulations
31  *
32  *  Author: Andrew Bartlett
33  *
34  *  Modifications:
35  *    - made the module async
36  *      Simo Sorce Mar 2006
37  */
38
39 #include "ldb_includes.h"
40 #include "ldb_module.h"
41
42 struct rename_context {
43         struct ldb_module *module;
44         struct ldb_request *req;
45
46         struct ldb_reply *ares;
47 };
48
49 static struct ldb_message_element *rdn_name_find_attribute(const struct ldb_message *msg, const char *name)
50 {
51         int i;
52
53         for (i = 0; i < msg->num_elements; i++) {
54                 if (ldb_attr_cmp(name, msg->elements[i].name) == 0) {
55                         return &msg->elements[i];
56                 }
57         }
58
59         return NULL;
60 }
61
62 static int rdn_name_add_callback(struct ldb_request *req,
63                                  struct ldb_reply *ares)
64 {
65         struct rename_context *ac;
66
67         ac = talloc_get_type(req->context, struct rename_context);
68
69         if (!ares) {
70                 return ldb_module_done(ac->req, NULL, NULL,
71                                         LDB_ERR_OPERATIONS_ERROR);
72         }
73         if (ares->error != LDB_SUCCESS) {
74                 return ldb_module_done(ac->req, ares->controls,
75                                         ares->response, ares->error);
76         }
77
78         if (ares->type != LDB_REPLY_DONE) {
79                 return ldb_module_done(ac->req, NULL, NULL,
80                                         LDB_ERR_OPERATIONS_ERROR);
81         }
82
83         return ldb_module_done(ac->req, ares->controls,
84                                         ares->response, LDB_SUCCESS);
85 }
86
87 static int rdn_name_add(struct ldb_module *module, struct ldb_request *req)
88 {
89         struct ldb_context *ldb;
90         struct ldb_request *down_req;
91         struct rename_context *ac;
92         struct ldb_message *msg;
93         struct ldb_message_element *attribute;
94         const struct ldb_schema_attribute *a;
95         const char *rdn_name;
96         struct ldb_val rdn_val;
97         int i, ret;
98
99         ldb = ldb_module_get_ctx(module);
100
101         /* do not manipulate our control entries */
102         if (ldb_dn_is_special(req->op.add.message->dn)) {
103                 return ldb_next_request(module, req);
104         }
105
106         ac = talloc_zero(req, struct rename_context);
107         if (ac == NULL) {
108                 return LDB_ERR_OPERATIONS_ERROR;
109         }
110
111         ac->module = module;
112         ac->req = req;
113
114         msg = ldb_msg_copy_shallow(req, req->op.add.message);
115         if (msg == NULL) {
116                 return LDB_ERR_OPERATIONS_ERROR;
117         }
118
119         rdn_name = ldb_dn_get_rdn_name(msg->dn);
120         if (rdn_name == NULL) {
121                 return LDB_ERR_OPERATIONS_ERROR;
122         }
123         
124         rdn_val = ldb_val_dup(msg, ldb_dn_get_rdn_val(msg->dn));
125         
126         /* Perhaps someone above us tried to set this? */
127         if ((attribute = rdn_name_find_attribute(msg, "name")) != NULL ) {
128                 attribute->num_values = 0;
129         }
130
131         if (ldb_msg_add_value(msg, "name", &rdn_val, NULL) != 0) {
132                 return LDB_ERR_OPERATIONS_ERROR;
133         }
134
135         attribute = rdn_name_find_attribute(msg, rdn_name);
136
137         if (!attribute) {
138                 if (ldb_msg_add_value(msg, rdn_name, &rdn_val, NULL) != 0) {
139                         return LDB_ERR_OPERATIONS_ERROR;
140                 }
141         } else {
142                 a = ldb_schema_attribute_by_name(ldb, rdn_name);
143
144                 for (i = 0; i < attribute->num_values; i++) {
145                         ret = a->syntax->comparison_fn(ldb, msg,
146                                         &rdn_val, &attribute->values[i]);
147                         if (ret == 0) {
148                                 /* overwrite so it matches in case */
149                                 attribute->values[i] = rdn_val;
150                                 break;
151                         }
152                 }
153                 if (i == attribute->num_values) {
154                         char *rdn_errstring = talloc_asprintf(ac,
155                                 "RDN mismatch on %s: %s (%.*s) should match one of:", 
156                                 ldb_dn_get_linearized(msg->dn), rdn_name, 
157                                 (int)rdn_val.length, (const char *)rdn_val.data);
158                         for (i = 0; i < attribute->num_values; i++) {
159                                 rdn_errstring = talloc_asprintf_append(
160                                         rdn_errstring, " (%.*s)",
161                                         (int)attribute->values[i].length, 
162                                         (const char *)attribute->values[i].data);
163                         }
164                         ldb_set_errstring(ldb, rdn_errstring);
165                         /* Match AD's error here */
166                         return LDB_ERR_INVALID_DN_SYNTAX;
167                 }
168         }
169
170         ret = ldb_build_add_req(&down_req, ldb, req,
171                                 msg,
172                                 req->controls,
173                                 ac, rdn_name_add_callback,
174                                 req);
175         if (ret != LDB_SUCCESS) {
176                 return ret;
177         }
178
179         talloc_steal(down_req, msg);
180
181         /* go on with the call chain */
182         return ldb_next_request(module, down_req);
183 }
184
185 static int rdn_modify_callback(struct ldb_request *req, struct ldb_reply *ares)
186 {
187         struct rename_context *ac;
188
189         ac = talloc_get_type(req->context, struct rename_context);
190
191         if (!ares) {
192                 return ldb_module_done(ac->req, NULL, NULL,
193                                         LDB_ERR_OPERATIONS_ERROR);
194         }
195         if (ares->error != LDB_SUCCESS) {
196                 return ldb_module_done(ac->req, ares->controls,
197                                         ares->response, ares->error);
198         }
199
200         /* the only supported reply right now is a LDB_REPLY_DONE */
201         if (ares->type != LDB_REPLY_DONE) {
202                 return ldb_module_done(ac->req, NULL, NULL,
203                                         LDB_ERR_OPERATIONS_ERROR);
204         }
205
206         /* send saved controls eventually */
207         return ldb_module_done(ac->req, ac->ares->controls,
208                                 ac->ares->response, LDB_SUCCESS);
209 }
210
211 static int rdn_rename_callback(struct ldb_request *req, struct ldb_reply *ares)
212 {
213         struct ldb_context *ldb;
214         struct rename_context *ac;
215         struct ldb_request *mod_req;
216         const char *rdn_name;
217         struct ldb_val rdn_val;
218         struct ldb_message *msg;
219         int ret;
220
221         ac = talloc_get_type(req->context, struct rename_context);
222         ldb = ldb_module_get_ctx(ac->module);
223
224         if (!ares) {
225                 goto error;
226         }
227         if (ares->error != LDB_SUCCESS) {
228                 return ldb_module_done(ac->req, ares->controls,
229                                         ares->response, ares->error);
230         }
231
232         /* the only supported reply right now is a LDB_REPLY_DONE */
233         if (ares->type != LDB_REPLY_DONE) {
234                 goto error;
235         }
236
237         /* save reply for caller */
238         ac->ares = talloc_steal(ac, ares);
239
240         msg = ldb_msg_new(ac);
241         if (msg == NULL) {
242                 goto error;
243         }
244         msg->dn = ldb_dn_copy(msg, ac->req->op.rename.newdn);
245         if (msg->dn == NULL) {
246                 goto error;
247         }
248         rdn_name = ldb_dn_get_rdn_name(ac->req->op.rename.newdn);
249         if (rdn_name == NULL) {
250                 goto error;
251         }
252         
253         rdn_val = ldb_val_dup(msg, ldb_dn_get_rdn_val(ac->req->op.rename.newdn));
254         
255         if (ldb_msg_add_empty(msg, rdn_name, LDB_FLAG_MOD_REPLACE, NULL) != 0) {
256                 goto error;
257         }
258         if (ldb_msg_add_value(msg, rdn_name, &rdn_val, NULL) != 0) {
259                 goto error;
260         }
261         if (ldb_msg_add_empty(msg, "name", LDB_FLAG_MOD_REPLACE, NULL) != 0) {
262                 goto error;
263         }
264         if (ldb_msg_add_value(msg, "name", &rdn_val, NULL) != 0) {
265                 goto error;
266         }
267
268         ret = ldb_build_mod_req(&mod_req, ldb,
269                                 ac, msg, NULL,
270                                 ac, rdn_modify_callback,
271                                 req);
272         if (ret != LDB_SUCCESS) {
273                 return ldb_module_done(ac->req, NULL, NULL, ret);
274         }
275         talloc_steal(mod_req, msg);
276
277         /* go on with the call chain */
278         return ldb_next_request(ac->module, mod_req);
279
280 error:
281         return ldb_module_done(ac->req, NULL, NULL,
282                                                  LDB_ERR_OPERATIONS_ERROR);
283 }
284
285 static int rdn_name_rename(struct ldb_module *module, struct ldb_request *req)
286 {
287         struct ldb_context *ldb;
288         struct rename_context *ac;
289         struct ldb_request *down_req;
290         int ret;
291
292         ldb = ldb_module_get_ctx(module);
293
294         /* do not manipulate our control entries */
295         if (ldb_dn_is_special(req->op.rename.newdn)) {
296                 return ldb_next_request(module, req);
297         }
298
299         ac = talloc_zero(req, struct rename_context);
300         if (ac == NULL) {
301                 return LDB_ERR_OPERATIONS_ERROR;
302         }
303
304         ac->module = module;
305         ac->req = req;
306
307         ret = ldb_build_rename_req(&down_req,
308                                    ldb,
309                                    ac,
310                                    req->op.rename.olddn,
311                                    req->op.rename.newdn,
312                                    req->controls,
313                                    ac,
314                                    rdn_rename_callback,
315                                    req);
316
317         if (ret != LDB_SUCCESS) {
318                 return ret;
319         }
320
321         /* rename first, modify "name" if rename is ok */
322         return ldb_next_request(module, down_req);
323 }
324
325 static int rdn_name_modify(struct ldb_module *module, struct ldb_request *req)
326 {
327         struct ldb_context *ldb;
328
329         ldb = ldb_module_get_ctx(module);
330
331         /* do not manipulate our control entries */
332         if (ldb_dn_is_special(req->op.mod.message->dn)) {
333                 return ldb_next_request(module, req);
334         }
335
336         if (ldb_msg_find_element(req->op.mod.message, "name")) {
337                 ldb_asprintf_errstring(ldb, "Modify of 'name' on %s not permitted, must use 'rename' operation instead",
338                                        ldb_dn_get_linearized(req->op.mod.message->dn));
339                 return LDB_ERR_NOT_ALLOWED_ON_RDN;
340         }
341
342         if (ldb_msg_find_element(req->op.mod.message, ldb_dn_get_rdn_name(req->op.mod.message->dn))) {
343                 ldb_asprintf_errstring(ldb, "Modify of RDN '%s' on %s not permitted, must use 'rename' operation instead",
344                                        ldb_dn_get_rdn_name(req->op.mod.message->dn), ldb_dn_get_linearized(req->op.mod.message->dn));
345                 return LDB_ERR_NOT_ALLOWED_ON_RDN;
346         }
347
348         /* All OK, they kept their fingers out of the special attributes */
349         return ldb_next_request(module, req);
350 }
351
352 const struct ldb_module_ops ldb_rdn_name_module_ops = {
353         .name              = "rdn_name",
354         .add               = rdn_name_add,
355         .modify            = rdn_name_modify,
356         .rename            = rdn_name_rename
357 };