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