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