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

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

Diff Legend

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

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

Diff Legend

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