source: branches/samba-3.3.x/source/libads/dns.c

Last change on this file was 206, checked in by Herwig Bauernfeind, 16 years ago

Import Samba 3.3 branch at 3.0.0 level (psmedley's port)
File size: 25.1 KB
RevLine 
[206]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
207 srv->hostname = talloc_strdup( ctx, dcname );
208
209 DEBUG(10,("ads_dns_parse_rr_srv: Parsed %s [%u, %u, %u]\n",
210 srv->hostname,
211 srv->priority,
212 srv->weight,
213 srv->port));
214
215 return True;
216}
217
218/*********************************************************************
219*********************************************************************/
220
221static bool ads_dns_parse_rr_ns( TALLOC_CTX *ctx, uint8 *start, uint8 *end,
222 uint8 **ptr, struct dns_rr_ns *nsrec )
223{
224 struct dns_rr rr;
225 uint8 *p;
226 char nsname[MAX_DNS_NAME_LENGTH];
227 int namelen;
228
229 if ( !start || !end || !nsrec || !*ptr)
230 return -1;
231
232 /* Parse the RR entry. Coming out of the this, ptr is at the beginning
233 of the next record */
234
235 if ( !ads_dns_parse_rr( ctx, start, end, ptr, &rr ) ) {
236 DEBUG(1,("ads_dns_parse_rr_ns: Failed to parse RR record\n"));
237 return False;
238 }
239
240 if ( rr.type != T_NS ) {
241 DEBUG(1,("ads_dns_parse_rr_ns: Bad answer type (%d)\n",
242 rr.type));
243 return False;
244 }
245
246 p = rr.rdata;
247
248 /* ame server hostname */
249
250 namelen = dn_expand( start, end, p, nsname, sizeof(nsname) );
251 if ( namelen < 0 ) {
252 DEBUG(1,("ads_dns_parse_rr_ns: Failed to uncompress name!\n"));
253 return False;
254 }
255 nsrec->hostname = talloc_strdup( ctx, nsname );
256
257 return True;
258}
259
260/*********************************************************************
261 Sort SRV record list based on weight and priority. See RFC 2782.
262*********************************************************************/
263
264static int dnssrvcmp( struct dns_rr_srv *a, struct dns_rr_srv *b )
265{
266 if ( a->priority == b->priority ) {
267
268 /* randomize entries with an equal weight and priority */
269 if ( a->weight == b->weight )
270 return 0;
271
272 /* higher weights should be sorted lower */
273 if ( a->weight > b->weight )
274 return -1;
275 else
276 return 1;
277 }
278
279 if ( a->priority < b->priority )
280 return -1;
281
282 return 1;
283}
284
285/*********************************************************************
286 Simple wrapper for a DNS query
287*********************************************************************/
288
289#define DNS_FAILED_WAITTIME 30
290
291static NTSTATUS dns_send_req( TALLOC_CTX *ctx, const char *name, int q_type,
292 uint8 **buf, int *resp_length )
293{
294 uint8 *buffer = NULL;
295 size_t buf_len = 0;
296 int resp_len = NS_PACKETSZ;
297 static time_t last_dns_check = 0;
298 static NTSTATUS last_dns_status = NT_STATUS_OK;
299 time_t now = time(NULL);
300
301 /* Try to prevent bursts of DNS lookups if the server is down */
302
303 /* Protect against large clock changes */
304
305 if ( last_dns_check > now )
306 last_dns_check = 0;
307
308 /* IF we had a DNS timeout or a bad server and we are still
309 in the 30 second cache window, just return the previous
310 status and save the network timeout. */
311
312 if ( (NT_STATUS_EQUAL(last_dns_status,NT_STATUS_IO_TIMEOUT) ||
313 NT_STATUS_EQUAL(last_dns_status,NT_STATUS_CONNECTION_REFUSED)) &&
314 (last_dns_check+DNS_FAILED_WAITTIME) > now )
315 {
316 DEBUG(10,("last_dns_check: Returning cached status (%s)\n",
317 nt_errstr(last_dns_status) ));
318 return last_dns_status;
319 }
320
321 /* Send the Query */
322 do {
323 if ( buffer )
324 TALLOC_FREE( buffer );
325
326 buf_len = resp_len * sizeof(uint8);
327
328 if (buf_len) {
329 if ((buffer = TALLOC_ARRAY(ctx, uint8, buf_len))
330 == NULL ) {
331 DEBUG(0,("ads_dns_lookup_srv: "
332 "talloc() failed!\n"));
333 last_dns_status = NT_STATUS_NO_MEMORY;
334 last_dns_check = time(NULL);
335 return last_dns_status;
336 }
337 }
338
339 if ((resp_len = res_query(name, C_IN, q_type, buffer, buf_len))
340 < 0 ) {
341 DEBUG(3,("ads_dns_lookup_srv: "
342 "Failed to resolve %s (%s)\n",
343 name, strerror(errno)));
344 TALLOC_FREE( buffer );
345 last_dns_status = NT_STATUS_UNSUCCESSFUL;
346
347 if (errno == ETIMEDOUT) {
348 last_dns_status = NT_STATUS_IO_TIMEOUT;
349 }
350 if (errno == ECONNREFUSED) {
351 last_dns_status = NT_STATUS_CONNECTION_REFUSED;
352 }
353 last_dns_check = time(NULL);
354 return last_dns_status;
355 }
356
357 /* On AIX, Solaris, and possibly some older glibc systems (e.g. SLES8)
358 truncated replies never give back a resp_len > buflen
359 which ends up causing DNS resolve failures on large tcp DNS replies */
360
361 if (buf_len == resp_len) {
362 if (resp_len == MAX_DNS_PACKET_SIZE) {
363 DEBUG(1,("dns_send_req: DNS reply too large when resolving %s\n",
364 name));
365 TALLOC_FREE( buffer );
366 last_dns_status = NT_STATUS_BUFFER_TOO_SMALL;
367 last_dns_check = time(NULL);
368 return last_dns_status;
369 }
370
371 resp_len = MIN(resp_len*2, MAX_DNS_PACKET_SIZE);
372 }
373
374
375 } while ( buf_len < resp_len && resp_len <= MAX_DNS_PACKET_SIZE );
376
377 *buf = buffer;
378 *resp_length = resp_len;
379
380 last_dns_check = time(NULL);
381 last_dns_status = NT_STATUS_OK;
382 return last_dns_status;
383}
384
385/*********************************************************************
386 Simple wrapper for a DNS SRV query
387*********************************************************************/
388
389static NTSTATUS ads_dns_lookup_srv( TALLOC_CTX *ctx,
390 const char *name,
391 struct dns_rr_srv **dclist,
392 int *numdcs)
393{
394 uint8 *buffer = NULL;
395 int resp_len = 0;
396 struct dns_rr_srv *dcs = NULL;
397 int query_count, answer_count, auth_count, additional_count;
398 uint8 *p = buffer;
399 int rrnum;
400 int idx = 0;
401 NTSTATUS status;
402
403 if ( !ctx || !name || !dclist ) {
404 return NT_STATUS_INVALID_PARAMETER;
405 }
406
407 /* Send the request. May have to loop several times in case
408 of large replies */
409
410 status = dns_send_req( ctx, name, T_SRV, &buffer, &resp_len );
411 if ( !NT_STATUS_IS_OK(status) ) {
412 DEBUG(3,("ads_dns_lookup_srv: Failed to send DNS query (%s)\n",
413 nt_errstr(status)));
414 return status;
415 }
416 p = buffer;
417
418 /* For some insane reason, the ns_initparse() et. al. routines are only
419 available in libresolv.a, and not the shared lib. Who knows why....
420 So we have to parse the DNS reply ourselves */
421
422 /* Pull the answer RR's count from the header.
423 * Use the NMB ordering macros */
424
425 query_count = RSVAL( p, 4 );
426 answer_count = RSVAL( p, 6 );
427 auth_count = RSVAL( p, 8 );
428 additional_count = RSVAL( p, 10 );
429
430 DEBUG(4,("ads_dns_lookup_srv: "
431 "%d records returned in the answer section.\n",
432 answer_count));
433
434 if (answer_count) {
435 if ((dcs = TALLOC_ZERO_ARRAY(ctx, struct dns_rr_srv,
436 answer_count)) == NULL ) {
437 DEBUG(0,("ads_dns_lookup_srv: "
438 "talloc() failure for %d char*'s\n",
439 answer_count));
440 return NT_STATUS_NO_MEMORY;
441 }
442 } else {
443 dcs = NULL;
444 }
445
446 /* now skip the header */
447
448 p += NS_HFIXEDSZ;
449
450 /* parse the query section */
451
452 for ( rrnum=0; rrnum<query_count; rrnum++ ) {
453 struct dns_query q;
454
455 if (!ads_dns_parse_query(ctx, buffer,
456 buffer+resp_len, &p, &q)) {
457 DEBUG(1,("ads_dns_lookup_srv: "
458 "Failed to parse query record [%d]!\n", rrnum));
459 return NT_STATUS_UNSUCCESSFUL;
460 }
461 }
462
463 /* now we are at the answer section */
464
465 for ( rrnum=0; rrnum<answer_count; rrnum++ ) {
466 if (!ads_dns_parse_rr_srv(ctx, buffer, buffer+resp_len,
467 &p, &dcs[rrnum])) {
468 DEBUG(1,("ads_dns_lookup_srv: "
469 "Failed to parse answer recordi [%d]!\n", rrnum));
470 return NT_STATUS_UNSUCCESSFUL;
471 }
472 }
473 idx = rrnum;
474
475 /* Parse the authority section */
476 /* just skip these for now */
477
478 for ( rrnum=0; rrnum<auth_count; rrnum++ ) {
479 struct dns_rr rr;
480
481 if (!ads_dns_parse_rr( ctx, buffer,
482 buffer+resp_len, &p, &rr)) {
483 DEBUG(1,("ads_dns_lookup_srv: "
484 "Failed to parse authority record! [%d]\n", rrnum));
485 return NT_STATUS_UNSUCCESSFUL;
486 }
487 }
488
489 /* Parse the additional records section */
490
491 for ( rrnum=0; rrnum<additional_count; rrnum++ ) {
492 struct dns_rr rr;
493 int i;
494
495 if (!ads_dns_parse_rr(ctx, buffer, buffer+resp_len,
496 &p, &rr)) {
497 DEBUG(1,("ads_dns_lookup_srv: Failed "
498 "to parse additional records section! [%d]\n", rrnum));
499 return NT_STATUS_UNSUCCESSFUL;
500 }
501
502 /* Only interested in A or AAAA records as a shortcut for having
503 * to come back later and lookup the name. For multi-homed
504 * hosts, the number of additional records and exceed the
505 * number of answer records. */
506
507 if (rr.type != T_A || rr.rdatalen != 4) {
508#if defined(HAVE_IPV6)
509 /* FIXME. RFC2874 defines A6 records. This
510 * requires recusive and horribly complex lookups.
511 * Bastards. Ignore this for now.... JRA.
512 */
513 if (rr.type != T_AAAA || rr.rdatalen != 16)
514#endif
515 continue;
516 }
517
518 for ( i=0; i<idx; i++ ) {
519 if ( strcmp( rr.hostname, dcs[i].hostname ) == 0 ) {
520 int num_ips = dcs[i].num_ips;
521 struct sockaddr_storage *tmp_ss_s;
522
523 /* allocate new memory */
524
525 if (dcs[i].num_ips == 0) {
526 if ((dcs[i].ss_s = TALLOC_ARRAY(dcs,
527 struct sockaddr_storage, 1 ))
528 == NULL ) {
529 return NT_STATUS_NO_MEMORY;
530 }
531 } else {
532 if ((tmp_ss_s = TALLOC_REALLOC_ARRAY(dcs,
533 dcs[i].ss_s,
534 struct sockaddr_storage,
535 dcs[i].num_ips+1))
536 == NULL ) {
537 return NT_STATUS_NO_MEMORY;
538 }
539
540 dcs[i].ss_s = tmp_ss_s;
541 }
542 dcs[i].num_ips++;
543
544 /* copy the new IP address */
545 if (rr.type == T_A) {
546 struct in_addr ip;
547 memcpy(&ip, rr.rdata, 4);
548 in_addr_to_sockaddr_storage(
549 &dcs[i].ss_s[num_ips],
550 ip);
551 }
552#if defined(HAVE_IPV6)
553 if (rr.type == T_AAAA) {
554 struct in6_addr ip6;
555 memcpy(&ip6, rr.rdata, rr.rdatalen);
556 in6_addr_to_sockaddr_storage(
557 &dcs[i].ss_s[num_ips],
558 ip6);
559 }
560#endif
561 }
562 }
563 }
564
565 qsort( dcs, idx, sizeof(struct dns_rr_srv), QSORT_CAST dnssrvcmp );
566
567 *dclist = dcs;
568 *numdcs = idx;
569
570 return NT_STATUS_OK;
571}
572
573/*********************************************************************
574 Simple wrapper for a DNS NS query
575*********************************************************************/
576
577NTSTATUS ads_dns_lookup_ns(TALLOC_CTX *ctx,
578 const char *dnsdomain,
579 struct dns_rr_ns **nslist,
580 int *numns)
581{
582 uint8 *buffer = NULL;
583 int resp_len = 0;
584 struct dns_rr_ns *nsarray = NULL;
585 int query_count, answer_count, auth_count, additional_count;
586 uint8 *p;
587 int rrnum;
588 int idx = 0;
589 NTSTATUS status;
590
591 if ( !ctx || !dnsdomain || !nslist ) {
592 return NT_STATUS_INVALID_PARAMETER;
593 }
594
595 /* Send the request. May have to loop several times in case
596 of large replies */
597
598 status = dns_send_req( ctx, dnsdomain, T_NS, &buffer, &resp_len );
599 if ( !NT_STATUS_IS_OK(status) ) {
600 DEBUG(3,("ads_dns_lookup_ns: Failed to send DNS query (%s)\n",
601 nt_errstr(status)));
602 return status;
603 }
604 p = buffer;
605
606 /* For some insane reason, the ns_initparse() et. al. routines are only
607 available in libresolv.a, and not the shared lib. Who knows why....
608 So we have to parse the DNS reply ourselves */
609
610 /* Pull the answer RR's count from the header.
611 * Use the NMB ordering macros */
612
613 query_count = RSVAL( p, 4 );
614 answer_count = RSVAL( p, 6 );
615 auth_count = RSVAL( p, 8 );
616 additional_count = RSVAL( p, 10 );
617
618 DEBUG(4,("ads_dns_lookup_ns: "
619 "%d records returned in the answer section.\n",
620 answer_count));
621
622 if (answer_count) {
623 if ((nsarray = TALLOC_ARRAY(ctx, struct dns_rr_ns,
624 answer_count)) == NULL ) {
625 DEBUG(0,("ads_dns_lookup_ns: "
626 "talloc() failure for %d char*'s\n",
627 answer_count));
628 return NT_STATUS_NO_MEMORY;
629 }
630 } else {
631 nsarray = NULL;
632 }
633
634 /* now skip the header */
635
636 p += NS_HFIXEDSZ;
637
638 /* parse the query section */
639
640 for ( rrnum=0; rrnum<query_count; rrnum++ ) {
641 struct dns_query q;
642
643 if (!ads_dns_parse_query(ctx, buffer, buffer+resp_len,
644 &p, &q)) {
645 DEBUG(1,("ads_dns_lookup_ns: "
646 " Failed to parse query record!\n"));
647 return NT_STATUS_UNSUCCESSFUL;
648 }
649 }
650
651 /* now we are at the answer section */
652
653 for ( rrnum=0; rrnum<answer_count; rrnum++ ) {
654 if (!ads_dns_parse_rr_ns(ctx, buffer, buffer+resp_len,
655 &p, &nsarray[rrnum])) {
656 DEBUG(1,("ads_dns_lookup_ns: "
657 "Failed to parse answer record!\n"));
658 return NT_STATUS_UNSUCCESSFUL;
659 }
660 }
661 idx = rrnum;
662
663 /* Parse the authority section */
664 /* just skip these for now */
665
666 for ( rrnum=0; rrnum<auth_count; rrnum++ ) {
667 struct dns_rr rr;
668
669 if ( !ads_dns_parse_rr(ctx, buffer, buffer+resp_len,
670 &p, &rr)) {
671 DEBUG(1,("ads_dns_lookup_ns: "
672 "Failed to parse authority record!\n"));
673 return NT_STATUS_UNSUCCESSFUL;
674 }
675 }
676
677 /* Parse the additional records section */
678
679 for ( rrnum=0; rrnum<additional_count; rrnum++ ) {
680 struct dns_rr rr;
681 int i;
682
683 if (!ads_dns_parse_rr(ctx, buffer, buffer+resp_len,
684 &p, &rr)) {
685 DEBUG(1,("ads_dns_lookup_ns: Failed "
686 "to parse additional records section!\n"));
687 return NT_STATUS_UNSUCCESSFUL;
688 }
689
690 /* only interested in A records as a shortcut for having to come
691 back later and lookup the name */
692
693 if (rr.type != T_A || rr.rdatalen != 4) {
694#if defined(HAVE_IPV6)
695 if (rr.type != T_AAAA || rr.rdatalen != 16)
696#endif
697 continue;
698 }
699
700 for ( i=0; i<idx; i++ ) {
701 if (strcmp(rr.hostname, nsarray[i].hostname) == 0) {
702 if (rr.type == T_A) {
703 struct in_addr ip;
704 memcpy(&ip, rr.rdata, 4);
705 in_addr_to_sockaddr_storage(
706 &nsarray[i].ss,
707 ip);
708 }
709#if defined(HAVE_IPV6)
710 if (rr.type == T_AAAA) {
711 struct in6_addr ip6;
712 memcpy(&ip6, rr.rdata, rr.rdatalen);
713 in6_addr_to_sockaddr_storage(
714 &nsarray[i].ss,
715 ip6);
716 }
717#endif
718 }
719 }
720 }
721
722 *nslist = nsarray;
723 *numns = idx;
724
725 return NT_STATUS_OK;
726}
727
728/****************************************************************************
729 Store and fetch the AD client sitename.
730****************************************************************************/
731
732#define SITENAME_KEY "AD_SITENAME/DOMAIN/%s"
733
734static char *sitename_key(const char *realm)
735{
736 char *keystr;
737
738 if (asprintf_strupper_m(&keystr, SITENAME_KEY, realm) == -1) {
739 return NULL;
740 }
741
742 return keystr;
743}
744
745
746/****************************************************************************
747 Store the AD client sitename.
748 We store indefinately as every new CLDAP query will re-write this.
749****************************************************************************/
750
751bool sitename_store(const char *realm, const char *sitename)
752{
753 time_t expire;
754 bool ret = False;
755 char *key;
756
757 if (!gencache_init()) {
758 return False;
759 }
760
761 if (!realm || (strlen(realm) == 0)) {
762 DEBUG(0,("sitename_store: no realm\n"));
763 return False;
764 }
765
766 key = sitename_key(realm);
767
768 if (!sitename || (sitename && !*sitename)) {
769 DEBUG(5,("sitename_store: deleting empty sitename!\n"));
770 ret = gencache_del(key);
771 SAFE_FREE(key);
772 return ret;
773 }
774
775 expire = get_time_t_max(); /* Store indefinately. */
776
777 DEBUG(10,("sitename_store: realm = [%s], sitename = [%s], expire = [%u]\n",
778 realm, sitename, (unsigned int)expire ));
779
780 ret = gencache_set( key, sitename, expire );
781 SAFE_FREE(key);
782 return ret;
783}
784
785/****************************************************************************
786 Fetch the AD client sitename.
787 Caller must free.
788****************************************************************************/
789
790char *sitename_fetch(const char *realm)
791{
792 char *sitename = NULL;
793 time_t timeout;
794 bool ret = False;
795 const char *query_realm;
796 char *key;
797
798 if (!gencache_init()) {
799 return NULL;
800 }
801
802 if (!realm || (strlen(realm) == 0)) {
803 query_realm = lp_realm();
804 } else {
805 query_realm = realm;
806 }
807
808 key = sitename_key(query_realm);
809
810 ret = gencache_get( key, &sitename, &timeout );
811 SAFE_FREE(key);
812 if ( !ret ) {
813 DEBUG(5,("sitename_fetch: No stored sitename for %s\n",
814 query_realm));
815 } else {
816 DEBUG(5,("sitename_fetch: Returning sitename for %s: \"%s\"\n",
817 query_realm, sitename ));
818 }
819 return sitename;
820}
821
822/****************************************************************************
823 Did the sitename change ?
824****************************************************************************/
825
826bool stored_sitename_changed(const char *realm, const char *sitename)
827{
828 bool ret = False;
829
830 char *new_sitename;
831
832 if (!realm || (strlen(realm) == 0)) {
833 DEBUG(0,("stored_sitename_changed: no realm\n"));
834 return False;
835 }
836
837 new_sitename = sitename_fetch(realm);
838
839 if (sitename && new_sitename && !strequal(sitename, new_sitename)) {
840 ret = True;
841 } else if ((sitename && !new_sitename) ||
842 (!sitename && new_sitename)) {
843 ret = True;
844 }
845 SAFE_FREE(new_sitename);
846 return ret;
847}
848
849/********************************************************************
850 Query with optional sitename.
851********************************************************************/
852
853static NTSTATUS ads_dns_query_internal(TALLOC_CTX *ctx,
854 const char *servicename,
855 const char *dc_pdc_gc_domains,
856 const char *realm,
857 const char *sitename,
858 struct dns_rr_srv **dclist,
859 int *numdcs )
860{
861 char *name;
862 if (sitename) {
863 name = talloc_asprintf(ctx, "%s._tcp.%s._sites.%s._msdcs.%s",
864 servicename, sitename,
865 dc_pdc_gc_domains, realm);
866 } else {
867 name = talloc_asprintf(ctx, "%s._tcp.%s._msdcs.%s",
868 servicename, dc_pdc_gc_domains, realm);
869 }
870 if (!name) {
871 return NT_STATUS_NO_MEMORY;
872 }
873 return ads_dns_lookup_srv( ctx, name, dclist, numdcs );
874}
875
876/********************************************************************
877 Query for AD DC's.
878********************************************************************/
879
880NTSTATUS ads_dns_query_dcs(TALLOC_CTX *ctx,
881 const char *realm,
882 const char *sitename,
883 struct dns_rr_srv **dclist,
884 int *numdcs )
885{
886 NTSTATUS status;
887
888 status = ads_dns_query_internal(ctx, "_ldap", "dc", realm, sitename,
889 dclist, numdcs);
890
891 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
892 NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_REFUSED)) {
893 return status;
894 }
895
896 if (sitename &&
897 ((!NT_STATUS_IS_OK(status)) ||
898 (NT_STATUS_IS_OK(status) && (numdcs == 0)))) {
899 /* Sitename DNS query may have failed. Try without. */
900 status = ads_dns_query_internal(ctx, "_ldap", "dc", realm,
901 NULL, dclist, numdcs);
902 }
903 return status;
904}
905
906/********************************************************************
907 Query for AD GC's.
908********************************************************************/
909
910NTSTATUS ads_dns_query_gcs(TALLOC_CTX *ctx,
911 const char *realm,
912 const char *sitename,
913 struct dns_rr_srv **dclist,
914 int *numdcs )
915{
916 NTSTATUS status;
917
918 status = ads_dns_query_internal(ctx, "_ldap", "gc", realm, sitename,
919 dclist, numdcs);
920
921 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
922 NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_REFUSED)) {
923 return status;
924 }
925
926 if (sitename &&
927 ((!NT_STATUS_IS_OK(status)) ||
928 (NT_STATUS_IS_OK(status) && (numdcs == 0)))) {
929 /* Sitename DNS query may have failed. Try without. */
930 status = ads_dns_query_internal(ctx, "_ldap", "gc", realm,
931 NULL, dclist, numdcs);
932 }
933 return status;
934}
935
936/********************************************************************
937 Query for AD KDC's.
938 Even if our underlying kerberos libraries are UDP only, this
939 is pretty safe as it's unlikely that a KDC supports TCP and not UDP.
940********************************************************************/
941
942NTSTATUS ads_dns_query_kdcs(TALLOC_CTX *ctx,
943 const char *dns_forest_name,
944 const char *sitename,
945 struct dns_rr_srv **dclist,
946 int *numdcs )
947{
948 NTSTATUS status;
949
950 status = ads_dns_query_internal(ctx, "_kerberos", "dc",
951 dns_forest_name, sitename, dclist,
952 numdcs);
953
954 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
955 NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_REFUSED)) {
956 return status;
957 }
958
959 if (sitename &&
960 ((!NT_STATUS_IS_OK(status)) ||
961 (NT_STATUS_IS_OK(status) && (numdcs == 0)))) {
962 /* Sitename DNS query may have failed. Try without. */
963 status = ads_dns_query_internal(ctx, "_kerberos", "dc",
964 dns_forest_name, NULL,
965 dclist, numdcs);
966 }
967 return status;
968}
969
970/********************************************************************
971 Query for AD PDC. Sitename is obsolete here.
972********************************************************************/
973
974NTSTATUS ads_dns_query_pdc(TALLOC_CTX *ctx,
975 const char *dns_domain_name,
976 struct dns_rr_srv **dclist,
977 int *numdcs )
978{
979 return ads_dns_query_internal(ctx, "_ldap", "pdc", dns_domain_name,
980 NULL, dclist, numdcs);
981}
982
983/********************************************************************
984 Query for AD DC by guid. Sitename is obsolete here.
985********************************************************************/
986
987NTSTATUS ads_dns_query_dcs_guid(TALLOC_CTX *ctx,
988 const char *dns_forest_name,
989 const struct GUID *domain_guid,
990 struct dns_rr_srv **dclist,
991 int *numdcs )
992{
993 /*_ldap._tcp.DomainGuid.domains._msdcs.DnsForestName */
994
995 const char *domains;
996 const char *guid_string;
997
998 guid_string = GUID_string(ctx, domain_guid);
999 if (!guid_string) {
1000 return NT_STATUS_NO_MEMORY;
1001 }
1002
1003 /* little hack */
1004 domains = talloc_asprintf(ctx, "%s.domains", guid_string);
1005 if (!domains) {
1006 return NT_STATUS_NO_MEMORY;
1007 }
1008
1009 return ads_dns_query_internal(ctx, "_ldap", domains, dns_forest_name,
1010 NULL, dclist, numdcs);
1011}
Note: See TracBrowser for help on using the repository browser.