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 if (ret
!= LDB_SUCCESS
) {
323 /* save it locally and remove it from the list */
324 /* we do not need to replace them later as we
325 * are keeping the original req intact */
326 if (!ldb_save_controls(control
, down_req
, &saved_controls
)) {
327 return LDB_ERR_OPERATIONS_ERROR
;
330 return ldb_next_request(module
, down_req
);
333 static int server_sort_init(struct ldb_module
*module
)
335 struct ldb_context
*ldb
;
338 ldb
= ldb_module_get_ctx(module
);
340 ret
= ldb_mod_register_control(module
, LDB_CONTROL_SERVER_SORT_OID
);
341 if (ret
!= LDB_SUCCESS
) {
342 ldb_debug(ldb
, LDB_DEBUG_WARNING
,
344 "Unable to register control with rootdse!");
347 return ldb_next_init(module
);
350 static const struct ldb_module_ops ldb_server_sort_module_ops
= {
351 .name
= "server_sort",
352 .search
= server_sort_search
,
353 .init_context
= server_sort_init
356 int ldb_server_sort_init(const char *version
)
358 LDB_MODULE_CHECK_VERSION(version
);
359 return ldb_register_module(&ldb_server_sort_module_ops
);