[hcoop/zz_old/debian/djbdns.git] / axfrdns.c

#include <unistd.h>
#include "droproot.h"
#include "exit.h"
#include "env.h"
#include "uint32.h"
#include "uint16.h"
#include "ip4.h"
#include "tai.h"
#include "buffer.h"
#include "timeoutread.h"
#include "timeoutwrite.h"
#include "open.h"
#include "seek.h"
#include "cdb.h"
#include "stralloc.h"
#include "strerr.h"
#include "str.h"
#include "byte.h"
#include "case.h"
#include "dns.h"
#include "scan.h"
#include "qlog.h"
#include "response.h"

extern int respond(char *,char *,char *);

#define FATAL "axfrdns: fatal: "

void nomem()
{
  strerr_die2x(111,FATAL,"out of memory");
}
void die_truncated()
{
  strerr_die2x(111,FATAL,"truncated request");
}
void die_netwrite()
{
  strerr_die2sys(111,FATAL,"unable to write to network: ");
}
void die_netread()
{
  strerr_die2sys(111,FATAL,"unable to read from network: ");
}
void die_outside()
{
  strerr_die2x(111,FATAL,"unable to locate information in data.cdb");
}
void die_cdbread()
{
  strerr_die2sys(111,FATAL,"unable to read data.cdb: ");
}
void die_cdbformat()
{
  strerr_die3x(111,FATAL,"unable to read data.cdb: ","format error");
}

int safewrite(int fd,char *buf,unsigned int len)
{
  int w;

  w = timeoutwrite(60,fd,buf,len);
  if (w <= 0) die_netwrite();
  return w;
}

char netwritespace[1024];
buffer netwrite = BUFFER_INIT(safewrite,1,netwritespace,sizeof netwritespace);

void print(char *buf,unsigned int len)
{
  char tcpheader[2];
  uint16_pack_big(tcpheader,len);
  buffer_put(&netwrite,tcpheader,2);
  buffer_put(&netwrite,buf,len);
  buffer_flush(&netwrite);
}

char *axfr;
static char *axfrok;

void axfrcheck(char *q)
{
  int i;
  int j;

  if (!axfr) return;

  i = j = 0;
  for (;;) {
    if (!axfr[i] || (axfr[i] == '/')) {
      if (i > j) {
        if (!dns_domain_fromdot(&axfrok,axfr + j,i - j)) nomem();
        if (dns_domain_equal(q,axfrok)) return;
      }
      j = i + 1;
    }
    if (!axfr[i]) break;
    ++i;
  }

  strerr_die2x(111,FATAL,"disallowed zone transfer request");
}

static char *zone;
unsigned int zonelen;
char typeclass[4];

int fdcdb;
buffer bcdb;
char bcdbspace[1024];

void get(char *buf,unsigned int len)
{
  int r;

  while (len > 0) {
    r = buffer_get(&bcdb,buf,len);
    if (r < 0) die_cdbread();
    if (!r) die_cdbformat();
    buf += r;
    len -= r;
  }
}

char ip[4];
unsigned long port;
char clientloc[2];

struct tai now;
char data[32767];
uint32 dlen;
uint32 dpos;

void copy(char *buf,unsigned int len)
{
  dpos = dns_packet_copy(data,dlen,dpos,buf,len);
  if (!dpos) die_cdbread();
}

void doname(stralloc *sa)
{
  static char *d;
  dpos = dns_packet_getname(data,dlen,dpos,&d);
  if (!dpos) die_cdbread();
  if (!stralloc_catb(sa,d,dns_domain_length(d))) nomem();
}

int build(stralloc *sa,char *q,int flagsoa,char id[2])
{
  unsigned int rdatapos;
  char misc[20];
  char type[2];
  char recordloc[2];
  char ttl[4];
  char ttd[8];
  struct tai cutoff;

  dpos = 0;
  copy(type,2);
  if (flagsoa) if (byte_diff(type,2,DNS_T_SOA)) return 0;
  if (!flagsoa) if (byte_equal(type,2,DNS_T_SOA)) return 0;

  if (!stralloc_copyb(sa,id,2)) nomem();
  if (!stralloc_catb(sa,"\204\000\0\0\0\1\0\0\0\0",10)) nomem();
  copy(misc,1);
  if ((misc[0] == '=' + 1) || (misc[0] == '*' + 1)) {
    --misc[0];
    copy(recordloc,2);
    if (byte_diff(recordloc,2,clientloc)) return 0;
  }
  if (misc[0] == '*') {
    if (flagsoa) return 0;
    if (!stralloc_catb(sa,"\1*",2)) nomem();
  }
  if (!stralloc_catb(sa,q,dns_domain_length(q))) nomem();
  if (!stralloc_catb(sa,type,2)) nomem();

  copy(ttl,4);
  copy(ttd,8);
  if (byte_diff(ttd,8,"\0\0\0\0\0\0\0\0")) {
    tai_unpack(ttd,&cutoff);
    if (byte_equal(ttl,4,"\0\0\0\0")) {
      if (tai_less(&cutoff,&now)) return 0;
      uint32_pack_big(ttl,2);
    }
    else
      if (!tai_less(&cutoff,&now)) return 0;
  }

  if (!stralloc_catb(sa,DNS_C_IN,2)) nomem();
  if (!stralloc_catb(sa,ttl,4)) nomem();
  if (!stralloc_catb(sa,"\0\0",2)) nomem();
  rdatapos = sa->len;

  if (byte_equal(type,2,DNS_T_SOA)) {
    doname(sa);
    doname(sa);
    copy(misc,20);
    if (!stralloc_catb(sa,misc,20)) nomem();
  }
  else if (byte_equal(type,2,DNS_T_NS) || byte_equal(type,2,DNS_T_PTR) || byte_equal(type,2,DNS_T_CNAME)) {
    doname(sa);
  }
  else if (byte_equal(type,2,DNS_T_MX)) {
    copy(misc,2);
    if (!stralloc_catb(sa,misc,2)) nomem();
    doname(sa);
  }
  else
    if (!stralloc_catb(sa,data + dpos,dlen - dpos)) nomem();

  if (sa->len > 65535) die_cdbformat();
  uint16_pack_big(sa->s + rdatapos - 2,sa->len - rdatapos);
  return 1;
}

static struct cdb c;
static char *q;
static stralloc soa;
static stralloc message;

void doaxfr(char id[2])
{
  char key[512];
  uint32 klen;
  char num[4];
  uint32 eod;
  uint32 pos;
  int r;

  axfrcheck(zone);

  tai_now(&now);
  cdb_init(&c,fdcdb);

  byte_zero(clientloc,2);
  key[0] = 0;
  key[1] = '%';
  byte_copy(key + 2,4,ip);
  r = cdb_find(&c,key,6);
  if (!r) r = cdb_find(&c,key,5);
  if (!r) r = cdb_find(&c,key,4);
  if (!r) r = cdb_find(&c,key,3);
  if (!r) r = cdb_find(&c,key,2);
  if (r == -1) die_cdbread();
  if (r && (cdb_datalen(&c) == 2))
    if (cdb_read(&c,clientloc,2,cdb_datapos(&c)) == -1) die_cdbread();

  cdb_findstart(&c);
  for (;;) {
    r = cdb_findnext(&c,zone,zonelen);
    if (r == -1) die_cdbread();
    if (!r) die_outside();
    dlen = cdb_datalen(&c);
    if (dlen > sizeof data) die_cdbformat();
    if (cdb_read(&c,data,dlen,cdb_datapos(&c)) == -1) die_cdbformat();
    if (build(&soa,zone,1,id)) break;
  }

  cdb_free(&c);
  print(soa.s,soa.len);

  seek_begin(fdcdb);
  buffer_init(&bcdb,buffer_unixread,fdcdb,bcdbspace,sizeof bcdbspace);

  pos = 0;
  get(num,4); pos += 4;
  uint32_unpack(num,&eod);
  while (pos < 2048) { get(num,4); pos += 4; }

  while (pos < eod) {
    if (eod - pos < 8) die_cdbformat();
    get(num,4); pos += 4;
    uint32_unpack(num,&klen);
    get(num,4); pos += 4;
    uint32_unpack(num,&dlen);
    if (eod - pos < klen) die_cdbformat();
    pos += klen;
    if (eod - pos < dlen) die_cdbformat();
    pos += dlen;

    if (klen > sizeof key) die_cdbformat();
    get(key,klen);
    if (dlen > sizeof data) die_cdbformat();
    get(data,dlen);

    if ((klen > 1) && (key[0] == 0)) continue; /* location */
    if (klen < 1) die_cdbformat();
    if (dns_packet_getname(key,klen,0,&q) != klen) die_cdbformat();
    if (!dns_domain_suffix(q,zone)) continue;
    if (!build(&message,q,0,id)) continue;
    print(message.s,message.len);
  }

  print(soa.s,soa.len);
}

