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

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

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.9 by pcg, Fri Mar 4 04:52:38 2005 UTC vs. Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.9 by pcg, Fri Mar 4 04:52:38 2005 UTC vs.
Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC