ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/gvpe/src/vpn_dns.C

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

Diff Legend

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