source4/dsdb/schema/schema_set.c

   1 /*
   2    Unix SMB/CIFS mplementation.
   3    DSDB schema header
   4
   5    Copyright (C) Stefan Metzmacher <metze@samba.org> 2006-2007
   6    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006-2008
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 */
  22
  23 #include "includes.h"
  24 #include "lib/util/dlinklist.h"
  25 #include "dsdb/samdb/samdb.h"
  26 #include "lib/ldb/include/ldb_module.h"
  27 #include "param/param.h"
  28 #include "librpc/ndr/libndr.h"
  29 #include "librpc/gen_ndr/ndr_misc.h"
  30 #include "lib/util/tsort.h"
  31
  32 /*
  33   override the name to attribute handler function
  34  */
  35 const struct ldb_schema_attribute *dsdb_attribute_handler_override(struct ldb_context *ldb,
  36                                                                    void *private_data,
  37                                                                    const char *name)
  38 {
  39         struct dsdb_schema *schema = talloc_get_type_abort(private_data, struct dsdb_schema);
  40         const struct dsdb_attribute *a = dsdb_attribute_by_lDAPDisplayName(schema, name);
  41         if (a == NULL) {
  42                 /* this will fall back to ldb internal handling */
  43                 return NULL;
  44         }
  45         return a->ldb_schema_attribute;
  46 }
  47
  48 static int dsdb_schema_set_attributes(struct ldb_context *ldb, struct dsdb_schema *schema, bool write_attributes)
  49 {
  50         int ret = LDB_SUCCESS;
  51         struct ldb_result *res;
  52         struct ldb_result *res_idx;
  53         struct dsdb_attribute *attr;
  54         struct ldb_message *mod_msg;
  55         TALLOC_CTX *mem_ctx;
  56         struct ldb_message *msg;
  57         struct ldb_message *msg_idx;
  58
  59         /* setup our own attribute name to schema handler */
  60         ldb_schema_attribute_set_override_handler(ldb, dsdb_attribute_handler_override, schema);
  61
  62         if (!write_attributes) {
  63                 return ret;
  64         }
  65
  66         mem_ctx = talloc_new(ldb);
  67         if (!mem_ctx) {
  68                 return LDB_ERR_OPERATIONS_ERROR;
  69         }
  70
  71         msg = ldb_msg_new(mem_ctx);
  72         if (!msg) {
  73                 ldb_oom(ldb);
  74                 goto op_error;
  75         }
  76         msg_idx = ldb_msg_new(mem_ctx);
  77         if (!msg_idx) {
  78                 ldb_oom(ldb);
  79                 goto op_error;
  80         }
  81         msg->dn = ldb_dn_new(msg, ldb, "@ATTRIBUTES");
  82         if (!msg->dn) {
  83                 ldb_oom(ldb);
  84                 goto op_error;
  85         }
  86         msg_idx->dn = ldb_dn_new(msg_idx, ldb, "@INDEXLIST");
  87         if (!msg_idx->dn) {
  88                 ldb_oom(ldb);
  89                 goto op_error;
  90         }
  91
  92         ret = ldb_msg_add_string(msg_idx, "@IDXONE", "1");
  93         if (ret != LDB_SUCCESS) {
  94                 goto op_error;
  95         }
  96
  97         for (attr = schema->attributes; attr; attr = attr->next) {
  98                 const char *syntax = attr->syntax->ldb_syntax;
  99
 100                 if (!syntax) {
 101                         syntax = attr->syntax->ldap_oid;
 102                 }
 103
 104                 /* Write out a rough approximation of the schema as an @ATTRIBUTES value, for bootstrapping */
 105                 if (strcmp(syntax, LDB_SYNTAX_INTEGER) == 0) {
 106                         ret = ldb_msg_add_string(msg, attr->lDAPDisplayName, "INTEGER");
 107                 } else if (strcmp(syntax, LDB_SYNTAX_DIRECTORY_STRING) == 0) {
 108                         ret = ldb_msg_add_string(msg, attr->lDAPDisplayName, "CASE_INSENSITIVE");
 109                 }
 110                 if (ret != LDB_SUCCESS) {
 111                         break;
 112                 }
 113
 114                 if (attr->searchFlags & SEARCH_FLAG_ATTINDEX) {
 115                         ret = ldb_msg_add_string(msg_idx, "@IDXATTR", attr->lDAPDisplayName);
 116                         if (ret != LDB_SUCCESS) {
 117                                 break;
 118                         }
 119                 }
 120         }
 121
 122         if (ret != LDB_SUCCESS) {
 123                 talloc_free(mem_ctx);
 124                 return ret;
 125         }
 126
 127         /* Try to avoid churning the attributes too much - we only want to do this if they have changed */
 128         ret = ldb_search(ldb, mem_ctx, &res, msg->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg->dn));
 129         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 130                 ret = ldb_add(ldb, msg);
 131         } else if (ret != LDB_SUCCESS) {
 132         } else if (res->count != 1) {
 133                 ret = ldb_add(ldb, msg);
 134         } else {
 135                 ret = LDB_SUCCESS;
 136                 /* Annoyingly added to our search results */
 137                 ldb_msg_remove_attr(res->msgs[0], "distinguishedName");
 138
 139                 mod_msg = ldb_msg_diff(ldb, res->msgs[0], msg);
 140                 if (mod_msg->num_elements > 0) {
 141                         ret = dsdb_replace(ldb, mod_msg, 0);
 142                 }
 143                 talloc_free(mod_msg);
 144         }
 145
 146         if (ret == LDB_ERR_OPERATIONS_ERROR || ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS || ret == LDB_ERR_INVALID_DN_SYNTAX) {
 147                 /* We might be on a read-only DB or LDAP */
 148                 ret = LDB_SUCCESS;
 149         }
 150         if (ret != LDB_SUCCESS) {
 151                 talloc_free(mem_ctx);
 152                 return ret;
 153         }
 154
 155         /* Now write out the indexs, as found in the schema (if they have changed) */
 156
 157         ret = ldb_search(ldb, mem_ctx, &res_idx, msg_idx->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg_idx->dn));
 158         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 159                 ret = ldb_add(ldb, msg_idx);
 160         } else if (ret != LDB_SUCCESS) {
 161         } else if (res_idx->count != 1) {
 162                 ret = ldb_add(ldb, msg_idx);
 163         } else {
 164                 ret = LDB_SUCCESS;
 165                 /* Annoyingly added to our search results */
 166                 ldb_msg_remove_attr(res_idx->msgs[0], "distinguishedName");
 167
 168                 mod_msg = ldb_msg_diff(ldb, res_idx->msgs[0], msg_idx);
 169                 if (mod_msg->num_elements > 0) {
 170                         ret = dsdb_replace(ldb, mod_msg, 0);
 171                 }
 172                 talloc_free(mod_msg);
 173         }
 174         if (ret == LDB_ERR_OPERATIONS_ERROR || ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS || ret == LDB_ERR_INVALID_DN_SYNTAX) {
 175                 /* We might be on a read-only DB */
 176                 ret = LDB_SUCCESS;
 177         }
 178         talloc_free(mem_ctx);
 179         return ret;
 180
 181 op_error:
 182         talloc_free(mem_ctx);
 183         return LDB_ERR_OPERATIONS_ERROR;
 184 }
 185
 186 static int uint32_cmp(uint32_t c1, uint32_t c2)
 187 {
 188         if (c1 == c2) return 0;
 189         return c1 > c2 ? 1 : -1;
 190 }
 191
 192 static int dsdb_compare_class_by_lDAPDisplayName(struct dsdb_class **c1, struct dsdb_class **c2)
 193 {
 194         return strcasecmp((*c1)->lDAPDisplayName, (*c2)->lDAPDisplayName);
 195 }
 196 static int dsdb_compare_class_by_governsID_id(struct dsdb_class **c1, struct dsdb_class **c2)
 197 {
 198         return uint32_cmp((*c1)->governsID_id, (*c2)->governsID_id);
 199 }
 200 static int dsdb_compare_class_by_governsID_oid(struct dsdb_class **c1, struct dsdb_class **c2)
 201 {
 202         return strcasecmp((*c1)->governsID_oid, (*c2)->governsID_oid);
 203 }
 204 static int dsdb_compare_class_by_cn(struct dsdb_class **c1, struct dsdb_class **c2)
 205 {
 206         return strcasecmp((*c1)->cn, (*c2)->cn);
 207 }
 208
 209 static int dsdb_compare_attribute_by_lDAPDisplayName(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
 210 {
 211         return strcasecmp((*a1)->lDAPDisplayName, (*a2)->lDAPDisplayName);
 212 }
 213 static int dsdb_compare_attribute_by_attributeID_id(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
 214 {
 215         return uint32_cmp((*a1)->attributeID_id, (*a2)->attributeID_id);
 216 }
 217 static int dsdb_compare_attribute_by_attributeID_oid(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
 218 {
 219         return strcasecmp((*a1)->attributeID_oid, (*a2)->attributeID_oid);
 220 }
 221 static int dsdb_compare_attribute_by_linkID(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
 222 {
 223         return uint32_cmp((*a1)->linkID, (*a2)->linkID);
 224 }
 225
 226 /**
 227  * Clean up Classes and Attributes accessor arrays
 228  */
 229 static void dsdb_sorted_accessors_free(struct dsdb_schema *schema)
 230 {
 231         /* free classes accessors */
 232         TALLOC_FREE(schema->classes_by_lDAPDisplayName);
 233         TALLOC_FREE(schema->classes_by_governsID_id);
 234         TALLOC_FREE(schema->classes_by_governsID_oid);
 235         TALLOC_FREE(schema->classes_by_cn);
 236         /* free attribute accessors */
 237         TALLOC_FREE(schema->attributes_by_lDAPDisplayName);
 238         TALLOC_FREE(schema->attributes_by_attributeID_id);
 239         TALLOC_FREE(schema->attributes_by_msDS_IntId);
 240         TALLOC_FREE(schema->attributes_by_attributeID_oid);
 241         TALLOC_FREE(schema->attributes_by_linkID);
 242 }
 243
 244 /*
 245   create the sorted accessor arrays for the schema
 246  */
 247 static int dsdb_setup_sorted_accessors(struct ldb_context *ldb,
 248                                        struct dsdb_schema *schema)
 249 {
 250         struct dsdb_class *cur;
 251         struct dsdb_attribute *a;
 252         unsigned int i;
 253         unsigned int num_int_id;
 254
 255         /* free all caches */
 256         dsdb_sorted_accessors_free(schema);
 257
 258         /* count the classes */
 259         for (i=0, cur=schema->classes; cur; i++, cur=cur->next) /* noop */ ;
 260         schema->num_classes = i;
 261
 262         /* setup classes_by_* */
 263         schema->classes_by_lDAPDisplayName = talloc_array(schema, struct dsdb_class *, i);
 264         schema->classes_by_governsID_id    = talloc_array(schema, struct dsdb_class *, i);
 265         schema->classes_by_governsID_oid   = talloc_array(schema, struct dsdb_class *, i);
 266         schema->classes_by_cn              = talloc_array(schema, struct dsdb_class *, i);
 267         if (schema->classes_by_lDAPDisplayName == NULL ||
 268             schema->classes_by_governsID_id == NULL ||
 269             schema->classes_by_governsID_oid == NULL ||
 270             schema->classes_by_cn == NULL) {
 271                 goto failed;
 272         }
 273
 274         for (i=0, cur=schema->classes; cur; i++, cur=cur->next) {
 275                 schema->classes_by_lDAPDisplayName[i] = cur;
 276                 schema->classes_by_governsID_id[i]    = cur;
 277                 schema->classes_by_governsID_oid[i]   = cur;
 278                 schema->classes_by_cn[i]              = cur;
 279         }
 280
 281         /* sort the arrays */
 282         TYPESAFE_QSORT(schema->classes_by_lDAPDisplayName, schema->num_classes, dsdb_compare_class_by_lDAPDisplayName);
 283         TYPESAFE_QSORT(schema->classes_by_governsID_id, schema->num_classes, dsdb_compare_class_by_governsID_id);
 284         TYPESAFE_QSORT(schema->classes_by_governsID_oid, schema->num_classes, dsdb_compare_class_by_governsID_oid);
 285         TYPESAFE_QSORT(schema->classes_by_cn, schema->num_classes, dsdb_compare_class_by_cn);
 286
 287         /* now build the attribute accessor arrays */
 288
 289         /* count the attributes
 290          * and attributes with msDS-IntId set */
 291         num_int_id = 0;
 292         for (i=0, a=schema->attributes; a; i++, a=a->next) {
 293                 if (a->msDS_IntId != 0) {
 294                         num_int_id++;
 295                 }
 296         }
 297         schema->num_attributes = i;
 298         schema->num_int_id_attr = num_int_id;
 299
 300         /* setup attributes_by_* */
 301         schema->attributes_by_lDAPDisplayName = talloc_array(schema, struct dsdb_attribute *, i);
 302         schema->attributes_by_attributeID_id    = talloc_array(schema, struct dsdb_attribute *, i);
 303         schema->attributes_by_msDS_IntId        = talloc_array(schema,
 304                                                                struct dsdb_attribute *, num_int_id);
 305         schema->attributes_by_attributeID_oid   = talloc_array(schema, struct dsdb_attribute *, i);
 306         schema->attributes_by_linkID              = talloc_array(schema, struct dsdb_attribute *, i);
 307         if (schema->attributes_by_lDAPDisplayName == NULL ||
 308             schema->attributes_by_attributeID_id == NULL ||
 309             schema->attributes_by_msDS_IntId == NULL ||
 310             schema->attributes_by_attributeID_oid == NULL ||
 311             schema->attributes_by_linkID == NULL) {
 312                 goto failed;
 313         }
 314
 315         num_int_id = 0;
 316         for (i=0, a=schema->attributes; a; i++, a=a->next) {
 317                 schema->attributes_by_lDAPDisplayName[i] = a;
 318                 schema->attributes_by_attributeID_id[i]    = a;
 319                 schema->attributes_by_attributeID_oid[i]   = a;
 320                 schema->attributes_by_linkID[i]          = a;
 321                 /* append attr-by-msDS-IntId values */
 322                 if (a->msDS_IntId != 0) {
 323                         schema->attributes_by_msDS_IntId[num_int_id] = a;
 324                         num_int_id++;
 325                 }
 326         }
 327         SMB_ASSERT(num_int_id == schema->num_int_id_attr);
 328
 329         /* sort the arrays */
 330         TYPESAFE_QSORT(schema->attributes_by_lDAPDisplayName, schema->num_attributes, dsdb_compare_attribute_by_lDAPDisplayName);
 331         TYPESAFE_QSORT(schema->attributes_by_attributeID_id, schema->num_attributes, dsdb_compare_attribute_by_attributeID_id);
 332         TYPESAFE_QSORT(schema->attributes_by_msDS_IntId, schema->num_int_id_attr, dsdb_compare_attribute_by_attributeID_id);
 333         TYPESAFE_QSORT(schema->attributes_by_attributeID_oid, schema->num_attributes, dsdb_compare_attribute_by_attributeID_oid);
 334         TYPESAFE_QSORT(schema->attributes_by_linkID, schema->num_attributes, dsdb_compare_attribute_by_linkID);
 335
 336         return LDB_SUCCESS;
 337
 338 failed:
 339         dsdb_sorted_accessors_free(schema);
 340         ldb_oom(ldb);
 341         return LDB_ERR_OPERATIONS_ERROR;
 342 }
 343
 344 int dsdb_setup_schema_inversion(struct ldb_context *ldb, struct dsdb_schema *schema)
 345 {
 346         /* Walk the list of schema classes */
 347
 348         /*  For each subClassOf, add us to subclasses of the parent */
 349
 350         /* collect these subclasses into a recursive list of total subclasses, preserving order */
 351
 352         /* For each subclass under 'top', write the index from it's
 353          * order as an integer in the dsdb_class (for sorting
 354          * objectClass lists efficiently) */
 355
 356         /* Walk the list of scheam classes */
 357
 358         /*  Create a 'total possible superiors' on each class */
 359         return LDB_SUCCESS;
 360 }
 361
 362 /**
 363  * Attach the schema to an opaque pointer on the ldb, so ldb modules
 364  * can find it
 365  */
 366
 367 int dsdb_set_schema(struct ldb_context *ldb, struct dsdb_schema *schema)
 368 {
 369         int ret;
 370
 371         ret = dsdb_setup_sorted_accessors(ldb, schema);
 372         if (ret != LDB_SUCCESS) {
 373                 return ret;
 374         }
 375
 376         ret = schema_fill_constructed(schema);
 377         if (ret != LDB_SUCCESS) {
 378                 return ret;
 379         }
 380
 381         ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
 382         if (ret != LDB_SUCCESS) {
 383                 return ret;
 384         }
 385
 386         ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", NULL);
 387         if (ret != LDB_SUCCESS) {
 388                 return ret;
 389         }
 390
 391         /* Set the new attributes based on the new schema */
 392         ret = dsdb_schema_set_attributes(ldb, schema, true);
 393         if (ret != LDB_SUCCESS) {
 394                 return ret;
 395         }
 396
 397         talloc_steal(ldb, schema);
 398
 399         return LDB_SUCCESS;
 400 }
 401
 402 /**
 403  * Global variable to hold one copy of the schema, used to avoid memory bloat
 404  */
 405 static struct dsdb_schema *global_schema;
 406
 407 /**
 408  * Make this ldb use a specified schema, already fully calculated and belonging to another ldb
 409  */
 410 int dsdb_reference_schema(struct ldb_context *ldb, struct dsdb_schema *schema,
 411                           bool write_attributes)
 412 {
 413         int ret;
 414         ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
 415         if (ret != LDB_SUCCESS) {
 416                 return ret;
 417         }
 418
 419         if (talloc_reference(ldb, schema) == NULL) {
 420                 return LDB_ERR_OPERATIONS_ERROR;
 421         }
 422
 423         ret = dsdb_schema_set_attributes(ldb, schema, write_attributes);
 424         if (ret != LDB_SUCCESS) {
 425                 return ret;
 426         }
 427
 428         return LDB_SUCCESS;
 429 }
 430
 431 /**
 432  * Make this ldb use the 'global' schema, setup to avoid having multiple copies in this process
 433  */
 434 int dsdb_set_global_schema(struct ldb_context *ldb)
 435 {
 436         int ret;
 437         void *use_global_schema = (void *)1;
 438         if (!global_schema) {
 439                 return LDB_SUCCESS;
 440         }
 441
 442         ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", use_global_schema);
 443         if (ret != LDB_SUCCESS) {
 444                 return ret;
 445         }
 446
 447         /* Set the new attributes based on the new schema */
 448         ret = dsdb_schema_set_attributes(ldb, global_schema, false /* Don't write attributes, it's expensive */);
 449         if (ret == LDB_SUCCESS) {
 450                 /* Keep a reference to this schema, just incase the original copy is replaced */
 451                 if (talloc_reference(ldb, global_schema) == NULL) {
 452                         return LDB_ERR_OPERATIONS_ERROR;
 453                 }
 454         }
 455
 456         return ret;
 457 }
 458
 459 /**
 460  * Find the schema object for this ldb
 461  *
 462  * If reference_ctx is not NULL, then talloc_reference onto that context
 463  */
 464
 465 struct dsdb_schema *dsdb_get_schema(struct ldb_context *ldb, TALLOC_CTX *reference_ctx)
 466 {
 467         const void *p;
 468         struct dsdb_schema *schema_out;
 469         struct dsdb_schema *schema_in;
 470         bool use_global_schema;
 471
 472         /* see if we have a cached copy */
 473         use_global_schema = (ldb_get_opaque(ldb, "dsdb_use_global_schema") != NULL);
 474         if (use_global_schema) {
 475                 schema_in = global_schema;
 476         } else {
 477                 p = ldb_get_opaque(ldb, "dsdb_schema");
 478
 479                 schema_in = talloc_get_type(p, struct dsdb_schema);
 480                 if (!schema_in) {
 481                         return NULL;
 482                 }
 483         }
 484
 485         if (schema_in->refresh_fn && !schema_in->refresh_in_progress) {
 486                 schema_in->refresh_in_progress = true;
 487                 /* This may change schema, if it needs to reload it from disk */
 488                 schema_out = schema_in->refresh_fn(schema_in->loaded_from_module,
 489                                                    schema_in,
 490                                                    use_global_schema);
 491                 schema_in->refresh_in_progress = false;
 492                 if (schema_out != schema_in) {
 493                         talloc_unlink(schema_in, ldb);
 494                 }
 495         } else {
 496                 schema_out = schema_in;
 497         }
 498
 499         if (!reference_ctx) {
 500                 return schema_out;
 501         } else {
 502                 return talloc_reference(reference_ctx, schema_out);
 503         }
 504 }
 505
 506 /**
 507  * Make the schema found on this ldb the 'global' schema
 508  */
 509
 510 void dsdb_make_schema_global(struct ldb_context *ldb, struct dsdb_schema *schema)
 511 {
 512         if (!schema) {
 513                 return;
 514         }
 515
 516         if (global_schema) {
 517                 talloc_unlink(talloc_autofree_context(), global_schema);
 518         }
 519
 520         /* Wipe any reference to the exact schema - we will set 'use the global schema' below */
 521         ldb_set_opaque(ldb, "dsdb_schema", NULL);
 522
 523         /* we want the schema to be around permanently */
 524         talloc_reparent(ldb, talloc_autofree_context(), schema);
 525         global_schema = schema;
 526
 527         /* This calls the talloc_reference() of the global schema back onto the ldb */
 528         dsdb_set_global_schema(ldb);
 529 }
 530
 531 /* When loading the schema from LDIF files, we don't get the extended DNs.
 532
 533    We need to set these up, so that from the moment we start the provision, the defaultObjectCategory links are set up correctly.
 534  */
 535 int dsdb_schema_fill_extended_dn(struct ldb_context *ldb, struct dsdb_schema *schema)
 536 {
 537         struct dsdb_class *cur;
 538         const struct dsdb_class *target_class;
 539         for (cur = schema->classes; cur; cur = cur->next) {
 540                 const struct ldb_val *rdn;
 541                 struct ldb_val guid;
 542                 NTSTATUS status;
 543                 struct ldb_dn *dn = ldb_dn_new(NULL, ldb, cur->defaultObjectCategory);
 544
 545                 if (!dn) {
 546                         return LDB_ERR_INVALID_DN_SYNTAX;
 547                 }
 548                 rdn = ldb_dn_get_component_val(dn, 0);
 549                 if (!rdn) {
 550                         talloc_free(dn);
 551                         return LDB_ERR_INVALID_DN_SYNTAX;
 552                 }
 553                 target_class = dsdb_class_by_cn_ldb_val(schema, rdn);
 554                 if (!target_class) {
 555                         talloc_free(dn);
 556                         return LDB_ERR_CONSTRAINT_VIOLATION;
 557                 }
 558
 559                 status = GUID_to_ndr_blob(&target_class->objectGUID, dn, &guid);
 560                 if (!NT_STATUS_IS_OK(status)) {
 561                         talloc_free(dn);
 562                         return LDB_ERR_OPERATIONS_ERROR;
 563                 }
 564                 ldb_dn_set_extended_component(dn, "GUID", &guid);
 565
 566                 cur->defaultObjectCategory = ldb_dn_get_extended_linearized(cur, dn, 1);
 567                 talloc_free(dn);
 568         }
 569         return LDB_SUCCESS;
 570 }
 571
 572 /**
 573  * Add an element to the schema (attribute or class) from an LDB message
 574  */
 575 WERROR dsdb_schema_set_el_from_ldb_msg(struct ldb_context *ldb, struct dsdb_schema *schema,
 576                                        struct ldb_message *msg)
 577 {
 578         if (samdb_find_attribute(ldb, msg,
 579                                  "objectclass", "attributeSchema") != NULL) {
 580                 return dsdb_attribute_from_ldb(ldb, schema, msg);
 581         } else if (samdb_find_attribute(ldb, msg,
 582                                  "objectclass", "classSchema") != NULL) {
 583                 return dsdb_class_from_ldb(schema, msg);
 584         }
 585
 586         /* Don't fail on things not classes or attributes */
 587         return WERR_OK;
 588 }
 589
 590 /**
 591  * Rather than read a schema from the LDB itself, read it from an ldif
 592  * file.  This allows schema to be loaded and used while adding the
 593  * schema itself to the directory.
 594  */
 595
 596 WERROR dsdb_set_schema_from_ldif(struct ldb_context *ldb, const char *pf, const char *df)
 597 {
 598         struct ldb_ldif *ldif;
 599         struct ldb_message *msg;
 600         TALLOC_CTX *mem_ctx;
 601         WERROR status;
 602         int ret;
 603         struct dsdb_schema *schema;
 604         const struct ldb_val *prefix_val;
 605         const struct ldb_val *info_val;
 606         struct ldb_val info_val_default;
 607
 608
 609         mem_ctx = talloc_new(ldb);
 610         if (!mem_ctx) {
 611                 goto nomem;
 612         }
 613
 614         schema = dsdb_new_schema(mem_ctx);
 615
 616         schema->fsmo.we_are_master = true;
 617         schema->fsmo.master_dn = ldb_dn_new_fmt(schema, ldb, "@PROVISION_SCHEMA_MASTER");
 618         if (!schema->fsmo.master_dn) {
 619                 goto nomem;
 620         }
 621
 622         /*
 623          * load the prefixMap attribute from pf
 624          */
 625         ldif = ldb_ldif_read_string(ldb, &pf);
 626         if (!ldif) {
 627                 status = WERR_INVALID_PARAM;
 628                 goto failed;
 629         }
 630         talloc_steal(mem_ctx, ldif);
 631
 632         msg = ldb_msg_canonicalize(ldb, ldif->msg);
 633         if (!msg) {
 634                 goto nomem;
 635         }
 636         talloc_steal(mem_ctx, msg);
 637         talloc_free(ldif);
 638
 639         prefix_val = ldb_msg_find_ldb_val(msg, "prefixMap");
 640         if (!prefix_val) {
 641                 status = WERR_INVALID_PARAM;
 642                 goto failed;
 643         }
 644
 645         info_val = ldb_msg_find_ldb_val(msg, "schemaInfo");
 646         if (!info_val) {
 647                 status = dsdb_schema_info_blob_new(mem_ctx, &info_val_default);
 648                 W_ERROR_NOT_OK_GOTO(status, failed);
 649                 info_val = &info_val_default;
 650         }
 651
 652         status = dsdb_load_oid_mappings_ldb(schema, prefix_val, info_val);
 653         if (!W_ERROR_IS_OK(status)) {
 654                 DEBUG(0,("ERROR: dsdb_load_oid_mappings_ldb() failed with %s\n", win_errstr(status)));
 655                 goto failed;
 656         }
 657
 658         /*
 659          * load the attribute and class definitions outof df
 660          */
 661         while ((ldif = ldb_ldif_read_string(ldb, &df))) {
 662                 talloc_steal(mem_ctx, ldif);
 663
 664                 msg = ldb_msg_canonicalize(ldb, ldif->msg);
 665                 if (!msg) {
 666                         goto nomem;
 667                 }
 668
 669                 status = dsdb_schema_set_el_from_ldb_msg(ldb, schema, msg);
 670                 talloc_free(ldif);
 671                 if (!W_ERROR_IS_OK(status)) {
 672                         goto failed;
 673                 }
 674         }
 675
 676         ret = dsdb_set_schema(ldb, schema);
 677         if (ret != LDB_SUCCESS) {
 678                 status = WERR_FOOBAR;
 679                 goto failed;
 680         }
 681
 682         ret = dsdb_schema_fill_extended_dn(ldb, schema);
 683         if (ret != LDB_SUCCESS) {
 684                 status = WERR_FOOBAR;
 685                 goto failed;
 686         }
 687
 688         goto done;
 689
 690 nomem:
 691         status = WERR_NOMEM;
 692 failed:
 693 done:
 694         talloc_free(mem_ctx);
 695         return status;
 696 }