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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.8 by pcg, Fri Mar 4 03:43:09 2005 UTC vs.
Revision 1.49 by root, Tue Feb 8 23:11:36 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-2008 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 MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data
49	#define MAX_RETRY 60.	65	#define ACTIVITY_INTERVAL 5.
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	#define CMD_IP_RST 29
		97	#define CMD_IP_SYN 113
		98	#define CMD_IP_REJ 32
70		99
71	// works for cmaps up to 255 (not 256!)	100	// works for cmaps up to 255 (not 256!)
72	struct charmap	101	struct charmap
73	{	102	{
74	enum { INVALID = (u8)255 };	103	enum { INVALID = (u8)255 };
…		…
139	enc_len [len] = n;	168	enc_len [len] = n;
140	dec_len [n] = len;	169	dec_len [n] = len;
141	}	170	}
142	}	171	}
143		172
		173	unsigned int
144	unsigned int basecoder::encode_len (unsigned int len)	174	basecoder::encode_len (unsigned int len)
145	{	175	{
146	return enc_len [len];	176	return enc_len [len];
147	}	177	}
148		178
		179	unsigned int
149	unsigned int basecoder::decode_len (unsigned int len)	180	basecoder::decode_len (unsigned int len)
150	{	181	{
151	while (len && !dec_len [len])	182	while (len && !dec_len [len])
152	--len;	183	--len;
153		184
154	return dec_len [len];	185	return dec_len [len];
155	}	186	}
156		187
		188	unsigned int
157	unsigned int basecoder::encode (char dst, u8 src, unsigned int len)	189	basecoder::encode (char dst, u8 src, unsigned int len)
158	{	190	{
159	if (!len)	191	if (!len \|\| len > MAX_DEC_LEN)
160	return 0;	192	return 0;
161		193
162	int elen = encode_len (len);	194	int elen = encode_len (len);
163		195
164	mp_limb_t m [MAX_LIMBS];	196	mp_limb_t m [MAX_LIMBS];
…		…
181	*dst++ = cmap.encode [dst_ [i]];	213	*dst++ = cmap.encode [dst_ [i]];
182		214
183	return elen;	215	return elen;
184	}	216	}
185		217
		218	unsigned int
186	unsigned int basecoder::decode (u8 dst, char src, unsigned int len)	219	basecoder::decode (u8 dst, char src, unsigned int len)
187	{	220	{
188	if (!len)	221	if (!len \|\| len > MAX_ENC_LEN)
189	return 0;	222	return 0;
190		223
191	u8 src_ [MAX_ENC_LEN];	224	u8 src_ [MAX_ENC_LEN];
192	unsigned int elen = 0;	225	unsigned int elen = 0;
193		226
…		…
240	}	273	}
241	abort ();	274	abort ();
242	}	275	}
243	#endif	276	#endif
244		277
245	// the following sequence has been crafted to	278	//static basecoder cdc64 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI-");
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");	279	//static basecoder cdc63 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
251	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");	280	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
252	//static basecoder cdc36 ("dphzr06qmjkb34tsvl81xaef92wgyo57ucni"); // unused as of yet	281	//static basecoder cdc36 ("dphzr06qmjkb34tsvl81xaef92wgyo57ucni"); // unused as of yet
253	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	282	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
254		283
255	/////////////////////////////////////////////////////////////////////////////	284	/////////////////////////////////////////////////////////////////////////////
256		285
257	#define HDRSIZE 6	286	#define HDRSIZE 6
258		287
		288	inline void
259	inline void encode_header (char *data, int clientid, int seqno)	289	encode_header (char *data, int clientid, int seqno, int retry = 0)
260	{	290	{
261	u8 hdr[3] = { clientid, seqno >> 8, seqno };	291	seqno &= SEQNO_MASK;
		292
		293	u8 hdr[3] = {
		294	clientid,
		295	(seqno >> 8) \| (retry << 6),
		296	seqno,
		297	};
262		298
263	assert (clientid < 256);	299	assert (clientid < 256);
264		300
265	cdc26.encode (data, hdr, 3);	301	cdc26.encode (data, hdr, 3);
266	}	302	}
267		303
		304	inline void
268	inline void decode_header (char *data, int &clientid, int &seqno)	305	decode_header (char *data, int &clientid, int &seqno)
269	{	306	{
270	u8 hdr[3];	307	u8 hdr[3];
271		308
272	cdc26.decode (hdr, data, HDRSIZE);	309	cdc26.decode (hdr, data, HDRSIZE);
273		310
274	printf ("DEC %02x %02x %02x %02x\n", hdr[0], hdr[1], hdr[2], hdr[3]);
275
276	clientid = hdr[0];	311	clientid = hdr[0];
277	seqno = (hdr[1] << 8) \| hdr[2];	312	seqno = ((hdr[1] << 8) \| hdr[2]) & SEQNO_MASK;
278	}	313	}
279		314
280	/////////////////////////////////////////////////////////////////////////////	315	/////////////////////////////////////////////////////////////////////////////
281		316
282	struct byte_stream	317	struct byte_stream
…		…
308	byte_stream::~byte_stream ()	343	byte_stream::~byte_stream ()
309	{	344	{
310	delete data;	345	delete data;
311	}	346	}
312		347
		348	void
313	void byte_stream::remove (int count)	349	byte_stream::remove (int count)
314	{	350	{
315	if (count > fill)	351	if (count > fill)
316	abort ();	352	assert (count <= fill);
317		353
318	memmove (data, data + count, fill -= count);	354	memmove (data, data + count, fill -= count);
319	}	355	}
320		356
		357	bool
