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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.17 by pcg, Sat Mar 5 03:47:05 2005 UTC vs.
Revision 1.48 by pcg, Tue Jul 28 00:42:14 2009 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
26	// dns processing is EXTREMELY ugly. For obvious(?) reasons.	40	// dns processing is EXTREMELY ugly. For obvious(?) reasons.
27	// it's a hack, use only in emergency situations please.	41	// it's a hack, use only in emergency situations please.
28		42
29	#include <cstring>	43	#include <cstring>
		44	#include <cassert>
30		45
31	#include <sys/types.h>	46	#include <sys/types.h>
32	#include <sys/socket.h>	47	#include <sys/socket.h>
33	#include <sys/wait.h>	48	#include <sys/wait.h>
34	#include <sys/uio.h>	49	#include <sys/uio.h>
37	#include <unistd.h>	52	#include <unistd.h>
38	#include <fcntl.h>	53	#include <fcntl.h>
39		54
40	#include <map>	55	#include <map>
41		56
		57	#include <cstdio> /* bug in libgmp: gmp.h relies on cstdio being included */
42	#include <gmp.h>	58	#include <gmp.h>
43		59
44	#include "netcompat.h"	60	#include "netcompat.h"
45		61
46	#include "vpn.h"	62	#include "vpn.h"
47		63
48	#define MIN_POLL_INTERVAL .02 // how often to poll minimally when the server has data
49	#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
50	#define ACTIVITY_INTERVAL 5.	65	#define ACTIVITY_INTERVAL 5.
51		66
52	#define INITIAL_TIMEOUT 0.1 // retry timeouts	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
53	#define INITIAL_SYN_TIMEOUT 10. // retry timeout for initial syn	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54		69
55	#define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests
56	#define MAX_SEND_INTERVAL 0.5 // optimistic?	70	#define MAX_SEND_INTERVAL 2. // optimistic?
57		71
58	#define MAX_OUTSTANDING 10 // max. outstanding requests
59	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
60	#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
61		74
62	#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
63	// 240 leaves about 4 bytes of server reply data	76	// 240 leaves about 4 bytes of server reply data
64	// every two request bytes less give room for one reply byte	77	// every request byte less give room for two reply bytes
65		78
66	#define SEQNO_MASK 0x3fff	79	#define SEQNO_MASK 0x3fff
67	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )	80	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
68		81
69	#define MAX_LBL_SIZE 63	82	#define MAX_LBL_SIZE 63
70	#define MAX_PKT_SIZE 512	83	#define MAX_PKT_SIZE 512
71		84
72	#define RR_TYPE_A 1	85	#define RR_TYPE_A 1
73	#define RR_TYPE_NULL 10	86	#define RR_TYPE_NULL 10
74	#define RR_TYPE_TXT 16	87	#define RR_TYPE_TXT 16
		88	#define RR_TYPE_AAAA 28
