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