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);
167 /* we don't want to trace the schema load */
168 flags = ldb_get_flags(ldb);
169 ldb_set_flags(ldb, flags & ~LDB_FLG_ENABLE_TRACING);
172 * setup the prefix mappings and schema info
174 ret = dsdb_module_search_dn(module, tmp_ctx, &schema_res,
175 schema_dn, schema_attrs, 0);
176 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
177 ldb_reset_err_string(ldb);
178 ldb_debug(ldb, LDB_DEBUG_WARNING,
179 "schema_load_init: no schema head present: (skip schema loading)\n");
181 } else if (ret != LDB_SUCCESS) {
182 ldb_asprintf_errstring(ldb,
183 "dsdb_schema: failed to search the schema head: %s",
189 * load the attribute definitions
191 ret = dsdb_module_search(module, tmp_ctx, &a_res,
192 schema_dn, LDB_SCOPE_ONELEVEL, NULL,
193 DSDB_FLAG_NEXT_MODULE,
194 "(objectClass=attributeSchema)");
195 if (ret != LDB_SUCCESS) {
196 ldb_asprintf_errstring(ldb,
197 "dsdb_schema: failed to search attributeSchema objects: %s",
203 * load the objectClass definitions
205 ret = dsdb_module_search(module, tmp_ctx, &c_res,
206 schema_dn, LDB_SCOPE_ONELEVEL, NULL,
207 DSDB_FLAG_NEXT_MODULE |
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 schema_res, a_res, c_res, schema, &error_string);
219 if (ret != LDB_SUCCESS) {
220 ldb_asprintf_errstring(ldb,
221 "dsdb_schema load failed: %s",
226 (*schema)->refresh_in_progress = true;
227 (*schema)->refresh_fn = dsdb_schema_refresh;
228 (*schema)->loaded_from_module = module;
229 (*schema)->loaded_usn = current_usn;
231 /* "dsdb_set_schema()" steals schema into the ldb_context */
232 ret = dsdb_set_schema(ldb, (*schema));
234 if (*schema != NULL) {
235 (*schema)->refresh_in_progress = false;
238 if (ret != LDB_SUCCESS) {
239 ldb_debug_set(ldb, LDB_DEBUG_FATAL,
240 "schema_load_init: dsdb_set_schema() failed: %d:%s: %s",
241 ret, ldb_strerror(ret), ldb_errstring(ldb));
245 /* Ensure this module won't go away before the callback */
246 if (talloc_reference(*schema, ldb) == NULL) {
248 ret = LDB_ERR_OPERATIONS_ERROR;
252 if (flags & LDB_FLG_ENABLE_TRACING) {
253 flags = ldb_get_flags(ldb);
254 ldb_set_flags(ldb, flags | LDB_FLG_ENABLE_TRACING);
256 talloc_free(tmp_ctx);
261 static int schema_load_init(struct ldb_module *module)
263 struct schema_load_private_data *private_data;
264 struct dsdb_schema *schema;
265 struct ldb_context *ldb = ldb_module_get_ctx(module);
267 uint64_t current_usn;
268 struct ldb_dn *schema_dn;
270 private_data = talloc_zero(module, struct schema_load_private_data);
271 if (private_data == NULL) {
275 ldb_module_set_private(module, private_data);
277 ret = ldb_next_init(module);
278 if (ret != LDB_SUCCESS) {
282 if (dsdb_get_schema(ldb, NULL)) {
286 schema_dn = ldb_get_schema_basedn(ldb);
288 ldb_reset_err_string(ldb);
289 ldb_debug(ldb, LDB_DEBUG_WARNING,
290 "schema_load_init: no schema dn present: (skip schema loading)\n");
294 ret = dsdb_module_load_partition_usn(module, schema_dn, ¤t_usn, NULL);
295 if (ret != LDB_SUCCESS) {
296 /* Ignore the error and just reload the DB more often */
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,