f16cea25554ed0e540e2af1786c5e1c560d74b8c
[samba.git] / source3 / libads / dns.c
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
69 static 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
107 static 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
161 static 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
206 static 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
248 static 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
273 static 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
318 static 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
470 NTSTATUS 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
594 static 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
613 BOOL 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
652 char *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
688 BOOL 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
715 NTSTATUS 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
740 NTSTATUS 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
770 NTSTATUS 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 }