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