s4-dsdb: In rootdse module, catch rename on any DN that has an impact on our NTDS...
[mat/samba.git] / source4 / dsdb / samdb / ldb_modules / rootdse.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    rootDSE ldb module
5
6    Copyright (C) Andrew Tridgell 2005
7    Copyright (C) Simo Sorce 2005-2008
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include <ldb.h>
25 #include <ldb_module.h>
26 #include "system/time.h"
27 #include "dsdb/samdb/samdb.h"
28 #include "version.h"
29 #include "dsdb/samdb/ldb_modules/util.h"
30 #include "libcli/security/security.h"
31 #include "librpc/ndr/libndr.h"
32 #include "auth/auth.h"
33 #include "param/param.h"
34 #include "lib/messaging/irpc.h"
35 #include "librpc/gen_ndr/ndr_irpc_c.h"
36
37 struct private_data {
38         unsigned int num_controls;
39         char **controls;
40         unsigned int num_partitions;
41         struct ldb_dn **partitions;
42         bool block_anonymous;
43 };
44
45 /*
46   return 1 if a specific attribute has been requested
47 */
48 static int do_attribute(const char * const *attrs, const char *name)
49 {
50         return attrs == NULL ||
51                 ldb_attr_in_list(attrs, name) ||
52                 ldb_attr_in_list(attrs, "*");
53 }
54
55 static int do_attribute_explicit(const char * const *attrs, const char *name)
56 {
57         return attrs != NULL && ldb_attr_in_list(attrs, name);
58 }
59
60
61 /*
62   expand a DN attribute to include extended DN information if requested
63  */
64 static int expand_dn_in_message(struct ldb_module *module, struct ldb_message *msg,
65                                 const char *attrname, struct ldb_control *edn_control,
66                                 struct ldb_request *req)
67 {
68         struct ldb_dn *dn, *dn2;
69         struct ldb_val *v;
70         int ret;
71         struct ldb_request *req2;
72         char *dn_string;
73         const char *no_attrs[] = { NULL };
74         struct ldb_result *res;
75         struct ldb_extended_dn_control *edn;
76         TALLOC_CTX *tmp_ctx = talloc_new(req);
77         struct ldb_context *ldb;
78         int edn_type = 0;
79
80         ldb = ldb_module_get_ctx(module);
81
82         edn = talloc_get_type(edn_control->data, struct ldb_extended_dn_control);
83         if (edn) {
84                 edn_type = edn->type;
85         }
86
87         v = discard_const_p(struct ldb_val, ldb_msg_find_ldb_val(msg, attrname));
88         if (v == NULL) {
89                 talloc_free(tmp_ctx);
90                 return LDB_SUCCESS;
91         }
92
93         dn_string = talloc_strndup(tmp_ctx, (const char *)v->data, v->length);
94         if (dn_string == NULL) {
95                 talloc_free(tmp_ctx);
96                 return ldb_operr(ldb);
97         }
98
99         res = talloc_zero(tmp_ctx, struct ldb_result);
100         if (res == NULL) {
101                 talloc_free(tmp_ctx);
102                 return ldb_operr(ldb);
103         }
104
105         dn = ldb_dn_new(tmp_ctx, ldb, dn_string);
106         if (dn == NULL) {
107                 talloc_free(tmp_ctx);
108                 return ldb_operr(ldb);
109         }
110
111         ret = ldb_build_search_req(&req2, ldb, tmp_ctx,
112                                    dn,
113                                    LDB_SCOPE_BASE,
114                                    NULL,
115                                    no_attrs,
116                                    NULL,
117                                    res, ldb_search_default_callback,
118                                    req);
119         LDB_REQ_SET_LOCATION(req2);
120         if (ret != LDB_SUCCESS) {
121                 talloc_free(tmp_ctx);
122                 return ret;
123         }
124
125
126         ret = ldb_request_add_control(req2,
127                                       LDB_CONTROL_EXTENDED_DN_OID,
128                                       edn_control->critical, edn);
129         if (ret != LDB_SUCCESS) {
130                 talloc_free(tmp_ctx);
131                 return ret;
132         }
133
134         ret = ldb_next_request(module, req2);
135         if (ret == LDB_SUCCESS) {
136                 ret = ldb_wait(req2->handle, LDB_WAIT_ALL);
137         }
138         if (ret != LDB_SUCCESS) {
139                 talloc_free(tmp_ctx);
140                 return ret;
141         }
142
143         if (!res || res->count != 1) {
144                 talloc_free(tmp_ctx);
145                 return ldb_operr(ldb);
146         }
147
148         dn2 = res->msgs[0]->dn;
149
150         v->data = (uint8_t *)ldb_dn_get_extended_linearized(msg->elements, dn2, edn_type);
151         if (v->data == NULL) {
152                 talloc_free(tmp_ctx);
153                 return ldb_operr(ldb);
154         }
155         v->length = strlen((char *)v->data);
156
157
158         talloc_free(tmp_ctx);
159
160         return LDB_SUCCESS;
161 }
162
163
164 /*
165   add dynamically generated attributes to rootDSE result
166 */
167 static int rootdse_add_dynamic(struct ldb_module *module, struct ldb_message *msg,
168                                const char * const *attrs, struct ldb_request *req)
169 {
170         struct ldb_context *ldb;
171         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
172         char **server_sasl;
173         const struct dsdb_schema *schema;
174         int *val;
175         struct ldb_control *edn_control;
176         const char *dn_attrs[] = {
177                 "configurationNamingContext",
178                 "defaultNamingContext",
179                 "dsServiceName",
180                 "rootDomainNamingContext",
181                 "schemaNamingContext",
182                 "serverName",
183                 "namingContexts",
184                 NULL
185         };
186
187         ldb = ldb_module_get_ctx(module);
188         schema = dsdb_get_schema(ldb, NULL);
189
190         msg->dn = ldb_dn_new(msg, ldb, NULL);
191
192         /* don't return the distinguishedName, cn and name attributes */
193         ldb_msg_remove_attr(msg, "distinguishedName");
194         ldb_msg_remove_attr(msg, "cn");
195         ldb_msg_remove_attr(msg, "name");
196
197         if (do_attribute(attrs, "serverName")) {
198                 if (ldb_msg_add_linearized_dn(msg, "serverName",
199                         samdb_server_dn(ldb, msg)) != LDB_SUCCESS) {
200                         goto failed;
201                 }
202         }
203
204         if (do_attribute(attrs, "dnsHostName")) {
205                 struct ldb_result *res;
206                 int ret;
207                 const char *dns_attrs[] = { "dNSHostName", NULL };
208                 ret = dsdb_module_search_dn(module, msg, &res, samdb_server_dn(ldb, msg),
209                                             dns_attrs, DSDB_FLAG_NEXT_MODULE, req);
210                 if (ret == LDB_SUCCESS) {
211                         const char *hostname = ldb_msg_find_attr_as_string(res->msgs[0], "dNSHostName", NULL);
212                         if (hostname != NULL) {
213                                 if (ldb_msg_add_string(msg, "dNSHostName", hostname)) {
214                                         goto failed;
215                                 }
216                         }
217                 }
218         }
219
220         if (do_attribute(attrs, "ldapServiceName")) {
221                 struct loadparm_context *lp_ctx
222                         = talloc_get_type(ldb_get_opaque(ldb, "loadparm"),
223                                           struct loadparm_context);
224                 char *ldap_service_name, *hostname;
225
226                 hostname = strlower_talloc(msg, lpcfg_netbios_name(lp_ctx));
227                 if (hostname == NULL) {
228                         goto failed;
229                 }
230
231                 ldap_service_name = talloc_asprintf(msg, "%s:%s$@%s",
232                                                     samdb_forest_name(ldb, msg),
233                                                     hostname, lpcfg_realm(lp_ctx));
234                 if (ldap_service_name == NULL) {
235                         goto failed;
236                 }
237
238                 if (ldb_msg_add_string(msg, "ldapServiceName",
239                                        ldap_service_name) != LDB_SUCCESS) {
240                         goto failed;
241                 }
242         }
243
244         if (do_attribute(attrs, "currentTime")) {
245                 if (ldb_msg_add_steal_string(msg, "currentTime",
246                                              ldb_timestring(msg, time(NULL))) != LDB_SUCCESS) {
247                         goto failed;
248                 }
249         }
250
251         if (priv && do_attribute(attrs, "supportedControl")) {
252                 unsigned int i;
253                 for (i = 0; i < priv->num_controls; i++) {
254                         char *control = talloc_strdup(msg, priv->controls[i]);
255                         if (!control) {
256                                 goto failed;
257                         }
258                         if (ldb_msg_add_steal_string(msg, "supportedControl",
259                                                      control) != LDB_SUCCESS) {
260                                 goto failed;
261                         }
262                 }
263         }
264
265         if (priv && do_attribute(attrs, "namingContexts")) {
266                 unsigned int i;
267                 for (i = 0; i < priv->num_partitions; i++) {
268                         struct ldb_dn *dn = priv->partitions[i];
269                         if (ldb_msg_add_steal_string(msg, "namingContexts",
270                                                      ldb_dn_alloc_linearized(msg, dn)) != LDB_SUCCESS) {
271                                 goto failed;
272                         }
273                 }
274         }
275
276         server_sasl = talloc_get_type(ldb_get_opaque(ldb, "supportedSASLMechanisms"),
277                                        char *);
278         if (server_sasl && do_attribute(attrs, "supportedSASLMechanisms")) {
279                 unsigned int i;
280                 for (i = 0; server_sasl && server_sasl[i]; i++) {
281                         char *sasl_name = talloc_strdup(msg, server_sasl[i]);
282                         if (!sasl_name) {
283                                 goto failed;
284                         }
285                         if (ldb_msg_add_steal_string(msg, "supportedSASLMechanisms",
286                                                      sasl_name) != LDB_SUCCESS) {
287                                 goto failed;
288                         }
289                 }
290         }
291
292         if (do_attribute(attrs, "highestCommittedUSN")) {
293                 uint64_t seq_num;
294                 int ret = ldb_sequence_number(ldb, LDB_SEQ_HIGHEST_SEQ, &seq_num);
295                 if (ret == LDB_SUCCESS) {
296                         if (samdb_msg_add_uint64(ldb, msg, msg,
297                                                  "highestCommittedUSN",
298                                                  seq_num) != LDB_SUCCESS) {
299                                 goto failed;
300                         }
301                 }
302         }
303
304         if (schema && do_attribute_explicit(attrs, "dsSchemaAttrCount")) {
305                 struct dsdb_attribute *cur;
306                 unsigned int n = 0;
307
308                 for (cur = schema->attributes; cur; cur = cur->next) {
309                         n++;
310                 }
311
312                 if (samdb_msg_add_uint(ldb, msg, msg, "dsSchemaAttrCount",
313                                        n) != LDB_SUCCESS) {
314                         goto failed;
315                 }
316         }
317
318         if (schema && do_attribute_explicit(attrs, "dsSchemaClassCount")) {
319                 struct dsdb_class *cur;
320                 unsigned int n = 0;
321
322                 for (cur = schema->classes; cur; cur = cur->next) {
323                         n++;
324                 }
325
326                 if (samdb_msg_add_uint(ldb, msg, msg, "dsSchemaClassCount",
327                                        n) != LDB_SUCCESS) {
328                         goto failed;
329                 }
330         }
331
332         if (schema && do_attribute_explicit(attrs, "dsSchemaPrefixCount")) {
333                 if (samdb_msg_add_uint(ldb, msg, msg, "dsSchemaPrefixCount",
334                                        schema->prefixmap->length) != LDB_SUCCESS) {
335                         goto failed;
336                 }
337         }
338
339         if (do_attribute_explicit(attrs, "validFSMOs")) {
340                 const struct dsdb_naming_fsmo *naming_fsmo;
341                 const struct dsdb_pdc_fsmo *pdc_fsmo;
342                 const char *dn_str;
343
344                 if (schema && schema->fsmo.we_are_master) {
345                         dn_str = ldb_dn_get_linearized(ldb_get_schema_basedn(ldb));
346                         if (dn_str && dn_str[0]) {
347                                 if (ldb_msg_add_fmt(msg, "validFSMOs", "%s", dn_str) != LDB_SUCCESS) {
348                                         goto failed;
349                                 }
350                         }
351                 }
352
353                 naming_fsmo = talloc_get_type(ldb_get_opaque(ldb, "dsdb_naming_fsmo"),
354                                               struct dsdb_naming_fsmo);
355                 if (naming_fsmo && naming_fsmo->we_are_master) {
356                         dn_str = ldb_dn_get_linearized(samdb_partitions_dn(ldb, msg));
357                         if (dn_str && dn_str[0]) {
358                                 if (ldb_msg_add_fmt(msg, "validFSMOs", "%s", dn_str) != LDB_SUCCESS) {
359                                         goto failed;
360                                 }
361                         }
362                 }
363
364                 pdc_fsmo = talloc_get_type(ldb_get_opaque(ldb, "dsdb_pdc_fsmo"),
365                                            struct dsdb_pdc_fsmo);
366                 if (pdc_fsmo && pdc_fsmo->we_are_master) {
367                         dn_str = ldb_dn_get_linearized(ldb_get_default_basedn(ldb));
368                         if (dn_str && dn_str[0]) {
369                                 if (ldb_msg_add_fmt(msg, "validFSMOs", "%s", dn_str) != LDB_SUCCESS) {
370                                         goto failed;
371                                 }
372                         }
373                 }
374         }
375
376         if (do_attribute_explicit(attrs, "vendorVersion")) {
377                 if (ldb_msg_add_fmt(msg, "vendorVersion",
378                                     "%s", SAMBA_VERSION_STRING) != LDB_SUCCESS) {
379                         goto failed;
380                 }
381         }
382
383         if (do_attribute(attrs, "domainFunctionality")) {
384                 if (samdb_msg_add_int(ldb, msg, msg, "domainFunctionality",
385                                       dsdb_functional_level(ldb)) != LDB_SUCCESS) {
386                         goto failed;
387                 }
388         }
389
390         if (do_attribute(attrs, "forestFunctionality")) {
391                 if (samdb_msg_add_int(ldb, msg, msg, "forestFunctionality",
392                                       dsdb_forest_functional_level(ldb)) != LDB_SUCCESS) {
393                         goto failed;
394                 }
395         }
396
397         if (do_attribute(attrs, "domainControllerFunctionality")
398             && (val = talloc_get_type(ldb_get_opaque(ldb, "domainControllerFunctionality"), int))) {
399                 if (samdb_msg_add_int(ldb, msg, msg,
400                                       "domainControllerFunctionality",
401                                       *val) != LDB_SUCCESS) {
402                         goto failed;
403                 }
404         }
405
406         if (do_attribute(attrs, "isGlobalCatalogReady")) {
407                 /* MS-ADTS 3.1.1.3.2.10
408                    Note, we should only return true here is we have
409                    completed at least one synchronisation. As both
410                    provision and vampire do a full sync, this means we
411                    can return true is the gc bit is set in the NTDSDSA
412                    options */
413                 if (ldb_msg_add_fmt(msg, "isGlobalCatalogReady",
414                                     "%s", samdb_is_gc(ldb)?"TRUE":"FALSE") != LDB_SUCCESS) {
415                         goto failed;
416                 }
417         }
418
419         if (do_attribute_explicit(attrs, "tokenGroups")) {
420                 unsigned int i;
421                 /* Obtain the user's session_info */
422                 struct auth_session_info *session_info
423                         = (struct auth_session_info *)ldb_get_opaque(ldb, "sessionInfo");
424                 if (session_info && session_info->security_token) {
425                         /* The list of groups this user is in */
426                         for (i = 0; i < session_info->security_token->num_sids; i++) {
427                                 if (samdb_msg_add_dom_sid(ldb, msg, msg,
428                                                           "tokenGroups",
429                                                           &session_info->security_token->sids[i]) != LDB_SUCCESS) {
430                                         goto failed;
431                                 }
432                         }
433                 }
434         }
435
436         /* TODO: lots more dynamic attributes should be added here */
437
438         edn_control = ldb_request_get_control(req, LDB_CONTROL_EXTENDED_DN_OID);
439
440         /* if the client sent us the EXTENDED_DN control then we need
441            to expand the DNs to have GUID and SID. W2K8 join relies on
442            this */
443         if (edn_control) {
444                 unsigned int i;
445                 int ret;
446                 for (i=0; dn_attrs[i]; i++) {
447                         if (!do_attribute(attrs, dn_attrs[i])) continue;
448                         ret = expand_dn_in_message(module, msg, dn_attrs[i],
449                                                    edn_control, req);
450                         if (ret != LDB_SUCCESS) {
451                                 DEBUG(0,(__location__ ": Failed to expand DN in rootDSE for %s\n",
452                                          dn_attrs[i]));
453                                 goto failed;
454                         }
455                 }
456         }
457
458         return LDB_SUCCESS;
459
460 failed:
461         return ldb_operr(ldb);
462 }
463
464 /*
465   handle search requests
466 */
467
468 struct rootdse_context {
469         struct ldb_module *module;
470         struct ldb_request *req;
471 };
472
473 static struct rootdse_context *rootdse_init_context(struct ldb_module *module,
474                                                     struct ldb_request *req)
475 {
476         struct ldb_context *ldb;
477         struct rootdse_context *ac;
478
479         ldb = ldb_module_get_ctx(module);
480
481         ac = talloc_zero(req, struct rootdse_context);
482         if (ac == NULL) {
483                 ldb_set_errstring(ldb, "Out of Memory");
484                 return NULL;
485         }
486
487         ac->module = module;
488         ac->req = req;
489
490         return ac;
491 }
492
493 static int rootdse_callback(struct ldb_request *req, struct ldb_reply *ares)
494 {
495         struct rootdse_context *ac;
496         int ret;
497
498         ac = talloc_get_type(req->context, struct rootdse_context);
499
500         if (!ares) {
501                 return ldb_module_done(ac->req, NULL, NULL,
502                                         LDB_ERR_OPERATIONS_ERROR);
503         }
504         if (ares->error != LDB_SUCCESS) {
505                 return ldb_module_done(ac->req, ares->controls,
506                                         ares->response, ares->error);
507         }
508
509         switch (ares->type) {
510         case LDB_REPLY_ENTRY:
511                 /*
512                  * if the client explicit asks for the 'netlogon' attribute
513                  * the reply_entry needs to be skipped
514                  */
515                 if (ac->req->op.search.attrs &&
516                     ldb_attr_in_list(ac->req->op.search.attrs, "netlogon")) {
517                         talloc_free(ares);
518                         return LDB_SUCCESS;
519                 }
520
521                 /* for each record returned post-process to add any dynamic
522                    attributes that have been asked for */
523                 ret = rootdse_add_dynamic(ac->module, ares->message,
524                                           ac->req->op.search.attrs, ac->req);
525                 if (ret != LDB_SUCCESS) {
526                         talloc_free(ares);
527                         return ldb_module_done(ac->req, NULL, NULL, ret);
528                 }
529
530                 return ldb_module_send_entry(ac->req, ares->message, ares->controls);
531
532         case LDB_REPLY_REFERRAL:
533                 /* should we allow the backend to return referrals in this case
534                  * ?? */
535                 break;
536
537         case LDB_REPLY_DONE:
538                 return ldb_module_done(ac->req, ares->controls,
539                                         ares->response, ares->error);
540         }
541
542         talloc_free(ares);
543         return LDB_SUCCESS;
544 }
545
546 /*
547   filter from controls from clients in several ways
548
549   1) mark our registered controls as non-critical in the request
550
551     This is needed as clients may mark controls as critical even if
552     they are not needed at all in a request. For example, the centrify
553     client sets the SD_FLAGS control as critical on ldap modify
554     requests which are setting the dNSHostName attribute on the
555     machine account. That request doesn't need SD_FLAGS at all, but
556     centrify adds it on all ldap requests.
557
558   2) if this request is untrusted then remove any non-registered
559      controls that are non-critical
560
561     This is used on ldap:// connections to prevent remote users from
562     setting an internal control that may be dangerous
563
564   3) if this request is untrusted then fail any request that includes
565      a critical non-registered control
566  */
567 static int rootdse_filter_controls(struct ldb_module *module, struct ldb_request *req)
568 {
569         unsigned int i, j;
570         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
571         bool is_untrusted;
572
573         if (!req->controls) {
574                 return LDB_SUCCESS;
575         }
576
577         is_untrusted = ldb_req_is_untrusted(req);
578
579         for (i=0; req->controls[i]; i++) {
580                 bool is_registered = false;
581                 bool is_critical = (req->controls[i]->critical != 0);
582
583                 if (req->controls[i]->oid == NULL) {
584                         continue;
585                 }
586
587                 if (is_untrusted || is_critical) {
588                         for (j=0; j<priv->num_controls; j++) {
589                                 if (strcasecmp(priv->controls[j], req->controls[i]->oid) == 0) {
590                                         is_registered = true;
591                                         break;
592                                 }
593                         }
594                 }
595
596                 if (is_untrusted && !is_registered) {
597                         if (!is_critical) {
598                                 /* remove it by marking the oid NULL */
599                                 req->controls[i]->oid = NULL;
600                                 req->controls[i]->data = NULL;
601                                 req->controls[i]->critical = 0;
602                                 continue;
603                         }
604                         /* its a critical unregistered control - give
605                            an error */
606                         ldb_asprintf_errstring(ldb_module_get_ctx(module),
607                                                "Attempt to use critical non-registered control '%s'",
608                                                req->controls[i]->oid);
609                         return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
610                 }
611
612                 if (!is_critical) {
613                         continue;
614                 }
615
616                 /* If the control is DIRSYNC control then we keep the critical
617                  * flag as the dirsync module will need to act upon it
618                  */
619                 if (is_registered && strcmp(req->controls[i]->oid,
620                                         LDB_CONTROL_DIRSYNC_OID)!= 0) {
621                         req->controls[i]->critical = 0;
622                 }
623         }
624
625         return LDB_SUCCESS;
626 }
627
628 /* Ensure that anonymous users are not allowed to make anything other than rootDSE search operations */
629
630 static int rootdse_filter_operations(struct ldb_module *module, struct ldb_request *req)
631 {
632         struct auth_session_info *session_info;
633         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
634         bool is_untrusted = ldb_req_is_untrusted(req);
635         bool is_anonymous = true;
636         if (is_untrusted == false) {
637                 return LDB_SUCCESS;
638         }
639
640         session_info = (struct auth_session_info *)ldb_get_opaque(ldb_module_get_ctx(module), "sessionInfo");
641         if (session_info) {
642                 is_anonymous = security_token_is_anonymous(session_info->security_token);
643         }
644         
645         if (is_anonymous == false || (priv && priv->block_anonymous == false)) {
646                 return LDB_SUCCESS;
647         }
648         
649         if (req->operation == LDB_SEARCH) {
650                 if (req->op.search.scope == LDB_SCOPE_BASE && ldb_dn_is_null(req->op.search.base)) {
651                         return LDB_SUCCESS;
652                 }
653         }
654         ldb_set_errstring(ldb_module_get_ctx(module), "Operation unavailable without authentication");
655         return LDB_ERR_OPERATIONS_ERROR;
656 }
657
658 static int rootdse_search(struct ldb_module *module, struct ldb_request *req)
659 {
660         struct ldb_context *ldb;
661         struct rootdse_context *ac;
662         struct ldb_request *down_req;
663         int ret;
664
665         ret = rootdse_filter_operations(module, req);
666         if (ret != LDB_SUCCESS) {
667                 return ret;
668         }
669
670         ret = rootdse_filter_controls(module, req);
671         if (ret != LDB_SUCCESS) {
672                 return ret;
673         }
674
675         ldb = ldb_module_get_ctx(module);
676
677         /* see if its for the rootDSE - only a base search on the "" DN qualifies */
678         if (!(req->op.search.scope == LDB_SCOPE_BASE && ldb_dn_is_null(req->op.search.base))) {
679                 /* Otherwise, pass down to the rest of the stack */
680                 return ldb_next_request(module, req);
681         }
682
683         ac = rootdse_init_context(module, req);
684         if (ac == NULL) {
685                 return ldb_operr(ldb);
686         }
687
688         /* in our db we store the rootDSE with a DN of @ROOTDSE */
689         ret = ldb_build_search_req(&down_req, ldb, ac,
690                                         ldb_dn_new(ac, ldb, "@ROOTDSE"),
691                                         LDB_SCOPE_BASE,
692                                         NULL,
693                                         req->op.search.attrs,
694                                         NULL,/* for now skip the controls from the client */
695                                         ac, rootdse_callback,
696                                         req);
697         LDB_REQ_SET_LOCATION(down_req);
698         if (ret != LDB_SUCCESS) {
699                 return ret;
700         }
701
702         return ldb_next_request(module, down_req);
703 }
704
705 static int rootdse_register_control(struct ldb_module *module, struct ldb_request *req)
706 {
707         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
708         char **list;
709
710         list = talloc_realloc(priv, priv->controls, char *, priv->num_controls + 1);
711         if (!list) {
712                 return ldb_oom(ldb_module_get_ctx(module));
713         }
714
715         list[priv->num_controls] = talloc_strdup(list, req->op.reg_control.oid);
716         if (!list[priv->num_controls]) {
717                 return ldb_oom(ldb_module_get_ctx(module));
718         }
719
720         priv->num_controls += 1;
721         priv->controls = list;
722
723         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
724 }
725
726 static int rootdse_register_partition(struct ldb_module *module, struct ldb_request *req)
727 {
728         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
729         struct ldb_dn **list;
730
731         list = talloc_realloc(priv, priv->partitions, struct ldb_dn *, priv->num_partitions + 1);
732         if (!list) {
733                 return ldb_oom(ldb_module_get_ctx(module));
734         }
735
736         list[priv->num_partitions] = ldb_dn_copy(list, req->op.reg_partition.dn);
737         if (!list[priv->num_partitions]) {
738                 return ldb_operr(ldb_module_get_ctx(module));
739         }
740
741         priv->num_partitions += 1;
742         priv->partitions = list;
743
744         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
745 }
746
747
748 static int rootdse_request(struct ldb_module *module, struct ldb_request *req)
749 {
750         switch (req->operation) {
751
752         case LDB_REQ_REGISTER_CONTROL:
753                 return rootdse_register_control(module, req);
754         case LDB_REQ_REGISTER_PARTITION:
755                 return rootdse_register_partition(module, req);
756
757         default:
758                 break;
759         }
760         return ldb_next_request(module, req);
761 }
762
763 static int rootdse_init(struct ldb_module *module)
764 {
765         int ret;
766         struct ldb_context *ldb;
767         struct ldb_result *res;
768         struct private_data *data;
769         const char *attrs[] = { "msDS-Behavior-Version", NULL };
770         const char *ds_attrs[] = { "dsServiceName", NULL };
771         TALLOC_CTX *mem_ctx;
772
773         ldb = ldb_module_get_ctx(module);
774
775         data = talloc_zero(module, struct private_data);
776         if (data == NULL) {
777                 return ldb_oom(ldb);
778         }
779
780         data->num_controls = 0;
781         data->controls = NULL;
782         data->num_partitions = 0;
783         data->partitions = NULL;
784         data->block_anonymous = true;
785
786         ldb_module_set_private(module, data);
787
788         ldb_set_default_dns(ldb);
789
790         ret = ldb_next_init(module);
791
792         if (ret != LDB_SUCCESS) {
793                 return ret;
794         }
795
796         mem_ctx = talloc_new(data);
797         if (!mem_ctx) {
798                 return ldb_oom(ldb);
799         }
800
801         /* Now that the partitions are set up, do a search for:
802            - domainControllerFunctionality
803            - domainFunctionality
804            - forestFunctionality
805
806            Then stuff these values into an opaque
807         */
808         ret = dsdb_module_search(module, mem_ctx, &res,
809                                  ldb_get_default_basedn(ldb),
810                                  LDB_SCOPE_BASE, attrs, DSDB_FLAG_NEXT_MODULE, NULL, NULL);
811         if (ret == LDB_SUCCESS && res->count == 1) {
812                 int domain_behaviour_version
813                         = ldb_msg_find_attr_as_int(res->msgs[0],
814                                                    "msDS-Behavior-Version", -1);
815                 if (domain_behaviour_version != -1) {
816                         int *val = talloc(ldb, int);
817                         if (!val) {
818                                 talloc_free(mem_ctx);
819                                 return ldb_oom(ldb);
820                         }
821                         *val = domain_behaviour_version;
822                         ret = ldb_set_opaque(ldb, "domainFunctionality", val);
823                         if (ret != LDB_SUCCESS) {
824                                 talloc_free(mem_ctx);
825                                 return ret;
826                         }
827                 }
828         }
829
830         ret = dsdb_module_search(module, mem_ctx, &res,
831                                  samdb_partitions_dn(ldb, mem_ctx),
832                                  LDB_SCOPE_BASE, attrs, DSDB_FLAG_NEXT_MODULE, NULL, NULL);
833         if (ret == LDB_SUCCESS && res->count == 1) {
834                 int forest_behaviour_version
835                         = ldb_msg_find_attr_as_int(res->msgs[0],
836                                                    "msDS-Behavior-Version", -1);
837                 if (forest_behaviour_version != -1) {
838                         int *val = talloc(ldb, int);
839                         if (!val) {
840                                 talloc_free(mem_ctx);
841                                 return ldb_oom(ldb);
842                         }
843                         *val = forest_behaviour_version;
844                         ret = ldb_set_opaque(ldb, "forestFunctionality", val);
845                         if (ret != LDB_SUCCESS) {
846                                 talloc_free(mem_ctx);
847                                 return ret;
848                         }
849                 }
850         }
851
852         /* For now, our own server's location in the DB is recorded in
853          * the @ROOTDSE record */
854         ret = dsdb_module_search(module, mem_ctx, &res,
855                                  ldb_dn_new(mem_ctx, ldb, "@ROOTDSE"),
856                                  LDB_SCOPE_BASE, ds_attrs, DSDB_FLAG_NEXT_MODULE, NULL, NULL);
857         if (ret == LDB_SUCCESS && res->count == 1) {
858                 struct ldb_dn *ds_dn
859                         = ldb_msg_find_attr_as_dn(ldb, mem_ctx, res->msgs[0],
860                                                   "dsServiceName");
861                 if (ds_dn) {
862                         ret = dsdb_module_search(module, mem_ctx, &res, ds_dn,
863                                                  LDB_SCOPE_BASE, attrs, DSDB_FLAG_NEXT_MODULE, NULL, NULL);
864                         if (ret == LDB_SUCCESS && res->count == 1) {
865                                 int domain_controller_behaviour_version
866                                         = ldb_msg_find_attr_as_int(res->msgs[0],
867                                                                    "msDS-Behavior-Version", -1);
868                                 if (domain_controller_behaviour_version != -1) {
869                                         int *val = talloc(ldb, int);
870                                         if (!val) {
871                                                 talloc_free(mem_ctx);
872                                                 return ldb_oom(ldb);
873                                         }
874                                         *val = domain_controller_behaviour_version;
875                                         ret = ldb_set_opaque(ldb,
876                                                              "domainControllerFunctionality", val);
877                                         if (ret != LDB_SUCCESS) {
878                                                 talloc_free(mem_ctx);
879                                                 return ret;
880                                         }
881                                 }
882                         }
883                 }
884         }
885
886         data->block_anonymous = dsdb_block_anonymous_ops(module, NULL);
887
888         talloc_free(mem_ctx);
889
890         return LDB_SUCCESS;
891 }
892
893 /*
894  * This function gets the string SCOPE_DN:OPTIONAL_FEATURE_GUID and parse it
895  * to a DN and a GUID object
896  */
897 static int get_optional_feature_dn_guid(struct ldb_request *req, struct ldb_context *ldb,
898                                                 TALLOC_CTX *mem_ctx,
899                                                 struct ldb_dn **op_feature_scope_dn,
900                                                 struct GUID *op_feature_guid)
901 {
902         const struct ldb_message *msg = req->op.mod.message;
903         const char *ldb_val_str;
904         char *dn, *guid;
905         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
906         NTSTATUS status;
907
908         ldb_val_str = ldb_msg_find_attr_as_string(msg, "enableOptionalFeature", NULL);
909         if (!ldb_val_str) {
910                 ldb_set_errstring(ldb,
911                                   "rootdse: unable to find 'enableOptionalFeature'!");
912                 return LDB_ERR_UNWILLING_TO_PERFORM;
913         }
914
915         guid = strchr(ldb_val_str, ':');
916         if (!guid) {
917                 ldb_set_errstring(ldb,
918                                   "rootdse: unable to find GUID in 'enableOptionalFeature'!");
919                 return LDB_ERR_UNWILLING_TO_PERFORM;
920         }
921         status = GUID_from_string(guid+1, op_feature_guid);
922         if (!NT_STATUS_IS_OK(status)) {
923                 ldb_set_errstring(ldb,
924                                   "rootdse: bad GUID in 'enableOptionalFeature'!");
925                 return LDB_ERR_UNWILLING_TO_PERFORM;
926         }
927
928         dn = talloc_strndup(tmp_ctx, ldb_val_str, guid-ldb_val_str);
929         if (!dn) {
930                 ldb_set_errstring(ldb,
931                                   "rootdse: bad DN in 'enableOptionalFeature'!");
932                 return LDB_ERR_UNWILLING_TO_PERFORM;
933         }
934
935         *op_feature_scope_dn = ldb_dn_new(mem_ctx, ldb, dn);
936
937         talloc_free(tmp_ctx);
938         return LDB_SUCCESS;
939 }
940
941 /*
942  * This function gets the OPTIONAL_FEATURE_GUID and looks for the optional feature
943  * ldb_message object.
944  */
945 static int dsdb_find_optional_feature(struct ldb_module *module, struct ldb_context *ldb,
946                                       TALLOC_CTX *mem_ctx, struct GUID op_feature_guid, struct ldb_message **msg,
947                                       struct ldb_request *parent)
948 {
949         struct ldb_result *res;
950         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
951         int ret;
952
953         ret = dsdb_module_search(module, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
954                                  NULL,
955                                  DSDB_FLAG_NEXT_MODULE |
956                                  DSDB_SEARCH_SEARCH_ALL_PARTITIONS,
957                                  parent,
958                                  "(&(objectClass=msDS-OptionalFeature)"
959                                  "(msDS-OptionalFeatureGUID=%s))",GUID_string(tmp_ctx, &op_feature_guid));
960
961         if (ret != LDB_SUCCESS) {
962                 talloc_free(tmp_ctx);
963                 return ret;
964         }
965         if (res->count == 0) {
966                 talloc_free(tmp_ctx);
967                 return LDB_ERR_NO_SUCH_OBJECT;
968         }
969         if (res->count != 1) {
970                 ldb_asprintf_errstring(ldb,
971                                        "More than one object found matching optional feature GUID %s\n",
972                                        GUID_string(tmp_ctx, &op_feature_guid));
973                 talloc_free(tmp_ctx);
974                 return LDB_ERR_OPERATIONS_ERROR;
975         }
976
977         *msg = talloc_steal(mem_ctx, res->msgs[0]);
978
979         talloc_free(tmp_ctx);
980         return LDB_SUCCESS;
981 }
982
983 static int rootdse_enable_recycle_bin(struct ldb_module *module,struct ldb_context *ldb,
984                                       TALLOC_CTX *mem_ctx, struct ldb_dn *op_feature_scope_dn,
985                                       struct ldb_message *op_feature_msg, struct ldb_request *parent)
986 {
987         int ret;
988         const int domain_func_level = dsdb_functional_level(ldb);
989         struct ldb_dn *ntds_settings_dn;
990         TALLOC_CTX *tmp_ctx;
991         unsigned int el_count = 0;
992         struct ldb_message *msg;
993
994         ret = ldb_msg_find_attr_as_int(op_feature_msg, "msDS-RequiredForestBehaviorVersion", 0);
995         if (domain_func_level < ret){
996                 ldb_asprintf_errstring(ldb,
997                                        "rootdse_enable_recycle_bin: Domain functional level must be at least %d\n",
998                                        ret);
999                 return LDB_ERR_UNWILLING_TO_PERFORM;
1000         }
1001
1002         tmp_ctx = talloc_new(mem_ctx);
1003         ntds_settings_dn = samdb_ntds_settings_dn(ldb);
1004         if (!ntds_settings_dn) {
1005                 talloc_free(tmp_ctx);
1006                 return ldb_error(ldb, LDB_ERR_OPERATIONS_ERROR, "Failed to find NTDS settings DN");
1007         }
1008
1009         ntds_settings_dn = ldb_dn_copy(tmp_ctx, ntds_settings_dn);
1010         if (!ntds_settings_dn) {
1011                 talloc_free(tmp_ctx);
1012                 return ldb_error(ldb, LDB_ERR_OPERATIONS_ERROR, "Failed to copy NTDS settings DN");
1013         }
1014
1015         msg = ldb_msg_new(tmp_ctx);
1016         msg->dn = ntds_settings_dn;
1017
1018         ldb_msg_add_linearized_dn(msg, "msDS-EnabledFeature", op_feature_msg->dn);
1019         msg->elements[el_count++].flags = LDB_FLAG_MOD_ADD;
1020
1021         ret = dsdb_module_modify(module, msg, DSDB_FLAG_NEXT_MODULE, parent);
1022         if (ret != LDB_SUCCESS) {
1023                 ldb_asprintf_errstring(ldb,
1024                                        "rootdse_enable_recycle_bin: Failed to modify object %s - %s",
1025                                        ldb_dn_get_linearized(ntds_settings_dn),
1026                                        ldb_errstring(ldb));
1027                 talloc_free(tmp_ctx);
1028                 return ret;
1029         }
1030
1031         msg->dn = op_feature_scope_dn;
1032         ret = dsdb_module_modify(module, msg, DSDB_FLAG_NEXT_MODULE, parent);
1033         if (ret != LDB_SUCCESS) {
1034                 ldb_asprintf_errstring(ldb,
1035                                        "rootdse_enable_recycle_bin: Failed to modify object %s - %s",
1036                                        ldb_dn_get_linearized(op_feature_scope_dn),
1037                                        ldb_errstring(ldb));
1038                 talloc_free(tmp_ctx);
1039                 return ret;
1040         }
1041
1042         return LDB_SUCCESS;
1043 }
1044
1045 static int rootdse_enableoptionalfeature(struct ldb_module *module, struct ldb_request *req)
1046 {
1047         /*
1048           steps:
1049                - check for system (only system can enable features)
1050                - extract GUID from the request
1051                - find the feature object
1052                - check functional level, must be at least msDS-RequiredForestBehaviorVersion
1053                - check if it is already enabled (if enabled return LDAP_ATTRIBUTE_OR_VALUE_EXISTS) - probably not needed, just return error from the add/modify
1054                - add/modify objects (see ntdsconnection code for an example)
1055          */
1056
1057         struct ldb_context *ldb = ldb_module_get_ctx(module);
1058         struct GUID op_feature_guid;
1059         struct ldb_dn *op_feature_scope_dn;
1060         struct ldb_message *op_feature_msg;
1061         struct auth_session_info *session_info =
1062                                 (struct auth_session_info *)ldb_get_opaque(ldb, "sessionInfo");
1063         TALLOC_CTX *tmp_ctx = talloc_new(ldb);
1064         int ret;
1065         const char *guid_string;
1066
1067         if (security_session_user_level(session_info, NULL) != SECURITY_SYSTEM) {
1068                 ldb_set_errstring(ldb, "rootdse: Insufficient rights for enableoptionalfeature");
1069                 return LDB_ERR_UNWILLING_TO_PERFORM;
1070         }
1071
1072         ret = get_optional_feature_dn_guid(req, ldb, tmp_ctx, &op_feature_scope_dn, &op_feature_guid);
1073         if (ret != LDB_SUCCESS) {
1074                 talloc_free(tmp_ctx);
1075                 return ret;
1076         }
1077
1078         guid_string = GUID_string(tmp_ctx, &op_feature_guid);
1079         if (!guid_string) {
1080                 ldb_set_errstring(ldb, "rootdse: bad optional feature GUID");
1081                 return LDB_ERR_UNWILLING_TO_PERFORM;
1082         }
1083
1084         ret = dsdb_find_optional_feature(module, ldb, tmp_ctx, op_feature_guid, &op_feature_msg, req);
1085         if (ret != LDB_SUCCESS) {
1086                 ldb_asprintf_errstring(ldb,
1087                                        "rootdse: unable to find optional feature for %s - %s",
1088                                        guid_string, ldb_errstring(ldb));
1089                 talloc_free(tmp_ctx);
1090                 return ret;
1091         }
1092
1093         if (strcasecmp(DS_GUID_FEATURE_RECYCLE_BIN, guid_string) == 0) {
1094                         ret = rootdse_enable_recycle_bin(module, ldb,
1095                                                          tmp_ctx, op_feature_scope_dn,
1096                                                          op_feature_msg, req);
1097         } else {
1098                 ldb_asprintf_errstring(ldb,
1099                                        "rootdse: unknown optional feature %s",
1100                                        guid_string);
1101                 talloc_free(tmp_ctx);
1102                 return LDB_ERR_UNWILLING_TO_PERFORM;
1103         }
1104         if (ret != LDB_SUCCESS) {
1105                 ldb_asprintf_errstring(ldb,
1106                                        "rootdse: failed to set optional feature for %s - %s",
1107                                        guid_string, ldb_errstring(ldb));
1108                 talloc_free(tmp_ctx);
1109                 return ret;
1110         }
1111
1112         talloc_free(tmp_ctx);
1113         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);;
1114 }
1115
1116 static int rootdse_schemaupdatenow(struct ldb_module *module, struct ldb_request *req)
1117 {
1118         struct ldb_context *ldb = ldb_module_get_ctx(module);
1119         struct ldb_result *ext_res;
1120         int ret;
1121         struct ldb_dn *schema_dn;
1122
1123         schema_dn = ldb_get_schema_basedn(ldb);
1124         if (!schema_dn) {
1125                 ldb_reset_err_string(ldb);
1126                 ldb_debug(ldb, LDB_DEBUG_WARNING,
1127                           "rootdse_modify: no schema dn present: (skip ldb_extended call)\n");
1128                 return ldb_next_request(module, req);
1129         }
1130
1131         ret = ldb_extended(ldb, DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID, schema_dn, &ext_res);
1132         if (ret != LDB_SUCCESS) {
1133                 return ldb_operr(ldb);
1134         }
1135
1136         talloc_free(ext_res);
1137         return ldb_module_done(req, NULL, NULL, ret);
1138 }
1139
1140 static int rootdse_add(struct ldb_module *module, struct ldb_request *req)
1141 {
1142         struct ldb_context *ldb = ldb_module_get_ctx(module);
1143         int ret;
1144
1145         ret = rootdse_filter_operations(module, req);
1146         if (ret != LDB_SUCCESS) {
1147                 return ret;
1148         }
1149
1150         ret = rootdse_filter_controls(module, req);
1151         if (ret != LDB_SUCCESS) {
1152                 return ret;
1153         }
1154
1155         /*
1156                 If dn is not "" we should let it pass through
1157         */
1158         if (!ldb_dn_is_null(req->op.add.message->dn)) {
1159                 return ldb_next_request(module, req);
1160         }
1161
1162         ldb_set_errstring(ldb, "rootdse_add: you cannot add a new rootdse entry!");
1163         return LDB_ERR_NAMING_VIOLATION;
1164 }
1165
1166 struct fsmo_transfer_state {
1167         struct ldb_context *ldb;
1168         struct ldb_request *req;
1169 };
1170
1171 /*
1172   called when a FSMO transfer operation has completed
1173  */
1174 static void rootdse_fsmo_transfer_callback(struct tevent_req *treq)
1175 {
1176         struct fsmo_transfer_state *fsmo = tevent_req_callback_data(treq, struct fsmo_transfer_state);
1177         NTSTATUS status;
1178         WERROR werr;
1179         struct ldb_request *req = fsmo->req;
1180         struct ldb_context *ldb = fsmo->ldb;
1181
1182         status = dcerpc_drepl_takeFSMORole_recv(treq, fsmo, &werr);
1183         talloc_free(fsmo);
1184         if (!NT_STATUS_IS_OK(status)) {
1185                 ldb_asprintf_errstring(ldb, "Failed FSMO transfer: %s", nt_errstr(status));
1186                 ldb_module_done(req, NULL, NULL, LDB_ERR_UNAVAILABLE);
1187                 return;
1188         }
1189         if (!W_ERROR_IS_OK(werr)) {
1190                 ldb_asprintf_errstring(ldb, "Failed FSMO transfer: %s", win_errstr(werr));
1191                 ldb_module_done(req, NULL, NULL, LDB_ERR_UNAVAILABLE);
1192                 return;
1193         }
1194
1195         ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
1196 }
1197
1198 static int rootdse_become_master(struct ldb_module *module,
1199                                  struct ldb_request *req,
1200                                  enum drepl_role_master role)
1201 {
1202         struct imessaging_context *msg;
1203         struct ldb_context *ldb = ldb_module_get_ctx(module);
1204         TALLOC_CTX *tmp_ctx = talloc_new(req);
1205         struct loadparm_context *lp_ctx = ldb_get_opaque(ldb, "loadparm");
1206         bool am_rodc;
1207         struct dcerpc_binding_handle *irpc_handle;
1208         int ret;
1209         struct auth_session_info *session_info;
1210         enum security_user_level level;
1211         struct fsmo_transfer_state *fsmo;
1212         struct tevent_req *treq;
1213
1214         session_info = (struct auth_session_info *)ldb_get_opaque(ldb_module_get_ctx(module), "sessionInfo");
1215         level = security_session_user_level(session_info, NULL);
1216         if (level < SECURITY_ADMINISTRATOR) {
1217                 return ldb_error(ldb, LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS, "Denied rootDSE modify for non-administrator");
1218         }
1219
1220         ret = samdb_rodc(ldb, &am_rodc);
1221         if (ret != LDB_SUCCESS) {
1222                 return ldb_error(ldb, ret, "Could not determine if server is RODC.");
1223         }
1224
1225         if (am_rodc) {
1226                 return ldb_error(ldb, LDB_ERR_UNWILLING_TO_PERFORM,
1227                                  "RODC cannot become a role master.");
1228         }
1229
1230         msg = imessaging_client_init(tmp_ctx, lpcfg_imessaging_path(tmp_ctx, lp_ctx),
1231                                     ldb_get_event_context(ldb));
1232         if (!msg) {
1233                 ldb_asprintf_errstring(ldb, "Failed to generate client messaging context in %s", lpcfg_imessaging_path(tmp_ctx, lp_ctx));
1234                 return LDB_ERR_OPERATIONS_ERROR;
1235         }
1236         irpc_handle = irpc_binding_handle_by_name(tmp_ctx, msg,
1237                                                   "dreplsrv",
1238                                                   &ndr_table_irpc);
1239         if (irpc_handle == NULL) {
1240                 return ldb_oom(ldb);
1241         }
1242         fsmo = talloc_zero(req, struct fsmo_transfer_state);
1243         if (fsmo == NULL) {
1244                 return ldb_oom(ldb);
1245         }
1246         fsmo->ldb = ldb;
1247         fsmo->req = req;
1248
1249         /* we send the call asynchronously, as the ldap client is
1250          * expecting to get an error back if the role transfer fails
1251          */
1252
1253         treq = dcerpc_drepl_takeFSMORole_send(req, ldb_get_event_context(ldb), irpc_handle, role);
1254         if (treq == NULL) {
1255                 return ldb_oom(ldb);
1256         }
1257
1258         tevent_req_set_callback(treq, rootdse_fsmo_transfer_callback, fsmo);
1259         return LDB_SUCCESS;
1260 }
1261
1262 static int rootdse_modify(struct ldb_module *module, struct ldb_request *req)
1263 {
1264         struct ldb_context *ldb = ldb_module_get_ctx(module);
1265         int ret;
1266
1267         ret = rootdse_filter_operations(module, req);
1268         if (ret != LDB_SUCCESS) {
1269                 return ret;
1270         }
1271
1272         ret = rootdse_filter_controls(module, req);
1273         if (ret != LDB_SUCCESS) {
1274                 return ret;
1275         }
1276
1277         /*
1278                 If dn is not "" we should let it pass through
1279         */
1280         if (!ldb_dn_is_null(req->op.mod.message->dn)) {
1281                 return ldb_next_request(module, req);
1282         }
1283
1284         /*
1285                 dn is empty so check for schemaUpdateNow attribute
1286                 "The type of modification and values specified in the LDAP modify operation do not matter." MSDN
1287         */
1288         if (ldb_msg_find_element(req->op.mod.message, "schemaUpdateNow")) {
1289                 return rootdse_schemaupdatenow(module, req);
1290         }
1291         if (ldb_msg_find_element(req->op.mod.message, "becomeDomainMaster")) {
1292                 return rootdse_become_master(module, req, DREPL_NAMING_MASTER);
1293         }
1294         if (ldb_msg_find_element(req->op.mod.message, "becomeInfrastructureMaster")) {
1295                 return rootdse_become_master(module, req, DREPL_INFRASTRUCTURE_MASTER);
1296         }
1297         if (ldb_msg_find_element(req->op.mod.message, "becomeRidMaster")) {
1298                 return rootdse_become_master(module, req, DREPL_RID_MASTER);
1299         }
1300         if (ldb_msg_find_element(req->op.mod.message, "becomeSchemaMaster")) {
1301                 return rootdse_become_master(module, req, DREPL_SCHEMA_MASTER);
1302         }
1303         if (ldb_msg_find_element(req->op.mod.message, "becomePdc")) {
1304                 return rootdse_become_master(module, req, DREPL_PDC_MASTER);
1305         }
1306         if (ldb_msg_find_element(req->op.mod.message, "enableOptionalFeature")) {
1307                 return rootdse_enableoptionalfeature(module, req);
1308         }
1309
1310         ldb_set_errstring(ldb, "rootdse_modify: unknown attribute to change!");
1311         return LDB_ERR_UNWILLING_TO_PERFORM;
1312 }
1313
1314 static int rootdse_rename(struct ldb_module *module, struct ldb_request *req)
1315 {
1316         struct ldb_context *ldb = ldb_module_get_ctx(module);
1317         int ret;
1318         const struct GUID *ntds_guid = NULL;
1319         struct ldb_dn *old_ntds_dn;
1320         struct ldb_dn *new_ntds_dn;
1321         struct ldb_message *msg;
1322         bool ok = false;
1323
1324         ret = rootdse_filter_operations(module, req);
1325         if (ret != LDB_SUCCESS) {
1326                 return ret;
1327         }
1328         ret = rootdse_filter_controls(module, req);
1329         if (ret != LDB_SUCCESS) {
1330                 return ret;
1331         }
1332
1333         /*
1334                 If dn is not "" we should let it pass through
1335         */
1336         if (ldb_dn_is_null(req->op.rename.olddn)) {
1337                 ldb_set_errstring(ldb, "rootdse_remove: you cannot rename the rootdse entry!");
1338                 return LDB_ERR_NO_SUCH_OBJECT;
1339         }
1340
1341         old_ntds_dn = samdb_ntds_settings_dn(ldb);
1342         if (ldb_dn_compare_base(req->op.rename.olddn, old_ntds_dn) == 0) {
1343                 ntds_guid = samdb_ntds_objectGUID(ldb);
1344                 if (ntds_guid == NULL) {
1345                         return ldb_error(ldb, LDB_ERR_OPERATIONS_ERROR, "Unable to find the GUID of the NTDS Settings object");
1346                 }
1347         }
1348
1349         if (ntds_guid == NULL) {
1350                 return ldb_next_request(module, req);
1351         }
1352
1353         ret = dsdb_module_rename(module,
1354                                  req->op.rename.olddn,
1355                                  req->op.rename.newdn,
1356                                  DSDB_FLAG_NEXT_MODULE,
1357                                  req);
1358         if (ret != LDB_SUCCESS) {
1359                 /* Error msg is most probably done by module bellow*/
1360                 return ret;
1361         }
1362
1363         ret = dsdb_module_dn_by_guid(module, req, ntds_guid, &new_ntds_dn, req);
1364         if (ret != LDB_SUCCESS) {
1365                 return ldb_error(ldb, LDB_ERR_OPERATIONS_ERROR, "Unable to find the new DN of NTDS Settings object");
1366         }
1367
1368         msg = ldb_msg_new(req);
1369         if (msg == NULL) {
1370                 return ldb_module_oom(module);
1371         }
1372
1373         msg->dn = ldb_dn_new(msg, ldb, "@ROOTDSE");
1374         if (msg->dn == NULL) {
1375                 return ldb_module_oom(module);
1376         }
1377
1378         ret = ldb_msg_add_linearized_dn(msg, "dsServiceName", new_ntds_dn);
1379         if (ret != LDB_SUCCESS) {
1380                 return ldb_module_oom(module);
1381         }
1382
1383         ret = dsdb_replace(ldb, msg, DSDB_FLAG_AS_SYSTEM);
1384         if (ret != LDB_SUCCESS) {
1385                 return ldb_error(ldb, ret, "Unable to update dsServiceName of ROOTDSE");
1386         }
1387
1388         ok = samdb_set_ntds_settings_dn(ldb, new_ntds_dn);
1389         if (!ok) {
1390                 return ldb_error(ldb, LDB_ERR_OPERATIONS_ERROR, "Call to samdb_set_ntds_settings_dn has failed");
1391         }
1392
1393         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
1394 }
1395
1396 static int rootdse_delete(struct ldb_module *module, struct ldb_request *req)
1397 {
1398         struct ldb_context *ldb = ldb_module_get_ctx(module);
1399         int ret;
1400
1401         ret = rootdse_filter_operations(module, req);
1402         if (ret != LDB_SUCCESS) {
1403                 return ret;
1404         }
1405
1406         ret = rootdse_filter_controls(module, req);
1407         if (ret != LDB_SUCCESS) {
1408                 return ret;
1409         }
1410
1411         /*
1412                 If dn is not "" we should let it pass through
1413         */
1414         if (!ldb_dn_is_null(req->op.del.dn)) {
1415                 return ldb_next_request(module, req);
1416         }
1417
1418         ldb_set_errstring(ldb, "rootdse_remove: you cannot delete the rootdse entry!");
1419         return LDB_ERR_NO_SUCH_OBJECT;
1420 }
1421
1422 static int rootdse_extended(struct ldb_module *module, struct ldb_request *req)
1423 {
1424         int ret;
1425
1426         ret = rootdse_filter_operations(module, req);
1427         if (ret != LDB_SUCCESS) {
1428                 return ret;
1429         }
1430
1431         ret = rootdse_filter_controls(module, req);
1432         if (ret != LDB_SUCCESS) {
1433                 return ret;
1434         }
1435
1436         return ldb_next_request(module, req);
1437 }
1438
1439 static const struct ldb_module_ops ldb_rootdse_module_ops = {
1440         .name           = "rootdse",
1441         .init_context   = rootdse_init,
1442         .search         = rootdse_search,
1443         .request        = rootdse_request,
1444         .add            = rootdse_add,
1445         .modify         = rootdse_modify,
1446         .rename         = rootdse_rename,
1447         .extended       = rootdse_extended,
1448         .del            = rootdse_delete
1449 };
1450
1451 int ldb_rootdse_module_init(const char *version)
1452 {
1453         LDB_MODULE_CHECK_VERSION(version);
1454         return ldb_register_module(&ldb_rootdse_module_ops);
1455 }