5 Copyright (C) Simo Sorce 2004
7 ** NOTE! The following LGPL license applies to the ldb
8 ** library. This does NOT imply that all of Samba is released
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 3 of the License, or (at your option) any later version.
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.
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
29 * Component: ldb modules core
31 * Description: core modules routines
37 #include "ldb/include/includes.h"
39 #if (_SAMBA_BUILD_ >= 4)
41 #include "dynconfig.h"
44 #define LDB_MODULE_PREFIX "modules:"
45 #define LDB_MODULE_PREFIX_LEN 8
47 static char *ldb_modules_strdup_no_spaces(TALLOC_CTX
*mem_ctx
, const char *string
)
52 trimmed
= talloc_strdup(mem_ctx
, string
);
57 len
= strlen(trimmed
);
58 for (i
= 0; trimmed
[i
] != '\0'; i
++) {
63 memmove(&trimmed
[i
], &trimmed
[i
+ 1], len
-i
-1);
72 /* modules are called in inverse order on the stack.
73 Lets place them as an admin would think the right order is.
74 Modules order is important */
75 const char **ldb_modules_list_from_string(struct ldb_context
*ldb
, TALLOC_CTX
*mem_ctx
, const char *string
)
77 char **modules
= NULL
;
82 /* spaces not admitted */
83 modstr
= ldb_modules_strdup_no_spaces(mem_ctx
, string
);
85 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Out of Memory in ldb_modules_strdup_no_spaces()\n");
89 modules
= talloc_realloc(mem_ctx
, modules
, char *, 2);
91 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Out of Memory in ldb_modules_list_from_string()\n");
95 talloc_steal(modules
, modstr
);
98 /* The str*r*chr walks backwards: This is how we get the inverse order mentioned above */
99 while ((p
= strrchr(modstr
, ',')) != NULL
) {
105 modules
= talloc_realloc(mem_ctx
, modules
, char *, i
+ 2);
107 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Out of Memory in ldb_modules_list_from_string()\n");
114 modules
[i
+ 1] = NULL
;
116 m
= (const char **)modules
;
121 static struct ops_list_entry
{
122 const struct ldb_module_ops
*ops
;
123 struct ops_list_entry
*next
;
124 } *registered_modules
= NULL
;
126 static const struct ldb_module_ops
*ldb_find_module_ops(const char *name
)
128 struct ops_list_entry
*e
;
130 for (e
= registered_modules
; e
; e
= e
->next
) {
131 if (strcmp(e
->ops
->name
, name
) == 0)
138 #ifndef STATIC_ldb_MODULES
141 #define LDAP_INIT ldb_ldap_init,
146 #ifdef HAVE_LDB_SQLITE3
147 #define SQLITE3_INIT ldb_sqlite3_init,
152 #define STATIC_ldb_MODULES \
157 ldb_operational_init, \
159 ldb_objectclass_init, \
160 ldb_paged_results_init, \
167 int ldb_global_init(void)
169 static int (*static_init_fns
[])(void) = STATIC_ldb_MODULES
;
171 static int initialized
= 0;
179 for (i
= 0; static_init_fns
[i
]; i
++) {
180 if (static_init_fns
[i
]() == -1)
187 int ldb_register_module(const struct ldb_module_ops
*ops
)
189 struct ops_list_entry
*entry
= talloc(talloc_autofree_context(), struct ops_list_entry
);
191 if (ldb_find_module_ops(ops
->name
) != NULL
)
198 entry
->next
= registered_modules
;
199 registered_modules
= entry
;
204 int ldb_try_load_dso(struct ldb_context
*ldb
, const char *name
)
208 int (*init_fn
) (void);
212 if (getenv("LD_LDB_MODULE_PATH") != NULL
) {
213 modulesdir
= talloc_strdup(ldb
, getenv("LD_LDB_MODULE_PATH"));
216 modulesdir
= talloc_asprintf(ldb
, "%s/ldb", dyn_MODULESDIR
);
218 modulesdir
= talloc_strdup(ldb
, MODULESDIR
);
222 path
= talloc_asprintf(ldb
, "%s/%s.%s", modulesdir
, name
, SHLIBEXT
);
224 talloc_free(modulesdir
);
226 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "trying to load %s from %s\n", name
, path
);
228 handle
= dlopen(path
, RTLD_NOW
);
229 if (handle
== NULL
) {
230 ldb_debug(ldb
, LDB_DEBUG_WARNING
, "unable to load %s from %s: %s\n", name
, path
, dlerror());
234 init_fn
= (int (*)(void))dlsym(handle
, "init_module");
236 if (init_fn
== NULL
) {
237 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "no symbol `init_module' found in %s: %s\n", path
, dlerror());
245 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "no dlopen() - not trying to load %s module\n", name
);
250 int ldb_load_modules_list(struct ldb_context
*ldb
, const char **module_list
, struct ldb_module
*backend
, struct ldb_module
**out
)
252 struct ldb_module
*module
;
257 for (i
= 0; module_list
[i
] != NULL
; i
++) {
258 struct ldb_module
*current
;
259 const struct ldb_module_ops
*ops
;
261 ops
= ldb_find_module_ops(module_list
[i
]);
263 if (ldb_try_load_dso(ldb
, module_list
[i
]) == 0) {
264 ops
= ldb_find_module_ops(module_list
[i
]);
269 ldb_debug(ldb
, LDB_DEBUG_WARNING
, "WARNING: Module [%s] not found\n",
274 current
= talloc_zero(ldb
, struct ldb_module
);
275 if (current
== NULL
) {
276 return LDB_ERR_OPERATIONS_ERROR
;
278 talloc_set_name(current
, "ldb_module: %s", module_list
[i
]);
283 DLIST_ADD(module
, current
);
289 int ldb_init_module_chain(struct ldb_context
*ldb
, struct ldb_module
*module
)
291 while (module
&& module
->ops
->init_context
== NULL
)
292 module
= module
->next
;
294 if (module
&& module
->ops
->init_context
&&
295 module
->ops
->init_context(module
) != LDB_SUCCESS
) {
296 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "module initialization failed\n");
297 return LDB_ERR_OPERATIONS_ERROR
;
303 int ldb_load_modules(struct ldb_context
*ldb
, const char *options
[])
305 const char **modules
= NULL
;
308 TALLOC_CTX
*mem_ctx
= talloc_new(ldb
);
310 return LDB_ERR_OPERATIONS_ERROR
;
313 /* find out which modules we are requested to activate */
315 /* check if we have a custom module list passd as ldb option */
317 for (i
= 0; options
[i
] != NULL
; i
++) {
318 if (strncmp(options
[i
], LDB_MODULE_PREFIX
, LDB_MODULE_PREFIX_LEN
) == 0) {
319 modules
= ldb_modules_list_from_string(ldb
, mem_ctx
, &options
[i
][LDB_MODULE_PREFIX_LEN
]);
324 /* if not overloaded by options and the backend is not ldap try to load the modules list from ldb */
325 if ((modules
== NULL
) && (strcmp("ldap", ldb
->modules
->ops
->name
) != 0)) {
326 const char * const attrs
[] = { "@LIST" , NULL
};
327 struct ldb_result
*res
= NULL
;
328 struct ldb_dn
*mods_dn
;
330 mods_dn
= ldb_dn_explode(mem_ctx
, "@MODULES");
331 if (mods_dn
== NULL
) {
332 talloc_free(mem_ctx
);
336 ret
= ldb_search(ldb
, mods_dn
, LDB_SCOPE_BASE
, "", attrs
, &res
);
337 talloc_steal(mods_dn
, res
);
338 if (ret
== LDB_SUCCESS
&& (res
->count
== 0 || res
->msgs
[0]->num_elements
== 0)) {
339 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "no modules required by the db\n");
341 if (ret
!= LDB_SUCCESS
) {
342 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "ldb error (%s) occurred searching for modules, bailing out\n", ldb_errstring(ldb
));
343 talloc_free(mem_ctx
);
346 if (res
->count
> 1) {
347 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Too many records found (%d), bailing out\n", res
->count
);
348 talloc_free(mem_ctx
);
352 modules
= ldb_modules_list_from_string(ldb
, mem_ctx
,
353 (const char *)res
->msgs
[0]->elements
[0].values
[0].data
);
357 talloc_free(mods_dn
);
360 if (modules
!= NULL
) {
361 ret
= ldb_load_modules_list(ldb
, modules
, ldb
->modules
, &ldb
->modules
);
362 talloc_free(modules
);
363 if (ret
!= LDB_SUCCESS
) {
367 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "No modules specified for this database\n");
370 return ldb_init_module_chain(ldb
, ldb
->modules
);
374 by using this we allow ldb modules to only implement the functions they care about,
375 which makes writing a module simpler, and makes it more likely to keep working
378 #define FIND_OP(module, op) do { \
379 struct ldb_context *ldb = module->ldb; \
380 module = module->next; \
381 while (module && module->ops->op == NULL) module = module->next; \
382 if (module == NULL) { \
383 ldb_asprintf_errstring(ldb, "Unable to find backend operation for " #op ); \
384 return LDB_ERR_OPERATIONS_ERROR; \
390 helper functions to call the next module in chain
393 int ldb_next_request(struct ldb_module
*module
, struct ldb_request
*request
)
395 switch (request
->operation
) {
397 FIND_OP(module
, search
);
398 return module
->ops
->search(module
, request
);
400 FIND_OP(module
, add
);
401 return module
->ops
->add(module
, request
);
403 FIND_OP(module
, modify
);
404 return module
->ops
->modify(module
, request
);
406 FIND_OP(module
, del
);
407 return module
->ops
->del(module
, request
);
409 FIND_OP(module
, rename
);
410 return module
->ops
->rename(module
, request
);
411 case LDB_SEQUENCE_NUMBER
:
412 FIND_OP(module
, sequence_number
);
413 return module
->ops
->sequence_number(module
, request
);
415 FIND_OP(module
, request
);
416 return module
->ops
->request(module
, request
);
420 int ldb_next_init(struct ldb_module
*module
)
422 /* init is different in that it is not an error if modules
423 * do not require initialization */
425 module
= module
->next
;
427 while (module
&& module
->ops
->init_context
== NULL
)
428 module
= module
->next
;
433 return module
->ops
->init_context(module
);
436 int ldb_next_start_trans(struct ldb_module
*module
)
438 FIND_OP(module
, start_transaction
);
439 return module
->ops
->start_transaction(module
);
442 int ldb_next_end_trans(struct ldb_module
*module
)
444 FIND_OP(module
, end_transaction
);
445 return module
->ops
->end_transaction(module
);
448 int ldb_next_del_trans(struct ldb_module
*module
)
450 FIND_OP(module
, del_transaction
);
451 return module
->ops
->del_transaction(module
);