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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.11 by pcg, Fri Mar 4 08:45:24 2005 UTC vs.
Revision 1.48 by pcg, Tue Jul 28 00:42:14 2009 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 .2 // how often to poll minimally when the server is having 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 1.	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
53	#define INITIAL_SYN_TIMEOUT 2.	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54		69
55	#define MIN_SEND_INTERVAL 0.001
56	#define MAX_SEND_INTERVAL 0.5 // optimistic?	70	#define MAX_SEND_INTERVAL 2. // optimistic?
57		71
58	#define MAX_OUTSTANDING 400 // max. outstanding requests
59	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
60	#define MAX_BACKLOG (100*1024) // size of protocol backlog, 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 byte sless give room for one reply byte	77	// every request byte less give room for two reply bytes
65		78
66	#define SEQNO_MASK 0xffff	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
…		…
264	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	278	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
265		279
266	/////////////////////////////////////////////////////////////////////////////	280	/////////////////////////////////////////////////////////////////////////////
267		281
268	#define HDRSIZE 6	282	#define HDRSIZE 6
269		283
270	inline void encode_header (char *data, int clientid, int seqno)	284	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)
271	{	285	{
272	u8 hdr[3] = { clientid, seqno >> 8, seqno };	286	seqno &= SEQNO_MASK;
		287
		288	u8 hdr[3] = {
		289	clientid,
		290	(seqno >> 8) \| (retry << 6),
		291	seqno,
		292	};
273		293
274	assert (clientid < 256);	294	assert (clientid < 256);
275		295
276	cdc26.encode (data, hdr, 3);	296	cdc26.encode (data, hdr, 3);
277	}	297	}
…		…
281	u8 hdr[3];	301	u8 hdr[3];
282		302
283	cdc26.decode (hdr, data, HDRSIZE);	303	cdc26.decode (hdr, data, HDRSIZE);
284		304
285	clientid = hdr[0];	305	clientid = hdr[0];
286	seqno = (hdr[1] << 8) \| hdr[2];	306	seqno = ((hdr[1] << 8) \| hdr[2]) & SEQNO_MASK;
287	}	307	}
288		308
289	/////////////////////////////////////////////////////////////////////////////	309	/////////////////////////////////////////////////////////////////////////////
290		310
291	struct byte_stream	311	struct byte_stream
…		…
320	}	340	}
321		341
322	void byte_stream::remove (int count)	342	void byte_stream::remove (int count)
323	{	343	{
324	if (count > fill)	344	if (count > fill)
325	abort ();	345	assert (count <= fill);
326		346
327	memmove (data, data + count, fill -= count);	347	memmove (data, data + count, fill -= count);
328	}	348	}
329		349
330	bool byte_stream::put (u8 *data, unsigned int datalen)	350	bool byte_stream::put (u8 *data, unsigned int datalen)
…		…
350	return true;	370	return true;
351	}	371	}
352		372
353	vpn_packet *byte_stream::get ()	373	vpn_packet *byte_stream::get ()
354	{	374	{
		375	unsigned int len;
		376
		377	for (;;)
		378	{
355	int len = (data [0] << 8) \| data [1];	379	len = (data [0] << 8) \| data [1];
356		380
357	if (len > MAXSIZE && fill >= 2)	381	if (len <= MAXSIZE \|\| fill < 2)
358	abort (); // TODO handle this gracefully, connection reset	382	break;
359		383
		384	// TODO: handle this better than skipping, e.g. by reset
		385	slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
		386	remove (1);
		387	}
		388
360	if (fill < len + 2)	389	if (fill < len + 2)
361	return 0;	390	return 0;
362		391
363	vpn_packet *pkt = new vpn_packet;	392	vpn_packet *pkt = new vpn_packet;
364		393
…		…
393	struct dns_cfg	422	struct dns_cfg
394	{	423	{
395	static int next_uid;	424	static int next_uid;
396		425
397	u8 id1, id2, id3, id4;	426	u8 id1, id2, id3, id4;
		427
398	u8 version;	428	u8 version;
		429	u8 flags;
399	u8 rrtype;	430	u8 rrtype;
400	u8 flags;
401	u8 def_ttl;	431	u8 def_ttl;
402	u8 rcv_cdc;	432
403	u8 snd_cdc;
404	u16 max_size;
405	u16 client;	433	u16 client;
406	u16 uid; // to make request unique	434	u16 uid; // to make request unique
407		435
408	u8 reserved[8];	436	u16 max_size;
		437	u8 seq_cdc;
		438	u8 req_cdc;
		439
		440	u8 rep_cdc;
		441	u8 delay; // time in 0.01s units that the server may delay replying packets
		442	u8 r3, r4;
		443
		444	u8 r5, r6, r7, r8;
409		445
410	void reset (int clientid);	446	void reset (int clientid);
411	bool valid ();	447	bool valid ();
412	};	448	};
413		449
…		…
423	version = 1;	459	version = 1;
424		460
425	rrtype = RR_TYPE_TXT;	461	rrtype = RR_TYPE_TXT;
426	flags = 0;	462	flags = 0;
427	def_ttl = 0;	463	def_ttl = 0;
		464	seq_cdc = 26;
		465	req_cdc = 62;
428	rcv_cdc = 0;	466	rep_cdc = 0;
429	snd_cdc = 62;
430	max_size = ntohs (MAX_PKT_SIZE);	467	max_size = htons (MAX_PKT_SIZE);
431	client = ntohs (clientid);	468	client = htons (clientid);
432	uid = next_uid++;	469	uid = next_uid++;
		470	delay = 0;
433		471
434	memset (reserved, 0, 8);	472	r3 = r4 = 0;
		473	r4 = r5 = r6 = r7 = 0;
435	}	474	}
436		475
437	bool dns_cfg::valid ()	476	bool dns_cfg::valid ()
438	{	477	{
		478	// although the protocol itself allows for some configurability,
		479	// only the following encoding/decoding settings are implemented.
439	return id1 == 'G'	480	return id1 == 'G'
440	&& id2 == 'V'	481	&& id2 == 'V'
441	&& id3 == 'P'	482	&& id3 == 'P'
442	&& id4 == 'E'	483	&& id4 == 'E'
		484	&& seq_cdc == 26
		485	&& req_cdc == 62
		486	&& rep_cdc == 0
443	&& version == 1	487	&& version == 1;
444	&& flags == 0
445	&& rcv_cdc == 0
446	&& snd_cdc == 62
447	&& max_size == ntohs (MAX_PKT_SIZE);
448	}	488	}
449		489
450	struct dns_packet : net_packet	490	struct dns_packet : net_packet
451	{	491	{
452	u16 id;	492	u16 id;
453	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4	493	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
454	u16 qdcount, ancount, nscount, arcount;	494	u16 qdcount, ancount, nscount, arcount;
455		495
456	u8 data[MAXSIZE - 6 * 2];	496	u8 data [MAXSIZE - 6 * 2];
457		497
458	int decode_label (char *data, int size, int &offs);	498	int decode_label (char *data, int size, int &offs);
459	};	499	};
460		500
461	int dns_packet::decode_label (char *data, int size, int &offs)	501	int dns_packet::decode_label (char *data, int size, int &offs)
…		…
492	return data - orig;	532	return data - orig;
493	}	533	}
494		534
495	/////////////////////////////////////////////////////////////////////////////	535	/////////////////////////////////////////////////////////////////////////////
496		536
497	struct dns_snd
498	{
499	dns_packet *pkt;
500	tstamp timeout, sent;
501	int retry;
502	struct dns_connection *dns;
503	int seqno;
504
505	void gen_stream_req (int seqno, byte_stream &stream);
506	void gen_syn_req (const dns_cfg &cfg);
507
508	dns_snd (dns_connection *dns);
509	~dns_snd ();
510	};
511
512	static u16 dns_id = 12098; // TODO: should be per-vpn	537	static u16 dns_id = 0; // TODO: should be per-vpn
513		538
514	static u16 next_id ()	539	static u16 next_id ()
515	{	540	{
		541	if (!dns_id)
		542	dns_id = time (0);
		543
516	// the simplest lsfr with periodicity 65535 i could find	544	// the simplest lsfr with periodicity 65535 i could find
517	dns_id = (dns_id << 1)	545	dns_id = (dns_id << 1)
518	\| (((dns_id >> 1)	546	\| (((dns_id >> 1)
519	^ (dns_id >> 2)	547	^ (dns_id >> 2)
520	^ (dns_id >> 4)	548	^ (dns_id >> 4)
521	^ (dns_id >> 15)) & 1);	549	^ (dns_id >> 15)) & 1);
522		550
523	return dns_id;	551	return dns_id;
524	}	552	}
525		553
		554	struct dns_rcv;
		555	struct dns_snd;
		556
		557	struct dns_connection
		558	{
		559	connection *c;
		560	struct vpn *vpn;
		561
		562	dns_cfg cfg;
		563
		564	bool established;
		565
		566	tstamp last_received;
		567	tstamp last_sent;
		568	double min_latency;
		569	double poll_interval, send_interval;
		570
		571	vector<dns_rcv *> rcvpq;
		572
		573	byte_stream rcvdq; int rcvseq; int repseq;
		574	byte_stream snddq; int sndseq;
		575
		576	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
		577	void receive_rep (dns_rcv *r);
		578
		579	dns_connection (connection *c);
		580	~dns_connection ();
		581	};
		582
		583	struct dns_snd
		584	{
		585	dns_packet *pkt;
		586	tstamp timeout, sent;
		587	int retry;
		588	struct dns_connection *dns;
		589	int seqno;
		590	bool stdhdr;
		591
		592	void gen_stream_req (int seqno, byte_stream &stream);
		593	void gen_syn_req ();
		594
		595	dns_snd (dns_connection *dns);
		596	~dns_snd ();
		597	};
		598
526	dns_snd::dns_snd (dns_connection *dns)	599	dns_snd::dns_snd (dns_connection *dns)
527	: dns (dns)	600	: dns (dns)
528	{	601	{
529	timeout = 0;	602	timeout = 0;
530	retry = 0;	603	retry = 0;
531	seqno = 0;	604	seqno = 0;
532	sent = NOW;	605	sent = ev_now ();
		606	stdhdr = false;
533		607
534	pkt = new dns_packet;	608	pkt = new dns_packet;
535		609
536	pkt->id = next_id ();	610	pkt->id = next_id ();
537	}	611	}
…		…
564	}	638	}
565	}	639	}
566		640
567	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	641	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
568	{	642	{
		643	stdhdr = true;
569	this->seqno = seqno;	644	this->seqno = seqno;
570		645
571	timeout = NOW + INITIAL_TIMEOUT;	646	timeout = ev_now () + INITIAL_TIMEOUT;
572		647
573	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	648	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
574	pkt->qdcount = htons (1);	649	pkt->qdcount = htons (1);
575		650
576	int offs = 6*2;	651	int offs = 6*2;
577	int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2);	652	int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
578	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,	653	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,
579	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	654	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
580		655
581	char enc[256], *encp = enc;	656	char enc[256], *encp = enc;
582	encode_header (enc, THISNODE->id, seqno);	657	encode_header (enc, THISNODE->id, seqno);
…		…
600	encp += lbllen;	675	encp += lbllen;
601		676
602	enclen -= lbllen;	677	enclen -= lbllen;
603	}	678	}
604		679
605	append_domain (*pkt, offs, THISNODE->domain);	680	append_domain (*pkt, offs, dns->c->conf->domain);
606		681
607	(*pkt)[offs++] = 0;	682	(*pkt)[offs++] = 0;
608	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;	683	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;
609	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	684	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
610		685
611	pkt->len = offs;	686	pkt->len = offs;
612	}	687	}
613		688
614	void dns_snd::gen_syn_req (const dns_cfg &cfg)	689	void dns_snd::gen_syn_req ()
615	{	690	{
616	timeout = NOW + INITIAL_SYN_TIMEOUT;	691	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
617		692
618	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	693	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
619	pkt->qdcount = htons (1);	694	pkt->qdcount = htons (1);
620		695
621	int offs = 6*2;	696	int offs = 6 * 2;
622		697
623	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&cfg, sizeof (dns_cfg));	698	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&dns->cfg, sizeof (dns_cfg));
624		699
625	assert (elen <= MAX_LBL_SIZE);	700	assert (elen <= MAX_LBL_SIZE);
626		701
627	(*pkt)[offs] = elen;	702	(*pkt)[offs] = elen;
628	offs += elen + 1;	703	offs += elen + 1;
629	append_domain (*pkt, offs, THISNODE->domain);	704	append_domain (*pkt, offs, dns->c->conf->domain);
630		705
631	(*pkt)[offs++] = 0;	706	(*pkt)[offs++] = 0;
632	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;	707	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;
633	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	708	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
634		709
…		…
657	delete pkt;	732	delete pkt;
658	}	733	}
659		734
660	/////////////////////////////////////////////////////////////////////////////	735	/////////////////////////////////////////////////////////////////////////////
661		736
662	struct dns_connection
663	{
664	connection *c;
665	struct vpn *vpn;
666
667	dns_cfg cfg;
668
669	bool established;
670
671	tstamp last_received;
672	tstamp last_sent;
673	double poll_interval, send_interval;
674
675	vector<dns_rcv *> rcvpq;
676
677	byte_stream rcvdq; int rcvseq;
678	byte_stream snddq; int sndseq;
679
680	void time_cb (time_watcher &w); time_watcher tw;
681	void receive_rep (dns_rcv *r);
682
683	dns_connection (connection *c);
684	~dns_connection ();
685	};
686
687	dns_connection::dns_connection (connection *c)	737	dns_connection::dns_connection (connection *c)
688	: c (c)	738	: c (c)
689	, rcvdq (MAX_BACKLOG * 2)	739	, rcvdq (MAX_BACKLOG * 2)
690	, snddq (MAX_BACKLOG * 2)	740	, snddq (MAX_BACKLOG)
691	, tw (this, &dns_connection::time_cb)
692	{	741	{
		742	tw.set<dns_connection, &dns_connection::time_cb> (this);
		743
693	vpn = c->vpn;	744	vpn = c->vpn;
694		745
695	established = false;	746	established = false;
696		747
697	rcvseq = sndseq = 0;	748	rcvseq = repseq = sndseq = 0;
698		749
699	last_sent = last_received = 0;	750	last_sent = last_received = 0;
700	poll_interval = MIN_POLL_INTERVAL;	751	poll_interval = 0.5; // starting here
701	send_interval = 0.2; // starting rate	752	send_interval = 0.5; // starting rate
		753	min_latency = INITIAL_TIMEOUT;
702	}	754	}
703		755
704	dns_connection::~dns_connection ()	756	dns_connection::~dns_connection ()
705	{	757	{
706	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	758	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
…		…
711		763
712	void dns_connection::receive_rep (dns_rcv *r)	764	void dns_connection::receive_rep (dns_rcv *r)
713	{	765	{
714	if (r->datalen)	766	if (r->datalen)
715	{	767	{
716	last_received = NOW;	768	last_received = ev_now ();
717	tw.trigger ();	769	tw ();
718		770
719	poll_interval *= 0.99;	771	poll_interval = send_interval;
720	if (poll_interval > MIN_POLL_INTERVAL)
721	poll_interval = MIN_POLL_INTERVAL;
722	}	772	}
723	else	773	else
724	{	774	{
725	poll_interval *= 1.1;	775	poll_interval *= 1.5;
		776
726	if (poll_interval > MAX_POLL_INTERVAL)	777	if (poll_interval > MAX_POLL_INTERVAL)
727	poll_interval = MAX_POLL_INTERVAL;	778	poll_interval = MAX_POLL_INTERVAL;
728	}	779	}
729		780
730	rcvpq.push_back (r);	781	rcvpq.push_back (r);
…		…
733		784
734	// find next packet	785	// find next packet
735	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	786	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
736	if (SEQNO_EQ (rcvseq, (*i)->seqno))	787	if (SEQNO_EQ (rcvseq, (*i)->seqno))
737	{	788	{
		789	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
738	// enter the packet into our input stream	790	// enter the packet into our input stream
739	r = *i;	791	r = *i;
740		792
741	// remove the oldest packet, look forward, as it's oldest first	793	// remove the oldest packet, look forward, as it's oldest first
742	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	794	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
743	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	795	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
744	{	796	{
		797	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
745	delete *j;	798	delete *j;
746	rcvpq.erase (j);	799	rcvpq.erase (j);
747	break;	800	break;
748	}	801	}
749		802
750	rcvseq = (rcvseq + 1) & SEQNO_MASK;	803	rcvseq = (rcvseq + 1) & SEQNO_MASK;
751		804
752	if (!rcvdq.put (r->data, r->datalen))	805	if (!rcvdq.put (r->data, r->datalen))
		806	{
		807	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
753	abort (); // MUST never overflow, can be caused by data corruption, TODO	808	abort (); // MUST never overflow, can be caused by data corruption, TODO
		809	}
754		810
755	while (vpn_packet *pkt = rcvdq.get ())	811	while (vpn_packet *pkt = rcvdq.get ())
756	{	812	{
757	sockinfo si;	813	sockinfo si;
758	si.host = 0; si.port = 0; si.prot = PROT_DNSv4;	814	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
759		815
760	vpn->recv_vpn_packet (pkt, si);	816	vpn->recv_vpn_packet (pkt, si);
761		817
762	delete pkt;	818	delete pkt;
763	}	819	}
…		…
777	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	833	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
778		834
779	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	835	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
780	&& pkt.qdcount == htons (1))	836	&& pkt.qdcount == htons (1))
781	{	837	{
782	char qname[MAXSIZE];	838	char qname [MAXSIZE];
783	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	839	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
784		840
785	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	841	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
786	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	842	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
787		843
788	pkt.qdcount = htons (1);	844	pkt.qdcount = htons (1);
789	pkt.ancount = 0;	845	pkt.ancount = 0;
790	pkt.nscount = 0; // should be self, as other nameservers reply like this	846	pkt.nscount = 0; // should be self, as other nameservers reply like this
791	pkt.arcount = 0; // a record for self, as other nameservers reply like this	847	pkt.arcount = 0; // a record for self, as other nameservers reply like this
792		848
793	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_NXDOMAIN);	849	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_SERVFAIL);
794		850
795	int dlen = strlen (THISNODE->domain);	851	int dlen = strlen (THISNODE->domain);
796		852
797	if (qclass == RR_CLASS_IN	853	if (qclass == RR_CLASS_IN
798	&& qlen > dlen + 1	854	&& qlen > dlen + 1
799	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	855	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
800	{	856	{
801	// now generate reply	857	// now generate reply
802	pkt.ancount = htons (1); // one answer RR	858	pkt.ancount = htons (1); // one answer RR
803	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	859	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
804		860
…		…
826	if (SEQNO_EQ ((*i)->seqno, seqno))	882	if (SEQNO_EQ ((*i)->seqno, seqno))
827	{	883	{
828	// already seen that request: simply reply with the cached reply	884	// already seen that request: simply reply with the cached reply
829	dns_rcv r = i;	885	dns_rcv r = i;
830		886
831	printf ("DUPLICATE %d\n", htons (r->pkt->id));//D	887	slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno);
		888
		889	// refresh header & id, as the retry count could have changed
		890	memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE);
		891	r->pkt->id = pkt.id;
832		892
833	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	893	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
834	pkt.id = r->pkt->id;	894
835	goto duplicate_request;	895	goto duplicate_request;
836	}	896	}
837		897
838	// new packet, queue	898	// new packet, queue
839	rcv = new dns_rcv (seqno, data, datalen);	899	rcv = new dns_rcv (seqno, data, datalen);
840	dns->receive_rep (rcv);	900	dns->receive_rep (rcv);
841	}	901	}
842		902
		903	{
843	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section	904	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
844		905
845	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;	906	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
846	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type	907	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
847	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	908	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
848	pkt [offs++] = 0; pkt [offs++] = 0;	909	pkt [offs++] = 0; pkt [offs++] = 0;
849	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL	910	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
850		911
851	int rdlen_offs = offs += 2;	912	int rdlen_offs = offs += 2;
852		913
		914	if (dns)
		915	{
853	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;	916	int dlen = ntohs (dns->cfg.max_size) - offs;
		917
854	// bind doesn't compress well, so reduce further by one label length	918	// bind doesn't compress well, so reduce further by one label length
855	dlen -= qlen;	919	dlen -= qlen;
856		920
857	if (dns)	921	// only put data into in-order sequence packets, if
858	{	922	// we receive out-of-order packets we generate empty
859	while (dlen > 1 && !dns->snddq.empty ())	923	// replies
		924	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		925	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
860	{	926	{
		927	dns->repseq = seqno;
		928
		929	while (dlen > 1 && !dns->snddq.empty ())
		930	{
861	int txtlen = dlen <= 255 ? dlen - 1 : 255;	931	int txtlen = dlen <= 255 ? dlen - 1 : 255;
862		932
863	if (txtlen > dns->snddq.size ())	933	if (txtlen > dns->snddq.size ())
864	txtlen = dns->snddq.size ();	934	txtlen = dns->snddq.size ();
865		935
866	pkt[offs++] = txtlen;	936	pkt[offs++] = txtlen;
867	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	937	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
868	offs += txtlen;	938	offs += txtlen;
869	dns->snddq.remove (txtlen);	939	dns->snddq.remove (txtlen);
870		940
871	dlen -= txtlen + 1;	941	dlen -= txtlen + 1;
		942	}
872	}	943	}
873		944
874	// avoid empty TXT rdata	945	// avoid completely empty TXT rdata
875	if (offs == rdlen_offs)	946	if (offs == rdlen_offs)
876	pkt[offs++] = 0;	947	pkt[offs++] = 0;
		948
		949	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
877	}	950	}
878	else	951	else
879	{	952	{
880	// send RST	953	// send RST
881	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	954	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
882	pkt [offs++] = CMD_IP_RST;	955	pkt [offs++] = CMD_IP_RST;
883	}	956	}
884		957
885	int rdlen = offs - rdlen_offs;	958	int rdlen = offs - rdlen_offs;
886		959
887	pkt [rdlen_offs - 2] = rdlen >> 8;	960	pkt [rdlen_offs - 2] = rdlen >> 8;
888	pkt [rdlen_offs - 1] = rdlen;	961	pkt [rdlen_offs - 1] = rdlen;
889		962
890	if (dns)	963	if (dns)
891	{	964	{
892	// now update dns_rcv copy	965	// now update dns_rcv copy
893	rcv->pkt->len = offs;	966	rcv->pkt->len = offs;
894	memcpy (rcv->pkt->at (0), pkt.at (0), offs);	967	memcpy (rcv->pkt->at (0), pkt.at (0), offs);
895	}	968	}
		969	}
896		970
897	duplicate_request: ;	971	duplicate_request: ;
898	}	972	}
899	else	973	else
900	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	974	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
…		…
912	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	986	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
913	pkt [offs++] = 0; pkt [offs++] = 0;	987	pkt [offs++] = 0; pkt [offs++] = 0;
914	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	988	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
915	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	989	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
916		990
917	slog (L_INFO, _("DNS tunnel: client %d tries to connect"), client);	991	slog (L_INFO, _("DNS: client %d connects"), client);
918		992
919	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	993	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
920	pkt [offs++] = CMD_IP_REJ;	994	pkt [offs++] = CMD_IP_REJ;
921		995
922	if (0 < client && client <= conns.size ())	996	if (0 < client && client <= conns.size ())
…		…
953	i != dns_sndpq.end ();	1027	i != dns_sndpq.end ();
954	++i)	1028	++i)
955	if ((*i)->pkt->id == pkt.id)	1029	if ((*i)->pkt->id == pkt.id)
956	{	1030	{
957	dns_connection dns = (i)->dns;	1031	dns_connection dns = (i)->dns;
		1032	connection *c = dns->c;
958	int seqno = (*i)->seqno;	1033	int seqno = (*i)->seqno;
959	u8 data[MAXSIZE], *datap = data;	1034	u8 data[MAXSIZE], *datap = data;
		1035	//printf ("rcv pkt %x\n", seqno);//D
960		1036
961	if ((*i)->retry)	1037	if ((*i)->retry)
962	{	1038	{
963	dns->send_interval *= 1.01;	1039	dns->send_interval *= 1.01;
964	if (dns->send_interval < MAX_SEND_INTERVAL)	1040	if (dns->send_interval > MAX_SEND_INTERVAL)
965	dns->send_interval = MAX_SEND_INTERVAL;	1041	dns->send_interval = MAX_SEND_INTERVAL;
966	}	1042	}
967	else	1043	else
968	{	1044	{
		1045	#if 0
969	dns->send_interval *= 0.99;	1046	dns->send_interval *= 0.999;
970	if (dns->send_interval < MIN_SEND_INTERVAL)	1047	#endif
971	dns->send_interval = MIN_SEND_INTERVAL;
972
973	// the latency surely puts an upper bound on	1048	// the latency surely puts an upper bound on
974	// the minimum send interval	1049	// the minimum send interval
975	if (dns->send_interval > NOW - (*i)->sent)	1050	double latency = ev_now () - (*i)->sent;
976	dns->send_interval = NOW - (*i)->sent;	1051
		1052	if (latency < dns->min_latency)
		1053	dns->min_latency = latency;
		1054
		1055	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1056	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1057
		1058	if (dns->send_interval < conf.dns_send_interval)
		1059	dns->send_interval = conf.dns_send_interval;
977	}	1060	}
978		1061
979	delete *i;	1062	delete *i;
980	dns_sndpq.erase (i);	1063	dns_sndpq.erase (i);
981		1064
…		…
1031		1114
1032	if (ip [0] == CMD_IP_1	1115	if (ip [0] == CMD_IP_1
1033	&& ip [1] == CMD_IP_2	1116	&& ip [1] == CMD_IP_2
1034	&& ip [2] == CMD_IP_3)	1117	&& ip [2] == CMD_IP_3)
1035	{	1118	{
1036	slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]);	1119	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1037		1120
1038	if (ip [3] == CMD_IP_RST)	1121	if (ip [3] == CMD_IP_RST)
1039	{	1122	{
1040	slog (L_DEBUG, _("got tunnel RST request"));	1123	slog (L_DEBUG, _("DNS: got tunnel RST request"));
1041		1124
1042	connection *c = dns->c;
1043	delete c->dns; c->dns = 0;	1125	delete dns; c->dns = 0;
1044		1126
1045	return;	1127	return;
1046	}	1128	}
1047	else if (ip [3] == CMD_IP_SYN)	1129	else if (ip [3] == CMD_IP_SYN)
		1130	{
		1131	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1048	dns->established = true;	1132	dns->established = true;
		1133	}
		1134	else if (ip [3] == CMD_IP_REJ)
		1135	{
		1136	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
		1137	abort ();
		1138	}
1049	else	1139	else
1050	slog (L_INFO, _("got unknown meta command %02x"), ip [3]);	1140	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1051	}	1141	}
1052	else	1142	else
1053	slog (L_INFO, _("got spurious a record %d.%d.%d.%d"),	1143	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1054	ip [0], ip [1], ip [2], ip [3]);	1144	ip [0], ip [1], ip [2], ip [3]);
1055		1145
1056	return;	1146	return;
1057	}	1147	}
1058		1148
1059	int client, rseqno;	1149	int client, rseqno;
1060	decode_header (qname, client, rseqno);	1150	decode_header (qname, client, rseqno);
1061		1151
1062	if (client != THISNODE->id)	1152	if (client != THISNODE->id)
1063	{	1153	{
1064	slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring"));	1154	slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1065	datap = 0;	1155	datap = 0;
1066	}	1156	}
1067	else if (rseqno != seqno)	1157	else if (rseqno != seqno)
1068	{	1158	{
1069	slog (L_DEBUG, _("got dns tunnel response with wrong seqno, badly caching nameserver?"));	1159	slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
1070	datap = 0;	1160	datap = 0;
1071	}	1161	}
1072	}	1162	}
1073	}	1163	}
1074		1164
…		…
1079	break;	1169	break;
1080	}	1170	}
1081	}	1171	}
1082		1172
1083	void	1173	void
1084	vpn::dnsv4_ev (io_watcher &w, short revents)	1174	vpn::dnsv4_ev (ev::io &w, int revents)
1085	{	1175	{
1086	if (revents & EVENT_READ)	1176	if (revents & EV_READ)
1087	{	1177	{
1088	dns_packet *pkt = new dns_packet;	1178	dns_packet *pkt = new dns_packet;
1089	struct sockaddr_in sa;	1179	struct sockaddr_in sa;
1090	socklen_t sa_len = sizeof (sa);	1180	socklen_t sa_len = sizeof (sa);
1091		1181
1092	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);	1182	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1093		1183
1094	if (pkt->len > 0)	1184	if (pkt->len > 0)
1095	{	1185	{
1096	if (THISNODE->dns_port)	1186	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1187	dnsv4_client (*pkt);
		1188	else
1097	{	1189	{
1098	dnsv4_server (*pkt);	1190	dnsv4_server (*pkt);
1099	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);	1191	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1100	}	1192	}
1101	else
1102	dnsv4_client (*pkt);
1103		1193
1104	delete pkt;	1194	delete pkt;
1105	}	1195	}
1106	}	1196	}
1107	}	1197	}
1108		1198
1109	bool	1199	bool
1110	connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1200	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1111	{	1201	{
		1202	int client = ntohl (si.host);
		1203
		1204	assert (0 < client && client <= conns.size ());
		1205
		1206	connection *c = conns [client - 1];
		1207
1112	if (!dns)	1208	if (!c->dns)
1113	dns = new dns_connection (this);	1209	c->dns = new dns_connection (c);
1114		1210
1115	if (!dns->snddq.put (pkt))	1211	if (c->dns->snddq.put (pkt))
1116	return false;	1212	c->dns->tw ();
1117		1213
1118	dns->tw.trigger ();	1214	// always return true even if the buffer overflows
1119
1120	return true;	1215	return true;
1121	}	1216	}
1122		1217
		1218	void
		1219	connection::dnsv4_reset_connection ()
		1220	{
		1221	//delete dns; dns = 0; //TODO
		1222	}
		1223
1123	#define NEXT(w) do { if (next > (w)) next = w; } while (0)	1224	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1124		1225
1125	void	1226	void
1126	dns_connection::time_cb (time_watcher &w)	1227	dns_connection::time_cb (ev::timer &w, int revents)
1127	{	1228	{
1128	// servers have to be polled	1229	// servers have to be polled
1129	if (THISNODE->dns_port)	1230	if (THISNODE->dns_port)
1130	return;	1231	return;
1131		1232
1132	// check for timeouts and (re)transmit	1233	// check for timeouts and (re)transmit
1133	tstamp next = NOW + poll_interval;	1234	tstamp next = ev::now () + poll_interval;
1134	dns_snd *send = 0;	1235	dns_snd *send = 0;
1135		1236
1136	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1237	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1137	i != vpn->dns_sndpq.end ();	1238	i != vpn->dns_sndpq.end ();
1138	++i)	1239	++i)
1139	{	1240	{
1140	dns_snd r = i;	1241	dns_snd r = i;
1141		1242
1142	if (r->timeout <= NOW)	1243	if (r->timeout <= ev_now ())
1143	{	1244	{
1144	if (!send)	1245	if (!send)
1145	{	1246	{
1146	send = r;	1247	send = r;
1147		1248
1148	r->retry++;	1249	r->retry++;
1149	r->timeout = NOW + r->retry;	1250	r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
		1251	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
		1252
		1253	// the following code changes the query section a bit, forcing
		1254	// the forwarder to generate a new request
		1255	if (r->stdhdr)
		1256	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1150	}	1257	}
1151	}	1258	}
1152	else	1259	else
1153	NEXT (r->timeout);	1260	NEXT (r->timeout);
1154	}	1261	}
1155		1262
1156	if (last_sent + send_interval <= NOW)
1157	{
1158	if (!send)	1263	if (!send)
		1264	{
		1265	// generate a new packet, if wise
		1266
		1267	if (!established)
1159	{	1268	{
1160	// generate a new packet, if wise
1161
1162	if (!established)
1163	{
1164	if (vpn->dns_sndpq.empty ())	1269	if (vpn->dns_sndpq.empty ())
1165	{
1166	send = new dns_snd (this);
1167
1168	cfg.reset (THISNODE->id);
1169	send->gen_syn_req (cfg);
1170	}
1171	}
1172	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING)
1173	{	1270	{
1174	send = new dns_snd (this);	1271	send = new dns_snd (this);
		1272
		1273	cfg.reset (THISNODE->id);
		1274	send->gen_syn_req ();
		1275	}
		1276	}
		1277	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
		1278	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1279	{
		1280	if (last_sent + send_interval <= ev_now ())
		1281	{
		1282	//printf ("sending data request etc.\n"); //D
		1283	if (!snddq.empty () \|\| last_received + 1. > ev_now ())
		1284	{
		1285	poll_interval = send_interval;
		1286	NEXT (ev_now () + send_interval);
		1287	}
		1288
		1289	send = new dns_snd (this);
1175	send->gen_stream_req (sndseq, snddq);	1290	send->gen_stream_req (sndseq, snddq);
		1291	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1292	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1176		1293
1177	sndseq = (sndseq + 1) & SEQNO_MASK;	1294	sndseq = (sndseq + 1) & SEQNO_MASK;
1178	}	1295	}
1179		1296	else
1180	if (send)	1297	NEXT (last_sent + send_interval);
1181	vpn->dns_sndpq.push_back (send);
1182	}	1298	}
1183		1299
1184	if (send)	1300	if (send)
1185	{	1301	vpn->dns_sndpq.push_back (send);
1186	last_sent = NOW;	1302	}
1187		1303
		1304	if (send)
		1305	{
		1306	last_sent = ev_now ();
1188	sendto (vpn->dnsv4_fd,	1307	sendto (vpn->dnsv4_fd,
1189	send->pkt->at (0), send->pkt->len, 0,	1308	send->pkt->at (0), send->pkt->len, 0,
1190	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1309	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1191	}
1192	}	1310	}
1193	else
1194	NEXT (last_sent + send_interval);
1195		1311
1196	//printf ("pi %f si %f N %f (%d:%d)\n", poll_interval, send_interval, next - NOW, vpn->dns_sndpq.size (), snddq.size ());	1312	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
		1313	poll_interval, send_interval, next - ev_now (),
		1314	vpn->dns_sndpq.size (), snddq.size (),
		1315	rcvpq.size ());
1197		1316
1198	// TODO: no idea when this happens, but when next < NOW, we have a problem	1317	// TODO: no idea when this happens, but when next < ev_now (), we have a problem
		1318	// doesn't seem to happen anymore
1199	if (next < NOW + 0.0001)	1319	if (next < ev_now () + 0.001)
1200	next = NOW + 0.1;	1320	next = ev_now () + 0.1;
1201		1321
1202	w.start (next);	1322	w.start (next - ev_now ());
1203	}	1323	}
1204		1324
1205	#endif	1325	#endif
1206		1326

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.11 by pcg, Fri Mar 4 08:45:24 2005 UTC vs. Revision 1.48 by pcg, Tue Jul 28 00:42:14 2009 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.11 by pcg, Fri Mar 4 08:45:24 2005 UTC vs.
Revision 1.48 by pcg, Tue Jul 28 00:42:14 2009 UTC