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

Last change on this file since 39 was 39, checked in by Paul Smedley, 18 years ago

Upgrade source to 3.0.25a
File size: 20.6 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 DNS utility library
4 Copyright (C) Gerald (Jerry) Carter 2006.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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# define T_SRV ns_t_srv
49#if !defined(T_NS) /* AIX 5.3 already defines T_NS */
50# define T_NS ns_t_ns
51#endif
52#else
53# ifdef HFIXEDSZ
54# define NS_HFIXEDSZ HFIXEDSZ
55# else
56# define NS_HFIXEDSZ sizeof(HEADER)
57# endif /* HFIXEDSZ */
58# ifdef PACKETSZ
59# define NS_PACKETSZ PACKETSZ
60# else /* 512 is usually the default */
61# define NS_PACKETSZ 512
62# endif /* PACKETSZ */
63# define T_SRV 33
64#endif
65
66/*********************************************************************
67*********************************************************************/
68
69static BOOL ads_dns_parse_query( TALLOC_CTX *ctx, uint8 *start, uint8 *end,
70 uint8 **ptr, struct dns_query *q )
71{
72 uint8 *p = *ptr;
73 pstring hostname;
74 int namelen;
75
76 ZERO_STRUCTP( q );
77
78 if ( !start || !end || !q || !*ptr)
79 return False;
80
81 /* See RFC 1035 for details. If this fails, then return. */
82
83 namelen = dn_expand( start, end, p, hostname, sizeof(hostname) );
84 if ( namelen < 0 ) {
85 return False;
86 }
87 p += namelen;
88 q->hostname = talloc_strdup( ctx, hostname );
89
90 /* check that we have space remaining */
91
92 if ( PTR_DIFF(p+4, end) > 0 )
93 return False;
94
95 q->type = RSVAL( p, 0 );
96 q->in_class = RSVAL( p, 2 );
97 p += 4;
98
99 *ptr = p;
100
101 return True;
102}
103
104/*********************************************************************
105*********************************************************************/
106
107static BOOL ads_dns_parse_rr( TALLOC_CTX *ctx, uint8 *start, uint8 *end,
108 uint8 **ptr, struct dns_rr *rr )
109{
110 uint8 *p = *ptr;
111 pstring hostname;
112 int namelen;
113
114 if ( !start || !end || !rr || !*ptr)
115 return -1;
116
117 ZERO_STRUCTP( rr );
118 /* pull the name from the answer */
119
120 namelen = dn_expand( start, end, p, hostname, sizeof(hostname) );
121 if ( namelen < 0 ) {
122 return -1;
123 }
124 p += namelen;
125 rr->hostname = talloc_strdup( ctx, hostname );
126
127 /* check that we have space remaining */
128
129 if ( PTR_DIFF(p+10, end) > 0 )
130 return False;
131
132 /* pull some values and then skip onto the string */
133
134 rr->type = RSVAL(p, 0);
135 rr->in_class = RSVAL(p, 2);
136 rr->ttl = RIVAL(p, 4);
137 rr->rdatalen = RSVAL(p, 8);
138
139 p += 10;
140
141 /* sanity check the available space */
142
143 if ( PTR_DIFF(p+rr->rdatalen, end ) > 0 ) {
144 return False;
145
146 }
147
148 /* save a point to the rdata for this section */
149
150 rr->rdata = p;
151 p += rr->rdatalen;
152
153 *ptr = p;
154
155 return True;
156}
157
158/*********************************************************************
159*********************************************************************/
160
161static BOOL ads_dns_parse_rr_srv( TALLOC_CTX *ctx, uint8 *start, uint8 *end,
162 uint8 **ptr, struct dns_rr_srv *srv )
163{
164 struct dns_rr rr;
165 uint8 *p;
166 pstring dcname;
167 int namelen;
168
169 if ( !start || !end || !srv || !*ptr)
170 return -1;
171
172 /* Parse the RR entry. Coming out of the this, ptr is at the beginning
173 of the next record */
174
175 if ( !ads_dns_parse_rr( ctx, start, end, ptr, &rr ) ) {
176 DEBUG(1,("ads_dns_parse_rr_srv: Failed to parse RR record\n"));
177 return False;
178 }
179
180 if ( rr.type != T_SRV ) {
181 DEBUG(1,("ads_dns_parse_rr_srv: Bad answer type (%d)\n", rr.type));
182 return False;
183 }
184
185 p = rr.rdata;
186
187 srv->priority = RSVAL(p, 0);
188 srv->weight = RSVAL(p, 2);
189 srv->port = RSVAL(p, 4);
190
191 p += 6;
192
193 namelen = dn_expand( start, end, p, dcname, sizeof(dcname) );
194 if ( namelen < 0 ) {
195 DEBUG(1,("ads_dns_parse_rr_srv: Failed to uncompress name!\n"));
196 return False;
197 }
198 srv->hostname = talloc_strdup( ctx, dcname );
199
200 return True;
201}
202
203/*********************************************************************
204*********************************************************************/
205
206static BOOL ads_dns_parse_rr_ns( TALLOC_CTX *ctx, uint8 *start, uint8 *end,
207 uint8 **ptr, struct dns_rr_ns *nsrec )
208{
209 struct dns_rr rr;
210 uint8 *p;
211 pstring nsname;
212 int namelen;
213
214 if ( !start || !end || !nsrec || !*ptr)
215 return -1;
216
217 /* Parse the RR entry. Coming out of the this, ptr is at the beginning
218 of the next record */
219
220 if ( !ads_dns_parse_rr( ctx, start, end, ptr, &rr ) ) {
221 DEBUG(1,("ads_dns_parse_rr_ns: Failed to parse RR record\n"));
222 return False;
223 }
224
225 if ( rr.type != T_NS ) {
226 DEBUG(1,("ads_dns_parse_rr_ns: Bad answer type (%d)\n", rr.type));
227 return False;
228 }
229
230 p = rr.rdata;
231
232 /* ame server hostname */
233
234 namelen = dn_expand( start, end, p, nsname, sizeof(nsname) );
235 if ( namelen < 0 ) {
236 DEBUG(1,("ads_dns_parse_rr_ns: Failed to uncompress name!\n"));
237 return False;
238 }
239 nsrec->hostname = talloc_strdup( ctx, nsname );
240
241 return True;
242}
243
244/*********************************************************************
245 Sort SRV record list based on weight and priority. See RFC 2782.
246*********************************************************************/
247
248static int dnssrvcmp( struct dns_rr_srv *a, struct dns_rr_srv *b )
249{
250 if ( a->priority == b->priority ) {
251
252 /* randomize entries with an equal weight and priority */
253 if ( a->weight == b->weight )
254 return 0;
255
256 /* higher weights should be sorted lower */
257 if ( a->weight > b->weight )
258 return -1;
259 else
260 return 1;
261 }
262
263 if ( a->priority < b->priority )
264 return -1;
265
266 return 1;
267}
268
269/*********************************************************************
270 Simple wrapper for a DNS query
271*********************************************************************/
272
273static NTSTATUS dns_send_req( TALLOC_CTX *ctx, const char *name, int q_type,
274 uint8 **buf, int *resp_length )
275{
276 uint8 *buffer = NULL;
277 size_t buf_len;
278 int resp_len = NS_PACKETSZ;
279
280 do {
281 if ( buffer )
282 TALLOC_FREE( buffer );
283
284 buf_len = resp_len * sizeof(uint8);
285
286 if (buf_len) {
287 if ( (buffer = TALLOC_ARRAY(ctx, uint8, buf_len)) == NULL ) {
288 DEBUG(0,("ads_dns_lookup_srv: talloc() failed!\n"));
289 return NT_STATUS_NO_MEMORY;
290 }
291 } else {
292 buffer = NULL;
293 }
294
295 if ( (resp_len = res_query(name, C_IN, q_type, buffer, buf_len)) < 0 ) {
296 DEBUG(3,("ads_dns_lookup_srv: Failed to resolve %s (%s)\n", name, strerror(errno)));
297 TALLOC_FREE( buffer );
298 if (errno == ETIMEDOUT) {
299 return NT_STATUS_IO_TIMEOUT;
300 }
301 if (errno == ECONNREFUSED) {
302 return NT_STATUS_CONNECTION_REFUSED;
303 }
304 return NT_STATUS_UNSUCCESSFUL;
305 }
306 } while ( buf_len < resp_len && resp_len < MAX_DNS_PACKET_SIZE );
307
308 *buf = buffer;
309 *resp_length = resp_len;
310
311 return NT_STATUS_OK;
312}
313
314/*********************************************************************
315 Simple wrapper for a DNS SRV query
316*********************************************************************/
317
318static NTSTATUS ads_dns_lookup_srv( TALLOC_CTX *ctx, const char *name, struct dns_rr_srv **dclist, int *numdcs )
319{
320 uint8 *buffer = NULL;
321 int resp_len = 0;
322 struct dns_rr_srv *dcs = NULL;
323 int query_count, answer_count, auth_count, additional_count;
324 uint8 *p = buffer;
325 int rrnum;
326 int idx = 0;
327 NTSTATUS status;
328
329 if ( !ctx || !name || !dclist ) {
330 return NT_STATUS_INVALID_PARAMETER;
331 }
332
333 /* Send the request. May have to loop several times in case
334 of large replies */
335
336 status = dns_send_req( ctx, name, T_SRV, &buffer, &resp_len );
337 if ( !NT_STATUS_IS_OK(status) ) {
338 DEBUG(3,("ads_dns_lookup_srv: Failed to send DNS query (%s)\n",
339 nt_errstr(status)));
340 return status;
341 }
342 p = buffer;
343
344 /* For some insane reason, the ns_initparse() et. al. routines are only
345 available in libresolv.a, and not the shared lib. Who knows why....
346 So we have to parse the DNS reply ourselves */
347
348 /* Pull the answer RR's count from the header. Use the NMB ordering macros */
349
350 query_count = RSVAL( p, 4 );
351 answer_count = RSVAL( p, 6 );
352 auth_count = RSVAL( p, 8 );
353 additional_count = RSVAL( p, 10 );
354
355 DEBUG(4,("ads_dns_lookup_srv: %d records returned in the answer section.\n",
356 answer_count));
357
358 if (answer_count) {
359 if ( (dcs = TALLOC_ZERO_ARRAY(ctx, struct dns_rr_srv, answer_count)) == NULL ) {
360 DEBUG(0,("ads_dns_lookup_srv: talloc() failure for %d char*'s\n",
361 answer_count));
362 return NT_STATUS_NO_MEMORY;
363 }
364 } else {
365 dcs = NULL;
366 }
367
368 /* now skip the header */
369
370 p += NS_HFIXEDSZ;
371
372 /* parse the query section */
373
374 for ( rrnum=0; rrnum<query_count; rrnum++ ) {
375 struct dns_query q;
376
377 if ( !ads_dns_parse_query( ctx, buffer, buffer+resp_len, &p, &q ) ) {
378 DEBUG(1,("ads_dns_lookup_srv: Failed to parse query record!\n"));
379 return NT_STATUS_UNSUCCESSFUL;
380 }
381 }
382
383 /* now we are at the answer section */
384
385 for ( rrnum=0; rrnum<answer_count; rrnum++ ) {
386 if ( !ads_dns_parse_rr_srv( ctx, buffer, buffer+resp_len, &p, &dcs[rrnum] ) ) {
387 DEBUG(1,("ads_dns_lookup_srv: Failed to parse answer record!\n"));
388 return NT_STATUS_UNSUCCESSFUL;
389 }
390 }
391 idx = rrnum;
392
393 /* Parse the authority section */
394 /* just skip these for now */
395
396 for ( rrnum=0; rrnum<auth_count; rrnum++ ) {
397 struct dns_rr rr;
398
399 if ( !ads_dns_parse_rr( ctx, buffer, buffer+resp_len, &p, &rr ) ) {
400 DEBUG(1,("ads_dns_lookup_srv: Failed to parse authority record!\n"));
401 return NT_STATUS_UNSUCCESSFUL;
402 }
403 }
404
405 /* Parse the additional records section */
406
407 for ( rrnum=0; rrnum<additional_count; rrnum++ ) {
408 struct dns_rr rr;
409 int i;
410
411 if ( !ads_dns_parse_rr( ctx, buffer, buffer+resp_len, &p, &rr ) ) {
412 DEBUG(1,("ads_dns_lookup_srv: Failed to parse additional records section!\n"));
413 return NT_STATUS_UNSUCCESSFUL;
414 }
415
416 /* only interested in A records as a shortcut for having to come
417 back later and lookup the name. For multi-homed hosts, the
418 number of additional records and exceed the number of answer
419 records. */
420
421
422 if ( (rr.type != T_A) || (rr.rdatalen != 4) )
423 continue;
424
425 for ( i=0; i<idx; i++ ) {
426 if ( strcmp( rr.hostname, dcs[i].hostname ) == 0 ) {
427 int num_ips = dcs[i].num_ips;
428 uint8 *buf;
429 struct in_addr *tmp_ips;
430
431 /* allocate new memory */
432
433 if ( dcs[i].num_ips == 0 ) {
434 if ( (dcs[i].ips = TALLOC_ARRAY( dcs,
435 struct in_addr, 1 )) == NULL )
436 {
437 return NT_STATUS_NO_MEMORY;
438 }
439 } else {
440 if ( (tmp_ips = TALLOC_REALLOC_ARRAY( dcs, dcs[i].ips,
441 struct in_addr, dcs[i].num_ips+1)) == NULL )
442 {
443 return NT_STATUS_NO_MEMORY;
444 }
445
446 dcs[i].ips = tmp_ips;
447 }
448 dcs[i].num_ips++;
449
450 /* copy the new IP address */
451
452 buf = (uint8*)&dcs[i].ips[num_ips].s_addr;
453 memcpy( buf, rr.rdata, 4 );
454 }
455 }
456 }
457
458 qsort( dcs, idx, sizeof(struct dns_rr_srv), QSORT_CAST dnssrvcmp );
459
460 *dclist = dcs;
461 *numdcs = idx;
462
463 return NT_STATUS_OK;
464}
465
466/*********************************************************************
467 Simple wrapper for a DNS NS query
468*********************************************************************/
469
470NTSTATUS ads_dns_lookup_ns( TALLOC_CTX *ctx, const char *dnsdomain, struct dns_rr_ns **nslist, int *numns )
471{
472 uint8 *buffer = NULL;
473 int resp_len = 0;
474 struct dns_rr_ns *nsarray = NULL;
475 int query_count, answer_count, auth_count, additional_count;
476 uint8 *p;
477 int rrnum;
478 int idx = 0;
479 NTSTATUS status;
480
481 if ( !ctx || !dnsdomain || !nslist ) {
482 return NT_STATUS_INVALID_PARAMETER;
483 }
484
485 /* Send the request. May have to loop several times in case
486 of large replies */
487
488 status = dns_send_req( ctx, dnsdomain, T_NS, &buffer, &resp_len );
489 if ( !NT_STATUS_IS_OK(status) ) {
490 DEBUG(3,("ads_dns_lookup_ns: Failed to send DNS query (%s)\n",
491 nt_errstr(status)));
492 return status;
493 }
494 p = buffer;
495
496 /* For some insane reason, the ns_initparse() et. al. routines are only
497 available in libresolv.a, and not the shared lib. Who knows why....
498 So we have to parse the DNS reply ourselves */
499
500 /* Pull the answer RR's count from the header. Use the NMB ordering macros */
501
502 query_count = RSVAL( p, 4 );
503 answer_count = RSVAL( p, 6 );
504 auth_count = RSVAL( p, 8 );
505 additional_count = RSVAL( p, 10 );
506
507 DEBUG(4,("ads_dns_lookup_ns: %d records returned in the answer section.\n",
508 answer_count));
509
510 if (answer_count) {
511 if ( (nsarray = TALLOC_ARRAY(ctx, struct dns_rr_ns, answer_count)) == NULL ) {
512 DEBUG(0,("ads_dns_lookup_ns: talloc() failure for %d char*'s\n",
513 answer_count));
514 return NT_STATUS_NO_MEMORY;
515 }
516 } else {
517 nsarray = NULL;
518 }
519
520 /* now skip the header */
521
522 p += NS_HFIXEDSZ;
523
524 /* parse the query section */
525
526 for ( rrnum=0; rrnum<query_count; rrnum++ ) {
527 struct dns_query q;
528
529 if ( !ads_dns_parse_query( ctx, buffer, buffer+resp_len, &p, &q ) ) {
530 DEBUG(1,("ads_dns_lookup_ns: Failed to parse query record!\n"));
531 return NT_STATUS_UNSUCCESSFUL;
532 }
533 }
534
535 /* now we are at the answer section */
536
537 for ( rrnum=0; rrnum<answer_count; rrnum++ ) {
538 if ( !ads_dns_parse_rr_ns( ctx, buffer, buffer+resp_len, &p, &nsarray[rrnum] ) ) {
539 DEBUG(1,("ads_dns_lookup_ns: Failed to parse answer record!\n"));
540 return NT_STATUS_UNSUCCESSFUL;
541 }
542 }
543 idx = rrnum;
544
545 /* Parse the authority section */
546 /* just skip these for now */
547
548 for ( rrnum=0; rrnum<auth_count; rrnum++ ) {
549 struct dns_rr rr;
550
551 if ( !ads_dns_parse_rr( ctx, buffer, buffer+resp_len, &p, &rr ) ) {
552 DEBUG(1,("ads_dns_lookup_ns: Failed to parse authority record!\n"));
553 return NT_STATUS_UNSUCCESSFUL;
554 }
555 }
556
557 /* Parse the additional records section */
558
559 for ( rrnum=0; rrnum<additional_count; rrnum++ ) {
560 struct dns_rr rr;
561 int i;
562
563 if ( !ads_dns_parse_rr( ctx, buffer, buffer+resp_len, &p, &rr ) ) {
564 DEBUG(1,("ads_dns_lookup_ns: Failed to parse additional records section!\n"));
565 return NT_STATUS_UNSUCCESSFUL;
566 }
567
568 /* only interested in A records as a shortcut for having to come
569 back later and lookup the name */
570
571 if ( (rr.type != T_A) || (rr.rdatalen != 4) )
572 continue;
573
574 for ( i=0; i<idx; i++ ) {
575 if ( strcmp( rr.hostname, nsarray[i].hostname ) == 0 ) {
576 uint8 *buf = (uint8*)&nsarray[i].ip.s_addr;
577 memcpy( buf, rr.rdata, 4 );
578 }
579 }
580 }
581
582 *nslist = nsarray;
583 *numns = idx;
584
585 return NT_STATUS_OK;
586}
587
588/****************************************************************************
589 Store and fetch the AD client sitename.
590****************************************************************************/
591
592#define SITENAME_KEY "AD_SITENAME/DOMAIN/%s"
593
594static char *sitename_key(const char *realm)
595{
596 char *keystr;
597
598 if (asprintf(&keystr, SITENAME_KEY, strupper_static(realm)) == -1) {
599 return NULL;
600 }
601
602 return keystr;
603}
604
605
606/****************************************************************************
607 Store the AD client sitename.
608 We store indefinately as every new CLDAP query will re-write this.
609 If the sitename is "Default-First-Site-Name" we don't store it
610 as this isn't a valid DNS name.
611****************************************************************************/
612
613BOOL sitename_store(const char *realm, const char *sitename)
614{
615 time_t expire;
616 BOOL ret = False;
617 char *key;
618
619 if (!gencache_init()) {
620 return False;
621 }
622
623 if (!realm || (strlen(realm) == 0)) {
624 DEBUG(0,("no realm\n"));
625 return False;
626 }
627
628 key = sitename_key(realm);
629
630 if (!sitename || (sitename && !*sitename)) {
631 DEBUG(5,("sitename_store: deleting empty sitename!\n"));
632 ret = gencache_del(key);
633 SAFE_FREE(key);
634 return ret;
635 }
636
637 expire = get_time_t_max(); /* Store indefinately. */
638
639 DEBUG(10,("sitename_store: realm = [%s], sitename = [%s], expire = [%u]\n",
640 realm, sitename, (unsigned int)expire ));
641
642 ret = gencache_set( key, sitename, expire );
643 SAFE_FREE(key);
644 return ret;
645}
646
647/****************************************************************************
648 Fetch the AD client sitename.
649 Caller must free.
650****************************************************************************/
651
652char *sitename_fetch(const char *realm)
653{
654 char *sitename = NULL;
655 time_t timeout;
656 BOOL ret = False;
657 const char *query_realm;
658 char *key;
659
660 if (!gencache_init()) {
661 return False;
662 }
663
664 if (!realm || (strlen(realm) == 0)) {
665 query_realm = lp_realm();
666 } else {
667 query_realm = realm;
668 }
669
670 key = sitename_key(query_realm);
671
672 ret = gencache_get( key, &sitename, &timeout );
673 SAFE_FREE(key);
674 if ( !ret ) {
675 DEBUG(5,("sitename_fetch: No stored sitename for %s\n",
676 query_realm));
677 } else {
678 DEBUG(5,("sitename_fetch: Returning sitename for %s: \"%s\"\n",
679 query_realm, sitename ));
680 }
681 return sitename;
682}
683
684/****************************************************************************
685 Did the sitename change ?
686****************************************************************************/
687
688BOOL stored_sitename_changed(const char *realm, const char *sitename)
689{
690 BOOL ret = False;
691
692 char *new_sitename;
693
694 if (!realm || (strlen(realm) == 0)) {
695 DEBUG(0,("no realm\n"));
696 return False;
697 }
698
699 new_sitename = sitename_fetch(realm);
700
701 if (sitename && new_sitename && !strequal(sitename, new_sitename)) {
702 ret = True;
703 } else if ((sitename && !new_sitename) ||
704 (!sitename && new_sitename)) {
705 ret = True;
706 }
707 SAFE_FREE(new_sitename);
708 return ret;
709}
710
711/********************************************************************
712 Query with optional sitename.
713********************************************************************/
714
715NTSTATUS ads_dns_query_internal(TALLOC_CTX *ctx,
716 const char *servicename,
717 const char *realm,
718 const char *sitename,
719 struct dns_rr_srv **dclist,
720 int *numdcs )
721{
722 char *name;
723 if (sitename) {
724 name = talloc_asprintf(ctx, "%s._tcp.%s._sites.dc._msdcs.%s",
725 servicename, sitename, realm );
726 } else {
727 name = talloc_asprintf(ctx, "%s._tcp.dc._msdcs.%s",
728 servicename, realm );
729 }
730 if (!name) {
731 return NT_STATUS_NO_MEMORY;
732 }
733 return ads_dns_lookup_srv( ctx, name, dclist, numdcs );
734}
735
736/********************************************************************
737 Query for AD DC's.
738********************************************************************/
739
740NTSTATUS ads_dns_query_dcs(TALLOC_CTX *ctx,
741 const char *realm,
742 const char *sitename,
743 struct dns_rr_srv **dclist,
744 int *numdcs )
745{
746 NTSTATUS status;
747
748 status = ads_dns_query_internal(ctx, "_ldap", realm, sitename,
749 dclist, numdcs);
750
751 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
752 NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_REFUSED)) {
753 return status;
754 }
755
756 if (sitename && !NT_STATUS_IS_OK(status)) {
757 /* Sitename DNS query may have failed. Try without. */
758 status = ads_dns_query_internal(ctx, "_ldap", realm, NULL,
759 dclist, numdcs);
760 }
761 return status;
762}
763
764/********************************************************************
765 Query for AD KDC's.
766 Even if our underlying kerberos libraries are UDP only, this
767 is pretty safe as it's unlikely that a KDC supports TCP and not UDP.
768********************************************************************/
769
770NTSTATUS ads_dns_query_kdcs(TALLOC_CTX *ctx,
771 const char *realm,
772 const char *sitename,
773 struct dns_rr_srv **dclist,
774 int *numdcs )
775{
776 NTSTATUS status;
777
778 status = ads_dns_query_internal(ctx, "_kerberos", realm, sitename,
779 dclist, numdcs);
780
781 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
782 NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_REFUSED)) {
783 return status;
784 }
785
786 if (sitename && !NT_STATUS_IS_OK(status)) {
787 /* Sitename DNS query may have failed. Try without. */
788 status = ads_dns_query_internal(ctx, "_kerberos", realm, NULL,
789 dclist, numdcs);
790 }
791 return status;
792}
Note: See TracBrowser for help on using the repository browser.