321	bool byte_stream::put (u8 *data, unsigned int datalen)	358	byte_stream::put (u8 *data, unsigned int datalen)
322	{	359	{
323	if (maxsize - fill < datalen)	360	if (maxsize - fill < datalen)
324	return false;	361	return false;
325		362
326	memcpy (this->data + fill, data, datalen); fill += datalen;	363	memcpy (this->data + fill, data, datalen); fill += datalen;
327		364
328	return true;	365	return true;
329	}	366	}
330		367
		368	bool
331	bool byte_stream::put (vpn_packet *pkt)	369	byte_stream::put (vpn_packet *pkt)
332	{	370	{
333	if (maxsize - fill < pkt->len + 2)	371	if (maxsize - fill < pkt->len + 2)
334	return false;	372	return false;
335		373
336	data [fill++] = pkt->len >> 8;	374	data [fill++] = pkt->len >> 8;
337	data [fill++] = pkt->len;	375	data [fill++] = pkt->len;
338		376
339	memcpy (data + fill, &((*pkt)[0]), pkt->len); fill += pkt->len;	377	memcpy (data + fill, pkt->at (0), pkt->len); fill += pkt->len;
340		378
341	return true;	379	return true;
342	}	380	}
343		381
344	vpn_packet *byte_stream::get ()	382	vpn_packet *byte_stream::get ()
345	{	383	{
		384	unsigned int len;
		385
		386	for (;;)
		387	{
346	int len = (data [0] << 8) \| data [1];	388	len = (data [0] << 8) \| data [1];
347		389
348	if (len > MAXSIZE && fill >= 2)	390	if (len <= MAXSIZE \|\| fill < 2)
349	abort (); // TODO handle this gracefully, connection reset	391	break;
350		392
		393	// TODO: handle this better than skipping, e.g. by reset
		394	slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
		395	remove (1);
		396	}
		397
351	if (fill < len + 2)	398	if (fill < len + 2)
352	return 0;	399	return 0;
353		400
354	vpn_packet *pkt = new vpn_packet;	401	vpn_packet *pkt = new vpn_packet;
355		402
356	pkt->len = len;	403	pkt->len = len;
357	memcpy (&((*pkt)[0]), data + 2, len);	404	memcpy (pkt->at (0), data + 2, len);
358	remove (len + 2);	405	remove (len + 2);
359		406
360	return pkt;	407	return pkt;
361	}	408	}
362		409
363	/////////////////////////////////////////////////////////////////////////////	410	/////////////////////////////////////////////////////////////////////////////
364		411
365	#define FLAG_QUERY ( 0 << 15)	412	#define FLAG_QUERY ( 0 << 15)
366	#define FLAG_RESPONSE ( 1 << 15)	413	#define FLAG_RESPONSE ( 1 << 15)
367	#define FLAG_OP_MASK (15 << 14)	414	#define FLAG_OP_MASK (15 << 11)
368	#define FLAG_OP_QUERY ( 0 << 11)	415	#define FLAG_OP_QUERY ( 0 << 11)
369	#define FLAG_AA ( 1 << 10)	416	#define FLAG_AA ( 1 << 10)
370	#define FLAG_TC ( 1 << 9)	417	#define FLAG_TC ( 1 << 9)
371	#define FLAG_RD ( 1 << 8)	418	#define FLAG_RD ( 1 << 8)
372	#define FLAG_RA ( 1 << 7)	419	#define FLAG_RA ( 1 << 7)
…		…
379	#define FLAG_RCODE_REFUSED ( 5 << 0)	426	#define FLAG_RCODE_REFUSED ( 5 << 0)
380		427
381	#define DEFAULT_CLIENT_FLAGS (FLAG_QUERY \| FLAG_OP_QUERY \| FLAG_RD)	428	#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)	429	#define DEFAULT_SERVER_FLAGS (FLAG_RESPONSE \| FLAG_OP_QUERY \| FLAG_AA \| FLAG_RD \| FLAG_RA)
383		430
		431	struct dns_cfg
		432	{
		433	static int next_uid;
		434
		435	u8 id1, id2, id3, id4;
		436
		437	u8 version;
		438	u8 flags;
		439	u8 rrtype;
		440	u8 def_ttl;
		441
		442	u16 client;
		443	u16 uid; // to make request unique
		444
		445	u16 max_size;
		446	u8 seq_cdc;
		447	u8 req_cdc;
		448
		449	u8 rep_cdc;
		450	u8 delay; // time in 0.01s units that the server may delay replying packets
		451	u8 r3, r4;
		452
		453	u8 r5, r6, r7, r8;
		454
		455	void reset (int clientid);
		456	bool valid ();
		457	};
		458
		459	int dns_cfg::next_uid;
		460
		461	void
		462	dns_cfg::reset (int clientid)
		463	{
		464	id1 = 'G';
		465	id2 = 'V';
		466	id3 = 'P';
		467	id4 = 'E';
		468
		469	version = 1;
		470
		471	rrtype = RR_TYPE_TXT;
		472	flags = 0;
		473	def_ttl = 0;
		474	seq_cdc = 26;
		475	req_cdc = 62;
		476	rep_cdc = 0;
		477	max_size = htons (MAX_PKT_SIZE);
		478	client = htons (clientid);
		479	uid = next_uid++;
		480	delay = 0;
		481
		482	r3 = r4 = 0;
		483	r4 = r5 = r6 = r7 = 0;
		484	}
		485
		486	bool
		487	dns_cfg::valid ()
		488	{
		489	// although the protocol itself allows for some configurability,
		490	// only the following encoding/decoding settings are implemented.
		491	return id1 == 'G'
		492	&& id2 == 'V'
		493	&& id3 == 'P'
		494	&& id4 == 'E'
		495	&& seq_cdc == 26
		496	&& req_cdc == 62
		497	&& rep_cdc == 0
		498	&& version == 1;
		499	}
		500
