2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1994-1998
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 /* nmbd.c sets this to True. */
25 BOOL global_in_nmbd
= False
;
27 /****************************************************************************
28 Generate a random trn_id.
29 ****************************************************************************/
31 static int generate_trn_id(void)
36 sys_srandom(sys_getpid());
39 trn_id
= sys_random();
41 return trn_id
% (unsigned)0x7FFF;
44 /****************************************************************************
45 Parse a node status response into an array of structures.
46 ****************************************************************************/
48 static struct node_status
*parse_node_status(char *p
, int *num_names
)
50 struct node_status
*ret
;
53 *num_names
= CVAL(p
,0);
58 ret
= (struct node_status
*)malloc(sizeof(struct node_status
)* (*num_names
));
59 if (!ret
) return NULL
;
62 for (i
=0;i
< *num_names
;i
++) {
63 StrnCpy(ret
[i
].name
,p
,15);
64 trim_char(ret
[i
].name
,'\0',' ');
65 ret
[i
].type
= CVAL(p
,15);
68 DEBUG(10, ("%s#%02x: flags = 0x%02x\n", ret
[i
].name
,
69 ret
[i
].type
, ret
[i
].flags
));
75 /****************************************************************************
76 Do a NBT node status query on an open socket and return an array of
77 structures holding the returned names or NULL if the query failed.
78 **************************************************************************/
80 struct node_status
*node_status_query(int fd
,struct nmb_name
*name
,
81 struct in_addr to_ip
, int *num_names
)
85 int retry_time
= 2000;
87 struct packet_struct p
;
88 struct packet_struct
*p2
;
89 struct nmb_packet
*nmb
= &p
.packet
.nmb
;
90 struct node_status
*ret
;
94 nmb
->header
.name_trn_id
= generate_trn_id();
95 nmb
->header
.opcode
= 0;
96 nmb
->header
.response
= False
;
97 nmb
->header
.nm_flags
.bcast
= False
;
98 nmb
->header
.nm_flags
.recursion_available
= False
;
99 nmb
->header
.nm_flags
.recursion_desired
= False
;
100 nmb
->header
.nm_flags
.trunc
= False
;
101 nmb
->header
.nm_flags
.authoritative
= False
;
102 nmb
->header
.rcode
= 0;
103 nmb
->header
.qdcount
= 1;
104 nmb
->header
.ancount
= 0;
105 nmb
->header
.nscount
= 0;
106 nmb
->header
.arcount
= 0;
107 nmb
->question
.question_name
= *name
;
108 nmb
->question
.question_type
= 0x21;
109 nmb
->question
.question_class
= 0x1;
114 p
.timestamp
= time(NULL
);
115 p
.packet_type
= NMB_PACKET
;
119 if (!send_packet(&p
))
125 struct timeval tval2
;
126 GetTimeOfDay(&tval2
);
127 if (TvalDiff(&tval
,&tval2
) > retry_time
) {
130 if (!found
&& !send_packet(&p
))
136 if ((p2
=receive_nmb_packet(fd
,90,nmb
->header
.name_trn_id
))) {
137 struct nmb_packet
*nmb2
= &p2
->packet
.nmb
;
138 debug_nmb_packet(p2
);
140 if (nmb2
->header
.opcode
!= 0 ||
141 nmb2
->header
.nm_flags
.bcast
||
142 nmb2
->header
.rcode
||
143 !nmb2
->header
.ancount
||
144 nmb2
->answers
->rr_type
!= 0x21) {
145 /* XXXX what do we do with this? could be a
146 redirect, but we'll discard it for the
152 ret
= parse_node_status(&nmb2
->answers
->rdata
[0], num_names
);
161 /****************************************************************************
162 Find the first type XX name in a node status reply - used for finding
163 a servers name given its IP. Return the matched name in *name.
164 **************************************************************************/
166 BOOL
name_status_find(const char *q_name
, int q_type
, int type
, struct in_addr to_ip
, fstring name
)
168 struct node_status
*status
= NULL
;
169 struct nmb_name nname
;
174 if (lp_disable_netbios()) {
175 DEBUG(5,("name_status_find(%s#%02x): netbios is disabled\n", q_name
, q_type
));
179 DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name
,
180 q_type
, inet_ntoa(to_ip
)));
182 /* Check the cache first. */
184 if (namecache_status_fetch(q_name
, q_type
, type
, to_ip
, name
))
187 sock
= open_socket_in(SOCK_DGRAM
, 0, 3, interpret_addr(lp_socket_address()), True
);
191 /* W2K PDC's seem not to respond to '*'#0. JRA */
192 make_nmb_name(&nname
, q_name
, q_type
);
193 status
= node_status_query(sock
, &nname
, to_ip
, &count
);
198 for (i
=0;i
<count
;i
++) {
199 if (status
[i
].type
== type
)
205 pull_ascii_nstring(name
, sizeof(fstring
), status
[i
].name
);
207 /* Store the result in the cache. */
208 /* but don't store an entry for 0x1c names here. Here we have
209 a single host and DOMAIN<0x1c> names should be a list of hosts */
211 if ( q_type
!= 0x1c )
212 namecache_status_store(q_name
, q_type
, type
, to_ip
, name
);
219 DEBUG(10, ("name_status_find: name %sfound", result
? "" : "not "));
222 DEBUGADD(10, (", name %s ip address is %s", name
, inet_ntoa(to_ip
)));
230 comparison function used by sort_ip_list
233 static int ip_compare(struct in_addr
*ip1
, struct in_addr
*ip2
)
235 int max_bits1
=0, max_bits2
=0;
236 int num_interfaces
= iface_count();
239 for (i
=0;i
<num_interfaces
;i
++) {
242 ip
= *iface_n_bcast(i
);
243 bits1
= matching_quad_bits((uchar
*)&ip1
->s_addr
, (uchar
*)&ip
.s_addr
);
244 bits2
= matching_quad_bits((uchar
*)&ip2
->s_addr
, (uchar
*)&ip
.s_addr
);
245 max_bits1
= MAX(bits1
, max_bits1
);
246 max_bits2
= MAX(bits2
, max_bits2
);
249 /* bias towards directly reachable IPs */
250 if (iface_local(*ip1
)) {
253 if (iface_local(*ip2
)) {
257 return max_bits2
- max_bits1
;
260 /*******************************************************************
261 compare 2 ldap IPs by nearness to our interfaces - used in qsort
262 *******************************************************************/
264 static int ip_service_compare(struct ip_service
*ip1
, struct ip_service
*ip2
)
268 if ( (result
= ip_compare(&ip1
->ip
, &ip2
->ip
)) != 0 )
271 if ( ip1
->port
> ip2
->port
)
274 if ( ip1
->port
< ip2
->port
)
281 sort an IP list so that names that are close to one of our interfaces
282 are at the top. This prevents the problem where a WINS server returns an IP that
283 is not reachable from our subnet as the first match
286 static void sort_ip_list(struct in_addr
*iplist
, int count
)
292 qsort(iplist
, count
, sizeof(struct in_addr
), QSORT_CAST ip_compare
);
295 static void sort_ip_list2(struct ip_service
*iplist
, int count
)
301 qsort(iplist
, count
, sizeof(struct ip_service
), QSORT_CAST ip_service_compare
);
304 /**********************************************************************
305 Remove any duplicate address/port pairs in the list
306 *********************************************************************/
308 static int remove_duplicate_addrs2( struct ip_service
*iplist
, int count
)
312 DEBUG(10,("remove_duplicate_addrs2: looking for duplicate address/port pairs\n"));
314 /* one loop to remove duplicates */
315 for ( i
=0; i
<count
; i
++ ) {
316 if ( is_zero_ip(iplist
[i
].ip
) )
319 for ( j
=i
+1; j
<count
; j
++ ) {
320 if ( ip_service_equal(iplist
[i
], iplist
[j
]) )
321 zero_ip(&iplist
[j
].ip
);
325 /* one loop to clean up any holes we left */
326 /* first ip should never be a zero_ip() */
327 for (i
= 0; i
<count
; ) {
328 if ( is_zero_ip(iplist
[i
].ip
) ) {
330 memmove(&iplist
[i
], &iplist
[i
+1], (count
- i
- 1)*sizeof(iplist
[i
]));
340 /****************************************************************************
341 Do a netbios name query to find someones IP.
342 Returns an array of IP addresses or NULL if none.
343 *count will be set to the number of addresses returned.
344 *timed_out is set if we failed by timing out
345 ****************************************************************************/
347 struct in_addr
*name_query(int fd
,const char *name
,int name_type
,
348 BOOL bcast
,BOOL recurse
,
349 struct in_addr to_ip
, int *count
, int *flags
,
354 int retry_time
= bcast
?250:2000;
356 struct packet_struct p
;
357 struct packet_struct
*p2
;
358 struct nmb_packet
*nmb
= &p
.packet
.nmb
;
359 struct in_addr
*ip_list
= NULL
;
361 if (lp_disable_netbios()) {
362 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n", name
, name_type
));
370 memset((char *)&p
,'\0',sizeof(p
));
374 nmb
->header
.name_trn_id
= generate_trn_id();
375 nmb
->header
.opcode
= 0;
376 nmb
->header
.response
= False
;
377 nmb
->header
.nm_flags
.bcast
= bcast
;
378 nmb
->header
.nm_flags
.recursion_available
= False
;
379 nmb
->header
.nm_flags
.recursion_desired
= recurse
;
380 nmb
->header
.nm_flags
.trunc
= False
;
381 nmb
->header
.nm_flags
.authoritative
= False
;
382 nmb
->header
.rcode
= 0;
383 nmb
->header
.qdcount
= 1;
384 nmb
->header
.ancount
= 0;
385 nmb
->header
.nscount
= 0;
386 nmb
->header
.arcount
= 0;
388 make_nmb_name(&nmb
->question
.question_name
,name
,name_type
);
390 nmb
->question
.question_type
= 0x20;
391 nmb
->question
.question_class
= 0x1;
396 p
.timestamp
= time(NULL
);
397 p
.packet_type
= NMB_PACKET
;
401 if (!send_packet(&p
))
407 struct timeval tval2
;
408 struct in_addr
*tmp_ip_list
;
410 GetTimeOfDay(&tval2
);
411 if (TvalDiff(&tval
,&tval2
) > retry_time
) {
414 if (!found
&& !send_packet(&p
))
420 if ((p2
=receive_nmb_packet(fd
,90,nmb
->header
.name_trn_id
))) {
421 struct nmb_packet
*nmb2
= &p2
->packet
.nmb
;
422 debug_nmb_packet(p2
);
424 /* If we get a Negative Name Query Response from a WINS
425 * server, we should report it and give up.
427 if( 0 == nmb2
->header
.opcode
/* A query response */
428 && !(bcast
) /* from a WINS server */
429 && nmb2
->header
.rcode
/* Error returned */
432 if( DEBUGLVL( 3 ) ) {
433 /* Only executed if DEBUGLEVEL >= 3 */
434 dbgtext( "Negative name query response, rcode 0x%02x: ", nmb2
->header
.rcode
);
435 switch( nmb2
->header
.rcode
) {
437 dbgtext( "Request was invalidly formatted.\n" );
440 dbgtext( "Problem with NBNS, cannot process name.\n");
443 dbgtext( "The name requested does not exist.\n" );
446 dbgtext( "Unsupported request error.\n" );
449 dbgtext( "Query refused error.\n" );
452 dbgtext( "Unrecognized error code.\n" );
460 if (nmb2
->header
.opcode
!= 0 ||
461 nmb2
->header
.nm_flags
.bcast
||
462 nmb2
->header
.rcode
||
463 !nmb2
->header
.ancount
) {
465 * XXXX what do we do with this? Could be a
466 * redirect, but we'll discard it for the
473 tmp_ip_list
= (struct in_addr
*)Realloc( ip_list
, sizeof( ip_list
[0] )
474 * ( (*count
) + nmb2
->answers
->rdlength
/6 ) );
477 DEBUG(0,("name_query: Realloc failed.\n"));
481 ip_list
= tmp_ip_list
;
484 DEBUG(2,("Got a positive name query response from %s ( ", inet_ntoa(p2
->ip
)));
485 for (i
=0;i
<nmb2
->answers
->rdlength
/6;i
++) {
486 putip((char *)&ip_list
[(*count
)],&nmb2
->answers
->rdata
[2+i
*6]);
487 DEBUGADD(2,("%s ",inet_ntoa(ip_list
[(*count
)])));
495 /* We add the flags back ... */
496 if (nmb2
->header
.response
)
497 (*flags
) |= NM_FLAGS_RS
;
498 if (nmb2
->header
.nm_flags
.authoritative
)
499 (*flags
) |= NM_FLAGS_AA
;
500 if (nmb2
->header
.nm_flags
.trunc
)
501 (*flags
) |= NM_FLAGS_TC
;
502 if (nmb2
->header
.nm_flags
.recursion_desired
)
503 (*flags
) |= NM_FLAGS_RD
;
504 if (nmb2
->header
.nm_flags
.recursion_available
)
505 (*flags
) |= NM_FLAGS_RA
;
506 if (nmb2
->header
.nm_flags
.bcast
)
507 (*flags
) |= NM_FLAGS_B
;
510 * If we're doing a unicast lookup we only
511 * expect one reply. Don't wait the full 2
512 * seconds if we got one. JRA.
519 /* only set timed_out if we didn't fund what we where looking for*/
521 if ( !found
&& timed_out
) {
525 /* sort the ip list so we choose close servers first if possible */
526 sort_ip_list(ip_list
, *count
);
531 /********************************************************
532 Start parsing the lmhosts file.
533 *********************************************************/
535 XFILE
*startlmhosts(char *fname
)
537 XFILE
*fp
= x_fopen(fname
,O_RDONLY
, 0);
539 DEBUG(4,("startlmhosts: Can't open lmhosts file %s. Error was %s\n",
540 fname
, strerror(errno
)));
546 /********************************************************
547 Parse the next line in the lmhosts file.
548 *********************************************************/
550 BOOL
getlmhostsent( XFILE
*fp
, pstring name
, int *name_type
, struct in_addr
*ipaddr
)
554 while(!x_feof(fp
) && !x_ferror(fp
)) {
555 pstring ip
,flags
,extra
;
562 if (!fgets_slash(line
,sizeof(pstring
),fp
))
574 if (next_token(&ptr
,ip
,NULL
,sizeof(ip
)))
576 if (next_token(&ptr
,name
,NULL
, sizeof(pstring
)))
578 if (next_token(&ptr
,flags
,NULL
, sizeof(flags
)))
580 if (next_token(&ptr
,extra
,NULL
, sizeof(extra
)))
586 if (count
> 0 && count
< 2)
588 DEBUG(0,("getlmhostsent: Ill formed hosts line [%s]\n",line
));
594 DEBUG(0,("getlmhostsent: too many columns in lmhosts file (obsolete syntax)\n"));
598 DEBUG(4, ("getlmhostsent: lmhost entry: %s %s %s\n", ip
, name
, flags
));
600 if (strchr_m(flags
,'G') || strchr_m(flags
,'S'))
602 DEBUG(0,("getlmhostsent: group flag in lmhosts ignored (obsolete)\n"));
606 *ipaddr
= *interpret_addr2(ip
);
608 /* Extra feature. If the name ends in '#XX', where XX is a hex number,
609 then only add that name type. */
610 if((ptr1
= strchr_m(name
, '#')) != NULL
)
615 *name_type
= (int)strtol(ptr1
, &endptr
, 16);
617 if(!*ptr1
|| (endptr
== ptr1
))
619 DEBUG(0,("getlmhostsent: invalid name %s containing '#'.\n", name
));
623 *(--ptr1
) = '\0'; /* Truncate at the '#' */
632 /********************************************************
633 Finish parsing the lmhosts file.
634 *********************************************************/
636 void endlmhosts(XFILE
*fp
)
641 /********************************************************
642 convert an array if struct in_addrs to struct ip_service
643 return False on failure. Port is set to PORT_NONE;
644 *********************************************************/
646 static BOOL
convert_ip2service( struct ip_service
**return_iplist
, struct in_addr
*ip_list
, int count
)
650 if ( count
==0 || !ip_list
)
653 /* copy the ip address; port will be PORT_NONE */
654 if ( (*return_iplist
= (struct ip_service
*)malloc(count
*sizeof(struct ip_service
))) == NULL
) {
655 DEBUG(0,("convert_ip2service: malloc failed for %d enetries!\n", count
));
659 for ( i
=0; i
<count
; i
++ ) {
660 (*return_iplist
)[i
].ip
= ip_list
[i
];
661 (*return_iplist
)[i
].port
= PORT_NONE
;
666 /********************************************************
667 Resolve via "bcast" method.
668 *********************************************************/
670 BOOL
name_resolve_bcast(const char *name
, int name_type
,
671 struct ip_service
**return_iplist
, int *return_count
)
674 int num_interfaces
= iface_count();
675 struct in_addr
*ip_list
;
678 if (lp_disable_netbios()) {
679 DEBUG(5,("name_resolve_bcast(%s#%02x): netbios is disabled\n", name
, name_type
));
683 *return_iplist
= NULL
;
687 * "bcast" means do a broadcast lookup on all the local interfaces.
690 DEBUG(3,("name_resolve_bcast: Attempting broadcast lookup for name %s<0x%x>\n", name
, name_type
));
692 sock
= open_socket_in( SOCK_DGRAM
, 0, 3,
693 interpret_addr(lp_socket_address()), True
);
695 if (sock
== -1) return False
;
697 set_socket_options(sock
,"SO_BROADCAST");
699 * Lookup the name on all the interfaces, return on
700 * the first successful match.
702 for( i
= num_interfaces
-1; i
>= 0; i
--) {
703 struct in_addr sendto_ip
;
705 /* Done this way to fix compiler error on IRIX 5.x */
706 sendto_ip
= *iface_n_bcast(i
);
707 ip_list
= name_query(sock
, name
, name_type
, True
,
708 True
, sendto_ip
, return_count
, &flags
, NULL
);
713 /* failed - no response */
720 if ( !convert_ip2service(return_iplist
, ip_list
, *return_count
) )
723 SAFE_FREE( ip_list
);
728 /********************************************************
729 Resolve via "wins" method.
730 *********************************************************/
732 BOOL
resolve_wins(const char *name
, int name_type
,
733 struct ip_service
**return_iplist
, int *return_count
)
737 struct in_addr src_ip
, *ip_list
= NULL
;
740 if (lp_disable_netbios()) {
741 DEBUG(5,("resolve_wins(%s#%02x): netbios is disabled\n", name
, name_type
));
745 *return_iplist
= NULL
;
748 DEBUG(3,("resolve_wins: Attempting wins lookup for name %s<0x%x>\n", name
, name_type
));
750 if (wins_srv_count() < 1) {
751 DEBUG(3,("resolve_wins: WINS server resolution selected and no WINS servers listed.\n"));
755 /* we try a lookup on each of the WINS tags in turn */
756 wins_tags
= wins_srv_tags();
759 /* huh? no tags?? give up in disgust */
763 /* the address we will be sending from */
764 src_ip
= *interpret_addr2(lp_socket_address());
766 /* in the worst case we will try every wins server with every
768 for (t
=0; wins_tags
&& wins_tags
[t
]; t
++) {
769 int srv_count
= wins_srv_count_tag(wins_tags
[t
]);
770 for (i
=0; i
<srv_count
; i
++) {
771 struct in_addr wins_ip
;
775 wins_ip
= wins_srv_ip_tag(wins_tags
[t
], src_ip
);
777 if (global_in_nmbd
&& ismyip(wins_ip
)) {
778 /* yikes! we'll loop forever */
782 /* skip any that have been unresponsive lately */
783 if (wins_srv_is_dead(wins_ip
, src_ip
)) {
787 DEBUG(3,("resolve_wins: using WINS server %s and tag '%s'\n", inet_ntoa(wins_ip
), wins_tags
[t
]));
789 sock
= open_socket_in(SOCK_DGRAM
, 0, 3, src_ip
.s_addr
, True
);
794 ip_list
= name_query(sock
,name
,name_type
, False
,
795 True
, wins_ip
, return_count
, &flags
,
798 /* exit loop if we got a list of addresses */
806 /* Timed out wating for WINS server to respond. Mark it dead. */
807 wins_srv_died(wins_ip
, src_ip
);
809 /* The name definately isn't in this
810 group of WINS servers. goto the next group */
816 wins_srv_tags_free(wins_tags
);
821 if ( !convert_ip2service( return_iplist
, ip_list
, *return_count
) )
824 SAFE_FREE( ip_list
);
825 wins_srv_tags_free(wins_tags
);
831 /********************************************************
832 Resolve via "lmhosts" method.
833 *********************************************************/
835 static BOOL
resolve_lmhosts(const char *name
, int name_type
,
836 struct ip_service
**return_iplist
, int *return_count
)
839 * "lmhosts" means parse the local lmhosts file.
845 struct in_addr return_ip
;
847 *return_iplist
= NULL
;
850 DEBUG(3,("resolve_lmhosts: Attempting lmhosts lookup for name %s<0x%x>\n", name
, name_type
));
852 fp
= startlmhosts(dyn_LMHOSTSFILE
);
854 while (getlmhostsent(fp
, lmhost_name
, &name_type2
, &return_ip
)) {
855 if (strequal(name
, lmhost_name
) &&
856 ((name_type2
== -1) || (name_type
== name_type2
))
859 if ( (*return_iplist
= (struct ip_service
*)malloc(sizeof(struct ip_service
))) == NULL
) {
860 DEBUG(3,("resolve_lmhosts: malloc fail !\n"));
863 (*return_iplist
)[0].ip
= return_ip
;
864 (*return_iplist
)[0].port
= PORT_NONE
;
875 /********************************************************
876 Resolve via "hosts" method.
877 *********************************************************/
879 static BOOL
resolve_hosts(const char *name
, int name_type
,
880 struct ip_service
**return_iplist
, int *return_count
)
883 * "host" means do a localhost, or dns lookup.
887 if ( name_type
!= 0x20 && name_type
!= 0x0) {
888 DEBUG(5, ("resolve_hosts: not appropriate for name type <0x%x>\n", name_type
));
892 *return_iplist
= NULL
;
895 DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n", name
, name_type
));
897 if (((hp
= sys_gethostbyname(name
)) != NULL
) && (hp
->h_addr
!= NULL
)) {
898 struct in_addr return_ip
;
899 putip((char *)&return_ip
,(char *)hp
->h_addr
);
900 *return_iplist
= (struct ip_service
*)malloc(sizeof(struct ip_service
));
901 if(*return_iplist
== NULL
) {
902 DEBUG(3,("resolve_hosts: malloc fail !\n"));
905 (*return_iplist
)->ip
= return_ip
;
906 (*return_iplist
)->port
= PORT_NONE
;
913 /********************************************************
914 Resolve via "ADS" method.
915 *********************************************************/
917 static BOOL
resolve_ads(const char *name
, int name_type
,
918 struct ip_service
**return_iplist
, int *return_count
)
922 if ( name_type
== 0x1c ) {
928 /* try to lookup the _ldap._tcp.<domain> if we are using ADS */
929 if ( lp_security() != SEC_ADS
)
932 DEBUG(5,("resolve_hosts: Attempting to resolve DC's for %s using DNS\n",
935 if (ldap_domain2hostlist(name
, &list
) != LDAP_SUCCESS
)
938 count
= count_chars(list
, ' ') + 1;
939 if ( (*return_iplist
= malloc(count
* sizeof(struct ip_service
))) == NULL
) {
940 DEBUG(0,("resolve_hosts: malloc failed for %d entries\n", count
));
945 while (next_token(&ptr
, tok
, " ", sizeof(tok
))) {
946 unsigned port
= LDAP_PORT
;
947 char *p
= strchr(tok
, ':');
952 (*return_iplist
)[i
].ip
= *interpret_addr2(tok
);
953 (*return_iplist
)[i
].port
= port
;
955 /* make sure it is a valid IP. I considered checking the negative
956 connection cache, but this is the wrong place for it. Maybe only
957 as a hac. After think about it, if all of the IP addresses retuend
958 from DNS are dead, what hope does a netbios name lookup have?
959 The standard reason for falling back to netbios lookups is that
960 our DNS server doesn't know anything about the DC's -- jerry */
962 if ( is_zero_ip((*return_iplist
)[i
].ip
) )
973 #endif /* HAVE_ADS */
979 /*******************************************************************
980 Internal interface to resolve a name into an IP address.
981 Use this function if the string is either an IP address, DNS
982 or host name or NetBIOS name. This uses the name switch in the
983 smb.conf to determine the order of name resolution.
985 Added support for ip addr/port to support ADS ldap servers.
986 the only place we currently care about the port is in the
987 resolve_hosts() when looking up DC's via SRV RR entries in DNS
988 **********************************************************************/
990 static BOOL
internal_resolve_name(const char *name
, int name_type
,
991 struct ip_service
**return_iplist
,
992 int *return_count
, const char *resolve_order
)
994 pstring name_resolve_list
;
997 BOOL allones
= (strcmp(name
,"255.255.255.255") == 0);
998 BOOL allzeros
= (strcmp(name
,"0.0.0.0") == 0);
999 BOOL is_address
= is_ipaddress(name
);
1000 BOOL result
= False
;
1003 *return_iplist
= NULL
;
1006 DEBUG(10, ("internal_resolve_name: looking up %s#%x\n", name
, name_type
));
1008 if (allzeros
|| allones
|| is_address
) {
1010 if ( (*return_iplist
= (struct ip_service
*)malloc(sizeof(struct ip_service
))) == NULL
) {
1011 DEBUG(0,("internal_resolve_name: malloc fail !\n"));
1016 /* ignore the port here */
1017 (*return_iplist
)->port
= PORT_NONE
;
1019 /* if it's in the form of an IP address then get the lib to interpret it */
1020 if (((*return_iplist
)->ip
.s_addr
= inet_addr(name
)) == 0xFFFFFFFF ){
1021 DEBUG(1,("internal_resolve_name: inet_addr failed on %s\n", name
));
1025 (*return_iplist
)->ip
.s_addr
= allones
? 0xFFFFFFFF : 0;
1031 /* Check name cache */
1033 if (namecache_fetch(name
, name_type
, return_iplist
, return_count
)) {
1034 /* This could be a negative response */
1035 return (*return_count
> 0);
1038 /* set the name resolution order */
1040 if ( strcmp( resolve_order
, "NULL") == 0 ) {
1041 DEBUG(8,("internal_resolve_name: all lookups disabled\n"));
1045 if ( !resolve_order
)
1046 pstrcpy(name_resolve_list
, lp_name_resolve_order());
1048 pstrcpy(name_resolve_list
, resolve_order
);
1050 if ( !name_resolve_list
[0] )
1053 ptr
= name_resolve_list
;
1055 /* iterate through the name resolution backends */
1057 while (next_token(&ptr
, tok
, LIST_SEP
, sizeof(tok
))) {
1058 if((strequal(tok
, "host") || strequal(tok
, "hosts"))) {
1059 if (resolve_hosts(name
, name_type
, return_iplist
, return_count
)) {
1063 } else if(strequal( tok
, "ads")) {
1064 /* deal with 0x1c names here. This will result in a
1065 SRV record lookup for _ldap._tcp.<domain> if we
1066 are using 'security = ads' */
1067 if (resolve_ads(name
, name_type
, return_iplist
, return_count
)) {
1071 } else if(strequal( tok
, "lmhosts")) {
1072 if (resolve_lmhosts(name
, name_type
, return_iplist
, return_count
)) {
1076 } else if(strequal( tok
, "wins")) {
1077 /* don't resolve 1D via WINS */
1078 if (name_type
!= 0x1D &&
1079 resolve_wins(name
, name_type
, return_iplist
, return_count
)) {
1083 } else if(strequal( tok
, "bcast")) {
1084 if (name_resolve_bcast(name
, name_type
, return_iplist
, return_count
)) {
1089 DEBUG(0,("resolve_name: unknown name switch type %s\n", tok
));
1093 /* All of the resolve_* functions above have returned false. */
1095 SAFE_FREE(*return_iplist
);
1102 /* Remove duplicate entries. Some queries, notably #1c (domain
1103 controllers) return the PDC in iplist[0] and then all domain
1104 controllers including the PDC in iplist[1..n]. Iterating over
1105 the iplist when the PDC is down will cause two sets of timeouts. */
1107 if ( *return_count
) {
1108 *return_count
= remove_duplicate_addrs2( *return_iplist
, *return_count
);
1111 /* Save in name cache */
1112 if ( DEBUGLEVEL
>= 100 ) {
1113 for (i
= 0; i
< *return_count
&& DEBUGLEVEL
== 100; i
++)
1114 DEBUG(100, ("Storing name %s of type %d (%s:%d)\n", name
,
1115 name_type
, inet_ntoa((*return_iplist
)[i
].ip
), (*return_iplist
)[i
].port
));
1118 namecache_store(name
, name_type
, *return_count
, *return_iplist
);
1120 /* Display some debugging info */
1122 if ( DEBUGLEVEL
>= 10 ) {
1123 DEBUG(10, ("internal_resolve_name: returning %d addresses: ",
1126 for (i
= 0; i
< *return_count
; i
++)
1127 DEBUGADD(10, ("%s:%d ", inet_ntoa((*return_iplist
)[i
].ip
), (*return_iplist
)[i
].port
));
1135 /********************************************************
1136 Internal interface to resolve a name into one IP address.
1137 Use this function if the string is either an IP address, DNS
1138 or host name or NetBIOS name. This uses the name switch in the
1139 smb.conf to determine the order of name resolution.
1140 *********************************************************/
1142 BOOL
resolve_name(const char *name
, struct in_addr
*return_ip
, int name_type
)
1144 struct ip_service
*ip_list
= NULL
;
1147 if (is_ipaddress(name
)) {
1148 *return_ip
= *interpret_addr2(name
);
1152 if (internal_resolve_name(name
, name_type
, &ip_list
, &count
, lp_name_resolve_order())) {
1155 /* only return valid addresses for TCP connections */
1156 for (i
=0; i
<count
; i
++) {
1157 char *ip_str
= inet_ntoa(ip_list
[i
].ip
);
1159 strcmp(ip_str
, "255.255.255.255") != 0 &&
1160 strcmp(ip_str
, "0.0.0.0") != 0)
1162 *return_ip
= ip_list
[i
].ip
;
1173 /********************************************************
1174 Find the IP address of the master browser or DMB for a workgroup.
1175 *********************************************************/
1177 BOOL
find_master_ip(const char *group
, struct in_addr
*master_ip
)
1179 struct ip_service
*ip_list
= NULL
;
1182 if (lp_disable_netbios()) {
1183 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group
));
1187 if (internal_resolve_name(group
, 0x1D, &ip_list
, &count
, lp_name_resolve_order())) {
1188 *master_ip
= ip_list
[0].ip
;
1192 if(internal_resolve_name(group
, 0x1B, &ip_list
, &count
, lp_name_resolve_order())) {
1193 *master_ip
= ip_list
[0].ip
;
1202 /********************************************************
1203 Get the IP address list of the primary domain controller
1205 *********************************************************/
1207 BOOL
get_pdc_ip(const char *domain
, struct in_addr
*ip
)
1209 struct ip_service
*ip_list
;
1212 /* Look up #1B name */
1214 if (!internal_resolve_name(domain
, 0x1b, &ip_list
, &count
, lp_name_resolve_order()))
1217 /* if we get more than 1 IP back we have to assume it is a
1218 multi-homed PDC and not a mess up */
1221 DEBUG(6,("get_pdc_ip: PDC has %d IP addresses!\n", count
));
1222 sort_ip_list2( ip_list
, count
);
1225 *ip
= ip_list
[0].ip
;
1232 /********************************************************
1233 Get the IP address list of the domain controllers for
1235 *********************************************************/
1237 static BOOL
get_dc_list(const char *domain
, struct ip_service
**ip_list
,
1238 int *count
, BOOL ads_only
, int *ordered
)
1240 fstring resolve_order
;
1242 /* if we are restricted to solely using DNS for looking
1243 up a domain controller, make sure that host lookups
1244 are enabled for the 'name resolve order'. If host lookups
1245 are disabled and ads_only is True, then set the string to
1248 fstrcpy( resolve_order
, lp_name_resolve_order() );
1249 strlower_m( resolve_order
);
1251 if ( strstr( resolve_order
, "host" ) )
1252 fstrcpy( resolve_order
, "ads" );
1254 fstrcpy( resolve_order
, "NULL" );
1260 /* If it's our domain then use the 'password server' parameter. */
1262 if ( strequal(domain
, lp_workgroup()) || strequal(domain
, lp_realm()) ) {
1264 char *pserver
= lp_passwordserver(); /* UNIX charset. */
1268 int num_addresses
= 0;
1269 int local_count
, i
, j
;
1270 struct ip_service
*return_iplist
= NULL
;
1271 struct ip_service
*auto_ip_list
= NULL
;
1272 BOOL done_auto_lookup
= False
;
1277 return internal_resolve_name(domain
, 0x1C, ip_list
, count
, resolve_order
);
1282 * if '*' appears in the "password server" list then add
1283 * an auto lookup to the list of manually configured
1284 * DC's. If any DC is listed by name, then the list should be
1285 * considered to be ordered
1288 while (next_token(&p
,name
,LIST_SEP
,sizeof(name
))) {
1289 if (strequal(name
, "*")) {
1290 if ( internal_resolve_name(domain
, 0x1C, &auto_ip_list
, &auto_count
, resolve_order
) )
1291 num_addresses
+= auto_count
;
1292 done_auto_lookup
= True
;
1293 DEBUG(8,("Adding %d DC's from auto lookup\n", auto_count
));
1299 /* if we have no addresses and haven't done the auto lookup, then
1300 just return the list of DC's */
1302 if ( (num_addresses
== 0) && !done_auto_lookup
)
1303 return internal_resolve_name(domain
, 0x1C, ip_list
, count
, resolve_order
);
1305 /* maybe we just failed? */
1307 if ( num_addresses
== 0 ) {
1308 DEBUG(4,("get_dc_list: no servers found\n"));
1312 if ( (return_iplist
= (struct ip_service
*)
1313 malloc(num_addresses
* sizeof(struct ip_service
))) == NULL
)
1315 DEBUG(3,("get_dc_list: malloc fail !\n"));
1322 /* fill in the return list now with real IP's */
1324 while ( (local_count
<num_addresses
) && next_token(&p
,name
,LIST_SEP
,sizeof(name
)) ) {
1325 struct in_addr name_ip
;
1327 /* copy any addersses from the auto lookup */
1329 if ( strequal(name
, "*") ) {
1330 for ( j
=0; j
<auto_count
; j
++ ) {
1331 return_iplist
[local_count
].ip
= auto_ip_list
[j
].ip
;
1332 return_iplist
[local_count
].port
= auto_ip_list
[j
].port
;
1339 /* added support for address:port syntax for ads (not that I think
1340 anyone will ever run the LDAP server in an AD domain on something
1341 other than port 389 */
1343 port
= (lp_security() == SEC_ADS
) ? LDAP_PORT
: PORT_NONE
;
1344 if ( (port_str
=strchr(name
, ':')) != NULL
) {
1347 port
= atoi( port_str
);
1350 /* explicit lookup; resolve_name() will handle names & IP addresses */
1351 if ( resolve_name( name
, &name_ip
, 0x20 ) ) {
1352 return_iplist
[local_count
].ip
= name_ip
;
1353 return_iplist
[local_count
].port
= port
;
1359 SAFE_FREE(auto_ip_list
);
1361 /* need to remove duplicates in the list if we have any
1362 explicit password servers */
1365 local_count
= remove_duplicate_addrs2( return_iplist
, local_count
);
1367 if ( DEBUGLEVEL
>= 4 ) {
1368 DEBUG(4,("get_dc_list: returning %d ip addresses in an %sordered list\n", local_count
,
1369 *ordered
? "":"un"));
1370 DEBUG(4,("get_dc_list: "));
1371 for ( i
=0; i
<local_count
; i
++ )
1372 DEBUGADD(4,("%s:%d ", inet_ntoa(return_iplist
[i
].ip
), return_iplist
[i
].port
));
1376 *ip_list
= return_iplist
;
1377 *count
= local_count
;
1379 return (*count
!= 0);
1382 DEBUG(10,("get_dc_list: defaulting to internal auto lookup for domain %s\n", domain
));
1384 return internal_resolve_name(domain
, 0x1C, ip_list
, count
, resolve_order
);
1387 /*********************************************************************
1388 small wrapper function to get the DC list and sort it if neccessary
1389 *********************************************************************/
1390 BOOL
get_sorted_dc_list( const char *domain
, struct ip_service
**ip_list
, int *count
, BOOL ads_only
)
1394 DEBUG(8,("get_sorted_dc_list: attempting lookup using [%s]\n",
1395 (ads_only
? "ads" : lp_name_resolve_order())));
1397 if ( !get_dc_list(domain
, ip_list
, count
, ads_only
, &ordered
) )
1400 /* only sort if we don't already have an ordered list */
1402 sort_ip_list2( *ip_list
, *count
);