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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.11 by pcg, Fri Mar 4 08:45:24 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
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 .2 // how often to poll minimally when the server is having 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 1.	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
53	#define INITIAL_SYN_TIMEOUT 2.	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54		69
55	#define MIN_SEND_INTERVAL 0.001
56	#define MAX_SEND_INTERVAL 0.5 // optimistic?	70	#define MAX_SEND_INTERVAL 2. // optimistic?
57		71
58	#define MAX_OUTSTANDING 400 // max. outstanding requests
59	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
60	#define MAX_BACKLOG (100*1024) // size of protocol backlog, 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 byte sless give room for one reply byte	77	// every request byte less give room for two reply bytes
65		78
66	#define SEQNO_MASK 0xffff	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
…		…
154	enc_len [len] = n;	168	enc_len [len] = n;
155	dec_len [n] = len;	169	dec_len [n] = len;
156	}	170	}
157	}	171	}
158		172
		173	unsigned int
159	unsigned int basecoder::encode_len (unsigned int len)	174	basecoder::encode_len (unsigned int len)
160	{	175	{
161	return enc_len [len];	176	return enc_len [len];
162	}	177	}
163		178
		179	unsigned int
164	unsigned int basecoder::decode_len (unsigned int len)	180	basecoder::decode_len (unsigned int len)
165	{	181	{
166	while (len && !dec_len [len])	182	while (len && !dec_len [len])
167	--len;	183	--len;
168		184
169	return dec_len [len];	185	return dec_len [len];
170	}	186	}
171		187
		188	unsigned int
172	unsigned int basecoder::encode (char dst, u8 src, unsigned int len)	189	basecoder::encode (char dst, u8 src, unsigned int len)
173	{	190	{
174	if (!len \|\| len > MAX_DEC_LEN)	191	if (!len \|\| len > MAX_DEC_LEN)
175	return 0;	192	return 0;
176		193
177	int elen = encode_len (len);	194	int elen = encode_len (len);
…		…
196	*dst++ = cmap.encode [dst_ [i]];	213	*dst++ = cmap.encode [dst_ [i]];
197		214
198	return elen;	215	return elen;
199	}	216	}
200		217
		218	unsigned int
