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

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.50 by root, Sun Mar 6 13:49:50 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.50 by root, Sun Mar 6 13:49:50 2011 UTC