Testsuite: tidying
[exim.git] / test / src / fakens.c
CommitLineData
c55a77db
PH
1/*************************************************
2* fakens - A Fake Nameserver Program *
3*************************************************/
4
5/* This program exists to support the testing of DNS handling code in Exim. It
6avoids the need to install special zones in a real nameserver. When Exim is
7running in its (new) test harness, DNS lookups are first passed to this program
8instead of to the real resolver. (With a few exceptions - see the discussion in
9the test suite's README file.) The program is also passed the name of the Exim
10spool directory; it expects to find its "zone files" in ../dnszones relative to
11that directory. Note that there is little checking in this program. The fake
12zone files are assumed to be syntactically valid.
13
14The zones that are handled are found by scanning the dnszones directory. A file
15whose name is of the form db.ip4.x is a zone file for .x.in-addr.arpa; a file
16whose name is of the form db.ip6.x is a zone file for .x.ip6.arpa; a file of
17the form db.anything.else is a zone file for .anything.else. A file of the form
18qualify.x.y specifies the domain that is used to qualify single-component
19names, except for the name "dontqualify".
20
21The arguments to the program are:
22
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
26
27The output from the program is written to stdout. It is supposed to be in
28exactly the same format as a traditional namserver response (see RFC 1035) so
29that Exim can process it as normal. At present, no compression is used.
30Error messages are written to stderr.
31
32The return codes from the program are zero for success, and otherwise the
33values that are set in h_errno after a failing call to the normal resolver:
34
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
39
40In a real nameserver, TRY_AGAIN is also used for a non-authoritative not found,
41but it is not used for that here. There is also one extra return code:
42
43 5 PASS_ON requests Exim to call res_search()
44
45This is used for zones that fakens does not recognize. It is also used if a
46line in the zone file contains exactly this:
47
48 PASS ON NOT FOUND
49
50and the domain is not found. It converts the the result to PASS_ON instead of
4d4c2a9b
JH
51HOST_NOT_FOUND.
52
53Any DNS record line in a zone file can be prefixed with "DNSSEC" and
54at least one space; if all the records found by a lookup are marked
55as such then the response will have the "AD" bit set. */
c55a77db
PH
56
57#include <ctype.h>
58#include <stdarg.h>
59#include <stdio.h>
60#include <string.h>
61#include <netdb.h>
62#include <errno.h>
63#include <arpa/nameser.h>
64#include <sys/types.h>
65#include <dirent.h>
66
67#define FALSE 0
68#define TRUE 1
69#define PASS_ON 5
70
71typedef int BOOL;
72typedef unsigned char uschar;
73
74#define CS (char *)
75#define CCS (const char *)
76#define US (unsigned char *)
77
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)
85
c55a77db
PH
86typedef struct zoneitem {
87 uschar *zone;
88 uschar *zonefile;
89} zoneitem;
90
91typedef struct tlist {
92 uschar *name;
93 int value;
94} tlist;
95
96/* On some (older?) operating systems, the standard ns_t_xxx definitions are
97not available, and only the older T_xxx ones exist in nameser.h. If ns_t_a is
98not defined, assume we are in this state. A really old system might not even
99know about AAAA and SRV at all. */
100
101#ifndef ns_t_a
b4161d10
JH
102# define ns_t_a T_A
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
112# ifndef T_AAAA
113# define T_AAAA 28
114# endif
115# ifndef T_SRV
116# define T_SRV 33
117# endif
118# ifndef T_TLSA
119# define T_TLSA 52
120# endif
c55a77db
PH
121#endif
122
123static tlist type_list[] = {
124 { US"A", ns_t_a },
125 { US"NS", ns_t_ns },
126 { US"CNAME", ns_t_cname },
127/* { US"SOA", ns_t_soa }, Not currently in use */
128 { US"PTR", ns_t_ptr },
129 { US"MX", ns_t_mx },
130 { US"TXT", ns_t_txt },
131 { US"AAAA", ns_t_aaaa },
132 { US"SRV", ns_t_srv },
b4161d10 133 { US"TLSA", ns_t_tlsa },
c55a77db
PH
134 { NULL, 0 }
135};
136
137
138
139/*************************************************
140* Get memory and sprintf into it *
141*************************************************/
142
143/* This is used when building a table of zones and their files.
144
145Arguments:
146 format a format string
147 ... arguments
148
149Returns: pointer to formatted string
150*/
151
152static uschar *
153fcopystring(uschar *format, ...)
154{
155uschar *yield;
156char buffer[256];
157va_list ap;
158va_start(ap, format);
159vsprintf(buffer, format, ap);
160va_end(ap);
161yield = (uschar *)malloc(Ustrlen(buffer) + 1);
162Ustrcpy(yield, buffer);
163return yield;
164}
165
166
167/*************************************************
168* Pack name into memory *
169*************************************************/
170
171/* This function packs a domain name into memory according to DNS rules. At
172present, it doesn't do any compression.
173
174Arguments:
175 name the name
176 pk where to put it
177
178Returns: the updated value of pk
179*/
180
181static uschar *
182packname(uschar *name, uschar *pk)
183{
184while (*name != 0)
185 {
186 uschar *p = name;
187 while (*p != 0 && *p != '.') p++;
188 *pk++ = (p - name);
189 memmove(pk, name, p - name);
190 pk += p - name;
191 name = (*p == 0)? p : p + 1;
192 }
193*pk++ = 0;
194return pk;
195}
196
b4161d10 197uschar *
36b894a6
JH
198bytefield(uschar ** pp, uschar * pk)
199{
200unsigned value = 0;
201uschar * p = *pp;
202
203while (isdigit(*p)) value = value*10 + *p++ - '0';
204while (isspace(*p)) p++;
205*pp = p;
206*pk++ = value & 255;
207return pk;
208}
209
210uschar *
b4161d10
JH
211shortfield(uschar ** pp, uschar * pk)
212{
213unsigned value = 0;
214uschar * p = *pp;
215
216while (isdigit(*p)) value = value*10 + *p++ - '0';
217while (isspace(*p)) p++;
218*pp = p;
219*pk++ = (value >> 8) & 255;
220*pk++ = value & 255;
221return pk;
222}
223
c55a77db
PH
224
225
226/*************************************************
227* Scan file for RRs *
228*************************************************/
229
230/* This function scans an open "zone file" for appropriate records, and adds
231any that are found to the output buffer.
232
233Arguments:
234 f the input FILE
235 zone the current zone name
236 domain the domain we are looking for
237 qtype the type of RR we want
238 qtypelen the length of qtype
239 pkptr points to the output buffer pointer; this is updated
240 countptr points to the record count; this is updated
c55a77db
PH
241
242Returns: 0 on success, else HOST_NOT_FOUND or NO_DATA or NO_RECOVERY or
243 PASS_ON - the latter if a "PASS ON NOT FOUND" line is seen
244*/
245
246static int
247find_records(FILE *f, uschar *zone, uschar *domain, uschar *qtype,
4d4c2a9b 248 int qtypelen, uschar **pkptr, int *countptr, BOOL * dnssec)
c55a77db
PH
249{
250int yield = HOST_NOT_FOUND;
c55a77db
PH
251int domainlen = Ustrlen(domain);
252BOOL pass_on_not_found = FALSE;
253tlist *typeptr;
254uschar *pk = *pkptr;
255uschar buffer[256];
256uschar rrdomain[256];
75e0e026 257uschar RRdomain[256];
c55a77db
PH
258
259/* Decode the required type */
260
261for (typeptr = type_list; typeptr->name != NULL; typeptr++)
262 { if (Ustrcmp(typeptr->name, qtype) == 0) break; }
263if (typeptr->name == NULL)
264 {
265 fprintf(stderr, "fakens: unknown record type %s\n", qtype);
266 return NO_RECOVERY;
267 }
268
269rrdomain[0] = 0; /* No previous domain */
270(void)fseek(f, 0, SEEK_SET); /* Start again at the beginning */
271
b4161d10 272*dnssec = TRUE; /* cancelled by first nonsecure rec found */
4d4c2a9b 273
c55a77db
PH
274/* Scan for RRs */
275
276while (fgets(CS buffer, sizeof(buffer), f) != NULL)
277 {
278 uschar *rdlptr;
279 uschar *p, *ep, *pp;
280 BOOL found_cname = FALSE;
281 int i, plen, value;
282 int tvalue = typeptr->value;
283 int qtlen = qtypelen;
4d4c2a9b 284 BOOL rr_sec = FALSE;
c55a77db
PH
285
286 p = buffer;
287 while (isspace(*p)) p++;
288 if (*p == 0 || *p == ';') continue;
289
4d4c2a9b 290 if (Ustrncmp(p, US"PASS ON NOT FOUND", 17) == 0)
c55a77db
PH
291 {
292 pass_on_not_found = TRUE;
293 continue;
294 }
295
296 ep = buffer + Ustrlen(buffer);
297 while (isspace(ep[-1])) ep--;
298 *ep = 0;
299
300 p = buffer;
4d4c2a9b
JH
301 if (Ustrncmp(p, US"DNSSEC ", 7) == 0) /* tagged as secure */
302 {
303 rr_sec = TRUE;
304 p += 7;
305 }
306
c55a77db
PH
307 if (!isspace(*p))
308 {
309 uschar *pp = rrdomain;
75e0e026
PH
310 uschar *PP = RRdomain;
311 while (!isspace(*p))
312 {
313 *pp++ = tolower(*p);
314 *PP++ = *p++;
315 }
316 if (pp[-1] != '.')
317 {
318 Ustrcpy(pp, zone);
319 Ustrcpy(PP, zone);
320 }
321 else
322 {
323 pp[-1] = 0;
324 PP[-1] = 0;
325 }
c55a77db
PH
326 }
327
328 /* Compare domain names; first check for a wildcard */
329
330 if (rrdomain[0] == '*')
331 {
332 int restlen = Ustrlen(rrdomain) - 1;
333 if (domainlen > restlen &&
334 Ustrcmp(domain + domainlen - restlen, rrdomain + 1) != 0) continue;
335 }
336
337 /* Not a wildcard RR */
338
339 else if (Ustrcmp(domain, rrdomain) != 0) continue;
340
341 /* The domain matches */
342
343 if (yield == HOST_NOT_FOUND) yield = NO_DATA;
344
345 /* Compare RR types; a CNAME record is always returned */
346
347 while (isspace(*p)) p++;
348
349 if (Ustrncmp(p, "CNAME", 5) == 0)
350 {
351 tvalue = ns_t_cname;
352 qtlen = 5;
353 found_cname = TRUE;
354 }
355 else if (Ustrncmp(p, qtype, qtypelen) != 0 || !isspace(p[qtypelen])) continue;
356
357 /* Found a relevant record */
358
4d4c2a9b
JH
359 if (!rr_sec)
360 *dnssec = FALSE; /* cancel AD return */
361
c55a77db
PH
362 yield = 0;
363 *countptr = *countptr + 1;
364
365 p += qtlen;
366 while (isspace(*p)) p++;
367
75e0e026
PH
368 /* For a wildcard record, use the search name; otherwise use the record's
369 name in its original case because it might contain upper case letters. */
370
371 pk = packname((rrdomain[0] == '*')? domain : RRdomain, pk);
c55a77db
PH
372 *pk++ = (tvalue >> 8) & 255;
373 *pk++ = (tvalue) & 255;
374 *pk++ = 0;
375 *pk++ = 1; /* class = IN */
376
377 pk += 4; /* TTL field; don't care */
378
379 rdlptr = pk; /* remember rdlength field */
380 pk += 2;
381
382 /* The rest of the data depends on the type */
383
384 switch (tvalue)
385 {
386 case ns_t_soa: /* Not currently used */
387 break;
388
389 case ns_t_a:
390 for (i = 0; i < 4; i++)
391 {
392 value = 0;
393 while (isdigit(*p)) value = value*10 + *p++ - '0';
394 *pk++ = value;
395 p++;
396 }
397 break;
398
399 /* The only occurrence of a double colon is for ::1 */
400 case ns_t_aaaa:
401 if (Ustrcmp(p, "::1") == 0)
402 {
403 memset(pk, 0, 15);
404 pk += 15;
405 *pk++ = 1;
406 }
407 else for (i = 0; i < 8; i++)
408 {
409 value = 0;
410 while (isxdigit(*p))
411 {
412 value = value * 16 + toupper(*p) - (isdigit(*p)? '0' : '7');
413 p++;
414 }
415 *pk++ = (value >> 8) & 255;
416 *pk++ = value & 255;
417 p++;
418 }
419 break;
420
421 case ns_t_mx:
b4161d10 422 pk = shortfield(&p, pk);
75e0e026
PH
423 if (ep[-1] != '.') sprintf(ep, "%s.", zone);
424 pk = packname(p, pk);
425 plen = Ustrlen(p);
426 break;
c55a77db
PH
427
428 case ns_t_txt:
429 pp = pk++;
430 if (*p == '"') p++; /* Should always be the case */
431 while (*p != 0 && *p != '"') *pk++ = *p++;
432 *pp = pk - pp - 1;
433 break;
434
b4161d10 435 case ns_t_tlsa:
36b894a6
JH
436 pk = bytefield(&p, pk); /* usage */
437 pk = bytefield(&p, pk); /* selector */
438 pk = bytefield(&p, pk); /* match type */
b4161d10
JH
439 while (isxdigit(*p))
440 {
441 value = toupper(*p) - (isdigit(*p) ? '0' : '7') << 4;
442 if (isxdigit(*++p))
443 {
444 value |= toupper(*p) - (isdigit(*p) ? '0' : '7');
445 p++;
446 }
447 *pk++ = value & 255;
448 }
449
450 break;
451
c55a77db
PH
452 case ns_t_srv:
453 for (i = 0; i < 3; i++)
454 {
455 value = 0;
456 while (isdigit(*p)) value = value*10 + *p++ - '0';
457 while (isspace(*p)) p++;
458 *pk++ = (value >> 8) & 255;
459 *pk++ = value & 255;
460 }
461
462 /* Fall through */
463
464 case ns_t_cname:
465 case ns_t_ns:
466 case ns_t_ptr:
c55a77db
PH
467 if (ep[-1] != '.') sprintf(ep, "%s.", zone);
468 pk = packname(p, pk);
469 plen = Ustrlen(p);
c55a77db
PH
470 break;
471 }
472
473 /* Fill in the length, and we are done with this RR */
474
475 rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255;
476 rdlptr[1] = (pk -rdlptr - 2) & 255;
c55a77db
PH
477 }
478
479*pkptr = pk;
480return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield;
481}
482
483
484
485/*************************************************
486* Entry point and main program *
487*************************************************/
488
489int
490main(int argc, char **argv)
491{
492FILE *f;
493DIR *d;
75e0e026 494int domlen, qtypelen;
c55a77db
PH
495int yield, count;
496int i;
497int zonecount = 0;
c55a77db 498struct dirent *de;
c55a77db
PH
499zoneitem zones[32];
500uschar *qualify = NULL;
501uschar *p, *zone;
502uschar *zonefile = NULL;
503uschar domain[256];
504uschar buffer[256];
505uschar qtype[12];
506uschar packet[512];
507uschar *pk = packet;
4d4c2a9b 508BOOL dnssec;
c55a77db
PH
509
510if (argc != 4)
511 {
512 fprintf(stderr, "fakens: expected 3 arguments, received %d\n", argc-1);
513 return NO_RECOVERY;
514 }
515
516/* Find the zones */
517
518(void)sprintf(buffer, "%s/../dnszones", argv[1]);
519
520d = opendir(CCS buffer);
521if (d == NULL)
522 {
523 fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer,
524 strerror(errno));
525 return NO_RECOVERY;
526 }
527
528while ((de = readdir(d)) != NULL)
529 {
530 uschar *name = de->d_name;
531 if (Ustrncmp(name, "qualify.", 8) == 0)
532 {
533 qualify = fcopystring("%s", name + 7);
534 continue;
535 }
536 if (Ustrncmp(name, "db.", 3) != 0) continue;
537 if (Ustrncmp(name + 3, "ip4.", 4) == 0)
538 zones[zonecount].zone = fcopystring("%s.in-addr.arpa", name + 6);
539 else if (Ustrncmp(name + 3, "ip6.", 4) == 0)
540 zones[zonecount].zone = fcopystring("%s.ip6.arpa", name + 6);
541 else
542 zones[zonecount].zone = fcopystring("%s", name + 2);
543 zones[zonecount++].zonefile = fcopystring("%s", name);
544 }
545(void)closedir(d);
546
547/* Get the RR type and upper case it, and check that we recognize it. */
548
549Ustrncpy(qtype, argv[3], sizeof(qtype));
550qtypelen = Ustrlen(qtype);
551for (p = qtype; *p != 0; p++) *p = toupper(*p);
552
553/* Find the domain, lower case it, check that it is in a zone that we handle,
554and set up the zone file name. The zone names in the table all start with a
555dot. */
556
557domlen = Ustrlen(argv[2]);
558if (argv[2][domlen-1] == '.') domlen--;
559Ustrncpy(domain, argv[2], domlen);
560domain[domlen] = 0;
561for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]);
562
563if (Ustrchr(domain, '.') == NULL && qualify != NULL &&
564 Ustrcmp(domain, "dontqualify") != 0)
565 {
566 Ustrcat(domain, qualify);
567 domlen += Ustrlen(qualify);
568 }
569
570for (i = 0; i < zonecount; i++)
571 {
572 int zlen;
573 zone = zones[i].zone;
574 zlen = Ustrlen(zone);
575 if (Ustrcmp(domain, zone+1) == 0 || (domlen >= zlen &&
576 Ustrcmp(domain + domlen - zlen, zone) == 0))
577 {
578 zonefile = zones[i].zonefile;
579 break;
580 }
581 }
582
583if (zonefile == NULL)
584 {
585 fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain);
586 return PASS_ON;
587 }
588
589(void)sprintf(buffer, "%s/../dnszones/%s", argv[1], zonefile);
590
591/* Initialize the start of the response packet. We don't have to fake up
592everything, because we know that Exim will look only at the answer and
593additional section parts. */
594
595memset(packet, 0, 12);
596pk += 12;
597
598/* Open the zone file. */
599
600f = fopen(buffer, "r");
601if (f == NULL)
602 {
603 fprintf(stderr, "fakens: failed to open %s: %s\n", buffer, strerror(errno));
604 return NO_RECOVERY;
605 }
606
607/* Find the records we want, and add them to the result. */
608
609count = 0;
4d4c2a9b 610yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &dnssec);
c55a77db
PH
611if (yield == NO_RECOVERY) goto END_OFF;
612
613packet[6] = (count >> 8) & 255;
614packet[7] = count & 255;
615
75e0e026
PH
616/* There is no need to return any additional records because Exim no longer
617(from release 4.61) makes any use of them. */
c55a77db 618
75e0e026
PH
619packet[10] = 0;
620packet[11] = 0;
c55a77db 621
4d4c2a9b
JH
622if (dnssec)
623 ((HEADER *)packet)->ad = 1;
624
c55a77db
PH
625/* Close the zone file, write the result, and return. */
626
627END_OFF:
628(void)fclose(f);
629(void)fwrite(packet, 1, pk - packet, stdout);
630return yield;
631}
632
4d4c2a9b
JH
633/* vi: aw ai sw=2
634*/
c55a77db 635/* End of fakens.c */