r9616: Finish ldb_map module (still needs a lot of testing though...)
[sfrench/samba-autobuild/.git] / source4 / lib / ldb / ldb_map / ldb_map.c
1 /* 
2    ldb database library - map backend
3
4    Copyright (C) Jelmer Vernooij 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 #include "includes.h"
26 #include "lib/ldb/include/ldb.h"
27 #include "lib/ldb/include/ldb_private.h"
28 #include "lib/ldb/ldb_map/ldb_map.h"
29
30 /* TODO:
31  *  - objectclass hint in ldb_map_attribute 
32  *     for use when multiple remote attributes (independant of each other)
33  *     map to one local attribute. E.g.: (uid, gidNumber) -> unixName
34  */
35
36 struct map_private {
37         const struct ldb_map_mappings *mappings;
38         const char *last_err_string;
39 };
40
41 /* find an attribute by the local name */
42 static const struct ldb_map_attribute *map_find_attr_local(struct ldb_module *module, const char *attr)
43 {
44         struct map_private *privdat = module->private_data;
45         int i;
46         for (i = 0; privdat->mappings->attribute_maps[i]; i++) {
47                 if (!strcmp(privdat->mappings->attribute_maps[i]->local_name, attr)) 
48                         return privdat->mappings->attribute_maps[i];
49         }
50
51         return NULL;
52 }
53
54 /* find an attribute by the remote name */
55 static const struct ldb_map_attribute *map_find_attr_remote(struct ldb_module *module, const char *attr)
56 {
57         struct map_private *privdat = module->private_data;
58         int i;
59         for (i = 0; privdat->mappings->attribute_maps[i]; i++) {
60                 if (privdat->mappings->attribute_maps[i]->type != MAP_RENAME &&
61                         privdat->mappings->attribute_maps[i]->type != MAP_CONVERT) 
62                         continue;
63
64                 if (!strcmp(privdat->mappings->attribute_maps[i]->u.rename.remote_name, attr)) 
65                         return privdat->mappings->attribute_maps[i];
66         }
67
68         return NULL;
69 }
70
71 static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, const struct ldb_parse_tree *tree)
72 {
73         int i;
74         const struct ldb_map_attribute *attr;
75         struct ldb_parse_tree *new_tree = talloc_memdup(module, tree, sizeof(*tree));
76
77         /* Find attr in question and:
78          *  - if it has a convert_operator function, run that
79          *  - otherwise, replace attr name with required[0] */
80
81         if (tree->operation == LDB_OP_AND || 
82                 tree->operation == LDB_OP_OR) {
83                 for (i = 0; i < tree->u.list.num_elements; i++) {
84                         new_tree->u.list.elements[i] = ldb_map_parse_tree(module, tree->u.list.elements[i]);
85                 }
86
87                 return new_tree;
88         }
89                 
90         if (tree->operation == LDB_OP_NOT) {
91                 new_tree->u.isnot.child = ldb_map_parse_tree(module, tree->u.isnot.child);
92                 return new_tree;
93         }
94
95         /* tree->operation is LDB_OP_EQUALITY, LDB_OP_SUBSTRING, LDB_OP_GREATER,
96          * LDB_OP_LESS, LDB_OP_APPROX, LDB_OP_PRESENT or LDB_OP_EXTENDED
97          *
98          * (all have attr as the first element)
99          */
100
101         attr = map_find_attr_local(module, tree->u.equality.attr);
102
103         if (!attr) {
104                 DEBUG(0, ("Unable to find local attribute '%s', leaving as is", tree->u.equality.attr));
105                 return new_tree;
106         }
107
108         if (attr->type == MAP_IGNORE)
109                 return NULL;
110
111         if (attr->convert_operator) {
112                 /* Run convert_operator */
113                 talloc_free(new_tree);
114                 new_tree = attr->convert_operator(module, tree);
115         } else {
116                 new_tree->u.equality.attr = talloc_strdup(new_tree, attr->u.rename.remote_name);
117         }
118
119         return new_tree;
120 }
121
122 /* Remote DN -> Local DN */
123 static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_dn *dn)
124 {
125         struct ldb_dn *newdn;
126         int i;
127
128         newdn = talloc_memdup(module, dn, sizeof(*dn));
129         if (!newdn) 
130                 return NULL;
131
132         newdn->components = talloc_memdup(newdn, dn->components, sizeof(struct ldb_dn_component) * newdn->comp_num); 
133
134         if (!newdn->components)
135                 return NULL;
136
137         /* For each rdn, map the attribute name and possibly the 
138          * complete rdn */
139         
140         for (i = 0; i < dn->comp_num; i++) {
141                 const struct ldb_map_attribute *attr = map_find_attr_remote(module, dn->components[i].name);
142
143                 /* Unknown attribute - leave this dn as is and hope the best... */
144                 if (!attr)
145                         continue;
146
147                 if (attr->type == MAP_IGNORE) {
148                         DEBUG(0, ("Local MAP_IGNORE attribute '%s' used in DN!", dn->components[i].name));
149                         talloc_free(newdn);
150                         return NULL;
151                 }
152
153                 if (attr->type == MAP_GENERATE) {
154                         DEBUG(0, ("Local MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name));
155                         talloc_free(newdn);
156
157                         return NULL;
158                 }
159
160                 if (attr->type == MAP_CONVERT) {
161                         struct ldb_message_element elm, *newelm;
162                         struct ldb_val vals[1] = { dn->components[i].value };
163                         elm.flags = 0;
164                         elm.name = attr->u.convert.remote_name;
165                         elm.num_values = 1;
166                         elm.values = vals;
167
168                         newelm = attr->u.convert.convert_remote(module, attr->local_name, &elm);
169
170                         newdn->components[i].name = talloc_strdup(module, newelm->name);
171                         newdn->components[i].value = newelm->values[0];
172                 } else if (attr->type == MAP_RENAME) {
173                         newdn->components[i].name = talloc_strdup(module, attr->local_name);
174                 }
175         }
176         return newdn;
177 }
178
179 /* Local DN -> Remote DN */
180 static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_dn *dn)
181 {       struct ldb_dn *newdn;
182         int i;
183         struct ldb_parse_tree eqtree, *new_eqtree;
184
185         newdn = talloc_memdup(module, dn, sizeof(*dn));
186         if (!newdn) 
187                 return NULL;
188
189         newdn->components = talloc_memdup(newdn, dn->components, sizeof(struct ldb_dn_component) * newdn->comp_num); 
190
191         if (!newdn->components)
192                 return NULL;
193
194         /* For each rdn, map the attribute name and possibly the 
195          * complete rdn using an equality convert_operator call */
196         
197         for (i = 0; i < dn->comp_num; i++) {
198                 const struct ldb_map_attribute *attr = map_find_attr_local(module, dn->components[i].name);
199
200                 /* Unknown attribute - leave this dn as is and hope the best... */
201                 if (!attr)
202                         continue;
203
204                 if (attr->type == MAP_IGNORE) {
205                         DEBUG(0, ("Local MAP_IGNORE attribute '%s' used in DN!", dn->components[i].name));
206                         talloc_free(newdn);
207                         return NULL;
208                 }
209
210                 if (attr->type == MAP_GENERATE) {
211                         DEBUG(0, ("Local MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name));
212                         talloc_free(newdn);
213
214                         return NULL;
215                 }
216
217                 /* Simple rename/convert only */
218                 if (attr->convert_operator) {
219                         /* Fancy stuff */
220                         eqtree.operation = LDB_OP_EQUALITY;
221                         eqtree.u.equality.attr = dn->components[i].name;
222                         eqtree.u.equality.value = dn->components[i].value;
223
224                         new_eqtree = ldb_map_parse_tree(module, &eqtree);
225
226                         /* Silently continue for now */
227                         if (!new_eqtree) {
228                                 DEBUG(0, ("Unable to convert RDN for attribute %s\n", dn->components[i].name));
229                                 continue;
230                         }
231
232                         newdn->components[i].name = new_eqtree->u.equality.attr;
233                         newdn->components[i].value = new_eqtree->u.equality.value;
234                 } else if (attr->type == MAP_CONVERT) {
235                         struct ldb_message_element elm, *newelm;
236                         struct ldb_val vals[1] = { dn->components[i].value };
237                         elm.flags = 0;
238                         elm.name = attr->local_name;
239                         elm.num_values = 1;
240                         elm.values = vals;
241
242                         newelm = attr->u.convert.convert_local(module, attr->u.convert.remote_name, &elm);
243
244                         newdn->components[i].name = talloc_strdup(module, newelm->name);
245                         newdn->components[i].value = newelm->values[0];
246                 } else if (attr->type == MAP_RENAME) {
247                         newdn->components[i].name = talloc_strdup(module, attr->u.rename.remote_name);
248                 }
249         }
250
251         return newdn;
252 }
253
254
255
256 /* Loop over ldb_map_attribute array and add remote_names */
257 static const char **ldb_map_attrs(struct ldb_module *module, const char *const attrs[])
258 {
259         int i;
260         const char **ret;
261         int ar_size = 0, last_element = 0;
262
263         /* Start with good guess of number of elements */
264         for (i = 0; attrs[i]; i++);
265
266         ret = talloc_array(module, const char *, i);
267         ar_size = i;
268
269         for (i = 0; attrs[i]; i++) {
270                 int j;
271                 const struct ldb_map_attribute *attr = map_find_attr_local(module, attrs[i]);
272
273                 if (!attr) {
274                         DEBUG(0, ("Local attribute '%s' does not have a definition!\n", attrs[i]));
275                         continue;
276                 }
277
278                 switch (attr->type)
279                 { 
280                         case MAP_IGNORE: break;
281                         case MAP_KEEP: 
282                                 if (last_element >= ar_size) {
283                                         ret = talloc_realloc(module, ret, const char *, ar_size+1);
284                                         ar_size++;
285                                 }
286                                 ret[last_element] = attr->local_name;
287                                 last_element++;
288                                 break;
289
290                         case MAP_RENAME:
291                         case MAP_CONVERT:
292                                 if (last_element >= ar_size) {
293                                         ret = talloc_realloc(module, ret, const char *, ar_size+1);
294                                         ar_size++;
295                                 }
296                                 ret[last_element] = attr->u.rename.remote_name;
297                                 last_element++;
298                                 break;
299
300                         case MAP_GENERATE:
301                                 /* Add remote_names[] for this attribute to the list of 
302                                  * attributes to request from the remote server */
303                                 for (j = 0; attr->u.generate.remote_names[j]; j++) {
304                                         if (last_element >= ar_size) {
305                                                 ret = talloc_realloc(module, ret, const char *, ar_size+1);
306                                                 ar_size++;
307                                         }
308                                         ret[last_element] = attr->u.generate.remote_names[j];                   
309                                         last_element++;
310                                 }
311                                 break;
312                 } 
313         }
314
315         return NULL;
316 }
317
318 static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const char * const*attrs, const struct ldb_message *mi)
319 {
320         int i;
321         struct ldb_message *msg = talloc_zero(module, struct ldb_message);
322         struct ldb_message_element *elm, *oldelm;
323
324         msg->dn = map_remote_dn(module, mi->dn);
325
326         /* Loop over attrs, find in ldb_map_attribute array and 
327          * run generate() */
328
329         for (i = 0; attrs[i]; i++) {
330                 const struct ldb_map_attribute *attr = map_find_attr_local(module, attrs[i]);
331
332                 if (!attr) {
333                         DEBUG(0, ("Unable to find local attribute '%s' when generating incoming message", attrs[i]));
334                         continue;
335                 }
336
337                 switch (attr->type) {
338                         case MAP_IGNORE:break;
339                         case MAP_RENAME:
340                                 oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name);
341                                 elm = talloc_memdup(msg, oldelm, sizeof(*oldelm));
342                                 elm->name = talloc_strdup(elm, attr->local_name);
343
344                                 ldb_msg_add(module->ldb, msg, elm, 0);
345                                 break;
346                                 
347                         case MAP_CONVERT:
348                                 oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name);
349                                 elm = attr->u.convert.convert_local(msg, attr->local_name, oldelm);
350
351                                 ldb_msg_add(module->ldb, msg, elm, 0);
352                                 break;
353
354                         case MAP_KEEP:
355                                 ldb_msg_add(module->ldb, msg, ldb_msg_find_element(mi, attr->local_name), 0);
356                                 break;
357
358                         case MAP_GENERATE:
359                                 elm = attr->u.generate.generate_local(msg, attr->local_name, mi);
360                                 ldb_msg_add(module->ldb, msg, elm, 0);
361                                 break;
362                         default: 
363                                 DEBUG(0, ("Unknown attr->type for %s", attr->local_name));
364                                 break;
365                 }
366         }
367
368         return msg;
369 }
370
371 static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mo)
372 {
373         struct ldb_message *msg = talloc_zero(module, struct ldb_message);
374         struct ldb_message_element *elm;
375         int i;
376         
377         msg->private_data = mo->private_data;
378         
379         msg->dn = map_local_dn(module, mo->dn);
380
381         /* Loop over mi and call generate_remote for each attribute */
382         for (i = 0; i < mo->num_elements; i++) {
383                 const struct ldb_map_attribute *attr = map_find_attr_local(module, mo->elements[i].name);
384
385                 if (!attr) {
386                         DEBUG(0, ("Undefined local attribute '%s', ignoring\n", mo->elements[i].name));
387                         continue;
388                 }
389
390                 switch (attr->type) {
391                 case MAP_IGNORE: break;
392                 case MAP_RENAME:
393                         elm = talloc_memdup(msg, &msg->elements[i], sizeof(*elm));
394                         elm->name = talloc_strdup(elm, attr->u.rename.remote_name);
395
396                         ldb_msg_add(module->ldb, msg, elm, 0);
397                         break;
398
399                 case MAP_CONVERT:
400                         elm = attr->u.convert.convert_remote(msg, attr->local_name, &msg->elements[i]);
401                         ldb_msg_add(module->ldb, msg, elm, 0);
402                         break;
403
404                 case MAP_KEEP:
405                         ldb_msg_add(module->ldb, msg, &msg->elements[i], 0);    
406                         break;
407
408                 case MAP_GENERATE:
409                         attr->u.generate.generate_remote(attr->local_name, mo, msg);
410                         break;
411                 } 
412         }
413
414         return msg;
415 }
416
417 /*
418   rename a record
419 */
420 static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
421 {
422         struct ldb_dn *n_olddn, *n_newdn;
423         int ret;
424         
425         n_olddn = map_local_dn(module, olddn);
426         n_newdn = map_local_dn(module, newdn);
427
428         ret = ldb_next_rename_record(module, n_olddn, n_newdn);
429
430         talloc_free(n_olddn);
431         talloc_free(n_newdn);
432         
433         return ret;
434 }
435
436 /*
437   delete a record
438 */
439 static int map_delete(struct ldb_module *module, const struct ldb_dn *dn)
440 {
441         struct ldb_dn *newdn;
442         int ret;
443
444         newdn = map_local_dn(module, dn);
445
446         ret = ldb_next_delete_record(module, newdn);
447
448         talloc_free(newdn);
449
450         return ret;
451 }
452
453 /*
454   search for matching records using a ldb_parse_tree
455 */
456 static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
457                               enum ldb_scope scope, struct ldb_parse_tree *tree,
458                               const char * const *attrs, struct ldb_message ***res)
459 {
460         int ret;
461         const char **newattrs;
462         struct ldb_parse_tree *new_tree;
463         struct ldb_dn *new_base;
464         struct ldb_message **newres;
465         int i;
466
467         new_tree = ldb_map_parse_tree(module, tree);
468         newattrs = ldb_map_attrs(module, attrs); 
469         new_base = map_local_dn(module, base);
470
471         ret = ldb_next_search_bytree(module, new_base, scope, new_tree, newattrs, &newres);
472
473         talloc_free(new_base);
474         talloc_free(new_tree);
475         talloc_free(newattrs);
476
477         for (i = 0; i < ret; i++) {
478                 *res[i] = ldb_map_message_incoming(module, attrs, newres[i]);
479                 talloc_free(newres[i]);
480         }
481
482         return ret;
483 }
484 /*
485   search for matching records
486 */
487 static int map_search(struct ldb_module *module, const struct ldb_dn *base,
488                        enum ldb_scope scope, const char *expression,
489                        const char * const *attrs, struct ldb_message ***res)
490 {
491         struct map_private *map = module->private_data;
492         struct ldb_parse_tree *tree;
493         int ret;
494
495         tree = ldb_parse_tree(map, expression);
496         if (tree == NULL) {
497                 map->last_err_string = "expression parse failed";
498                 return -1;
499         }
500
501         ret = map_search_bytree(module, base, scope, tree, attrs, res);
502         talloc_free(tree);
503         return ret;
504 }
505
506 /*
507   add a record
508 */
509 static int map_add(struct ldb_module *module, const struct ldb_message *msg)
510 {
511         struct ldb_message *nmsg = ldb_map_message_outgoing(module, msg);
512         int ret;
513
514         ret = ldb_next_add_record(module, nmsg);
515
516         talloc_free(nmsg);
517
518         return ret;
519 }
520
521
522
523
524 /*
525   modify a record
526 */
527 static int map_modify(struct ldb_module *module, const struct ldb_message *msg)
528 {
529         struct ldb_message *nmsg = ldb_map_message_outgoing(module, msg);
530         int ret;
531
532         ret = ldb_next_modify_record(module, nmsg);
533
534         talloc_free(nmsg);
535
536         return ret;
537 }
538
539 static int map_lock(struct ldb_module *module, const char *lockname)
540 {
541         return ldb_next_named_lock(module, lockname);
542 }
543
544 static int map_unlock(struct ldb_module *module, const char *lockname)
545 {
546         return ldb_next_named_unlock(module, lockname);
547 }
548
549 /*
550   return extended error information
551 */
552 static const char *map_errstring(struct ldb_module *module)
553 {
554         struct map_private *map = module->private_data;
555         
556         if (map->last_err_string)
557                 return map->last_err_string;
558
559         return ldb_next_errstring(module);
560 }
561
562 static const struct ldb_module_ops map_ops = {
563         .name          = "map",
564         .search        = map_search,
565         .search_bytree = map_search_bytree,
566         .add_record    = map_add,
567         .modify_record = map_modify,
568         .delete_record = map_delete,
569         .rename_record = map_rename,
570         .named_lock    = map_lock,
571         .named_unlock  = map_unlock,
572         .errstring     = map_errstring
573 };
574
575 /* the init function */
576 struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_mappings *mappings, const char *options[])
577 {
578         struct ldb_module *ctx;
579         struct map_private *data;
580
581         ctx = talloc(ldb, struct ldb_module);
582         if (!ctx)
583                 return NULL;
584
585         data = talloc(ctx, struct map_private);
586         if (!data) {
587                 talloc_free(ctx);
588                 return NULL;
589         }
590
591         data->mappings = mappings;
592         ctx->private_data = data;
593         ctx->ldb = ldb;
594         ctx->prev = ctx->next = NULL;
595         ctx->ops = &map_ops;
596
597         return ctx;
598 }