4 Copyright (C) Simo Sorce 2004-2008
6 ** NOTE! The following LGPL license applies to the ldb
7 ** library. This does NOT imply that all of Samba is released
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 3 of the License, or (at your option) any later version.
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.
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 * Component: ldb modules core
29 * Description: core modules routines
34 #include "ldb_private.h"
35 #include "dlinklist.h"
36 #include "system/dir.h"
38 static char *ldb_modules_strdup_no_spaces(TALLOC_CTX
*mem_ctx
, const char *string
)
43 trimmed
= talloc_strdup(mem_ctx
, string
);
48 len
= strlen(trimmed
);
49 for (i
= 0; trimmed
[i
] != '\0'; i
++) {
54 memmove(&trimmed
[i
], &trimmed
[i
+ 1], len
-i
-1);
63 /* modules are called in inverse order on the stack.
64 Lets place them as an admin would think the right order is.
65 Modules order is important */
66 const char **ldb_modules_list_from_string(struct ldb_context
*ldb
, TALLOC_CTX
*mem_ctx
, const char *string
)
68 char **modules
= NULL
;
73 /* spaces not admitted */
74 modstr
= ldb_modules_strdup_no_spaces(mem_ctx
, string
);
76 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Out of Memory in ldb_modules_strdup_no_spaces()");
80 modules
= talloc_realloc(mem_ctx
, modules
, char *, 2);
82 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Out of Memory in ldb_modules_list_from_string()");
86 talloc_steal(modules
, modstr
);
88 if (modstr
[0] == '\0') {
90 m
= (const char **)modules
;
95 /* The str*r*chr walks backwards: This is how we get the inverse order mentioned above */
96 while ((p
= strrchr(modstr
, ',')) != NULL
) {
102 modules
= talloc_realloc(mem_ctx
, modules
, char *, i
+ 2);
104 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Out of Memory in ldb_modules_list_from_string()");
111 modules
[i
+ 1] = NULL
;
113 m
= (const char **)modules
;
118 static struct backends_list_entry
{
119 struct ldb_backend_ops
*ops
;
120 struct backends_list_entry
*prev
, *next
;
121 } *ldb_backends
= NULL
;
123 static struct ops_list_entry
{
124 const struct ldb_module_ops
*ops
;
125 struct ops_list_entry
*next
;
126 } *registered_modules
= NULL
;
128 static struct backends_list_entry
*ldb_find_backend(const char *url_prefix
)
130 struct backends_list_entry
*backend
;
132 for (backend
= ldb_backends
; backend
; backend
= backend
->next
) {
133 if (strcmp(backend
->ops
->name
, url_prefix
) == 0) {
142 register a new ldb backend
144 if override is true, then override any existing backend for this prefix
146 int ldb_register_backend(const char *url_prefix
, ldb_connect_fn connectfn
, bool override
)
148 struct backends_list_entry
*be
;
150 be
= ldb_find_backend(url_prefix
);
156 be
= talloc_zero(ldb_backends
, struct backends_list_entry
);
158 return LDB_ERR_OPERATIONS_ERROR
;
160 be
->ops
= talloc_zero(be
, struct ldb_backend_ops
);
163 return LDB_ERR_OPERATIONS_ERROR
;
165 DLIST_ADD_END(ldb_backends
, be
, struct backends_list_entry
);
168 be
->ops
->name
= url_prefix
;
169 be
->ops
->connect_fn
= connectfn
;
175 Return the ldb module form of a database.
176 The URL can either be one of the following forms
180 flags is made up of LDB_FLG_*
182 the options are passed uninterpreted to the backend, and are
185 This allows modules to get at only the backend module, for example where a
186 module may wish to direct certain requests at a particular backend.
188 int ldb_module_connect_backend(struct ldb_context
*ldb
,
190 const char *options
[],
191 struct ldb_module
**backend_module
)
195 struct backends_list_entry
*be
;
197 if (strchr(url
, ':') != NULL
) {
198 backend
= talloc_strndup(ldb
, url
, strchr(url
, ':')-url
);
201 backend
= talloc_strdup(ldb
, "tdb");
203 if (backend
== NULL
) {
207 be
= ldb_find_backend(backend
);
209 talloc_free(backend
);
212 ldb_debug(ldb
, LDB_DEBUG_FATAL
,
213 "Unable to find backend for '%s' - do you need to set LDB_MODULES_PATH?", url
);
214 return LDB_ERR_OTHER
;
217 ret
= be
->ops
->connect_fn(ldb
, url
, ldb
->flags
, options
, backend_module
);
219 if (ret
!= LDB_SUCCESS
) {
220 ldb_debug(ldb
, LDB_DEBUG_ERROR
,
221 "Failed to connect to '%s' with backend '%s': %s", url
, be
->ops
->name
, ldb_errstring(ldb
));
227 static struct ldb_hooks
{
228 struct ldb_hooks
*next
, *prev
;
233 register a ldb hook function
235 int ldb_register_hook(ldb_hook_fn hook_fn
)
237 struct ldb_hooks
*lc
;
238 lc
= talloc_zero(ldb_hooks
, struct ldb_hooks
);
240 return LDB_ERR_OPERATIONS_ERROR
;
242 lc
->hook_fn
= hook_fn
;
243 DLIST_ADD_END(ldb_hooks
, lc
, struct ldb_hooks
);
248 call ldb hooks of a given type
250 int ldb_modules_hook(struct ldb_context
*ldb
, enum ldb_module_hook_type t
)
252 struct ldb_hooks
*lc
;
253 for (lc
= ldb_hooks
; lc
; lc
=lc
->next
) {
254 int ret
= lc
->hook_fn(ldb
, t
);
255 if (ret
!= LDB_SUCCESS
) {
263 static const struct ldb_module_ops
*ldb_find_module_ops(const char *name
)
265 struct ops_list_entry
*e
;
267 for (e
= registered_modules
; e
; e
= e
->next
) {
268 if (strcmp(e
->ops
->name
, name
) == 0)
276 int ldb_register_module(const struct ldb_module_ops
*ops
)
278 struct ops_list_entry
*entry
;
280 if (ldb_find_module_ops(ops
->name
) != NULL
)
281 return LDB_ERR_ENTRY_ALREADY_EXISTS
;
283 entry
= talloc(talloc_autofree_context(), struct ops_list_entry
);
285 return LDB_ERR_OPERATIONS_ERROR
;
289 entry
->next
= registered_modules
;
290 registered_modules
= entry
;
296 load a list of modules
298 int ldb_module_load_list(struct ldb_context
*ldb
, const char **module_list
,
299 struct ldb_module
*backend
, struct ldb_module
**out
)
301 struct ldb_module
*module
;
306 for (i
= 0; module_list
&& module_list
[i
] != NULL
; i
++) {
307 struct ldb_module
*current
;
308 const struct ldb_module_ops
*ops
;
310 if (strcmp(module_list
[i
], "") == 0) {
314 ops
= ldb_find_module_ops(module_list
[i
]);
317 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "WARNING: Module [%s] not found - do you need to set LDB_MODULES_PATH?",
319 return LDB_ERR_OPERATIONS_ERROR
;
322 current
= talloc_zero(ldb
, struct ldb_module
);
323 if (current
== NULL
) {
324 return LDB_ERR_OPERATIONS_ERROR
;
326 talloc_set_name(current
, "ldb_module: %s", module_list
[i
]);
331 DLIST_ADD(module
, current
);
338 initialise a chain of modules
340 int ldb_module_init_chain(struct ldb_context
*ldb
, struct ldb_module
*module
)
342 while (module
&& module
->ops
->init_context
== NULL
)
343 module
= module
->next
;
345 /* init is different in that it is not an error if modules
346 * do not require initialization */
349 int ret
= module
->ops
->init_context(module
);
350 if (ret
!= LDB_SUCCESS
) {
351 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "module %s initialization failed : %s",
352 module
->ops
->name
, ldb_strerror(ret
));
360 int ldb_load_modules(struct ldb_context
*ldb
, const char *options
[])
362 const char *modules_string
;
363 const char **modules
= NULL
;
365 TALLOC_CTX
*mem_ctx
= talloc_new(ldb
);
370 /* find out which modules we are requested to activate */
372 /* check if we have a custom module list passd as ldb option */
374 modules_string
= ldb_options_find(ldb
, options
, "modules");
375 if (modules_string
) {
376 modules
= ldb_modules_list_from_string(ldb
, mem_ctx
, modules_string
);
380 /* if not overloaded by options and the backend is not ldap try to load the modules list from ldb */
381 if ((modules
== NULL
) && (strcmp("ldap", ldb
->modules
->ops
->name
) != 0)) {
382 const char * const attrs
[] = { "@LIST" , NULL
};
383 struct ldb_result
*res
= NULL
;
384 struct ldb_dn
*mods_dn
;
386 mods_dn
= ldb_dn_new(mem_ctx
, ldb
, "@MODULES");
387 if (mods_dn
== NULL
) {
388 talloc_free(mem_ctx
);
392 ret
= ldb_search(ldb
, mods_dn
, &res
, mods_dn
, LDB_SCOPE_BASE
, attrs
, "@LIST=*");
394 if (ret
== LDB_ERR_NO_SUCH_OBJECT
) {
395 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "no modules required by the db");
396 } else if (ret
!= LDB_SUCCESS
) {
397 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "ldb error (%s) occurred searching for modules, bailing out", ldb_errstring(ldb
));
398 talloc_free(mem_ctx
);
401 const char *module_list
;
402 if (res
->count
== 0) {
403 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "no modules required by the db");
404 } else if (res
->count
> 1) {
405 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Too many records found (%u), bailing out", res
->count
);
406 talloc_free(mem_ctx
);
407 return LDB_ERR_OPERATIONS_ERROR
;
409 module_list
= ldb_msg_find_attr_as_string(res
->msgs
[0], "@LIST", NULL
);
411 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "no modules required by the db");
413 modules
= ldb_modules_list_from_string(ldb
, mem_ctx
,
418 talloc_free(mods_dn
);
421 if (modules
!= NULL
) {
422 ret
= ldb_module_load_list(ldb
, modules
, ldb
->modules
, &ldb
->modules
);
423 if (ret
!= LDB_SUCCESS
) {
424 talloc_free(mem_ctx
);
428 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "No modules specified for this database");
431 ret
= ldb_module_init_chain(ldb
, ldb
->modules
);
432 talloc_free(mem_ctx
);
437 by using this we allow ldb modules to only implement the functions they care about,
438 which makes writing a module simpler, and makes it more likely to keep working
441 #define FIND_OP_NOERR(module, op) do { \
442 module = module->next; \
443 while (module && module->ops->op == NULL) module = module->next; \
444 if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) { \
445 ldb_debug(module->ldb, LDB_DEBUG_TRACE, "ldb_trace_next_request: (%s)->" #op, \
446 module->ops->name); \
450 #define FIND_OP(module, op) do { \
451 struct ldb_context *ldb = module->ldb; \
452 FIND_OP_NOERR(module, op); \
453 if (module == NULL) { \
454 ldb_asprintf_errstring(ldb, "Unable to find backend operation for " #op ); \
455 return LDB_ERR_OPERATIONS_ERROR; \
460 struct ldb_module
*ldb_module_new(TALLOC_CTX
*memctx
,
461 struct ldb_context
*ldb
,
462 const char *module_name
,
463 const struct ldb_module_ops
*ops
)
465 struct ldb_module
*module
;
467 module
= talloc(memctx
, struct ldb_module
);
472 talloc_set_name_const(module
, module_name
);
474 module
->prev
= module
->next
= NULL
;
480 const char * ldb_module_get_name(struct ldb_module
*module
)
482 return module
->ops
->name
;
485 struct ldb_context
*ldb_module_get_ctx(struct ldb_module
*module
)
490 const struct ldb_module_ops
*ldb_module_get_ops(struct ldb_module
*module
)
495 void *ldb_module_get_private(struct ldb_module
*module
)
497 return module
->private_data
;
500 void ldb_module_set_private(struct ldb_module
*module
, void *private_data
)
502 module
->private_data
= private_data
;
506 helper functions to call the next module in chain
509 int ldb_next_request(struct ldb_module
*module
, struct ldb_request
*request
)
513 if (request
->callback
== NULL
) {
514 ldb_set_errstring(module
->ldb
, "Requests MUST define callbacks");
515 return LDB_ERR_UNWILLING_TO_PERFORM
;
518 request
->handle
->nesting
++;
520 switch (request
->operation
) {
522 FIND_OP(module
, search
);
523 ret
= module
->ops
->search(module
, request
);
526 FIND_OP(module
, add
);
527 ret
= module
->ops
->add(module
, request
);
530 FIND_OP(module
, modify
);
531 ret
= module
->ops
->modify(module
, request
);
534 FIND_OP(module
, del
);
535 ret
= module
->ops
->del(module
, request
);
538 FIND_OP(module
, rename
);
539 ret
= module
->ops
->rename(module
, request
);
542 FIND_OP(module
, extended
);
543 ret
= module
->ops
->extended(module
, request
);
546 FIND_OP(module
, request
);
547 ret
= module
->ops
->request(module
, request
);
551 request
->handle
->nesting
--;
553 if (ret
== LDB_SUCCESS
) {
556 if (!ldb_errstring(module
->ldb
)) {
557 /* Set a default error string, to place the blame somewhere */
558 ldb_asprintf_errstring(module
->ldb
, "error in module %s: %s (%d)", module
->ops
->name
, ldb_strerror(ret
), ret
);
561 if (!(request
->handle
->flags
& LDB_HANDLE_FLAG_DONE_CALLED
)) {
562 /* It is _extremely_ common that a module returns a
563 * failure without calling ldb_module_done(), but that
564 * guarantees we will end up hanging in
565 * ldb_wait(). This fixes it without having to rewrite
566 * all our modules, and leaves us one less sharp
567 * corner for module developers to cut themselves on
569 ret
= ldb_module_done(request
, NULL
, NULL
, ret
);
574 int ldb_next_init(struct ldb_module
*module
)
576 module
= module
->next
;
578 return ldb_module_init_chain(module
->ldb
, module
);
581 int ldb_next_start_trans(struct ldb_module
*module
)
584 FIND_OP(module
, start_transaction
);
585 ret
= module
->ops
->start_transaction(module
);
586 if (ret
== LDB_SUCCESS
) {
589 if (!ldb_errstring(module
->ldb
)) {
590 /* Set a default error string, to place the blame somewhere */
591 ldb_asprintf_errstring(module
->ldb
, "start_trans error in module %s: %s (%d)", module
->ops
->name
, ldb_strerror(ret
), ret
);
593 if ((module
&& module
->ldb
->flags
& LDB_FLG_ENABLE_TRACING
)) {
594 ldb_debug(module
->ldb
, LDB_DEBUG_TRACE
, "ldb_next_start_trans error: %s",
595 ldb_errstring(module
->ldb
));
600 int ldb_next_end_trans(struct ldb_module
*module
)
603 FIND_OP(module
, end_transaction
);
604 ret
= module
->ops
->end_transaction(module
);
605 if (ret
== LDB_SUCCESS
) {
608 if (!ldb_errstring(module
->ldb
)) {
609 /* Set a default error string, to place the blame somewhere */
610 ldb_asprintf_errstring(module
->ldb
, "end_trans error in module %s: %s (%d)", module
->ops
->name
, ldb_strerror(ret
), ret
);
612 if ((module
&& module
->ldb
->flags
& LDB_FLG_ENABLE_TRACING
)) {
613 ldb_debug(module
->ldb
, LDB_DEBUG_TRACE
, "ldb_next_end_trans error: %s",
614 ldb_errstring(module
->ldb
));
619 int ldb_next_prepare_commit(struct ldb_module
*module
)
622 FIND_OP_NOERR(module
, prepare_commit
);
623 if (module
== NULL
) {
624 /* we are allowed to have no prepare commit in
628 ret
= module
->ops
->prepare_commit(module
);
629 if (ret
== LDB_SUCCESS
) {
632 if (!ldb_errstring(module
->ldb
)) {
633 /* Set a default error string, to place the blame somewhere */
634 ldb_asprintf_errstring(module
->ldb
, "prepare_commit error in module %s: %s (%d)", module
->ops
->name
, ldb_strerror(ret
), ret
);
636 if ((module
&& module
->ldb
->flags
& LDB_FLG_ENABLE_TRACING
)) {
637 ldb_debug(module
->ldb
, LDB_DEBUG_TRACE
, "ldb_next_prepare_commit error: %s",
638 ldb_errstring(module
->ldb
));
643 int ldb_next_del_trans(struct ldb_module
*module
)
646 FIND_OP(module
, del_transaction
);
647 ret
= module
->ops
->del_transaction(module
);
648 if (ret
== LDB_SUCCESS
) {
651 if (!ldb_errstring(module
->ldb
)) {
652 /* Set a default error string, to place the blame somewhere */
653 ldb_asprintf_errstring(module
->ldb
, "del_trans error in module %s: %s (%d)", module
->ops
->name
, ldb_strerror(ret
), ret
);
655 if ((module
&& module
->ldb
->flags
& LDB_FLG_ENABLE_TRACING
)) {
656 ldb_debug(module
->ldb
, LDB_DEBUG_TRACE
, "ldb_next_del_trans error: %s",
657 ldb_errstring(module
->ldb
));
662 struct ldb_handle
*ldb_handle_new(TALLOC_CTX
*mem_ctx
, struct ldb_context
*ldb
)
664 struct ldb_handle
*h
;
666 h
= talloc_zero(mem_ctx
, struct ldb_handle
);
668 ldb_set_errstring(ldb
, "Out of Memory");
672 h
->status
= LDB_SUCCESS
;
673 h
->state
= LDB_ASYNC_INIT
;
682 /* calls the request callback to send an entry
685 * req: the original request passed to your module
686 * msg: reply message (must be a talloc pointer, and it will be stolen
687 * on the ldb_reply that is sent to the callback)
688 * ctrls: controls to send in the reply (must be a talloc pointer, and it will be stolen
689 * on the ldb_reply that is sent to the callback)
692 int ldb_module_send_entry(struct ldb_request
*req
,
693 struct ldb_message
*msg
,
694 struct ldb_control
**ctrls
)
696 struct ldb_reply
*ares
;
698 ares
= talloc_zero(req
, struct ldb_reply
);
700 ldb_oom(req
->handle
->ldb
);
701 req
->callback(req
, NULL
);
702 return LDB_ERR_OPERATIONS_ERROR
;
704 ares
->type
= LDB_REPLY_ENTRY
;
705 ares
->message
= talloc_steal(ares
, msg
);
706 ares
->controls
= talloc_steal(ares
, ctrls
);
707 ares
->error
= LDB_SUCCESS
;
709 if ((req
->handle
->ldb
->flags
& LDB_FLG_ENABLE_TRACING
) &&
710 req
->handle
->nesting
== 0) {
712 ldb_debug_add(req
->handle
->ldb
, "ldb_trace_response: ENTRY\n");
713 s
= ldb_ldif_message_string(req
->handle
->ldb
, msg
, LDB_CHANGETYPE_NONE
, msg
);
714 ldb_debug_add(req
->handle
->ldb
, "%s\n", s
);
716 ldb_debug_end(req
->handle
->ldb
, LDB_DEBUG_TRACE
);
719 return req
->callback(req
, ares
);
722 /* calls the request callback to send an referrals
725 * req: the original request passed to your module
726 * ref: referral string (must be a talloc pointer, steal)
729 int ldb_module_send_referral(struct ldb_request
*req
,
732 struct ldb_reply
*ares
;
734 ares
= talloc_zero(req
, struct ldb_reply
);
736 ldb_oom(req
->handle
->ldb
);
737 req
->callback(req
, NULL
);
738 return LDB_ERR_OPERATIONS_ERROR
;
740 ares
->type
= LDB_REPLY_REFERRAL
;
741 ares
->referral
= talloc_steal(ares
, ref
);
742 ares
->error
= LDB_SUCCESS
;
744 if ((req
->handle
->ldb
->flags
& LDB_FLG_ENABLE_TRACING
) &&
745 req
->handle
->nesting
== 0) {
746 ldb_debug_add(req
->handle
->ldb
, "ldb_trace_response: REFERRAL\n");
747 ldb_debug_add(req
->handle
->ldb
, "ref: %s\n", ref
);
748 ldb_debug_end(req
->handle
->ldb
, LDB_DEBUG_TRACE
);
751 return req
->callback(req
, ares
);
754 /* calls the original request callback
757 * req: the original request passed to your module
758 * ctrls: controls to send in the reply (must be a talloc pointer, steal)
759 * response: results for extended request (steal)
760 * error: LDB_SUCCESS for a successful return
761 * any other ldb error otherwise
763 int ldb_module_done(struct ldb_request
*req
,
764 struct ldb_control
**ctrls
,
765 struct ldb_extended
*response
,
768 struct ldb_reply
*ares
;
770 ares
= talloc_zero(req
, struct ldb_reply
);
772 ldb_oom(req
->handle
->ldb
);
773 req
->callback(req
, NULL
);
774 return LDB_ERR_OPERATIONS_ERROR
;
776 ares
->type
= LDB_REPLY_DONE
;
777 ares
->controls
= talloc_steal(ares
, ctrls
);
778 ares
->response
= talloc_steal(ares
, response
);
781 req
->handle
->flags
|= LDB_HANDLE_FLAG_DONE_CALLED
;
783 if ((req
->handle
->ldb
->flags
& LDB_FLG_ENABLE_TRACING
) &&
784 req
->handle
->nesting
== 0) {
785 ldb_debug_add(req
->handle
->ldb
, "ldb_trace_response: DONE\n");
786 ldb_debug_add(req
->handle
->ldb
, "error: %d\n", error
);
787 if (ldb_errstring(req
->handle
->ldb
)) {
788 ldb_debug_add(req
->handle
->ldb
, "msg: %s\n",
789 ldb_errstring(req
->handle
->ldb
));
791 ldb_debug_end(req
->handle
->ldb
, LDB_DEBUG_TRACE
);
794 return req
->callback(req
, ares
);
797 /* to be used *only* in modules init functions.
798 * this function is synchronous and will register
799 * the requested OID in the rootdse module if present
800 * otherwise it will return an error */
801 int ldb_mod_register_control(struct ldb_module
*module
, const char *oid
)
803 struct ldb_request
*req
;
806 req
= talloc_zero(module
, struct ldb_request
);
808 return LDB_ERR_OPERATIONS_ERROR
;
811 req
->operation
= LDB_REQ_REGISTER_CONTROL
;
812 req
->op
.reg_control
.oid
= oid
;
813 req
->callback
= ldb_op_default_callback
;
815 ldb_set_timeout(module
->ldb
, req
, 0);
817 req
->handle
= ldb_handle_new(req
, module
->ldb
);
818 if (req
->handle
== NULL
) {
819 return LDB_ERR_OPERATIONS_ERROR
;
822 ret
= ldb_request(module
->ldb
, req
);
823 if (ret
== LDB_SUCCESS
) {
824 ret
= ldb_wait(req
->handle
, LDB_WAIT_ALL
);
831 static int ldb_modules_load_dir(const char *modules_dir
, const char *version
);
835 load one module. A static list of loaded module inode numbers is
836 used to prevent a module being loaded twice
838 dlopen() is used on the module, and dlsym() is then used to look for
839 a ldb_init_module() function. If present, that function is called
840 with the ldb version number as an argument.
842 The ldb_init_module() function will typically call
843 ldb_register_module() and ldb_register_backend() to register a
844 module or backend, but it may also be used to register command line
845 handling functions, ldif handlers or any other local
848 The ldb_init_module() function does not get a ldb_context passed in,
849 as modules will be used for multiple ldb context handles. The call
850 from the first ldb_init() is just a convenient way to ensure it is
853 static int ldb_modules_load_path(const char *path
, const char *version
)
856 int (*init_fn
)(const char *);
859 static struct loaded
{
860 struct loaded
*next
, *prev
;
867 ret
= stat(path
, &st
);
869 fprintf(stderr
, "ldb: unable to stat module %s : %s\n", path
, strerror(errno
));
870 return LDB_ERR_UNAVAILABLE
;
873 for (le
=loaded
; le
; le
=le
->next
) {
874 if (le
->st_ino
== st
.st_ino
&&
875 le
->st_dev
== st
.st_dev
) {
876 /* its already loaded */
881 le
= talloc(loaded
, struct loaded
);
883 fprintf(stderr
, "ldb: unable to allocated loaded entry\n");
884 return LDB_ERR_UNAVAILABLE
;
887 le
->st_ino
= st
.st_ino
;
888 le
->st_dev
= st
.st_dev
;
890 DLIST_ADD_END(loaded
, le
, struct loaded
);
892 /* if it is a directory, recurse */
893 if (S_ISDIR(st
.st_mode
)) {
894 return ldb_modules_load_dir(path
, version
);
897 dlopen_flags
= RTLD_NOW
;
899 /* use deepbind if possible, to avoid issues with different
900 system library varients, for example ldb modules may be linked
901 against Heimdal while the application may use MIT kerberos
903 See the dlopen manpage for details
905 dlopen_flags
|= RTLD_DEEPBIND
;
908 handle
= dlopen(path
, dlopen_flags
);
909 if (handle
== NULL
) {
910 fprintf(stderr
, "ldb: unable to dlopen %s : %s\n", path
, dlerror());
914 init_fn
= dlsym(handle
, "ldb_init_module");
915 if (init_fn
== NULL
) {
916 /* ignore it, it could be an old-style
917 * module. Once we've converted all modules we
918 * could consider this an error */
923 ret
= init_fn(version
);
924 if (ret
== LDB_ERR_ENTRY_ALREADY_EXISTS
) {
925 /* the module is already registered - ignore this, as
926 * it can happen if LDB_MODULES_PATH points at both
927 * the build and install directory
934 static int qsort_string(const char **s1
, const char **s2
)
936 return strcmp(*s1
, *s2
);
941 load all modules from the given ldb modules directory. This is run once
942 during the first ldb_init() call.
944 Modules are loaded in alphabetical order to ensure that any module
945 load ordering dependencies are reproducible. Modules should avoid
946 relying on load order
948 static int ldb_modules_load_dir(const char *modules_dir
, const char *version
)
952 const char **modlist
= NULL
;
953 TALLOC_CTX
*tmp_ctx
= talloc_new(NULL
);
954 unsigned i
, num_modules
= 0;
956 dir
= opendir(modules_dir
);
958 if (errno
== ENOENT
) {
959 talloc_free(tmp_ctx
);
960 /* we don't have any modules */
963 talloc_free(tmp_ctx
);
964 fprintf(stderr
, "ldb: unable to open modules directory '%s' - %s\n",
965 modules_dir
, strerror(errno
));
966 return LDB_ERR_UNAVAILABLE
;
970 while ((de
= readdir(dir
))) {
971 if (ISDOT(de
->d_name
) || ISDOTDOT(de
->d_name
))
974 modlist
= talloc_realloc(tmp_ctx
, modlist
, const char *, num_modules
+1);
975 if (modlist
== NULL
) {
976 talloc_free(tmp_ctx
);
978 fprintf(stderr
, "ldb: unable to allocate modules list\n");
979 return LDB_ERR_UNAVAILABLE
;
981 modlist
[num_modules
] = talloc_asprintf(modlist
, "%s/%s", modules_dir
, de
->d_name
);
982 if (modlist
[num_modules
] == NULL
) {
983 talloc_free(tmp_ctx
);
985 fprintf(stderr
, "ldb: unable to allocate module list entry\n");
986 return LDB_ERR_UNAVAILABLE
;
993 /* sort the directory, so we get consistent load ordering */
994 TYPESAFE_QSORT(modlist
, num_modules
, qsort_string
);
996 for (i
=0; i
<num_modules
; i
++) {
997 int ret
= ldb_modules_load_path(modlist
[i
], version
);
998 if (ret
!= LDB_SUCCESS
) {
999 fprintf(stderr
, "ldb: failed to initialise module %s : %s\n",
1000 modlist
[i
], ldb_strerror(ret
));
1001 talloc_free(tmp_ctx
);
1006 talloc_free(tmp_ctx
);
1012 load any additional modules from the given directory
1014 void ldb_set_modules_dir(struct ldb_context
*ldb
, const char *path
)
1016 int ret
= ldb_modules_load_path(path
, LDB_VERSION
);
1017 if (ret
!= LDB_SUCCESS
) {
1018 ldb_asprintf_errstring(ldb
, "Failed to load modules from: %s\n", path
);
1024 load all modules static (builtin) modules
1026 static int ldb_modules_load_static(const char *version
)
1028 static bool initialised
;
1029 #define _MODULE_PROTO(init) extern int init(const char *);
1030 STATIC_ldb_MODULES_PROTO
;
1031 const ldb_module_init_fn static_init_functions
[] = { STATIC_ldb_MODULES
};
1039 for (i
=0; static_init_functions
[i
]; i
++) {
1040 int ret
= static_init_functions
[i
](version
);
1041 if (ret
!= LDB_SUCCESS
) {
1049 load all modules from the given ldb modules path, colon
1052 modules are loaded recursively for all subdirectories in the paths
1054 int ldb_modules_load(const char *modules_path
, const char *version
)
1056 char *tok
, *path
, *tok_ptr
=NULL
;
1059 ret
= ldb_modules_load_static(version
);
1060 if (ret
!= LDB_SUCCESS
) {
1064 path
= talloc_strdup(NULL
, modules_path
);
1066 fprintf(stderr
, "ldb: failed to allocate modules_path\n");
1067 return LDB_ERR_UNAVAILABLE
;
1070 for (tok
=strtok_r(path
, ":", &tok_ptr
);
1072 tok
=strtok_r(NULL
, ":", &tok_ptr
)) {
1073 ret
= ldb_modules_load_path(tok
, version
);
1074 if (ret
!= LDB_SUCCESS
) {
1086 return a string representation of the calling chain for the given
1089 char *ldb_module_call_chain(struct ldb_request
*req
, TALLOC_CTX
*mem_ctx
)
1094 ret
= talloc_strdup(mem_ctx
, "");
1099 while (req
&& req
->handle
) {
1100 char *s
= talloc_asprintf_append_buffer(ret
, "req[%u] %p : %s\n",
1101 i
++, req
, ldb_req_location(req
));
1107 req
= req
->handle
->parent
;
1114 return the next module in the chain
1116 struct ldb_module
*ldb_module_next(struct ldb_module
*module
)
1118 return module
->next
;
1122 set the next module in the module chain
1124 void ldb_module_set_next(struct ldb_module
*module
, struct ldb_module
*next
)
1126 module
->next
= next
;
1131 get the popt_options pointer in the ldb structure. This allows a ldb
1132 module to change the command line parsing
1134 struct poptOption
**ldb_module_popt_options(struct ldb_context
*ldb
)
1136 return &ldb
->popt_options
;
1141 return the current ldb flags LDB_FLG_*
1143 uint32_t ldb_module_flags(struct ldb_context
*ldb
)