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