04cb046f465755967d703d547c10b648bd4e730a
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions for interfacing with the DNS. */
13 /*************************************************
15 *************************************************/
17 /* This function is called instead of res_search() when Exim is running in its
18 test harness. It recognizes some special domain names, and uses them to force
19 failure and retry responses (optionally with a delay). Otherwise, it calls an
20 external utility that mocks-up a nameserver, if it can find the utility.
21 If not, it passes its arguments on to res_search(). The fake nameserver may
22 also return a code specifying that the name should be passed on.
24 Background: the original test suite required a real nameserver to carry the
25 test zones, whereas the new test suite has the fake server for portability. This
29 domain the domain name
30 type the DNS record type
31 answerptr where to put the answer
32 size size of the answer area
34 Returns: length of returned data, or -1 on error (h_errno set)
38 fakens_search(const uschar
*domain
, int type
, uschar
*answerptr
, int size
)
40 int len
= Ustrlen(domain
);
41 int asize
= size
; /* Locally modified */
44 uschar
*aptr
= answerptr
; /* Locally modified */
47 /* Remove terminating dot. */
49 if (domain
[len
- 1] == '.') len
--;
50 name
= string_copyn(domain
, len
);
52 /* Look for the fakens utility, and if it exists, call it. */
54 (void)string_format(utilname
, sizeof(utilname
), "%s/bin/fakens",
55 config_main_directory
);
57 if (stat(CS utilname
, &statbuf
) >= 0)
63 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) using fakens\n", name
, dns_text_type(type
));
66 argv
[1] = config_main_directory
;
68 argv
[3] = dns_text_type(type
);
71 pid
= child_open(argv
, NULL
, 0000, &infd
, &outfd
, FALSE
);
73 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "failed to run fakens: %s",
78 while (asize
> 0 && (rc
= read(outfd
, aptr
, asize
)) > 0)
81 aptr
+= rc
; /* Don't modify the actual arguments, because they */
82 asize
-= rc
; /* may need to be passed on to res_search(). */
85 /* If we ran out of output buffer before exhausting the return,
86 carry on reading and counting it. */
89 while ((rc
= read(outfd
, name
, sizeof(name
))) > 0)
93 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "read from fakens failed: %s",
96 switch(child_close(pid
, 0))
99 case 1: h_errno
= HOST_NOT_FOUND
; return -1;
100 case 2: h_errno
= TRY_AGAIN
; return -1;
102 case 3: h_errno
= NO_RECOVERY
; return -1;
103 case 4: h_errno
= NO_DATA
; return -1;
104 case 5: /* Pass on to res_search() */
105 DEBUG(D_dns
) debug_printf("fakens returned PASS_ON\n");
110 DEBUG(D_dns
) debug_printf("fakens (%s) not found\n", utilname
);
113 /* fakens utility not found, or it returned "pass on" */
115 DEBUG(D_dns
) debug_printf("passing %s on to res_search()\n", domain
);
117 return res_search(CS domain
, C_IN
, type
, answerptr
, size
);
122 /*************************************************
123 * Initialize and configure resolver *
124 *************************************************/
126 /* Initialize the resolver and the storage for holding DNS answers if this is
127 the first time we have been here, and set the resolver options.
130 qualify_single TRUE to set the RES_DEFNAMES option
131 search_parents TRUE to set the RES_DNSRCH option
132 use_dnssec TRUE to set the RES_USE_DNSSEC option
138 dns_init(BOOL qualify_single
, BOOL search_parents
, BOOL use_dnssec
)
140 res_state resp
= os_get_dns_resolver_res();
142 if ((resp
->options
& RES_INIT
) == 0)
144 DEBUG(D_resolver
) resp
->options
|= RES_DEBUG
; /* For Cygwin */
145 os_put_dns_resolver_res(resp
);
147 DEBUG(D_resolver
) resp
->options
|= RES_DEBUG
;
148 os_put_dns_resolver_res(resp
);
151 resp
->options
&= ~(RES_DNSRCH
| RES_DEFNAMES
);
152 resp
->options
|= (qualify_single
? RES_DEFNAMES
: 0) |
153 (search_parents
? RES_DNSRCH
: 0);
154 if (dns_retrans
> 0) resp
->retrans
= dns_retrans
;
155 if (dns_retry
> 0) resp
->retry
= dns_retry
;
158 if (dns_use_edns0
>= 0)
161 resp
->options
|= RES_USE_EDNS0
;
163 resp
->options
&= ~RES_USE_EDNS0
;
165 debug_printf("Coerced resolver EDNS0 support %s.\n",
166 dns_use_edns0
? "on" : "off");
169 if (dns_use_edns0
>= 0)
171 debug_printf("Unable to %sset EDNS0 without resolver support.\n",
172 dns_use_edns0
? "" : "un");
175 #ifndef DISABLE_DNSSEC
176 # ifdef RES_USE_DNSSEC
177 # ifndef RES_USE_EDNS0
178 # error Have RES_USE_DNSSEC but not RES_USE_EDNS0? Something hinky ...
181 resp
->options
|= RES_USE_DNSSEC
;
182 if (dns_dnssec_ok
>= 0)
184 if (dns_use_edns0
== 0 && dns_dnssec_ok
!= 0)
187 debug_printf("CONFLICT: dns_use_edns0 forced false, dns_dnssec_ok forced true, ignoring latter!\n");
192 resp
->options
|= RES_USE_DNSSEC
;
194 resp
->options
&= ~RES_USE_DNSSEC
;
195 DEBUG(D_resolver
) debug_printf("Coerced resolver DNSSEC support %s.\n",
196 dns_dnssec_ok
? "on" : "off");
200 if (dns_dnssec_ok
>= 0)
202 debug_printf("Unable to %sset DNSSEC without resolver support.\n",
203 dns_dnssec_ok
? "" : "un");
206 debug_printf("Unable to set DNSSEC without resolver support.\n");
208 #endif /* DISABLE_DNSSEC */
210 os_put_dns_resolver_res(resp
);
215 /*************************************************
216 * Build key name for PTR records *
217 *************************************************/
219 /* This function inverts an IP address and adds the relevant domain, to produce
220 a name that can be used to look up PTR records.
223 string the IP address as a string
224 buffer a suitable buffer, long enough to hold the result
230 dns_build_reverse(const uschar
*string
, uschar
*buffer
)
232 const uschar
*p
= string
+ Ustrlen(string
);
235 /* Handle IPv4 address */
238 if (Ustrchr(string
, ':') == NULL
)
241 for (int i
= 0; i
< 4; i
++)
243 const uschar
*ppp
= p
;
244 while (ppp
> string
&& ppp
[-1] != '.') ppp
--;
245 Ustrncpy(pp
, ppp
, p
- ppp
);
250 Ustrcpy(pp
, US
"in-addr.arpa");
253 /* Handle IPv6 address; convert to binary so as to fill out any
254 abbreviation in the textual form. */
260 (void)host_aton(string
, v6
);
262 /* The original specification for IPv6 reverse lookup was to invert each
263 nibble, and look in the ip6.int domain. The domain was subsequently
264 changed to ip6.arpa. */
266 for (int i
= 3; i
>= 0; i
--)
267 for (int j
= 0; j
< 32; j
+= 4)
268 pp
+= sprintf(CS pp
, "%x.", (v6
[i
] >> j
) & 15);
269 Ustrcpy(pp
, US
"ip6.arpa.");
271 /* Another way of doing IPv6 reverse lookups was proposed in conjunction
272 with A6 records. However, it fell out of favour when they did. The
273 alternative was to construct a binary key, and look in ip6.arpa. I tried
274 to make this code do that, but I could not make it work on Solaris 8. The
275 resolver seems to lose the initial backslash somehow. However, now that
276 this style of reverse lookup has been dropped, it doesn't matter. These
277 lines are left here purely for historical interest. */
279 /**************************************************
283 for (int i = 0; i < 4; i++)
285 sprintf(pp, "%08X", v6[i]);
288 Ustrcpy(pp, US"].ip6.arpa.");
289 **************************************************/
298 /* Increment the aptr in dnss, checking against dnsa length.
299 Return: TRUE for a bad result
302 dnss_inc_aptr(const dns_answer
* dnsa
, dns_scan
* dnss
, unsigned delta
)
304 return (dnss
->aptr
+= delta
) >= dnsa
->answer
+ dnsa
->answerlen
;
307 /*************************************************
308 * Get next DNS record from answer block *
309 *************************************************/
311 /* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
312 RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
313 scan the additional records, and reset == RESET_NEXT to get the next record.
314 The result is in static storage which must be copied if it is to be preserved.
317 dnsa pointer to dns answer block
318 dnss pointer to dns scan block
319 reset option specifying what portion to scan, as described above
321 Returns: next dns record, or NULL when no more
325 dns_next_rr(const dns_answer
*dnsa
, dns_scan
*dnss
, int reset
)
327 const HEADER
* h
= (const HEADER
*)dnsa
->answer
;
332 # define TRACE DEBUG(D_dns)
335 # define TRACE if (FALSE)
338 /* Reset the saved data when requested to, and skip to the first required RR */
340 if (reset
!= RESET_NEXT
)
342 dnss
->rrcount
= ntohs(h
->qdcount
);
343 TRACE
debug_printf("%s: reset (Q rrcount %d)\n", __FUNCTION__
, dnss
->rrcount
);
344 dnss
->aptr
= dnsa
->answer
+ sizeof(HEADER
);
346 /* Skip over questions; failure to expand the name just gives up */
348 while (dnss
->rrcount
-- > 0)
350 TRACE trace
= "Q-namelen";
351 namelen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
352 dnss
->aptr
, (DN_EXPAND_ARG4_TYPE
) &dnss
->srr
.name
, DNS_MAXNAME
);
353 if (namelen
< 0) goto null_return
;
354 /* skip name & type & class */
355 TRACE trace
= "Q-skip";
356 if (dnss_inc_aptr(dnsa
, dnss
, namelen
+4)) goto null_return
;
359 /* Get the number of answer records. */
361 dnss
->rrcount
= ntohs(h
->ancount
);
362 TRACE
debug_printf("%s: reset (A rrcount %d)\n", __FUNCTION__
, dnss
->rrcount
);
364 /* Skip over answers if we want to look at the authority section. Also skip
365 the NS records (i.e. authority section) if wanting to look at the additional
368 if (reset
== RESET_ADDITIONAL
)
370 TRACE
debug_printf("%s: additional\n", __FUNCTION__
);
371 dnss
->rrcount
+= ntohs(h
->nscount
);
372 TRACE
debug_printf("%s: reset (NS rrcount %d)\n", __FUNCTION__
, dnss
->rrcount
);
375 if (reset
== RESET_AUTHORITY
|| reset
== RESET_ADDITIONAL
)
377 TRACE
if (reset
== RESET_AUTHORITY
)
378 debug_printf("%s: authority\n", __FUNCTION__
);
379 while (dnss
->rrcount
-- > 0)
381 TRACE trace
= "A-namelen";
382 namelen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
383 dnss
->aptr
, (DN_EXPAND_ARG4_TYPE
) &dnss
->srr
.name
, DNS_MAXNAME
);
384 if (namelen
< 0) goto null_return
;
385 /* skip name, type, class & TTL */
386 TRACE trace
= "A-hdr";
387 if (dnss_inc_aptr(dnsa
, dnss
, namelen
+8)) goto null_return
;
388 GETSHORT(dnss
->srr
.size
, dnss
->aptr
); /* size of data portion */
390 TRACE trace
= "A-skip";
391 if (dnss_inc_aptr(dnsa
, dnss
, dnss
->srr
.size
)) goto null_return
;
393 dnss
->rrcount
= reset
== RESET_AUTHORITY
394 ? ntohs(h
->nscount
) : ntohs(h
->arcount
);
395 TRACE
debug_printf("%s: reset (%s rrcount %d)\n", __FUNCTION__
,
396 reset
== RESET_AUTHORITY
? "NS" : "AR", dnss
->rrcount
);
398 TRACE
debug_printf("%s: %d RRs to read\n", __FUNCTION__
, dnss
->rrcount
);
401 TRACE
debug_printf("%s: next (%d left)\n", __FUNCTION__
, dnss
->rrcount
);
403 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
404 contains the number of RR records left. */
406 if (dnss
->rrcount
-- <= 0) return NULL
;
408 /* If expanding the RR domain name fails, behave as if no more records
411 TRACE trace
= "R-namelen";
412 namelen
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
, dnss
->aptr
,
413 (DN_EXPAND_ARG4_TYPE
) &dnss
->srr
.name
, DNS_MAXNAME
);
414 if (namelen
< 0) goto null_return
;
416 /* Move the pointer past the name and fill in the rest of the data structure
417 from the following bytes. */
419 TRACE trace
= "R-name";
420 if (dnss_inc_aptr(dnsa
, dnss
, namelen
)) goto null_return
;
422 GETSHORT(dnss
->srr
.type
, dnss
->aptr
); /* Record type */
423 TRACE trace
= "R-class";
424 if (dnss_inc_aptr(dnsa
, dnss
, 2)) goto null_return
; /* Don't want class */
425 GETLONG(dnss
->srr
.ttl
, dnss
->aptr
); /* TTL */
426 GETSHORT(dnss
->srr
.size
, dnss
->aptr
); /* Size of data portion */
427 dnss
->srr
.data
= dnss
->aptr
; /* The record's data follows */
429 /* Unchecked increment ok here since no further access on this iteration;
430 will be checked on next at "R-name". */
432 dnss
->aptr
+= dnss
->srr
.size
; /* Advance to next RR */
434 /* Return a pointer to the dns_record structure within the dns_answer. This is
435 for convenience so that the scans can use nice-looking for loops. */
437 TRACE
debug_printf("%s: return %s\n", __FUNCTION__
, dns_text_type(dnss
->srr
.type
));
441 TRACE
debug_printf("%s: terminate (%d RRs left). Last op: %s; errno %d %s\n",
442 __FUNCTION__
, dnss
->rrcount
, trace
, errno
, strerror(errno
));
448 /* Extract the AUTHORITY information from the answer. If the answer isn't
449 authoritative (AA not set), we do not extract anything.
451 The AUTHORITY section contains NS records if the name in question was found,
452 it contains a SOA record otherwise. (This is just from experience and some
453 tests, is there some spec?)
455 Scan the whole AUTHORITY section, since it may contain other records
458 Return: name for the authority, in an allocated string, or NULL if none found */
460 static const uschar
*
461 dns_extract_auth_name(const dns_answer
* dnsa
) /* FIXME: const dns_answer */
464 const HEADER
* h
= (const HEADER
*) dnsa
->answer
;
466 if (h
->nscount
&& h
->aa
)
467 for (dns_record
* rr
= dns_next_rr(dnsa
, &dnss
, RESET_AUTHORITY
);
468 rr
; rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
))
469 if (rr
->type
== (h
->ancount
? T_NS
: T_SOA
))
470 return string_copy(rr
->name
);
477 /*************************************************
478 * Return whether AD bit set in DNS result *
479 *************************************************/
481 /* We do not perform DNSSEC work ourselves; if the administrator has installed
482 a verifying resolver which sets AD as appropriate, though, we'll use that.
483 (AD = Authentic Data, AA = Authoritative Answer)
485 Argument: pointer to dns answer block
486 Returns: bool indicating presence of AD bit
490 dns_is_secure(const dns_answer
* dnsa
)
492 #ifdef DISABLE_DNSSEC
494 debug_printf("DNSSEC support disabled at build-time; dns_is_secure() false\n");
497 const HEADER
* h
= (const HEADER
*) dnsa
->answer
;
498 const uschar
* auth_name
;
499 const uschar
* trusted
;
501 if (h
->ad
) return TRUE
;
503 /* If the resolver we ask is authoritative for the domain in question, it
504 * may not set the AD but the AA bit. If we explicitly trust
505 * the resolver for that domain (via a domainlist in dns_trust_aa),
506 * we return TRUE to indicate a secure answer.
511 || !(trusted
= expand_string(dns_trust_aa
))
513 || !(auth_name
= dns_extract_auth_name(dnsa
))
514 || OK
!= match_isinlist(auth_name
, &trusted
, 0, NULL
, NULL
,
515 MCL_DOMAIN
, TRUE
, NULL
)
519 DEBUG(D_dns
) debug_printf("DNS faked the AD bit "
520 "(got AA and matched with dns_trust_aa (%s in %s))\n",
521 auth_name
, dns_trust_aa
);
528 dns_set_insecure(dns_answer
* dnsa
)
530 #ifndef DISABLE_DNSSEC
531 HEADER
* h
= (HEADER
*)dnsa
->answer
;
536 /************************************************
537 * Check whether the AA bit is set *
538 * We need this to warn if we requested AD *
539 * from an authoritative server *
540 ************************************************/
543 dns_is_aa(const dns_answer
*dnsa
)
545 #ifdef DISABLE_DNSSEC
548 return ((const HEADER
*)dnsa
->answer
)->aa
;
554 /*************************************************
555 * Turn DNS type into text *
556 *************************************************/
558 /* Turn the coded record type into a string for printing. All those that Exim
559 uses should be included here.
561 Argument: record type
562 Returns: pointer to string
570 case T_A
: return US
"A";
571 case T_MX
: return US
"MX";
572 case T_AAAA
: return US
"AAAA";
573 case T_A6
: return US
"A6";
574 case T_TXT
: return US
"TXT";
575 case T_SPF
: return US
"SPF";
576 case T_PTR
: return US
"PTR";
577 case T_SOA
: return US
"SOA";
578 case T_SRV
: return US
"SRV";
579 case T_NS
: return US
"NS";
580 case T_CNAME
: return US
"CNAME";
581 case T_TLSA
: return US
"TLSA";
582 default: return US
"?";
588 /*************************************************
589 * Cache a failed DNS lookup result *
590 *************************************************/
593 dns_fail_tag(uschar
* buf
, const uschar
* name
, int dns_type
)
595 res_state resp
= os_get_dns_resolver_res();
597 /*XX buf needs to be 255 +1 + (max(typetext) == 5) +1 + max(chars_for_long-max) +1
598 We truncate the name here for safety... could use a dynamic string. */
600 sprintf(CS buf
, "%.255s-%s-%lx", name
, dns_text_type(dns_type
),
601 (unsigned long) resp
->options
);
605 /* We cache failed lookup results so as not to experience timeouts many
606 times for the same domain. We need to retain the resolver options because they
607 may change. For successful lookups, we rely on resolver and/or name server
613 expiry time TTL expires, or zero for unlimited
616 Returns: the return code
619 /*XXX the derivation of this value needs explaining */
620 #define DNS_FAILTAG_MAX 290
622 (sizeof(void *) > sizeof(double) ? sizeof(void *) : sizeof(double))
624 (((((intptr_t)n) + (alignment-1)) / alignment) * alignment)
625 #define DNS_FAILNODE_SIZE \
626 align(sizeof(tree_node) + DNS_FAILTAG_MAX + sizeof(expiring_data))
629 dns_fail_return(const uschar
* name
, int type
, time_t expiry
, int rc
)
631 uschar node_name
[DNS_FAILTAG_MAX
];
632 tree_node
* previous
, * new;
635 dns_fail_tag(node_name
, name
, type
);
636 if ((previous
= tree_search(tree_dns_fails
, node_name
)))
637 e
= previous
->data
.ptr
;
640 new = store_get_perm(DNS_FAILNODE_SIZE
, is_tainted(name
));
642 dns_fail_tag(new->name
, name
, type
);
643 e
= (expiring_data
*) align((char *)new + sizeof(tree_node
) + DNS_FAILTAG_MAX
);
645 (void)tree_insertnode(&tree_dns_fails
, new);
648 DEBUG(D_dns
) debug_printf(" %s neg-cache entry for %s, ttl %d\n",
649 previous
? "update" : "writing",
650 node_name
, expiry
? (int)(expiry
- time(NULL
)) : -1);
657 /* Return the cached result of a known-bad lookup, or -1.
660 dns_fail_cache_hit(const uschar
* name
, int type
)
662 uschar node_name
[DNS_FAILTAG_MAX
];
663 tree_node
* previous
;
667 dns_fail_tag(node_name
, name
, type
);
668 if (!(previous
= tree_search(tree_dns_fails
, node_name
)))
671 e
= previous
->data
.ptr
;
673 rc
= e
->expiry
&& e
->expiry
<= time(NULL
) ? -1 : val
;
675 DEBUG(D_dns
) debug_printf("DNS lookup of %.255s-%s: %scached value %s%s\n",
676 name
, dns_text_type(type
),
677 rc
== -1 ? "" : "using ",
678 val
== DNS_NOMATCH
? "DNS_NOMATCH" :
679 val
== DNS_NODATA
? "DNS_NODATA" :
680 val
== DNS_AGAIN
? "DNS_AGAIN" :
681 val
== DNS_FAIL
? "DNS_FAIL" : "??",
682 rc
== -1 ? " past valid time" : "");
689 /* Return the TTL suitable for an NXDOMAIN result, which is given
690 in the SOA. We hope that one was returned in the lookup, and do not
691 bother doing a separate lookup; if not found return a forever TTL.
695 dns_expire_from_soa(dns_answer
* dnsa
)
697 const HEADER
* h
= (const HEADER
*)dnsa
->answer
;
700 /* This is really gross. The successful return value from res_search() is
701 the packet length, which is stored in dnsa->answerlen. If we get a
702 negative DNS reply then res_search() returns -1, which causes the bounds
703 checks for name decompression to fail when it is treated as a packet
704 length, which in turn causes the authority search to fail. The correct
705 packet length has been lost inside libresolv, so we have to guess a
706 replacement value. (The only way to fix this properly would be to
707 re-implement res_search() and res_query() so that they don't muddle their
708 success and packet length return values.) For added safety we only reset
709 the packet length if the packet header looks plausible. */
711 if ( h
->qr
== 1 && h
->opcode
== QUERY
&& h
->tc
== 0
712 && (h
->rcode
== NOERROR
|| h
->rcode
== NXDOMAIN
)
713 && (ntohs(h
->qdcount
) == 1 || f
.running_in_test_harness
)
714 && ntohs(h
->ancount
) == 0
715 && ntohs(h
->nscount
) >= 1)
716 dnsa
->answerlen
= sizeof(dnsa
->answer
);
718 for (dns_record
* rr
= dns_next_rr(dnsa
, &dnss
, RESET_AUTHORITY
);
719 rr
; rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
)
720 ) if (rr
->type
== T_SOA
)
722 const uschar
* p
= rr
->data
;
723 uschar discard_buf
[256];
727 /* Skip the mname & rname strings */
729 if ((len
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
730 p
, (DN_EXPAND_ARG4_TYPE
)discard_buf
, 256)) < 0)
733 if ((len
= dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
734 p
, (DN_EXPAND_ARG4_TYPE
)discard_buf
, 256)) < 0)
738 /* Skip the SOA serial, refresh, retry & expire. Grab the TTL */
740 if (p
> dnsa
->answer
+ dnsa
->answerlen
- 5 * INT32SZ
)
745 return time(NULL
) + ttl
;
747 DEBUG(D_dns
) debug_printf("DNS: no SOA record found for neg-TTL\n");
752 /*************************************************
753 * Do basic DNS lookup *
754 *************************************************/
756 /* Call the resolver to look up the given domain name, using the given type,
757 and check the result. The error code TRY_AGAIN is documented as meaning "non-
758 Authoritative Host not found, or SERVERFAIL". Sometimes there are badly set
759 up nameservers that produce this error continually, so there is the option of
760 providing a list of domains for which this is treated as a non-existent
763 The dns_answer structure is pretty big; enough to hold a max-sized DNS message
764 - so best allocated from fast-release memory. As of writing, all our callers
765 use a stack-auto variable.
768 dnsa pointer to dns_answer structure
770 type type of DNS record required (T_A, T_MX, etc)
772 Returns: DNS_SUCCEED successful lookup
773 DNS_NOMATCH name not found (NXDOMAIN)
774 or name contains illegal characters (if checking)
775 or name is an IP address (for IP address lookup)
776 DNS_NODATA domain exists, but no data for this type (NODATA)
777 DNS_AGAIN soft failure, try again later
782 dns_basic_lookup(dns_answer
* dnsa
, const uschar
* name
, int type
)
786 const uschar
* save_domain
;
789 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
790 a timeout on one domain doesn't happen time and time again for messages that
791 have many addresses in the same domain. We rely on the resolver and name server
792 caching for successful lookups.
795 if ((rc
= dns_fail_cache_hit(name
, type
)) > 0)
799 /* Convert all names to a-label form before doing lookup */
802 uschar
* errstr
= NULL
;
803 DEBUG(D_dns
) if (string_is_utf8(name
))
804 debug_printf("convert utf8 '%s' to alabel for for lookup\n", name
);
805 if ((alabel
= string_domain_utf8_to_alabel(name
, &errstr
)), errstr
)
808 debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name
,
810 f
.host_find_failed_syntax
= TRUE
;
817 /* If configured, check the hygiene of the name passed to lookup. Otherwise,
818 although DNS lookups may give REFUSED at the lower level, some resolvers
819 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
820 domains cannot be in the DNS. The check is now done by a regular expression;
821 give it space for substring storage to save it having to get its own if the
822 regex has substrings that are used - the default uses a conditional.
824 This test is omitted for PTR records. These occur only in calls from the dnsdb
825 lookup, which constructs the names itself, so they should be OK. Besides,
826 bitstring labels don't conform to normal name syntax. (But the aren't used any
829 For SRV records, we omit the initial _smtp._tcp. components at the start.
830 The check has been seen to bite on the destination of a SRV lookup that
831 initiall hit a CNAME, for which the next name had only two components.
832 RFC2782 makes no mention of the possibiility of CNAMES, but the Wikipedia
833 article on SRV says they are not a valid configuration. */
835 #ifndef STAND_ALONE /* Omit this for stand-alone tests */
837 if (check_dns_names_pattern
[0] != 0 && type
!= T_PTR
&& type
!= T_TXT
)
839 const uschar
*checkname
= name
;
840 int ovector
[3*(EXPAND_MAXN
+1)];
844 /* For an SRV lookup, skip over the first two components (the service and
845 protocol names, which both start with an underscore). */
847 if (type
== T_SRV
|| type
== T_TLSA
)
849 while (*checkname
&& *checkname
++ != '.') ;
850 while (*checkname
&& *checkname
++ != '.') ;
853 if (pcre_exec(regex_check_dns_names
, NULL
, CCS checkname
, Ustrlen(checkname
),
854 0, PCRE_EOPT
, ovector
, nelem(ovector
)) < 0)
857 debug_printf("DNS name syntax check failed: %s (%s)\n", name
,
858 dns_text_type(type
));
859 f
.host_find_failed_syntax
= TRUE
;
864 #endif /* STAND_ALONE */
866 /* Call the resolver; for an overlong response, res_search() will return the
867 number of bytes the message would need, so we need to check for this case. The
868 effect is to truncate overlong data.
870 On some systems, res_search() will recognize "A-for-A" queries and return
871 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
872 nameservers are also believed to do this. It is, of course, contrary to the
873 specification of the DNS, so we lock it out. */
875 if ((type
== T_A
|| type
== T_AAAA
) && string_is_ip_address(name
, NULL
) != 0)
878 /* If we are running in the test harness, instead of calling the normal resolver
879 (res_search), we call fakens_search(), which recognizes certain special
880 domains, and interfaces to a fake nameserver for certain special zones. */
882 dnsa
->answerlen
= f
.running_in_test_harness
883 ? fakens_search(name
, type
, dnsa
->answer
, sizeof(dnsa
->answer
))
884 : res_search(CCS name
, C_IN
, type
, dnsa
->answer
, sizeof(dnsa
->answer
));
886 if (dnsa
->answerlen
> (int) sizeof(dnsa
->answer
))
888 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) resulted in overlong packet"
889 " (size %d), truncating to %u.\n",
890 name
, dns_text_type(type
), dnsa
->answerlen
, (unsigned int) sizeof(dnsa
->answer
));
891 dnsa
->answerlen
= sizeof(dnsa
->answer
);
894 if (dnsa
->answerlen
< 0) switch (h_errno
)
897 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
898 "returning DNS_NOMATCH\n", name
, dns_text_type(type
));
899 return dns_fail_return(name
, type
, dns_expire_from_soa(dnsa
), DNS_NOMATCH
);
902 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
903 name
, dns_text_type(type
));
905 /* Cut this out for various test programs */
907 save_domain
= deliver_domain
;
908 deliver_domain
= string_copy(name
); /* set $domain */
909 rc
= match_isinlist(name
, (const uschar
**)&dns_again_means_nonexist
, 0, NULL
, NULL
,
910 MCL_DOMAIN
, TRUE
, NULL
);
911 deliver_domain
= save_domain
;
914 DEBUG(D_dns
) debug_printf("returning DNS_AGAIN\n");
915 return dns_fail_return(name
, type
, 0, DNS_AGAIN
);
917 DEBUG(D_dns
) debug_printf("%s is in dns_again_means_nonexist: returning "
918 "DNS_NOMATCH\n", name
);
919 return dns_fail_return(name
, type
, dns_expire_from_soa(dnsa
), DNS_NOMATCH
);
921 #else /* For stand-alone tests */
922 return dns_fail_return(name
, type
, 0, DNS_AGAIN
);
926 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
927 "returning DNS_FAIL\n", name
, dns_text_type(type
));
928 return dns_fail_return(name
, type
, 0, DNS_FAIL
);
931 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
932 "returning DNS_NODATA\n", name
, dns_text_type(type
));
933 return dns_fail_return(name
, type
, dns_expire_from_soa(dnsa
), DNS_NODATA
);
936 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
937 "returning DNS_FAIL\n", name
, dns_text_type(type
), h_errno
);
938 return dns_fail_return(name
, type
, 0, DNS_FAIL
);
941 DEBUG(D_dns
) debug_printf("DNS lookup of %s (%s) succeeded\n",
942 name
, dns_text_type(type
));
950 /************************************************
951 * Do a DNS lookup and handle CNAMES *
952 ************************************************/
954 /* Look up the given domain name, using the given type. Follow CNAMEs if
955 necessary, but only so many times. There aren't supposed to be CNAME chains in
956 the DNS, but you are supposed to cope with them if you find them.
957 By default, follow one CNAME since a resolver has been seen, faced with
958 an MX request and a CNAME (to an A) but no MX present, returning the CNAME.
960 The assumption is made that if the resolver gives back records of the
961 requested type *and* a CNAME, we don't need to make another call to look up
962 the CNAME. I can't see how it could return only some of the right records. If
963 it's done a CNAME lookup in the past, it will have all of them; if not, it
966 If fully_qualified_name is not NULL, set it to point to the full name
967 returned by the resolver, if this is different to what it is given, unless
968 the returned name starts with "*" as some nameservers seem to be returning
969 wildcards in this form. In international mode "different" means "alabel
970 forms are different".
973 dnsa pointer to dns_answer structure
974 name domain name to look up
975 type DNS record type (T_A, T_MX, etc)
976 fully_qualified_name if not NULL, return the returned name here if its
977 contents are different (i.e. it must be preset)
979 Returns: DNS_SUCCEED successful lookup
980 DNS_NOMATCH name not found
981 DNS_NODATA no data found
982 DNS_AGAIN soft failure, try again later
987 dns_lookup(dns_answer
*dnsa
, const uschar
*name
, int type
,
988 const uschar
**fully_qualified_name
)
990 const uschar
*orig_name
= name
;
991 BOOL secure_so_far
= TRUE
;
993 /* By default, assume the resolver follows CNAME chains (and returns NODATA for
994 an unterminated one). If it also does that for a CNAME loop, fine; if it returns
995 a CNAME (maybe the last?) whine about it. However, retain the coding for dumb
996 resolvers hiding behind a config variable. Loop to follow CNAME chains so far,
997 but no further... The testsuite tests the latter case, mostly assuming that the
1000 for (int i
= 0; i
<= dns_cname_loops
; i
++)
1003 dns_record cname_rr
, type_rr
;
1007 /* DNS lookup failures get passed straight back. */
1009 if ((rc
= dns_basic_lookup(dnsa
, name
, type
)) != DNS_SUCCEED
)
1012 /* We should have either records of the required type, or a CNAME record,
1013 or both. We need to know whether both exist for getting the fully qualified
1014 name, but avoid scanning more than necessary. Note that we must copy the
1015 contents of any rr blocks returned by dns_next_rr() as they use the same
1016 area in the dnsa block. */
1018 cname_rr
.data
= type_rr
.data
= NULL
;
1019 for (dns_record
* rr
= dns_next_rr(dnsa
, &dnss
, RESET_ANSWERS
);
1020 rr
; rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
))
1021 if (rr
->type
== type
)
1023 if (type_rr
.data
== NULL
) type_rr
= *rr
;
1024 if (cname_rr
.data
!= NULL
) break;
1026 else if (rr
->type
== T_CNAME
)
1029 /* For the first time round this loop, if a CNAME was found, take the fully
1030 qualified name from it; otherwise from the first data record, if present. */
1032 if (i
== 0 && fully_qualified_name
)
1034 uschar
* rr_name
= cname_rr
.data
1035 ? cname_rr
.name
: type_rr
.data
? type_rr
.name
: NULL
;
1037 && Ustrcmp(rr_name
, *fully_qualified_name
) != 0
1038 && rr_name
[0] != '*'
1040 && ( !string_is_utf8(*fully_qualified_name
)
1042 string_domain_utf8_to_alabel(*fully_qualified_name
, NULL
)) != 0
1046 *fully_qualified_name
= string_copy_dnsdomain(rr_name
);
1049 /* If any data records of the correct type were found, we are done. */
1053 if (!secure_so_far
) /* mark insecure if any element of CNAME chain was */
1054 dns_set_insecure(dnsa
);
1058 /* If there are no data records, we need to re-scan the DNS using the
1059 domain given in the CNAME record, which should exist (otherwise we should
1060 have had a failure from dns_lookup). However code against the possibility of
1061 its not existing. */
1066 /* DNS data comes from the outside, hence tainted */
1067 data
= store_get(256, TRUE
);
1068 if (dn_expand(dnsa
->answer
, dnsa
->answer
+ dnsa
->answerlen
,
1069 cname_rr
.data
, (DN_EXPAND_ARG4_TYPE
)data
, 256) < 0)
1073 if (!dns_is_secure(dnsa
))
1074 secure_so_far
= FALSE
;
1076 DEBUG(D_dns
) debug_printf("CNAME found: change to %s\n", name
);
1077 } /* Loop back to do another lookup */
1079 /*Control reaches here after 10 times round the CNAME loop. Something isn't
1082 log_write(0, LOG_MAIN
, "CNAME loop for %s encountered", orig_name
);
1091 /************************************************
1092 * Do a DNS lookup and handle virtual types *
1093 ************************************************/
1095 /* This function handles some invented "lookup types" that synthesize features
1096 not available in the basic types. The special types all have negative values.
1097 Positive type values are passed straight on to dns_lookup().
1100 dnsa pointer to dns_answer structure
1101 name domain name to look up
1102 type DNS record type (T_A, T_MX, etc or a "special")
1103 fully_qualified_name if not NULL, return the returned name here if its
1104 contents are different (i.e. it must be preset)
1106 Returns: DNS_SUCCEED successful lookup
1107 DNS_NOMATCH name not found
1108 DNS_NODATA no data found
1109 DNS_AGAIN soft failure, try again later
1110 DNS_FAIL DNS failure
1114 dns_special_lookup(dns_answer
*dnsa
, const uschar
*name
, int type
,
1115 const uschar
**fully_qualified_name
)
1119 /* The "mx hosts only" type doesn't require any special action here */
1121 return dns_lookup(dnsa
, name
, T_MX
, fully_qualified_name
);
1123 /* Find nameservers for the domain or the nearest enclosing zone, excluding
1124 the root servers. */
1130 const uschar
*d
= name
;
1133 int rc
= dns_lookup(dnsa
, d
, type
, fully_qualified_name
);
1134 if (rc
!= DNS_NOMATCH
&& rc
!= DNS_NODATA
) return rc
;
1135 while (*d
!= 0 && *d
!= '.') d
++;
1136 if (*d
++ == 0) break;
1141 /* Try to look up the Client SMTP Authorization SRV record for the name. If
1142 there isn't one, search from the top downwards for a CSA record in a parent
1143 domain, which might be making assertions about subdomains. If we find a record
1144 we set fully_qualified_name to whichever lookup succeeded, so that the caller
1145 can tell whether to look at the explicit authorization field or the subdomain
1149 uschar
*srvname
, *namesuff
, *tld
;
1150 int priority
, weight
, port
;
1156 DEBUG(D_dns
) debug_printf("CSA lookup of %s\n", name
);
1158 srvname
= string_sprintf("_client._smtp.%s", name
);
1159 rc
= dns_lookup(dnsa
, srvname
, T_SRV
, NULL
);
1160 if (rc
== DNS_SUCCEED
|| rc
== DNS_AGAIN
)
1162 if (rc
== DNS_SUCCEED
) *fully_qualified_name
= string_copy(name
);
1166 /* Search for CSA subdomain assertion SRV records from the top downwards,
1167 starting with the 2nd level domain. This order maximizes cache-friendliness.
1168 We skip the top level domains to avoid loading their nameservers and because
1169 we know they'll never have CSA SRV records. */
1171 namesuff
= Ustrrchr(name
, '.');
1172 if (namesuff
== NULL
) return DNS_NOMATCH
;
1175 limit
= dns_csa_search_limit
;
1177 /* Use more appropriate search parameters if we are in the reverse DNS. */
1179 if (strcmpic(namesuff
, US
".arpa") == 0)
1180 if (namesuff
- 8 > name
&& strcmpic(namesuff
- 8, US
".in-addr.arpa") == 0)
1186 else if (namesuff
- 4 > name
&& strcmpic(namesuff
- 4, US
".ip6.arpa") == 0)
1194 DEBUG(D_dns
) debug_printf("CSA TLD %s\n", tld
);
1196 /* Do not perform the search if the top level or 2nd level domains do not
1197 exist. This is quite common, and when it occurs all the search queries would
1198 go to the root or TLD name servers, which is not friendly. So we check the
1199 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
1200 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
1201 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
1202 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
1204 if (rc
== DNS_NOMATCH
)
1206 /* This is really gross. The successful return value from res_search() is
1207 the packet length, which is stored in dnsa->answerlen. If we get a
1208 negative DNS reply then res_search() returns -1, which causes the bounds
1209 checks for name decompression to fail when it is treated as a packet
1210 length, which in turn causes the authority search to fail. The correct
1211 packet length has been lost inside libresolv, so we have to guess a
1212 replacement value. (The only way to fix this properly would be to
1213 re-implement res_search() and res_query() so that they don't muddle their
1214 success and packet length return values.) For added safety we only reset
1215 the packet length if the packet header looks plausible. */
1217 const HEADER
* h
= (const HEADER
*)dnsa
->answer
;
1218 if (h
->qr
== 1 && h
->opcode
== QUERY
&& h
->tc
== 0
1219 && (h
->rcode
== NOERROR
|| h
->rcode
== NXDOMAIN
)
1220 && ntohs(h
->qdcount
) == 1 && ntohs(h
->ancount
) == 0
1221 && ntohs(h
->nscount
) >= 1)
1222 dnsa
->answerlen
= sizeof(dnsa
->answer
);
1224 for (rr
= dns_next_rr(dnsa
, &dnss
, RESET_AUTHORITY
);
1225 rr
; rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
)
1227 if (rr
->type
!= T_SOA
) continue;
1228 else if (strcmpic(rr
->name
, US
"") == 0 ||
1229 strcmpic(rr
->name
, tld
) == 0) return DNS_NOMATCH
;
1233 for (i
= 0; i
< limit
; i
++)
1237 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1238 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1240 if (namesuff
<= name
) return DNS_NOMATCH
;
1243 /* Find the start of the preceding domain name label. */
1245 if (--namesuff
<= name
) return DNS_NOMATCH
;
1246 while (*namesuff
!= '.');
1248 DEBUG(D_dns
) debug_printf("CSA parent search at %s\n", namesuff
+ 1);
1250 srvname
= string_sprintf("_client._smtp.%s", namesuff
+ 1);
1251 rc
= dns_lookup(dnsa
, srvname
, T_SRV
, NULL
);
1252 if (rc
== DNS_AGAIN
) return rc
;
1253 if (rc
!= DNS_SUCCEED
) continue;
1255 /* Check that the SRV record we have found is worth returning. We don't
1256 just return the first one we find, because some lower level SRV record
1257 might make stricter assertions than its parent domain. */
1259 for (rr
= dns_next_rr(dnsa
, &dnss
, RESET_ANSWERS
);
1260 rr
; rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
)) if (rr
->type
== T_SRV
)
1262 const uschar
* p
= rr
->data
;
1264 /* Extract the numerical SRV fields (p is incremented) */
1265 GETSHORT(priority
, p
);
1266 GETSHORT(weight
, p
); weight
= weight
; /* compiler quietening */
1269 /* Check the CSA version number */
1270 if (priority
!= 1) continue;
1272 /* If it's making an interesting assertion, return this response. */
1275 *fully_qualified_name
= namesuff
+ 1;
1285 return dns_lookup(dnsa
, name
, type
, fully_qualified_name
);
1288 /* Control should never reach here */
1297 /*************************************************
1298 * Get address(es) from DNS record *
1299 *************************************************/
1301 /* The record type is either T_A for an IPv4 address or T_AAAA for an IPv6 address.
1304 dnsa the DNS answer block
1307 Returns: pointer to a chain of dns_address items; NULL when the dnsa was overrun
1311 dns_address_from_rr(dns_answer
*dnsa
, dns_record
*rr
)
1313 dns_address
* yield
= NULL
;
1314 uschar
* dnsa_lim
= dnsa
->answer
+ dnsa
->answerlen
;
1316 if (rr
->type
== T_A
)
1318 uschar
*p
= US rr
->data
;
1319 if (p
+ 4 <= dnsa_lim
)
1321 /* the IP is not regarded as tainted */
1322 yield
= store_get(sizeof(dns_address
) + 20, FALSE
);
1323 (void)sprintf(CS yield
->address
, "%d.%d.%d.%d", p
[0], p
[1], p
[2], p
[3]);
1332 if (rr
->data
+ 16 <= dnsa_lim
)
1334 struct in6_addr in6
;
1335 for (int i
= 0; i
< 16; i
++) in6
.s6_addr
[i
] = rr
->data
[i
];
1336 yield
= store_get(sizeof(dns_address
) + 50, FALSE
);
1337 inet_ntop(AF_INET6
, &in6
, CS yield
->address
, 50);
1341 #endif /* HAVE_IPV6 */
1349 dns_pattern_init(void)
1351 if (check_dns_names_pattern
[0] != 0 && !regex_check_dns_names
)
1352 regex_check_dns_names
=
1353 regex_must_compile(check_dns_names_pattern
, FALSE
, TRUE
);