source: vendor/3.5.11/source3/lib/tldap_util.c

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

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