Fix DKIM verify operation in -bh test mode. Bug 2017
[exim.git] / src / src / dns.c
CommitLineData
059ec3d9
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
80fea873 5/* Copyright (c) University of Cambridge 1995 - 2016 */
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
2a407b17
JH
308/* Increment the aptr in dnss, checking against dnsa length.
309Return: TRUE for a bad result
310*/
311static BOOL
dd708fd7 312dnss_inc_aptr(const dns_answer * dnsa, dns_scan * dnss, unsigned delta)
2a407b17
JH
313{
314return (dnss->aptr += delta) >= dnsa->answer + dnsa->answerlen;
315}
316
059ec3d9
PH
317/*************************************************
318* Get next DNS record from answer block *
319*************************************************/
320
321/* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
e5a9dba6
PH
322RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
323scan the additional records, and reset == RESET_NEXT to get the next record.
324The result is in static storage which must be copied if it is to be preserved.
059ec3d9
PH
325
326Arguments:
327 dnsa pointer to dns answer block
328 dnss pointer to dns scan block
4c04137d 329 reset option specifying what portion to scan, as described above
059ec3d9
PH
330
331Returns: next dns record, or NULL when no more
332*/
333
334dns_record *
dd708fd7 335dns_next_rr(const dns_answer *dnsa, dns_scan *dnss, int reset)
059ec3d9 336{
dd708fd7 337const HEADER * h = (const HEADER *)dnsa->answer;
059ec3d9
PH
338int namelen;
339
2a407b17
JH
340char * trace = NULL;
341#ifdef rr_trace
342# define TRACE DEBUG(D_dns)
343#else
344trace = trace;
345# define TRACE if (FALSE)
346#endif
347
059ec3d9
PH
348/* Reset the saved data when requested to, and skip to the first required RR */
349
350if (reset != RESET_NEXT)
351 {
2a407b17 352 TRACE debug_printf("%s: reset\n", __FUNCTION__);
059ec3d9
PH
353 dnss->rrcount = ntohs(h->qdcount);
354 dnss->aptr = dnsa->answer + sizeof(HEADER);
355
356 /* Skip over questions; failure to expand the name just gives up */
357
358 while (dnss->rrcount-- > 0)
359 {
2a407b17 360 TRACE trace = "Q-namelen";
059ec3d9 361 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
2a407b17
JH
362 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
363 if (namelen < 0) goto null_return;
364 /* skip name & type & class */
365 TRACE trace = "Q-skip";
dd708fd7 366 if (dnss_inc_aptr(dnsa, dnss, namelen+4)) goto null_return;
059ec3d9
PH
367 }
368
369 /* Get the number of answer records. */
370
371 dnss->rrcount = ntohs(h->ancount);
372
e5a9dba6
PH
373 /* Skip over answers if we want to look at the authority section. Also skip
374 the NS records (i.e. authority section) if wanting to look at the additional
059ec3d9
PH
375 records. */
376
2a407b17
JH
377 if (reset == RESET_ADDITIONAL)
378 {
379 TRACE debug_printf("%s: additional\n", __FUNCTION__);
380 dnss->rrcount += ntohs(h->nscount);
381 }
e5a9dba6
PH
382
383 if (reset == RESET_AUTHORITY || reset == RESET_ADDITIONAL)
059ec3d9 384 {
2a407b17
JH
385 TRACE if (reset == RESET_AUTHORITY)
386 debug_printf("%s: authority\n", __FUNCTION__);
059ec3d9
PH
387 while (dnss->rrcount-- > 0)
388 {
2a407b17 389 TRACE trace = "A-namelen";
059ec3d9 390 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
2a407b17
JH
391 dnss->aptr, (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
392 if (namelen < 0) goto null_return;
393 /* skip name, type, class & TTL */
394 TRACE trace = "A-hdr";
dd708fd7 395 if (dnss_inc_aptr(dnsa, dnss, namelen+8)) goto null_return;
059ec3d9 396 GETSHORT(dnss->srr.size, dnss->aptr); /* size of data portion */
2a407b17
JH
397 /* skip over it */
398 TRACE trace = "A-skip";
dd708fd7 399 if (dnss_inc_aptr(dnsa, dnss, dnss->srr.size)) goto null_return;
059ec3d9 400 }
2a407b17 401 dnss->rrcount = reset == RESET_AUTHORITY
e5a9dba6 402 ? ntohs(h->nscount) : ntohs(h->arcount);
059ec3d9 403 }
2a407b17 404 TRACE debug_printf("%s: %d RRs to read\n", __FUNCTION__, dnss->rrcount);
059ec3d9 405 }
2a407b17
JH
406else
407 TRACE debug_printf("%s: next (%d left)\n", __FUNCTION__, dnss->rrcount);
059ec3d9 408
059ec3d9
PH
409/* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
410contains the number of RR records left. */
411
412if (dnss->rrcount-- <= 0) return NULL;
413
414/* If expanding the RR domain name fails, behave as if no more records
415(something safe). */
416
2a407b17 417TRACE trace = "R-namelen";
059ec3d9 418namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, dnss->aptr,
2a407b17
JH
419 (DN_EXPAND_ARG4_TYPE) &dnss->srr.name, DNS_MAXNAME);
420if (namelen < 0) goto null_return;
059ec3d9
PH
421
422/* Move the pointer past the name and fill in the rest of the data structure
423from the following bytes. */
424
2a407b17 425TRACE trace = "R-name";
dd708fd7 426if (dnss_inc_aptr(dnsa, dnss, namelen)) goto null_return;
2a407b17
JH
427
428GETSHORT(dnss->srr.type, dnss->aptr); /* Record type */
429TRACE trace = "R-class";
dd708fd7 430if (dnss_inc_aptr(dnsa, dnss, 2)) goto null_return; /* Don't want class */
2a407b17
JH
431GETLONG(dnss->srr.ttl, dnss->aptr); /* TTL */
432GETSHORT(dnss->srr.size, dnss->aptr); /* Size of data portion */
433dnss->srr.data = dnss->aptr; /* The record's data follows */
434
435/* Unchecked increment ok here since no further access on this iteration;
436will be checked on next at "R-name". */
437
438dnss->aptr += dnss->srr.size; /* Advance to next RR */
059ec3d9
PH
439
440/* Return a pointer to the dns_record structure within the dns_answer. This is
441for convenience so that the scans can use nice-looking for loops. */
442
2a407b17
JH
443return &dnss->srr;
444
445null_return:
446 TRACE debug_printf("%s: terminate (%d RRs left). Last op: %s\n",
447 __FUNCTION__, dnss->rrcount, trace);
448 dnss->rrcount = 0;
449 return NULL;
059ec3d9
PH
450}
451
452
8688d177 453/* Extract the AUTHORITY information from the answer. If the answer isn't
4c04137d 454authoritative (AA not set), we do not extract anything.
8db90b31 455
4c04137d 456The AUTHORITY section contains NS records if the name in question was found,
8688d177
JH
457it contains a SOA record otherwise. (This is just from experience and some
458tests, is there some spec?)
8db90b31 459
8688d177
JH
460Scan the whole AUTHORITY section, since it may contain other records
461(e.g. NSEC3) too.
462
463Return: name for the authority, in an allocated string, or NULL if none found */
09b80b4e
JH
464
465static const uschar *
466dns_extract_auth_name(const dns_answer * dnsa) /* FIXME: const dns_answer */
9820a77f 467{
09b80b4e
JH
468dns_scan dnss;
469dns_record * rr;
dd708fd7 470const HEADER * h = (const HEADER *) dnsa->answer;
09b80b4e 471
8688d177
JH
472if (h->nscount && h->aa)
473 for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
474 rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
475 if (rr->type == (h->ancount ? T_NS : T_SOA))
476 return string_copy(rr->name);
09b80b4e 477return NULL;
9820a77f
HSHR
478}
479
480
059ec3d9
PH
481
482
483/*************************************************
1f4a55da
PP
484* Return whether AD bit set in DNS result *
485*************************************************/
486
487/* We do not perform DNSSEC work ourselves; if the administrator has installed
488a verifying resolver which sets AD as appropriate, though, we'll use that.
4c04137d 489(AD = Authentic Data, AA = Authoritative Answer)
1f4a55da
PP
490
491Argument: pointer to dns answer block
492Returns: bool indicating presence of AD bit
493*/
494
495BOOL
4a142059 496dns_is_secure(const dns_answer * dnsa)
1f4a55da
PP
497{
498#ifdef DISABLE_DNSSEC
499DEBUG(D_dns)
500 debug_printf("DNSSEC support disabled at build-time; dns_is_secure() false\n");
501return FALSE;
502#else
dd708fd7 503const HEADER * h = (const HEADER *) dnsa->answer;
09b80b4e
JH
504const uschar * auth_name;
505const uschar * trusted;
9820a77f
HSHR
506
507if (h->ad) return TRUE;
9820a77f 508
4c04137d 509/* If the resolver we ask is authoritative for the domain in question, it
09b80b4e
JH
510* may not set the AD but the AA bit. If we explicitly trust
511* the resolver for that domain (via a domainlist in dns_trust_aa),
512* we return TRUE to indicate a secure answer.
513*/
9820a77f 514
09b80b4e
JH
515if ( !h->aa
516 || !dns_trust_aa
25bf2076
HSHR
517 || !(trusted = expand_string(dns_trust_aa))
518 || !*trusted
09b80b4e
JH
519 || !(auth_name = dns_extract_auth_name(dnsa))
520 || OK != match_isinlist(auth_name, &trusted, 0, NULL, NULL,
94431adb 521 MCL_DOMAIN, TRUE, NULL)
09b80b4e
JH
522 )
523 return FALSE;
9820a77f 524
09b80b4e
JH
525DEBUG(D_dns) debug_printf("DNS faked the AD bit "
526 "(got AA and matched with dns_trust_aa (%s in %s))\n",
527 auth_name, dns_trust_aa);
9820a77f 528
09b80b4e 529return TRUE;
1f4a55da
PP
530#endif
531}
532
4a142059
JH
533static void
534dns_set_insecure(dns_answer * dnsa)
535{
e87c01c7 536#ifndef DISABLE_DNSSEC
4a142059 537HEADER * h = (HEADER *)dnsa->answer;
8688d177 538h->aa = h->ad = 0;
e87c01c7 539#endif
4a142059
JH
540}
541
221dff13
HSHR
542/************************************************
543 * Check whether the AA bit is set *
544 * We need this to warn if we requested AD *
4c04137d 545 * from an authoritative server *
221dff13
HSHR
546 ************************************************/
547
548BOOL
549dns_is_aa(const dns_answer *dnsa)
550{
e87c01c7
MH
551#ifdef DISABLE_DNSSEC
552return FALSE;
553#else
dd708fd7 554return ((const HEADER*)dnsa->answer)->aa;
e87c01c7 555#endif
221dff13 556}
1f4a55da
PP
557
558
559
560/*************************************************
059ec3d9
PH
561* Turn DNS type into text *
562*************************************************/
563
885ccd3e
PH
564/* Turn the coded record type into a string for printing. All those that Exim
565uses should be included here.
059ec3d9
PH
566
567Argument: record type
568Returns: pointer to string
569*/
570
571uschar *
572dns_text_type(int t)
573{
574switch(t)
575 {
33397d19
PH
576 case T_A: return US"A";
577 case T_MX: return US"MX";
578 case T_AAAA: return US"AAAA";
579 case T_A6: return US"A6";
580 case T_TXT: return US"TXT";
eae0036b 581 case T_SPF: return US"SPF";
33397d19 582 case T_PTR: return US"PTR";
885ccd3e 583 case T_SOA: return US"SOA";
33397d19
PH
584 case T_SRV: return US"SRV";
585 case T_NS: return US"NS";
8e669ac1 586 case T_CNAME: return US"CNAME";
1e06383a 587 case T_TLSA: return US"TLSA";
33397d19 588 default: return US"?";
059ec3d9
PH
589 }
590}
591
592
593
594/*************************************************
595* Cache a failed DNS lookup result *
596*************************************************/
597
598/* We cache failed lookup results so as not to experience timeouts many
599times for the same domain. We need to retain the resolver options because they
600may change. For successful lookups, we rely on resolver and/or name server
601caching.
602
603Arguments:
604 name the domain name
605 type the lookup type
606 rc the return code
607
608Returns: the return code
609*/
610
611static int
1dc92d5a 612dns_return(const uschar * name, int type, int rc)
059ec3d9 613{
5bfb4cdf 614res_state resp = os_get_dns_resolver_res();
059ec3d9
PH
615tree_node *node = store_get_perm(sizeof(tree_node) + 290);
616sprintf(CS node->name, "%.255s-%s-%lx", name, dns_text_type(type),
f794c12b 617 (unsigned long) resp->options);
059ec3d9
PH
618node->data.val = rc;
619(void)tree_insertnode(&tree_dns_fails, node);
620return rc;
621}
622
059ec3d9
PH
623/*************************************************
624* Do basic DNS lookup *
625*************************************************/
626
627/* Call the resolver to look up the given domain name, using the given type,
628and check the result. The error code TRY_AGAIN is documented as meaning "non-
4c04137d 629Authoritative Host not found, or SERVERFAIL". Sometimes there are badly set
059ec3d9
PH
630up nameservers that produce this error continually, so there is the option of
631providing a list of domains for which this is treated as a non-existent
632host.
633
634Arguments:
635 dnsa pointer to dns_answer structure
636 name name to look up
637 type type of DNS record required (T_A, T_MX, etc)
638
639Returns: DNS_SUCCEED successful lookup
640 DNS_NOMATCH name not found (NXDOMAIN)
641 or name contains illegal characters (if checking)
30e18802 642 or name is an IP address (for IP address lookup)
059ec3d9
PH
643 DNS_NODATA domain exists, but no data for this type (NODATA)
644 DNS_AGAIN soft failure, try again later
645 DNS_FAIL DNS failure
646*/
647
648int
1dc92d5a 649dns_basic_lookup(dns_answer *dnsa, const uschar *name, int type)
059ec3d9
PH
650{
651#ifndef STAND_ALONE
7156b1ef 652int rc = -1;
55414b25 653const uschar *save_domain;
059ec3d9 654#endif
5bfb4cdf 655res_state resp = os_get_dns_resolver_res();
059ec3d9
PH
656
657tree_node *previous;
658uschar node_name[290];
659
660/* DNS lookup failures of any kind are cached in a tree. This is mainly so that
661a timeout on one domain doesn't happen time and time again for messages that
662have many addresses in the same domain. We rely on the resolver and name server
663caching for successful lookups. */
664
665sprintf(CS node_name, "%.255s-%s-%lx", name, dns_text_type(type),
f794c12b 666 (unsigned long) resp->options);
4b0fe319 667if ((previous = tree_search(tree_dns_fails, node_name)))
059ec3d9
PH
668 {
669 DEBUG(D_dns) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
670 name, dns_text_type(type),
671 (previous->data.val == DNS_NOMATCH)? "DNS_NOMATCH" :
672 (previous->data.val == DNS_NODATA)? "DNS_NODATA" :
673 (previous->data.val == DNS_AGAIN)? "DNS_AGAIN" :
674 (previous->data.val == DNS_FAIL)? "DNS_FAIL" : "??");
675 return previous->data.val;
676 }
677
8c5d388a 678#ifdef SUPPORT_I18N
9d4319df
JH
679/* Convert all names to a-label form before doing lookup */
680 {
681 uschar * alabel;
682 uschar * errstr = NULL;
766e7a65
JH
683 DEBUG(D_dns) if (string_is_utf8(name))
684 debug_printf("convert utf8 '%s' to alabel for for lookup\n", name);
9d4319df
JH
685 if ((alabel = string_domain_utf8_to_alabel(name, &errstr)), errstr)
686 {
687 DEBUG(D_dns)
37bf366e 688 debug_printf("DNS name '%s' utf8 conversion to alabel failed: %s\n", name,
9d4319df
JH
689 errstr);
690 host_find_failed_syntax = TRUE;
691 return DNS_NOMATCH;
692 }
693 name = alabel;
694 }
695#endif
696
4c04137d 697/* If configured, check the hygiene of the name passed to lookup. Otherwise,
059ec3d9
PH
698although DNS lookups may give REFUSED at the lower level, some resolvers
699turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
700domains cannot be in the DNS. The check is now done by a regular expression;
701give it space for substring storage to save it having to get its own if the
702regex has substrings that are used - the default uses a conditional.
703
704This test is omitted for PTR records. These occur only in calls from the dnsdb
705lookup, which constructs the names itself, so they should be OK. Besides,
706bitstring labels don't conform to normal name syntax. (But the aren't used any
707more.)
708
709For SRV records, we omit the initial _smtp._tcp. components at the start. */
710
711#ifndef STAND_ALONE /* Omit this for stand-alone tests */
712
482d1455 713if (check_dns_names_pattern[0] != 0 && type != T_PTR && type != T_TXT)
059ec3d9 714 {
1dc92d5a 715 const uschar *checkname = name;
059ec3d9
PH
716 int ovector[3*(EXPAND_MAXN+1)];
717
476be7e2 718 dns_pattern_init();
059ec3d9
PH
719
720 /* For an SRV lookup, skip over the first two components (the service and
721 protocol names, which both start with an underscore). */
722
b4161d10 723 if (type == T_SRV || type == T_TLSA)
059ec3d9
PH
724 {
725 while (*checkname++ != '.');
726 while (*checkname++ != '.');
727 }
728
1dc92d5a 729 if (pcre_exec(regex_check_dns_names, NULL, CCS checkname, Ustrlen(checkname),
059ec3d9
PH
730 0, PCRE_EOPT, ovector, sizeof(ovector)/sizeof(int)) < 0)
731 {
732 DEBUG(D_dns)
733 debug_printf("DNS name syntax check failed: %s (%s)\n", name,
734 dns_text_type(type));
735 host_find_failed_syntax = TRUE;
736 return DNS_NOMATCH;
737 }
738 }
739
740#endif /* STAND_ALONE */
741
742/* Call the resolver; for an overlong response, res_search() will return the
bef5a11f
PH
743number of bytes the message would need, so we need to check for this case. The
744effect is to truncate overlong data.
745
30e18802
PH
746On some systems, res_search() will recognize "A-for-A" queries and return
747the IP address instead of returning -1 with h_error=HOST_NOT_FOUND. Some
748nameservers are also believed to do this. It is, of course, contrary to the
749specification of the DNS, so we lock it out. */
750
cc00f4af 751if ((type == T_A || type == T_AAAA) && string_is_ip_address(name, NULL) != 0)
30e18802
PH
752 return DNS_NOMATCH;
753
754/* If we are running in the test harness, instead of calling the normal resolver
bef5a11f
PH
755(res_search), we call fakens_search(), which recognizes certain special
756domains, and interfaces to a fake nameserver for certain special zones. */
757
cc00f4af
JH
758dnsa->answerlen = running_in_test_harness
759 ? fakens_search(name, type, dnsa->answer, MAXPACKET)
760 : res_search(CCS name, C_IN, type, dnsa->answer, MAXPACKET);
059ec3d9 761
80a47a2c
TK
762if (dnsa->answerlen > MAXPACKET)
763 {
764 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) resulted in overlong packet (size %d), truncating to %d.\n",
765 name, dns_text_type(type), dnsa->answerlen, MAXPACKET);
766 dnsa->answerlen = MAXPACKET;
767 }
059ec3d9
PH
768
769if (dnsa->answerlen < 0) switch (h_errno)
770 {
771 case HOST_NOT_FOUND:
4b0fe319
JH
772 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
773 "returning DNS_NOMATCH\n", name, dns_text_type(type));
774 return dns_return(name, type, DNS_NOMATCH);
059ec3d9
PH
775
776 case TRY_AGAIN:
4b0fe319
JH
777 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
778 name, dns_text_type(type));
059ec3d9 779
4b0fe319 780 /* Cut this out for various test programs */
1dc92d5a 781#ifndef STAND_ALONE
4b0fe319
JH
782 save_domain = deliver_domain;
783 deliver_domain = string_copy(name); /* set $domain */
784 rc = match_isinlist(name, (const uschar **)&dns_again_means_nonexist, 0, NULL, NULL,
785 MCL_DOMAIN, TRUE, NULL);
786 deliver_domain = save_domain;
787 if (rc != OK)
788 {
789 DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
790 return dns_return(name, type, DNS_AGAIN);
791 }
792 DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
793 "DNS_NOMATCH\n", name);
794 return dns_return(name, type, DNS_NOMATCH);
059ec3d9 795
1dc92d5a 796#else /* For stand-alone tests */
4b0fe319 797 return dns_return(name, type, DNS_AGAIN);
1dc92d5a 798#endif
059ec3d9
PH
799
800 case NO_RECOVERY:
4b0fe319
JH
801 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
802 "returning DNS_FAIL\n", name, dns_text_type(type));
803 return dns_return(name, type, DNS_FAIL);
059ec3d9
PH
804
805 case NO_DATA:
4b0fe319
JH
806 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
807 "returning DNS_NODATA\n", name, dns_text_type(type));
808 return dns_return(name, type, DNS_NODATA);
059ec3d9
PH
809
810 default:
4b0fe319
JH
811 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
812 "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
813 return dns_return(name, type, DNS_FAIL);
059ec3d9
PH
814 }
815
816DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
817 name, dns_text_type(type));
818
819return DNS_SUCCEED;
820}
821
822
823
824
825/************************************************
826* Do a DNS lookup and handle CNAMES *
827************************************************/
828
829/* Look up the given domain name, using the given type. Follow CNAMEs if
830necessary, but only so many times. There aren't supposed to be CNAME chains in
831the DNS, but you are supposed to cope with them if you find them.
832
833The assumption is made that if the resolver gives back records of the
834requested type *and* a CNAME, we don't need to make another call to look up
835the CNAME. I can't see how it could return only some of the right records. If
836it's done a CNAME lookup in the past, it will have all of them; if not, it
837won't return any.
838
839If fully_qualified_name is not NULL, set it to point to the full name
840returned by the resolver, if this is different to what it is given, unless
841the returned name starts with "*" as some nameservers seem to be returning
766e7a65
JH
842wildcards in this form. In international mode "different" means "alabel
843forms are different".
059ec3d9
PH
844
845Arguments:
846 dnsa pointer to dns_answer structure
847 name domain name to look up
848 type DNS record type (T_A, T_MX, etc)
849 fully_qualified_name if not NULL, return the returned name here if its
850 contents are different (i.e. it must be preset)
851
852Returns: DNS_SUCCEED successful lookup
853 DNS_NOMATCH name not found
854 DNS_NODATA no data found
855 DNS_AGAIN soft failure, try again later
856 DNS_FAIL DNS failure
857*/
858
859int
1dc92d5a 860dns_lookup(dns_answer *dnsa, const uschar *name, int type,
55414b25 861 const uschar **fully_qualified_name)
059ec3d9
PH
862{
863int i;
1dc92d5a 864const uschar *orig_name = name;
c85b3043 865BOOL secure_so_far = TRUE;
059ec3d9
PH
866
867/* Loop to follow CNAME chains so far, but no further... */
868
869for (i = 0; i < 10; i++)
870 {
806c3df9 871 uschar * data;
059ec3d9
PH
872 dns_record *rr, cname_rr, type_rr;
873 dns_scan dnss;
874 int datalen, rc;
875
876 /* DNS lookup failures get passed straight back. */
877
dd708fd7
JH
878 if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED)
879 return rc;
059ec3d9
PH
880
881 /* We should have either records of the required type, or a CNAME record,
882 or both. We need to know whether both exist for getting the fully qualified
883 name, but avoid scanning more than necessary. Note that we must copy the
884 contents of any rr blocks returned by dns_next_rr() as they use the same
885 area in the dnsa block. */
886
887 cname_rr.data = type_rr.data = NULL;
888 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
8688d177 889 rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
059ec3d9
PH
890 if (rr->type == type)
891 {
892 if (type_rr.data == NULL) type_rr = *rr;
893 if (cname_rr.data != NULL) break;
894 }
dd708fd7
JH
895 else if (rr->type == T_CNAME)
896 cname_rr = *rr;
059ec3d9 897
a2042e78
PH
898 /* For the first time round this loop, if a CNAME was found, take the fully
899 qualified name from it; otherwise from the first data record, if present. */
059ec3d9 900
dd708fd7 901 if (i == 0 && fully_qualified_name)
059ec3d9 902 {
dd708fd7
JH
903 uschar * rr_name = cname_rr.data
904 ? cname_rr.name : type_rr.data ? type_rr.name : NULL;
766e7a65
JH
905 if ( rr_name
906 && Ustrcmp(rr_name, *fully_qualified_name) != 0
907 && rr_name[0] != '*'
8c5d388a 908#ifdef SUPPORT_I18N
766e7a65
JH
909 && ( !string_is_utf8(*fully_qualified_name)
910 || Ustrcmp(rr_name,
911 string_domain_utf8_to_alabel(*fully_qualified_name, NULL)) != 0
912 )
913#endif
914 )
915 *fully_qualified_name = string_copy_dnsdomain(rr_name);
059ec3d9
PH
916 }
917
918 /* If any data records of the correct type were found, we are done. */
919
806c3df9 920 if (type_rr.data)
c85b3043
JH
921 {
922 if (!secure_so_far) /* mark insecure if any element of CNAME chain was */
4a142059 923 dns_set_insecure(dnsa);
c85b3043
JH
924 return DNS_SUCCEED;
925 }
059ec3d9
PH
926
927 /* If there are no data records, we need to re-scan the DNS using the
928 domain given in the CNAME record, which should exist (otherwise we should
929 have had a failure from dns_lookup). However code against the possibility of
930 its not existing. */
931
806c3df9
JH
932 if (!cname_rr.data)
933 return DNS_FAIL;
934
935 data = store_get(256);
dd708fd7
JH
936 if ((datalen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
937 cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, 256)) < 0)
806c3df9 938 return DNS_FAIL;
059ec3d9 939 name = data;
a2042e78 940
c85b3043
JH
941 if (!dns_is_secure(dnsa))
942 secure_so_far = FALSE;
943
a2042e78 944 DEBUG(D_dns) debug_printf("CNAME found: change to %s\n", name);
059ec3d9
PH
945 } /* Loop back to do another lookup */
946
947/*Control reaches here after 10 times round the CNAME loop. Something isn't
948right... */
949
950log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
951return DNS_FAIL;
952}
953
954
955
33397d19
PH
956
957
958
959/************************************************
960* Do a DNS lookup and handle virtual types *
961************************************************/
962
9820a77f 963/* This function handles some invented "lookup types" that synthesize features
8e669ac1 964not available in the basic types. The special types all have negative values.
33397d19
PH
965Positive type values are passed straight on to dns_lookup().
966
967Arguments:
968 dnsa pointer to dns_answer structure
969 name domain name to look up
970 type DNS record type (T_A, T_MX, etc or a "special")
971 fully_qualified_name if not NULL, return the returned name here if its
972 contents are different (i.e. it must be preset)
973
974Returns: DNS_SUCCEED successful lookup
975 DNS_NOMATCH name not found
976 DNS_NODATA no data found
977 DNS_AGAIN soft failure, try again later
978 DNS_FAIL DNS failure
979*/
980
981int
1dc92d5a 982dns_special_lookup(dns_answer *dnsa, const uschar *name, int type,
55414b25 983 const uschar **fully_qualified_name)
33397d19 984{
d2a2c69b 985switch (type)
e5a9dba6 986 {
d2a2c69b
JH
987 /* The "mx hosts only" type doesn't require any special action here */
988 case T_MXH:
1705dd20 989 return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
d2a2c69b
JH
990
991 /* Find nameservers for the domain or the nearest enclosing zone, excluding
992 the root servers. */
993 case T_ZNS:
1705dd20
JH
994 type = T_NS;
995 /* FALLTHROUGH */
d2a2c69b 996 case T_SOA:
1705dd20
JH
997 {
998 const uschar *d = name;
999 while (d != 0)
1000 {
1001 int rc = dns_lookup(dnsa, d, type, fully_qualified_name);
1002 if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
1003 while (*d != 0 && *d != '.') d++;
1004 if (*d++ == 0) break;
1005 }
1006 return DNS_NOMATCH;
1007 }
d2a2c69b
JH
1008
1009 /* Try to look up the Client SMTP Authorization SRV record for the name. If
1010 there isn't one, search from the top downwards for a CSA record in a parent
1011 domain, which might be making assertions about subdomains. If we find a record
1012 we set fully_qualified_name to whichever lookup succeeded, so that the caller
1013 can tell whether to look at the explicit authorization field or the subdomain
1014 assertion field. */
1015 case T_CSA:
1705dd20
JH
1016 {
1017 uschar *srvname, *namesuff, *tld, *p;
1018 int priority, weight, port;
1019 int limit, rc, i;
1020 BOOL ipv6;
1021 dns_record *rr;
1022 dns_scan dnss;
1023
1024 DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
1025
1026 srvname = string_sprintf("_client._smtp.%s", name);
1027 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1028 if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
1029 {
1030 if (rc == DNS_SUCCEED) *fully_qualified_name = string_copy(name);
1031 return rc;
1032 }
d2a2c69b 1033
1705dd20
JH
1034 /* Search for CSA subdomain assertion SRV records from the top downwards,
1035 starting with the 2nd level domain. This order maximizes cache-friendliness.
1036 We skip the top level domains to avoid loading their nameservers and because
1037 we know they'll never have CSA SRV records. */
d2a2c69b 1038
1705dd20
JH
1039 namesuff = Ustrrchr(name, '.');
1040 if (namesuff == NULL) return DNS_NOMATCH;
1041 tld = namesuff + 1;
1042 ipv6 = FALSE;
1043 limit = dns_csa_search_limit;
1044
1045 /* Use more appropriate search parameters if we are in the reverse DNS. */
1046
1047 if (strcmpic(namesuff, US".arpa") == 0)
1048 if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
1049 {
1050 namesuff -= 8;
d2a2c69b 1051 tld = namesuff + 1;
1705dd20
JH
1052 limit = 3;
1053 }
1054 else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
1055 {
1056 namesuff -= 4;
1057 tld = namesuff + 1;
1058 ipv6 = TRUE;
1059 limit = 3;
1060 }
d2a2c69b 1061
1705dd20 1062 DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
d2a2c69b 1063
1705dd20
JH
1064 /* Do not perform the search if the top level or 2nd level domains do not
1065 exist. This is quite common, and when it occurs all the search queries would
1066 go to the root or TLD name servers, which is not friendly. So we check the
1067 AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
1068 the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
1069 If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
1070 the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
1071
1072 if (rc == DNS_NOMATCH)
1073 {
1074 /* This is really gross. The successful return value from res_search() is
1075 the packet length, which is stored in dnsa->answerlen. If we get a
1076 negative DNS reply then res_search() returns -1, which causes the bounds
1077 checks for name decompression to fail when it is treated as a packet
1078 length, which in turn causes the authority search to fail. The correct
1079 packet length has been lost inside libresolv, so we have to guess a
1080 replacement value. (The only way to fix this properly would be to
1081 re-implement res_search() and res_query() so that they don't muddle their
1082 success and packet length return values.) For added safety we only reset
1083 the packet length if the packet header looks plausible. */
1084
dd708fd7 1085 const HEADER * h = (const HEADER *)dnsa->answer;
1705dd20
JH
1086 if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
1087 && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
1088 && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
1089 && ntohs(h->nscount) >= 1)
1090 dnsa->answerlen = MAXPACKET;
1091
1092 for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
8688d177 1093 rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
1705dd20
JH
1094 )
1095 if (rr->type != T_SOA) continue;
1096 else if (strcmpic(rr->name, US"") == 0 ||
1097 strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
1098 else break;
1099 }
d2a2c69b 1100
1705dd20
JH
1101 for (i = 0; i < limit; i++)
1102 {
1103 if (ipv6)
1104 {
1105 /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
1106 address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
1107 namesuff -= 8;
1108 if (namesuff <= name) return DNS_NOMATCH;
1109 }
1110 else
1111 /* Find the start of the preceding domain name label. */
1112 do
1113 if (--namesuff <= name) return DNS_NOMATCH;
1114 while (*namesuff != '.');
1115
1116 DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
1117
1118 srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
1119 rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
1120 if (rc == DNS_AGAIN) return rc;
1121 if (rc != DNS_SUCCEED) continue;
1122
1123 /* Check that the SRV record we have found is worth returning. We don't
1124 just return the first one we find, because some lower level SRV record
1125 might make stricter assertions than its parent domain. */
1126
1127 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
8688d177 1128 rr; rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == T_SRV)
1705dd20 1129 {
dd708fd7 1130 const uschar * p = rr->data;
d2a2c69b 1131
1705dd20 1132 /* Extract the numerical SRV fields (p is incremented) */
1705dd20
JH
1133 GETSHORT(priority, p);
1134 GETSHORT(weight, p); weight = weight; /* compiler quietening */
1135 GETSHORT(port, p);
d2a2c69b 1136
1705dd20
JH
1137 /* Check the CSA version number */
1138 if (priority != 1) continue;
d2a2c69b 1139
1705dd20
JH
1140 /* If it's making an interesting assertion, return this response. */
1141 if (port & 1)
d2a2c69b 1142 {
1705dd20
JH
1143 *fully_qualified_name = namesuff + 1;
1144 return DNS_SUCCEED;
d2a2c69b 1145 }
d2a2c69b 1146 }
1705dd20
JH
1147 }
1148 return DNS_NOMATCH;
1149 }
e5a9dba6 1150
d2a2c69b 1151 default:
1705dd20
JH
1152 if (type >= 0)
1153 return dns_lookup(dnsa, name, type, fully_qualified_name);
e5a9dba6
PH
1154 }
1155
33397d19
PH
1156/* Control should never reach here */
1157
1158return DNS_FAIL;
1159}
1160
1161
1162
059ec3d9
PH
1163
1164
1165/*************************************************
1166* Get address(es) from DNS record *
1167*************************************************/
1168
d57d474f 1169/* The record type is either T_A for an IPv4 address or T_AAAA for an IPv6 address.
059ec3d9
PH
1170
1171Argument:
1172 dnsa the DNS answer block
1173 rr the RR
1174
e1a3f32f 1175Returns: pointer to a chain of dns_address items; NULL when the dnsa was overrun
059ec3d9
PH
1176*/
1177
1178dns_address *
1179dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1180{
e1a3f32f
JH
1181dns_address * yield = NULL;
1182uschar * dnsa_lim = dnsa->answer + dnsa->answerlen;
059ec3d9
PH
1183
1184if (rr->type == T_A)
1185 {
d2a2c69b 1186 uschar *p = US rr->data;
e1a3f32f
JH
1187 if (p + 4 <= dnsa_lim)
1188 {
1189 yield = store_get(sizeof(dns_address) + 20);
1190 (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1191 yield->next = NULL;
1192 }
059ec3d9
PH
1193 }
1194
1195#if HAVE_IPV6
1196
059ec3d9
PH
1197else
1198 {
e1a3f32f
JH
1199 if (rr->data + 16 <= dnsa_lim)
1200 {
d57d474f
JH
1201 struct in6_addr in6;
1202 int i;
f794c12b 1203 for (i = 0; i < 16; i++) in6.s6_addr[i] = rr->data[i];
e1a3f32f 1204 yield = store_get(sizeof(dns_address) + 50);
d57d474f 1205 inet_ntop(AF_INET6, &in6, CS yield->address, 50);
e1a3f32f
JH
1206 yield->next = NULL;
1207 }
059ec3d9
PH
1208 }
1209#endif /* HAVE_IPV6 */
1210
1211return yield;
1212}
1213
476be7e2
JH
1214
1215
1216void
1217dns_pattern_init(void)
1218{
1219if (check_dns_names_pattern[0] != 0 && !regex_check_dns_names)
1220 regex_check_dns_names =
1221 regex_must_compile(check_dns_names_pattern, FALSE, TRUE);
1222}
1223
8c51eead
JH
1224/* vi: aw ai sw=2
1225*/
059ec3d9 1226/* End of dns.c */