?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Describe implication of upstream ICU-22610
[Samba.git] / source3 / lib / tldap.c
blobac95272fe0636a9796a406f78d8244db85b2baaa
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 "replace.h"
21 #include "tldap.h"
22 #include "system/network.h"
23 #include "system/locale.h"
24 #include "lib/util/talloc_stack.h"
25 #include "lib/util/samba_util.h"
26 #include "lib/util_tsock.h"
27 #include "../lib/util/asn1.h"
28 #include "../lib/tsocket/tsocket.h"
29 #include "../lib/util/tevent_unix.h"
30 #include "../libcli/util/ntstatus.h"
31 #include "../source4/lib/tls/tls.h"
32
33 static TLDAPRC tldap_simple_recv(struct tevent_req *req);
34 static bool tldap_msg_set_pending(struct tevent_req *req);
35
36 #define TEVENT_TLDAP_RC_MAGIC (0x87bcd26e)
37
38 bool tevent_req_ldap_error(struct tevent_req *req, TLDAPRC rc)
39 {
40 uint64_t err;
41
42 if (TLDAP_RC_IS_SUCCESS(rc)) {
43 return false;
44 }
45
46 err = TEVENT_TLDAP_RC_MAGIC;
47 err <<= 32;
48 err |= TLDAP_RC_V(rc);
49
50 return tevent_req_error(req, err);
51 }
52
53 bool tevent_req_is_ldap_error(struct tevent_req *req, TLDAPRC *perr)
54 {
55 enum tevent_req_state state;
56 uint64_t err;
57
58 if (!tevent_req_is_error(req, &state, &err)) {
59 return false;
60 }
61 switch (state) {
62 case TEVENT_REQ_TIMED_OUT:
63 *perr = TLDAP_TIMEOUT;
64 break;
65 case TEVENT_REQ_NO_MEMORY:
66 *perr = TLDAP_NO_MEMORY;
67 break;
68 case TEVENT_REQ_USER_ERROR:
69 if ((err >> 32) != TEVENT_TLDAP_RC_MAGIC) {
70 abort();
71 }
72 *perr = TLDAP_RC(err & 0xffffffff);
73 break;
74 default:
75 *perr = TLDAP_OPERATIONS_ERROR;
76 break;
77 }
78 return true;
79 }
80
81 struct tldap_ctx_attribute {
82 char *name;
83 void *ptr;
84 };
85
86 struct tldap_context {
87 int ld_version;
88 struct tstream_context *plain;
89 bool starttls_needed;
90 struct tstream_context *tls;
91 struct tstream_context *gensec;
92 struct tstream_context *active;
93 int msgid;
94 struct tevent_queue *outgoing;
95 struct tevent_req **pending;
96 struct tevent_req *read_req;
97
98 /* For the sync wrappers we need something like get_last_error... */
99 struct tldap_message *last_msg;
100
101 /* debug */
102 void (*log_fn)(void *context, enum tldap_debug_level level,
103 const char *fmt, va_list ap);
104 void *log_private;
105
106 struct tldap_ctx_attribute *ctx_attrs;
107 };
108
109 struct tldap_message {
110 struct asn1_data *data;
111 uint8_t *inbuf;
112 int type;
113 int id;
114
115 /* RESULT_ENTRY */
116 char *dn;
117 struct tldap_attribute *attribs;
118
119 /* Error data sent by the server */
120 TLDAPRC lderr;
121 char *res_matcheddn;
122 char *res_diagnosticmessage;
123 char *res_referral;
124 DATA_BLOB res_serverSaslCreds;
125 struct {
126 char *oid;
127 DATA_BLOB blob;
128 } res_extended;
129 struct tldap_control *res_sctrls;
130
131 /* Controls sent by the server */
132 struct tldap_control *ctrls;
133 };
134
135 void tldap_set_debug(struct tldap_context *ld,
136 void (*log_fn)(void *log_private,
137 enum tldap_debug_level level,
138 const char *fmt,
139 va_list ap) PRINTF_ATTRIBUTE(3,0),
140 void *log_private)
141 {
142 ld->log_fn = log_fn;
143 ld->log_private = log_private;
144 }
145
146 static void tldap_debug(
147 struct tldap_context *ld,
148 enum tldap_debug_level level,
149 const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
150
151 static void tldap_debug(struct tldap_context *ld,
152 enum tldap_debug_level level,
153 const char *fmt, ...)
154 {
155 va_list ap;
156 if (!ld) {
157 return;
158 }
159 if (ld->log_fn == NULL) {
160 return;
161 }
162 va_start(ap, fmt);
163 ld->log_fn(ld->log_private, level, fmt, ap);
164 va_end(ap);
165 }
166
167 static int tldap_next_msgid(struct tldap_context *ld)
168 {
169 int result;
170
171 result = ld->msgid++;
172 if (ld->msgid == INT_MAX) {
173 ld->msgid = 1;
174 }
175 return result;
176 }
177
178 struct tldap_context *tldap_context_create(TALLOC_CTX *mem_ctx, int fd)
179 {
180 struct tldap_context *ctx;
181 int ret;
182
183 ctx = talloc_zero(mem_ctx, struct tldap_context);
184 if (ctx == NULL) {
185 return NULL;
186 }
187 ret = tstream_bsd_existing_socket(ctx, fd, &ctx->plain);
188 if (ret == -1) {
189 TALLOC_FREE(ctx);
190 return NULL;
191 }
192 ctx->active = ctx->plain;
193 ctx->msgid = 1;
194 ctx->ld_version = 3;
195 ctx->outgoing = tevent_queue_create(ctx, "tldap_outgoing");
196 if (ctx->outgoing == NULL) {
197 TALLOC_FREE(ctx);
198 return NULL;
199 }
200 return ctx;
201 }
202
203 bool tldap_connection_ok(struct tldap_context *ld)
204 {
205 int ret;
206
207 if (ld == NULL) {
208 return false;
209 }
210
211 if (ld->active == NULL) {
212 return false;
213 }
214
215 ret = tstream_pending_bytes(ld->active);
216 if (ret == -1) {
217 return false;
218 }
219
220 return true;
221 }
222
223 static size_t tldap_pending_reqs(struct tldap_context *ld)
224 {
225 return talloc_array_length(ld->pending);
226 }
227
228 struct tstream_context *tldap_get_plain_tstream(struct tldap_context *ld)
229 {
230 return ld->plain;
231 }
232
233 void tldap_set_starttls_needed(struct tldap_context *ld, bool needed)
234 {
235 if (ld == NULL) {
236 return;
237 }
238
239 ld->starttls_needed = needed;
240 }
241
242 bool tldap_get_starttls_needed(struct tldap_context *ld)
243 {
244 if (ld == NULL) {
245 return false;
246 }
247
248 return ld->starttls_needed;
249 }
250
251 bool tldap_has_tls_tstream(struct tldap_context *ld)
252 {
253 return ld->tls != NULL && ld->active == ld->tls;
254 }
255
256 const DATA_BLOB *tldap_tls_channel_bindings(struct tldap_context *ld)
257 {
258 return tstream_tls_channel_bindings(ld->tls);
259 }
260
261 void tldap_set_tls_tstream(struct tldap_context *ld,
262 struct tstream_context **stream)
263 {
264 TALLOC_FREE(ld->tls);
265 if (stream != NULL) {
266 ld->tls = talloc_move(ld, stream);
267 }
268 if (ld->tls != NULL) {
269 ld->active = ld->tls;
270 } else {
271 ld->active = ld->plain;
272 }
273 }
274
275 bool tldap_has_gensec_tstream(struct tldap_context *ld)
276 {
277 return ld->gensec != NULL && ld->active == ld->gensec;
278 }
279
280 void tldap_set_gensec_tstream(struct tldap_context *ld,
281 struct tstream_context **stream)
282 {
283 TALLOC_FREE(ld->gensec);
284 if (stream != NULL) {
285 ld->gensec = talloc_move(ld, stream);
286 }
287 if (ld->gensec != NULL) {
288 ld->active = ld->gensec;
289 } else {
290 ld->active = ld->plain;
291 }
292 }
293
294 static struct tldap_ctx_attribute *tldap_context_findattr(
295 struct tldap_context *ld, const char *name)
296 {
297 size_t i, num_attrs;
298
299 num_attrs = talloc_array_length(ld->ctx_attrs);
300
301 for (i=0; i<num_attrs; i++) {
302 if (strcmp(ld->ctx_attrs[i].name, name) == 0) {
303 return &ld->ctx_attrs[i];
304 }
305 }
306 return NULL;
307 }
308
309 bool tldap_context_setattr(struct tldap_context *ld,
310 const char *name, const void *_pptr)
311 {
312 struct tldap_ctx_attribute *tmp, *attr;
313 char *tmpname;
314 int num_attrs;
315 void **pptr = (void **)discard_const_p(void,_pptr);
316
317 attr = tldap_context_findattr(ld, name);
318 if (attr != NULL) {
319 /*
320 * We don't actually delete attrs, we don't expect tons of
321 * attributes being shuffled around.
322 */
323 TALLOC_FREE(attr->ptr);
324 if (*pptr != NULL) {
325 attr->ptr = talloc_move(ld->ctx_attrs, pptr);
326 *pptr = NULL;
327 }
328 return true;
329 }
330
331 tmpname = talloc_strdup(ld, name);
332 if (tmpname == NULL) {
333 return false;
334 }
335
336 num_attrs = talloc_array_length(ld->ctx_attrs);
337
338 tmp = talloc_realloc(ld, ld->ctx_attrs, struct tldap_ctx_attribute,
339 num_attrs+1);
340 if (tmp == NULL) {
341 TALLOC_FREE(tmpname);
342 return false;
343 }
344 tmp[num_attrs].name = talloc_move(tmp, &tmpname);
345 if (*pptr != NULL) {
346 tmp[num_attrs].ptr = talloc_move(tmp, pptr);
347 } else {
348 tmp[num_attrs].ptr = NULL;
349 }
350 *pptr = NULL;
351 ld->ctx_attrs = tmp;
352 return true;
353 }
354
355 void *tldap_context_getattr(struct tldap_context *ld, const char *name)
356 {
357 struct tldap_ctx_attribute *attr = tldap_context_findattr(ld, name);
358
359 if (attr == NULL) {
360 return NULL;
361 }
362 return attr->ptr;
363 }
364
365 struct read_ldap_state {
366 uint8_t *buf;
367 };
368
369 static ssize_t read_ldap_more(uint8_t *buf, size_t buflen, void *private_data);
370 static void read_ldap_done(struct tevent_req *subreq);
371
372 static struct tevent_req *read_ldap_send(TALLOC_CTX *mem_ctx,
373 struct tevent_context *ev,
374 struct tstream_context *conn)
375 {
376 struct tevent_req *req, *subreq;
377 struct read_ldap_state *state;
378
379 req = tevent_req_create(mem_ctx, &state, struct read_ldap_state);
380 if (req == NULL) {
381 return NULL;
382 }
383
384 subreq = tstream_read_packet_send(state, ev, conn, 7, read_ldap_more,
385 state);
386 if (tevent_req_nomem(subreq, req)) {
387 return tevent_req_post(req, ev);
388 }
389 tevent_req_set_callback(subreq, read_ldap_done, req);
390 return req;
391 }
392
393 static ssize_t read_ldap_more(uint8_t *buf, size_t buflen, void *private_data)
394 {
395 const DATA_BLOB blob = data_blob_const(buf, buflen);
396 size_t pdu_len = 0;
397 int ret;
398
399 if (buflen < 7) {
400 /*
401 * We need at least 6 bytes to workout the length
402 * of the pdu.
403 *
404 * And we have asked for 7 because the that's
405 * the size of the smallest possible LDAP pdu.
406 */
407 return -1;
408 }
409
410 ret = asn1_peek_full_tag(blob, ASN1_SEQUENCE(0), &pdu_len);
411 if (ret == 0) {
412 return 0;
413 }
414 if (ret == EAGAIN) {
415 return pdu_len - buflen;
416 }
417
418 return -1;
419 }
420
421 static void read_ldap_done(struct tevent_req *subreq)
422 {
423 struct tevent_req *req = tevent_req_callback_data(
424 subreq, struct tevent_req);
425 struct read_ldap_state *state = tevent_req_data(
426 req, struct read_ldap_state);
427 ssize_t nread;
428 int err;
429
430 nread = tstream_read_packet_recv(subreq, state, &state->buf, &err);
431 TALLOC_FREE(subreq);
432 if (nread == -1) {
433 tevent_req_error(req, err);
434 return;
435 }
436 tevent_req_done(req);
437 }
438
439 static ssize_t read_ldap_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
440 uint8_t **pbuf, int *perrno)
441 {
442 struct read_ldap_state *state = tevent_req_data(
443 req, struct read_ldap_state);
444
445 if (tevent_req_is_unix_error(req, perrno)) {
446 return -1;
447 }
448 *pbuf = talloc_move(mem_ctx, &state->buf);
449 return talloc_get_size(*pbuf);
450 }
451
452 struct tldap_msg_state {
453 struct tldap_context *ld;
454 struct tevent_context *ev;
455 int id;
456 struct iovec iov;
457
458 struct asn1_data *data;
459 uint8_t *inbuf;
460 };
461
462 static bool tldap_push_controls(struct asn1_data *data,
463 struct tldap_control *sctrls,
464 int num_sctrls)
465 {
466 int i;
467
468 if ((sctrls == NULL) || (num_sctrls == 0)) {
469 return true;
470 }
471
472 if (!asn1_push_tag(data, ASN1_CONTEXT(0))) return false;
473
474 for (i=0; i<num_sctrls; i++) {
475 struct tldap_control *c = &sctrls[i];
476 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) return false;
477 if (!asn1_write_OctetString(data, c->oid, strlen(c->oid))) return false;
478 if (c->critical) {
479 if (!asn1_write_BOOLEAN(data, true)) return false;
480 }
481 if (c->value.data != NULL) {
482 if (!asn1_write_OctetString(data, c->value.data,
483 c->value.length)) return false;
484 }
485 if (!asn1_pop_tag(data)) return false; /* ASN1_SEQUENCE(0) */
486 }
487
488 return asn1_pop_tag(data); /* ASN1_CONTEXT(0) */
489 }
490
491 #define tldap_context_disconnect(ld, status) \
492 _tldap_context_disconnect(ld, status, __location__)
493
494 static void _tldap_context_disconnect(struct tldap_context *ld,
495 TLDAPRC status,
496 const char *location)
497 {
498 if (ld->active == NULL) {
499 /*
500 * We don't need to tldap_debug() on
501 * a potential 2nd run.
502 *
503 * The rest of the function would just
504 * be a noop for the 2nd run anyway.
505 */
506 return;
507 }
508
509 tldap_debug(ld, TLDAP_DEBUG_WARNING,
510 "tldap_context_disconnect: %s at %s\n",
511 tldap_rc2string(status),
512 location);
513 tevent_queue_stop(ld->outgoing);
514 TALLOC_FREE(ld->read_req);
515 ld->active = NULL;
516 TALLOC_FREE(ld->gensec);
517 TALLOC_FREE(ld->tls);
518 TALLOC_FREE(ld->plain);
519
520 while (talloc_array_length(ld->pending) > 0) {
521 struct tevent_req *req = NULL;
522 struct tldap_msg_state *state = NULL;
523
524 req = ld->pending[0];
525 state = tevent_req_data(req, struct tldap_msg_state);
526 tevent_req_defer_callback(req, state->ev);
527 tevent_req_ldap_error(req, status);
528 }
529 }
530
531 static void tldap_msg_sent(struct tevent_req *subreq);
532 static void tldap_msg_received(struct tevent_req *subreq);
533
534 static struct tevent_req *tldap_msg_send(TALLOC_CTX *mem_ctx,
535 struct tevent_context *ev,
536 struct tldap_context *ld,
537 int id, struct asn1_data *data,
538 struct tldap_control *sctrls,
539 int num_sctrls)
540 {
541 struct tevent_req *req, *subreq;
542 struct tldap_msg_state *state;
543 DATA_BLOB blob;
544 bool ok;
545
546 tldap_debug(ld, TLDAP_DEBUG_TRACE, "tldap_msg_send: sending msg %d\n",
547 id);
548
549 req = tevent_req_create(mem_ctx, &state, struct tldap_msg_state);
550 if (req == NULL) {
551 return NULL;
552 }
553 state->ld = ld;
554 state->ev = ev;
555 state->id = id;
556
557 ok = tldap_connection_ok(ld);
558 if (!ok) {
559 tevent_req_ldap_error(req, TLDAP_SERVER_DOWN);
560 return tevent_req_post(req, ev);
561 }
562
563 if (!tldap_push_controls(data, sctrls, num_sctrls)) {
564 tevent_req_ldap_error(req, TLDAP_ENCODING_ERROR);
565 return tevent_req_post(req, ev);
566 }
567
568
569 if (!asn1_pop_tag(data)) {
570 tevent_req_ldap_error(req, TLDAP_ENCODING_ERROR);
571 return tevent_req_post(req, ev);
572 }
573
574 if (!asn1_blob(data, &blob)) {
575 tevent_req_ldap_error(req, TLDAP_ENCODING_ERROR);
576 return tevent_req_post(req, ev);
577 }
578
579 if (!tldap_msg_set_pending(req)) {
580 tevent_req_oom(req);
581 return tevent_req_post(req, ev);;
582 }
583
584 state->iov.iov_base = (void *)blob.data;
585 state->iov.iov_len = blob.length;
586
587 subreq = tstream_writev_queue_send(state, ev, ld->active, ld->outgoing,
588 &state->iov, 1);
589 if (tevent_req_nomem(subreq, req)) {
590 return tevent_req_post(req, ev);
591 }
592 tevent_req_set_callback(subreq, tldap_msg_sent, req);
593 return req;
594 }
595
596 static void tldap_msg_unset_pending(struct tevent_req *req)
597 {
598 struct tldap_msg_state *state = tevent_req_data(
599 req, struct tldap_msg_state);
600 struct tldap_context *ld = state->ld;
601 int num_pending = tldap_pending_reqs(ld);
602 int i;
603
604 tevent_req_set_cleanup_fn(req, NULL);
605
606 for (i=0; i<num_pending; i++) {
607 if (req == ld->pending[i]) {
608 break;
609 }
610 }
611 if (i == num_pending) {
612 /*
613 * Something's seriously broken. Just returning here is the
614 * right thing nevertheless, the point of this routine is to
615 * remove ourselves from cli->pending.
616 */
617 return;
618 }
619
620 if (num_pending == 1) {
621 TALLOC_FREE(ld->pending);
622 return;
623 }
624
625 /*
626 * Remove ourselves from the cli->pending array
627 */
628 if (num_pending > 1) {
629 ld->pending[i] = ld->pending[num_pending-1];
630 }
631
632 /*
633 * No NULL check here, we're shrinking by sizeof(void *), and
634 * talloc_realloc just adjusts the size for this.
635 */
636 ld->pending = talloc_realloc(NULL, ld->pending, struct tevent_req *,
637 num_pending - 1);
638 }
639
640 static void tldap_msg_cleanup(struct tevent_req *req,
641 enum tevent_req_state req_state)
642 {
643 tldap_msg_unset_pending(req);
644 }
645
646 static bool tldap_msg_set_pending(struct tevent_req *req)
647 {
648 struct tldap_msg_state *state = tevent_req_data(
649 req, struct tldap_msg_state);
650 struct tldap_context *ld;
651 struct tevent_req **pending;
652 int num_pending;
653
654 ld = state->ld;
655 num_pending = tldap_pending_reqs(ld);
656
657 pending = talloc_realloc(ld, ld->pending, struct tevent_req *,
658 num_pending+1);
659 if (pending == NULL) {
660 return false;
661 }
662 pending[num_pending] = req;
663 ld->pending = pending;
664 tevent_req_set_cleanup_fn(req, tldap_msg_cleanup);
665
666 if (ld->read_req != NULL) {
667 return true;
668 }
669
670 /*
671 * We're the first one, add the read_ldap request that waits for the
672 * answer from the server
673 */
674 ld->read_req = read_ldap_send(ld->pending, state->ev, ld->active);
675 if (ld->read_req == NULL) {
676 tldap_msg_unset_pending(req);
677 return false;
678 }
679 tevent_req_set_callback(ld->read_req, tldap_msg_received, ld);
680 return true;
681 }
682
683 static void tldap_msg_sent(struct tevent_req *subreq)
684 {
685 struct tevent_req *req = tevent_req_callback_data(
686 subreq, struct tevent_req);
687 struct tldap_msg_state *state = tevent_req_data(
688 req, struct tldap_msg_state);
689 ssize_t nwritten;
690 int err;
691
692 nwritten = tstream_writev_queue_recv(subreq, &err);
693 TALLOC_FREE(subreq);
694 if (nwritten == -1) {
695 tldap_context_disconnect(state->ld, TLDAP_SERVER_DOWN);
696 return;
697 }
698 }
699
700 static int tldap_msg_msgid(struct tevent_req *req)
701 {
702 struct tldap_msg_state *state = tevent_req_data(
703 req, struct tldap_msg_state);
704
705 return state->id;
706 }
707
708 static void tldap_msg_received(struct tevent_req *subreq)
709 {
710 struct tldap_context *ld = tevent_req_callback_data(
711 subreq, struct tldap_context);
712 struct tevent_req *req;
713 struct tldap_msg_state *state;
714 struct asn1_data *data;
715 uint8_t *inbuf;
716 ssize_t received;
717 size_t num_pending;
718 size_t i;
719 int err;
720 TLDAPRC status = TLDAP_PROTOCOL_ERROR;
721 int id;
722 uint8_t type;
723 bool ok;
724
725 received = read_ldap_recv(subreq, talloc_tos(), &inbuf, &err);
726 TALLOC_FREE(subreq);
727 ld->read_req = NULL;
728 if (received == -1) {
729 status = TLDAP_SERVER_DOWN;
730 goto fail;
731 }
732
733 data = asn1_init(talloc_tos(), ASN1_MAX_TREE_DEPTH);
734 if (data == NULL) {
735 /*
736 * We have to disconnect all, we can't tell which of
737 * the requests this reply is for.
738 */
739 status = TLDAP_NO_MEMORY;
740 goto fail;
741 }
742 asn1_load_nocopy(data, inbuf, received);
743
744 ok = true;
745 ok &= asn1_start_tag(data, ASN1_SEQUENCE(0));
746 ok &= asn1_read_Integer(data, &id);
747 ok &= asn1_peek_uint8(data, &type);
748
749 if (!ok) {
750 status = TLDAP_PROTOCOL_ERROR;
751 goto fail;
752 }
753
754 tldap_debug(ld, TLDAP_DEBUG_TRACE, "tldap_msg_received: got msg %d "
755 "type %d\n", id, (int)type);
756
757 if (id == 0) {
758 tldap_debug(
759 ld,
760 TLDAP_DEBUG_WARNING,
761 "tldap_msg_received: got msgid 0 of "
762 "type %"PRIu8", disconnecting\n",
763 type);
764 tldap_context_disconnect(ld, TLDAP_SERVER_DOWN);
765 return;
766 }
767
768 num_pending = talloc_array_length(ld->pending);
769
770 for (i=0; i<num_pending; i++) {
771 if (id == tldap_msg_msgid(ld->pending[i])) {
772 break;
773 }
774 }
775 if (i == num_pending) {
776 /* Dump unexpected reply */
777 tldap_debug(ld, TLDAP_DEBUG_WARNING, "tldap_msg_received: "
778 "No request pending for msg %d\n", id);
779 TALLOC_FREE(data);
780 TALLOC_FREE(inbuf);
781 goto done;
782 }
783
784 req = ld->pending[i];
785 state = tevent_req_data(req, struct tldap_msg_state);
786
787 state->inbuf = talloc_move(state, &inbuf);
788 state->data = talloc_move(state, &data);
789
790 tldap_msg_unset_pending(req);
791 num_pending = talloc_array_length(ld->pending);
792
793 tevent_req_defer_callback(req, state->ev);
794 tevent_req_done(req);
795
796 done:
797 if (num_pending == 0) {
798 return;
799 }
800
801 state = tevent_req_data(ld->pending[0], struct tldap_msg_state);
802 ld->read_req = read_ldap_send(ld->pending, state->ev, ld->active);
803 if (ld->read_req == NULL) {
804 status = TLDAP_NO_MEMORY;
805 goto fail;
806 }
807 tevent_req_set_callback(ld->read_req, tldap_msg_received, ld);
808 return;
809
810 fail:
811 tldap_context_disconnect(ld, status);
812 }
813
814 static TLDAPRC tldap_msg_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
815 struct tldap_message **pmsg)
816 {
817 struct tldap_msg_state *state = tevent_req_data(
818 req, struct tldap_msg_state);
819 struct tldap_message *msg;
820 TLDAPRC err;
821 uint8_t msgtype;
822
823 if (tevent_req_is_ldap_error(req, &err)) {
824 return err;
825 }
826
827 if (!asn1_peek_uint8(state->data, &msgtype)) {
828 return TLDAP_PROTOCOL_ERROR;
829 }
830
831 if (pmsg == NULL) {
832 return TLDAP_SUCCESS;
833 }
834
835 msg = talloc_zero(mem_ctx, struct tldap_message);
836 if (msg == NULL) {
837 return TLDAP_NO_MEMORY;
838 }
839 msg->id = state->id;
840
841 msg->inbuf = talloc_move(msg, &state->inbuf);
842 msg->data = talloc_move(msg, &state->data);
843 msg->type = msgtype;
844
845 *pmsg = msg;
846 return TLDAP_SUCCESS;
847 }
848
849 struct tldap_req_state {
850 int id;
851 struct asn1_data *out;
852 struct tldap_message *result;
853 };
854
855 static struct tevent_req *tldap_req_create(TALLOC_CTX *mem_ctx,
856 struct tldap_context *ld,
857 struct tldap_req_state **pstate)
858 {
859 struct tevent_req *req;
860 struct tldap_req_state *state;
861
862 req = tevent_req_create(mem_ctx, &state, struct tldap_req_state);
863 if (req == NULL) {
864 return NULL;
865 }
866 state->out = asn1_init(state, ASN1_MAX_TREE_DEPTH);
867 if (state->out == NULL) {
868 goto err;
869 }
870 state->id = tldap_next_msgid(ld);
871
872 if (!asn1_push_tag(state->out, ASN1_SEQUENCE(0))) goto err;
873 if (!asn1_write_Integer(state->out, state->id)) goto err;
874
875 *pstate = state;
876 return req;
877
878 err:
879
880 TALLOC_FREE(req);
881 return NULL;
882 }
883
884 static void tldap_save_msg(struct tldap_context *ld, struct tevent_req *req)
885 {
886 struct tldap_req_state *state = tevent_req_data(
887 req, struct tldap_req_state);
888
889 TALLOC_FREE(ld->last_msg);
890 ld->last_msg = talloc_move(ld, &state->result);
891 }
892
893 static char *blob2string_talloc(TALLOC_CTX *mem_ctx, DATA_BLOB blob)
894 {
895 char *result = talloc_array(mem_ctx, char, blob.length+1);
896
897 if (result == NULL) {
898 return NULL;
899 }
900
901 memcpy(result, blob.data, blob.length);
902 result[blob.length] = '\0';
903 return result;
904 }
905
906 static bool asn1_read_OctetString_talloc(TALLOC_CTX *mem_ctx,
907 struct asn1_data *data,
908 char **presult)
909 {
910 DATA_BLOB string;
911 char *result;
912 if (!asn1_read_OctetString(data, mem_ctx, &string))
913 return false;
914
915 result = blob2string_talloc(mem_ctx, string);
916
917 data_blob_free(&string);
918
919 if (result == NULL) {
920 return false;
921 }
922 *presult = result;
923 return true;
924 }
925
926 static bool tldap_decode_controls(struct tldap_req_state *state);
927
928 static bool tldap_decode_response(struct tldap_req_state *state)
929 {
930 struct asn1_data *data = state->result->data;
931 struct tldap_message *msg = state->result;
932 int rc;
933 bool ok = true;
934
935 ok &= asn1_read_enumerated(data, &rc);
936 if (ok) {
937 msg->lderr = TLDAP_RC(rc);
938 }
939
940 ok &= asn1_read_OctetString_talloc(msg, data, &msg->res_matcheddn);
941 ok &= asn1_read_OctetString_talloc(msg, data,
942 &msg->res_diagnosticmessage);
943 if (!ok) return ok;
944 if (asn1_peek_tag(data, ASN1_CONTEXT(3))) {
945 ok &= asn1_start_tag(data, ASN1_CONTEXT(3));
946 ok &= asn1_read_OctetString_talloc(msg, data,
947 &msg->res_referral);
948 ok &= asn1_end_tag(data);
949 } else {
950 msg->res_referral = NULL;
951 }
952
953 return ok;
954 }
955
956 static void tldap_sasl_bind_done(struct tevent_req *subreq);
957
958 struct tevent_req *tldap_sasl_bind_send(TALLOC_CTX *mem_ctx,
959 struct tevent_context *ev,
960 struct tldap_context *ld,
961 const char *dn,
962 const char *mechanism,
963 DATA_BLOB *creds,
964 struct tldap_control *sctrls,
965 int num_sctrls,
966 struct tldap_control *cctrls,
967 int num_cctrls)
968 {
969 struct tevent_req *req, *subreq;
970 struct tldap_req_state *state;
971
972 req = tldap_req_create(mem_ctx, ld, &state);
973 if (req == NULL) {
974 return NULL;
975 }
976
977 if (dn == NULL) {
978 dn = "";
979 }
980
981 if (!asn1_push_tag(state->out, TLDAP_REQ_BIND)) goto err;
982 if (!asn1_write_Integer(state->out, ld->ld_version)) goto err;
983 if (!asn1_write_OctetString(state->out, dn, strlen(dn))) goto err;
984
985 if (mechanism == NULL) {
986 if (!asn1_push_tag(state->out, ASN1_CONTEXT_SIMPLE(0))) goto err;
987 if (!asn1_write(state->out, creds->data, creds->length)) goto err;
988 if (!asn1_pop_tag(state->out)) goto err;
989 } else {
990 if (!asn1_push_tag(state->out, ASN1_CONTEXT(3))) goto err;
991 if (!asn1_write_OctetString(state->out, mechanism,
992 strlen(mechanism))) goto err;
993 if ((creds != NULL) && (creds->data != NULL)) {
994 if (!asn1_write_OctetString(state->out, creds->data,
995 creds->length)) goto err;
996 }
997 if (!asn1_pop_tag(state->out)) goto err;
998 }
999
1000 if (!asn1_pop_tag(state->out)) goto err;
1001
1002 subreq = tldap_msg_send(state, ev, ld, state->id, state->out,
1003 sctrls, num_sctrls);
1004 if (tevent_req_nomem(subreq, req)) {
1005 return tevent_req_post(req, ev);
1006 }
1007 tevent_req_set_callback(subreq, tldap_sasl_bind_done, req);
1008 return req;
1009
1010 err:
1011
1012 tevent_req_ldap_error(req, TLDAP_ENCODING_ERROR);
1013 return tevent_req_post(req, ev);
1014 }
1015
1016 static void tldap_sasl_bind_done(struct tevent_req *subreq)
1017 {
1018 struct tevent_req *req = tevent_req_callback_data(
1019 subreq, struct tevent_req);
1020 struct tldap_req_state *state = tevent_req_data(
1021 req, struct tldap_req_state);
1022 TLDAPRC rc;
1023 bool ok;
1024
1025 rc = tldap_msg_recv(subreq, state, &state->result);
1026 TALLOC_FREE(subreq);
1027 if (tevent_req_ldap_error(req, rc)) {
1028 return;
1029 }
1030 if (state->result->type != TLDAP_RES_BIND) {
1031 tevent_req_ldap_error(req, TLDAP_PROTOCOL_ERROR);
1032 return;
1033 }
1034
1035 ok = asn1_start_tag(state->result->data, TLDAP_RES_BIND);
1036 ok &= tldap_decode_response(state);
1037
1038 if (asn1_peek_tag(state->result->data, ASN1_CONTEXT_SIMPLE(7))) {
1039 int len;
1040
1041 ok &= asn1_start_tag(state->result->data,
1042 ASN1_CONTEXT_SIMPLE(7));
1043 if (!ok) {
1044 goto decode_error;
1045 }
1046
1047 len = asn1_tag_remaining(state->result->data);
1048 if (len == -1) {
1049 goto decode_error;
1050 }
1051
1052 state->result->res_serverSaslCreds =
1053 data_blob_talloc(state->result, NULL, len);
1054 if (state->result->res_serverSaslCreds.data == NULL) {
1055 goto decode_error;
1056 }
1057
1058 ok = asn1_read(state->result->data,
1059 state->result->res_serverSaslCreds.data,
1060 state->result->res_serverSaslCreds.length);
1061
1062 ok &= asn1_end_tag(state->result->data);
1063 }
1064
1065 ok &= asn1_end_tag(state->result->data);
1066
1067 if (!ok) {
1068 goto decode_error;
1069 }
1070
1071 if (!TLDAP_RC_IS_SUCCESS(state->result->lderr) &&
1072 !TLDAP_RC_EQUAL(state->result->lderr,
1073 TLDAP_SASL_BIND_IN_PROGRESS)) {
1074 tevent_req_ldap_error(req, state->result->lderr);
1075 return;
1076 }
1077 tevent_req_done(req);
1078 return;
1079
1080 decode_error:
1081 tevent_req_ldap_error(req, TLDAP_DECODING_ERROR);
1082 return;
1083 }
1084
1085 TLDAPRC tldap_sasl_bind_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1086 DATA_BLOB *serverSaslCreds)
1087 {
1088 struct tldap_req_state *state = tevent_req_data(
1089 req, struct tldap_req_state);
1090 TLDAPRC rc;
1091
1092 if (tevent_req_is_ldap_error(req, &rc)) {
1093 return rc;
1094 }
1095
1096 if (serverSaslCreds != NULL) {
1097 serverSaslCreds->data = talloc_move(
1098 mem_ctx, &state->result->res_serverSaslCreds.data);
1099 serverSaslCreds->length =
1100 state->result->res_serverSaslCreds.length;
1101 }
1102
1103 return state->result->lderr;
1104 }
1105
1106 TLDAPRC tldap_sasl_bind(struct tldap_context *ld,
1107 const char *dn,
1108 const char *mechanism,
1109 DATA_BLOB *creds,
1110 struct tldap_control *sctrls,
1111 int num_sctrls,
1112 struct tldap_control *cctrls,
1113 int num_cctrls,
1114 TALLOC_CTX *mem_ctx,
1115 DATA_BLOB *serverSaslCreds)
1116 {
1117 TALLOC_CTX *frame = talloc_stackframe();
1118 struct tevent_context *ev;
1119 struct tevent_req *req;
1120 TLDAPRC rc = TLDAP_NO_MEMORY;
1121
1122 ev = samba_tevent_context_init(frame);
1123 if (ev == NULL) {
1124 goto fail;
1125 }
1126 req = tldap_sasl_bind_send(frame, ev, ld, dn, mechanism, creds,
1127 sctrls, num_sctrls, cctrls, num_cctrls);
1128 if (req == NULL) {
1129 goto fail;
1130 }
1131 if (!tevent_req_poll(req, ev)) {
1132 rc = TLDAP_OPERATIONS_ERROR;
1133 goto fail;
1134 }
1135 rc = tldap_sasl_bind_recv(req, mem_ctx, serverSaslCreds);
1136 tldap_save_msg(ld, req);
1137 fail:
1138 TALLOC_FREE(frame);
1139 return rc;
1140 }
1141
1142 struct tevent_req *tldap_simple_bind_send(TALLOC_CTX *mem_ctx,
1143 struct tevent_context *ev,
1144 struct tldap_context *ld,
1145 const char *dn,
1146 const char *passwd)
1147 {
1148 DATA_BLOB cred;
1149
1150 if (passwd != NULL) {
1151 cred.data = discard_const_p(uint8_t, passwd);
1152 cred.length = strlen(passwd);
1153 } else {
1154 cred.data = discard_const_p(uint8_t, "");
1155 cred.length = 0;
1156 }
1157 return tldap_sasl_bind_send(mem_ctx, ev, ld, dn, NULL, &cred, NULL, 0,
1158 NULL, 0);
1159 }
1160
1161 TLDAPRC tldap_simple_bind_recv(struct tevent_req *req)
1162 {
1163 return tldap_sasl_bind_recv(req, NULL, NULL);
1164 }
1165
1166 TLDAPRC tldap_simple_bind(struct tldap_context *ld, const char *dn,
1167 const char *passwd)
1168 {
1169 DATA_BLOB cred;
1170
1171 if (passwd != NULL) {
1172 cred.data = discard_const_p(uint8_t, passwd);
1173 cred.length = strlen(passwd);
1174 } else {
1175 cred.data = discard_const_p(uint8_t, "");
1176 cred.length = 0;
1177 }
1178 return tldap_sasl_bind(ld, dn, NULL, &cred, NULL, 0, NULL, 0,
1179 NULL, NULL);
1180 }
1181
1182 /*****************************************************************************/
1183
1184 /* can't use isalpha() as only a strict set is valid for LDAP */
1185
1186 static bool tldap_is_alpha(char c)
1187 {
1188 return (((c >= 'a') && (c <= 'z')) || \
1189 ((c >= 'A') && (c <= 'Z')));
1190 }
1191
1192 static bool tldap_is_adh(char c)
1193 {
1194 return tldap_is_alpha(c) || isdigit(c) || (c == '-');
1195 }
1196
1197 #define TLDAP_FILTER_AND ASN1_CONTEXT(0)
1198 #define TLDAP_FILTER_OR ASN1_CONTEXT(1)
1199 #define TLDAP_FILTER_NOT ASN1_CONTEXT(2)
1200 #define TLDAP_FILTER_EQ ASN1_CONTEXT(3)
1201 #define TLDAP_FILTER_SUB ASN1_CONTEXT(4)
1202 #define TLDAP_FILTER_LE ASN1_CONTEXT(5)
1203 #define TLDAP_FILTER_GE ASN1_CONTEXT(6)
1204 #define TLDAP_FILTER_PRES ASN1_CONTEXT_SIMPLE(7)
1205 #define TLDAP_FILTER_APX ASN1_CONTEXT(8)
1206 #define TLDAP_FILTER_EXT ASN1_CONTEXT(9)
1207
1208 #define TLDAP_SUB_INI ASN1_CONTEXT_SIMPLE(0)
1209 #define TLDAP_SUB_ANY ASN1_CONTEXT_SIMPLE(1)
1210 #define TLDAP_SUB_FIN ASN1_CONTEXT_SIMPLE(2)
1211
1212
1213 /* oid's should be numerical only in theory,
1214 * but apparently some broken servers may have alphanum aliases instead.
1215 * Do like openldap libraries and allow alphanum aliases for oids, but
1216 * do not allow Tagging options in that case.
1217 */
1218 static bool tldap_is_attrdesc(const char *s, int len, bool no_tagopts)
1219 {
1220 bool is_oid = false;
1221 bool dot = false;
1222 int i;
1223
1224 /* first char has stricter rules */
1225 if (isdigit(*s)) {
1226 is_oid = true;
1227 } else if (!tldap_is_alpha(*s)) {
1228 /* bad first char */
1229 return false;
1230 }
1231
1232 for (i = 1; i < len; i++) {
1233
1234 if (is_oid) {
1235 if (isdigit(s[i])) {
1236 dot = false;
1237 continue;
1238 }
1239 if (s[i] == '.') {
1240 if (dot) {
1241 /* malformed */
1242 return false;
1243 }
1244 dot = true;
1245 continue;
1246 }
1247 } else {
1248 if (tldap_is_adh(s[i])) {
1249 continue;
1250 }
1251 }
1252
1253 if (s[i] == ';') {
1254 if (no_tagopts) {
1255 /* no tagging options */
1256 return false;
1257 }
1258 if (dot) {
1259 /* malformed */
1260 return false;
1261 }
1262 if ((i + 1) == len) {
1263 /* malformed */
1264 return false;
1265 }
1266
1267 is_oid = false;
1268 continue;
1269 }
1270 }
1271
1272 if (dot) {
1273 /* malformed */
1274 return false;
1275 }
1276
1277 return true;
1278 }
1279
1280 /* this function copies the value until the closing parenthesis is found. */
1281 static char *tldap_get_val(TALLOC_CTX *memctx,
1282 const char *value, const char **_s)
1283 {
1284 const char *s = value;
1285
1286 /* find terminator */
1287 while (*s) {
1288 s = strchr(s, ')');
1289 if (s && (*(s - 1) == '\\')) {
1290 s++;
1291 continue;
1292 }
1293 break;
1294 }
1295 if (!s || !(*s == ')')) {
1296 /* malformed filter */
1297 return NULL;
1298 }
1299
1300 *_s = s;
1301
1302 return talloc_strndup(memctx, value, s - value);
1303 }
1304
1305 static int tldap_hex2char(const char *x)
1306 {
1307 if (isxdigit(x[0]) && isxdigit(x[1])) {
1308 const char h1 = x[0], h2 = x[1];
1309 int c = 0;
1310
1311 if (h1 >= 'a') c = h1 - (int)'a' + 10;
1312 else if (h1 >= 'A') c = h1 - (int)'A' + 10;
1313 else if (h1 >= '0') c = h1 - (int)'0';
1314 c = c << 4;
1315 if (h2 >= 'a') c += h2 - (int)'a' + 10;
1316 else if (h2 >= 'A') c += h2 - (int)'A' + 10;
1317 else if (h2 >= '0') c += h2 - (int)'0';
1318
1319 return c;
1320 }
1321
1322 return -1;
1323 }
1324
1325 static bool tldap_find_first_star(const char *val, const char **star)
1326 {
1327 const char *s;
1328
1329 for (s = val; *s; s++) {
1330 switch (*s) {
1331 case '\\':
1332 if (isxdigit(s[1]) && isxdigit(s[2])) {
1333 s += 2;
1334 break;
1335 }
1336 /* not hex based escape, check older syntax */
1337 switch (s[1]) {
1338 case '(':
1339 case ')':
1340 case '*':
1341 case '\\':
1342 s++;
1343 break;
1344 default:
1345 /* invalid escape sequence */
1346 return false;
1347 }
1348 break;
1349 case ')':
1350 /* end of val, nothing found */
1351 *star = s;
1352 return true;
1353
1354 case '*':
1355 *star = s;
1356 return true;
1357 }
1358 }
1359
1360 /* string ended without closing parenthesis, filter is malformed */
1361 return false;
1362 }
1363
1364 static bool tldap_unescape_inplace(char *value, size_t *val_len)
1365 {
1366 int c;
1367 size_t i, p;
1368
1369 for (i = 0,p = 0; i < *val_len; i++) {
1370
1371 switch (value[i]) {
1372 case '(':
1373 case ')':
1374 case '*':
1375 /* these must be escaped */
1376 return false;
1377
1378 case '\\':
1379 if (!value[i + 1]) {
1380 /* invalid EOL */
1381 return false;
1382 }
1383 i++;
1384
1385 /* LDAPv3 escaped */
1386 c = tldap_hex2char(&value[i]);
1387 if (c >= 0 && c < 256) {
1388 value[p] = c;
1389 i++;
1390 p++;
1391 break;
1392 }
1393
1394 /* LDAPv2 escaped */
1395 switch (value[i]) {
1396 case '(':
1397 case ')':
1398 case '*':
1399 case '\\':
1400 value[p] = value[i];
1401 p++;
1402
1403 break;
1404 default:
1405 /* invalid */
1406 return false;
1407 }
1408 break;
1409
1410 default:
1411 value[p] = value[i];
1412 p++;
1413 }
1414 }
1415 value[p] = '\0';
1416 *val_len = p;
1417 return true;
1418 }
1419
1420 static bool tldap_push_filter_basic(struct tldap_context *ld,
1421 struct asn1_data *data,
1422 const char **_s);
1423 static bool tldap_push_filter_substring(struct tldap_context *ld,
1424 struct asn1_data *data,
1425 const char *val,
1426 const char **_s);
1427 static bool tldap_push_filter_int(struct tldap_context *ld,
1428 struct asn1_data *data,
1429 const char **_s)
1430 {
1431 const char *s = *_s;
1432 bool ret;
1433
1434 if (*s != '(') {
1435 tldap_debug(ld, TLDAP_DEBUG_ERROR,
1436 "Incomplete or malformed filter\n");
1437 return false;
1438 }
1439 s++;
1440
1441 /* we are right after a parenthesis,
1442 * find out what op we have at hand */
1443 switch (*s) {
1444 case '&':
1445 tldap_debug(ld, TLDAP_DEBUG_TRACE, "Filter op: AND\n");
1446 if (!asn1_push_tag(data, TLDAP_FILTER_AND)) return false;
1447 s++;
1448 break;
1449
1450 case '|':
1451 tldap_debug(ld, TLDAP_DEBUG_TRACE, "Filter op: OR\n");
1452 if (!asn1_push_tag(data, TLDAP_FILTER_OR)) return false;
1453 s++;
1454 break;
1455
1456 case '!':
1457 tldap_debug(ld, TLDAP_DEBUG_TRACE, "Filter op: NOT\n");
1458 if (!asn1_push_tag(data, TLDAP_FILTER_NOT)) return false;
1459 s++;
1460 ret = tldap_push_filter_int(ld, data, &s);
1461 if (!ret) {
1462 return false;
1463 }
1464 if (!asn1_pop_tag(data)) return false;
1465 goto done;
1466
1467 case '(':
1468 case ')':
1469 tldap_debug(ld, TLDAP_DEBUG_ERROR,
1470 "Invalid parenthesis '%c'\n", *s);
1471 return false;
1472
1473 case '\0':
1474 tldap_debug(ld, TLDAP_DEBUG_ERROR,
1475 "Invalid filter termination\n");
1476 return false;
1477
1478 default:
1479 ret = tldap_push_filter_basic(ld, data, &s);
1480 if (!ret) {
1481 return false;
1482 }
1483 goto done;
1484 }
1485
1486 /* only and/or filters get here.
1487 * go through the list of filters */
1488
1489 if (*s == ')') {
1490 /* RFC 4526: empty and/or */
1491 if (!asn1_pop_tag(data)) return false;
1492 goto done;
1493 }
1494
1495 while (*s) {
1496 ret = tldap_push_filter_int(ld, data, &s);
1497 if (!ret) {
1498 return false;
1499 }
1500
1501 if (*s == ')') {
1502 /* end of list, return */
1503 if (!asn1_pop_tag(data)) return false;
1504 break;
1505 }
1506 }
1507
1508 done:
1509 if (*s != ')') {
1510 tldap_debug(ld, TLDAP_DEBUG_ERROR,
1511 "Incomplete or malformed filter\n");
1512 return false;
1513 }
1514 s++;
1515
1516 if (asn1_has_error(data)) {
1517 return false;
1518 }
1519
1520 *_s = s;
1521 return true;
1522 }
1523
1524
1525 static bool tldap_push_filter_basic(struct tldap_context *ld,
1526 struct asn1_data *data,
1527 const char **_s)
1528 {
1529 TALLOC_CTX *tmpctx = talloc_tos();
1530 const char *s = *_s;
1531 const char *e;
1532 const char *eq;
1533 const char *val;
1534 const char *type;
1535 const char *dn;
1536 const char *rule;
1537 const char *star;
1538 size_t type_len = 0;
1539 char *uval;
1540 size_t uval_len;
1541 bool write_octect = true;
1542 bool ret;
1543
1544 eq = strchr(s, '=');
1545 if (!eq) {
1546 tldap_debug(ld, TLDAP_DEBUG_ERROR,
1547 "Invalid filter, missing equal sign\n");
1548 return false;
1549 }
1550
1551 val = eq + 1;
1552 e = eq - 1;
1553
1554 switch (*e) {
1555 case '<':
1556 if (!asn1_push_tag(data, TLDAP_FILTER_LE)) return false;
1557 break;
1558
1559 case '>':
1560 if (!asn1_push_tag(data, TLDAP_FILTER_GE)) return false;
1561 break;
1562
1563 case '~':
1564 if (!asn1_push_tag(data, TLDAP_FILTER_APX)) return false;
1565 break;
1566
1567 case ':':
1568 if (!asn1_push_tag(data, TLDAP_FILTER_EXT)) return false;
1569 write_octect = false;
1570
1571 type = NULL;
1572 dn = NULL;
1573 rule = NULL;
1574
1575 if (*s == ':') { /* [:dn]:rule:= value */
1576 if (s == e) {
1577 /* malformed filter */
1578 return false;
1579 }
1580 dn = s;
1581 } else { /* type[:dn][:rule]:= value */
1582 type = s;
1583 dn = strchr(s, ':');
1584 type_len = dn - type;
1585 if (dn == e) { /* type:= value */
1586 dn = NULL;
1587 }
1588 }
1589 if (dn) {
1590 dn++;
1591
1592 rule = strchr(dn, ':');
1593 if (rule == NULL) {
1594 return false;
1595 }
1596 if ((rule == dn + 1) || rule + 1 == e) {
1597 /* malformed filter, contains "::" */
1598 return false;
1599 }
1600
1601 if (strncasecmp_m(dn, "dn:", 3) != 0) {
1602 if (rule == e) {
1603 rule = dn;
1604 dn = NULL;
1605 } else {
1606 /* malformed filter. With two
1607 * optionals, the first must be "dn"
1608 */
1609 return false;
1610 }
1611 } else {
1612 if (rule == e) {
1613 rule = NULL;
1614 } else {
1615 rule++;
1616 }
1617 }
1618 }
1619
1620 if (!type && !dn && !rule) {
1621 /* malformed filter, there must be at least one */
1622 return false;
1623 }
1624
1625 /*
1626 MatchingRuleAssertion ::= SEQUENCE {
1627 matchingRule [1] MatchingRuleID OPTIONAL,
1628 type [2] AttributeDescription OPTIONAL,
1629 matchValue [3] AssertionValue,
1630 dnAttributes [4] BOOLEAN DEFAULT FALSE
1631 }
1632 */
1633
1634 /* check and add rule */
1635 if (rule) {
1636 ret = tldap_is_attrdesc(rule, e - rule, true);
1637 if (!ret) {
1638 return false;
1639 }
1640 if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(1))) return false;
1641 if (!asn1_write(data, rule, e - rule)) return false;
1642 if (!asn1_pop_tag(data)) return false;
1643 }
1644
1645 /* check and add type */
1646 if (type) {
1647 ret = tldap_is_attrdesc(type, type_len, false);
1648 if (!ret) {
1649 return false;
1650 }
1651 if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(2))) return false;
1652 if (!asn1_write(data, type, type_len)) return false;
1653 if (!asn1_pop_tag(data)) return false;
1654 }
1655
1656 uval = tldap_get_val(tmpctx, val, _s);
1657 if (!uval) {
1658 return false;
1659 }
1660 uval_len = *_s - val;
1661 ret = tldap_unescape_inplace(uval, &uval_len);
1662 if (!ret) {
1663 return false;
1664 }
1665
1666 if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(3))) return false;
1667 if (!asn1_write(data, uval, uval_len)) return false;
1668 if (!asn1_pop_tag(data)) return false;
1669
1670 if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(4))) return false;
1671 if (!asn1_write_uint8(data, dn?1:0)) return false;
1672 if (!asn1_pop_tag(data)) return false;
1673 break;
1674
1675 default:
1676 e = eq;
1677
1678 ret = tldap_is_attrdesc(s, e - s, false);
1679 if (!ret) {
1680 return false;
1681 }
1682
1683 if (strncmp(val, "*)", 2) == 0) {
1684 /* presence */
1685 if (!asn1_push_tag(data, TLDAP_FILTER_PRES)) return false;
1686 if (!asn1_write(data, s, e - s)) return false;
1687 *_s = val + 1;
1688 write_octect = false;
1689 break;
1690 }
1691
1692 ret = tldap_find_first_star(val, &star);
1693 if (!ret) {
1694 return false;
1695 }
1696 if (*star == '*') {
1697 /* substring */
1698 if (!asn1_push_tag(data, TLDAP_FILTER_SUB)) return false;
1699 if (!asn1_write_OctetString(data, s, e - s)) return false;
1700 ret = tldap_push_filter_substring(ld, data, val, &s);
1701 if (!ret) {
1702 return false;
1703 }
1704 *_s = s;
1705 write_octect = false;
1706 break;
1707 }
1708
1709 /* if nothing else, then it is just equality */
1710 if (!asn1_push_tag(data, TLDAP_FILTER_EQ)) return false;
1711 write_octect = true;
1712 break;
1713 }
1714
1715 if (write_octect) {
1716 uval = tldap_get_val(tmpctx, val, _s);
1717 if (!uval) {
1718 return false;
1719 }
1720 uval_len = *_s - val;
1721 ret = tldap_unescape_inplace(uval, &uval_len);
1722 if (!ret) {
1723 return false;
1724 }
1725
1726 if (!asn1_write_OctetString(data, s, e - s)) return false;
1727 if (!asn1_write_OctetString(data, uval, uval_len)) return false;
1728 }
1729
1730 if (asn1_has_error(data)) {
1731 return false;
1732 }
1733 return asn1_pop_tag(data);
1734 }
1735
1736 static bool tldap_push_filter_substring(struct tldap_context *ld,
1737 struct asn1_data *data,
1738 const char *val,
1739 const char **_s)
1740 {
1741 TALLOC_CTX *tmpctx = talloc_tos();
1742 bool initial = true;
1743 const char *star;
1744 char *chunk;
1745 size_t chunk_len;
1746 bool ret;
1747
1748 /*
1749 SubstringFilter ::= SEQUENCE {
1750 type AttributeDescription,
1751 -- at least one must be present
1752 substrings SEQUENCE OF CHOICE {
1753 initial [0] LDAPString,
1754 any [1] LDAPString,
1755 final [2] LDAPString } }
1756 */
1757 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) return false;
1758
1759 do {
1760 ret = tldap_find_first_star(val, &star);
1761 if (!ret) {
1762 return false;
1763 }
1764 chunk_len = star - val;
1765
1766 switch (*star) {
1767 case '*':
1768 if (!initial && chunk_len == 0) {
1769 /* found '**', which is illegal */
1770 return false;
1771 }
1772 break;
1773 case ')':
1774 if (initial) {
1775 /* no stars ?? */
1776 return false;
1777 }
1778 /* we are done */
1779 break;
1780 default:
1781 /* ?? */
1782 return false;
1783 }
1784
1785 if (initial && chunk_len == 0) {
1786 val = star + 1;
1787 initial = false;
1788 continue;
1789 }
1790
1791 chunk = talloc_strndup(tmpctx, val, chunk_len);
1792 if (!chunk) {
1793 return false;
1794 }
1795 ret = tldap_unescape_inplace(chunk, &chunk_len);
1796 if (!ret) {
1797 return false;
1798 }
1799 switch (*star) {
1800 case '*':
1801 if (initial) {
1802 if (!asn1_push_tag(data, TLDAP_SUB_INI)) return false;
1803 initial = false;
1804 } else {
1805 if (!asn1_push_tag(data, TLDAP_SUB_ANY)) return false;
1806 }
1807 break;
1808 case ')':
1809 if (!asn1_push_tag(data, TLDAP_SUB_FIN)) return false;
1810 break;
1811 default:
1812 /* ?? */
1813 return false;
1814 }
1815 if (!asn1_write(data, chunk, chunk_len)) return false;
1816 if (!asn1_pop_tag(data)) return false;
1817
1818 val = star + 1;
1819
1820 } while (*star == '*');
1821
1822 *_s = star;
1823
1824 /* end of sequence */
1825 return asn1_pop_tag(data);
1826 }
1827
1828 /* NOTE: although openldap libraries allow for spaces in some places, mostly
1829 * around parentheses, we do not allow any spaces (except in values of
1830 * course) as I couldn't find any place in RFC 4512 or RFC 4515 where
1831 * leading or trailing spaces were allowed.
1832 */
1833 static bool tldap_push_filter(struct tldap_context *ld,
1834 struct asn1_data *data,
1835 const char *filter)
1836 {
1837 const char *s = filter;
1838 bool ret;
1839
1840 ret = tldap_push_filter_int(ld, data, &s);
1841 if (ret && *s) {
1842 tldap_debug(ld, TLDAP_DEBUG_ERROR,
1843 "Incomplete or malformed filter\n");
1844 return false;
1845 }
1846 return ret;
1847 }
1848
1849 /*****************************************************************************/
1850
1851 static void tldap_search_done(struct tevent_req *subreq);
1852
1853 struct tevent_req *tldap_search_send(TALLOC_CTX *mem_ctx,
1854 struct tevent_context *ev,
1855 struct tldap_context *ld,
1856 const char *base, int scope,
1857 const char *filter,
1858 const char **attrs,
1859 int num_attrs,
1860 int attrsonly,
1861 struct tldap_control *sctrls,
1862 int num_sctrls,
1863 struct tldap_control *cctrls,
1864 int num_cctrls,
1865 int timelimit,
1866 int sizelimit,
1867 int deref)
1868 {
1869 struct tevent_req *req, *subreq;
1870 struct tldap_req_state *state;
1871 int i;
1872
1873 req = tldap_req_create(mem_ctx, ld, &state);
1874 if (req == NULL) {
1875 return NULL;
1876 }
1877
1878 if (!asn1_push_tag(state->out, TLDAP_REQ_SEARCH)) goto encoding_error;
1879 if (!asn1_write_OctetString(state->out, base, strlen(base))) goto encoding_error;
1880 if (!asn1_write_enumerated(state->out, scope)) goto encoding_error;
1881 if (!asn1_write_enumerated(state->out, deref)) goto encoding_error;
1882 if (!asn1_write_Integer(state->out, sizelimit)) goto encoding_error;
1883 if (!asn1_write_Integer(state->out, timelimit)) goto encoding_error;
1884 if (!asn1_write_BOOLEAN(state->out, attrsonly)) goto encoding_error;
1885
1886 if (!tldap_push_filter(ld, state->out, filter)) {
1887 goto encoding_error;
1888 }
1889
1890 if (!asn1_push_tag(state->out, ASN1_SEQUENCE(0))) goto encoding_error;
1891 for (i=0; i<num_attrs; i++) {
1892 if (!asn1_write_OctetString(state->out, attrs[i], strlen(attrs[i]))) goto encoding_error;
1893 }
1894 if (!asn1_pop_tag(state->out)) goto encoding_error;
1895 if (!asn1_pop_tag(state->out)) goto encoding_error;
1896
1897 subreq = tldap_msg_send(state, ev, ld, state->id, state->out,
1898 sctrls, num_sctrls);
1899 if (tevent_req_nomem(subreq, req)) {
1900 return tevent_req_post(req, ev);
1901 }
1902 tevent_req_set_callback(subreq, tldap_search_done, req);
1903 return req;
1904
1905 encoding_error:
1906 tevent_req_ldap_error(req, TLDAP_ENCODING_ERROR);
1907 return tevent_req_post(req, ev);
1908 }
1909
1910 static void tldap_search_done(struct tevent_req *subreq)
1911 {
1912 struct tevent_req *req = tevent_req_callback_data(
1913 subreq, struct tevent_req);
1914 struct tldap_req_state *state = tevent_req_data(
1915 req, struct tldap_req_state);
1916 TLDAPRC rc;
1917
1918 rc = tldap_msg_recv(subreq, state, &state->result);
1919 if (tevent_req_ldap_error(req, rc)) {
1920 return;
1921 }
1922 switch (state->result->type) {
1923 case TLDAP_RES_SEARCH_ENTRY:
1924 case TLDAP_RES_SEARCH_REFERENCE:
1925 if (!tldap_msg_set_pending(subreq)) {
1926 tevent_req_oom(req);
1927 return;
1928 }
1929 tevent_req_notify_callback(req);
1930 break;
1931 case TLDAP_RES_SEARCH_RESULT:
1932 TALLOC_FREE(subreq);
1933 if (!asn1_start_tag(state->result->data,
1934 state->result->type) ||
1935 !tldap_decode_response(state) ||
1936 !asn1_end_tag(state->result->data) ||
1937 !tldap_decode_controls(state)) {
1938 tevent_req_ldap_error(req, TLDAP_DECODING_ERROR);
1939 return;
1940 }
1941 tevent_req_done(req);
1942 break;
1943 default:
1944 tevent_req_ldap_error(req, TLDAP_PROTOCOL_ERROR);
1945 return;
1946 }
1947 }
1948
1949 TLDAPRC tldap_search_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1950 struct tldap_message **pmsg)
1951 {
1952 struct tldap_req_state *state = tevent_req_data(
1953 req, struct tldap_req_state);
1954 TLDAPRC rc;
1955
1956 if (!tevent_req_is_in_progress(req)
1957 && tevent_req_is_ldap_error(req, &rc)) {
1958 return rc;
1959 }
1960
1961 if (tevent_req_is_in_progress(req)) {
1962 switch (state->result->type) {
1963 case TLDAP_RES_SEARCH_ENTRY:
1964 case TLDAP_RES_SEARCH_REFERENCE:
1965 break;
1966 default:
1967 return TLDAP_OPERATIONS_ERROR;
1968 }
1969 }
1970
1971 *pmsg = talloc_move(mem_ctx, &state->result);
1972 return TLDAP_SUCCESS;
1973 }
1974
1975 struct tldap_search_all_state {
1976 struct tldap_message **msgs;
1977 struct tldap_message *result;
1978 };
1979
1980 static void tldap_search_all_done(struct tevent_req *subreq);
1981
1982 struct tevent_req *tldap_search_all_send(
1983 TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1984 struct tldap_context *ld, const char *base, int scope,
1985 const char *filter, const char **attrs, int num_attrs, int attrsonly,
1986 struct tldap_control *sctrls, int num_sctrls,
1987 struct tldap_control *cctrls, int num_cctrls,
1988 int timelimit, int sizelimit, int deref)
1989 {
1990 struct tevent_req *req, *subreq;
1991 struct tldap_search_all_state *state;
1992
1993 req = tevent_req_create(mem_ctx, &state,
1994 struct tldap_search_all_state);
1995 if (req == NULL) {
1996 return NULL;
1997 }
1998
1999 subreq = tldap_search_send(state, ev, ld, base, scope, filter,
2000 attrs, num_attrs, attrsonly,
2001 sctrls, num_sctrls, cctrls, num_cctrls,
2002 timelimit, sizelimit, deref);
2003 if (tevent_req_nomem(subreq, req)) {
2004 return tevent_req_post(req, ev);
2005 }
2006 tevent_req_set_callback(subreq, tldap_search_all_done, req);
2007 return req;
2008 }
2009
2010 static void tldap_search_all_done(struct tevent_req *subreq)
2011 {
2012 struct tevent_req *req = tevent_req_callback_data(
2013 subreq, struct tevent_req);
2014 struct tldap_search_all_state *state = tevent_req_data(
2015 req, struct tldap_search_all_state);
2016 struct tldap_message *msg, **tmp;
2017 size_t num_msgs;
2018 TLDAPRC rc;
2019 int msgtype;
2020
2021 rc = tldap_search_recv(subreq, state, &msg);
2022 /* No TALLOC_FREE(subreq), this is multi-step */
2023 if (tevent_req_ldap_error(req, rc)) {
2024 return;
2025 }
2026
2027 msgtype = tldap_msg_type(msg);
2028 if (msgtype == TLDAP_RES_SEARCH_RESULT) {
2029 state->result = msg;
2030 tevent_req_done(req);
2031 return;
2032 }
2033
2034 num_msgs = talloc_array_length(state->msgs);
2035
2036 tmp = talloc_realloc(state, state->msgs, struct tldap_message *,
2037 num_msgs + 1);
2038 if (tevent_req_nomem(tmp, req)) {
2039 return;
2040 }
2041 state->msgs = tmp;
2042 state->msgs[num_msgs] = talloc_move(state->msgs, &msg);
2043 }
2044
2045 TLDAPRC tldap_search_all_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
2046 struct tldap_message ***msgs,
2047 struct tldap_message **result)
2048 {
2049 struct tldap_search_all_state *state = tevent_req_data(
2050 req, struct tldap_search_all_state);
2051 TLDAPRC rc;
2052
2053 if (tevent_req_is_ldap_error(req, &rc)) {
2054 return rc;
2055 }
2056
2057 if (msgs != NULL) {
2058 *msgs = talloc_move(mem_ctx, &state->msgs);
2059 }
2060 if (result != NULL) {
2061 *result = talloc_move(mem_ctx, &state->result);
2062 }
2063
2064 return TLDAP_SUCCESS;
2065 }
2066
2067 TLDAPRC tldap_search(struct tldap_context *ld,
2068 const char *base, int scope, const char *filter,
2069 const char **attrs, int num_attrs, int attrsonly,
2070 struct tldap_control *sctrls, int num_sctrls,
2071 struct tldap_control *cctrls, int num_cctrls,
2072 int timelimit, int sizelimit, int deref,
2073 TALLOC_CTX *mem_ctx, struct tldap_message ***pmsgs)
2074 {
2075 TALLOC_CTX *frame;
2076 struct tevent_context *ev;
2077 struct tevent_req *req;
2078 TLDAPRC rc = TLDAP_NO_MEMORY;
2079 struct tldap_message **msgs;
2080 struct tldap_message *result;
2081
2082 if (tldap_pending_reqs(ld)) {
2083 return TLDAP_BUSY;
2084 }
2085
2086 frame = talloc_stackframe();
2087
2088 ev = samba_tevent_context_init(frame);
2089 if (ev == NULL) {
2090 goto fail;
2091 }
2092 req = tldap_search_all_send(frame, ev, ld, base, scope, filter,
2093 attrs, num_attrs, attrsonly,
2094 sctrls, num_sctrls, cctrls, num_cctrls,
2095 timelimit, sizelimit, deref);
2096 if (req == NULL) {
2097 goto fail;
2098 }
2099 if (!tevent_req_poll(req, ev)) {
2100 rc = TLDAP_OPERATIONS_ERROR;
2101 goto fail;
2102 }
2103 rc = tldap_search_all_recv(req, frame, &msgs, &result);
2104 TALLOC_FREE(req);
2105 if (!TLDAP_RC_IS_SUCCESS(rc)) {
2106 goto fail;
2107 }
2108
2109 TALLOC_FREE(ld->last_msg);
2110 ld->last_msg = talloc_move(ld, &result);
2111
2112 if (pmsgs != NULL) {
2113 *pmsgs = talloc_move(mem_ctx, &msgs);
2114 }
2115 fail:
2116 TALLOC_FREE(frame);
2117 return rc;
2118 }
2119
2120 static bool tldap_parse_search_entry(struct tldap_message *msg)
2121 {
2122 int num_attribs = 0;
2123
2124 if (msg->type != TLDAP_RES_SEARCH_ENTRY) {
2125 return false;
2126 }
2127 if (!asn1_start_tag(msg->data, TLDAP_RES_SEARCH_ENTRY)) {
2128 return false;
2129 }
2130
2131 /* dn */
2132
2133 if (!asn1_read_OctetString_talloc(msg, msg->data, &msg->dn)) return false;
2134
2135 if (msg->dn == NULL) {
2136 return false;
2137 }
2138
2139 /*
2140 * Attributes: We overallocate msg->attribs by one, so that while
2141 * looping over the attributes we can directly parse into the last
2142 * array element. Same for the values in the inner loop.
2143 */
2144
2145 msg->attribs = talloc_array(msg, struct tldap_attribute, 1);
2146 if (msg->attribs == NULL) {
2147 return false;
2148 }
2149
2150 if (!asn1_start_tag(msg->data, ASN1_SEQUENCE(0))) return false;
2151 while (asn1_peek_tag(msg->data, ASN1_SEQUENCE(0))) {
2152 struct tldap_attribute *attrib;
2153 int num_values = 0;
2154
2155 attrib = &msg->attribs[num_attribs];
2156 attrib->values = talloc_array(msg->attribs, DATA_BLOB, 1);
2157 if (attrib->values == NULL) {
2158 return false;
2159 }
2160 if (!asn1_start_tag(msg->data, ASN1_SEQUENCE(0))) return false;
2161 if (!asn1_read_OctetString_talloc(msg->attribs, msg->data,
2162 &attrib->name)) return false;
2163 if (!asn1_start_tag(msg->data, ASN1_SET)) return false;
2164
2165 while (asn1_peek_tag(msg->data, ASN1_OCTET_STRING)) {
2166 if (!asn1_read_OctetString(msg->data, msg,
2167 &attrib->values[num_values])) return false;
2168
2169 attrib->values = talloc_realloc(
2170 msg->attribs, attrib->values, DATA_BLOB,
2171 num_values + 2);
2172 if (attrib->values == NULL) {
2173 return false;
2174 }
2175 num_values += 1;
2176 }
2177 attrib->values = talloc_realloc(msg->attribs, attrib->values,
2178 DATA_BLOB, num_values);
2179 attrib->num_values = num_values;
2180
2181 if (!asn1_end_tag(msg->data)) return false; /* ASN1_SET */
2182 if (!asn1_end_tag(msg->data)) return false; /* ASN1_SEQUENCE(0) */
2183 msg->attribs = talloc_realloc(
2184 msg, msg->attribs, struct tldap_attribute,
2185 num_attribs + 2);
2186 if (msg->attribs == NULL) {
2187 return false;
2188 }
2189 num_attribs += 1;
2190 }
2191 msg->attribs = talloc_realloc(
2192 msg, msg->attribs, struct tldap_attribute, num_attribs);
2193 return asn1_end_tag(msg->data);
2194 }
2195
2196 bool tldap_entry_dn(struct tldap_message *msg, char **dn)
2197 {
2198 if ((msg->dn == NULL) && (!tldap_parse_search_entry(msg))) {
2199 return false;
2200 }
2201 *dn = msg->dn;
2202 return true;
2203 }
2204
2205 bool tldap_entry_attributes(struct tldap_message *msg,
2206 struct tldap_attribute **attributes,
2207 int *num_attributes)
2208 {
2209 if ((msg->dn == NULL) && (!tldap_parse_search_entry(msg))) {
2210 return false;
2211 }
2212 *attributes = msg->attribs;
2213 *num_attributes = talloc_array_length(msg->attribs);
2214 return true;
2215 }
2216
2217 static bool tldap_decode_controls(struct tldap_req_state *state)
2218 {
2219 struct tldap_message *msg = state->result;
2220 struct asn1_data *data = msg->data;
2221 struct tldap_control *sctrls = NULL;
2222 int num_controls = 0;
2223 bool ret = false;
2224
2225 msg->res_sctrls = NULL;
2226
2227 if (!asn1_peek_tag(data, ASN1_CONTEXT(0))) {
2228 return true;
2229 }
2230
2231 if (!asn1_start_tag(data, ASN1_CONTEXT(0))) goto out;
2232
2233 while (asn1_peek_tag(data, ASN1_SEQUENCE(0))) {
2234 struct tldap_control *c;
2235 char *oid = NULL;
2236
2237 sctrls = talloc_realloc(msg, sctrls, struct tldap_control,
2238 num_controls + 1);
2239 if (sctrls == NULL) {
2240 goto out;
2241 }
2242 c = &sctrls[num_controls];
2243
2244 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) goto out;
2245 if (!asn1_read_OctetString_talloc(msg, data, &oid)) goto out;
2246 if (asn1_has_error(data) || (oid == NULL)) {
2247 goto out;
2248 }
2249 c->oid = oid;
2250 if (asn1_peek_tag(data, ASN1_BOOLEAN)) {
2251 if (!asn1_read_BOOLEAN(data, &c->critical)) goto out;
2252 } else {
2253 c->critical = false;
2254 }
2255 c->value = data_blob_null;
2256 if (asn1_peek_tag(data, ASN1_OCTET_STRING) &&
2257 !asn1_read_OctetString(data, msg, &c->value)) {
2258 goto out;
2259 }
2260 if (!asn1_end_tag(data)) goto out; /* ASN1_SEQUENCE(0) */
2261
2262 num_controls += 1;
2263 }
2264
2265 if (!asn1_end_tag(data)) goto out; /* ASN1_CONTEXT(0) */
2266
2267 ret = true;
2268
2269 out:
2270
2271 if (ret) {
2272 msg->res_sctrls = sctrls;
2273 } else {
2274 TALLOC_FREE(sctrls);
2275 }
2276 return ret;
2277 }
2278
2279 static void tldap_simple_done(struct tevent_req *subreq, int type)
2280 {
2281 struct tevent_req *req = tevent_req_callback_data(
2282 subreq, struct tevent_req);
2283 struct tldap_req_state *state = tevent_req_data(
2284 req, struct tldap_req_state);
2285 TLDAPRC rc;
2286
2287 rc = tldap_msg_recv(subreq, state, &state->result);
2288 TALLOC_FREE(subreq);
2289 if (tevent_req_ldap_error(req, rc)) {
2290 return;
2291 }
2292 if (state->result->type != type) {
2293 tevent_req_ldap_error(req, TLDAP_PROTOCOL_ERROR);
2294 return;
2295 }
2296 if (!asn1_start_tag(state->result->data, state->result->type) ||
2297 !tldap_decode_response(state) ||
2298 !asn1_end_tag(state->result->data) ||
2299 !tldap_decode_controls(state)) {
2300 tevent_req_ldap_error(req, TLDAP_DECODING_ERROR);
2301 return;
2302 }
2303 if (!TLDAP_RC_IS_SUCCESS(state->result->lderr)) {
2304 tevent_req_ldap_error(req, state->result->lderr);
2305 return;
2306 }
2307 tevent_req_done(req);
2308 }
2309
2310 static TLDAPRC tldap_simple_recv(struct tevent_req *req)
2311 {
2312 TLDAPRC rc;
2313 if (tevent_req_is_ldap_error(req, &rc)) {
2314 return rc;
2315 }
2316 return TLDAP_SUCCESS;
2317 }
2318
2319 static void tldap_add_done(struct tevent_req *subreq);
2320
2321 struct tevent_req *tldap_add_send(TALLOC_CTX *mem_ctx,
2322 struct tevent_context *ev,
2323 struct tldap_context *ld,
2324 const char *dn,
2325 struct tldap_mod *attributes,
2326 int num_attributes,
2327 struct tldap_control *sctrls,
2328 int num_sctrls,
2329 struct tldap_control *cctrls,
2330 int num_cctrls)
2331 {
2332 struct tevent_req *req, *subreq;
2333 struct tldap_req_state *state;
2334 int i, j;
2335
2336 req = tldap_req_create(mem_ctx, ld, &state);
2337 if (req == NULL) {
2338 return NULL;
2339 }
2340
2341 if (!asn1_push_tag(state->out, TLDAP_REQ_ADD)) goto err;
2342 if (!asn1_write_OctetString(state->out, dn, strlen(dn))) goto err;
2343 if (!asn1_push_tag(state->out, ASN1_SEQUENCE(0))) goto err;
2344
2345 for (i=0; i<num_attributes; i++) {
2346 struct tldap_mod *attrib = &attributes[i];
2347 if (!asn1_push_tag(state->out, ASN1_SEQUENCE(0))) goto err;
2348 if (!asn1_write_OctetString(state->out, attrib->attribute,
2349 strlen(attrib->attribute))) goto err;
2350 if (!asn1_push_tag(state->out, ASN1_SET)) goto err;
2351 for (j=0; j<attrib->num_values; j++) {
2352 if (!asn1_write_OctetString(state->out,
2353 attrib->values[j].data,
2354 attrib->values[j].length)) goto err;
2355 }
2356 if (!asn1_pop_tag(state->out)) goto err;
2357 if (!asn1_pop_tag(state->out)) goto err;
2358 }
2359
2360 if (!asn1_pop_tag(state->out)) goto err;
2361 if (!asn1_pop_tag(state->out)) goto err;
2362
2363 subreq = tldap_msg_send(state, ev, ld, state->id, state->out,
2364 sctrls, num_sctrls);
2365 if (tevent_req_nomem(subreq, req)) {
2366 return tevent_req_post(req, ev);
2367 }
2368 tevent_req_set_callback(subreq, tldap_add_done, req);
2369 return req;
2370
2371 err:
2372
2373 tevent_req_ldap_error(req, TLDAP_ENCODING_ERROR);
2374 return tevent_req_post(req, ev);
2375 }
2376
2377 static void tldap_add_done(struct tevent_req *subreq)
2378 {
2379 tldap_simple_done(subreq, TLDAP_RES_ADD);
2380 }
2381
2382 TLDAPRC tldap_add_recv(struct tevent_req *req)
2383 {
2384 return tldap_simple_recv(req);
2385 }
2386
2387 TLDAPRC tldap_add(struct tldap_context *ld, const char *dn,
2388 struct tldap_mod *attributes, int num_attributes,
2389 struct tldap_control *sctrls, int num_sctrls,
2390 struct tldap_control *cctrls, int num_cctrls)
2391 {
2392 TALLOC_CTX *frame = talloc_stackframe();
2393 struct tevent_context *ev;
2394 struct tevent_req *req;
2395 TLDAPRC rc = TLDAP_NO_MEMORY;
2396
2397 ev = samba_tevent_context_init(frame);
2398 if (ev == NULL) {
2399 goto fail;
2400 }
2401 req = tldap_add_send(frame, ev, ld, dn, attributes, num_attributes,
2402 sctrls, num_sctrls, cctrls, num_cctrls);
2403 if (req == NULL) {
2404 goto fail;
2405 }
2406 if (!tevent_req_poll(req, ev)) {
2407 rc = TLDAP_OPERATIONS_ERROR;
2408 goto fail;
2409 }
2410 rc = tldap_add_recv(req);
2411 tldap_save_msg(ld, req);
2412 fail:
2413 TALLOC_FREE(frame);
2414 return rc;
2415 }
2416
2417 static void tldap_modify_done(struct tevent_req *subreq);
2418
2419 struct tevent_req *tldap_modify_send(TALLOC_CTX *mem_ctx,
2420 struct tevent_context *ev,
2421 struct tldap_context *ld,
2422 const char *dn,
2423 struct tldap_mod *mods, int num_mods,
2424 struct tldap_control *sctrls,
2425 int num_sctrls,
2426 struct tldap_control *cctrls,
2427 int num_cctrls)
2428 {
2429 struct tevent_req *req, *subreq;
2430 struct tldap_req_state *state;
2431 int i, j;
2432
2433 req = tldap_req_create(mem_ctx, ld, &state);
2434 if (req == NULL) {
2435 return NULL;
2436 }
2437
2438 if (!asn1_push_tag(state->out, TLDAP_REQ_MODIFY)) goto err;
2439 if (!asn1_write_OctetString(state->out, dn, strlen(dn))) goto err;
2440 if (!asn1_push_tag(state->out, ASN1_SEQUENCE(0))) goto err;
2441
2442 for (i=0; i<num_mods; i++) {
2443 struct tldap_mod *mod = &mods[i];
2444 if (!asn1_push_tag(state->out, ASN1_SEQUENCE(0))) goto err;
2445 if (!asn1_write_enumerated(state->out, mod->mod_op)) goto err;
2446 if (!asn1_push_tag(state->out, ASN1_SEQUENCE(0))) goto err;
2447 if (!asn1_write_OctetString(state->out, mod->attribute,
2448 strlen(mod->attribute))) goto err;
2449 if (!asn1_push_tag(state->out, ASN1_SET)) goto err;
2450 for (j=0; j<mod->num_values; j++) {
2451 if (!asn1_write_OctetString(state->out,
2452 mod->values[j].data,
2453 mod->values[j].length)) goto err;
2454 }
2455 if (!asn1_pop_tag(state->out)) goto err;
2456 if (!asn1_pop_tag(state->out)) goto err;
2457 if (!asn1_pop_tag(state->out)) goto err;
2458 }
2459
2460 if (!asn1_pop_tag(state->out)) goto err;
2461 if (!asn1_pop_tag(state->out)) goto err;
2462
2463 subreq = tldap_msg_send(state, ev, ld, state->id, state->out,
2464 sctrls, num_sctrls);
2465 if (tevent_req_nomem(subreq, req)) {
2466 return tevent_req_post(req, ev);
2467 }
2468 tevent_req_set_callback(subreq, tldap_modify_done, req);
2469 return req;
2470
2471 err:
2472
2473 tevent_req_ldap_error(req, TLDAP_ENCODING_ERROR);
2474 return tevent_req_post(req, ev);
2475 }
2476
2477 static void tldap_modify_done(struct tevent_req *subreq)
2478 {
2479 tldap_simple_done(subreq, TLDAP_RES_MODIFY);
2480 }
2481
2482 TLDAPRC tldap_modify_recv(struct tevent_req *req)
2483 {
2484 return tldap_simple_recv(req);
2485 }
2486
2487 TLDAPRC tldap_modify(struct tldap_context *ld, const char *dn,
2488 struct tldap_mod *mods, int num_mods,
2489 struct tldap_control *sctrls, int num_sctrls,
2490 struct tldap_control *cctrls, int num_cctrls)
2491 {
2492 TALLOC_CTX *frame = talloc_stackframe();
2493 struct tevent_context *ev;
2494 struct tevent_req *req;
2495 TLDAPRC rc = TLDAP_NO_MEMORY;
2496
2497 ev = samba_tevent_context_init(frame);
2498 if (ev == NULL) {
2499 goto fail;
2500 }
2501 req = tldap_modify_send(frame, ev, ld, dn, mods, num_mods,
2502 sctrls, num_sctrls, cctrls, num_cctrls);
2503 if (req == NULL) {
2504 goto fail;
2505 }
2506 if (!tevent_req_poll(req, ev)) {
2507 rc = TLDAP_OPERATIONS_ERROR;
2508 goto fail;
2509 }
2510 rc = tldap_modify_recv(req);
2511 tldap_save_msg(ld, req);
2512 fail:
2513 TALLOC_FREE(frame);
2514 return rc;
2515 }
2516
2517 static void tldap_delete_done(struct tevent_req *subreq);
2518
2519 struct tevent_req *tldap_delete_send(TALLOC_CTX *mem_ctx,
2520 struct tevent_context *ev,
2521 struct tldap_context *ld,
2522 const char *dn,
2523 struct tldap_control *sctrls,
2524 int num_sctrls,
2525 struct tldap_control *cctrls,
2526 int num_cctrls)
2527 {
2528 struct tevent_req *req, *subreq;
2529 struct tldap_req_state *state;
2530
2531 req = tldap_req_create(mem_ctx, ld, &state);
2532 if (req == NULL) {
2533 return NULL;
2534 }
2535
2536 if (!asn1_push_tag(state->out, TLDAP_REQ_DELETE)) goto err;
2537 if (!asn1_write(state->out, dn, strlen(dn))) goto err;
2538 if (!asn1_pop_tag(state->out)) goto err;
2539
2540 subreq = tldap_msg_send(state, ev, ld, state->id, state->out,
2541 sctrls, num_sctrls);
2542 if (tevent_req_nomem(subreq, req)) {
2543 return tevent_req_post(req, ev);
2544 }
2545 tevent_req_set_callback(subreq, tldap_delete_done, req);
2546 return req;
2547
2548 err:
2549
2550 tevent_req_ldap_error(req, TLDAP_ENCODING_ERROR);
2551 return tevent_req_post(req, ev);
2552 }
2553
2554 static void tldap_delete_done(struct tevent_req *subreq)
2555 {
2556 tldap_simple_done(subreq, TLDAP_RES_DELETE);
2557 }
2558
2559 TLDAPRC tldap_delete_recv(struct tevent_req *req)
2560 {
2561 return tldap_simple_recv(req);
2562 }
2563
2564 TLDAPRC tldap_delete(struct tldap_context *ld, const char *dn,
2565 struct tldap_control *sctrls, int num_sctrls,
2566 struct tldap_control *cctrls, int num_cctrls)
2567 {
2568 TALLOC_CTX *frame = talloc_stackframe();
2569 struct tevent_context *ev;
2570 struct tevent_req *req;
2571 TLDAPRC rc = TLDAP_NO_MEMORY;
2572
2573 ev = samba_tevent_context_init(frame);
2574 if (ev == NULL) {
2575 goto fail;
2576 }
2577 req = tldap_delete_send(frame, ev, ld, dn, sctrls, num_sctrls,
2578 cctrls, num_cctrls);
2579 if (req == NULL) {
2580 goto fail;
2581 }
2582 if (!tevent_req_poll(req, ev)) {
2583 rc = TLDAP_OPERATIONS_ERROR;
2584 goto fail;
2585 }
2586 rc = tldap_delete_recv(req);
2587 tldap_save_msg(ld, req);
2588 fail:
2589 TALLOC_FREE(frame);
2590 return rc;
2591 }
2592
2593 static void tldap_extended_done(struct tevent_req *subreq);
2594
2595 struct tevent_req *tldap_extended_send(TALLOC_CTX *mem_ctx,
2596 struct tevent_context *ev,
2597 struct tldap_context *ld,
2598 const char *in_oid,
2599 const DATA_BLOB *in_blob,
2600 struct tldap_control *sctrls,
2601 int num_sctrls,
2602 struct tldap_control *cctrls,
2603 int num_cctrls)
2604 {
2605 struct tevent_req *req, *subreq;
2606 struct tldap_req_state *state;
2607
2608 req = tldap_req_create(mem_ctx, ld, &state);
2609 if (req == NULL) {
2610 return NULL;
2611 }
2612
2613 if (!asn1_push_tag(state->out, TLDAP_REQ_EXTENDED)) goto err;
2614
2615 if (!asn1_push_tag(state->out, ASN1_CONTEXT_SIMPLE(0))) goto err;
2616 if (!asn1_write(state->out, in_oid, strlen(in_oid))) goto err;
2617 if (!asn1_pop_tag(state->out)) goto err;
2618
2619 if (in_blob != NULL) {
2620 if (!asn1_push_tag(state->out, ASN1_CONTEXT_SIMPLE(1))) goto err;
2621 if (!asn1_write_OctetString(state->out, in_blob->data, in_blob->length)) goto err;
2622 if (!asn1_pop_tag(state->out)) goto err;
2623 }
2624
2625 if (!asn1_pop_tag(state->out)) goto err;
2626
2627 subreq = tldap_msg_send(state, ev, ld, state->id, state->out,
2628 sctrls, num_sctrls);
2629 if (tevent_req_nomem(subreq, req)) {
2630 return tevent_req_post(req, ev);
2631 }
2632 tevent_req_set_callback(subreq, tldap_extended_done, req);
2633 return req;
2634
2635 err:
2636
2637 tevent_req_ldap_error(req, TLDAP_ENCODING_ERROR);
2638 return tevent_req_post(req, ev);
2639 }
2640
2641 static void tldap_extended_done(struct tevent_req *subreq)
2642 {
2643 struct tevent_req *req = tevent_req_callback_data(
2644 subreq, struct tevent_req);
2645 struct tldap_req_state *state = tevent_req_data(
2646 req, struct tldap_req_state);
2647 TLDAPRC rc;
2648 bool ok;
2649
2650 rc = tldap_msg_recv(subreq, state, &state->result);
2651 TALLOC_FREE(subreq);
2652 if (tevent_req_ldap_error(req, rc)) {
2653 return;
2654 }
2655 if (state->result->type != TLDAP_RES_EXTENDED) {
2656 tevent_req_ldap_error(req, TLDAP_PROTOCOL_ERROR);
2657 return;
2658 }
2659
2660 ok = asn1_start_tag(state->result->data, TLDAP_RES_EXTENDED);
2661 ok &= tldap_decode_response(state);
2662
2663 if (asn1_peek_tag(state->result->data, ASN1_CONTEXT_SIMPLE(10))) {
2664 ok &= asn1_start_tag(state->result->data,
2665 ASN1_CONTEXT_SIMPLE(10));
2666 if (!ok) {
2667 goto decode_error;
2668 }
2669
2670 ok &= asn1_read_LDAPString(state->result->data,
2671 state->result,
2672 &state->result->res_extended.oid);
2673
2674 ok &= asn1_end_tag(state->result->data);
2675 }
2676
2677 if (asn1_peek_tag(state->result->data, ASN1_CONTEXT_SIMPLE(11))) {
2678 int len;
2679
2680 ok &= asn1_start_tag(state->result->data,
2681 ASN1_CONTEXT_SIMPLE(11));
2682 if (!ok) {
2683 goto decode_error;
2684 }
2685
2686 len = asn1_tag_remaining(state->result->data);
2687 if (len == -1) {
2688 goto decode_error;
2689 }
2690
2691 state->result->res_extended.blob =
2692 data_blob_talloc(state->result, NULL, len);
2693 if (state->result->res_extended.blob.data == NULL) {
2694 goto decode_error;
2695 }
2696
2697 ok = asn1_read(state->result->data,
2698 state->result->res_extended.blob.data,
2699 state->result->res_extended.blob.length);
2700
2701 ok &= asn1_end_tag(state->result->data);
2702 }
2703
2704 ok &= asn1_end_tag(state->result->data);
2705
2706 if (!ok) {
2707 goto decode_error;
2708 }
2709
2710 if (!TLDAP_RC_IS_SUCCESS(state->result->lderr)) {
2711 tevent_req_ldap_error(req, state->result->lderr);
2712 return;
2713 }
2714 tevent_req_done(req);
2715 return;
2716
2717 decode_error:
2718 tevent_req_ldap_error(req, TLDAP_DECODING_ERROR);
2719 return;
2720 }
2721
2722 TLDAPRC tldap_extended_recv(struct tevent_req *req,
2723 TALLOC_CTX *mem_ctx,
2724 char **out_oid,
2725 DATA_BLOB *out_blob)
2726 {
2727 struct tldap_req_state *state = tevent_req_data(
2728 req, struct tldap_req_state);
2729 TLDAPRC rc;
2730
2731 if (tevent_req_is_ldap_error(req, &rc)) {
2732 return rc;
2733 }
2734
2735 if (out_oid != NULL) {
2736 *out_oid = talloc_move(mem_ctx,
2737 &state->result->res_extended.oid);
2738 }
2739
2740 if (out_blob != NULL) {
2741 out_blob->data = talloc_move(mem_ctx,
2742 &state->result->res_extended.blob.data);
2743 out_blob->length =
2744 state->result->res_extended.blob.length;
2745 }
2746
2747 return state->result->lderr;
2748 }
2749
2750 TLDAPRC tldap_extended(struct tldap_context *ld,
2751 const char *in_oid,
2752 const DATA_BLOB *in_blob,
2753 struct tldap_control *sctrls,
2754 int num_sctrls,
2755 struct tldap_control *cctrls,
2756 int num_cctrls,
2757 TALLOC_CTX *mem_ctx,
2758 char **out_oid,
2759 DATA_BLOB *out_blob)
2760 {
2761 TALLOC_CTX *frame = talloc_stackframe();
2762 struct tevent_context *ev;
2763 struct tevent_req *req;
2764 TLDAPRC rc = TLDAP_NO_MEMORY;
2765
2766 ev = samba_tevent_context_init(frame);
2767 if (ev == NULL) {
2768 goto fail;
2769 }
2770 req = tldap_extended_send(frame, ev, ld,
2771 in_oid, in_blob,
2772 sctrls, num_sctrls,
2773 cctrls, num_cctrls);
2774 if (req == NULL) {
2775 goto fail;
2776 }
2777 if (!tevent_req_poll(req, ev)) {
2778 rc = TLDAP_OPERATIONS_ERROR;
2779 goto fail;
2780 }
2781 rc = tldap_extended_recv(req, mem_ctx, out_oid, out_blob);
2782 tldap_save_msg(ld, req);
2783 fail:
2784 TALLOC_FREE(frame);
2785 return rc;
2786 }
2787
2788 int tldap_msg_id(const struct tldap_message *msg)
2789 {
2790 return msg->id;
2791 }
2792
2793 int tldap_msg_type(const struct tldap_message *msg)
2794 {
2795 return msg->type;
2796 }
2797
2798 const char *tldap_msg_matcheddn(struct tldap_message *msg)
2799 {
2800 if (msg == NULL) {
2801 return NULL;
2802 }
2803 return msg->res_matcheddn;
2804 }
2805
2806 const char *tldap_msg_diagnosticmessage(struct tldap_message *msg)
2807 {
2808 if (msg == NULL) {
2809 return NULL;
2810 }
2811 return msg->res_diagnosticmessage;
2812 }
2813
2814 const char *tldap_msg_referral(struct tldap_message *msg)
2815 {
2816 if (msg == NULL) {
2817 return NULL;
2818 }
2819 return msg->res_referral;
2820 }
2821
2822 void tldap_msg_sctrls(struct tldap_message *msg, int *num_sctrls,
2823 struct tldap_control **sctrls)
2824 {
2825 if (msg == NULL) {
2826 *sctrls = NULL;
2827 *num_sctrls = 0;
2828 return;
2829 }
2830 *sctrls = msg->res_sctrls;
2831 *num_sctrls = talloc_array_length(msg->res_sctrls);
2832 }
2833
2834 struct tldap_message *tldap_ctx_lastmsg(struct tldap_context *ld)
2835 {
2836 return ld->last_msg;
2837 }
2838
2839 static const struct { TLDAPRC rc; const char *string; } tldaprc_errmap[] =
2840 {
2841 { TLDAP_SUCCESS,
2842 "TLDAP_SUCCESS" },
2843 { TLDAP_OPERATIONS_ERROR,
2844 "TLDAP_OPERATIONS_ERROR" },
2845 { TLDAP_PROTOCOL_ERROR,
2846 "TLDAP_PROTOCOL_ERROR" },
2847 { TLDAP_TIMELIMIT_EXCEEDED,
2848 "TLDAP_TIMELIMIT_EXCEEDED" },
2849 { TLDAP_SIZELIMIT_EXCEEDED,
2850 "TLDAP_SIZELIMIT_EXCEEDED" },
2851 { TLDAP_COMPARE_FALSE,
2852 "TLDAP_COMPARE_FALSE" },
2853 { TLDAP_COMPARE_TRUE,
2854 "TLDAP_COMPARE_TRUE" },
2855 { TLDAP_STRONG_AUTH_NOT_SUPPORTED,
2856 "TLDAP_STRONG_AUTH_NOT_SUPPORTED" },
2857 { TLDAP_STRONG_AUTH_REQUIRED,
2858 "TLDAP_STRONG_AUTH_REQUIRED" },
2859 { TLDAP_REFERRAL,
2860 "TLDAP_REFERRAL" },
2861 { TLDAP_ADMINLIMIT_EXCEEDED,
2862 "TLDAP_ADMINLIMIT_EXCEEDED" },
2863 { TLDAP_UNAVAILABLE_CRITICAL_EXTENSION,
2864 "TLDAP_UNAVAILABLE_CRITICAL_EXTENSION" },
2865 { TLDAP_CONFIDENTIALITY_REQUIRED,
2866 "TLDAP_CONFIDENTIALITY_REQUIRED" },
2867 { TLDAP_SASL_BIND_IN_PROGRESS,
2868 "TLDAP_SASL_BIND_IN_PROGRESS" },
2869 { TLDAP_NO_SUCH_ATTRIBUTE,
2870 "TLDAP_NO_SUCH_ATTRIBUTE" },
2871 { TLDAP_UNDEFINED_TYPE,
2872 "TLDAP_UNDEFINED_TYPE" },
2873 { TLDAP_INAPPROPRIATE_MATCHING,
2874 "TLDAP_INAPPROPRIATE_MATCHING" },
2875 { TLDAP_CONSTRAINT_VIOLATION,
2876 "TLDAP_CONSTRAINT_VIOLATION" },
2877 { TLDAP_TYPE_OR_VALUE_EXISTS,
2878 "TLDAP_TYPE_OR_VALUE_EXISTS" },
2879 { TLDAP_INVALID_SYNTAX,
2880 "TLDAP_INVALID_SYNTAX" },
2881 { TLDAP_NO_SUCH_OBJECT,
2882 "TLDAP_NO_SUCH_OBJECT" },
2883 { TLDAP_ALIAS_PROBLEM,
2884 "TLDAP_ALIAS_PROBLEM" },
2885 { TLDAP_INVALID_DN_SYNTAX,
2886 "TLDAP_INVALID_DN_SYNTAX" },
2887 { TLDAP_IS_LEAF,
2888 "TLDAP_IS_LEAF" },
2889 { TLDAP_ALIAS_DEREF_PROBLEM,
2890 "TLDAP_ALIAS_DEREF_PROBLEM" },
2891 { TLDAP_INAPPROPRIATE_AUTH,
2892 "TLDAP_INAPPROPRIATE_AUTH" },
2893 { TLDAP_INVALID_CREDENTIALS,
2894 "TLDAP_INVALID_CREDENTIALS" },
2895 { TLDAP_INSUFFICIENT_ACCESS,
2896 "TLDAP_INSUFFICIENT_ACCESS" },
2897 { TLDAP_BUSY,
2898 "TLDAP_BUSY" },
2899 { TLDAP_UNAVAILABLE,
2900 "TLDAP_UNAVAILABLE" },
2901 { TLDAP_UNWILLING_TO_PERFORM,
2902 "TLDAP_UNWILLING_TO_PERFORM" },
2903 { TLDAP_LOOP_DETECT,
2904 "TLDAP_LOOP_DETECT" },
2905 { TLDAP_NAMING_VIOLATION,
2906 "TLDAP_NAMING_VIOLATION" },
2907 { TLDAP_OBJECT_CLASS_VIOLATION,
2908 "TLDAP_OBJECT_CLASS_VIOLATION" },
2909 { TLDAP_NOT_ALLOWED_ON_NONLEAF,
2910 "TLDAP_NOT_ALLOWED_ON_NONLEAF" },
2911 { TLDAP_NOT_ALLOWED_ON_RDN,
2912 "TLDAP_NOT_ALLOWED_ON_RDN" },
2913 { TLDAP_ALREADY_EXISTS,
2914 "TLDAP_ALREADY_EXISTS" },
2915 { TLDAP_NO_OBJECT_CLASS_MODS,
2916 "TLDAP_NO_OBJECT_CLASS_MODS" },
2917 { TLDAP_RESULTS_TOO_LARGE,
2918 "TLDAP_RESULTS_TOO_LARGE" },
2919 { TLDAP_AFFECTS_MULTIPLE_DSAS,
2920 "TLDAP_AFFECTS_MULTIPLE_DSAS" },
2921 { TLDAP_OTHER,
2922 "TLDAP_OTHER" },
2923 { TLDAP_SERVER_DOWN,
2924 "TLDAP_SERVER_DOWN" },
2925 { TLDAP_LOCAL_ERROR,
2926 "TLDAP_LOCAL_ERROR" },
2927 { TLDAP_ENCODING_ERROR,
2928 "TLDAP_ENCODING_ERROR" },
2929 { TLDAP_DECODING_ERROR,
2930 "TLDAP_DECODING_ERROR" },
2931 { TLDAP_TIMEOUT,
2932 "TLDAP_TIMEOUT" },
2933 { TLDAP_AUTH_UNKNOWN,
2934 "TLDAP_AUTH_UNKNOWN" },
2935 { TLDAP_FILTER_ERROR,
2936 "TLDAP_FILTER_ERROR" },
2937 { TLDAP_USER_CANCELLED,
2938 "TLDAP_USER_CANCELLED" },
2939 { TLDAP_PARAM_ERROR,
2940 "TLDAP_PARAM_ERROR" },
2941 { TLDAP_NO_MEMORY,
2942 "TLDAP_NO_MEMORY" },
2943 { TLDAP_CONNECT_ERROR,
2944 "TLDAP_CONNECT_ERROR" },
2945 { TLDAP_NOT_SUPPORTED,
2946 "TLDAP_NOT_SUPPORTED" },
2947 { TLDAP_CONTROL_NOT_FOUND,
2948 "TLDAP_CONTROL_NOT_FOUND" },
2949 { TLDAP_NO_RESULTS_RETURNED,
2950 "TLDAP_NO_RESULTS_RETURNED" },
2951 { TLDAP_MORE_RESULTS_TO_RETURN,
2952 "TLDAP_MORE_RESULTS_TO_RETURN" },
2953 { TLDAP_CLIENT_LOOP,
2954 "TLDAP_CLIENT_LOOP" },
2955 { TLDAP_REFERRAL_LIMIT_EXCEEDED,
2956 "TLDAP_REFERRAL_LIMIT_EXCEEDED" },
2957 };
2958
2959 const char *tldap_rc2string(TLDAPRC rc)
2960 {
2961 size_t i;
2962
2963 for (i=0; i<ARRAY_SIZE(tldaprc_errmap); i++) {
2964 if (TLDAP_RC_EQUAL(rc, tldaprc_errmap[i].rc)) {
2965 return tldaprc_errmap[i].string;
2966 }
2967 }
2968
2969 return "Unknown LDAP Error";
2970 }
Samba GIT mirror