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         int                     i = 0;
1028         NTSTATUS                status;
1029         TALLOC_CTX              *ctx;
1030         struct dns_rr_srv       *dcs = NULL;
1031         int                     numdcs = 0;
1032
1033         if ( name_type != 0x1c )
1034                 return False;
1035
1036         DEBUG(5,("resolve_hosts: Attempting to resolve DC's for %s using DNS\n",
1037                 name));
1038
1039         if ( (ctx = talloc_init("resolve_ads")) == NULL ) {
1040                 DEBUG(0,("resolve_ads: talloc_init() failed!\n"));
1041                 return False;
1042         }
1043
1044         status = ads_dns_query_dcs( ctx, name, &dcs, &numdcs );
1045         if ( !NT_STATUS_IS_OK( status ) ) {
1046                 return False;
1047         }
1048
1049         if ( (*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, numdcs)) == NULL ) {
1050                 DEBUG(0,("resolve_ads: malloc failed for %d entries\n", numdcs ));
1051                 return False;
1052         }
1053
1054         i = 0;
1055         while ( i < numdcs ) {
1056
1057                 /* use the IP address from the SRV structure if we have one */
1058                 if ( is_zero_ip( dcs[i].ip ) )
1059                         (*return_iplist)[i].ip   = *interpret_addr2(dcs[i].hostname);
1060                 else
1061                         (*return_iplist)[i].ip = dcs[i].ip;
1062
1063                 (*return_iplist)[i].port = dcs[i].port;
1064
1065                 /* make sure it is a valid IP.  I considered checking the negative
1066                    connection cache, but this is the wrong place for it.  Maybe only
1067                    as a hac.  After think about it, if all of the IP addresses retuend
1068                    from DNS are dead, what hope does a netbios name lookup have?
1069                    The standard reason for falling back to netbios lookups is that
1070                    our DNS server doesn't know anything about the DC's   -- jerry */
1071
1072                 if ( is_zero_ip((*return_iplist)[i].ip) )
1073                         continue;
1074
1075                 i++;
1076         }
1077
1078         TALLOC_FREE( dcs );
1079
1080         *return_count = i;
1081
1082         return True;
1083 }
1084
1085 /*******************************************************************
1086  Internal interface to resolve a name into an IP address.
1087  Use this function if the string is either an IP address, DNS
1088  or host name or NetBIOS name. This uses the name switch in the
1089  smb.conf to determine the order of name resolution.
1090
1091  Added support for ip addr/port to support ADS ldap servers.
1092  the only place we currently care about the port is in the
1093  resolve_hosts() when looking up DC's via SRV RR entries in DNS
1094 **********************************************************************/
1095
1096 BOOL internal_resolve_name(const char *name, int name_type,
1097                            struct ip_service **return_iplist,
1098                            int *return_count, const char *resolve_order)
1099 {
1100         pstring name_resolve_list;
1101         fstring tok;
1102         const char *ptr;
1103         BOOL allones = (strcmp(name,"255.255.255.255") == 0);
1104         BOOL allzeros = (strcmp(name,"0.0.0.0") == 0);
1105         BOOL is_address = is_ipaddress(name);
1106         BOOL result = False;
1107         int i;
1108
1109         *return_iplist = NULL;
1110         *return_count = 0;
1111
1112         DEBUG(10, ("internal_resolve_name: looking up %s#%x\n", name, name_type));
1113
1114         if (allzeros || allones || is_address) {
1115
1116                 if ( (*return_iplist = SMB_MALLOC_P(struct ip_service)) == NULL ) {
1117                         DEBUG(0,("internal_resolve_name: malloc fail !\n"));
1118                         return False;
1119                 }
1120
1121                 if(is_address) {
1122                         /* ignore the port here */
1123                         (*return_iplist)->port = PORT_NONE;
1124
1125                         /* if it's in the form of an IP address then get the lib to interpret it */
1126                         if (((*return_iplist)->ip.s_addr = inet_addr(name)) == 0xFFFFFFFF ){
1127                                 DEBUG(1,("internal_resolve_name: inet_addr failed on %s\n", name));
1128                                 SAFE_FREE(*return_iplist);
1129                                 return False;
1130                         }
1131                 } else {
1132                         (*return_iplist)->ip.s_addr = allones ? 0xFFFFFFFF : 0;
1133                 }
1134                 *return_count = 1;
1135                 return True;
1136         }
1137
1138         /* Check name cache */
1139
1140         if (namecache_fetch(name, name_type, return_iplist, return_count)) {
1141                 /* This could be a negative response */
1142                 return (*return_count > 0);
1143         }
1144
1145         /* set the name resolution order */
1146
1147         if ( strcmp( resolve_order, "NULL") == 0 ) {
1148                 DEBUG(8,("internal_resolve_name: all lookups disabled\n"));
1149                 return False;
1150         }
1151
1152         if ( !resolve_order ) {
1153                 pstrcpy(name_resolve_list, lp_name_resolve_order());
1154         } else {
1155                 pstrcpy(name_resolve_list, resolve_order);
1156
1157                 if ( !name_resolve_list[0] ) {
1158                         ptr = "host";
1159                 } else {
1160                         ptr = name_resolve_list;
1161                 }
1162
1163                 /* iterate through the name resolution backends */
1164
1165                 while (next_token(&ptr, tok, LIST_SEP, sizeof(tok))) {
1166                         if((strequal(tok, "host") || strequal(tok, "hosts"))) {
1167                                 if (resolve_hosts(name, name_type, return_iplist, return_count)) {
1168                                         result = True;
1169                                         goto done;
1170                                 }
1171                         } else if(strequal( tok, "ads")) {
1172                                 /* deal with 0x1c names here.  This will result in a
1173                                         SRV record lookup */
1174                                 if (resolve_ads(name, name_type, return_iplist, return_count)) {
1175                                         result = True;
1176                                         goto done;
1177                                 }
1178                         } else if(strequal( tok, "lmhosts")) {
1179                                 if (resolve_lmhosts(name, name_type, return_iplist, return_count)) {
1180                                         result = True;
1181                                         goto done;
1182                                 }
1183                         } else if(strequal( tok, "wins")) {
1184                                 /* don't resolve 1D via WINS */
1185                                 if (name_type != 0x1D && resolve_wins(name, name_type, return_iplist, return_count)) {
1186                                         result = True;
1187                                         goto done;
1188                                 }
1189                         } else if(strequal( tok, "bcast")) {
1190                                 if (name_resolve_bcast(name, name_type, return_iplist, return_count)) {
1191                                         result = True;
1192                                         goto done;
1193                                 }
1194                         } else {
1195                                 DEBUG(0,("resolve_name: unknown name switch type %s\n", tok));
1196                         }
1197                 }
1198
1199                 /* All of the resolve_* functions above have returned false. */
1200
1201                 SAFE_FREE(*return_iplist);
1202                 *return_count = 0;
1203
1204                 return False;
1205
1206   done:
1207
1208                 /* Remove duplicate entries.  Some queries, notably #1c (domain
1209                         controllers) return the PDC in iplist[0] and then all domain
1210                         controllers including the PDC in iplist[1..n].  Iterating over
1211                         the iplist when the PDC is down will cause two sets of timeouts. */
1212
1213                 if ( *return_count ) {
1214                         *return_count = remove_duplicate_addrs2( *return_iplist, *return_count );
1215                 }
1216
1217                 /* Save in name cache */
1218                 if ( DEBUGLEVEL >= 100 ) {
1219                         for (i = 0; i < *return_count && DEBUGLEVEL == 100; i++)
1220                                 DEBUG(100, ("Storing name %s of type %d (%s:%d)\n", name,
1221                                         name_type, inet_ntoa((*return_iplist)[i].ip), (*return_iplist)[i].port));
1222                 }
1223
1224                 namecache_store(name, name_type, *return_count, *return_iplist);
1225
1226                 /* Display some debugging info */
1227
1228                 if ( DEBUGLEVEL >= 10 ) {
1229                         DEBUG(10, ("internal_resolve_name: returning %d addresses: ", *return_count));
1230
1231                         for (i = 0; i < *return_count; i++) {
1232                                 DEBUGADD(10, ("%s:%d ", inet_ntoa((*return_iplist)[i].ip), (*return_iplist)[i].port));
1233                         }
1234                         DEBUG(10, ("\n"));
1235                 }
1236         }
1237
1238         return result;
1239 }
1240
1241 /********************************************************
1242  Internal interface to resolve a name into one IP address.
1243  Use this function if the string is either an IP address, DNS
1244  or host name or NetBIOS name. This uses the name switch in the
1245  smb.conf to determine the order of name resolution.
1246 *********************************************************/
1247
1248 BOOL resolve_name(const char *name, struct in_addr *return_ip, int name_type)
1249 {
1250         struct ip_service *ip_list = NULL;
1251         int count = 0;
1252
1253         if (is_ipaddress(name)) {
1254                 *return_ip = *interpret_addr2(name);
1255                 return True;
1256         }
1257
1258         if (internal_resolve_name(name, name_type, &ip_list, &count, lp_name_resolve_order())) {
1259                 int i;
1260
1261                 /* only return valid addresses for TCP connections */
1262                 for (i=0; i<count; i++) {
1263                         char *ip_str = inet_ntoa(ip_list[i].ip);
1264                         if (ip_str &&
1265                             strcmp(ip_str, "255.255.255.255") != 0 &&
1266                             strcmp(ip_str, "0.0.0.0") != 0)
1267                         {
1268                                 *return_ip = ip_list[i].ip;
1269                                 SAFE_FREE(ip_list);
1270                                 return True;
1271                         }
1272                 }
1273         }
1274
1275         SAFE_FREE(ip_list);
1276         return False;
1277 }
1278
1279 /********************************************************
1280  Find the IP address of the master browser or DMB for a workgroup.
1281 *********************************************************/
1282
1283 BOOL find_master_ip(const char *group, struct in_addr *master_ip)
1284 {
1285         struct ip_service *ip_list = NULL;
1286         int count = 0;
1287
1288         if (lp_disable_netbios()) {
1289                 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group));
1290                 return False;
1291         }
1292
1293         if (internal_resolve_name(group, 0x1D, &ip_list, &count, lp_name_resolve_order())) {
1294                 *master_ip = ip_list[0].ip;
1295                 SAFE_FREE(ip_list);
1296                 return True;
1297         }
1298         if(internal_resolve_name(group, 0x1B, &ip_list, &count, lp_name_resolve_order())) {
1299                 *master_ip = ip_list[0].ip;
1300                 SAFE_FREE(ip_list);
1301                 return True;
1302         }
1303
1304         SAFE_FREE(ip_list);
1305         return False;
1306 }
1307
1308 /********************************************************
1309  Get the IP address list of the primary domain controller
1310  for a domain.
1311 *********************************************************/
1312
1313 BOOL get_pdc_ip(const char *domain, struct in_addr *ip)
1314 {
1315         struct ip_service *ip_list;
1316         int count;
1317
1318         /* Look up #1B name */
1319
1320         if (!internal_resolve_name(domain, 0x1b, &ip_list, &count, lp_name_resolve_order())) {
1321                 return False;
1322         }
1323
1324         /* if we get more than 1 IP back we have to assume it is a
1325            multi-homed PDC and not a mess up */
1326
1327         if ( count > 1 ) {
1328                 DEBUG(6,("get_pdc_ip: PDC has %d IP addresses!\n", count));
1329                 sort_ip_list2( ip_list, count );
1330         }
1331
1332         *ip = ip_list[0].ip;
1333
1334         SAFE_FREE(ip_list);
1335
1336         return True;
1337 }
1338
1339 /********************************************************
1340  Get the IP address list of the domain controllers for
1341  a domain.
1342 *********************************************************/
1343
1344 static BOOL get_dc_list(const char *domain, struct ip_service **ip_list,
1345                  int *count, BOOL ads_only, int *ordered)
1346 {
1347         fstring resolve_order;
1348         char *saf_servername;
1349         pstring pserver;
1350         const char *p;
1351         char *port_str;
1352         int port;
1353         fstring name;
1354         int num_addresses = 0;
1355         int  local_count, i, j;
1356         struct ip_service *return_iplist = NULL;
1357         struct ip_service *auto_ip_list = NULL;
1358         BOOL done_auto_lookup = False;
1359         int auto_count = 0;
1360
1361         /* if we are restricted to solely using DNS for looking
1362            up a domain controller, make sure that host lookups
1363            are enabled for the 'name resolve order'.  If host lookups
1364            are disabled and ads_only is True, then set the string to
1365            NULL. */
1366
1367         fstrcpy( resolve_order, lp_name_resolve_order() );
1368         strlower_m( resolve_order );
1369         if ( ads_only )  {
1370                 if ( strstr( resolve_order, "host" ) )
1371                         fstrcpy( resolve_order, "ads" );
1372                 else
1373                         fstrcpy( resolve_order, "NULL" );
1374         }
1375
1376         *ordered = False;
1377
1378         /* fetch the server we have affinity for.  Add the
1379            'password server' list to a search for our domain controllers */
1380
1381         saf_servername = saf_fetch( domain );
1382
1383         if ( strequal(domain, lp_workgroup()) || strequal(domain, lp_realm()) ) {
1384                 pstr_sprintf( pserver, "%s, %s",
1385                         saf_servername ? saf_servername : "",
1386                         lp_passwordserver() );
1387         } else {
1388                 pstr_sprintf( pserver, "%s, *",
1389                         saf_servername ? saf_servername : "" );
1390         }
1391
1392         SAFE_FREE( saf_servername );
1393
1394         /* if we are starting from scratch, just lookup DOMAIN<0x1c> */
1395
1396         if ( !*pserver ) {
1397                 DEBUG(10,("get_dc_list: no preferred domain controllers.\n"));
1398                 return internal_resolve_name(domain, 0x1C, ip_list, count, resolve_order);
1399         }
1400
1401         DEBUG(3,("get_dc_list: preferred server list: \"%s\"\n", pserver ));
1402
1403         /*
1404          * if '*' appears in the "password server" list then add
1405          * an auto lookup to the list of manually configured
1406          * DC's.  If any DC is listed by name, then the list should be
1407          * considered to be ordered
1408          */
1409
1410         p = pserver;
1411         while (next_token(&p,name,LIST_SEP,sizeof(name))) {
1412                 if (strequal(name, "*")) {
1413                         if ( internal_resolve_name(domain, 0x1C, &auto_ip_list, &auto_count, resolve_order) )
1414                                 num_addresses += auto_count;
1415                         done_auto_lookup = True;
1416                         DEBUG(8,("Adding %d DC's from auto lookup\n", auto_count));
1417                 } else  {
1418                         num_addresses++;
1419                 }
1420         }
1421
1422         /* if we have no addresses and haven't done the auto lookup, then
1423            just return the list of DC's.  Or maybe we just failed. */
1424
1425         if ( (num_addresses == 0) ) {
1426                 if ( !done_auto_lookup ) {
1427                         return internal_resolve_name(domain, 0x1C, ip_list, count, resolve_order);
1428                 } else {
1429                         DEBUG(4,("get_dc_list: no servers found\n"));
1430                         return False;
1431                 }
1432         }
1433
1434         if ( (return_iplist = SMB_MALLOC_ARRAY(struct ip_service, num_addresses)) == NULL ) {
1435                 DEBUG(3,("get_dc_list: malloc fail !\n"));
1436                 return False;
1437         }
1438
1439         p = pserver;
1440         local_count = 0;
1441
1442         /* fill in the return list now with real IP's */
1443
1444         while ( (local_count<num_addresses) && next_token(&p,name,LIST_SEP,sizeof(name)) ) {
1445                 struct in_addr name_ip;
1446
1447                 /* copy any addersses from the auto lookup */
1448
1449                 if ( strequal(name, "*") ) {
1450                         for ( j=0; j<auto_count; j++ ) {
1451                                 /* Check for and don't copy any known bad DC IP's. */
1452                                 if(!NT_STATUS_IS_OK(check_negative_conn_cache(domain,
1453                                                 inet_ntoa(auto_ip_list[j].ip)))) {
1454                                         DEBUG(5,("get_dc_list: negative entry %s removed from DC list\n",
1455                                                 inet_ntoa(auto_ip_list[j].ip) ));
1456                                         continue;
1457                                 }
1458                                 return_iplist[local_count].ip   = auto_ip_list[j].ip;
1459                                 return_iplist[local_count].port = auto_ip_list[j].port;
1460                                 local_count++;
1461                         }
1462                         continue;
1463                 }
1464
1465
1466                 /* added support for address:port syntax for ads (not that I think
1467                    anyone will ever run the LDAP server in an AD domain on something
1468                    other than port 389 */
1469
1470                 port = (lp_security() == SEC_ADS) ? LDAP_PORT : PORT_NONE;
1471                 if ( (port_str=strchr(name, ':')) != NULL ) {
1472                         *port_str = '\0';
1473                         port_str++;
1474                         port = atoi( port_str );
1475                 }
1476
1477                 /* explicit lookup; resolve_name() will handle names & IP addresses */
1478                 if ( resolve_name( name, &name_ip, 0x20 ) ) {
1479
1480                         /* Check for and don't copy any known bad DC IP's. */
1481                         if( !NT_STATUS_IS_OK(check_negative_conn_cache(domain, inet_ntoa(name_ip))) ) {
1482                                 DEBUG(5,("get_dc_list: negative entry %s removed from DC list\n",name ));
1483                                 continue;
1484                         }
1485
1486                         return_iplist[local_count].ip   = name_ip;
1487                         return_iplist[local_count].port = port;
1488                         local_count++;
1489                         *ordered = True;
1490                 }
1491         }
1492
1493         SAFE_FREE(auto_ip_list);
1494
1495         /* need to remove duplicates in the list if we have any
1496            explicit password servers */
1497
1498         if ( local_count ) {
1499                 local_count = remove_duplicate_addrs2( return_iplist, local_count );
1500         }
1501
1502         if ( DEBUGLEVEL >= 4 ) {
1503                 DEBUG(4,("get_dc_list: returning %d ip addresses in an %sordered list\n", local_count,
1504                         *ordered ? "":"un"));
1505                 DEBUG(4,("get_dc_list: "));
1506                 for ( i=0; i<local_count; i++ )
1507                         DEBUGADD(4,("%s:%d ", inet_ntoa(return_iplist[i].ip), return_iplist[i].port ));
1508                 DEBUGADD(4,("\n"));
1509         }
1510
1511         *ip_list = return_iplist;
1512         *count = local_count;
1513
1514         return (*count != 0);
1515 }
1516
1517 /*********************************************************************
1518  Small wrapper function to get the DC list and sort it if neccessary.
1519 *********************************************************************/
1520
1521 BOOL get_sorted_dc_list( const char *domain, struct ip_service **ip_list, int *count, BOOL ads_only )
1522 {
1523         BOOL ordered;
1524
1525         DEBUG(8,("get_sorted_dc_list: attempting lookup using [%s]\n",
1526                 (ads_only ? "ads" : lp_name_resolve_order())));
1527
1528         if ( !get_dc_list(domain, ip_list, count, ads_only, &ordered) ) {
1529                 return False;
1530         }
1531
1532         /* only sort if we don't already have an ordered list */
1533         if ( !ordered ) {
1534                 sort_ip_list2( *ip_list, *count );
1535         }
1536
1537         return True;
1538 }