1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2013 */
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(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
167 dns_init(BOOL qualify_single, BOOL search_parents)
169 res_state resp = os_get_dns_resolver_res();
171 if ((resp->options & RES_INIT) == 0)
173 DEBUG(D_resolver) resp->options |= RES_DEBUG; /* For Cygwin */
174 os_put_dns_resolver_res(resp);
176 DEBUG(D_resolver) resp->options |= RES_DEBUG;
177 os_put_dns_resolver_res(resp);
180 resp->options &= ~(RES_DNSRCH | RES_DEFNAMES);
181 resp->options |= (qualify_single? RES_DEFNAMES : 0) |
182 (search_parents? RES_DNSRCH : 0);
183 if (dns_retrans > 0) resp->retrans = dns_retrans;
184 if (dns_retry > 0) resp->retry = dns_retry;
187 if (dns_use_edns0 >= 0)
190 resp->options |= RES_USE_EDNS0;
192 resp->options &= ~RES_USE_EDNS0;
194 debug_printf("Coerced resolver EDNS0 support %s.\n",
195 dns_use_edns0 ? "on" : "off");
198 if (dns_use_edns0 >= 0)
200 debug_printf("Unable to %sset EDNS0 without resolver support.\n",
201 dns_use_edns0 ? "" : "un");
204 #ifndef DISABLE_DNSSEC
205 # ifdef RES_USE_DNSSEC
206 # ifndef RES_USE_EDNS0
207 # error Have RES_USE_DNSSEC but not RES_USE_EDNS0? Something hinky ...
209 if (dns_dnssec_ok >= 0)
211 if (dns_use_edns0 == 0 && dns_dnssec_ok != 0)
214 debug_printf("CONFLICT: dns_use_edns0 forced false, dns_dnssec_ok forced true, ignoring latter!\n");
219 resp->options |= RES_USE_DNSSEC;
221 resp->options &= ~RES_USE_DNSSEC;
222 DEBUG(D_resolver) debug_printf("Coerced resolver DNSSEC support %s.\n",
223 dns_dnssec_ok ? "on" : "off");
227 if (dns_dnssec_ok >= 0)
229 debug_printf("Unable to %sset DNSSEC without resolver support.\n",
230 dns_dnssec_ok ? "" : "un");
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(uschar *string, uschar *buffer)
256 uschar *p = string + Ustrlen(string);
259 /* Handle IPv4 address */
262 if (Ustrchr(string, ':') == NULL)
266 for (i = 0; i < 4; i++)
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(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;
455 /*************************************************
456 * Turn DNS type into text *
457 *************************************************/
459 /* Turn the coded record type into a string for printing. All those that Exim
460 uses should be included here.
462 Argument: record type
463 Returns: pointer to string
471 case T_A: return US"A";
472 case T_MX: return US"MX";
473 case T_AAAA: return US"AAAA";
474 case T_A6: return US"A6";
475 case T_TXT: return US"TXT";
476 case T_SPF: return US"SPF";
477 case T_PTR: return US"PTR";
478 case T_SOA: return US"SOA";
479 case T_SRV: return US"SRV";
480 case T_NS: return US"NS";
481 case T_CNAME: return US"CNAME";
482 case T_TLSA: return US"TLSA";
483 default: return US"?";
489 /*************************************************
490 * Cache a failed DNS lookup result *
491 *************************************************/
493 /* We cache failed lookup results so as not to experience timeouts many
494 times for the same domain. We need to retain the resolver options because they
495 may change. For successful lookups, we rely on resolver and/or name server
503 Returns: the return code
507 dns_return(uschar *name, int type, int rc)
509 res_state resp = os_get_dns_resolver_res();
510 tree_node *node = store_get_perm(sizeof(tree_node) + 290);
511 sprintf(CS node->name, "%.255s-%s-%lx", name, dns_text_type(type),
514 (void)tree_insertnode(&tree_dns_fails, node);
520 /*************************************************
521 * Do basic DNS lookup *
522 *************************************************/
524 /* Call the resolver to look up the given domain name, using the given type,
525 and check the result. The error code TRY_AGAIN is documented as meaning "non-
526 Authoritive Host not found, or SERVERFAIL". Sometimes there are badly set
527 up nameservers that produce this error continually, so there is the option of
528 providing a list of domains for which this is treated as a non-existent
532 dnsa pointer to dns_answer structure
534 type type of DNS record required (T_A, T_MX, etc)
536 Returns: DNS_SUCCEED successful lookup
537 DNS_NOMATCH name not found (NXDOMAIN)
538 or name contains illegal characters (if checking)
539 or name is an IP address (for IP address lookup)
540 DNS_NODATA domain exists, but no data for this type (NODATA)
541 DNS_AGAIN soft failure, try again later
546 dns_basic_lookup(dns_answer *dnsa, uschar *name, int type)
552 res_state resp = os_get_dns_resolver_res();
555 uschar node_name[290];
557 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
558 a timeout on one domain doesn't happen time and time again for messages that
559 have many addresses in the same domain. We rely on the resolver and name server
560 caching for successful lookups. */
562 sprintf(CS node_name, "%.255s-%s-%lx", name, dns_text_type(type),
564 previous = tree_search(tree_dns_fails, node_name);
565 if (previous != NULL)
567 DEBUG(D_dns) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
568 name, dns_text_type(type),
569 (previous->data.val == DNS_NOMATCH)? "DNS_NOMATCH" :
570 (previous->data.val == DNS_NODATA)? "DNS_NODATA" :
571 (previous->data.val == DNS_AGAIN)? "DNS_AGAIN" :
572 (previous->data.val == DNS_FAIL)? "DNS_FAIL" : "??");
573 return previous->data.val;
576 /* If configured, check the hygene of the name passed to lookup. Otherwise,
577 although DNS lookups may give REFUSED at the lower level, some resolvers
578 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
579 domains cannot be in the DNS. The check is now done by a regular expression;
580 give it space for substring storage to save it having to get its own if the
581 regex has substrings that are used - the default uses a conditional.
583 This test is omitted for PTR records. These occur only in calls from the dnsdb
584 lookup, which constructs the names itself, so they should be OK. Besides,
585 bitstring labels don't conform to normal name syntax. (But the aren't used any
588 For SRV records, we omit the initial _smtp._tcp. components at the start. */
590 #ifndef STAND_ALONE /* Omit this for stand-alone tests */
592 if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
594 uschar *checkname = name;
595 int ovector[3*(EXPAND_MAXN+1)];
597 if (regex_check_dns_names == NULL)
598 regex_check_dns_names =
599 regex_must_compile(check_dns_names_pattern, FALSE, TRUE);
601 /* For an SRV lookup, skip over the first two components (the service and
602 protocol names, which both start with an underscore). */
606 while (*checkname++ != '.');
607 while (*checkname++ != '.');
610 if (pcre_exec(regex_check_dns_names, NULL, CS checkname, Ustrlen(checkname),
611 0, PCRE_EOPT, ovector, sizeof(ovector)/sizeof(int)) < 0)
614 debug_printf("DNS name syntax check failed: %s (%s)\n", name,
615 dns_text_type(type));
616 host_find_failed_syntax = TRUE;
621 #endif /* STAND_ALONE */
623 /* Call the resolver; for an overlong response, res_search() will return the
624 number of bytes the message would need, so we need to check for this case. The
625 effect is to truncate overlong data.
627 On some systems, res_search() will recognize "A-for-A" queries and return
628 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
629 nameservers are also believed to do this. It is, of course, contrary to the
630 specification of the DNS, so we lock it out. */
636 type == T_A || type == T_AAAA) &&
637 string_is_ip_address(name, NULL) != 0)
640 /* If we are running in the test harness, instead of calling the normal resolver
641 (res_search), we call fakens_search(), which recognizes certain special
642 domains, and interfaces to a fake nameserver for certain special zones. */
644 if (running_in_test_harness)
645 dnsa->answerlen = fakens_search(name, type, dnsa->answer, MAXPACKET);
647 dnsa->answerlen = res_search(CS name, C_IN, type, dnsa->answer, MAXPACKET);
649 if (dnsa->answerlen > MAXPACKET)
651 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet (size %d), truncating to %d.\n",
652 name, dns_text_type(type), dnsa->answerlen, MAXPACKET);
653 dnsa->answerlen = MAXPACKET;
656 if (dnsa->answerlen < 0) switch (h_errno)
659 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
660 "returning DNS_NOMATCH\n", name, dns_text_type(type));
661 return dns_return(name, type, DNS_NOMATCH);
664 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
665 name, dns_text_type(type));
667 /* Cut this out for various test programs */
669 save = deliver_domain;
670 deliver_domain = name; /* set $domain */
671 rc = match_isinlist(name, &dns_again_means_nonexist, 0, NULL, NULL,
672 MCL_DOMAIN, TRUE, NULL);
673 deliver_domain = save;
676 DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
677 return dns_return(name, type, DNS_AGAIN);
679 DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
680 "DNS_NOMATCH\n", name);
681 return dns_return(name, type, DNS_NOMATCH);
683 #else /* For stand-alone tests */
684 return dns_return(name, type, DNS_AGAIN);
688 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
689 "returning DNS_FAIL\n", name, dns_text_type(type));
690 return dns_return(name, type, DNS_FAIL);
693 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
694 "returning DNS_NODATA\n", name, dns_text_type(type));
695 return dns_return(name, type, DNS_NODATA);
698 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
699 "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
700 return dns_return(name, type, DNS_FAIL);
703 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
704 name, dns_text_type(type));
712 /************************************************
713 * Do a DNS lookup and handle CNAMES *
714 ************************************************/
716 /* Look up the given domain name, using the given type. Follow CNAMEs if
717 necessary, but only so many times. There aren't supposed to be CNAME chains in
718 the DNS, but you are supposed to cope with them if you find them.
720 The assumption is made that if the resolver gives back records of the
721 requested type *and* a CNAME, we don't need to make another call to look up
722 the CNAME. I can't see how it could return only some of the right records. If
723 it's done a CNAME lookup in the past, it will have all of them; if not, it
726 If fully_qualified_name is not NULL, set it to point to the full name
727 returned by the resolver, if this is different to what it is given, unless
728 the returned name starts with "*" as some nameservers seem to be returning
729 wildcards in this form.
732 dnsa pointer to dns_answer structure
733 name domain name to look up
734 type DNS record type (T_A, T_MX, etc)
735 fully_qualified_name if not NULL, return the returned name here if its
736 contents are different (i.e. it must be preset)
738 Returns: DNS_SUCCEED successful lookup
739 DNS_NOMATCH name not found
740 DNS_NODATA no data found
741 DNS_AGAIN soft failure, try again later
746 dns_lookup(dns_answer *dnsa, uschar *name, int type, uschar **fully_qualified_name)
749 uschar *orig_name = name;
751 /* Loop to follow CNAME chains so far, but no further... */
753 for (i = 0; i < 10; i++)
756 dns_record *rr, cname_rr, type_rr;
760 /* DNS lookup failures get passed straight back. */
762 if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED) return rc;
764 /* We should have either records of the required type, or a CNAME record,
765 or both. We need to know whether both exist for getting the fully qualified
766 name, but avoid scanning more than necessary. Note that we must copy the
767 contents of any rr blocks returned by dns_next_rr() as they use the same
768 area in the dnsa block. */
770 cname_rr.data = type_rr.data = NULL;
771 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
773 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
775 if (rr->type == type)
777 if (type_rr.data == NULL) type_rr = *rr;
778 if (cname_rr.data != NULL) break;
780 else if (rr->type == T_CNAME) cname_rr = *rr;
783 /* For the first time round this loop, if a CNAME was found, take the fully
784 qualified name from it; otherwise from the first data record, if present. */
786 if (i == 0 && fully_qualified_name != NULL)
788 if (cname_rr.data != NULL)
790 if (Ustrcmp(cname_rr.name, *fully_qualified_name) != 0 &&
791 cname_rr.name[0] != '*')
792 *fully_qualified_name = string_copy_dnsdomain(cname_rr.name);
794 else if (type_rr.data != NULL)
796 if (Ustrcmp(type_rr.name, *fully_qualified_name) != 0 &&
797 type_rr.name[0] != '*')
798 *fully_qualified_name = string_copy_dnsdomain(type_rr.name);
802 /* If any data records of the correct type were found, we are done. */
804 if (type_rr.data != NULL) return DNS_SUCCEED;
806 /* If there are no data records, we need to re-scan the DNS using the
807 domain given in the CNAME record, which should exist (otherwise we should
808 have had a failure from dns_lookup). However code against the possibility of
811 if (cname_rr.data == NULL) return DNS_FAIL;
812 datalen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
813 cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, 256);
814 if (datalen < 0) return DNS_FAIL;
817 DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
818 } /* Loop back to do another lookup */
820 /*Control reaches here after 10 times round the CNAME loop. Something isn't
823 log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
832 /************************************************
833 * Do a DNS lookup and handle virtual types *
834 ************************************************/
836 /* This function handles some invented "lookup types" that synthesize feature
837 not available in the basic types. The special types all have negative values.
838 Positive type values are passed straight on to dns_lookup().
841 dnsa pointer to dns_answer structure
842 name domain name to look up
843 type DNS record type (T_A, T_MX, etc or a "special")
844 fully_qualified_name if not NULL, return the returned name here if its
845 contents are different (i.e. it must be preset)
847 Returns: DNS_SUCCEED successful lookup
848 DNS_NOMATCH name not found
849 DNS_NODATA no data found
850 DNS_AGAIN soft failure, try again later
855 dns_special_lookup(dns_answer *dnsa, uschar *name, int type,
856 uschar **fully_qualified_name)
858 if (type >= 0) return dns_lookup(dnsa, name, type, fully_qualified_name);
860 /* The "mx hosts only" type doesn't require any special action here */
862 if (type == T_MXH) return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
864 /* Find nameservers for the domain or the nearest enclosing zone, excluding the
872 int rc = dns_lookup(dnsa, d, T_NS, fully_qualified_name);
873 if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
874 while (*d != 0 && *d != '.') d++;
875 if (*d++ == 0) break;
880 /* Try to look up the Client SMTP Authorization SRV record for the name. If
881 there isn't one, search from the top downwards for a CSA record in a parent
882 domain, which might be making assertions about subdomains. If we find a record
883 we set fully_qualified_name to whichever lookup succeeded, so that the caller
884 can tell whether to look at the explicit authorization field or the subdomain
889 uschar *srvname, *namesuff, *tld, *p;
890 int priority, weight, port;
896 DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
898 srvname = string_sprintf("_client._smtp.%s", name);
899 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
900 if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
902 if (rc == DNS_SUCCEED) *fully_qualified_name = name;
906 /* Search for CSA subdomain assertion SRV records from the top downwards,
907 starting with the 2nd level domain. This order maximizes cache-friendliness.
908 We skip the top level domains to avoid loading their nameservers and because
909 we know they'll never have CSA SRV records. */
911 namesuff = Ustrrchr(name, '.');
912 if (namesuff == NULL) return DNS_NOMATCH;
915 limit = dns_csa_search_limit;
917 /* Use more appropriate search parameters if we are in the reverse DNS. */
919 if (strcmpic(namesuff, US".arpa") == 0)
921 if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
927 else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
936 DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
938 /* Do not perform the search if the top level or 2nd level domains do not
939 exist. This is quite common, and when it occurs all the search queries would
940 go to the root or TLD name servers, which is not friendly. So we check the
941 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
942 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
943 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
944 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
946 if (rc == DNS_NOMATCH)
948 /* This is really gross. The successful return value from res_search() is
949 the packet length, which is stored in dnsa->answerlen. If we get a
950 negative DNS reply then res_search() returns -1, which causes the bounds
951 checks for name decompression to fail when it is treated as a packet
952 length, which in turn causes the authority search to fail. The correct
953 packet length has been lost inside libresolv, so we have to guess a
954 replacement value. (The only way to fix this properly would be to
955 re-implement res_search() and res_query() so that they don't muddle their
956 success and packet length return values.) For added safety we only reset
957 the packet length if the packet header looks plausible. */
959 HEADER *h = (HEADER *)dnsa->answer;
960 if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
961 && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
962 && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
963 && ntohs(h->nscount) >= 1)
964 dnsa->answerlen = MAXPACKET;
966 for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
968 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
969 if (rr->type != T_SOA) continue;
970 else if (strcmpic(rr->name, US"") == 0 ||
971 strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
975 for (i = 0; i < limit; i++)
979 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
980 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
982 if (namesuff <= name) return DNS_NOMATCH;
985 /* Find the start of the preceding domain name label. */
987 if (--namesuff <= name) return DNS_NOMATCH;
988 while (*namesuff != '.');
990 DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
992 srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
993 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
994 if (rc == DNS_AGAIN) return rc;
995 if (rc != DNS_SUCCEED) continue;
997 /* Check that the SRV record we have found is worth returning. We don't
998 just return the first one we find, because some lower level SRV record
999 might make stricter assertions than its parent domain. */
1001 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1003 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1005 if (rr->type != T_SRV) continue;
1007 /* Extract the numerical SRV fields (p is incremented) */
1009 GETSHORT(priority, p);
1010 GETSHORT(weight, p);
1013 /* Check the CSA version number */
1014 if (priority != 1) continue;
1016 /* If it's making an interesting assertion, return this response. */
1019 *fully_qualified_name = namesuff + 1;
1027 /* Control should never reach here */
1034 /* Support for A6 records has been commented out since they were demoted to
1035 experimental status at IETF 51. */
1037 #if HAVE_IPV6 && defined(SUPPORT_A6)
1039 /*************************************************
1040 * Search DNS block for prefix RRs *
1041 *************************************************/
1043 /* Called from dns_complete_a6() to search an additional section or a main
1044 answer section for required prefix records to complete an IPv6 address obtained
1045 from an A6 record. For each prefix record, a recursive call to dns_complete_a6
1046 is made, with a new copy of the address so far.
1049 dnsa the DNS answer block
1050 which RESET_ADDITIONAL or RESET_ANSWERS
1051 name name of prefix record
1052 yptrptr pointer to the pointer that points to where to hang the next
1053 dns_address structure
1054 bits number of bits we have already got
1055 bitvec the bits we have already got
1057 Returns: TRUE if any records were found
1061 dns_find_prefix(dns_answer *dnsa, int which, uschar *name, dns_address
1062 ***yptrptr, int bits, uschar *bitvec)
1068 for (rr = dns_next_rr(dnsa, &dnss, which);
1070 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1073 if (rr->type != T_A6 || strcmpic(rr->name, name) != 0) continue;
1075 memcpy(cbitvec, bitvec, sizeof(cbitvec));
1076 dns_complete_a6(yptrptr, dnsa, rr, bits, cbitvec);
1084 /*************************************************
1085 * Follow chains of A6 records *
1086 *************************************************/
1088 /* A6 records may be incomplete, with pointers to other records containing more
1089 bits of the address. There can be a tree structure, leading to a number of
1090 addresses originating from a single initial A6 record.
1093 yptrptr pointer to the pointer that points to where to hang the next
1094 dns_address structure
1095 dnsa the current DNS answer block
1096 rr the RR we have at present
1097 bits number of bits we have already got
1098 bitvec the bits we have already got
1104 dns_complete_a6(dns_address ***yptrptr, dns_answer *dnsa, dns_record *rr,
1105 int bits, uschar *bitvec)
1107 static uschar bitmask[] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 };
1108 uschar *p = (uschar *)(rr->data);
1109 int prefix_len, suffix_len;
1115 /* The prefix length is the first byte. It defines the prefix which is missing
1116 from the data in this record as a number of bits. Zero means this is the end of
1117 a chain. The suffix is the data in this record; only sufficient bytes to hold
1118 it are supplied. There may be zero bytes. We have to ignore trailing bits that
1119 we have already obtained from earlier RRs in the chain. */
1121 prefix_len = *p++; /* bits */
1122 suffix_len = (128 - prefix_len + 7)/8; /* bytes */
1124 /* If the prefix in this record is greater than the prefix in the previous
1125 record in the chain, we have to ignore the record (RFC 2874). */
1127 if (prefix_len > 128 - bits) return;
1129 /* In this little loop, the number of bits up to and including the current byte
1130 is held in k. If we have none of the bits in this byte, we can just or it into
1131 the current data. If we have all of the bits in this byte, we skip it.
1132 Otherwise, some masking has to be done. */
1134 for (i = suffix_len - 1, j = 15, k = 8; i >= 0; i--)
1136 int required = k - bits;
1137 if (required >= 8) bitvec[j] |= p[i];
1138 else if (required > 0) bitvec[j] |= p[i] & bitmask[required];
1139 j--; /* I tried putting these in the "for" statement, but gcc muttered */
1140 k += 8; /* about computed values not being used. */
1143 /* If the prefix_length is zero, we are at the end of a chain. Build a
1144 dns_address item with the current data, hang it onto the end of the chain,
1145 adjust the hanging pointer, and we are done. */
1147 if (prefix_len == 0)
1149 dns_address *new = store_get(sizeof(dns_address) + 50);
1150 inet_ntop(AF_INET6, bitvec, CS new->address, 50);
1153 *yptrptr = &(new->next);
1157 /* Prefix length is not zero. Reset the number of bits that we have collected
1158 so far, and extract the chain name. */
1160 bits = 128 - prefix_len;
1164 while ((i = *p++) != 0)
1166 if (chainptr != chain) *chainptr++ = '.';
1167 memcpy(chainptr, p, i);
1174 /* Now scan the current DNS response record to see if the additional section
1175 contains the records we want. This processing can be cut out for testing
1178 if (dns_find_prefix(dnsa, RESET_ADDITIONAL, chainptr, yptrptr, bits, bitvec))
1181 /* No chain records were found in the current DNS response block. Do a new DNS
1182 lookup to try to find these records. This opens up the possibility of DNS
1183 failures. We ignore them at this point; if all branches of the tree fail, there
1184 will be no addresses at the end. */
1186 if (dns_lookup(&cdnsa, chainptr, T_A6, NULL) == DNS_SUCCEED)
1187 (void)dns_find_prefix(&cdnsa, RESET_ANSWERS, chainptr, yptrptr, bits, bitvec);
1189 #endif /* HAVE_IPV6 && defined(SUPPORT_A6) */
1194 /*************************************************
1195 * Get address(es) from DNS record *
1196 *************************************************/
1198 /* The record type is either T_A for an IPv4 address or T_AAAA (or T_A6 when
1199 supported) for an IPv6 address. In the A6 case, there may be several addresses,
1200 generated by following chains. A recursive function does all the hard work. A6
1201 records now look like passing into history, so the code is only included when
1202 explicitly asked for.
1205 dnsa the DNS answer block
1208 Returns: pointer a chain of dns_address items
1212 dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1214 dns_address *yield = NULL;
1216 #if HAVE_IPV6 && defined(SUPPORT_A6)
1217 dns_address **yieldptr = &yield;
1220 dnsa = dnsa; /* Stop picky compilers warning */
1223 if (rr->type == T_A)
1225 uschar *p = (uschar *)(rr->data);
1226 yield = store_get(sizeof(dns_address) + 20);
1227 (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1234 else if (rr->type == T_A6)
1236 memset(bitvec, 0, sizeof(bitvec));
1237 dns_complete_a6(&yieldptr, dnsa, rr, 0, bitvec);
1239 #endif /* SUPPORT_A6 */
1243 yield = store_get(sizeof(dns_address) + 50);
1244 inet_ntop(AF_INET6, (uschar *)(rr->data), CS yield->address, 50);
1247 #endif /* HAVE_IPV6 */