test/src/fakens.c

   1 /* $Cambridge: exim/test/src/fakens.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */
   2
   3 /*************************************************
   4 *       fakens - A Fake Nameserver Program       *
   5 *************************************************/
   6
   7 /* This program exists to support the testing of DNS handling code in Exim. It
   8 avoids the need to install special zones in a real nameserver. When Exim is
   9 running in its (new) test harness, DNS lookups are first passed to this program
  10 instead of to the real resolver. (With a few exceptions - see the discussion in
  11 the test suite's README file.) The program is also passed the name of the Exim
  12 spool directory; it expects to find its "zone files" in ../dnszones relative to
  13 that directory. Note that there is little checking in this program. The fake
  14 zone files are assumed to be syntactically valid.
  15
  16 The zones that are handled are found by scanning the dnszones directory. A file
  17 whose name is of the form db.ip4.x is a zone file for .x.in-addr.arpa; a file
  18 whose name is of the form db.ip6.x is a zone file for .x.ip6.arpa; a file of
  19 the form db.anything.else is a zone file for .anything.else. A file of the form
  20 qualify.x.y specifies the domain that is used to qualify single-component
  21 names, except for the name "dontqualify".
  22
  23 The arguments to the program are:
  24
  25   the name of the Exim spool directory
  26   the domain name that is being sought
  27   the DNS record type that is being sought
  28
  29 The output from the program is written to stdout. It is supposed to be in
  30 exactly the same format as a traditional namserver response (see RFC 1035) so
  31 that Exim can process it as normal. At present, no compression is used.
  32 Error messages are written to stderr.
  33
  34 The return codes from the program are zero for success, and otherwise the
  35 values that are set in h_errno after a failing call to the normal resolver:
  36
  37   1 HOST_NOT_FOUND     host not found (authoritative)
  38   2 TRY_AGAIN          server failure
  39   3 NO_RECOVERY        non-recoverable error
  40   4 NO_DATA            valid name, no data of requested type
  41
  42 In a real nameserver, TRY_AGAIN is also used for a non-authoritative not found,
  43 but it is not used for that here. There is also one extra return code:
  44
  45   5 PASS_ON            requests Exim to call res_search()
  46
  47 This is used for zones that fakens does not recognize. It is also used if a
  48 line in the zone file contains exactly this:
  49
  50   PASS ON NOT FOUND
  51
  52 and the domain is not found. It converts the the result to PASS_ON instead of
  53 HOST_NOT_FOUND. */
  54
  55 #include <ctype.h>
  56 #include <stdarg.h>
  57 #include <stdio.h>
  58 #include <string.h>
  59 #include <netdb.h>
  60 #include <errno.h>
  61 #include <arpa/nameser.h>
  62 #include <sys/types.h>
  63 #include <dirent.h>
  64
  65 #define FALSE         0
  66 #define TRUE          1
  67 #define PASS_ON       5
  68
  69 typedef int BOOL;
  70 typedef unsigned char uschar;
  71
  72 #define CS   (char *)
  73 #define CCS  (const char *)
  74 #define US   (unsigned char *)
  75
  76 #define Ustrcat(s,t)       strcat(CS(s),CCS(t))
  77 #define Ustrchr(s,n)       US strchr(CCS(s),n)
  78 #define Ustrcmp(s,t)       strcmp(CCS(s),CCS(t))
  79 #define Ustrcpy(s,t)       strcpy(CS(s),CCS(t))
  80 #define Ustrlen(s)         (int)strlen(CCS(s))
  81 #define Ustrncmp(s,t,n)    strncmp(CCS(s),CCS(t),n)
  82 #define Ustrncpy(s,t,n)    strncpy(CS(s),CCS(t),n)
  83
  84
  85 typedef struct adomainstr {
  86   struct adomainstr *next;
  87   uschar name[1];
  88 } adomainstr;
  89
  90 typedef struct zoneitem {
  91   uschar *zone;
  92   uschar *zonefile;
  93 } zoneitem;
  94
  95 typedef struct tlist {
  96   uschar *name;
  97   int value;
  98 } tlist;
  99
 100 /* On some (older?) operating systems, the standard ns_t_xxx definitions are
 101 not available, and only the older T_xxx ones exist in nameser.h. If ns_t_a is
 102 not defined, assume we are in this state. A really old system might not even
 103 know about AAAA and SRV at all. */
 104
 105 #ifndef ns_t_a
 106 #define ns_t_a      T_A
 107 #define ns_t_ns     T_NS
 108 #define ns_t_cname  T_CNAME
 109 #define ns_t_soa    T_SOA
 110 #define ns_t_ptr    T_PTR
 111 #define ns_t_mx     T_MX
 112 #define ns_t_txt    T_TXT
 113 #define ns_t_aaaa   T_AAAA
 114 #define ns_t_srv    T_SRV
 115 #ifndef T_AAAA
 116 #define T_AAAA      28
 117 #endif
 118 #ifndef T_SRV
 119 #define T_SRV       33
 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   { NULL,        0 }
 134 };
 135
 136
 137
 138 /*************************************************
 139 *           Get memory and sprintf into it       *
 140 *************************************************/
 141
 142 /* This is used when building a table of zones and their files.
 143
 144 Arguments:
 145   format       a format string
 146   ...          arguments
 147
 148 Returns:       pointer to formatted string
 149 */
 150
 151 static uschar *
 152 fcopystring(uschar *format, ...)
 153 {
 154 uschar *yield;
 155 char buffer[256];
 156 va_list ap;
 157 va_start(ap, format);
 158 vsprintf(buffer, format, ap);
 159 va_end(ap);
 160 yield = (uschar *)malloc(Ustrlen(buffer) + 1);
 161 Ustrcpy(yield, buffer);
 162 return yield;
 163 }
 164
 165
 166 /*************************************************
 167 *             Pack name into memory              *
 168 *************************************************/
 169
 170 /* This function packs a domain name into memory according to DNS rules. At
 171 present, it doesn't do any compression.
 172
 173 Arguments:
 174   name         the name
 175   pk           where to put it
 176
 177 Returns:       the updated value of pk
 178 */
 179
 180 static uschar *
 181 packname(uschar *name, uschar *pk)
 182 {
 183 while (*name != 0)
 184   {
 185   uschar *p = name;
 186   while (*p != 0 && *p != '.') p++;
 187   *pk++ = (p - name);
 188   memmove(pk, name, p - name);
 189   pk += p - name;
 190   name = (*p == 0)? p : p + 1;
 191   }
 192 *pk++ = 0;
 193 return pk;
 194 }
 195
 196
 197
 198 /*************************************************
 199 *              Scan file for RRs                 *
 200 *************************************************/
 201
 202 /* This function scans an open "zone file" for appropriate records, and adds
 203 any that are found to the output buffer.
 204
 205 Arguments:
 206   f           the input FILE
 207   zone        the current zone name
 208   domain      the domain we are looking for
 209   qtype       the type of RR we want
 210   qtypelen    the length of qtype
 211   pkptr       points to the output buffer pointer; this is updated
 212   countptr    points to the record count; this is updated
 213   adomainptr  points to where to hang additional domains
 214
 215 Returns:      0 on success, else HOST_NOT_FOUND or NO_DATA or NO_RECOVERY or
 216               PASS_ON - the latter if a "PASS ON NOT FOUND" line is seen
 217 */
 218
 219 static int
 220 find_records(FILE *f, uschar *zone, uschar *domain, uschar *qtype,
 221   int qtypelen, uschar **pkptr, int *countptr, adomainstr **adomainptr)
 222 {
 223 int yield = HOST_NOT_FOUND;
 224 int zonelen = Ustrlen(zone);
 225 int domainlen = Ustrlen(domain);
 226 BOOL pass_on_not_found = FALSE;
 227 tlist *typeptr;
 228 uschar *pk = *pkptr;
 229 uschar buffer[256];
 230 uschar rrdomain[256];
 231
 232 /* Decode the required type */
 233
 234 for (typeptr = type_list; typeptr->name != NULL; typeptr++)
 235   { if (Ustrcmp(typeptr->name, qtype) == 0) break; }
 236 if (typeptr->name == NULL)
 237   {
 238   fprintf(stderr, "fakens: unknown record type %s\n", qtype);
 239   return NO_RECOVERY;
 240   }
 241
 242 rrdomain[0] = 0;                 /* No previous domain */
 243 (void)fseek(f, 0, SEEK_SET);     /* Start again at the beginning */
 244
 245 /* Scan for RRs */
 246
 247 while (fgets(CS buffer, sizeof(buffer), f) != NULL)
 248   {
 249   uschar *rdlptr;
 250   uschar *p, *ep, *pp;
 251   BOOL found_cname = FALSE;
 252   int i, plen, value;
 253   int tvalue = typeptr->value;
 254   int qtlen = qtypelen;
 255
 256   p = buffer;
 257   while (isspace(*p)) p++;
 258   if (*p == 0 || *p == ';') continue;
 259
 260   if (Ustrncmp(p, "PASS ON NOT FOUND", 17) == 0)
 261     {
 262     pass_on_not_found = TRUE;
 263     continue;
 264     }
 265
 266   ep = buffer + Ustrlen(buffer);
 267   while (isspace(ep[-1])) ep--;
 268   *ep = 0;
 269
 270   p = buffer;
 271   if (!isspace(*p))
 272     {
 273     uschar *pp = rrdomain;
 274     while (!isspace(*p)) *pp++ = tolower(*p++);
 275     if (pp[-1] != '.') Ustrcpy(pp, zone); else pp[-1] = 0;
 276     }
 277
 278   /* Compare domain names; first check for a wildcard */
 279
 280   if (rrdomain[0] == '*')
 281     {
 282     int restlen = Ustrlen(rrdomain) - 1;
 283     if (domainlen > restlen &&
 284         Ustrcmp(domain + domainlen - restlen, rrdomain + 1) != 0) continue;
 285     }
 286
 287   /* Not a wildcard RR */
 288
 289   else if (Ustrcmp(domain, rrdomain) != 0) continue;
 290
 291   /* The domain matches */
 292
 293   if (yield == HOST_NOT_FOUND) yield = NO_DATA;
 294
 295   /* Compare RR types; a CNAME record is always returned */
 296
 297   while (isspace(*p)) p++;
 298
 299   if (Ustrncmp(p, "CNAME", 5) == 0)
 300     {
 301     tvalue = ns_t_cname;
 302     qtlen = 5;
 303     found_cname = TRUE;
 304     }
 305   else if (Ustrncmp(p, qtype, qtypelen) != 0 || !isspace(p[qtypelen])) continue;
 306
 307   /* Found a relevant record */
 308
 309   yield = 0;
 310   *countptr = *countptr + 1;
 311
 312   p += qtlen;
 313   while (isspace(*p)) p++;
 314
 315   pk = packname(domain, pk);            /* Not rrdomain because of wildcard */
 316   *pk++ = (tvalue >> 8) & 255;
 317   *pk++ = (tvalue) & 255;
 318   *pk++ = 0;
 319   *pk++ = 1;     /* class = IN */
 320
 321   pk += 4;       /* TTL field; don't care */
 322
 323   rdlptr = pk;   /* remember rdlength field */
 324   pk += 2;
 325
 326   /* The rest of the data depends on the type */
 327
 328   switch (tvalue)
 329     {
 330     case ns_t_soa:  /* Not currently used */
 331     break;
 332
 333     case ns_t_a:
 334     for (i = 0; i < 4; i++)
 335       {
 336       value = 0;
 337       while (isdigit(*p)) value = value*10 + *p++ - '0';
 338       *pk++ = value;
 339       p++;
 340       }
 341     break;
 342
 343     /* The only occurrence of a double colon is for ::1 */
 344     case ns_t_aaaa:
 345     if (Ustrcmp(p, "::1") == 0)
 346       {
 347       memset(pk, 0, 15);
 348       pk += 15;
 349       *pk++ = 1;
 350       }
 351     else for (i = 0; i < 8; i++)
 352       {
 353       value = 0;
 354       while (isxdigit(*p))
 355         {
 356         value = value * 16 + toupper(*p) - (isdigit(*p)? '0' : '7');
 357         p++;
 358         }
 359       *pk++ = (value >> 8) & 255;
 360       *pk++ = value & 255;
 361       p++;
 362       }
 363     break;
 364
 365     case ns_t_mx:
 366     value = 0;
 367     while (isdigit(*p)) value = value*10 + *p++ - '0';
 368     while (isspace(*p)) p++;
 369     *pk++ = (value >> 8) & 255;
 370     *pk++ = value & 255;
 371     goto PACKNAME;
 372
 373     case ns_t_txt:
 374     pp = pk++;
 375     if (*p == '"') p++;   /* Should always be the case */
 376     while (*p != 0 && *p != '"') *pk++ = *p++;
 377     *pp = pk - pp - 1;
 378     break;
 379
 380     case ns_t_srv:
 381     for (i = 0; i < 3; i++)
 382       {
 383       value = 0;
 384       while (isdigit(*p)) value = value*10 + *p++ - '0';
 385       while (isspace(*p)) p++;
 386       *pk++ = (value >> 8) & 255;
 387       *pk++ = value & 255;
 388       }
 389
 390     /* Fall through */
 391
 392     case ns_t_cname:
 393     case ns_t_ns:
 394     case ns_t_ptr:
 395     PACKNAME:
 396     if (ep[-1] != '.') sprintf(ep, "%s.", zone);
 397     pk = packname(p, pk);
 398     plen = Ustrlen(p);
 399     if (adomainptr != NULL && plen > zonelen + 2 &&
 400         Ustrncmp(p + plen - zonelen - 1, zone, zonelen) == 0)
 401       {
 402       adomainstr *adomain = (adomainstr *)malloc(sizeof(adomainstr) + plen);
 403       *adomainptr = adomain;
 404       adomainptr = &(adomain->next);
 405       adomain->next = NULL;
 406       Ustrncpy(adomain->name, p, plen - 1);
 407       adomain->name[plen-1] = 0;
 408       }
 409     break;
 410     }
 411
 412   /* Fill in the length, and we are done with this RR */
 413
 414   rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255;
 415   rdlptr[1] = (pk -rdlptr - 2) & 255;
 416
 417   /* If we have just yielded a CNAME, we must change the domain name to the
 418   new domain, and re-start the scan from the beginning. */
 419
 420   if (found_cname)
 421     {
 422     domain = fcopystring("%s", p);
 423     domainlen = Ustrlen(domain);
 424     domain[domainlen - 1] = 0;       /* Removed trailing dot */
 425     rrdomain[0] = 0;                 /* No previous domain */
 426     (void)fseek(f, 0, SEEK_SET);     /* Start again at the beginning */
 427     }
 428   }
 429
 430 *pkptr = pk;
 431 return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield;
 432 }
 433
 434
 435
 436 /*************************************************
 437 *           Entry point and main program         *
 438 *************************************************/
 439
 440 int
 441 main(int argc, char **argv)
 442 {
 443 FILE *f;
 444 DIR *d;
 445 int dirlen, domlen, qtypelen;
 446 int yield, count;
 447 int i;
 448 int zonecount = 0;
 449 tlist *typeptr;
 450 struct dirent *de;
 451 adomainstr *adomain = NULL;
 452 zoneitem zones[32];
 453 uschar *qualify = NULL;
 454 uschar *p, *zone;
 455 uschar *zonefile = NULL;
 456 uschar domain[256];
 457 uschar buffer[256];
 458 uschar qtype[12];
 459 uschar packet[512];
 460 uschar *pk = packet;
 461
 462 if (argc != 4)
 463   {
 464   fprintf(stderr, "fakens: expected 3 arguments, received %d\n", argc-1);
 465   return NO_RECOVERY;
 466   }
 467
 468 /* Find the zones */
 469
 470 (void)sprintf(buffer, "%s/../dnszones", argv[1]);
 471
 472 d = opendir(CCS buffer);
 473 if (d == NULL)
 474   {
 475   fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer,
 476     strerror(errno));
 477   return NO_RECOVERY;
 478   }
 479
 480 while ((de = readdir(d)) != NULL)
 481   {
 482   uschar *name = de->d_name;
 483   if (Ustrncmp(name, "qualify.", 8) == 0)
 484     {
 485     qualify = fcopystring("%s", name + 7);
 486     continue;
 487     }
 488   if (Ustrncmp(name, "db.", 3) != 0) continue;
 489   if (Ustrncmp(name + 3, "ip4.", 4) == 0)
 490     zones[zonecount].zone = fcopystring("%s.in-addr.arpa", name + 6);
 491   else if (Ustrncmp(name + 3, "ip6.", 4) == 0)
 492     zones[zonecount].zone = fcopystring("%s.ip6.arpa", name + 6);
 493   else
 494     zones[zonecount].zone = fcopystring("%s", name + 2);
 495   zones[zonecount++].zonefile = fcopystring("%s", name);
 496   }
 497 (void)closedir(d);
 498
 499 /* Get the RR type and upper case it, and check that we recognize it. */
 500
 501 Ustrncpy(qtype, argv[3], sizeof(qtype));
 502 qtypelen = Ustrlen(qtype);
 503 for (p = qtype; *p != 0; p++) *p = toupper(*p);
 504
 505 /* Find the domain, lower case it, check that it is in a zone that we handle,
 506 and set up the zone file name. The zone names in the table all start with a
 507 dot. */
 508
 509 domlen = Ustrlen(argv[2]);
 510 if (argv[2][domlen-1] == '.') domlen--;
 511 Ustrncpy(domain, argv[2], domlen);
 512 domain[domlen] = 0;
 513 for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]);
 514
 515 if (Ustrchr(domain, '.') == NULL && qualify != NULL &&
 516     Ustrcmp(domain, "dontqualify") != 0)
 517   {
 518   Ustrcat(domain, qualify);
 519   domlen += Ustrlen(qualify);
 520   }
 521
 522 for (i = 0; i < zonecount; i++)
 523   {
 524   int zlen;
 525   zone = zones[i].zone;
 526   zlen = Ustrlen(zone);
 527   if (Ustrcmp(domain, zone+1) == 0 || (domlen >= zlen &&
 528       Ustrcmp(domain + domlen - zlen, zone) == 0))
 529     {
 530     zonefile = zones[i].zonefile;
 531     break;
 532     }
 533   }
 534
 535 if (zonefile == NULL)
 536   {
 537   fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain);
 538   return PASS_ON;
 539   }
 540
 541 (void)sprintf(buffer, "%s/../dnszones/%s", argv[1], zonefile);
 542
 543 /* Initialize the start of the response packet. We don't have to fake up
 544 everything, because we know that Exim will look only at the answer and
 545 additional section parts. */
 546
 547 memset(packet, 0, 12);
 548 pk += 12;
 549
 550 /* Open the zone file. */
 551
 552 f = fopen(buffer, "r");
 553 if (f == NULL)
 554   {
 555   fprintf(stderr, "fakens: failed to open %s: %s\n", buffer, strerror(errno));
 556   return NO_RECOVERY;
 557   }
 558
 559 /* Find the records we want, and add them to the result. */
 560
 561 count = 0;
 562 yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &adomain);
 563 if (yield == NO_RECOVERY) goto END_OFF;
 564
 565 packet[6] = (count >> 8) & 255;
 566 packet[7] = count & 255;
 567
 568 /* Search for additional records and add them to the result. */
 569
 570 count = 0;
 571 for (; adomain != NULL; adomain = adomain->next)
 572   {
 573   (void)find_records(f, zone, adomain->name, US"AAAA", 4, &pk, &count, NULL);
 574   (void)find_records(f, zone, adomain->name, US"A", 1, &pk, &count, NULL);
 575   }
 576
 577 packet[10] = (count >> 8) & 255;
 578 packet[11] = count & 255;
 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 /* End of fakens.c */