5 files changed, 6 insertions, 707 deletions

diff --git a/source4/lib/ldb/modules/asq.c b/source4/lib/ldb/modules/asq.c
index 884616abdd..005d1e41b0 100644
--- a/source4/lib/ldb/modules/asq.c
+++ b/source4/lib/ldb/modules/asq.c
@@ -41,152 +41,6 @@
 #define ASQ_CTRL_UNWILLING_TO_PERFORM		53
 #define ASQ_CTRL_AFFECTS_MULTIPLE_DSA		71
 
-static int build_response(struct ldb_result *res, int result)
-{
-	struct ldb_asq_control *asq;
-	int i;
-
-	if (res->controls) {
-		for (i = 0; res->controls[i]; i++);
-		res->controls = talloc_realloc(res, res->controls, struct ldb_control *, i + 2);
-	} else {
-		i = 0;
-		res->controls = talloc_array(res, struct ldb_control *, 2);
-	}
-	if (res->controls == NULL)
-		return LDB_ERR_OPERATIONS_ERROR;
-
-	res->controls[i] = talloc(res->controls, struct ldb_control);
-	if (res->controls[i] == NULL)
-		return LDB_ERR_OPERATIONS_ERROR;
-
-	res->controls[i]->oid = LDB_CONTROL_ASQ_OID;
-	res->controls[i]->critical = 0;
-
-	asq = talloc_zero(res->controls[i], struct ldb_asq_control);
-	if (asq == NULL)
-		return LDB_ERR_OPERATIONS_ERROR;
-
-	asq->result = result;
-	
-	res->controls[i]->data = asq;
-
-	res->controls[i + 1] = NULL;
-
-	return LDB_SUCCESS;
-}
-
-/* search */
-static int asq_search_sync(struct ldb_module *module, struct ldb_control *control, struct ldb_request *req)
-{
-	struct ldb_asq_control *asq_ctrl;
-	struct ldb_request *base_req;
-	struct ldb_message_element *el;
-	struct ldb_result *res;
-	char **base_attrs;
-	int i, c, ret;
-
-	/* pre-allocate a clean result structure */
-	req->op.search.res = res = talloc_zero(req, struct ldb_result);
-	if (res == NULL)
-		return LDB_ERR_OPERATIONS_ERROR;
-
-	/* check the search is well formed */
-	if (req->op.search.scope != LDB_SCOPE_BASE) {
-		return build_response(res, ASQ_CTRL_UNWILLING_TO_PERFORM);
-	}
-
-	asq_ctrl = talloc_get_type(control->data, struct ldb_asq_control);
-	if (!asq_ctrl) {
-		return LDB_ERR_PROTOCOL_ERROR;
-	}
-
-	/* get the object to retrieve the DNs to search */
-	base_req = talloc_zero(req, struct ldb_request);
-	if (base_req == NULL)
-		return LDB_ERR_OPERATIONS_ERROR;
-	base_req->operation = LDB_REQ_SEARCH;
-	base_req->op.search.base = req->op.search.base;
-	base_req->op.search.scope = LDB_SCOPE_BASE;
-	base_req->op.search.tree = req->op.search.tree;
-	base_attrs = talloc_array(base_req, char *, 2);
-	if (base_attrs == NULL)
-		return LDB_ERR_OPERATIONS_ERROR;
-	base_attrs[0] = talloc_strdup(base_attrs, asq_ctrl->source_attribute);
-	if (base_attrs[0] == NULL)
-		return LDB_ERR_OPERATIONS_ERROR;
-	base_attrs[1] = NULL;
-	base_req->op.search.attrs = (const char * const *)base_attrs;
-
-	ret = ldb_request(module->ldb, base_req);
-
-	if (ret != LDB_SUCCESS) {
-		talloc_free(base_req);
-		return ret;
-	}
-
-	if (base_req->op.search.res->count == 0) {
-		talloc_free(base_req);
-		return build_response(res, ASQ_CTRL_SUCCESS);
-	}
-	
-	/* look up the DNs */
-	el = ldb_msg_find_element(base_req->op.search.res->msgs[0],
-				  asq_ctrl->source_attribute);
-	/* no values found */
-	if (el == NULL) {
-		talloc_free(base_req);
-		return build_response(res, ASQ_CTRL_SUCCESS);
-	}
-
-	for (i = 0, c = 0; i < el->num_values; i++) {
-		struct ldb_request *exp_req;
-
-		exp_req = talloc_zero(req, struct ldb_request);
-		if (exp_req == NULL)
-			return LDB_ERR_OPERATIONS_ERROR;
-		exp_req->operation = LDB_REQ_SEARCH;
-		exp_req->op.search.base = ldb_dn_explode(exp_req, (const char *)el->values[i].data);
-		if (exp_req->op.search.base == NULL) {
-			return build_response(res, ASQ_CTRL_INVALID_ATTRIBUTE_SYNTAX);
-		}
-		exp_req->op.search.scope = LDB_SCOPE_BASE;
-		exp_req->op.search.tree = req->op.search.tree;
-		exp_req->op.search.attrs = req->op.search.attrs;
-
-		ret = ldb_request(module->ldb, exp_req);
-
-		if (ret != LDB_SUCCESS)
-			return ret;
-
-		if (exp_req->op.search.res && exp_req->op.search.res->count != 0) {
-			if (res->msgs == NULL) {
-				res->msgs = talloc_array(res,
-						struct ldb_message *, 2);
-			} else {
-				res->msgs = talloc_realloc(res, res->msgs,
-						struct ldb_message *, c + 2);
-			}
-			if (res->msgs == NULL)
-				return LDB_ERR_OPERATIONS_ERROR;
-
-			res->msgs[c] = talloc_steal(res->msgs, exp_req->op.search.res->msgs[0]);
-			c++;
-		}
-
-		if (res->msgs) {
-			res->msgs[c] = NULL;
-			res->count = c;
-		}
-
-		talloc_free(exp_req);
-	}
-
-	talloc_free(base_req);
-
-	return build_response(res, ASQ_CTRL_SUCCESS);
-}
-
 struct asq_async_context {
 
 	enum {ASQ_SEARCH_BASE, ASQ_SEARCH_MULTI} step;
@@ -580,28 +434,6 @@ static int asq_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_t
 	}
 }
 
