Testsuite: locate fakens relative to the config_main_directory
[exim.git] / test / src / fakens.c
1 /*************************************************
2 * fakens - A Fake Nameserver Program *
3 *************************************************/
4
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 exim config_main_directory. Note that there is little checking in this program. The fake
12 zone files are assumed to be syntactically valid.
13
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".
20
21 The 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
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.
31
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:
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
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:
42
43 5 PASS_ON requests Exim to call res_search()
44
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:
47
48 PASS ON NOT FOUND
49
50 and the domain is not found. It converts the the result to PASS_ON instead of
51 HOST_NOT_FOUND.
52
53 Any DNS record line in a zone file can be prefixed with "DELAY=" and
54 a number of milliseconds (followed by whitespace).
55
56 Any DNS record line in a zone file can be prefixed with "DNSSEC" and
57 at least one space; if all the records found by a lookup are marked
58 as such then the response will have the "AD" bit set. */
59
60 #include <ctype.h>
61 #include <stdarg.h>
62 #include <stdio.h>
63 #include <stdlib.h>
64 #include <string.h>
65 #include <netdb.h>
66 #include <errno.h>
67 #include <signal.h>
68 #include <arpa/nameser.h>
69 #include <sys/types.h>
70 #include <sys/time.h>
71 #include <dirent.h>
72
73 #define FALSE 0
74 #define TRUE 1
75 #define PASS_ON 5
76
77 typedef int BOOL;
78 typedef unsigned char uschar;
79
80 #define CS (char *)
81 #define CCS (const char *)
82 #define US (unsigned char *)
83
84 #define Ustrcat(s,t) strcat(CS(s),CCS(t))
85 #define Ustrchr(s,n) US strchr(CCS(s),n)
86 #define Ustrcmp(s,t) strcmp(CCS(s),CCS(t))
87 #define Ustrcpy(s,t) strcpy(CS(s),CCS(t))
88 #define Ustrlen(s) (int)strlen(CCS(s))
89 #define Ustrncmp(s,t,n) strncmp(CCS(s),CCS(t),n)
90 #define Ustrncpy(s,t,n) strncpy(CS(s),CCS(t),n)
91
92 typedef struct zoneitem {
93 uschar *zone;
94 uschar *zonefile;
95 } zoneitem;
96
97 typedef struct tlist {
98 uschar *name;
99 int value;
100 } tlist;
101
102 /* On some (older?) operating systems, the standard ns_t_xxx definitions are
103 not available, and only the older T_xxx ones exist in nameser.h. If ns_t_a is
104 not defined, assume we are in this state. A really old system might not even
105 know about AAAA and SRV at all. */
106
107 #ifndef ns_t_a
108 # define ns_t_a T_A
109 # define ns_t_ns T_NS
110 # define ns_t_cname T_CNAME
111 # define ns_t_soa T_SOA
112 # define ns_t_ptr T_PTR
113 # define ns_t_mx T_MX
114 # define ns_t_txt T_TXT
115 # define ns_t_aaaa T_AAAA
116 # define ns_t_srv T_SRV
117 # define ns_t_tlsa T_TLSA
118 # ifndef T_AAAA
119 # define T_AAAA 28
120 # endif
121 # ifndef T_SRV
122 # define T_SRV 33
123 # endif
124 # ifndef T_TLSA
125 # define T_TLSA 52
126 # endif
127 #endif
128
129 static tlist type_list[] = {
130 { US"A", ns_t_a },
131 { US"NS", ns_t_ns },
132 { US"CNAME", ns_t_cname },
133 { US"SOA", ns_t_soa },
134 { US"PTR", ns_t_ptr },
135 { US"MX", ns_t_mx },
136 { US"TXT", ns_t_txt },
137 { US"AAAA", ns_t_aaaa },
138 { US"SRV", ns_t_srv },
139 { US"TLSA", ns_t_tlsa },
140 { NULL, 0 }
141 };
142
143
144
145 /*************************************************
146 * Get memory and sprintf into it *
147 *************************************************/
148
149 /* This is used when building a table of zones and their files.
150
151 Arguments:
152 format a format string
153 ... arguments
154
155 Returns: pointer to formatted string
156 */
157
158 static uschar *
159 fcopystring(uschar *format, ...)
160 {
161 uschar *yield;
162 char buffer[256];
163 va_list ap;
164 va_start(ap, format);
165 vsprintf(buffer, CS format, ap);
166 va_end(ap);
167 yield = (uschar *)malloc(Ustrlen(buffer) + 1);
168 Ustrcpy(yield, buffer);
169 return yield;
170 }
171
172
173 /*************************************************
174 * Pack name into memory *
175 *************************************************/
176
177 /* This function packs a domain name into memory according to DNS rules. At
178 present, it doesn't do any compression.
179
180 Arguments:
181 name the name
182 pk where to put it
183
184 Returns: the updated value of pk
185 */
186
187 static uschar *
188 packname(uschar *name, uschar *pk)
189 {
190 while (*name != 0)
191 {
192 uschar *p = name;
193 while (*p != 0 && *p != '.') p++;
194 *pk++ = (p - name);
195 memmove(pk, name, p - name);
196 pk += p - name;
197 name = (*p == 0)? p : p + 1;
198 }
199 *pk++ = 0;
200 return pk;
201 }
202
203 uschar *
204 bytefield(uschar ** pp, uschar * pk)
205 {
206 unsigned value = 0;
207 uschar * p = *pp;
208
209 while (isdigit(*p)) value = value*10 + *p++ - '0';
210 while (isspace(*p)) p++;
211 *pp = p;
212 *pk++ = value & 255;
213 return pk;
214 }
215
216 uschar *
217 shortfield(uschar ** pp, uschar * pk)
218 {
219 unsigned value = 0;
220 uschar * p = *pp;
221
222 while (isdigit(*p)) value = value*10 + *p++ - '0';
223 while (isspace(*p)) p++;
224 *pp = p;
225 *pk++ = (value >> 8) & 255;
226 *pk++ = value & 255;
227 return pk;
228 }
229
230 uschar *
231 longfield(uschar ** pp, uschar * pk)
232 {
233 unsigned long value = 0;
234 uschar * p = *pp;
235
236 while (isdigit(*p)) value = value*10 + *p++ - '0';
237 while (isspace(*p)) p++;
238 *pp = p;
239 *pk++ = (value >> 24) & 255;
240 *pk++ = (value >> 16) & 255;
241 *pk++ = (value >> 8) & 255;
242 *pk++ = value & 255;
243 return pk;
244 }
245
246
247
248 /*************************************************/
249
250 static void
251 milliwait(struct itimerval *itval)
252 {
253 sigset_t sigmask;
254 sigset_t old_sigmask;
255
256 if (itval->it_value.tv_usec < 100 && itval->it_value.tv_sec == 0)
257 return;
258 (void)sigemptyset(&sigmask); /* Empty mask */
259 (void)sigaddset(&sigmask, SIGALRM); /* Add SIGALRM */
260 (void)sigprocmask(SIG_BLOCK, &sigmask, &old_sigmask); /* Block SIGALRM */
261 (void)setitimer(ITIMER_REAL, itval, NULL); /* Start timer */
262 (void)sigfillset(&sigmask); /* All signals */
263 (void)sigdelset(&sigmask, SIGALRM); /* Remove SIGALRM */
264 (void)sigsuspend(&sigmask); /* Until SIGALRM */
265 (void)sigprocmask(SIG_SETMASK, &old_sigmask, NULL); /* Restore mask */
266 }
267
268 static void
269 millisleep(int msec)
270 {
271 struct itimerval itval;
272 itval.it_interval.tv_sec = 0;
273 itval.it_interval.tv_usec = 0;
274 itval.it_value.tv_sec = msec/1000;
275 itval.it_value.tv_usec = (msec % 1000) * 1000;
276 milliwait(&itval);
277 }
278
279
280 /*************************************************
281 * Scan file for RRs *
282 *************************************************/
283
284 /* This function scans an open "zone file" for appropriate records, and adds
285 any that are found to the output buffer.
286
287 Arguments:
288 f the input FILE
289 zone the current zone name
290 domain the domain we are looking for
291 qtype the type of RR we want
292 qtypelen the length of qtype
293 pkptr points to the output buffer pointer; this is updated
294 countptr points to the record count; this is updated
295
296 Returns: 0 on success, else HOST_NOT_FOUND or NO_DATA or NO_RECOVERY or
297 PASS_ON - the latter if a "PASS ON NOT FOUND" line is seen
298 */
299
300 static int
301 find_records(FILE *f, uschar *zone, uschar *domain, uschar *qtype,
302 int qtypelen, uschar **pkptr, int *countptr, BOOL * dnssec)
303 {
304 int yield = HOST_NOT_FOUND;
305 int domainlen = Ustrlen(domain);
306 BOOL pass_on_not_found = FALSE;
307 tlist *typeptr;
308 uschar *pk = *pkptr;
309 uschar buffer[256];
310 uschar rrdomain[256];
311 uschar RRdomain[256];
312
313 /* Decode the required type */
314
315 for (typeptr = type_list; typeptr->name != NULL; typeptr++)
316 { if (Ustrcmp(typeptr->name, qtype) == 0) break; }
317 if (typeptr->name == NULL)
318 {
319 fprintf(stderr, "fakens: unknown record type %s\n", qtype);
320 return NO_RECOVERY;
321 }
322
323 rrdomain[0] = 0; /* No previous domain */
324 (void)fseek(f, 0, SEEK_SET); /* Start again at the beginning */
325
326 *dnssec = TRUE; /* cancelled by first nonsecure rec found */
327
328 /* Scan for RRs */
329
330 while (fgets(CS buffer, sizeof(buffer), f) != NULL)
331 {
332 uschar *rdlptr;
333 uschar *p, *ep, *pp;
334 BOOL found_cname = FALSE;
335 int i, value;
336 int tvalue = typeptr->value;
337 int qtlen = qtypelen;
338 BOOL rr_sec = FALSE;
339 int delay = 0;
340
341 p = buffer;
342 while (isspace(*p)) p++;
343 if (*p == 0 || *p == ';') continue;
344
345 if (Ustrncmp(p, US"PASS ON NOT FOUND", 17) == 0)
346 {
347 pass_on_not_found = TRUE;
348 continue;
349 }
350
351 ep = buffer + Ustrlen(buffer);
352 while (isspace(ep[-1])) ep--;
353 *ep = 0;
354
355 p = buffer;
356 for (;;)
357 {
358 if (Ustrncmp(p, US"DNSSEC ", 7) == 0) /* tagged as secure */
359 {
360 rr_sec = TRUE;
361 p += 7;
362 }
363 else if (Ustrncmp(p, US"DELAY=", 6) == 0) /* delay beforee response */
364 {
365 for (p += 6; *p >= '0' && *p <= '9'; p++)
366 delay = delay*10 + *p - '0';
367 while (isspace(*p)) p++;
368 }
369 else
370 break;
371 }
372
373 if (!isspace(*p))
374 {
375 uschar *pp = rrdomain;
376 uschar *PP = RRdomain;
377 while (!isspace(*p))
378 {
379 *pp++ = tolower(*p);
380 *PP++ = *p++;
381 }
382 if (pp[-1] != '.')
383 {
384 Ustrcpy(pp, zone);
385 Ustrcpy(PP, zone);
386 }
387 else
388 {
389 pp[-1] = 0;
390 PP[-1] = 0;
391 }
392 }
393
394 /* Compare domain names; first check for a wildcard */
395
396 if (rrdomain[0] == '*')
397 {
398 int restlen = Ustrlen(rrdomain) - 1;
399 if (domainlen > restlen &&
400 Ustrcmp(domain + domainlen - restlen, rrdomain + 1) != 0) continue;
401 }
402
403 /* Not a wildcard RR */
404
405 else if (Ustrcmp(domain, rrdomain) != 0) continue;
406
407 /* The domain matches */
408
409 if (yield == HOST_NOT_FOUND) yield = NO_DATA;
410
411 /* Compare RR types; a CNAME record is always returned */
412
413 while (isspace(*p)) p++;
414
415 if (Ustrncmp(p, "CNAME", 5) == 0)
416 {
417 tvalue = ns_t_cname;
418 qtlen = 5;
419 found_cname = TRUE;
420 }
421 else if (Ustrncmp(p, qtype, qtypelen) != 0 || !isspace(p[qtypelen])) continue;
422
423 /* Found a relevant record */
424
425 if (delay)
426 millisleep(delay);
427
428 if (!rr_sec)
429 *dnssec = FALSE; /* cancel AD return */
430
431 yield = 0;
432 *countptr = *countptr + 1;
433
434 p += qtlen;
435 while (isspace(*p)) p++;
436
437 /* For a wildcard record, use the search name; otherwise use the record's
438 name in its original case because it might contain upper case letters. */
439
440 pk = packname((rrdomain[0] == '*')? domain : RRdomain, pk);
441 *pk++ = (tvalue >> 8) & 255;
442 *pk++ = (tvalue) & 255;
443 *pk++ = 0;
444 *pk++ = 1; /* class = IN */
445
446 pk += 4; /* TTL field; don't care */
447
448 rdlptr = pk; /* remember rdlength field */
449 pk += 2;
450
451 /* The rest of the data depends on the type */
452
453 switch (tvalue)
454 {
455 case ns_t_soa:
456 p = strtok(p, " ");
457 ep = p + strlen(p);
458 if (ep[-1] != '.') sprintf(CS ep, "%s.", zone);
459 pk = packname(p, pk); /* primary ns */
460 p = strtok(NULL, " ");
461 pk = packname(p , pk); /* responsible mailbox */
462 *(p += strlen(p)) = ' ';
463 while (isspace(*p)) p++;
464 pk = longfield(&p, pk); /* serial */
465 pk = longfield(&p, pk); /* refresh */
466 pk = longfield(&p, pk); /* retry */
467 pk = longfield(&p, pk); /* expire */
468 pk = longfield(&p, pk); /* minimum */
469 break;
470
471 case ns_t_a:
472 for (i = 0; i < 4; i++)
473 {
474 value = 0;
475 while (isdigit(*p)) value = value*10 + *p++ - '0';
476 *pk++ = value;
477 p++;
478 }
479 break;
480
481 /* The only occurrence of a double colon is for ::1 */
482 case ns_t_aaaa:
483 if (Ustrcmp(p, "::1") == 0)
484 {
485 memset(pk, 0, 15);
486 pk += 15;
487 *pk++ = 1;
488 }
489 else for (i = 0; i < 8; i++)
490 {
491 value = 0;
492 while (isxdigit(*p))
493 {
494 value = value * 16 + toupper(*p) - (isdigit(*p)? '0' : '7');
495 p++;
496 }
497 *pk++ = (value >> 8) & 255;
498 *pk++ = value & 255;
499 p++;
500 }
501 break;
502
503 case ns_t_mx:
504 pk = shortfield(&p, pk);
505 if (ep[-1] != '.') sprintf(CS ep, "%s.", zone);
506 pk = packname(p, pk);
507 break;
508
509 case ns_t_txt:
510 pp = pk++;
511 if (*p == '"') p++; /* Should always be the case */
512 while (*p != 0 && *p != '"') *pk++ = *p++;
513 *pp = pk - pp - 1;
514 break;
515
516 case ns_t_tlsa:
517 pk = bytefield(&p, pk); /* usage */
518 pk = bytefield(&p, pk); /* selector */
519 pk = bytefield(&p, pk); /* match type */
520 while (isxdigit(*p))
521 {
522 value = toupper(*p) - (isdigit(*p) ? '0' : '7') << 4;
523 if (isxdigit(*++p))
524 {
525 value |= toupper(*p) - (isdigit(*p) ? '0' : '7');
526 p++;
527 }
528 *pk++ = value & 255;
529 }
530
531 break;
532
533 case ns_t_srv:
534 for (i = 0; i < 3; i++)
535 {
536 value = 0;
537 while (isdigit(*p)) value = value*10 + *p++ - '0';
538 while (isspace(*p)) p++;
539 *pk++ = (value >> 8) & 255;
540 *pk++ = value & 255;
541 }
542
543 /* Fall through */
544
545 case ns_t_cname:
546 case ns_t_ns:
547 case ns_t_ptr:
548 if (ep[-1] != '.') sprintf(CS ep, "%s.", zone);
549 pk = packname(p, pk);
550 break;
551 }
552
553 /* Fill in the length, and we are done with this RR */
554
555 rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255;
556 rdlptr[1] = (pk -rdlptr - 2) & 255;
557 }
558
559 *pkptr = pk;
560 return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield;
561 }
562
563
564 static void
565 alarmfn(int sig)
566 {
567 }
568
569 /*************************************************
570 * Entry point and main program *
571 *************************************************/
572
573 int
574 main(int argc, char **argv)
575 {
576 FILE *f;
577 DIR *d;
578 int domlen, qtypelen;
579 int yield, count;
580 int i;
581 int zonecount = 0;
582 struct dirent *de;
583 zoneitem zones[32];
584 uschar *qualify = NULL;
585 uschar *p, *zone;
586 uschar *zonefile = NULL;
587 uschar domain[256];
588 uschar buffer[256];
589 uschar qtype[12];
590 uschar packet[512];
591 uschar *pk = packet;
592 BOOL dnssec;
593
594 signal(SIGALRM, alarmfn);
595
596 if (argc != 4)
597 {
598 fprintf(stderr, "fakens: expected 3 arguments, received %d\n", argc-1);
599 return NO_RECOVERY;
600 }
601
602 /* Find the zones */
603
604 (void)sprintf(CS buffer, "%s/dnszones", argv[1]);
605
606 d = opendir(CCS buffer);
607 if (d == NULL)
608 {
609 fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer,
610 strerror(errno));
611 return NO_RECOVERY;
612 }
613
614 while ((de = readdir(d)) != NULL)
615 {
616 uschar *name = US de->d_name;
617 if (Ustrncmp(name, "qualify.", 8) == 0)
618 {
619 qualify = fcopystring(US "%s", name + 7);
620 continue;
621 }
622 if (Ustrncmp(name, "db.", 3) != 0) continue;
623 if (Ustrncmp(name + 3, "ip4.", 4) == 0)
624 zones[zonecount].zone = fcopystring(US "%s.in-addr.arpa", name + 6);
625 else if (Ustrncmp(name + 3, "ip6.", 4) == 0)
626 zones[zonecount].zone = fcopystring(US "%s.ip6.arpa", name + 6);
627 else
628 zones[zonecount].zone = fcopystring(US "%s", name + 2);
629 zones[zonecount++].zonefile = fcopystring(US "%s", name);
630 }
631 (void)closedir(d);
632
633 /* Get the RR type and upper case it, and check that we recognize it. */
634
635 Ustrncpy(qtype, argv[3], sizeof(qtype));
636 qtypelen = Ustrlen(qtype);
637 for (p = qtype; *p != 0; p++) *p = toupper(*p);
638
639 /* Find the domain, lower case it, check that it is in a zone that we handle,
640 and set up the zone file name. The zone names in the table all start with a
641 dot. */
642
643 domlen = Ustrlen(argv[2]);
644 if (argv[2][domlen-1] == '.') domlen--;
645 Ustrncpy(domain, argv[2], domlen);
646 domain[domlen] = 0;
647 for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]);
648
649 if (Ustrchr(domain, '.') == NULL && qualify != NULL &&
650 Ustrcmp(domain, "dontqualify") != 0)
651 {
652 Ustrcat(domain, qualify);
653 domlen += Ustrlen(qualify);
654 }
655
656 for (i = 0; i < zonecount; i++)
657 {
658 int zlen;
659 zone = zones[i].zone;
660 zlen = Ustrlen(zone);
661 if (Ustrcmp(domain, zone+1) == 0 || (domlen >= zlen &&
662 Ustrcmp(domain + domlen - zlen, zone) == 0))
663 {
664 zonefile = zones[i].zonefile;
665 break;
666 }
667 }
668
669 if (zonefile == NULL)
670 {
671 fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain);
672 return PASS_ON;
673 }
674
675 (void)sprintf(CS buffer, "%s/dnszones/%s", argv[1], zonefile);
676
677 /* Initialize the start of the response packet. We don't have to fake up
678 everything, because we know that Exim will look only at the answer and
679 additional section parts. */
680
681 memset(packet, 0, 12);
682 pk += 12;
683
684 /* Open the zone file. */
685
686 f = fopen(CS buffer, "r");
687 if (f == NULL)
688 {
689 fprintf(stderr, "fakens: failed to open %s: %s\n", buffer, strerror(errno));
690 return NO_RECOVERY;
691 }
692
693 /* Find the records we want, and add them to the result. */
694
695 count = 0;
696 yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &dnssec);
697 if (yield == NO_RECOVERY) goto END_OFF;
698
699 packet[6] = (count >> 8) & 255;
700 packet[7] = count & 255;
701
702 /* There is no need to return any additional records because Exim no longer
703 (from release 4.61) makes any use of them. */
704
705 packet[10] = 0;
706 packet[11] = 0;
707
708 if (dnssec)
709 ((HEADER *)packet)->ad = 1;
710
711 /* Close the zone file, write the result, and return. */
712
713 END_OFF:
714 (void)fclose(f);
715 (void)fwrite(packet, 1, pk - packet, stdout);
716 return yield;
717 }
718
719 /* vi: aw ai sw=2
720 */
721 /* End of fakens.c */