6ef6b7784b03343bff3a2b3fae635577d8300d37
[exim.git] / src / src / dns.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Functions for interfacing with the DNS. */
9
10 #include "exim.h"
11
12
13
14 /*************************************************
15 *               Fake DNS resolver                *
16 *************************************************/
17
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.
24
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
27 code supports both.
28
29 Arguments:
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
34
35 Returns:      length of returned data, or -1 on error (h_errno set)
36 */
37
38 static int
39 fakens_search(const uschar *domain, int type, uschar *answerptr, int size)
40 {
41 int len = Ustrlen(domain);
42 int asize = size;                  /* Locally modified */
43 uschar name[256];
44 uschar utilname[256];
45 uschar *aptr = answerptr;          /* Locally modified */
46 struct stat statbuf;
47
48 /* Remove terminating dot. */
49
50 if (domain[len - 1] == '.') len--;
51 Ustrncpy(name, domain, len);
52 name[len] = 0;
53
54 /* Look for the fakens utility, and if it exists, call it. */
55
56 (void)string_format(utilname, sizeof(utilname), "%s/bin/fakens",
57   config_main_directory);
58
59 if (stat(CS utilname, &statbuf) >= 0)
60   {
61   pid_t pid;
62   int infd, outfd, rc;
63   uschar *argv[5];
64
65   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) using fakens\n", name, dns_text_type(type));
66
67   argv[0] = utilname;
68   argv[1] = config_main_directory;
69   argv[2] = name;
70   argv[3] = dns_text_type(type);
71   argv[4] = NULL;
72
73   pid = child_open(argv, NULL, 0000, &infd, &outfd, FALSE);
74   if (pid < 0)
75     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to run fakens: %s",
76       strerror(errno));
77
78   len = 0;
79   rc = -1;
80   while (asize > 0 && (rc = read(outfd, aptr, asize)) > 0)
81     {
82     len += rc;
83     aptr += rc;       /* Don't modify the actual arguments, because they */
84     asize -= rc;      /* may need to be passed on to res_search(). */
85     }
86
87   /* If we ran out of output buffer before exhausting the return,
88   carry on reading and counting it. */
89
90   if (asize == 0)
91     while ((rc = read(outfd, name, sizeof(name))) > 0)
92       len += rc;
93
94   if (rc < 0)
95     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "read from fakens failed: %s",
96       strerror(errno));
97
98   switch(child_close(pid, 0))
99     {
100     case 0: return len;
101     case 1: h_errno = HOST_NOT_FOUND; return -1;
102     case 2: h_errno = TRY_AGAIN; return -1;
103     default:
104     case 3: h_errno = NO_RECOVERY; return -1;
105     case 4: h_errno = NO_DATA; return -1;
106     case 5: /* Pass on to res_search() */
107     DEBUG(D_dns) debug_printf("fakens returned PASS_ON\n");
108     }
109   }
110 else
111   {
112   DEBUG(D_dns) debug_printf("fakens (%s) not found\n", utilname);
113   }
114
115 /* fakens utility not found, or it returned "pass on" */
116
117 DEBUG(D_dns) debug_printf("passing %s on to res_search()\n", domain);
118
119 return res_search(CS domain, C_IN, type, answerptr, size);
120 }
121
122
123
124 /*************************************************
125 *        Initialize and configure resolver       *
126 *************************************************/
127
128 /* Initialize the resolver and the storage for holding DNS answers if this is
129 the first time we have been here, and set the resolver options.
130
131 Arguments:
132   qualify_single    TRUE to set the RES_DEFNAMES option
133   search_parents    TRUE to set the RES_DNSRCH option
134   use_dnssec        TRUE to set the RES_USE_DNSSEC option
135
136 Returns:            nothing
137 */
138
139 void
140 dns_init(BOOL qualify_single, BOOL search_parents, BOOL use_dnssec)
141 {
142 res_state resp = os_get_dns_resolver_res();
143
144 if ((resp->options & RES_INIT) == 0)
145   {
146   DEBUG(D_resolver) resp->options |= RES_DEBUG;     /* For Cygwin */
147   os_put_dns_resolver_res(resp);
148   res_init();
149   DEBUG(D_resolver) resp->options |= RES_DEBUG;
150   os_put_dns_resolver_res(resp);
151   }
152
153 resp->options &= ~(RES_DNSRCH | RES_DEFNAMES);
154 resp->options |= (qualify_single? RES_DEFNAMES : 0) |
155                 (search_parents? RES_DNSRCH : 0);
156 if (dns_retrans > 0) resp->retrans = dns_retrans;
157 if (dns_retry > 0) resp->retry = dns_retry;
158
159 #ifdef RES_USE_EDNS0
160 if (dns_use_edns0 >= 0)
161   {
162   if (dns_use_edns0)
163     resp->options |= RES_USE_EDNS0;
164   else
165     resp->options &= ~RES_USE_EDNS0;
166   DEBUG(D_resolver)
167     debug_printf("Coerced resolver EDNS0 support %s.\n",
168         dns_use_edns0 ? "on" : "off");
169   }
170 #else
171 if (dns_use_edns0 >= 0)
172   DEBUG(D_resolver)
173     debug_printf("Unable to %sset EDNS0 without resolver support.\n",
174         dns_use_edns0 ? "" : "un");
175 #endif
176
177 #ifndef DISABLE_DNSSEC
178 # ifdef RES_USE_DNSSEC
179 #  ifndef RES_USE_EDNS0
180 #   error Have RES_USE_DNSSEC but not RES_USE_EDNS0?  Something hinky ...
181 #  endif
182 if (use_dnssec)
183   resp->options |= RES_USE_DNSSEC;
184 if (dns_dnssec_ok >= 0)
185   {
186   if (dns_use_edns0 == 0 && dns_dnssec_ok != 0)
187     {
188     DEBUG(D_resolver)
189       debug_printf("CONFLICT: dns_use_edns0 forced false, dns_dnssec_ok forced true, ignoring latter!\n");
190     }
191   else
192     {
193     if (dns_dnssec_ok)
194       resp->options |= RES_USE_DNSSEC;
195     else
196       resp->options &= ~RES_USE_DNSSEC;
197     DEBUG(D_resolver) debug_printf("Coerced resolver DNSSEC support %s.\n",
198         dns_dnssec_ok ? "on" : "off");
199     }
200   }
201 # else
202 if (dns_dnssec_ok >= 0)
203   DEBUG(D_resolver)
204     debug_printf("Unable to %sset DNSSEC without resolver support.\n",
205         dns_dnssec_ok ? "" : "un");
206 if (use_dnssec)
207   DEBUG(D_resolver)
208     debug_printf("Unable to set DNSSEC without resolver support.\n");
209 # endif
210 #endif /* DISABLE_DNSSEC */
211
212 os_put_dns_resolver_res(resp);
213 }
214
215
216
217 /*************************************************
218 *       Build key name for PTR records           *
219 *************************************************/
220
221 /* This function inverts an IP address and adds the relevant domain, to produce
222 a name that can be used to look up PTR records.
223
224 Arguments:
225   string     the IP address as a string
226   buffer     a suitable buffer, long enough to hold the result
227
228 Returns:     nothing
229 */
230
231 void
232 dns_build_reverse(const uschar *string, uschar *buffer)
233 {
234 const uschar *p = string + Ustrlen(string);
235 uschar *pp = buffer;
236
237 /* Handle IPv4 address */
238
239 #if HAVE_IPV6
240 if (Ustrchr(string, ':') == NULL)
241 #endif
242   {
243   for (int i = 0; i < 4; i++)
244     {
245     const uschar *ppp = p;
246     while (ppp > string && ppp[-1] != '.') ppp--;
247     Ustrncpy(pp, ppp, p - ppp);
248     pp += p - ppp;
249     *pp++ = '.';
250     p = ppp - 1;
251     }
252   Ustrcpy(pp, "in-addr.arpa");
253   }
254
255 /* Handle IPv6 address; convert to binary so as to fill out any
256 abbreviation in the textual form. */
257
258 #if HAVE_IPV6
259 else
260   {
261   int v6[4];
262   (void)host_aton(string, v6);
263
264   /* The original specification for IPv6 reverse lookup was to invert each
265   nibble, and look in the ip6.int domain. The domain was subsequently
266   changed to ip6.arpa. */
267
268   for (int i = 3; i >= 0; i--)
269     for (int j = 0; j < 32; j += 4)
270       pp += sprintf(CS pp, "%x.", (v6[i] >> j) & 15);
271   Ustrcpy(pp, "ip6.arpa.");
272
273   /* Another way of doing IPv6 reverse lookups was proposed in conjunction
274   with A6 records. However, it fell out of favour when they did. The
275   alternative was to construct a binary key, and look in ip6.arpa. I tried
276   to make this code do that, but I could not make it work on Solaris 8. The
277   resolver seems to lose the initial backslash somehow. However, now that
278   this style of reverse lookup has been dropped, it doesn't matter. These
279   lines are left here purely for historical interest. */
280
281   /**************************************************
282   Ustrcpy(pp, "\\[x");
283   pp += 3;
284
285   for (int i = 0; i < 4; i++)
286     {
287     sprintf(pp, "%08X", v6[i]);
288     pp += 8;
289     }
290   Ustrcpy(pp, "].ip6.arpa.");
291   **************************************************/
292
293   }
294 #endif
295 }
296
297
298
299
300 /* Increment the aptr in dnss, checking against dnsa length.
301 Return: TRUE for a bad result
302 */
303 static BOOL
304 dnss_inc_aptr(const dns_answer * dnsa, dns_scan * dnss, unsigned delta)
305 {
306 return (dnss->aptr += delta) >= dnsa->answer + dnsa->answerlen;
307 }
308
309 /*************************************************
310 *       Get next DNS record from answer block    *
311 *************************************************/
312
313 /* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
314 RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
315 scan the additional records, and reset == RESET_NEXT to get the next record.
316 The result is in static storage which must be copied if it is to be preserved.
317
318 Arguments:
319   dnsa      pointer to dns answer block
320   dnss      pointer to dns scan block
321   reset     option specifying what portion to scan, as described above
322
323 Returns:    next dns record, or NULL when no more
324 */
325
326 dns_record *
327 dns_next_rr(const dns_answer *dnsa, dns_scan *dnss, int reset)
328 {
329 const HEADER * h = (const HEADER *)dnsa->answer;
330 int namelen;
331
332 char * trace = NULL;
333 #ifdef rr_trace
334 # define TRACE DEBUG(D_dns)
335 #else
336 trace = trace;
337 # define TRACE if (FALSE)
338 #endif
339
340 /* Reset the saved data when requested to, and skip to the first required RR */
341
342 if (reset != RESET_NEXT)
343   {
344   dnss->rrcount = ntohs(h->qdcount);
345   TRACE debug_printf("%s: reset (Q rrcount %d)\n", __FUNCTION__, dnss->rrcount);
346   dnss->aptr = dnsa->answer + sizeof(HEADER);
347
348   /* Skip over questions; failure to expand the name just gives up */
349
350   while (dnss->rrcount-- > 0)
351     {
352     TRACE trace = "Q-namelen";
353     namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
354       dnss->aptr, (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
355     if (namelen < 0) goto null_return;
356     /* skip name & type & class */
357     TRACE trace = "Q-skip";
358     if (dnss_inc_aptr(dnsa, dnss, namelen+4)) goto null_return;
359     }
360
361   /* Get the number of answer records. */
362
363   dnss->rrcount = ntohs(h->ancount);
364   TRACE debug_printf("%s: reset (A rrcount %d)\n", __FUNCTION__, dnss->rrcount);
365
366   /* Skip over answers if we want to look at the authority section. Also skip
367   the NS records (i.e. authority section) if wanting to look at the additional
368   records. */
369
370   if (reset == RESET_ADDITIONAL)
371     {
372     TRACE debug_printf("%s: additional\n", __FUNCTION__);
373     dnss->rrcount += ntohs(h->nscount);
374     TRACE debug_printf("%s: reset (NS rrcount %d)\n", __FUNCTION__, dnss->rrcount);
375     }
376
377   if (reset == RESET_AUTHORITY || reset == RESET_ADDITIONAL)
378     {
379     TRACE if (reset == RESET_AUTHORITY)
380       debug_printf("%s: authority\n", __FUNCTION__);
381     while (dnss->rrcount-- > 0)
382       {
383       TRACE trace = "A-namelen";
384       namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
385         dnss->aptr, (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
386       if (namelen < 0) goto null_return;
387       /* skip name, type, class & TTL */
388       TRACE trace = "A-hdr";
389       if (dnss_inc_aptr(dnsa, dnss, namelen+8)) goto null_return;
390       GETSHORT(dnss->srr.size, dnss->aptr); /* size of data portion */
391       /* skip over it */
392       TRACE trace = "A-skip";
393       if (dnss_inc_aptr(dnsa, dnss, dnss->srr.size)) goto null_return;
394       }
395     dnss->rrcount = reset == RESET_AUTHORITY
396       ? ntohs(h->nscount) : ntohs(h->arcount);
397     TRACE debug_printf("%s: reset (%s rrcount %d)\n", __FUNCTION__,
398       reset == RESET_AUTHORITY ? "NS" : "AR", dnss->rrcount);
399     }
400   TRACE debug_printf("%s: %d RRs to read\n", __FUNCTION__, dnss->rrcount);
401   }
402 else
403   TRACE debug_printf("%s: next (%d left)\n", __FUNCTION__, dnss->rrcount);
404
405 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
406 contains the number of RR records left. */
407
408 if (dnss->rrcount-- <= 0) return NULL;
409
410 /* If expanding the RR domain name fails, behave as if no more records
411 (something safe). */
412
413 TRACE trace = "R-namelen";
414 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, dnss->aptr,
415   (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
416 if (namelen < 0) goto null_return;
417
418 /* Move the pointer past the name and fill in the rest of the data structure
419 from the following bytes. */
420
421 TRACE trace = "R-name";
422 if (dnss_inc_aptr(dnsa, dnss, namelen)) goto null_return;
423
424 GETSHORT(dnss->srr.type, dnss->aptr);           /* Record type */
425 TRACE trace = "R-class";
426 if (dnss_inc_aptr(dnsa, dnss, 2)) goto null_return;     /* Don't want class */
427 GETLONG(dnss->srr.ttl, dnss->aptr);             /* TTL */
428 GETSHORT(dnss->srr.size, dnss->aptr);           /* Size of data portion */
429 dnss->srr.data = dnss->aptr;                    /* The record's data follows */
430
431 /* Unchecked increment ok here since no further access on this iteration;
432 will be checked on next at "R-name". */
433
434 dnss->aptr += dnss->srr.size;                   /* Advance to next RR */
435
436 /* Return a pointer to the dns_record structure within the dns_answer. This is
437 for convenience so that the scans can use nice-looking for loops. */
438
439 return &dnss->srr;
440
441 null_return:
442   TRACE debug_printf("%s: terminate (%d RRs left). Last op: %s; errno %d %s\n",
443     __FUNCTION__, dnss->rrcount, trace, errno, strerror(errno));
444   dnss->rrcount = 0;
445   return NULL;
446 }
447
448
449 /* Extract the AUTHORITY information from the answer. If the answer isn't
450 authoritative (AA not set), we do not extract anything.
451
452 The AUTHORITY section contains NS records if the name in question was found,
453 it contains a SOA record otherwise. (This is just from experience and some
454 tests, is there some spec?)
455
456 Scan the whole AUTHORITY section, since it may contain other records
457 (e.g. NSEC3) too.
458
459 Return: name for the authority, in an allocated string, or NULL if none found */
460
461 static const uschar *
462 dns_extract_auth_name(const dns_answer * dnsa)  /* FIXME: const dns_answer */
463 {
464 dns_scan dnss;
465 const HEADER * h = (const HEADER *) dnsa->answer;
466
467 if (h->nscount && h->aa)
468   for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
469        rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
470     if (rr->type == (h->ancount ? T_NS : T_SOA))
471       return string_copy(rr->name);
472 return NULL;
473 }
474
475
476
477
478 /*************************************************
479 *    Return whether AD bit set in DNS result     *
480 *************************************************/
481
482 /* We do not perform DNSSEC work ourselves; if the administrator has installed
483 a verifying resolver which sets AD as appropriate, though, we'll use that.
484 (AD = Authentic Data, AA = Authoritative Answer)
485
486 Argument:   pointer to dns answer block
487 Returns:    bool indicating presence of AD bit
488 */
489
490 BOOL
491 dns_is_secure(const dns_answer * dnsa)
492 {
493 #ifdef DISABLE_DNSSEC
494 DEBUG(D_dns)
495   debug_printf("DNSSEC support disabled at build-time; dns_is_secure() false\n");
496 return FALSE;
497 #else
498 const HEADER * h = (const HEADER *) dnsa->answer;
499 const uschar * auth_name;
500 const uschar * trusted;
501
502 if (h->ad) return TRUE;
503
504 /* If the resolver we ask is authoritative for the domain in question, it
505 * may not set the AD but the AA bit. If we explicitly trust
506 * the resolver for that domain (via a domainlist in dns_trust_aa),
507 * we return TRUE to indicate a secure answer.
508 */
509
510 if (  !h->aa
511    || !dns_trust_aa
512    || !(trusted = expand_string(dns_trust_aa))
513    || !*trusted
514    || !(auth_name = dns_extract_auth_name(dnsa))
515    || OK != match_isinlist(auth_name, &trusted, 0, NULL, NULL,
516                             MCL_DOMAIN, TRUE, NULL)
517    )
518   return FALSE;
519
520 DEBUG(D_dns) debug_printf("DNS faked the AD bit "
521   "(got AA and matched with dns_trust_aa (%s in %s))\n",
522   auth_name, dns_trust_aa);
523
524 return TRUE;
525 #endif
526 }
527
528 static void
529 dns_set_insecure(dns_answer * dnsa)
530 {
531 #ifndef DISABLE_DNSSEC
532 HEADER * h = (HEADER *)dnsa->answer;
533 h->aa = h->ad = 0;
534 #endif
535 }
536
537 /************************************************
538  *      Check whether the AA bit is set         *
539  *      We need this to warn if we requested AD *
540  *      from an authoritative server            *
541  ************************************************/
542
543 BOOL
544 dns_is_aa(const dns_answer *dnsa)
545 {
546 #ifdef DISABLE_DNSSEC
547 return FALSE;
548 #else
549 return ((const HEADER*)dnsa->answer)->aa;
550 #endif
551 }
552
553
554
555 /*************************************************
556 *            Turn DNS type into text             *
557 *************************************************/
558
559 /* Turn the coded record type into a string for printing. All those that Exim
560 uses should be included here.
561
562 Argument:   record type
563 Returns:    pointer to string
564 */
565
566 uschar *
567 dns_text_type(int t)
568 {
569 switch(t)
570   {
571   case T_A:     return US"A";
572   case T_MX:    return US"MX";
573   case T_AAAA:  return US"AAAA";
574   case T_A6:    return US"A6";
575   case T_TXT:   return US"TXT";
576   case T_SPF:   return US"SPF";
577   case T_PTR:   return US"PTR";
578   case T_SOA:   return US"SOA";
579   case T_SRV:   return US"SRV";
580   case T_NS:    return US"NS";
581   case T_CNAME: return US"CNAME";
582   case T_TLSA:  return US"TLSA";
583   default:      return US"?";
584   }
585 }
586
587
588
589 /*************************************************
590 *        Cache a failed DNS lookup result        *
591 *************************************************/
592
593 static void
594 dns_fail_tag(uschar * buf, const uschar * name, int dns_type)
595 {
596 res_state resp = os_get_dns_resolver_res();
597 sprintf(CS buf, "%.255s-%s-%lx", name, dns_text_type(dns_type),
598   (unsigned long) resp->options);
599 }
600
601
602 /* We cache failed lookup results so as not to experience timeouts many
603 times for the same domain. We need to retain the resolver options because they
604 may change. For successful lookups, we rely on resolver and/or name server
605 caching.
606
607 Arguments:
608   name       the domain name
609   type       the lookup type
610   rc         the return code
611
612 Returns:     the return code
613 */
614
615 static int
616 dns_return(const uschar * name, int type, int rc)
617 {
618 tree_node *node = store_get_perm(sizeof(tree_node) + 290);
619 dns_fail_tag(node->name, name, type);
620 node->data.val = rc;
621 (void)tree_insertnode(&tree_dns_fails, node);
622 return rc;
623 }
624
625 /*************************************************
626 *              Do basic DNS lookup               *
627 *************************************************/
628
629 /* Call the resolver to look up the given domain name, using the given type,
630 and check the result. The error code TRY_AGAIN is documented as meaning "non-
631 Authoritative Host not found, or SERVERFAIL". Sometimes there are badly set
632 up nameservers that produce this error continually, so there is the option of
633 providing a list of domains for which this is treated as a non-existent
634 host.
635
636 The dns_answer structure is pretty big; enough to hold a max-sized DNS message
637 - so best allocated from fast-release memory.  As of writing, all our callers
638 use a stack-auto variable.
639
640 Arguments:
641   dnsa      pointer to dns_answer structure
642   name      name to look up
643   type      type of DNS record required (T_A, T_MX, etc)
644
645 Returns:    DNS_SUCCEED   successful lookup
646             DNS_NOMATCH   name not found (NXDOMAIN)
647                           or name contains illegal characters (if checking)
648                           or name is an IP address (for IP address lookup)
649             DNS_NODATA    domain exists, but no data for this type (NODATA)
650             DNS_AGAIN     soft failure, try again later
651             DNS_FAIL      DNS failure
652 */
653
654 int
655 dns_basic_lookup(dns_answer *dnsa, const uschar *name, int type)
656 {
657 #ifndef STAND_ALONE
658 int rc = -1;
659 const uschar *save_domain;
660 #endif
661
662 tree_node *previous;
663 uschar node_name[290];
664
665 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
666 a timeout on one domain doesn't happen time and time again for messages that
667 have many addresses in the same domain. We rely on the resolver and name server
668 caching for successful lookups. */
669
670 dns_fail_tag(node_name, name, type);
671 if ((previous = tree_search(tree_dns_fails, node_name)))
672   {
673   DEBUG(D_dns) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
674     name, dns_text_type(type),
675       previous->data.val == DNS_NOMATCH ? "DNS_NOMATCH" :
676       previous->data.val == DNS_NODATA ? "DNS_NODATA" :
677       previous->data.val == DNS_AGAIN ? "DNS_AGAIN" :
678       previous->data.val == DNS_FAIL ? "DNS_FAIL" : "??");
679   return previous->data.val;
680   }
681
682 #ifdef SUPPORT_I18N
683 /* Convert all names to a-label form before doing lookup */
684   {
685   uschar * alabel;
686   uschar * errstr = NULL;
687   DEBUG(D_dns) if (string_is_utf8(name))
688     debug_printf("convert utf8 '%s' to alabel for for lookup\n", name);
689   if ((alabel = string_domain_utf8_to_alabel(name, &errstr)), errstr)
690     {
691     DEBUG(D_dns)
692       debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name,
693         errstr);
694     f.host_find_failed_syntax = TRUE;
695     return DNS_NOMATCH;
696     }
697   name = alabel;
698   }
699 #endif
700
701 /* If configured, check the hygiene of the name passed to lookup. Otherwise,
702 although DNS lookups may give REFUSED at the lower level, some resolvers
703 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
704 domains cannot be in the DNS. The check is now done by a regular expression;
705 give it space for substring storage to save it having to get its own if the
706 regex has substrings that are used - the default uses a conditional.
707
708 This test is omitted for PTR records. These occur only in calls from the dnsdb
709 lookup, which constructs the names itself, so they should be OK. Besides,
710 bitstring labels don't conform to normal name syntax. (But the aren't used any
711 more.)
712
713 For SRV records, we omit the initial _smtp._tcp. components at the start.
714 The check has been seen to bite on the destination of a SRV lookup that
715 initiall hit a CNAME, for which the next name had only two components.
716 RFC2782 makes no mention of the possibiility of CNAMES, but the Wikipedia
717 article on SRV says they are not a valid configuration. */
718
719 #ifndef STAND_ALONE   /* Omit this for stand-alone tests */
720
721 if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
722   {
723   const uschar *checkname = name;
724   int ovector[3*(EXPAND_MAXN+1)];
725
726   dns_pattern_init();
727
728   /* For an SRV lookup, skip over the first two components (the service and
729   protocol names, which both start with an underscore). */
730
731   if (type == T_SRV || type == T_TLSA)
732     {
733     while (*checkname && *checkname++ != '.') ;
734     while (*checkname && *checkname++ != '.') ;
735     }
736
737   if (pcre_exec(regex_check_dns_names, NULL, CCS checkname, Ustrlen(checkname),
738       0, PCRE_EOPT, ovector, nelem(ovector)) < 0)
739     {
740     DEBUG(D_dns)
741       debug_printf("DNS name syntax check failed: %s (%s)\n", name,
742         dns_text_type(type));
743     f.host_find_failed_syntax = TRUE;
744     return DNS_NOMATCH;
745     }
746   }
747
748 #endif /* STAND_ALONE */
749
750 /* Call the resolver; for an overlong response, res_search() will return the
751 number of bytes the message would need, so we need to check for this case. The
752 effect is to truncate overlong data.
753
754 On some systems, res_search() will recognize "A-for-A" queries and return
755 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
756 nameservers are also believed to do this. It is, of course, contrary to the
757 specification of the DNS, so we lock it out. */
758
759 if ((type == T_A || type == T_AAAA) && string_is_ip_address(name, NULL) != 0)
760   return DNS_NOMATCH;
761
762 /* If we are running in the test harness, instead of calling the normal resolver
763 (res_search), we call fakens_search(), which recognizes certain special
764 domains, and interfaces to a fake nameserver for certain special zones. */
765
766 dnsa->answerlen = f.running_in_test_harness
767   ? fakens_search(name, type, dnsa->answer, sizeof(dnsa->answer))
768   : res_search(CCS name, C_IN, type, dnsa->answer, sizeof(dnsa->answer));
769
770 if (dnsa->answerlen > (int) sizeof(dnsa->answer))
771   {
772   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet"
773     " (size %d), truncating to %u.\n",
774     name, dns_text_type(type), dnsa->answerlen, (unsigned int) sizeof(dnsa->answer));
775   dnsa->answerlen = sizeof(dnsa->answer);
776   }
777
778 if (dnsa->answerlen < 0) switch (h_errno)
779   {
780   case HOST_NOT_FOUND:
781     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
782       "returning DNS_NOMATCH\n", name, dns_text_type(type));
783     return dns_return(name, type, DNS_NOMATCH);
784
785   case TRY_AGAIN:
786     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
787       name, dns_text_type(type));
788
789     /* Cut this out for various test programs */
790 #ifndef STAND_ALONE
791     save_domain = deliver_domain;
792     deliver_domain = string_copy(name);  /* set $domain */
793     rc = match_isinlist(name, (const uschar **)&dns_again_means_nonexist, 0, NULL, NULL,
794       MCL_DOMAIN, TRUE, NULL);
795     deliver_domain = save_domain;
796     if (rc != OK)
797       {
798       DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
799       return dns_return(name, type, DNS_AGAIN);
800       }
801     DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
802       "DNS_NOMATCH\n", name);
803     return dns_return(name, type, DNS_NOMATCH);
804
805 #else   /* For stand-alone tests */
806     return dns_return(name, type, DNS_AGAIN);
807 #endif
808
809   case NO_RECOVERY:
810     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
811       "returning DNS_FAIL\n", name, dns_text_type(type));
812     return dns_return(name, type, DNS_FAIL);
813
814   case NO_DATA:
815     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
816       "returning DNS_NODATA\n", name, dns_text_type(type));
817     return dns_return(name, type, DNS_NODATA);
818
819   default:
820     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
821       "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
822     return dns_return(name, type, DNS_FAIL);
823   }
824
825 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
826   name, dns_text_type(type));
827
828 return DNS_SUCCEED;
829 }
830
831
832
833
834 /************************************************
835 *        Do a DNS lookup and handle CNAMES      *
836 ************************************************/
837
838 /* Look up the given domain name, using the given type. Follow CNAMEs if
839 necessary, but only so many times. There aren't supposed to be CNAME chains in
840 the DNS, but you are supposed to cope with them if you find them.
841 By default, follow one CNAME since a resolver has been seen, faced with
842 an MX request and a CNAME (to an A) but no MX present, returning the CNAME.
843
844 The assumption is made that if the resolver gives back records of the
845 requested type *and* a CNAME, we don't need to make another call to look up
846 the CNAME. I can't see how it could return only some of the right records. If
847 it's done a CNAME lookup in the past, it will have all of them; if not, it
848 won't return any.
849
850 If fully_qualified_name is not NULL, set it to point to the full name
851 returned by the resolver, if this is different to what it is given, unless
852 the returned name starts with "*" as some nameservers seem to be returning
853 wildcards in this form.  In international mode "different" means "alabel
854 forms are different".
855
856 Arguments:
857   dnsa                  pointer to dns_answer structure
858   name                  domain name to look up
859   type                  DNS record type (T_A, T_MX, etc)
860   fully_qualified_name  if not NULL, return the returned name here if its
861                           contents are different (i.e. it must be preset)
862
863 Returns:                DNS_SUCCEED   successful lookup
864                         DNS_NOMATCH   name not found
865                         DNS_NODATA    no data found
866                         DNS_AGAIN     soft failure, try again later
867                         DNS_FAIL      DNS failure
868 */
869
870 int
871 dns_lookup(dns_answer *dnsa, const uschar *name, int type,
872   const uschar **fully_qualified_name)
873 {
874 const uschar *orig_name = name;
875 BOOL secure_so_far = TRUE;
876
877 /* By default, assume the resolver follows CNAME chains (and returns NODATA for
878 an unterminated one). If it also does that for a CNAME loop, fine; if it returns
879 a CNAME (maybe the last?) whine about it.  However, retain the coding for dumb
880 resolvers hiding behind a config variable. Loop to follow CNAME chains so far,
881 but no further...  The testsuite tests the latter case, mostly assuming that the
882 former will work. */
883
884 for (int i = 0; i <= dns_cname_loops; i++)
885   {
886   uschar * data;
887   dns_record cname_rr, type_rr;
888   dns_scan dnss;
889   int rc;
890
891   /* DNS lookup failures get passed straight back. */
892
893   if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED)
894     return rc;
895
896   /* We should have either records of the required type, or a CNAME record,
897   or both. We need to know whether both exist for getting the fully qualified
898   name, but avoid scanning more than necessary. Note that we must copy the
899   contents of any rr blocks returned by dns_next_rr() as they use the same
900   area in the dnsa block. */
901
902   cname_rr.data = type_rr.data = NULL;
903   for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
904        rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
905     if (rr->type == type)
906       {
907       if (type_rr.data == NULL) type_rr = *rr;
908       if (cname_rr.data != NULL) break;
909       }
910     else if (rr->type == T_CNAME)
911       cname_rr = *rr;
912
913   /* For the first time round this loop, if a CNAME was found, take the fully
914   qualified name from it; otherwise from the first data record, if present. */
915
916   if (i == 0 && fully_qualified_name)
917     {
918     uschar * rr_name = cname_rr.data
919       ? cname_rr.name : type_rr.data ? type_rr.name : NULL;
920     if (  rr_name
921        && Ustrcmp(rr_name, *fully_qualified_name) != 0
922        && rr_name[0] != '*'
923 #ifdef SUPPORT_I18N
924        && (  !string_is_utf8(*fully_qualified_name)
925           || Ustrcmp(rr_name,
926                string_domain_utf8_to_alabel(*fully_qualified_name, NULL)) != 0
927           )
928 #endif
929        )
930         *fully_qualified_name = string_copy_dnsdomain(rr_name);
931     }
932
933   /* If any data records of the correct type were found, we are done. */
934
935   if (type_rr.data)
936     {
937     if (!secure_so_far) /* mark insecure if any element of CNAME chain was */
938       dns_set_insecure(dnsa);
939     return DNS_SUCCEED;
940     }
941
942   /* If there are no data records, we need to re-scan the DNS using the
943   domain given in the CNAME record, which should exist (otherwise we should
944   have had a failure from dns_lookup). However code against the possibility of
945   its not existing. */
946
947   if (!cname_rr.data)
948     return DNS_FAIL;
949
950   data = store_get(256);
951   if (dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
952       cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, 256) < 0)
953     return DNS_FAIL;
954   name = data;
955
956   if (!dns_is_secure(dnsa))
957     secure_so_far = FALSE;
958
959   DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
960   }       /* Loop back to do another lookup */
961
962 /*Control reaches here after 10 times round the CNAME loop. Something isn't
963 right... */
964
965 log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
966 return DNS_FAIL;
967 }
968
969
970
971
972
973
974 /************************************************
975 *    Do a DNS lookup and handle virtual types   *
976 ************************************************/
977
978 /* This function handles some invented "lookup types" that synthesize features
979 not available in the basic types. The special types all have negative values.
980 Positive type values are passed straight on to dns_lookup().
981
982 Arguments:
983   dnsa                  pointer to dns_answer structure
984   name                  domain name to look up
985   type                  DNS record type (T_A, T_MX, etc or a "special")
986   fully_qualified_name  if not NULL, return the returned name here if its
987                           contents are different (i.e. it must be preset)
988
989 Returns:                DNS_SUCCEED   successful lookup
990                         DNS_NOMATCH   name not found
991                         DNS_NODATA    no data found
992                         DNS_AGAIN     soft failure, try again later
993                         DNS_FAIL      DNS failure
994 */
995
996 int
997 dns_special_lookup(dns_answer *dnsa, const uschar *name, int type,
998   const uschar **fully_qualified_name)
999 {
1000 switch (type)
1001   {
1002   /* The "mx hosts only" type doesn't require any special action here */
1003   case T_MXH:
1004     return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
1005
1006   /* Find nameservers for the domain or the nearest enclosing zone, excluding
1007   the root servers. */
1008   case T_ZNS:
1009     type = T_NS;
1010     /* FALLTHROUGH */
1011   case T_SOA:
1012     {
1013     const uschar *d = name;
1014     while (d != 0)
1015       {
1016       int rc = dns_lookup(dnsa, d, type, fully_qualified_name);
1017       if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
1018       while (*d != 0 && *d != '.') d++;
1019       if (*d++ == 0) break;
1020       }
1021     return DNS_NOMATCH;
1022     }
1023
1024   /* Try to look up the Client SMTP Authorization SRV record for the name. If
1025   there isn't one, search from the top downwards for a CSA record in a parent
1026   domain, which might be making assertions about subdomains. If we find a record
1027   we set fully_qualified_name to whichever lookup succeeded, so that the caller
1028   can tell whether to look at the explicit authorization field or the subdomain
1029   assertion field. */
1030   case T_CSA:
1031     {
1032     uschar *srvname, *namesuff, *tld;
1033     int priority, weight, port;
1034     int limit, rc, i;
1035     BOOL ipv6;
1036     dns_record *rr;
1037     dns_scan dnss;
1038
1039     DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
1040
1041     srvname = string_sprintf("_client._smtp.%s", name);
1042     rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1043     if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
1044       {
1045       if (rc == DNS_SUCCEED) *fully_qualified_name = string_copy(name);
1046       return rc;
1047       }
1048
1049     /* Search for CSA subdomain assertion SRV records from the top downwards,
1050     starting with the 2nd level domain. This order maximizes cache-friendliness.
1051     We skip the top level domains to avoid loading their nameservers and because
1052     we know they'll never have CSA SRV records. */
1053
1054     namesuff = Ustrrchr(name, '.');
1055     if (namesuff == NULL) return DNS_NOMATCH;
1056     tld = namesuff + 1;
1057     ipv6 = FALSE;
1058     limit = dns_csa_search_limit;
1059
1060     /* Use more appropriate search parameters if we are in the reverse DNS. */
1061
1062     if (strcmpic(namesuff, US".arpa") == 0)
1063       if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
1064         {
1065         namesuff -= 8;
1066         tld = namesuff + 1;
1067         limit = 3;
1068         }
1069       else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
1070         {
1071         namesuff -= 4;
1072         tld = namesuff + 1;
1073         ipv6 = TRUE;
1074         limit = 3;
1075         }
1076
1077     DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
1078
1079     /* Do not perform the search if the top level or 2nd level domains do not
1080     exist. This is quite common, and when it occurs all the search queries would
1081     go to the root or TLD name servers, which is not friendly. So we check the
1082     AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
1083     the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
1084     If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
1085     the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
1086
1087     if (rc == DNS_NOMATCH)
1088       {
1089       /* This is really gross. The successful return value from res_search() is
1090       the packet length, which is stored in dnsa->answerlen. If we get a
1091       negative DNS reply then res_search() returns -1, which causes the bounds
1092       checks for name decompression to fail when it is treated as a packet
1093       length, which in turn causes the authority search to fail. The correct
1094       packet length has been lost inside libresolv, so we have to guess a
1095       replacement value. (The only way to fix this properly would be to
1096       re-implement res_search() and res_query() so that they don't muddle their
1097       success and packet length return values.) For added safety we only reset
1098       the packet length if the packet header looks plausible. */
1099
1100       const HEADER * h = (const HEADER *)dnsa->answer;
1101       if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
1102           && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
1103           && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
1104           && ntohs(h->nscount) >= 1)
1105             dnsa->answerlen = sizeof(dnsa->answer);
1106
1107       for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
1108            rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
1109           )
1110         if (rr->type != T_SOA) continue;
1111         else if (strcmpic(rr->name, US"") == 0 ||
1112                  strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
1113         else break;
1114       }
1115
1116     for (i = 0; i < limit; i++)
1117       {
1118       if (ipv6)
1119         {
1120         /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1121         address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1122         namesuff -= 8;
1123         if (namesuff <= name) return DNS_NOMATCH;
1124         }
1125       else
1126         /* Find the start of the preceding domain name label. */
1127         do
1128           if (--namesuff <= name) return DNS_NOMATCH;
1129         while (*namesuff != '.');
1130
1131       DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
1132
1133       srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
1134       rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1135       if (rc == DNS_AGAIN) return rc;
1136       if (rc != DNS_SUCCEED) continue;
1137
1138       /* Check that the SRV record we have found is worth returning. We don't
1139       just return the first one we find, because some lower level SRV record
1140       might make stricter assertions than its parent domain. */
1141
1142       for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1143            rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == T_SRV)
1144         {
1145         const uschar * p = rr->data;
1146
1147         /* Extract the numerical SRV fields (p is incremented) */
1148         GETSHORT(priority, p);
1149         GETSHORT(weight, p);    weight = weight; /* compiler quietening */
1150         GETSHORT(port, p);
1151
1152         /* Check the CSA version number */
1153         if (priority != 1) continue;
1154
1155         /* If it's making an interesting assertion, return this response. */
1156         if (port & 1)
1157           {
1158           *fully_qualified_name = namesuff + 1;
1159           return DNS_SUCCEED;
1160           }
1161         }
1162       }
1163     return DNS_NOMATCH;
1164     }
1165
1166   default:
1167     if (type >= 0)
1168       return dns_lookup(dnsa, name, type, fully_qualified_name);
1169   }
1170
1171 /* Control should never reach here */
1172
1173 return DNS_FAIL;
1174 }
1175
1176
1177
1178
1179
1180 /*************************************************
1181 *          Get address(es) from DNS record       *
1182 *************************************************/
1183
1184 /* The record type is either T_A for an IPv4 address or T_AAAA for an IPv6 address.
1185
1186 Argument:
1187   dnsa       the DNS answer block
1188   rr         the RR
1189
1190 Returns:     pointer to a chain of dns_address items; NULL when the dnsa was overrun
1191 */
1192
1193 dns_address *
1194 dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1195 {
1196 dns_address * yield = NULL;
1197 uschar * dnsa_lim = dnsa->answer + dnsa->answerlen;
1198
1199 if (rr->type == T_A)
1200   {
1201   uschar *p = US rr->data;
1202   if (p + 4 <= dnsa_lim)
1203     {
1204     yield = store_get(sizeof(dns_address) + 20);
1205     (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1206     yield->next = NULL;
1207     }
1208   }
1209
1210 #if HAVE_IPV6
1211
1212 else
1213   {
1214   if (rr->data + 16 <= dnsa_lim)
1215     {
1216     struct in6_addr in6;
1217     for (int i = 0; i < 16; i++) in6.s6_addr[i] = rr->data[i];
1218     yield = store_get(sizeof(dns_address) + 50);
1219     inet_ntop(AF_INET6, &in6, CS yield->address, 50);
1220     yield->next = NULL;
1221     }
1222   }
1223 #endif  /* HAVE_IPV6 */
1224
1225 return yield;
1226 }
1227
1228
1229
1230 void
1231 dns_pattern_init(void)
1232 {
1233 if (check_dns_names_pattern[0] != 0 && !regex_check_dns_names)
1234   regex_check_dns_names =
1235     regex_must_compile(check_dns_names_pattern, FALSE, TRUE);
1236 }
1237
1238 /* vi: aw ai sw=2
1239 */
1240 /* End of dns.c */