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. */
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 */
45 uschar *aptr = answerptr; /* Locally modified */
48 /* Remove terminating dot. */
50 if (domain[len - 1] == '.') len--;
51 Ustrncpy(name, domain, len);
54 /* Look for the fakens utility, and if it exists, call it. */
56 (void)string_format(utilname, sizeof(utilname), "%s/bin/fakens",
57 config_main_directory);
59 if (stat(CS utilname, &statbuf) >= 0)
65 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) using fakens\n", name, dns_text_type(type));
68 argv[1] = config_main_directory;
70 argv[3] = dns_text_type(type);
73 pid = child_open(argv, NULL, 0000, &infd, &outfd, FALSE);
75 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to run fakens: %s",
80 while (asize > 0 && (rc = read(outfd, aptr, asize)) > 0)
83 aptr += rc; /* Don't modify the actual arguments, because they */
84 asize -= rc; /* may need to be passed on to res_search(). */
87 /* If we ran out of output buffer before exhausting the return,
88 carry on reading and counting it. */
91 while ((rc = read(outfd, name, sizeof(name))) > 0)
95 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "read from fakens failed: %s",
98 switch(child_close(pid, 0))
101 case 1: h_errno = HOST_NOT_FOUND; return -1;
102 case 2: h_errno = TRY_AGAIN; return -1;
104 case 3: h_errno = NO_RECOVERY; return -1;
105 case 4: h_errno = NO_DATA; return -1;
106 case 5: /* Pass on to res_search() */
107 DEBUG(D_dns) debug_printf("fakens returned PASS_ON\n");
112 DEBUG(D_dns) debug_printf("fakens (%s) not found\n", utilname);
115 /* fakens utility not found, or it returned "pass on" */
117 DEBUG(D_dns) debug_printf("passing %s on to res_search()\n", domain);
119 return res_search(CS domain, C_IN, type, answerptr, size);
124 /*************************************************
125 * Initialize and configure resolver *
126 *************************************************/
128 /* Initialize the resolver and the storage for holding DNS answers if this is
129 the first time we have been here, and set the resolver options.
132 qualify_single TRUE to set the RES_DEFNAMES option
133 search_parents TRUE to set the RES_DNSRCH option
134 use_dnssec TRUE to set the RES_USE_DNSSEC option
140 dns_init(BOOL qualify_single, BOOL search_parents, BOOL use_dnssec)
142 res_state resp = os_get_dns_resolver_res();
144 if ((resp->options & RES_INIT) == 0)
146 DEBUG(D_resolver) resp->options |= RES_DEBUG; /* For Cygwin */
147 os_put_dns_resolver_res(resp);
149 DEBUG(D_resolver) resp->options |= RES_DEBUG;
150 os_put_dns_resolver_res(resp);
153 resp->options &= ~(RES_DNSRCH | RES_DEFNAMES);
154 resp->options |= (qualify_single? RES_DEFNAMES : 0) |
155 (search_parents? RES_DNSRCH : 0);
156 if (dns_retrans > 0) resp->retrans = dns_retrans;
157 if (dns_retry > 0) resp->retry = dns_retry;
160 if (dns_use_edns0 >= 0)
163 resp->options |= RES_USE_EDNS0;
165 resp->options &= ~RES_USE_EDNS0;
167 debug_printf("Coerced resolver EDNS0 support %s.\n",
168 dns_use_edns0 ? "on" : "off");
171 if (dns_use_edns0 >= 0)
173 debug_printf("Unable to %sset EDNS0 without resolver support.\n",
174 dns_use_edns0 ? "" : "un");
177 #ifndef DISABLE_DNSSEC
178 # ifdef RES_USE_DNSSEC
179 # ifndef RES_USE_EDNS0
180 # error Have RES_USE_DNSSEC but not RES_USE_EDNS0? Something hinky ...
183 resp->options |= RES_USE_DNSSEC;
184 if (dns_dnssec_ok >= 0)
186 if (dns_use_edns0 == 0 && dns_dnssec_ok != 0)
189 debug_printf("CONFLICT: dns_use_edns0 forced false, dns_dnssec_ok forced true, ignoring latter!\n");
194 resp->options |= RES_USE_DNSSEC;
196 resp->options &= ~RES_USE_DNSSEC;
197 DEBUG(D_resolver) debug_printf("Coerced resolver DNSSEC support %s.\n",
198 dns_dnssec_ok ? "on" : "off");
202 if (dns_dnssec_ok >= 0)
204 debug_printf("Unable to %sset DNSSEC without resolver support.\n",
205 dns_dnssec_ok ? "" : "un");
208 debug_printf("Unable to set DNSSEC without resolver support.\n");
210 #endif /* DISABLE_DNSSEC */
212 os_put_dns_resolver_res(resp);
217 /*************************************************
218 * Build key name for PTR records *
219 *************************************************/
221 /* This function inverts an IP address and adds the relevant domain, to produce
222 a name that can be used to look up PTR records.
225 string the IP address as a string
226 buffer a suitable buffer, long enough to hold the result
232 dns_build_reverse(const uschar *string, uschar *buffer)
234 const uschar *p = string + Ustrlen(string);
237 /* Handle IPv4 address */
240 if (Ustrchr(string, ':') == NULL)
243 for (int i = 0; i < 4; i++)
245 const uschar *ppp = p;
246 while (ppp > string && ppp[-1] != '.') ppp--;
247 Ustrncpy(pp, ppp, p - ppp);
252 Ustrcpy(pp, "in-addr.arpa");
255 /* Handle IPv6 address; convert to binary so as to fill out any
256 abbreviation in the textual form. */
262 (void)host_aton(string, v6);
264 /* The original specification for IPv6 reverse lookup was to invert each
265 nibble, and look in the ip6.int domain. The domain was subsequently
266 changed to ip6.arpa. */
268 for (int i = 3; i >= 0; i--)
269 for (int j = 0; j < 32; j += 4)
270 pp += sprintf(CS pp, "%x.", (v6[i] >> j) & 15);
271 Ustrcpy(pp, "ip6.arpa.");
273 /* Another way of doing IPv6 reverse lookups was proposed in conjunction
274 with A6 records. However, it fell out of favour when they did. The
275 alternative was to construct a binary key, and look in ip6.arpa. I tried
276 to make this code do that, but I could not make it work on Solaris 8. The
277 resolver seems to lose the initial backslash somehow. However, now that
278 this style of reverse lookup has been dropped, it doesn't matter. These
279 lines are left here purely for historical interest. */
281 /**************************************************
285 for (int i = 0; i < 4; i++)
287 sprintf(pp, "%08X", v6[i]);
290 Ustrcpy(pp, "].ip6.arpa.");
291 **************************************************/
300 /* Increment the aptr in dnss, checking against dnsa length.
301 Return: TRUE for a bad result
304 dnss_inc_aptr(const dns_answer * dnsa, dns_scan * dnss, unsigned delta)
306 return (dnss->aptr += delta) >= dnsa->answer + dnsa->answerlen;
309 /*************************************************
310 * Get next DNS record from answer block *
311 *************************************************/
313 /* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
314 RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
315 scan the additional records, and reset == RESET_NEXT to get the next record.
316 The result is in static storage which must be copied if it is to be preserved.
319 dnsa pointer to dns answer block
320 dnss pointer to dns scan block
321 reset option specifying what portion to scan, as described above
323 Returns: next dns record, or NULL when no more
327 dns_next_rr(const dns_answer *dnsa, dns_scan *dnss, int reset)
329 const HEADER * h = (const HEADER *)dnsa->answer;
334 # define TRACE DEBUG(D_dns)
337 # define TRACE if (FALSE)
340 /* Reset the saved data when requested to, and skip to the first required RR */
342 if (reset != RESET_NEXT)
344 dnss->rrcount = ntohs(h->qdcount);
345 TRACE debug_printf("%s: reset (Q rrcount %d)\n", __FUNCTION__, dnss->rrcount);
346 dnss->aptr = dnsa->answer + sizeof(HEADER);
348 /* Skip over questions; failure to expand the name just gives up */
350 while (dnss->rrcount-- > 0)
352 TRACE trace = "Q-namelen";
353 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
354 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
355 if (namelen < 0) goto null_return;
356 /* skip name & type & class */
357 TRACE trace = "Q-skip";
358 if (dnss_inc_aptr(dnsa, dnss, namelen+4)) goto null_return;
361 /* Get the number of answer records. */
363 dnss->rrcount = ntohs(h->ancount);
364 TRACE debug_printf("%s: reset (A rrcount %d)\n", __FUNCTION__, dnss->rrcount);
366 /* Skip over answers if we want to look at the authority section. Also skip
367 the NS records (i.e. authority section) if wanting to look at the additional
370 if (reset == RESET_ADDITIONAL)
372 TRACE debug_printf("%s: additional\n", __FUNCTION__);
373 dnss->rrcount += ntohs(h->nscount);
374 TRACE debug_printf("%s: reset (NS rrcount %d)\n", __FUNCTION__, dnss->rrcount);
377 if (reset == RESET_AUTHORITY || reset == RESET_ADDITIONAL)
379 TRACE if (reset == RESET_AUTHORITY)
380 debug_printf("%s: authority\n", __FUNCTION__);
381 while (dnss->rrcount-- > 0)
383 TRACE trace = "A-namelen";
384 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
385 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
386 if (namelen < 0) goto null_return;
387 /* skip name, type, class & TTL */
388 TRACE trace = "A-hdr";
389 if (dnss_inc_aptr(dnsa, dnss, namelen+8)) goto null_return;
390 GETSHORT(dnss->srr.size, dnss->aptr); /* size of data portion */
392 TRACE trace = "A-skip";
393 if (dnss_inc_aptr(dnsa, dnss, dnss->srr.size)) goto null_return;
395 dnss->rrcount = reset == RESET_AUTHORITY
396 ? ntohs(h->nscount) : ntohs(h->arcount);
397 TRACE debug_printf("%s: reset (%s rrcount %d)\n", __FUNCTION__,
398 reset == RESET_AUTHORITY ? "NS" : "AR", dnss->rrcount);
400 TRACE debug_printf("%s: %d RRs to read\n", __FUNCTION__, dnss->rrcount);
403 TRACE debug_printf("%s: next (%d left)\n", __FUNCTION__, dnss->rrcount);
405 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
406 contains the number of RR records left. */
408 if (dnss->rrcount-- <= 0) return NULL;
410 /* If expanding the RR domain name fails, behave as if no more records
413 TRACE trace = "R-namelen";
414 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, dnss->aptr,
415 (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
416 if (namelen < 0) goto null_return;
418 /* Move the pointer past the name and fill in the rest of the data structure
419 from the following bytes. */
421 TRACE trace = "R-name";
422 if (dnss_inc_aptr(dnsa, dnss, namelen)) goto null_return;
424 GETSHORT(dnss->srr.type, dnss->aptr); /* Record type */
425 TRACE trace = "R-class";
426 if (dnss_inc_aptr(dnsa, dnss, 2)) goto null_return; /* Don't want class */
427 GETLONG(dnss->srr.ttl, dnss->aptr); /* TTL */
428 GETSHORT(dnss->srr.size, dnss->aptr); /* Size of data portion */
429 dnss->srr.data = dnss->aptr; /* The record's data follows */
431 /* Unchecked increment ok here since no further access on this iteration;
432 will be checked on next at "R-name". */
434 dnss->aptr += dnss->srr.size; /* Advance to next RR */
436 /* Return a pointer to the dns_record structure within the dns_answer. This is
437 for convenience so that the scans can use nice-looking for loops. */
442 TRACE debug_printf("%s: terminate (%d RRs left). Last op: %s; errno %d %s\n",
443 __FUNCTION__, dnss->rrcount, trace, errno, strerror(errno));
449 /* Extract the AUTHORITY information from the answer. If the answer isn't
450 authoritative (AA not set), we do not extract anything.
452 The AUTHORITY section contains NS records if the name in question was found,
453 it contains a SOA record otherwise. (This is just from experience and some
454 tests, is there some spec?)
456 Scan the whole AUTHORITY section, since it may contain other records
459 Return: name for the authority, in an allocated string, or NULL if none found */
461 static const uschar *
462 dns_extract_auth_name(const dns_answer * dnsa) /* FIXME: const dns_answer */
465 const HEADER * h = (const HEADER *) dnsa->answer;
467 if (h->nscount && h->aa)
468 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
469 rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
470 if (rr->type == (h->ancount ? T_NS : T_SOA))
471 return string_copy(rr->name);
478 /*************************************************
479 * Return whether AD bit set in DNS result *
480 *************************************************/
482 /* We do not perform DNSSEC work ourselves; if the administrator has installed
483 a verifying resolver which sets AD as appropriate, though, we'll use that.
484 (AD = Authentic Data, AA = Authoritative Answer)
486 Argument: pointer to dns answer block
487 Returns: bool indicating presence of AD bit
491 dns_is_secure(const dns_answer * dnsa)
493 #ifdef DISABLE_DNSSEC
495 debug_printf("DNSSEC support disabled at build-time; dns_is_secure() false\n");
498 const HEADER * h = (const HEADER *) dnsa->answer;
499 const uschar * auth_name;
500 const uschar * trusted;
502 if (h->ad) return TRUE;
504 /* If the resolver we ask is authoritative for the domain in question, it
505 * may not set the AD but the AA bit. If we explicitly trust
506 * the resolver for that domain (via a domainlist in dns_trust_aa),
507 * we return TRUE to indicate a secure answer.
512 || !(trusted = expand_string(dns_trust_aa))
514 || !(auth_name = dns_extract_auth_name(dnsa))
515 || OK != match_isinlist(auth_name, &trusted, 0, NULL, NULL,
516 MCL_DOMAIN, TRUE, NULL)
520 DEBUG(D_dns) debug_printf("DNS faked the AD bit "
521 "(got AA and matched with dns_trust_aa (%s in %s))\n",
522 auth_name, dns_trust_aa);
529 dns_set_insecure(dns_answer * dnsa)
531 #ifndef DISABLE_DNSSEC
532 HEADER * h = (HEADER *)dnsa->answer;
537 /************************************************
538 * Check whether the AA bit is set *
539 * We need this to warn if we requested AD *
540 * from an authoritative server *
541 ************************************************/
544 dns_is_aa(const dns_answer *dnsa)
546 #ifdef DISABLE_DNSSEC
549 return ((const HEADER*)dnsa->answer)->aa;
555 /*************************************************
556 * Turn DNS type into text *
557 *************************************************/
559 /* Turn the coded record type into a string for printing. All those that Exim
560 uses should be included here.
562 Argument: record type
563 Returns: pointer to string
571 case T_A: return US"A";
572 case T_MX: return US"MX";
573 case T_AAAA: return US"AAAA";
574 case T_A6: return US"A6";
575 case T_TXT: return US"TXT";
576 case T_SPF: return US"SPF";
577 case T_PTR: return US"PTR";
578 case T_SOA: return US"SOA";
579 case T_SRV: return US"SRV";
580 case T_NS: return US"NS";
581 case T_CNAME: return US"CNAME";
582 case T_TLSA: return US"TLSA";
583 default: return US"?";
589 /*************************************************
590 * Cache a failed DNS lookup result *
591 *************************************************/
594 dns_fail_tag(uschar * buf, const uschar * name, int dns_type)
596 res_state resp = os_get_dns_resolver_res();
597 sprintf(CS buf, "%.255s-%s-%lx", name, dns_text_type(dns_type),
598 (unsigned long) resp->options);
602 /* We cache failed lookup results so as not to experience timeouts many
603 times for the same domain. We need to retain the resolver options because they
604 may change. For successful lookups, we rely on resolver and/or name server
612 Returns: the return code
616 dns_return(const uschar * name, int type, int rc)
618 tree_node *node = store_get_perm(sizeof(tree_node) + 290);
619 dns_fail_tag(node->name, name, type);
621 (void)tree_insertnode(&tree_dns_fails, node);
625 /*************************************************
626 * Do basic DNS lookup *
627 *************************************************/
629 /* Call the resolver to look up the given domain name, using the given type,
630 and check the result. The error code TRY_AGAIN is documented as meaning "non-
631 Authoritative Host not found, or SERVERFAIL". Sometimes there are badly set
632 up nameservers that produce this error continually, so there is the option of
633 providing a list of domains for which this is treated as a non-existent
636 The dns_answer structure is pretty big; enough to hold a max-sized DNS message
637 - so best allocated from fast-release memory. As of writing, all our callers
638 use a stack-auto variable.
641 dnsa pointer to dns_answer structure
643 type type of DNS record required (T_A, T_MX, etc)
645 Returns: DNS_SUCCEED successful lookup
646 DNS_NOMATCH name not found (NXDOMAIN)
647 or name contains illegal characters (if checking)
648 or name is an IP address (for IP address lookup)
649 DNS_NODATA domain exists, but no data for this type (NODATA)
650 DNS_AGAIN soft failure, try again later
655 dns_basic_lookup(dns_answer *dnsa, const uschar *name, int type)
659 const uschar *save_domain;
663 uschar node_name[290];
665 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
666 a timeout on one domain doesn't happen time and time again for messages that
667 have many addresses in the same domain. We rely on the resolver and name server
668 caching for successful lookups. */
670 dns_fail_tag(node_name, name, type);
671 if ((previous = tree_search(tree_dns_fails, node_name)))
673 DEBUG(D_dns) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
674 name, dns_text_type(type),
675 previous->data.val == DNS_NOMATCH ? "DNS_NOMATCH" :
676 previous->data.val == DNS_NODATA ? "DNS_NODATA" :
677 previous->data.val == DNS_AGAIN ? "DNS_AGAIN" :
678 previous->data.val == DNS_FAIL ? "DNS_FAIL" : "??");
679 return previous->data.val;
683 /* Convert all names to a-label form before doing lookup */
686 uschar * errstr = NULL;
687 DEBUG(D_dns) if (string_is_utf8(name))
688 debug_printf("convert utf8 '%s' to alabel for for lookup\n", name);
689 if ((alabel = string_domain_utf8_to_alabel(name, &errstr)), errstr)
692 debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name,
694 f.host_find_failed_syntax = TRUE;
701 /* If configured, check the hygiene of the name passed to lookup. Otherwise,
702 although DNS lookups may give REFUSED at the lower level, some resolvers
703 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
704 domains cannot be in the DNS. The check is now done by a regular expression;
705 give it space for substring storage to save it having to get its own if the
706 regex has substrings that are used - the default uses a conditional.
708 This test is omitted for PTR records. These occur only in calls from the dnsdb
709 lookup, which constructs the names itself, so they should be OK. Besides,
710 bitstring labels don't conform to normal name syntax. (But the aren't used any
713 For SRV records, we omit the initial _smtp._tcp. components at the start. */
715 #ifndef STAND_ALONE /* Omit this for stand-alone tests */
717 if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
719 const uschar *checkname = name;
720 int ovector[3*(EXPAND_MAXN+1)];
724 /* For an SRV lookup, skip over the first two components (the service and
725 protocol names, which both start with an underscore). */
727 if (type == T_SRV || type == T_TLSA)
729 while (*checkname++ != '.');
730 while (*checkname++ != '.');
733 if (pcre_exec(regex_check_dns_names, NULL, CCS checkname, Ustrlen(checkname),
734 0, PCRE_EOPT, ovector, nelem(ovector)) < 0)
737 debug_printf("DNS name syntax check failed: %s (%s)\n", name,
738 dns_text_type(type));
739 f.host_find_failed_syntax = TRUE;
744 #endif /* STAND_ALONE */
746 /* Call the resolver; for an overlong response, res_search() will return the
747 number of bytes the message would need, so we need to check for this case. The
748 effect is to truncate overlong data.
750 On some systems, res_search() will recognize "A-for-A" queries and return
751 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
752 nameservers are also believed to do this. It is, of course, contrary to the
753 specification of the DNS, so we lock it out. */
755 if ((type == T_A || type == T_AAAA) && string_is_ip_address(name, NULL) != 0)
758 /* If we are running in the test harness, instead of calling the normal resolver
759 (res_search), we call fakens_search(), which recognizes certain special
760 domains, and interfaces to a fake nameserver for certain special zones. */
762 dnsa->answerlen = f.running_in_test_harness
763 ? fakens_search(name, type, dnsa->answer, sizeof(dnsa->answer))
764 : res_search(CCS name, C_IN, type, dnsa->answer, sizeof(dnsa->answer));
766 if (dnsa->answerlen > (int) sizeof(dnsa->answer))
768 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet"
769 " (size %d), truncating to %u.\n",
770 name, dns_text_type(type), dnsa->answerlen, (unsigned int) sizeof(dnsa->answer));
771 dnsa->answerlen = sizeof(dnsa->answer);
774 if (dnsa->answerlen < 0) switch (h_errno)
777 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
778 "returning DNS_NOMATCH\n", name, dns_text_type(type));
779 return dns_return(name, type, DNS_NOMATCH);
782 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
783 name, dns_text_type(type));
785 /* Cut this out for various test programs */
787 save_domain = deliver_domain;
788 deliver_domain = string_copy(name); /* set $domain */
789 rc = match_isinlist(name, (const uschar **)&dns_again_means_nonexist, 0, NULL, NULL,
790 MCL_DOMAIN, TRUE, NULL);
791 deliver_domain = save_domain;
794 DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
795 return dns_return(name, type, DNS_AGAIN);
797 DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
798 "DNS_NOMATCH\n", name);
799 return dns_return(name, type, DNS_NOMATCH);
801 #else /* For stand-alone tests */
802 return dns_return(name, type, DNS_AGAIN);
806 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
807 "returning DNS_FAIL\n", name, dns_text_type(type));
808 return dns_return(name, type, DNS_FAIL);
811 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
812 "returning DNS_NODATA\n", name, dns_text_type(type));
813 return dns_return(name, type, DNS_NODATA);
816 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
817 "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
818 return dns_return(name, type, DNS_FAIL);
821 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
822 name, dns_text_type(type));
830 /************************************************
831 * Do a DNS lookup and handle CNAMES *
832 ************************************************/
834 /* Look up the given domain name, using the given type. Follow CNAMEs if
835 necessary, but only so many times. There aren't supposed to be CNAME chains in
836 the DNS, but you are supposed to cope with them if you find them.
837 By default, follow one CNAME since a resolver has been seen, faced with
838 an MX request and a CNAME (to an A) but no MX present, returning the CNAME.
840 The assumption is made that if the resolver gives back records of the
841 requested type *and* a CNAME, we don't need to make another call to look up
842 the CNAME. I can't see how it could return only some of the right records. If
843 it's done a CNAME lookup in the past, it will have all of them; if not, it
846 If fully_qualified_name is not NULL, set it to point to the full name
847 returned by the resolver, if this is different to what it is given, unless
848 the returned name starts with "*" as some nameservers seem to be returning
849 wildcards in this form. In international mode "different" means "alabel
850 forms are different".
853 dnsa pointer to dns_answer structure
854 name domain name to look up
855 type DNS record type (T_A, T_MX, etc)
856 fully_qualified_name if not NULL, return the returned name here if its
857 contents are different (i.e. it must be preset)
859 Returns: DNS_SUCCEED successful lookup
860 DNS_NOMATCH name not found
861 DNS_NODATA no data found
862 DNS_AGAIN soft failure, try again later
867 dns_lookup(dns_answer *dnsa, const uschar *name, int type,
868 const uschar **fully_qualified_name)
870 const uschar *orig_name = name;
871 BOOL secure_so_far = TRUE;
873 /* By default, assume the resolver follows CNAME chains (and returns NODATA for
874 an unterminated one). If it also does that for a CNAME loop, fine; if it returns
875 a CNAME (maybe the last?) whine about it. However, retain the coding for dumb
876 resolvers hiding behind a config variable. Loop to follow CNAME chains so far,
877 but no further... The testsuite tests the latter case, mostly assuming that the
880 for (int i = 0; i <= dns_cname_loops; i++)
883 dns_record cname_rr, type_rr;
887 /* DNS lookup failures get passed straight back. */
889 if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED)
892 /* We should have either records of the required type, or a CNAME record,
893 or both. We need to know whether both exist for getting the fully qualified
894 name, but avoid scanning more than necessary. Note that we must copy the
895 contents of any rr blocks returned by dns_next_rr() as they use the same
896 area in the dnsa block. */
898 cname_rr.data = type_rr.data = NULL;
899 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
900 rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
901 if (rr->type == type)
903 if (type_rr.data == NULL) type_rr = *rr;
904 if (cname_rr.data != NULL) break;
906 else if (rr->type == T_CNAME)
909 /* For the first time round this loop, if a CNAME was found, take the fully
910 qualified name from it; otherwise from the first data record, if present. */
912 if (i == 0 && fully_qualified_name)
914 uschar * rr_name = cname_rr.data
915 ? cname_rr.name : type_rr.data ? type_rr.name : NULL;
917 && Ustrcmp(rr_name, *fully_qualified_name) != 0
920 && ( !string_is_utf8(*fully_qualified_name)
922 string_domain_utf8_to_alabel(*fully_qualified_name, NULL)) != 0
926 *fully_qualified_name = string_copy_dnsdomain(rr_name);
929 /* If any data records of the correct type were found, we are done. */
933 if (!secure_so_far) /* mark insecure if any element of CNAME chain was */
934 dns_set_insecure(dnsa);
938 /* If there are no data records, we need to re-scan the DNS using the
939 domain given in the CNAME record, which should exist (otherwise we should
940 have had a failure from dns_lookup). However code against the possibility of
946 data = store_get(256);
947 if (dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
948 cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, 256) < 0)
952 if (!dns_is_secure(dnsa))
953 secure_so_far = FALSE;
955 DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
956 } /* Loop back to do another lookup */
958 /*Control reaches here after 10 times round the CNAME loop. Something isn't
961 log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
970 /************************************************
971 * Do a DNS lookup and handle virtual types *
972 ************************************************/
974 /* This function handles some invented "lookup types" that synthesize features
975 not available in the basic types. The special types all have negative values.
976 Positive type values are passed straight on to dns_lookup().
979 dnsa pointer to dns_answer structure
980 name domain name to look up
981 type DNS record type (T_A, T_MX, etc or a "special")
982 fully_qualified_name if not NULL, return the returned name here if its
983 contents are different (i.e. it must be preset)
985 Returns: DNS_SUCCEED successful lookup
986 DNS_NOMATCH name not found
987 DNS_NODATA no data found
988 DNS_AGAIN soft failure, try again later
993 dns_special_lookup(dns_answer *dnsa, const uschar *name, int type,
994 const uschar **fully_qualified_name)
998 /* The "mx hosts only" type doesn't require any special action here */
1000 return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
1002 /* Find nameservers for the domain or the nearest enclosing zone, excluding
1003 the root servers. */
1009 const uschar *d = name;
1012 int rc = dns_lookup(dnsa, d, type, fully_qualified_name);
1013 if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
1014 while (*d != 0 && *d != '.') d++;
1015 if (*d++ == 0) break;
1020 /* Try to look up the Client SMTP Authorization SRV record for the name. If
1021 there isn't one, search from the top downwards for a CSA record in a parent
1022 domain, which might be making assertions about subdomains. If we find a record
1023 we set fully_qualified_name to whichever lookup succeeded, so that the caller
1024 can tell whether to look at the explicit authorization field or the subdomain
1028 uschar *srvname, *namesuff, *tld;
1029 int priority, weight, port;
1035 DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
1037 srvname = string_sprintf("_client._smtp.%s", name);
1038 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1039 if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
1041 if (rc == DNS_SUCCEED) *fully_qualified_name = string_copy(name);
1045 /* Search for CSA subdomain assertion SRV records from the top downwards,
1046 starting with the 2nd level domain. This order maximizes cache-friendliness.
1047 We skip the top level domains to avoid loading their nameservers and because
1048 we know they'll never have CSA SRV records. */
1050 namesuff = Ustrrchr(name, '.');
1051 if (namesuff == NULL) return DNS_NOMATCH;
1054 limit = dns_csa_search_limit;
1056 /* Use more appropriate search parameters if we are in the reverse DNS. */
1058 if (strcmpic(namesuff, US".arpa") == 0)
1059 if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
1065 else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
1073 DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
1075 /* Do not perform the search if the top level or 2nd level domains do not
1076 exist. This is quite common, and when it occurs all the search queries would
1077 go to the root or TLD name servers, which is not friendly. So we check the
1078 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
1079 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
1080 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
1081 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
1083 if (rc == DNS_NOMATCH)
1085 /* This is really gross. The successful return value from res_search() is
1086 the packet length, which is stored in dnsa->answerlen. If we get a
1087 negative DNS reply then res_search() returns -1, which causes the bounds
1088 checks for name decompression to fail when it is treated as a packet
1089 length, which in turn causes the authority search to fail. The correct
1090 packet length has been lost inside libresolv, so we have to guess a
1091 replacement value. (The only way to fix this properly would be to
1092 re-implement res_search() and res_query() so that they don't muddle their
1093 success and packet length return values.) For added safety we only reset
1094 the packet length if the packet header looks plausible. */
1096 const HEADER * h = (const HEADER *)dnsa->answer;
1097 if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
1098 && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
1099 && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
1100 && ntohs(h->nscount) >= 1)
1101 dnsa->answerlen = sizeof(dnsa->answer);
1103 for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
1104 rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
1106 if (rr->type != T_SOA) continue;
1107 else if (strcmpic(rr->name, US"") == 0 ||
1108 strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
1112 for (i = 0; i < limit; i++)
1116 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1117 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1119 if (namesuff <= name) return DNS_NOMATCH;
1122 /* Find the start of the preceding domain name label. */
1124 if (--namesuff <= name) return DNS_NOMATCH;
1125 while (*namesuff != '.');
1127 DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
1129 srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
1130 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1131 if (rc == DNS_AGAIN) return rc;
1132 if (rc != DNS_SUCCEED) continue;
1134 /* Check that the SRV record we have found is worth returning. We don't
1135 just return the first one we find, because some lower level SRV record
1136 might make stricter assertions than its parent domain. */
1138 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1139 rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == T_SRV)
1141 const uschar * p = rr->data;
1143 /* Extract the numerical SRV fields (p is incremented) */
1144 GETSHORT(priority, p);
1145 GETSHORT(weight, p); weight = weight; /* compiler quietening */
1148 /* Check the CSA version number */
1149 if (priority != 1) continue;
1151 /* If it's making an interesting assertion, return this response. */
1154 *fully_qualified_name = namesuff + 1;
1164 return dns_lookup(dnsa, name, type, fully_qualified_name);
1167 /* Control should never reach here */
1176 /*************************************************
1177 * Get address(es) from DNS record *
1178 *************************************************/
1180 /* The record type is either T_A for an IPv4 address or T_AAAA for an IPv6 address.
1183 dnsa the DNS answer block
1186 Returns: pointer to a chain of dns_address items; NULL when the dnsa was overrun
1190 dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1192 dns_address * yield = NULL;
1193 uschar * dnsa_lim = dnsa->answer + dnsa->answerlen;
1195 if (rr->type == T_A)
1197 uschar *p = US rr->data;
1198 if (p + 4 <= dnsa_lim)
1200 yield = store_get(sizeof(dns_address) + 20);
1201 (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1210 if (rr->data + 16 <= dnsa_lim)
1212 struct in6_addr in6;
1213 for (int i = 0; i < 16; i++) in6.s6_addr[i] = rr->data[i];
1214 yield = store_get(sizeof(dns_address) + 50);
1215 inet_ntop(AF_INET6, &in6, CS yield->address, 50);
1219 #endif /* HAVE_IPV6 */
1227 dns_pattern_init(void)
1229 if (check_dns_names_pattern[0] != 0 && !regex_check_dns_names)
1230 regex_check_dns_names =
1231 regex_must_compile(check_dns_names_pattern, FALSE, TRUE);