2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Jeremy Allison 2007.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include "libsmb/namequery.h"
23 #include "../lib/util/tevent_ntstatus.h"
24 #include "libads/sitename_cache.h"
25 #include "../lib/addns/dnsquery.h"
26 #include "../lib/addns/dnsquery_srv.h"
27 #include "../libcli/netlogon/netlogon.h"
28 #include "lib/async_req/async_sock.h"
29 #include "lib/tsocket/tsocket.h"
30 #include "libsmb/nmblib.h"
31 #include "libsmb/unexpected.h"
32 #include "../libcli/nbt/libnbt.h"
33 #include "libads/kerberos_proto.h"
34 #include "lib/gencache.h"
35 #include "librpc/gen_ndr/dns.h"
36 #include "lib/util/util_net.h"
37 #include "lib/util/string_wrappers.h"
39 /* nmbd.c sets this to True. */
40 bool global_in_nmbd
= False
;
43 * Utility function to convert from a sockaddr_storage
44 * array to a struct samba_sockaddr array.
47 static NTSTATUS
sockaddr_array_to_samba_sockaddr_array(
49 struct samba_sockaddr
**sa_out
,
51 const struct sockaddr_storage
*ss_in
,
54 struct samba_sockaddr
*sa
= NULL
;
60 * Zero length arrays are returned as NULL.
61 * in the name resolution code.
67 sa
= talloc_zero_array(ctx
,
68 struct samba_sockaddr
,
71 return NT_STATUS_NO_MEMORY
;
74 for (i
= 0; i
< count_in
; i
++) {
77 /* Filter out zero addresses. */
78 if (is_zero_addr(&ss_in
[i
])) {
81 ok
= sockaddr_storage_to_samba_sockaddr(&sa
[count
],
90 * Zero length arrays are returned as NULL.
91 * in the name resolution code.
100 /****************************
101 * SERVER AFFINITY ROUTINES *
102 ****************************/
104 /* Server affinity is the concept of preferring the last domain
105 controller with whom you had a successful conversation */
107 /****************************************************************************
108 ****************************************************************************/
109 #define SAFKEY_FMT "SAF/DOMAIN/%s"
111 #define SAFJOINKEY_FMT "SAFJOIN/DOMAIN/%s"
112 #define SAFJOIN_TTL 3600
114 static char *saf_key(TALLOC_CTX
*mem_ctx
, const char *domain
)
116 return talloc_asprintf_strupper_m(mem_ctx
, SAFKEY_FMT
, domain
);
119 static char *saf_join_key(TALLOC_CTX
*mem_ctx
, const char *domain
)
121 return talloc_asprintf_strupper_m(mem_ctx
, SAFJOINKEY_FMT
, domain
);
124 /****************************************************************************
125 ****************************************************************************/
127 bool saf_store( const char *domain
, const char *servername
)
133 if ( !domain
|| !servername
) {
134 DEBUG(2,("saf_store: "
135 "Refusing to store empty domain or servername!\n"));
139 if ( (strlen(domain
) == 0) || (strlen(servername
) == 0) ) {
140 DEBUG(0,("saf_store: "
141 "refusing to store 0 length domain or servername!\n"));
145 key
= saf_key(talloc_tos(), domain
);
147 DEBUG(1, ("saf_key() failed\n"));
150 expire
= time( NULL
) + lp_parm_int(-1, "saf","ttl", SAF_TTL
);
152 DEBUG(10,("saf_store: domain = [%s], server = [%s], expire = [%u]\n",
153 domain
, servername
, (unsigned int)expire
));
155 ret
= gencache_set( key
, servername
, expire
);
162 bool saf_join_store( const char *domain
, const char *servername
)
168 if ( !domain
|| !servername
) {
169 DEBUG(2,("saf_join_store: Refusing to store empty domain or servername!\n"));
173 if ( (strlen(domain
) == 0) || (strlen(servername
) == 0) ) {
174 DEBUG(0,("saf_join_store: refusing to store 0 length domain or servername!\n"));
178 key
= saf_join_key(talloc_tos(), domain
);
180 DEBUG(1, ("saf_join_key() failed\n"));
183 expire
= time( NULL
) + lp_parm_int(-1, "saf","join ttl", SAFJOIN_TTL
);
185 DEBUG(10,("saf_join_store: domain = [%s], server = [%s], expire = [%u]\n",
186 domain
, servername
, (unsigned int)expire
));
188 ret
= gencache_set( key
, servername
, expire
);
195 bool saf_delete( const char *domain
)
201 DEBUG(2,("saf_delete: Refusing to delete empty domain\n"));
205 key
= saf_join_key(talloc_tos(), domain
);
207 DEBUG(1, ("saf_join_key() failed\n"));
210 ret
= gencache_del(key
);
214 DEBUG(10,("saf_delete[join]: domain = [%s]\n", domain
));
217 key
= saf_key(talloc_tos(), domain
);
219 DEBUG(1, ("saf_key() failed\n"));
222 ret
= gencache_del(key
);
226 DEBUG(10,("saf_delete: domain = [%s]\n", domain
));
232 /****************************************************************************
233 ****************************************************************************/
235 char *saf_fetch(TALLOC_CTX
*mem_ctx
, const char *domain
)
242 if ( !domain
|| strlen(domain
) == 0) {
243 DEBUG(2,("saf_fetch: Empty domain name!\n"));
247 key
= saf_join_key(talloc_tos(), domain
);
249 DEBUG(1, ("saf_join_key() failed\n"));
253 ret
= gencache_get( key
, mem_ctx
, &server
, &timeout
);
258 DEBUG(5,("saf_fetch[join]: Returning \"%s\" for \"%s\" domain\n",
263 key
= saf_key(talloc_tos(), domain
);
265 DEBUG(1, ("saf_key() failed\n"));
269 ret
= gencache_get( key
, mem_ctx
, &server
, &timeout
);
274 DEBUG(5,("saf_fetch: failed to find server for \"%s\" domain\n",
277 DEBUG(5,("saf_fetch: Returning \"%s\" for \"%s\" domain\n",
284 static void set_socket_addr_v4(struct samba_sockaddr
*addr
)
286 if (!interpret_string_addr(&addr
->u
.ss
, lp_nbt_client_socket_address(),
287 AI_NUMERICHOST
|AI_PASSIVE
)) {
288 zero_sockaddr(&addr
->u
.ss
);
289 /* zero_sockaddr sets family to AF_INET. */
290 addr
->sa_socklen
= sizeof(struct sockaddr_in
);
292 if (addr
->u
.ss
.ss_family
!= AF_INET
) {
293 zero_sockaddr(&addr
->u
.ss
);
294 /* zero_sockaddr sets family to AF_INET. */
295 addr
->sa_socklen
= sizeof(struct sockaddr_in
);
299 static struct in_addr
my_socket_addr_v4(void)
301 struct samba_sockaddr my_addr
= {0};
303 set_socket_addr_v4(&my_addr
);
304 return my_addr
.u
.in
.sin_addr
;
307 /****************************************************************************
308 Generate a random trn_id.
309 ****************************************************************************/
311 static int generate_trn_id(void)
315 generate_random_buffer((uint8_t *)&id
, sizeof(id
));
317 return id
% (unsigned)0x7FFF;
320 /****************************************************************************
321 Parse a node status response into an array of structures.
322 ****************************************************************************/
324 static struct node_status
*parse_node_status(TALLOC_CTX
*mem_ctx
, char *p
,
326 struct node_status_extra
*extra
)
328 struct node_status
*ret
;
330 size_t result_count
= 0;
332 result_count
= CVAL(p
,0);
334 if (result_count
== 0)
337 ret
= talloc_array(mem_ctx
, struct node_status
,result_count
);
342 for (i
=0;i
< result_count
;i
++) {
343 strlcpy(ret
[i
].name
,p
,16);
344 trim_char(ret
[i
].name
,'\0',' ');
345 ret
[i
].type
= CVAL(p
,15);
346 ret
[i
].flags
= p
[16];
348 DEBUG(10, ("%s#%02x: flags = 0x%02x\n", ret
[i
].name
,
349 ret
[i
].type
, ret
[i
].flags
));
352 * Also, pick up the MAC address ...
355 memcpy(&extra
->mac_addr
, p
, 6); /* Fill in the mac addr */
357 *num_names
= result_count
;
361 struct sock_packet_read_state
{
362 struct tevent_context
*ev
;
363 enum packet_type type
;
366 struct nb_packet_reader
*reader
;
367 struct tevent_req
*reader_req
;
369 struct tdgram_context
*sock
;
370 struct tevent_req
*socket_req
;
372 struct tsocket_address
*addr
;
374 bool (*validator
)(struct packet_struct
*p
,
378 struct packet_struct
*packet
;
381 static void sock_packet_read_got_packet(struct tevent_req
*subreq
);
382 static void sock_packet_read_got_socket(struct tevent_req
*subreq
);
384 static struct tevent_req
*sock_packet_read_send(
386 struct tevent_context
*ev
,
387 struct tdgram_context
*sock
,
388 struct nb_packet_reader
*reader
,
389 enum packet_type type
,
391 bool (*validator
)(struct packet_struct
*p
, void *private_data
),
394 struct tevent_req
*req
;
395 struct sock_packet_read_state
*state
;
397 req
= tevent_req_create(mem_ctx
, &state
,
398 struct sock_packet_read_state
);
403 state
->reader
= reader
;
406 state
->trn_id
= trn_id
;
407 state
->validator
= validator
;
408 state
->private_data
= private_data
;
410 if (reader
!= NULL
) {
411 state
->reader_req
= nb_packet_read_send(state
, ev
, reader
);
412 if (tevent_req_nomem(state
->reader_req
, req
)) {
413 return tevent_req_post(req
, ev
);
415 tevent_req_set_callback(
416 state
->reader_req
, sock_packet_read_got_packet
, req
);
419 state
->socket_req
= tdgram_recvfrom_send(state
, ev
, state
->sock
);
420 if (tevent_req_nomem(state
->socket_req
, req
)) {
421 return tevent_req_post(req
, ev
);
423 tevent_req_set_callback(state
->socket_req
, sock_packet_read_got_socket
,
429 static void sock_packet_read_got_packet(struct tevent_req
*subreq
)
431 struct tevent_req
*req
= tevent_req_callback_data(
432 subreq
, struct tevent_req
);
433 struct sock_packet_read_state
*state
= tevent_req_data(
434 req
, struct sock_packet_read_state
);
437 status
= nb_packet_read_recv(subreq
, state
, &state
->packet
);
439 TALLOC_FREE(state
->reader_req
);
441 if (!NT_STATUS_IS_OK(status
)) {
442 if (state
->socket_req
!= NULL
) {
444 * Still waiting for socket
449 * Both socket and packet reader failed
451 tevent_req_nterror(req
, status
);
455 if ((state
->validator
!= NULL
) &&
456 !state
->validator(state
->packet
, state
->private_data
)) {
457 DEBUG(10, ("validator failed\n"));
459 TALLOC_FREE(state
->packet
);
461 state
->reader_req
= nb_packet_read_send(state
, state
->ev
,
463 if (tevent_req_nomem(state
->reader_req
, req
)) {
466 tevent_req_set_callback(
467 state
->reader_req
, sock_packet_read_got_packet
, req
);
471 TALLOC_FREE(state
->socket_req
);
472 tevent_req_done(req
);
475 static void sock_packet_read_got_socket(struct tevent_req
*subreq
)
477 struct tevent_req
*req
= tevent_req_callback_data(
478 subreq
, struct tevent_req
);
479 struct sock_packet_read_state
*state
= tevent_req_data(
480 req
, struct sock_packet_read_state
);
481 struct samba_sockaddr addr
= {0};
487 received
= tdgram_recvfrom_recv(subreq
, &err
, state
,
488 &state
->buf
, &state
->addr
);
490 TALLOC_FREE(state
->socket_req
);
492 if (received
== -1) {
493 if (state
->reader_req
!= NULL
) {
495 * Still waiting for reader
500 * Both socket and reader failed
502 tevent_req_nterror(req
, map_nt_error_from_unix(err
));
505 ok
= tsocket_address_is_inet(state
->addr
, "ipv4");
509 ret
= tsocket_address_bsd_sockaddr(state
->addr
,
513 tevent_req_nterror(req
, map_nt_error_from_unix(errno
));
517 state
->packet
= parse_packet_talloc(
518 state
, (char *)state
->buf
, received
, state
->type
,
519 addr
.u
.in
.sin_addr
, addr
.u
.in
.sin_port
);
520 if (state
->packet
== NULL
) {
521 DEBUG(10, ("parse_packet failed\n"));
524 if ((state
->trn_id
!= -1) &&
525 (state
->trn_id
!= packet_trn_id(state
->packet
))) {
526 DEBUG(10, ("Expected transaction id %d, got %d\n",
527 state
->trn_id
, packet_trn_id(state
->packet
)));
531 if ((state
->validator
!= NULL
) &&
532 !state
->validator(state
->packet
, state
->private_data
)) {
533 DEBUG(10, ("validator failed\n"));
537 tevent_req_done(req
);
541 TALLOC_FREE(state
->packet
);
542 TALLOC_FREE(state
->buf
);
543 TALLOC_FREE(state
->addr
);
545 state
->socket_req
= tdgram_recvfrom_send(state
, state
->ev
, state
->sock
);
546 if (tevent_req_nomem(state
->socket_req
, req
)) {
549 tevent_req_set_callback(state
->socket_req
, sock_packet_read_got_socket
,
553 static NTSTATUS
sock_packet_read_recv(struct tevent_req
*req
,
555 struct packet_struct
**ppacket
)
557 struct sock_packet_read_state
*state
= tevent_req_data(
558 req
, struct sock_packet_read_state
);
561 if (tevent_req_is_nterror(req
, &status
)) {
564 *ppacket
= talloc_move(mem_ctx
, &state
->packet
);
568 struct nb_trans_state
{
569 struct tevent_context
*ev
;
570 struct tdgram_context
*sock
;
571 struct nb_packet_reader
*reader
;
573 struct tsocket_address
*src_addr
;
574 struct tsocket_address
*dst_addr
;
577 enum packet_type type
;
580 bool (*validator
)(struct packet_struct
*p
,
584 struct packet_struct
*packet
;
587 static void nb_trans_got_reader(struct tevent_req
*subreq
);
588 static void nb_trans_done(struct tevent_req
*subreq
);
589 static void nb_trans_sent(struct tevent_req
*subreq
);
590 static void nb_trans_send_next(struct tevent_req
*subreq
);
592 static struct tevent_req
*nb_trans_send(
594 struct tevent_context
*ev
,
595 const struct samba_sockaddr
*_my_addr
,
596 const struct samba_sockaddr
*_dst_addr
,
598 uint8_t *buf
, size_t buflen
,
599 enum packet_type type
, int trn_id
,
600 bool (*validator
)(struct packet_struct
*p
,
604 const struct sockaddr
*my_addr
= &_my_addr
->u
.sa
;
605 size_t my_addr_len
= sizeof(_my_addr
->u
.in
); /*We know it's AF_INET.*/
606 const struct sockaddr
*dst_addr
= &_dst_addr
->u
.sa
;
607 size_t dst_addr_len
= sizeof(_dst_addr
->u
.in
); /*We know it's AF_INET.*/
608 struct tevent_req
*req
, *subreq
;
609 struct nb_trans_state
*state
;
612 req
= tevent_req_create(mem_ctx
, &state
, struct nb_trans_state
);
618 state
->buflen
= buflen
;
620 state
->trn_id
= trn_id
;
621 state
->validator
= validator
;
622 state
->private_data
= private_data
;
624 ret
= tsocket_address_bsd_from_sockaddr(state
,
625 my_addr
, my_addr_len
,
628 tevent_req_nterror(req
, map_nt_error_from_unix(errno
));
629 return tevent_req_post(req
, ev
);
632 ret
= tsocket_address_bsd_from_sockaddr(state
,
633 dst_addr
, dst_addr_len
,
636 tevent_req_nterror(req
, map_nt_error_from_unix(errno
));
637 return tevent_req_post(req
, ev
);
640 ret
= tdgram_inet_udp_broadcast_socket(state
->src_addr
, state
,
643 tevent_req_nterror(req
, map_nt_error_from_unix(errno
));
644 return tevent_req_post(req
, ev
);
647 subreq
= nb_packet_reader_send(state
, ev
, type
, state
->trn_id
, NULL
);
648 if (tevent_req_nomem(subreq
, req
)) {
649 return tevent_req_post(req
, ev
);
651 tevent_req_set_callback(subreq
, nb_trans_got_reader
, req
);
655 static void nb_trans_got_reader(struct tevent_req
*subreq
)
657 struct tevent_req
*req
= tevent_req_callback_data(
658 subreq
, struct tevent_req
);
659 struct nb_trans_state
*state
= tevent_req_data(
660 req
, struct nb_trans_state
);
663 status
= nb_packet_reader_recv(subreq
, state
, &state
->reader
);
666 if (!NT_STATUS_IS_OK(status
)) {
667 DEBUG(10, ("nmbd not around\n"));
668 state
->reader
= NULL
;
671 subreq
= sock_packet_read_send(
672 state
, state
->ev
, state
->sock
,
673 state
->reader
, state
->type
, state
->trn_id
,
674 state
->validator
, state
->private_data
);
675 if (tevent_req_nomem(subreq
, req
)) {
678 tevent_req_set_callback(subreq
, nb_trans_done
, req
);
680 subreq
= tdgram_sendto_send(state
, state
->ev
,
682 state
->buf
, state
->buflen
,
684 if (tevent_req_nomem(subreq
, req
)) {
687 tevent_req_set_callback(subreq
, nb_trans_sent
, req
);
690 static void nb_trans_sent(struct tevent_req
*subreq
)
692 struct tevent_req
*req
= tevent_req_callback_data(
693 subreq
, struct tevent_req
);
694 struct nb_trans_state
*state
= tevent_req_data(
695 req
, struct nb_trans_state
);
699 sent
= tdgram_sendto_recv(subreq
, &err
);
702 DEBUG(10, ("sendto failed: %s\n", strerror(err
)));
703 tevent_req_nterror(req
, map_nt_error_from_unix(err
));
706 subreq
= tevent_wakeup_send(state
, state
->ev
,
707 timeval_current_ofs(1, 0));
708 if (tevent_req_nomem(subreq
, req
)) {
711 tevent_req_set_callback(subreq
, nb_trans_send_next
, req
);
714 static void nb_trans_send_next(struct tevent_req
*subreq
)
716 struct tevent_req
*req
= tevent_req_callback_data(
717 subreq
, struct tevent_req
);
718 struct nb_trans_state
*state
= tevent_req_data(
719 req
, struct nb_trans_state
);
722 ret
= tevent_wakeup_recv(subreq
);
725 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
728 subreq
= tdgram_sendto_send(state
, state
->ev
,
730 state
->buf
, state
->buflen
,
732 if (tevent_req_nomem(subreq
, req
)) {
735 tevent_req_set_callback(subreq
, nb_trans_sent
, req
);
738 static void nb_trans_done(struct tevent_req
*subreq
)
740 struct tevent_req
*req
= tevent_req_callback_data(
741 subreq
, struct tevent_req
);
742 struct nb_trans_state
*state
= tevent_req_data(
743 req
, struct nb_trans_state
);
746 status
= sock_packet_read_recv(subreq
, state
, &state
->packet
);
748 if (tevent_req_nterror(req
, status
)) {
751 tevent_req_done(req
);
754 static NTSTATUS
nb_trans_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
755 struct packet_struct
**ppacket
)
757 struct nb_trans_state
*state
= tevent_req_data(
758 req
, struct nb_trans_state
);
761 if (tevent_req_is_nterror(req
, &status
)) {
764 *ppacket
= talloc_move(mem_ctx
, &state
->packet
);
768 /****************************************************************************
769 Do a NBT node status query on an open socket and return an array of
770 structures holding the returned names or NULL if the query failed.
771 **************************************************************************/
773 struct node_status_query_state
{
774 struct samba_sockaddr my_addr
;
775 struct samba_sockaddr addr
;
778 struct packet_struct
*packet
;
781 static bool node_status_query_validator(struct packet_struct
*p
,
783 static void node_status_query_done(struct tevent_req
*subreq
);
785 struct tevent_req
*node_status_query_send(TALLOC_CTX
*mem_ctx
,
786 struct tevent_context
*ev
,
787 struct nmb_name
*name
,
788 const struct sockaddr_storage
*addr
)
790 struct tevent_req
*req
, *subreq
;
791 struct node_status_query_state
*state
;
792 struct packet_struct p
;
793 struct nmb_packet
*nmb
= &p
.packet
.nmb
;
796 req
= tevent_req_create(mem_ctx
, &state
,
797 struct node_status_query_state
);
802 if (addr
->ss_family
!= AF_INET
) {
803 /* Can't do node status to IPv6 */
804 tevent_req_nterror(req
, NT_STATUS_INVALID_ADDRESS
);
805 return tevent_req_post(req
, ev
);
808 ok
= sockaddr_storage_to_samba_sockaddr(&state
->addr
, addr
);
810 /* node status must be IPv4 */
811 tevent_req_nterror(req
, NT_STATUS_INVALID_ADDRESS
);
812 return tevent_req_post(req
, ev
);
814 state
->addr
.u
.in
.sin_port
= htons(NMB_PORT
);
816 set_socket_addr_v4(&state
->my_addr
);
819 nmb
->header
.name_trn_id
= generate_trn_id();
820 nmb
->header
.opcode
= 0;
821 nmb
->header
.response
= false;
822 nmb
->header
.nm_flags
.bcast
= false;
823 nmb
->header
.nm_flags
.recursion_available
= false;
824 nmb
->header
.nm_flags
.recursion_desired
= false;
825 nmb
->header
.nm_flags
.trunc
= false;
826 nmb
->header
.nm_flags
.authoritative
= false;
827 nmb
->header
.rcode
= 0;
828 nmb
->header
.qdcount
= 1;
829 nmb
->header
.ancount
= 0;
830 nmb
->header
.nscount
= 0;
831 nmb
->header
.arcount
= 0;
832 nmb
->question
.question_name
= *name
;
833 nmb
->question
.question_type
= 0x21;
834 nmb
->question
.question_class
= 0x1;
836 state
->buflen
= build_packet((char *)state
->buf
, sizeof(state
->buf
),
838 if (state
->buflen
== 0) {
839 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
840 DEBUG(10, ("build_packet failed\n"));
841 return tevent_req_post(req
, ev
);
844 subreq
= nb_trans_send(state
,
852 nmb
->header
.name_trn_id
,
853 node_status_query_validator
,
855 if (tevent_req_nomem(subreq
, req
)) {
856 DEBUG(10, ("nb_trans_send failed\n"));
857 return tevent_req_post(req
, ev
);
859 if (!tevent_req_set_endtime(req
, ev
, timeval_current_ofs(10, 0))) {
860 return tevent_req_post(req
, ev
);
862 tevent_req_set_callback(subreq
, node_status_query_done
, req
);
866 static bool node_status_query_validator(struct packet_struct
*p
,
869 struct nmb_packet
*nmb
= &p
->packet
.nmb
;
872 if (nmb
->header
.opcode
!= 0 ||
873 nmb
->header
.nm_flags
.bcast
||
875 !nmb
->header
.ancount
||
876 nmb
->answers
->rr_type
!= 0x21) {
878 * XXXX what do we do with this? could be a redirect,
879 * but we'll discard it for the moment
886 static void node_status_query_done(struct tevent_req
*subreq
)
888 struct tevent_req
*req
= tevent_req_callback_data(
889 subreq
, struct tevent_req
);
890 struct node_status_query_state
*state
= tevent_req_data(
891 req
, struct node_status_query_state
);
894 status
= nb_trans_recv(subreq
, state
, &state
->packet
);
896 if (tevent_req_nterror(req
, status
)) {
899 tevent_req_done(req
);
902 NTSTATUS
node_status_query_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
903 struct node_status
**pnode_status
,
905 struct node_status_extra
*extra
)
907 struct node_status_query_state
*state
= tevent_req_data(
908 req
, struct node_status_query_state
);
909 struct node_status
*node_status
;
910 size_t num_names
= 0;
913 if (tevent_req_is_nterror(req
, &status
)) {
916 node_status
= parse_node_status(
917 mem_ctx
, &state
->packet
->packet
.nmb
.answers
->rdata
[0],
919 if (node_status
== NULL
) {
920 return NT_STATUS_NO_MEMORY
;
922 *pnode_status
= node_status
;
923 *pnum_names
= num_names
;
927 NTSTATUS
node_status_query(TALLOC_CTX
*mem_ctx
, struct nmb_name
*name
,
928 const struct sockaddr_storage
*addr
,
929 struct node_status
**pnode_status
,
931 struct node_status_extra
*extra
)
933 TALLOC_CTX
*frame
= talloc_stackframe();
934 struct tevent_context
*ev
;
935 struct tevent_req
*req
;
936 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
938 ev
= samba_tevent_context_init(frame
);
942 req
= node_status_query_send(ev
, ev
, name
, addr
);
946 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
949 status
= node_status_query_recv(req
, mem_ctx
, pnode_status
,
956 static bool name_status_lmhosts(const struct sockaddr_storage
*paddr
,
957 int qname_type
, fstring pname
)
962 struct samba_sockaddr addr_in
= {0};
963 struct samba_sockaddr addr
= {0};
966 ok
= sockaddr_storage_to_samba_sockaddr(&addr_in
, paddr
);
970 if (addr_in
.u
.ss
.ss_family
!= AF_INET
) {
974 f
= startlmhosts(get_dyn_LMHOSTSFILE());
979 while (getlmhostsent(talloc_tos(), f
, &name
, &name_type
, &addr
.u
.ss
)) {
980 if (addr
.u
.ss
.ss_family
!= AF_INET
) {
983 if (name_type
!= qname_type
) {
986 if (sockaddr_equal(&addr_in
.u
.sa
, &addr
.u
.sa
)) {
987 fstrcpy(pname
, name
);
996 /****************************************************************************
997 Find the first type XX name in a node status reply - used for finding
998 a servers name given its IP. Return the matched name in *name.
999 **************************************************************************/
1001 bool name_status_find(const char *q_name
,
1004 const struct sockaddr_storage
*to_ss
,
1007 char addr
[INET6_ADDRSTRLEN
];
1008 struct node_status
*addrs
= NULL
;
1009 struct nmb_name nname
;
1010 size_t count
= 0, i
;
1011 bool result
= false;
1014 if (lp_disable_netbios()) {
1015 DEBUG(5,("name_status_find(%s#%02x): netbios is disabled\n",
1020 print_sockaddr(addr
, sizeof(addr
), to_ss
);
1022 DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name
,
1025 /* Check the cache first. */
1027 if (namecache_status_fetch(q_name
, q_type
, type
, to_ss
, name
)) {
1031 if (to_ss
->ss_family
!= AF_INET
) {
1032 /* Can't do node status to IPv6 */
1036 result
= name_status_lmhosts(to_ss
, type
, name
);
1038 DBG_DEBUG("Found name %s in lmhosts\n", name
);
1039 namecache_status_store(q_name
, q_type
, type
, to_ss
, name
);
1043 /* W2K PDC's seem not to respond to '*'#0. JRA */
1044 make_nmb_name(&nname
, q_name
, q_type
);
1045 status
= node_status_query(talloc_tos(), &nname
, to_ss
,
1046 &addrs
, &count
, NULL
);
1047 if (!NT_STATUS_IS_OK(status
)) {
1051 for (i
=0;i
<count
;i
++) {
1052 /* Find first one of the requested type that's not a GROUP. */
1053 if (addrs
[i
].type
== type
&& ! (addrs
[i
].flags
& 0x80))
1059 pull_ascii_nstring(name
, sizeof(fstring
), addrs
[i
].name
);
1061 /* Store the result in the cache. */
1062 /* but don't store an entry for 0x1c names here. Here we have
1063 a single host and DOMAIN<0x1c> names should be a list of hosts */
1065 if ( q_type
!= 0x1c ) {
1066 namecache_status_store(q_name
, q_type
, type
, to_ss
, name
);
1074 DEBUG(10, ("name_status_find: name %sfound", result
? "" : "not "));
1077 DEBUGADD(10, (", name %s ip address is %s", name
, addr
));
1085 comparison function used by sort_addr_list
1088 static int addr_compare(const struct sockaddr_storage
*ss1
,
1089 const struct sockaddr_storage
*ss2
)
1091 int max_bits1
=0, max_bits2
=0;
1092 int num_interfaces
= iface_count();
1094 struct samba_sockaddr sa1
;
1095 struct samba_sockaddr sa2
;
1098 ok
= sockaddr_storage_to_samba_sockaddr(&sa1
, ss1
);
1100 return 0; /* No change. */
1103 ok
= sockaddr_storage_to_samba_sockaddr(&sa2
, ss2
);
1105 return 0; /* No change. */
1108 /* Sort IPv4 addresses first. */
1109 if (sa1
.u
.ss
.ss_family
!= sa2
.u
.ss
.ss_family
) {
1110 if (sa2
.u
.ss
.ss_family
== AF_INET
) {
1117 /* Here we know both addresses are of the same
1120 for (i
=0;i
<num_interfaces
;i
++) {
1121 struct samba_sockaddr sif
= {0};
1122 const unsigned char *p_ss1
= NULL
;
1123 const unsigned char *p_ss2
= NULL
;
1124 const unsigned char *p_if
= NULL
;
1128 ok
= sockaddr_storage_to_samba_sockaddr(&sif
, iface_n_bcast(i
));
1130 return 0; /* No change. */
1132 if (sif
.u
.ss
.ss_family
!= sa1
.u
.ss
.ss_family
) {
1133 /* Ignore interfaces of the wrong type. */
1136 if (sif
.u
.ss
.ss_family
== AF_INET
) {
1137 p_if
= (const unsigned char *)&sif
.u
.in
.sin_addr
;
1138 p_ss1
= (const unsigned char *)&sa1
.u
.in
.sin_addr
;
1139 p_ss2
= (const unsigned char *)&sa2
.u
.in
.sin_addr
;
1142 #if defined(HAVE_IPV6)
1143 if (sif
.u
.ss
.ss_family
== AF_INET6
) {
1144 p_if
= (const unsigned char *)&sif
.u
.in6
.sin6_addr
;
1145 p_ss1
= (const unsigned char *)&sa1
.u
.in6
.sin6_addr
;
1146 p_ss2
= (const unsigned char *)&sa2
.u
.in6
.sin6_addr
;
1150 if (!p_ss1
|| !p_ss2
|| !p_if
|| len
== 0) {
1153 bits1
= matching_len_bits(p_ss1
, p_if
, len
);
1154 bits2
= matching_len_bits(p_ss2
, p_if
, len
);
1155 max_bits1
= MAX(bits1
, max_bits1
);
1156 max_bits2
= MAX(bits2
, max_bits2
);
1159 /* Bias towards directly reachable IPs */
1160 if (iface_local(&sa1
.u
.sa
)) {
1161 if (sa1
.u
.ss
.ss_family
== AF_INET
) {
1167 if (iface_local(&sa2
.u
.sa
)) {
1168 if (sa2
.u
.ss
.ss_family
== AF_INET
) {
1174 return max_bits2
- max_bits1
;
1178 sort an IP list so that names that are close to one of our interfaces
1179 are at the top. This prevents the problem where a WINS server returns an IP
1180 that is not reachable from our subnet as the first match
1183 static void sort_addr_list(struct sockaddr_storage
*sslist
, size_t count
)
1189 TYPESAFE_QSORT(sslist
, count
, addr_compare
);
1192 static int samba_sockaddr_compare(struct samba_sockaddr
*sa1
,
1193 struct samba_sockaddr
*sa2
)
1195 return addr_compare(&sa1
->u
.ss
, &sa2
->u
.ss
);
1198 static void sort_sa_list(struct samba_sockaddr
*salist
, size_t count
)
1204 TYPESAFE_QSORT(salist
, count
, samba_sockaddr_compare
);
1207 /**********************************************************************
1208 Remove any duplicate address/port pairs in the samba_sockaddr array.
1209 *********************************************************************/
1211 size_t remove_duplicate_addrs2(struct samba_sockaddr
*salist
, size_t count
)
1215 DBG_DEBUG("looking for duplicate address/port pairs\n");
1217 /* One loop to set duplicates to a zero addr. */
1218 for (i
=0; i
< count
; i
++) {
1219 if (is_zero_addr(&salist
[i
].u
.ss
)) {
1223 for (j
=i
+1; j
<count
; j
++) {
1224 if (sockaddr_equal(&salist
[i
].u
.sa
, &salist
[j
].u
.sa
)) {
1225 zero_sockaddr(&salist
[j
].u
.ss
);
1230 /* Now remove any addresses set to zero above. */
1231 for (i
= 0; i
< count
; i
++) {
1233 is_zero_addr(&salist
[i
].u
.ss
)) {
1234 ARRAY_DEL_ELEMENT(salist
, i
, count
);
1242 static bool prioritize_ipv4_list(struct samba_sockaddr
*salist
, size_t count
)
1244 TALLOC_CTX
*frame
= talloc_stackframe();
1245 struct samba_sockaddr
*salist_new
= talloc_array(frame
,
1246 struct samba_sockaddr
,
1250 if (salist_new
== NULL
) {
1257 /* Copy IPv4 first. */
1258 for (i
= 0; i
< count
; i
++) {
1259 if (salist
[i
].u
.ss
.ss_family
== AF_INET
) {
1260 salist_new
[j
++] = salist
[i
];
1265 for (i
= 0; i
< count
; i
++) {
1266 if (salist
[i
].u
.ss
.ss_family
!= AF_INET
) {
1267 salist_new
[j
++] = salist
[i
];
1271 memcpy(salist
, salist_new
, sizeof(struct samba_sockaddr
)*count
);
1276 /****************************************************************************
1277 Do a netbios name query to find someones IP.
1278 Returns an array of IP addresses or NULL if none.
1279 *count will be set to the number of addresses returned.
1280 *timed_out is set if we failed by timing out
1281 ****************************************************************************/
1283 struct name_query_state
{
1284 struct samba_sockaddr my_addr
;
1285 struct samba_sockaddr addr
;
1287 bool bcast_star_query
;
1293 NTSTATUS validate_error
;
1296 struct sockaddr_storage
*addrs
;
1300 static bool name_query_validator(struct packet_struct
*p
, void *private_data
);
1301 static void name_query_done(struct tevent_req
*subreq
);
1303 struct tevent_req
*name_query_send(TALLOC_CTX
*mem_ctx
,
1304 struct tevent_context
*ev
,
1305 const char *name
, int name_type
,
1306 bool bcast
, bool recurse
,
1307 const struct sockaddr_storage
*addr
)
1309 struct tevent_req
*req
, *subreq
;
1310 struct name_query_state
*state
;
1311 struct packet_struct p
;
1312 struct nmb_packet
*nmb
= &p
.packet
.nmb
;
1315 req
= tevent_req_create(mem_ctx
, &state
, struct name_query_state
);
1319 state
->bcast
= bcast
;
1321 if (addr
->ss_family
!= AF_INET
) {
1322 /* Can't do node status to IPv6 */
1323 tevent_req_nterror(req
, NT_STATUS_INVALID_ADDRESS
);
1324 return tevent_req_post(req
, ev
);
1327 if (lp_disable_netbios()) {
1328 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n",
1330 tevent_req_nterror(req
, NT_STATUS_NOT_SUPPORTED
);
1331 return tevent_req_post(req
, ev
);
1334 ok
= sockaddr_storage_to_samba_sockaddr(&state
->addr
, addr
);
1336 /* Node status must be IPv4 */
1337 tevent_req_nterror(req
, NT_STATUS_INVALID_ADDRESS
);
1338 return tevent_req_post(req
, ev
);
1340 state
->addr
.u
.in
.sin_port
= htons(NMB_PORT
);
1342 set_socket_addr_v4(&state
->my_addr
);
1345 nmb
->header
.name_trn_id
= generate_trn_id();
1346 nmb
->header
.opcode
= 0;
1347 nmb
->header
.response
= false;
1348 nmb
->header
.nm_flags
.bcast
= bcast
;
1349 nmb
->header
.nm_flags
.recursion_available
= false;
1350 nmb
->header
.nm_flags
.recursion_desired
= recurse
;
1351 nmb
->header
.nm_flags
.trunc
= false;
1352 nmb
->header
.nm_flags
.authoritative
= false;
1353 nmb
->header
.rcode
= 0;
1354 nmb
->header
.qdcount
= 1;
1355 nmb
->header
.ancount
= 0;
1356 nmb
->header
.nscount
= 0;
1357 nmb
->header
.arcount
= 0;
1359 if (bcast
&& (strcmp(name
, "*")==0)) {
1361 * We're doing a broadcast query for all
1362 * names in the area. Remember this so
1363 * we will wait for all names within
1364 * the timeout period.
1366 state
->bcast_star_query
= true;
1369 make_nmb_name(&nmb
->question
.question_name
,name
,name_type
);
1371 nmb
->question
.question_type
= 0x20;
1372 nmb
->question
.question_class
= 0x1;
1374 state
->buflen
= build_packet((char *)state
->buf
, sizeof(state
->buf
),
1376 if (state
->buflen
== 0) {
1377 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
1378 DEBUG(10, ("build_packet failed\n"));
1379 return tevent_req_post(req
, ev
);
1382 subreq
= nb_trans_send(state
,
1390 nmb
->header
.name_trn_id
,
1391 name_query_validator
,
1393 if (tevent_req_nomem(subreq
, req
)) {
1394 DEBUG(10, ("nb_trans_send failed\n"));
1395 return tevent_req_post(req
, ev
);
1397 tevent_req_set_callback(subreq
, name_query_done
, req
);
1401 static bool name_query_validator(struct packet_struct
*p
, void *private_data
)
1403 struct name_query_state
*state
= talloc_get_type_abort(
1404 private_data
, struct name_query_state
);
1405 struct nmb_packet
*nmb
= &p
->packet
.nmb
;
1406 struct sockaddr_storage
*tmp_addrs
;
1407 bool got_unique_netbios_name
= false;
1410 debug_nmb_packet(p
);
1413 * If we get a Negative Name Query Response from a WINS
1414 * server, we should report it and give up.
1416 if( 0 == nmb
->header
.opcode
/* A query response */
1417 && !state
->bcast
/* from a WINS server */
1418 && nmb
->header
.rcode
/* Error returned */
1421 if( DEBUGLVL( 3 ) ) {
1422 /* Only executed if DEBUGLEVEL >= 3 */
1423 dbgtext( "Negative name query "
1424 "response, rcode 0x%02x: ",
1425 nmb
->header
.rcode
);
1426 switch( nmb
->header
.rcode
) {
1428 dbgtext("Request was invalidly formatted.\n");
1431 dbgtext("Problem with NBNS, cannot process "
1435 dbgtext("The name requested does not "
1439 dbgtext("Unsupported request error.\n");
1442 dbgtext("Query refused error.\n");
1445 dbgtext("Unrecognized error code.\n" );
1451 * We accept this packet as valid, but tell the upper
1452 * layers that it's a negative response.
1454 state
->validate_error
= NT_STATUS_NOT_FOUND
;
1458 if (nmb
->header
.opcode
!= 0 ||
1459 nmb
->header
.nm_flags
.bcast
||
1460 nmb
->header
.rcode
||
1461 !nmb
->header
.ancount
) {
1463 * XXXX what do we do with this? Could be a redirect,
1464 * but we'll discard it for the moment.
1469 tmp_addrs
= talloc_realloc(
1470 state
, state
->addrs
, struct sockaddr_storage
,
1471 state
->num_addrs
+ nmb
->answers
->rdlength
/6);
1472 if (tmp_addrs
== NULL
) {
1473 state
->validate_error
= NT_STATUS_NO_MEMORY
;
1476 state
->addrs
= tmp_addrs
;
1478 DEBUG(2,("Got a positive name query response "
1479 "from %s ( ", inet_ntoa(p
->ip
)));
1481 for (i
=0; i
<nmb
->answers
->rdlength
/6; i
++) {
1484 struct sockaddr_storage addr
;
1485 struct samba_sockaddr sa
= {0};
1489 flags
= RSVAL(&nmb
->answers
->rdata
[i
*6], 0);
1490 got_unique_netbios_name
|= ((flags
& 0x8000) == 0);
1492 putip((char *)&ip
,&nmb
->answers
->rdata
[2+i
*6]);
1493 in_addr_to_sockaddr_storage(&addr
, ip
);
1495 ok
= sockaddr_storage_to_samba_sockaddr(&sa
, &addr
);
1500 if (is_zero_addr(&sa
.u
.ss
)) {
1504 for (j
=0; j
<state
->num_addrs
; j
++) {
1505 struct samba_sockaddr sa_j
= {0};
1507 ok
= sockaddr_storage_to_samba_sockaddr(&sa_j
,
1512 if (sockaddr_equal(&sa
.u
.sa
, &sa_j
.u
.sa
)) {
1516 if (j
< state
->num_addrs
) {
1517 /* Already got it */
1521 DEBUGADD(2,("%s ",inet_ntoa(ip
)));
1523 state
->addrs
[state
->num_addrs
] = addr
;
1525 if (state
->num_addrs
+ 1 < state
->num_addrs
) {
1528 state
->num_addrs
+= 1;
1530 DEBUGADD(2,(")\n"));
1532 /* We add the flags back ... */
1533 if (nmb
->header
.response
)
1534 state
->flags
|= NM_FLAGS_RS
;
1535 if (nmb
->header
.nm_flags
.authoritative
)
1536 state
->flags
|= NM_FLAGS_AA
;
1537 if (nmb
->header
.nm_flags
.trunc
)
1538 state
->flags
|= NM_FLAGS_TC
;
1539 if (nmb
->header
.nm_flags
.recursion_desired
)
1540 state
->flags
|= NM_FLAGS_RD
;
1541 if (nmb
->header
.nm_flags
.recursion_available
)
1542 state
->flags
|= NM_FLAGS_RA
;
1543 if (nmb
->header
.nm_flags
.bcast
)
1544 state
->flags
|= NM_FLAGS_B
;
1548 * We have to collect all entries coming in from broadcast
1549 * queries. If we got a unique name and we are not querying
1550 * all names registered within broadcast area (query
1551 * for the name '*', so state->bcast_star_query is set),
1554 return (got_unique_netbios_name
&& !state
->bcast_star_query
);
1557 * WINS responses are accepted when they are received
1562 static void name_query_done(struct tevent_req
*subreq
)
1564 struct tevent_req
*req
= tevent_req_callback_data(
1565 subreq
, struct tevent_req
);
1566 struct name_query_state
*state
= tevent_req_data(
1567 req
, struct name_query_state
);
1569 struct packet_struct
*p
= NULL
;
1571 status
= nb_trans_recv(subreq
, state
, &p
);
1572 TALLOC_FREE(subreq
);
1573 if (tevent_req_nterror(req
, status
)) {
1576 if (!NT_STATUS_IS_OK(state
->validate_error
)) {
1577 tevent_req_nterror(req
, state
->validate_error
);
1580 tevent_req_done(req
);
1583 NTSTATUS
name_query_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
1584 struct sockaddr_storage
**addrs
, size_t *num_addrs
,
1587 struct name_query_state
*state
= tevent_req_data(
1588 req
, struct name_query_state
);
1591 if (tevent_req_is_nterror(req
, &status
)) {
1593 NT_STATUS_EQUAL(status
, NT_STATUS_IO_TIMEOUT
)) {
1595 * In the broadcast case we collect replies until the
1598 status
= NT_STATUS_OK
;
1600 if (!NT_STATUS_IS_OK(status
)) {
1604 if (state
->num_addrs
== 0) {
1605 return NT_STATUS_NOT_FOUND
;
1607 *addrs
= talloc_move(mem_ctx
, &state
->addrs
);
1608 sort_addr_list(*addrs
, state
->num_addrs
);
1609 *num_addrs
= state
->num_addrs
;
1610 if (flags
!= NULL
) {
1611 *flags
= state
->flags
;
1613 return NT_STATUS_OK
;
1616 NTSTATUS
name_query(const char *name
, int name_type
,
1617 bool bcast
, bool recurse
,
1618 const struct sockaddr_storage
*to_ss
,
1619 TALLOC_CTX
*mem_ctx
,
1620 struct sockaddr_storage
**addrs
,
1621 size_t *num_addrs
, uint8_t *flags
)
1623 TALLOC_CTX
*frame
= talloc_stackframe();
1624 struct tevent_context
*ev
;
1625 struct tevent_req
*req
;
1626 struct timeval timeout
;
1627 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
1629 ev
= samba_tevent_context_init(frame
);
1633 req
= name_query_send(ev
, ev
, name
, name_type
, bcast
, recurse
, to_ss
);
1638 timeout
= timeval_current_ofs(0, 250000);
1640 timeout
= timeval_current_ofs(2, 0);
1642 if (!tevent_req_set_endtime(req
, ev
, timeout
)) {
1645 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
1648 status
= name_query_recv(req
, mem_ctx
, addrs
, num_addrs
, flags
);
1654 struct name_queries_state
{
1655 struct tevent_context
*ev
;
1660 const struct sockaddr_storage
*addrs
;
1665 struct tevent_req
**subreqs
;
1666 size_t num_received
;
1669 size_t received_index
;
1670 struct sockaddr_storage
*result_addrs
;
1671 size_t num_result_addrs
;
1675 static void name_queries_done(struct tevent_req
*subreq
);
1676 static void name_queries_next(struct tevent_req
*subreq
);
1679 * Send a name query to multiple destinations with a wait time in between
1682 static struct tevent_req
*name_queries_send(
1683 TALLOC_CTX
*mem_ctx
, struct tevent_context
*ev
,
1684 const char *name
, int name_type
,
1685 bool bcast
, bool recurse
,
1686 const struct sockaddr_storage
*addrs
,
1687 size_t num_addrs
, int wait_msec
, int timeout_msec
)
1689 struct tevent_req
*req
, *subreq
;
1690 struct name_queries_state
*state
;
1692 req
= tevent_req_create(mem_ctx
, &state
,
1693 struct name_queries_state
);
1699 state
->name_type
= name_type
;
1700 state
->bcast
= bcast
;
1701 state
->recurse
= recurse
;
1702 state
->addrs
= addrs
;
1703 state
->num_addrs
= num_addrs
;
1704 state
->wait_msec
= wait_msec
;
1705 state
->timeout_msec
= timeout_msec
;
1707 state
->subreqs
= talloc_zero_array(
1708 state
, struct tevent_req
*, num_addrs
);
1709 if (tevent_req_nomem(state
->subreqs
, req
)) {
1710 return tevent_req_post(req
, ev
);
1712 state
->num_sent
= 0;
1714 subreq
= name_query_send(
1715 state
->subreqs
, state
->ev
, name
, name_type
, bcast
, recurse
,
1716 &state
->addrs
[state
->num_sent
]);
1717 if (tevent_req_nomem(subreq
, req
)) {
1718 return tevent_req_post(req
, ev
);
1720 if (!tevent_req_set_endtime(
1722 timeval_current_ofs(0, state
->timeout_msec
* 1000))) {
1723 return tevent_req_post(req
, ev
);
1725 tevent_req_set_callback(subreq
, name_queries_done
, req
);
1727 state
->subreqs
[state
->num_sent
] = subreq
;
1728 state
->num_sent
+= 1;
1730 if (state
->num_sent
< state
->num_addrs
) {
1731 subreq
= tevent_wakeup_send(
1733 timeval_current_ofs(0, state
->wait_msec
* 1000));
1734 if (tevent_req_nomem(subreq
, req
)) {
1735 return tevent_req_post(req
, ev
);
1737 tevent_req_set_callback(subreq
, name_queries_next
, req
);
1742 static void name_queries_done(struct tevent_req
*subreq
)
1744 struct tevent_req
*req
= tevent_req_callback_data(
1745 subreq
, struct tevent_req
);
1746 struct name_queries_state
*state
= tevent_req_data(
1747 req
, struct name_queries_state
);
1751 status
= name_query_recv(subreq
, state
, &state
->result_addrs
,
1752 &state
->num_result_addrs
, &state
->flags
);
1754 for (i
=0; i
<state
->num_sent
; i
++) {
1755 if (state
->subreqs
[i
] == subreq
) {
1759 if (i
== state
->num_sent
) {
1760 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
1763 TALLOC_FREE(state
->subreqs
[i
]);
1766 if (state
->num_received
+ 1 < state
->num_received
) {
1767 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
1770 state
->num_received
+= 1;
1772 if (!NT_STATUS_IS_OK(status
)) {
1774 if (state
->num_received
>= state
->num_addrs
) {
1775 tevent_req_nterror(req
, status
);
1779 * Still outstanding requests, just wait
1783 state
->received_index
= i
;
1784 tevent_req_done(req
);
1787 static void name_queries_next(struct tevent_req
*subreq
)
1789 struct tevent_req
*req
= tevent_req_callback_data(
1790 subreq
, struct tevent_req
);
1791 struct name_queries_state
*state
= tevent_req_data(
1792 req
, struct name_queries_state
);
1794 if (!tevent_wakeup_recv(subreq
)) {
1795 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
1799 subreq
= name_query_send(
1800 state
->subreqs
, state
->ev
,
1801 state
->name
, state
->name_type
, state
->bcast
, state
->recurse
,
1802 &state
->addrs
[state
->num_sent
]);
1803 if (tevent_req_nomem(subreq
, req
)) {
1806 tevent_req_set_callback(subreq
, name_queries_done
, req
);
1807 if (!tevent_req_set_endtime(
1809 timeval_current_ofs(0, state
->timeout_msec
* 1000))) {
1812 state
->subreqs
[state
->num_sent
] = subreq
;
1813 state
->num_sent
+= 1;
1815 if (state
->num_sent
< state
->num_addrs
) {
1816 subreq
= tevent_wakeup_send(
1818 timeval_current_ofs(0, state
->wait_msec
* 1000));
1819 if (tevent_req_nomem(subreq
, req
)) {
1822 tevent_req_set_callback(subreq
, name_queries_next
, req
);
1826 static NTSTATUS
name_queries_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
1827 struct sockaddr_storage
**result_addrs
,
1828 size_t *num_result_addrs
, uint8_t *flags
,
1829 size_t *received_index
)
1831 struct name_queries_state
*state
= tevent_req_data(
1832 req
, struct name_queries_state
);
1835 if (tevent_req_is_nterror(req
, &status
)) {
1839 if (result_addrs
!= NULL
) {
1840 *result_addrs
= talloc_move(mem_ctx
, &state
->result_addrs
);
1842 if (num_result_addrs
!= NULL
) {
1843 *num_result_addrs
= state
->num_result_addrs
;
1845 if (flags
!= NULL
) {
1846 *flags
= state
->flags
;
1848 if (received_index
!= NULL
) {
1849 *received_index
= state
->received_index
;
1851 return NT_STATUS_OK
;
1854 /********************************************************
1855 Resolve via "bcast" method.
1856 *********************************************************/
1858 struct name_resolve_bcast_state
{
1859 struct sockaddr_storage
*addrs
;
1863 static void name_resolve_bcast_done(struct tevent_req
*subreq
);
1865 struct tevent_req
*name_resolve_bcast_send(TALLOC_CTX
*mem_ctx
,
1866 struct tevent_context
*ev
,
1870 struct tevent_req
*req
, *subreq
;
1871 struct name_resolve_bcast_state
*state
;
1872 struct sockaddr_storage
*bcast_addrs
;
1873 size_t i
, num_addrs
, num_bcast_addrs
;
1875 req
= tevent_req_create(mem_ctx
, &state
,
1876 struct name_resolve_bcast_state
);
1881 if (lp_disable_netbios()) {
1882 DEBUG(5, ("name_resolve_bcast(%s#%02x): netbios is disabled\n",
1884 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
1885 return tevent_req_post(req
, ev
);
1889 * "bcast" means do a broadcast lookup on all the local interfaces.
1892 DEBUG(3, ("name_resolve_bcast: Attempting broadcast lookup "
1893 "for name %s<0x%x>\n", name
, name_type
));
1895 num_addrs
= iface_count();
1896 bcast_addrs
= talloc_array(state
, struct sockaddr_storage
, num_addrs
);
1897 if (tevent_req_nomem(bcast_addrs
, req
)) {
1898 return tevent_req_post(req
, ev
);
1902 * Lookup the name on all the interfaces, return on
1903 * the first successful match.
1905 num_bcast_addrs
= 0;
1907 for (i
=0; i
<num_addrs
; i
++) {
1908 const struct sockaddr_storage
*pss
= iface_n_bcast(i
);
1910 if (pss
->ss_family
!= AF_INET
) {
1913 bcast_addrs
[num_bcast_addrs
] = *pss
;
1914 num_bcast_addrs
+= 1;
1917 subreq
= name_queries_send(state
, ev
, name
, name_type
, true, true,
1918 bcast_addrs
, num_bcast_addrs
, 0, 250);
1919 if (tevent_req_nomem(subreq
, req
)) {
1920 return tevent_req_post(req
, ev
);
1922 tevent_req_set_callback(subreq
, name_resolve_bcast_done
, req
);
1926 static void name_resolve_bcast_done(struct tevent_req
*subreq
)
1928 struct tevent_req
*req
= tevent_req_callback_data(
1929 subreq
, struct tevent_req
);
1930 struct name_resolve_bcast_state
*state
= tevent_req_data(
1931 req
, struct name_resolve_bcast_state
);
1934 status
= name_queries_recv(subreq
, state
,
1935 &state
->addrs
, &state
->num_addrs
,
1937 TALLOC_FREE(subreq
);
1938 if (tevent_req_nterror(req
, status
)) {
1941 tevent_req_done(req
);
1944 NTSTATUS
name_resolve_bcast_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
1945 struct sockaddr_storage
**addrs
,
1948 struct name_resolve_bcast_state
*state
= tevent_req_data(
1949 req
, struct name_resolve_bcast_state
);
1952 if (tevent_req_is_nterror(req
, &status
)) {
1955 *addrs
= talloc_move(mem_ctx
, &state
->addrs
);
1956 *num_addrs
= state
->num_addrs
;
1957 return NT_STATUS_OK
;
1960 NTSTATUS
name_resolve_bcast(TALLOC_CTX
*mem_ctx
,
1963 struct sockaddr_storage
**return_iplist
,
1964 size_t *return_count
)
1966 TALLOC_CTX
*frame
= talloc_stackframe();
1967 struct tevent_context
*ev
;
1968 struct tevent_req
*req
;
1969 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
1971 ev
= samba_tevent_context_init(frame
);
1975 req
= name_resolve_bcast_send(frame
, ev
, name
, name_type
);
1979 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
1982 status
= name_resolve_bcast_recv(req
, mem_ctx
, return_iplist
,
1989 struct query_wins_list_state
{
1990 struct tevent_context
*ev
;
1993 struct in_addr
*servers
;
1995 struct sockaddr_storage server
;
1998 struct sockaddr_storage
*addrs
;
2003 static void query_wins_list_done(struct tevent_req
*subreq
);
2006 * Query a list of (replicating) wins servers in sequence, call them
2007 * dead if they don't reply
2010 static struct tevent_req
*query_wins_list_send(
2011 TALLOC_CTX
*mem_ctx
, struct tevent_context
*ev
,
2012 struct in_addr src_ip
, const char *name
, uint8_t name_type
,
2013 struct in_addr
*servers
, size_t num_servers
)
2015 struct tevent_req
*req
, *subreq
;
2016 struct query_wins_list_state
*state
;
2018 req
= tevent_req_create(mem_ctx
, &state
,
2019 struct query_wins_list_state
);
2025 state
->name_type
= name_type
;
2026 state
->servers
= servers
;
2027 state
->num_servers
= num_servers
;
2029 if (state
->num_servers
== 0) {
2030 tevent_req_nterror(req
, NT_STATUS_NOT_FOUND
);
2031 return tevent_req_post(req
, ev
);
2034 in_addr_to_sockaddr_storage(
2035 &state
->server
, state
->servers
[state
->num_sent
]);
2037 subreq
= name_query_send(state
, state
->ev
,
2038 state
->name
, state
->name_type
,
2039 false, true, &state
->server
);
2041 if (tevent_req_nomem(subreq
, req
)) {
2042 return tevent_req_post(req
, ev
);
2046 if (state
->num_sent
+ 1 < state
->num_sent
) {
2047 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2048 return tevent_req_post(req
, ev
);
2051 state
->num_sent
+= 1;
2052 if (!tevent_req_set_endtime(subreq
, state
->ev
,
2053 timeval_current_ofs(2, 0))) {
2054 return tevent_req_post(req
, ev
);
2056 tevent_req_set_callback(subreq
, query_wins_list_done
, req
);
2060 static void query_wins_list_done(struct tevent_req
*subreq
)
2062 struct tevent_req
*req
= tevent_req_callback_data(
2063 subreq
, struct tevent_req
);
2064 struct query_wins_list_state
*state
= tevent_req_data(
2065 req
, struct query_wins_list_state
);
2068 status
= name_query_recv(subreq
, state
,
2069 &state
->addrs
, &state
->num_addrs
,
2071 TALLOC_FREE(subreq
);
2072 if (NT_STATUS_IS_OK(status
)) {
2073 tevent_req_done(req
);
2076 if (!NT_STATUS_EQUAL(status
, NT_STATUS_IO_TIMEOUT
)) {
2077 tevent_req_nterror(req
, status
);
2080 wins_srv_died(state
->servers
[state
->num_sent
-1],
2081 my_socket_addr_v4());
2083 if (state
->num_sent
== state
->num_servers
) {
2084 tevent_req_nterror(req
, NT_STATUS_NOT_FOUND
);
2088 in_addr_to_sockaddr_storage(
2089 &state
->server
, state
->servers
[state
->num_sent
]);
2091 subreq
= name_query_send(state
, state
->ev
,
2092 state
->name
, state
->name_type
,
2093 false, true, &state
->server
);
2094 state
->num_sent
+= 1;
2095 if (tevent_req_nomem(subreq
, req
)) {
2098 if (!tevent_req_set_endtime(subreq
, state
->ev
,
2099 timeval_current_ofs(2, 0))) {
2102 tevent_req_set_callback(subreq
, query_wins_list_done
, req
);
2105 static NTSTATUS
query_wins_list_recv(struct tevent_req
*req
,
2106 TALLOC_CTX
*mem_ctx
,
2107 struct sockaddr_storage
**addrs
,
2111 struct query_wins_list_state
*state
= tevent_req_data(
2112 req
, struct query_wins_list_state
);
2115 if (tevent_req_is_nterror(req
, &status
)) {
2118 if (addrs
!= NULL
) {
2119 *addrs
= talloc_move(mem_ctx
, &state
->addrs
);
2121 if (num_addrs
!= NULL
) {
2122 *num_addrs
= state
->num_addrs
;
2124 if (flags
!= NULL
) {
2125 *flags
= state
->flags
;
2127 return NT_STATUS_OK
;
2130 struct resolve_wins_state
{
2132 size_t num_received
;
2134 struct sockaddr_storage
*addrs
;
2139 static void resolve_wins_done(struct tevent_req
*subreq
);
2141 struct tevent_req
*resolve_wins_send(TALLOC_CTX
*mem_ctx
,
2142 struct tevent_context
*ev
,
2146 struct tevent_req
*req
, *subreq
;
2147 struct resolve_wins_state
*state
;
2148 char **wins_tags
= NULL
;
2149 struct sockaddr_storage src_ss
;
2150 struct samba_sockaddr src_sa
= {0};
2151 struct in_addr src_ip
;
2152 size_t i
, num_wins_tags
;
2155 req
= tevent_req_create(mem_ctx
, &state
,
2156 struct resolve_wins_state
);
2161 if (wins_srv_count() < 1) {
2162 DEBUG(3,("resolve_wins: WINS server resolution selected "
2163 "and no WINS servers listed.\n"));
2164 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2168 /* the address we will be sending from */
2169 if (!interpret_string_addr(&src_ss
, lp_nbt_client_socket_address(),
2170 AI_NUMERICHOST
|AI_PASSIVE
)) {
2171 zero_sockaddr(&src_ss
);
2174 ok
= sockaddr_storage_to_samba_sockaddr(&src_sa
, &src_ss
);
2176 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2180 if (src_sa
.u
.ss
.ss_family
!= AF_INET
) {
2181 char addr
[INET6_ADDRSTRLEN
];
2182 print_sockaddr(addr
, sizeof(addr
), &src_sa
.u
.ss
);
2183 DEBUG(3,("resolve_wins: cannot receive WINS replies "
2184 "on IPv6 address %s\n",
2186 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2190 src_ip
= src_sa
.u
.in
.sin_addr
;
2192 wins_tags
= wins_srv_tags();
2193 if (wins_tags
== NULL
) {
2194 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2199 while (wins_tags
[num_wins_tags
] != NULL
) {
2201 if (num_wins_tags
+ 1 < num_wins_tags
) {
2202 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2208 for (i
=0; i
<num_wins_tags
; i
++) {
2209 size_t num_servers
, num_alive
;
2210 struct in_addr
*servers
, *alive
;
2213 if (!wins_server_tag_ips(wins_tags
[i
], talloc_tos(),
2214 &servers
, &num_servers
)) {
2215 DEBUG(10, ("wins_server_tag_ips failed for tag %s\n",
2220 alive
= talloc_array(state
, struct in_addr
, num_servers
);
2221 if (tevent_req_nomem(alive
, req
)) {
2226 for (j
=0; j
<num_servers
; j
++) {
2227 struct in_addr wins_ip
= servers
[j
];
2229 if (global_in_nmbd
&& ismyip_v4(wins_ip
)) {
2230 /* yikes! we'll loop forever */
2233 /* skip any that have been unresponsive lately */
2234 if (wins_srv_is_dead(wins_ip
, src_ip
)) {
2237 DEBUG(3, ("resolve_wins: using WINS server %s "
2239 inet_ntoa(wins_ip
), wins_tags
[i
]));
2240 alive
[num_alive
] = wins_ip
;
2243 TALLOC_FREE(servers
);
2245 if (num_alive
== 0) {
2249 subreq
= query_wins_list_send(
2250 state
, ev
, src_ip
, name
, name_type
,
2252 if (tevent_req_nomem(subreq
, req
)) {
2255 tevent_req_set_callback(subreq
, resolve_wins_done
, req
);
2256 state
->num_sent
+= 1;
2259 if (state
->num_sent
== 0) {
2260 tevent_req_nterror(req
, NT_STATUS_NOT_FOUND
);
2264 wins_srv_tags_free(wins_tags
);
2267 wins_srv_tags_free(wins_tags
);
2268 return tevent_req_post(req
, ev
);
2271 static void resolve_wins_done(struct tevent_req
*subreq
)
2273 struct tevent_req
*req
= tevent_req_callback_data(
2274 subreq
, struct tevent_req
);
2275 struct resolve_wins_state
*state
= tevent_req_data(
2276 req
, struct resolve_wins_state
);
2279 status
= query_wins_list_recv(subreq
, state
, &state
->addrs
,
2280 &state
->num_addrs
, &state
->flags
);
2281 if (NT_STATUS_IS_OK(status
)) {
2282 tevent_req_done(req
);
2287 if (state
->num_received
+ 1 < state
->num_received
) {
2288 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2292 state
->num_received
+= 1;
2294 if (state
->num_received
< state
->num_sent
) {
2296 * Wait for the others
2300 tevent_req_nterror(req
, status
);
2303 NTSTATUS
resolve_wins_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
2304 struct sockaddr_storage
**addrs
,
2305 size_t *num_addrs
, uint8_t *flags
)
2307 struct resolve_wins_state
*state
= tevent_req_data(
2308 req
, struct resolve_wins_state
);
2311 if (tevent_req_is_nterror(req
, &status
)) {
2314 if (addrs
!= NULL
) {
2315 *addrs
= talloc_move(mem_ctx
, &state
->addrs
);
2317 if (num_addrs
!= NULL
) {
2318 *num_addrs
= state
->num_addrs
;
2320 if (flags
!= NULL
) {
2321 *flags
= state
->flags
;
2323 return NT_STATUS_OK
;
2326 /********************************************************
2327 Resolve via "wins" method.
2328 *********************************************************/
2330 NTSTATUS
resolve_wins(TALLOC_CTX
*mem_ctx
,
2333 struct sockaddr_storage
**return_iplist
,
2334 size_t *return_count
)
2336 struct tevent_context
*ev
;
2337 struct tevent_req
*req
;
2338 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
2340 ev
= samba_tevent_context_init(talloc_tos());
2344 req
= resolve_wins_send(ev
, ev
, name
, name_type
);
2348 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
2351 status
= resolve_wins_recv(req
, mem_ctx
, return_iplist
, return_count
,
2359 /********************************************************
2360 Resolve via "hosts" method.
2361 *********************************************************/
2363 static NTSTATUS
resolve_hosts(TALLOC_CTX
*mem_ctx
,
2366 struct sockaddr_storage
**return_iplist
,
2367 size_t *return_count
)
2370 * "host" means do a localhost, or dns lookup.
2372 struct addrinfo hints
;
2373 struct addrinfo
*ailist
= NULL
;
2374 struct addrinfo
*res
= NULL
;
2377 size_t ret_count
= 0;
2378 struct sockaddr_storage
*iplist
= NULL
;
2380 if ( name_type
!= 0x20 && name_type
!= 0x0) {
2381 DEBUG(5, ("resolve_hosts: not appropriate "
2382 "for name type <0x%x>\n",
2384 return NT_STATUS_INVALID_PARAMETER
;
2387 DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n",
2391 /* By default make sure it supports TCP. */
2392 hints
.ai_socktype
= SOCK_STREAM
;
2393 hints
.ai_flags
= AI_ADDRCONFIG
;
2395 #if !defined(HAVE_IPV6)
2396 /* Unless we have IPv6, we really only want IPv4 addresses back. */
2397 hints
.ai_family
= AF_INET
;
2400 ret
= getaddrinfo(name
,
2405 DEBUG(3,("resolve_hosts: getaddrinfo failed for name %s [%s]\n",
2407 gai_strerror(ret
) ));
2410 for (res
= ailist
; res
; res
= res
->ai_next
) {
2411 struct sockaddr_storage ss
= {0};
2412 struct sockaddr_storage
*tmp
= NULL
;
2414 if ((res
->ai_addr
== NULL
) ||
2415 (res
->ai_addrlen
== 0) ||
2416 (res
->ai_addrlen
> sizeof(ss
))) {
2420 memcpy(&ss
, res
->ai_addr
, res
->ai_addrlen
);
2422 if (is_zero_addr(&ss
)) {
2427 if (ret_count
+ 1 < ret_count
) {
2428 freeaddrinfo(ailist
);
2429 TALLOC_FREE(iplist
);
2430 return NT_STATUS_INVALID_PARAMETER
;
2434 tmp
= talloc_realloc(
2435 mem_ctx
, iplist
, struct sockaddr_storage
,
2438 DEBUG(3,("resolve_hosts: malloc fail !\n"));
2439 freeaddrinfo(ailist
);
2440 TALLOC_FREE(iplist
);
2441 return NT_STATUS_NO_MEMORY
;
2448 freeaddrinfo(ailist
);
2450 if (ret_count
== 0) {
2451 return NT_STATUS_UNSUCCESSFUL
;
2453 *return_count
= ret_count
;
2454 *return_iplist
= iplist
;
2455 return NT_STATUS_OK
;
2458 /********************************************************
2459 Resolve via "ADS" method.
2460 *********************************************************/
2462 /* Special name type used to cause a _kerberos DNS lookup. */
2463 #define KDC_NAME_TYPE 0xDCDC
2465 static NTSTATUS
resolve_ads(TALLOC_CTX
*ctx
,
2468 const char *sitename
,
2469 struct sockaddr_storage
**return_addrs
,
2470 size_t *return_count
)
2474 struct dns_rr_srv
*dcs
= NULL
;
2476 size_t num_srv_addrs
= 0;
2477 struct sockaddr_storage
*srv_addrs
= NULL
;
2480 if ((name_type
!= 0x1c) && (name_type
!= KDC_NAME_TYPE
) &&
2481 (name_type
!= 0x1b)) {
2482 return NT_STATUS_INVALID_PARAMETER
;
2485 status
= NT_STATUS_OK
;
2487 switch (name_type
) {
2489 DEBUG(5,("resolve_ads: Attempting to resolve "
2490 "PDC for %s using DNS\n", name
));
2491 query
= ads_dns_query_string_pdc(ctx
, name
);
2495 DEBUG(5,("resolve_ads: Attempting to resolve "
2496 "DCs for %s using DNS\n", name
));
2497 query
= ads_dns_query_string_dcs(ctx
, name
);
2500 DEBUG(5,("resolve_ads: Attempting to resolve "
2501 "KDCs for %s using DNS\n", name
));
2502 query
= ads_dns_query_string_kdcs(ctx
, name
);
2505 status
= NT_STATUS_INVALID_PARAMETER
;
2509 if (!NT_STATUS_IS_OK(status
)) {
2512 if (query
== NULL
) {
2513 return NT_STATUS_NO_MEMORY
;
2516 DBG_DEBUG("SRV query for %s\n", query
);
2518 status
= ads_dns_query_srv(
2520 lp_get_async_dns_timeout(),
2525 if (!NT_STATUS_IS_OK(status
)) {
2530 *return_addrs
= NULL
;
2533 return NT_STATUS_OK
;
2536 /* First count the sizes of each array. */
2537 for(i
= 0; i
< numdcs
; i
++) {
2538 if (dcs
[i
].ss_s
== NULL
) {
2540 * Nothing received or timeout in A/AAAA reqs
2545 if (num_srv_addrs
+ dcs
[i
].num_ips
< num_srv_addrs
) {
2548 return NT_STATUS_INVALID_PARAMETER
;
2550 /* Add in the number of addresses we got. */
2551 num_srv_addrs
+= dcs
[i
].num_ips
;
2554 /* Allocate the list of IP addresses we already have. */
2555 srv_addrs
= talloc_zero_array(ctx
,
2556 struct sockaddr_storage
,
2558 if (srv_addrs
== NULL
) {
2560 return NT_STATUS_NO_MEMORY
;
2564 for(i
= 0; i
< numdcs
; i
++) {
2565 /* Copy all the IP addresses from the SRV response */
2567 for (j
= 0; j
< dcs
[i
].num_ips
; j
++) {
2568 char addr
[INET6_ADDRSTRLEN
];
2570 srv_addrs
[num_srv_addrs
] = dcs
[i
].ss_s
[j
];
2571 if (is_zero_addr(&srv_addrs
[num_srv_addrs
])) {
2575 DBG_DEBUG("SRV lookup %s got IP[%zu] %s\n",
2578 print_sockaddr(addr
,
2580 &srv_addrs
[num_srv_addrs
]));
2588 *return_addrs
= srv_addrs
;
2589 *return_count
= num_srv_addrs
;
2590 return NT_STATUS_OK
;
2593 static const char **filter_out_nbt_lookup(TALLOC_CTX
*mem_ctx
,
2594 const char **resolve_order
)
2596 size_t i
, len
, result_idx
;
2597 const char **result
;
2600 while (resolve_order
[len
] != NULL
) {
2604 result
= talloc_array(mem_ctx
, const char *, len
+1);
2605 if (result
== NULL
) {
2611 for (i
=0; i
<len
; i
++) {
2612 const char *tok
= resolve_order
[i
];
2614 if (strequal(tok
, "lmhosts") || strequal(tok
, "wins") ||
2615 strequal(tok
, "bcast")) {
2618 result
[result_idx
++] = tok
;
2620 result
[result_idx
] = NULL
;
2625 /*******************************************************************
2626 Samba interface to resolve a name into an IP address.
2627 Use this function if the string is either an IP address, DNS
2628 or host name or NetBIOS name. This uses the name switch in the
2629 smb.conf to determine the order of name resolution.
2631 Added support for ip addr/port to support ADS ldap servers.
2632 the only place we currently care about the port is in the
2633 resolve_hosts() when looking up DC's via SRV RR entries in DNS
2634 **********************************************************************/
2636 NTSTATUS
internal_resolve_name(TALLOC_CTX
*ctx
,
2639 const char *sitename
,
2640 struct samba_sockaddr
**return_salist
,
2641 size_t *return_count
,
2642 const char **resolve_order
)
2644 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
2646 size_t nc_count
= 0;
2647 size_t ret_count
= 0;
2649 struct sockaddr_storage
*ss_list
= NULL
;
2650 struct samba_sockaddr
*sa_list
= NULL
;
2651 TALLOC_CTX
*frame
= talloc_stackframe();
2653 DBG_DEBUG("looking up %s#%x (sitename %s)\n",
2654 name
, name_type
, sitename
? sitename
: "(null)");
2656 if (is_ipaddress(name
)) {
2657 struct sockaddr_storage ss
;
2659 /* if it's in the form of an IP address then get the lib to interpret it */
2660 ok
= interpret_string_addr(&ss
, name
, AI_NUMERICHOST
);
2662 DBG_WARNING("interpret_string_addr failed on %s\n",
2665 return NT_STATUS_INVALID_PARAMETER
;
2667 if (is_zero_addr(&ss
)) {
2669 return NT_STATUS_UNSUCCESSFUL
;
2672 status
= sockaddr_array_to_samba_sockaddr_array(frame
,
2677 if (!NT_STATUS_IS_OK(status
)) {
2682 *return_salist
= talloc_move(ctx
, &sa_list
);
2685 return NT_STATUS_OK
;
2688 /* Check name cache */
2690 ok
= namecache_fetch(frame
,
2697 * remove_duplicate_addrs2() has the
2698 * side effect of removing zero addresses,
2701 nc_count
= remove_duplicate_addrs2(sa_list
, nc_count
);
2702 if (nc_count
== 0) {
2703 TALLOC_FREE(sa_list
);
2705 return NT_STATUS_UNSUCCESSFUL
;
2707 *return_count
= nc_count
;
2708 *return_salist
= talloc_move(ctx
, &sa_list
);
2710 return NT_STATUS_OK
;
2713 /* set the name resolution order */
2715 if (resolve_order
&& strcmp(resolve_order
[0], "NULL") == 0) {
2716 DBG_DEBUG("all lookups disabled\n");
2718 return NT_STATUS_INVALID_PARAMETER
;
2721 if (!resolve_order
|| !resolve_order
[0]) {
2722 static const char *host_order
[] = { "host", NULL
};
2723 resolve_order
= host_order
;
2726 if ((strlen(name
) > MAX_NETBIOSNAME_LEN
- 1) ||
2727 (strchr(name
, '.') != NULL
)) {
2729 * Don't do NBT lookup, the name would not fit anyway
2731 resolve_order
= filter_out_nbt_lookup(frame
, resolve_order
);
2732 if (resolve_order
== NULL
) {
2734 return NT_STATUS_NO_MEMORY
;
2738 /* iterate through the name resolution backends */
2740 for (i
=0; resolve_order
[i
]; i
++) {
2741 const char *tok
= resolve_order
[i
];
2743 if ((strequal(tok
, "host") || strequal(tok
, "hosts"))) {
2744 status
= resolve_hosts(talloc_tos(),
2749 if (!NT_STATUS_IS_OK(status
)) {
2755 if (strequal(tok
, "kdc")) {
2756 /* deal with KDC_NAME_TYPE names here.
2757 * This will result in a SRV record lookup */
2758 status
= resolve_ads(talloc_tos(),
2764 if (!NT_STATUS_IS_OK(status
)) {
2767 /* Ensure we don't namecache
2768 * this with the KDC port. */
2769 name_type
= KDC_NAME_TYPE
;
2773 if (strequal(tok
, "ads")) {
2774 /* deal with 0x1c and 0x1b names here.
2775 * This will result in a SRV record lookup */
2776 status
= resolve_ads(talloc_tos(),
2782 if (!NT_STATUS_IS_OK(status
)) {
2788 if (strequal(tok
, "lmhosts")) {
2789 status
= resolve_lmhosts_file_as_sockaddr(
2791 get_dyn_LMHOSTSFILE(),
2796 if (!NT_STATUS_IS_OK(status
)) {
2802 if (strequal(tok
, "wins")) {
2803 /* don't resolve 1D via WINS */
2804 if (name_type
== 0x1D) {
2807 status
= resolve_wins(talloc_tos(),
2812 if (!NT_STATUS_IS_OK(status
)) {
2818 if (strequal(tok
, "bcast")) {
2819 status
= name_resolve_bcast(
2825 if (!NT_STATUS_IS_OK(status
)) {
2831 DBG_ERR("unknown name switch type %s\n", tok
);
2834 /* All of the resolve_* functions above have returned false. */
2843 status
= sockaddr_array_to_samba_sockaddr_array(frame
,
2848 if (!NT_STATUS_IS_OK(status
)) {
2850 return NT_STATUS_NO_MEMORY
;
2853 /* Remove duplicate entries. Some queries, notably #1c (domain
2854 controllers) return the PDC in iplist[0] and then all domain
2855 controllers including the PDC in iplist[1..n]. Iterating over
2856 the iplist when the PDC is down will cause two sets of timeouts. */
2858 ret_count
= remove_duplicate_addrs2(sa_list
, ret_count
);
2860 /* Save in name cache */
2861 if ( DEBUGLEVEL
>= 100 ) {
2862 for (i
= 0; i
< ret_count
&& DEBUGLEVEL
== 100; i
++) {
2863 char addr
[INET6_ADDRSTRLEN
];
2864 print_sockaddr(addr
, sizeof(addr
),
2866 DEBUG(100, ("Storing name %s of type %d (%s:0)\n",
2874 namecache_store(name
,
2880 /* Display some debugging info */
2882 if ( DEBUGLEVEL
>= 10 ) {
2883 DBG_DEBUG("returning %zu addresses: ",
2886 for (i
= 0; i
< ret_count
; i
++) {
2887 char addr
[INET6_ADDRSTRLEN
];
2888 print_sockaddr(addr
, sizeof(addr
),
2890 DEBUGADD(10, ("%s ", addr
));
2895 *return_count
= ret_count
;
2896 *return_salist
= talloc_move(ctx
, &sa_list
);
2902 /********************************************************
2903 Internal interface to resolve a name into one IP address.
2904 Use this function if the string is either an IP address, DNS
2905 or host name or NetBIOS name. This uses the name switch in the
2906 smb.conf to determine the order of name resolution.
2907 *********************************************************/
2909 bool resolve_name(const char *name
,
2910 struct sockaddr_storage
*return_ss
,
2914 struct samba_sockaddr
*sa_list
= NULL
;
2915 char *sitename
= NULL
;
2918 TALLOC_CTX
*frame
= NULL
;
2920 if (is_ipaddress(name
)) {
2921 return interpret_string_addr(return_ss
, name
, AI_NUMERICHOST
);
2924 frame
= talloc_stackframe();
2926 sitename
= sitename_fetch(frame
, lp_realm()); /* wild guess */
2928 status
= internal_resolve_name(frame
,
2934 lp_name_resolve_order());
2935 if (NT_STATUS_IS_OK(status
)) {
2939 for (i
=0; i
<count
; i
++) {
2940 if (!is_broadcast_addr(&sa_list
[i
].u
.sa
) &&
2941 (sa_list
[i
].u
.ss
.ss_family
== AF_INET
)) {
2942 *return_ss
= sa_list
[i
].u
.ss
;
2943 TALLOC_FREE(sa_list
);
2950 /* only return valid addresses for TCP connections */
2951 for (i
=0; i
<count
; i
++) {
2952 if (!is_broadcast_addr(&sa_list
[i
].u
.sa
)) {
2953 *return_ss
= sa_list
[i
].u
.ss
;
2954 TALLOC_FREE(sa_list
);
2961 TALLOC_FREE(sa_list
);
2966 /********************************************************
2967 Internal interface to resolve a name into a list of IP addresses.
2968 Use this function if the string is either an IP address, DNS
2969 or host name or NetBIOS name. This uses the name switch in the
2970 smb.conf to determine the order of name resolution.
2971 *********************************************************/
2973 NTSTATUS
resolve_name_list(TALLOC_CTX
*ctx
,
2976 struct sockaddr_storage
**return_ss_arr
,
2977 unsigned int *p_num_entries
)
2979 struct samba_sockaddr
*sa_list
= NULL
;
2980 char *sitename
= NULL
;
2983 unsigned int num_entries
= 0;
2984 struct sockaddr_storage
*result_arr
= NULL
;
2987 if (is_ipaddress(name
)) {
2988 result_arr
= talloc(ctx
, struct sockaddr_storage
);
2989 if (result_arr
== NULL
) {
2990 return NT_STATUS_NO_MEMORY
;
2992 if (!interpret_string_addr(result_arr
, name
, AI_NUMERICHOST
)) {
2993 TALLOC_FREE(result_arr
);
2994 return NT_STATUS_BAD_NETWORK_NAME
;
2997 *return_ss_arr
= result_arr
;
2998 return NT_STATUS_OK
;
3001 sitename
= sitename_fetch(ctx
, lp_realm()); /* wild guess */
3003 status
= internal_resolve_name(ctx
,
3009 lp_name_resolve_order());
3010 TALLOC_FREE(sitename
);
3012 if (!NT_STATUS_IS_OK(status
)) {
3016 /* only return valid addresses for TCP connections */
3017 for (i
=0, num_entries
= 0; i
<count
; i
++) {
3018 if (!is_zero_addr(&sa_list
[i
].u
.ss
) &&
3019 !is_broadcast_addr(&sa_list
[i
].u
.sa
)) {
3023 if (num_entries
== 0) {
3024 status
= NT_STATUS_BAD_NETWORK_NAME
;
3028 result_arr
= talloc_array(ctx
,
3029 struct sockaddr_storage
,
3031 if (result_arr
== NULL
) {
3032 status
= NT_STATUS_NO_MEMORY
;
3036 for (i
=0, num_entries
= 0; i
<count
; i
++) {
3037 if (!is_zero_addr(&sa_list
[i
].u
.ss
) &&
3038 !is_broadcast_addr(&sa_list
[i
].u
.sa
)) {
3039 result_arr
[num_entries
++] = sa_list
[i
].u
.ss
;
3043 if (num_entries
== 0) {
3044 TALLOC_FREE(result_arr
);
3045 status
= NT_STATUS_BAD_NETWORK_NAME
;
3049 status
= NT_STATUS_OK
;
3050 *p_num_entries
= num_entries
;
3051 *return_ss_arr
= result_arr
;
3053 TALLOC_FREE(sa_list
);
3057 /********************************************************
3058 Find the IP address of the master browser or DMB for a workgroup.
3059 *********************************************************/
3061 bool find_master_ip(const char *group
, struct sockaddr_storage
*master_ss
)
3063 struct samba_sockaddr
*sa_list
= NULL
;
3067 if (lp_disable_netbios()) {
3068 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group
));
3072 status
= internal_resolve_name(talloc_tos(),
3078 lp_name_resolve_order());
3079 if (NT_STATUS_IS_OK(status
)) {
3080 *master_ss
= sa_list
[0].u
.ss
;
3081 TALLOC_FREE(sa_list
);
3085 TALLOC_FREE(sa_list
);
3087 status
= internal_resolve_name(talloc_tos(),
3093 lp_name_resolve_order());
3094 if (NT_STATUS_IS_OK(status
)) {
3095 *master_ss
= sa_list
[0].u
.ss
;
3096 TALLOC_FREE(sa_list
);
3100 TALLOC_FREE(sa_list
);
3104 /********************************************************
3105 Get the IP address list of the primary domain controller
3107 *********************************************************/
3109 bool get_pdc_ip(const char *domain
, struct sockaddr_storage
*pss
)
3111 struct samba_sockaddr
*sa_list
= NULL
;
3113 NTSTATUS status
= NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND
;
3114 static const char *ads_order
[] = { "ads", NULL
};
3115 /* Look up #1B name */
3117 if (lp_security() == SEC_ADS
) {
3118 status
= internal_resolve_name(talloc_tos(),
3127 if (!NT_STATUS_IS_OK(status
) || count
== 0) {
3128 TALLOC_FREE(sa_list
);
3129 status
= internal_resolve_name(talloc_tos(),
3135 lp_name_resolve_order());
3136 if (!NT_STATUS_IS_OK(status
)) {
3137 TALLOC_FREE(sa_list
);
3142 /* if we get more than 1 IP back we have to assume it is a
3143 multi-homed PDC and not a mess up */
3146 DBG_INFO("PDC has %zu IP addresses!\n", count
);
3147 sort_sa_list(sa_list
, count
);
3150 *pss
= sa_list
[0].u
.ss
;
3151 TALLOC_FREE(sa_list
);
3155 /* Private enum type for lookups. */
3157 enum dc_lookup_type
{ DC_NORMAL_LOOKUP
, DC_ADS_ONLY
, DC_KDC_ONLY
};
3159 /********************************************************
3160 Get the IP address list of the domain controllers for
3162 *********************************************************/
3164 static NTSTATUS
get_dc_list(TALLOC_CTX
*ctx
,
3166 const char *sitename
,
3167 struct samba_sockaddr
**sa_list_ret
,
3169 enum dc_lookup_type lookup_type
,
3172 const char **resolve_order
= NULL
;
3173 char *saf_servername
= NULL
;
3174 char *pserver
= NULL
;
3177 size_t num_addresses
= 0;
3178 size_t local_count
= 0;
3180 struct samba_sockaddr
*auto_sa_list
= NULL
;
3181 struct samba_sockaddr
*return_salist
= NULL
;
3182 bool done_auto_lookup
= false;
3183 size_t auto_count
= 0;
3185 TALLOC_CTX
*frame
= talloc_stackframe();
3186 int auto_name_type
= 0x1C;
3190 /* if we are restricted to solely using DNS for looking
3191 up a domain controller, make sure that host lookups
3192 are enabled for the 'name resolve order'. If host lookups
3193 are disabled and ads_only is True, then set the string to
3196 resolve_order
= lp_name_resolve_order();
3197 if (!resolve_order
) {
3198 status
= NT_STATUS_NO_MEMORY
;
3201 if (lookup_type
== DC_ADS_ONLY
) {
3202 if (str_list_check_ci(resolve_order
, "host")) {
3203 static const char *ads_order
[] = { "ads", NULL
};
3204 resolve_order
= ads_order
;
3206 /* DNS SRV lookups used by the ads resolver
3207 are already sorted by priority and weight */
3210 /* this is quite bizarre! */
3211 static const char *null_order
[] = { "NULL", NULL
};
3212 resolve_order
= null_order
;
3214 } else if (lookup_type
== DC_KDC_ONLY
) {
3215 static const char *kdc_order
[] = { "kdc", NULL
};
3216 /* DNS SRV lookups used by the ads/kdc resolver
3217 are already sorted by priority and weight */
3219 resolve_order
= kdc_order
;
3220 auto_name_type
= KDC_NAME_TYPE
;
3223 /* fetch the server we have affinity for. Add the
3224 'password server' list to a search for our domain controllers */
3226 saf_servername
= saf_fetch(frame
, domain
);
3228 if (strequal(domain
, lp_workgroup()) || strequal(domain
, lp_realm())) {
3229 pserver
= talloc_asprintf(frame
, "%s, %s",
3230 saf_servername
? saf_servername
: "",
3231 lp_password_server());
3233 pserver
= talloc_asprintf(frame
, "%s, *",
3234 saf_servername
? saf_servername
: "");
3237 TALLOC_FREE(saf_servername
);
3239 status
= NT_STATUS_NO_MEMORY
;
3243 DEBUG(3,("get_dc_list: preferred server list: \"%s\"\n", pserver
));
3246 * if '*' appears in the "password server" list then add
3247 * an auto lookup to the list of manually configured
3248 * DC's. If any DC is listed by name, then the list should be
3249 * considered to be ordered
3253 while (next_token_talloc(frame
, &p
, &name
, LIST_SEP
)) {
3254 if (!done_auto_lookup
&& strequal(name
, "*")) {
3255 done_auto_lookup
= true;
3257 status
= internal_resolve_name(frame
,
3264 if (!NT_STATUS_IS_OK(status
)) {
3268 if (num_addresses
+ auto_count
< num_addresses
) {
3269 TALLOC_FREE(auto_sa_list
);
3270 status
= NT_STATUS_INVALID_PARAMETER
;
3273 num_addresses
+= auto_count
;
3274 DBG_DEBUG("Adding %zu DC's from auto lookup\n",
3278 if (num_addresses
+ 1 < num_addresses
) {
3279 TALLOC_FREE(auto_sa_list
);
3280 status
= NT_STATUS_INVALID_PARAMETER
;
3287 /* if we have no addresses and haven't done the auto lookup, then
3288 just return the list of DC's. Or maybe we just failed. */
3290 if (num_addresses
== 0) {
3291 struct samba_sockaddr
*dc_salist
= NULL
;
3292 size_t dc_count
= 0;
3294 if (done_auto_lookup
) {
3295 DEBUG(4,("get_dc_list: no servers found\n"));
3296 status
= NT_STATUS_NO_LOGON_SERVERS
;
3299 /* talloc off frame, only move to ctx on success. */
3300 status
= internal_resolve_name(frame
,
3307 if (!NT_STATUS_IS_OK(status
)) {
3310 return_salist
= dc_salist
;
3311 local_count
= dc_count
;
3315 return_salist
= talloc_zero_array(frame
,
3316 struct samba_sockaddr
,
3318 if (return_salist
== NULL
) {
3319 DEBUG(3,("get_dc_list: malloc fail !\n"));
3320 status
= NT_STATUS_NO_MEMORY
;
3327 /* fill in the return list now with real IP's */
3329 while ((local_count
<num_addresses
) &&
3330 next_token_talloc(frame
, &p
, &name
, LIST_SEP
)) {
3331 struct samba_sockaddr name_sa
= {0};
3333 /* copy any addresses from the auto lookup */
3335 if (strequal(name
, "*")) {
3337 for (j
=0; j
<auto_count
; j
++) {
3338 char addr
[INET6_ADDRSTRLEN
];
3339 print_sockaddr(addr
,
3341 &auto_sa_list
[j
].u
.ss
);
3342 /* Check for and don't copy any
3343 * known bad DC IP's. */
3344 if(!NT_STATUS_IS_OK(check_negative_conn_cache(
3347 DEBUG(5,("get_dc_list: "
3348 "negative entry %s removed "
3353 return_salist
[local_count
] = auto_sa_list
[j
];
3359 /* explicit lookup; resolve_name() will
3360 * handle names & IP addresses */
3361 if (resolve_name(name
, &name_sa
.u
.ss
, 0x20, true)) {
3362 char addr
[INET6_ADDRSTRLEN
];
3366 * Ensure we set sa_socklen correctly.
3367 * Doesn't matter now, but eventually we
3368 * will remove ip_service and return samba_sockaddr
3371 ok
= sockaddr_storage_to_samba_sockaddr(
3375 status
= NT_STATUS_INVALID_ADDRESS
;
3379 print_sockaddr(addr
,
3383 /* Check for and don't copy any known bad DC IP's. */
3384 if( !NT_STATUS_IS_OK(check_negative_conn_cache(domain
,
3386 DEBUG(5,("get_dc_list: negative entry %s "
3387 "removed from DC list\n",
3392 return_salist
[local_count
] = name_sa
;
3398 /* need to remove duplicates in the list if we have any
3399 explicit password servers */
3401 local_count
= remove_duplicate_addrs2(return_salist
, local_count
);
3403 /* For DC's we always prioritize IPv4 due to W2K3 not
3404 * supporting LDAP, KRB5 or CLDAP over IPv6. */
3406 if (local_count
&& return_salist
!= NULL
) {
3407 prioritize_ipv4_list(return_salist
, local_count
);
3410 if ( DEBUGLEVEL
>= 4 ) {
3411 DEBUG(4,("get_dc_list: returning %zu ip addresses "
3412 "in an %sordered list\n",
3414 *ordered
? "":"un"));
3415 DEBUG(4,("get_dc_list: "));
3416 for ( i
=0; i
<local_count
; i
++ ) {
3417 char addr
[INET6_ADDRSTRLEN
];
3418 print_sockaddr(addr
,
3420 &return_salist
[i
].u
.ss
);
3421 DEBUGADD(4,("%s ", addr
));
3426 status
= (local_count
!= 0 ? NT_STATUS_OK
: NT_STATUS_NO_LOGON_SERVERS
);
3430 if (NT_STATUS_IS_OK(status
)) {
3431 *sa_list_ret
= talloc_move(ctx
, &return_salist
);
3432 *ret_count
= local_count
;
3434 TALLOC_FREE(return_salist
);
3435 TALLOC_FREE(auto_sa_list
);
3440 /*********************************************************************
3441 Small wrapper function to get the DC list and sort it if neccessary.
3442 Returns a samba_sockaddr array.
3443 *********************************************************************/
3445 NTSTATUS
get_sorted_dc_list(TALLOC_CTX
*ctx
,
3447 const char *sitename
,
3448 struct samba_sockaddr
**sa_list_ret
,
3452 bool ordered
= false;
3454 enum dc_lookup_type lookup_type
= DC_NORMAL_LOOKUP
;
3455 struct samba_sockaddr
*sa_list
= NULL
;
3458 DBG_INFO("attempting lookup for name %s (sitename %s)\n",
3460 sitename
? sitename
: "NULL");
3463 lookup_type
= DC_ADS_ONLY
;
3466 status
= get_dc_list(ctx
,
3473 if (NT_STATUS_EQUAL(status
, NT_STATUS_NO_LOGON_SERVERS
)
3475 DBG_NOTICE("no server for name %s available"
3476 " in site %s, fallback to all servers\n",
3479 status
= get_dc_list(ctx
,
3488 if (!NT_STATUS_IS_OK(status
)) {
3492 /* only sort if we don't already have an ordered list */
3494 sort_sa_list(sa_list
, count
);
3498 *sa_list_ret
= sa_list
;
3502 /*********************************************************************
3503 Get the KDC list - re-use all the logic in get_dc_list.
3504 Returns a samba_sockaddr array.
3505 *********************************************************************/
3507 NTSTATUS
get_kdc_list(TALLOC_CTX
*ctx
,
3509 const char *sitename
,
3510 struct samba_sockaddr
**sa_list_ret
,
3514 struct samba_sockaddr
*sa_list
= NULL
;
3515 bool ordered
= false;
3518 status
= get_dc_list(ctx
,
3526 if (!NT_STATUS_IS_OK(status
)) {
3530 /* only sort if we don't already have an ordered list */
3532 sort_sa_list(sa_list
, count
);
3536 *sa_list_ret
= sa_list
;