[exim.git] / test / src / fakens.c

/*************************************************
*       fakens - A Fake Nameserver Program       *
*************************************************/

/* This program exists to support the testing of DNS handling code in Exim. It
avoids the need to install special zones in a real nameserver. When Exim is
running in its (new) test harness, DNS lookups are first passed to this program
instead of to the real resolver. (With a few exceptions - see the discussion in
the test suite's README file.) The program is also passed the name of the Exim
spool directory; it expects to find its "zone files" in ../dnszones relative to
that directory. Note that there is little checking in this program. The fake
zone files are assumed to be syntactically valid.

The zones that are handled are found by scanning the dnszones directory. A file
whose name is of the form db.ip4.x is a zone file for .x.in-addr.arpa; a file
whose name is of the form db.ip6.x is a zone file for .x.ip6.arpa; a file of
the form db.anything.else is a zone file for .anything.else. A file of the form
qualify.x.y specifies the domain that is used to qualify single-component
names, except for the name "dontqualify".

The arguments to the program are:

  the name of the Exim spool directory
  the domain name that is being sought
  the DNS record type that is being sought

The output from the program is written to stdout. It is supposed to be in
exactly the same format as a traditional namserver response (see RFC 1035) so
that Exim can process it as normal. At present, no compression is used.
Error messages are written to stderr.

The return codes from the program are zero for success, and otherwise the
values that are set in h_errno after a failing call to the normal resolver:

  1 HOST_NOT_FOUND     host not found (authoritative)
  2 TRY_AGAIN          server failure
  3 NO_RECOVERY        non-recoverable error
  4 NO_DATA            valid name, no data of requested type

In a real nameserver, TRY_AGAIN is also used for a non-authoritative not found,
but it is not used for that here. There is also one extra return code:

  5 PASS_ON            requests Exim to call res_search()

This is used for zones that fakens does not recognize. It is also used if a
line in the zone file contains exactly this:

  PASS ON NOT FOUND

and the domain is not found. It converts the the result to PASS_ON instead of
HOST_NOT_FOUND.

Any DNS record line in a zone file can be prefixed with "DNSSEC" and
at least one space; if all the records found by a lookup are marked
as such then the response will have the "AD" bit set. */

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <netdb.h>
#include <errno.h>
#include <arpa/nameser.h>
#include <sys/types.h>
#include <dirent.h>

#define FALSE         0
#define TRUE          1
#define PASS_ON       5

typedef int BOOL;
typedef unsigned char uschar;

#define CS   (char *)
#define CCS  (const char *)
#define US   (unsigned char *)

#define Ustrcat(s,t)       strcat(CS(s),CCS(t))
#define Ustrchr(s,n)       US strchr(CCS(s),n)
#define Ustrcmp(s,t)       strcmp(CCS(s),CCS(t))
#define Ustrcpy(s,t)       strcpy(CS(s),CCS(t))
#define Ustrlen(s)         (int)strlen(CCS(s))
#define Ustrncmp(s,t,n)    strncmp(CCS(s),CCS(t),n)
#define Ustrncpy(s,t,n)    strncpy(CS(s),CCS(t),n)

typedef struct zoneitem {
  uschar *zone;
  uschar *zonefile;
} zoneitem;

typedef struct tlist {
  uschar *name;
  int value;
} tlist;

/* On some (older?) operating systems, the standard ns_t_xxx definitions are
not available, and only the older T_xxx ones exist in nameser.h. If ns_t_a is
not defined, assume we are in this state. A really old system might not even
know about AAAA and SRV at all. */

#ifndef ns_t_a
#define ns_t_a      T_A
#define ns_t_ns     T_NS
#define ns_t_cname  T_CNAME
#define ns_t_soa    T_SOA
#define ns_t_ptr    T_PTR
#define ns_t_mx     T_MX
#define ns_t_txt    T_TXT
#define ns_t_aaaa   T_AAAA
#define ns_t_srv    T_SRV
#ifndef T_AAAA
#define T_AAAA      28
#endif
#ifndef T_SRV
#define T_SRV       33
#endif
#endif

