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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.29 by pcg, Sun Mar 13 12:40:20 2005 UTC vs.
Revision 1.55 by root, Tue Oct 18 11:11:32 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 2. // optimistic?	70	#define MAX_SEND_INTERVAL 5. // optimistic?
58		71
59	#define LATENCY_FACTOR 0.5 // RTT * LATENCY_FACTOR == sending rate
60	#define MAX_OUTSTANDING 100 // 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 240 // 255 is legal limit, but bind doesn't compress well	75	#define MAX_DOMAIN_SIZE 235 // 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;
…		…
362	{	401	{
363	unsigned int len;	402	unsigned int len;
364		403
365	for (;;)	404	for (;;)
366	{	405	{
		406	if (fill < 2)
		407	return 0;
		408
367	len = (data [0] << 8) \| data [1];	409	len = (data [0] << 8) \| data [1];
368		410
369	if (len <= MAXSIZE \|\| fill < 2)	411	if (len <= MAXSIZE)
370	break;	412	break;
371		413
372	// TODO: handle this better than skipping, e.g. by reset	414	// TODO: handle this better than skipping, e.g. by reset
373	slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));	415	slog (L_DEBUG, _("DNS: corrupted packet (%02x %02x) stream skipping a byte..."), data [0], data [1]);
374	remove (1);	416	remove (1);
375	}	417	}
376		418
377	if (fill < len + 2)	419	if (fill < len + 2)
378	return 0;	420	return 0;
…		…
409		451
410	struct dns_cfg	452	struct dns_cfg
411	{	453	{
412	static int next_uid;	454	static int next_uid;
413		455
414	u8 id1, id2, id3, id4;	456	u8 chksum;
		457	u8 rrtype;
		458	u16 uid; // to make request unique
415		459
416	u8 version;	460	u8 version;
417	u8 flags;	461	u8 flags;
418	u8 rrtype;	462	u16 max_size;
		463
		464	u8 id1, id2, id3, id4;
		465
		466	u16 client;
419	u8 def_ttl;	467	u8 def_ttl;
		468	u8 r0;
420		469
421	u16 client;	470	u8 syn_cdc; // cdc en/decoder for syn (A?) requests
422	u16 uid; // to make request unique	471	u8 hdr_cdc; // cdc en/decoder for regular request headers
		472	u8 req_cdc; // cdc en/decoder for regular (ANY?) request data
		473	u8 rep_cdc; // cdc en/decoder for regular (TXT) replies, 0 == 8 bit encoding
423		474
424	u16 max_size;
425	u8 seq_cdc;
426	u8 req_cdc;
427
428	u8 rep_cdc;
429	u8 r2, r3, r4;	475	u8 r1, r2, r3, r4;
430
431	u8 r5, r6, r7, r8;
432		476
433	void reset (int clientid);	477	void reset (int clientid);
434	bool valid ();	478	bool valid ();
		479	u8 get_chksum ();
435	};	480	};
436		481
437	int dns_cfg::next_uid;	482	int dns_cfg::next_uid;
438		483
		484	void
439	void dns_cfg::reset (int clientid)	485	dns_cfg::reset (int clientid)
440	{	486	{
		487	// this ID must result in some mixed-case characters in cdc26-encoding
441	id1 = 'G';	488	id1 = 'G';
442	id2 = 'V';	489	id2 = 'V';
443	id3 = 'P';	490	id3 = 'P';
444	id4 = 'E';	491	id4 = 'E';
445		492
446	version = 1;	493	version = 2;
447		494
448	rrtype = RR_TYPE_TXT;	495	rrtype = RR_TYPE_TXT;
449	flags = 0;	496	flags = 0;
450	def_ttl = 0;	497	def_ttl = 0;
451	seq_cdc = 26;	498	syn_cdc = 26;
452	req_cdc = 62;	499	hdr_cdc = 36;
		500	req_cdc = conf.dns_case_preserving ? 62 : 36;
453	rep_cdc = 0;	501	rep_cdc = 0;
454	max_size = htons (MAX_PKT_SIZE);	502	max_size = htons (MAX_PKT_SIZE);
455	client = htons (clientid);	503	client = htons (clientid);
456	uid = next_uid++;	504	uid = ++next_uid;
457		505
458	r2 = r3 = r4 = 0;	506	r0 = r1 = r2 = r3 = r4 = 0;
459	r4 = r5 = r6 = r7 = 0;
460	}
461		507
		508	chksum = get_chksum ();
		509	}
		510
		511	// simple but not trivial chksum
		512	u8
		513	dns_cfg::get_chksum ()
		514	{
		515	unsigned int sum = 0xff00; // only 16 bits required
		516
		517	u8 old_chksum = chksum;
		518	chksum = 0;
		519
		520	for (unsigned int i = 0; i < sizeof (*this); ++i)
		521	sum += ((u8 )this)[i] (i + 1);
		522
		523	chksum = old_chksum;
		524
		525	return sum + (sum >> 8);
		526	}
		527
		528	bool
