Add tldap paged searches, together with two helper routines
[ira/wip.git] / source3 / lib / tldap_util.c
1 /*
2    Unix SMB/CIFS implementation.
3    Infrastructure for async ldap client requests
4    Copyright (C) Volker Lendecke 2009
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21
22 bool tldap_entry_values(struct tldap_message *msg, const char *attribute,
23                         int *num_values, DATA_BLOB **values)
24 {
25         struct tldap_attribute *attributes;
26         int i, num_attributes;
27
28         if (!tldap_entry_attributes(msg, &num_attributes, &attributes)) {
29                 return false;
30         }
31
32         for (i=0; i<num_attributes; i++) {
33                 if (strequal(attribute, attributes[i].name)) {
34                         break;
35                 }
36         }
37         if (i == num_attributes) {
38                 return false;
39         }
40         *num_values = attributes[i].num_values;
41         *values = attributes[i].values;
42         return true;
43 }
44
45 bool tldap_get_single_valueblob(struct tldap_message *msg,
46                                 const char *attribute, DATA_BLOB *blob)
47 {
48         int num_values;
49         DATA_BLOB *values;
50
51         if (attribute == NULL) {
52                 return NULL;
53         }
54         if (!tldap_entry_values(msg, attribute, &num_values, &values)) {
55                 return NULL;
56         }
57         if (num_values != 1) {
58                 return NULL;
59         }
60         *blob = values[0];
61         return true;
62 }
63
64 char *tldap_talloc_single_attribute(struct tldap_message *msg,
65                                     const char *attribute,
66                                     TALLOC_CTX *mem_ctx)
67 {
68         DATA_BLOB val;
69         char *result;
70         size_t len;
71
72         if (!tldap_get_single_valueblob(msg, attribute, &val)) {
73                 return false;
74         }
75         if (!convert_string_talloc(mem_ctx, CH_UTF8, CH_UNIX,
76                                    val.data, val.length,
77                                    &result, &len, false)) {
78                 return NULL;
79         }
80         return result;
81 }
82
83 bool tldap_pull_binsid(struct tldap_message *msg, const char *attribute,
84                        struct dom_sid *sid)
85 {
86         DATA_BLOB val;
87
88         if (!tldap_get_single_valueblob(msg, attribute, &val)) {
89                 return false;
90         }
91         return sid_parse((char *)val.data, val.length, sid);
92 }
93
94 static bool tldap_add_blob_vals(TALLOC_CTX *mem_ctx, struct tldap_mod *mod,
95                                 int num_newvals, DATA_BLOB *newvals)
96 {
97         int num_values = talloc_array_length(mod->values);
98         int i;
99         DATA_BLOB *tmp;
100
101         tmp = talloc_realloc(mem_ctx, mod->values, DATA_BLOB,
102                              num_values + num_newvals);
103         if (tmp == NULL) {
104                 return false;
105         }
106         mod->values = tmp;
107
108         for (i=0; i<num_newvals; i++) {
109                 mod->values[i+num_values].data = (uint8_t *)talloc_memdup(
110                         mod->values, newvals[i].data, newvals[i].length);
111                 if (mod->values[i+num_values].data == NULL) {
112                         return false;
113                 }
114                 mod->values[i+num_values].length = newvals[i].length;
115         }
116         mod->num_values = num_values + num_newvals;
117         return true;
118 }
119
120 bool tldap_add_mod_blobs(TALLOC_CTX *mem_ctx, struct tldap_mod **pmods,
121                          int mod_op, const char *attrib,
122                          int num_newvals, DATA_BLOB *newvals)
123 {
124         struct tldap_mod new_mod;
125         struct tldap_mod *mods = *pmods;
126         struct tldap_mod *mod = NULL;
127         int i, num_mods;
128
129         if (mods == NULL) {
130                 mods = talloc_array(mem_ctx, struct tldap_mod, 0);
131         }
132         if (mods == NULL) {
133                 return false;
134         }
135
136         num_mods = talloc_array_length(mods);
137
138         for (i=0; i<num_mods; i++) {
139                 if ((mods[i].mod_op == mod_op)
140                     && strequal(mods[i].attribute, attrib)) {
141                         mod = &mods[i];
142                         break;
143                 }
144         }
145
146         if (mod == NULL) {
147                 new_mod.mod_op = mod_op;
148                 new_mod.attribute = talloc_strdup(mods, attrib);
149                 if (new_mod.attribute == NULL) {
150                         return false;
151                 }
152                 new_mod.num_values = 0;
153                 new_mod.values = NULL;
154                 mod = &new_mod;
155         }
156
157         if ((num_newvals != 0)
158             && !tldap_add_blob_vals(mods, mod, num_newvals, newvals)) {
159                 return false;
160         }
161
162         if (i == num_mods) {
163                 mods = talloc_realloc(talloc_tos(), mods, struct tldap_mod,
164                                       num_mods+1);
165                 if (mods == NULL) {
166                         return false;
167                 }
168                 mods[num_mods] = *mod;
169         }
170
171         *pmods = mods;
172         return true;
173 }
174
175 bool tldap_add_mod_str(TALLOC_CTX *mem_ctx, struct tldap_mod **pmods,
176                        int mod_op, const char *attrib, const char *str)
177 {
178         DATA_BLOB utf8;
179         bool ret;
180
181         if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_UTF8, str,
182                                    strlen(str), &utf8.data, &utf8.length,
183                                    false)) {
184                 return false;
185         }
186
187         ret = tldap_add_mod_blobs(mem_ctx, pmods, mod_op, attrib, 1, &utf8);
188         TALLOC_FREE(utf8.data);
189         return ret;
190 }
191
192 static bool tldap_make_mod_blob_int(struct tldap_message *existing,
193                                     TALLOC_CTX *mem_ctx,
194                                     int *pnum_mods, struct tldap_mod **pmods,
195                                     const char *attrib, DATA_BLOB newval,
196                                     int (*comparison)(const DATA_BLOB *d1,
197                                                       const DATA_BLOB *d2))
198 {
199         int num_values = 0;
200         DATA_BLOB *values = NULL;
201         DATA_BLOB oldval = data_blob_null;
202
203         if ((existing != NULL)
204             && tldap_entry_values(existing, attrib, &num_values, &values)) {
205
206                 if (num_values > 1) {
207                         /* can't change multivalue attributes atm */
208                         return false;
209                 }
210                 if (num_values == 1) {
211                         oldval = values[0];
212                 }
213         }
214
215         if ((oldval.data != NULL) && (newval.data != NULL)
216             && (comparison(&oldval, &newval) == 0)) {
217                 /* Believe it or not, but LDAP will deny a delete and
218                    an add at the same time if the values are the
219                    same... */
220                 DEBUG(10,("smbldap_make_mod_blob: attribute |%s| not "
221                           "changed.\n", attrib));
222                 return true;
223         }
224
225         if (oldval.data != NULL) {
226                 /* By deleting exactly the value we found in the entry this
227                  * should be race-free in the sense that the LDAP-Server will
228                  * deny the complete operation if somebody changed the
229                  * attribute behind our back. */
230                 /* This will also allow modifying single valued attributes in
231                  * Novell NDS. In NDS you have to first remove attribute and
232                  * then you could add new value */
233
234                 DEBUG(10, ("smbldap_make_mod_blob: deleting attribute |%s|\n",
235                            attrib));
236                 if (!tldap_add_mod_blobs(mem_ctx, pmods, TLDAP_MOD_DELETE,
237                                          attrib, 1, &oldval)) {
238                         return false;
239                 }
240         }
241
242         /* Regardless of the real operation (add or modify)
243            we add the new value here. We rely on deleting
244            the old value, should it exist. */
245
246         if (newval.data != NULL) {
247                 DEBUG(10, ("smbldap_make_mod: adding attribute |%s| value len "
248                            "%d\n", attrib, (int)newval.length));
249                 if (!tldap_add_mod_blobs(mem_ctx, pmods, TLDAP_MOD_ADD,
250                                          attrib, 1, &newval)) {
251                         return false;
252                 }
253         }
254         *pnum_mods = talloc_array_length(*pmods);
255         return true;
256 }
257
258 bool tldap_make_mod_blob(struct tldap_message *existing, TALLOC_CTX *mem_ctx,
259                          int *pnum_mods, struct tldap_mod **pmods,
260                          const char *attrib, DATA_BLOB newval)
261 {
262         return tldap_make_mod_blob_int(existing, mem_ctx, pnum_mods, pmods,
263                                        attrib, newval, data_blob_cmp);
264 }
265
266 static int compare_utf8_blobs(const DATA_BLOB *d1, const DATA_BLOB *d2)
267 {
268         char *s1, *s2;
269         size_t s1len, s2len;
270         int ret;
271
272         if (!convert_string_talloc(talloc_tos(), CH_UTF8, CH_UNIX, d1->data,
273                                    d1->length, &s1, &s1len, false)) {
274                 /* can't do much here */
275                 return 0;
276         }
277         if (!convert_string_talloc(talloc_tos(), CH_UTF8, CH_UNIX, d2->data,
278                                    d2->length, &s2, &s2len, false)) {
279                 /* can't do much here */
280                 TALLOC_FREE(s1);
281                 return 0;
282         }
283         ret = StrCaseCmp(s1, s2);
284         TALLOC_FREE(s2);
285         TALLOC_FREE(s1);
286         return ret;
287 }
288
289 bool tldap_make_mod_fmt(struct tldap_message *existing, TALLOC_CTX *mem_ctx,
290                         int *pnum_mods, struct tldap_mod **pmods,
291                         const char *attrib, const char *fmt, ...)
292 {
293         va_list ap;
294         char *newval;
295         bool ret;
296         DATA_BLOB blob = data_blob_null;
297
298         va_start(ap, fmt);
299         newval = talloc_vasprintf(talloc_tos(), fmt, ap);
300         va_end(ap);
301
302         if (newval == NULL) {
303                 return false;
304         }
305
306         blob.length = strlen(newval);
307         if (blob.length != 0) {
308                 blob.data = CONST_DISCARD(uint8_t *, newval);
309         }
310         ret = tldap_make_mod_blob_int(existing, mem_ctx, pnum_mods, pmods,
311                                       attrib, blob, compare_utf8_blobs);
312         TALLOC_FREE(newval);
313         return ret;
314 }
315
316 const char *tldap_errstr(TALLOC_CTX *mem_ctx, struct tldap_context *ld, int rc)
317 {
318         const char *ld_error = NULL;
319         char *res;
320
321         ld_error = tldap_msg_diagnosticmessage(tldap_ctx_lastmsg(ld));
322         res = talloc_asprintf(mem_ctx, "LDAP error %d (%s), %s", rc,
323                               tldap_err2string(rc),
324                               ld_error ? ld_error : "unknown");
325         return res;
326 }
327
328 int tldap_search_fmt(struct tldap_context *ld, const char *base, int scope,
329                      const char *attrs[], int num_attrs, int attrsonly,
330                      TALLOC_CTX *mem_ctx, struct tldap_message ***res,
331                      const char *fmt, ...)
332 {
333         va_list ap;
334         char *filter;
335         int ret;
336
337         va_start(ap, fmt);
338         filter = talloc_vasprintf(talloc_tos(), fmt, ap);
339         va_end(ap);
340
341         if (filter == NULL) {
342                 return TLDAP_NO_MEMORY;
343         }
344         ret = tldap_search(ld, base, scope, filter,
345                            attrs, num_attrs, attrsonly,
346                            NULL /*sctrls*/, 0, NULL /*cctrls*/, 0,
347                            0 /*timelimit*/, 0 /*sizelimit*/, 0 /*deref*/,
348                            mem_ctx, res, NULL);
349         TALLOC_FREE(filter);
350         return ret;
351 }
352
353 bool tldap_pull_uint64(struct tldap_message *msg, const char *attr,
354                        uint64_t *presult)
355 {
356         char *str;
357         uint64_t result;
358
359         str = tldap_talloc_single_attribute(msg, attr, talloc_tos());
360         if (str == NULL) {
361                 DEBUG(10, ("Could not find attribute %s\n", attr));
362                 return false;
363         }
364         result = strtoull(str, NULL, 10);
365         TALLOC_FREE(str);
366         *presult = result;
367         return true;
368 }
369
370 bool tldap_pull_uint32(struct tldap_message *msg, const char *attr,
371                        uint32_t *presult)
372 {
373         uint64_t result;
374
375         if (!tldap_pull_uint64(msg, attr, &result)) {
376                 return false;
377         }
378         *presult = (uint32_t)result;
379         return true;
380 }
381
382 struct tldap_fetch_rootdse_state {
383         struct tldap_context *ld;
384         struct tldap_message *rootdse;
385 };
386
387 static void tldap_fetch_rootdse_done(struct tevent_req *subreq);
388
389 struct tevent_req *tldap_fetch_rootdse_send(TALLOC_CTX *mem_ctx,
390                                             struct tevent_context *ev,
391                                             struct tldap_context *ld)
392 {
393         struct tevent_req *req, *subreq;
394         struct tldap_fetch_rootdse_state *state;
395         static const char *attrs[2] = { "*", "+" };
396
397         req = tevent_req_create(mem_ctx, &state,
398                                 struct tldap_fetch_rootdse_state);
399         if (req == NULL) {
400                 return NULL;
401         }
402         state->ld = ld;
403         state->rootdse = NULL;
404
405         subreq = tldap_search_send(
406                 mem_ctx, ev, ld, "", TLDAP_SCOPE_BASE, "(objectclass=*)",
407                 attrs, ARRAY_SIZE(attrs), 0, NULL, 0, NULL, 0, 0, 0, 0);
408         if (tevent_req_nomem(subreq, req)) {
409                 return tevent_req_post(req, ev);
410         }
411         tevent_req_set_callback(subreq, tldap_fetch_rootdse_done, req);
412         return req;
413 }
414
415 static void tldap_fetch_rootdse_done(struct tevent_req *subreq)
416 {
417         struct tevent_req *req = tevent_req_callback_data(
418                 subreq, struct tevent_req);
419         struct tldap_fetch_rootdse_state *state = tevent_req_data(
420                 req, struct tldap_fetch_rootdse_state);
421         struct tldap_message *msg;
422         int rc;
423
424         rc = tldap_search_recv(subreq, state, &msg);
425         if (rc != TLDAP_SUCCESS) {
426                 TALLOC_FREE(subreq);
427                 tevent_req_error(req, rc);
428                 return;
429         }
430
431         switch (tldap_msg_type(msg)) {
432         case TLDAP_RES_SEARCH_ENTRY:
433                 if (state->rootdse != NULL) {
434                         goto protocol_error;
435                 }
436                 state->rootdse = msg;
437                 break;
438         case TLDAP_RES_SEARCH_RESULT:
439                 TALLOC_FREE(subreq);
440                 if (state->rootdse == NULL) {
441                         goto protocol_error;
442                 }
443                 tevent_req_done(req);
444                 break;
445         default:
446                 goto protocol_error;
447         }
448         tevent_req_done(req);
449         return;
450
451 protocol_error:
452         tevent_req_error(req, TLDAP_PROTOCOL_ERROR);
453         return;
454 }
455
456 int tldap_fetch_rootdse_recv(struct tevent_req *req)
457 {
458         struct tldap_fetch_rootdse_state *state = tevent_req_data(
459                 req, struct tldap_fetch_rootdse_state);
460         int err;
461         char *dn;
462
463         if (tevent_req_is_ldap_error(req, &err)) {
464                 return err;
465         }
466         /* Trigger parsing the dn, just to make sure it's ok */
467         if (!tldap_entry_dn(state->rootdse, &dn)) {
468                 return TLDAP_DECODING_ERROR;
469         }
470         if (!tldap_context_setattr(state->ld, "tldap:rootdse",
471                                    &state->rootdse)) {
472                 return TLDAP_NO_MEMORY;
473         }
474         return 0;
475 }
476
477 int tldap_fetch_rootdse(struct tldap_context *ld)
478 {
479         TALLOC_CTX *frame = talloc_stackframe();
480         struct tevent_context *ev;
481         struct tevent_req *req;
482         int result;
483
484         ev = event_context_init(frame);
485         if (ev == NULL) {
486                 result = TLDAP_NO_MEMORY;
487                 goto fail;
488         }
489
490         req = tldap_fetch_rootdse_send(frame, ev, ld);
491         if (req == NULL) {
492                 result = TLDAP_NO_MEMORY;
493                 goto fail;
494         }
495
496         if (!tevent_req_poll(req, ev)) {
497                 result = TLDAP_OPERATIONS_ERROR;
498                 goto fail;
499         }
500
501         result = tldap_fetch_rootdse_recv(req);
502  fail:
503         TALLOC_FREE(frame);
504         return result;
505 }
506
507 struct tldap_message *tldap_rootdse(struct tldap_context *ld)
508 {
509         return talloc_get_type(tldap_context_getattr(ld, "tldap:rootdse"),
510                                struct tldap_message);
511 }
512
513 bool tldap_entry_has_attrvalue(struct tldap_message *msg,
514                                const char *attribute,
515                                const DATA_BLOB blob)
516 {
517         int i, num_values;
518         DATA_BLOB *values;
519
520         if (!tldap_entry_values(msg, attribute, &num_values, &values)) {
521                 return false;
522         }
523         for (i=0; i<num_values; i++) {
524                 if (data_blob_cmp(&values[i], &blob) == 0) {
525                         return true;
526                 }
527         }
528         return false;
529 }
530
531 bool tldap_supports_control(struct tldap_context *ld, const char *oid)
532 {
533         struct tldap_message *rootdse = tldap_rootdse(ld);
534
535         if (rootdse == NULL) {
536                 return false;
537         }
538         return tldap_entry_has_attrvalue(rootdse, "supportedControl",
539                                          data_blob_const(oid, strlen(oid)));
540 }
541
542 struct tldap_control *tldap_add_control(TALLOC_CTX *mem_ctx,
543                                         struct tldap_control *ctrls,
544                                         int num_ctrls,
545                                         struct tldap_control *ctrl)
546 {
547         struct tldap_control *result;
548
549         result = talloc_array(mem_ctx, struct tldap_control, num_ctrls+1);
550         if (result == NULL) {
551                 return NULL;
552         }
553         memcpy(result, ctrls, sizeof(struct tldap_control) * num_ctrls);
554         result[num_ctrls] = *ctrl;
555         return result;
556 }
557
558 /*
559  * Find a control returned by the server
560  */
561 struct tldap_control *tldap_msg_findcontrol(struct tldap_message *msg,
562                                             const char *oid)
563 {
564         struct tldap_control *controls;
565         int i, num_controls;
566
567         tldap_msg_sctrls(msg, &num_controls, &controls);
568
569         for (i=0; i<num_controls; i++) {
570                 if (strcmp(controls[i].oid, oid) == 0) {
571                         return &controls[i];
572                 }
573         }
574         return NULL;
575 }
576
577 struct tldap_search_paged_state {
578         struct tevent_context *ev;
579         struct tldap_context *ld;
580         const char *base;
581         const char *filter;
582         int scope;
583         const char **attrs;
584         int num_attrs;
585         int attrsonly;
586         struct tldap_control *sctrls;
587         int num_sctrls;
588         struct tldap_control *cctrls;
589         int num_cctrls;
590         int timelimit;
591         int sizelimit;
592         int deref;
593
594         int page_size;
595         struct asn1_data *asn1;
596         DATA_BLOB cookie;
597         struct tldap_message *result;
598 };
599
600 static struct tevent_req *tldap_ship_paged_search(
601         TALLOC_CTX *mem_ctx,
602         struct tldap_search_paged_state *state)
603 {
604         struct tldap_control *pgctrl;
605         struct asn1_data *asn1;
606
607         asn1 = asn1_init(state);
608         if (asn1 == NULL) {
609                 return NULL;
610         }
611         asn1_push_tag(asn1, ASN1_SEQUENCE(0));
612         asn1_write_Integer(asn1, state->page_size);
613         asn1_write_OctetString(asn1, state->cookie.data, state->cookie.length);
614         asn1_pop_tag(asn1);
615         if (asn1->has_error) {
616                 TALLOC_FREE(asn1);
617                 return NULL;
618         }
619         state->asn1 = asn1;
620
621         pgctrl = &state->sctrls[state->num_sctrls-1];
622         pgctrl->oid = TLDAP_CONTROL_PAGEDRESULTS;
623         pgctrl->critical = true;
624         if (!asn1_blob(state->asn1, &pgctrl->value)) {
625                 TALLOC_FREE(asn1);
626                 return NULL;
627         }
628         return tldap_search_send(mem_ctx, state->ev, state->ld, state->base,
629                                  state->scope, state->filter, state->attrs,
630                                  state->num_attrs, state->attrsonly,
631                                  state->sctrls, state->num_sctrls,
632                                  state->cctrls, state->num_cctrls,
633                                  state->timelimit, state->sizelimit,
634                                  state->deref);
635 }
636
637 static void tldap_search_paged_done(struct tevent_req *subreq);
638
639 struct tevent_req *tldap_search_paged_send(TALLOC_CTX *mem_ctx,
640                                            struct tevent_context *ev,
641                                            struct tldap_context *ld,
642                                            const char *base, int scope,
643                                            const char *filter,
644                                            const char **attrs,
645                                            int num_attrs,
646                                            int attrsonly,
647                                            struct tldap_control *sctrls,
648                                            int num_sctrls,
649                                            struct tldap_control *cctrls,
650                                            int num_cctrls,
651                                            int timelimit,
652                                            int sizelimit,
653                                            int deref,
654                                            int page_size)
655 {
656         struct tevent_req *req, *subreq;
657         struct tldap_search_paged_state *state;
658         struct tldap_control empty_control;
659
660         req = tevent_req_create(mem_ctx, &state,
661                                 struct tldap_search_paged_state);
662         if (req == NULL) {
663                 return NULL;
664         }
665         state->ev = ev;
666         state->ld = ld;
667         state->base = base;
668         state->filter = filter;
669         state->scope = scope;
670         state->attrs = attrs;
671         state->num_attrs = num_attrs;
672         state->attrsonly = attrsonly;
673         state->cctrls = cctrls;
674         state->num_cctrls = num_cctrls;
675         state->timelimit = timelimit;
676         state->sizelimit = sizelimit;
677         state->deref = deref;
678
679         state->page_size = page_size;
680         state->asn1 = NULL;
681         state->cookie = data_blob_null;
682
683         ZERO_STRUCT(empty_control);
684
685         state->sctrls = tldap_add_control(state, sctrls, num_sctrls,
686                                           &empty_control);
687         if (tevent_req_nomem(state->sctrls, req)) {
688                 return tevent_req_post(req, ev);
689         }
690         state->num_sctrls = num_sctrls+1;
691
692         subreq = tldap_ship_paged_search(state, state);
693         if (tevent_req_nomem(subreq, req)) {
694                 return tevent_req_post(req, ev);
695         }
696         tevent_req_set_callback(subreq, tldap_search_paged_done, req);
697
698         return req;
699 }
700
701 static void tldap_search_paged_done(struct tevent_req *subreq)
702 {
703         struct tevent_req *req = tevent_req_callback_data(
704                 subreq, struct tevent_req);
705         struct tldap_search_paged_state *state = tevent_req_data(
706                 req, struct tldap_search_paged_state);
707         struct asn1_data *asn1;
708         struct tldap_control *pgctrl;
709         int rc, size;
710
711         rc = tldap_search_recv(subreq, state, &state->result);
712         if (rc != TLDAP_SUCCESS) {
713                 TALLOC_FREE(subreq);
714                 tevent_req_error(req, rc);
715                 return;
716         }
717
718         TALLOC_FREE(state->asn1);
719
720         switch (tldap_msg_type(state->result)) {
721         case TLDAP_RES_SEARCH_ENTRY:
722         case TLDAP_RES_SEARCH_REFERENCE:
723                 tevent_req_notify_callback(req);
724                 return;
725         case TLDAP_RES_SEARCH_RESULT:
726                 break;
727         default:
728                 TALLOC_FREE(subreq);
729                 tevent_req_error(req, TLDAP_PROTOCOL_ERROR);
730                 return;
731         }
732
733         TALLOC_FREE(subreq);
734
735         /* We've finished one paged search, fire the next */
736
737         pgctrl = tldap_msg_findcontrol(state->result,
738                                        TLDAP_CONTROL_PAGEDRESULTS);
739         if (pgctrl == NULL) {
740                 /* RFC2696 requires the server to return the control */
741                 tevent_req_error(req, TLDAP_PROTOCOL_ERROR);
742                 return;
743         }
744
745         TALLOC_FREE(state->cookie.data);
746
747         asn1 = asn1_init(talloc_tos());
748         if (asn1 == NULL) {
749                 tevent_req_error(req, TLDAP_NO_MEMORY);
750                 return;
751         }
752
753         asn1_load_nocopy(asn1, pgctrl->value.data, pgctrl->value.length);
754         asn1_start_tag(asn1, ASN1_SEQUENCE(0));
755         asn1_read_Integer(asn1, &size);
756         asn1_read_OctetString(asn1, state, &state->cookie);
757         asn1_end_tag(asn1);
758         if (asn1->has_error) {
759                 tevent_req_error(req, TLDAP_DECODING_ERROR);
760                 return;
761         }
762         TALLOC_FREE(asn1);
763
764         if (state->cookie.length == 0) {
765                 /* We're done, no cookie anymore */
766                 tevent_req_done(req);
767                 return;
768         }
769
770         TALLOC_FREE(state->result);
771
772         subreq = tldap_ship_paged_search(state, state);
773         if (tevent_req_nomem(subreq, req)) {
774                 return;
775         }
776         tevent_req_set_callback(subreq, tldap_search_paged_done, req);
777 }
778
779 int tldap_search_paged_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
780                             struct tldap_message **pmsg)
781 {
782         struct tldap_search_paged_state *state = tevent_req_data(
783                 req, struct tldap_search_paged_state);
784         int err;
785
786         if (!tevent_req_is_in_progress(req)
787             && tevent_req_is_ldap_error(req, &err)) {
788                 return err;
789         }
790         if (tevent_req_is_in_progress(req)) {
791                 switch (tldap_msg_type(state->result)) {
792                 case TLDAP_RES_SEARCH_ENTRY:
793                 case TLDAP_RES_SEARCH_REFERENCE:
794                         break;
795                 default:
796                         return TLDAP_PROTOCOL_ERROR;
797                 }
798         }
799         *pmsg = talloc_move(mem_ctx, &state->result);
800         return TLDAP_SUCCESS;
801 }