static tlist type_list[] = {
  { US"A",       ns_t_a },
  { US"NS",      ns_t_ns },
  { US"CNAME",   ns_t_cname },
/*  { US"SOA",     ns_t_soa },  Not currently in use */
  { US"PTR",     ns_t_ptr },
  { US"MX",      ns_t_mx },
  { US"TXT",     ns_t_txt },
  { US"AAAA",    ns_t_aaaa },
  { US"SRV",     ns_t_srv },
  { NULL,        0 }
};


/*************************************************
*           Get memory and sprintf into it       *
*************************************************/

/* This is used when building a table of zones and their files.

Arguments:
  format       a format string
  ...          arguments

Returns:       pointer to formatted string
*/

static uschar *
fcopystring(uschar *format, ...)
{
uschar *yield;
char buffer[256];
va_list ap;
va_start(ap, format);
vsprintf(buffer, format, ap);
va_end(ap);
yield = (uschar *)malloc(Ustrlen(buffer) + 1);
Ustrcpy(yield, buffer);
return yield;
}


/*************************************************
*             Pack name into memory              *
*************************************************/

/* This function packs a domain name into memory according to DNS rules. At
present, it doesn't do any compression.

Arguments:
  name         the name
  pk           where to put it

Returns:       the updated value of pk
*/

static uschar *
packname(uschar *name, uschar *pk)
{
while (*name != 0)
  {
  uschar *p = name;
  while (*p != 0 && *p != '.') p++;
  *pk++ = (p - name);
  memmove(pk, name, p - name);
  pk += p - name;
  name = (*p == 0)? p : p + 1;
  }
*pk++ = 0;
return pk;
}


/*************************************************
*              Scan file for RRs                 *
*************************************************/

/* This function scans an open "zone file" for appropriate records, and adds
any that are found to the output buffer.

Arguments:
  f           the input FILE
  zone        the current zone name
  domain      the domain we are looking for
  qtype       the type of RR we want
  qtypelen    the length of qtype
  pkptr       points to the output buffer pointer; this is updated
  countptr    points to the record count; this is updated

Returns:      0 on success, else HOST_NOT_FOUND or NO_DATA or NO_RECOVERY or
              PASS_ON - the latter if a "PASS ON NOT FOUND" line is seen
*/