void netread(char *buf,unsigned int len)
{
  int r;

  while (len > 0) {
    r = timeoutread(60,0,buf,len);
    if (r == 0) _exit(0);
    if (r < 0) die_netread();
    buf += r; len -= r;
  }
}

char tcpheader[2];
char buf[512];
uint16 len;

static char seed[128];

int main()
{
  unsigned int pos;
  char header[12];
  char qtype[2];
  char qclass[2];
  const char *x;

  droproot(FATAL);
  dns_random_init(seed);

  axfr = env_get("AXFR");
  
  x = env_get("TCPREMOTEIP");
  if (x && ip4_scan(x,ip))
    ;
  else
    byte_zero(ip,4);

  x = env_get("TCPREMOTEPORT");
  if (!x) x = "0";
  scan_ulong(x,&port);

  for (;;) {
    netread(tcpheader,2);
    uint16_unpack_big(tcpheader,&len);
    if (len > 512) strerr_die2x(111,FATAL,"excessively large request");
    netread(buf,len);

    pos = dns_packet_copy(buf,len,0,header,12); if (!pos) die_truncated();
    if (header[2] & 254) strerr_die2x(111,FATAL,"bogus query");
    if (header[4] || (header[5] != 1)) strerr_die2x(111,FATAL,"bogus query");

    pos = dns_packet_getname(buf,len,pos,&zone); if (!pos) die_truncated();
    zonelen = dns_domain_length(zone);
    pos = dns_packet_copy(buf,len,pos,qtype,2); if (!pos) die_truncated();
    pos = dns_packet_copy(buf,len,pos,qclass,2); if (!pos) die_truncated();

    if (byte_diff(qclass,2,DNS_C_IN) && byte_diff(qclass,2,DNS_C_ANY))
      strerr_die2x(111,FATAL,"bogus query: bad class");

    qlog(ip,port,header,zone,qtype," ");

    if (byte_equal(qtype,2,DNS_T_AXFR)) {
      case_lowerb(zone,zonelen);
      fdcdb = open_read("data.cdb");
      if (fdcdb == -1) die_cdbread();
      doaxfr(header);
      close(fdcdb);
    }
    else {
      if (!response_query(zone,qtype,qclass)) nomem();
      response[2] |= 4;
      case_lowerb(zone,zonelen);
      response_id(header);
      response[3] &= ~128;
      if (!(header[2] & 1)) response[2] &= ~1;
      if (!respond(zone,qtype,ip)) die_outside();
      print(response,response_len);
    }
  }
}
Commit	Line	Data
dc0d77d7 CE	1	#include <unistd.h>
	2	#include "droproot.h"
	3	#include "exit.h"
	4	#include "env.h"
	5	#include "uint32.h"
	6	#include "uint16.h"
	7	#include "ip4.h"
	8	#include "tai.h"
	9	#include "buffer.h"
	10	#include "timeoutread.h"
	11	#include "timeoutwrite.h"
	12	#include "open.h"
	13	#include "seek.h"
	14	#include "cdb.h"
	15	#include "stralloc.h"
	16	#include "strerr.h"
	17	#include "str.h"
	18	#include "byte.h"
	19	#include "case.h"
	20	#include "dns.h"
	21	#include "scan.h"
	22	#include "qlog.h"
	23	#include "response.h"
	24
	25	extern int respond(char ,char ,char *);
	26
	27	#define FATAL "axfrdns: fatal: "
	28
	29	void nomem()
	30	{
	31	strerr_die2x(111,FATAL,"out of memory");
	32	}
	33	void die_truncated()
	34	{
	35	strerr_die2x(111,FATAL,"truncated request");
	36	}
	37	void die_netwrite()
	38	{
	39	strerr_die2sys(111,FATAL,"unable to write to network: ");
	40	}
	41	void die_netread()
	42	{
	43	strerr_die2sys(111,FATAL,"unable to read from network: ");
	44	}
	45	void die_outside()
	46	{
	47	strerr_die2x(111,FATAL,"unable to locate information in data.cdb");
	48	}
	49	void die_cdbread()
	50	{
	51	strerr_die2sys(111,FATAL,"unable to read data.cdb: ");
	52	}
	53	void die_cdbformat()
	54	{
	55	strerr_die3x(111,FATAL,"unable to read data.cdb: ","format error");
	56	}
	57
	58	int safewrite(int fd,char *buf,unsigned int len)
	59	{
	60	int w;
	61
	62	w = timeoutwrite(60,fd,buf,len);
	63	if (w <= 0) die_netwrite();
	64	return w;
65	}
66
67	char netwritespace[1024];
68	buffer netwrite = BUFFER_INIT(safewrite,1,netwritespace,sizeof netwritespace);
69
70	void print(char *buf,unsigned int len)
71	{
72	char tcpheader[2];
73	uint16_pack_big(tcpheader,len);
74	buffer_put(&netwrite,tcpheader,2);
75	buffer_put(&netwrite,buf,len);
76	buffer_flush(&netwrite);
77	}
78
79	char *axfr;
80	static char *axfrok;
81
82	void axfrcheck(char *q)
83	{
84	int i;
85	int j;
86
87	if (!axfr) return;
88
89	i = j = 0;
90	for (;;) {
91	if (!axfr[i] \|\| (axfr[i] == '/')) {
92	if (i > j) {
93	if (!dns_domain_fromdot(&axfrok,axfr + j,i - j)) nomem();
94	if (dns_domain_equal(q,axfrok)) return;
95	}
96	j = i + 1;
97	}
98	if (!axfr[i]) break;
99	++i;
100	}
101
102	strerr_die2x(111,FATAL,"disallowed zone transfer request");
103	}
104
105	static char *zone;
106	unsigned int zonelen;
107	char typeclass[4];
108
109	int fdcdb;
110	buffer bcdb;
111	char bcdbspace[1024];
112
113	void get(char *buf,unsigned int len)
114	{
115	int r;
116
117	while (len > 0) {
118	r = buffer_get(&bcdb,buf,len);
119	if (r < 0) die_cdbread();
120	if (!r) die_cdbformat();
121	buf += r;
122	len -= r;
123	}
124	}
125
126	char ip[4];
127	unsigned long port;
128	char clientloc[2];
129
130	struct tai now;
131	char data[32767];
132	uint32 dlen;
133	uint32 dpos;
134
135	void copy(char *buf,unsigned int len)
136	{
137	dpos = dns_packet_copy(data,dlen,dpos,buf,len);
138	if (!dpos) die_cdbread();
139	}
140
141	void doname(stralloc *sa)
142	{
143	static char *d;
144	dpos = dns_packet_getname(data,dlen,dpos,&d);
145	if (!dpos) die_cdbread();
146	if (!stralloc_catb(sa,d,dns_domain_length(d))) nomem();
147	}
148
149	int build(stralloc sa,char q,int flagsoa,char id[2])
150	{
151	unsigned int rdatapos;
152	char misc[20];
153	char type[2];
154	char recordloc[2];
155	char ttl[4];
156	char ttd[8];
157	struct tai cutoff;
158
159	dpos = 0;
160	copy(type,2);
161	if (flagsoa) if (byte_diff(type,2,DNS_T_SOA)) return 0;
162	if (!flagsoa) if (byte_equal(type,2,DNS_T_SOA)) return 0;
163
164	if (!stralloc_copyb(sa,id,2)) nomem();
165	if (!stralloc_catb(sa,"\204\000\0\0\0\1\0\0\0\0",10)) nomem();
166	copy(misc,1);
167	if ((misc[0] == '=' + 1) \|\| (misc[0] == '*' + 1)) {
168	--misc[0];
169	copy(recordloc,2);
170	if (byte_diff(recordloc,2,clientloc)) return 0;
171	}
172	if (misc[0] == '*') {
173	if (flagsoa) return 0;
174	if (!stralloc_catb(sa,"\1*",2)) nomem();
175	}
176	if (!stralloc_catb(sa,q,dns_domain_length(q))) nomem();
177	if (!stralloc_catb(sa,type,2)) nomem();
178
179	copy(ttl,4);
180	copy(ttd,8);
181	if (byte_diff(ttd,8,"\0\0\0\0\0\0\0\0")) {
182	tai_unpack(ttd,&cutoff);
183	if (byte_equal(ttl,4,"\0\0\0\0")) {
184	if (tai_less(&cutoff,&now)) return 0;
185	uint32_pack_big(ttl,2);
186	}
187	else
188	if (!tai_less(&cutoff,&now)) return 0;
189	}
190
191	if (!stralloc_catb(sa,DNS_C_IN,2)) nomem();
192	if (!stralloc_catb(sa,ttl,4)) nomem();
193	if (!stralloc_catb(sa,"\0\0",2)) nomem();
194	rdatapos = sa->len;
195
196	if (byte_equal(type,2,DNS_T_SOA)) {
197	doname(sa);
198	doname(sa);
199	copy(misc,20);
200	if (!stralloc_catb(sa,misc,20)) nomem();
201	}
202	else if (byte_equal(type,2,DNS_T_NS) \|\| byte_equal(type,2,DNS_T_PTR) \|\| byte_equal(type,2,DNS_T_CNAME)) {
203	doname(sa);
204	}
205	else if (byte_equal(type,2,DNS_T_MX)) {
206	copy(misc,2);
207	if (!stralloc_catb(sa,misc,2)) nomem();
208	doname(sa);
209	}
210	else
211	if (!stralloc_catb(sa,data + dpos,dlen - dpos)) nomem();
212
213	if (sa->len > 65535) die_cdbformat();
214	uint16_pack_big(sa->s + rdatapos - 2,sa->len - rdatapos);
215	return 1;
216	}
217
218	static struct cdb c;
219	static char *q;
220	static stralloc soa;
221	static stralloc message;
222
223	void doaxfr(char id[2])
224	{
225	char key[512];
226	uint32 klen;
227	char num[4];
228	uint32 eod;
229	uint32 pos;
230	int r;
231
232	axfrcheck(zone);
233
234	tai_now(&now);
235	cdb_init(&c,fdcdb);
236
237	byte_zero(clientloc,2);
238	key[0] = 0;
239	key[1] = '%';
240	byte_copy(key + 2,4,ip);
241	r = cdb_find(&c,key,6);
242	if (!r) r = cdb_find(&c,key,5);
243	if (!r) r = cdb_find(&c,key,4);
244	if (!r) r = cdb_find(&c,key,3);
245	if (!r) r = cdb_find(&c,key,2);
246	if (r == -1) die_cdbread();
247	if (r && (cdb_datalen(&c) == 2))
248	if (cdb_read(&c,clientloc,2,cdb_datapos(&c)) == -1) die_cdbread();
249
250	cdb_findstart(&c);
251	for (;;) {
252	r = cdb_findnext(&c,zone,zonelen);
253	if (r == -1) die_cdbread();
254	if (!r) die_outside();
255	dlen = cdb_datalen(&c);
256	if (dlen > sizeof data) die_cdbformat();
257	if (cdb_read(&c,data,dlen,cdb_datapos(&c)) == -1) die_cdbformat();
258	if (build(&soa,zone,1,id)) break;
259	}
260
261	cdb_free(&c);
262	print(soa.s,soa.len);
263
264	seek_begin(fdcdb);
265	buffer_init(&bcdb,buffer_unixread,fdcdb,bcdbspace,sizeof bcdbspace);
266
267	pos = 0;
268	get(num,4); pos += 4;
269	uint32_unpack(num,&eod);
270	while (pos < 2048) { get(num,4); pos += 4; }
271
272	while (pos < eod) {
273	if (eod - pos < 8) die_cdbformat();
274	get(num,4); pos += 4;
275	uint32_unpack(num,&klen);
276	get(num,4); pos += 4;
277	uint32_unpack(num,&dlen);
278	if (eod - pos < klen) die_cdbformat();
279	pos += klen;
280	if (eod - pos < dlen) die_cdbformat();
281	pos += dlen;
282
283	if (klen > sizeof key) die_cdbformat();
284	get(key,klen);
285	if (dlen > sizeof data) die_cdbformat();
286	get(data,dlen);
287
288	if ((klen > 1) && (key[0] == 0)) continue; /* location */
289	if (klen < 1) die_cdbformat();
290	if (dns_packet_getname(key,klen,0,&q) != klen) die_cdbformat();
291	if (!dns_domain_suffix(q,zone)) continue;
292	if (!build(&message,q,0,id)) continue;
293	print(message.s,message.len);
294	}
295
296	print(soa.s,soa.len);
297	}
298
299	void netread(char *buf,unsigned int len)
300	{
301	int r;
302
303	while (len > 0) {
304	r = timeoutread(60,0,buf,len);
305	if (r == 0) _exit(0);
306	if (r < 0) die_netread();
307	buf += r; len -= r;
308	}
309	}
310
311	char tcpheader[2];
312	char buf[512];
313	uint16 len;
314
315	static char seed[128];
316
317	int main()
318	{
319	unsigned int pos;
320	char header[12];
321	char qtype[2];
322	char qclass[2];
323	const char *x;
324
325	droproot(FATAL);
326	dns_random_init(seed);
327
328	axfr = env_get("AXFR");
329
330	x = env_get("TCPREMOTEIP");
331	if (x && ip4_scan(x,ip))
332	;
333	else
334	byte_zero(ip,4);
335
336	x = env_get("TCPREMOTEPORT");
337	if (!x) x = "0";
338	scan_ulong(x,&port);
339
340	for (;;) {
341	netread(tcpheader,2);
342	uint16_unpack_big(tcpheader,&len);
343	if (len > 512) strerr_die2x(111,FATAL,"excessively large request");
344	netread(buf,len);
345
346	pos = dns_packet_copy(buf,len,0,header,12); if (!pos) die_truncated();
347	if (header[2] & 254) strerr_die2x(111,FATAL,"bogus query");
348	if (header[4] \|\| (header[5] != 1)) strerr_die2x(111,FATAL,"bogus query");
349
350	pos = dns_packet_getname(buf,len,pos,&zone); if (!pos) die_truncated();
351	zonelen = dns_domain_length(zone);
352	pos = dns_packet_copy(buf,len,pos,qtype,2); if (!pos) die_truncated();
353	pos = dns_packet_copy(buf,len,pos,qclass,2); if (!pos) die_truncated();
354
355	if (byte_diff(qclass,2,DNS_C_IN) && byte_diff(qclass,2,DNS_C_ANY))
356	strerr_die2x(111,FATAL,"bogus query: bad class");
357
358	qlog(ip,port,header,zone,qtype," ");
359
360	if (byte_equal(qtype,2,DNS_T_AXFR)) {
361	case_lowerb(zone,zonelen);
362	fdcdb = open_read("data.cdb");
363	if (fdcdb == -1) die_cdbread();
364	doaxfr(header);
365	close(fdcdb);
366	}
367	else {
368	if (!response_query(zone,qtype,qclass)) nomem();
369	response[2] \|= 4;
370	case_lowerb(zone,zonelen);
371	response_id(header);
372	response[3] &= ~128;
373	if (!(header[2] & 1)) response[2] &= ~1;
374	if (!respond(zone,qtype,ip)) die_outside();
375	print(response,response_len);
376	}
377	}
378	}