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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.11 by pcg, Fri Mar 4 08:45:24 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 .2 // how often to poll minimally when the server is having 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.	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
53	#define INITIAL_SYN_TIMEOUT 2.	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54		69
55	#define MIN_SEND_INTERVAL 0.001
56	#define MAX_SEND_INTERVAL 0.5 // optimistic?	70	#define MAX_SEND_INTERVAL 5. // optimistic?
57		71
58	#define MAX_OUTSTANDING 400 // max. outstanding requests
59	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
60	#define MAX_BACKLOG (100*1024) // size of protocol backlog, must be > MAXSIZE	73	#define MAX_BACKLOG (64*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
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 byte sless 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	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 *= 0.99;
720	if (poll_interval > MIN_POLL_INTERVAL)
721	poll_interval = MIN_POLL_INTERVAL;
722	}
723	else	858	else
724	{	859	poll_interval = min (poll_interval * 1.1, MAX_POLL_INTERVAL);
725	poll_interval *= 1.1;
726	if (poll_interval > MAX_POLL_INTERVAL)
727	poll_interval = MAX_POLL_INTERVAL;
728	}
729		860
730	rcvpq.push_back (r);	861	rcvpq.push_back (r);
731		862
732	redo:	863	redo:
733		864
734	// find next packet	865	// find next packet
735	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	866	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
736	if (SEQNO_EQ (rcvseq, (*i)->seqno))	867	if (SEQNO_EQ (rcvseq, (*i)->seqno))
737	{	868	{
		869	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
738	// enter the packet into our input stream	870	// enter the packet into our input stream
739	r = *i;	871	r = *i;
740		872
741	// remove the oldest packet, look forward, as it's oldest first	873	// remove the oldest packet, look forward, as it's oldest first
742	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)
743	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	875	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
744	{	876	{
		877	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
745	delete *j;	878	delete *j;
746	rcvpq.erase (j);	879	rcvpq.erase (j);
747	break;	880	break;
748	}	881	}
749		882
750	rcvseq = (rcvseq + 1) & SEQNO_MASK;	883	rcvseq = (rcvseq + 1) & SEQNO_MASK;
751		884
752	if (!rcvdq.put (r->data, r->datalen))	885	if (!rcvdq.put (r->data, r->datalen))
		886	{
753	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	}
754		892
755	while (vpn_packet *pkt = rcvdq.get ())	893	while (vpn_packet *pkt = rcvdq.get ())
756	{	894	{
757	sockinfo si;	895	sockinfo si;
758	si.host = 0; si.port = 0; si.prot = PROT_DNSv4;	896	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
759		897
760	vpn->recv_vpn_packet (pkt, si);	898	vpn->recv_vpn_packet (pkt, si);
761
762	delete pkt;	899	delete pkt;
763	}	900	}
764		901
765	// check for further packets	902	// check for further packets
766	goto redo;	903	goto redo;
…		…
777	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	914	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
778		915
779	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	916	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
780	&& pkt.qdcount == htons (1))	917	&& pkt.qdcount == htons (1))
781	{	918	{
782	char qname[MAXSIZE];	919	char qname [MAXSIZE];
783	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	920	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
784		921
785	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	922	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
786	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	923	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
787		924
788	pkt.qdcount = htons (1);	925	pkt.qdcount = htons (1);
789	pkt.ancount = 0;	926	pkt.ancount = 0;
790	pkt.nscount = 0; // should be self, as other nameservers reply like this	927	pkt.nscount = 0; // should be self, as other nameservers reply like this
791	pkt.arcount = 0; // a record for self, as other nameservers reply like this	928	pkt.arcount = 0; // a record for self, as other nameservers reply like this
792		929
793	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_NXDOMAIN);	930	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_SERVFAIL);
794		931
795	int dlen = strlen (THISNODE->domain);	932	int dlen = strlen (THISNODE->domain);
796		933
797	if (qclass == RR_CLASS_IN	934	if (qclass == RR_CLASS_IN
798	&& qlen > dlen + 1	935	&& qlen > dlen + 1
799	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	936	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
800	{	937	{
801	// now generate reply	938	// now generate reply
802	pkt.ancount = htons (1); // one answer RR	939	pkt.ancount = htons (1); // one answer RR
803	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	940	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
804		941
…		…
809	{	946	{
810	// correct class, domain: parse	947	// correct class, domain: parse
811	int client, seqno;	948	int client, seqno;
812	decode_header (qname, client, seqno);	949	decode_header (qname, client, seqno);
813		950
814	u8 data[MAXSIZE];
815	int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
816
817	if (0 < client && client <= conns.size ())	951	if (0 < client && client <= conns.size ())
818	{	952	{
819	connection *c = conns [client - 1];	953	connection *c = conns [client - 1];
820	dns_connection *dns = c->dns;	954	dns_connection *dns = c->dns;
821	dns_rcv *rcv;	955	dns_rcv *rcv;
822		956
823	if (dns)	957	if (dns)
824	{	958	{
		959	u8 data[MAXSIZE];
		960	int datalen = dns->cdc->decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
		961
825	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 (); )
826	if (SEQNO_EQ ((*i)->seqno, seqno))	963	if (SEQNO_EQ ((*i)->seqno, seqno))
827	{	964	{
828	// already seen that request: simply reply with the cached reply	965	// already seen that request: simply reply with the cached reply
829	dns_rcv r = i;	966	dns_rcv r = i;
830		967
831	printf ("DUPLICATE %d\n", htons (r->pkt->id));//D	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;
832		973
833	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);
834	pkt.id = r->pkt->id;	975
835	goto duplicate_request;	976	goto duplicate_request;
836	}	977	}
837		978
838	// new packet, queue	979	// new packet, queue
839	rcv = new dns_rcv (seqno, data, datalen);	980	rcv = new dns_rcv (seqno, data, datalen);
840	dns->receive_rep (rcv);	981	dns->receive_rep (rcv);
841	}	982	}
842		983
		984	{
843	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
844		986
845	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;	987	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
846	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type	988	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
847	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
848	pkt [offs++] = 0; pkt [offs++] = 0;	990	pkt [offs++] = 0; pkt [offs++] = 0;
849	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
850		992
851	int rdlen_offs = offs += 2;	993	int rdlen_offs = offs += 2;
852		994
		995	if (dns)
		996	{
853	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;	997	int dlen = ntohs (dns->cfg.max_size) - offs;
		998
854	// 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
855	dlen -= qlen;	1000	dlen -= qlen;
856		1001
857	if (dns)	1002	// only put data into in-order sequence packets, if
858	{	1003	// we receive out-of-order packets we generate empty
859	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)
860	{	1007	{
		1008	dns->repseq = seqno;
		1009
		1010	while (dlen > 1 && !dns->snddq.empty ())
		1011	{
861	int txtlen = dlen <= 255 ? dlen - 1 : 255;	1012	int txtlen = dlen <= 255 ? dlen - 1 : 255;
862		1013
863	if (txtlen > dns->snddq.size ())	1014	if (txtlen > dns->snddq.size ())
864	txtlen = dns->snddq.size ();	1015	txtlen = dns->snddq.size ();
865		1016
866	pkt[offs++] = txtlen;	1017	pkt[offs++] = txtlen;
867	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	1018	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
868	offs += txtlen;	1019	offs += txtlen;
869	dns->snddq.remove (txtlen);	1020	dns->snddq.remove (txtlen);
870		1021
871	dlen -= txtlen + 1;	1022	dlen -= txtlen + 1;
		1023	}
872	}	1024	}
873		1025
874	// avoid empty TXT rdata	1026	// avoid completely empty TXT rdata
875	if (offs == rdlen_offs)	1027	if (offs == rdlen_offs)
876	pkt[offs++] = 0;	1028	pkt[offs++] = 0;
		1029
		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
…		…
953	i != dns_sndpq.end ();	1115	i != dns_sndpq.end ();
954	++i)	1116	++i)
955	if ((*i)->pkt->id == pkt.id)	1117	if ((*i)->pkt->id == pkt.id)
956	{	1118	{
957	dns_connection dns = (i)->dns;	1119	dns_connection dns = (i)->dns;
		1120	connection *c = dns->c;
958	int seqno = (*i)->seqno;	1121	int seqno = (*i)->seqno;
959	u8 data[MAXSIZE], *datap = data;	1122	u8 data[MAXSIZE], *datap = data;
		1123	//printf ("rcv pkt %x\n", seqno);//D
960		1124
961	if ((*i)->retry)	1125	if ((*i)->retry)
962	{	1126	{
963	dns->send_interval *= 1.01;	1127	dns->send_interval *= 1.01;
964	if (dns->send_interval < MAX_SEND_INTERVAL)	1128	if (dns->send_interval > MAX_SEND_INTERVAL)
965	dns->send_interval = MAX_SEND_INTERVAL;	1129	dns->send_interval = MAX_SEND_INTERVAL;
966	}	1130	}
967	else	1131	else
968	{	1132	{
		1133	#if 0
969	dns->send_interval *= 0.99;	1134	dns->send_interval *= 0.999;
970	if (dns->send_interval < MIN_SEND_INTERVAL)	1135	#endif
971	dns->send_interval = MIN_SEND_INTERVAL;
972
973	// the latency surely puts an upper bound on	1136	// the latency surely puts an upper bound on
974	// the minimum send interval	1137	// the minimum send interval
975	if (dns->send_interval > NOW - (*i)->sent)	1138	double latency = ev_now () - (*i)->sent;
976	dns->send_interval = NOW - (*i)->sent;	1139
		1140	if (latency < dns->min_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;
977	}	1148	}
978		1149
979	delete *i;	1150	delete *i;
980	dns_sndpq.erase (i);	1151	dns_sndpq.erase (i);
981		1152
…		…
999	ttl \|= pkt [offs++] << 16;	1170	ttl \|= pkt [offs++] << 16;
1000	ttl \|= pkt [offs++] << 8;	1171	ttl \|= pkt [offs++] << 8;
1001	ttl \|= pkt [offs++];	1172	ttl \|= pkt [offs++];
1002	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];	1173	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];
1003		1174
1004	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT)	1175	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT \|\| qtype == dns->cfg.rrtype)
1005	{	1176	{
1006	if (rdlen <= MAXSIZE - offs)	1177	if (rdlen <= MAXSIZE - offs)
1007	{	1178	{
1008	// decode bytes, finally	1179	// decode bytes, finally
1009		1180
…		…
1031		1202
1032	if (ip [0] == CMD_IP_1	1203	if (ip [0] == CMD_IP_1
1033	&& ip [1] == CMD_IP_2	1204	&& ip [1] == CMD_IP_2
1034	&& ip [2] == CMD_IP_3)	1205	&& ip [2] == CMD_IP_3)
1035	{	1206	{
1036	slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]);	1207	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1037		1208
1038	if (ip [3] == CMD_IP_RST)	1209	if (ip [3] == CMD_IP_RST)
1039	{	1210	{
1040	slog (L_DEBUG, _("got tunnel RST request"));	1211	slog (L_DEBUG, _("DNS: got tunnel RST request."));
1041		1212
1042	connection *c = dns->c;	1213	dns->reset ();
1043	delete c->dns; c->dns = 0;
1044
1045	return;	1214	return;
1046	}	1215	}
1047	else if (ip [3] == CMD_IP_SYN)	1216	else if (ip [3] == CMD_IP_SYN)
		1217	{
		1218	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1048	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	}
		1235	}
		1236	else if (ip [3] == CMD_IP_REJ)
		1237	{
		1238	slog (L_ERR, _("DNS: got tunnel REJ reply, server does not like us."));
		1239	dns->tw.start (60.);
		1240	}
1049	else	1241	else
		1242	{
1050	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	}
1051	}	1246	}
1052	else	1247	else
1053	slog (L_INFO, _("got spurious a record %d.%d.%d.%d"),	1248	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1054	ip [0], ip [1], ip [2], ip [3]);	1249	ip [0], ip [1], ip [2], ip [3]);
1055		1250
1056	return;	1251	return;
1057	}	1252	}
1058		1253
1059	int client, rseqno;	1254	int client, rseqno;
1060	decode_header (qname, client, rseqno);	1255	decode_header (qname, client, rseqno);
1061		1256
1062	if (client != THISNODE->id)	1257	if (client != THISNODE->id)
1063	{	1258	{
1064	slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring"));	1259	slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1065	datap = 0;	1260	datap = 0;
1066	}	1261	}
1067	else if (rseqno != seqno)	1262	else if (rseqno != seqno)
1068	{	1263	{
1069	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?"));
1070	datap = 0;	1265	datap = 0;
1071	}	1266	}
1072	}	1267	}
1073	}	1268	}
1074		1269
…		…
1079	break;	1274	break;
1080	}	1275	}
1081	}	1276	}
1082		1277
1083	void	1278	void
1084	vpn::dnsv4_ev (io_watcher &w, short revents)	1279	vpn::dnsv4_ev (ev::io &w, int revents)
1085	{	1280	{
1086	if (revents & EVENT_READ)	1281	if (revents & EV_READ)
1087	{	1282	{
1088	dns_packet *pkt = new dns_packet;	1283	dns_packet *pkt = new dns_packet;
1089	struct sockaddr_in sa;	1284	struct sockaddr_in sa;
1090	socklen_t sa_len = sizeof (sa);	1285	socklen_t sa_len = sizeof (sa);
1091		1286
1092	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);
1093		1288
1094	if (pkt->len > 0)	1289	if (pkt->len > 0)
1095	{	1290	{
1096	if (THISNODE->dns_port)	1291	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1292	dnsv4_client (*pkt);
		1293	else
1097	{	1294	{
1098	dnsv4_server (*pkt);	1295	dnsv4_server (*pkt);
1099	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);
1100	}	1297	}
1101	else
1102	dnsv4_client (*pkt);
1103		1298
1104	delete pkt;	1299	delete pkt;
1105	}	1300	}
1106	}	1301	}
1107	}	1302	}
1108		1303
1109	bool	1304	bool
1110	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)
1111	{	1306	{
		1307	int client = ntohl (si.host);
		1308
		1309	assert (0 < client && client <= conns.size ());
		1310
		1311	connection *c = conns [client - 1];
		1312
1112	if (!dns)	1313	if (!c->dns)
1113	dns = new dns_connection (this);	1314	c->dns = new dns_connection (c);
1114		1315
1115	if (!dns->snddq.put (pkt))	1316	if (c->dns->snddq.put (pkt))
1116	return false;	1317	{
		1318	min_it (c->dns->poll_interval, 0.25);
		1319	c->dns->tw ();
		1320	}
1117		1321
1118	dns->tw.trigger ();	1322	// always return true even if the buffer overflows
1119
1120	return true;	1323	return true;
1121	}	1324	}
1122		1325
1123	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1124
1125	void	1326	void
1126	dns_connection::time_cb (time_watcher &w)	1327	dns_connection::time_cb (ev::timer &w, int revents)
1127	{	1328	{
1128	// servers have to be polled	1329	// servers have to be polled
1129	if (THISNODE->dns_port)	1330	if (THISNODE->dns_port)
1130	return;	1331	return;
1131		1332
1132	// check for timeouts and (re)transmit	1333	// check for timeouts and (re)transmit
1133	tstamp next = NOW + poll_interval;	1334	tstamp next = 86400 * 365;
1134	dns_snd *send = 0;	1335	dns_snd *send = 0;
1135		1336
1136	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1337	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1137	i != vpn->dns_sndpq.end ();	1338	i != vpn->dns_sndpq.end ();
1138	++i)	1339	++i)
1139	{	1340	{
1140	dns_snd r = i;	1341	dns_snd r = i;
1141		1342
1142	if (r->timeout <= NOW)	1343	if (r->timeout <= ev_now ())
1143	{	1344	{
1144	if (!send)	1345	if (!send)
1145	{	1346	{
1146	send = r;	1347	send = r;
1147		1348
1148	r->retry++;	1349	r->retry++;
1149	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);
1150	}	1357	}
1151	}	1358	}
1152	else	1359	else
1153	NEXT (r->timeout);	1360	min_it (next, r->timeout - ev_now ());
1154	}
1155
1156	if (last_sent + send_interval <= NOW)
1157	{	1361	}
		1362