-static int asq(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_ASQ_OID);
-	if (control == NULL) {
-		/* not found go on */
-		return ldb_next_request(module, req);
-	}
-
-	switch (req->operation) {
-
-	case LDB_REQ_SEARCH:
-		return asq_search_sync(module, control, req);
-	
-	default:
-		return LDB_ERR_PROTOCOL_ERROR;
-
-	}
-}
-
 static int asq_init(struct ldb_module *module)
 {
 	struct ldb_request request;
@@ -624,7 +456,6 @@ static int asq_init(struct ldb_module *module)
 static const struct ldb_module_ops asq_ops = {
 	.name		   = "asq",
 	.search		   = asq_search,
-	.request      	   = asq,
 	.async_wait        = asq_async_wait,
 	.init_context	   = asq_init
 };
diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 084105fd85..4b1daba30f 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -170,76 +170,6 @@ failed:
 }
 
 /*
-  hook search operations
-*/
-static int operational_search_bytree(struct ldb_module *module, struct ldb_request *req)
-{
-	int i, r, a;
-	int ret;
-	const char * const *attrs = req->op.search.attrs;
-	const char **search_attrs = NULL;
-
-	req->op.search.res = NULL;
-
-	/* replace any attributes in the parse tree that are
-	   searchable, but are stored using a different name in the
-	   backend */
-	for (i=0;i<ARRAY_SIZE(parse_tree_sub);i++) {
-		ldb_parse_tree_attr_replace(req->op.search.tree, 
-					    parse_tree_sub[i].attr, 
-					    parse_tree_sub[i].replace);
-	}
-
-	/* in the list of attributes we are looking for, rename any
-	   attributes to the alias for any hidden attributes that can
-	   be fetched directly using non-hidden names */
-	for (a=0;attrs && attrs[a];a++) {
-		for (i=0;i<ARRAY_SIZE(search_sub);i++) {
-			if (ldb_attr_cmp(attrs[a], search_sub[i].attr) == 0 &&
-			    search_sub[i].replace) {
-				if (!search_attrs) {
-					search_attrs = ldb_attr_list_copy(req, attrs);
-					if (search_attrs == NULL) {
-						goto failed;
-					}
-				}
-				search_attrs[a] = search_sub[i].replace;
-			}
-		}
-	}
-	
-	/* use new set of attrs if any */
-	if (search_attrs) req->op.search.attrs = search_attrs;
-	/* perform the search */
-	ret = ldb_next_request(module, req);
-	/* set back saved attrs if needed */
-	if (search_attrs) req->op.search.attrs = attrs;
-
-	/* check operation result */
-	if (ret != LDB_SUCCESS) {
-		return ret;
-	}
-
-	/* for each record returned post-process to add any derived
-	   attributes that have been asked for */
-	for (r = 0; r < req->op.search.res->count; r++) {
-		if (operational_search_post_process(module, req->op.search.res->msgs[r], attrs) != 0) {
-			goto failed;
-		}
-	}
-
-	/* all done */
-	talloc_free(search_attrs);
-	return ret;
-
-failed:
-	talloc_free(search_attrs);
-	talloc_free(req->op.search.res);
-	ldb_oom(module->ldb);
-	return LDB_ERR_OTHER;
-}
-
-/*
   add a time element to a record
 */
 static int add_time_element(struct ldb_message *msg, const char *attr, time_t t)
@@ -293,95 +223,6 @@ static int add_uint64_element(struct ldb_message *msg, const char *attr, uint64_
 
 
 /*
-  hook add record ops
-*/
-static int operational_add_sync(struct ldb_module *module, struct ldb_request *req)
-{
-	const struct ldb_message *msg = req->op.add.message;
-	time_t t = time(NULL);
-	struct ldb_message *msg2;
-	int ret;
-
-	if (ldb_dn_is_special(msg->dn)) {
-		return ldb_next_request(module, req);
-	}
-
-	/* we have to copy the message as the caller might have it as a const */
-	msg2 = ldb_msg_copy_shallow(module, msg);
-	if (msg2 == NULL) {
-		return -1;
-	}
-	if (add_time_element(msg2, "whenCreated", t) != 0 ||
-	    add_time_element(msg2, "whenChanged", t) != 0) {
-		talloc_free(msg2);
-		return -1;
-	}
-
-	/* see if the backend can give us the USN */
-	if (module->ldb->sequence_number != NULL) {
-		uint64_t seq_num = module->ldb->sequence_number(module->ldb);
-		if (add_uint64_element(msg2, "uSNCreated", seq_num) != 0 ||
-		    add_uint64_element(msg2, "uSNChanged", seq_num) != 0) {
-			talloc_free(msg2);
-			return -1;
-		}
-	}
-
-	/* use the new structure for the call chain below this point */
-	req->op.add.message = msg2;
-	/* go on with the call chain */
-	ret = ldb_next_request(module, req);
-	/* put back saved message */
-	req->op.add.message = msg;
-	/* free temproary compy */
-	talloc_free(msg2);
-	return ret;
-}
-
-/*
-  hook modify record ops
-*/
-static int operational_modify_sync(struct ldb_module *module, struct ldb_request *req)
-{
-	const struct ldb_message *msg = req->op.mod.message;
-	time_t t = time(NULL);
-	struct ldb_message *msg2;
-	int ret;
-
-	if (ldb_dn_is_special(msg->dn)) {
-		return ldb_next_request(module, req);
-	}
-
-	/* we have to copy the message as the caller might have it as a const */
-	msg2 = ldb_msg_copy_shallow(module, msg);
-	if (msg2 == NULL) {
-		return -1;
-	}
-	if (add_time_element(msg2, "whenChanged", t) != 0) {
-		talloc_free(msg2);
-		return -1;
-	}
-
-	/* update the records USN if possible */
-	if (module->ldb->sequence_number != NULL &&
-	    add_uint64_element(msg2, "uSNChanged", 
-			       module->ldb->sequence_number(module->ldb)) != 0) {
-		talloc_free(msg2);
-		return -1;
-	}
-
-	/* use the new structure for the call chain below this point */
-	req->op.mod.message = msg2;
-	/* go on with the call chain */
-	ret = ldb_next_request(module, req);
-	/* put back saved message */
-	req->op.mod.message = msg;
-	/* free temproary compy */
-	talloc_free(msg2);
-	return ret;
-}
-
-/*
   hook search operations
 */
 
@@ -607,26 +448,6 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 	return ret;
 }
 
