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

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

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.25 by pcg, Mon Mar 7 22:24:24 2005 UTC vs. Revision 1.51 by root, Sun Mar 6 19:40:28 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.25 by pcg, Mon Mar 7 22:24:24 2005 UTC vs.
Revision 1.51 by root, Sun Mar 6 19:40:28 2011 UTC