201	unsigned int basecoder::decode (u8 dst, char src, unsigned int len)	219	basecoder::decode (u8 dst, char src, unsigned int len)
202	{	220	{
203	if (!len \|\| len > MAX_ENC_LEN)	221	if (!len \|\| len > MAX_ENC_LEN)
204	return 0;	222	return 0;
205		223
206	u8 src_ [MAX_ENC_LEN];	224	u8 src_ [MAX_ENC_LEN];
…		…
264	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	282	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
265		283
266	/////////////////////////////////////////////////////////////////////////////	284	/////////////////////////////////////////////////////////////////////////////
267		285
268	#define HDRSIZE 6	286	#define HDRSIZE 6
269		287
		288	inline void
270	inline void encode_header (char *data, int clientid, int seqno)	289	encode_header (char *data, int clientid, int seqno, int retry = 0)
271	{	290	{
272	u8 hdr[3] = { clientid, seqno >> 8, seqno };	291	seqno &= SEQNO_MASK;
		292
		293	u8 hdr[3] = {
		294	clientid,
		295	(seqno >> 8) \| (retry << 6),
		296	seqno,
		297	};
273		298
274	assert (clientid < 256);	299	assert (clientid < 256);
275		300
276	cdc26.encode (data, hdr, 3);	301	cdc26.encode (data, hdr, 3);
277	}	302	}
278		303
		304	inline void
279	inline void decode_header (char *data, int &clientid, int &seqno)	305	decode_header (char *data, int &clientid, int &seqno)
280	{	306	{
281	u8 hdr[3];	307	u8 hdr[3];
282		308
283	cdc26.decode (hdr, data, HDRSIZE);	309	cdc26.decode (hdr, data, HDRSIZE);
284		310
285	clientid = hdr[0];	311	clientid = hdr[0];
286	seqno = (hdr[1] << 8) \| hdr[2];	312	seqno = ((hdr[1] << 8) \| hdr[2]) & SEQNO_MASK;
287	}	313	}
288		314
289	/////////////////////////////////////////////////////////////////////////////	315	/////////////////////////////////////////////////////////////////////////////
290		316
291	struct byte_stream	317	struct byte_stream
…		…
317	byte_stream::~byte_stream ()	343	byte_stream::~byte_stream ()
318	{	344	{
319	delete data;	345	delete data;
320	}	346	}
321		347
		348	void
322	void byte_stream::remove (int count)	349	byte_stream::remove (int count)
323	{	350	{
324	if (count > fill)	351	if (count > fill)
325	abort ();	352	assert (count <= fill);
326		353
327	memmove (data, data + count, fill -= count);	354	memmove (data, data + count, fill -= count);
328	}	355	}
329		356
		357	bool
330	bool byte_stream::put (u8 *data, unsigned int datalen)	358	byte_stream::put (u8 *data, unsigned int datalen)
331	{	359	{
332	if (maxsize - fill < datalen)	360	if (maxsize - fill < datalen)
333	return false;	361	return false;
334		362
335	memcpy (this->data + fill, data, datalen); fill += datalen;	363	memcpy (this->data + fill, data, datalen); fill += datalen;
336		364
337	return true;	365	return true;
338	}	366	}
339		367
		368	bool
340	bool byte_stream::put (vpn_packet *pkt)	369	byte_stream::put (vpn_packet *pkt)
341	{	370	{
342	if (maxsize - fill < pkt->len + 2)	371	if (maxsize - fill < pkt->len + 2)
343	return false;	372	return false;
344		373
345	data [fill++] = pkt->len >> 8;	374	data [fill++] = pkt->len >> 8;
…		…
350	return true;	379	return true;
351	}	380	}
352		381
353	vpn_packet *byte_stream::get ()	382	vpn_packet *byte_stream::get ()
354	{	383	{
		384	unsigned int len;
		385
		386	for (;;)
		387	{
355	int len = (data [0] << 8) \| data [1];	388	len = (data [0] << 8) \| data [1];
356		389
357	if (len > MAXSIZE && fill >= 2)	390	if (len <= MAXSIZE \|\| fill < 2)
358	abort (); // TODO handle this gracefully, connection reset	391	break;
359		392
		393	// TODO: handle this better than skipping, e.g. by reset
		394	slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
		395	remove (1);
		396	}
		397
360	if (fill < len + 2)	398	if (fill < len + 2)
361	return 0;	399	return 0;
362		400
363	vpn_packet *pkt = new vpn_packet;	401	vpn_packet *pkt = new vpn_packet;
364		402
…		…
393	struct dns_cfg	431	struct dns_cfg
394	{	432	{
395	static int next_uid;	433	static int next_uid;
396		434
397	u8 id1, id2, id3, id4;	435	u8 id1, id2, id3, id4;
		436
398	u8 version;	437	u8 version;
		438	u8 flags;
399	u8 rrtype;	439	u8 rrtype;
400	u8 flags;
401	u8 def_ttl;	440	u8 def_ttl;
402	u8 rcv_cdc;	441
403	u8 snd_cdc;
404	u16 max_size;
405	u16 client;	442	u16 client;
406	u16 uid; // to make request unique	443	u16 uid; // to make request unique
407		444
408	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;
409		454
410	void reset (int clientid);	455	void reset (int clientid);
411	bool valid ();	456	bool valid ();
412	};	457	};
413		458
414	int dns_cfg::next_uid;	459	int dns_cfg::next_uid;
415		460
		461	void
416	void dns_cfg::reset (int clientid)	462	dns_cfg::reset (int clientid)
417	{	463	{
418	id1 = 'G';	464	id1 = 'G';
419	id2 = 'V';	465	id2 = 'V';
420	id3 = 'P';	466	id3 = 'P';
421	id4 = 'E';	467	id4 = 'E';
…		…
423	version = 1;	469	version = 1;
424		470
425	rrtype = RR_TYPE_TXT;	471	rrtype = RR_TYPE_TXT;
426	flags = 0;	472	flags = 0;
427	def_ttl = 0;	473	def_ttl = 0;
		474	seq_cdc = 26;
		475	req_cdc = 62;
428	rcv_cdc = 0;	476	rep_cdc = 0;
429	snd_cdc = 62;
430	max_size = ntohs (MAX_PKT_SIZE);	477	max_size = htons (MAX_PKT_SIZE);
431	client = ntohs (clientid);	478	client = htons (clientid);
432	uid = next_uid++;	479	uid = next_uid++;
		480	delay = 0;
433		481
434	memset (reserved, 0, 8);	482	r3 = r4 = 0;
		483	r4 = r5 = r6 = r7 = 0;
435	}	484	}
436		485
		486	bool
437	bool dns_cfg::valid ()	487	dns_cfg::valid ()
438	{	488	{
		489	// although the protocol itself allows for some configurability,
		490	// only the following encoding/decoding settings are implemented.
439	return id1 == 'G'	491	return id1 == 'G'
440	&& id2 == 'V'	492	&& id2 == 'V'
441	&& id3 == 'P'	493	&& id3 == 'P'
442	&& id4 == 'E'	494	&& id4 == 'E'
		495	&& seq_cdc == 26
		496	&& req_cdc == 62
		497	&& rep_cdc == 0
443	&& version == 1	498	&& version == 1;
444	&& flags == 0
445	&& rcv_cdc == 0
446	&& snd_cdc == 62
447	&& max_size == ntohs (MAX_PKT_SIZE);
448	}	499	}
449		500
450	struct dns_packet : net_packet	501	struct dns_packet : net_packet
451	{	502	{
452	u16 id;	503	u16 id;
453	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
454	u16 qdcount, ancount, nscount, arcount;	505	u16 qdcount, ancount, nscount, arcount;
455		506
456	u8 data[MAXSIZE - 6 * 2];	507	u8 data [MAXSIZE - 6 * 2];
457		508
458	int decode_label (char *data, int size, int &offs);	509	int decode_label (char *data, int size, int &offs);
459	};	510	};
460		511
		512	int
461	int dns_packet::decode_label (char *data, int size, int &offs)	513	dns_packet::decode_label (char *data, int size, int &offs)
462	{	514	{
463	char *orig = data;	515	char *orig = data;
464		516
465	memset (data, 0, size);	517	memset (data, 0, size);
466		518
…		…
492	return data - orig;	544	return data - orig;
493	}	545	}
494		546
495	/////////////////////////////////////////////////////////////////////////////	547	/////////////////////////////////////////////////////////////////////////////
496		548
497	struct dns_snd	549	static
		550	u16 next_id ()
498	{	551	{
499	dns_packet *pkt;
500	tstamp timeout, sent;
501	int retry;
502	struct dns_connection *dns;
503	int seqno;
504
505	void gen_stream_req (int seqno, byte_stream &stream);
506	void gen_syn_req (const dns_cfg &cfg);
507
508	dns_snd (dns_connection *dns);
509	~dns_snd ();
510	};
511
512	static u16 dns_id = 12098; // TODO: should be per-vpn	552	static u16 dns_id = 0; // TODO: should be per-vpn
513		553
514	static u16 next_id ()	554	if (!dns_id)
515	{	555	dns_id = time (0);
		556
516	// the simplest lsfr with periodicity 65535 i could find	557	// the simplest lsfr with periodicity 65535 i could find
517	dns_id = (dns_id << 1)	558	dns_id = (dns_id << 1)
518	\| (((dns_id >> 1)	559	\| (((dns_id >> 1)
519	^ (dns_id >> 2)	560	^ (dns_id >> 2)
520	^ (dns_id >> 4)	561	^ (dns_id >> 4)
521	^ (dns_id >> 15)) & 1);	562	^ (dns_id >> 15)) & 1);
522		563
523	return dns_id;	564	return dns_id;
524	}	565	}
525		566
		567	struct dns_rcv;
		568	struct dns_snd;
		569
		570	struct dns_connection
		571	{
		572	connection *c;
		573	struct vpn *vpn;
		574
		575	dns_cfg cfg;
		576
		577	bool established;
		578
		579	tstamp last_received;
		580	tstamp last_sent;
		581	double min_latency;
		582	double poll_interval, send_interval;
		583
		584	vector<dns_rcv *> rcvpq;
		585
		586	byte_stream rcvdq; int rcvseq; int repseq;
		587	byte_stream snddq; int sndseq;
		588
		589	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
		590	void receive_rep (dns_rcv *r);
		591
		592	dns_connection (connection *c);
		593	~dns_connection ();
		594	};
		595
		596	struct dns_snd
		597	{
		598	dns_packet *pkt;
		599	tstamp timeout, sent;
		600	int retry;
		601	struct dns_connection *dns;
		602	int seqno;
		603	bool stdhdr;
		604
		605	void gen_stream_req (int seqno, byte_stream &stream);
		606	void gen_syn_req ();
		607
		608	dns_snd (dns_connection *dns);
		609	~dns_snd ();
		610	};
		611
526	dns_snd::dns_snd (dns_connection *dns)	612	dns_snd::dns_snd (dns_connection *dns)
527	: dns (dns)	613	: dns (dns)
528	{	614	{
529	timeout = 0;	615	timeout = 0;
530	retry = 0;	616	retry = 0;
531	seqno = 0;	617	seqno = 0;
532	sent = NOW;	618	sent = ev_now ();
		619	stdhdr = false;
533		620
534	pkt = new dns_packet;	621	pkt = new dns_packet;
535		622
536	pkt->id = next_id ();	623	pkt->id = next_id ();
537	}	624	}
…		…
539	dns_snd::~dns_snd ()	626	dns_snd::~dns_snd ()
540	{	627	{
541	delete pkt;	628	delete pkt;
542	}	629	}
543		630
		631	static void
544	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	632	append_domain (dns_packet &pkt, int &offs, const char *domain)
545	{	633	{
546	// add tunnel domain	634	// add tunnel domain
547	for (;;)	635	for (;;)
548	{	636	{
549	const char *end = strchr (domain, '.');	637	const char *end = strchr (domain, '.');
…		…
562		650
563	domain = end + 1;	651	domain = end + 1;
564	}	652	}
565	}	653	}
566		654
		655	void
567	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	656	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
568	{	657	{
		658	stdhdr = true;
569	this->seqno = seqno;	659	this->seqno = seqno;
570		660
571	timeout = NOW + INITIAL_TIMEOUT;	661	timeout = ev_now () + INITIAL_TIMEOUT;
572		662
573	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	663	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
574	pkt->qdcount = htons (1);	664	pkt->qdcount = htons (1);
575		665
576	int offs = 6*2;	666	int offs = 6*2;
577	int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2);	667	int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
578	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,	668	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,
579	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	669	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
580		670
581	char enc[256], *encp = enc;	671	char enc[256], *encp = enc;
582	encode_header (enc, THISNODE->id, seqno);	672	encode_header (enc, THISNODE->id, seqno);
…		…
600	encp += lbllen;	690	encp += lbllen;
601		691
602	enclen -= lbllen;	692	enclen -= lbllen;
603	}	693	}
604		694
605	append_domain (*pkt, offs, THISNODE->domain);	695	append_domain (*pkt, offs, dns->c->conf->domain);
606		696
607	(*pkt)[offs++] = 0;	697	(*pkt)[offs++] = 0;
608	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;	698	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;
609	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	699	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
610		700
611	pkt->len = offs;	701	pkt->len = offs;
612	}	702	}
613		703
614	void dns_snd::gen_syn_req (const dns_cfg &cfg)	704	void
		705	dns_snd::gen_syn_req ()
615	{	706	{
616	timeout = NOW + INITIAL_SYN_TIMEOUT;	707	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
617		708
618	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	709	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
619	pkt->qdcount = htons (1);	710	pkt->qdcount = htons (1);
620		711
621	int offs = 6*2;	712	int offs = 6 * 2;
622		713
623	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&cfg, sizeof (dns_cfg));	714	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&dns->cfg, sizeof (dns_cfg));
624		715
625	assert (elen <= MAX_LBL_SIZE);	716	assert (elen <= MAX_LBL_SIZE);
626		717
627	(*pkt)[offs] = elen;	718	(*pkt)[offs] = elen;
628	offs += elen + 1;	719	offs += elen + 1;
629	append_domain (*pkt, offs, THISNODE->domain);	720	append_domain (*pkt, offs, dns->c->conf->domain);
630		721
631	(*pkt)[offs++] = 0;	722	(*pkt)[offs++] = 0;
632	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;	723	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;
633	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	724	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
634		725
…		…
657	delete pkt;	748	delete pkt;
658	}	749	}
659		750
660	/////////////////////////////////////////////////////////////////////////////	751	/////////////////////////////////////////////////////////////////////////////
661		752
662	struct dns_connection
663	{
664	connection *c;
665	struct vpn *vpn;
666
667	dns_cfg cfg;
668
669	bool established;
670
671	tstamp last_received;
672	tstamp last_sent;
673	double poll_interval, send_interval;
674
675	vector<dns_rcv *> rcvpq;
676
677	byte_stream rcvdq; int rcvseq;
678	byte_stream snddq; int sndseq;
679
680	void time_cb (time_watcher &w); time_watcher tw;
681	void receive_rep (dns_rcv *r);
682
683	dns_connection (connection *c);
684	~dns_connection ();
685	};
686
687	dns_connection::dns_connection (connection *c)	753	dns_connection::dns_connection (connection *c)
688	: c (c)	754	: c (c)
689	, rcvdq (MAX_BACKLOG * 2)	755	, rcvdq (MAX_BACKLOG * 2)
690	, snddq (MAX_BACKLOG * 2)	756	, snddq (MAX_BACKLOG)
691	, tw (this, &dns_connection::time_cb)
692	{	757	{
		758	tw.set<dns_connection, &dns_connection::time_cb> (this);
		759
693	vpn = c->vpn;	760	vpn = c->vpn;
694		761
695	established = false;	762	established = false;
696		763
697	rcvseq = sndseq = 0;	764	rcvseq = repseq = sndseq = 0;
698		765
699	last_sent = last_received = 0;	766	last_sent = last_received = 0;
700	poll_interval = MIN_POLL_INTERVAL;	767	poll_interval = 0.5; // starting here
701	send_interval = 0.2; // starting rate	768	send_interval = 0.5; // starting rate
		769	min_latency = INITIAL_TIMEOUT;
702	}	770	}
703		771
704	dns_connection::~dns_connection ()	772	dns_connection::~dns_connection ()
705	{	773	{
706	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	774	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
707	i != rcvpq.end ();	775	i != rcvpq.end ();
708	++i)	776	++i)
709	delete *i;	777	delete *i;
710	}	778	}
711		779
		780	void
