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