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