1 /*************************************************
2 * fakens - A Fake Nameserver Program *
3 *************************************************/
5 /* This program exists to support the testing of DNS handling code in Exim. It
6 avoids the need to install special zones in a real nameserver. When Exim is
7 running in its (new) test harness, DNS lookups are first passed to this program
8 instead of to the real resolver. (With a few exceptions - see the discussion in
9 the test suite's README file.) The program is also passed the name of the Exim
10 spool directory; it expects to find its "zone files" in ../dnszones relative to
11 that directory. Note that there is little checking in this program. The fake
12 zone files are assumed to be syntactically valid.
14 The zones that are handled are found by scanning the dnszones directory. A file
15 whose name is of the form db.ip4.x is a zone file for .x.in-addr.arpa; a file
16 whose name is of the form db.ip6.x is a zone file for .x.ip6.arpa; a file of
17 the form db.anything.else is a zone file for .anything.else. A file of the form
18 qualify.x.y specifies the domain that is used to qualify single-component
19 names, except for the name "dontqualify".
21 The arguments to the program are:
23 the name of the Exim spool directory
24 the domain name that is being sought
25 the DNS record type that is being sought
27 The output from the program is written to stdout. It is supposed to be in
28 exactly the same format as a traditional namserver response (see RFC 1035) so
29 that Exim can process it as normal. At present, no compression is used.
30 Error messages are written to stderr.
32 The return codes from the program are zero for success, and otherwise the
33 values that are set in h_errno after a failing call to the normal resolver:
35 1 HOST_NOT_FOUND host not found (authoritative)
36 2 TRY_AGAIN server failure
37 3 NO_RECOVERY non-recoverable error
38 4 NO_DATA valid name, no data of requested type
40 In a real nameserver, TRY_AGAIN is also used for a non-authoritative not found,
41 but it is not used for that here. There is also one extra return code:
43 5 PASS_ON requests Exim to call res_search()
45 This is used for zones that fakens does not recognize. It is also used if a
46 line in the zone file contains exactly this:
50 and the domain is not found. It converts the the result to PASS_ON instead of
53 Any DNS record line in a zone file can be prefixed with "DNSSEC" and
54 at least one space; if all the records found by a lookup are marked
55 as such then the response will have the "AD" bit set. */
63 #include <arpa/nameser.h>
64 #include <sys/types.h>
72 typedef unsigned char uschar;
75 #define CCS (const char *)
76 #define US (unsigned char *)
78 #define Ustrcat(s,t) strcat(CS(s),CCS(t))
79 #define Ustrchr(s,n) US strchr(CCS(s),n)
80 #define Ustrcmp(s,t) strcmp(CCS(s),CCS(t))
81 #define Ustrcpy(s,t) strcpy(CS(s),CCS(t))
82 #define Ustrlen(s) (int)strlen(CCS(s))
83 #define Ustrncmp(s,t,n) strncmp(CCS(s),CCS(t),n)
84 #define Ustrncpy(s,t,n) strncpy(CS(s),CCS(t),n)
86 typedef struct zoneitem {
91 typedef struct tlist {
96 /* On some (older?) operating systems, the standard ns_t_xxx definitions are
97 not available, and only the older T_xxx ones exist in nameser.h. If ns_t_a is
98 not defined, assume we are in this state. A really old system might not even
99 know about AAAA and SRV at all. */
103 # define ns_t_ns T_NS
104 # define ns_t_cname T_CNAME
105 # define ns_t_soa T_SOA
106 # define ns_t_ptr T_PTR
107 # define ns_t_mx T_MX
108 # define ns_t_txt T_TXT
109 # define ns_t_aaaa T_AAAA
110 # define ns_t_srv T_SRV
111 # define ns_t_tlsa T_TLSA
123 static tlist type_list[] = {
126 { US"CNAME", ns_t_cname },
127 /* { US"SOA", ns_t_soa }, Not currently in use */
128 { US"PTR", ns_t_ptr },
130 { US"TXT", ns_t_txt },
131 { US"AAAA", ns_t_aaaa },
132 { US"SRV", ns_t_srv },
133 { US"TLSA", ns_t_tlsa },
139 /*************************************************
140 * Get memory and sprintf into it *
141 *************************************************/
143 /* This is used when building a table of zones and their files.
146 format a format string
149 Returns: pointer to formatted string
153 fcopystring(uschar *format, ...)
158 va_start(ap, format);
159 vsprintf(buffer, format, ap);
161 yield = (uschar *)malloc(Ustrlen(buffer) + 1);
162 Ustrcpy(yield, buffer);
167 /*************************************************
168 * Pack name into memory *
169 *************************************************/
171 /* This function packs a domain name into memory according to DNS rules. At
172 present, it doesn't do any compression.
178 Returns: the updated value of pk
182 packname(uschar *name, uschar *pk)
187 while (*p != 0 && *p != '.') p++;
189 memmove(pk, name, p - name);
191 name = (*p == 0)? p : p + 1;
198 shortfield(uschar ** pp, uschar * pk)
203 while (isdigit(*p)) value = value*10 + *p++ - '0';
204 while (isspace(*p)) p++;
206 *pk++ = (value >> 8) & 255;
213 /*************************************************
214 * Scan file for RRs *
215 *************************************************/
217 /* This function scans an open "zone file" for appropriate records, and adds
218 any that are found to the output buffer.
222 zone the current zone name
223 domain the domain we are looking for
224 qtype the type of RR we want
225 qtypelen the length of qtype
226 pkptr points to the output buffer pointer; this is updated
227 countptr points to the record count; this is updated
229 Returns: 0 on success, else HOST_NOT_FOUND or NO_DATA or NO_RECOVERY or
230 PASS_ON - the latter if a "PASS ON NOT FOUND" line is seen
234 find_records(FILE *f, uschar *zone, uschar *domain, uschar *qtype,
235 int qtypelen, uschar **pkptr, int *countptr, BOOL * dnssec)
237 int yield = HOST_NOT_FOUND;
238 int domainlen = Ustrlen(domain);
239 BOOL pass_on_not_found = FALSE;
243 uschar rrdomain[256];
244 uschar RRdomain[256];
246 /* Decode the required type */
248 for (typeptr = type_list; typeptr->name != NULL; typeptr++)
249 { if (Ustrcmp(typeptr->name, qtype) == 0) break; }
250 if (typeptr->name == NULL)
252 fprintf(stderr, "fakens: unknown record type %s\n", qtype);
256 rrdomain[0] = 0; /* No previous domain */
257 (void)fseek(f, 0, SEEK_SET); /* Start again at the beginning */
259 *dnssec = TRUE; /* cancelled by first nonsecure rec found */
263 while (fgets(CS buffer, sizeof(buffer), f) != NULL)
267 BOOL found_cname = FALSE;
269 int tvalue = typeptr->value;
270 int qtlen = qtypelen;
274 while (isspace(*p)) p++;
275 if (*p == 0 || *p == ';') continue;
277 if (Ustrncmp(p, US"PASS ON NOT FOUND", 17) == 0)
279 pass_on_not_found = TRUE;
283 ep = buffer + Ustrlen(buffer);
284 while (isspace(ep[-1])) ep--;
288 if (Ustrncmp(p, US"DNSSEC ", 7) == 0) /* tagged as secure */
296 uschar *pp = rrdomain;
297 uschar *PP = RRdomain;
315 /* Compare domain names; first check for a wildcard */
317 if (rrdomain[0] == '*')
319 int restlen = Ustrlen(rrdomain) - 1;
320 if (domainlen > restlen &&
321 Ustrcmp(domain + domainlen - restlen, rrdomain + 1) != 0) continue;
324 /* Not a wildcard RR */
326 else if (Ustrcmp(domain, rrdomain) != 0) continue;
328 /* The domain matches */
330 if (yield == HOST_NOT_FOUND) yield = NO_DATA;
332 /* Compare RR types; a CNAME record is always returned */
334 while (isspace(*p)) p++;
336 if (Ustrncmp(p, "CNAME", 5) == 0)
342 else if (Ustrncmp(p, qtype, qtypelen) != 0 || !isspace(p[qtypelen])) continue;
344 /* Found a relevant record */
347 *dnssec = FALSE; /* cancel AD return */
350 *countptr = *countptr + 1;
353 while (isspace(*p)) p++;
355 /* For a wildcard record, use the search name; otherwise use the record's
356 name in its original case because it might contain upper case letters. */
358 pk = packname((rrdomain[0] == '*')? domain : RRdomain, pk);
359 *pk++ = (tvalue >> 8) & 255;
360 *pk++ = (tvalue) & 255;
362 *pk++ = 1; /* class = IN */
364 pk += 4; /* TTL field; don't care */
366 rdlptr = pk; /* remember rdlength field */
369 /* The rest of the data depends on the type */
373 case ns_t_soa: /* Not currently used */
377 for (i = 0; i < 4; i++)
380 while (isdigit(*p)) value = value*10 + *p++ - '0';
386 /* The only occurrence of a double colon is for ::1 */
388 if (Ustrcmp(p, "::1") == 0)
394 else for (i = 0; i < 8; i++)
399 value = value * 16 + toupper(*p) - (isdigit(*p)? '0' : '7');
402 *pk++ = (value >> 8) & 255;
409 pk = shortfield(&p, pk);
410 if (ep[-1] != '.') sprintf(ep, "%s.", zone);
411 pk = packname(p, pk);
417 if (*p == '"') p++; /* Should always be the case */
418 while (*p != 0 && *p != '"') *pk++ = *p++;
423 pk = shortfield(&p, pk); /* usage */
424 pk = shortfield(&p, pk); /* selector */
425 pk = shortfield(&p, pk); /* match type */
428 value = toupper(*p) - (isdigit(*p) ? '0' : '7') << 4;
431 value |= toupper(*p) - (isdigit(*p) ? '0' : '7');
440 for (i = 0; i < 3; i++)
443 while (isdigit(*p)) value = value*10 + *p++ - '0';
444 while (isspace(*p)) p++;
445 *pk++ = (value >> 8) & 255;
454 if (ep[-1] != '.') sprintf(ep, "%s.", zone);
455 pk = packname(p, pk);
460 /* Fill in the length, and we are done with this RR */
462 rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255;
463 rdlptr[1] = (pk -rdlptr - 2) & 255;
467 return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield;
472 /*************************************************
473 * Entry point and main program *
474 *************************************************/
477 main(int argc, char **argv)
481 int domlen, qtypelen;
487 uschar *qualify = NULL;
489 uschar *zonefile = NULL;
499 fprintf(stderr, "fakens: expected 3 arguments, received %d\n", argc-1);
505 (void)sprintf(buffer, "%s/../dnszones", argv[1]);
507 d = opendir(CCS buffer);
510 fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer,
515 while ((de = readdir(d)) != NULL)
517 uschar *name = de->d_name;
518 if (Ustrncmp(name, "qualify.", 8) == 0)
520 qualify = fcopystring("%s", name + 7);
523 if (Ustrncmp(name, "db.", 3) != 0) continue;
524 if (Ustrncmp(name + 3, "ip4.", 4) == 0)
525 zones[zonecount].zone = fcopystring("%s.in-addr.arpa", name + 6);
526 else if (Ustrncmp(name + 3, "ip6.", 4) == 0)
527 zones[zonecount].zone = fcopystring("%s.ip6.arpa", name + 6);
529 zones[zonecount].zone = fcopystring("%s", name + 2);
530 zones[zonecount++].zonefile = fcopystring("%s", name);
534 /* Get the RR type and upper case it, and check that we recognize it. */
536 Ustrncpy(qtype, argv[3], sizeof(qtype));
537 qtypelen = Ustrlen(qtype);
538 for (p = qtype; *p != 0; p++) *p = toupper(*p);
540 /* Find the domain, lower case it, check that it is in a zone that we handle,
541 and set up the zone file name. The zone names in the table all start with a
544 domlen = Ustrlen(argv[2]);
545 if (argv[2][domlen-1] == '.') domlen--;
546 Ustrncpy(domain, argv[2], domlen);
548 for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]);
550 if (Ustrchr(domain, '.') == NULL && qualify != NULL &&
551 Ustrcmp(domain, "dontqualify") != 0)
553 Ustrcat(domain, qualify);
554 domlen += Ustrlen(qualify);
557 for (i = 0; i < zonecount; i++)
560 zone = zones[i].zone;
561 zlen = Ustrlen(zone);
562 if (Ustrcmp(domain, zone+1) == 0 || (domlen >= zlen &&
563 Ustrcmp(domain + domlen - zlen, zone) == 0))
565 zonefile = zones[i].zonefile;
570 if (zonefile == NULL)
572 fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain);
576 (void)sprintf(buffer, "%s/../dnszones/%s", argv[1], zonefile);
578 /* Initialize the start of the response packet. We don't have to fake up
579 everything, because we know that Exim will look only at the answer and
580 additional section parts. */
582 memset(packet, 0, 12);
585 /* Open the zone file. */
587 f = fopen(buffer, "r");
590 fprintf(stderr, "fakens: failed to open %s: %s\n", buffer, strerror(errno));
594 /* Find the records we want, and add them to the result. */
597 yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &dnssec);
598 if (yield == NO_RECOVERY) goto END_OFF;
600 packet[6] = (count >> 8) & 255;
601 packet[7] = count & 255;
603 /* There is no need to return any additional records because Exim no longer
604 (from release 4.61) makes any use of them. */
610 ((HEADER *)packet)->ad = 1;
612 /* Close the zone file, write the result, and return. */
616 (void)fwrite(packet, 1, pk - packet, stdout);
622 /* End of fakens.c */