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