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

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

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.33 by pcg, Tue Mar 15 19:23:33 2005 UTC vs. Revision 1.53 by root, Tue Oct 18 10:54:17 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.33 by pcg, Tue Mar 15 19:23:33 2005 UTC vs.
Revision 1.53 by root, Tue Oct 18 10:54:17 2011 UTC