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