source: branches/samba-3.5.x/source4/dsdb/schema/schema_query.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 12.7 KB
Line 
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 "dsdb/samdb/samdb.h"
25
26/* a binary array search, where the array is an array of pointers to structures,
27 and we want to find a match for 'target' on 'field' in those structures.
28
29 Inputs:
30 array: base pointer to an array of structures
31 arrray_size: number of elements in the array
32 field: the name of the field in the structure we are keying off
33 target: the field value we are looking for
34 comparison_fn: the comparison function
35 result: where the result of the search is put
36
37 if the element is found, then 'result' is set to point to the found array element. If not,
38 then 'result' is set to NULL.
39
40 The array is assumed to be sorted by the same comparison_fn as the
41 search (with, for example, qsort)
42 */
43#define BINARY_ARRAY_SEARCH(array, array_size, field, target, comparison_fn, result) do { \
44 int32_t _b, _e; \
45 (result) = NULL; \
46 for (_b = 0, _e = (array_size)-1; _b <= _e; ) { \
47 int32_t _i = (_b+_e)/2; \
48 int _r = comparison_fn(target, array[_i]->field); \
49 if (_r == 0) { (result) = array[_i]; break; } \
50 if (_r < 0) _e = _i - 1; else _b = _i + 1; \
51 } } while (0)
52
53
54static const char **dsdb_full_attribute_list_internal(TALLOC_CTX *mem_ctx,
55 const struct dsdb_schema *schema,
56 const char **class_list,
57 enum dsdb_attr_list_query query);
58
59static int uint32_cmp(uint32_t c1, uint32_t c2)
60{
61 return c1 - c2;
62}
63
64static int strcasecmp_with_ldb_val(const struct ldb_val *target, const char *str)
65{
66 int ret = strncasecmp((const char *)target->data, str, target->length);
67 if (ret == 0) {
68 return (target->length - strlen(str));
69 }
70 return ret;
71}
72
73const struct dsdb_attribute *dsdb_attribute_by_attributeID_id(const struct dsdb_schema *schema,
74 uint32_t id)
75{
76 struct dsdb_attribute *c;
77
78 /*
79 * 0xFFFFFFFF is used as value when no mapping table is available,
80 * so don't try to match with it
81 */
82 if (id == 0xFFFFFFFF) return NULL;
83
84 BINARY_ARRAY_SEARCH(schema->attributes_by_attributeID_id,
85 schema->num_attributes, attributeID_id, id, uint32_cmp, c);
86 return c;
87}
88
89const struct dsdb_attribute *dsdb_attribute_by_attributeID_oid(const struct dsdb_schema *schema,
90 const char *oid)
91{
92 struct dsdb_attribute *c;
93
94 if (!oid) return NULL;
95
96 BINARY_ARRAY_SEARCH(schema->attributes_by_attributeID_oid,
97 schema->num_attributes, attributeID_oid, oid, strcasecmp, c);
98 return c;
99}
100
101const struct dsdb_attribute *dsdb_attribute_by_lDAPDisplayName(const struct dsdb_schema *schema,
102 const char *name)
103{
104 struct dsdb_attribute *c;
105
106 if (!name) return NULL;
107
108 BINARY_ARRAY_SEARCH(schema->attributes_by_lDAPDisplayName,
109 schema->num_attributes, lDAPDisplayName, name, strcasecmp, c);
110 return c;
111}
112
113const struct dsdb_attribute *dsdb_attribute_by_linkID(const struct dsdb_schema *schema,
114 int linkID)
115{
116 struct dsdb_attribute *c;
117
118 BINARY_ARRAY_SEARCH(schema->attributes_by_linkID,
119 schema->num_attributes, linkID, linkID, uint32_cmp, c);
120 return c;
121}
122
123const struct dsdb_class *dsdb_class_by_governsID_id(const struct dsdb_schema *schema,
124 uint32_t id)
125{
126 struct dsdb_class *c;
127
128 /*
129 * 0xFFFFFFFF is used as value when no mapping table is available,
130 * so don't try to match with it
131 */
132 if (id == 0xFFFFFFFF) return NULL;
133
134 BINARY_ARRAY_SEARCH(schema->classes_by_governsID_id,
135 schema->num_classes, governsID_id, id, uint32_cmp, c);
136 return c;
137}
138
139const struct dsdb_class *dsdb_class_by_governsID_oid(const struct dsdb_schema *schema,
140 const char *oid)
141{
142 struct dsdb_class *c;
143 if (!oid) return NULL;
144 BINARY_ARRAY_SEARCH(schema->classes_by_governsID_oid,
145 schema->num_classes, governsID_oid, oid, strcasecmp, c);
146 return c;
147}
148
149const struct dsdb_class *dsdb_class_by_lDAPDisplayName(const struct dsdb_schema *schema,
150 const char *name)
151{
152 struct dsdb_class *c;
153 if (!name) return NULL;
154 BINARY_ARRAY_SEARCH(schema->classes_by_lDAPDisplayName,
155 schema->num_classes, lDAPDisplayName, name, strcasecmp, c);
156 return c;
157}
158
159const struct dsdb_class *dsdb_class_by_lDAPDisplayName_ldb_val(const struct dsdb_schema *schema,
160 const struct ldb_val *name)
161{
162 struct dsdb_class *c;
163 if (!name) return NULL;
164 BINARY_ARRAY_SEARCH(schema->classes_by_lDAPDisplayName,
165 schema->num_classes, lDAPDisplayName, name, strcasecmp_with_ldb_val, c);
166 return c;
167}
168
169const struct dsdb_class *dsdb_class_by_cn(const struct dsdb_schema *schema,
170 const char *cn)
171{
172 struct dsdb_class *c;
173 if (!cn) return NULL;
174 BINARY_ARRAY_SEARCH(schema->classes_by_cn,
175 schema->num_classes, cn, cn, strcasecmp, c);
176 return c;
177}
178
179const struct dsdb_class *dsdb_class_by_cn_ldb_val(const struct dsdb_schema *schema,
180 const struct ldb_val *cn)
181{
182 struct dsdb_class *c;
183 if (!cn) return NULL;
184 BINARY_ARRAY_SEARCH(schema->classes_by_cn,
185 schema->num_classes, cn, cn, strcasecmp_with_ldb_val, c);
186 return c;
187}
188
189const char *dsdb_lDAPDisplayName_by_id(const struct dsdb_schema *schema,
190 uint32_t id)
191{
192 const struct dsdb_attribute *a;
193 const struct dsdb_class *c;
194
195 a = dsdb_attribute_by_attributeID_id(schema, id);
196 if (a) {
197 return a->lDAPDisplayName;
198 }
199
200 c = dsdb_class_by_governsID_id(schema, id);
201 if (c) {
202 return c->lDAPDisplayName;
203 }
204
205 return NULL;
206}
207
208/**
209 Return a list of linked attributes, in lDAPDisplayName format.
210
211 This may be used to determine if a modification would require
212 backlinks to be updated, for example
213*/
214
215WERROR dsdb_linked_attribute_lDAPDisplayName_list(const struct dsdb_schema *schema, TALLOC_CTX *mem_ctx, const char ***attr_list_ret)
216{
217 const char **attr_list = NULL;
218 struct dsdb_attribute *cur;
219 int i = 0;
220 for (cur = schema->attributes; cur; cur = cur->next) {
221 if (cur->linkID == 0) continue;
222
223 attr_list = talloc_realloc(mem_ctx, attr_list, const char *, i+2);
224 if (!attr_list) {
225 return WERR_NOMEM;
226 }
227 attr_list[i] = cur->lDAPDisplayName;
228 i++;
229 }
230 attr_list[i] = NULL;
231 *attr_list_ret = attr_list;
232 return WERR_OK;
233}
234
235const char **merge_attr_list(TALLOC_CTX *mem_ctx,
236 const char **attrs, const char * const*new_attrs)
237{
238 const char **ret_attrs;
239 int i;
240 size_t new_len, orig_len = str_list_length(attrs);
241 if (!new_attrs) {
242 return attrs;
243 }
244
245 ret_attrs = talloc_realloc(mem_ctx,
246 attrs, const char *, orig_len + str_list_length(new_attrs) + 1);
247 if (ret_attrs) {
248 for (i=0; i < str_list_length(new_attrs); i++) {
249 ret_attrs[orig_len + i] = new_attrs[i];
250 }
251 new_len = orig_len + str_list_length(new_attrs);
252
253 ret_attrs[new_len] = NULL;
254 }
255
256 return ret_attrs;
257}
258
259/*
260 Return a merged list of the attributes of exactly one class (not
261 considering subclasses, auxillary classes etc)
262*/
263
264const char **dsdb_attribute_list(TALLOC_CTX *mem_ctx, const struct dsdb_class *sclass, enum dsdb_attr_list_query query)
265{
266 const char **attr_list = NULL;
267 switch (query) {
268 case DSDB_SCHEMA_ALL_MAY:
269 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mayContain);
270 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMayContain);
271 break;
272
273 case DSDB_SCHEMA_ALL_MUST:
274 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mustContain);
275 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMustContain);
276 break;
277
278 case DSDB_SCHEMA_SYS_MAY:
279 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMayContain);
280 break;
281
282 case DSDB_SCHEMA_SYS_MUST:
283 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMustContain);
284 break;
285
286 case DSDB_SCHEMA_MAY:
287 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mayContain);
288 break;
289
290 case DSDB_SCHEMA_MUST:
291 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mustContain);
292 break;
293
294 case DSDB_SCHEMA_ALL:
295 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mayContain);
296 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMayContain);
297 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->mustContain);
298 attr_list = merge_attr_list(mem_ctx, attr_list, sclass->systemMustContain);
299 break;
300 }
301 return attr_list;
302}
303
304static const char **attribute_list_from_class(TALLOC_CTX *mem_ctx,
305 const struct dsdb_schema *schema,
306 const struct dsdb_class *sclass,
307 enum dsdb_attr_list_query query)
308{
309 const char **this_class_list;
310 const char **system_recursive_list;
311 const char **recursive_list;
312 const char **attr_list;
313
314 this_class_list = dsdb_attribute_list(mem_ctx, sclass, query);
315
316 recursive_list = dsdb_full_attribute_list_internal(mem_ctx, schema,
317 sclass->systemAuxiliaryClass,
318 query);
319
320 system_recursive_list = dsdb_full_attribute_list_internal(mem_ctx, schema,
321 sclass->auxiliaryClass,
322 query);
323
324 attr_list = this_class_list;
325 attr_list = merge_attr_list(mem_ctx, attr_list, recursive_list);
326 attr_list = merge_attr_list(mem_ctx, attr_list, system_recursive_list);
327 return attr_list;
328}
329
330/* Return a full attribute list for a given class list (as a ldb_message_element)
331
332 Via attribute_list_from_class() this calls itself when recursing on auxiliary classes
333 */
334static const char **dsdb_full_attribute_list_internal(TALLOC_CTX *mem_ctx,
335 const struct dsdb_schema *schema,
336 const char **class_list,
337 enum dsdb_attr_list_query query)
338{
339 int i;
340 const char **attr_list = NULL;
341
342 for (i=0; class_list && class_list[i]; i++) {
343 const char **sclass_list
344 = attribute_list_from_class(mem_ctx, schema,
345 dsdb_class_by_lDAPDisplayName(schema, class_list[i]),
346 query);
347
348 attr_list = merge_attr_list(mem_ctx, attr_list, sclass_list);
349 }
350 return attr_list;
351}
352
353/* Return a full attribute list for a given class list (as a ldb_message_element)
354
355 Using the ldb_message_element ensures we do length-limited
356 comparisons, rather than casting the possibly-unterminated string
357
358 Via attribute_list_from_class() this calls
359 dsdb_full_attribute_list_internal() when recursing on auxiliary classes
360 */
361static const char **dsdb_full_attribute_list_internal_el(TALLOC_CTX *mem_ctx,
362 const struct dsdb_schema *schema,
363 const struct ldb_message_element *el,
364 enum dsdb_attr_list_query query)
365{
366 int i;
367 const char **attr_list = NULL;
368
369 for (i=0; i < el->num_values; i++) {
370 const char **sclass_list
371 = attribute_list_from_class(mem_ctx, schema,
372 dsdb_class_by_lDAPDisplayName_ldb_val(schema, &el->values[i]),
373 query);
374
375 attr_list = merge_attr_list(mem_ctx, attr_list, sclass_list);
376 }
377 return attr_list;
378}
379
380/* Helper function to remove duplicates from the attribute list to be returned */
381static const char **dedup_attr_list(const char **attr_list)
382{
383 size_t new_len = str_list_length(attr_list);
384 /* Remove duplicates */
385 if (new_len > 1) {
386 int i;
387 qsort(attr_list, new_len,
388 sizeof(*attr_list),
389 (comparison_fn_t)strcasecmp);
390
391 for (i=1 ; i < new_len; i++) {
392 const char **val1 = &attr_list[i-1];
393 const char **val2 = &attr_list[i];
394 if (ldb_attr_cmp(*val1, *val2) == 0) {
395 memmove(val1, val2, (new_len - i) * sizeof( *attr_list));
396 new_len--;
397 i--;
398 }
399 }
400 }
401 return attr_list;
402}
403
404/* Return a full attribute list for a given class list (as a ldb_message_element)
405
406 Using the ldb_message_element ensures we do length-limited
407 comparisons, rather than casting the possibly-unterminated string
408
409 The result contains only unique values
410 */
411const char **dsdb_full_attribute_list(TALLOC_CTX *mem_ctx,
412 const struct dsdb_schema *schema,
413 const struct ldb_message_element *class_list,
414 enum dsdb_attr_list_query query)
415{
416 const char **attr_list = dsdb_full_attribute_list_internal_el(mem_ctx, schema, class_list, query);
417 return dedup_attr_list(attr_list);
418}
419
420/* Return the schemaIDGUID of a class */
421
422const struct GUID * class_schemaid_guid_by_lDAPDisplayName(const struct dsdb_schema *schema,
423 const char *name)
424{
425 const struct dsdb_class *object_class = dsdb_class_by_lDAPDisplayName(schema, name);
426 if (!object_class)
427 return NULL;
428
429 return &object_class->schemaIDGUID;
430}
Note: See TracBrowser for help on using the repository browser.