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         struct dsdb_schema *old_schema;
 370         int ret;
 371
 372         ret = dsdb_setup_sorted_accessors(ldb, schema);
 373         if (ret != LDB_SUCCESS) {
 374                 return ret;
 375         }
 376
 377         ret = schema_fill_constructed(schema);
 378         if (ret != LDB_SUCCESS) {
 379                 return ret;
 380         }
 381
 382         old_schema = ldb_get_opaque(ldb, "dsdb_schema");
 383
 384         ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
 385         if (ret != LDB_SUCCESS) {
 386                 return ret;
 387         }
 388         /* Remove the refernece to the schema we just overwrote - if there was none, NULL is harmless here */
 389         if (old_schema != schema) {
 390                 talloc_unlink(ldb, old_schema);
 391                 talloc_steal(ldb, schema);
 392         }
 393
 394         ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", NULL);
 395         if (ret != LDB_SUCCESS) {
 396                 return ret;
 397         }
 398
 399         /* Set the new attributes based on the new schema */
 400         ret = dsdb_schema_set_attributes(ldb, schema, true);
 401         if (ret != LDB_SUCCESS) {
 402                 return ret;
 403         }
 404
 405         return LDB_SUCCESS;
 406 }
 407
 408 /**
 409  * Global variable to hold one copy of the schema, used to avoid memory bloat
 410  */
 411 static struct dsdb_schema *global_schema;
 412
 413 /**
 414  * Make this ldb use a specified schema, already fully calculated and belonging to another ldb
 415  */
 416 int dsdb_reference_schema(struct ldb_context *ldb, struct dsdb_schema *schema,
 417                           bool write_attributes)
 418 {
 419         int ret;
 420         struct dsdb_schema *old_schema;
 421         old_schema = ldb_get_opaque(ldb, "dsdb_schema");
 422         ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
 423         if (ret != LDB_SUCCESS) {
 424                 return ret;
 425         }
 426
 427         /* Remove the refernece to the schema we just overwrote - if there was none, NULL is harmless here */
 428         talloc_unlink(ldb, old_schema);
 429
 430         if (talloc_reference(ldb, schema) == NULL) {
 431                 return LDB_ERR_OPERATIONS_ERROR;
 432         }
 433
 434         ret = dsdb_schema_set_attributes(ldb, schema, write_attributes);
 435         if (ret != LDB_SUCCESS) {
 436                 return ret;
 437         }
 438
 439         return LDB_SUCCESS;
 440 }
 441
 442 /**
 443  * Make this ldb use the 'global' schema, setup to avoid having multiple copies in this process
 444  */
 445 int dsdb_set_global_schema(struct ldb_context *ldb)
 446 {
 447         int ret;
 448         void *use_global_schema = (void *)1;
 449         if (!global_schema) {
 450                 return LDB_SUCCESS;
 451         }
 452         ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", use_global_schema);
 453         if (ret != LDB_SUCCESS) {
 454                 return ret;
 455         }
 456
 457         /* Set the new attributes based on the new schema */
 458         ret = dsdb_schema_set_attributes(ldb, global_schema, false /* Don't write attributes, it's expensive */);
 459         if (ret == LDB_SUCCESS) {
 460                 /* Keep a reference to this schema, just incase the original copy is replaced */
 461                 if (talloc_reference(ldb, global_schema) == NULL) {
 462                         return LDB_ERR_OPERATIONS_ERROR;
 463                 }
 464         }
 465
 466         return ret;
 467 }
 468
 469 /**
 470  * Find the schema object for this ldb
 471  *
 472  * If reference_ctx is not NULL, then talloc_reference onto that context
 473  */
 474
 475 struct dsdb_schema *dsdb_get_schema(struct ldb_context *ldb, TALLOC_CTX *reference_ctx)
 476 {
 477         const void *p;
 478         struct dsdb_schema *schema_out;
 479         struct dsdb_schema *schema_in;
 480         bool use_global_schema;
 481         TALLOC_CTX *tmp_ctx = talloc_new(reference_ctx);
 482         if (!tmp_ctx) {
 483                 return NULL;
 484         }
 485
 486         /* see if we have a cached copy */
 487         use_global_schema = (ldb_get_opaque(ldb, "dsdb_use_global_schema") != NULL);
 488         if (use_global_schema) {
 489                 schema_in = global_schema;
 490         } else {
 491                 p = ldb_get_opaque(ldb, "dsdb_schema");
 492
 493                 schema_in = talloc_get_type(p, struct dsdb_schema);
 494                 if (!schema_in) {
 495                         talloc_free(tmp_ctx);
 496                         return NULL;
 497                 }
 498         }
 499
 500         if (schema_in->refresh_fn && !schema_in->refresh_in_progress) {
 501                 if (!talloc_reference(tmp_ctx, schema_in)) {
 502                         /* ensure that the schema_in->refresh_in_progress remains valid for the right amount of time */
 503                         talloc_free(tmp_ctx);
 504                         return NULL;
 505                 }
 506                 schema_in->refresh_in_progress = true;
 507                 /* This may change schema, if it needs to reload it from disk */
 508                 schema_out = schema_in->refresh_fn(schema_in->loaded_from_module,
 509                                                    schema_in,
 510                                                    use_global_schema);
 511                 schema_in->refresh_in_progress = false;
 512         } else {
 513                 schema_out = schema_in;
 514         }
 515
 516         /* This removes the extra reference above */
 517         talloc_free(tmp_ctx);
 518         if (!reference_ctx) {
 519                 return schema_out;
 520         } else {
 521                 return talloc_reference(reference_ctx, schema_out);
 522         }
 523 }
 524
 525 /**
 526  * Make the schema found on this ldb the 'global' schema
 527  */
 528
 529 void dsdb_make_schema_global(struct ldb_context *ldb, struct dsdb_schema *schema)
 530 {
 531         if (!schema) {
 532                 return;
 533         }
 534
 535         if (global_schema) {
 536                 talloc_unlink(talloc_autofree_context(), global_schema);
 537         }
 538
 539         /* we want the schema to be around permanently */
 540         talloc_reparent(ldb, talloc_autofree_context(), schema);
 541         global_schema = schema;
 542
 543         /* This calls the talloc_reference() of the global schema back onto the ldb */
 544         dsdb_set_global_schema(ldb);
 545 }
 546
 547 /* When loading the schema from LDIF files, we don't get the extended DNs.
 548
 549    We need to set these up, so that from the moment we start the provision, the defaultObjectCategory links are set up correctly.
 550  */
 551 int dsdb_schema_fill_extended_dn(struct ldb_context *ldb, struct dsdb_schema *schema)
 552 {
 553         struct dsdb_class *cur;
 554         const struct dsdb_class *target_class;
 555         for (cur = schema->classes; cur; cur = cur->next) {
 556                 const struct ldb_val *rdn;
 557                 struct ldb_val guid;
 558                 NTSTATUS status;
 559                 struct ldb_dn *dn = ldb_dn_new(NULL, ldb, cur->defaultObjectCategory);
 560
 561                 if (!dn) {
 562                         return LDB_ERR_INVALID_DN_SYNTAX;
 563                 }
 564                 rdn = ldb_dn_get_component_val(dn, 0);
 565                 if (!rdn) {
 566                         talloc_free(dn);
 567                         return LDB_ERR_INVALID_DN_SYNTAX;
 568                 }
 569                 target_class = dsdb_class_by_cn_ldb_val(schema, rdn);
 570                 if (!target_class) {
 571                         talloc_free(dn);
 572                         return LDB_ERR_CONSTRAINT_VIOLATION;
 573                 }
 574
 575                 status = GUID_to_ndr_blob(&target_class->objectGUID, dn, &guid);
 576                 if (!NT_STATUS_IS_OK(status)) {
 577                         talloc_free(dn);
 578                         return LDB_ERR_OPERATIONS_ERROR;
 579                 }
 580                 ldb_dn_set_extended_component(dn, "GUID", &guid);
 581
 582                 cur->defaultObjectCategory = ldb_dn_get_extended_linearized(cur, dn, 1);
 583                 talloc_free(dn);
 584         }
 585         return LDB_SUCCESS;
 586 }
 587
 588 /**
 589  * Add an element to the schema (attribute or class) from an LDB message
 590  */
 591 WERROR dsdb_schema_set_el_from_ldb_msg(struct ldb_context *ldb, struct dsdb_schema *schema,
 592                                        struct ldb_message *msg)
 593 {
 594         if (samdb_find_attribute(ldb, msg,
 595                                  "objectclass", "attributeSchema") != NULL) {
 596                 return dsdb_attribute_from_ldb(ldb, schema, msg);
 597         } else if (samdb_find_attribute(ldb, msg,
 598                                  "objectclass", "classSchema") != NULL) {
 599                 return dsdb_class_from_ldb(schema, msg);
 600         }
 601
 602         /* Don't fail on things not classes or attributes */
 603         return WERR_OK;
 604 }
 605
 606 /**
 607  * Rather than read a schema from the LDB itself, read it from an ldif
 608  * file.  This allows schema to be loaded and used while adding the
 609  * schema itself to the directory.
 610  */
 611
 612 WERROR dsdb_set_schema_from_ldif(struct ldb_context *ldb, const char *pf, const char *df)
 613 {
 614         struct ldb_ldif *ldif;
 615         struct ldb_message *msg;
 616         TALLOC_CTX *mem_ctx;
 617         WERROR status;
 618         int ret;
 619         struct dsdb_schema *schema;
 620         const struct ldb_val *prefix_val;
 621         const struct ldb_val *info_val;
 622         struct ldb_val info_val_default;
 623
 624
 625         mem_ctx = talloc_new(ldb);
 626         if (!mem_ctx) {
 627                 goto nomem;
 628         }
 629
 630         schema = dsdb_new_schema(mem_ctx);
 631
 632         schema->fsmo.we_are_master = true;
 633         schema->fsmo.master_dn = ldb_dn_new_fmt(schema, ldb, "@PROVISION_SCHEMA_MASTER");
 634         if (!schema->fsmo.master_dn) {
 635                 goto nomem;
 636         }
 637
 638         /*
 639          * load the prefixMap attribute from pf
 640          */
 641         ldif = ldb_ldif_read_string(ldb, &pf);
 642         if (!ldif) {
 643                 status = WERR_INVALID_PARAM;
 644                 goto failed;
 645         }
 646         talloc_steal(mem_ctx, ldif);
 647
 648         msg = ldb_msg_canonicalize(ldb, ldif->msg);
 649         if (!msg) {
 650                 goto nomem;
 651         }
 652         talloc_steal(mem_ctx, msg);
 653         talloc_free(ldif);
 654
 655         prefix_val = ldb_msg_find_ldb_val(msg, "prefixMap");
 656         if (!prefix_val) {
 657                 status = WERR_INVALID_PARAM;
 658                 goto failed;
 659         }
 660
 661         info_val = ldb_msg_find_ldb_val(msg, "schemaInfo");
 662         if (!info_val) {
 663                 status = dsdb_schema_info_blob_new(mem_ctx, &info_val_default);
 664                 W_ERROR_NOT_OK_GOTO(status, failed);
 665                 info_val = &info_val_default;
 666         }
 667
 668         status = dsdb_load_oid_mappings_ldb(schema, prefix_val, info_val);
 669         if (!W_ERROR_IS_OK(status)) {
 670                 DEBUG(0,("ERROR: dsdb_load_oid_mappings_ldb() failed with %s\n", win_errstr(status)));
 671                 goto failed;
 672         }
 673
 674         /*
 675          * load the attribute and class definitions outof df
 676          */
 677         while ((ldif = ldb_ldif_read_string(ldb, &df))) {
 678                 talloc_steal(mem_ctx, ldif);
 679
 680                 msg = ldb_msg_canonicalize(ldb, ldif->msg);
 681                 if (!msg) {
 682                         goto nomem;
 683                 }
 684
 685                 status = dsdb_schema_set_el_from_ldb_msg(ldb, schema, msg);
 686                 talloc_free(ldif);
 687                 if (!W_ERROR_IS_OK(status)) {
 688                         goto failed;
 689                 }
 690         }
 691
 692         ret = dsdb_set_schema(ldb, schema);
 693         if (ret != LDB_SUCCESS) {
 694                 status = WERR_FOOBAR;
 695                 goto failed;
 696         }
 697
 698         ret = dsdb_schema_fill_extended_dn(ldb, schema);
 699         if (ret != LDB_SUCCESS) {
 700                 status = WERR_FOOBAR;
 701                 goto failed;
 702         }
 703
 704         goto done;
 705
 706 nomem:
 707         status = WERR_NOMEM;
 708 failed:
 709 done:
 710         talloc_free(mem_ctx);
 711         return status;
 712 }