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