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