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