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