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