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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.21 by pcg, Sun Mar 6 21:33:40 2005 UTC vs.
Revision 1.50 by root, Sun Mar 6 13:49:50 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-2008 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
49	#define MIN_POLL_INTERVAL .02 // how often to poll minimally when the server has data
50	#define MAX_POLL_INTERVAL 6. // how often to poll minimally when the server has no data	64	#define MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data
51	#define ACTIVITY_INTERVAL 5.	65	#define ACTIVITY_INTERVAL 5.
52		66
53	#define INITIAL_TIMEOUT 0.1 // retry timeouts	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
54	#define INITIAL_SYN_TIMEOUT 10. // retry timeout for initial syn	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
55		69
56	#define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests
57	#define MAX_SEND_INTERVAL 0.5 // optimistic?	70	#define MAX_SEND_INTERVAL 2. // optimistic?
58		71
59	#define MAX_OUTSTANDING 10 // max. outstanding requests
60	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
61	#define MAX_BACKLOG (100*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
62		74
63	#define MAX_DOMAIN_SIZE 220 // 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
64	// 240 leaves about 4 bytes of server reply data	76	// 240 leaves about 4 bytes of server reply data
65	// every two request bytes less give room for one reply byte	77	// every request byte less give room for two reply bytes
66		78
67	#define SEQNO_MASK 0x3fff	79	#define SEQNO_MASK 0x3fff
68	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )	80	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
69		81
70	#define MAX_LBL_SIZE 63	82	#define MAX_LBL_SIZE 63
71	#define MAX_PKT_SIZE 512	83	#define MAX_PKT_SIZE 512
72		84
73	#define RR_TYPE_A 1	85	#define RR_TYPE_A 1
74	#define RR_TYPE_NULL 10	86	#define RR_TYPE_NULL 10
75	#define RR_TYPE_TXT 16	87	#define RR_TYPE_TXT 16
		88	#define RR_TYPE_AAAA 28
76	#define RR_TYPE_ANY 255	89	#define RR_TYPE_ANY 255
77		90
78	#define RR_CLASS_IN 1	91	#define RR_CLASS_IN 1
79		92
80	#define CMD_IP_1 207	93	#define CMD_IP_1 207
…		…
104	memset (enc, (char) 0, 256);	117	memset (enc, (char) 0, 256);
105	memset (dec, (char)INVALID, 256);	118	memset (dec, (char)INVALID, 256);
106		119
107	for (size = 0; cmap [size]; size++)	120	for (size = 0; cmap [size]; size++)
108	{	121	{
		122	char c = cmap [size];
		123
109	enc [size] = cmap [size];	124	enc [size] = c;
110	dec [(u8)enc [size]] = size;	125	dec [(u8)c] = size;
		126
		127	// allow lowercase/uppercase aliases if possible
		128	if (c >= 'A' && c <= 'Z' && dec [c + ('a' - 'A')] == INVALID) dec [c + ('a' - 'A')] = size;
		129	if (c >= 'a' && c <= 'z' && dec [c - ('a' - 'A')] == INVALID) dec [c - ('a' - 'A')] = size;
111	}	130	}
112		131
113	assert (size < 256);	132	assert (size < 256);
114	}	133	}
115		134
…		…
155	enc_len [len] = n;	174	enc_len [len] = n;
156	dec_len [n] = len;	175	dec_len [n] = len;
157	}	176	}
158	}	177	}
159		178
		179	unsigned int
160	unsigned int basecoder::encode_len (unsigned int len)	180	basecoder::encode_len (unsigned int len)
161	{	181	{
162	return enc_len [len];	182	return enc_len [len];
163	}	183	}
164		184
		185	unsigned int
165	unsigned int basecoder::decode_len (unsigned int len)	186	basecoder::decode_len (unsigned int len)
166	{	187	{
167	while (len && !dec_len [len])	188	while (len && !dec_len [len])
168	--len;	189	--len;
169		190
170	return dec_len [len];	191	return dec_len [len];
171	}	192	}
172		193
		194	unsigned int
173	unsigned int basecoder::encode (char dst, u8 src, unsigned int len)	195	basecoder::encode (char dst, u8 src, unsigned int len)
174	{	196	{
175	if (!len \|\| len > MAX_DEC_LEN)	197	if (!len \|\| len > MAX_DEC_LEN)
176	return 0;	198	return 0;
177		199
178	int elen = encode_len (len);	200	int elen = encode_len (len);
…		…
197	*dst++ = cmap.encode [dst_ [i]];	219	*dst++ = cmap.encode [dst_ [i]];
198		220
199	return elen;	221	return elen;
200	}	222	}
201		223
		224	unsigned int
202	unsigned int basecoder::decode (u8 dst, char src, unsigned int len)	225	basecoder::decode (u8 dst, char src, unsigned int len)
203	{	226	{
204	if (!len \|\| len > MAX_ENC_LEN)	227	if (!len \|\| len > MAX_ENC_LEN)
205	return 0;	228	return 0;
206		229
207	u8 src_ [MAX_ENC_LEN];	230	u8 src_ [MAX_ENC_LEN];
…		…
265	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	288	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
266		289
267	/////////////////////////////////////////////////////////////////////////////	290	/////////////////////////////////////////////////////////////////////////////
268		291
269	#define HDRSIZE 6	292	#define HDRSIZE 6
270		293
		294	inline void
271	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)	295	encode_header (char *data, int clientid, int seqno, int retry = 0)
272	{	296	{
273	seqno &= SEQNO_MASK;	297	seqno &= SEQNO_MASK;
274		298
275	u8 hdr[3] = {	299	u8 hdr[3] = {
276	clientid,	300	clientid,
…		…
281	assert (clientid < 256);	305	assert (clientid < 256);
282		306
283	cdc26.encode (data, hdr, 3);	307	cdc26.encode (data, hdr, 3);
284	}	308	}
285		309
		310	inline void
286	inline void decode_header (char *data, int &clientid, int &seqno)	311	decode_header (char *data, int &clientid, int &seqno)
287	{	312	{
288	u8 hdr[3];	313	u8 hdr[3];
289		314
290	cdc26.decode (hdr, data, HDRSIZE);	315	cdc26.decode (hdr, data, HDRSIZE);
291		316
…		…
324	byte_stream::~byte_stream ()	349	byte_stream::~byte_stream ()
325	{	350	{
326	delete data;	351	delete data;
327	}	352	}
328		353
		354	void
329	void byte_stream::remove (int count)	355	byte_stream::remove (int count)
330	{	356	{
331	if (count > fill)	357	if (count > fill)
332	assert (count <= fill);	358	assert (count <= fill);
333		359
334	memmove (data, data + count, fill -= count);	360	memmove (data, data + count, fill -= count);
335	}	361	}
336		362
		363	bool
337	bool byte_stream::put (u8 *data, unsigned int datalen)	364	byte_stream::put (u8 *data, unsigned int datalen)
338	{	365	{
339	if (maxsize - fill < datalen)	366	if (maxsize - fill < datalen)
340	return false;	367	return false;
341		368
342	memcpy (this->data + fill, data, datalen); fill += datalen;	369	memcpy (this->data + fill, data, datalen); fill += datalen;
343		370
344	return true;	371	return true;
345	}	372	}
346		373
		374	bool
347	bool byte_stream::put (vpn_packet *pkt)	375	byte_stream::put (vpn_packet *pkt)
348	{	376	{
349	if (maxsize - fill < pkt->len + 2)	377	if (maxsize - fill < pkt->len + 2)
350	return false;	378	return false;
351		379
352	data [fill++] = pkt->len >> 8;	380	data [fill++] = pkt->len >> 8;
…		…
409	struct dns_cfg	437	struct dns_cfg
410	{	438	{
411	static int next_uid;	439	static int next_uid;
412		440
413	u8 id1, id2, id3, id4;	441	u8 id1, id2, id3, id4;
		442
414	u8 version;	443	u8 version;
		444	u8 flags;
415	u8 rrtype;	445	u8 rrtype;
416	u8 flags;
417	u8 def_ttl;	446	u8 def_ttl;
418	u8 rcv_cdc;	447
419	u8 snd_cdc;
420	u16 max_size;
421	u16 client;	448	u16 client;
422	u16 uid; // to make request unique	449	u16 uid; // to make request unique
423		450
424	u8 reserved[8];	451	u16 max_size;
		452	u8 seq_cdc;
		453	u8 req_cdc;
		454
		455	u8 rep_cdc;
		456	u8 delay; // time in 0.01s units that the server may delay replying packets
		457	u8 r3, r4;
		458
		459	u8 r5, r6, r7, r8;
425		460
426	void reset (int clientid);	461	void reset (int clientid);
427	bool valid ();	462	bool valid ();
428	};	463	};
429		464
430	int dns_cfg::next_uid;	465	int dns_cfg::next_uid;
431		466
		467	void
432	void dns_cfg::reset (int clientid)	468	dns_cfg::reset (int clientid)
433	{	469	{
434	id1 = 'G';	470	id1 = 'G';
435	id2 = 'V';	471	id2 = 'V';
436	id3 = 'P';	472	id3 = 'P';
437	id4 = 'E';	473	id4 = 'E';
438		474
439	version = 1;	475	version = 1;
440		476
441	rrtype = RR_TYPE_TXT;	477	rrtype = RR_TYPE_TXT;
442	flags = 0;	478	flags = 0;
443	def_ttl = 1;	479	def_ttl = 0;
		480	seq_cdc = 26;
		481	req_cdc = 62;
444	rcv_cdc = 0;	482	rep_cdc = 0;
445	snd_cdc = 62;
446	max_size = ntohs (MAX_PKT_SIZE);	483	max_size = htons (MAX_PKT_SIZE);
447	client = ntohs (clientid);	484	client = htons (clientid);
448	uid = next_uid++;	485	uid = next_uid++;
		486	delay = 0;
449		487
450	memset (reserved, 0, 8);	488	r3 = r4 = 0;
		489	r4 = r5 = r6 = r7 = 0;
451	}	490	}
452		491
		492	bool
453	bool dns_cfg::valid ()	493	dns_cfg::valid ()
454	{	494	{
		495	// although the protocol itself allows for some configurability,
		496	// only the following encoding/decoding settings are implemented.
455	return id1 == 'G'	497	return id1 == 'G'
456	&& id2 == 'V'	498	&& id2 == 'V'
457	&& id3 == 'P'	499	&& id3 == 'P'
458	&& id4 == 'E'	500	&& id4 == 'E'
		501	&& seq_cdc == 26
		502	&& req_cdc == 62
		503	&& rep_cdc == 0
459	&& version == 1	504	&& version == 1;
460	&& flags == 0
461	&& rcv_cdc == 0
462	&& snd_cdc == 62
463	&& max_size == ntohs (MAX_PKT_SIZE);
464	}	505	}
465		506
466	struct dns_packet : net_packet	507	struct dns_packet : net_packet
467	{	508	{
468	u16 id;	509	u16 id;
469	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4	510	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
470	u16 qdcount, ancount, nscount, arcount;	511	u16 qdcount, ancount, nscount, arcount;
471		512
472	u8 data[MAXSIZE - 6 * 2];	513	u8 data [MAXSIZE - 6 * 2];
473		514
474	int decode_label (char *data, int size, int &offs);	515	int decode_label (char *data, int size, int &offs);
475	};	516	};
476		517
		518	int
477	int dns_packet::decode_label (char *data, int size, int &offs)	519	dns_packet::decode_label (char *data, int size, int &offs)
478	{	520	{
479	char *orig = data;	521	char *orig = data;
480		522
481	memset (data, 0, size);	523	memset (data, 0, size);
482		524
…		…
508	return data - orig;	550	return data - orig;
509	}	551	}
510		552
511	/////////////////////////////////////////////////////////////////////////////	553	/////////////////////////////////////////////////////////////////////////////
512		554
		555	static
		556	u16 next_id ()
		557	{
513	static u16 dns_id = 0; // TODO: should be per-vpn	558	static u16 dns_id = 0; // TODO: should be per-vpn
514		559
515	static u16 next_id ()
516	{
517	if (!dns_id)	560	if (!dns_id)
518	dns_id = time (0);	561	dns_id = time (0);
519		562
520	// the simplest lsfr with periodicity 65535 i could find	563	// the simplest lsfr with periodicity 65535 i could find
521	dns_id = (dns_id << 1)	564	dns_id = (dns_id << 1)
…		…
539		582
540	bool established;	583	bool established;
541		584
542	tstamp last_received;	585	tstamp last_received;
543	tstamp last_sent;	586	tstamp last_sent;
544	double last_latency;	587	double min_latency;
545	double poll_interval, send_interval;	588	double poll_interval, send_interval;
546		589
547	vector<dns_rcv *> rcvpq;	590	vector<dns_rcv *> rcvpq;
548		591
549	byte_stream rcvdq; int rcvseq;	592	byte_stream rcvdq; int rcvseq; int repseq;
550	byte_stream snddq; int sndseq;	593	byte_stream snddq; int sndseq;
551		594
552	void time_cb (time_watcher &w); time_watcher tw;	595	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
553	void receive_rep (dns_rcv *r);	596	void receive_rep (dns_rcv *r);
554		597
555	dns_connection (connection *c);	598	dns_connection (connection *c);
556	~dns_connection ();	599	~dns_connection ();
557	};	600	};
…		…
576	: dns (dns)	619	: dns (dns)
577	{	620	{
578	timeout = 0;	621	timeout = 0;
579	retry = 0;	622	retry = 0;
580	seqno = 0;	623	seqno = 0;
581	sent = NOW;	624	sent = ev_now ();
582	stdhdr = false;	625	stdhdr = false;
583		626
584	pkt = new dns_packet;	627	pkt = new dns_packet;
585		628
586	pkt->id = next_id ();	629	pkt->id = next_id ();
…		…
589	dns_snd::~dns_snd ()	632	dns_snd::~dns_snd ()
590	{	633	{
591	delete pkt;	634	delete pkt;
592	}	635	}
593		636
		637	static void
594	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	638	append_domain (dns_packet &pkt, int &offs, const char *domain)
595	{	639	{
596	// add tunnel domain	640	// add tunnel domain
597	for (;;)	641	for (;;)
598	{	642	{
599	const char *end = strchr (domain, '.');	643	const char *end = strchr (domain, '.');
…		…
612		656
613	domain = end + 1;	657	domain = end + 1;
614	}	658	}
615	}	659	}
616		660
		661	void
617	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	662	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
618	{	663	{
619	stdhdr = true;	664	stdhdr = true;
620	this->seqno = seqno;	665	this->seqno = seqno;
621		666
622	timeout = NOW + INITIAL_TIMEOUT;	667	timeout = ev_now () + INITIAL_TIMEOUT;
623		668
624	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	669	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
625	pkt->qdcount = htons (1);	670	pkt->qdcount = htons (1);
626		671
627	int offs = 6*2;	672	int offs = 6*2;
…		…
660	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	705	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
661		706
662	pkt->len = offs;	707	pkt->len = offs;
663	}	708	}
664		709
		710	void
665	void dns_snd::gen_syn_req ()	711	dns_snd::gen_syn_req ()
666	{	712	{
667	timeout = NOW + INITIAL_SYN_TIMEOUT;	713	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
668
669	printf ("send syn\n");//D
670		714
671	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	715	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
672	pkt->qdcount = htons (1);	716	pkt->qdcount = htons (1);
673		717
674	int offs = 6 * 2;	718	int offs = 6 * 2;
…		…
713	/////////////////////////////////////////////////////////////////////////////	757	/////////////////////////////////////////////////////////////////////////////
714		758
715	dns_connection::dns_connection (connection *c)	759	dns_connection::dns_connection (connection *c)
716	: c (c)	760	: c (c)
717	, rcvdq (MAX_BACKLOG * 2)	761	, rcvdq (MAX_BACKLOG * 2)
718	, snddq (MAX_BACKLOG * 2)	762	, snddq (MAX_BACKLOG)
719	, tw (this, &dns_connection::time_cb)
720	{	763	{
		764	tw.set<dns_connection, &dns_connection::time_cb> (this);
		765
721	vpn = c->vpn;	766	vpn = c->vpn;
722		767
723	established = false;	768	established = false;
724		769
725	rcvseq = sndseq = 0;	770	rcvseq = repseq = sndseq = 0;
726		771
727	last_sent = last_received = 0;	772	last_sent = last_received = 0;
728	poll_interval = MIN_POLL_INTERVAL;	773	poll_interval = 0.5; // starting here
729	send_interval = 0.5; // starting rate	774	send_interval = 0.5; // starting rate
730	last_latency = INITIAL_TIMEOUT;	775	min_latency = INITIAL_TIMEOUT;
731	}	776	}
732		777
733	dns_connection::~dns_connection ()	778	dns_connection::~dns_connection ()
734	{	779	{
735	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	780	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
736	i != rcvpq.end ();	781	i != rcvpq.end ();
737	++i)	782	++i)
738	delete *i;	783	delete *i;
739	}	784	}
740		785
		786	void
741	void dns_connection::receive_rep (dns_rcv *r)	787	dns_connection::receive_rep (dns_rcv *r)
742	{	788	{
743	if (r->datalen)	789	if (r->datalen)
744	{	790	{
745	last_received = NOW;	791	last_received = ev_now ();
746	tw.trigger ();	792	tw ();
747		793
748	poll_interval = send_interval;	794	poll_interval = send_interval;
749	}	795	}
750	else	796	else
751	{	797	{
752	poll_interval *= 1.5;	798	poll_interval *= 1.5;
		799
753	if (poll_interval > MAX_POLL_INTERVAL)	800	if (poll_interval > MAX_POLL_INTERVAL)
754	poll_interval = MAX_POLL_INTERVAL;	801	poll_interval = MAX_POLL_INTERVAL;
755	}	802	}
756		803
757	rcvpq.push_back (r);	804	rcvpq.push_back (r);
…		…
760		807
761	// find next packet	808	// find next packet
762	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	809	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
763	if (SEQNO_EQ (rcvseq, (*i)->seqno))	810	if (SEQNO_EQ (rcvseq, (*i)->seqno))
764	{	811	{
		812	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
765	// enter the packet into our input stream	813	// enter the packet into our input stream
766	r = *i;	814	r = *i;
767		815
768	// remove the oldest packet, look forward, as it's oldest first	816	// remove the oldest packet, look forward, as it's oldest first
769	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	817	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
770	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	818	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
771	{	819	{
		820	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
772	delete *j;	821	delete *j;
773	rcvpq.erase (j);	822	rcvpq.erase (j);
774	break;	823	break;
775	}	824	}
776		825
777	rcvseq = (rcvseq + 1) & SEQNO_MASK;	826	rcvseq = (rcvseq + 1) & SEQNO_MASK;
778		827
779	if (!rcvdq.put (r->data, r->datalen))	828	if (!rcvdq.put (r->data, r->datalen))
780	{	829	{
		830	// MUST never overflow, can be caused by data corruption, TODO
781	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");	831	slog (L_CRIT, "DNS: !rcvdq.put (r->data, r->datalen)");
782	abort (); // MUST never overflow, can be caused by data corruption, TODO	832	c->dnsv4_reset_connection ();
		833	return;
783	}	834	}
784		835
785	while (vpn_packet *pkt = rcvdq.get ())	836	while (vpn_packet *pkt = rcvdq.get ())
786	{	837	{
787	sockinfo si;	838	sockinfo si;
788	si.host = 0x01010101; si.port = htons (c->conf->id); si.prot = PROT_DNSv4;	839	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
789		840
790	vpn->recv_vpn_packet (pkt, si);	841	vpn->recv_vpn_packet (pkt, si);
791
792	delete pkt;	842	delete pkt;
793	}	843	}
794		844
795	// check for further packets	845	// check for further packets
796	goto redo;	846	goto redo;
…		…
807	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	857	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
808		858
809	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	859	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
810	&& pkt.qdcount == htons (1))	860	&& pkt.qdcount == htons (1))
811	{	861	{
812	char qname[MAXSIZE];	862	char qname [MAXSIZE];
813	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	863	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
814		864
815	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	865	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
816	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	866	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
817		867
…		…
824		874
825	int dlen = strlen (THISNODE->domain);	875	int dlen = strlen (THISNODE->domain);
826		876
827	if (qclass == RR_CLASS_IN	877	if (qclass == RR_CLASS_IN
828	&& qlen > dlen + 1	878	&& qlen > dlen + 1
829	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	879	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
830	{	880	{
831	// now generate reply	881	// now generate reply
832	pkt.ancount = htons (1); // one answer RR	882	pkt.ancount = htons (1); // one answer RR
833	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	883	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
834		884
…		…
847	if (0 < client && client <= conns.size ())	897	if (0 < client && client <= conns.size ())
848	{	898	{
849	connection *c = conns [client - 1];	899	connection *c = conns [client - 1];
850	dns_connection *dns = c->dns;	900	dns_connection *dns = c->dns;
851	dns_rcv *rcv;	901	dns_rcv *rcv;
852	bool in_seq;
853		902
854	if (dns)	903	if (dns)
855	{	904	{
856	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	905	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
857	if (SEQNO_EQ ((*i)->seqno, seqno))	906	if (SEQNO_EQ ((*i)->seqno, seqno))
…		…
868	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	917	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
869		918
870	goto duplicate_request;	919	goto duplicate_request;
871	}	920	}
872		921
873	in_seq = dns->rcvseq == seqno;
874
875	// new packet, queue	922	// new packet, queue
876	rcv = new dns_rcv (seqno, data, datalen);	923	rcv = new dns_rcv (seqno, data, datalen);
877	dns->receive_rep (rcv);	924	dns->receive_rep (rcv);
878	}	925	}
879		926
…		…
886	pkt [offs++] = 0; pkt [offs++] = 0;	933	pkt [offs++] = 0; pkt [offs++] = 0;
887	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL	934	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
888		935
889	int rdlen_offs = offs += 2;	936	int rdlen_offs = offs += 2;
890		937
891	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;
892	// bind doesn't compress well, so reduce further by one label length
893	dlen -= qlen;
894
895	if (dns)	938	if (dns)
896	{	939	{
		940	int dlen = ntohs (dns->cfg.max_size) - offs;
		941
		942	// bind doesn't compress well, so reduce further by one label length
		943	dlen -= qlen;
		944
897	// only put data into in-order sequence packets, if	945	// only put data into in-order sequence packets, if
898	// we receive out-of-order packets we generate empty	946	// we receive out-of-order packets we generate empty
899	// replies	947	// replies
900	while (dlen > 1 && !dns->snddq.empty () && in_seq)	948	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		949	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
901	{	950	{
		951	dns->repseq = seqno;
		952
		953	while (dlen > 1 && !dns->snddq.empty ())
		954	{
902	int txtlen = dlen <= 255 ? dlen - 1 : 255;	955	int txtlen = dlen <= 255 ? dlen - 1 : 255;
903		956
904	if (txtlen > dns->snddq.size ())	957	if (txtlen > dns->snddq.size ())
905	txtlen = dns->snddq.size ();	958	txtlen = dns->snddq.size ();
906		959
907	pkt[offs++] = txtlen;	960	pkt[offs++] = txtlen;
908	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	961	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
909	offs += txtlen;	962	offs += txtlen;
910	dns->snddq.remove (txtlen);	963	dns->snddq.remove (txtlen);
911		964
912	dlen -= txtlen + 1;	965	dlen -= txtlen + 1;
		966	}
913	}	967	}
914		968
915	// avoid empty TXT rdata	969	// avoid completely empty TXT rdata
916	if (offs == rdlen_offs)	970	if (offs == rdlen_offs)
917	pkt[offs++] = 0;	971	pkt[offs++] = 0;
918		972
919	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());	973	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
920	}	974	}
…		…
956	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	1010	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
957	pkt [offs++] = 0; pkt [offs++] = 0;	1011	pkt [offs++] = 0; pkt [offs++] = 0;
958	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1012	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
959	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1013	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
960		1014
961	slog (L_INFO, _("DNS: client %d tries to connect"), client);	1015	slog (L_INFO, _("DNS: client %d connects"), client);
962		1016
963	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	1017	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
964	pkt [offs++] = CMD_IP_REJ;	1018	pkt [offs++] = CMD_IP_REJ;
965		1019
966	if (0 < client && client <= conns.size ())	1020	if (0 < client && client <= conns.size ())
…		…
1000	{	1054	{
1001	dns_connection dns = (i)->dns;	1055	dns_connection dns = (i)->dns;
1002	connection *c = dns->c;	1056	connection *c = dns->c;
1003	int seqno = (*i)->seqno;	1057	int seqno = (*i)->seqno;
1004	u8 data[MAXSIZE], *datap = data;	1058	u8 data[MAXSIZE], *datap = data;
		1059	//printf ("rcv pkt %x\n", seqno);//D
1005		1060
1006	if ((*i)->retry)	1061	if ((*i)->retry)
1007	{	1062	{
1008	dns->send_interval *= 1.01;	1063	dns->send_interval *= 1.01;
1009	if (dns->send_interval > MAX_SEND_INTERVAL)	1064	if (dns->send_interval > MAX_SEND_INTERVAL)
1010	dns->send_interval = MAX_SEND_INTERVAL;	1065	dns->send_interval = MAX_SEND_INTERVAL;
1011	}	1066	}
1012	else	1067	else
1013	{	1068	{
1014	#if 1	1069	#if 0
1015	dns->send_interval *= 0.999;	1070	dns->send_interval *= 0.999;
1016	#endif	1071	#endif
1017	if (dns->send_interval < MIN_SEND_INTERVAL)
1018	dns->send_interval = MIN_SEND_INTERVAL;
1019
1020	// the latency surely puts an upper bound on	1072	// the latency surely puts an upper bound on
1021	// the minimum send interval	1073	// the minimum send interval
1022	double latency = NOW - (*i)->sent;	1074	double latency = ev_now () - (*i)->sent;
		1075
		1076	if (latency < dns->min_latency)
1023	dns->last_latency = latency;	1077	dns->min_latency = latency;
1024		1078
1025	if (dns->send_interval > latency)	1079	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1080	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1081
		1082	if (dns->send_interval < conf.dns_send_interval)
1026	dns->send_interval = latency;	1083	dns->send_interval = conf.dns_send_interval;
1027	}	1084	}
1028		1085
1029	delete *i;	1086	delete *i;
1030	dns_sndpq.erase (i);	1087	dns_sndpq.erase (i);
1031		1088
…		…
1087		1144
1088	if (ip [3] == CMD_IP_RST)	1145	if (ip [3] == CMD_IP_RST)
1089	{	1146	{
1090	slog (L_DEBUG, _("DNS: got tunnel RST request"));	1147	slog (L_DEBUG, _("DNS: got tunnel RST request"));
1091		1148
1092	delete dns; c->dns = 0;	1149	c->dnsv4_reset_connection ();
1093
1094	return;
1095	}	1150	}
1096	else if (ip [3] == CMD_IP_SYN)	1151	else if (ip [3] == CMD_IP_SYN)
1097	{	1152	{
1098	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));	1153	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1099	dns->established = true;	1154	dns->established = true;
1100	}	1155	}
1101	else if (ip [3] == CMD_IP_REJ)	1156	else if (ip [3] == CMD_IP_REJ)
1102	{
1103	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));	1157	slog (L_ERR, _("DNS: got tunnel REJ reply, server does not like us."));
1104	abort ();
1105	}
1106	else	1158	else
1107	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);	1159	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1108	}	1160	}
1109	else	1161	else
1110	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),	1162	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
…		…
1136	break;	1188	break;
1137	}	1189	}
1138	}	1190	}
1139		1191
1140	void	1192	void
1141	vpn::dnsv4_ev (io_watcher &w, short revents)	1193	vpn::dnsv4_ev (ev::io &w, int revents)
1142	{	1194	{
1143	if (revents & EVENT_READ)	1195	if (revents & EV_READ)
1144	{	1196	{
1145	dns_packet *pkt = new dns_packet;	1197	dns_packet *pkt = new dns_packet;
1146	struct sockaddr_in sa;	1198	struct sockaddr_in sa;
1147	socklen_t sa_len = sizeof (sa);	1199	socklen_t sa_len = sizeof (sa);
1148		1200
1149	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);	1201	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1150		1202
1151	if (pkt->len > 0)	1203	if (pkt->len > 0)
1152	{	1204	{
1153	if (THISNODE->dns_port)	1205	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1206	dnsv4_client (*pkt);
		1207	else
1154	{	1208	{
1155	dnsv4_server (*pkt);	1209	dnsv4_server (*pkt);
1156	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);	1210	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1157	}	1211	}
1158	else
1159	dnsv4_client (*pkt);
1160		1212
1161	delete pkt;	1213	delete pkt;
1162	}	1214	}
1163	}	1215	}
1164	}	1216	}
1165		1217
1166	bool	1218	bool
1167	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1219	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1168	{	1220	{
1169	int client = ntohs (si.port);	1221	int client = ntohl (si.host);
1170		1222
1171	assert (0 < client && client <= conns.size ());	1223	assert (0 < client && client <= conns.size ());
1172		1224
1173	connection *c = conns [client - 1];	1225	connection *c = conns [client - 1];
1174		1226
1175	if (!c->dns)	1227	if (!c->dns)
1176	c->dns = new dns_connection (c);	1228	c->dns = new dns_connection (c);
1177		1229
1178	if (!c->dns->snddq.put (pkt))	1230	if (c->dns->snddq.put (pkt))
1179	return false;
1180
1181	c->dns->tw.trigger ();	1231	c->dns->tw ();
1182		1232
		1233	// always return true even if the buffer overflows
1183	return true;	1234	return true;
1184	}	1235	}
1185		1236
1186	void	1237	void
1187	connection::dnsv4_reset_connection ()	1238	connection::dnsv4_reset_connection ()
…		…
1190	}	1241	}
1191		1242
1192	#define NEXT(w) do { if (next > (w)) next = w; } while (0)	1243	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1193		1244
1194	void	1245	void
1195	dns_connection::time_cb (time_watcher &w)	1246	dns_connection::time_cb (ev::timer &w, int revents)
1196	{	1247	{
1197	// servers have to be polled	1248	// servers have to be polled
1198	if (THISNODE->dns_port)	1249	if (THISNODE->dns_port)
1199	return;	1250	return;
1200		1251
1201	// check for timeouts and (re)transmit	1252	// check for timeouts and (re)transmit
1202	tstamp next = NOW + poll_interval;	1253	tstamp next = ev::now () + poll_interval;
1203	dns_snd *send = 0;	1254	dns_snd *send = 0;
1204		1255
1205	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1256	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1206	i != vpn->dns_sndpq.end ();	1257	i != vpn->dns_sndpq.end ();
1207	++i)	1258	++i)
1208	{	1259	{
1209	dns_snd r = i;	1260	dns_snd r = i;
1210		1261
1211	if (r->timeout <= NOW)	1262	if (r->timeout <= ev_now ())
1212	{	1263	{
1213	if (!send)	1264	if (!send)
1214	{	1265	{
1215	send = r;	1266	send = r;
1216		1267
1217	r->retry++;	1268	r->retry++;
1218	r->timeout = NOW + (r->retry * last_latency * 8.);	1269	r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
		1270	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1219		1271
1220	// the following code changes the query section a bit, forcing	1272	// the following code changes the query section a bit, forcing
1221	// the forwarder to generate a new request	1273	// the forwarder to generate a new request
1222	if (r->stdhdr)	1274	if (r->stdhdr)
1223	{
1224	//printf ("reencoded header for ID %d retry %d:%d:%d\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);printf ("reencoded header for ID %d retry %d:%d:%d\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);
1225	//encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);	1275	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1226	}
1227	}	1276	}
1228	}	1277	}
1229	else	1278	else
1230	NEXT (r->timeout);	1279	NEXT (r->timeout);
1231	}	1280	}
1232		1281
1233	if (last_sent + send_interval <= NOW)
1234	{
1235	if (!send)	1282	if (!send)
		1283	{
		1284	// generate a new packet, if wise
		1285
		1286	if (!established)
1236	{	1287	{
1237	// generate a new packet, if wise	1288	if (vpn->dns_sndpq.empty ())
1238
1239	if (!established)
1240	{	1289	{
1241	if (vpn->dns_sndpq.empty ())
1242	{
1243	send = new dns_snd (this);	1290	send = new dns_snd (this);
1244		1291
1245	printf ("new conn %p %d\n", this, c->conf->id);//D
1246	cfg.reset (THISNODE->id);	1292	cfg.reset (THISNODE->id);
1247	send->gen_syn_req ();	1293	send->gen_syn_req ();
1248	}
1249	}	1294	}
1250	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING	1295	}
		1296	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1251	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))	1297	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1298	{
		1299	if (last_sent + send_interval <= ev_now ())
1252	{	1300	{
1253	//printf ("sending data request etc.\n"); //D	1301	//printf ("sending data request etc.\n"); //D
1254	if (!snddq.empty ())	1302	if (!snddq.empty () \|\| last_received + 1. > ev_now ())
1255	{	1303	{
1256	poll_interval = send_interval;	1304	poll_interval = send_interval;
1257	NEXT (NOW + send_interval);	1305	NEXT (ev_now () + send_interval);
1258	}	1306	}
1259		1307
1260	send = new dns_snd (this);	1308	send = new dns_snd (this);
1261	send->gen_stream_req (sndseq, snddq);	1309	send->gen_stream_req (sndseq, snddq);
1262	send->timeout = NOW + last_latency * 8.;	1310	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1311	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1263		1312
1264	sndseq = (sndseq + 1) & SEQNO_MASK;	1313	sndseq = (sndseq + 1) & SEQNO_MASK;
1265	}	1314	}
1266		1315	else
1267	if (send)	1316	NEXT (last_sent + send_interval);
1268	vpn->dns_sndpq.push_back (send);
1269	}	1317	}
1270		1318
1271	if (send)	1319	if (send)
1272	{	1320	vpn->dns_sndpq.push_back (send);
1273	last_sent = NOW;	1321	}
		1322
		1323	if (send)
		1324	{
		1325	last_sent = ev_now ();
1274	sendto (vpn->dnsv4_fd,	1326	sendto (vpn->dnsv4_fd,
1275	send->pkt->at (0), send->pkt->len, 0,	1327	send->pkt->at (0), send->pkt->len, 0,
1276	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1328	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1277	}
1278	}	1329	}
1279	else
1280	NEXT (last_sent + send_interval);
1281		1330
1282	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d)",	1331	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1283	poll_interval, send_interval, next - NOW,	1332	poll_interval, send_interval, next - ev_now (),
1284	vpn->dns_sndpq.size (), snddq.size ());	1333	vpn->dns_sndpq.size (), snddq.size (),
		1334	rcvpq.size ());
1285		1335
1286	// TODO: no idea when this happens, but when next < NOW, we have a problem	1336	// TODO: no idea when this happens, but when next < ev_now (), we have a problem
		1337	// doesn't seem to happen anymore
1287	if (next < NOW + 0.0001)	1338	if (next < ev_now () + 0.001)
1288	next = NOW + 0.1;	1339	next = ev_now () + 0.1;
1289		1340
1290	w.start (next);	1341	w.start (next - ev_now ());
1291	}	1342	}
1292		1343
1293	#endif	1344	#endif
1294		1345

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.21 by pcg, Sun Mar 6 21:33:40 2005 UTC vs. Revision 1.50 by root, Sun Mar 6 13:49:50 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.21 by pcg, Sun Mar 6 21:33:40 2005 UTC vs.
Revision 1.50 by root, Sun Mar 6 13:49:50 2011 UTC