-
-static int operational_request(struct ldb_module *module, struct ldb_request *req)
-{
-	switch (req->operation) {
-
-	case LDB_REQ_SEARCH:
-		return operational_search_bytree(module, req);
-
-	case LDB_REQ_ADD:
-		return operational_add_sync(module, req);
-
-	case LDB_REQ_MODIFY:
-		return operational_modify_sync(module, req);
-
-	default:
-		return ldb_next_request(module, req);
-
-	}
-}
-
 static int operational_init(struct ldb_module *ctx)
 {
 	/* setup some standard attribute handlers */
@@ -643,7 +464,6 @@ static const struct ldb_module_ops operational_ops = {
 	.search            = operational_search,
 	.add               = operational_add,
 	.modify            = operational_modify,
-	.request           = operational_request,
 	.init_context	   = operational_init
 };
 
diff --git a/source4/lib/ldb/modules/paged_results.c b/source4/lib/ldb/modules/paged_results.c
index 71b99184a1..6d864375c6 100644
--- a/source4/lib/ldb/modules/paged_results.c
+++ b/source4/lib/ldb/modules/paged_results.c
@@ -122,135 +122,6 @@ static struct results_store *new_store(struct private_data *priv)
 	return new;
 }
 
-/* search */
-static int paged_search_sync(struct ldb_module *module, struct ldb_control *control, struct ldb_request *req)
-{
-	struct private_data *private_data = talloc_get_type(module->private_data, struct private_data);
-	struct results_store *current = NULL;
-	struct ldb_result *paged_result;
-	struct ldb_control **saved_controls;
-	struct ldb_paged_control *paged_ctrl;
-	struct ldb_paged_control *paged_ret;
-	int i, ret;
-
-	paged_ctrl = talloc_get_type(control->data, struct ldb_paged_control);
-	if (!paged_ctrl) {
-		return LDB_ERR_PROTOCOL_ERROR;
-	}
-
-	/* check if it is a continuation search the store */
-	if (paged_ctrl->cookie_len != 0) {
-		for (current = private_data->store; current; current = current->next) {
-			if (strcmp(current->cookie, paged_ctrl->cookie) == 0) {
-				current->timestamp = time(NULL);
-				break;
-			}
-		}
-		if (current == NULL) {
-			return LDB_ERR_UNWILLING_TO_PERFORM;
-		}
-	}
-
-	/* is this a brand new paged request ? */
-	if (current == NULL) {
-
-		/* save controls list and remove this one from the list */
-		if (!save_controls(control, req, &saved_controls)) {
-			return LDB_ERR_OTHER;
-		}
-
-		/* perform the search */
-		ret = ldb_next_request(module, req);
-
-		/* restore original controls list */
-		if (req->controls) talloc_free(req->controls);
-		req->controls = saved_controls;
-
-		if (ret != LDB_SUCCESS) {
-			return ret;
-		}
-
-		/* create a new entry in the cache */
-		current = new_store(private_data);
-		if (!current) {
-			return LDB_ERR_OTHER;
-		}
-
-		/* steal the search result */
-		current->result = talloc_steal(current, req->op.search.res);
-		req->op.search.res = NULL;
-	}
-
-	/* create a container for the next batch of results */
-	paged_result = talloc(current, struct ldb_result);
-	if (!paged_result) {
-		return LDB_ERR_OTHER;
-	}
-	paged_result->count = 0;
-	paged_result->msgs = NULL;
-	paged_result->controls = NULL;
-
-	/* check if it is an abandon */
-	if (paged_ctrl->size == 0) {
-		req->op.search.res = talloc_steal(private_data, paged_result);
-		talloc_free(current);
-		return LDB_SUCCESS;
-	}
-
-	/* return a batch of results */
-		
-	paged_result->controls = talloc_array(paged_result, struct ldb_control *, 2);
-	if (!paged_result->controls) {
-		talloc_free(paged_result);
-		return LDB_ERR_OTHER;
-	}
-
-	paged_result->controls[0] = talloc(paged_result->controls, struct ldb_control);
-	if (!paged_result->controls[0]) {
-		talloc_free(paged_result);
-		return LDB_ERR_OTHER;
-	}
-	paged_result->controls[0]->oid = talloc_strdup(paged_result->controls[0], LDB_CONTROL_PAGED_RESULTS_OID);
-	paged_result->controls[0]->critical = 0;
-	paged_result->controls[1] = NULL;
-
-	paged_ret = talloc(paged_result->controls[0], struct ldb_paged_control);
-	if (!paged_ret) {
-		talloc_free(paged_result);
-		return LDB_ERR_OTHER;
-	}
-	paged_result->controls[0]->data = paged_ret;
-
-	if (paged_ctrl->size >= current->result->count) {
-		paged_ret->size = 0;
-		paged_ret->cookie = NULL;
-		paged_ret->cookie_len = 0;
-		paged_result->count = current->result->count;
-		current->result->count = 0;
-	} else {
-		paged_ret->size = current->result->count;
-		paged_ret->cookie = talloc_strdup(paged_ret, current->cookie);
-		paged_ret->cookie_len = strlen(paged_ret->cookie) + 1;
-		paged_result->count = paged_ctrl->size;
-		current->result->count -= paged_ctrl->size;
-	}
-
-	paged_result->msgs = talloc_array(paged_result, struct ldb_message *, paged_result->count + 1);
-	if (!paged_result->msgs) {
-		talloc_free(paged_result);
-		return LDB_ERR_OTHER;
-	}
-	for (i = 0; i < paged_result->count; i++) {
-		paged_result->msgs[i] = talloc_steal(paged_result->msgs, current->result->msgs[current->num_sent + i]);
-	}
-	current->num_sent += paged_result->count;
-	paged_result->msgs[paged_result->count] = NULL;
-
-	req->op.search.res = paged_result;
-
-	return LDB_SUCCESS;	
-}
-
 struct paged_async_context {
 	struct ldb_module *module;
 	void *up_context;
@@ -654,28 +525,6 @@ static int paged_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait
 	return ret;
 }
 
