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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.44 by pcg, Tue Dec 4 14:55:59 2007 UTC vs.
Revision 1.56 by root, Tue Oct 18 13:24:01 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. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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	*/
21		31
22	// TODO: EDNS0 option to increase dns mtu?	32	// TODO: EDNS0 option to increase dns mtu?
23	// TODO: re-write dns packet parsing/creation using a safe mem-buffer	33	// TODO: re-write dns packet parsing/creation using a safe mem-buffer
24	// to ensure no buffer overflows or similar problems.	34	// to ensure no buffer overflows or similar problems.
49		59
50	#include "netcompat.h"	60	#include "netcompat.h"
51		61
52	#include "vpn.h"	62	#include "vpn.h"
53		63
		64	#define MIN_POLL_INTERVAL 0.025 // poll at most this often when no data received
54	#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
55	#define ACTIVITY_INTERVAL 5.
56		66
57	#define INITIAL_TIMEOUT 0.1 // retry timeouts	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
58	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
59		69
60	#define MAX_SEND_INTERVAL 2. // optimistic?	70	#define MAX_SEND_INTERVAL 5. // optimistic?
61		71
62	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
63	#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
64		74
65	#define MAX_DOMAIN_SIZE 240 // 255 is legal limit, but bind doesn't compress well	75	#define MAX_DOMAIN_SIZE 235 // 255 is legal limit, but bind doesn't compress well
66	// 240 leaves about 4 bytes of server reply data	76	// 240 leaves about 4 bytes of server reply data
67	// every request byte less give room for two reply bytes	77	// every request byte less give room for two reply bytes
68		78
69	#define SEQNO_MASK 0x3fff	79	#define SEQNO_MASK 0x3fff
70	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )	80	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
…		…
73	#define MAX_PKT_SIZE 512	83	#define MAX_PKT_SIZE 512
74		84
75	#define RR_TYPE_A 1	85	#define RR_TYPE_A 1
76	#define RR_TYPE_NULL 10	86	#define RR_TYPE_NULL 10
77	#define RR_TYPE_TXT 16	87	#define RR_TYPE_TXT 16
		88	#define RR_TYPE_AAAA 28
78	#define RR_TYPE_ANY 255	89	#define RR_TYPE_ANY 255
79		90
80	#define RR_CLASS_IN 1	91	#define RR_CLASS_IN 1
81		92
82	#define CMD_IP_1 207	93	#define CMD_IP_1 207
83	#define CMD_IP_2 46	94	#define CMD_IP_2 46
84	#define CMD_IP_3 236	95	#define CMD_IP_3 236
85	#define CMD_IP_RST 29	96
86	#define CMD_IP_SYN 113	97	#define CMD_IP_RST 29 // some error, reset and retry
87	#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	}
88		113
89	// works for cmaps up to 255 (not 256!)	114	// works for cmaps up to 255 (not 256!)
90	struct charmap	115	struct charmap
91	{	116	{
92	enum { INVALID = (u8)255 };	117	enum { INVALID = (u8)255 };
…		…
106	memset (enc, (char) 0, 256);	131	memset (enc, (char) 0, 256);
107	memset (dec, (char)INVALID, 256);	132	memset (dec, (char)INVALID, 256);
108		133
109	for (size = 0; cmap [size]; size++)	134	for (size = 0; cmap [size]; size++)
110	{	135	{
		136	char c = cmap [size];
		137
111	enc [size] = cmap [size];	138	enc [size] = c;
112	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;
113	}	144	}
114		145
115	assert (size < 256);	146	assert (size < 256);
116	}	147	}
117		148
118	#define MAX_DEC_LEN 500	149	#define MAX_DEC_LEN 500
119	#define MAX_ENC_LEN (MAX_DEC_LEN * 2)	150	#define MAX_ENC_LEN (MAX_DEC_LEN * 2)
120	#define MAX_LIMBS ((MAX_DEC_LEN * 8 + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS)	151	#define MAX_LIMBS ((MAX_DEC_LEN * 8 + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS + 1)
121		152
122	// ugly. minimum base is 16(!)	153	// ugly. minimum base is 16(!)
123	struct basecoder	154	struct basecoder
124	{	155	{
125	charmap cmap;	156	charmap cmap;
126	unsigned int enc_len [MAX_DEC_LEN];	157	unsigned int enc_len [MAX_DEC_LEN];
127	unsigned int dec_len [MAX_ENC_LEN];	158	unsigned int dec_len [MAX_ENC_LEN];
128		159
129	unsigned int encode_len (unsigned int len);	160	unsigned int encode_len (unsigned int len) const;
130	unsigned int decode_len (unsigned int len);	161	unsigned int decode_len (unsigned int len) const;
131		162
132	unsigned int encode (char dst, u8 src, unsigned int len);	163	unsigned int encode (char dst, u8 src, unsigned int len) const;
133	unsigned int decode (u8 dst, char src, unsigned int len);	164	unsigned int decode (u8 dst, char src, unsigned int len) const;
134		165
135	basecoder (const char *cmap);	166	basecoder (const char *cmap);
136	};	167	};
137		168
138	basecoder::basecoder (const char *cmap)	169	basecoder::basecoder (const char *cmap)
139	: cmap (cmap)	170	: cmap (cmap)
140	{	171	{
		172	int decn = -1;
		173
141	for (unsigned int len = 0; len < MAX_DEC_LEN; ++len)	174	for (unsigned int len = 0; len < MAX_DEC_LEN; ++len)
142	{	175	{
143	u8 src [MAX_DEC_LEN];	176	u8 src [MAX_DEC_LEN];
144	u8 dst [MAX_ENC_LEN];	177	u8 dst [MAX_ENC_LEN];
145		178
…		…
149	mp_size_t n;	182	mp_size_t n;
150		183
151	n = mpn_set_str (m, src, len, 256);	184	n = mpn_set_str (m, src, len, 256);
152	n = mpn_get_str (dst, this->cmap.size, m, n);	185	n = mpn_get_str (dst, this->cmap.size, m, n);
153		186
154	for (int i = 0; !dst [i]; ++i)	187	for (int i = 0; n && !dst [i]; ++i, --n)
155	n--;	188	;
156		189
157	enc_len [len] = n;	190	enc_len [len] = n;
		191	while (decn < n)
158	dec_len [n] = len;	192	dec_len [++decn] = len;
159	}	193	}
160	}	194	}
161		195
		196	unsigned int
162	unsigned int basecoder::encode_len (unsigned int len)	197	basecoder::encode_len (unsigned int len) const
163	{	198	{
164	return enc_len [len];	199	return enc_len [len];
165	}	200	}
166		201
		202	unsigned int
167	unsigned int basecoder::decode_len (unsigned int len)	203	basecoder::decode_len (unsigned int len) const
168	{	204	{
169	while (len && !dec_len [len])
170	--len;
171
172	return dec_len [len];	205	return dec_len [len];
173	}	206	}
174		207
		208	unsigned int
175	unsigned int basecoder::encode (char dst, u8 src, unsigned int len)	209	basecoder::encode (char dst, u8 src, unsigned int len) const
176	{	210	{
177	if (!len \|\| len > MAX_DEC_LEN)	211	if (!len \|\| len > MAX_DEC_LEN)
178	return 0;	212	return 0;
179		213
180	int elen = encode_len (len);	214	int elen = encode_len (len);
…		…
199	*dst++ = cmap.encode [dst_ [i]];	233	*dst++ = cmap.encode [dst_ [i]];
200		234
201	return elen;	235	return elen;
202	}	236	}
203		237
		238	unsigned int
204	unsigned int basecoder::decode (u8 dst, char src, unsigned int len)	239	basecoder::decode (u8 dst, char src, unsigned int len) const
205	{	240	{
206	if (!len \|\| len > MAX_ENC_LEN)	241	if (!len \|\| len > MAX_ENC_LEN)
207	return 0;	242	return 0;
208		243
209	u8 src_ [MAX_ENC_LEN];	244	u8 src_ [MAX_ENC_LEN];
…		…
258	}	293	}
259	abort ();	294	abort ();
260	}	295	}
261	#endif	296	#endif
262		297
263	//static basecoder cdc64 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI-");
264	//static basecoder cdc63 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
265	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");	298	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI"); // a-zA-Z0-9
266	//static basecoder cdc36 ("dphzr06qmjkb34tsvl81xaef92wgyo57ucni"); // unused as of yet	299	static basecoder cdc36 ("dPhZr06QmJkB34tSvL81xAeF92wGyO57uCnI"); // a-z0-9 for case-changers
267	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	300	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyOuCnI"); // a-z
268		301
269	/////////////////////////////////////////////////////////////////////////////	302	/////////////////////////////////////////////////////////////////////////////
270		303
271	#define HDRSIZE 6	304	#define HDRSIZE 5
272		305
		306	inline void
273	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)
274	{	308	{
		309	assert (clientid < 256);
		310
275	seqno &= SEQNO_MASK;	311	seqno &= SEQNO_MASK;
276		312
277	u8 hdr[3] = {	313	u8 hdr[3] = {
		314	seqno,
		315	(seqno >> 8) \| (retry << 6),
278	clientid,	316	clientid,
279	(seqno >> 8) \| (retry << 6),
280	seqno,
281	};	317	};
282		318
283	assert (clientid < 256);
284
285	cdc26.encode (data, hdr, 3);	319	cdc36.encode (data, hdr, 3);
286	}	320	}
287		321
		322	inline void
288	inline void decode_header (char *data, int &clientid, int &seqno)	323	decode_header (char *data, int &clientid, int &seqno)
289	{	324	{
290	u8 hdr[3];	325	u8 hdr[3];
291		326
292	cdc26.decode (hdr, data, HDRSIZE);	327	cdc36.decode (hdr, data, HDRSIZE);
293		328
294	clientid = hdr[0];	329	clientid = hdr[2];
295	seqno = ((hdr[1] << 8) \| hdr[2]) & SEQNO_MASK;	330	seqno = ((hdr[1] << 8) \| hdr[0]) & SEQNO_MASK;
296	}	331	}
297		332
298	/////////////////////////////////////////////////////////////////////////////	333	/////////////////////////////////////////////////////////////////////////////
299		334
300	struct byte_stream	335	struct byte_stream
…		…
326	byte_stream::~byte_stream ()	361	byte_stream::~byte_stream ()
327	{	362	{
328	delete data;	363	delete data;
329	}	364	}
330		365
		366	void
331	void byte_stream::remove (int count)	367	byte_stream::remove (int count)
332	{	368	{
333	if (count > fill)
334	assert (count <= fill);	369	assert (count <= fill);
335		370
336	memmove (data, data + count, fill -= count);	371	memmove (data, data + count, fill -= count);
337	}	372	}
338		373
		374	bool
339	bool byte_stream::put (u8 *data, unsigned int datalen)	375	byte_stream::put (u8 *data, unsigned int datalen)
340	{	376	{
341	if (maxsize - fill < datalen)	377	if (maxsize - fill < datalen)
342	return false;	378	return false;
343		379
344	memcpy (this->data + fill, data, datalen); fill += datalen;	380	memcpy (this->data + fill, data, datalen); fill += datalen;
345		381
346	return true;	382	return true;
347	}	383	}
348		384
		385	bool
349	bool byte_stream::put (vpn_packet *pkt)	386	byte_stream::put (vpn_packet *pkt)
350	{	387	{
351	if (maxsize - fill < pkt->len + 2)	388	if (maxsize - fill < pkt->len + 2)
352	return false;	389	return false;
353		390
354	data [fill++] = pkt->len >> 8;	391	data [fill++] = pkt->len >> 8;
…		…
357	memcpy (data + fill, pkt->at (0), pkt->len); fill += pkt->len;	394	memcpy (data + fill, pkt->at (0), pkt->len); fill += pkt->len;
358		395
359	return true;	396	return true;
360	}	397	}
361		398
		399	vpn_packet *
362	vpn_packet *byte_stream::get ()	400	byte_stream::get ()
363	{	401	{
364	unsigned int len;	402	unsigned int len;
365		403
366	for (;;)	404	for (;;)
367	{	405	{
		406	if (fill < 2)
		407	return 0;
		408
368	len = (data [0] << 8) \| data [1];	409	len = (data [0] << 8) \| data [1];
369		410
370	if (len <= MAXSIZE \|\| fill < 2)	411	if (len <= MAXSIZE)
371	break;	412	break;
372		413
373	// TODO: handle this better than skipping, e.g. by reset	414	// TODO: handle this better than skipping, e.g. by reset
374	slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));	415	slog (L_DEBUG, _("DNS: corrupted packet (%02x %02x > %d) stream skipping a byte..."), data [0], data [1], MAXSIZE);
375	remove (1);	416	remove (1);
376	}	417	}
377		418
378	if (fill < len + 2)	419	if (fill < len + 2)
379	return 0;	420	return 0;
…		…
410		451
411	struct dns_cfg	452	struct dns_cfg
412	{	453	{
413	static int next_uid;	454	static int next_uid;
414		455
415	u8 id1, id2, id3, id4;	456	u8 chksum;
		457	u8 rrtype;
		458	u16 uid; // to make request unique
416		459
417	u8 version;	460	u8 version;
418	u8 flags;	461	u8 flags;
419	u8 rrtype;	462	u16 max_size;
		463
		464	u8 id1, id2, id3, id4;
		465
		466	u16 client;
420	u8 def_ttl;	467	u8 def_ttl;
		468	u8 r0;
421		469
422	u16 client;	470	u8 syn_cdc; // cdc en/decoder for syn (A?) requests
423	u16 uid; // to make request unique	471	u8 hdr_cdc; // cdc en/decoder for regular request headers
		472	u8 req_cdc; // cdc en/decoder for regular (ANY?) request data
		473	u8 rep_cdc; // cdc en/decoder for regular (TXT) replies, 0 == 8 bit encoding
424		474
425	u16 max_size;
426	u8 seq_cdc;
427	u8 req_cdc;
428
429	u8 rep_cdc;
430	u8 delay; // time in 0.01s units that the server may delay replying packets
431	u8 r3, r4;
432
433	u8 r5, r6, r7, r8;	475	u8 r1, r2, r3, r4;
434		476
435	void reset (int clientid);	477	void reset (int clientid);
436	bool valid ();	478	bool valid ();
		479	u8 get_chksum ();
437	};	480	};
438		481
439	int dns_cfg::next_uid;	482	int dns_cfg::next_uid;
440		483
		484	void
441	void dns_cfg::reset (int clientid)	485	dns_cfg::reset (int clientid)
442	{	486	{
		487	// this ID must result in some mixed-case characters in cdc26-encoding
443	id1 = 'G';	488	id1 = 'G';
444	id2 = 'V';	489	id2 = 'V';
445	id3 = 'P';	490	id3 = 'P';
446	id4 = 'E';	491	id4 = 'E';
447		492
448	version = 1;	493	version = 2;
449		494
450	rrtype = RR_TYPE_TXT;	495	rrtype = RR_TYPE_TXT;
451	flags = 0;	496	flags = 0;
452	def_ttl = 0;	497	def_ttl = 0;
453	seq_cdc = 26;	498	syn_cdc = 26;
454	req_cdc = 62;	499	hdr_cdc = 36;
		500	req_cdc = conf.dns_case_preserving ? 62 : 36;
455	rep_cdc = 0;	501	rep_cdc = 0;
456	max_size = htons (MAX_PKT_SIZE);	502	max_size = htons (MAX_PKT_SIZE);
457	client = htons (clientid);	503	client = htons (clientid);
458	uid = next_uid++;	504	uid = ++next_uid;
459	delay = 0;
460		505
461	r3 = r4 = 0;	506	r0 = r1 = r2 = r3 = r4 = 0;
462	r4 = r5 = r6 = r7 = 0;
463	}
464		507
		508	chksum = get_chksum ();
		509	}
		510
		511	// simple but not trivial chksum
		512	u8
		513	dns_cfg::get_chksum ()
		514	{
		515	unsigned int sum = 0xff00; // only 16 bits required
		516
		517	u8 old_chksum = chksum;
		518	chksum = 0;
		519
		520	for (unsigned int i = 0; i < sizeof (*this); ++i)
		521	sum += ((u8 )this)[i] (i + 1);
		522
		523	chksum = old_chksum;
		524
		525	return sum + (sum >> 8);
		526	}
		527
		528	bool
465	bool dns_cfg::valid ()	529	dns_cfg::valid ()
466	{	530	{
467	// although the protocol itself allows for some configurability,	531	// although the protocol itself allows for some configurability,
468	// only the following encoding/decoding settings are implemented.	532	// only the following encoding/decoding settings are implemented.
469	return id1 == 'G'	533	return id1 == 'G'
470	&& id2 == 'V'	534	&& id2 == 'V'
471	&& id3 == 'P'	535	&& id3 == 'P'
472	&& id4 == 'E'	536	&& id4 == 'E'
		537	&& version == 2
473	&& seq_cdc == 26	538	&& syn_cdc == 26
474	&& req_cdc == 62	539	&& hdr_cdc == 36
		540	&& (req_cdc == 36 \|\| req_cdc == 62)
475	&& rep_cdc == 0	541	&& rep_cdc == 0
476	&& version == 1;	542	&& chksum == get_chksum ();
477	}	543	}
478		544
479	struct dns_packet : net_packet	545	struct dns_packet : net_packet
480	{	546	{
481	u16 id;	547	u16 id;
…		…
485	u8 data [MAXSIZE - 6 * 2];	551	u8 data [MAXSIZE - 6 * 2];
486		552
487	int decode_label (char *data, int size, int &offs);	553	int decode_label (char *data, int size, int &offs);
488	};	554	};
489		555
		556	int
490	int dns_packet::decode_label (char *data, int size, int &offs)	557	dns_packet::decode_label (char *data, int size, int &offs)
491	{	558	{
492	char *orig = data;	559	char *orig = data;
493		560
494	memset (data, 0, size);	561	memset (data, 0, size);
495		562
…		…
521	return data - orig;	588	return data - orig;
522	}	589	}
523		590
524	/////////////////////////////////////////////////////////////////////////////	591	/////////////////////////////////////////////////////////////////////////////
525		592
		593	static
		594	u16 next_id ()
		595	{
526	static u16 dns_id = 0; // TODO: should be per-vpn	596	static u16 dns_id = 0; // TODO: should be per-vpn
527		597
528	static u16 next_id ()	598	#if 1
529	{
530	if (!dns_id)	599	if (!dns_id)
531	dns_id = time (0);	600	dns_id = time (0);
532		601
533	// the simplest lsfr with periodicity 65535 i could find	602	// the simplest lsfr with periodicity 65535 i could find
534	dns_id = (dns_id << 1)	603	dns_id = (dns_id << 1)
…		…
536	^ (dns_id >> 2)	605	^ (dns_id >> 2)
537	^ (dns_id >> 4)	606	^ (dns_id >> 4)
538	^ (dns_id >> 15)) & 1);	607	^ (dns_id >> 15)) & 1);
539		608
540	return dns_id;	609	return dns_id;
		610	#else
		611	dns_id++;//D
		612
		613	return htons (dns_id);
		614	#endif
541	}	615	}
542		616
543	struct dns_rcv;	617	struct dns_rcv;
544	struct dns_snd;	618	struct dns_snd;
545		619
…		…
549	struct vpn *vpn;	623	struct vpn *vpn;
550		624
551	dns_cfg cfg;	625	dns_cfg cfg;
552		626
553	bool established;	627	bool established;
		628	const basecoder *cdc;
554		629
555	tstamp last_received;	630	tstamp last_received;
556	tstamp last_sent;	631	tstamp last_sent;
557	double min_latency;	632	double min_latency;
558	double poll_interval, send_interval;	633	double poll_interval, send_interval;
…		…
560	vector<dns_rcv *> rcvpq;	635	vector<dns_rcv *> rcvpq;
561		636
562	byte_stream rcvdq; int rcvseq; int repseq;	637	byte_stream rcvdq; int rcvseq; int repseq;
563	byte_stream snddq; int sndseq;	638	byte_stream snddq; int sndseq;
564		639
565	void time_cb (ev::timer &w, int revents); ev::timer tw;	640	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
566	void receive_rep (dns_rcv *r);	641	void receive_rep (dns_rcv *r);
		642
		643	void reset (); // quite like tcp RST
		644	void set_cfg (); // to be called after any cfg changes
567		645
568	dns_connection (connection *c);	646	dns_connection (connection *c);
569	~dns_connection ();	647	~dns_connection ();
570	};	648	};
571		649
…		…
602	dns_snd::~dns_snd ()	680	dns_snd::~dns_snd ()
603	{	681	{
604	delete pkt;	682	delete pkt;
605	}	683	}
606		684
		685	static void
607	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	686	append_domain (dns_packet &pkt, int &offs, const char *domain)
608	{	687	{
609	// add tunnel domain	688	// add tunnel domain
610	for (;;)	689	for (;;)
611	{	690	{
612	const char *end = strchr (domain, '.');	691	const char *end = strchr (domain, '.');
…		…
625		704
626	domain = end + 1;	705	domain = end + 1;
627	}	706	}
628	}	707	}
629		708
		709	void
630	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	710	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
631	{	711	{
632	stdhdr = true;	712	stdhdr = true;
633	this->seqno = seqno;	713	this->seqno = seqno;
634		714
635	timeout = ev_now () + INITIAL_TIMEOUT;	715	timeout = ev_now () + INITIAL_TIMEOUT;
…		…
643	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	723	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
644		724
645	char enc[256], *encp = enc;	725	char enc[256], *encp = enc;
646	encode_header (enc, THISNODE->id, seqno);	726	encode_header (enc, THISNODE->id, seqno);
647		727
648	int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);	728	int datalen = dns->cdc->decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
649		729
650	if (datalen > stream.size ())	730	if (datalen > stream.size ())
651	datalen = stream.size ();	731	datalen = stream.size ();
652		732
653	int enclen = cdc62.encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;	733	int enclen = dns->cdc->encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
654	stream.remove (datalen);	734	stream.remove (datalen);
655		735
656	while (enclen)	736	while (enclen)
657	{	737	{
658	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;	738	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
…		…
673	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	753	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
674		754
675	pkt->len = offs;	755	pkt->len = offs;
676	}	756	}
677		757
		758	void
678	void dns_snd::gen_syn_req ()	759	dns_snd::gen_syn_req ()
679	{	760	{
680	timeout = ev_now () + INITIAL_SYN_TIMEOUT;	761	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
681		762
682	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	763	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
683	pkt->qdcount = htons (1);	764	pkt->qdcount = htons (1);
…		…
725		806
726	dns_connection::dns_connection (connection *c)	807	dns_connection::dns_connection (connection *c)
727	: c (c)	808	: c (c)
728	, rcvdq (MAX_BACKLOG * 2)	809	, rcvdq (MAX_BACKLOG * 2)
729	, snddq (MAX_BACKLOG)	810	, snddq (MAX_BACKLOG)
730	, tw (this, &dns_connection::time_cb)
731	{	811	{
		812	tw.set<dns_connection, &dns_connection::time_cb> (this);
		813
732	vpn = c->vpn;	814	vpn = c->vpn;
733		815
		816	reset ();
		817	}
		818
		819	dns_connection::~dns_connection ()
		820	{
		821	reset ();
		822	}
		823
		824	void
		825	dns_connection::reset ()
		826	{
		827	while (!rcvpq.empty ())
		828	{
		829	delete rcvpq.back ();
		830	rcvpq.pop_back ();
		831	}
		832
		833	for (int i = vpn->dns_sndpq.size (); i--; )
		834	if (vpn->dns_sndpq [i]->dns == this)
		835	{
		836	vpn->dns_sndpq [i] = vpn->dns_sndpq.back ();
		837	vpn->dns_sndpq.pop_back ();
		838	}
		839
734	established = false;	840	established = false;
735		841
736	rcvseq = repseq = sndseq = 0;	842	rcvseq = repseq = sndseq = 0;
737		843
738	last_sent = last_received = 0;	844	last_sent = 0;
739	poll_interval = 0.5; // starting here	845	poll_interval = 0.5; // starting here
740	send_interval = 0.5; // starting rate	846	send_interval = 0.5; // starting rate
741	min_latency = INITIAL_TIMEOUT;	847	min_latency = INITIAL_TIMEOUT;
742	}	848	}
743		849
744	dns_connection::~dns_connection ()	850	void
		851	dns_connection::set_cfg ()
745	{	852	{
746	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	853	cdc = cfg.req_cdc == 36 ? &cdc36 : &cdc62;
747	i != rcvpq.end ();
748	++i)
749	delete *i;
750	}	854	}
751		855
		856	void
752	void dns_connection::receive_rep (dns_rcv *r)	857	dns_connection::receive_rep (dns_rcv *r)
753	{	858	{
754	if (r->datalen)	859	if (r->datalen)
755	{	860	poll_interval = max (poll_interval * (1. / 1.2), MIN_POLL_INTERVAL);
756	last_received = ev_now ();
757	tw ();
758
759	poll_interval = send_interval;
760	}
761	else	861	else
762	{	862	poll_interval = min (poll_interval * 1.1, MAX_POLL_INTERVAL);
763	poll_interval *= 1.5;
764
765	if (poll_interval > MAX_POLL_INTERVAL)
766	poll_interval = MAX_POLL_INTERVAL;
767	}
768		863
769	rcvpq.push_back (r);	864	rcvpq.push_back (r);
770		865
771	redo:	866	redo:
772		867
…		…
790		885
791	rcvseq = (rcvseq + 1) & SEQNO_MASK;	886	rcvseq = (rcvseq + 1) & SEQNO_MASK;
792		887
793	if (!rcvdq.put (r->data, r->datalen))	888	if (!rcvdq.put (r->data, r->datalen))
794	{	889	{
		890	// MUST never overflow, can be caused by data corruption, TODO
795	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");	891	slog (L_CRIT, "DNS: !rcvdq.put (r->data, r->datalen)");
796	abort (); // MUST never overflow, can be caused by data corruption, TODO	892	reset ();
		893	return;
797	}	894	}
798		895
799	while (vpn_packet *pkt = rcvdq.get ())	896	while (vpn_packet *pkt = rcvdq.get ())
800	{	897	{
801	sockinfo si;	898	sockinfo si;
802	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;	899	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
803		900
804	vpn->recv_vpn_packet (pkt, si);	901	vpn->recv_vpn_packet (pkt, si);
805
806	delete pkt;	902	delete pkt;
807	}	903	}
808		904
809	// check for further packets	905	// check for further packets
810	goto redo;	906	goto redo;
…		…
853	{	949	{
854	// correct class, domain: parse	950	// correct class, domain: parse
855	int client, seqno;	951	int client, seqno;
856	decode_header (qname, client, seqno);	952	decode_header (qname, client, seqno);
857		953
858	u8 data[MAXSIZE];
859	int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
860
861	if (0 < client && client <= conns.size ())	954	if (0 < client && client <= conns.size ())
862	{	955	{
863	connection *c = conns [client - 1];	956	connection *c = conns [client - 1];
864	dns_connection *dns = c->dns;	957	dns_connection *dns = c->dns;
865	dns_rcv *rcv;	958	dns_rcv *rcv;
866		959
867	if (dns)	960	if (dns)
868	{	961	{
		962	u8 data[MAXSIZE];
		963	int datalen = dns->cdc->decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
		964
869	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	965	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
870	if (SEQNO_EQ ((*i)->seqno, seqno))	966	if (SEQNO_EQ ((*i)->seqno, seqno))
871	{	967	{
872	// already seen that request: simply reply with the cached reply	968	// already seen that request: simply reply with the cached reply
873	dns_rcv r = i;	969	dns_rcv r = i;
…		…
974	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	1070	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
975	pkt [offs++] = 0; pkt [offs++] = 0;	1071	pkt [offs++] = 0; pkt [offs++] = 0;
976	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1072	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
977	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1073	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
978		1074
979	slog (L_INFO, _("DNS: client %d connects"), client);
980
981	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	1075	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
982	pkt [offs++] = CMD_IP_REJ;	1076	pkt [offs++] = CMD_IP_REJ;
983		1077
984	if (0 < client && client <= conns.size ())	1078	if (0 < client && client <= conns.size ())
985	{	1079	{
986	connection *c = conns [client - 1];	1080	connection *c = conns [client - 1];
987		1081
988	if (cfg.valid ())	1082	if (cfg.valid ())
989	{	1083	{
990	pkt [offs - 1] = CMD_IP_SYN;	1084	slog (L_INFO, _("DNS: client %d connects (version %d, req_cdc %d)"), client, cfg.version, cfg.req_cdc);
		1085
		1086	// check for any encoding mismatches - hints at a case problem
		1087	char qname2 [MAX_ENC_LEN];
		1088	cdc26.encode (qname2, (u8 *)&cfg, sizeof (dns_cfg));
991		1089
992	delete c->dns;	1090	delete c->dns;
		1091
		1092	pkt [offs - 1] = memcmp (qname, qname2, cdc26.encode_len (sizeof (dns_cfg)))
		1093	? CMD_IP_CSE : CMD_IP_SYN;
		1094
993	c->dns = new dns_connection (c);	1095	c->dns = new dns_connection (c);
994	c->dns->cfg = cfg;	1096	c->dns->cfg = cfg;
		1097	c->dns->set_cfg ();
995	}	1098	}
996	}	1099	}
997	}	1100	}
998	}	1101	}
999		1102
…		…
1070	ttl \|= pkt [offs++] << 16;	1173	ttl \|= pkt [offs++] << 16;
1071	ttl \|= pkt [offs++] << 8;	1174	ttl \|= pkt [offs++] << 8;
1072	ttl \|= pkt [offs++];	1175	ttl \|= pkt [offs++];
1073	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];	1176	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];
1074		1177
1075	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT)	1178	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT \|\| qtype == dns->cfg.rrtype)
1076	{	1179	{
1077	if (rdlen <= MAXSIZE - offs)	1180	if (rdlen <= MAXSIZE - offs)
1078	{	1181	{
1079	// decode bytes, finally	1182	// decode bytes, finally
1080		1183
…		…
1106	{	1209	{
1107	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);	1210	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1108		1211
1109	if (ip [3] == CMD_IP_RST)	1212	if (ip [3] == CMD_IP_RST)
1110	{	1213	{
1111	slog (L_DEBUG, _("DNS: got tunnel RST request"));	1214	slog (L_DEBUG, _("DNS: got tunnel RST request."));
1112		1215
1113	delete dns; c->dns = 0;	1216	dns->reset ();
1114
1115	return;	1217	return;
1116	}	1218	}
1117	else if (ip [3] == CMD_IP_SYN)	1219	else if (ip [3] == CMD_IP_SYN)
1118	{	1220	{
1119	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));	1221	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1120	dns->established = true;	1222	dns->established = true;
1121	}	1223	}
		1224	else if (ip [3] == CMD_IP_CSE)
		1225	{
		1226	if (conf.dns_case_preserving)
		1227	{
		1228	slog (L_INFO, _("DNS: got tunnel CSE reply, globally downgrading to case-insensitive protocol."));
		1229	conf.dns_case_preserving = false;
		1230	dns->reset ();
		1231	return;
		1232	}
		1233	else
		1234	{
		1235	slog (L_DEBUG, _("DNS: got tunnel CSE reply, server likes us."));
		1236	dns->established = true;
		1237	}
		1238	}
1122	else if (ip [3] == CMD_IP_REJ)	1239	else if (ip [3] == CMD_IP_REJ)
1123	{	1240	{
1124	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));	1241	slog (L_ERR, _("DNS: got tunnel REJ reply, server does not like us."));
1125	abort ();	1242	dns->tw.start (60.);
1126	}	1243	}
1127	else	1244	else
		1245	{
1128	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);	1246	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
		1247	dns->tw.start (60.);
		1248	}
1129	}	1249	}
1130	else	1250	else
1131	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),	1251	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1132	ip [0], ip [1], ip [2], ip [3]);	1252	ip [0], ip [1], ip [2], ip [3]);
1133		1253
…		…
1195		1315
1196	if (!c->dns)	1316	if (!c->dns)
1197	c->dns = new dns_connection (c);	1317	c->dns = new dns_connection (c);
1198		1318
1199	if (c->dns->snddq.put (pkt))	1319	if (c->dns->snddq.put (pkt))
		1320	{
		1321	min_it (c->dns->poll_interval, 0.25);
1200	c->dns->tw ();	1322	c->dns->tw ();
		1323	}
1201		1324
1202	// always return true even if the buffer overflows	1325	// always return true even if the buffer overflows
1203	return true;	1326	return true;
1204	}	1327	}
1205
1206	void
1207	connection::dnsv4_reset_connection ()
1208	{
1209	//delete dns; dns = 0; //TODO
1210	}
1211
1212	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1213		1328
1214	void	1329	void
1215	dns_connection::time_cb (ev::timer &w, int revents)	1330	dns_connection::time_cb (ev::timer &w, int revents)
1216	{	1331	{
1217	// servers have to be polled	1332	// servers have to be polled
1218	if (THISNODE->dns_port)	1333	if (THISNODE->dns_port)
1219	return;	1334	return;
1220		1335
1221	// check for timeouts and (re)transmit	1336	// check for timeouts and (re)transmit
1222	tstamp next = ev::now () + poll_interval;	1337	tstamp next = 86400 * 365;
1223	dns_snd *send = 0;	1338	dns_snd *send = 0;
1224		1339
1225	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1340	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1226	i != vpn->dns_sndpq.end ();	1341	i != vpn->dns_sndpq.end ();
1227	++i)	1342	++i)
…		…
1233	if (!send)	1348	if (!send)
1234	{	1349	{
1235	send = r;	1350	send = r;
1236		1351
1237	r->retry++;	1352	r->retry++;
1238	r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);	1353	r->timeout = ev_now () + r->retry * min_latency * conf.dns_timeout_factor;
1239	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D	1354	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1240		1355
1241	// the following code changes the query section a bit, forcing	1356	// the following code changes the query section a bit, forcing
1242	// the forwarder to generate a new request	1357	// the forwarder to generate a new request
1243	if (r->stdhdr)	1358	if (r->stdhdr)
1244	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);	1359	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1245	}	1360	}
1246	}	1361	}
1247	else	1362	else
1248	NEXT (r->timeout);	1363	min_it (next, r->timeout - ev_now ());
1249	}	1364	}
1250		1365
1251	if (!send)	1366	if (!send)
1252	{	1367	{
1253	// generate a new packet, if wise	1368	// generate a new packet, if wise
…		…
1257	if (vpn->dns_sndpq.empty ())	1372	if (vpn->dns_sndpq.empty ())
1258	{	1373	{
1259	send = new dns_snd (this);	1374	send = new dns_snd (this);
1260		1375
1261	cfg.reset (THISNODE->id);	1376	cfg.reset (THISNODE->id);
		1377	set_cfg ();
1262	send->gen_syn_req ();	1378	send->gen_syn_req ();
1263	}	1379	}
1264	}	1380	}
1265	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding	1381	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1266	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))	1382	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1267	{	1383	{
1268	if (last_sent + send_interval <= ev_now ())	1384	if (last_sent + send_interval <= ev_now ())
1269	{	1385	{
1270	//printf ("sending data request etc.\n"); //D	1386	//printf ("sending data request etc.\n"); //D
1271	if (!snddq.empty () \|\| last_received + 1. > ev_now ())	1387	if (!snddq.empty ())
1272	{
1273	poll_interval = send_interval;	1388	min_it (next, send_interval);
1274	NEXT (ev_now () + send_interval);
1275	}
1276		1389
1277	send = new dns_snd (this);	1390	send = new dns_snd (this);
1278	send->gen_stream_req (sndseq, snddq);	1391	send->gen_stream_req (sndseq, snddq);
1279	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;	1392	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
1280	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D	1393	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1281		1394
1282	sndseq = (sndseq + 1) & SEQNO_MASK;	1395	sndseq = (sndseq + 1) & SEQNO_MASK;
1283	}	1396	}
1284	else	1397	else
1285	NEXT (last_sent + send_interval);	1398	min_it (next, last_sent + send_interval - ev_now ());
1286	}	1399	}
1287		1400
1288	if (send)	1401	if (send)
1289	vpn->dns_sndpq.push_back (send);	1402	vpn->dns_sndpq.push_back (send);
1290	}	1403	}
…		…
1295	sendto (vpn->dnsv4_fd,	1408	sendto (vpn->dnsv4_fd,
1296	send->pkt->at (0), send->pkt->len, 0,	1409	send->pkt->at (0), send->pkt->len, 0,
1297	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1410	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1298	}	1411	}
1299		1412
		1413	min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ());
		1414
1300	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",	1415	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1301	poll_interval, send_interval, next - ev_now (),	1416	poll_interval, send_interval, next - ev_now (),
1302	vpn->dns_sndpq.size (), snddq.size (),	1417	vpn->dns_sndpq.size (), snddq.size (),
1303	rcvpq.size ());	1418	rcvpq.size ());
1304		1419
1305	// TODO: no idea when this happens, but when next < ev_now (), we have a problem	1420	w.start (next);
1306	// doesn't seem to happen anymore
1307	if (next < ev_now () + 0.001)
1308	next = ev_now () + 0.1;
1309
1310	w.start (next - ev_now ());
1311	}	1421	}
1312		1422
1313	#endif	1423	#endif
1314		1424

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.44 by pcg, Tue Dec 4 14:55:59 2007 UTC vs. Revision 1.56 by root, Tue Oct 18 13:24:01 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.44 by pcg, Tue Dec 4 14:55:59 2007 UTC vs.
Revision 1.56 by root, Tue Oct 18 13:24:01 2011 UTC