struct ldb_request *req;
struct part_request *part_req;
- int num_requests;
- int finished_requests;
+ unsigned int num_requests;
+ unsigned int finished_requests;
+
+ const char **referrals;
};
static struct partition_context *partition_init_ctx(struct ldb_module *module, struct ldb_request *req)
}
/*
- * helper functions to call the next module in chain
- * */
-
+ * helper functions to call the next module in chain
+ */
int partition_request(struct ldb_module *module, struct ldb_request *request)
{
- if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) { \
+ if ((module && ldb_module_flags(ldb_module_get_ctx(module)) & LDB_FLG_ENABLE_TRACING)) { \
const struct dsdb_control_current_partition *partition = NULL;
struct ldb_control *partition_ctrl = ldb_request_get_control(request, DSDB_CONTROL_CURRENT_PARTITION_OID);
if (partition_ctrl) {
}
if (partition != NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_request() -> %s",
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_request() -> %s",
ldb_dn_get_linearized(partition->dn));
} else {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_request() -> (metadata partition)");
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_request() -> (metadata partition)");
}
}
struct ldb_dn *dn,
struct ldb_request *req)
{
- int i;
+ unsigned int i;
struct ldb_control *partition_ctrl;
/* see if the request has the partition DN specified in a
struct ldb_control *partition_ctrl;
ac = talloc_get_type(req->context, struct partition_context);
- data = talloc_get_type(ac->module->private_data, struct partition_private_data);
+ data = talloc_get_type(ldb_module_get_private(ac->module), struct partition_private_data);
if (!ares) {
return ldb_module_done(ac->req, NULL, NULL,
* or this is an individual search result, we can
* deterministily tell the caller what partition this was
* written to (repl_meta_data likes to know) */
- ret = ldb_reply_add_control(ares,
- DSDB_CONTROL_CURRENT_PARTITION_OID,
- false, partition_ctrl->data);
- if (ret != LDB_SUCCESS) {
- return ldb_module_done(ac->req, NULL, NULL,
- ret);
- }
+ ret = ldb_reply_add_control(ares,
+ DSDB_CONTROL_CURRENT_PARTITION_OID,
+ false, partition_ctrl->data);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ ret);
+ }
}
if (ares->error != LDB_SUCCESS) {
switch (ares->type) {
case LDB_REPLY_REFERRAL:
- /* ignore referrals for now */
- break;
+ return ldb_module_send_referral(ac->req, ares->referral);
case LDB_REPLY_ENTRY:
if (ac->req->operation != LDB_SEARCH) {
ac->finished_requests++;
if (ac->finished_requests == ac->num_requests) {
+ /* Send back referrals if they do exist (search ops) */
+ if (ac->referrals != NULL) {
+ const char **ref;
+ for (ref = ac->referrals; *ref != NULL; ++ref) {
+ ret = ldb_module_send_referral(ac->req,
+ talloc_strdup(ac->req, *ref));
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ ret);
+ }
+ }
+ }
+
/* this was the last one, call callback */
return ldb_module_done(ac->req, ares->controls,
ares->response,
struct part_request,
ac->num_requests + 1);
if (ac->part_req == NULL) {
- ldb_oom(ldb_module_get_ctx(ac->module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(ac->module));
}
switch (ac->req->operation) {
ac->req->controls,
ac, partition_req_callback,
ac->req);
+ LDB_REQ_SET_LOCATION(req);
break;
case LDB_ADD:
ret = ldb_build_add_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->controls,
ac, partition_req_callback,
ac->req);
+ LDB_REQ_SET_LOCATION(req);
break;
case LDB_MODIFY:
ret = ldb_build_mod_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->controls,
ac, partition_req_callback,
ac->req);
+ LDB_REQ_SET_LOCATION(req);
break;
case LDB_DELETE:
ret = ldb_build_del_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->controls,
ac, partition_req_callback,
ac->req);
+ LDB_REQ_SET_LOCATION(req);
break;
case LDB_RENAME:
ret = ldb_build_rename_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->controls,
ac, partition_req_callback,
ac->req);
+ LDB_REQ_SET_LOCATION(req);
break;
case LDB_EXTENDED:
ret = ldb_build_extended_req(&req, ldb_module_get_ctx(ac->module),
ac->req->controls,
ac, partition_req_callback,
ac->req);
+ LDB_REQ_SET_LOCATION(req);
break;
default:
ldb_set_errstring(ldb_module_get_ctx(ac->module),
req->controls = talloc_memdup(req, ac->req->controls,
talloc_get_size(ac->req->controls));
if (req->controls == NULL) {
- ldb_oom(ldb_module_get_ctx(ac->module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(ac->module));
}
}
struct partition_context *ac,
struct ldb_request *req)
{
- int i;
- struct partition_private_data *data = talloc_get_type(module->private_data,
+ unsigned int i;
+ struct partition_private_data *data = talloc_get_type(ldb_module_get_private(module),
struct partition_private_data);
int ret = partition_prep_request(ac, NULL);
if (ret != LDB_SUCCESS) {
static int partition_replicate(struct ldb_module *module, struct ldb_request *req, struct ldb_dn *dn)
{
struct partition_context *ac;
- unsigned i;
+ unsigned int i;
int ret;
struct dsdb_partition *partition;
- struct partition_private_data *data = talloc_get_type(module->private_data,
+ struct partition_private_data *data = talloc_get_type(ldb_module_get_private(module),
struct partition_private_data);
if (!data || !data->partitions) {
return ldb_next_request(module, req);
ac = partition_init_ctx(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
return partition_send_all(module, ac, req);
ac = partition_init_ctx(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
/* we need to add a control but we never touch the original request */
/* search */
static int partition_search(struct ldb_module *module, struct ldb_request *req)
{
- int ret;
struct ldb_control **saved_controls;
/* Find backend */
- struct partition_private_data *data = talloc_get_type(module->private_data,
+ struct partition_private_data *data = talloc_get_type(ldb_module_get_private(module),
struct partition_private_data);
-
- /* issue request */
-
- /* (later) consider if we should be searching multiple
- * partitions (for 'invisible' partition behaviour */
+ struct partition_context *ac;
+ struct ldb_context *ldb;
+ struct loadparm_context *lp_ctx;
struct ldb_control *search_control = ldb_request_get_control(req, LDB_CONTROL_SEARCH_OPTIONS_OID);
struct ldb_control *domain_scope_control = ldb_request_get_control(req, LDB_CONTROL_DOMAIN_SCOPE_OID);
struct ldb_search_options_control *search_options = NULL;
struct dsdb_partition *p;
+ unsigned int i, j;
+ int ret;
+ bool domain_scope = false, phantom_root = false;
- ret = partition_reload_if_required(module, data);
+ ret = partition_reload_if_required(module, data, req);
if (ret != LDB_SUCCESS) {
return ret;
}
/* the caller specified what partition they want the
* search - just pass it on
*/
- return ldb_next_request(p->module, req);
+ return ldb_next_request(p->module, req);
}
-
+ /* Get back the search options from the search control, and mark it as
+ * non-critical (to make backends and also dcpromo happy).
+ */
if (search_control) {
search_options = talloc_get_type(search_control->data, struct ldb_search_options_control);
+ search_control->critical = 0;
+
}
- /* 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(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ /* Remove the "domain_scope" control, so we don't confuse a backend
+ * server */
+ if (domain_scope_control && !ldb_save_controls(domain_scope_control, req, &saved_controls)) {
+ return ldb_oom(ldb_module_get_ctx(module));
}
- /*
- * for now pass down the LDB_CONTROL_SEARCH_OPTIONS_OID control
- * down as uncritical to make windows 2008 dcpromo happy.
- */
- if (search_control) {
- search_control->critical = 0;
+ /* Locate the options */
+ domain_scope = (search_options
+ && (search_options->search_options & LDB_SEARCH_OPTION_DOMAIN_SCOPE))
+ || domain_scope_control;
+ phantom_root = search_options
+ && (search_options->search_options & LDB_SEARCH_OPTION_PHANTOM_ROOT);
+
+ /* Remove handled options from the search control flag */
+ if (search_options) {
+ search_options->search_options = search_options->search_options
+ & ~LDB_SEARCH_OPTION_DOMAIN_SCOPE
+ & ~LDB_SEARCH_OPTION_PHANTOM_ROOT;
}
- /* TODO:
- Generate referrals (look for a partition under this DN) if we don't have the above control specified
- */
-
- if (search_options && (search_options->search_options & LDB_SEARCH_OPTION_PHANTOM_ROOT)) {
- int i;
- struct partition_context *ac;
- if ((search_options->search_options & ~LDB_SEARCH_OPTION_PHANTOM_ROOT) == 0) {
- /* We have processed this flag, so we are done with this control now */
-
- /* Remove search control, so we don't confuse a backend server */
- if (search_control && !save_controls(search_control, req, &saved_controls)) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
- }
- }
- ac = partition_init_ctx(module, req);
- if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ if (!data || !data->partitions) {
+ return ldb_next_request(module, req);
+ }
- /* Search from the base DN */
- if (!req->op.search.base || ldb_dn_is_null(req->op.search.base)) {
- return partition_send_all(module, ac, req);
- }
- for (i=0; data && data->partitions && data->partitions[i]; i++) {
- bool match = false, stop = false;
- /* Find all partitions under the search base
-
- we match if:
-
- 1) the DN we are looking for exactly matches the partition
- or
- 2) the DN we are looking for is a parent of the partition and it isn't
- a scope base search
- or
- 3) the DN we are looking for is a child of the partition
+ ac = partition_init_ctx(module, req);
+ if (!ac) {
+ return ldb_operr(ldb_module_get_ctx(module));
+ }
+
+ ldb = ldb_module_get_ctx(ac->module);
+ lp_ctx = talloc_get_type(ldb_get_opaque(ldb, "loadparm"),
+ struct loadparm_context);
+
+ /* Search from the base DN */
+ if (ldb_dn_is_null(req->op.search.base)) {
+ return partition_send_all(module, ac, req);
+ }
+
+ for (i=0; data->partitions[i]; i++) {
+ bool match = false, stop = false;
+
+ if (phantom_root) {
+ /* Phantom root: Find all partitions under the
+ * search base. We match if:
+ *
+ * 1) the DN we are looking for exactly matches a
+ * certain partition and always stop
+ * 2) the DN we are looking for is a parent of certain
+ * partitions and it isn't a scope base search
+ * 3) the DN we are looking for is a child of a certain
+ * partition and always stop
+ * - we don't need to go any further up in the
+ * hierarchy!
*/
- if (ldb_dn_compare(data->partitions[i]->ctrl->dn, req->op.search.base) == 0) {
+ if (ldb_dn_compare(data->partitions[i]->ctrl->dn,
+ req->op.search.base) == 0) {
match = true;
stop = true;
}
- if (!match &&
- (ldb_dn_compare_base(req->op.search.base, data->partitions[i]->ctrl->dn) == 0 &&
+ if (!match &&
+ (ldb_dn_compare_base(req->op.search.base,
+ data->partitions[i]->ctrl->dn) == 0 &&
req->op.search.scope != LDB_SCOPE_BASE)) {
match = true;
}
if (!match &&
- ldb_dn_compare_base(data->partitions[i]->ctrl->dn, req->op.search.base) == 0) {
+ ldb_dn_compare_base(data->partitions[i]->ctrl->dn,
+ req->op.search.base) == 0) {
match = true;
stop = true; /* note that this relies on partition ordering */
}
- if (match) {
- ret = partition_prep_request(ac, data->partitions[i]);
- if (ret != LDB_SUCCESS) {
- return ret;
+ } else {
+ /* Domain scope: Find all partitions under the search
+ * base.
+ *
+ * We generate referral candidates if we haven't
+ * specified the domain scope control, haven't a base
+ * search* scope and the DN we are looking for is a real
+ * predecessor of certain partitions. When a new
+ * referral candidate is nearer to the DN than an
+ * existing one delete the latter (we want to have only
+ * the closest ones). When we checked this for all
+ * candidates we have the final referrals.
+ *
+ * We match if the DN we are looking for is a child of
+ * a certain partition or the partition
+ * DN itself - we don't need to go any further
+ * up in the hierarchy!
+ */
+ if ((!domain_scope) &&
+ (req->op.search.scope != LDB_SCOPE_BASE) &&
+ (ldb_dn_compare_base(req->op.search.base,
+ data->partitions[i]->ctrl->dn) == 0) &&
+ (ldb_dn_compare(req->op.search.base,
+ data->partitions[i]->ctrl->dn) != 0)) {
+ char *ref = talloc_asprintf(ac,
+ "ldap://%s/%s%s",
+ lpcfg_dnsdomain(lp_ctx),
+ ldb_dn_get_linearized(data->partitions[i]->ctrl->dn),
+ req->op.search.scope == LDB_SCOPE_ONELEVEL ? "??base" : "");
+
+ if (ref == NULL) {
+ return ldb_oom(ldb);
}
- }
- if (stop) break;
- }
- /* Perhaps we didn't match any partitions. Try the main partition, only */
- if (ac->num_requests == 0) {
- talloc_free(ac);
- return ldb_next_request(module, req);
- }
+ /* Initialise the referrals list */
+ if (ac->referrals == NULL) {
+ ac->referrals = (const char **) str_list_make_empty(ac);
+ if (ac->referrals == NULL) {
+ return ldb_oom(ldb);
+ }
+ }
- /* fire the first one */
- return partition_call_first(ac);
+ /* Check if the new referral candidate is
+ * closer to the base DN than already
+ * saved ones and delete the latters */
+ j = 0;
+ while (ac->referrals[j] != NULL) {
+ if (strstr(ac->referrals[j],
+ ldb_dn_get_linearized(data->partitions[i]->ctrl->dn)) != NULL) {
+ str_list_remove(ac->referrals,
+ ac->referrals[j]);
+ } else {
+ ++j;
+ }
+ }
- } else {
- /* Handle this like all other requests */
- if (search_control && (search_options->search_options & ~LDB_SEARCH_OPTION_PHANTOM_ROOT) == 0) {
- /* We have processed this flag, so we are done with this control now */
-
- /* Remove search control, so we don't confuse a backend server */
- if (search_control && !save_controls(search_control, req, &saved_controls)) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ /* Add our new candidate */
+ ac->referrals = str_list_add(ac->referrals, ref);
+
+ talloc_free(ref);
+
+ if (ac->referrals == NULL) {
+ return ldb_oom(ldb);
+ }
+ }
+ if (ldb_dn_compare_base(data->partitions[i]->ctrl->dn, req->op.search.base) == 0) {
+ match = true;
+ stop = true; /* note that this relies on partition ordering */
}
}
- return partition_replicate(module, req, req->op.search.base);
+ if (match) {
+ ret = partition_prep_request(ac, data->partitions[i]);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ }
+
+ if (stop) break;
+ }
+
+ /* Perhaps we didn't match any partitions. Try the main partition */
+ if (ac->num_requests == 0) {
+ talloc_free(ac);
+ return ldb_next_request(module, req);
}
+
+ /* fire the first one */
+ return partition_call_first(ac);
}
/* add */
/* Find backend */
struct dsdb_partition *backend, *backend2;
- struct partition_private_data *data = talloc_get_type(module->private_data,
+ struct partition_private_data *data = talloc_get_type(ldb_module_get_private(module),
struct partition_private_data);
/* Skip the lot if 'data' isn't here yet (initialisation) */
if (!data) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
backend = find_partition(data, req->op.rename.olddn, req);
/* start a transaction */
static int partition_start_trans(struct ldb_module *module)
{
- int i, ret;
- struct partition_private_data *data = talloc_get_type(module->private_data,
+ unsigned int i;
+ int ret;
+ struct partition_private_data *data = talloc_get_type(ldb_module_get_private(module),
struct partition_private_data);
/* Look at base DN */
/* Figure out which partition it is under */
/* Skip the lot if 'data' isn't here yet (initialization) */
- if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_start_trans() -> (metadata partition)");
+ if ((module && ldb_module_flags(ldb_module_get_ctx(module)) & LDB_FLG_ENABLE_TRACING)) {
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_start_trans() -> (metadata partition)");
}
ret = ldb_next_start_trans(module);
if (ret != LDB_SUCCESS) {
return ret;
}
- ret = partition_reload_if_required(module, data);
+ ret = partition_reload_if_required(module, data, NULL);
if (ret != LDB_SUCCESS) {
return ret;
}
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_start_trans() -> %s",
+ if ((module && ldb_module_flags(ldb_module_get_ctx(module)) & LDB_FLG_ENABLE_TRACING)) {
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_start_trans() -> %s",
ldb_dn_get_linearized(data->partitions[i]->ctrl->dn));
}
ret = ldb_next_start_trans(data->partitions[i]->module);
/* prepare for a commit */
static int partition_prepare_commit(struct ldb_module *module)
{
- int i;
- struct partition_private_data *data = talloc_get_type(module->private_data,
+ unsigned int i;
+ struct partition_private_data *data = talloc_get_type(ldb_module_get_private(module),
struct partition_private_data);
for (i=0; data && data->partitions && data->partitions[i]; i++) {
int ret;
- if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_prepare_commit() -> %s",
+ if ((module && ldb_module_flags(ldb_module_get_ctx(module)) & LDB_FLG_ENABLE_TRACING)) {
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_prepare_commit() -> %s",
ldb_dn_get_linearized(data->partitions[i]->ctrl->dn));
}
ret = ldb_next_prepare_commit(data->partitions[i]->module);
if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(module->ldb, "prepare_commit error on %s: %s", ldb_dn_get_linearized(data->partitions[i]->ctrl->dn), ldb_errstring(module->ldb));
+ ldb_asprintf_errstring(ldb_module_get_ctx(module), "prepare_commit error on %s: %s",
+ ldb_dn_get_linearized(data->partitions[i]->ctrl->dn),
+ ldb_errstring(ldb_module_get_ctx(module)));
return ret;
}
}
- if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_prepare_commit() -> (metadata partition)");
+ if ((module && ldb_module_flags(ldb_module_get_ctx(module)) & LDB_FLG_ENABLE_TRACING)) {
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_prepare_commit() -> (metadata partition)");
}
return ldb_next_prepare_commit(module);
}
/* end a transaction */
static int partition_end_trans(struct ldb_module *module)
{
- int i, ret, ret2;
- struct partition_private_data *data = talloc_get_type(module->private_data,
+ int ret, ret2;
+ unsigned int i;
+ struct partition_private_data *data = talloc_get_type(ldb_module_get_private(module),
struct partition_private_data);
ret = LDB_SUCCESS;
}
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_end_trans() -> %s",
+ if ((module && ldb_module_flags(ldb_module_get_ctx(module)) & LDB_FLG_ENABLE_TRACING)) {
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_end_trans() -> %s",
ldb_dn_get_linearized(data->partitions[i]->ctrl->dn));
}
ret2 = ldb_next_end_trans(data->partitions[i]->module);
if (ret2 != LDB_SUCCESS) {
- ldb_asprintf_errstring(module->ldb, "end_trans error on %s: %s", ldb_dn_get_linearized(data->partitions[i]->ctrl->dn), ldb_errstring(module->ldb));
+ ldb_asprintf_errstring(ldb_module_get_ctx(module), "end_trans error on %s: %s",
+ ldb_dn_get_linearized(data->partitions[i]->ctrl->dn),
+ ldb_errstring(ldb_module_get_ctx(module)));
ret = ret2;
}
}
- if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_end_trans() -> (metadata partition)");
+ if ((module && ldb_module_flags(ldb_module_get_ctx(module)) & LDB_FLG_ENABLE_TRACING)) {
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_end_trans() -> (metadata partition)");
}
ret2 = ldb_next_end_trans(module);
if (ret2 != LDB_SUCCESS) {
/* delete a transaction */
static int partition_del_trans(struct ldb_module *module)
{
- int i, ret, final_ret = LDB_SUCCESS;
- struct partition_private_data *data = talloc_get_type(module->private_data,
+ int ret, final_ret = LDB_SUCCESS;
+ unsigned int i;
+ struct partition_private_data *data = talloc_get_type(ldb_module_get_private(module),
struct partition_private_data);
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_del_trans() -> %s",
+ if ((module && ldb_module_flags(ldb_module_get_ctx(module)) & LDB_FLG_ENABLE_TRACING)) {
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_del_trans() -> %s",
ldb_dn_get_linearized(data->partitions[i]->ctrl->dn));
}
ret = ldb_next_del_trans(data->partitions[i]->module);
if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(module->ldb, "del_trans error on %s: %s", ldb_dn_get_linearized(data->partitions[i]->ctrl->dn), ldb_errstring(module->ldb));
+ ldb_asprintf_errstring(ldb_module_get_ctx(module), "del_trans error on %s: %s",
+ ldb_dn_get_linearized(data->partitions[i]->ctrl->dn),
+ ldb_errstring(ldb_module_get_ctx(module)));
final_ret = ret;
}
}
if (data->in_transaction == 0) {
DEBUG(0,("partition del transaction mismatch\n"));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
data->in_transaction--;
- if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "partition_del_trans() -> (metadata partition)");
+ if ((module && ldb_module_flags(ldb_module_get_ctx(module)) & LDB_FLG_ENABLE_TRACING)) {
+ ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_TRACE, "partition_del_trans() -> (metadata partition)");
}
ret = ldb_next_del_trans(module);
if (ret != LDB_SUCCESS) {
struct ldb_seqnum_result *seqr;
res = talloc_zero(mem_ctx, struct ldb_result);
if (res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq = talloc_zero(res, struct ldb_seqnum_request);
if (tseq == NULL) {
talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq->type = type;
res,
ldb_extended_default_callback,
NULL);
+ LDB_REQ_SET_LOCATION(treq);
if (ret != LDB_SUCCESS) {
talloc_free(res);
return ret;
/* FIXME: This function is still semi-async */
static int partition_sequence_number(struct ldb_module *module, struct ldb_request *req)
{
- int i, ret;
+ int ret;
+ unsigned int i;
uint64_t seq_number = 0;
uint64_t timestamp_sequence = 0;
uint64_t timestamp = 0;
- struct partition_private_data *data = talloc_get_type(module->private_data,
+ struct partition_private_data *data = talloc_get_type(ldb_module_get_private(module),
struct partition_private_data);
struct ldb_seqnum_request *seq;
struct ldb_seqnum_result *seqr;
res = talloc_zero(req, struct ldb_result);
if (res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq = talloc_zero(res, struct ldb_seqnum_request);
if (tseq == NULL) {
talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq->type = seq->type;
res,
ldb_extended_default_callback,
NULL);
+ LDB_REQ_SET_LOCATION(treq);
if (ret != LDB_SUCCESS) {
talloc_free(res);
return ret;
res = talloc_zero(req, struct ldb_result);
if (res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq = talloc_zero(res, struct ldb_seqnum_request);
if (tseq == NULL) {
talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
res,
ldb_extended_default_callback,
NULL);
+ LDB_REQ_SET_LOCATION(treq);
if (ret != LDB_SUCCESS) {
talloc_free(res);
return ret;
res = talloc_zero(req, struct ldb_result);
if (res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq = talloc_zero(res, struct ldb_seqnum_request);
if (tseq == NULL) {
talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
res,
ldb_extended_default_callback,
NULL);
+ LDB_REQ_SET_LOCATION(treq);
if (ret != LDB_SUCCESS) {
talloc_free(res);
return ret;
ext = talloc_zero(req, struct ldb_extended);
if (!ext) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
seqr = talloc_zero(ext, struct ldb_seqnum_result);
if (seqr == NULL) {
talloc_free(ext);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ext->oid = LDB_EXTENDED_SEQUENCE_NUMBER;
ext->data = seqr;
struct partition_context *ac;
int ret;
- data = talloc_get_type(module->private_data, struct partition_private_data);
+ data = talloc_get_type(ldb_module_get_private(module), struct partition_private_data);
if (!data) {
return ldb_next_request(module, req);
}
- ret = partition_reload_if_required(module, data);
+ ret = partition_reload_if_required(module, data, req);
if (ret != LDB_SUCCESS) {
return ret;
}
ac = partition_init_ctx(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
return partition_send_all(module, ac, req);
}
-_PUBLIC_ const struct ldb_module_ops ldb_partition_module_ops = {
+static const struct ldb_module_ops ldb_partition_module_ops = {
.name = "partition",
.init_context = partition_init,
.search = partition_search,
.end_transaction = partition_end_trans,
.del_transaction = partition_del_trans,
};
+
+int ldb_partition_module_init(const char *version)
+{
+ LDB_MODULE_CHECK_VERSION(version);
+ return ldb_register_module(&ldb_partition_module_ops);
+}