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