5 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006
6 Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
8 * NOTICE: this module is NOT released under the GNU LGPL license as
9 * other ldb code. This module is release under the GNU GPL v2 or
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30 * Component: ldb partitions module
32 * Description: Implement LDAP partitions
34 * Author: Andrew Bartlett
35 * Author: Stefan Metzmacher
39 #include "ldb/include/ldb_includes.h"
40 #include "dsdb/samdb/samdb.h"
42 struct partition_private_data {
43 struct dsdb_control_current_partition **partitions;
44 struct ldb_dn **replicate;
47 struct partition_context {
48 struct ldb_module *module;
49 struct ldb_handle *handle;
50 struct ldb_request *orig_req;
52 struct ldb_request **down_req;
54 int finished_requests;
57 static struct partition_context *partition_init_handle(struct ldb_request *req, struct ldb_module *module)
59 struct partition_context *ac;
62 h = talloc_zero(req, struct ldb_handle);
64 ldb_set_errstring(module->ldb, "Out of Memory");
70 ac = talloc_zero(h, struct partition_context);
72 ldb_set_errstring(module->ldb, "Out of Memory");
88 static struct ldb_module *make_module_for_next_request(TALLOC_CTX *mem_ctx,
89 struct ldb_context *ldb,
90 struct ldb_module *module)
92 struct ldb_module *current;
93 static const struct ldb_module_ops ops; /* zero */
94 current = talloc_zero(mem_ctx, struct ldb_module);
95 if (current == NULL) {
101 current->prev = NULL;
102 current->next = module;
106 static struct dsdb_control_current_partition *find_partition(struct partition_private_data *data,
111 /* Look at base DN */
112 /* Figure out which partition it is under */
113 /* Skip the lot if 'data' isn't here yet (initialistion) */
114 for (i=0; data && data->partitions && data->partitions[i]; i++) {
115 if (ldb_dn_compare_base(data->partitions[i]->dn, dn) == 0) {
116 return data->partitions[i];
124 fire the caller's callback for every entry, but only send 'done' once.
126 static int partition_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
128 struct partition_context *ac;
130 if (!context || !ares) {
131 ldb_set_errstring(ldb, "partition_search_callback: NULL Context or Result in 'search' callback");
135 ac = talloc_get_type(context, struct partition_context);
137 if (ares->type == LDB_REPLY_ENTRY) {
138 return ac->orig_req->callback(ldb, ac->orig_req->context, ares);
140 ac->finished_requests++;
141 if (ac->finished_requests == ac->num_requests) {
142 return ac->orig_req->callback(ldb, ac->orig_req->context, ares);
150 return LDB_ERR_OPERATIONS_ERROR;
154 only fire the 'last' callback, and only for START-TLS for now
156 static int partition_other_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
158 struct partition_context *ac;
161 ldb_set_errstring(ldb, "partition_other_callback: NULL Context in 'other' callback");
165 ac = talloc_get_type(context, struct partition_context);
167 if (!ac->orig_req->callback) {
173 || (ares->type == LDB_REPLY_EXTENDED
174 && strcmp(ares->response->oid, LDB_EXTENDED_START_TLS_OID))) {
175 ac->finished_requests++;
176 if (ac->finished_requests == ac->num_requests) {
177 return ac->orig_req->callback(ldb, ac->orig_req->context, ares);
182 ldb_set_errstring(ldb, "partition_other_callback: Unknown reply type, only supports START_TLS");
185 return LDB_ERR_OPERATIONS_ERROR;
189 static int partition_send_request(struct partition_context *ac, struct ldb_control *remove_control,
190 struct dsdb_control_current_partition *partition)
193 struct ldb_module *backend;
194 struct ldb_request *req;
195 struct ldb_control **saved_controls;
198 backend = make_module_for_next_request(ac, ac->module->ldb, partition->module);
200 backend = ac->module;
203 ac->down_req = talloc_realloc(ac, ac->down_req,
204 struct ldb_request *, ac->num_requests + 1);
206 ldb_oom(ac->module->ldb);
207 return LDB_ERR_OPERATIONS_ERROR;
209 req = ac->down_req[ac->num_requests] = talloc(ac, struct ldb_request);
211 ldb_oom(ac->module->ldb);
212 return LDB_ERR_OPERATIONS_ERROR;
215 *req = *ac->orig_req; /* copy the request */
220 ac->orig_req->controls, talloc_get_size(ac->orig_req->controls));
221 if (req->controls == NULL) {
222 ldb_oom(ac->module->ldb);
223 return LDB_ERR_OPERATIONS_ERROR;
227 if (req->operation == LDB_SEARCH) {
228 /* If the search is for 'more' than this partition,
229 * then change the basedn, so a remote LDAP server
232 if (ldb_dn_compare_base(partition->dn, req->op.search.base) != 0) {
233 req->op.search.base = partition->dn;
236 req->op.search.base = NULL;
238 req->callback = partition_search_callback;
241 req->callback = partition_other_callback;
245 /* Remove a control, so we don't confuse a backend server */
246 if (remove_control && !save_controls(remove_control, req, &saved_controls)) {
247 ldb_oom(ac->module->ldb);
248 return LDB_ERR_OPERATIONS_ERROR;
252 ret = ldb_request_add_control(req, DSDB_CONTROL_CURRENT_PARTITION_OID, false, partition);
253 if (ret != LDB_SUCCESS) {
258 /* Spray off search requests to all backends */
259 ret = ldb_next_request(backend, req);
260 if (ret != LDB_SUCCESS) {
268 /* Send a request down to all the partitions */
269 static int partition_send_all(struct ldb_module *module,
270 struct partition_context *ac,
271 struct ldb_control *remove_control,
272 struct ldb_request *req)
275 struct partition_private_data *data = talloc_get_type(module->private_data,
276 struct partition_private_data);
277 int ret = partition_send_request(ac, remove_control, NULL);
278 if (ret != LDB_SUCCESS) {
281 for (i=0; data && data->partitions && data->partitions[i]; i++) {
282 ret = partition_send_request(ac, remove_control, data->partitions[i]);
283 if (ret != LDB_SUCCESS) {
290 /* Figure out which backend a request needs to be aimed at. Some
291 * requests must be replicated to all backends */
292 static int partition_replicate(struct ldb_module *module, struct ldb_request *req, struct ldb_dn *dn)
296 struct dsdb_control_current_partition *partition;
297 struct ldb_module *backend;
298 struct partition_private_data *data = talloc_get_type(module->private_data,
299 struct partition_private_data);
301 if (req->operation != LDB_SEARCH) {
302 /* Is this a special DN, we need to replicate to every backend? */
303 for (i=0; data->replicate && data->replicate[i]; i++) {
304 if (ldb_dn_compare(data->replicate[i],
306 struct partition_context *ac;
308 ac = partition_init_handle(req, module);
310 return LDB_ERR_OPERATIONS_ERROR;
313 return partition_send_all(module, ac, NULL, req);
318 /* Otherwise, we need to find the partition to fire it to */
321 partition = find_partition(data, dn);
324 * if we haven't found a matching partition
325 * pass the request to the main ldb
327 * TODO: we should maybe return an error here
328 * if it's not a special dn
330 return ldb_next_request(module, req);
333 backend = make_module_for_next_request(req, module->ldb, partition->module);
335 return LDB_ERR_OPERATIONS_ERROR;
338 ret = ldb_request_add_control(req, DSDB_CONTROL_CURRENT_PARTITION_OID, false, partition);
339 if (ret != LDB_SUCCESS) {
344 return ldb_next_request(backend, req);
348 static int partition_search(struct ldb_module *module, struct ldb_request *req)
351 struct partition_private_data *data = talloc_get_type(module->private_data,
352 struct partition_private_data);
355 /* (later) consider if we should be searching multiple
356 * partitions (for 'invisible' partition behaviour */
357 struct ldb_control *search_control = ldb_request_get_control(req, LDB_CONTROL_SEARCH_OPTIONS_OID);
359 struct ldb_search_options_control *search_options = NULL;
360 if (search_control) {
361 search_options = talloc_get_type(search_control->data, struct ldb_search_options_control);
364 if (search_options && (search_options->search_options & LDB_SEARCH_OPTION_PHANTOM_ROOT)) {
366 struct partition_context *ac;
367 struct ldb_control *remove_control = NULL;
368 if ((search_options->search_options & ~LDB_SEARCH_OPTION_PHANTOM_ROOT) == 0) {
369 /* We have processed this flag, so we are done with this control now */
370 remove_control = search_control;
372 ac = partition_init_handle(req, module);
374 return LDB_ERR_OPERATIONS_ERROR;
377 /* Search from the base DN */
378 if (!req->op.search.base || ldb_dn_is_null(req->op.search.base)) {
379 return partition_send_all(module, ac, remove_control, req);
381 for (i=0; data && data->partitions && data->partitions[i]; i++) {
382 /* Find all partitions under the search base */
383 if (ldb_dn_compare_base(req->op.search.base, data->partitions[i]->dn) == 0) {
384 ret = partition_send_request(ac, remove_control, data->partitions[i]);
385 if (ret != LDB_SUCCESS) {
391 /* Perhaps we didn't match any partitions. Try the main partition, only */
392 if (ac->num_requests == 0) {
394 return ldb_next_request(module, req);
399 /* Handle this like all other requests */
400 return partition_replicate(module, req, req->op.search.base);
405 static int partition_add(struct ldb_module *module, struct ldb_request *req)
407 return partition_replicate(module, req, req->op.add.message->dn);
411 static int partition_modify(struct ldb_module *module, struct ldb_request *req)
413 return partition_replicate(module, req, req->op.mod.message->dn);
417 static int partition_delete(struct ldb_module *module, struct ldb_request *req)
419 return partition_replicate(module, req, req->op.del.dn);
423 static int partition_rename(struct ldb_module *module, struct ldb_request *req)
426 struct dsdb_control_current_partition *backend, *backend2;
428 struct partition_private_data *data = talloc_get_type(module->private_data,
429 struct partition_private_data);
431 /* Skip the lot if 'data' isn't here yet (initialistion) */
433 return LDB_ERR_OPERATIONS_ERROR;
436 backend = find_partition(data, req->op.rename.olddn);
437 backend2 = find_partition(data, req->op.rename.newdn);
439 if ((backend && !backend2) || (!backend && backend2)) {
440 return LDB_ERR_AFFECTS_MULTIPLE_DSAS;
443 if (backend != backend2) {
444 ldb_asprintf_errstring(module->ldb,
445 "Cannot rename from %s in %s to %s in %s: %s",
446 ldb_dn_get_linearized(req->op.rename.olddn),
447 ldb_dn_get_linearized(backend->dn),
448 ldb_dn_get_linearized(req->op.rename.newdn),
449 ldb_dn_get_linearized(backend2->dn),
450 ldb_strerror(LDB_ERR_AFFECTS_MULTIPLE_DSAS));
451 return LDB_ERR_AFFECTS_MULTIPLE_DSAS;
454 return partition_replicate(module, req, req->op.rename.olddn);
457 /* start a transaction */
458 static int partition_start_trans(struct ldb_module *module)
461 struct partition_private_data *data = talloc_get_type(module->private_data,
462 struct partition_private_data);
463 /* Look at base DN */
464 /* Figure out which partition it is under */
465 /* Skip the lot if 'data' isn't here yet (initialistion) */
466 ret = ldb_next_start_trans(module);
467 if (ret != LDB_SUCCESS) {
471 for (i=0; data && data->partitions && data->partitions[i]; i++) {
472 struct ldb_module *next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
474 ret = ldb_next_start_trans(next);
476 if (ret != LDB_SUCCESS) {
477 /* Back it out, if it fails on one */
478 for (i--; i >= 0; i--) {
479 next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
480 ldb_next_del_trans(next);
489 /* end a transaction */
490 static int partition_end_trans(struct ldb_module *module)
492 int i, ret, ret2 = LDB_SUCCESS;
493 struct partition_private_data *data = talloc_get_type(module->private_data,
494 struct partition_private_data);
495 ret = ldb_next_end_trans(module);
496 if (ret != LDB_SUCCESS) {
500 /* Look at base DN */
501 /* Figure out which partition it is under */
502 /* Skip the lot if 'data' isn't here yet (initialistion) */
503 for (i=0; data && data->partitions && data->partitions[i]; i++) {
504 struct ldb_module *next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
506 ret = ldb_next_end_trans(next);
508 if (ret != LDB_SUCCESS) {
513 if (ret != LDB_SUCCESS) {
514 /* Back it out, if it fails on one */
515 for (i=0; data && data->partitions && data->partitions[i]; i++) {
516 struct ldb_module *next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
517 ldb_next_del_trans(next);
524 /* delete a transaction */
525 static int partition_del_trans(struct ldb_module *module)
527 int i, ret, ret2 = LDB_SUCCESS;
528 struct partition_private_data *data = talloc_get_type(module->private_data,
529 struct partition_private_data);
530 ret = ldb_next_del_trans(module);
531 if (ret != LDB_SUCCESS) {
535 /* Look at base DN */
536 /* Figure out which partition it is under */
537 /* Skip the lot if 'data' isn't here yet (initialistion) */
538 for (i=0; data && data->partitions && data->partitions[i]; i++) {
539 struct ldb_module *next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
541 ret = ldb_next_del_trans(next);
543 if (ret != LDB_SUCCESS) {
550 static int partition_sequence_number(struct ldb_module *module, struct ldb_request *req)
553 uint64_t seq_number = 0;
554 uint64_t timestamp_sequence = 0;
555 uint64_t timestamp = 0;
556 struct partition_private_data *data = talloc_get_type(module->private_data,
557 struct partition_private_data);
559 switch (req->op.seq_num.type) {
561 case LDB_SEQ_HIGHEST_SEQ:
562 ret = ldb_next_request(module, req);
563 if (ret != LDB_SUCCESS) {
566 if (req->op.seq_num.flags & LDB_SEQ_TIMESTAMP_SEQUENCE) {
567 timestamp_sequence = req->op.seq_num.seq_num;
569 seq_number = seq_number + req->op.seq_num.seq_num;
572 /* Look at base DN */
573 /* Figure out which partition it is under */
574 /* Skip the lot if 'data' isn't here yet (initialistion) */
575 for (i=0; data && data->partitions && data->partitions[i]; i++) {
576 struct ldb_module *next = make_module_for_next_request(req, module->ldb, data->partitions[i]->module);
578 ret = ldb_next_request(next, req);
580 if (ret != LDB_SUCCESS) {
583 if (req->op.seq_num.flags & LDB_SEQ_TIMESTAMP_SEQUENCE) {
584 timestamp_sequence = MAX(timestamp_sequence, req->op.seq_num.seq_num);
586 seq_number = seq_number + req->op.seq_num.seq_num;
590 case LDB_SEQ_HIGHEST_TIMESTAMP:
592 struct ldb_request *date_req = talloc(req, struct ldb_request);
594 return LDB_ERR_OPERATIONS_ERROR;
597 date_req->op.seq_num.flags = LDB_SEQ_HIGHEST_TIMESTAMP;
599 ret = ldb_next_request(module, date_req);
600 if (ret != LDB_SUCCESS) {
603 timestamp = date_req->op.seq_num.seq_num;
605 /* Look at base DN */
606 /* Figure out which partition it is under */
607 /* Skip the lot if 'data' isn't here yet (initialistion) */
608 for (i=0; data && data->partitions && data->partitions[i]; i++) {
609 struct ldb_module *next = make_module_for_next_request(req, module->ldb, data->partitions[i]->module);
611 ret = ldb_next_request(next, date_req);
613 if (ret != LDB_SUCCESS) {
616 timestamp = MAX(timestamp, date_req->op.seq_num.seq_num);
622 switch (req->op.seq_num.flags) {
624 case LDB_SEQ_HIGHEST_SEQ:
626 req->op.seq_num.flags = 0;
628 /* Has someone above set a timebase sequence? */
629 if (timestamp_sequence) {
630 req->op.seq_num.seq_num = (((unsigned long long)timestamp << 24) | (seq_number & 0xFFFFFF));
632 req->op.seq_num.seq_num = seq_number;
635 if (timestamp_sequence > req->op.seq_num.seq_num) {
636 req->op.seq_num.seq_num = timestamp_sequence;
637 req->op.seq_num.flags |= LDB_SEQ_TIMESTAMP_SEQUENCE;
640 req->op.seq_num.flags |= LDB_SEQ_GLOBAL_SEQUENCE;
642 case LDB_SEQ_HIGHEST_TIMESTAMP:
643 req->op.seq_num.seq_num = timestamp;
647 switch (req->op.seq_num.flags) {
649 req->op.seq_num.seq_num++;
654 static int partition_extended_replicated_objects(struct ldb_module *module, struct ldb_request *req)
656 struct dsdb_extended_replicated_objects *ext;
658 ext = talloc_get_type(req->op.extended.data, struct dsdb_extended_replicated_objects);
660 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended_replicated_objects: invalid extended data\n");
661 return LDB_ERR_PROTOCOL_ERROR;
664 if (ext->version != DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION) {
665 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended_replicated_objects: extended data invalid version [%u != %u]\n",
666 ext->version, DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION);
667 return LDB_ERR_PROTOCOL_ERROR;
670 return partition_replicate(module, req, ext->partition_dn);
674 static int partition_extended(struct ldb_module *module, struct ldb_request *req)
676 struct partition_context *ac;
678 if (strcmp(req->op.extended.oid, DSDB_EXTENDED_REPLICATED_OBJECTS_OID) == 0) {
679 return partition_extended_replicated_objects(module, req);
683 * as the extended operation has no dn
684 * we need to send it to all partitions
687 ac = partition_init_handle(req, module);
689 return LDB_ERR_OPERATIONS_ERROR;
692 return partition_send_all(module, ac, NULL, req);
695 static int sort_compare(void *void1,
696 void *void2, void *opaque)
698 struct dsdb_control_current_partition **pp1 = void1;
699 struct dsdb_control_current_partition **pp2 = void2;
700 struct dsdb_control_current_partition *partition1 = talloc_get_type(*pp1,
701 struct dsdb_control_current_partition);
702 struct dsdb_control_current_partition *partition2 = talloc_get_type(*pp2,
703 struct dsdb_control_current_partition);
705 return ldb_dn_compare(partition1->dn, partition2->dn);
708 static const char *relative_path(struct ldb_module *module,
712 const char *base_url = ldb_get_opaque(module->ldb, "ldb_url");
713 char *path, *p, *full_name;
717 if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
718 return talloc_strdup(mem_ctx, name);
720 path = talloc_strdup(mem_ctx, base_url);
724 if ( (p = strrchr(path, '/')) != NULL) {
730 full_name = talloc_asprintf(mem_ctx, "%s/%s", path, name);
735 static int partition_init(struct ldb_module *module)
738 TALLOC_CTX *mem_ctx = talloc_new(module);
739 static const char *attrs[] = { "partition", "replicateEntries", "modules", NULL };
740 struct ldb_result *res;
741 struct ldb_message *msg;
742 struct ldb_message_element *partition_attributes;
743 struct ldb_message_element *replicate_attributes;
744 struct ldb_message_element *modules_attributes;
746 struct partition_private_data *data;
749 return LDB_ERR_OPERATIONS_ERROR;
752 data = talloc(mem_ctx, struct partition_private_data);
754 return LDB_ERR_OPERATIONS_ERROR;
757 ret = ldb_search(module->ldb, ldb_dn_new(mem_ctx, module->ldb, "@PARTITION"),
761 if (ret != LDB_SUCCESS) {
762 talloc_free(mem_ctx);
765 talloc_steal(mem_ctx, res);
766 if (res->count == 0) {
767 talloc_free(mem_ctx);
768 return ldb_next_init(module);
771 if (res->count > 1) {
772 talloc_free(mem_ctx);
773 return LDB_ERR_CONSTRAINT_VIOLATION;
778 partition_attributes = ldb_msg_find_element(msg, "partition");
779 if (!partition_attributes) {
780 ldb_set_errstring(module->ldb, "partition_init: no partitions specified");
781 talloc_free(mem_ctx);
782 return LDB_ERR_CONSTRAINT_VIOLATION;
784 data->partitions = talloc_array(data, struct dsdb_control_current_partition *, partition_attributes->num_values + 1);
785 if (!data->partitions) {
786 talloc_free(mem_ctx);
787 return LDB_ERR_OPERATIONS_ERROR;
789 for (i=0; i < partition_attributes->num_values; i++) {
790 char *base = talloc_strdup(data->partitions, (char *)partition_attributes->values[i].data);
791 char *p = strchr(base, ':');
793 ldb_asprintf_errstring(module->ldb,
795 "invalid form for partition record (missing ':'): %s", base);
796 talloc_free(mem_ctx);
797 return LDB_ERR_CONSTRAINT_VIOLATION;
802 ldb_asprintf_errstring(module->ldb,
804 "invalid form for partition record (missing backend database): %s", base);
805 talloc_free(mem_ctx);
806 return LDB_ERR_CONSTRAINT_VIOLATION;
808 data->partitions[i] = talloc(data->partitions, struct dsdb_control_current_partition);
809 if (!data->partitions[i]) {
810 talloc_free(mem_ctx);
811 return LDB_ERR_OPERATIONS_ERROR;
813 data->partitions[i]->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
815 data->partitions[i]->dn = ldb_dn_new(data->partitions[i], module->ldb, base);
816 if (!data->partitions[i]->dn) {
817 ldb_asprintf_errstring(module->ldb,
818 "partition_init: invalid DN in partition record: %s", base);
819 talloc_free(mem_ctx);
820 return LDB_ERR_CONSTRAINT_VIOLATION;
823 data->partitions[i]->backend = relative_path(module,
826 ret = ldb_connect_backend(module->ldb, data->partitions[i]->backend, NULL, &data->partitions[i]->module);
827 if (ret != LDB_SUCCESS) {
828 talloc_free(mem_ctx);
832 data->partitions[i] = NULL;
834 /* sort these into order, most to least specific */
835 ldb_qsort(data->partitions, partition_attributes->num_values, sizeof(*data->partitions),
836 module->ldb, sort_compare);
838 for (i=0; data->partitions[i]; i++) {
839 struct ldb_request *req;
840 req = talloc_zero(mem_ctx, struct ldb_request);
842 ldb_debug(module->ldb, LDB_DEBUG_ERROR, "partition: Out of memory!\n");
843 talloc_free(mem_ctx);
844 return LDB_ERR_OPERATIONS_ERROR;
847 req->operation = LDB_REQ_REGISTER_PARTITION;
848 req->op.reg_partition.dn = data->partitions[i]->dn;
850 ret = ldb_request(module->ldb, req);
851 if (ret != LDB_SUCCESS) {
852 ldb_debug(module->ldb, LDB_DEBUG_ERROR, "partition: Unable to register partition with rootdse!\n");
853 talloc_free(mem_ctx);
854 return LDB_ERR_OTHER;
859 replicate_attributes = ldb_msg_find_element(msg, "replicateEntries");
860 if (!replicate_attributes) {
861 data->replicate = NULL;
863 data->replicate = talloc_array(data, struct ldb_dn *, replicate_attributes->num_values + 1);
864 if (!data->replicate) {
865 talloc_free(mem_ctx);
866 return LDB_ERR_OPERATIONS_ERROR;
869 for (i=0; i < replicate_attributes->num_values; i++) {
870 data->replicate[i] = ldb_dn_new(data->replicate, module->ldb, (const char *)replicate_attributes->values[i].data);
871 if (!ldb_dn_validate(data->replicate[i])) {
872 ldb_asprintf_errstring(module->ldb,
874 "invalid DN in partition replicate record: %s",
875 replicate_attributes->values[i].data);
876 talloc_free(mem_ctx);
877 return LDB_ERR_CONSTRAINT_VIOLATION;
880 data->replicate[i] = NULL;
883 /* Make the private data available to any searches the modules may trigger in initialisation */
884 module->private_data = data;
885 talloc_steal(module, data);
887 modules_attributes = ldb_msg_find_element(msg, "modules");
888 if (modules_attributes) {
889 for (i=0; i < modules_attributes->num_values; i++) {
890 struct ldb_dn *base_dn;
892 struct dsdb_control_current_partition *partition = NULL;
893 const char **modules = NULL;
895 char *base = talloc_strdup(data->partitions, (char *)modules_attributes->values[i].data);
896 char *p = strchr(base, ':');
898 ldb_asprintf_errstring(module->ldb,
900 "invalid form for partition module record (missing ':'): %s", base);
901 talloc_free(mem_ctx);
902 return LDB_ERR_CONSTRAINT_VIOLATION;
907 ldb_asprintf_errstring(module->ldb,
909 "invalid form for partition module record (missing backend database): %s", base);
910 talloc_free(mem_ctx);
911 return LDB_ERR_CONSTRAINT_VIOLATION;
914 modules = ldb_modules_list_from_string(module->ldb, mem_ctx,
917 base_dn = ldb_dn_new(mem_ctx, module->ldb, base);
918 if (!ldb_dn_validate(base_dn)) {
919 talloc_free(mem_ctx);
920 return LDB_ERR_OPERATIONS_ERROR;
923 for (partition_idx = 0; data->partitions[partition_idx]; partition_idx++) {
924 if (ldb_dn_compare(data->partitions[partition_idx]->dn, base_dn) == 0) {
925 partition = data->partitions[partition_idx];
931 ldb_asprintf_errstring(module->ldb,
933 "invalid form for partition module record (no such partition): %s", base);
934 talloc_free(mem_ctx);
935 return LDB_ERR_CONSTRAINT_VIOLATION;
938 ret = ldb_load_modules_list(module->ldb, modules, partition->module, &partition->module);
939 if (ret != LDB_SUCCESS) {
940 ldb_asprintf_errstring(module->ldb,
942 "loading backend for %s failed: %s",
943 base, ldb_errstring(module->ldb));
944 talloc_free(mem_ctx);
947 ret = ldb_init_module_chain(module->ldb, partition->module);
948 if (ret != LDB_SUCCESS) {
949 ldb_asprintf_errstring(module->ldb,
951 "initialising backend for %s failed: %s",
952 base, ldb_errstring(module->ldb));
953 talloc_free(mem_ctx);
959 talloc_free(mem_ctx);
960 return ldb_next_init(module);
963 static int partition_wait_none(struct ldb_handle *handle) {
964 struct partition_context *ac;
968 if (!handle || !handle->private_data) {
969 return LDB_ERR_OPERATIONS_ERROR;
972 if (handle->state == LDB_ASYNC_DONE) {
973 return handle->status;
976 handle->state = LDB_ASYNC_PENDING;
977 handle->status = LDB_SUCCESS;
979 ac = talloc_get_type(handle->private_data, struct partition_context);
981 for (i=0; i < ac->num_requests; i++) {
982 ret = ldb_wait(ac->down_req[i]->handle, LDB_WAIT_NONE);
984 if (ret != LDB_SUCCESS) {
985 handle->status = ret;
988 if (ac->down_req[i]->handle->status != LDB_SUCCESS) {
989 handle->status = ac->down_req[i]->handle->status;
993 if (ac->down_req[i]->handle->state != LDB_ASYNC_DONE) {
1001 handle->state = LDB_ASYNC_DONE;
1006 static int partition_wait_all(struct ldb_handle *handle) {
1010 while (handle->state != LDB_ASYNC_DONE) {
1011 ret = partition_wait_none(handle);
1012 if (ret != LDB_SUCCESS) {
1017 return handle->status;
1020 static int partition_wait(struct ldb_handle *handle, enum ldb_wait_type type)
1022 if (type == LDB_WAIT_ALL) {
1023 return partition_wait_all(handle);
1025 return partition_wait_none(handle);
1029 static const struct ldb_module_ops partition_ops = {
1030 .name = "partition",
1031 .init_context = partition_init,
1032 .search = partition_search,
1033 .add = partition_add,
1034 .modify = partition_modify,
1035 .del = partition_delete,
1036 .rename = partition_rename,
1037 .extended = partition_extended,
1038 .sequence_number = partition_sequence_number,
1039 .start_transaction = partition_start_trans,
1040 .end_transaction = partition_end_trans,
1041 .del_transaction = partition_del_trans,
1042 .wait = partition_wait
1045 int ldb_partition_init(void)
1047 return ldb_register_module(&partition_ops);