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

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

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.13 by pcg, Fri Mar 4 09:48:42 2005 UTC vs. Revision 1.47 by pcg, Thu Aug 7 17:54:27 2008 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.13 by pcg, Fri Mar 4 09:48:42 2005 UTC vs.
Revision 1.47 by pcg, Thu Aug 7 17:54:27 2008 UTC