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