2 Unix SMB/CIFS implementation.
6 Copyright (C) Andrew Tridgell 2005
7 Copyright (C) Stefan Metzmacher 2009
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 see RFC1798 for details of CLDAP
27 - carried over UDP on port 389
28 - request and response matched by message ID
29 - request consists of only a single searchRequest element
30 - response can be in one of two forms
31 - a single searchResponse, followed by a searchResult
32 - a single searchResult
37 #include "../lib/util/dlinklist.h"
38 #include "../libcli/ldap/ldap_message.h"
39 #include "../libcli/ldap/ldap_ndr.h"
40 #include "../libcli/cldap/cldap.h"
41 #include "../lib/tsocket/tsocket.h"
42 #include "../libcli/security/dom_sid.h"
43 #include "../librpc/gen_ndr/ndr_nbt.h"
44 #include "../lib/util/asn1.h"
45 #include "../lib/util/tevent_ntstatus.h"
50 context structure for operations on cldap packets
53 /* the low level socket */
54 struct tdgram_context
*sock
;
57 * Are we in connected mode, which means
58 * we get ICMP errors back instead of timing
59 * out requests. And we can only send requests
60 * to the connected peer.
65 * we allow sync requests only, if the caller
66 * did not pass an event context to cldap_socket_init()
70 struct tevent_context
*ctx
;
73 /* the queue for outgoing dgrams */
74 struct tevent_queue
*send_queue
;
76 /* do we have an async tsocket_recvfrom request pending */
77 struct tevent_req
*recv_subreq
;
80 /* a queue of pending search requests */
81 struct cldap_search_state
*list
;
83 /* mapping from message_id to pending request */
84 struct idr_context
*idr
;
87 /* what to do with incoming request packets */
89 void (*handler
)(struct cldap_socket
*,
91 struct cldap_incoming
*);
96 struct cldap_search_state
{
97 struct cldap_search_state
*prev
, *next
;
100 struct cldap_socket
*cldap
;
109 struct tsocket_address
*dest
;
114 struct cldap_incoming
*in
;
115 struct asn1_data
*asn1
;
118 struct tevent_req
*req
;
121 static int cldap_socket_destructor(struct cldap_socket
*c
)
123 while (c
->searches
.list
) {
124 struct cldap_search_state
*s
= c
->searches
.list
;
125 DLIST_REMOVE(c
->searches
.list
, s
);
126 ZERO_STRUCT(s
->caller
);
129 talloc_free(c
->recv_subreq
);
130 talloc_free(c
->send_queue
);
131 talloc_free(c
->sock
);
135 static void cldap_recvfrom_done(struct tevent_req
*subreq
);
137 static bool cldap_recvfrom_setup(struct cldap_socket
*c
)
139 if (c
->recv_subreq
) {
143 if (!c
->searches
.list
&& !c
->incoming
.handler
) {
147 c
->recv_subreq
= tdgram_recvfrom_send(c
, c
->event
.ctx
, c
->sock
);
148 if (!c
->recv_subreq
) {
151 tevent_req_set_callback(c
->recv_subreq
, cldap_recvfrom_done
, c
);
156 static void cldap_recvfrom_stop(struct cldap_socket
*c
)
158 if (!c
->recv_subreq
) {
162 if (c
->searches
.list
|| c
->incoming
.handler
) {
166 talloc_free(c
->recv_subreq
);
167 c
->recv_subreq
= NULL
;
170 static void cldap_socket_recv_dgram(struct cldap_socket
*c
,
171 struct cldap_incoming
*in
);
173 static void cldap_recvfrom_done(struct tevent_req
*subreq
)
175 struct cldap_socket
*c
= tevent_req_callback_data(subreq
,
176 struct cldap_socket
);
177 struct cldap_incoming
*in
= NULL
;
180 c
->recv_subreq
= NULL
;
182 in
= talloc_zero(c
, struct cldap_incoming
);
187 ret
= tdgram_recvfrom_recv(subreq
,
197 if (ret
== -1 && in
->recv_errno
== 0) {
198 in
->recv_errno
= EIO
;
201 /* this function should free or steal 'in' */
202 cldap_socket_recv_dgram(c
, in
);
205 if (!cldap_recvfrom_setup(c
)) {
214 /*TODO: call a dead socket handler */
219 handle recv events on a cldap socket
221 static void cldap_socket_recv_dgram(struct cldap_socket
*c
,
222 struct cldap_incoming
*in
)
225 struct asn1_data
*asn1
;
227 struct cldap_search_state
*search
;
230 if (in
->recv_errno
!= 0) {
234 blob
= data_blob_const(in
->buf
, in
->len
);
236 asn1
= asn1_init(in
);
241 if (!asn1_load(asn1
, blob
)) {
245 in
->ldap_msg
= talloc(in
, struct ldap_message
);
246 if (in
->ldap_msg
== NULL
) {
250 /* this initial decode is used to find the message id */
251 status
= ldap_decode(asn1
, NULL
, in
->ldap_msg
);
252 if (!NT_STATUS_IS_OK(status
)) {
256 /* find the pending request */
257 p
= idr_find(c
->searches
.idr
, in
->ldap_msg
->messageid
);
259 if (!c
->incoming
.handler
) {
263 /* this function should free or steal 'in' */
264 c
->incoming
.handler(c
, c
->incoming
.private_data
, in
);
268 search
= talloc_get_type(p
, struct cldap_search_state
);
269 search
->response
.in
= talloc_move(search
, &in
);
270 search
->response
.asn1
= asn1
;
271 search
->response
.asn1
->ofs
= 0;
273 tevent_req_done(search
->req
);
277 in
->recv_errno
= ENOMEM
;
279 status
= map_nt_error_from_unix(in
->recv_errno
);
281 /* in connected mode the first pending search gets the error */
283 /* otherwise we just ignore the error */
286 if (!c
->searches
.list
) {
289 tevent_req_nterror(c
->searches
.list
->req
, status
);
295 initialise a cldap_sock
297 NTSTATUS
cldap_socket_init(TALLOC_CTX
*mem_ctx
,
298 struct tevent_context
*ev
,
299 const struct tsocket_address
*local_addr
,
300 const struct tsocket_address
*remote_addr
,
301 struct cldap_socket
**_cldap
)
303 struct cldap_socket
*c
= NULL
;
304 struct tsocket_address
*any
= NULL
;
308 c
= talloc_zero(mem_ctx
, struct cldap_socket
);
314 ev
= tevent_context_init(c
);
318 c
->event
.allow_poll
= true;
323 ret
= tsocket_address_inet_from_strings(c
, "ip",
327 status
= map_nt_error_from_unix(errno
);
333 c
->searches
.idr
= idr_init(c
);
334 if (!c
->searches
.idr
) {
338 ret
= tdgram_inet_udp_socket(local_addr
, remote_addr
,
341 status
= map_nt_error_from_unix(errno
);
350 c
->send_queue
= tevent_queue_create(c
, "cldap_send_queue");
351 if (!c
->send_queue
) {
355 talloc_set_destructor(c
, cldap_socket_destructor
);
361 status
= NT_STATUS_NO_MEMORY
;
368 setup a handler for incoming requests
370 NTSTATUS
cldap_set_incoming_handler(struct cldap_socket
*c
,
371 void (*handler
)(struct cldap_socket
*,
373 struct cldap_incoming
*),
377 return NT_STATUS_PIPE_CONNECTED
;
380 /* if sync requests are allowed, we don't allow an incoming handler */
381 if (c
->event
.allow_poll
) {
382 return NT_STATUS_INVALID_PIPE_STATE
;
385 c
->incoming
.handler
= handler
;
386 c
->incoming
.private_data
= private_data
;
388 if (!cldap_recvfrom_setup(c
)) {
389 ZERO_STRUCT(c
->incoming
);
390 return NT_STATUS_NO_MEMORY
;
396 struct cldap_reply_state
{
397 struct tsocket_address
*dest
;
401 static void cldap_reply_state_destroy(struct tevent_req
*subreq
);
404 queue a cldap reply for send
406 NTSTATUS
cldap_reply_send(struct cldap_socket
*cldap
, struct cldap_reply
*io
)
408 struct cldap_reply_state
*state
= NULL
;
409 struct ldap_message
*msg
;
410 DATA_BLOB blob1
, blob2
;
412 struct tevent_req
*subreq
;
414 if (cldap
->connected
) {
415 return NT_STATUS_PIPE_CONNECTED
;
419 return NT_STATUS_INVALID_ADDRESS
;
422 state
= talloc(cldap
, struct cldap_reply_state
);
423 NT_STATUS_HAVE_NO_MEMORY(state
);
425 state
->dest
= tsocket_address_copy(io
->dest
, state
);
430 msg
= talloc(state
, struct ldap_message
);
435 msg
->messageid
= io
->messageid
;
436 msg
->controls
= NULL
;
439 msg
->type
= LDAP_TAG_SearchResultEntry
;
440 msg
->r
.SearchResultEntry
= *io
->response
;
442 if (!ldap_encode(msg
, NULL
, &blob1
, state
)) {
443 status
= NT_STATUS_INVALID_PARAMETER
;
447 blob1
= data_blob(NULL
, 0);
450 msg
->type
= LDAP_TAG_SearchResultDone
;
451 msg
->r
.SearchResultDone
= *io
->result
;
453 if (!ldap_encode(msg
, NULL
, &blob2
, state
)) {
454 status
= NT_STATUS_INVALID_PARAMETER
;
459 state
->blob
= data_blob_talloc(state
, NULL
, blob1
.length
+ blob2
.length
);
460 if (!state
->blob
.data
) {
464 memcpy(state
->blob
.data
, blob1
.data
, blob1
.length
);
465 memcpy(state
->blob
.data
+blob1
.length
, blob2
.data
, blob2
.length
);
466 data_blob_free(&blob1
);
467 data_blob_free(&blob2
);
469 subreq
= tdgram_sendto_queue_send(state
,
479 /* the callback will just free the state, as we don't need a result */
480 tevent_req_set_callback(subreq
, cldap_reply_state_destroy
, state
);
485 status
= NT_STATUS_NO_MEMORY
;
491 static void cldap_reply_state_destroy(struct tevent_req
*subreq
)
493 struct cldap_reply_state
*state
= tevent_req_callback_data(subreq
,
494 struct cldap_reply_state
);
496 /* we don't want to know the result here, we just free the state */
501 static int cldap_search_state_destructor(struct cldap_search_state
*s
)
503 if (s
->caller
.cldap
) {
504 if (s
->message_id
!= -1) {
505 idr_remove(s
->caller
.cldap
->searches
.idr
, s
->message_id
);
508 DLIST_REMOVE(s
->caller
.cldap
->searches
.list
, s
);
509 cldap_recvfrom_stop(s
->caller
.cldap
);
510 ZERO_STRUCT(s
->caller
);
516 static void cldap_search_state_queue_done(struct tevent_req
*subreq
);
517 static void cldap_search_state_wakeup_done(struct tevent_req
*subreq
);
520 queue a cldap reply for send
522 struct tevent_req
*cldap_search_send(TALLOC_CTX
*mem_ctx
,
523 struct cldap_socket
*cldap
,
524 const struct cldap_search
*io
)
526 struct tevent_req
*req
, *subreq
;
527 struct cldap_search_state
*state
= NULL
;
528 struct ldap_message
*msg
;
529 struct ldap_SearchRequest
*search
;
535 req
= tevent_req_create(mem_ctx
, &state
,
536 struct cldap_search_state
);
542 state
->caller
.cldap
= cldap
;
543 state
->message_id
= -1;
545 talloc_set_destructor(state
, cldap_search_state_destructor
);
547 if (io
->in
.dest_address
) {
548 if (cldap
->connected
) {
549 tevent_req_nterror(req
, NT_STATUS_PIPE_CONNECTED
);
552 ret
= tsocket_address_inet_from_strings(state
,
556 &state
->request
.dest
);
558 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
562 if (!cldap
->connected
) {
563 tevent_req_nterror(req
, NT_STATUS_INVALID_ADDRESS
);
566 state
->request
.dest
= NULL
;
569 state
->message_id
= idr_get_new_random(cldap
->searches
.idr
,
571 if (state
->message_id
== -1) {
572 tevent_req_nterror(req
, NT_STATUS_INSUFFICIENT_RESOURCES
);
576 msg
= talloc(state
, struct ldap_message
);
577 if (tevent_req_nomem(msg
, req
)) {
581 msg
->messageid
= state
->message_id
;
582 msg
->type
= LDAP_TAG_SearchRequest
;
583 msg
->controls
= NULL
;
584 search
= &msg
->r
.SearchRequest
;
587 search
->scope
= LDAP_SEARCH_SCOPE_BASE
;
588 search
->deref
= LDAP_DEREFERENCE_NEVER
;
589 search
->timelimit
= 0;
590 search
->sizelimit
= 0;
591 search
->attributesonly
= false;
592 search
->num_attributes
= str_list_length(io
->in
.attributes
);
593 search
->attributes
= io
->in
.attributes
;
594 search
->tree
= ldb_parse_tree(msg
, io
->in
.filter
);
595 if (tevent_req_nomem(search
->tree
, req
)) {
599 if (!ldap_encode(msg
, NULL
, &state
->request
.blob
, state
)) {
600 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
605 state
->request
.idx
= 0;
606 state
->request
.delay
= 10*1000*1000;
607 state
->request
.count
= 3;
608 if (io
->in
.timeout
> 0) {
609 state
->request
.delay
= io
->in
.timeout
* 1000 * 1000;
610 state
->request
.count
= io
->in
.retries
+ 1;
613 now
= tevent_timeval_current();
615 for (i
= 0; i
< state
->request
.count
; i
++) {
616 end
= tevent_timeval_add(&end
, 0, state
->request
.delay
);
619 if (!tevent_req_set_endtime(req
, state
->caller
.cldap
->event
.ctx
, end
)) {
620 tevent_req_nomem(NULL
, req
);
624 subreq
= tdgram_sendto_queue_send(state
,
625 state
->caller
.cldap
->event
.ctx
,
626 state
->caller
.cldap
->sock
,
627 state
->caller
.cldap
->send_queue
,
628 state
->request
.blob
.data
,
629 state
->request
.blob
.length
,
630 state
->request
.dest
);
631 if (tevent_req_nomem(subreq
, req
)) {
634 tevent_req_set_callback(subreq
, cldap_search_state_queue_done
, req
);
636 DLIST_ADD_END(cldap
->searches
.list
, state
, struct cldap_search_state
*);
641 return tevent_req_post(req
, cldap
->event
.ctx
);
644 static void cldap_search_state_queue_done(struct tevent_req
*subreq
)
646 struct tevent_req
*req
= tevent_req_callback_data(subreq
,
648 struct cldap_search_state
*state
= tevent_req_data(req
,
649 struct cldap_search_state
);
654 ret
= tdgram_sendto_queue_recv(subreq
, &sys_errno
);
658 status
= map_nt_error_from_unix(sys_errno
);
659 DLIST_REMOVE(state
->caller
.cldap
->searches
.list
, state
);
660 ZERO_STRUCT(state
->caller
.cldap
);
661 tevent_req_nterror(req
, status
);
665 state
->request
.idx
++;
667 /* wait for incoming traffic */
668 if (!cldap_recvfrom_setup(state
->caller
.cldap
)) {
669 tevent_req_nomem(NULL
, req
);
673 if (state
->request
.idx
> state
->request
.count
) {
674 /* we just wait for the response or a timeout */
678 next
= tevent_timeval_current_ofs(0, state
->request
.delay
);
679 subreq
= tevent_wakeup_send(state
,
680 state
->caller
.cldap
->event
.ctx
,
682 if (tevent_req_nomem(subreq
, req
)) {
685 tevent_req_set_callback(subreq
, cldap_search_state_wakeup_done
, req
);
688 static void cldap_search_state_wakeup_done(struct tevent_req
*subreq
)
690 struct tevent_req
*req
= tevent_req_callback_data(subreq
,
692 struct cldap_search_state
*state
= tevent_req_data(req
,
693 struct cldap_search_state
);
696 ok
= tevent_wakeup_recv(subreq
);
699 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
703 subreq
= tdgram_sendto_queue_send(state
,
704 state
->caller
.cldap
->event
.ctx
,
705 state
->caller
.cldap
->sock
,
706 state
->caller
.cldap
->send_queue
,
707 state
->request
.blob
.data
,
708 state
->request
.blob
.length
,
709 state
->request
.dest
);
710 if (tevent_req_nomem(subreq
, req
)) {
713 tevent_req_set_callback(subreq
, cldap_search_state_queue_done
, req
);
717 receive a cldap reply
719 NTSTATUS
cldap_search_recv(struct tevent_req
*req
,
721 struct cldap_search
*io
)
723 struct cldap_search_state
*state
= tevent_req_data(req
,
724 struct cldap_search_state
);
725 struct ldap_message
*ldap_msg
;
728 if (tevent_req_is_nterror(req
, &status
)) {
732 ldap_msg
= talloc(mem_ctx
, struct ldap_message
);
737 status
= ldap_decode(state
->response
.asn1
, NULL
, ldap_msg
);
738 if (!NT_STATUS_IS_OK(status
)) {
742 ZERO_STRUCT(io
->out
);
744 /* the first possible form has a search result in first place */
745 if (ldap_msg
->type
== LDAP_TAG_SearchResultEntry
) {
746 io
->out
.response
= talloc(mem_ctx
, struct ldap_SearchResEntry
);
747 if (!io
->out
.response
) {
750 *io
->out
.response
= ldap_msg
->r
.SearchResultEntry
;
752 /* decode the 2nd part */
753 status
= ldap_decode(state
->response
.asn1
, NULL
, ldap_msg
);
754 if (!NT_STATUS_IS_OK(status
)) {
759 if (ldap_msg
->type
!= LDAP_TAG_SearchResultDone
) {
760 status
= NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR
);
764 io
->out
.result
= talloc(mem_ctx
, struct ldap_Result
);
765 if (!io
->out
.result
) {
768 *io
->out
.result
= ldap_msg
->r
.SearchResultDone
;
770 if (io
->out
.result
->resultcode
!= LDAP_SUCCESS
) {
771 status
= NT_STATUS_LDAP(io
->out
.result
->resultcode
);
775 tevent_req_received(req
);
779 status
= NT_STATUS_NO_MEMORY
;
781 tevent_req_received(req
);
787 synchronous cldap search
789 NTSTATUS
cldap_search(struct cldap_socket
*cldap
,
791 struct cldap_search
*io
)
793 struct tevent_req
*req
;
796 if (!cldap
->event
.allow_poll
) {
797 return NT_STATUS_INVALID_PIPE_STATE
;
800 if (cldap
->searches
.list
) {
801 return NT_STATUS_PIPE_BUSY
;
804 req
= cldap_search_send(mem_ctx
, cldap
, io
);
805 NT_STATUS_HAVE_NO_MEMORY(req
);
807 if (!tevent_req_poll(req
, cldap
->event
.ctx
)) {
809 return NT_STATUS_INTERNAL_ERROR
;
812 status
= cldap_search_recv(req
, mem_ctx
, io
);
818 struct cldap_netlogon_state
{
819 struct cldap_search search
;
822 static void cldap_netlogon_state_done(struct tevent_req
*subreq
);
824 queue a cldap netlogon for send
826 struct tevent_req
*cldap_netlogon_send(TALLOC_CTX
*mem_ctx
,
827 struct cldap_socket
*cldap
,
828 const struct cldap_netlogon
*io
)
830 struct tevent_req
*req
, *subreq
;
831 struct cldap_netlogon_state
*state
;
833 static const char * const attr
[] = { "NetLogon", NULL
};
835 req
= tevent_req_create(mem_ctx
, &state
,
836 struct cldap_netlogon_state
);
841 filter
= talloc_asprintf(state
, "(&(NtVer=%s)",
842 ldap_encode_ndr_uint32(state
, io
->in
.version
));
843 if (tevent_req_nomem(filter
, req
)) {
847 filter
= talloc_asprintf_append_buffer(filter
, "(User=%s)", io
->in
.user
);
848 if (tevent_req_nomem(filter
, req
)) {
853 filter
= talloc_asprintf_append_buffer(filter
, "(Host=%s)", io
->in
.host
);
854 if (tevent_req_nomem(filter
, req
)) {
859 filter
= talloc_asprintf_append_buffer(filter
, "(DnsDomain=%s)", io
->in
.realm
);
860 if (tevent_req_nomem(filter
, req
)) {
864 if (io
->in
.acct_control
!= -1) {
865 filter
= talloc_asprintf_append_buffer(filter
, "(AAC=%s)",
866 ldap_encode_ndr_uint32(state
, io
->in
.acct_control
));
867 if (tevent_req_nomem(filter
, req
)) {
871 if (io
->in
.domain_sid
) {
872 struct dom_sid
*sid
= dom_sid_parse_talloc(state
, io
->in
.domain_sid
);
873 if (tevent_req_nomem(sid
, req
)) {
876 filter
= talloc_asprintf_append_buffer(filter
, "(domainSid=%s)",
877 ldap_encode_ndr_dom_sid(state
, sid
));
878 if (tevent_req_nomem(filter
, req
)) {
882 if (io
->in
.domain_guid
) {
885 status
= GUID_from_string(io
->in
.domain_guid
, &guid
);
886 if (tevent_req_nterror(req
, status
)) {
889 filter
= talloc_asprintf_append_buffer(filter
, "(DomainGuid=%s)",
890 ldap_encode_ndr_GUID(state
, &guid
));
891 if (tevent_req_nomem(filter
, req
)) {
895 filter
= talloc_asprintf_append_buffer(filter
, ")");
896 if (tevent_req_nomem(filter
, req
)) {
900 if (io
->in
.dest_address
) {
901 state
->search
.in
.dest_address
= talloc_strdup(state
,
902 io
->in
.dest_address
);
903 if (tevent_req_nomem(state
->search
.in
.dest_address
, req
)) {
906 state
->search
.in
.dest_port
= io
->in
.dest_port
;
908 state
->search
.in
.dest_address
= NULL
;
909 state
->search
.in
.dest_port
= 0;
911 state
->search
.in
.filter
= filter
;
912 state
->search
.in
.attributes
= attr
;
913 state
->search
.in
.timeout
= 2;
914 state
->search
.in
.retries
= 2;
916 subreq
= cldap_search_send(state
, cldap
, &state
->search
);
917 if (tevent_req_nomem(subreq
, req
)) {
920 tevent_req_set_callback(subreq
, cldap_netlogon_state_done
, req
);
924 return tevent_req_post(req
, cldap
->event
.ctx
);
927 static void cldap_netlogon_state_done(struct tevent_req
*subreq
)
929 struct tevent_req
*req
= tevent_req_callback_data(subreq
,
931 struct cldap_netlogon_state
*state
= tevent_req_data(req
,
932 struct cldap_netlogon_state
);
935 status
= cldap_search_recv(subreq
, state
, &state
->search
);
938 if (tevent_req_nterror(req
, status
)) {
942 tevent_req_done(req
);
946 receive a cldap netlogon reply
948 NTSTATUS
cldap_netlogon_recv(struct tevent_req
*req
,
949 struct smb_iconv_convenience
*iconv_convenience
,
951 struct cldap_netlogon
*io
)
953 struct cldap_netlogon_state
*state
= tevent_req_data(req
,
954 struct cldap_netlogon_state
);
958 if (tevent_req_is_nterror(req
, &status
)) {
962 if (state
->search
.out
.response
== NULL
) {
963 status
= NT_STATUS_NOT_FOUND
;
967 if (state
->search
.out
.response
->num_attributes
!= 1 ||
968 strcasecmp(state
->search
.out
.response
->attributes
[0].name
, "netlogon") != 0 ||
969 state
->search
.out
.response
->attributes
[0].num_values
!= 1 ||
970 state
->search
.out
.response
->attributes
[0].values
->length
< 2) {
971 status
= NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
974 data
= state
->search
.out
.response
->attributes
[0].values
;
976 status
= pull_netlogon_samlogon_response(data
, mem_ctx
,
979 if (!NT_STATUS_IS_OK(status
)) {
983 if (io
->in
.map_response
) {
984 map_netlogon_samlogon_response(&io
->out
.netlogon
);
987 status
= NT_STATUS_OK
;
989 tevent_req_received(req
);
994 sync cldap netlogon search
996 NTSTATUS
cldap_netlogon(struct cldap_socket
*cldap
,
997 struct smb_iconv_convenience
*iconv_convenience
,
999 struct cldap_netlogon
*io
)
1001 struct tevent_req
*req
;
1004 if (!cldap
->event
.allow_poll
) {
1005 return NT_STATUS_INVALID_PIPE_STATE
;
1008 if (cldap
->searches
.list
) {
1009 return NT_STATUS_PIPE_BUSY
;
1012 req
= cldap_netlogon_send(mem_ctx
, cldap
, io
);
1013 NT_STATUS_HAVE_NO_MEMORY(req
);
1015 if (!tevent_req_poll(req
, cldap
->event
.ctx
)) {
1017 return NT_STATUS_INTERNAL_ERROR
;
1020 status
= cldap_netlogon_recv(req
, iconv_convenience
, mem_ctx
, io
);
1028 send an empty reply (used on any error, so the client doesn't keep waiting
1029 or send the bad request again)
1031 NTSTATUS
cldap_empty_reply(struct cldap_socket
*cldap
,
1032 uint32_t message_id
,
1033 struct tsocket_address
*dest
)
1036 struct cldap_reply reply
;
1037 struct ldap_Result result
;
1039 reply
.messageid
= message_id
;
1041 reply
.response
= NULL
;
1042 reply
.result
= &result
;
1044 ZERO_STRUCT(result
);
1046 status
= cldap_reply_send(cldap
, &reply
);
1052 send an error reply (used on any error, so the client doesn't keep waiting
1053 or send the bad request again)
1055 NTSTATUS
cldap_error_reply(struct cldap_socket
*cldap
,
1056 uint32_t message_id
,
1057 struct tsocket_address
*dest
,
1059 const char *errormessage
)
1062 struct cldap_reply reply
;
1063 struct ldap_Result result
;
1065 reply
.messageid
= message_id
;
1067 reply
.response
= NULL
;
1068 reply
.result
= &result
;
1070 ZERO_STRUCT(result
);
1071 result
.resultcode
= resultcode
;
1072 result
.errormessage
= errormessage
;
1074 status
= cldap_reply_send(cldap
, &reply
);
1081 send a netlogon reply
1083 NTSTATUS
cldap_netlogon_reply(struct cldap_socket
*cldap
,
1084 struct smb_iconv_convenience
*iconv_convenience
,
1085 uint32_t message_id
,
1086 struct tsocket_address
*dest
,
1088 struct netlogon_samlogon_response
*netlogon
)
1091 struct cldap_reply reply
;
1092 struct ldap_SearchResEntry response
;
1093 struct ldap_Result result
;
1094 TALLOC_CTX
*tmp_ctx
= talloc_new(cldap
);
1097 status
= push_netlogon_samlogon_response(&blob
, tmp_ctx
,
1100 if (!NT_STATUS_IS_OK(status
)) {
1101 talloc_free(tmp_ctx
);
1104 reply
.messageid
= message_id
;
1106 reply
.response
= &response
;
1107 reply
.result
= &result
;
1109 ZERO_STRUCT(result
);
1112 response
.num_attributes
= 1;
1113 response
.attributes
= talloc(tmp_ctx
, struct ldb_message_element
);
1114 NT_STATUS_HAVE_NO_MEMORY(response
.attributes
);
1115 response
.attributes
->name
= "netlogon";
1116 response
.attributes
->num_values
= 1;
1117 response
.attributes
->values
= &blob
;
1119 status
= cldap_reply_send(cldap
, &reply
);
1121 talloc_free(tmp_ctx
);