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