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