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