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