712	void dns_connection::receive_rep (dns_rcv *r)	781	dns_connection::receive_rep (dns_rcv *r)
713	{	782	{
714	if (r->datalen)	783	if (r->datalen)
715	{	784	{
716	last_received = NOW;	785	last_received = ev_now ();
717	tw.trigger ();	786	tw ();
718		787
719	poll_interval *= 0.99;	788	poll_interval = send_interval;
720	if (poll_interval > MIN_POLL_INTERVAL)
721	poll_interval = MIN_POLL_INTERVAL;
722	}	789	}
723	else	790	else
724	{	791	{
725	poll_interval *= 1.1;	792	poll_interval *= 1.5;
		793
726	if (poll_interval > MAX_POLL_INTERVAL)	794	if (poll_interval > MAX_POLL_INTERVAL)
727	poll_interval = MAX_POLL_INTERVAL;	795	poll_interval = MAX_POLL_INTERVAL;
728	}	796	}
729		797
730	rcvpq.push_back (r);	798	rcvpq.push_back (r);
…		…
733		801
734	// find next packet	802	// find next packet
735	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	803	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
736	if (SEQNO_EQ (rcvseq, (*i)->seqno))	804	if (SEQNO_EQ (rcvseq, (*i)->seqno))
737	{	805	{
		806	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
738	// enter the packet into our input stream	807	// enter the packet into our input stream
739	r = *i;	808	r = *i;
740		809
741	// remove the oldest packet, look forward, as it's oldest first	810	// remove the oldest packet, look forward, as it's oldest first
742	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)
743	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	812	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
744	{	813	{
		814	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
745	delete *j;	815	delete *j;
746	rcvpq.erase (j);	816	rcvpq.erase (j);
747	break;	817	break;
748	}	818	}
749		819
750	rcvseq = (rcvseq + 1) & SEQNO_MASK;	820	rcvseq = (rcvseq + 1) & SEQNO_MASK;
751		821
752	if (!rcvdq.put (r->data, r->datalen))	822	if (!rcvdq.put (r->data, r->datalen))
		823	{
		824	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
753	abort (); // MUST never overflow, can be caused by data corruption, TODO	825	abort (); // MUST never overflow, can be caused by data corruption, TODO
		826	}
754		827
755	while (vpn_packet *pkt = rcvdq.get ())	828	while (vpn_packet *pkt = rcvdq.get ())
756	{	829	{
757	sockinfo si;	830	sockinfo si;
758	si.host = 0; si.port = 0; si.prot = PROT_DNSv4;	831	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
759		832
760	vpn->recv_vpn_packet (pkt, si);	833	vpn->recv_vpn_packet (pkt, si);
761		834
762	delete pkt;	835	delete pkt;
763	}	836	}
…		…
777	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	850	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
778		851
779	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	852	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
780	&& pkt.qdcount == htons (1))	853	&& pkt.qdcount == htons (1))
781	{	854	{
782	char qname[MAXSIZE];	855	char qname [MAXSIZE];
783	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	856	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
784		857
785	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	858	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
786	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	859	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
787		860
788	pkt.qdcount = htons (1);	861	pkt.qdcount = htons (1);
789	pkt.ancount = 0;	862	pkt.ancount = 0;
790	pkt.nscount = 0; // should be self, as other nameservers reply like this	863	pkt.nscount = 0; // should be self, as other nameservers reply like this
791	pkt.arcount = 0; // a record for self, as other nameservers reply like this	864	pkt.arcount = 0; // a record for self, as other nameservers reply like this
792		865
793	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_NXDOMAIN);	866	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_SERVFAIL);
794		867
795	int dlen = strlen (THISNODE->domain);	868	int dlen = strlen (THISNODE->domain);
796		869
797	if (qclass == RR_CLASS_IN	870	if (qclass == RR_CLASS_IN
798	&& qlen > dlen + 1	871	&& qlen > dlen + 1
799	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	872	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
800	{	873	{
801	// now generate reply	874	// now generate reply
802	pkt.ancount = htons (1); // one answer RR	875	pkt.ancount = htons (1); // one answer RR
803	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	876	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
804		877
…		…
826	if (SEQNO_EQ ((*i)->seqno, seqno))	899	if (SEQNO_EQ ((*i)->seqno, seqno))
827	{	900	{
828	// already seen that request: simply reply with the cached reply	901	// already seen that request: simply reply with the cached reply
829	dns_rcv r = i;	902	dns_rcv r = i;
830		903
831	printf ("DUPLICATE %d\n", htons (r->pkt->id));//D	904	slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno);
		905
		906	// refresh header & id, as the retry count could have changed
		907	memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE);
		908	r->pkt->id = pkt.id;
832		909
833	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);
834	pkt.id = r->pkt->id;	911
835	goto duplicate_request;	912	goto duplicate_request;
836	}	913	}
837		914
838	// new packet, queue	915	// new packet, queue
839	rcv = new dns_rcv (seqno, data, datalen);	916	rcv = new dns_rcv (seqno, data, datalen);
840	dns->receive_rep (rcv);	917	dns->receive_rep (rcv);
841	}	918	}
842		919
		920	{
843	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
844		922
845	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;	923	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
846	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type	924	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
847	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
848	pkt [offs++] = 0; pkt [offs++] = 0;	926	pkt [offs++] = 0; pkt [offs++] = 0;
849	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
850		928
851	int rdlen_offs = offs += 2;	929	int rdlen_offs = offs += 2;
852		930
		931	if (dns)
		932	{
853	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;	933	int dlen = ntohs (dns->cfg.max_size) - offs;
		934
854	// 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
855	dlen -= qlen;	936	dlen -= qlen;
856		937
857	if (dns)	938	// only put data into in-order sequence packets, if
858	{	939	// we receive out-of-order packets we generate empty
859	while (dlen > 1 && !dns->snddq.empty ())	940	// replies
		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)
860	{	943	{
		944	dns->repseq = seqno;
		945
		946	while (dlen > 1 && !dns->snddq.empty ())
		947	{
861	int txtlen = dlen <= 255 ? dlen - 1 : 255;	948	int txtlen = dlen <= 255 ? dlen - 1 : 255;
862		949
863	if (txtlen > dns->snddq.size ())	950	if (txtlen > dns->snddq.size ())
864	txtlen = dns->snddq.size ();	951	txtlen = dns->snddq.size ();
865		952
866	pkt[offs++] = txtlen;	953	pkt[offs++] = txtlen;
867	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	954	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
868	offs += txtlen;	955	offs += txtlen;
869	dns->snddq.remove (txtlen);	956	dns->snddq.remove (txtlen);
870		957
871	dlen -= txtlen + 1;	958	dlen -= txtlen + 1;
		959	}
872	}	960	}
873		961
874	// avoid empty TXT rdata	962	// avoid completely empty TXT rdata
875	if (offs == rdlen_offs)	963	if (offs == rdlen_offs)
876	pkt[offs++] = 0;	964	pkt[offs++] = 0;
		965
		966	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
877	}	967	}
878	else	968	else
879	{	969	{
880	// send RST	970	// send RST
881	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;
882	pkt [offs++] = CMD_IP_RST;	972	pkt [offs++] = CMD_IP_RST;
883	}	973	}
884		974
885	int rdlen = offs - rdlen_offs;	975	int rdlen = offs - rdlen_offs;
886		976
887	pkt [rdlen_offs - 2] = rdlen >> 8;	977	pkt [rdlen_offs - 2] = rdlen >> 8;
888	pkt [rdlen_offs - 1] = rdlen;	978	pkt [rdlen_offs - 1] = rdlen;
889		979
890	if (dns)	980	if (dns)
891	{	981	{
892	// now update dns_rcv copy	982	// now update dns_rcv copy
893	rcv->pkt->len = offs;	983	rcv->pkt->len = offs;
894	memcpy (rcv->pkt->at (0), pkt.at (0), offs);	984	memcpy (rcv->pkt->at (0), pkt.at (0), offs);
895	}	985	}
		986	}
