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