r9789: Patch from Volker that fixes the build on AIX.
[sfrench/samba-autobuild/.git] / source4 / lib / ldb / modules / 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/modules/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  *     (use MAP_GENERATE instead ?) 
35  */
36
37 /*
38  - special attribute 'isMapped'
39  - add/modify
40         - split up ldb_message into fallback and mapped parts if is_mappable
41  - search: 
42         - search local one for not isMapped entries
43         - remove remote attributes from ldb_parse_tree
44         - search remote one
45          - per record, search local one for additional data (by dn)
46          - test if (full expression) is now true
47  - delete
48         - delete both
49  - rename
50         - rename locally and remotely
51 */
52
53 static struct ldb_val map_convert_local_dn(struct ldb_map_context *map,
54                                            TALLOC_CTX *ctx,
55                                            const struct ldb_val *val);
56 static struct ldb_val map_convert_remote_dn(struct ldb_map_context *map,
57                                             TALLOC_CTX *ctx,
58                                             const struct ldb_val *val);
59 static struct ldb_val map_convert_local_objectclass(struct ldb_map_context *map,
60                                                     TALLOC_CTX *ctx,
61                                                     const struct ldb_val *val);
62 static struct ldb_val map_convert_remote_objectclass(struct ldb_map_context *map,
63                                                      TALLOC_CTX *ctx,
64                                                      const struct ldb_val *val);
65
66 static const struct ldb_map_attribute builtin_attribute_maps[] = {
67         {
68                 .local_name = "dn",
69                 .type = MAP_CONVERT,
70                 .u.convert.remote_name = "dn",
71                 .u.convert.convert_local = map_convert_local_dn,
72                 .u.convert.convert_remote = map_convert_remote_dn,
73         },
74         {
75                 .local_name = "objectclass",
76                 .type = MAP_CONVERT,
77                 .u.convert.remote_name = "objectclass",
78                 .u.convert.convert_local = map_convert_local_objectclass,
79                 .u.convert.convert_remote = map_convert_remote_objectclass,
80         },
81         {
82                 .local_name = NULL,
83         }
84 };
85
86 struct map_private {
87         struct ldb_map_context context;
88         const char *last_err_string;
89 };
90
91 static struct ldb_map_context *map_get_privdat(struct ldb_module *module)
92 {
93         return &((struct map_private *)module->private_data)->context;
94 }
95
96 static const struct ldb_map_objectclass *map_find_objectclass_local(struct ldb_map_context *privdat, const char *name)
97 {
98         int i;
99         for (i = 0; privdat->objectclass_maps[i].local_name; i++) {
100                 if (!ldb_attr_cmp(privdat->objectclass_maps[i].local_name, name))
101                         return &privdat->objectclass_maps[i];
102         }
103
104         return NULL;
105 }
106
107 /* Decide whether a add/modify should be pushed to the 
108  * remote LDAP server. We currently only do this if we see an objectClass we know */
109 static BOOL map_is_mappable(struct ldb_map_context *privdat, const struct ldb_message *msg)
110 {
111         int i;
112         struct ldb_message_element *el = ldb_msg_find_element(msg, "objectClass");
113
114         /* No objectClass... */
115         if (el == NULL) {
116                 return False;
117         }
118
119         for (i = 0; i < el->num_values; i++) {
120                 if (map_find_objectclass_local(privdat, (char *)el->values[i].data))
121                         return True;
122         }
123
124         return False;
125 }
126
127 /* find an attribute by the local name */
128 static const struct ldb_map_attribute *map_find_attr_local(struct ldb_map_context *privdat, const char *attr)
129 {
130         int i;
131
132         for (i = 0; privdat->attribute_maps[i].local_name; i++) {
133                 if (!ldb_attr_cmp(privdat->attribute_maps[i].local_name, attr)) 
134                         return &privdat->attribute_maps[i];
135         }
136
137         return NULL;
138 }
139
140 /* find an attribute by the remote name */
141 static const struct ldb_map_attribute *map_find_attr_remote(struct ldb_map_context *privdat, const char *attr)
142 {
143         int i;
144
145         for (i = 0; privdat->attribute_maps[i].local_name; i++) {
146                 if (privdat->attribute_maps[i].type == MAP_IGNORE)
147                         continue;
148
149                 if (privdat->attribute_maps[i].type == MAP_GENERATE)
150                         continue;
151
152                 if (privdat->attribute_maps[i].type == MAP_KEEP &&
153                         ldb_attr_cmp(privdat->attribute_maps[i].local_name, attr) == 0)
154                         return &privdat->attribute_maps[i];
155
156                 if ((privdat->attribute_maps[i].type == MAP_RENAME ||
157                         privdat->attribute_maps[i].type == MAP_CONVERT) &&
158                         ldb_attr_cmp(privdat->attribute_maps[i].u.rename.remote_name, attr) == 0) 
159                         return &privdat->attribute_maps[i];
160
161         }
162
163         return NULL;
164 }
165
166 static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_parse_tree *tree)
167 {
168         int i;
169         const struct ldb_map_attribute *attr;
170         struct ldb_parse_tree *new_tree;
171         enum ldb_map_attr_type map_type;
172         struct ldb_val value, newvalue;
173         struct ldb_map_context *privdat = map_get_privdat(module);
174
175         if (tree == NULL)
176                 return NULL;
177         
178
179         /* Find attr in question and:
180          *  - if it has a convert_operator function, run that
181          *  - otherwise, replace attr name with required[0] */
182
183         if (tree->operation == LDB_OP_AND || 
184                 tree->operation == LDB_OP_OR) {
185                 
186                 new_tree = talloc_memdup(ctx, tree, sizeof(*tree));
187                 new_tree->u.list.elements = talloc_array(new_tree, struct ldb_parse_tree *, tree->u.list.num_elements);
188                 new_tree->u.list.num_elements = 0;
189                 for (i = 0; i < tree->u.list.num_elements; i++) {
190                         struct ldb_parse_tree *child = ldb_map_parse_tree(module, new_tree, tree->u.list.elements[i]);
191                         
192                         if (child) {
193                                 new_tree->u.list.elements[i] = child;
194                                 new_tree->u.list.num_elements++;
195                         }
196                 }
197
198                 return new_tree;
199         }
200                 
201         if (tree->operation == LDB_OP_NOT) {
202                 struct ldb_parse_tree *child;
203                 
204                 new_tree = talloc_memdup(ctx, tree, sizeof(*tree));
205                 child = ldb_map_parse_tree(module, new_tree, tree->u.isnot.child);
206
207                 if (!child) {
208                         talloc_free(new_tree);
209                         return NULL;
210                 }
211
212                 new_tree->u.isnot.child = child;
213                 return new_tree;
214         }
215
216         /* tree->operation is LDB_OP_EQUALITY, LDB_OP_SUBSTRING, LDB_OP_GREATER,
217          * LDB_OP_LESS, LDB_OP_APPROX, LDB_OP_PRESENT or LDB_OP_EXTENDED
218          *
219          * (all have attr as the first element)
220          */
221
222         attr = map_find_attr_local(privdat, tree->u.equality.attr);
223
224         if (!attr) {
225                 ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Unable to find local attribute '%s', leaving as is\n", tree->u.equality.attr);
226                 map_type = MAP_KEEP;
227         } else {
228                 map_type = attr->type;
229         }
230
231         if (attr && attr->convert_operator) {
232                 /* Run convert_operator */
233                 return attr->convert_operator(privdat, module, tree);
234         }
235
236         if (map_type == MAP_IGNORE) {
237                 ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Search on ignored attribute '%s'\n", tree->u.equality.attr);
238                 return NULL;
239         }
240
241         if (map_type == MAP_GENERATE) {
242                 ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Can't do conversion for MAP_GENERATE in map_parse_tree without convert_operator for '%s'\n", tree->u.equality.attr);
243                 return NULL;
244         }
245
246         if (tree->operation == LDB_OP_EQUALITY) {
247                 value = tree->u.equality.value;
248         } else if (tree->operation == LDB_OP_LESS || tree->operation == LDB_OP_GREATER ||
249                            tree->operation == LDB_OP_APPROX) {
250                 value = tree->u.comparison.value;
251         } else if (tree->operation == LDB_OP_EXTENDED) {
252                 value = tree->u.extended.value;
253         }
254         
255         new_tree = talloc_memdup(ctx, tree, sizeof(*tree));
256
257         if (map_type == MAP_KEEP) {
258                 new_tree->u.equality.attr = talloc_strdup(new_tree, tree->u.equality.attr);
259         } else { /* MAP_RENAME / MAP_CONVERT */
260                 new_tree->u.equality.attr = talloc_strdup(new_tree, attr->u.rename.remote_name);
261         }
262
263         if (new_tree->operation == LDB_OP_PRESENT) 
264                 return new_tree;
265                 
266         if (new_tree->operation == LDB_OP_SUBSTRING) {
267                 new_tree->u.substring.chunks = NULL; /* FIXME! */
268                 return new_tree;
269         }
270
271         if (map_type == MAP_CONVERT) {
272                 newvalue = attr->u.convert.convert_local(privdat, new_tree, &value);
273         } else {
274                 newvalue = ldb_val_dup(new_tree, &value);
275         }
276
277         if (new_tree->operation == LDB_OP_EQUALITY) {
278                 new_tree->u.equality.value = newvalue;
279         } else if (new_tree->operation == LDB_OP_LESS || new_tree->operation == LDB_OP_GREATER ||
280                            new_tree->operation == LDB_OP_APPROX) {
281                 new_tree->u.comparison.value = newvalue;
282         } else if (new_tree->operation == LDB_OP_EXTENDED) {
283                 new_tree->u.extended.value = newvalue;
284                 new_tree->u.extended.rule_id = talloc_strdup(new_tree, tree->u.extended.rule_id);
285         }
286         
287         return new_tree;
288 }
289
290 /* Remote DN -> Local DN */
291 static struct ldb_dn *map_remote_dn(struct ldb_map_context *privdat, TALLOC_CTX *ctx, const struct ldb_dn *dn)
292 {
293         struct ldb_dn *newdn;
294         int i;
295
296         if (dn == NULL)
297                 return NULL;
298
299         newdn = talloc_memdup(ctx, dn, sizeof(*dn));
300         if (!newdn) 
301                 return NULL;
302
303         newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num); 
304
305         if (!newdn->components)
306                 return NULL;
307
308         /* For each rdn, map the attribute name and possibly the 
309          * complete rdn */
310         
311         for (i = 0; i < dn->comp_num; i++) {
312                 const struct ldb_map_attribute *attr = map_find_attr_remote(privdat, dn->components[i].name);
313                 enum ldb_map_attr_type map_type;
314
315                 /* Unknown attribute - leave this dn as is and hope the best... */
316                 if (!attr) map_type = MAP_KEEP;
317                 else map_type = attr->type;
318                         
319                 switch (map_type) { 
320                 case MAP_IGNORE:
321                 case MAP_GENERATE:
322                         DEBUG(0, ("Local MAP_IGNORE or MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name));
323                         talloc_free(newdn);
324                         return NULL;
325
326                 case MAP_KEEP:
327                         newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name);
328                         newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value);
329                         break;
330                         
331                 case MAP_CONVERT:
332                         newdn->components[i].name = talloc_strdup(newdn->components, attr->local_name);
333                         newdn->components[i].value = attr->u.convert.convert_remote(privdat, ctx, &dn->components[i].value);
334                         break;
335                         
336                 case MAP_RENAME:
337                         newdn->components[i].name = talloc_strdup(newdn->components, attr->local_name);
338                         newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value);
339                         break;
340                 }
341         }
342         return newdn;
343 }
344
345 /* Local DN -> Remote DN */
346 static struct ldb_dn *map_local_dn(struct ldb_map_context *privdat, TALLOC_CTX *ctx, const struct ldb_dn *dn)
347 {       
348         struct ldb_dn *newdn;
349         int i;
350
351         if (dn == NULL)
352                 return NULL;
353
354         newdn = talloc_memdup(ctx, dn, sizeof(*dn));
355         if (!newdn) 
356                 return NULL;
357
358         newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num); 
359
360         if (!newdn->components)
361                 return NULL;
362
363         /* For each rdn, map the attribute name and possibly the 
364          * complete rdn using an equality convert_operator call */
365         
366         for (i = 0; i < dn->comp_num; i++) {
367                 const struct ldb_map_attribute *attr = map_find_attr_local(privdat, dn->components[i].name);
368                 enum ldb_map_attr_type map_type;
369
370                 /* Unknown attribute - leave this dn as is and hope the best... */
371                 if (!attr) map_type = MAP_KEEP; else map_type = attr->type;
372                 
373                 switch (map_type) 
374                 {
375                         case MAP_IGNORE: 
376                         case MAP_GENERATE:
377                         DEBUG(0, ("Local MAP_IGNORE/MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name));
378                         talloc_free(newdn);
379                         return NULL;
380
381                         case MAP_CONVERT: 
382                                 newdn->components[i].name = talloc_strdup(newdn->components, attr->u.convert.remote_name);
383                                 newdn->components[i].value = attr->u.convert.convert_local(privdat, newdn->components, &dn->components[i].value);
384                         break;
385                         
386                         case MAP_RENAME:
387                                 newdn->components[i].name = talloc_strdup(newdn->components, attr->u.rename.remote_name);
388                                 newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value);
389                         break;
390
391                         case MAP_KEEP:
392                                 newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name);
393                                 newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value);
394                         continue;
395                 }
396         }
397
398         return newdn;
399 }
400
401 /* Loop over ldb_map_attribute array and add remote_names */
402 static const char **ldb_map_attrs(struct ldb_module *module, const char *const attrs[])
403 {
404         int i;
405         const char **ret;
406         int ar_size = 0, last_element = 0;
407         struct ldb_map_context *privdat = map_get_privdat(module);
408
409         if (attrs == NULL) 
410                 return NULL;
411
412         /* Start with good guess of number of elements */
413         for (i = 0; attrs[i]; i++);
414
415         ret = talloc_array(module, const char *, i);
416         ar_size = i;
417
418         for (i = 0; attrs[i]; i++) {
419                 int j;
420                 const struct ldb_map_attribute *attr = map_find_attr_local(privdat, attrs[i]);
421                 enum ldb_map_attr_type map_type;
422
423                 if (!attr) {
424                         ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Local attribute '%s' does not have a definition!\n", attrs[i]);
425                         map_type = MAP_IGNORE;
426                 } else map_type = attr->type;
427
428                 switch (map_type)
429                 { 
430                         case MAP_IGNORE: break;
431                         case MAP_KEEP: 
432                                 if (last_element >= ar_size) {
433                                         ret = talloc_realloc(module, ret, const char *, ar_size+1);
434                                         ar_size++;
435                                 }
436                                 ret[last_element] = attr->local_name;
437                                 last_element++;
438                                 break;
439
440                         case MAP_RENAME:
441                         case MAP_CONVERT:
442                                 if (last_element >= ar_size) {
443                                         ret = talloc_realloc(module, ret, const char *, ar_size+1);
444                                         ar_size++;
445                                 }
446                                 ret[last_element] = attr->u.rename.remote_name;
447                                 last_element++;
448                                 break;
449
450                         case MAP_GENERATE:
451                                 /* Add remote_names[] for this attribute to the list of 
452                                  * attributes to request from the remote server */
453                                 for (j = 0; attr->u.generate.remote_names[j]; j++) {
454                                         if (last_element >= ar_size) {
455                                                 ret = talloc_realloc(module, ret, const char *, ar_size+1);
456                                                 ar_size++;
457                                         }
458                                         ret[last_element] = attr->u.generate.remote_names[j];                   
459                                         last_element++;
460                                 }
461                                 break;
462                 } 
463         }
464         
465         if (last_element >= ar_size) {
466                 ret = talloc_realloc(module, ret, const char *, ar_size+1);
467                 ar_size++;
468         }
469
470         ret[last_element] = NULL;
471
472         return ret;
473 }
474
475 static const char **available_local_attributes(struct ldb_module *module, const struct ldb_message *msg)
476 {
477         struct ldb_map_context *privdat = map_get_privdat(module);
478         int i, j;
479         int count = 0;
480         const char **ret = talloc_array(module, const char *, 1);
481
482         ret[0] = NULL;
483
484         for (i = 0; privdat->attribute_maps[i].local_name; i++) {
485                 BOOL avail = False;
486                 const struct ldb_map_attribute *attr = &privdat->attribute_maps[i];
487
488                 /* If all remote attributes for this attribute are present, add the 
489                  * local one to the list */
490                 
491                 switch (attr->type) {
492                 case MAP_IGNORE: break;
493                 case MAP_KEEP: 
494                                 avail = (ldb_msg_find_ldb_val(msg, attr->local_name) != NULL); 
495                                 break;
496                                 
497                 case MAP_RENAME:
498                 case MAP_CONVERT:
499                                 avail = (ldb_msg_find_ldb_val(msg, attr->u.rename.remote_name) != NULL);
500                                 break;
501
502                 case MAP_GENERATE:
503                                 avail = True;
504                                 for (j = 0; attr->u.generate.remote_names[j]; j++) {
505                                         avail &= (ldb_msg_find_ldb_val(msg, attr->u.generate.remote_names[j]) != NULL);
506                                 }
507                                 break;
508                 }
509
510                 if (!avail)
511                         continue;
512
513                 ret = talloc_realloc(module, ret, const char *, count+2);
514                 ret[count] = attr->local_name;
515                 ret[count+1] = NULL;
516                 count++;
517         }
518
519         return ret;
520 }
521
522 /* Used for search */
523 static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const char * const*attrs, const struct ldb_message *mi)
524 {
525         int i, j;
526         struct ldb_message *msg = talloc_zero(module, struct ldb_message);
527         struct ldb_message_element *elm, *oldelm;
528         struct ldb_map_context *privdat = map_get_privdat(module);
529         const char **newattrs = NULL;
530
531         msg->dn = map_remote_dn(privdat, module, mi->dn);
532
533         ldb_msg_add_string(module->ldb, msg, "mappedFromDn", ldb_dn_linearize(msg, mi->dn));
534
535         /* Loop over attrs, find in ldb_map_attribute array and 
536          * run generate() */
537
538         if (attrs == NULL) {
539                 /* Generate list of the local attributes that /can/ be generated
540                  * using the specific remote attributes */
541
542                 attrs = newattrs = available_local_attributes(module, mi);
543         }
544
545         for (i = 0; attrs[i]; i++) {
546                 const struct ldb_map_attribute *attr = map_find_attr_local(privdat, attrs[i]);
547                 enum ldb_map_attr_type map_type;
548
549                 if (!attr) {
550                         ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Unable to find local attribute '%s' when generating incoming message\n", attrs[i]);
551                         map_type = MAP_IGNORE;
552                 } else map_type = attr->type;
553
554                 switch (map_type) {
555                         case MAP_IGNORE:break;
556                         case MAP_RENAME:
557                                 oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name);
558                                 if (!oldelm) continue;
559
560                                 elm = talloc(msg, struct ldb_message_element);
561                                 elm->name = talloc_strdup(elm, attr->local_name);
562                                 elm->num_values = oldelm->num_values;
563                                 elm->values = talloc_reference(elm, oldelm->values);
564
565                                 ldb_msg_add(module->ldb, msg, elm, oldelm->flags);
566                                 break;
567                                 
568                         case MAP_CONVERT:
569                                 oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name);
570                                 if (!oldelm) continue;
571
572                                 elm = talloc(msg, struct ldb_message_element);
573                                 elm->name = talloc_strdup(elm, attr->local_name);
574                                 elm->num_values = oldelm->num_values;
575                                 elm->values = talloc_array(elm, struct ldb_val, elm->num_values);
576
577                                 for (j = 0; j < oldelm->num_values; j++)
578                                         elm->values[j] = attr->u.convert.convert_remote(privdat, elm, &oldelm->values[j]);
579
580                                 ldb_msg_add(module->ldb, msg, elm, oldelm->flags);
581                                 break;
582
583                         case MAP_KEEP:
584                                 oldelm = ldb_msg_find_element(mi, attr->local_name);
585                                 if (!oldelm) continue;
586                                 
587                                 elm = talloc(msg, struct ldb_message_element);
588
589                                 elm->num_values = oldelm->num_values;
590                                 elm->values = talloc_reference(elm, oldelm->values);
591                                 elm->name = talloc_strdup(elm, oldelm->name);
592
593                                 ldb_msg_add(module->ldb, msg, elm, oldelm->flags);
594                                 break;
595
596                         case MAP_GENERATE:
597                                 elm = attr->u.generate.generate_local(privdat, msg, attr->local_name, mi);
598                                 if (!elm) continue;
599
600                                 ldb_msg_add(module->ldb, msg, elm, elm->flags);
601                                 break;
602                         default: 
603                                 ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Unknown attr->type for %s", attr->local_name);
604                                 break;
605                 }
606         }
607
608         talloc_free(newattrs);
609
610         return msg;
611 }
612
613 /* Used for add, modify */
614 static int ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mo, struct ldb_message **fb, struct ldb_message **mp)
615 {
616         struct ldb_map_context *privdat = map_get_privdat(module);
617         struct ldb_message *msg = talloc_zero(module, struct ldb_message);
618         struct ldb_message_element *elm;
619         int i,j;
620
621         *fb = talloc_zero(module, struct ldb_message);
622         (*fb)->dn = talloc_reference(*fb, mo->dn);
623
624         *mp = msg;
625
626         msg->private_data = mo->private_data;
627         
628         msg->dn = map_local_dn(privdat, module, mo->dn);
629
630         /* Loop over mi and call generate_remote for each attribute */
631         for (i = 0; i < mo->num_elements; i++) {
632                 const struct ldb_map_attribute *attr = map_find_attr_local(privdat, mo->elements[i].name);
633                 enum ldb_map_attr_type map_type;
634
635                 if (!attr) {
636                         ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Undefined local attribute '%s', ignoring\n", mo->elements[i].name);
637                         map_type = MAP_IGNORE;
638                         continue;
639                 } else map_type = attr->type;
640
641                 switch (map_type) {
642                 case MAP_IGNORE: /* Add to fallback message */
643                         elm = talloc(*fb, struct ldb_message_element);
644
645                         elm->num_values = mo->elements[i].num_values;
646                         elm->values = talloc_reference(elm, mo->elements[i].values);
647                         elm->name = talloc_strdup(elm, mo->elements[i].name);
648                         
649                         ldb_msg_add(module->ldb, *fb, elm, mo->elements[i].flags);      
650                         break;
651                 case MAP_RENAME:
652                         elm = talloc(msg, struct ldb_message_element);
653
654                         elm->name = talloc_strdup(elm, attr->u.rename.remote_name);
655                         elm->num_values = mo->elements[i].num_values;
656                         elm->values = talloc_reference(elm, mo->elements[i].values);
657
658                         ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags);
659                         break;
660
661                 case MAP_CONVERT:
662                         elm = talloc(msg, struct ldb_message_element);
663
664                         elm->name = talloc_strdup(elm, attr->u.rename.remote_name);
665                         elm->num_values = mo->elements[i].num_values;
666                         elm->values = talloc_array(elm, struct ldb_val, elm->num_values);
667                         
668                         for (j = 0; j < elm->num_values; j++) {
669                                 elm->values[j] = attr->u.convert.convert_local(privdat, msg, &mo->elements[i].values[j]);
670                         }
671
672                         ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags);
673                         break;
674
675                 case MAP_KEEP:
676                         elm = talloc(msg, struct ldb_message_element);
677
678                         elm->num_values = mo->elements[i].num_values;
679                         elm->values = talloc_reference(elm, mo->elements[i].values);
680                         elm->name = talloc_strdup(elm, mo->elements[i].name);
681                         
682                         ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags);      
683                         break;
684
685                 case MAP_GENERATE:
686                         attr->u.generate.generate_remote(privdat, attr->local_name, mo, msg);
687                         break;
688                 } 
689         }
690
691         return 0;
692 }
693
694
695 /*
696   rename a record
697 */
698 static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
699 {
700         struct ldb_map_context *privdat = map_get_privdat(module);
701         struct ldb_dn *n_olddn, *n_newdn;
702         int ret;
703
704         ret = ldb_next_rename_record(module, olddn, newdn);
705         
706         n_olddn = map_local_dn(privdat, module, olddn);
707         n_newdn = map_local_dn(privdat, module, newdn);
708
709         ret = ldb_rename(privdat->mapped_ldb, n_olddn, n_newdn);
710
711         talloc_free(n_olddn);
712         talloc_free(n_newdn);
713         
714         return ret;
715 }
716
717 /*
718   delete a record
719 */
720 static int map_delete(struct ldb_module *module, const struct ldb_dn *dn)
721 {
722         struct ldb_map_context *privdat = map_get_privdat(module);
723         struct ldb_dn *newdn;
724         int ret;
725
726         ret = ldb_next_delete_record(module, dn);
727         
728         newdn = map_local_dn(privdat, module, dn);
729
730         ret = ldb_delete(privdat->mapped_ldb, newdn);
731
732         talloc_free(newdn);
733
734         return ret;
735 }
736
737 /* search fallback database */
738 static int map_search_bytree_fb(struct ldb_module *module, const struct ldb_dn *base,
739                               enum ldb_scope scope, struct ldb_parse_tree *tree,
740                               const char * const *attrs, struct ldb_message ***res)
741 {
742         int ret;
743         struct ldb_parse_tree t_and, t_not, t_present, *childs[2];
744
745         t_present.operation = LDB_OP_PRESENT;
746         t_present.u.present.attr = talloc_strdup(NULL, "isMapped");
747
748         t_not.operation = LDB_OP_NOT;
749         t_not.u.isnot.child = &t_present;
750
751         childs[0] = &t_not;
752         childs[1] = tree;
753         t_and.operation = LDB_OP_AND;
754         t_and.u.list.num_elements = 2;
755         t_and.u.list.elements = childs;
756         
757         ret = ldb_next_search_bytree(module, base, scope, &t_and, attrs, res);
758
759         talloc_free(t_present.u.present.attr);
760
761         return ret;
762 }
763
764 static int map_search_bytree_mp(struct ldb_module *module, const struct ldb_dn *base,
765                               enum ldb_scope scope, struct ldb_parse_tree *tree,
766                               const char * const *attrs, struct ldb_message ***res)
767 {
768         struct ldb_parse_tree *new_tree;
769         struct ldb_dn *new_base;
770         struct ldb_message **newres;
771         const char **newattrs;
772         int mpret, ret;
773         struct ldb_map_context *privdat = map_get_privdat(module);
774         int i;
775
776         /*- search mapped database */
777
778         new_tree = ldb_map_parse_tree(module, module, tree);
779         newattrs = ldb_map_attrs(module, attrs); 
780         new_base = map_local_dn(privdat, module, base);
781
782         mpret = ldb_search_bytree(privdat->mapped_ldb, new_base, scope, new_tree, newattrs, &newres);
783
784         talloc_free(new_base);
785         talloc_free(new_tree);
786         talloc_free(newattrs);
787
788         if (mpret == -1) {
789                 struct map_private *map_private = module->private_data;
790                 map_private->last_err_string = ldb_errstring(privdat->mapped_ldb);
791                 return -1;
792         }
793
794         /*
795          - per returned record, search fallback database for additional data (by dn)
796          - test if (full expression) is now true
797         */
798
799         *res = talloc_array(module, struct ldb_message *, mpret);
800
801         ret = 0;
802
803         for (i = 0; i < mpret; i++) {
804                 struct ldb_message *merged = ldb_map_message_incoming(module, attrs, newres[i]);
805                 struct ldb_message **extrares = NULL;
806                 int extraret;
807                 
808                 /* Merge with additional data from local database */
809                 extraret = ldb_next_search(module, merged->dn, LDB_SCOPE_BASE, "", NULL, &extrares);
810
811                 if (extraret == -1) {
812                         ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Error searching for extra data!\n");
813                 } else if (extraret > 1) {
814                         ldb_debug(module->ldb, LDB_DEBUG_ERROR, "More than one result for extra data!\n");
815                         talloc_free(newres);
816                         return -1;
817                 } else if (extraret == 0) {
818                         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "No extra data found for remote DN");
819                 }
820                 
821                 if (extraret == 1) {
822                         int j;
823                         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Extra data found for remote DN");
824                         for (j = 0; j < extrares[0]->num_elements; j++) {
825                                 ldb_msg_add(module->ldb, merged, &(extrares[0]->elements[j]), extrares[0]->elements[j].flags);
826                         }
827
828                         ldb_msg_add_string(module->ldb, merged, "extraMapped", "TRUE");
829                 } else {
830                         ldb_msg_add_string(module->ldb, merged, "extraMapped", "FALSE");
831                 }
832                 
833                 if (ldb_match_msg(module->ldb, merged, tree, base, scope)) {
834                         (*res)[ret] = merged;
835                         ret++;
836                 } else {
837                         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Discarded merged message because it did not match");
838                 }
839         }
840
841         talloc_free(newres);
842
843         return ret;
844 }
845
846
847 /*
848   search for matching records using a ldb_parse_tree
849 */
850 static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
851                               enum ldb_scope scope, struct ldb_parse_tree *tree,
852                               const char * const *attrs, struct ldb_message ***res)
853 {
854         struct ldb_message **fbres, **mpres;
855         int i;
856         int ret_fb, ret_mp;
857
858         ret_fb = map_search_bytree_fb(module, base, scope, tree, attrs, &fbres);
859         if (ret_fb == -1) 
860                 return -1;
861
862         ret_mp = map_search_bytree_mp(module, base, scope, tree, attrs, &mpres);
863         if (ret_mp == -1) {
864                 return -1;
865         }
866
867         /* Merge results */
868         *res = talloc_array(module, struct ldb_message *, ret_fb + ret_mp);
869
870         for (i = 0; i < ret_fb; i++) (*res)[i] = fbres[i];
871         for (i = 0; i < ret_mp; i++) (*res)[ret_fb+i] = mpres[i];
872
873         return ret_fb + ret_mp;
874 }
875 /*
876   search for matching records
877 */
878 static int map_search(struct ldb_module *module, const struct ldb_dn *base,
879                        enum ldb_scope scope, const char *expression,
880                        const char * const *attrs, struct ldb_message ***res)
881 {
882         struct map_private *map = module->private_data;
883         struct ldb_parse_tree *tree;
884         int ret;
885
886         tree = ldb_parse_tree(NULL, expression);
887         if (tree == NULL) {
888                 map->last_err_string = "expression parse failed";
889                 return -1;
890         }
891
892         ret = map_search_bytree(module, base, scope, tree, attrs, res);
893         talloc_free(tree);
894         return ret;
895 }
896
897 /*
898   add a record
899 */
900 static int map_add(struct ldb_module *module, const struct ldb_message *msg)
901 {
902         int ret;
903         struct ldb_map_context *privdat = map_get_privdat(module);
904         struct ldb_message *fb, *mp;
905
906         if (!map_is_mappable(privdat, msg)) {
907                 return ldb_next_add_record(module, msg);
908         }
909
910         if (ldb_map_message_outgoing(module, msg, &fb, &mp) == -1)
911                 return -1;
912                 
913         ldb_msg_add_string(module->ldb, fb, "isMapped", "TRUE");
914
915         ret = ldb_next_add_record(module, fb);
916         if (ret == -1) {
917                 ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Adding fallback record failed");
918                 return -1;
919         }
920                 
921         ret = ldb_add(privdat->mapped_ldb, mp);
922         if (ret == -1) {
923                 ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Adding mapped record failed");
924                 return -1;
925         }
926
927         talloc_free(fb);
928         talloc_free(mp);
929
930         return ret;
931 }
932
933
934 /*
935   modify a record
936 */
937 static int map_modify(struct ldb_module *module, const struct ldb_message *msg)
938 {
939         struct ldb_map_context *privdat = map_get_privdat(module);
940         struct ldb_message *fb, *mp;
941         int ret;
942
943         if (!map_is_mappable(privdat, msg))
944                 return ldb_next_modify_record(module, msg);
945                 
946
947         if (ldb_map_message_outgoing(module, msg, &fb, &mp) == -1)
948                 return -1;
949                 
950         ldb_msg_add_string(module->ldb, fb, "isMapped", "TRUE");
951
952         ret = ldb_next_modify_record(module, fb);
953
954         ret = ldb_modify(privdat->mapped_ldb, mp);
955
956         talloc_free(fb);
957         talloc_free(mp);
958
959         return ret;
960 }
961
962 static int map_lock(struct ldb_module *module, const char *lockname)
963 {
964         return ldb_next_named_lock(module, lockname);
965 }
966
967 static int map_unlock(struct ldb_module *module, const char *lockname)
968 {
969         return ldb_next_named_unlock(module, lockname);
970 }
971
972 /*
973   return extended error information
974 */
975 static const char *map_errstring(struct ldb_module *module)
976 {
977         struct map_private *map = module->private_data;
978         
979         if (map->last_err_string)
980                 return map->last_err_string;
981
982         return ldb_next_errstring(module);
983 }
984
985 static const struct ldb_module_ops map_ops = {
986         .name          = "map",
987         .search        = map_search,
988         .search_bytree = map_search_bytree,
989         .add_record    = map_add,
990         .modify_record = map_modify,
991         .delete_record = map_delete,
992         .rename_record = map_rename,
993         .named_lock    = map_lock,
994         .named_unlock  = map_unlock,
995         .errstring     = map_errstring
996 };
997
998 static char *map_find_url(struct ldb_context *ldb, const char *name)
999 {
1000         const char * const attrs[] = { "@MAP_URL" , NULL};
1001         struct ldb_message **msg = NULL;
1002         struct ldb_dn *mods;
1003         char *url;
1004         int ret;
1005
1006         mods = ldb_dn_string_compose(ldb, NULL, "@MAP=%s", name);
1007         if (mods == NULL) {
1008                 ldb_debug(ldb, LDB_DEBUG_ERROR, "Can't construct DN");
1009                 return NULL;
1010         }
1011
1012         ret = ldb_search(ldb, mods, LDB_SCOPE_BASE, "", attrs, &msg);
1013         talloc_free(mods);
1014         if (ret < 1) {
1015                 ldb_debug(ldb, LDB_DEBUG_ERROR, "Not enough results found looking for @MAP");
1016                 return NULL;
1017         }
1018
1019         url = talloc_strdup(ldb, ldb_msg_find_string(msg[0], "@MAP_URL", NULL));
1020
1021         talloc_free(msg);
1022
1023         return url;
1024 }
1025
1026 /* the init function */
1027 struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_attribute *attrs, const struct ldb_map_objectclass *ocls, const char *name)
1028 {
1029         int i, j;
1030         struct ldb_module *ctx;
1031         struct map_private *data;
1032         char *url;
1033
1034         ctx = talloc(ldb, struct ldb_module);
1035         if (!ctx)
1036                 return NULL;
1037
1038         data = talloc(ctx, struct map_private);
1039         if (!data) {
1040                 talloc_free(ctx);
1041                 return NULL;
1042         }
1043
1044         data->context.mapped_ldb = ldb_init(data);
1045         url = map_find_url(ldb, name);
1046
1047         if (!url) {
1048                 ldb_debug(ldb, LDB_DEBUG_FATAL, "@MAP=%s not set!\n", name);
1049                 return NULL;
1050         }
1051
1052         if (ldb_connect(data->context.mapped_ldb, url, 0, NULL) != 0) {
1053                 ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to open mapped database for %s at '%s'\n", name, url);
1054                 return NULL;
1055         }
1056
1057         talloc_free(url);
1058
1059         data->last_err_string = NULL;
1060
1061         /* Get list of attribute maps */
1062         j = 0;
1063         data->context.attribute_maps = NULL;
1064
1065         for (i = 0; attrs[i].local_name; i++) {
1066                 data->context.attribute_maps = talloc_realloc(data, data->context.attribute_maps, struct ldb_map_attribute, j+1);
1067                 data->context.attribute_maps[j] = attrs[i];
1068                 j++;
1069         }
1070
1071         for (i = 0; builtin_attribute_maps[i].local_name; i++) {
1072                 data->context.attribute_maps = talloc_realloc(data, data->context.attribute_maps, struct ldb_map_attribute, j+1);
1073                 data->context.attribute_maps[j] = builtin_attribute_maps[i];
1074                 j++;
1075         }
1076
1077         data->context.attribute_maps = talloc_realloc(data, data->context.attribute_maps, struct ldb_map_attribute, j+1);
1078         ZERO_STRUCT(data->context.attribute_maps[j].local_name);
1079
1080         data->context.objectclass_maps = ocls;
1081         ctx->private_data = data;
1082         ctx->ldb = ldb;
1083         ctx->prev = ctx->next = NULL;
1084         ctx->ops = &map_ops;
1085
1086         return ctx;
1087 }
1088
1089 static struct ldb_val map_convert_local_dn(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val)
1090 {
1091         struct ldb_dn *dn, *newdn;;
1092         struct ldb_val *newval;
1093
1094         dn = ldb_dn_explode(ctx, (char *)val->data);
1095
1096         newdn = map_local_dn(map, ctx, dn);
1097
1098         talloc_free(dn);
1099
1100         newval = talloc(ctx, struct ldb_val);
1101         newval->data = (uint8_t *)ldb_dn_linearize(ctx, newdn);
1102         newval->length = strlen((char *)newval->data);
1103
1104         talloc_free(newdn);
1105
1106         return *newval;
1107 }
1108
1109 static struct ldb_val map_convert_remote_dn(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val)
1110 {
1111         struct ldb_dn *dn, *newdn;;
1112         struct ldb_val *newval;
1113
1114         dn = ldb_dn_explode(ctx, (char *)val->data);
1115
1116         newdn = map_remote_dn(map, ctx, dn);
1117
1118         talloc_free(dn);
1119
1120         newval = talloc(ctx, struct ldb_val);
1121         newval->data = (uint8_t *)ldb_dn_linearize(ctx, newdn);
1122         newval->length = strlen((char *)newval->data);
1123
1124         talloc_free(newdn);
1125
1126         return *newval;
1127 }
1128
1129 static struct ldb_val map_convert_local_objectclass(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val)
1130 {
1131         int i;
1132
1133         for (i = 0; map->objectclass_maps[i].local_name; i++) {
1134                 if (!strcmp(map->objectclass_maps[i].local_name, (char *)val->data)) {
1135                         struct ldb_val newval;
1136                         newval.data = (uint8_t*)talloc_strdup(ctx, map->objectclass_maps[i].remote_name);
1137                         newval.length = strlen((char *)newval.data);
1138
1139                         return ldb_val_dup(ctx, &newval);
1140                 }
1141         }
1142
1143         return ldb_val_dup(ctx, val); 
1144 }
1145
1146 static struct ldb_val map_convert_remote_objectclass(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val)
1147 {
1148         int i;
1149
1150         for (i = 0; map->objectclass_maps[i].remote_name; i++) {
1151                 if (!strcmp(map->objectclass_maps[i].remote_name, (char *)val->data)) {
1152                         struct ldb_val newval;
1153                         newval.data = (uint8_t*)talloc_strdup(ctx, map->objectclass_maps[i].local_name);
1154                         newval.length = strlen((char *)newval.data);
1155
1156                         return ldb_val_dup(ctx, &newval);
1157                 }
1158         }
1159
1160         return ldb_val_dup(ctx, val); 
1161 }
1162