-static int paged_request(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_PAGED_RESULTS_OID);
-	if (control == NULL) {
-		/* not found go on */
-		return ldb_next_request(module, req);
-	}
-
-	switch (req->operation) {
-
-	case LDB_REQ_SEARCH:
-		return paged_search_sync(module, control, req);
-
-	default:
-		return LDB_ERR_PROTOCOL_ERROR;
-
-	}
-}
-
 static int paged_request_init(struct ldb_module *module)
 {
 	struct private_data *data;
@@ -714,7 +563,6 @@ static int paged_request_init(struct ldb_module *module)
 static const struct ldb_module_ops paged_ops = {
 	.name           = "paged_results",
 	.search         = paged_search,
-	.request        = paged_request,
 	.async_wait     = paged_async_wait,
 	.init_context 	= paged_request_init
 };
diff --git a/source4/lib/ldb/modules/rdn_name.c b/source4/lib/ldb/modules/rdn_name.c
index 2004002e38..059e7843cd 100644
--- a/source4/lib/ldb/modules/rdn_name.c
+++ b/source4/lib/ldb/modules/rdn_name.c
@@ -53,85 +53,6 @@ static struct ldb_message_element *rdn_name_find_attribute(const struct ldb_mess
 	return NULL;
 }
 
-static int rdn_name_add_sync(struct ldb_module *module, struct ldb_request *req)
-{
-	const struct ldb_message *msg = req->op.add.message;
-	struct ldb_message *msg2;
-	struct ldb_message_element *attribute;
-	struct ldb_dn_component *rdn;
-	int i, ret;
-
-	ldb_debug(module->ldb, LDB_DEBUG_TRACE, "rdn_name_add_record\n");
-
-	/* do not manipulate our control entries */
-	if (ldb_dn_is_special(msg->dn)) {
-		return ldb_next_request(module, req);
-	}
-
-	msg2 = talloc(module, struct ldb_message);
-	if (!msg2) {
-		return -1;
-	}
-
-	msg2->dn = msg->dn;
-	msg2->num_elements = msg->num_elements;
-	msg2->private_data = msg->private_data;
-	msg2->elements = talloc_array(msg2, struct ldb_message_element, msg2->num_elements);
-	for (i = 0; i < msg2->num_elements; i++) {
-		msg2->elements[i] = msg->elements[i];
-	}
-
-	rdn = ldb_dn_get_rdn(msg2, msg2->dn);
-	if (!rdn) {
-		talloc_free(msg2);
-		return -1;
-	}
-	
-	/* Perhaps someone above us tried to set this? */
-	if ((attribute = rdn_name_find_attribute(msg, "name")) != NULL ) {
-		attribute->num_values = 0;
-	}
-
-	if (ldb_msg_add_value(msg2, "name", &rdn->value) != 0) {
-		talloc_free(msg2);
-		return -1;
-	}
-
-	attribute = rdn_name_find_attribute(msg2, rdn->name);
-
-	if (!attribute) {
-		if (ldb_msg_add_value(msg2, rdn->name, &rdn->value) != 0) {
-			talloc_free(msg2);
-			return -1;
-		}
-	} else {
-		const struct ldb_attrib_handler *handler
-			= ldb_attrib_handler(module->ldb, rdn->name);
-		for (i=0; i < attribute->num_values; i++) {
-			if (handler->comparison_fn(module->ldb, msg2, &rdn->value, &attribute->values[i]) == 0) {
-				/* overwrite so it matches in case */
-				attribute->values[i] = rdn->value;
-				break;
-			}
-		}
-		if (i == attribute->num_values) {
-			ldb_debug_set(module->ldb, LDB_DEBUG_FATAL, 
-				      "RDN mismatch on %s: %s", 
-				      ldb_dn_linearize(msg2, msg2->dn), rdn->name);
-			talloc_free(msg2);
-			return -1;
-		}
-	}
-
-	req->op.add.message = msg2;
-	ret = ldb_next_request(module, req);
-	req->op.add.message = msg;
-
-	talloc_free(msg2);
-
-	return ret;
-}
-
 static int rdn_name_add(struct ldb_module *module, struct ldb_request *req)
 {
 	struct ldb_request *down_req;
@@ -402,24 +323,10 @@ static int rdn_name_async_wait(struct ldb_async_handle *handle, enum ldb_async_w
 	}
 }
 
-static int rdn_name_request(struct ldb_module *module, struct ldb_request *req)
-{
-	switch (req->operation) {
-
-	case LDB_REQ_ADD:
-		return rdn_name_add_sync(module, req);
-
-	default:
-		return ldb_next_request(module, req);
-
-	}
-}
-
 static const struct ldb_module_ops rdn_name_ops = {
 	.name              = "rdn_name",
 	.add               = rdn_name_add,
 	.rename            = rdn_name_rename,
-	.request           = rdn_name_request,
 	.async_wait        = rdn_name_async_wait
 };
 
diff --git a/source4/lib/ldb/modules/sort.c b/source4/lib/ldb/modules/sort.c
index 6905417e95..2f9d7dfc96 100644
--- a/source4/lib/ldb/modules/sort.c
+++ b/source4/lib/ldb/modules/sort.c
@@ -196,91 +196,7 @@ static int sort_compare_async(struct ldb_message **msg1, struct ldb_message **ms
 	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_control *control, struct ldb_request *req)
-{
-	struct ldb_result *sort_result = NULL;
-	struct ldb_control **saved_controls;
-	struct ldb_server_sort_control **sort_ctrls;
-	int ret, result = 0;
-	int do_sort = 1;
-
-	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)
-		do_sort = 0;
-		
-	if (!do_sort && control->critical) {
-		sort_result = talloc_zero(req, struct ldb_result);
-		if (!sort_result)
-			return LDB_ERR_OPERATIONS_ERROR;
-
-		req->op.search.res = sort_result;
-	
-		/* 53 = unwilling to perform */
-		if ((ret = build_response(sort_result, &sort_result->controls, 53, "sort control is not complete yet")) != LDB_SUCCESS) {
-			return ret;
-		}
-
-		return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
-	}
-
-	/* save it locally and remove it from the list */
-	if (!save_controls(control, req, &saved_controls)) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	ret = ldb_next_request(module, req);
-
-	if (req->controls) talloc_free(req->controls);
-	req->controls = saved_controls;
-
-	if (ret != LDB_SUCCESS) {
-		return ret;
-	}
-
-	sort_result = req->op.search.res;
-
-	/* SORT HERE */
-	if (do_sort) {
-		struct opaque *data;
-	       
-		data = talloc(module, struct opaque);
-		if (!data)
-			return LDB_ERR_OPERATIONS_ERROR;
-		
-		data->attribute = sort_ctrls[0]->attributeName;
-		data->reverse = sort_ctrls[0]->reverse;
-		data->ldb = module->ldb;
-		data->h = ldb_attrib_handler(data->ldb, data->attribute);
-		data->result = 0;
-
-		ldb_qsort(sort_result->msgs,
-			  sort_result->count,
-			  sizeof(struct ldb_message *),
-			  data,
-			  (ldb_qsort_cmp_fn_t)sort_compare);
-
-		result = data->result;
-
-		talloc_free(data);
-	} else {
-		result = 53;
-	}
-
-	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)
+static int server_sort_search_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares)
 {
 	struct sort_async_context *ac = NULL;
 	
@@ -340,7 +256,7 @@ error:
 	return LDB_ERR_OPERATIONS_ERROR;
 }
 
