a3e4f57f4bc369f920b76346cc4e3864b7224ddc
[samba.git] / source4 / dsdb / samdb / ldb_modules / extended_dn_out.c
1 /* 
2    ldb database library
3
4    Copyright (C) Simo Sorce 2005-2008
5    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2007-2009
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 extended dn control module
25  *
26  *  Description: this module builds a special dn for returned search
27  *  results, and fixes some other aspects of the result (returned case issues)
28  *  values.
29  *
30  *  Authors: Simo Sorce
31  *           Andrew Bartlett
32  */
33
34 #include "includes.h"
35 #include "ldb/include/ldb.h"
36 #include "ldb/include/ldb_errors.h"
37 #include "ldb/include/ldb_module.h"
38 #include "libcli/security/dom_sid.h"
39 #include "librpc/gen_ndr/ndr_misc.h"
40 #include "librpc/gen_ndr/ndr_security.h"
41 #include "librpc/ndr/libndr.h"
42 #include "dsdb/samdb/samdb.h"
43
44 struct extended_dn_out_private {
45         bool dereference;
46         bool normalise;
47         struct dsdb_openldap_dereference_control *dereference_control;
48 };
49
50 static bool is_attr_in_list(const char * const * attrs, const char *attr)
51 {
52         int i;
53
54         for (i = 0; attrs[i]; i++) {
55                 if (ldb_attr_cmp(attrs[i], attr) == 0)
56                         return true;
57         }
58
59         return false;
60 }
61
62 static char **copy_attrs(void *mem_ctx, const char * const * attrs)
63 {
64         char **nattrs;
65         int i, num;
66
67         for (num = 0; attrs[num]; num++);
68
69         nattrs = talloc_array(mem_ctx, char *, num + 1);
70         if (!nattrs) return NULL;
71
72         for(i = 0; i < num; i++) {
73                 nattrs[i] = talloc_strdup(nattrs, attrs[i]);
74                 if (!nattrs[i]) {
75                         talloc_free(nattrs);
76                         return NULL;
77                 }
78         }
79         nattrs[i] = NULL;
80
81         return nattrs;
82 }
83
84 static bool add_attrs(void *mem_ctx, char ***attrs, const char *attr)
85 {
86         char **nattrs;
87         int num;
88
89         for (num = 0; (*attrs)[num]; num++);
90
91         nattrs = talloc_realloc(mem_ctx, *attrs, char *, num + 2);
92         if (!nattrs) return false;
93
94         *attrs = nattrs;
95
96         nattrs[num] = talloc_strdup(nattrs, attr);
97         if (!nattrs[num]) return false;
98
99         nattrs[num + 1] = NULL;
100
101         return true;
102 }
103
104 /* Fix the DN so that the relative attribute names are in upper case so that the DN:
105    cn=Adminstrator,cn=users,dc=samba,dc=example,dc=com becomes
106    CN=Adminstrator,CN=users,DC=samba,DC=example,DC=com
107 */
108
109
110 static int fix_dn(struct ldb_dn *dn) 
111 {
112         int i, ret;
113         char *upper_rdn_attr;
114
115         for (i=0; i < ldb_dn_get_comp_num(dn); i++) {
116                 /* We need the attribute name in upper case */
117                 upper_rdn_attr = strupper_talloc(dn,
118                                                  ldb_dn_get_component_name(dn, i));
119                 if (!upper_rdn_attr) {
120                         return LDB_ERR_OPERATIONS_ERROR;
121                 }
122                 
123                 /* And replace it with CN=foo (we need the attribute in upper case */
124                 ret = ldb_dn_set_component(dn, i, upper_rdn_attr,
125                                            *ldb_dn_get_component_val(dn, i));
126                 talloc_free(upper_rdn_attr);
127                 if (ret != LDB_SUCCESS) {
128                         return ret;
129                 }
130         }
131         return LDB_SUCCESS;
132 }
133
134 /* Inject the extended DN components, so the DN cn=Adminstrator,cn=users,dc=samba,dc=example,dc=com becomes
135    <GUID=541203ae-f7d6-47ef-8390-bfcf019f9583>;<SID=S-1-5-21-4177067393-1453636373-93818737-500>;cn=Adminstrator,cn=users,dc=samba,dc=example,dc=com */
136
137 static int inject_extended_dn_out(struct ldb_reply *ares,
138                                   struct ldb_context *ldb,
139                                   int type,
140                                   bool remove_guid,
141                                   bool remove_sid)
142 {
143         int ret;
144         const DATA_BLOB *guid_blob;
145         const DATA_BLOB *sid_blob;
146
147         guid_blob = ldb_msg_find_ldb_val(ares->message, "objectGUID");
148         sid_blob = ldb_msg_find_ldb_val(ares->message, "objectSID");
149
150         if (!guid_blob) {
151                 ldb_set_errstring(ldb, "Did not find objectGUID to inject into extended DN");
152                 return LDB_ERR_OPERATIONS_ERROR;
153         }
154
155         ret = ldb_dn_set_extended_component(ares->message->dn, "GUID", guid_blob);
156         if (ret != LDB_SUCCESS) {
157                 return ret;
158         }
159         if (sid_blob) {
160                 ret = ldb_dn_set_extended_component(ares->message->dn, "SID", sid_blob);
161                 if (ret != LDB_SUCCESS) {
162                         return ret;
163                 }
164         }
165
166         if (remove_guid) {
167                 ldb_msg_remove_attr(ares->message, "objectGUID");
168         }
169
170         if (sid_blob && remove_sid) {
171                 ldb_msg_remove_attr(ares->message, "objectSID");
172         }
173
174         return LDB_SUCCESS;
175 }
176
177 static int handle_dereference_openldap(struct ldb_dn *dn,
178                               struct dsdb_openldap_dereference_result **dereference_attrs, 
179                               const char *attr, const DATA_BLOB *val)
180 {
181         const struct ldb_val *entryUUIDblob, *sid_blob;
182         struct ldb_message fake_msg; /* easier to use routines that expect an ldb_message */
183         int j;
184         
185         fake_msg.num_elements = 0;
186                         
187         /* Look for this attribute in the returned control */
188         for (j = 0; dereference_attrs && dereference_attrs[j]; j++) {
189                 struct ldb_val source_dn = data_blob_string_const(dereference_attrs[j]->dereferenced_dn);
190                 if (ldb_attr_cmp(dereference_attrs[j]->source_attribute, attr) == 0
191                     && data_blob_cmp(&source_dn, val) == 0) {
192                         fake_msg.num_elements = dereference_attrs[j]->num_attributes;
193                         fake_msg.elements = dereference_attrs[j]->attributes;
194                         break;
195                 }
196         }
197         if (!fake_msg.num_elements) {
198                 return LDB_SUCCESS;
199         }
200         /* Look for an OpenLDAP entryUUID */
201         
202         entryUUIDblob = ldb_msg_find_ldb_val(&fake_msg, "entryUUID");
203         if (entryUUIDblob) {
204                 NTSTATUS status;
205                 enum ndr_err_code ndr_err;
206                 
207                 struct ldb_val guid_blob;
208                 struct GUID guid;
209                 
210                 status = GUID_from_data_blob(entryUUIDblob, &guid);
211                 
212                 if (!NT_STATUS_IS_OK(status)) {
213                         return LDB_ERR_INVALID_DN_SYNTAX;
214                 }
215                 ndr_err = ndr_push_struct_blob(&guid_blob, NULL, NULL, &guid,
216                                                (ndr_push_flags_fn_t)ndr_push_GUID);
217                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
218                         return LDB_ERR_INVALID_DN_SYNTAX;
219                 }
220                 
221                 ldb_dn_set_extended_component(dn, "GUID", &guid_blob);
222         }
223         
224         sid_blob = ldb_msg_find_ldb_val(&fake_msg, "objectSID");
225         
226         /* Look for the objectSID */
227         if (sid_blob) {
228                 ldb_dn_set_extended_component(dn, "SID", sid_blob);
229         }
230         return LDB_SUCCESS;
231 }
232
233 static int handle_dereference_fds(struct ldb_dn *dn,
234                               struct dsdb_openldap_dereference_result **dereference_attrs, 
235                               const char *attr, const DATA_BLOB *val)
236 {
237         const struct ldb_val *nsUniqueIdBlob, *sidBlob;
238         struct ldb_message fake_msg; /* easier to use routines that expect an ldb_message */
239         int j;
240         
241         fake_msg.num_elements = 0;
242                         
243         /* Look for this attribute in the returned control */
244         for (j = 0; dereference_attrs && dereference_attrs[j]; j++) {
245                 struct ldb_val source_dn = data_blob_string_const(dereference_attrs[j]->dereferenced_dn);
246                 if (ldb_attr_cmp(dereference_attrs[j]->source_attribute, attr) == 0
247                     && data_blob_cmp(&source_dn, val) == 0) {
248                         fake_msg.num_elements = dereference_attrs[j]->num_attributes;
249                         fake_msg.elements = dereference_attrs[j]->attributes;
250                         break;
251                 }
252         }
253         if (!fake_msg.num_elements) {
254                 return LDB_SUCCESS;
255         }
256
257         /* Look for the nsUniqueId */
258         
259         nsUniqueIdBlob = ldb_msg_find_ldb_val(&fake_msg, "nsUniqueId");
260         if (nsUniqueIdBlob) {
261                 NTSTATUS status;
262                 enum ndr_err_code ndr_err;
263                 
264                 struct ldb_val guid_blob;
265                 struct GUID guid;
266                 
267                 status = NS_GUID_from_string((char *)nsUniqueIdBlob->data, &guid);
268                 
269                 if (!NT_STATUS_IS_OK(status)) {
270                         return LDB_ERR_INVALID_DN_SYNTAX;
271                 }
272                 ndr_err = ndr_push_struct_blob(&guid_blob, NULL, NULL, &guid,
273                                                 (ndr_push_flags_fn_t)ndr_push_GUID);
274                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
275                         return LDB_ERR_INVALID_DN_SYNTAX;
276                 }
277                 
278                 ldb_dn_set_extended_component(dn, "GUID", &guid_blob);
279         }
280         
281         /* Look for the objectSID */
282
283         sidBlob = ldb_msg_find_ldb_val(&fake_msg, "sambaSID");
284         if (sidBlob) {
285                 enum ndr_err_code ndr_err;
286
287                 struct ldb_val sid_blob;
288                 struct dom_sid *sid;
289
290                 sid = dom_sid_parse_length(NULL, sidBlob);
291
292                 if (sid == NULL) {
293                         return LDB_ERR_INVALID_DN_SYNTAX;
294                 }
295
296                 ndr_err = ndr_push_struct_blob(&sid_blob, NULL, NULL, sid,
297                                                 (ndr_push_flags_fn_t)ndr_push_dom_sid);
298                 talloc_free(sid);
299                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
300                         return LDB_ERR_INVALID_DN_SYNTAX;
301                 }
302
303                 ldb_dn_set_extended_component(dn, "SID", &sid_blob);
304         }
305         return LDB_SUCCESS;
306 }
307
308 /* search */
309 struct extended_search_context {
310         struct ldb_module *module;
311         const struct dsdb_schema *schema;
312         struct ldb_request *req;
313         bool inject;
314         bool remove_guid;
315         bool remove_sid;
316         int extended_type;
317 };
318
319 static int extended_callback(struct ldb_request *req, struct ldb_reply *ares,
320                 int (*handle_dereference)(struct ldb_dn *dn,
321                                 struct dsdb_openldap_dereference_result **dereference_attrs, 
322                                 const char *attr, const DATA_BLOB *val))
323 {
324         struct extended_search_context *ac;
325         struct ldb_control *control;
326         struct dsdb_openldap_dereference_result_control *dereference_control = NULL;
327         int ret, i, j;
328         struct ldb_message *msg = ares->message;
329         struct extended_dn_out_private *p;
330         struct ldb_context *ldb;
331         ac = talloc_get_type(req->context, struct extended_search_context);
332         p = talloc_get_type(ldb_module_get_private(ac->module), struct extended_dn_out_private);
333         ldb = ldb_module_get_ctx(ac->module);
334         if (!ares) {
335                 return ldb_module_done(ac->req, NULL, NULL,
336                                         LDB_ERR_OPERATIONS_ERROR);
337         }
338         if (ares->error != LDB_SUCCESS) {
339                 return ldb_module_done(ac->req, ares->controls,
340                                         ares->response, ares->error);
341         }
342
343         switch (ares->type) {
344         case LDB_REPLY_REFERRAL:
345                 return ldb_module_send_referral(ac->req, ares->referral);
346
347         case LDB_REPLY_DONE:
348                 return ldb_module_done(ac->req, ares->controls,
349                                         ares->response, LDB_SUCCESS);
350         case LDB_REPLY_ENTRY:
351                 break;
352         }
353
354         if (p && p->normalise) {
355                 ret = fix_dn(ares->message->dn);
356                 if (ret != LDB_SUCCESS) {
357                         return ldb_module_done(ac->req, NULL, NULL, ret);
358                 }
359         }
360                         
361         if (ac->inject) {
362                 /* for each record returned post-process to add any derived
363                    attributes that have been asked for */
364                 ret = inject_extended_dn_out(ares, ldb,
365                                              ac->extended_type, ac->remove_guid,
366                                              ac->remove_sid);
367                 if (ret != LDB_SUCCESS) {
368                         return ldb_module_done(ac->req, NULL, NULL, ret);
369                 }
370         }
371
372         if ((p && p->normalise) || ac->inject) {
373                 const struct ldb_val *val = ldb_msg_find_ldb_val(ares->message, "distinguishedName");
374                 if (val) {
375                         ldb_msg_remove_attr(ares->message, "distinguishedName");
376                         if (ac->inject) {
377                                 ret = ldb_msg_add_steal_string(ares->message, "distinguishedName", 
378                                                                ldb_dn_get_extended_linearized(ares->message, ares->message->dn, ac->extended_type));
379                         } else {
380                                 ret = ldb_msg_add_string(ares->message, "distinguishedName", 
381                                                          ldb_dn_get_linearized(ares->message->dn));
382                         }
383                         if (ret != LDB_SUCCESS) {
384                                 ldb_oom(ldb);
385                                 return LDB_ERR_OPERATIONS_ERROR;
386                         }
387                 }
388         }
389
390         if (p && p->dereference) {
391                 control = ldb_reply_get_control(ares, DSDB_OPENLDAP_DEREFERENCE_CONTROL);
392         
393                 if (control && control->data) {
394                         dereference_control = talloc_get_type(control->data, struct dsdb_openldap_dereference_result_control);
395                 }
396         }
397
398         /* Walk the retruned elements (but only if we have a schema to interpret the list with) */
399         for (i = 0; ac->schema && i < msg->num_elements; i++) {
400                 const struct dsdb_attribute *attribute;
401                 attribute = dsdb_attribute_by_lDAPDisplayName(ac->schema, msg->elements[i].name);
402                 if (!attribute) {
403                         continue;
404                 }
405
406                 if (p->normalise) {
407                         /* If we are also in 'normalise' mode, then
408                          * fix the attribute names to be in the
409                          * correct case */
410                         msg->elements[i].name = talloc_strdup(msg->elements, attribute->lDAPDisplayName);
411                         if (!msg->elements[i].name) {
412                                 ldb_oom(ldb);
413                                 return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
414                         }
415                 }
416
417                 /* distinguishedName has been dealt with above */
418                 if (ldb_attr_cmp(msg->elements[i].name, "distinguishedName") == 0) {
419                         continue;
420                 }
421
422                 /* Look to see if this attributeSyntax is a DN */
423                 if (dsdb_dn_oid_to_format(attribute->syntax->ldap_oid) == DSDB_INVALID_DN) {
424                         continue;
425                 }
426
427                 for (j = 0; j < msg->elements[i].num_values; j++) {
428                         const char *dn_str;
429                         struct ldb_dn *dn;
430                         struct dsdb_dn *dsdb_dn = NULL;
431                         struct ldb_val *plain_dn = &msg->elements[i].values[j];         
432                         dsdb_dn = dsdb_dn_parse(msg, ldb, plain_dn, attribute->syntax->ldap_oid);
433                         
434                         if (!dsdb_dn || !ldb_dn_validate(dsdb_dn->dn)) {
435                                 ldb_asprintf_errstring(ldb, 
436                                                        "could not parse %.*s in %s on %s as a %s DN", 
437                                                        (int)plain_dn->length, plain_dn->data,
438                                                        msg->elements[i].name, ldb_dn_get_linearized(msg->dn),
439                                                        attribute->syntax->ldap_oid);
440                                 talloc_free(dsdb_dn);
441                                 return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_INVALID_DN_SYNTAX);
442                         }
443                         dn = dsdb_dn->dn;
444
445                         if (p->normalise) {
446                                 ret = fix_dn(dn);
447                                 if (ret != LDB_SUCCESS) {
448                                         talloc_free(dsdb_dn);
449                                         return ldb_module_done(ac->req, NULL, NULL, ret);
450                                 }
451                         }
452                         
453                         /* If we are running in dereference mode (such
454                          * as against OpenLDAP) then the DN in the msg
455                          * above does not contain the extended values,
456                          * and we need to look in the dereference
457                          * result */
458
459                         /* Look for this value in the attribute */
460
461                         if (dereference_control) {
462                                 ret = handle_dereference(dn, 
463                                                          dereference_control->attributes,
464                                                          msg->elements[i].name,
465                                                          &msg->elements[i].values[j]);
466                                 if (ret != LDB_SUCCESS) {
467                                         talloc_free(dsdb_dn);
468                                         return ldb_module_done(ac->req, NULL, NULL, ret);
469                                 }
470                         }
471                         
472                         if (!ac->inject) {
473                                 dn_str = dsdb_dn_get_linearized(msg->elements[i].values, 
474                                                                 dsdb_dn);
475                         } else {
476                                 dn_str = dsdb_dn_get_extended_linearized(msg->elements[i].values, 
477                                                                          dsdb_dn, ac->extended_type);
478                         }
479                         
480                         if (!dn_str) {
481                                 ldb_oom(ldb);
482                                 talloc_free(dsdb_dn);
483                                 return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
484                         }
485                         msg->elements[i].values[j] = data_blob_string_const(dn_str);
486                         talloc_free(dsdb_dn);
487                 }
488         }
489         return ldb_module_send_entry(ac->req, msg, ares->controls);
490 }
491
492 static int extended_callback_ldb(struct ldb_request *req, struct ldb_reply *ares)
493 {
494         return extended_callback(req, ares, NULL);
495 }
496
497 static int extended_callback_openldap(struct ldb_request *req, struct ldb_reply *ares)
498 {
499         return extended_callback(req, ares, handle_dereference_openldap);
500 }
501
502 static int extended_callback_fds(struct ldb_request *req, struct ldb_reply *ares)
503 {
504         return extended_callback(req, ares, handle_dereference_fds);
505 }
506
507 static int extended_dn_out_search(struct ldb_module *module, struct ldb_request *req,
508                 int (*callback)(struct ldb_request *req, struct ldb_reply *ares))
509 {
510         struct ldb_control *control;
511         struct ldb_control *storage_format_control;
512         struct ldb_extended_dn_control *extended_ctrl = NULL;
513         struct ldb_control **saved_controls;
514         struct extended_search_context *ac;
515         struct ldb_request *down_req;
516         char **new_attrs;
517         const char * const *const_attrs;
518         struct ldb_context *ldb = ldb_module_get_ctx(module);
519         int ret;
520
521         struct extended_dn_out_private *p = talloc_get_type(ldb_module_get_private(module), struct extended_dn_out_private);
522
523         /* check if there's an extended dn control */
524         control = ldb_request_get_control(req, LDB_CONTROL_EXTENDED_DN_OID);
525         if (control && control->data) {
526                 extended_ctrl = talloc_get_type(control->data, struct ldb_extended_dn_control);
527                 if (!extended_ctrl) {
528                         return LDB_ERR_PROTOCOL_ERROR;
529                 }
530         }
531
532         /* Look to see if, as we are in 'store DN+GUID+SID' mode, the
533          * client is after the storage format (to fill in linked
534          * attributes) */
535         storage_format_control = ldb_request_get_control(req, DSDB_CONTROL_DN_STORAGE_FORMAT_OID);
536         if (!control && storage_format_control && storage_format_control->data) {
537                 extended_ctrl = talloc_get_type(storage_format_control->data, struct ldb_extended_dn_control);
538                 if (!extended_ctrl) {
539                         ldb_set_errstring(ldb, "extended_dn_out: extended_ctrl was of the wrong data type");
540                         return LDB_ERR_PROTOCOL_ERROR;
541                 }
542         }
543
544         ac = talloc_zero(req, struct extended_search_context);
545         if (ac == NULL) {
546                 ldb_oom(ldb);
547                 return LDB_ERR_OPERATIONS_ERROR;
548         }
549
550         ac->module = module;
551         ac->schema = dsdb_get_schema(ldb);
552         ac->req = req;
553         ac->inject = false;
554         ac->remove_guid = false;
555         ac->remove_sid = false;
556         
557         const_attrs = req->op.search.attrs;
558
559         /* We only need to do special processing if we were asked for
560          * the extended DN, or we are 'store DN+GUID+SID'
561          * (!dereference) mode.  (This is the normal mode for LDB on
562          * tdb). */
563         if (control || (storage_format_control && p && !p->dereference)) {
564                 ac->inject = true;
565                 if (extended_ctrl) {
566                         ac->extended_type = extended_ctrl->type;
567                 } else {
568                         ac->extended_type = 0;
569                 }
570
571                 /* check if attrs only is specified, in that case check wether we need to modify them */
572                 if (req->op.search.attrs && !is_attr_in_list(req->op.search.attrs, "*")) {
573                         if (! is_attr_in_list(req->op.search.attrs, "objectGUID")) {
574                                 ac->remove_guid = true;
575                         }
576                         if (! is_attr_in_list(req->op.search.attrs, "objectSID")) {
577                                 ac->remove_sid = true;
578                         }
579                         if (ac->remove_guid || ac->remove_sid) {
580                                 new_attrs = copy_attrs(ac, req->op.search.attrs);
581                                 if (new_attrs == NULL) {
582                                         ldb_oom(ldb);
583                                         return LDB_ERR_OPERATIONS_ERROR;
584                                 }
585
586                                 if (ac->remove_guid) {
587                                         if (!add_attrs(ac, &new_attrs, "objectGUID"))
588                                                 return LDB_ERR_OPERATIONS_ERROR;
589                                 }
590                                 if (ac->remove_sid) {
591                                         if (!add_attrs(ac, &new_attrs, "objectSID"))
592                                                 return LDB_ERR_OPERATIONS_ERROR;
593                                 }
594                                 const_attrs = (const char * const *)new_attrs;
595                         }
596                 }
597         }
598
599         ret = ldb_build_search_req_ex(&down_req,
600                                       ldb, ac,
601                                       req->op.search.base,
602                                       req->op.search.scope,
603                                       req->op.search.tree,
604                                       const_attrs,
605                                       req->controls,
606                                       ac, callback,
607                                       req);
608         if (ret != LDB_SUCCESS) {
609                 return ret;
610         }
611
612         /* Remove extended DN and storage format controls */
613
614         if (control) {
615                 /* save it locally and remove it from the list */
616                 /* we do not need to replace them later as we
617                  * are keeping the original req intact */
618                 if (!save_controls(control, down_req, &saved_controls)) {
619                         return LDB_ERR_OPERATIONS_ERROR;
620                 }
621         }
622
623         if (storage_format_control) {
624                 /* save it locally and remove it from the list */
625                 /* we do not need to replace them later as we
626                  * are keeping the original req intact */
627                 if (!save_controls(storage_format_control, down_req, &saved_controls)) {
628                         return LDB_ERR_OPERATIONS_ERROR;
629                 }
630         }
631
632         /* Add in dereference control, if we were asked to, we are
633          * using the 'dereference' mode (such as with an OpenLDAP
634          * backend) and have the control prepared */
635         if (control && p && p->dereference && p->dereference_control) {
636                 ret = ldb_request_add_control(down_req,
637                                               DSDB_OPENLDAP_DEREFERENCE_CONTROL,
638                                               false, p->dereference_control);
639                 if (ret != LDB_SUCCESS) {
640                         return ret;
641                 }
642         }
643
644         /* perform the search */
645         return ldb_next_request(module, down_req);
646 }
647
648 static int extended_dn_out_ldb_search(struct ldb_module *module, struct ldb_request *req)
649 {
650         return extended_dn_out_search(module, req, extended_callback_ldb);
651 }
652
653 static int extended_dn_out_openldap_search(struct ldb_module *module, struct ldb_request *req)
654 {
655         return extended_dn_out_search(module, req, extended_callback_openldap);
656 }
657
658 static int extended_dn_out_fds_search(struct ldb_module *module, struct ldb_request *req)
659 {
660         return extended_dn_out_search(module, req, extended_callback_fds);
661 }
662
663 static int extended_dn_out_ldb_init(struct ldb_module *module)
664 {
665         int ret;
666
667         struct extended_dn_out_private *p = talloc(module, struct extended_dn_out_private);
668         struct dsdb_extended_dn_store_format *dn_format;
669
670         ldb_module_set_private(module, p);
671
672         if (!p) {
673                 ldb_oom(ldb_module_get_ctx(module));
674                 return LDB_ERR_OPERATIONS_ERROR;
675         }
676
677         dn_format = talloc(p, struct dsdb_extended_dn_store_format);
678         if (!dn_format) {
679                 talloc_free(p);
680                 ldb_oom(ldb_module_get_ctx(module));
681                 return LDB_ERR_OPERATIONS_ERROR;
682         }
683
684         dn_format->store_extended_dn_in_ldb = true;
685         ret = ldb_set_opaque(ldb_module_get_ctx(module), DSDB_EXTENDED_DN_STORE_FORMAT_OPAQUE_NAME, dn_format);
686         if (ret != LDB_SUCCESS) {
687                 talloc_free(p);
688                 return ret;
689         }
690
691         p->dereference = false;
692         p->normalise = false;
693
694         ret = ldb_mod_register_control(module, LDB_CONTROL_EXTENDED_DN_OID);
695         if (ret != LDB_SUCCESS) {
696                 ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
697                         "extended_dn_out: Unable to register control with rootdse!\n");
698                 return LDB_ERR_OPERATIONS_ERROR;
699         }
700
701         return ldb_next_init(module);
702 }
703
704 static int extended_dn_out_dereference_init(struct ldb_module *module, const char *attrs[])
705 {
706         int ret, i = 0;
707         struct extended_dn_out_private *p = talloc_zero(module, struct extended_dn_out_private);
708         struct dsdb_extended_dn_store_format *dn_format;
709         struct dsdb_openldap_dereference_control *dereference_control;
710         struct dsdb_attribute *cur;
711         struct ldb_context *ldb = ldb_module_get_ctx(module);
712         struct dsdb_schema *schema;
713
714         ldb_module_set_private(module, p);
715
716         if (!p) {
717                 ldb_oom(ldb);
718                 return LDB_ERR_OPERATIONS_ERROR;
719         }
720
721         dn_format = talloc(p, struct dsdb_extended_dn_store_format);
722         if (!dn_format) {
723                 talloc_free(p);
724                 ldb_oom(ldb_module_get_ctx(module));
725                 return LDB_ERR_OPERATIONS_ERROR;
726         }
727
728         dn_format->store_extended_dn_in_ldb = false;
729
730         ret = ldb_set_opaque(ldb_module_get_ctx(module), DSDB_EXTENDED_DN_STORE_FORMAT_OPAQUE_NAME, dn_format);
731         if (ret != LDB_SUCCESS) {
732                 talloc_free(p);
733                 return ret;
734         }
735
736         p->dereference = true;
737
738         /* At the moment, servers that need dereference also need the
739          * DN and attribute names to be normalised */
740         p->normalise = true;
741
742         ret = ldb_mod_register_control(module, LDB_CONTROL_EXTENDED_DN_OID);
743         if (ret != LDB_SUCCESS) {
744                 ldb_debug(ldb, LDB_DEBUG_ERROR,
745                         "extended_dn_out: Unable to register control with rootdse!\n");
746                 return LDB_ERR_OPERATIONS_ERROR;
747         }
748
749         ret = ldb_next_init(module);
750
751         if (ret != LDB_SUCCESS) {
752                 return ret;
753         }
754
755         schema = dsdb_get_schema(ldb);
756         if (!schema) {
757                 /* No schema on this DB (yet) */
758                 return LDB_SUCCESS;
759         }
760
761         p->dereference_control = dereference_control
762                 = talloc_zero(p, struct dsdb_openldap_dereference_control);
763
764         if (!p->dereference_control) {
765                 ldb_oom(ldb);
766                 return LDB_ERR_OPERATIONS_ERROR;
767         }
768         
769         for (cur = schema->attributes; cur; cur = cur->next) {
770                 if (dsdb_dn_oid_to_format(cur->syntax->ldap_oid) == DSDB_INVALID_DN) {
771                         continue;
772                 }
773                 dereference_control->dereference
774                         = talloc_realloc(p, dereference_control->dereference,
775                                          struct dsdb_openldap_dereference *, i + 2);
776                 if (!dereference_control) {
777                         ldb_oom(ldb);
778                         return LDB_ERR_OPERATIONS_ERROR;
779                 }
780                 dereference_control->dereference[i] = talloc(dereference_control->dereference,  
781                                          struct dsdb_openldap_dereference);
782                 if (!dereference_control->dereference[i]) {
783                         ldb_oom(ldb);
784                         return LDB_ERR_OPERATIONS_ERROR;
785                 }
786                 dereference_control->dereference[i]->source_attribute = cur->lDAPDisplayName;
787                 dereference_control->dereference[i]->dereference_attribute = attrs;
788                 i++;
789                 dereference_control->dereference[i] = NULL;
790         }
791         return LDB_SUCCESS;
792 }
793
794 static int extended_dn_out_openldap_init(struct ldb_module *module)
795 {
796         static const char *attrs[] = {
797                 "entryUUID",
798                 "objectSID",
799                 NULL
800         };
801
802         return extended_dn_out_dereference_init(module, attrs);
803 }
804
805 static int extended_dn_out_fds_init(struct ldb_module *module)
806 {
807         static const char *attrs[] = {
808                 "nsUniqueId",
809                 "objectSID",
810                 NULL
811         };
812
813         return extended_dn_out_dereference_init(module, attrs);
814 }
815
816 _PUBLIC_ const struct ldb_module_ops ldb_extended_dn_out_ldb_module_ops = {
817         .name              = "extended_dn_out_ldb",
818         .search            = extended_dn_out_ldb_search,
819         .init_context      = extended_dn_out_ldb_init,
820 };
821
822 _PUBLIC_ const struct ldb_module_ops ldb_extended_dn_out_openldap_module_ops = {
823         .name              = "extended_dn_out_openldap",
824         .search            = extended_dn_out_openldap_search,
825         .init_context      = extended_dn_out_openldap_init,
826 };
827
828 _PUBLIC_ const struct ldb_module_ops ldb_extended_dn_out_fds_module_ops = {
829         .name              = "extended_dn_out_fds",
830         .search            = extended_dn_out_fds_search,
831         .init_context      = extended_dn_out_fds_init,
832 };