*/
#include "includes.h"
-#include "ldb/include/ldb_includes.h"
+#include "lib/ldb/include/ldb.h"
+#include "lib/ldb/include/ldb_errors.h"
+#include "lib/ldb/include/ldb_module.h"
+#include "lib/ldb/include/ldb_private.h"
#include "dsdb/samdb/samdb.h"
struct partition_private_data {
ac = talloc_zero(req, struct partition_context);
if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
+ ldb_set_errstring(ldb_module_get_ctx(module), "Out of Memory");
return NULL;
}
return ac;
}
-#define PARTITION_FIND_OP(module, op) do { \
- struct ldb_context *ldbctx = module->ldb; \
+#define PARTITION_FIND_OP_NOERROR(module, op) do { \
while (module && module->ops->op == NULL) module = module->next; \
+} while (0)
+
+#define PARTITION_FIND_OP(module, op) do { \
+ PARTITION_FIND_OP_NOERROR(module, op); \
if (module == NULL) { \
- ldb_asprintf_errstring(ldbctx, \
+ ldb_asprintf_errstring(ldb_module_get_ctx(module), \
"Unable to find backend operation for " #op ); \
return LDB_ERR_OPERATIONS_ERROR; \
} \
* helper functions to call the next module in chain
* */
-int partition_request(struct ldb_module *module, struct ldb_request *request)
+static int partition_request(struct ldb_module *module, struct ldb_request *request)
{
int ret;
switch (request->operation) {
PARTITION_FIND_OP(module, extended);
ret = module->ops->extended(module, request);
break;
- case LDB_SEQUENCE_NUMBER:
- PARTITION_FIND_OP(module, sequence_number);
- ret = module->ops->sequence_number(module, request);
- break;
default:
PARTITION_FIND_OP(module, request);
ret = module->ops->request(module, request);
if (ret == LDB_SUCCESS) {
return ret;
}
- if (!ldb_errstring(module->ldb)) {
+ if (!ldb_errstring(ldb_module_get_ctx(module))) {
/* Set a default error string, to place the blame somewhere */
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"error in module %s: %s (%d)",
module->ops->name,
ldb_strerror(ret), ret);
/* Look at base DN */
/* Figure out which partition it is under */
- /* Skip the lot if 'data' isn't here yet (initialistion) */
+ /* Skip the lot if 'data' isn't here yet (initialisation) */
for (i=0; data && data->partitions && data->partitions[i]; i++) {
if (ldb_dn_compare_base(data->partitions[i]->dn, dn) == 0) {
return data->partitions[i];
}
return NULL;
-};
+}
/**
* fire the caller's callback for every entry, but only send 'done' once.
case LDB_REPLY_ENTRY:
if (ac->req->operation != LDB_SEARCH) {
- ldb_set_errstring(ac->module->ldb,
+ ldb_set_errstring(ldb_module_get_ctx(ac->module),
"partition_req_callback:"
" Unsupported reply type for this request");
return ldb_module_done(ac->req, NULL, NULL,
LDB_ERR_OPERATIONS_ERROR);
}
- return ldb_module_send_entry(ac->req, ares->message);
+ return ldb_module_send_entry(ac->req, ares->message, ares->controls);
case LDB_REPLY_DONE:
if (ares->error == LDB_SUCCESS) {
/* FIXME: check for ares->response, replmd does not fill it ! */
if (ares->response) {
if (strcmp(ares->response->oid, LDB_EXTENDED_START_TLS_OID) != 0) {
- ldb_set_errstring(ac->module->ldb,
+ ldb_set_errstring(ldb_module_get_ctx(ac->module),
"partition_req_callback:"
" Unknown extended reply, "
"only supports START_TLS");
struct part_request,
ac->num_requests + 1);
if (ac->part_req == NULL) {
- ldb_oom(ac->module->ldb);
+ ldb_oom(ldb_module_get_ctx(ac->module));
return LDB_ERR_OPERATIONS_ERROR;
}
switch (ac->req->operation) {
case LDB_SEARCH:
- ret = ldb_build_search_req_ex(&req, ac->module->ldb,
+ ret = ldb_build_search_req_ex(&req, ldb_module_get_ctx(ac->module),
ac->part_req,
ac->req->op.search.base,
ac->req->op.search.scope,
ac->req);
break;
case LDB_ADD:
- ret = ldb_build_add_req(&req, ac->module->ldb, ac->part_req,
+ ret = ldb_build_add_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->op.add.message,
ac->req->controls,
ac, partition_req_callback,
ac->req);
break;
case LDB_MODIFY:
- ret = ldb_build_mod_req(&req, ac->module->ldb, ac->part_req,
+ ret = ldb_build_mod_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->op.mod.message,
ac->req->controls,
ac, partition_req_callback,
ac->req);
break;
case LDB_DELETE:
- ret = ldb_build_del_req(&req, ac->module->ldb, ac->part_req,
+ ret = ldb_build_del_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->op.del.dn,
ac->req->controls,
ac, partition_req_callback,
ac->req);
break;
case LDB_RENAME:
- ret = ldb_build_rename_req(&req, ac->module->ldb, ac->part_req,
+ ret = ldb_build_rename_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->op.rename.olddn,
ac->req->op.rename.newdn,
ac->req->controls,
ac->req);
break;
case LDB_EXTENDED:
- ret = ldb_build_extended_req(&req, ac->module->ldb,
+ ret = ldb_build_extended_req(&req, ldb_module_get_ctx(ac->module),
ac->part_req,
ac->req->op.extended.oid,
ac->req->op.extended.data,
ac->req);
break;
default:
- ldb_set_errstring(ac->module->ldb,
+ ldb_set_errstring(ldb_module_get_ctx(ac->module),
"Unsupported request type!");
ret = LDB_ERR_UNWILLING_TO_PERFORM;
}
req->controls = talloc_memdup(req, ac->req->controls,
talloc_get_size(ac->req->controls));
if (req->controls == NULL) {
- ldb_oom(ac->module->ldb);
+ ldb_oom(ldb_module_get_ctx(ac->module));
return LDB_ERR_OPERATIONS_ERROR;
}
}
/* Remove the domain_scope control, so we don't confuse a backend server */
if (domain_scope_control && !save_controls(domain_scope_control, req, &saved_controls)) {
- ldb_oom(module->ldb);
+ ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
/* Remove search control, so we don't confuse a backend server */
if (search_control && !save_controls(search_control, req, &saved_controls)) {
- ldb_oom(module->ldb);
+ ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
}
/* Remove search control, so we don't confuse a backend server */
if (search_control && !save_controls(search_control, req, &saved_controls)) {
- ldb_oom(module->ldb);
+ ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
}
struct partition_private_data *data = talloc_get_type(module->private_data,
struct partition_private_data);
- /* Skip the lot if 'data' isn't here yet (initialization) */
+ /* Skip the lot if 'data' isn't here yet (initialisation) */
if (!data) {
return LDB_ERR_OPERATIONS_ERROR;
}
}
if (backend != backend2) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"Cannot rename from %s in %s to %s in %s: %s",
ldb_dn_get_linearized(req->op.rename.olddn),
ldb_dn_get_linearized(backend->dn),
/* end a transaction */
static int partition_end_trans(struct ldb_module *module)
{
- int i, ret;
+ int i, ret, final_ret;
struct partition_private_data *data = talloc_get_type(module->private_data,
struct partition_private_data);
ret = ldb_next_end_trans(module);
return ret;
}
+ /* if the backend has a prepare_commit op then use that, to ensure
+ that all partitions are committed safely together */
+ for (i=0; data && data->partitions && data->partitions[i]; i++) {
+ struct ldb_module *next_end = data->partitions[i]->module;
+ struct ldb_module *next_prepare = data->partitions[i]->module;
+ struct ldb_module *next_del = data->partitions[i]->module;
+
+ PARTITION_FIND_OP_NOERROR(next_prepare, prepare_commit);
+ if (next_prepare == NULL) {
+ continue;
+ }
+
+ PARTITION_FIND_OP(next_end, end_transaction);
+ PARTITION_FIND_OP(next_del, del_transaction);
+
+ if (next_end != next_prepare || next_del != next_end) {
+ ldb_asprintf_errstring(ldb_module_get_ctx(module), "ERROR: Mismatch between prepare and commit ops in ldb module");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = next_prepare->ops->prepare_commit(next_prepare);
+ if (ret != LDB_SUCCESS) {
+ /* if one fails, cancel all but this one */
+ int j;
+ for (j=0; data->partitions[j]; j++) {
+ if (j == i) continue;
+ next_del = data->partitions[j]->module;
+ PARTITION_FIND_OP(next_del, del_transaction);
+ next_del->ops->del_transaction(next_del);
+ }
+ ldb_next_del_trans(module);
+ return ret;
+ }
+ }
+
/* Look at base DN */
/* Figure out which partition it is under */
- /* Skip the lot if 'data' isn't here yet (initialistion) */
+ /* Skip the lot if 'data' isn't here yet (initialisation) */
+ final_ret = LDB_SUCCESS;
+
for (i=0; data && data->partitions && data->partitions[i]; i++) {
struct ldb_module *next = data->partitions[i]->module;
PARTITION_FIND_OP(next, end_transaction);
ret = next->ops->end_transaction(next);
if (ret != LDB_SUCCESS) {
- /* Back it out, if it fails on one */
- for (i--; i >= 0; i--) {
- next = data->partitions[i]->module;
- PARTITION_FIND_OP(next, del_transaction);
-
- next->ops->del_transaction(next);
- }
- ldb_next_del_trans(module);
- return ret;
+ /* this should only be happening if we had a serious
+ OS or hardware error */
+ ldb_asprintf_errstring(ldb_module_get_ctx(module), "ERROR: partition commit error");
+ final_ret = ret;
}
}
- return LDB_SUCCESS;
+ return final_ret;
}
/* delete a transaction */
return ret2;
}
-/* NOTE: ldb_sequence_number is still a completely SYNCHRONOUS call
- * implemented only in ldb_rdb. It does not require ldb_wait() to be
- * called after a request is made */
+
+/* FIXME: This function is still semi-async */
static int partition_sequence_number(struct ldb_module *module, struct ldb_request *req)
{
int i, ret;
uint64_t timestamp = 0;
struct partition_private_data *data = talloc_get_type(module->private_data,
struct partition_private_data);
+ struct ldb_seqnum_request *seq;
+ struct ldb_seqnum_result *seqr;
+ struct ldb_request *treq;
+ struct ldb_seqnum_request *tseq;
+ struct ldb_seqnum_result *tseqr;
+ struct ldb_extended *ext;
+ struct ldb_result *res;
+
+ seq = talloc_get_type(req->op.extended.data, struct ldb_seqnum_request);
- switch (req->op.seq_num.type) {
+ switch (seq->type) {
case LDB_SEQ_NEXT:
case LDB_SEQ_HIGHEST_SEQ:
- ret = ldb_next_request(module, req);
- if (ret != LDB_SUCCESS) {
- return ret;
+ res = talloc_zero(req, struct ldb_result);
+ if (res == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- if (req->op.seq_num.flags & LDB_SEQ_TIMESTAMP_SEQUENCE) {
- timestamp_sequence = req->op.seq_num.seq_num;
- } else {
- seq_number = seq_number + req->op.seq_num.seq_num;
+ tseq = talloc_zero(res, struct ldb_seqnum_request);
+ if (tseq == NULL) {
+ talloc_free(res);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ tseq->type = seq->type;
+
+ ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
+ LDB_EXTENDED_SEQUENCE_NUMBER,
+ tseq,
+ NULL,
+ res,
+ ldb_extended_default_callback,
+ NULL);
+ ret = ldb_next_request(module, treq);
+ if (ret == LDB_SUCCESS) {
+ ret = ldb_wait(treq->handle, LDB_WAIT_ALL);
}
-
- /* gross hack part1 */
- ret = ldb_request_add_control(req,
- DSDB_CONTROL_CURRENT_PARTITION_OID,
- false, NULL);
if (ret != LDB_SUCCESS) {
+ talloc_free(res);
return ret;
}
+ seqr = talloc_get_type(res->extended->data,
+ struct ldb_seqnum_result);
+ if (seqr->flags & LDB_SEQ_TIMESTAMP_SEQUENCE) {
+ timestamp_sequence = seqr->seq_num;
+ } else {
+ seq_number += seqr->seq_num;
+ }
+ talloc_free(res);
- /* Look at base DN */
- /* Figure out which partition it is under */
- /* Skip the lot if 'data' isn't here yet (initialistion) */
+ /* Skip the lot if 'data' isn't here yet (initialisation) */
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- /* gross hack part2 */
- int j;
- for (j=0; req->controls[j]; j++) {
- if (strcmp(req->controls[j]->oid, DSDB_CONTROL_CURRENT_PARTITION_OID) == 0) {
- req->controls[j]->data = data->partitions[i];
- break;
- }
+ res = talloc_zero(req, struct ldb_result);
+ if (res == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ tseq = talloc_zero(res, struct ldb_seqnum_request);
+ if (tseq == NULL) {
+ talloc_free(res);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ tseq->type = seq->type;
+
+ ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
+ LDB_EXTENDED_SEQUENCE_NUMBER,
+ tseq,
+ NULL,
+ res,
+ ldb_extended_default_callback,
+ NULL);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(res);
+ return ret;
+ }
+
+ ret = ldb_request_add_control(treq,
+ DSDB_CONTROL_CURRENT_PARTITION_OID,
+ false, data->partitions[i]);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(res);
+ return ret;
}
- ret = partition_request(data->partitions[i]->module, req);
+ ret = partition_request(data->partitions[i]->module, treq);
if (ret != LDB_SUCCESS) {
+ talloc_free(res);
return ret;
}
- if (req->op.seq_num.flags & LDB_SEQ_TIMESTAMP_SEQUENCE) {
- timestamp_sequence = MAX(timestamp_sequence, req->op.seq_num.seq_num);
+ ret = ldb_wait(treq->handle, LDB_WAIT_ALL);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(res);
+ return ret;
+ }
+ tseqr = talloc_get_type(res->extended->data,
+ struct ldb_seqnum_result);
+ if (tseqr->flags & LDB_SEQ_TIMESTAMP_SEQUENCE) {
+ timestamp_sequence = MAX(timestamp_sequence,
+ tseqr->seq_num);
} else {
- seq_number = seq_number + req->op.seq_num.seq_num;
+ seq_number += tseqr->seq_num;
}
+ talloc_free(res);
}
- /* fall though */
+ /* fall through */
case LDB_SEQ_HIGHEST_TIMESTAMP:
- {
- struct ldb_request *date_req = talloc(req, struct ldb_request);
- if (!date_req) {
+
+ res = talloc_zero(req, struct ldb_result);
+ if (res == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- *date_req = *req;
- date_req->op.seq_num.flags = LDB_SEQ_HIGHEST_TIMESTAMP;
- ret = ldb_next_request(module, date_req);
+ tseq = talloc_zero(res, struct ldb_seqnum_request);
+ if (tseq == NULL) {
+ talloc_free(res);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
+
+ ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
+ LDB_EXTENDED_SEQUENCE_NUMBER,
+ tseq,
+ NULL,
+ res,
+ ldb_extended_default_callback,
+ NULL);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(res);
+ return ret;
+ }
+
+ ret = ldb_next_request(module, treq);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(res);
+ return ret;
+ }
+ ret = ldb_wait(treq->handle, LDB_WAIT_ALL);
if (ret != LDB_SUCCESS) {
+ talloc_free(res);
return ret;
}
- timestamp = date_req->op.seq_num.seq_num;
- /* Look at base DN */
- /* Figure out which partition it is under */
- /* Skip the lot if 'data' isn't here yet (initialistion) */
+ tseqr = talloc_get_type(res->extended->data,
+ struct ldb_seqnum_result);
+ timestamp = tseqr->seq_num;
+
+ talloc_free(res);
+
+ /* Skip the lot if 'data' isn't here yet (initialisation) */
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- ret = partition_request(data->partitions[i]->module, req);
+ res = talloc_zero(req, struct ldb_result);
+ if (res == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ tseq = talloc_zero(res, struct ldb_seqnum_request);
+ if (tseq == NULL) {
+ talloc_free(res);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
+
+ ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
+ LDB_EXTENDED_SEQUENCE_NUMBER,
+ tseq,
+ NULL,
+ res,
+ ldb_extended_default_callback,
+ NULL);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(res);
+ return ret;
+ }
+
+ ret = ldb_request_add_control(treq,
+ DSDB_CONTROL_CURRENT_PARTITION_OID,
+ false, data->partitions[i]);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(res);
+ return ret;
+ }
+
+ ret = partition_request(data->partitions[i]->module, treq);
if (ret != LDB_SUCCESS) {
+ talloc_free(res);
return ret;
}
- timestamp = MAX(timestamp, date_req->op.seq_num.seq_num);
+ ret = ldb_wait(treq->handle, LDB_WAIT_ALL);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(res);
+ return ret;
+ }
+
+ tseqr = talloc_get_type(res->extended->data,
+ struct ldb_seqnum_result);
+ timestamp = MAX(timestamp, tseqr->seq_num);
+
+ talloc_free(res);
}
+
break;
}
+
+ ext = talloc_zero(req, struct ldb_extended);
+ if (!ext) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ seqr = talloc_zero(ext, struct ldb_seqnum_result);
+ if (seqr == NULL) {
+ talloc_free(ext);
+ return LDB_ERR_OPERATIONS_ERROR;
}
+ ext->oid = LDB_EXTENDED_SEQUENCE_NUMBER;
+ ext->data = seqr;
- switch (req->op.seq_num.flags) {
+ switch (seq->type) {
case LDB_SEQ_NEXT:
case LDB_SEQ_HIGHEST_SEQ:
- req->op.seq_num.flags = 0;
-
/* Has someone above set a timebase sequence? */
if (timestamp_sequence) {
- req->op.seq_num.seq_num = (((unsigned long long)timestamp << 24) | (seq_number & 0xFFFFFF));
+ seqr->seq_num = (((unsigned long long)timestamp << 24) | (seq_number & 0xFFFFFF));
} else {
- req->op.seq_num.seq_num = seq_number;
+ seqr->seq_num = seq_number;
}
- if (timestamp_sequence > req->op.seq_num.seq_num) {
- req->op.seq_num.seq_num = timestamp_sequence;
- req->op.seq_num.flags |= LDB_SEQ_TIMESTAMP_SEQUENCE;
+ if (timestamp_sequence > seqr->seq_num) {
+ seqr->seq_num = timestamp_sequence;
+ seqr->flags |= LDB_SEQ_TIMESTAMP_SEQUENCE;
}
- req->op.seq_num.flags |= LDB_SEQ_GLOBAL_SEQUENCE;
+ seqr->flags |= LDB_SEQ_GLOBAL_SEQUENCE;
break;
case LDB_SEQ_HIGHEST_TIMESTAMP:
- req->op.seq_num.seq_num = timestamp;
+ seqr->seq_num = timestamp;
break;
}
- switch (req->op.seq_num.flags) {
- case LDB_SEQ_NEXT:
- req->op.seq_num.seq_num++;
+ if (seq->type == LDB_SEQ_NEXT) {
+ seqr->seq_num++;
}
- return LDB_SUCCESS;
+
+ /* send request done */
+ return ldb_module_done(req, NULL, ext, LDB_SUCCESS);
}
static int partition_extended_replicated_objects(struct ldb_module *module, struct ldb_request *req)
ext = talloc_get_type(req->op.extended.data, struct dsdb_extended_replicated_objects);
if (!ext) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended_replicated_objects: invalid extended data\n");
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_FATAL, "partition_extended_replicated_objects: invalid extended data\n");
return LDB_ERR_PROTOCOL_ERROR;
}
if (ext->version != DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended_replicated_objects: extended data invalid version [%u != %u]\n",
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_FATAL, "partition_extended_replicated_objects: extended data invalid version [%u != %u]\n",
ext->version, DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION);
return LDB_ERR_PROTOCOL_ERROR;
}
schema_dn = talloc_get_type(req->op.extended.data, struct ldb_dn);
if (!schema_dn) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended: invalid extended data\n");
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_FATAL, "partition_extended: invalid extended data\n");
return LDB_ERR_PROTOCOL_ERROR;
}
return ldb_next_request(module, req);
}
+ if (strcmp(req->op.extended.oid, LDB_EXTENDED_SEQUENCE_NUMBER) == 0) {
+ return partition_sequence_number(module, req);
+ }
+
if (strcmp(req->op.extended.oid, DSDB_EXTENDED_REPLICATED_OBJECTS_OID) == 0) {
return partition_extended_replicated_objects(module, req);
}
static int partition_sort_compare(const void *v1, const void *v2)
{
- struct dsdb_control_current_partition *p1;
- struct dsdb_control_current_partition *p2;
+ const struct dsdb_control_current_partition *p1;
+ const struct dsdb_control_current_partition *p2;
- p1 = *((struct dsdb_control_current_partition **)v1);
- p2 = *((struct dsdb_control_current_partition **)v2);
+ p1 = *((struct dsdb_control_current_partition * const*)v1);
+ p2 = *((struct dsdb_control_current_partition * const*)v2);
return ldb_dn_compare(p1->dn, p2->dn);
}
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_search(module->ldb, mem_ctx, &res,
- ldb_dn_new(mem_ctx, module->ldb, "@PARTITION"),
+ ret = ldb_search(ldb_module_get_ctx(module), mem_ctx, &res,
+ ldb_dn_new(mem_ctx, ldb_module_get_ctx(module), "@PARTITION"),
LDB_SCOPE_BASE, attrs, NULL);
if (ret != LDB_SUCCESS) {
talloc_free(mem_ctx);
partition_attributes = ldb_msg_find_element(msg, "partition");
if (!partition_attributes) {
- ldb_set_errstring(module->ldb, "partition_init: no partitions specified");
+ ldb_set_errstring(ldb_module_get_ctx(module), "partition_init: no partitions specified");
talloc_free(mem_ctx);
return LDB_ERR_CONSTRAINT_VIOLATION;
}
char *base = talloc_strdup(data->partitions, (char *)partition_attributes->values[i].data);
char *p = strchr(base, ':');
if (!p) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition record (missing ':'): %s", base);
talloc_free(mem_ctx);
p[0] = '\0';
p++;
if (!p[0]) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition record (missing backend database): %s", base);
talloc_free(mem_ctx);
}
data->partitions[i]->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
- data->partitions[i]->dn = ldb_dn_new(data->partitions[i], module->ldb, base);
+ data->partitions[i]->dn = ldb_dn_new(data->partitions[i], ldb_module_get_ctx(module), base);
if (!data->partitions[i]->dn) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: invalid DN in partition record: %s", base);
talloc_free(mem_ctx);
return LDB_ERR_CONSTRAINT_VIOLATION;
}
- data->partitions[i]->backend = samdb_relative_path(module->ldb,
+ data->partitions[i]->backend = samdb_relative_path(ldb_module_get_ctx(module),
data->partitions[i],
p);
if (!data->partitions[i]->backend) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: unable to determine an relative path for partition: %s", base);
talloc_free(mem_ctx);
}
- ret = ldb_connect_backend(module->ldb, data->partitions[i]->backend, NULL, &data->partitions[i]->module);
+ ret = ldb_connect_backend(ldb_module_get_ctx(module), data->partitions[i]->backend, NULL, &data->partitions[i]->module);
if (ret != LDB_SUCCESS) {
talloc_free(mem_ctx);
return ret;
struct ldb_request *req;
req = talloc_zero(mem_ctx, struct ldb_request);
if (req == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "partition: Out of memory!\n");
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR, "partition: Out of memory!\n");
talloc_free(mem_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
req->op.reg_partition.dn = data->partitions[i]->dn;
req->callback = ldb_op_default_callback;
- ldb_set_timeout(module->ldb, req, 0);
+ ldb_set_timeout(ldb_module_get_ctx(module), req, 0);
- req->handle = ldb_handle_new(req, module->ldb);
+ req->handle = ldb_handle_new(req, ldb_module_get_ctx(module));
if (req->handle == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_request(module->ldb, req);
+ ret = ldb_request(ldb_module_get_ctx(module), req);
if (ret == LDB_SUCCESS) {
ret = ldb_wait(req->handle, LDB_WAIT_ALL);
}
if (ret != LDB_SUCCESS) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "partition: Unable to register partition with rootdse!\n");
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR, "partition: Unable to register partition with rootdse!\n");
talloc_free(mem_ctx);
return LDB_ERR_OTHER;
}
}
for (i=0; i < replicate_attributes->num_values; i++) {
- data->replicate[i] = ldb_dn_from_ldb_val(data->replicate, module->ldb, &replicate_attributes->values[i]);
+ data->replicate[i] = ldb_dn_from_ldb_val(data->replicate, ldb_module_get_ctx(module), &replicate_attributes->values[i]);
if (!ldb_dn_validate(data->replicate[i])) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid DN in partition replicate record: %s",
replicate_attributes->values[i].data);
char *base = talloc_strdup(data->partitions, (char *)modules_attributes->values[i].data);
char *p = strchr(base, ':');
if (!p) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition module record (missing ':'): %s", base);
talloc_free(mem_ctx);
p[0] = '\0';
p++;
if (!p[0]) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition module record (missing backend database): %s", base);
talloc_free(mem_ctx);
return LDB_ERR_CONSTRAINT_VIOLATION;
}
- modules = ldb_modules_list_from_string(module->ldb, mem_ctx,
+ modules = ldb_modules_list_from_string(ldb_module_get_ctx(module), mem_ctx,
p);
- base_dn = ldb_dn_new(mem_ctx, module->ldb, base);
+ base_dn = ldb_dn_new(mem_ctx, ldb_module_get_ctx(module), base);
if (!ldb_dn_validate(base_dn)) {
talloc_free(mem_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
if (!partition) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition module record (no such partition): %s", base);
talloc_free(mem_ctx);
return LDB_ERR_CONSTRAINT_VIOLATION;
}
- ret = ldb_load_modules_list(module->ldb, modules, partition->module, &partition->module);
+ ret = ldb_load_modules_list(ldb_module_get_ctx(module), modules, partition->module, &partition->module);
if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"loading backend for %s failed: %s",
- base, ldb_errstring(module->ldb));
+ base, ldb_errstring(ldb_module_get_ctx(module)));
talloc_free(mem_ctx);
return ret;
}
- ret = ldb_init_module_chain(module->ldb, partition->module);
+ ret = ldb_init_module_chain(ldb_module_get_ctx(module), partition->module);
if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(module->ldb,
+ ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"initialising backend for %s failed: %s",
- base, ldb_errstring(module->ldb));
+ base, ldb_errstring(ldb_module_get_ctx(module)));
talloc_free(mem_ctx);
return ret;
}
ret = ldb_mod_register_control(module, LDB_CONTROL_DOMAIN_SCOPE_OID);
if (ret != LDB_SUCCESS) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
"partition: Unable to register control with rootdse!\n");
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_mod_register_control(module, LDB_CONTROL_SEARCH_OPTIONS_OID);
if (ret != LDB_SUCCESS) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
"partition: Unable to register control with rootdse!\n");
return LDB_ERR_OPERATIONS_ERROR;
}
.del = partition_delete,
.rename = partition_rename,
.extended = partition_extended,
- .sequence_number = partition_sequence_number,
.start_transaction = partition_start_trans,
.end_transaction = partition_end_trans,
.del_transaction = partition_del_trans,
git.samba.org / metze / samba / wip.git / blobdiff