63f9ee67523101dd73995b37d0cd84fa7286d6a0
[ira/wip.git] / source3 / lib / ldb / modules / paged_results.c
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
38 struct 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
46 struct private_data;
47
48 struct 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
70 struct private_data {
71
72         int next_free_id;
73         struct results_store *store;
74         
75 };
76
77 int store_destructor(struct results_store *store);
78
79 int 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
95 static 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
133 struct 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
143 static 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
177 static 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
227 error:
228         talloc_free(ares);
229         return LDB_ERR_OPERATIONS_ERROR;
230 }
231
232 static 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
339 static 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
446 static 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
522 static 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
555 static 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
562 int ldb_paged_results_init(void)
563 {
564         return ldb_register_module(&paged_ops);
565 }
566