[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.54 by root, Tue Oct 18 11:07:28 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	if (fill < 2)
		403	return 0;
		404
		405	unsigned int len;
		406
		407	for (;;)
		408	{
355	int len = (data [0] << 8) \| data [1];	409	len = (data [0] << 8) \| data [1];
356		410
357	if (len > MAXSIZE && fill >= 2)	411	if (len <= MAXSIZE)
358	abort (); // TODO handle this gracefully, connection reset	412	break;
359		413
		414	// TODO: handle this better than skipping, e.g. by reset
		415	slog (L_DEBUG, _("DNS: corrupted packet (%02x %02x) stream skipping a byte..."), data [0], data [1]);
		416	remove (1);
		417	}
		418
360	if (fill < len + 2)	419	if (fill < len + 2)
361	return 0;	420	return 0;
362		421
363	vpn_packet *pkt = new vpn_packet;	422	vpn_packet *pkt = new vpn_packet;
364		423
…		…
392		451
393	struct dns_cfg	452	struct dns_cfg
394	{	453	{
395	static int next_uid;	454	static int next_uid;
396		455
		456	u8 chksum;
		457	u8 rrtype;
		458	u16 uid; // to make request unique
		459
		460	u8 version;
		461	u8 flags;
		462	u16 max_size;
		463
397	u8 id1, id2, id3, id4;	464	u8 id1, id2, id3, id4;
398	u8 version;	465
399	u8 rrtype;	466	u16 client;
400	u8 flags;
401	u8 def_ttl;	467	u8 def_ttl;
402	u8 rcv_cdc;	468	u8 r0;
403	u8 snd_cdc;
404	u16 max_size;
405	u16 client;
406	u16 uid; // to make request unique
407		469
408	u8 reserved[8];	470	u8 syn_cdc; // cdc en/decoder for syn (A?) requests
		471	u8 hdr_cdc; // cdc en/decoder for regular request headers
		472	u8 req_cdc; // cdc en/decoder for regular (ANY?) request data
		473	u8 rep_cdc; // cdc en/decoder for regular (TXT) replies, 0 == 8 bit encoding
		474
		475	u8 r1, r2, r3, r4;
409		476
410	void reset (int clientid);	477	void reset (int clientid);
411	bool valid ();	478	bool valid ();
		479	u8 get_chksum ();
412	};	480	};
413		481
414	int dns_cfg::next_uid;	482	int dns_cfg::next_uid;
415		483
		484	void
416	void dns_cfg::reset (int clientid)	485	dns_cfg::reset (int clientid)
417	{	486	{
		487	// this ID must result in some mixed-case characters in cdc26-encoding
418	id1 = 'G';	488	id1 = 'G';
419	id2 = 'V';	489	id2 = 'V';
420	id3 = 'P';	490	id3 = 'P';
421	id4 = 'E';	491	id4 = 'E';
422		492
423	version = 1;	493	version = 2;
424		494
425	rrtype = RR_TYPE_TXT;	495	rrtype = RR_TYPE_TXT;
426	flags = 0;	496	flags = 0;
427	def_ttl = 0;	497	def_ttl = 0;
428	rcv_cdc = 0;
429	snd_cdc = 62;	498	syn_cdc = 26;
		499	hdr_cdc = 36;
		500	req_cdc = conf.dns_case_preserving ? 62 : 36;
		501	rep_cdc = 0;
430	max_size = ntohs (MAX_PKT_SIZE);	502	max_size = htons (MAX_PKT_SIZE);
431	client = ntohs (clientid);	503	client = htons (clientid);
432	uid = next_uid++;	504	uid = ++next_uid;
433		505
434	memset (reserved, 0, 8);	506	r0 = r1 = r2 = r3 = r4 = 0;
435	}
436		507
		508	chksum = get_chksum ();
		509	}
		510
		511	// simple but not trivial chksum
		512	u8
		513	dns_cfg::get_chksum ()
		514	{
		515	unsigned int sum = 0xff00; // only 16 bits required
		516
		517	u8 old_chksum = chksum;
		518	chksum = 0;
		519
		520	for (unsigned int i = 0; i < sizeof (*this); ++i)
		521	sum += ((u8 )this)[i] (i + 1);
		522
		523	chksum = old_chksum;
		524
		525	return sum + (sum >> 8);
		526	}
		527
		528	bool
437	bool dns_cfg::valid ()	529	dns_cfg::valid ()
438	{	530	{
		531	// although the protocol itself allows for some configurability,
		532	// only the following encoding/decoding settings are implemented.
439	return id1 == 'G'	533	return id1 == 'G'
440	&& id2 == 'V'	534	&& id2 == 'V'
441	&& id3 == 'P'	535	&& id3 == 'P'
442	&& id4 == 'E'	536	&& id4 == 'E'
443	&& version == 1	537	&& version == 2
444	&& flags == 0
445	&& rcv_cdc == 0
446	&& snd_cdc == 62	538	&& syn_cdc == 26
447	&& max_size == ntohs (MAX_PKT_SIZE);	539	&& hdr_cdc == 36
		540	&& (req_cdc == 36 \|\| req_cdc == 62)
		541	&& rep_cdc == 0
		542	&& chksum == get_chksum ();
448	}	543	}
449		544
450	struct dns_packet : net_packet	545	struct dns_packet : net_packet
451	{	546	{
452	u16 id;	547	u16 id;
453	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4	548	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
454	u16 qdcount, ancount, nscount, arcount;	549	u16 qdcount, ancount, nscount, arcount;
455		550
456	u8 data[MAXSIZE - 6 * 2];	551	u8 data [MAXSIZE - 6 * 2];
457		552
458	int decode_label (char *data, int size, int &offs);	553	int decode_label (char *data, int size, int &offs);
459	};	554	};
460		555
		556	int
461	int dns_packet::decode_label (char *data, int size, int &offs)	557	dns_packet::decode_label (char *data, int size, int &offs)
462	{	558	{
463	char *orig = data;	559	char *orig = data;
464		560
465	memset (data, 0, size);	561	memset (data, 0, size);
466		562
…		…
492	return data - orig;	588	return data - orig;
493	}	589	}
494		590
495	/////////////////////////////////////////////////////////////////////////////	591	/////////////////////////////////////////////////////////////////////////////
496		592
497	struct dns_snd	593	static
		594	u16 next_id ()
498	{	595	{
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	596	static u16 dns_id = 0; // TODO: should be per-vpn
513		597
514	static u16 next_id ()	598	#if 1
515	{	599	if (!dns_id)
		600	dns_id = time (0);
		601
516	// the simplest lsfr with periodicity 65535 i could find	602	// the simplest lsfr with periodicity 65535 i could find
517	dns_id = (dns_id << 1)	603	dns_id = (dns_id << 1)
518	\| (((dns_id >> 1)	604	\| (((dns_id >> 1)
519	^ (dns_id >> 2)	605	^ (dns_id >> 2)
520	^ (dns_id >> 4)	606	^ (dns_id >> 4)
521	^ (dns_id >> 15)) & 1);	607	^ (dns_id >> 15)) & 1);
522		608
523	return dns_id;	609	return dns_id;
		610	#else
		611	dns_id++;//D
		612
		613	return htons (dns_id);
		614	#endif
524	}	615	}
		616
		617	struct dns_rcv;
		618	struct dns_snd;
		619
		620	struct dns_connection
		621	{
		622	connection *c;
		623	struct vpn *vpn;
		624
		625	dns_cfg cfg;
		626
		627	bool established;
		628	const basecoder *cdc;
		629
		630	tstamp last_received;
		631	tstamp last_sent;
		632	double min_latency;
		633	double poll_interval, send_interval;
		634
		635	vector<dns_rcv *> rcvpq;
		636
		637	byte_stream rcvdq; int rcvseq; int repseq;
		638	byte_stream snddq; int sndseq;
		639
		640	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
		641	void receive_rep (dns_rcv *r);
		642
		643	void reset (); // quite like tcp RST
		644	void set_cfg (); // to be called after any cfg changes
		645
		646	dns_connection (connection *c);
		647	~dns_connection ();
		648	};
		649
		650	struct dns_snd
		651	{
		652	dns_packet *pkt;
		653	tstamp timeout, sent;
		654	int retry;
		655	struct dns_connection *dns;
		656	int seqno;
		657	bool stdhdr;
		658
		659	void gen_stream_req (int seqno, byte_stream &stream);
		660	void gen_syn_req ();
		661
		662	dns_snd (dns_connection *dns);
		663	~dns_snd ();
		664	};
525		665
526	dns_snd::dns_snd (dns_connection *dns)	666	dns_snd::dns_snd (dns_connection *dns)
527	: dns (dns)	667	: dns (dns)
528	{	668	{
529	timeout = 0;	669	timeout = 0;
530	retry = 0;	670	retry = 0;
531	seqno = 0;	671	seqno = 0;
532	sent = NOW;	672	sent = ev_now ();
		673	stdhdr = false;
533		674
534	pkt = new dns_packet;	675	pkt = new dns_packet;
535		676
536	pkt->id = next_id ();	677	pkt->id = next_id ();
537	}	678	}
…		…
539	dns_snd::~dns_snd ()	680	dns_snd::~dns_snd ()
540	{	681	{
541	delete pkt;	682	delete pkt;
542	}	683	}
543		684
		685	static void
544	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	686	append_domain (dns_packet &pkt, int &offs, const char *domain)
545	{	687	{
546	// add tunnel domain	688	// add tunnel domain
547	for (;;)	689	for (;;)
548	{	690	{
549	const char *end = strchr (domain, '.');	691	const char *end = strchr (domain, '.');
…		…
562		704
563	domain = end + 1;	705	domain = end + 1;
564	}	706	}
565	}	707	}
566		708
		709	void
567	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	710	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
568	{	711	{
		712	stdhdr = true;
569	this->seqno = seqno;	713	this->seqno = seqno;
570		714
571	timeout = NOW + INITIAL_TIMEOUT;	715	timeout = ev_now () + INITIAL_TIMEOUT;
572		716
573	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	717	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
574	pkt->qdcount = htons (1);	718	pkt->qdcount = htons (1);
575		719
576	int offs = 6*2;	720	int offs = 6*2;
577	int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2);	721	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,	722	// 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	723	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
580		724
581	char enc[256], *encp = enc;	725	char enc[256], *encp = enc;
582	encode_header (enc, THISNODE->id, seqno);	726	encode_header (enc, THISNODE->id, seqno);
583		727
584	int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);	728	int datalen = dns->cdc->decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
585		729
586	if (datalen > stream.size ())	730	if (datalen > stream.size ())
587	datalen = stream.size ();	731	datalen = stream.size ();
588		732
589	int enclen = cdc62.encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;	733	int enclen = dns->cdc->encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
590	stream.remove (datalen);	734	stream.remove (datalen);
591		735
592	while (enclen)	736	while (enclen)
593	{	737	{
594	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;	738	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
…		…
600	encp += lbllen;	744	encp += lbllen;
601		745
602	enclen -= lbllen;	746	enclen -= lbllen;
603	}	747	}
604		748
605	append_domain (*pkt, offs, THISNODE->domain);	749	append_domain (*pkt, offs, dns->c->conf->domain);
606		750
607	(*pkt)[offs++] = 0;	751	(*pkt)[offs++] = 0;
608	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;	752	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;
609	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	753	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
610		754
611	pkt->len = offs;	755	pkt->len = offs;
612	}	756	}
613		757
614	void dns_snd::gen_syn_req (const dns_cfg &cfg)	758	void
		759	dns_snd::gen_syn_req ()
615	{	760	{
616	timeout = NOW + INITIAL_SYN_TIMEOUT;	761	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
617		762
618	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	763	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
619	pkt->qdcount = htons (1);	764	pkt->qdcount = htons (1);
620		765
621	int offs = 6*2;	766	int offs = 6 * 2;
622		767
623	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&cfg, sizeof (dns_cfg));	768	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&dns->cfg, sizeof (dns_cfg));
624		769
625	assert (elen <= MAX_LBL_SIZE);	770	assert (elen <= MAX_LBL_SIZE);
626		771
627	(*pkt)[offs] = elen;	772	(*pkt)[offs] = elen;
628	offs += elen + 1;	773	offs += elen + 1;
629	append_domain (*pkt, offs, THISNODE->domain);	774	append_domain (*pkt, offs, dns->c->conf->domain);
630		775
631	(*pkt)[offs++] = 0;	776	(*pkt)[offs++] = 0;
632	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;	777	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;
633	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	778	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
634		779
…		…
657	delete pkt;	802	delete pkt;
658	}	803	}
659		804
660	/////////////////////////////////////////////////////////////////////////////	805	/////////////////////////////////////////////////////////////////////////////
661		806
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)	807	dns_connection::dns_connection (connection *c)
688	: c (c)	808	: c (c)
689	, rcvdq (MAX_BACKLOG * 2)	809	, rcvdq (MAX_BACKLOG * 2)
690	, snddq (MAX_BACKLOG * 2)	810	, snddq (MAX_BACKLOG)
691	, tw (this, &dns_connection::time_cb)
692	{	811	{
		812	tw.set<dns_connection, &dns_connection::time_cb> (this);
		813
693	vpn = c->vpn;	814	vpn = c->vpn;
694		815
		816	reset ();
		817	}
		818
		819	dns_connection::~dns_connection ()
		820	{
		821	reset ();
		822	}
		823
		824	void
		825	dns_connection::reset ()
		826	{
		827	while (!rcvpq.empty ())
		828	{
		829	delete rcvpq.back ();
		830	rcvpq.pop_back ();
		831	}
		832
		833	for (int i = vpn->dns_sndpq.size (); i--; )
		834	if (vpn->dns_sndpq [i]->dns == this)
		835	{
		836	vpn->dns_sndpq [i] = vpn->dns_sndpq.back ();
		837	vpn->dns_sndpq.pop_back ();
		838	}
		839
695	established = false;	840	established = false;
696		841
697	rcvseq = sndseq = 0;	842	rcvseq = repseq = sndseq = 0;
698		843
699	last_sent = last_received = 0;	844	last_sent = 0;
700	poll_interval = MIN_POLL_INTERVAL;	845	poll_interval = 0.5; // starting here
701	send_interval = 0.2; // starting rate	846	send_interval = 0.5; // starting rate
		847	min_latency = INITIAL_TIMEOUT;
702	}	848	}
703		849
704	dns_connection::~dns_connection ()	850	void
		851	dns_connection::set_cfg ()
