[ViewVC] Diff of: cvs/gvpe/src/vpn

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.37 by pcg, Wed Mar 23 17:03:58 2005 UTC vs.
Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC

…		…
1	/*	1	/*
2	vpn_dns.C -- handle the dns tunnel part of the protocol.	2	vpn_dns.C -- handle the dns tunnel part of the protocol.
3	Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de>	3	Copyright (C) 2003-2011 Marc Lehmann <gvpe@schmorp.de>
4		4
5	This file is part of GVPE.	5	This file is part of GVPE.
6		6
7	GVPE is free software; you can redistribute it and/or modify	7	GVPE is free software; you can redistribute it and/or modify it
8	it under the terms of the GNU General Public License as published by	8	under the terms of the GNU General Public License as published by the
9	the Free Software Foundation; either version 2 of the License, or	9	Free Software Foundation; either version 3 of the License, or (at your
10	(at your option) any later version.	10	option) any later version.
11		11
12	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful, but
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15	GNU General Public License for more details.	15	Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License along
18	along with gvpe; if not, write to the Free Software	18	with this program; if not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	19
		20	Additional permission under GNU GPL version 3 section 7
		21
		22	If you modify this Program, or any covered work, by linking or
		23	combining it with the OpenSSL project's OpenSSL library (or a modified
		24	version of that library), containing parts covered by the terms of the
		25	OpenSSL or SSLeay licenses, the licensors of this Program grant you
		26	additional permission to convey the resulting work. Corresponding
		27	Source for a non-source form of such a combination shall include the
		28	source code for the parts of OpenSSL used as well as that of the
		29	covered work.
20	*/	30	*/
		31
		32	// TODO: EDNS0 option to increase dns mtu?
		33	// TODO: re-write dns packet parsing/creation using a safe mem-buffer
		34	// to ensure no buffer overflows or similar problems.
21		35
22	#include "config.h"	36	#include "config.h"
23		37
24	#if ENABLE_DNS	38	#if ENABLE_DNS
25		39
38	#include <unistd.h>	52	#include <unistd.h>
39	#include <fcntl.h>	53	#include <fcntl.h>
40		54
41	#include <map>	55	#include <map>
42		56
		57	#include <cstdio> /* bug in libgmp: gmp.h relies on cstdio being included */
43	#include <gmp.h>	58	#include <gmp.h>
44		59
45	#include "netcompat.h"	60	#include "netcompat.h"
46		61
47	#include "vpn.h"	62	#include "vpn.h"
48		63
		64	#define MIN_POLL_INTERVAL 0.025 // poll at most this often when no data received
49	#define MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data	65	#define MAX_POLL_INTERVAL 1. // how often to poll minimally when the server has no data
50	#define ACTIVITY_INTERVAL 5.
51		66
52	#define INITIAL_TIMEOUT 0.1 // retry timeouts	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
53	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54		69
55	#define MAX_SEND_INTERVAL 2. // optimistic?	70	#define MAX_SEND_INTERVAL 5. // optimistic?
56		71
57	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
58	#define MAX_BACKLOG (64*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE	73	#define MAX_BACKLOG (64*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
59		74
60	#define MAX_DOMAIN_SIZE 240 // 255 is legal limit, but bind doesn't compress well	75	#define MAX_DOMAIN_SIZE 240 // 255 is legal limit, but bind doesn't compress well
…		…
68	#define MAX_PKT_SIZE 512	83	#define MAX_PKT_SIZE 512
69		84
70	#define RR_TYPE_A 1	85	#define RR_TYPE_A 1
71	#define RR_TYPE_NULL 10	86	#define RR_TYPE_NULL 10
72	#define RR_TYPE_TXT 16	87	#define RR_TYPE_TXT 16
		88	#define RR_TYPE_AAAA 28
73	#define RR_TYPE_ANY 255	89	#define RR_TYPE_ANY 255
74		90
75	#define RR_CLASS_IN 1	91	#define RR_CLASS_IN 1
76		92
77	#define CMD_IP_1 207	93	#define CMD_IP_1 207
78	#define CMD_IP_2 46	94	#define CMD_IP_2 46
79	#define CMD_IP_3 236	95	#define CMD_IP_3 236
80	#define CMD_IP_RST 29	96
81	#define CMD_IP_SYN 113	97	#define CMD_IP_RST 29 // some error, reset and retry
82	#define CMD_IP_REJ 32	98	#define CMD_IP_REJ 32 // do not want you
		99	#define CMD_IP_SYN 113 // connection established
		100	#define CMD_IP_CSE 213 // connection established, but likely case mismatch
		101
		102	static bool
		103	is_uc (char c)
		104	{
		105	return 'A' <= c && c <= 'Z';
		106	}
		107
		108	static bool
		109	is_lc (char c)
		110	{
		111	return 'a' <= c && c <= 'z';
		112	}
