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