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