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