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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.17 by pcg, Sat Mar 5 03:47:05 2005 UTC vs.
Revision 1.50 by root, Sun Mar 6 13:49:50 2011 UTC

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

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.17 by pcg, Sat Mar 5 03:47:05 2005 UTC vs. Revision 1.50 by root, Sun Mar 6 13:49:50 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.17 by pcg, Sat Mar 5 03:47:05 2005 UTC vs.
Revision 1.50 by root, Sun Mar 6 13:49:50 2011 UTC