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