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