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 static bool name_status_lmhosts(const struct sockaddr_storage *paddr,
 920                                 int qname_type, fstring pname)
 921 {
 922         FILE *f;
 923         char *name;
 924         int name_type;
 925         struct sockaddr_storage addr;
 926
 927         if (paddr->ss_family != AF_INET) {
 928                 return false;
 929         }
 930
 931         f = startlmhosts(get_dyn_LMHOSTSFILE());
 932         if (f == NULL) {
 933                 return false;
 934         }
 935
 936         while (getlmhostsent(talloc_tos(), f, &name, &name_type, &addr)) {
 937                 if (addr.ss_family != AF_INET) {
 938                         continue;
 939                 }
 940                 if (name_type != qname_type) {
 941                         continue;
 942                 }
 943                 if (memcmp(&((const struct sockaddr_in *)paddr)->sin_addr,
 944                            &((const struct sockaddr_in *)&addr)->sin_addr,
 945                            sizeof(struct in_addr)) == 0) {
 946                         fstrcpy(pname, name);
 947                         endlmhosts(f);
 948                         return true;
 949                 }
 950         }
 951         endlmhosts(f);
 952         return false;
 953 }
 954
 955 /****************************************************************************
 956  Find the first type XX name in a node status reply - used for finding
 957  a servers name given its IP. Return the matched name in *name.
 958 **************************************************************************/
 959
 960 bool name_status_find(const char *q_name,
 961                         int q_type,
 962                         int type,
 963                         const struct sockaddr_storage *to_ss,
 964                         fstring name)
 965 {
 966         char addr[INET6_ADDRSTRLEN];
 967         struct sockaddr_storage ss;
 968         struct node_status *addrs = NULL;
 969         struct nmb_name nname;
 970         int count, i;
 971         bool result = false;
 972         NTSTATUS status;
 973
 974         if (lp_disable_netbios()) {
 975                 DEBUG(5,("name_status_find(%s#%02x): netbios is disabled\n",
 976                                         q_name, q_type));
 977                 return False;
 978         }
 979
 980         print_sockaddr(addr, sizeof(addr), to_ss);
 981
 982         DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name,
 983                    q_type, addr));
 984
 985         /* Check the cache first. */
 986
 987         if (namecache_status_fetch(q_name, q_type, type, to_ss, name)) {
 988                 return True;
 989         }
 990
 991         if (to_ss->ss_family != AF_INET) {
 992                 /* Can't do node status to IPv6 */
 993                 return false;
 994         }
 995
 996         result = name_status_lmhosts(to_ss, type, name);
 997         if (result) {
 998                 DBG_DEBUG("Found name %s in lmhosts\n", name);
 999                 namecache_status_store(q_name, q_type, type, to_ss, name);
1000                 return true;
1001         }
1002
1003         set_socket_addr_v4(&ss);
1004
1005         /* W2K PDC's seem not to respond to '*'#0. JRA */
1006         make_nmb_name(&nname, q_name, q_type);
1007         status = node_status_query(talloc_tos(), &nname, to_ss,
1008                                    &addrs, &count, NULL);
1009         if (!NT_STATUS_IS_OK(status)) {
1010                 goto done;
1011         }
1012
1013         for (i=0;i<count;i++) {
1014                 /* Find first one of the requested type that's not a GROUP. */
1015                 if (addrs[i].type == type && ! (addrs[i].flags & 0x80))
1016                         break;
1017         }
1018         if (i == count)
1019                 goto done;
1020
1021         pull_ascii_nstring(name, sizeof(fstring), addrs[i].name);
1022
1023         /* Store the result in the cache. */
1024         /* but don't store an entry for 0x1c names here.  Here we have
1025            a single host and DOMAIN<0x1c> names should be a list of hosts */
1026
1027         if ( q_type != 0x1c ) {
1028                 namecache_status_store(q_name, q_type, type, to_ss, name);
1029         }
1030
1031         result = true;
1032
1033  done:
1034         TALLOC_FREE(addrs);
1035
1036         DEBUG(10, ("name_status_find: name %sfound", result ? "" : "not "));
1037
1038         if (result)
1039                 DEBUGADD(10, (", name %s ip address is %s", name, addr));
1040
1041         DEBUG(10, ("\n"));
1042
1043         return result;
1044 }
1045
1046 /*
1047   comparison function used by sort_addr_list
1048 */
1049
1050 static int addr_compare(const struct sockaddr_storage *ss1,
1051                         const struct sockaddr_storage *ss2)
1052 {
1053         int max_bits1=0, max_bits2=0;
1054         int num_interfaces = iface_count();
1055         int i;
1056
1057         /* Sort IPv4 addresses first. */
1058         if (ss1->ss_family != ss2->ss_family) {
1059                 if (ss2->ss_family == AF_INET) {
1060                         return 1;
1061                 } else {
1062                         return -1;
1063                 }
1064         }
1065
1066         /* Here we know both addresses are of the same
1067          * family. */
1068
1069         for (i=0;i<num_interfaces;i++) {
1070                 const struct sockaddr_storage *pss = iface_n_bcast(i);
1071                 const unsigned char *p_ss1 = NULL;
1072                 const unsigned char *p_ss2 = NULL;
1073                 const unsigned char *p_if = NULL;
1074                 size_t len = 0;
1075                 int bits1, bits2;
1076
1077                 if (pss->ss_family != ss1->ss_family) {
1078                         /* Ignore interfaces of the wrong type. */
1079                         continue;
1080                 }
1081                 if (pss->ss_family == AF_INET) {
1082                         p_if = (const unsigned char *)
1083                                 &((const struct sockaddr_in *)pss)->sin_addr;
1084                         p_ss1 = (const unsigned char *)
1085                                 &((const struct sockaddr_in *)ss1)->sin_addr;
1086                         p_ss2 = (const unsigned char *)
1087                                 &((const struct sockaddr_in *)ss2)->sin_addr;
1088                         len = 4;
1089                 }
1090 #if defined(HAVE_IPV6)
1091                 if (pss->ss_family == AF_INET6) {
1092                         p_if = (const unsigned char *)
1093                                 &((const struct sockaddr_in6 *)pss)->sin6_addr;
1094                         p_ss1 = (const unsigned char *)
1095                                 &((const struct sockaddr_in6 *)ss1)->sin6_addr;
1096                         p_ss2 = (const unsigned char *)
1097                                 &((const struct sockaddr_in6 *)ss2)->sin6_addr;
1098                         len = 16;
1099                 }
1100 #endif
1101                 if (!p_ss1 || !p_ss2 || !p_if || len == 0) {
1102                         continue;
1103                 }
1104                 bits1 = matching_len_bits(p_ss1, p_if, len);
1105                 bits2 = matching_len_bits(p_ss2, p_if, len);
1106                 max_bits1 = MAX(bits1, max_bits1);
1107                 max_bits2 = MAX(bits2, max_bits2);
1108         }
1109
1110         /* Bias towards directly reachable IPs */
1111         if (iface_local((const struct sockaddr *)ss1)) {
1112                 if (ss1->ss_family == AF_INET) {
1113                         max_bits1 += 32;
1114                 } else {
1115                         max_bits1 += 128;
1116                 }
1117         }
1118         if (iface_local((const struct sockaddr *)ss2)) {
1119                 if (ss2->ss_family == AF_INET) {
1120                         max_bits2 += 32;
1121                 } else {
1122                         max_bits2 += 128;
1123                 }
1124         }
1125         return max_bits2 - max_bits1;
1126 }
1127
1128 /*******************************************************************
1129  compare 2 ldap IPs by nearness to our interfaces - used in qsort
1130 *******************************************************************/
1131
1132 static int ip_service_compare(struct ip_service *ss1, struct ip_service *ss2)
1133 {
1134         int result;
1135
1136         if ((result = addr_compare(&ss1->ss, &ss2->ss)) != 0) {
1137                 return result;
1138         }
1139
1140         if (ss1->port > ss2->port) {
1141                 return 1;
1142         }
1143
1144         if (ss1->port < ss2->port) {
1145                 return -1;
1146         }
1147
1148         return 0;
1149 }
1150
1151 /*
1152   sort an IP list so that names that are close to one of our interfaces
1153   are at the top. This prevents the problem where a WINS server returns an IP
1154   that is not reachable from our subnet as the first match
1155 */
1156
1157 static void sort_addr_list(struct sockaddr_storage *sslist, int count)
1158 {
1159         if (count <= 1) {
1160                 return;
1161         }
1162
1163         TYPESAFE_QSORT(sslist, count, addr_compare);
1164 }
1165
1166 static void sort_service_list(struct ip_service *servlist, int count)
1167 {
1168         if (count <= 1) {
1169                 return;
1170         }
1171
1172         TYPESAFE_QSORT(servlist, count, ip_service_compare);
1173 }
1174
1175 /**********************************************************************
1176  Remove any duplicate address/port pairs in the list
1177  *********************************************************************/
1178
1179 int remove_duplicate_addrs2(struct ip_service *iplist, int count )
1180 {
1181         int i, j;
1182
1183         DEBUG(10,("remove_duplicate_addrs2: "
1184                         "looking for duplicate address/port pairs\n"));
1185
1186         /* One loop to set duplicates to a zero addr. */
1187         for ( i=0; i<count; i++ ) {
1188                 if ( is_zero_addr(&iplist[i].ss)) {
1189                         continue;
1190                 }
1191
1192                 for ( j=i+1; j<count; j++ ) {
1193                         if (sockaddr_equal((struct sockaddr *)(void *)&iplist[i].ss,
1194                                            (struct sockaddr *)(void *)&iplist[j].ss) &&
1195                                         iplist[i].port == iplist[j].port) {
1196                                 zero_sockaddr(&iplist[j].ss);
1197                         }
1198                 }
1199         }
1200
1201         /* Now remove any addresses set to zero above. */
1202         for (i = 0; i < count; i++) {
1203                 while (i < count &&
1204                                 is_zero_addr(&iplist[i].ss)) {
1205                         if (count-i-1>0) {
1206                                 memmove(&iplist[i],
1207                                         &iplist[i+1],
1208                                         (count-i-1)*sizeof(struct ip_service));
1209                         }
1210                         count--;
1211                 }
1212         }
1213
1214         return count;
1215 }
1216
1217 static bool prioritize_ipv4_list(struct ip_service *iplist, int count)
1218 {
1219         TALLOC_CTX *frame = talloc_stackframe();
1220         struct ip_service *iplist_new = talloc_array(frame, struct ip_service, count);
1221         int i, j;
1222
1223         if (iplist_new == NULL) {
1224                 TALLOC_FREE(frame);
1225                 return false;
1226         }
1227
1228         j = 0;
1229
1230         /* Copy IPv4 first. */
1231         for (i = 0; i < count; i++) {
1232                 if (iplist[i].ss.ss_family == AF_INET) {
1233                         iplist_new[j++] = iplist[i];
1234                 }
1235         }
1236
1237         /* Copy IPv6. */
1238         for (i = 0; i < count; i++) {
1239                 if (iplist[i].ss.ss_family != AF_INET) {
1240                         iplist_new[j++] = iplist[i];
1241                 }
1242         }
1243
1244         memcpy(iplist, iplist_new, sizeof(struct ip_service)*count);
1245         TALLOC_FREE(frame);
1246         return true;
1247 }
1248
1249 /****************************************************************************
1250  Do a netbios name query to find someones IP.
1251  Returns an array of IP addresses or NULL if none.
1252  *count will be set to the number of addresses returned.
1253  *timed_out is set if we failed by timing out
1254 ****************************************************************************/
1255
1256 struct name_query_state {
1257         struct sockaddr_storage my_addr;
1258         struct sockaddr_storage addr;
1259         bool bcast;
1260
1261
1262         uint8_t buf[1024];
1263         ssize_t buflen;
1264
1265         NTSTATUS validate_error;
1266         uint8_t flags;
1267
1268         struct sockaddr_storage *addrs;
1269         int num_addrs;
1270 };
1271
1272 static bool name_query_validator(struct packet_struct *p, void *private_data);
1273 static void name_query_done(struct tevent_req *subreq);
1274
1275 struct tevent_req *name_query_send(TALLOC_CTX *mem_ctx,
1276                                    struct tevent_context *ev,
1277                                    const char *name, int name_type,
1278                                    bool bcast, bool recurse,
1279                                    const struct sockaddr_storage *addr)
1280 {
1281         struct tevent_req *req, *subreq;
1282         struct name_query_state *state;
1283         struct packet_struct p;
1284         struct nmb_packet *nmb = &p.packet.nmb;
1285         struct sockaddr_in *in_addr;
1286
1287         req = tevent_req_create(mem_ctx, &state, struct name_query_state);
1288         if (req == NULL) {
1289                 return NULL;
1290         }
1291         state->bcast = bcast;
1292
1293         if (addr->ss_family != AF_INET) {
1294                 /* Can't do node status to IPv6 */
1295                 tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
1296                 return tevent_req_post(req, ev);
1297         }
1298
1299         if (lp_disable_netbios()) {
1300                 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n",
1301                                         name, name_type));
1302                 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
1303                 return tevent_req_post(req, ev);
1304         }
1305
1306         state->addr = *addr;
1307         in_addr = (struct sockaddr_in *)(void *)&state->addr;
1308         in_addr->sin_port = htons(NMB_PORT);
1309
1310         set_socket_addr_v4(&state->my_addr);
1311
1312         ZERO_STRUCT(p);
1313         nmb->header.name_trn_id = generate_trn_id();
1314         nmb->header.opcode = 0;
1315         nmb->header.response = false;
1316         nmb->header.nm_flags.bcast = bcast;
1317         nmb->header.nm_flags.recursion_available = false;
1318         nmb->header.nm_flags.recursion_desired = recurse;
1319         nmb->header.nm_flags.trunc = false;
1320         nmb->header.nm_flags.authoritative = false;
1321         nmb->header.rcode = 0;
1322         nmb->header.qdcount = 1;
1323         nmb->header.ancount = 0;
1324         nmb->header.nscount = 0;
1325         nmb->header.arcount = 0;
1326
1327         make_nmb_name(&nmb->question.question_name,name,name_type);
1328
1329         nmb->question.question_type = 0x20;
1330         nmb->question.question_class = 0x1;
1331
1332         state->buflen = build_packet((char *)state->buf, sizeof(state->buf),
1333                                      &p);
1334         if (state->buflen == 0) {
1335                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1336                 DEBUG(10, ("build_packet failed\n"));
1337                 return tevent_req_post(req, ev);
1338         }
1339
1340         subreq = nb_trans_send(state, ev, &state->my_addr, &state->addr, bcast,
1341                                state->buf, state->buflen,
1342                                NMB_PACKET, nmb->header.name_trn_id,
1343                                name_query_validator, state);
1344         if (tevent_req_nomem(subreq, req)) {
1345                 DEBUG(10, ("nb_trans_send failed\n"));
1346                 return tevent_req_post(req, ev);
1347         }
1348         tevent_req_set_callback(subreq, name_query_done, req);
1349         return req;
1350 }
1351
1352 static bool name_query_validator(struct packet_struct *p, void *private_data)
1353 {
1354         struct name_query_state *state = talloc_get_type_abort(
1355                 private_data, struct name_query_state);
1356         struct nmb_packet *nmb = &p->packet.nmb;
1357         struct sockaddr_storage *tmp_addrs;
1358         bool got_unique_netbios_name = false;
1359         int i;
1360
1361         debug_nmb_packet(p);
1362
1363         /*
1364          * If we get a Negative Name Query Response from a WINS
1365          * server, we should report it and give up.
1366          */
1367         if( 0 == nmb->header.opcode     /* A query response   */
1368             && !state->bcast            /* from a WINS server */
1369             && nmb->header.rcode        /* Error returned     */
1370                 ) {
1371
1372                 if( DEBUGLVL( 3 ) ) {
1373                         /* Only executed if DEBUGLEVEL >= 3 */
1374                         dbgtext( "Negative name query "
1375                                  "response, rcode 0x%02x: ",
1376                                  nmb->header.rcode );
1377                         switch( nmb->header.rcode ) {
1378                         case 0x01:
1379                                 dbgtext("Request was invalidly formatted.\n");
1380                                 break;
1381                         case 0x02:
1382                                 dbgtext("Problem with NBNS, cannot process "
1383                                         "name.\n");
1384                                 break;
1385                         case 0x03:
1386                                 dbgtext("The name requested does not "
1387                                         "exist.\n");
1388                                 break;
1389                         case 0x04:
1390                                 dbgtext("Unsupported request error.\n");
1391                                 break;
1392                         case 0x05:
1393                                 dbgtext("Query refused error.\n");
1394                                 break;
1395                         default:
1396                                 dbgtext("Unrecognized error code.\n" );
1397                                 break;
1398                         }
1399                 }
1400
1401                 /*
1402                  * We accept this packet as valid, but tell the upper
1403                  * layers that it's a negative response.
1404                  */
1405                 state->validate_error = NT_STATUS_NOT_FOUND;
1406                 return true;
1407         }
1408
1409         if (nmb->header.opcode != 0 ||
1410             nmb->header.nm_flags.bcast ||
1411             nmb->header.rcode ||
1412             !nmb->header.ancount) {
1413                 /*
1414                  * XXXX what do we do with this? Could be a redirect,
1415                  * but we'll discard it for the moment.
1416                  */
1417                 return false;
1418         }
1419
1420         tmp_addrs = talloc_realloc(
1421                 state, state->addrs, struct sockaddr_storage,
1422                 state->num_addrs + nmb->answers->rdlength/6);
1423         if (tmp_addrs == NULL) {
1424                 state->validate_error = NT_STATUS_NO_MEMORY;
1425                 return true;
1426         }
1427         state->addrs = tmp_addrs;
1428
1429         DEBUG(2,("Got a positive name query response "
1430                  "from %s ( ", inet_ntoa(p->ip)));
1431
1432         for (i=0; i<nmb->answers->rdlength/6; i++) {
1433                 uint16_t flags;
1434                 struct in_addr ip;
1435                 struct sockaddr_storage addr;
1436                 int j;
1437
1438                 flags = RSVAL(&nmb->answers->rdata[i*6], 0);
1439                 got_unique_netbios_name |= ((flags & 0x8000) == 0);
1440
1441                 putip((char *)&ip,&nmb->answers->rdata[2+i*6]);
1442                 in_addr_to_sockaddr_storage(&addr, ip);
1443
1444                 if (is_zero_addr(&addr)) {
1445                         continue;
1446                 }
1447
1448                 for (j=0; j<state->num_addrs; j++) {
1449                         if (sockaddr_equal(
1450                                     (struct sockaddr *)(void *)&addr,
1451                                     (struct sockaddr *)(void *)&state->addrs[j])) {
1452                                 break;
1453                         }
1454                 }
1455                 if (j < state->num_addrs) {
1456                         /* Already got it */
1457                         continue;
1458                 }
1459
1460                 DEBUGADD(2,("%s ",inet_ntoa(ip)));
1461
1462                 state->addrs[state->num_addrs] = addr;
1463                 state->num_addrs += 1;
1464         }
1465         DEBUGADD(2,(")\n"));
1466
1467         /* We add the flags back ... */
1468         if (nmb->header.response)
1469                 state->flags |= NM_FLAGS_RS;
1470         if (nmb->header.nm_flags.authoritative)
1471                 state->flags |= NM_FLAGS_AA;
1472         if (nmb->header.nm_flags.trunc)
1473                 state->flags |= NM_FLAGS_TC;
1474         if (nmb->header.nm_flags.recursion_desired)
1475                 state->flags |= NM_FLAGS_RD;
1476         if (nmb->header.nm_flags.recursion_available)
1477                 state->flags |= NM_FLAGS_RA;
1478         if (nmb->header.nm_flags.bcast)
1479                 state->flags |= NM_FLAGS_B;
1480
1481         if (state->bcast) {
1482                 /*
1483                  * We have to collect all entries coming in from broadcast
1484                  * queries. If we got a unique name, we're done.
1485                  */
1486                 return got_unique_netbios_name;
1487         }
1488         /*
1489          * WINS responses are accepted when they are received
1490          */
1491         return true;
1492 }
1493
1494 static void name_query_done(struct tevent_req *subreq)
1495 {
1496         struct tevent_req *req = tevent_req_callback_data(
1497                 subreq, struct tevent_req);
1498         struct name_query_state *state = tevent_req_data(
1499                 req, struct name_query_state);
1500         NTSTATUS status;
1501         struct packet_struct *p = NULL;
1502
1503         status = nb_trans_recv(subreq, &p);
1504         TALLOC_FREE(subreq);
1505         if (tevent_req_nterror(req, status)) {
1506                 return;
1507         }
1508         if (!NT_STATUS_IS_OK(state->validate_error)) {
1509                 tevent_req_nterror(req, state->validate_error);
1510                 return;
1511         }
1512         if (p != NULL) {
1513                 /*
1514                  * Free the packet here, we've collected the response in the
1515                  * validator
1516                  */
1517                 free_packet(p);
1518         }
1519         tevent_req_done(req);
1520 }
1521
1522 NTSTATUS name_query_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1523                          struct sockaddr_storage **addrs, int *num_addrs,
1524                          uint8_t *flags)
1525 {
1526         struct name_query_state *state = tevent_req_data(
1527                 req, struct name_query_state);
1528         NTSTATUS status;
1529
1530         if (tevent_req_is_nterror(req, &status)) {
1531                 if (state->bcast &&
1532                     NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
1533                         /*
1534                          * In the broadcast case we collect replies until the
1535                          * timeout.
1536                          */
1537                         status = NT_STATUS_OK;
1538                 }
1539                 if (!NT_STATUS_IS_OK(status)) {
1540                         return status;
1541                 }
1542         }
1543         if (state->num_addrs == 0) {
1544                 return NT_STATUS_NOT_FOUND;
1545         }
1546         *addrs = talloc_move(mem_ctx, &state->addrs);
1547         sort_addr_list(*addrs, state->num_addrs);
1548         *num_addrs = state->num_addrs;
1549         if (flags != NULL) {
1550                 *flags = state->flags;
1551         }
1552         return NT_STATUS_OK;
1553 }
1554
1555 NTSTATUS name_query(const char *name, int name_type,
1556                     bool bcast, bool recurse,
1557                     const struct sockaddr_storage *to_ss,
1558                     TALLOC_CTX *mem_ctx,
1559                     struct sockaddr_storage **addrs,
1560                     int *num_addrs, uint8_t *flags)
1561 {
1562         TALLOC_CTX *frame = talloc_stackframe();
1563         struct tevent_context *ev;
1564         struct tevent_req *req;
1565         struct timeval timeout;
1566         NTSTATUS status = NT_STATUS_NO_MEMORY;
1567
1568         ev = samba_tevent_context_init(frame);
1569         if (ev == NULL) {
1570                 goto fail;
1571         }
1572         req = name_query_send(ev, ev, name, name_type, bcast, recurse, to_ss);
1573         if (req == NULL) {
1574                 goto fail;
1575         }
1576         if (bcast) {
1577                 timeout = timeval_current_ofs(0, 250000);
1578         } else {
1579                 timeout = timeval_current_ofs(2, 0);
1580         }
1581         if (!tevent_req_set_endtime(req, ev, timeout)) {
1582                 goto fail;
1583         }
1584         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1585                 goto fail;
1586         }
1587         status = name_query_recv(req, mem_ctx, addrs, num_addrs, flags);
1588  fail:
1589         TALLOC_FREE(frame);
1590         return status;
1591 }
1592
1593 /********************************************************
1594  Convert an array if struct sockaddr_storage to struct ip_service
1595  return false on failure.  Port is set to PORT_NONE;
1596  pcount is [in/out] - it is the length of ss_list on input,
1597  and the length of return_iplist on output as we remove any
1598  zero addresses from ss_list.
1599 *********************************************************/
1600
1601 static bool convert_ss2service(struct ip_service **return_iplist,
1602                 const struct sockaddr_storage *ss_list,
1603                 int *pcount)
1604 {
1605         int i;
1606         int orig_count = *pcount;
1607         int real_count = 0;
1608
1609         if (orig_count==0 || !ss_list )
1610                 return False;
1611
1612         /* Filter out zero addrs. */
1613         for ( i=0; i<orig_count; i++ ) {
1614                 if (is_zero_addr(&ss_list[i])) {
1615                         continue;
1616                 }
1617                 real_count++;
1618         }
1619         if (real_count==0) {
1620                 return false;
1621         }
1622
1623         /* copy the ip address; port will be PORT_NONE */
1624         if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, real_count)) ==
1625                         NULL) {
1626                 DEBUG(0,("convert_ip2service: malloc failed "
1627                         "for %d enetries!\n", real_count ));
1628                 return False;
1629         }
1630
1631         for ( i=0, real_count = 0; i<orig_count; i++ ) {
1632                 if (is_zero_addr(&ss_list[i])) {
1633                         continue;
1634                 }
1635                 (*return_iplist)[real_count].ss   = ss_list[i];
1636                 (*return_iplist)[real_count].port = PORT_NONE;
1637                 real_count++;
1638         }
1639
1640         *pcount = real_count;
1641         return true;
1642 }
1643
1644 struct name_queries_state {
1645         struct tevent_context *ev;
1646         const char *name;
1647         int name_type;
1648         bool bcast;
1649         bool recurse;
1650         const struct sockaddr_storage *addrs;
1651         int num_addrs;
1652         int wait_msec;
1653         int timeout_msec;
1654
1655         struct tevent_req **subreqs;
1656         int num_received;
1657         int num_sent;
1658
1659         int received_index;
1660         struct sockaddr_storage *result_addrs;
1661         int num_result_addrs;
1662         uint8_t flags;
1663 };
1664
1665 static void name_queries_done(struct tevent_req *subreq);
1666 static void name_queries_next(struct tevent_req *subreq);
1667
1668 /*
1669  * Send a name query to multiple destinations with a wait time in between
1670  */
1671
1672 static struct tevent_req *name_queries_send(
1673         TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1674         const char *name, int name_type,
1675         bool bcast, bool recurse,
1676         const struct sockaddr_storage *addrs,
1677         int num_addrs, int wait_msec, int timeout_msec)
1678 {
1679         struct tevent_req *req, *subreq;
1680         struct name_queries_state *state;
1681
1682         req = tevent_req_create(mem_ctx, &state,
1683                                 struct name_queries_state);
1684         if (req == NULL) {
1685                 return NULL;
1686         }
1687         state->ev = ev;
1688         state->name = name;
1689         state->name_type = name_type;
1690         state->bcast = bcast;
1691         state->recurse = recurse;
1692         state->addrs = addrs;
1693         state->num_addrs = num_addrs;
1694         state->wait_msec = wait_msec;
1695         state->timeout_msec = timeout_msec;
1696
1697         state->subreqs = talloc_zero_array(
1698                 state, struct tevent_req *, num_addrs);
1699         if (tevent_req_nomem(state->subreqs, req)) {
1700                 return tevent_req_post(req, ev);
1701         }
1702         state->num_sent = 0;
1703
1704         subreq = name_query_send(
1705                 state->subreqs, state->ev, name, name_type, bcast, recurse,
1706                 &state->addrs[state->num_sent]);
1707         if (tevent_req_nomem(subreq, req)) {
1708                 return tevent_req_post(req, ev);
1709         }
1710         if (!tevent_req_set_endtime(
1711                     subreq, state->ev,
1712                     timeval_current_ofs(0, state->timeout_msec * 1000))) {
1713                 tevent_req_oom(req);
1714                 return tevent_req_post(req, ev);
1715         }
1716         tevent_req_set_callback(subreq, name_queries_done, req);
1717
1718         state->subreqs[state->num_sent] = subreq;
1719         state->num_sent += 1;
1720
1721         if (state->num_sent < state->num_addrs) {
1722                 subreq = tevent_wakeup_send(
1723                         state, state->ev,
1724                         timeval_current_ofs(0, state->wait_msec * 1000));
1725                 if (tevent_req_nomem(subreq, req)) {
1726                         return tevent_req_post(req, ev);
1727                 }
1728                 tevent_req_set_callback(subreq, name_queries_next, req);
1729         }
1730         return req;
1731 }
1732
1733 static void name_queries_done(struct tevent_req *subreq)
1734 {
1735         struct tevent_req *req = tevent_req_callback_data(
1736                 subreq, struct tevent_req);
1737         struct name_queries_state *state = tevent_req_data(
1738                 req, struct name_queries_state);
1739         int i;
1740         NTSTATUS status;
1741
1742         status = name_query_recv(subreq, state, &state->result_addrs,
1743                                  &state->num_result_addrs, &state->flags);
1744
1745         for (i=0; i<state->num_sent; i++) {
1746                 if (state->subreqs[i] == subreq) {
1747                         break;
1748                 }
1749         }
1750         if (i == state->num_sent) {
1751                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1752                 return;
1753         }
1754         TALLOC_FREE(state->subreqs[i]);
1755
1756         state->num_received += 1;
1757
1758         if (!NT_STATUS_IS_OK(status)) {
1759
1760                 if (state->num_received >= state->num_addrs) {
1761                         tevent_req_nterror(req, status);
1762                         return;
1763                 }
1764                 /*
1765                  * Still outstanding requests, just wait
1766                  */
1767                 return;
1768         }
1769         state->received_index = i;
1770         tevent_req_done(req);
1771 }
1772
1773 static void name_queries_next(struct tevent_req *subreq)
1774 {
1775         struct tevent_req *req = tevent_req_callback_data(
1776                 subreq, struct tevent_req);
1777         struct name_queries_state *state = tevent_req_data(
1778                 req, struct name_queries_state);
1779
1780         if (!tevent_wakeup_recv(subreq)) {
1781                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1782                 return;
1783         }
1784
1785         subreq = name_query_send(
1786                 state->subreqs, state->ev,
1787                 state->name, state->name_type, state->bcast, state->recurse,
1788                 &state->addrs[state->num_sent]);
1789         if (tevent_req_nomem(subreq, req)) {
1790                 return;
1791         }
1792         tevent_req_set_callback(subreq, name_queries_done, req);
1793         if (!tevent_req_set_endtime(
1794                     subreq, state->ev,
1795                     timeval_current_ofs(0, state->timeout_msec * 1000))) {
1796                 tevent_req_oom(req);
1797                 return;
1798         }
1799         state->subreqs[state->num_sent] = subreq;
1800         state->num_sent += 1;
1801
1802         if (state->num_sent < state->num_addrs) {
1803                 subreq = tevent_wakeup_send(
1804                         state, state->ev,
1805                         timeval_current_ofs(0, state->wait_msec * 1000));
1806                 if (tevent_req_nomem(subreq, req)) {
1807                         return;
1808                 }
1809                 tevent_req_set_callback(subreq, name_queries_next, req);
1810         }
1811 }
1812
1813 static NTSTATUS name_queries_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1814                                   struct sockaddr_storage **result_addrs,
1815                                   int *num_result_addrs, uint8_t *flags,
1816                                   int *received_index)
1817 {
1818         struct name_queries_state *state = tevent_req_data(
1819                 req, struct name_queries_state);
1820         NTSTATUS status;
1821
1822         if (tevent_req_is_nterror(req, &status)) {
1823                 return status;
1824         }
1825
1826         if (result_addrs != NULL) {
1827                 *result_addrs = talloc_move(mem_ctx, &state->result_addrs);
1828         }
1829         if (num_result_addrs != NULL) {
1830                 *num_result_addrs = state->num_result_addrs;
1831         }
1832         if (flags != NULL) {
1833                 *flags = state->flags;
1834         }
1835         if (received_index != NULL) {
1836                 *received_index = state->received_index;
1837         }
1838         return NT_STATUS_OK;
1839 }
1840
1841 /********************************************************
1842  Resolve via "bcast" method.
1843 *********************************************************/
1844
1845 struct name_resolve_bcast_state {
1846         struct sockaddr_storage *addrs;
1847         int num_addrs;
1848 };
1849
1850 static void name_resolve_bcast_done(struct tevent_req *subreq);
1851
1852 struct tevent_req *name_resolve_bcast_send(TALLOC_CTX *mem_ctx,
1853                                            struct tevent_context *ev,
1854                                            const char *name,
1855                                            int name_type)
1856 {
1857         struct tevent_req *req, *subreq;
1858         struct name_resolve_bcast_state *state;
1859         struct sockaddr_storage *bcast_addrs;
1860         int i, num_addrs, num_bcast_addrs;
1861
1862         req = tevent_req_create(mem_ctx, &state,
1863                                 struct name_resolve_bcast_state);
1864         if (req == NULL) {
1865                 return NULL;
1866         }
1867
1868         if (lp_disable_netbios()) {
1869                 DEBUG(5, ("name_resolve_bcast(%s#%02x): netbios is disabled\n",
1870                           name, name_type));
1871                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
1872                 return tevent_req_post(req, ev);
1873         }
1874
1875         /*
1876          * "bcast" means do a broadcast lookup on all the local interfaces.
1877          */
1878
1879         DEBUG(3, ("name_resolve_bcast: Attempting broadcast lookup "
1880                   "for name %s<0x%x>\n", name, name_type));
1881
1882         num_addrs = iface_count();
1883         bcast_addrs = talloc_array(state, struct sockaddr_storage, num_addrs);
1884         if (tevent_req_nomem(bcast_addrs, req)) {
1885                 return tevent_req_post(req, ev);
1886         }
1887
1888         /*
1889          * Lookup the name on all the interfaces, return on
1890          * the first successful match.
1891          */
1892         num_bcast_addrs = 0;
1893
1894         for (i=0; i<num_addrs; i++) {
1895                 const struct sockaddr_storage *pss = iface_n_bcast(i);
1896
1897                 if (pss->ss_family != AF_INET) {
1898                         continue;
1899                 }
1900                 bcast_addrs[num_bcast_addrs] = *pss;
1901                 num_bcast_addrs += 1;
1902         }
1903
1904         subreq = name_queries_send(state, ev, name, name_type, true, true,
1905                                    bcast_addrs, num_bcast_addrs, 0, 1000);
1906         if (tevent_req_nomem(subreq, req)) {
1907                 return tevent_req_post(req, ev);
1908         }
1909         tevent_req_set_callback(subreq, name_resolve_bcast_done, req);
1910         return req;
1911 }
1912
1913 static void name_resolve_bcast_done(struct tevent_req *subreq)
1914 {
1915         struct tevent_req *req = tevent_req_callback_data(
1916                 subreq, struct tevent_req);
1917         struct name_resolve_bcast_state *state = tevent_req_data(
1918                 req, struct name_resolve_bcast_state);
1919         NTSTATUS status;
1920
1921         status = name_queries_recv(subreq, state,
1922                                    &state->addrs, &state->num_addrs,
1923                                    NULL, NULL);
1924         TALLOC_FREE(subreq);
1925         if (tevent_req_nterror(req, status)) {
1926                 return;
1927         }
1928         tevent_req_done(req);
1929 }
1930
1931 NTSTATUS name_resolve_bcast_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1932                                  struct sockaddr_storage **addrs,
1933                                  int *num_addrs)
1934 {
1935         struct name_resolve_bcast_state *state = tevent_req_data(
1936                 req, struct name_resolve_bcast_state);
1937         NTSTATUS status;
1938
1939         if (tevent_req_is_nterror(req, &status)) {
1940                 return status;
1941         }
1942         *addrs = talloc_move(mem_ctx, &state->addrs);
1943         *num_addrs = state->num_addrs;
1944         return NT_STATUS_OK;
1945 }
1946
1947 NTSTATUS name_resolve_bcast(const char *name,
1948                         int name_type,
1949                         TALLOC_CTX *mem_ctx,
1950                         struct sockaddr_storage **return_iplist,
1951                         int *return_count)
1952 {
1953         TALLOC_CTX *frame = talloc_stackframe();
1954         struct tevent_context *ev;
1955         struct tevent_req *req;
1956         NTSTATUS status = NT_STATUS_NO_MEMORY;
1957
1958         ev = samba_tevent_context_init(frame);
1959         if (ev == NULL) {
1960                 goto fail;
1961         }
1962         req = name_resolve_bcast_send(frame, ev, name, name_type);
1963         if (req == NULL) {
1964                 goto fail;
1965         }
1966         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1967                 goto fail;
1968         }
1969         status = name_resolve_bcast_recv(req, mem_ctx, return_iplist,
1970                                          return_count);
1971  fail:
1972         TALLOC_FREE(frame);
1973         return status;
1974 }
1975
1976 struct query_wins_list_state {
1977         struct tevent_context *ev;
1978         const char *name;
1979         uint8_t name_type;
1980         struct in_addr *servers;
1981         uint32_t num_servers;
1982         struct sockaddr_storage server;
1983         uint32_t num_sent;
1984
1985         struct sockaddr_storage *addrs;
1986         int num_addrs;
1987         uint8_t flags;
1988 };
1989
1990 static void query_wins_list_done(struct tevent_req *subreq);
1991
1992 /*
1993  * Query a list of (replicating) wins servers in sequence, call them
1994  * dead if they don't reply
1995  */
1996
1997 static struct tevent_req *query_wins_list_send(
1998         TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1999         struct in_addr src_ip, const char *name, uint8_t name_type,
2000         struct in_addr *servers, int num_servers)
2001 {
2002         struct tevent_req *req, *subreq;
2003         struct query_wins_list_state *state;
2004
2005         req = tevent_req_create(mem_ctx, &state,
2006                                 struct query_wins_list_state);
2007         if (req == NULL) {
2008                 return NULL;
2009         }
2010         state->ev = ev;
2011         state->name = name;
2012         state->name_type = name_type;
2013         state->servers = servers;
2014         state->num_servers = num_servers;
2015
2016         if (state->num_servers == 0) {
2017                 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
2018                 return tevent_req_post(req, ev);
2019         }
2020
2021         in_addr_to_sockaddr_storage(
2022                 &state->server, state->servers[state->num_sent]);
2023
2024         subreq = name_query_send(state, state->ev,
2025                                  state->name, state->name_type,
2026                                  false, true, &state->server);
2027         state->num_sent += 1;
2028         if (tevent_req_nomem(subreq, req)) {
2029                 return tevent_req_post(req, ev);
2030         }
2031         if (!tevent_req_set_endtime(subreq, state->ev,
2032                                     timeval_current_ofs(2, 0))) {
2033                 tevent_req_oom(req);
2034                 return tevent_req_post(req, ev);
2035         }
2036         tevent_req_set_callback(subreq, query_wins_list_done, req);
2037         return req;
2038 }
2039
2040 static void query_wins_list_done(struct tevent_req *subreq)
2041 {
2042         struct tevent_req *req = tevent_req_callback_data(
2043                 subreq, struct tevent_req);
2044         struct query_wins_list_state *state = tevent_req_data(
2045                 req, struct query_wins_list_state);
2046         NTSTATUS status;
2047
2048         status = name_query_recv(subreq, state,
2049                                  &state->addrs, &state->num_addrs,
2050                                  &state->flags);
2051         TALLOC_FREE(subreq);
2052         if (NT_STATUS_IS_OK(status)) {
2053                 tevent_req_done(req);
2054                 return;
2055         }
2056         if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
2057                 tevent_req_nterror(req, status);
2058                 return;
2059         }
2060         wins_srv_died(state->servers[state->num_sent-1],
2061                       my_socket_addr_v4());
2062
2063         if (state->num_sent == state->num_servers) {
2064                 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
2065                 return;
2066         }
2067
2068         in_addr_to_sockaddr_storage(
2069                 &state->server, state->servers[state->num_sent]);
2070
2071         subreq = name_query_send(state, state->ev,
2072                                  state->name, state->name_type,
2073                                  false, true, &state->server);
2074         state->num_sent += 1;
2075         if (tevent_req_nomem(subreq, req)) {
2076                 return;
2077         }
2078         if (!tevent_req_set_endtime(subreq, state->ev,
2079                                     timeval_current_ofs(2, 0))) {
2080                 tevent_req_oom(req);
2081                 return;
2082         }
2083         tevent_req_set_callback(subreq, query_wins_list_done, req);
2084 }
2085
2086 static NTSTATUS query_wins_list_recv(struct tevent_req *req,
2087                                      TALLOC_CTX *mem_ctx,
2088                                      struct sockaddr_storage **addrs,
2089                                      int *num_addrs,
2090                                      uint8_t *flags)
2091 {
2092         struct query_wins_list_state *state = tevent_req_data(
2093                 req, struct query_wins_list_state);
2094         NTSTATUS status;
2095
2096         if (tevent_req_is_nterror(req, &status)) {
2097                 return status;
2098         }
2099         if (addrs != NULL) {
2100                 *addrs = talloc_move(mem_ctx, &state->addrs);
2101         }
2102         if (num_addrs != NULL) {
2103                 *num_addrs = state->num_addrs;
2104         }
2105         if (flags != NULL) {
2106                 *flags = state->flags;
2107         }
2108         return NT_STATUS_OK;
2109 }
2110
2111 struct resolve_wins_state {
2112         int num_sent;
2113         int num_received;
2114
2115         struct sockaddr_storage *addrs;
2116         int num_addrs;
2117         uint8_t flags;
2118 };
2119
2120 static void resolve_wins_done(struct tevent_req *subreq);
2121
2122 struct tevent_req *resolve_wins_send(TALLOC_CTX *mem_ctx,
2123                                      struct tevent_context *ev,
2124                                      const char *name,
2125                                      int name_type)
2126 {
2127         struct tevent_req *req, *subreq;
2128         struct resolve_wins_state *state;
2129         char **wins_tags = NULL;
2130         struct sockaddr_storage src_ss;
2131         struct in_addr src_ip;
2132         int i, num_wins_tags;
2133
2134         req = tevent_req_create(mem_ctx, &state,
2135                                 struct resolve_wins_state);
2136         if (req == NULL) {
2137                 return NULL;
2138         }
2139
2140         if (wins_srv_count() < 1) {
2141                 DEBUG(3,("resolve_wins: WINS server resolution selected "
2142                         "and no WINS servers listed.\n"));
2143                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2144                 goto fail;
2145         }
2146
2147         /* the address we will be sending from */
2148         if (!interpret_string_addr(&src_ss, lp_nbt_client_socket_address(),
2149                                 AI_NUMERICHOST|AI_PASSIVE)) {
2150                 zero_sockaddr(&src_ss);
2151         }
2152
2153         if (src_ss.ss_family != AF_INET) {
2154                 char addr[INET6_ADDRSTRLEN];
2155                 print_sockaddr(addr, sizeof(addr), &src_ss);
2156                 DEBUG(3,("resolve_wins: cannot receive WINS replies "
2157                         "on IPv6 address %s\n",
2158                         addr));
2159                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2160                 goto fail;
2161         }
2162
2163         src_ip = ((const struct sockaddr_in *)(void *)&src_ss)->sin_addr;
2164
2165         wins_tags = wins_srv_tags();
2166         if (wins_tags == NULL) {
2167                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2168                 goto fail;
2169         }
2170
2171         num_wins_tags = 0;
2172         while (wins_tags[num_wins_tags] != NULL) {
2173                 num_wins_tags += 1;
2174         }
2175
2176         for (i=0; i<num_wins_tags; i++) {
2177                 int num_servers, num_alive;
2178                 struct in_addr *servers, *alive;
2179                 int j;
2180
2181                 if (!wins_server_tag_ips(wins_tags[i], talloc_tos(),
2182                                          &servers, &num_servers)) {
2183                         DEBUG(10, ("wins_server_tag_ips failed for tag %s\n",
2184                                    wins_tags[i]));
2185                         continue;
2186                 }
2187
2188                 alive = talloc_array(state, struct in_addr, num_servers);
2189                 if (tevent_req_nomem(alive, req)) {
2190                         goto fail;
2191                 }
2192
2193                 num_alive = 0;
2194                 for (j=0; j<num_servers; j++) {
2195                         struct in_addr wins_ip = servers[j];
2196
2197                         if (global_in_nmbd && ismyip_v4(wins_ip)) {
2198                                 /* yikes! we'll loop forever */
2199                                 continue;
2200                         }
2201                         /* skip any that have been unresponsive lately */
2202                         if (wins_srv_is_dead(wins_ip, src_ip)) {
2203                                 continue;
2204                         }
2205                         DEBUG(3, ("resolve_wins: using WINS server %s "
2206                                  "and tag '%s'\n",
2207                                   inet_ntoa(wins_ip), wins_tags[i]));
2208                         alive[num_alive] = wins_ip;
2209                         num_alive += 1;
2210                 }
2211                 TALLOC_FREE(servers);
2212
2213                 if (num_alive == 0) {
2214                         continue;
2215                 }
2216
2217                 subreq = query_wins_list_send(
2218                         state, ev, src_ip, name, name_type,
2219                         alive, num_alive);
2220                 if (tevent_req_nomem(subreq, req)) {
2221                         goto fail;
2222                 }
2223                 tevent_req_set_callback(subreq, resolve_wins_done, req);
2224                 state->num_sent += 1;
2225         }
2226
2227         if (state->num_sent == 0) {
2228                 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
2229                 goto fail;
2230         }
2231
2232         wins_srv_tags_free(wins_tags);
2233         return req;
2234 fail:
2235         wins_srv_tags_free(wins_tags);
2236         return tevent_req_post(req, ev);
2237 }
2238
2239 static void resolve_wins_done(struct tevent_req *subreq)
2240 {
2241         struct tevent_req *req = tevent_req_callback_data(
2242                 subreq, struct tevent_req);
2243         struct resolve_wins_state *state = tevent_req_data(
2244                 req, struct resolve_wins_state);
2245         NTSTATUS status;
2246
2247         status = query_wins_list_recv(subreq, state, &state->addrs,
2248                                       &state->num_addrs, &state->flags);
2249         if (NT_STATUS_IS_OK(status)) {
2250                 tevent_req_done(req);
2251                 return;
2252         }
2253
2254         state->num_received += 1;
2255
2256         if (state->num_received < state->num_sent) {
2257                 /*
2258                  * Wait for the others
2259                  */
2260                 return;
2261         }
2262         tevent_req_nterror(req, status);
2263 }
2264
2265 NTSTATUS resolve_wins_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
2266                            struct sockaddr_storage **addrs,
2267                            int *num_addrs, uint8_t *flags)
2268 {
2269         struct resolve_wins_state *state = tevent_req_data(
2270                 req, struct resolve_wins_state);
2271         NTSTATUS status;
2272
2273         if (tevent_req_is_nterror(req, &status)) {
2274                 return status;
2275         }
2276         if (addrs != NULL) {
2277                 *addrs = talloc_move(mem_ctx, &state->addrs);
2278         }
2279         if (num_addrs != NULL) {
2280                 *num_addrs = state->num_addrs;
2281         }
2282         if (flags != NULL) {
2283                 *flags = state->flags;
2284         }
2285         return NT_STATUS_OK;
2286 }
2287
2288 /********************************************************
2289  Resolve via "wins" method.
2290 *********************************************************/
2291
2292 NTSTATUS resolve_wins(const char *name,
2293                 int name_type,
2294                 TALLOC_CTX *mem_ctx,
2295                 struct sockaddr_storage **return_iplist,
2296                 int *return_count)
2297 {
2298         struct tevent_context *ev;
2299         struct tevent_req *req;
2300         NTSTATUS status = NT_STATUS_NO_MEMORY;
2301
2302         ev = samba_tevent_context_init(talloc_tos());
2303         if (ev == NULL) {
2304                 goto fail;
2305         }
2306         req = resolve_wins_send(ev, ev, name, name_type);
2307         if (req == NULL) {
2308                 goto fail;
2309         }
2310         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2311                 goto fail;
2312         }
2313         status = resolve_wins_recv(req, mem_ctx, return_iplist, return_count,
2314                                    NULL);
2315 fail:
2316         TALLOC_FREE(ev);
2317         return status;
2318 }
2319
2320 /********************************************************
2321  Resolve via "hosts" method.
2322 *********************************************************/
2323
2324 static NTSTATUS resolve_hosts(const char *name, int name_type,
2325                               TALLOC_CTX *mem_ctx,
2326                               struct sockaddr_storage **return_iplist,
2327                               int *return_count)
2328 {
2329         /*
2330          * "host" means do a localhost, or dns lookup.
2331          */
2332         struct addrinfo hints;
2333         struct addrinfo *ailist = NULL;
2334         struct addrinfo *res = NULL;
2335         int ret = -1;
2336         int i = 0;
2337
2338         if ( name_type != 0x20 && name_type != 0x0) {
2339                 DEBUG(5, ("resolve_hosts: not appropriate "
2340                         "for name type <0x%x>\n",
2341                         name_type));
2342                 return NT_STATUS_INVALID_PARAMETER;
2343         }
2344
2345         *return_iplist = NULL;
2346         *return_count = 0;
2347
2348         DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n",
2349                                 name, name_type));
2350
2351         ZERO_STRUCT(hints);
2352         /* By default make sure it supports TCP. */
2353         hints.ai_socktype = SOCK_STREAM;
2354         hints.ai_flags = AI_ADDRCONFIG;
2355
2356 #if !defined(HAVE_IPV6)
2357         /* Unless we have IPv6, we really only want IPv4 addresses back. */
2358         hints.ai_family = AF_INET;
2359 #endif
2360
2361         ret = getaddrinfo(name,
2362                         NULL,
2363                         &hints,
2364                         &ailist);
2365         if (ret) {
2366                 DEBUG(3,("resolve_hosts: getaddrinfo failed for name %s [%s]\n",
2367                         name,
2368                         gai_strerror(ret) ));
2369         }
2370
2371         for (res = ailist; res; res = res->ai_next) {
2372                 struct sockaddr_storage ss;
2373
2374                 if (!res->ai_addr || res->ai_addrlen == 0) {
2375                         continue;
2376                 }
2377
2378                 ZERO_STRUCT(ss);
2379                 memcpy(&ss, res->ai_addr, res->ai_addrlen);
2380
2381                 if (is_zero_addr(&ss)) {
2382                         continue;
2383                 }
2384
2385                 *return_count += 1;
2386
2387                 *return_iplist = talloc_realloc(
2388                         mem_ctx, *return_iplist, struct sockaddr_storage,
2389                         *return_count);
2390                 if (!*return_iplist) {
2391                         DEBUG(3,("resolve_hosts: malloc fail !\n"));
2392                         freeaddrinfo(ailist);
2393                         return NT_STATUS_NO_MEMORY;
2394                 }
2395                 (*return_iplist)[i] = ss;
2396                 i++;
2397         }
2398         if (ailist) {
2399                 freeaddrinfo(ailist);
2400         }
2401         if (*return_count) {
2402                 return NT_STATUS_OK;
2403         }
2404         return NT_STATUS_UNSUCCESSFUL;
2405 }
2406
2407 /********************************************************
2408  Resolve via "ADS" method.
2409 *********************************************************/
2410
2411 /* Special name type used to cause a _kerberos DNS lookup. */
2412 #define KDC_NAME_TYPE 0xDCDC
2413
2414 static NTSTATUS resolve_ads(const char *name,
2415                             int name_type,
2416                             const char *sitename,
2417                             struct ip_service **return_iplist,
2418                             int *return_count)
2419 {
2420         int                     i;
2421         NTSTATUS                status;
2422         TALLOC_CTX              *ctx;
2423         struct dns_rr_srv       *dcs = NULL;
2424         int                     numdcs = 0;
2425         int                     numaddrs = 0;
2426
2427         if ((name_type != 0x1c) && (name_type != KDC_NAME_TYPE) &&
2428             (name_type != 0x1b)) {
2429                 return NT_STATUS_INVALID_PARAMETER;
2430         }
2431
2432         if ( (ctx = talloc_init("resolve_ads")) == NULL ) {
2433                 DEBUG(0,("resolve_ads: talloc_init() failed!\n"));
2434                 return NT_STATUS_NO_MEMORY;
2435         }
2436
2437         /* The DNS code needs fixing to find IPv6 addresses... JRA. */
2438         switch (name_type) {
2439                 case 0x1b:
2440                         DEBUG(5,("resolve_ads: Attempting to resolve "
2441                                  "PDC for %s using DNS\n", name));
2442                         status = ads_dns_query_pdc(ctx,
2443                                                    name,
2444                                                    &dcs,
2445                                                    &numdcs);
2446                         break;
2447
2448                 case 0x1c:
2449                         DEBUG(5,("resolve_ads: Attempting to resolve "
2450                                  "DCs for %s using DNS\n", name));
2451                         status = ads_dns_query_dcs(ctx,
2452                                                    name,
2453                                                    sitename,
2454                                                    &dcs,
2455                                                    &numdcs);
2456                         break;
2457                 case KDC_NAME_TYPE:
2458                         DEBUG(5,("resolve_ads: Attempting to resolve "
2459                                  "KDCs for %s using DNS\n", name));
2460                         status = ads_dns_query_kdcs(ctx,
2461                                                     name,
2462                                                     sitename,
2463                                                     &dcs,
2464                                                     &numdcs);
2465                         break;
2466                 default:
2467                         status = NT_STATUS_INVALID_PARAMETER;
2468                         break;
2469         }
2470
2471         if ( !NT_STATUS_IS_OK( status ) ) {
2472                 talloc_destroy(ctx);
2473                 return status;
2474         }
2475
2476         if (numdcs == 0) {
2477                 *return_iplist = NULL;
2478                 *return_count = 0;
2479                 talloc_destroy(ctx);
2480                 return NT_STATUS_OK;
2481         }
2482
2483         for (i=0;i<numdcs;i++) {
2484                 if (!dcs[i].ss_s) {
2485                         numaddrs += 1;
2486                 } else {
2487                         numaddrs += dcs[i].num_ips;
2488                 }
2489         }
2490
2491         if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, numaddrs)) ==
2492                         NULL ) {
2493                 DEBUG(0,("resolve_ads: malloc failed for %d entries\n",
2494                                         numaddrs ));
2495                 talloc_destroy(ctx);
2496                 return NT_STATUS_NO_MEMORY;
2497         }
2498
2499         /* now unroll the list of IP addresses */
2500
2501         *return_count = 0;
2502
2503         for (i = 0; i < numdcs && (*return_count<numaddrs); i++ ) {
2504                 /* If we don't have an IP list for a name, lookup it up */
2505                 if (!dcs[i].ss_s) {
2506                         /* We need to get all IP addresses here. */
2507                         struct addrinfo *res = NULL;
2508                         struct addrinfo *p;
2509                         int extra_addrs = 0;
2510
2511                         if (!interpret_string_addr_internal(&res,
2512                                                 dcs[i].hostname,
2513                                                 0)) {
2514                                 continue;
2515                         }
2516                         /* Add in every IP from the lookup. How
2517                            many is that ? */
2518                         for (p = res; p; p = p->ai_next) {
2519                                 struct sockaddr_storage ss;
2520                                 memcpy(&ss, p->ai_addr, p->ai_addrlen);
2521                                 if (is_zero_addr(&ss)) {
2522                                         continue;
2523                                 }
2524                                 extra_addrs++;
2525                         }
2526                         if (extra_addrs > 1) {
2527                                 /* We need to expand the return_iplist array
2528                                    as we only budgeted for one address. */
2529                                 numaddrs += (extra_addrs-1);
2530                                 *return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
2531                                                 struct ip_service,
2532                                                 numaddrs);
2533                                 if (*return_iplist == NULL) {
2534                                         if (res) {
2535                                                 freeaddrinfo(res);
2536                                         }
2537                                         talloc_destroy(ctx);
2538                                         return NT_STATUS_NO_MEMORY;
2539                                 }
2540                         }
2541                         for (p = res; p; p = p->ai_next) {
2542                                 (*return_iplist)[*return_count].port = dcs[i].port;
2543                                 memcpy(&(*return_iplist)[*return_count].ss,
2544                                                 p->ai_addr,
2545                                                 p->ai_addrlen);
2546                                 if (is_zero_addr(&(*return_iplist)[*return_count].ss)) {
2547                                         continue;
2548                                 }
2549                                 (*return_count)++;
2550                                 /* Should never happen, but still... */
2551                                 if (*return_count>=numaddrs) {
2552                                         break;
2553                                 }
2554                         }
2555                         if (res) {
2556                                 freeaddrinfo(res);
2557                         }
2558                 } else {
2559                         /* use all the IP addresses from the SRV response */
2560                         int j;
2561                         for (j = 0; j < dcs[i].num_ips; j++) {
2562                                 (*return_iplist)[*return_count].port = dcs[i].port;
2563                                 (*return_iplist)[*return_count].ss = dcs[i].ss_s[j];
2564                                 if (is_zero_addr(&(*return_iplist)[*return_count].ss)) {
2565                                         continue;
2566                                 }
2567                                 (*return_count)++;
2568                                 /* Should never happen, but still... */
2569                                 if (*return_count>=numaddrs) {
2570                                         break;
2571                                 }
2572                         }
2573                 }
2574         }
2575
2576         talloc_destroy(ctx);
2577         return NT_STATUS_OK;
2578 }
2579
2580 static const char **filter_out_nbt_lookup(TALLOC_CTX *mem_ctx,
2581                                           const char **resolve_order)
2582 {
2583         size_t i, len, result_idx;
2584         const char **result;
2585
2586         len = 0;
2587         while (resolve_order[len] != NULL) {
2588                 len += 1;
2589         }
2590
2591         result = talloc_array(mem_ctx, const char *, len+1);
2592         if (result == NULL) {
2593                 return NULL;
2594         }
2595
2596         result_idx = 0;
2597
2598         for (i=0; i<len; i++) {
2599                 const char *tok = resolve_order[i];
2600
2601                 if (strequal(tok, "lmhosts") || strequal(tok, "wins") ||
2602                     strequal(tok, "bcast")) {
2603                         continue;
2604                 }
2605                 result[result_idx++] = tok;
2606         }
2607         result[result_idx] = NULL;
2608
2609         return result;
2610 }
2611
2612 /*******************************************************************
2613  Internal interface to resolve a name into an IP address.
2614  Use this function if the string is either an IP address, DNS
2615  or host name or NetBIOS name. This uses the name switch in the
2616  smb.conf to determine the order of name resolution.
2617
2618  Added support for ip addr/port to support ADS ldap servers.
2619  the only place we currently care about the port is in the
2620  resolve_hosts() when looking up DC's via SRV RR entries in DNS
2621 **********************************************************************/
2622
2623 NTSTATUS internal_resolve_name(const char *name,
2624                                 int name_type,
2625                                 const char *sitename,
2626                                 struct ip_service **return_iplist,
2627                                 int *return_count,
2628                                 const char **resolve_order)
2629 {
2630         const char *tok;
2631         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2632         int i;
2633         TALLOC_CTX *frame = NULL;
2634
2635         *return_iplist = NULL;
2636         *return_count = 0;
2637
2638         DEBUG(10, ("internal_resolve_name: looking up %s#%x (sitename %s)\n",
2639                         name, name_type, sitename ? sitename : "(null)"));
2640
2641         if (is_ipaddress(name)) {
2642                 if ((*return_iplist = SMB_MALLOC_P(struct ip_service)) ==
2643                                 NULL) {
2644                         DEBUG(0,("internal_resolve_name: malloc fail !\n"));
2645                         return NT_STATUS_NO_MEMORY;
2646                 }
2647
2648                 /* ignore the port here */
2649                 (*return_iplist)->port = PORT_NONE;
2650
2651                 /* if it's in the form of an IP address then get the lib to interpret it */
2652                 if (!interpret_string_addr(&(*return_iplist)->ss,
2653                                         name, AI_NUMERICHOST)) {
2654                         DEBUG(1,("internal_resolve_name: interpret_string_addr "
2655                                 "failed on %s\n",
2656                                 name));
2657                         SAFE_FREE(*return_iplist);
2658                         return NT_STATUS_INVALID_PARAMETER;
2659                 }
2660                 if (is_zero_addr(&(*return_iplist)->ss)) {
2661                         SAFE_FREE(*return_iplist);
2662                         return NT_STATUS_UNSUCCESSFUL;
2663                 }
2664                 *return_count = 1;
2665                 return NT_STATUS_OK;
2666         }
2667
2668         /* Check name cache */
2669
2670         if (namecache_fetch(name, name_type, return_iplist, return_count)) {
2671                 *return_count = remove_duplicate_addrs2(*return_iplist,
2672                                         *return_count );
2673                 /* This could be a negative response */
2674                 if (*return_count > 0) {
2675                         return NT_STATUS_OK;
2676                 } else {
2677                         return NT_STATUS_UNSUCCESSFUL;
2678                 }
2679         }
2680
2681         /* set the name resolution order */
2682
2683         if (resolve_order && strcmp(resolve_order[0], "NULL") == 0) {
2684                 DEBUG(8,("internal_resolve_name: all lookups disabled\n"));
2685                 return NT_STATUS_INVALID_PARAMETER;
2686         }
2687
2688         if (!resolve_order || !resolve_order[0]) {
2689                 static const char *host_order[] = { "host", NULL };
2690                 resolve_order = host_order;
2691         }
2692
2693         frame = talloc_stackframe();
2694
2695         if ((strlen(name) > MAX_NETBIOSNAME_LEN - 1) ||
2696             (strchr(name, '.') != NULL)) {
2697                 /*
2698                  * Don't do NBT lookup, the name would not fit anyway
2699                  */
2700                 resolve_order = filter_out_nbt_lookup(frame, resolve_order);
2701                 if (resolve_order == NULL) {
2702                         TALLOC_FREE(frame);
2703                         return NT_STATUS_NO_MEMORY;
2704                 }
2705         }
2706
2707         /* iterate through the name resolution backends */
2708
2709         for (i=0; resolve_order[i]; i++) {
2710                 tok = resolve_order[i];
2711
2712                 if((strequal(tok, "host") || strequal(tok, "hosts"))) {
2713                         struct sockaddr_storage *ss_list;
2714                         status = resolve_hosts(name, name_type,
2715                                                talloc_tos(), &ss_list,
2716                                                return_count);
2717                         if (NT_STATUS_IS_OK(status)) {
2718                                 if (!convert_ss2service(return_iplist,
2719                                                         ss_list,
2720                                                         return_count)) {
2721                                         status = NT_STATUS_NO_MEMORY;
2722                                 }
2723                                 goto done;
2724                         }
2725                 } else if(strequal( tok, "kdc")) {
2726                         /* deal with KDC_NAME_TYPE names here.
2727                          * This will result in a SRV record lookup */
2728                         status = resolve_ads(name, KDC_NAME_TYPE, sitename,
2729                                              return_iplist, return_count);
2730                         if (NT_STATUS_IS_OK(status)) {
2731                                 /* Ensure we don't namecache
2732                                  * this with the KDC port. */
2733                                 name_type = KDC_NAME_TYPE;
2734                                 goto done;
2735                         }
2736                 } else if(strequal( tok, "ads")) {
2737                         /* deal with 0x1c and 0x1b names here.
2738                          * This will result in a SRV record lookup */
2739                         status = resolve_ads(name, name_type, sitename,
2740                                              return_iplist, return_count);
2741                         if (NT_STATUS_IS_OK(status)) {
2742                                 goto done;
2743                         }
2744                 } else if (strequal(tok, "lmhosts")) {
2745                         struct sockaddr_storage *ss_list;
2746                         status = resolve_lmhosts_file_as_sockaddr(
2747                                 get_dyn_LMHOSTSFILE(), name, name_type,
2748                                 talloc_tos(), &ss_list, return_count);
2749                         if (NT_STATUS_IS_OK(status)) {
2750                                 if (!convert_ss2service(return_iplist,
2751                                                         ss_list,
2752                                                         return_count)) {
2753                                         status = NT_STATUS_NO_MEMORY;
2754                                 }
2755                                 goto done;
2756                         }
2757                 } else if (strequal(tok, "wins")) {
2758                         /* don't resolve 1D via WINS */
2759                         struct sockaddr_storage *ss_list;
2760                         if (name_type != 0x1D) {
2761                                 status = resolve_wins(name, name_type,
2762                                                       talloc_tos(),
2763                                                       &ss_list,
2764                                                       return_count);
2765                                 if (NT_STATUS_IS_OK(status)) {
2766                                         if (!convert_ss2service(return_iplist,
2767                                                                 ss_list,
2768                                                                 return_count)) {
2769                                                 status = NT_STATUS_NO_MEMORY;
2770                                         }
2771                                         goto done;
2772                                 }
2773                         }
2774                 } else if (strequal(tok, "bcast")) {
2775                         struct sockaddr_storage *ss_list;
2776                         status = name_resolve_bcast(
2777                                 name, name_type, talloc_tos(),
2778                                 &ss_list, return_count);
2779                         if (NT_STATUS_IS_OK(status)) {
2780                                 if (!convert_ss2service(return_iplist,
2781                                                         ss_list,
2782                                                         return_count)) {
2783                                         status = NT_STATUS_NO_MEMORY;
2784                                 }
2785                                 goto done;
2786                         }
2787                 } else {
2788                         DEBUG(0,("resolve_name: unknown name switch type %s\n",
2789                                 tok));
2790                 }
2791         }
2792
2793         /* All of the resolve_* functions above have returned false. */
2794
2795         TALLOC_FREE(frame);
2796         SAFE_FREE(*return_iplist);
2797         *return_count = 0;
2798
2799         return NT_STATUS_UNSUCCESSFUL;
2800
2801   done:
2802
2803         /* Remove duplicate entries.  Some queries, notably #1c (domain
2804         controllers) return the PDC in iplist[0] and then all domain
2805         controllers including the PDC in iplist[1..n].  Iterating over
2806         the iplist when the PDC is down will cause two sets of timeouts. */
2807
2808         *return_count = remove_duplicate_addrs2(*return_iplist, *return_count );
2809
2810         /* Save in name cache */
2811         if ( DEBUGLEVEL >= 100 ) {
2812                 for (i = 0; i < *return_count && DEBUGLEVEL == 100; i++) {
2813                         char addr[INET6_ADDRSTRLEN];
2814                         print_sockaddr(addr, sizeof(addr),
2815                                         &(*return_iplist)[i].ss);
2816                         DEBUG(100, ("Storing name %s of type %d (%s:%d)\n",
2817                                         name,
2818                                         name_type,
2819                                         addr,
2820                                         (*return_iplist)[i].port));
2821                 }
2822         }
2823
2824         if (*return_count) {
2825                 namecache_store(name, name_type, *return_count, *return_iplist);
2826         }
2827
2828         /* Display some debugging info */
2829
2830         if ( DEBUGLEVEL >= 10 ) {
2831                 DEBUG(10, ("internal_resolve_name: returning %d addresses: ",
2832                                         *return_count));
2833
2834                 for (i = 0; i < *return_count; i++) {
2835                         char addr[INET6_ADDRSTRLEN];
2836                         print_sockaddr(addr, sizeof(addr),
2837                                         &(*return_iplist)[i].ss);
2838                         DEBUGADD(10, ("%s:%d ",
2839                                         addr,
2840                                         (*return_iplist)[i].port));
2841                 }
2842                 DEBUG(10, ("\n"));
2843         }
2844
2845         TALLOC_FREE(frame);
2846         return status;
2847 }
2848
2849 /********************************************************
2850  Internal interface to resolve a name into one IP address.
2851  Use this function if the string is either an IP address, DNS
2852  or host name or NetBIOS name. This uses the name switch in the
2853  smb.conf to determine the order of name resolution.
2854 *********************************************************/
2855
2856 bool resolve_name(const char *name,
2857                 struct sockaddr_storage *return_ss,
2858                 int name_type,
2859                 bool prefer_ipv4)
2860 {
2861         struct ip_service *ss_list = NULL;
2862         char *sitename = NULL;
2863         int count = 0;
2864         NTSTATUS status;
2865
2866         if (is_ipaddress(name)) {
2867                 return interpret_string_addr(return_ss, name, AI_NUMERICHOST);
2868         }
2869
2870         sitename = sitename_fetch(talloc_tos(), lp_realm()); /* wild guess */
2871
2872         status = internal_resolve_name(name, name_type, sitename,
2873                                        &ss_list, &count,
2874                                        lp_name_resolve_order());
2875         if (NT_STATUS_IS_OK(status)) {
2876                 int i;
2877
2878                 if (prefer_ipv4) {
2879                         for (i=0; i<count; i++) {
2880                                 if (!is_zero_addr(&ss_list[i].ss) &&
2881                                     !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss) &&
2882                                                 (ss_list[i].ss.ss_family == AF_INET)) {
2883                                         *return_ss = ss_list[i].ss;
2884                                         SAFE_FREE(ss_list);
2885                                         TALLOC_FREE(sitename);
2886                                         return True;
2887                                 }
2888                         }
2889                 }
2890
2891                 /* only return valid addresses for TCP connections */
2892                 for (i=0; i<count; i++) {
2893                         if (!is_zero_addr(&ss_list[i].ss) &&
2894                             !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
2895                                 *return_ss = ss_list[i].ss;
2896                                 SAFE_FREE(ss_list);
2897                                 TALLOC_FREE(sitename);
2898                                 return True;
2899                         }
2900                 }
2901         }
2902
2903         SAFE_FREE(ss_list);
2904         TALLOC_FREE(sitename);
2905         return False;
2906 }
2907
2908 /********************************************************
2909  Internal interface to resolve a name into a list of IP addresses.
2910  Use this function if the string is either an IP address, DNS
2911  or host name or NetBIOS name. This uses the name switch in the
2912  smb.conf to determine the order of name resolution.
2913 *********************************************************/
2914
2915 NTSTATUS resolve_name_list(TALLOC_CTX *ctx,
2916                 const char *name,
2917                 int name_type,
2918                 struct sockaddr_storage **return_ss_arr,
2919                 unsigned int *p_num_entries)
2920 {
2921         struct ip_service *ss_list = NULL;
2922         char *sitename = NULL;
2923         int count = 0;
2924         int i;
2925         unsigned int num_entries;
2926         NTSTATUS status;
2927
2928         *p_num_entries = 0;
2929         *return_ss_arr = NULL;
2930
2931         if (is_ipaddress(name)) {
2932                 *return_ss_arr = talloc(ctx, struct sockaddr_storage);
2933                 if (!*return_ss_arr) {
2934                         return NT_STATUS_NO_MEMORY;
2935                 }
2936                 if (!interpret_string_addr(*return_ss_arr, name, AI_NUMERICHOST)) {
2937                         TALLOC_FREE(*return_ss_arr);
2938                         return NT_STATUS_BAD_NETWORK_NAME;
2939                 }
2940                 *p_num_entries = 1;
2941                 return NT_STATUS_OK;
2942         }
2943
2944         sitename = sitename_fetch(ctx, lp_realm()); /* wild guess */
2945
2946         status = internal_resolve_name(name, name_type, sitename,
2947                                                   &ss_list, &count,
2948                                                   lp_name_resolve_order());
2949         TALLOC_FREE(sitename);
2950
2951         if (!NT_STATUS_IS_OK(status)) {
2952                 return status;
2953         }
2954
2955         /* only return valid addresses for TCP connections */
2956         for (i=0, num_entries = 0; i<count; i++) {
2957                 if (!is_zero_addr(&ss_list[i].ss) &&
2958                     !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
2959                         num_entries++;
2960                 }
2961         }
2962         if (num_entries == 0) {
2963                 SAFE_FREE(ss_list);
2964                 return NT_STATUS_BAD_NETWORK_NAME;
2965         }
2966
2967         *return_ss_arr = talloc_array(ctx,
2968                                 struct sockaddr_storage,
2969                                 num_entries);
2970         if (!(*return_ss_arr)) {
2971                 SAFE_FREE(ss_list);
2972                 return NT_STATUS_NO_MEMORY;
2973         }
2974
2975         for (i=0, num_entries = 0; i<count; i++) {
2976                 if (!is_zero_addr(&ss_list[i].ss) &&
2977                     !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
2978                         (*return_ss_arr)[num_entries++] = ss_list[i].ss;
2979                 }
2980         }
2981
2982         status = NT_STATUS_OK;
2983         *p_num_entries = num_entries;
2984
2985         SAFE_FREE(ss_list);
2986         return NT_STATUS_OK;
2987 }
2988
2989 /********************************************************
2990  Find the IP address of the master browser or DMB for a workgroup.
2991 *********************************************************/
2992
2993 bool find_master_ip(const char *group, struct sockaddr_storage *master_ss)
2994 {
2995         struct ip_service *ip_list = NULL;
2996         int count = 0;
2997         NTSTATUS status;
2998
2999         if (lp_disable_netbios()) {
3000                 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group));
3001                 return false;
3002         }
3003
3004         status = internal_resolve_name(group, 0x1D, NULL, &ip_list, &count,
3005                                        lp_name_resolve_order());
3006         if (NT_STATUS_IS_OK(status)) {
3007                 *master_ss = ip_list[0].ss;
3008                 SAFE_FREE(ip_list);
3009                 return true;
3010         }
3011
3012         status = internal_resolve_name(group, 0x1B, NULL, &ip_list, &count,
3013                                        lp_name_resolve_order());
3014         if (NT_STATUS_IS_OK(status)) {
3015                 *master_ss = ip_list[0].ss;
3016                 SAFE_FREE(ip_list);
3017                 return true;
3018         }
3019
3020         SAFE_FREE(ip_list);
3021         return false;
3022 }
3023
3024 /********************************************************
3025  Get the IP address list of the primary domain controller
3026  for a domain.
3027 *********************************************************/
3028
3029 bool get_pdc_ip(const char *domain, struct sockaddr_storage *pss)
3030 {
3031         struct ip_service *ip_list = NULL;
3032         int count = 0;
3033         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
3034         static const char *ads_order[] = { "ads", NULL };
3035         /* Look up #1B name */
3036
3037         if (lp_security() == SEC_ADS) {
3038                 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
3039                                                &count, ads_order);
3040         }
3041
3042         if (!NT_STATUS_IS_OK(status) || count == 0) {
3043                 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
3044                                                &count,
3045                                                lp_name_resolve_order());
3046                 if (!NT_STATUS_IS_OK(status)) {
3047                         SAFE_FREE(ip_list);
3048                         return false;
3049                 }
3050         }
3051
3052         /* if we get more than 1 IP back we have to assume it is a
3053            multi-homed PDC and not a mess up */
3054
3055         if ( count > 1 ) {
3056                 DEBUG(6,("get_pdc_ip: PDC has %d IP addresses!\n", count));
3057                 sort_service_list(ip_list, count);
3058         }
3059
3060         *pss = ip_list[0].ss;
3061         SAFE_FREE(ip_list);
3062         return true;
3063 }
3064
3065 /* Private enum type for lookups. */
3066
3067 enum dc_lookup_type { DC_NORMAL_LOOKUP, DC_ADS_ONLY, DC_KDC_ONLY };
3068
3069 /********************************************************
3070  Get the IP address list of the domain controllers for
3071  a domain.
3072 *********************************************************/
3073
3074 static NTSTATUS get_dc_list(const char *domain,
3075                         const char *sitename,
3076                         struct ip_service **ip_list,
3077                         int *count,
3078                         enum dc_lookup_type lookup_type,
3079                         bool *ordered)
3080 {
3081         const char **resolve_order = NULL;
3082         char *saf_servername = NULL;
3083         char *pserver = NULL;
3084         const char *p;
3085         char *port_str = NULL;
3086         int port;
3087         char *name;
3088         int num_addresses = 0;
3089         int  local_count, i, j;
3090         struct ip_service *return_iplist = NULL;
3091         struct ip_service *auto_ip_list = NULL;
3092         bool done_auto_lookup = false;
3093         int auto_count = 0;
3094         NTSTATUS status;
3095         TALLOC_CTX *ctx = talloc_init("get_dc_list");
3096         int auto_name_type = 0x1C;
3097
3098         *ip_list = NULL;
3099         *count = 0;
3100
3101         if (!ctx) {
3102                 return NT_STATUS_NO_MEMORY;
3103         }
3104
3105         *ordered = False;
3106
3107         /* if we are restricted to solely using DNS for looking
3108            up a domain controller, make sure that host lookups
3109            are enabled for the 'name resolve order'.  If host lookups
3110            are disabled and ads_only is True, then set the string to
3111            NULL. */
3112
3113         resolve_order = lp_name_resolve_order();
3114         if (!resolve_order) {
3115                 status = NT_STATUS_NO_MEMORY;
3116                 goto out;
3117         }
3118         if (lookup_type == DC_ADS_ONLY)  {
3119                 if (str_list_check_ci(resolve_order, "host")) {
3120                         static const char *ads_order[] = { "ads", NULL };
3121                         resolve_order = ads_order;
3122
3123                         /* DNS SRV lookups used by the ads resolver
3124                            are already sorted by priority and weight */
3125                         *ordered = true;
3126                 } else {
3127                         /* this is quite bizarre! */
3128                         static const char *null_order[] = { "NULL", NULL };
3129                         resolve_order = null_order;
3130                 }
3131         } else if (lookup_type == DC_KDC_ONLY) {
3132                 static const char *kdc_order[] = { "kdc", NULL };
3133                 /* DNS SRV lookups used by the ads/kdc resolver
3134                    are already sorted by priority and weight */
3135                 *ordered = true;
3136                 resolve_order = kdc_order;
3137                 auto_name_type = KDC_NAME_TYPE;
3138         }
3139
3140         /* fetch the server we have affinity for.  Add the
3141            'password server' list to a search for our domain controllers */
3142
3143         saf_servername = saf_fetch(ctx, domain);
3144
3145         if (strequal(domain, lp_workgroup()) || strequal(domain, lp_realm())) {
3146                 pserver = talloc_asprintf(ctx, "%s, %s",
3147                         saf_servername ? saf_servername : "",
3148                         lp_password_server());
3149         } else {
3150                 pserver = talloc_asprintf(ctx, "%s, *",
3151                         saf_servername ? saf_servername : "");
3152         }
3153
3154         TALLOC_FREE(saf_servername);
3155         if (!pserver) {
3156                 status = NT_STATUS_NO_MEMORY;
3157                 goto out;
3158         }
3159
3160         DEBUG(3,("get_dc_list: preferred server list: \"%s\"\n", pserver ));
3161
3162         /*
3163          * if '*' appears in the "password server" list then add
3164          * an auto lookup to the list of manually configured
3165          * DC's.  If any DC is listed by name, then the list should be
3166          * considered to be ordered
3167          */
3168
3169         p = pserver;
3170         while (next_token_talloc(ctx, &p, &name, LIST_SEP)) {
3171                 if (!done_auto_lookup && strequal(name, "*")) {
3172                         status = internal_resolve_name(domain, auto_name_type,
3173                                                        sitename,
3174                                                        &auto_ip_list,
3175                                                        &auto_count,
3176                                                        resolve_order);
3177                         if (NT_STATUS_IS_OK(status)) {
3178                                 num_addresses += auto_count;
3179                         }
3180                         done_auto_lookup = true;
3181                         DEBUG(8,("Adding %d DC's from auto lookup\n",
3182                                                 auto_count));
3183                 } else  {
3184                         num_addresses++;
3185                 }
3186         }
3187
3188         /* if we have no addresses and haven't done the auto lookup, then
3189            just return the list of DC's.  Or maybe we just failed. */
3190
3191         if (num_addresses == 0) {
3192                 if (done_auto_lookup) {
3193                         DEBUG(4,("get_dc_list: no servers found\n"));
3194                         status = NT_STATUS_NO_LOGON_SERVERS;
3195                         goto out;
3196                 }
3197                 status = internal_resolve_name(domain, auto_name_type,
3198                                                sitename, ip_list,
3199                                              count, resolve_order);
3200                 goto out;
3201         }
3202
3203         if ((return_iplist = SMB_MALLOC_ARRAY(struct ip_service,
3204                                         num_addresses)) == NULL) {
3205                 DEBUG(3,("get_dc_list: malloc fail !\n"));
3206                 status = NT_STATUS_NO_MEMORY;
3207                 goto out;
3208         }
3209
3210         p = pserver;
3211         local_count = 0;
3212
3213         /* fill in the return list now with real IP's */
3214
3215         while ((local_count<num_addresses) &&
3216                         next_token_talloc(ctx, &p, &name, LIST_SEP)) {
3217                 struct sockaddr_storage name_ss;
3218
3219                 /* copy any addresses from the auto lookup */
3220
3221                 if (strequal(name, "*")) {
3222                         for (j=0; j<auto_count; j++) {
3223                                 char addr[INET6_ADDRSTRLEN];
3224                                 print_sockaddr(addr,
3225                                                 sizeof(addr),
3226                                                 &auto_ip_list[j].ss);
3227                                 /* Check for and don't copy any
3228                                  * known bad DC IP's. */
3229                                 if(!NT_STATUS_IS_OK(check_negative_conn_cache(
3230                                                 domain,
3231                                                 addr))) {
3232                                         DEBUG(5,("get_dc_list: "
3233                                                 "negative entry %s removed "
3234                                                 "from DC list\n",
3235                                                 addr));
3236                                         continue;
3237                                 }
3238                                 return_iplist[local_count].ss =
3239                                         auto_ip_list[j].ss;
3240                                 return_iplist[local_count].port =
3241                                         auto_ip_list[j].port;
3242                                 local_count++;
3243                         }
3244                         continue;
3245                 }
3246
3247                 /* added support for address:port syntax for ads
3248                  * (not that I think anyone will ever run the LDAP
3249                  * server in an AD domain on something other than
3250                  * port 389
3251                  * However, the port should not be used for kerberos
3252                  */
3253
3254                 port = (lookup_type == DC_ADS_ONLY) ? LDAP_PORT :
3255                         ((lookup_type == DC_KDC_ONLY) ? DEFAULT_KRB5_PORT :
3256                          PORT_NONE);
3257                 if ((port_str=strchr(name, ':')) != NULL) {
3258                         *port_str = '\0';
3259                         if (lookup_type != DC_KDC_ONLY) {
3260                                 port_str++;
3261                                 port = atoi(port_str);
3262                         }
3263                 }
3264
3265                 /* explicit lookup; resolve_name() will
3266                  * handle names & IP addresses */
3267                 if (resolve_name( name, &name_ss, 0x20, true )) {
3268                         char addr[INET6_ADDRSTRLEN];
3269                         print_sockaddr(addr,
3270                                         sizeof(addr),
3271                                         &name_ss);
3272
3273                         /* Check for and don't copy any known bad DC IP's. */
3274                         if( !NT_STATUS_IS_OK(check_negative_conn_cache(domain,
3275                                                         addr)) ) {
3276                                 DEBUG(5,("get_dc_list: negative entry %s "
3277                                         "removed from DC list\n",
3278                                         name ));
3279                                 continue;
3280                         }
3281
3282                         return_iplist[local_count].ss = name_ss;
3283                         return_iplist[local_count].port = port;
3284                         local_count++;
3285                         *ordered = true;
3286                 }
3287         }
3288
3289         /* need to remove duplicates in the list if we have any
3290            explicit password servers */
3291
3292         local_count = remove_duplicate_addrs2(return_iplist, local_count );
3293
3294         /* For DC's we always prioritize IPv4 due to W2K3 not
3295          * supporting LDAP, KRB5 or CLDAP over IPv6. */
3296
3297         if (local_count && return_iplist) {
3298                 prioritize_ipv4_list(return_iplist, local_count);
3299         }
3300
3301         if ( DEBUGLEVEL >= 4 ) {
3302                 DEBUG(4,("get_dc_list: returning %d ip addresses "
3303                                 "in an %sordered list\n",
3304                                 local_count,
3305                                 *ordered ? "":"un"));
3306                 DEBUG(4,("get_dc_list: "));
3307                 for ( i=0; i<local_count; i++ ) {
3308                         char addr[INET6_ADDRSTRLEN];
3309                         print_sockaddr(addr,
3310                                         sizeof(addr),
3311                                         &return_iplist[i].ss);
3312                         DEBUGADD(4,("%s:%d ", addr, return_iplist[i].port ));
3313                 }
3314                 DEBUGADD(4,("\n"));
3315         }
3316
3317         *ip_list = return_iplist;
3318         *count = local_count;
3319
3320         status = ( *count != 0 ? NT_STATUS_OK : NT_STATUS_NO_LOGON_SERVERS );
3321
3322   out:
3323
3324         if (!NT_STATUS_IS_OK(status)) {
3325                 SAFE_FREE(return_iplist);
3326                 *ip_list = NULL;
3327                 *count = 0;
3328         }
3329
3330         SAFE_FREE(auto_ip_list);
3331         TALLOC_FREE(ctx);
3332         return status;
3333 }
3334
3335 /*********************************************************************
3336  Small wrapper function to get the DC list and sort it if neccessary.
3337 *********************************************************************/
3338
3339 NTSTATUS get_sorted_dc_list( const char *domain,
3340                         const char *sitename,
3341                         struct ip_service **ip_list,
3342                         int *count,
3343                         bool ads_only )
3344 {
3345         bool ordered = false;
3346         NTSTATUS status;
3347         enum dc_lookup_type lookup_type = DC_NORMAL_LOOKUP;
3348
3349         *ip_list = NULL;
3350         *count = 0;
3351
3352         DEBUG(8,("get_sorted_dc_list: attempting lookup "
3353                 "for name %s (sitename %s)\n",
3354                 domain,
3355                  sitename ? sitename : "NULL"));
3356
3357         if (ads_only) {
3358                 lookup_type = DC_ADS_ONLY;
3359         }
3360
3361         status = get_dc_list(domain, sitename, ip_list,
3362                         count, lookup_type, &ordered);
3363         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_LOGON_SERVERS)
3364             && sitename) {
3365                 DEBUG(3,("get_sorted_dc_list: no server for name %s available"
3366                          " in site %s, fallback to all servers\n",
3367                          domain, sitename));
3368                 status = get_dc_list(domain, NULL, ip_list,
3369                                      count, lookup_type, &ordered);
3370         }
3371
3372         if (!NT_STATUS_IS_OK(status)) {
3373                 SAFE_FREE(*ip_list);
3374                 *count = 0;
3375                 return status;
3376         }
3377
3378         /* only sort if we don't already have an ordered list */
3379         if (!ordered) {
3380                 sort_service_list(*ip_list, *count);
3381         }
3382
3383         return NT_STATUS_OK;
3384 }
3385
3386 /*********************************************************************
3387  Get the KDC list - re-use all the logic in get_dc_list.
3388 *********************************************************************/
3389
3390 NTSTATUS get_kdc_list( const char *realm,
3391                         const char *sitename,
3392                         struct ip_service **ip_list,
3393                         int *count)
3394 {
3395         bool ordered;
3396         NTSTATUS status;
3397
3398         *count = 0;
3399         *ip_list = NULL;
3400
3401         status = get_dc_list(realm, sitename, ip_list,
3402                         count, DC_KDC_ONLY, &ordered);
3403
3404         if (!NT_STATUS_IS_OK(status)) {
3405                 SAFE_FREE(*ip_list);
3406                 *count = 0;
3407                 return status;
3408         }
3409
3410         /* only sort if we don't already have an ordered list */
3411         if ( !ordered ) {
3412                 sort_service_list(*ip_list, *count);
3413         }
3414
3415         return NT_STATUS_OK;
3416 }