4 Copyright (C) Simo Sorce 2005-2008
6 ** NOTE! The following LGPL license applies to the ldb
7 ** library. This does NOT imply that all of Samba is released
10 This library is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 version 3 of the License, or (at your option) any later version.
15 This library is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 * Component: ldb server side sort control module
29 * Description: this module sorts the results of a search
35 #include "system/filesys.h"
36 #include "system/time.h"
37 #include "ldb_module.h"
40 struct ldb_context *ldb;
41 const struct ldb_attrib_handler *h;
42 const char *attribute;
48 struct ldb_module *module;
50 const char *attributeName;
51 const char *orderingRule;
54 struct ldb_request *req;
55 struct ldb_message **msgs;
57 unsigned int num_msgs;
58 unsigned int num_refs;
60 const struct ldb_schema_attribute *a;
64 static int build_response(void *mem_ctx, struct ldb_control ***ctrls, int result, const char *desc)
66 struct ldb_control **controls;
67 struct ldb_sort_resp_control *resp;
72 for (i = 0; controls[i]; i++);
73 controls = talloc_realloc(mem_ctx, controls, struct ldb_control *, i + 2);
76 controls = talloc_array(mem_ctx, struct ldb_control *, 2);
79 return LDB_ERR_OPERATIONS_ERROR;
84 controls[i] = talloc(controls, struct ldb_control);
86 return LDB_ERR_OPERATIONS_ERROR;
88 controls[i]->oid = LDB_CONTROL_SORT_RESP_OID;
89 controls[i]->critical = 0;
91 resp = talloc(controls[i], struct ldb_sort_resp_control);
93 return LDB_ERR_OPERATIONS_ERROR;
95 resp->result = result;
96 resp->attr_desc = talloc_strdup(resp, desc);
98 if (! resp->attr_desc )
99 return LDB_ERR_OPERATIONS_ERROR;
101 controls[i]->data = resp;
106 static int sort_compare(struct ldb_message **msg1, struct ldb_message **msg2, void *opaque)
108 struct sort_context *ac = talloc_get_type(opaque, struct sort_context);
109 struct ldb_message_element *el1, *el2;
110 struct ldb_context *ldb;
112 ldb = ldb_module_get_ctx(ac->module);
114 if (ac->sort_result != 0) {
115 /* an error occurred previously,
116 * let's exit the sorting by returning always 0 */
120 el1 = ldb_msg_find_element(*msg1, ac->attributeName);
121 el2 = ldb_msg_find_element(*msg2, ac->attributeName);
134 return ac->a->syntax->comparison_fn(ldb, ac, &el2->values[0], &el1->values[0]);
136 return ac->a->syntax->comparison_fn(ldb, ac, &el1->values[0], &el2->values[0]);
139 static int server_sort_results(struct sort_context *ac)
141 struct ldb_context *ldb;
142 struct ldb_reply *ares;
146 ldb = ldb_module_get_ctx(ac->module);
148 ac->a = ldb_schema_attribute_by_name(ldb, ac->attributeName);
151 LDB_TYPESAFE_QSORT(ac->msgs, ac->num_msgs, ac, sort_compare);
153 if (ac->sort_result != LDB_SUCCESS) {
154 return ac->sort_result;
157 for (i = 0; i < ac->num_msgs; i++) {
158 ares = talloc_zero(ac, struct ldb_reply);
160 return LDB_ERR_OPERATIONS_ERROR;
163 ares->type = LDB_REPLY_ENTRY;
164 ares->message = talloc_move(ares, &ac->msgs[i]);
166 ret = ldb_module_send_entry(ac->req, ares->message, ares->controls);
167 if (ret != LDB_SUCCESS) {
172 for (i = 0; i < ac->num_refs; i++) {
173 ares = talloc_zero(ac, struct ldb_reply);
175 return LDB_ERR_OPERATIONS_ERROR;
178 ares->type = LDB_REPLY_REFERRAL;
179 ares->referral = talloc_move(ares, &ac->referrals[i]);
181 ret = ldb_module_send_referral(ac->req, ares->referral);
182 if (ret != LDB_SUCCESS) {
190 static int server_sort_search_callback(struct ldb_request *req, struct ldb_reply *ares)
192 struct sort_context *ac;
193 struct ldb_context *ldb;
196 ac = talloc_get_type(req->context, struct sort_context);
197 ldb = ldb_module_get_ctx(ac->module);
200 return ldb_module_done(ac->req, NULL, NULL,
201 LDB_ERR_OPERATIONS_ERROR);
203 if (ares->error != LDB_SUCCESS) {
204 return ldb_module_done(ac->req, ares->controls,
205 ares->response, ares->error);
208 switch (ares->type) {
209 case LDB_REPLY_ENTRY:
210 ac->msgs = talloc_realloc(ac, ac->msgs, struct ldb_message *, ac->num_msgs + 2);
214 return ldb_module_done(ac->req, NULL, NULL,
215 LDB_ERR_OPERATIONS_ERROR);
218 ac->msgs[ac->num_msgs] = talloc_steal(ac->msgs, ares->message);
220 ac->msgs[ac->num_msgs] = NULL;
224 case LDB_REPLY_REFERRAL:
225 ac->referrals = talloc_realloc(ac, ac->referrals, char *, ac->num_refs + 2);
226 if (! ac->referrals) {
229 return ldb_module_done(ac->req, NULL, NULL,
230 LDB_ERR_OPERATIONS_ERROR);
233 ac->referrals[ac->num_refs] = talloc_steal(ac->referrals, ares->referral);
235 ac->referrals[ac->num_refs] = NULL;
241 ret = server_sort_results(ac);
242 return ldb_module_done(ac->req, ares->controls,
243 ares->response, ret);
250 static int server_sort_search(struct ldb_module *module, struct ldb_request *req)
252 struct ldb_control *control;
253 struct ldb_server_sort_control **sort_ctrls;
254 struct ldb_control **saved_controls;
255 struct ldb_control **controls;
256 struct ldb_request *down_req;
257 struct sort_context *ac;
258 struct ldb_context *ldb;
261 ldb = ldb_module_get_ctx(module);
263 /* check if there's a server sort control */
264 control = ldb_request_get_control(req, LDB_CONTROL_SERVER_SORT_OID);
265 if (control == NULL) {
266 /* not found go on */
267 return ldb_next_request(module, req);
270 ac = talloc_zero(req, struct sort_context);
273 return LDB_ERR_OPERATIONS_ERROR;
279 sort_ctrls = talloc_get_type(control->data, struct ldb_server_sort_control *);
281 return LDB_ERR_PROTOCOL_ERROR;
284 /* FIXME: we do not support more than one attribute for sorting right now */
285 /* FIXME: we need to check if the attribute type exist or return an error */
287 if (sort_ctrls[1] != NULL) {
288 if (control->critical) {
290 /* callback immediately */
291 ret = build_response(req, &controls,
292 LDB_ERR_UNWILLING_TO_PERFORM,
293 "sort control is not complete yet");
294 if (ret != LDB_SUCCESS) {
295 return ldb_module_done(req, NULL, NULL,
296 LDB_ERR_OPERATIONS_ERROR);
299 return ldb_module_done(req, controls, NULL, ret);
301 /* just pass the call down and don't do any sorting */
302 return ldb_next_request(module, req);
306 ac->attributeName = sort_ctrls[0]->attributeName;
307 ac->orderingRule = sort_ctrls[0]->orderingRule;
308 ac->reverse = sort_ctrls[0]->reverse;
310 ret = ldb_build_search_req_ex(&down_req, ldb, ac,
312 req->op.search.scope,
314 req->op.search.attrs,
317 server_sort_search_callback,
319 ldb_req_mark_trusted(down_req);
320 if (ret != LDB_SUCCESS) {
324 /* save it locally and remove it from the list */
325 /* we do not need to replace them later as we
326 * are keeping the original req intact */
327 if (!ldb_save_controls(control, down_req, &saved_controls)) {
328 return LDB_ERR_OPERATIONS_ERROR;
331 return ldb_next_request(module, down_req);
334 static int server_sort_init(struct ldb_module *module)
336 struct ldb_context *ldb;
339 ldb = ldb_module_get_ctx(module);
341 ret = ldb_mod_register_control(module, LDB_CONTROL_SERVER_SORT_OID);
342 if (ret != LDB_SUCCESS) {
343 ldb_debug(ldb, LDB_DEBUG_WARNING,
345 "Unable to register control with rootdse!");
348 return ldb_next_init(module);
351 static const struct ldb_module_ops ldb_server_sort_module_ops = {
352 .name = "server_sort",
353 .search = server_sort_search,
354 .init_context = server_sort_init
357 int ldb_server_sort_init(const char *version)
359 LDB_MODULE_CHECK_VERSION(version);
360 return ldb_register_module(&ldb_server_sort_module_ops);