2 Unix SMB/CIFS mplementation.
4 The module that handles the Schema FSMO Role Owner
5 checkings, it also loads the dsdb_schema.
7 Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
8 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2009-2010
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program 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
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
26 #include "ldb_module.h"
27 #include "dsdb/samdb/samdb.h"
28 #include "librpc/gen_ndr/ndr_misc.h"
29 #include "librpc/gen_ndr/ndr_drsuapi.h"
30 #include "librpc/gen_ndr/ndr_drsblobs.h"
31 #include "param/param.h"
32 #include "dsdb/samdb/ldb_modules/util.h"
34 struct schema_load_private_data
{
38 static int dsdb_schema_from_db(struct ldb_module
*module
, struct ldb_dn
*schema_dn
, uint64_t current_usn
,
39 struct dsdb_schema
**schema
);
41 struct dsdb_schema
*dsdb_schema_refresh(struct ldb_module
*module
, struct dsdb_schema
*schema
, bool is_global_schema
)
45 struct ldb_result
*res
;
46 struct ldb_request
*treq
;
47 struct ldb_seqnum_request
*tseq
;
48 struct ldb_seqnum_result
*tseqr
;
49 struct dsdb_control_current_partition
*ctrl
;
50 struct ldb_context
*ldb
= ldb_module_get_ctx(module
);
51 struct dsdb_schema
*new_schema
;
53 struct schema_load_private_data
*private_data
= talloc_get_type(ldb_module_get_private(module
), struct schema_load_private_data
);
55 /* We can't refresh until the init function has run */
59 /* We don't allow a schema reload during a transaction - nobody else can modify our schema behind our backs */
60 if (private_data
->in_transaction
) {
64 res
= talloc_zero(schema
, struct ldb_result
);
68 tseq
= talloc_zero(res
, struct ldb_seqnum_request
);
73 tseq
->type
= LDB_SEQ_HIGHEST_SEQ
;
75 ret
= ldb_build_extended_req(&treq
, ldb_module_get_ctx(module
), res
,
76 LDB_EXTENDED_SEQUENCE_NUMBER
,
80 ldb_extended_default_callback
,
82 if (ret
!= LDB_SUCCESS
) {
87 ctrl
= talloc(treq
, struct dsdb_control_current_partition
);
92 ctrl
->version
= DSDB_CONTROL_CURRENT_PARTITION_VERSION
;
93 ctrl
->dn
= schema
->base_dn
;
95 ret
= ldb_request_add_control(treq
,
96 DSDB_CONTROL_CURRENT_PARTITION_OID
,
98 if (ret
!= LDB_SUCCESS
) {
103 ret
= ldb_next_request(module
, treq
);
104 if (ret
!= LDB_SUCCESS
) {
108 ret
= ldb_wait(treq
->handle
, LDB_WAIT_ALL
);
109 if (ret
!= LDB_SUCCESS
) {
113 tseqr
= talloc_get_type(res
->extended
->data
,
114 struct ldb_seqnum_result
);
115 if (tseqr
->seq_num
== schema
->reload_seq_number
) {
120 schema
->reload_seq_number
= tseqr
->seq_num
;
123 ret
= dsdb_module_load_partition_usn(module
, schema
->base_dn
, ¤t_usn
, NULL
);
124 if (ret
!= LDB_SUCCESS
|| current_usn
== schema
->loaded_usn
) {
128 ret
= dsdb_schema_from_db(module
, schema
->base_dn
, current_usn
, &new_schema
);
129 if (ret
!= LDB_SUCCESS
) {
133 if (is_global_schema
) {
134 dsdb_make_schema_global(ldb
, new_schema
);
141 Given an LDB module (pointing at the schema DB), and the DN, set the populated schema
144 static int dsdb_schema_from_db(struct ldb_module
*module
, struct ldb_dn
*schema_dn
, uint64_t current_usn
,
145 struct dsdb_schema
**schema
)
147 struct ldb_context
*ldb
= ldb_module_get_ctx(module
);
151 struct ldb_result
*schema_res
;
152 struct ldb_result
*a_res
;
153 struct ldb_result
*c_res
;
154 static const char *schema_attrs
[] = {
162 tmp_ctx
= talloc_new(module
);
165 return LDB_ERR_OPERATIONS_ERROR
;
168 /* we don't want to trace the schema load */
169 flags
= ldb_get_flags(ldb
);
170 ldb_set_flags(ldb
, flags
& ~LDB_FLG_ENABLE_TRACING
);
173 * setup the prefix mappings and schema info
175 ret
= dsdb_module_search_dn(module
, tmp_ctx
, &schema_res
,
176 schema_dn
, schema_attrs
, 0);
177 if (ret
== LDB_ERR_NO_SUCH_OBJECT
) {
178 ldb_reset_err_string(ldb
);
179 ldb_debug(ldb
, LDB_DEBUG_WARNING
,
180 "schema_load_init: no schema head present: (skip schema loading)\n");
182 } else if (ret
!= LDB_SUCCESS
) {
183 ldb_asprintf_errstring(ldb
,
184 "dsdb_schema: failed to search the schema head: %s",
190 * load the attribute definitions
192 ret
= dsdb_module_search(module
, tmp_ctx
, &a_res
,
193 schema_dn
, LDB_SCOPE_ONELEVEL
, NULL
,
195 "(objectClass=attributeSchema)");
196 if (ret
!= LDB_SUCCESS
) {
197 ldb_asprintf_errstring(ldb
,
198 "dsdb_schema: failed to search attributeSchema objects: %s",
204 * load the objectClass definitions
206 ret
= dsdb_module_search(module
, tmp_ctx
, &c_res
,
207 schema_dn
, LDB_SCOPE_ONELEVEL
, NULL
,
208 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT
,
209 "(objectClass=classSchema)");
210 if (ret
!= LDB_SUCCESS
) {
211 ldb_asprintf_errstring(ldb
,
212 "dsdb_schema: failed to search classSchema objects: %s",
217 ret
= dsdb_schema_from_ldb_results(tmp_ctx
, ldb
,
218 lp_iconv_convenience(ldb_get_opaque(ldb
, "loadparm")),
219 schema_res
, a_res
, c_res
, schema
, &error_string
);
220 if (ret
!= LDB_SUCCESS
) {
221 ldb_asprintf_errstring(ldb
,
222 "dsdb_schema load failed: %s",
227 (*schema
)->refresh_fn
= dsdb_schema_refresh
;
228 (*schema
)->loaded_from_module
= module
;
229 (*schema
)->loaded_usn
= current_usn
;
231 /* dsdb_set_schema() steal schema into the ldb_context */
232 ret
= dsdb_set_schema(ldb
, (*schema
));
234 if (ret
!= LDB_SUCCESS
) {
235 ldb_debug_set(ldb
, LDB_DEBUG_FATAL
,
236 "schema_load_init: dsdb_set_schema() failed: %d:%s: %s",
237 ret
, ldb_strerror(ret
), ldb_errstring(ldb
));
238 talloc_free(tmp_ctx
);
242 /* Ensure this module won't go away before the callback */
243 if (talloc_reference(*schema
, ldb
) == NULL
) {
245 ret
= LDB_ERR_OPERATIONS_ERROR
;
249 if (flags
& LDB_FLG_ENABLE_TRACING
) {
250 flags
= ldb_get_flags(ldb
);
251 ldb_set_flags(ldb
, flags
| LDB_FLG_ENABLE_TRACING
);
253 talloc_free(tmp_ctx
);
258 static int schema_load_init(struct ldb_module
*module
)
260 struct schema_load_private_data
*private_data
;
261 struct dsdb_schema
*schema
;
262 struct ldb_context
*ldb
= ldb_module_get_ctx(module
);
264 uint64_t current_usn
;
265 struct ldb_dn
*schema_dn
;
267 private_data
= talloc_zero(module
, struct schema_load_private_data
);
268 if (private_data
== NULL
) {
270 return LDB_ERR_OPERATIONS_ERROR
;
273 ldb_module_set_private(module
, private_data
);
275 ret
= ldb_next_init(module
);
276 if (ret
!= LDB_SUCCESS
) {
280 if (dsdb_get_schema(ldb
, NULL
)) {
284 schema_dn
= samdb_schema_dn(ldb
);
286 ldb_reset_err_string(ldb
);
287 ldb_debug(ldb
, LDB_DEBUG_WARNING
,
288 "schema_load_init: no schema dn present: (skip schema loading)\n");
292 ret
= dsdb_module_load_partition_usn(module
, schema_dn
, ¤t_usn
, NULL
);
293 if (ret
!= LDB_SUCCESS
) {
294 ldb_asprintf_errstring(ldb
,
295 "dsdb_load_partition_usn failed: %s",
300 return dsdb_schema_from_db(module
, schema_dn
, current_usn
, &schema
);
303 static int schema_load_start_transaction(struct ldb_module
*module
)
305 struct schema_load_private_data
*private_data
=
306 talloc_get_type(ldb_module_get_private(module
), struct schema_load_private_data
);
308 private_data
->in_transaction
= true;
310 return ldb_next_start_trans(module
);
313 static int schema_load_del_transaction(struct ldb_module
*module
)
315 struct schema_load_private_data
*private_data
=
316 talloc_get_type(ldb_module_get_private(module
), struct schema_load_private_data
);
318 private_data
->in_transaction
= false;
320 return ldb_next_del_trans(module
);
323 static int schema_load_prepare_commit(struct ldb_module
*module
)
326 struct schema_load_private_data
*private_data
=
327 talloc_get_type(ldb_module_get_private(module
), struct schema_load_private_data
);
329 ret
= ldb_next_prepare_commit(module
);
330 private_data
->in_transaction
= false;
334 static int schema_load_extended(struct ldb_module
*module
, struct ldb_request
*req
)
336 struct ldb_context
*ldb
;
338 ldb
= ldb_module_get_ctx(module
);
340 if (strcmp(req
->op
.extended
.oid
, DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID
) != 0) {
341 return ldb_next_request(module
, req
);
344 /* This is a no-op. We reload as soon as we can */
345 return ldb_module_done(req
, NULL
, NULL
, LDB_SUCCESS
);
349 _PUBLIC_
const struct ldb_module_ops ldb_schema_load_module_ops
= {
350 .name
= "schema_load",
351 .init_context
= schema_load_init
,
352 .extended
= schema_load_extended
,
353 .start_transaction
= schema_load_start_transaction
,
354 .prepare_commit
= schema_load_prepare_commit
,
355 .del_transaction
= schema_load_del_transaction
,