75	#define RR_TYPE_ANY 255	89	#define RR_TYPE_ANY 255
76		90
77	#define RR_CLASS_IN 1	91	#define RR_CLASS_IN 1
78		92
79	#define CMD_IP_1 207	93	#define CMD_IP_1 207
…		…
264	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	278	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
265		279
266	/////////////////////////////////////////////////////////////////////////////	280	/////////////////////////////////////////////////////////////////////////////
267		281
268	#define HDRSIZE 6	282	#define HDRSIZE 6
269		283
270	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)	284	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)
271	{	285	{
272	seqno &= SEQNO_MASK;	286	seqno &= SEQNO_MASK;
273		287
274	u8 hdr[3] = {	288	u8 hdr[3] = {
…		…
356	return true;	370	return true;
357	}	371	}
358		372
359	vpn_packet *byte_stream::get ()	373	vpn_packet *byte_stream::get ()
360	{	374	{
		375	unsigned int len;
		376
		377	for (;;)
		378	{
361	unsigned int len = (data [0] << 8) \| data [1];	379	len = (data [0] << 8) \| data [1];
362		380
363	if (len > MAXSIZE && fill >= 2)	381	if (len <= MAXSIZE \|\| fill < 2)
364	assert (len <= MAXSIZE \|\| fill < 2); // TODO handle this gracefully, connection reset	382	break;
365		383
		384	// TODO: handle this better than skipping, e.g. by reset
		385	slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
		386	remove (1);
		387	}
		388
366	if (fill < len + 2)	389	if (fill < len + 2)
367	return 0;	390	return 0;
368		391
369	vpn_packet *pkt = new vpn_packet;	392	vpn_packet *pkt = new vpn_packet;
370		393
…		…
399	struct dns_cfg	422	struct dns_cfg
400	{	423	{
401	static int next_uid;	424	static int next_uid;
402		425
403	u8 id1, id2, id3, id4;	426	u8 id1, id2, id3, id4;
		427
404	u8 version;	428	u8 version;
		429	u8 flags;
405	u8 rrtype;	430	u8 rrtype;
406	u8 flags;
407	u8 def_ttl;	431	u8 def_ttl;
408	u8 rcv_cdc;	432
409	u8 snd_cdc;
410	u16 max_size;
411	u16 client;	433	u16 client;
412	u16 uid; // to make request unique	434	u16 uid; // to make request unique
413		435
414	u8 reserved[8];	436	u16 max_size;
		437	u8 seq_cdc;
		438	u8 req_cdc;
		439
		440	u8 rep_cdc;
		441	u8 delay; // time in 0.01s units that the server may delay replying packets
		442	u8 r3, r4;
		443
		444	u8 r5, r6, r7, r8;
415		445
416	void reset (int clientid);	446	void reset (int clientid);
417	bool valid ();	447	bool valid ();
418	};	448	};
419		449
…		…
428		458
429	version = 1;	459	version = 1;
430		460
431	rrtype = RR_TYPE_TXT;	461	rrtype = RR_TYPE_TXT;
432	flags = 0;	462	flags = 0;
433	def_ttl = 1;	463	def_ttl = 0;
		464	seq_cdc = 26;
		465	req_cdc = 62;
434	rcv_cdc = 0;	466	rep_cdc = 0;
435	snd_cdc = 62;
436	max_size = ntohs (MAX_PKT_SIZE);	467	max_size = htons (MAX_PKT_SIZE);
437	client = ntohs (clientid);	468	client = htons (clientid);
438	uid = next_uid++;	469	uid = next_uid++;
		470	delay = 0;
439		471
440	memset (reserved, 0, 8);	472	r3 = r4 = 0;
		473	r4 = r5 = r6 = r7 = 0;
441	}	474	}
442		475
443	bool dns_cfg::valid ()	476	bool dns_cfg::valid ()
444	{	477	{
		478	// although the protocol itself allows for some configurability,
		479	// only the following encoding/decoding settings are implemented.
445	return id1 == 'G'	480	return id1 == 'G'
446	&& id2 == 'V'	481	&& id2 == 'V'
447	&& id3 == 'P'	482	&& id3 == 'P'
448	&& id4 == 'E'	483	&& id4 == 'E'
		484	&& seq_cdc == 26
		485	&& req_cdc == 62
		486	&& rep_cdc == 0
449	&& version == 1	487	&& version == 1;
450	&& flags == 0
451	&& rcv_cdc == 0
452	&& snd_cdc == 62
453	&& max_size == ntohs (MAX_PKT_SIZE);
454	}	488	}
455		489
456	struct dns_packet : net_packet	490	struct dns_packet : net_packet
457	{	491	{
458	u16 id;	492	u16 id;
459	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4	493	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
460	u16 qdcount, ancount, nscount, arcount;	494	u16 qdcount, ancount, nscount, arcount;
461		495
462	u8 data[MAXSIZE - 6 * 2];	496	u8 data [MAXSIZE - 6 * 2];
463		497
464	int decode_label (char *data, int size, int &offs);	498	int decode_label (char *data, int size, int &offs);
465	};	499	};
466		500
467	int dns_packet::decode_label (char *data, int size, int &offs)	501	int dns_packet::decode_label (char *data, int size, int &offs)
…		…
498	return data - orig;	532	return data - orig;
499	}	533	}
500		534
501	/////////////////////////////////////////////////////////////////////////////	535	/////////////////////////////////////////////////////////////////////////////
502		536
		537	static u16 dns_id = 0; // TODO: should be per-vpn
		538
		539	static u16 next_id ()
		540	{
		541	if (!dns_id)
		542	dns_id = time (0);
		543
		544	// the simplest lsfr with periodicity 65535 i could find
		545	dns_id = (dns_id << 1)
		546	\| (((dns_id >> 1)
		547	^ (dns_id >> 2)
		548	^ (dns_id >> 4)
		549	^ (dns_id >> 15)) & 1);
		550
		551	return dns_id;
		552	}
		553
		554	struct dns_rcv;
		555	struct dns_snd;
		556
		557	struct dns_connection
		558	{
		559	connection *c;
		560	struct vpn *vpn;
		561
		562	dns_cfg cfg;
		563
		564	bool established;
		565
		566	tstamp last_received;
		567	tstamp last_sent;
		568	double min_latency;
		569	double poll_interval, send_interval;
		570
		571	vector<dns_rcv *> rcvpq;
		572
		573	byte_stream rcvdq; int rcvseq; int repseq;
		574	byte_stream snddq; int sndseq;
		575
		576	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
		577	void receive_rep (dns_rcv *r);
		578
		579	dns_connection (connection *c);
		580	~dns_connection ();
		581	};
		582
