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