?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r1383: sync from 3.0 tree
[Samba.git] / source / libsmb / namequery.c
blobcee0015e25795daadcf709c2ac83f1d8c5dd4ee9
1 /*
2 Unix SMB/CIFS implementation.
3 name query routines
4 Copyright (C) Andrew Tridgell 1994-1998
5
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.
10
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.
15
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.
19
20 */
21
22 #include "includes.h"
23
24 /* nmbd.c sets this to True. */
25 BOOL global_in_nmbd = False;
26
27 /****************************************************************************
28 Generate a random trn_id.
29 ****************************************************************************/
30
31 static int generate_trn_id(void)
32 {
33 static int trn_id;
34
35 if (trn_id == 0) {
36 sys_srandom(sys_getpid());
37 }
38
39 trn_id = sys_random();
40
41 return trn_id % (unsigned)0x7FFF;
42 }
43
44 /****************************************************************************
45 Parse a node status response into an array of structures.
46 ****************************************************************************/
47
48 static struct node_status *parse_node_status(char *p, int *num_names, struct node_status_extra *extra)
49 {
50 struct node_status *ret;
51 int i;
52
53 *num_names = CVAL(p,0);
54
55 if (*num_names == 0)
56 return NULL;
57
58 ret = (struct node_status *)malloc(sizeof(struct node_status)* (*num_names));
59 if (!ret)
60 return NULL;
61
62 p++;
63 for (i=0;i< *num_names;i++) {
64 StrnCpy(ret[i].name,p,15);
65 trim_char(ret[i].name,'\0',' ');
66 ret[i].type = CVAL(p,15);
67 ret[i].flags = p[16];
68 p += 18;
69 DEBUG(10, ("%s#%02x: flags = 0x%02x\n", ret[i].name,
70 ret[i].type, ret[i].flags));
71 }
72 /*
73 * Also, pick up the MAC address ...
74 */
75 if (extra) {
76 memcpy(&extra->mac_addr, p, 6); /* Fill in the mac addr */
77 }
78 return ret;
79 }
80
81
82 /****************************************************************************
83 Do a NBT node status query on an open socket and return an array of
84 structures holding the returned names or NULL if the query failed.
85 **************************************************************************/
86
87 struct node_status *node_status_query(int fd,struct nmb_name *name,
88 struct in_addr to_ip, int *num_names,
89 struct node_status_extra *extra)
90 {
91 BOOL found=False;
92 int retries = 2;
93 int retry_time = 2000;
94 struct timeval tval;
95 struct packet_struct p;
96 struct packet_struct *p2;
97 struct nmb_packet *nmb = &p.packet.nmb;
98 struct node_status *ret;
99
100 ZERO_STRUCT(p);
101
102 nmb->header.name_trn_id = generate_trn_id();
103 nmb->header.opcode = 0;
104 nmb->header.response = False;
105 nmb->header.nm_flags.bcast = False;
106 nmb->header.nm_flags.recursion_available = False;
107 nmb->header.nm_flags.recursion_desired = False;
108 nmb->header.nm_flags.trunc = False;
109 nmb->header.nm_flags.authoritative = False;
110 nmb->header.rcode = 0;
111 nmb->header.qdcount = 1;
112 nmb->header.ancount = 0;
113 nmb->header.nscount = 0;
114 nmb->header.arcount = 0;
115 nmb->question.question_name = *name;
116 nmb->question.question_type = 0x21;
117 nmb->question.question_class = 0x1;
118
119 p.ip = to_ip;
120 p.port = NMB_PORT;
121 p.fd = fd;
122 p.timestamp = time(NULL);
123 p.packet_type = NMB_PACKET;
124
125 GetTimeOfDay(&tval);
126
127 if (!send_packet(&p))
128 return NULL;
129
130 retries--;
131
132 while (1) {
133 struct timeval tval2;
134 GetTimeOfDay(&tval2);
135 if (TvalDiff(&tval,&tval2) > retry_time) {
136 if (!retries)
137 break;
138 if (!found && !send_packet(&p))
139 return NULL;
140 GetTimeOfDay(&tval);
141 retries--;
142 }
143
144 if ((p2=receive_nmb_packet(fd,90,nmb->header.name_trn_id))) {
145 struct nmb_packet *nmb2 = &p2->packet.nmb;
146 debug_nmb_packet(p2);
147
148 if (nmb2->header.opcode != 0 ||
149 nmb2->header.nm_flags.bcast ||
150 nmb2->header.rcode ||
151 !nmb2->header.ancount ||
152 nmb2->answers->rr_type != 0x21) {
153 /* XXXX what do we do with this? could be a
154 redirect, but we'll discard it for the
155 moment */
156 free_packet(p2);
157 continue;
158 }
159
160 ret = parse_node_status(&nmb2->answers->rdata[0], num_names, extra);
161 free_packet(p2);
162 return ret;
163 }
164 }
165
166 return NULL;
167 }
168
169 /****************************************************************************
170 Find the first type XX name in a node status reply - used for finding
171 a servers name given its IP. Return the matched name in *name.
172 **************************************************************************/
173
174 BOOL name_status_find(const char *q_name, int q_type, int type, struct in_addr to_ip, fstring name)
175 {
176 struct node_status *status = NULL;
177 struct nmb_name nname;
178 int count, i;
179 int sock;
180 BOOL result = False;
181
182 if (lp_disable_netbios()) {
183 DEBUG(5,("name_status_find(%s#%02x): netbios is disabled\n", q_name, q_type));
184 return False;
185 }
186
187 DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name,
188 q_type, inet_ntoa(to_ip)));
189
190 /* Check the cache first. */
191
192 if (namecache_status_fetch(q_name, q_type, type, to_ip, name))
193 return True;
194
195 sock = open_socket_in(SOCK_DGRAM, 0, 3, interpret_addr(lp_socket_address()), True);
196 if (sock == -1)
197 goto done;
198
199 /* W2K PDC's seem not to respond to '*'#0. JRA */
200 make_nmb_name(&nname, q_name, q_type);
201 status = node_status_query(sock, &nname, to_ip, &count, NULL);
202 close(sock);
203 if (!status)
204 goto done;
205
206 for (i=0;i<count;i++) {
207 if (status[i].type == type)
208 break;
209 }
210 if (i == count)
211 goto done;
212
213 pull_ascii_nstring(name, sizeof(fstring), status[i].name);
214
215 /* Store the result in the cache. */
216 /* but don't store an entry for 0x1c names here. Here we have
217 a single host and DOMAIN<0x1c> names should be a list of hosts */
218
219 if ( q_type != 0x1c )
220 namecache_status_store(q_name, q_type, type, to_ip, name);
221
222 result = True;
223
224 done:
225 SAFE_FREE(status);
226
227 DEBUG(10, ("name_status_find: name %sfound", result ? "" : "not "));
228
229 if (result)
230 DEBUGADD(10, (", name %s ip address is %s", name, inet_ntoa(to_ip)));
231
232 DEBUG(10, ("\n"));
233
234 return result;
235 }
236
237 /*
238 comparison function used by sort_ip_list
239 */
240
241 static int ip_compare(struct in_addr *ip1, struct in_addr *ip2)
242 {
243 int max_bits1=0, max_bits2=0;
244 int num_interfaces = iface_count();
245 int i;
246
247 for (i=0;i<num_interfaces;i++) {
248 struct in_addr ip;
249 int bits1, bits2;
250 ip = *iface_n_bcast(i);
251 bits1 = matching_quad_bits((uchar *)&ip1->s_addr, (uchar *)&ip.s_addr);
252 bits2 = matching_quad_bits((uchar *)&ip2->s_addr, (uchar *)&ip.s_addr);
253 max_bits1 = MAX(bits1, max_bits1);
254 max_bits2 = MAX(bits2, max_bits2);
255 }
256
257 /* bias towards directly reachable IPs */
258 if (iface_local(*ip1)) {
259 max_bits1 += 32;
260 }
261 if (iface_local(*ip2)) {
262 max_bits2 += 32;
263 }
264
265 return max_bits2 - max_bits1;
266 }
267
268 /*******************************************************************
269 compare 2 ldap IPs by nearness to our interfaces - used in qsort
270 *******************************************************************/
271
272 static int ip_service_compare(struct ip_service *ip1, struct ip_service *ip2)
273 {
274 int result;
275
276 if ( (result = ip_compare(&ip1->ip, &ip2->ip)) != 0 )
277 return result;
278
279 if ( ip1->port > ip2->port )
280 return 1;
281
282 if ( ip1->port < ip2->port )
283 return -1;
284
285 return 0;
286 }
287
288 /*
289 sort an IP list so that names that are close to one of our interfaces
290 are at the top. This prevents the problem where a WINS server returns an IP that
291 is not reachable from our subnet as the first match
292 */
293
294 static void sort_ip_list(struct in_addr *iplist, int count)
295 {
296 if (count <= 1) {
297 return;
298 }
299
300 qsort(iplist, count, sizeof(struct in_addr), QSORT_CAST ip_compare);
301 }
302
303 static void sort_ip_list2(struct ip_service *iplist, int count)
304 {
305 if (count <= 1) {
306 return;
307 }
308
309 qsort(iplist, count, sizeof(struct ip_service), QSORT_CAST ip_service_compare);
310 }
311
312 /**********************************************************************
313 Remove any duplicate address/port pairs in the list
314 *********************************************************************/
315
316 static int remove_duplicate_addrs2( struct ip_service *iplist, int count )
317 {
318 int i, j;
319
320 DEBUG(10,("remove_duplicate_addrs2: looking for duplicate address/port pairs\n"));
321
322 /* one loop to remove duplicates */
323 for ( i=0; i<count; i++ ) {
324 if ( is_zero_ip(iplist[i].ip) )
325 continue;
326
327 for ( j=i+1; j<count; j++ ) {
328 if ( ip_service_equal(iplist[i], iplist[j]) )
329 zero_ip(&iplist[j].ip);
330 }
331 }
332
333 /* one loop to clean up any holes we left */
334 /* first ip should never be a zero_ip() */
335 for (i = 0; i<count; ) {
336 if ( is_zero_ip(iplist[i].ip) ) {
337 if (i != count-1 )
338 memmove(&iplist[i], &iplist[i+1], (count - i - 1)*sizeof(iplist[i]));
339 count--;
340 continue;
341 }
342 i++;
343 }
344
345 return count;
346 }
347
348 /****************************************************************************
349 Do a netbios name query to find someones IP.
350 Returns an array of IP addresses or NULL if none.
351 *count will be set to the number of addresses returned.
352 *timed_out is set if we failed by timing out
353 ****************************************************************************/
354
355 struct in_addr *name_query(int fd,const char *name,int name_type,
356 BOOL bcast,BOOL recurse,
357 struct in_addr to_ip, int *count, int *flags,
358 BOOL *timed_out)
359 {
360 BOOL found=False;
361 int i, retries = 3;
362 int retry_time = bcast?250:2000;
363 struct timeval tval;
364 struct packet_struct p;
365 struct packet_struct *p2;
366 struct nmb_packet *nmb = &p.packet.nmb;
367 struct in_addr *ip_list = NULL;
368
369 if (lp_disable_netbios()) {
370 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n", name, name_type));
371 return NULL;
372 }
373
374 if (timed_out) {
375 *timed_out = False;
376 }
377
378 memset((char *)&p,'\0',sizeof(p));
379 (*count) = 0;
380 (*flags) = 0;
381
382 nmb->header.name_trn_id = generate_trn_id();
383 nmb->header.opcode = 0;
384 nmb->header.response = False;
385 nmb->header.nm_flags.bcast = bcast;
386 nmb->header.nm_flags.recursion_available = False;
387 nmb->header.nm_flags.recursion_desired = recurse;
388 nmb->header.nm_flags.trunc = False;
389 nmb->header.nm_flags.authoritative = False;
390 nmb->header.rcode = 0;
391 nmb->header.qdcount = 1;
392 nmb->header.ancount = 0;
393 nmb->header.nscount = 0;
394 nmb->header.arcount = 0;
395
396 make_nmb_name(&nmb->question.question_name,name,name_type);
397
398 nmb->question.question_type = 0x20;
399 nmb->question.question_class = 0x1;
400
401 p.ip = to_ip;
402 p.port = NMB_PORT;
403 p.fd = fd;
404 p.timestamp = time(NULL);
405 p.packet_type = NMB_PACKET;
406
407 GetTimeOfDay(&tval);
408
409 if (!send_packet(&p))
410 return NULL;
411
412 retries--;
413
414 while (1) {
415 struct timeval tval2;
416 struct in_addr *tmp_ip_list;
417
418 GetTimeOfDay(&tval2);
419 if (TvalDiff(&tval,&tval2) > retry_time) {
420 if (!retries)
421 break;
422 if (!found && !send_packet(&p))
423 return NULL;
424 GetTimeOfDay(&tval);
425 retries--;
426 }
427
428 if ((p2=receive_nmb_packet(fd,90,nmb->header.name_trn_id))) {
429 struct nmb_packet *nmb2 = &p2->packet.nmb;
430 debug_nmb_packet(p2);
431
432 /* If we get a Negative Name Query Response from a WINS
433 * server, we should report it and give up.
434 */
435 if( 0 == nmb2->header.opcode /* A query response */
436 && !(bcast) /* from a WINS server */
437 && nmb2->header.rcode /* Error returned */
438 ) {
439
440 if( DEBUGLVL( 3 ) ) {
441 /* Only executed if DEBUGLEVEL >= 3 */
442 dbgtext( "Negative name query response, rcode 0x%02x: ", nmb2->header.rcode );
443 switch( nmb2->header.rcode ) {
444 case 0x01:
445 dbgtext( "Request was invalidly formatted.\n" );
446 break;
447 case 0x02:
448 dbgtext( "Problem with NBNS, cannot process name.\n");
449 break;
450 case 0x03:
451 dbgtext( "The name requested does not exist.\n" );
452 break;
453 case 0x04:
454 dbgtext( "Unsupported request error.\n" );
455 break;
456 case 0x05:
457 dbgtext( "Query refused error.\n" );
458 break;
459 default:
460 dbgtext( "Unrecognized error code.\n" );
461 break;
462 }
463 }
464 free_packet(p2);
465 return( NULL );
466 }
467
468 if (nmb2->header.opcode != 0 ||
469 nmb2->header.nm_flags.bcast ||
470 nmb2->header.rcode ||
471 !nmb2->header.ancount) {
472 /*
473 * XXXX what do we do with this? Could be a
474 * redirect, but we'll discard it for the
475 * moment.
476 */
477 free_packet(p2);
478 continue;
479 }
480
481 tmp_ip_list = (struct in_addr *)Realloc( ip_list, sizeof( ip_list[0] )
482 * ( (*count) + nmb2->answers->rdlength/6 ) );
483
484 if (!tmp_ip_list) {
485 DEBUG(0,("name_query: Realloc failed.\n"));
486 SAFE_FREE(ip_list);
487 }
488
489 ip_list = tmp_ip_list;
490
491 if (ip_list) {
492 DEBUG(2,("Got a positive name query response from %s ( ", inet_ntoa(p2->ip)));
493 for (i=0;i<nmb2->answers->rdlength/6;i++) {
494 putip((char *)&ip_list[(*count)],&nmb2->answers->rdata[2+i*6]);
495 DEBUGADD(2,("%s ",inet_ntoa(ip_list[(*count)])));
496 (*count)++;
497 }
498 DEBUGADD(2,(")\n"));
499 }
500
501 found=True;
502 retries=0;
503 /* We add the flags back ... */
504 if (nmb2->header.response)
505 (*flags) |= NM_FLAGS_RS;
506 if (nmb2->header.nm_flags.authoritative)
507 (*flags) |= NM_FLAGS_AA;
508 if (nmb2->header.nm_flags.trunc)
509 (*flags) |= NM_FLAGS_TC;
510 if (nmb2->header.nm_flags.recursion_desired)
511 (*flags) |= NM_FLAGS_RD;
512 if (nmb2->header.nm_flags.recursion_available)
513 (*flags) |= NM_FLAGS_RA;
514 if (nmb2->header.nm_flags.bcast)
515 (*flags) |= NM_FLAGS_B;
516 free_packet(p2);
517 /*
518 * If we're doing a unicast lookup we only
519 * expect one reply. Don't wait the full 2
520 * seconds if we got one. JRA.
521 */
522 if(!bcast && found)
523 break;
524 }
525 }
526
527 /* only set timed_out if we didn't fund what we where looking for*/
528
529 if ( !found && timed_out ) {
530 *timed_out = True;
531 }
532
533 /* sort the ip list so we choose close servers first if possible */
534 sort_ip_list(ip_list, *count);
535
536 return ip_list;
537 }
538
539 /********************************************************
540 Start parsing the lmhosts file.
541 *********************************************************/
542
543 XFILE *startlmhosts(char *fname)
544 {
545 XFILE *fp = x_fopen(fname,O_RDONLY, 0);
546 if (!fp) {
547 DEBUG(4,("startlmhosts: Can't open lmhosts file %s. Error was %s\n",
548 fname, strerror(errno)));
549 return NULL;
550 }
551 return fp;
552 }
553
554 /********************************************************
555 Parse the next line in the lmhosts file.
556 *********************************************************/
557
558 BOOL getlmhostsent( XFILE *fp, pstring name, int *name_type, struct in_addr *ipaddr)
559 {
560 pstring line;
561
562 while(!x_feof(fp) && !x_ferror(fp)) {
563 pstring ip,flags,extra;
564 const char *ptr;
565 char *ptr1;
566 int count = 0;
567
568 *name_type = -1;
569
570 if (!fgets_slash(line,sizeof(pstring),fp)) {
571 continue;
572 }
573
574 if (*line == '#') {
575 continue;
576 }
577
578 pstrcpy(ip,"");
579 pstrcpy(name,"");
580 pstrcpy(flags,"");
581
582 ptr = line;
583
584 if (next_token(&ptr,ip ,NULL,sizeof(ip)))
585 ++count;
586 if (next_token(&ptr,name ,NULL, sizeof(pstring)))
587 ++count;
588 if (next_token(&ptr,flags,NULL, sizeof(flags)))
589 ++count;
590 if (next_token(&ptr,extra,NULL, sizeof(extra)))
591 ++count;
592
593 if (count <= 0)
594 continue;
595
596 if (count > 0 && count < 2) {
597 DEBUG(0,("getlmhostsent: Ill formed hosts line [%s]\n",line));
598 continue;
599 }
600
601 if (count >= 4) {
602 DEBUG(0,("getlmhostsent: too many columns in lmhosts file (obsolete syntax)\n"));
603 continue;
604 }
605
606 DEBUG(4, ("getlmhostsent: lmhost entry: %s %s %s\n", ip, name, flags));
607
608 if (strchr_m(flags,'G') || strchr_m(flags,'S')) {
609 DEBUG(0,("getlmhostsent: group flag in lmhosts ignored (obsolete)\n"));
610 continue;
611 }
612
613 *ipaddr = *interpret_addr2(ip);
614
615 /* Extra feature. If the name ends in '#XX', where XX is a hex number,
616 then only add that name type. */
617 if((ptr1 = strchr_m(name, '#')) != NULL) {
618 char *endptr;
619 ptr1++;
620
621 *name_type = (int)strtol(ptr1, &endptr, 16);
622 if(!*ptr1 || (endptr == ptr1)) {
623 DEBUG(0,("getlmhostsent: invalid name %s containing '#'.\n", name));
624 continue;
625 }
626
627 *(--ptr1) = '\0'; /* Truncate at the '#' */
628 }
629
630 return True;
631 }
632
633 return False;
634 }
635
636 /********************************************************
637 Finish parsing the lmhosts file.
638 *********************************************************/
639
640 void endlmhosts(XFILE *fp)
641 {
642 x_fclose(fp);
643 }
644
645 /********************************************************
646 convert an array if struct in_addrs to struct ip_service
647 return False on failure. Port is set to PORT_NONE;
648 *********************************************************/
649
650 static BOOL convert_ip2service( struct ip_service **return_iplist, struct in_addr *ip_list, int count )
651 {
652 int i;
653
654 if ( count==0 || !ip_list )
655 return False;
656
657 /* copy the ip address; port will be PORT_NONE */
658 if ( (*return_iplist = (struct ip_service*)malloc(count*sizeof(struct ip_service))) == NULL ) {
659 DEBUG(0,("convert_ip2service: malloc failed for %d enetries!\n", count ));
660 return False;
661 }
662
663 for ( i=0; i<count; i++ ) {
664 (*return_iplist)[i].ip = ip_list[i];
665 (*return_iplist)[i].port = PORT_NONE;
666 }
667
668 return True;
669 }
670 /********************************************************
671 Resolve via "bcast" method.
672 *********************************************************/
673
674 BOOL name_resolve_bcast(const char *name, int name_type,
675 struct ip_service **return_iplist, int *return_count)
676 {
677 int sock, i;
678 int num_interfaces = iface_count();
679 struct in_addr *ip_list;
680 BOOL ret;
681
682 if (lp_disable_netbios()) {
683 DEBUG(5,("name_resolve_bcast(%s#%02x): netbios is disabled\n", name, name_type));
684 return False;
685 }
686
687 *return_iplist = NULL;
688 *return_count = 0;
689
690 /*
691 * "bcast" means do a broadcast lookup on all the local interfaces.
692 */
693
694 DEBUG(3,("name_resolve_bcast: Attempting broadcast lookup for name %s<0x%x>\n", name, name_type));
695
696 sock = open_socket_in( SOCK_DGRAM, 0, 3,
697 interpret_addr(lp_socket_address()), True );
698
699 if (sock == -1) return False;
700
701 set_socket_options(sock,"SO_BROADCAST");
702 /*
703 * Lookup the name on all the interfaces, return on
704 * the first successful match.
705 */
706 for( i = num_interfaces-1; i >= 0; i--) {
707 struct in_addr sendto_ip;
708 int flags;
709 /* Done this way to fix compiler error on IRIX 5.x */
710 sendto_ip = *iface_n_bcast(i);
711 ip_list = name_query(sock, name, name_type, True,
712 True, sendto_ip, return_count, &flags, NULL);
713 if( ip_list )
714 goto success;
715 }
716
717 /* failed - no response */
718
719 close(sock);
720 return False;
721
722 success:
723 ret = True;
724 if ( !convert_ip2service(return_iplist, ip_list, *return_count) )
725 ret = False;
726
727 SAFE_FREE( ip_list );
728 close(sock);
729 return ret;
730 }
731
732 /********************************************************
733 Resolve via "wins" method.
734 *********************************************************/
735
736 BOOL resolve_wins(const char *name, int name_type,
737 struct ip_service **return_iplist, int *return_count)
738 {
739 int sock, t, i;
740 char **wins_tags;
741 struct in_addr src_ip, *ip_list = NULL;
742 BOOL ret;
743
744 if (lp_disable_netbios()) {
745 DEBUG(5,("resolve_wins(%s#%02x): netbios is disabled\n", name, name_type));
746 return False;
747 }
748
749 *return_iplist = NULL;
750 *return_count = 0;
751
752 DEBUG(3,("resolve_wins: Attempting wins lookup for name %s<0x%x>\n", name, name_type));
753
754 if (wins_srv_count() < 1) {
755 DEBUG(3,("resolve_wins: WINS server resolution selected and no WINS servers listed.\n"));
756 return False;
757 }
758
759 /* we try a lookup on each of the WINS tags in turn */
760 wins_tags = wins_srv_tags();
761
762 if (!wins_tags) {
763 /* huh? no tags?? give up in disgust */
764 return False;
765 }
766
767 /* the address we will be sending from */
768 src_ip = *interpret_addr2(lp_socket_address());
769
770 /* in the worst case we will try every wins server with every
771 tag! */
772 for (t=0; wins_tags && wins_tags[t]; t++) {
773 int srv_count = wins_srv_count_tag(wins_tags[t]);
774 for (i=0; i<srv_count; i++) {
775 struct in_addr wins_ip;
776 int flags;
777 BOOL timed_out;
778
779 wins_ip = wins_srv_ip_tag(wins_tags[t], src_ip);
780
781 if (global_in_nmbd && ismyip(wins_ip)) {
782 /* yikes! we'll loop forever */
783 continue;
784 }
785
786 /* skip any that have been unresponsive lately */
787 if (wins_srv_is_dead(wins_ip, src_ip)) {
788 continue;
789 }
790
791 DEBUG(3,("resolve_wins: using WINS server %s and tag '%s'\n", inet_ntoa(wins_ip), wins_tags[t]));
792
793 sock = open_socket_in(SOCK_DGRAM, 0, 3, src_ip.s_addr, True);
794 if (sock == -1) {
795 continue;
796 }
797
798 ip_list = name_query(sock,name,name_type, False,
799 True, wins_ip, return_count, &flags,
800 &timed_out);
801
802 /* exit loop if we got a list of addresses */
803
804 if ( ip_list )
805 goto success;
806
807 close(sock);
808
809 if (timed_out) {
810 /* Timed out wating for WINS server to respond. Mark it dead. */
811 wins_srv_died(wins_ip, src_ip);
812 } else {
813 /* The name definately isn't in this
814 group of WINS servers. goto the next group */
815 break;
816 }
817 }
818 }
819
820 wins_srv_tags_free(wins_tags);
821 return False;
822
823 success:
824 ret = True;
825 if ( !convert_ip2service( return_iplist, ip_list, *return_count ) )
826 ret = False;
827
828 SAFE_FREE( ip_list );
829 wins_srv_tags_free(wins_tags);
830 close(sock);
831
832 return ret;
833 }
834
835 /********************************************************
836 Resolve via "lmhosts" method.
837 *********************************************************/
838
839 static BOOL resolve_lmhosts(const char *name, int name_type,
840 struct ip_service **return_iplist, int *return_count)
841 {
842 /*
843 * "lmhosts" means parse the local lmhosts file.
844 */
845
846 XFILE *fp;
847 pstring lmhost_name;
848 int name_type2;
849 struct in_addr return_ip;
850
851 *return_iplist = NULL;
852 *return_count = 0;
853
854 DEBUG(3,("resolve_lmhosts: Attempting lmhosts lookup for name %s<0x%x>\n", name, name_type));
855
856 fp = startlmhosts(dyn_LMHOSTSFILE);
857 if(fp) {
858 while (getlmhostsent(fp, lmhost_name, &name_type2, &return_ip)) {
859 if (strequal(name, lmhost_name) &&
860 ((name_type2 == -1) || (name_type == name_type2))
861 ) {
862 endlmhosts(fp);
863 if ( (*return_iplist = (struct ip_service *)malloc(sizeof(struct ip_service))) == NULL ) {
864 DEBUG(3,("resolve_lmhosts: malloc fail !\n"));
865 return False;
866 }
867 (*return_iplist)[0].ip = return_ip;
868 (*return_iplist)[0].port = PORT_NONE;
869 *return_count = 1;
870 return True;
871 }
872 }
873 endlmhosts(fp);
874 }
875 return False;
876 }
877
878
879 /********************************************************
880 Resolve via "hosts" method.
881 *********************************************************/
882
883 static BOOL resolve_hosts(const char *name, int name_type,
884 struct ip_service **return_iplist, int *return_count)
885 {
886 /*
887 * "host" means do a localhost, or dns lookup.
888 */
889 struct hostent *hp;
890
891 if ( name_type != 0x20 && name_type != 0x0) {
892 DEBUG(5, ("resolve_hosts: not appropriate for name type <0x%x>\n", name_type));
893 return False;
894 }
895
896 *return_iplist = NULL;
897 *return_count = 0;
898
899 DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n", name, name_type));
900
901 if (((hp = sys_gethostbyname(name)) != NULL) && (hp->h_addr != NULL)) {
902 struct in_addr return_ip;
903 putip((char *)&return_ip,(char *)hp->h_addr);
904 *return_iplist = (struct ip_service *)malloc(sizeof(struct ip_service));
905 if(*return_iplist == NULL) {
906 DEBUG(3,("resolve_hosts: malloc fail !\n"));
907 return False;
908 }
909 (*return_iplist)->ip = return_ip;
910 (*return_iplist)->port = PORT_NONE;
911 *return_count = 1;
912 return True;
913 }
914 return False;
915 }
916
917 /********************************************************
918 Resolve via "ADS" method.
919 *********************************************************/
920
921 static BOOL resolve_ads(const char *name, int name_type,
922 struct ip_service **return_iplist, int *return_count)
923 {
924
925 #ifdef HAVE_ADS
926 if ( name_type == 0x1c ) {
927 int count, i = 0;
928 char *list = NULL;
929 const char *ptr;
930 pstring tok;
931
932 /* try to lookup the _ldap._tcp.<domain> if we are using ADS */
933 if ( lp_security() != SEC_ADS )
934 return False;
935
936 DEBUG(5,("resolve_hosts: Attempting to resolve DC's for %s using DNS\n",
937 name));
938
939 if (ldap_domain2hostlist(name, &list) != LDAP_SUCCESS)
940 return False;
941
942 count = count_chars(list, ' ') + 1;
943 if ( (*return_iplist = malloc(count * sizeof(struct ip_service))) == NULL ) {
944 DEBUG(0,("resolve_hosts: malloc failed for %d entries\n", count ));
945 return False;
946 }
947
948 ptr = list;
949 while (next_token(&ptr, tok, " ", sizeof(tok))) {
950 unsigned port = LDAP_PORT;
951 char *p = strchr(tok, ':');
952 if (p) {
953 *p = 0;
954 port = atoi(p+1);
955 }
956 (*return_iplist)[i].ip = *interpret_addr2(tok);
957 (*return_iplist)[i].port = port;
958
959 /* make sure it is a valid IP. I considered checking the negative
960 connection cache, but this is the wrong place for it. Maybe only
961 as a hac. After think about it, if all of the IP addresses retuend
962 from DNS are dead, what hope does a netbios name lookup have?
963 The standard reason for falling back to netbios lookups is that
964 our DNS server doesn't know anything about the DC's -- jerry */
965
966 if ( is_zero_ip((*return_iplist)[i].ip) )
967 continue;
968
969 i++;
970 }
971 SAFE_FREE(list);
972
973 *return_count = i;
974
975 return True;
976 } else
977 #endif /* HAVE_ADS */
978 {
979 return False;
980 }
981 }
982
983 /*******************************************************************
984 Internal interface to resolve a name into an IP address.
985 Use this function if the string is either an IP address, DNS
986 or host name or NetBIOS name. This uses the name switch in the
987 smb.conf to determine the order of name resolution.
988
989 Added support for ip addr/port to support ADS ldap servers.
990 the only place we currently care about the port is in the
991 resolve_hosts() when looking up DC's via SRV RR entries in DNS
992 **********************************************************************/
993
994 static BOOL internal_resolve_name(const char *name, int name_type,
995 struct ip_service **return_iplist,
996 int *return_count, const char *resolve_order)
997 {
998 pstring name_resolve_list;
999 fstring tok;
1000 const char *ptr;
1001 BOOL allones = (strcmp(name,"255.255.255.255") == 0);
1002 BOOL allzeros = (strcmp(name,"0.0.0.0") == 0);
1003 BOOL is_address = is_ipaddress(name);
1004 BOOL result = False;
1005 int i;
1006
1007 *return_iplist = NULL;
1008 *return_count = 0;
1009
1010 DEBUG(10, ("internal_resolve_name: looking up %s#%x\n", name, name_type));
1011
1012 if (allzeros || allones || is_address) {
1013
1014 if ( (*return_iplist = (struct ip_service *)malloc(sizeof(struct ip_service))) == NULL ) {
1015 DEBUG(0,("internal_resolve_name: malloc fail !\n"));
1016 return False;
1017 }
1018
1019 if(is_address) {
1020 /* ignore the port here */
1021 (*return_iplist)->port = PORT_NONE;
1022
1023 /* if it's in the form of an IP address then get the lib to interpret it */
1024 if (((*return_iplist)->ip.s_addr = inet_addr(name)) == 0xFFFFFFFF ){
1025 DEBUG(1,("internal_resolve_name: inet_addr failed on %s\n", name));
1026 return False;
1027 }
1028 } else {
1029 (*return_iplist)->ip.s_addr = allones ? 0xFFFFFFFF : 0;
1030 }
1031 *return_count = 1;
1032 return True;
1033 }
1034
1035 /* Check name cache */
1036
1037 if (namecache_fetch(name, name_type, return_iplist, return_count)) {
1038 /* This could be a negative response */
1039 return (*return_count > 0);
1040 }
1041
1042 /* set the name resolution order */
1043
1044 if ( strcmp( resolve_order, "NULL") == 0 ) {
1045 DEBUG(8,("internal_resolve_name: all lookups disabled\n"));
1046 return False;
1047 }
1048
1049 if ( !resolve_order ) {
1050 pstrcpy(name_resolve_list, lp_name_resolve_order());
1051 } else {
1052 pstrcpy(name_resolve_list, resolve_order);
1053
1054 if ( !name_resolve_list[0] ) {
1055 ptr = "host";
1056 } else {
1057 ptr = name_resolve_list;
1058 }
1059
1060 /* iterate through the name resolution backends */
1061
1062 while (next_token(&ptr, tok, LIST_SEP, sizeof(tok))) {
1063 if((strequal(tok, "host") || strequal(tok, "hosts"))) {
1064 if (resolve_hosts(name, name_type, return_iplist, return_count)) {
1065 result = True;
1066 goto done;
1067 }
1068 } else if(strequal( tok, "ads")) {
1069 /* deal with 0x1c names here. This will result in a
1070 SRV record lookup for _ldap._tcp.<domain> if we
1071 are using 'security = ads' */
1072 if (resolve_ads(name, name_type, return_iplist, return_count)) {
1073 result = True;
1074 goto done;
1075 }
1076 } else if(strequal( tok, "lmhosts")) {
1077 if (resolve_lmhosts(name, name_type, return_iplist, return_count)) {
1078 result = True;
1079 goto done;
1080 }
1081 } else if(strequal( tok, "wins")) {
1082 /* don't resolve 1D via WINS */
1083 if (name_type != 0x1D && resolve_wins(name, name_type, return_iplist, return_count)) {
1084 result = True;
1085 goto done;
1086 }
1087 } else if(strequal( tok, "bcast")) {
1088 if (name_resolve_bcast(name, name_type, return_iplist, return_count)) {
1089 result = True;
1090 goto done;
1091 }
1092 } else {
1093 DEBUG(0,("resolve_name: unknown name switch type %s\n", tok));
1094 }
1095 }
1096
1097 /* All of the resolve_* functions above have returned false. */
1098
1099 SAFE_FREE(*return_iplist);
1100 *return_count = 0;
1101
1102 return False;
1103
1104 done:
1105
1106 /* Remove duplicate entries. Some queries, notably #1c (domain
1107 controllers) return the PDC in iplist[0] and then all domain
1108 controllers including the PDC in iplist[1..n]. Iterating over
1109 the iplist when the PDC is down will cause two sets of timeouts. */
1110
1111 if ( *return_count ) {
1112 *return_count = remove_duplicate_addrs2( *return_iplist, *return_count );
1113 }
1114
1115 /* Save in name cache */
1116 if ( DEBUGLEVEL >= 100 ) {
1117 for (i = 0; i < *return_count && DEBUGLEVEL == 100; i++)
1118 DEBUG(100, ("Storing name %s of type %d (%s:%d)\n", name,
1119 name_type, inet_ntoa((*return_iplist)[i].ip), (*return_iplist)[i].port));
1120 }
1121
1122 namecache_store(name, name_type, *return_count, *return_iplist);
1123
1124 /* Display some debugging info */
1125
1126 if ( DEBUGLEVEL >= 10 ) {
1127 DEBUG(10, ("internal_resolve_name: returning %d addresses: ", *return_count));
1128
1129 for (i = 0; i < *return_count; i++) {
1130 DEBUGADD(10, ("%s:%d ", inet_ntoa((*return_iplist)[i].ip), (*return_iplist)[i].port));
1131 }
1132 DEBUG(10, ("\n"));
1133 }
1134 }
1135
1136 return result;
1137 }
1138
1139 /********************************************************
1140 Internal interface to resolve a name into one IP address.
1141 Use this function if the string is either an IP address, DNS
1142 or host name or NetBIOS name. This uses the name switch in the
1143 smb.conf to determine the order of name resolution.
1144 *********************************************************/
1145
1146 BOOL resolve_name(const char *name, struct in_addr *return_ip, int name_type)
1147 {
1148 struct ip_service *ip_list = NULL;
1149 int count = 0;
1150
1151 if (is_ipaddress(name)) {
1152 *return_ip = *interpret_addr2(name);
1153 return True;
1154 }
1155
1156 if (internal_resolve_name(name, name_type, &ip_list, &count, lp_name_resolve_order())) {
1157 int i;
1158
1159 /* only return valid addresses for TCP connections */
1160 for (i=0; i<count; i++) {
1161 char *ip_str = inet_ntoa(ip_list[i].ip);
1162 if (ip_str &&
1163 strcmp(ip_str, "255.255.255.255") != 0 &&
1164 strcmp(ip_str, "0.0.0.0") != 0)
1165 {
1166 *return_ip = ip_list[i].ip;
1167 SAFE_FREE(ip_list);
1168 return True;
1169 }
1170 }
1171 }
1172
1173 SAFE_FREE(ip_list);
1174 return False;
1175 }
1176
1177 /********************************************************
1178 Find the IP address of the master browser or DMB for a workgroup.
1179 *********************************************************/
1180
1181 BOOL find_master_ip(const char *group, struct in_addr *master_ip)
1182 {
1183 struct ip_service *ip_list = NULL;
1184 int count = 0;
1185
1186 if (lp_disable_netbios()) {
1187 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group));
1188 return False;
1189 }
1190
1191 if (internal_resolve_name(group, 0x1D, &ip_list, &count, lp_name_resolve_order())) {
1192 *master_ip = ip_list[0].ip;
1193 SAFE_FREE(ip_list);
1194 return True;
1195 }
1196 if(internal_resolve_name(group, 0x1B, &ip_list, &count, lp_name_resolve_order())) {
1197 *master_ip = ip_list[0].ip;
1198 SAFE_FREE(ip_list);
1199 return True;
1200 }
1201
1202 SAFE_FREE(ip_list);
1203 return False;
1204 }
1205
1206 /********************************************************
1207 Get the IP address list of the primary domain controller
1208 for a domain.
1209 *********************************************************/
1210
1211 BOOL get_pdc_ip(const char *domain, struct in_addr *ip)
1212 {
1213 struct ip_service *ip_list;
1214 int count;
1215
1216 /* Look up #1B name */
1217
1218 if (!internal_resolve_name(domain, 0x1b, &ip_list, &count, lp_name_resolve_order())) {
1219 return False;
1220 }
1221
1222 /* if we get more than 1 IP back we have to assume it is a
1223 multi-homed PDC and not a mess up */
1224
1225 if ( count > 1 ) {
1226 DEBUG(6,("get_pdc_ip: PDC has %d IP addresses!\n", count));
1227 sort_ip_list2( ip_list, count );
1228 }
1229
1230 *ip = ip_list[0].ip;
1231
1232 SAFE_FREE(ip_list);
1233
1234 return True;
1235 }
1236
1237 /********************************************************
1238 Get the IP address list of the domain controllers for
1239 a domain.
1240 *********************************************************/
1241
1242 static BOOL get_dc_list(const char *domain, struct ip_service **ip_list,
1243 int *count, BOOL ads_only, int *ordered)
1244 {
1245 fstring resolve_order;
1246
1247 /* if we are restricted to solely using DNS for looking
1248 up a domain controller, make sure that host lookups
1249 are enabled for the 'name resolve order'. If host lookups
1250 are disabled and ads_only is True, then set the string to
1251 NULL. */
1252
1253 fstrcpy( resolve_order, lp_name_resolve_order() );
1254 strlower_m( resolve_order );
1255 if ( ads_only ) {
1256 if ( strstr( resolve_order, "host" ) )
1257 fstrcpy( resolve_order, "ads" );
1258 else
1259 fstrcpy( resolve_order, "NULL" );
1260 }
1261
1262
1263 *ordered = False;
1264
1265 /* If it's our domain then use the 'password server' parameter. */
1266
1267 if ( strequal(domain, lp_workgroup()) || strequal(domain, lp_realm()) ) {
1268 const char *p;
1269 char *pserver = lp_passwordserver(); /* UNIX charset. */
1270 char *port_str;
1271 int port;
1272 fstring name;
1273 int num_addresses = 0;
1274 int local_count, i, j;
1275 struct ip_service *return_iplist = NULL;
1276 struct ip_service *auto_ip_list = NULL;
1277 BOOL done_auto_lookup = False;
1278 int auto_count = 0;
1279
1280
1281 if (!*pserver)
1282 return internal_resolve_name(domain, 0x1C, ip_list, count, resolve_order);
1283
1284 p = pserver;
1285
1286 /*
1287 * if '*' appears in the "password server" list then add
1288 * an auto lookup to the list of manually configured
1289 * DC's. If any DC is listed by name, then the list should be
1290 * considered to be ordered
1291 */
1292
1293 while (next_token(&p,name,LIST_SEP,sizeof(name))) {
1294 if (strequal(name, "*")) {
1295 if ( internal_resolve_name(domain, 0x1C, &auto_ip_list, &auto_count, resolve_order) )
1296 num_addresses += auto_count;
1297 done_auto_lookup = True;
1298 DEBUG(8,("Adding %d DC's from auto lookup\n", auto_count));
1299 } else {
1300 num_addresses++;
1301 }
1302 }
1303
1304 /* if we have no addresses and haven't done the auto lookup, then
1305 just return the list of DC's */
1306
1307 if ( (num_addresses == 0) && !done_auto_lookup ) {
1308 return internal_resolve_name(domain, 0x1C, ip_list, count, resolve_order);
1309 }
1310
1311 /* maybe we just failed? */
1312
1313 if ( num_addresses == 0 ) {
1314 DEBUG(4,("get_dc_list: no servers found\n"));
1315 return False;
1316 }
1317
1318 if ( (return_iplist = (struct ip_service *)
1319 malloc(num_addresses * sizeof(struct ip_service))) == NULL ) {
1320 DEBUG(3,("get_dc_list: malloc fail !\n"));
1321 return False;
1322 }
1323
1324 p = pserver;
1325 local_count = 0;
1326
1327 /* fill in the return list now with real IP's */
1328
1329 while ( (local_count<num_addresses) && next_token(&p,name,LIST_SEP,sizeof(name)) ) {
1330 struct in_addr name_ip;
1331
1332 /* copy any addersses from the auto lookup */
1333
1334 if ( strequal(name, "*") ) {
1335 for ( j=0; j<auto_count; j++ ) {
1336 /* Check for and don't copy any known bad DC IP's. */
1337 if(!NT_STATUS_IS_OK(check_negative_conn_cache(domain,
1338 inet_ntoa(auto_ip_list[j].ip)))) {
1339 DEBUG(5,("get_dc_list: negative entry %s removed from DC list\n",
1340 inet_ntoa(auto_ip_list[j].ip) ));
1341 continue;
1342 }
1343 return_iplist[local_count].ip = auto_ip_list[j].ip;
1344 return_iplist[local_count].port = auto_ip_list[j].port;
1345 local_count++;
1346 }
1347 continue;
1348 }
1349
1350
1351 /* added support for address:port syntax for ads (not that I think
1352 anyone will ever run the LDAP server in an AD domain on something
1353 other than port 389 */
1354
1355 port = (lp_security() == SEC_ADS) ? LDAP_PORT : PORT_NONE;
1356 if ( (port_str=strchr(name, ':')) != NULL ) {
1357 *port_str = '\0';
1358 port_str++;
1359 port = atoi( port_str );
1360 }
1361
1362 /* explicit lookup; resolve_name() will handle names & IP addresses */
1363 if ( resolve_name( name, &name_ip, 0x20 ) ) {
1364
1365 /* Check for and don't copy any known bad DC IP's. */
1366 if( !NT_STATUS_IS_OK(check_negative_conn_cache(domain, inet_ntoa(name_ip))) ) {
1367 DEBUG(5,("get_dc_list: negative entry %s removed from DC list\n",name ));
1368 continue;
1369 }
1370
1371 return_iplist[local_count].ip = name_ip;
1372 return_iplist[local_count].port = port;
1373 local_count++;
1374 *ordered = True;
1375 }
1376 }
1377
1378 SAFE_FREE(auto_ip_list);
1379
1380 /* need to remove duplicates in the list if we have any
1381 explicit password servers */
1382
1383 if ( local_count ) {
1384 local_count = remove_duplicate_addrs2( return_iplist, local_count );
1385 }
1386
1387 if ( DEBUGLEVEL >= 4 ) {
1388 DEBUG(4,("get_dc_list: returning %d ip addresses in an %sordered list\n", local_count,
1389 *ordered ? "":"un"));
1390 DEBUG(4,("get_dc_list: "));
1391 for ( i=0; i<local_count; i++ )
1392 DEBUGADD(4,("%s:%d ", inet_ntoa(return_iplist[i].ip), return_iplist[i].port ));
1393 DEBUGADD(4,("\n"));
1394 }
1395
1396 *ip_list = return_iplist;
1397 *count = local_count;
1398
1399 return (*count != 0);
1400 }
1401
1402 DEBUG(10,("get_dc_list: defaulting to internal auto lookup for domain %s\n", domain));
1403
1404 return internal_resolve_name(domain, 0x1C, ip_list, count, resolve_order);
1405 }
1406
1407 /*********************************************************************
1408 Small wrapper function to get the DC list and sort it if neccessary.
1409 *********************************************************************/
1410
1411 BOOL get_sorted_dc_list( const char *domain, struct ip_service **ip_list, int *count, BOOL ads_only )
1412 {
1413 BOOL ordered;
1414
1415 DEBUG(8,("get_sorted_dc_list: attempting lookup using [%s]\n",
1416 (ads_only ? "ads" : lp_name_resolve_order())));
1417
1418 if ( !get_dc_list(domain, ip_list, count, ads_only, &ordered) ) {
1419 return False;
1420 }
1421
1422 /* only sort if we don't already have an ordered list */
1423 if ( !ordered ) {
1424 sort_ip_list2( *ip_list, *count );
1425 }
1426
1427 return True;
1428 }
Samba GIT mirror