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_includes.h"
36 #if (_SAMBA_BUILD_ >= 4)
40 #define LDB_MODULE_PREFIX "modules:"
41 #define LDB_MODULE_PREFIX_LEN 8
43 void ldb_set_modules_dir(struct ldb_context
*ldb
, const char *path
)
45 talloc_free(ldb
->modules_dir
);
46 ldb
->modules_dir
= talloc_strdup(ldb
, path
);
49 static char *ldb_modules_strdup_no_spaces(TALLOC_CTX
*mem_ctx
, const char *string
)
54 trimmed
= talloc_strdup(mem_ctx
, string
);
59 len
= strlen(trimmed
);
60 for (i
= 0; trimmed
[i
] != '\0'; i
++) {
65 memmove(&trimmed
[i
], &trimmed
[i
+ 1], len
-i
-1);
74 /* modules are called in inverse order on the stack.
75 Lets place them as an admin would think the right order is.
76 Modules order is important */
77 const char **ldb_modules_list_from_string(struct ldb_context
*ldb
, TALLOC_CTX
*mem_ctx
, const char *string
)
79 char **modules
= NULL
;
84 /* spaces not admitted */
85 modstr
= ldb_modules_strdup_no_spaces(mem_ctx
, string
);
87 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Out of Memory in ldb_modules_strdup_no_spaces()\n");
91 modules
= talloc_realloc(mem_ctx
, modules
, char *, 2);
93 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Out of Memory in ldb_modules_list_from_string()\n");
97 talloc_steal(modules
, modstr
);
100 /* The str*r*chr walks backwards: This is how we get the inverse order mentioned above */
101 while ((p
= strrchr(modstr
, ',')) != NULL
) {
107 modules
= talloc_realloc(mem_ctx
, modules
, char *, i
+ 2);
109 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Out of Memory in ldb_modules_list_from_string()\n");
116 modules
[i
+ 1] = NULL
;
118 m
= (const char **)modules
;
123 static struct backends_list_entry
{
124 struct ldb_backend_ops
*ops
;
125 struct backends_list_entry
*prev
, *next
;
126 } *ldb_backends
= NULL
;
128 static struct ops_list_entry
{
129 const struct ldb_module_ops
*ops
;
130 struct ops_list_entry
*next
;
131 } *registered_modules
= NULL
;
133 static const struct ldb_builtins
{
134 const struct ldb_backend_ops
*backend_ops
;
135 const struct ldb_module_ops
*module_ops
;
138 static ldb_connect_fn
ldb_find_backend(const char *url
)
140 struct backends_list_entry
*backend
;
143 for (i
= 0; builtins
[i
].backend_ops
|| builtins
[i
].module_ops
; i
++) {
144 if (builtins
[i
].backend_ops
== NULL
) continue;
146 if (strncmp(builtins
[i
].backend_ops
->name
, url
,
147 strlen(builtins
[i
].backend_ops
->name
)) == 0) {
148 return builtins
[i
].backend_ops
->connect_fn
;
152 for (backend
= ldb_backends
; backend
; backend
= backend
->next
) {
153 if (strncmp(backend
->ops
->name
, url
,
154 strlen(backend
->ops
->name
)) == 0) {
155 return backend
->ops
->connect_fn
;
163 register a new ldb backend
165 int ldb_register_backend(const char *url_prefix
, ldb_connect_fn connectfn
)
167 struct ldb_backend_ops
*backend
;
168 struct backends_list_entry
*entry
;
170 backend
= talloc(talloc_autofree_context(), struct ldb_backend_ops
);
171 if (!backend
) return LDB_ERR_OPERATIONS_ERROR
;
173 entry
= talloc(talloc_autofree_context(), struct backends_list_entry
);
175 talloc_free(backend
);
176 return LDB_ERR_OPERATIONS_ERROR
;
179 if (ldb_find_backend(url_prefix
)) {
183 /* Maybe check for duplicity here later on? */
185 backend
->name
= talloc_strdup(backend
, url_prefix
);
186 backend
->connect_fn
= connectfn
;
187 entry
->ops
= backend
;
188 DLIST_ADD(ldb_backends
, entry
);
194 Return the ldb module form of a database.
195 The URL can either be one of the following forms
199 flags is made up of LDB_FLG_*
201 the options are passed uninterpreted to the backend, and are
204 This allows modules to get at only the backend module, for example where a
205 module may wish to direct certain requests at a particular backend.
207 int ldb_connect_backend(struct ldb_context
*ldb
,
209 const char *options
[],
210 struct ldb_module
**backend_module
)
216 if (strchr(url
, ':') != NULL
) {
217 backend
= talloc_strndup(ldb
, url
, strchr(url
, ':')-url
);
220 backend
= talloc_strdup(ldb
, "tdb");
223 fn
= ldb_find_backend(backend
);
226 struct ldb_backend_ops
*ops
;
227 char *symbol_name
= talloc_asprintf(ldb
, "ldb_%s_backend_ops", backend
);
228 if (symbol_name
== NULL
) {
229 return LDB_ERR_OPERATIONS_ERROR
;
231 ops
= ldb_dso_load_symbol(ldb
, backend
, symbol_name
);
233 fn
= ops
->connect_fn
;
235 talloc_free(symbol_name
);
238 talloc_free(backend
);
241 ldb_debug(ldb
, LDB_DEBUG_FATAL
,
242 "Unable to find backend for '%s'\n", url
);
243 return LDB_ERR_OTHER
;
246 ret
= fn(ldb
, url
, ldb
->flags
, options
, backend_module
);
248 if (ret
!= LDB_SUCCESS
) {
249 ldb_debug(ldb
, LDB_DEBUG_ERROR
,
250 "Failed to connect to '%s'\n", url
);
256 static const struct ldb_module_ops
*ldb_find_module_ops(const char *name
)
258 struct ops_list_entry
*e
;
261 for (i
= 0; builtins
[i
].backend_ops
|| builtins
[i
].module_ops
; i
++) {
262 if (builtins
[i
].module_ops
== NULL
) continue;
264 if (strcmp(builtins
[i
].module_ops
->name
, name
) == 0)
265 return builtins
[i
].module_ops
;
268 for (e
= registered_modules
; e
; e
= e
->next
) {
269 if (strcmp(e
->ops
->name
, name
) == 0)
277 int ldb_register_module(const struct ldb_module_ops
*ops
)
279 struct ops_list_entry
*entry
= talloc(talloc_autofree_context(), struct ops_list_entry
);
281 if (ldb_find_module_ops(ops
->name
) != NULL
)
288 entry
->next
= registered_modules
;
289 registered_modules
= entry
;
294 void *ldb_dso_load_symbol(struct ldb_context
*ldb
, const char *name
,
301 if (ldb
->modules_dir
== NULL
)
304 path
= talloc_asprintf(ldb
, "%s/%s.%s", ldb
->modules_dir
, name
,
307 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "trying to load %s from %s\n", name
, path
);
309 handle
= dlopen(path
, RTLD_NOW
);
310 if (handle
== NULL
) {
311 ldb_debug(ldb
, LDB_DEBUG_WARNING
, "unable to load %s from %s: %s\n", name
, path
, dlerror());
315 sym
= (int (*)(void))dlsym(handle
, symbol
);
318 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "no symbol `%s' found in %s: %s\n", symbol
, path
, dlerror());
327 int ldb_load_modules_list(struct ldb_context
*ldb
, const char **module_list
, struct ldb_module
*backend
, struct ldb_module
**out
)
329 struct ldb_module
*module
;
334 for (i
= 0; module_list
[i
] != NULL
; i
++) {
335 struct ldb_module
*current
;
336 const struct ldb_module_ops
*ops
;
338 ops
= ldb_find_module_ops(module_list
[i
]);
340 char *symbol_name
= talloc_asprintf(ldb
, "ldb_%s_module_ops",
342 if (symbol_name
== NULL
) {
343 return LDB_ERR_OPERATIONS_ERROR
;
345 ops
= ldb_dso_load_symbol(ldb
, module_list
[i
], symbol_name
);
346 talloc_free(symbol_name
);
350 ldb_debug(ldb
, LDB_DEBUG_WARNING
, "WARNING: Module [%s] not found\n",
355 current
= talloc_zero(ldb
, struct ldb_module
);
356 if (current
== NULL
) {
357 return LDB_ERR_OPERATIONS_ERROR
;
359 talloc_set_name(current
, "ldb_module: %s", module_list
[i
]);
364 DLIST_ADD(module
, current
);
370 int ldb_init_module_chain(struct ldb_context
*ldb
, struct ldb_module
*module
)
372 while (module
&& module
->ops
->init_context
== NULL
)
373 module
= module
->next
;
375 /* init is different in that it is not an error if modules
376 * do not require initialization */
379 int ret
= module
->ops
->init_context(module
);
380 if (ret
!= LDB_SUCCESS
) {
381 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "module %s initialization failed\n", module
->ops
->name
);
389 int ldb_load_modules(struct ldb_context
*ldb
, const char *options
[])
391 const char **modules
= NULL
;
394 TALLOC_CTX
*mem_ctx
= talloc_new(ldb
);
396 return LDB_ERR_OPERATIONS_ERROR
;
399 /* find out which modules we are requested to activate */
401 /* check if we have a custom module list passd as ldb option */
403 for (i
= 0; options
[i
] != NULL
; i
++) {
404 if (strncmp(options
[i
], LDB_MODULE_PREFIX
, LDB_MODULE_PREFIX_LEN
) == 0) {
405 modules
= ldb_modules_list_from_string(ldb
, mem_ctx
, &options
[i
][LDB_MODULE_PREFIX_LEN
]);
410 /* if not overloaded by options and the backend is not ldap try to load the modules list from ldb */
411 if ((modules
== NULL
) && (strcmp("ldap", ldb
->modules
->ops
->name
) != 0)) {
412 const char * const attrs
[] = { "@LIST" , NULL
};
413 struct ldb_result
*res
= NULL
;
414 struct ldb_dn
*mods_dn
;
416 mods_dn
= ldb_dn_new(mem_ctx
, ldb
, "@MODULES");
417 if (mods_dn
== NULL
) {
418 talloc_free(mem_ctx
);
422 ret
= ldb_search(ldb
, mods_dn
, &res
, mods_dn
, LDB_SCOPE_BASE
, attrs
, "@LIST=*");
424 if (ret
== LDB_ERR_NO_SUCH_OBJECT
) {
425 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "no modules required by the db");
426 } else if (ret
!= LDB_SUCCESS
) {
427 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "ldb error (%s) occurred searching for modules, bailing out\n", ldb_errstring(ldb
));
428 talloc_free(mem_ctx
);
431 const char *module_list
;
432 if (res
->count
== 0) {
433 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "no modules required by the db");
434 } else if (res
->count
> 1) {
435 ldb_debug(ldb
, LDB_DEBUG_FATAL
, "Too many records found (%d), bailing out\n", res
->count
);
436 talloc_free(mem_ctx
);
439 module_list
= ldb_msg_find_attr_as_string(res
->msgs
[0], "@LIST", NULL
);
441 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "no modules required by the db");
443 modules
= ldb_modules_list_from_string(ldb
, mem_ctx
,
448 talloc_free(mods_dn
);
451 if (modules
!= NULL
) {
452 ret
= ldb_load_modules_list(ldb
, modules
, ldb
->modules
, &ldb
->modules
);
453 if (ret
!= LDB_SUCCESS
) {
454 talloc_free(mem_ctx
);
458 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "No modules specified for this database");
461 ret
= ldb_init_module_chain(ldb
, ldb
->modules
);
462 talloc_free(mem_ctx
);
467 by using this we allow ldb modules to only implement the functions they care about,
468 which makes writing a module simpler, and makes it more likely to keep working
471 #define FIND_OP(module, op) do { \
472 struct ldb_context *ldb = module->ldb; \
473 module = module->next; \
474 while (module && module->ops->op == NULL) module = module->next; \
475 if (module == NULL) { \
476 ldb_asprintf_errstring(ldb, "Unable to find backend operation for " #op ); \
477 return LDB_ERR_OPERATIONS_ERROR; \
483 helper functions to call the next module in chain
486 int ldb_next_request(struct ldb_module
*module
, struct ldb_request
*request
)
490 if (request
->callback
== NULL
) {
491 ldb_set_errstring(module
->ldb
, "Requests MUST define callbacks");
492 return LDB_ERR_UNWILLING_TO_PERFORM
;
495 switch (request
->operation
) {
497 FIND_OP(module
, search
);
498 ret
= module
->ops
->search(module
, request
);
501 FIND_OP(module
, add
);
502 ret
= module
->ops
->add(module
, request
);
505 FIND_OP(module
, modify
);
506 ret
= module
->ops
->modify(module
, request
);
509 FIND_OP(module
, del
);
510 ret
= module
->ops
->del(module
, request
);
513 FIND_OP(module
, rename
);
514 ret
= module
->ops
->rename(module
, request
);
517 FIND_OP(module
, extended
);
518 ret
= module
->ops
->extended(module
, request
);
520 case LDB_SEQUENCE_NUMBER
:
521 FIND_OP(module
, sequence_number
);
522 ret
= module
->ops
->sequence_number(module
, request
);
525 FIND_OP(module
, request
);
526 ret
= module
->ops
->request(module
, request
);
529 if (ret
== LDB_SUCCESS
) {
532 if (!ldb_errstring(module
->ldb
)) {
533 /* Set a default error string, to place the blame somewhere */
534 ldb_asprintf_errstring(module
->ldb
, "error in module %s: %s (%d)", module
->ops
->name
, ldb_strerror(ret
), ret
);
539 int ldb_next_init(struct ldb_module
*module
)
541 module
= module
->next
;
543 return ldb_init_module_chain(module
->ldb
, module
);
546 int ldb_next_start_trans(struct ldb_module
*module
)
548 FIND_OP(module
, start_transaction
);
549 return module
->ops
->start_transaction(module
);
552 int ldb_next_end_trans(struct ldb_module
*module
)
554 FIND_OP(module
, end_transaction
);
555 return module
->ops
->end_transaction(module
);
558 int ldb_next_del_trans(struct ldb_module
*module
)
560 FIND_OP(module
, del_transaction
);
561 return module
->ops
->del_transaction(module
);
564 struct ldb_handle
*ldb_handle_new(TALLOC_CTX
*mem_ctx
, struct ldb_context
*ldb
)
566 struct ldb_handle
*h
;
568 h
= talloc_zero(mem_ctx
, struct ldb_handle
);
570 ldb_set_errstring(ldb
, "Out of Memory");
574 h
->status
= LDB_SUCCESS
;
575 h
->state
= LDB_ASYNC_INIT
;
581 /* calls the request callback to send an entry
584 * req: the original request passed to your module
585 * msg: reply message (must be a talloc pointer, and it will be stolen
586 * on the ldb_reply that is sent to the callback)
589 int ldb_module_send_entry(struct ldb_request
*req
,
590 struct ldb_message
*msg
)
592 struct ldb_reply
*ares
;
594 ares
= talloc_zero(req
, struct ldb_reply
);
596 ldb_oom(req
->handle
->ldb
);
597 req
->callback(req
, NULL
);
598 return LDB_ERR_OPERATIONS_ERROR
;
600 ares
->type
= LDB_REPLY_ENTRY
;
601 ares
->message
= talloc_steal(ares
, msg
);
602 ares
->error
= LDB_SUCCESS
;
604 return req
->callback(req
, ares
);
607 /* calls the request callback to send an referrals
610 * req: the original request passed to your module
611 * ref: referral string (must be a talloc pointeri, steal)
614 int ldb_module_send_referral(struct ldb_request
*req
,
617 struct ldb_reply
*ares
;
619 ares
= talloc_zero(req
, struct ldb_reply
);
621 ldb_oom(req
->handle
->ldb
);
622 req
->callback(req
, NULL
);
623 return LDB_ERR_OPERATIONS_ERROR
;
625 ares
->type
= LDB_REPLY_REFERRAL
;
626 ares
->referral
= talloc_steal(ares
, ref
);
627 ares
->error
= LDB_SUCCESS
;
629 return req
->callback(req
, ares
);
632 /* calls the original request callback
635 * req: the original request passed to your module
636 * ctrls: controls to send in the reply (must be a talloc pointer, steal)
637 * response: results for extended request (steal)
638 * error: LDB_SUCCESS for a succesful return
639 * any other ldb error otherwise
641 int ldb_module_done(struct ldb_request
*req
,
642 struct ldb_control
**ctrls
,
643 struct ldb_extended
*response
,
646 struct ldb_reply
*ares
;
648 ares
= talloc_zero(req
, struct ldb_reply
);
650 ldb_oom(req
->handle
->ldb
);
651 req
->callback(req
, NULL
);
652 return LDB_ERR_OPERATIONS_ERROR
;
654 ares
->type
= LDB_REPLY_DONE
;
655 ares
->controls
= talloc_steal(ares
, ctrls
);
656 ares
->response
= talloc_steal(ares
, response
);
659 req
->callback(req
, ares
);
663 /* to be used *only* in modules init functions.
664 * this function i synchronous and will register
665 * the requested OID in the rootdse module if present
666 * otherwise it will return an error */
667 int ldb_mod_register_control(struct ldb_module
*module
, const char *oid
)
669 struct ldb_request
*req
;
672 req
= talloc_zero(module
, struct ldb_request
);
674 return LDB_ERR_OPERATIONS_ERROR
;
677 req
->operation
= LDB_REQ_REGISTER_CONTROL
;
678 req
->op
.reg_control
.oid
= oid
;
679 req
->callback
= ldb_op_default_callback
;
681 ldb_set_timeout(module
->ldb
, req
, 0);
683 req
->handle
= ldb_handle_new(req
, module
->ldb
);
684 if (req
->handle
== NULL
) {
685 return LDB_ERR_OPERATIONS_ERROR
;
688 ret
= ldb_request(module
->ldb
, req
);
689 if (ret
== LDB_SUCCESS
) {
690 ret
= ldb_wait(req
->handle
, LDB_WAIT_ALL
);
697 #ifndef STATIC_LIBLDB_MODULES
700 #define LDAP_BACKEND LDB_BACKEND(ldap), LDB_BACKEND(ldapi), LDB_BACKEND(ldaps),
705 #ifdef HAVE_LDB_SQLITE3
706 #define SQLITE3_BACKEND LDB_BACKEND(sqlite3),
708 #define SQLITE3_BACKEND
711 #define STATIC_LIBLDB_MODULES \
715 LDB_MODULE(operational), \
716 LDB_MODULE(rdn_name), \
717 LDB_MODULE(paged_results), \
718 LDB_MODULE(server_sort), \
724 * this is a bit hacked, as STATIC_LIBLDB_MODULES contains ','
725 * between the elements and we want to autogenerate the
726 * extern struct declarations, so we do some hacks and let the
727 * ',' appear in an unused function prototype.
730 #define NULL LDB_MODULE(NULL),
732 #define LDB_BACKEND(name) \
734 extern const struct ldb_backend_ops ldb_ ## name ## _backend_ops;\
735 extern void ldb_noop ## name (int
736 #define LDB_MODULE(name) \
738 extern const struct ldb_module_ops ldb_ ## name ## _module_ops;\
739 extern void ldb_noop ## name (int
741 extern void ldb_start_noop(int,
742 STATIC_LIBLDB_MODULES
747 .backend_ops = (void *)0, \
748 .module_ops = (void *)0 \
752 #define LDB_BACKEND(name) { \
753 .backend_ops = &ldb_ ## name ## _backend_ops, \
754 .module_ops = (void *)0 \
757 #define LDB_MODULE(name) { \
758 .backend_ops = (void *)0, \
759 .module_ops = &ldb_ ## name ## _module_ops \
762 static const struct ldb_builtins builtins
[] = {
763 STATIC_LIBLDB_MODULES