source: trunk/server/source4/dsdb/schema/schema_set.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 21.5 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
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 <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 */
35const 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
48static 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_oom(ldb);
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 /*
105 * Write out a rough approximation of the schema
106 * as an @ATTRIBUTES value, for bootstrapping
107 */
108 if (strcmp(syntax, LDB_SYNTAX_INTEGER) == 0) {
109 ret = ldb_msg_add_string(msg, attr->lDAPDisplayName, "INTEGER");
110 } else if (strcmp(syntax, LDB_SYNTAX_DIRECTORY_STRING) == 0) {
111 ret = ldb_msg_add_string(msg, attr->lDAPDisplayName, "CASE_INSENSITIVE");
112 }
113 if (ret != LDB_SUCCESS) {
114 break;
115 }
116
117 if (attr->searchFlags & SEARCH_FLAG_ATTINDEX) {
118 ret = ldb_msg_add_string(msg_idx, "@IDXATTR", attr->lDAPDisplayName);
119 if (ret != LDB_SUCCESS) {
120 break;
121 }
122 }
123 }
124
125 if (ret != LDB_SUCCESS) {
126 talloc_free(mem_ctx);
127 return ret;
128 }
129
130 /*
131 * Try to avoid churning the attributes too much,
132 * we only want to do this if they have changed
133 */
134 ret = ldb_search(ldb, mem_ctx, &res, msg->dn, LDB_SCOPE_BASE, NULL,
135 NULL);
136 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
137 ret = ldb_add(ldb, msg);
138 } else if (ret != LDB_SUCCESS) {
139 } else if (res->count != 1) {
140 ret = ldb_add(ldb, msg);
141 } else {
142 ret = LDB_SUCCESS;
143 /* Annoyingly added to our search results */
144 ldb_msg_remove_attr(res->msgs[0], "distinguishedName");
145
146 ret = ldb_msg_difference(ldb, mem_ctx,
147 res->msgs[0], msg, &mod_msg);
148 if (ret != LDB_SUCCESS) {
149 goto op_error;
150 }
151 if (mod_msg->num_elements > 0) {
152 ret = dsdb_replace(ldb, mod_msg, 0);
153 }
154 talloc_free(mod_msg);
155 }
156
157 if (ret == LDB_ERR_OPERATIONS_ERROR || ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS || ret == LDB_ERR_INVALID_DN_SYNTAX) {
158 /* We might be on a read-only DB or LDAP */
159 ret = LDB_SUCCESS;
160 }
161 if (ret != LDB_SUCCESS) {
162 talloc_free(mem_ctx);
163 return ret;
164 }
165
166 /* Now write out the indexes, as found in the schema (if they have changed) */
167
168 ret = ldb_search(ldb, mem_ctx, &res_idx, msg_idx->dn, LDB_SCOPE_BASE,
169 NULL, NULL);
170 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
171 ret = ldb_add(ldb, msg_idx);
172 } else if (ret != LDB_SUCCESS) {
173 } else if (res_idx->count != 1) {
174 ret = ldb_add(ldb, msg_idx);
175 } else {
176 ret = LDB_SUCCESS;
177 /* Annoyingly added to our search results */
178 ldb_msg_remove_attr(res_idx->msgs[0], "distinguishedName");
179
180 ret = ldb_msg_difference(ldb, mem_ctx,
181 res_idx->msgs[0], msg_idx, &mod_msg);
182 if (ret != LDB_SUCCESS) {
183 goto op_error;
184 }
185 if (mod_msg->num_elements > 0) {
186 ret = dsdb_replace(ldb, mod_msg, 0);
187 }
188 talloc_free(mod_msg);
189 }
190 if (ret == LDB_ERR_OPERATIONS_ERROR || ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS || ret == LDB_ERR_INVALID_DN_SYNTAX) {
191 /* We might be on a read-only DB */
192 ret = LDB_SUCCESS;
193 }
194 talloc_free(mem_ctx);
195 return ret;
196
197op_error:
198 talloc_free(mem_ctx);
199 return ldb_operr(ldb);
200}
201
202static int uint32_cmp(uint32_t c1, uint32_t c2)
203{
204 if (c1 == c2) return 0;
205 return c1 > c2 ? 1 : -1;
206}
207
208static int dsdb_compare_class_by_lDAPDisplayName(struct dsdb_class **c1, struct dsdb_class **c2)
209{
210 return strcasecmp((*c1)->lDAPDisplayName, (*c2)->lDAPDisplayName);
211}
212static int dsdb_compare_class_by_governsID_id(struct dsdb_class **c1, struct dsdb_class **c2)
213{
214 return uint32_cmp((*c1)->governsID_id, (*c2)->governsID_id);
215}
216static int dsdb_compare_class_by_governsID_oid(struct dsdb_class **c1, struct dsdb_class **c2)
217{
218 return strcasecmp((*c1)->governsID_oid, (*c2)->governsID_oid);
219}
220static int dsdb_compare_class_by_cn(struct dsdb_class **c1, struct dsdb_class **c2)
221{
222 return strcasecmp((*c1)->cn, (*c2)->cn);
223}
224
225static int dsdb_compare_attribute_by_lDAPDisplayName(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
226{
227 return strcasecmp((*a1)->lDAPDisplayName, (*a2)->lDAPDisplayName);
228}
229static int dsdb_compare_attribute_by_attributeID_id(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
230{
231 return uint32_cmp((*a1)->attributeID_id, (*a2)->attributeID_id);
232}
233static int dsdb_compare_attribute_by_msDS_IntId(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
234{
235 return uint32_cmp((*a1)->msDS_IntId, (*a2)->msDS_IntId);
236}
237static int dsdb_compare_attribute_by_attributeID_oid(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
238{
239 return strcasecmp((*a1)->attributeID_oid, (*a2)->attributeID_oid);
240}
241static int dsdb_compare_attribute_by_linkID(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
242{
243 return uint32_cmp((*a1)->linkID, (*a2)->linkID);
244}
245
246/**
247 * Clean up Classes and Attributes accessor arrays
248 */
249static void dsdb_sorted_accessors_free(struct dsdb_schema *schema)
250{
251 /* free classes accessors */
252 TALLOC_FREE(schema->classes_by_lDAPDisplayName);
253 TALLOC_FREE(schema->classes_by_governsID_id);
254 TALLOC_FREE(schema->classes_by_governsID_oid);
255 TALLOC_FREE(schema->classes_by_cn);
256 /* free attribute accessors */
257 TALLOC_FREE(schema->attributes_by_lDAPDisplayName);
258 TALLOC_FREE(schema->attributes_by_attributeID_id);
259 TALLOC_FREE(schema->attributes_by_msDS_IntId);
260 TALLOC_FREE(schema->attributes_by_attributeID_oid);
261 TALLOC_FREE(schema->attributes_by_linkID);
262}
263
264/*
265 create the sorted accessor arrays for the schema
266 */
267int dsdb_setup_sorted_accessors(struct ldb_context *ldb,
268 struct dsdb_schema *schema)
269{
270 struct dsdb_class *cur;
271 struct dsdb_attribute *a;
272 unsigned int i;
273 unsigned int num_int_id;
274
275 /* free all caches */
276 dsdb_sorted_accessors_free(schema);
277
278 /* count the classes */
279 for (i=0, cur=schema->classes; cur; i++, cur=cur->next) /* noop */ ;
280 schema->num_classes = i;
281
282 /* setup classes_by_* */
283 schema->classes_by_lDAPDisplayName = talloc_array(schema, struct dsdb_class *, i);
284 schema->classes_by_governsID_id = talloc_array(schema, struct dsdb_class *, i);
285 schema->classes_by_governsID_oid = talloc_array(schema, struct dsdb_class *, i);
286 schema->classes_by_cn = talloc_array(schema, struct dsdb_class *, i);
287 if (schema->classes_by_lDAPDisplayName == NULL ||
288 schema->classes_by_governsID_id == NULL ||
289 schema->classes_by_governsID_oid == NULL ||
290 schema->classes_by_cn == NULL) {
291 goto failed;
292 }
293
294 for (i=0, cur=schema->classes; cur; i++, cur=cur->next) {
295 schema->classes_by_lDAPDisplayName[i] = cur;
296 schema->classes_by_governsID_id[i] = cur;
297 schema->classes_by_governsID_oid[i] = cur;
298 schema->classes_by_cn[i] = cur;
299 }
300
301 /* sort the arrays */
302 TYPESAFE_QSORT(schema->classes_by_lDAPDisplayName, schema->num_classes, dsdb_compare_class_by_lDAPDisplayName);
303 TYPESAFE_QSORT(schema->classes_by_governsID_id, schema->num_classes, dsdb_compare_class_by_governsID_id);
304 TYPESAFE_QSORT(schema->classes_by_governsID_oid, schema->num_classes, dsdb_compare_class_by_governsID_oid);
305 TYPESAFE_QSORT(schema->classes_by_cn, schema->num_classes, dsdb_compare_class_by_cn);
306
307 /* now build the attribute accessor arrays */
308
309 /* count the attributes
310 * and attributes with msDS-IntId set */
311 num_int_id = 0;
312 for (i=0, a=schema->attributes; a; i++, a=a->next) {
313 if (a->msDS_IntId != 0) {
314 num_int_id++;
315 }
316 }
317 schema->num_attributes = i;
318 schema->num_int_id_attr = num_int_id;
319
320 /* setup attributes_by_* */
321 schema->attributes_by_lDAPDisplayName = talloc_array(schema, struct dsdb_attribute *, i);
322 schema->attributes_by_attributeID_id = talloc_array(schema, struct dsdb_attribute *, i);
323 schema->attributes_by_msDS_IntId = talloc_array(schema,
324 struct dsdb_attribute *, num_int_id);
325 schema->attributes_by_attributeID_oid = talloc_array(schema, struct dsdb_attribute *, i);
326 schema->attributes_by_linkID = talloc_array(schema, struct dsdb_attribute *, i);
327 if (schema->attributes_by_lDAPDisplayName == NULL ||
328 schema->attributes_by_attributeID_id == NULL ||
329 schema->attributes_by_msDS_IntId == NULL ||
330 schema->attributes_by_attributeID_oid == NULL ||
331 schema->attributes_by_linkID == NULL) {
332 goto failed;
333 }
334
335 num_int_id = 0;
336 for (i=0, a=schema->attributes; a; i++, a=a->next) {
337 schema->attributes_by_lDAPDisplayName[i] = a;
338 schema->attributes_by_attributeID_id[i] = a;
339 schema->attributes_by_attributeID_oid[i] = a;
340 schema->attributes_by_linkID[i] = a;
341 /* append attr-by-msDS-IntId values */
342 if (a->msDS_IntId != 0) {
343 schema->attributes_by_msDS_IntId[num_int_id] = a;
344 num_int_id++;
345 }
346 }
347 SMB_ASSERT(num_int_id == schema->num_int_id_attr);
348
349 /* sort the arrays */
350 TYPESAFE_QSORT(schema->attributes_by_lDAPDisplayName, schema->num_attributes, dsdb_compare_attribute_by_lDAPDisplayName);
351 TYPESAFE_QSORT(schema->attributes_by_attributeID_id, schema->num_attributes, dsdb_compare_attribute_by_attributeID_id);
352 TYPESAFE_QSORT(schema->attributes_by_msDS_IntId, schema->num_int_id_attr, dsdb_compare_attribute_by_msDS_IntId);
353 TYPESAFE_QSORT(schema->attributes_by_attributeID_oid, schema->num_attributes, dsdb_compare_attribute_by_attributeID_oid);
354 TYPESAFE_QSORT(schema->attributes_by_linkID, schema->num_attributes, dsdb_compare_attribute_by_linkID);
355
356 return LDB_SUCCESS;
357
358failed:
359 dsdb_sorted_accessors_free(schema);
360 return ldb_oom(ldb);
361}
362
363int dsdb_setup_schema_inversion(struct ldb_context *ldb, struct dsdb_schema *schema)
364{
365 /* Walk the list of schema classes */
366
367 /* For each subClassOf, add us to subclasses of the parent */
368
369 /* collect these subclasses into a recursive list of total subclasses, preserving order */
370
371 /* For each subclass under 'top', write the index from it's
372 * order as an integer in the dsdb_class (for sorting
373 * objectClass lists efficiently) */
374
375 /* Walk the list of schema classes */
376
377 /* Create a 'total possible superiors' on each class */
378 return LDB_SUCCESS;
379}
380
381/**
382 * Attach the schema to an opaque pointer on the ldb,
383 * so ldb modules can find it
384 */
385int dsdb_set_schema(struct ldb_context *ldb, struct dsdb_schema *schema)
386{
387 struct dsdb_schema *old_schema;
388 int ret;
389
390 ret = dsdb_setup_sorted_accessors(ldb, schema);
391 if (ret != LDB_SUCCESS) {
392 return ret;
393 }
394
395 ret = schema_fill_constructed(schema);
396 if (ret != LDB_SUCCESS) {
397 return ret;
398 }
399
400 old_schema = ldb_get_opaque(ldb, "dsdb_schema");
401
402 ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
403 if (ret != LDB_SUCCESS) {
404 return ret;
405 }
406
407 /* Remove the reference to the schema we just overwrote - if there was
408 * none, NULL is harmless here */
409 if (old_schema != schema) {
410 talloc_unlink(ldb, old_schema);
411 talloc_steal(ldb, schema);
412 }
413
414 ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", NULL);
415 if (ret != LDB_SUCCESS) {
416 return ret;
417 }
418
419 /* Set the new attributes based on the new schema */
420 ret = dsdb_schema_set_attributes(ldb, schema, true);
421 if (ret != LDB_SUCCESS) {
422 return ret;
423 }
424
425 return LDB_SUCCESS;
426}
427
428/**
429 * Global variable to hold one copy of the schema, used to avoid memory bloat
430 */
431static struct dsdb_schema *global_schema;
432
433/**
434 * Make this ldb use a specified schema, already fully calculated and belonging to another ldb
435 */
436int dsdb_reference_schema(struct ldb_context *ldb, struct dsdb_schema *schema,
437 bool write_attributes)
438{
439 int ret;
440 struct dsdb_schema *old_schema;
441 old_schema = ldb_get_opaque(ldb, "dsdb_schema");
442 ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
443 if (ret != LDB_SUCCESS) {
444 return ret;
445 }
446
447 /* Remove the reference to the schema we just overwrote - if there was
448 * none, NULL is harmless here */
449 talloc_unlink(ldb, old_schema);
450
451 if (talloc_reference(ldb, schema) == NULL) {
452 return ldb_oom(ldb);
453 }
454
455 /* Make this ldb use local schema preferably */
456 ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", NULL);
457 if (ret != LDB_SUCCESS) {
458 return ret;
459 }
460
461 ret = dsdb_schema_set_attributes(ldb, schema, write_attributes);
462 if (ret != LDB_SUCCESS) {
463 return ret;
464 }
465
466 return LDB_SUCCESS;
467}
468
469/**
470 * Make this ldb use the 'global' schema, setup to avoid having multiple copies in this process
471 */
472int dsdb_set_global_schema(struct ldb_context *ldb)
473{
474 int ret;
475 void *use_global_schema = (void *)1;
476 if (!global_schema) {
477 return LDB_SUCCESS;
478 }
479 ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", use_global_schema);
480 if (ret != LDB_SUCCESS) {
481 return ret;
482 }
483
484 /* Set the new attributes based on the new schema */
485 ret = dsdb_schema_set_attributes(ldb, global_schema, false /* Don't write attributes, it's expensive */);
486 if (ret == LDB_SUCCESS) {
487 /* Keep a reference to this schema, just in case the original copy is replaced */
488 if (talloc_reference(ldb, global_schema) == NULL) {
489 return ldb_oom(ldb);
490 }
491 }
492
493 return ret;
494}
495
496bool dsdb_uses_global_schema(struct ldb_context *ldb)
497{
498 return (ldb_get_opaque(ldb, "dsdb_use_global_schema") != NULL);
499}
500
501/**
502 * Find the schema object for this ldb
503 *
504 * If reference_ctx is not NULL, then talloc_reference onto that context
505 */
506
507struct dsdb_schema *dsdb_get_schema(struct ldb_context *ldb, TALLOC_CTX *reference_ctx)
508{
509 const void *p;
510 struct dsdb_schema *schema_out;
511 struct dsdb_schema *schema_in;
512 bool use_global_schema;
513 TALLOC_CTX *tmp_ctx = talloc_new(reference_ctx);
514 if (!tmp_ctx) {
515 return NULL;
516 }
517
518 /* see if we have a cached copy */
519 use_global_schema = dsdb_uses_global_schema(ldb);
520 if (use_global_schema) {
521 schema_in = global_schema;
522 } else {
523 p = ldb_get_opaque(ldb, "dsdb_schema");
524
525 schema_in = talloc_get_type(p, struct dsdb_schema);
526 if (!schema_in) {
527 talloc_free(tmp_ctx);
528 return NULL;
529 }
530 }
531
532 if (schema_in->refresh_fn && !schema_in->refresh_in_progress) {
533 if (!talloc_reference(tmp_ctx, schema_in)) {
534 /*
535 * ensure that the schema_in->refresh_in_progress
536 * remains valid for the right amount of time
537 */
538 talloc_free(tmp_ctx);
539 return NULL;
540 }
541 schema_in->refresh_in_progress = true;
542 /* This may change schema, if it needs to reload it from disk */
543 schema_out = schema_in->refresh_fn(schema_in->loaded_from_module,
544 schema_in,
545 use_global_schema);
546 schema_in->refresh_in_progress = false;
547 } else {
548 schema_out = schema_in;
549 }
550
551 /* This removes the extra reference above */
552 talloc_free(tmp_ctx);
553 if (!reference_ctx) {
554 return schema_out;
555 } else {
556 return talloc_reference(reference_ctx, schema_out);
557 }
558}
559
560/**
561 * Make the schema found on this ldb the 'global' schema
562 */
563
564void dsdb_make_schema_global(struct ldb_context *ldb, struct dsdb_schema *schema)
565{
566 if (!schema) {
567 return;
568 }
569
570 if (global_schema) {
571 talloc_unlink(talloc_autofree_context(), global_schema);
572 }
573
574 /* we want the schema to be around permanently */
575 talloc_reparent(ldb, talloc_autofree_context(), schema);
576 global_schema = schema;
577
578 /* This calls the talloc_reference() of the global schema back onto the ldb */
579 dsdb_set_global_schema(ldb);
580}
581
582/**
583 * When loading the schema from LDIF files, we don't get the extended DNs.
584 *
585 * We need to set these up, so that from the moment we start the provision,
586 * the defaultObjectCategory links are set up correctly.
587 */
588int dsdb_schema_fill_extended_dn(struct ldb_context *ldb, struct dsdb_schema *schema)
589{
590 struct dsdb_class *cur;
591 const struct dsdb_class *target_class;
592 for (cur = schema->classes; cur; cur = cur->next) {
593 const struct ldb_val *rdn;
594 struct ldb_val guid;
595 NTSTATUS status;
596 struct ldb_dn *dn = ldb_dn_new(NULL, ldb, cur->defaultObjectCategory);
597
598 if (!dn) {
599 return LDB_ERR_INVALID_DN_SYNTAX;
600 }
601 rdn = ldb_dn_get_component_val(dn, 0);
602 if (!rdn) {
603 talloc_free(dn);
604 return LDB_ERR_INVALID_DN_SYNTAX;
605 }
606 target_class = dsdb_class_by_cn_ldb_val(schema, rdn);
607 if (!target_class) {
608 talloc_free(dn);
609 return LDB_ERR_CONSTRAINT_VIOLATION;
610 }
611
612 status = GUID_to_ndr_blob(&target_class->objectGUID, dn, &guid);
613 if (!NT_STATUS_IS_OK(status)) {
614 talloc_free(dn);
615 return ldb_operr(ldb);
616 }
617 ldb_dn_set_extended_component(dn, "GUID", &guid);
618
619 cur->defaultObjectCategory = ldb_dn_get_extended_linearized(cur, dn, 1);
620 talloc_free(dn);
621 }
622 return LDB_SUCCESS;
623}
624
625/**
626 * Add an element to the schema (attribute or class) from an LDB message
627 */
628WERROR dsdb_schema_set_el_from_ldb_msg(struct ldb_context *ldb, struct dsdb_schema *schema,
629 struct ldb_message *msg)
630{
631 if (samdb_find_attribute(ldb, msg,
632 "objectclass", "attributeSchema") != NULL) {
633 return dsdb_attribute_from_ldb(ldb, schema, msg);
634 } else if (samdb_find_attribute(ldb, msg,
635 "objectclass", "classSchema") != NULL) {
636 return dsdb_class_from_ldb(schema, msg);
637 }
638
639 /* Don't fail on things not classes or attributes */
640 return WERR_OK;
641}
642
643/**
644 * Rather than read a schema from the LDB itself, read it from an ldif
645 * file. This allows schema to be loaded and used while adding the
646 * schema itself to the directory.
647 */
648
649WERROR dsdb_set_schema_from_ldif(struct ldb_context *ldb, const char *pf, const char *df)
650{
651 struct ldb_ldif *ldif;
652 struct ldb_message *msg;
653 TALLOC_CTX *mem_ctx;
654 WERROR status;
655 int ret;
656 struct dsdb_schema *schema;
657 const struct ldb_val *prefix_val;
658 const struct ldb_val *info_val;
659 struct ldb_val info_val_default;
660
661
662 mem_ctx = talloc_new(ldb);
663 if (!mem_ctx) {
664 goto nomem;
665 }
666
667 schema = dsdb_new_schema(mem_ctx);
668
669 schema->fsmo.we_are_master = true;
670 schema->fsmo.master_dn = ldb_dn_new_fmt(schema, ldb, "@PROVISION_SCHEMA_MASTER");
671 if (!schema->fsmo.master_dn) {
672 goto nomem;
673 }
674
675 /*
676 * load the prefixMap attribute from pf
677 */
678 ldif = ldb_ldif_read_string(ldb, &pf);
679 if (!ldif) {
680 status = WERR_INVALID_PARAM;
681 goto failed;
682 }
683 talloc_steal(mem_ctx, ldif);
684
685 ret = ldb_msg_normalize(ldb, mem_ctx, ldif->msg, &msg);
686 if (ret != LDB_SUCCESS) {
687 goto nomem;
688 }
689 talloc_free(ldif);
690
691 prefix_val = ldb_msg_find_ldb_val(msg, "prefixMap");
692 if (!prefix_val) {
693 status = WERR_INVALID_PARAM;
694 goto failed;
695 }
696
697 info_val = ldb_msg_find_ldb_val(msg, "schemaInfo");
698 if (!info_val) {
699 status = dsdb_schema_info_blob_new(mem_ctx, &info_val_default);
700 W_ERROR_NOT_OK_GOTO(status, failed);
701 info_val = &info_val_default;
702 }
703
704 status = dsdb_load_oid_mappings_ldb(schema, prefix_val, info_val);
705 if (!W_ERROR_IS_OK(status)) {
706 DEBUG(0,("ERROR: dsdb_load_oid_mappings_ldb() failed with %s\n", win_errstr(status)));
707 goto failed;
708 }
709
710 /* load the attribute and class definitions out of df */
711 while ((ldif = ldb_ldif_read_string(ldb, &df))) {
712 talloc_steal(mem_ctx, ldif);
713
714 ret = ldb_msg_normalize(ldb, ldif, ldif->msg, &msg);
715 if (ret != LDB_SUCCESS) {
716 goto nomem;
717 }
718
719 status = dsdb_schema_set_el_from_ldb_msg(ldb, schema, msg);
720 talloc_free(ldif);
721 if (!W_ERROR_IS_OK(status)) {
722 goto failed;
723 }
724 }
725
726 ret = dsdb_set_schema(ldb, schema);
727 if (ret != LDB_SUCCESS) {
728 status = WERR_FOOBAR;
729 goto failed;
730 }
731
732 ret = dsdb_schema_fill_extended_dn(ldb, schema);
733 if (ret != LDB_SUCCESS) {
734 status = WERR_FOOBAR;
735 goto failed;
736 }
737
738 goto done;
739
740nomem:
741 status = WERR_NOMEM;
742failed:
743done:
744 talloc_free(mem_ctx);
745 return status;
746}
Note: See TracBrowser for help on using the repository browser.