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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.22 by pcg, Sun Mar 6 21:47:35 2005 UTC vs.
Revision 1.53 by root, Tue Oct 18 10:54:17 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-2011 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
38	#include <unistd.h>	52	#include <unistd.h>
39	#include <fcntl.h>	53	#include <fcntl.h>
40		54
41	#include <map>	55	#include <map>
42		56
		57	#include <cstdio> /* bug in libgmp: gmp.h relies on cstdio being included */
43	#include <gmp.h>	58	#include <gmp.h>
44		59
45	#include "netcompat.h"	60	#include "netcompat.h"
46		61
47	#include "vpn.h"	62	#include "vpn.h"
48		63
49	#define MIN_POLL_INTERVAL .02 // how often to poll minimally when the server has data	64	#define MIN_POLL_INTERVAL 0.025 // poll at most this often when no data received
50	#define MAX_POLL_INTERVAL 6. // how often to poll minimally when the server has no data	65	#define MAX_POLL_INTERVAL 1. // how often to poll minimally when the server has no data
51	#define ACTIVITY_INTERVAL 5.
52		66
53	#define INITIAL_TIMEOUT 0.1 // retry timeouts	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
54	#define INITIAL_SYN_TIMEOUT 10. // retry timeout for initial syn	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
55		69
56	#define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests
57	#define MAX_SEND_INTERVAL 0.5 // optimistic?	70	#define MAX_SEND_INTERVAL 5. // optimistic?
58		71
59	#define MAX_OUTSTANDING 10 // max. outstanding requests
60	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
61	#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
62		74
63	#define MAX_DOMAIN_SIZE 220 // 255 is legal limit, but bind doesn't compress well	75	#define MAX_DOMAIN_SIZE 235 // 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 bytes less give room for one reply byte	77	// every request byte less give room for two reply bytes
66		78
67	#define SEQNO_MASK 0x3fff	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
81	#define CMD_IP_2 46	94	#define CMD_IP_2 46
82	#define CMD_IP_3 236	95	#define CMD_IP_3 236
83	#define CMD_IP_RST 29	96
84	#define CMD_IP_SYN 113	97	#define CMD_IP_RST 29 // some error, reset and retry
85	#define CMD_IP_REJ 32	98	#define CMD_IP_REJ 32 // do not want you
		99	#define CMD_IP_SYN 113 // connection established
		100	#define CMD_IP_CSE 213 // connection established, but likely case mismatch
		101
		102	static bool
		103	is_uc (char c)
		104	{
		105	return 'A' <= c && c <= 'Z';
		106	}
		107
		108	static bool
		109	is_lc (char c)
		110	{
		111	return 'a' <= c && c <= 'z';
		112	}
86		113
87	// works for cmaps up to 255 (not 256!)	114	// works for cmaps up to 255 (not 256!)
88	struct charmap	115	struct charmap
89	{	116	{
90	enum { INVALID = (u8)255 };	117	enum { INVALID = (u8)255 };
…		…
104	memset (enc, (char) 0, 256);	131	memset (enc, (char) 0, 256);
105	memset (dec, (char)INVALID, 256);	132	memset (dec, (char)INVALID, 256);
106		133
107	for (size = 0; cmap [size]; size++)	134	for (size = 0; cmap [size]; size++)
108	{	135	{
		136	char c = cmap [size];
		137
109	enc [size] = cmap [size];	138	enc [size] = c;
110	dec [(u8)enc [size]] = size;	139	dec [(u8)c] = size;
		140
		141	// allow lowercase/uppercase aliases if possible
		142	if (is_uc (c) && dec [c + ('a' - 'A')] == INVALID) dec [c + ('a' - 'A')] = size;
		143	if (is_lc (c) && dec [c - ('a' - 'A')] == INVALID) dec [c - ('a' - 'A')] = size;
111	}	144	}
112		145
113	assert (size < 256);	146	assert (size < 256);
114	}	147	}
115		148
…		…
122	{	155	{
123	charmap cmap;	156	charmap cmap;
124	unsigned int enc_len [MAX_DEC_LEN];	157	unsigned int enc_len [MAX_DEC_LEN];
125	unsigned int dec_len [MAX_ENC_LEN];	158	unsigned int dec_len [MAX_ENC_LEN];
126		159
127	unsigned int encode_len (unsigned int len);	160	unsigned int encode_len (unsigned int len) const;
128	unsigned int decode_len (unsigned int len);	161	unsigned int decode_len (unsigned int len) const;
129		162
130	unsigned int encode (char dst, u8 src, unsigned int len);	163	unsigned int encode (char dst, u8 src, unsigned int len) const;
131	unsigned int decode (u8 dst, char src, unsigned int len);	164	unsigned int decode (u8 dst, char src, unsigned int len) const;
132		165
133	basecoder (const char *cmap);	166	basecoder (const char *cmap);
134	};	167	};
135		168
136	basecoder::basecoder (const char *cmap)	169	basecoder::basecoder (const char *cmap)
…		…
155	enc_len [len] = n;	188	enc_len [len] = n;
156	dec_len [n] = len;	189	dec_len [n] = len;
157	}	190	}
158	}	191	}
159		192
		193	unsigned int
160	unsigned int basecoder::encode_len (unsigned int len)	194	basecoder::encode_len (unsigned int len) const
161	{	195	{
162	return enc_len [len];	196	return enc_len [len];
163	}	197	}
164		198
		199	unsigned int
165	unsigned int basecoder::decode_len (unsigned int len)	200	basecoder::decode_len (unsigned int len) const
166	{	201	{
167	while (len && !dec_len [len])	202	while (len && !dec_len [len])
168	--len;	203	--len;
169		204
170	return dec_len [len];	205	return dec_len [len];
171	}	206	}
172		207
		208	unsigned int
173	unsigned int basecoder::encode (char dst, u8 src, unsigned int len)	209	basecoder::encode (char dst, u8 src, unsigned int len) const
174	{	210	{
175	if (!len \|\| len > MAX_DEC_LEN)	211	if (!len \|\| len > MAX_DEC_LEN)
176	return 0;	212	return 0;
177		213
178	int elen = encode_len (len);	214	int elen = encode_len (len);
…		…
197	*dst++ = cmap.encode [dst_ [i]];	233	*dst++ = cmap.encode [dst_ [i]];
198		234
199	return elen;	235	return elen;
200	}	236	}
201		237
		238	unsigned int
202	unsigned int basecoder::decode (u8 dst, char src, unsigned int len)	239	basecoder::decode (u8 dst, char src, unsigned int len) const
203	{	240	{
204	if (!len \|\| len > MAX_ENC_LEN)	241	if (!len \|\| len > MAX_ENC_LEN)
205	return 0;	242	return 0;
206		243
207	u8 src_ [MAX_ENC_LEN];	244	u8 src_ [MAX_ENC_LEN];
…		…
256	}	293	}
257	abort ();	294	abort ();
258	}	295	}
259	#endif	296	#endif
260		297
261	//static basecoder cdc64 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI-");
262	//static basecoder cdc63 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
263	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");	298	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI"); // a-zA-Z0-9
264	//static basecoder cdc36 ("dphzr06qmjkb34tsvl81xaef92wgyo57ucni"); // unused as of yet	299	static basecoder cdc36 ("dPhZr06QmJkB34tSvL81xAeF92wGyO57uCnI"); // a-z0-9 for case-changers
265	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	300	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyOuCnI"); // a-z
266		301
267	/////////////////////////////////////////////////////////////////////////////	302	/////////////////////////////////////////////////////////////////////////////
268		303
269	#define HDRSIZE 6	304	#define HDRSIZE 5
270		305
		306	inline void
271	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)	307	encode_header (char *data, int clientid, int seqno, int retry = 0)
272	{	308	{
		309	assert (clientid < 256);
		310
273	seqno &= SEQNO_MASK;	311	seqno &= SEQNO_MASK;
274		312
275	u8 hdr[3] = {	313	u8 hdr[3] = {
		314	seqno,
		315	(seqno >> 8) \| (retry << 6),
276	clientid,	316	clientid,
277	(seqno >> 8) \| (retry << 6),
278	seqno,
279	};	317	};
280		318
281	assert (clientid < 256);
282
283	cdc26.encode (data, hdr, 3);	319	cdc36.encode (data, hdr, 3);
284	}	320	}
285		321
		322	inline void
286	inline void decode_header (char *data, int &clientid, int &seqno)	323	decode_header (char *data, int &clientid, int &seqno)
287	{	324	{
288	u8 hdr[3];	325	u8 hdr[3];
289		326
290	cdc26.decode (hdr, data, HDRSIZE);	327	cdc36.decode (hdr, data, HDRSIZE);
291		328
292	clientid = hdr[0];	329	clientid = hdr[2];
293	seqno = ((hdr[1] << 8) \| hdr[2]) & SEQNO_MASK;	330	seqno = ((hdr[1] << 8) \| hdr[0]) & SEQNO_MASK;
294	}	331	}
295		332
296	/////////////////////////////////////////////////////////////////////////////	333	/////////////////////////////////////////////////////////////////////////////
297		334
298	struct byte_stream	335	struct byte_stream
…		…
324	byte_stream::~byte_stream ()	361	byte_stream::~byte_stream ()
325	{	362	{
326	delete data;	363	delete data;
327	}	364	}
328		365
		366	void
329	void byte_stream::remove (int count)	367	byte_stream::remove (int count)
330	{	368	{
331	if (count > fill)	369	if (count > fill)
332	assert (count <= fill);	370	assert (count <= fill);
333		371
334	memmove (data, data + count, fill -= count);	372	memmove (data, data + count, fill -= count);
335	}	373	}
336		374
		375	bool
337	bool byte_stream::put (u8 *data, unsigned int datalen)	376	byte_stream::put (u8 *data, unsigned int datalen)
338	{	377	{
339	if (maxsize - fill < datalen)	378	if (maxsize - fill < datalen)
340	return false;	379	return false;
341		380
342	memcpy (this->data + fill, data, datalen); fill += datalen;	381	memcpy (this->data + fill, data, datalen); fill += datalen;
343		382
344	return true;	383	return true;
345	}	384	}
346		385
		386	bool