462	bool dns_cfg::valid ()	529	dns_cfg::valid ()
463	{	530	{
		531	// although the protocol itself allows for some configurability,
		532	// only the following encoding/decoding settings are implemented.
464	return id1 == 'G'	533	return id1 == 'G'
465	&& id2 == 'V'	534	&& id2 == 'V'
466	&& id3 == 'P'	535	&& id3 == 'P'
467	&& id4 == 'E'	536	&& id4 == 'E'
		537	&& version == 2
468	&& seq_cdc == 26	538	&& syn_cdc == 26
469	&& req_cdc == 62	539	&& hdr_cdc == 36
		540	&& (req_cdc == 36 \|\| req_cdc == 62)
470	&& rep_cdc == 0	541	&& rep_cdc == 0
471	&& version == 1;	542	&& chksum == get_chksum ();
472	}	543	}
473		544
474	struct dns_packet : net_packet	545	struct dns_packet : net_packet
475	{	546	{
476	u16 id;	547	u16 id;
…		…
480	u8 data [MAXSIZE - 6 * 2];	551	u8 data [MAXSIZE - 6 * 2];
481		552
482	int decode_label (char *data, int size, int &offs);	553	int decode_label (char *data, int size, int &offs);
483	};	554	};
484		555
		556	int
485	int dns_packet::decode_label (char *data, int size, int &offs)	557	dns_packet::decode_label (char *data, int size, int &offs)
486	{	558	{
487	char *orig = data;	559	char *orig = data;
488		560
489	memset (data, 0, size);	561	memset (data, 0, size);
490		562
…		…
516	return data - orig;	588	return data - orig;
517	}	589	}
518		590
519	/////////////////////////////////////////////////////////////////////////////	591	/////////////////////////////////////////////////////////////////////////////
520		592
		593	static
		594	u16 next_id ()
		595	{
521	static u16 dns_id = 0; // TODO: should be per-vpn	596	static u16 dns_id = 0; // TODO: should be per-vpn
522		597
523	static u16 next_id ()	598	#if 1
524	{
525	if (!dns_id)	599	if (!dns_id)
526	dns_id = time (0);	600	dns_id = time (0);
527		601
528	// the simplest lsfr with periodicity 65535 i could find	602	// the simplest lsfr with periodicity 65535 i could find
529	dns_id = (dns_id << 1)	603	dns_id = (dns_id << 1)
…		…
531	^ (dns_id >> 2)	605	^ (dns_id >> 2)
532	^ (dns_id >> 4)	606	^ (dns_id >> 4)
533	^ (dns_id >> 15)) & 1);	607	^ (dns_id >> 15)) & 1);
534		608
535	return dns_id;	609	return dns_id;
		610	#else
		611	dns_id++;//D
		612
		613	return htons (dns_id);
		614	#endif
536	}	615	}
537		616
538	struct dns_rcv;	617	struct dns_rcv;
539	struct dns_snd;	618	struct dns_snd;
540		619
…		…
544	struct vpn *vpn;	623	struct vpn *vpn;
545		624
546	dns_cfg cfg;	625	dns_cfg cfg;
547		626
548	bool established;	627	bool established;
		628	const basecoder *cdc;
549		629
550	tstamp last_received;	630	tstamp last_received;
551	tstamp last_sent;	631	tstamp last_sent;
552	double min_latency;	632	double min_latency;
553	double poll_interval, send_interval;	633	double poll_interval, send_interval;
554		634
555	vector<dns_rcv *> rcvpq;	635	vector<dns_rcv *> rcvpq;
556		636
557	byte_stream rcvdq; int rcvseq;	637	byte_stream rcvdq; int rcvseq; int repseq;
558	byte_stream snddq; int sndseq;	638	byte_stream snddq; int sndseq;
559		639
560	void time_cb (time_watcher &w); time_watcher tw;	640	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
561	void receive_rep (dns_rcv *r);	641	void receive_rep (dns_rcv *r);
		642
		643	void reset (); // quite like tcp RST
		644	void set_cfg (); // to be called after any cfg changes
562		645
563	dns_connection (connection *c);	646	dns_connection (connection *c);
564	~dns_connection ();	647	~dns_connection ();
565	};	648	};
566		649
…		…
584	: dns (dns)	667	: dns (dns)
585	{	668	{
586	timeout = 0;	669	timeout = 0;
587	retry = 0;	670	retry = 0;
588	seqno = 0;	671	seqno = 0;
589	sent = NOW;	672	sent = ev_now ();
590	stdhdr = false;	673	stdhdr = false;
591		674
592	pkt = new dns_packet;	675	pkt = new dns_packet;
593		676
594	pkt->id = next_id ();	677	pkt->id = next_id ();
…		…
597	dns_snd::~dns_snd ()	680	dns_snd::~dns_snd ()
598	{	681	{
599	delete pkt;	682	delete pkt;
600	}	683	}
601		684
		685	static void
602	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	686	append_domain (dns_packet &pkt, int &offs, const char *domain)
603	{	687	{
604	// add tunnel domain	688	// add tunnel domain
605	for (;;)	689	for (;;)
606	{	690	{
607	const char *end = strchr (domain, '.');	691	const char *end = strchr (domain, '.');
…		…
620		704
621	domain = end + 1;	705	domain = end + 1;
622	}	706	}
623	}	707	}
624		708
		709	void
625	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	710	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
626	{	711	{
627	stdhdr = true;	712	stdhdr = true;
628	this->seqno = seqno;	713	this->seqno = seqno;
629		714
630	timeout = NOW + INITIAL_TIMEOUT;	715	timeout = ev_now () + INITIAL_TIMEOUT;
631		716
632	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	717	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
633	pkt->qdcount = htons (1);	718	pkt->qdcount = htons (1);
634		719
635	int offs = 6*2;	720	int offs = 6*2;
…		…
638	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	723	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
639		724
640	char enc[256], *encp = enc;	725	char enc[256], *encp = enc;
641	encode_header (enc, THISNODE->id, seqno);	726	encode_header (enc, THISNODE->id, seqno);
642		727
643	int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);	728	int datalen = dns->cdc->decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
644		729
645	if (datalen > stream.size ())	730	if (datalen > stream.size ())
646	datalen = stream.size ();	731	datalen = stream.size ();
647		732
648	int enclen = cdc62.encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;	733	int enclen = dns->cdc->encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
649	stream.remove (datalen);	734	stream.remove (datalen);
650		735
651	while (enclen)	736	while (enclen)
652	{	737	{
653	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;	738	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
…		…
668	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	753	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
669		754
670	pkt->len = offs;	755	pkt->len = offs;
671	}	756	}
672		757
		758	void
673	void dns_snd::gen_syn_req ()	759	dns_snd::gen_syn_req ()
674	{	760	{
675	timeout = NOW + INITIAL_SYN_TIMEOUT;	761	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
676		762
677	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	763	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
678	pkt->qdcount = htons (1);	764	pkt->qdcount = htons (1);
679		765
680	int offs = 6 * 2;	766	int offs = 6 * 2;
…		…
719	/////////////////////////////////////////////////////////////////////////////	805	/////////////////////////////////////////////////////////////////////////////
720		806
721	dns_connection::dns_connection (connection *c)	807	dns_connection::dns_connection (connection *c)
722	: c (c)	808	: c (c)
723	, rcvdq (MAX_BACKLOG * 2)	809	, rcvdq (MAX_BACKLOG * 2)
724	, snddq (MAX_BACKLOG * 2)	810	, snddq (MAX_BACKLOG)
725	, tw (this, &dns_connection::time_cb)
726	{	811	{
		812	tw.set<dns_connection, &dns_connection::time_cb> (this);
		813
727	vpn = c->vpn;	814	vpn = c->vpn;
728		815
		816	reset ();
		817	}
		818
		819	dns_connection::~dns_connection ()
		820	{
		821	reset ();
		822	}
		823
		824	void
		825	dns_connection::reset ()
		826	{
		827	while (!rcvpq.empty ())
		828	{
		829	delete rcvpq.back ();
		830	rcvpq.pop_back ();
		831	}
		832
		833	for (int i = vpn->dns_sndpq.size (); i--; )
		834	if (vpn->dns_sndpq [i]->dns == this)
		835	{
		836	vpn->dns_sndpq [i] = vpn->dns_sndpq.back ();
		837	vpn->dns_sndpq.pop_back ();
		838	}
		839
729	established = false;	840	established = false;
730		841
731	rcvseq = sndseq = 0;	842	rcvseq = repseq = sndseq = 0;
732		843
733	last_sent = last_received = 0;	844	last_sent = 0;
734	poll_interval = MIN_POLL_INTERVAL;	845	poll_interval = 0.5; // starting here
735	send_interval = 0.5; // starting rate	846	send_interval = 0.5; // starting rate
736	min_latency = INITIAL_TIMEOUT;	847	min_latency = INITIAL_TIMEOUT;
737	}	848	}
738		849
739	dns_connection::~dns_connection ()	850	void
		851	dns_connection::set_cfg ()
740	{	852	{
741	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	853	cdc = cfg.req_cdc == 36 ? &cdc36 : &cdc62;
742	i != rcvpq.end ();
743	++i)
744	delete *i;
745	}	854	}
746		855
		856	void
747	void dns_connection::receive_rep (dns_rcv *r)	857	dns_connection::receive_rep (dns_rcv *r)
748	{	858	{
749	if (r->datalen)	859	if (r->datalen)
750	{	860	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	861	else
757	{	862	poll_interval = min (poll_interval * 1.1, MAX_POLL_INTERVAL);
758	poll_interval *= 1.5;
759
760	if (poll_interval > MAX_POLL_INTERVAL)
761	poll_interval = MAX_POLL_INTERVAL;
762	}
763		863
764	rcvpq.push_back (r);	864	rcvpq.push_back (r);
765		865
766	redo:	866	redo:
767		867
768	// find next packet	868	// find next packet
769	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	869	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
770	if (SEQNO_EQ (rcvseq, (*i)->seqno))	870	if (SEQNO_EQ (rcvseq, (*i)->seqno))
771	{	871	{
		872	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
772	// enter the packet into our input stream	873	// enter the packet into our input stream
773	r = *i;	874	r = *i;
774		875
775	// remove the oldest packet, look forward, as it's oldest first	876	// remove the oldest packet, look forward, as it's oldest first
776	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	877	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
777	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	878	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
778	{	879	{
		880	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
779	delete *j;	881	delete *j;
780	rcvpq.erase (j);	882	rcvpq.erase (j);
781	break;	883	break;
782	}	884	}
783		885
784	rcvseq = (rcvseq + 1) & SEQNO_MASK;	886	rcvseq = (rcvseq + 1) & SEQNO_MASK;
785		887
786	if (!rcvdq.put (r->data, r->datalen))	888	if (!rcvdq.put (r->data, r->datalen))
787	{	889	{
		890	// MUST never overflow, can be caused by data corruption, TODO
788	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");	891	slog (L_CRIT, "DNS: !rcvdq.put (r->data, r->datalen)");
789	abort (); // MUST never overflow, can be caused by data corruption, TODO	892	reset ();
		893	return;
790	}	894	}
791		895
792	while (vpn_packet *pkt = rcvdq.get ())	896	while (vpn_packet *pkt = rcvdq.get ())
793	{	897	{
794	sockinfo si;	898	sockinfo si;
795	si.host = 0x01010101; si.port = htons (c->conf->id); si.prot = PROT_DNSv4;	899	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
796		900
797	vpn->recv_vpn_packet (pkt, si);	901	vpn->recv_vpn_packet (pkt, si);
798
799	delete pkt;	902	delete pkt;
800	}	903	}
801		904
802	// check for further packets	905	// check for further packets
803	goto redo;	906	goto redo;
…		…
846	{	949	{
847	// correct class, domain: parse	950	// correct class, domain: parse
848	int client, seqno;	951	int client, seqno;
849	decode_header (qname, client, seqno);	952	decode_header (qname, client, seqno);
850		953
851	u8 data[MAXSIZE];
852	int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
853
854	if (0 < client && client <= conns.size ())	954	if (0 < client && client <= conns.size ())
855	{	955	{
856	connection *c = conns [client - 1];	956	connection *c = conns [client - 1];
857	dns_connection *dns = c->dns;	957	dns_connection *dns = c->dns;
858	dns_rcv *rcv;	958	dns_rcv *rcv;
859	bool in_seq;
860		959
861	if (dns)	960	if (dns)
862	{	961	{
		962	u8 data[MAXSIZE];
		963	int datalen = dns->cdc->decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
		964
863	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	965	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
864	if (SEQNO_EQ ((*i)->seqno, seqno))	966	if (SEQNO_EQ ((*i)->seqno, seqno))
865	{	967	{
866	// already seen that request: simply reply with the cached reply	968	// already seen that request: simply reply with the cached reply
867	dns_rcv r = i;	969	dns_rcv r = i;
…		…
875	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	977	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
876		978
877	goto duplicate_request;	979	goto duplicate_request;
878	}	980	}
879		981
880	in_seq = dns->rcvseq == seqno;
881
882	// new packet, queue	982	// new packet, queue
883	rcv = new dns_rcv (seqno, data, datalen);	983	rcv = new dns_rcv (seqno, data, datalen);
884	dns->receive_rep (rcv);	984	dns->receive_rep (rcv);
885	}	985	}
886		986
…		…
903	dlen -= qlen;	1003	dlen -= qlen;
904		1004
905	// only put data into in-order sequence packets, if	1005	// only put data into in-order sequence packets, if
906	// we receive out-of-order packets we generate empty	1006	// we receive out-of-order packets we generate empty
907	// replies	1007	// replies
908	while (dlen > 1 && !dns->snddq.empty () && in_seq)	1008	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		1009	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
909	{	1010	{
		1011	dns->repseq = seqno;
		1012
		1013	while (dlen > 1 && !dns->snddq.empty ())
		1014	{
910	int txtlen = dlen <= 255 ? dlen - 1 : 255;	1015	int txtlen = dlen <= 255 ? dlen - 1 : 255;
911		1016
912	if (txtlen > dns->snddq.size ())	1017	if (txtlen > dns->snddq.size ())
913	txtlen = dns->snddq.size ();	1018	txtlen = dns->snddq.size ();
914		1019
915	pkt[offs++] = txtlen;	1020	pkt[offs++] = txtlen;
916	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	1021	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
917	offs += txtlen;	1022	offs += txtlen;
918	dns->snddq.remove (txtlen);	1023	dns->snddq.remove (txtlen);
919		1024
920	dlen -= txtlen + 1;	1025	dlen -= txtlen + 1;
		1026	}
921	}	1027	}
922		1028
923	// avoid empty TXT rdata	1029	// avoid completely empty TXT rdata
924	if (offs == rdlen_offs)	1030	if (offs == rdlen_offs)
925	pkt[offs++] = 0;	1031	pkt[offs++] = 0;
926		1032
927	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());	1033	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
928	}	1034	}
…		…
964	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	1070	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
965	pkt [offs++] = 0; pkt [offs++] = 0;	1071	pkt [offs++] = 0; pkt [offs++] = 0;
966	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1072	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
967	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1073	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
968		1074
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;	1075	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
972	pkt [offs++] = CMD_IP_REJ;	1076	pkt [offs++] = CMD_IP_REJ;
973		1077
974	if (0 < client && client <= conns.size ())	1078	if (0 < client && client <= conns.size ())
975	{	1079	{
976	connection *c = conns [client - 1];	1080	connection *c = conns [client - 1];
977		1081
978	if (cfg.valid ())	1082	if (cfg.valid ())
979	{	1083	{
980	pkt [offs - 1] = CMD_IP_SYN;	1084	slog (L_INFO, _("DNS: client %d connects (version %d, req_cdc %d)"), client, cfg.version, cfg.req_cdc);
		1085
		1086	// check for any encoding mismatches - hints at a case problem
		1087	char qname2 [MAX_ENC_LEN];
		1088	cdc26.encode (qname2, (u8 *)&cfg, sizeof (dns_cfg));
981		1089
982	delete c->dns;	1090	delete c->dns;
		1091
		1092	pkt [offs - 1] = memcmp (qname, qname2, cdc26.encode_len (sizeof (dns_cfg)))
		1093	? CMD_IP_CSE : CMD_IP_SYN;
		1094
983	c->dns = new dns_connection (c);	1095	c->dns = new dns_connection (c);
984	c->dns->cfg = cfg;	1096	c->dns->cfg = cfg;
		1097	c->dns->set_cfg ();
985	}	1098	}
986	}	1099	}
987	}	1100	}
988	}	1101	}
989		1102
…		…
1008	{	1121	{
1009	dns_connection dns = (i)->dns;	1122	dns_connection dns = (i)->dns;
1010	connection *c = dns->c;	1123	connection *c = dns->c;
1011	int seqno = (*i)->seqno;	1124	int seqno = (*i)->seqno;
1012	u8 data[MAXSIZE], *datap = data;	1125	u8 data[MAXSIZE], *datap = data;
		1126	//printf ("rcv pkt %x\n", seqno);//D
1013		1127
1014	if ((*i)->retry)	1128	if ((*i)->retry)
1015	{	1129	{
1016	dns->send_interval *= 1.01;	1130	dns->send_interval *= 1.01;
1017	if (dns->send_interval > MAX_SEND_INTERVAL)	1131	if (dns->send_interval > MAX_SEND_INTERVAL)
…		…
1022	#if 0	1136	#if 0
1023	dns->send_interval *= 0.999;	1137	dns->send_interval *= 0.999;
1024	#endif	1138	#endif
1025	// the latency surely puts an upper bound on	1139	// the latency surely puts an upper bound on
1026	// the minimum send interval	1140	// the minimum send interval
1027	double latency = NOW - (*i)->sent;	1141	double latency = ev_now () - (*i)->sent;
1028		1142
1029	if (latency < dns->min_latency)	1143	if (latency < dns->min_latency)
1030	dns->min_latency = latency;	1144	dns->min_latency = latency;
1031		1145
1032	if (dns->send_interval > dns->min_latency * LATENCY_FACTOR)	1146	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
1033	dns->send_interval = dns->min_latency * LATENCY_FACTOR;	1147	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
1034		1148
1035	if (dns->send_interval < MIN_SEND_INTERVAL)	1149	if (dns->send_interval < conf.dns_send_interval)
1036	dns->send_interval = MIN_SEND_INTERVAL;	1150	dns->send_interval = conf.dns_send_interval;
1037	}	1151	}
1038		1152
1039	delete *i;	1153	delete *i;
1040	dns_sndpq.erase (i);	1154	dns_sndpq.erase (i);
1041		1155
…		…
1059	ttl \|= pkt [offs++] << 16;	1173	ttl \|= pkt [offs++] << 16;
1060	ttl \|= pkt [offs++] << 8;	1174	ttl \|= pkt [offs++] << 8;
1061	ttl \|= pkt [offs++];	1175	ttl \|= pkt [offs++];
1062	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];	1176	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];
1063		1177
1064	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT)	1178	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT \|\| qtype == dns->cfg.rrtype)
1065	{	1179	{
1066	if (rdlen <= MAXSIZE - offs)	1180	if (rdlen <= MAXSIZE - offs)
1067	{	1181	{
1068	// decode bytes, finally	1182	// decode bytes, finally
1069		1183
…		…
1095	{	1209	{
1096	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);	1210	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1097		1211
1098	if (ip [3] == CMD_IP_RST)	1212	if (ip [3] == CMD_IP_RST)
1099	{	1213	{
1100	slog (L_DEBUG, _("DNS: got tunnel RST request"));	1214	slog (L_DEBUG, _("DNS: got tunnel RST request."));
1101		1215
1102	delete dns; c->dns = 0;	1216	dns->reset ();
1103
1104	return;	1217	return;
1105	}	1218	}
1106	else if (ip [3] == CMD_IP_SYN)	1219	else if (ip [3] == CMD_IP_SYN)
1107	{	1220	{
1108	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));	1221	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1109	dns->established = true;	1222	dns->established = true;
1110	}	1223	}
		1224	else if (ip [3] == CMD_IP_CSE)
		1225	{
		1226	if (conf.dns_case_preserving)
		1227	{
		1228	slog (L_INFO, _("DNS: got tunnel CSE reply, globally downgrading to case-insensitive protocol."));
		1229	conf.dns_case_preserving = false;
		1230	dns->reset ();
		1231	return;
		1232	}
		1233	else
		1234	{
		1235	slog (L_DEBUG, _("DNS: got tunnel CSE reply, server likes us."));
		1236	dns->established = true;
		1237	}
		1238	}
1111	else if (ip [3] == CMD_IP_REJ)	1239	else if (ip [3] == CMD_IP_REJ)
1112	{	1240	{
1113	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));	1241	slog (L_ERR, _("DNS: got tunnel REJ reply, server does not like us."));
1114	abort ();	1242	dns->tw.start (60.);
1115	}	1243	}
1116	else	1244	else
		1245	{
1117	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);	1246	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
		1247	dns->tw.start (60.);
		1248	}
1118	}	1249	}
1119	else	1250	else
1120	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),	1251	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1121	ip [0], ip [1], ip [2], ip [3]);	1252	ip [0], ip [1], ip [2], ip [3]);
1122		1253
…		…
1146	break;	1277	break;
1147	}	1278	}
1148	}	1279	}
1149		1280
1150	void	1281	void
1151	vpn::dnsv4_ev (io_watcher &w, short revents)	1282	vpn::dnsv4_ev (ev::io &w, int revents)
1152	{	1283	{
1153	if (revents & EVENT_READ)	1284	if (revents & EV_READ)
1154	{	1285	{
1155	dns_packet *pkt = new dns_packet;	1286	dns_packet *pkt = new dns_packet;
1156	struct sockaddr_in sa;	1287	struct sockaddr_in sa;
1157	socklen_t sa_len = sizeof (sa);	1288	socklen_t sa_len = sizeof (sa);
1158		1289
…		…
1174	}	1305	}
1175		1306
1176	bool	1307	bool
1177	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1308	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1178	{	1309	{
1179	int client = ntohs (si.port);	1310	int client = ntohl (si.host);
1180		1311
1181	assert (0 < client && client <= conns.size ());	1312	assert (0 < client && client <= conns.size ());
1182		1313
1183	connection *c = conns [client - 1];	1314	connection *c = conns [client - 1];
1184		1315
1185	if (!c->dns)	1316	if (!c->dns)
1186	c->dns = new dns_connection (c);	1317	c->dns = new dns_connection (c);
1187		1318
1188	if (!c->dns->snddq.put (pkt))	1319	if (c->dns->snddq.put (pkt))
1189	return false;	1320	{
		1321	min_it (c->dns->poll_interval, 0.25);
		1322	c->dns->tw ();
		1323	}
1190		1324
1191	c->dns->tw.trigger ();	1325	// always return true even if the buffer overflows
1192
1193	return true;	1326	return true;
1194	}	1327	}
1195		1328
1196	void	1329	void
1197	connection::dnsv4_reset_connection ()	1330	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	{	1331	{
1207	// servers have to be polled	1332	// servers have to be polled
1208	if (THISNODE->dns_port)	1333	if (THISNODE->dns_port)
1209	return;	1334	return;
1210		1335
1211	// check for timeouts and (re)transmit	1336	// check for timeouts and (re)transmit
1212	tstamp next = NOW + poll_interval;	1337	tstamp next = 86400 * 365;
1213	dns_snd *send = 0;	1338	dns_snd *send = 0;
1214		1339
1215	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1340	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1216	i != vpn->dns_sndpq.end ();	1341	i != vpn->dns_sndpq.end ();
1217	++i)	1342	++i)
1218	{	1343	{
1219	dns_snd r = i;	1344	dns_snd r = i;
1220		1345
1221	if (r->timeout <= NOW)	1346	if (r->timeout <= ev_now ())
1222	{	1347	{
1223	if (!send)	1348	if (!send)
1224	{	1349	{
1225	send = r;	1350	send = r;
1226		1351
1227	r->retry++;	1352	r->retry++;
1228	r->timeout = NOW + (r->retry * min_latency * 8.);	1353	r->timeout = ev_now () + r->retry * min_latency * conf.dns_timeout_factor;
		1354	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1229		1355
1230	// the following code changes the query section a bit, forcing	1356	// the following code changes the query section a bit, forcing
1231	// the forwarder to generate a new request	1357	// the forwarder to generate a new request
1232	if (r->stdhdr)	1358	if (r->stdhdr)
1233	{
1234	//printf ("reencoded header for ID %d retry %d:%d:%d (%p)\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);	1359	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1236	}
1237	}	1360	}
1238	}	1361	}
1239	else	1362	else
1240	NEXT (r->timeout);	1363	min_it (next, r->timeout - ev_now ());
1241	}	1364	}
1242		1365
1243	if (!send)	1366	if (!send)
1244	{	1367	{
1245	// generate a new packet, if wise	1368	// generate a new packet, if wise
…		…
1249	if (vpn->dns_sndpq.empty ())	1372	if (vpn->dns_sndpq.empty ())
1250	{	1373	{
1251	send = new dns_snd (this);	1374	send = new dns_snd (this);
1252		1375
1253	cfg.reset (THISNODE->id);	1376	cfg.reset (THISNODE->id);
		1377	set_cfg ();
1254	send->gen_syn_req ();	1378	send->gen_syn_req ();
1255	}	1379	}
1256	}	1380	}
1257	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING	1381	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1258	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))	1382	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1259	{	1383	{
1260	if (last_sent + send_interval <= NOW)	1384	if (last_sent + send_interval <= ev_now ())
1261	{	1385	{
1262	//printf ("sending data request etc.\n"); //D	1386	//printf ("sending data request etc.\n"); //D
1263	if (!snddq.empty () \|\| last_received + 1. > NOW)	1387	if (!snddq.empty ())
1264	{
1265	poll_interval = send_interval;
1266	NEXT (NOW + send_interval);	1388	min_it (next, send_interval);
1267	}
1268		1389
1269	send = new dns_snd (this);	1390	send = new dns_snd (this);
1270	send->gen_stream_req (sndseq, snddq);	1391	send->gen_stream_req (sndseq, snddq);
1271	send->timeout = NOW + min_latency * 8.;	1392	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1393	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1272		1394
1273	sndseq = (sndseq + 1) & SEQNO_MASK;	1395	sndseq = (sndseq + 1) & SEQNO_MASK;
1274	}	1396	}
1275	else	1397	else
1276	NEXT (last_sent + send_interval);	1398	min_it (next, last_sent + send_interval - ev_now ());
1277	}	1399	}
1278		1400
1279	if (send)	1401	if (send)
1280	vpn->dns_sndpq.push_back (send);	1402	vpn->dns_sndpq.push_back (send);
1281	}	1403	}
1282		1404
1283	if (send)	1405	if (send)
1284	{	1406	{
1285	last_sent = NOW;	1407	last_sent = ev_now ();
1286	sendto (vpn->dnsv4_fd,	1408	sendto (vpn->dnsv4_fd,
1287	send->pkt->at (0), send->pkt->len, 0,	1409	send->pkt->at (0), send->pkt->len, 0,
1288	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1410	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1289	}	1411	}
1290		1412
		1413	min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ());
		1414
1291	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",	1415	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1292	poll_interval, send_interval, next - NOW,	1416	poll_interval, send_interval, next - ev_now (),
1293	vpn->dns_sndpq.size (), snddq.size (),	1417	vpn->dns_sndpq.size (), snddq.size (),
1294	rcvpq.size ());	1418	rcvpq.size ());
1295		1419
1296	// TODO: no idea when this happens, but when next < NOW, we have a problem
1297	if (next < NOW + 0.001)
1298	next = NOW + 0.1;
1299
1300	w.start (next);	1420	w.start (next);
1301	}	1421	}
1302		1422
1303	#endif	1423	#endif
1304		1424

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.29 by pcg, Sun Mar 13 12:40:20 2005 UTC vs. Revision 1.55 by root, Tue Oct 18 11:11:32 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.29 by pcg, Sun Mar 13 12:40:20 2005 UTC vs.
Revision 1.55 by root, Tue Oct 18 11:11:32 2011 UTC