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