83		113
84	// works for cmaps up to 255 (not 256!)	114	// works for cmaps up to 255 (not 256!)
85	struct charmap	115	struct charmap
86	{	116	{
87	enum { INVALID = (u8)255 };	117	enum { INVALID = (u8)255 };
…		…
101	memset (enc, (char) 0, 256);	131	memset (enc, (char) 0, 256);
102	memset (dec, (char)INVALID, 256);	132	memset (dec, (char)INVALID, 256);
103		133
104	for (size = 0; cmap [size]; size++)	134	for (size = 0; cmap [size]; size++)
105	{	135	{
		136	char c = cmap [size];
		137
106	enc [size] = cmap [size];	138	enc [size] = c;
107	dec [(u8)enc [size]] = size;	139	dec [(u8)c] = size;
		140
		141	// allow lowercase/uppercase aliases if possible
		142	if (is_uc (c) && dec [c + ('a' - 'A')] == INVALID) dec [c + ('a' - 'A')] = size;
		143	if (is_lc (c) && dec [c - ('a' - 'A')] == INVALID) dec [c - ('a' - 'A')] = size;
108	}	144	}
109		145
110	assert (size < 256);	146	assert (size < 256);
111	}	147	}
112		148
…		…
119	{	155	{
120	charmap cmap;	156	charmap cmap;
121	unsigned int enc_len [MAX_DEC_LEN];	157	unsigned int enc_len [MAX_DEC_LEN];
122	unsigned int dec_len [MAX_ENC_LEN];	158	unsigned int dec_len [MAX_ENC_LEN];
123		159
124	unsigned int encode_len (unsigned int len);	160	unsigned int encode_len (unsigned int len) const;
125	unsigned int decode_len (unsigned int len);	161	unsigned int decode_len (unsigned int len) const;
126		162
127	unsigned int encode (char dst, u8 src, unsigned int len);	163	unsigned int encode (char dst, u8 src, unsigned int len) const;
128	unsigned int decode (u8 dst, char src, unsigned int len);	164	unsigned int decode (u8 dst, char src, unsigned int len) const;
129		165
130	basecoder (const char *cmap);	166	basecoder (const char *cmap);
131	};	167	};
132		168
133	basecoder::basecoder (const char *cmap)	169	basecoder::basecoder (const char *cmap)
…		…
152	enc_len [len] = n;	188	enc_len [len] = n;
153	dec_len [n] = len;	189	dec_len [n] = len;
154	}	190	}
155	}	191	}
156		192
		193	unsigned int
157	unsigned int basecoder::encode_len (unsigned int len)	194	basecoder::encode_len (unsigned int len) const
158	{	195	{
159	return enc_len [len];	196	return enc_len [len];
160	}	197	}
161		198
		199	unsigned int
162	unsigned int basecoder::decode_len (unsigned int len)	200	basecoder::decode_len (unsigned int len) const
163	{	201	{
164	while (len && !dec_len [len])	202	while (len && !dec_len [len])
165	--len;	203	--len;
166		204
167	return dec_len [len];	205	return dec_len [len];
168	}	206	}
169		207
		208	unsigned int
170	unsigned int basecoder::encode (char dst, u8 src, unsigned int len)	209	basecoder::encode (char dst, u8 src, unsigned int len) const
171	{	210	{
172	if (!len \|\| len > MAX_DEC_LEN)	211	if (!len \|\| len > MAX_DEC_LEN)
173	return 0;	212	return 0;
174		213
175	int elen = encode_len (len);	214	int elen = encode_len (len);
…		…
194	*dst++ = cmap.encode [dst_ [i]];	233	*dst++ = cmap.encode [dst_ [i]];
195		234
196	return elen;	235	return elen;
197	}	236	}
198		237
		238	unsigned int
199	unsigned int basecoder::decode (u8 dst, char src, unsigned int len)	239	basecoder::decode (u8 dst, char src, unsigned int len) const
200	{	240	{
201	if (!len \|\| len > MAX_ENC_LEN)	241	if (!len \|\| len > MAX_ENC_LEN)
202	return 0;	242	return 0;
203		243
204	u8 src_ [MAX_ENC_LEN];	244	u8 src_ [MAX_ENC_LEN];
…		…
253	}	293	}
254	abort ();	294	abort ();
255	}	295	}
256	#endif	296	#endif
257		297
258	//static basecoder cdc64 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI-");
259	//static basecoder cdc63 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
260	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");	298	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI"); // a-zA-Z0-9
261	//static basecoder cdc36 ("dphzr06qmjkb34tsvl81xaef92wgyo57ucni"); // unused as of yet	299	static basecoder cdc36 ("dPhZr06QmJkB34tSvL81xAeF92wGyO57uCnI"); // a-z0-9 for case-changers
262	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	300	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyOuCnI"); // a-z
263		301
264	/////////////////////////////////////////////////////////////////////////////	302	/////////////////////////////////////////////////////////////////////////////
265		303
266	#define HDRSIZE 6	304	#define HDRSIZE 5
267		305
		306	inline void
268	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)	307	encode_header (char *data, int clientid, int seqno, int retry = 0)
269	{	308	{
		309	assert (clientid < 256);
		310
270	seqno &= SEQNO_MASK;	311	seqno &= SEQNO_MASK;
271		312
272	u8 hdr[3] = {	313	u8 hdr[3] = {
		314	seqno,
		315	(seqno >> 8) \| (retry << 6),
273	clientid,	316	clientid,
274	(seqno >> 8) \| (retry << 6),
275	seqno,
276	};	317	};
277		318
278	assert (clientid < 256);
279
280	cdc26.encode (data, hdr, 3);	319	cdc36.encode (data, hdr, 3);
281	}	320	}
282		321
		322	inline void
