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