r9685: Add tests for samba3sam mapping module
[sfrench/samba-autobuild/.git] / source4 / lib / ldb / common / ldb_modules.c
1
2 /* 
3    ldb database library
4
5    Copyright (C) Simo Sorce  2004
6
7      ** NOTE! The following LGPL license applies to the ldb
8      ** library. This does NOT imply that all of Samba is released
9      ** under the LGPL
10    
11    This library is free software; you can redistribute it and/or
12    modify it under the terms of the GNU Lesser General Public
13    License as published by the Free Software Foundation; either
14    version 2 of the License, or (at your option) any later version.
15
16    This library is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19    Lesser General Public License for more details.
20
21    You should have received a copy of the GNU Lesser General Public
22    License along with this library; if not, write to the Free Software
23    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
24 */
25
26 /*
27  *  Name: ldb
28  *
29  *  Component: ldb modules core
30  *
31  *  Description: core modules routines
32  *
33  *  Author: Simo Sorce
34  */
35
36 #include "includes.h"
37 #include "ldb/include/ldb.h"
38 #include "ldb/include/ldb_private.h"
39 #include "dlinklist.h"
40 #include <sys/types.h> 
41 #include <sys/stat.h> 
42 #include <unistd.h> 
43
44 #ifdef HAVE_DLOPEN_DISABLED
45 #include <dlfcn.h>
46 #endif
47
48 #define LDB_MODULE_PREFIX       "modules:"
49 #define LDB_MODULE_PREFIX_LEN   8
50
51 static char *talloc_strdup_no_spaces(struct ldb_context *ldb, const char *string)
52 {
53         int i, len;
54         char *trimmed;
55
56         trimmed = talloc_strdup(ldb, string);
57         if (!trimmed) {
58                 ldb_debug(ldb, LDB_DEBUG_FATAL, "Out of Memory in talloc_strdup_trim_spaces()\n");
59                 return NULL;
60         }
61
62         len = strlen(trimmed);
63         for (i = 0; trimmed[i] != '\0'; i++) {
64                 switch (trimmed[i]) {
65                 case ' ':
66                 case '\t':
67                 case '\n':
68                         memmove(&trimmed[i], &trimmed[i + 1], len -i -1);
69                         break;
70                 }
71         }
72
73         return trimmed;
74 }
75
76
77 /* modules are called in inverse order on the stack.
78    Lets place them as an admin would think the right order is.
79    Modules order is imprtant */
80 static char **ldb_modules_list_from_string(struct ldb_context *ldb, const char *string)
81 {
82         char **modules = NULL;
83         char *modstr, *p;
84         int i;
85
86         /* spaces not admitted */
87         modstr = talloc_strdup_no_spaces(ldb, string);
88         if ( ! modstr) {
89                 return NULL;
90         }
91
92         modules = talloc_realloc(ldb, modules, char *, 2);
93         if ( ! modules ) {
94                 ldb_debug(ldb, LDB_DEBUG_FATAL, "Out of Memory in ldb_modules_list_from_string()\n");
95                 talloc_free(modstr);
96                 return NULL;
97         }
98         talloc_steal(modules, modstr);
99
100         i = 0;
101         while ((p = strrchr(modstr, ',')) != NULL) {
102                 *p = '\0';
103                 p++;
104                 modules[i] = p;
105
106                 i++;
107                 modules = talloc_realloc(ldb, modules, char *, i + 2);
108                 if ( ! modules ) {
109                         ldb_debug(ldb, LDB_DEBUG_FATAL, "Out of Memory in ldb_modules_list_from_string()\n");
110                         return NULL;
111                 }
112
113         }
114         modules[i] = modstr;
115
116         modules[i + 1] = NULL;
117
118         return modules;
119 }
120
121 int ldb_load_modules(struct ldb_context *ldb, const char *options[])
122 {
123         char **modules = NULL;
124         int i;
125
126         /* find out which modules we are requested to activate */
127
128         /* check if we have a custom module list passd as ldb option */
129         if (options) {
130                 for (i = 0; options[i] != NULL; i++) {
131                         if (strncmp(options[i], LDB_MODULE_PREFIX, LDB_MODULE_PREFIX_LEN) == 0) {
132                                 modules = ldb_modules_list_from_string(ldb, &options[i][LDB_MODULE_PREFIX_LEN]);
133                         }
134                 }
135         }
136
137         /* if not overloaded by options and the backend is not ldap try to load the modules list form ldb */
138         if ((modules == NULL) && (strcmp("ldap", ldb->modules->ops->name) != 0)) { 
139                 int ret;
140                 const char * const attrs[] = { "@LIST" , NULL};
141                 struct ldb_message **msg = NULL;
142                 struct ldb_dn *mods;
143
144                 mods = ldb_dn_explode(ldb, "@MODULES");
145                 if (mods == NULL) {
146                         return -1;
147                 }
148
149                 ret = ldb_search(ldb, mods, LDB_SCOPE_BASE, "", attrs, &msg);
150                 talloc_free(mods);
151                 if (ret == 0 || (ret == 1 && msg[0]->num_elements == 0)) {
152                         ldb_debug(ldb, LDB_DEBUG_TRACE, "no modules required by the db\n");
153                 } else {
154                         if (ret < 0) {
155                                 ldb_debug(ldb, LDB_DEBUG_FATAL, "ldb error (%s) occurred searching for modules, bailing out\n", ldb_errstring(ldb));
156                                 return -1;
157                         }
158                         if (ret > 1) {
159                                 ldb_debug(ldb, LDB_DEBUG_FATAL, "Too many records found, bailing out\n");
160                                 talloc_free(msg);
161                                 return -1;
162                         }
163
164                         modules = ldb_modules_list_from_string(ldb, msg[0]->elements[0].values[0].data);
165
166                 }
167
168                 talloc_free(msg);
169         }
170
171         if (modules == NULL) {
172                 ldb_debug(ldb, LDB_DEBUG_TRACE, "No modules specified for this database\n");
173                 return 0;
174         }
175
176         for (i = 0; modules[i] != NULL; i++) {
177                 struct ldb_module *current;
178
179                 if (strcmp(modules[i], "schema") == 0) {
180                         current = schema_module_init(ldb, options);
181                         if (!current) {
182                                 ldb_debug(ldb, LDB_DEBUG_FATAL, "function 'init_module' in %s fails\n", modules[i]);
183                                 return -1;
184                         }
185                         DLIST_ADD(ldb->modules, current);
186                         continue;
187                 }
188
189                 if (strcmp(modules[i], "timestamps") == 0) {
190                         current = timestamps_module_init(ldb, options);
191                         if (!current) {
192                                 ldb_debug(ldb, LDB_DEBUG_FATAL, "function 'init_module' in %s fails\n", modules[i]);
193                                 return -1;
194                         }
195                         DLIST_ADD(ldb->modules, current);
196                         continue;
197                 }
198
199                 if (strcmp(modules[i], "rdn_name") == 0) {
200                         current = rdn_name_module_init(ldb, options);
201                         if (!current) {
202                                 ldb_debug(ldb, LDB_DEBUG_FATAL, "function 'init_module' in %s fails\n", modules[i]);
203                                 return -1;
204                         }
205                         DLIST_ADD(ldb->modules, current);
206                         continue;
207                 }
208
209 #ifdef _SAMBA_BUILD_
210                 if (strcmp(modules[i], "objectguid") == 0) {
211                         current = objectguid_module_init(ldb, options);
212                         if (!current) {
213                                 ldb_debug(ldb, LDB_DEBUG_FATAL, "function 'init_module' in %s fails\n", modules[i]);
214                                 return -1;
215                         }
216                         DLIST_ADD(ldb->modules, current);
217                         continue;
218                 }
219
220                 if (strcmp(modules[i], "samldb") == 0) {
221                         current = samldb_module_init(ldb, options);
222                         if (!current) {
223                                 ldb_debug(ldb, LDB_DEBUG_FATAL, "function 'init_module' in %s fails\n", modules[i]);
224                                 return -1;
225                         }
226                         DLIST_ADD(ldb->modules, current);
227                         continue;
228                 }
229
230                 if (strcmp(modules[i], "samba3sam") == 0) {
231                         current = ldb_samba3sam_module_init(ldb, options);
232                         if (!current) {
233                                 ldb_debug(ldb, LDB_DEBUG_FATAL, "function 'init_module' in %s fails\n", modules[i]);
234                                 return -1;
235                         }
236                         DLIST_ADD(ldb->modules, current);
237                         continue;
238                 }
239
240 #endif
241
242                 ldb_debug(ldb, LDB_DEBUG_WARNING, "WARNING: Module [%s] not found\n", modules[i]);
243         }
244
245         talloc_free(modules);
246         return 0; 
247 }
248
249 /*
250    helper functions to call the next module in chain
251 */
252
253 int ldb_next_search(struct ldb_module *module, 
254                     const struct ldb_dn *base,
255                     enum ldb_scope scope,
256                     const char *expression,
257                     const char * const *attrs, struct ldb_message ***res)
258 {
259         if (!module->next) {
260                 return -1;
261         }
262         return module->next->ops->search(module->next, base, scope, expression, attrs, res);
263 }
264
265 int ldb_next_search_bytree(struct ldb_module *module, 
266                            const struct ldb_dn *base,
267                            enum ldb_scope scope,
268                            struct ldb_parse_tree *tree,
269                            const char * const *attrs, struct ldb_message ***res)
270 {
271         if (!module->next) {
272                 return -1;
273         }
274         return module->next->ops->search_bytree(module->next, base, scope, tree, attrs, res);
275 }
276
277 int ldb_next_add_record(struct ldb_module *module, const struct ldb_message *message)
278 {
279         if (!module->next) {
280                 return -1;
281         }
282         return module->next->ops->add_record(module->next, message);
283 }
284
285 int ldb_next_modify_record(struct ldb_module *module, const struct ldb_message *message)
286 {
287         if (!module->next) {
288                 return -1;
289         }
290         return module->next->ops->modify_record(module->next, message);
291 }
292
293 int ldb_next_delete_record(struct ldb_module *module, const struct ldb_dn *dn)
294 {
295         if (!module->next) {
296                 return -1;
297         }
298         return module->next->ops->delete_record(module->next, dn);
299 }
300
301 int ldb_next_rename_record(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
302 {
303         if (!module->next) {
304                 return -1;
305         }
306         return module->next->ops->rename_record(module->next, olddn, newdn);
307 }
308
309 int ldb_next_named_lock(struct ldb_module *module, const char *lockname)
310 {
311         if (!module->next) {
312                 return -1;
313         }
314         return module->next->ops->named_lock(module->next, lockname);
315 }
316
317 int ldb_next_named_unlock(struct ldb_module *module, const char *lockname)
318 {
319         if (!module->next) {
320                 return -1;
321         }
322         return module->next->ops->named_unlock(module->next, lockname);
323 }
324
325 const char *ldb_next_errstring(struct ldb_module *module)
326 {
327         if (!module->next) {
328                 return NULL;
329         }
330         return module->next->ops->errstring(module->next);
331 }
332