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