-static int server_sort_search_async(struct ldb_module *module, struct ldb_request *req)
+static int server_sort_search(struct ldb_module *module, struct ldb_request *req)
 {
 	struct ldb_control *control;
 	struct ldb_server_sort_control **sort_ctrls;
@@ -425,7 +341,7 @@ static int server_sort_search_async(struct ldb_module *module, struct ldb_reques
 	}
 
 	ac->req->async.context = ac;
-	ac->req->async.callback = server_sort_search_async_callback;
+	ac->req->async.callback = server_sort_search_callback;
 	ac->req->async.timeout = req->async.timeout;
 
 	req->async.handle = h;
@@ -433,7 +349,7 @@ static int server_sort_search_async(struct ldb_module *module, struct ldb_reques
 	return ldb_next_request(module, ac->req);
 }
 
-static int server_sort_async_results(struct ldb_async_handle *handle)
+static int server_sort_results(struct ldb_async_handle *handle)
 {
 	struct sort_async_context *ac;
 	struct ldb_async_result *ares;
@@ -527,34 +443,12 @@ static int server_sort_async_wait(struct ldb_async_handle *handle, enum ldb_asyn
 	}
 
 	if (handle->state == LDB_ASYNC_DONE) {
-		ret = server_sort_async_results(handle);
+		ret = server_sort_results(handle);
 	}
 
 	return ret;
 }
 
-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, control, req);
-
-	default:
-		return LDB_ERR_PROTOCOL_ERROR;
-
-	}
-}
-
 static int server_sort_init(struct ldb_module *module)
 {
 	struct ldb_request *req;
@@ -582,8 +476,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,
-	.request      	   = server_sort,
+	.search            = server_sort_search,
 	.async_wait        = server_sort_async_wait,
 	.init_context	   = server_sort_init
 };