r17514: Simplify the way to set ldb errors and add another

[abartlet/samba.git/.git] / source4 / lib / ldb / modules / sort.c

diff --git a/source4/lib/ldb/modules/sort.c b/source4/lib/ldb/modules/sort.c
index 23f4f3647842436fa6fac9a18b1b75a42c08ec3f..0ae16d08ab9a265b703764f283bd5f0bb216315b 100644 (file)
--- a/source4/lib/ldb/modules/sort.c
+++ b/source4/lib/ldb/modules/sort.c
@@ -43,10 +43,10 @@ struct opaque {
        int result;
 };
 
-struct sort_async_context {
+struct sort_context {
        struct ldb_module *module;
        void *up_context;
-       int (*up_callback)(struct ldb_context *, void *, struct ldb_async_result *);
+       int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
 
        char *attributeName;
        char *orderingRule;
@@ -63,24 +63,24 @@ struct sort_async_context {
        int sort_result;
 };
 
-static struct ldb_async_handle *init_handle(void *mem_ctx, struct ldb_module *module,
+static struct ldb_handle *init_handle(void *mem_ctx, struct ldb_module *module,
                                            void *context,
-                                           int (*callback)(struct ldb_context *, void *, struct ldb_async_result *))
+                                           int (*callback)(struct ldb_context *, void *, struct ldb_reply *))
 {
-       struct sort_async_context *ac;
-       struct ldb_async_handle *h;
+       struct sort_context *ac;
+       struct ldb_handle *h;
 
-       h = talloc_zero(mem_ctx, struct ldb_async_handle);
+       h = talloc_zero(mem_ctx, struct ldb_handle);
        if (h == NULL) {
-               ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+               ldb_set_errstring(module->ldb, "Out of Memory");
                return NULL;
        }
 
        h->module = module;
 
-       ac = talloc_zero(h, struct sort_async_context);
+       ac = talloc_zero(h, struct sort_context);
        if (ac == NULL) {
-               ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+               ldb_set_errstring(module->ldb, "Out of Memory");
                talloc_free(h);
                return NULL;
        }
@@ -141,7 +141,7 @@ static int build_response(void *mem_ctx, struct ldb_control ***ctrls, int result
 
 static int sort_compare(struct ldb_message **msg1, struct ldb_message **msg2, void *opaque)
 {
-       struct sort_async_context *ac = talloc_get_type(opaque, struct sort_async_context);
+       struct sort_context *ac = talloc_get_type(opaque, struct sort_context);
        struct ldb_message_element *el1, *el2;
 
        if (ac->sort_result != 0) {
@@ -166,16 +166,16 @@ static int sort_compare(struct ldb_message **msg1, struct ldb_message **msg2, vo
        return ac->h->comparison_fn(ac->module->ldb, ac, &el1->values[0], &el2->values[0]);
 }
 
-static int server_sort_search_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares)
+static int server_sort_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
 {
-       struct sort_async_context *ac = NULL;
+       struct sort_context *ac = NULL;
        
        if (!context || !ares) {
-               ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context or Result in callback"));
+               ldb_set_errstring(ldb, "NULL Context or Result in callback");
                goto error;
        }       
 
-               ac = talloc_get_type(context, struct sort_async_context);
+               ac = talloc_get_type(context, struct sort_context);
 
        if (ares->type == LDB_REPLY_ENTRY) {
                ac->msgs = talloc_realloc(ac, ac->msgs, struct ldb_message *, ac->num_msgs + 2);
@@ -231,8 +231,8 @@ static int server_sort_search(struct ldb_module *module, struct ldb_request *req
        struct ldb_control *control;
        struct ldb_server_sort_control **sort_ctrls;
        struct ldb_control **saved_controls;
-       struct sort_async_context *ac;
-       struct ldb_async_handle *h;
+       struct sort_context *ac;
+       struct ldb_handle *h;
        int ret;
 
        /* check if there's a paged request control */
@@ -242,18 +242,19 @@ static int server_sort_search(struct ldb_module *module, struct ldb_request *req
                return ldb_next_request(module, req);
        }
 
-       req->async.handle = NULL;
+       req->handle = NULL;
 
-       if (!req->async.callback || !req->async.context) {
-               ldb_set_errstring(module->ldb, talloc_asprintf(module, "Async interface called with NULL callback function or NULL context"));
+       if (!req->callback || !req->context) {
+               ldb_set_errstring(module->ldb,
+                                 "Async interface called with NULL callback function or NULL context");
                return LDB_ERR_OPERATIONS_ERROR;
        }
        
-       h = init_handle(req, module, req->async.context, req->async.callback);
+       h = init_handle(req, module, req->context, req->callback);
        if (!h) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
-       ac = talloc_get_type(h->private_data, struct sort_async_context);
+       ac = talloc_get_type(h->private_data, struct sort_context);
 
        sort_ctrls = talloc_get_type(control->data, struct ldb_server_sort_control *);
        if (!sort_ctrls) {
@@ -265,9 +266,9 @@ static int server_sort_search(struct ldb_module *module, struct ldb_request *req
                
        if (sort_ctrls[1] != NULL) {
                if (control->critical) {
-                       struct ldb_async_result *ares;
+                       struct ldb_reply *ares;
 
-                       ares = talloc_zero(req, struct ldb_async_result);
+                       ares = talloc_zero(req, struct ldb_reply);
                        if (!ares)
                                return LDB_ERR_OPERATIONS_ERROR;
 
@@ -310,22 +311,22 @@ static int server_sort_search(struct ldb_module *module, struct ldb_request *req
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       ac->req->async.context = ac;
-       ac->req->async.callback = server_sort_search_callback;
+       ac->req->context = ac;
+       ac->req->callback = server_sort_search_callback;
        ldb_set_timeout_from_prev_req(module->ldb, req, ac->req);
 
-       req->async.handle = h;
+       req->handle = h;
 
        return ldb_next_request(module, ac->req);
 }
 
-static int server_sort_results(struct ldb_async_handle *handle)
+static int server_sort_results(struct ldb_handle *handle)
 {
-       struct sort_async_context *ac;
-       struct ldb_async_result *ares;
+       struct sort_context *ac;
+       struct ldb_reply *ares;
        int i, ret;
 
-       ac = talloc_get_type(handle->private_data, struct sort_async_context);
+       ac = talloc_get_type(handle->private_data, struct sort_context);
 
        ac->h = ldb_attrib_handler(ac->module->ldb, ac->attributeName);
        ac->sort_result = 0;
@@ -335,7 +336,7 @@ static int server_sort_results(struct ldb_async_handle *handle)
                  ac, (ldb_qsort_cmp_fn_t)sort_compare);
 
        for (i = 0; i < ac->num_msgs; i++) {
-               ares = talloc_zero(ac, struct ldb_async_result);
+               ares = talloc_zero(ac, struct ldb_reply);
                if (!ares) {
                        handle->status = LDB_ERR_OPERATIONS_ERROR;
                        return handle->status;
@@ -351,7 +352,7 @@ static int server_sort_results(struct ldb_async_handle *handle)
        }
 
        for (i = 0; i < ac->num_refs; i++) {
-               ares = talloc_zero(ac, struct ldb_async_result);
+               ares = talloc_zero(ac, struct ldb_reply);
                if (!ares) {
                        handle->status = LDB_ERR_OPERATIONS_ERROR;
                        return handle->status;
@@ -366,7 +367,7 @@ static int server_sort_results(struct ldb_async_handle *handle)
                }
        }
 
-       ares = talloc_zero(ac, struct ldb_async_result);
+       ares = talloc_zero(ac, struct ldb_reply);
        if (!ares) {
                handle->status = LDB_ERR_OPERATIONS_ERROR;
                return handle->status;
@@ -387,26 +388,26 @@ static int server_sort_results(struct ldb_async_handle *handle)
        return LDB_SUCCESS;
 }
 
-static int server_sort_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+static int server_sort_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 {
-       struct sort_async_context *ac;
+       struct sort_context *ac;
        int ret;
     
        if (!handle || !handle->private_data) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       ac = talloc_get_type(handle->private_data, struct sort_async_context);
+       ac = talloc_get_type(handle->private_data, struct sort_context);
 
-       ret = ldb_async_wait(ac->req->async.handle, type);
+       ret = ldb_wait(ac->req->handle, type);
 
        if (ret != LDB_SUCCESS) {
                handle->status = ret;
                return ret;
        }
                
-       handle->state = ac->req->async.handle->state;
-       handle->status = ac->req->async.handle->status;
+       handle->state = ac->req->handle->state;
+       handle->status = ac->req->handle->status;
 
        if (handle->status != LDB_SUCCESS) {
                return handle->status;
@@ -429,8 +430,8 @@ static int server_sort_init(struct ldb_module *module)
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       req->operation = LDB_REQ_REGISTER;
-       req->op.reg.oid = LDB_CONTROL_SERVER_SORT_OID;
+       req->operation = LDB_REQ_REGISTER_CONTROL;
+       req->op.reg_control.oid = LDB_CONTROL_SERVER_SORT_OID;
        req->controls = NULL;
 
        ret = ldb_request(module->ldb, req);
@@ -447,7 +448,7 @@ static int server_sort_init(struct ldb_module *module)
 static const struct ldb_module_ops server_sort_ops = {
        .name              = "server_sort",
        .search            = server_sort_search,
-       .async_wait        = server_sort_async_wait,
+       .wait              = server_sort_wait,
        .init_context      = server_sort_init
 };