490eb883d3d53eaf85f33063fd2e7bf148e37c43
[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 # define TRACE if (FALSE)
338 #endif
339
340 /* Reset the saved data when requested to, and skip to the first required RR */
341
342 if (reset != RESET_NEXT)
343   {
344   dnss->rrcount = ntohs(h->qdcount);
345   TRACE debug_printf("%s: reset (Q rrcount %d)\n", __FUNCTION__, dnss->rrcount);
346   dnss->aptr = dnsa->answer + sizeof(HEADER);
347
348   /* Skip over questions; failure to expand the name just gives up */
349
350   while (dnss->rrcount-- > 0)
351     {
352     TRACE trace = "Q-namelen";
353     namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
354       dnss->aptr, (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
355     if (namelen < 0) goto null_return;
356     /* skip name & type & class */
357     TRACE trace = "Q-skip";
358     if (dnss_inc_aptr(dnsa, dnss, namelen+4)) goto null_return;
359     }
360
361   /* Get the number of answer records. */
362
363   dnss->rrcount = ntohs(h->ancount);
364   TRACE debug_printf("%s: reset (A rrcount %d)\n", __FUNCTION__, dnss->rrcount);
365
366   /* Skip over answers if we want to look at the authority section. Also skip
367   the NS records (i.e. authority section) if wanting to look at the additional
368   records. */
369
370   if (reset == RESET_ADDITIONAL)
371     {
372     TRACE debug_printf("%s: additional\n", __FUNCTION__);
373     dnss->rrcount += ntohs(h->nscount);
374     TRACE debug_printf("%s: reset (NS rrcount %d)\n", __FUNCTION__, dnss->rrcount);
375     }
376
377   if (reset == RESET_AUTHORITY || reset == RESET_ADDITIONAL)
378     {
379     TRACE if (reset == RESET_AUTHORITY)
380       debug_printf("%s: authority\n", __FUNCTION__);
381     while (dnss->rrcount-- > 0)
382       {
383       TRACE trace = "A-namelen";
384       namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
385         dnss->aptr, (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
386       if (namelen < 0) goto null_return;
387       /* skip name, type, class & TTL */
388       TRACE trace = "A-hdr";
389       if (dnss_inc_aptr(dnsa, dnss, namelen+8)) goto null_return;
390       GETSHORT(dnss->srr.size, dnss->aptr); /* size of data portion */
391       /* skip over it */
392       TRACE trace = "A-skip";
393       if (dnss_inc_aptr(dnsa, dnss, dnss->srr.size)) goto null_return;
394       }
395     dnss->rrcount = reset == RESET_AUTHORITY
396       ? ntohs(h->nscount) : ntohs(h->arcount);
397     TRACE debug_printf("%s: reset (%s rrcount %d)\n", __FUNCTION__,
398       reset == RESET_AUTHORITY ? "NS" : "AR", dnss->rrcount);
399     }
400   TRACE debug_printf("%s: %d RRs to read\n", __FUNCTION__, dnss->rrcount);
401   }
402 else
403   TRACE debug_printf("%s: next (%d left)\n", __FUNCTION__, dnss->rrcount);
404
405 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
406 contains the number of RR records left. */
407
408 if (dnss->rrcount-- <= 0) return NULL;
409
410 /* If expanding the RR domain name fails, behave as if no more records
411 (something safe). */
412
413 TRACE trace = "R-namelen";
414 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, dnss->aptr,
415   (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
416 if (namelen < 0) goto null_return;
417
418 /* Move the pointer past the name and fill in the rest of the data structure
419 from the following bytes. */
420
421 TRACE trace = "R-name";
422 if (dnss_inc_aptr(dnsa, dnss, namelen)) goto null_return;
423
424 GETSHORT(dnss->srr.type, dnss->aptr);           /* Record type */
425 TRACE trace = "R-class";
426 if (dnss_inc_aptr(dnsa, dnss, 2)) goto null_return;     /* Don't want class */
427 GETLONG(dnss->srr.ttl, dnss->aptr);             /* TTL */
428 GETSHORT(dnss->srr.size, dnss->aptr);           /* Size of data portion */
429 dnss->srr.data = dnss->aptr;                    /* The record's data follows */
430
431 /* Unchecked increment ok here since no further access on this iteration;
432 will be checked on next at "R-name". */
433
434 dnss->aptr += dnss->srr.size;                   /* Advance to next RR */
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, is_tainted(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 #endif
805
806 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
807 a timeout on one domain doesn't happen time and time again for messages that
808 have many addresses in the same domain. We rely on the resolver and name server
809 caching for successful lookups.
810 */
811
812 if ((rc = dns_fail_cache_hit(name, type)) > 0)
813   {
814   dnsa->answerlen = -1;
815   return rc;
816   }
817
818 #ifdef SUPPORT_I18N
819 /* Convert all names to a-label form before doing lookup */
820   {
821   uschar * alabel;
822   uschar * errstr = NULL;
823   DEBUG(D_dns) if (string_is_utf8(name))
824     debug_printf("convert utf8 '%s' to alabel for for lookup\n", name);
825   if ((alabel = string_domain_utf8_to_alabel(name, &errstr)), errstr)
826     {
827     DEBUG(D_dns)
828       debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name,
829         errstr);
830     f.host_find_failed_syntax = TRUE;
831     return DNS_NOMATCH;
832     }
833   name = alabel;
834   }
835 #endif
836
837 /* If configured, check the hygiene of the name passed to lookup. Otherwise,
838 although DNS lookups may give REFUSED at the lower level, some resolvers
839 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
840 domains cannot be in the DNS. The check is now done by a regular expression;
841 give it space for substring storage to save it having to get its own if the
842 regex has substrings that are used - the default uses a conditional.
843
844 This test is omitted for PTR records. These occur only in calls from the dnsdb
845 lookup, which constructs the names itself, so they should be OK. Besides,
846 bitstring labels don't conform to normal name syntax. (But they aren't used any
847 more.) */
848
849 #ifndef STAND_ALONE   /* Omit this for stand-alone tests */
850
851 if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
852   {
853   int ovector[3*(EXPAND_MAXN+1)];
854
855   dns_pattern_init();
856   if (pcre_exec(regex_check_dns_names, NULL, CCS name, Ustrlen(name),
857       0, PCRE_EOPT, ovector, nelem(ovector)) < 0)
858     {
859     DEBUG(D_dns)
860       debug_printf("DNS name syntax check failed: %s (%s)\n", name,
861         dns_text_type(type));
862     f.host_find_failed_syntax = TRUE;
863     return DNS_NOMATCH;
864     }
865   }
866
867 #endif /* STAND_ALONE */
868
869 /* Call the resolver; for an overlong response, res_search() will return the
870 number of bytes the message would need, so we need to check for this case. The
871 effect is to truncate overlong data.
872
873 On some systems, res_search() will recognize "A-for-A" queries and return
874 the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
875 nameservers are also believed to do this. It is, of course, contrary to the
876 specification of the DNS, so we lock it out. */
877
878 if ((type == T_A || type == T_AAAA) && string_is_ip_address(name, NULL) != 0)
879   return DNS_NOMATCH;
880
881 /* If we are running in the test harness, instead of calling the normal resolver
882 (res_search), we call fakens_search(), which recognizes certain special
883 domains, and interfaces to a fake nameserver for certain special zones. */
884
885 h_errno = 0;
886 dnsa->answerlen = f.running_in_test_harness
887   ? fakens_search(name, type, dnsa->answer, sizeof(dnsa->answer))
888   : res_search(CCS name, C_IN, type, dnsa->answer, sizeof(dnsa->answer));
889
890 if (dnsa->answerlen > (int) sizeof(dnsa->answer))
891   {
892   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet"
893     " (size %d), truncating to %u.\n",
894     name, dns_text_type(type), dnsa->answerlen, (unsigned int) sizeof(dnsa->answer));
895   dnsa->answerlen = sizeof(dnsa->answer);
896   }
897
898 if (dnsa->answerlen < 0) switch (h_errno)
899   {
900   case HOST_NOT_FOUND:
901     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
902       "returning DNS_NOMATCH\n", name, dns_text_type(type));
903     return dns_fail_return(name, type, dns_expire_from_soa(dnsa, type), DNS_NOMATCH);
904
905   case TRY_AGAIN:
906     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
907       name, dns_text_type(type));
908
909     /* Cut this out for various test programs */
910 #ifndef STAND_ALONE
911     save_domain = deliver_domain;
912     deliver_domain = string_copy(name);  /* set $domain */
913     rc = match_isinlist(name, CUSS &dns_again_means_nonexist, 0,
914       &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
915     deliver_domain = save_domain;
916     if (rc != OK)
917       {
918       DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
919       return dns_fail_return(name, type, 0, DNS_AGAIN);
920       }
921     DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
922       "DNS_NOMATCH\n", name);
923     return dns_fail_return(name, type, dns_expire_from_soa(dnsa, type), DNS_NOMATCH);
924
925 #else   /* For stand-alone tests */
926     return dns_fail_return(name, type, 0, DNS_AGAIN);
927 #endif
928
929   case NO_RECOVERY:
930     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
931       "returning DNS_FAIL\n", name, dns_text_type(type));
932     return dns_fail_return(name, type, 0, DNS_FAIL);
933
934   case NO_DATA:
935     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
936       "returning DNS_NODATA\n", name, dns_text_type(type));
937     return dns_fail_return(name, type, dns_expire_from_soa(dnsa, type), DNS_NODATA);
938
939   default:
940     DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
941       "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
942     return dns_fail_return(name, type, 0, DNS_FAIL);
943   }
944
945 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
946   name, dns_text_type(type));
947
948 return DNS_SUCCEED;
949 }
950
951
952
953
954 /************************************************
955 *        Do a DNS lookup and handle CNAMES      *
956 ************************************************/
957
958 /* Look up the given domain name, using the given type. Follow CNAMEs if
959 necessary, but only so many times. There aren't supposed to be CNAME chains in
960 the DNS, but you are supposed to cope with them if you find them.
961 By default, follow one CNAME since a resolver has been seen, faced with
962 an MX request and a CNAME (to an A) but no MX present, returning the CNAME.
963
964 The assumption is made that if the resolver gives back records of the
965 requested type *and* a CNAME, we don't need to make another call to look up
966 the CNAME. I can't see how it could return only some of the right records. If
967 it's done a CNAME lookup in the past, it will have all of them; if not, it
968 won't return any.
969
970 If fully_qualified_name is not NULL, set it to point to the full name
971 returned by the resolver, if this is different to what it is given, unless
972 the returned name starts with "*" as some nameservers seem to be returning
973 wildcards in this form.  In international mode "different" means "alabel
974 forms are different".
975
976 Arguments:
977   dnsa                  pointer to dns_answer structure
978   name                  domain name to look up
979   type                  DNS record type (T_A, T_MX, etc)
980   fully_qualified_name  if not NULL, return the returned name here if its
981                           contents are different (i.e. it must be preset)
982
983 Returns:                DNS_SUCCEED   successful lookup
984                         DNS_NOMATCH   name not found
985                         DNS_NODATA    no data found
986                         DNS_AGAIN     soft failure, try again later
987                         DNS_FAIL      DNS failure
988 */
989
990 int
991 dns_lookup(dns_answer *dnsa, const uschar *name, int type,
992   const uschar **fully_qualified_name)
993 {
994 const uschar *orig_name = name;
995 BOOL secure_so_far = TRUE;
996
997 /* By default, assume the resolver follows CNAME chains (and returns NODATA for
998 an unterminated one). If it also does that for a CNAME loop, fine; if it returns
999 a CNAME (maybe the last?) whine about it.  However, retain the coding for dumb
1000 resolvers hiding behind a config variable. Loop to follow CNAME chains so far,
1001 but no further...  The testsuite tests the latter case, mostly assuming that the
1002 former will work. */
1003
1004 for (int i = 0; i <= dns_cname_loops; i++)
1005   {
1006   uschar * data;
1007   dns_record cname_rr, type_rr;
1008   dns_scan dnss;
1009   int rc;
1010
1011   /* DNS lookup failures get passed straight back. */
1012
1013   if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED)
1014     return rc;
1015
1016   /* We should have either records of the required type, or a CNAME record,
1017   or both. We need to know whether both exist for getting the fully qualified
1018   name, but avoid scanning more than necessary. Note that we must copy the
1019   contents of any rr blocks returned by dns_next_rr() as they use the same
1020   area in the dnsa block. */
1021
1022   cname_rr.data = type_rr.data = NULL;
1023   for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1024        rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1025     if (rr->type == type)
1026       {
1027       if (type_rr.data == NULL) type_rr = *rr;
1028       if (cname_rr.data != NULL) break;
1029       }
1030     else if (rr->type == T_CNAME)
1031       cname_rr = *rr;
1032
1033   /* For the first time round this loop, if a CNAME was found, take the fully
1034   qualified name from it; otherwise from the first data record, if present. */
1035
1036   if (i == 0 && fully_qualified_name)
1037     {
1038     uschar * rr_name = cname_rr.data
1039       ? cname_rr.name : type_rr.data ? type_rr.name : NULL;
1040     if (  rr_name
1041        && Ustrcmp(rr_name, *fully_qualified_name) != 0
1042        && rr_name[0] != '*'
1043 #ifdef SUPPORT_I18N
1044        && (  !string_is_utf8(*fully_qualified_name)
1045           || Ustrcmp(rr_name,
1046                string_domain_utf8_to_alabel(*fully_qualified_name, NULL)) != 0
1047           )
1048 #endif
1049        )
1050         *fully_qualified_name = string_copy_dnsdomain(rr_name);
1051     }
1052
1053   /* If any data records of the correct type were found, we are done. */
1054
1055   if (type_rr.data)
1056     {
1057     if (!secure_so_far) /* mark insecure if any element of CNAME chain was */
1058       dns_set_insecure(dnsa);
1059     return DNS_SUCCEED;
1060     }
1061
1062   /* If there are no data records, we need to re-scan the DNS using the
1063   domain given in the CNAME record, which should exist (otherwise we should
1064   have had a failure from dns_lookup). However code against the possibility of
1065   its not existing. */
1066
1067   if (!cname_rr.data)
1068     return DNS_FAIL;
1069
1070   /* DNS data comes from the outside, hence tainted */
1071   data = store_get(256, TRUE);
1072   if (dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
1073       cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, 256) < 0)
1074     return DNS_FAIL;
1075   name = data;
1076
1077   if (!dns_is_secure(dnsa))
1078     secure_so_far = FALSE;
1079
1080   DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
1081   }       /* Loop back to do another lookup */
1082
1083 /*Control reaches here after 10 times round the CNAME loop. Something isn't
1084 right... */
1085
1086 log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
1087 return DNS_FAIL;
1088 }
1089
1090
1091
1092
1093
1094
1095 /************************************************
1096 *    Do a DNS lookup and handle virtual types   *
1097 ************************************************/
1098
1099 /* This function handles some invented "lookup types" that synthesize features
1100 not available in the basic types. The special types all have negative values.
1101 Positive type values are passed straight on to dns_lookup().
1102
1103 Arguments:
1104   dnsa                  pointer to dns_answer structure
1105   name                  domain name to look up
1106   type                  DNS record type (T_A, T_MX, etc or a "special")
1107   fully_qualified_name  if not NULL, return the returned name here if its
1108                           contents are different (i.e. it must be preset)
1109
1110 Returns:                DNS_SUCCEED   successful lookup
1111                         DNS_NOMATCH   name not found
1112                         DNS_NODATA    no data found
1113                         DNS_AGAIN     soft failure, try again later
1114                         DNS_FAIL      DNS failure
1115 */
1116
1117 int
1118 dns_special_lookup(dns_answer *dnsa, const uschar *name, int type,
1119   const uschar **fully_qualified_name)
1120 {
1121 switch (type)
1122   {
1123   /* The "mx hosts only" type doesn't require any special action here */
1124   case T_MXH:
1125     return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
1126
1127   /* Find nameservers for the domain or the nearest enclosing zone, excluding
1128   the root servers. */
1129   case T_ZNS:
1130     type = T_NS;
1131     /* FALLTHROUGH */
1132   case T_SOA:
1133     {
1134     const uschar *d = name;
1135     while (d != 0)
1136       {
1137       int rc = dns_lookup(dnsa, d, type, fully_qualified_name);
1138       if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
1139       while (*d != 0 && *d != '.') d++;
1140       if (*d++ == 0) break;
1141       }
1142     return DNS_NOMATCH;
1143     }
1144
1145   /* Try to look up the Client SMTP Authorization SRV record for the name. If
1146   there isn't one, search from the top downwards for a CSA record in a parent
1147   domain, which might be making assertions about subdomains. If we find a record
1148   we set fully_qualified_name to whichever lookup succeeded, so that the caller
1149   can tell whether to look at the explicit authorization field or the subdomain
1150   assertion field. */
1151   case T_CSA:
1152     {
1153     uschar *srvname, *namesuff, *tld;
1154     int priority, weight, port;
1155     int limit, rc, i;
1156     BOOL ipv6;
1157     dns_record *rr;
1158     dns_scan dnss;
1159
1160     DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
1161
1162     srvname = string_sprintf("_client._smtp.%s", name);
1163     rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1164     if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
1165       {
1166       if (rc == DNS_SUCCEED) *fully_qualified_name = string_copy(name);
1167       return rc;
1168       }
1169
1170     /* Search for CSA subdomain assertion SRV records from the top downwards,
1171     starting with the 2nd level domain. This order maximizes cache-friendliness.
1172     We skip the top level domains to avoid loading their nameservers and because
1173     we know they'll never have CSA SRV records. */
1174
1175     namesuff = Ustrrchr(name, '.');
1176     if (namesuff == NULL) return DNS_NOMATCH;
1177     tld = namesuff + 1;
1178     ipv6 = FALSE;
1179     limit = dns_csa_search_limit;
1180
1181     /* Use more appropriate search parameters if we are in the reverse DNS. */
1182
1183     if (strcmpic(namesuff, US".arpa") == 0)
1184       if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
1185         {
1186         namesuff -= 8;
1187         tld = namesuff + 1;
1188         limit = 3;
1189         }
1190       else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
1191         {
1192         namesuff -= 4;
1193         tld = namesuff + 1;
1194         ipv6 = TRUE;
1195         limit = 3;
1196         }
1197
1198     DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
1199
1200     /* Do not perform the search if the top level or 2nd level domains do not
1201     exist. This is quite common, and when it occurs all the search queries would
1202     go to the root or TLD name servers, which is not friendly. So we check the
1203     AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
1204     the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
1205     If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
1206     the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
1207
1208     if (rc == DNS_NOMATCH) return DNS_NOMATCH;
1209
1210     for (i = 0; i < limit; i++)
1211       {
1212       if (ipv6)
1213         {
1214         /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1215         address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1216         namesuff -= 8;
1217         if (namesuff <= name) return DNS_NOMATCH;
1218         }
1219       else
1220         /* Find the start of the preceding domain name label. */
1221         do
1222           if (--namesuff <= name) return DNS_NOMATCH;
1223         while (*namesuff != '.');
1224
1225       DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
1226
1227       srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
1228       rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1229       if (rc == DNS_AGAIN) return rc;
1230       if (rc != DNS_SUCCEED) continue;
1231
1232       /* Check that the SRV record we have found is worth returning. We don't
1233       just return the first one we find, because some lower level SRV record
1234       might make stricter assertions than its parent domain. */
1235
1236       for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1237            rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == T_SRV)
1238         {
1239         const uschar * p = rr->data;
1240
1241         /* Extract the numerical SRV fields (p is incremented) */
1242         GETSHORT(priority, p);
1243         GETSHORT(weight, p);
1244         GETSHORT(port, p);
1245
1246         /* Check the CSA version number */
1247         if (priority != 1) continue;
1248
1249         /* If it's making an interesting assertion, return this response. */
1250         if (port & 1)
1251           {
1252           *fully_qualified_name = namesuff + 1;
1253           return DNS_SUCCEED;
1254           }
1255         }
1256       }
1257     return DNS_NOMATCH;
1258     }
1259
1260   default:
1261     if (type >= 0)
1262       return dns_lookup(dnsa, name, type, fully_qualified_name);
1263   }
1264
1265 /* Control should never reach here */
1266
1267 return DNS_FAIL;
1268 }
1269
1270
1271
1272
1273
1274 /*************************************************
1275 *          Get address(es) from DNS record       *
1276 *************************************************/
1277
1278 /* The record type is either T_A for an IPv4 address or T_AAAA for an IPv6 address.
1279
1280 Argument:
1281   dnsa       the DNS answer block
1282   rr         the RR
1283
1284 Returns:     pointer to a chain of dns_address items; NULL when the dnsa was overrun
1285 */
1286
1287 dns_address *
1288 dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1289 {
1290 dns_address * yield = NULL;
1291 uschar * dnsa_lim = dnsa->answer + dnsa->answerlen;
1292
1293 if (rr->type == T_A)
1294   {
1295   uschar *p = US rr->data;
1296   if (p + 4 <= dnsa_lim)
1297     {
1298     /* the IP is not regarded as tainted */
1299     yield = store_get(sizeof(dns_address) + 20, FALSE);
1300     (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1301     yield->next = NULL;
1302     }
1303   }
1304
1305 #if HAVE_IPV6
1306
1307 else
1308   {
1309   if (rr->data + 16 <= dnsa_lim)
1310     {
1311     struct in6_addr in6;
1312     for (int i = 0; i < 16; i++) in6.s6_addr[i] = rr->data[i];
1313     yield = store_get(sizeof(dns_address) + 50, FALSE);
1314     inet_ntop(AF_INET6, &in6, CS yield->address, 50);
1315     yield->next = NULL;
1316     }
1317   }
1318 #endif  /* HAVE_IPV6 */
1319
1320 return yield;
1321 }
1322
1323
1324
1325 void
1326 dns_pattern_init(void)
1327 {
1328 if (check_dns_names_pattern[0] != 0 && !regex_check_dns_names)
1329   regex_check_dns_names =
1330     regex_must_compile(check_dns_names_pattern, FALSE, TRUE);
1331 }
1332
1333 /* vi: aw ai sw=2
1334 */
1335 /* End of dns.c */