Change host_lookup re-forward from byname to bydns; checking DNSSEC
[exim.git] / src / src / dns.c
CommitLineData
059ec3d9
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
5a66c31b 5/* Copyright (c) University of Cambridge 1995 - 2014 */
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
059ec3d9 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 */
e7726cbf
PH
43uschar *endname;
44uschar name[256];
433a2980
PH
45uschar utilname[256];
46uschar *aptr = answerptr; /* Locally modified */
47struct stat statbuf;
48
49/* Remove terminating dot. */
e7726cbf
PH
50
51if (domain[len - 1] == '.') len--;
52Ustrncpy(name, domain, len);
53name[len] = 0;
54endname = name + len;
bef5a11f 55
433a2980
PH
56/* This code, for forcing TRY_AGAIN and NO_RECOVERY, is here so that it works
57for the old test suite that uses a real nameserver. When the old test suite is
58eventually abandoned, this code could be moved into the fakens utility. */
59
bef5a11f
PH
60if (len >= 14 && Ustrcmp(endname - 14, "test.again.dns") == 0)
61 {
62 int delay = Uatoi(name); /* digits at the start of the name */
63 DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
64 name, dns_text_type(type));
65 if (delay > 0)
66 {
67 DEBUG(D_dns) debug_printf("delaying %d seconds\n", delay);
68 sleep(delay);
69 }
70 h_errno = TRY_AGAIN;
71 return -1;
72 }
73
74if (len >= 13 && Ustrcmp(endname - 13, "test.fail.dns") == 0)
75 {
76 DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
77 name, dns_text_type(type));
78 h_errno = NO_RECOVERY;
79 return -1;
80 }
81
433a2980
PH
82/* Look for the fakens utility, and if it exists, call it. */
83
5f3d0983
HSHR
84(void)string_format(utilname, sizeof(utilname), "%s/bin/fakens",
85 config_main_directory);
433a2980
PH
86
87if (stat(CS utilname, &statbuf) >= 0)
bef5a11f 88 {
433a2980
PH
89 pid_t pid;
90 int infd, outfd, rc;
91 uschar *argv[5];
92
3735e326 93 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) using fakens\n", name, dns_text_type(type));
433a2980
PH
94
95 argv[0] = utilname;
5f3d0983 96 argv[1] = config_main_directory;
433a2980
PH
97 argv[2] = name;
98 argv[3] = dns_text_type(type);
99 argv[4] = NULL;
100
101 pid = child_open(argv, NULL, 0000, &infd, &outfd, FALSE);
102 if (pid < 0)
103 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to run fakens: %s",
104 strerror(errno));
105
106 len = 0;
107 rc = -1;
108 while (asize > 0 && (rc = read(outfd, aptr, asize)) > 0)
109 {
110 len += rc;
111 aptr += rc; /* Don't modify the actual arguments, because they */
112 asize -= rc; /* may need to be passed on to res_search(). */
113 }
bef5a11f 114
1fb7660f
JH
115 /* If we ran out of output buffer before exhasting the return,
116 carry on reading and counting it. */
117
118 if (asize == 0)
119 while ((rc = read(outfd, name, sizeof(name))) > 0)
120 len += rc;
121
433a2980
PH
122 if (rc < 0)
123 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "read from fakens failed: %s",
124 strerror(errno));
bef5a11f 125
433a2980 126 switch(child_close(pid, 0))
bef5a11f 127 {
433a2980
PH
128 case 0: return len;
129 case 1: h_errno = HOST_NOT_FOUND; return -1;
130 case 2: h_errno = TRY_AGAIN; return -1;
131 default:
132 case 3: h_errno = NO_RECOVERY; return -1;
133 case 4: h_errno = NO_DATA; return -1;
134 case 5: /* Pass on to res_search() */
135 DEBUG(D_dns) debug_printf("fakens returned PASS_ON\n");
bef5a11f
PH
136 }
137 }
8e013028
HSHR
138else
139 {
140 DEBUG(D_dns) debug_printf("fakens (%s) not found\n", utilname);
141 }
bef5a11f 142
433a2980 143/* fakens utility not found, or it returned "pass on" */
bef5a11f 144
433a2980 145DEBUG(D_dns) debug_printf("passing %s on to res_search()\n", domain);
e7726cbf
PH
146
147return res_search(CS domain, C_IN, type, answerptr, size);
bef5a11f
PH
148}
149
150
059ec3d9
PH
151
152/*************************************************
153* Initialize and configure resolver *
154*************************************************/
155
156/* Initialize the resolver and the storage for holding DNS answers if this is
157the first time we have been here, and set the resolver options.
158
159Arguments:
160 qualify_single TRUE to set the RES_DEFNAMES option
161 search_parents TRUE to set the RES_DNSRCH option
8c51eead 162 use_dnssec TRUE to set the RES_USE_DNSSEC option
059ec3d9
PH
163
164Returns: nothing
165*/
166
167void
8c51eead 168dns_init(BOOL qualify_single, BOOL search_parents, BOOL use_dnssec)
059ec3d9 169{
5bfb4cdf
PP
170res_state resp = os_get_dns_resolver_res();
171
172if ((resp->options & RES_INIT) == 0)
059ec3d9 173 {
5bfb4cdf
PP
174 DEBUG(D_resolver) resp->options |= RES_DEBUG; /* For Cygwin */
175 os_put_dns_resolver_res(resp);
059ec3d9 176 res_init();
5bfb4cdf
PP
177 DEBUG(D_resolver) resp->options |= RES_DEBUG;
178 os_put_dns_resolver_res(resp);
059ec3d9
PH
179 }
180
5bfb4cdf
PP
181resp->options &= ~(RES_DNSRCH | RES_DEFNAMES);
182resp->options |= (qualify_single? RES_DEFNAMES : 0) |
059ec3d9 183 (search_parents? RES_DNSRCH : 0);
5bfb4cdf
PP
184if (dns_retrans > 0) resp->retrans = dns_retrans;
185if (dns_retry > 0) resp->retry = dns_retry;
e97d1f08
PP
186
187#ifdef RES_USE_EDNS0
188if (dns_use_edns0 >= 0)
189 {
190 if (dns_use_edns0)
5bfb4cdf 191 resp->options |= RES_USE_EDNS0;
e97d1f08 192 else
5bfb4cdf 193 resp->options &= ~RES_USE_EDNS0;
e97d1f08
PP
194 DEBUG(D_resolver)
195 debug_printf("Coerced resolver EDNS0 support %s.\n",
196 dns_use_edns0 ? "on" : "off");
197 }
198#else
199if (dns_use_edns0 >= 0)
200 DEBUG(D_resolver)
201 debug_printf("Unable to %sset EDNS0 without resolver support.\n",
202 dns_use_edns0 ? "" : "un");
203#endif
5bfb4cdf 204
1f4a55da
PP
205#ifndef DISABLE_DNSSEC
206# ifdef RES_USE_DNSSEC
207# ifndef RES_USE_EDNS0
208# error Have RES_USE_DNSSEC but not RES_USE_EDNS0? Something hinky ...
209# endif
8c51eead
JH
210if (use_dnssec)
211 resp->options |= RES_USE_DNSSEC;
0fbd9bff 212if (dns_dnssec_ok >= 0)
1f4a55da 213 {
0fbd9bff 214 if (dns_use_edns0 == 0 && dns_dnssec_ok != 0)
1f4a55da
PP
215 {
216 DEBUG(D_resolver)
0fbd9bff 217 debug_printf("CONFLICT: dns_use_edns0 forced false, dns_dnssec_ok forced true, ignoring latter!\n");
1f4a55da
PP
218 }
219 else
220 {
0fbd9bff 221 if (dns_dnssec_ok)
1f4a55da
PP
222 resp->options |= RES_USE_DNSSEC;
223 else
224 resp->options &= ~RES_USE_DNSSEC;
225 DEBUG(D_resolver) debug_printf("Coerced resolver DNSSEC support %s.\n",
0fbd9bff 226 dns_dnssec_ok ? "on" : "off");
1f4a55da
PP
227 }
228 }
229# else
0fbd9bff 230if (dns_dnssec_ok >= 0)
1f4a55da
PP
231 DEBUG(D_resolver)
232 debug_printf("Unable to %sset DNSSEC without resolver support.\n",
0fbd9bff 233 dns_dnssec_ok ? "" : "un");
8c51eead
JH
234if (use_dnssec)
235 DEBUG(D_resolver)
93d4b03a 236 debug_printf("Unable to set DNSSEC without resolver support.\n");
1f4a55da
PP
237# endif
238#endif /* DISABLE_DNSSEC */
239
5bfb4cdf 240os_put_dns_resolver_res(resp);
059ec3d9
PH
241}
242
243
244
245/*************************************************
246* Build key name for PTR records *
247*************************************************/
248
249/* This function inverts an IP address and adds the relevant domain, to produce
250a name that can be used to look up PTR records.
251
252Arguments:
253 string the IP address as a string
254 buffer a suitable buffer, long enough to hold the result
255
256Returns: nothing
257*/
258
259void
55414b25 260dns_build_reverse(const uschar *string, uschar *buffer)
059ec3d9 261{
55414b25 262const uschar *p = string + Ustrlen(string);
059ec3d9
PH
263uschar *pp = buffer;
264
265/* Handle IPv4 address */
266
267#if HAVE_IPV6
268if (Ustrchr(string, ':') == NULL)
269#endif
270 {
271 int i;
272 for (i = 0; i < 4; i++)
273 {
55414b25 274 const uschar *ppp = p;
059ec3d9
PH
275 while (ppp > string && ppp[-1] != '.') ppp--;
276 Ustrncpy(pp, ppp, p - ppp);
277 pp += p - ppp;
278 *pp++ = '.';
279 p = ppp - 1;
280 }
281 Ustrcpy(pp, "in-addr.arpa");
282 }
283
284/* Handle IPv6 address; convert to binary so as to fill out any
285abbreviation in the textual form. */
286
287#if HAVE_IPV6
288else
289 {
290 int i;
291 int v6[4];
292 (void)host_aton(string, v6);
293
294 /* The original specification for IPv6 reverse lookup was to invert each
295 nibble, and look in the ip6.int domain. The domain was subsequently
296 changed to ip6.arpa. */
297
298 for (i = 3; i >= 0; i--)
299 {
300 int j;
301 for (j = 0; j < 32; j += 4)
302 {
303 sprintf(CS pp, "%x.", (v6[i] >> j) & 15);
304 pp += 2;
305 }
306 }
307 Ustrcpy(pp, "ip6.arpa.");
308
309 /* Another way of doing IPv6 reverse lookups was proposed in conjunction
310 with A6 records. However, it fell out of favour when they did. The
311 alternative was to construct a binary key, and look in ip6.arpa. I tried
312 to make this code do that, but I could not make it work on Solaris 8. The
313 resolver seems to lose the initial backslash somehow. However, now that
314 this style of reverse lookup has been dropped, it doesn't matter. These
315 lines are left here purely for historical interest. */
316
317 /**************************************************
318 Ustrcpy(pp, "\\[x");
319 pp += 3;
320
321 for (i = 0; i < 4; i++)
322 {
323 sprintf(pp, "%08X", v6[i]);
324 pp += 8;
325 }
326 Ustrcpy(pp, "].ip6.arpa.");
327 **************************************************/
328
329 }
330#endif
331}
332
333
334
335
336/*************************************************
337* Get next DNS record from answer block *
338*************************************************/
339
340/* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
e5a9dba6
PH
341RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
342scan the additional records, and reset == RESET_NEXT to get the next record.
343The result is in static storage which must be copied if it is to be preserved.
059ec3d9
PH
344
345Arguments:
346 dnsa pointer to dns answer block
347 dnss pointer to dns scan block
348 reset option specifing what portion to scan, as described above
349
350Returns: next dns record, or NULL when no more
351*/
352
353dns_record *
354dns_next_rr(dns_answer *dnsa, dns_scan *dnss, int reset)
355{
356HEADER *h = (HEADER *)dnsa->answer;
357int namelen;
358
359/* Reset the saved data when requested to, and skip to the first required RR */
360
361if (reset != RESET_NEXT)
362 {
363 dnss->rrcount = ntohs(h->qdcount);
364 dnss->aptr = dnsa->answer + sizeof(HEADER);
365
366 /* Skip over questions; failure to expand the name just gives up */
367
368 while (dnss->rrcount-- > 0)
369 {
370 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
371 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
372 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
373 dnss->aptr += namelen + 4; /* skip name & type & class */
374 }
375
376 /* Get the number of answer records. */
377
378 dnss->rrcount = ntohs(h->ancount);
379
e5a9dba6
PH
380 /* Skip over answers if we want to look at the authority section. Also skip
381 the NS records (i.e. authority section) if wanting to look at the additional
059ec3d9
PH
382 records. */
383
e5a9dba6
PH
384 if (reset == RESET_ADDITIONAL) dnss->rrcount += ntohs(h->nscount);
385
386 if (reset == RESET_AUTHORITY || reset == RESET_ADDITIONAL)
059ec3d9 387 {
059ec3d9
PH
388 while (dnss->rrcount-- > 0)
389 {
390 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
391 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
392 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
393 dnss->aptr += namelen + 8; /* skip name, type, class & TTL */
394 GETSHORT(dnss->srr.size, dnss->aptr); /* size of data portion */
395 dnss->aptr += dnss->srr.size; /* skip over it */
396 }
e5a9dba6
PH
397 dnss->rrcount = (reset == RESET_AUTHORITY)
398 ? ntohs(h->nscount) : ntohs(h->arcount);
059ec3d9
PH
399 }
400 }
401
059ec3d9
PH
402/* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
403contains the number of RR records left. */
404
405if (dnss->rrcount-- <= 0) return NULL;
406
407/* If expanding the RR domain name fails, behave as if no more records
408(something safe). */
409
410namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, dnss->aptr,
411 (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
412if (namelen < 0) { dnss->rrcount = 0; return NULL; }
413
414/* Move the pointer past the name and fill in the rest of the data structure
415from the following bytes. */
416
417dnss->aptr += namelen;
418GETSHORT(dnss->srr.type, dnss->aptr); /* Record type */
419dnss->aptr += 6; /* Don't want class or TTL */
420GETSHORT(dnss->srr.size, dnss->aptr); /* Size of data portion */
421dnss->srr.data = dnss->aptr; /* The record's data follows */
422dnss->aptr += dnss->srr.size; /* Advance to next RR */
423
424/* Return a pointer to the dns_record structure within the dns_answer. This is
425for convenience so that the scans can use nice-looking for loops. */
426
427return &(dnss->srr);
428}
429
430
431
432
433/*************************************************
1f4a55da
PP
434* Return whether AD bit set in DNS result *
435*************************************************/
436
437/* We do not perform DNSSEC work ourselves; if the administrator has installed
438a verifying resolver which sets AD as appropriate, though, we'll use that.
439(AD = Authentic Data)
440
441Argument: pointer to dns answer block
442Returns: bool indicating presence of AD bit
443*/
444
445BOOL
4a142059 446dns_is_secure(const dns_answer * dnsa)
1f4a55da
PP
447{
448#ifdef DISABLE_DNSSEC
449DEBUG(D_dns)
450 debug_printf("DNSSEC support disabled at build-time; dns_is_secure() false\n");
451return FALSE;
452#else
453HEADER *h = (HEADER *)dnsa->answer;
454return h->ad ? TRUE : FALSE;
455#endif
456}
457
4a142059
JH
458static void
459dns_set_insecure(dns_answer * dnsa)
460{
461HEADER * h = (HEADER *)dnsa->answer;
462h->ad = 0;
463}
464
1f4a55da
PP
465
466
467
468/*************************************************
059ec3d9
PH
469* Turn DNS type into text *
470*************************************************/
471
885ccd3e
PH
472/* Turn the coded record type into a string for printing. All those that Exim
473uses should be included here.
059ec3d9
PH
474
475Argument: record type
476Returns: pointer to string
477*/
478
479uschar *
480dns_text_type(int t)
481{
482switch(t)
483 {
33397d19
PH
484 case T_A: return US"A";
485 case T_MX: return US"MX";
486 case T_AAAA: return US"AAAA";
487 case T_A6: return US"A6";
488 case T_TXT: return US"TXT";
eae0036b 489 case T_SPF: return US"SPF";
33397d19 490 case T_PTR: return US"PTR";
885ccd3e 491 case T_SOA: return US"SOA";
33397d19
PH
492 case T_SRV: return US"SRV";
493 case T_NS: return US"NS";
8e669ac1 494 case T_CNAME: return US"CNAME";
1e06383a 495 case T_TLSA: return US"TLSA";
33397d19 496 default: return US"?";
059ec3d9
PH
497 }
498}
499
500
501
502/*************************************************
503* Cache a failed DNS lookup result *
504*************************************************/
505
506/* We cache failed lookup results so as not to experience timeouts many
507times for the same domain. We need to retain the resolver options because they
508may change. For successful lookups, we rely on resolver and/or name server
509caching.
510
511Arguments:
512 name the domain name
513 type the lookup type
514 rc the return code
515
516Returns: the return code
517*/
518
519static int
1dc92d5a 520dns_return(const uschar * name, int type, int rc)
059ec3d9 521{
5bfb4cdf 522res_state resp = os_get_dns_resolver_res();
059ec3d9
PH
523tree_node *node = store_get_perm(sizeof(tree_node) + 290);
524sprintf(CS node->name, "%.255s-%s-%lx", name, dns_text_type(type),
5bfb4cdf 525 resp->options);
059ec3d9
PH
526node->data.val = rc;
527(void)tree_insertnode(&tree_dns_fails, node);
528return rc;
529}
530
531
532
533/*************************************************
534* Do basic DNS lookup *
535*************************************************/
536
537/* Call the resolver to look up the given domain name, using the given type,
538and check the result. The error code TRY_AGAIN is documented as meaning "non-
539Authoritive Host not found, or SERVERFAIL". Sometimes there are badly set
540up nameservers that produce this error continually, so there is the option of
541providing a list of domains for which this is treated as a non-existent
542host.
543
544Arguments:
545 dnsa pointer to dns_answer structure
546 name name to look up
547 type type of DNS record required (T_A, T_MX, etc)
548
549Returns: DNS_SUCCEED successful lookup
550 DNS_NOMATCH name not found (NXDOMAIN)
551 or name contains illegal characters (if checking)
30e18802 552 or name is an IP address (for IP address lookup)
059ec3d9
PH
553 DNS_NODATA domain exists, but no data for this type (NODATA)
554 DNS_AGAIN soft failure, try again later
555 DNS_FAIL DNS failure
556*/
557
558int
1dc92d5a 559dns_basic_lookup(dns_answer *dnsa, const uschar *name, int type)
059ec3d9
PH
560{
561#ifndef STAND_ALONE
7156b1ef 562int rc = -1;
55414b25 563const uschar *save_domain;
059ec3d9 564#endif
5bfb4cdf 565res_state resp = os_get_dns_resolver_res();
059ec3d9
PH
566
567tree_node *previous;
568uschar node_name[290];
569
570/* DNS lookup failures of any kind are cached in a tree. This is mainly so that
571a timeout on one domain doesn't happen time and time again for messages that
572have many addresses in the same domain. We rely on the resolver and name server
573caching for successful lookups. */
574
575sprintf(CS node_name, "%.255s-%s-%lx", name, dns_text_type(type),
5bfb4cdf 576 resp->options);
059ec3d9
PH
577previous = tree_search(tree_dns_fails, node_name);
578if (previous != NULL)
579 {
580 DEBUG(D_dns) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
581 name, dns_text_type(type),
582 (previous->data.val == DNS_NOMATCH)? "DNS_NOMATCH" :
583 (previous->data.val == DNS_NODATA)? "DNS_NODATA" :
584 (previous->data.val == DNS_AGAIN)? "DNS_AGAIN" :
585 (previous->data.val == DNS_FAIL)? "DNS_FAIL" : "??");
586 return previous->data.val;
587 }
588
9d4319df
JH
589#ifdef EXPERIMENTAL_INTERNATIONAL
590/* Convert all names to a-label form before doing lookup */
591 {
592 uschar * alabel;
593 uschar * errstr = NULL;
766e7a65
JH
594 DEBUG(D_dns) if (string_is_utf8(name))
595 debug_printf("convert utf8 '%s' to alabel for for lookup\n", name);
9d4319df
JH
596 if ((alabel = string_domain_utf8_to_alabel(name, &errstr)), errstr)
597 {
598 DEBUG(D_dns)
37bf366e 599 debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name,
9d4319df
JH
600 errstr);
601 host_find_failed_syntax = TRUE;
602 return DNS_NOMATCH;
603 }
604 name = alabel;
605 }
606#endif
607
059ec3d9
PH
608/* If configured, check the hygene of the name passed to lookup. Otherwise,
609although DNS lookups may give REFUSED at the lower level, some resolvers
610turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
611domains cannot be in the DNS. The check is now done by a regular expression;
612give it space for substring storage to save it having to get its own if the
613regex has substrings that are used - the default uses a conditional.
614
615This test is omitted for PTR records. These occur only in calls from the dnsdb
616lookup, which constructs the names itself, so they should be OK. Besides,
617bitstring labels don't conform to normal name syntax. (But the aren't used any
618more.)
619
620For SRV records, we omit the initial _smtp._tcp. components at the start. */
621
622#ifndef STAND_ALONE /* Omit this for stand-alone tests */
623
482d1455 624if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
059ec3d9 625 {
1dc92d5a 626 const uschar *checkname = name;
059ec3d9
PH
627 int ovector[3*(EXPAND_MAXN+1)];
628
476be7e2 629 dns_pattern_init();
059ec3d9
PH
630
631 /* For an SRV lookup, skip over the first two components (the service and
632 protocol names, which both start with an underscore). */
633
b4161d10 634 if (type == T_SRV || type == T_TLSA)
059ec3d9
PH
635 {
636 while (*checkname++ != '.');
637 while (*checkname++ != '.');
638 }
639
1dc92d5a 640 if (pcre_exec(regex_check_dns_names, NULL, CCS checkname, Ustrlen(checkname),
059ec3d9
PH
641 0, PCRE_EOPT, ovector, sizeof(ovector)/sizeof(int)) < 0)
642 {
643 DEBUG(D_dns)
644 debug_printf("DNS name syntax check failed: %s (%s)\n", name,
645 dns_text_type(type));
646 host_find_failed_syntax = TRUE;
647 return DNS_NOMATCH;
648 }
649 }
650
651#endif /* STAND_ALONE */
652
653/* Call the resolver; for an overlong response, res_search() will return the
bef5a11f
PH
654number of bytes the message would need, so we need to check for this case. The
655effect is to truncate overlong data.
656
30e18802
PH
657On some systems, res_search() will recognize "A-for-A" queries and return
658the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
659nameservers are also believed to do this. It is, of course, contrary to the
660specification of the DNS, so we lock it out. */
661
cc00f4af 662if ((type == T_A || type == T_AAAA) && string_is_ip_address(name, NULL) != 0)
30e18802
PH
663 return DNS_NOMATCH;
664
665/* If we are running in the test harness, instead of calling the normal resolver
bef5a11f
PH
666(res_search), we call fakens_search(), which recognizes certain special
667domains, and interfaces to a fake nameserver for certain special zones. */
668
cc00f4af
JH
669dnsa->answerlen = running_in_test_harness
670 ? fakens_search(name, type, dnsa->answer, MAXPACKET)
671 : res_search(CCS name, C_IN, type, dnsa->answer, MAXPACKET);
059ec3d9 672
80a47a2c
TK
673if (dnsa->answerlen > MAXPACKET)
674 {
675 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet (size %d), truncating to %d.\n",
676 name, dns_text_type(type), dnsa->answerlen, MAXPACKET);
677 dnsa->answerlen = MAXPACKET;
678 }
059ec3d9
PH
679
680if (dnsa->answerlen < 0) switch (h_errno)
681 {
682 case HOST_NOT_FOUND:
683 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
684 "returning DNS_NOMATCH\n", name, dns_text_type(type));
685 return dns_return(name, type, DNS_NOMATCH);
686
687 case TRY_AGAIN:
688 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
689 name, dns_text_type(type));
690
691 /* Cut this out for various test programs */
1dc92d5a 692#ifndef STAND_ALONE
55414b25 693 save_domain = deliver_domain;
1dc92d5a 694 deliver_domain = string_copy(name); /* set $domain */
55414b25 695 rc = match_isinlist(name, (const uschar **)&dns_again_means_nonexist, 0, NULL, NULL,
059ec3d9 696 MCL_DOMAIN, TRUE, NULL);
55414b25 697 deliver_domain = save_domain;
059ec3d9
PH
698 if (rc != OK)
699 {
700 DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
701 return dns_return(name, type, DNS_AGAIN);
702 }
703 DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
704 "DNS_NOMATCH\n", name);
705 return dns_return(name, type, DNS_NOMATCH);
706
1dc92d5a 707#else /* For stand-alone tests */
059ec3d9 708 return dns_return(name, type, DNS_AGAIN);
1dc92d5a 709#endif
059ec3d9
PH
710
711 case NO_RECOVERY:
712 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
713 "returning DNS_FAIL\n", name, dns_text_type(type));
714 return dns_return(name, type, DNS_FAIL);
715
716 case NO_DATA:
717 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
718 "returning DNS_NODATA\n", name, dns_text_type(type));
719 return dns_return(name, type, DNS_NODATA);
720
721 default:
722 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
723 "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
724 return dns_return(name, type, DNS_FAIL);
725 }
726
727DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
728 name, dns_text_type(type));
729
730return DNS_SUCCEED;
731}
732
733
734
735
736/************************************************
737* Do a DNS lookup and handle CNAMES *
738************************************************/
739
740/* Look up the given domain name, using the given type. Follow CNAMEs if
741necessary, but only so many times. There aren't supposed to be CNAME chains in
742the DNS, but you are supposed to cope with them if you find them.
743
744The assumption is made that if the resolver gives back records of the
745requested type *and* a CNAME, we don't need to make another call to look up
746the CNAME. I can't see how it could return only some of the right records. If
747it's done a CNAME lookup in the past, it will have all of them; if not, it
748won't return any.
749
750If fully_qualified_name is not NULL, set it to point to the full name
751returned by the resolver, if this is different to what it is given, unless
752the returned name starts with "*" as some nameservers seem to be returning
766e7a65
JH
753wildcards in this form. In international mode "different" means "alabel
754forms are different".
059ec3d9
PH
755
756Arguments:
757 dnsa pointer to dns_answer structure
758 name domain name to look up
759 type DNS record type (T_A, T_MX, etc)
760 fully_qualified_name if not NULL, return the returned name here if its
761 contents are different (i.e. it must be preset)
762
763Returns: DNS_SUCCEED successful lookup
764 DNS_NOMATCH name not found
765 DNS_NODATA no data found
766 DNS_AGAIN soft failure, try again later
767 DNS_FAIL DNS failure
768*/
769
770int
1dc92d5a 771dns_lookup(dns_answer *dnsa, const uschar *name, int type,
55414b25 772 const uschar **fully_qualified_name)
059ec3d9
PH
773{
774int i;
1dc92d5a 775const uschar *orig_name = name;
c85b3043 776BOOL secure_so_far = TRUE;
059ec3d9
PH
777
778/* Loop to follow CNAME chains so far, but no further... */
779
780for (i = 0; i < 10; i++)
781 {
782 uschar data[256];
783 dns_record *rr, cname_rr, type_rr;
784 dns_scan dnss;
785 int datalen, rc;
786
787 /* DNS lookup failures get passed straight back. */
788
789 if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED) return rc;
790
791 /* We should have either records of the required type, or a CNAME record,
792 or both. We need to know whether both exist for getting the fully qualified
793 name, but avoid scanning more than necessary. Note that we must copy the
794 contents of any rr blocks returned by dns_next_rr() as they use the same
795 area in the dnsa block. */
796
797 cname_rr.data = type_rr.data = NULL;
798 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
799 rr != NULL;
800 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
801 {
802 if (rr->type == type)
803 {
804 if (type_rr.data == NULL) type_rr = *rr;
805 if (cname_rr.data != NULL) break;
806 }
807 else if (rr->type == T_CNAME) cname_rr = *rr;
808 }
809
a2042e78
PH
810 /* For the first time round this loop, if a CNAME was found, take the fully
811 qualified name from it; otherwise from the first data record, if present. */
059ec3d9 812
a2042e78 813 if (i == 0 && fully_qualified_name != NULL)
059ec3d9 814 {
766e7a65
JH
815 uschar * rr_name = cname_rr.data ? cname_rr.name
816 : type_rr.data ? type_rr.name : NULL;
817 if ( rr_name
818 && Ustrcmp(rr_name, *fully_qualified_name) != 0
819 && rr_name[0] != '*'
820#ifdef EXPERIMENTAL_INTERNATIONAL
821 && ( !string_is_utf8(*fully_qualified_name)
822 || Ustrcmp(rr_name,
823 string_domain_utf8_to_alabel(*fully_qualified_name, NULL)) != 0
824 )
825#endif
826 )
827 *fully_qualified_name = string_copy_dnsdomain(rr_name);
059ec3d9
PH
828 }
829
830 /* If any data records of the correct type were found, we are done. */
831
c85b3043
JH
832 if (type_rr.data != NULL)
833 {
834 if (!secure_so_far) /* mark insecure if any element of CNAME chain was */
4a142059 835 dns_set_insecure(dnsa);
c85b3043
JH
836 return DNS_SUCCEED;
837 }
059ec3d9
PH
838
839 /* If there are no data records, we need to re-scan the DNS using the
840 domain given in the CNAME record, which should exist (otherwise we should
841 have had a failure from dns_lookup). However code against the possibility of
842 its not existing. */
843
844 if (cname_rr.data == NULL) return DNS_FAIL;
845 datalen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
1dc92d5a 846 cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
059ec3d9
PH
847 if (datalen < 0) return DNS_FAIL;
848 name = data;
a2042e78 849
c85b3043
JH
850 if (!dns_is_secure(dnsa))
851 secure_so_far = FALSE;
852
a2042e78 853 DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
059ec3d9
PH
854 } /* Loop back to do another lookup */
855
856/*Control reaches here after 10 times round the CNAME loop. Something isn't
857right... */
858
859log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
860return DNS_FAIL;
861}
862
863
864
33397d19
PH
865
866
867
868/************************************************
869* Do a DNS lookup and handle virtual types *
870************************************************/
871
8e669ac1
PH
872/* This function handles some invented "lookup types" that synthesize feature
873not available in the basic types. The special types all have negative values.
33397d19
PH
874Positive type values are passed straight on to dns_lookup().
875
876Arguments:
877 dnsa pointer to dns_answer structure
878 name domain name to look up
879 type DNS record type (T_A, T_MX, etc or a "special")
880 fully_qualified_name if not NULL, return the returned name here if its
881 contents are different (i.e. it must be preset)
882
883Returns: DNS_SUCCEED successful lookup
884 DNS_NOMATCH name not found
885 DNS_NODATA no data found
886 DNS_AGAIN soft failure, try again later
887 DNS_FAIL DNS failure
888*/
889
890int
1dc92d5a 891dns_special_lookup(dns_answer *dnsa, const uschar *name, int type,
55414b25 892 const uschar **fully_qualified_name)
33397d19 893{
d2a2c69b 894switch (type)
e5a9dba6 895 {
d2a2c69b
JH
896 /* The "mx hosts only" type doesn't require any special action here */
897 case T_MXH:
898 return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
899
900 /* Find nameservers for the domain or the nearest enclosing zone, excluding
901 the root servers. */
902 case T_ZNS:
903 type = T_NS;
904 /* FALLTHROUGH */
905 case T_SOA:
906 {
907 const uschar *d = name;
908 while (d != 0)
909 {
910 int rc = dns_lookup(dnsa, d, type, fully_qualified_name);
911 if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
912 while (*d != 0 && *d != '.') d++;
913 if (*d++ == 0) break;
914 }
915 return DNS_NOMATCH;
916 }
917
918 /* Try to look up the Client SMTP Authorization SRV record for the name. If
919 there isn't one, search from the top downwards for a CSA record in a parent
920 domain, which might be making assertions about subdomains. If we find a record
921 we set fully_qualified_name to whichever lookup succeeded, so that the caller
922 can tell whether to look at the explicit authorization field or the subdomain
923 assertion field. */
924 case T_CSA:
925 {
926 uschar *srvname, *namesuff, *tld, *p;
927 int priority, weight, port;
928 int limit, rc, i;
929 BOOL ipv6;
930 dns_record *rr;
931 dns_scan dnss;
932
933 DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
934
935 srvname = string_sprintf("_client._smtp.%s", name);
936 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
937 if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
938 {
939 if (rc == DNS_SUCCEED) *fully_qualified_name = string_copy(name);
940 return rc;
941 }
942
943 /* Search for CSA subdomain assertion SRV records from the top downwards,
944 starting with the 2nd level domain. This order maximizes cache-friendliness.
945 We skip the top level domains to avoid loading their nameservers and because
946 we know they'll never have CSA SRV records. */
947
948 namesuff = Ustrrchr(name, '.');
949 if (namesuff == NULL) return DNS_NOMATCH;
950 tld = namesuff + 1;
951 ipv6 = FALSE;
952 limit = dns_csa_search_limit;
953
954 /* Use more appropriate search parameters if we are in the reverse DNS. */
955
956 if (strcmpic(namesuff, US".arpa") == 0)
957 {
958 if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
959 {
960 namesuff -= 8;
961 tld = namesuff + 1;
962 limit = 3;
963 }
964 else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
965 {
966 namesuff -= 4;
967 tld = namesuff + 1;
968 ipv6 = TRUE;
969 limit = 3;
970 }
971 }
972
973 DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
974
975 /* Do not perform the search if the top level or 2nd level domains do not
976 exist. This is quite common, and when it occurs all the search queries would
977 go to the root or TLD name servers, which is not friendly. So we check the
978 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
979 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
980 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
981 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
982
983 if (rc == DNS_NOMATCH)
984 {
985 /* This is really gross. The successful return value from res_search() is
986 the packet length, which is stored in dnsa->answerlen. If we get a
987 negative DNS reply then res_search() returns -1, which causes the bounds
988 checks for name decompression to fail when it is treated as a packet
989 length, which in turn causes the authority search to fail. The correct
990 packet length has been lost inside libresolv, so we have to guess a
991 replacement value. (The only way to fix this properly would be to
992 re-implement res_search() and res_query() so that they don't muddle their
993 success and packet length return values.) For added safety we only reset
994 the packet length if the packet header looks plausible. */
995
996 HEADER *h = (HEADER *)dnsa->answer;
997 if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
998 && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
999 && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
1000 && ntohs(h->nscount) >= 1)
1001 dnsa->answerlen = MAXPACKET;
1002
1003 for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
1004 rr != NULL;
1005 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1006 if (rr->type != T_SOA) continue;
1007 else if (strcmpic(rr->name, US"") == 0 ||
1008 strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
1009 else break;
1010 }
1011
1012 for (i = 0; i < limit; i++)
1013 {
1014 if (ipv6)
1015 {
1016 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1017 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1018 namesuff -= 8;
1019 if (namesuff <= name) return DNS_NOMATCH;
1020 }
1021 else
1022 /* Find the start of the preceding domain name label. */
1023 do
1024 if (--namesuff <= name) return DNS_NOMATCH;
1025 while (*namesuff != '.');
1026
1027 DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
1028
1029 srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
1030 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1031 if (rc == DNS_AGAIN) return rc;
1032 if (rc != DNS_SUCCEED) continue;
1033
1034 /* Check that the SRV record we have found is worth returning. We don't
1035 just return the first one we find, because some lower level SRV record
1036 might make stricter assertions than its parent domain. */
1037
1038 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1039 rr != NULL;
1040 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1041 {
1042 if (rr->type != T_SRV) continue;
1043
1044 /* Extract the numerical SRV fields (p is incremented) */
1045 p = rr->data;
1046 GETSHORT(priority, p);
1047 GETSHORT(weight, p); weight = weight; /* compiler quietening */
1048 GETSHORT(port, p);
1049
1050 /* Check the CSA version number */
1051 if (priority != 1) continue;
1052
1053 /* If it's making an interesting assertion, return this response. */
1054 if (port & 1)
1055 {
1056 *fully_qualified_name = namesuff + 1;
1057 return DNS_SUCCEED;
1058 }
1059 }
1060 }
1061 return DNS_NOMATCH;
1062 }
e5a9dba6 1063
d2a2c69b
JH
1064 default:
1065 if (type >= 0)
1066 return dns_lookup(dnsa, name, type, fully_qualified_name);
e5a9dba6
PH
1067 }
1068
33397d19
PH
1069/* Control should never reach here */
1070
1071return DNS_FAIL;
1072}
1073
1074
1075
059ec3d9
PH
1076
1077
1078/*************************************************
1079* Get address(es) from DNS record *
1080*************************************************/
1081
1082/* The record type is either T_A for an IPv4 address or T_AAAA (or T_A6 when
d2a2c69b 1083supported) for an IPv6 address.
059ec3d9
PH
1084
1085Argument:
1086 dnsa the DNS answer block
1087 rr the RR
1088
e1a3f32f 1089Returns: pointer to a chain of dns_address items; NULL when the dnsa was overrun
059ec3d9
PH
1090*/
1091
1092dns_address *
1093dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1094{
e1a3f32f
JH
1095dns_address * yield = NULL;
1096uschar * dnsa_lim = dnsa->answer + dnsa->answerlen;
059ec3d9
PH
1097
1098if (rr->type == T_A)
1099 {
d2a2c69b 1100 uschar *p = US rr->data;
e1a3f32f
JH
1101 if (p + 4 <= dnsa_lim)
1102 {
1103 yield = store_get(sizeof(dns_address) + 20);
1104 (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1105 yield->next = NULL;
1106 }
059ec3d9
PH
1107 }
1108
1109#if HAVE_IPV6
1110
059ec3d9
PH
1111else
1112 {
e1a3f32f
JH
1113 if (rr->data + 16 <= dnsa_lim)
1114 {
1115 yield = store_get(sizeof(dns_address) + 50);
1116 inet_ntop(AF_INET6, US rr->data, CS yield->address, 50);
1117 yield->next = NULL;
1118 }
059ec3d9
PH
1119 }
1120#endif /* HAVE_IPV6 */
1121
1122return yield;
1123}
1124
476be7e2
JH
1125
1126
1127void
1128dns_pattern_init(void)
1129{
1130if (check_dns_names_pattern[0] != 0 && !regex_check_dns_names)
1131 regex_check_dns_names =
1132 regex_must_compile(check_dns_names_pattern, FALSE, TRUE);
1133}
1134
8c51eead
JH
1135/* vi: aw ai sw=2
1136*/
059ec3d9 1137/* End of dns.c */