1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions for interfacing with the DNS. */
14 /*************************************************
16 *************************************************/
18 /* This function is called instead of res_search() when Exim is running in its
19 test harness. It recognizes some special domain names, and uses them to force
20 failure and retry responses (optionally with a delay). Otherwise, it calls an
21 external utility that mocks-up a nameserver, if it can find the utility.
22 If not, it passes its arguments on to res_search(). The fake nameserver may
23 also return a code specifying that the name should be passed on.
25 Background: the original test suite required a real nameserver to carry the
26 test zones, whereas the new test suite has the fake server for portability. This
30 domain the domain name
31 type the DNS record type
32 answerptr where to put the answer
33 size size of the answer area
35 Returns: length of returned data, or -1 on error (h_errno set)
39 fakens_search(const uschar *domain, int type, uschar *answerptr, int size)
41 int len = Ustrlen(domain);
42 int asize = size; /* Locally modified */
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)
244 for (i = 0; i < 4; i++)
246 const uschar *ppp = p;
247 while (ppp > string && ppp[-1] != '.') ppp--;
248 Ustrncpy(pp, ppp, p - ppp);
253 Ustrcpy(pp, "in-addr.arpa");
256 /* Handle IPv6 address; convert to binary so as to fill out any
257 abbreviation in the textual form. */
264 (void)host_aton(string, v6);
266 /* The original specification for IPv6 reverse lookup was to invert each
267 nibble, and look in the ip6.int domain. The domain was subsequently
268 changed to ip6.arpa. */
270 for (i = 3; i >= 0; i--)
273 for (j = 0; j < 32; j += 4)
275 sprintf(CS pp, "%x.", (v6[i] >> j) & 15);
279 Ustrcpy(pp, "ip6.arpa.");
281 /* Another way of doing IPv6 reverse lookups was proposed in conjunction
282 with A6 records. However, it fell out of favour when they did. The
283 alternative was to construct a binary key, and look in ip6.arpa. I tried
284 to make this code do that, but I could not make it work on Solaris 8. The
285 resolver seems to lose the initial backslash somehow. However, now that
286 this style of reverse lookup has been dropped, it doesn't matter. These
287 lines are left here purely for historical interest. */
289 /**************************************************
293 for (i = 0; i < 4; i++)
295 sprintf(pp, "%08X", v6[i]);
298 Ustrcpy(pp, "].ip6.arpa.");
299 **************************************************/
308 /*************************************************
309 * Get next DNS record from answer block *
310 *************************************************/
312 /* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
313 RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
314 scan the additional records, and reset == RESET_NEXT to get the next record.
315 The result is in static storage which must be copied if it is to be preserved.
318 dnsa pointer to dns answer block
319 dnss pointer to dns scan block
320 reset option specifing what portion to scan, as described above
322 Returns: next dns record, or NULL when no more
326 dns_next_rr(dns_answer *dnsa, dns_scan *dnss, int reset)
328 HEADER *h = (HEADER *)dnsa->answer;
331 /* Reset the saved data when requested to, and skip to the first required RR */
333 if (reset != RESET_NEXT)
335 dnss->rrcount = ntohs(h->qdcount);
336 dnss->aptr = dnsa->answer + sizeof(HEADER);
338 /* Skip over questions; failure to expand the name just gives up */
340 while (dnss->rrcount-- > 0)
342 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
343 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
344 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
345 dnss->aptr += namelen + 4; /* skip name & type & class */
348 /* Get the number of answer records. */
350 dnss->rrcount = ntohs(h->ancount);
352 /* Skip over answers if we want to look at the authority section. Also skip
353 the NS records (i.e. authority section) if wanting to look at the additional
356 if (reset == RESET_ADDITIONAL) dnss->rrcount += ntohs(h->nscount);
358 if (reset == RESET_AUTHORITY || reset == RESET_ADDITIONAL)
360 while (dnss->rrcount-- > 0)
362 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
363 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
364 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
365 dnss->aptr += namelen + 8; /* skip name, type, class & TTL */
366 GETSHORT(dnss->srr.size, dnss->aptr); /* size of data portion */
367 dnss->aptr += dnss->srr.size; /* skip over it */
369 dnss->rrcount = (reset == RESET_AUTHORITY)
370 ? ntohs(h->nscount) : ntohs(h->arcount);
374 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
375 contains the number of RR records left. */
377 if (dnss->rrcount-- <= 0) return NULL;
379 /* If expanding the RR domain name fails, behave as if no more records
382 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, dnss->aptr,
383 (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
384 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
386 /* Move the pointer past the name and fill in the rest of the data structure
387 from the following bytes. */
389 dnss->aptr += namelen;
390 GETSHORT(dnss->srr.type, dnss->aptr); /* Record type */
391 dnss->aptr += 2; /* Don't want class */
392 GETLONG(dnss->srr.ttl, dnss->aptr); /* TTL */
393 GETSHORT(dnss->srr.size, dnss->aptr); /* Size of data portion */
394 dnss->srr.data = dnss->aptr; /* The record's data follows */
395 dnss->aptr += dnss->srr.size; /* Advance to next RR */
397 /* Return a pointer to the dns_record structure within the dns_answer. This is
398 for convenience so that the scans can use nice-looking for loops. */
404 /* Extract the AUTHORITY information from the answer. If the
405 answer isn't authoritive (AA not set), we do not extract anything.
407 The AUTHORITIVE section contains NS records if
408 the name in question was found, it contains a SOA record
409 otherwise. (This is just from experience and some tests, is there
412 We've cycle through the AUTHORITY section, since it may contain
413 other records (e.g. NSEC3) too. */
415 static const uschar *
416 dns_extract_auth_name(const dns_answer * dnsa) /* FIXME: const dns_answer */
420 HEADER * h = (HEADER *) dnsa->answer;
422 if (!h->nscount || !h->aa) return NULL;
423 for (rr = dns_next_rr((dns_answer*) dnsa, &dnss, RESET_AUTHORITY);
425 rr = dns_next_rr((dns_answer*) dnsa, &dnss, RESET_NEXT))
426 if (rr->type == (h->ancount ? T_NS : T_SOA)) return rr->name;
433 /*************************************************
434 * Return whether AD bit set in DNS result *
435 *************************************************/
437 /* We do not perform DNSSEC work ourselves; if the administrator has installed
438 a verifying resolver which sets AD as appropriate, though, we'll use that.
439 (AD = Authentic Data, AA = Authoritive Answer)
441 Argument: pointer to dns answer block
442 Returns: bool indicating presence of AD bit
446 dns_is_secure(const dns_answer * dnsa)
448 #ifdef DISABLE_DNSSEC
450 debug_printf("DNSSEC support disabled at build-time; dns_is_secure() false\n");
453 HEADER * h = (HEADER *) dnsa->answer;
454 const uschar * auth_name;
455 const uschar * trusted;
457 if (h->ad) return TRUE;
459 /* If the resolver we ask is authoritive for the domain in question, it
460 * may not set the AD but the AA bit. If we explicitly trust
461 * the resolver for that domain (via a domainlist in dns_trust_aa),
462 * we return TRUE to indicate a secure answer.
467 || !(trusted = expand_string(dns_trust_aa))
469 || !(auth_name = dns_extract_auth_name(dnsa))
470 || OK != match_isinlist(auth_name, &trusted, 0, NULL, NULL,
471 MCL_DOMAIN, TRUE, NULL)
475 DEBUG(D_dns) debug_printf("DNS faked the AD bit "
476 "(got AA and matched with dns_trust_aa (%s in %s))\n",
477 auth_name, dns_trust_aa);
484 dns_set_insecure(dns_answer * dnsa)
486 #ifndef DISABLE_DNSSEC
487 HEADER * h = (HEADER *)dnsa->answer;
492 /************************************************
493 * Check whether the AA bit is set *
494 * We need this to warn if we requested AD *
495 * from an authoritive server *
496 ************************************************/
499 dns_is_aa(const dns_answer *dnsa)
501 #ifdef DISABLE_DNSSEC
504 return ((HEADER*)dnsa->answer)->aa;
510 /*************************************************
511 * Turn DNS type into text *
512 *************************************************/
514 /* Turn the coded record type into a string for printing. All those that Exim
515 uses should be included here.
517 Argument: record type
518 Returns: pointer to string
526 case T_A: return US"A";
527 case T_MX: return US"MX";
528 case T_AAAA: return US"AAAA";
529 case T_A6: return US"A6";
530 case T_TXT: return US"TXT";
531 case T_SPF: return US"SPF";
532 case T_PTR: return US"PTR";
533 case T_SOA: return US"SOA";
534 case T_SRV: return US"SRV";
535 case T_NS: return US"NS";
536 case T_CNAME: return US"CNAME";
537 case T_TLSA: return US"TLSA";
538 default: return US"?";
544 /*************************************************
545 * Cache a failed DNS lookup result *
546 *************************************************/
548 /* We cache failed lookup results so as not to experience timeouts many
549 times for the same domain. We need to retain the resolver options because they
550 may change. For successful lookups, we rely on resolver and/or name server
558 Returns: the return code
562 dns_return(const uschar * name, int type, int rc)
564 res_state resp = os_get_dns_resolver_res();
565 tree_node *node = store_get_perm(sizeof(tree_node) + 290);
566 sprintf(CS node->name, "%.255s-%s-%lx", name, dns_text_type(type),
567 (unsigned long) resp->options);
569 (void)tree_insertnode(&tree_dns_fails, node);
573 /*************************************************
574 * Do basic DNS lookup *
575 *************************************************/
577 /* Call the resolver to look up the given domain name, using the given type,
578 and check the result. The error code TRY_AGAIN is documented as meaning "non-
579 Authoritive Host not found, or SERVERFAIL". Sometimes there are badly set
580 up nameservers that produce this error continually, so there is the option of
581 providing a list of domains for which this is treated as a non-existent
585 dnsa pointer to dns_answer structure
587 type type of DNS record required (T_A, T_MX, etc)
589 Returns: DNS_SUCCEED successful lookup
590 DNS_NOMATCH name not found (NXDOMAIN)
591 or name contains illegal characters (if checking)
592 or name is an IP address (for IP address lookup)
593 DNS_NODATA domain exists, but no data for this type (NODATA)
594 DNS_AGAIN soft failure, try again later
599 dns_basic_lookup(dns_answer *dnsa, const uschar *name, int type)
603 const uschar *save_domain;
605 res_state resp = os_get_dns_resolver_res();
608 uschar node_name[290];
610 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
611 a timeout on one domain doesn't happen time and time again for messages that
612 have many addresses in the same domain. We rely on the resolver and name server
613 caching for successful lookups. */
615 sprintf(CS node_name, "%.255s-%s-%lx", name, dns_text_type(type),
616 (unsigned long) resp->options);
617 previous = tree_search(tree_dns_fails, node_name);
618 if (previous != NULL)
620 DEBUG(D_dns) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
621 name, dns_text_type(type),
622 (previous->data.val == DNS_NOMATCH)? "DNS_NOMATCH" :
623 (previous->data.val == DNS_NODATA)? "DNS_NODATA" :
624 (previous->data.val == DNS_AGAIN)? "DNS_AGAIN" :
625 (previous->data.val == DNS_FAIL)? "DNS_FAIL" : "??");
626 return previous->data.val;
630 /* Convert all names to a-label form before doing lookup */
633 uschar * errstr = NULL;
634 DEBUG(D_dns) if (string_is_utf8(name))
635 debug_printf("convert utf8 '%s' to alabel for for lookup\n", name);
636 if ((alabel = string_domain_utf8_to_alabel(name, &errstr)), errstr)
639 debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name,
641 host_find_failed_syntax = TRUE;
648 /* If configured, check the hygene of the name passed to lookup. Otherwise,
649 although DNS lookups may give REFUSED at the lower level, some resolvers
650 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
651 domains cannot be in the DNS. The check is now done by a regular expression;
652 give it space for substring storage to save it having to get its own if the
653 regex has substrings that are used - the default uses a conditional.
655 This test is omitted for PTR records. These occur only in calls from the dnsdb
656 lookup, which constructs the names itself, so they should be OK. Besides,
657 bitstring labels don't conform to normal name syntax. (But the aren't used any
660 For SRV records, we omit the initial _smtp._tcp. components at the start. */
662 #ifndef STAND_ALONE /* Omit this for stand-alone tests */
664 if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
666 const uschar *checkname = name;
667 int ovector[3*(EXPAND_MAXN+1)];
671 /* For an SRV lookup, skip over the first two components (the service and
672 protocol names, which both start with an underscore). */
674 if (type == T_SRV || type == T_TLSA)
676 while (*checkname++ != '.');
677 while (*checkname++ != '.');
680 if (pcre_exec(regex_check_dns_names, NULL, CCS checkname, Ustrlen(checkname),
681 0, PCRE_EOPT, ovector, sizeof(ovector)/sizeof(int)) < 0)
684 debug_printf("DNS name syntax check failed: %s (%s)\n", name,
685 dns_text_type(type));
686 host_find_failed_syntax = TRUE;
691 #endif /* STAND_ALONE */
693 /* Call the resolver; for an overlong response, res_search() will return the
694 number of bytes the message would need, so we need to check for this case. The
695 effect is to truncate overlong data.
697 On some systems, res_search() will recognize "A-for-A" queries and return
698 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
699 nameservers are also believed to do this. It is, of course, contrary to the
700 specification of the DNS, so we lock it out. */
702 if ((type == T_A || type == T_AAAA) && string_is_ip_address(name, NULL) != 0)
705 /* If we are running in the test harness, instead of calling the normal resolver
706 (res_search), we call fakens_search(), which recognizes certain special
707 domains, and interfaces to a fake nameserver for certain special zones. */
709 dnsa->answerlen = running_in_test_harness
710 ? fakens_search(name, type, dnsa->answer, MAXPACKET)
711 : res_search(CCS name, C_IN, type, dnsa->answer, MAXPACKET);
713 if (dnsa->answerlen > MAXPACKET)
715 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet (size %d), truncating to %d.\n",
716 name, dns_text_type(type), dnsa->answerlen, MAXPACKET);
717 dnsa->answerlen = MAXPACKET;
720 if (dnsa->answerlen < 0) switch (h_errno)
723 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
724 "returning DNS_NOMATCH\n", name, dns_text_type(type));
725 return dns_return(name, type, DNS_NOMATCH);
728 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
729 name, dns_text_type(type));
731 /* Cut this out for various test programs */
733 save_domain = deliver_domain;
734 deliver_domain = string_copy(name); /* set $domain */
735 rc = match_isinlist(name, (const uschar **)&dns_again_means_nonexist, 0, NULL, NULL,
736 MCL_DOMAIN, TRUE, NULL);
737 deliver_domain = save_domain;
740 DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
741 return dns_return(name, type, DNS_AGAIN);
743 DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
744 "DNS_NOMATCH\n", name);
745 return dns_return(name, type, DNS_NOMATCH);
747 #else /* For stand-alone tests */
748 return dns_return(name, type, DNS_AGAIN);
752 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
753 "returning DNS_FAIL\n", name, dns_text_type(type));
754 return dns_return(name, type, DNS_FAIL);
757 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
758 "returning DNS_NODATA\n", name, dns_text_type(type));
759 return dns_return(name, type, DNS_NODATA);
762 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
763 "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
764 return dns_return(name, type, DNS_FAIL);
767 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
768 name, dns_text_type(type));
776 /************************************************
777 * Do a DNS lookup and handle CNAMES *
778 ************************************************/
780 /* Look up the given domain name, using the given type. Follow CNAMEs if
781 necessary, but only so many times. There aren't supposed to be CNAME chains in
782 the DNS, but you are supposed to cope with them if you find them.
784 The assumption is made that if the resolver gives back records of the
785 requested type *and* a CNAME, we don't need to make another call to look up
786 the CNAME. I can't see how it could return only some of the right records. If
787 it's done a CNAME lookup in the past, it will have all of them; if not, it
790 If fully_qualified_name is not NULL, set it to point to the full name
791 returned by the resolver, if this is different to what it is given, unless
792 the returned name starts with "*" as some nameservers seem to be returning
793 wildcards in this form. In international mode "different" means "alabel
794 forms are different".
797 dnsa pointer to dns_answer structure
798 name domain name to look up
799 type DNS record type (T_A, T_MX, etc)
800 fully_qualified_name if not NULL, return the returned name here if its
801 contents are different (i.e. it must be preset)
803 Returns: DNS_SUCCEED successful lookup
804 DNS_NOMATCH name not found
805 DNS_NODATA no data found
806 DNS_AGAIN soft failure, try again later
811 dns_lookup(dns_answer *dnsa, const uschar *name, int type,
812 const uschar **fully_qualified_name)
815 const uschar *orig_name = name;
816 BOOL secure_so_far = TRUE;
818 /* Loop to follow CNAME chains so far, but no further... */
820 for (i = 0; i < 10; i++)
823 dns_record *rr, cname_rr, type_rr;
827 /* DNS lookup failures get passed straight back. */
829 if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED) return rc;
831 /* We should have either records of the required type, or a CNAME record,
832 or both. We need to know whether both exist for getting the fully qualified
833 name, but avoid scanning more than necessary. Note that we must copy the
834 contents of any rr blocks returned by dns_next_rr() as they use the same
835 area in the dnsa block. */
837 cname_rr.data = type_rr.data = NULL;
838 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
840 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
842 if (rr->type == type)
844 if (type_rr.data == NULL) type_rr = *rr;
845 if (cname_rr.data != NULL) break;
847 else if (rr->type == T_CNAME) cname_rr = *rr;
850 /* For the first time round this loop, if a CNAME was found, take the fully
851 qualified name from it; otherwise from the first data record, if present. */
853 if (i == 0 && fully_qualified_name != NULL)
855 uschar * rr_name = cname_rr.data ? cname_rr.name
856 : type_rr.data ? type_rr.name : NULL;
858 && Ustrcmp(rr_name, *fully_qualified_name) != 0
861 && ( !string_is_utf8(*fully_qualified_name)
863 string_domain_utf8_to_alabel(*fully_qualified_name, NULL)) != 0
867 *fully_qualified_name = string_copy_dnsdomain(rr_name);
870 /* If any data records of the correct type were found, we are done. */
872 if (type_rr.data != NULL)
874 if (!secure_so_far) /* mark insecure if any element of CNAME chain was */
875 dns_set_insecure(dnsa);
879 /* If there are no data records, we need to re-scan the DNS using the
880 domain given in the CNAME record, which should exist (otherwise we should
881 have had a failure from dns_lookup). However code against the possibility of
884 if (cname_rr.data == NULL) return DNS_FAIL;
885 datalen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
886 cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
887 if (datalen < 0) return DNS_FAIL;
890 if (!dns_is_secure(dnsa))
891 secure_so_far = FALSE;
893 DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
894 } /* Loop back to do another lookup */
896 /*Control reaches here after 10 times round the CNAME loop. Something isn't
899 log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
908 /************************************************
909 * Do a DNS lookup and handle virtual types *
910 ************************************************/
912 /* This function handles some invented "lookup types" that synthesize features
913 not available in the basic types. The special types all have negative values.
914 Positive type values are passed straight on to dns_lookup().
917 dnsa pointer to dns_answer structure
918 name domain name to look up
919 type DNS record type (T_A, T_MX, etc or a "special")
920 fully_qualified_name if not NULL, return the returned name here if its
921 contents are different (i.e. it must be preset)
923 Returns: DNS_SUCCEED successful lookup
924 DNS_NOMATCH name not found
925 DNS_NODATA no data found
926 DNS_AGAIN soft failure, try again later
931 dns_special_lookup(dns_answer *dnsa, const uschar *name, int type,
932 const uschar **fully_qualified_name)
936 /* The "mx hosts only" type doesn't require any special action here */
938 return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
940 /* Find nameservers for the domain or the nearest enclosing zone, excluding
947 const uschar *d = name;
950 int rc = dns_lookup(dnsa, d, type, fully_qualified_name);
951 if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
952 while (*d != 0 && *d != '.') d++;
953 if (*d++ == 0) break;
958 /* Try to look up the Client SMTP Authorization SRV record for the name. If
959 there isn't one, search from the top downwards for a CSA record in a parent
960 domain, which might be making assertions about subdomains. If we find a record
961 we set fully_qualified_name to whichever lookup succeeded, so that the caller
962 can tell whether to look at the explicit authorization field or the subdomain
966 uschar *srvname, *namesuff, *tld, *p;
967 int priority, weight, port;
973 DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
975 srvname = string_sprintf("_client._smtp.%s", name);
976 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
977 if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
979 if (rc == DNS_SUCCEED) *fully_qualified_name = string_copy(name);
983 /* Search for CSA subdomain assertion SRV records from the top downwards,
984 starting with the 2nd level domain. This order maximizes cache-friendliness.
985 We skip the top level domains to avoid loading their nameservers and because
986 we know they'll never have CSA SRV records. */
988 namesuff = Ustrrchr(name, '.');
989 if (namesuff == NULL) return DNS_NOMATCH;
992 limit = dns_csa_search_limit;
994 /* Use more appropriate search parameters if we are in the reverse DNS. */
996 if (strcmpic(namesuff, US".arpa") == 0)
997 if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
1003 else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
1011 DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
1013 /* Do not perform the search if the top level or 2nd level domains do not
1014 exist. This is quite common, and when it occurs all the search queries would
1015 go to the root or TLD name servers, which is not friendly. So we check the
1016 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
1017 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
1018 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
1019 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
1021 if (rc == DNS_NOMATCH)
1023 /* This is really gross. The successful return value from res_search() is
1024 the packet length, which is stored in dnsa->answerlen. If we get a
1025 negative DNS reply then res_search() returns -1, which causes the bounds
1026 checks for name decompression to fail when it is treated as a packet
1027 length, which in turn causes the authority search to fail. The correct
1028 packet length has been lost inside libresolv, so we have to guess a
1029 replacement value. (The only way to fix this properly would be to
1030 re-implement res_search() and res_query() so that they don't muddle their
1031 success and packet length return values.) For added safety we only reset
1032 the packet length if the packet header looks plausible. */
1034 HEADER *h = (HEADER *)dnsa->answer;
1035 if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
1036 && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
1037 && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
1038 && ntohs(h->nscount) >= 1)
1039 dnsa->answerlen = MAXPACKET;
1041 for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
1043 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
1045 if (rr->type != T_SOA) continue;
1046 else if (strcmpic(rr->name, US"") == 0 ||
1047 strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
1051 for (i = 0; i < limit; i++)
1055 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1056 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1058 if (namesuff <= name) return DNS_NOMATCH;
1061 /* Find the start of the preceding domain name label. */
1063 if (--namesuff <= name) return DNS_NOMATCH;
1064 while (*namesuff != '.');
1066 DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
1068 srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
1069 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1070 if (rc == DNS_AGAIN) return rc;
1071 if (rc != DNS_SUCCEED) continue;
1073 /* Check that the SRV record we have found is worth returning. We don't
1074 just return the first one we find, because some lower level SRV record
1075 might make stricter assertions than its parent domain. */
1077 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1079 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1081 if (rr->type != T_SRV) continue;
1083 /* Extract the numerical SRV fields (p is incremented) */
1085 GETSHORT(priority, p);
1086 GETSHORT(weight, p); weight = weight; /* compiler quietening */
1089 /* Check the CSA version number */
1090 if (priority != 1) continue;
1092 /* If it's making an interesting assertion, return this response. */
1095 *fully_qualified_name = namesuff + 1;
1105 return dns_lookup(dnsa, name, type, fully_qualified_name);
1108 /* Control should never reach here */
1117 /*************************************************
1118 * Get address(es) from DNS record *
1119 *************************************************/
1121 /* The record type is either T_A for an IPv4 address or T_AAAA for an IPv6 address.
1124 dnsa the DNS answer block
1127 Returns: pointer to a chain of dns_address items; NULL when the dnsa was overrun
1131 dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1133 dns_address * yield = NULL;
1134 uschar * dnsa_lim = dnsa->answer + dnsa->answerlen;
1136 if (rr->type == T_A)
1138 uschar *p = US rr->data;
1139 if (p + 4 <= dnsa_lim)
1141 yield = store_get(sizeof(dns_address) + 20);
1142 (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1151 if (rr->data + 16 <= dnsa_lim)
1153 struct in6_addr in6;
1155 for (i = 0; i < 16; i++) in6.s6_addr[i] = rr->data[i];
1156 yield = store_get(sizeof(dns_address) + 50);
1157 inet_ntop(AF_INET6, &in6, CS yield->address, 50);
1161 #endif /* HAVE_IPV6 */
1169 dns_pattern_init(void)
1171 if (check_dns_names_pattern[0] != 0 && !regex_check_dns_names)
1172 regex_check_dns_names =
1173 regex_must_compile(check_dns_names_pattern, FALSE, TRUE);