s4-dsdb: isGlobalCatalogReady should be shown by default
[ira/wip.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 "lib/ldb/include/ldb.h"
25 #include "lib/ldb/include/ldb_module.h"
26 #include "system/time.h"
27 #include "dsdb/samdb/samdb.h"
28 #include "version.h"
29
30 struct private_data {
31         int num_controls;
32         char **controls;
33         int num_partitions;
34         struct ldb_dn **partitions;
35 };
36
37 /*
38   return 1 if a specific attribute has been requested
39 */
40 static int do_attribute(const char * const *attrs, const char *name)
41 {
42         return attrs == NULL ||
43                 ldb_attr_in_list(attrs, name) ||
44                 ldb_attr_in_list(attrs, "*");
45 }
46
47 static int do_attribute_explicit(const char * const *attrs, const char *name)
48 {
49         return attrs != NULL && ldb_attr_in_list(attrs, name);
50 }
51
52
53 /*
54   expand a DN attribute to include extended DN information if requested
55  */
56 static int expand_dn_in_message(struct ldb_module *module, struct ldb_message *msg,
57                                 const char *attrname, struct ldb_control *edn_control,
58                                 struct ldb_request *req)
59 {
60         struct ldb_dn *dn, *dn2;
61         struct ldb_val *v;
62         int ret;
63         struct ldb_request *req2;
64         char *dn_string;
65         const char *no_attrs[] = { NULL };
66         struct ldb_result *res;
67         struct ldb_extended_dn_control *edn;
68         TALLOC_CTX *tmp_ctx = talloc_new(req);
69         struct ldb_context *ldb;
70         int edn_type = 0;
71
72         ldb = ldb_module_get_ctx(module);
73
74         edn = talloc_get_type(edn_control->data, struct ldb_extended_dn_control);
75         if (edn) {
76                 edn_type = edn->type;
77         }
78
79         v = discard_const_p(struct ldb_val, ldb_msg_find_ldb_val(msg, attrname));
80         if (v == NULL) {
81                 talloc_free(tmp_ctx);
82                 return 0;
83         }
84
85         dn_string = talloc_strndup(tmp_ctx, (const char *)v->data, v->length);
86         if (dn_string == NULL) {
87                 talloc_free(tmp_ctx);
88                 return LDB_ERR_OPERATIONS_ERROR;
89         }
90
91         res = talloc_zero(tmp_ctx, struct ldb_result);
92         if (res == NULL) {
93                 talloc_free(tmp_ctx);
94                 return LDB_ERR_OPERATIONS_ERROR;
95         }
96
97         dn = ldb_dn_new(tmp_ctx, ldb, dn_string);
98         if (!ldb_dn_validate(dn)) {
99                 talloc_free(tmp_ctx);
100                 return LDB_ERR_OPERATIONS_ERROR;
101         }
102
103         ret = ldb_build_search_req(&req2, ldb, tmp_ctx,
104                                    dn,
105                                    LDB_SCOPE_BASE,
106                                    NULL,
107                                    no_attrs,
108                                    NULL,
109                                    res, ldb_search_default_callback,
110                                    req);
111         if (ret != LDB_SUCCESS) {
112                 talloc_free(tmp_ctx);
113                 return ret;
114         }
115
116
117         ret = ldb_request_add_control(req2,
118                                       LDB_CONTROL_EXTENDED_DN_OID,
119                                       edn_control->critical, edn);
120         if (ret != LDB_SUCCESS) {
121                 talloc_free(tmp_ctx);
122                 return ret;
123         }
124
125         ret = ldb_next_request(module, req2);
126         if (ret == LDB_SUCCESS) {
127                 ret = ldb_wait(req2->handle, LDB_WAIT_ALL);
128         }
129         if (ret != LDB_SUCCESS) {
130                 talloc_free(tmp_ctx);
131                 return ret;
132         }
133
134         if (!res || res->count != 1) {
135                 talloc_free(tmp_ctx);
136                 return LDB_ERR_OPERATIONS_ERROR;
137         }
138
139         dn2 = res->msgs[0]->dn;
140
141         v->data = (uint8_t *)ldb_dn_get_extended_linearized(msg->elements, dn2, edn_type);
142         v->length = strlen((char *)v->data);
143
144         if (v->data == NULL) {
145                 talloc_free(tmp_ctx);
146                 return LDB_ERR_OPERATIONS_ERROR;
147         }
148
149         talloc_free(tmp_ctx);
150
151         return 0;
152 }       
153                         
154
155 /*
156   add dynamically generated attributes to rootDSE result
157 */
158 static int rootdse_add_dynamic(struct ldb_module *module, struct ldb_message *msg, 
159                                const char * const *attrs, struct ldb_request *req)
160 {
161         struct ldb_context *ldb;
162         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
163         char **server_sasl;
164         const struct dsdb_schema *schema;
165         int *val;
166         struct ldb_control *edn_control;
167         const char *dn_attrs[] = {
168                 "configurationNamingContext",
169                 "defaultNamingContext",
170                 "dsServiceName",
171                 "rootDomainNamingContext",
172                 "schemaNamingContext",
173                 "serverName",
174                 NULL
175         };
176
177         ldb = ldb_module_get_ctx(module);
178         schema = dsdb_get_schema(ldb);
179
180         msg->dn = ldb_dn_new(msg, ldb, NULL);
181
182         /* don't return the distinduishedName, cn and name attributes */
183         ldb_msg_remove_attr(msg, "distinguishedName");
184         ldb_msg_remove_attr(msg, "cn");
185         ldb_msg_remove_attr(msg, "name");
186
187         if (do_attribute(attrs, "currentTime")) {
188                 if (ldb_msg_add_steal_string(msg, "currentTime", 
189                                              ldb_timestring(msg, time(NULL))) != 0) {
190                         goto failed;
191                 }
192         }
193
194         if (priv && do_attribute(attrs, "supportedControl")) {
195                 int i;
196                 for (i = 0; i < priv->num_controls; i++) {
197                         char *control = talloc_strdup(msg, priv->controls[i]);
198                         if (!control) {
199                                 goto failed;
200                         }
201                         if (ldb_msg_add_steal_string(msg, "supportedControl",
202                                                      control) != 0) {
203                                 goto failed;
204                         }
205                 }
206         }
207
208         if (priv && do_attribute(attrs, "namingContexts")) {
209                 int i;
210                 for (i = 0; i < priv->num_partitions; i++) {
211                         struct ldb_dn *dn = priv->partitions[i];
212                         if (ldb_msg_add_steal_string(msg, "namingContexts",
213                                                      ldb_dn_alloc_linearized(msg, dn)) != 0) {
214                                 goto failed;
215                         }
216                 }
217         }
218
219         server_sasl = talloc_get_type(ldb_get_opaque(ldb, "supportedSASLMechanims"), 
220                                        char *);
221         if (server_sasl && do_attribute(attrs, "supportedSASLMechanisms")) {
222                 int i;
223                 for (i = 0; server_sasl && server_sasl[i]; i++) {
224                         char *sasl_name = talloc_strdup(msg, server_sasl[i]);
225                         if (!sasl_name) {
226                                 goto failed;
227                         }
228                         if (ldb_msg_add_steal_string(msg, "supportedSASLMechanisms",
229                                                      sasl_name) != 0) {
230                                 goto failed;
231                         }
232                 }
233         }
234
235         if (do_attribute(attrs, "highestCommittedUSN")) {
236                 uint64_t seq_num;
237                 int ret = ldb_sequence_number(ldb, LDB_SEQ_HIGHEST_SEQ, &seq_num);
238                 if (ret == LDB_SUCCESS) {
239                         if (ldb_msg_add_fmt(msg, "highestCommittedUSN", 
240                                             "%llu", (unsigned long long)seq_num) != 0) {
241                                 goto failed;
242                         }
243                 }
244         }
245
246         if (schema && do_attribute_explicit(attrs, "dsSchemaAttrCount")) {
247                 struct dsdb_attribute *cur;
248                 uint32_t n = 0;
249
250                 for (cur = schema->attributes; cur; cur = cur->next) {
251                         n++;
252                 }
253
254                 if (ldb_msg_add_fmt(msg, "dsSchemaAttrCount", 
255                                     "%u", n) != 0) {
256                         goto failed;
257                 }
258         }
259
260         if (schema && do_attribute_explicit(attrs, "dsSchemaClassCount")) {
261                 struct dsdb_class *cur;
262                 uint32_t n = 0;
263
264                 for (cur = schema->classes; cur; cur = cur->next) {
265                         n++;
266                 }
267
268                 if (ldb_msg_add_fmt(msg, "dsSchemaClassCount", 
269                                     "%u", n) != 0) {
270                         goto failed;
271                 }
272         }
273
274         if (schema && do_attribute_explicit(attrs, "dsSchemaPrefixCount")) {
275                 if (ldb_msg_add_fmt(msg, "dsSchemaPrefixCount", 
276                                     "%u", schema->prefixmap->length) != 0) {
277                         goto failed;
278                 }
279         }
280
281         if (do_attribute_explicit(attrs, "validFSMOs")) {
282                 const struct dsdb_naming_fsmo *naming_fsmo;
283                 const struct dsdb_pdc_fsmo *pdc_fsmo;
284                 const char *dn_str;
285
286                 if (schema && schema->fsmo.we_are_master) {
287                         dn_str = ldb_dn_get_linearized(samdb_schema_dn(ldb));
288                         if (dn_str && dn_str[0]) {
289                                 if (ldb_msg_add_fmt(msg, "validFSMOs", "%s", dn_str) != 0) {
290                                         goto failed;
291                                 }
292                         }
293                 }
294
295                 naming_fsmo = talloc_get_type(ldb_get_opaque(ldb, "dsdb_naming_fsmo"),
296                                               struct dsdb_naming_fsmo);
297                 if (naming_fsmo && naming_fsmo->we_are_master) {
298                         dn_str = ldb_dn_get_linearized(samdb_partitions_dn(ldb, msg));
299                         if (dn_str && dn_str[0]) {
300                                 if (ldb_msg_add_fmt(msg, "validFSMOs", "%s", dn_str) != 0) {
301                                         goto failed;
302                                 }
303                         }
304                 }
305
306                 pdc_fsmo = talloc_get_type(ldb_get_opaque(ldb, "dsdb_pdc_fsmo"),
307                                            struct dsdb_pdc_fsmo);
308                 if (pdc_fsmo && pdc_fsmo->we_are_master) {
309                         dn_str = ldb_dn_get_linearized(samdb_base_dn(ldb));
310                         if (dn_str && dn_str[0]) {
311                                 if (ldb_msg_add_fmt(msg, "validFSMOs", "%s", dn_str) != 0) {
312                                         goto failed;
313                                 }
314                         }
315                 }
316         }
317
318         if (do_attribute_explicit(attrs, "vendorVersion")) {
319                 if (ldb_msg_add_fmt(msg, "vendorVersion", 
320                                     "%s", SAMBA_VERSION_STRING) != 0) {
321                         goto failed;
322                 }
323         }
324
325         if (priv && do_attribute(attrs, "domainFunctionality")) {
326                 if (ldb_msg_add_fmt(msg, "domainFunctionality", 
327                                     "%d", dsdb_functional_level(ldb)) != 0) {
328                         goto failed;
329                 }
330         }
331
332         if (priv && do_attribute(attrs, "forestFunctionality")
333             && (val = talloc_get_type(ldb_get_opaque(ldb, "forestFunctionality"), int))) {
334                 if (ldb_msg_add_fmt(msg, "forestFunctionality", 
335                                     "%d", *val) != 0) {
336                         goto failed;
337                 }
338         }
339
340         if (priv && do_attribute(attrs, "domainControllerFunctionality")
341             && (val = talloc_get_type(ldb_get_opaque(ldb, "domainControllerFunctionality"), int))) {
342                 if (ldb_msg_add_fmt(msg, "domainControllerFunctionality", 
343                                     "%d", *val) != 0) {
344                         goto failed;
345                 }
346         }
347
348         edn_control = ldb_request_get_control(req, LDB_CONTROL_EXTENDED_DN_OID);
349
350         /* if the client sent us the EXTENDED_DN control then we need
351            to expand the DNs to have GUID and SID. W2K8 join relies on
352            this */
353         if (edn_control) {
354                 int i, ret;
355                 for (i=0; dn_attrs[i]; i++) {
356                         if (!do_attribute(attrs, dn_attrs[i])) continue;
357                         ret = expand_dn_in_message(module, msg, dn_attrs[i],
358                                                    edn_control, req);
359                         if (ret != LDB_SUCCESS) {
360                                 DEBUG(0,(__location__ ": Failed to expand DN in rootDSE for %s\n",
361                                          dn_attrs[i]));
362                                 goto failed;
363                         }
364                 }
365         }
366
367         if (do_attribute(attrs, "isGlobalCatalogReady")) {
368                 /* MS-ADTS 3.1.1.3.2.10
369                    Note, we should only return true here is we have
370                    completed at least one synchronisation. As both
371                    provision and vampire do a full sync, this means we
372                    can return true is the gc bit is set in the NTDSDSA
373                    options */
374                 if (ldb_msg_add_fmt(msg, "isGlobalCatalogReady",
375                                     "%s", samdb_is_gc(ldb)?"TRUE":"FALSE") != 0) {
376                         goto failed;
377                 }
378         }
379
380         /* TODO: lots more dynamic attributes should be added here */
381
382         return LDB_SUCCESS;
383
384 failed:
385         return LDB_ERR_OPERATIONS_ERROR;
386 }
387
388 /*
389   handle search requests
390 */
391
392 struct rootdse_context {
393         struct ldb_module *module;
394         struct ldb_request *req;
395 };
396
397 static struct rootdse_context *rootdse_init_context(struct ldb_module *module,
398                                                     struct ldb_request *req)
399 {
400         struct ldb_context *ldb;
401         struct rootdse_context *ac;
402
403         ldb = ldb_module_get_ctx(module);
404
405         ac = talloc_zero(req, struct rootdse_context);
406         if (ac == NULL) {
407                 ldb_set_errstring(ldb, "Out of Memory");
408                 return NULL;
409         }
410
411         ac->module = module;
412         ac->req = req;
413
414         return ac;
415 }
416
417 static int rootdse_callback(struct ldb_request *req, struct ldb_reply *ares)
418 {
419         struct rootdse_context *ac;
420         int ret;
421
422         ac = talloc_get_type(req->context, struct rootdse_context);
423
424         if (!ares) {
425                 return ldb_module_done(ac->req, NULL, NULL,
426                                         LDB_ERR_OPERATIONS_ERROR);
427         }
428         if (ares->error != LDB_SUCCESS) {
429                 return ldb_module_done(ac->req, ares->controls,
430                                         ares->response, ares->error);
431         }
432
433         switch (ares->type) {
434         case LDB_REPLY_ENTRY:
435                 /*
436                  * if the client explicit asks for the 'netlogon' attribute
437                  * the reply_entry needs to be skipped
438                  */
439                 if (ac->req->op.search.attrs &&
440                     ldb_attr_in_list(ac->req->op.search.attrs, "netlogon")) {
441                         talloc_free(ares);
442                         return LDB_SUCCESS;
443                 }
444
445                 /* for each record returned post-process to add any dynamic
446                    attributes that have been asked for */
447                 ret = rootdse_add_dynamic(ac->module, ares->message,
448                                           ac->req->op.search.attrs, ac->req);
449                 if (ret != LDB_SUCCESS) {
450                         talloc_free(ares);
451                         return ldb_module_done(ac->req, NULL, NULL, ret);
452                 }
453
454                 return ldb_module_send_entry(ac->req, ares->message, ares->controls);
455
456         case LDB_REPLY_REFERRAL:
457                 /* should we allow the backend to return referrals in this case
458                  * ?? */
459                 break;
460
461         case LDB_REPLY_DONE:
462                 return ldb_module_done(ac->req, ares->controls,
463                                         ares->response, ares->error);
464         }
465
466         talloc_free(ares);
467         return LDB_SUCCESS;
468 }
469
470 static int rootdse_search(struct ldb_module *module, struct ldb_request *req)
471 {
472         struct ldb_context *ldb;
473         struct rootdse_context *ac;
474         struct ldb_request *down_req;
475         int ret;
476
477         ldb = ldb_module_get_ctx(module);
478
479         /* see if its for the rootDSE - only a base search on the "" DN qualifies */
480         if (!(req->op.search.scope == LDB_SCOPE_BASE && ldb_dn_is_null(req->op.search.base))) {
481                 /* Otherwise, pass down to the rest of the stack */
482                 return ldb_next_request(module, req);
483         }
484
485         ac = rootdse_init_context(module, req);
486         if (ac == NULL) {
487                 return LDB_ERR_OPERATIONS_ERROR;
488         }
489
490         /* in our db we store the rootDSE with a DN of @ROOTDSE */
491         ret = ldb_build_search_req(&down_req, ldb, ac,
492                                         ldb_dn_new(ac, ldb, "@ROOTDSE"),
493                                         LDB_SCOPE_BASE,
494                                         NULL,
495                                         req->op.search.attrs,
496                                         NULL,/* for now skip the controls from the client */
497                                         ac, rootdse_callback,
498                                         req);
499         if (ret != LDB_SUCCESS) {
500                 return ret;
501         }
502
503         return ldb_next_request(module, down_req);
504 }
505
506 static int rootdse_register_control(struct ldb_module *module, struct ldb_request *req)
507 {
508         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
509         char **list;
510
511         list = talloc_realloc(priv, priv->controls, char *, priv->num_controls + 1);
512         if (!list) {
513                 return LDB_ERR_OPERATIONS_ERROR;
514         }
515
516         list[priv->num_controls] = talloc_strdup(list, req->op.reg_control.oid);
517         if (!list[priv->num_controls]) {
518                 return LDB_ERR_OPERATIONS_ERROR;
519         }
520
521         priv->num_controls += 1;
522         priv->controls = list;
523
524         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
525 }
526
527 static int rootdse_register_partition(struct ldb_module *module, struct ldb_request *req)
528 {
529         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
530         struct ldb_dn **list;
531
532         list = talloc_realloc(priv, priv->partitions, struct ldb_dn *, priv->num_partitions + 1);
533         if (!list) {
534                 return LDB_ERR_OPERATIONS_ERROR;
535         }
536
537         list[priv->num_partitions] = ldb_dn_copy(list, req->op.reg_partition.dn);
538         if (!list[priv->num_partitions]) {
539                 return LDB_ERR_OPERATIONS_ERROR;
540         }
541
542         priv->num_partitions += 1;
543         priv->partitions = list;
544
545         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
546 }
547
548
549 static int rootdse_request(struct ldb_module *module, struct ldb_request *req)
550 {
551         switch (req->operation) {
552
553         case LDB_REQ_REGISTER_CONTROL:
554                 return rootdse_register_control(module, req);
555         case LDB_REQ_REGISTER_PARTITION:
556                 return rootdse_register_partition(module, req);
557
558         default:
559                 break;
560         }
561         return ldb_next_request(module, req);
562 }
563
564 static int rootdse_init(struct ldb_module *module)
565 {
566         int ret;
567         struct ldb_context *ldb;
568         struct ldb_result *res;
569         struct private_data *data;
570         const char *attrs[] = { "msDS-Behavior-Version", NULL };
571         const char *ds_attrs[] = { "dsServiceName", NULL };
572         TALLOC_CTX *mem_ctx;
573
574         ldb = ldb_module_get_ctx(module);
575
576         data = talloc_zero(module, struct private_data);
577         if (data == NULL) {
578                 return -1;
579         }
580
581         data->num_controls = 0;
582         data->controls = NULL;
583         data->num_partitions = 0;
584         data->partitions = NULL;
585         ldb_module_set_private(module, data);
586
587         ldb_set_default_dns(ldb);
588
589         ret = ldb_next_init(module);
590
591         if (ret) {
592                 return ret;
593         }
594
595         mem_ctx = talloc_new(data);
596         if (!mem_ctx) {
597                 ldb_oom(ldb);
598                 return LDB_ERR_OPERATIONS_ERROR;
599         }
600
601         /* Now that the partitions are set up, do a search for:
602            - domainControllerFunctionality
603            - domainFunctionality
604            - forestFunctionality
605
606            Then stuff these values into an opaque
607         */
608         ret = ldb_search(ldb, mem_ctx, &res,
609                          ldb_get_default_basedn(ldb),
610                          LDB_SCOPE_BASE, attrs, NULL);
611         if (ret == LDB_SUCCESS && res->count == 1) {
612                 int domain_behaviour_version
613                         = ldb_msg_find_attr_as_int(res->msgs[0], 
614                                                    "msDS-Behavior-Version", -1);
615                 if (domain_behaviour_version != -1) {
616                         int *val = talloc(ldb, int);
617                         if (!val) {
618                                 ldb_oom(ldb);
619                                 talloc_free(mem_ctx);
620                                 return LDB_ERR_OPERATIONS_ERROR;
621                         }
622                         *val = domain_behaviour_version;
623                         ret = ldb_set_opaque(ldb, "domainFunctionality", val);
624                         if (ret != LDB_SUCCESS) {
625                                 talloc_free(mem_ctx);
626                                 return ret;
627                         }
628                 }
629         }
630
631         ret = ldb_search(ldb, mem_ctx, &res,
632                          samdb_partitions_dn(ldb, mem_ctx),
633                          LDB_SCOPE_BASE, attrs, NULL);
634         if (ret == LDB_SUCCESS && res->count == 1) {
635                 int forest_behaviour_version
636                         = ldb_msg_find_attr_as_int(res->msgs[0], 
637                                                    "msDS-Behavior-Version", -1);
638                 if (forest_behaviour_version != -1) {
639                         int *val = talloc(ldb, int);
640                         if (!val) {
641                                 ldb_oom(ldb);
642                                 talloc_free(mem_ctx);
643                                 return LDB_ERR_OPERATIONS_ERROR;
644                         }
645                         *val = forest_behaviour_version;
646                         ret = ldb_set_opaque(ldb, "forestFunctionality", val);
647                         if (ret != LDB_SUCCESS) {
648                                 talloc_free(mem_ctx);
649                                 return ret;
650                         }
651                 }
652         }
653
654         ret = ldb_search(ldb, mem_ctx, &res,
655                          ldb_dn_new(mem_ctx, ldb, ""),
656                          LDB_SCOPE_BASE, ds_attrs, NULL);
657         if (ret == LDB_SUCCESS && res->count == 1) {
658                 struct ldb_dn *ds_dn
659                         = ldb_msg_find_attr_as_dn(ldb, mem_ctx, res->msgs[0], 
660                                                   "dsServiceName");
661                 if (ds_dn) {
662                         ret = ldb_search(ldb, mem_ctx, &res, ds_dn, 
663                                          LDB_SCOPE_BASE, attrs, NULL);
664                         if (ret == LDB_SUCCESS && res->count == 1) {
665                                 int domain_controller_behaviour_version
666                                         = ldb_msg_find_attr_as_int(res->msgs[0], 
667                                                                    "msDS-Behavior-Version", -1);
668                                 if (domain_controller_behaviour_version != -1) {
669                                         int *val = talloc(ldb, int);
670                                         if (!val) {
671                                                 ldb_oom(ldb);
672                                                 talloc_free(mem_ctx);
673                                         return LDB_ERR_OPERATIONS_ERROR;
674                                         }
675                                         *val = domain_controller_behaviour_version;
676                                         ret = ldb_set_opaque(ldb, 
677                                                              "domainControllerFunctionality", val);
678                                         if (ret != LDB_SUCCESS) {
679                                                 talloc_free(mem_ctx);
680                                                 return ret;
681                                         }
682                                 }
683                         }
684                 }
685         }
686
687         talloc_free(mem_ctx);
688         
689         return LDB_SUCCESS;
690 }
691
692 static int rootdse_modify(struct ldb_module *module, struct ldb_request *req)
693 {
694         struct ldb_context *ldb;
695         struct ldb_result *ext_res;
696         int ret;
697         struct ldb_dn *schema_dn;
698         struct ldb_message_element *schemaUpdateNowAttr;
699         
700         /*
701                 If dn is not "" we should let it pass through
702         */
703         if (!ldb_dn_is_null(req->op.mod.message->dn)) {
704                 return ldb_next_request(module, req);
705         }
706
707         ldb = ldb_module_get_ctx(module);
708
709         /*
710                 dn is empty so check for schemaUpdateNow attribute
711                 "The type of modification and values specified in the LDAP modify operation do not matter." MSDN
712         */
713         schemaUpdateNowAttr = ldb_msg_find_element(req->op.mod.message, "schemaUpdateNow");
714         if (!schemaUpdateNowAttr) {
715                 return LDB_ERR_OPERATIONS_ERROR;
716         }
717
718         schema_dn = samdb_schema_dn(ldb);
719         if (!schema_dn) {
720                 ldb_reset_err_string(ldb);
721                 ldb_debug(ldb, LDB_DEBUG_WARNING,
722                           "rootdse_modify: no schema dn present: (skip ldb_extended call)\n");
723                 return ldb_next_request(module, req);
724         }
725
726         ret = ldb_extended(ldb, DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID, schema_dn, &ext_res);
727         if (ret != LDB_SUCCESS) {
728                 return LDB_ERR_OPERATIONS_ERROR;
729         }
730         
731         talloc_free(ext_res);
732         return ldb_module_done(req, NULL, NULL, ret);
733 }
734
735 _PUBLIC_ const struct ldb_module_ops ldb_rootdse_module_ops = {
736         .name           = "rootdse",
737         .init_context   = rootdse_init,
738         .search         = rootdse_search,
739         .request        = rootdse_request,
740         .modify         = rootdse_modify
741 };