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

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

Diff Legend

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

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