Line data Source code
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 "dsdb/samdb/samdb.h"
25 : #include <ldb_module.h>
26 : #include "lib/util/binsearch.h"
27 : #include "lib/util/tsort.h"
28 : #include "util/dlinklist.h"
29 :
30 : #undef strcasecmp
31 : #undef strncasecmp
32 :
33 : static const char **dsdb_full_attribute_list_internal(TALLOC_CTX *mem_ctx,
34 : const struct dsdb_schema *schema,
35 : const char **class_list,
36 : enum dsdb_attr_list_query query);
37 :
38 348118904 : static int uint32_cmp(uint32_t c1, uint32_t c2)
39 : {
40 348118904 : if (c1 == c2) return 0;
41 311115103 : return c1 > c2 ? 1 : -1;
42 : }
43 :
44 77993622 : static int strcasecmp_with_ldb_val(const struct ldb_val *target, const char *str)
45 : {
46 77993622 : int ret = strncasecmp((const char *)target->data, str, target->length);
47 77993622 : if (ret == 0) {
48 11072411 : size_t len = strlen(str);
49 11072411 : if (target->length > len) {
50 0 : if (target->data[len] == 0) {
51 0 : return 0;
52 : }
53 0 : return 1;
54 : }
55 11072411 : return (target->length - len);
56 : }
57 66921211 : return ret;
58 : }
59 :
60 33495641 : const struct dsdb_attribute *dsdb_attribute_by_attributeID_id(const struct dsdb_schema *schema,
61 : uint32_t id)
62 : {
63 : struct dsdb_attribute *c;
64 :
65 : /*
66 : * 0xFFFFFFFF is used as value when no mapping table is available,
67 : * so don't try to match with it
68 : */
69 33495641 : if (id == 0xFFFFFFFF) return NULL;
70 :
71 : /* check for msDS-IntId type attribute */
72 33495641 : if (dsdb_pfm_get_attid_type(id) == DSDB_ATTID_TYPE_INTID) {
73 1516 : BINARY_ARRAY_SEARCH_P(schema->attributes_by_msDS_IntId,
74 : schema->num_int_id_attr, msDS_IntId, id, uint32_cmp, c);
75 1279 : return c;
76 : }
77 :
78 44274071 : BINARY_ARRAY_SEARCH_P(schema->attributes_by_attributeID_id,
79 : schema->num_attributes, attributeID_id, id, uint32_cmp, c);
80 33494362 : return c;
81 : }
82 :
83 633 : const struct dsdb_attribute *dsdb_attribute_by_attributeID_oid(const struct dsdb_schema *schema,
84 : const char *oid)
85 : {
86 : struct dsdb_attribute *c;
87 :
88 633 : if (!oid) return NULL;
89 :
90 981 : BINARY_ARRAY_SEARCH_P(schema->attributes_by_attributeID_oid,
91 : schema->num_attributes, attributeID_oid, oid, strcasecmp, c);
92 633 : return c;
93 : }
94 :
95 1324107086 : const struct dsdb_attribute *dsdb_attribute_by_lDAPDisplayName(const struct dsdb_schema *schema,
96 : const char *name)
97 : {
98 : struct dsdb_attribute *c;
99 :
100 1324107086 : if (!name) return NULL;
101 :
102 3971486914 : BINARY_ARRAY_SEARCH_P(schema->attributes_by_lDAPDisplayName,
103 : schema->num_attributes, lDAPDisplayName, name, strcasecmp, c);
104 1324107086 : return c;
105 : }
106 :
107 0 : const struct dsdb_attribute *dsdb_attribute_by_lDAPDisplayName_ldb_val(const struct dsdb_schema *schema,
108 : const struct ldb_val *name)
109 : {
110 : struct dsdb_attribute *a;
111 :
112 0 : if (!name) return NULL;
113 :
114 0 : BINARY_ARRAY_SEARCH_P(schema->attributes_by_lDAPDisplayName,
115 : schema->num_attributes, lDAPDisplayName, name, strcasecmp_with_ldb_val, a);
116 0 : return a;
117 : }
118 :
119 1396697 : const struct dsdb_attribute *dsdb_attribute_by_linkID(const struct dsdb_schema *schema,
120 : int linkID)
121 : {
122 : struct dsdb_attribute *c;
123 :
124 4330738 : BINARY_ARRAY_SEARCH_P(schema->attributes_by_linkID,
125 : schema->num_attributes, linkID, linkID, uint32_cmp, c);
126 1396697 : return c;
127 : }
128 :
129 2603420 : const struct dsdb_class *dsdb_class_by_governsID_id(const struct dsdb_schema *schema,
130 : uint32_t id)
131 : {
132 : struct dsdb_class *c;
133 :
134 : /*
135 : * 0xFFFFFFFF is used as value when no mapping table is available,
136 : * so don't try to match with it
137 : */
138 2603420 : if (id == 0xFFFFFFFF) return NULL;
139 :
140 3957489 : BINARY_ARRAY_SEARCH_P(schema->classes_by_governsID_id,
141 : schema->num_classes, governsID_id, id, uint32_cmp, c);
142 2603420 : return c;
143 : }
144 :
145 22 : const struct dsdb_class *dsdb_class_by_governsID_oid(const struct dsdb_schema *schema,
146 : const char *oid)
147 : {
148 : struct dsdb_class *c;
149 22 : if (!oid) return NULL;
150 22 : BINARY_ARRAY_SEARCH_P(schema->classes_by_governsID_oid,
151 : schema->num_classes, governsID_oid, oid, strcasecmp, c);
152 22 : return c;
153 : }
154 :
155 80023629 : const struct dsdb_class *dsdb_class_by_lDAPDisplayName(const struct dsdb_schema *schema,
156 : const char *name)
157 : {
158 : struct dsdb_class *c;
159 80023629 : if (!name) return NULL;
160 203357961 : BINARY_ARRAY_SEARCH_P(schema->classes_by_lDAPDisplayName,
161 : schema->num_classes, lDAPDisplayName, name, strcasecmp, c);
162 80023629 : return c;
163 : }
164 :
165 10884891 : const struct dsdb_class *dsdb_class_by_lDAPDisplayName_ldb_val(const struct dsdb_schema *schema,
166 : const struct ldb_val *name)
167 : {
168 : struct dsdb_class *c;
169 10884891 : if (!name) return NULL;
170 19553131 : BINARY_ARRAY_SEARCH_P(schema->classes_by_lDAPDisplayName,
171 : schema->num_classes, lDAPDisplayName, name, strcasecmp_with_ldb_val, c);
172 10884891 : return c;
173 : }
174 :
175 85930 : const struct dsdb_class *dsdb_class_by_cn_ldb_val(const struct dsdb_schema *schema,
176 : const struct ldb_val *cn)
177 : {
178 : struct dsdb_class *c;
179 85930 : if (!cn) return NULL;
180 160563 : BINARY_ARRAY_SEARCH_P(schema->classes_by_cn,
181 : schema->num_classes, cn, cn, strcasecmp_with_ldb_val, c);
182 85930 : return c;
183 : }
184 :
185 0 : const char *dsdb_lDAPDisplayName_by_id(const struct dsdb_schema *schema,
186 : uint32_t id)
187 : {
188 : const struct dsdb_attribute *a;
189 : const struct dsdb_class *c;
190 :
191 0 : a = dsdb_attribute_by_attributeID_id(schema, id);
192 0 : if (a) {
193 0 : return a->lDAPDisplayName;
194 : }
195 :
196 0 : c = dsdb_class_by_governsID_id(schema, id);
197 0 : if (c) {
198 0 : return c->lDAPDisplayName;
199 : }
200 :
201 0 : return NULL;
202 : }
203 :
204 : /**
205 : Return a list of linked attributes, in lDAPDisplayName format.
206 :
207 : This may be used to determine if a modification would require
208 : backlinks to be updated, for example
209 : */
210 :
211 0 : WERROR dsdb_linked_attribute_lDAPDisplayName_list(const struct dsdb_schema *schema, TALLOC_CTX *mem_ctx, const char ***attr_list_ret)
212 : {
213 0 : const char **attr_list = NULL;
214 : struct dsdb_attribute *cur;
215 0 : unsigned int i = 0;
216 0 : for (cur = schema->attributes; cur; cur = cur->next) {
217 0 : if (cur->linkID == 0) continue;
218 :
219 0 : attr_list = talloc_realloc(mem_ctx, attr_list, const char *, i+2);
220 0 : if (!attr_list) {
221 0 : return WERR_NOT_ENOUGH_MEMORY;
222 : }
223 0 : attr_list[i] = cur->lDAPDisplayName;
224 0 : i++;
225 : }
226 0 : if (attr_list != NULL && attr_list[i] != NULL) {
227 0 : attr_list[i] = NULL;
228 : }
229 0 : *attr_list_ret = attr_list;
230 0 : return WERR_OK;
231 : }
232 :
233 18449016 : const char **merge_attr_list(TALLOC_CTX *mem_ctx,
234 : const char **attrs, const char * const*new_attrs)
235 : {
236 : const char **ret_attrs;
237 : unsigned int i;
238 18449016 : size_t new_len, new_attr_len, orig_len = str_list_length(attrs);
239 18449016 : if (new_attrs == NULL || new_attrs[0] == NULL) {
240 10994556 : return attrs;
241 : }
242 7454460 : new_attr_len = str_list_length(new_attrs);
243 :
244 7454460 : ret_attrs = talloc_realloc(mem_ctx,
245 : attrs, const char *, orig_len + new_attr_len + 1);
246 7454460 : if (ret_attrs) {
247 231776715 : for (i = 0; i < new_attr_len; i++) {
248 224322255 : ret_attrs[orig_len + i] = new_attrs[i];
249 : }
250 7454460 : new_len = orig_len + new_attr_len;
251 :
252 7454460 : ret_attrs[new_len] = NULL;
253 : }
254 :
255 7454460 : return ret_attrs;
256 : }
257 :
258 : /*
259 : Return a merged list of the attributes of exactly one class (not
260 : considering subclasses, auxillary classes etc)
261 : */
262 :
263 3692450 : const char **dsdb_attribute_list(TALLOC_CTX *mem_ctx, const struct dsdb_class *sclass, enum dsdb_attr_list_query query)
264 : {
265 3692450 : const char **attr_list = NULL;
266 3692450 : switch (query) {
267 1846195 : case DSDB_SCHEMA_ALL_MAY:
268 1846195 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mayContain);
269 1846195 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMayContain);
270 1846195 : break;
271 :
272 1846195 : case DSDB_SCHEMA_ALL_MUST:
273 1846195 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mustContain);
274 1846195 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMustContain);
275 1846195 : break;
276 :
277 0 : case DSDB_SCHEMA_SYS_MAY:
278 0 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMayContain);
279 0 : break;
280 :
281 0 : case DSDB_SCHEMA_SYS_MUST:
282 0 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMustContain);
283 0 : break;
284 :
285 0 : case DSDB_SCHEMA_MAY:
286 0 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mayContain);
287 0 : break;
288 :
289 0 : case DSDB_SCHEMA_MUST:
290 0 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mustContain);
291 0 : break;
292 :
293 60 : case DSDB_SCHEMA_ALL:
294 60 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mayContain);
295 60 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMayContain);
296 60 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mustContain);
297 60 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMustContain);
298 60 : break;
299 : }
300 3692450 : return attr_list;
301 : }
302 :
303 3687848 : static const char **attribute_list_from_class(TALLOC_CTX *mem_ctx,
304 : const struct dsdb_schema *schema,
305 : const struct dsdb_class *sclass,
306 : enum dsdb_attr_list_query query)
307 : {
308 : const char **this_class_list;
309 : const char **system_recursive_list;
310 : const char **recursive_list;
311 : const char **attr_list;
312 :
313 3687848 : this_class_list = dsdb_attribute_list(mem_ctx, sclass, query);
314 :
315 3687848 : recursive_list = dsdb_full_attribute_list_internal(mem_ctx, schema,
316 638606 : sclass->systemAuxiliaryClass,
317 : query);
318 :
319 3687848 : system_recursive_list = dsdb_full_attribute_list_internal(mem_ctx, schema,
320 638606 : sclass->auxiliaryClass,
321 : query);
322 :
323 3687848 : attr_list = this_class_list;
324 3687848 : attr_list = merge_attr_list(mem_ctx, attr_list, recursive_list);
325 3687848 : attr_list = merge_attr_list(mem_ctx, attr_list, system_recursive_list);
326 3687848 : return attr_list;
327 : }
328 :
329 : /* Return a full attribute list for a given class list
330 :
331 : Via attribute_list_from_class() this calls itself when recursing on auxiliary classes
332 : */
333 7375696 : static const char **dsdb_full_attribute_list_internal(TALLOC_CTX *mem_ctx,
334 : const struct dsdb_schema *schema,
335 : const char **class_list,
336 : enum dsdb_attr_list_query query)
337 : {
338 : unsigned int i;
339 7375696 : const char **attr_list = NULL;
340 :
341 8260708 : for (i=0; class_list && class_list[i]; i++) {
342 724654 : const char **sclass_list
343 885012 : = attribute_list_from_class(mem_ctx, schema,
344 885012 : dsdb_class_by_lDAPDisplayName(schema, class_list[i]),
345 : query);
346 :
347 885012 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass_list);
348 : }
349 7375696 : return attr_list;
350 : }
351 :
352 : /* Return a full attribute list for a given class list (as a ldb_message_element)
353 :
354 : Using the ldb_message_element ensures we do length-limited
355 : comparisons, rather than casting the possibly-unterminated string
356 :
357 : Via attribute_list_from_class() this calls
358 : dsdb_full_attribute_list_internal() when recursing on auxiliary classes
359 : */
360 1207068 : static const char **dsdb_full_attribute_list_internal_el(TALLOC_CTX *mem_ctx,
361 : const struct dsdb_schema *schema,
362 : const struct ldb_message_element *el,
363 : enum dsdb_attr_list_query query)
364 : {
365 : unsigned int i;
366 1207068 : const char **attr_list = NULL;
367 :
368 4009904 : for (i=0; i < el->num_values; i++) {
369 2324588 : const char **sclass_list
370 2802836 : = attribute_list_from_class(mem_ctx, schema,
371 2802836 : dsdb_class_by_lDAPDisplayName_ldb_val(schema, &el->values[i]),
372 : query);
373 :
374 2802836 : attr_list = merge_attr_list(mem_ctx, attr_list, sclass_list);
375 : }
376 1207068 : return attr_list;
377 : }
378 :
379 578747018 : static int qsort_string(const char **s1, const char **s2)
380 : {
381 578747018 : return strcasecmp(*s1, *s2);
382 : }
383 :
384 : /* Helper function to remove duplicates from the attribute list to be returned */
385 1207068 : static const char **dedup_attr_list(const char **attr_list)
386 : {
387 1207068 : size_t new_len = str_list_length(attr_list);
388 : /* Remove duplicates */
389 1207068 : if (new_len > 1) {
390 : size_t i;
391 1207068 : TYPESAFE_QSORT(attr_list, new_len, qsort_string);
392 :
393 105615055 : for (i=1; i < new_len; i++) {
394 104407987 : const char **val1 = &attr_list[i-1];
395 104407987 : const char **val2 = &attr_list[i];
396 104407987 : if (ldb_attr_cmp(*val1, *val2) == 0) {
397 2327384 : memmove(val1, val2, (new_len - i) * sizeof( *attr_list));
398 2327384 : attr_list[new_len-1] = NULL;
399 2327384 : new_len--;
400 2327384 : i--;
401 : }
402 : }
403 : }
404 1207068 : return attr_list;
405 : }
406 :
407 : /* Return a full attribute list for a given class list (as a ldb_message_element)
408 :
409 : Using the ldb_message_element ensures we do length-limited
410 : comparisons, rather than casting the possibly-unterminated string
411 :
412 : The result contains only unique values
413 : */
414 1207068 : const char **dsdb_full_attribute_list(TALLOC_CTX *mem_ctx,
415 : const struct dsdb_schema *schema,
416 : const struct ldb_message_element *class_list,
417 : enum dsdb_attr_list_query query)
418 : {
419 1207068 : const char **attr_list = dsdb_full_attribute_list_internal_el(mem_ctx, schema, class_list, query);
420 1207068 : return dedup_attr_list(attr_list);
421 : }
422 :
423 : /* Return the schemaIDGUID of a class */
424 :
425 0 : const struct GUID *class_schemaid_guid_by_lDAPDisplayName(const struct dsdb_schema *schema,
426 : const char *name)
427 : {
428 0 : const struct dsdb_class *object_class = dsdb_class_by_lDAPDisplayName(schema, name);
429 0 : if (!object_class)
430 0 : return NULL;
431 :
432 0 : return &object_class->schemaIDGUID;
433 : }
434 :
435 0 : const struct GUID *attribute_schemaid_guid_by_lDAPDisplayName(const struct dsdb_schema *schema,
436 : const char *name)
437 : {
438 0 : const struct dsdb_attribute *attr = dsdb_attribute_by_lDAPDisplayName(schema, name);
439 0 : if (!attr)
440 0 : return NULL;
441 :
442 0 : return &attr->schemaIDGUID;
443 : }
444 :
445 : /*
446 : * Sort a "objectClass" attribute (LDB message element "objectclass_element")
447 : * into correct order and validate that all object classes specified actually
448 : * exist in the schema.
449 : * The output is written in an existing LDB message element
450 : * "out_objectclass_element" where the values will be allocated on "mem_ctx".
451 : */
452 606063 : int dsdb_sort_objectClass_attr(struct ldb_context *ldb,
453 : const struct dsdb_schema *schema,
454 : const struct ldb_message_element *objectclass_element,
455 : TALLOC_CTX *mem_ctx,
456 : struct ldb_message_element *out_objectclass_element)
457 : {
458 : unsigned int i, lowest;
459 : struct class_list {
460 : struct class_list *prev, *next;
461 : const struct dsdb_class *objectclass;
462 606063 : } *unsorted = NULL, *sorted = NULL, *current = NULL,
463 606063 : *poss_parent = NULL, *new_parent = NULL,
464 606063 : *current_lowest = NULL, *current_lowest_struct = NULL;
465 : struct ldb_message_element *el;
466 : TALLOC_CTX *tmp_mem_ctx;
467 :
468 606063 : tmp_mem_ctx = talloc_new(mem_ctx);
469 606063 : if (tmp_mem_ctx == NULL) {
470 0 : return ldb_oom(ldb);
471 : }
472 :
473 : /*
474 : * DESIGN:
475 : *
476 : * We work on 4 different 'bins' (implemented here as linked lists):
477 : *
478 : * * sorted: the eventual list, in the order we wish to push
479 : * into the database. This is the only ordered list.
480 : *
481 : * * parent_class: The current parent class 'bin' we are
482 : * trying to find subclasses for
483 : *
484 : * * subclass: The subclasses we have found so far
485 : *
486 : * * unsorted: The remaining objectClasses
487 : *
488 : * The process is a matter of filtering objectClasses up from
489 : * unsorted into sorted. Order is irrelevent in the later 3 'bins'.
490 : *
491 : * We start with 'top' (found and promoted to parent_class
492 : * initially). Then we find (in unsorted) all the direct
493 : * subclasses of 'top'. parent_classes is concatenated onto
494 : * the end of 'sorted', and subclass becomes the list in
495 : * parent_class.
496 : *
497 : * We then repeat, until we find no more subclasses. Any left
498 : * over classes are added to the end.
499 : *
500 : */
501 :
502 : /*
503 : * Firstly, dump all the "objectClass" values into the unsorted bin,
504 : * except for 'top', which is special
505 : */
506 1795645 : for (i=0; i < objectclass_element->num_values; i++) {
507 1189584 : current = talloc(tmp_mem_ctx, struct class_list);
508 1189584 : if (!current) {
509 0 : talloc_free(tmp_mem_ctx);
510 0 : return ldb_oom(ldb);
511 : }
512 1189584 : current->objectclass = dsdb_class_by_lDAPDisplayName_ldb_val(schema, &objectclass_element->values[i]);
513 1189584 : if (!current->objectclass) {
514 2 : ldb_asprintf_errstring(ldb, "objectclass %.*s is not a valid objectClass in schema",
515 2 : (int)objectclass_element->values[i].length, (const char *)objectclass_element->values[i].data);
516 : /* This looks weird, but windows apparently returns this for invalid objectClass values */
517 2 : talloc_free(tmp_mem_ctx);
518 2 : return LDB_ERR_NO_SUCH_ATTRIBUTE;
519 1189582 : } else if (current->objectclass->isDefunct) {
520 0 : ldb_asprintf_errstring(ldb, "objectclass %.*s marked as isDefunct objectClass in schema - not valid for new objects",
521 0 : (int)objectclass_element->values[i].length, (const char *)objectclass_element->values[i].data);
522 : /* This looks weird, but windows apparently returns this for invalid objectClass values */
523 0 : talloc_free(tmp_mem_ctx);
524 0 : return LDB_ERR_NO_SUCH_ATTRIBUTE;
525 : }
526 :
527 : /* Don't add top to list, we will do that later */
528 1189582 : if (ldb_attr_cmp("top", current->objectclass->lDAPDisplayName) != 0) {
529 633947 : DLIST_ADD_END(unsorted, current);
530 : }
531 : }
532 :
533 :
534 : /* Add top here, to prevent duplicates */
535 606061 : current = talloc(tmp_mem_ctx, struct class_list);
536 606061 : current->objectclass = dsdb_class_by_lDAPDisplayName(schema, "top");
537 606061 : DLIST_ADD_END(sorted, current);
538 :
539 : /* For each object: find parent chain */
540 1282617 : for (current = unsorted; current != NULL; current = current->next) {
541 1432261 : for (poss_parent = unsorted; poss_parent; poss_parent = poss_parent->next) {
542 783474 : if (ldb_attr_cmp(poss_parent->objectclass->lDAPDisplayName, current->objectclass->subClassOf) == 0) {
543 27769 : break;
544 : }
545 : }
546 : /* If we didn't get to the end of the list, we need to add this parent */
547 676556 : if (poss_parent || (ldb_attr_cmp("top", current->objectclass->subClassOf) == 0)) {
548 633946 : continue;
549 : }
550 :
551 42610 : new_parent = talloc(tmp_mem_ctx, struct class_list);
552 42610 : new_parent->objectclass = dsdb_class_by_lDAPDisplayName(schema, current->objectclass->subClassOf);
553 42610 : DLIST_ADD_END(unsorted, new_parent);
554 : }
555 :
556 : /* For each object: order by hierarchy */
557 1888678 : while (unsorted != NULL) {
558 676556 : lowest = UINT_MAX;
559 676556 : current_lowest = current_lowest_struct = NULL;
560 1459895 : for (current = unsorted; current != NULL; current = current->next) {
561 783339 : if (current->objectclass->subClass_order <= lowest) {
562 : /*
563 : * According to MS-ADTS 3.1.1.1.4 structural
564 : * and 88 object classes are always listed after
565 : * the other class types in a subclass hierarchy
566 : */
567 743488 : if (current->objectclass->objectClassCategory > 1) {
568 5782 : current_lowest = current;
569 : } else {
570 737706 : current_lowest_struct = current;
571 : }
572 743488 : lowest = current->objectclass->subClass_order;
573 : }
574 : }
575 676556 : if (current_lowest == NULL) {
576 670777 : current_lowest = current_lowest_struct;
577 : }
578 :
579 676556 : if (current_lowest != NULL) {
580 676556 : DLIST_REMOVE(unsorted,current_lowest);
581 676556 : DLIST_ADD_END(sorted,current_lowest);
582 : }
583 : }
584 :
585 : /* Now rebuild the sorted "objectClass" message element */
586 606061 : el = out_objectclass_element;
587 :
588 606061 : el->flags = objectclass_element->flags;
589 606061 : el->name = talloc_strdup(mem_ctx, objectclass_element->name);
590 606061 : if (el->name == NULL) {
591 0 : talloc_free(tmp_mem_ctx);
592 0 : return ldb_oom(ldb);
593 : }
594 606061 : el->num_values = 0;
595 606061 : el->values = NULL;
596 1888678 : for (current = sorted; current != NULL; current = current->next) {
597 1282617 : el->values = talloc_realloc(mem_ctx, el->values,
598 : struct ldb_val, el->num_values + 1);
599 1282617 : if (el->values == NULL) {
600 0 : talloc_free(tmp_mem_ctx);
601 0 : return ldb_oom(ldb);
602 : }
603 1282617 : el->values[el->num_values] = data_blob_string_const(current->objectclass->lDAPDisplayName);
604 :
605 1282617 : ++(el->num_values);
606 : }
607 :
608 606061 : talloc_free(tmp_mem_ctx);
609 606061 : return LDB_SUCCESS;
610 : }
|
