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