source: vendor/current/source3/lib/ldb/modules/paged_results.c@ 414

Last change on this file since 414 was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 13.2 KB
Line 
1/*
2 ldb database library
3
4 Copyright (C) Simo Sorce 2005-2006
5
6 ** NOTE! The following LGPL license applies to the ldb
7 ** library. This does NOT imply that all of Samba is released
8 ** under the LGPL
9
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.
14
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.
19
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/>.
22*/
23
24/*
25 * Name: paged_result
26 *
27 * Component: ldb paged results control module
28 *
29 * Description: this module caches a complete search and sends back
30 * results in chunks as asked by the client
31 *
32 * Author: Simo Sorce
33 */
34
35#include "includes.h"
36#include "ldb/include/includes.h"
37
38struct message_store {
39 /* keep the whole ldb_reply as an optimization
40 * instead of freeing and talloc-ing the container
41 * on each result */
42 struct ldb_reply *r;
43 struct message_store *next;
44};
45
46struct private_data;
47
48struct results_store {
49
50 struct private_data *priv;
51
52 char *cookie;
53 time_t timestamp;
54
55 struct results_store *prev;
56 struct results_store *next;
57
58 struct message_store *first;
59 struct message_store *last;
60 int num_entries;
61
62 struct message_store *first_ref;
63 struct message_store *last_ref;
64
65 struct ldb_control **controls;
66
67 struct ldb_request *req;
68};
69
70struct private_data {
71
72 int next_free_id;
73 struct results_store *store;
74
75};
76
77int store_destructor(struct results_store *store);
78
79int store_destructor(struct results_store *store)
80{
81 if (store->prev) {
82 store->prev->next = store->next;
83 }
84 if (store->next) {
85 store->next->prev = store->prev;
86 }
87
88 if (store == store->priv->store) {
89 store->priv->store = NULL;
90 }
91
92 return 0;
93}
94
95static struct results_store *new_store(struct private_data *priv)
96{
97 struct results_store *newr;
98 int new_id = priv->next_free_id++;
99
100 /* TODO: we should have a limit on the number of
101 * outstanding paged searches
102 */
103
104 newr = talloc(priv, struct results_store);
105 if (!newr) return NULL;
106
107 newr->priv = priv;
108
109 newr->cookie = talloc_asprintf(newr, "%d", new_id);
110 if (!newr->cookie) {
111 talloc_free(newr);
112 return NULL;
113 }
114
115 newr->timestamp = time(NULL);
116
117 newr->first = NULL;
118 newr->num_entries = 0;
119 newr->first_ref = NULL;
120 newr->controls = NULL;
121
122 /* put this entry as first */
123 newr->prev = NULL;
124 newr->next = priv->store;
125 if (priv->store != NULL) priv->store->prev = newr;
126 priv->store = newr;
127
128 talloc_set_destructor(newr, store_destructor);
129
130 return newr;
131}
132
133struct paged_context {
134 struct ldb_module *module;
135 void *up_context;
136 int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
137
138 int size;
139
140 struct results_store *store;
141};
142
143static struct ldb_handle *init_handle(void *mem_ctx, struct ldb_module *module,
144 void *context,
145 int (*callback)(struct ldb_context *, void *, struct ldb_reply *))
146{
147 struct paged_context *ac;
148 struct ldb_handle *h;
149
150 h = talloc_zero(mem_ctx, struct ldb_handle);
151 if (h == NULL) {
152 ldb_set_errstring(module->ldb, "Out of Memory");
153 return NULL;
154 }
155
156 h->module = module;
157
158 ac = talloc_zero(h, struct paged_context);
159 if (ac == NULL) {
160 ldb_set_errstring(module->ldb, "Out of Memory");
161 talloc_free(h);
162 return NULL;
163 }
164
165 h->private_data = (void *)ac;
166
167 h->state = LDB_ASYNC_INIT;
168 h->status = LDB_SUCCESS;
169
170 ac->module = module;
171 ac->up_context = context;
172 ac->up_callback = callback;
173
174 return h;
175}
176
177static int paged_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
178{
179 struct paged_context *ac = NULL;
180
181 if (!context || !ares) {
182 ldb_set_errstring(ldb, "NULL Context or Result in callback");
183 goto error;
184 }
185
186 ac = talloc_get_type(context, struct paged_context);
187
188 if (ares->type == LDB_REPLY_ENTRY) {
189 if (ac->store->first == NULL) {
190 ac->store->first = ac->store->last = talloc(ac->store, struct message_store);
191 } else {
192 ac->store->last->next = talloc(ac->store, struct message_store);
193 ac->store->last = ac->store->last->next;
194 }
195 if (ac->store->last == NULL) {
196 goto error;
197 }
198
199 ac->store->num_entries++;
200
201 ac->store->last->r = talloc_steal(ac->store->last, ares);
202 ac->store->last->next = NULL;
203 }
204
205 if (ares->type == LDB_REPLY_REFERRAL) {
206 if (ac->store->first_ref == NULL) {
207 ac->store->first_ref = ac->store->last_ref = talloc(ac->store, struct message_store);
208 } else {
209 ac->store->last_ref->next = talloc(ac->store, struct message_store);
210 ac->store->last_ref = ac->store->last_ref->next;
211 }
212 if (ac->store->last_ref == NULL) {
213 goto error;
214 }
215
216 ac->store->last_ref->r = talloc_steal(ac->store->last, ares);
217 ac->store->last_ref->next = NULL;
218 }
219
220 if (ares->type == LDB_REPLY_DONE) {
221 ac->store->controls = talloc_move(ac->store, &ares->controls);
222 talloc_free(ares);
223 }
224
225 return LDB_SUCCESS;
226
227error:
228 talloc_free(ares);
229 return LDB_ERR_OPERATIONS_ERROR;
230}
231
232static int paged_search(struct ldb_module *module, struct ldb_request *req)
233{
234 struct ldb_control *control;
235 struct private_data *private_data;
236 struct ldb_paged_control *paged_ctrl;
237 struct ldb_control **saved_controls;
238 struct paged_context *ac;
239 struct ldb_handle *h;
240 int ret;
241
242 /* check if there's a paged request control */
243 control = get_control_from_list(req->controls, LDB_CONTROL_PAGED_RESULTS_OID);
244 if (control == NULL) {
245 /* not found go on */
246 return ldb_next_request(module, req);
247 }
248
249 private_data = talloc_get_type(module->private_data, struct private_data);
250
251 req->handle = NULL;
252
253 if (!req->callback || !req->context) {
254 ldb_set_errstring(module->ldb,
255 "Async interface called with NULL callback function or NULL context");
256 return LDB_ERR_OPERATIONS_ERROR;
257 }
258
259 paged_ctrl = talloc_get_type(control->data, struct ldb_paged_control);
260 if (!paged_ctrl) {
261 return LDB_ERR_PROTOCOL_ERROR;
262 }
263
264 h = init_handle(req, module, req->context, req->callback);
265 if (!h) {
266 return LDB_ERR_OPERATIONS_ERROR;
267 }
268 ac = talloc_get_type(h->private_data, struct paged_context);
269
270 ac->size = paged_ctrl->size;
271
272 /* check if it is a continuation search the store */
273 if (paged_ctrl->cookie_len == 0) {
274
275 ac->store = new_store(private_data);
276 if (ac->store == NULL) {
277 talloc_free(h);
278 return LDB_ERR_UNWILLING_TO_PERFORM;
279 }
280
281 ac->store->req = talloc(ac->store, struct ldb_request);
282 if (!ac->store->req)
283 return LDB_ERR_OPERATIONS_ERROR;
284
285 ac->store->req->operation = req->operation;
286 ac->store->req->op.search.base = req->op.search.base;
287 ac->store->req->op.search.scope = req->op.search.scope;
288 ac->store->req->op.search.tree = req->op.search.tree;
289 ac->store->req->op.search.attrs = req->op.search.attrs;
290 ac->store->req->controls = req->controls;
291
292 /* save it locally and remove it from the list */
293 /* we do not need to replace them later as we
294 * are keeping the original req intact */
295 if (!save_controls(control, ac->store->req, &saved_controls)) {
296 return LDB_ERR_OPERATIONS_ERROR;
297 }
298
299 ac->store->req->context = ac;
300 ac->store->req->callback = paged_search_callback;
301 ldb_set_timeout_from_prev_req(module->ldb, req, ac->store->req);
302
303 ret = ldb_next_request(module, ac->store->req);
304
305 } else {
306 struct results_store *current = NULL;
307
308 for (current = private_data->store; current; current = current->next) {
309 if (strcmp(current->cookie, paged_ctrl->cookie) == 0) {
310 current->timestamp = time(NULL);
311 break;
312 }
313 }
314 if (current == NULL) {
315 talloc_free(h);
316 return LDB_ERR_UNWILLING_TO_PERFORM;
317 }
318
319 ac->store = current;
320 ret = LDB_SUCCESS;
321 }
322
323 req->handle = h;
324
325 /* check if it is an abandon */
326 if (ac->size == 0) {
327 talloc_free(ac->store);
328 h->status = LDB_SUCCESS;
329 h->state = LDB_ASYNC_DONE;
330 return LDB_SUCCESS;
331 }
332
333 /* TODO: age out old outstanding requests */
334
335 return ret;
336
337}
338
339static int paged_results(struct ldb_handle *handle)
340{
341 struct paged_context *ac;
342 struct ldb_paged_control *paged;
343 struct ldb_reply *ares;
344 struct message_store *msg;
345 int i, num_ctrls, ret;
346
347 ac = talloc_get_type(handle->private_data, struct paged_context);
348
349 if (ac->store == NULL)
350 return LDB_ERR_OPERATIONS_ERROR;
351
352 while (ac->store->num_entries > 0 && ac->size > 0) {
353 msg = ac->store->first;
354 ret = ac->up_callback(ac->module->ldb, ac->up_context, msg->r);
355 if (ret != LDB_SUCCESS) {
356 handle->status = ret;
357 handle->state = LDB_ASYNC_DONE;
358 return ret;
359 }
360
361 ac->store->first = msg->next;
362 talloc_free(msg);
363 ac->store->num_entries--;
364 ac->size--;
365 }
366
367 handle->state = LDB_ASYNC_DONE;
368
369 while (ac->store->first_ref != NULL) {
370 msg = ac->store->first_ref;
371 ret = ac->up_callback(ac->module->ldb, ac->up_context, msg->r);
372 if (ret != LDB_SUCCESS) {
373 handle->status = ret;
374 handle->state = LDB_ASYNC_DONE;
375 return ret;
376 }
377
378 ac->store->first_ref = msg->next;
379 talloc_free(msg);
380 }
381
382 ares = talloc_zero(ac->store, struct ldb_reply);
383 if (ares == NULL) {
384 handle->status = LDB_ERR_OPERATIONS_ERROR;
385 return handle->status;
386 }
387 num_ctrls = 2;
388 i = 0;
389
390 if (ac->store->controls != NULL) {
391 ares->controls = ac->store->controls;
392 while (ares->controls[i]) i++; /* counting */
393
394 ares->controls = talloc_move(ares, &ac->store->controls);
395 num_ctrls += i;
396 }
397
398 ares->controls = talloc_realloc(ares, ares->controls, struct ldb_control *, num_ctrls);
399 if (ares->controls == NULL) {
400 handle->status = LDB_ERR_OPERATIONS_ERROR;
401 return handle->status;
402 }
403
404 ares->controls[i] = talloc(ares->controls, struct ldb_control);
405 if (ares->controls[i] == NULL) {
406 handle->status = LDB_ERR_OPERATIONS_ERROR;
407 return handle->status;
408 }
409
410 ares->controls[i]->oid = talloc_strdup(ares->controls[i], LDB_CONTROL_PAGED_RESULTS_OID);
411 if (ares->controls[i]->oid == NULL) {
412 handle->status = LDB_ERR_OPERATIONS_ERROR;
413 return handle->status;
414 }
415
416 ares->controls[i]->critical = 0;
417 ares->controls[i + 1] = NULL;
418
419 paged = talloc(ares->controls[i], struct ldb_paged_control);
420 if (paged == NULL) {
421 handle->status = LDB_ERR_OPERATIONS_ERROR;
422 return handle->status;
423 }
424
425 ares->controls[i]->data = paged;
426
427 if (ac->size > 0) {
428 paged->size = 0;
429 paged->cookie = NULL;
430 paged->cookie_len = 0;
431 } else {
432 paged->size = ac->store->num_entries;
433 paged->cookie = talloc_strdup(paged, ac->store->cookie);
434 paged->cookie_len = strlen(paged->cookie) + 1;
435 }
436
437 ares->type = LDB_REPLY_DONE;
438
439 ret = ac->up_callback(ac->module->ldb, ac->up_context, ares);
440
441 handle->status = ret;
442
443 return ret;
444}
445
446static int paged_wait(struct ldb_handle *handle, enum ldb_wait_type type)
447{
448 struct paged_context *ac;
449 int ret;
450
451 if (!handle || !handle->private_data) {
452 return LDB_ERR_OPERATIONS_ERROR;
453 }
454
455 if (handle->state == LDB_ASYNC_DONE) {
456 return handle->status;
457 }
458
459 handle->state = LDB_ASYNC_PENDING;
460
461 ac = talloc_get_type(handle->private_data, struct paged_context);
462
463 if (ac->store->req->handle->state == LDB_ASYNC_DONE) {
464 /* if lower level is finished we do not need to call it anymore */
465 /* return all we have until size == 0 or we empty storage */
466 ret = paged_results(handle);
467
468 /* we are done, if num_entries is zero free the storage
469 * as that mean we delivered the last batch */
470 if (ac->store->num_entries == 0) {
471 talloc_free(ac->store);
472 }
473
474 return ret;
475 }
476
477 if (type == LDB_WAIT_ALL) {
478 while (ac->store->req->handle->state != LDB_ASYNC_DONE) {
479 ret = ldb_wait(ac->store->req->handle, type);
480 if (ret != LDB_SUCCESS) {
481 handle->state = LDB_ASYNC_DONE;
482 handle->status = ret;
483 return ret;
484 }
485 }
486
487 ret = paged_results(handle);
488
489 /* we are done, if num_entries is zero free the storage
490 * as that mean we delivered the last batch */
491 if (ac->store->num_entries == 0) {
492 talloc_free(ac->store);
493 }
494
495 return ret;
496 }
497
498 ret = ldb_wait(ac->store->req->handle, type);
499 if (ret != LDB_SUCCESS) {
500 handle->state = LDB_ASYNC_DONE;
501 handle->status = ret;
502 return ret;
503 }
504
505 handle->status = ret;
506
507 if (ac->store->num_entries >= ac->size ||
508 ac->store->req->handle->state == LDB_ASYNC_DONE) {
509
510 ret = paged_results(handle);
511
512 /* we are done, if num_entries is zero free the storage
513 * as that mean we delivered the last batch */
514 if (ac->store->num_entries == 0) {
515 talloc_free(ac->store);
516 }
517 }
518
519 return ret;
520}
521
522static int paged_request_init(struct ldb_module *module)
523{
524 struct private_data *data;
525 struct ldb_request *req;
526 int ret;
527
528 data = talloc(module, struct private_data);
529 if (data == NULL) {
530 return LDB_ERR_OTHER;
531 }
532
533 data->next_free_id = 1;
534 data->store = NULL;
535 module->private_data = data;
536
537 req = talloc(module, struct ldb_request);
538 if (req == NULL) {
539 return LDB_ERR_OPERATIONS_ERROR;
540 }
541
542 req->operation = LDB_REQ_REGISTER_CONTROL;
543 req->op.reg_control.oid = LDB_CONTROL_PAGED_RESULTS_OID;
544 req->controls = NULL;
545
546 ret = ldb_request(module->ldb, req);
547 if (ret != LDB_SUCCESS) {
548 ldb_debug(module->ldb, LDB_DEBUG_WARNING, "paged_request: Unable to register control with rootdse!\n");
549 }
550
551 talloc_free(req);
552 return ldb_next_init(module);
553}
554
555static const struct ldb_module_ops paged_ops = {
556 .name = "paged_results",
557 .search = paged_search,
558 .wait = paged_wait,
559 .init_context = paged_request_init
560};
561
562int ldb_paged_results_init(void)
563{
564 return ldb_register_module(&paged_ops);
565}
566
Note: See TracBrowser for help on using the repository browser.