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