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