static int
find_records(FILE *f, uschar *zone, uschar *domain, uschar *qtype,
  int qtypelen, uschar **pkptr, int *countptr, BOOL * dnssec)
{
int yield = HOST_NOT_FOUND;
int domainlen = Ustrlen(domain);
BOOL pass_on_not_found = FALSE;
tlist *typeptr;
uschar *pk = *pkptr;
uschar buffer[256];
uschar rrdomain[256];
uschar RRdomain[256];

/* Decode the required type */

for (typeptr = type_list; typeptr->name != NULL; typeptr++)
  { if (Ustrcmp(typeptr->name, qtype) == 0) break; }
if (typeptr->name == NULL)
  {
  fprintf(stderr, "fakens: unknown record type %s\n", qtype);
  return NO_RECOVERY;
  }

rrdomain[0] = 0;                 /* No previous domain */
(void)fseek(f, 0, SEEK_SET);     /* Start again at the beginning */

*dnssec = TRUE;			/* cancelled by first nonsecure rec found */

/* Scan for RRs */

while (fgets(CS buffer, sizeof(buffer), f) != NULL)
  {
  uschar *rdlptr;
  uschar *p, *ep, *pp;
  BOOL found_cname = FALSE;
  int i, plen, value;
  int tvalue = typeptr->value;
  int qtlen = qtypelen;
  BOOL rr_sec = FALSE;

  p = buffer;
  while (isspace(*p)) p++;
  if (*p == 0 || *p == ';') continue;

  if (Ustrncmp(p, US"PASS ON NOT FOUND", 17) == 0)
    {
    pass_on_not_found = TRUE;
    continue;
    }

  ep = buffer + Ustrlen(buffer);
  while (isspace(ep[-1])) ep--;
  *ep = 0;

  p = buffer;
  if (Ustrncmp(p, US"DNSSEC ", 7) == 0)	/* tagged as secure */
    {
    rr_sec = TRUE;
    p += 7;
    }

  if (!isspace(*p))
    {
    uschar *pp = rrdomain;
    uschar *PP = RRdomain;
    while (!isspace(*p))
      {
      *pp++ = tolower(*p);
      *PP++ = *p++;
      }
    if (pp[-1] != '.')
      {
      Ustrcpy(pp, zone);
      Ustrcpy(PP, zone);
      }
    else
      {
      pp[-1] = 0;
      PP[-1] = 0;
      }
    }

  /* Compare domain names; first check for a wildcard */

  if (rrdomain[0] == '*')
    {
    int restlen = Ustrlen(rrdomain) - 1;
    if (domainlen > restlen &&
        Ustrcmp(domain + domainlen - restlen, rrdomain + 1) != 0) continue;
    }

  /* Not a wildcard RR */

  else if (Ustrcmp(domain, rrdomain) != 0) continue;

  /* The domain matches */

  if (yield == HOST_NOT_FOUND) yield = NO_DATA;

  /* Compare RR types; a CNAME record is always returned */

  while (isspace(*p)) p++;

  if (Ustrncmp(p, "CNAME", 5) == 0)
    {
    tvalue = ns_t_cname;
    qtlen = 5;
    found_cname = TRUE;
    }
  else if (Ustrncmp(p, qtype, qtypelen) != 0 || !isspace(p[qtypelen])) continue;

  /* Found a relevant record */

  if (!rr_sec)
    *dnssec = FALSE;			/* cancel AD return */

  yield = 0;
  *countptr = *countptr + 1;

  p += qtlen;
  while (isspace(*p)) p++;

  /* For a wildcard record, use the search name; otherwise use the record's
  name in its original case because it might contain upper case letters. */

  pk = packname((rrdomain[0] == '*')? domain : RRdomain, pk);
  *pk++ = (tvalue >> 8) & 255;
  *pk++ = (tvalue) & 255;
  *pk++ = 0;
  *pk++ = 1;     /* class = IN */

  pk += 4;       /* TTL field; don't care */

  rdlptr = pk;   /* remember rdlength field */
  pk += 2;

  /* The rest of the data depends on the type */

  switch (tvalue)
    {
    case ns_t_soa:  /* Not currently used */
    break;

    case ns_t_a:
    for (i = 0; i < 4; i++)
      {
      value = 0;
      while (isdigit(*p)) value = value*10 + *p++ - '0';
      *pk++ = value;
      p++;
      }
    break;

    /* The only occurrence of a double colon is for ::1 */
    case ns_t_aaaa:
    if (Ustrcmp(p, "::1") == 0)
      {
      memset(pk, 0, 15);
      pk += 15;
      *pk++ = 1;
      }
    else for (i = 0; i < 8; i++)
      {
      value = 0;
      while (isxdigit(*p))
        {
        value = value * 16 + toupper(*p) - (isdigit(*p)? '0' : '7');
        p++;
        }
      *pk++ = (value >> 8) & 255;
      *pk++ = value & 255;
      p++;
      }
    break;

    case ns_t_mx:
    value = 0;
    while (isdigit(*p)) value = value*10 + *p++ - '0';
    while (isspace(*p)) p++;
    *pk++ = (value >> 8) & 255;
    *pk++ = value & 255;
    if (ep[-1] != '.') sprintf(ep, "%s.", zone);
    pk = packname(p, pk);
    plen = Ustrlen(p);
    break;

    case ns_t_txt:
    pp = pk++;
    if (*p == '"') p++;   /* Should always be the case */
    while (*p != 0 && *p != '"') *pk++ = *p++;
    *pp = pk - pp - 1;
    break;

    case ns_t_srv:
    for (i = 0; i < 3; i++)
      {
      value = 0;
      while (isdigit(*p)) value = value*10 + *p++ - '0';
      while (isspace(*p)) p++;
      *pk++ = (value >> 8) & 255;
      *pk++ = value & 255;
      }

    /* Fall through */

    case ns_t_cname:
    case ns_t_ns:
    case ns_t_ptr:
    if (ep[-1] != '.') sprintf(ep, "%s.", zone);
    pk = packname(p, pk);
    plen = Ustrlen(p);
    break;
    }

  /* Fill in the length, and we are done with this RR */

  rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255;
  rdlptr[1] = (pk -rdlptr - 2) & 255;
  }

*pkptr = pk;
return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield;
}


