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 "libsmb/namequery.h"
  23 #include "../lib/util/tevent_ntstatus.h"
  24 #include "libads/sitename_cache.h"
  25 #include "../lib/addns/dnsquery.h"
  26 #include "../libcli/netlogon/netlogon.h"
  27 #include "lib/async_req/async_sock.h"
  28 #include "lib/tsocket/tsocket.h"
  29 #include "libsmb/nmblib.h"
  30 #include "libsmb/unexpected.h"
  31 #include "../libcli/nbt/libnbt.h"
  32 #include "libads/kerberos_proto.h"
  33 #include "lib/gencache.h"
  34 #include "librpc/gen_ndr/dns.h"
  35 #include "lib/util/util_net.h"
  36 #include "lib/util/string_wrappers.h"
  37
  38 /* nmbd.c sets this to True. */
  39 bool global_in_nmbd = False;
  40
  41 /*
  42  * Utility function that copes only with AF_INET and AF_INET6
  43  * as that's all we're going to get out of DNS / NetBIOS / WINS
  44  * name resolution functions.
  45  */
  46
  47 bool sockaddr_storage_to_samba_sockaddr(struct samba_sockaddr *sa,
  48                                         const struct sockaddr_storage *ss)
  49 {
  50         sa->u.ss = *ss;
  51
  52         switch (ss->ss_family) {
  53         case AF_INET:
  54                 sa->sa_socklen = sizeof(struct sockaddr_in);
  55                 break;
  56 #ifdef HAVE_IPV6
  57         case AF_INET6:
  58                 sa->sa_socklen = sizeof(struct sockaddr_in6);
  59                 break;
  60 #endif
  61         default:
  62                 return false;
  63         }
  64         return true;
  65 }
  66
  67 /*
  68  * Utility function to convert from a sockaddr_storage
  69  * array to a struct samba_sockaddr array.
  70  */
  71
  72 static NTSTATUS sockaddr_array_to_samba_sockaddr_array(
  73                                 TALLOC_CTX *ctx,
  74                                 struct samba_sockaddr **sa_out,
  75                                 size_t *count_out,
  76                                 const struct sockaddr_storage *ss_in,
  77                                 size_t count_in)
  78 {
  79         struct samba_sockaddr *sa = NULL;
  80         size_t i;
  81         size_t count = 0;
  82
  83         if (count_in == 0) {
  84                 /*
  85                  * Zero length arrays are returned as NULL.
  86                  * in the name resolution code.
  87                  */
  88                 *count_out = 0;
  89                 *sa_out = NULL;
  90                 return NT_STATUS_OK;
  91         }
  92         sa = talloc_zero_array(ctx,
  93                                 struct samba_sockaddr,
  94                                 count_in);
  95         if (sa == NULL) {
  96                 return NT_STATUS_NO_MEMORY;
  97         }
  98         count = 0;
  99         for (i = 0; i < count_in; i++) {
 100                 bool ok;
 101
 102                 /* Filter out zero addresses. */
 103                 if (is_zero_addr(&ss_in[i])) {
 104                         continue;
 105                 }
 106                 ok = sockaddr_storage_to_samba_sockaddr(&sa[count],
 107                                                         &ss_in[i]);
 108                 if (!ok) {
 109                         continue;
 110                 }
 111                 count++;
 112         }
 113         if (count == 0) {
 114                 /*
 115                  * Zero length arrays are returned as NULL.
 116                  * in the name resolution code.
 117                  */
 118                 TALLOC_FREE(sa);
 119         }
 120         *count_out = count;
 121         *sa_out = sa;
 122         return NT_STATUS_OK;
 123 }
 124
 125 /****************************
 126  * SERVER AFFINITY ROUTINES *
 127  ****************************/
 128
 129  /* Server affinity is the concept of preferring the last domain
 130     controller with whom you had a successful conversation */
 131
 132 /****************************************************************************
 133 ****************************************************************************/
 134 #define SAFKEY_FMT      "SAF/DOMAIN/%s"
 135 #define SAF_TTL         900
 136 #define SAFJOINKEY_FMT  "SAFJOIN/DOMAIN/%s"
 137 #define SAFJOIN_TTL     3600
 138
 139 static char *saf_key(TALLOC_CTX *mem_ctx, const char *domain)
 140 {
 141         return talloc_asprintf_strupper_m(mem_ctx, SAFKEY_FMT, domain);
 142 }
 143
 144 static char *saf_join_key(TALLOC_CTX *mem_ctx, const char *domain)
 145 {
 146         return talloc_asprintf_strupper_m(mem_ctx, SAFJOINKEY_FMT, domain);
 147 }
 148
 149 /****************************************************************************
 150 ****************************************************************************/
 151
 152 bool saf_store( const char *domain, const char *servername )
 153 {
 154         char *key;
 155         time_t expire;
 156         bool ret = False;
 157
 158         if ( !domain || !servername ) {
 159                 DEBUG(2,("saf_store: "
 160                         "Refusing to store empty domain or servername!\n"));
 161                 return False;
 162         }
 163
 164         if ( (strlen(domain) == 0) || (strlen(servername) == 0) ) {
 165                 DEBUG(0,("saf_store: "
 166                         "refusing to store 0 length domain or servername!\n"));
 167                 return False;
 168         }
 169
 170         key = saf_key(talloc_tos(), domain);
 171         if (key == NULL) {
 172                 DEBUG(1, ("saf_key() failed\n"));
 173                 return false;
 174         }
 175         expire = time( NULL ) + lp_parm_int(-1, "saf","ttl", SAF_TTL);
 176
 177         DEBUG(10,("saf_store: domain = [%s], server = [%s], expire = [%u]\n",
 178                 domain, servername, (unsigned int)expire ));
 179
 180         ret = gencache_set( key, servername, expire );
 181
 182         TALLOC_FREE( key );
 183
 184         return ret;
 185 }
 186
 187 bool saf_join_store( const char *domain, const char *servername )
 188 {
 189         char *key;
 190         time_t expire;
 191         bool ret = False;
 192
 193         if ( !domain || !servername ) {
 194                 DEBUG(2,("saf_join_store: Refusing to store empty domain or servername!\n"));
 195                 return False;
 196         }
 197
 198         if ( (strlen(domain) == 0) || (strlen(servername) == 0) ) {
 199                 DEBUG(0,("saf_join_store: refusing to store 0 length domain or servername!\n"));
 200                 return False;
 201         }
 202
 203         key = saf_join_key(talloc_tos(), domain);
 204         if (key == NULL) {
 205                 DEBUG(1, ("saf_join_key() failed\n"));
 206                 return false;
 207         }
 208         expire = time( NULL ) + lp_parm_int(-1, "saf","join ttl", SAFJOIN_TTL);
 209
 210         DEBUG(10,("saf_join_store: domain = [%s], server = [%s], expire = [%u]\n",
 211                 domain, servername, (unsigned int)expire ));
 212
 213         ret = gencache_set( key, servername, expire );
 214
 215         TALLOC_FREE( key );
 216
 217         return ret;
 218 }
 219
 220 bool saf_delete( const char *domain )
 221 {
 222         char *key;
 223         bool ret = False;
 224
 225         if ( !domain ) {
 226                 DEBUG(2,("saf_delete: Refusing to delete empty domain\n"));
 227                 return False;
 228         }
 229
 230         key = saf_join_key(talloc_tos(), domain);
 231         if (key == NULL) {
 232                 DEBUG(1, ("saf_join_key() failed\n"));
 233                 return false;
 234         }
 235         ret = gencache_del(key);
 236         TALLOC_FREE(key);
 237
 238         if (ret) {
 239                 DEBUG(10,("saf_delete[join]: domain = [%s]\n", domain ));
 240         }
 241
 242         key = saf_key(talloc_tos(), domain);
 243         if (key == NULL) {
 244                 DEBUG(1, ("saf_key() failed\n"));
 245                 return false;
 246         }
 247         ret = gencache_del(key);
 248         TALLOC_FREE(key);
 249
 250         if (ret) {
 251                 DEBUG(10,("saf_delete: domain = [%s]\n", domain ));
 252         }
 253
 254         return ret;
 255 }
 256
 257 /****************************************************************************
 258 ****************************************************************************/
 259
 260 char *saf_fetch(TALLOC_CTX *mem_ctx, const char *domain )
 261 {
 262         char *server = NULL;
 263         time_t timeout;
 264         bool ret = False;
 265         char *key = NULL;
 266
 267         if ( !domain || strlen(domain) == 0) {
 268                 DEBUG(2,("saf_fetch: Empty domain name!\n"));
 269                 return NULL;
 270         }
 271
 272         key = saf_join_key(talloc_tos(), domain);
 273         if (key == NULL) {
 274                 DEBUG(1, ("saf_join_key() failed\n"));
 275                 return NULL;
 276         }
 277
 278         ret = gencache_get( key, mem_ctx, &server, &timeout );
 279
 280         TALLOC_FREE( key );
 281
 282         if ( ret ) {
 283                 DEBUG(5,("saf_fetch[join]: Returning \"%s\" for \"%s\" domain\n",
 284                         server, domain ));
 285                 return server;
 286         }
 287
 288         key = saf_key(talloc_tos(), domain);
 289         if (key == NULL) {
 290                 DEBUG(1, ("saf_key() failed\n"));
 291                 return NULL;
 292         }
 293
 294         ret = gencache_get( key, mem_ctx, &server, &timeout );
 295
 296         TALLOC_FREE( key );
 297
 298         if ( !ret ) {
 299                 DEBUG(5,("saf_fetch: failed to find server for \"%s\" domain\n",
 300                                         domain ));
 301         } else {
 302                 DEBUG(5,("saf_fetch: Returning \"%s\" for \"%s\" domain\n",
 303                         server, domain ));
 304         }
 305
 306         return server;
 307 }
 308
 309 static void set_socket_addr_v4(struct samba_sockaddr *addr)
 310 {
 311         if (!interpret_string_addr(&addr->u.ss, lp_nbt_client_socket_address(),
 312                                    AI_NUMERICHOST|AI_PASSIVE)) {
 313                 zero_sockaddr(&addr->u.ss);
 314                 /* zero_sockaddr sets family to AF_INET. */
 315                 addr->sa_socklen = sizeof(struct sockaddr_in);
 316         }
 317         if (addr->u.ss.ss_family != AF_INET) {
 318                 zero_sockaddr(&addr->u.ss);
 319                 /* zero_sockaddr sets family to AF_INET. */
 320                 addr->sa_socklen = sizeof(struct sockaddr_in);
 321         }
 322 }
 323
 324 static struct in_addr my_socket_addr_v4(void)
 325 {
 326         struct samba_sockaddr my_addr = {0};
 327
 328         set_socket_addr_v4(&my_addr);
 329         return my_addr.u.in.sin_addr;
 330 }
 331
 332 /****************************************************************************
 333  Generate a random trn_id.
 334 ****************************************************************************/
 335
 336 static int generate_trn_id(void)
 337 {
 338         uint16_t id;
 339
 340         generate_random_buffer((uint8_t *)&id, sizeof(id));
 341
 342         return id % (unsigned)0x7FFF;
 343 }
 344
 345 /****************************************************************************
 346  Parse a node status response into an array of structures.
 347 ****************************************************************************/
 348
 349 static struct node_status *parse_node_status(TALLOC_CTX *mem_ctx, char *p,
 350                                 size_t *num_names,
 351                                 struct node_status_extra *extra)
 352 {
 353         struct node_status *ret;
 354         size_t i;
 355         size_t result_count = 0;
 356
 357         result_count = CVAL(p,0);
 358
 359         if (result_count == 0)
 360                 return NULL;
 361
 362         ret = talloc_array(mem_ctx, struct node_status,result_count);
 363         if (!ret)
 364                 return NULL;
 365
 366         p++;
 367         for (i=0;i< result_count;i++) {
 368                 strlcpy(ret[i].name,p,16);
 369                 trim_char(ret[i].name,'\0',' ');
 370                 ret[i].type = CVAL(p,15);
 371                 ret[i].flags = p[16];
 372                 p += 18;
 373                 DEBUG(10, ("%s#%02x: flags = 0x%02x\n", ret[i].name,
 374                            ret[i].type, ret[i].flags));
 375         }
 376         /*
 377          * Also, pick up the MAC address ...
 378          */
 379         if (extra) {
 380                 memcpy(&extra->mac_addr, p, 6); /* Fill in the mac addr */
 381         }
 382         *num_names = result_count;
 383         return ret;
 384 }
 385
 386 struct sock_packet_read_state {
 387         struct tevent_context *ev;
 388         enum packet_type type;
 389         int trn_id;
 390
 391         struct nb_packet_reader *reader;
 392         struct tevent_req *reader_req;
 393
 394         struct tdgram_context *sock;
 395         struct tevent_req *socket_req;
 396         uint8_t *buf;
 397         struct tsocket_address *addr;
 398
 399         bool (*validator)(struct packet_struct *p,
 400                           void *private_data);
 401         void *private_data;
 402
 403         struct packet_struct *packet;
 404 };
 405
 406 static void sock_packet_read_got_packet(struct tevent_req *subreq);
 407 static void sock_packet_read_got_socket(struct tevent_req *subreq);
 408
 409 static struct tevent_req *sock_packet_read_send(
 410         TALLOC_CTX *mem_ctx,
 411         struct tevent_context *ev,
 412         struct tdgram_context *sock,
 413         struct nb_packet_reader *reader,
 414         enum packet_type type,
 415         int trn_id,
 416         bool (*validator)(struct packet_struct *p, void *private_data),
 417         void *private_data)
 418 {
 419         struct tevent_req *req;
 420         struct sock_packet_read_state *state;
 421
 422         req = tevent_req_create(mem_ctx, &state,
 423                                 struct sock_packet_read_state);
 424         if (req == NULL) {
 425                 return NULL;
 426         }
 427         state->ev = ev;
 428         state->reader = reader;
 429         state->sock = sock;
 430         state->type = type;
 431         state->trn_id = trn_id;
 432         state->validator = validator;
 433         state->private_data = private_data;
 434
 435         if (reader != NULL) {
 436                 state->reader_req = nb_packet_read_send(state, ev, reader);
 437                 if (tevent_req_nomem(state->reader_req, req)) {
 438                         return tevent_req_post(req, ev);
 439                 }
 440                 tevent_req_set_callback(
 441                         state->reader_req, sock_packet_read_got_packet, req);
 442         }
 443
 444         state->socket_req = tdgram_recvfrom_send(state, ev, state->sock);
 445         if (tevent_req_nomem(state->socket_req, req)) {
 446                 return tevent_req_post(req, ev);
 447         }
 448         tevent_req_set_callback(state->socket_req, sock_packet_read_got_socket,
 449                                 req);
 450
 451         return req;
 452 }
 453
 454 static void sock_packet_read_got_packet(struct tevent_req *subreq)
 455 {
 456         struct tevent_req *req = tevent_req_callback_data(
 457                 subreq, struct tevent_req);
 458         struct sock_packet_read_state *state = tevent_req_data(
 459                 req, struct sock_packet_read_state);
 460         NTSTATUS status;
 461
 462         status = nb_packet_read_recv(subreq, state, &state->packet);
 463
 464         TALLOC_FREE(state->reader_req);
 465
 466         if (!NT_STATUS_IS_OK(status)) {
 467                 if (state->socket_req != NULL) {
 468                         /*
 469                          * Still waiting for socket
 470                          */
 471                         return;
 472                 }
 473                 /*
 474                  * Both socket and packet reader failed
 475                  */
 476                 tevent_req_nterror(req, status);
 477                 return;
 478         }
 479
 480         if ((state->validator != NULL) &&
 481             !state->validator(state->packet, state->private_data)) {
 482                 DEBUG(10, ("validator failed\n"));
 483
 484                 TALLOC_FREE(state->packet);
 485
 486                 state->reader_req = nb_packet_read_send(state, state->ev,
 487                                                         state->reader);
 488                 if (tevent_req_nomem(state->reader_req, req)) {
 489                         return;
 490                 }
 491                 tevent_req_set_callback(
 492                         state->reader_req, sock_packet_read_got_packet, req);
 493                 return;
 494         }
 495
 496         TALLOC_FREE(state->socket_req);
 497         tevent_req_done(req);
 498 }
 499
 500 static void sock_packet_read_got_socket(struct tevent_req *subreq)
 501 {
 502         struct tevent_req *req = tevent_req_callback_data(
 503                 subreq, struct tevent_req);
 504         struct sock_packet_read_state *state = tevent_req_data(
 505                 req, struct sock_packet_read_state);
 506         struct samba_sockaddr addr = {0};
 507         ssize_t ret;
 508         ssize_t received;
 509         int err;
 510         bool ok;
 511
 512         received = tdgram_recvfrom_recv(subreq, &err, state,
 513                                         &state->buf, &state->addr);
 514
 515         TALLOC_FREE(state->socket_req);
 516
 517         if (received == -1) {
 518                 if (state->reader_req != NULL) {
 519                         /*
 520                          * Still waiting for reader
 521                          */
 522                         return;
 523                 }
 524                 /*
 525                  * Both socket and reader failed
 526                  */
 527                 tevent_req_nterror(req, map_nt_error_from_unix(err));
 528                 return;
 529         }
 530         ok = tsocket_address_is_inet(state->addr, "ipv4");
 531         if (!ok) {
 532                 goto retry;
 533         }
 534         ret = tsocket_address_bsd_sockaddr(state->addr,
 535                                         &addr.u.sa,
 536                                         sizeof(addr.u.in));
 537         if (ret == -1) {
 538                 tevent_req_nterror(req, map_nt_error_from_unix(errno));
 539                 return;
 540         }
 541
 542         state->packet = parse_packet_talloc(
 543                 state, (char *)state->buf, received, state->type,
 544                 addr.u.in.sin_addr, addr.u.in.sin_port);
 545         if (state->packet == NULL) {
 546                 DEBUG(10, ("parse_packet failed\n"));
 547                 goto retry;
 548         }
 549         if ((state->trn_id != -1) &&
 550             (state->trn_id != packet_trn_id(state->packet))) {
 551                 DEBUG(10, ("Expected transaction id %d, got %d\n",
 552                            state->trn_id, packet_trn_id(state->packet)));
 553                 goto retry;
 554         }
 555
 556         if ((state->validator != NULL) &&
 557             !state->validator(state->packet, state->private_data)) {
 558                 DEBUG(10, ("validator failed\n"));
 559                 goto retry;
 560         }
 561
 562         tevent_req_done(req);
 563         return;
 564
 565 retry:
 566         TALLOC_FREE(state->packet);
 567         TALLOC_FREE(state->buf);
 568         TALLOC_FREE(state->addr);
 569
 570         state->socket_req = tdgram_recvfrom_send(state, state->ev, state->sock);
 571         if (tevent_req_nomem(state->socket_req, req)) {
 572                 return;
 573         }
 574         tevent_req_set_callback(state->socket_req, sock_packet_read_got_socket,
 575                                 req);
 576 }
 577
 578 static NTSTATUS sock_packet_read_recv(struct tevent_req *req,
 579                                       TALLOC_CTX *mem_ctx,
 580                                       struct packet_struct **ppacket)
 581 {
 582         struct sock_packet_read_state *state = tevent_req_data(
 583                 req, struct sock_packet_read_state);
 584         NTSTATUS status;
 585
 586         if (tevent_req_is_nterror(req, &status)) {
 587                 return status;
 588         }
 589         *ppacket = talloc_move(mem_ctx, &state->packet);
 590         return NT_STATUS_OK;
 591 }
 592
 593 struct nb_trans_state {
 594         struct tevent_context *ev;
 595         struct tdgram_context *sock;
 596         struct nb_packet_reader *reader;
 597
 598         struct tsocket_address *src_addr;
 599         struct tsocket_address *dst_addr;
 600         uint8_t *buf;
 601         size_t buflen;
 602         enum packet_type type;
 603         int trn_id;
 604
 605         bool (*validator)(struct packet_struct *p,
 606                           void *private_data);
 607         void *private_data;
 608
 609         struct packet_struct *packet;
 610 };
 611
 612 static void nb_trans_got_reader(struct tevent_req *subreq);
 613 static void nb_trans_done(struct tevent_req *subreq);
 614 static void nb_trans_sent(struct tevent_req *subreq);
 615 static void nb_trans_send_next(struct tevent_req *subreq);
 616
 617 static struct tevent_req *nb_trans_send(
 618         TALLOC_CTX *mem_ctx,
 619         struct tevent_context *ev,
 620         const struct samba_sockaddr *_my_addr,
 621         const struct samba_sockaddr *_dst_addr,
 622         bool bcast,
 623         uint8_t *buf, size_t buflen,
 624         enum packet_type type, int trn_id,
 625         bool (*validator)(struct packet_struct *p,
 626                           void *private_data),
 627         void *private_data)
 628 {
 629         const struct sockaddr *my_addr = &_my_addr->u.sa;
 630         size_t my_addr_len = sizeof(_my_addr->u.in); /*We know it's AF_INET.*/
 631         const struct sockaddr *dst_addr = &_dst_addr->u.sa;
 632         size_t dst_addr_len = sizeof(_dst_addr->u.in); /*We know it's AF_INET.*/
 633         struct tevent_req *req, *subreq;
 634         struct nb_trans_state *state;
 635         int ret;
 636
 637         req = tevent_req_create(mem_ctx, &state, struct nb_trans_state);
 638         if (req == NULL) {
 639                 return NULL;
 640         }
 641         state->ev = ev;
 642         state->buf = buf;
 643         state->buflen = buflen;
 644         state->type = type;
 645         state->trn_id = trn_id;
 646         state->validator = validator;
 647         state->private_data = private_data;
 648
 649         ret = tsocket_address_bsd_from_sockaddr(state,
 650                                                 my_addr, my_addr_len,
 651                                                 &state->src_addr);
 652         if (ret == -1) {
 653                 tevent_req_nterror(req, map_nt_error_from_unix(errno));
 654                 return tevent_req_post(req, ev);
 655         }
 656
 657         ret = tsocket_address_bsd_from_sockaddr(state,
 658                                                 dst_addr, dst_addr_len,
 659                                                 &state->dst_addr);
 660         if (ret == -1) {
 661                 tevent_req_nterror(req, map_nt_error_from_unix(errno));
 662                 return tevent_req_post(req, ev);
 663         }
 664
 665         ret = tdgram_inet_udp_broadcast_socket(state->src_addr, state,
 666                                                &state->sock);
 667         if (ret == -1) {
 668                 tevent_req_nterror(req, map_nt_error_from_unix(errno));
 669                 return tevent_req_post(req, ev);
 670         }
 671
 672         subreq = nb_packet_reader_send(state, ev, type, state->trn_id, NULL);
 673         if (tevent_req_nomem(subreq, req)) {
 674                 return tevent_req_post(req, ev);
 675         }
 676         tevent_req_set_callback(subreq, nb_trans_got_reader, req);
 677         return req;
 678 }
 679
 680 static void nb_trans_got_reader(struct tevent_req *subreq)
 681 {
 682         struct tevent_req *req = tevent_req_callback_data(
 683                 subreq, struct tevent_req);
 684         struct nb_trans_state *state = tevent_req_data(
 685                 req, struct nb_trans_state);
 686         NTSTATUS status;
 687
 688         status = nb_packet_reader_recv(subreq, state, &state->reader);
 689         TALLOC_FREE(subreq);
 690
 691         if (!NT_STATUS_IS_OK(status)) {
 692                 DEBUG(10, ("nmbd not around\n"));
 693                 state->reader = NULL;
 694         }
 695
 696         subreq = sock_packet_read_send(
 697                 state, state->ev, state->sock,
 698                 state->reader, state->type, state->trn_id,
 699                 state->validator, state->private_data);
 700         if (tevent_req_nomem(subreq, req)) {
 701                 return;
 702         }
 703         tevent_req_set_callback(subreq, nb_trans_done, req);
 704
 705         subreq = tdgram_sendto_send(state, state->ev,
 706                                     state->sock,
 707                                     state->buf, state->buflen,
 708                                     state->dst_addr);
 709         if (tevent_req_nomem(subreq, req)) {
 710                 return;
 711         }
 712         tevent_req_set_callback(subreq, nb_trans_sent, req);
 713 }
 714
 715 static void nb_trans_sent(struct tevent_req *subreq)
 716 {
 717         struct tevent_req *req = tevent_req_callback_data(
 718                 subreq, struct tevent_req);
 719         struct nb_trans_state *state = tevent_req_data(
 720                 req, struct nb_trans_state);
 721         ssize_t sent;
 722         int err;
 723
 724         sent = tdgram_sendto_recv(subreq, &err);
 725         TALLOC_FREE(subreq);
 726         if (sent == -1) {
 727                 DEBUG(10, ("sendto failed: %s\n", strerror(err)));
 728                 tevent_req_nterror(req, map_nt_error_from_unix(err));
 729                 return;
 730         }
 731         subreq = tevent_wakeup_send(state, state->ev,
 732                                     timeval_current_ofs(1, 0));
 733         if (tevent_req_nomem(subreq, req)) {
 734                 return;
 735         }
 736         tevent_req_set_callback(subreq, nb_trans_send_next, req);
 737 }
 738
 739 static void nb_trans_send_next(struct tevent_req *subreq)
 740 {
 741         struct tevent_req *req = tevent_req_callback_data(
 742                 subreq, struct tevent_req);
 743         struct nb_trans_state *state = tevent_req_data(
 744                 req, struct nb_trans_state);
 745         bool ret;
 746
 747         ret = tevent_wakeup_recv(subreq);
 748         TALLOC_FREE(subreq);
 749         if (!ret) {
 750                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
 751                 return;
 752         }
 753         subreq = tdgram_sendto_send(state, state->ev,
 754                                     state->sock,
 755                                     state->buf, state->buflen,
 756                                     state->dst_addr);
 757         if (tevent_req_nomem(subreq, req)) {
 758                 return;
 759         }
 760         tevent_req_set_callback(subreq, nb_trans_sent, req);
 761 }
 762
 763 static void nb_trans_done(struct tevent_req *subreq)
 764 {
 765         struct tevent_req *req = tevent_req_callback_data(
 766                 subreq, struct tevent_req);
 767         struct nb_trans_state *state = tevent_req_data(
 768                 req, struct nb_trans_state);
 769         NTSTATUS status;
 770
 771         status = sock_packet_read_recv(subreq, state, &state->packet);
 772         TALLOC_FREE(subreq);
 773         if (tevent_req_nterror(req, status)) {
 774                 return;
 775         }
 776         tevent_req_done(req);
 777 }
 778
 779 static NTSTATUS nb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 780                               struct packet_struct **ppacket)
 781 {
 782         struct nb_trans_state *state = tevent_req_data(
 783                 req, struct nb_trans_state);
 784         NTSTATUS status;
 785
 786         if (tevent_req_is_nterror(req, &status)) {
 787                 return status;
 788         }
 789         *ppacket = talloc_move(mem_ctx, &state->packet);
 790         return NT_STATUS_OK;
 791 }
 792
 793 /****************************************************************************
 794  Do a NBT node status query on an open socket and return an array of
 795  structures holding the returned names or NULL if the query failed.
 796 **************************************************************************/
 797
 798 struct node_status_query_state {
 799         struct samba_sockaddr my_addr;
 800         struct samba_sockaddr addr;
 801         uint8_t buf[1024];
 802         ssize_t buflen;
 803         struct packet_struct *packet;
 804 };
 805
 806 static bool node_status_query_validator(struct packet_struct *p,
 807                                         void *private_data);
 808 static void node_status_query_done(struct tevent_req *subreq);
 809
 810 struct tevent_req *node_status_query_send(TALLOC_CTX *mem_ctx,
 811                                           struct tevent_context *ev,
 812                                           struct nmb_name *name,
 813                                           const struct sockaddr_storage *addr)
 814 {
 815         struct tevent_req *req, *subreq;
 816         struct node_status_query_state *state;
 817         struct packet_struct p;
 818         struct nmb_packet *nmb = &p.packet.nmb;
 819         bool ok;
 820
 821         req = tevent_req_create(mem_ctx, &state,
 822                                 struct node_status_query_state);
 823         if (req == NULL) {
 824                 return NULL;
 825         }
 826
 827         if (addr->ss_family != AF_INET) {
 828                 /* Can't do node status to IPv6 */
 829                 tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
 830                 return tevent_req_post(req, ev);
 831         }
 832
 833         ok = sockaddr_storage_to_samba_sockaddr(&state->addr, addr);
 834         if (!ok) {
 835                 /* node status must be IPv4 */
 836                 tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
 837                 return tevent_req_post(req, ev);
 838         }
 839         state->addr.u.in.sin_port = htons(NMB_PORT);
 840
 841         set_socket_addr_v4(&state->my_addr);
 842
 843         ZERO_STRUCT(p);
 844         nmb->header.name_trn_id = generate_trn_id();
 845         nmb->header.opcode = 0;
 846         nmb->header.response = false;
 847         nmb->header.nm_flags.bcast = false;
 848         nmb->header.nm_flags.recursion_available = false;
 849         nmb->header.nm_flags.recursion_desired = false;
 850         nmb->header.nm_flags.trunc = false;
 851         nmb->header.nm_flags.authoritative = false;
 852         nmb->header.rcode = 0;
 853         nmb->header.qdcount = 1;
 854         nmb->header.ancount = 0;
 855         nmb->header.nscount = 0;
 856         nmb->header.arcount = 0;
 857         nmb->question.question_name = *name;
 858         nmb->question.question_type = 0x21;
 859         nmb->question.question_class = 0x1;
 860
 861         state->buflen = build_packet((char *)state->buf, sizeof(state->buf),
 862                                      &p);
 863         if (state->buflen == 0) {
 864                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
 865                 DEBUG(10, ("build_packet failed\n"));
 866                 return tevent_req_post(req, ev);
 867         }
 868
 869         subreq = nb_trans_send(state,
 870                                 ev,
 871                                 &state->my_addr,
 872                                 &state->addr,
 873                                 false,
 874                                 state->buf,
 875                                 state->buflen,
 876                                 NMB_PACKET,
 877                                 nmb->header.name_trn_id,
 878                                 node_status_query_validator,
 879                                 NULL);
 880         if (tevent_req_nomem(subreq, req)) {
 881                 DEBUG(10, ("nb_trans_send failed\n"));
 882                 return tevent_req_post(req, ev);
 883         }
 884         if (!tevent_req_set_endtime(req, ev, timeval_current_ofs(10, 0))) {
 885                 return tevent_req_post(req, ev);
 886         }
 887         tevent_req_set_callback(subreq, node_status_query_done, req);
 888         return req;
 889 }
 890
 891 static bool node_status_query_validator(struct packet_struct *p,
 892                                         void *private_data)
 893 {
 894         struct nmb_packet *nmb = &p->packet.nmb;
 895         debug_nmb_packet(p);
 896
 897         if (nmb->header.opcode != 0 ||
 898             nmb->header.nm_flags.bcast ||
 899             nmb->header.rcode ||
 900             !nmb->header.ancount ||
 901             nmb->answers->rr_type != 0x21) {
 902                 /*
 903                  * XXXX what do we do with this? could be a redirect,
 904                  * but we'll discard it for the moment
 905                  */
 906                 return false;
 907         }
 908         return true;
 909 }
 910
 911 static void node_status_query_done(struct tevent_req *subreq)
 912 {
 913         struct tevent_req *req = tevent_req_callback_data(
 914                 subreq, struct tevent_req);
 915         struct node_status_query_state *state = tevent_req_data(
 916                 req, struct node_status_query_state);
 917         NTSTATUS status;
 918
 919         status = nb_trans_recv(subreq, state, &state->packet);
 920         TALLOC_FREE(subreq);
 921         if (tevent_req_nterror(req, status)) {
 922                 return;
 923         }
 924         tevent_req_done(req);
 925 }
 926
 927 NTSTATUS node_status_query_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 928                                 struct node_status **pnode_status,
 929                                 size_t *pnum_names,
 930                                 struct node_status_extra *extra)
 931 {
 932         struct node_status_query_state *state = tevent_req_data(
 933                 req, struct node_status_query_state);
 934         struct node_status *node_status;
 935         size_t num_names = 0;
 936         NTSTATUS status;
 937
 938         if (tevent_req_is_nterror(req, &status)) {
 939                 return status;
 940         }
 941         node_status = parse_node_status(
 942                 mem_ctx, &state->packet->packet.nmb.answers->rdata[0],
 943                 &num_names, extra);
 944         if (node_status == NULL) {
 945                 return NT_STATUS_NO_MEMORY;
 946         }
 947         *pnode_status = node_status;
 948         *pnum_names = num_names;
 949         return NT_STATUS_OK;
 950 }
 951
 952 NTSTATUS node_status_query(TALLOC_CTX *mem_ctx, struct nmb_name *name,
 953                            const struct sockaddr_storage *addr,
 954                            struct node_status **pnode_status,
 955                            size_t *pnum_names,
 956                            struct node_status_extra *extra)
 957 {
 958         TALLOC_CTX *frame = talloc_stackframe();
 959         struct tevent_context *ev;
 960         struct tevent_req *req;
 961         NTSTATUS status = NT_STATUS_NO_MEMORY;
 962
 963         ev = samba_tevent_context_init(frame);
 964         if (ev == NULL) {
 965                 goto fail;
 966         }
 967         req = node_status_query_send(ev, ev, name, addr);
 968         if (req == NULL) {
 969                 goto fail;
 970         }
 971         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 972                 goto fail;
 973         }
 974         status = node_status_query_recv(req, mem_ctx, pnode_status,
 975                                         pnum_names, extra);
 976  fail:
 977         TALLOC_FREE(frame);
 978         return status;
 979 }
 980
 981 static bool name_status_lmhosts(const struct sockaddr_storage *paddr,
 982                                 int qname_type, fstring pname)
 983 {
 984         FILE *f;
 985         char *name;
 986         int name_type;
 987         struct samba_sockaddr addr_in = {0};
 988         struct samba_sockaddr addr = {0};
 989         bool ok;
 990
 991         ok = sockaddr_storage_to_samba_sockaddr(&addr_in, paddr);
 992         if (!ok) {
 993                 return false;
 994         }
 995         if (addr_in.u.ss.ss_family != AF_INET) {
 996                 return false;
 997         }
 998
 999         f = startlmhosts(get_dyn_LMHOSTSFILE());
1000         if (f == NULL) {
1001                 return false;
1002         }
1003
1004         while (getlmhostsent(talloc_tos(), f, &name, &name_type, &addr.u.ss)) {
1005                 if (addr.u.ss.ss_family != AF_INET) {
1006                         continue;
1007                 }
1008                 if (name_type != qname_type) {
1009                         continue;
1010                 }
1011                 if (sockaddr_equal(&addr_in.u.sa, &addr.u.sa)) {
1012                         fstrcpy(pname, name);
1013                         endlmhosts(f);
1014                         return true;
1015                 }
1016         }
1017         endlmhosts(f);
1018         return false;
1019 }
1020
1021 /****************************************************************************
1022  Find the first type XX name in a node status reply - used for finding
1023  a servers name given its IP. Return the matched name in *name.
1024 **************************************************************************/
1025
1026 bool name_status_find(const char *q_name,
1027                         int q_type,
1028                         int type,
1029                         const struct sockaddr_storage *to_ss,
1030                         fstring name)
1031 {
1032         char addr[INET6_ADDRSTRLEN];
1033         struct node_status *addrs = NULL;
1034         struct nmb_name nname;
1035         size_t count = 0, i;
1036         bool result = false;
1037         NTSTATUS status;
1038
1039         if (lp_disable_netbios()) {
1040                 DEBUG(5,("name_status_find(%s#%02x): netbios is disabled\n",
1041                                         q_name, q_type));
1042                 return False;
1043         }
1044
1045         print_sockaddr(addr, sizeof(addr), to_ss);
1046
1047         DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name,
1048                    q_type, addr));
1049
1050         /* Check the cache first. */
1051
1052         if (namecache_status_fetch(q_name, q_type, type, to_ss, name)) {
1053                 return True;
1054         }
1055
1056         if (to_ss->ss_family != AF_INET) {
1057                 /* Can't do node status to IPv6 */
1058                 return false;
1059         }
1060
1061         result = name_status_lmhosts(to_ss, type, name);
1062         if (result) {
1063                 DBG_DEBUG("Found name %s in lmhosts\n", name);
1064                 namecache_status_store(q_name, q_type, type, to_ss, name);
1065                 return true;
1066         }
1067
1068         /* W2K PDC's seem not to respond to '*'#0. JRA */
1069         make_nmb_name(&nname, q_name, q_type);
1070         status = node_status_query(talloc_tos(), &nname, to_ss,
1071                                    &addrs, &count, NULL);
1072         if (!NT_STATUS_IS_OK(status)) {
1073                 goto done;
1074         }
1075
1076         for (i=0;i<count;i++) {
1077                 /* Find first one of the requested type that's not a GROUP. */
1078                 if (addrs[i].type == type && ! (addrs[i].flags & 0x80))
1079                         break;
1080         }
1081         if (i == count)
1082                 goto done;
1083
1084         pull_ascii_nstring(name, sizeof(fstring), addrs[i].name);
1085
1086         /* Store the result in the cache. */
1087         /* but don't store an entry for 0x1c names here.  Here we have
1088            a single host and DOMAIN<0x1c> names should be a list of hosts */
1089
1090         if ( q_type != 0x1c ) {
1091                 namecache_status_store(q_name, q_type, type, to_ss, name);
1092         }
1093
1094         result = true;
1095
1096  done:
1097         TALLOC_FREE(addrs);
1098
1099         DEBUG(10, ("name_status_find: name %sfound", result ? "" : "not "));
1100
1101         if (result)
1102                 DEBUGADD(10, (", name %s ip address is %s", name, addr));
1103
1104         DEBUG(10, ("\n"));
1105
1106         return result;
1107 }
1108
1109 /*
1110   comparison function used by sort_addr_list
1111 */
1112
1113 static int addr_compare(const struct sockaddr_storage *ss1,
1114                         const struct sockaddr_storage *ss2)
1115 {
1116         int max_bits1=0, max_bits2=0;
1117         int num_interfaces = iface_count();
1118         int i;
1119         struct samba_sockaddr sa1;
1120         struct samba_sockaddr sa2;
1121         bool ok;
1122
1123         ok = sockaddr_storage_to_samba_sockaddr(&sa1, ss1);
1124         if (!ok) {
1125                 return 0; /* No change. */
1126         }
1127
1128         ok = sockaddr_storage_to_samba_sockaddr(&sa2, ss2);
1129         if (!ok) {
1130                 return 0; /* No change. */
1131         }
1132
1133         /* Sort IPv4 addresses first. */
1134         if (sa1.u.ss.ss_family != sa2.u.ss.ss_family) {
1135                 if (sa2.u.ss.ss_family == AF_INET) {
1136                         return 1;
1137                 } else {
1138                         return -1;
1139                 }
1140         }
1141
1142         /* Here we know both addresses are of the same
1143          * family. */
1144
1145         for (i=0;i<num_interfaces;i++) {
1146                 struct samba_sockaddr sif = {0};
1147                 const unsigned char *p_ss1 = NULL;
1148                 const unsigned char *p_ss2 = NULL;
1149                 const unsigned char *p_if = NULL;
1150                 size_t len = 0;
1151                 int bits1, bits2;
1152
1153                 ok = sockaddr_storage_to_samba_sockaddr(&sif, iface_n_bcast(i));
1154                 if (!ok) {
1155                         return 0; /* No change. */
1156                 }
1157                 if (sif.u.ss.ss_family != sa1.u.ss.ss_family) {
1158                         /* Ignore interfaces of the wrong type. */
1159                         continue;
1160                 }
1161                 if (sif.u.ss.ss_family == AF_INET) {
1162                         p_if = (const unsigned char *)&sif.u.in.sin_addr;
1163                         p_ss1 = (const unsigned char *)&sa1.u.in.sin_addr;
1164                         p_ss2 = (const unsigned char *)&sa2.u.in.sin_addr;
1165                         len = 4;
1166                 }
1167 #if defined(HAVE_IPV6)
1168                 if (sif.u.ss.ss_family == AF_INET6) {
1169                         p_if = (const unsigned char *)&sif.u.in6.sin6_addr;
1170                         p_ss1 = (const unsigned char *)&sa1.u.in6.sin6_addr;
1171                         p_ss2 = (const unsigned char *)&sa2.u.in6.sin6_addr;
1172                         len = 16;
1173                 }
1174 #endif
1175                 if (!p_ss1 || !p_ss2 || !p_if || len == 0) {
1176                         continue;
1177                 }
1178                 bits1 = matching_len_bits(p_ss1, p_if, len);
1179                 bits2 = matching_len_bits(p_ss2, p_if, len);
1180                 max_bits1 = MAX(bits1, max_bits1);
1181                 max_bits2 = MAX(bits2, max_bits2);
1182         }
1183
1184         /* Bias towards directly reachable IPs */
1185         if (iface_local(&sa1.u.sa)) {
1186                 if (sa1.u.ss.ss_family == AF_INET) {
1187                         max_bits1 += 32;
1188                 } else {
1189                         max_bits1 += 128;
1190                 }
1191         }
1192         if (iface_local(&sa2.u.sa)) {
1193                 if (sa2.u.ss.ss_family == AF_INET) {
1194                         max_bits2 += 32;
1195                 } else {
1196                         max_bits2 += 128;
1197                 }
1198         }
1199         return max_bits2 - max_bits1;
1200 }
1201
1202 /*
1203   sort an IP list so that names that are close to one of our interfaces
1204   are at the top. This prevents the problem where a WINS server returns an IP
1205   that is not reachable from our subnet as the first match
1206 */
1207
1208 static void sort_addr_list(struct sockaddr_storage *sslist, size_t count)
1209 {
1210         if (count <= 1) {
1211                 return;
1212         }
1213
1214         TYPESAFE_QSORT(sslist, count, addr_compare);
1215 }
1216
1217 static int samba_sockaddr_compare(struct samba_sockaddr *sa1,
1218                                 struct samba_sockaddr *sa2)
1219 {
1220         return addr_compare(&sa1->u.ss, &sa2->u.ss);
1221 }
1222
1223 static void sort_sa_list(struct samba_sockaddr *salist, size_t count)
1224 {
1225         if (count <= 1) {
1226                 return;
1227         }
1228
1229         TYPESAFE_QSORT(salist, count, samba_sockaddr_compare);
1230 }
1231
1232 /**********************************************************************
1233  Remove any duplicate address/port pairs in the samba_sockaddr array.
1234  *********************************************************************/
1235
1236 size_t remove_duplicate_addrs2(struct samba_sockaddr *salist, size_t count )
1237 {
1238         size_t i, j;
1239
1240         DBG_DEBUG("looking for duplicate address/port pairs\n");
1241
1242         /* One loop to set duplicates to a zero addr. */
1243         for (i=0; i < count; i++) {
1244                 if (is_zero_addr(&salist[i].u.ss)) {
1245                         continue;
1246                 }
1247
1248                 for (j=i+1; j<count; j++) {
1249                         if (sockaddr_equal(&salist[i].u.sa, &salist[j].u.sa)) {
1250                                 zero_sockaddr(&salist[j].u.ss);
1251                         }
1252                 }
1253         }
1254
1255         /* Now remove any addresses set to zero above. */
1256         for (i = 0; i < count; i++) {
1257                 while (i < count &&
1258                                 is_zero_addr(&salist[i].u.ss)) {
1259                         ARRAY_DEL_ELEMENT(salist, i, count);
1260                         count--;
1261                 }
1262         }
1263
1264         return count;
1265 }
1266
1267 static bool prioritize_ipv4_list(struct samba_sockaddr *salist, size_t count)
1268 {
1269         TALLOC_CTX *frame = talloc_stackframe();
1270         struct samba_sockaddr *salist_new = talloc_array(frame,
1271                                                 struct samba_sockaddr,
1272                                                 count);
1273         size_t i, j;
1274
1275         if (salist_new == NULL) {
1276                 TALLOC_FREE(frame);
1277                 return false;
1278         }
1279
1280         j = 0;
1281
1282         /* Copy IPv4 first. */
1283         for (i = 0; i < count; i++) {
1284                 if (salist[i].u.ss.ss_family == AF_INET) {
1285                         salist_new[j++] = salist[i];
1286                 }
1287         }
1288
1289         /* Copy IPv6. */
1290         for (i = 0; i < count; i++) {
1291                 if (salist[i].u.ss.ss_family != AF_INET) {
1292                         salist_new[j++] = salist[i];
1293                 }
1294         }
1295
1296         memcpy(salist, salist_new, sizeof(struct samba_sockaddr)*count);
1297         TALLOC_FREE(frame);
1298         return true;
1299 }
1300
1301 /****************************************************************************
1302  Do a netbios name query to find someones IP.
1303  Returns an array of IP addresses or NULL if none.
1304  *count will be set to the number of addresses returned.
1305  *timed_out is set if we failed by timing out
1306 ****************************************************************************/
1307
1308 struct name_query_state {
1309         struct samba_sockaddr my_addr;
1310         struct samba_sockaddr addr;
1311         bool bcast;
1312         bool bcast_star_query;
1313
1314
1315         uint8_t buf[1024];
1316         ssize_t buflen;
1317
1318         NTSTATUS validate_error;
1319         uint8_t flags;
1320
1321         struct sockaddr_storage *addrs;
1322         size_t num_addrs;
1323 };
1324
1325 static bool name_query_validator(struct packet_struct *p, void *private_data);
1326 static void name_query_done(struct tevent_req *subreq);
1327
1328 struct tevent_req *name_query_send(TALLOC_CTX *mem_ctx,
1329                                    struct tevent_context *ev,
1330                                    const char *name, int name_type,
1331                                    bool bcast, bool recurse,
1332                                    const struct sockaddr_storage *addr)
1333 {
1334         struct tevent_req *req, *subreq;
1335         struct name_query_state *state;
1336         struct packet_struct p;
1337         struct nmb_packet *nmb = &p.packet.nmb;
1338         bool ok;
1339
1340         req = tevent_req_create(mem_ctx, &state, struct name_query_state);
1341         if (req == NULL) {
1342                 return NULL;
1343         }
1344         state->bcast = bcast;
1345
1346         if (addr->ss_family != AF_INET) {
1347                 /* Can't do node status to IPv6 */
1348                 tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
1349                 return tevent_req_post(req, ev);
1350         }
1351
1352         if (lp_disable_netbios()) {
1353                 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n",
1354                                         name, name_type));
1355                 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
1356                 return tevent_req_post(req, ev);
1357         }
1358
1359         ok = sockaddr_storage_to_samba_sockaddr(&state->addr, addr);
1360         if (!ok) {
1361                 /* Node status must be IPv4 */
1362                 tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
1363                 return tevent_req_post(req, ev);
1364         }
1365         state->addr.u.in.sin_port = htons(NMB_PORT);
1366
1367         set_socket_addr_v4(&state->my_addr);
1368
1369         ZERO_STRUCT(p);
1370         nmb->header.name_trn_id = generate_trn_id();
1371         nmb->header.opcode = 0;
1372         nmb->header.response = false;
1373         nmb->header.nm_flags.bcast = bcast;
1374         nmb->header.nm_flags.recursion_available = false;
1375         nmb->header.nm_flags.recursion_desired = recurse;
1376         nmb->header.nm_flags.trunc = false;
1377         nmb->header.nm_flags.authoritative = false;
1378         nmb->header.rcode = 0;
1379         nmb->header.qdcount = 1;
1380         nmb->header.ancount = 0;
1381         nmb->header.nscount = 0;
1382         nmb->header.arcount = 0;
1383
1384         if (bcast && (strcmp(name, "*")==0)) {
1385                 /*
1386                  * We're doing a broadcast query for all
1387                  * names in the area. Remember this so
1388                  * we will wait for all names within
1389                  * the timeout period.
1390                  */
1391                 state->bcast_star_query = true;
1392         }
1393
1394         make_nmb_name(&nmb->question.question_name,name,name_type);
1395
1396         nmb->question.question_type = 0x20;
1397         nmb->question.question_class = 0x1;
1398
1399         state->buflen = build_packet((char *)state->buf, sizeof(state->buf),
1400                                      &p);
1401         if (state->buflen == 0) {
1402                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1403                 DEBUG(10, ("build_packet failed\n"));
1404                 return tevent_req_post(req, ev);
1405         }
1406
1407         subreq = nb_trans_send(state,
1408                                 ev,
1409                                 &state->my_addr,
1410                                 &state->addr,
1411                                 bcast,
1412                                 state->buf,
1413                                 state->buflen,
1414                                 NMB_PACKET,
1415                                 nmb->header.name_trn_id,
1416                                 name_query_validator,
1417                                 state);
1418         if (tevent_req_nomem(subreq, req)) {
1419                 DEBUG(10, ("nb_trans_send failed\n"));
1420                 return tevent_req_post(req, ev);
1421         }
1422         tevent_req_set_callback(subreq, name_query_done, req);
1423         return req;
1424 }
1425
1426 static bool name_query_validator(struct packet_struct *p, void *private_data)
1427 {
1428         struct name_query_state *state = talloc_get_type_abort(
1429                 private_data, struct name_query_state);
1430         struct nmb_packet *nmb = &p->packet.nmb;
1431         struct sockaddr_storage *tmp_addrs;
1432         bool got_unique_netbios_name = false;
1433         int i;
1434
1435         debug_nmb_packet(p);
1436
1437         /*
1438          * If we get a Negative Name Query Response from a WINS
1439          * server, we should report it and give up.
1440          */
1441         if( 0 == nmb->header.opcode     /* A query response   */
1442             && !state->bcast            /* from a WINS server */
1443             && nmb->header.rcode        /* Error returned     */
1444                 ) {
1445
1446                 if( DEBUGLVL( 3 ) ) {
1447                         /* Only executed if DEBUGLEVEL >= 3 */
1448                         dbgtext( "Negative name query "
1449                                  "response, rcode 0x%02x: ",
1450                                  nmb->header.rcode );
1451                         switch( nmb->header.rcode ) {
1452                         case 0x01:
1453                                 dbgtext("Request was invalidly formatted.\n");
1454                                 break;
1455                         case 0x02:
1456                                 dbgtext("Problem with NBNS, cannot process "
1457                                         "name.\n");
1458                                 break;
1459                         case 0x03:
1460                                 dbgtext("The name requested does not "
1461                                         "exist.\n");
1462                                 break;
1463                         case 0x04:
1464                                 dbgtext("Unsupported request error.\n");
1465                                 break;
1466                         case 0x05:
1467                                 dbgtext("Query refused error.\n");
1468                                 break;
1469                         default:
1470                                 dbgtext("Unrecognized error code.\n" );
1471                                 break;
1472                         }
1473                 }
1474
1475                 /*
1476                  * We accept this packet as valid, but tell the upper
1477                  * layers that it's a negative response.
1478                  */
1479                 state->validate_error = NT_STATUS_NOT_FOUND;
1480                 return true;
1481         }
1482
1483         if (nmb->header.opcode != 0 ||
1484             nmb->header.nm_flags.bcast ||
1485             nmb->header.rcode ||
1486             !nmb->header.ancount) {
1487                 /*
1488                  * XXXX what do we do with this? Could be a redirect,
1489                  * but we'll discard it for the moment.
1490                  */
1491                 return false;
1492         }
1493
1494         tmp_addrs = talloc_realloc(
1495                 state, state->addrs, struct sockaddr_storage,
1496                 state->num_addrs + nmb->answers->rdlength/6);
1497         if (tmp_addrs == NULL) {
1498                 state->validate_error = NT_STATUS_NO_MEMORY;
1499                 return true;
1500         }
1501         state->addrs = tmp_addrs;
1502
1503         DEBUG(2,("Got a positive name query response "
1504                  "from %s ( ", inet_ntoa(p->ip)));
1505
1506         for (i=0; i<nmb->answers->rdlength/6; i++) {
1507                 uint16_t flags;
1508                 struct in_addr ip;
1509                 struct sockaddr_storage addr;
1510                 struct samba_sockaddr sa = {0};
1511                 bool ok;
1512                 size_t j;
1513
1514                 flags = RSVAL(&nmb->answers->rdata[i*6], 0);
1515                 got_unique_netbios_name |= ((flags & 0x8000) == 0);
1516
1517                 putip((char *)&ip,&nmb->answers->rdata[2+i*6]);
1518                 in_addr_to_sockaddr_storage(&addr, ip);
1519
1520                 ok = sockaddr_storage_to_samba_sockaddr(&sa, &addr);
1521                 if (!ok) {
1522                         continue;
1523                 }
1524
1525                 if (is_zero_addr(&sa.u.ss)) {
1526                         continue;
1527                 }
1528
1529                 for (j=0; j<state->num_addrs; j++) {
1530                         struct samba_sockaddr sa_j = {0};
1531
1532                         ok = sockaddr_storage_to_samba_sockaddr(&sa_j,
1533                                                 &state->addrs[j]);
1534                         if (!ok) {
1535                                 continue;
1536                         }
1537                         if (sockaddr_equal(&sa.u.sa, &sa_j.u.sa)) {
1538                                 break;
1539                         }
1540                 }
1541                 if (j < state->num_addrs) {
1542                         /* Already got it */
1543                         continue;
1544                 }
1545
1546                 DEBUGADD(2,("%s ",inet_ntoa(ip)));
1547
1548                 state->addrs[state->num_addrs] = addr;
1549                 /* wrap check. */
1550                 if (state->num_addrs + 1 < state->num_addrs) {
1551                         return false;
1552                 }
1553                 state->num_addrs += 1;
1554         }
1555         DEBUGADD(2,(")\n"));
1556
1557         /* We add the flags back ... */
1558         if (nmb->header.response)
1559                 state->flags |= NM_FLAGS_RS;
1560         if (nmb->header.nm_flags.authoritative)
1561                 state->flags |= NM_FLAGS_AA;
1562         if (nmb->header.nm_flags.trunc)
1563                 state->flags |= NM_FLAGS_TC;
1564         if (nmb->header.nm_flags.recursion_desired)
1565                 state->flags |= NM_FLAGS_RD;
1566         if (nmb->header.nm_flags.recursion_available)
1567                 state->flags |= NM_FLAGS_RA;
1568         if (nmb->header.nm_flags.bcast)
1569                 state->flags |= NM_FLAGS_B;
1570
1571         if (state->bcast) {
1572                 /*
1573                  * We have to collect all entries coming in from broadcast
1574                  * queries. If we got a unique name and we are not querying
1575                  * all names registered within broadcast area (query
1576                  * for the name '*', so state->bcast_star_query is set),
1577                  * we're done.
1578                  */
1579                 return (got_unique_netbios_name && !state->bcast_star_query);
1580         }
1581         /*
1582          * WINS responses are accepted when they are received
1583          */
1584         return true;
1585 }
1586
1587 static void name_query_done(struct tevent_req *subreq)
1588 {
1589         struct tevent_req *req = tevent_req_callback_data(
1590                 subreq, struct tevent_req);
1591         struct name_query_state *state = tevent_req_data(
1592                 req, struct name_query_state);
1593         NTSTATUS status;
1594         struct packet_struct *p = NULL;
1595
1596         status = nb_trans_recv(subreq, state, &p);
1597         TALLOC_FREE(subreq);
1598         if (tevent_req_nterror(req, status)) {
1599                 return;
1600         }
1601         if (!NT_STATUS_IS_OK(state->validate_error)) {
1602                 tevent_req_nterror(req, state->validate_error);
1603                 return;
1604         }
1605         tevent_req_done(req);
1606 }
1607
1608 NTSTATUS name_query_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1609                          struct sockaddr_storage **addrs, size_t *num_addrs,
1610                          uint8_t *flags)
1611 {
1612         struct name_query_state *state = tevent_req_data(
1613                 req, struct name_query_state);
1614         NTSTATUS status;
1615
1616         if (tevent_req_is_nterror(req, &status)) {
1617                 if (state->bcast &&
1618                     NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
1619                         /*
1620                          * In the broadcast case we collect replies until the
1621                          * timeout.
1622                          */
1623                         status = NT_STATUS_OK;
1624                 }
1625                 if (!NT_STATUS_IS_OK(status)) {
1626                         return status;
1627                 }
1628         }
1629         if (state->num_addrs == 0) {
1630                 return NT_STATUS_NOT_FOUND;
1631         }
1632         *addrs = talloc_move(mem_ctx, &state->addrs);
1633         sort_addr_list(*addrs, state->num_addrs);
1634         *num_addrs = state->num_addrs;
1635         if (flags != NULL) {
1636                 *flags = state->flags;
1637         }
1638         return NT_STATUS_OK;
1639 }
1640
1641 NTSTATUS name_query(const char *name, int name_type,
1642                     bool bcast, bool recurse,
1643                     const struct sockaddr_storage *to_ss,
1644                     TALLOC_CTX *mem_ctx,
1645                     struct sockaddr_storage **addrs,
1646                     size_t *num_addrs, uint8_t *flags)
1647 {
1648         TALLOC_CTX *frame = talloc_stackframe();
1649         struct tevent_context *ev;
1650         struct tevent_req *req;
1651         struct timeval timeout;
1652         NTSTATUS status = NT_STATUS_NO_MEMORY;
1653
1654         ev = samba_tevent_context_init(frame);
1655         if (ev == NULL) {
1656                 goto fail;
1657         }
1658         req = name_query_send(ev, ev, name, name_type, bcast, recurse, to_ss);
1659         if (req == NULL) {
1660                 goto fail;
1661         }
1662         if (bcast) {
1663                 timeout = timeval_current_ofs(0, 250000);
1664         } else {
1665                 timeout = timeval_current_ofs(2, 0);
1666         }
1667         if (!tevent_req_set_endtime(req, ev, timeout)) {
1668                 goto fail;
1669         }
1670         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1671                 goto fail;
1672         }
1673         status = name_query_recv(req, mem_ctx, addrs, num_addrs, flags);
1674  fail:
1675         TALLOC_FREE(frame);
1676         return status;
1677 }
1678
1679 struct name_queries_state {
1680         struct tevent_context *ev;
1681         const char *name;
1682         int name_type;
1683         bool bcast;
1684         bool recurse;
1685         const struct sockaddr_storage *addrs;
1686         size_t num_addrs;
1687         int wait_msec;
1688         int timeout_msec;
1689
1690         struct tevent_req **subreqs;
1691         size_t num_received;
1692         size_t num_sent;
1693
1694         size_t received_index;
1695         struct sockaddr_storage *result_addrs;
1696         size_t num_result_addrs;
1697         uint8_t flags;
1698 };
1699
1700 static void name_queries_done(struct tevent_req *subreq);
1701 static void name_queries_next(struct tevent_req *subreq);
1702
1703 /*
1704  * Send a name query to multiple destinations with a wait time in between
1705  */
1706
1707 static struct tevent_req *name_queries_send(
1708         TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1709         const char *name, int name_type,
1710         bool bcast, bool recurse,
1711         const struct sockaddr_storage *addrs,
1712         size_t num_addrs, int wait_msec, int timeout_msec)
1713 {
1714         struct tevent_req *req, *subreq;
1715         struct name_queries_state *state;
1716
1717         req = tevent_req_create(mem_ctx, &state,
1718                                 struct name_queries_state);
1719         if (req == NULL) {
1720                 return NULL;
1721         }
1722         state->ev = ev;
1723         state->name = name;
1724         state->name_type = name_type;
1725         state->bcast = bcast;
1726         state->recurse = recurse;
1727         state->addrs = addrs;
1728         state->num_addrs = num_addrs;
1729         state->wait_msec = wait_msec;
1730         state->timeout_msec = timeout_msec;
1731
1732         state->subreqs = talloc_zero_array(
1733                 state, struct tevent_req *, num_addrs);
1734         if (tevent_req_nomem(state->subreqs, req)) {
1735                 return tevent_req_post(req, ev);
1736         }
1737         state->num_sent = 0;
1738
1739         subreq = name_query_send(
1740                 state->subreqs, state->ev, name, name_type, bcast, recurse,
1741                 &state->addrs[state->num_sent]);
1742         if (tevent_req_nomem(subreq, req)) {
1743                 return tevent_req_post(req, ev);
1744         }
1745         if (!tevent_req_set_endtime(
1746                     subreq, state->ev,
1747                     timeval_current_ofs(0, state->timeout_msec * 1000))) {
1748                 return tevent_req_post(req, ev);
1749         }
1750         tevent_req_set_callback(subreq, name_queries_done, req);
1751
1752         state->subreqs[state->num_sent] = subreq;
1753         state->num_sent += 1;
1754
1755         if (state->num_sent < state->num_addrs) {
1756                 subreq = tevent_wakeup_send(
1757                         state, state->ev,
1758                         timeval_current_ofs(0, state->wait_msec * 1000));
1759                 if (tevent_req_nomem(subreq, req)) {
1760                         return tevent_req_post(req, ev);
1761                 }
1762                 tevent_req_set_callback(subreq, name_queries_next, req);
1763         }
1764         return req;
1765 }
1766
1767 static void name_queries_done(struct tevent_req *subreq)
1768 {
1769         struct tevent_req *req = tevent_req_callback_data(
1770                 subreq, struct tevent_req);
1771         struct name_queries_state *state = tevent_req_data(
1772                 req, struct name_queries_state);
1773         size_t i;
1774         NTSTATUS status;
1775
1776         status = name_query_recv(subreq, state, &state->result_addrs,
1777                                  &state->num_result_addrs, &state->flags);
1778
1779         for (i=0; i<state->num_sent; i++) {
1780                 if (state->subreqs[i] == subreq) {
1781                         break;
1782                 }
1783         }
1784         if (i == state->num_sent) {
1785                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1786                 return;
1787         }
1788         TALLOC_FREE(state->subreqs[i]);
1789
1790         /* wrap check. */
1791         if (state->num_received + 1 < state->num_received) {
1792                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
1793                 return;
1794         }
1795         state->num_received += 1;
1796
1797         if (!NT_STATUS_IS_OK(status)) {
1798
1799                 if (state->num_received >= state->num_addrs) {
1800                         tevent_req_nterror(req, status);
1801                         return;
1802                 }
1803                 /*
1804                  * Still outstanding requests, just wait
1805                  */
1806                 return;
1807         }
1808         state->received_index = i;
1809         tevent_req_done(req);
1810 }
1811
1812 static void name_queries_next(struct tevent_req *subreq)
1813 {
1814         struct tevent_req *req = tevent_req_callback_data(
1815                 subreq, struct tevent_req);
1816         struct name_queries_state *state = tevent_req_data(
1817                 req, struct name_queries_state);
1818
1819         if (!tevent_wakeup_recv(subreq)) {
1820                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1821                 return;
1822         }
1823
1824         subreq = name_query_send(
1825                 state->subreqs, state->ev,
1826                 state->name, state->name_type, state->bcast, state->recurse,
1827                 &state->addrs[state->num_sent]);
1828         if (tevent_req_nomem(subreq, req)) {
1829                 return;
1830         }
1831         tevent_req_set_callback(subreq, name_queries_done, req);
1832         if (!tevent_req_set_endtime(
1833                     subreq, state->ev,
1834                     timeval_current_ofs(0, state->timeout_msec * 1000))) {
1835                 return;
1836         }
1837         state->subreqs[state->num_sent] = subreq;
1838         state->num_sent += 1;
1839
1840         if (state->num_sent < state->num_addrs) {
1841                 subreq = tevent_wakeup_send(
1842                         state, state->ev,
1843                         timeval_current_ofs(0, state->wait_msec * 1000));
1844                 if (tevent_req_nomem(subreq, req)) {
1845                         return;
1846                 }
1847                 tevent_req_set_callback(subreq, name_queries_next, req);
1848         }
1849 }
1850
1851 static NTSTATUS name_queries_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1852                                   struct sockaddr_storage **result_addrs,
1853                                   size_t *num_result_addrs, uint8_t *flags,
1854                                   size_t *received_index)
1855 {
1856         struct name_queries_state *state = tevent_req_data(
1857                 req, struct name_queries_state);
1858         NTSTATUS status;
1859
1860         if (tevent_req_is_nterror(req, &status)) {
1861                 return status;
1862         }
1863
1864         if (result_addrs != NULL) {
1865                 *result_addrs = talloc_move(mem_ctx, &state->result_addrs);
1866         }
1867         if (num_result_addrs != NULL) {
1868                 *num_result_addrs = state->num_result_addrs;
1869         }
1870         if (flags != NULL) {
1871                 *flags = state->flags;
1872         }
1873         if (received_index != NULL) {
1874                 *received_index = state->received_index;
1875         }
1876         return NT_STATUS_OK;
1877 }
1878
1879 /********************************************************
1880  Resolve via "bcast" method.
1881 *********************************************************/
1882
1883 struct name_resolve_bcast_state {
1884         struct sockaddr_storage *addrs;
1885         size_t num_addrs;
1886 };
1887
1888 static void name_resolve_bcast_done(struct tevent_req *subreq);
1889
1890 struct tevent_req *name_resolve_bcast_send(TALLOC_CTX *mem_ctx,
1891                                            struct tevent_context *ev,
1892                                            const char *name,
1893                                            int name_type)
1894 {
1895         struct tevent_req *req, *subreq;
1896         struct name_resolve_bcast_state *state;
1897         struct sockaddr_storage *bcast_addrs;
1898         size_t i, num_addrs, num_bcast_addrs;
1899
1900         req = tevent_req_create(mem_ctx, &state,
1901                                 struct name_resolve_bcast_state);
1902         if (req == NULL) {
1903                 return NULL;
1904         }
1905
1906         if (lp_disable_netbios()) {
1907                 DEBUG(5, ("name_resolve_bcast(%s#%02x): netbios is disabled\n",
1908                           name, name_type));
1909                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
1910                 return tevent_req_post(req, ev);
1911         }
1912
1913         /*
1914          * "bcast" means do a broadcast lookup on all the local interfaces.
1915          */
1916
1917         DEBUG(3, ("name_resolve_bcast: Attempting broadcast lookup "
1918                   "for name %s<0x%x>\n", name, name_type));
1919
1920         num_addrs = iface_count();
1921         bcast_addrs = talloc_array(state, struct sockaddr_storage, num_addrs);
1922         if (tevent_req_nomem(bcast_addrs, req)) {
1923                 return tevent_req_post(req, ev);
1924         }
1925
1926         /*
1927          * Lookup the name on all the interfaces, return on
1928          * the first successful match.
1929          */
1930         num_bcast_addrs = 0;
1931
1932         for (i=0; i<num_addrs; i++) {
1933                 const struct sockaddr_storage *pss = iface_n_bcast(i);
1934
1935                 if (pss->ss_family != AF_INET) {
1936                         continue;
1937                 }
1938                 bcast_addrs[num_bcast_addrs] = *pss;
1939                 num_bcast_addrs += 1;
1940         }
1941
1942         subreq = name_queries_send(state, ev, name, name_type, true, true,
1943                                    bcast_addrs, num_bcast_addrs, 0, 250);
1944         if (tevent_req_nomem(subreq, req)) {
1945                 return tevent_req_post(req, ev);
1946         }
1947         tevent_req_set_callback(subreq, name_resolve_bcast_done, req);
1948         return req;
1949 }
1950
1951 static void name_resolve_bcast_done(struct tevent_req *subreq)
1952 {
1953         struct tevent_req *req = tevent_req_callback_data(
1954                 subreq, struct tevent_req);
1955         struct name_resolve_bcast_state *state = tevent_req_data(
1956                 req, struct name_resolve_bcast_state);
1957         NTSTATUS status;
1958
1959         status = name_queries_recv(subreq, state,
1960                                    &state->addrs, &state->num_addrs,
1961                                    NULL, NULL);
1962         TALLOC_FREE(subreq);
1963         if (tevent_req_nterror(req, status)) {
1964                 return;
1965         }
1966         tevent_req_done(req);
1967 }
1968
1969 NTSTATUS name_resolve_bcast_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1970                                  struct sockaddr_storage **addrs,
1971                                  size_t *num_addrs)
1972 {
1973         struct name_resolve_bcast_state *state = tevent_req_data(
1974                 req, struct name_resolve_bcast_state);
1975         NTSTATUS status;
1976
1977         if (tevent_req_is_nterror(req, &status)) {
1978                 return status;
1979         }
1980         *addrs = talloc_move(mem_ctx, &state->addrs);
1981         *num_addrs = state->num_addrs;
1982         return NT_STATUS_OK;
1983 }
1984
1985 NTSTATUS name_resolve_bcast(TALLOC_CTX *mem_ctx,
1986                         const char *name,
1987                         int name_type,
1988                         struct sockaddr_storage **return_iplist,
1989                         size_t *return_count)
1990 {
1991         TALLOC_CTX *frame = talloc_stackframe();
1992         struct tevent_context *ev;
1993         struct tevent_req *req;
1994         NTSTATUS status = NT_STATUS_NO_MEMORY;
1995
1996         ev = samba_tevent_context_init(frame);
1997         if (ev == NULL) {
1998                 goto fail;
1999         }
2000         req = name_resolve_bcast_send(frame, ev, name, name_type);
2001         if (req == NULL) {
2002                 goto fail;
2003         }
2004         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2005                 goto fail;
2006         }
2007         status = name_resolve_bcast_recv(req, mem_ctx, return_iplist,
2008                                          return_count);
2009  fail:
2010         TALLOC_FREE(frame);
2011         return status;
2012 }
2013
2014 struct query_wins_list_state {
2015         struct tevent_context *ev;
2016         const char *name;
2017         uint8_t name_type;
2018         struct in_addr *servers;
2019         size_t num_servers;
2020         struct sockaddr_storage server;
2021         size_t num_sent;
2022
2023         struct sockaddr_storage *addrs;
2024         size_t num_addrs;
2025         uint8_t flags;
2026 };
2027
2028 static void query_wins_list_done(struct tevent_req *subreq);
2029
2030 /*
2031  * Query a list of (replicating) wins servers in sequence, call them
2032  * dead if they don't reply
2033  */
2034
2035 static struct tevent_req *query_wins_list_send(
2036         TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2037         struct in_addr src_ip, const char *name, uint8_t name_type,
2038         struct in_addr *servers, size_t num_servers)
2039 {
2040         struct tevent_req *req, *subreq;
2041         struct query_wins_list_state *state;
2042
2043         req = tevent_req_create(mem_ctx, &state,
2044                                 struct query_wins_list_state);
2045         if (req == NULL) {
2046                 return NULL;
2047         }
2048         state->ev = ev;
2049         state->name = name;
2050         state->name_type = name_type;
2051         state->servers = servers;
2052         state->num_servers = num_servers;
2053
2054         if (state->num_servers == 0) {
2055                 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
2056                 return tevent_req_post(req, ev);
2057         }
2058
2059         in_addr_to_sockaddr_storage(
2060                 &state->server, state->servers[state->num_sent]);
2061
2062         subreq = name_query_send(state, state->ev,
2063                                  state->name, state->name_type,
2064                                  false, true, &state->server);
2065
2066         if (tevent_req_nomem(subreq, req)) {
2067                 return tevent_req_post(req, ev);
2068         }
2069
2070         /* wrap check */
2071         if (state->num_sent + 1 < state->num_sent) {
2072                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2073                 return tevent_req_post(req, ev);
2074         }
2075
2076         state->num_sent += 1;
2077         if (!tevent_req_set_endtime(subreq, state->ev,
2078                                     timeval_current_ofs(2, 0))) {
2079                 return tevent_req_post(req, ev);
2080         }
2081         tevent_req_set_callback(subreq, query_wins_list_done, req);
2082         return req;
2083 }
2084
2085 static void query_wins_list_done(struct tevent_req *subreq)
2086 {
2087         struct tevent_req *req = tevent_req_callback_data(
2088                 subreq, struct tevent_req);
2089         struct query_wins_list_state *state = tevent_req_data(
2090                 req, struct query_wins_list_state);
2091         NTSTATUS status;
2092
2093         status = name_query_recv(subreq, state,
2094                                  &state->addrs, &state->num_addrs,
2095                                  &state->flags);
2096         TALLOC_FREE(subreq);
2097         if (NT_STATUS_IS_OK(status)) {
2098                 tevent_req_done(req);
2099                 return;
2100         }
2101         if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
2102                 tevent_req_nterror(req, status);
2103                 return;
2104         }
2105         wins_srv_died(state->servers[state->num_sent-1],
2106                       my_socket_addr_v4());
2107
2108         if (state->num_sent == state->num_servers) {
2109                 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
2110                 return;
2111         }
2112
2113         in_addr_to_sockaddr_storage(
2114                 &state->server, state->servers[state->num_sent]);
2115
2116         subreq = name_query_send(state, state->ev,
2117                                  state->name, state->name_type,
2118                                  false, true, &state->server);
2119         state->num_sent += 1;
2120         if (tevent_req_nomem(subreq, req)) {
2121                 return;
2122         }
2123         if (!tevent_req_set_endtime(subreq, state->ev,
2124                                     timeval_current_ofs(2, 0))) {
2125                 return;
2126         }
2127         tevent_req_set_callback(subreq, query_wins_list_done, req);
2128 }
2129
2130 static NTSTATUS query_wins_list_recv(struct tevent_req *req,
2131                                      TALLOC_CTX *mem_ctx,
2132                                      struct sockaddr_storage **addrs,
2133                                      size_t *num_addrs,
2134                                      uint8_t *flags)
2135 {
2136         struct query_wins_list_state *state = tevent_req_data(
2137                 req, struct query_wins_list_state);
2138         NTSTATUS status;
2139
2140         if (tevent_req_is_nterror(req, &status)) {
2141                 return status;
2142         }
2143         if (addrs != NULL) {
2144                 *addrs = talloc_move(mem_ctx, &state->addrs);
2145         }
2146         if (num_addrs != NULL) {
2147                 *num_addrs = state->num_addrs;
2148         }
2149         if (flags != NULL) {
2150                 *flags = state->flags;
2151         }
2152         return NT_STATUS_OK;
2153 }
2154
2155 struct resolve_wins_state {
2156         size_t num_sent;
2157         size_t num_received;
2158
2159         struct sockaddr_storage *addrs;
2160         size_t num_addrs;
2161         uint8_t flags;
2162 };
2163
2164 static void resolve_wins_done(struct tevent_req *subreq);
2165
2166 struct tevent_req *resolve_wins_send(TALLOC_CTX *mem_ctx,
2167                                      struct tevent_context *ev,
2168                                      const char *name,
2169                                      int name_type)
2170 {
2171         struct tevent_req *req, *subreq;
2172         struct resolve_wins_state *state;
2173         char **wins_tags = NULL;
2174         struct sockaddr_storage src_ss;
2175         struct samba_sockaddr src_sa = {0};
2176         struct in_addr src_ip;
2177         size_t i, num_wins_tags;
2178         bool ok;
2179
2180         req = tevent_req_create(mem_ctx, &state,
2181                                 struct resolve_wins_state);
2182         if (req == NULL) {
2183                 return NULL;
2184         }
2185
2186         if (wins_srv_count() < 1) {
2187                 DEBUG(3,("resolve_wins: WINS server resolution selected "
2188                         "and no WINS servers listed.\n"));
2189                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2190                 goto fail;
2191         }
2192
2193         /* the address we will be sending from */
2194         if (!interpret_string_addr(&src_ss, lp_nbt_client_socket_address(),
2195                                 AI_NUMERICHOST|AI_PASSIVE)) {
2196                 zero_sockaddr(&src_ss);
2197         }
2198
2199         ok = sockaddr_storage_to_samba_sockaddr(&src_sa, &src_ss);
2200         if (!ok) {
2201                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2202                 goto fail;
2203         }
2204
2205         if (src_sa.u.ss.ss_family != AF_INET) {
2206                 char addr[INET6_ADDRSTRLEN];
2207                 print_sockaddr(addr, sizeof(addr), &src_sa.u.ss);
2208                 DEBUG(3,("resolve_wins: cannot receive WINS replies "
2209                         "on IPv6 address %s\n",
2210                         addr));
2211                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2212                 goto fail;
2213         }
2214
2215         src_ip = src_sa.u.in.sin_addr;
2216
2217         wins_tags = wins_srv_tags();
2218         if (wins_tags == NULL) {
2219                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2220                 goto fail;
2221         }
2222
2223         num_wins_tags = 0;
2224         while (wins_tags[num_wins_tags] != NULL) {
2225                 /* wrap check. */
2226                 if (num_wins_tags + 1 < num_wins_tags) {
2227                         tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2228                         goto fail;
2229                 }
2230                 num_wins_tags += 1;
2231         }
2232
2233         for (i=0; i<num_wins_tags; i++) {
2234                 size_t num_servers, num_alive;
2235                 struct in_addr *servers, *alive;
2236                 size_t j;
2237
2238                 if (!wins_server_tag_ips(wins_tags[i], talloc_tos(),
2239                                          &servers, &num_servers)) {
2240                         DEBUG(10, ("wins_server_tag_ips failed for tag %s\n",
2241                                    wins_tags[i]));
2242                         continue;
2243                 }
2244
2245                 alive = talloc_array(state, struct in_addr, num_servers);
2246                 if (tevent_req_nomem(alive, req)) {
2247                         goto fail;
2248                 }
2249
2250                 num_alive = 0;
2251                 for (j=0; j<num_servers; j++) {
2252                         struct in_addr wins_ip = servers[j];
2253
2254                         if (global_in_nmbd && ismyip_v4(wins_ip)) {
2255                                 /* yikes! we'll loop forever */
2256                                 continue;
2257                         }
2258                         /* skip any that have been unresponsive lately */
2259                         if (wins_srv_is_dead(wins_ip, src_ip)) {
2260                                 continue;
2261                         }
2262                         DEBUG(3, ("resolve_wins: using WINS server %s "
2263                                  "and tag '%s'\n",
2264                                   inet_ntoa(wins_ip), wins_tags[i]));
2265                         alive[num_alive] = wins_ip;
2266                         num_alive += 1;
2267                 }
2268                 TALLOC_FREE(servers);
2269
2270                 if (num_alive == 0) {
2271                         continue;
2272                 }
2273
2274                 subreq = query_wins_list_send(
2275                         state, ev, src_ip, name, name_type,
2276                         alive, num_alive);
2277                 if (tevent_req_nomem(subreq, req)) {
2278                         goto fail;
2279                 }
2280                 tevent_req_set_callback(subreq, resolve_wins_done, req);
2281                 state->num_sent += 1;
2282         }
2283
2284         if (state->num_sent == 0) {
2285                 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
2286                 goto fail;
2287         }
2288
2289         wins_srv_tags_free(wins_tags);
2290         return req;
2291 fail:
2292         wins_srv_tags_free(wins_tags);
2293         return tevent_req_post(req, ev);
2294 }
2295
2296 static void resolve_wins_done(struct tevent_req *subreq)
2297 {
2298         struct tevent_req *req = tevent_req_callback_data(
2299                 subreq, struct tevent_req);
2300         struct resolve_wins_state *state = tevent_req_data(
2301                 req, struct resolve_wins_state);
2302         NTSTATUS status;
2303
2304         status = query_wins_list_recv(subreq, state, &state->addrs,
2305                                       &state->num_addrs, &state->flags);
2306         if (NT_STATUS_IS_OK(status)) {
2307                 tevent_req_done(req);
2308                 return;
2309         }
2310
2311         /* wrap check. */
2312         if (state->num_received + 1 < state->num_received) {
2313                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2314                 return;
2315         }
2316
2317         state->num_received += 1;
2318
2319         if (state->num_received < state->num_sent) {
2320                 /*
2321                  * Wait for the others
2322                  */
2323                 return;
2324         }
2325         tevent_req_nterror(req, status);
2326 }
2327
2328 NTSTATUS resolve_wins_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
2329                            struct sockaddr_storage **addrs,
2330                            size_t *num_addrs, uint8_t *flags)
2331 {
2332         struct resolve_wins_state *state = tevent_req_data(
2333                 req, struct resolve_wins_state);
2334         NTSTATUS status;
2335
2336         if (tevent_req_is_nterror(req, &status)) {
2337                 return status;
2338         }
2339         if (addrs != NULL) {
2340                 *addrs = talloc_move(mem_ctx, &state->addrs);
2341         }
2342         if (num_addrs != NULL) {
2343                 *num_addrs = state->num_addrs;
2344         }
2345         if (flags != NULL) {
2346                 *flags = state->flags;
2347         }
2348         return NT_STATUS_OK;
2349 }
2350
2351 /********************************************************
2352  Resolve via "wins" method.
2353 *********************************************************/
2354
2355 NTSTATUS resolve_wins(TALLOC_CTX *mem_ctx,
2356                 const char *name,
2357                 int name_type,
2358                 struct sockaddr_storage **return_iplist,
2359                 size_t *return_count)
2360 {
2361         struct tevent_context *ev;
2362         struct tevent_req *req;
2363         NTSTATUS status = NT_STATUS_NO_MEMORY;
2364
2365         ev = samba_tevent_context_init(talloc_tos());
2366         if (ev == NULL) {
2367                 goto fail;
2368         }
2369         req = resolve_wins_send(ev, ev, name, name_type);
2370         if (req == NULL) {
2371                 goto fail;
2372         }
2373         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2374                 goto fail;
2375         }
2376         status = resolve_wins_recv(req, mem_ctx, return_iplist, return_count,
2377                                    NULL);
2378 fail:
2379         TALLOC_FREE(ev);
2380         return status;
2381 }
2382
2383 /********************************************************
2384  Use ads_dns_lookup_[a|aaaa]_send() calls to look up a
2385  list of names asynchronously.
2386 *********************************************************/
2387
2388 struct dns_query_state {
2389         /* Used to tell our parent we've completed. */
2390         struct dns_lookup_list_async_state *p_async_state;
2391         const char *query_name; /* For debugging only. */
2392         size_t num_addrs;
2393         struct samba_sockaddr *addrs;
2394 };
2395
2396 struct dns_lookup_list_async_state {
2397         bool timed_out;
2398         size_t num_query_returns;
2399         struct dns_query_state *queries;
2400 };
2401
2402 /* Called on query timeout. */
2403 static void dns_lookup_send_timeout_handler(struct tevent_context *ev,
2404                                             struct tevent_timer *te,
2405                                             struct timeval t,
2406                                             void *private_data)
2407 {
2408         bool *timed_out = (bool *)private_data;
2409         *timed_out = true;
2410 }
2411
2412 static void dns_lookup_list_a_done(struct tevent_req *req);
2413 #if defined(HAVE_IPV6)
2414 static void dns_lookup_list_aaaa_done(struct tevent_req *req);
2415 #endif
2416
2417 NTSTATUS dns_lookup_list_async(TALLOC_CTX *ctx,
2418                               size_t num_dns_names,
2419                               const char **dns_lookup_names,
2420                               size_t *p_num_addrs,
2421                               struct samba_sockaddr **pp_addrs,
2422                               char ***pp_dns_names)
2423 {
2424         struct dns_lookup_list_async_state *state = NULL;
2425         struct tevent_context *ev = NULL;
2426         struct tevent_req *req = NULL;
2427         struct tevent_timer *timer = NULL;
2428         size_t num_queries_sent = 0;
2429         size_t queries_size = num_dns_names;
2430         size_t i;
2431         size_t num_addrs = 0;
2432         struct samba_sockaddr *addr_out = NULL;
2433         char **dns_names_ret = NULL;
2434         NTSTATUS status = NT_STATUS_NO_MEMORY;
2435
2436         /* Nothing to do. */
2437         if (num_dns_names == 0) {
2438                 *p_num_addrs = 0;
2439                 *pp_addrs = NULL;
2440                 if (pp_dns_names != NULL) {
2441                         *pp_dns_names = NULL;
2442                 }
2443                 return NT_STATUS_OK;
2444         }
2445
2446         state = talloc_zero(ctx, struct dns_lookup_list_async_state);
2447         if (state == NULL) {
2448                 goto fail;
2449         }
2450         ev = samba_tevent_context_init(ctx);
2451         if (ev == NULL) {
2452                 goto fail;
2453         }
2454
2455 #if defined(HAVE_IPV6)
2456         queries_size = 2 * num_dns_names;
2457         /* Wrap protection. */
2458         if (queries_size < num_dns_names) {
2459                 goto fail;
2460         }
2461 #else
2462         queries_size = num_dns_names;
2463 #endif
2464
2465         state->queries = talloc_zero_array(state,
2466                                            struct dns_query_state,
2467                                            queries_size);
2468         if (state->queries == NULL) {
2469                 goto fail;
2470         }
2471
2472         /* Hit all the DNS servers with async lookups for all the names. */
2473         for (i = 0; i < num_dns_names; i++) {
2474                 DBG_INFO("async DNS lookup A record for %s\n",
2475                         dns_lookup_names[i]);
2476
2477                 /* Setup the query state. */
2478                 state->queries[num_queries_sent].query_name =
2479                                         dns_lookup_names[i];
2480                 state->queries[num_queries_sent].p_async_state = state;
2481
2482                 req = ads_dns_lookup_a_send(ev, ev, dns_lookup_names[i]);
2483                 if (req == NULL) {
2484                         goto fail;
2485                 }
2486                 tevent_req_set_callback(req,
2487                                 dns_lookup_list_a_done,
2488                                 &state->queries[num_queries_sent]);
2489                 num_queries_sent++;
2490
2491 #if defined(HAVE_IPV6)
2492                 /* If we're IPv6 capable ask for that too. */
2493                 state->queries[num_queries_sent].query_name =
2494                                         dns_lookup_names[i];
2495                 state->queries[num_queries_sent].p_async_state = state;
2496
2497                 DBG_INFO("async DNS lookup AAAA record for %s\n",
2498                         dns_lookup_names[i]);
2499
2500                 req = ads_dns_lookup_aaaa_send(ev, ev, dns_lookup_names[i]);
2501                 if (req == NULL) {
2502                         goto fail;
2503                 }
2504                 tevent_req_set_callback(req,
2505                                         dns_lookup_list_aaaa_done,
2506                                         &state->queries[num_queries_sent]);
2507                 num_queries_sent++;
2508 #endif
2509         }
2510
2511         /* We must always have a timeout. */
2512         timer = tevent_add_timer(ev,
2513                                  ev,
2514                                  timeval_current_ofs(lp_get_async_dns_timeout(),
2515                                                      0),
2516                                  dns_lookup_send_timeout_handler,
2517                                  &state->timed_out);
2518         if (timer == NULL) {
2519                 goto fail;
2520         }
2521
2522         /* Loop until timed out or got all replies. */
2523         for(;;) {
2524                 int ret;
2525
2526                 if (state->timed_out) {
2527                         break;
2528                 }
2529                 if (state->num_query_returns == num_queries_sent) {
2530                         break;
2531                 }
2532                 ret = tevent_loop_once(ev);
2533                 if (ret != 0) {
2534                         goto fail;
2535                 }
2536         }
2537
2538         /* Count what we got back. */
2539         for (i = 0; i < num_queries_sent; i++) {
2540                 struct dns_query_state *query = &state->queries[i];
2541
2542                 /* Wrap check. */
2543                 if (num_addrs + query->num_addrs < num_addrs) {
2544                         goto fail;
2545                 }
2546                 num_addrs += query->num_addrs;
2547         }
2548
2549         if (state->timed_out) {
2550                 DBG_INFO("async DNS lookup timed out after %zu entries "
2551                         "(not an error)\n",
2552                         num_addrs);
2553         }
2554
2555         addr_out = talloc_zero_array(ctx,
2556                                      struct samba_sockaddr,
2557                                      num_addrs);
2558         if (addr_out == NULL) {
2559                 goto fail;
2560         }
2561
2562         /*
2563          * Did the caller want an array of names back
2564          * that match the IP addresses ? If we provide
2565          * this, dsgetdcname() internals can now use this
2566          * async lookup code also.
2567          */
2568         if (pp_dns_names != NULL) {
2569                 dns_names_ret = talloc_zero_array(ctx,
2570                                                   char *,
2571                                                   num_addrs);
2572                 if (dns_names_ret == NULL) {
2573                         goto fail;
2574                 }
2575         }
2576
2577         /* Copy what we got back. */
2578         num_addrs = 0;
2579         for (i = 0; i < num_queries_sent; i++) {
2580                 size_t j;
2581                 struct dns_query_state *query = &state->queries[i];
2582
2583                 if (query->num_addrs == 0) {
2584                         continue;
2585                 }
2586
2587                 if (dns_names_ret != NULL) {
2588                         /*
2589                          * If caller wants a name array matched with
2590                          * the addrs array, copy the same queried name for
2591                          * each IP address returned.
2592                          */
2593                         for (j = 0; j < query->num_addrs; j++) {
2594                                 dns_names_ret[num_addrs + j] = talloc_strdup(
2595                                                 ctx,
2596                                                 query->query_name);
2597                                 if (dns_names_ret[num_addrs + j] == NULL) {
2598                                         goto fail;
2599                                 }
2600                         }
2601                 }
2602
2603                 for (j = 0; j < query->num_addrs; j++) {
2604                         addr_out[num_addrs] = query->addrs[j];
2605                 }
2606                 num_addrs += query->num_addrs;
2607         }
2608
2609         *p_num_addrs = num_addrs;
2610         *pp_addrs = addr_out;
2611         if (pp_dns_names != NULL) {
2612                 *pp_dns_names = dns_names_ret;
2613         }
2614
2615         status = NT_STATUS_OK;
2616
2617   fail:
2618
2619         TALLOC_FREE(state);
2620         TALLOC_FREE(ev);
2621         return status;
2622 }
2623
2624 /*
2625  Called when an A record lookup completes.
2626 */
2627
2628 static void dns_lookup_list_a_done(struct tevent_req *req)
2629 {
2630         /*
2631          * Callback data is an element of a talloc'ed array,
2632          * not a talloc object in its own right. So use the
2633          * tevent_req_callback_data_void() void * cast function.
2634          */
2635         struct dns_query_state *state = (struct dns_query_state *)
2636                                 tevent_req_callback_data_void(req);
2637         uint8_t rcode = 0;
2638         size_t i;
2639         char **hostnames_out = NULL;
2640         struct samba_sockaddr *addrs = NULL;
2641         size_t num_addrs = 0;
2642         NTSTATUS status;
2643
2644         /* For good or ill, tell the parent we're finished. */
2645         state->p_async_state->num_query_returns++;
2646
2647         status = ads_dns_lookup_a_recv(req,
2648                                        state->p_async_state,
2649                                        &rcode,
2650                                        &num_addrs,
2651                                        &hostnames_out,
2652                                        &addrs);
2653         if (!NT_STATUS_IS_OK(status)) {
2654                 DBG_INFO("async DNS A lookup for %s returned %s\n",
2655                         state->query_name,
2656                         nt_errstr(status));
2657                 return;
2658         }
2659
2660         if (rcode != DNS_RCODE_OK) {
2661                 DBG_INFO("async DNS A lookup for %s returned DNS code %u\n",
2662                         state->query_name,
2663                         (unsigned int)rcode);
2664                 return;
2665         }
2666
2667         if (num_addrs == 0) {
2668                 DBG_INFO("async DNS A lookup for %s returned 0 addresses.\n",
2669                         state->query_name);
2670                 return;
2671         }
2672
2673         /* Copy data out. */
2674         state->addrs = talloc_zero_array(state->p_async_state,
2675                                          struct samba_sockaddr,
2676                                          num_addrs);
2677         if (state->addrs == NULL) {
2678                 return;
2679         }
2680
2681         for (i = 0; i < num_addrs; i++) {
2682                 char addr[INET6_ADDRSTRLEN];
2683                 DBG_INFO("async DNS A lookup for %s [%zu] got %s -> %s\n",
2684                         state->query_name,
2685                         i,
2686                         hostnames_out[i],
2687                         print_sockaddr(addr,
2688                                 sizeof(addr),
2689                                 &addrs[i].u.ss));
2690
2691                 state->addrs[i] = addrs[i];
2692         }
2693         state->num_addrs = num_addrs;
2694 }
2695
2696 #if defined(HAVE_IPV6)
2697 /*
2698  Called when an AAAA record lookup completes.
2699 */
2700
2701 static void dns_lookup_list_aaaa_done(struct tevent_req *req)
2702 {
2703         /*
2704          * Callback data is an element of a talloc'ed array,
2705          * not a talloc object in its own right. So use the
2706          * tevent_req_callback_data_void() void * cast function.
2707          */
2708         struct dns_query_state *state = (struct dns_query_state *)
2709                                 tevent_req_callback_data_void(req);
2710         uint8_t rcode = 0;
2711         size_t i;
2712         char **hostnames_out = NULL;
2713         struct samba_sockaddr *addrs = NULL;
2714         size_t num_addrs = 0;
2715         NTSTATUS status;
2716
2717         /* For good or ill, tell the parent we're finished. */
2718         state->p_async_state->num_query_returns++;
2719
2720         status = ads_dns_lookup_aaaa_recv(req,
2721                                           state->p_async_state,
2722                                           &rcode,
2723                                           &num_addrs,
2724                                           &hostnames_out,
2725                                           &addrs);
2726         if (!NT_STATUS_IS_OK(status)) {
2727                 DBG_INFO("async DNS AAAA lookup for %s returned %s\n",
2728                         state->query_name,
2729                         nt_errstr(status));
2730                 return;
2731         }
2732
2733         if (rcode != DNS_RCODE_OK) {
2734                 DBG_INFO("async DNS AAAA lookup for %s returned DNS code %u\n",
2735                         state->query_name,
2736                         (unsigned int)rcode);
2737                 return;
2738         }
2739
2740         if (num_addrs == 0) {
2741                 DBG_INFO("async DNS AAAA lookup for %s returned 0 addresses.\n",
2742                         state->query_name);
2743                 return;
2744         }
2745
2746         /* Copy data out. */
2747         state->addrs = talloc_zero_array(state->p_async_state,
2748                                          struct samba_sockaddr,
2749                                          num_addrs);
2750         if (state->addrs == NULL) {
2751                 return;
2752         }
2753
2754         for (i = 0; i < num_addrs; i++) {
2755                 char addr[INET6_ADDRSTRLEN];
2756                 DBG_INFO("async DNS AAAA lookup for %s [%zu] got %s -> %s\n",
2757                         state->query_name,
2758                         i,
2759                         hostnames_out[i],
2760                         print_sockaddr(addr,
2761                                 sizeof(addr),
2762                                 &addrs[i].u.ss));
2763                 state->addrs[i] = addrs[i];
2764         }
2765         state->num_addrs = num_addrs;
2766 }
2767 #endif
2768
2769 /********************************************************
2770  Resolve via "hosts" method.
2771 *********************************************************/
2772
2773 static NTSTATUS resolve_hosts(TALLOC_CTX *mem_ctx,
2774                               const char *name,
2775                               int name_type,
2776                               struct sockaddr_storage **return_iplist,
2777                               size_t *return_count)
2778 {
2779         /*
2780          * "host" means do a localhost, or dns lookup.
2781          */
2782         struct addrinfo hints;
2783         struct addrinfo *ailist = NULL;
2784         struct addrinfo *res = NULL;
2785         int ret = -1;
2786         size_t i = 0;
2787         size_t ret_count = 0;
2788         struct sockaddr_storage *iplist = NULL;
2789
2790         if ( name_type != 0x20 && name_type != 0x0) {
2791                 DEBUG(5, ("resolve_hosts: not appropriate "
2792                         "for name type <0x%x>\n",
2793                         name_type));
2794                 return NT_STATUS_INVALID_PARAMETER;
2795         }
2796
2797         DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n",
2798                                 name, name_type));
2799
2800         ZERO_STRUCT(hints);
2801         /* By default make sure it supports TCP. */
2802         hints.ai_socktype = SOCK_STREAM;
2803         hints.ai_flags = AI_ADDRCONFIG;
2804
2805 #if !defined(HAVE_IPV6)
2806         /* Unless we have IPv6, we really only want IPv4 addresses back. */
2807         hints.ai_family = AF_INET;
2808 #endif
2809
2810         ret = getaddrinfo(name,
2811                         NULL,
2812                         &hints,
2813                         &ailist);
2814         if (ret) {
2815                 DEBUG(3,("resolve_hosts: getaddrinfo failed for name %s [%s]\n",
2816                         name,
2817                         gai_strerror(ret) ));
2818         }
2819
2820         for (res = ailist; res; res = res->ai_next) {
2821                 struct sockaddr_storage ss = {0};
2822                 struct sockaddr_storage *tmp = NULL;
2823
2824                 if ((res->ai_addr == NULL) ||
2825                     (res->ai_addrlen == 0) ||
2826                     (res->ai_addrlen > sizeof(ss))) {
2827                         continue;
2828                 }
2829
2830                 memcpy(&ss, res->ai_addr, res->ai_addrlen);
2831
2832                 if (is_zero_addr(&ss)) {
2833                         continue;
2834                 }
2835
2836                 /* wrap check. */
2837                 if (ret_count + 1 < ret_count) {
2838                         freeaddrinfo(ailist);
2839                         TALLOC_FREE(iplist);
2840                         return NT_STATUS_INVALID_PARAMETER;
2841                 }
2842                 ret_count += 1;
2843
2844                 tmp = talloc_realloc(
2845                         mem_ctx, iplist, struct sockaddr_storage,
2846                         ret_count);
2847                 if (tmp == NULL) {
2848                         DEBUG(3,("resolve_hosts: malloc fail !\n"));
2849                         freeaddrinfo(ailist);
2850                         TALLOC_FREE(iplist);
2851                         return NT_STATUS_NO_MEMORY;
2852                 }
2853                 iplist = tmp;
2854                 iplist[i] = ss;
2855                 i++;
2856         }
2857         if (ailist) {
2858                 freeaddrinfo(ailist);
2859         }
2860         if (ret_count == 0) {
2861                 return NT_STATUS_UNSUCCESSFUL;
2862         }
2863         *return_count = ret_count;
2864         *return_iplist = iplist;
2865         return NT_STATUS_OK;
2866 }
2867
2868 /********************************************************
2869  Resolve via "ADS" method.
2870 *********************************************************/
2871
2872 /* Special name type used to cause a _kerberos DNS lookup. */
2873 #define KDC_NAME_TYPE 0xDCDC
2874
2875 static NTSTATUS resolve_ads(TALLOC_CTX *ctx,
2876                             const char *name,
2877                             int name_type,
2878                             const char *sitename,
2879                             struct sockaddr_storage **return_addrs,
2880                             size_t *return_count)
2881 {
2882         size_t                  i;
2883         NTSTATUS                status;
2884         struct dns_rr_srv       *dcs = NULL;
2885         size_t                  numdcs = 0;
2886         size_t                  numaddrs = 0;
2887         size_t num_srv_addrs = 0;
2888         struct sockaddr_storage *srv_addrs = NULL;
2889         size_t num_dns_addrs = 0;
2890         struct samba_sockaddr *dns_addrs = NULL;
2891         size_t num_dns_names = 0;
2892         const char **dns_lookup_names = NULL;
2893         struct sockaddr_storage *ret_addrs = NULL;
2894
2895         if ((name_type != 0x1c) && (name_type != KDC_NAME_TYPE) &&
2896             (name_type != 0x1b)) {
2897                 return NT_STATUS_INVALID_PARAMETER;
2898         }
2899
2900         switch (name_type) {
2901                 case 0x1b:
2902                         DEBUG(5,("resolve_ads: Attempting to resolve "
2903                                  "PDC for %s using DNS\n", name));
2904                         status = ads_dns_query_pdc(ctx,
2905                                                    name,
2906                                                    &dcs,
2907                                                    &numdcs);
2908                         break;
2909
2910                 case 0x1c:
2911                         DEBUG(5,("resolve_ads: Attempting to resolve "
2912                                  "DCs for %s using DNS\n", name));
2913                         status = ads_dns_query_dcs(ctx,
2914                                                    name,
2915                                                    sitename,
2916                                                    &dcs,
2917                                                    &numdcs);
2918                         break;
2919                 case KDC_NAME_TYPE:
2920                         DEBUG(5,("resolve_ads: Attempting to resolve "
2921                                  "KDCs for %s using DNS\n", name));
2922                         status = ads_dns_query_kdcs(ctx,
2923                                                     name,
2924                                                     sitename,
2925                                                     &dcs,
2926                                                     &numdcs);
2927                         break;
2928                 default:
2929                         status = NT_STATUS_INVALID_PARAMETER;
2930                         break;
2931         }
2932
2933         if (!NT_STATUS_IS_OK(status)) {
2934                 TALLOC_FREE(dcs);
2935                 return status;
2936         }
2937
2938         if (numdcs == 0) {
2939                 *return_addrs = NULL;
2940                 *return_count = 0;
2941                 TALLOC_FREE(dcs);
2942                 return NT_STATUS_OK;
2943         }
2944
2945         /*
2946          * Split the returned values into 2 arrays. First one
2947          * is a struct sockaddr_storage array that contains results
2948          * from the SRV record lookup that contain both hostnames
2949          * and IP addresses. We only need to copy out the IP
2950          * addresses. This is srv_addrs.
2951          *
2952          * Second array contains the results from the SRV record
2953          * lookup that only contain hostnames - no IP addresses.
2954          * We must then call dns_lookup_list() to lookup
2955          * hostnames -> IP address. This is dns_addrs.
2956          *
2957          * Finally we will merge these two arrays to create the
2958          * return sockaddr_storage array.
2959          */
2960
2961         /* First count the sizes of each array. */
2962         for(i = 0; i < numdcs; i++) {
2963                 if (dcs[i].ss_s != NULL) {
2964                         /* IP address returned in SRV record. */
2965                         if (num_srv_addrs + dcs[i].num_ips < num_srv_addrs) {
2966                                 /* Wrap check. */
2967                                 TALLOC_FREE(dcs);
2968                                 return NT_STATUS_INVALID_PARAMETER;
2969                         }
2970                         /* Add in the number of addresses we got. */
2971                         num_srv_addrs += dcs[i].num_ips;
2972                         /*
2973                          * If we got any IP addresses zero out
2974                          * the hostname so we know we've already
2975                          * processed this entry and won't add it
2976                          * to the dns_lookup_names array we use
2977                          * to do DNS queries below.
2978                          */
2979                         dcs[i].hostname = NULL;
2980                 } else {
2981                         /* Ensure we have a hostname to lookup. */
2982                         if (dcs[i].hostname == NULL) {
2983                                 continue;
2984                         }
2985                         /* No IP address returned in SRV record. */
2986                         if (num_dns_names + 1 < num_dns_names) {
2987                                 /* Wrap check. */
2988                                 TALLOC_FREE(dcs);
2989                                 return NT_STATUS_INVALID_PARAMETER;
2990                         }
2991                         /* One more name to lookup. */
2992                         num_dns_names += 1;
2993                 }
2994         }
2995
2996         /* Allocate the list of IP addresses we already have. */
2997         srv_addrs = talloc_zero_array(ctx,
2998                                 struct sockaddr_storage,
2999                                 num_srv_addrs);
3000         if (srv_addrs == NULL) {
3001                 TALLOC_FREE(dcs);
3002                 return NT_STATUS_NO_MEMORY;
3003         }
3004
3005         /* Copy the addresses we already have. */
3006         num_srv_addrs = 0;
3007         for(i = 0; i < numdcs; i++) {
3008                 /* Copy all the IP addresses from the SRV response */
3009                 size_t j;
3010                 for (j = 0; j < dcs[i].num_ips; j++) {
3011                         char addr[INET6_ADDRSTRLEN];
3012
3013                         srv_addrs[num_srv_addrs] = dcs[i].ss_s[j];
3014                         if (is_zero_addr(&srv_addrs[num_srv_addrs])) {
3015                                 continue;
3016                         }
3017
3018                         DBG_DEBUG("SRV lookup %s got IP[%zu] %s\n",
3019                                 name,
3020                                 j,
3021                                 print_sockaddr(addr,
3022                                         sizeof(addr),
3023                                         &srv_addrs[num_srv_addrs]));
3024
3025                         num_srv_addrs++;
3026                 }
3027         }
3028
3029         /* Allocate the array of hostnames we must look up. */
3030         dns_lookup_names = talloc_zero_array(ctx,
3031                                         const char *,
3032                                         num_dns_names);
3033         if (dns_lookup_names == NULL) {
3034                 TALLOC_FREE(dcs);
3035                 TALLOC_FREE(srv_addrs);
3036                 return NT_STATUS_NO_MEMORY;
3037         }
3038
3039         num_dns_names = 0;
3040         for(i = 0; i < numdcs; i++) {
3041                 if (dcs[i].hostname == NULL) {
3042                         /*
3043                          * Must have been a SRV return with an IP address.
3044                          * We don't need to look up this hostname.
3045                          */
3046                         continue;
3047                 }
3048                 dns_lookup_names[num_dns_names] = dcs[i].hostname;
3049                 num_dns_names++;
3050         }
3051
3052         /* Lookup the addresses on the dns_lookup_list. */
3053         status = dns_lookup_list_async(ctx,
3054                                 num_dns_names,
3055                                 dns_lookup_names,
3056                                 &num_dns_addrs,
3057                                 &dns_addrs,
3058                                 NULL);
3059
3060         if (!NT_STATUS_IS_OK(status)) {
3061                 TALLOC_FREE(dcs);
3062                 TALLOC_FREE(srv_addrs);
3063                 TALLOC_FREE(dns_lookup_names);
3064                 TALLOC_FREE(dns_addrs);
3065                 return status;
3066         }
3067
3068         /*
3069          * Combine the two sockaddr_storage arrays into a talloc'ed
3070          * struct sockaddr_storage array return.
3071          */
3072
3073         numaddrs = num_srv_addrs + num_dns_addrs;
3074         /* Wrap check */
3075         if (numaddrs < num_srv_addrs) {
3076                 TALLOC_FREE(dcs);
3077                 TALLOC_FREE(srv_addrs);
3078                 TALLOC_FREE(dns_addrs);
3079                 TALLOC_FREE(dns_lookup_names);
3080                 return NT_STATUS_INVALID_PARAMETER;
3081         }
3082
3083         if (numaddrs == 0) {
3084                 /* Keep the same semantics for zero names. */
3085                 TALLOC_FREE(dcs);
3086                 TALLOC_FREE(srv_addrs);
3087                 TALLOC_FREE(dns_addrs);
3088                 TALLOC_FREE(dns_lookup_names);
3089                 *return_addrs = NULL;
3090                 *return_count = 0;
3091                 return NT_STATUS_OK;
3092         }
3093
3094         ret_addrs = talloc_zero_array(ctx,
3095                                 struct sockaddr_storage,
3096                                 numaddrs);
3097         if (ret_addrs == NULL) {
3098                 TALLOC_FREE(dcs);
3099                 TALLOC_FREE(srv_addrs);
3100                 TALLOC_FREE(dns_addrs);
3101                 TALLOC_FREE(dns_lookup_names);
3102                 return NT_STATUS_NO_MEMORY;
3103         }
3104
3105         for (i = 0; i < num_srv_addrs; i++) {
3106                 ret_addrs[i] = srv_addrs[i];
3107         }
3108         for (i = 0; i < num_dns_addrs; i++) {
3109                 ret_addrs[num_srv_addrs+i] = dns_addrs[i].u.ss;
3110         }
3111
3112         TALLOC_FREE(dcs);
3113         TALLOC_FREE(srv_addrs);
3114         TALLOC_FREE(dns_addrs);
3115         TALLOC_FREE(dns_lookup_names);
3116
3117         *return_addrs = ret_addrs;
3118         *return_count = numaddrs;
3119         return NT_STATUS_OK;
3120 }
3121
3122 static const char **filter_out_nbt_lookup(TALLOC_CTX *mem_ctx,
3123                                           const char **resolve_order)
3124 {
3125         size_t i, len, result_idx;
3126         const char **result;
3127
3128         len = 0;
3129         while (resolve_order[len] != NULL) {
3130                 len += 1;
3131         }
3132
3133         result = talloc_array(mem_ctx, const char *, len+1);
3134         if (result == NULL) {
3135                 return NULL;
3136         }
3137
3138         result_idx = 0;
3139
3140         for (i=0; i<len; i++) {
3141                 const char *tok = resolve_order[i];
3142
3143                 if (strequal(tok, "lmhosts") || strequal(tok, "wins") ||
3144                     strequal(tok, "bcast")) {
3145                         continue;
3146                 }
3147                 result[result_idx++] = tok;
3148         }
3149         result[result_idx] = NULL;
3150
3151         return result;
3152 }
3153
3154 /*******************************************************************
3155  Samba interface to resolve a name into an IP address.
3156  Use this function if the string is either an IP address, DNS
3157  or host name or NetBIOS name. This uses the name switch in the
3158  smb.conf to determine the order of name resolution.
3159
3160  Added support for ip addr/port to support ADS ldap servers.
3161  the only place we currently care about the port is in the
3162  resolve_hosts() when looking up DC's via SRV RR entries in DNS
3163 **********************************************************************/
3164
3165 NTSTATUS internal_resolve_name(TALLOC_CTX *ctx,
3166                                 const char *name,
3167                                 int name_type,
3168                                 const char *sitename,
3169                                 struct samba_sockaddr **return_salist,
3170                                 size_t *return_count,
3171                                 const char **resolve_order)
3172 {
3173         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
3174         size_t i;
3175         size_t nc_count = 0;
3176         size_t ret_count = 0;
3177         bool ok;
3178         struct sockaddr_storage *ss_list = NULL;
3179         struct samba_sockaddr *sa_list = NULL;
3180         TALLOC_CTX *frame = talloc_stackframe();
3181
3182         DBG_DEBUG("looking up %s#%x (sitename %s)\n",
3183                 name, name_type, sitename ? sitename : "(null)");
3184
3185         if (is_ipaddress(name)) {
3186                 struct sockaddr_storage ss;
3187
3188                 /* if it's in the form of an IP address then get the lib to interpret it */
3189                 ok = interpret_string_addr(&ss, name, AI_NUMERICHOST);
3190                 if (!ok) {
3191                         DBG_WARNING("interpret_string_addr failed on %s\n",
3192                                 name);
3193                         TALLOC_FREE(frame);
3194                         return NT_STATUS_INVALID_PARAMETER;
3195                 }
3196                 if (is_zero_addr(&ss)) {
3197                         TALLOC_FREE(frame);
3198                         return NT_STATUS_UNSUCCESSFUL;
3199                 }
3200
3201                 status = sockaddr_array_to_samba_sockaddr_array(frame,
3202                                                         &sa_list,
3203                                                         &ret_count,
3204                                                         &ss,
3205                                                         1);
3206                 if (!NT_STATUS_IS_OK(status)) {
3207                         TALLOC_FREE(frame);
3208                         return status;
3209                 }
3210
3211                 *return_salist = talloc_move(ctx, &sa_list);
3212                 *return_count = 1;
3213                 TALLOC_FREE(frame);
3214                 return NT_STATUS_OK;
3215         }
3216
3217         /* Check name cache */
3218
3219         ok = namecache_fetch(frame,
3220                                 name,
3221                                 name_type,
3222                                 &sa_list,
3223                                 &nc_count);
3224         if (ok) {
3225                 /*
3226                  * remove_duplicate_addrs2() has the
3227                  * side effect of removing zero addresses,
3228                  * so use it here.
3229                  */
3230                 nc_count = remove_duplicate_addrs2(sa_list, nc_count);
3231                 if (nc_count == 0) {
3232                         TALLOC_FREE(sa_list);
3233                         TALLOC_FREE(frame);
3234                         return NT_STATUS_UNSUCCESSFUL;
3235                 }
3236                 *return_count = nc_count;
3237                 *return_salist = talloc_move(ctx, &sa_list);
3238                 TALLOC_FREE(frame);
3239                 return NT_STATUS_OK;
3240         }
3241
3242         /* set the name resolution order */
3243
3244         if (resolve_order && strcmp(resolve_order[0], "NULL") == 0) {
3245                 DBG_DEBUG("all lookups disabled\n");
3246                 TALLOC_FREE(frame);
3247                 return NT_STATUS_INVALID_PARAMETER;
3248         }
3249
3250         if (!resolve_order || !resolve_order[0]) {
3251                 static const char *host_order[] = { "host", NULL };
3252                 resolve_order = host_order;
3253         }
3254
3255         if ((strlen(name) > MAX_NETBIOSNAME_LEN - 1) ||
3256             (strchr(name, '.') != NULL)) {
3257                 /*
3258                  * Don't do NBT lookup, the name would not fit anyway
3259                  */
3260                 resolve_order = filter_out_nbt_lookup(frame, resolve_order);
3261                 if (resolve_order == NULL) {
3262                         TALLOC_FREE(frame);
3263                         return NT_STATUS_NO_MEMORY;
3264                 }
3265         }
3266
3267         /* iterate through the name resolution backends */
3268
3269         for (i=0; resolve_order[i]; i++) {
3270                 const char *tok = resolve_order[i];
3271
3272                 if ((strequal(tok, "host") || strequal(tok, "hosts"))) {
3273                         status = resolve_hosts(talloc_tos(),
3274                                                name,
3275                                                name_type,
3276                                                &ss_list,
3277                                                &ret_count);
3278                         if (!NT_STATUS_IS_OK(status)) {
3279                                 continue;
3280                         }
3281                         goto done;
3282                 }
3283
3284                 if (strequal(tok, "kdc")) {
3285                         /* deal with KDC_NAME_TYPE names here.
3286                          * This will result in a SRV record lookup */
3287                         status = resolve_ads(talloc_tos(),
3288                                              name,
3289                                              KDC_NAME_TYPE,
3290                                              sitename,
3291                                              &ss_list,
3292                                              &ret_count);
3293                         if (!NT_STATUS_IS_OK(status)) {
3294                                 continue;
3295                         }
3296                         /* Ensure we don't namecache
3297                          * this with the KDC port. */
3298                         name_type = KDC_NAME_TYPE;
3299                         goto done;
3300                 }
3301
3302                 if (strequal(tok, "ads")) {
3303                         /* deal with 0x1c and 0x1b names here.
3304                          * This will result in a SRV record lookup */
3305                         status = resolve_ads(talloc_tos(),
3306                                              name,
3307                                              name_type,
3308                                              sitename,
3309                                              &ss_list,
3310                                              &ret_count);
3311                         if (!NT_STATUS_IS_OK(status)) {
3312                                 continue;
3313                         }
3314                         goto done;
3315                 }
3316
3317                 if (strequal(tok, "lmhosts")) {
3318                         status = resolve_lmhosts_file_as_sockaddr(
3319                                 talloc_tos(),
3320                                 get_dyn_LMHOSTSFILE(),
3321                                 name,
3322                                 name_type,
3323                                 &ss_list,
3324                                 &ret_count);
3325                         if (!NT_STATUS_IS_OK(status)) {
3326                                 continue;
3327                         }
3328                         goto done;
3329                 }
3330
3331                 if (strequal(tok, "wins")) {
3332                         /* don't resolve 1D via WINS */
3333                         if (name_type == 0x1D) {
3334                                 continue;
3335                         }
3336                         status = resolve_wins(talloc_tos(),
3337                                               name,
3338                                               name_type,
3339                                               &ss_list,
3340                                               &ret_count);
3341                         if (!NT_STATUS_IS_OK(status)) {
3342                                 continue;
3343                         }
3344                         goto done;
3345                 }
3346
3347                 if (strequal(tok, "bcast")) {
3348                         status = name_resolve_bcast(
3349                                                 talloc_tos(),
3350                                                 name,
3351                                                 name_type,
3352                                                 &ss_list,
3353                                                 &ret_count);
3354                         if (!NT_STATUS_IS_OK(status)) {
3355                                 continue;
3356                         }
3357                         goto done;
3358                 }
3359
3360                 DBG_ERR("unknown name switch type %s\n", tok);
3361         }
3362
3363         /* All of the resolve_* functions above have returned false. */
3364
3365         TALLOC_FREE(frame);
3366         *return_count = 0;
3367
3368         return status;
3369
3370   done:
3371
3372         status = sockaddr_array_to_samba_sockaddr_array(frame,
3373                                                         &sa_list,
3374                                                         &ret_count,
3375                                                         ss_list,
3376                                                         ret_count);
3377         if (!NT_STATUS_IS_OK(status)) {
3378                 TALLOC_FREE(frame);
3379                 return NT_STATUS_NO_MEMORY;
3380         }
3381
3382         /* Remove duplicate entries.  Some queries, notably #1c (domain
3383         controllers) return the PDC in iplist[0] and then all domain
3384         controllers including the PDC in iplist[1..n].  Iterating over
3385         the iplist when the PDC is down will cause two sets of timeouts. */
3386
3387         ret_count = remove_duplicate_addrs2(sa_list, ret_count);
3388
3389         /* Save in name cache */
3390         if ( DEBUGLEVEL >= 100 ) {
3391                 for (i = 0; i < ret_count && DEBUGLEVEL == 100; i++) {
3392                         char addr[INET6_ADDRSTRLEN];
3393                         print_sockaddr(addr, sizeof(addr),
3394                                         &sa_list[i].u.ss);
3395                         DEBUG(100, ("Storing name %s of type %d (%s:0)\n",
3396                                         name,
3397                                         name_type,
3398                                         addr));
3399                 }
3400         }
3401
3402         if (ret_count) {
3403                 namecache_store(name,
3404                                 name_type,
3405                                 ret_count,
3406                                 sa_list);
3407         }
3408
3409         /* Display some debugging info */
3410
3411         if ( DEBUGLEVEL >= 10 ) {
3412                 DBG_DEBUG("returning %zu addresses: ",
3413                                 ret_count);
3414
3415                 for (i = 0; i < ret_count; i++) {
3416                         char addr[INET6_ADDRSTRLEN];
3417                         print_sockaddr(addr, sizeof(addr),
3418                                         &sa_list[i].u.ss);
3419                         DEBUGADD(10, ("%s ", addr));
3420                 }
3421                 DEBUG(10, ("\n"));
3422         }
3423
3424         *return_count = ret_count;
3425         *return_salist = talloc_move(ctx, &sa_list);
3426
3427         TALLOC_FREE(frame);
3428         return status;
3429 }
3430
3431 /********************************************************
3432  Internal interface to resolve a name into one IP address.
3433  Use this function if the string is either an IP address, DNS
3434  or host name or NetBIOS name. This uses the name switch in the
3435  smb.conf to determine the order of name resolution.
3436 *********************************************************/
3437
3438 bool resolve_name(const char *name,
3439                 struct sockaddr_storage *return_ss,
3440                 int name_type,
3441                 bool prefer_ipv4)
3442 {
3443         struct samba_sockaddr *sa_list = NULL;
3444         char *sitename = NULL;
3445         size_t count = 0;
3446         NTSTATUS status;
3447         TALLOC_CTX *frame = NULL;
3448
3449         if (is_ipaddress(name)) {
3450                 return interpret_string_addr(return_ss, name, AI_NUMERICHOST);
3451         }
3452
3453         frame = talloc_stackframe();
3454
3455         sitename = sitename_fetch(frame, lp_realm()); /* wild guess */
3456
3457         status = internal_resolve_name(frame,
3458                                         name,
3459                                         name_type,
3460                                         sitename,
3461                                         &sa_list,
3462                                         &count,
3463                                         lp_name_resolve_order());
3464         if (NT_STATUS_IS_OK(status)) {
3465                 size_t i;
3466
3467                 if (prefer_ipv4) {
3468                         for (i=0; i<count; i++) {
3469                                 if (!is_broadcast_addr(&sa_list[i].u.sa) &&
3470                                                 (sa_list[i].u.ss.ss_family == AF_INET)) {
3471                                         *return_ss = sa_list[i].u.ss;
3472                                         TALLOC_FREE(sa_list);
3473                                         TALLOC_FREE(frame);
3474                                         return True;
3475                                 }
3476                         }
3477                 }
3478
3479                 /* only return valid addresses for TCP connections */
3480                 for (i=0; i<count; i++) {
3481                         if (!is_broadcast_addr(&sa_list[i].u.sa)) {
3482                                 *return_ss = sa_list[i].u.ss;
3483                                 TALLOC_FREE(sa_list);
3484                                 TALLOC_FREE(frame);
3485                                 return True;
3486                         }
3487                 }
3488         }
3489
3490         TALLOC_FREE(sa_list);
3491         TALLOC_FREE(frame);
3492         return False;
3493 }
3494
3495 /********************************************************
3496  Internal interface to resolve a name into a list of IP addresses.
3497  Use this function if the string is either an IP address, DNS
3498  or host name or NetBIOS name. This uses the name switch in the
3499  smb.conf to determine the order of name resolution.
3500 *********************************************************/
3501
3502 NTSTATUS resolve_name_list(TALLOC_CTX *ctx,
3503                 const char *name,
3504                 int name_type,
3505                 struct sockaddr_storage **return_ss_arr,
3506                 unsigned int *p_num_entries)
3507 {
3508         struct samba_sockaddr *sa_list = NULL;
3509         char *sitename = NULL;
3510         size_t count = 0;
3511         size_t i;
3512         unsigned int num_entries = 0;
3513         struct sockaddr_storage *result_arr = NULL;
3514         NTSTATUS status;
3515
3516         if (is_ipaddress(name)) {
3517                 result_arr = talloc(ctx, struct sockaddr_storage);
3518                 if (result_arr == NULL) {
3519                         return NT_STATUS_NO_MEMORY;
3520                 }
3521                 if (!interpret_string_addr(result_arr, name, AI_NUMERICHOST)) {
3522                         TALLOC_FREE(result_arr);
3523                         return NT_STATUS_BAD_NETWORK_NAME;
3524                 }
3525                 *p_num_entries = 1;
3526                 *return_ss_arr = result_arr;
3527                 return NT_STATUS_OK;
3528         }
3529
3530         sitename = sitename_fetch(ctx, lp_realm()); /* wild guess */
3531
3532         status = internal_resolve_name(ctx,
3533                                         name,
3534                                         name_type,
3535                                         sitename,
3536                                         &sa_list,
3537                                         &count,
3538                                         lp_name_resolve_order());
3539         TALLOC_FREE(sitename);
3540
3541         if (!NT_STATUS_IS_OK(status)) {
3542                 return status;
3543         }
3544
3545         /* only return valid addresses for TCP connections */
3546         for (i=0, num_entries = 0; i<count; i++) {
3547                 if (!is_zero_addr(&sa_list[i].u.ss) &&
3548                     !is_broadcast_addr(&sa_list[i].u.sa)) {
3549                         num_entries++;
3550                 }
3551         }
3552         if (num_entries == 0) {
3553                 status = NT_STATUS_BAD_NETWORK_NAME;
3554                 goto done;
3555         }
3556
3557         result_arr = talloc_array(ctx,
3558                                 struct sockaddr_storage,
3559                                 num_entries);
3560         if (result_arr == NULL) {
3561                 status = NT_STATUS_NO_MEMORY;
3562                 goto done;
3563         }
3564
3565         for (i=0, num_entries = 0; i<count; i++) {
3566                 if (!is_zero_addr(&sa_list[i].u.ss) &&
3567                     !is_broadcast_addr(&sa_list[i].u.sa)) {
3568                         result_arr[num_entries++] = sa_list[i].u.ss;
3569                 }
3570         }
3571
3572         if (num_entries == 0) {
3573                 TALLOC_FREE(result_arr);
3574                 status = NT_STATUS_BAD_NETWORK_NAME;
3575                 goto done;
3576         }
3577
3578         status = NT_STATUS_OK;
3579         *p_num_entries = num_entries;
3580         *return_ss_arr = result_arr;
3581 done:
3582         TALLOC_FREE(sa_list);
3583         return status;
3584 }
3585
3586 /********************************************************
3587  Find the IP address of the master browser or DMB for a workgroup.
3588 *********************************************************/
3589
3590 bool find_master_ip(const char *group, struct sockaddr_storage *master_ss)
3591 {
3592         struct samba_sockaddr *sa_list = NULL;
3593         size_t count = 0;
3594         NTSTATUS status;
3595
3596         if (lp_disable_netbios()) {
3597                 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group));
3598                 return false;
3599         }
3600
3601         status = internal_resolve_name(talloc_tos(),
3602                                         group,
3603                                         0x1D,
3604                                         NULL,
3605                                         &sa_list,
3606                                         &count,
3607                                         lp_name_resolve_order());
3608         if (NT_STATUS_IS_OK(status)) {
3609                 *master_ss = sa_list[0].u.ss;
3610                 TALLOC_FREE(sa_list);
3611                 return true;
3612         }
3613
3614         TALLOC_FREE(sa_list);
3615
3616         status = internal_resolve_name(talloc_tos(),
3617                                         group,
3618                                         0x1B,
3619                                         NULL,
3620                                         &sa_list,
3621                                         &count,
3622                                         lp_name_resolve_order());
3623         if (NT_STATUS_IS_OK(status)) {
3624                 *master_ss = sa_list[0].u.ss;
3625                 TALLOC_FREE(sa_list);
3626                 return true;
3627         }
3628
3629         TALLOC_FREE(sa_list);
3630         return false;
3631 }
3632
3633 /********************************************************
3634  Get the IP address list of the primary domain controller
3635  for a domain.
3636 *********************************************************/
3637
3638 bool get_pdc_ip(const char *domain, struct sockaddr_storage *pss)
3639 {
3640         struct samba_sockaddr *sa_list = NULL;
3641         size_t count = 0;
3642         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
3643         static const char *ads_order[] = { "ads", NULL };
3644         /* Look up #1B name */
3645
3646         if (lp_security() == SEC_ADS) {
3647                 status = internal_resolve_name(talloc_tos(),
3648                                                 domain,
3649                                                 0x1b,
3650                                                 NULL,
3651                                                 &sa_list,
3652                                                 &count,
3653                                                 ads_order);
3654         }
3655
3656         if (!NT_STATUS_IS_OK(status) || count == 0) {
3657                 TALLOC_FREE(sa_list);
3658                 status = internal_resolve_name(talloc_tos(),
3659                                                 domain,
3660                                                 0x1b,
3661                                                 NULL,
3662                                                 &sa_list,
3663                                                 &count,
3664                                                 lp_name_resolve_order());
3665                 if (!NT_STATUS_IS_OK(status)) {
3666                         TALLOC_FREE(sa_list);
3667                         return false;
3668                 }
3669         }
3670
3671         /* if we get more than 1 IP back we have to assume it is a
3672            multi-homed PDC and not a mess up */
3673
3674         if ( count > 1 ) {
3675                 DBG_INFO("PDC has %zu IP addresses!\n", count);
3676                 sort_sa_list(sa_list, count);
3677         }
3678
3679         *pss = sa_list[0].u.ss;
3680         TALLOC_FREE(sa_list);
3681         return true;
3682 }
3683
3684 /* Private enum type for lookups. */
3685
3686 enum dc_lookup_type { DC_NORMAL_LOOKUP, DC_ADS_ONLY, DC_KDC_ONLY };
3687
3688 /********************************************************
3689  Get the IP address list of the domain controllers for
3690  a domain.
3691 *********************************************************/
3692
3693 static NTSTATUS get_dc_list(TALLOC_CTX *ctx,
3694                         const char *domain,
3695                         const char *sitename,
3696                         struct samba_sockaddr **sa_list_ret,
3697                         size_t *ret_count,
3698                         enum dc_lookup_type lookup_type,
3699                         bool *ordered)
3700 {
3701         const char **resolve_order = NULL;
3702         char *saf_servername = NULL;
3703         char *pserver = NULL;
3704         const char *p;
3705         char *name;
3706         size_t num_addresses = 0;
3707         size_t local_count = 0;
3708         size_t i;
3709         struct samba_sockaddr *auto_sa_list = NULL;
3710         struct samba_sockaddr *return_salist = NULL;
3711         bool done_auto_lookup = false;
3712         size_t auto_count = 0;
3713         NTSTATUS status;
3714         TALLOC_CTX *frame = talloc_stackframe();
3715         int auto_name_type = 0x1C;
3716
3717         *ordered = False;
3718
3719         /* if we are restricted to solely using DNS for looking
3720            up a domain controller, make sure that host lookups
3721            are enabled for the 'name resolve order'.  If host lookups
3722            are disabled and ads_only is True, then set the string to
3723            NULL. */
3724
3725         resolve_order = lp_name_resolve_order();
3726         if (!resolve_order) {
3727                 status = NT_STATUS_NO_MEMORY;
3728                 goto out;
3729         }
3730         if (lookup_type == DC_ADS_ONLY)  {
3731                 if (str_list_check_ci(resolve_order, "host")) {
3732                         static const char *ads_order[] = { "ads", NULL };
3733                         resolve_order = ads_order;
3734
3735                         /* DNS SRV lookups used by the ads resolver
3736                            are already sorted by priority and weight */
3737                         *ordered = true;
3738                 } else {
3739                         /* this is quite bizarre! */
3740                         static const char *null_order[] = { "NULL", NULL };
3741                         resolve_order = null_order;
3742                 }
3743         } else if (lookup_type == DC_KDC_ONLY) {
3744                 static const char *kdc_order[] = { "kdc", NULL };
3745                 /* DNS SRV lookups used by the ads/kdc resolver
3746                    are already sorted by priority and weight */
3747                 *ordered = true;
3748                 resolve_order = kdc_order;
3749                 auto_name_type = KDC_NAME_TYPE;
3750         }
3751
3752         /* fetch the server we have affinity for.  Add the
3753            'password server' list to a search for our domain controllers */
3754
3755         saf_servername = saf_fetch(frame, domain);
3756
3757         if (strequal(domain, lp_workgroup()) || strequal(domain, lp_realm())) {
3758                 pserver = talloc_asprintf(frame, "%s, %s",
3759                         saf_servername ? saf_servername : "",
3760                         lp_password_server());
3761         } else {
3762                 pserver = talloc_asprintf(frame, "%s, *",
3763                         saf_servername ? saf_servername : "");
3764         }
3765
3766         TALLOC_FREE(saf_servername);
3767         if (!pserver) {
3768                 status = NT_STATUS_NO_MEMORY;
3769                 goto out;
3770         }
3771
3772         DEBUG(3,("get_dc_list: preferred server list: \"%s\"\n", pserver ));
3773
3774         /*
3775          * if '*' appears in the "password server" list then add
3776          * an auto lookup to the list of manually configured
3777          * DC's.  If any DC is listed by name, then the list should be
3778          * considered to be ordered
3779          */
3780
3781         p = pserver;
3782         while (next_token_talloc(frame, &p, &name, LIST_SEP)) {
3783                 if (!done_auto_lookup && strequal(name, "*")) {
3784                         done_auto_lookup = true;
3785
3786                         status = internal_resolve_name(frame,
3787                                                         domain,
3788                                                         auto_name_type,
3789                                                         sitename,
3790                                                         &auto_sa_list,
3791                                                         &auto_count,
3792                                                         resolve_order);
3793                         if (!NT_STATUS_IS_OK(status)) {
3794                                 continue;
3795                         }
3796                         /* Wrap check. */
3797                         if (num_addresses + auto_count < num_addresses) {
3798                                 TALLOC_FREE(auto_sa_list);
3799                                 status = NT_STATUS_INVALID_PARAMETER;
3800                                 goto out;
3801                         }
3802                         num_addresses += auto_count;
3803                         DBG_DEBUG("Adding %zu DC's from auto lookup\n",
3804                                                 auto_count);
3805                 } else  {
3806                         /* Wrap check. */
3807                         if (num_addresses + 1 < num_addresses) {
3808                                 TALLOC_FREE(auto_sa_list);
3809                                 status = NT_STATUS_INVALID_PARAMETER;
3810                                 goto out;
3811                         }
3812                         num_addresses++;
3813                 }
3814         }
3815
3816         /* if we have no addresses and haven't done the auto lookup, then
3817            just return the list of DC's.  Or maybe we just failed. */
3818
3819         if (num_addresses == 0) {
3820                 struct samba_sockaddr *dc_salist = NULL;
3821                 size_t dc_count = 0;
3822
3823                 if (done_auto_lookup) {
3824                         DEBUG(4,("get_dc_list: no servers found\n"));
3825                         status = NT_STATUS_NO_LOGON_SERVERS;
3826                         goto out;
3827                 }
3828                 /* talloc off frame, only move to ctx on success. */
3829                 status = internal_resolve_name(frame,
3830                                                 domain,
3831                                                 auto_name_type,
3832                                                 sitename,
3833                                                 &dc_salist,
3834                                                 &dc_count,
3835                                                 resolve_order);
3836                 if (!NT_STATUS_IS_OK(status)) {
3837                         goto out;
3838                 }
3839                 return_salist = dc_salist;
3840                 local_count = dc_count;
3841                 goto out;
3842         }
3843
3844         return_salist = talloc_zero_array(frame,
3845                                         struct samba_sockaddr,
3846                                         num_addresses);
3847         if (return_salist == NULL) {
3848                 DEBUG(3,("get_dc_list: malloc fail !\n"));
3849                 status = NT_STATUS_NO_MEMORY;
3850                 goto out;
3851         }
3852
3853         p = pserver;
3854         local_count = 0;
3855
3856         /* fill in the return list now with real IP's */
3857
3858         while ((local_count<num_addresses) &&
3859                         next_token_talloc(frame, &p, &name, LIST_SEP)) {
3860                 struct samba_sockaddr name_sa = {0};
3861
3862                 /* copy any addresses from the auto lookup */
3863
3864                 if (strequal(name, "*")) {
3865                         size_t j;
3866                         for (j=0; j<auto_count; j++) {
3867                                 char addr[INET6_ADDRSTRLEN];
3868                                 print_sockaddr(addr,
3869                                                 sizeof(addr),
3870                                                 &auto_sa_list[j].u.ss);
3871                                 /* Check for and don't copy any
3872                                  * known bad DC IP's. */
3873                                 if(!NT_STATUS_IS_OK(check_negative_conn_cache(
3874                                                 domain,
3875                                                 addr))) {
3876                                         DEBUG(5,("get_dc_list: "
3877                                                 "negative entry %s removed "
3878                                                 "from DC list\n",
3879                                                 addr));
3880                                         continue;
3881                                 }
3882                                 return_salist[local_count] = auto_sa_list[j];
3883                                 local_count++;
3884                         }
3885                         continue;
3886                 }
3887
3888                 /* explicit lookup; resolve_name() will
3889                  * handle names & IP addresses */
3890                 if (resolve_name(name, &name_sa.u.ss, 0x20, true)) {
3891                         char addr[INET6_ADDRSTRLEN];
3892                         bool ok;
3893
3894                         /*
3895                          * Ensure we set sa_socklen correctly.
3896                          * Doesn't matter now, but eventually we
3897                          * will remove ip_service and return samba_sockaddr
3898                          * arrays directly.
3899                          */
3900                         ok = sockaddr_storage_to_samba_sockaddr(
3901                                         &name_sa,
3902                                         &name_sa.u.ss);
3903                         if (!ok) {
3904                                 status = NT_STATUS_INVALID_ADDRESS;
3905                                 goto out;
3906                         }
3907
3908                         print_sockaddr(addr,
3909                                         sizeof(addr),
3910                                         &name_sa.u.ss);
3911
3912                         /* Check for and don't copy any known bad DC IP's. */
3913                         if( !NT_STATUS_IS_OK(check_negative_conn_cache(domain,
3914                                                         addr)) ) {
3915                                 DEBUG(5,("get_dc_list: negative entry %s "
3916                                         "removed from DC list\n",
3917                                         name ));
3918                                 continue;
3919                         }
3920
3921                         return_salist[local_count] = name_sa;
3922                         local_count++;
3923                         *ordered = true;
3924                 }
3925         }
3926
3927         /* need to remove duplicates in the list if we have any
3928            explicit password servers */
3929
3930         local_count = remove_duplicate_addrs2(return_salist, local_count );
3931
3932         /* For DC's we always prioritize IPv4 due to W2K3 not
3933          * supporting LDAP, KRB5 or CLDAP over IPv6. */
3934
3935         if (local_count && return_salist != NULL) {
3936                 prioritize_ipv4_list(return_salist, local_count);
3937         }
3938
3939         if ( DEBUGLEVEL >= 4 ) {
3940                 DEBUG(4,("get_dc_list: returning %zu ip addresses "
3941                                 "in an %sordered list\n",
3942                                 local_count,
3943                                 *ordered ? "":"un"));
3944                 DEBUG(4,("get_dc_list: "));
3945                 for ( i=0; i<local_count; i++ ) {
3946                         char addr[INET6_ADDRSTRLEN];
3947                         print_sockaddr(addr,
3948                                         sizeof(addr),
3949                                         &return_salist[i].u.ss);
3950                         DEBUGADD(4,("%s ", addr));
3951                 }
3952                 DEBUGADD(4,("\n"));
3953         }
3954
3955         status = (local_count != 0 ? NT_STATUS_OK : NT_STATUS_NO_LOGON_SERVERS);
3956
3957   out:
3958
3959         if (NT_STATUS_IS_OK(status)) {
3960                 *sa_list_ret = talloc_move(ctx, &return_salist);
3961                 *ret_count = local_count;
3962         }
3963         TALLOC_FREE(return_salist);
3964         TALLOC_FREE(auto_sa_list);
3965         TALLOC_FREE(frame);
3966         return status;
3967 }
3968
3969 /*********************************************************************
3970  Small wrapper function to get the DC list and sort it if neccessary.
3971  Returns a samba_sockaddr array.
3972 *********************************************************************/
3973
3974 NTSTATUS get_sorted_dc_list(TALLOC_CTX *ctx,
3975                                 const char *domain,
3976                                 const char *sitename,
3977                                 struct samba_sockaddr **sa_list_ret,
3978                                 size_t *ret_count,
3979                                 bool ads_only)
3980 {
3981         bool ordered = false;
3982         NTSTATUS status;
3983         enum dc_lookup_type lookup_type = DC_NORMAL_LOOKUP;
3984         struct samba_sockaddr *sa_list = NULL;
3985         size_t count = 0;
3986
3987         DBG_INFO("attempting lookup for name %s (sitename %s)\n",
3988                 domain,
3989                 sitename ? sitename : "NULL");
3990
3991         if (ads_only) {
3992                 lookup_type = DC_ADS_ONLY;
3993         }
3994
3995         status = get_dc_list(ctx,
3996                         domain,
3997                         sitename,
3998                         &sa_list,
3999                         &count,
4000                         lookup_type,
4001                         &ordered);
4002         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_LOGON_SERVERS)
4003                         && sitename) {
4004                 DBG_NOTICE("no server for name %s available"
4005                         " in site %s, fallback to all servers\n",
4006                         domain,
4007                         sitename);
4008                 status = get_dc_list(ctx,
4009                                 domain,
4010                                 NULL,
4011                                 &sa_list,
4012                                 &count,
4013                                 lookup_type,
4014                                 &ordered);
4015         }
4016
4017         if (!NT_STATUS_IS_OK(status)) {
4018                 return status;
4019         }
4020
4021         /* only sort if we don't already have an ordered list */
4022         if (!ordered) {
4023                 sort_sa_list(sa_list, count);
4024         }
4025
4026         *ret_count = count;
4027         *sa_list_ret = sa_list;
4028         return status;
4029 }
4030
4031 /*********************************************************************
4032  Get the KDC list - re-use all the logic in get_dc_list.
4033  Returns a samba_sockaddr array.
4034 *********************************************************************/
4035
4036 NTSTATUS get_kdc_list(TALLOC_CTX *ctx,
4037                         const char *realm,
4038                         const char *sitename,
4039                         struct samba_sockaddr **sa_list_ret,
4040                         size_t *ret_count)
4041 {
4042         size_t count = 0;
4043         struct samba_sockaddr *sa_list = NULL;
4044         bool ordered = false;
4045         NTSTATUS status;
4046
4047         status = get_dc_list(ctx,
4048                         realm,
4049                         sitename,
4050                         &sa_list,
4051                         &count,
4052                         DC_KDC_ONLY,
4053                         &ordered);
4054
4055         if (!NT_STATUS_IS_OK(status)) {
4056                 return status;
4057         }
4058
4059         /* only sort if we don't already have an ordered list */
4060         if (!ordered ) {
4061                 sort_sa_list(sa_list, count);
4062         }
4063
4064         *ret_count = count;
4065         *sa_list_ret = sa_list;
4066         return status;
4067 }