705	{	852	{
706	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	853	cdc = cfg.req_cdc == 36 ? &cdc36 : &cdc62;
707	i != rcvpq.end ();
708	++i)
709	delete *i;
710	}	854	}
711		855
		856	void
712	void dns_connection::receive_rep (dns_rcv *r)	857	dns_connection::receive_rep (dns_rcv *r)
713	{	858	{
714	if (r->datalen)	859	if (r->datalen)
715	{	860	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	861	else
724	{	862	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		863
730	rcvpq.push_back (r);	864	rcvpq.push_back (r);
731		865
732	redo:	866	redo:
733		867
734	// find next packet	868	// find next packet
735	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	869	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
736	if (SEQNO_EQ (rcvseq, (*i)->seqno))	870	if (SEQNO_EQ (rcvseq, (*i)->seqno))
737	{	871	{
		872	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
738	// enter the packet into our input stream	873	// enter the packet into our input stream
739	r = *i;	874	r = *i;
740		875
741	// remove the oldest packet, look forward, as it's oldest first	876	// remove the oldest packet, look forward, as it's oldest first
742	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	877	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
743	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	878	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
744	{	879	{
		880	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
745	delete *j;	881	delete *j;
746	rcvpq.erase (j);	882	rcvpq.erase (j);
747	break;	883	break;
748	}	884	}
749		885
750	rcvseq = (rcvseq + 1) & SEQNO_MASK;	886	rcvseq = (rcvseq + 1) & SEQNO_MASK;
751		887
752	if (!rcvdq.put (r->data, r->datalen))	888	if (!rcvdq.put (r->data, r->datalen))
		889	{
753	abort (); // MUST never overflow, can be caused by data corruption, TODO	890	// MUST never overflow, can be caused by data corruption, TODO
		891	slog (L_CRIT, "DNS: !rcvdq.put (r->data, r->datalen)");
		892	reset ();
		893	return;
		894	}
754		895
755	while (vpn_packet *pkt = rcvdq.get ())	896	while (vpn_packet *pkt = rcvdq.get ())
756	{	897	{
757	sockinfo si;	898	sockinfo si;
758	si.host = 0; si.port = 0; si.prot = PROT_DNSv4;	899	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
759		900
760	vpn->recv_vpn_packet (pkt, si);	901	vpn->recv_vpn_packet (pkt, si);
761
762	delete pkt;	902	delete pkt;
763	}	903	}
764		904
765	// check for further packets	905	// check for further packets
766	goto redo;	906	goto redo;
…		…
777	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	917	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
778		918
779	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	919	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
780	&& pkt.qdcount == htons (1))	920	&& pkt.qdcount == htons (1))
781	{	921	{
782	char qname[MAXSIZE];	922	char qname [MAXSIZE];
783	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	923	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
784		924
785	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	925	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
786	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	926	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
787		927
788	pkt.qdcount = htons (1);	928	pkt.qdcount = htons (1);
789	pkt.ancount = 0;	929	pkt.ancount = 0;
790	pkt.nscount = 0; // should be self, as other nameservers reply like this	930	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	931	pkt.arcount = 0; // a record for self, as other nameservers reply like this
792		932
793	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_NXDOMAIN);	933	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_SERVFAIL);
794		934
795	int dlen = strlen (THISNODE->domain);	935	int dlen = strlen (THISNODE->domain);
796		936
797	if (qclass == RR_CLASS_IN	937	if (qclass == RR_CLASS_IN
798	&& qlen > dlen + 1	938	&& qlen > dlen + 1
799	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	939	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
800	{	940	{
801	// now generate reply	941	// now generate reply
802	pkt.ancount = htons (1); // one answer RR	942	pkt.ancount = htons (1); // one answer RR
803	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	943	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
804		944
…		…
809	{	949	{
810	// correct class, domain: parse	950	// correct class, domain: parse
811	int client, seqno;	951	int client, seqno;
812	decode_header (qname, client, seqno);	952	decode_header (qname, client, seqno);
813		953
814	u8 data[MAXSIZE];
815	int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
816
817	if (0 < client && client <= conns.size ())	954	if (0 < client && client <= conns.size ())
818	{	955	{
819	connection *c = conns [client - 1];	956	connection *c = conns [client - 1];
820	dns_connection *dns = c->dns;	957	dns_connection *dns = c->dns;
821	dns_rcv *rcv;	958	dns_rcv *rcv;
822		959
823	if (dns)	960	if (dns)
824	{	961	{
		962	u8 data[MAXSIZE];
		963	int datalen = dns->cdc->decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
		964
825	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )	965	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
826	if (SEQNO_EQ ((*i)->seqno, seqno))	966	if (SEQNO_EQ ((*i)->seqno, seqno))
827	{	967	{
828	// already seen that request: simply reply with the cached reply	968	// already seen that request: simply reply with the cached reply
829	dns_rcv r = i;	969	dns_rcv r = i;
830		970
831	printf ("DUPLICATE %d\n", htons (r->pkt->id));//D	971	slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno);
		972
		973	// refresh header & id, as the retry count could have changed
		974	memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE);
		975	r->pkt->id = pkt.id;
832		976
833	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	977	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
834	pkt.id = r->pkt->id;	978
835	goto duplicate_request;	979	goto duplicate_request;
836	}	980	}
837		981
838	// new packet, queue	982	// new packet, queue
839	rcv = new dns_rcv (seqno, data, datalen);	983	rcv = new dns_rcv (seqno, data, datalen);
840	dns->receive_rep (rcv);	984	dns->receive_rep (rcv);
841	}	985	}
842		986
		987	{
843	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section	988	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
844		989
845	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;	990	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
846	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type	991	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
847	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	992	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
848	pkt [offs++] = 0; pkt [offs++] = 0;	993	pkt [offs++] = 0; pkt [offs++] = 0;
849	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL	994	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
850		995
851	int rdlen_offs = offs += 2;	996	int rdlen_offs = offs += 2;
852		997
		998	if (dns)
		999	{
853	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;	1000	int dlen = ntohs (dns->cfg.max_size) - offs;
		1001
854	// bind doesn't compress well, so reduce further by one label length	1002	// bind doesn't compress well, so reduce further by one label length
855	dlen -= qlen;	1003	dlen -= qlen;
856		1004
857	if (dns)	1005	// only put data into in-order sequence packets, if
858	{	1006	// we receive out-of-order packets we generate empty
859	while (dlen > 1 && !dns->snddq.empty ())	1007	// replies
		1008	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		1009	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
860	{	1010	{
		1011	dns->repseq = seqno;
		1012
		1013	while (dlen > 1 && !dns->snddq.empty ())
		1014	{
861	int txtlen = dlen <= 255 ? dlen - 1 : 255;	1015	int txtlen = dlen <= 255 ? dlen - 1 : 255;
862		1016
863	if (txtlen > dns->snddq.size ())	1017	if (txtlen > dns->snddq.size ())
864	txtlen = dns->snddq.size ();	1018	txtlen = dns->snddq.size ();
865		1019
866	pkt[offs++] = txtlen;	1020	pkt[offs++] = txtlen;
867	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	1021	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
868	offs += txtlen;	1022	offs += txtlen;
869	dns->snddq.remove (txtlen);	1023	dns->snddq.remove (txtlen);
870		1024
871	dlen -= txtlen + 1;	1025	dlen -= txtlen + 1;
		1026	}
872	}	1027	}
873		1028
874	// avoid empty TXT rdata	1029	// avoid completely empty TXT rdata
875	if (offs == rdlen_offs)	1030	if (offs == rdlen_offs)
876	pkt[offs++] = 0;	1031	pkt[offs++] = 0;
		1032
		1033	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
877	}	1034	}
878	else	1035	else
879	{	1036	{
880	// send RST	1037	// send RST
881	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	1038	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
882	pkt [offs++] = CMD_IP_RST;	1039	pkt [offs++] = CMD_IP_RST;
883	}	1040	}
884		1041
885	int rdlen = offs - rdlen_offs;	1042	int rdlen = offs - rdlen_offs;
886		1043
887	pkt [rdlen_offs - 2] = rdlen >> 8;	1044	pkt [rdlen_offs - 2] = rdlen >> 8;
888	pkt [rdlen_offs - 1] = rdlen;	1045	pkt [rdlen_offs - 1] = rdlen;
889		1046
890	if (dns)	1047	if (dns)
891	{	1048	{
892	// now update dns_rcv copy	1049	// now update dns_rcv copy
893	rcv->pkt->len = offs;	1050	rcv->pkt->len = offs;
894	memcpy (rcv->pkt->at (0), pkt.at (0), offs);	1051	memcpy (rcv->pkt->at (0), pkt.at (0), offs);
895	}	1052	}
		1053	}
896		1054
897	duplicate_request: ;	1055	duplicate_request: ;
898	}	1056	}
899	else	1057	else
900	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	1058	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
…		…
912	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	1070	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
913	pkt [offs++] = 0; pkt [offs++] = 0;	1071	pkt [offs++] = 0; pkt [offs++] = 0;
914	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	1072	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
915	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	1073	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
916		1074
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;	1075	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
920	pkt [offs++] = CMD_IP_REJ;	1076	pkt [offs++] = CMD_IP_REJ;
921		1077
922	if (0 < client && client <= conns.size ())	1078	if (0 < client && client <= conns.size ())
923	{	1079	{
924	connection *c = conns [client - 1];	1080	connection *c = conns [client - 1];
925		1081
926	if (cfg.valid ())	1082	if (cfg.valid ())
927	{	1083	{
928	pkt [offs - 1] = CMD_IP_SYN;	1084	slog (L_INFO, _("DNS: client %d connects (version %d, req_cdc %d)"), client, cfg.version, cfg.req_cdc);
		1085
		1086	// check for any encoding mismatches - hints at a case problem
		1087	char qname2 [MAX_ENC_LEN];
		1088	cdc26.encode (qname2, (u8 *)&cfg, sizeof (dns_cfg));
929		1089
930	delete c->dns;	1090	delete c->dns;
		1091
		1092	pkt [offs - 1] = memcmp (qname, qname2, cdc26.encode_len (sizeof (dns_cfg)))
		1093	? CMD_IP_CSE : CMD_IP_SYN;
		1094
931	c->dns = new dns_connection (c);	1095	c->dns = new dns_connection (c);
932	c->dns->cfg = cfg;	1096	c->dns->cfg = cfg;
		1097	c->dns->set_cfg ();
933	}	1098	}
934	}	1099	}
935	}	1100	}
936	}	1101	}
937		1102
…		…
953	i != dns_sndpq.end ();	1118	i != dns_sndpq.end ();
954	++i)	1119	++i)
955	if ((*i)->pkt->id == pkt.id)	1120	if ((*i)->pkt->id == pkt.id)
956	{	1121	{
957	dns_connection dns = (i)->dns;	1122	dns_connection dns = (i)->dns;
		1123	connection *c = dns->c;
958	int seqno = (*i)->seqno;	1124	int seqno = (*i)->seqno;
959	u8 data[MAXSIZE], *datap = data;	1125	u8 data[MAXSIZE], *datap = data;
		1126	//printf ("rcv pkt %x\n", seqno);//D
960		1127
961	if ((*i)->retry)	1128	if ((*i)->retry)
962	{	1129	{
963	dns->send_interval *= 1.01;	1130	dns->send_interval *= 1.01;
964	if (dns->send_interval < MAX_SEND_INTERVAL)	1131	if (dns->send_interval > MAX_SEND_INTERVAL)
965	dns->send_interval = MAX_SEND_INTERVAL;	1132	dns->send_interval = MAX_SEND_INTERVAL;
966	}	1133	}
967	else	1134	else
968	{	1135	{
		1136	#if 0
969	dns->send_interval *= 0.99;	1137	dns->send_interval *= 0.999;
970	if (dns->send_interval < MIN_SEND_INTERVAL)	1138	#endif
971	dns->send_interval = MIN_SEND_INTERVAL;
972
973	// the latency surely puts an upper bound on	1139	// the latency surely puts an upper bound on
974	// the minimum send interval	1140	// the minimum send interval
975	if (dns->send_interval > NOW - (*i)->sent)	1141	double latency = ev_now () - (*i)->sent;
976	dns->send_interval = NOW - (*i)->sent;	1142
		1143	if (latency < dns->min_latency)
		1144	dns->min_latency = latency;
		1145
		1146	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1147	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1148
		1149	if (dns->send_interval < conf.dns_send_interval)
		1150	dns->send_interval = conf.dns_send_interval;
977	}	1151	}
978		1152
979	delete *i;	1153	delete *i;
980	dns_sndpq.erase (i);	1154	dns_sndpq.erase (i);
981		1155
…		…
999	ttl \|= pkt [offs++] << 16;	1173	ttl \|= pkt [offs++] << 16;
1000	ttl \|= pkt [offs++] << 8;	1174	ttl \|= pkt [offs++] << 8;
1001	ttl \|= pkt [offs++];	1175	ttl \|= pkt [offs++];
1002	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];	1176	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];
1003		1177
1004	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT)	1178	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT \|\| qtype == dns->cfg.rrtype)
1005	{	1179	{
1006	if (rdlen <= MAXSIZE - offs)	1180	if (rdlen <= MAXSIZE - offs)
1007	{	1181	{
1008	// decode bytes, finally	1182	// decode bytes, finally
1009		1183
…		…
1031		1205
1032	if (ip [0] == CMD_IP_1	1206	if (ip [0] == CMD_IP_1
1033	&& ip [1] == CMD_IP_2	1207	&& ip [1] == CMD_IP_2
1034	&& ip [2] == CMD_IP_3)	1208	&& ip [2] == CMD_IP_3)
1035	{	1209	{
1036	slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]);	1210	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1037		1211
1038	if (ip [3] == CMD_IP_RST)	1212	if (ip [3] == CMD_IP_RST)
1039	{	1213	{
1040	slog (L_DEBUG, _("got tunnel RST request"));	1214	slog (L_DEBUG, _("DNS: got tunnel RST request."));
1041		1215
1042	connection *c = dns->c;	1216	dns->reset ();
1043	delete c->dns; c->dns = 0;
1044
1045	return;	1217	return;
1046	}	1218	}
1047	else if (ip [3] == CMD_IP_SYN)	1219	else if (ip [3] == CMD_IP_SYN)
		1220	{
		1221	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1048	dns->established = true;	1222	dns->established = true;
		1223	}
		1224	else if (ip [3] == CMD_IP_CSE)
		1225	{
		1226	if (conf.dns_case_preserving)
		1227	{
		1228	slog (L_INFO, _("DNS: got tunnel CSE reply, globally downgrading to case-insensitive protocol."));
		1229	conf.dns_case_preserving = false;
		1230	dns->reset ();
		1231	return;
		1232	}
		1233	else
		1234	{
		1235	slog (L_DEBUG, _("DNS: got tunnel CSE reply, server likes us."));
		1236	dns->established = true;
		1237	}
		1238	}
		1239	else if (ip [3] == CMD_IP_REJ)
		1240	{
		1241	slog (L_ERR, _("DNS: got tunnel REJ reply, server does not like us."));
		1242	dns->tw.start (60.);
		1243	}
1049	else	1244	else
		1245	{
1050	slog (L_INFO, _("got unknown meta command %02x"), ip [3]);	1246	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
		1247	dns->tw.start (60.);
		1248	}
1051	}	1249	}
1052	else	1250	else
1053	slog (L_INFO, _("got spurious a record %d.%d.%d.%d"),	1251	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1054	ip [0], ip [1], ip [2], ip [3]);	1252	ip [0], ip [1], ip [2], ip [3]);
1055		1253
1056	return;	1254	return;
1057	}	1255	}
1058		1256
1059	int client, rseqno;	1257	int client, rseqno;
1060	decode_header (qname, client, rseqno);	1258	decode_header (qname, client, rseqno);
1061		1259
1062	if (client != THISNODE->id)	1260	if (client != THISNODE->id)
1063	{	1261	{
1064	slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring"));	1262	slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1065	datap = 0;	1263	datap = 0;
1066	}	1264	}
1067	else if (rseqno != seqno)	1265	else if (rseqno != seqno)
1068	{	1266	{
1069	slog (L_DEBUG, _("got dns tunnel response with wrong seqno, badly caching nameserver?"));	1267	slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
1070	datap = 0;	1268	datap = 0;
1071	}	1269	}
1072	}	1270	}
1073	}	1271	}
1074		1272
…		…
1079	break;	1277	break;
1080	}	1278	}
1081	}	1279	}
1082		1280
1083	void	1281	void
1084	vpn::dnsv4_ev (io_watcher &w, short revents)	1282	vpn::dnsv4_ev (ev::io &w, int revents)
1085	{	1283	{
1086	if (revents & EVENT_READ)	1284	if (revents & EV_READ)
1087	{	1285	{
1088	dns_packet *pkt = new dns_packet;	1286	dns_packet *pkt = new dns_packet;
1089	struct sockaddr_in sa;	1287	struct sockaddr_in sa;
1090	socklen_t sa_len = sizeof (sa);	1288	socklen_t sa_len = sizeof (sa);
1091		1289
1092	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);	1290	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1093		1291
1094	if (pkt->len > 0)	1292	if (pkt->len > 0)
1095	{	1293	{
1096	if (THISNODE->dns_port)	1294	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1295	dnsv4_client (*pkt);
		1296	else
1097	{	1297	{
1098	dnsv4_server (*pkt);	1298	dnsv4_server (*pkt);
1099	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);	1299	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1100	}	1300	}
1101	else
1102	dnsv4_client (*pkt);
1103		1301
1104	delete pkt;	1302	delete pkt;
1105	}	1303	}
1106	}	1304	}
1107	}	1305	}
1108		1306
1109	bool	1307	bool
1110	connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1308	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1111	{	1309	{
		1310	int client = ntohl (si.host);
		1311
		1312	assert (0 < client && client <= conns.size ());
		1313
		1314	connection *c = conns [client - 1];
		1315
1112	if (!dns)	1316	if (!c->dns)
1113	dns = new dns_connection (this);	1317	c->dns = new dns_connection (c);
1114		1318
1115	if (!dns->snddq.put (pkt))	1319	if (c->dns->snddq.put (pkt))
1116	return false;	1320	{
		1321	min_it (c->dns->poll_interval, 0.25);
		1322	c->dns->tw ();
		1323	}
1117		1324
1118	dns->tw.trigger ();	1325	// always return true even if the buffer overflows
1119
1120	return true;	1326	return true;
1121	}	1327	}
1122		1328
1123	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1124
1125	void	1329	void
1126	dns_connection::time_cb (time_watcher &w)	1330	dns_connection::time_cb (ev::timer &w, int revents)
1127	{	1331	{
1128	// servers have to be polled	1332	// servers have to be polled
1129	if (THISNODE->dns_port)	1333	if (THISNODE->dns_port)
1130	return;	1334	return;
1131		1335
1132	// check for timeouts and (re)transmit	1336	// check for timeouts and (re)transmit
1133	tstamp next = NOW + poll_interval;	1337	tstamp next = 86400 * 365;
1134	dns_snd *send = 0;	1338	dns_snd *send = 0;
1135		1339
1136	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1340	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1137	i != vpn->dns_sndpq.end ();	1341	i != vpn->dns_sndpq.end ();
1138	++i)	1342	++i)
1139	{	1343	{
1140	dns_snd r = i;	1344	dns_snd r = i;
1141		1345
1142	if (r->timeout <= NOW)	1346	if (r->timeout <= ev_now ())
1143	{	1347	{
1144	if (!send)	1348	if (!send)
1145	{	1349	{
1146	send = r;	1350	send = r;
1147		1351
1148	r->retry++;	1352	r->retry++;
1149	r->timeout = NOW + r->retry;	1353	r->timeout = ev_now () + r->retry * min_latency * conf.dns_timeout_factor;
		1354	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
		1355
		1356	// the following code changes the query section a bit, forcing
		1357	// the forwarder to generate a new request
		1358	if (r->stdhdr)
		1359	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1150	}	1360	}
1151	}	1361	}
1152	else	1362	else
1153	NEXT (r->timeout);	1363	min_it (next, r->timeout - ev_now ());
1154	}
1155
1156	if (last_sent + send_interval <= NOW)
1157	{	1364	}
		1365
1158	if (!send)	1366	if (!send)
		1367	{
		1368	// generate a new packet, if wise
		1369
		1370	if (!established)
1159	{	1371	{
1160	// generate a new packet, if wise
1161
1162	if (!established)
1163	{
1164	if (vpn->dns_sndpq.empty ())	1372	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	{	1373	{
1174	send = new dns_snd (this);	1374	send = new dns_snd (this);
		1375
		1376	cfg.reset (THISNODE->id);
		1377	set_cfg ();
		1378	send->gen_syn_req ();
		1379	}
		1380	}
		1381	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
		1382	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1383	{
		1384	if (last_sent + send_interval <= ev_now ())
		1385	{
		1386	//printf ("sending data request etc.\n"); //D
		1387	if (!snddq.empty ())
		1388	min_it (next, send_interval);
		1389
		1390	send = new dns_snd (this);
1175	send->gen_stream_req (sndseq, snddq);	1391	send->gen_stream_req (sndseq, snddq);
		1392	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1393	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1176		1394
1177	sndseq = (sndseq + 1) & SEQNO_MASK;	1395	sndseq = (sndseq + 1) & SEQNO_MASK;
1178	}	1396	}
1179		1397	else
1180	if (send)	1398	min_it (next, last_sent + send_interval - ev_now ());
1181	vpn->dns_sndpq.push_back (send);
1182	}	1399	}
1183		1400
1184	if (send)	1401	if (send)
1185	{	1402	vpn->dns_sndpq.push_back (send);
1186	last_sent = NOW;	1403	}
1187		1404
		1405	if (send)
		1406	{
		1407	last_sent = ev_now ();
1188	sendto (vpn->dnsv4_fd,	1408	sendto (vpn->dnsv4_fd,
1189	send->pkt->at (0), send->pkt->len, 0,	1409	send->pkt->at (0), send->pkt->len, 0,
1190	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1410	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1191	}
1192	}	1411	}
1193	else
1194	NEXT (last_sent + send_interval);
1195		1412
1196	//printf ("pi %f si %f N %f (%d:%d)\n", poll_interval, send_interval, next - NOW, vpn->dns_sndpq.size (), snddq.size ());	1413	min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ());
1197		1414
1198	// TODO: no idea when this happens, but when next < NOW, we have a problem	1415	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1199	if (next < NOW + 0.0001)	1416	poll_interval, send_interval, next - ev_now (),
1200	next = NOW + 0.1;	1417	vpn->dns_sndpq.size (), snddq.size (),
		1418	rcvpq.size ());
1201		1419
1202	w.start (next);	1420	w.start (next);
1203	}	1421	}
1204		1422
1205	#endif	1423	#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.54 by root, Tue Oct 18 11:07:28 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.54 by root, Tue Oct 18 11:07:28 2011 UTC