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

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

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.16 by pcg, Fri Mar 4 19:28:17 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.16 by pcg, Fri Mar 4 19:28:17 2005 UTC vs.
Revision 1.53 by root, Tue Oct 18 10:54:17 2011 UTC