source: trunk/samba/source/libads/dns.c@ 133

Last change on this file since 133 was 133, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.0pre3
File size: 24.3 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 DNS utility library
4 Copyright (C) Gerald (Jerry) Carter 2006.
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
23/* AIX resolv.h uses 'class' in struct ns_rr */
24
25#if defined(AIX)
26# if defined(class)
27# undef class
28# endif
29#endif /* AIX */
30
31/* resolver headers */
32
33#include <sys/types.h>
34#include <netinet/in.h>
35#include <arpa/nameser.h>
36#include <resolv.h>
37#include <netdb.h>
38
39#define MAX_DNS_PACKET_SIZE 0xffff
40
41#ifdef NS_HFIXEDSZ /* Bind 8/9 interface */
42#if !defined(C_IN) /* AIX 5.3 already defines C_IN */
43# define C_IN ns_c_in
44#endif
45#if !defined(T_A) /* AIX 5.3 already defines T_A */
46# define T_A ns_t_a
47#endif
48
49#if defined(HAVE_IPV6)
50#if !defined(T_AAAA)
51# define T_AAAA ns_t_aaaa
52#endif
53#endif
54
55# define T_SRV ns_t_srv
56#if !defined(T_NS) /* AIX 5.3 already defines T_NS */
57# define T_NS ns_t_ns
58#endif
59#else
60# ifdef HFIXEDSZ
61# define NS_HFIXEDSZ HFIXEDSZ
62# else
63# define NS_HFIXEDSZ sizeof(HEADER)
64# endif /* HFIXEDSZ */
65# ifdef PACKETSZ
66# define NS_PACKETSZ PACKETSZ
67# else /* 512 is usually the default */
68# define NS_PACKETSZ 512
69# endif /* PACKETSZ */
70# define T_SRV 33
71#endif
72
73/*********************************************************************
74*********************************************************************/
75
76static bool ads_dns_parse_query( TALLOC_CTX *ctx, uint8 *start, uint8 *end,
77 uint8 **ptr, struct dns_query *q )
78{
79 uint8 *p = *ptr;
80 char hostname[MAX_DNS_NAME_LENGTH];
81 int namelen;
82
83 ZERO_STRUCTP( q );
84
85 if ( !start || !end || !q || !*ptr)
86 return False;
87
88 /* See RFC 1035 for details. If this fails, then return. */
89
90 namelen = dn_expand( start, end, p, hostname, sizeof(hostname) );
91 if ( namelen < 0 ) {
92 return False;
93 }
94 p += namelen;
95 q->hostname = talloc_strdup( ctx, hostname );
96
97 /* check that we have space remaining */
98
99 if ( PTR_DIFF(p+4, end) > 0 )
100 return False;
101
102 q->type = RSVAL( p, 0 );
103 q->in_class = RSVAL( p, 2 );
104 p += 4;
105
106 *ptr = p;
107
108 return True;
109}
110
111/*********************************************************************
112*********************************************************************/
113
114static bool ads_dns_parse_rr( TALLOC_CTX *ctx, uint8 *start, uint8 *end,
115 uint8 **ptr, struct dns_rr *rr )
116{
117 uint8 *p = *ptr;
118 char hostname[MAX_DNS_NAME_LENGTH];
119 int namelen;
120
121 if ( !start || !end || !rr || !*ptr)
122 return -1;
123
124 ZERO_STRUCTP( rr );
125 /* pull the name from the answer */
126
127 namelen = dn_expand( start, end, p, hostname, sizeof(hostname) );
128 if ( namelen < 0 ) {
129 return -1;
130 }
131 p += namelen;
132 rr->hostname = talloc_strdup( ctx, hostname );
133
134 /* check that we have space remaining */
135
136 if ( PTR_DIFF(p+10, end) > 0 )
137 return False;
138
139 /* pull some values and then skip onto the string */
140
141 rr->type = RSVAL(p, 0);
142 rr->in_class = RSVAL(p, 2);
143 rr->ttl = RIVAL(p, 4);
144 rr->rdatalen = RSVAL(p, 8);
145
146 p += 10;
147
148 /* sanity check the available space */
149
150 if ( PTR_DIFF(p+rr->rdatalen, end ) > 0 ) {
151 return False;
152
153 }
154
155 /* save a point to the rdata for this section */
156
157 rr->rdata = p;
158 p += rr->rdatalen;
159
160 *ptr = p;
161
162 return True;
163}
164
165/*********************************************************************
166*********************************************************************/
167
168static bool ads_dns_parse_rr_srv( TALLOC_CTX *ctx, uint8 *start, uint8 *end,
169 uint8 **ptr, struct dns_rr_srv *srv )
170{
171 struct dns_rr rr;
172 uint8 *p;
173 char dcname[MAX_DNS_NAME_LENGTH];
174 int namelen;
175
176 if ( !start || !end || !srv || !*ptr)
177 return -1;
178
179 /* Parse the RR entry. Coming out of the this, ptr is at the beginning
180 of the next record */
181
182 if ( !ads_dns_parse_rr( ctx, start, end, ptr, &rr ) ) {
183 DEBUG(1,("ads_dns_parse_rr_srv: Failed to parse RR record\n"));
184 return False;
185 }
186
187 if ( rr.type != T_SRV ) {
188 DEBUG(1,("ads_dns_parse_rr_srv: Bad answer type (%d)\n",
189 rr.type));
190 return False;
191 }
192
193 p = rr.rdata;
194
195 srv->priority = RSVAL(p, 0);
196 srv->weight = RSVAL(p, 2);
197 srv->port = RSVAL(p, 4);
198
199 p += 6;
200
201 namelen = dn_expand( start, end, p, dcname, sizeof(dcname) );
202 if ( namelen < 0 ) {
203 DEBUG(1,("ads_dns_parse_rr_srv: Failed to uncompress name!\n"));
204 return False;
205 }
206 srv->hostname = talloc_strdup( ctx, dcname );
207
208 return True;
209}
210
211/*********************************************************************
212*********************************************************************/
213
214static bool ads_dns_parse_rr_ns( TALLOC_CTX *ctx, uint8 *start, uint8 *end,
215 uint8 **ptr, struct dns_rr_ns *nsrec )
216{
217 struct dns_rr rr;
218 uint8 *p;
219 char nsname[MAX_DNS_NAME_LENGTH];
220 int namelen;
221
222 if ( !start || !end || !nsrec || !*ptr)
223 return -1;
224
225 /* Parse the RR entry. Coming out of the this, ptr is at the beginning
226 of the next record */
227
228 if ( !ads_dns_parse_rr( ctx, start, end, ptr, &rr ) ) {
229 DEBUG(1,("ads_dns_parse_rr_ns: Failed to parse RR record\n"));
230 return False;
231 }
232
233 if ( rr.type != T_NS ) {
234 DEBUG(1,("ads_dns_parse_rr_ns: Bad answer type (%d)\n",
235 rr.type));
236 return False;
237 }
238
239 p = rr.rdata;
240
241 /* ame server hostname */
242
243 namelen = dn_expand( start, end, p, nsname, sizeof(nsname) );
244 if ( namelen < 0 ) {
245 DEBUG(1,("ads_dns_parse_rr_ns: Failed to uncompress name!\n"));
246 return False;
247 }
248 nsrec->hostname = talloc_strdup( ctx, nsname );
249
250 return True;
251}
252
253/*********************************************************************
254 Sort SRV record list based on weight and priority. See RFC 2782.
255*********************************************************************/
256
257static int dnssrvcmp( struct dns_rr_srv *a, struct dns_rr_srv *b )
258{
259 if ( a->priority == b->priority ) {
260
261 /* randomize entries with an equal weight and priority */
262 if ( a->weight == b->weight )
263 return 0;
264
265 /* higher weights should be sorted lower */
266 if ( a->weight > b->weight )
267 return -1;
268 else
269 return 1;
270 }
271
272 if ( a->priority < b->priority )
273 return -1;
274
275 return 1;
276}
277
278/*********************************************************************
279 Simple wrapper for a DNS query
280*********************************************************************/
281
282#define DNS_FAILED_WAITTIME 30
283
284static NTSTATUS dns_send_req( TALLOC_CTX *ctx, const char *name, int q_type,
285 uint8 **buf, int *resp_length )
286{
287 uint8 *buffer = NULL;
288 size_t buf_len;
289 int resp_len = NS_PACKETSZ;
290 static time_t last_dns_check = 0;
291 static NTSTATUS last_dns_status = NT_STATUS_OK;
292 time_t now = time(NULL);
293
294 /* Try to prevent bursts of DNS lookups if the server is down */
295
296 /* Protect against large clock changes */
297
298 if ( last_dns_check > now )
299 last_dns_check = 0;
300
301 /* IF we had a DNS timeout or a bad server and we are still
302 in the 30 second cache window, just return the previous
303 status and save the network timeout. */
304
305 if ( (NT_STATUS_EQUAL(last_dns_status,NT_STATUS_IO_TIMEOUT) ||
306 NT_STATUS_EQUAL(last_dns_status,NT_STATUS_CONNECTION_REFUSED)) &&
307 (last_dns_check+DNS_FAILED_WAITTIME) > now )
308 {
309 DEBUG(10,("last_dns_check: Returning cached status (%s)\n",
310 nt_errstr(last_dns_status) ));
311 return last_dns_status;
312 }
313
314 /* Send the Query */
315 do {
316 if ( buffer )
317 TALLOC_FREE( buffer );
318
319 buf_len = resp_len * sizeof(uint8);
320
321 if (buf_len) {
322 if ((buffer = TALLOC_ARRAY(ctx, uint8, buf_len))
323 == NULL ) {
324 DEBUG(0,("ads_dns_lookup_srv: "
325 "talloc() failed!\n"));
326 last_dns_status = NT_STATUS_NO_MEMORY;
327 last_dns_check = time(NULL);
328 return last_dns_status;
329 }
330 }
331
332 if ((resp_len = res_query(name, C_IN, q_type, buffer, buf_len))
333 < 0 ) {
334 DEBUG(3,("ads_dns_lookup_srv: "
335 "Failed to resolve %s (%s)\n",
336 name, strerror(errno)));
337 TALLOC_FREE( buffer );
338 last_dns_status = NT_STATUS_UNSUCCESSFUL;
339
340 if (errno == ETIMEDOUT) {
341 last_dns_status = NT_STATUS_IO_TIMEOUT;
342 }
343 if (errno == ECONNREFUSED) {
344 last_dns_status = NT_STATUS_CONNECTION_REFUSED;
345 }
346 last_dns_check = time(NULL);
347 return last_dns_status;
348 }
349 } while ( buf_len < resp_len && resp_len < MAX_DNS_PACKET_SIZE );
350
351 *buf = buffer;
352 *resp_length = resp_len;
353
354 last_dns_check = time(NULL);
355 last_dns_status = NT_STATUS_OK;
356 return last_dns_status;
357}
358
359/*********************************************************************
360 Simple wrapper for a DNS SRV query
361*********************************************************************/
362
363static NTSTATUS ads_dns_lookup_srv( TALLOC_CTX *ctx,
364 const char *name,
365 struct dns_rr_srv **dclist,
366 int *numdcs)
367{
368 uint8 *buffer = NULL;
369 int resp_len = 0;
370 struct dns_rr_srv *dcs = NULL;
371 int query_count, answer_count, auth_count, additional_count;
372 uint8 *p = buffer;
373 int rrnum;
374 int idx = 0;
375 NTSTATUS status;
376
377 if ( !ctx || !name || !dclist ) {
378 return NT_STATUS_INVALID_PARAMETER;
379 }
380
381 /* Send the request. May have to loop several times in case
382 of large replies */
383
384 status = dns_send_req( ctx, name, T_SRV, &buffer, &resp_len );
385 if ( !NT_STATUS_IS_OK(status) ) {
386 DEBUG(3,("ads_dns_lookup_srv: Failed to send DNS query (%s)\n",
387 nt_errstr(status)));
388 return status;
389 }
390 p = buffer;
391
392 /* For some insane reason, the ns_initparse() et. al. routines are only
393 available in libresolv.a, and not the shared lib. Who knows why....
394 So we have to parse the DNS reply ourselves */
395
396 /* Pull the answer RR's count from the header.
397 * Use the NMB ordering macros */
398
399 query_count = RSVAL( p, 4 );
400 answer_count = RSVAL( p, 6 );
401 auth_count = RSVAL( p, 8 );
402 additional_count = RSVAL( p, 10 );
403
404 DEBUG(4,("ads_dns_lookup_srv: "
405 "%d records returned in the answer section.\n",
406 answer_count));
407
408 if (answer_count) {
409 if ((dcs = TALLOC_ZERO_ARRAY(ctx, struct dns_rr_srv,
410 answer_count)) == NULL ) {
411 DEBUG(0,("ads_dns_lookup_srv: "
412 "talloc() failure for %d char*'s\n",
413 answer_count));
414 return NT_STATUS_NO_MEMORY;
415 }
416 } else {
417 dcs = NULL;
418 }
419
420 /* now skip the header */
421
422 p += NS_HFIXEDSZ;
423
424 /* parse the query section */
425
426 for ( rrnum=0; rrnum<query_count; rrnum++ ) {
427 struct dns_query q;
428
429 if (!ads_dns_parse_query(ctx, buffer,
430 buffer+resp_len, &p, &q)) {
431 DEBUG(1,("ads_dns_lookup_srv: "
432 "Failed to parse query record!\n"));
433 return NT_STATUS_UNSUCCESSFUL;
434 }
435 }
436
437 /* now we are at the answer section */
438
439 for ( rrnum=0; rrnum<answer_count; rrnum++ ) {
440 if (!ads_dns_parse_rr_srv(ctx, buffer, buffer+resp_len,
441 &p, &dcs[rrnum])) {
442 DEBUG(1,("ads_dns_lookup_srv: "
443 "Failed to parse answer record!\n"));
444 return NT_STATUS_UNSUCCESSFUL;
445 }
446 }
447 idx = rrnum;
448
449 /* Parse the authority section */
450 /* just skip these for now */
451
452 for ( rrnum=0; rrnum<auth_count; rrnum++ ) {
453 struct dns_rr rr;
454
455 if (!ads_dns_parse_rr( ctx, buffer,
456 buffer+resp_len, &p, &rr)) {
457 DEBUG(1,("ads_dns_lookup_srv: "
458 "Failed to parse authority record!\n"));
459 return NT_STATUS_UNSUCCESSFUL;
460 }
461 }
462
463 /* Parse the additional records section */
464
465 for ( rrnum=0; rrnum<additional_count; rrnum++ ) {
466 struct dns_rr rr;
467 int i;
468
469 if (!ads_dns_parse_rr(ctx, buffer, buffer+resp_len,
470 &p, &rr)) {
471 DEBUG(1,("ads_dns_lookup_srv: Failed "
472 "to parse additional records section!\n"));
473 return NT_STATUS_UNSUCCESSFUL;
474 }
475
476 /* Only interested in A or AAAA records as a shortcut for having
477 * to come back later and lookup the name. For multi-homed
478 * hosts, the number of additional records and exceed the
479 * number of answer records. */
480
481 if (rr.type != T_A || rr.rdatalen != 4) {
482#if defined(HAVE_IPV6)
483 /* FIXME. RFC2874 defines A6 records. This
484 * requires recusive and horribly complex lookups.
485 * Bastards. Ignore this for now.... JRA.
486 */
487 if (rr.type != T_AAAA || rr.rdatalen != 16)
488#endif
489 continue;
490 }
491
492 for ( i=0; i<idx; i++ ) {
493 if ( strcmp( rr.hostname, dcs[i].hostname ) == 0 ) {
494 int num_ips = dcs[i].num_ips;
495 struct sockaddr_storage *tmp_ss_s;
496
497 /* allocate new memory */
498
499 if (dcs[i].num_ips == 0) {
500 if ((dcs[i].ss_s = TALLOC_ARRAY(dcs,
501 struct sockaddr_storage, 1 ))
502 == NULL ) {
503 return NT_STATUS_NO_MEMORY;
504 }
505 } else {
506 if ((tmp_ss_s = TALLOC_REALLOC_ARRAY(dcs,
507 dcs[i].ss_s,
508 struct sockaddr_storage,
509 dcs[i].num_ips+1))
510 == NULL ) {
511 return NT_STATUS_NO_MEMORY;
512 }
513
514 dcs[i].ss_s = tmp_ss_s;
515 }
516 dcs[i].num_ips++;
517
518 /* copy the new IP address */
519 if (rr.type == T_A) {
520 struct in_addr ip;
521 memcpy(&ip, rr.rdata, 4);
522 in_addr_to_sockaddr_storage(
523 &dcs[i].ss_s[num_ips],
524 ip);
525 }
526#if defined(HAVE_IPV6)
527 if (rr.type == T_AAAA) {
528 struct in6_addr ip6;
529 memcpy(&ip6, rr.rdata, rr.rdatalen);
530 in6_addr_to_sockaddr_storage(
531 &dcs[i].ss_s[num_ips],
532 ip6);
533 }
534#endif
535 }
536 }
537 }
538
539 qsort( dcs, idx, sizeof(struct dns_rr_srv), QSORT_CAST dnssrvcmp );
540
541 *dclist = dcs;
542 *numdcs = idx;
543
544 return NT_STATUS_OK;
545}
546
547/*********************************************************************
548 Simple wrapper for a DNS NS query
549*********************************************************************/
550
551NTSTATUS ads_dns_lookup_ns(TALLOC_CTX *ctx,
552 const char *dnsdomain,
553 struct dns_rr_ns **nslist,
554 int *numns)
555{
556 uint8 *buffer = NULL;
557 int resp_len = 0;
558 struct dns_rr_ns *nsarray = NULL;
559 int query_count, answer_count, auth_count, additional_count;
560 uint8 *p;
561 int rrnum;
562 int idx = 0;
563 NTSTATUS status;
564
565 if ( !ctx || !dnsdomain || !nslist ) {
566 return NT_STATUS_INVALID_PARAMETER;
567 }
568
569 /* Send the request. May have to loop several times in case
570 of large replies */
571
572 status = dns_send_req( ctx, dnsdomain, T_NS, &buffer, &resp_len );
573 if ( !NT_STATUS_IS_OK(status) ) {
574 DEBUG(3,("ads_dns_lookup_ns: Failed to send DNS query (%s)\n",
575 nt_errstr(status)));
576 return status;
577 }
578 p = buffer;
579
580 /* For some insane reason, the ns_initparse() et. al. routines are only
581 available in libresolv.a, and not the shared lib. Who knows why....
582 So we have to parse the DNS reply ourselves */
583
584 /* Pull the answer RR's count from the header.
585 * Use the NMB ordering macros */
586
587 query_count = RSVAL( p, 4 );
588 answer_count = RSVAL( p, 6 );
589 auth_count = RSVAL( p, 8 );
590 additional_count = RSVAL( p, 10 );
591
592 DEBUG(4,("ads_dns_lookup_ns: "
593 "%d records returned in the answer section.\n",
594 answer_count));
595
596 if (answer_count) {
597 if ((nsarray = TALLOC_ARRAY(ctx, struct dns_rr_ns,
598 answer_count)) == NULL ) {
599 DEBUG(0,("ads_dns_lookup_ns: "
600 "talloc() failure for %d char*'s\n",
601 answer_count));
602 return NT_STATUS_NO_MEMORY;
603 }
604 } else {
605 nsarray = NULL;
606 }
607
608 /* now skip the header */
609
610 p += NS_HFIXEDSZ;
611
612 /* parse the query section */
613
614 for ( rrnum=0; rrnum<query_count; rrnum++ ) {
615 struct dns_query q;
616
617 if (!ads_dns_parse_query(ctx, buffer, buffer+resp_len,
618 &p, &q)) {
619 DEBUG(1,("ads_dns_lookup_ns: "
620 " Failed to parse query record!\n"));
621 return NT_STATUS_UNSUCCESSFUL;
622 }
623 }
624
625 /* now we are at the answer section */
626
627 for ( rrnum=0; rrnum<answer_count; rrnum++ ) {
628 if (!ads_dns_parse_rr_ns(ctx, buffer, buffer+resp_len,
629 &p, &nsarray[rrnum])) {
630 DEBUG(1,("ads_dns_lookup_ns: "
631 "Failed to parse answer record!\n"));
632 return NT_STATUS_UNSUCCESSFUL;
633 }
634 }
635 idx = rrnum;
636
637 /* Parse the authority section */
638 /* just skip these for now */
639
640 for ( rrnum=0; rrnum<auth_count; rrnum++ ) {
641 struct dns_rr rr;
642
643 if ( !ads_dns_parse_rr(ctx, buffer, buffer+resp_len,
644 &p, &rr)) {
645 DEBUG(1,("ads_dns_lookup_ns: "
646 "Failed to parse authority record!\n"));
647 return NT_STATUS_UNSUCCESSFUL;
648 }
649 }
650
651 /* Parse the additional records section */
652
653 for ( rrnum=0; rrnum<additional_count; rrnum++ ) {
654 struct dns_rr rr;
655 int i;
656
657 if (!ads_dns_parse_rr(ctx, buffer, buffer+resp_len,
658 &p, &rr)) {
659 DEBUG(1,("ads_dns_lookup_ns: Failed "
660 "to parse additional records section!\n"));
661 return NT_STATUS_UNSUCCESSFUL;
662 }
663
664 /* only interested in A records as a shortcut for having to come
665 back later and lookup the name */
666
667 if (rr.type != T_A || rr.rdatalen != 4) {
668#if defined(HAVE_IPV6)
669 if (rr.type != T_AAAA || rr.rdatalen != 16)
670#endif
671 continue;
672 }
673
674 for ( i=0; i<idx; i++ ) {
675 if (strcmp(rr.hostname, nsarray[i].hostname) == 0) {
676 if (rr.type == T_A) {
677 struct in_addr ip;
678 memcpy(&ip, rr.rdata, 4);
679 in_addr_to_sockaddr_storage(
680 &nsarray[i].ss,
681 ip);
682 }
683#if defined(HAVE_IPV6)
684 if (rr.type == T_AAAA) {
685 struct in6_addr ip6;
686 memcpy(&ip6, rr.rdata, rr.rdatalen);
687 in6_addr_to_sockaddr_storage(
688 &nsarray[i].ss,
689 ip6);
690 }
691#endif
692 }
693 }
694 }
695
696 *nslist = nsarray;
697 *numns = idx;
698
699 return NT_STATUS_OK;
700}
701
702/****************************************************************************
703 Store and fetch the AD client sitename.
704****************************************************************************/
705
706#define SITENAME_KEY "AD_SITENAME/DOMAIN/%s"
707
708static char *sitename_key(const char *realm)
709{
710 char *keystr;
711
712 if (asprintf_strupper_m(&keystr, SITENAME_KEY, realm) == -1) {
713 return NULL;
714 }
715
716 return keystr;
717}
718
719
720/****************************************************************************
721 Store the AD client sitename.
722 We store indefinately as every new CLDAP query will re-write this.
723****************************************************************************/
724
725bool sitename_store(const char *realm, const char *sitename)
726{
727 time_t expire;
728 bool ret = False;
729 char *key;
730
731 if (!gencache_init()) {
732 return False;
733 }
734
735 if (!realm || (strlen(realm) == 0)) {
736 DEBUG(0,("sitename_store: no realm\n"));
737 return False;
738 }
739
740 key = sitename_key(realm);
741
742 if (!sitename || (sitename && !*sitename)) {
743 DEBUG(5,("sitename_store: deleting empty sitename!\n"));
744 ret = gencache_del(key);
745 SAFE_FREE(key);
746 return ret;
747 }
748
749 expire = get_time_t_max(); /* Store indefinately. */
750
751 DEBUG(10,("sitename_store: realm = [%s], sitename = [%s], expire = [%u]\n",
752 realm, sitename, (unsigned int)expire ));
753
754 ret = gencache_set( key, sitename, expire );
755 SAFE_FREE(key);
756 return ret;
757}
758
759/****************************************************************************
760 Fetch the AD client sitename.
761 Caller must free.
762****************************************************************************/
763
764char *sitename_fetch(const char *realm)
765{
766 char *sitename = NULL;
767 time_t timeout;
768 bool ret = False;
769 const char *query_realm;
770 char *key;
771
772 if (!gencache_init()) {
773 return False;
774 }
775
776 if (!realm || (strlen(realm) == 0)) {
777 query_realm = lp_realm();
778 } else {
779 query_realm = realm;
780 }
781
782 key = sitename_key(query_realm);
783
784 ret = gencache_get( key, &sitename, &timeout );
785 SAFE_FREE(key);
786 if ( !ret ) {
787 DEBUG(5,("sitename_fetch: No stored sitename for %s\n",
788 query_realm));
789 } else {
790 DEBUG(5,("sitename_fetch: Returning sitename for %s: \"%s\"\n",
791 query_realm, sitename ));
792 }
793 return sitename;
794}
795
796/****************************************************************************
797 Did the sitename change ?
798****************************************************************************/
799
800bool stored_sitename_changed(const char *realm, const char *sitename)
801{
802 bool ret = False;
803
804 char *new_sitename;
805
806 if (!realm || (strlen(realm) == 0)) {
807 DEBUG(0,("stored_sitename_changed: no realm\n"));
808 return False;
809 }
810
811 new_sitename = sitename_fetch(realm);
812
813 if (sitename && new_sitename && !strequal(sitename, new_sitename)) {
814 ret = True;
815 } else if ((sitename && !new_sitename) ||
816 (!sitename && new_sitename)) {
817 ret = True;
818 }
819 SAFE_FREE(new_sitename);
820 return ret;
821}
822
823/********************************************************************
824 Query with optional sitename.
825********************************************************************/
826
827static NTSTATUS ads_dns_query_internal(TALLOC_CTX *ctx,
828 const char *servicename,
829 const char *dc_pdc_gc_domains,
830 const char *realm,
831 const char *sitename,
832 struct dns_rr_srv **dclist,
833 int *numdcs )
834{
835 char *name;
836 if (sitename) {
837 name = talloc_asprintf(ctx, "%s._tcp.%s._sites.%s._msdcs.%s",
838 servicename, sitename,
839 dc_pdc_gc_domains, realm);
840 } else {
841 name = talloc_asprintf(ctx, "%s._tcp.%s._msdcs.%s",
842 servicename, dc_pdc_gc_domains, realm);
843 }
844 if (!name) {
845 return NT_STATUS_NO_MEMORY;
846 }
847 return ads_dns_lookup_srv( ctx, name, dclist, numdcs );
848}
849
850/********************************************************************
851 Query for AD DC's.
852********************************************************************/
853
854NTSTATUS ads_dns_query_dcs(TALLOC_CTX *ctx,
855 const char *realm,
856 const char *sitename,
857 struct dns_rr_srv **dclist,
858 int *numdcs )
859{
860 NTSTATUS status;
861
862 status = ads_dns_query_internal(ctx, "_ldap", "dc", realm, sitename,
863 dclist, numdcs);
864
865 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
866 NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_REFUSED)) {
867 return status;
868 }
869
870 if (sitename &&
871 ((!NT_STATUS_IS_OK(status)) ||
872 (NT_STATUS_IS_OK(status) && (numdcs == 0)))) {
873 /* Sitename DNS query may have failed. Try without. */
874 status = ads_dns_query_internal(ctx, "_ldap", "dc", realm,
875 NULL, dclist, numdcs);
876 }
877 return status;
878}
879
880/********************************************************************
881 Query for AD GC's.
882********************************************************************/
883
884NTSTATUS ads_dns_query_gcs(TALLOC_CTX *ctx,
885 const char *realm,
886 const char *sitename,
887 struct dns_rr_srv **dclist,
888 int *numdcs )
889{
890 NTSTATUS status;
891
892 status = ads_dns_query_internal(ctx, "_ldap", "gc", realm, sitename,
893 dclist, numdcs);
894
895 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
896 NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_REFUSED)) {
897 return status;
898 }
899
900 if (sitename &&
901 ((!NT_STATUS_IS_OK(status)) ||
902 (NT_STATUS_IS_OK(status) && (numdcs == 0)))) {
903 /* Sitename DNS query may have failed. Try without. */
904 status = ads_dns_query_internal(ctx, "_ldap", "gc", realm,
905 NULL, dclist, numdcs);
906 }
907 return status;
908}
909
910/********************************************************************
911 Query for AD KDC's.
912 Even if our underlying kerberos libraries are UDP only, this
913 is pretty safe as it's unlikely that a KDC supports TCP and not UDP.
914********************************************************************/
915
916NTSTATUS ads_dns_query_kdcs(TALLOC_CTX *ctx,
917 const char *dns_forest_name,
918 const char *sitename,
919 struct dns_rr_srv **dclist,
920 int *numdcs )
921{
922 NTSTATUS status;
923
924 status = ads_dns_query_internal(ctx, "_kerberos", "dc",
925 dns_forest_name, sitename, dclist,
926 numdcs);
927
928 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
929 NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_REFUSED)) {
930 return status;
931 }
932
933 if (sitename &&
934 ((!NT_STATUS_IS_OK(status)) ||
935 (NT_STATUS_IS_OK(status) && (numdcs == 0)))) {
936 /* Sitename DNS query may have failed. Try without. */
937 status = ads_dns_query_internal(ctx, "_kerberos", "dc",
938 dns_forest_name, NULL,
939 dclist, numdcs);
940 }
941 return status;
942}
943
944/********************************************************************
945 Query for AD PDC. Sitename is obsolete here.
946********************************************************************/
947
948NTSTATUS ads_dns_query_pdc(TALLOC_CTX *ctx,
949 const char *dns_domain_name,
950 struct dns_rr_srv **dclist,
951 int *numdcs )
952{
953 return ads_dns_query_internal(ctx, "_ldap", "pdc", dns_domain_name,
954 NULL, dclist, numdcs);
955}
956
957/********************************************************************
958 Query for AD DC by guid. Sitename is obsolete here.
959********************************************************************/
960
961NTSTATUS ads_dns_query_dcs_guid(TALLOC_CTX *ctx,
962 const char *dns_forest_name,
963 const struct GUID *domain_guid,
964 struct dns_rr_srv **dclist,
965 int *numdcs )
966{
967 /*_ldap._tcp.DomainGuid.domains._msdcs.DnsForestName */
968
969 const char *domains;
970 const char *guid_string;
971
972 guid_string = GUID_string(ctx, domain_guid);
973 if (!guid_string) {
974 return NT_STATUS_NO_MEMORY;
975 }
976
977 /* little hack */
978 domains = talloc_asprintf(ctx, "%s.domains", guid_string);
979 if (!domains) {
980 return NT_STATUS_NO_MEMORY;
981 }
982
983 return ads_dns_query_internal(ctx, "_ldap", domains, dns_forest_name,
984 NULL, dclist, numdcs);
985}
Note: See TracBrowser for help on using the repository browser.