?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4 dns: Implement RFC-compatible update prescan
[Samba/gebeck_regimport.git] / source3 / libsmb / namequery.c
blobdf7fdc3d9f4ca9fe7142c49fc43dc97c9a912ecb
1 /*
2 Unix SMB/CIFS implementation.
3 name query routines
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Jeremy Allison 2007.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "../lib/util/tevent_ntstatus.h"
23 #include "libads/sitename_cache.h"
24 #include "libads/dns.h"
25 #include "../libcli/netlogon/netlogon.h"
26 #include "lib/async_req/async_sock.h"
27 #include "libsmb/nmblib.h"
28 #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( 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, &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, &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_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 = 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 static 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 remove duplicates */
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 /* one loop to clean up any holes we left */
1128 /* first ip should never be a zero_ip() */
1129 for (i = 0; i<count; ) {
1130 if (is_zero_addr(&iplist[i].ss) ) {
1131 if (i != count-1) {
1132 memmove(&iplist[i], &iplist[i+1],
1133 (count - i - 1)*sizeof(iplist[i]));
1134 }
1135 count--;
1136 continue;
1137 }
1138 i++;
1139 }
1140
1141 return count;
1142 }
1143
1144 static bool prioritize_ipv4_list(struct ip_service *iplist, int count)
1145 {
1146 TALLOC_CTX *frame = talloc_stackframe();
1147 struct ip_service *iplist_new = talloc_array(frame, struct ip_service, count);
1148 int i, j;
1149
1150 if (iplist_new == NULL) {
1151 TALLOC_FREE(frame);
1152 return false;
1153 }
1154
1155 j = 0;
1156
1157 /* Copy IPv4 first. */
1158 for (i = 0; i < count; i++) {
1159 if (iplist[i].ss.ss_family == AF_INET) {
1160 iplist_new[j++] = iplist[i];
1161 }
1162 }
1163
1164 /* Copy IPv6. */
1165 for (i = 0; i < count; i++) {
1166 if (iplist[i].ss.ss_family != AF_INET) {
1167 iplist_new[j++] = iplist[i];
1168 }
1169 }
1170
1171 memcpy(iplist, iplist_new, sizeof(struct ip_service)*count);
1172 TALLOC_FREE(frame);
1173 return true;
1174 }
1175
1176 /****************************************************************************
1177 Do a netbios name query to find someones IP.
1178 Returns an array of IP addresses or NULL if none.
1179 *count will be set to the number of addresses returned.
1180 *timed_out is set if we failed by timing out
1181 ****************************************************************************/
1182
1183 struct name_query_state {
1184 struct sockaddr_storage my_addr;
1185 struct sockaddr_storage addr;
1186 bool bcast;
1187
1188
1189 uint8_t buf[1024];
1190 ssize_t buflen;
1191
1192 NTSTATUS validate_error;
1193 uint8_t flags;
1194
1195 struct sockaddr_storage *addrs;
1196 int num_addrs;
1197 };
1198
1199 static bool name_query_validator(struct packet_struct *p, void *private_data);
1200 static void name_query_done(struct tevent_req *subreq);
1201
1202 struct tevent_req *name_query_send(TALLOC_CTX *mem_ctx,
1203 struct tevent_context *ev,
1204 const char *name, int name_type,
1205 bool bcast, bool recurse,
1206 const struct sockaddr_storage *addr)
1207 {
1208 struct tevent_req *req, *subreq;
1209 struct name_query_state *state;
1210 struct packet_struct p;
1211 struct nmb_packet *nmb = &p.packet.nmb;
1212 struct sockaddr_in *in_addr;
1213
1214 req = tevent_req_create(mem_ctx, &state, struct name_query_state);
1215 if (req == NULL) {
1216 return NULL;
1217 }
1218 state->bcast = bcast;
1219
1220 if (addr->ss_family != AF_INET) {
1221 /* Can't do node status to IPv6 */
1222 tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
1223 return tevent_req_post(req, ev);
1224 }
1225
1226 if (lp_disable_netbios()) {
1227 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n",
1228 name, name_type));
1229 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
1230 return tevent_req_post(req, ev);
1231 }
1232
1233 state->addr = *addr;
1234 in_addr = (struct sockaddr_in *)(void *)&state->addr;
1235 in_addr->sin_port = htons(NMB_PORT);
1236
1237 set_socket_addr_v4(&state->my_addr);
1238
1239 ZERO_STRUCT(p);
1240 nmb->header.name_trn_id = generate_trn_id();
1241 nmb->header.opcode = 0;
1242 nmb->header.response = false;
1243 nmb->header.nm_flags.bcast = bcast;
1244 nmb->header.nm_flags.recursion_available = false;
1245 nmb->header.nm_flags.recursion_desired = recurse;
1246 nmb->header.nm_flags.trunc = false;
1247 nmb->header.nm_flags.authoritative = false;
1248 nmb->header.rcode = 0;
1249 nmb->header.qdcount = 1;
1250 nmb->header.ancount = 0;
1251 nmb->header.nscount = 0;
1252 nmb->header.arcount = 0;
1253
1254 make_nmb_name(&nmb->question.question_name,name,name_type);
1255
1256 nmb->question.question_type = 0x20;
1257 nmb->question.question_class = 0x1;
1258
1259 state->buflen = build_packet((char *)state->buf, sizeof(state->buf),
1260 &p);
1261 if (state->buflen == 0) {
1262 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1263 DEBUG(10, ("build_packet failed\n"));
1264 return tevent_req_post(req, ev);
1265 }
1266
1267 subreq = nb_trans_send(state, ev, &state->my_addr, &state->addr, bcast,
1268 state->buf, state->buflen,
1269 NMB_PACKET, nmb->header.name_trn_id,
1270 name_query_validator, state);
1271 if (tevent_req_nomem(subreq, req)) {
1272 DEBUG(10, ("nb_trans_send failed\n"));
1273 return tevent_req_post(req, ev);
1274 }
1275 tevent_req_set_callback(subreq, name_query_done, req);
1276 return req;
1277 }
1278
1279 static bool name_query_validator(struct packet_struct *p, void *private_data)
1280 {
1281 struct name_query_state *state = talloc_get_type_abort(
1282 private_data, struct name_query_state);
1283 struct nmb_packet *nmb = &p->packet.nmb;
1284 struct sockaddr_storage *tmp_addrs;
1285 bool got_unique_netbios_name = false;
1286 int i;
1287
1288 debug_nmb_packet(p);
1289
1290 /*
1291 * If we get a Negative Name Query Response from a WINS
1292 * server, we should report it and give up.
1293 */
1294 if( 0 == nmb->header.opcode /* A query response */
1295 && !state->bcast /* from a WINS server */
1296 && nmb->header.rcode /* Error returned */
1297 ) {
1298
1299 if( DEBUGLVL( 3 ) ) {
1300 /* Only executed if DEBUGLEVEL >= 3 */
1301 dbgtext( "Negative name query "
1302 "response, rcode 0x%02x: ",
1303 nmb->header.rcode );
1304 switch( nmb->header.rcode ) {
1305 case 0x01:
1306 dbgtext("Request was invalidly formatted.\n");
1307 break;
1308 case 0x02:
1309 dbgtext("Problem with NBNS, cannot process "
1310 "name.\n");
1311 break;
1312 case 0x03:
1313 dbgtext("The name requested does not "
1314 "exist.\n");
1315 break;
1316 case 0x04:
1317 dbgtext("Unsupported request error.\n");
1318 break;
1319 case 0x05:
1320 dbgtext("Query refused error.\n");
1321 break;
1322 default:
1323 dbgtext("Unrecognized error code.\n" );
1324 break;
1325 }
1326 }
1327
1328 /*
1329 * We accept this packet as valid, but tell the upper
1330 * layers that it's a negative response.
1331 */
1332 state->validate_error = NT_STATUS_NOT_FOUND;
1333 return true;
1334 }
1335
1336 if (nmb->header.opcode != 0 ||
1337 nmb->header.nm_flags.bcast ||
1338 nmb->header.rcode ||
1339 !nmb->header.ancount) {
1340 /*
1341 * XXXX what do we do with this? Could be a redirect,
1342 * but we'll discard it for the moment.
1343 */
1344 return false;
1345 }
1346
1347 tmp_addrs = talloc_realloc(
1348 state, state->addrs, struct sockaddr_storage,
1349 state->num_addrs + nmb->answers->rdlength/6);
1350 if (tmp_addrs == NULL) {
1351 state->validate_error = NT_STATUS_NO_MEMORY;
1352 return true;
1353 }
1354 state->addrs = tmp_addrs;
1355
1356 DEBUG(2,("Got a positive name query response "
1357 "from %s ( ", inet_ntoa(p->ip)));
1358
1359 for (i=0; i<nmb->answers->rdlength/6; i++) {
1360 uint16_t flags;
1361 struct in_addr ip;
1362 struct sockaddr_storage addr;
1363 int j;
1364
1365 flags = RSVAL(&nmb->answers->rdata[i*6], 0);
1366 got_unique_netbios_name |= ((flags & 0x8000) == 0);
1367
1368 putip((char *)&ip,&nmb->answers->rdata[2+i*6]);
1369 in_addr_to_sockaddr_storage(&addr, ip);
1370
1371 for (j=0; j<state->num_addrs; j++) {
1372 if (sockaddr_equal(
1373 (struct sockaddr *)(void *)&addr,
1374 (struct sockaddr *)(void *)&state->addrs[j])) {
1375 break;
1376 }
1377 }
1378 if (j < state->num_addrs) {
1379 /* Already got it */
1380 continue;
1381 }
1382
1383 DEBUGADD(2,("%s ",inet_ntoa(ip)));
1384
1385 state->addrs[state->num_addrs] = addr;
1386 state->num_addrs += 1;
1387 }
1388 DEBUGADD(2,(")\n"));
1389
1390 /* We add the flags back ... */
1391 if (nmb->header.response)
1392 state->flags |= NM_FLAGS_RS;
1393 if (nmb->header.nm_flags.authoritative)
1394 state->flags |= NM_FLAGS_AA;
1395 if (nmb->header.nm_flags.trunc)
1396 state->flags |= NM_FLAGS_TC;
1397 if (nmb->header.nm_flags.recursion_desired)
1398 state->flags |= NM_FLAGS_RD;
1399 if (nmb->header.nm_flags.recursion_available)
1400 state->flags |= NM_FLAGS_RA;
1401 if (nmb->header.nm_flags.bcast)
1402 state->flags |= NM_FLAGS_B;
1403
1404 if (state->bcast) {
1405 /*
1406 * We have to collect all entries coming in from broadcast
1407 * queries. If we got a unique name, we're done.
1408 */
1409 return got_unique_netbios_name;
1410 }
1411 /*
1412 * WINS responses are accepted when they are received
1413 */
1414 return true;
1415 }
1416
1417 static void name_query_done(struct tevent_req *subreq)
1418 {
1419 struct tevent_req *req = tevent_req_callback_data(
1420 subreq, struct tevent_req);
1421 struct name_query_state *state = tevent_req_data(
1422 req, struct name_query_state);
1423 NTSTATUS status;
1424 struct packet_struct *p = NULL;
1425
1426 status = nb_trans_recv(subreq, &p);
1427 TALLOC_FREE(subreq);
1428 if (tevent_req_nterror(req, status)) {
1429 return;
1430 }
1431 if (!NT_STATUS_IS_OK(state->validate_error)) {
1432 tevent_req_nterror(req, state->validate_error);
1433 return;
1434 }
1435 if (p != NULL) {
1436 /*
1437 * Free the packet here, we've collected the response in the
1438 * validator
1439 */
1440 free_packet(p);
1441 }
1442 tevent_req_done(req);
1443 }
1444
1445 NTSTATUS name_query_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1446 struct sockaddr_storage **addrs, int *num_addrs,
1447 uint8_t *flags)
1448 {
1449 struct name_query_state *state = tevent_req_data(
1450 req, struct name_query_state);
1451 NTSTATUS status;
1452
1453 if (tevent_req_is_nterror(req, &status)) {
1454 if (state->bcast &&
1455 NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
1456 /*
1457 * In the broadcast case we collect replies until the
1458 * timeout.
1459 */
1460 status = NT_STATUS_OK;
1461 }
1462 if (!NT_STATUS_IS_OK(status)) {
1463 return status;
1464 }
1465 }
1466 if (state->num_addrs == 0) {
1467 return NT_STATUS_NOT_FOUND;
1468 }
1469 *addrs = talloc_move(mem_ctx, &state->addrs);
1470 sort_addr_list(*addrs, state->num_addrs);
1471 *num_addrs = state->num_addrs;
1472 if (flags != NULL) {
1473 *flags = state->flags;
1474 }
1475 return NT_STATUS_OK;
1476 }
1477
1478 NTSTATUS name_query(const char *name, int name_type,
1479 bool bcast, bool recurse,
1480 const struct sockaddr_storage *to_ss,
1481 TALLOC_CTX *mem_ctx,
1482 struct sockaddr_storage **addrs,
1483 int *num_addrs, uint8_t *flags)
1484 {
1485 TALLOC_CTX *frame = talloc_stackframe();
1486 struct tevent_context *ev;
1487 struct tevent_req *req;
1488 struct timeval timeout;
1489 NTSTATUS status = NT_STATUS_NO_MEMORY;
1490
1491 ev = tevent_context_init(frame);
1492 if (ev == NULL) {
1493 goto fail;
1494 }
1495 req = name_query_send(ev, ev, name, name_type, bcast, recurse, to_ss);
1496 if (req == NULL) {
1497 goto fail;
1498 }
1499 if (bcast) {
1500 timeout = timeval_current_ofs(0, 250000);
1501 } else {
1502 timeout = timeval_current_ofs(2, 0);
1503 }
1504 if (!tevent_req_set_endtime(req, ev, timeout)) {
1505 goto fail;
1506 }
1507 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1508 goto fail;
1509 }
1510 status = name_query_recv(req, mem_ctx, addrs, num_addrs, flags);
1511 fail:
1512 TALLOC_FREE(frame);
1513 return status;
1514 }
1515
1516 /********************************************************
1517 convert an array if struct sockaddr_storage to struct ip_service
1518 return false on failure. Port is set to PORT_NONE;
1519 *********************************************************/
1520
1521 static bool convert_ss2service(struct ip_service **return_iplist,
1522 const struct sockaddr_storage *ss_list,
1523 int count)
1524 {
1525 int i;
1526
1527 if ( count==0 || !ss_list )
1528 return False;
1529
1530 /* copy the ip address; port will be PORT_NONE */
1531 if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, count)) ==
1532 NULL) {
1533 DEBUG(0,("convert_ip2service: malloc failed "
1534 "for %d enetries!\n", count ));
1535 return False;
1536 }
1537
1538 for ( i=0; i<count; i++ ) {
1539 (*return_iplist)[i].ss = ss_list[i];
1540 (*return_iplist)[i].port = PORT_NONE;
1541 }
1542
1543 return true;
1544 }
1545
1546 struct name_queries_state {
1547 struct tevent_context *ev;
1548 const char *name;
1549 int name_type;
1550 bool bcast;
1551 bool recurse;
1552 const struct sockaddr_storage *addrs;
1553 int num_addrs;
1554 int wait_msec;
1555 int timeout_msec;
1556
1557 struct tevent_req **subreqs;
1558 int num_received;
1559 int num_sent;
1560
1561 int received_index;
1562 struct sockaddr_storage *result_addrs;
1563 int num_result_addrs;
1564 uint8_t flags;
1565 };
1566
1567 static void name_queries_done(struct tevent_req *subreq);
1568 static void name_queries_next(struct tevent_req *subreq);
1569
1570 /*
1571 * Send a name query to multiple destinations with a wait time in between
1572 */
1573
1574 static struct tevent_req *name_queries_send(
1575 TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1576 const char *name, int name_type,
1577 bool bcast, bool recurse,
1578 const struct sockaddr_storage *addrs,
1579 int num_addrs, int wait_msec, int timeout_msec)
1580 {
1581 struct tevent_req *req, *subreq;
1582 struct name_queries_state *state;
1583
1584 req = tevent_req_create(mem_ctx, &state,
1585 struct name_queries_state);
1586 if (req == NULL) {
1587 return NULL;
1588 }
1589 state->ev = ev;
1590 state->name = name;
1591 state->name_type = name_type;
1592 state->bcast = bcast;
1593 state->recurse = recurse;
1594 state->addrs = addrs;
1595 state->num_addrs = num_addrs;
1596 state->wait_msec = wait_msec;
1597 state->timeout_msec = timeout_msec;
1598
1599 state->subreqs = talloc_zero_array(
1600 state, struct tevent_req *, num_addrs);
1601 if (tevent_req_nomem(state->subreqs, req)) {
1602 return tevent_req_post(req, ev);
1603 }
1604 state->num_sent = 0;
1605
1606 subreq = name_query_send(
1607 state->subreqs, state->ev, name, name_type, bcast, recurse,
1608 &state->addrs[state->num_sent]);
1609 if (tevent_req_nomem(subreq, req)) {
1610 return tevent_req_post(req, ev);
1611 }
1612 if (!tevent_req_set_endtime(
1613 subreq, state->ev,
1614 timeval_current_ofs(0, state->timeout_msec * 1000))) {
1615 tevent_req_oom(req);
1616 return tevent_req_post(req, ev);
1617 }
1618 tevent_req_set_callback(subreq, name_queries_done, req);
1619
1620 state->subreqs[state->num_sent] = subreq;
1621 state->num_sent += 1;
1622
1623 if (state->num_sent < state->num_addrs) {
1624 subreq = tevent_wakeup_send(
1625 state, state->ev,
1626 timeval_current_ofs(0, state->wait_msec * 1000));
1627 if (tevent_req_nomem(subreq, req)) {
1628 return tevent_req_post(req, ev);
1629 }
1630 tevent_req_set_callback(subreq, name_queries_next, req);
1631 }
1632 return req;
1633 }
1634
1635 static void name_queries_done(struct tevent_req *subreq)
1636 {
1637 struct tevent_req *req = tevent_req_callback_data(
1638 subreq, struct tevent_req);
1639 struct name_queries_state *state = tevent_req_data(
1640 req, struct name_queries_state);
1641 int i;
1642 NTSTATUS status;
1643
1644 status = name_query_recv(subreq, state, &state->result_addrs,
1645 &state->num_result_addrs, &state->flags);
1646
1647 for (i=0; i<state->num_sent; i++) {
1648 if (state->subreqs[i] == subreq) {
1649 break;
1650 }
1651 }
1652 if (i == state->num_sent) {
1653 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1654 return;
1655 }
1656 TALLOC_FREE(state->subreqs[i]);
1657
1658 state->num_received += 1;
1659
1660 if (!NT_STATUS_IS_OK(status)) {
1661
1662 if (state->num_received >= state->num_addrs) {
1663 tevent_req_nterror(req, status);
1664 return;
1665 }
1666 /*
1667 * Still outstanding requests, just wait
1668 */
1669 return;
1670 }
1671 state->received_index = i;
1672 tevent_req_done(req);
1673 }
1674
1675 static void name_queries_next(struct tevent_req *subreq)
1676 {
1677 struct tevent_req *req = tevent_req_callback_data(
1678 subreq, struct tevent_req);
1679 struct name_queries_state *state = tevent_req_data(
1680 req, struct name_queries_state);
1681
1682 if (!tevent_wakeup_recv(subreq)) {
1683 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1684 return;
1685 }
1686
1687 subreq = name_query_send(
1688 state->subreqs, state->ev,
1689 state->name, state->name_type, state->bcast, state->recurse,
1690 &state->addrs[state->num_sent]);
1691 if (tevent_req_nomem(subreq, req)) {
1692 return;
1693 }
1694 tevent_req_set_callback(subreq, name_queries_done, req);
1695 if (!tevent_req_set_endtime(
1696 subreq, state->ev,
1697 timeval_current_ofs(0, state->timeout_msec * 1000))) {
1698 tevent_req_oom(req);
1699 return;
1700 }
1701 state->subreqs[state->num_sent] = subreq;
1702 state->num_sent += 1;
1703
1704 if (state->num_sent < state->num_addrs) {
1705 subreq = tevent_wakeup_send(
1706 state, state->ev,
1707 timeval_current_ofs(0, state->wait_msec * 1000));
1708 if (tevent_req_nomem(subreq, req)) {
1709 return;
1710 }
1711 tevent_req_set_callback(subreq, name_queries_next, req);
1712 }
1713 }
1714
1715 static NTSTATUS name_queries_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1716 struct sockaddr_storage **result_addrs,
1717 int *num_result_addrs, uint8_t *flags,
1718 int *received_index)
1719 {
1720 struct name_queries_state *state = tevent_req_data(
1721 req, struct name_queries_state);
1722 NTSTATUS status;
1723
1724 if (tevent_req_is_nterror(req, &status)) {
1725 return status;
1726 }
1727
1728 if (result_addrs != NULL) {
1729 *result_addrs = talloc_move(mem_ctx, &state->result_addrs);
1730 }
1731 if (num_result_addrs != NULL) {
1732 *num_result_addrs = state->num_result_addrs;
1733 }
1734 if (flags != NULL) {
1735 *flags = state->flags;
1736 }
1737 if (received_index != NULL) {
1738 *received_index = state->received_index;
1739 }
1740 return NT_STATUS_OK;
1741 }
1742
1743 /********************************************************
1744 Resolve via "bcast" method.
1745 *********************************************************/
1746
1747 struct name_resolve_bcast_state {
1748 struct sockaddr_storage *addrs;
1749 int num_addrs;
1750 };
1751
1752 static void name_resolve_bcast_done(struct tevent_req *subreq);
1753
1754 struct tevent_req *name_resolve_bcast_send(TALLOC_CTX *mem_ctx,
1755 struct tevent_context *ev,
1756 const char *name,
1757 int name_type)
1758 {
1759 struct tevent_req *req, *subreq;
1760 struct name_resolve_bcast_state *state;
1761 struct sockaddr_storage *bcast_addrs;
1762 int i, num_addrs, num_bcast_addrs;
1763
1764 req = tevent_req_create(mem_ctx, &state,
1765 struct name_resolve_bcast_state);
1766 if (req == NULL) {
1767 return NULL;
1768 }
1769
1770 if (lp_disable_netbios()) {
1771 DEBUG(5, ("name_resolve_bcast(%s#%02x): netbios is disabled\n",
1772 name, name_type));
1773 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
1774 return tevent_req_post(req, ev);
1775 }
1776
1777 /*
1778 * "bcast" means do a broadcast lookup on all the local interfaces.
1779 */
1780
1781 DEBUG(3, ("name_resolve_bcast: Attempting broadcast lookup "
1782 "for name %s<0x%x>\n", name, name_type));
1783
1784 num_addrs = iface_count();
1785 bcast_addrs = talloc_array(state, struct sockaddr_storage, num_addrs);
1786 if (tevent_req_nomem(bcast_addrs, req)) {
1787 return tevent_req_post(req, ev);
1788 }
1789
1790 /*
1791 * Lookup the name on all the interfaces, return on
1792 * the first successful match.
1793 */
1794 num_bcast_addrs = 0;
1795
1796 for (i=0; i<num_addrs; i++) {
1797 const struct sockaddr_storage *pss = iface_n_bcast(i);
1798
1799 if (pss->ss_family != AF_INET) {
1800 continue;
1801 }
1802 bcast_addrs[num_bcast_addrs] = *pss;
1803 num_bcast_addrs += 1;
1804 }
1805
1806 subreq = name_queries_send(state, ev, name, name_type, true, true,
1807 bcast_addrs, num_bcast_addrs, 0, 1000);
1808 if (tevent_req_nomem(subreq, req)) {
1809 return tevent_req_post(req, ev);
1810 }
1811 tevent_req_set_callback(subreq, name_resolve_bcast_done, req);
1812 return req;
1813 }
1814
1815 static void name_resolve_bcast_done(struct tevent_req *subreq)
1816 {
1817 struct tevent_req *req = tevent_req_callback_data(
1818 subreq, struct tevent_req);
1819 struct name_resolve_bcast_state *state = tevent_req_data(
1820 req, struct name_resolve_bcast_state);
1821 NTSTATUS status;
1822
1823 status = name_queries_recv(subreq, state,
1824 &state->addrs, &state->num_addrs,
1825 NULL, NULL);
1826 TALLOC_FREE(subreq);
1827 if (tevent_req_nterror(req, status)) {
1828 return;
1829 }
1830 tevent_req_done(req);
1831 }
1832
1833 NTSTATUS name_resolve_bcast_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
1834 struct sockaddr_storage **addrs,
1835 int *num_addrs)
1836 {
1837 struct name_resolve_bcast_state *state = tevent_req_data(
1838 req, struct name_resolve_bcast_state);
1839 NTSTATUS status;
1840
1841 if (tevent_req_is_nterror(req, &status)) {
1842 return status;
1843 }
1844 *addrs = talloc_move(mem_ctx, &state->addrs);
1845 *num_addrs = state->num_addrs;
1846 return NT_STATUS_OK;
1847 }
1848
1849 NTSTATUS name_resolve_bcast(const char *name,
1850 int name_type,
1851 TALLOC_CTX *mem_ctx,
1852 struct sockaddr_storage **return_iplist,
1853 int *return_count)
1854 {
1855 TALLOC_CTX *frame = talloc_stackframe();
1856 struct event_context *ev;
1857 struct tevent_req *req;
1858 NTSTATUS status = NT_STATUS_NO_MEMORY;
1859
1860 ev = event_context_init(frame);
1861 if (ev == NULL) {
1862 goto fail;
1863 }
1864 req = name_resolve_bcast_send(frame, ev, name, name_type);
1865 if (req == NULL) {
1866 goto fail;
1867 }
1868 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1869 goto fail;
1870 }
1871 status = name_resolve_bcast_recv(req, mem_ctx, return_iplist,
1872 return_count);
1873 fail:
1874 TALLOC_FREE(frame);
1875 return status;
1876 }
1877
1878 struct query_wins_list_state {
1879 struct tevent_context *ev;
1880 const char *name;
1881 uint8_t name_type;
1882 struct in_addr *servers;
1883 uint32_t num_servers;
1884 struct sockaddr_storage server;
1885 uint32_t num_sent;
1886
1887 struct sockaddr_storage *addrs;
1888 int num_addrs;
1889 uint8_t flags;
1890 };
1891
1892 static void query_wins_list_done(struct tevent_req *subreq);
1893
1894 /*
1895 * Query a list of (replicating) wins servers in sequence, call them
1896 * dead if they don't reply
1897 */
1898
1899 static struct tevent_req *query_wins_list_send(
1900 TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1901 struct in_addr src_ip, const char *name, uint8_t name_type,
1902 struct in_addr *servers, int num_servers)
1903 {
1904 struct tevent_req *req, *subreq;
1905 struct query_wins_list_state *state;
1906
1907 req = tevent_req_create(mem_ctx, &state,
1908 struct query_wins_list_state);
1909 if (req == NULL) {
1910 return NULL;
1911 }
1912 state->ev = ev;
1913 state->name = name;
1914 state->name_type = name_type;
1915 state->servers = servers;
1916 state->num_servers = num_servers;
1917
1918 if (state->num_servers == 0) {
1919 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
1920 return tevent_req_post(req, ev);
1921 }
1922
1923 in_addr_to_sockaddr_storage(
1924 &state->server, state->servers[state->num_sent]);
1925
1926 subreq = name_query_send(state, state->ev,
1927 state->name, state->name_type,
1928 false, true, &state->server);
1929 state->num_sent += 1;
1930 if (tevent_req_nomem(subreq, req)) {
1931 return tevent_req_post(req, ev);
1932 }
1933 if (!tevent_req_set_endtime(subreq, state->ev,
1934 timeval_current_ofs(2, 0))) {
1935 tevent_req_oom(req);
1936 return tevent_req_post(req, ev);
1937 }
1938 tevent_req_set_callback(subreq, query_wins_list_done, req);
1939 return req;
1940 }
1941
1942 static void query_wins_list_done(struct tevent_req *subreq)
1943 {
1944 struct tevent_req *req = tevent_req_callback_data(
1945 subreq, struct tevent_req);
1946 struct query_wins_list_state *state = tevent_req_data(
1947 req, struct query_wins_list_state);
1948 NTSTATUS status;
1949
1950 status = name_query_recv(subreq, state,
1951 &state->addrs, &state->num_addrs,
1952 &state->flags);
1953 TALLOC_FREE(subreq);
1954 if (NT_STATUS_IS_OK(status)) {
1955 tevent_req_done(req);
1956 return;
1957 }
1958 if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
1959 tevent_req_nterror(req, status);
1960 return;
1961 }
1962 wins_srv_died(state->servers[state->num_sent-1],
1963 my_socket_addr_v4());
1964
1965 if (state->num_sent == state->num_servers) {
1966 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
1967 return;
1968 }
1969
1970 in_addr_to_sockaddr_storage(
1971 &state->server, state->servers[state->num_sent]);
1972
1973 subreq = name_query_send(state, state->ev,
1974 state->name, state->name_type,
1975 false, true, &state->server);
1976 state->num_sent += 1;
1977 if (tevent_req_nomem(subreq, req)) {
1978 return;
1979 }
1980 if (!tevent_req_set_endtime(subreq, state->ev,
1981 timeval_current_ofs(2, 0))) {
1982 tevent_req_oom(req);
1983 return;
1984 }
1985 tevent_req_set_callback(subreq, query_wins_list_done, req);
1986 }
1987
1988 static NTSTATUS query_wins_list_recv(struct tevent_req *req,
1989 TALLOC_CTX *mem_ctx,
1990 struct sockaddr_storage **addrs,
1991 int *num_addrs,
1992 uint8_t *flags)
1993 {
1994 struct query_wins_list_state *state = tevent_req_data(
1995 req, struct query_wins_list_state);
1996 NTSTATUS status;
1997
1998 if (tevent_req_is_nterror(req, &status)) {
1999 return status;
2000 }
2001 if (addrs != NULL) {
2002 *addrs = talloc_move(mem_ctx, &state->addrs);
2003 }
2004 if (num_addrs != NULL) {
2005 *num_addrs = state->num_addrs;
2006 }
2007 if (flags != NULL) {
2008 *flags = state->flags;
2009 }
2010 return NT_STATUS_OK;
2011 }
2012
2013 struct resolve_wins_state {
2014 int num_sent;
2015 int num_received;
2016
2017 struct sockaddr_storage *addrs;
2018 int num_addrs;
2019 uint8_t flags;
2020 };
2021
2022 static void resolve_wins_done(struct tevent_req *subreq);
2023
2024 struct tevent_req *resolve_wins_send(TALLOC_CTX *mem_ctx,
2025 struct tevent_context *ev,
2026 const char *name,
2027 int name_type)
2028 {
2029 struct tevent_req *req, *subreq;
2030 struct resolve_wins_state *state;
2031 char **wins_tags = NULL;
2032 struct sockaddr_storage src_ss;
2033 struct in_addr src_ip;
2034 int i, num_wins_tags;
2035
2036 req = tevent_req_create(mem_ctx, &state,
2037 struct resolve_wins_state);
2038 if (req == NULL) {
2039 return NULL;
2040 }
2041
2042 if (wins_srv_count() < 1) {
2043 DEBUG(3,("resolve_wins: WINS server resolution selected "
2044 "and no WINS servers listed.\n"));
2045 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2046 goto fail;
2047 }
2048
2049 /* the address we will be sending from */
2050 if (!interpret_string_addr(&src_ss, lp_socket_address(),
2051 AI_NUMERICHOST|AI_PASSIVE)) {
2052 zero_sockaddr(&src_ss);
2053 }
2054
2055 if (src_ss.ss_family != AF_INET) {
2056 char addr[INET6_ADDRSTRLEN];
2057 print_sockaddr(addr, sizeof(addr), &src_ss);
2058 DEBUG(3,("resolve_wins: cannot receive WINS replies "
2059 "on IPv6 address %s\n",
2060 addr));
2061 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2062 goto fail;
2063 }
2064
2065 src_ip = ((const struct sockaddr_in *)(void *)&src_ss)->sin_addr;
2066
2067 wins_tags = wins_srv_tags();
2068 if (wins_tags == NULL) {
2069 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2070 goto fail;
2071 }
2072
2073 num_wins_tags = 0;
2074 while (wins_tags[num_wins_tags] != NULL) {
2075 num_wins_tags += 1;
2076 }
2077
2078 for (i=0; i<num_wins_tags; i++) {
2079 int num_servers, num_alive;
2080 struct in_addr *servers, *alive;
2081 int j;
2082
2083 if (!wins_server_tag_ips(wins_tags[i], talloc_tos(),
2084 &servers, &num_servers)) {
2085 DEBUG(10, ("wins_server_tag_ips failed for tag %s\n",
2086 wins_tags[i]));
2087 continue;
2088 }
2089
2090 alive = talloc_array(state, struct in_addr, num_servers);
2091 if (tevent_req_nomem(alive, req)) {
2092 goto fail;
2093 }
2094
2095 num_alive = 0;
2096 for (j=0; j<num_servers; j++) {
2097 struct in_addr wins_ip = servers[j];
2098
2099 if (global_in_nmbd && ismyip_v4(wins_ip)) {
2100 /* yikes! we'll loop forever */
2101 continue;
2102 }
2103 /* skip any that have been unresponsive lately */
2104 if (wins_srv_is_dead(wins_ip, src_ip)) {
2105 continue;
2106 }
2107 DEBUG(3, ("resolve_wins: using WINS server %s "
2108 "and tag '%s'\n",
2109 inet_ntoa(wins_ip), wins_tags[i]));
2110 alive[num_alive] = wins_ip;
2111 num_alive += 1;
2112 }
2113 TALLOC_FREE(servers);
2114
2115 if (num_alive == 0) {
2116 continue;
2117 }
2118
2119 subreq = query_wins_list_send(
2120 state, ev, src_ip, name, name_type,
2121 alive, num_alive);
2122 if (tevent_req_nomem(subreq, req)) {
2123 goto fail;
2124 }
2125 tevent_req_set_callback(subreq, resolve_wins_done, req);
2126 state->num_sent += 1;
2127 }
2128
2129 if (state->num_sent == 0) {
2130 tevent_req_nterror(req, NT_STATUS_NOT_FOUND);
2131 goto fail;
2132 }
2133
2134 wins_srv_tags_free(wins_tags);
2135 return req;
2136 fail:
2137 wins_srv_tags_free(wins_tags);
2138 return tevent_req_post(req, ev);
2139 }
2140
2141 static void resolve_wins_done(struct tevent_req *subreq)
2142 {
2143 struct tevent_req *req = tevent_req_callback_data(
2144 subreq, struct tevent_req);
2145 struct resolve_wins_state *state = tevent_req_data(
2146 req, struct resolve_wins_state);
2147 NTSTATUS status;
2148
2149 status = query_wins_list_recv(subreq, state, &state->addrs,
2150 &state->num_addrs, &state->flags);
2151 if (NT_STATUS_IS_OK(status)) {
2152 tevent_req_done(req);
2153 return;
2154 }
2155
2156 state->num_received += 1;
2157
2158 if (state->num_received < state->num_sent) {
2159 /*
2160 * Wait for the others
2161 */
2162 return;
2163 }
2164 tevent_req_nterror(req, status);
2165 }
2166
2167 NTSTATUS resolve_wins_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
2168 struct sockaddr_storage **addrs,
2169 int *num_addrs, uint8_t *flags)
2170 {
2171 struct resolve_wins_state *state = tevent_req_data(
2172 req, struct resolve_wins_state);
2173 NTSTATUS status;
2174
2175 if (tevent_req_is_nterror(req, &status)) {
2176 return status;
2177 }
2178 if (addrs != NULL) {
2179 *addrs = talloc_move(mem_ctx, &state->addrs);
2180 }
2181 if (num_addrs != NULL) {
2182 *num_addrs = state->num_addrs;
2183 }
2184 if (flags != NULL) {
2185 *flags = state->flags;
2186 }
2187 return NT_STATUS_OK;
2188 }
2189
2190 /********************************************************
2191 Resolve via "wins" method.
2192 *********************************************************/
2193
2194 NTSTATUS resolve_wins(const char *name,
2195 int name_type,
2196 TALLOC_CTX *mem_ctx,
2197 struct sockaddr_storage **return_iplist,
2198 int *return_count)
2199 {
2200 struct tevent_context *ev;
2201 struct tevent_req *req;
2202 NTSTATUS status = NT_STATUS_NO_MEMORY;
2203
2204 ev = tevent_context_init(talloc_tos());
2205 if (ev == NULL) {
2206 goto fail;
2207 }
2208 req = resolve_wins_send(ev, ev, name, name_type);
2209 if (req == NULL) {
2210 goto fail;
2211 }
2212 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2213 goto fail;
2214 }
2215 status = resolve_wins_recv(req, mem_ctx, return_iplist, return_count,
2216 NULL);
2217 fail:
2218 TALLOC_FREE(ev);
2219 return status;
2220 }
2221
2222 /********************************************************
2223 Resolve via "lmhosts" method.
2224 *********************************************************/
2225
2226 static NTSTATUS resolve_lmhosts(const char *name, int name_type,
2227 struct ip_service **return_iplist,
2228 int *return_count)
2229 {
2230 /*
2231 * "lmhosts" means parse the local lmhosts file.
2232 */
2233 struct sockaddr_storage *ss_list;
2234 NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
2235 TALLOC_CTX *ctx = NULL;
2236
2237 *return_iplist = NULL;
2238 *return_count = 0;
2239
2240 DEBUG(3,("resolve_lmhosts: "
2241 "Attempting lmhosts lookup for name %s<0x%x>\n",
2242 name, name_type));
2243
2244 ctx = talloc_init("resolve_lmhosts");
2245 if (!ctx) {
2246 return NT_STATUS_NO_MEMORY;
2247 }
2248
2249 status = resolve_lmhosts_file_as_sockaddr(get_dyn_LMHOSTSFILE(),
2250 name, name_type,
2251 ctx,
2252 &ss_list,
2253 return_count);
2254 if (NT_STATUS_IS_OK(status)) {
2255 if (convert_ss2service(return_iplist,
2256 ss_list,
2257 *return_count)) {
2258 talloc_free(ctx);
2259 return NT_STATUS_OK;
2260 } else {
2261 talloc_free(ctx);
2262 return NT_STATUS_NO_MEMORY;
2263 }
2264 }
2265 talloc_free(ctx);
2266 return status;
2267 }
2268
2269
2270 /********************************************************
2271 Resolve via "hosts" method.
2272 *********************************************************/
2273
2274 static NTSTATUS resolve_hosts(const char *name, int name_type,
2275 struct ip_service **return_iplist,
2276 int *return_count)
2277 {
2278 /*
2279 * "host" means do a localhost, or dns lookup.
2280 */
2281 struct addrinfo hints;
2282 struct addrinfo *ailist = NULL;
2283 struct addrinfo *res = NULL;
2284 int ret = -1;
2285 int i = 0;
2286 const char *dns_hosts_file;
2287
2288 if ( name_type != 0x20 && name_type != 0x0) {
2289 DEBUG(5, ("resolve_hosts: not appropriate "
2290 "for name type <0x%x>\n",
2291 name_type));
2292 return NT_STATUS_INVALID_PARAMETER;
2293 }
2294
2295 *return_iplist = NULL;
2296 *return_count = 0;
2297
2298 DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n",
2299 name, name_type));
2300
2301 ZERO_STRUCT(hints);
2302 /* By default make sure it supports TCP. */
2303 hints.ai_socktype = SOCK_STREAM;
2304 hints.ai_flags = AI_ADDRCONFIG;
2305
2306 #if !defined(HAVE_IPV6)
2307 /* Unless we have IPv6, we really only want IPv4 addresses back. */
2308 hints.ai_family = AF_INET;
2309 #endif
2310
2311 dns_hosts_file = lp_parm_const_string(-1, "resolv", "host file", NULL);
2312 if (dns_hosts_file) {
2313 struct sockaddr_storage *ss_list;
2314 NTSTATUS status;
2315 TALLOC_CTX *ctx = talloc_stackframe();
2316 if (!ctx) {
2317 return NT_STATUS_NO_MEMORY;
2318 }
2319
2320 status = resolve_dns_hosts_file_as_sockaddr(dns_hosts_file, name, false,
2321 ctx, &ss_list, return_count);
2322 if (NT_STATUS_IS_OK(status)) {
2323 if (convert_ss2service(return_iplist,
2324 ss_list,
2325 *return_count)) {
2326 talloc_free(ctx);
2327 return NT_STATUS_OK;
2328 } else {
2329 talloc_free(ctx);
2330 return NT_STATUS_NO_MEMORY;
2331 }
2332 }
2333 talloc_free(ctx);
2334 return NT_STATUS_UNSUCCESSFUL;
2335 }
2336
2337 ret = getaddrinfo(name,
2338 NULL,
2339 &hints,
2340 &ailist);
2341 if (ret) {
2342 DEBUG(3,("resolve_hosts: getaddrinfo failed for name %s [%s]\n",
2343 name,
2344 gai_strerror(ret) ));
2345 }
2346
2347 for (res = ailist; res; res = res->ai_next) {
2348 struct sockaddr_storage ss;
2349
2350 if (!res->ai_addr || res->ai_addrlen == 0) {
2351 continue;
2352 }
2353
2354 ZERO_STRUCT(ss);
2355 memcpy(&ss, res->ai_addr, res->ai_addrlen);
2356
2357 *return_count += 1;
2358
2359 *return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
2360 struct ip_service,
2361 *return_count);
2362 if (!*return_iplist) {
2363 DEBUG(3,("resolve_hosts: malloc fail !\n"));
2364 freeaddrinfo(ailist);
2365 return NT_STATUS_NO_MEMORY;
2366 }
2367 (*return_iplist)[i].ss = ss;
2368 (*return_iplist)[i].port = PORT_NONE;
2369 i++;
2370 }
2371 if (ailist) {
2372 freeaddrinfo(ailist);
2373 }
2374 if (*return_count) {
2375 return NT_STATUS_OK;
2376 }
2377 return NT_STATUS_UNSUCCESSFUL;
2378 }
2379
2380 /********************************************************
2381 Resolve via "ADS" method.
2382 *********************************************************/
2383
2384 /* Special name type used to cause a _kerberos DNS lookup. */
2385 #define KDC_NAME_TYPE 0xDCDC
2386
2387 static NTSTATUS resolve_ads(const char *name,
2388 int name_type,
2389 const char *sitename,
2390 struct ip_service **return_iplist,
2391 int *return_count)
2392 {
2393 int i, j;
2394 NTSTATUS status;
2395 TALLOC_CTX *ctx;
2396 struct dns_rr_srv *dcs = NULL;
2397 int numdcs = 0;
2398 int numaddrs = 0;
2399
2400 if ((name_type != 0x1c) && (name_type != KDC_NAME_TYPE) &&
2401 (name_type != 0x1b)) {
2402 return NT_STATUS_INVALID_PARAMETER;
2403 }
2404
2405 if ( (ctx = talloc_init("resolve_ads")) == NULL ) {
2406 DEBUG(0,("resolve_ads: talloc_init() failed!\n"));
2407 return NT_STATUS_NO_MEMORY;
2408 }
2409
2410 /* The DNS code needs fixing to find IPv6 addresses... JRA. */
2411
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, name, &dcs, &numdcs);
2417 break;
2418
2419 case 0x1c:
2420 DEBUG(5,("resolve_ads: Attempting to resolve "
2421 "DCs for %s using DNS\n", name));
2422 status = ads_dns_query_dcs(ctx, name, sitename, &dcs,
2423 &numdcs);
2424 break;
2425 case KDC_NAME_TYPE:
2426 DEBUG(5,("resolve_ads: Attempting to resolve "
2427 "KDCs for %s using DNS\n", name));
2428 status = ads_dns_query_kdcs(ctx, name, sitename, &dcs,
2429 &numdcs);
2430 break;
2431 default:
2432 status = NT_STATUS_INVALID_PARAMETER;
2433 break;
2434 }
2435
2436 if ( !NT_STATUS_IS_OK( status ) ) {
2437 talloc_destroy(ctx);
2438 return status;
2439 }
2440
2441 for (i=0;i<numdcs;i++) {
2442 numaddrs += MAX(dcs[i].num_ips,1);
2443 }
2444
2445 if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, numaddrs)) ==
2446 NULL ) {
2447 DEBUG(0,("resolve_ads: malloc failed for %d entries\n",
2448 numaddrs ));
2449 talloc_destroy(ctx);
2450 return NT_STATUS_NO_MEMORY;
2451 }
2452
2453 /* now unroll the list of IP addresses */
2454
2455 *return_count = 0;
2456 i = 0;
2457 j = 0;
2458 while ( i < numdcs && (*return_count<numaddrs) ) {
2459 struct ip_service *r = &(*return_iplist)[*return_count];
2460
2461 r->port = dcs[i].port;
2462
2463 /* If we don't have an IP list for a name, lookup it up */
2464
2465 if (!dcs[i].ss_s) {
2466 interpret_string_addr(&r->ss, dcs[i].hostname, 0);
2467 i++;
2468 j = 0;
2469 } else {
2470 /* use the IP addresses from the SRV sresponse */
2471
2472 if ( j >= dcs[i].num_ips ) {
2473 i++;
2474 j = 0;
2475 continue;
2476 }
2477
2478 r->ss = dcs[i].ss_s[j];
2479 j++;
2480 }
2481
2482 /* make sure it is a valid IP. I considered checking the
2483 * negative connection cache, but this is the wrong place
2484 * for it. Maybe only as a hack. After think about it, if
2485 * all of the IP addresses returned from DNS are dead, what
2486 * hope does a netbios name lookup have ? The standard reason
2487 * for falling back to netbios lookups is that our DNS server
2488 * doesn't know anything about the DC's -- jerry */
2489
2490 if (!is_zero_addr(&r->ss)) {
2491 (*return_count)++;
2492 }
2493 }
2494
2495 talloc_destroy(ctx);
2496 return NT_STATUS_OK;
2497 }
2498
2499 /*******************************************************************
2500 Internal interface to resolve a name into an IP address.
2501 Use this function if the string is either an IP address, DNS
2502 or host name or NetBIOS name. This uses the name switch in the
2503 smb.conf to determine the order of name resolution.
2504
2505 Added support for ip addr/port to support ADS ldap servers.
2506 the only place we currently care about the port is in the
2507 resolve_hosts() when looking up DC's via SRV RR entries in DNS
2508 **********************************************************************/
2509
2510 NTSTATUS internal_resolve_name(const char *name,
2511 int name_type,
2512 const char *sitename,
2513 struct ip_service **return_iplist,
2514 int *return_count,
2515 const char *resolve_order)
2516 {
2517 char *tok;
2518 const char *ptr;
2519 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2520 int i;
2521 TALLOC_CTX *frame = NULL;
2522
2523 *return_iplist = NULL;
2524 *return_count = 0;
2525
2526 DEBUG(10, ("internal_resolve_name: looking up %s#%x (sitename %s)\n",
2527 name, name_type, sitename ? sitename : "(null)"));
2528
2529 if (is_ipaddress(name)) {
2530 if ((*return_iplist = SMB_MALLOC_P(struct ip_service)) ==
2531 NULL) {
2532 DEBUG(0,("internal_resolve_name: malloc fail !\n"));
2533 return NT_STATUS_NO_MEMORY;
2534 }
2535
2536 /* ignore the port here */
2537 (*return_iplist)->port = PORT_NONE;
2538
2539 /* if it's in the form of an IP address then get the lib to interpret it */
2540 if (!interpret_string_addr(&(*return_iplist)->ss,
2541 name, AI_NUMERICHOST)) {
2542 DEBUG(1,("internal_resolve_name: interpret_string_addr "
2543 "failed on %s\n",
2544 name));
2545 SAFE_FREE(*return_iplist);
2546 return NT_STATUS_INVALID_PARAMETER;
2547 }
2548 *return_count = 1;
2549 return NT_STATUS_OK;
2550 }
2551
2552 /* Check name cache */
2553
2554 if (namecache_fetch(name, name_type, return_iplist, return_count)) {
2555 /* This could be a negative response */
2556 if (*return_count > 0) {
2557 return NT_STATUS_OK;
2558 } else {
2559 return NT_STATUS_UNSUCCESSFUL;
2560 }
2561 }
2562
2563 /* set the name resolution order */
2564
2565 if (strcmp( resolve_order, "NULL") == 0) {
2566 DEBUG(8,("internal_resolve_name: all lookups disabled\n"));
2567 return NT_STATUS_INVALID_PARAMETER;
2568 }
2569
2570 if (!resolve_order[0]) {
2571 ptr = "host";
2572 } else {
2573 ptr = resolve_order;
2574 }
2575
2576 /* iterate through the name resolution backends */
2577
2578 frame = talloc_stackframe();
2579 while (next_token_talloc(frame, &ptr, &tok, LIST_SEP)) {
2580 if((strequal(tok, "host") || strequal(tok, "hosts"))) {
2581 status = resolve_hosts(name, name_type, return_iplist,
2582 return_count);
2583 if (NT_STATUS_IS_OK(status)) {
2584 goto done;
2585 }
2586 } else if(strequal( tok, "kdc")) {
2587 /* deal with KDC_NAME_TYPE names here.
2588 * This will result in a SRV record lookup */
2589 status = resolve_ads(name, KDC_NAME_TYPE, sitename,
2590 return_iplist, return_count);
2591 if (NT_STATUS_IS_OK(status)) {
2592 /* Ensure we don't namecache
2593 * this with the KDC port. */
2594 name_type = KDC_NAME_TYPE;
2595 goto done;
2596 }
2597 } else if(strequal( tok, "ads")) {
2598 /* deal with 0x1c and 0x1b names here.
2599 * This will result in a SRV record lookup */
2600 status = resolve_ads(name, name_type, sitename,
2601 return_iplist, return_count);
2602 if (NT_STATUS_IS_OK(status)) {
2603 goto done;
2604 }
2605 } else if(strequal( tok, "lmhosts")) {
2606 status = resolve_lmhosts(name, name_type,
2607 return_iplist, return_count);
2608 if (NT_STATUS_IS_OK(status)) {
2609 goto done;
2610 }
2611 } else if(strequal( tok, "wins")) {
2612 /* don't resolve 1D via WINS */
2613 struct sockaddr_storage *ss_list;
2614 if (name_type != 0x1D) {
2615 status = resolve_wins(name, name_type,
2616 talloc_tos(),
2617 &ss_list,
2618 return_count);
2619 if (NT_STATUS_IS_OK(status)) {
2620 if (!convert_ss2service(return_iplist,
2621 ss_list,
2622 *return_count)) {
2623 status = NT_STATUS_NO_MEMORY;
2624 }
2625 goto done;
2626 }
2627 }
2628 } else if(strequal( tok, "bcast")) {
2629 struct sockaddr_storage *ss_list;
2630 status = name_resolve_bcast(
2631 name, name_type, talloc_tos(),
2632 &ss_list, return_count);
2633 if (NT_STATUS_IS_OK(status)) {
2634 if (!convert_ss2service(return_iplist,
2635 ss_list,
2636 *return_count)) {
2637 status = NT_STATUS_NO_MEMORY;
2638 }
2639 goto done;
2640 }
2641 } else {
2642 DEBUG(0,("resolve_name: unknown name switch type %s\n",
2643 tok));
2644 }
2645 }
2646
2647 /* All of the resolve_* functions above have returned false. */
2648
2649 TALLOC_FREE(frame);
2650 SAFE_FREE(*return_iplist);
2651 *return_count = 0;
2652
2653 return NT_STATUS_UNSUCCESSFUL;
2654
2655 done:
2656
2657 /* Remove duplicate entries. Some queries, notably #1c (domain
2658 controllers) return the PDC in iplist[0] and then all domain
2659 controllers including the PDC in iplist[1..n]. Iterating over
2660 the iplist when the PDC is down will cause two sets of timeouts. */
2661
2662 if ( *return_count ) {
2663 *return_count = remove_duplicate_addrs2(*return_iplist,
2664 *return_count );
2665 }
2666
2667 /* Save in name cache */
2668 if ( DEBUGLEVEL >= 100 ) {
2669 for (i = 0; i < *return_count && DEBUGLEVEL == 100; i++) {
2670 char addr[INET6_ADDRSTRLEN];
2671 print_sockaddr(addr, sizeof(addr),
2672 &(*return_iplist)[i].ss);
2673 DEBUG(100, ("Storing name %s of type %d (%s:%d)\n",
2674 name,
2675 name_type,
2676 addr,
2677 (*return_iplist)[i].port));
2678 }
2679 }
2680
2681 namecache_store(name, name_type, *return_count, *return_iplist);
2682
2683 /* Display some debugging info */
2684
2685 if ( DEBUGLEVEL >= 10 ) {
2686 DEBUG(10, ("internal_resolve_name: returning %d addresses: ",
2687 *return_count));
2688
2689 for (i = 0; i < *return_count; i++) {
2690 char addr[INET6_ADDRSTRLEN];
2691 print_sockaddr(addr, sizeof(addr),
2692 &(*return_iplist)[i].ss);
2693 DEBUGADD(10, ("%s:%d ",
2694 addr,
2695 (*return_iplist)[i].port));
2696 }
2697 DEBUG(10, ("\n"));
2698 }
2699
2700 TALLOC_FREE(frame);
2701 return status;
2702 }
2703
2704 /********************************************************
2705 Internal interface to resolve a name into one IP address.
2706 Use this function if the string is either an IP address, DNS
2707 or host name or NetBIOS name. This uses the name switch in the
2708 smb.conf to determine the order of name resolution.
2709 *********************************************************/
2710
2711 bool resolve_name(const char *name,
2712 struct sockaddr_storage *return_ss,
2713 int name_type,
2714 bool prefer_ipv4)
2715 {
2716 struct ip_service *ss_list = NULL;
2717 char *sitename = NULL;
2718 int count = 0;
2719 NTSTATUS status;
2720
2721 if (is_ipaddress(name)) {
2722 return interpret_string_addr(return_ss, name, AI_NUMERICHOST);
2723 }
2724
2725 sitename = sitename_fetch(lp_realm()); /* wild guess */
2726
2727 status = internal_resolve_name(name, name_type, sitename,
2728 &ss_list, &count,
2729 lp_name_resolve_order());
2730 if (NT_STATUS_IS_OK(status)) {
2731 int i;
2732
2733 if (prefer_ipv4) {
2734 for (i=0; i<count; i++) {
2735 if (!is_zero_addr(&ss_list[i].ss) &&
2736 !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss) &&
2737 (ss_list[i].ss.ss_family == AF_INET)) {
2738 *return_ss = ss_list[i].ss;
2739 SAFE_FREE(ss_list);
2740 SAFE_FREE(sitename);
2741 return True;
2742 }
2743 }
2744 }
2745
2746 /* only return valid addresses for TCP connections */
2747 for (i=0; i<count; i++) {
2748 if (!is_zero_addr(&ss_list[i].ss) &&
2749 !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
2750 *return_ss = ss_list[i].ss;
2751 SAFE_FREE(ss_list);
2752 SAFE_FREE(sitename);
2753 return True;
2754 }
2755 }
2756 }
2757
2758 SAFE_FREE(ss_list);
2759 SAFE_FREE(sitename);
2760 return False;
2761 }
2762
2763 /********************************************************
2764 Internal interface to resolve a name into a list of IP addresses.
2765 Use this function if the string is either an IP address, DNS
2766 or host name or NetBIOS name. This uses the name switch in the
2767 smb.conf to determine the order of name resolution.
2768 *********************************************************/
2769
2770 NTSTATUS resolve_name_list(TALLOC_CTX *ctx,
2771 const char *name,
2772 int name_type,
2773 struct sockaddr_storage **return_ss_arr,
2774 unsigned int *p_num_entries)
2775 {
2776 struct ip_service *ss_list = NULL;
2777 char *sitename = NULL;
2778 int count = 0;
2779 int i;
2780 unsigned int num_entries;
2781 NTSTATUS status;
2782
2783 *p_num_entries = 0;
2784 *return_ss_arr = NULL;
2785
2786 if (is_ipaddress(name)) {
2787 *return_ss_arr = talloc(ctx, struct sockaddr_storage);
2788 if (!*return_ss_arr) {
2789 return NT_STATUS_NO_MEMORY;
2790 }
2791 if (!interpret_string_addr(*return_ss_arr, name, AI_NUMERICHOST)) {
2792 TALLOC_FREE(*return_ss_arr);
2793 return NT_STATUS_BAD_NETWORK_NAME;
2794 }
2795 *p_num_entries = 1;
2796 return NT_STATUS_OK;
2797 }
2798
2799 sitename = sitename_fetch(lp_realm()); /* wild guess */
2800
2801 status = internal_resolve_name(name, name_type, sitename,
2802 &ss_list, &count,
2803 lp_name_resolve_order());
2804 SAFE_FREE(sitename);
2805
2806 if (!NT_STATUS_IS_OK(status)) {
2807 return status;
2808 }
2809
2810 /* only return valid addresses for TCP connections */
2811 for (i=0, num_entries = 0; i<count; i++) {
2812 if (!is_zero_addr(&ss_list[i].ss) &&
2813 !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
2814 num_entries++;
2815 }
2816 }
2817 if (num_entries == 0) {
2818 SAFE_FREE(ss_list);
2819 return NT_STATUS_BAD_NETWORK_NAME;
2820 }
2821
2822 *return_ss_arr = talloc_array(ctx,
2823 struct sockaddr_storage,
2824 num_entries);
2825 if (!(*return_ss_arr)) {
2826 SAFE_FREE(ss_list);
2827 return NT_STATUS_NO_MEMORY;
2828 }
2829
2830 for (i=0, num_entries = 0; i<count; i++) {
2831 if (!is_zero_addr(&ss_list[i].ss) &&
2832 !is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
2833 (*return_ss_arr)[num_entries++] = ss_list[i].ss;
2834 }
2835 }
2836
2837 status = NT_STATUS_OK;
2838 *p_num_entries = num_entries;
2839
2840 SAFE_FREE(ss_list);
2841 return NT_STATUS_OK;
2842 }
2843
2844 /********************************************************
2845 Find the IP address of the master browser or DMB for a workgroup.
2846 *********************************************************/
2847
2848 bool find_master_ip(const char *group, struct sockaddr_storage *master_ss)
2849 {
2850 struct ip_service *ip_list = NULL;
2851 int count = 0;
2852 NTSTATUS status;
2853
2854 if (lp_disable_netbios()) {
2855 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group));
2856 return false;
2857 }
2858
2859 status = internal_resolve_name(group, 0x1D, NULL, &ip_list, &count,
2860 lp_name_resolve_order());
2861 if (NT_STATUS_IS_OK(status)) {
2862 *master_ss = ip_list[0].ss;
2863 SAFE_FREE(ip_list);
2864 return true;
2865 }
2866
2867 status = internal_resolve_name(group, 0x1B, NULL, &ip_list, &count,
2868 lp_name_resolve_order());
2869 if (NT_STATUS_IS_OK(status)) {
2870 *master_ss = ip_list[0].ss;
2871 SAFE_FREE(ip_list);
2872 return true;
2873 }
2874
2875 SAFE_FREE(ip_list);
2876 return false;
2877 }
2878
2879 /********************************************************
2880 Get the IP address list of the primary domain controller
2881 for a domain.
2882 *********************************************************/
2883
2884 bool get_pdc_ip(const char *domain, struct sockaddr_storage *pss)
2885 {
2886 struct ip_service *ip_list = NULL;
2887 int count = 0;
2888 NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
2889
2890 /* Look up #1B name */
2891
2892 if (lp_security() == SEC_ADS) {
2893 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
2894 &count, "ads");
2895 }
2896
2897 if (!NT_STATUS_IS_OK(status) || count == 0) {
2898 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
2899 &count,
2900 lp_name_resolve_order());
2901 if (!NT_STATUS_IS_OK(status)) {
2902 return false;
2903 }
2904 }
2905
2906 /* if we get more than 1 IP back we have to assume it is a
2907 multi-homed PDC and not a mess up */
2908
2909 if ( count > 1 ) {
2910 DEBUG(6,("get_pdc_ip: PDC has %d IP addresses!\n", count));
2911 sort_service_list(ip_list, count);
2912 }
2913
2914 *pss = ip_list[0].ss;
2915 SAFE_FREE(ip_list);
2916 return true;
2917 }
2918
2919 /* Private enum type for lookups. */
2920
2921 enum dc_lookup_type { DC_NORMAL_LOOKUP, DC_ADS_ONLY, DC_KDC_ONLY };
2922
2923 /********************************************************
2924 Get the IP address list of the domain controllers for
2925 a domain.
2926 *********************************************************/
2927
2928 static NTSTATUS get_dc_list(const char *domain,
2929 const char *sitename,
2930 struct ip_service **ip_list,
2931 int *count,
2932 enum dc_lookup_type lookup_type,
2933 bool *ordered)
2934 {
2935 char *resolve_order = NULL;
2936 char *saf_servername = NULL;
2937 char *pserver = NULL;
2938 const char *p;
2939 char *port_str = NULL;
2940 int port;
2941 char *name;
2942 int num_addresses = 0;
2943 int local_count, i, j;
2944 struct ip_service *return_iplist = NULL;
2945 struct ip_service *auto_ip_list = NULL;
2946 bool done_auto_lookup = false;
2947 int auto_count = 0;
2948 NTSTATUS status;
2949 TALLOC_CTX *ctx = talloc_init("get_dc_list");
2950
2951 *ip_list = NULL;
2952 *count = 0;
2953
2954 if (!ctx) {
2955 return NT_STATUS_NO_MEMORY;
2956 }
2957
2958 *ordered = False;
2959
2960 /* if we are restricted to solely using DNS for looking
2961 up a domain controller, make sure that host lookups
2962 are enabled for the 'name resolve order'. If host lookups
2963 are disabled and ads_only is True, then set the string to
2964 NULL. */
2965
2966 resolve_order = talloc_strdup(ctx, lp_name_resolve_order());
2967 if (!resolve_order) {
2968 status = NT_STATUS_NO_MEMORY;
2969 goto out;
2970 }
2971 strlower_m(resolve_order);
2972 if (lookup_type == DC_ADS_ONLY) {
2973 if (strstr( resolve_order, "host")) {
2974 resolve_order = talloc_strdup(ctx, "ads");
2975
2976 /* DNS SRV lookups used by the ads resolver
2977 are already sorted by priority and weight */
2978 *ordered = true;
2979 } else {
2980 resolve_order = talloc_strdup(ctx, "NULL");
2981 }
2982 } else if (lookup_type == DC_KDC_ONLY) {
2983 /* DNS SRV lookups used by the ads/kdc resolver
2984 are already sorted by priority and weight */
2985 *ordered = true;
2986 resolve_order = talloc_strdup(ctx, "kdc");
2987 }
2988 if (!resolve_order) {
2989 status = NT_STATUS_NO_MEMORY;
2990 goto out;
2991 }
2992
2993 /* fetch the server we have affinity for. Add the
2994 'password server' list to a search for our domain controllers */
2995
2996 saf_servername = saf_fetch( domain);
2997
2998 if (strequal(domain, lp_workgroup()) || strequal(domain, lp_realm())) {
2999 pserver = talloc_asprintf(ctx, "%s, %s",
3000 saf_servername ? saf_servername : "",
3001 lp_passwordserver());
3002 } else {
3003 pserver = talloc_asprintf(ctx, "%s, *",
3004 saf_servername ? saf_servername : "");
3005 }
3006
3007 SAFE_FREE(saf_servername);
3008 if (!pserver) {
3009 status = NT_STATUS_NO_MEMORY;
3010 goto out;
3011 }
3012
3013 /* if we are starting from scratch, just lookup DOMAIN<0x1c> */
3014
3015 if (!*pserver ) {
3016 DEBUG(10,("get_dc_list: no preferred domain controllers.\n"));
3017 status = internal_resolve_name(domain, 0x1C, sitename, ip_list,
3018 count, resolve_order);
3019 goto out;
3020 }
3021
3022 DEBUG(3,("get_dc_list: preferred server list: \"%s\"\n", pserver ));
3023
3024 /*
3025 * if '*' appears in the "password server" list then add
3026 * an auto lookup to the list of manually configured
3027 * DC's. If any DC is listed by name, then the list should be
3028 * considered to be ordered
3029 */
3030
3031 p = pserver;
3032 while (next_token_talloc(ctx, &p, &name, LIST_SEP)) {
3033 if (!done_auto_lookup && strequal(name, "*")) {
3034 status = internal_resolve_name(domain, 0x1C, sitename,
3035 &auto_ip_list,
3036 &auto_count,
3037 resolve_order);
3038 if (NT_STATUS_IS_OK(status)) {
3039 num_addresses += auto_count;
3040 }
3041 done_auto_lookup = true;
3042 DEBUG(8,("Adding %d DC's from auto lookup\n",
3043 auto_count));
3044 } else {
3045 num_addresses++;
3046 }
3047 }
3048
3049 /* if we have no addresses and haven't done the auto lookup, then
3050 just return the list of DC's. Or maybe we just failed. */
3051
3052 if ((num_addresses == 0)) {
3053 if (done_auto_lookup) {
3054 DEBUG(4,("get_dc_list: no servers found\n"));
3055 status = NT_STATUS_NO_LOGON_SERVERS;
3056 goto out;
3057 }
3058 status = internal_resolve_name(domain, 0x1C, sitename, ip_list,
3059 count, resolve_order);
3060 goto out;
3061 }
3062
3063 if ((return_iplist = SMB_MALLOC_ARRAY(struct ip_service,
3064 num_addresses)) == NULL) {
3065 DEBUG(3,("get_dc_list: malloc fail !\n"));
3066 status = NT_STATUS_NO_MEMORY;
3067 goto out;
3068 }
3069
3070 p = pserver;
3071 local_count = 0;
3072
3073 /* fill in the return list now with real IP's */
3074
3075 while ((local_count<num_addresses) &&
3076 next_token_talloc(ctx, &p, &name, LIST_SEP)) {
3077 struct sockaddr_storage name_ss;
3078
3079 /* copy any addersses from the auto lookup */
3080
3081 if (strequal(name, "*")) {
3082 for (j=0; j<auto_count; j++) {
3083 char addr[INET6_ADDRSTRLEN];
3084 print_sockaddr(addr,
3085 sizeof(addr),
3086 &auto_ip_list[j].ss);
3087 /* Check for and don't copy any
3088 * known bad DC IP's. */
3089 if(!NT_STATUS_IS_OK(check_negative_conn_cache(
3090 domain,
3091 addr))) {
3092 DEBUG(5,("get_dc_list: "
3093 "negative entry %s removed "
3094 "from DC list\n",
3095 addr));
3096 continue;
3097 }
3098 return_iplist[local_count].ss =
3099 auto_ip_list[j].ss;
3100 return_iplist[local_count].port =
3101 auto_ip_list[j].port;
3102 local_count++;
3103 }
3104 continue;
3105 }
3106
3107 /* added support for address:port syntax for ads
3108 * (not that I think anyone will ever run the LDAP
3109 * server in an AD domain on something other than
3110 * port 389 */
3111
3112 port = (lp_security() == SEC_ADS) ? LDAP_PORT : PORT_NONE;
3113 if ((port_str=strchr(name, ':')) != NULL) {
3114 *port_str = '\0';
3115 port_str++;
3116 port = atoi(port_str);
3117 }
3118
3119 /* explicit lookup; resolve_name() will
3120 * handle names & IP addresses */
3121 if (resolve_name( name, &name_ss, 0x20, true )) {
3122 char addr[INET6_ADDRSTRLEN];
3123 print_sockaddr(addr,
3124 sizeof(addr),
3125 &name_ss);
3126
3127 /* Check for and don't copy any known bad DC IP's. */
3128 if( !NT_STATUS_IS_OK(check_negative_conn_cache(domain,
3129 addr)) ) {
3130 DEBUG(5,("get_dc_list: negative entry %s "
3131 "removed from DC list\n",
3132 name ));
3133 continue;
3134 }
3135
3136 return_iplist[local_count].ss = name_ss;
3137 return_iplist[local_count].port = port;
3138 local_count++;
3139 *ordered = true;
3140 }
3141 }
3142
3143 /* need to remove duplicates in the list if we have any
3144 explicit password servers */
3145
3146 if (local_count) {
3147 local_count = remove_duplicate_addrs2(return_iplist,
3148 local_count );
3149 }
3150
3151 /* For DC's we always prioritize IPv4 due to W2K3 not
3152 * supporting LDAP, KRB5 or CLDAP over IPv6. */
3153
3154 if (local_count && return_iplist) {
3155 prioritize_ipv4_list(return_iplist, local_count);
3156 }
3157
3158 if ( DEBUGLEVEL >= 4 ) {
3159 DEBUG(4,("get_dc_list: returning %d ip addresses "
3160 "in an %sordered list\n",
3161 local_count,
3162 *ordered ? "":"un"));
3163 DEBUG(4,("get_dc_list: "));
3164 for ( i=0; i<local_count; i++ ) {
3165 char addr[INET6_ADDRSTRLEN];
3166 print_sockaddr(addr,
3167 sizeof(addr),
3168 &return_iplist[i].ss);
3169 DEBUGADD(4,("%s:%d ", addr, return_iplist[i].port ));
3170 }
3171 DEBUGADD(4,("\n"));
3172 }
3173
3174 *ip_list = return_iplist;
3175 *count = local_count;
3176
3177 status = ( *count != 0 ? NT_STATUS_OK : NT_STATUS_NO_LOGON_SERVERS );
3178
3179 out:
3180
3181 if (!NT_STATUS_IS_OK(status)) {
3182 SAFE_FREE(return_iplist);
3183 *ip_list = NULL;
3184 *count = 0;
3185 }
3186
3187 SAFE_FREE(auto_ip_list);
3188 TALLOC_FREE(ctx);
3189 return status;
3190 }
3191
3192 /*********************************************************************
3193 Small wrapper function to get the DC list and sort it if neccessary.
3194 *********************************************************************/
3195
3196 NTSTATUS get_sorted_dc_list( const char *domain,
3197 const char *sitename,
3198 struct ip_service **ip_list,
3199 int *count,
3200 bool ads_only )
3201 {
3202 bool ordered = false;
3203 NTSTATUS status;
3204 enum dc_lookup_type lookup_type = DC_NORMAL_LOOKUP;
3205
3206 *ip_list = NULL;
3207 *count = 0;
3208
3209 DEBUG(8,("get_sorted_dc_list: attempting lookup "
3210 "for name %s (sitename %s) using [%s]\n",
3211 domain,
3212 sitename ? sitename : "NULL",
3213 (ads_only ? "ads" : lp_name_resolve_order())));
3214
3215 if (ads_only) {
3216 lookup_type = DC_ADS_ONLY;
3217 }
3218
3219 status = get_dc_list(domain, sitename, ip_list,
3220 count, lookup_type, &ordered);
3221 if (NT_STATUS_EQUAL(status, NT_STATUS_NO_LOGON_SERVERS)
3222 && sitename) {
3223 DEBUG(3,("get_sorted_dc_list: no server for name %s available"
3224 " in site %s, fallback to all servers\n",
3225 domain, sitename));
3226 status = get_dc_list(domain, NULL, ip_list,
3227 count, lookup_type, &ordered);
3228 }
3229
3230 if (!NT_STATUS_IS_OK(status)) {
3231 SAFE_FREE(*ip_list);
3232 *count = 0;
3233 return status;
3234 }
3235
3236 /* only sort if we don't already have an ordered list */
3237 if (!ordered) {
3238 sort_service_list(*ip_list, *count);
3239 }
3240
3241 return NT_STATUS_OK;
3242 }
3243
3244 /*********************************************************************
3245 Get the KDC list - re-use all the logic in get_dc_list.
3246 *********************************************************************/
3247
3248 NTSTATUS get_kdc_list( const char *realm,
3249 const char *sitename,
3250 struct ip_service **ip_list,
3251 int *count)
3252 {
3253 bool ordered;
3254 NTSTATUS status;
3255
3256 *count = 0;
3257 *ip_list = NULL;
3258
3259 status = get_dc_list(realm, sitename, ip_list,
3260 count, DC_KDC_ONLY, &ordered);
3261
3262 if (!NT_STATUS_IS_OK(status)) {
3263 SAFE_FREE(*ip_list);
3264 *count = 0;
3265 return status;
3266 }
3267
3268 /* only sort if we don't already have an ordered list */
3269 if ( !ordered ) {
3270 sort_service_list(*ip_list, *count);
3271 }
3272
3273 return NT_STATUS_OK;
3274 }
reg import