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