/*************************************************
*           Entry point and main program         *
*************************************************/

int
main(int argc, char **argv)
{
FILE *f;
DIR *d;
int domlen, qtypelen;
int yield, count;
int i;
int zonecount = 0;
struct dirent *de;
zoneitem zones[32];
uschar *qualify = NULL;
uschar *p, *zone;
uschar *zonefile = NULL;
uschar domain[256];
uschar buffer[256];
uschar qtype[12];
uschar packet[512];
uschar *pk = packet;
BOOL dnssec;

if (argc != 4)
  {
  fprintf(stderr, "fakens: expected 3 arguments, received %d\n", argc-1);
  return NO_RECOVERY;
  }

/* Find the zones */

(void)sprintf(buffer, "%s/../dnszones", argv[1]);

d = opendir(CCS buffer);
if (d == NULL)
  {
  fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer,
    strerror(errno));
  return NO_RECOVERY;
  }

while ((de = readdir(d)) != NULL)
  {
  uschar *name = de->d_name;
  if (Ustrncmp(name, "qualify.", 8) == 0)
    {
    qualify = fcopystring("%s", name + 7);
    continue;
    }
  if (Ustrncmp(name, "db.", 3) != 0) continue;
  if (Ustrncmp(name + 3, "ip4.", 4) == 0)
    zones[zonecount].zone = fcopystring("%s.in-addr.arpa", name + 6);
  else if (Ustrncmp(name + 3, "ip6.", 4) == 0)
    zones[zonecount].zone = fcopystring("%s.ip6.arpa", name + 6);
  else
    zones[zonecount].zone = fcopystring("%s", name + 2);
  zones[zonecount++].zonefile = fcopystring("%s", name);
  }
(void)closedir(d);

/* Get the RR type and upper case it, and check that we recognize it. */

Ustrncpy(qtype, argv[3], sizeof(qtype));
qtypelen = Ustrlen(qtype);
for (p = qtype; *p != 0; p++) *p = toupper(*p);

/* Find the domain, lower case it, check that it is in a zone that we handle,
and set up the zone file name. The zone names in the table all start with a
dot. */

domlen = Ustrlen(argv[2]);
if (argv[2][domlen-1] == '.') domlen--;
Ustrncpy(domain, argv[2], domlen);
domain[domlen] = 0;
for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]);

if (Ustrchr(domain, '.') == NULL && qualify != NULL &&
    Ustrcmp(domain, "dontqualify") != 0)
  {
  Ustrcat(domain, qualify);
  domlen += Ustrlen(qualify);
  }

for (i = 0; i < zonecount; i++)
  {
  int zlen;
  zone = zones[i].zone;
  zlen = Ustrlen(zone);
  if (Ustrcmp(domain, zone+1) == 0 || (domlen >= zlen &&
      Ustrcmp(domain + domlen - zlen, zone) == 0))
    {
    zonefile = zones[i].zonefile;
    break;
    }
  }

if (zonefile == NULL)
  {
  fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain);
  return PASS_ON;
  }

(void)sprintf(buffer, "%s/../dnszones/%s", argv[1], zonefile);

/* Initialize the start of the response packet. We don't have to fake up
everything, because we know that Exim will look only at the answer and
additional section parts. */

memset(packet, 0, 12);
pk += 12;

/* Open the zone file. */

f = fopen(buffer, "r");
if (f == NULL)
  {
  fprintf(stderr, "fakens: failed to open %s: %s\n", buffer, strerror(errno));
  return NO_RECOVERY;
  }

/* Find the records we want, and add them to the result. */

count = 0;
yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &dnssec);
if (yield == NO_RECOVERY) goto END_OFF;

packet[6] = (count >> 8) & 255;
packet[7] = count & 255;

/* There is no need to return any additional records because Exim no longer
(from release 4.61) makes any use of them. */

packet[10] = 0;
packet[11] = 0;

if (dnssec)
  ((HEADER *)packet)->ad = 1;

/* Close the zone file, write the result, and return. */

END_OFF:
(void)fclose(f);
(void)fwrite(packet, 1, pk - packet, stdout);
return yield;
}

/* vi: aw ai sw=2
*/
/* End of fakens.c */
Commit	Line	Data
c55a77db PH	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
4d4c2a9b JH	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. */
c55a77db PH	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
c55a77db PH	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
c55a77db PH	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,
4d4c2a9b	216	int qtypelen, uschar *pkptr, int countptr, BOOL * dnssec)
c55a77db PH	217	{
c55a77db PH	218	int yield = HOST_NOT_FOUND;
c55a77db PH	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];
75e0e026	225	uschar RRdomain[256];
c55a77db PH	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
4d4c2a9b JH	240	dnssec = TRUE; / cancelled by first nonsecure rec found */
4d4c2a9b JH	241
c55a77db PH	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;
4d4c2a9b	252	BOOL rr_sec = FALSE;
c55a77db PH	253
	254	p = buffer;
	255	while (isspace(*p)) p++;
	256	if (p == 0 \|\| p == ';') continue;
	257
4d4c2a9b	258	if (Ustrncmp(p, US"PASS ON NOT FOUND", 17) == 0)
c55a77db PH	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;
4d4c2a9b JH	269	if (Ustrncmp(p, US"DNSSEC ", 7) == 0) /* tagged as secure */
	270	{
	271	rr_sec = TRUE;
	272	p += 7;
	273	}
	274
c55a77db PH	275	if (!isspace(*p))
	276	{
	277	uschar *pp = rrdomain;
75e0e026 PH	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	}
c55a77db PH	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
4d4c2a9b JH	327	if (!rr_sec)
	328	dnssec = FALSE; / cancel AD return */
	329
c55a77db PH	330	yield = 0;
	331	countptr = countptr + 1;
	332
	333	p += qtlen;
	334	while (isspace(*p)) p++;
	335
75e0e026 PH	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);
c55a77db PH	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 = value10 + *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 = value10 + *p++ - '0';
	392	while (isspace(*p)) p++;
	393	*pk++ = (value >> 8) & 255;
	394	*pk++ = value & 255;
75e0e026 PH	395	if (ep[-1] != '.') sprintf(ep, "%s.", zone);
	396	pk = packname(p, pk);
	397	plen = Ustrlen(p);
	398	break;
c55a77db PH	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 = value10 + *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:
c55a77db PH	422	if (ep[-1] != '.') sprintf(ep, "%s.", zone);
	423	pk = packname(p, pk);
	424	plen = Ustrlen(p);
c55a77db PH	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;
c55a77db PH	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;
75e0e026	449	int domlen, qtypelen;
c55a77db PH	450	int yield, count;
	451	int i;
	452	int zonecount = 0;
c55a77db	453	struct dirent *de;
c55a77db PH	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;
4d4c2a9b	463	BOOL dnssec;
c55a77db PH	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;
4d4c2a9b	565	yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &dnssec);
c55a77db PH	566	if (yield == NO_RECOVERY) goto END_OFF;
	567
	568	packet[6] = (count >> 8) & 255;
	569	packet[7] = count & 255;
	570
75e0e026 PH	571	/* There is no need to return any additional records because Exim no longer
75e0e026 PH	572	(from release 4.61) makes any use of them. */
c55a77db	573
75e0e026 PH	574	packet[10] = 0;
75e0e026 PH	575	packet[11] = 0;
c55a77db	576
4d4c2a9b JH	577	if (dnssec)
	578	((HEADER *)packet)->ad = 1;
	579
c55a77db PH	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
4d4c2a9b JH	588	/* vi: aw ai sw=2
4d4c2a9b JH	589	*/
c55a77db	590	/* End of fakens.c */