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 if (dnssec) *dnssec = TRUE;     /* cancelled by first nonsecure rec found */
 346 if (aa) *aa = TRUE;             /* cancelled by first non-aa rec found */
 347
 348 /* Scan for RRs */
 349
 350 while (fgets(CS buffer, sizeof(buffer), f) != NULL)
 351   {
 352   uschar *rdlptr;
 353   uschar *p, *ep, *pp;
 354   BOOL found_cname = FALSE;
 355   int i, value;
 356   int tvalue = typeptr->value;
 357   int qtlen = qtypelen;
 358   BOOL rr_sec = FALSE;
 359   BOOL rr_aa = FALSE;
 360   int delay = 0;
 361   uint ttl = DEFAULT_TTL;
 362
 363   p = buffer;
 364   while (isspace(*p)) p++;
 365   if (*p == 0 || *p == ';') continue;
 366
 367   if (Ustrncmp(p, US"PASS ON NOT FOUND", 17) == 0)
 368     {
 369     pass_on_not_found = TRUE;
 370     continue;
 371     }
 372
 373   ep = buffer + Ustrlen(buffer);
 374   while (isspace(ep[-1])) ep--;
 375   *ep = 0;
 376
 377   p = buffer;
 378   for (;;)
 379     {
 380     if (Ustrncmp(p, US"DNSSEC ", 7) == 0)       /* tagged as secure */
 381       {
 382       rr_sec = TRUE;
 383       p += 7;
 384       }
 385     else if (Ustrncmp(p, US"AA ", 3) == 0)      /* tagged as authoritative */
 386       {
 387       rr_aa = TRUE;
 388       p += 3;
 389       }
 390     else if (Ustrncmp(p, US"DELAY=", 6) == 0)   /* delay before response */
 391       {
 392       for (p += 6; *p >= '0' && *p <= '9'; p++) delay = delay*10 + *p - '0';
 393       if (isspace(*p)) p++;
 394       }
 395     else if (Ustrncmp(p, US"TTL=", 4) == 0)     /* TTL for record */
 396       {
 397       ttl = 0;
 398       for (p += 4; *p >= '0' && *p <= '9'; p++) ttl = ttl*10 + *p - '0';
 399       if (isspace(*p)) p++;
 400       }
 401     else
 402       break;
 403     }
 404
 405   if (!isspace(*p))     /* new domain name */
 406     {
 407     uschar *pp = rrdomain;
 408     uschar *PP = RRdomain;
 409     while (!isspace(*p))
 410       {
 411       *pp++ = tolower(*p);
 412       *PP++ = *p++;
 413       }
 414     if (pp[-1] != '.')
 415       {
 416       Ustrcpy(pp, zone);
 417       Ustrcpy(PP, zone);
 418       }
 419     else
 420       {
 421       pp[-1] = 0;
 422       PP[-1] = 0;
 423       }
 424     }                   /* else use previous line's domain name */
 425
 426   /* Compare domain names; first check for a wildcard */
 427
 428   if (rrdomain[0] == '*')
 429     {
 430     int restlen = Ustrlen(rrdomain) - 1;
 431     if (domainlen > restlen &&
 432         Ustrcmp(domain + domainlen - restlen, rrdomain + 1) != 0) continue;
 433     }
 434
 435   /* Not a wildcard RR */
 436
 437   else if (Ustrcmp(domain, rrdomain) != 0) continue;
 438
 439   /* The domain matches */
 440
 441   if (yield == HOST_NOT_FOUND) yield = NO_DATA;
 442
 443   /* Compare RR types; a CNAME record is always returned */
 444
 445   while (isspace(*p)) p++;
 446
 447   if (Ustrncmp(p, "CNAME", 5) == 0)
 448     {
 449     tvalue = ns_t_cname;
 450     qtlen = 5;
 451     found_cname = TRUE;
 452     }
 453   else if (Ustrncmp(p, qtype, qtypelen) != 0 || !isspace(p[qtypelen])) continue;
 454
 455   /* Found a relevant record */
 456   if (delay)
 457     millisleep(delay);
 458
 459   if (dnssec && !rr_sec)
 460     *dnssec = FALSE;                    /* cancel AD return */
 461
 462   if (aa && !rr_aa)
 463     *aa = FALSE;                        /* cancel AA return */
 464
 465   yield = 0;
 466   *countptr = *countptr + 1;
 467
 468   p += qtlen;
 469   while (isspace(*p)) p++;
 470
 471   /* For a wildcard record, use the search name; otherwise use the record's
 472   name in its original case because it might contain upper case letters. */
 473
 474   pk = packname((rrdomain[0] == '*')? domain : RRdomain, pk);
 475   *pk++ = (tvalue >> 8) & 255;
 476   *pk++ = (tvalue) & 255;
 477   *pk++ = 0;
 478   *pk++ = 1;     /* class = IN */
 479
 480   *pk++ = (ttl >>24) & 255;
 481   *pk++ = (ttl >>16) & 255;
 482   *pk++ = (ttl >> 8) & 255;
 483   *pk++ = ttl & 255;
 484
 485   rdlptr = pk;   /* remember rdlength field */
 486   pk += 2;
 487
 488   /* The rest of the data depends on the type */
 489
 490   switch (tvalue)
 491     {
 492     case ns_t_soa:
 493       p = Ustrtok(p, " ");
 494       ep = p + Ustrlen(p);
 495       if (ep[-1] != '.') sprintf(CS ep, "%s.", zone);
 496       pk = packname(p, pk);                     /* primary ns */
 497       p = Ustrtok(NULL, " ");
 498       pk = packname(p , pk);                    /* responsible mailbox */
 499       *(p += Ustrlen(p)) = ' ';
 500       while (isspace(*p)) p++;
 501       pk = longfield(&p, pk);                   /* serial */
 502       pk = longfield(&p, pk);                   /* refresh */
 503       pk = longfield(&p, pk);                   /* retry */
 504       pk = longfield(&p, pk);                   /* expire */
 505       pk = longfield(&p, pk);                   /* minimum */
 506       break;
 507
 508     case ns_t_a:
 509       inet_pton(AF_INET, CCS p, pk);                /* FIXME: error checking */
 510       pk += 4;
 511       break;
 512
 513     case ns_t_aaaa:
 514       inet_pton(AF_INET6, CCS p, pk);               /* FIXME: error checking */
 515       pk += 16;
 516       break;
 517
 518     case ns_t_mx:
 519       pk = shortfield(&p, pk);
 520       if (ep[-1] != '.') sprintf(CS ep, "%s.", zone);
 521       pk = packname(p, pk);
 522       break;
 523
 524     case ns_t_txt:
 525       pp = pk++;
 526       if (*p == '"') p++;   /* Should always be the case */
 527       while (*p != 0 && *p != '"') *pk++ = *p++;
 528       *pp = pk - pp - 1;
 529       break;
 530
 531     case ns_t_tlsa:
 532       pk = bytefield(&p, pk);   /* usage */
 533       pk = bytefield(&p, pk);   /* selector */
 534       pk = bytefield(&p, pk);   /* match type */
 535       while (isxdigit(*p))
 536       {
 537       value = toupper(*p) - (isdigit(*p) ? '0' : '7') << 4;
 538       if (isxdigit(*++p))
 539         {
 540         value |= toupper(*p) - (isdigit(*p) ? '0' : '7');
 541         p++;
 542         }
 543       *pk++ = value & 255;
 544       }
 545
 546       break;
 547
 548     case ns_t_srv:
 549       for (i = 0; i < 3; i++)
 550         {
 551         value = 0;
 552         while (isdigit(*p)) value = value*10 + *p++ - '0';
 553         while (isspace(*p)) p++;
 554         *pk++ = (value >> 8) & 255;
 555         *pk++ = value & 255;
 556         }
 557
 558     /* Fall through */
 559
 560     case ns_t_cname:
 561     case ns_t_ns:
 562     case ns_t_ptr:
 563       if (ep[-1] != '.') sprintf(CS ep, "%s.", zone);
 564       pk = packname(p, pk);
 565       break;
 566     }
 567
 568   /* Fill in the length, and we are done with this RR */
 569
 570   rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255;
 571   rdlptr[1] = (pk -rdlptr - 2) & 255;
 572   }
 573
 574 *pkptr = pk;
 575 return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield;
 576 }
 577
 578
 579 static  void
 580 alarmfn(int sig)
 581 {
 582 }
 583
 584
 585 /*************************************************
 586 *     Special-purpose domains                    *
 587 *************************************************/
 588
 589 static int
 590 special_manyhome(uschar * packet, uschar * domain)
 591 {
 592 uschar *pk = packet + 12;
 593 uschar *rdlptr;
 594 int i, j;
 595
 596 memset(packet, 0, 12);
 597
 598 for (i = 104; i <= 111; i++) for (j = 0; j <= 255; j++)
 599   {
 600   pk = packname(domain, pk);
 601   *pk++ = (ns_t_a >> 8) & 255;
 602   *pk++ = (ns_t_a) & 255;
 603   *pk++ = 0;
 604   *pk++ = 1;     /* class = IN */
 605   pk += 4;       /* TTL field; don't care */
 606   rdlptr = pk;   /* remember rdlength field */
 607   pk += 2;
 608
 609   *pk++ = 10; *pk++ = 250; *pk++ = i; *pk++ = j;
 610
 611   rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255;
 612   rdlptr[1] = (pk - rdlptr - 2) & 255;
 613   }
 614
 615 packet[6] = (2048 >> 8) & 255;
 616 packet[7] = 2048 & 255;
 617 packet[10] = 0;
 618 packet[11] = 0;
 619
 620 (void)fwrite(packet, 1, pk - packet, stdout);
 621 return 0;
 622 }
 623
 624 static int
 625 special_again(uschar * packet, uschar * domain)
 626 {
 627 int delay = atoi(CCS domain);  /* digits at the start of the name */
 628 if (delay > 0) sleep(delay);
 629 return TRY_AGAIN;
 630 }
 631
 632
 633 /*************************************************
 634 *           Entry point and main program         *
 635 *************************************************/
 636
 637 int
 638 main(int argc, char **argv)
 639 {
 640 FILE *f;
 641 DIR *d;
 642 int domlen, qtypelen;
 643 int yield, count;
 644 int i;
 645 int zonecount = 0;
 646 struct dirent *de;
 647 zoneitem zones[32];
 648 uschar *qualify = NULL;
 649 uschar *p, *zone;
 650 uschar *zonefile = NULL;
 651 uschar domain[256];
 652 uschar buffer[256];
 653 uschar qtype[12];
 654 uschar packet[2048 * 32 + 32];
 655 HEADER *header = (HEADER *)packet;
 656 uschar *pk = packet;
 657 BOOL dnssec;
 658 BOOL aa;
 659
 660 signal(SIGALRM, alarmfn);
 661
 662 if (argc != 4)
 663   {
 664   fprintf(stderr, "fakens: expected 3 arguments, received %d\n", argc-1);
 665   return NO_RECOVERY;
 666   }
 667
 668 /* Find the zones */
 669
 670 (void)sprintf(CS buffer, "%s/dnszones", argv[1]);
 671
 672 d = opendir(CCS buffer);
 673 if (d == NULL)
 674   {
 675   fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer,
 676     strerror(errno));
 677   return NO_RECOVERY;
 678   }
 679
 680 while ((de = readdir(d)) != NULL)
 681   {
 682   uschar *name = US de->d_name;
 683   if (Ustrncmp(name, "qualify.", 8) == 0)
 684     {
 685     qualify = fcopystring(US "%s", name + 7);
 686     continue;
 687     }
 688   if (Ustrncmp(name, "db.", 3) != 0) continue;
 689   if (Ustrncmp(name + 3, "ip4.", 4) == 0)
 690     zones[zonecount].zone = fcopystring(US "%s.in-addr.arpa", name + 6);
 691   else if (Ustrncmp(name + 3, "ip6.", 4) == 0)
 692     zones[zonecount].zone = fcopystring(US "%s.ip6.arpa", name + 6);
 693   else
 694     zones[zonecount].zone = fcopystring(US "%s", name + 2);
 695   zones[zonecount++].zonefile = fcopystring(US "%s", name);
 696   }
 697 (void)closedir(d);
 698
 699 /* Get the RR type and upper case it, and check that we recognize it. */
 700
 701 Ustrncpy(qtype, argv[3], sizeof(qtype));
 702 qtypelen = Ustrlen(qtype);
 703 for (p = qtype; *p != 0; p++) *p = toupper(*p);
 704
 705 /* Find the domain, lower case it, deal with any specials,
 706 check that it is in a zone that we handle,
 707 and set up the zone file name. The zone names in the table all start with a
 708 dot. */
 709
 710 domlen = Ustrlen(argv[2]);
 711 if (argv[2][domlen-1] == '.') domlen--;
 712 Ustrncpy(domain, argv[2], domlen);
 713 domain[domlen] = 0;
 714 for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]);
 715
 716 if (Ustrcmp(domain, "manyhome.test.ex") == 0 && Ustrcmp(qtype, "A") == 0)
 717   return special_manyhome(packet, domain);
 718 else if (domlen >= 14 && Ustrcmp(domain + domlen - 14, "test.again.dns") == 0)
 719   return special_again(packet, domain);
 720 else if (domlen >= 13 && Ustrcmp(domain + domlen - 13, "test.fail.dns") == 0)
 721   return NO_RECOVERY;
 722
 723
 724 if (Ustrchr(domain, '.') == NULL && qualify != NULL &&
 725     Ustrcmp(domain, "dontqualify") != 0)
 726   {
 727   Ustrcat(domain, qualify);
 728   domlen += Ustrlen(qualify);
 729   }
 730
 731 for (i = 0; i < zonecount; i++)
 732   {
 733   int zlen;
 734   zone = zones[i].zone;
 735   zlen = Ustrlen(zone);
 736   if (Ustrcmp(domain, zone+1) == 0 || (domlen >= zlen &&
 737       Ustrcmp(domain + domlen - zlen, zone) == 0))
 738     {
 739     zonefile = zones[i].zonefile;
 740     break;
 741     }
 742   }
 743
 744 if (zonefile == NULL)
 745   {
 746   fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain);
 747   return PASS_ON;
 748   }
 749
 750 (void)sprintf(CS buffer, "%s/dnszones/%s", argv[1], zonefile);
 751
 752 /* Initialize the start of the response packet. We don't have to fake up
 753 everything, because we know that Exim will look only at the answer and
 754 additional section parts. */
 755
 756 memset(packet, 0, 12);
 757 pk += 12;
 758
 759 /* Open the zone file. */
 760
 761 f = fopen(CS buffer, "r");
 762 if (f == NULL)
 763   {
 764   fprintf(stderr, "fakens: failed to open %s: %s\n", buffer, strerror(errno));
 765   return NO_RECOVERY;
 766   }
 767
 768 /* Find the records we want, and add them to the result. */
 769
 770 count = 0;
 771 yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &dnssec, &aa);
 772 if (yield == NO_RECOVERY) goto END_OFF;
 773 header->ancount = htons(count);
 774
 775 /* If the AA bit should be set (as indicated by the AA prefix in the zone file),
 776 we are expected to return some records in the authoritative section. Bind9: If
 777 there is data in the answer section, the authoritative section contains the NS
 778 records, otherwise it contains the SOA record.  Currently we mimic this
 779 behaviour for the first case (there is some answer record).
 780 */
 781
 782 if (aa)
 783   find_records(f, zone, zone[0] == '.' ? zone+1 : zone, US"NS", 2, &pk, &count, NULL, NULL);
 784 header->nscount = htons(count - ntohs(header->ancount));
 785
 786 /* There is no need to return any additional records because Exim no longer
 787 (from release 4.61) makes any use of them. */
 788 header->arcount = 0;
 789
 790 if (dnssec)
 791   header->ad = 1;
 792
 793 if (aa)
 794   header->aa = 1;
 795
 796 /* Close the zone file, write the result, and return. */
 797
 798 END_OFF:
 799 (void)fclose(f);
 800 (void)fwrite(packet, 1, pk - packet, stdout);
 801 return yield;
 802 }
 803
 804 /* vi: aw ai sw=2 sts=2 ts=8 et
 805 */
 806 /* End of fakens.c */