git.samba.org / nivanova / samba-autobuild / .git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
s4:partition LDB module - fill in parent requests for inheriting the flags
[nivanova/samba-autobuild/.git] / source4 / dsdb / samdb / ldb_modules / partition.c
diff --git a/source4/dsdb/samdb/ldb_modules/partition.c b/source4/dsdb/samdb/ldb_modules/partition.c
index ba695d2221895ccf2a0b08f28f855f26e78e7fde..6cf670937e60c5207d83becf01be7a2ecd1c154b 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/partition.c
+++ b/source4/dsdb/samdb/ldb_modules/partition.c
@@ -68,7 +68,7 @@ static struct partition_context *partition_init_ctx(struct ldb_module *module, s
  */
 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) {
@@ -77,10 +77,10 @@ int partition_request(struct ldb_module *module, struct ldb_request *request)
                }
 
                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)");
                }
        }
 
@@ -138,7 +138,7 @@ static int partition_req_callback(struct ldb_request *req,
        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,
@@ -149,7 +149,7 @@ static int partition_req_callback(struct ldb_request *req,
        if (partition_ctrl && (ac->num_requests == 1 || ares->type == LDB_REPLY_ENTRY)) {
                /* If we didn't fan this request out to mulitple partitions,
                 * or this is an individual search result, we can
-                * deterministily tell the caller what partition this was
+                * deterministically 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,
@@ -244,8 +244,7 @@ static int partition_prep_request(struct partition_context *ac,
                                        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) {
@@ -259,6 +258,7 @@ static int partition_prep_request(struct partition_context *ac,
                                        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,
@@ -266,6 +266,7 @@ static int partition_prep_request(struct partition_context *ac,
                                        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,
@@ -273,6 +274,7 @@ static int partition_prep_request(struct partition_context *ac,
                                        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,
@@ -280,6 +282,7 @@ static int partition_prep_request(struct partition_context *ac,
                                        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,
@@ -288,6 +291,7 @@ static int partition_prep_request(struct partition_context *ac,
                                        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),
@@ -297,6 +301,7 @@ static int partition_prep_request(struct partition_context *ac,
                                        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),
@@ -314,8 +319,7 @@ static int partition_prep_request(struct partition_context *ac,
                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));
                }
        }
 
@@ -365,7 +369,7 @@ static int partition_send_all(struct ldb_module *module,
                              struct ldb_request *req) 
 {
        unsigned int i;
-       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);
        int ret = partition_prep_request(ac, NULL);
        if (ret != LDB_SUCCESS) {
@@ -392,8 +396,10 @@ static int partition_replicate(struct ldb_module *module, struct ldb_request *re
        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 we aren't initialised yet go further */
        if (!data || !data->partitions) {
                return ldb_next_request(module, req);
        }
@@ -406,7 +412,7 @@ static int partition_replicate(struct ldb_module *module, struct ldb_request *re
                                
                                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);
@@ -432,7 +438,7 @@ static int partition_replicate(struct ldb_module *module, struct ldb_request *re
 
        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 */
@@ -450,7 +456,7 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
 {
        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);
        struct partition_context *ac;
        struct ldb_context *ldb;
@@ -464,8 +470,9 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
        unsigned int i, j;
        int ret;
        bool domain_scope = false, phantom_root = false;
-       
-       ret = partition_reload_if_required(module, data);
+
+       /* see if we are still up-to-date */
+       ret = partition_reload_if_required(module, data, req);
        if (ret != LDB_SUCCESS) {
                return ret;
        }
@@ -489,9 +496,8 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
 
        /* 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;
+       if (domain_scope_control && !ldb_save_controls(domain_scope_control, req, &saved_controls)) {
+               return ldb_oom(ldb_module_get_ctx(module));
        }
 
        /* Locate the options */
@@ -514,7 +520,7 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
 
        ac = partition_init_ctx(module, req);
        if (!ac) {
-               return LDB_ERR_OPERATIONS_ERROR;
+               return ldb_operr(ldb_module_get_ctx(module));
        }
 
        ldb = ldb_module_get_ctx(ac->module);
@@ -585,21 +591,19 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
                                            data->partitions[i]->ctrl->dn) != 0)) {
                                char *ref = talloc_asprintf(ac,
                                                            "ldap://%s/%s%s",
-                                                           lp_dnsdomain(lp_ctx),
+                                                           lpcfg_dnsdomain(lp_ctx),
                                                            ldb_dn_get_linearized(data->partitions[i]->ctrl->dn),
                                                            req->op.search.scope == LDB_SCOPE_ONELEVEL ? "??base" : "");
 
                                if (ref == NULL) {
-                                       ldb_oom(ldb);
-                                       return LDB_ERR_OPERATIONS_ERROR;
+                                       return ldb_oom(ldb);
                                }
 
                                /* Initialise the referrals list */
                                if (ac->referrals == NULL) {
                                        ac->referrals = (const char **) str_list_make_empty(ac);
                                        if (ac->referrals == NULL) {
-                                               ldb_oom(ldb);
-                                               return LDB_ERR_OPERATIONS_ERROR;
+                                               return ldb_oom(ldb);
                                        }
                                }
 
@@ -623,8 +627,7 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
                                talloc_free(ref);
 
                                if (ac->referrals == NULL) {
-                                       ldb_oom(ldb);
-                                       return LDB_ERR_OPERATIONS_ERROR;
+                                       return ldb_oom(ldb);
                                }
                        }
                        if (ldb_dn_compare_base(data->partitions[i]->ctrl->dn, req->op.search.base) == 0) {
@@ -677,12 +680,12 @@ static int partition_rename(struct ldb_module *module, struct ldb_request *req)
        /* 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);
@@ -711,27 +714,27 @@ static int partition_start_trans(struct ldb_module *module)
 {
        unsigned int i;
        int ret;
-       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);
        /* 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);
@@ -754,27 +757,27 @@ static int partition_start_trans(struct ldb_module *module)
 static int partition_prepare_commit(struct ldb_module *module)
 {
        unsigned int i;
-       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);
 
        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_asprintf_errstring(ldb_module_get_ctx(module), "prepare_commit error on %s: %s",
                                               ldb_dn_get_linearized(data->partitions[i]->ctrl->dn),
-                                              ldb_errstring(module->ldb));
+                                              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);
 }
@@ -785,7 +788,7 @@ static int partition_end_trans(struct ldb_module *module)
 {
        int ret, ret2;
        unsigned int i;
-       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);
 
        ret = LDB_SUCCESS;
@@ -798,21 +801,21 @@ static int partition_end_trans(struct ldb_module *module)
        }
 
        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_asprintf_errstring(ldb_module_get_ctx(module), "end_trans error on %s: %s",
                                               ldb_dn_get_linearized(data->partitions[i]->ctrl->dn),
-                                              ldb_errstring(module->ldb));
+                                              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) {
@@ -826,30 +829,30 @@ static int partition_del_trans(struct ldb_module *module)
 {
        int ret, final_ret = LDB_SUCCESS;
        unsigned int i;
-       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);
        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_asprintf_errstring(ldb_module_get_ctx(module), "del_trans error on %s: %s",
                                               ldb_dn_get_linearized(data->partitions[i]->ctrl->dn),
-                                              ldb_errstring(module->ldb));
+                                              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) {
@@ -868,12 +871,12 @@ int partition_primary_sequence_number(struct ldb_module *module, TALLOC_CTX *mem
        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;
        
@@ -884,6 +887,7 @@ int partition_primary_sequence_number(struct ldb_module *module, TALLOC_CTX *mem
                                     res,
                                     ldb_extended_default_callback,
                                     NULL);
+       LDB_REQ_SET_LOCATION(treq);
        if (ret != LDB_SUCCESS) {
                talloc_free(res);
                return ret;
@@ -922,7 +926,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
        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;
@@ -957,12 +961,12 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
 
                        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;
 
@@ -972,7 +976,8 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
                                                     NULL,
                                                     res,
                                                     ldb_extended_default_callback,
-                                                    NULL);
+                                                    req);
+                       LDB_REQ_SET_LOCATION(treq);
                        if (ret != LDB_SUCCESS) {
                                talloc_free(res);
                                return ret;
@@ -1013,13 +1018,13 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
 
                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;
 
@@ -1029,7 +1034,8 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
                                             NULL,
                                             res,
                                             ldb_extended_default_callback,
-                                            NULL);
+                                            req);
+               LDB_REQ_SET_LOCATION(treq);
                if (ret != LDB_SUCCESS) {
                        talloc_free(res);
                        return ret;
@@ -1057,13 +1063,13 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
 
                        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;
 
@@ -1073,7 +1079,8 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
                                                     NULL,
                                                     res,
                                                     ldb_extended_default_callback,
-                                                    NULL);
+                                                    req);
+                       LDB_REQ_SET_LOCATION(treq);
                        if (ret != LDB_SUCCESS) {
                                talloc_free(res);
                                return ret;
@@ -1112,12 +1119,12 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
 
        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;
@@ -1160,12 +1167,12 @@ static int partition_extended(struct ldb_module *module, struct ldb_request *req
        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;
        }
@@ -1185,13 +1192,13 @@ static int partition_extended(struct ldb_module *module, struct ldb_request *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);
 }
 
-_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,
@@ -1205,3 +1212,9 @@ _PUBLIC_ const struct ldb_module_ops ldb_partition_module_ops = {
        .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);
+}
Unnamed repository; edit this file 'description' to name the repository.