384	struct dns_packet : net_packet	501	struct dns_packet : net_packet
385	{	502	{
386	u16 id;	503	u16 id;
387	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4	504	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
388	u16 qdcount, ancount, nscount, arcount;	505	u16 qdcount, ancount, nscount, arcount;
389		506
390	u8 data[MAXSIZE - 6 * 2];	507	u8 data [MAXSIZE - 6 * 2];
391		508
392	int decode_label (char *data, int size, int &offs);	509	int decode_label (char *data, int size, int &offs);
393	};	510	};
394		511
		512	int
395	int dns_packet::decode_label (char *data, int size, int &offs)	513	dns_packet::decode_label (char *data, int size, int &offs)
396	{	514	{
397	char *orig = data;	515	char *orig = data;
398		516
399	memset (data, 0, size);	517	memset (data, 0, size);
400		518
…		…
426	return data - orig;	544	return data - orig;
427	}	545	}
428		546
429	/////////////////////////////////////////////////////////////////////////////	547	/////////////////////////////////////////////////////////////////////////////
430		548
431	struct dns_req	549	static
		550	u16 next_id ()
432	{	551	{
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	552	static u16 dns_id = 0; // TODO: should be per-vpn
444		553
445	static u16 next_id ()	554	if (!dns_id)
446	{	555	dns_id = time (0);
		556
447	// the simplest lsfr with periodicity 65535 i could find	557	// the simplest lsfr with periodicity 65535 i could find
448	dns_id = (dns_id << 1)	558	dns_id = (dns_id << 1)
449	\| (((dns_id >> 1)	559	\| (((dns_id >> 1)
450	^ (dns_id >> 2)	560	^ (dns_id >> 2)
451	^ (dns_id >> 4)	561	^ (dns_id >> 4)
452	^ (dns_id >> 15)) & 1);	562	^ (dns_id >> 15)) & 1);
453		563
454	return dns_id;	564	return dns_id;
455	}	565	}
456		566
457	dns_req::dns_req (connection *c)	567	struct dns_rcv;
458	: conn (c)	568	struct dns_snd;
		569
		570	struct dns_connection
459	{	571	{
460	next = 0;	572	connection *c;
		573	struct vpn *vpn;
		574
		575	dns_cfg cfg;
		576
		577	bool established;
		578
		579	tstamp last_received;
		580	tstamp last_sent;
		581	double min_latency;
		582	double poll_interval, send_interval;
		583
		584	vector<dns_rcv *> rcvpq;
		585
		586	byte_stream rcvdq; int rcvseq; int repseq;
		587	byte_stream snddq; int sndseq;
		588
		589	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
		590	void receive_rep (dns_rcv *r);
		591
		592	dns_connection (connection *c);
		593	~dns_connection ();
		594	};
		595
		596	struct dns_snd
		597	{
		598	dns_packet *pkt;
		599	tstamp timeout, sent;
		600	int retry;
		601	struct dns_connection *dns;
		602	int seqno;
		603	bool stdhdr;
		604
		605	void gen_stream_req (int seqno, byte_stream &stream);
		606	void gen_syn_req ();
		607
		608	dns_snd (dns_connection *dns);
		609	~dns_snd ();
		610	};
		611
		612	dns_snd::dns_snd (dns_connection *dns)
		613	: dns (dns)
		614	{
		615	timeout = 0;
461	retry = 0;	616	retry = 0;
		617	seqno = 0;
		618	sent = ev_now ();
		619	stdhdr = false;
462		620
463	pkt = new dns_packet;	621	pkt = new dns_packet;
464		622
465	pkt->id = next_id ();	623	pkt->id = next_id ();
466	}	624	}
467		625
		626	dns_snd::~dns_snd ()
		627	{
		628	delete pkt;
		629	}
		630
		631	static void
		632	append_domain (dns_packet &pkt, int &offs, const char *domain)
		633	{
		634	// add tunnel domain
		635	for (;;)
		636	{
		637	const char *end = strchr (domain, '.');
		638
		639	if (!end)
		640	end = domain + strlen (domain);
		641
		642	int len = end - domain;
		643
		644	pkt [offs++] = len;
		645	memcpy (pkt.at (offs), domain, len);
		646	offs += len;
		647
		648	if (!*end)
		649	break;
		650
		651	domain = end + 1;
		652	}
		653	}
		654
		655	void
468	void dns_req::gen_stream_req (int seqno, byte_stream *stream)	656	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
469	{	657	{
		658	stdhdr = true;
470	this->seqno = seqno;	659	this->seqno = seqno;
		660
		661	timeout = ev_now () + INITIAL_TIMEOUT;
471		662
472	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	663	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
473	pkt->qdcount = htons (1);	664	pkt->qdcount = htons (1);
474		665
475	int offs = 6*2;	666	int offs = 6*2;
476	int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2);	667	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,	668	// 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	669	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
479		670
480	char enc[256], *encp = enc;	671	char enc[256], *encp = enc;
481	encode_header (enc, THISNODE->id, seqno);	672	encode_header (enc, THISNODE->id, seqno);
482		673
483	int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);	674	int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
484		675
485	if (datalen > stream->size ())	676	if (datalen > stream.size ())
486	datalen = stream->size ();	677	datalen = stream.size ();
487		678
488	int enclen = cdc62.encode (enc + HDRSIZE, stream->begin (), datalen) + HDRSIZE;	679	int enclen = cdc62.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);	680	stream.remove (datalen);
497		681
498	while (enclen)	682	while (enclen)
499	{	683	{
500	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;	684	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
501		685
…		…
506	encp += lbllen;	690	encp += lbllen;
507		691
508	enclen -= lbllen;	692	enclen -= lbllen;
509	}	693	}
510		694
511	const char *suffix = THISNODE->domain;	695	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		696
533	(*pkt)[offs++] = 0;	697	(*pkt)[offs++] = 0;
534	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;	698	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;
		699	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
		700
		701	pkt->len = offs;
		702	}
		703
		704	void
		705	dns_snd::gen_syn_req ()
		706	{
		707	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
		708
		709	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
		710	pkt->qdcount = htons (1);
		711
		712	int offs = 6 * 2;
		713
		714	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&dns->cfg, sizeof (dns_cfg));
		715
		716	assert (elen <= MAX_LBL_SIZE);
		717
		718	(*pkt)[offs] = elen;
		719	offs += elen + 1;
		720	append_domain (*pkt, offs, dns->c->conf->domain);
		721
		722	(*pkt)[offs++] = 0;
		723	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;
