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