r18866: Jeremy and Volker have given the go-ahead on the group mapping ldb
[kai/samba-autobuild/.git] / source3 / lib / ldb / common / ldb_attributes.c
1 /* 
2    ldb database library
3
4    Copyright (C) Andrew Tridgell  2005
5
6      ** NOTE! The following LGPL license applies to the ldb
7      ** library. This does NOT imply that all of Samba is released
8      ** under the LGPL
9    
10    This library is free software; you can redistribute it and/or
11    modify it under the terms of the GNU Lesser General Public
12    License as published by the Free Software Foundation; either
13    version 2 of the License, or (at your option) any later version.
14
15    This library is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18    Lesser General Public License for more details.
19
20    You should have received a copy of the GNU Lesser General Public
21    License along with this library; if not, write to the Free Software
22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23 */
24 /*
25   register handlers for specific attributes and objectclass relationships
26
27   this allows a backend to store its schema information in any format
28   it likes (or to not have any schema information at all) while keeping the 
29   message matching logic generic
30 */
31
32 #include "includes.h"
33 #include "ldb/include/includes.h"
34
35 /*
36   add to the list of ldif handlers for this ldb context
37 */
38 int ldb_set_attrib_handlers(struct ldb_context *ldb, 
39                             const struct ldb_attrib_handler *handlers, 
40                             unsigned num_handlers)
41 {
42         struct ldb_attrib_handler *h;
43         h = talloc_realloc(ldb, ldb->schema.attrib_handlers,
44                            struct ldb_attrib_handler,
45                            ldb->schema.num_attrib_handlers + num_handlers);
46         if (h == NULL) {
47                 ldb_oom(ldb);
48                 return -1;
49         }
50         ldb->schema.attrib_handlers = h;
51         memcpy(h + ldb->schema.num_attrib_handlers, 
52                handlers, sizeof(*h) * num_handlers);
53         ldb->schema.num_attrib_handlers += num_handlers;
54         return 0;
55 }
56                           
57
58 /*
59   default function for read/write/canonicalise
60 */
61 static int ldb_default_copy(struct ldb_context *ldb, 
62                             void *mem_ctx,
63                             const struct ldb_val *in, 
64                             struct ldb_val *out)
65 {
66         *out = ldb_val_dup(mem_ctx, in);
67
68         if (out->data == NULL && in->data != NULL) {
69                 return -1;
70         }
71
72         return 0;
73 }
74
75 /*
76   default function for comparison
77 */
78 static int ldb_default_cmp(struct ldb_context *ldb, 
79                             void *mem_ctx,
80                            const struct ldb_val *v1, 
81                            const struct ldb_val *v2)
82 {
83         if (v1->length != v2->length) {
84                 return v1->length - v2->length;
85         }
86         return memcmp(v1->data, v2->data, v1->length);
87 }
88
89 /*
90   default handler function pointers
91 */
92 static const struct ldb_attrib_handler ldb_default_attrib_handler = {
93         .attr = NULL,
94         .ldif_read_fn    = ldb_default_copy,
95         .ldif_write_fn   = ldb_default_copy,
96         .canonicalise_fn = ldb_default_copy,
97         .comparison_fn   = ldb_default_cmp,
98 };
99
100 /*
101   return the attribute handlers for a given attribute
102 */
103 const struct ldb_attrib_handler *ldb_attrib_handler(struct ldb_context *ldb,
104                                                     const char *attrib)
105 {
106         int i;
107         const struct ldb_attrib_handler *def = &ldb_default_attrib_handler;
108         /* TODO: should be replaced with a binary search, with a sort on add */
109         for (i=0;i<ldb->schema.num_attrib_handlers;i++) {
110                 if (strcmp(ldb->schema.attrib_handlers[i].attr, "*") == 0) {
111                         def = &ldb->schema.attrib_handlers[i];
112                 }
113                 if (ldb_attr_cmp(attrib, ldb->schema.attrib_handlers[i].attr) == 0) {
114                         return &ldb->schema.attrib_handlers[i];
115                 }
116         }
117         return def;
118 }
119
120
121 /*
122   add to the list of ldif handlers for this ldb context
123 */
124 void ldb_remove_attrib_handler(struct ldb_context *ldb, const char *attrib)
125 {
126         const struct ldb_attrib_handler *h;
127         int i;
128         h = ldb_attrib_handler(ldb, attrib);
129         if (h == &ldb_default_attrib_handler) {
130                 return;
131         }
132         i = h - ldb->schema.attrib_handlers;
133         if (i < ldb->schema.num_attrib_handlers - 1) {
134                 memmove(&ldb->schema.attrib_handlers[i], 
135                         h+1, sizeof(*h) * (ldb->schema.num_attrib_handlers-(i+1)));
136         }
137         ldb->schema.num_attrib_handlers--;
138 }
139
140 /*
141   setup a attribute handler using a standard syntax
142 */
143 int ldb_set_attrib_handler_syntax(struct ldb_context *ldb, 
144                                   const char *attr, const char *syntax)
145 {
146         const struct ldb_attrib_handler *h = ldb_attrib_handler_syntax(ldb, syntax);
147         struct ldb_attrib_handler h2;
148         if (h == NULL) {
149                 ldb_debug(ldb, LDB_DEBUG_ERROR, "Unknown syntax '%s'\n", syntax);
150                 return -1;
151         }
152         h2 = *h;
153         h2.attr = attr;
154         return ldb_set_attrib_handlers(ldb, &h2, 1);
155 }
156
157 /*
158   setup the attribute handles for well known attributes
159 */
160 int ldb_setup_wellknown_attributes(struct ldb_context *ldb)
161 {
162         const struct {
163                 const char *attr;
164                 const char *syntax;
165         } wellknown[] = {
166                 { "dn", LDB_SYNTAX_DN },
167                 { "ncName", LDB_SYNTAX_DN },
168                 { "distinguishedName", LDB_SYNTAX_DN },
169                 { "cn", LDB_SYNTAX_DIRECTORY_STRING },
170                 { "dc", LDB_SYNTAX_DIRECTORY_STRING },
171                 { "ou", LDB_SYNTAX_DIRECTORY_STRING },
172                 { "objectClass", LDB_SYNTAX_OBJECTCLASS }
173         };
174         int i;
175         for (i=0;i<ARRAY_SIZE(wellknown);i++) {
176                 if (ldb_set_attrib_handler_syntax(ldb, wellknown[i].attr, 
177                                                   wellknown[i].syntax) != 0) {
178                         return -1;
179                 }
180         }
181         return 0;
182 }
183
184
185 /*
186   return the list of subclasses for a class
187 */
188 const char **ldb_subclass_list(struct ldb_context *ldb, const char *classname)
189 {
190         int i;
191         for (i=0;i<ldb->schema.num_classes;i++) {
192                 if (ldb_attr_cmp(classname, ldb->schema.classes[i].name) == 0) {
193                         return (const char **)ldb->schema.classes[i].subclasses;
194                 }
195         }
196         return NULL;
197 }
198
199
200 /*
201   add a new subclass
202 */
203 static int ldb_subclass_new(struct ldb_context *ldb, const char *classname, const char *subclass)
204 {
205         struct ldb_subclass *s, *c;
206         s = talloc_realloc(ldb, ldb->schema.classes, struct ldb_subclass, ldb->schema.num_classes+1);
207         if (s == NULL) goto failed;
208
209         ldb->schema.classes = s;
210         c = &s[ldb->schema.num_classes];
211         c->name = talloc_strdup(s, classname);
212         if (c->name == NULL) goto failed;
213
214         c->subclasses = talloc_array(s, char *, 2);
215         if (c->subclasses == NULL) goto failed;
216
217         c->subclasses[0] = talloc_strdup(c->subclasses, subclass);
218         if (c->subclasses[0] == NULL) goto failed;
219         c->subclasses[1] = NULL;
220
221         ldb->schema.num_classes++;
222
223         return 0;
224 failed:
225         ldb_oom(ldb);
226         return -1;
227 }
228
229 /*
230   add a subclass
231 */
232 int ldb_subclass_add(struct ldb_context *ldb, const char *classname, const char *subclass)
233 {
234         int i, n;
235         struct ldb_subclass *c;
236         char **s;
237
238         for (i=0;i<ldb->schema.num_classes;i++) {
239                 if (ldb_attr_cmp(classname, ldb->schema.classes[i].name) == 0) {
240                         break;
241                 }
242         }
243         if (i == ldb->schema.num_classes) {
244                 return ldb_subclass_new(ldb, classname, subclass);
245         }
246         c = &ldb->schema.classes[i];
247         
248         for (n=0;c->subclasses[n];n++) /* noop */;
249
250         s = talloc_realloc(ldb->schema.classes, c->subclasses, char *, n+2);
251         if (s == NULL) {
252                 ldb_oom(ldb);
253                 return -1;
254         }
255
256         c->subclasses = s;
257         s[n] = talloc_strdup(s, subclass);
258         if (s[n] == NULL) {
259                 ldb_oom(ldb);
260                 return -1;
261         }
262         s[n+1] = NULL;
263
264         return 0;
265 }
266
267 /*
268   remove a set of subclasses for a class
269 */
270 void ldb_subclass_remove(struct ldb_context *ldb, const char *classname)
271 {
272         int i;
273         struct ldb_subclass *c;
274
275         for (i=0;i<ldb->schema.num_classes;i++) {
276                 if (ldb_attr_cmp(classname, ldb->schema.classes[i].name) == 0) {
277                         break;
278                 }
279         }
280         if (i == ldb->schema.num_classes) {
281                 return;
282         }
283
284         c = &ldb->schema.classes[i];
285         talloc_free(c->name);
286         talloc_free(c->subclasses);
287         if (ldb->schema.num_classes-(i+1) > 0) {
288                 memmove(c, c+1, sizeof(*c) * (ldb->schema.num_classes-(i+1)));
289         }
290         ldb->schema.num_classes--;
291         if (ldb->schema.num_classes == 0) {
292                 talloc_free(ldb->schema.classes);
293                 ldb->schema.classes = NULL;
294         }
295 }