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