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