283	inline void decode_header (char *data, int &clientid, int &seqno)	323	decode_header (char *data, int &clientid, int &seqno)
284	{	324	{
285	u8 hdr[3];	325	u8 hdr[3];
286		326
287	cdc26.decode (hdr, data, HDRSIZE);	327	cdc36.decode (hdr, data, HDRSIZE);
288		328
289	clientid = hdr[0];	329	clientid = hdr[2];
290	seqno = ((hdr[1] << 8) \| hdr[2]) & SEQNO_MASK;	330	seqno = ((hdr[1] << 8) \| hdr[0]) & SEQNO_MASK;
291	}	331	}
292		332
293	/////////////////////////////////////////////////////////////////////////////	333	/////////////////////////////////////////////////////////////////////////////
294		334
295	struct byte_stream	335	struct byte_stream
…		…
321	byte_stream::~byte_stream ()	361	byte_stream::~byte_stream ()
322	{	362	{
323	delete data;	363	delete data;
324	}	364	}
325		365
		366	void
326	void byte_stream::remove (int count)	367	byte_stream::remove (int count)
327	{	368	{
328	if (count > fill)	369	if (count > fill)
329	assert (count <= fill);	370	assert (count <= fill);
330		371
331	memmove (data, data + count, fill -= count);	372	memmove (data, data + count, fill -= count);
332	}	373	}
333		374
		375	bool
334	bool byte_stream::put (u8 *data, unsigned int datalen)	376	byte_stream::put (u8 *data, unsigned int datalen)
335	{	377	{
336	if (maxsize - fill < datalen)	378	if (maxsize - fill < datalen)
337	return false;	379	return false;
338		380
339	memcpy (this->data + fill, data, datalen); fill += datalen;	381	memcpy (this->data + fill, data, datalen); fill += datalen;
340		382
341	return true;	383	return true;
342	}	384	}
343		385
		386	bool
