source3/libsmb/namequery.c

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