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

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

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.15 by pcg, Fri Mar 4 10:15:45 2005 UTC vs. Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.15 by pcg, Fri Mar 4 10:15:45 2005 UTC vs.
Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC