51029d4a557e6899b84b8e06521f07001cfbe2c1
[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
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 *endname;
44 uschar name[256];
45 uschar utilname[256];
46 uschar *aptr = answerptr;          /* Locally modified */
47 struct stat statbuf;
48
49 /* Remove terminating dot. */
50
51 if (domain[len - 1] == '.') len--;
52 Ustrncpy(name, domain, len);
53 name[len] = 0;
54 endname = name + len;
55
56 /* This code, for forcing TRY_AGAIN and NO_RECOVERY, is here so that it works
57 for the old test suite that uses a real nameserver. When the old test suite is
58 eventually abandoned, this code could be moved into the fakens utility. */
59
60 if (len >= 14 && Ustrcmp(endname - 14, "test.again.dns") == 0)
61   {
62   int delay = Uatoi(name);  /* digits at the start of the name */
63   DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
64     name, dns_text_type(type));
65   if (delay > 0)
66     {
67     DEBUG(D_dns) debug_printf("delaying %d seconds\n", delay);
68     sleep(delay);
69     }
70   h_errno = TRY_AGAIN;
71   return -1;
72   }
73
74 if (len >= 13 && Ustrcmp(endname - 13, "test.fail.dns") == 0)
75   {
76   DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
77     name, dns_text_type(type));
78   h_errno = NO_RECOVERY;
79   return -1;
80   }
81
82 /* Look for the fakens utility, and if it exists, call it. */
83
84 (void)string_format(utilname, sizeof(utilname), "%s/bin/fakens",
85   config_main_directory);
86
87 if (stat(CS utilname, &statbuf) >= 0)
88   {
89   pid_t pid;
90   int infd, outfd, rc;
91   uschar *argv[5];
92
93   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) using fakens\n", name, dns_text_type(type));
94
95   argv[0] = utilname;
96   argv[1] = config_main_directory;
97   argv[2] = name;
98   argv[3] = dns_text_type(type);
99   argv[4] = NULL;
100
101   pid = child_open(argv, NULL, 0000, &infd, &outfd, FALSE);
102   if (pid < 0)
103     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to run fakens: %s",
104       strerror(errno));
105
106   len = 0;
107   rc = -1;
108   while (asize > 0 && (rc = read(outfd, aptr, asize)) > 0)
109     {
110     len += rc;
111     aptr += rc;       /* Don't modify the actual arguments, because they */
112     asize -= rc;      /* may need to be passed on to res_search(). */
113     }
114
115   /* If we ran out of output buffer before exhasting the return,
116   carry on reading and counting it. */
117
118   if (asize == 0)
119     while ((rc = read(outfd, name, sizeof(name))) > 0)
120       len += rc;
121
122   if (rc < 0)
123     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "read from fakens failed: %s",
124       strerror(errno));
125
126   switch(child_close(pid, 0))
127     {
128     case 0: return len;
129     case 1: h_errno = HOST_NOT_FOUND; return -1;
130     case 2: h_errno = TRY_AGAIN; return -1;
131     default:
132     case 3: h_errno = NO_RECOVERY; return -1;
133     case 4: h_errno = NO_DATA; return -1;
134     case 5: /* Pass on to res_search() */
135     DEBUG(D_dns) debug_printf("fakens returned PASS_ON\n");
136     }
137   }
138 else
139   {
140     DEBUG(D_dns) debug_printf("fakens (%s) not found\n", utilname);
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 #ifdef EXPERIMENTAL_INTERNATIONAL
590 /* Convert all names to a-label form before doing lookup */
591   {
592   uschar * alabel;
593   uschar * errstr = NULL;
594   DEBUG(D_dns) if (string_is_utf8(name))
595     debug_printf("convert utf8 '%s' to alabel for for lookup\n", name);
596   if ((alabel = string_domain_utf8_to_alabel(name, &errstr)), errstr)
597     {
598     DEBUG(D_dns)
599       debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name,
600         errstr);
601     host_find_failed_syntax = TRUE;
602     return DNS_NOMATCH;
603     }
604   name = alabel;
605   }
606 #endif
607
608 /* If configured, check the hygene of the name passed to lookup. Otherwise,
609 although DNS lookups may give REFUSED at the lower level, some resolvers
610 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
611 domains cannot be in the DNS. The check is now done by a regular expression;
612 give it space for substring storage to save it having to get its own if the
613 regex has substrings that are used - the default uses a conditional.
614
615 This test is omitted for PTR records. These occur only in calls from the dnsdb
616 lookup, which constructs the names itself, so they should be OK. Besides,
617 bitstring labels don't conform to normal name syntax. (But the aren't used any
618 more.)
619
620 For SRV records, we omit the initial _smtp._tcp. components at the start. */
621
622 #ifndef STAND_ALONE   /* Omit this for stand-alone tests */
623
624 if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
625   {
626   const uschar *checkname = name;
627   int ovector[3*(EXPAND_MAXN+1)];
628
629   dns_pattern_init();
630
631   /* For an SRV lookup, skip over the first two components (the service and
632   protocol names, which both start with an underscore). */
633
634   if (type == T_SRV || type == T_TLSA)
635     {
636     while (*checkname++ != '.');
637     while (*checkname++ != '.');
638     }
639
640   if (pcre_exec(regex_check_dns_names, NULL, CCS checkname, Ustrlen(checkname),
641       0, PCRE_EOPT, ovector, sizeof(ovector)/sizeof(int)) < 0)
642     {
643     DEBUG(D_dns)
644       debug_printf("DNS name syntax check failed: %s (%s)\n", name,
645         dns_text_type(type));
646     host_find_failed_syntax = TRUE;
647     return DNS_NOMATCH;
648     }
649   }
650
651 #endif /* STAND_ALONE */
652
653 /* Call the resolver; for an overlong response, res_search() will return the
654 number of bytes the message would need, so we need to check for this case. The
655 effect is to truncate overlong data.
656
657 On some systems, res_search() will recognize "A-for-A" queries and return
658 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
659 nameservers are also believed to do this. It is, of course, contrary to the
660 specification of the DNS, so we lock it out. */
661
662 if ((type == T_A || type == T_AAAA) && string_is_ip_address(name, NULL) != 0)
663   return DNS_NOMATCH;
664
665 /* If we are running in the test harness, instead of calling the normal resolver
666 (res_search), we call fakens_search(), which recognizes certain special
667 domains, and interfaces to a fake nameserver for certain special zones. */
668
669 dnsa->answerlen = running_in_test_harness
670   ? fakens_search(name, type, dnsa->answer, MAXPACKET)
671   : res_search(CCS name, C_IN, type, dnsa->answer, MAXPACKET);
672
673 if (dnsa->answerlen > MAXPACKET)
674   {
675   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet (size %d), truncating to %d.\n",
676     name, dns_text_type(type), dnsa->answerlen, MAXPACKET);
677   dnsa->answerlen = MAXPACKET;
678   }
679
680 if (dnsa->answerlen < 0) switch (h_errno)
681   {
682   case HOST_NOT_FOUND:
683   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
684     "returning DNS_NOMATCH\n", name, dns_text_type(type));
685   return dns_return(name, type, DNS_NOMATCH);
686
687   case TRY_AGAIN:
688   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
689     name, dns_text_type(type));
690
691   /* Cut this out for various test programs */
692 #ifndef STAND_ALONE
693   save_domain = deliver_domain;
694   deliver_domain = string_copy(name);  /* set $domain */
695   rc = match_isinlist(name, (const uschar **)&dns_again_means_nonexist, 0, NULL, NULL,
696     MCL_DOMAIN, TRUE, NULL);
697   deliver_domain = save_domain;
698   if (rc != OK)
699     {
700     DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
701     return dns_return(name, type, DNS_AGAIN);
702     }
703   DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
704     "DNS_NOMATCH\n", name);
705   return dns_return(name, type, DNS_NOMATCH);
706
707 #else   /* For stand-alone tests */
708   return dns_return(name, type, DNS_AGAIN);
709 #endif
710
711   case NO_RECOVERY:
712   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
713     "returning DNS_FAIL\n", name, dns_text_type(type));
714   return dns_return(name, type, DNS_FAIL);
715
716   case NO_DATA:
717   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
718     "returning DNS_NODATA\n", name, dns_text_type(type));
719   return dns_return(name, type, DNS_NODATA);
720
721   default:
722   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
723     "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
724   return dns_return(name, type, DNS_FAIL);
725   }
726
727 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
728   name, dns_text_type(type));
729
730 return DNS_SUCCEED;
731 }
732
733
734
735
736 /************************************************
737 *        Do a DNS lookup and handle CNAMES      *
738 ************************************************/
739
740 /* Look up the given domain name, using the given type. Follow CNAMEs if
741 necessary, but only so many times. There aren't supposed to be CNAME chains in
742 the DNS, but you are supposed to cope with them if you find them.
743
744 The assumption is made that if the resolver gives back records of the
745 requested type *and* a CNAME, we don't need to make another call to look up
746 the CNAME. I can't see how it could return only some of the right records. If
747 it's done a CNAME lookup in the past, it will have all of them; if not, it
748 won't return any.
749
750 If fully_qualified_name is not NULL, set it to point to the full name
751 returned by the resolver, if this is different to what it is given, unless
752 the returned name starts with "*" as some nameservers seem to be returning
753 wildcards in this form.  In international mode "different" means "alabel
754 forms are different".
755
756 Arguments:
757   dnsa                  pointer to dns_answer structure
758   name                  domain name to look up
759   type                  DNS record type (T_A, T_MX, etc)
760   fully_qualified_name  if not NULL, return the returned name here if its
761                           contents are different (i.e. it must be preset)
762
763 Returns:                DNS_SUCCEED   successful lookup
764                         DNS_NOMATCH   name not found
765                         DNS_NODATA    no data found
766                         DNS_AGAIN     soft failure, try again later
767                         DNS_FAIL      DNS failure
768 */
769
770 int
771 dns_lookup(dns_answer *dnsa, const uschar *name, int type,
772   const uschar **fully_qualified_name)
773 {
774 int i;
775 const uschar *orig_name = name;
776 BOOL secure_so_far = TRUE;
777
778 /* Loop to follow CNAME chains so far, but no further... */
779
780 for (i = 0; i < 10; i++)
781   {
782   uschar data[256];
783   dns_record *rr, cname_rr, type_rr;
784   dns_scan dnss;
785   int datalen, rc;
786
787   /* DNS lookup failures get passed straight back. */
788
789   if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED) return rc;
790
791   /* We should have either records of the required type, or a CNAME record,
792   or both. We need to know whether both exist for getting the fully qualified
793   name, but avoid scanning more than necessary. Note that we must copy the
794   contents of any rr blocks returned by dns_next_rr() as they use the same
795   area in the dnsa block. */
796
797   cname_rr.data = type_rr.data = NULL;
798   for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
799        rr != NULL;
800        rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
801     {
802     if (rr->type == type)
803       {
804       if (type_rr.data == NULL) type_rr = *rr;
805       if (cname_rr.data != NULL) break;
806       }
807     else if (rr->type == T_CNAME) cname_rr = *rr;
808     }
809
810   /* For the first time round this loop, if a CNAME was found, take the fully
811   qualified name from it; otherwise from the first data record, if present. */
812
813   if (i == 0 && fully_qualified_name != NULL)
814     {
815     uschar * rr_name = cname_rr.data ? cname_rr.name
816       : type_rr.data ? type_rr.name : NULL;
817     if (  rr_name
818        && Ustrcmp(rr_name, *fully_qualified_name) != 0
819        && rr_name[0] != '*'
820 #ifdef EXPERIMENTAL_INTERNATIONAL
821        && (  !string_is_utf8(*fully_qualified_name)
822           || Ustrcmp(rr_name,
823                string_domain_utf8_to_alabel(*fully_qualified_name, NULL)) != 0
824           )
825 #endif
826        )
827         *fully_qualified_name = string_copy_dnsdomain(rr_name);
828     }
829
830   /* If any data records of the correct type were found, we are done. */
831
832   if (type_rr.data != NULL)
833     {
834     if (!secure_so_far) /* mark insecure if any element of CNAME chain was */
835       dns_set_insecure(dnsa);
836     return DNS_SUCCEED;
837     }
838
839   /* If there are no data records, we need to re-scan the DNS using the
840   domain given in the CNAME record, which should exist (otherwise we should
841   have had a failure from dns_lookup). However code against the possibility of
842   its not existing. */
843
844   if (cname_rr.data == NULL) return DNS_FAIL;
845   datalen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
846     cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
847   if (datalen < 0) return DNS_FAIL;
848   name = data;
849
850   if (!dns_is_secure(dnsa))
851     secure_so_far = FALSE;
852
853   DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
854   }       /* Loop back to do another lookup */
855
856 /*Control reaches here after 10 times round the CNAME loop. Something isn't
857 right... */
858
859 log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
860 return DNS_FAIL;
861 }
862
863
864
865
866
867
868 /************************************************
869 *    Do a DNS lookup and handle virtual types   *
870 ************************************************/
871
872 /* This function handles some invented "lookup types" that synthesize feature
873 not available in the basic types. The special types all have negative values.
874 Positive type values are passed straight on to dns_lookup().
875
876 Arguments:
877   dnsa                  pointer to dns_answer structure
878   name                  domain name to look up
879   type                  DNS record type (T_A, T_MX, etc or a "special")
880   fully_qualified_name  if not NULL, return the returned name here if its
881                           contents are different (i.e. it must be preset)
882
883 Returns:                DNS_SUCCEED   successful lookup
884                         DNS_NOMATCH   name not found
885                         DNS_NODATA    no data found
886                         DNS_AGAIN     soft failure, try again later
887                         DNS_FAIL      DNS failure
888 */
889
890 int
891 dns_special_lookup(dns_answer *dnsa, const uschar *name, int type,
892   const uschar **fully_qualified_name)
893 {
894 switch (type)
895   {
896   /* The "mx hosts only" type doesn't require any special action here */
897   case T_MXH:
898         return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
899
900   /* Find nameservers for the domain or the nearest enclosing zone, excluding
901   the root servers. */
902   case T_ZNS:
903         type = T_NS;
904         /* FALLTHROUGH */
905   case T_SOA:
906         {
907         const uschar *d = name;
908         while (d != 0)
909           {
910           int rc = dns_lookup(dnsa, d, type, fully_qualified_name);
911           if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
912           while (*d != 0 && *d != '.') d++;
913           if (*d++ == 0) break;
914           }
915         return DNS_NOMATCH;
916         }
917
918   /* Try to look up the Client SMTP Authorization SRV record for the name. If
919   there isn't one, search from the top downwards for a CSA record in a parent
920   domain, which might be making assertions about subdomains. If we find a record
921   we set fully_qualified_name to whichever lookup succeeded, so that the caller
922   can tell whether to look at the explicit authorization field or the subdomain
923   assertion field. */
924   case T_CSA:
925         {
926         uschar *srvname, *namesuff, *tld, *p;
927         int priority, weight, port;
928         int limit, rc, i;
929         BOOL ipv6;
930         dns_record *rr;
931         dns_scan dnss;
932
933         DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
934
935         srvname = string_sprintf("_client._smtp.%s", name);
936         rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
937         if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
938           {
939           if (rc == DNS_SUCCEED) *fully_qualified_name = string_copy(name);
940           return rc;
941           }
942
943         /* Search for CSA subdomain assertion SRV records from the top downwards,
944         starting with the 2nd level domain. This order maximizes cache-friendliness.
945         We skip the top level domains to avoid loading their nameservers and because
946         we know they'll never have CSA SRV records. */
947
948         namesuff = Ustrrchr(name, '.');
949         if (namesuff == NULL) return DNS_NOMATCH;
950         tld = namesuff + 1;
951         ipv6 = FALSE;
952         limit = dns_csa_search_limit;
953
954         /* Use more appropriate search parameters if we are in the reverse DNS. */
955
956         if (strcmpic(namesuff, US".arpa") == 0)
957           {
958           if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
959                 {
960                 namesuff -= 8;
961                 tld = namesuff + 1;
962                 limit = 3;
963                 }
964           else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
965                 {
966                 namesuff -= 4;
967                 tld = namesuff + 1;
968                 ipv6 = TRUE;
969                 limit = 3;
970                 }
971           }
972
973         DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
974
975         /* Do not perform the search if the top level or 2nd level domains do not
976         exist. This is quite common, and when it occurs all the search queries would
977         go to the root or TLD name servers, which is not friendly. So we check the
978         AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
979         the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
980         If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
981         the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
982
983         if (rc == DNS_NOMATCH)
984           {
985           /* This is really gross. The successful return value from res_search() is
986           the packet length, which is stored in dnsa->answerlen. If we get a
987           negative DNS reply then res_search() returns -1, which causes the bounds
988           checks for name decompression to fail when it is treated as a packet
989           length, which in turn causes the authority search to fail. The correct
990           packet length has been lost inside libresolv, so we have to guess a
991           replacement value. (The only way to fix this properly would be to
992           re-implement res_search() and res_query() so that they don't muddle their
993           success and packet length return values.) For added safety we only reset
994           the packet length if the packet header looks plausible. */
995
996           HEADER *h = (HEADER *)dnsa->answer;
997           if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
998                   && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
999                   && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
1000                   && ntohs(h->nscount) >= 1)
1001                 dnsa->answerlen = MAXPACKET;
1002
1003           for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
1004                    rr != NULL;
1005                    rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1006                 if (rr->type != T_SOA) continue;
1007                 else if (strcmpic(rr->name, US"") == 0 ||
1008                                  strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
1009                 else break;
1010           }
1011
1012         for (i = 0; i < limit; i++)
1013           {
1014           if (ipv6)
1015                 {
1016                 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1017                 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1018                 namesuff -= 8;
1019                 if (namesuff <= name) return DNS_NOMATCH;
1020                 }
1021           else
1022                 /* Find the start of the preceding domain name label. */
1023                 do
1024                   if (--namesuff <= name) return DNS_NOMATCH;
1025                 while (*namesuff != '.');
1026
1027           DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
1028
1029           srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
1030           rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1031           if (rc == DNS_AGAIN) return rc;
1032           if (rc != DNS_SUCCEED) continue;
1033
1034           /* Check that the SRV record we have found is worth returning. We don't
1035           just return the first one we find, because some lower level SRV record
1036           might make stricter assertions than its parent domain. */
1037
1038           for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1039                    rr != NULL;
1040                    rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1041                 {
1042                 if (rr->type != T_SRV) continue;
1043
1044                 /* Extract the numerical SRV fields (p is incremented) */
1045                 p = rr->data;
1046                 GETSHORT(priority, p);
1047                 GETSHORT(weight, p);    weight = weight; /* compiler quietening */
1048                 GETSHORT(port, p);
1049
1050                 /* Check the CSA version number */
1051                 if (priority != 1) continue;
1052
1053                 /* If it's making an interesting assertion, return this response. */
1054                 if (port & 1)
1055                   {
1056                   *fully_qualified_name = namesuff + 1;
1057                   return DNS_SUCCEED;
1058                   }
1059                 }
1060           }
1061         return DNS_NOMATCH;
1062         }
1063
1064   default:
1065         if (type >= 0)
1066           return dns_lookup(dnsa, name, type, fully_qualified_name);
1067   }
1068
1069 /* Control should never reach here */
1070
1071 return DNS_FAIL;
1072 }
1073
1074
1075
1076
1077
1078 /*************************************************
1079 *          Get address(es) from DNS record       *
1080 *************************************************/
1081
1082 /* The record type is either T_A for an IPv4 address or T_AAAA (or T_A6 when
1083 supported) for an IPv6 address.
1084
1085 Argument:
1086   dnsa       the DNS answer block
1087   rr         the RR
1088
1089 Returns:     pointer to a chain of dns_address items
1090 */
1091
1092 dns_address *
1093 dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1094 {
1095 dns_address *yield = NULL;
1096
1097 dnsa = dnsa;    /* Stop picky compilers warning */
1098
1099 if (rr->type == T_A)
1100   {
1101   uschar *p = US rr->data;
1102   yield = store_get(sizeof(dns_address) + 20);
1103   (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1104   yield->next = NULL;
1105   }
1106
1107 #if HAVE_IPV6
1108
1109 else
1110   {
1111   yield = store_get(sizeof(dns_address) + 50);
1112   inet_ntop(AF_INET6, US rr->data, CS yield->address, 50);
1113   yield->next = NULL;
1114   }
1115 #endif  /* HAVE_IPV6 */
1116
1117 return yield;
1118 }
1119
1120
1121
1122 void
1123 dns_pattern_init(void)
1124 {
1125 if (check_dns_names_pattern[0] != 0 && !regex_check_dns_names)
1126   regex_check_dns_names =
1127     regex_must_compile(check_dns_names_pattern, FALSE, TRUE);
1128 }
1129
1130 /* vi: aw ai sw=2
1131 */
1132 /* End of dns.c */