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