344	bool byte_stream::put (vpn_packet *pkt)	387	byte_stream::put (vpn_packet *pkt)
345	{	388	{
346	if (maxsize - fill < pkt->len + 2)	389	if (maxsize - fill < pkt->len + 2)
347	return false;	390	return false;
348		391
349	data [fill++] = pkt->len >> 8;	392	data [fill++] = pkt->len >> 8;
…		…
405		448
406	struct dns_cfg	449	struct dns_cfg
407	{	450	{
408	static int next_uid;	451	static int next_uid;
409		452
410	u8 id1, id2, id3, id4;	453	u8 chksum;
		454	u8 rrtype;
		455	u16 uid; // to make request unique
411		456
412	u8 version;	457	u8 version;
413	u8 flags;	458	u8 flags;
414	u8 rrtype;	459	u16 max_size;
		460
		461	u8 id1, id2, id3, id4;
		462
		463	u16 client;
415	u8 def_ttl;	464	u8 def_ttl;
		465	u8 r0;
416		466
417	u16 client;	467	u8 syn_cdc; // cdc en/decoder for syn (A?) requests
418	u16 uid; // to make request unique	468	u8 hdr_cdc; // cdc en/decoder for regular request headers
		469	u8 req_cdc; // cdc en/decoder for regular (ANY?) request data
		470	u8 rep_cdc; // cdc en/decoder for regular (TXT) replies, 0 == 8 bit encoding
419		471
420	u16 max_size;
421	u8 seq_cdc;
422	u8 req_cdc;
423
424	u8 rep_cdc;
425	u8 delay; // time in 0.01s units that the server may delay replying packets
426	u8 r3, r4;
427
428	u8 r5, r6, r7, r8;	472	u8 r1, r2, r3, r4;
429		473
430	void reset (int clientid);	474	void reset (int clientid);
431	bool valid ();	475	bool valid ();
		476	u8 get_chksum ();
432	};	477	};
433		478
434	int dns_cfg::next_uid;	479	int dns_cfg::next_uid;
435		480
		481	void
436	void dns_cfg::reset (int clientid)	482	dns_cfg::reset (int clientid)
437	{	483	{
		484	// this ID must result in some mixed-case characters in cdc26-encoding
438	id1 = 'G';	485	id1 = 'G';
439	id2 = 'V';	486	id2 = 'V';
440	id3 = 'P';	487	id3 = 'P';
441	id4 = 'E';	488	id4 = 'E';
442		489
443	version = 1;	490	version = 2;
444		491
445	rrtype = RR_TYPE_TXT;	492	rrtype = RR_TYPE_TXT;
446	flags = 0;	493	flags = 0;
447	def_ttl = 0;	494	def_ttl = 0;
448	seq_cdc = 26;	495	syn_cdc = 26;
449	req_cdc = 62;	496	hdr_cdc = 36;
		497	req_cdc = conf.dns_case_preserving ? 62 : 36;
450	rep_cdc = 0;	498	rep_cdc = 0;
451	max_size = htons (MAX_PKT_SIZE);	499	max_size = htons (MAX_PKT_SIZE);
452	client = htons (clientid);	500	client = htons (clientid);
453	uid = next_uid++;	501	uid = ++next_uid;
454	delay = 0;
455		502
456	r3 = r4 = 0;	503	r0 = r1 = r2 = r3 = r4 = 0;
457	r4 = r5 = r6 = r7 = 0;
458	}
459		504
		505	chksum = get_chksum ();
		506	}
		507
		508	// simple but not trivial chksum
		509	u8
		510	dns_cfg::get_chksum ()
		511	{
		512	unsigned int sum = 0xff00; // only 16 bits required
		513
		514	u8 old_chksum = chksum;
		515	chksum = 0;
		516
		517	for (unsigned int i = 0; i < sizeof (*this); ++i)
		518	sum += ((u8 )this)[i] (i + 1);
		519
		520	chksum = old_chksum;
		521
		522	return sum + (sum >> 8);
		523	}
		524
		525	bool
460	bool dns_cfg::valid ()	526	dns_cfg::valid ()
461	{	527	{
		528	// although the protocol itself allows for some configurability,
		529	// only the following encoding/decoding settings are implemented.
462	return id1 == 'G'	530	return id1 == 'G'
463	&& id2 == 'V'	531	&& id2 == 'V'
464	&& id3 == 'P'	532	&& id3 == 'P'
465	&& id4 == 'E'	533	&& id4 == 'E'
		534	&& version == 2
466	&& seq_cdc == 26	535	&& syn_cdc == 26
467	&& req_cdc == 62	536	&& hdr_cdc == 36
		537	&& (req_cdc == 36 \|\| req_cdc == 62)
468	&& rep_cdc == 0	538	&& rep_cdc == 0
469	&& version == 1;	539	&& chksum == get_chksum ();
470	}	540	}
471		541
472	struct dns_packet : net_packet	542	struct dns_packet : net_packet
473	{	543	{
474	u16 id;	544	u16 id;
…		…
478	u8 data [MAXSIZE - 6 * 2];	548	u8 data [MAXSIZE - 6 * 2];
479		549
480	int decode_label (char *data, int size, int &offs);	550	int decode_label (char *data, int size, int &offs);
481	};	551	};
482		552
		553	int
483	int dns_packet::decode_label (char *data, int size, int &offs)	554	dns_packet::decode_label (char *data, int size, int &offs)
484	{	555	{
485	char *orig = data;	556	char *orig = data;
486		557
487	memset (data, 0, size);	558	memset (data, 0, size);
488		559
…		…
514	return data - orig;	585	return data - orig;
515	}	586	}
516		587
517	/////////////////////////////////////////////////////////////////////////////	588	/////////////////////////////////////////////////////////////////////////////
518		589
		590	static
		591	u16 next_id ()
		592	{
519	static u16 dns_id = 0; // TODO: should be per-vpn	593	static u16 dns_id = 0; // TODO: should be per-vpn
520		594
521	static u16 next_id ()
522	{
523	if (!dns_id)	595	if (!dns_id)
524	dns_id = time (0);	596	dns_id = time (0);
525		597
526	// the simplest lsfr with periodicity 65535 i could find	598	// the simplest lsfr with periodicity 65535 i could find
527	dns_id = (dns_id << 1)	599	dns_id = (dns_id << 1)
…		…
542	struct vpn *vpn;	614	struct vpn *vpn;
543		615
544	dns_cfg cfg;	616	dns_cfg cfg;
545		617
546	bool established;	618	bool established;
		619	const basecoder *cdc;
547		620
548	tstamp last_received;	621	tstamp last_received;
549	tstamp last_sent;	622	tstamp last_sent;
550	double min_latency;	623	double min_latency;
551	double poll_interval, send_interval;	624	double poll_interval, send_interval;
…		…
553	vector<dns_rcv *> rcvpq;	626	vector<dns_rcv *> rcvpq;
554		627
555	byte_stream rcvdq; int rcvseq; int repseq;	628	byte_stream rcvdq; int rcvseq; int repseq;
556	byte_stream snddq; int sndseq;	629	byte_stream snddq; int sndseq;
557		630
558	void time_cb (time_watcher &w); time_watcher tw;	631	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
559	void receive_rep (dns_rcv *r);	632	void receive_rep (dns_rcv *r);
		633
		634	void reset (); // quite like tcp RST
		635	void set_cfg (); // to be called after any cfg changes
560		636
561	dns_connection (connection *c);	637	dns_connection (connection *c);
562	~dns_connection ();	638	~dns_connection ();
563	};	639	};
564		640
…		…
582	: dns (dns)	658	: dns (dns)
583	{	659	{
584	timeout = 0;	660	timeout = 0;
585	retry = 0;	661	retry = 0;
586	seqno = 0;	662	seqno = 0;
587	sent = NOW;	663	sent = ev_now ();
588	stdhdr = false;	664	stdhdr = false;
589		665
590	pkt = new dns_packet;	666	pkt = new dns_packet;
591		667
592	pkt->id = next_id ();	668	pkt->id = next_id ();
…		…
595	dns_snd::~dns_snd ()	671	dns_snd::~dns_snd ()
596	{	672	{
597	delete pkt;	673	delete pkt;
598	}	674	}
599		675
		676	static void
600	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	677	append_domain (dns_packet &pkt, int &offs, const char *domain)
601	{	678	{
602	// add tunnel domain	679	// add tunnel domain
603	for (;;)	680	for (;;)
604	{	681	{
605	const char *end = strchr (domain, '.');	682	const char *end = strchr (domain, '.');
…		…
618		695
619	domain = end + 1;	696	domain = end + 1;
620	}	697	}
621	}	698	}
622		699
		700	void
623	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	701	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
624	{	702	{
625	stdhdr = true;	703	stdhdr = true;
626	this->seqno = seqno;	704	this->seqno = seqno;
627		705
628	timeout = NOW + INITIAL_TIMEOUT;	706	timeout = ev_now () + INITIAL_TIMEOUT;
629		707
630	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	708	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
631	pkt->qdcount = htons (1);	709	pkt->qdcount = htons (1);
632		710
633	int offs = 6*2;	711	int offs = 6*2;
…		…
636	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	714	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
637		715
638	char enc[256], *encp = enc;	716	char enc[256], *encp = enc;
639	encode_header (enc, THISNODE->id, seqno);	717	encode_header (enc, THISNODE->id, seqno);
640		718
641	int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);	719	int datalen = dns->cdc->decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
642		720
643	if (datalen > stream.size ())	721	if (datalen > stream.size ())
644	datalen = stream.size ();	722	datalen = stream.size ();
645		723
646	int enclen = cdc62.encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;	724	int enclen = dns->cdc->encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
647	stream.remove (datalen);	725	stream.remove (datalen);
648		726
649	while (enclen)	727	while (enclen)
650	{	728	{
651	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;	729	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
…		…
666	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	744	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
667		745
668	pkt->len = offs;	746	pkt->len = offs;
669	}	747	}
670		748
		749	void
671	void dns_snd::gen_syn_req ()	750	dns_snd::gen_syn_req ()
672	{	751	{
673	timeout = NOW + INITIAL_SYN_TIMEOUT;	752	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
674		753
675	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	754	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
676	pkt->qdcount = htons (1);	755	pkt->qdcount = htons (1);
677		756
678	int offs = 6 * 2;	757	int offs = 6 * 2;
…		…
718		797
719	dns_connection::dns_connection (connection *c)	798	dns_connection::dns_connection (connection *c)
720	: c (c)	799	: c (c)
721	, rcvdq (MAX_BACKLOG * 2)	800	, rcvdq (MAX_BACKLOG * 2)
722	, snddq (MAX_BACKLOG)	801	, snddq (MAX_BACKLOG)
723	, tw (this, &dns_connection::time_cb)
724	{	802	{
		803	tw.set<dns_connection, &dns_connection::time_cb> (this);
		804
725	vpn = c->vpn;	805	vpn = c->vpn;
726		806
		807	reset ();
		808	}
		809
		810	dns_connection::~dns_connection ()
		811	{
		812	reset ();
		813	}
		814
		815	void
		816	dns_connection::reset ()
		817	{
		818	while (!rcvpq.empty ())
		819	{
		820	delete rcvpq.back ();
		821	rcvpq.pop_back ();
		822	}
		823
		824	for (int i = vpn->dns_sndpq.size (); i--; )
		825	if (vpn->dns_sndpq [i]->dns == this)
		826	{
		827	vpn->dns_sndpq [i] = vpn->dns_sndpq.back ();
		828	vpn->dns_sndpq.pop_back ();
		829	}
		830
727	established = false;	831	established = false;
728		832
729	rcvseq = repseq = sndseq = 0;	833	rcvseq = repseq = sndseq = 0;
730		834
731	last_sent = last_received = 0;	835	last_sent = 0;
732	poll_interval = 0.5; // starting here	836	poll_interval = 0.5; // starting here
733	send_interval = 0.5; // starting rate	837	send_interval = 0.5; // starting rate
734	min_latency = INITIAL_TIMEOUT;	838	min_latency = INITIAL_TIMEOUT;
735	}	839	}
736		840
737	dns_connection::~dns_connection ()	841	void
		842	dns_connection::set_cfg ()
738	{	843	{
739	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	844	cdc = cfg.req_cdc == 36 ? &cdc36 : &cdc62;
740	i != rcvpq.end ();
741	++i)
742	delete *i;
743	}	845	}
744		846
		847	void
745	void dns_connection::receive_rep (dns_rcv *r)	848	dns_connection::receive_rep (dns_rcv *r)
746	{	849	{
747	if (r->datalen)	850	if (r->datalen)
748	{	851	poll_interval = max (poll_interval * (1. / 1.2), MIN_POLL_INTERVAL);
749	last_received = NOW;
750	tw.trigger ();
751
752	poll_interval = send_interval;
753	}
754	else	852	else
755	{	853	poll_interval = min (poll_interval * 1.1, MAX_POLL_INTERVAL);
756	poll_interval *= 1.5;
757
758	if (poll_interval > MAX_POLL_INTERVAL)
759	poll_interval = MAX_POLL_INTERVAL;
760	}
761		854
762	rcvpq.push_back (r);	855	rcvpq.push_back (r);
763		856
764	redo:	857	redo:
765		858
766	// find next packet	859	// find next packet
767	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	860	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
768	if (SEQNO_EQ (rcvseq, (*i)->seqno))	861	if (SEQNO_EQ (rcvseq, (*i)->seqno))
769	{	862	{
		863	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
770	// enter the packet into our input stream	864	// enter the packet into our input stream
771	r = *i;	865	r = *i;
772		866
773	// remove the oldest packet, look forward, as it's oldest first	867	// remove the oldest packet, look forward, as it's oldest first
774	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	868	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
775	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	869	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
776	{	870	{
		871	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
777	delete *j;	872	delete *j;
778	rcvpq.erase (j);	873	rcvpq.erase (j);
779	break;	874	break;
780	}	875	}
781		876
782	rcvseq = (rcvseq + 1) & SEQNO_MASK;	877	rcvseq = (rcvseq + 1) & SEQNO_MASK;
783		878
784	if (!rcvdq.put (r->data, r->datalen))	879	if (!rcvdq.put (r->data, r->datalen))
785	{	880	{
		881	// MUST never overflow, can be caused by data corruption, TODO
786	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");	882	slog (L_CRIT, "DNS: !rcvdq.put (r->data, r->datalen)");
787	abort (); // MUST never overflow, can be caused by data corruption, TODO	883	reset ();
		884	return;
788	}	885	}
789		886
790	while (vpn_packet *pkt = rcvdq.get ())	887	while (vpn_packet *pkt = rcvdq.get ())
791	{	888	{
792	sockinfo si;	889	sockinfo si;
793	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;	890	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
794		891
795	vpn->recv_vpn_packet (pkt, si);	892	vpn->recv_vpn_packet (pkt, si);
796
797	delete pkt;	893	delete pkt;
798	}	894	}
799		895
800	// check for further packets	896	// check for further packets
801	goto redo;	897	goto redo;
…		…
844	{	940	{
845	// correct class, domain: parse	941	// correct class, domain: parse
846	int client, seqno;	942	int client, seqno;
847	decode_header (qname, client, seqno);	943	decode_header (qname, client, seqno);
848		944
849	u8 data[MAXSIZE];
850	int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
851
852	if (0 < client && client <= conns.size ())	945	if (0 < client && client <= conns.size ())
853	{	946	{
854	connection *c = conns [client - 1];	947	connection *c = conns [client - 1];
855	dns_connection *dns = c->dns;	948	dns_connection *dns = c->dns;
856	dns_rcv *rcv;	949	dns_rcv *rcv;
857		950
858	if (dns)	951	if (dns)
859	{	952	{
		953	u8 data[MAXSIZE];
		954	int datalen = dns->cdc->decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
		955
860	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	956	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
861	if (SEQNO_EQ ((*i)->seqno, seqno))	957	if (SEQNO_EQ ((*i)->seqno, seqno))
862	{	958	{
863	// already seen that request: simply reply with the cached reply	959	// already seen that request: simply reply with the cached reply
864	dns_rcv r = i;	960	dns_rcv r = i;
…		…
965	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	1061	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
966	pkt [offs++] = 0; pkt [offs++] = 0;	1062	pkt [offs++] = 0; pkt [offs++] = 0;
967	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1063	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
968	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1064	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
969		1065
970	slog (L_INFO, _("DNS: client %d connects"), client);
971
972	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	1066	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
973	pkt [offs++] = CMD_IP_REJ;	1067	pkt [offs++] = CMD_IP_REJ;
974		1068
975	if (0 < client && client <= conns.size ())	1069	if (0 < client && client <= conns.size ())
976	{	1070	{
977	connection *c = conns [client - 1];	1071	connection *c = conns [client - 1];
978		1072
979	if (cfg.valid ())	1073	if (cfg.valid ())
980	{	1074	{
981	pkt [offs - 1] = CMD_IP_SYN;	1075	slog (L_INFO, _("DNS: client %d connects (version %d, req_cdc %d)"), client, cfg.version, cfg.req_cdc);
		1076
		1077	// check for any encoding mismatches - hints at a case problem
		1078	char qname2 [MAX_ENC_LEN];
		1079	cdc26.encode (qname2, (u8 *)&cfg, sizeof (dns_cfg));
982		1080
983	delete c->dns;	1081	delete c->dns;
		1082
		1083	pkt [offs - 1] = memcmp (qname, qname2, cdc26.encode_len (sizeof (dns_cfg)))
		1084	? CMD_IP_CSE : CMD_IP_SYN;
		1085
984	c->dns = new dns_connection (c);	1086	c->dns = new dns_connection (c);
985	c->dns->cfg = cfg;	1087	c->dns->cfg = cfg;
		1088	c->dns->set_cfg ();
986	}	1089	}
987	}	1090	}
988	}	1091	}
989	}	1092	}
990		1093
…		…
1009	{	1112	{
1010	dns_connection dns = (i)->dns;	1113	dns_connection dns = (i)->dns;
1011	connection *c = dns->c;	1114	connection *c = dns->c;
1012	int seqno = (*i)->seqno;	1115	int seqno = (*i)->seqno;
1013	u8 data[MAXSIZE], *datap = data;	1116	u8 data[MAXSIZE], *datap = data;
		1117	//printf ("rcv pkt %x\n", seqno);//D
1014		1118
1015	if ((*i)->retry)	1119	if ((*i)->retry)
1016	{	1120	{
1017	dns->send_interval *= 1.01;	1121	dns->send_interval *= 1.01;
1018	if (dns->send_interval > MAX_SEND_INTERVAL)	1122	if (dns->send_interval > MAX_SEND_INTERVAL)
…		…
1023	#if 0	1127	#if 0
1024	dns->send_interval *= 0.999;	1128	dns->send_interval *= 0.999;
1025	#endif	1129	#endif
1026	// the latency surely puts an upper bound on	1130	// the latency surely puts an upper bound on
1027	// the minimum send interval	1131	// the minimum send interval
1028	double latency = NOW - (*i)->sent;	1132	double latency = ev_now () - (*i)->sent;
1029		1133
1030	if (latency < dns->min_latency)	1134	if (latency < dns->min_latency)
1031	dns->min_latency = latency;	1135	dns->min_latency = latency;
1032		1136
1033	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)	1137	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
…		…
1060	ttl \|= pkt [offs++] << 16;	1164	ttl \|= pkt [offs++] << 16;
1061	ttl \|= pkt [offs++] << 8;	1165	ttl \|= pkt [offs++] << 8;
1062	ttl \|= pkt [offs++];	1166	ttl \|= pkt [offs++];
1063	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];	1167	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];
1064		1168
1065	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT)	1169	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT \|\| qtype == dns->cfg.rrtype)
1066	{	1170	{
1067	if (rdlen <= MAXSIZE - offs)	1171	if (rdlen <= MAXSIZE - offs)
1068	{	1172	{
1069	// decode bytes, finally	1173	// decode bytes, finally
1070		1174
…		…
1096	{	1200	{
1097	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);	1201	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1098		1202
1099	if (ip [3] == CMD_IP_RST)	1203	if (ip [3] == CMD_IP_RST)
1100	{	1204	{
1101	slog (L_DEBUG, _("DNS: got tunnel RST request"));	1205	slog (L_DEBUG, _("DNS: got tunnel RST request."));
1102		1206
1103	delete dns; c->dns = 0;	1207	dns->reset ();
1104
1105	return;	1208	return;
1106	}	1209	}
1107	else if (ip [3] == CMD_IP_SYN)	1210	else if (ip [3] == CMD_IP_SYN)
1108	{	1211	{
1109	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));	1212	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1110	dns->established = true;	1213	dns->established = true;
1111	}	1214	}
		1215	else if (ip [3] == CMD_IP_CSE)
		1216	{
		1217	if (conf.dns_case_preserving)
		1218	{
		1219	slog (L_INFO, _("DNS: got tunnel CSE reply, globally downgrading to case-insensitive protocol."));
		1220	conf.dns_case_preserving = false;
		1221	dns->reset ();
		1222	return;
		1223	}
		1224	else
		1225	{
		1226	slog (L_DEBUG, _("DNS: got tunnel CSE reply, server likes us."));
		1227	dns->established = true;
		1228	}
		1229	}
1112	else if (ip [3] == CMD_IP_REJ)	1230	else if (ip [3] == CMD_IP_REJ)
1113	{	1231	{
1114	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));	1232	slog (L_ERR, _("DNS: got tunnel REJ reply, server does not like us."));
1115	abort ();	1233	dns->tw.start (60.);
1116	}	1234	}
1117	else	1235	else
		1236	{
1118	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);	1237	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
		1238	dns->tw.start (60.);
		1239	}
1119	}	1240	}
1120	else	1241	else
1121	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),	1242	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1122	ip [0], ip [1], ip [2], ip [3]);	1243	ip [0], ip [1], ip [2], ip [3]);
1123		1244
…		…
1147	break;	1268	break;
1148	}	1269	}
1149	}	1270	}
1150		1271
1151	void	1272	void
1152	vpn::dnsv4_ev (io_watcher &w, short revents)	1273	vpn::dnsv4_ev (ev::io &w, int revents)
1153	{	1274	{
1154	if (revents & EVENT_READ)	1275	if (revents & EV_READ)
1155	{	1276	{
1156	dns_packet *pkt = new dns_packet;	1277	dns_packet *pkt = new dns_packet;
1157	struct sockaddr_in sa;	1278	struct sockaddr_in sa;
1158	socklen_t sa_len = sizeof (sa);	1279	socklen_t sa_len = sizeof (sa);
1159		1280
…		…
1185		1306
1186	if (!c->dns)	1307	if (!c->dns)
1187	c->dns = new dns_connection (c);	1308	c->dns = new dns_connection (c);
1188		1309
1189	if (c->dns->snddq.put (pkt))	1310	if (c->dns->snddq.put (pkt))
		1311	{
		1312	min_it (c->dns->poll_interval, 0.25);
1190	c->dns->tw.trigger ();	1313	c->dns->tw ();
		1314	}
1191		1315
1192	// always return true even if the buffer overflows	1316	// always return true even if the buffer overflows
1193	return true;	1317	return true;
1194	}	1318	}
1195		1319
1196	void	1320	void
1197	connection::dnsv4_reset_connection ()	1321	dns_connection::time_cb (ev::timer &w, int revents)
1198	{
1199	//delete dns; dns = 0; //TODO
1200	}
1201
1202	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1203
1204	void
1205	dns_connection::time_cb (time_watcher &w)
1206	{	1322	{
1207	// servers have to be polled	1323	// servers have to be polled
1208	if (THISNODE->dns_port)	1324	if (THISNODE->dns_port)
1209	return;	1325	return;
1210		1326
1211	// check for timeouts and (re)transmit	1327	// check for timeouts and (re)transmit
1212	tstamp next = NOW + poll_interval;	1328	tstamp next = 86400 * 365;
1213	dns_snd *send = 0;	1329	dns_snd *send = 0;
1214		1330
1215	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1331	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1216	i != vpn->dns_sndpq.end ();	1332	i != vpn->dns_sndpq.end ();
1217	++i)	1333	++i)
1218	{	1334	{
1219	dns_snd r = i;	1335	dns_snd r = i;
1220		1336
1221	if (r->timeout <= NOW)	1337	if (r->timeout <= ev_now ())
1222	{	1338	{
1223	if (!send)	1339	if (!send)
1224	{	1340	{
1225	send = r;	1341	send = r;
1226		1342
1227	r->retry++;	1343	r->retry++;
1228	r->timeout = NOW + (r->retry * min_latency * conf.dns_timeout_factor);	1344	r->timeout = ev_now () + r->retry * min_latency * conf.dns_timeout_factor;
		1345	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1229		1346
1230	// the following code changes the query section a bit, forcing	1347	// the following code changes the query section a bit, forcing
1231	// the forwarder to generate a new request	1348	// the forwarder to generate a new request
1232	if (r->stdhdr)	1349	if (r->stdhdr)
1233	{
1234	//printf ("reencoded header for ID %d retry %d:%d:%d (%p)\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);
1235	//encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);	1350	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1236	}
1237	}	1351	}
1238	}	1352	}
1239	else	1353	else
1240	NEXT (r->timeout);	1354	min_it (next, r->timeout - ev_now ());
1241	}	1355	}
1242		1356
1243	if (!send)	1357	if (!send)
1244	{	1358	{
1245	// generate a new packet, if wise	1359	// generate a new packet, if wise
…		…
1249	if (vpn->dns_sndpq.empty ())	1363	if (vpn->dns_sndpq.empty ())
1250	{	1364	{
1251	send = new dns_snd (this);	1365	send = new dns_snd (this);
1252		1366
1253	cfg.reset (THISNODE->id);	1367	cfg.reset (THISNODE->id);
		1368	set_cfg ();
1254	send->gen_syn_req ();	1369	send->gen_syn_req ();
1255	}	1370	}
1256	}	1371	}
1257	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding	1372	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1258	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))	1373	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1259	{	1374	{
1260	if (last_sent + send_interval <= NOW)	1375	if (last_sent + send_interval <= ev_now ())
1261	{	1376	{
1262	//printf ("sending data request etc.\n"); //D	1377	//printf ("sending data request etc.\n"); //D
1263	if (!snddq.empty () \|\| last_received + 1. > NOW)	1378	if (!snddq.empty ())
1264	{
1265	poll_interval = send_interval;
1266	NEXT (NOW + send_interval);	1379	min_it (next, send_interval);
1267	}
1268		1380
1269	send = new dns_snd (this);	1381	send = new dns_snd (this);
1270	send->gen_stream_req (sndseq, snddq);	1382	send->gen_stream_req (sndseq, snddq);
1271	send->timeout = NOW + min_latency * conf.dns_timeout_factor;	1383	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1384	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1272		1385
1273	sndseq = (sndseq + 1) & SEQNO_MASK;	1386	sndseq = (sndseq + 1) & SEQNO_MASK;
1274	}	1387	}
1275	else	1388	else
1276	NEXT (last_sent + send_interval);	1389	min_it (next, last_sent + send_interval - ev_now ());
1277	}	1390	}
1278		1391
1279	if (send)	1392	if (send)
1280	vpn->dns_sndpq.push_back (send);	1393	vpn->dns_sndpq.push_back (send);
1281	}	1394	}
1282		1395
1283	if (send)	1396	if (send)
1284	{	1397	{
1285	last_sent = NOW;	1398	last_sent = ev_now ();
1286	sendto (vpn->dnsv4_fd,	1399	sendto (vpn->dnsv4_fd,
1287	send->pkt->at (0), send->pkt->len, 0,	1400	send->pkt->at (0), send->pkt->len, 0,
1288	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1401	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1289	}	1402	}
1290		1403
		1404	min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ());
		1405
1291	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",	1406	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1292	poll_interval, send_interval, next - NOW,	1407	poll_interval, send_interval, next - ev_now (),
1293	vpn->dns_sndpq.size (), snddq.size (),	1408	vpn->dns_sndpq.size (), snddq.size (),
1294	rcvpq.size ());	1409	rcvpq.size ());
1295		1410
1296	// TODO: no idea when this happens, but when next < NOW, we have a problem
1297	// doesn't seem to happen anymore
1298	if (next < NOW + 0.001)
1299	next = NOW + 0.1;
1300
1301	w.start (next);	1411	w.start (next);
1302	}	1412	}
1303		1413
1304	#endif	1414	#endif
1305		1415

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.37 by pcg, Wed Mar 23 17:03:58 2005 UTC vs. Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.37 by pcg, Wed Mar 23 17:03:58 2005 UTC vs.
Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC