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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.20 by pcg, Sun Mar 6 21:32:15 2005 UTC vs.
Revision 1.49 by root, Tue Feb 8 23:11:36 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
…		…
155	enc_len [len] = n;	168	enc_len [len] = n;
156	dec_len [n] = len;	169	dec_len [n] = len;
157	}	170	}
158	}	171	}
159		172
		173	unsigned int
160	unsigned int basecoder::encode_len (unsigned int len)	174	basecoder::encode_len (unsigned int len)
161	{	175	{
162	return enc_len [len];	176	return enc_len [len];
163	}	177	}
164		178
		179	unsigned int
165	unsigned int basecoder::decode_len (unsigned int len)	180	basecoder::decode_len (unsigned int len)
166	{	181	{
167	while (len && !dec_len [len])	182	while (len && !dec_len [len])
168	--len;	183	--len;
169		184
170	return dec_len [len];	185	return dec_len [len];
171	}	186	}
172		187
		188	unsigned int
173	unsigned int basecoder::encode (char dst, u8 src, unsigned int len)	189	basecoder::encode (char dst, u8 src, unsigned int len)
174	{	190	{
175	if (!len \|\| len > MAX_DEC_LEN)	191	if (!len \|\| len > MAX_DEC_LEN)
176	return 0;	192	return 0;
177		193
178	int elen = encode_len (len);	194	int elen = encode_len (len);
…		…
197	*dst++ = cmap.encode [dst_ [i]];	213	*dst++ = cmap.encode [dst_ [i]];
198		214
199	return elen;	215	return elen;
200	}	216	}
201		217
		218	unsigned int
202	unsigned int basecoder::decode (u8 dst, char src, unsigned int len)	219	basecoder::decode (u8 dst, char src, unsigned int len)
203	{	220	{
204	if (!len \|\| len > MAX_ENC_LEN)	221	if (!len \|\| len > MAX_ENC_LEN)
205	return 0;	222	return 0;
206		223
207	u8 src_ [MAX_ENC_LEN];	224	u8 src_ [MAX_ENC_LEN];
…		…
265	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	282	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
266		283
267	/////////////////////////////////////////////////////////////////////////////	284	/////////////////////////////////////////////////////////////////////////////
268		285
269	#define HDRSIZE 6	286	#define HDRSIZE 6
270		287
		288	inline void
271	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)	289	encode_header (char *data, int clientid, int seqno, int retry = 0)
272	{	290	{
273	seqno &= SEQNO_MASK;	291	seqno &= SEQNO_MASK;
274		292
275	u8 hdr[3] = {	293	u8 hdr[3] = {
276	clientid,	294	clientid,
…		…
281	assert (clientid < 256);	299	assert (clientid < 256);
282		300
283	cdc26.encode (data, hdr, 3);	301	cdc26.encode (data, hdr, 3);
284	}	302	}
285		303
		304	inline void
286	inline void decode_header (char *data, int &clientid, int &seqno)	305	decode_header (char *data, int &clientid, int &seqno)
287	{	306	{
288	u8 hdr[3];	307	u8 hdr[3];
289		308
290	cdc26.decode (hdr, data, HDRSIZE);	309	cdc26.decode (hdr, data, HDRSIZE);
291		310
…		…
324	byte_stream::~byte_stream ()	343	byte_stream::~byte_stream ()
325	{	344	{
326	delete data;	345	delete data;
327	}	346	}
328		347
		348	void
329	void byte_stream::remove (int count)	349	byte_stream::remove (int count)
330	{	350	{
331	if (count > fill)	351	if (count > fill)
332	assert (count <= fill);	352	assert (count <= fill);
333		353
334	memmove (data, data + count, fill -= count);	354	memmove (data, data + count, fill -= count);
335	}	355	}
336		356
		357	bool
337	bool byte_stream::put (u8 *data, unsigned int datalen)	358	byte_stream::put (u8 *data, unsigned int datalen)
338	{	359	{
339	if (maxsize - fill < datalen)	360	if (maxsize - fill < datalen)
340	return false;	361	return false;
341		362
342	memcpy (this->data + fill, data, datalen); fill += datalen;	363	memcpy (this->data + fill, data, datalen); fill += datalen;
343		364
344	return true;	365	return true;
345	}	366	}
346		367
		368	bool
347	bool byte_stream::put (vpn_packet *pkt)	369	byte_stream::put (vpn_packet *pkt)
348	{	370	{
349	if (maxsize - fill < pkt->len + 2)	371	if (maxsize - fill < pkt->len + 2)
350	return false;	372	return false;
351		373
352	data [fill++] = pkt->len >> 8;	374	data [fill++] = pkt->len >> 8;
…		…
409	struct dns_cfg	431	struct dns_cfg
410	{	432	{
411	static int next_uid;	433	static int next_uid;
412		434
413	u8 id1, id2, id3, id4;	435	u8 id1, id2, id3, id4;
		436
414	u8 version;	437	u8 version;
		438	u8 flags;
415	u8 rrtype;	439	u8 rrtype;
416	u8 flags;
417	u8 def_ttl;	440	u8 def_ttl;
418	u8 rcv_cdc;	441
419	u8 snd_cdc;
420	u16 max_size;
421	u16 client;	442	u16 client;
422	u16 uid; // to make request unique	443	u16 uid; // to make request unique
423		444
424	u8 reserved[8];	445	u16 max_size;
		446	u8 seq_cdc;
		447	u8 req_cdc;
		448
		449	u8 rep_cdc;
		450	u8 delay; // time in 0.01s units that the server may delay replying packets
		451	u8 r3, r4;
		452
		453	u8 r5, r6, r7, r8;
425		454
426	void reset (int clientid);	455	void reset (int clientid);
427	bool valid ();	456	bool valid ();
428	};	457	};
429		458
430	int dns_cfg::next_uid;	459	int dns_cfg::next_uid;
431		460
		461	void
432	void dns_cfg::reset (int clientid)	462	dns_cfg::reset (int clientid)
433	{	463	{
434	id1 = 'G';	464	id1 = 'G';
435	id2 = 'V';	465	id2 = 'V';
436	id3 = 'P';	466	id3 = 'P';
437	id4 = 'E';	467	id4 = 'E';
438		468
439	version = 1;	469	version = 1;
440		470
441	rrtype = RR_TYPE_TXT;	471	rrtype = RR_TYPE_TXT;
442	flags = 0;	472	flags = 0;
443	def_ttl = 1;	473	def_ttl = 0;
		474	seq_cdc = 26;
		475	req_cdc = 62;
444	rcv_cdc = 0;	476	rep_cdc = 0;
445	snd_cdc = 62;
446	max_size = ntohs (MAX_PKT_SIZE);	477	max_size = htons (MAX_PKT_SIZE);
447	client = ntohs (clientid);	478	client = htons (clientid);
448	uid = next_uid++;	479	uid = next_uid++;
		480	delay = 0;
449		481
450	memset (reserved, 0, 8);	482	r3 = r4 = 0;
		483	r4 = r5 = r6 = r7 = 0;
451	}	484	}
452		485
		486	bool
453	bool dns_cfg::valid ()	487	dns_cfg::valid ()
454	{	488	{
		489	// although the protocol itself allows for some configurability,
		490	// only the following encoding/decoding settings are implemented.
455	return id1 == 'G'	491	return id1 == 'G'
456	&& id2 == 'V'	492	&& id2 == 'V'
457	&& id3 == 'P'	493	&& id3 == 'P'
458	&& id4 == 'E'	494	&& id4 == 'E'
		495	&& seq_cdc == 26
		496	&& req_cdc == 62
		497	&& rep_cdc == 0
459	&& version == 1	498	&& version == 1;
460	&& flags == 0
461	&& rcv_cdc == 0
462	&& snd_cdc == 62
463	&& max_size == ntohs (MAX_PKT_SIZE);
464	}	499	}
465		500
466	struct dns_packet : net_packet	501	struct dns_packet : net_packet
467	{	502	{
468	u16 id;	503	u16 id;
469	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4	504	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
470	u16 qdcount, ancount, nscount, arcount;	505	u16 qdcount, ancount, nscount, arcount;
471		506
472	u8 data[MAXSIZE - 6 * 2];	507	u8 data [MAXSIZE - 6 * 2];
473		508
474	int decode_label (char *data, int size, int &offs);	509	int decode_label (char *data, int size, int &offs);
475	};	510	};
476		511
		512	int
477	int dns_packet::decode_label (char *data, int size, int &offs)	513	dns_packet::decode_label (char *data, int size, int &offs)
478	{	514	{
479	char *orig = data;	515	char *orig = data;
480		516
481	memset (data, 0, size);	517	memset (data, 0, size);
482		518
…		…
508	return data - orig;	544	return data - orig;
509	}	545	}
510		546
511	/////////////////////////////////////////////////////////////////////////////	547	/////////////////////////////////////////////////////////////////////////////
512		548
		549	static
		550	u16 next_id ()
		551	{
513	static u16 dns_id = 0; // TODO: should be per-vpn	552	static u16 dns_id = 0; // TODO: should be per-vpn
514		553
515	static u16 next_id ()
516	{
517	if (!dns_id)	554	if (!dns_id)
518	dns_id = time (0);	555	dns_id = time (0);
519		556
520	// the simplest lsfr with periodicity 65535 i could find	557	// the simplest lsfr with periodicity 65535 i could find
521	dns_id = (dns_id << 1)	558	dns_id = (dns_id << 1)
…		…
539		576
540	bool established;	577	bool established;
541		578
542	tstamp last_received;	579	tstamp last_received;
543	tstamp last_sent;	580	tstamp last_sent;
544	double last_latency;	581	double min_latency;
545	double poll_interval, send_interval;	582	double poll_interval, send_interval;
546		583
547	vector<dns_rcv *> rcvpq;	584	vector<dns_rcv *> rcvpq;
548		585
549	byte_stream rcvdq; int rcvseq;	586	byte_stream rcvdq; int rcvseq; int repseq;
550	byte_stream snddq; int sndseq;	587	byte_stream snddq; int sndseq;
551		588
552	void time_cb (time_watcher &w); time_watcher tw;	589	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
553	void receive_rep (dns_rcv *r);	590	void receive_rep (dns_rcv *r);
554		591
555	dns_connection (connection *c);	592	dns_connection (connection *c);
556	~dns_connection ();	593	~dns_connection ();
557	};	594	};
…		…
576	: dns (dns)	613	: dns (dns)
577	{	614	{
578	timeout = 0;	615	timeout = 0;
579	retry = 0;	616	retry = 0;
580	seqno = 0;	617	seqno = 0;
581	sent = NOW;	618	sent = ev_now ();
582	stdhdr = false;	619	stdhdr = false;
583		620
584	pkt = new dns_packet;	621	pkt = new dns_packet;
585		622
586	pkt->id = next_id ();	623	pkt->id = next_id ();
…		…
589	dns_snd::~dns_snd ()	626	dns_snd::~dns_snd ()
590	{	627	{
591	delete pkt;	628	delete pkt;
592	}	629	}
593		630
		631	static void
594	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	632	append_domain (dns_packet &pkt, int &offs, const char *domain)
595	{	633	{
596	// add tunnel domain	634	// add tunnel domain
597	for (;;)	635	for (;;)
598	{	636	{
599	const char *end = strchr (domain, '.');	637	const char *end = strchr (domain, '.');
…		…
612		650
613	domain = end + 1;	651	domain = end + 1;
614	}	652	}
615	}	653	}
616		654
		655	void
617	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	656	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
618	{	657	{
619	stdhdr = true;	658	stdhdr = true;
620	this->seqno = seqno;	659	this->seqno = seqno;
621		660
622	timeout = NOW + INITIAL_TIMEOUT;	661	timeout = ev_now () + INITIAL_TIMEOUT;
623		662
624	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	663	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
625	pkt->qdcount = htons (1);	664	pkt->qdcount = htons (1);
626		665
627	int offs = 6*2;	666	int offs = 6*2;
…		…
660	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	699	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
661		700
662	pkt->len = offs;	701	pkt->len = offs;
663	}	702	}
664		703
		704	void
665	void dns_snd::gen_syn_req ()	705	dns_snd::gen_syn_req ()
666	{	706	{
667	timeout = NOW + INITIAL_SYN_TIMEOUT;	707	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
668
669	printf ("send syn\n");//D
670		708
671	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	709	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
672	pkt->qdcount = htons (1);	710	pkt->qdcount = htons (1);
673		711
674	int offs = 6 * 2;	712	int offs = 6 * 2;
…		…
713	/////////////////////////////////////////////////////////////////////////////	751	/////////////////////////////////////////////////////////////////////////////
714		752
715	dns_connection::dns_connection (connection *c)	753	dns_connection::dns_connection (connection *c)
716	: c (c)	754	: c (c)
717	, rcvdq (MAX_BACKLOG * 2)	755	, rcvdq (MAX_BACKLOG * 2)
718	, snddq (MAX_BACKLOG * 2)	756	, snddq (MAX_BACKLOG)
719	, tw (this, &dns_connection::time_cb)
720	{	757	{
		758	tw.set<dns_connection, &dns_connection::time_cb> (this);
		759
721	vpn = c->vpn;	760	vpn = c->vpn;
722		761
723	established = false;	762	established = false;
724		763
725	rcvseq = sndseq = 0;	764	rcvseq = repseq = sndseq = 0;
726		765
727	last_sent = last_received = 0;	766	last_sent = last_received = 0;
728	poll_interval = MIN_POLL_INTERVAL;	767	poll_interval = 0.5; // starting here
729	send_interval = 0.5; // starting rate	768	send_interval = 0.5; // starting rate
730	last_latency = INITIAL_TIMEOUT;	769	min_latency = INITIAL_TIMEOUT;
731	}	770	}
732		771
733	dns_connection::~dns_connection ()	772	dns_connection::~dns_connection ()
734	{	773	{
735	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	774	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
736	i != rcvpq.end ();	775	i != rcvpq.end ();
737	++i)	776	++i)
738	delete *i;	777	delete *i;
739	}	778	}
740		779
		780	void
741	void dns_connection::receive_rep (dns_rcv *r)	781	dns_connection::receive_rep (dns_rcv *r)
742	{	782	{
743	if (r->datalen)	783	if (r->datalen)
744	{	784	{
745	last_received = NOW;	785	last_received = ev_now ();
746	tw.trigger ();	786	tw ();
747		787
748	poll_interval = send_interval;	788	poll_interval = send_interval;
749	}	789	}
750	else	790	else
751	{	791	{
752	poll_interval *= 1.5;	792	poll_interval *= 1.5;
		793
753	if (poll_interval > MAX_POLL_INTERVAL)	794	if (poll_interval > MAX_POLL_INTERVAL)
754	poll_interval = MAX_POLL_INTERVAL;	795	poll_interval = MAX_POLL_INTERVAL;
755	}	796	}
756		797
757	rcvpq.push_back (r);	798	rcvpq.push_back (r);
…		…
760		801
761	// find next packet	802	// find next packet
762	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	803	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
763	if (SEQNO_EQ (rcvseq, (*i)->seqno))	804	if (SEQNO_EQ (rcvseq, (*i)->seqno))
764	{	805	{
		806	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
765	// enter the packet into our input stream	807	// enter the packet into our input stream
766	r = *i;	808	r = *i;
767		809
768	// remove the oldest packet, look forward, as it's oldest first	810	// remove the oldest packet, look forward, as it's oldest first
769	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	811	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
770	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	812	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
771	{	813	{
		814	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
772	delete *j;	815	delete *j;
773	rcvpq.erase (j);	816	rcvpq.erase (j);
774	break;	817	break;
775	}	818	}
776		819
…		…
783	}	826	}
784		827
785	while (vpn_packet *pkt = rcvdq.get ())	828	while (vpn_packet *pkt = rcvdq.get ())
786	{	829	{
787	sockinfo si;	830	sockinfo si;
788	si.host = 0x01010101; si.port = htons (c->conf->id); si.prot = PROT_DNSv4;	831	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
789		832
790	vpn->recv_vpn_packet (pkt, si);	833	vpn->recv_vpn_packet (pkt, si);
791		834
792	delete pkt;	835	delete pkt;
793	}	836	}
…		…
807	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	850	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
808		851
809	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	852	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
810	&& pkt.qdcount == htons (1))	853	&& pkt.qdcount == htons (1))
811	{	854	{
812	char qname[MAXSIZE];	855	char qname [MAXSIZE];
813	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	856	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
814		857
815	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	858	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
816	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	859	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
817		860
…		…
824		867
825	int dlen = strlen (THISNODE->domain);	868	int dlen = strlen (THISNODE->domain);
826		869
827	if (qclass == RR_CLASS_IN	870	if (qclass == RR_CLASS_IN
828	&& qlen > dlen + 1	871	&& qlen > dlen + 1
829	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	872	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
830	{	873	{
831	// now generate reply	874	// now generate reply
832	pkt.ancount = htons (1); // one answer RR	875	pkt.ancount = htons (1); // one answer RR
833	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	876	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
834		877
…		…
847	if (0 < client && client <= conns.size ())	890	if (0 < client && client <= conns.size ())
848	{	891	{
849	connection *c = conns [client - 1];	892	connection *c = conns [client - 1];
850	dns_connection *dns = c->dns;	893	dns_connection *dns = c->dns;
851	dns_rcv *rcv;	894	dns_rcv *rcv;
852	bool in_seq;
853		895
854	if (dns)	896	if (dns)
855	{	897	{
856	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	898	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
857	if (SEQNO_EQ ((*i)->seqno, seqno))	899	if (SEQNO_EQ ((*i)->seqno, seqno))
…		…
868	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	910	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
869		911
870	goto duplicate_request;	912	goto duplicate_request;
871	}	913	}
872		914
873	in_seq = dns->rcvseq == seqno;
874
875	// new packet, queue	915	// new packet, queue
876	rcv = new dns_rcv (seqno, data, datalen);	916	rcv = new dns_rcv (seqno, data, datalen);
877	dns->receive_rep (rcv);	917	dns->receive_rep (rcv);
878	}	918	}
879		919
		920	{
880	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section	921	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
881		922
882	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;	923	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
883	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type	924	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
884	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	925	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
885	pkt [offs++] = 0; pkt [offs++] = 0;	926	pkt [offs++] = 0; pkt [offs++] = 0;
886	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL	927	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
887		928
888	int rdlen_offs = offs += 2;	929	int rdlen_offs = offs += 2;
889		930
		931	if (dns)
		932	{
890	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;	933	int dlen = ntohs (dns->cfg.max_size) - offs;
		934
891	// bind doesn't compress well, so reduce further by one label length	935	// bind doesn't compress well, so reduce further by one label length
892	dlen -= qlen;	936	dlen -= qlen;
893		937
894	if (dns)
895	{
896	// only put data into in-order sequence packets, if	938	// only put data into in-order sequence packets, if
897	// we receive out-of-order packets we generate empty	939	// we receive out-of-order packets we generate empty
898	// replies	940	// replies
899	while (dlen > 1 && !dns->snddq.empty () && in_seq)	941	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		942	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
900	{	943	{
		944	dns->repseq = seqno;
		945
		946	while (dlen > 1 && !dns->snddq.empty ())
		947	{
901	int txtlen = dlen <= 255 ? dlen - 1 : 255;	948	int txtlen = dlen <= 255 ? dlen - 1 : 255;
902		949
903	if (txtlen > dns->snddq.size ())	950	if (txtlen > dns->snddq.size ())
904	txtlen = dns->snddq.size ();	951	txtlen = dns->snddq.size ();
905		952
906	pkt[offs++] = txtlen;	953	pkt[offs++] = txtlen;
907	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	954	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
908	offs += txtlen;	955	offs += txtlen;
909	dns->snddq.remove (txtlen);	956	dns->snddq.remove (txtlen);
910		957
911	dlen -= txtlen + 1;	958	dlen -= txtlen + 1;
		959	}
912	}	960	}
913		961
914	// avoid empty TXT rdata	962	// avoid completely empty TXT rdata
915	if (offs == rdlen_offs)	963	if (offs == rdlen_offs)
916	pkt[offs++] = 0;	964	pkt[offs++] = 0;
917		965
918	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());	966	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
919	}	967	}
920	else	968	else
921	{	969	{
922	// send RST	970	// send RST
923	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	971	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
924	pkt [offs++] = CMD_IP_RST;	972	pkt [offs++] = CMD_IP_RST;
925	}	973	}
926		974
927	int rdlen = offs - rdlen_offs;	975	int rdlen = offs - rdlen_offs;
928		976
929	pkt [rdlen_offs - 2] = rdlen >> 8;	977	pkt [rdlen_offs - 2] = rdlen >> 8;
930	pkt [rdlen_offs - 1] = rdlen;	978	pkt [rdlen_offs - 1] = rdlen;
931		979
932	if (dns)	980	if (dns)
933	{	981	{
934	// now update dns_rcv copy	982	// now update dns_rcv copy
935	rcv->pkt->len = offs;	983	rcv->pkt->len = offs;
936	memcpy (rcv->pkt->at (0), pkt.at (0), offs);	984	memcpy (rcv->pkt->at (0), pkt.at (0), offs);
937	}	985	}
		986	}
938		987
939	duplicate_request: ;	988	duplicate_request: ;
940	}	989	}
941	else	990	else
942	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	991	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
…		…
954	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	1003	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
955	pkt [offs++] = 0; pkt [offs++] = 0;	1004	pkt [offs++] = 0; pkt [offs++] = 0;
956	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1005	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
957	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1006	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
958		1007
959	slog (L_INFO, _("DNS: client %d tries to connect"), client);	1008	slog (L_INFO, _("DNS: client %d connects"), client);
960		1009
961	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	1010	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
962	pkt [offs++] = CMD_IP_REJ;	1011	pkt [offs++] = CMD_IP_REJ;
963		1012
964	if (0 < client && client <= conns.size ())	1013	if (0 < client && client <= conns.size ())
…		…
998	{	1047	{
999	dns_connection dns = (i)->dns;	1048	dns_connection dns = (i)->dns;
1000	connection *c = dns->c;	1049	connection *c = dns->c;
1001	int seqno = (*i)->seqno;	1050	int seqno = (*i)->seqno;
1002	u8 data[MAXSIZE], *datap = data;	1051	u8 data[MAXSIZE], *datap = data;
		1052	//printf ("rcv pkt %x\n", seqno);//D
1003		1053
1004	if ((*i)->retry)	1054	if ((*i)->retry)
1005	{	1055	{
1006	dns->send_interval *= 1.01;	1056	dns->send_interval *= 1.01;
1007	if (dns->send_interval > MAX_SEND_INTERVAL)	1057	if (dns->send_interval > MAX_SEND_INTERVAL)
1008	dns->send_interval = MAX_SEND_INTERVAL;	1058	dns->send_interval = MAX_SEND_INTERVAL;
1009	}	1059	}
1010	else	1060	else
1011	{	1061	{
1012	#if 1	1062	#if 0
1013	dns->send_interval *= 0.999;	1063	dns->send_interval *= 0.999;
1014	#endif	1064	#endif
1015	if (dns->send_interval < MIN_SEND_INTERVAL)
1016	dns->send_interval = MIN_SEND_INTERVAL;
1017
1018	// the latency surely puts an upper bound on	1065	// the latency surely puts an upper bound on
1019	// the minimum send interval	1066	// the minimum send interval
1020	double latency = NOW - (*i)->sent;	1067	double latency = ev_now () - (*i)->sent;
		1068
		1069	if (latency < dns->min_latency)
1021	dns->last_latency = latency;	1070	dns->min_latency = latency;
1022		1071
1023	if (dns->send_interval > latency)	1072	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1073	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1074
		1075	if (dns->send_interval < conf.dns_send_interval)
1024	dns->send_interval = latency;	1076	dns->send_interval = conf.dns_send_interval;
1025	}	1077	}
1026		1078
1027	delete *i;	1079	delete *i;
1028	dns_sndpq.erase (i);	1080	dns_sndpq.erase (i);
1029		1081
…		…
1134	break;	1186	break;
1135	}	1187	}
1136	}	1188	}
1137		1189
1138	void	1190	void
1139	vpn::dnsv4_ev (io_watcher &w, short revents)	1191	vpn::dnsv4_ev (ev::io &w, int revents)
1140	{	1192	{
1141	if (revents & EVENT_READ)	1193	if (revents & EV_READ)
1142	{	1194	{
1143	dns_packet *pkt = new dns_packet;	1195	dns_packet *pkt = new dns_packet;
1144	struct sockaddr_in sa;	1196	struct sockaddr_in sa;
1145	socklen_t sa_len = sizeof (sa);	1197	socklen_t sa_len = sizeof (sa);
1146		1198
1147	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);	1199	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1148		1200
1149	if (pkt->len > 0)	1201	if (pkt->len > 0)
1150	{	1202	{
1151	if (THISNODE->dns_port)	1203	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1204	dnsv4_client (*pkt);
		1205	else
1152	{	1206	{
1153	dnsv4_server (*pkt);	1207	dnsv4_server (*pkt);
1154	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);	1208	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1155	}	1209	}
1156	else
1157	dnsv4_client (*pkt);
1158		1210
1159	delete pkt;	1211	delete pkt;
1160	}	1212	}
1161	}	1213	}
1162	}	1214	}
1163		1215
1164	bool	1216	bool
1165	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1217	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1166	{	1218	{
1167	int client = ntohs (si.port);	1219	int client = ntohl (si.host);
1168		1220
1169	assert (0 < client && client <= conns.size ());	1221	assert (0 < client && client <= conns.size ());
1170		1222
1171	connection *c = conns [client - 1];	1223	connection *c = conns [client - 1];
1172		1224
1173	if (!c->dns)	1225	if (!c->dns)
1174	c->dns = new dns_connection (c);	1226	c->dns = new dns_connection (c);
1175		1227
1176	if (!c->dns->snddq.put (pkt))	1228	if (c->dns->snddq.put (pkt))
1177	return false;
1178
1179	c->dns->tw.trigger ();	1229	c->dns->tw ();
1180		1230
		1231	// always return true even if the buffer overflows
1181	return true;	1232	return true;
1182	}	1233	}
1183		1234
1184	void	1235	void
1185	connection::dnsv4_reset_connection ()	1236	connection::dnsv4_reset_connection ()
…		…
1188	}	1239	}
1189		1240
1190	#define NEXT(w) do { if (next > (w)) next = w; } while (0)	1241	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1191		1242
1192	void	1243	void
1193	dns_connection::time_cb (time_watcher &w)	1244	dns_connection::time_cb (ev::timer &w, int revents)
1194	{	1245	{
1195	// servers have to be polled	1246	// servers have to be polled
1196	if (THISNODE->dns_port)	1247	if (THISNODE->dns_port)
1197	return;	1248	return;
1198		1249
1199	// check for timeouts and (re)transmit	1250	// check for timeouts and (re)transmit
1200	tstamp next = NOW + poll_interval;	1251	tstamp next = ev::now () + poll_interval;
1201	dns_snd *send = 0;	1252	dns_snd *send = 0;
1202		1253
1203	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1254	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1204	i != vpn->dns_sndpq.end ();	1255	i != vpn->dns_sndpq.end ();
1205	++i)	1256	++i)
1206	{	1257	{
1207	dns_snd r = i;	1258	dns_snd r = i;
1208		1259
1209	if (r->timeout <= NOW)	1260	if (r->timeout <= ev_now ())
1210	{	1261	{
1211	if (!send)	1262	if (!send)
1212	{	1263	{
1213	send = r;	1264	send = r;
1214		1265
1215	r->retry++;	1266	r->retry++;
1216	r->timeout = NOW + (r->retry * last_latency * 8.);	1267	r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
		1268	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1217		1269
1218	// the following code changes the query section a bit, forcing	1270	// the following code changes the query section a bit, forcing
1219	// the forwarder to generate a new request	1271	// the forwarder to generate a new request
1220	if (r->stdhdr)	1272	if (r->stdhdr)
1221	{
1222	//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);
1223	//encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);	1273	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1224	}
1225	}	1274	}
1226	}	1275	}
1227	else	1276	else
1228	NEXT (r->timeout);	1277	NEXT (r->timeout);
1229	}	1278	}
1230		1279
1231	if (last_sent + send_interval <= NOW)
1232	{
1233	if (!send)	1280	if (!send)
		1281	{
		1282	// generate a new packet, if wise
		1283
		1284	if (!established)
1234	{	1285	{
1235	// generate a new packet, if wise	1286	if (vpn->dns_sndpq.empty ())
1236
1237	if (!established)
1238	{	1287	{
1239	if (vpn->dns_sndpq.empty ())
1240	{
1241	send = new dns_snd (this);	1288	send = new dns_snd (this);
1242		1289
1243	printf ("new conn %p %d\n", this, c->conf->id);//D
1244	cfg.reset (THISNODE->id);	1290	cfg.reset (THISNODE->id);
1245	send->gen_syn_req ();	1291	send->gen_syn_req ();
1246	}
1247	}	1292	}
1248	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING	1293	}
		1294	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1249	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))	1295	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1296	{
		1297	if (last_sent + send_interval <= ev_now ())
1250	{	1298	{
1251	//printf ("sending data request etc.\n"); //D	1299	//printf ("sending data request etc.\n"); //D
1252	if (!snddq.empty ())	1300	if (!snddq.empty () \|\| last_received + 1. > ev_now ())
1253	{	1301	{
1254	poll_interval = send_interval;	1302	poll_interval = send_interval;
1255	NEXT (NOW + send_interval);	1303	NEXT (ev_now () + send_interval);
1256	}	1304	}
1257		1305
1258	send = new dns_snd (this);	1306	send = new dns_snd (this);
1259	send->gen_stream_req (sndseq, snddq);	1307	send->gen_stream_req (sndseq, snddq);
1260	send->timeout = NOW + last_latency * 8.;	1308	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1309	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1261		1310
1262	sndseq = (sndseq + 1) & SEQNO_MASK;	1311	sndseq = (sndseq + 1) & SEQNO_MASK;
1263	}	1312	}
1264		1313	else
1265	if (send)	1314	NEXT (last_sent + send_interval);
1266	vpn->dns_sndpq.push_back (send);
1267	}	1315	}
1268		1316
1269	if (send)	1317	if (send)
1270	{	1318	vpn->dns_sndpq.push_back (send);
1271	last_sent = NOW;	1319	}
		1320
		1321	if (send)
		1322	{
		1323	last_sent = ev_now ();
1272	sendto (vpn->dnsv4_fd,	1324	sendto (vpn->dnsv4_fd,
1273	send->pkt->at (0), send->pkt->len, 0,	1325	send->pkt->at (0), send->pkt->len, 0,
1274	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1326	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1275	}
1276	}	1327	}
1277	else
1278	NEXT (last_sent + send_interval);
1279		1328
1280	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d)",	1329	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1281	poll_interval, send_interval, next - NOW,	1330	poll_interval, send_interval, next - ev_now (),
1282	vpn->dns_sndpq.size (), snddq.size ());	1331	vpn->dns_sndpq.size (), snddq.size (),
		1332	rcvpq.size ());
1283		1333
1284	// TODO: no idea when this happens, but when next < NOW, we have a problem	1334	// TODO: no idea when this happens, but when next < ev_now (), we have a problem
		1335	// doesn't seem to happen anymore
1285	if (next < NOW + 0.0001)	1336	if (next < ev_now () + 0.001)
1286	next = NOW + 0.1;	1337	next = ev_now () + 0.1;
1287		1338
1288	w.start (next);	1339	w.start (next - ev_now ());
1289	}	1340	}
1290		1341
1291	#endif	1342	#endif
1292		1343

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.20 by pcg, Sun Mar 6 21:32:15 2005 UTC vs. Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.20 by pcg, Sun Mar 6 21:32:15 2005 UTC vs.
Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC