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