r13993: First prototype of how an async module should be built.

This is NOT tested yet, just compiles.
Committing to share the code and gather comments
(This used to be commit 1c8536750fb811c987357cf1223666e1d79b2672)

1 files changed, 361 insertions, 42 deletions

diff --git a/source4/lib/ldb/modules/sort.c b/source4/lib/ldb/modules/sort.c
index d01e468956..a37442b41f 100644
--- a/source4/lib/ldb/modules/sort.c
+++ b/source4/lib/ldb/modules/sort.c
@@ -43,30 +43,88 @@ struct opaque {
 	int result;
 };
 
-static int build_response(struct ldb_result *res, int result, const char *desc)
+struct sort_async_context {
+	struct ldb_module *module;
+	void *up_context;
+	int (*up_callback)(struct ldb_context *, void *, struct ldb_async_result *);
+	int timeout;
+
+	char *attributeName;
+	char *orderingRule;
+	int reverse;
+
+	struct ldb_request *req;
+	struct ldb_message **msgs;
+	char **referrals;
+	struct ldb_control **controls;
+	int num_msgs;
+	int num_refs;
+
+	const struct ldb_attrib_handler *h;
+	int sort_result;
+};
+
+static struct ldb_async_handle *init_handle(void *mem_ctx, struct ldb_module *module,
+					    void *context,
+					    int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
+					    int timeout)
 {
+	struct sort_async_context *ac;
+	struct ldb_async_handle *h;
+
+	h = talloc_zero(mem_ctx, struct ldb_async_handle);
+	if (h == NULL) {
+		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+		return NULL;
+	}
+
+	h->module = module;
+
+	ac = talloc_zero(h, struct sort_async_context);
+	if (ac == NULL) {
+		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+		talloc_free(h);
+		return NULL;
+	}
+
+	h->private_data = (void *)ac;
+
+	ac->module = module;
+	ac->up_context = context;
+	ac->up_callback = callback;
+	ac->timeout = timeout;
+
+	return h;
+}
+
+static int build_response(void *mem_ctx, struct ldb_control ***ctrls, int result, const char *desc)
+{
+	struct ldb_control **controls;
 	struct ldb_sort_resp_control *resp;
 	int i;
 
-	if (res->controls) {
-		for (i = 0; res->controls[i]; i++);
-		res->controls = talloc_realloc(res, res->controls, struct ldb_control *, i + 2);
+	if (*ctrls) {
+		controls = *ctrls;
+		for (i = 0; controls[i]; i++);
+		controls = talloc_realloc(mem_ctx, controls, struct ldb_control *, i + 2);
 	} else {
 		i = 0;
-		res->controls = talloc_array(res, struct ldb_control *, 2);
+		controls = talloc_array(mem_ctx, struct ldb_control *, 2);
 	}
-	if (! res->controls )
+	if (! controls )
 		return LDB_ERR_OPERATIONS_ERROR;
 
-	res->controls[i+1] = NULL;
-	res->controls[i] = talloc(res->controls, struct ldb_control);
-	if (! res->controls[i] )
+	*ctrls = controls;
+
+	controls[i+1] = NULL;
+	controls[i] = talloc(controls, struct ldb_control);
+	if (! controls[i] )
 		return LDB_ERR_OPERATIONS_ERROR;
 
-	res->controls[i]->oid = LDB_CONTROL_SORT_RESP_OID;
-	res->controls[i]->critical = 0;
+	controls[i]->oid = LDB_CONTROL_SORT_RESP_OID;
+	controls[i]->critical = 0;
 
-	resp = talloc(res->controls[i], struct ldb_sort_resp_control);
+	resp = talloc(controls[i], struct ldb_sort_resp_control);
 	if (! resp )
 		return LDB_ERR_OPERATIONS_ERROR;
 
@@ -76,7 +134,7 @@ static int build_response(struct ldb_result *res, int result, const char *desc)
 	if (! resp->attr_desc )
 		return LDB_ERR_OPERATIONS_ERROR;
 	
-	res->controls[i]->data = resp;
+	controls[i]->data = resp;
 
 	return LDB_SUCCESS;
 }
@@ -108,23 +166,42 @@ static int sort_compare(struct ldb_message **msg1, struct ldb_message **msg2, vo
 	return data->h->comparison_fn(data->ldb, data, &el1->values[0], &el2->values[0]);
 }
 
+static int sort_compare_async(struct ldb_message **msg1, struct ldb_message **msg2, void *opaque)
+{
+	struct sort_async_context *ac = talloc_get_type(opaque, struct sort_async_context);
+	struct ldb_message_element *el1, *el2;
+
+	if (ac->sort_result != 0) {
+		/* an error occurred previously,
+		 * let's exit the sorting by returning always 0 */
+		return 0;
+	}
+
+	el1 = ldb_msg_find_element(*msg1, ac->attributeName);
+	el2 = ldb_msg_find_element(*msg2, ac->attributeName);
+
+	if (!el1 || !el2) {
+		/* the attribute was not found return and
+		 * set an error */
+		ac->sort_result = 53;
+		return 0;
+	}
+
+	if (ac->reverse)
+		return ac->h->comparison_fn(ac->module->ldb, ac, &el2->values[0], &el1->values[0]);
+
+	return ac->h->comparison_fn(ac->module->ldb, ac, &el1->values[0], &el2->values[0]);
+}
+
 /* search */
-static int server_sort_search(struct ldb_module *module, struct ldb_request *req)
+static int server_sort_search(struct ldb_module *module, struct ldb_control *control, struct ldb_request *req)
 {
 	struct ldb_result *sort_result = NULL;
-	struct ldb_control *control;
 	struct ldb_control **saved_controls;
 	struct ldb_server_sort_control **sort_ctrls;
 	int ret, result = 0;
 	int do_sort = 1;
 
-	/* check if there's a paged request control */
-	control = get_control_from_list(req->controls, LDB_CONTROL_SERVER_SORT_OID);
-	if (control == NULL) {
-		/* not found go on */
-		return ldb_next_request(module, req);
-	}
-
 	sort_ctrls = talloc_get_type(control->data, struct ldb_server_sort_control *);
 	if (!sort_ctrls) {
 		return LDB_ERR_PROTOCOL_ERROR;
@@ -143,7 +220,7 @@ static int server_sort_search(struct ldb_module *module, struct ldb_request *req
 		req->op.search.res = sort_result;
 	
 		/* 53 = unwilling to perform */
-		if ((ret = build_response(sort_result, 53, "sort control is not complete yet")) != LDB_SUCCESS) {
+		if ((ret = build_response(sort_result, &sort_result->controls, 53, "sort control is not complete yet")) != LDB_SUCCESS) {
 			return ret;
 		}
 
@@ -179,22 +256,6 @@ static int server_sort_search(struct ldb_module *module, struct ldb_request *req
 		data->result = 0;
 		sort_result = req->op.search.res;
 
-		/* FIXME: I don't like to use a static structure like sort_control
-		 * we need to either:
-		 * a) write a qsort function that takes a third void parameter
-		 * or
-		 * b) prepare a structure with all elements pre digested like:
-		 * 	struct element {
-		 * 		struct ldb_message_element *el;
-		 * 		struct ldb_message *msg;
-		 * 	}
-		 *
-		 * 	this mean we will have to do a linear scan of
-		 * 	the msgs array to build the new sort array, and
-		 * 	then do a linear scan of the resulting array
-		 * 	to rebuild the msgs array in the original shape.
-		 */
-
 		ldb_qsort(sort_result->msgs,
 			  sort_result->count,
 			  sizeof(struct ldb_message *),
@@ -208,24 +269,281 @@ static int server_sort_search(struct ldb_module *module, struct ldb_request *req
 		result = 53;
 	}
 
-	if ((ret = build_response(sort_result, result, "sort control is not complete yet")) != LDB_SUCCESS) {
+	if ((ret = build_response(sort_result, &sort_result->controls, result, "sort control is not complete yet")) != LDB_SUCCESS) {
 		return ret;
 	}
 
 	return LDB_SUCCESS;
 }
 
+static int server_sort_search_async_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares)
+{
+	struct sort_async_context *ac = NULL;
+	
+ 	if (!context || !ares) {
+		ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context or Result in callback"));
+		goto error;
+	}	
+
+       	ac = talloc_get_type(context, struct sort_async_context);
+
+	if (ares->type == LDB_REPLY_ENTRY) {
+		ac->msgs = talloc_realloc(ac, ac->msgs, struct ldb_message *, ac->num_msgs + 2);
+		if (! ac->msgs) {
+			goto error;
+		}
+
+		ac->msgs[ac->num_msgs + 1] = NULL;
+
+		ac->msgs[ac->num_msgs] = talloc_steal(ac->msgs, ares->message);
+		if (! ac->msgs[ac->num_msgs]) {
+			goto error;
+		}
+
+		ac->num_msgs++;
+	}
+
+	if (ares->type == LDB_REPLY_REFERRAL) {
+		ac->referrals = talloc_realloc(ac, ac->referrals, char *, ac->num_refs + 2);
+		if (! ac->referrals) {
+			goto error;
+		}
+
+		ac->referrals[ac->num_refs + 1] = NULL;
+
+		ac->referrals[ac->num_refs] = talloc_steal(ac->referrals, ares->referral);
+		if (! ac->referrals[ac->num_refs]) {
+			goto error;
+		}
+
+		ac->num_refs++;
+	}
+
+	if (ares->type == LDB_REPLY_DONE) {
+		if (ares->controls) {
+			ac->controls = talloc_steal(ac, ares->controls);
+			if (! ac->controls) {
+				goto error;
+			}
+		}
+	}
+
+	talloc_free(ares);
+	return LDB_SUCCESS;
+
+error:
+	talloc_free(ares);
+	return LDB_ERR_OPERATIONS_ERROR;
+}
+
+static int server_sort_search_async(struct ldb_module *module, struct ldb_control *control, struct ldb_request *req)
+{
+	struct ldb_server_sort_control **sort_ctrls;
+	struct ldb_control **saved_controls;
+	struct sort_async_context *ac;
+	struct ldb_async_handle *h;
+	int ret;
+
+	req->async.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"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	
+	h = init_handle(req, module, req->async.context, req->async.callback, req->async.timeout);
+	if (!h) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	ac = talloc_get_type(h->private_data, struct sort_async_context);
+
+	sort_ctrls = talloc_get_type(control->data, struct ldb_server_sort_control *);
+	if (!sort_ctrls) {
+		return LDB_ERR_PROTOCOL_ERROR;
+	}
+
+	/* FIXME: we do not support more than one attribute for sorting right now */
+	/* FIXME: we need to check if the attribute type exist or return an error */
+		
+	if (sort_ctrls[1] != NULL) {
+		if (control->critical) {
+			struct ldb_async_result *ares;
+
+			ares = talloc_zero(req, struct ldb_async_result);
+			if (!ares)
+				return LDB_ERR_OPERATIONS_ERROR;
+
+			/* 53 = unwilling to perform */
+			ares->type = LDB_REPLY_DONE;
+			if ((ret = build_response(ares, &ares->controls, 53, "sort control is not complete yet")) != LDB_SUCCESS) {
+				return ret;
+			}
+
+			h->status = LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+			h->state = LDB_ASYNC_DONE;
+			ret = ac->up_callback(module->ldb, ac->up_context, ares);
+
+			return ret;
+		} else {
+			/* just pass the call down and don't do any sorting */
+			ldb_next_request(module, req);
+		}
+	}
+
+	ac->attributeName = sort_ctrls[0]->attributeName;
+	ac->orderingRule = sort_ctrls[0]->orderingRule;
+	ac->reverse = sort_ctrls[0]->reverse;
+
+	ac->req = talloc(req, struct ldb_request);
+
+	ac->req->operation = req->operation;
+	ac->req->op.search.base = req->op.search.base;
+	ac->req->op.search.scope = req->op.search.scope;
+	ac->req->op.search.tree = req->op.search.tree;
+	ac->req->op.search.attrs = req->op.search.attrs;
+	ac->req->controls = req->controls;
+
+	/* save it locally and remove it from the list */
+	/* we do not need to replace them later as we
+	 * are keeping the original req intact */
+	if (!save_controls(control, ac->req, &saved_controls)) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	ac->req->creds = req->creds;
+
+	ac->req->async.context = ac;
+	ac->req->async.callback = server_sort_search_async_callback;
+	ac->req->async.timeout = req->async.timeout;
+
+	req->async.handle = h;
+
+	return ldb_next_request(module, ac->req);
+}
+
 static int server_sort(struct ldb_module *module, struct ldb_request *req)
 {
+	struct ldb_control *control;
+
+	/* check if there's a paged request control */
+	control = get_control_from_list(req->controls, LDB_CONTROL_SERVER_SORT_OID);
+	if (control == NULL) {
+		/* not found go on */
+		return ldb_next_request(module, req);
+	}
+
 	switch (req->operation) {
 
 	case LDB_REQ_SEARCH:
-		return server_sort_search(module, req);
+		return server_sort_search(module, control, req);
+
+	case LDB_ASYNC_SEARCH:
+		return server_sort_search_async(module, control, req);
 
 	default:
-		return ldb_next_request(module, req);
+		return LDB_ERR_PROTOCOL_ERROR;
+
+	}
+}
+
+static int server_sort_async_results(struct ldb_async_handle *handle)
+{
+	struct sort_async_context *ac;
+	struct ldb_async_result *ares;
+	int i, ret;
+
+	ac = talloc_get_type(handle->private_data, struct sort_async_context);
+
+	ac->h = ldb_attrib_handler(ac->module->ldb, ac->attributeName);
+	ac->sort_result = 0;
+
+	ldb_qsort(ac->msgs, ac->num_msgs,
+		  sizeof(struct ldb_message *),
+		  ac, (ldb_qsort_cmp_fn_t)sort_compare_async);
+
+	for (i = 0; i < ac->num_msgs; i++) {
+		ares = talloc_zero(ac, struct ldb_async_result);
+		if (!ares) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			return handle->status;
+		}
+
+		ares->type = LDB_REPLY_ENTRY;
+		ares->message = talloc_steal(ares, ac->msgs[i]);
+		
+		handle->status = ac->up_callback(ac->module->ldb, ac->up_context, ares);
+		if (handle->status != LDB_SUCCESS) {
+			return handle->status;
+		}
+	}
+
+	for (i = 0; i < ac->num_refs; i++) {
+		ares = talloc_zero(ac, struct ldb_async_result);
+		if (!ares) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			return handle->status;
+		}
+
+		ares->type = LDB_REPLY_REFERRAL;
+		ares->referral = talloc_steal(ares, ac->referrals[i]);
+		
+		handle->status = ac->up_callback(ac->module->ldb, ac->up_context, ares);
+		if (handle->status != LDB_SUCCESS) {
+			return handle->status;
+		}
+	}
+
+	ares = talloc_zero(ac, struct ldb_async_result);
+	if (!ares) {
+		handle->status = LDB_ERR_OPERATIONS_ERROR;
+		return handle->status;
+	}
+
+	ares->type = LDB_REPLY_DONE;
+	ares->controls = talloc_steal(ares, ac->controls);
+		
+	handle->status = ac->up_callback(ac->module->ldb, ac->up_context, ares);
+	if (handle->status != LDB_SUCCESS) {
+		return handle->status;
+	}
 
+	if ((ret = build_response(ac, &ac->controls, ac->sort_result, "sort control is not complete yet")) != LDB_SUCCESS) {
+		return ret;
 	}
+
+	return LDB_SUCCESS;
+}
+
+static int server_sort_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+{
+	struct sort_async_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);
+
+	ret = ldb_async_wait(handle->module->ldb, ac->req->async.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;
+
+	if (handle->status != LDB_SUCCESS) {
+		return handle->status;
+	}
+
+	if (handle->state == LDB_ASYNC_DONE) {
+		ret = server_sort_async_results(handle);
+	}
+
+	return ret;
 }
 
 static int server_sort_init(struct ldb_module *module)
@@ -249,6 +567,7 @@ static int server_sort_init(struct ldb_module *module)
 static const struct ldb_module_ops server_sort_ops = {
 	.name		   = "server_sort",
 	.request      	   = server_sort,
+	.async_wait        = server_sort_async_wait,
 	.init_context	   = server_sort_init
 };