1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2014 */
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 suit 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 /* This code, for forcing TRY_AGAIN and NO_RECOVERY, is here so that it works
57 for the old test suite that uses a real nameserver. When the old test suite is
58 eventually abandoned, this code could be moved into the fakens utility. */
60 if (len
>= 14 && Ustrcmp(endname
- 14, "test.again.dns") == 0)
62 int delay
= Uatoi(name
); /* digits at the start of the name */
63 DEBUG(D_dns
) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
64 name
, dns_text_type(type
));
67 DEBUG(D_dns
) debug_printf("delaying %d seconds\n", delay
);
74 if (len
>= 13 && Ustrcmp(endname
- 13, "test.fail.dns") == 0)
76 DEBUG(D_dns
) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
77 name
, dns_text_type(type
));
78 h_errno
= NO_RECOVERY
;
82 /* Look for the fakens utility, and if it exists, call it. */
84 (void)string_format(utilname
, sizeof(utilname
), "%s/../bin/fakens",
87 if (stat(CS utilname
, &statbuf
) >= 0)
93 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) using fakens\n",
94 name
, dns_text_type(type
));
97 argv
[1] = spool_directory
;
99 argv
[3] = dns_text_type(type
);
102 pid
= child_open(argv
, NULL
, 0000, &infd
, &outfd
, FALSE
);
104 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "failed to run fakens: %s",
109 while (asize
> 0 && (rc
= read(outfd
, aptr
, asize
)) > 0)
112 aptr
+= rc
; /* Don't modify the actual arguments, because they */
113 asize
-= rc
; /* may need to be passed on to res_search(). */
117 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "read from fakens failed: %s",
120 switch(child_close(pid
, 0))
123 case 1: h_errno
= HOST_NOT_FOUND
; return -1;
124 case 2: h_errno
= TRY_AGAIN
; return -1;
126 case 3: h_errno
= NO_RECOVERY
; return -1;
127 case 4: h_errno
= NO_DATA
; return -1;
128 case 5: /* Pass on to res_search() */
129 DEBUG(D_dns
) debug_printf("fakens returned PASS_ON\n");
133 /* fakens utility not found, or it returned "pass on" */
135 DEBUG(D_dns
) debug_printf("passing %s on to res_search()\n", domain
);
137 return res_search(CS domain
, C_IN
, type
, answerptr
, size
);
142 /*************************************************
143 * Initialize and configure resolver *
144 *************************************************/
146 /* Initialize the resolver and the storage for holding DNS answers if this is
147 the first time we have been here, and set the resolver options.
150 qualify_single TRUE to set the RES_DEFNAMES option
151 search_parents TRUE to set the RES_DNSRCH option
152 use_dnssec TRUE to set the RES_USE_DNSSEC option
158 dns_init(BOOL qualify_single
, BOOL search_parents
, BOOL use_dnssec
)
160 res_state resp
= os_get_dns_resolver_res();
162 if ((resp
->options
& RES_INIT
) == 0)
164 DEBUG(D_resolver
) resp
->options
|= RES_DEBUG
; /* For Cygwin */
165 os_put_dns_resolver_res(resp
);
167 DEBUG(D_resolver
) resp
->options
|= RES_DEBUG
;
168 os_put_dns_resolver_res(resp
);
171 resp
->options
&= ~(RES_DNSRCH
| RES_DEFNAMES
);
172 resp
->options
|= (qualify_single
? RES_DEFNAMES
: 0) |
173 (search_parents
? RES_DNSRCH
: 0);
174 if (dns_retrans
> 0) resp
->retrans
= dns_retrans
;
175 if (dns_retry
> 0) resp
->retry
= dns_retry
;
178 if (dns_use_edns0
>= 0)
181 resp
->options
|= RES_USE_EDNS0
;
183 resp
->options
&= ~RES_USE_EDNS0
;
185 debug_printf("Coerced resolver EDNS0 support %s.\n",
186 dns_use_edns0
? "on" : "off");
189 if (dns_use_edns0
>= 0)
191 debug_printf("Unable to %sset EDNS0 without resolver support.\n",
192 dns_use_edns0
? "" : "un");
195 #ifndef DISABLE_DNSSEC
196 # ifdef RES_USE_DNSSEC
197 # ifndef RES_USE_EDNS0
198 # error Have RES_USE_DNSSEC but not RES_USE_EDNS0? Something hinky ...
201 resp
->options
|= RES_USE_DNSSEC
;
202 if (dns_dnssec_ok
>= 0)
204 if (dns_use_edns0
== 0 && dns_dnssec_ok
!= 0)
207 debug_printf("CONFLICT: dns_use_edns0 forced false, dns_dnssec_ok forced true, ignoring latter!\n");
212 resp
->options
|= RES_USE_DNSSEC
;
214 resp
->options
&= ~RES_USE_DNSSEC
;
215 DEBUG(D_resolver
) debug_printf("Coerced resolver DNSSEC support %s.\n",
216 dns_dnssec_ok
? "on" : "off");
220 if (dns_dnssec_ok
>= 0)
222 debug_printf("Unable to %sset DNSSEC without resolver support.\n",
223 dns_dnssec_ok
? "" : "un");
226 debug_printf("Unable to set DNSSEC without resolver support.\n");
228 #endif /* DISABLE_DNSSEC */
230 os_put_dns_resolver_res(resp
);
235 /*************************************************
236 * Build key name for PTR records *
237 *************************************************/
239 /* This function inverts an IP address and adds the relevant domain, to produce
240 a name that can be used to look up PTR records.
243 string the IP address as a string
244 buffer a suitable buffer, long enough to hold the result
250 dns_build_reverse(const uschar
*string
, uschar
*buffer
)
252 const uschar
*p
= string
+ Ustrlen(string
);
255 /* Handle IPv4 address */
258 if (Ustrchr(string
, ':') == NULL
)
262 for (i
= 0; i
< 4; i
++)
264 const uschar
*ppp
= p
;
265 while (ppp
> string
&& ppp
[-1] != '.') ppp
--;
266 Ustrncpy(pp
, ppp
, p
- ppp
);
271 Ustrcpy(pp
, "in-addr.arpa");
274 /* Handle IPv6 address; convert to binary so as to fill out any
275 abbreviation in the textual form. */
282 (void)host_aton(string
, v6
);
284 /* The original specification for IPv6 reverse lookup was to invert each
285 nibble, and look in the ip6.int domain. The domain was subsequently
286 changed to ip6.arpa. */
288 for (i
= 3; i
>= 0; i
--)
291 for (j
= 0; j
< 32; j
+= 4)
293 sprintf(CS pp
, "%x.", (v6
[i
] >> j
) & 15);
297 Ustrcpy(pp
, "ip6.arpa.");
299 /* Another way of doing IPv6 reverse lookups was proposed in conjunction
300 with A6 records. However, it fell out of favour when they did. The
301 alternative was to construct a binary key, and look in ip6.arpa. I tried
302 to make this code do that, but I could not make it work on Solaris 8. The
303 resolver seems to lose the initial backslash somehow. However, now that
304 this style of reverse lookup has been dropped, it doesn't matter. These
305 lines are left here purely for historical interest. */
307 /**************************************************
311 for (i = 0; i < 4; i++)
313 sprintf(pp, "%08X", v6[i]);
316 Ustrcpy(pp, "].ip6.arpa.");
317 **************************************************/
326 /*************************************************
327 * Get next DNS record from answer block *
328 *************************************************/
330 /* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
331 RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
332 scan the additional records, and reset == RESET_NEXT to get the next record.
333 The result is in static storage which must be copied if it is to be preserved.
336 dnsa pointer to dns answer block
337 dnss pointer to dns scan block
338 reset option specifing what portion to scan, as described above
340 Returns: next dns record, or NULL when no more
344 dns_next_rr(dns_answer
*dnsa
, dns_scan
*dnss
, int reset
)
346 HEADER
*h
= (HEADER
*)dnsa
->answer
;
349 /* Reset the saved data when requested to, and skip to the first required RR */
351 if (reset
!= RESET_NEXT
)
353 dnss
->rrcount
= ntohs(h
->qdcount
);
354 dnss
->aptr
= dnsa
->answer
+ sizeof(HEADER
);
356 /* Skip over questions; failure to expand the name just gives up */
358 while (dnss
->rrcount
-- > 0)
360 namelen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
361 dnss
->aptr
, (DN_EXPAND_ARG4_TYPE
) &(dnss
->srr
.name
), DNS_MAXNAME
);
362 if (namelen
< 0) { dnss
->rrcount
= 0; return NULL
; }
363 dnss
->aptr
+= namelen
+ 4; /* skip name & type & class */
366 /* Get the number of answer records. */
368 dnss
->rrcount
= ntohs(h
->ancount
);
370 /* Skip over answers if we want to look at the authority section. Also skip
371 the NS records (i.e. authority section) if wanting to look at the additional
374 if (reset
== RESET_ADDITIONAL
) dnss
->rrcount
+= ntohs(h
->nscount
);
376 if (reset
== RESET_AUTHORITY
|| reset
== RESET_ADDITIONAL
)
378 while (dnss
->rrcount
-- > 0)
380 namelen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
381 dnss
->aptr
, (DN_EXPAND_ARG4_TYPE
) &(dnss
->srr
.name
), DNS_MAXNAME
);
382 if (namelen
< 0) { dnss
->rrcount
= 0; return NULL
; }
383 dnss
->aptr
+= namelen
+ 8; /* skip name, type, class & TTL */
384 GETSHORT(dnss
->srr
.size
, dnss
->aptr
); /* size of data portion */
385 dnss
->aptr
+= dnss
->srr
.size
; /* skip over it */
387 dnss
->rrcount
= (reset
== RESET_AUTHORITY
)
388 ? ntohs(h
->nscount
) : ntohs(h
->arcount
);
392 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
393 contains the number of RR records left. */
395 if (dnss
->rrcount
-- <= 0) return NULL
;
397 /* If expanding the RR domain name fails, behave as if no more records
400 namelen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
, dnss
->aptr
,
401 (DN_EXPAND_ARG4_TYPE
) &(dnss
->srr
.name
), DNS_MAXNAME
);
402 if (namelen
< 0) { dnss
->rrcount
= 0; return NULL
; }
404 /* Move the pointer past the name and fill in the rest of the data structure
405 from the following bytes. */
407 dnss
->aptr
+= namelen
;
408 GETSHORT(dnss
->srr
.type
, dnss
->aptr
); /* Record type */
409 dnss
->aptr
+= 6; /* Don't want class or TTL */
410 GETSHORT(dnss
->srr
.size
, dnss
->aptr
); /* Size of data portion */
411 dnss
->srr
.data
= dnss
->aptr
; /* The record's data follows */
412 dnss
->aptr
+= dnss
->srr
.size
; /* Advance to next RR */
414 /* Return a pointer to the dns_record structure within the dns_answer. This is
415 for convenience so that the scans can use nice-looking for loops. */
423 /*************************************************
424 * Return whether AD bit set in DNS result *
425 *************************************************/
427 /* We do not perform DNSSEC work ourselves; if the administrator has installed
428 a verifying resolver which sets AD as appropriate, though, we'll use that.
429 (AD = Authentic Data)
431 Argument: pointer to dns answer block
432 Returns: bool indicating presence of AD bit
436 dns_is_secure(const dns_answer
* dnsa
)
438 #ifdef DISABLE_DNSSEC
440 debug_printf("DNSSEC support disabled at build-time; dns_is_secure() false\n");
443 HEADER
*h
= (HEADER
*)dnsa
->answer
;
444 return h
->ad
? TRUE
: FALSE
;
449 dns_set_insecure(dns_answer
* dnsa
)
451 HEADER
* h
= (HEADER
*)dnsa
->answer
;
458 /*************************************************
459 * Turn DNS type into text *
460 *************************************************/
462 /* Turn the coded record type into a string for printing. All those that Exim
463 uses should be included here.
465 Argument: record type
466 Returns: pointer to string
474 case T_A
: return US
"A";
475 case T_MX
: return US
"MX";
476 case T_AAAA
: return US
"AAAA";
477 case T_A6
: return US
"A6";
478 case T_TXT
: return US
"TXT";
479 case T_SPF
: return US
"SPF";
480 case T_PTR
: return US
"PTR";
481 case T_SOA
: return US
"SOA";
482 case T_SRV
: return US
"SRV";
483 case T_NS
: return US
"NS";
484 case T_CNAME
: return US
"CNAME";
485 case T_TLSA
: return US
"TLSA";
486 default: return US
"?";
492 /*************************************************
493 * Cache a failed DNS lookup result *
494 *************************************************/
496 /* We cache failed lookup results so as not to experience timeouts many
497 times for the same domain. We need to retain the resolver options because they
498 may change. For successful lookups, we rely on resolver and/or name server
506 Returns: the return code
510 dns_return(const uschar
* name
, int type
, int rc
)
512 res_state resp
= os_get_dns_resolver_res();
513 tree_node
*node
= store_get_perm(sizeof(tree_node
) + 290);
514 sprintf(CS node
->name
, "%.255s-%s-%lx", name
, dns_text_type(type
),
517 (void)tree_insertnode(&tree_dns_fails
, node
);
523 /*************************************************
524 * Do basic DNS lookup *
525 *************************************************/
527 /* Call the resolver to look up the given domain name, using the given type,
528 and check the result. The error code TRY_AGAIN is documented as meaning "non-
529 Authoritive Host not found, or SERVERFAIL". Sometimes there are badly set
530 up nameservers that produce this error continually, so there is the option of
531 providing a list of domains for which this is treated as a non-existent
535 dnsa pointer to dns_answer structure
537 type type of DNS record required (T_A, T_MX, etc)
539 Returns: DNS_SUCCEED successful lookup
540 DNS_NOMATCH name not found (NXDOMAIN)
541 or name contains illegal characters (if checking)
542 or name is an IP address (for IP address lookup)
543 DNS_NODATA domain exists, but no data for this type (NODATA)
544 DNS_AGAIN soft failure, try again later
549 dns_basic_lookup(dns_answer
*dnsa
, const uschar
*name
, int type
)
553 const uschar
*save_domain
;
555 res_state resp
= os_get_dns_resolver_res();
558 uschar node_name
[290];
560 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
561 a timeout on one domain doesn't happen time and time again for messages that
562 have many addresses in the same domain. We rely on the resolver and name server
563 caching for successful lookups. */
565 sprintf(CS node_name
, "%.255s-%s-%lx", name
, dns_text_type(type
),
567 previous
= tree_search(tree_dns_fails
, node_name
);
568 if (previous
!= NULL
)
570 DEBUG(D_dns
) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
571 name
, dns_text_type(type
),
572 (previous
->data
.val
== DNS_NOMATCH
)? "DNS_NOMATCH" :
573 (previous
->data
.val
== DNS_NODATA
)? "DNS_NODATA" :
574 (previous
->data
.val
== DNS_AGAIN
)? "DNS_AGAIN" :
575 (previous
->data
.val
== DNS_FAIL
)? "DNS_FAIL" : "??");
576 return previous
->data
.val
;
579 #ifdef EXPERIMENTAL_INTERNATIONAL
580 /* Convert all names to a-label form before doing lookup */
583 uschar
* errstr
= NULL
;
584 if ((alabel
= string_domain_utf8_to_alabel(name
, &errstr
)), errstr
)
587 debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name
,
589 host_find_failed_syntax
= TRUE
;
596 /* If configured, check the hygene of the name passed to lookup. Otherwise,
597 although DNS lookups may give REFUSED at the lower level, some resolvers
598 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
599 domains cannot be in the DNS. The check is now done by a regular expression;
600 give it space for substring storage to save it having to get its own if the
601 regex has substrings that are used - the default uses a conditional.
603 This test is omitted for PTR records. These occur only in calls from the dnsdb
604 lookup, which constructs the names itself, so they should be OK. Besides,
605 bitstring labels don't conform to normal name syntax. (But the aren't used any
608 For SRV records, we omit the initial _smtp._tcp. components at the start. */
610 #ifndef STAND_ALONE /* Omit this for stand-alone tests */
612 if (check_dns_names_pattern
[0] != 0 && type
!= T_PTR
&& type
!= T_TXT
)
614 const uschar
*checkname
= name
;
615 int ovector
[3*(EXPAND_MAXN
+1)];
619 /* For an SRV lookup, skip over the first two components (the service and
620 protocol names, which both start with an underscore). */
622 if (type
== T_SRV
|| type
== T_TLSA
)
624 while (*checkname
++ != '.');
625 while (*checkname
++ != '.');
628 if (pcre_exec(regex_check_dns_names
, NULL
, CCS checkname
, Ustrlen(checkname
),
629 0, PCRE_EOPT
, ovector
, sizeof(ovector
)/sizeof(int)) < 0)
632 debug_printf("DNS name syntax check failed: %s (%s)\n", name
,
633 dns_text_type(type
));
634 host_find_failed_syntax
= TRUE
;
639 #endif /* STAND_ALONE */
641 /* Call the resolver; for an overlong response, res_search() will return the
642 number of bytes the message would need, so we need to check for this case. The
643 effect is to truncate overlong data.
645 On some systems, res_search() will recognize "A-for-A" queries and return
646 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
647 nameservers are also believed to do this. It is, of course, contrary to the
648 specification of the DNS, so we lock it out. */
650 if ((type
== T_A
|| type
== T_AAAA
) && string_is_ip_address(name
, NULL
) != 0)
653 /* If we are running in the test harness, instead of calling the normal resolver
654 (res_search), we call fakens_search(), which recognizes certain special
655 domains, and interfaces to a fake nameserver for certain special zones. */
657 dnsa
->answerlen
= running_in_test_harness
658 ? fakens_search(name
, type
, dnsa
->answer
, MAXPACKET
)
659 : res_search(CCS name
, C_IN
, type
, dnsa
->answer
, MAXPACKET
);
661 if (dnsa
->answerlen
> MAXPACKET
)
663 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) resulted in overlong packet (size %d), truncating to %d.\n",
664 name
, dns_text_type(type
), dnsa
->answerlen
, MAXPACKET
);
665 dnsa
->answerlen
= MAXPACKET
;
668 if (dnsa
->answerlen
< 0) switch (h_errno
)
671 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
672 "returning DNS_NOMATCH\n", name
, dns_text_type(type
));
673 return dns_return(name
, type
, DNS_NOMATCH
);
676 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
677 name
, dns_text_type(type
));
679 /* Cut this out for various test programs */
681 save_domain
= deliver_domain
;
682 deliver_domain
= string_copy(name
); /* set $domain */
683 rc
= match_isinlist(name
, (const uschar
**)&dns_again_means_nonexist
, 0, NULL
, NULL
,
684 MCL_DOMAIN
, TRUE
, NULL
);
685 deliver_domain
= save_domain
;
688 DEBUG(D_dns
) debug_printf("returning DNS_AGAIN\n");
689 return dns_return(name
, type
, DNS_AGAIN
);
691 DEBUG(D_dns
) debug_printf("%s is in dns_again_means_nonexist: returning "
692 "DNS_NOMATCH\n", name
);
693 return dns_return(name
, type
, DNS_NOMATCH
);
695 #else /* For stand-alone tests */
696 return dns_return(name
, type
, DNS_AGAIN
);
700 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
701 "returning DNS_FAIL\n", name
, dns_text_type(type
));
702 return dns_return(name
, type
, DNS_FAIL
);
705 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
706 "returning DNS_NODATA\n", name
, dns_text_type(type
));
707 return dns_return(name
, type
, DNS_NODATA
);
710 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
711 "returning DNS_FAIL\n", name
, dns_text_type(type
), h_errno
);
712 return dns_return(name
, type
, DNS_FAIL
);
715 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) succeeded\n",
716 name
, dns_text_type(type
));
724 /************************************************
725 * Do a DNS lookup and handle CNAMES *
726 ************************************************/
728 /* Look up the given domain name, using the given type. Follow CNAMEs if
729 necessary, but only so many times. There aren't supposed to be CNAME chains in
730 the DNS, but you are supposed to cope with them if you find them.
732 The assumption is made that if the resolver gives back records of the
733 requested type *and* a CNAME, we don't need to make another call to look up
734 the CNAME. I can't see how it could return only some of the right records. If
735 it's done a CNAME lookup in the past, it will have all of them; if not, it
738 If fully_qualified_name is not NULL, set it to point to the full name
739 returned by the resolver, if this is different to what it is given, unless
740 the returned name starts with "*" as some nameservers seem to be returning
741 wildcards in this form.
744 dnsa pointer to dns_answer structure
745 name domain name to look up
746 type DNS record type (T_A, T_MX, etc)
747 fully_qualified_name if not NULL, return the returned name here if its
748 contents are different (i.e. it must be preset)
750 Returns: DNS_SUCCEED successful lookup
751 DNS_NOMATCH name not found
752 DNS_NODATA no data found
753 DNS_AGAIN soft failure, try again later
758 dns_lookup(dns_answer
*dnsa
, const uschar
*name
, int type
,
759 const uschar
**fully_qualified_name
)
762 const uschar
*orig_name
= name
;
763 BOOL secure_so_far
= TRUE
;
765 /* Loop to follow CNAME chains so far, but no further... */
767 for (i
= 0; i
< 10; i
++)
770 dns_record
*rr
, cname_rr
, type_rr
;
774 /* DNS lookup failures get passed straight back. */
776 if ((rc
= dns_basic_lookup(dnsa
, name
, type
)) != DNS_SUCCEED
) return rc
;
778 /* We should have either records of the required type, or a CNAME record,
779 or both. We need to know whether both exist for getting the fully qualified
780 name, but avoid scanning more than necessary. Note that we must copy the
781 contents of any rr blocks returned by dns_next_rr() as they use the same
782 area in the dnsa block. */
784 cname_rr
.data
= type_rr
.data
= NULL
;
785 for (rr
= dns_next_rr(dnsa
, &dnss
, RESET_ANSWERS
);
787 rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
))
789 if (rr
->type
== type
)
791 if (type_rr
.data
== NULL
) type_rr
= *rr
;
792 if (cname_rr
.data
!= NULL
) break;
794 else if (rr
->type
== T_CNAME
) cname_rr
= *rr
;
797 /* For the first time round this loop, if a CNAME was found, take the fully
798 qualified name from it; otherwise from the first data record, if present. */
800 if (i
== 0 && fully_qualified_name
!= NULL
)
802 if (cname_rr
.data
!= NULL
)
804 if (Ustrcmp(cname_rr
.name
, *fully_qualified_name
) != 0 &&
805 cname_rr
.name
[0] != '*')
806 *fully_qualified_name
= string_copy_dnsdomain(cname_rr
.name
);
808 else if (type_rr
.data
!= NULL
)
810 if (Ustrcmp(type_rr
.name
, *fully_qualified_name
) != 0 &&
811 type_rr
.name
[0] != '*')
812 *fully_qualified_name
= string_copy_dnsdomain(type_rr
.name
);
816 /* If any data records of the correct type were found, we are done. */
818 if (type_rr
.data
!= NULL
)
820 if (!secure_so_far
) /* mark insecure if any element of CNAME chain was */
821 dns_set_insecure(dnsa
);
825 /* If there are no data records, we need to re-scan the DNS using the
826 domain given in the CNAME record, which should exist (otherwise we should
827 have had a failure from dns_lookup). However code against the possibility of
830 if (cname_rr
.data
== NULL
) return DNS_FAIL
;
831 datalen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
832 cname_rr
.data
, (DN_EXPAND_ARG4_TYPE
)data
, sizeof(data
));
833 if (datalen
< 0) return DNS_FAIL
;
836 if (!dns_is_secure(dnsa
))
837 secure_so_far
= FALSE
;
839 DEBUG(D_dns
) debug_printf("CNAME found: change to %s\n", name
);
840 } /* Loop back to do another lookup */
842 /*Control reaches here after 10 times round the CNAME loop. Something isn't
845 log_write(0, LOG_MAIN
, "CNAME loop for %s encountered", orig_name
);
854 /************************************************
855 * Do a DNS lookup and handle virtual types *
856 ************************************************/
858 /* This function handles some invented "lookup types" that synthesize feature
859 not available in the basic types. The special types all have negative values.
860 Positive type values are passed straight on to dns_lookup().
863 dnsa pointer to dns_answer structure
864 name domain name to look up
865 type DNS record type (T_A, T_MX, etc or a "special")
866 fully_qualified_name if not NULL, return the returned name here if its
867 contents are different (i.e. it must be preset)
869 Returns: DNS_SUCCEED successful lookup
870 DNS_NOMATCH name not found
871 DNS_NODATA no data found
872 DNS_AGAIN soft failure, try again later
877 dns_special_lookup(dns_answer
*dnsa
, const uschar
*name
, int type
,
878 const uschar
**fully_qualified_name
)
880 if (type
>= 0) return dns_lookup(dnsa
, name
, type
, fully_qualified_name
);
882 /* The "mx hosts only" type doesn't require any special action here */
884 if (type
== T_MXH
) return dns_lookup(dnsa
, name
, T_MX
, fully_qualified_name
);
886 /* Find nameservers for the domain or the nearest enclosing zone, excluding the
891 const uschar
*d
= name
;
894 int rc
= dns_lookup(dnsa
, d
, T_NS
, fully_qualified_name
);
895 if (rc
!= DNS_NOMATCH
&& rc
!= DNS_NODATA
) return rc
;
896 while (*d
!= 0 && *d
!= '.') d
++;
897 if (*d
++ == 0) break;
902 /* Try to look up the Client SMTP Authorization SRV record for the name. If
903 there isn't one, search from the top downwards for a CSA record in a parent
904 domain, which might be making assertions about subdomains. If we find a record
905 we set fully_qualified_name to whichever lookup succeeded, so that the caller
906 can tell whether to look at the explicit authorization field or the subdomain
911 uschar
*srvname
, *namesuff
, *tld
, *p
;
912 int priority
, weight
, port
;
918 DEBUG(D_dns
) debug_printf("CSA lookup of %s\n", name
);
920 srvname
= string_sprintf("_client._smtp.%s", name
);
921 rc
= dns_lookup(dnsa
, srvname
, T_SRV
, NULL
);
922 if (rc
== DNS_SUCCEED
|| rc
== DNS_AGAIN
)
924 if (rc
== DNS_SUCCEED
) *fully_qualified_name
= string_copy(name
);
928 /* Search for CSA subdomain assertion SRV records from the top downwards,
929 starting with the 2nd level domain. This order maximizes cache-friendliness.
930 We skip the top level domains to avoid loading their nameservers and because
931 we know they'll never have CSA SRV records. */
933 namesuff
= Ustrrchr(name
, '.');
934 if (namesuff
== NULL
) return DNS_NOMATCH
;
937 limit
= dns_csa_search_limit
;
939 /* Use more appropriate search parameters if we are in the reverse DNS. */
941 if (strcmpic(namesuff
, US
".arpa") == 0)
943 if (namesuff
- 8 > name
&& strcmpic(namesuff
- 8, US
".in-addr.arpa") == 0)
949 else if (namesuff
- 4 > name
&& strcmpic(namesuff
- 4, US
".ip6.arpa") == 0)
958 DEBUG(D_dns
) debug_printf("CSA TLD %s\n", tld
);
960 /* Do not perform the search if the top level or 2nd level domains do not
961 exist. This is quite common, and when it occurs all the search queries would
962 go to the root or TLD name servers, which is not friendly. So we check the
963 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
964 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
965 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
966 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
968 if (rc
== DNS_NOMATCH
)
970 /* This is really gross. The successful return value from res_search() is
971 the packet length, which is stored in dnsa->answerlen. If we get a
972 negative DNS reply then res_search() returns -1, which causes the bounds
973 checks for name decompression to fail when it is treated as a packet
974 length, which in turn causes the authority search to fail. The correct
975 packet length has been lost inside libresolv, so we have to guess a
976 replacement value. (The only way to fix this properly would be to
977 re-implement res_search() and res_query() so that they don't muddle their
978 success and packet length return values.) For added safety we only reset
979 the packet length if the packet header looks plausible. */
981 HEADER
*h
= (HEADER
*)dnsa
->answer
;
982 if (h
->qr
== 1 && h
->opcode
== QUERY
&& h
->tc
== 0
983 && (h
->rcode
== NOERROR
|| h
->rcode
== NXDOMAIN
)
984 && ntohs(h
->qdcount
) == 1 && ntohs(h
->ancount
) == 0
985 && ntohs(h
->nscount
) >= 1)
986 dnsa
->answerlen
= MAXPACKET
;
988 for (rr
= dns_next_rr(dnsa
, &dnss
, RESET_AUTHORITY
);
990 rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
))
991 if (rr
->type
!= T_SOA
) continue;
992 else if (strcmpic(rr
->name
, US
"") == 0 ||
993 strcmpic(rr
->name
, tld
) == 0) return DNS_NOMATCH
;
997 for (i
= 0; i
< limit
; i
++)
1001 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1002 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1004 if (namesuff
<= name
) return DNS_NOMATCH
;
1007 /* Find the start of the preceding domain name label. */
1009 if (--namesuff
<= name
) return DNS_NOMATCH
;
1010 while (*namesuff
!= '.');
1012 DEBUG(D_dns
) debug_printf("CSA parent search at %s\n", namesuff
+ 1);
1014 srvname
= string_sprintf("_client._smtp.%s", namesuff
+ 1);
1015 rc
= dns_lookup(dnsa
, srvname
, T_SRV
, NULL
);
1016 if (rc
== DNS_AGAIN
) return rc
;
1017 if (rc
!= DNS_SUCCEED
) continue;
1019 /* Check that the SRV record we have found is worth returning. We don't
1020 just return the first one we find, because some lower level SRV record
1021 might make stricter assertions than its parent domain. */
1023 for (rr
= dns_next_rr(dnsa
, &dnss
, RESET_ANSWERS
);
1025 rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
))
1027 if (rr
->type
!= T_SRV
) continue;
1029 /* Extract the numerical SRV fields (p is incremented) */
1031 GETSHORT(priority
, p
);
1032 GETSHORT(weight
, p
); weight
= weight
; /* compiler quietening */
1035 /* Check the CSA version number */
1036 if (priority
!= 1) continue;
1038 /* If it's making an interesting assertion, return this response. */
1041 *fully_qualified_name
= namesuff
+ 1;
1049 /* Control should never reach here */
1058 /*************************************************
1059 * Get address(es) from DNS record *
1060 *************************************************/
1062 /* The record type is either T_A for an IPv4 address or T_AAAA (or T_A6 when
1063 supported) for an IPv6 address. In the A6 case, there may be several addresses,
1064 generated by following chains. A recursive function does all the hard work. A6
1065 records now look like passing into history, so the code is only included when
1066 explicitly asked for.
1069 dnsa the DNS answer block
1072 Returns: pointer a chain of dns_address items
1076 dns_address_from_rr(dns_answer
*dnsa
, dns_record
*rr
)
1078 dns_address
*yield
= NULL
;
1080 dnsa
= dnsa
; /* Stop picky compilers warning */
1082 if (rr
->type
== T_A
)
1084 uschar
*p
= (uschar
*)(rr
->data
);
1085 yield
= store_get(sizeof(dns_address
) + 20);
1086 (void)sprintf(CS yield
->address
, "%d.%d.%d.%d", p
[0], p
[1], p
[2], p
[3]);
1094 yield
= store_get(sizeof(dns_address
) + 50);
1095 inet_ntop(AF_INET6
, (uschar
*)(rr
->data
), CS yield
->address
, 50);
1098 #endif /* HAVE_IPV6 */
1106 dns_pattern_init(void)
1108 if (check_dns_names_pattern
[0] != 0 && !regex_check_dns_names
)
1109 regex_check_dns_names
=
1110 regex_must_compile(check_dns_names_pattern
, FALSE
, TRUE
);