fe456412d1fc1a9a08666e0dbd37fa4e2d93c2a1
[amitay/samba.git] / source4 / dsdb / schema / schema_inferiors.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    implement possibleInferiors calculation
5    
6    Copyright (C) Andrew Tridgell 2009
7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2009
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21    
22 */
23 /*
24   This module is a C implementation of the logic in the
25   dsdb/samdb/ldb_modules/tests/possibleInferiors.py code
26
27   To understand the C code, please see the python code first
28  */
29
30 #include "includes.h"
31 #include "dsdb/samdb/samdb.h"
32
33
34 /*
35   create the SUPCLASSES() list
36  */
37 static const char **schema_supclasses(const struct dsdb_schema *schema,
38                                       struct dsdb_class *schema_class)
39 {
40         const char **list;
41
42         if (schema_class->supclasses) {
43                 return schema_class->supclasses;
44         }
45
46         list = const_str_list(str_list_make_empty(schema_class));
47         if (list == NULL) {
48                 DEBUG(0,(__location__ " out of memory\n"));
49                 return NULL;
50         }
51
52         /* Cope with 'top SUP top', i.e. top is subClassOf top */
53         if (schema_class->subClassOf &&
54             strcmp(schema_class->lDAPDisplayName, schema_class->subClassOf) == 0) {
55                 schema_class->supclasses = list;
56                 return list;
57         }
58
59         if (schema_class->subClassOf) {
60                 const struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, schema_class->subClassOf);
61                 const char **list2;
62                 list = str_list_add_const(list, schema_class->subClassOf);
63
64                 list2 = schema_supclasses(schema, discard_const_p(struct dsdb_class, schema_class2));
65                 list = str_list_append_const(list, list2);
66         }
67
68         schema_class->supclasses = str_list_unique(list);
69
70         return schema_class->supclasses;
71 }
72
73 /*
74   this one is used internally
75   matches SUBCLASSES() python function
76  */
77 static const char **schema_subclasses(const struct dsdb_schema *schema,
78                                       TALLOC_CTX *mem_ctx,
79                                       const char **oclist)
80 {
81         const char **list = const_str_list(str_list_make_empty(mem_ctx));
82         unsigned int i;
83
84         for (i=0; oclist && oclist[i]; i++) {
85                 const struct dsdb_class *schema_class = dsdb_class_by_lDAPDisplayName(schema, oclist[i]);
86                 if (!schema_class) {
87                         DEBUG(0, ("ERROR: Unable to locate subClass: '%s'\n", oclist[i]));
88                         continue;
89                 }
90                 list = str_list_append_const(list, schema_class->subclasses);
91         }
92         return list;
93 }
94
95
96 /* 
97    equivalent of the POSSSUPERIORS() python function
98  */
99 static const char **schema_posssuperiors(const struct dsdb_schema *schema,
100                                          struct dsdb_class *schema_class)
101 {
102         if (schema_class->posssuperiors == NULL) {
103                 const char **list2 = const_str_list(str_list_make_empty(schema_class));
104                 const char **list3;
105                 unsigned int i;
106
107                 list2 = str_list_append_const(list2, schema_class->systemPossSuperiors);
108                 list2 = str_list_append_const(list2, schema_class->possSuperiors);
109                 list3 = schema_supclasses(schema, schema_class);
110                 for (i=0; list3 && list3[i]; i++) {
111                         const struct dsdb_class *class2 = dsdb_class_by_lDAPDisplayName(schema, list3[i]);
112                         if (!class2) {
113                                 DEBUG(0, ("ERROR: Unable to locate supClass: '%s'\n", list3[i]));
114                                 continue;
115                         }
116                         list2 = str_list_append_const(list2, schema_posssuperiors(schema,
117                                 discard_const_p(struct dsdb_class, class2)));
118                 }
119                 list2 = str_list_append_const(list2, schema_subclasses(schema, list2, list2));
120
121                 schema_class->posssuperiors = str_list_unique(list2);
122         }
123
124         return schema_class->posssuperiors;
125 }
126
127 static const char **schema_subclasses_recurse(const struct dsdb_schema *schema,
128                                               struct dsdb_class *schema_class)
129 {
130         const char **list = str_list_copy_const(schema_class, schema_class->subclasses_direct);
131         unsigned int i;
132         for (i=0;list && list[i]; i++) {
133                 const struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, list[i]);
134                 if (schema_class != schema_class2) {
135                         list = str_list_append_const(list, schema_subclasses_recurse(schema,
136                                 discard_const_p(struct dsdb_class, schema_class2)));
137                 }
138         }
139         return list;
140 }
141
142 /* Walk down the subClass tree, setting a higher index as we go down
143  * each level.  top is 1, subclasses of top are 2, etc */
144 void schema_subclasses_order_recurse(const struct dsdb_schema *schema,
145                                      struct dsdb_class *schema_class,
146                                      const int order)
147 {
148         const char **list = schema_class->subclasses_direct;
149         unsigned int i;
150         schema_class->subClass_order = order;
151         for (i=0;list && list[i]; i++) {
152                 const struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, list[i]);
153                 schema_subclasses_order_recurse(schema, discard_const_p(struct dsdb_class, schema_class2), order+1);
154         }
155         return;
156 }
157
158 static int schema_create_subclasses(const struct dsdb_schema *schema)
159 {
160         struct dsdb_class *schema_class, *top;
161
162         for (schema_class=schema->classes; schema_class; schema_class=schema_class->next) {
163                 struct dsdb_class *schema_class2 = discard_const_p(struct dsdb_class,
164                         dsdb_class_by_lDAPDisplayName(schema, schema_class->subClassOf));
165                 if (schema_class2 == NULL) {
166                         DEBUG(0,("ERROR: no subClassOf '%s' for '%s'\n",
167                                  schema_class->subClassOf,
168                                  schema_class->lDAPDisplayName));
169                         return LDB_ERR_OPERATIONS_ERROR;
170                 }
171                 if (schema_class2 && schema_class != schema_class2) {
172                         if (schema_class2->subclasses_direct == NULL) {
173                                 schema_class2->subclasses_direct = const_str_list(str_list_make_empty(schema_class2));
174                                 if (!schema_class2->subclasses_direct) {
175                                         return LDB_ERR_OPERATIONS_ERROR;
176                                 }
177                         }
178                         schema_class2->subclasses_direct = str_list_add_const(schema_class2->subclasses_direct,
179                                                 schema_class->lDAPDisplayName);
180                 }
181         }
182
183         for (schema_class=schema->classes; schema_class; schema_class=schema_class->next) {
184                 schema_class->subclasses = str_list_unique(schema_subclasses_recurse(schema, schema_class));
185
186                 /* Initialize the subClass order, to ensure we can't have uninitialized sort on the subClass hierarchy */
187                 schema_class->subClass_order = 0;
188         }
189
190         top = discard_const_p(struct dsdb_class, dsdb_class_by_lDAPDisplayName(schema, "top"));
191         if (!top) {
192                 DEBUG(0,("ERROR: no 'top' class in loaded schema\n"));
193                 return LDB_ERR_OPERATIONS_ERROR;
194         }
195
196         schema_subclasses_order_recurse(schema, top, 1);
197         return LDB_SUCCESS;
198 }
199
200 static void schema_fill_possible_inferiors(const struct dsdb_schema *schema,
201                                            struct dsdb_class *schema_class)
202 {
203         struct dsdb_class *c2;
204
205         for (c2=schema->classes; c2; c2=c2->next) {
206                 const char **superiors = schema_posssuperiors(schema, c2);
207                 if (c2->systemOnly == false 
208                     && c2->objectClassCategory != 2 
209                     && c2->objectClassCategory != 3
210                     && str_list_check(superiors, schema_class->lDAPDisplayName)) {
211                         if (schema_class->possibleInferiors == NULL) {
212                                 schema_class->possibleInferiors = const_str_list(str_list_make_empty(schema_class));
213                         }
214                         schema_class->possibleInferiors = str_list_add_const(schema_class->possibleInferiors,
215                                                         c2->lDAPDisplayName);
216                 }
217         }
218         schema_class->possibleInferiors = str_list_unique(schema_class->possibleInferiors);
219 }
220
221 static void schema_fill_system_possible_inferiors(const struct dsdb_schema *schema,
222                                                   struct dsdb_class *schema_class)
223 {
224         struct dsdb_class *c2;
225
226         for (c2=schema->classes; c2; c2=c2->next) {
227                 const char **superiors = schema_posssuperiors(schema, c2);
228                 if (c2->objectClassCategory != 2
229                     && c2->objectClassCategory != 3
230                     && str_list_check(superiors, schema_class->lDAPDisplayName)) {
231                         if (schema_class->systemPossibleInferiors == NULL) {
232                                 schema_class->systemPossibleInferiors = const_str_list(str_list_make_empty(schema_class));
233                         }
234                         schema_class->systemPossibleInferiors = str_list_add_const(schema_class->systemPossibleInferiors,
235                                                         c2->lDAPDisplayName);
236                 }
237         }
238         schema_class->systemPossibleInferiors = str_list_unique(schema_class->systemPossibleInferiors);
239 }
240
241 /*
242   fill in a string class name from a governs_ID
243  */
244 static void schema_fill_from_class_one(const struct dsdb_schema *schema,
245                                        const struct dsdb_class *c,
246                                        const char **s,
247                                        const uint32_t id)
248 {
249         if (*s == NULL && id != 0) {
250                 const struct dsdb_class *c2 =
251                                         dsdb_class_by_governsID_id(schema, id);
252                 if (c2) {
253                         *s = c2->lDAPDisplayName;
254                 }
255         }
256 }
257
258 /*
259   fill in a list of string class names from a governs_ID list
260  */
261 static void schema_fill_from_class_list(const struct dsdb_schema *schema,
262                                         const struct dsdb_class *c,
263                                         const char ***s,
264                                         const uint32_t *ids)
265 {
266         if (*s == NULL && ids != NULL) {
267                 unsigned int i;
268                 for (i=0;ids[i];i++) ;
269                 *s = talloc_array(c, const char *, i+1);
270                 for (i=0;ids[i];i++) {
271                         const struct dsdb_class *c2 =
272                                 dsdb_class_by_governsID_id(schema, ids[i]);
273                         if (c2) {
274                                 (*s)[i] = c2->lDAPDisplayName;
275                         } else {
276                                 (*s)[i] = NULL;                         
277                         }
278                 }
279                 (*s)[i] = NULL;                         
280         }
281 }
282
283 /*
284   fill in a list of string attribute names from a attributeID list
285  */
286 static void schema_fill_from_attribute_list(const struct dsdb_schema *schema,
287                                             const struct dsdb_class *c,
288                                             const char ***s,
289                                             const uint32_t *ids)
290 {
291         if (*s == NULL && ids != NULL) {
292                 unsigned int i;
293                 for (i=0;ids[i];i++) ;
294                 *s = talloc_array(c, const char *, i+1);
295                 for (i=0;ids[i];i++) {
296                         const struct dsdb_attribute *a =
297                                 dsdb_attribute_by_attributeID_id(schema, ids[i]);
298                         if (a) {
299                                 (*s)[i] = a->lDAPDisplayName;
300                         } else {
301                                 (*s)[i] = NULL;                         
302                         }
303                 }
304                 (*s)[i] = NULL;                         
305         }
306 }
307
308 /*
309   if the schema came from DRS then some attributes will be setup as IDs
310  */
311 static void schema_fill_from_ids(const struct dsdb_schema *schema)
312 {
313         struct dsdb_class *c;
314         for (c=schema->classes; c; c=c->next) {
315                 schema_fill_from_class_one(schema, c, &c->subClassOf, c->subClassOf_id);
316                 schema_fill_from_attribute_list(schema, c, &c->systemMayContain, c->systemMayContain_ids);
317                 schema_fill_from_attribute_list(schema, c, &c->systemMustContain, c->systemMustContain_ids);
318                 schema_fill_from_attribute_list(schema, c, &c->mustContain, c->mustContain_ids);
319                 schema_fill_from_attribute_list(schema, c, &c->mayContain, c->mayContain_ids);
320                 schema_fill_from_class_list(schema, c, &c->possSuperiors, c->possSuperiors_ids);
321                 schema_fill_from_class_list(schema, c, &c->systemPossSuperiors, c->systemPossSuperiors_ids);
322                 schema_fill_from_class_list(schema, c, &c->systemAuxiliaryClass, c->systemAuxiliaryClass_ids);
323                 schema_fill_from_class_list(schema, c, &c->auxiliaryClass, c->auxiliaryClass_ids);
324         }
325 }
326
327 int schema_fill_constructed(const struct dsdb_schema *schema)
328 {
329         int ret;
330         struct dsdb_class *schema_class;
331         struct dsdb_attribute *attribute;
332
333         schema_fill_from_ids(schema);
334
335         ret = schema_create_subclasses(schema);
336         if (ret != LDB_SUCCESS) {
337                 return ret;
338         }
339
340         for (schema_class=schema->classes; schema_class; schema_class=schema_class->next) {
341                 schema_fill_possible_inferiors(schema, schema_class);
342                 schema_fill_system_possible_inferiors(schema, schema_class);
343         }
344
345         /* free up our internal cache elements */
346         for (schema_class=schema->classes; schema_class; schema_class=schema_class->next) {
347                 talloc_free(schema_class->supclasses);
348                 talloc_free(schema_class->subclasses_direct);
349                 talloc_free(schema_class->subclasses);
350                 talloc_free(schema_class->posssuperiors);
351                 schema_class->supclasses = NULL;
352                 schema_class->subclasses_direct = NULL;
353                 schema_class->subclasses = NULL;
354                 schema_class->posssuperiors = NULL;
355         }
356
357         /* setup fast access to one_way_link and DN format */
358         for (attribute=schema->attributes; attribute; attribute=attribute->next) {
359                 attribute->dn_format = dsdb_dn_oid_to_format(attribute->syntax->ldap_oid);
360
361                 if (attribute->dn_format == DSDB_INVALID_DN) {
362                         attribute->one_way_link = false;
363                         continue;
364                 }
365
366                 /* these are not considered to be one way links for
367                    the purpose of DN link fixups */
368                 if (ldb_attr_cmp("distinguishedName", attribute->lDAPDisplayName) == 0 ||
369                     ldb_attr_cmp("objectCategory", attribute->lDAPDisplayName) == 0) {
370                         attribute->one_way_link = false;
371                         continue;
372                 }
373
374                 if (attribute->linkID == 0) {
375                         attribute->one_way_link = true;
376                         continue;
377                 }
378                 /* handle attributes with a linkID but no backlink */
379                 if (dsdb_attribute_by_linkID(schema, attribute->linkID) == NULL) {
380                         attribute->one_way_link = true;
381                         continue;
382                 }
383                 attribute->one_way_link = false;
384         }
385
386
387         return LDB_SUCCESS;
388 }