535	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	724	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
536		725
537	pkt->len = offs;	726	pkt->len = offs;
538	}	727	}
539		728
…		…
558	{	747	{
559	delete pkt;	748	delete pkt;
560	}	749	}
561		750
562	/////////////////////////////////////////////////////////////////////////////	751	/////////////////////////////////////////////////////////////////////////////
563		752
564	struct dns_cfg	753	dns_connection::dns_connection (connection *c)
		754	: c (c)
		755	, rcvdq (MAX_BACKLOG * 2)
		756	, snddq (MAX_BACKLOG)
565	{	757	{
566	u8 id1, id2, id3;	758	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		759
		760	vpn = c->vpn;
		761
		762	established = false;
		763
		764	rcvseq = repseq = sndseq = 0;
		765
		766	last_sent = last_received = 0;
		767	poll_interval = 0.5; // starting here
		768	send_interval = 0.5; // starting rate
		769	min_latency = INITIAL_TIMEOUT;
		770	}
		771
		772	dns_connection::~dns_connection ()
		773	{
		774	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
		775	i != rcvpq.end ();
		776	++i)
		777	delete *i;
		778	}
		779
		780	void
573	void connection::dnsv4_receive_rep (struct dns_rcv *r)	781	dns_connection::receive_rep (dns_rcv *r)
574	{	782	{
		783	if (r->datalen)
		784	{
		785	last_received = ev_now ();
		786	tw ();
		787
		788	poll_interval = send_interval;
		789	}
		790	else
		791	{
		792	poll_interval *= 1.5;
		793
		794	if (poll_interval > MAX_POLL_INTERVAL)
		795	poll_interval = MAX_POLL_INTERVAL;
		796	}
		797
575	dns_rcvpq.push_back (r);	798	rcvpq.push_back (r);
576		799
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:	800	redo:
584		801
585	// find next packet	802	// find next packet
586	for (vector<dns_rcv *>::iterator i = dns_rcvpq.end (); i-- != dns_rcvpq.begin (); )	803	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
587	if (SEQNO_EQ (dns_rcvseq, (*i)->seqno))	804	if (SEQNO_EQ (rcvseq, (*i)->seqno))
588	{	805	{
		806	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
589	// enter the packet into our input stream	807	// enter the packet into our input stream
590	r = *i;	808	r = *i;
591		809
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	810	// 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)	811	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
595	if (SEQNO_EQ ((*j)->seqno, dns_rcvseq - MAX_WINDOW))	812	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
596	{	813	{
597	printf ("%d removing %d\n", THISNODE->id, (*j)->seqno);	814	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
598	delete *j;	815	delete *j;
599	dns_rcvpq.erase (j);	816	rcvpq.erase (j);
600	break;	817	break;
601	}	818	}
602		819
603	dns_rcvseq = (dns_rcvseq + 1) & SEQNO_MASK;	820	rcvseq = (rcvseq + 1) & SEQNO_MASK;
604		821
605	if (!dns_snddq && !dns_rcvdq)	822	if (!rcvdq.put (r->data, r->datalen))
606	{	823	{
607	dns_rcvdq = new byte_stream (MAX_BACKLOG * 2);	824	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
608	dns_snddq = new byte_stream (MAX_BACKLOG);	825	abort (); // MUST never overflow, can be caused by data corruption, TODO
609
610	dns_si.set (::conf.dns_forw_host, ::conf.dns_forw_port, PROT_DNSv4);
611	}	826	}
612		827
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 ())	828	while (vpn_packet *pkt = rcvdq.get ())
617	{	829	{
618	sockinfo si;	830	sockinfo si;
619	si.host = 0; si.port = 0; si.prot = PROT_DNSv4;	831	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
620		832
621	vpn->recv_vpn_packet (pkt, si);	833	vpn->recv_vpn_packet (pkt, si);
		834
		835	delete pkt;
622	}	836	}
623		837
624	// check for further packets	838	// check for further packets
625	goto redo;	839	goto redo;
626	}	840	}
627	}	841	}
628		842
629	dns_packet *	843	void
630	vpn::dnsv4_server (dns_packet *pkt)	844	vpn::dnsv4_server (dns_packet &pkt)
631	{	845	{
632	u16 flags = ntohs (pkt->flags);	846	u16 flags = ntohs (pkt.flags);
633		847
634	//memcpy (&((rep)[0]), &((pkt)[0]), pkt->len);
635	int offs = 6 * 2; // skip header	848	int offs = 6 * 2; // skip header
636		849
637	pkt->flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	850	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
638		851
639	if (!(flags & (FLAG_RESPONSE \| FLAG_OP_MASK \| FLAG_TC))	852	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
640	&& pkt->qdcount == htons (1))	853	&& pkt.qdcount == htons (1))
641	{	854	{
642	char qname[MAXSIZE];	855	char qname [MAXSIZE];
643	int qlen = pkt->decode_label ((char *)qname, MAXSIZE - offs, offs);	856	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
644		857
645	u16 qtype = (pkt) [offs++] << 8; qtype \|= (pkt) [offs++];	858	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
646	u16 qclass = (pkt) [offs++] << 8; qclass \|= (pkt) [offs++];	859	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
647		860
648	pkt->qdcount = htons (1);	861	pkt.qdcount = htons (1);
649	pkt->ancount = 0;	862	pkt.ancount = 0;
650	pkt->nscount = 0; // should be self, as other nameservers reply like this	863	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	864	pkt.arcount = 0; // a record for self, as other nameservers reply like this
652		865
653	pkt->flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_NXDOMAIN);	866	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_SERVFAIL);
654		867
655	int dlen = strlen (THISNODE->domain);	868	int dlen = strlen (THISNODE->domain);
656		869
657	if (qclass == RR_CLASS_IN	870	if (qclass == RR_CLASS_IN
658	&& (qtype == RR_TYPE_ANY \|\| qtype == RR_TYPE_TXT)
659	&& qlen > dlen + 1 + HDRSIZE	871	&& qlen > dlen + 1
660	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	872	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
661	{	873	{
662	// correct class, domain: parse	874	// now generate reply
663	int client, seqno;	875	pkt.ancount = htons (1); // one answer RR
664	decode_header (qname, client, seqno);	876	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
665		877
666	u8 data[MAXSIZE];	878	if ((qtype == RR_TYPE_ANY
667	int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));	879	\|\| qtype == RR_TYPE_TXT
668		880	\|\| qtype == RR_TYPE_NULL)
669	printf ("cdc62.decode %d(%d): %02x %02x %02x %02x\n",
670	qlen - (dlen + 1 + HDRSIZE), datalen	881	&& 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	{	882	{
		883	// correct class, domain: parse
		884	int client, seqno;
		885	decode_header (qname, client, seqno);
		886
		887	u8 data[MAXSIZE];
		888	int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
		889
		890	if (0 < client && client <= conns.size ())
		891	{
681	connection *c = conns [client - 1];	892	connection *c = conns [client - 1];
		893	dns_connection *dns = c->dns;
		894	dns_rcv *rcv;
682		895
		896	if (dns)
		897	{
683	for (vector<dns_rcv *>::iterator i = c->dns_rcvpq.end (); i-- != c->dns_rcvpq.begin (); )	898	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
684	if (SEQNO_EQ ((*i)->seqno, seqno))	899	if (SEQNO_EQ ((*i)->seqno, seqno))
		900	{
		901	// already seen that request: simply reply with the cached reply
		902	dns_rcv r = i;
		903
		904	slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno);
		905
		906	// refresh header & id, as the retry count could have changed
		907	memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE);
		908	r->pkt->id = pkt.id;
		909
		910	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
		911
		912	goto duplicate_request;
		913	}
		914
		915	// new packet, queue
		916	rcv = new dns_rcv (seqno, data, datalen);
		917	dns->receive_rep (rcv);
		918	}
		919
685	{	920	{
686	// already seen that request: simply reply with the cached reply	921	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
687	dns_rcv r = i;
688		922
689	printf ("DUPLICATE %d\n", htons (r->pkt->id));//D	923	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
		924	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
		925	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
		926	pkt [offs++] = 0; pkt [offs++] = 0;
		927	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
690		928
691	memcpy (pkt->at (0), r->pkt->at (0), offs = r->pkt->len);	929	int rdlen_offs = offs += 2;
692	pkt->id = r->pkt->id;	930
693	goto duplicate_request;	931	if (dns)
		932	{
		933	int dlen = ntohs (dns->cfg.max_size) - offs;
		934
		935	// bind doesn't compress well, so reduce further by one label length
		936	dlen -= qlen;
		937
		938	// only put data into in-order sequence packets, if
		939	// we receive out-of-order packets we generate empty
		940	// replies
		941	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		942	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
		943	{
		944	dns->repseq = seqno;
		945
		946	while (dlen > 1 && !dns->snddq.empty ())
		947	{
		948	int txtlen = dlen <= 255 ? dlen - 1 : 255;
		949
		950	if (txtlen > dns->snddq.size ())
		951	txtlen = dns->snddq.size ();
		952
		953	pkt[offs++] = txtlen;
		954	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
		955	offs += txtlen;
		956	dns->snddq.remove (txtlen);
		957
		958	dlen -= txtlen + 1;
		959	}
		960	}
		961
		962	// avoid completely empty TXT rdata
		963	if (offs == rdlen_offs)
		964	pkt[offs++] = 0;
		965
		966	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
		967	}
		968	else
		969	{
		970	// send RST
		971	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
		972	pkt [offs++] = CMD_IP_RST;
		973	}
		974
		975	int rdlen = offs - rdlen_offs;
		976
		977	pkt [rdlen_offs - 2] = rdlen >> 8;
		978	pkt [rdlen_offs - 1] = rdlen;
		979
		980	if (dns)
		981	{
		982	// now update dns_rcv copy
		983	rcv->pkt->len = offs;
		984	memcpy (rcv->pkt->at (0), pkt.at (0), offs);
		985	}
694	}	986	}
695		987
696	// new packet, queue	988	duplicate_request: ;
697	dns_rcv *rcv = new dns_rcv (seqno, data, datalen);	989	}
698	c->dnsv4_receive_rep (rcv);	990	else
699
700	// now generate reply
701	pkt->ancount = htons (1); // one answer RR
702	pkt->flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	991	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
		992	}
		993	else if (qtype == RR_TYPE_A
		994	&& qlen > dlen + 1 + cdc26.encode_len (sizeof (dns_cfg)))
		995	{
		996	dns_cfg cfg;
		997	cdc26.decode ((u8 *)&cfg, qname, cdc26.encode_len (sizeof (dns_cfg)));
		998	int client = ntohs (cfg.client);
703		999
704	(*pkt) [offs++] = 0xc0;
705	(pkt) [offs++] = 6 2; // same as in query section	1000	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
706		1001
707	(pkt) [offs++] = RR_TYPE_TXT >> 8; (pkt) [offs++] = RR_TYPE_TXT;	1002	pkt [offs++] = RR_TYPE_A >> 8; pkt [offs++] = RR_TYPE_A; // type
708	(pkt) [offs++] = RR_CLASS_IN >> 8; (pkt) [offs++] = RR_CLASS_IN;	1003	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
709
710	(pkt) [offs++] = 0; (pkt) [offs++] = 0;	1004	pkt [offs++] = 0; pkt [offs++] = 0;
711	(pkt) [offs++] = 0; (pkt) [offs++] = 0; // TTL	1005	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
		1006	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
712		1007
713	int dlen = MAX_PKT_SIZE - offs - 2;	1008	slog (L_INFO, _("DNS: client %d connects"), client);
714		1009
715	// bind doesn't compress well, so reduce further by one label length	1010	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
716	dlen -= qlen;	1011	pkt [offs++] = CMD_IP_REJ;
717		1012
718	int rdlen_offs = offs += 2;	1013	if (0 < client && client <= conns.size ())
719
720	while (c->dns_snddq
721	&& !c->dns_snddq->empty ()
722	&& dlen > 1)
723	{	1014	{
724	int txtlen = dlen <= 255 ? dlen - 1 : 255;	1015	connection *c = conns [client - 1];
725		1016
726	if (txtlen > c->dns_snddq->size ())	1017	if (cfg.valid ())
727	txtlen = c->dns_snddq->size ();	1018	{
		1019	pkt [offs - 1] = CMD_IP_SYN;
728		1020
729	(*pkt)[offs++] = txtlen;	1021	delete c->dns;
730	memcpy (pkt->at (offs), c->dns_snddq->begin (), txtlen);	1022	c->dns = new dns_connection (c);
731	offs += txtlen;	1023	c->dns->cfg = cfg;
732	c->dns_snddq->remove (txtlen);	1024	}
733
734	dlen -= txtlen + 1;
735	}	1025	}
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	}	1026	}
752	else
753	pkt->flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
754	}	1027	}
755		1028
756	pkt->len = offs;	1029	pkt.len = offs;
757	}	1030	}
758
759	return pkt;
760	}	1031	}
761		1032
762	void	1033	void
763	vpn::dnsv4_client (dns_packet *pkt)	1034	vpn::dnsv4_client (dns_packet &pkt)
764	{	1035	{
765	u16 flags = ntohs (pkt->flags);	1036	u16 flags = ntohs (pkt.flags);
766	int offs = 6 * 2; // skip header	1037	int offs = 6 * 2; // skip header
767		1038
768	pkt->qdcount = ntohs (pkt->qdcount);	1039	pkt.qdcount = ntohs (pkt.qdcount);
769	pkt->ancount = ntohs (pkt->ancount);	1040	pkt.ancount = ntohs (pkt.ancount);
770		1041
771	// go through our request list and find the corresponding request	1042	// go through our request list and find the corresponding request
772	for (vector<dns_req *>::iterator i = dns_sndpq.begin ();	1043	for (vector<dns_snd *>::iterator i = dns_sndpq.begin ();
773	i != dns_sndpq.end ();	1044	i != dns_sndpq.end ();
774	++i)	1045	++i)
775	if ((*i)->pkt->id == pkt->id)	1046	if ((*i)->pkt->id == pkt.id)
776	{	1047	{
		1048	dns_connection dns = (i)->dns;
777	connection c = (i)->conn;	1049	connection *c = dns->c;
778	int seqno = (*i)->seqno;	1050	int seqno = (*i)->seqno;
779	u8 data[MAXSIZE], *datap = data;	1051	u8 data[MAXSIZE], *datap = data;
		1052	//printf ("rcv pkt %x\n", seqno);//D
		1053
		1054	if ((*i)->retry)
		1055	{
		1056	dns->send_interval *= 1.01;
		1057	if (dns->send_interval > MAX_SEND_INTERVAL)
		1058	dns->send_interval = MAX_SEND_INTERVAL;
		1059	}
		1060	else
		1061	{
		1062	#if 0
		1063	dns->send_interval *= 0.999;
		1064	#endif
		1065	// the latency surely puts an upper bound on
		1066	// the minimum send interval
		1067	double latency = ev_now () - (*i)->sent;
		1068
		1069	if (latency < dns->min_latency)
		1070	dns->min_latency = latency;
		1071
		1072	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1073	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1074
		1075	if (dns->send_interval < conf.dns_send_interval)
		1076	dns->send_interval = conf.dns_send_interval;
		1077	}
780		1078
781	delete *i;	1079	delete *i;
782	dns_sndpq.erase (i);	1080	dns_sndpq.erase (i);
783		1081
784	if (flags & (FLAG_RESPONSE \| FLAG_OP_MASK \| FLAG_TC))	1082	if (flags & FLAG_RESPONSE && !(flags & FLAG_OP_MASK))
785	{	1083	{
786	char qname[MAXSIZE];	1084	char qname[MAXSIZE];
787		1085
788	while (pkt->qdcount-- && offs < MAXSIZE - 4)	1086	while (pkt.qdcount-- && offs < MAXSIZE - 4)
789	{	1087	{
790	int qlen = pkt->decode_label ((char *)qname, MAXSIZE - offs, offs);	1088	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
791	offs += 4; // skip qtype, qclass	1089	offs += 4; // skip qtype, qclass
792	}	1090	}
793		1091
794	while (pkt->ancount-- && offs < MAXSIZE - 10)	1092	while (pkt.ancount-- && offs < MAXSIZE - 10 && datap)
795	{	1093	{
796	int qlen = //D
797	pkt->decode_label ((char *)qname, MAXSIZE - offs, offs);	1094	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
798		1095
799	printf ("got reply to <%.*s>\n", qlen, qname);//D
800
801	u16 qtype = (pkt) [offs++] << 8; qtype \|= (pkt) [offs++];	1096	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
802	u16 qclass = (pkt) [offs++] << 8; qclass \|= (pkt) [offs++];	1097	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
803	u32 ttl = (*pkt) [offs++] << 24;	1098	u32 ttl = pkt [offs++] << 24;
804	ttl \|= (*pkt) [offs++] << 16;	1099	ttl \|= pkt [offs++] << 16;
805	ttl \|= (*pkt) [offs++] << 8;	1100	ttl \|= pkt [offs++] << 8;
806	ttl \|= (*pkt) [offs++];	1101	ttl \|= pkt [offs++];
807
808	u16 rdlen = (pkt) [offs++] << 8; rdlen \|= (pkt) [offs++];	1102	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];
809		1103
810	if (rdlen <= MAXSIZE - offs)	1104	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT)
811	{	1105	{
812	// decode bytes, finally	1106	if (rdlen <= MAXSIZE - offs)
813
814	while (rdlen)
815	{	1107	{
		1108	// decode bytes, finally
		1109
		1110	while (rdlen)
		1111	{
816	int txtlen = (*pkt) [offs++];	1112	int txtlen = pkt [offs++];
817		1113
818	assert (txtlen + offs < MAXSIZE - 1);	1114	assert (txtlen + offs < MAXSIZE - 1);
819		1115
820	memcpy (datap, pkt->at (offs), txtlen);	1116	memcpy (datap, pkt.at (offs), txtlen);
821	datap += txtlen; offs += txtlen;	1117	datap += txtlen; offs += txtlen;
822		1118
823	rdlen -= txtlen + 1;	1119	rdlen -= txtlen + 1;
		1120	}
824	}	1121	}
825
826	}	1122	}
		1123	else if (qtype == RR_TYPE_A)
		1124	{
		1125	u8 ip [4];
827		1126
		1127	ip [0] = pkt [offs++];
		1128	ip [1] = pkt [offs++];
		1129	ip [2] = pkt [offs++];
		1130	ip [3] = pkt [offs++];
		1131
		1132	if (ip [0] == CMD_IP_1
		1133	&& ip [1] == CMD_IP_2
		1134	&& ip [2] == CMD_IP_3)
		1135	{
		1136	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
		1137
		1138	if (ip [3] == CMD_IP_RST)
		1139	{
		1140	slog (L_DEBUG, _("DNS: got tunnel RST request"));
		1141
		1142	delete dns; c->dns = 0;
		1143
		1144	return;
		1145	}
		1146	else if (ip [3] == CMD_IP_SYN)
		1147	{
		1148	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
		1149	dns->established = true;
		1150	}
		1151	else if (ip [3] == CMD_IP_REJ)
		1152	{
		1153	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
		1154	abort ();
		1155	}
		1156	else
		1157	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
		1158	}
		1159	else
		1160	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
		1161	ip [0], ip [1], ip [2], ip [3]);
		1162
		1163	return;
		1164	}
		1165
		1166	int client, rseqno;
		1167	decode_header (qname, client, rseqno);
		1168
		1169	if (client != THISNODE->id)
		1170	{
		1171	slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
		1172	datap = 0;
		1173	}
		1174	else if (rseqno != seqno)
		1175	{
		1176	slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
		1177	datap = 0;
		1178	}
828	}	1179	}
829	}	1180	}
830		1181
831	// todo: pkt now used	1182	// todo: pkt now used
		1183	if (datap)
832	c->dnsv4_receive_rep (new dns_rcv (seqno, data, datap - data));	1184	dns->receive_rep (new dns_rcv (seqno, data, datap - data));
833		1185
834	break;	1186	break;
835	}	1187	}
836
837	delete pkt;
838	}	1188	}
839		1189
840	void	1190	void
841	vpn::dnsv4_ev (io_watcher &w, short revents)	1191	vpn::dnsv4_ev (ev::io &w, int revents)
842	{	1192	{
843	if (revents & EVENT_READ)	1193	if (revents & EV_READ)
844	{	1194	{
845	dns_packet *pkt = new dns_packet;	1195	dns_packet *pkt = new dns_packet;
846	struct sockaddr_in sa;	1196	struct sockaddr_in sa;
847	socklen_t sa_len = sizeof (sa);	1197	socklen_t sa_len = sizeof (sa);
848		1198
849	pkt->len = recvfrom (w.fd, &((pkt)[0]), MAXSIZE, 0, (sockaddr )&sa, &sa_len);	1199	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
850		1200
851	if (pkt->len > 0)	1201	if (pkt->len > 0)
852	{	1202	{
853	if (pkt->flags & htons (FLAG_TC))	1203	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1204	dnsv4_client (*pkt);
		1205	else
854	{	1206	{
855	slog (L_WARN, _("DNS request/response truncated, check protocol settings."));	1207	dnsv4_server (*pkt);
856	//TODO connection reset	1208	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
857	}	1209	}
858		1210
859	if (THISNODE->dns_port)	1211	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	}	1212	}
867	}	1213	}
868	}	1214	}
869		1215
870	bool	1216	bool
871	connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1217	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
872	{	1218	{
873	// never initialized	1219	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		1220
879	//dns_rcvseq = dns_sndseq = 0;	1221	assert (0 < client && client <= conns.size ());
880		1222
881	dns_si.set (::conf.dns_forw_host, ::conf.dns_forw_port, PROT_DNSv4);	1223	connection *c = conns [client - 1];
882	}	1224
		1225	if (!c->dns)
		1226	c->dns = new dns_connection (c);
883		1227
884	if (!dns_snddq->put (pkt))	1228	if (c->dns->snddq.put (pkt))
885	return false;	1229	c->dns->tw ();
886		1230
887	// start timer if neccessary	1231	// 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;	1232	return true;
892	}	1233	}
893		1234
894	void	1235	void
895	connection::dnsv4_cb (time_watcher &w)	1236	connection::dnsv4_reset_connection ()
896	{	1237	{
		1238	//delete dns; dns = 0; //TODO
		1239	}
		1240
		1241	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
		1242
		1243	void
		1244	dns_connection::time_cb (ev::timer &w, int revents)
		1245	{
		1246	// servers have to be polled
		1247	if (THISNODE->dns_port)
		1248	return;
		1249
897	// check for timeouts and (re)transmit	1250	// check for timeouts and (re)transmit
898	tstamp next = NOW + 60;	1251	tstamp next = ev::now () + poll_interval;
899	dns_req *send = 0;	1252	dns_snd *send = 0;
900		1253
901	for (vector<dns_req *>::iterator i = vpn->dns_sndpq.begin ();	1254	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
902	i != vpn->dns_sndpq.end ();	1255	i != vpn->dns_sndpq.end ();
903	++i)	1256	++i)
904	{	1257	{
905	dns_req r = i;	1258	dns_snd r = i;
906		1259
907	if (r->next <= NOW)	1260	if (r->timeout <= ev_now ())
908	{	1261	{
909	if (!send)	1262	if (!send)
910	{	1263	{
911	send = r;	1264	send = r;
912		1265
913	if (r->retry)//D
914	printf ("req %d:%d, retry %d\n", r->seqno, r->pkt->id, r->retry);
915	r->retry++;	1266	r->retry++;
916	r->next = NOW + r->retry;	1267	r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
		1268	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
		1269
		1270	// the following code changes the query section a bit, forcing
		1271	// the forwarder to generate a new request
		1272	if (r->stdhdr)
		1273	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
917	}	1274	}
918	}	1275	}
919		1276	else
920	if (r->next < next)	1277	NEXT (r->timeout);
921	next = r->next;
922	}	1278	}
923		1279
924	if (!send	1280	if (!send)
925	&& vpn->dns_sndpq.size () < MAX_OUTSTANDING)
926	{	1281	{
		1282	// generate a new packet, if wise
		1283
		1284	if (!established)
		1285	{
		1286	if (vpn->dns_sndpq.empty ())
		1287	{
927	send = new dns_req (this);	1288	send = new dns_snd (this);
		1289
		1290	cfg.reset (THISNODE->id);
		1291	send->gen_syn_req ();
		1292	}
		1293	}
		1294	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
		1295	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1296	{
		1297	if (last_sent + send_interval <= ev_now ())
		1298	{
		1299	//printf ("sending data request etc.\n"); //D
		1300	if (!snddq.empty () \|\| last_received + 1. > ev_now ())
		1301	{
		1302	poll_interval = send_interval;
		1303	NEXT (ev_now () + send_interval);
		1304	}
		1305
		1306	send = new dns_snd (this);
928	send->gen_stream_req (dns_sndseq, dns_snddq);	1307	send->gen_stream_req (sndseq, snddq);
		1308	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1309	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
		1310
		1311	sndseq = (sndseq + 1) & SEQNO_MASK;
		1312	}
		1313	else
		1314	NEXT (last_sent + send_interval);
		1315	}
		1316
		1317	if (send)
929	vpn->dns_sndpq.push_back (send);	1318	vpn->dns_sndpq.push_back (send);
930
931	dns_sndseq = (dns_sndseq + 1) & SEQNO_MASK;
932	}	1319	}
933
934	tstamp min_next = NOW + (1. / (tstamp)MAX_RATE);
935		1320
936	if (send)	1321	if (send)
937	{	1322	{
938	dns_packet *pkt = send->pkt;	1323	last_sent = ev_now ();
939		1324	sendto (vpn->dnsv4_fd,
940	next = min_next;	1325	send->pkt->at (0), send->pkt->len, 0,
941		1326	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	}	1327	}
944	else if (next < min_next)
945	next = min_next;
946		1328
947	w.start (next);	1329	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
		1330	poll_interval, send_interval, next - ev_now (),
		1331	vpn->dns_sndpq.size (), snddq.size (),
		1332	rcvpq.size ());
		1333
		1334	// TODO: no idea when this happens, but when next < ev_now (), we have a problem
		1335	// doesn't seem to happen anymore
		1336	if (next < ev_now () + 0.001)
		1337	next = ev_now () + 0.1;
		1338
		1339	w.start (next - ev_now ());
948	}	1340	}
949		1341
950	#endif	1342	#endif
951		1343

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.8 by pcg, Fri Mar 4 03:43:09 2005 UTC vs. Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.8 by pcg, Fri Mar 4 03:43:09 2005 UTC vs.
Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC