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