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