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 "../libcli/netlogon/netlogon.h"
27 #include "lib/async_req/async_sock.h"
28 #include "lib/tsocket/tsocket.h"
29 #include "libsmb/nmblib.h"
30 #include "libsmb/unexpected.h"
31 #include "../libcli/nbt/libnbt.h"
32 #include "libads/kerberos_proto.h"
33 #include "lib/gencache.h"
35 /* nmbd.c sets this to True. */
36 bool global_in_nmbd = False;
38 /****************************
39 * SERVER AFFINITY ROUTINES *
40 ****************************/
42 /* Server affinity is the concept of preferring the last domain
43 controller with whom you had a successful conversation */
45 /****************************************************************************
46 ****************************************************************************/
47 #define SAFKEY_FMT "SAF/DOMAIN/%s"
49 #define SAFJOINKEY_FMT "SAFJOIN/DOMAIN/%s"
50 #define SAFJOIN_TTL 3600
52 static char *saf_key(TALLOC_CTX *mem_ctx, const char *domain)
54 return talloc_asprintf_strupper_m(mem_ctx, SAFKEY_FMT, domain);
57 static char *saf_join_key(TALLOC_CTX *mem_ctx, const char *domain)
59 return talloc_asprintf_strupper_m(mem_ctx, SAFJOINKEY_FMT, domain);
62 /****************************************************************************
63 ****************************************************************************/
65 bool saf_store( const char *domain, const char *servername )
71 if ( !domain || !servername ) {
72 DEBUG(2,("saf_store: "
73 "Refusing to store empty domain or servername!\n"));
77 if ( (strlen(domain) == 0) || (strlen(servername) == 0) ) {
78 DEBUG(0,("saf_store: "
79 "refusing to store 0 length domain or servername!\n"));
83 key = saf_key(talloc_tos(), domain);
85 DEBUG(1, ("saf_key() failed\n"));
88 expire = time( NULL ) + lp_parm_int(-1, "saf","ttl", SAF_TTL);
90 DEBUG(10,("saf_store: domain = [%s], server = [%s], expire = [%u]\n",
91 domain, servername, (unsigned int)expire ));
93 ret = gencache_set( key, servername, expire );
100 bool saf_join_store( const char *domain, const char *servername )
106 if ( !domain || !servername ) {
107 DEBUG(2,("saf_join_store: Refusing to store empty domain or servername!\n"));
111 if ( (strlen(domain) == 0) || (strlen(servername) == 0) ) {
112 DEBUG(0,("saf_join_store: refusing to store 0 length domain or servername!\n"));
116 key = saf_join_key(talloc_tos(), domain);
118 DEBUG(1, ("saf_join_key() failed\n"));
121 expire = time( NULL ) + lp_parm_int(-1, "saf","join ttl", SAFJOIN_TTL);
123 DEBUG(10,("saf_join_store: domain = [%s], server = [%s], expire = [%u]\n",
124 domain, servername, (unsigned int)expire ));
126 ret = gencache_set( key, servername, expire );
133 bool saf_delete( const char *domain )
139 DEBUG(2,("saf_delete: Refusing to delete empty domain\n"));
143 key = saf_join_key(talloc_tos(), domain);
145 DEBUG(1, ("saf_join_key() failed\n"));
148 ret = gencache_del(key);
152 DEBUG(10,("saf_delete[join]: domain = [%s]\n", domain ));
155 key = saf_key(talloc_tos(), domain);
157 DEBUG(1, ("saf_key() failed\n"));
160 ret = gencache_del(key);
164 DEBUG(10,("saf_delete: domain = [%s]\n", domain ));
170 /****************************************************************************
171 ****************************************************************************/
173 char *saf_fetch(TALLOC_CTX *mem_ctx, const char *domain )
180 if ( !domain || strlen(domain) == 0) {
181 DEBUG(2,("saf_fetch: Empty domain name!\n"));
185 key = saf_join_key(talloc_tos(), domain);
187 DEBUG(1, ("saf_join_key() failed\n"));
191 ret = gencache_get( key, mem_ctx, &server, &timeout );
196 DEBUG(5,("saf_fetch[join]: Returning \"%s\" for \"%s\" domain\n",
201 key = saf_key(talloc_tos(), domain);
203 DEBUG(1, ("saf_key() failed\n"));
207 ret = gencache_get( key, mem_ctx, &server, &timeout );
212 DEBUG(5,("saf_fetch: failed to find server for \"%s\" domain\n",
215 DEBUG(5,("saf_fetch: Returning \"%s\" for \"%s\" domain\n",
222 static void set_socket_addr_v4(struct sockaddr_storage *addr)
224 if (!interpret_string_addr(addr, lp_nbt_client_socket_address(),
225 AI_NUMERICHOST|AI_PASSIVE)) {
228 if (addr->ss_family != AF_INET) {
233 static struct in_addr my_socket_addr_v4(void)
235 struct sockaddr_storage my_addr;
236 struct sockaddr_in *in_addr = (struct sockaddr_in *)((char *)&my_addr);
238 set_socket_addr_v4(&my_addr);
239 return in_addr->sin_addr;
242 /****************************************************************************
243 Generate a random trn_id.
244 ****************************************************************************/
246 static int generate_trn_id(void)
250 generate_random_buffer((uint8_t *)&id, sizeof(id));
252 return id % (unsigned)0x7FFF;
255 /****************************************************************************
256 Parse a node status response into an array of structures.
257 ****************************************************************************/
259 static struct node_status *parse_node_status(TALLOC_CTX *mem_ctx, char *p,
261 struct node_status_extra *extra)
263 struct node_status *ret;
266 *num_names = CVAL(p,0);
271 ret = talloc_array(mem_ctx, struct node_status,*num_names);
276 for (i=0;i< *num_names;i++) {
277 strlcpy(ret[i].name,p,16);
278 trim_char(ret[i].name,'\0',' ');
279 ret[i].type = CVAL(p,15);
280 ret[i].flags = p[16];
282 DEBUG(10, ("%s#%02x: flags = 0x%02x\n", ret[i].name,
283 ret[i].type, ret[i].flags));
286 * Also, pick up the MAC address ...
289 memcpy(&extra->mac_addr, p, 6); /* Fill in the mac addr */
294 struct sock_packet_read_state {
295 struct tevent_context *ev;
296 enum packet_type type;
299 struct nb_packet_reader *reader;
300 struct tevent_req *reader_req;
302 struct tdgram_context *sock;
303 struct tevent_req *socket_req;
305 struct tsocket_address *addr;
307 bool (*validator)(struct packet_struct *p,
311 struct packet_struct *packet;
314 static void sock_packet_read_got_packet(struct tevent_req *subreq);
315 static void sock_packet_read_got_socket(struct tevent_req *subreq);
317 static struct tevent_req *sock_packet_read_send(
319 struct tevent_context *ev,
320 struct tdgram_context *sock,
321 struct nb_packet_reader *reader,
322 enum packet_type type,
324 bool (*validator)(struct packet_struct *p, void *private_data),
327 struct tevent_req *req;
328 struct sock_packet_read_state *state;
330 req = tevent_req_create(mem_ctx, &state,
331 struct sock_packet_read_state);
336 state->reader = reader;
339 state->trn_id = trn_id;
340 state->validator = validator;
341 state->private_data = private_data;
343 if (reader != NULL) {
344 state->reader_req = nb_packet_read_send(state, ev, reader);
345 if (tevent_req_nomem(state->reader_req, req)) {
346 return tevent_req_post(req, ev);
348 tevent_req_set_callback(
349 state->reader_req, sock_packet_read_got_packet, req);
352 state->socket_req = tdgram_recvfrom_send(state, ev, state->sock);
353 if (tevent_req_nomem(state->socket_req, req)) {
354 return tevent_req_post(req, ev);
356 tevent_req_set_callback(state->socket_req, sock_packet_read_got_socket,
362 static void sock_packet_read_got_packet(struct tevent_req *subreq)
364 struct tevent_req *req = tevent_req_callback_data(
365 subreq, struct tevent_req);
366 struct sock_packet_read_state *state = tevent_req_data(
367 req, struct sock_packet_read_state);
370 status = nb_packet_read_recv(subreq, state, &state->packet);
372 TALLOC_FREE(state->reader_req);
374 if (!NT_STATUS_IS_OK(status)) {
375 if (state->socket_req != NULL) {
377 * Still waiting for socket
382 * Both socket and packet reader failed
384 tevent_req_nterror(req, status);
388 if ((state->validator != NULL) &&
389 !state->validator(state->packet, state->private_data)) {
390 DEBUG(10, ("validator failed\n"));
392 TALLOC_FREE(state->packet);
394 state->reader_req = nb_packet_read_send(state, state->ev,
396 if (tevent_req_nomem(state->reader_req, req)) {
399 tevent_req_set_callback(
400 state->reader_req, sock_packet_read_got_packet, req);
404 TALLOC_FREE(state->socket_req);
405 tevent_req_done(req);
408 static void sock_packet_read_got_socket(struct tevent_req *subreq)
410 struct tevent_req *req = tevent_req_callback_data(
411 subreq, struct tevent_req);
412 struct sock_packet_read_state *state = tevent_req_data(
413 req, struct sock_packet_read_state);
416 struct sockaddr_in sin;
423 received = tdgram_recvfrom_recv(subreq, &err, state,
424 &state->buf, &state->addr);
426 TALLOC_FREE(state->socket_req);
428 if (received == -1) {
429 if (state->reader_req != NULL) {
431 * Still waiting for reader
436 * Both socket and reader failed
438 tevent_req_nterror(req, map_nt_error_from_unix(err));
441 ok = tsocket_address_is_inet(state->addr, "ipv4");
445 ret = tsocket_address_bsd_sockaddr(state->addr,
449 tevent_req_nterror(req, map_nt_error_from_unix(errno));
453 state->packet = parse_packet_talloc(
454 state, (char *)state->buf, received, state->type,
455 addr.sin.sin_addr, addr.sin.sin_port);
456 if (state->packet == NULL) {
457 DEBUG(10, ("parse_packet failed\n"));
460 if ((state->trn_id != -1) &&
461 (state->trn_id != packet_trn_id(state->packet))) {
462 DEBUG(10, ("Expected transaction id %d, got %d\n",
463 state->trn_id, packet_trn_id(state->packet)));
467 if ((state->validator != NULL) &&
468 !state->validator(state->packet, state->private_data)) {
469 DEBUG(10, ("validator failed\n"));
473 tevent_req_done(req);
477 TALLOC_FREE(state->packet);
478 TALLOC_FREE(state->buf);
479 TALLOC_FREE(state->addr);
481 state->socket_req = tdgram_recvfrom_send(state, state->ev, state->sock);
482 if (tevent_req_nomem(state->socket_req, req)) {
485 tevent_req_set_callback(state->socket_req, sock_packet_read_got_socket,
489 static NTSTATUS sock_packet_read_recv(struct tevent_req *req,
491 struct packet_struct **ppacket)
493 struct sock_packet_read_state *state = tevent_req_data(
494 req, struct sock_packet_read_state);
497 if (tevent_req_is_nterror(req, &status)) {
500 *ppacket = talloc_move(mem_ctx, &state->packet);
504 struct nb_trans_state {
505 struct tevent_context *ev;
506 struct tdgram_context *sock;
507 struct nb_packet_reader *reader;
509 struct tsocket_address *src_addr;
510 struct tsocket_address *dst_addr;
513 enum packet_type type;
516 bool (*validator)(struct packet_struct *p,
520 struct packet_struct *packet;
523 static void nb_trans_got_reader(struct tevent_req *subreq);
524 static void nb_trans_done(struct tevent_req *subreq);
525 static void nb_trans_sent(struct tevent_req *subreq);
526 static void nb_trans_send_next(struct tevent_req *subreq);
528 static struct tevent_req *nb_trans_send(
530 struct tevent_context *ev,
531 const struct sockaddr_storage *_my_addr,
532 const struct sockaddr_storage *_dst_addr,
534 uint8_t *buf, size_t buflen,
535 enum packet_type type, int trn_id,
536 bool (*validator)(struct packet_struct *p,
540 const struct sockaddr *my_addr =
541 discard_const_p(const struct sockaddr, _my_addr);
542 size_t my_addr_len = sizeof(*_my_addr);
543 const struct sockaddr *dst_addr =
544 discard_const_p(const struct sockaddr, _dst_addr);
545 size_t dst_addr_len = sizeof(*_dst_addr);
546 struct tevent_req *req, *subreq;
547 struct nb_trans_state *state;
550 req = tevent_req_create(mem_ctx, &state, struct nb_trans_state);
556 state->buflen = buflen;
558 state->trn_id = trn_id;
559 state->validator = validator;
560 state->private_data = private_data;
562 ret = tsocket_address_bsd_from_sockaddr(state,
563 my_addr, my_addr_len,
566 tevent_req_nterror(req, map_nt_error_from_unix(errno));
567 return tevent_req_post(req, ev);
570 ret = tsocket_address_bsd_from_sockaddr(state,
571 dst_addr, dst_addr_len,
574 tevent_req_nterror(req, map_nt_error_from_unix(errno));
575 return tevent_req_post(req, ev);
578 ret = tdgram_inet_udp_broadcast_socket(state->src_addr, state,
581 tevent_req_nterror(req, map_nt_error_from_unix(errno));
582 return tevent_req_post(req, ev);
585 subreq = nb_packet_reader_send(state, ev, type, state->trn_id, NULL);
586 if (tevent_req_nomem(subreq, req)) {
587 return tevent_req_post(req, ev);
589 tevent_req_set_callback(subreq, nb_trans_got_reader, req);
593 static void nb_trans_got_reader(struct tevent_req *subreq)
595 struct tevent_req *req = tevent_req_callback_data(
596 subreq, struct tevent_req);
597 struct nb_trans_state *state = tevent_req_data(
598 req, struct nb_trans_state);
601 status = nb_packet_reader_recv(subreq, state, &state->reader);
604 if (!NT_STATUS_IS_OK(status)) {
605 DEBUG(10, ("nmbd not around\n"));
606 state->reader = NULL;
609 subreq = sock_packet_read_send(
610 state, state->ev, state->sock,
611 state->reader, state->type, state->trn_id,
612 state->validator, state->private_data);
613 if (tevent_req_nomem(subreq, req)) {
616 tevent_req_set_callback(subreq, nb_trans_done, req);
618 subreq = tdgram_sendto_send(state, state->ev,
620 state->buf, state->buflen,
622 if (tevent_req_nomem(subreq, req)) {
625 tevent_req_set_callback(subreq, nb_trans_sent, req);
628 static void nb_trans_sent(struct tevent_req *subreq)
630 struct tevent_req *req = tevent_req_callback_data(
631 subreq, struct tevent_req);
632 struct nb_trans_state *state = tevent_req_data(
633 req, struct nb_trans_state);
637 sent = tdgram_sendto_recv(subreq, &err);
640 DEBUG(10, ("sendto failed: %s\n", strerror(err)));
641 tevent_req_nterror(req, map_nt_error_from_unix(err));
644 subreq = tevent_wakeup_send(state, state->ev,
645 timeval_current_ofs(1, 0));
646 if (tevent_req_nomem(subreq, req)) {
649 tevent_req_set_callback(subreq, nb_trans_send_next, req);
652 static void nb_trans_send_next(struct tevent_req *subreq)
654 struct tevent_req *req = tevent_req_callback_data(
655 subreq, struct tevent_req);
656 struct nb_trans_state *state = tevent_req_data(
657 req, struct nb_trans_state);
660 ret = tevent_wakeup_recv(subreq);
663 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
666 subreq = tdgram_sendto_send(state, state->ev,
668 state->buf, state->buflen,
670 if (tevent_req_nomem(subreq, req)) {
673 tevent_req_set_callback(subreq, nb_trans_sent, req);
676 static void nb_trans_done(struct tevent_req *subreq)
678 struct tevent_req *req = tevent_req_callback_data(
679 subreq, struct tevent_req);
680 struct nb_trans_state *state = tevent_req_data(
681 req, struct nb_trans_state);
684 status = sock_packet_read_recv(subreq, state, &state->packet);
686 if (tevent_req_nterror(req, status)) {
689 tevent_req_done(req);
692 static NTSTATUS nb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
693 struct packet_struct **ppacket)
695 struct nb_trans_state *state = tevent_req_data(
696 req, struct nb_trans_state);
699 if (tevent_req_is_nterror(req, &status)) {
702 *ppacket = talloc_move(mem_ctx, &state->packet);
706 /****************************************************************************
707 Do a NBT node status query on an open socket and return an array of
708 structures holding the returned names or NULL if the query failed.
709 **************************************************************************/
711 struct node_status_query_state {
712 struct sockaddr_storage my_addr;
713 struct sockaddr_storage addr;
716 struct packet_struct *packet;
719 static bool node_status_query_validator(struct packet_struct *p,
721 static void node_status_query_done(struct tevent_req *subreq);
723 struct tevent_req *node_status_query_send(TALLOC_CTX *mem_ctx,
724 struct tevent_context *ev,
725 struct nmb_name *name,
726 const struct sockaddr_storage *addr)
728 struct tevent_req *req, *subreq;
729 struct node_status_query_state *state;
730 struct packet_struct p;
731 struct nmb_packet *nmb = &p.packet.nmb;
732 struct sockaddr_in *in_addr;
734 req = tevent_req_create(mem_ctx, &state,
735 struct node_status_query_state);
740 if (addr->ss_family != AF_INET) {
741 /* Can't do node status to IPv6 */
742 tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
743 return tevent_req_post(req, ev);
747 in_addr = (struct sockaddr_in *)(void *)&state->addr;
748 in_addr->sin_port = htons(NMB_PORT);
750 set_socket_addr_v4(&state->my_addr);
753 nmb->header.name_trn_id = generate_trn_id();
754 nmb->header.opcode = 0;
755 nmb->header.response = false;
756 nmb->header.nm_flags.bcast = false;
757 nmb->header.nm_flags.recursion_available = false;
758 nmb->header.nm_flags.recursion_desired = false;
759 nmb->header.nm_flags.trunc = false;
760 nmb->header.nm_flags.authoritative = false;
761 nmb->header.rcode = 0;
762 nmb->header.qdcount = 1;
763 nmb->header.ancount = 0;
764 nmb->header.nscount = 0;
765 nmb->header.arcount = 0;
766 nmb->question.question_name = *name;
767 nmb->question.question_type = 0x21;
768 nmb->question.question_class = 0x1;
770 state->buflen = build_packet((char *)state->buf, sizeof(state->buf),
772 if (state->buflen == 0) {
773 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
774 DEBUG(10, ("build_packet failed\n"));
775 return tevent_req_post(req, ev);
778 subreq = nb_trans_send(state, ev, &state->my_addr, &state->addr, false,
779 state->buf, state->buflen,
780 NMB_PACKET, nmb->header.name_trn_id,
781 node_status_query_validator, NULL);
782 if (tevent_req_nomem(subreq, req)) {
783 DEBUG(10, ("nb_trans_send failed\n"));
784 return tevent_req_post(req, ev);
786 if (!tevent_req_set_endtime(req, ev, timeval_current_ofs(10, 0))) {
787 return tevent_req_post(req, ev);
789 tevent_req_set_callback(subreq, node_status_query_done, req);
793 static bool node_status_query_validator(struct packet_struct *p,
796 struct nmb_packet *nmb = &p->packet.nmb;
799 if (nmb->header.opcode != 0 ||
800 nmb->header.nm_flags.bcast ||
802 !nmb->header.ancount ||
803 nmb->answers->rr_type != 0x21) {
805 * XXXX what do we do with this? could be a redirect,
806 * but we'll discard it for the moment
813 static void node_status_query_done(struct tevent_req *subreq)
815 struct tevent_req *req = tevent_req_callback_data(
816 subreq, struct tevent_req);
817 struct node_status_query_state *state = tevent_req_data(
818 req, struct node_status_query_state);
821 status = nb_trans_recv(subreq, state, &state->packet);
823 if (tevent_req_nterror(req, status)) {
826 tevent_req_done(req);
829 NTSTATUS node_status_query_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
830 struct node_status **pnode_status,
832 struct node_status_extra *extra)
834 struct node_status_query_state *state = tevent_req_data(
835 req, struct node_status_query_state);
836 struct node_status *node_status;
840 if (tevent_req_is_nterror(req, &status)) {
843 node_status = parse_node_status(
844 mem_ctx, &state->packet->packet.nmb.answers->rdata[0],
846 if (node_status == NULL) {
847 return NT_STATUS_NO_MEMORY;
849 *pnode_status = node_status;
850 *pnum_names = num_names;
854 NTSTATUS node_status_query(TALLOC_CTX *mem_ctx, struct nmb_name *name,
855 const struct sockaddr_storage *addr,
856 struct node_status **pnode_status,
858 struct node_status_extra *extra)
860 TALLOC_CTX *frame = talloc_stackframe();
861 struct tevent_context *ev;
862 struct tevent_req *req;
863 NTSTATUS status = NT_STATUS_NO_MEMORY;
865 ev = samba_tevent_context_init(frame);
869 req = node_status_query_send(ev, ev, name, addr);
873 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
876 status = node_status_query_recv(req, mem_ctx, pnode_status,
883 static bool name_status_lmhosts(const struct sockaddr_storage *paddr,
884 int qname_type, fstring pname)
889 struct sockaddr_storage addr;
891 if (paddr->ss_family != AF_INET) {
895 f = startlmhosts(get_dyn_LMHOSTSFILE());
900 while (getlmhostsent(talloc_tos(), f, &name, &name_type, &addr)) {
901 if (addr.ss_family != AF_INET) {
904 if (name_type != qname_type) {
907 if (memcmp(&((const struct sockaddr_in *)paddr)->sin_addr,
908 &((const struct sockaddr_in *)&addr)->sin_addr,
909 sizeof(struct in_addr)) == 0) {
910 fstrcpy(pname, name);
919 /****************************************************************************
920 Find the first type XX name in a node status reply - used for finding
921 a servers name given its IP. Return the matched name in *name.
922 **************************************************************************/
924 bool name_status_find(const char *q_name,
927 const struct sockaddr_storage *to_ss,
930 char addr[INET6_ADDRSTRLEN];
931 struct sockaddr_storage ss;
932 struct node_status *addrs = NULL;
933 struct nmb_name nname;
938 if (lp_disable_netbios()) {
939 DEBUG(5,("name_status_find(%s#%02x): netbios is disabled\n",
944 print_sockaddr(addr, sizeof(addr), to_ss);
946 DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name,
949 /* Check the cache first. */
951 if (namecache_status_fetch(q_name, q_type, type, to_ss, name)) {
955 if (to_ss->ss_family != AF_INET) {
956 /* Can't do node status to IPv6 */
960 result = name_status_lmhosts(to_ss, type, name);
962 DBG_DEBUG("Found name %s in lmhosts\n", name);
963 namecache_status_store(q_name, q_type, type, to_ss, name);
967 set_socket_addr_v4(&ss);
969 /* W2K PDC's seem not to respond to '*'#0. JRA */
970 make_nmb_name(&nname, q_name, q_type);
971 status = node_status_query(talloc_tos(), &nname, to_ss,
972 &addrs, &count, NULL);
973 if (!NT_STATUS_IS_OK(status)) {
977 for (i=0;i<count;i++) {
978 /* Find first one of the requested type that's not a GROUP. */
979 if (addrs[i].type == type && ! (addrs[i].flags & 0x80))
985 pull_ascii_nstring(name, sizeof(fstring), addrs[i].name);
987 /* Store the result in the cache. */
988 /* but don't store an entry for 0x1c names here. Here we have
989 a single host and DOMAIN<0x1c> names should be a list of hosts */
991 if ( q_type != 0x1c ) {
992 namecache_status_store(q_name, q_type, type, to_ss, name);
1000 DEBUG(10, ("name_status_find: name %sfound", result ? "" : "not "));
1003 DEBUGADD(10, (", name %s ip address is %s", name, addr));
1011 comparison function used by sort_addr_list
1014 static int addr_compare(const struct sockaddr_storage *ss1,
1015 const struct sockaddr_storage *ss2)
1017 int max_bits1=0, max_bits2=0;
1018 int num_interfaces = iface_count();
1021 /* Sort IPv4 addresses first. */
1022 if (ss1->ss_family != ss2->ss_family) {
1023 if (ss2->ss_family == AF_INET) {
1030 /* Here we know both addresses are of the same
1033 for (i=0;i<num_interfaces;i++) {
1034 const struct sockaddr_storage *pss = iface_n_bcast(i);
1035 const unsigned char *p_ss1 = NULL;
1036 const unsigned char *p_ss2 = NULL;
1037 const unsigned char *p_if = NULL;
1041 if (pss->ss_family != ss1->ss_family) {
1042 /* Ignore interfaces of the wrong type. */
1045 if (pss->ss_family == AF_INET) {
1046 p_if = (const unsigned char *)
1047 &((const struct sockaddr_in *)pss)->sin_addr;
1048 p_ss1 = (const unsigned char *)
1049 &((const struct sockaddr_in *)ss1)->sin_addr;
1050 p_ss2 = (const unsigned char *)
1051 &((const struct sockaddr_in *)ss2)->sin_addr;
1054 #if defined(HAVE_IPV6)
1055 if (pss->ss_family == AF_INET6) {
1056 p_if = (const unsigned char *)
1057 &((const struct sockaddr_in6 *)pss)->sin6_addr;
1058 p_ss1 = (const unsigned char *)
1059 &((const struct sockaddr_in6 *)ss1)->sin6_addr;
1060 p_ss2 = (const unsigned char *)
1061 &((const struct sockaddr_in6 *)ss2)->sin6_addr;
1065 if (!p_ss1 || !p_ss2 || !p_if || len == 0) {
1068 bits1 = matching_len_bits(p_ss1, p_if, len);
1069 bits2 = matching_len_bits(p_ss2, p_if, len);
1070 max_bits1 = MAX(bits1, max_bits1);
1071 max_bits2 = MAX(bits2, max_bits2);
1074 /* Bias towards directly reachable IPs */
1075 if (iface_local((const struct sockaddr *)ss1)) {
1076 if (ss1->ss_family == AF_INET) {
1082 if (iface_local((const struct sockaddr *)ss2)) {
1083 if (ss2->ss_family == AF_INET) {
1089 return max_bits2 - max_bits1;
1092 /*******************************************************************
1093 compare 2 ldap IPs by nearness to our interfaces - used in qsort
1094 *******************************************************************/
1096 static int ip_service_compare(struct ip_service *ss1, struct ip_service *ss2)
1100 if ((result = addr_compare(&ss1->ss, &ss2->ss)) != 0) {
1104 if (ss1->port > ss2->port) {
1108 if (ss1->port < ss2->port) {
1116 sort an IP list so that names that are close to one of our interfaces
1117 are at the top. This prevents the problem where a WINS server returns an IP
1118 that is not reachable from our subnet as the first match
1121 static void sort_addr_list(struct sockaddr_storage *sslist, int count)
1127 TYPESAFE_QSORT(sslist, count, addr_compare);
1130 static void sort_service_list(struct ip_service *servlist, int count)
1136 TYPESAFE_QSORT(servlist, count, ip_service_compare);
1139 /**********************************************************************
1140 Remove any duplicate address/port pairs in the list
1141 *********************************************************************/
1143 int remove_duplicate_addrs2(struct ip_service *iplist, int count )
1147 DEBUG(10,("remove_duplicate_addrs2: "
1148 "looking for duplicate address/port pairs\n"));
1150 /* One loop to set duplicates to a zero addr. */
1151 for ( i=0; i<count; i++ ) {
1152 if ( is_zero_addr(&iplist[i].ss)) {
1156 for ( j=i+1; j<count; j++ ) {
1157 if (sockaddr_equal((struct sockaddr *)(void *)&iplist[i].ss,
1158 (struct sockaddr *)(void *)&iplist[j].ss) &&
1159 iplist[i].port == iplist[j].port) {
1160 zero_sockaddr(&iplist[j].ss);
1165 /* Now remove any addresses set to zero above. */
1166 for (i = 0; i < count; i++) {
1168 is_zero_addr(&iplist[i].ss)) {
1172 (count-i-1)*sizeof(struct ip_service));
1181 static bool prioritize_ipv4_list(struct ip_service *iplist, int count)
1183 TALLOC_CTX *frame = talloc_stackframe();
1184 struct ip_service *iplist_new = talloc_array(frame, struct ip_service, count);
1187 if (iplist_new == NULL) {
1194 /* Copy IPv4 first. */
1195 for (i = 0; i < count; i++) {
1196 if (iplist[i].ss.ss_family == AF_INET) {
1197 iplist_new[j++] = iplist[i];
1202 for (i = 0; i < count; i++) {
1203 if (iplist[i].ss.ss_family != AF_INET) {
1204 iplist_new[j++] = iplist[i];
1208 memcpy(iplist, iplist_new, sizeof(struct ip_service)*count);
1213 /****************************************************************************
1214 Do a netbios name query to find someones IP.
1215 Returns an array of IP addresses or NULL if none.
1216 *count will be set to the number of addresses returned.
1217 *timed_out is set if we failed by timing out
1218 ****************************************************************************/
1220 struct name_query_state {
1221 struct sockaddr_storage my_addr;
1222 struct sockaddr_storage addr;
1229 NTSTATUS validate_error;
1232 struct sockaddr_storage *addrs;
1236 static bool name_query_validator(struct packet_struct *p, void *private_data);
1237 static void name_query_done(struct tevent_req *subreq);
1239 struct tevent_req *name_query_send(TALLOC_CTX *mem_ctx,
1240 struct tevent_context *ev,
1241 const char *name, int name_type,
1242 bool bcast, bool recurse,
1243 const struct sockaddr_storage *addr)
1245 struct tevent_req *req, *subreq;
1246 struct name_query_state *state;
1247 struct packet_struct p;
1248 struct nmb_packet *nmb = &p.packet.nmb;
1249 struct sockaddr_in *in_addr;
1251 req = tevent_req_create(mem_ctx, &state, struct name_query_state);
1255 state->bcast = bcast;
1257 if (addr->ss_family != AF_INET) {
1258 /* Can't do node status to IPv6 */
1259 tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
1260 return tevent_req_post(req, ev);
1263 if (lp_disable_netbios()) {
1264 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n",
1266 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
1267 return tevent_req_post(req, ev);
1270 state->addr = *addr;
1271 in_addr = (struct sockaddr_in *)(void *)&state->addr;
1272 in_addr->sin_port = htons(NMB_PORT);
1274 set_socket_addr_v4(&state->my_addr);
1277 nmb->header.name_trn_id = generate_trn_id();
1278 nmb->header.opcode = 0;
1279 nmb->header.response = false;
1280 nmb->header.nm_flags.bcast = bcast;
1281 nmb->header.nm_flags.recursion_available = false;
1282 nmb->header.nm_flags.recursion_desired = recurse;
1283 nmb->header.nm_flags.trunc = false;
1284 nmb->header.nm_flags.authoritative = false;
1285 nmb->header.rcode = 0;
1286 nmb->header.qdcount = 1;
1287 nmb->header.ancount = 0;
1288 nmb->header.nscount = 0;
1289 nmb->header.arcount = 0;
1291 make_nmb_name(&nmb->question.question_name,name,name_type);
1293 nmb->question.question_type = 0x20;
1294 nmb->question.question_class = 0x1;
1296 state->buflen = build_packet((char *)state->buf, sizeof(state->buf),
1298 if (state->buflen == 0) {
1299 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1300 DEBUG(10, ("build_packet failed\n"));
1301 return tevent_req_post(req, ev);
1304 subreq = nb_trans_send(state, ev, &state->my_addr, &state->addr, bcast,
1305 state->buf, state->buflen,
1306 NMB_PACKET, nmb->header.name_trn_id,
1307 name_query_validator, state);
1308 if (tevent_req_nomem(subreq, req)) {
1309 DEBUG(10, ("nb_trans_send failed\n"));
1310 return tevent_req_post(req, ev);
1312 tevent_req_set_callback(subreq, name_query_done, req);
1316 static bool name_query_validator(struct packet_struct *p, void *private_data)
1318 struct name_query_state *state = talloc_get_type_abort(
1319 private_data, struct name_query_state);
1320 struct nmb_packet *nmb = &p->packet.nmb;
1321 struct sockaddr_storage *tmp_addrs;
1322 bool got_unique_netbios_name = false;
1325 debug_nmb_packet(p);
1328 * If we get a Negative Name Query Response from a WINS
1329 * server, we should report it and give up.
1331 if( 0 == nmb->header.opcode /* A query response */
1332 && !state->bcast /* from a WINS server */
1333 && nmb->header.rcode /* Error returned */
1336 if( DEBUGLVL( 3 ) ) {
1337 /* Only executed if DEBUGLEVEL >= 3 */
1338 dbgtext( "Negative name query "
1339 "response, rcode 0x%02x: ",
1340 nmb->header.rcode );
1341 switch( nmb->header.rcode ) {
1343 dbgtext("Request was invalidly formatted.\n");
1346 dbgtext("Problem with NBNS, cannot process "
1350 dbgtext("The name requested does not "
1354 dbgtext("Unsupported request error.\n");
1357 dbgtext("Query refused error.\n");
1360 dbgtext("Unrecognized error code.\n" );
1366 * We accept this packet as valid, but tell the upper
1367 * layers that it's a negative response.
1369 state->validate_error = NT_STATUS_NOT_FOUND;
1373 if (nmb->header.opcode != 0 ||
1374 nmb->header.nm_flags.bcast ||
1375 nmb->header.rcode ||
1376 !nmb->header.ancount) {
1378 * XXXX what do we do with this? Could be a redirect,
1379 * but we'll discard it for the moment.
1384 tmp_addrs = talloc_realloc(
1385 state, state->addrs, struct sockaddr_storage,
1386 state->num_addrs + nmb->answers->rdlength/6);
1387 if (tmp_addrs == NULL) {
1388 state->validate_error = NT_STATUS_NO_MEMORY;
1391 state->addrs = tmp_addrs;
1393 DEBUG(2,("Got a positive name query response "
1394 "from %s ( ", inet_ntoa(p->ip)));
1396 for (i=0; i<nmb->answers->rdlength/6; i++) {
1399 struct sockaddr_storage addr;
1402 flags = RSVAL(&nmb->answers->rdata[i*6], 0);
1403 got_unique_netbios_name |= ((flags & 0x8000) == 0);
1405 putip((char *)&ip,&nmb->answers->rdata[2+i*6]);
1406 in_addr_to_sockaddr_storage(&addr, ip);
1408 if (is_zero_addr(&addr)) {
1412 for (j=0; j<state->num_addrs; j++) {
1414 (struct sockaddr *)(void *)&addr,
1415 (struct sockaddr *)(void *)&state->addrs[j])) {
1419 if (j < state->num_addrs) {
1420 /* Already got it */
1424 DEBUGADD(2,("%s ",inet_ntoa(ip)));
1426 state->addrs[state->num_addrs] = addr;
1427 state->num_addrs += 1;
1429 DEBUGADD(2,(")\n"));
1431 /* We add the flags back ... */
1432 if (nmb->header.response)
1433 state->flags |= NM_FLAGS_RS;
1434 if (nmb->header.nm_flags.authoritative)
1435 state->flags |= NM_FLAGS_AA;
1436 if (nmb->header.nm_flags.trunc)
1437 state->flags |= NM_FLAGS_TC;
1438 if (nmb->header.nm_flags.recursion_desired)
1439 state->flags |= NM_FLAGS_RD;
1440 if (nmb->header.nm_flags.recursion_available)
1441 state->flags |= NM_FLAGS_RA;
1442 if (nmb->header.nm_flags.bcast)
1443 state->flags |= NM_FLAGS_B;
1447 * We have to collect all entries coming in from broadcast
1448 * queries. If we got a unique name, we're done.
1450 return got_unique_netbios_name;
1453 * WINS responses are accepted when they are received
1458 static void name_query_done(struct tevent_req *subreq)
1460 struct tevent_req *req = tevent_req_callback_data(
1461 subreq, struct tevent_req);
1462 struct name_query_state *state = tevent_req_data(
1463 req, struct name_query_state);
1465 struct packet_struct *p = NULL;
1467 status = nb_trans_recv(subreq, state, &p);
1468 TALLOC_FREE(subreq);
1469 if (tevent_req_nterror(req, status)) {
1472 if (!NT_STATUS_IS_OK(state->validate_error)) {
1473 tevent_req_nterror(req, state->validate_error);
1476 tevent_req_done(req);
1479 NTSTATUS name_query_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1480 struct sockaddr_storage **addrs, int *num_addrs,
1483 struct name_query_state *state = tevent_req_data(
1484 req, struct name_query_state);
1487 if (tevent_req_is_nterror(req, &status)) {
1489 NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
1491 * In the broadcast case we collect replies until the
1494 status = NT_STATUS_OK;
1496 if (!NT_STATUS_IS_OK(status)) {
1500 if (state->num_addrs == 0) {
1501 return NT_STATUS_NOT_FOUND;
1503 *addrs = talloc_move(mem_ctx, &state->addrs);
1504 sort_addr_list(*addrs, state->num_addrs);
1505 *num_addrs = state->num_addrs;
1506 if (flags != NULL) {
1507 *flags = state->flags;
1509 return NT_STATUS_OK;
1512 NTSTATUS name_query(const char *name, int name_type,
1513 bool bcast, bool recurse,
1514 const struct sockaddr_storage *to_ss,
1515 TALLOC_CTX *mem_ctx,
1516 struct sockaddr_storage **addrs,
1517 int *num_addrs, uint8_t *flags)
1519 TALLOC_CTX *frame = talloc_stackframe();
1520 struct tevent_context *ev;
1521 struct tevent_req *req;
1522 struct timeval timeout;
1523 NTSTATUS status = NT_STATUS_NO_MEMORY;
1525 ev = samba_tevent_context_init(frame);
1529 req = name_query_send(ev, ev, name, name_type, bcast, recurse, to_ss);
1534 timeout = timeval_current_ofs(0, 250000);
1536 timeout = timeval_current_ofs(2, 0);
1538 if (!tevent_req_set_endtime(req, ev, timeout)) {
1541 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1544 status = name_query_recv(req, mem_ctx, addrs, num_addrs, flags);
1550 /********************************************************
1551 Convert an array if struct sockaddr_storage to struct ip_service
1552 return false on failure. Port is set to PORT_NONE;
1553 pcount is [in/out] - it is the length of ss_list on input,
1554 and the length of return_iplist on output as we remove any
1555 zero addresses from ss_list.
1556 *********************************************************/
1558 static bool convert_ss2service(struct ip_service **return_iplist,
1559 const struct sockaddr_storage *ss_list,
1563 int orig_count = *pcount;
1566 if (orig_count==0 || !ss_list )
1569 /* Filter out zero addrs. */
1570 for ( i=0; i<orig_count; i++ ) {
1571 if (is_zero_addr(&ss_list[i])) {
1576 if (real_count==0) {
1580 /* copy the ip address; port will be PORT_NONE */
1581 if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, real_count)) ==
1583 DEBUG(0,("convert_ip2service: malloc failed "
1584 "for %d enetries!\n", real_count ));
1588 for ( i=0, real_count = 0; i<orig_count; i++ ) {
1589 if (is_zero_addr(&ss_list[i])) {
1592 (*return_iplist)[real_count].ss = ss_list[i];
1593 (*return_iplist)[real_count].port = PORT_NONE;
1597 *pcount = real_count;
1601 struct name_queries_state {
1602 struct tevent_context *ev;
1607 const struct sockaddr_storage *addrs;
1612 struct tevent_req **subreqs;
1617 struct sockaddr_storage *result_addrs;
1618 int num_result_addrs;
1622 static void name_queries_done(struct tevent_req *subreq);
1623 static void name_queries_next(struct tevent_req *subreq);
1626 * Send a name query to multiple destinations with a wait time in between
1629 static struct tevent_req *name_queries_send(
1630 TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1631 const char *name, int name_type,
1632 bool bcast, bool recurse,
1633 const struct sockaddr_storage *addrs,
1634 int num_addrs, int wait_msec, int timeout_msec)
1636 struct tevent_req *req, *subreq;
1637 struct name_queries_state *state;
1639 req = tevent_req_create(mem_ctx, &state,
1640 struct name_queries_state);
1646 state->name_type = name_type;
1647 state->bcast = bcast;
1648 state->recurse = recurse;
1649 state->addrs = addrs;
1650 state->num_addrs = num_addrs;
1651 state->wait_msec = wait_msec;
1652 state->timeout_msec = timeout_msec;
1654 state->subreqs = talloc_zero_array(
1655 state, struct tevent_req *, num_addrs);
1656 if (tevent_req_nomem(state->subreqs, req)) {
1657 return tevent_req_post(req, ev);
1659 state->num_sent = 0;
1661 subreq = name_query_send(
1662 state->subreqs, state->ev, name, name_type, bcast, recurse,
1663 &state->addrs[state->num_sent]);
1664 if (tevent_req_nomem(subreq, req)) {
1665 return tevent_req_post(req, ev);
1667 if (!tevent_req_set_endtime(
1669 timeval_current_ofs(0, state->timeout_msec * 1000))) {
1670 return tevent_req_post(req, ev);
1672 tevent_req_set_callback(subreq, name_queries_done, req);
1674 state->subreqs[state->num_sent] = subreq;
1675 state->num_sent += 1;
1677 if (state->num_sent < state->num_addrs) {
1678 subreq = tevent_wakeup_send(
1680 timeval_current_ofs(0, state->wait_msec * 1000));
1681 if (tevent_req_nomem(subreq, req)) {
1682 return tevent_req_post(req, ev);
1684 tevent_req_set_callback(subreq, name_queries_next, req);
1689 static void name_queries_done(struct tevent_req *subreq)
1691 struct tevent_req *req = tevent_req_callback_data(
1692 subreq, struct tevent_req);
1693 struct name_queries_state *state = tevent_req_data(
1694 req, struct name_queries_state);
1698 status = name_query_recv(subreq, state, &state->result_addrs,
1699 &state->num_result_addrs, &state->flags);
1701 for (i=0; i<state->num_sent; i++) {
1702 if (state->subreqs[i] == subreq) {
1706 if (i == state->num_sent) {
1707 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1710 TALLOC_FREE(state->subreqs[i]);
1712 state->num_received += 1;
1714 if (!NT_STATUS_IS_OK(status)) {
1716 if (state->num_received >= state->num_addrs) {
1717 tevent_req_nterror(req, status);
1721 * Still outstanding requests, just wait
1725 state->received_index = i;
1726 tevent_req_done(req);
1729 static void name_queries_next(struct tevent_req *subreq)
1731 struct tevent_req *req = tevent_req_callback_data(
1732 subreq, struct tevent_req);
1733 struct name_queries_state *state = tevent_req_data(
1734 req, struct name_queries_state);
1736 if (!tevent_wakeup_recv(subreq)) {
1737 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1741 subreq = name_query_send(
1742 state->subreqs, state->ev,
1743 state->name, state->name_type, state->bcast, state->recurse,
1744 &state->addrs[state->num_sent]);
1745 if (tevent_req_nomem(subreq, req)) {
1748 tevent_req_set_callback(subreq, name_queries_done, req);
1749 if (!tevent_req_set_endtime(
1751 timeval_current_ofs(0, state->timeout_msec * 1000))) {
1754 state->subreqs[state->num_sent] = subreq;
1755 state->num_sent += 1;
1757 if (state->num_sent < state->num_addrs) {
1758 subreq = tevent_wakeup_send(
1760 timeval_current_ofs(0, state->wait_msec * 1000));
1761 if (tevent_req_nomem(subreq, req)) {
1764 tevent_req_set_callback(subreq, name_queries_next, req);
1768 static NTSTATUS name_queries_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1769 struct sockaddr_storage **result_addrs,
1770 int *num_result_addrs, uint8_t *flags,
1771 int *received_index)
1773 struct name_queries_state *state = tevent_req_data(
1774 req, struct name_queries_state);
1777 if (tevent_req_is_nterror(req, &status)) {
1781 if (result_addrs != NULL) {
1782 *result_addrs = talloc_move(mem_ctx, &state->result_addrs);
1784 if (num_result_addrs != NULL) {
1785 *num_result_addrs = state->num_result_addrs;
1787 if (flags != NULL) {
1788 *flags = state->flags;
1790 if (received_index != NULL) {
1791 *received_index = state->received_index;
1793 return NT_STATUS_OK;
1796 /********************************************************
1797 Resolve via "bcast" method.
1798 *********************************************************/
1800 struct name_resolve_bcast_state {
1801 struct sockaddr_storage *addrs;
1805 static void name_resolve_bcast_done(struct tevent_req *subreq);
1807 struct tevent_req *name_resolve_bcast_send(TALLOC_CTX *mem_ctx,
1808 struct tevent_context *ev,
1812 struct tevent_req *req, *subreq;
1813 struct name_resolve_bcast_state *state;
1814 struct sockaddr_storage *bcast_addrs;
1815 int i, num_addrs, num_bcast_addrs;
1817 req = tevent_req_create(mem_ctx, &state,
1818 struct name_resolve_bcast_state);
1823 if (lp_disable_netbios()) {
1824 DEBUG(5, ("name_resolve_bcast(%s#%02x): netbios is disabled\n",
1826 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
1827 return tevent_req_post(req, ev);
1831 * "bcast" means do a broadcast lookup on all the local interfaces.
1834 DEBUG(3, ("name_resolve_bcast: Attempting broadcast lookup "
1835 "for name %s<0x%x>\n", name, name_type));
1837 num_addrs = iface_count();
1838 bcast_addrs = talloc_array(state, struct sockaddr_storage, num_addrs);
1839 if (tevent_req_nomem(bcast_addrs, req)) {
1840 return tevent_req_post(req, ev);
1844 * Lookup the name on all the interfaces, return on
1845 * the first successful match.
1847 num_bcast_addrs = 0;
1849 for (i=0; i<num_addrs; i++) {
1850 const struct sockaddr_storage *pss = iface_n_bcast(i);
1852 if (pss->ss_family != AF_INET) {
1855 bcast_addrs[num_bcast_addrs] = *pss;
1856 num_bcast_addrs += 1;
1859 subreq = name_queries_send(state, ev, name, name_type, true, true,
1860 bcast_addrs, num_bcast_addrs, 0, 1000);
1861 if (tevent_req_nomem(subreq, req)) {
1862 return tevent_req_post(req, ev);
1864 tevent_req_set_callback(subreq, name_resolve_bcast_done, req);
1868 static void name_resolve_bcast_done(struct tevent_req *subreq)
1870 struct tevent_req *req = tevent_req_callback_data(
1871 subreq, struct tevent_req);
1872 struct name_resolve_bcast_state *state = tevent_req_data(
1873 req, struct name_resolve_bcast_state);
1876 status = name_queries_recv(subreq, state,
1877 &state->addrs, &state->num_addrs,
1879 TALLOC_FREE(subreq);
1880 if (tevent_req_nterror(req, status)) {
1883 tevent_req_done(req);
1886 NTSTATUS name_resolve_bcast_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1887 struct sockaddr_storage **addrs,
1890 struct name_resolve_bcast_state *state = tevent_req_data(
1891 req, struct name_resolve_bcast_state);
1894 if (tevent_req_is_nterror(req, &status)) {
1897 *addrs = talloc_move(mem_ctx, &state->addrs);
1898 *num_addrs = state->num_addrs;
1899 return NT_STATUS_OK;
1902 NTSTATUS name_resolve_bcast(const char *name,
1904 TALLOC_CTX *mem_ctx,
1905 struct sockaddr_storage **return_iplist,
1908 TALLOC_CTX *frame = talloc_stackframe();
1909 struct tevent_context *ev;
1910 struct tevent_req *req;
1911 NTSTATUS status = NT_STATUS_NO_MEMORY;
1913 ev = samba_tevent_context_init(frame);
1917 req = name_resolve_bcast_send(frame, ev, name, name_type);
1921 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1924 status = name_resolve_bcast_recv(req, mem_ctx, return_iplist,
1931 struct query_wins_list_state {
1932 struct tevent_context *ev;
1935 struct in_addr *servers;
1936 uint32_t num_servers;
1937 struct sockaddr_storage server;
1940 struct sockaddr_storage *addrs;
1945 static void query_wins_list_done(struct tevent_req *subreq);
1948 * Query a list of (replicating) wins servers in sequence, call them
1949 * dead if they don't reply
1952 static struct tevent_req *query_wins_list_send(
1953 TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1954 struct in_addr src_ip, const char *name, uint8_t name_type,
1955 struct in_addr *servers, int num_servers)
1957 struct tevent_req *req, *subreq;
1958 struct query_wins_list_state *state;
1960 req = tevent_req_create(mem_ctx, &state,
1961 struct query_wins_list_state);
1967 state->name_type = name_type;
1968 state->servers = servers;
1969 state->num_servers = num_servers;
1971 if (state->num_servers == 0) {
1972 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
1973 return tevent_req_post(req, ev);
1976 in_addr_to_sockaddr_storage(
1977 &state->server, state->servers[state->num_sent]);
1979 subreq = name_query_send(state, state->ev,
1980 state->name, state->name_type,
1981 false, true, &state->server);
1982 state->num_sent += 1;
1983 if (tevent_req_nomem(subreq, req)) {
1984 return tevent_req_post(req, ev);
1986 if (!tevent_req_set_endtime(subreq, state->ev,
1987 timeval_current_ofs(2, 0))) {
1988 return tevent_req_post(req, ev);
1990 tevent_req_set_callback(subreq, query_wins_list_done, req);
1994 static void query_wins_list_done(struct tevent_req *subreq)
1996 struct tevent_req *req = tevent_req_callback_data(
1997 subreq, struct tevent_req);
1998 struct query_wins_list_state *state = tevent_req_data(
1999 req, struct query_wins_list_state);
2002 status = name_query_recv(subreq, state,
2003 &state->addrs, &state->num_addrs,
2005 TALLOC_FREE(subreq);
2006 if (NT_STATUS_IS_OK(status)) {
2007 tevent_req_done(req);
2010 if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
2011 tevent_req_nterror(req, status);
2014 wins_srv_died(state->servers[state->num_sent-1],
2015 my_socket_addr_v4());
2017 if (state->num_sent == state->num_servers) {
2018 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
2022 in_addr_to_sockaddr_storage(
2023 &state->server, state->servers[state->num_sent]);
2025 subreq = name_query_send(state, state->ev,
2026 state->name, state->name_type,
2027 false, true, &state->server);
2028 state->num_sent += 1;
2029 if (tevent_req_nomem(subreq, req)) {
2032 if (!tevent_req_set_endtime(subreq, state->ev,
2033 timeval_current_ofs(2, 0))) {
2036 tevent_req_set_callback(subreq, query_wins_list_done, req);
2039 static NTSTATUS query_wins_list_recv(struct tevent_req *req,
2040 TALLOC_CTX *mem_ctx,
2041 struct sockaddr_storage **addrs,
2045 struct query_wins_list_state *state = tevent_req_data(
2046 req, struct query_wins_list_state);
2049 if (tevent_req_is_nterror(req, &status)) {
2052 if (addrs != NULL) {
2053 *addrs = talloc_move(mem_ctx, &state->addrs);
2055 if (num_addrs != NULL) {
2056 *num_addrs = state->num_addrs;
2058 if (flags != NULL) {
2059 *flags = state->flags;
2061 return NT_STATUS_OK;
2064 struct resolve_wins_state {
2068 struct sockaddr_storage *addrs;
2073 static void resolve_wins_done(struct tevent_req *subreq);
2075 struct tevent_req *resolve_wins_send(TALLOC_CTX *mem_ctx,
2076 struct tevent_context *ev,
2080 struct tevent_req *req, *subreq;
2081 struct resolve_wins_state *state;
2082 char **wins_tags = NULL;
2083 struct sockaddr_storage src_ss;
2084 struct in_addr src_ip;
2085 int i, num_wins_tags;
2087 req = tevent_req_create(mem_ctx, &state,
2088 struct resolve_wins_state);
2093 if (wins_srv_count() < 1) {
2094 DEBUG(3,("resolve_wins: WINS server resolution selected "
2095 "and no WINS servers listed.\n"));
2096 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2100 /* the address we will be sending from */
2101 if (!interpret_string_addr(&src_ss, lp_nbt_client_socket_address(),
2102 AI_NUMERICHOST|AI_PASSIVE)) {
2103 zero_sockaddr(&src_ss);
2106 if (src_ss.ss_family != AF_INET) {
2107 char addr[INET6_ADDRSTRLEN];
2108 print_sockaddr(addr, sizeof(addr), &src_ss);
2109 DEBUG(3,("resolve_wins: cannot receive WINS replies "
2110 "on IPv6 address %s\n",
2112 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2116 src_ip = ((const struct sockaddr_in *)(void *)&src_ss)->sin_addr;
2118 wins_tags = wins_srv_tags();
2119 if (wins_tags == NULL) {
2120 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2125 while (wins_tags[num_wins_tags] != NULL) {
2129 for (i=0; i<num_wins_tags; i++) {
2130 int num_servers, num_alive;
2131 struct in_addr *servers, *alive;
2134 if (!wins_server_tag_ips(wins_tags[i], talloc_tos(),
2135 &servers, &num_servers)) {
2136 DEBUG(10, ("wins_server_tag_ips failed for tag %s\n",
2141 alive = talloc_array(state, struct in_addr, num_servers);
2142 if (tevent_req_nomem(alive, req)) {
2147 for (j=0; j<num_servers; j++) {
2148 struct in_addr wins_ip = servers[j];
2150 if (global_in_nmbd && ismyip_v4(wins_ip)) {
2151 /* yikes! we'll loop forever */
2154 /* skip any that have been unresponsive lately */
2155 if (wins_srv_is_dead(wins_ip, src_ip)) {
2158 DEBUG(3, ("resolve_wins: using WINS server %s "
2160 inet_ntoa(wins_ip), wins_tags[i]));
2161 alive[num_alive] = wins_ip;
2164 TALLOC_FREE(servers);
2166 if (num_alive == 0) {
2170 subreq = query_wins_list_send(
2171 state, ev, src_ip, name, name_type,
2173 if (tevent_req_nomem(subreq, req)) {
2176 tevent_req_set_callback(subreq, resolve_wins_done, req);
2177 state->num_sent += 1;
2180 if (state->num_sent == 0) {
2181 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
2185 wins_srv_tags_free(wins_tags);
2188 wins_srv_tags_free(wins_tags);
2189 return tevent_req_post(req, ev);
2192 static void resolve_wins_done(struct tevent_req *subreq)
2194 struct tevent_req *req = tevent_req_callback_data(
2195 subreq, struct tevent_req);
2196 struct resolve_wins_state *state = tevent_req_data(
2197 req, struct resolve_wins_state);
2200 status = query_wins_list_recv(subreq, state, &state->addrs,
2201 &state->num_addrs, &state->flags);
2202 if (NT_STATUS_IS_OK(status)) {
2203 tevent_req_done(req);
2207 state->num_received += 1;
2209 if (state->num_received < state->num_sent) {
2211 * Wait for the others
2215 tevent_req_nterror(req, status);
2218 NTSTATUS resolve_wins_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
2219 struct sockaddr_storage **addrs,
2220 int *num_addrs, uint8_t *flags)
2222 struct resolve_wins_state *state = tevent_req_data(
2223 req, struct resolve_wins_state);
2226 if (tevent_req_is_nterror(req, &status)) {
2229 if (addrs != NULL) {
2230 *addrs = talloc_move(mem_ctx, &state->addrs);
2232 if (num_addrs != NULL) {
2233 *num_addrs = state->num_addrs;
2235 if (flags != NULL) {
2236 *flags = state->flags;
2238 return NT_STATUS_OK;
2241 /********************************************************
2242 Resolve via "wins" method.
2243 *********************************************************/
2245 NTSTATUS resolve_wins(const char *name,
2247 TALLOC_CTX *mem_ctx,
2248 struct sockaddr_storage **return_iplist,
2251 struct tevent_context *ev;
2252 struct tevent_req *req;
2253 NTSTATUS status = NT_STATUS_NO_MEMORY;
2255 ev = samba_tevent_context_init(talloc_tos());
2259 req = resolve_wins_send(ev, ev, name, name_type);
2263 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2266 status = resolve_wins_recv(req, mem_ctx, return_iplist, return_count,
2273 /********************************************************
2274 Resolve via "hosts" method.
2275 *********************************************************/
2277 static NTSTATUS resolve_hosts(const char *name, int name_type,
2278 TALLOC_CTX *mem_ctx,
2279 struct sockaddr_storage **return_iplist,
2283 * "host" means do a localhost, or dns lookup.
2285 struct addrinfo hints;
2286 struct addrinfo *ailist = NULL;
2287 struct addrinfo *res = NULL;
2291 if ( name_type != 0x20 && name_type != 0x0) {
2292 DEBUG(5, ("resolve_hosts: not appropriate "
2293 "for name type <0x%x>\n",
2295 return NT_STATUS_INVALID_PARAMETER;
2298 *return_iplist = NULL;
2301 DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n",
2305 /* By default make sure it supports TCP. */
2306 hints.ai_socktype = SOCK_STREAM;
2307 hints.ai_flags = AI_ADDRCONFIG;
2309 #if !defined(HAVE_IPV6)
2310 /* Unless we have IPv6, we really only want IPv4 addresses back. */
2311 hints.ai_family = AF_INET;
2314 ret = getaddrinfo(name,
2319 DEBUG(3,("resolve_hosts: getaddrinfo failed for name %s [%s]\n",
2321 gai_strerror(ret) ));
2324 for (res = ailist; res; res = res->ai_next) {
2325 struct sockaddr_storage ss;
2327 if (!res->ai_addr || res->ai_addrlen == 0) {
2332 memcpy(&ss, res->ai_addr, res->ai_addrlen);
2334 if (is_zero_addr(&ss)) {
2340 *return_iplist = talloc_realloc(
2341 mem_ctx, *return_iplist, struct sockaddr_storage,
2343 if (!*return_iplist) {
2344 DEBUG(3,("resolve_hosts: malloc fail !\n"));
2345 freeaddrinfo(ailist);
2346 return NT_STATUS_NO_MEMORY;
2348 (*return_iplist)[i] = ss;
2352 freeaddrinfo(ailist);
2354 if (*return_count) {
2355 return NT_STATUS_OK;
2357 return NT_STATUS_UNSUCCESSFUL;
2360 /********************************************************
2361 Resolve via "ADS" method.
2362 *********************************************************/
2364 /* Special name type used to cause a _kerberos DNS lookup. */
2365 #define KDC_NAME_TYPE 0xDCDC
2367 static NTSTATUS resolve_ads(const char *name,
2369 const char *sitename,
2370 struct ip_service **return_iplist,
2376 struct dns_rr_srv *dcs = NULL;
2380 if ((name_type != 0x1c) && (name_type != KDC_NAME_TYPE) &&
2381 (name_type != 0x1b)) {
2382 return NT_STATUS_INVALID_PARAMETER;
2385 if ( (ctx = talloc_init("resolve_ads")) == NULL ) {
2386 DEBUG(0,("resolve_ads: talloc_init() failed!\n"));
2387 return NT_STATUS_NO_MEMORY;
2390 /* The DNS code needs fixing to find IPv6 addresses... JRA. */
2391 switch (name_type) {
2393 DEBUG(5,("resolve_ads: Attempting to resolve "
2394 "PDC for %s using DNS\n", name));
2395 status = ads_dns_query_pdc(ctx,
2402 DEBUG(5,("resolve_ads: Attempting to resolve "
2403 "DCs for %s using DNS\n", name));
2404 status = ads_dns_query_dcs(ctx,
2411 DEBUG(5,("resolve_ads: Attempting to resolve "
2412 "KDCs for %s using DNS\n", name));
2413 status = ads_dns_query_kdcs(ctx,
2420 status = NT_STATUS_INVALID_PARAMETER;
2424 if ( !NT_STATUS_IS_OK( status ) ) {
2425 talloc_destroy(ctx);
2430 *return_iplist = NULL;
2432 talloc_destroy(ctx);
2433 return NT_STATUS_OK;
2436 for (i=0;i<numdcs;i++) {
2440 numaddrs += dcs[i].num_ips;
2444 if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, numaddrs)) ==
2446 DEBUG(0,("resolve_ads: malloc failed for %d entries\n",
2448 talloc_destroy(ctx);
2449 return NT_STATUS_NO_MEMORY;
2452 /* now unroll the list of IP addresses */
2456 for (i = 0; i < numdcs && (*return_count<numaddrs); i++ ) {
2457 /* If we don't have an IP list for a name, lookup it up */
2459 /* We need to get all IP addresses here. */
2460 struct addrinfo *res = NULL;
2462 int extra_addrs = 0;
2464 if (!interpret_string_addr_internal(&res,
2469 /* Add in every IP from the lookup. How
2471 for (p = res; p; p = p->ai_next) {
2472 struct sockaddr_storage ss;
2473 memcpy(&ss, p->ai_addr, p->ai_addrlen);
2474 if (is_zero_addr(&ss)) {
2479 if (extra_addrs > 1) {
2480 /* We need to expand the return_iplist array
2481 as we only budgeted for one address. */
2482 numaddrs += (extra_addrs-1);
2483 *return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
2486 if (*return_iplist == NULL) {
2490 talloc_destroy(ctx);
2491 return NT_STATUS_NO_MEMORY;
2494 for (p = res; p; p = p->ai_next) {
2495 (*return_iplist)[*return_count].port = dcs[i].port;
2496 memcpy(&(*return_iplist)[*return_count].ss,
2499 if (is_zero_addr(&(*return_iplist)[*return_count].ss)) {
2503 /* Should never happen, but still... */
2504 if (*return_count>=numaddrs) {
2512 /* use all the IP addresses from the SRV response */
2514 for (j = 0; j < dcs[i].num_ips; j++) {
2515 (*return_iplist)[*return_count].port = dcs[i].port;
2516 (*return_iplist)[*return_count].ss = dcs[i].ss_s[j];
2517 if (is_zero_addr(&(*return_iplist)[*return_count].ss)) {
2521 /* Should never happen, but still... */
2522 if (*return_count>=numaddrs) {
2529 talloc_destroy(ctx);
2530 return NT_STATUS_OK;
2533 static const char **filter_out_nbt_lookup(TALLOC_CTX *mem_ctx,
2534 const char **resolve_order)
2536 size_t i, len, result_idx;
2537 const char **result;
2540 while (resolve_order[len] != NULL) {
2544 result = talloc_array(mem_ctx, const char *, len+1);
2545 if (result == NULL) {
2551 for (i=0; i<len; i++) {
2552 const char *tok = resolve_order[i];
2554 if (strequal(tok, "lmhosts") || strequal(tok, "wins") ||
2555 strequal(tok, "bcast")) {
2558 result[result_idx++] = tok;
2560 result[result_idx] = NULL;
2565 /*******************************************************************
2566 Internal interface to resolve a name into an IP address.
2567 Use this function if the string is either an IP address, DNS
2568 or host name or NetBIOS name. This uses the name switch in the
2569 smb.conf to determine the order of name resolution.
2571 Added support for ip addr/port to support ADS ldap servers.
2572 the only place we currently care about the port is in the
2573 resolve_hosts() when looking up DC's via SRV RR entries in DNS
2574 **********************************************************************/
2576 NTSTATUS internal_resolve_name(const char *name,
2578 const char *sitename,
2579 struct ip_service **return_iplist,
2581 const char **resolve_order)
2584 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2586 TALLOC_CTX *frame = NULL;
2588 *return_iplist = NULL;
2591 DEBUG(10, ("internal_resolve_name: looking up %s#%x (sitename %s)\n",
2592 name, name_type, sitename ? sitename : "(null)"));
2594 if (is_ipaddress(name)) {
2595 if ((*return_iplist = SMB_MALLOC_P(struct ip_service)) ==
2597 DEBUG(0,("internal_resolve_name: malloc fail !\n"));
2598 return NT_STATUS_NO_MEMORY;
2601 /* ignore the port here */
2602 (*return_iplist)->port = PORT_NONE;
2604 /* if it's in the form of an IP address then get the lib to interpret it */
2605 if (!interpret_string_addr(&(*return_iplist)->ss,
2606 name, AI_NUMERICHOST)) {
2607 DEBUG(1,("internal_resolve_name: interpret_string_addr "
2610 SAFE_FREE(*return_iplist);
2611 return NT_STATUS_INVALID_PARAMETER;
2613 if (is_zero_addr(&(*return_iplist)->ss)) {
2614 SAFE_FREE(*return_iplist);
2615 return NT_STATUS_UNSUCCESSFUL;
2618 return NT_STATUS_OK;
2621 /* Check name cache */
2623 if (namecache_fetch(name, name_type, return_iplist, return_count)) {
2624 *return_count = remove_duplicate_addrs2(*return_iplist,
2626 /* This could be a negative response */
2627 if (*return_count > 0) {
2628 return NT_STATUS_OK;
2630 return NT_STATUS_UNSUCCESSFUL;
2634 /* set the name resolution order */
2636 if (resolve_order && strcmp(resolve_order[0], "NULL") == 0) {
2637 DEBUG(8,("internal_resolve_name: all lookups disabled\n"));
2638 return NT_STATUS_INVALID_PARAMETER;
2641 if (!resolve_order || !resolve_order[0]) {
2642 static const char *host_order[] = { "host", NULL };
2643 resolve_order = host_order;
2646 frame = talloc_stackframe();
2648 if ((strlen(name) > MAX_NETBIOSNAME_LEN - 1) ||
2649 (strchr(name, '.') != NULL)) {
2651 * Don't do NBT lookup, the name would not fit anyway
2653 resolve_order = filter_out_nbt_lookup(frame, resolve_order);
2654 if (resolve_order == NULL) {
2656 return NT_STATUS_NO_MEMORY;
2660 /* iterate through the name resolution backends */
2662 for (i=0; resolve_order[i]; i++) {
2663 tok = resolve_order[i];
2665 if((strequal(tok, "host") || strequal(tok, "hosts"))) {
2666 struct sockaddr_storage *ss_list;
2667 status = resolve_hosts(name, name_type,
2668 talloc_tos(), &ss_list,
2670 if (NT_STATUS_IS_OK(status)) {
2671 if (!convert_ss2service(return_iplist,
2674 status = NT_STATUS_NO_MEMORY;
2678 } else if(strequal( tok, "kdc")) {
2679 /* deal with KDC_NAME_TYPE names here.
2680 * This will result in a SRV record lookup */
2681 status = resolve_ads(name, KDC_NAME_TYPE, sitename,
2682 return_iplist, return_count);
2683 if (NT_STATUS_IS_OK(status)) {
2684 /* Ensure we don't namecache
2685 * this with the KDC port. */
2686 name_type = KDC_NAME_TYPE;
2689 } else if(strequal( tok, "ads")) {
2690 /* deal with 0x1c and 0x1b names here.
2691 * This will result in a SRV record lookup */
2692 status = resolve_ads(name, name_type, sitename,
2693 return_iplist, return_count);
2694 if (NT_STATUS_IS_OK(status)) {
2697 } else if (strequal(tok, "lmhosts")) {
2698 struct sockaddr_storage *ss_list;
2699 status = resolve_lmhosts_file_as_sockaddr(
2700 get_dyn_LMHOSTSFILE(), name, name_type,
2701 talloc_tos(), &ss_list, return_count);
2702 if (NT_STATUS_IS_OK(status)) {
2703 if (!convert_ss2service(return_iplist,
2706 status = NT_STATUS_NO_MEMORY;
2710 } else if (strequal(tok, "wins")) {
2711 /* don't resolve 1D via WINS */
2712 struct sockaddr_storage *ss_list;
2713 if (name_type != 0x1D) {
2714 status = resolve_wins(name, name_type,
2718 if (NT_STATUS_IS_OK(status)) {
2719 if (!convert_ss2service(return_iplist,
2722 status = NT_STATUS_NO_MEMORY;
2727 } else if (strequal(tok, "bcast")) {
2728 struct sockaddr_storage *ss_list;
2729 status = name_resolve_bcast(
2730 name, name_type, talloc_tos(),
2731 &ss_list, return_count);
2732 if (NT_STATUS_IS_OK(status)) {
2733 if (!convert_ss2service(return_iplist,
2736 status = NT_STATUS_NO_MEMORY;
2741 DEBUG(0,("resolve_name: unknown name switch type %s\n",
2746 /* All of the resolve_* functions above have returned false. */
2749 SAFE_FREE(*return_iplist);
2752 return NT_STATUS_UNSUCCESSFUL;
2756 /* Remove duplicate entries. Some queries, notably #1c (domain
2757 controllers) return the PDC in iplist[0] and then all domain
2758 controllers including the PDC in iplist[1..n]. Iterating over
2759 the iplist when the PDC is down will cause two sets of timeouts. */
2761 *return_count = remove_duplicate_addrs2(*return_iplist, *return_count );
2763 /* Save in name cache */
2764 if ( DEBUGLEVEL >= 100 ) {
2765 for (i = 0; i < *return_count && DEBUGLEVEL == 100; i++) {
2766 char addr[INET6_ADDRSTRLEN];
2767 print_sockaddr(addr, sizeof(addr),
2768 &(*return_iplist)[i].ss);
2769 DEBUG(100, ("Storing name %s of type %d (%s:%d)\n",
2773 (*return_iplist)[i].port));
2777 if (*return_count) {
2778 namecache_store(name, name_type, *return_count, *return_iplist);
2781 /* Display some debugging info */
2783 if ( DEBUGLEVEL >= 10 ) {
2784 DEBUG(10, ("internal_resolve_name: returning %d addresses: ",
2787 for (i = 0; i < *return_count; i++) {
2788 char addr[INET6_ADDRSTRLEN];
2789 print_sockaddr(addr, sizeof(addr),
2790 &(*return_iplist)[i].ss);
2791 DEBUGADD(10, ("%s:%d ",
2793 (*return_iplist)[i].port));
2802 /********************************************************
2803 Internal interface to resolve a name into one IP address.
2804 Use this function if the string is either an IP address, DNS
2805 or host name or NetBIOS name. This uses the name switch in the
2806 smb.conf to determine the order of name resolution.
2807 *********************************************************/
2809 bool resolve_name(const char *name,
2810 struct sockaddr_storage *return_ss,
2814 struct ip_service *ss_list = NULL;
2815 char *sitename = NULL;
2818 TALLOC_CTX *frame = NULL;
2820 if (is_ipaddress(name)) {
2821 return interpret_string_addr(return_ss, name, AI_NUMERICHOST);
2824 frame = talloc_stackframe();
2826 sitename = sitename_fetch(frame, lp_realm()); /* wild guess */
2828 status = internal_resolve_name(name, name_type, sitename,
2830 lp_name_resolve_order());
2831 if (NT_STATUS_IS_OK(status)) {
2835 for (i=0; i<count; i++) {
2836 if (!is_zero_addr(&ss_list[i].ss) &&
2837 !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss) &&
2838 (ss_list[i].ss.ss_family == AF_INET)) {
2839 *return_ss = ss_list[i].ss;
2847 /* only return valid addresses for TCP connections */
2848 for (i=0; i<count; i++) {
2849 if (!is_zero_addr(&ss_list[i].ss) &&
2850 !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
2851 *return_ss = ss_list[i].ss;
2864 /********************************************************
2865 Internal interface to resolve a name into a list of IP addresses.
2866 Use this function if the string is either an IP address, DNS
2867 or host name or NetBIOS name. This uses the name switch in the
2868 smb.conf to determine the order of name resolution.
2869 *********************************************************/
2871 NTSTATUS resolve_name_list(TALLOC_CTX *ctx,
2874 struct sockaddr_storage **return_ss_arr,
2875 unsigned int *p_num_entries)
2877 struct ip_service *ss_list = NULL;
2878 char *sitename = NULL;
2881 unsigned int num_entries;
2885 *return_ss_arr = NULL;
2887 if (is_ipaddress(name)) {
2888 *return_ss_arr = talloc(ctx, struct sockaddr_storage);
2889 if (!*return_ss_arr) {
2890 return NT_STATUS_NO_MEMORY;
2892 if (!interpret_string_addr(*return_ss_arr, name, AI_NUMERICHOST)) {
2893 TALLOC_FREE(*return_ss_arr);
2894 return NT_STATUS_BAD_NETWORK_NAME;
2897 return NT_STATUS_OK;
2900 sitename = sitename_fetch(ctx, lp_realm()); /* wild guess */
2902 status = internal_resolve_name(name, name_type, sitename,
2904 lp_name_resolve_order());
2905 TALLOC_FREE(sitename);
2907 if (!NT_STATUS_IS_OK(status)) {
2911 /* only return valid addresses for TCP connections */
2912 for (i=0, num_entries = 0; i<count; i++) {
2913 if (!is_zero_addr(&ss_list[i].ss) &&
2914 !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
2918 if (num_entries == 0) {
2920 return NT_STATUS_BAD_NETWORK_NAME;
2923 *return_ss_arr = talloc_array(ctx,
2924 struct sockaddr_storage,
2926 if (!(*return_ss_arr)) {
2928 return NT_STATUS_NO_MEMORY;
2931 for (i=0, num_entries = 0; i<count; i++) {
2932 if (!is_zero_addr(&ss_list[i].ss) &&
2933 !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
2934 (*return_ss_arr)[num_entries++] = ss_list[i].ss;
2938 status = NT_STATUS_OK;
2939 *p_num_entries = num_entries;
2942 return NT_STATUS_OK;
2945 /********************************************************
2946 Find the IP address of the master browser or DMB for a workgroup.
2947 *********************************************************/
2949 bool find_master_ip(const char *group, struct sockaddr_storage *master_ss)
2951 struct ip_service *ip_list = NULL;
2955 if (lp_disable_netbios()) {
2956 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group));
2960 status = internal_resolve_name(group, 0x1D, NULL, &ip_list, &count,
2961 lp_name_resolve_order());
2962 if (NT_STATUS_IS_OK(status)) {
2963 *master_ss = ip_list[0].ss;
2968 status = internal_resolve_name(group, 0x1B, NULL, &ip_list, &count,
2969 lp_name_resolve_order());
2970 if (NT_STATUS_IS_OK(status)) {
2971 *master_ss = ip_list[0].ss;
2980 /********************************************************
2981 Get the IP address list of the primary domain controller
2983 *********************************************************/
2985 bool get_pdc_ip(const char *domain, struct sockaddr_storage *pss)
2987 struct ip_service *ip_list = NULL;
2989 NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
2990 static const char *ads_order[] = { "ads", NULL };
2991 /* Look up #1B name */
2993 if (lp_security() == SEC_ADS) {
2994 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
2998 if (!NT_STATUS_IS_OK(status) || count == 0) {
2999 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
3001 lp_name_resolve_order());
3002 if (!NT_STATUS_IS_OK(status)) {
3008 /* if we get more than 1 IP back we have to assume it is a
3009 multi-homed PDC and not a mess up */
3012 DEBUG(6,("get_pdc_ip: PDC has %d IP addresses!\n", count));
3013 sort_service_list(ip_list, count);
3016 *pss = ip_list[0].ss;
3021 /* Private enum type for lookups. */
3023 enum dc_lookup_type { DC_NORMAL_LOOKUP, DC_ADS_ONLY, DC_KDC_ONLY };
3025 /********************************************************
3026 Get the IP address list of the domain controllers for
3028 *********************************************************/
3030 static NTSTATUS get_dc_list(const char *domain,
3031 const char *sitename,
3032 struct ip_service **ip_list,
3034 enum dc_lookup_type lookup_type,
3037 const char **resolve_order = NULL;
3038 char *saf_servername = NULL;
3039 char *pserver = NULL;
3041 char *port_str = NULL;
3044 size_t num_addresses = 0;
3045 size_t local_count, i;
3046 struct ip_service *return_iplist = NULL;
3047 struct ip_service *auto_ip_list = NULL;
3048 bool done_auto_lookup = false;
3051 TALLOC_CTX *ctx = talloc_stackframe();
3052 int auto_name_type = 0x1C;
3059 /* if we are restricted to solely using DNS for looking
3060 up a domain controller, make sure that host lookups
3061 are enabled for the 'name resolve order'. If host lookups
3062 are disabled and ads_only is True, then set the string to
3065 resolve_order = lp_name_resolve_order();
3066 if (!resolve_order) {
3067 status = NT_STATUS_NO_MEMORY;
3070 if (lookup_type == DC_ADS_ONLY) {
3071 if (str_list_check_ci(resolve_order, "host")) {
3072 static const char *ads_order[] = { "ads", NULL };
3073 resolve_order = ads_order;
3075 /* DNS SRV lookups used by the ads resolver
3076 are already sorted by priority and weight */
3079 /* this is quite bizarre! */
3080 static const char *null_order[] = { "NULL", NULL };
3081 resolve_order = null_order;
3083 } else if (lookup_type == DC_KDC_ONLY) {
3084 static const char *kdc_order[] = { "kdc", NULL };
3085 /* DNS SRV lookups used by the ads/kdc resolver
3086 are already sorted by priority and weight */
3088 resolve_order = kdc_order;
3089 auto_name_type = KDC_NAME_TYPE;
3092 /* fetch the server we have affinity for. Add the
3093 'password server' list to a search for our domain controllers */
3095 saf_servername = saf_fetch(ctx, domain);
3097 if (strequal(domain, lp_workgroup()) || strequal(domain, lp_realm())) {
3098 pserver = talloc_asprintf(ctx, "%s, %s",
3099 saf_servername ? saf_servername : "",
3100 lp_password_server());
3102 pserver = talloc_asprintf(ctx, "%s, *",
3103 saf_servername ? saf_servername : "");
3106 TALLOC_FREE(saf_servername);
3108 status = NT_STATUS_NO_MEMORY;
3112 DEBUG(3,("get_dc_list: preferred server list: \"%s\"\n", pserver ));
3115 * if '*' appears in the "password server" list then add
3116 * an auto lookup to the list of manually configured
3117 * DC's. If any DC is listed by name, then the list should be
3118 * considered to be ordered
3122 while (next_token_talloc(ctx, &p, &name, LIST_SEP)) {
3123 if (!done_auto_lookup && strequal(name, "*")) {
3124 status = internal_resolve_name(domain, auto_name_type,
3129 if (NT_STATUS_IS_OK(status)) {
3130 num_addresses += auto_count;
3132 done_auto_lookup = true;
3133 DEBUG(8,("Adding %d DC's from auto lookup\n",
3140 /* if we have no addresses and haven't done the auto lookup, then
3141 just return the list of DC's. Or maybe we just failed. */
3143 if (num_addresses == 0) {
3144 if (done_auto_lookup) {
3145 DEBUG(4,("get_dc_list: no servers found\n"));
3146 status = NT_STATUS_NO_LOGON_SERVERS;
3149 status = internal_resolve_name(domain, auto_name_type,
3151 count, resolve_order);
3155 if ((return_iplist = SMB_MALLOC_ARRAY(struct ip_service,
3156 num_addresses)) == NULL) {
3157 DEBUG(3,("get_dc_list: malloc fail !\n"));
3158 status = NT_STATUS_NO_MEMORY;
3165 /* fill in the return list now with real IP's */
3167 while ((local_count<num_addresses) &&
3168 next_token_talloc(ctx, &p, &name, LIST_SEP)) {
3169 struct sockaddr_storage name_ss;
3171 /* copy any addresses from the auto lookup */
3173 if (strequal(name, "*")) {
3175 for (j=0; j<auto_count; j++) {
3176 char addr[INET6_ADDRSTRLEN];
3177 print_sockaddr(addr,
3179 &auto_ip_list[j].ss);
3180 /* Check for and don't copy any
3181 * known bad DC IP's. */
3182 if(!NT_STATUS_IS_OK(check_negative_conn_cache(
3185 DEBUG(5,("get_dc_list: "
3186 "negative entry %s removed "
3191 return_iplist[local_count].ss =
3193 return_iplist[local_count].port =
3194 auto_ip_list[j].port;
3200 /* added support for address:port syntax for ads
3201 * (not that I think anyone will ever run the LDAP
3202 * server in an AD domain on something other than
3204 * However, the port should not be used for kerberos
3207 port = (lookup_type == DC_ADS_ONLY) ? LDAP_PORT :
3208 ((lookup_type == DC_KDC_ONLY) ? DEFAULT_KRB5_PORT :
3210 if ((port_str=strchr(name, ':')) != NULL) {
3212 if (lookup_type != DC_KDC_ONLY) {
3214 port = atoi(port_str);
3218 /* explicit lookup; resolve_name() will
3219 * handle names & IP addresses */
3220 if (resolve_name( name, &name_ss, 0x20, true )) {
3221 char addr[INET6_ADDRSTRLEN];
3222 print_sockaddr(addr,
3226 /* Check for and don't copy any known bad DC IP's. */
3227 if( !NT_STATUS_IS_OK(check_negative_conn_cache(domain,
3229 DEBUG(5,("get_dc_list: negative entry %s "
3230 "removed from DC list\n",
3235 return_iplist[local_count].ss = name_ss;
3236 return_iplist[local_count].port = port;
3242 /* need to remove duplicates in the list if we have any
3243 explicit password servers */
3245 local_count = remove_duplicate_addrs2(return_iplist, local_count );
3247 /* For DC's we always prioritize IPv4 due to W2K3 not
3248 * supporting LDAP, KRB5 or CLDAP over IPv6. */
3250 if (local_count && return_iplist) {
3251 prioritize_ipv4_list(return_iplist, local_count);
3254 if ( DEBUGLEVEL >= 4 ) {
3255 DEBUG(4,("get_dc_list: returning %zu ip addresses "
3256 "in an %sordered list\n",
3258 *ordered ? "":"un"));
3259 DEBUG(4,("get_dc_list: "));
3260 for ( i=0; i<local_count; i++ ) {
3261 char addr[INET6_ADDRSTRLEN];
3262 print_sockaddr(addr,
3264 &return_iplist[i].ss);
3265 DEBUGADD(4,("%s:%d ", addr, return_iplist[i].port ));
3270 *ip_list = return_iplist;
3271 *count = local_count;
3273 status = ( *count != 0 ? NT_STATUS_OK : NT_STATUS_NO_LOGON_SERVERS );
3277 if (!NT_STATUS_IS_OK(status)) {
3278 SAFE_FREE(return_iplist);
3283 SAFE_FREE(auto_ip_list);
3288 /*********************************************************************
3289 Small wrapper function to get the DC list and sort it if neccessary.
3290 *********************************************************************/
3292 NTSTATUS get_sorted_dc_list( const char *domain,
3293 const char *sitename,
3294 struct ip_service **ip_list,
3298 bool ordered = false;
3300 enum dc_lookup_type lookup_type = DC_NORMAL_LOOKUP;
3305 DEBUG(8,("get_sorted_dc_list: attempting lookup "
3306 "for name %s (sitename %s)\n",
3308 sitename ? sitename : "NULL"));
3311 lookup_type = DC_ADS_ONLY;
3314 status = get_dc_list(domain, sitename, ip_list,
3315 count, lookup_type, &ordered);
3316 if (NT_STATUS_EQUAL(status, NT_STATUS_NO_LOGON_SERVERS)
3318 DEBUG(3,("get_sorted_dc_list: no server for name %s available"
3319 " in site %s, fallback to all servers\n",
3321 status = get_dc_list(domain, NULL, ip_list,
3322 count, lookup_type, &ordered);
3325 if (!NT_STATUS_IS_OK(status)) {
3326 SAFE_FREE(*ip_list);
3331 /* only sort if we don't already have an ordered list */
3333 sort_service_list(*ip_list, *count);
3336 return NT_STATUS_OK;
3339 /*********************************************************************
3340 Get the KDC list - re-use all the logic in get_dc_list.
3341 *********************************************************************/
3343 NTSTATUS get_kdc_list( const char *realm,
3344 const char *sitename,
3345 struct ip_service **ip_list,
3354 status = get_dc_list(realm, sitename, ip_list,
3355 count, DC_KDC_ONLY, &ordered);
3357 if (!NT_STATUS_IS_OK(status)) {
3358 SAFE_FREE(*ip_list);
3363 /* only sort if we don't already have an ordered list */
3365 sort_service_list(*ip_list, *count);
3368 return NT_STATUS_OK;