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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.17 by pcg, Sat Mar 5 03:47:05 2005 UTC vs.
Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC

…		…
1	/*	1	/*
2	vpn_dns.C -- handle the dns tunnel part of the protocol.	2	vpn_dns.C -- handle the dns tunnel part of the protocol.
3	Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de>	3	Copyright (C) 2003-2008 Marc Lehmann <gvpe@schmorp.de>
4		4
5	This file is part of GVPE.	5	This file is part of GVPE.
6		6
7	GVPE is free software; you can redistribute it and/or modify	7	GVPE is free software; you can redistribute it and/or modify it
8	it under the terms of the GNU General Public License as published by	8	under the terms of the GNU General Public License as published by the
9	the Free Software Foundation; either version 2 of the License, or	9	Free Software Foundation; either version 3 of the License, or (at your
10	(at your option) any later version.	10	option) any later version.
11		11
12	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful, but
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15	GNU General Public License for more details.	15	Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License along
18	along with gvpe; if not, write to the Free Software	18	with this program; if not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	19
		20	Additional permission under GNU GPL version 3 section 7
		21
		22	If you modify this Program, or any covered work, by linking or
		23	combining it with the OpenSSL project's OpenSSL library (or a modified
		24	version of that library), containing parts covered by the terms of the
		25	OpenSSL or SSLeay licenses, the licensors of this Program grant you
		26	additional permission to convey the resulting work. Corresponding
		27	Source for a non-source form of such a combination shall include the
		28	source code for the parts of OpenSSL used as well as that of the
		29	covered work.
20	*/	30	*/
		31
		32	// TODO: EDNS0 option to increase dns mtu?
		33	// TODO: re-write dns packet parsing/creation using a safe mem-buffer
		34	// to ensure no buffer overflows or similar problems.
21		35
22	#include "config.h"	36	#include "config.h"
23		37
24	#if ENABLE_DNS	38	#if ENABLE_DNS
25		39
26	// dns processing is EXTREMELY ugly. For obvious(?) reasons.	40	// dns processing is EXTREMELY ugly. For obvious(?) reasons.
27	// it's a hack, use only in emergency situations please.	41	// it's a hack, use only in emergency situations please.
28		42
29	#include <cstring>	43	#include <cstring>
		44	#include <cassert>
30		45
31	#include <sys/types.h>	46	#include <sys/types.h>
32	#include <sys/socket.h>	47	#include <sys/socket.h>
33	#include <sys/wait.h>	48	#include <sys/wait.h>
34	#include <sys/uio.h>	49	#include <sys/uio.h>
37	#include <unistd.h>	52	#include <unistd.h>
38	#include <fcntl.h>	53	#include <fcntl.h>
39		54
40	#include <map>	55	#include <map>
41		56
		57	#include <cstdio> /* bug in libgmp: gmp.h relies on cstdio being included */
42	#include <gmp.h>	58	#include <gmp.h>
43		59
44	#include "netcompat.h"	60	#include "netcompat.h"
45		61
46	#include "vpn.h"	62	#include "vpn.h"
47		63
48	#define MIN_POLL_INTERVAL .02 // how often to poll minimally when the server has data
49	#define MAX_POLL_INTERVAL 6. // how often to poll minimally when the server has no data	64	#define MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data
50	#define ACTIVITY_INTERVAL 5.	65	#define ACTIVITY_INTERVAL 5.
51		66
52	#define INITIAL_TIMEOUT 0.1 // retry timeouts	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
53	#define INITIAL_SYN_TIMEOUT 10. // retry timeout for initial syn	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54		69
55	#define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests
56	#define MAX_SEND_INTERVAL 0.5 // optimistic?	70	#define MAX_SEND_INTERVAL 2. // optimistic?
57		71
58	#define MAX_OUTSTANDING 10 // max. outstanding requests
59	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
60	#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
61		74
62	#define MAX_DOMAIN_SIZE 220 // 255 is legal limit, but bind doesn't compress well	75	#define MAX_DOMAIN_SIZE 240 // 255 is legal limit, but bind doesn't compress well
63	// 240 leaves about 4 bytes of server reply data	76	// 240 leaves about 4 bytes of server reply data
64	// every two request bytes less give room for one reply byte	77	// every request byte less give room for two reply bytes
65		78
66	#define SEQNO_MASK 0x3fff	79	#define SEQNO_MASK 0x3fff
67	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )	80	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
68		81
69	#define MAX_LBL_SIZE 63	82	#define MAX_LBL_SIZE 63
70	#define MAX_PKT_SIZE 512	83	#define MAX_PKT_SIZE 512
71		84
72	#define RR_TYPE_A 1	85	#define RR_TYPE_A 1
73	#define RR_TYPE_NULL 10	86	#define RR_TYPE_NULL 10
74	#define RR_TYPE_TXT 16	87	#define RR_TYPE_TXT 16
		88	#define RR_TYPE_AAAA 28
75	#define RR_TYPE_ANY 255	89	#define RR_TYPE_ANY 255
76		90
77	#define RR_CLASS_IN 1	91	#define RR_CLASS_IN 1
78		92
79	#define CMD_IP_1 207	93	#define CMD_IP_1 207
…		…
154	enc_len [len] = n;	168	enc_len [len] = n;
155	dec_len [n] = len;	169	dec_len [n] = len;
156	}	170	}
157	}	171	}
158		172
		173	unsigned int
159	unsigned int basecoder::encode_len (unsigned int len)	174	basecoder::encode_len (unsigned int len)
160	{	175	{
161	return enc_len [len];	176	return enc_len [len];
162	}	177	}
163		178
		179	unsigned int
164	unsigned int basecoder::decode_len (unsigned int len)	180	basecoder::decode_len (unsigned int len)
165	{	181	{
166	while (len && !dec_len [len])	182	while (len && !dec_len [len])
167	--len;	183	--len;
168		184
169	return dec_len [len];	185	return dec_len [len];
170	}	186	}
171		187
		188	unsigned int
172	unsigned int basecoder::encode (char dst, u8 src, unsigned int len)	189	basecoder::encode (char dst, u8 src, unsigned int len)
173	{	190	{
174	if (!len \|\| len > MAX_DEC_LEN)	191	if (!len \|\| len > MAX_DEC_LEN)
175	return 0;	192	return 0;
176		193
177	int elen = encode_len (len);	194	int elen = encode_len (len);
…		…
196	*dst++ = cmap.encode [dst_ [i]];	213	*dst++ = cmap.encode [dst_ [i]];
197		214
198	return elen;	215	return elen;
199	}	216	}
200		217
		218	unsigned int
201	unsigned int basecoder::decode (u8 dst, char src, unsigned int len)	219	basecoder::decode (u8 dst, char src, unsigned int len)
202	{	220	{
203	if (!len \|\| len > MAX_ENC_LEN)	221	if (!len \|\| len > MAX_ENC_LEN)
204	return 0;	222	return 0;
205		223
206	u8 src_ [MAX_ENC_LEN];	224	u8 src_ [MAX_ENC_LEN];
…		…
264	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	282	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
265		283
266	/////////////////////////////////////////////////////////////////////////////	284	/////////////////////////////////////////////////////////////////////////////
267		285
268	#define HDRSIZE 6	286	#define HDRSIZE 6
269		287
		288	inline void
270	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)	289	encode_header (char *data, int clientid, int seqno, int retry = 0)
271	{	290	{
272	seqno &= SEQNO_MASK;	291	seqno &= SEQNO_MASK;
273		292
274	u8 hdr[3] = {	293	u8 hdr[3] = {
275	clientid,	294	clientid,
…		…
280	assert (clientid < 256);	299	assert (clientid < 256);
281		300
282	cdc26.encode (data, hdr, 3);	301	cdc26.encode (data, hdr, 3);
283	}	302	}
284		303
		304	inline void
285	inline void decode_header (char *data, int &clientid, int &seqno)	305	decode_header (char *data, int &clientid, int &seqno)
286	{	306	{
287	u8 hdr[3];	307	u8 hdr[3];
288		308
289	cdc26.decode (hdr, data, HDRSIZE);	309	cdc26.decode (hdr, data, HDRSIZE);
290		310
…		…
323	byte_stream::~byte_stream ()	343	byte_stream::~byte_stream ()
324	{	344	{
325	delete data;	345	delete data;
326	}	346	}
327		347
		348	void
328	void byte_stream::remove (int count)	349	byte_stream::remove (int count)
329	{	350	{
330	if (count > fill)	351	if (count > fill)
331	assert (count <= fill);	352	assert (count <= fill);
332		353
333	memmove (data, data + count, fill -= count);	354	memmove (data, data + count, fill -= count);
334	}	355	}
335		356
		357	bool
336	bool byte_stream::put (u8 *data, unsigned int datalen)	358	byte_stream::put (u8 *data, unsigned int datalen)
337	{	359	{
338	if (maxsize - fill < datalen)	360	if (maxsize - fill < datalen)
339	return false;	361	return false;
340		362
341	memcpy (this->data + fill, data, datalen); fill += datalen;	363	memcpy (this->data + fill, data, datalen); fill += datalen;
342		364
343	return true;	365	return true;
344	}	366	}
345		367
		368	bool
346	bool byte_stream::put (vpn_packet *pkt)	369	byte_stream::put (vpn_packet *pkt)
347	{	370	{
348	if (maxsize - fill < pkt->len + 2)	371	if (maxsize - fill < pkt->len + 2)
349	return false;	372	return false;
350		373
351	data [fill++] = pkt->len >> 8;	374	data [fill++] = pkt->len >> 8;
…		…
356	return true;	379	return true;
357	}	380	}
358		381
359	vpn_packet *byte_stream::get ()	382	vpn_packet *byte_stream::get ()
360	{	383	{
		384	unsigned int len;
		385
		386	for (;;)
		387	{
361	unsigned int len = (data [0] << 8) \| data [1];	388	len = (data [0] << 8) \| data [1];
362		389
363	if (len > MAXSIZE && fill >= 2)	390	if (len <= MAXSIZE \|\| fill < 2)
364	assert (len <= MAXSIZE \|\| fill < 2); // TODO handle this gracefully, connection reset	391	break;
365		392
		393	// TODO: handle this better than skipping, e.g. by reset
		394	slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
		395	remove (1);
		396	}
		397
366	if (fill < len + 2)	398	if (fill < len + 2)
367	return 0;	399	return 0;
368		400
369	vpn_packet *pkt = new vpn_packet;	401	vpn_packet *pkt = new vpn_packet;
370		402
…		…
399	struct dns_cfg	431	struct dns_cfg
400	{	432	{
401	static int next_uid;	433	static int next_uid;
402		434
403	u8 id1, id2, id3, id4;	435	u8 id1, id2, id3, id4;
		436
404	u8 version;	437	u8 version;
		438	u8 flags;
405	u8 rrtype;	439	u8 rrtype;
406	u8 flags;
407	u8 def_ttl;	440	u8 def_ttl;
408	u8 rcv_cdc;	441
409	u8 snd_cdc;
410	u16 max_size;
411	u16 client;	442	u16 client;
412	u16 uid; // to make request unique	443	u16 uid; // to make request unique
413		444
414	u8 reserved[8];	445	u16 max_size;
		446	u8 seq_cdc;
		447	u8 req_cdc;
		448
		449	u8 rep_cdc;
		450	u8 delay; // time in 0.01s units that the server may delay replying packets
		451	u8 r3, r4;
		452
		453	u8 r5, r6, r7, r8;
415		454
416	void reset (int clientid);	455	void reset (int clientid);
417	bool valid ();	456	bool valid ();
418	};	457	};
419		458
420	int dns_cfg::next_uid;	459	int dns_cfg::next_uid;
421		460
		461	void
422	void dns_cfg::reset (int clientid)	462	dns_cfg::reset (int clientid)
423	{	463	{
424	id1 = 'G';	464	id1 = 'G';
425	id2 = 'V';	465	id2 = 'V';
426	id3 = 'P';	466	id3 = 'P';
427	id4 = 'E';	467	id4 = 'E';
428		468
429	version = 1;	469	version = 1;
430		470
431	rrtype = RR_TYPE_TXT;	471	rrtype = RR_TYPE_TXT;
432	flags = 0;	472	flags = 0;
433	def_ttl = 1;	473	def_ttl = 0;
		474	seq_cdc = 26;
		475	req_cdc = 62;
434	rcv_cdc = 0;	476	rep_cdc = 0;
435	snd_cdc = 62;
436	max_size = ntohs (MAX_PKT_SIZE);	477	max_size = htons (MAX_PKT_SIZE);
437	client = ntohs (clientid);	478	client = htons (clientid);
438	uid = next_uid++;	479	uid = next_uid++;
		480	delay = 0;
439		481
440	memset (reserved, 0, 8);	482	r3 = r4 = 0;
		483	r4 = r5 = r6 = r7 = 0;
441	}	484	}
442		485
		486	bool
443	bool dns_cfg::valid ()	487	dns_cfg::valid ()
444	{	488	{
		489	// although the protocol itself allows for some configurability,
		490	// only the following encoding/decoding settings are implemented.
445	return id1 == 'G'	491	return id1 == 'G'
446	&& id2 == 'V'	492	&& id2 == 'V'
447	&& id3 == 'P'	493	&& id3 == 'P'
448	&& id4 == 'E'	494	&& id4 == 'E'
		495	&& seq_cdc == 26
		496	&& req_cdc == 62
		497	&& rep_cdc == 0
449	&& version == 1	498	&& version == 1;
450	&& flags == 0
451	&& rcv_cdc == 0
452	&& snd_cdc == 62
453	&& max_size == ntohs (MAX_PKT_SIZE);
454	}	499	}
455		500
456	struct dns_packet : net_packet	501	struct dns_packet : net_packet
457	{	502	{
458	u16 id;	503	u16 id;
459	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4	504	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
460	u16 qdcount, ancount, nscount, arcount;	505	u16 qdcount, ancount, nscount, arcount;
461		506
462	u8 data[MAXSIZE - 6 * 2];	507	u8 data [MAXSIZE - 6 * 2];
463		508
464	int decode_label (char *data, int size, int &offs);	509	int decode_label (char *data, int size, int &offs);
465	};	510	};
466		511
		512	int
467	int dns_packet::decode_label (char *data, int size, int &offs)	513	dns_packet::decode_label (char *data, int size, int &offs)
468	{	514	{
469	char *orig = data;	515	char *orig = data;
470		516
471	memset (data, 0, size);	517	memset (data, 0, size);
472		518
…		…
498	return data - orig;	544	return data - orig;
499	}	545	}
500		546
501	/////////////////////////////////////////////////////////////////////////////	547	/////////////////////////////////////////////////////////////////////////////
502		548
		549	static
		550	u16 next_id ()
		551	{
		552	static u16 dns_id = 0; // TODO: should be per-vpn
		553
		554	if (!dns_id)
		555	dns_id = time (0);
		556
		557	// the simplest lsfr with periodicity 65535 i could find
		558	dns_id = (dns_id << 1)
		559	\| (((dns_id >> 1)
		560	^ (dns_id >> 2)
		561	^ (dns_id >> 4)
		562	^ (dns_id >> 15)) & 1);
		563
		564	return dns_id;
		565	}
		566
		567	struct dns_rcv;
		568	struct dns_snd;
		569
		570	struct dns_connection
		571	{
		572	connection *c;
		573	struct vpn *vpn;
		574
		575	dns_cfg cfg;
		576
		577	bool established;
		578
		579	tstamp last_received;
		580	tstamp last_sent;
		581	double min_latency;
		582	double poll_interval, send_interval;
		583
		584	vector<dns_rcv *> rcvpq;
		585
		586	byte_stream rcvdq; int rcvseq; int repseq;
		587	byte_stream snddq; int sndseq;
		588
		589	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
		590	void receive_rep (dns_rcv *r);
		591
		592	dns_connection (connection *c);
		593	~dns_connection ();
		594	};
		595
503	struct dns_snd	596	struct dns_snd
504	{	597	{
505	dns_packet *pkt;	598	dns_packet *pkt;
506	tstamp timeout, sent;	599	tstamp timeout, sent;
507	int retry;	600	int retry;
508	struct dns_connection *dns;	601	struct dns_connection *dns;
509	int seqno;	602	int seqno;
510	bool stdhdr;	603	bool stdhdr;
511		604
512	void gen_stream_req (int seqno, byte_stream &stream);	605	void gen_stream_req (int seqno, byte_stream &stream);
513	void gen_syn_req (const dns_cfg &cfg);	606	void gen_syn_req ();
514		607
515	dns_snd (dns_connection *dns);	608	dns_snd (dns_connection *dns);
516	~dns_snd ();	609	~dns_snd ();
517	};	610	};
518		611
519	static u16 dns_id = 12098; // TODO: should be per-vpn
520
521	static u16 next_id ()
522	{
523	// the simplest lsfr with periodicity 65535 i could find
524	dns_id = (dns_id << 1)
525	\| (((dns_id >> 1)
526	^ (dns_id >> 2)
527	^ (dns_id >> 4)
528	^ (dns_id >> 15)) & 1);
529
530	return dns_id;
531	}
532
533	dns_snd::dns_snd (dns_connection *dns)	612	dns_snd::dns_snd (dns_connection *dns)
534	: dns (dns)	613	: dns (dns)
535	{	614	{
536	timeout = 0;	615	timeout = 0;
537	retry = 0;	616	retry = 0;
538	seqno = 0;	617	seqno = 0;
539	sent = NOW;	618	sent = ev_now ();
540	stdhdr = false;	619	stdhdr = false;
541		620
542	pkt = new dns_packet;	621	pkt = new dns_packet;
543		622
544	pkt->id = next_id ();	623	pkt->id = next_id ();
…		…
547	dns_snd::~dns_snd ()	626	dns_snd::~dns_snd ()
548	{	627	{
549	delete pkt;	628	delete pkt;
550	}	629	}
551		630
		631	static void
552	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	632	append_domain (dns_packet &pkt, int &offs, const char *domain)
553	{	633	{
554	// add tunnel domain	634	// add tunnel domain
555	for (;;)	635	for (;;)
556	{	636	{
557	const char *end = strchr (domain, '.');	637	const char *end = strchr (domain, '.');
…		…
570		650
571	domain = end + 1;	651	domain = end + 1;
572	}	652	}
573	}	653	}
574		654
		655	void
575	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	656	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
576	{	657	{
577	stdhdr = true;	658	stdhdr = true;
578	this->seqno = seqno;	659	this->seqno = seqno;
579		660
580	timeout = NOW + INITIAL_TIMEOUT;	661	timeout = ev_now () + INITIAL_TIMEOUT;
581		662
582	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	663	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
583	pkt->qdcount = htons (1);	664	pkt->qdcount = htons (1);
584		665
585	int offs = 6*2;	666	int offs = 6*2;
586	int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2);	667	int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
587	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,	668	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,
588	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	669	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
589		670
590	char enc[256], *encp = enc;	671	char enc[256], *encp = enc;
591	encode_header (enc, THISNODE->id, seqno);	672	encode_header (enc, THISNODE->id, seqno);
…		…
609	encp += lbllen;	690	encp += lbllen;
610		691
611	enclen -= lbllen;	692	enclen -= lbllen;
612	}	693	}
613		694
614	append_domain (*pkt, offs, THISNODE->domain);	695	append_domain (*pkt, offs, dns->c->conf->domain);
615		696
616	(*pkt)[offs++] = 0;	697	(*pkt)[offs++] = 0;
617	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;	698	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;
618	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	699	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
619		700
620	pkt->len = offs;	701	pkt->len = offs;
621	}	702	}
622		703
623	void dns_snd::gen_syn_req (const dns_cfg &cfg)	704	void
		705	dns_snd::gen_syn_req ()
624	{	706	{
625	timeout = NOW + INITIAL_SYN_TIMEOUT;	707	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
626		708
627	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	709	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
628	pkt->qdcount = htons (1);	710	pkt->qdcount = htons (1);
629		711
630	int offs = 6*2;	712	int offs = 6 * 2;
631		713
632	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&cfg, sizeof (dns_cfg));	714	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&dns->cfg, sizeof (dns_cfg));
633		715
634	assert (elen <= MAX_LBL_SIZE);	716	assert (elen <= MAX_LBL_SIZE);
635		717
636	(*pkt)[offs] = elen;	718	(*pkt)[offs] = elen;
637	offs += elen + 1;	719	offs += elen + 1;
638	append_domain (*pkt, offs, THISNODE->domain);	720	append_domain (*pkt, offs, dns->c->conf->domain);
639		721
640	(*pkt)[offs++] = 0;	722	(*pkt)[offs++] = 0;
641	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;	723	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;
642	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	724	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
643		725
…		…
666	delete pkt;	748	delete pkt;
667	}	749	}
668		750
669	/////////////////////////////////////////////////////////////////////////////	751	/////////////////////////////////////////////////////////////////////////////
670		752
671	struct dns_connection
672	{
673	connection *c;
674	struct vpn *vpn;
675
676	dns_cfg cfg;
677
678	bool established;
679
680	tstamp last_received;
681	tstamp last_sent;
682	double last_latency;
683	double poll_interval, send_interval;
684
685	vector<dns_rcv *> rcvpq;
686
687	byte_stream rcvdq; int rcvseq;
688	byte_stream snddq; int sndseq;
689
690	void time_cb (time_watcher &w); time_watcher tw;
691	void receive_rep (dns_rcv *r);
692
693	dns_connection (connection *c);
694	~dns_connection ();
695	};
696
697	dns_connection::dns_connection (connection *c)	753	dns_connection::dns_connection (connection *c)
698	: c (c)	754	: c (c)
699	, rcvdq (MAX_BACKLOG * 2)	755	, rcvdq (MAX_BACKLOG * 2)
700	, snddq (MAX_BACKLOG * 2)	756	, snddq (MAX_BACKLOG)
701	, tw (this, &dns_connection::time_cb)
702	{	757	{
		758	tw.set<dns_connection, &dns_connection::time_cb> (this);
		759
703	vpn = c->vpn;	760	vpn = c->vpn;
704		761
705	established = false;	762	established = false;
706		763
707	rcvseq = sndseq = 0;	764	rcvseq = repseq = sndseq = 0;
708		765
709	last_sent = last_received = 0;	766	last_sent = last_received = 0;
710	poll_interval = MIN_POLL_INTERVAL;	767	poll_interval = 0.5; // starting here
711	send_interval = 0.5; // starting rate	768	send_interval = 0.5; // starting rate
712	last_latency = INITIAL_TIMEOUT;	769	min_latency = INITIAL_TIMEOUT;
713	}	770	}
714		771
715	dns_connection::~dns_connection ()	772	dns_connection::~dns_connection ()
716	{	773	{
717	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	774	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
718	i != rcvpq.end ();	775	i != rcvpq.end ();
719	++i)	776	++i)
720	delete *i;	777	delete *i;
721	}	778	}
722		779
		780	void
723	void dns_connection::receive_rep (dns_rcv *r)	781	dns_connection::receive_rep (dns_rcv *r)
724	{	782	{
725	if (r->datalen)	783	if (r->datalen)
726	{	784	{
727	last_received = NOW;	785	last_received = ev_now ();
728	tw.trigger ();	786	tw ();
729		787
730	poll_interval = send_interval;	788	poll_interval = send_interval;
731	}	789	}
732	else	790	else
733	{	791	{
734	poll_interval *= 1.5;	792	poll_interval *= 1.5;
		793
735	if (poll_interval > MAX_POLL_INTERVAL)	794	if (poll_interval > MAX_POLL_INTERVAL)
736	poll_interval = MAX_POLL_INTERVAL;	795	poll_interval = MAX_POLL_INTERVAL;
737	}	796	}
738		797
739	rcvpq.push_back (r);	798	rcvpq.push_back (r);
…		…
742		801
743	// find next packet	802	// find next packet
744	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	803	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
745	if (SEQNO_EQ (rcvseq, (*i)->seqno))	804	if (SEQNO_EQ (rcvseq, (*i)->seqno))
746	{	805	{
		806	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
747	// enter the packet into our input stream	807	// enter the packet into our input stream
748	r = *i;	808	r = *i;
749		809
750	// remove the oldest packet, look forward, as it's oldest first	810	// remove the oldest packet, look forward, as it's oldest first
751	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	811	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
752	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	812	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
753	{	813	{
		814	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
754	delete *j;	815	delete *j;
755	rcvpq.erase (j);	816	rcvpq.erase (j);
756	break;	817	break;
757	}	818	}
758		819
…		…
765	}	826	}
766		827
767	while (vpn_packet *pkt = rcvdq.get ())	828	while (vpn_packet *pkt = rcvdq.get ())
768	{	829	{
769	sockinfo si;	830	sockinfo si;
770	si.host = 0; si.port = 0; si.prot = PROT_DNSv4;	831	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
771		832
772	vpn->recv_vpn_packet (pkt, si);	833	vpn->recv_vpn_packet (pkt, si);
773		834
774	delete pkt;	835	delete pkt;
775	}	836	}
…		…
789	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	850	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
790		851
791	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	852	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
792	&& pkt.qdcount == htons (1))	853	&& pkt.qdcount == htons (1))
793	{	854	{
794	char qname[MAXSIZE];	855	char qname [MAXSIZE];
795	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	856	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
796		857
797	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	858	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
798	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	859	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
799		860
…		…
806		867
807	int dlen = strlen (THISNODE->domain);	868	int dlen = strlen (THISNODE->domain);
808		869
809	if (qclass == RR_CLASS_IN	870	if (qclass == RR_CLASS_IN
810	&& qlen > dlen + 1	871	&& qlen > dlen + 1
811	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	872	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
812	{	873	{
813	// now generate reply	874	// now generate reply
814	pkt.ancount = htons (1); // one answer RR	875	pkt.ancount = htons (1); // one answer RR
815	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	876	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
816		877
…		…
829	if (0 < client && client <= conns.size ())	890	if (0 < client && client <= conns.size ())
830	{	891	{
831	connection *c = conns [client - 1];	892	connection *c = conns [client - 1];
832	dns_connection *dns = c->dns;	893	dns_connection *dns = c->dns;
833	dns_rcv *rcv;	894	dns_rcv *rcv;
834	bool in_seq;
835		895
836	if (dns)	896	if (dns)
837	{	897	{
838	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	898	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
839	if (SEQNO_EQ ((*i)->seqno, seqno))	899	if (SEQNO_EQ ((*i)->seqno, seqno))
…		…
850	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	910	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
851		911
852	goto duplicate_request;	912	goto duplicate_request;
853	}	913	}
854		914
855	in_seq = dns->rcvseq == seqno;
856
857	// new packet, queue	915	// new packet, queue
858	rcv = new dns_rcv (seqno, data, datalen);	916	rcv = new dns_rcv (seqno, data, datalen);
859	dns->receive_rep (rcv);	917	dns->receive_rep (rcv);
860	}	918	}
861		919
		920	{
862	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section	921	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
863		922
864	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;	923	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
865	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type	924	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
866	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	925	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
867	pkt [offs++] = 0; pkt [offs++] = 0;	926	pkt [offs++] = 0; pkt [offs++] = 0;
868	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL	927	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
869		928
870	int rdlen_offs = offs += 2;	929	int rdlen_offs = offs += 2;
871		930
		931	if (dns)
		932	{
872	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;	933	int dlen = ntohs (dns->cfg.max_size) - offs;
		934
873	// bind doesn't compress well, so reduce further by one label length	935	// bind doesn't compress well, so reduce further by one label length
874	dlen -= qlen;	936	dlen -= qlen;
875		937
876	if (dns)
877	{
878	// only put data into in-order sequence packets, if	938	// only put data into in-order sequence packets, if
879	// we receive out-of-order packets we generate empty	939	// we receive out-of-order packets we generate empty
880	// replies	940	// replies
881	while (dlen > 1 && !dns->snddq.empty () && in_seq)	941	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		942	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
882	{	943	{
		944	dns->repseq = seqno;
		945
		946	while (dlen > 1 && !dns->snddq.empty ())
		947	{
883	int txtlen = dlen <= 255 ? dlen - 1 : 255;	948	int txtlen = dlen <= 255 ? dlen - 1 : 255;
884		949
885	if (txtlen > dns->snddq.size ())	950	if (txtlen > dns->snddq.size ())
886	txtlen = dns->snddq.size ();	951	txtlen = dns->snddq.size ();
887		952
888	pkt[offs++] = txtlen;	953	pkt[offs++] = txtlen;
889	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	954	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
890	offs += txtlen;	955	offs += txtlen;
891	dns->snddq.remove (txtlen);	956	dns->snddq.remove (txtlen);
892		957
893	dlen -= txtlen + 1;	958	dlen -= txtlen + 1;
		959	}
894	}	960	}
895		961
896	// avoid empty TXT rdata	962	// avoid completely empty TXT rdata
897	if (offs == rdlen_offs)	963	if (offs == rdlen_offs)
898	pkt[offs++] = 0;	964	pkt[offs++] = 0;
899		965
900	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());	966	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
901	}	967	}
902	else	968	else
903	{	969	{
904	// send RST	970	// send RST
905	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	971	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
906	pkt [offs++] = CMD_IP_RST;	972	pkt [offs++] = CMD_IP_RST;
907	}	973	}
908		974
909	int rdlen = offs - rdlen_offs;	975	int rdlen = offs - rdlen_offs;
910		976
911	pkt [rdlen_offs - 2] = rdlen >> 8;	977	pkt [rdlen_offs - 2] = rdlen >> 8;
912	pkt [rdlen_offs - 1] = rdlen;	978	pkt [rdlen_offs - 1] = rdlen;
913		979
914	if (dns)	980	if (dns)
915	{	981	{
916	// now update dns_rcv copy	982	// now update dns_rcv copy
917	rcv->pkt->len = offs;	983	rcv->pkt->len = offs;
918	memcpy (rcv->pkt->at (0), pkt.at (0), offs);	984	memcpy (rcv->pkt->at (0), pkt.at (0), offs);
919	}	985	}
		986	}
920		987
921	duplicate_request: ;	988	duplicate_request: ;
922	}	989	}
923	else	990	else
924	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	991	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
…		…
936	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	1003	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
937	pkt [offs++] = 0; pkt [offs++] = 0;	1004	pkt [offs++] = 0; pkt [offs++] = 0;
938	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1005	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
939	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1006	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
940		1007
941	slog (L_INFO, _("DNS: client %d tries to connect"), client);	1008	slog (L_INFO, _("DNS: client %d connects"), client);
942		1009
943	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	1010	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
944	pkt [offs++] = CMD_IP_REJ;	1011	pkt [offs++] = CMD_IP_REJ;
945		1012
946	if (0 < client && client <= conns.size ())	1013	if (0 < client && client <= conns.size ())
…		…
980	{	1047	{
981	dns_connection dns = (i)->dns;	1048	dns_connection dns = (i)->dns;
982	connection *c = dns->c;	1049	connection *c = dns->c;
983	int seqno = (*i)->seqno;	1050	int seqno = (*i)->seqno;
984	u8 data[MAXSIZE], *datap = data;	1051	u8 data[MAXSIZE], *datap = data;
		1052	//printf ("rcv pkt %x\n", seqno);//D
985		1053
986	if ((*i)->retry)	1054	if ((*i)->retry)
987	{	1055	{
988	dns->send_interval *= 1.01;	1056	dns->send_interval *= 1.01;
989	if (dns->send_interval > MAX_SEND_INTERVAL)	1057	if (dns->send_interval > MAX_SEND_INTERVAL)
990	dns->send_interval = MAX_SEND_INTERVAL;	1058	dns->send_interval = MAX_SEND_INTERVAL;
991	}	1059	}
992	else	1060	else
993	{	1061	{
994	#if 1	1062	#if 0
995	dns->send_interval *= 0.999;	1063	dns->send_interval *= 0.999;
996	#endif	1064	#endif
997	if (dns->send_interval < MIN_SEND_INTERVAL)
998	dns->send_interval = MIN_SEND_INTERVAL;
999
1000	// the latency surely puts an upper bound on	1065	// the latency surely puts an upper bound on
1001	// the minimum send interval	1066	// the minimum send interval
1002	double latency = NOW - (*i)->sent;	1067	double latency = ev_now () - (*i)->sent;
		1068
		1069	if (latency < dns->min_latency)
1003	dns->last_latency = latency;	1070	dns->min_latency = latency;
1004		1071
1005	if (dns->send_interval > latency)	1072	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1073	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1074
		1075	if (dns->send_interval < conf.dns_send_interval)
1006	dns->send_interval = latency;	1076	dns->send_interval = conf.dns_send_interval;
1007	}	1077	}
1008		1078
1009	delete *i;	1079	delete *i;
1010	dns_sndpq.erase (i);	1080	dns_sndpq.erase (i);
1011		1081
…		…
1116	break;	1186	break;
1117	}	1187	}
1118	}	1188	}
1119		1189
1120	void	1190	void
1121	vpn::dnsv4_ev (io_watcher &w, short revents)	1191	vpn::dnsv4_ev (ev::io &w, int revents)
1122	{	1192	{
1123	if (revents & EVENT_READ)	1193	if (revents & EV_READ)
1124	{	1194	{
1125	dns_packet *pkt = new dns_packet;	1195	dns_packet *pkt = new dns_packet;
1126	struct sockaddr_in sa;	1196	struct sockaddr_in sa;
1127	socklen_t sa_len = sizeof (sa);	1197	socklen_t sa_len = sizeof (sa);
1128		1198
1129	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);	1199	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1130		1200
1131	if (pkt->len > 0)	1201	if (pkt->len > 0)
1132	{	1202	{
1133	if (THISNODE->dns_port)	1203	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1204	dnsv4_client (*pkt);
		1205	else
1134	{	1206	{
1135	dnsv4_server (*pkt);	1207	dnsv4_server (*pkt);
1136	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);	1208	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1137	}	1209	}
1138	else
1139	dnsv4_client (*pkt);
1140		1210
1141	delete pkt;	1211	delete pkt;
1142	}	1212	}
1143	}	1213	}
1144	}	1214	}
1145		1215
1146	bool	1216	bool
1147	connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1217	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1148	{	1218	{
		1219	int client = ntohl (si.host);
		1220
		1221	assert (0 < client && client <= conns.size ());
		1222
		1223	connection *c = conns [client - 1];
		1224
1149	if (!dns)	1225	if (!c->dns)
1150	dns = new dns_connection (this);	1226	c->dns = new dns_connection (c);
1151		1227
1152	if (!dns->snddq.put (pkt))	1228	if (c->dns->snddq.put (pkt))
1153	return false;	1229	c->dns->tw ();
1154		1230
1155	dns->tw.trigger ();	1231	// always return true even if the buffer overflows
1156
1157	return true;	1232	return true;
1158	}	1233	}
1159		1234
1160	void	1235	void
1161	connection::dnsv4_reset_connection ()	1236	connection::dnsv4_reset_connection ()
…		…
1164	}	1239	}
1165		1240
1166	#define NEXT(w) do { if (next > (w)) next = w; } while (0)	1241	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1167		1242
1168	void	1243	void
1169	dns_connection::time_cb (time_watcher &w)	1244	dns_connection::time_cb (ev::timer &w, int revents)
1170	{	1245	{
1171	// servers have to be polled	1246	// servers have to be polled
1172	if (THISNODE->dns_port)	1247	if (THISNODE->dns_port)
1173	return;	1248	return;
1174		1249
1175	// check for timeouts and (re)transmit	1250	// check for timeouts and (re)transmit
1176	tstamp next = NOW + poll_interval;	1251	tstamp next = ev::now () + poll_interval;
1177	dns_snd *send = 0;	1252	dns_snd *send = 0;
1178		1253
1179	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1254	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1180	i != vpn->dns_sndpq.end ();	1255	i != vpn->dns_sndpq.end ();
1181	++i)	1256	++i)
1182	{	1257	{
1183	dns_snd r = i;	1258	dns_snd r = i;
1184		1259
1185	if (r->timeout <= NOW)	1260	if (r->timeout <= ev_now ())
1186	{	1261	{
1187	if (!send)	1262	if (!send)
1188	{	1263	{
1189	send = r;	1264	send = r;
1190		1265
1191	r->retry++;	1266	r->retry++;
1192	r->timeout = NOW + (r->retry * last_latency * 8.);	1267	r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
		1268	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1193		1269
1194	// the following code changes the query section a bit, forcing	1270	// the following code changes the query section a bit, forcing
1195	// the forwarder to generate a new request	1271	// the forwarder to generate a new request
1196	if (r->stdhdr)	1272	if (r->stdhdr)
1197	{
1198	//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);
1199	//encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);	1273	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1200	}
1201	}	1274	}
1202	}	1275	}
1203	else	1276	else
1204	NEXT (r->timeout);	1277	NEXT (r->timeout);
1205	}	1278	}
1206		1279
1207	if (last_sent + send_interval <= NOW)
1208	{
1209	if (!send)	1280	if (!send)
		1281	{
		1282	// generate a new packet, if wise
		1283
		1284	if (!established)
1210	{	1285	{
1211	// generate a new packet, if wise	1286	if (vpn->dns_sndpq.empty ())
1212
1213	if (!established)
1214	{	1287	{
1215	if (vpn->dns_sndpq.empty ())
1216	{
1217	send = new dns_snd (this);	1288	send = new dns_snd (this);
1218		1289
1219	cfg.reset (THISNODE->id);	1290	cfg.reset (THISNODE->id);
1220	send->gen_syn_req (cfg);	1291	send->gen_syn_req ();
1221	}
1222	}	1292	}
1223	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING	1293	}
		1294	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1224	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))	1295	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1296	{
		1297	if (last_sent + send_interval <= ev_now ())
1225	{	1298	{
1226	if (!snddq.empty ())	1299	//printf ("sending data request etc.\n"); //D
		1300	if (!snddq.empty () \|\| last_received + 1. > ev_now ())
1227	{	1301	{
1228	poll_interval = send_interval;	1302	poll_interval = send_interval;
1229	NEXT (NOW + send_interval);	1303	NEXT (ev_now () + send_interval);
1230	}	1304	}
1231		1305
1232	send = new dns_snd (this);	1306	send = new dns_snd (this);
1233	send->gen_stream_req (sndseq, snddq);	1307	send->gen_stream_req (sndseq, snddq);
1234	send->timeout = NOW + last_latency * 8.;	1308	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1309	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1235		1310
1236	sndseq = (sndseq + 1) & SEQNO_MASK;	1311	sndseq = (sndseq + 1) & SEQNO_MASK;
1237	}	1312	}
1238		1313	else
1239	if (send)	1314	NEXT (last_sent + send_interval);
1240	vpn->dns_sndpq.push_back (send);
1241	}	1315	}
1242		1316
1243	if (send)	1317	if (send)
1244	{	1318	vpn->dns_sndpq.push_back (send);
1245	last_sent = NOW;	1319	}
		1320
		1321	if (send)
		1322	{
		1323	last_sent = ev_now ();
1246	sendto (vpn->dnsv4_fd,	1324	sendto (vpn->dnsv4_fd,
1247	send->pkt->at (0), send->pkt->len, 0,	1325	send->pkt->at (0), send->pkt->len, 0,
1248	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1326	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1249	}
1250	}	1327	}
1251	else
1252	NEXT (last_sent + send_interval);
1253		1328
1254	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d)",	1329	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1255	poll_interval, send_interval, next - NOW,	1330	poll_interval, send_interval, next - ev_now (),
1256	vpn->dns_sndpq.size (), snddq.size ());	1331	vpn->dns_sndpq.size (), snddq.size (),
		1332	rcvpq.size ());
1257		1333
1258	// TODO: no idea when this happens, but when next < NOW, we have a problem	1334	// TODO: no idea when this happens, but when next < ev_now (), we have a problem
		1335	// doesn't seem to happen anymore
1259	if (next < NOW + 0.0001)	1336	if (next < ev_now () + 0.001)
1260	next = NOW + 0.1;	1337	next = ev_now () + 0.1;
1261		1338
1262	w.start (next);	1339	w.start (next - ev_now ());
1263	}	1340	}
1264		1341
1265	#endif	1342	#endif
1266		1343

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.17 by pcg, Sat Mar 5 03:47:05 2005 UTC vs. Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.17 by pcg, Sat Mar 5 03:47:05 2005 UTC vs.
Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC