1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions for interfacing with the DNS. */
14 /*************************************************
16 *************************************************/
18 /* This function is called instead of res_search() when Exim is running in its
19 test harness. It recognizes some special domain names, and uses them to force
20 failure and retry responses (optionally with a delay). Otherwise, it calls an
21 external utility that mocks-up a nameserver, if it can find the utility.
22 If not, it passes its arguments on to res_search(). The fake nameserver may
23 also return a code specifying that the name should be passed on.
25 Background: the original test suite required a real nameserver to carry the
26 test zones, whereas the new test suite has the fake server for portability. This
30 domain the domain name
31 type the DNS record type
32 answerptr where to put the answer
33 size size of the answer area
35 Returns: length of returned data, or -1 on error (h_errno set)
39 fakens_search(const uschar
*domain
, int type
, uschar
*answerptr
, int size
)
41 int len
= Ustrlen(domain
);
42 int asize
= size
; /* Locally modified */
46 uschar
*aptr
= answerptr
; /* Locally modified */
49 /* Remove terminating dot. */
51 if (domain
[len
- 1] == '.') len
--;
52 Ustrncpy(name
, domain
, len
);
56 /* Look for the fakens utility, and if it exists, call it. */
58 (void)string_format(utilname
, sizeof(utilname
), "%s/bin/fakens",
59 config_main_directory
);
61 if (stat(CS utilname
, &statbuf
) >= 0)
67 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) using fakens\n", name
, dns_text_type(type
));
70 argv
[1] = config_main_directory
;
72 argv
[3] = dns_text_type(type
);
75 pid
= child_open(argv
, NULL
, 0000, &infd
, &outfd
, FALSE
);
77 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "failed to run fakens: %s",
82 while (asize
> 0 && (rc
= read(outfd
, aptr
, asize
)) > 0)
85 aptr
+= rc
; /* Don't modify the actual arguments, because they */
86 asize
-= rc
; /* may need to be passed on to res_search(). */
89 /* If we ran out of output buffer before exhasting the return,
90 carry on reading and counting it. */
93 while ((rc
= read(outfd
, name
, sizeof(name
))) > 0)
97 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "read from fakens failed: %s",
100 switch(child_close(pid
, 0))
103 case 1: h_errno
= HOST_NOT_FOUND
; return -1;
104 case 2: h_errno
= TRY_AGAIN
; return -1;
106 case 3: h_errno
= NO_RECOVERY
; return -1;
107 case 4: h_errno
= NO_DATA
; return -1;
108 case 5: /* Pass on to res_search() */
109 DEBUG(D_dns
) debug_printf("fakens returned PASS_ON\n");
114 DEBUG(D_dns
) debug_printf("fakens (%s) not found\n", utilname
);
117 /* fakens utility not found, or it returned "pass on" */
119 DEBUG(D_dns
) debug_printf("passing %s on to res_search()\n", domain
);
121 return res_search(CS domain
, C_IN
, type
, answerptr
, size
);
126 /*************************************************
127 * Initialize and configure resolver *
128 *************************************************/
130 /* Initialize the resolver and the storage for holding DNS answers if this is
131 the first time we have been here, and set the resolver options.
134 qualify_single TRUE to set the RES_DEFNAMES option
135 search_parents TRUE to set the RES_DNSRCH option
136 use_dnssec TRUE to set the RES_USE_DNSSEC option
142 dns_init(BOOL qualify_single
, BOOL search_parents
, BOOL use_dnssec
)
144 res_state resp
= os_get_dns_resolver_res();
146 if ((resp
->options
& RES_INIT
) == 0)
148 DEBUG(D_resolver
) resp
->options
|= RES_DEBUG
; /* For Cygwin */
149 os_put_dns_resolver_res(resp
);
151 DEBUG(D_resolver
) resp
->options
|= RES_DEBUG
;
152 os_put_dns_resolver_res(resp
);
155 resp
->options
&= ~(RES_DNSRCH
| RES_DEFNAMES
);
156 resp
->options
|= (qualify_single
? RES_DEFNAMES
: 0) |
157 (search_parents
? RES_DNSRCH
: 0);
158 if (dns_retrans
> 0) resp
->retrans
= dns_retrans
;
159 if (dns_retry
> 0) resp
->retry
= dns_retry
;
162 if (dns_use_edns0
>= 0)
165 resp
->options
|= RES_USE_EDNS0
;
167 resp
->options
&= ~RES_USE_EDNS0
;
169 debug_printf("Coerced resolver EDNS0 support %s.\n",
170 dns_use_edns0
? "on" : "off");
173 if (dns_use_edns0
>= 0)
175 debug_printf("Unable to %sset EDNS0 without resolver support.\n",
176 dns_use_edns0
? "" : "un");
179 #ifndef DISABLE_DNSSEC
180 # ifdef RES_USE_DNSSEC
181 # ifndef RES_USE_EDNS0
182 # error Have RES_USE_DNSSEC but not RES_USE_EDNS0? Something hinky ...
185 resp
->options
|= RES_USE_DNSSEC
;
186 if (dns_dnssec_ok
>= 0)
188 if (dns_use_edns0
== 0 && dns_dnssec_ok
!= 0)
191 debug_printf("CONFLICT: dns_use_edns0 forced false, dns_dnssec_ok forced true, ignoring latter!\n");
196 resp
->options
|= RES_USE_DNSSEC
;
198 resp
->options
&= ~RES_USE_DNSSEC
;
199 DEBUG(D_resolver
) debug_printf("Coerced resolver DNSSEC support %s.\n",
200 dns_dnssec_ok
? "on" : "off");
204 if (dns_dnssec_ok
>= 0)
206 debug_printf("Unable to %sset DNSSEC without resolver support.\n",
207 dns_dnssec_ok
? "" : "un");
210 debug_printf("Unable to set DNSSEC without resolver support.\n");
212 #endif /* DISABLE_DNSSEC */
214 os_put_dns_resolver_res(resp
);
219 /*************************************************
220 * Build key name for PTR records *
221 *************************************************/
223 /* This function inverts an IP address and adds the relevant domain, to produce
224 a name that can be used to look up PTR records.
227 string the IP address as a string
228 buffer a suitable buffer, long enough to hold the result
234 dns_build_reverse(const uschar
*string
, uschar
*buffer
)
236 const uschar
*p
= string
+ Ustrlen(string
);
239 /* Handle IPv4 address */
242 if (Ustrchr(string
, ':') == NULL
)
246 for (i
= 0; i
< 4; i
++)
248 const uschar
*ppp
= p
;
249 while (ppp
> string
&& ppp
[-1] != '.') ppp
--;
250 Ustrncpy(pp
, ppp
, p
- ppp
);
255 Ustrcpy(pp
, "in-addr.arpa");
258 /* Handle IPv6 address; convert to binary so as to fill out any
259 abbreviation in the textual form. */
266 (void)host_aton(string
, v6
);
268 /* The original specification for IPv6 reverse lookup was to invert each
269 nibble, and look in the ip6.int domain. The domain was subsequently
270 changed to ip6.arpa. */
272 for (i
= 3; i
>= 0; i
--)
275 for (j
= 0; j
< 32; j
+= 4)
277 sprintf(CS pp
, "%x.", (v6
[i
] >> j
) & 15);
281 Ustrcpy(pp
, "ip6.arpa.");
283 /* Another way of doing IPv6 reverse lookups was proposed in conjunction
284 with A6 records. However, it fell out of favour when they did. The
285 alternative was to construct a binary key, and look in ip6.arpa. I tried
286 to make this code do that, but I could not make it work on Solaris 8. The
287 resolver seems to lose the initial backslash somehow. However, now that
288 this style of reverse lookup has been dropped, it doesn't matter. These
289 lines are left here purely for historical interest. */
291 /**************************************************
295 for (i = 0; i < 4; i++)
297 sprintf(pp, "%08X", v6[i]);
300 Ustrcpy(pp, "].ip6.arpa.");
301 **************************************************/
310 /*************************************************
311 * Get next DNS record from answer block *
312 *************************************************/
314 /* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
315 RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
316 scan the additional records, and reset == RESET_NEXT to get the next record.
317 The result is in static storage which must be copied if it is to be preserved.
320 dnsa pointer to dns answer block
321 dnss pointer to dns scan block
322 reset option specifing what portion to scan, as described above
324 Returns: next dns record, or NULL when no more
328 dns_next_rr(dns_answer
*dnsa
, dns_scan
*dnss
, int reset
)
330 HEADER
*h
= (HEADER
*)dnsa
->answer
;
333 /* Reset the saved data when requested to, and skip to the first required RR */
335 if (reset
!= RESET_NEXT
)
337 dnss
->rrcount
= ntohs(h
->qdcount
);
338 dnss
->aptr
= dnsa
->answer
+ sizeof(HEADER
);
340 /* Skip over questions; failure to expand the name just gives up */
342 while (dnss
->rrcount
-- > 0)
344 namelen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
345 dnss
->aptr
, (DN_EXPAND_ARG4_TYPE
) &(dnss
->srr
.name
), DNS_MAXNAME
);
346 if (namelen
< 0) { dnss
->rrcount
= 0; return NULL
; }
347 dnss
->aptr
+= namelen
+ 4; /* skip name & type & class */
350 /* Get the number of answer records. */
352 dnss
->rrcount
= ntohs(h
->ancount
);
354 /* Skip over answers if we want to look at the authority section. Also skip
355 the NS records (i.e. authority section) if wanting to look at the additional
358 if (reset
== RESET_ADDITIONAL
) dnss
->rrcount
+= ntohs(h
->nscount
);
360 if (reset
== RESET_AUTHORITY
|| reset
== RESET_ADDITIONAL
)
362 while (dnss
->rrcount
-- > 0)
364 namelen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
365 dnss
->aptr
, (DN_EXPAND_ARG4_TYPE
) &(dnss
->srr
.name
), DNS_MAXNAME
);
366 if (namelen
< 0) { dnss
->rrcount
= 0; return NULL
; }
367 dnss
->aptr
+= namelen
+ 8; /* skip name, type, class & TTL */
368 GETSHORT(dnss
->srr
.size
, dnss
->aptr
); /* size of data portion */
369 dnss
->aptr
+= dnss
->srr
.size
; /* skip over it */
371 dnss
->rrcount
= (reset
== RESET_AUTHORITY
)
372 ? ntohs(h
->nscount
) : ntohs(h
->arcount
);
376 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
377 contains the number of RR records left. */
379 if (dnss
->rrcount
-- <= 0) return NULL
;
381 /* If expanding the RR domain name fails, behave as if no more records
384 namelen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
, dnss
->aptr
,
385 (DN_EXPAND_ARG4_TYPE
) &(dnss
->srr
.name
), DNS_MAXNAME
);
386 if (namelen
< 0) { dnss
->rrcount
= 0; return NULL
; }
388 /* Move the pointer past the name and fill in the rest of the data structure
389 from the following bytes. */
391 dnss
->aptr
+= namelen
;
392 GETSHORT(dnss
->srr
.type
, dnss
->aptr
); /* Record type */
393 dnss
->aptr
+= 6; /* Don't want class or TTL */
394 GETSHORT(dnss
->srr
.size
, dnss
->aptr
); /* Size of data portion */
395 dnss
->srr
.data
= dnss
->aptr
; /* The record's data follows */
396 dnss
->aptr
+= dnss
->srr
.size
; /* Advance to next RR */
398 /* Return a pointer to the dns_record structure within the dns_answer. This is
399 for convenience so that the scans can use nice-looking for loops. */
405 /* Extract the AUTHORITY info from the answer. If the
406 answer isn't authoritive (AA) we do not extract anything.
407 We've to search for SOA or NS records, since there may be
408 other records (e.g. NSEC3) too.
411 static const uschar
*
412 dns_extract_auth_name(const dns_answer
* dnsa
) /* FIXME: const dns_answer */
416 HEADER
* h
= (HEADER
*) dnsa
->answer
;
418 if (!h
->nscount
|| !h
->aa
) return NULL
;
419 for (rr
= dns_next_rr((dns_answer
*) dnsa
, &dnss
, RESET_AUTHORITY
);
421 rr
= dns_next_rr((dns_answer
*) dnsa
, &dnss
, RESET_NEXT
))
422 if (rr
->type
== T_SOA
|| rr
->type
== T_NS
) return rr
->name
;
429 /*************************************************
430 * Return whether AD bit set in DNS result *
431 *************************************************/
433 /* We do not perform DNSSEC work ourselves; if the administrator has installed
434 a verifying resolver which sets AD as appropriate, though, we'll use that.
435 (AD = Authentic Data, AA = Authoritive Answer)
437 Argument: pointer to dns answer block
438 Returns: bool indicating presence of AD bit
442 dns_is_secure(const dns_answer
* dnsa
)
444 #ifdef DISABLE_DNSSEC
446 debug_printf("DNSSEC support disabled at build-time; dns_is_secure() false\n");
449 HEADER
* h
= (HEADER
*) dnsa
->answer
;
450 const uschar
* auth_name
;
451 const uschar
* trusted
;
453 if (h
->ad
) return TRUE
;
455 /* If the resolver we ask is authoritive for the domain in question, it
456 * may not set the AD but the AA bit. If we explicitly trust
457 * the resolver for that domain (via a domainlist in dns_trust_aa),
458 * we return TRUE to indicate a secure answer.
463 || !(trusted
= expand_string(dns_trust_aa
))
465 || !(auth_name
= dns_extract_auth_name(dnsa
))
466 || OK
!= match_isinlist(auth_name
, &trusted
, 0, NULL
, NULL
,
467 MCL_DOMAIN
, TRUE
, NULL
)
471 DEBUG(D_dns
) debug_printf("DNS faked the AD bit "
472 "(got AA and matched with dns_trust_aa (%s in %s))\n",
473 auth_name
, dns_trust_aa
);
480 dns_set_insecure(dns_answer
* dnsa
)
482 HEADER
* h
= (HEADER
*)dnsa
->answer
;
486 /************************************************
487 * Check whether the AA bit is set *
488 * We need this to warn if we requested AD *
489 * from an authoritive server *
490 ************************************************/
493 dns_is_aa(const dns_answer
*dnsa
)
495 return ((HEADER
*)dnsa
->answer
)->aa
;
500 /*************************************************
501 * Turn DNS type into text *
502 *************************************************/
504 /* Turn the coded record type into a string for printing. All those that Exim
505 uses should be included here.
507 Argument: record type
508 Returns: pointer to string
516 case T_A
: return US
"A";
517 case T_MX
: return US
"MX";
518 case T_AAAA
: return US
"AAAA";
519 case T_A6
: return US
"A6";
520 case T_TXT
: return US
"TXT";
521 case T_SPF
: return US
"SPF";
522 case T_PTR
: return US
"PTR";
523 case T_SOA
: return US
"SOA";
524 case T_SRV
: return US
"SRV";
525 case T_NS
: return US
"NS";
526 case T_CNAME
: return US
"CNAME";
527 case T_TLSA
: return US
"TLSA";
528 default: return US
"?";
534 /*************************************************
535 * Cache a failed DNS lookup result *
536 *************************************************/
538 /* We cache failed lookup results so as not to experience timeouts many
539 times for the same domain. We need to retain the resolver options because they
540 may change. For successful lookups, we rely on resolver and/or name server
548 Returns: the return code
552 dns_return(const uschar
* name
, int type
, int rc
)
554 res_state resp
= os_get_dns_resolver_res();
555 tree_node
*node
= store_get_perm(sizeof(tree_node
) + 290);
556 sprintf(CS node
->name
, "%.255s-%s-%lx", name
, dns_text_type(type
),
559 (void)tree_insertnode(&tree_dns_fails
, node
);
563 /*************************************************
564 * Do basic DNS lookup *
565 *************************************************/
567 /* Call the resolver to look up the given domain name, using the given type,
568 and check the result. The error code TRY_AGAIN is documented as meaning "non-
569 Authoritive Host not found, or SERVERFAIL". Sometimes there are badly set
570 up nameservers that produce this error continually, so there is the option of
571 providing a list of domains for which this is treated as a non-existent
575 dnsa pointer to dns_answer structure
577 type type of DNS record required (T_A, T_MX, etc)
579 Returns: DNS_SUCCEED successful lookup
580 DNS_NOMATCH name not found (NXDOMAIN)
581 or name contains illegal characters (if checking)
582 or name is an IP address (for IP address lookup)
583 DNS_NODATA domain exists, but no data for this type (NODATA)
584 DNS_AGAIN soft failure, try again later
589 dns_basic_lookup(dns_answer
*dnsa
, const uschar
*name
, int type
)
593 const uschar
*save_domain
;
595 res_state resp
= os_get_dns_resolver_res();
598 uschar node_name
[290];
600 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
601 a timeout on one domain doesn't happen time and time again for messages that
602 have many addresses in the same domain. We rely on the resolver and name server
603 caching for successful lookups. */
605 sprintf(CS node_name
, "%.255s-%s-%lx", name
, dns_text_type(type
),
607 previous
= tree_search(tree_dns_fails
, node_name
);
608 if (previous
!= NULL
)
610 DEBUG(D_dns
) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
611 name
, dns_text_type(type
),
612 (previous
->data
.val
== DNS_NOMATCH
)? "DNS_NOMATCH" :
613 (previous
->data
.val
== DNS_NODATA
)? "DNS_NODATA" :
614 (previous
->data
.val
== DNS_AGAIN
)? "DNS_AGAIN" :
615 (previous
->data
.val
== DNS_FAIL
)? "DNS_FAIL" : "??");
616 return previous
->data
.val
;
619 #ifdef EXPERIMENTAL_INTERNATIONAL
620 /* Convert all names to a-label form before doing lookup */
623 uschar
* errstr
= NULL
;
624 DEBUG(D_dns
) if (string_is_utf8(name
))
625 debug_printf("convert utf8 '%s' to alabel for for lookup\n", name
);
626 if ((alabel
= string_domain_utf8_to_alabel(name
, &errstr
)), errstr
)
629 debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name
,
631 host_find_failed_syntax
= TRUE
;
638 /* If configured, check the hygene of the name passed to lookup. Otherwise,
639 although DNS lookups may give REFUSED at the lower level, some resolvers
640 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
641 domains cannot be in the DNS. The check is now done by a regular expression;
642 give it space for substring storage to save it having to get its own if the
643 regex has substrings that are used - the default uses a conditional.
645 This test is omitted for PTR records. These occur only in calls from the dnsdb
646 lookup, which constructs the names itself, so they should be OK. Besides,
647 bitstring labels don't conform to normal name syntax. (But the aren't used any
650 For SRV records, we omit the initial _smtp._tcp. components at the start. */
652 #ifndef STAND_ALONE /* Omit this for stand-alone tests */
654 if (check_dns_names_pattern
[0] != 0 && type
!= T_PTR
&& type
!= T_TXT
)
656 const uschar
*checkname
= name
;
657 int ovector
[3*(EXPAND_MAXN
+1)];
661 /* For an SRV lookup, skip over the first two components (the service and
662 protocol names, which both start with an underscore). */
664 if (type
== T_SRV
|| type
== T_TLSA
)
666 while (*checkname
++ != '.');
667 while (*checkname
++ != '.');
670 if (pcre_exec(regex_check_dns_names
, NULL
, CCS checkname
, Ustrlen(checkname
),
671 0, PCRE_EOPT
, ovector
, sizeof(ovector
)/sizeof(int)) < 0)
674 debug_printf("DNS name syntax check failed: %s (%s)\n", name
,
675 dns_text_type(type
));
676 host_find_failed_syntax
= TRUE
;
681 #endif /* STAND_ALONE */
683 /* Call the resolver; for an overlong response, res_search() will return the
684 number of bytes the message would need, so we need to check for this case. The
685 effect is to truncate overlong data.
687 On some systems, res_search() will recognize "A-for-A" queries and return
688 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
689 nameservers are also believed to do this. It is, of course, contrary to the
690 specification of the DNS, so we lock it out. */
692 if ((type
== T_A
|| type
== T_AAAA
) && string_is_ip_address(name
, NULL
) != 0)
695 /* If we are running in the test harness, instead of calling the normal resolver
696 (res_search), we call fakens_search(), which recognizes certain special
697 domains, and interfaces to a fake nameserver for certain special zones. */
699 dnsa
->answerlen
= running_in_test_harness
700 ? fakens_search(name
, type
, dnsa
->answer
, MAXPACKET
)
701 : res_search(CCS name
, C_IN
, type
, dnsa
->answer
, MAXPACKET
);
703 if (dnsa
->answerlen
> MAXPACKET
)
705 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) resulted in overlong packet (size %d), truncating to %d.\n",
706 name
, dns_text_type(type
), dnsa
->answerlen
, MAXPACKET
);
707 dnsa
->answerlen
= MAXPACKET
;
710 if (dnsa
->answerlen
< 0) switch (h_errno
)
713 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
714 "returning DNS_NOMATCH\n", name
, dns_text_type(type
));
715 return dns_return(name
, type
, DNS_NOMATCH
);
718 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
719 name
, dns_text_type(type
));
721 /* Cut this out for various test programs */
723 save_domain
= deliver_domain
;
724 deliver_domain
= string_copy(name
); /* set $domain */
725 rc
= match_isinlist(name
, (const uschar
**)&dns_again_means_nonexist
, 0, NULL
, NULL
,
726 MCL_DOMAIN
, TRUE
, NULL
);
727 deliver_domain
= save_domain
;
730 DEBUG(D_dns
) debug_printf("returning DNS_AGAIN\n");
731 return dns_return(name
, type
, DNS_AGAIN
);
733 DEBUG(D_dns
) debug_printf("%s is in dns_again_means_nonexist: returning "
734 "DNS_NOMATCH\n", name
);
735 return dns_return(name
, type
, DNS_NOMATCH
);
737 #else /* For stand-alone tests */
738 return dns_return(name
, type
, DNS_AGAIN
);
742 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
743 "returning DNS_FAIL\n", name
, dns_text_type(type
));
744 return dns_return(name
, type
, DNS_FAIL
);
747 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
748 "returning DNS_NODATA\n", name
, dns_text_type(type
));
749 return dns_return(name
, type
, DNS_NODATA
);
752 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
753 "returning DNS_FAIL\n", name
, dns_text_type(type
), h_errno
);
754 return dns_return(name
, type
, DNS_FAIL
);
757 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) succeeded\n",
758 name
, dns_text_type(type
));
766 /************************************************
767 * Do a DNS lookup and handle CNAMES *
768 ************************************************/
770 /* Look up the given domain name, using the given type. Follow CNAMEs if
771 necessary, but only so many times. There aren't supposed to be CNAME chains in
772 the DNS, but you are supposed to cope with them if you find them.
774 The assumption is made that if the resolver gives back records of the
775 requested type *and* a CNAME, we don't need to make another call to look up
776 the CNAME. I can't see how it could return only some of the right records. If
777 it's done a CNAME lookup in the past, it will have all of them; if not, it
780 If fully_qualified_name is not NULL, set it to point to the full name
781 returned by the resolver, if this is different to what it is given, unless
782 the returned name starts with "*" as some nameservers seem to be returning
783 wildcards in this form. In international mode "different" means "alabel
784 forms are different".
787 dnsa pointer to dns_answer structure
788 name domain name to look up
789 type DNS record type (T_A, T_MX, etc)
790 fully_qualified_name if not NULL, return the returned name here if its
791 contents are different (i.e. it must be preset)
793 Returns: DNS_SUCCEED successful lookup
794 DNS_NOMATCH name not found
795 DNS_NODATA no data found
796 DNS_AGAIN soft failure, try again later
801 dns_lookup(dns_answer
*dnsa
, const uschar
*name
, int type
,
802 const uschar
**fully_qualified_name
)
805 const uschar
*orig_name
= name
;
806 BOOL secure_so_far
= TRUE
;
808 /* Loop to follow CNAME chains so far, but no further... */
810 for (i
= 0; i
< 10; i
++)
813 dns_record
*rr
, cname_rr
, type_rr
;
817 /* DNS lookup failures get passed straight back. */
819 if ((rc
= dns_basic_lookup(dnsa
, name
, type
)) != DNS_SUCCEED
) return rc
;
821 /* We should have either records of the required type, or a CNAME record,
822 or both. We need to know whether both exist for getting the fully qualified
823 name, but avoid scanning more than necessary. Note that we must copy the
824 contents of any rr blocks returned by dns_next_rr() as they use the same
825 area in the dnsa block. */
827 cname_rr
.data
= type_rr
.data
= NULL
;
828 for (rr
= dns_next_rr(dnsa
, &dnss
, RESET_ANSWERS
);
830 rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
))
832 if (rr
->type
== type
)
834 if (type_rr
.data
== NULL
) type_rr
= *rr
;
835 if (cname_rr
.data
!= NULL
) break;
837 else if (rr
->type
== T_CNAME
) cname_rr
= *rr
;
840 /* For the first time round this loop, if a CNAME was found, take the fully
841 qualified name from it; otherwise from the first data record, if present. */
843 if (i
== 0 && fully_qualified_name
!= NULL
)
845 uschar
* rr_name
= cname_rr
.data
? cname_rr
.name
846 : type_rr
.data
? type_rr
.name
: NULL
;
848 && Ustrcmp(rr_name
, *fully_qualified_name
) != 0
850 #ifdef EXPERIMENTAL_INTERNATIONAL
851 && ( !string_is_utf8(*fully_qualified_name
)
853 string_domain_utf8_to_alabel(*fully_qualified_name
, NULL
)) != 0
857 *fully_qualified_name
= string_copy_dnsdomain(rr_name
);
860 /* If any data records of the correct type were found, we are done. */
862 if (type_rr
.data
!= NULL
)
864 if (!secure_so_far
) /* mark insecure if any element of CNAME chain was */
865 dns_set_insecure(dnsa
);
869 /* If there are no data records, we need to re-scan the DNS using the
870 domain given in the CNAME record, which should exist (otherwise we should
871 have had a failure from dns_lookup). However code against the possibility of
874 if (cname_rr
.data
== NULL
) return DNS_FAIL
;
875 datalen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
876 cname_rr
.data
, (DN_EXPAND_ARG4_TYPE
)data
, sizeof(data
));
877 if (datalen
< 0) return DNS_FAIL
;
880 if (!dns_is_secure(dnsa
))
881 secure_so_far
= FALSE
;
883 DEBUG(D_dns
) debug_printf("CNAME found: change to %s\n", name
);
884 } /* Loop back to do another lookup */
886 /*Control reaches here after 10 times round the CNAME loop. Something isn't
889 log_write(0, LOG_MAIN
, "CNAME loop for %s encountered", orig_name
);
898 /************************************************
899 * Do a DNS lookup and handle virtual types *
900 ************************************************/
902 /* This function handles some invented "lookup types" that synthesize features
903 not available in the basic types. The special types all have negative values.
904 Positive type values are passed straight on to dns_lookup().
907 dnsa pointer to dns_answer structure
908 name domain name to look up
909 type DNS record type (T_A, T_MX, etc or a "special")
910 fully_qualified_name if not NULL, return the returned name here if its
911 contents are different (i.e. it must be preset)
913 Returns: DNS_SUCCEED successful lookup
914 DNS_NOMATCH name not found
915 DNS_NODATA no data found
916 DNS_AGAIN soft failure, try again later
921 dns_special_lookup(dns_answer
*dnsa
, const uschar
*name
, int type
,
922 const uschar
**fully_qualified_name
)
926 /* The "mx hosts only" type doesn't require any special action here */
928 return dns_lookup(dnsa
, name
, T_MX
, fully_qualified_name
);
930 /* Find nameservers for the domain or the nearest enclosing zone, excluding
937 const uschar
*d
= name
;
940 int rc
= dns_lookup(dnsa
, d
, type
, fully_qualified_name
);
941 if (rc
!= DNS_NOMATCH
&& rc
!= DNS_NODATA
) return rc
;
942 while (*d
!= 0 && *d
!= '.') d
++;
943 if (*d
++ == 0) break;
948 /* Try to look up the Client SMTP Authorization SRV record for the name. If
949 there isn't one, search from the top downwards for a CSA record in a parent
950 domain, which might be making assertions about subdomains. If we find a record
951 we set fully_qualified_name to whichever lookup succeeded, so that the caller
952 can tell whether to look at the explicit authorization field or the subdomain
956 uschar
*srvname
, *namesuff
, *tld
, *p
;
957 int priority
, weight
, port
;
963 DEBUG(D_dns
) debug_printf("CSA lookup of %s\n", name
);
965 srvname
= string_sprintf("_client._smtp.%s", name
);
966 rc
= dns_lookup(dnsa
, srvname
, T_SRV
, NULL
);
967 if (rc
== DNS_SUCCEED
|| rc
== DNS_AGAIN
)
969 if (rc
== DNS_SUCCEED
) *fully_qualified_name
= string_copy(name
);
973 /* Search for CSA subdomain assertion SRV records from the top downwards,
974 starting with the 2nd level domain. This order maximizes cache-friendliness.
975 We skip the top level domains to avoid loading their nameservers and because
976 we know they'll never have CSA SRV records. */
978 namesuff
= Ustrrchr(name
, '.');
979 if (namesuff
== NULL
) return DNS_NOMATCH
;
982 limit
= dns_csa_search_limit
;
984 /* Use more appropriate search parameters if we are in the reverse DNS. */
986 if (strcmpic(namesuff
, US
".arpa") == 0)
987 if (namesuff
- 8 > name
&& strcmpic(namesuff
- 8, US
".in-addr.arpa") == 0)
993 else if (namesuff
- 4 > name
&& strcmpic(namesuff
- 4, US
".ip6.arpa") == 0)
1001 DEBUG(D_dns
) debug_printf("CSA TLD %s\n", tld
);
1003 /* Do not perform the search if the top level or 2nd level domains do not
1004 exist. This is quite common, and when it occurs all the search queries would
1005 go to the root or TLD name servers, which is not friendly. So we check the
1006 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
1007 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
1008 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
1009 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
1011 if (rc
== DNS_NOMATCH
)
1013 /* This is really gross. The successful return value from res_search() is
1014 the packet length, which is stored in dnsa->answerlen. If we get a
1015 negative DNS reply then res_search() returns -1, which causes the bounds
1016 checks for name decompression to fail when it is treated as a packet
1017 length, which in turn causes the authority search to fail. The correct
1018 packet length has been lost inside libresolv, so we have to guess a
1019 replacement value. (The only way to fix this properly would be to
1020 re-implement res_search() and res_query() so that they don't muddle their
1021 success and packet length return values.) For added safety we only reset
1022 the packet length if the packet header looks plausible. */
1024 HEADER
*h
= (HEADER
*)dnsa
->answer
;
1025 if (h
->qr
== 1 && h
->opcode
== QUERY
&& h
->tc
== 0
1026 && (h
->rcode
== NOERROR
|| h
->rcode
== NXDOMAIN
)
1027 && ntohs(h
->qdcount
) == 1 && ntohs(h
->ancount
) == 0
1028 && ntohs(h
->nscount
) >= 1)
1029 dnsa
->answerlen
= MAXPACKET
;
1031 for (rr
= dns_next_rr(dnsa
, &dnss
, RESET_AUTHORITY
);
1033 rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
)
1035 if (rr
->type
!= T_SOA
) continue;
1036 else if (strcmpic(rr
->name
, US
"") == 0 ||
1037 strcmpic(rr
->name
, tld
) == 0) return DNS_NOMATCH
;
1041 for (i
= 0; i
< limit
; i
++)
1045 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1046 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1048 if (namesuff
<= name
) return DNS_NOMATCH
;
1051 /* Find the start of the preceding domain name label. */
1053 if (--namesuff
<= name
) return DNS_NOMATCH
;
1054 while (*namesuff
!= '.');
1056 DEBUG(D_dns
) debug_printf("CSA parent search at %s\n", namesuff
+ 1);
1058 srvname
= string_sprintf("_client._smtp.%s", namesuff
+ 1);
1059 rc
= dns_lookup(dnsa
, srvname
, T_SRV
, NULL
);
1060 if (rc
== DNS_AGAIN
) return rc
;
1061 if (rc
!= DNS_SUCCEED
) continue;
1063 /* Check that the SRV record we have found is worth returning. We don't
1064 just return the first one we find, because some lower level SRV record
1065 might make stricter assertions than its parent domain. */
1067 for (rr
= dns_next_rr(dnsa
, &dnss
, RESET_ANSWERS
);
1069 rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
))
1071 if (rr
->type
!= T_SRV
) continue;
1073 /* Extract the numerical SRV fields (p is incremented) */
1075 GETSHORT(priority
, p
);
1076 GETSHORT(weight
, p
); weight
= weight
; /* compiler quietening */
1079 /* Check the CSA version number */
1080 if (priority
!= 1) continue;
1082 /* If it's making an interesting assertion, return this response. */
1085 *fully_qualified_name
= namesuff
+ 1;
1095 return dns_lookup(dnsa
, name
, type
, fully_qualified_name
);
1098 /* Control should never reach here */
1107 /*************************************************
1108 * Get address(es) from DNS record *
1109 *************************************************/
1111 /* The record type is either T_A for an IPv4 address or T_AAAA (or T_A6 when
1112 supported) for an IPv6 address.
1115 dnsa the DNS answer block
1118 Returns: pointer to a chain of dns_address items; NULL when the dnsa was overrun
1122 dns_address_from_rr(dns_answer
*dnsa
, dns_record
*rr
)
1124 dns_address
* yield
= NULL
;
1125 uschar
* dnsa_lim
= dnsa
->answer
+ dnsa
->answerlen
;
1127 if (rr
->type
== T_A
)
1129 uschar
*p
= US rr
->data
;
1130 if (p
+ 4 <= dnsa_lim
)
1132 yield
= store_get(sizeof(dns_address
) + 20);
1133 (void)sprintf(CS yield
->address
, "%d.%d.%d.%d", p
[0], p
[1], p
[2], p
[3]);
1142 if (rr
->data
+ 16 <= dnsa_lim
)
1144 yield
= store_get(sizeof(dns_address
) + 50);
1145 inet_ntop(AF_INET6
, US rr
->data
, CS yield
->address
, 50);
1149 #endif /* HAVE_IPV6 */
1157 dns_pattern_init(void)
1159 if (check_dns_names_pattern
[0] != 0 && !regex_check_dns_names
)
1160 regex_check_dns_names
=
1161 regex_must_compile(check_dns_names_pattern
, FALSE
, TRUE
);