?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WHATSNEW: Update changed parameters.
[Samba/gbeck.git] / source3 / libsmb / namequery.c
blobfd12f75af53c657ec4385071aa0840d2bb425b00
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 "libads/sitename_cache.h"
23 #include "libads/dns.h"
24 #include "../libcli/netlogon.h"
25 #include "librpc/gen_ndr/messaging.h"
26
27 /* nmbd.c sets this to True. */
28 bool global_in_nmbd = False;
29
30 /****************************
31 * SERVER AFFINITY ROUTINES *
32 ****************************/
33
34 /* Server affinity is the concept of preferring the last domain
35 controller with whom you had a successful conversation */
36
37 /****************************************************************************
38 ****************************************************************************/
39 #define SAFKEY_FMT "SAF/DOMAIN/%s"
40 #define SAF_TTL 900
41 #define SAFJOINKEY_FMT "SAFJOIN/DOMAIN/%s"
42 #define SAFJOIN_TTL 3600
43
44 static char *saf_key(const char *domain)
45 {
46 char *keystr;
47
48 asprintf_strupper_m(&keystr, SAFKEY_FMT, domain);
49
50 return keystr;
51 }
52
53 static char *saf_join_key(const char *domain)
54 {
55 char *keystr;
56
57 asprintf_strupper_m(&keystr, SAFJOINKEY_FMT, domain);
58
59 return keystr;
60 }
61
62 /****************************************************************************
63 ****************************************************************************/
64
65 bool saf_store( const char *domain, const char *servername )
66 {
67 char *key;
68 time_t expire;
69 bool ret = False;
70
71 if ( !domain || !servername ) {
72 DEBUG(2,("saf_store: "
73 "Refusing to store empty domain or servername!\n"));
74 return False;
75 }
76
77 if ( (strlen(domain) == 0) || (strlen(servername) == 0) ) {
78 DEBUG(0,("saf_store: "
79 "refusing to store 0 length domain or servername!\n"));
80 return False;
81 }
82
83 key = saf_key( domain );
84 expire = time( NULL ) + lp_parm_int(-1, "saf","ttl", SAF_TTL);
85
86 DEBUG(10,("saf_store: domain = [%s], server = [%s], expire = [%u]\n",
87 domain, servername, (unsigned int)expire ));
88
89 ret = gencache_set( key, servername, expire );
90
91 SAFE_FREE( key );
92
93 return ret;
94 }
95
96 bool saf_join_store( const char *domain, const char *servername )
97 {
98 char *key;
99 time_t expire;
100 bool ret = False;
101
102 if ( !domain || !servername ) {
103 DEBUG(2,("saf_join_store: Refusing to store empty domain or servername!\n"));
104 return False;
105 }
106
107 if ( (strlen(domain) == 0) || (strlen(servername) == 0) ) {
108 DEBUG(0,("saf_join_store: refusing to store 0 length domain or servername!\n"));
109 return False;
110 }
111
112 key = saf_join_key( domain );
113 expire = time( NULL ) + lp_parm_int(-1, "saf","join ttl", SAFJOIN_TTL);
114
115 DEBUG(10,("saf_join_store: domain = [%s], server = [%s], expire = [%u]\n",
116 domain, servername, (unsigned int)expire ));
117
118 ret = gencache_set( key, servername, expire );
119
120 SAFE_FREE( key );
121
122 return ret;
123 }
124
125 bool saf_delete( const char *domain )
126 {
127 char *key;
128 bool ret = False;
129
130 if ( !domain ) {
131 DEBUG(2,("saf_delete: Refusing to delete empty domain\n"));
132 return False;
133 }
134
135 key = saf_join_key(domain);
136 ret = gencache_del(key);
137 SAFE_FREE(key);
138
139 if (ret) {
140 DEBUG(10,("saf_delete[join]: domain = [%s]\n", domain ));
141 }
142
143 key = saf_key(domain);
144 ret = gencache_del(key);
145 SAFE_FREE(key);
146
147 if (ret) {
148 DEBUG(10,("saf_delete: domain = [%s]\n", domain ));
149 }
150
151 return ret;
152 }
153
154 /****************************************************************************
155 ****************************************************************************/
156
157 char *saf_fetch( const char *domain )
158 {
159 char *server = NULL;
160 time_t timeout;
161 bool ret = False;
162 char *key = NULL;
163
164 if ( !domain || strlen(domain) == 0) {
165 DEBUG(2,("saf_fetch: Empty domain name!\n"));
166 return NULL;
167 }
168
169 key = saf_join_key( domain );
170
171 ret = gencache_get( key, &server, &timeout );
172
173 SAFE_FREE( key );
174
175 if ( ret ) {
176 DEBUG(5,("saf_fetch[join]: Returning \"%s\" for \"%s\" domain\n",
177 server, domain ));
178 return server;
179 }
180
181 key = saf_key( domain );
182
183 ret = gencache_get( key, &server, &timeout );
184
185 SAFE_FREE( key );
186
187 if ( !ret ) {
188 DEBUG(5,("saf_fetch: failed to find server for \"%s\" domain\n",
189 domain ));
190 } else {
191 DEBUG(5,("saf_fetch: Returning \"%s\" for \"%s\" domain\n",
192 server, domain ));
193 }
194
195 return server;
196 }
197
198 /****************************************************************************
199 Generate a random trn_id.
200 ****************************************************************************/
201
202 static int generate_trn_id(void)
203 {
204 uint16 id;
205
206 generate_random_buffer((uint8 *)&id, sizeof(id));
207
208 return id % (unsigned)0x7FFF;
209 }
210
211 /****************************************************************************
212 Parse a node status response into an array of structures.
213 ****************************************************************************/
214
215 static NODE_STATUS_STRUCT *parse_node_status(char *p,
216 int *num_names,
217 struct node_status_extra *extra)
218 {
219 NODE_STATUS_STRUCT *ret;
220 int i;
221
222 *num_names = CVAL(p,0);
223
224 if (*num_names == 0)
225 return NULL;
226
227 ret = SMB_MALLOC_ARRAY(NODE_STATUS_STRUCT,*num_names);
228 if (!ret)
229 return NULL;
230
231 p++;
232 for (i=0;i< *num_names;i++) {
233 StrnCpy(ret[i].name,p,15);
234 trim_char(ret[i].name,'\0',' ');
235 ret[i].type = CVAL(p,15);
236 ret[i].flags = p[16];
237 p += 18;
238 DEBUG(10, ("%s#%02x: flags = 0x%02x\n", ret[i].name,
239 ret[i].type, ret[i].flags));
240 }
241 /*
242 * Also, pick up the MAC address ...
243 */
244 if (extra) {
245 memcpy(&extra->mac_addr, p, 6); /* Fill in the mac addr */
246 }
247 return ret;
248 }
249
250 /****************************************************************************
251 Try and send a request to nmbd to send a packet_struct packet first.
252 If this fails, use send_packet().
253 **************************************************************************/
254
255 static bool send_packet_request(struct packet_struct *p)
256 {
257 struct messaging_context *msg_ctx = server_messaging_context();
258 if (msg_ctx) {
259 pid_t nmbd_pid = pidfile_pid("nmbd");
260
261 if (nmbd_pid) {
262 /* Try nmbd. */
263 if (NT_STATUS_IS_OK(messaging_send_buf(msg_ctx,
264 pid_to_procid(nmbd_pid),
265 MSG_SEND_PACKET,
266 (uint8_t *)p,
267 sizeof(struct packet_struct)))) {
268 return true;
269 }
270 }
271 }
272
273 return send_packet(p);
274 }
275
276 /****************************************************************************
277 Do a NBT node status query on an open socket and return an array of
278 structures holding the returned names or NULL if the query failed.
279 **************************************************************************/
280
281 NODE_STATUS_STRUCT *node_status_query(int fd,
282 struct nmb_name *name,
283 const struct sockaddr_storage *to_ss,
284 int *num_names,
285 struct node_status_extra *extra)
286 {
287 bool found=False;
288 int retries = 2;
289 int retry_time = 2000;
290 struct timespec tp;
291 struct packet_struct p;
292 struct packet_struct *p2;
293 struct nmb_packet *nmb = &p.packet.nmb;
294 NODE_STATUS_STRUCT *ret;
295
296 ZERO_STRUCT(p);
297
298 if (to_ss->ss_family != AF_INET) {
299 /* Can't do node status to IPv6 */
300 return NULL;
301 }
302 nmb->header.name_trn_id = generate_trn_id();
303 nmb->header.opcode = 0;
304 nmb->header.response = false;
305 nmb->header.nm_flags.bcast = false;
306 nmb->header.nm_flags.recursion_available = false;
307 nmb->header.nm_flags.recursion_desired = false;
308 nmb->header.nm_flags.trunc = false;
309 nmb->header.nm_flags.authoritative = false;
310 nmb->header.rcode = 0;
311 nmb->header.qdcount = 1;
312 nmb->header.ancount = 0;
313 nmb->header.nscount = 0;
314 nmb->header.arcount = 0;
315 nmb->question.question_name = *name;
316 nmb->question.question_type = 0x21;
317 nmb->question.question_class = 0x1;
318
319 p.ip = ((const struct sockaddr_in *)to_ss)->sin_addr;
320 p.port = NMB_PORT;
321 p.recv_fd = -1;
322 p.send_fd = fd;
323 p.timestamp = time(NULL);
324 p.packet_type = NMB_PACKET;
325
326 clock_gettime_mono(&tp);
327
328 if (!send_packet_request(&p))
329 return NULL;
330
331 retries--;
332
333 while (1) {
334 struct timespec tp2;
335 clock_gettime_mono(&tp2);
336 if (nsec_time_diff(&tp2,&tp)/1000000 > retry_time) {
337 if (!retries)
338 break;
339 if (!found && !send_packet_request(&p))
340 return NULL;
341 clock_gettime_mono(&tp);
342 retries--;
343 }
344
345 if ((p2=receive_nmb_packet(fd,90,nmb->header.name_trn_id))) {
346 struct nmb_packet *nmb2 = &p2->packet.nmb;
347 debug_nmb_packet(p2);
348
349 if (nmb2->header.opcode != 0 ||
350 nmb2->header.nm_flags.bcast ||
351 nmb2->header.rcode ||
352 !nmb2->header.ancount ||
353 nmb2->answers->rr_type != 0x21) {
354 /* XXXX what do we do with this? could be a
355 redirect, but we'll discard it for the
356 moment */
357 free_packet(p2);
358 continue;
359 }
360
361 ret = parse_node_status(&nmb2->answers->rdata[0],
362 num_names, extra);
363 free_packet(p2);
364 return ret;
365 }
366 }
367
368 return NULL;
369 }
370
371 /****************************************************************************
372 Find the first type XX name in a node status reply - used for finding
373 a servers name given its IP. Return the matched name in *name.
374 **************************************************************************/
375
376 bool name_status_find(const char *q_name,
377 int q_type,
378 int type,
379 const struct sockaddr_storage *to_ss,
380 fstring name)
381 {
382 char addr[INET6_ADDRSTRLEN];
383 struct sockaddr_storage ss;
384 NODE_STATUS_STRUCT *status = NULL;
385 struct nmb_name nname;
386 int count, i;
387 int sock;
388 bool result = false;
389
390 if (lp_disable_netbios()) {
391 DEBUG(5,("name_status_find(%s#%02x): netbios is disabled\n",
392 q_name, q_type));
393 return False;
394 }
395
396 print_sockaddr(addr, sizeof(addr), to_ss);
397
398 DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name,
399 q_type, addr));
400
401 /* Check the cache first. */
402
403 if (namecache_status_fetch(q_name, q_type, type, to_ss, name)) {
404 return True;
405 }
406
407 if (to_ss->ss_family != AF_INET) {
408 /* Can't do node status to IPv6 */
409 return false;
410 }
411
412 if (!interpret_string_addr(&ss, lp_socket_address(),
413 AI_NUMERICHOST|AI_PASSIVE)) {
414 zero_sockaddr(&ss);
415 }
416
417 sock = open_socket_in(SOCK_DGRAM, 0, 3, &ss, True);
418 if (sock == -1)
419 goto done;
420
421 /* W2K PDC's seem not to respond to '*'#0. JRA */
422 make_nmb_name(&nname, q_name, q_type);
423 status = node_status_query(sock, &nname, to_ss, &count, NULL);
424 close(sock);
425 if (!status)
426 goto done;
427
428 for (i=0;i<count;i++) {
429 /* Find first one of the requested type that's not a GROUP. */
430 if (status[i].type == type && ! (status[i].flags & 0x80))
431 break;
432 }
433 if (i == count)
434 goto done;
435
436 pull_ascii_nstring(name, sizeof(fstring), status[i].name);
437
438 /* Store the result in the cache. */
439 /* but don't store an entry for 0x1c names here. Here we have
440 a single host and DOMAIN<0x1c> names should be a list of hosts */
441
442 if ( q_type != 0x1c ) {
443 namecache_status_store(q_name, q_type, type, to_ss, name);
444 }
445
446 result = true;
447
448 done:
449 SAFE_FREE(status);
450
451 DEBUG(10, ("name_status_find: name %sfound", result ? "" : "not "));
452
453 if (result)
454 DEBUGADD(10, (", name %s ip address is %s", name, addr));
455
456 DEBUG(10, ("\n"));
457
458 return result;
459 }
460
461 /*
462 comparison function used by sort_addr_list
463 */
464
465 static int addr_compare(const struct sockaddr_storage *ss1,
466 const struct sockaddr_storage *ss2)
467 {
468 int max_bits1=0, max_bits2=0;
469 int num_interfaces = iface_count();
470 int i;
471
472 /* Sort IPv4 addresses first. */
473 if (ss1->ss_family != ss2->ss_family) {
474 if (ss2->ss_family == AF_INET) {
475 return 1;
476 } else {
477 return -1;
478 }
479 }
480
481 /* Here we know both addresses are of the same
482 * family. */
483
484 for (i=0;i<num_interfaces;i++) {
485 const struct sockaddr_storage *pss = iface_n_bcast(i);
486 unsigned char *p_ss1 = NULL;
487 unsigned char *p_ss2 = NULL;
488 unsigned char *p_if = NULL;
489 size_t len = 0;
490 int bits1, bits2;
491
492 if (pss->ss_family != ss1->ss_family) {
493 /* Ignore interfaces of the wrong type. */
494 continue;
495 }
496 if (pss->ss_family == AF_INET) {
497 p_if = (unsigned char *)
498 &((const struct sockaddr_in *)pss)->sin_addr;
499 p_ss1 = (unsigned char *)
500 &((const struct sockaddr_in *)ss1)->sin_addr;
501 p_ss2 = (unsigned char *)
502 &((const struct sockaddr_in *)ss2)->sin_addr;
503 len = 4;
504 }
505 #if defined(HAVE_IPV6)
506 if (pss->ss_family == AF_INET6) {
507 p_if = (unsigned char *)
508 &((const struct sockaddr_in6 *)pss)->sin6_addr;
509 p_ss1 = (unsigned char *)
510 &((const struct sockaddr_in6 *)ss1)->sin6_addr;
511 p_ss2 = (unsigned char *)
512 &((const struct sockaddr_in6 *)ss2)->sin6_addr;
513 len = 16;
514 }
515 #endif
516 if (!p_ss1 || !p_ss2 || !p_if || len == 0) {
517 continue;
518 }
519 bits1 = matching_len_bits(p_ss1, p_if, len);
520 bits2 = matching_len_bits(p_ss2, p_if, len);
521 max_bits1 = MAX(bits1, max_bits1);
522 max_bits2 = MAX(bits2, max_bits2);
523 }
524
525 /* Bias towards directly reachable IPs */
526 if (iface_local((struct sockaddr *)ss1)) {
527 if (ss1->ss_family == AF_INET) {
528 max_bits1 += 32;
529 } else {
530 max_bits1 += 128;
531 }
532 }
533 if (iface_local((struct sockaddr *)ss2)) {
534 if (ss2->ss_family == AF_INET) {
535 max_bits2 += 32;
536 } else {
537 max_bits2 += 128;
538 }
539 }
540 return max_bits2 - max_bits1;
541 }
542
543 /*******************************************************************
544 compare 2 ldap IPs by nearness to our interfaces - used in qsort
545 *******************************************************************/
546
547 int ip_service_compare(struct ip_service *ss1, struct ip_service *ss2)
548 {
549 int result;
550
551 if ((result = addr_compare(&ss1->ss, &ss2->ss)) != 0) {
552 return result;
553 }
554
555 if (ss1->port > ss2->port) {
556 return 1;
557 }
558
559 if (ss1->port < ss2->port) {
560 return -1;
561 }
562
563 return 0;
564 }
565
566 /*
567 sort an IP list so that names that are close to one of our interfaces
568 are at the top. This prevents the problem where a WINS server returns an IP
569 that is not reachable from our subnet as the first match
570 */
571
572 static void sort_addr_list(struct sockaddr_storage *sslist, int count)
573 {
574 if (count <= 1) {
575 return;
576 }
577
578 TYPESAFE_QSORT(sslist, count, addr_compare);
579 }
580
581 static void sort_service_list(struct ip_service *servlist, int count)
582 {
583 if (count <= 1) {
584 return;
585 }
586
587 TYPESAFE_QSORT(servlist, count, ip_service_compare);
588 }
589
590 /**********************************************************************
591 Remove any duplicate address/port pairs in the list
592 *********************************************************************/
593
594 static int remove_duplicate_addrs2(struct ip_service *iplist, int count )
595 {
596 int i, j;
597
598 DEBUG(10,("remove_duplicate_addrs2: "
599 "looking for duplicate address/port pairs\n"));
600
601 /* one loop to remove duplicates */
602 for ( i=0; i<count; i++ ) {
603 if ( is_zero_addr((struct sockaddr *)&iplist[i].ss)) {
604 continue;
605 }
606
607 for ( j=i+1; j<count; j++ ) {
608 if (sockaddr_equal((struct sockaddr *)&iplist[i].ss, (struct sockaddr *)&iplist[j].ss) &&
609 iplist[i].port == iplist[j].port) {
610 zero_sockaddr(&iplist[j].ss);
611 }
612 }
613 }
614
615 /* one loop to clean up any holes we left */
616 /* first ip should never be a zero_ip() */
617 for (i = 0; i<count; ) {
618 if (is_zero_addr((struct sockaddr *)&iplist[i].ss) ) {
619 if (i != count-1) {
620 memmove(&iplist[i], &iplist[i+1],
621 (count - i - 1)*sizeof(iplist[i]));
622 }
623 count--;
624 continue;
625 }
626 i++;
627 }
628
629 return count;
630 }
631
632 static bool prioritize_ipv4_list(struct ip_service *iplist, int count)
633 {
634 TALLOC_CTX *frame = talloc_stackframe();
635 struct ip_service *iplist_new = TALLOC_ARRAY(frame, struct ip_service, count);
636 int i, j;
637
638 if (iplist_new == NULL) {
639 TALLOC_FREE(frame);
640 return false;
641 }
642
643 j = 0;
644
645 /* Copy IPv4 first. */
646 for (i = 0; i < count; i++) {
647 if (iplist[i].ss.ss_family == AF_INET) {
648 iplist_new[j++] = iplist[i];
649 }
650 }
651
652 /* Copy IPv6. */
653 for (i = 0; i < count; i++) {
654 if (iplist[i].ss.ss_family != AF_INET) {
655 iplist_new[j++] = iplist[i];
656 }
657 }
658
659 memcpy(iplist, iplist_new, sizeof(struct ip_service)*count);
660 TALLOC_FREE(frame);
661 return true;
662 }
663
664 /****************************************************************************
665 Do a netbios name query to find someones IP.
666 Returns an array of IP addresses or NULL if none.
667 *count will be set to the number of addresses returned.
668 *timed_out is set if we failed by timing out
669 ****************************************************************************/
670
671 struct sockaddr_storage *name_query(int fd,
672 const char *name,
673 int name_type,
674 bool bcast,
675 bool recurse,
676 const struct sockaddr_storage *to_ss,
677 int *count,
678 int *flags,
679 bool *timed_out)
680 {
681 bool found=false;
682 int i, retries = 3;
683 int retry_time = bcast?250:2000;
684 struct timespec tp;
685 struct packet_struct p;
686 struct packet_struct *p2;
687 struct nmb_packet *nmb = &p.packet.nmb;
688 struct sockaddr_storage *ss_list = NULL;
689
690 if (lp_disable_netbios()) {
691 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n",
692 name, name_type));
693 return NULL;
694 }
695
696 if (to_ss->ss_family != AF_INET) {
697 return NULL;
698 }
699
700 if (timed_out) {
701 *timed_out = false;
702 }
703
704 memset((char *)&p,'\0',sizeof(p));
705 (*count) = 0;
706 (*flags) = 0;
707
708 nmb->header.name_trn_id = generate_trn_id();
709 nmb->header.opcode = 0;
710 nmb->header.response = false;
711 nmb->header.nm_flags.bcast = bcast;
712 nmb->header.nm_flags.recursion_available = false;
713 nmb->header.nm_flags.recursion_desired = recurse;
714 nmb->header.nm_flags.trunc = false;
715 nmb->header.nm_flags.authoritative = false;
716 nmb->header.rcode = 0;
717 nmb->header.qdcount = 1;
718 nmb->header.ancount = 0;
719 nmb->header.nscount = 0;
720 nmb->header.arcount = 0;
721
722 make_nmb_name(&nmb->question.question_name,name,name_type);
723
724 nmb->question.question_type = 0x20;
725 nmb->question.question_class = 0x1;
726
727 p.ip = ((struct sockaddr_in *)to_ss)->sin_addr;
728 p.port = NMB_PORT;
729 p.recv_fd = -1;
730 p.send_fd = fd;
731 p.timestamp = time(NULL);
732 p.packet_type = NMB_PACKET;
733
734 clock_gettime_mono(&tp);
735
736 if (!send_packet_request(&p))
737 return NULL;
738
739 retries--;
740
741 while (1) {
742 struct timespec tp2;
743
744 clock_gettime_mono(&tp2);
745 if (nsec_time_diff(&tp2,&tp)/1000000 > retry_time) {
746 if (!retries)
747 break;
748 if (!found && !send_packet_request(&p))
749 return NULL;
750 clock_gettime_mono(&tp);
751 retries--;
752 }
753 if ((p2=receive_nmb_packet(fd,90,nmb->header.name_trn_id))) {
754 struct nmb_packet *nmb2 = &p2->packet.nmb;
755 debug_nmb_packet(p2);
756
757 /* If we get a Negative Name Query Response from a WINS
758 * server, we should report it and give up.
759 */
760 if( 0 == nmb2->header.opcode /* A query response */
761 && !(bcast) /* from a WINS server */
762 && nmb2->header.rcode /* Error returned */
763 ) {
764
765 if( DEBUGLVL( 3 ) ) {
766 /* Only executed if DEBUGLEVEL >= 3 */
767 dbgtext( "Negative name query "
768 "response, rcode 0x%02x: ",
769 nmb2->header.rcode );
770 switch( nmb2->header.rcode ) {
771 case 0x01:
772 dbgtext( "Request "
773 "was invalidly formatted.\n" );
774 break;
775 case 0x02:
776 dbgtext( "Problem with NBNS, "
777 "cannot process name.\n");
778 break;
779 case 0x03:
780 dbgtext( "The name requested "
781 "does not exist.\n" );
782 break;
783 case 0x04:
784 dbgtext( "Unsupported request "
785 "error.\n" );
786 break;
787 case 0x05:
788 dbgtext( "Query refused "
789 "error.\n" );
790 break;
791 default:
792 dbgtext( "Unrecognized error "
793 "code.\n" );
794 break;
795 }
796 }
797 free_packet(p2);
798 return( NULL );
799 }
800
801 if (nmb2->header.opcode != 0 ||
802 nmb2->header.nm_flags.bcast ||
803 nmb2->header.rcode ||
804 !nmb2->header.ancount) {
805 /*
806 * XXXX what do we do with this? Could be a
807 * redirect, but we'll discard it for the
808 * moment.
809 */
810 free_packet(p2);
811 continue;
812 }
813
814 ss_list = SMB_REALLOC_ARRAY(ss_list,
815 struct sockaddr_storage,
816 (*count) +
817 nmb2->answers->rdlength/6);
818
819 if (!ss_list) {
820 DEBUG(0,("name_query: Realloc failed.\n"));
821 free_packet(p2);
822 return NULL;
823 }
824
825 DEBUG(2,("Got a positive name query response "
826 "from %s ( ",
827 inet_ntoa(p2->ip)));
828
829 for (i=0;i<nmb2->answers->rdlength/6;i++) {
830 struct in_addr ip;
831 putip((char *)&ip,&nmb2->answers->rdata[2+i*6]);
832 in_addr_to_sockaddr_storage(&ss_list[(*count)],
833 ip);
834 DEBUGADD(2,("%s ",inet_ntoa(ip)));
835 (*count)++;
836 }
837 DEBUGADD(2,(")\n"));
838
839 found=true;
840 retries=0;
841 /* We add the flags back ... */
842 if (nmb2->header.response)
843 (*flags) |= NM_FLAGS_RS;
844 if (nmb2->header.nm_flags.authoritative)
845 (*flags) |= NM_FLAGS_AA;
846 if (nmb2->header.nm_flags.trunc)
847 (*flags) |= NM_FLAGS_TC;
848 if (nmb2->header.nm_flags.recursion_desired)
849 (*flags) |= NM_FLAGS_RD;
850 if (nmb2->header.nm_flags.recursion_available)
851 (*flags) |= NM_FLAGS_RA;
852 if (nmb2->header.nm_flags.bcast)
853 (*flags) |= NM_FLAGS_B;
854 free_packet(p2);
855 /*
856 * If we're doing a unicast lookup we only
857 * expect one reply. Don't wait the full 2
858 * seconds if we got one. JRA.
859 */
860 if(!bcast && found)
861 break;
862 }
863 }
864
865 /* only set timed_out if we didn't fund what we where looking for*/
866
867 if ( !found && timed_out ) {
868 *timed_out = true;
869 }
870
871 /* sort the ip list so we choose close servers first if possible */
872 sort_addr_list(ss_list, *count);
873
874 return ss_list;
875 }
876
877 /********************************************************
878 convert an array if struct sockaddr_storage to struct ip_service
879 return false on failure. Port is set to PORT_NONE;
880 *********************************************************/
881
882 static bool convert_ss2service(struct ip_service **return_iplist,
883 const struct sockaddr_storage *ss_list,
884 int count)
885 {
886 int i;
887
888 if ( count==0 || !ss_list )
889 return False;
890
891 /* copy the ip address; port will be PORT_NONE */
892 if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, count)) ==
893 NULL) {
894 DEBUG(0,("convert_ip2service: malloc failed "
895 "for %d enetries!\n", count ));
896 return False;
897 }
898
899 for ( i=0; i<count; i++ ) {
900 (*return_iplist)[i].ss = ss_list[i];
901 (*return_iplist)[i].port = PORT_NONE;
902 }
903
904 return true;
905 }
906
907 /********************************************************
908 Resolve via "bcast" method.
909 *********************************************************/
910
911 NTSTATUS name_resolve_bcast(const char *name,
912 int name_type,
913 struct ip_service **return_iplist,
914 int *return_count)
915 {
916 int sock, i;
917 int num_interfaces = iface_count();
918 struct sockaddr_storage *ss_list;
919 struct sockaddr_storage ss;
920 NTSTATUS status;
921
922 if (lp_disable_netbios()) {
923 DEBUG(5,("name_resolve_bcast(%s#%02x): netbios is disabled\n",
924 name, name_type));
925 return NT_STATUS_INVALID_PARAMETER;
926 }
927
928 *return_iplist = NULL;
929 *return_count = 0;
930
931 /*
932 * "bcast" means do a broadcast lookup on all the local interfaces.
933 */
934
935 DEBUG(3,("name_resolve_bcast: Attempting broadcast lookup "
936 "for name %s<0x%x>\n", name, name_type));
937
938 if (!interpret_string_addr(&ss, lp_socket_address(),
939 AI_NUMERICHOST|AI_PASSIVE)) {
940 zero_sockaddr(&ss);
941 }
942
943 sock = open_socket_in( SOCK_DGRAM, 0, 3, &ss, true );
944 if (sock == -1) {
945 return NT_STATUS_UNSUCCESSFUL;
946 }
947
948 set_socket_options(sock,"SO_BROADCAST");
949 /*
950 * Lookup the name on all the interfaces, return on
951 * the first successful match.
952 */
953 for( i = num_interfaces-1; i >= 0; i--) {
954 const struct sockaddr_storage *pss = iface_n_bcast(i);
955 int flags;
956
957 /* Done this way to fix compiler error on IRIX 5.x */
958 if (!pss) {
959 continue;
960 }
961 ss_list = name_query(sock, name, name_type, true,
962 true, pss, return_count, &flags, NULL);
963 if (ss_list) {
964 goto success;
965 }
966 }
967
968 /* failed - no response */
969
970 close(sock);
971 return NT_STATUS_UNSUCCESSFUL;
972
973 success:
974
975 status = NT_STATUS_OK;
976 if (!convert_ss2service(return_iplist, ss_list, *return_count) )
977 status = NT_STATUS_INVALID_PARAMETER;
978
979 SAFE_FREE(ss_list);
980 close(sock);
981 return status;
982 }
983
984 /********************************************************
985 Resolve via "wins" method.
986 *********************************************************/
987
988 NTSTATUS resolve_wins(const char *name,
989 int name_type,
990 struct ip_service **return_iplist,
991 int *return_count)
992 {
993 int sock, t, i;
994 char **wins_tags;
995 struct sockaddr_storage src_ss, *ss_list = NULL;
996 struct in_addr src_ip;
997 NTSTATUS status;
998
999 if (lp_disable_netbios()) {
1000 DEBUG(5,("resolve_wins(%s#%02x): netbios is disabled\n",
1001 name, name_type));
1002 return NT_STATUS_INVALID_PARAMETER;
1003 }
1004
1005 *return_iplist = NULL;
1006 *return_count = 0;
1007
1008 DEBUG(3,("resolve_wins: Attempting wins lookup for name %s<0x%x>\n",
1009 name, name_type));
1010
1011 if (wins_srv_count() < 1) {
1012 DEBUG(3,("resolve_wins: WINS server resolution selected "
1013 "and no WINS servers listed.\n"));
1014 return NT_STATUS_INVALID_PARAMETER;
1015 }
1016
1017 /* we try a lookup on each of the WINS tags in turn */
1018 wins_tags = wins_srv_tags();
1019
1020 if (!wins_tags) {
1021 /* huh? no tags?? give up in disgust */
1022 return NT_STATUS_INVALID_PARAMETER;
1023 }
1024
1025 /* the address we will be sending from */
1026 if (!interpret_string_addr(&src_ss, lp_socket_address(),
1027 AI_NUMERICHOST|AI_PASSIVE)) {
1028 zero_sockaddr(&src_ss);
1029 }
1030
1031 if (src_ss.ss_family != AF_INET) {
1032 char addr[INET6_ADDRSTRLEN];
1033 print_sockaddr(addr, sizeof(addr), &src_ss);
1034 DEBUG(3,("resolve_wins: cannot receive WINS replies "
1035 "on IPv6 address %s\n",
1036 addr));
1037 wins_srv_tags_free(wins_tags);
1038 return NT_STATUS_INVALID_PARAMETER;
1039 }
1040
1041 src_ip = ((struct sockaddr_in *)&src_ss)->sin_addr;
1042
1043 /* in the worst case we will try every wins server with every
1044 tag! */
1045 for (t=0; wins_tags && wins_tags[t]; t++) {
1046 int srv_count = wins_srv_count_tag(wins_tags[t]);
1047 for (i=0; i<srv_count; i++) {
1048 struct sockaddr_storage wins_ss;
1049 struct in_addr wins_ip;
1050 int flags;
1051 bool timed_out;
1052
1053 wins_ip = wins_srv_ip_tag(wins_tags[t], src_ip);
1054
1055 if (global_in_nmbd && ismyip_v4(wins_ip)) {
1056 /* yikes! we'll loop forever */
1057 continue;
1058 }
1059
1060 /* skip any that have been unresponsive lately */
1061 if (wins_srv_is_dead(wins_ip, src_ip)) {
1062 continue;
1063 }
1064
1065 DEBUG(3,("resolve_wins: using WINS server %s "
1066 "and tag '%s'\n",
1067 inet_ntoa(wins_ip), wins_tags[t]));
1068
1069 sock = open_socket_in(SOCK_DGRAM, 0, 3, &src_ss, true);
1070 if (sock == -1) {
1071 continue;
1072 }
1073
1074 in_addr_to_sockaddr_storage(&wins_ss, wins_ip);
1075 ss_list = name_query(sock,
1076 name,
1077 name_type,
1078 false,
1079 true,
1080 &wins_ss,
1081 return_count,
1082 &flags,
1083 &timed_out);
1084
1085 /* exit loop if we got a list of addresses */
1086
1087 if (ss_list)
1088 goto success;
1089
1090 close(sock);
1091
1092 if (timed_out) {
1093 /* Timed out wating for WINS server to respond.
1094 * Mark it dead. */
1095 wins_srv_died(wins_ip, src_ip);
1096 } else {
1097 /* The name definately isn't in this
1098 group of WINS servers.
1099 goto the next group */
1100 break;
1101 }
1102 }
1103 }
1104
1105 wins_srv_tags_free(wins_tags);
1106 return NT_STATUS_NO_LOGON_SERVERS;
1107
1108 success:
1109
1110 status = NT_STATUS_OK;
1111 if (!convert_ss2service(return_iplist, ss_list, *return_count))
1112 status = NT_STATUS_INVALID_PARAMETER;
1113
1114 SAFE_FREE(ss_list);
1115 wins_srv_tags_free(wins_tags);
1116 close(sock);
1117
1118 return status;
1119 }
1120
1121 /********************************************************
1122 Resolve via "lmhosts" method.
1123 *********************************************************/
1124
1125 static NTSTATUS resolve_lmhosts(const char *name, int name_type,
1126 struct ip_service **return_iplist,
1127 int *return_count)
1128 {
1129 /*
1130 * "lmhosts" means parse the local lmhosts file.
1131 */
1132 struct sockaddr_storage *ss_list;
1133 NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1134 TALLOC_CTX *ctx = NULL;
1135
1136 *return_iplist = NULL;
1137 *return_count = 0;
1138
1139 DEBUG(3,("resolve_lmhosts: "
1140 "Attempting lmhosts lookup for name %s<0x%x>\n",
1141 name, name_type));
1142
1143 ctx = talloc_init("resolve_lmhosts");
1144 if (!ctx) {
1145 return NT_STATUS_NO_MEMORY;
1146 }
1147
1148 status = resolve_lmhosts_file_as_sockaddr(get_dyn_LMHOSTSFILE(),
1149 name, name_type,
1150 ctx,
1151 &ss_list,
1152 return_count);
1153 if (NT_STATUS_IS_OK(status)) {
1154 if (convert_ss2service(return_iplist,
1155 ss_list,
1156 *return_count)) {
1157 talloc_free(ctx);
1158 return NT_STATUS_OK;
1159 } else {
1160 talloc_free(ctx);
1161 return NT_STATUS_NO_MEMORY;
1162 }
1163 }
1164 talloc_free(ctx);
1165 return status;
1166 }
1167
1168
1169 /********************************************************
1170 Resolve via "hosts" method.
1171 *********************************************************/
1172
1173 static NTSTATUS resolve_hosts(const char *name, int name_type,
1174 struct ip_service **return_iplist,
1175 int *return_count)
1176 {
1177 /*
1178 * "host" means do a localhost, or dns lookup.
1179 */
1180 struct addrinfo hints;
1181 struct addrinfo *ailist = NULL;
1182 struct addrinfo *res = NULL;
1183 int ret = -1;
1184 int i = 0;
1185
1186 if ( name_type != 0x20 && name_type != 0x0) {
1187 DEBUG(5, ("resolve_hosts: not appropriate "
1188 "for name type <0x%x>\n",
1189 name_type));
1190 return NT_STATUS_INVALID_PARAMETER;
1191 }
1192
1193 *return_iplist = NULL;
1194 *return_count = 0;
1195
1196 DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x%x>\n",
1197 name, name_type));
1198
1199 ZERO_STRUCT(hints);
1200 /* By default make sure it supports TCP. */
1201 hints.ai_socktype = SOCK_STREAM;
1202 hints.ai_flags = AI_ADDRCONFIG;
1203
1204 #if !defined(HAVE_IPV6)
1205 /* Unless we have IPv6, we really only want IPv4 addresses back. */
1206 hints.ai_family = AF_INET;
1207 #endif
1208
1209 ret = getaddrinfo(name,
1210 NULL,
1211 &hints,
1212 &ailist);
1213 if (ret) {
1214 DEBUG(3,("resolve_hosts: getaddrinfo failed for name %s [%s]\n",
1215 name,
1216 gai_strerror(ret) ));
1217 }
1218
1219 for (res = ailist; res; res = res->ai_next) {
1220 struct sockaddr_storage ss;
1221
1222 if (!res->ai_addr || res->ai_addrlen == 0) {
1223 continue;
1224 }
1225
1226 ZERO_STRUCT(ss);
1227 memcpy(&ss, res->ai_addr, res->ai_addrlen);
1228
1229 *return_count += 1;
1230
1231 *return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
1232 struct ip_service,
1233 *return_count);
1234 if (!*return_iplist) {
1235 DEBUG(3,("resolve_hosts: malloc fail !\n"));
1236 freeaddrinfo(ailist);
1237 return NT_STATUS_NO_MEMORY;
1238 }
1239 (*return_iplist)[i].ss = ss;
1240 (*return_iplist)[i].port = PORT_NONE;
1241 i++;
1242 }
1243 if (ailist) {
1244 freeaddrinfo(ailist);
1245 }
1246 if (*return_count) {
1247 return NT_STATUS_OK;
1248 }
1249 return NT_STATUS_UNSUCCESSFUL;
1250 }
1251
1252 /********************************************************
1253 Resolve via "ADS" method.
1254 *********************************************************/
1255
1256 static NTSTATUS resolve_ads(const char *name,
1257 int name_type,
1258 const char *sitename,
1259 struct ip_service **return_iplist,
1260 int *return_count)
1261 {
1262 int i, j;
1263 NTSTATUS status;
1264 TALLOC_CTX *ctx;
1265 struct dns_rr_srv *dcs = NULL;
1266 int numdcs = 0;
1267 int numaddrs = 0;
1268
1269 if ((name_type != 0x1c) && (name_type != KDC_NAME_TYPE) &&
1270 (name_type != 0x1b)) {
1271 return NT_STATUS_INVALID_PARAMETER;
1272 }
1273
1274 if ( (ctx = talloc_init("resolve_ads")) == NULL ) {
1275 DEBUG(0,("resolve_ads: talloc_init() failed!\n"));
1276 return NT_STATUS_NO_MEMORY;
1277 }
1278
1279 /* The DNS code needs fixing to find IPv6 addresses... JRA. */
1280
1281 switch (name_type) {
1282 case 0x1b:
1283 DEBUG(5,("resolve_ads: Attempting to resolve "
1284 "PDC for %s using DNS\n", name));
1285 status = ads_dns_query_pdc(ctx, name, &dcs, &numdcs);
1286 break;
1287
1288 case 0x1c:
1289 DEBUG(5,("resolve_ads: Attempting to resolve "
1290 "DCs for %s using DNS\n", name));
1291 status = ads_dns_query_dcs(ctx, name, sitename, &dcs,
1292 &numdcs);
1293 break;
1294 case KDC_NAME_TYPE:
1295 DEBUG(5,("resolve_ads: Attempting to resolve "
1296 "KDCs for %s using DNS\n", name));
1297 status = ads_dns_query_kdcs(ctx, name, sitename, &dcs,
1298 &numdcs);
1299 break;
1300 default:
1301 status = NT_STATUS_INVALID_PARAMETER;
1302 break;
1303 }
1304
1305 if ( !NT_STATUS_IS_OK( status ) ) {
1306 talloc_destroy(ctx);
1307 return status;
1308 }
1309
1310 for (i=0;i<numdcs;i++) {
1311 numaddrs += MAX(dcs[i].num_ips,1);
1312 }
1313
1314 if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, numaddrs)) ==
1315 NULL ) {
1316 DEBUG(0,("resolve_ads: malloc failed for %d entries\n",
1317 numaddrs ));
1318 talloc_destroy(ctx);
1319 return NT_STATUS_NO_MEMORY;
1320 }
1321
1322 /* now unroll the list of IP addresses */
1323
1324 *return_count = 0;
1325 i = 0;
1326 j = 0;
1327 while ( i < numdcs && (*return_count<numaddrs) ) {
1328 struct ip_service *r = &(*return_iplist)[*return_count];
1329
1330 r->port = dcs[i].port;
1331
1332 /* If we don't have an IP list for a name, lookup it up */
1333
1334 if (!dcs[i].ss_s) {
1335 interpret_string_addr(&r->ss, dcs[i].hostname, 0);
1336 i++;
1337 j = 0;
1338 } else {
1339 /* use the IP addresses from the SRV sresponse */
1340
1341 if ( j >= dcs[i].num_ips ) {
1342 i++;
1343 j = 0;
1344 continue;
1345 }
1346
1347 r->ss = dcs[i].ss_s[j];
1348 j++;
1349 }
1350
1351 /* make sure it is a valid IP. I considered checking the
1352 * negative connection cache, but this is the wrong place
1353 * for it. Maybe only as a hack. After think about it, if
1354 * all of the IP addresses returned from DNS are dead, what
1355 * hope does a netbios name lookup have ? The standard reason
1356 * for falling back to netbios lookups is that our DNS server
1357 * doesn't know anything about the DC's -- jerry */
1358
1359 if (!is_zero_addr((struct sockaddr *)&r->ss)) {
1360 (*return_count)++;
1361 }
1362 }
1363
1364 talloc_destroy(ctx);
1365 return NT_STATUS_OK;
1366 }
1367
1368 /*******************************************************************
1369 Internal interface to resolve a name into an IP address.
1370 Use this function if the string is either an IP address, DNS
1371 or host name or NetBIOS name. This uses the name switch in the
1372 smb.conf to determine the order of name resolution.
1373
1374 Added support for ip addr/port to support ADS ldap servers.
1375 the only place we currently care about the port is in the
1376 resolve_hosts() when looking up DC's via SRV RR entries in DNS
1377 **********************************************************************/
1378
1379 NTSTATUS internal_resolve_name(const char *name,
1380 int name_type,
1381 const char *sitename,
1382 struct ip_service **return_iplist,
1383 int *return_count,
1384 const char *resolve_order)
1385 {
1386 char *tok;
1387 const char *ptr;
1388 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
1389 int i;
1390 TALLOC_CTX *frame = NULL;
1391
1392 *return_iplist = NULL;
1393 *return_count = 0;
1394
1395 DEBUG(10, ("internal_resolve_name: looking up %s#%x (sitename %s)\n",
1396 name, name_type, sitename ? sitename : "(null)"));
1397
1398 if (is_ipaddress(name)) {
1399 if ((*return_iplist = SMB_MALLOC_P(struct ip_service)) ==
1400 NULL) {
1401 DEBUG(0,("internal_resolve_name: malloc fail !\n"));
1402 return NT_STATUS_NO_MEMORY;
1403 }
1404
1405 /* ignore the port here */
1406 (*return_iplist)->port = PORT_NONE;
1407
1408 /* if it's in the form of an IP address then get the lib to interpret it */
1409 if (!interpret_string_addr(&(*return_iplist)->ss,
1410 name, AI_NUMERICHOST)) {
1411 DEBUG(1,("internal_resolve_name: interpret_string_addr "
1412 "failed on %s\n",
1413 name));
1414 SAFE_FREE(*return_iplist);
1415 return NT_STATUS_INVALID_PARAMETER;
1416 }
1417 *return_count = 1;
1418 return NT_STATUS_OK;
1419 }
1420
1421 /* Check name cache */
1422
1423 if (namecache_fetch(name, name_type, return_iplist, return_count)) {
1424 /* This could be a negative response */
1425 if (*return_count > 0) {
1426 return NT_STATUS_OK;
1427 } else {
1428 return NT_STATUS_UNSUCCESSFUL;
1429 }
1430 }
1431
1432 /* set the name resolution order */
1433
1434 if (strcmp( resolve_order, "NULL") == 0) {
1435 DEBUG(8,("internal_resolve_name: all lookups disabled\n"));
1436 return NT_STATUS_INVALID_PARAMETER;
1437 }
1438
1439 if (!resolve_order[0]) {
1440 ptr = "host";
1441 } else {
1442 ptr = resolve_order;
1443 }
1444
1445 /* iterate through the name resolution backends */
1446
1447 frame = talloc_stackframe();
1448 while (next_token_talloc(frame, &ptr, &tok, LIST_SEP)) {
1449 if((strequal(tok, "host") || strequal(tok, "hosts"))) {
1450 status = resolve_hosts(name, name_type, return_iplist,
1451 return_count);
1452 if (NT_STATUS_IS_OK(status)) {
1453 goto done;
1454 }
1455 } else if(strequal( tok, "kdc")) {
1456 /* deal with KDC_NAME_TYPE names here.
1457 * This will result in a SRV record lookup */
1458 status = resolve_ads(name, KDC_NAME_TYPE, sitename,
1459 return_iplist, return_count);
1460 if (NT_STATUS_IS_OK(status)) {
1461 /* Ensure we don't namecache
1462 * this with the KDC port. */
1463 name_type = KDC_NAME_TYPE;
1464 goto done;
1465 }
1466 } else if(strequal( tok, "ads")) {
1467 /* deal with 0x1c and 0x1b names here.
1468 * This will result in a SRV record lookup */
1469 status = resolve_ads(name, name_type, sitename,
1470 return_iplist, return_count);
1471 if (NT_STATUS_IS_OK(status)) {
1472 goto done;
1473 }
1474 } else if(strequal( tok, "lmhosts")) {
1475 status = resolve_lmhosts(name, name_type,
1476 return_iplist, return_count);
1477 if (NT_STATUS_IS_OK(status)) {
1478 goto done;
1479 }
1480 } else if(strequal( tok, "wins")) {
1481 /* don't resolve 1D via WINS */
1482 if (name_type != 0x1D) {
1483 status = resolve_wins(name, name_type,
1484 return_iplist,
1485 return_count);
1486 if (NT_STATUS_IS_OK(status)) {
1487 goto done;
1488 }
1489 }
1490 } else if(strequal( tok, "bcast")) {
1491 status = name_resolve_bcast(name, name_type,
1492 return_iplist,
1493 return_count);
1494 if (NT_STATUS_IS_OK(status)) {
1495 goto done;
1496 }
1497 } else {
1498 DEBUG(0,("resolve_name: unknown name switch type %s\n",
1499 tok));
1500 }
1501 }
1502
1503 /* All of the resolve_* functions above have returned false. */
1504
1505 TALLOC_FREE(frame);
1506 SAFE_FREE(*return_iplist);
1507 *return_count = 0;
1508
1509 return NT_STATUS_UNSUCCESSFUL;
1510
1511 done:
1512
1513 /* Remove duplicate entries. Some queries, notably #1c (domain
1514 controllers) return the PDC in iplist[0] and then all domain
1515 controllers including the PDC in iplist[1..n]. Iterating over
1516 the iplist when the PDC is down will cause two sets of timeouts. */
1517
1518 if ( *return_count ) {
1519 *return_count = remove_duplicate_addrs2(*return_iplist,
1520 *return_count );
1521 }
1522
1523 /* Save in name cache */
1524 if ( DEBUGLEVEL >= 100 ) {
1525 for (i = 0; i < *return_count && DEBUGLEVEL == 100; i++) {
1526 char addr[INET6_ADDRSTRLEN];
1527 print_sockaddr(addr, sizeof(addr),
1528 &(*return_iplist)[i].ss);
1529 DEBUG(100, ("Storing name %s of type %d (%s:%d)\n",
1530 name,
1531 name_type,
1532 addr,
1533 (*return_iplist)[i].port));
1534 }
1535 }
1536
1537 namecache_store(name, name_type, *return_count, *return_iplist);
1538
1539 /* Display some debugging info */
1540
1541 if ( DEBUGLEVEL >= 10 ) {
1542 DEBUG(10, ("internal_resolve_name: returning %d addresses: ",
1543 *return_count));
1544
1545 for (i = 0; i < *return_count; i++) {
1546 char addr[INET6_ADDRSTRLEN];
1547 print_sockaddr(addr, sizeof(addr),
1548 &(*return_iplist)[i].ss);
1549 DEBUGADD(10, ("%s:%d ",
1550 addr,
1551 (*return_iplist)[i].port));
1552 }
1553 DEBUG(10, ("\n"));
1554 }
1555
1556 TALLOC_FREE(frame);
1557 return status;
1558 }
1559
1560 /********************************************************
1561 Internal interface to resolve a name into one IP address.
1562 Use this function if the string is either an IP address, DNS
1563 or host name or NetBIOS name. This uses the name switch in the
1564 smb.conf to determine the order of name resolution.
1565 *********************************************************/
1566
1567 bool resolve_name(const char *name,
1568 struct sockaddr_storage *return_ss,
1569 int name_type,
1570 bool prefer_ipv4)
1571 {
1572 struct ip_service *ss_list = NULL;
1573 char *sitename = NULL;
1574 int count = 0;
1575
1576 if (is_ipaddress(name)) {
1577 return interpret_string_addr(return_ss, name, AI_NUMERICHOST);
1578 }
1579
1580 sitename = sitename_fetch(lp_realm()); /* wild guess */
1581
1582 if (NT_STATUS_IS_OK(internal_resolve_name(name, name_type, sitename,
1583 &ss_list, &count,
1584 lp_name_resolve_order()))) {
1585 int i;
1586
1587 if (prefer_ipv4) {
1588 for (i=0; i<count; i++) {
1589 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
1590 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss) &&
1591 (ss_list[i].ss.ss_family == AF_INET)) {
1592 *return_ss = ss_list[i].ss;
1593 SAFE_FREE(ss_list);
1594 SAFE_FREE(sitename);
1595 return True;
1596 }
1597 }
1598 }
1599
1600 /* only return valid addresses for TCP connections */
1601 for (i=0; i<count; i++) {
1602 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
1603 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss)) {
1604 *return_ss = ss_list[i].ss;
1605 SAFE_FREE(ss_list);
1606 SAFE_FREE(sitename);
1607 return True;
1608 }
1609 }
1610 }
1611
1612 SAFE_FREE(ss_list);
1613 SAFE_FREE(sitename);
1614 return False;
1615 }
1616
1617 /********************************************************
1618 Internal interface to resolve a name into a list of IP addresses.
1619 Use this function if the string is either an IP address, DNS
1620 or host name or NetBIOS name. This uses the name switch in the
1621 smb.conf to determine the order of name resolution.
1622 *********************************************************/
1623
1624 NTSTATUS resolve_name_list(TALLOC_CTX *ctx,
1625 const char *name,
1626 int name_type,
1627 struct sockaddr_storage **return_ss_arr,
1628 unsigned int *p_num_entries)
1629 {
1630 struct ip_service *ss_list = NULL;
1631 char *sitename = NULL;
1632 int count = 0;
1633 int i;
1634 unsigned int num_entries;
1635 NTSTATUS status;
1636
1637 *p_num_entries = 0;
1638 *return_ss_arr = NULL;
1639
1640 if (is_ipaddress(name)) {
1641 *return_ss_arr = TALLOC_P(ctx, struct sockaddr_storage);
1642 if (!*return_ss_arr) {
1643 return NT_STATUS_NO_MEMORY;
1644 }
1645 if (!interpret_string_addr(*return_ss_arr, name, AI_NUMERICHOST)) {
1646 TALLOC_FREE(*return_ss_arr);
1647 return NT_STATUS_BAD_NETWORK_NAME;
1648 }
1649 *p_num_entries = 1;
1650 return NT_STATUS_OK;
1651 }
1652
1653 sitename = sitename_fetch(lp_realm()); /* wild guess */
1654
1655 status = internal_resolve_name(name, name_type, sitename,
1656 &ss_list, &count,
1657 lp_name_resolve_order());
1658 SAFE_FREE(sitename);
1659
1660 if (!NT_STATUS_IS_OK(status)) {
1661 return status;
1662 }
1663
1664 /* only return valid addresses for TCP connections */
1665 for (i=0, num_entries = 0; i<count; i++) {
1666 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
1667 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss)) {
1668 num_entries++;
1669 }
1670 }
1671 if (num_entries == 0) {
1672 SAFE_FREE(ss_list);
1673 return NT_STATUS_BAD_NETWORK_NAME;
1674 }
1675
1676 *return_ss_arr = TALLOC_ARRAY(ctx,
1677 struct sockaddr_storage,
1678 num_entries);
1679 if (!(*return_ss_arr)) {
1680 SAFE_FREE(ss_list);
1681 return NT_STATUS_NO_MEMORY;
1682 }
1683
1684 for (i=0, num_entries = 0; i<count; i++) {
1685 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
1686 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss)) {
1687 (*return_ss_arr)[num_entries++] = ss_list[i].ss;
1688 }
1689 }
1690
1691 status = NT_STATUS_OK;
1692 *p_num_entries = num_entries;
1693
1694 SAFE_FREE(ss_list);
1695 return NT_STATUS_OK;
1696 }
1697
1698 /********************************************************
1699 Find the IP address of the master browser or DMB for a workgroup.
1700 *********************************************************/
1701
1702 bool find_master_ip(const char *group, struct sockaddr_storage *master_ss)
1703 {
1704 struct ip_service *ip_list = NULL;
1705 int count = 0;
1706 NTSTATUS status;
1707
1708 if (lp_disable_netbios()) {
1709 DEBUG(5,("find_master_ip(%s): netbios is disabled\n", group));
1710 return false;
1711 }
1712
1713 status = internal_resolve_name(group, 0x1D, NULL, &ip_list, &count,
1714 lp_name_resolve_order());
1715 if (NT_STATUS_IS_OK(status)) {
1716 *master_ss = ip_list[0].ss;
1717 SAFE_FREE(ip_list);
1718 return true;
1719 }
1720
1721 status = internal_resolve_name(group, 0x1B, NULL, &ip_list, &count,
1722 lp_name_resolve_order());
1723 if (NT_STATUS_IS_OK(status)) {
1724 *master_ss = ip_list[0].ss;
1725 SAFE_FREE(ip_list);
1726 return true;
1727 }
1728
1729 SAFE_FREE(ip_list);
1730 return false;
1731 }
1732
1733 /********************************************************
1734 Get the IP address list of the primary domain controller
1735 for a domain.
1736 *********************************************************/
1737
1738 bool get_pdc_ip(const char *domain, struct sockaddr_storage *pss)
1739 {
1740 struct ip_service *ip_list = NULL;
1741 int count = 0;
1742 NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1743
1744 /* Look up #1B name */
1745
1746 if (lp_security() == SEC_ADS) {
1747 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
1748 &count, "ads");
1749 }
1750
1751 if (!NT_STATUS_IS_OK(status) || count == 0) {
1752 status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
1753 &count,
1754 lp_name_resolve_order());
1755 if (!NT_STATUS_IS_OK(status)) {
1756 return false;
1757 }
1758 }
1759
1760 /* if we get more than 1 IP back we have to assume it is a
1761 multi-homed PDC and not a mess up */
1762
1763 if ( count > 1 ) {
1764 DEBUG(6,("get_pdc_ip: PDC has %d IP addresses!\n", count));
1765 sort_service_list(ip_list, count);
1766 }
1767
1768 *pss = ip_list[0].ss;
1769 SAFE_FREE(ip_list);
1770 return true;
1771 }
1772
1773 /* Private enum type for lookups. */
1774
1775 enum dc_lookup_type { DC_NORMAL_LOOKUP, DC_ADS_ONLY, DC_KDC_ONLY };
1776
1777 /********************************************************
1778 Get the IP address list of the domain controllers for
1779 a domain.
1780 *********************************************************/
1781
1782 static NTSTATUS get_dc_list(const char *domain,
1783 const char *sitename,
1784 struct ip_service **ip_list,
1785 int *count,
1786 enum dc_lookup_type lookup_type,
1787 bool *ordered)
1788 {
1789 char *resolve_order = NULL;
1790 char *saf_servername = NULL;
1791 char *pserver = NULL;
1792 const char *p;
1793 char *port_str = NULL;
1794 int port;
1795 char *name;
1796 int num_addresses = 0;
1797 int local_count, i, j;
1798 struct ip_service *return_iplist = NULL;
1799 struct ip_service *auto_ip_list = NULL;
1800 bool done_auto_lookup = false;
1801 int auto_count = 0;
1802 NTSTATUS status;
1803 TALLOC_CTX *ctx = talloc_init("get_dc_list");
1804
1805 *ip_list = NULL;
1806 *count = 0;
1807
1808 if (!ctx) {
1809 return NT_STATUS_NO_MEMORY;
1810 }
1811
1812 *ordered = False;
1813
1814 /* if we are restricted to solely using DNS for looking
1815 up a domain controller, make sure that host lookups
1816 are enabled for the 'name resolve order'. If host lookups
1817 are disabled and ads_only is True, then set the string to
1818 NULL. */
1819
1820 resolve_order = talloc_strdup(ctx, lp_name_resolve_order());
1821 if (!resolve_order) {
1822 status = NT_STATUS_NO_MEMORY;
1823 goto out;
1824 }
1825 strlower_m(resolve_order);
1826 if (lookup_type == DC_ADS_ONLY) {
1827 if (strstr( resolve_order, "host")) {
1828 resolve_order = talloc_strdup(ctx, "ads");
1829
1830 /* DNS SRV lookups used by the ads resolver
1831 are already sorted by priority and weight */
1832 *ordered = true;
1833 } else {
1834 resolve_order = talloc_strdup(ctx, "NULL");
1835 }
1836 } else if (lookup_type == DC_KDC_ONLY) {
1837 /* DNS SRV lookups used by the ads/kdc resolver
1838 are already sorted by priority and weight */
1839 *ordered = true;
1840 resolve_order = talloc_strdup(ctx, "kdc");
1841 }
1842 if (!resolve_order) {
1843 status = NT_STATUS_NO_MEMORY;
1844 goto out;
1845 }
1846
1847 /* fetch the server we have affinity for. Add the
1848 'password server' list to a search for our domain controllers */
1849
1850 saf_servername = saf_fetch( domain);
1851
1852 if (strequal(domain, lp_workgroup()) || strequal(domain, lp_realm())) {
1853 pserver = talloc_asprintf(ctx, "%s, %s",
1854 saf_servername ? saf_servername : "",
1855 lp_passwordserver());
1856 } else {
1857 pserver = talloc_asprintf(ctx, "%s, *",
1858 saf_servername ? saf_servername : "");
1859 }
1860
1861 SAFE_FREE(saf_servername);
1862 if (!pserver) {
1863 status = NT_STATUS_NO_MEMORY;
1864 goto out;
1865 }
1866
1867 /* if we are starting from scratch, just lookup DOMAIN<0x1c> */
1868
1869 if (!*pserver ) {
1870 DEBUG(10,("get_dc_list: no preferred domain controllers.\n"));
1871 status = internal_resolve_name(domain, 0x1C, sitename, ip_list,
1872 count, resolve_order);
1873 goto out;
1874 }
1875
1876 DEBUG(3,("get_dc_list: preferred server list: \"%s\"\n", pserver ));
1877
1878 /*
1879 * if '*' appears in the "password server" list then add
1880 * an auto lookup to the list of manually configured
1881 * DC's. If any DC is listed by name, then the list should be
1882 * considered to be ordered
1883 */
1884
1885 p = pserver;
1886 while (next_token_talloc(ctx, &p, &name, LIST_SEP)) {
1887 if (!done_auto_lookup && strequal(name, "*")) {
1888 status = internal_resolve_name(domain, 0x1C, sitename,
1889 &auto_ip_list,
1890 &auto_count,
1891 resolve_order);
1892 if (NT_STATUS_IS_OK(status)) {
1893 num_addresses += auto_count;
1894 }
1895 done_auto_lookup = true;
1896 DEBUG(8,("Adding %d DC's from auto lookup\n",
1897 auto_count));
1898 } else {
1899 num_addresses++;
1900 }
1901 }
1902
1903 /* if we have no addresses and haven't done the auto lookup, then
1904 just return the list of DC's. Or maybe we just failed. */
1905
1906 if ((num_addresses == 0)) {
1907 if (done_auto_lookup) {
1908 DEBUG(4,("get_dc_list: no servers found\n"));
1909 status = NT_STATUS_NO_LOGON_SERVERS;
1910 goto out;
1911 }
1912 status = internal_resolve_name(domain, 0x1C, sitename, ip_list,
1913 count, resolve_order);
1914 goto out;
1915 }
1916
1917 if ((return_iplist = SMB_MALLOC_ARRAY(struct ip_service,
1918 num_addresses)) == NULL) {
1919 DEBUG(3,("get_dc_list: malloc fail !\n"));
1920 status = NT_STATUS_NO_MEMORY;
1921 goto out;
1922 }
1923
1924 p = pserver;
1925 local_count = 0;
1926
1927 /* fill in the return list now with real IP's */
1928
1929 while ((local_count<num_addresses) &&
1930 next_token_talloc(ctx, &p, &name, LIST_SEP)) {
1931 struct sockaddr_storage name_ss;
1932
1933 /* copy any addersses from the auto lookup */
1934
1935 if (strequal(name, "*")) {
1936 for (j=0; j<auto_count; j++) {
1937 char addr[INET6_ADDRSTRLEN];
1938 print_sockaddr(addr,
1939 sizeof(addr),
1940 &auto_ip_list[j].ss);
1941 /* Check for and don't copy any
1942 * known bad DC IP's. */
1943 if(!NT_STATUS_IS_OK(check_negative_conn_cache(
1944 domain,
1945 addr))) {
1946 DEBUG(5,("get_dc_list: "
1947 "negative entry %s removed "
1948 "from DC list\n",
1949 addr));
1950 continue;
1951 }
1952 return_iplist[local_count].ss =
1953 auto_ip_list[j].ss;
1954 return_iplist[local_count].port =
1955 auto_ip_list[j].port;
1956 local_count++;
1957 }
1958 continue;
1959 }
1960
1961 /* added support for address:port syntax for ads
1962 * (not that I think anyone will ever run the LDAP
1963 * server in an AD domain on something other than
1964 * port 389 */
1965
1966 port = (lp_security() == SEC_ADS) ? LDAP_PORT : PORT_NONE;
1967 if ((port_str=strchr(name, ':')) != NULL) {
1968 *port_str = '\0';
1969 port_str++;
1970 port = atoi(port_str);
1971 }
1972
1973 /* explicit lookup; resolve_name() will
1974 * handle names & IP addresses */
1975 if (resolve_name( name, &name_ss, 0x20, true )) {
1976 char addr[INET6_ADDRSTRLEN];
1977 print_sockaddr(addr,
1978 sizeof(addr),
1979 &name_ss);
1980
1981 /* Check for and don't copy any known bad DC IP's. */
1982 if( !NT_STATUS_IS_OK(check_negative_conn_cache(domain,
1983 addr)) ) {
1984 DEBUG(5,("get_dc_list: negative entry %s "
1985 "removed from DC list\n",
1986 name ));
1987 continue;
1988 }
1989
1990 return_iplist[local_count].ss = name_ss;
1991 return_iplist[local_count].port = port;
1992 local_count++;
1993 *ordered = true;
1994 }
1995 }
1996
1997 /* need to remove duplicates in the list if we have any
1998 explicit password servers */
1999
2000 if (local_count) {
2001 local_count = remove_duplicate_addrs2(return_iplist,
2002 local_count );
2003 }
2004
2005 /* For DC's we always prioritize IPv4 due to W2K3 not
2006 * supporting LDAP, KRB5 or CLDAP over IPv6. */
2007
2008 if (local_count && return_iplist) {
2009 prioritize_ipv4_list(return_iplist, local_count);
2010 }
2011
2012 if ( DEBUGLEVEL >= 4 ) {
2013 DEBUG(4,("get_dc_list: returning %d ip addresses "
2014 "in an %sordered list\n",
2015 local_count,
2016 *ordered ? "":"un"));
2017 DEBUG(4,("get_dc_list: "));
2018 for ( i=0; i<local_count; i++ ) {
2019 char addr[INET6_ADDRSTRLEN];
2020 print_sockaddr(addr,
2021 sizeof(addr),
2022 &return_iplist[i].ss);
2023 DEBUGADD(4,("%s:%d ", addr, return_iplist[i].port ));
2024 }
2025 DEBUGADD(4,("\n"));
2026 }
2027
2028 *ip_list = return_iplist;
2029 *count = local_count;
2030
2031 status = ( *count != 0 ? NT_STATUS_OK : NT_STATUS_NO_LOGON_SERVERS );
2032
2033 out:
2034
2035 if (!NT_STATUS_IS_OK(status)) {
2036 SAFE_FREE(return_iplist);
2037 *ip_list = NULL;
2038 *count = 0;
2039 }
2040
2041 SAFE_FREE(auto_ip_list);
2042 TALLOC_FREE(ctx);
2043 return status;
2044 }
2045
2046 /*********************************************************************
2047 Small wrapper function to get the DC list and sort it if neccessary.
2048 *********************************************************************/
2049
2050 NTSTATUS get_sorted_dc_list( const char *domain,
2051 const char *sitename,
2052 struct ip_service **ip_list,
2053 int *count,
2054 bool ads_only )
2055 {
2056 bool ordered = false;
2057 NTSTATUS status;
2058 enum dc_lookup_type lookup_type = DC_NORMAL_LOOKUP;
2059
2060 *ip_list = NULL;
2061 *count = 0;
2062
2063 DEBUG(8,("get_sorted_dc_list: attempting lookup "
2064 "for name %s (sitename %s) using [%s]\n",
2065 domain,
2066 sitename ? sitename : "NULL",
2067 (ads_only ? "ads" : lp_name_resolve_order())));
2068
2069 if (ads_only) {
2070 lookup_type = DC_ADS_ONLY;
2071 }
2072
2073 status = get_dc_list(domain, sitename, ip_list,
2074 count, lookup_type, &ordered);
2075 if (NT_STATUS_EQUAL(status, NT_STATUS_NO_LOGON_SERVERS)
2076 && sitename) {
2077 DEBUG(3,("get_sorted_dc_list: no server for name %s available"
2078 " in site %s, fallback to all servers\n",
2079 domain, sitename));
2080 status = get_dc_list(domain, NULL, ip_list,
2081 count, lookup_type, &ordered);
2082 }
2083
2084 if (!NT_STATUS_IS_OK(status)) {
2085 SAFE_FREE(*ip_list);
2086 *count = 0;
2087 return status;
2088 }
2089
2090 /* only sort if we don't already have an ordered list */
2091 if (!ordered) {
2092 sort_service_list(*ip_list, *count);
2093 }
2094
2095 return NT_STATUS_OK;
2096 }
2097
2098 /*********************************************************************
2099 Get the KDC list - re-use all the logic in get_dc_list.
2100 *********************************************************************/
2101
2102 NTSTATUS get_kdc_list( const char *realm,
2103 const char *sitename,
2104 struct ip_service **ip_list,
2105 int *count)
2106 {
2107 bool ordered;
2108 NTSTATUS status;
2109
2110 *count = 0;
2111 *ip_list = NULL;
2112
2113 status = get_dc_list(realm, sitename, ip_list,
2114 count, DC_KDC_ONLY, &ordered);
2115
2116 if (!NT_STATUS_IS_OK(status)) {
2117 SAFE_FREE(*ip_list);
2118 *count = 0;
2119 return status;
2120 }
2121
2122 /* only sort if we don't already have an ordered list */
2123 if ( !ordered ) {
2124 sort_service_list(*ip_list, *count);
2125 }
2126
2127 return NT_STATUS_OK;
2128 }
WIP