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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.24 by pcg, Mon Mar 7 01:31:26 2005 UTC vs.
Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC

…		…
1	/*	1	/*
2	vpn_dns.C -- handle the dns tunnel part of the protocol.	2	vpn_dns.C -- handle the dns tunnel part of the protocol.
3	Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de>	3	Copyright (C) 2003-2011 Marc Lehmann <gvpe@schmorp.de>
4		4
5	This file is part of GVPE.	5	This file is part of GVPE.
6		6
7	GVPE is free software; you can redistribute it and/or modify	7	GVPE is free software; you can redistribute it and/or modify it
8	it under the terms of the GNU General Public License as published by	8	under the terms of the GNU General Public License as published by the
9	the Free Software Foundation; either version 2 of the License, or	9	Free Software Foundation; either version 3 of the License, or (at your
10	(at your option) any later version.	10	option) any later version.
11		11
12	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful, but
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15	GNU General Public License for more details.	15	Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License along
18	along with gvpe; if not, write to the Free Software	18	with this program; if not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc. 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	64	#define MIN_POLL_INTERVAL 0.025 // poll at most this often when no data received
50	#define MAX_POLL_INTERVAL 6. // how often to poll minimally when the server has no data	65	#define MAX_POLL_INTERVAL 1. // how often to poll minimally when the server has no data
51	#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 5. // 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
81	#define CMD_IP_2 46	94	#define CMD_IP_2 46
82	#define CMD_IP_3 236	95	#define CMD_IP_3 236
83	#define CMD_IP_RST 29	96
84	#define CMD_IP_SYN 113	97	#define CMD_IP_RST 29 // some error, reset and retry
85	#define CMD_IP_REJ 32	98	#define CMD_IP_REJ 32 // do not want you
		99	#define CMD_IP_SYN 113 // connection established
		100	#define CMD_IP_CSE 213 // connection established, but likely case mismatch
		101
		102	static bool
		103	is_uc (char c)
		104	{
		105	return 'A' <= c && c <= 'Z';
		106	}
		107
		108	static bool
		109	is_lc (char c)
		110	{
		111	return 'a' <= c && c <= 'z';
		112	}
86		113
87	// works for cmaps up to 255 (not 256!)	114	// works for cmaps up to 255 (not 256!)
88	struct charmap	115	struct charmap
89	{	116	{
90	enum { INVALID = (u8)255 };	117	enum { INVALID = (u8)255 };
…		…
104	memset (enc, (char) 0, 256);	131	memset (enc, (char) 0, 256);
105	memset (dec, (char)INVALID, 256);	132	memset (dec, (char)INVALID, 256);
106		133
107	for (size = 0; cmap [size]; size++)	134	for (size = 0; cmap [size]; size++)
108	{	135	{
		136	char c = cmap [size];
		137
109	enc [size] = cmap [size];	138	enc [size] = c;
110	dec [(u8)enc [size]] = size;	139	dec [(u8)c] = size;
		140
		141	// allow lowercase/uppercase aliases if possible
		142	if (is_uc (c) && dec [c + ('a' - 'A')] == INVALID) dec [c + ('a' - 'A')] = size;
		143	if (is_lc (c) && dec [c - ('a' - 'A')] == INVALID) dec [c - ('a' - 'A')] = size;
111	}	144	}
112		145
113	assert (size < 256);	146	assert (size < 256);
114	}	147	}
115		148
…		…
122	{	155	{
123	charmap cmap;	156	charmap cmap;
124	unsigned int enc_len [MAX_DEC_LEN];	157	unsigned int enc_len [MAX_DEC_LEN];
125	unsigned int dec_len [MAX_ENC_LEN];	158	unsigned int dec_len [MAX_ENC_LEN];
126		159
127	unsigned int encode_len (unsigned int len);	160	unsigned int encode_len (unsigned int len) const;
128	unsigned int decode_len (unsigned int len);	161	unsigned int decode_len (unsigned int len) const;
129		162
130	unsigned int encode (char dst, u8 src, unsigned int len);	163	unsigned int encode (char dst, u8 src, unsigned int len) const;
131	unsigned int decode (u8 dst, char src, unsigned int len);	164	unsigned int decode (u8 dst, char src, unsigned int len) const;
132		165
133	basecoder (const char *cmap);	166	basecoder (const char *cmap);
134	};	167	};
135		168
136	basecoder::basecoder (const char *cmap)	169	basecoder::basecoder (const char *cmap)
…		…
155	enc_len [len] = n;	188	enc_len [len] = n;
156	dec_len [n] = len;	189	dec_len [n] = len;
157	}	190	}
158	}	191	}
159		192
		193	unsigned int
160	unsigned int basecoder::encode_len (unsigned int len)	194	basecoder::encode_len (unsigned int len) const
161	{	195	{
162	return enc_len [len];	196	return enc_len [len];
163	}	197	}
164		198
		199	unsigned int
165	unsigned int basecoder::decode_len (unsigned int len)	200	basecoder::decode_len (unsigned int len) const
166	{	201	{
167	while (len && !dec_len [len])	202	while (len && !dec_len [len])
168	--len;	203	--len;
169		204
170	return dec_len [len];	205	return dec_len [len];
171	}	206	}
172		207
		208	unsigned int
173	unsigned int basecoder::encode (char dst, u8 src, unsigned int len)	209	basecoder::encode (char dst, u8 src, unsigned int len) const
174	{	210	{
175	if (!len \|\| len > MAX_DEC_LEN)	211	if (!len \|\| len > MAX_DEC_LEN)
176	return 0;	212	return 0;
177		213
178	int elen = encode_len (len);	214	int elen = encode_len (len);
…		…
197	*dst++ = cmap.encode [dst_ [i]];	233	*dst++ = cmap.encode [dst_ [i]];
198		234
199	return elen;	235	return elen;
200	}	236	}
201		237
		238	unsigned int
202	unsigned int basecoder::decode (u8 dst, char src, unsigned int len)	239	basecoder::decode (u8 dst, char src, unsigned int len) const
203	{	240	{
204	if (!len \|\| len > MAX_ENC_LEN)	241	if (!len \|\| len > MAX_ENC_LEN)
205	return 0;	242	return 0;
206		243
207	u8 src_ [MAX_ENC_LEN];	244	u8 src_ [MAX_ENC_LEN];
…		…
256	}	293	}
257	abort ();	294	abort ();
258	}	295	}
259	#endif	296	#endif
260		297
261	//static basecoder cdc64 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI-");
262	//static basecoder cdc63 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
263	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");	298	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI"); // a-zA-Z0-9
264	//static basecoder cdc36 ("dphzr06qmjkb34tsvl81xaef92wgyo57ucni"); // unused as of yet	299	static basecoder cdc36 ("dPhZr06QmJkB34tSvL81xAeF92wGyO57uCnI"); // a-z0-9 for case-changers
265	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	300	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyOuCnI"); // a-z
266		301
267	/////////////////////////////////////////////////////////////////////////////	302	/////////////////////////////////////////////////////////////////////////////
268		303
269	#define HDRSIZE 6	304	#define HDRSIZE 5
270		305
		306	inline void
271	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)	307	encode_header (char *data, int clientid, int seqno, int retry = 0)
272	{	308	{
		309	assert (clientid < 256);
		310
273	seqno &= SEQNO_MASK;	311	seqno &= SEQNO_MASK;
274		312
275	u8 hdr[3] = {	313	u8 hdr[3] = {
		314	seqno,
		315	(seqno >> 8) \| (retry << 6),
276	clientid,	316	clientid,
277	(seqno >> 8) \| (retry << 6),
278	seqno,
279	};	317	};
280		318
281	assert (clientid < 256);
282
283	cdc26.encode (data, hdr, 3);	319	cdc36.encode (data, hdr, 3);
284	}	320	}
285		321
		322	inline void
286	inline void decode_header (char *data, int &clientid, int &seqno)	323	decode_header (char *data, int &clientid, int &seqno)
287	{	324	{
288	u8 hdr[3];	325	u8 hdr[3];
289		326
290	cdc26.decode (hdr, data, HDRSIZE);	327	cdc36.decode (hdr, data, HDRSIZE);
291		328
292	clientid = hdr[0];	329	clientid = hdr[2];
293	seqno = ((hdr[1] << 8) \| hdr[2]) & SEQNO_MASK;	330	seqno = ((hdr[1] << 8) \| hdr[0]) & SEQNO_MASK;
294	}	331	}
295		332
296	/////////////////////////////////////////////////////////////////////////////	333	/////////////////////////////////////////////////////////////////////////////
297		334
298	struct byte_stream	335	struct byte_stream
…		…
324	byte_stream::~byte_stream ()	361	byte_stream::~byte_stream ()
325	{	362	{
326	delete data;	363	delete data;
327	}	364	}
328		365
		366	void
329	void byte_stream::remove (int count)	367	byte_stream::remove (int count)
330	{	368	{
331	if (count > fill)	369	if (count > fill)
332	assert (count <= fill);	370	assert (count <= fill);
333		371
334	memmove (data, data + count, fill -= count);	372	memmove (data, data + count, fill -= count);
335	}	373	}
336		374
		375	bool
337	bool byte_stream::put (u8 *data, unsigned int datalen)	376	byte_stream::put (u8 *data, unsigned int datalen)
338	{	377	{
339	if (maxsize - fill < datalen)	378	if (maxsize - fill < datalen)
340	return false;	379	return false;
341		380
342	memcpy (this->data + fill, data, datalen); fill += datalen;	381	memcpy (this->data + fill, data, datalen); fill += datalen;
343		382
344	return true;	383	return true;
345	}	384	}
346		385
		386	bool
347	bool byte_stream::put (vpn_packet *pkt)	387	byte_stream::put (vpn_packet *pkt)
348	{	388	{
349	if (maxsize - fill < pkt->len + 2)	389	if (maxsize - fill < pkt->len + 2)
350	return false;	390	return false;
351		391
352	data [fill++] = pkt->len >> 8;	392	data [fill++] = pkt->len >> 8;
…		…
408		448
409	struct dns_cfg	449	struct dns_cfg
410	{	450	{
411	static int next_uid;	451	static int next_uid;
412		452
413	u8 id1, id2, id3, id4;	453	u8 chksum;
		454	u8 rrtype;
		455	u16 uid; // to make request unique
414		456
415	u8 version;	457	u8 version;
416	u8 flags;	458	u8 flags;
417	u8 rrtype;	459	u16 max_size;
		460
		461	u8 id1, id2, id3, id4;
		462
		463	u16 client;
418	u8 def_ttl;	464	u8 def_ttl;
		465	u8 r0;
419		466
420	u16 client;	467	u8 syn_cdc; // cdc en/decoder for syn (A?) requests
421	u16 uid; // to make request unique	468	u8 hdr_cdc; // cdc en/decoder for regular request headers
		469	u8 req_cdc; // cdc en/decoder for regular (ANY?) request data
		470	u8 rep_cdc; // cdc en/decoder for regular (TXT) replies, 0 == 8 bit encoding
422		471
423	u16 max_size;
424	u8 seq_cdc;
425	u8 req_cdc;
426
427	u8 rep_cdc;
428	u8 r2, r3, r4;	472	u8 r1, r2, r3, r4;
429
430	u8 r5, r6, r7, r8;
431		473
432	void reset (int clientid);	474	void reset (int clientid);
433	bool valid ();	475	bool valid ();
		476	u8 get_chksum ();
434	};	477	};
435		478
436	int dns_cfg::next_uid;	479	int dns_cfg::next_uid;
437		480
		481	void
438	void dns_cfg::reset (int clientid)	482	dns_cfg::reset (int clientid)
439	{	483	{
		484	// this ID must result in some mixed-case characters in cdc26-encoding
440	id1 = 'G';	485	id1 = 'G';
441	id2 = 'V';	486	id2 = 'V';
442	id3 = 'P';	487	id3 = 'P';
443	id4 = 'E';	488	id4 = 'E';
444		489
445	version = 1;	490	version = 2;
446		491
447	rrtype = RR_TYPE_TXT;	492	rrtype = RR_TYPE_TXT;
448	flags = 0;	493	flags = 0;
449	def_ttl = 0;	494	def_ttl = 0;
450	seq_cdc = 26;	495	syn_cdc = 26;
451	req_cdc = 62;	496	hdr_cdc = 36;
		497	req_cdc = conf.dns_case_preserving ? 62 : 36;
452	rep_cdc = 0;	498	rep_cdc = 0;
453	max_size = ntohs (MAX_PKT_SIZE);	499	max_size = htons (MAX_PKT_SIZE);
454	client = ntohs (clientid);	500	client = htons (clientid);
455	uid = next_uid++;	501	uid = ++next_uid;
456		502
457	r2 = r3 = r4 = 0;	503	r0 = r1 = r2 = r3 = r4 = 0;
458	r4 = r5 = r6 = r7 = 0;
459	}
460		504
		505	chksum = get_chksum ();
		506	}
		507
		508	// simple but not trivial chksum
		509	u8
		510	dns_cfg::get_chksum ()
		511	{
		512	unsigned int sum = 0xff00; // only 16 bits required
		513
		514	u8 old_chksum = chksum;
		515	chksum = 0;
		516
		517	for (unsigned int i = 0; i < sizeof (*this); ++i)
		518	sum += ((u8 )this)[i] (i + 1);
		519
		520	chksum = old_chksum;
		521
		522	return sum + (sum >> 8);
		523	}
		524
		525	bool
461	bool dns_cfg::valid ()	526	dns_cfg::valid ()
462	{	527	{
		528	// although the protocol itself allows for some configurability,
		529	// only the following encoding/decoding settings are implemented.
463	return id1 == 'G'	530	return id1 == 'G'
464	&& id2 == 'V'	531	&& id2 == 'V'
465	&& id3 == 'P'	532	&& id3 == 'P'
466	&& id4 == 'E'	533	&& id4 == 'E'
		534	&& version == 2
467	&& seq_cdc == 26	535	&& syn_cdc == 26
468	&& req_cdc == 62	536	&& hdr_cdc == 36
		537	&& (req_cdc == 36 \|\| req_cdc == 62)
469	&& rep_cdc == 0	538	&& rep_cdc == 0
470	&& version == 1	539	&& chksum == get_chksum ();
471	&& max_size == ntohs (MAX_PKT_SIZE);
472	}	540	}
473		541
474	struct dns_packet : net_packet	542	struct dns_packet : net_packet
475	{	543	{
476	u16 id;	544	u16 id;
…		…
480	u8 data [MAXSIZE - 6 * 2];	548	u8 data [MAXSIZE - 6 * 2];
481		549
482	int decode_label (char *data, int size, int &offs);	550	int decode_label (char *data, int size, int &offs);
483	};	551	};
484		552
		553	int
485	int dns_packet::decode_label (char *data, int size, int &offs)	554	dns_packet::decode_label (char *data, int size, int &offs)
486	{	555	{
487	char *orig = data;	556	char *orig = data;
488		557
489	memset (data, 0, size);	558	memset (data, 0, size);
490		559
…		…
516	return data - orig;	585	return data - orig;
517	}	586	}
518		587
519	/////////////////////////////////////////////////////////////////////////////	588	/////////////////////////////////////////////////////////////////////////////
520		589
		590	static
		591	u16 next_id ()
		592	{
521	static u16 dns_id = 0; // TODO: should be per-vpn	593	static u16 dns_id = 0; // TODO: should be per-vpn
522		594
523	static u16 next_id ()
524	{
525	if (!dns_id)	595	if (!dns_id)
526	dns_id = time (0);	596	dns_id = time (0);
527		597
528	// the simplest lsfr with periodicity 65535 i could find	598	// the simplest lsfr with periodicity 65535 i could find
529	dns_id = (dns_id << 1)	599	dns_id = (dns_id << 1)
…		…
544	struct vpn *vpn;	614	struct vpn *vpn;
545		615
546	dns_cfg cfg;	616	dns_cfg cfg;
547		617
548	bool established;	618	bool established;
		619	const basecoder *cdc;
549		620
550	tstamp last_received;	621	tstamp last_received;
551	tstamp last_sent;	622	tstamp last_sent;
552	double last_latency;	623	double min_latency;
553	double poll_interval, send_interval;	624	double poll_interval, send_interval;
554		625
555	vector<dns_rcv *> rcvpq;	626	vector<dns_rcv *> rcvpq;
556		627
557	byte_stream rcvdq; int rcvseq;	628	byte_stream rcvdq; int rcvseq; int repseq;
558	byte_stream snddq; int sndseq;	629	byte_stream snddq; int sndseq;
559		630
560	void time_cb (time_watcher &w); time_watcher tw;	631	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
561	void receive_rep (dns_rcv *r);	632	void receive_rep (dns_rcv *r);
		633
		634	void reset (); // quite like tcp RST
		635	void set_cfg (); // to be called after any cfg changes
562		636
563	dns_connection (connection *c);	637	dns_connection (connection *c);
564	~dns_connection ();	638	~dns_connection ();
565	};	639	};
566		640
…		…
584	: dns (dns)	658	: dns (dns)
585	{	659	{
586	timeout = 0;	660	timeout = 0;
587	retry = 0;	661	retry = 0;
588	seqno = 0;	662	seqno = 0;
589	sent = NOW;	663	sent = ev_now ();
590	stdhdr = false;	664	stdhdr = false;
591		665
592	pkt = new dns_packet;	666	pkt = new dns_packet;
593		667
594	pkt->id = next_id ();	668	pkt->id = next_id ();
…		…
597	dns_snd::~dns_snd ()	671	dns_snd::~dns_snd ()
598	{	672	{
599	delete pkt;	673	delete pkt;
600	}	674	}
601		675
		676	static void
602	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	677	append_domain (dns_packet &pkt, int &offs, const char *domain)
603	{	678	{
604	// add tunnel domain	679	// add tunnel domain
605	for (;;)	680	for (;;)
606	{	681	{
607	const char *end = strchr (domain, '.');	682	const char *end = strchr (domain, '.');
…		…
620		695
621	domain = end + 1;	696	domain = end + 1;
622	}	697	}
623	}	698	}
624		699
		700	void
625	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	701	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
626	{	702	{
627	stdhdr = true;	703	stdhdr = true;
628	this->seqno = seqno;	704	this->seqno = seqno;
629		705
630	timeout = NOW + INITIAL_TIMEOUT;	706	timeout = ev_now () + INITIAL_TIMEOUT;
631		707
632	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	708	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
633	pkt->qdcount = htons (1);	709	pkt->qdcount = htons (1);
634		710
635	int offs = 6*2;	711	int offs = 6*2;
…		…
638	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	714	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
639		715
640	char enc[256], *encp = enc;	716	char enc[256], *encp = enc;
641	encode_header (enc, THISNODE->id, seqno);	717	encode_header (enc, THISNODE->id, seqno);
642		718
643	int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);	719	int datalen = dns->cdc->decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
644		720
645	if (datalen > stream.size ())	721	if (datalen > stream.size ())
646	datalen = stream.size ();	722	datalen = stream.size ();
647		723
648	int enclen = cdc62.encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;	724	int enclen = dns->cdc->encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
649	stream.remove (datalen);	725	stream.remove (datalen);
650		726
651	while (enclen)	727	while (enclen)
652	{	728	{
653	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;	729	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
…		…
668	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	744	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
669		745
670	pkt->len = offs;	746	pkt->len = offs;
671	}	747	}
672		748
		749	void
673	void dns_snd::gen_syn_req ()	750	dns_snd::gen_syn_req ()
674	{	751	{
675	timeout = NOW + INITIAL_SYN_TIMEOUT;	752	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
676		753
677	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	754	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
678	pkt->qdcount = htons (1);	755	pkt->qdcount = htons (1);
679		756
680	int offs = 6 * 2;	757	int offs = 6 * 2;
…		…
719	/////////////////////////////////////////////////////////////////////////////	796	/////////////////////////////////////////////////////////////////////////////
720		797
721	dns_connection::dns_connection (connection *c)	798	dns_connection::dns_connection (connection *c)
722	: c (c)	799	: c (c)
723	, rcvdq (MAX_BACKLOG * 2)	800	, rcvdq (MAX_BACKLOG * 2)
724	, snddq (MAX_BACKLOG * 2)	801	, snddq (MAX_BACKLOG)
725	, tw (this, &dns_connection::time_cb)
726	{	802	{
		803	tw.set<dns_connection, &dns_connection::time_cb> (this);
		804
727	vpn = c->vpn;	805	vpn = c->vpn;
728		806
		807	reset ();
		808	}
		809
		810	dns_connection::~dns_connection ()
		811	{
		812	reset ();
		813	}
		814
		815	void
		816	dns_connection::reset ()
		817	{
		818	while (!rcvpq.empty ())
		819	{
		820	delete rcvpq.back ();
		821	rcvpq.pop_back ();
		822	}
		823
		824	for (int i = vpn->dns_sndpq.size (); i--; )
		825	if (vpn->dns_sndpq [i]->dns == this)
		826	{
		827	vpn->dns_sndpq [i] = vpn->dns_sndpq.back ();
		828	vpn->dns_sndpq.pop_back ();
		829	}
		830
729	established = false;	831	established = false;
730		832
731	rcvseq = sndseq = 0;	833	rcvseq = repseq = sndseq = 0;
732		834
733	last_sent = last_received = 0;	835	last_sent = 0;
734	poll_interval = MIN_POLL_INTERVAL;	836	poll_interval = 0.5; // starting here
735	send_interval = 0.5; // starting rate	837	send_interval = 0.5; // starting rate
736	last_latency = INITIAL_TIMEOUT;	838	min_latency = INITIAL_TIMEOUT;
737	}	839	}
738		840
739	dns_connection::~dns_connection ()	841	void
		842	dns_connection::set_cfg ()
740	{	843	{
741	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	844	cdc = cfg.req_cdc == 36 ? &cdc36 : &cdc62;
742	i != rcvpq.end ();
743	++i)
744	delete *i;
745	}	845	}
746		846
		847	void
747	void dns_connection::receive_rep (dns_rcv *r)	848	dns_connection::receive_rep (dns_rcv *r)
748	{	849	{
749	if (r->datalen)	850	if (r->datalen)
750	{	851	poll_interval = max (poll_interval * (1. / 1.2), MIN_POLL_INTERVAL);
751	last_received = NOW;
752	tw.trigger ();
753
754	poll_interval = send_interval;
755	}
756	else	852	else
757	{	853	poll_interval = min (poll_interval * 1.1, MAX_POLL_INTERVAL);
758	poll_interval *= 1.5;
759	if (poll_interval > MAX_POLL_INTERVAL)
760	poll_interval = MAX_POLL_INTERVAL;
761	}
762		854
763	rcvpq.push_back (r);	855	rcvpq.push_back (r);
764		856
765	redo:	857	redo:
766		858
767	// find next packet	859	// find next packet
768	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	860	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
769	if (SEQNO_EQ (rcvseq, (*i)->seqno))	861	if (SEQNO_EQ (rcvseq, (*i)->seqno))
770	{	862	{
		863	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
771	// enter the packet into our input stream	864	// enter the packet into our input stream
772	r = *i;	865	r = *i;
773		866
774	// remove the oldest packet, look forward, as it's oldest first	867	// remove the oldest packet, look forward, as it's oldest first
775	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	868	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
776	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	869	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
777	{	870	{
		871	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
778	delete *j;	872	delete *j;
779	rcvpq.erase (j);	873	rcvpq.erase (j);
780	break;	874	break;
781	}	875	}
782		876
783	rcvseq = (rcvseq + 1) & SEQNO_MASK;	877	rcvseq = (rcvseq + 1) & SEQNO_MASK;
784		878
785	if (!rcvdq.put (r->data, r->datalen))	879	if (!rcvdq.put (r->data, r->datalen))
786	{	880	{
		881	// MUST never overflow, can be caused by data corruption, TODO
787	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");	882	slog (L_CRIT, "DNS: !rcvdq.put (r->data, r->datalen)");
788	abort (); // MUST never overflow, can be caused by data corruption, TODO	883	reset ();
		884	return;
789	}	885	}
790		886
791	while (vpn_packet *pkt = rcvdq.get ())	887	while (vpn_packet *pkt = rcvdq.get ())
792	{	888	{
793	sockinfo si;	889	sockinfo si;
794	si.host = 0x01010101; si.port = htons (c->conf->id); si.prot = PROT_DNSv4;	890	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
795		891
796	vpn->recv_vpn_packet (pkt, si);	892	vpn->recv_vpn_packet (pkt, si);
797
798	delete pkt;	893	delete pkt;
799	}	894	}
800		895
801	// check for further packets	896	// check for further packets
802	goto redo;	897	goto redo;
…		…
845	{	940	{
846	// correct class, domain: parse	941	// correct class, domain: parse
847	int client, seqno;	942	int client, seqno;
848	decode_header (qname, client, seqno);	943	decode_header (qname, client, seqno);
849		944
850	u8 data[MAXSIZE];
851	int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
852
853	if (0 < client && client <= conns.size ())	945	if (0 < client && client <= conns.size ())
854	{	946	{
855	connection *c = conns [client - 1];	947	connection *c = conns [client - 1];
856	dns_connection *dns = c->dns;	948	dns_connection *dns = c->dns;
857	dns_rcv *rcv;	949	dns_rcv *rcv;
858	bool in_seq;
859		950
860	if (dns)	951	if (dns)
861	{	952	{
		953	u8 data[MAXSIZE];
		954	int datalen = dns->cdc->decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
		955
862	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	956	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
863	if (SEQNO_EQ ((*i)->seqno, seqno))	957	if (SEQNO_EQ ((*i)->seqno, seqno))
864	{	958	{
865	// already seen that request: simply reply with the cached reply	959	// already seen that request: simply reply with the cached reply
866	dns_rcv r = i;	960	dns_rcv r = i;
…		…
874	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	968	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
875		969
876	goto duplicate_request;	970	goto duplicate_request;
877	}	971	}
878		972
879	in_seq = dns->rcvseq == seqno;
880
881	// new packet, queue	973	// new packet, queue
882	rcv = new dns_rcv (seqno, data, datalen);	974	rcv = new dns_rcv (seqno, data, datalen);
883	dns->receive_rep (rcv);	975	dns->receive_rep (rcv);
884	}	976	}
885		977
…		…
892	pkt [offs++] = 0; pkt [offs++] = 0;	984	pkt [offs++] = 0; pkt [offs++] = 0;
893	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL	985	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
894		986
895	int rdlen_offs = offs += 2;	987	int rdlen_offs = offs += 2;
896		988
897	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;
898	// bind doesn't compress well, so reduce further by one label length
899	dlen -= qlen;
900
901	if (dns)	989	if (dns)
902	{	990	{
		991	int dlen = ntohs (dns->cfg.max_size) - offs;
		992
		993	// bind doesn't compress well, so reduce further by one label length
		994	dlen -= qlen;
		995
903	// only put data into in-order sequence packets, if	996	// only put data into in-order sequence packets, if
904	// we receive out-of-order packets we generate empty	997	// we receive out-of-order packets we generate empty
905	// replies	998	// replies
906	while (dlen > 1 && !dns->snddq.empty () && in_seq)	999	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		1000	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
907	{	1001	{
		1002	dns->repseq = seqno;
		1003
		1004	while (dlen > 1 && !dns->snddq.empty ())
		1005	{
908	int txtlen = dlen <= 255 ? dlen - 1 : 255;	1006	int txtlen = dlen <= 255 ? dlen - 1 : 255;
909		1007
910	if (txtlen > dns->snddq.size ())	1008	if (txtlen > dns->snddq.size ())
911	txtlen = dns->snddq.size ();	1009	txtlen = dns->snddq.size ();
912		1010
913	pkt[offs++] = txtlen;	1011	pkt[offs++] = txtlen;
914	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	1012	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
915	offs += txtlen;	1013	offs += txtlen;
916	dns->snddq.remove (txtlen);	1014	dns->snddq.remove (txtlen);
917		1015
918	dlen -= txtlen + 1;	1016	dlen -= txtlen + 1;
		1017	}
919	}	1018	}
920		1019
921	// avoid empty TXT rdata	1020	// avoid completely empty TXT rdata
922	if (offs == rdlen_offs)	1021	if (offs == rdlen_offs)
923	pkt[offs++] = 0;	1022	pkt[offs++] = 0;
924		1023
925	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());	1024	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
926	}	1025	}
…		…
962	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	1061	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
963	pkt [offs++] = 0; pkt [offs++] = 0;	1062	pkt [offs++] = 0; pkt [offs++] = 0;
964	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1063	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
965	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1064	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
966		1065
967	slog (L_INFO, _("DNS: client %d connects"), client);
968
969	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	1066	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
970	pkt [offs++] = CMD_IP_REJ;	1067	pkt [offs++] = CMD_IP_REJ;
971		1068
972	if (0 < client && client <= conns.size ())	1069	if (0 < client && client <= conns.size ())
973	{	1070	{
974	connection *c = conns [client - 1];	1071	connection *c = conns [client - 1];
975		1072
976	if (cfg.valid ())	1073	if (cfg.valid ())
977	{	1074	{
978	pkt [offs - 1] = CMD_IP_SYN;	1075	slog (L_INFO, _("DNS: client %d connects (version %d, req_cdc %d)"), client, cfg.version, cfg.req_cdc);
		1076
		1077	// check for any encoding mismatches - hints at a case problem
		1078	char qname2 [MAX_ENC_LEN];
		1079	cdc26.encode (qname2, (u8 *)&cfg, sizeof (dns_cfg));
979		1080
980	delete c->dns;	1081	delete c->dns;
		1082
		1083	pkt [offs - 1] = memcmp (qname, qname2, cdc26.encode_len (sizeof (dns_cfg)))
		1084	? CMD_IP_CSE : CMD_IP_SYN;
		1085
981	c->dns = new dns_connection (c);	1086	c->dns = new dns_connection (c);
982	c->dns->cfg = cfg;	1087	c->dns->cfg = cfg;
		1088	c->dns->set_cfg ();
983	}	1089	}
984	}	1090	}
985	}	1091	}
986	}	1092	}
987		1093
…		…
1006	{	1112	{
1007	dns_connection dns = (i)->dns;	1113	dns_connection dns = (i)->dns;
1008	connection *c = dns->c;	1114	connection *c = dns->c;
1009	int seqno = (*i)->seqno;	1115	int seqno = (*i)->seqno;
1010	u8 data[MAXSIZE], *datap = data;	1116	u8 data[MAXSIZE], *datap = data;
		1117	//printf ("rcv pkt %x\n", seqno);//D
1011		1118
1012	if ((*i)->retry)	1119	if ((*i)->retry)
1013	{	1120	{
1014	dns->send_interval *= 1.01;	1121	dns->send_interval *= 1.01;
1015	if (dns->send_interval > MAX_SEND_INTERVAL)	1122	if (dns->send_interval > MAX_SEND_INTERVAL)
1016	dns->send_interval = MAX_SEND_INTERVAL;	1123	dns->send_interval = MAX_SEND_INTERVAL;
1017	}	1124	}
1018	else	1125	else
1019	{	1126	{
1020	#if 1	1127	#if 0
1021	dns->send_interval *= 0.999;	1128	dns->send_interval *= 0.999;
1022	#endif	1129	#endif
1023	if (dns->send_interval < MIN_SEND_INTERVAL)
1024	dns->send_interval = MIN_SEND_INTERVAL;
1025
1026	// the latency surely puts an upper bound on	1130	// the latency surely puts an upper bound on
1027	// the minimum send interval	1131	// the minimum send interval
1028	double latency = NOW - (*i)->sent;	1132	double latency = ev_now () - (*i)->sent;
		1133
		1134	if (latency < dns->min_latency)
1029	dns->last_latency = latency;	1135	dns->min_latency = latency;
1030		1136
1031	if (dns->send_interval > latency)	1137	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1138	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1139
		1140	if (dns->send_interval < conf.dns_send_interval)
1032	dns->send_interval = latency;	1141	dns->send_interval = conf.dns_send_interval;
1033	}	1142	}
1034		1143
1035	delete *i;	1144	delete *i;
1036	dns_sndpq.erase (i);	1145	dns_sndpq.erase (i);
1037		1146
…		…
1055	ttl \|= pkt [offs++] << 16;	1164	ttl \|= pkt [offs++] << 16;
1056	ttl \|= pkt [offs++] << 8;	1165	ttl \|= pkt [offs++] << 8;
1057	ttl \|= pkt [offs++];	1166	ttl \|= pkt [offs++];
1058	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];	1167	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];
1059		1168
1060	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT)	1169	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT \|\| qtype == dns->cfg.rrtype)
1061	{	1170	{
1062	if (rdlen <= MAXSIZE - offs)	1171	if (rdlen <= MAXSIZE - offs)
1063	{	1172	{
1064	// decode bytes, finally	1173	// decode bytes, finally
1065		1174
…		…
1091	{	1200	{
1092	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);	1201	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1093		1202
1094	if (ip [3] == CMD_IP_RST)	1203	if (ip [3] == CMD_IP_RST)
1095	{	1204	{
1096	slog (L_DEBUG, _("DNS: got tunnel RST request"));	1205	slog (L_DEBUG, _("DNS: got tunnel RST request."));
1097		1206
1098	delete dns; c->dns = 0;	1207	dns->reset ();
1099
1100	return;	1208	return;
1101	}	1209	}
1102	else if (ip [3] == CMD_IP_SYN)	1210	else if (ip [3] == CMD_IP_SYN)
1103	{	1211	{
1104	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));	1212	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1105	dns->established = true;	1213	dns->established = true;
1106	}	1214	}
		1215	else if (ip [3] == CMD_IP_CSE)
		1216	{
		1217	if (conf.dns_case_preserving)
		1218	{
		1219	slog (L_INFO, _("DNS: got tunnel CSE reply, globally downgrading to case-insensitive protocol."));
		1220	conf.dns_case_preserving = false;
		1221	dns->reset ();
		1222	return;
		1223	}
		1224	else
		1225	{
		1226	slog (L_DEBUG, _("DNS: got tunnel CSE reply, server likes us."));
		1227	dns->established = true;
		1228	}
		1229	}
1107	else if (ip [3] == CMD_IP_REJ)	1230	else if (ip [3] == CMD_IP_REJ)
1108	{	1231	{
1109	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));	1232	slog (L_ERR, _("DNS: got tunnel REJ reply, server does not like us."));
1110	abort ();	1233	dns->tw.start (60.);
1111	}	1234	}
1112	else	1235	else
		1236	{
1113	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);	1237	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
		1238	dns->tw.start (60.);
		1239	}
1114	}	1240	}
1115	else	1241	else
1116	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),	1242	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1117	ip [0], ip [1], ip [2], ip [3]);	1243	ip [0], ip [1], ip [2], ip [3]);
1118		1244
…		…
1142	break;	1268	break;
1143	}	1269	}
1144	}	1270	}
1145		1271
1146	void	1272	void
1147	vpn::dnsv4_ev (io_watcher &w, short revents)	1273	vpn::dnsv4_ev (ev::io &w, int revents)
1148	{	1274	{
1149	if (revents & EVENT_READ)	1275	if (revents & EV_READ)
1150	{	1276	{
1151	dns_packet *pkt = new dns_packet;	1277	dns_packet *pkt = new dns_packet;
1152	struct sockaddr_in sa;	1278	struct sockaddr_in sa;
1153	socklen_t sa_len = sizeof (sa);	1279	socklen_t sa_len = sizeof (sa);
1154		1280
…		…
1170	}	1296	}
1171		1297
1172	bool	1298	bool
1173	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1299	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1174	{	1300	{
1175	int client = ntohs (si.port);	1301	int client = ntohl (si.host);
1176		1302
1177	assert (0 < client && client <= conns.size ());	1303	assert (0 < client && client <= conns.size ());
1178		1304
1179	connection *c = conns [client - 1];	1305	connection *c = conns [client - 1];
1180		1306
1181	if (!c->dns)	1307	if (!c->dns)
1182	c->dns = new dns_connection (c);	1308	c->dns = new dns_connection (c);
1183		1309
1184	if (!c->dns->snddq.put (pkt))	1310	if (c->dns->snddq.put (pkt))
1185	return false;	1311	{
		1312	min_it (c->dns->poll_interval, 0.25);
		1313	c->dns->tw ();
		1314	}
1186		1315
1187	c->dns->tw.trigger ();	1316	// always return true even if the buffer overflows
1188
1189	return true;	1317	return true;
1190	}	1318	}
1191		1319
1192	void	1320	void
1193	connection::dnsv4_reset_connection ()	1321	dns_connection::time_cb (ev::timer &w, int revents)
1194	{
1195	//delete dns; dns = 0; //TODO
1196	}
1197
1198	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1199
1200	void
1201	dns_connection::time_cb (time_watcher &w)
1202	{	1322	{
1203	// servers have to be polled	1323	// servers have to be polled
1204	if (THISNODE->dns_port)	1324	if (THISNODE->dns_port)
1205	return;	1325	return;
1206		1326
1207	// check for timeouts and (re)transmit	1327	// check for timeouts and (re)transmit
1208	tstamp next = NOW + poll_interval;	1328	tstamp next = 86400 * 365;
1209	dns_snd *send = 0;	1329	dns_snd *send = 0;
1210		1330
1211	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1331	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1212	i != vpn->dns_sndpq.end ();	1332	i != vpn->dns_sndpq.end ();
1213	++i)	1333	++i)
1214	{	1334	{
1215	dns_snd r = i;	1335	dns_snd r = i;
1216		1336
1217	if (r->timeout <= NOW)	1337	if (r->timeout <= ev_now ())
1218	{	1338	{
1219	if (!send)	1339	if (!send)
1220	{	1340	{
1221	send = r;	1341	send = r;
1222		1342
1223	r->retry++;	1343	r->retry++;
1224	r->timeout = NOW + (r->retry * last_latency * 8.);	1344	r->timeout = ev_now () + r->retry * min_latency * conf.dns_timeout_factor;
		1345	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1225		1346
1226	// the following code changes the query section a bit, forcing	1347	// the following code changes the query section a bit, forcing
1227	// the forwarder to generate a new request	1348	// the forwarder to generate a new request
1228	if (r->stdhdr)	1349	if (r->stdhdr)
1229	{
1230	//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);
1231	//encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);	1350	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1232	}
1233	}	1351	}
1234	}	1352	}
1235	else	1353	else
1236	NEXT (r->timeout);	1354	min_it (next, r->timeout - ev_now ());
1237	}
1238
1239	if (last_sent + send_interval <= NOW)
1240	{	1355	}
		1356
1241	if (!send)	1357	if (!send)
		1358	{
		1359	// generate a new packet, if wise
		1360
		1361	if (!established)
1242	{	1362	{
1243	// generate a new packet, if wise	1363	if (vpn->dns_sndpq.empty ())
1244
1245	if (!established)
1246	{	1364	{
1247	if (vpn->dns_sndpq.empty ())
1248	{
1249	send = new dns_snd (this);	1365	send = new dns_snd (this);
1250		1366
1251	cfg.reset (THISNODE->id);	1367	cfg.reset (THISNODE->id);
		1368	set_cfg ();
1252	send->gen_syn_req ();	1369	send->gen_syn_req ();
1253	}
1254	}	1370	}
1255	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING	1371	}
		1372	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1256	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))	1373	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1374	{
		1375	if (last_sent + send_interval <= ev_now ())
1257	{	1376	{
1258	//printf ("sending data request etc.\n"); //D	1377	//printf ("sending data request etc.\n"); //D
1259	if (!snddq.empty ())	1378	if (!snddq.empty ())
1260	{
1261	poll_interval = send_interval;
1262	NEXT (NOW + send_interval);	1379	min_it (next, send_interval);
1263	}
1264		1380
1265	send = new dns_snd (this);	1381	send = new dns_snd (this);
1266	send->gen_stream_req (sndseq, snddq);	1382	send->gen_stream_req (sndseq, snddq);
1267	send->timeout = NOW + last_latency * 8.;	1383	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1384	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1268		1385
1269	sndseq = (sndseq + 1) & SEQNO_MASK;	1386	sndseq = (sndseq + 1) & SEQNO_MASK;
1270	}	1387	}
1271		1388	else
1272	if (send)	1389	min_it (next, last_sent + send_interval - ev_now ());
1273	vpn->dns_sndpq.push_back (send);
1274	}	1390	}
1275		1391
1276	if (send)	1392	if (send)
1277	{	1393	vpn->dns_sndpq.push_back (send);
1278	last_sent = NOW;	1394	}
		1395
		1396	if (send)
		1397	{
		1398	last_sent = ev_now ();
1279	sendto (vpn->dnsv4_fd,	1399	sendto (vpn->dnsv4_fd,
1280	send->pkt->at (0), send->pkt->len, 0,	1400	send->pkt->at (0), send->pkt->len, 0,
1281	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1401	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1282	}
1283	}	1402	}
1284	else
1285	NEXT (last_sent + send_interval);
1286		1403
		1404	min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ());
		1405
1287	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d)",	1406	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1288	poll_interval, send_interval, next - NOW,	1407	poll_interval, send_interval, next - ev_now (),
1289	vpn->dns_sndpq.size (), snddq.size ());	1408	vpn->dns_sndpq.size (), snddq.size (),
1290		1409	rcvpq.size ());
1291	// TODO: no idea when this happens, but when next < NOW, we have a problem
1292	if (next < NOW + 0.0001)
1293	next = NOW + 0.1;
1294		1410
1295	w.start (next);	1411	w.start (next);
1296	}	1412	}
1297		1413
1298	#endif	1414	#endif

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.24 by pcg, Mon Mar 7 01:31:26 2005 UTC vs. Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.24 by pcg, Mon Mar 7 01:31:26 2005 UTC vs.
Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC