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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.15 by pcg, Fri Mar 4 10:15:45 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 .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 1. // retry timeouts	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
53	#define INITIAL_SYN_TIMEOUT 2. // 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 40 // max. outstanding requests
59	#define MAX_WINDOW 100 // max. for MAX_OUTSTANDING	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 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	unsigned 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 = send_interval;	771	poll_interval = send_interval;
720	}	772	}
721	else	773	else
722	{	774	{
723	poll_interval *= 1.1;	775	poll_interval *= 1.5;
		776
724	if (poll_interval > MAX_POLL_INTERVAL)	777	if (poll_interval > MAX_POLL_INTERVAL)
725	poll_interval = MAX_POLL_INTERVAL;	778	poll_interval = MAX_POLL_INTERVAL;
726	}	779	}
727		780
728	rcvpq.push_back (r);	781	rcvpq.push_back (r);
…		…
731		784
732	// find next packet	785	// find next packet
733	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	786	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
734	if (SEQNO_EQ (rcvseq, (*i)->seqno))	787	if (SEQNO_EQ (rcvseq, (*i)->seqno))
735	{	788	{
		789	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
736	// enter the packet into our input stream	790	// enter the packet into our input stream
737	r = *i;	791	r = *i;
738		792
739	// remove the oldest packet, look forward, as it's oldest first	793	// remove the oldest packet, look forward, as it's oldest first
740	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)
741	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	795	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
742	{	796	{
		797	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
743	delete *j;	798	delete *j;
744	rcvpq.erase (j);	799	rcvpq.erase (j);
745	break;	800	break;
746	}	801	}
747		802
748	rcvseq = (rcvseq + 1) & SEQNO_MASK;	803	rcvseq = (rcvseq + 1) & SEQNO_MASK;
749		804
750	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)");
751	abort (); // MUST never overflow, can be caused by data corruption, TODO	808	abort (); // MUST never overflow, can be caused by data corruption, TODO
		809	}
752		810
753	while (vpn_packet *pkt = rcvdq.get ())	811	while (vpn_packet *pkt = rcvdq.get ())
754	{	812	{
755	sockinfo si;	813	sockinfo si;
756	si.host = 0; si.port = 0; si.prot = PROT_DNSv4;	814	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
757		815
758	vpn->recv_vpn_packet (pkt, si);	816	vpn->recv_vpn_packet (pkt, si);
759		817
760	delete pkt;	818	delete pkt;
761	}	819	}
…		…
775	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	833	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
776		834
777	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	835	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
778	&& pkt.qdcount == htons (1))	836	&& pkt.qdcount == htons (1))
779	{	837	{
780	char qname[MAXSIZE];	838	char qname [MAXSIZE];
781	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	839	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
782		840
783	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	841	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
784	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	842	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
785		843
786	pkt.qdcount = htons (1);	844	pkt.qdcount = htons (1);
787	pkt.ancount = 0;	845	pkt.ancount = 0;
788	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
789	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
790		848
791	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_NXDOMAIN);	849	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_SERVFAIL);
792		850
793	int dlen = strlen (THISNODE->domain);	851	int dlen = strlen (THISNODE->domain);
794		852
795	if (qclass == RR_CLASS_IN	853	if (qclass == RR_CLASS_IN
796	&& qlen > dlen + 1	854	&& qlen > dlen + 1
797	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	855	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
798	{	856	{
799	// now generate reply	857	// now generate reply
800	pkt.ancount = htons (1); // one answer RR	858	pkt.ancount = htons (1); // one answer RR
801	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	859	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
802		860
…		…
824	if (SEQNO_EQ ((*i)->seqno, seqno))	882	if (SEQNO_EQ ((*i)->seqno, seqno))
825	{	883	{
826	// already seen that request: simply reply with the cached reply	884	// already seen that request: simply reply with the cached reply
827	dns_rcv r = i;	885	dns_rcv r = i;
828		886
829	slog (L_DEBUG, "DUPLICATE %d\n", htons (r->pkt->id));	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;
830		892
831	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);
832	pkt.id = r->pkt->id;	894
833	goto duplicate_request;	895	goto duplicate_request;
834	}	896	}
835		897
836	// new packet, queue	898	// new packet, queue
837	rcv = new dns_rcv (seqno, data, datalen);	899	rcv = new dns_rcv (seqno, data, datalen);
838	dns->receive_rep (rcv);	900	dns->receive_rep (rcv);
839	}	901	}
840		902
		903	{
841	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
842		905
843	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;	906	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
844	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type	907	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
845	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
846	pkt [offs++] = 0; pkt [offs++] = 0;	909	pkt [offs++] = 0; pkt [offs++] = 0;
847	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
848		911
849	int rdlen_offs = offs += 2;	912	int rdlen_offs = offs += 2;
850		913
		914	if (dns)
		915	{
851	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;	916	int dlen = ntohs (dns->cfg.max_size) - offs;
		917
852	// 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
853	dlen -= qlen;	919	dlen -= qlen;
854		920
855	if (dns)	921	// only put data into in-order sequence packets, if
856	{	922	// we receive out-of-order packets we generate empty
857	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)
858	{	926	{
		927	dns->repseq = seqno;
		928
		929	while (dlen > 1 && !dns->snddq.empty ())
		930	{
859	int txtlen = dlen <= 255 ? dlen - 1 : 255;	931	int txtlen = dlen <= 255 ? dlen - 1 : 255;
860		932
861	if (txtlen > dns->snddq.size ())	933	if (txtlen > dns->snddq.size ())
862	txtlen = dns->snddq.size ();	934	txtlen = dns->snddq.size ();
863		935
864	pkt[offs++] = txtlen;	936	pkt[offs++] = txtlen;
865	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	937	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
866	offs += txtlen;	938	offs += txtlen;
867	dns->snddq.remove (txtlen);	939	dns->snddq.remove (txtlen);
868		940
869	dlen -= txtlen + 1;	941	dlen -= txtlen + 1;
		942	}
870	}	943	}
871		944
872	// avoid empty TXT rdata	945	// avoid completely empty TXT rdata
873	if (offs == rdlen_offs)	946	if (offs == rdlen_offs)
874	pkt[offs++] = 0;	947	pkt[offs++] = 0;
875		948
876	slog (L_NOISE, "snddq %d", dns->snddq.size ());	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 ())
…		…
956	{	1030	{
957	dns_connection dns = (i)->dns;	1031	dns_connection dns = (i)->dns;
958	connection *c = dns->c;	1032	connection *c = dns->c;
959	int seqno = (*i)->seqno;	1033	int seqno = (*i)->seqno;
960	u8 data[MAXSIZE], *datap = data;	1034	u8 data[MAXSIZE], *datap = data;
		1035	//printf ("rcv pkt %x\n", seqno);//D
961		1036
962	if ((*i)->retry)	1037	if ((*i)->retry)
963	{	1038	{
964	dns->send_interval *= 1.001;	1039	dns->send_interval *= 1.01;
965	if (dns->send_interval > MAX_SEND_INTERVAL)	1040	if (dns->send_interval > MAX_SEND_INTERVAL)
966	dns->send_interval = MAX_SEND_INTERVAL;	1041	dns->send_interval = MAX_SEND_INTERVAL;
967	}	1042	}
968	else	1043	else
969	{	1044	{
970	#if 1	1045	#if 0
971	dns->send_interval *= 0.9999;	1046	dns->send_interval *= 0.999;
972	#endif	1047	#endif
973	if (dns->send_interval < MIN_SEND_INTERVAL)
974	dns->send_interval = MIN_SEND_INTERVAL;
975
976	// the latency surely puts an upper bound on	1048	// the latency surely puts an upper bound on
977	// the minimum send interval	1049	// the minimum send interval
978	double latency = NOW - (*i)->sent;	1050	double latency = ev_now () - (*i)->sent;
979		1051
980	if (dns->send_interval > latency)	1052	if (latency < dns->min_latency)
981	dns->send_interval = 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;
982	}	1060	}
983		1061
984	delete *i;	1062	delete *i;
985	dns_sndpq.erase (i);	1063	dns_sndpq.erase (i);
986		1064
…		…
1036		1114
1037	if (ip [0] == CMD_IP_1	1115	if (ip [0] == CMD_IP_1
1038	&& ip [1] == CMD_IP_2	1116	&& ip [1] == CMD_IP_2
1039	&& ip [2] == CMD_IP_3)	1117	&& ip [2] == CMD_IP_3)
1040	{	1118	{
1041	slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]);	1119	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1042		1120
1043	if (ip [3] == CMD_IP_RST)	1121	if (ip [3] == CMD_IP_RST)
1044	{	1122	{
1045	slog (L_DEBUG, _("got tunnel RST request"));	1123	slog (L_DEBUG, _("DNS: got tunnel RST request"));
1046		1124
1047	delete dns; c->dns = 0;	1125	delete dns; c->dns = 0;
1048		1126
1049	return;	1127	return;
1050	}	1128	}
1051	else if (ip [3] == CMD_IP_SYN)	1129	else if (ip [3] == CMD_IP_SYN)
1052	{	1130	{
1053	slog (L_DEBUG, _("got tunnel SYN reply, server likes us."));	1131	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1054	dns->established = true;	1132	dns->established = true;
1055	}	1133	}
1056	else if (ip [3] == CMD_IP_REJ)	1134	else if (ip [3] == CMD_IP_REJ)
1057	{	1135	{
1058	slog (L_DEBUG, _("got tunnel REJ reply, server does not like us, aborting."));	1136	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
1059	abort ();	1137	abort ();
1060	}	1138	}
1061	else	1139	else
1062	slog (L_INFO, _("got unknown meta command %02x"), ip [3]);	1140	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1063	}	1141	}
1064	else	1142	else
1065	slog (L_INFO, _("got spurious a record %d.%d.%d.%d"),	1143	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1066	ip [0], ip [1], ip [2], ip [3]);	1144	ip [0], ip [1], ip [2], ip [3]);
1067		1145
1068	return;	1146	return;
1069	}	1147	}
1070		1148
1071	int client, rseqno;	1149	int client, rseqno;
1072	decode_header (qname, client, rseqno);	1150	decode_header (qname, client, rseqno);
1073		1151
1074	if (client != THISNODE->id)	1152	if (client != THISNODE->id)
1075	{	1153	{
1076	slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring"));	1154	slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1077	datap = 0;	1155	datap = 0;
1078	}	1156	}
1079	else if (rseqno != seqno)	1157	else if (rseqno != seqno)
1080	{	1158	{
1081	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?"));
1082	datap = 0;	1160	datap = 0;
1083	}	1161	}
1084	}	1162	}
1085	}	1163	}
1086		1164
…		…
1091	break;	1169	break;
1092	}	1170	}
1093	}	1171	}
1094		1172
1095	void	1173	void
1096	vpn::dnsv4_ev (io_watcher &w, short revents)	1174	vpn::dnsv4_ev (ev::io &w, int revents)
1097	{	1175	{
1098	if (revents & EVENT_READ)	1176	if (revents & EV_READ)
1099	{	1177	{
1100	dns_packet *pkt = new dns_packet;	1178	dns_packet *pkt = new dns_packet;
1101	struct sockaddr_in sa;	1179	struct sockaddr_in sa;
1102	socklen_t sa_len = sizeof (sa);	1180	socklen_t sa_len = sizeof (sa);
1103		1181
1104	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);
1105		1183
1106	if (pkt->len > 0)	1184	if (pkt->len > 0)
1107	{	1185	{
1108	if (THISNODE->dns_port)	1186	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1187	dnsv4_client (*pkt);
		1188	else
1109	{	1189	{
1110	dnsv4_server (*pkt);	1190	dnsv4_server (*pkt);
1111	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);
1112	}	1192	}
1113	else
1114	dnsv4_client (*pkt);
1115		1193
1116	delete pkt;	1194	delete pkt;
1117	}	1195	}
1118	}	1196	}
1119	}	1197	}
1120		1198
1121	bool	1199	bool
1122	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)
1123	{	1201	{
		1202	int client = ntohl (si.host);
		1203
		1204	assert (0 < client && client <= conns.size ());
		1205
		1206	connection *c = conns [client - 1];
		1207
1124	if (!dns)	1208	if (!c->dns)
1125	dns = new dns_connection (this);	1209	c->dns = new dns_connection (c);
1126		1210
1127	if (!dns->snddq.put (pkt))	1211	if (c->dns->snddq.put (pkt))
1128	return false;	1212	c->dns->tw ();
1129		1213
1130	dns->tw.trigger ();	1214	// always return true even if the buffer overflows
1131
1132	return true;	1215	return true;
1133	}	1216	}
1134		1217
1135	void	1218	void
1136	connection::dnsv4_reset_connection ()	1219	connection::dnsv4_reset_connection ()
…		…
1139	}	1222	}
1140		1223
1141	#define NEXT(w) do { if (next > (w)) next = w; } while (0)	1224	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1142		1225
1143	void	1226	void
1144	dns_connection::time_cb (time_watcher &w)	1227	dns_connection::time_cb (ev::timer &w, int revents)
1145	{	1228	{
1146	// servers have to be polled	1229	// servers have to be polled
1147	if (THISNODE->dns_port)	1230	if (THISNODE->dns_port)
1148	return;	1231	return;
1149		1232
1150	// check for timeouts and (re)transmit	1233	// check for timeouts and (re)transmit
1151	tstamp next = NOW + poll_interval;	1234	tstamp next = ev::now () + poll_interval;
1152	dns_snd *send = 0;	1235	dns_snd *send = 0;
1153		1236
1154	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1237	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1155	i != vpn->dns_sndpq.end ();	1238	i != vpn->dns_sndpq.end ();
1156	++i)	1239	++i)
1157	{	1240	{
1158	dns_snd r = i;	1241	dns_snd r = i;
1159		1242
1160	if (r->timeout <= NOW)	1243	if (r->timeout <= ev_now ())
1161	{	1244	{
1162	if (!send)	1245	if (!send)
1163	{	1246	{
1164	send = r;	1247	send = r;
1165		1248
1166	r->retry++;	1249	r->retry++;
1167	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);
1168	}	1257	}
1169	}	1258	}
1170	else	1259	else
1171	NEXT (r->timeout);	1260	NEXT (r->timeout);
1172	}	1261	}
1173		1262
1174	if (last_sent + send_interval <= NOW)
1175	{
1176	if (!send)	1263	if (!send)
		1264	{
		1265	// generate a new packet, if wise
		1266
		1267	if (!established)
1177	{	1268	{
1178	// generate a new packet, if wise
1179
1180	if (!established)
1181	{
1182	if (vpn->dns_sndpq.empty ())	1269	if (vpn->dns_sndpq.empty ())
1183	{
1184	send = new dns_snd (this);
1185
1186	cfg.reset (THISNODE->id);
1187	send->gen_syn_req (cfg);
1188	}
1189	}
1190	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING)
1191	{	1270	{
1192	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);
1193	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
1194		1293
1195	sndseq = (sndseq + 1) & SEQNO_MASK;	1294	sndseq = (sndseq + 1) & SEQNO_MASK;
1196	}	1295	}
1197		1296	else
1198	if (send)	1297	NEXT (last_sent + send_interval);
1199	vpn->dns_sndpq.push_back (send);
1200	}	1298	}
1201		1299
1202	if (send)	1300	if (send)
1203	{	1301	vpn->dns_sndpq.push_back (send);
1204	last_sent = NOW;	1302	}
		1303
		1304	if (send)
		1305	{
		1306	last_sent = ev_now ();
1205	sendto (vpn->dnsv4_fd,	1307	sendto (vpn->dnsv4_fd,
1206	send->pkt->at (0), send->pkt->len, 0,	1308	send->pkt->at (0), send->pkt->len, 0,
1207	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1309	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1208	}
1209	}	1310	}
1210	else
1211	NEXT (last_sent + send_interval);
1212		1311
1213	slog (L_NOISE, "pi %f si %f N %f (%d:%d)",	1312	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1214	poll_interval, send_interval, next - NOW,	1313	poll_interval, send_interval, next - ev_now (),
1215	vpn->dns_sndpq.size (), snddq.size ());	1314	vpn->dns_sndpq.size (), snddq.size (),
		1315	rcvpq.size ());
1216		1316
1217	// 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
1218	if (next < NOW + 0.0001)	1319	if (next < ev_now () + 0.001)
1219	next = NOW + 0.1;	1320	next = ev_now () + 0.1;
1220		1321
1221	w.start (next);	1322	w.start (next - ev_now ());
1222	}	1323	}
1223		1324
1224	#endif	1325	#endif
1225		1326

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.15 by pcg, Fri Mar 4 10:15:45 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.15 by pcg, Fri Mar 4 10:15:45 2005 UTC vs.
Revision 1.48 by pcg, Tue Jul 28 00:42:14 2009 UTC