503	struct dns_snd	583	struct dns_snd
504	{	584	{
505	dns_packet *pkt;	585	dns_packet *pkt;
506	tstamp timeout, sent;	586	tstamp timeout, sent;
507	int retry;	587	int retry;
508	struct dns_connection *dns;	588	struct dns_connection *dns;
509	int seqno;	589	int seqno;
510	bool stdhdr;	590	bool stdhdr;
511		591
512	void gen_stream_req (int seqno, byte_stream &stream);	592	void gen_stream_req (int seqno, byte_stream &stream);
513	void gen_syn_req (const dns_cfg &cfg);	593	void gen_syn_req ();
514		594
515	dns_snd (dns_connection *dns);	595	dns_snd (dns_connection *dns);
516	~dns_snd ();	596	~dns_snd ();
517	};	597	};
518		598
519	static u16 dns_id = 12098; // TODO: should be per-vpn
520
521	static u16 next_id ()
522	{
523	// the simplest lsfr with periodicity 65535 i could find
524	dns_id = (dns_id << 1)
525	\| (((dns_id >> 1)
526	^ (dns_id >> 2)
527	^ (dns_id >> 4)
528	^ (dns_id >> 15)) & 1);
529
530	return dns_id;
531	}
532
533	dns_snd::dns_snd (dns_connection *dns)	599	dns_snd::dns_snd (dns_connection *dns)
534	: dns (dns)	600	: dns (dns)
535	{	601	{
536	timeout = 0;	602	timeout = 0;
537	retry = 0;	603	retry = 0;
538	seqno = 0;	604	seqno = 0;
539	sent = NOW;	605	sent = ev_now ();
540	stdhdr = false;	606	stdhdr = false;
541		607
542	pkt = new dns_packet;	608	pkt = new dns_packet;
543		609
544	pkt->id = next_id ();	610	pkt->id = next_id ();
…		…
575	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	641	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
576	{	642	{
577	stdhdr = true;	643	stdhdr = true;
578	this->seqno = seqno;	644	this->seqno = seqno;
579		645
580	timeout = NOW + INITIAL_TIMEOUT;	646	timeout = ev_now () + INITIAL_TIMEOUT;
581		647
582	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	648	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
583	pkt->qdcount = htons (1);	649	pkt->qdcount = htons (1);
584		650
585	int offs = 6*2;	651	int offs = 6*2;
586	int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2);	652	int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
587	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,	653	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,
588	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	654	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
589		655
590	char enc[256], *encp = enc;	656	char enc[256], *encp = enc;
591	encode_header (enc, THISNODE->id, seqno);	657	encode_header (enc, THISNODE->id, seqno);
…		…
609	encp += lbllen;	675	encp += lbllen;
610		676
611	enclen -= lbllen;	677	enclen -= lbllen;
612	}	678	}
613		679
614	append_domain (*pkt, offs, THISNODE->domain);	680	append_domain (*pkt, offs, dns->c->conf->domain);
615		681
616	(*pkt)[offs++] = 0;	682	(*pkt)[offs++] = 0;
617	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;	683	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;
618	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	684	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
619		685
620	pkt->len = offs;	686	pkt->len = offs;
621	}	687	}
622		688
623	void dns_snd::gen_syn_req (const dns_cfg &cfg)	689	void dns_snd::gen_syn_req ()
624	{	690	{
625	timeout = NOW + INITIAL_SYN_TIMEOUT;	691	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
626		692
627	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	693	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
628	pkt->qdcount = htons (1);	694	pkt->qdcount = htons (1);
629		695
630	int offs = 6*2;	696	int offs = 6 * 2;
631		697
632	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&cfg, sizeof (dns_cfg));	698	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&dns->cfg, sizeof (dns_cfg));
633		699
634	assert (elen <= MAX_LBL_SIZE);	700	assert (elen <= MAX_LBL_SIZE);
635		701
636	(*pkt)[offs] = elen;	702	(*pkt)[offs] = elen;
637	offs += elen + 1;	703	offs += elen + 1;
638	append_domain (*pkt, offs, THISNODE->domain);	704	append_domain (*pkt, offs, dns->c->conf->domain);
639		705
640	(*pkt)[offs++] = 0;	706	(*pkt)[offs++] = 0;
641	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;	707	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;
642	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	708	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
643		709
…		…
666	delete pkt;	732	delete pkt;
667	}	733	}
668		734
669	/////////////////////////////////////////////////////////////////////////////	735	/////////////////////////////////////////////////////////////////////////////
670		736
671	struct dns_connection
672	{
673	connection *c;
674	struct vpn *vpn;
675
676	dns_cfg cfg;
677
678	bool established;
679
680	tstamp last_received;
681	tstamp last_sent;
682	double last_latency;
683	double poll_interval, send_interval;
684
685	vector<dns_rcv *> rcvpq;
686
687	byte_stream rcvdq; int rcvseq;
688	byte_stream snddq; int sndseq;
689
690	void time_cb (time_watcher &w); time_watcher tw;
691	void receive_rep (dns_rcv *r);
692
693	dns_connection (connection *c);
694	~dns_connection ();
695	};
696
697	dns_connection::dns_connection (connection *c)	737	dns_connection::dns_connection (connection *c)
698	: c (c)	738	: c (c)
699	, rcvdq (MAX_BACKLOG * 2)	739	, rcvdq (MAX_BACKLOG * 2)
700	, snddq (MAX_BACKLOG * 2)	740	, snddq (MAX_BACKLOG)
701	, tw (this, &dns_connection::time_cb)
702	{	741	{
		742	tw.set<dns_connection, &dns_connection::time_cb> (this);
		743
703	vpn = c->vpn;	744	vpn = c->vpn;
704		745
705	established = false;	746	established = false;
706		747
707	rcvseq = sndseq = 0;	748	rcvseq = repseq = sndseq = 0;
708		749
709	last_sent = last_received = 0;	750	last_sent = last_received = 0;
710	poll_interval = MIN_POLL_INTERVAL;	751	poll_interval = 0.5; // starting here
711	send_interval = 0.5; // starting rate	752	send_interval = 0.5; // starting rate
712	last_latency = INITIAL_TIMEOUT;	753	min_latency = INITIAL_TIMEOUT;
713	}	754	}
714		755
715	dns_connection::~dns_connection ()	756	dns_connection::~dns_connection ()
716	{	757	{
717	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	758	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
…		…
722		763
723	void dns_connection::receive_rep (dns_rcv *r)	764	void dns_connection::receive_rep (dns_rcv *r)
724	{	765	{
725	if (r->datalen)	766	if (r->datalen)
726	{	767	{
727	last_received = NOW;	768	last_received = ev_now ();
728	tw.trigger ();	769	tw ();
729		770
730	poll_interval = send_interval;	771	poll_interval = send_interval;
731	}	772	}
732	else	773	else
733	{	774	{
734	poll_interval *= 1.5;	775	poll_interval *= 1.5;
		776
735	if (poll_interval > MAX_POLL_INTERVAL)	777	if (poll_interval > MAX_POLL_INTERVAL)
736	poll_interval = MAX_POLL_INTERVAL;	778	poll_interval = MAX_POLL_INTERVAL;
737	}	779	}
738		780
739	rcvpq.push_back (r);	781	rcvpq.push_back (r);
…		…
742		784
743	// find next packet	785	// find next packet
744	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	786	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
745	if (SEQNO_EQ (rcvseq, (*i)->seqno))	787	if (SEQNO_EQ (rcvseq, (*i)->seqno))
746	{	788	{
		789	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
747	// enter the packet into our input stream	790	// enter the packet into our input stream
748	r = *i;	791	r = *i;
749		792
750	// remove the oldest packet, look forward, as it's oldest first	793	// remove the oldest packet, look forward, as it's oldest first
751	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	794	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
752	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	795	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
753	{	796	{
		797	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
754	delete *j;	798	delete *j;
755	rcvpq.erase (j);	799	rcvpq.erase (j);
756	break;	800	break;
757	}	801	}
758		802
…		…
765	}	809	}
766		810
767	while (vpn_packet *pkt = rcvdq.get ())	811	while (vpn_packet *pkt = rcvdq.get ())
768	{	812	{
769	sockinfo si;	813	sockinfo si;
770	si.host = 0; si.port = 0; si.prot = PROT_DNSv4;	814	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
771		815
772	vpn->recv_vpn_packet (pkt, si);	816	vpn->recv_vpn_packet (pkt, si);
773		817
774	delete pkt;	818	delete pkt;
775	}	819	}
…		…
789	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	833	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
790		834
791	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	835	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
792	&& pkt.qdcount == htons (1))	836	&& pkt.qdcount == htons (1))
793	{	837	{
794	char qname[MAXSIZE];	838	char qname [MAXSIZE];
795	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	839	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
796		840
797	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	841	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
798	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	842	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
799		843
…		…
806		850
807	int dlen = strlen (THISNODE->domain);	851	int dlen = strlen (THISNODE->domain);
808		852
809	if (qclass == RR_CLASS_IN	853	if (qclass == RR_CLASS_IN
810	&& qlen > dlen + 1	854	&& qlen > dlen + 1
811	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	855	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
812	{	856	{
813	// now generate reply	857	// now generate reply
814	pkt.ancount = htons (1); // one answer RR	858	pkt.ancount = htons (1); // one answer RR
815	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	859	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
816		860
…		…
829	if (0 < client && client <= conns.size ())	873	if (0 < client && client <= conns.size ())
830	{	874	{
831	connection *c = conns [client - 1];	875	connection *c = conns [client - 1];
832	dns_connection *dns = c->dns;	876	dns_connection *dns = c->dns;
833	dns_rcv *rcv;	877	dns_rcv *rcv;
834	bool in_seq;
835		878
836	if (dns)	879	if (dns)
837	{	880	{
838	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	881	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
839	if (SEQNO_EQ ((*i)->seqno, seqno))	882	if (SEQNO_EQ ((*i)->seqno, seqno))
…		…
850	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	893	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
851		894
852	goto duplicate_request;	895	goto duplicate_request;
853	}	896	}
854		897
855	in_seq = dns->rcvseq == seqno;
856
857	// new packet, queue	898	// new packet, queue
858	rcv = new dns_rcv (seqno, data, datalen);	899	rcv = new dns_rcv (seqno, data, datalen);
859	dns->receive_rep (rcv);	900	dns->receive_rep (rcv);
860	}	901	}
861		902
		903	{
862	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section	904	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
863		905
864	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;	906	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
865	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type	907	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
866	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	908	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
867	pkt [offs++] = 0; pkt [offs++] = 0;	909	pkt [offs++] = 0; pkt [offs++] = 0;
868	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL	910	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
869		911
870	int rdlen_offs = offs += 2;	912	int rdlen_offs = offs += 2;
871		913
		914	if (dns)
		915	{
872	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;	916	int dlen = ntohs (dns->cfg.max_size) - offs;
		917
873	// bind doesn't compress well, so reduce further by one label length	918	// bind doesn't compress well, so reduce further by one label length
874	dlen -= qlen;	919	dlen -= qlen;
875		920
876	if (dns)
877	{
878	// only put data into in-order sequence packets, if	921	// only put data into in-order sequence packets, if
879	// we receive out-of-order packets we generate empty	922	// we receive out-of-order packets we generate empty
880	// replies	923	// replies
881	while (dlen > 1 && !dns->snddq.empty () && in_seq)	924	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		925	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
882	{	926	{
		927	dns->repseq = seqno;
		928
		929	while (dlen > 1 && !dns->snddq.empty ())
		930	{
883	int txtlen = dlen <= 255 ? dlen - 1 : 255;	931	int txtlen = dlen <= 255 ? dlen - 1 : 255;
884		932
885	if (txtlen > dns->snddq.size ())	933	if (txtlen > dns->snddq.size ())
886	txtlen = dns->snddq.size ();	934	txtlen = dns->snddq.size ();
887		935
888	pkt[offs++] = txtlen;	936	pkt[offs++] = txtlen;
889	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	937	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
890	offs += txtlen;	938	offs += txtlen;
891	dns->snddq.remove (txtlen);	939	dns->snddq.remove (txtlen);
892		940
893	dlen -= txtlen + 1;	941	dlen -= txtlen + 1;
		942	}
894	}	943	}
895		944
896	// avoid empty TXT rdata	945	// avoid completely empty TXT rdata
897	if (offs == rdlen_offs)	946	if (offs == rdlen_offs)
898	pkt[offs++] = 0;	947	pkt[offs++] = 0;
899		948
900	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());	949	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
901	}	950	}
902	else	951	else
903	{	952	{
904	// send RST	953	// send RST
905	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	954	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
906	pkt [offs++] = CMD_IP_RST;	955	pkt [offs++] = CMD_IP_RST;
907	}	956	}
908		957
909	int rdlen = offs - rdlen_offs;	958	int rdlen = offs - rdlen_offs;
910		959
911	pkt [rdlen_offs - 2] = rdlen >> 8;	960	pkt [rdlen_offs - 2] = rdlen >> 8;
912	pkt [rdlen_offs - 1] = rdlen;	961	pkt [rdlen_offs - 1] = rdlen;
913		962
914	if (dns)	963	if (dns)
915	{	964	{
916	// now update dns_rcv copy	965	// now update dns_rcv copy
917	rcv->pkt->len = offs;	966	rcv->pkt->len = offs;
918	memcpy (rcv->pkt->at (0), pkt.at (0), offs);	967	memcpy (rcv->pkt->at (0), pkt.at (0), offs);
919	}	968	}
		969	}
920		970
921	duplicate_request: ;	971	duplicate_request: ;
922	}	972	}
923	else	973	else
924	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	974	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
…		…
936	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	986	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
937	pkt [offs++] = 0; pkt [offs++] = 0;	987	pkt [offs++] = 0; pkt [offs++] = 0;
938	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	988	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
939	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	989	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
940		990
941	slog (L_INFO, _("DNS: client %d tries to connect"), client);	991	slog (L_INFO, _("DNS: client %d connects"), client);
942		992
943	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	993	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
944	pkt [offs++] = CMD_IP_REJ;	994	pkt [offs++] = CMD_IP_REJ;
945		995
946	if (0 < client && client <= conns.size ())	996	if (0 < client && client <= conns.size ())
…		…
980	{	1030	{
981	dns_connection dns = (i)->dns;	1031	dns_connection dns = (i)->dns;
982	connection *c = dns->c;	1032	connection *c = dns->c;
983	int seqno = (*i)->seqno;	1033	int seqno = (*i)->seqno;
984	u8 data[MAXSIZE], *datap = data;	1034	u8 data[MAXSIZE], *datap = data;
		1035	//printf ("rcv pkt %x\n", seqno);//D
985		1036
986	if ((*i)->retry)	1037	if ((*i)->retry)
987	{	1038	{
988	dns->send_interval *= 1.01;	1039	dns->send_interval *= 1.01;
989	if (dns->send_interval > MAX_SEND_INTERVAL)	1040	if (dns->send_interval > MAX_SEND_INTERVAL)
990	dns->send_interval = MAX_SEND_INTERVAL;	1041	dns->send_interval = MAX_SEND_INTERVAL;
991	}	1042	}
992	else	1043	else
993	{	1044	{
994	#if 1	1045	#if 0
995	dns->send_interval *= 0.999;	1046	dns->send_interval *= 0.999;
996	#endif	1047	#endif
997	if (dns->send_interval < MIN_SEND_INTERVAL)
998	dns->send_interval = MIN_SEND_INTERVAL;
999
1000	// the latency surely puts an upper bound on	1048	// the latency surely puts an upper bound on
1001	// the minimum send interval	1049	// the minimum send interval
1002	double latency = NOW - (*i)->sent;	1050	double latency = ev_now () - (*i)->sent;
		1051
		1052	if (latency < dns->min_latency)
1003	dns->last_latency = latency;	1053	dns->min_latency = latency;
1004		1054
1005	if (dns->send_interval > latency)	1055	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1056	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1057
		1058	if (dns->send_interval < conf.dns_send_interval)
1006	dns->send_interval = latency;	1059	dns->send_interval = conf.dns_send_interval;
1007	}	1060	}
1008		1061
1009	delete *i;	1062	delete *i;
1010	dns_sndpq.erase (i);	1063	dns_sndpq.erase (i);
1011		1064
…		…
1116	break;	1169	break;
1117	}	1170	}
1118	}	1171	}
1119		1172
1120	void	1173	void
1121	vpn::dnsv4_ev (io_watcher &w, short revents)	1174	vpn::dnsv4_ev (ev::io &w, int revents)
1122	{	1175	{
1123	if (revents & EVENT_READ)	1176	if (revents & EV_READ)
1124	{	1177	{
1125	dns_packet *pkt = new dns_packet;	1178	dns_packet *pkt = new dns_packet;
1126	struct sockaddr_in sa;	1179	struct sockaddr_in sa;
1127	socklen_t sa_len = sizeof (sa);	1180	socklen_t sa_len = sizeof (sa);
1128		1181
1129	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);	1182	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1130		1183
1131	if (pkt->len > 0)	1184	if (pkt->len > 0)
1132	{	1185	{
1133	if (THISNODE->dns_port)	1186	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1187	dnsv4_client (*pkt);
		1188	else
1134	{	1189	{
1135	dnsv4_server (*pkt);	1190	dnsv4_server (*pkt);
1136	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);	1191	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1137	}	1192	}
1138	else
1139	dnsv4_client (*pkt);
1140		1193
1141	delete pkt;	1194	delete pkt;
1142	}	1195	}
1143	}	1196	}
1144	}	1197	}
1145		1198
1146	bool	1199	bool
1147	connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1200	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1148	{	1201	{
		1202	int client = ntohl (si.host);
		1203
		1204	assert (0 < client && client <= conns.size ());
		1205
		1206	connection *c = conns [client - 1];
		1207
1149	if (!dns)	1208	if (!c->dns)
1150	dns = new dns_connection (this);	1209	c->dns = new dns_connection (c);
1151		1210
1152	if (!dns->snddq.put (pkt))	1211	if (c->dns->snddq.put (pkt))
1153	return false;	1212	c->dns->tw ();
1154		1213
1155	dns->tw.trigger ();	1214	// always return true even if the buffer overflows
1156
1157	return true;	1215	return true;
1158	}	1216	}
1159		1217
1160	void	1218	void
1161	connection::dnsv4_reset_connection ()	1219	connection::dnsv4_reset_connection ()
…		…
1164	}	1222	}
1165		1223
1166	#define NEXT(w) do { if (next > (w)) next = w; } while (0)	1224	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1167		1225
1168	void	1226	void
1169	dns_connection::time_cb (time_watcher &w)	1227	dns_connection::time_cb (ev::timer &w, int revents)
1170	{	1228	{
1171	// servers have to be polled	1229	// servers have to be polled
1172	if (THISNODE->dns_port)	1230	if (THISNODE->dns_port)
1173	return;	1231	return;
1174		1232
1175	// check for timeouts and (re)transmit	1233	// check for timeouts and (re)transmit
1176	tstamp next = NOW + poll_interval;	1234	tstamp next = ev::now () + poll_interval;
1177	dns_snd *send = 0;	1235	dns_snd *send = 0;
1178		1236
1179	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1237	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1180	i != vpn->dns_sndpq.end ();	1238	i != vpn->dns_sndpq.end ();
1181	++i)	1239	++i)
1182	{	1240	{
1183	dns_snd r = i;	1241	dns_snd r = i;
1184		1242
1185	if (r->timeout <= NOW)	1243	if (r->timeout <= ev_now ())
1186	{	1244	{
1187	if (!send)	1245	if (!send)
1188	{	1246	{
1189	send = r;	1247	send = r;
1190		1248
1191	r->retry++;	1249	r->retry++;
1192	r->timeout = NOW + (r->retry * last_latency * 8.);	1250	r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
		1251	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1193		1252
1194	// the following code changes the query section a bit, forcing	1253	// the following code changes the query section a bit, forcing
1195	// the forwarder to generate a new request	1254	// the forwarder to generate a new request
1196	if (r->stdhdr)	1255	if (r->stdhdr)
1197	{
1198	//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);
1199	//encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);	1256	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1200	}
1201	}	1257	}
1202	}	1258	}
1203	else	1259	else
1204	NEXT (r->timeout);	1260	NEXT (r->timeout);
1205	}	1261	}
1206		1262
1207	if (last_sent + send_interval <= NOW)
1208	{
1209	if (!send)	1263	if (!send)
		1264	{
		1265	// generate a new packet, if wise
		1266
		1267	if (!established)
1210	{	1268	{
1211	// generate a new packet, if wise	1269	if (vpn->dns_sndpq.empty ())
1212
1213	if (!established)
1214	{	1270	{
1215	if (vpn->dns_sndpq.empty ())
1216	{
1217	send = new dns_snd (this);	1271	send = new dns_snd (this);
1218		1272
1219	cfg.reset (THISNODE->id);	1273	cfg.reset (THISNODE->id);
1220	send->gen_syn_req (cfg);	1274	send->gen_syn_req ();
1221	}
1222	}	1275	}
1223	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING	1276	}
		1277	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1224	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))	1278	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1279	{
		1280	if (last_sent + send_interval <= ev_now ())
1225	{	1281	{
1226	if (!snddq.empty ())	1282	//printf ("sending data request etc.\n"); //D
		1283	if (!snddq.empty () \|\| last_received + 1. > ev_now ())
1227	{	1284	{
1228	poll_interval = send_interval;	1285	poll_interval = send_interval;
1229	NEXT (NOW + send_interval);	1286	NEXT (ev_now () + send_interval);
1230	}	1287	}
1231		1288
1232	send = new dns_snd (this);	1289	send = new dns_snd (this);
1233	send->gen_stream_req (sndseq, snddq);	1290	send->gen_stream_req (sndseq, snddq);
1234	send->timeout = NOW + last_latency * 8.;	1291	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1292	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1235		1293
1236	sndseq = (sndseq + 1) & SEQNO_MASK;	1294	sndseq = (sndseq + 1) & SEQNO_MASK;
1237	}	1295	}
1238		1296	else
1239	if (send)	1297	NEXT (last_sent + send_interval);
1240	vpn->dns_sndpq.push_back (send);
1241	}	1298	}
1242		1299
1243	if (send)	1300	if (send)
1244	{	1301	vpn->dns_sndpq.push_back (send);
1245	last_sent = NOW;	1302	}
		1303
		1304	if (send)
		1305	{
		1306	last_sent = ev_now ();
1246	sendto (vpn->dnsv4_fd,	1307	sendto (vpn->dnsv4_fd,
1247	send->pkt->at (0), send->pkt->len, 0,	1308	send->pkt->at (0), send->pkt->len, 0,
1248	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1309	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1249	}
1250	}	1310	}
1251	else
1252	NEXT (last_sent + send_interval);
1253		1311
1254	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d)",	1312	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1255	poll_interval, send_interval, next - NOW,	1313	poll_interval, send_interval, next - ev_now (),
1256	vpn->dns_sndpq.size (), snddq.size ());	1314	vpn->dns_sndpq.size (), snddq.size (),
		1315	rcvpq.size ());
1257		1316
1258	// TODO: no idea when this happens, but when next < NOW, we have a problem	1317	// TODO: no idea when this happens, but when next < ev_now (), we have a problem
		1318	// doesn't seem to happen anymore
1259	if (next < NOW + 0.0001)	1319	if (next < ev_now () + 0.001)
1260	next = NOW + 0.1;	1320	next = ev_now () + 0.1;
1261		1321
1262	w.start (next);	1322	w.start (next - ev_now ());
1263	}	1323	}
1264		1324
1265	#endif	1325	#endif
1266		1326

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.17 by pcg, Sat Mar 5 03:47:05 2005 UTC vs. Revision 1.48 by pcg, Tue Jul 28 00:42:14 2009 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.17 by pcg, Sat Mar 5 03:47:05 2005 UTC vs.
Revision 1.48 by pcg, Tue Jul 28 00:42:14 2009 UTC