Testsuite: fakens/inet_pton on solaris again
[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
5f3d0983
HSHR
10spool directory; it expects to find its "zone files" in dnszones relative to
11exim config_main_directory. Note that there is little checking in this program. The fake
c55a77db
PH
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
846430d9 53Any DNS record line in a zone file can be prefixed with "DELAY=" and
6aa849d3 54a number of milliseconds (followed by one space).
846430d9 55
6aa849d3
JH
56Any DNS record line in a zone file can be prefixed with "DNSSEC ";
57if all the records found by a lookup are marked
f6584c83 58as such then the response will have the "AD" bit set.
589b3179 59
6aa849d3
JH
60Any DNS record line in a zone file can be prefixed with "AA "
61if all the records found by a lookup are marked
589b3179
HSHR
62as such then the response will have the "AA" bit set.
63
14b3c5bc
JH
64Any DNS record line in a zone file can be prefixed with "TTL=" and
65a number of seconds (followed by one space).
66
589b3179 67*/
c55a77db
PH
68
69#include <ctype.h>
70#include <stdarg.h>
71#include <stdio.h>
e265af1f 72#include <stdlib.h>
c55a77db
PH
73#include <string.h>
74#include <netdb.h>
75#include <errno.h>
9d787f10 76#include <signal.h>
c55a77db 77#include <arpa/nameser.h>
fd8184e3 78#include <arpa/inet.h>
c55a77db 79#include <sys/types.h>
846430d9 80#include <sys/time.h>
c55a77db 81#include <dirent.h>
2c98a555 82#include <unistd.h>
c55a77db
PH
83
84#define FALSE 0
85#define TRUE 1
86#define PASS_ON 5
87
88typedef int BOOL;
89typedef 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)
cf89e968 102#define Ustrtok(s,t) (uschar*)strtok(CS(s),CCS(t))
c55a77db 103
c55a77db
PH
104typedef struct zoneitem {
105 uschar *zone;
106 uschar *zonefile;
107} zoneitem;
108
109typedef struct tlist {
110 uschar *name;
111 int value;
112} tlist;
113
14b3c5bc
JH
114#define DEFAULT_TTL 3600U
115
c55a77db
PH
116/* On some (older?) operating systems, the standard ns_t_xxx definitions are
117not available, and only the older T_xxx ones exist in nameser.h. If ns_t_a is
118not defined, assume we are in this state. A really old system might not even
119know about AAAA and SRV at all. */
120
121#ifndef ns_t_a
b4161d10
JH
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
c55a77db
PH
141#endif
142
143static tlist type_list[] = {
144 { US"A", ns_t_a },
145 { US"NS", ns_t_ns },
146 { US"CNAME", ns_t_cname },
d2a2c69b 147 { US"SOA", ns_t_soa },
c55a77db
PH
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 },
b4161d10 153 { US"TLSA", ns_t_tlsa },
c55a77db
PH
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
165Arguments:
166 format a format string
167 ... arguments
168
169Returns: pointer to formatted string
170*/
171
172static uschar *
173fcopystring(uschar *format, ...)
174{
175uschar *yield;
176char buffer[256];
177va_list ap;
178va_start(ap, format);
e265af1f 179vsprintf(buffer, CS format, ap);
c55a77db
PH
180va_end(ap);
181yield = (uschar *)malloc(Ustrlen(buffer) + 1);
182Ustrcpy(yield, buffer);
183return 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
192present, it doesn't do any compression.
193
194Arguments:
195 name the name
196 pk where to put it
197
198Returns: the updated value of pk
199*/
200
201static uschar *
202packname(uschar *name, uschar *pk)
203{
204while (*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;
214return pk;
215}
216
b4161d10 217uschar *
36b894a6
JH
218bytefield(uschar ** pp, uschar * pk)
219{
220unsigned value = 0;
221uschar * p = *pp;
222
223while (isdigit(*p)) value = value*10 + *p++ - '0';
224while (isspace(*p)) p++;
225*pp = p;
226*pk++ = value & 255;
227return pk;
228}
229
230uschar *
b4161d10
JH
231shortfield(uschar ** pp, uschar * pk)
232{
233unsigned value = 0;
234uschar * p = *pp;
235
236while (isdigit(*p)) value = value*10 + *p++ - '0';
237while (isspace(*p)) p++;
238*pp = p;
239*pk++ = (value >> 8) & 255;
240*pk++ = value & 255;
241return pk;
242}
243
d2a2c69b
JH
244uschar *
245longfield(uschar ** pp, uschar * pk)
246{
247unsigned long value = 0;
248uschar * p = *pp;
249
250while (isdigit(*p)) value = value*10 + *p++ - '0';
251while (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;
257return pk;
258}
259
c55a77db
PH
260
261
846430d9
JH
262/*************************************************/
263
264static void
265milliwait(struct itimerval *itval)
266{
267sigset_t sigmask;
268sigset_t old_sigmask;
269
270if (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
282static void
283millisleep(int msec)
284{
285struct itimerval itval;
286itval.it_interval.tv_sec = 0;
287itval.it_interval.tv_usec = 0;
288itval.it_value.tv_sec = msec/1000;
289itval.it_value.tv_usec = (msec % 1000) * 1000;
290milliwait(&itval);
291}
292
293
c55a77db
PH
294/*************************************************
295* Scan file for RRs *
296*************************************************/
297
298/* This function scans an open "zone file" for appropriate records, and adds
299any that are found to the output buffer.
300
301Arguments:
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
f6584c83
HSHR
309 dnssec points to the AD flag indicator; this is updated
310 aa points to the AA flag indicator; this is updated
c55a77db
PH
311
312Returns: 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
316static int
317find_records(FILE *f, uschar *zone, uschar *domain, uschar *qtype,
589b3179 318 int qtypelen, uschar **pkptr, int *countptr, BOOL * dnssec, BOOL * aa)
c55a77db
PH
319{
320int yield = HOST_NOT_FOUND;
c55a77db
PH
321int domainlen = Ustrlen(domain);
322BOOL pass_on_not_found = FALSE;
323tlist *typeptr;
324uschar *pk = *pkptr;
325uschar buffer[256];
326uschar rrdomain[256];
75e0e026 327uschar RRdomain[256];
c55a77db 328
c55a77db 329
f6584c83 330/* Decode the required type */
c55a77db
PH
331for (typeptr = type_list; typeptr->name != NULL; typeptr++)
332 { if (Ustrcmp(typeptr->name, qtype) == 0) break; }
333if (typeptr->name == NULL)
334 {
335 fprintf(stderr, "fakens: unknown record type %s\n", qtype);
336 return NO_RECOVERY;
337 }
338
339rrdomain[0] = 0; /* No previous domain */
340(void)fseek(f, 0, SEEK_SET); /* Start again at the beginning */
341
f6584c83
HSHR
342if (dnssec) *dnssec = TRUE; /* cancelled by first nonsecure rec found */
343if (aa) *aa = TRUE; /* cancelled by first non-aa rec found */
4d4c2a9b 344
c55a77db
PH
345/* Scan for RRs */
346
347while (fgets(CS buffer, sizeof(buffer), f) != NULL)
348 {
349 uschar *rdlptr;
350 uschar *p, *ep, *pp;
351 BOOL found_cname = FALSE;
d2a2c69b 352 int i, value;
c55a77db
PH
353 int tvalue = typeptr->value;
354 int qtlen = qtypelen;
4d4c2a9b 355 BOOL rr_sec = FALSE;
589b3179 356 BOOL rr_aa = FALSE;
846430d9 357 int delay = 0;
14b3c5bc 358 uint ttl = DEFAULT_TTL;
c55a77db
PH
359
360 p = buffer;
361 while (isspace(*p)) p++;
362 if (*p == 0 || *p == ';') continue;
363
4d4c2a9b 364 if (Ustrncmp(p, US"PASS ON NOT FOUND", 17) == 0)
c55a77db
PH
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;
846430d9 375 for (;;)
1fb7660f 376 {
f6584c83 377 if (Ustrncmp(p, US"DNSSEC ", 7) == 0) /* tagged as secure */
1fb7660f
JH
378 {
379 rr_sec = TRUE;
380 p += 7;
381 }
f6584c83 382 else if (Ustrncmp(p, US"AA ", 3) == 0) /* tagged as authoritive */
589b3179
HSHR
383 {
384 rr_aa = TRUE;
385 p += 3;
386 }
f6584c83 387 else if (Ustrncmp(p, US"DELAY=", 6) == 0) /* delay before response */
1fb7660f
JH
388 {
389 for (p += 6; *p >= '0' && *p <= '9'; p++) delay = delay*10 + *p - '0';
6aa849d3 390 if (isspace(*p)) p++;
1fb7660f 391 }
14b3c5bc
JH
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 }
1fb7660f
JH
398 else
399 break;
400 }
4d4c2a9b 401
6aa849d3 402 if (!isspace(*p)) /* new domain name */
c55a77db
PH
403 {
404 uschar *pp = rrdomain;
75e0e026
PH
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 }
6aa849d3 421 } /* else use previous line's domain name */
c55a77db
PH
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 */
846430d9
JH
453 if (delay)
454 millisleep(delay);
455
f6584c83
HSHR
456 if (dnssec && !rr_sec)
457 *dnssec = FALSE; /* cancel AD return */
4d4c2a9b 458
f6584c83
HSHR
459 if (aa && !rr_aa)
460 *aa = FALSE; /* cancel AA return */
589b3179 461
c55a77db
PH
462 yield = 0;
463 *countptr = *countptr + 1;
464
465 p += qtlen;
466 while (isspace(*p)) p++;
467
75e0e026
PH
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);
c55a77db
PH
472 *pk++ = (tvalue >> 8) & 255;
473 *pk++ = (tvalue) & 255;
474 *pk++ = 0;
475 *pk++ = 1; /* class = IN */
476
14b3c5bc
JH
477 *pk++ = (ttl >>24) & 255;
478 *pk++ = (ttl >>16) & 255;
479 *pk++ = (ttl >> 8) & 255;
480 *pk++ = ttl & 255;
c55a77db
PH
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 {
d2a2c69b 489 case ns_t_soa:
d753e599 490 p = Ustrtok(p, " ");
cf89e968 491 ep = p + Ustrlen(p);
d2a2c69b 492 if (ep[-1] != '.') sprintf(CS ep, "%s.", zone);
f6584c83 493 pk = packname(p, pk); /* primary ns */
d753e599 494 p = Ustrtok(NULL, " ");
f6584c83 495 pk = packname(p , pk); /* responsible mailbox */
cf89e968 496 *(p += Ustrlen(p)) = ' ';
d2a2c69b 497 while (isspace(*p)) p++;
f6584c83
HSHR
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 */
d2a2c69b 503 break;
c55a77db
PH
504
505 case ns_t_a:
cf89e968 506 inet_pton(AF_INET, CCS p, pk); /* FIXME: error checking */
fd8184e3 507 pk += 4;
d2a2c69b 508 break;
c55a77db 509
c55a77db 510 case ns_t_aaaa:
cf89e968 511 inet_pton(AF_INET6, CCS p, pk); /* FIXME: error checking */
fd8184e3 512 pk += 16;
d2a2c69b 513 break;
c55a77db
PH
514
515 case ns_t_mx:
d2a2c69b
JH
516 pk = shortfield(&p, pk);
517 if (ep[-1] != '.') sprintf(CS ep, "%s.", zone);
518 pk = packname(p, pk);
519 break;
c55a77db
PH
520
521 case ns_t_txt:
d2a2c69b
JH
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;
c55a77db 527
b4161d10 528 case ns_t_tlsa:
f6584c83
HSHR
529 pk = bytefield(&p, pk); /* usage */
530 pk = bytefield(&p, pk); /* selector */
531 pk = bytefield(&p, pk); /* match type */
d2a2c69b 532 while (isxdigit(*p))
b4161d10
JH
533 {
534 value = toupper(*p) - (isdigit(*p) ? '0' : '7') << 4;
535 if (isxdigit(*++p))
f6584c83
HSHR
536 {
537 value |= toupper(*p) - (isdigit(*p) ? '0' : '7');
538 p++;
539 }
b4161d10
JH
540 *pk++ = value & 255;
541 }
542
d2a2c69b 543 break;
b4161d10 544
c55a77db 545 case ns_t_srv:
d2a2c69b 546 for (i = 0; i < 3; i++)
f6584c83
HSHR
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 }
c55a77db
PH
554
555 /* Fall through */
556
557 case ns_t_cname:
558 case ns_t_ns:
559 case ns_t_ptr:
d2a2c69b
JH
560 if (ep[-1] != '.') sprintf(CS ep, "%s.", zone);
561 pk = packname(p, pk);
562 break;
c55a77db
PH
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;
c55a77db
PH
569 }
570
571*pkptr = pk;
572return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield;
573}
574
575
846430d9
JH
576static void
577alarmfn(int sig)
578{
579}
c55a77db 580
dd2a32ad
JH
581
582/*************************************************
583* Special-purpose domains *
584*************************************************/
585
586static int
587special_manyhome(uschar * packet, uschar * domain)
588{
589uschar *pk = packet + 12;
590uschar *rdlptr;
591int i, j;
592
593memset(packet, 0, 12);
594
595for (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
612packet[6] = (2048 >> 8) & 255;
613packet[7] = 2048 & 255;
614packet[10] = 0;
615packet[11] = 0;
616
617(void)fwrite(packet, 1, pk - packet, stdout);
618return 0;
619}
620
621static int
622special_again(uschar * packet, uschar * domain)
623{
624int delay = atoi(CCS domain); /* digits at the start of the name */
625if (delay > 0) sleep(delay);
626return TRY_AGAIN;
627}
628
629
c55a77db
PH
630/*************************************************
631* Entry point and main program *
632*************************************************/
633
634int
635main(int argc, char **argv)
636{
637FILE *f;
638DIR *d;
75e0e026 639int domlen, qtypelen;
c55a77db
PH
640int yield, count;
641int i;
642int zonecount = 0;
c55a77db 643struct dirent *de;
c55a77db
PH
644zoneitem zones[32];
645uschar *qualify = NULL;
646uschar *p, *zone;
647uschar *zonefile = NULL;
648uschar domain[256];
649uschar buffer[256];
650uschar qtype[12];
1fb7660f 651uschar packet[2048 * 32 + 32];
f6584c83 652HEADER *header = (HEADER *)packet;
c55a77db 653uschar *pk = packet;
4d4c2a9b 654BOOL dnssec;
589b3179 655BOOL aa;
c55a77db 656
846430d9
JH
657signal(SIGALRM, alarmfn);
658
c55a77db
PH
659if (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
5f3d0983 667(void)sprintf(CS buffer, "%s/dnszones", argv[1]);
c55a77db
PH
668
669d = opendir(CCS buffer);
670if (d == NULL)
671 {
672 fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer,
673 strerror(errno));
674 return NO_RECOVERY;
675 }
676
677while ((de = readdir(d)) != NULL)
678 {
e265af1f 679 uschar *name = US de->d_name;
c55a77db
PH
680 if (Ustrncmp(name, "qualify.", 8) == 0)
681 {
e265af1f 682 qualify = fcopystring(US "%s", name + 7);
c55a77db
PH
683 continue;
684 }
685 if (Ustrncmp(name, "db.", 3) != 0) continue;
686 if (Ustrncmp(name + 3, "ip4.", 4) == 0)
e265af1f 687 zones[zonecount].zone = fcopystring(US "%s.in-addr.arpa", name + 6);
c55a77db 688 else if (Ustrncmp(name + 3, "ip6.", 4) == 0)
e265af1f 689 zones[zonecount].zone = fcopystring(US "%s.ip6.arpa", name + 6);
c55a77db 690 else
e265af1f
JH
691 zones[zonecount].zone = fcopystring(US "%s", name + 2);
692 zones[zonecount++].zonefile = fcopystring(US "%s", name);
c55a77db
PH
693 }
694(void)closedir(d);
695
696/* Get the RR type and upper case it, and check that we recognize it. */
697
698Ustrncpy(qtype, argv[3], sizeof(qtype));
699qtypelen = Ustrlen(qtype);
700for (p = qtype; *p != 0; p++) *p = toupper(*p);
701
1fb7660f
JH
702/* Find the domain, lower case it, deal with any specials,
703check that it is in a zone that we handle,
c55a77db
PH
704and set up the zone file name. The zone names in the table all start with a
705dot. */
706
707domlen = Ustrlen(argv[2]);
708if (argv[2][domlen-1] == '.') domlen--;
709Ustrncpy(domain, argv[2], domlen);
710domain[domlen] = 0;
711for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]);
712
1fb7660f 713if (Ustrcmp(domain, "manyhome.test.ex") == 0 && Ustrcmp(qtype, "A") == 0)
dd2a32ad
JH
714 return special_manyhome(packet, domain);
715else if (domlen >= 14 && Ustrcmp(domain + domlen - 14, "test.again.dns") == 0)
716 return special_again(packet, domain);
717else if (domlen >= 13 && Ustrcmp(domain + domlen - 13, "test.fail.dns") == 0)
718 return NO_RECOVERY;
1fb7660f
JH
719
720
c55a77db
PH
721if (Ustrchr(domain, '.') == NULL && qualify != NULL &&
722 Ustrcmp(domain, "dontqualify") != 0)
723 {
724 Ustrcat(domain, qualify);
725 domlen += Ustrlen(qualify);
726 }
727
728for (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
741if (zonefile == NULL)
742 {
743 fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain);
744 return PASS_ON;
745 }
746
5f3d0983 747(void)sprintf(CS buffer, "%s/dnszones/%s", argv[1], zonefile);
c55a77db
PH
748
749/* Initialize the start of the response packet. We don't have to fake up
750everything, because we know that Exim will look only at the answer and
751additional section parts. */
752
753memset(packet, 0, 12);
754pk += 12;
755
756/* Open the zone file. */
757
42ec9880 758f = fopen(CS buffer, "r");
c55a77db
PH
759if (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
767count = 0;
589b3179 768yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &dnssec, &aa);
c55a77db 769if (yield == NO_RECOVERY) goto END_OFF;
f6584c83 770header->ancount = htons(count);
c55a77db 771
f6584c83
HSHR
772/* If the AA bit should be set (as indicated by the AA prefix in the zone file),
773we are expected to return some records in the authortive section. Bind9: If
774there is data in the answer section, the authoritive section contains the NS
775records, otherwise it contains the SOA record. Currently we mimic this
776behaviour for the first case (there is some answer record).
777*/
778
779if (aa)
780 find_records(f, zone, zone[0] == '.' ? zone+1 : zone, US"NS", 2, &pk, &count, NULL, NULL);
781header->nscount = htons(count - ntohs(header->ancount));
c55a77db 782
75e0e026
PH
783/* There is no need to return any additional records because Exim no longer
784(from release 4.61) makes any use of them. */
f6584c83 785header->arcount = 0;
c55a77db 786
4d4c2a9b 787if (dnssec)
f6584c83 788 header->ad = 1;
4d4c2a9b 789
589b3179 790if (aa)
f6584c83 791 header->aa = 1;
589b3179 792
c55a77db
PH
793/* Close the zone file, write the result, and return. */
794
795END_OFF:
796(void)fclose(f);
797(void)fwrite(packet, 1, pk - packet, stdout);
798return yield;
799}
800
589b3179 801/* vi: aw ai sw=2 sts=2 ts=8 et
4d4c2a9b 802*/
c55a77db 803/* End of fakens.c */