source3/libsmb/namequery.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    name query routines
   4    Copyright (C) Andrew Tridgell 1994-1998
   5    Copyright (C) Jeremy Allison 2007.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22
  23 /* nmbd.c sets this to True. */
  24 bool global_in_nmbd = False;
  25
  26 /****************************
  27  * SERVER AFFINITY ROUTINES *
  28  ****************************/
  29
  30  /* Server affinity is the concept of preferring the last domain
  31     controller with whom you had a successful conversation */
  32
  33 /****************************************************************************
  34 ****************************************************************************/
  35 #define SAFKEY_FMT      "SAF/DOMAIN/%s"
  36 #define SAF_TTL         900
  37 #define SAFJOINKEY_FMT  "SAFJOIN/DOMAIN/%s"
  38 #define SAFJOIN_TTL     3600
  39
  40 static char *saf_key(const char *domain)
  41 {
  42         char *keystr;
  43
  44         asprintf_strupper_m(&keystr, SAFKEY_FMT, domain);
  45
  46         return keystr;
  47 }
  48
  49 static char *saf_join_key(const char *domain)
  50 {
  51         char *keystr;
  52
  53         asprintf_strupper_m(&keystr, SAFJOINKEY_FMT, domain);
  54
  55         return keystr;
  56 }
  57
  58 /****************************************************************************
  59 ****************************************************************************/
  60
  61 bool saf_store( const char *domain, const char *servername )
  62 {
  63         char *key;
  64         time_t expire;
  65         bool ret = False;
  66
  67         if ( !domain || !servername ) {
  68                 DEBUG(2,("saf_store: "
  69                         "Refusing to store empty domain or servername!\n"));
  70                 return False;
  71         }
  72
  73         if ( (strlen(domain) == 0) || (strlen(servername) == 0) ) {
  74                 DEBUG(0,("saf_store: "
  75                         "refusing to store 0 length domain or servername!\n"));
  76                 return False;
  77         }
  78
  79         key = saf_key( domain );
  80         expire = time( NULL ) + lp_parm_int(-1, "saf","ttl", SAF_TTL);
  81
  82         DEBUG(10,("saf_store: domain = [%s], server = [%s], expire = [%u]\n",
  83                 domain, servername, (unsigned int)expire ));
  84
  85         ret = gencache_set( key, servername, expire );
  86
  87         SAFE_FREE( key );
  88
  89         return ret;
  90 }
  91
  92 bool saf_join_store( const char *domain, const char *servername )
  93 {
  94         char *key;
  95         time_t expire;
  96         bool ret = False;
  97
  98         if ( !domain || !servername ) {
  99                 DEBUG(2,("saf_join_store: Refusing to store empty domain or servername!\n"));
 100                 return False;
 101         }
 102
 103         if ( (strlen(domain) == 0) || (strlen(servername) == 0) ) {
 104                 DEBUG(0,("saf_join_store: refusing to store 0 length domain or servername!\n"));
 105                 return False;
 106         }
 107
 108         key = saf_join_key( domain );
 109         expire = time( NULL ) + lp_parm_int(-1, "saf","join ttl", SAFJOIN_TTL);
 110
 111         DEBUG(10,("saf_join_store: domain = [%s], server = [%s], expire = [%u]\n",
 112                 domain, servername, (unsigned int)expire ));
 113
 114         ret = gencache_set( key, servername, expire );
 115
 116         SAFE_FREE( key );
 117
 118         return ret;
 119 }
 120
 121 bool saf_delete( const char *domain )
 122 {
 123         char *key;
 124         bool ret = False;
 125
 126         if ( !domain ) {
 127                 DEBUG(2,("saf_delete: Refusing to delete empty domain\n"));
 128                 return False;
 129         }
 130
 131         key = saf_join_key(domain);
 132         ret = gencache_del(key);
 133         SAFE_FREE(key);
 134
 135         if (ret) {
 136                 DEBUG(10,("saf_delete[join]: domain = [%s]\n", domain ));
 137         }
 138
 139         key = saf_key(domain);
 140         ret = gencache_del(key);
 141         SAFE_FREE(key);
 142
 143         if (ret) {
 144                 DEBUG(10,("saf_delete: domain = [%s]\n", domain ));
 145         }
 146
 147         return ret;
 148 }
 149
 150 /****************************************************************************
 151 ****************************************************************************/
 152
 153 char *saf_fetch( const char *domain )
 154 {
 155         char *server = NULL;
 156         time_t timeout;
 157         bool ret = False;
 158         char *key = NULL;
 159
 160         if ( !domain || strlen(domain) == 0) {
 161                 DEBUG(2,("saf_fetch: Empty domain name!\n"));
 162                 return NULL;
 163         }
 164
 165         key = saf_join_key( domain );
 166
 167         ret = gencache_get( key, &server, &timeout );
 168
 169         SAFE_FREE( key );
 170
 171         if ( ret ) {
 172                 DEBUG(5,("saf_fetch[join]: Returning \"%s\" for \"%s\" domain\n",
 173                         server, domain ));
 174                 return server;
 175         }
 176
 177         key = saf_key( domain );
 178
 179         ret = gencache_get( key, &server, &timeout );
 180
 181         SAFE_FREE( key );
 182
 183         if ( !ret ) {
 184                 DEBUG(5,("saf_fetch: failed to find server for \"%s\" domain\n",
 185                                         domain ));
 186         } else {
 187                 DEBUG(5,("saf_fetch: Returning \"%s\" for \"%s\" domain\n",
 188                         server, domain ));
 189         }
 190
 191         return server;
 192 }
 193
 194 /****************************************************************************
 195  Generate a random trn_id.
 196 ****************************************************************************/
 197
 198 static int generate_trn_id(void)
 199 {
 200         uint16 id;
 201
 202         generate_random_buffer((uint8 *)&id, sizeof(id));
 203
 204         return id % (unsigned)0x7FFF;
 205 }
 206
 207 /****************************************************************************
 208  Parse a node status response into an array of structures.
 209 ****************************************************************************/
 210
 211 static NODE_STATUS_STRUCT *parse_node_status(char *p,
 212                                 int *num_names,
 213                                 struct node_status_extra *extra)
 214 {
 215         NODE_STATUS_STRUCT *ret;
 216         int i;
 217
 218         *num_names = CVAL(p,0);
 219
 220         if (*num_names == 0)
 221                 return NULL;
 222
 223         ret = SMB_MALLOC_ARRAY(NODE_STATUS_STRUCT,*num_names);
 224         if (!ret)
 225                 return NULL;
 226
 227         p++;
 228         for (i=0;i< *num_names;i++) {
 229                 StrnCpy(ret[i].name,p,15);
 230                 trim_char(ret[i].name,'\0',' ');
 231                 ret[i].type = CVAL(p,15);
 232                 ret[i].flags = p[16];
 233                 p += 18;
 234                 DEBUG(10, ("%s#%02x: flags = 0x%02x\n", ret[i].name,
 235                            ret[i].type, ret[i].flags));
 236         }
 237         /*
 238          * Also, pick up the MAC address ...
 239          */
 240         if (extra) {
 241                 memcpy(&extra->mac_addr, p, 6); /* Fill in the mac addr */
 242         }
 243         return ret;
 244 }
 245
 246
 247 /****************************************************************************
 248  Do a NBT node status query on an open socket and return an array of
 249  structures holding the returned names or NULL if the query failed.
 250 **************************************************************************/
 251
 252 NODE_STATUS_STRUCT *node_status_query(int fd,
 253                                         struct nmb_name *name,
 254                                         const struct sockaddr_storage *to_ss,
 255                                         int *num_names,
 256                                         struct node_status_extra *extra)
 257 {
 258         bool found=False;
 259         int retries = 2;
 260         int retry_time = 2000;
 261         struct timeval tval;
 262         struct packet_struct p;
 263         struct packet_struct *p2;
 264         struct nmb_packet *nmb = &p.packet.nmb;
 265         NODE_STATUS_STRUCT *ret;
 266
 267         ZERO_STRUCT(p);
 268
 269         if (to_ss->ss_family != AF_INET) {
 270                 /* Can't do node status to IPv6 */
 271                 return NULL;
 272         }
 273         nmb->header.name_trn_id = generate_trn_id();
 274         nmb->header.opcode = 0;
 275         nmb->header.response = false;
 276         nmb->header.nm_flags.bcast = false;
 277         nmb->header.nm_flags.recursion_available = false;
 278         nmb->header.nm_flags.recursion_desired = false;
 279         nmb->header.nm_flags.trunc = false;
 280         nmb->header.nm_flags.authoritative = false;
 281         nmb->header.rcode = 0;
 282         nmb->header.qdcount = 1;
 283         nmb->header.ancount = 0;
 284         nmb->header.nscount = 0;
 285         nmb->header.arcount = 0;
 286         nmb->question.question_name = *name;
 287         nmb->question.question_type = 0x21;
 288         nmb->question.question_class = 0x1;
 289
 290         p.ip = ((const struct sockaddr_in *)to_ss)->sin_addr;
 291         p.port = NMB_PORT;
 292         p.recv_fd = -1;
 293         p.send_fd = fd;
 294         p.timestamp = time(NULL);
 295         p.packet_type = NMB_PACKET;
 296
 297         GetTimeOfDay(&tval);
 298
 299         if (!send_packet(&p))
 300                 return NULL;
 301
 302         retries--;
 303
 304         while (1) {
 305                 struct timeval tval2;
 306                 GetTimeOfDay(&tval2);
 307                 if (TvalDiff(&tval,&tval2) > retry_time) {
 308                         if (!retries)
 309                                 break;
 310                         if (!found && !send_packet(&p))
 311                                 return NULL;
 312                         GetTimeOfDay(&tval);
 313                         retries--;
 314                 }
 315
 316                 if ((p2=receive_nmb_packet(fd,90,nmb->header.name_trn_id))) {
 317                         struct nmb_packet *nmb2 = &p2->packet.nmb;
 318                         debug_nmb_packet(p2);
 319
 320                         if (nmb2->header.opcode != 0 ||
 321                             nmb2->header.nm_flags.bcast ||
 322                             nmb2->header.rcode ||
 323                             !nmb2->header.ancount ||
 324                             nmb2->answers->rr_type != 0x21) {
 325                                 /* XXXX what do we do with this? could be a
 326                                    redirect, but we'll discard it for the
 327                                    moment */
 328                                 free_packet(p2);
 329                                 continue;
 330                         }
 331
 332                         ret = parse_node_status(&nmb2->answers->rdata[0],
 333                                         num_names, extra);
 334                         free_packet(p2);
 335                         return ret;
 336                 }
 337         }
 338
 339         return NULL;
 340 }
 341
 342 /****************************************************************************
 343  Find the first type XX name in a node status reply - used for finding
 344  a servers name given its IP. Return the matched name in *name.
 345 **************************************************************************/
 346
 347 bool name_status_find(const char *q_name,
 348                         int q_type,
 349                         int type,
 350                         const struct sockaddr_storage *to_ss,
 351                         fstring name)
 352 {
 353         char addr[INET6_ADDRSTRLEN];
 354         struct sockaddr_storage ss;
 355         NODE_STATUS_STRUCT *status = NULL;
 356         struct nmb_name nname;
 357         int count, i;
 358         int sock;
 359         bool result = false;
 360
 361         if (lp_disable_netbios()) {
 362                 DEBUG(5,("name_status_find(%s#%02x): netbios is disabled\n",
 363                                         q_name, q_type));
 364                 return False;
 365         }
 366
 367         print_sockaddr(addr, sizeof(addr), to_ss);
 368
 369         DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name,
 370                    q_type, addr));
 371
 372         /* Check the cache first. */
 373
 374         if (namecache_status_fetch(q_name, q_type, type, to_ss, name)) {
 375                 return True;
 376         }
 377
 378         if (to_ss->ss_family != AF_INET) {
 379                 /* Can't do node status to IPv6 */
 380                 return false;
 381         }
 382
 383         if (!interpret_string_addr(&ss, lp_socket_address(),
 384                                 AI_NUMERICHOST|AI_PASSIVE)) {
 385                 zero_sockaddr(&ss);
 386         }
 387
 388         sock = open_socket_in(SOCK_DGRAM, 0, 3, &ss, True);
 389         if (sock == -1)
 390                 goto done;
 391
 392         /* W2K PDC's seem not to respond to '*'#0. JRA */
 393         make_nmb_name(&nname, q_name, q_type);
 394         status = node_status_query(sock, &nname, to_ss, &count, NULL);
 395         close(sock);
 396         if (!status)
 397                 goto done;
 398
 399         for (i=0;i<count;i++) {
 400                 /* Find first one of the requested type that's not a GROUP. */
 401                 if (status[i].type == type && ! (status[i].flags & 0x80))
 402                         break;
 403         }
 404         if (i == count)
 405                 goto done;
 406
 407         pull_ascii_nstring(name, sizeof(fstring), status[i].name);
 408
 409         /* Store the result in the cache. */
 410         /* but don't store an entry for 0x1c names here.  Here we have
 411            a single host and DOMAIN<0x1c> names should be a list of hosts */
 412
 413         if ( q_type != 0x1c ) {
 414                 namecache_status_store(q_name, q_type, type, to_ss, name);
 415         }
 416
 417         result = true;
 418
 419  done:
 420         SAFE_FREE(status);
 421
 422         DEBUG(10, ("name_status_find: name %sfound", result ? "" : "not "));
 423
 424         if (result)
 425                 DEBUGADD(10, (", name %s ip address is %s", name, addr));
 426
 427         DEBUG(10, ("\n"));
 428
 429         return result;
 430 }
 431
 432 /*
 433   comparison function used by sort_addr_list
 434 */
 435
 436 static int addr_compare(const struct sockaddr *ss1,
 437                 const struct sockaddr *ss2)
 438 {
 439         int max_bits1=0, max_bits2=0;
 440         int num_interfaces = iface_count();
 441         int i;
 442
 443         /* Sort IPv4 addresses first. */
 444         if (ss1->sa_family != ss2->sa_family) {
 445                 if (ss2->sa_family == AF_INET) {
 446                         return 1;
 447                 } else {
 448                         return -1;
 449                 }
 450         }
 451
 452         /* Here we know both addresses are of the same
 453          * family. */
 454
 455         for (i=0;i<num_interfaces;i++) {
 456                 const struct sockaddr_storage *pss = iface_n_bcast(i);
 457                 unsigned char *p_ss1 = NULL;
 458                 unsigned char *p_ss2 = NULL;
 459                 unsigned char *p_if = NULL;
 460                 size_t len = 0;
 461                 int bits1, bits2;
 462
 463                 if (pss->ss_family != ss1->sa_family) {
 464                         /* Ignore interfaces of the wrong type. */
 465                         continue;
 466                 }
 467                 if (pss->ss_family == AF_INET) {
 468                         p_if = (unsigned char *)
 469                                 &((const struct sockaddr_in *)pss)->sin_addr;
 470                         p_ss1 = (unsigned char *)
 471                                 &((const struct sockaddr_in *)ss1)->sin_addr;
 472                         p_ss2 = (unsigned char *)
 473                                 &((const struct sockaddr_in *)ss2)->sin_addr;
 474                         len = 4;
 475                 }
 476 #if defined(HAVE_IPV6)
 477                 if (pss->ss_family == AF_INET6) {
 478                         p_if = (unsigned char *)
 479                                 &((const struct sockaddr_in6 *)pss)->sin6_addr;
 480                         p_ss1 = (unsigned char *)
 481                                 &((const struct sockaddr_in6 *)ss1)->sin6_addr;
 482                         p_ss2 = (unsigned char *)
 483                                 &((const struct sockaddr_in6 *)ss2)->sin6_addr;
 484                         len = 16;
 485                 }
 486 #endif
 487                 if (!p_ss1 || !p_ss2 || !p_if || len == 0) {
 488                         continue;
 489                 }
 490                 bits1 = matching_len_bits(p_ss1, p_if, len);
 491                 bits2 = matching_len_bits(p_ss2, p_if, len);
 492                 max_bits1 = MAX(bits1, max_bits1);
 493                 max_bits2 = MAX(bits2, max_bits2);
 494         }
 495
 496         /* Bias towards directly reachable IPs */
 497         if (iface_local(ss1)) {
 498                 if (ss1->sa_family == AF_INET) {
 499                         max_bits1 += 32;
 500                 } else {
 501                         max_bits1 += 128;
 502                 }
 503         }
 504         if (iface_local(ss2)) {
 505                 if (ss2->sa_family == AF_INET) {
 506                         max_bits2 += 32;
 507                 } else {
 508                         max_bits2 += 128;
 509                 }
 510         }
 511         return max_bits2 - max_bits1;
 512 }
 513
 514 /*******************************************************************
 515  compare 2 ldap IPs by nearness to our interfaces - used in qsort
 516 *******************************************************************/
 517
 518 int ip_service_compare(struct ip_service *ss1, struct ip_service *ss2)
 519 {
 520         int result;
 521
 522         if ((result = addr_compare((struct sockaddr *)&ss1->ss, (struct sockaddr *)&ss2->ss)) != 0) {
 523                 return result;
 524         }
 525
 526         if (ss1->port > ss2->port) {
 527                 return 1;
 528         }
 529
 530         if (ss1->port < ss2->port) {
 531                 return -1;
 532         }
 533
 534         return 0;
 535 }
 536
 537 /*
 538   sort an IP list so that names that are close to one of our interfaces
 539   are at the top. This prevents the problem where a WINS server returns an IP
 540   that is not reachable from our subnet as the first match
 541 */
 542
 543 static void sort_addr_list(struct sockaddr_storage *sslist, int count)
 544 {
 545         if (count <= 1) {
 546                 return;
 547         }
 548
 549         qsort(sslist, count, sizeof(struct sockaddr_storage),
 550                         QSORT_CAST addr_compare);
 551 }
 552
 553 static void sort_service_list(struct ip_service *servlist, int count)
 554 {
 555         if (count <= 1) {
 556                 return;
 557         }
 558
 559         qsort(servlist, count, sizeof(struct ip_service),
 560                         QSORT_CAST ip_service_compare);
 561 }
 562
 563 /**********************************************************************
 564  Remove any duplicate address/port pairs in the list
 565  *********************************************************************/
 566
 567 static int remove_duplicate_addrs2(struct ip_service *iplist, int count )
 568 {
 569         int i, j;
 570
 571         DEBUG(10,("remove_duplicate_addrs2: "
 572                         "looking for duplicate address/port pairs\n"));
 573
 574         /* One loop to set duplicates to a zero addr. */
 575         for ( i=0; i<count; i++ ) {
 576                 if ( is_zero_addr((struct sockaddr *)&iplist[i].ss)) {
 577                         continue;
 578                 }
 579
 580                 for ( j=i+1; j<count; j++ ) {
 581                         if (sockaddr_equal((struct sockaddr *)&iplist[i].ss, (struct sockaddr *)&iplist[j].ss) &&
 582                                         iplist[i].port == iplist[j].port) {
 583                                 zero_sockaddr(&iplist[j].ss);
 584                         }
 585                 }
 586         }
 587
 588         /* Now remove any addresses set to zero above. */
 589         for (i = 0; i < count; i++) {
 590                 while (i < count &&
 591                                 is_zero_addr((struct sockaddr *)&iplist[i].ss)) {
 592                         if (count-i-1>0) {
 593                                 memmove(&iplist[i],
 594                                         &iplist[i+1],
 595                                         (count-i-1)*sizeof(struct ip_service));
 596                         }
 597                         count--;
 598                 }
 599         }
 600
 601         return count;
 602 }
 603
 604 static bool prioritize_ipv4_list(struct ip_service *iplist, int count)
 605 {
 606         TALLOC_CTX *frame = talloc_stackframe();
 607         struct ip_service *iplist_new = TALLOC_ARRAY(frame, struct ip_service, count);
 608         int i, j;
 609
 610         if (iplist_new == NULL) {
 611                 TALLOC_FREE(frame);
 612                 return false;
 613         }
 614
 615         j = 0;
 616
 617         /* Copy IPv4 first. */
 618         for (i = 0; i < count; i++) {
 619                 if (iplist[i].ss.ss_family == AF_INET) {
 620                         iplist_new[j++] = iplist[i];
 621                 }
 622         }
 623
 624         /* Copy IPv6. */
 625         for (i = 0; i < count; i++) {
 626                 if (iplist[i].ss.ss_family != AF_INET) {
 627                         iplist_new[j++] = iplist[i];
 628                 }
 629         }
 630
 631         memcpy(iplist, iplist_new, sizeof(struct ip_service)*count);
 632         TALLOC_FREE(frame);
 633         return true;
 634 }
 635
 636 /****************************************************************************
 637  Do a netbios name query to find someones IP.
 638  Returns an array of IP addresses or NULL if none.
 639  *count will be set to the number of addresses returned.
 640  *timed_out is set if we failed by timing out
 641 ****************************************************************************/
 642
 643 struct sockaddr_storage *name_query(int fd,
 644                         const char *name,
 645                         int name_type,
 646                         bool bcast,
 647                         bool recurse,
 648                         const struct sockaddr_storage *to_ss,
 649                         int *count,
 650                         int *flags,
 651                         bool *timed_out)
 652 {
 653         bool found=false;
 654         int i, retries = 3;
 655         int retry_time = bcast?250:2000;
 656         struct timeval tval;
 657         struct packet_struct p;
 658         struct packet_struct *p2;
 659         struct nmb_packet *nmb = &p.packet.nmb;
 660         struct sockaddr_storage *ss_list = NULL;
 661
 662         if (lp_disable_netbios()) {
 663                 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n",
 664                                         name, name_type));
 665                 return NULL;
 666         }
 667
 668         if (to_ss->ss_family != AF_INET) {
 669                 return NULL;
 670         }
 671
 672         if (timed_out) {
 673                 *timed_out = false;
 674         }
 675
 676         memset((char *)&p,'\0',sizeof(p));
 677         (*count) = 0;
 678         (*flags) = 0;
 679
 680         nmb->header.name_trn_id = generate_trn_id();
 681         nmb->header.opcode = 0;
 682         nmb->header.response = false;
 683         nmb->header.nm_flags.bcast = bcast;
 684         nmb->header.nm_flags.recursion_available = false;
 685         nmb->header.nm_flags.recursion_desired = recurse;
 686         nmb->header.nm_flags.trunc = false;
 687         nmb->header.nm_flags.authoritative = false;
 688         nmb->header.rcode = 0;
 689         nmb->header.qdcount = 1;
 690         nmb->header.ancount = 0;
 691         nmb->header.nscount = 0;
 692         nmb->header.arcount = 0;
 693
 694         make_nmb_name(&nmb->question.question_name,name,name_type);
 695
 696         nmb->question.question_type = 0x20;
 697         nmb->question.question_class = 0x1;
 698
 699         p.ip = ((struct sockaddr_in *)to_ss)->sin_addr;
 700         p.port = NMB_PORT;
 701         p.recv_fd = -1;
 702         p.send_fd = fd;
 703         p.timestamp = time(NULL);
 704         p.packet_type = NMB_PACKET;
 705
 706         GetTimeOfDay(&tval);
 707
 708         if (!send_packet(&p))
 709                 return NULL;
 710
 711         retries--;
 712
 713         while (1) {
 714                 struct timeval tval2;
 715
 716                 GetTimeOfDay(&tval2);
 717                 if (TvalDiff(&tval,&tval2) > retry_time) {
 718                         if (!retries)
 719                                 break;
 720                         if (!found && !send_packet(&p))
 721                                 return NULL;
 722                         GetTimeOfDay(&tval);
 723                         retries--;
 724                 }
 725
 726                 if ((p2=receive_nmb_packet(fd,90,nmb->header.name_trn_id))) {
 727                         struct nmb_packet *nmb2 = &p2->packet.nmb;
 728                         debug_nmb_packet(p2);
 729
 730                         /* If we get a Negative Name Query Response from a WINS
 731                          * server, we should report it and give up.
 732                          */
 733                         if( 0 == nmb2->header.opcode    /* A query response   */
 734                             && !(bcast)                 /* from a WINS server */
 735                             && nmb2->header.rcode       /* Error returned     */
 736                                 ) {
 737
 738                                 if( DEBUGLVL( 3 ) ) {
 739                                         /* Only executed if DEBUGLEVEL >= 3 */
 740                                         dbgtext( "Negative name query "
 741                                                 "response, rcode 0x%02x: ",
 742                                                 nmb2->header.rcode );
 743                                         switch( nmb2->header.rcode ) {
 744                                         case 0x01:
 745                                                 dbgtext( "Request "
 746                                                 "was invalidly formatted.\n" );
 747                                                 break;
 748                                         case 0x02:
 749                                                 dbgtext( "Problem with NBNS, "
 750                                                 "cannot process name.\n");
 751                                                 break;
 752                                         case 0x03:
 753                                                 dbgtext( "The name requested "
 754                                                 "does not exist.\n" );
 755                                                 break;
 756                                         case 0x04:
 757                                                 dbgtext( "Unsupported request "
 758                                                 "error.\n" );
 759                                                 break;
 760                                         case 0x05:
 761                                                 dbgtext( "Query refused "
 762                                                 "error.\n" );
 763                                                 break;
 764                                         default:
 765                                                 dbgtext( "Unrecognized error "
 766                                                 "code.\n" );
 767                                                 break;
 768                                         }
 769                                 }
 770                                 free_packet(p2);
 771                                 return( NULL );
 772                         }
 773
 774                         if (nmb2->header.opcode != 0 ||
 775                             nmb2->header.nm_flags.bcast ||
 776                             nmb2->header.rcode ||
 777                             !nmb2->header.ancount) {
 778                                 /*
 779                                  * XXXX what do we do with this? Could be a
 780                                  * redirect, but we'll discard it for the
 781                                  * moment.
 782                                  */
 783                                 free_packet(p2);
 784                                 continue;
 785                         }
 786
 787                         ss_list = SMB_REALLOC_ARRAY(ss_list,
 788                                                 struct sockaddr_storage,
 789                                                 (*count) +
 790                                                 nmb2->answers->rdlength/6);
 791
 792                         if (!ss_list) {
 793                                 DEBUG(0,("name_query: Realloc failed.\n"));
 794                                 free_packet(p2);
 795                                 return NULL;
 796                         }
 797
 798                         DEBUG(2,("Got a positive name query response "
 799                                         "from %s ( ",
 800                                         inet_ntoa(p2->ip)));
 801
 802                         for (i=0;i<nmb2->answers->rdlength/6;i++) {
 803                                 struct in_addr ip;
 804                                 putip((char *)&ip,&nmb2->answers->rdata[2+i*6]);
 805                                 in_addr_to_sockaddr_storage(&ss_list[(*count)],
 806                                                 ip);
 807                                 DEBUGADD(2,("%s ",inet_ntoa(ip)));
 808                                 (*count)++;
 809                         }
 810                         DEBUGADD(2,(")\n"));
 811
 812                         found=true;
 813                         retries=0;
 814                         /* We add the flags back ... */
 815                         if (nmb2->header.response)
 816                                 (*flags) |= NM_FLAGS_RS;
 817                         if (nmb2->header.nm_flags.authoritative)
 818                                 (*flags) |= NM_FLAGS_AA;
 819                         if (nmb2->header.nm_flags.trunc)
 820                                 (*flags) |= NM_FLAGS_TC;
 821                         if (nmb2->header.nm_flags.recursion_desired)
 822                                 (*flags) |= NM_FLAGS_RD;
 823                         if (nmb2->header.nm_flags.recursion_available)
 824                                 (*flags) |= NM_FLAGS_RA;
 825                         if (nmb2->header.nm_flags.bcast)
 826                                 (*flags) |= NM_FLAGS_B;
 827                         free_packet(p2);
 828                         /*
 829                          * If we're doing a unicast lookup we only
 830                          * expect one reply. Don't wait the full 2
 831                          * seconds if we got one. JRA.
 832                          */
 833                         if(!bcast && found)
 834                                 break;
 835                 }
 836         }
 837
 838         /* only set timed_out if we didn't fund what we where looking for*/
 839
 840         if ( !found && timed_out ) {
 841                 *timed_out = true;
 842         }
 843
 844         /* sort the ip list so we choose close servers first if possible */
 845         sort_addr_list(ss_list, *count);
 846
 847         return ss_list;
 848 }
 849
 850 /********************************************************
 851  Convert an array if struct sockaddr_storage to struct ip_service
 852  return false on failure.  Port is set to PORT_NONE;
 853  pcount is [in/out] - it is the length of ss_list on input,
 854  and the length of return_iplist on output as we remove any
 855  zero addresses from ss_list.
 856 *********************************************************/
 857
 858 static bool convert_ss2service(struct ip_service **return_iplist,
 859                 const struct sockaddr_storage *ss_list,
 860                 int *pcount)
 861 {
 862         int i;
 863         int orig_count = *pcount;
 864         int real_count = 0;
 865
 866         if (orig_count==0 || !ss_list )
 867                 return False;
 868
 869         /* Filter out zero addrs. */
 870         for ( i=0; i<orig_count; i++ ) {
 871                 if (is_zero_addr((struct sockaddr *)&ss_list[i])) {
 872                         continue;
 873                 }
 874                 real_count++;
 875         }
 876         if (real_count==0) {
 877                 return false;
 878         }
 879
 880         /* copy the ip address; port will be PORT_NONE */
 881         if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, real_count)) ==
 882                         NULL) {
 883                 DEBUG(0,("convert_ip2service: malloc failed "
 884                         "for %d enetries!\n", real_count ));
 885                 return False;
 886         }
 887
 888         for ( i=0, real_count = 0; i<orig_count; i++ ) {
 889                 if (is_zero_addr((struct sockaddr *)&ss_list[i])) {
 890                         continue;
 891                 }
 892                 (*return_iplist)[real_count].ss   = ss_list[i];
 893                 (*return_iplist)[real_count].port = PORT_NONE;
 894                 real_count++;
 895         }
 896
 897         *pcount = real_count;
 898         return true;
 899 }
 900
 901 /********************************************************
 902  Resolve via "bcast" method.
 903 *********************************************************/
 904
 905 NTSTATUS name_resolve_bcast(const char *name,
 906                         int name_type,
 907                         struct ip_service **return_iplist,
 908                         int *return_count)
 909 {
 910         int sock, i;
 911         int num_interfaces = iface_count();
 912         struct sockaddr_storage *ss_list;
 913         struct sockaddr_storage ss;
 914         NTSTATUS status;
 915
 916         if (lp_disable_netbios()) {
 917                 DEBUG(5,("name_resolve_bcast(%s#%02x): netbios is disabled\n",
 918                                         name, name_type));
 919                 return NT_STATUS_INVALID_PARAMETER;
 920         }
 921
 922         *return_iplist = NULL;
 923         *return_count = 0;
 924
 925         /*
 926          * "bcast" means do a broadcast lookup on all the local interfaces.
 927          */
 928
 929         DEBUG(3,("name_resolve_bcast: Attempting broadcast lookup "
 930                 "for name %s<0x%x>\n", name, name_type));
 931
 932         if (!interpret_string_addr(&ss, lp_socket_address(),
 933                                 AI_NUMERICHOST|AI_PASSIVE)) {
 934                 zero_sockaddr(&ss);
 935         }
 936
 937         sock = open_socket_in( SOCK_DGRAM, 0, 3, &ss, true );
 938         if (sock == -1) {
 939                 return NT_STATUS_UNSUCCESSFUL;
 940         }
 941
 942         set_socket_options(sock,"SO_BROADCAST");
 943         /*
 944          * Lookup the name on all the interfaces, return on
 945          * the first successful match.
 946          */
 947         for( i = num_interfaces-1; i >= 0; i--) {
 948                 const struct sockaddr_storage *pss = iface_n_bcast(i);
 949                 int flags;
 950
 951                 /* Done this way to fix compiler error on IRIX 5.x */
 952                 if (!pss) {
 953                         continue;
 954                 }
 955                 ss_list = name_query(sock, name, name_type, true,
 956                                     true, pss, return_count, &flags, NULL);
 957                 if (ss_list) {
 958                         goto success;
 959                 }
 960         }
 961
 962         /* failed - no response */
 963
 964         close(sock);
 965         return NT_STATUS_UNSUCCESSFUL;
 966
 967 success:
 968
 969         status = NT_STATUS_OK;
 970         if (!convert_ss2service(return_iplist, ss_list, return_count) )
 971                 status = NT_STATUS_INVALID_PARAMETER;
 972
 973         SAFE_FREE(ss_list);
 974         close(sock);
 975         return status;
 976 }
 977
 978 /********************************************************
 979  Resolve via "wins" method.
 980 *********************************************************/
 981
 982 NTSTATUS resolve_wins(const char *name,
 983                 int name_type,
 984                 struct ip_service **return_iplist,
 985                 int *return_count)
 986 {
 987         int sock, t, i;
 988         char **wins_tags;
 989         struct sockaddr_storage src_ss, *ss_list = NULL;
 990         struct in_addr src_ip;
 991         NTSTATUS status;
 992
 993         if (lp_disable_netbios()) {
 994                 DEBUG(5,("resolve_wins(%s#%02x): netbios is disabled\n",
 995                                         name, name_type));
 996                 return NT_STATUS_INVALID_PARAMETER;
 997         }
 998
 999         *return_iplist = NULL;
1000         *return_count = 0;
1001
1002         DEBUG(3,("resolve_wins: Attempting wins lookup for name %s<0x%x>\n",
1003                                 name, name_type));
1004
1005         if (wins_srv_count() < 1) {
1006                 DEBUG(3,("resolve_wins: WINS server resolution selected "
1007                         "and no WINS servers listed.\n"));
1008                 return NT_STATUS_INVALID_PARAMETER;
1009         }
1010
1011         /* we try a lookup on each of the WINS tags in turn */
1012         wins_tags = wins_srv_tags();
1013
1014         if (!wins_tags) {
1015                 /* huh? no tags?? give up in disgust */
1016                 return NT_STATUS_INVALID_PARAMETER;
1017         }
1018
1019         /* the address we will be sending from */
1020         if (!interpret_string_addr(&src_ss, lp_socket_address(),
1021                                 AI_NUMERICHOST|AI_PASSIVE)) {
1022                 zero_sockaddr(&src_ss);
1023         }
1024
1025         if (src_ss.ss_family != AF_INET) {
1026                 char addr[INET6_ADDRSTRLEN];
1027                 print_sockaddr(addr, sizeof(addr), &src_ss);
1028                 DEBUG(3,("resolve_wins: cannot receive WINS replies "
1029                         "on IPv6 address %s\n",
1030                         addr));
1031                 wins_srv_tags_free(wins_tags);
1032                 return NT_STATUS_INVALID_PARAMETER;
1033         }
1034
1035         src_ip = ((struct sockaddr_in *)&src_ss)->sin_addr;
1036
1037         /* in the worst case we will try every wins server with every
1038            tag! */
1039         for (t=0; wins_tags && wins_tags[t]; t++) {
1040                 int srv_count = wins_srv_count_tag(wins_tags[t]);
1041                 for (i=0; i<srv_count; i++) {
1042                         struct sockaddr_storage wins_ss;
1043                         struct in_addr wins_ip;
1044                         int flags;
1045                         bool timed_out;
1046
1047                         wins_ip = wins_srv_ip_tag(wins_tags[t], src_ip);
1048
1049                         if (global_in_nmbd && ismyip_v4(wins_ip)) {
1050                                 /* yikes! we'll loop forever */
1051                                 continue;
1052                         }
1053
1054                         /* skip any that have been unresponsive lately */
1055                         if (wins_srv_is_dead(wins_ip, src_ip)) {
1056                                 continue;
1057                         }
1058
1059                         DEBUG(3,("resolve_wins: using WINS server %s "
1060                                 "and tag '%s'\n",
1061                                 inet_ntoa(wins_ip), wins_tags[t]));
1062
1063                         sock = open_socket_in(SOCK_DGRAM, 0, 3, &src_ss, true);
1064                         if (sock == -1) {
1065                                 continue;
1066                         }
1067
1068                         in_addr_to_sockaddr_storage(&wins_ss, wins_ip);
1069                         ss_list = name_query(sock,
1070                                                 name,
1071                                                 name_type,
1072                                                 false,
1073                                                 true,
1074                                                 &wins_ss,
1075                                                 return_count,
1076                                                 &flags,
1077                                                 &timed_out);
1078
1079                         /* exit loop if we got a list of addresses */
1080
1081                         if (ss_list)
1082                                 goto success;
1083
1084                         close(sock);
1085
1086                         if (timed_out) {
1087                                 /* Timed out wating for WINS server to respond.
1088                                  * Mark it dead. */
1089                                 wins_srv_died(wins_ip, src_ip);
1090                         } else {
1091                                 /* The name definately isn't in this
1092                                    group of WINS servers.
1093                                    goto the next group  */
1094                                 break;
1095                         }
1096                 }
1097         }
1098
1099         wins_srv_tags_free(wins_tags);
1100         return NT_STATUS_NO_LOGON_SERVERS;
1101
1102 success:
1103
1104         status = NT_STATUS_OK;
1105         if (!convert_ss2service(return_iplist, ss_list, return_count))
1106                 status = NT_STATUS_INVALID_PARAMETER;
1107
1108         SAFE_FREE(ss_list);
1109         wins_srv_tags_free(wins_tags);
1110         close(sock);
1111
1112         return status;
1113 }
1114
1115 /********************************************************
1116  Resolve via "lmhosts" method.
1117 *********************************************************/
1118
1119 static NTSTATUS resolve_lmhosts(const char *name, int name_type,
1120                                 struct ip_service **return_iplist,
1121                                 int *return_count)
1122 {
1123         /*
1124          * "lmhosts" means parse the local lmhosts file.
1125          */
1126
1127         XFILE *fp;
1128         char *lmhost_name = NULL;
1129         int name_type2;
1130         struct sockaddr_storage return_ss;
1131         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1132         TALLOC_CTX *ctx = NULL;
1133
1134         *return_iplist = NULL;
1135         *return_count = 0;
1136
1137         DEBUG(3,("resolve_lmhosts: "
1138                 "Attempting lmhosts lookup for name %s<0x%x>\n",
1139                 name, name_type));
1140
1141         fp = startlmhosts(get_dyn_LMHOSTSFILE());
1142
1143         if ( fp == NULL )
1144                 return NT_STATUS_NO_SUCH_FILE;
1145
1146         ctx = talloc_init("resolve_lmhosts");
1147         if (!ctx) {
1148                 endlmhosts(fp);
1149                 return NT_STATUS_NO_MEMORY;
1150         }
1151
1152         while (getlmhostsent(ctx, fp, &lmhost_name, &name_type2, &return_ss)) {
1153
1154                 if (!strequal(name, lmhost_name)) {
1155                         TALLOC_FREE(lmhost_name);
1156                         continue;
1157                 }
1158
1159                 if ((name_type2 != -1) && (name_type != name_type2)) {
1160                         TALLOC_FREE(lmhost_name);
1161                         continue;
1162                 }
1163
1164                 *return_iplist = SMB_REALLOC_ARRAY((*return_iplist),
1165                                         struct ip_service,
1166                                         (*return_count)+1);
1167
1168                 if ((*return_iplist) == NULL) {
1169                         TALLOC_FREE(ctx);
1170                         endlmhosts(fp);
1171                         DEBUG(3,("resolve_lmhosts: malloc fail !\n"));
1172                         return NT_STATUS_NO_MEMORY;
1173                 }
1174
1175                 (*return_iplist)[*return_count].ss = return_ss;
1176                 (*return_iplist)[*return_count].port = PORT_NONE;
1177                 *return_count += 1;
1178
1179                 /* we found something */
1180                 status = NT_STATUS_OK;
1181
1182                 /* Multiple names only for DC lookup */
1183                 if (name_type != 0x1c)
1184                         break;
1185         }
1186
1187         TALLOC_FREE(ctx);
1188         endlmhosts(fp);
1189         return status;
1190 }
1191
1192
1193 /********************************************************
1194  Resolve via "hosts" method.
1195 *********************************************************/
1196
1197 static NTSTATUS resolve_hosts(const char *name, int name_type,
1198                               struct ip_service **return_iplist,
1199                               int *return_count)
1200 {
1201         /*
1202          * "host" means do a localhost, or dns lookup.
1203          */
1204         struct addrinfo hints;
1205         struct addrinfo *ailist = NULL;
1206         struct addrinfo *res = NULL;
1207         int ret = -1;
1208         int i = 0;
1209
1210         if ( name_type != 0x20 && name_type != 0x0) {
1211                 DEBUG(5, ("resolve_hosts: not appropriate "
1212                         "for name type <0x%x>\n",
1213                         name_type));
1214                 return NT_STATUS_INVALID_PARAMETER;
1215         }
1216
1217         *return_iplist = NULL;
1218         *return_count = 0;
1219
1220         DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n",
1221                                 name, name_type));
1222
1223         ZERO_STRUCT(hints);
1224         /* By default make sure it supports TCP. */
1225         hints.ai_socktype = SOCK_STREAM;
1226         hints.ai_flags = AI_ADDRCONFIG;
1227
1228 #if !defined(HAVE_IPV6)
1229         /* Unless we have IPv6, we really only want IPv4 addresses back. */
1230         hints.ai_family = AF_INET;
1231 #endif
1232
1233         ret = getaddrinfo(name,
1234                         NULL,
1235                         &hints,
1236                         &ailist);
1237         if (ret) {
1238                 DEBUG(3,("resolve_hosts: getaddrinfo failed for name %s [%s]\n",
1239                         name,
1240                         gai_strerror(ret) ));
1241         }
1242
1243         for (res = ailist; res; res = res->ai_next) {
1244                 struct sockaddr_storage ss;
1245
1246                 if (!res->ai_addr || res->ai_addrlen == 0) {
1247                         continue;
1248                 }
1249
1250                 ZERO_STRUCT(ss);
1251                 memcpy(&ss, res->ai_addr, res->ai_addrlen);
1252
1253                 if (is_zero_addr((struct sockaddr *)&ss)) {
1254                         continue;
1255                 }
1256
1257                 *return_count += 1;
1258
1259                 *return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
1260                                                 struct ip_service,
1261                                                 *return_count);
1262                 if (!*return_iplist) {
1263                         DEBUG(3,("resolve_hosts: malloc fail !\n"));
1264                         freeaddrinfo(ailist);
1265                         return NT_STATUS_NO_MEMORY;
1266                 }
1267                 (*return_iplist)[i].ss = ss;
1268                 (*return_iplist)[i].port = PORT_NONE;
1269                 i++;
1270         }
1271         if (ailist) {
1272                 freeaddrinfo(ailist);
1273         }
1274         if (*return_count) {
1275                 return NT_STATUS_OK;
1276         }
1277         return NT_STATUS_UNSUCCESSFUL;
1278 }
1279
1280 /********************************************************
1281  Resolve via "ADS" method.
1282 *********************************************************/
1283
1284 static NTSTATUS resolve_ads(const char *name,
1285                             int name_type,
1286                             const char *sitename,
1287                             struct ip_service **return_iplist,
1288                             int *return_count)
1289 {
1290         int                     i;
1291         NTSTATUS                status;
1292         TALLOC_CTX              *ctx;
1293         struct dns_rr_srv       *dcs = NULL;
1294         int                     numdcs = 0;
1295         int                     numaddrs = 0;
1296
1297         if ((name_type != 0x1c) && (name_type != KDC_NAME_TYPE) &&
1298             (name_type != 0x1b)) {
1299                 return NT_STATUS_INVALID_PARAMETER;
1300         }
1301
1302         if ( (ctx = talloc_init("resolve_ads")) == NULL ) {
1303                 DEBUG(0,("resolve_ads: talloc_init() failed!\n"));
1304                 return NT_STATUS_NO_MEMORY;
1305         }
1306
1307         /* The DNS code needs fixing to find IPv6 addresses... JRA. */
1308
1309         switch (name_type) {
1310                 case 0x1b:
1311                         DEBUG(5,("resolve_ads: Attempting to resolve "
1312                                  "PDC for %s using DNS\n", name));
1313                         status = ads_dns_query_pdc(ctx, name, &dcs, &numdcs);
1314                         break;
1315
1316                 case 0x1c:
1317                         DEBUG(5,("resolve_ads: Attempting to resolve "
1318                                  "DCs for %s using DNS\n", name));
1319                         status = ads_dns_query_dcs(ctx, name, sitename, &dcs,
1320                                                    &numdcs);
1321                         break;
1322                 case KDC_NAME_TYPE:
1323                         DEBUG(5,("resolve_ads: Attempting to resolve "
1324                                  "KDCs for %s using DNS\n", name));
1325                         status = ads_dns_query_kdcs(ctx, name, sitename, &dcs,
1326                                                     &numdcs);
1327                         break;
1328                 default:
1329                         status = NT_STATUS_INVALID_PARAMETER;
1330                         break;
1331         }
1332
1333         if ( !NT_STATUS_IS_OK( status ) ) {
1334                 talloc_destroy(ctx);
1335                 return status;
1336         }
1337
1338         for (i=0;i<numdcs;i++) {
1339                 if (!dcs[i].ss_s) {
1340                         numaddrs += 1;
1341                 } else {
1342                         numaddrs += dcs[i].num_ips;
1343                 }
1344         }
1345
1346         if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, numaddrs)) ==
1347                         NULL ) {
1348                 DEBUG(0,("resolve_ads: malloc failed for %d entries\n",
1349                                         numaddrs ));
1350                 talloc_destroy(ctx);
1351                 return NT_STATUS_NO_MEMORY;
1352         }
1353
1354         /* now unroll the list of IP addresses */
1355
1356         *return_count = 0;
1357
1358         for (i = 0; i < numdcs; i++) {
1359                 /* If we don't have an IP list for a name, look it up */
1360                 if (!dcs[i].ss_s) {
1361                         /* We need to get all IP addresses here. */
1362                         struct addrinfo *res = NULL;
1363                         struct addrinfo *p;
1364                         int extra_addrs = 0;
1365
1366                         if (!interpret_string_addr_internal(&res,
1367                                                 dcs[i].hostname,
1368                                                 0)) {
1369                                 continue;
1370                         }
1371                         /* Add in every IP from the lookup. How
1372                            many is that ? */
1373                         for (p = res; p; p = p->ai_next) {
1374                                 if (is_zero_addr((struct sockaddr *)p->ai_addr)) {
1375                                         continue;
1376                                 }
1377                                 extra_addrs++;
1378                         }
1379                         if (extra_addrs > 1) {
1380                                 /* We need to expand the return_iplist array
1381                                    as we only budgeted for one address. */
1382                                 numaddrs += (extra_addrs-1);
1383                                 *return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
1384                                                 struct ip_service,
1385                                                 numaddrs);
1386                                 if (*return_iplist == NULL) {
1387                                         if (res) {
1388                                                 freeaddrinfo(res);
1389                                         }
1390                                         talloc_destroy(ctx);
1391                                         return NT_STATUS_NO_MEMORY;
1392                                 }
1393                         }
1394                         for (p = res; p; p = p->ai_next) {
1395                                 (*return_iplist)[*return_count].port = dcs[i].port;
1396                                 memcpy(&(*return_iplist)[*return_count].ss,
1397                                                 p->ai_addr,
1398                                                 p->ai_addrlen);
1399                                 if (is_zero_addr((struct sockaddr *)&(*return_iplist)[*return_count].ss)) {
1400                                         continue;
1401                                 }
1402                                 (*return_count)++;
1403                                 /* Should never happen, but still... */
1404                                 if (*return_count>=numaddrs) {
1405                                         break;
1406                                 }
1407                         }
1408                         if (res) {
1409                                 freeaddrinfo(res);
1410                         }
1411                 } else {
1412                         /* use all the IP addresses from the SRV sresponse */
1413                         int j;
1414                         for (j = 0; j < dcs[i].num_ips; j++) {
1415                                 (*return_iplist)[*return_count].port = dcs[i].port;
1416                                 (*return_iplist)[*return_count].ss = dcs[i].ss_s[j];
1417                                 if (is_zero_addr((struct sockaddr *)&(*return_iplist)[*return_count].ss)) {
1418                                         continue;
1419                                 }
1420                                 (*return_count)++;
1421                                 /* Should never happen, but still... */
1422                                 if (*return_count>=numaddrs) {
1423                                         break;
1424                                 }
1425                         }
1426                 }
1427         }
1428
1429         talloc_destroy(ctx);
1430         return NT_STATUS_OK;
1431 }
1432
1433 /*******************************************************************
1434  Internal interface to resolve a name into an IP address.
1435  Use this function if the string is either an IP address, DNS
1436  or host name or NetBIOS name. This uses the name switch in the
1437  smb.conf to determine the order of name resolution.
1438
1439  Added support for ip addr/port to support ADS ldap servers.
1440  the only place we currently care about the port is in the
1441  resolve_hosts() when looking up DC's via SRV RR entries in DNS
1442 **********************************************************************/
1443
1444 NTSTATUS internal_resolve_name(const char *name,
1445                                 int name_type,
1446                                 const char *sitename,
1447                                 struct ip_service **return_iplist,
1448                                 int *return_count,
1449                                 const char *resolve_order)
1450 {
1451         char *tok;
1452         const char *ptr;
1453         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
1454         int i;
1455         TALLOC_CTX *frame = NULL;
1456
1457         *return_iplist = NULL;
1458         *return_count = 0;
1459
1460         DEBUG(10, ("internal_resolve_name: looking up %s#%x (sitename %s)\n",
1461                         name, name_type, sitename ? sitename : "(null)"));
1462
1463         if (is_ipaddress(name)) {
1464                 if ((*return_iplist = SMB_MALLOC_P(struct ip_service)) ==
1465                                 NULL) {
1466                         DEBUG(0,("internal_resolve_name: malloc fail !\n"));
1467                         return NT_STATUS_NO_MEMORY;
1468                 }
1469
1470                 /* ignore the port here */
1471                 (*return_iplist)->port = PORT_NONE;
1472
1473                 /* if it's in the form of an IP address then get the lib to interpret it */
1474                 if (!interpret_string_addr(&(*return_iplist)->ss,
1475                                         name, AI_NUMERICHOST)) {
1476                         DEBUG(1,("internal_resolve_name: interpret_string_addr "
1477                                 "failed on %s\n",
1478                                 name));
1479                         SAFE_FREE(*return_iplist);
1480                         return NT_STATUS_INVALID_PARAMETER;
1481                 }
1482                 if (is_zero_addr((struct sockaddr *)&(*return_iplist)->ss)) {
1483                         SAFE_FREE(*return_iplist);
1484                         return NT_STATUS_UNSUCCESSFUL;
1485                 }
1486                 *return_count = 1;
1487                 return NT_STATUS_OK;
1488         }
1489
1490         /* Check name cache */
1491
1492         if (namecache_fetch(name, name_type, return_iplist, return_count)) {
1493                 *return_count = remove_duplicate_addrs2(*return_iplist,
1494                                         *return_count );
1495                 /* This could be a negative response */
1496                 if (*return_count > 0) {
1497                         return NT_STATUS_OK;
1498                 } else {
1499                         return NT_STATUS_UNSUCCESSFUL;
1500                 }
1501         }
1502
1503         /* set the name resolution order */
1504
1505         if (strcmp( resolve_order, "NULL") == 0) {
1506                 DEBUG(8,("internal_resolve_name: all lookups disabled\n"));
1507                 return NT_STATUS_INVALID_PARAMETER;
1508         }
1509
1510         if (!resolve_order[0]) {
1511                 ptr = "host";
1512         } else {
1513                 ptr = resolve_order;
1514         }
1515
1516         /* iterate through the name resolution backends */
1517
1518         frame = talloc_stackframe();
1519         while (next_token_talloc(frame, &ptr, &tok, LIST_SEP)) {
1520                 if((strequal(tok, "host") || strequal(tok, "hosts"))) {
1521                         status = resolve_hosts(name, name_type, return_iplist,
1522                                                return_count);
1523                         if (NT_STATUS_IS_OK(status)) {
1524                                 goto done;
1525                         }
1526                 } else if(strequal( tok, "kdc")) {
1527                         /* deal with KDC_NAME_TYPE names here.
1528                          * This will result in a SRV record lookup */
1529                         status = resolve_ads(name, KDC_NAME_TYPE, sitename,
1530                                              return_iplist, return_count);
1531                         if (NT_STATUS_IS_OK(status)) {
1532                                 /* Ensure we don't namecache
1533                                  * this with the KDC port. */
1534                                 name_type = KDC_NAME_TYPE;
1535                                 goto done;
1536                         }
1537                 } else if(strequal( tok, "ads")) {
1538                         /* deal with 0x1c and 0x1b names here.
1539                          * This will result in a SRV record lookup */
1540                         status = resolve_ads(name, name_type, sitename,
1541                                              return_iplist, return_count);
1542                         if (NT_STATUS_IS_OK(status)) {
1543                                 goto done;
1544                         }
1545                 } else if(strequal( tok, "lmhosts")) {
1546                         status = resolve_lmhosts(name, name_type,
1547                                                  return_iplist, return_count);
1548                         if (NT_STATUS_IS_OK(status)) {
1549                                 goto done;
1550                         }
1551                 } else if(strequal( tok, "wins")) {
1552                         /* don't resolve 1D via WINS */
1553                         if (name_type != 0x1D) {
1554                                 status = resolve_wins(name, name_type,
1555                                                       return_iplist,
1556                                                       return_count);
1557                                 if (NT_STATUS_IS_OK(status)) {
1558                                         goto done;
1559                                 }
1560                         }
1561                 } else if(strequal( tok, "bcast")) {
1562                         status = name_resolve_bcast(name, name_type,
1563                                                     return_iplist,
1564                                                     return_count);
1565                         if (NT_STATUS_IS_OK(status)) {
1566                                 goto done;
1567                         }
1568                 } else {
1569                         DEBUG(0,("resolve_name: unknown name switch type %s\n",
1570                                 tok));
1571                 }
1572         }
1573
1574         /* All of the resolve_* functions above have returned false. */
1575
1576         TALLOC_FREE(frame);
1577         SAFE_FREE(*return_iplist);
1578         *return_count = 0;
1579
1580         return NT_STATUS_UNSUCCESSFUL;
1581
1582   done:
1583
1584         /* Remove duplicate entries.  Some queries, notably #1c (domain
1585         controllers) return the PDC in iplist[0] and then all domain
1586         controllers including the PDC in iplist[1..n].  Iterating over
1587         the iplist when the PDC is down will cause two sets of timeouts. */
1588
1589         *return_count = remove_duplicate_addrs2(*return_iplist, *return_count );
1590
1591         /* Save in name cache */
1592         if ( DEBUGLEVEL >= 100 ) {
1593                 for (i = 0; i < *return_count && DEBUGLEVEL == 100; i++) {
1594                         char addr[INET6_ADDRSTRLEN];
1595                         print_sockaddr(addr, sizeof(addr),
1596                                         &(*return_iplist)[i].ss);
1597                         DEBUG(100, ("Storing name %s of type %d (%s:%d)\n",
1598                                         name,
1599                                         name_type,
1600                                         addr,
1601                                         (*return_iplist)[i].port));
1602                 }
1603         }
1604
1605         if (*return_count) {
1606                 namecache_store(name, name_type, *return_count, *return_iplist);
1607         }
1608
1609         /* Display some debugging info */
1610
1611         if ( DEBUGLEVEL >= 10 ) {
1612                 DEBUG(10, ("internal_resolve_name: returning %d addresses: ",
1613                                         *return_count));
1614
1615                 for (i = 0; i < *return_count; i++) {
1616                         char addr[INET6_ADDRSTRLEN];
1617                         print_sockaddr(addr, sizeof(addr),
1618                                         &(*return_iplist)[i].ss);
1619                         DEBUGADD(10, ("%s:%d ",
1620                                         addr,
1621                                         (*return_iplist)[i].port));
1622                 }
1623                 DEBUG(10, ("\n"));
1624         }
1625
1626         TALLOC_FREE(frame);
1627         return status;
1628 }
1629
1630 /********************************************************
1631  Internal interface to resolve a name into one IP address.
1632  Use this function if the string is either an IP address, DNS
1633  or host name or NetBIOS name. This uses the name switch in the
1634  smb.conf to determine the order of name resolution.
1635 *********************************************************/
1636
1637 bool resolve_name(const char *name,
1638                 struct sockaddr_storage *return_ss,
1639                 int name_type,
1640                 bool prefer_ipv4)
1641 {
1642         struct ip_service *ss_list = NULL;
1643         char *sitename = NULL;
1644         int count = 0;
1645
1646         if (is_ipaddress(name)) {
1647                 return interpret_string_addr(return_ss, name, AI_NUMERICHOST);
1648         }
1649
1650         sitename = sitename_fetch(lp_realm()); /* wild guess */
1651
1652         if (NT_STATUS_IS_OK(internal_resolve_name(name, name_type, sitename,
1653                                                   &ss_list, &count,
1654                                                   lp_name_resolve_order()))) {
1655                 int i;
1656
1657                 if (prefer_ipv4) {
1658                         for (i=0; i<count; i++) {
1659                                 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
1660                                                 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss) &&
1661                                                 (ss_list[i].ss.ss_family == AF_INET)) {
1662                                         *return_ss = ss_list[i].ss;
1663                                         SAFE_FREE(ss_list);
1664                                         SAFE_FREE(sitename);
1665                                         return True;
1666                                 }
1667                         }
1668                 }
1669
1670                 /* only return valid addresses for TCP connections */
1671                 for (i=0; i<count; i++) {
1672                         if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
1673                                         !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss)) {
1674                                 *return_ss = ss_list[i].ss;
1675                                 SAFE_FREE(ss_list);
1676                                 SAFE_FREE(sitename);
1677                                 return True;
1678                         }
1679                 }
1680         }
1681
1682         SAFE_FREE(ss_list);
1683         SAFE_FREE(sitename);
1684         return False;
1685 }
1686
1687 /********************************************************
1688  Internal interface to resolve a name into a list of IP addresses.
1689  Use this function if the string is either an IP address, DNS
1690  or host name or NetBIOS name. This uses the name switch in the
1691  smb.conf to determine the order of name resolution.
1692 *********************************************************/
1693
1694 NTSTATUS resolve_name_list(TALLOC_CTX *ctx,
1695                 const char *name,
1696                 int name_type,
1697                 struct sockaddr_storage **return_ss_arr,
1698                 unsigned int *p_num_entries)
1699 {
1700         struct ip_service *ss_list = NULL;
1701         char *sitename = NULL;
1702         int count = 0;
1703         int i;
1704         unsigned int num_entries;
1705         NTSTATUS status;
1706
1707         *p_num_entries = 0;
1708         *return_ss_arr = NULL;
1709
1710         if (is_ipaddress(name)) {
1711                 *return_ss_arr = TALLOC_P(ctx, struct sockaddr_storage);
1712                 if (!*return_ss_arr) {
1713                         return NT_STATUS_NO_MEMORY;
1714                 }
1715                 if (!interpret_string_addr(*return_ss_arr, name, AI_NUMERICHOST)) {
1716                         TALLOC_FREE(*return_ss_arr);
1717                         return NT_STATUS_BAD_NETWORK_NAME;
1718                 }
1719                 *p_num_entries = 1;
1720                 return NT_STATUS_OK;
1721         }
1722
1723         sitename = sitename_fetch(lp_realm()); /* wild guess */
1724
1725         status = internal_resolve_name(name, name_type, sitename,
1726                                                   &ss_list, &count,
1727                                                   lp_name_resolve_order());
1728         SAFE_FREE(sitename);
1729
1730         if (!NT_STATUS_IS_OK(status)) {
1731                 return status;
1732         }
1733
1734         /* only return valid addresses for TCP connections */
1735         for (i=0, num_entries = 0; i<count; i++) {
1736                 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
1737                                 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss)) {
1738                         num_entries++;
1739                 }
1740         }
1741         if (num_entries == 0) {
1742                 SAFE_FREE(ss_list);
1743                 return NT_STATUS_BAD_NETWORK_NAME;
1744         }
1745
1746         *return_ss_arr = TALLOC_ARRAY(ctx,
1747                                 struct sockaddr_storage,
1748                                 num_entries);
1749         if (!(*return_ss_arr)) {
1750                 SAFE_FREE(ss_list);
1751                 return NT_STATUS_NO_MEMORY;
1752         }
1753
1754         for (i=0, num_entries = 0; i<count; i++) {
1755                 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
1756                                 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss)) {
1757                         (*return_ss_arr)[num_entries++] = ss_list[i].ss;
1758                 }
1759         }
1760
1761         status = NT_STATUS_OK;
1762         *p_num_entries = num_entries;
1763
1764         SAFE_FREE(ss_list);
1765         return NT_STATUS_OK;
1766 }
1767
1768 /********************************************************
1769  Find the IP address of the master browser or DMB for a workgroup.
1770 *********************************************************/
1771
1772 bool find_master_ip(const char *group, struct sockaddr_storage *master_ss)
1773 {
1774         struct ip_service *ip_list = NULL;
1775         int count = 0;
1776         NTSTATUS status;
1777
1778         if (lp_disable_netbios()) {
1779                 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group));
1780                 return false;
1781         }
1782
1783         status = internal_resolve_name(group, 0x1D, NULL, &ip_list, &count,
1784                                        lp_name_resolve_order());
1785         if (NT_STATUS_IS_OK(status)) {
1786                 *master_ss = ip_list[0].ss;
1787                 SAFE_FREE(ip_list);
1788                 return true;
1789         }
1790
1791         status = internal_resolve_name(group, 0x1B, NULL, &ip_list, &count,
1792                                        lp_name_resolve_order());
1793         if (NT_STATUS_IS_OK(status)) {
1794                 *master_ss = ip_list[0].ss;
1795                 SAFE_FREE(ip_list);
1796                 return true;
1797         }
1798
1799         SAFE_FREE(ip_list);
1800         return false;
1801 }
1802
1803 /********************************************************
1804  Get the IP address list of the primary domain controller
1805  for a domain.
1806 *********************************************************/
1807
1808 bool get_pdc_ip(const char *domain, struct sockaddr_storage *pss)
1809 {
1810         struct ip_service *ip_list = NULL;
1811         int count = 0;
1812         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1813
1814         /* Look up #1B name */
1815
1816         if (lp_security() == SEC_ADS) {
1817                 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
1818                                                &count, "ads");
1819         }
1820
1821         if (!NT_STATUS_IS_OK(status) || count == 0) {
1822                 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
1823                                                &count,
1824                                                lp_name_resolve_order());
1825                 if (!NT_STATUS_IS_OK(status)) {
1826                         return false;
1827                 }
1828         }
1829
1830         /* if we get more than 1 IP back we have to assume it is a
1831            multi-homed PDC and not a mess up */
1832
1833         if ( count > 1 ) {
1834                 DEBUG(6,("get_pdc_ip: PDC has %d IP addresses!\n", count));
1835                 sort_service_list(ip_list, count);
1836         }
1837
1838         *pss = ip_list[0].ss;
1839         SAFE_FREE(ip_list);
1840         return true;
1841 }
1842
1843 /* Private enum type for lookups. */
1844
1845 enum dc_lookup_type { DC_NORMAL_LOOKUP, DC_ADS_ONLY, DC_KDC_ONLY };
1846
1847 /********************************************************
1848  Get the IP address list of the domain controllers for
1849  a domain.
1850 *********************************************************/
1851
1852 static NTSTATUS get_dc_list(const char *domain,
1853                         const char *sitename,
1854                         struct ip_service **ip_list,
1855                         int *count,
1856                         enum dc_lookup_type lookup_type,
1857                         bool *ordered)
1858 {
1859         char *resolve_order = NULL;
1860         char *saf_servername = NULL;
1861         char *pserver = NULL;
1862         const char *p;
1863         char *port_str = NULL;
1864         int port;
1865         char *name;
1866         int num_addresses = 0;
1867         int  local_count, i, j;
1868         struct ip_service *return_iplist = NULL;
1869         struct ip_service *auto_ip_list = NULL;
1870         bool done_auto_lookup = false;
1871         int auto_count = 0;
1872         NTSTATUS status;
1873         TALLOC_CTX *ctx = talloc_init("get_dc_list");
1874
1875         *ip_list = NULL;
1876         *count = 0;
1877
1878         if (!ctx) {
1879                 return NT_STATUS_NO_MEMORY;
1880         }
1881
1882         *ordered = False;
1883
1884         /* if we are restricted to solely using DNS for looking
1885            up a domain controller, make sure that host lookups
1886            are enabled for the 'name resolve order'.  If host lookups
1887            are disabled and ads_only is True, then set the string to
1888            NULL. */
1889
1890         resolve_order = talloc_strdup(ctx, lp_name_resolve_order());
1891         if (!resolve_order) {
1892                 status = NT_STATUS_NO_MEMORY;
1893                 goto out;
1894         }
1895         strlower_m(resolve_order);
1896         if (lookup_type == DC_ADS_ONLY)  {
1897                 if (strstr( resolve_order, "host")) {
1898                         resolve_order = talloc_strdup(ctx, "ads");
1899
1900                         /* DNS SRV lookups used by the ads resolver
1901                            are already sorted by priority and weight */
1902                         *ordered = true;
1903                 } else {
1904                         resolve_order = talloc_strdup(ctx, "NULL");
1905                 }
1906         } else if (lookup_type == DC_KDC_ONLY) {
1907                 /* DNS SRV lookups used by the ads/kdc resolver
1908                    are already sorted by priority and weight */
1909                 *ordered = true;
1910                 resolve_order = talloc_strdup(ctx, "kdc");
1911         }
1912         if (!resolve_order) {
1913                 status = NT_STATUS_NO_MEMORY;
1914                 goto out;
1915         }
1916
1917         /* fetch the server we have affinity for.  Add the
1918            'password server' list to a search for our domain controllers */
1919
1920         saf_servername = saf_fetch( domain);
1921
1922         if (strequal(domain, lp_workgroup()) || strequal(domain, lp_realm())) {
1923                 pserver = talloc_asprintf(NULL, "%s, %s",
1924                         saf_servername ? saf_servername : "",
1925                         lp_passwordserver());
1926         } else {
1927                 pserver = talloc_asprintf(NULL, "%s, *",
1928                         saf_servername ? saf_servername : "");
1929         }
1930
1931         SAFE_FREE(saf_servername);
1932         if (!pserver) {
1933                 status = NT_STATUS_NO_MEMORY;
1934                 goto out;
1935         }
1936
1937         /* if we are starting from scratch, just lookup DOMAIN<0x1c> */
1938
1939         if (!*pserver ) {
1940                 DEBUG(10,("get_dc_list: no preferred domain controllers.\n"));
1941                 status = internal_resolve_name(domain, 0x1C, sitename, ip_list,
1942                                              count, resolve_order);
1943                 goto out;
1944         }
1945
1946         DEBUG(3,("get_dc_list: preferred server list: \"%s\"\n", pserver ));
1947
1948         /*
1949          * if '*' appears in the "password server" list then add
1950          * an auto lookup to the list of manually configured
1951          * DC's.  If any DC is listed by name, then the list should be
1952          * considered to be ordered
1953          */
1954
1955         p = pserver;
1956         while (next_token_talloc(ctx, &p, &name, LIST_SEP)) {
1957                 if (!done_auto_lookup && strequal(name, "*")) {
1958                         status = internal_resolve_name(domain, 0x1C, sitename,
1959                                                        &auto_ip_list,
1960                                                        &auto_count,
1961                                                        resolve_order);
1962                         if (NT_STATUS_IS_OK(status)) {
1963                                 num_addresses += auto_count;
1964                         }
1965                         done_auto_lookup = true;
1966                         DEBUG(8,("Adding %d DC's from auto lookup\n",
1967                                                 auto_count));
1968                 } else  {
1969                         num_addresses++;
1970                 }
1971         }
1972
1973         /* if we have no addresses and haven't done the auto lookup, then
1974            just return the list of DC's.  Or maybe we just failed. */
1975
1976         if ((num_addresses == 0)) {
1977                 if (done_auto_lookup) {
1978                         DEBUG(4,("get_dc_list: no servers found\n"));
1979                         status = NT_STATUS_NO_LOGON_SERVERS;
1980                         goto out;
1981                 }
1982                 status = internal_resolve_name(domain, 0x1C, sitename, ip_list,
1983                                              count, resolve_order);
1984                 goto out;
1985         }
1986
1987         if ((return_iplist = SMB_MALLOC_ARRAY(struct ip_service,
1988                                         num_addresses)) == NULL) {
1989                 DEBUG(3,("get_dc_list: malloc fail !\n"));
1990                 status = NT_STATUS_NO_MEMORY;
1991                 goto out;
1992         }
1993
1994         p = pserver;
1995         local_count = 0;
1996
1997         /* fill in the return list now with real IP's */
1998
1999         while ((local_count<num_addresses) &&
2000                         next_token_talloc(ctx, &p, &name, LIST_SEP)) {
2001                 struct sockaddr_storage name_ss;
2002
2003                 /* copy any addersses from the auto lookup */
2004
2005                 if (strequal(name, "*")) {
2006                         for (j=0; j<auto_count; j++) {
2007                                 char addr[INET6_ADDRSTRLEN];
2008                                 print_sockaddr(addr,
2009                                                 sizeof(addr),
2010                                                 &auto_ip_list[j].ss);
2011                                 /* Check for and don't copy any
2012                                  * known bad DC IP's. */
2013                                 if(!NT_STATUS_IS_OK(check_negative_conn_cache(
2014                                                 domain,
2015                                                 addr))) {
2016                                         DEBUG(5,("get_dc_list: "
2017                                                 "negative entry %s removed "
2018                                                 "from DC list\n",
2019                                                 addr));
2020                                         continue;
2021                                 }
2022                                 return_iplist[local_count].ss =
2023                                         auto_ip_list[j].ss;
2024                                 return_iplist[local_count].port =
2025                                         auto_ip_list[j].port;
2026                                 local_count++;
2027                         }
2028                         continue;
2029                 }
2030
2031                 /* added support for address:port syntax for ads
2032                  * (not that I think anyone will ever run the LDAP
2033                  * server in an AD domain on something other than
2034                  * port 389 */
2035
2036                 port = (lp_security() == SEC_ADS) ? LDAP_PORT : PORT_NONE;
2037                 if ((port_str=strchr(name, ':')) != NULL) {
2038                         *port_str = '\0';
2039                         port_str++;
2040                         port = atoi(port_str);
2041                 }
2042
2043                 /* explicit lookup; resolve_name() will
2044                  * handle names & IP addresses */
2045                 if (resolve_name( name, &name_ss, 0x20, true )) {
2046                         char addr[INET6_ADDRSTRLEN];
2047                         print_sockaddr(addr,
2048                                         sizeof(addr),
2049                                         &name_ss);
2050
2051                         /* Check for and don't copy any known bad DC IP's. */
2052                         if( !NT_STATUS_IS_OK(check_negative_conn_cache(domain,
2053                                                         addr)) ) {
2054                                 DEBUG(5,("get_dc_list: negative entry %s "
2055                                         "removed from DC list\n",
2056                                         name ));
2057                                 continue;
2058                         }
2059
2060                         return_iplist[local_count].ss = name_ss;
2061                         return_iplist[local_count].port = port;
2062                         local_count++;
2063                         *ordered = true;
2064                 }
2065         }
2066
2067         /* need to remove duplicates in the list if we have any
2068            explicit password servers */
2069
2070         local_count = remove_duplicate_addrs2(return_iplist, local_count );
2071
2072         /* For DC's we always prioritize IPv4 due to W2K3 not
2073          * supporting LDAP, KRB5 or CLDAP over IPv6. */
2074
2075         if (local_count && return_iplist) {
2076                 prioritize_ipv4_list(return_iplist, local_count);
2077         }
2078
2079         if ( DEBUGLEVEL >= 4 ) {
2080                 DEBUG(4,("get_dc_list: returning %d ip addresses "
2081                                 "in an %sordered list\n",
2082                                 local_count,
2083                                 *ordered ? "":"un"));
2084                 DEBUG(4,("get_dc_list: "));
2085                 for ( i=0; i<local_count; i++ ) {
2086                         char addr[INET6_ADDRSTRLEN];
2087                         print_sockaddr(addr,
2088                                         sizeof(addr),
2089                                         &return_iplist[i].ss);
2090                         DEBUGADD(4,("%s:%d ", addr, return_iplist[i].port ));
2091                 }
2092                 DEBUGADD(4,("\n"));
2093         }
2094
2095         *ip_list = return_iplist;
2096         *count = local_count;
2097
2098         status = ( *count != 0 ? NT_STATUS_OK : NT_STATUS_NO_LOGON_SERVERS );
2099
2100   out:
2101
2102         if (!NT_STATUS_IS_OK(status)) {
2103                 SAFE_FREE(return_iplist);
2104                 *ip_list = NULL;
2105                 *count = 0;
2106         }
2107
2108         SAFE_FREE(auto_ip_list);
2109         TALLOC_FREE(ctx);
2110         return status;
2111 }
2112
2113 /*********************************************************************
2114  Small wrapper function to get the DC list and sort it if neccessary.
2115 *********************************************************************/
2116
2117 NTSTATUS get_sorted_dc_list( const char *domain,
2118                         const char *sitename,
2119                         struct ip_service **ip_list,
2120                         int *count,
2121                         bool ads_only )
2122 {
2123         bool ordered = false;
2124         NTSTATUS status;
2125         enum dc_lookup_type lookup_type = DC_NORMAL_LOOKUP;
2126
2127         *ip_list = NULL;
2128         *count = 0;
2129
2130         DEBUG(8,("get_sorted_dc_list: attempting lookup "
2131                 "for name %s (sitename %s) using [%s]\n",
2132                 domain,
2133                 sitename ? sitename : "NULL",
2134                 (ads_only ? "ads" : lp_name_resolve_order())));
2135
2136         if (ads_only) {
2137                 lookup_type = DC_ADS_ONLY;
2138         }
2139
2140         status = get_dc_list(domain, sitename, ip_list,
2141                         count, lookup_type, &ordered);
2142         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_LOGON_SERVERS)
2143             && sitename) {
2144                 DEBUG(3,("get_sorted_dc_list: no server for name %s available"
2145                          " in site %s, fallback to all servers\n",
2146                          domain, sitename));
2147                 status = get_dc_list(domain, NULL, ip_list,
2148                                      count, lookup_type, &ordered);
2149         }
2150
2151         if (!NT_STATUS_IS_OK(status)) {
2152                 SAFE_FREE(*ip_list);
2153                 *count = 0;
2154                 return status;
2155         }
2156
2157         /* only sort if we don't already have an ordered list */
2158         if (!ordered) {
2159                 sort_service_list(*ip_list, *count);
2160         }
2161
2162         return NT_STATUS_OK;
2163 }
2164
2165 /*********************************************************************
2166  Get the KDC list - re-use all the logic in get_dc_list.
2167 *********************************************************************/
2168
2169 NTSTATUS get_kdc_list( const char *realm,
2170                         const char *sitename,
2171                         struct ip_service **ip_list,
2172                         int *count)
2173 {
2174         bool ordered;
2175         NTSTATUS status;
2176
2177         *count = 0;
2178         *ip_list = NULL;
2179
2180         status = get_dc_list(realm, sitename, ip_list,
2181                         count, DC_KDC_ONLY, &ordered);
2182
2183         if (!NT_STATUS_IS_OK(status)) {
2184                 SAFE_FREE(*ip_list);
2185                 *count = 0;
2186                 return status;
2187         }
2188
2189         /* only sort if we don't already have an ordered list */
2190         if ( !ordered ) {
2191                 sort_service_list(*ip_list, *count);
2192         }
2193
2194         return NT_STATUS_OK;
2195 }