1158	if (!send)	1363	if (!send)
		1364	{
		1365	// generate a new packet, if wise
		1366
		1367	if (!established)
1159	{	1368	{
1160	// generate a new packet, if wise
1161
1162	if (!established)
1163	{
1164	if (vpn->dns_sndpq.empty ())	1369	if (vpn->dns_sndpq.empty ())
1165	{
1166	send = new dns_snd (this);
1167
1168	cfg.reset (THISNODE->id);
1169	send->gen_syn_req (cfg);
1170	}
1171	}
1172	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING)
1173	{	1370	{
1174	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);
1175	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
1176		1391
1177	sndseq = (sndseq + 1) & SEQNO_MASK;	1392	sndseq = (sndseq + 1) & SEQNO_MASK;
1178	}	1393	}
1179		1394	else
1180	if (send)	1395	min_it (next, last_sent + send_interval - ev_now ());
1181	vpn->dns_sndpq.push_back (send);
1182	}	1396	}
1183		1397
1184	if (send)	1398	if (send)
1185	{	1399	vpn->dns_sndpq.push_back (send);
1186	last_sent = NOW;	1400	}
1187		1401
		1402	if (send)
		1403	{
		1404	last_sent = ev_now ();
1188	sendto (vpn->dnsv4_fd,	1405	sendto (vpn->dnsv4_fd,
1189	send->pkt->at (0), send->pkt->len, 0,	1406	send->pkt->at (0), send->pkt->len, 0,
1190	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1407	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1191	}
1192	}	1408	}
1193	else
1194	NEXT (last_sent + send_interval);
1195		1409
1196	//printf ("pi %f si %f N %f (%d:%d)\n", poll_interval, send_interval, next - NOW, vpn->dns_sndpq.size (), snddq.size ());	1410	min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ());
1197		1411
1198	// TODO: no idea when this happens, but when next < NOW, we have a problem	1412	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1199	if (next < NOW + 0.0001)	1413	poll_interval, send_interval, next - ev_now (),
1200	next = NOW + 0.1;	1414	vpn->dns_sndpq.size (), snddq.size (),
		1415	rcvpq.size ());
1201		1416
1202	w.start (next);	1417	w.start (next);
1203	}	1418	}
1204		1419
1205	#endif	1420	#endif

Diff Legend

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

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