1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2014 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions for interfacing with the DNS. */
14 /*************************************************
16 *************************************************/
18 /* This function is called instead of res_search() when Exim is running in its
19 test harness. It recognizes some special domain names, and uses them to force
20 failure and retry responses (optionally with a delay). Otherwise, it calls an
21 external utility that mocks-up a nameserver, if it can find the utility.
22 If not, it passes its arguments on to res_search(). The fake nameserver may
23 also return a code specifying that the name should be passed on.
25 Background: the original test suite required a real nameserver to carry the
26 test zones, whereas the new test suite has the fake server for portability. This
30 domain the domain name
31 type the DNS record type
32 answerptr where to put the answer
33 size size of the answer area
35 Returns: length of returned data, or -1 on error (h_errno set)
39 fakens_search(const uschar *domain, int type, uschar *answerptr, int size)
41 int len = Ustrlen(domain);
42 int asize = size; /* Locally modified */
46 uschar *aptr = answerptr; /* Locally modified */
49 /* Remove terminating dot. */
51 if (domain[len - 1] == '.') len--;
52 Ustrncpy(name, domain, len);
56 /* This code, for forcing TRY_AGAIN and NO_RECOVERY, is here so that it works
57 for the old test suite that uses a real nameserver. When the old test suite is
58 eventually abandoned, this code could be moved into the fakens utility. */
60 if (len >= 14 && Ustrcmp(endname - 14, "test.again.dns") == 0)
62 int delay = Uatoi(name); /* digits at the start of the name */
63 DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
64 name, dns_text_type(type));
67 DEBUG(D_dns) debug_printf("delaying %d seconds\n", delay);
74 if (len >= 13 && Ustrcmp(endname - 13, "test.fail.dns") == 0)
76 DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
77 name, dns_text_type(type));
78 h_errno = NO_RECOVERY;
82 /* Look for the fakens utility, and if it exists, call it. */
84 (void)string_format(utilname, sizeof(utilname), "%s/bin/fakens",
85 config_main_directory);
87 if (stat(CS utilname, &statbuf) >= 0)
93 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) using fakens `%s'\n",
94 name, dns_text_type(type), utilname);
97 argv[1] = config_main_directory;
99 argv[3] = dns_text_type(type);
102 pid = child_open(argv, NULL, 0000, &infd, &outfd, FALSE);
104 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to run fakens: %s",
109 while (asize > 0 && (rc = read(outfd, aptr, asize)) > 0)
112 aptr += rc; /* Don't modify the actual arguments, because they */
113 asize -= rc; /* may need to be passed on to res_search(). */
117 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "read from fakens failed: %s",
120 switch(child_close(pid, 0))
123 case 1: h_errno = HOST_NOT_FOUND; return -1;
124 case 2: h_errno = TRY_AGAIN; return -1;
126 case 3: h_errno = NO_RECOVERY; return -1;
127 case 4: h_errno = NO_DATA; return -1;
128 case 5: /* Pass on to res_search() */
129 DEBUG(D_dns) debug_printf("fakens returned PASS_ON\n");
134 DEBUG(D_dns) debug_printf("fakens (%s) not found\n", utilname);
137 /* fakens utility not found, or it returned "pass on" */
139 DEBUG(D_dns) debug_printf("passing %s on to res_search()\n", domain);
141 return res_search(CS domain, C_IN, type, answerptr, size);
146 /*************************************************
147 * Initialize and configure resolver *
148 *************************************************/
150 /* Initialize the resolver and the storage for holding DNS answers if this is
151 the first time we have been here, and set the resolver options.
154 qualify_single TRUE to set the RES_DEFNAMES option
155 search_parents TRUE to set the RES_DNSRCH option
156 use_dnssec TRUE to set the RES_USE_DNSSEC option
162 dns_init(BOOL qualify_single, BOOL search_parents, BOOL use_dnssec)
164 res_state resp = os_get_dns_resolver_res();
166 if ((resp->options & RES_INIT) == 0)
168 DEBUG(D_resolver) resp->options |= RES_DEBUG; /* For Cygwin */
169 os_put_dns_resolver_res(resp);
171 DEBUG(D_resolver) resp->options |= RES_DEBUG;
172 os_put_dns_resolver_res(resp);
175 resp->options &= ~(RES_DNSRCH | RES_DEFNAMES);
176 resp->options |= (qualify_single? RES_DEFNAMES : 0) |
177 (search_parents? RES_DNSRCH : 0);
178 if (dns_retrans > 0) resp->retrans = dns_retrans;
179 if (dns_retry > 0) resp->retry = dns_retry;
182 if (dns_use_edns0 >= 0)
185 resp->options |= RES_USE_EDNS0;
187 resp->options &= ~RES_USE_EDNS0;
189 debug_printf("Coerced resolver EDNS0 support %s.\n",
190 dns_use_edns0 ? "on" : "off");
193 if (dns_use_edns0 >= 0)
195 debug_printf("Unable to %sset EDNS0 without resolver support.\n",
196 dns_use_edns0 ? "" : "un");
199 #ifndef DISABLE_DNSSEC
200 # ifdef RES_USE_DNSSEC
201 # ifndef RES_USE_EDNS0
202 # error Have RES_USE_DNSSEC but not RES_USE_EDNS0? Something hinky ...
205 resp->options |= RES_USE_DNSSEC;
206 if (dns_dnssec_ok >= 0)
208 if (dns_use_edns0 == 0 && dns_dnssec_ok != 0)
211 debug_printf("CONFLICT: dns_use_edns0 forced false, dns_dnssec_ok forced true, ignoring latter!\n");
216 resp->options |= RES_USE_DNSSEC;
218 resp->options &= ~RES_USE_DNSSEC;
219 DEBUG(D_resolver) debug_printf("Coerced resolver DNSSEC support %s.\n",
220 dns_dnssec_ok ? "on" : "off");
224 if (dns_dnssec_ok >= 0)
226 debug_printf("Unable to %sset DNSSEC without resolver support.\n",
227 dns_dnssec_ok ? "" : "un");
230 debug_printf("Unable to set DNSSEC without resolver support.\n");
232 #endif /* DISABLE_DNSSEC */
234 os_put_dns_resolver_res(resp);
239 /*************************************************
240 * Build key name for PTR records *
241 *************************************************/
243 /* This function inverts an IP address and adds the relevant domain, to produce
244 a name that can be used to look up PTR records.
247 string the IP address as a string
248 buffer a suitable buffer, long enough to hold the result
254 dns_build_reverse(const uschar *string, uschar *buffer)
256 const uschar *p = string + Ustrlen(string);
259 /* Handle IPv4 address */
262 if (Ustrchr(string, ':') == NULL)
266 for (i = 0; i < 4; i++)
268 const uschar *ppp = p;
269 while (ppp > string && ppp[-1] != '.') ppp--;
270 Ustrncpy(pp, ppp, p - ppp);
275 Ustrcpy(pp, "in-addr.arpa");
278 /* Handle IPv6 address; convert to binary so as to fill out any
279 abbreviation in the textual form. */
286 (void)host_aton(string, v6);
288 /* The original specification for IPv6 reverse lookup was to invert each
289 nibble, and look in the ip6.int domain. The domain was subsequently
290 changed to ip6.arpa. */
292 for (i = 3; i >= 0; i--)
295 for (j = 0; j < 32; j += 4)
297 sprintf(CS pp, "%x.", (v6[i] >> j) & 15);
301 Ustrcpy(pp, "ip6.arpa.");
303 /* Another way of doing IPv6 reverse lookups was proposed in conjunction
304 with A6 records. However, it fell out of favour when they did. The
305 alternative was to construct a binary key, and look in ip6.arpa. I tried
306 to make this code do that, but I could not make it work on Solaris 8. The
307 resolver seems to lose the initial backslash somehow. However, now that
308 this style of reverse lookup has been dropped, it doesn't matter. These
309 lines are left here purely for historical interest. */
311 /**************************************************
315 for (i = 0; i < 4; i++)
317 sprintf(pp, "%08X", v6[i]);
320 Ustrcpy(pp, "].ip6.arpa.");
321 **************************************************/
330 /*************************************************
331 * Get next DNS record from answer block *
332 *************************************************/
334 /* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
335 RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
336 scan the additional records, and reset == RESET_NEXT to get the next record.
337 The result is in static storage which must be copied if it is to be preserved.
340 dnsa pointer to dns answer block
341 dnss pointer to dns scan block
342 reset option specifing what portion to scan, as described above
344 Returns: next dns record, or NULL when no more
348 dns_next_rr(dns_answer *dnsa, dns_scan *dnss, int reset)
350 HEADER *h = (HEADER *)dnsa->answer;
353 /* Reset the saved data when requested to, and skip to the first required RR */
355 if (reset != RESET_NEXT)
357 dnss->rrcount = ntohs(h->qdcount);
358 dnss->aptr = dnsa->answer + sizeof(HEADER);
360 /* Skip over questions; failure to expand the name just gives up */
362 while (dnss->rrcount-- > 0)
364 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
365 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
366 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
367 dnss->aptr += namelen + 4; /* skip name & type & class */
370 /* Get the number of answer records. */
372 dnss->rrcount = ntohs(h->ancount);
374 /* Skip over answers if we want to look at the authority section. Also skip
375 the NS records (i.e. authority section) if wanting to look at the additional
378 if (reset == RESET_ADDITIONAL) dnss->rrcount += ntohs(h->nscount);
380 if (reset == RESET_AUTHORITY || reset == RESET_ADDITIONAL)
382 while (dnss->rrcount-- > 0)
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) { dnss->rrcount = 0; return NULL; }
387 dnss->aptr += namelen + 8; /* skip name, type, class & TTL */
388 GETSHORT(dnss->srr.size, dnss->aptr); /* size of data portion */
389 dnss->aptr += dnss->srr.size; /* skip over it */
391 dnss->rrcount = (reset == RESET_AUTHORITY)
392 ? ntohs(h->nscount) : ntohs(h->arcount);
396 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
397 contains the number of RR records left. */
399 if (dnss->rrcount-- <= 0) return NULL;
401 /* If expanding the RR domain name fails, behave as if no more records
404 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, dnss->aptr,
405 (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
406 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
408 /* Move the pointer past the name and fill in the rest of the data structure
409 from the following bytes. */
411 dnss->aptr += namelen;
412 GETSHORT(dnss->srr.type, dnss->aptr); /* Record type */
413 dnss->aptr += 6; /* Don't want class or TTL */
414 GETSHORT(dnss->srr.size, dnss->aptr); /* Size of data portion */
415 dnss->srr.data = dnss->aptr; /* The record's data follows */
416 dnss->aptr += dnss->srr.size; /* Advance to next RR */
418 /* Return a pointer to the dns_record structure within the dns_answer. This is
419 for convenience so that the scans can use nice-looking for loops. */
427 /*************************************************
428 * Return whether AD bit set in DNS result *
429 *************************************************/
431 /* We do not perform DNSSEC work ourselves; if the administrator has installed
432 a verifying resolver which sets AD as appropriate, though, we'll use that.
433 (AD = Authentic Data)
435 Argument: pointer to dns answer block
436 Returns: bool indicating presence of AD bit
440 dns_is_secure(const dns_answer * dnsa)
442 #ifdef DISABLE_DNSSEC
444 debug_printf("DNSSEC support disabled at build-time; dns_is_secure() false\n");
447 HEADER *h = (HEADER *)dnsa->answer;
448 return h->ad ? TRUE : FALSE;
453 dns_set_insecure(dns_answer * dnsa)
455 HEADER * h = (HEADER *)dnsa->answer;
462 /*************************************************
463 * Turn DNS type into text *
464 *************************************************/
466 /* Turn the coded record type into a string for printing. All those that Exim
467 uses should be included here.
469 Argument: record type
470 Returns: pointer to string
478 case T_A: return US"A";
479 case T_MX: return US"MX";
480 case T_AAAA: return US"AAAA";
481 case T_A6: return US"A6";
482 case T_TXT: return US"TXT";
483 case T_SPF: return US"SPF";
484 case T_PTR: return US"PTR";
485 case T_SOA: return US"SOA";
486 case T_SRV: return US"SRV";
487 case T_NS: return US"NS";
488 case T_CNAME: return US"CNAME";
489 case T_TLSA: return US"TLSA";
490 default: return US"?";
496 /*************************************************
497 * Cache a failed DNS lookup result *
498 *************************************************/
500 /* We cache failed lookup results so as not to experience timeouts many
501 times for the same domain. We need to retain the resolver options because they
502 may change. For successful lookups, we rely on resolver and/or name server
510 Returns: the return code
514 dns_return(const uschar * name, int type, int rc)
516 res_state resp = os_get_dns_resolver_res();
517 tree_node *node = store_get_perm(sizeof(tree_node) + 290);
518 sprintf(CS node->name, "%.255s-%s-%lx", name, dns_text_type(type),
521 (void)tree_insertnode(&tree_dns_fails, node);
527 /*************************************************
528 * Do basic DNS lookup *
529 *************************************************/
531 /* Call the resolver to look up the given domain name, using the given type,
532 and check the result. The error code TRY_AGAIN is documented as meaning "non-
533 Authoritive Host not found, or SERVERFAIL". Sometimes there are badly set
534 up nameservers that produce this error continually, so there is the option of
535 providing a list of domains for which this is treated as a non-existent
539 dnsa pointer to dns_answer structure
541 type type of DNS record required (T_A, T_MX, etc)
543 Returns: DNS_SUCCEED successful lookup
544 DNS_NOMATCH name not found (NXDOMAIN)
545 or name contains illegal characters (if checking)
546 or name is an IP address (for IP address lookup)
547 DNS_NODATA domain exists, but no data for this type (NODATA)
548 DNS_AGAIN soft failure, try again later
553 dns_basic_lookup(dns_answer *dnsa, const uschar *name, int type)
557 const uschar *save_domain;
559 res_state resp = os_get_dns_resolver_res();
562 uschar node_name[290];
564 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
565 a timeout on one domain doesn't happen time and time again for messages that
566 have many addresses in the same domain. We rely on the resolver and name server
567 caching for successful lookups. */
569 sprintf(CS node_name, "%.255s-%s-%lx", name, dns_text_type(type),
571 previous = tree_search(tree_dns_fails, node_name);
572 if (previous != NULL)
574 DEBUG(D_dns) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
575 name, dns_text_type(type),
576 (previous->data.val == DNS_NOMATCH)? "DNS_NOMATCH" :
577 (previous->data.val == DNS_NODATA)? "DNS_NODATA" :
578 (previous->data.val == DNS_AGAIN)? "DNS_AGAIN" :
579 (previous->data.val == DNS_FAIL)? "DNS_FAIL" : "??");
580 return previous->data.val;
583 #ifdef EXPERIMENTAL_INTERNATIONAL
584 /* Convert all names to a-label form before doing lookup */
587 uschar * errstr = NULL;
588 DEBUG(D_dns) if (string_is_utf8(name))
589 debug_printf("convert utf8 '%s' to alabel for for lookup\n", name);
590 if ((alabel = string_domain_utf8_to_alabel(name, &errstr)), errstr)
593 debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name,
595 host_find_failed_syntax = TRUE;
602 /* If configured, check the hygene of the name passed to lookup. Otherwise,
603 although DNS lookups may give REFUSED at the lower level, some resolvers
604 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
605 domains cannot be in the DNS. The check is now done by a regular expression;
606 give it space for substring storage to save it having to get its own if the
607 regex has substrings that are used - the default uses a conditional.
609 This test is omitted for PTR records. These occur only in calls from the dnsdb
610 lookup, which constructs the names itself, so they should be OK. Besides,
611 bitstring labels don't conform to normal name syntax. (But the aren't used any
614 For SRV records, we omit the initial _smtp._tcp. components at the start. */
616 #ifndef STAND_ALONE /* Omit this for stand-alone tests */
618 if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
620 const uschar *checkname = name;
621 int ovector[3*(EXPAND_MAXN+1)];
625 /* For an SRV lookup, skip over the first two components (the service and
626 protocol names, which both start with an underscore). */
628 if (type == T_SRV || type == T_TLSA)
630 while (*checkname++ != '.');
631 while (*checkname++ != '.');
634 if (pcre_exec(regex_check_dns_names, NULL, CCS checkname, Ustrlen(checkname),
635 0, PCRE_EOPT, ovector, sizeof(ovector)/sizeof(int)) < 0)
638 debug_printf("DNS name syntax check failed: %s (%s)\n", name,
639 dns_text_type(type));
640 host_find_failed_syntax = TRUE;
645 #endif /* STAND_ALONE */
647 /* Call the resolver; for an overlong response, res_search() will return the
648 number of bytes the message would need, so we need to check for this case. The
649 effect is to truncate overlong data.
651 On some systems, res_search() will recognize "A-for-A" queries and return
652 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
653 nameservers are also believed to do this. It is, of course, contrary to the
654 specification of the DNS, so we lock it out. */
656 if ((type == T_A || type == T_AAAA) && string_is_ip_address(name, NULL) != 0)
659 /* If we are running in the test harness, instead of calling the normal resolver
660 (res_search), we call fakens_search(), which recognizes certain special
661 domains, and interfaces to a fake nameserver for certain special zones. */
663 dnsa->answerlen = running_in_test_harness
664 ? fakens_search(name, type, dnsa->answer, MAXPACKET)
665 : res_search(CCS name, C_IN, type, dnsa->answer, MAXPACKET);
667 if (dnsa->answerlen > MAXPACKET)
669 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet (size %d), truncating to %d.\n",
670 name, dns_text_type(type), dnsa->answerlen, MAXPACKET);
671 dnsa->answerlen = MAXPACKET;
674 if (dnsa->answerlen < 0) switch (h_errno)
677 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
678 "returning DNS_NOMATCH\n", name, dns_text_type(type));
679 return dns_return(name, type, DNS_NOMATCH);
682 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
683 name, dns_text_type(type));
685 /* Cut this out for various test programs */
687 save_domain = deliver_domain;
688 deliver_domain = string_copy(name); /* set $domain */
689 rc = match_isinlist(name, (const uschar **)&dns_again_means_nonexist, 0, NULL, NULL,
690 MCL_DOMAIN, TRUE, NULL);
691 deliver_domain = save_domain;
694 DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
695 return dns_return(name, type, DNS_AGAIN);
697 DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
698 "DNS_NOMATCH\n", name);
699 return dns_return(name, type, DNS_NOMATCH);
701 #else /* For stand-alone tests */
702 return dns_return(name, type, DNS_AGAIN);
706 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
707 "returning DNS_FAIL\n", name, dns_text_type(type));
708 return dns_return(name, type, DNS_FAIL);
711 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
712 "returning DNS_NODATA\n", name, dns_text_type(type));
713 return dns_return(name, type, DNS_NODATA);
716 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
717 "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
718 return dns_return(name, type, DNS_FAIL);
721 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
722 name, dns_text_type(type));
730 /************************************************
731 * Do a DNS lookup and handle CNAMES *
732 ************************************************/
734 /* Look up the given domain name, using the given type. Follow CNAMEs if
735 necessary, but only so many times. There aren't supposed to be CNAME chains in
736 the DNS, but you are supposed to cope with them if you find them.
738 The assumption is made that if the resolver gives back records of the
739 requested type *and* a CNAME, we don't need to make another call to look up
740 the CNAME. I can't see how it could return only some of the right records. If
741 it's done a CNAME lookup in the past, it will have all of them; if not, it
744 If fully_qualified_name is not NULL, set it to point to the full name
745 returned by the resolver, if this is different to what it is given, unless
746 the returned name starts with "*" as some nameservers seem to be returning
747 wildcards in this form. In international mode "different" means "alabel
748 forms are different".
751 dnsa pointer to dns_answer structure
752 name domain name to look up
753 type DNS record type (T_A, T_MX, etc)
754 fully_qualified_name if not NULL, return the returned name here if its
755 contents are different (i.e. it must be preset)
757 Returns: DNS_SUCCEED successful lookup
758 DNS_NOMATCH name not found
759 DNS_NODATA no data found
760 DNS_AGAIN soft failure, try again later
765 dns_lookup(dns_answer *dnsa, const uschar *name, int type,
766 const uschar **fully_qualified_name)
769 const uschar *orig_name = name;
770 BOOL secure_so_far = TRUE;
772 /* Loop to follow CNAME chains so far, but no further... */
774 for (i = 0; i < 10; i++)
777 dns_record *rr, cname_rr, type_rr;
781 /* DNS lookup failures get passed straight back. */
783 if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED) return rc;
785 /* We should have either records of the required type, or a CNAME record,
786 or both. We need to know whether both exist for getting the fully qualified
787 name, but avoid scanning more than necessary. Note that we must copy the
788 contents of any rr blocks returned by dns_next_rr() as they use the same
789 area in the dnsa block. */
791 cname_rr.data = type_rr.data = NULL;
792 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
794 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
796 if (rr->type == type)
798 if (type_rr.data == NULL) type_rr = *rr;
799 if (cname_rr.data != NULL) break;
801 else if (rr->type == T_CNAME) cname_rr = *rr;
804 /* For the first time round this loop, if a CNAME was found, take the fully
805 qualified name from it; otherwise from the first data record, if present. */
807 if (i == 0 && fully_qualified_name != NULL)
809 uschar * rr_name = cname_rr.data ? cname_rr.name
810 : type_rr.data ? type_rr.name : NULL;
812 && Ustrcmp(rr_name, *fully_qualified_name) != 0
814 #ifdef EXPERIMENTAL_INTERNATIONAL
815 && ( !string_is_utf8(*fully_qualified_name)
817 string_domain_utf8_to_alabel(*fully_qualified_name, NULL)) != 0
821 *fully_qualified_name = string_copy_dnsdomain(rr_name);
824 /* If any data records of the correct type were found, we are done. */
826 if (type_rr.data != NULL)
828 if (!secure_so_far) /* mark insecure if any element of CNAME chain was */
829 dns_set_insecure(dnsa);
833 /* If there are no data records, we need to re-scan the DNS using the
834 domain given in the CNAME record, which should exist (otherwise we should
835 have had a failure from dns_lookup). However code against the possibility of
838 if (cname_rr.data == NULL) return DNS_FAIL;
839 datalen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
840 cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
841 if (datalen < 0) return DNS_FAIL;
844 if (!dns_is_secure(dnsa))
845 secure_so_far = FALSE;
847 DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
848 } /* Loop back to do another lookup */
850 /*Control reaches here after 10 times round the CNAME loop. Something isn't
853 log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
862 /************************************************
863 * Do a DNS lookup and handle virtual types *
864 ************************************************/
866 /* This function handles some invented "lookup types" that synthesize feature
867 not available in the basic types. The special types all have negative values.
868 Positive type values are passed straight on to dns_lookup().
871 dnsa pointer to dns_answer structure
872 name domain name to look up
873 type DNS record type (T_A, T_MX, etc or a "special")
874 fully_qualified_name if not NULL, return the returned name here if its
875 contents are different (i.e. it must be preset)
877 Returns: DNS_SUCCEED successful lookup
878 DNS_NOMATCH name not found
879 DNS_NODATA no data found
880 DNS_AGAIN soft failure, try again later
885 dns_special_lookup(dns_answer *dnsa, const uschar *name, int type,
886 const uschar **fully_qualified_name)
890 /* The "mx hosts only" type doesn't require any special action here */
892 return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
894 /* Find nameservers for the domain or the nearest enclosing zone, excluding
901 const uschar *d = name;
904 int rc = dns_lookup(dnsa, d, type, fully_qualified_name);
905 if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
906 while (*d != 0 && *d != '.') d++;
907 if (*d++ == 0) break;
912 /* Try to look up the Client SMTP Authorization SRV record for the name. If
913 there isn't one, search from the top downwards for a CSA record in a parent
914 domain, which might be making assertions about subdomains. If we find a record
915 we set fully_qualified_name to whichever lookup succeeded, so that the caller
916 can tell whether to look at the explicit authorization field or the subdomain
920 uschar *srvname, *namesuff, *tld, *p;
921 int priority, weight, port;
927 DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
929 srvname = string_sprintf("_client._smtp.%s", name);
930 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
931 if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
933 if (rc == DNS_SUCCEED) *fully_qualified_name = string_copy(name);
937 /* Search for CSA subdomain assertion SRV records from the top downwards,
938 starting with the 2nd level domain. This order maximizes cache-friendliness.
939 We skip the top level domains to avoid loading their nameservers and because
940 we know they'll never have CSA SRV records. */
942 namesuff = Ustrrchr(name, '.');
943 if (namesuff == NULL) return DNS_NOMATCH;
946 limit = dns_csa_search_limit;
948 /* Use more appropriate search parameters if we are in the reverse DNS. */
950 if (strcmpic(namesuff, US".arpa") == 0)
952 if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
958 else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
967 DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
969 /* Do not perform the search if the top level or 2nd level domains do not
970 exist. This is quite common, and when it occurs all the search queries would
971 go to the root or TLD name servers, which is not friendly. So we check the
972 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
973 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
974 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
975 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
977 if (rc == DNS_NOMATCH)
979 /* This is really gross. The successful return value from res_search() is
980 the packet length, which is stored in dnsa->answerlen. If we get a
981 negative DNS reply then res_search() returns -1, which causes the bounds
982 checks for name decompression to fail when it is treated as a packet
983 length, which in turn causes the authority search to fail. The correct
984 packet length has been lost inside libresolv, so we have to guess a
985 replacement value. (The only way to fix this properly would be to
986 re-implement res_search() and res_query() so that they don't muddle their
987 success and packet length return values.) For added safety we only reset
988 the packet length if the packet header looks plausible. */
990 HEADER *h = (HEADER *)dnsa->answer;
991 if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
992 && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
993 && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
994 && ntohs(h->nscount) >= 1)
995 dnsa->answerlen = MAXPACKET;
997 for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
999 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1000 if (rr->type != T_SOA) continue;
1001 else if (strcmpic(rr->name, US"") == 0 ||
1002 strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
1006 for (i = 0; i < limit; i++)
1010 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1011 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1013 if (namesuff <= name) return DNS_NOMATCH;
1016 /* Find the start of the preceding domain name label. */
1018 if (--namesuff <= name) return DNS_NOMATCH;
1019 while (*namesuff != '.');
1021 DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
1023 srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
1024 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1025 if (rc == DNS_AGAIN) return rc;
1026 if (rc != DNS_SUCCEED) continue;
1028 /* Check that the SRV record we have found is worth returning. We don't
1029 just return the first one we find, because some lower level SRV record
1030 might make stricter assertions than its parent domain. */
1032 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1034 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1036 if (rr->type != T_SRV) continue;
1038 /* Extract the numerical SRV fields (p is incremented) */
1040 GETSHORT(priority, p);
1041 GETSHORT(weight, p); weight = weight; /* compiler quietening */
1044 /* Check the CSA version number */
1045 if (priority != 1) continue;
1047 /* If it's making an interesting assertion, return this response. */
1050 *fully_qualified_name = namesuff + 1;
1060 return dns_lookup(dnsa, name, type, fully_qualified_name);
1063 /* Control should never reach here */
1072 /*************************************************
1073 * Get address(es) from DNS record *
1074 *************************************************/
1076 /* The record type is either T_A for an IPv4 address or T_AAAA (or T_A6 when
1077 supported) for an IPv6 address.
1080 dnsa the DNS answer block
1083 Returns: pointer to a chain of dns_address items
1087 dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1089 dns_address *yield = NULL;
1091 dnsa = dnsa; /* Stop picky compilers warning */
1093 if (rr->type == T_A)
1095 uschar *p = US rr->data;
1096 yield = store_get(sizeof(dns_address) + 20);
1097 (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1105 yield = store_get(sizeof(dns_address) + 50);
1106 inet_ntop(AF_INET6, US rr->data, CS yield->address, 50);
1109 #endif /* HAVE_IPV6 */
1117 dns_pattern_init(void)
1119 if (check_dns_names_pattern[0] != 0 && !regex_check_dns_names)
1120 regex_check_dns_names =
1121 regex_must_compile(check_dns_names_pattern, FALSE, TRUE);