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
34 #include "ldb_includes.h"
37 struct ldb_context
*ldb
;
38 const struct ldb_attrib_handler
*h
;
39 const char *attribute
;
45 struct ldb_module
*module
;
51 struct ldb_request
*req
;
52 struct ldb_message
**msgs
;
57 const struct ldb_schema_attribute
*a
;
61 static int build_response(void *mem_ctx
, struct ldb_control
***ctrls
, int result
, const char *desc
)
63 struct ldb_control
**controls
;
64 struct ldb_sort_resp_control
*resp
;
69 for (i
= 0; controls
[i
]; i
++);
70 controls
= talloc_realloc(mem_ctx
, controls
, struct ldb_control
*, i
+ 2);
73 controls
= talloc_array(mem_ctx
, struct ldb_control
*, 2);
76 return LDB_ERR_OPERATIONS_ERROR
;
81 controls
[i
] = talloc(controls
, struct ldb_control
);
83 return LDB_ERR_OPERATIONS_ERROR
;
85 controls
[i
]->oid
= LDB_CONTROL_SORT_RESP_OID
;
86 controls
[i
]->critical
= 0;
88 resp
= talloc(controls
[i
], struct ldb_sort_resp_control
);
90 return LDB_ERR_OPERATIONS_ERROR
;
92 resp
->result
= result
;
93 resp
->attr_desc
= talloc_strdup(resp
, desc
);
95 if (! resp
->attr_desc
)
96 return LDB_ERR_OPERATIONS_ERROR
;
98 controls
[i
]->data
= resp
;
103 static int sort_compare(struct ldb_message
**msg1
, struct ldb_message
**msg2
, void *opaque
)
105 struct sort_context
*ac
= talloc_get_type(opaque
, struct sort_context
);
106 struct ldb_message_element
*el1
, *el2
;
108 if (!ac
|| ac
->sort_result
!= 0) {
109 /* an error occurred previously,
110 * let's exit the sorting by returning always 0 */
114 el1
= ldb_msg_find_element(*msg1
, ac
->attributeName
);
115 el2
= ldb_msg_find_element(*msg2
, ac
->attributeName
);
118 /* the attribute was not found return and
120 ac
->sort_result
= LDB_ERR_UNWILLING_TO_PERFORM
;
125 return ac
->a
->syntax
->comparison_fn(ac
->module
->ldb
, ac
, &el2
->values
[0], &el1
->values
[0]);
127 return ac
->a
->syntax
->comparison_fn(ac
->module
->ldb
, ac
, &el1
->values
[0], &el2
->values
[0]);
130 static int server_sort_results(struct sort_context
*ac
)
132 struct ldb_reply
*ares
;
135 ac
->a
= ldb_schema_attribute_by_name(ac
->module
->ldb
, ac
->attributeName
);
138 ldb_qsort(ac
->msgs
, ac
->num_msgs
,
139 sizeof(struct ldb_message
*),
140 ac
, (ldb_qsort_cmp_fn_t
)sort_compare
);
142 if (ac
->sort_result
!= LDB_SUCCESS
) {
143 return ac
->sort_result
;
146 for (i
= 0; i
< ac
->num_msgs
; i
++) {
147 ares
= talloc_zero(ac
, struct ldb_reply
);
149 return LDB_ERR_OPERATIONS_ERROR
;
152 ares
->type
= LDB_REPLY_ENTRY
;
153 ares
->message
= talloc_move(ares
, &ac
->msgs
[i
]);
155 ret
= ldb_module_send_entry(ac
->req
, ares
->message
, ares
->controls
);
156 if (ret
!= LDB_SUCCESS
) {
161 for (i
= 0; i
< ac
->num_refs
; i
++) {
162 ares
= talloc_zero(ac
, struct ldb_reply
);
164 return LDB_ERR_OPERATIONS_ERROR
;
167 ares
->type
= LDB_REPLY_REFERRAL
;
168 ares
->referral
= talloc_move(ares
, &ac
->referrals
[i
]);
170 ret
= ldb_module_send_referral(ac
->req
, ares
->referral
);
171 if (ret
!= LDB_SUCCESS
) {
179 static int server_sort_search_callback(struct ldb_request
*req
, struct ldb_reply
*ares
)
181 struct sort_context
*ac
;
184 ac
= talloc_get_type(req
->context
, struct sort_context
);
187 return ldb_module_done(ac
->req
, NULL
, NULL
,
188 LDB_ERR_OPERATIONS_ERROR
);
190 if (ares
->error
!= LDB_SUCCESS
) {
191 return ldb_module_done(ac
->req
, ares
->controls
,
192 ares
->response
, ares
->error
);
195 switch (ares
->type
) {
196 case LDB_REPLY_ENTRY
:
197 ac
->msgs
= talloc_realloc(ac
, ac
->msgs
, struct ldb_message
*, ac
->num_msgs
+ 2);
200 ldb_oom(ac
->module
->ldb
);
201 return ldb_module_done(ac
->req
, NULL
, NULL
,
202 LDB_ERR_OPERATIONS_ERROR
);
205 ac
->msgs
[ac
->num_msgs
] = talloc_steal(ac
->msgs
, ares
->message
);
207 ac
->msgs
[ac
->num_msgs
] = NULL
;
211 case LDB_REPLY_REFERRAL
:
212 ac
->referrals
= talloc_realloc(ac
, ac
->referrals
, char *, ac
->num_refs
+ 2);
213 if (! ac
->referrals
) {
215 ldb_oom(ac
->module
->ldb
);
216 return ldb_module_done(ac
->req
, NULL
, NULL
,
217 LDB_ERR_OPERATIONS_ERROR
);
220 ac
->referrals
[ac
->num_refs
] = talloc_steal(ac
->referrals
, ares
->referral
);
222 ac
->referrals
[ac
->num_refs
] = NULL
;
228 ret
= server_sort_results(ac
);
229 return ldb_module_done(ac
->req
, ares
->controls
,
230 ares
->response
, ret
);
237 static int server_sort_search(struct ldb_module
*module
, struct ldb_request
*req
)
239 struct ldb_control
*control
;
240 struct ldb_server_sort_control
**sort_ctrls
;
241 struct ldb_control
**saved_controls
;
242 struct ldb_control
**controls
;
243 struct ldb_request
*down_req
;
244 struct sort_context
*ac
;
247 /* check if there's a paged request control */
248 control
= ldb_request_get_control(req
, LDB_CONTROL_SERVER_SORT_OID
);
249 if (control
== NULL
) {
250 /* not found go on */
251 return ldb_next_request(module
, req
);
254 ac
= talloc_zero(req
, struct sort_context
);
256 ldb_oom(module
->ldb
);
257 return LDB_ERR_OPERATIONS_ERROR
;
263 sort_ctrls
= talloc_get_type(control
->data
, struct ldb_server_sort_control
*);
265 return LDB_ERR_PROTOCOL_ERROR
;
268 /* FIXME: we do not support more than one attribute for sorting right now */
269 /* FIXME: we need to check if the attribute type exist or return an error */
271 if (sort_ctrls
[1] != NULL
) {
272 if (control
->critical
) {
274 /* callback immediately */
275 ret
= build_response(req
, &controls
,
276 LDB_ERR_UNWILLING_TO_PERFORM
,
277 "sort control is not complete yet");
278 if (ret
!= LDB_SUCCESS
) {
279 return ldb_module_done(req
, NULL
, NULL
,
280 LDB_ERR_OPERATIONS_ERROR
);
283 return ldb_module_done(req
, controls
, NULL
, ret
);
285 /* just pass the call down and don't do any sorting */
286 return ldb_next_request(module
, req
);
290 ac
->attributeName
= sort_ctrls
[0]->attributeName
;
291 ac
->orderingRule
= sort_ctrls
[0]->orderingRule
;
292 ac
->reverse
= sort_ctrls
[0]->reverse
;
294 ret
= ldb_build_search_req_ex(&down_req
, module
->ldb
, ac
,
296 req
->op
.search
.scope
,
298 req
->op
.search
.attrs
,
301 server_sort_search_callback
,
303 if (ret
!= LDB_SUCCESS
) {
304 return LDB_ERR_OPERATIONS_ERROR
;
307 /* save it locally and remove it from the list */
308 /* we do not need to replace them later as we
309 * are keeping the original req intact */
310 if (!save_controls(control
, down_req
, &saved_controls
)) {
311 return LDB_ERR_OPERATIONS_ERROR
;
314 return ldb_next_request(module
, down_req
);
317 static int server_sort_init(struct ldb_module
*module
)
321 ret
= ldb_mod_register_control(module
, LDB_CONTROL_SERVER_SORT_OID
);
322 if (ret
!= LDB_SUCCESS
) {
323 ldb_debug(module
->ldb
, LDB_DEBUG_WARNING
,
325 "Unable to register control with rootdse!\n");
328 return ldb_next_init(module
);
331 const struct ldb_module_ops ldb_server_sort_module_ops
= {
332 .name
= "server_sort",
333 .search
= server_sort_search
,
334 .init_context
= server_sort_init