2 Samba4 module loading module
4 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2009
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 * Component: Samba4 module loading module
25 * Description: Implement a single 'module' in the ldb database,
26 * which loads the remaining modules based on 'choice of configuration' attributes
28 * This is to avoid forcing a reprovision of the ldb databases when we change the internal structure of the code
30 * Author: Andrew Bartlett
35 #include <ldb_errors.h>
36 #include <ldb_module.h>
37 #include "dsdb/samdb/ldb_modules/util.h"
38 #include "dsdb/samdb/samdb.h"
39 #include "librpc/ndr/libndr.h"
41 static int read_at_rootdse_record(struct ldb_context
*ldb
, struct ldb_module
*module
, TALLOC_CTX
*mem_ctx
,
42 struct ldb_message
**msg
, struct ldb_request
*parent
)
45 static const char *rootdse_attrs
[] = { "defaultNamingContext", "configurationNamingContext", "schemaNamingContext", NULL
};
46 struct ldb_result
*rootdse_res
;
47 struct ldb_dn
*rootdse_dn
;
48 TALLOC_CTX
*tmp_ctx
= talloc_new(mem_ctx
);
53 rootdse_dn
= ldb_dn_new(tmp_ctx
, ldb
, "@ROOTDSE");
59 ret
= dsdb_module_search_dn(module
, tmp_ctx
, &rootdse_res
, rootdse_dn
,
60 rootdse_attrs
, DSDB_FLAG_NEXT_MODULE
, parent
);
61 if (ret
!= LDB_SUCCESS
) {
66 talloc_steal(mem_ctx
, rootdse_res
->msgs
);
67 *msg
= rootdse_res
->msgs
[0];
74 static int prepare_modules_line(struct ldb_context
*ldb
,
76 const struct ldb_message
*rootdse_msg
,
77 struct ldb_message
*msg
, const char *backend_attr
,
78 const char *backend_mod
, const char **backend_mod_list
)
81 const char **backend_full_list
;
82 const char *backend_dn
;
83 char *mod_list_string
;
85 TALLOC_CTX
*tmp_ctx
= talloc_new(mem_ctx
);
91 backend_dn
= ldb_msg_find_attr_as_string(rootdse_msg
, backend_attr
, NULL
);
93 ldb_asprintf_errstring(ldb
,
95 "unable to read %s from %s:%s",
96 backend_attr
, ldb_dn_get_linearized(rootdse_msg
->dn
),
98 return LDB_ERR_CONSTRAINT_VIOLATION
;
105 backend_full_list
= (const char **)str_list_make_single(tmp_ctx
, backend_mod
);
107 backend_full_list
= (const char **)str_list_make_empty(tmp_ctx
);
109 if (!backend_full_list
) {
110 talloc_free(tmp_ctx
);
114 backend_full_list
= str_list_append_const(backend_full_list
, backend_mod_list
);
115 if (!backend_full_list
) {
116 talloc_free(tmp_ctx
);
120 mod_list_string
= str_list_join(tmp_ctx
, backend_full_list
, ',');
121 if (!mod_list_string
) {
122 talloc_free(tmp_ctx
);
126 full_string
= talloc_asprintf(tmp_ctx
, "%s:%s", backend_dn
, mod_list_string
);
127 ret
= ldb_msg_add_steal_string(msg
, "modules", full_string
);
128 talloc_free(tmp_ctx
);
134 static int samba_dsdb_init(struct ldb_module
*module
)
136 struct ldb_context
*ldb
= ldb_module_get_ctx(module
);
138 TALLOC_CTX
*tmp_ctx
= talloc_new(module
);
139 struct ldb_result
*res
;
140 struct ldb_message
*rootdse_msg
, *partition_msg
;
141 struct ldb_dn
*samba_dsdb_dn
;
142 struct ldb_module
*backend_module
, *module_chain
;
143 const char **final_module_list
, **reverse_module_list
;
145 Add modules to the list to activate them by default
146 beware often order is important
148 Some Known ordering constraints:
149 - rootdse must be first, as it makes redirects from "" -> cn=rootdse
150 - extended_dn_in must be before objectclass.c, as it resolves the DN
151 - objectclass must be before password_hash and samldb since these LDB
152 modules require the expanded "objectClass" list
153 - objectclass_attrs must be behind operational in order to see all
154 attributes (the operational module protects and therefore
155 suppresses per default some important ones)
156 - partition must be last
157 - each partition has its own module list then
159 The list is presented here as a set of declarations to show the
160 stack visually - the code below then handles the creation of the list
161 based on the parameters loaded from the database.
163 static const char *modules_list
[] = {"resolve_oids",
186 const char **link_modules
;
187 static const char *fedora_ds_modules
[] = {
189 static const char *openldap_modules
[] = {
191 static const char *tdb_modules_list
[] = {
199 const char *extended_dn_module
;
200 const char *extended_dn_module_ldb
= "extended_dn_out_ldb";
201 const char *extended_dn_module_fds
= "extended_dn_out_fds";
202 const char *extended_dn_module_openldap
= "extended_dn_out_openldap";
204 static const char *modules_list2
[] = {"show_deleted",
209 const char **backend_modules
;
210 static const char *fedora_ds_backend_modules
[] = {
211 "nsuniqueid", "paged_searches", "simple_dn", NULL
};
212 static const char *openldap_backend_modules
[] = {
213 "entryuuid", "paged_searches", "simple_dn", NULL
};
215 static const char *samba_dsdb_attrs
[] = { "backendType", "serverRole", NULL
};
216 const char *backendType
, *serverRole
;
222 ret
= ldb_register_samba_handlers(ldb
);
223 if (ret
!= LDB_SUCCESS
) {
224 talloc_free(tmp_ctx
);
228 samba_dsdb_dn
= ldb_dn_new(tmp_ctx
, ldb
, "@SAMBA_DSDB");
229 if (!samba_dsdb_dn
) {
230 talloc_free(tmp_ctx
);
234 #define CHECK_LDB_RET(check_ret) \
236 if (check_ret != LDB_SUCCESS) { \
237 talloc_free(tmp_ctx); \
242 ret
= dsdb_module_search_dn(module
, tmp_ctx
, &res
, samba_dsdb_dn
,
243 samba_dsdb_attrs
, DSDB_FLAG_NEXT_MODULE
, NULL
);
244 if (ret
== LDB_ERR_NO_SUCH_OBJECT
) {
246 serverRole
= "domain controller";
247 } else if (ret
== LDB_SUCCESS
) {
248 backendType
= ldb_msg_find_attr_as_string(res
->msgs
[0], "backendType", "ldb");
249 serverRole
= ldb_msg_find_attr_as_string(res
->msgs
[0], "serverRole", "domain controller");
251 talloc_free(tmp_ctx
);
255 backend_modules
= NULL
;
256 if (strcasecmp(backendType
, "ldb") == 0) {
257 extended_dn_module
= extended_dn_module_ldb
;
258 link_modules
= tdb_modules_list
;
260 if (strcasecmp(backendType
, "fedora-ds") == 0) {
261 link_modules
= fedora_ds_modules
;
262 backend_modules
= fedora_ds_backend_modules
;
263 extended_dn_module
= extended_dn_module_fds
;
264 } else if (strcasecmp(backendType
, "openldap") == 0) {
265 link_modules
= openldap_modules
;
266 backend_modules
= openldap_backend_modules
;
267 extended_dn_module
= extended_dn_module_openldap
;
269 return ldb_error(ldb
, LDB_ERR_OPERATIONS_ERROR
, "invalid backend type");
271 ret
= ldb_set_opaque(ldb
, "readOnlySchema", (void*)1);
272 if (ret
!= LDB_SUCCESS
) {
273 ldb_set_errstring(ldb
, "Failed to set readOnlySchema opaque");
277 #define CHECK_MODULE_LIST \
279 if (!final_module_list) { \
280 talloc_free(tmp_ctx); \
281 return ldb_oom(ldb); \
285 final_module_list
= str_list_copy_const(tmp_ctx
, modules_list
);
288 final_module_list
= str_list_append_const(final_module_list
, link_modules
);
291 final_module_list
= str_list_add_const(final_module_list
, extended_dn_module
);
294 final_module_list
= str_list_append_const(final_module_list
, modules_list2
);
298 ret
= read_at_rootdse_record(ldb
, module
, tmp_ctx
, &rootdse_msg
, NULL
);
301 partition_msg
= ldb_msg_new(tmp_ctx
);
302 partition_msg
->dn
= ldb_dn_new(partition_msg
, ldb
, "@" DSDB_OPAQUE_PARTITION_MODULE_MSG_OPAQUE_NAME
);
304 ret
= prepare_modules_line(ldb
, tmp_ctx
,
306 partition_msg
, "schemaNamingContext",
307 "schema_data", backend_modules
);
310 ret
= prepare_modules_line(ldb
, tmp_ctx
,
313 NULL
, backend_modules
);
316 ret
= ldb_set_opaque(ldb
, DSDB_OPAQUE_PARTITION_MODULE_MSG_OPAQUE_NAME
, partition_msg
);
319 talloc_steal(ldb
, partition_msg
);
321 /* Now prepare the module chain. Oddly, we must give it to ldb_load_modules_list in REVERSE */
322 for (len
= 0; final_module_list
[len
]; len
++) { /* noop */};
324 reverse_module_list
= talloc_array(tmp_ctx
, const char *, len
+1);
325 if (!reverse_module_list
) {
326 talloc_free(tmp_ctx
);
329 for (i
=0; i
< len
; i
++) {
330 reverse_module_list
[i
] = final_module_list
[(len
- 1) - i
];
332 reverse_module_list
[i
] = NULL
;
334 /* The backend (at least until the partitions module
335 * reconfigures things) is the next module in the currently
337 backend_module
= ldb_module_next(module
);
338 ret
= ldb_module_load_list(ldb
, reverse_module_list
, backend_module
, &module_chain
);
341 talloc_free(tmp_ctx
);
342 /* Set this as the 'next' module, so that we effectivly append it to module chain */
343 ldb_module_set_next(module
, module_chain
);
345 return ldb_next_init(module
);
348 static const struct ldb_module_ops ldb_samba_dsdb_module_ops
= {
349 .name
= "samba_dsdb",
350 .init_context
= samba_dsdb_init
,
353 int ldb_samba_dsdb_module_init(const char *version
)
355 LDB_MODULE_CHECK_VERSION(version
);
356 return ldb_register_module(&ldb_samba_dsdb_module_ops
);