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. */
13 /* Function declaration needed for mutual recursion when A6 records
18 static void dns_complete_a6(dns_address ***, dns_answer *, dns_record *,
24 /*************************************************
26 *************************************************/
28 /* This function is called instead of res_search() when Exim is running in its
29 test harness. It recognizes some special domain names, and uses them to force
30 failure and retry responses (optionally with a delay). Otherwise, it calls an
31 external utility that mocks-up a nameserver, if it can find the utility.
32 If not, it passes its arguments on to res_search(). The fake nameserver may
33 also return a code specifying that the name should be passed on.
35 Background: the original test suite required a real nameserver to carry the
36 test zones, whereas the new test suit has the fake server for portability. This
40 domain the domain name
41 type the DNS record type
42 answerptr where to put the answer
43 size size of the answer area
45 Returns: length of returned data, or -1 on error (h_errno set)
49 fakens_search(const uschar *domain, int type, uschar *answerptr, int size)
51 int len = Ustrlen(domain);
52 int asize = size; /* Locally modified */
56 uschar *aptr = answerptr; /* Locally modified */
59 /* Remove terminating dot. */
61 if (domain[len - 1] == '.') len--;
62 Ustrncpy(name, domain, len);
66 /* This code, for forcing TRY_AGAIN and NO_RECOVERY, is here so that it works
67 for the old test suite that uses a real nameserver. When the old test suite is
68 eventually abandoned, this code could be moved into the fakens utility. */
70 if (len >= 14 && Ustrcmp(endname - 14, "test.again.dns") == 0)
72 int delay = Uatoi(name); /* digits at the start of the name */
73 DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
74 name, dns_text_type(type));
77 DEBUG(D_dns) debug_printf("delaying %d seconds\n", delay);
84 if (len >= 13 && Ustrcmp(endname - 13, "test.fail.dns") == 0)
86 DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
87 name, dns_text_type(type));
88 h_errno = NO_RECOVERY;
92 /* Look for the fakens utility, and if it exists, call it. */
94 (void)string_format(utilname, sizeof(utilname), "%s/../bin/fakens",
97 if (stat(CS utilname, &statbuf) >= 0)
103 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) using fakens\n",
104 name, dns_text_type(type));
107 argv[1] = spool_directory;
109 argv[3] = dns_text_type(type);
112 pid = child_open(argv, NULL, 0000, &infd, &outfd, FALSE);
114 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to run fakens: %s",
119 while (asize > 0 && (rc = read(outfd, aptr, asize)) > 0)
122 aptr += rc; /* Don't modify the actual arguments, because they */
123 asize -= rc; /* may need to be passed on to res_search(). */
127 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "read from fakens failed: %s",
130 switch(child_close(pid, 0))
133 case 1: h_errno = HOST_NOT_FOUND; return -1;
134 case 2: h_errno = TRY_AGAIN; return -1;
136 case 3: h_errno = NO_RECOVERY; return -1;
137 case 4: h_errno = NO_DATA; return -1;
138 case 5: /* Pass on to res_search() */
139 DEBUG(D_dns) debug_printf("fakens returned PASS_ON\n");
143 /* fakens utility not found, or it returned "pass on" */
145 DEBUG(D_dns) debug_printf("passing %s on to res_search()\n", domain);
147 return res_search(CS domain, C_IN, type, answerptr, size);
152 /*************************************************
153 * Initialize and configure resolver *
154 *************************************************/
156 /* Initialize the resolver and the storage for holding DNS answers if this is
157 the first time we have been here, and set the resolver options.
160 qualify_single TRUE to set the RES_DEFNAMES option
161 search_parents TRUE to set the RES_DNSRCH option
162 use_dnssec TRUE to set the RES_USE_DNSSEC option
168 dns_init(BOOL qualify_single, BOOL search_parents, BOOL use_dnssec)
170 res_state resp = os_get_dns_resolver_res();
172 if ((resp->options & RES_INIT) == 0)
174 DEBUG(D_resolver) resp->options |= RES_DEBUG; /* For Cygwin */
175 os_put_dns_resolver_res(resp);
177 DEBUG(D_resolver) resp->options |= RES_DEBUG;
178 os_put_dns_resolver_res(resp);
181 resp->options &= ~(RES_DNSRCH | RES_DEFNAMES);
182 resp->options |= (qualify_single? RES_DEFNAMES : 0) |
183 (search_parents? RES_DNSRCH : 0);
184 if (dns_retrans > 0) resp->retrans = dns_retrans;
185 if (dns_retry > 0) resp->retry = dns_retry;
188 if (dns_use_edns0 >= 0)
191 resp->options |= RES_USE_EDNS0;
193 resp->options &= ~RES_USE_EDNS0;
195 debug_printf("Coerced resolver EDNS0 support %s.\n",
196 dns_use_edns0 ? "on" : "off");
199 if (dns_use_edns0 >= 0)
201 debug_printf("Unable to %sset EDNS0 without resolver support.\n",
202 dns_use_edns0 ? "" : "un");
205 #ifndef DISABLE_DNSSEC
206 # ifdef RES_USE_DNSSEC
207 # ifndef RES_USE_EDNS0
208 # error Have RES_USE_DNSSEC but not RES_USE_EDNS0? Something hinky ...
211 resp->options |= RES_USE_DNSSEC;
212 if (dns_dnssec_ok >= 0)
214 if (dns_use_edns0 == 0 && dns_dnssec_ok != 0)
217 debug_printf("CONFLICT: dns_use_edns0 forced false, dns_dnssec_ok forced true, ignoring latter!\n");
222 resp->options |= RES_USE_DNSSEC;
224 resp->options &= ~RES_USE_DNSSEC;
225 DEBUG(D_resolver) debug_printf("Coerced resolver DNSSEC support %s.\n",
226 dns_dnssec_ok ? "on" : "off");
230 if (dns_dnssec_ok >= 0)
232 debug_printf("Unable to %sset DNSSEC without resolver support.\n",
233 dns_dnssec_ok ? "" : "un");
236 debug_printf("Unable to set DNSSEC without resolver support.\n");
238 #endif /* DISABLE_DNSSEC */
240 os_put_dns_resolver_res(resp);
245 /*************************************************
246 * Build key name for PTR records *
247 *************************************************/
249 /* This function inverts an IP address and adds the relevant domain, to produce
250 a name that can be used to look up PTR records.
253 string the IP address as a string
254 buffer a suitable buffer, long enough to hold the result
260 dns_build_reverse(uschar *string, uschar *buffer)
262 uschar *p = string + Ustrlen(string);
265 /* Handle IPv4 address */
268 if (Ustrchr(string, ':') == NULL)
272 for (i = 0; i < 4; i++)
275 while (ppp > string && ppp[-1] != '.') ppp--;
276 Ustrncpy(pp, ppp, p - ppp);
281 Ustrcpy(pp, "in-addr.arpa");
284 /* Handle IPv6 address; convert to binary so as to fill out any
285 abbreviation in the textual form. */
292 (void)host_aton(string, v6);
294 /* The original specification for IPv6 reverse lookup was to invert each
295 nibble, and look in the ip6.int domain. The domain was subsequently
296 changed to ip6.arpa. */
298 for (i = 3; i >= 0; i--)
301 for (j = 0; j < 32; j += 4)
303 sprintf(CS pp, "%x.", (v6[i] >> j) & 15);
307 Ustrcpy(pp, "ip6.arpa.");
309 /* Another way of doing IPv6 reverse lookups was proposed in conjunction
310 with A6 records. However, it fell out of favour when they did. The
311 alternative was to construct a binary key, and look in ip6.arpa. I tried
312 to make this code do that, but I could not make it work on Solaris 8. The
313 resolver seems to lose the initial backslash somehow. However, now that
314 this style of reverse lookup has been dropped, it doesn't matter. These
315 lines are left here purely for historical interest. */
317 /**************************************************
321 for (i = 0; i < 4; i++)
323 sprintf(pp, "%08X", v6[i]);
326 Ustrcpy(pp, "].ip6.arpa.");
327 **************************************************/
336 /*************************************************
337 * Get next DNS record from answer block *
338 *************************************************/
340 /* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
341 RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
342 scan the additional records, and reset == RESET_NEXT to get the next record.
343 The result is in static storage which must be copied if it is to be preserved.
346 dnsa pointer to dns answer block
347 dnss pointer to dns scan block
348 reset option specifing what portion to scan, as described above
350 Returns: next dns record, or NULL when no more
354 dns_next_rr(dns_answer *dnsa, dns_scan *dnss, int reset)
356 HEADER *h = (HEADER *)dnsa->answer;
359 /* Reset the saved data when requested to, and skip to the first required RR */
361 if (reset != RESET_NEXT)
363 dnss->rrcount = ntohs(h->qdcount);
364 dnss->aptr = dnsa->answer + sizeof(HEADER);
366 /* Skip over questions; failure to expand the name just gives up */
368 while (dnss->rrcount-- > 0)
370 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
371 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
372 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
373 dnss->aptr += namelen + 4; /* skip name & type & class */
376 /* Get the number of answer records. */
378 dnss->rrcount = ntohs(h->ancount);
380 /* Skip over answers if we want to look at the authority section. Also skip
381 the NS records (i.e. authority section) if wanting to look at the additional
384 if (reset == RESET_ADDITIONAL) dnss->rrcount += ntohs(h->nscount);
386 if (reset == RESET_AUTHORITY || reset == RESET_ADDITIONAL)
388 while (dnss->rrcount-- > 0)
390 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
391 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
392 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
393 dnss->aptr += namelen + 8; /* skip name, type, class & TTL */
394 GETSHORT(dnss->srr.size, dnss->aptr); /* size of data portion */
395 dnss->aptr += dnss->srr.size; /* skip over it */
397 dnss->rrcount = (reset == RESET_AUTHORITY)
398 ? ntohs(h->nscount) : ntohs(h->arcount);
402 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
403 contains the number of RR records left. */
405 if (dnss->rrcount-- <= 0) return NULL;
407 /* If expanding the RR domain name fails, behave as if no more records
410 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, dnss->aptr,
411 (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
412 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
414 /* Move the pointer past the name and fill in the rest of the data structure
415 from the following bytes. */
417 dnss->aptr += namelen;
418 GETSHORT(dnss->srr.type, dnss->aptr); /* Record type */
419 dnss->aptr += 6; /* Don't want class or TTL */
420 GETSHORT(dnss->srr.size, dnss->aptr); /* Size of data portion */
421 dnss->srr.data = dnss->aptr; /* The record's data follows */
422 dnss->aptr += dnss->srr.size; /* Advance to next RR */
424 /* Return a pointer to the dns_record structure within the dns_answer. This is
425 for convenience so that the scans can use nice-looking for loops. */
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)
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 return h->ad ? TRUE : FALSE;
459 dns_set_insecure(dns_answer * dnsa)
461 HEADER * h = (HEADER *)dnsa->answer;
468 /*************************************************
469 * Turn DNS type into text *
470 *************************************************/
472 /* Turn the coded record type into a string for printing. All those that Exim
473 uses should be included here.
475 Argument: record type
476 Returns: pointer to string
484 case T_A: return US"A";
485 case T_MX: return US"MX";
486 case T_AAAA: return US"AAAA";
487 case T_A6: return US"A6";
488 case T_TXT: return US"TXT";
489 case T_SPF: return US"SPF";
490 case T_PTR: return US"PTR";
491 case T_SOA: return US"SOA";
492 case T_SRV: return US"SRV";
493 case T_NS: return US"NS";
494 case T_CNAME: return US"CNAME";
495 case T_TLSA: return US"TLSA";
496 default: return US"?";
502 /*************************************************
503 * Cache a failed DNS lookup result *
504 *************************************************/
506 /* We cache failed lookup results so as not to experience timeouts many
507 times for the same domain. We need to retain the resolver options because they
508 may change. For successful lookups, we rely on resolver and/or name server
516 Returns: the return code
520 dns_return(const uschar * name, int type, int rc)
522 res_state resp = os_get_dns_resolver_res();
523 tree_node *node = store_get_perm(sizeof(tree_node) + 290);
524 sprintf(CS node->name, "%.255s-%s-%lx", name, dns_text_type(type),
527 (void)tree_insertnode(&tree_dns_fails, node);
533 /*************************************************
534 * Do basic DNS lookup *
535 *************************************************/
537 /* Call the resolver to look up the given domain name, using the given type,
538 and check the result. The error code TRY_AGAIN is documented as meaning "non-
539 Authoritive Host not found, or SERVERFAIL". Sometimes there are badly set
540 up nameservers that produce this error continually, so there is the option of
541 providing a list of domains for which this is treated as a non-existent
545 dnsa pointer to dns_answer structure
547 type type of DNS record required (T_A, T_MX, etc)
549 Returns: DNS_SUCCEED successful lookup
550 DNS_NOMATCH name not found (NXDOMAIN)
551 or name contains illegal characters (if checking)
552 or name is an IP address (for IP address lookup)
553 DNS_NODATA domain exists, but no data for this type (NODATA)
554 DNS_AGAIN soft failure, try again later
559 dns_basic_lookup(dns_answer *dnsa, const uschar *name, int type)
565 res_state resp = os_get_dns_resolver_res();
568 uschar node_name[290];
570 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
571 a timeout on one domain doesn't happen time and time again for messages that
572 have many addresses in the same domain. We rely on the resolver and name server
573 caching for successful lookups. */
575 sprintf(CS node_name, "%.255s-%s-%lx", name, dns_text_type(type),
577 previous = tree_search(tree_dns_fails, node_name);
578 if (previous != NULL)
580 DEBUG(D_dns) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
581 name, dns_text_type(type),
582 (previous->data.val == DNS_NOMATCH)? "DNS_NOMATCH" :
583 (previous->data.val == DNS_NODATA)? "DNS_NODATA" :
584 (previous->data.val == DNS_AGAIN)? "DNS_AGAIN" :
585 (previous->data.val == DNS_FAIL)? "DNS_FAIL" : "??");
586 return previous->data.val;
589 /* If configured, check the hygene of the name passed to lookup. Otherwise,
590 although DNS lookups may give REFUSED at the lower level, some resolvers
591 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
592 domains cannot be in the DNS. The check is now done by a regular expression;
593 give it space for substring storage to save it having to get its own if the
594 regex has substrings that are used - the default uses a conditional.
596 This test is omitted for PTR records. These occur only in calls from the dnsdb
597 lookup, which constructs the names itself, so they should be OK. Besides,
598 bitstring labels don't conform to normal name syntax. (But the aren't used any
601 For SRV records, we omit the initial _smtp._tcp. components at the start. */
603 #ifndef STAND_ALONE /* Omit this for stand-alone tests */
605 if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
607 const uschar *checkname = name;
608 int ovector[3*(EXPAND_MAXN+1)];
610 if (regex_check_dns_names == NULL)
611 regex_check_dns_names =
612 regex_must_compile(check_dns_names_pattern, FALSE, TRUE);
614 /* For an SRV lookup, skip over the first two components (the service and
615 protocol names, which both start with an underscore). */
617 if (type == T_SRV || type == T_TLSA)
619 while (*checkname++ != '.');
620 while (*checkname++ != '.');
623 if (pcre_exec(regex_check_dns_names, NULL, CCS checkname, Ustrlen(checkname),
624 0, PCRE_EOPT, ovector, sizeof(ovector)/sizeof(int)) < 0)
627 debug_printf("DNS name syntax check failed: %s (%s)\n", name,
628 dns_text_type(type));
629 host_find_failed_syntax = TRUE;
634 #endif /* STAND_ALONE */
636 /* Call the resolver; for an overlong response, res_search() will return the
637 number of bytes the message would need, so we need to check for this case. The
638 effect is to truncate overlong data.
640 On some systems, res_search() will recognize "A-for-A" queries and return
641 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
642 nameservers are also believed to do this. It is, of course, contrary to the
643 specification of the DNS, so we lock it out. */
649 type == T_A || type == T_AAAA) &&
650 string_is_ip_address(name, NULL) != 0)
653 /* If we are running in the test harness, instead of calling the normal resolver
654 (res_search), we call fakens_search(), which recognizes certain special
655 domains, and interfaces to a fake nameserver for certain special zones. */
657 if (running_in_test_harness)
658 dnsa->answerlen = fakens_search(name, type, dnsa->answer, MAXPACKET);
660 dnsa->answerlen = res_search(CCS name, C_IN, type, dnsa->answer, MAXPACKET);
662 if (dnsa->answerlen > MAXPACKET)
664 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet (size %d), truncating to %d.\n",
665 name, dns_text_type(type), dnsa->answerlen, MAXPACKET);
666 dnsa->answerlen = MAXPACKET;
669 if (dnsa->answerlen < 0) switch (h_errno)
672 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
673 "returning DNS_NOMATCH\n", name, dns_text_type(type));
674 return dns_return(name, type, DNS_NOMATCH);
677 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
678 name, dns_text_type(type));
680 /* Cut this out for various test programs */
682 save = deliver_domain;
683 deliver_domain = string_copy(name); /* set $domain */
684 rc = match_isinlist(name, &dns_again_means_nonexist, 0, NULL, NULL,
685 MCL_DOMAIN, TRUE, NULL);
686 deliver_domain = save;
689 DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
690 return dns_return(name, type, DNS_AGAIN);
692 DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
693 "DNS_NOMATCH\n", name);
694 return dns_return(name, type, DNS_NOMATCH);
696 #else /* For stand-alone tests */
697 return dns_return(name, type, DNS_AGAIN);
701 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
702 "returning DNS_FAIL\n", name, dns_text_type(type));
703 return dns_return(name, type, DNS_FAIL);
706 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
707 "returning DNS_NODATA\n", name, dns_text_type(type));
708 return dns_return(name, type, DNS_NODATA);
711 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
712 "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
713 return dns_return(name, type, DNS_FAIL);
716 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
717 name, dns_text_type(type));
725 /************************************************
726 * Do a DNS lookup and handle CNAMES *
727 ************************************************/
729 /* Look up the given domain name, using the given type. Follow CNAMEs if
730 necessary, but only so many times. There aren't supposed to be CNAME chains in
731 the DNS, but you are supposed to cope with them if you find them.
733 The assumption is made that if the resolver gives back records of the
734 requested type *and* a CNAME, we don't need to make another call to look up
735 the CNAME. I can't see how it could return only some of the right records. If
736 it's done a CNAME lookup in the past, it will have all of them; if not, it
739 If fully_qualified_name is not NULL, set it to point to the full name
740 returned by the resolver, if this is different to what it is given, unless
741 the returned name starts with "*" as some nameservers seem to be returning
742 wildcards in this form.
745 dnsa pointer to dns_answer structure
746 name domain name to look up
747 type DNS record type (T_A, T_MX, etc)
748 fully_qualified_name if not NULL, return the returned name here if its
749 contents are different (i.e. it must be preset)
751 Returns: DNS_SUCCEED successful lookup
752 DNS_NOMATCH name not found
753 DNS_NODATA no data found
754 DNS_AGAIN soft failure, try again later
759 dns_lookup(dns_answer *dnsa, const uschar *name, int type,
760 uschar **fully_qualified_name)
763 const uschar *orig_name = name;
764 BOOL secure_so_far = TRUE;
766 /* Loop to follow CNAME chains so far, but no further... */
768 for (i = 0; i < 10; i++)
771 dns_record *rr, cname_rr, type_rr;
775 /* DNS lookup failures get passed straight back. */
777 if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED) return rc;
779 /* We should have either records of the required type, or a CNAME record,
780 or both. We need to know whether both exist for getting the fully qualified
781 name, but avoid scanning more than necessary. Note that we must copy the
782 contents of any rr blocks returned by dns_next_rr() as they use the same
783 area in the dnsa block. */
785 cname_rr.data = type_rr.data = NULL;
786 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
788 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
790 if (rr->type == type)
792 if (type_rr.data == NULL) type_rr = *rr;
793 if (cname_rr.data != NULL) break;
795 else if (rr->type == T_CNAME) cname_rr = *rr;
798 /* For the first time round this loop, if a CNAME was found, take the fully
799 qualified name from it; otherwise from the first data record, if present. */
801 if (i == 0 && fully_qualified_name != NULL)
803 if (cname_rr.data != NULL)
805 if (Ustrcmp(cname_rr.name, *fully_qualified_name) != 0 &&
806 cname_rr.name[0] != '*')
807 *fully_qualified_name = string_copy_dnsdomain(cname_rr.name);
809 else if (type_rr.data != NULL)
811 if (Ustrcmp(type_rr.name, *fully_qualified_name) != 0 &&
812 type_rr.name[0] != '*')
813 *fully_qualified_name = string_copy_dnsdomain(type_rr.name);
817 /* If any data records of the correct type were found, we are done. */
819 if (type_rr.data != NULL)
821 if (!secure_so_far) /* mark insecure if any element of CNAME chain was */
822 dns_set_insecure(dnsa);
826 /* If there are no data records, we need to re-scan the DNS using the
827 domain given in the CNAME record, which should exist (otherwise we should
828 have had a failure from dns_lookup). However code against the possibility of
831 if (cname_rr.data == NULL) return DNS_FAIL;
832 datalen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
833 cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
834 if (datalen < 0) return DNS_FAIL;
837 if (!dns_is_secure(dnsa))
838 secure_so_far = FALSE;
840 DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
841 } /* Loop back to do another lookup */
843 /*Control reaches here after 10 times round the CNAME loop. Something isn't
846 log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
855 /************************************************
856 * Do a DNS lookup and handle virtual types *
857 ************************************************/
859 /* This function handles some invented "lookup types" that synthesize feature
860 not available in the basic types. The special types all have negative values.
861 Positive type values are passed straight on to dns_lookup().
864 dnsa pointer to dns_answer structure
865 name domain name to look up
866 type DNS record type (T_A, T_MX, etc or a "special")
867 fully_qualified_name if not NULL, return the returned name here if its
868 contents are different (i.e. it must be preset)
870 Returns: DNS_SUCCEED successful lookup
871 DNS_NOMATCH name not found
872 DNS_NODATA no data found
873 DNS_AGAIN soft failure, try again later
878 dns_special_lookup(dns_answer *dnsa, const uschar *name, int type,
879 uschar **fully_qualified_name)
881 if (type >= 0) return dns_lookup(dnsa, name, type, fully_qualified_name);
883 /* The "mx hosts only" type doesn't require any special action here */
885 if (type == T_MXH) return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
887 /* Find nameservers for the domain or the nearest enclosing zone, excluding the
892 const uschar *d = name;
895 int rc = dns_lookup(dnsa, d, T_NS, fully_qualified_name);
896 if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
897 while (*d != 0 && *d != '.') d++;
898 if (*d++ == 0) break;
903 /* Try to look up the Client SMTP Authorization SRV record for the name. If
904 there isn't one, search from the top downwards for a CSA record in a parent
905 domain, which might be making assertions about subdomains. If we find a record
906 we set fully_qualified_name to whichever lookup succeeded, so that the caller
907 can tell whether to look at the explicit authorization field or the subdomain
912 uschar *srvname, *namesuff, *tld, *p;
913 int priority, weight, port;
919 DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
921 srvname = string_sprintf("_client._smtp.%s", name);
922 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
923 if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
925 if (rc == DNS_SUCCEED) *fully_qualified_name = string_copy(name);
929 /* Search for CSA subdomain assertion SRV records from the top downwards,
930 starting with the 2nd level domain. This order maximizes cache-friendliness.
931 We skip the top level domains to avoid loading their nameservers and because
932 we know they'll never have CSA SRV records. */
934 namesuff = Ustrrchr(name, '.');
935 if (namesuff == NULL) return DNS_NOMATCH;
938 limit = dns_csa_search_limit;
940 /* Use more appropriate search parameters if we are in the reverse DNS. */
942 if (strcmpic(namesuff, US".arpa") == 0)
944 if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
950 else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
959 DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
961 /* Do not perform the search if the top level or 2nd level domains do not
962 exist. This is quite common, and when it occurs all the search queries would
963 go to the root or TLD name servers, which is not friendly. So we check the
964 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
965 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
966 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
967 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
969 if (rc == DNS_NOMATCH)
971 /* This is really gross. The successful return value from res_search() is
972 the packet length, which is stored in dnsa->answerlen. If we get a
973 negative DNS reply then res_search() returns -1, which causes the bounds
974 checks for name decompression to fail when it is treated as a packet
975 length, which in turn causes the authority search to fail. The correct
976 packet length has been lost inside libresolv, so we have to guess a
977 replacement value. (The only way to fix this properly would be to
978 re-implement res_search() and res_query() so that they don't muddle their
979 success and packet length return values.) For added safety we only reset
980 the packet length if the packet header looks plausible. */
982 HEADER *h = (HEADER *)dnsa->answer;
983 if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
984 && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
985 && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
986 && ntohs(h->nscount) >= 1)
987 dnsa->answerlen = MAXPACKET;
989 for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
991 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
992 if (rr->type != T_SOA) continue;
993 else if (strcmpic(rr->name, US"") == 0 ||
994 strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
998 for (i = 0; i < limit; i++)
1002 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1003 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1005 if (namesuff <= name) return DNS_NOMATCH;
1008 /* Find the start of the preceding domain name label. */
1010 if (--namesuff <= name) return DNS_NOMATCH;
1011 while (*namesuff != '.');
1013 DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
1015 srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
1016 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1017 if (rc == DNS_AGAIN) return rc;
1018 if (rc != DNS_SUCCEED) continue;
1020 /* Check that the SRV record we have found is worth returning. We don't
1021 just return the first one we find, because some lower level SRV record
1022 might make stricter assertions than its parent domain. */
1024 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1026 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1028 if (rr->type != T_SRV) continue;
1030 /* Extract the numerical SRV fields (p is incremented) */
1032 GETSHORT(priority, p);
1033 GETSHORT(weight, p); weight = weight; /* compiler quietening */
1036 /* Check the CSA version number */
1037 if (priority != 1) continue;
1039 /* If it's making an interesting assertion, return this response. */
1042 *fully_qualified_name = namesuff + 1;
1050 /* Control should never reach here */
1057 /* Support for A6 records has been commented out since they were demoted to
1058 experimental status at IETF 51. */
1060 #if HAVE_IPV6 && defined(SUPPORT_A6)
1062 /*************************************************
1063 * Search DNS block for prefix RRs *
1064 *************************************************/
1066 /* Called from dns_complete_a6() to search an additional section or a main
1067 answer section for required prefix records to complete an IPv6 address obtained
1068 from an A6 record. For each prefix record, a recursive call to dns_complete_a6
1069 is made, with a new copy of the address so far.
1072 dnsa the DNS answer block
1073 which RESET_ADDITIONAL or RESET_ANSWERS
1074 name name of prefix record
1075 yptrptr pointer to the pointer that points to where to hang the next
1076 dns_address structure
1077 bits number of bits we have already got
1078 bitvec the bits we have already got
1080 Returns: TRUE if any records were found
1084 dns_find_prefix(dns_answer *dnsa, int which, uschar *name, dns_address
1085 ***yptrptr, int bits, uschar *bitvec)
1091 for (rr = dns_next_rr(dnsa, &dnss, which);
1093 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1096 if (rr->type != T_A6 || strcmpic(rr->name, name) != 0) continue;
1098 memcpy(cbitvec, bitvec, sizeof(cbitvec));
1099 dns_complete_a6(yptrptr, dnsa, rr, bits, cbitvec);
1107 /*************************************************
1108 * Follow chains of A6 records *
1109 *************************************************/
1111 /* A6 records may be incomplete, with pointers to other records containing more
1112 bits of the address. There can be a tree structure, leading to a number of
1113 addresses originating from a single initial A6 record.
1116 yptrptr pointer to the pointer that points to where to hang the next
1117 dns_address structure
1118 dnsa the current DNS answer block
1119 rr the RR we have at present
1120 bits number of bits we have already got
1121 bitvec the bits we have already got
1127 dns_complete_a6(dns_address ***yptrptr, dns_answer *dnsa, dns_record *rr,
1128 int bits, uschar *bitvec)
1130 static uschar bitmask[] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 };
1131 uschar *p = (uschar *)(rr->data);
1132 int prefix_len, suffix_len;
1138 /* The prefix length is the first byte. It defines the prefix which is missing
1139 from the data in this record as a number of bits. Zero means this is the end of
1140 a chain. The suffix is the data in this record; only sufficient bytes to hold
1141 it are supplied. There may be zero bytes. We have to ignore trailing bits that
1142 we have already obtained from earlier RRs in the chain. */
1144 prefix_len = *p++; /* bits */
1145 suffix_len = (128 - prefix_len + 7)/8; /* bytes */
1147 /* If the prefix in this record is greater than the prefix in the previous
1148 record in the chain, we have to ignore the record (RFC 2874). */
1150 if (prefix_len > 128 - bits) return;
1152 /* In this little loop, the number of bits up to and including the current byte
1153 is held in k. If we have none of the bits in this byte, we can just or it into
1154 the current data. If we have all of the bits in this byte, we skip it.
1155 Otherwise, some masking has to be done. */
1157 for (i = suffix_len - 1, j = 15, k = 8; i >= 0; i--)
1159 int required = k - bits;
1160 if (required >= 8) bitvec[j] |= p[i];
1161 else if (required > 0) bitvec[j] |= p[i] & bitmask[required];
1162 j--; /* I tried putting these in the "for" statement, but gcc muttered */
1163 k += 8; /* about computed values not being used. */
1166 /* If the prefix_length is zero, we are at the end of a chain. Build a
1167 dns_address item with the current data, hang it onto the end of the chain,
1168 adjust the hanging pointer, and we are done. */
1170 if (prefix_len == 0)
1172 dns_address *new = store_get(sizeof(dns_address) + 50);
1173 inet_ntop(AF_INET6, bitvec, CS new->address, 50);
1176 *yptrptr = &(new->next);
1180 /* Prefix length is not zero. Reset the number of bits that we have collected
1181 so far, and extract the chain name. */
1183 bits = 128 - prefix_len;
1187 while ((i = *p++) != 0)
1189 if (chainptr != chain) *chainptr++ = '.';
1190 memcpy(chainptr, p, i);
1197 /* Now scan the current DNS response record to see if the additional section
1198 contains the records we want. This processing can be cut out for testing
1201 if (dns_find_prefix(dnsa, RESET_ADDITIONAL, chainptr, yptrptr, bits, bitvec))
1204 /* No chain records were found in the current DNS response block. Do a new DNS
1205 lookup to try to find these records. This opens up the possibility of DNS
1206 failures. We ignore them at this point; if all branches of the tree fail, there
1207 will be no addresses at the end. */
1209 if (dns_lookup(&cdnsa, chainptr, T_A6, NULL) == DNS_SUCCEED)
1210 (void)dns_find_prefix(&cdnsa, RESET_ANSWERS, chainptr, yptrptr, bits, bitvec);
1212 #endif /* HAVE_IPV6 && defined(SUPPORT_A6) */
1217 /*************************************************
1218 * Get address(es) from DNS record *
1219 *************************************************/
1221 /* The record type is either T_A for an IPv4 address or T_AAAA (or T_A6 when
1222 supported) for an IPv6 address. In the A6 case, there may be several addresses,
1223 generated by following chains. A recursive function does all the hard work. A6
1224 records now look like passing into history, so the code is only included when
1225 explicitly asked for.
1228 dnsa the DNS answer block
1231 Returns: pointer a chain of dns_address items
1235 dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1237 dns_address *yield = NULL;
1239 #if HAVE_IPV6 && defined(SUPPORT_A6)
1240 dns_address **yieldptr = &yield;
1243 dnsa = dnsa; /* Stop picky compilers warning */
1246 if (rr->type == T_A)
1248 uschar *p = (uschar *)(rr->data);
1249 yield = store_get(sizeof(dns_address) + 20);
1250 (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1257 else if (rr->type == T_A6)
1259 memset(bitvec, 0, sizeof(bitvec));
1260 dns_complete_a6(&yieldptr, dnsa, rr, 0, bitvec);
1262 #endif /* SUPPORT_A6 */
1266 yield = store_get(sizeof(dns_address) + 50);
1267 inet_ntop(AF_INET6, (uschar *)(rr->data), CS yield->address, 50);
1270 #endif /* HAVE_IPV6 */