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
 368         /* TODO: lots more dynamic attributes should be added here */
 369
 370         return LDB_SUCCESS;
 371
 372 failed:
 373         return LDB_ERR_OPERATIONS_ERROR;
 374 }
 375
 376 /*
 377   handle search requests
 378 */
 379
 380 struct rootdse_context {
 381         struct ldb_module *module;
 382         struct ldb_request *req;
 383 };
 384
 385 static struct rootdse_context *rootdse_init_context(struct ldb_module *module,
 386                                                     struct ldb_request *req)
 387 {
 388         struct ldb_context *ldb;
 389         struct rootdse_context *ac;
 390
 391         ldb = ldb_module_get_ctx(module);
 392
 393         ac = talloc_zero(req, struct rootdse_context);
 394         if (ac == NULL) {
 395                 ldb_set_errstring(ldb, "Out of Memory");
 396                 return NULL;
 397         }
 398
 399         ac->module = module;
 400         ac->req = req;
 401
 402         return ac;
 403 }
 404
 405 static int rootdse_callback(struct ldb_request *req, struct ldb_reply *ares)
 406 {
 407         struct rootdse_context *ac;
 408         int ret;
 409
 410         ac = talloc_get_type(req->context, struct rootdse_context);
 411
 412         if (!ares) {
 413                 return ldb_module_done(ac->req, NULL, NULL,
 414                                         LDB_ERR_OPERATIONS_ERROR);
 415         }
 416         if (ares->error != LDB_SUCCESS) {
 417                 return ldb_module_done(ac->req, ares->controls,
 418                                         ares->response, ares->error);
 419         }
 420
 421         switch (ares->type) {
 422         case LDB_REPLY_ENTRY:
 423                 /*
 424                  * if the client explicit asks for the 'netlogon' attribute
 425                  * the reply_entry needs to be skipped
 426                  */
 427                 if (ac->req->op.search.attrs &&
 428                     ldb_attr_in_list(ac->req->op.search.attrs, "netlogon")) {
 429                         talloc_free(ares);
 430                         return LDB_SUCCESS;
 431                 }
 432
 433                 /* for each record returned post-process to add any dynamic
 434                    attributes that have been asked for */
 435                 ret = rootdse_add_dynamic(ac->module, ares->message,
 436                                           ac->req->op.search.attrs, ac->req);
 437                 if (ret != LDB_SUCCESS) {
 438                         talloc_free(ares);
 439                         return ldb_module_done(ac->req, NULL, NULL, ret);
 440                 }
 441
 442                 return ldb_module_send_entry(ac->req, ares->message, ares->controls);
 443
 444         case LDB_REPLY_REFERRAL:
 445                 /* should we allow the backend to return referrals in this case
 446                  * ?? */
 447                 break;
 448
 449         case LDB_REPLY_DONE:
 450                 return ldb_module_done(ac->req, ares->controls,
 451                                         ares->response, ares->error);
 452         }
 453
 454         talloc_free(ares);
 455         return LDB_SUCCESS;
 456 }
 457
 458 static int rootdse_search(struct ldb_module *module, struct ldb_request *req)
 459 {
 460         struct ldb_context *ldb;
 461         struct rootdse_context *ac;
 462         struct ldb_request *down_req;
 463         int ret;
 464
 465         ldb = ldb_module_get_ctx(module);
 466
 467         /* see if its for the rootDSE - only a base search on the "" DN qualifies */
 468         if (!(req->op.search.scope == LDB_SCOPE_BASE && ldb_dn_is_null(req->op.search.base))) {
 469                 /* Otherwise, pass down to the rest of the stack */
 470                 return ldb_next_request(module, req);
 471         }
 472
 473         ac = rootdse_init_context(module, req);
 474         if (ac == NULL) {
 475                 return LDB_ERR_OPERATIONS_ERROR;
 476         }
 477
 478         /* in our db we store the rootDSE with a DN of @ROOTDSE */
 479         ret = ldb_build_search_req(&down_req, ldb, ac,
 480                                         ldb_dn_new(ac, ldb, "@ROOTDSE"),
 481                                         LDB_SCOPE_BASE,
 482                                         NULL,
 483                                         req->op.search.attrs,
 484                                         NULL,/* for now skip the controls from the client */
 485                                         ac, rootdse_callback,
 486                                         req);
 487         if (ret != LDB_SUCCESS) {
 488                 return ret;
 489         }
 490
 491         return ldb_next_request(module, down_req);
 492 }
 493
 494 static int rootdse_register_control(struct ldb_module *module, struct ldb_request *req)
 495 {
 496         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
 497         char **list;
 498
 499         list = talloc_realloc(priv, priv->controls, char *, priv->num_controls + 1);
 500         if (!list) {
 501                 return LDB_ERR_OPERATIONS_ERROR;
 502         }
 503
 504         list[priv->num_controls] = talloc_strdup(list, req->op.reg_control.oid);
 505         if (!list[priv->num_controls]) {
 506                 return LDB_ERR_OPERATIONS_ERROR;
 507         }
 508
 509         priv->num_controls += 1;
 510         priv->controls = list;
 511
 512         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
 513 }
 514
 515 static int rootdse_register_partition(struct ldb_module *module, struct ldb_request *req)
 516 {
 517         struct private_data *priv = talloc_get_type(ldb_module_get_private(module), struct private_data);
 518         struct ldb_dn **list;
 519
 520         list = talloc_realloc(priv, priv->partitions, struct ldb_dn *, priv->num_partitions + 1);
 521         if (!list) {
 522                 return LDB_ERR_OPERATIONS_ERROR;
 523         }
 524
 525         list[priv->num_partitions] = ldb_dn_copy(list, req->op.reg_partition.dn);
 526         if (!list[priv->num_partitions]) {
 527                 return LDB_ERR_OPERATIONS_ERROR;
 528         }
 529
 530         priv->num_partitions += 1;
 531         priv->partitions = list;
 532
 533         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
 534 }
 535
 536
 537 static int rootdse_request(struct ldb_module *module, struct ldb_request *req)
 538 {
 539         switch (req->operation) {
 540
 541         case LDB_REQ_REGISTER_CONTROL:
 542                 return rootdse_register_control(module, req);
 543         case LDB_REQ_REGISTER_PARTITION:
 544                 return rootdse_register_partition(module, req);
 545
 546         default:
 547                 break;
 548         }
 549         return ldb_next_request(module, req);
 550 }
 551
 552 static int rootdse_init(struct ldb_module *module)
 553 {
 554         int ret;
 555         struct ldb_context *ldb;
 556         struct ldb_result *res;
 557         struct private_data *data;
 558         const char *attrs[] = { "msDS-Behavior-Version", NULL };
 559         const char *ds_attrs[] = { "dsServiceName", NULL };
 560         TALLOC_CTX *mem_ctx;
 561
 562         ldb = ldb_module_get_ctx(module);
 563
 564         data = talloc_zero(module, struct private_data);
 565         if (data == NULL) {
 566                 return -1;
 567         }
 568
 569         data->num_controls = 0;
 570         data->controls = NULL;
 571         data->num_partitions = 0;
 572         data->partitions = NULL;
 573         ldb_module_set_private(module, data);
 574
 575         ldb_set_default_dns(ldb);
 576
 577         ret = ldb_next_init(module);
 578
 579         if (ret) {
 580                 return ret;
 581         }
 582
 583         mem_ctx = talloc_new(data);
 584         if (!mem_ctx) {
 585                 ldb_oom(ldb);
 586                 return LDB_ERR_OPERATIONS_ERROR;
 587         }
 588
 589         /* Now that the partitions are set up, do a search for:
 590            - domainControllerFunctionality
 591            - domainFunctionality
 592            - forestFunctionality
 593
 594            Then stuff these values into an opaque
 595         */
 596         ret = ldb_search(ldb, mem_ctx, &res,
 597                          ldb_get_default_basedn(ldb),
 598                          LDB_SCOPE_BASE, attrs, NULL);
 599         if (ret == LDB_SUCCESS && res->count == 1) {
 600                 int domain_behaviour_version
 601                         = ldb_msg_find_attr_as_int(res->msgs[0],
 602                                                    "msDS-Behavior-Version", -1);
 603                 if (domain_behaviour_version != -1) {
 604                         int *val = talloc(ldb, int);
 605                         if (!val) {
 606                                 ldb_oom(ldb);
 607                                 talloc_free(mem_ctx);
 608                                 return LDB_ERR_OPERATIONS_ERROR;
 609                         }
 610                         *val = domain_behaviour_version;
 611                         ret = ldb_set_opaque(ldb, "domainFunctionality", val);
 612                         if (ret != LDB_SUCCESS) {
 613                                 talloc_free(mem_ctx);
 614                                 return ret;
 615                         }
 616                 }
 617         }
 618
 619         ret = ldb_search(ldb, mem_ctx, &res,
 620                          samdb_partitions_dn(ldb, mem_ctx),
 621                          LDB_SCOPE_BASE, attrs, NULL);
 622         if (ret == LDB_SUCCESS && res->count == 1) {
 623                 int forest_behaviour_version
 624                         = ldb_msg_find_attr_as_int(res->msgs[0],
 625                                                    "msDS-Behavior-Version", -1);
 626                 if (forest_behaviour_version != -1) {
 627                         int *val = talloc(ldb, int);
 628                         if (!val) {
 629                                 ldb_oom(ldb);
 630                                 talloc_free(mem_ctx);
 631                                 return LDB_ERR_OPERATIONS_ERROR;
 632                         }
 633                         *val = forest_behaviour_version;
 634                         ret = ldb_set_opaque(ldb, "forestFunctionality", val);
 635                         if (ret != LDB_SUCCESS) {
 636                                 talloc_free(mem_ctx);
 637                                 return ret;
 638                         }
 639                 }
 640         }
 641
 642         ret = ldb_search(ldb, mem_ctx, &res,
 643                          ldb_dn_new(mem_ctx, ldb, ""),
 644                          LDB_SCOPE_BASE, ds_attrs, NULL);
 645         if (ret == LDB_SUCCESS && res->count == 1) {
 646                 struct ldb_dn *ds_dn
 647                         = ldb_msg_find_attr_as_dn(ldb, mem_ctx, res->msgs[0],
 648                                                   "dsServiceName");
 649                 if (ds_dn) {
 650                         ret = ldb_search(ldb, mem_ctx, &res, ds_dn,
 651                                          LDB_SCOPE_BASE, attrs, NULL);
 652                         if (ret == LDB_SUCCESS && res->count == 1) {
 653                                 int domain_controller_behaviour_version
 654                                         = ldb_msg_find_attr_as_int(res->msgs[0],
 655                                                                    "msDS-Behavior-Version", -1);
 656                                 if (domain_controller_behaviour_version != -1) {
 657                                         int *val = talloc(ldb, int);
 658                                         if (!val) {
 659                                                 ldb_oom(ldb);
 660                                                 talloc_free(mem_ctx);
 661                                         return LDB_ERR_OPERATIONS_ERROR;
 662                                         }
 663                                         *val = domain_controller_behaviour_version;
 664                                         ret = ldb_set_opaque(ldb,
 665                                                              "domainControllerFunctionality", val);
 666                                         if (ret != LDB_SUCCESS) {
 667                                                 talloc_free(mem_ctx);
 668                                                 return ret;
 669                                         }
 670                                 }
 671                         }
 672                 }
 673         }
 674
 675         talloc_free(mem_ctx);
 676
 677         return LDB_SUCCESS;
 678 }
 679
 680 static int rootdse_modify(struct ldb_module *module, struct ldb_request *req)
 681 {
 682         struct ldb_context *ldb;
 683         struct ldb_result *ext_res;
 684         int ret;
 685         struct ldb_dn *schema_dn;
 686         struct ldb_message_element *schemaUpdateNowAttr;
 687
 688         /*
 689                 If dn is not "" we should let it pass through
 690         */
 691         if (!ldb_dn_is_null(req->op.mod.message->dn)) {
 692                 return ldb_next_request(module, req);
 693         }
 694
 695         ldb = ldb_module_get_ctx(module);
 696
 697         /*
 698                 dn is empty so check for schemaUpdateNow attribute
 699                 "The type of modification and values specified in the LDAP modify operation do not matter." MSDN
 700         */
 701         schemaUpdateNowAttr = ldb_msg_find_element(req->op.mod.message, "schemaUpdateNow");
 702         if (!schemaUpdateNowAttr) {
 703                 return LDB_ERR_OPERATIONS_ERROR;
 704         }
 705
 706         schema_dn = samdb_schema_dn(ldb);
 707         if (!schema_dn) {
 708                 ldb_reset_err_string(ldb);
 709                 ldb_debug(ldb, LDB_DEBUG_WARNING,
 710                           "rootdse_modify: no schema dn present: (skip ldb_extended call)\n");
 711                 return ldb_next_request(module, req);
 712         }
 713
 714         ret = ldb_extended(ldb, DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID, schema_dn, &ext_res);
 715         if (ret != LDB_SUCCESS) {
 716                 return LDB_ERR_OPERATIONS_ERROR;
 717         }
 718
 719         talloc_free(ext_res);
 720         return ldb_module_done(req, NULL, NULL, ret);
 721 }
 722
 723 _PUBLIC_ const struct ldb_module_ops ldb_rootdse_module_ops = {
 724         .name           = "rootdse",
 725         .init_context   = rootdse_init,
 726         .search         = rootdse_search,
 727         .request        = rootdse_request,
 728         .modify         = rootdse_modify
 729 };