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