347	bool byte_stream::put (vpn_packet *pkt)	387	byte_stream::put (vpn_packet *pkt)
348	{	388	{
349	if (maxsize - fill < pkt->len + 2)	389	if (maxsize - fill < pkt->len + 2)
350	return false;	390	return false;
351		391
352	data [fill++] = pkt->len >> 8;	392	data [fill++] = pkt->len >> 8;
…		…
408		448
409	struct dns_cfg	449	struct dns_cfg
410	{	450	{
411	static int next_uid;	451	static int next_uid;
412		452
		453	u8 chksum;
		454	u8 rrtype;
		455	u16 uid; // to make request unique
		456
		457	u8 version;
		458	u8 flags;
		459	u16 max_size;
		460
413	u8 id1, id2, id3, id4;	461	u8 id1, id2, id3, id4;
414	u8 version;	462
415	u8 rrtype;	463	u16 client;
416	u8 flags;
417	u8 def_ttl;	464	u8 def_ttl;
418	u8 rcv_cdc;	465	u8 r0;
419	u8 snd_cdc;
420	u16 max_size;
421	u16 client;
422	u16 uid; // to make request unique
423		466
424	u8 reserved[8];	467	u8 syn_cdc; // cdc en/decoder for syn (A?) requests
		468	u8 hdr_cdc; // cdc en/decoder for regular request headers
		469	u8 req_cdc; // cdc en/decoder for regular (ANY?) request data
		470	u8 rep_cdc; // cdc en/decoder for regular (TXT) replies, 0 == 8 bit encoding
		471
		472	u8 r1, r2, r3, r4;
425		473
426	void reset (int clientid);	474	void reset (int clientid);
427	bool valid ();	475	bool valid ();
		476	u8 get_chksum ();
428	};	477	};
429		478
430	int dns_cfg::next_uid;	479	int dns_cfg::next_uid;
431		480
		481	void
432	void dns_cfg::reset (int clientid)	482	dns_cfg::reset (int clientid)
433	{	483	{
		484	// this ID must result in some mixed-case characters in cdc26-encoding
434	id1 = 'G';	485	id1 = 'G';
435	id2 = 'V';	486	id2 = 'V';
436	id3 = 'P';	487	id3 = 'P';
437	id4 = 'E';	488	id4 = 'E';
438		489
439	version = 1;	490	version = 2;
440		491
441	rrtype = RR_TYPE_TXT;	492	rrtype = RR_TYPE_TXT;
442	flags = 0;	493	flags = 0;
443	def_ttl = 1;	494	def_ttl = 0;
444	rcv_cdc = 0;
445	snd_cdc = 62;	495	syn_cdc = 26;
		496	hdr_cdc = 36;
		497	req_cdc = conf.dns_case_preserving ? 62 : 36;
		498	rep_cdc = 0;
446	max_size = ntohs (MAX_PKT_SIZE);	499	max_size = htons (MAX_PKT_SIZE);
447	client = ntohs (clientid);	500	client = htons (clientid);
448	uid = next_uid++;	501	uid = ++next_uid;
449		502
450	memset (reserved, 0, 8);	503	r0 = r1 = r2 = r3 = r4 = 0;
451	}
452		504
		505	chksum = get_chksum ();
		506	}
		507
		508	// simple but not trivial chksum
		509	u8
		510	dns_cfg::get_chksum ()
		511	{
		512	unsigned int sum = 0xff00; // only 16 bits required
		513
		514	u8 old_chksum = chksum;
		515	chksum = 0;
		516
		517	for (unsigned int i = 0; i < sizeof (*this); ++i)
		518	sum += ((u8 )this)[i] (i + 1);
		519
		520	chksum = old_chksum;
		521
		522	return sum + (sum >> 8);
		523	}
		524
		525	bool
453	bool dns_cfg::valid ()	526	dns_cfg::valid ()
454	{	527	{
		528	// although the protocol itself allows for some configurability,
		529	// only the following encoding/decoding settings are implemented.
455	return id1 == 'G'	530	return id1 == 'G'
456	&& id2 == 'V'	531	&& id2 == 'V'
457	&& id3 == 'P'	532	&& id3 == 'P'
458	&& id4 == 'E'	533	&& id4 == 'E'
459	&& version == 1	534	&& version == 2
460	&& flags == 0
461	&& rcv_cdc == 0
462	&& snd_cdc == 62	535	&& syn_cdc == 26
463	&& max_size == ntohs (MAX_PKT_SIZE);	536	&& hdr_cdc == 36
		537	&& (req_cdc == 36 \|\| req_cdc == 62)
		538	&& rep_cdc == 0
		539	&& chksum == get_chksum ();
464	}	540	}
465		541
466	struct dns_packet : net_packet	542	struct dns_packet : net_packet
467	{	543	{
468	u16 id;	544	u16 id;
469	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4	545	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
470	u16 qdcount, ancount, nscount, arcount;	546	u16 qdcount, ancount, nscount, arcount;
471		547
472	u8 data[MAXSIZE - 6 * 2];	548	u8 data [MAXSIZE - 6 * 2];
473		549
474	int decode_label (char *data, int size, int &offs);	550	int decode_label (char *data, int size, int &offs);
475	};	551	};
476		552
		553	int
477	int dns_packet::decode_label (char *data, int size, int &offs)	554	dns_packet::decode_label (char *data, int size, int &offs)
478	{	555	{
479	char *orig = data;	556	char *orig = data;
480		557
481	memset (data, 0, size);	558	memset (data, 0, size);
482		559
…		…
508	return data - orig;	585	return data - orig;
509	}	586	}
510		587
511	/////////////////////////////////////////////////////////////////////////////	588	/////////////////////////////////////////////////////////////////////////////
512		589
		590	static
		591	u16 next_id ()
		592	{
513	static u16 dns_id = 0; // TODO: should be per-vpn	593	static u16 dns_id = 0; // TODO: should be per-vpn
514		594
515	static u16 next_id ()	595	#if 1
516	{
517	if (!dns_id)	596	if (!dns_id)
518	dns_id = time (0);	597	dns_id = time (0);
519		598
520	// the simplest lsfr with periodicity 65535 i could find	599	// the simplest lsfr with periodicity 65535 i could find
521	dns_id = (dns_id << 1)	600	dns_id = (dns_id << 1)
…		…
523	^ (dns_id >> 2)	602	^ (dns_id >> 2)
524	^ (dns_id >> 4)	603	^ (dns_id >> 4)
525	^ (dns_id >> 15)) & 1);	604	^ (dns_id >> 15)) & 1);
526		605
527	return dns_id;	606	return dns_id;
		607	#else
		608	dns_id++;//D
		609
		610	return htons (dns_id);
		611	#endif