896		987
897	duplicate_request: ;	988	duplicate_request: ;
898	}	989	}
899	else	990	else
900	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	991	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
…		…
912	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
913	pkt [offs++] = 0; pkt [offs++] = 0;	1004	pkt [offs++] = 0; pkt [offs++] = 0;
914	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1005	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
915	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1006	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
916		1007
917	slog (L_INFO, _("DNS tunnel: client %d tries to connect"), client);	1008	slog (L_INFO, _("DNS: client %d connects"), client);
918		1009
919	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;
920	pkt [offs++] = CMD_IP_REJ;	1011	pkt [offs++] = CMD_IP_REJ;
921		1012
922	if (0 < client && client <= conns.size ())	1013	if (0 < client && client <= conns.size ())
…		…
953	i != dns_sndpq.end ();	1044	i != dns_sndpq.end ();
954	++i)	1045	++i)
955	if ((*i)->pkt->id == pkt.id)	1046	if ((*i)->pkt->id == pkt.id)
956	{	1047	{
957	dns_connection dns = (i)->dns;	1048	dns_connection dns = (i)->dns;
		1049	connection *c = dns->c;
958	int seqno = (*i)->seqno;	1050	int seqno = (*i)->seqno;
959	u8 data[MAXSIZE], *datap = data;	1051	u8 data[MAXSIZE], *datap = data;
		1052	//printf ("rcv pkt %x\n", seqno);//D
960		1053
961	if ((*i)->retry)	1054	if ((*i)->retry)
962	{	1055	{
963	dns->send_interval *= 1.01;	1056	dns->send_interval *= 1.01;
964	if (dns->send_interval < MAX_SEND_INTERVAL)	1057	if (dns->send_interval > MAX_SEND_INTERVAL)
965	dns->send_interval = MAX_SEND_INTERVAL;	1058	dns->send_interval = MAX_SEND_INTERVAL;
966	}	1059	}
967	else	1060	else
968	{	1061	{
		1062	#if 0
969	dns->send_interval *= 0.99;	1063	dns->send_interval *= 0.999;
970	if (dns->send_interval < MIN_SEND_INTERVAL)	1064	#endif
971	dns->send_interval = MIN_SEND_INTERVAL;
972
973	// the latency surely puts an upper bound on	1065	// the latency surely puts an upper bound on
974	// the minimum send interval	1066	// the minimum send interval
975	if (dns->send_interval > NOW - (*i)->sent)	1067	double latency = ev_now () - (*i)->sent;
976	dns->send_interval = NOW - (*i)->sent;	1068
		1069	if (latency < dns->min_latency)
		1070	dns->min_latency = latency;
		1071
		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)
		1076	dns->send_interval = conf.dns_send_interval;
977	}	1077	}
978		1078
979	delete *i;	1079	delete *i;
980	dns_sndpq.erase (i);	1080	dns_sndpq.erase (i);
981		1081
…		…
1031		1131
1032	if (ip [0] == CMD_IP_1	1132	if (ip [0] == CMD_IP_1
1033	&& ip [1] == CMD_IP_2	1133	&& ip [1] == CMD_IP_2
1034	&& ip [2] == CMD_IP_3)	1134	&& ip [2] == CMD_IP_3)
1035	{	1135	{
1036	slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]);	1136	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1037		1137
1038	if (ip [3] == CMD_IP_RST)	1138	if (ip [3] == CMD_IP_RST)
1039	{	1139	{
1040	slog (L_DEBUG, _("got tunnel RST request"));	1140	slog (L_DEBUG, _("DNS: got tunnel RST request"));
1041		1141
1042	connection *c = dns->c;
1043	delete c->dns; c->dns = 0;	1142	delete dns; c->dns = 0;
1044		1143
1045	return;	1144	return;
1046	}	1145	}
1047	else if (ip [3] == CMD_IP_SYN)	1146	else if (ip [3] == CMD_IP_SYN)
		1147	{
		1148	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1048	dns->established = true;	1149	dns->established = true;
		1150	}
		1151	else if (ip [3] == CMD_IP_REJ)
		1152	{
		1153	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
		1154	abort ();
		1155	}
1049	else	1156	else
1050	slog (L_INFO, _("got unknown meta command %02x"), ip [3]);	1157	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1051	}	1158	}
1052	else	1159	else
1053	slog (L_INFO, _("got spurious a record %d.%d.%d.%d"),	1160	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1054	ip [0], ip [1], ip [2], ip [3]);	1161	ip [0], ip [1], ip [2], ip [3]);
1055		1162
1056	return;	1163	return;
1057	}	1164	}
1058		1165
1059	int client, rseqno;	1166	int client, rseqno;
1060	decode_header (qname, client, rseqno);	1167	decode_header (qname, client, rseqno);
1061		1168
1062	if (client != THISNODE->id)	1169	if (client != THISNODE->id)
1063	{	1170	{
1064	slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring"));	1171	slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1065	datap = 0;	1172	datap = 0;
1066	}	1173	}
1067	else if (rseqno != seqno)	1174	else if (rseqno != seqno)
1068	{	1175	{
1069	slog (L_DEBUG, _("got dns tunnel response with wrong seqno, badly caching nameserver?"));	1176	slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
1070	datap = 0;	1177	datap = 0;
1071	}	1178	}
1072	}	1179	}
1073	}	1180	}
1074		1181
…		…
1079	break;	1186	break;
1080	}	1187	}
1081	}	1188	}
1082		1189
1083	void	1190	void
1084	vpn::dnsv4_ev (io_watcher &w, short revents)	1191	vpn::dnsv4_ev (ev::io &w, int revents)
1085	{	1192	{
1086	if (revents & EVENT_READ)	1193	if (revents & EV_READ)
1087	{	1194	{
1088	dns_packet *pkt = new dns_packet;	1195	dns_packet *pkt = new dns_packet;
1089	struct sockaddr_in sa;	1196	struct sockaddr_in sa;
1090	socklen_t sa_len = sizeof (sa);	1197	socklen_t sa_len = sizeof (sa);
1091		1198
1092	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);
1093		1200
1094	if (pkt->len > 0)	1201	if (pkt->len > 0)
1095	{	1202	{
1096	if (THISNODE->dns_port)	1203	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1204	dnsv4_client (*pkt);
		1205	else
1097	{	1206	{
1098	dnsv4_server (*pkt);	1207	dnsv4_server (*pkt);
1099	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);
1100	}	1209	}
1101	else
1102	dnsv4_client (*pkt);
1103		1210
1104	delete pkt;	1211	delete pkt;
1105	}	1212	}
1106	}	1213	}
1107	}	1214	}
1108		1215
1109	bool	1216	bool
1110	connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1217	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1111	{	1218	{
		1219	int client = ntohl (si.host);
		1220
		1221	assert (0 < client && client <= conns.size ());
		1222
		1223	connection *c = conns [client - 1];
		1224
1112	if (!dns)	1225	if (!c->dns)
1113	dns = new dns_connection (this);	1226	c->dns = new dns_connection (c);
1114		1227
1115	if (!dns->snddq.put (pkt))	1228	if (c->dns->snddq.put (pkt))
1116	return false;	1229	c->dns->tw ();
1117		1230
1118	dns->tw.trigger ();	1231	// always return true even if the buffer overflows
1119
1120	return true;	1232	return true;
1121	}	1233	}
1122		1234
		1235	void
		1236	connection::dnsv4_reset_connection ()
		1237	{
		1238	//delete dns; dns = 0; //TODO
		1239	}
		1240
1123	#define NEXT(w) do { if (next > (w)) next = w; } while (0)	1241	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1124		1242
1125	void	1243	void
1126	dns_connection::time_cb (time_watcher &w)	1244	dns_connection::time_cb (ev::timer &w, int revents)
1127	{	1245	{
1128	// servers have to be polled	1246	// servers have to be polled
1129	if (THISNODE->dns_port)	1247	if (THISNODE->dns_port)
1130	return;	1248	return;
1131		1249
1132	// check for timeouts and (re)transmit	1250	// check for timeouts and (re)transmit
1133	tstamp next = NOW + poll_interval;	1251	tstamp next = ev::now () + poll_interval;
1134	dns_snd *send = 0;	1252	dns_snd *send = 0;
1135		1253
1136	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1254	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1137	i != vpn->dns_sndpq.end ();	1255	i != vpn->dns_sndpq.end ();
1138	++i)	1256	++i)
1139	{	1257	{
1140	dns_snd r = i;	1258	dns_snd r = i;
1141		1259
1142	if (r->timeout <= NOW)	1260	if (r->timeout <= ev_now ())
1143	{	1261	{
1144	if (!send)	1262	if (!send)
1145	{	1263	{
1146	send = r;	1264	send = r;
1147		1265
1148	r->retry++;	1266	r->retry++;
1149	r->timeout = NOW + r->retry;	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
		1269
		1270	// the following code changes the query section a bit, forcing
		1271	// the forwarder to generate a new request
		1272	if (r->stdhdr)
		1273	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1150	}	1274	}
1151	}	1275	}
1152	else	1276	else
1153	NEXT (r->timeout);	1277	NEXT (r->timeout);
1154	}	1278	}
1155		1279
1156	if (last_sent + send_interval <= NOW)
1157	{
1158	if (!send)	1280	if (!send)
		1281	{
		1282	// generate a new packet, if wise
		1283
		1284	if (!established)
1159	{	1285	{
1160	// generate a new packet, if wise
1161
1162	if (!established)
1163	{
1164	if (vpn->dns_sndpq.empty ())	1286	if (vpn->dns_sndpq.empty ())
1165	{
1166	send = new dns_snd (this);
1167
1168	cfg.reset (THISNODE->id);
1169	send->gen_syn_req (cfg);
1170	}
1171	}
1172	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING)
1173	{	1287	{
1174	send = new dns_snd (this);	1288	send = new dns_snd (this);
		1289
		1290	cfg.reset (THISNODE->id);
		1291	send->gen_syn_req ();
		1292	}
		1293	}
		1294	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
		1295	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1296	{
		1297	if (last_sent + send_interval <= ev_now ())
		1298	{
		1299	//printf ("sending data request etc.\n"); //D
		1300	if (!snddq.empty () \|\| last_received + 1. > ev_now ())
		1301	{
		1302	poll_interval = send_interval;
		1303	NEXT (ev_now () + send_interval);
		1304	}
		1305
		1306	send = new dns_snd (this);
1175	send->gen_stream_req (sndseq, snddq);	1307	send->gen_stream_req (sndseq, snddq);
		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
1176		1310
1177	sndseq = (sndseq + 1) & SEQNO_MASK;	1311	sndseq = (sndseq + 1) & SEQNO_MASK;
1178	}	1312	}
1179		1313	else
1180	if (send)	1314	NEXT (last_sent + send_interval);
1181	vpn->dns_sndpq.push_back (send);
1182	}	1315	}
1183		1316
1184	if (send)	1317	if (send)
1185	{	1318	vpn->dns_sndpq.push_back (send);
1186	last_sent = NOW;	1319	}
1187		1320
		1321	if (send)
		1322	{
		1323	last_sent = ev_now ();
1188	sendto (vpn->dnsv4_fd,	1324	sendto (vpn->dnsv4_fd,
1189	send->pkt->at (0), send->pkt->len, 0,	1325	send->pkt->at (0), send->pkt->len, 0,
1190	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1326	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1191	}
1192	}	1327	}
1193	else
1194	NEXT (last_sent + send_interval);
1195		1328
1196	//printf ("pi %f si %f N %f (%d:%d)\n", poll_interval, send_interval, next - NOW, vpn->dns_sndpq.size (), snddq.size ());	1329	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
		1330	poll_interval, send_interval, next - ev_now (),
		1331	vpn->dns_sndpq.size (), snddq.size (),
		1332	rcvpq.size ());
1197		1333
1198	// 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
1199	if (next < NOW + 0.0001)	1336	if (next < ev_now () + 0.001)
1200	next = NOW + 0.1;	1337	next = ev_now () + 0.1;
1201		1338
1202	w.start (next);	1339	w.start (next - ev_now ());
1203	}	1340	}
1204		1341
1205	#endif	1342	#endif
1206		1343

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.11 by pcg, Fri Mar 4 08:45:24 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.11 by pcg, Fri Mar 4 08:45:24 2005 UTC vs.
Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC