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