528	}	612	}
529		613
530	struct dns_rcv;	614	struct dns_rcv;
531	struct dns_snd;	615	struct dns_snd;
532		616
…		…
536	struct vpn *vpn;	620	struct vpn *vpn;
537		621
538	dns_cfg cfg;	622	dns_cfg cfg;
539		623
540	bool established;	624	bool established;
		625	const basecoder *cdc;
541		626
542	tstamp last_received;	627	tstamp last_received;
543	tstamp last_sent;	628	tstamp last_sent;
544	double last_latency;	629	double min_latency;
545	double poll_interval, send_interval;	630	double poll_interval, send_interval;
546		631
547	vector<dns_rcv *> rcvpq;	632	vector<dns_rcv *> rcvpq;
548		633
549	byte_stream rcvdq; int rcvseq;	634	byte_stream rcvdq; int rcvseq; int repseq;
550	byte_stream snddq; int sndseq;	635	byte_stream snddq; int sndseq;
551		636
552	void time_cb (time_watcher &w); time_watcher tw;	637	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
553	void receive_rep (dns_rcv *r);	638	void receive_rep (dns_rcv *r);
		639
		640	void reset (); // quite like tcp RST
		641	void set_cfg (); // to be called after any cfg changes
554		642
555	dns_connection (connection *c);	643	dns_connection (connection *c);
556	~dns_connection ();	644	~dns_connection ();
557	};	645	};
558		646
…		…
576	: dns (dns)	664	: dns (dns)
577	{	665	{
578	timeout = 0;	666	timeout = 0;
579	retry = 0;	667	retry = 0;
580	seqno = 0;	668	seqno = 0;
581	sent = NOW;	669	sent = ev_now ();
582	stdhdr = false;	670	stdhdr = false;
583		671
584	pkt = new dns_packet;	672	pkt = new dns_packet;
585		673
586	pkt->id = next_id ();	674	pkt->id = next_id ();
…		…
589	dns_snd::~dns_snd ()	677	dns_snd::~dns_snd ()
590	{	678	{
591	delete pkt;	679	delete pkt;
592	}	680	}
593		681
		682	static void
594	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	683	append_domain (dns_packet &pkt, int &offs, const char *domain)
595	{	684	{
596	// add tunnel domain	685	// add tunnel domain
597	for (;;)	686	for (;;)
598	{	687	{
599	const char *end = strchr (domain, '.');	688	const char *end = strchr (domain, '.');
…		…
612		701
613	domain = end + 1;	702	domain = end + 1;
614	}	703	}
615	}	704	}
616		705
		706	void
617	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	707	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
618	{	708	{
619	stdhdr = true;	709	stdhdr = true;
620	this->seqno = seqno;	710	this->seqno = seqno;
621		711
622	timeout = NOW + INITIAL_TIMEOUT;	712	timeout = ev_now () + INITIAL_TIMEOUT;
623		713
624	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	714	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
625	pkt->qdcount = htons (1);	715	pkt->qdcount = htons (1);
626		716
627	int offs = 6*2;	717	int offs = 6*2;
…		…
630	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	720	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
631		721
632	char enc[256], *encp = enc;	722	char enc[256], *encp = enc;
633	encode_header (enc, THISNODE->id, seqno);	723	encode_header (enc, THISNODE->id, seqno);
634		724
635	int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);	725	int datalen = dns->cdc->decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
636		726
637	if (datalen > stream.size ())	727	if (datalen > stream.size ())
638	datalen = stream.size ();	728	datalen = stream.size ();
639		729
640	int enclen = cdc62.encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;	730	int enclen = dns->cdc->encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
641	stream.remove (datalen);	731	stream.remove (datalen);
642		732
643	while (enclen)	733	while (enclen)
644	{	734	{
645	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;	735	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
…		…
660	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	750	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
661		751
662	pkt->len = offs;	752	pkt->len = offs;
663	}	753	}
664		754
		755	void
665	void dns_snd::gen_syn_req ()	756	dns_snd::gen_syn_req ()
666	{	757	{
667	timeout = NOW + INITIAL_SYN_TIMEOUT;	758	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
668		759
669	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	760	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
670	pkt->qdcount = htons (1);	761	pkt->qdcount = htons (1);
671		762
672	int offs = 6 * 2;	763	int offs = 6 * 2;
…		…
711	/////////////////////////////////////////////////////////////////////////////	802	/////////////////////////////////////////////////////////////////////////////
712		803
713	dns_connection::dns_connection (connection *c)	804	dns_connection::dns_connection (connection *c)
714	: c (c)	805	: c (c)
715	, rcvdq (MAX_BACKLOG * 2)	806	, rcvdq (MAX_BACKLOG * 2)
716	, snddq (MAX_BACKLOG * 2)	807	, snddq (MAX_BACKLOG)
717	, tw (this, &dns_connection::time_cb)
718	{	808	{
		809	tw.set<dns_connection, &dns_connection::time_cb> (this);
		810
719	vpn = c->vpn;	811	vpn = c->vpn;
720		812
		813	reset ();
		814	}
		815
		816	dns_connection::~dns_connection ()
		817	{
		818	reset ();
		819	}
		820
		821	void
		822	dns_connection::reset ()
		823	{
		824	while (!rcvpq.empty ())
		825	{
		826	delete rcvpq.back ();
		827	rcvpq.pop_back ();
		828	}
		829
		830	for (int i = vpn->dns_sndpq.size (); i--; )
		831	if (vpn->dns_sndpq [i]->dns == this)
		832	{
		833	vpn->dns_sndpq [i] = vpn->dns_sndpq.back ();
		834	vpn->dns_sndpq.pop_back ();
		835	}
		836
721	established = false;	837	established = false;
722		838
723	rcvseq = sndseq = 0;	839	rcvseq = repseq = sndseq = 0;
724		840
725	last_sent = last_received = 0;	841	last_sent = 0;
726	poll_interval = MIN_POLL_INTERVAL;	842	poll_interval = 0.5; // starting here
727	send_interval = 0.5; // starting rate	843	send_interval = 0.5; // starting rate
728	last_latency = INITIAL_TIMEOUT;	844	min_latency = INITIAL_TIMEOUT;
729	}	845	}
730		846
731	dns_connection::~dns_connection ()	847	void
		848	dns_connection::set_cfg ()
732	{	849	{
733	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	850	cdc = cfg.req_cdc == 36 ? &cdc36 : &cdc62;
734	i != rcvpq.end ();
735	++i)
736	delete *i;
737	}	851	}
738		852
		853	void
739	void dns_connection::receive_rep (dns_rcv *r)	854	dns_connection::receive_rep (dns_rcv *r)
740	{	855	{
741	if (r->datalen)	856	if (r->datalen)
742	{	857	poll_interval = max (poll_interval * (1. / 1.2), MIN_POLL_INTERVAL);
743	last_received = NOW;
744	tw.trigger ();
745
746	poll_interval = send_interval;
747	}
748	else	858	else
749	{	859	poll_interval = min (poll_interval * 1.1, MAX_POLL_INTERVAL);
750	poll_interval *= 1.5;
751	if (poll_interval > MAX_POLL_INTERVAL)
752	poll_interval = MAX_POLL_INTERVAL;
753	}
754		860
755	rcvpq.push_back (r);	861	rcvpq.push_back (r);
756		862
757	redo:	863	redo:
758		864
759	// find next packet	865	// find next packet
760	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	866	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
761	if (SEQNO_EQ (rcvseq, (*i)->seqno))	867	if (SEQNO_EQ (rcvseq, (*i)->seqno))
762	{	868	{
		869	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
763	// enter the packet into our input stream	870	// enter the packet into our input stream
764	r = *i;	871	r = *i;
765		872
766	// remove the oldest packet, look forward, as it's oldest first	873	// remove the oldest packet, look forward, as it's oldest first
767	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	874	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
768	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	875	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
769	{	876	{
		877	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
770	delete *j;	878	delete *j;
771	rcvpq.erase (j);	879	rcvpq.erase (j);
772	break;	880	break;
773	}	881	}
774		882
775	rcvseq = (rcvseq + 1) & SEQNO_MASK;	883	rcvseq = (rcvseq + 1) & SEQNO_MASK;
776		884
777	if (!rcvdq.put (r->data, r->datalen))	885	if (!rcvdq.put (r->data, r->datalen))
778	{	886	{
		887	// MUST never overflow, can be caused by data corruption, TODO
779	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");	888	slog (L_CRIT, "DNS: !rcvdq.put (r->data, r->datalen)");
780	abort (); // MUST never overflow, can be caused by data corruption, TODO	889	reset ();
		890	return;
781	}	891	}
782		892
783	while (vpn_packet *pkt = rcvdq.get ())	893	while (vpn_packet *pkt = rcvdq.get ())
784	{	894	{
785	sockinfo si;	895	sockinfo si;
786	si.host = 0x01010101; si.port = htons (c->conf->id); si.prot = PROT_DNSv4;	896	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
787		897
788	vpn->recv_vpn_packet (pkt, si);	898	vpn->recv_vpn_packet (pkt, si);
789
790	delete pkt;	899	delete pkt;
791	}	900	}
792		901
793	// check for further packets	902	// check for further packets
794	goto redo;	903	goto redo;
…		…
805	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	914	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
806		915
807	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	916	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
808	&& pkt.qdcount == htons (1))	917	&& pkt.qdcount == htons (1))
809	{	918	{
810	char qname[MAXSIZE];	919	char qname [MAXSIZE];
811	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	920	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
812		921
813	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	922	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
814	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	923	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
815		924
…		…
822		931
823	int dlen = strlen (THISNODE->domain);	932	int dlen = strlen (THISNODE->domain);
824		933
825	if (qclass == RR_CLASS_IN	934	if (qclass == RR_CLASS_IN
826	&& qlen > dlen + 1	935	&& qlen > dlen + 1
827	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	936	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
828	{	937	{
829	// now generate reply	938	// now generate reply
830	pkt.ancount = htons (1); // one answer RR	939	pkt.ancount = htons (1); // one answer RR
831	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	940	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
832		941
…		…
837	{	946	{
838	// correct class, domain: parse	947	// correct class, domain: parse
839	int client, seqno;	948	int client, seqno;
840	decode_header (qname, client, seqno);	949	decode_header (qname, client, seqno);
841		950
842	u8 data[MAXSIZE];
843	int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
844
845	if (0 < client && client <= conns.size ())	951	if (0 < client && client <= conns.size ())
846	{	952	{
847	connection *c = conns [client - 1];	953	connection *c = conns [client - 1];
848	dns_connection *dns = c->dns;	954	dns_connection *dns = c->dns;
849	dns_rcv *rcv;	955	dns_rcv *rcv;
850	bool in_seq;
851		956
852	if (dns)	957	if (dns)
853	{	958	{
		959	u8 data[MAXSIZE];
		960	int datalen = dns->cdc->decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
		961
854	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	962	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
855	if (SEQNO_EQ ((*i)->seqno, seqno))	963	if (SEQNO_EQ ((*i)->seqno, seqno))
856	{	964	{
857	// already seen that request: simply reply with the cached reply	965	// already seen that request: simply reply with the cached reply
858	dns_rcv r = i;	966	dns_rcv r = i;
…		…
866	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	974	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
867		975
868	goto duplicate_request;	976	goto duplicate_request;
869	}	977	}
870		978
871	in_seq = dns->rcvseq == seqno;
872
873	// new packet, queue	979	// new packet, queue
874	rcv = new dns_rcv (seqno, data, datalen);	980	rcv = new dns_rcv (seqno, data, datalen);
875	dns->receive_rep (rcv);	981	dns->receive_rep (rcv);
876	}	982	}
877		983
…		…
884	pkt [offs++] = 0; pkt [offs++] = 0;	990	pkt [offs++] = 0; pkt [offs++] = 0;
885	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL	991	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
886		992
887	int rdlen_offs = offs += 2;	993	int rdlen_offs = offs += 2;
888		994
889	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;
890	// bind doesn't compress well, so reduce further by one label length
891	dlen -= qlen;
892
893	if (dns)	995	if (dns)
894	{	996	{
		997	int dlen = ntohs (dns->cfg.max_size) - offs;
		998
		999	// bind doesn't compress well, so reduce further by one label length
		1000	dlen -= qlen;
		1001
895	// only put data into in-order sequence packets, if	1002	// only put data into in-order sequence packets, if
896	// we receive out-of-order packets we generate empty	1003	// we receive out-of-order packets we generate empty
897	// replies	1004	// replies
898	while (dlen > 1 && !dns->snddq.empty () && in_seq)	1005	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		1006	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
899	{	1007	{
		1008	dns->repseq = seqno;
		1009
		1010	while (dlen > 1 && !dns->snddq.empty ())
		1011	{
900	int txtlen = dlen <= 255 ? dlen - 1 : 255;	1012	int txtlen = dlen <= 255 ? dlen - 1 : 255;
901		1013
902	if (txtlen > dns->snddq.size ())	1014	if (txtlen > dns->snddq.size ())
903	txtlen = dns->snddq.size ();	1015	txtlen = dns->snddq.size ();
904		1016
905	pkt[offs++] = txtlen;	1017	pkt[offs++] = txtlen;
906	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	1018	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
907	offs += txtlen;	1019	offs += txtlen;
908	dns->snddq.remove (txtlen);	1020	dns->snddq.remove (txtlen);
909		1021
910	dlen -= txtlen + 1;	1022	dlen -= txtlen + 1;
		1023	}
911	}	1024	}
912		1025
913	// avoid empty TXT rdata	1026	// avoid completely empty TXT rdata
914	if (offs == rdlen_offs)	1027	if (offs == rdlen_offs)
915	pkt[offs++] = 0;	1028	pkt[offs++] = 0;
916		1029
917	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());	1030	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
918	}	1031	}
…		…
954	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	1067	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
955	pkt [offs++] = 0; pkt [offs++] = 0;	1068	pkt [offs++] = 0; pkt [offs++] = 0;
956	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1069	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
957	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1070	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
958		1071
959	slog (L_INFO, _("DNS: client %d tries to connect"), client);
960
961	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	1072	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
962	pkt [offs++] = CMD_IP_REJ;	1073	pkt [offs++] = CMD_IP_REJ;
963		1074
964	if (0 < client && client <= conns.size ())	1075	if (0 < client && client <= conns.size ())
965	{	1076	{
966	connection *c = conns [client - 1];	1077	connection *c = conns [client - 1];
967		1078
968	if (cfg.valid ())	1079	if (cfg.valid ())
969	{	1080	{
970	pkt [offs - 1] = CMD_IP_SYN;	1081	slog (L_INFO, _("DNS: client %d connects (version %d, req_cdc %d)"), client, cfg.version, cfg.req_cdc);
		1082
		1083	// check for any encoding mismatches - hints at a case problem
		1084	char qname2 [MAX_ENC_LEN];
		1085	cdc26.encode (qname2, (u8 *)&cfg, sizeof (dns_cfg));
971		1086
972	delete c->dns;	1087	delete c->dns;
		1088
		1089	pkt [offs - 1] = memcmp (qname, qname2, cdc26.encode_len (sizeof (dns_cfg)))
		1090	? CMD_IP_CSE : CMD_IP_SYN;
		1091
973	c->dns = new dns_connection (c);	1092	c->dns = new dns_connection (c);
974	c->dns->cfg = cfg;	1093	c->dns->cfg = cfg;
		1094	c->dns->set_cfg ();
975	}	1095	}
976	}	1096	}
977	}	1097	}
978	}	1098	}
979		1099
…		…
998	{	1118	{
999	dns_connection dns = (i)->dns;	1119	dns_connection dns = (i)->dns;
1000	connection *c = dns->c;	1120	connection *c = dns->c;
1001	int seqno = (*i)->seqno;	1121	int seqno = (*i)->seqno;
1002	u8 data[MAXSIZE], *datap = data;	1122	u8 data[MAXSIZE], *datap = data;
		1123	//printf ("rcv pkt %x\n", seqno);//D
1003		1124
1004	if ((*i)->retry)	1125	if ((*i)->retry)
1005	{	1126	{
1006	dns->send_interval *= 1.01;	1127	dns->send_interval *= 1.01;
1007	if (dns->send_interval > MAX_SEND_INTERVAL)	1128	if (dns->send_interval > MAX_SEND_INTERVAL)
1008	dns->send_interval = MAX_SEND_INTERVAL;	1129	dns->send_interval = MAX_SEND_INTERVAL;
1009	}	1130	}
1010	else	1131	else
1011	{	1132	{
1012	#if 1	1133	#if 0
1013	dns->send_interval *= 0.999;	1134	dns->send_interval *= 0.999;
1014	#endif	1135	#endif
1015	if (dns->send_interval < MIN_SEND_INTERVAL)
1016	dns->send_interval = MIN_SEND_INTERVAL;
1017
1018	// the latency surely puts an upper bound on	1136	// the latency surely puts an upper bound on
1019	// the minimum send interval	1137	// the minimum send interval
1020	double latency = NOW - (*i)->sent;	1138	double latency = ev_now () - (*i)->sent;
		1139
		1140	if (latency < dns->min_latency)
1021	dns->last_latency = latency;	1141	dns->min_latency = latency;
1022		1142
1023	if (dns->send_interval > latency)	1143	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1144	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1145
		1146	if (dns->send_interval < conf.dns_send_interval)
1024	dns->send_interval = latency;	1147	dns->send_interval = conf.dns_send_interval;
1025	}	1148	}
1026		1149
1027	delete *i;	1150	delete *i;
1028	dns_sndpq.erase (i);	1151	dns_sndpq.erase (i);
1029		1152
…		…
1047	ttl \|= pkt [offs++] << 16;	1170	ttl \|= pkt [offs++] << 16;
1048	ttl \|= pkt [offs++] << 8;	1171	ttl \|= pkt [offs++] << 8;
1049	ttl \|= pkt [offs++];	1172	ttl \|= pkt [offs++];
1050	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];	1173	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];
1051		1174
1052	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT)	1175	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT \|\| qtype == dns->cfg.rrtype)
1053	{	1176	{
1054	if (rdlen <= MAXSIZE - offs)	1177	if (rdlen <= MAXSIZE - offs)
1055	{	1178	{
1056	// decode bytes, finally	1179	// decode bytes, finally
1057		1180
…		…
1083	{	1206	{
1084	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);	1207	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1085		1208
1086	if (ip [3] == CMD_IP_RST)	1209	if (ip [3] == CMD_IP_RST)
1087	{	1210	{
1088	slog (L_DEBUG, _("DNS: got tunnel RST request"));	1211	slog (L_DEBUG, _("DNS: got tunnel RST request."));
1089		1212
1090	delete dns; c->dns = 0;	1213	dns->reset ();
1091
1092	return;	1214	return;
1093	}	1215	}
1094	else if (ip [3] == CMD_IP_SYN)	1216	else if (ip [3] == CMD_IP_SYN)
1095	{	1217	{
1096	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));	1218	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1097	dns->established = true;	1219	dns->established = true;
1098	}	1220	}
		1221	else if (ip [3] == CMD_IP_CSE)
		1222	{
		1223	if (conf.dns_case_preserving)
		1224	{
		1225	slog (L_INFO, _("DNS: got tunnel CSE reply, globally downgrading to case-insensitive protocol."));
		1226	conf.dns_case_preserving = false;
		1227	dns->reset ();
		1228	return;
		1229	}
		1230	else
		1231	{
		1232	slog (L_DEBUG, _("DNS: got tunnel CSE reply, server likes us."));
		1233	dns->established = true;
		1234	}
		1235	}
1099	else if (ip [3] == CMD_IP_REJ)	1236	else if (ip [3] == CMD_IP_REJ)
1100	{	1237	{
1101	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));	1238	slog (L_ERR, _("DNS: got tunnel REJ reply, server does not like us."));
1102	abort ();	1239	dns->tw.start (60.);
1103	}	1240	}
1104	else	1241	else
		1242	{
1105	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);	1243	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
		1244	dns->tw.start (60.);
		1245	}
1106	}	1246	}
1107	else	1247	else
1108	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),	1248	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1109	ip [0], ip [1], ip [2], ip [3]);	1249	ip [0], ip [1], ip [2], ip [3]);
1110		1250
…		…
1134	break;	1274	break;
1135	}	1275	}
1136	}	1276	}
1137		1277
1138	void	1278	void
1139	vpn::dnsv4_ev (io_watcher &w, short revents)	1279	vpn::dnsv4_ev (ev::io &w, int revents)
1140	{	1280	{
1141	if (revents & EVENT_READ)	1281	if (revents & EV_READ)
1142	{	1282	{
1143	dns_packet *pkt = new dns_packet;	1283	dns_packet *pkt = new dns_packet;
1144	struct sockaddr_in sa;	1284	struct sockaddr_in sa;
1145	socklen_t sa_len = sizeof (sa);	1285	socklen_t sa_len = sizeof (sa);
1146		1286
1147	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);	1287	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1148		1288
1149	if (pkt->len > 0)	1289	if (pkt->len > 0)
1150	{	1290	{
1151	if (THISNODE->dns_port)	1291	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1292	dnsv4_client (*pkt);
		1293	else
1152	{	1294	{
1153	dnsv4_server (*pkt);	1295	dnsv4_server (*pkt);
1154	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);	1296	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1155	}	1297	}
1156	else
1157	dnsv4_client (*pkt);
1158		1298
1159	delete pkt;	1299	delete pkt;
1160	}	1300	}
1161	}	1301	}
1162	}	1302	}
1163		1303
1164	bool	1304	bool
1165	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1305	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1166	{	1306	{
1167	int client = ntohs (si.port);	1307	int client = ntohl (si.host);
1168		1308
1169	assert (0 < client && client <= conns.size ());	1309	assert (0 < client && client <= conns.size ());
1170		1310
1171	connection *c = conns [client - 1];	1311	connection *c = conns [client - 1];
1172		1312
1173	if (!c->dns)	1313	if (!c->dns)
1174	c->dns = new dns_connection (c);	1314	c->dns = new dns_connection (c);
1175		1315
1176	if (!c->dns->snddq.put (pkt))	1316	if (c->dns->snddq.put (pkt))
1177	return false;	1317	{
		1318	min_it (c->dns->poll_interval, 0.25);
		1319	c->dns->tw ();
		1320	}
1178		1321
1179	c->dns->tw.trigger ();	1322	// always return true even if the buffer overflows
1180
1181	return true;	1323	return true;
1182	}	1324	}
1183		1325
1184	void	1326	void
1185	connection::dnsv4_reset_connection ()	1327	dns_connection::time_cb (ev::timer &w, int revents)
1186	{
1187	//delete dns; dns = 0; //TODO
1188	}
1189
1190	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1191
1192	void
1193	dns_connection::time_cb (time_watcher &w)
1194	{	1328	{
1195	// servers have to be polled	1329	// servers have to be polled
1196	if (THISNODE->dns_port)	1330	if (THISNODE->dns_port)
1197	return;	1331	return;
1198		1332
1199	// check for timeouts and (re)transmit	1333	// check for timeouts and (re)transmit
1200	tstamp next = NOW + poll_interval;	1334	tstamp next = 86400 * 365;
1201	dns_snd *send = 0;	1335	dns_snd *send = 0;
1202		1336
1203	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1337	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1204	i != vpn->dns_sndpq.end ();	1338	i != vpn->dns_sndpq.end ();
1205	++i)	1339	++i)
1206	{	1340	{
1207	dns_snd r = i;	1341	dns_snd r = i;
1208		1342
1209	if (r->timeout <= NOW)	1343	if (r->timeout <= ev_now ())
1210	{	1344	{
1211	if (!send)	1345	if (!send)
1212	{	1346	{
1213	send = r;	1347	send = r;
1214		1348
1215	r->retry++;	1349	r->retry++;
1216	r->timeout = NOW + (r->retry * last_latency * 8.);	1350	r->timeout = ev_now () + r->retry * min_latency * conf.dns_timeout_factor;
		1351	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1217		1352
1218	// the following code changes the query section a bit, forcing	1353	// the following code changes the query section a bit, forcing
1219	// the forwarder to generate a new request	1354	// the forwarder to generate a new request
1220	if (r->stdhdr)	1355	if (r->stdhdr)
1221	{
1222	//printf ("reencoded header for ID %d retry %d:%d:%d\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);printf ("reencoded header for ID %d retry %d:%d:%d\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);
1223	//encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);	1356	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1224	}
1225	}	1357	}
1226	}	1358	}
1227	else	1359	else
1228	NEXT (r->timeout);	1360	min_it (next, r->timeout - ev_now ());
1229	}
1230
1231	if (last_sent + send_interval <= NOW)
1232	{	1361	}
		1362
1233	if (!send)	1363	if (!send)
		1364	{
		1365	// generate a new packet, if wise
		1366
		1367	if (!established)
1234	{	1368	{
1235	// generate a new packet, if wise	1369	if (vpn->dns_sndpq.empty ())
1236
1237	if (!established)
1238	{	1370	{
1239	if (vpn->dns_sndpq.empty ())
1240	{
1241	send = new dns_snd (this);	1371	send = new dns_snd (this);
1242		1372
1243	printf ("new conn %p %d\n", this, c->conf->id);//D
1244	cfg.reset (THISNODE->id);	1373	cfg.reset (THISNODE->id);
		1374	set_cfg ();
1245	send->gen_syn_req ();	1375	send->gen_syn_req ();
1246	}
1247	}	1376	}
1248	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING	1377	}
		1378	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1249	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))	1379	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1380	{
		1381	if (last_sent + send_interval <= ev_now ())
1250	{	1382	{
1251	//printf ("sending data request etc.\n"); //D	1383	//printf ("sending data request etc.\n"); //D
1252	if (!snddq.empty ())	1384	if (!snddq.empty ())
1253	{
1254	poll_interval = send_interval;
1255	NEXT (NOW + send_interval);	1385	min_it (next, send_interval);
1256	}
1257		1386
1258	send = new dns_snd (this);	1387	send = new dns_snd (this);
1259	send->gen_stream_req (sndseq, snddq);	1388	send->gen_stream_req (sndseq, snddq);
1260	send->timeout = NOW + last_latency * 8.;	1389	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1390	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1261		1391
1262	sndseq = (sndseq + 1) & SEQNO_MASK;	1392	sndseq = (sndseq + 1) & SEQNO_MASK;
1263	}	1393	}
1264		1394	else
1265	if (send)	1395	min_it (next, last_sent + send_interval - ev_now ());
1266	vpn->dns_sndpq.push_back (send);
1267	}	1396	}
1268		1397
1269	if (send)	1398	if (send)
1270	{	1399	vpn->dns_sndpq.push_back (send);
1271	last_sent = NOW;	1400	}
		1401
		1402	if (send)
		1403	{
		1404	last_sent = ev_now ();
1272	sendto (vpn->dnsv4_fd,	1405	sendto (vpn->dnsv4_fd,
1273	send->pkt->at (0), send->pkt->len, 0,	1406	send->pkt->at (0), send->pkt->len, 0,
1274	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1407	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1275	}
1276	}	1408	}
1277	else
1278	NEXT (last_sent + send_interval);
1279		1409
		1410	min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ());
		1411
1280	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d)",	1412	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1281	poll_interval, send_interval, next - NOW,	1413	poll_interval, send_interval, next - ev_now (),
1282	vpn->dns_sndpq.size (), snddq.size ());	1414	vpn->dns_sndpq.size (), snddq.size (),
1283		1415	rcvpq.size ());
1284	// TODO: no idea when this happens, but when next < NOW, we have a problem
1285	if (next < NOW + 0.0001)
1286	next = NOW + 0.1;
1287		1416
1288	w.start (next);	1417	w.start (next);
1289	}	1418	}
1290		1419
1291	#endif	1420	#endif

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.22 by pcg, Sun Mar 6 21:47:35 2005 UTC vs. Revision 1.53 by root, Tue Oct 18 10:54:17 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.22 by pcg, Sun Mar 6 21:47:35 2005 UTC vs.
Revision 1.53 by root, Tue Oct 18 10:54:17 2011 UTC