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