2 Unix SMB/CIFS mplementation.
3 LDAP protocol helper functions for SAMBA
5 Copyright (C) Andrew Tridgell 2004
6 Copyright (C) Volker Lendecke 2004
7 Copyright (C) Stefan Metzmacher 2004
8 Copyright (C) Simo Sorce 2004
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
27 #include "lib/socket/socket.h"
28 #include "../lib/util/asn1.h"
29 #include "../lib/util/dlinklist.h"
30 #include "libcli/ldap/ldap.h"
31 #include "libcli/ldap/ldap_proto.h"
32 #include "libcli/ldap/ldap_client.h"
33 #include "libcli/composite/composite.h"
34 #include "lib/stream/packet.h"
35 #include "lib/tls/tls.h"
36 #include "auth/gensec/gensec.h"
37 #include "system/time.h"
38 #include "param/param.h"
39 #include "libcli/resolve/resolve.h"
42 create a new ldap_connection stucture. The event context is optional
44 _PUBLIC_
struct ldap_connection
*ldap4_new_connection(TALLOC_CTX
*mem_ctx
,
45 struct loadparm_context
*lp_ctx
,
46 struct tevent_context
*ev
)
48 struct ldap_connection
*conn
;
54 conn
= talloc_zero(mem_ctx
, struct ldap_connection
);
59 conn
->next_messageid
= 1;
60 conn
->event
.event_ctx
= ev
;
62 conn
->lp_ctx
= lp_ctx
;
64 /* set a reasonable request timeout */
67 /* explicitly avoid reconnections by default */
68 conn
->reconnect
.max_retries
= 0;
74 the connection is dead
76 static void ldap_connection_dead(struct ldap_connection
*conn
)
78 struct ldap_request
*req
;
80 talloc_free(conn
->sock
); /* this will also free event.fde */
81 talloc_free(conn
->packet
);
83 conn
->event
.fde
= NULL
;
86 /* return an error for any pending request ... */
87 while (conn
->pending
) {
89 DLIST_REMOVE(req
->conn
->pending
, req
);
90 req
->state
= LDAP_REQUEST_DONE
;
91 req
->status
= NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
98 static void ldap_reconnect(struct ldap_connection
*conn
);
103 static void ldap_error_handler(void *private_data
, NTSTATUS status
)
105 struct ldap_connection
*conn
= talloc_get_type(private_data
,
106 struct ldap_connection
);
107 ldap_connection_dead(conn
);
109 /* but try to reconnect so that the ldb client can go on */
110 ldap_reconnect(conn
);
115 match up with a pending message, adding to the replies list
117 static void ldap_match_message(struct ldap_connection
*conn
, struct ldap_message
*msg
)
119 struct ldap_request
*req
;
122 for (req
=conn
->pending
; req
; req
=req
->next
) {
123 if (req
->messageid
== msg
->messageid
) break;
125 /* match a zero message id to the last request sent.
126 It seems that servers send 0 if unable to parse */
127 if (req
== NULL
&& msg
->messageid
== 0) {
131 DEBUG(0,("ldap: no matching message id for %u\n",
137 /* Check for undecoded critical extensions */
138 for (i
=0; msg
->controls
&& msg
->controls
[i
]; i
++) {
139 if (!msg
->controls_decoded
[i
] &&
140 msg
->controls
[i
]->critical
) {
141 req
->status
= NT_STATUS_LDAP(LDAP_UNAVAILABLE_CRITICAL_EXTENSION
);
142 req
->state
= LDAP_REQUEST_DONE
;
143 DLIST_REMOVE(conn
->pending
, req
);
151 /* add to the list of replies received */
152 talloc_steal(req
, msg
);
153 req
->replies
= talloc_realloc(req
, req
->replies
,
154 struct ldap_message
*, req
->num_replies
+1);
155 if (req
->replies
== NULL
) {
156 req
->status
= NT_STATUS_NO_MEMORY
;
157 req
->state
= LDAP_REQUEST_DONE
;
158 DLIST_REMOVE(conn
->pending
, req
);
165 req
->replies
[req
->num_replies
] = talloc_steal(req
->replies
, msg
);
168 if (msg
->type
!= LDAP_TAG_SearchResultEntry
&&
169 msg
->type
!= LDAP_TAG_SearchResultReference
) {
170 /* currently only search results expect multiple
172 req
->state
= LDAP_REQUEST_DONE
;
173 DLIST_REMOVE(conn
->pending
, req
);
183 decode/process LDAP data
185 static NTSTATUS
ldap_recv_handler(void *private_data
, DATA_BLOB blob
)
188 struct ldap_connection
*conn
= talloc_get_type(private_data
,
189 struct ldap_connection
);
190 struct ldap_message
*msg
= talloc(conn
, struct ldap_message
);
191 struct asn1_data
*asn1
= asn1_init(conn
);
193 if (asn1
== NULL
|| msg
== NULL
) {
194 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR
);
197 if (!asn1_load(asn1
, blob
)) {
200 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR
);
203 status
= ldap_decode(asn1
, samba_ldap_control_handlers(), msg
);
204 if (!NT_STATUS_IS_OK(status
)) {
209 ldap_match_message(conn
, msg
);
211 data_blob_free(&blob
);
216 /* Handle read events, from the GENSEC socket callback, or real events */
217 void ldap_read_io_handler(void *private_data
, uint16_t flags
)
219 struct ldap_connection
*conn
= talloc_get_type(private_data
,
220 struct ldap_connection
);
221 packet_recv(conn
->packet
);
225 handle ldap socket events
227 static void ldap_io_handler(struct tevent_context
*ev
, struct tevent_fd
*fde
,
228 uint16_t flags
, void *private_data
)
230 struct ldap_connection
*conn
= talloc_get_type(private_data
,
231 struct ldap_connection
);
232 if (flags
& TEVENT_FD_WRITE
) {
233 packet_queue_run(conn
->packet
);
234 if (!tls_enabled(conn
->sock
)) return;
236 if (flags
& TEVENT_FD_READ
) {
237 ldap_read_io_handler(private_data
, flags
);
244 static NTSTATUS
ldap_parse_basic_url(TALLOC_CTX
*mem_ctx
, const char *url
,
245 char **host
, uint16_t *port
, bool *ldaps
)
253 SMB_ASSERT(sizeof(protocol
)>10 && sizeof(tmp_host
)>254);
255 ret
= sscanf(url
, "%10[^:]://%254[^:/]:%d", protocol
, tmp_host
, &tmp_port
);
257 return NT_STATUS_INVALID_PARAMETER
;
260 if (strequal(protocol
, "ldap")) {
263 } else if (strequal(protocol
, "ldaps")) {
267 DEBUG(0, ("unrecognised ldap protocol (%s)!\n", protocol
));
268 return NT_STATUS_PROTOCOL_UNREACHABLE
;
274 *host
= talloc_strdup(mem_ctx
, tmp_host
);
275 NT_STATUS_HAVE_NO_MEMORY(*host
);
281 connect to a ldap server
284 struct ldap_connect_state
{
285 struct composite_context
*ctx
;
286 struct ldap_connection
*conn
;
289 static void ldap_connect_recv_unix_conn(struct composite_context
*ctx
);
290 static void ldap_connect_recv_tcp_conn(struct composite_context
*ctx
);
292 _PUBLIC_
struct composite_context
*ldap_connect_send(struct ldap_connection
*conn
,
295 struct composite_context
*result
, *ctx
;
296 struct ldap_connect_state
*state
;
300 result
= talloc_zero(conn
, struct composite_context
);
301 if (result
== NULL
) goto failed
;
302 result
->state
= COMPOSITE_STATE_IN_PROGRESS
;
303 result
->async
.fn
= NULL
;
304 result
->event_ctx
= conn
->event
.event_ctx
;
306 state
= talloc(result
, struct ldap_connect_state
);
307 if (state
== NULL
) goto failed
;
309 result
->private_data
= state
;
313 if (conn
->reconnect
.url
== NULL
) {
314 conn
->reconnect
.url
= talloc_strdup(conn
, url
);
315 if (conn
->reconnect
.url
== NULL
) goto failed
;
319 SMB_ASSERT(sizeof(protocol
)>10);
321 ret
= sscanf(url
, "%10[^:]://", protocol
);
326 if (strequal(protocol
, "ldapi")) {
327 struct socket_address
*unix_addr
;
330 NTSTATUS status
= socket_create("unix", SOCKET_TYPE_STREAM
, &conn
->sock
, 0);
331 if (!NT_STATUS_IS_OK(status
)) {
334 talloc_steal(conn
, conn
->sock
);
335 SMB_ASSERT(sizeof(protocol
)>10);
336 SMB_ASSERT(sizeof(path
)>1024);
338 /* LDAPI connections are to localhost, so give the
339 * local host name as the target for gensec's
340 * DIGEST-MD5 mechanism */
341 conn
->host
= talloc_asprintf(conn
, "%s.%s", lp_netbios_name(conn
->lp_ctx
), lp_realm(conn
->lp_ctx
));
342 if (composite_nomem(conn
->host
, state
->ctx
)) {
346 /* The %c specifier doesn't null terminate :-( */
348 ret
= sscanf(url
, "%10[^:]://%1025c", protocol
, path
);
350 composite_error(state
->ctx
, NT_STATUS_INVALID_PARAMETER
);
354 rfc1738_unescape(path
);
356 unix_addr
= socket_address_from_strings(conn
, conn
->sock
->backend_name
,
362 ctx
= socket_connect_send(conn
->sock
, NULL
, unix_addr
,
363 0, conn
->event
.event_ctx
);
364 ctx
->async
.fn
= ldap_connect_recv_unix_conn
;
365 ctx
->async
.private_data
= state
;
368 NTSTATUS status
= ldap_parse_basic_url(conn
, url
, &conn
->host
,
369 &conn
->port
, &conn
->ldaps
);
370 if (!NT_STATUS_IS_OK(state
->ctx
->status
)) {
371 composite_error(state
->ctx
, status
);
375 ctx
= socket_connect_multi_send(state
, conn
->host
, 1, &conn
->port
,
376 lp_resolve_context(conn
->lp_ctx
), conn
->event
.event_ctx
);
377 if (ctx
== NULL
) goto failed
;
379 ctx
->async
.fn
= ldap_connect_recv_tcp_conn
;
380 ctx
->async
.private_data
= state
;
388 static void ldap_connect_got_sock(struct composite_context
*ctx
,
389 struct ldap_connection
*conn
)
391 /* setup a handler for events on this socket */
392 conn
->event
.fde
= tevent_add_fd(conn
->event
.event_ctx
, conn
->sock
,
393 socket_get_fd(conn
->sock
),
394 TEVENT_FD_READ
, ldap_io_handler
, conn
);
395 if (conn
->event
.fde
== NULL
) {
396 composite_error(ctx
, NT_STATUS_INTERNAL_ERROR
);
400 tevent_fd_set_close_fn(conn
->event
.fde
, socket_tevent_fd_close_fn
);
401 socket_set_flags(conn
->sock
, SOCKET_FLAG_NOCLOSE
);
403 talloc_steal(conn
, conn
->sock
);
405 struct socket_context
*tls_socket
;
406 char *cafile
= lp_tls_cafile(conn
->sock
, conn
->lp_ctx
);
408 if (!cafile
|| !*cafile
) {
409 talloc_free(conn
->sock
);
413 tls_socket
= tls_init_client(conn
->sock
, conn
->event
.fde
, cafile
);
416 if (tls_socket
== NULL
) {
417 talloc_free(conn
->sock
);
421 conn
->sock
= talloc_steal(conn
, tls_socket
);
424 conn
->packet
= packet_init(conn
);
425 if (conn
->packet
== NULL
) {
426 talloc_free(conn
->sock
);
430 packet_set_private(conn
->packet
, conn
);
431 packet_set_socket(conn
->packet
, conn
->sock
);
432 packet_set_callback(conn
->packet
, ldap_recv_handler
);
433 packet_set_full_request(conn
->packet
, ldap_full_packet
);
434 packet_set_error_handler(conn
->packet
, ldap_error_handler
);
435 packet_set_event_context(conn
->packet
, conn
->event
.event_ctx
);
436 packet_set_fde(conn
->packet
, conn
->event
.fde
);
437 /* packet_set_serialise(conn->packet); */
440 packet_set_unreliable_select(conn
->packet
);
446 static void ldap_connect_recv_tcp_conn(struct composite_context
*ctx
)
448 struct ldap_connect_state
*state
=
449 talloc_get_type(ctx
->async
.private_data
,
450 struct ldap_connect_state
);
451 struct ldap_connection
*conn
= state
->conn
;
453 NTSTATUS status
= socket_connect_multi_recv(ctx
, state
, &conn
->sock
,
455 if (!NT_STATUS_IS_OK(status
)) {
456 composite_error(state
->ctx
, status
);
460 ldap_connect_got_sock(state
->ctx
, conn
);
463 static void ldap_connect_recv_unix_conn(struct composite_context
*ctx
)
465 struct ldap_connect_state
*state
=
466 talloc_get_type(ctx
->async
.private_data
,
467 struct ldap_connect_state
);
468 struct ldap_connection
*conn
= state
->conn
;
470 NTSTATUS status
= socket_connect_recv(ctx
);
472 if (!NT_STATUS_IS_OK(state
->ctx
->status
)) {
473 composite_error(state
->ctx
, status
);
477 ldap_connect_got_sock(state
->ctx
, conn
);
480 _PUBLIC_ NTSTATUS
ldap_connect_recv(struct composite_context
*ctx
)
482 NTSTATUS status
= composite_wait(ctx
);
487 _PUBLIC_ NTSTATUS
ldap_connect(struct ldap_connection
*conn
, const char *url
)
489 struct composite_context
*ctx
= ldap_connect_send(conn
, url
);
490 return ldap_connect_recv(ctx
);
493 /* set reconnect parameters */
495 _PUBLIC_
void ldap_set_reconn_params(struct ldap_connection
*conn
, int max_retries
)
498 conn
->reconnect
.max_retries
= max_retries
;
499 conn
->reconnect
.retries
= 0;
500 conn
->reconnect
.previous
= time(NULL
);
504 /* Actually this function is NOT ASYNC safe, FIXME? */
505 static void ldap_reconnect(struct ldap_connection
*conn
)
508 time_t now
= time(NULL
);
510 /* do we have set up reconnect ? */
511 if (conn
->reconnect
.max_retries
== 0) return;
513 /* is the retry time expired ? */
514 if (now
> conn
->reconnect
.previous
+ 30) {
515 conn
->reconnect
.retries
= 0;
516 conn
->reconnect
.previous
= now
;
519 /* are we reconnectind too often and too fast? */
520 if (conn
->reconnect
.retries
> conn
->reconnect
.max_retries
) return;
522 /* keep track of the number of reconnections */
523 conn
->reconnect
.retries
++;
526 status
= ldap_connect(conn
, conn
->reconnect
.url
);
527 if ( ! NT_STATUS_IS_OK(status
)) {
532 status
= ldap_rebind(conn
);
533 if ( ! NT_STATUS_IS_OK(status
)) {
534 ldap_connection_dead(conn
);
538 /* destroy an open ldap request */
539 static int ldap_request_destructor(struct ldap_request
*req
)
541 if (req
->state
== LDAP_REQUEST_PENDING
) {
542 DLIST_REMOVE(req
->conn
->pending
, req
);
548 called on timeout of a ldap request
550 static void ldap_request_timeout(struct tevent_context
*ev
, struct tevent_timer
*te
,
551 struct timeval t
, void *private_data
)
553 struct ldap_request
*req
= talloc_get_type(private_data
, struct ldap_request
);
554 req
->status
= NT_STATUS_IO_TIMEOUT
;
555 if (req
->state
== LDAP_REQUEST_PENDING
) {
556 DLIST_REMOVE(req
->conn
->pending
, req
);
558 req
->state
= LDAP_REQUEST_DONE
;
566 called on completion of a one-way ldap request
568 static void ldap_request_complete(struct tevent_context
*ev
, struct tevent_timer
*te
,
569 struct timeval t
, void *private_data
)
571 struct ldap_request
*req
= talloc_get_type(private_data
, struct ldap_request
);
578 send a ldap message - async interface
580 _PUBLIC_
struct ldap_request
*ldap_request_send(struct ldap_connection
*conn
,
581 struct ldap_message
*msg
)
583 struct ldap_request
*req
;
584 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
586 req
= talloc_zero(conn
, struct ldap_request
);
587 if (req
== NULL
) return NULL
;
589 if (conn
->sock
== NULL
) {
590 status
= NT_STATUS_INVALID_CONNECTION
;
594 req
->state
= LDAP_REQUEST_SEND
;
596 req
->messageid
= conn
->next_messageid
++;
597 if (conn
->next_messageid
== 0) {
598 conn
->next_messageid
= 1;
600 req
->type
= msg
->type
;
601 if (req
->messageid
== -1) {
605 talloc_set_destructor(req
, ldap_request_destructor
);
607 msg
->messageid
= req
->messageid
;
609 if (!ldap_encode(msg
, samba_ldap_control_handlers(), &req
->data
, req
)) {
610 status
= NT_STATUS_INTERNAL_ERROR
;
614 status
= packet_send(conn
->packet
, req
->data
);
615 if (!NT_STATUS_IS_OK(status
)) {
619 /* some requests don't expect a reply, so don't add those to the
621 if (req
->type
== LDAP_TAG_AbandonRequest
||
622 req
->type
== LDAP_TAG_UnbindRequest
) {
623 req
->status
= NT_STATUS_OK
;
624 req
->state
= LDAP_REQUEST_DONE
;
625 /* we can't call the async callback now, as it isn't setup, so
626 call it as next event */
627 tevent_add_timer(conn
->event
.event_ctx
, req
, timeval_zero(),
628 ldap_request_complete
, req
);
632 req
->state
= LDAP_REQUEST_PENDING
;
633 DLIST_ADD(conn
->pending
, req
);
635 /* put a timeout on the request */
636 req
->time_event
= tevent_add_timer(conn
->event
.event_ctx
, req
,
637 timeval_current_ofs(conn
->timeout
, 0),
638 ldap_request_timeout
, req
);
643 req
->status
= status
;
644 req
->state
= LDAP_REQUEST_ERROR
;
645 tevent_add_timer(conn
->event
.event_ctx
, req
, timeval_zero(),
646 ldap_request_complete
, req
);
653 wait for a request to complete
654 note that this does not destroy the request
656 _PUBLIC_ NTSTATUS
ldap_request_wait(struct ldap_request
*req
)
658 while (req
->state
< LDAP_REQUEST_DONE
) {
659 if (tevent_loop_once(req
->conn
->event
.event_ctx
) != 0) {
660 req
->status
= NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
669 a mapping of ldap response code to strings
671 static const struct {
672 enum ldap_result_code code
;
674 } ldap_code_map
[] = {
675 #define _LDAP_MAP_CODE(c) { c, #c }
676 _LDAP_MAP_CODE(LDAP_SUCCESS
),
677 _LDAP_MAP_CODE(LDAP_OPERATIONS_ERROR
),
678 _LDAP_MAP_CODE(LDAP_PROTOCOL_ERROR
),
679 _LDAP_MAP_CODE(LDAP_TIME_LIMIT_EXCEEDED
),
680 _LDAP_MAP_CODE(LDAP_SIZE_LIMIT_EXCEEDED
),
681 _LDAP_MAP_CODE(LDAP_COMPARE_FALSE
),
682 _LDAP_MAP_CODE(LDAP_COMPARE_TRUE
),
683 _LDAP_MAP_CODE(LDAP_AUTH_METHOD_NOT_SUPPORTED
),
684 _LDAP_MAP_CODE(LDAP_STRONG_AUTH_REQUIRED
),
685 _LDAP_MAP_CODE(LDAP_REFERRAL
),
686 _LDAP_MAP_CODE(LDAP_ADMIN_LIMIT_EXCEEDED
),
687 _LDAP_MAP_CODE(LDAP_UNAVAILABLE_CRITICAL_EXTENSION
),
688 _LDAP_MAP_CODE(LDAP_CONFIDENTIALITY_REQUIRED
),
689 _LDAP_MAP_CODE(LDAP_SASL_BIND_IN_PROGRESS
),
690 _LDAP_MAP_CODE(LDAP_NO_SUCH_ATTRIBUTE
),
691 _LDAP_MAP_CODE(LDAP_UNDEFINED_ATTRIBUTE_TYPE
),
692 _LDAP_MAP_CODE(LDAP_INAPPROPRIATE_MATCHING
),
693 _LDAP_MAP_CODE(LDAP_CONSTRAINT_VIOLATION
),
694 _LDAP_MAP_CODE(LDAP_ATTRIBUTE_OR_VALUE_EXISTS
),
695 _LDAP_MAP_CODE(LDAP_INVALID_ATTRIBUTE_SYNTAX
),
696 _LDAP_MAP_CODE(LDAP_NO_SUCH_OBJECT
),
697 _LDAP_MAP_CODE(LDAP_ALIAS_PROBLEM
),
698 _LDAP_MAP_CODE(LDAP_INVALID_DN_SYNTAX
),
699 _LDAP_MAP_CODE(LDAP_ALIAS_DEREFERENCING_PROBLEM
),
700 _LDAP_MAP_CODE(LDAP_INAPPROPRIATE_AUTHENTICATION
),
701 _LDAP_MAP_CODE(LDAP_INVALID_CREDENTIALS
),
702 _LDAP_MAP_CODE(LDAP_INSUFFICIENT_ACCESS_RIGHTS
),
703 _LDAP_MAP_CODE(LDAP_BUSY
),
704 _LDAP_MAP_CODE(LDAP_UNAVAILABLE
),
705 _LDAP_MAP_CODE(LDAP_UNWILLING_TO_PERFORM
),
706 _LDAP_MAP_CODE(LDAP_LOOP_DETECT
),
707 _LDAP_MAP_CODE(LDAP_NAMING_VIOLATION
),
708 _LDAP_MAP_CODE(LDAP_OBJECT_CLASS_VIOLATION
),
709 _LDAP_MAP_CODE(LDAP_NOT_ALLOWED_ON_NON_LEAF
),
710 _LDAP_MAP_CODE(LDAP_NOT_ALLOWED_ON_RDN
),
711 _LDAP_MAP_CODE(LDAP_ENTRY_ALREADY_EXISTS
),
712 _LDAP_MAP_CODE(LDAP_OBJECT_CLASS_MODS_PROHIBITED
),
713 _LDAP_MAP_CODE(LDAP_AFFECTS_MULTIPLE_DSAS
),
714 _LDAP_MAP_CODE(LDAP_OTHER
)
718 used to setup the status code from a ldap response
720 _PUBLIC_ NTSTATUS
ldap_check_response(struct ldap_connection
*conn
, struct ldap_Result
*r
)
723 const char *codename
= "unknown";
725 if (r
->resultcode
== LDAP_SUCCESS
) {
729 if (conn
->last_error
) {
730 talloc_free(conn
->last_error
);
733 for (i
=0;i
<ARRAY_SIZE(ldap_code_map
);i
++) {
734 if (r
->resultcode
== ldap_code_map
[i
].code
) {
735 codename
= ldap_code_map
[i
].str
;
740 conn
->last_error
= talloc_asprintf(conn
, "LDAP error %u %s - %s <%s> <%s>",
743 r
->dn
?r
->dn
:"(NULL)",
744 r
->errormessage
?r
->errormessage
:"",
745 r
->referral
?r
->referral
:"");
747 return NT_STATUS_LDAP(r
->resultcode
);
751 return error string representing the last error
753 _PUBLIC_
const char *ldap_errstr(struct ldap_connection
*conn
,
757 if (NT_STATUS_IS_LDAP(status
) && conn
->last_error
!= NULL
) {
758 return talloc_strdup(mem_ctx
, conn
->last_error
);
760 return talloc_asprintf(mem_ctx
, "LDAP client internal error: %s", nt_errstr(status
));
765 return the Nth result message, waiting if necessary
767 _PUBLIC_ NTSTATUS
ldap_result_n(struct ldap_request
*req
, int n
, struct ldap_message
**msg
)
771 NT_STATUS_HAVE_NO_MEMORY(req
);
773 while (req
->state
< LDAP_REQUEST_DONE
&& n
>= req
->num_replies
) {
774 if (tevent_loop_once(req
->conn
->event
.event_ctx
) != 0) {
775 return NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
779 if (n
< req
->num_replies
) {
780 *msg
= req
->replies
[n
];
784 if (!NT_STATUS_IS_OK(req
->status
)) {
788 return NT_STATUS_NO_MORE_ENTRIES
;
793 return a single result message, checking if it is of the expected LDAP type
795 _PUBLIC_ NTSTATUS
ldap_result_one(struct ldap_request
*req
, struct ldap_message
**msg
, int type
)
798 status
= ldap_result_n(req
, 0, msg
);
799 if (!NT_STATUS_IS_OK(status
)) {
802 if ((*msg
)->type
!= type
) {
804 return NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
810 a simple ldap transaction, for single result requests that only need a status code
811 this relies on single valued requests having the response type == request type + 1
813 _PUBLIC_ NTSTATUS
ldap_transaction(struct ldap_connection
*conn
, struct ldap_message
*msg
)
815 struct ldap_request
*req
= ldap_request_send(conn
, msg
);
816 struct ldap_message
*res
;
818 status
= ldap_result_n(req
, 0, &res
);
819 if (!NT_STATUS_IS_OK(status
)) {
823 if (res
->type
!= msg
->type
+ 1) {
825 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR
);
827 status
= ldap_check_response(conn
, &res
->r
.GeneralResult
);