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 shortfield(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 >> 8) & 255;
 207 *pk++ = value & 255;
 208 return pk;
 209 }
 210
 211
 212
 213 /*************************************************
 214 *              Scan file for RRs                 *
 215 *************************************************/
 216
 217 /* This function scans an open "zone file" for appropriate records, and adds
 218 any that are found to the output buffer.
 219
 220 Arguments:
 221   f           the input FILE
 222   zone        the current zone name
 223   domain      the domain we are looking for
 224   qtype       the type of RR we want
 225   qtypelen    the length of qtype
 226   pkptr       points to the output buffer pointer; this is updated
 227   countptr    points to the record count; this is updated
 228
 229 Returns:      0 on success, else HOST_NOT_FOUND or NO_DATA or NO_RECOVERY or
 230               PASS_ON - the latter if a "PASS ON NOT FOUND" line is seen
 231 */
 232
 233 static int
 234 find_records(FILE *f, uschar *zone, uschar *domain, uschar *qtype,
 235   int qtypelen, uschar **pkptr, int *countptr, BOOL * dnssec)
 236 {
 237 int yield = HOST_NOT_FOUND;
 238 int domainlen = Ustrlen(domain);
 239 BOOL pass_on_not_found = FALSE;
 240 tlist *typeptr;
 241 uschar *pk = *pkptr;
 242 uschar buffer[256];
 243 uschar rrdomain[256];
 244 uschar RRdomain[256];
 245
 246 /* Decode the required type */
 247
 248 for (typeptr = type_list; typeptr->name != NULL; typeptr++)
 249   { if (Ustrcmp(typeptr->name, qtype) == 0) break; }
 250 if (typeptr->name == NULL)
 251   {
 252   fprintf(stderr, "fakens: unknown record type %s\n", qtype);
 253   return NO_RECOVERY;
 254   }
 255
 256 rrdomain[0] = 0;                 /* No previous domain */
 257 (void)fseek(f, 0, SEEK_SET);     /* Start again at the beginning */
 258
 259 *dnssec = TRUE;                 /* cancelled by first nonsecure rec found */
 260
 261 /* Scan for RRs */
 262
 263 while (fgets(CS buffer, sizeof(buffer), f) != NULL)
 264   {
 265   uschar *rdlptr;
 266   uschar *p, *ep, *pp;
 267   BOOL found_cname = FALSE;
 268   int i, plen, value;
 269   int tvalue = typeptr->value;
 270   int qtlen = qtypelen;
 271   BOOL rr_sec = FALSE;
 272
 273   p = buffer;
 274   while (isspace(*p)) p++;
 275   if (*p == 0 || *p == ';') continue;
 276
 277   if (Ustrncmp(p, US"PASS ON NOT FOUND", 17) == 0)
 278     {
 279     pass_on_not_found = TRUE;
 280     continue;
 281     }
 282
 283   ep = buffer + Ustrlen(buffer);
 284   while (isspace(ep[-1])) ep--;
 285   *ep = 0;
 286
 287   p = buffer;
 288   if (Ustrncmp(p, US"DNSSEC ", 7) == 0) /* tagged as secure */
 289     {
 290     rr_sec = TRUE;
 291     p += 7;
 292     }
 293
 294   if (!isspace(*p))
 295     {
 296     uschar *pp = rrdomain;
 297     uschar *PP = RRdomain;
 298     while (!isspace(*p))
 299       {
 300       *pp++ = tolower(*p);
 301       *PP++ = *p++;
 302       }
 303     if (pp[-1] != '.')
 304       {
 305       Ustrcpy(pp, zone);
 306       Ustrcpy(PP, zone);
 307       }
 308     else
 309       {
 310       pp[-1] = 0;
 311       PP[-1] = 0;
 312       }
 313     }
 314
 315   /* Compare domain names; first check for a wildcard */
 316
 317   if (rrdomain[0] == '*')
 318     {
 319     int restlen = Ustrlen(rrdomain) - 1;
 320     if (domainlen > restlen &&
 321         Ustrcmp(domain + domainlen - restlen, rrdomain + 1) != 0) continue;
 322     }
 323
 324   /* Not a wildcard RR */
 325
 326   else if (Ustrcmp(domain, rrdomain) != 0) continue;
 327
 328   /* The domain matches */
 329
 330   if (yield == HOST_NOT_FOUND) yield = NO_DATA;
 331
 332   /* Compare RR types; a CNAME record is always returned */
 333
 334   while (isspace(*p)) p++;
 335
 336   if (Ustrncmp(p, "CNAME", 5) == 0)
 337     {
 338     tvalue = ns_t_cname;
 339     qtlen = 5;
 340     found_cname = TRUE;
 341     }
 342   else if (Ustrncmp(p, qtype, qtypelen) != 0 || !isspace(p[qtypelen])) continue;
 343
 344   /* Found a relevant record */
 345
 346   if (!rr_sec)
 347     *dnssec = FALSE;                    /* cancel AD return */
 348
 349   yield = 0;
 350   *countptr = *countptr + 1;
 351
 352   p += qtlen;
 353   while (isspace(*p)) p++;
 354
 355   /* For a wildcard record, use the search name; otherwise use the record's
 356   name in its original case because it might contain upper case letters. */
 357
 358   pk = packname((rrdomain[0] == '*')? domain : RRdomain, pk);
 359   *pk++ = (tvalue >> 8) & 255;
 360   *pk++ = (tvalue) & 255;
 361   *pk++ = 0;
 362   *pk++ = 1;     /* class = IN */
 363
 364   pk += 4;       /* TTL field; don't care */
 365
 366   rdlptr = pk;   /* remember rdlength field */
 367   pk += 2;
 368
 369   /* The rest of the data depends on the type */
 370
 371   switch (tvalue)
 372     {
 373     case ns_t_soa:  /* Not currently used */
 374     break;
 375
 376     case ns_t_a:
 377     for (i = 0; i < 4; i++)
 378       {
 379       value = 0;
 380       while (isdigit(*p)) value = value*10 + *p++ - '0';
 381       *pk++ = value;
 382       p++;
 383       }
 384     break;
 385
 386     /* The only occurrence of a double colon is for ::1 */
 387     case ns_t_aaaa:
 388     if (Ustrcmp(p, "::1") == 0)
 389       {
 390       memset(pk, 0, 15);
 391       pk += 15;
 392       *pk++ = 1;
 393       }
 394     else for (i = 0; i < 8; i++)
 395       {
 396       value = 0;
 397       while (isxdigit(*p))
 398         {
 399         value = value * 16 + toupper(*p) - (isdigit(*p)? '0' : '7');
 400         p++;
 401         }
 402       *pk++ = (value >> 8) & 255;
 403       *pk++ = value & 255;
 404       p++;
 405       }
 406     break;
 407
 408     case ns_t_mx:
 409     pk = shortfield(&p, pk);
 410     if (ep[-1] != '.') sprintf(ep, "%s.", zone);
 411     pk = packname(p, pk);
 412     plen = Ustrlen(p);
 413     break;
 414
 415     case ns_t_txt:
 416     pp = pk++;
 417     if (*p == '"') p++;   /* Should always be the case */
 418     while (*p != 0 && *p != '"') *pk++ = *p++;
 419     *pp = pk - pp - 1;
 420     break;
 421
 422     case ns_t_tlsa:
 423     pk = shortfield(&p, pk);    /* usage */
 424     pk = shortfield(&p, pk);    /* selector */
 425     pk = shortfield(&p, pk);    /* match type */
 426     while (isxdigit(*p))
 427       {
 428       value = toupper(*p) - (isdigit(*p) ? '0' : '7') << 4;
 429       if (isxdigit(*++p))
 430         {
 431         value |= toupper(*p) - (isdigit(*p) ? '0' : '7');
 432         p++;
 433         }
 434       *pk++ = value & 255;
 435       }
 436
 437     break;
 438
 439     case ns_t_srv:
 440     for (i = 0; i < 3; i++)
 441       {
 442       value = 0;
 443       while (isdigit(*p)) value = value*10 + *p++ - '0';
 444       while (isspace(*p)) p++;
 445       *pk++ = (value >> 8) & 255;
 446       *pk++ = value & 255;
 447       }
 448
 449     /* Fall through */
 450
 451     case ns_t_cname:
 452     case ns_t_ns:
 453     case ns_t_ptr:
 454     if (ep[-1] != '.') sprintf(ep, "%s.", zone);
 455     pk = packname(p, pk);
 456     plen = Ustrlen(p);
 457     break;
 458     }
 459
 460   /* Fill in the length, and we are done with this RR */
 461
 462   rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255;
 463   rdlptr[1] = (pk -rdlptr - 2) & 255;
 464   }
 465
 466 *pkptr = pk;
 467 return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield;
 468 }
 469
 470
 471
 472 /*************************************************
 473 *           Entry point and main program         *
 474 *************************************************/
 475
 476 int
 477 main(int argc, char **argv)
 478 {
 479 FILE *f;
 480 DIR *d;
 481 int domlen, qtypelen;
 482 int yield, count;
 483 int i;
 484 int zonecount = 0;
 485 struct dirent *de;
 486 zoneitem zones[32];
 487 uschar *qualify = NULL;
 488 uschar *p, *zone;
 489 uschar *zonefile = NULL;
 490 uschar domain[256];
 491 uschar buffer[256];
 492 uschar qtype[12];
 493 uschar packet[512];
 494 uschar *pk = packet;
 495 BOOL dnssec;
 496
 497 if (argc != 4)
 498   {
 499   fprintf(stderr, "fakens: expected 3 arguments, received %d\n", argc-1);
 500   return NO_RECOVERY;
 501   }
 502
 503 /* Find the zones */
 504
 505 (void)sprintf(buffer, "%s/../dnszones", argv[1]);
 506
 507 d = opendir(CCS buffer);
 508 if (d == NULL)
 509   {
 510   fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer,
 511     strerror(errno));
 512   return NO_RECOVERY;
 513   }
 514
 515 while ((de = readdir(d)) != NULL)
 516   {
 517   uschar *name = de->d_name;
 518   if (Ustrncmp(name, "qualify.", 8) == 0)
 519     {
 520     qualify = fcopystring("%s", name + 7);
 521     continue;
 522     }
 523   if (Ustrncmp(name, "db.", 3) != 0) continue;
 524   if (Ustrncmp(name + 3, "ip4.", 4) == 0)
 525     zones[zonecount].zone = fcopystring("%s.in-addr.arpa", name + 6);
 526   else if (Ustrncmp(name + 3, "ip6.", 4) == 0)
 527     zones[zonecount].zone = fcopystring("%s.ip6.arpa", name + 6);
 528   else
 529     zones[zonecount].zone = fcopystring("%s", name + 2);
 530   zones[zonecount++].zonefile = fcopystring("%s", name);
 531   }
 532 (void)closedir(d);
 533
 534 /* Get the RR type and upper case it, and check that we recognize it. */
 535
 536 Ustrncpy(qtype, argv[3], sizeof(qtype));
 537 qtypelen = Ustrlen(qtype);
 538 for (p = qtype; *p != 0; p++) *p = toupper(*p);
 539
 540 /* Find the domain, lower case it, check that it is in a zone that we handle,
 541 and set up the zone file name. The zone names in the table all start with a
 542 dot. */
 543
 544 domlen = Ustrlen(argv[2]);
 545 if (argv[2][domlen-1] == '.') domlen--;
 546 Ustrncpy(domain, argv[2], domlen);
 547 domain[domlen] = 0;
 548 for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]);
 549
 550 if (Ustrchr(domain, '.') == NULL && qualify != NULL &&
 551     Ustrcmp(domain, "dontqualify") != 0)
 552   {
 553   Ustrcat(domain, qualify);
 554   domlen += Ustrlen(qualify);
 555   }
 556
 557 for (i = 0; i < zonecount; i++)
 558   {
 559   int zlen;
 560   zone = zones[i].zone;
 561   zlen = Ustrlen(zone);
 562   if (Ustrcmp(domain, zone+1) == 0 || (domlen >= zlen &&
 563       Ustrcmp(domain + domlen - zlen, zone) == 0))
 564     {
 565     zonefile = zones[i].zonefile;
 566     break;
 567     }
 568   }
 569
 570 if (zonefile == NULL)
 571   {
 572   fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain);
 573   return PASS_ON;
 574   }
 575
 576 (void)sprintf(buffer, "%s/../dnszones/%s", argv[1], zonefile);
 577
 578 /* Initialize the start of the response packet. We don't have to fake up
 579 everything, because we know that Exim will look only at the answer and
 580 additional section parts. */
 581
 582 memset(packet, 0, 12);
 583 pk += 12;
 584
 585 /* Open the zone file. */
 586
 587 f = fopen(buffer, "r");
 588 if (f == NULL)
 589   {
 590   fprintf(stderr, "fakens: failed to open %s: %s\n", buffer, strerror(errno));
 591   return NO_RECOVERY;
 592   }
 593
 594 /* Find the records we want, and add them to the result. */
 595
 596 count = 0;
 597 yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &dnssec);
 598 if (yield == NO_RECOVERY) goto END_OFF;
 599
 600 packet[6] = (count >> 8) & 255;
 601 packet[7] = count & 255;
 602
 603 /* There is no need to return any additional records because Exim no longer
 604 (from release 4.61) makes any use of them. */
 605
 606 packet[10] = 0;
 607 packet[11] = 0;
 608
 609 if (dnssec)
 610   ((HEADER *)packet)->ad = 1;
 611
 612 /* Close the zone file, write the result, and return. */
 613
 614 END_OFF:
 615 (void)fclose(f);
 616 (void)fwrite(packet, 1, pk - packet, stdout);
 617 return yield;
 618 }
 619
 620 /* vi: aw ai sw=2
 621 */
 622 /* End of fakens.c */