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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.2 by pcg, Tue Mar 1 04:38:21 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-2004 Marc Lehmann <pcg@goof.com>	3	Copyright (C) 2003-2011 Marc Lehmann <gvpe@schmorp.de>
4		4
		5	This file is part of GVPE.
		6
5	This program is free software; you can redistribute it and/or modify	7	GVPE is free software; you can redistribute it and/or modify it
6	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
7	the Free Software Foundation; either version 2 of the License, or	9	Free Software Foundation; either version 3 of the License, or (at your
8	(at your option) any later version.	10	option) any later version.
9		11
10	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
11	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
13	GNU General Public License for more details.	15	Public License for more details.
14		16
15	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
16	along with this program; if not, write to the Free Software	18	with this program; if not, see <http://www.gnu.org/licenses/>.
17	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.
18	*/	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.
19		35
20	#include "config.h"	36	#include "config.h"
21		37
22	#if ENABLE_DNS	38	#if ENABLE_DNS
23		39
24	// dns processing is EXTREMELY ugly. For obvious(?) reasons.	40	// dns processing is EXTREMELY ugly. For obvious(?) reasons.
25	// it's a hack, use only in emergency situations please.	41	// it's a hack, use only in emergency situations please.
26		42
27	#include <cstring>	43	#include <cstring>
		44	#include <cassert>
28		45
29	#include <sys/types.h>	46	#include <sys/types.h>
30	#include <sys/socket.h>	47	#include <sys/socket.h>
31	#include <sys/wait.h>	48	#include <sys/wait.h>
32	#include <sys/uio.h>	49	#include <sys/uio.h>
35	#include <unistd.h>	52	#include <unistd.h>
36	#include <fcntl.h>	53	#include <fcntl.h>
37		54
38	#include <map>	55	#include <map>
39		56
		57	#include <cstdio> /* bug in libgmp: gmp.h relies on cstdio being included */
		58	#include <gmp.h>
		59
40	#include "netcompat.h"	60	#include "netcompat.h"
41		61
42	#include "vpn.h"	62	#include "vpn.h"
43		63
44	#if ENABLE_HTTP_PROXY	64	#define MIN_POLL_INTERVAL 0.025 // poll at most this often when no data received
45	# include "conf.h"	65	#define MAX_POLL_INTERVAL 1. // how often to poll minimally when the server has no data
46	#endif
47		66
48	#define MIN_RETRY 1.	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
49	#define MAX_RETRY 60.	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
50		69
51	#define SERVER conf.dns_port	70	#define MAX_SEND_INTERVAL 5. // optimistic?
52		71
53	/*	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
		73	#define MAX_BACKLOG (64*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
54		74
55	protocol, in shorthand :)	75	#define MAX_DOMAIN_SIZE 240 // 255 is legal limit, but bind doesn't compress well
		76	// 240 leaves about 4 bytes of server reply data
		77	// every request byte less give room for two reply bytes
56		78
57	client -> server <req> ANY?	79	#define SEQNO_MASK 0x3fff
58	server -> client <req> TXT <rep>	80	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
59
60	<req> is dns64-encoded <client-id:12><recv-seqno:10>[<send-seqno:10><data>]
61	<rep> is dns64-encoded <0:12><recv-seqno:10>[<send-seqno:10><data>]
62
63	if <client-id> is zero, the connection will be configured:
64
65	<0:12><0:4>client-id:12><default-ttl:8><max-size:16><flags:16>
66
67	*/
68		81
69	#define MAX_LBL_SIZE 63	82	#define MAX_LBL_SIZE 63
70	#define MAX_PKT_SIZE 512	83	#define MAX_PKT_SIZE 512
71		84
		85	#define RR_TYPE_A 1
		86	#define RR_TYPE_NULL 10
72	#define RR_TYPE_TXT 16	87	#define RR_TYPE_TXT 16
		88	#define RR_TYPE_AAAA 28
73	#define RR_TYPE_ANY 255	89	#define RR_TYPE_ANY 255
		90
74	#define RR_CLASS_IN 1	91	#define RR_CLASS_IN 1
75		92
76	// the "_" is not valid but widely accepted (all octets should be supported, but let's be conservative)	93	#define CMD_IP_1 207
77	struct dns64	94	#define CMD_IP_2 46
78	{	95	#define CMD_IP_3 236
79	static const char encode_chars[64 + 1];
80	static s8 decode_chars[256];
81		96
82	static int encode_len (int bytes) { return (bytes * 8 + 5) / 6; }	97	#define CMD_IP_RST 29 // some error, reset and retry
83	static int decode_len (int bytes) { return (bytes * 6) / 8; }	98	#define CMD_IP_REJ 32 // do not want you
84	static void encode (char dst, u8 src, int len);	99	#define CMD_IP_SYN 113 // connection established
85	static void decode (u8 dst, char src, int len);	100	#define CMD_IP_CSE 213 // connection established, but likely case mismatch
86		101
87	dns64 ();	102	static bool
88	} dns64;	103	is_uc (char c)
89
90	const char dns64::encode_chars[64 + 1] = "0123456789-abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ";
91	s8 dns64::decode_chars[256];
92
93	dns64::dns64 ()
94	{	104	{
95	for (int i = 0; i < 64; i++)	105	return 'A' <= c && c <= 'Z';
96	decode_chars [encode_chars [i]] = i + 1;
97	}	106	}
98		107
99	void dns64::encode (char dst, u8 src, int len)	108	static bool
		109	is_lc (char c)
100	{	110	{
101	// slow, but easy to debug	111	return 'a' <= c && c <= 'z';
102	unsigned int accum, bits = 0;	112	}
		113
		114	// works for cmaps up to 255 (not 256!)
		115	struct charmap
		116	{
		117	enum { INVALID = (u8)255 };
		118
		119	char encode [256]; // index => char
		120	u8 decode [256]; // char => index
		121	unsigned int size;
		122
		123	charmap (const char *cmap);
		124	};
		125
		126	charmap::charmap (const char *cmap)
		127	{
		128	char *enc = encode;
		129	u8 *dec = decode;
		130
		131	memset (enc, (char) 0, 256);
		132	memset (dec, (char)INVALID, 256);
		133
		134	for (size = 0; cmap [size]; size++)
		135	{
		136	char c = cmap [size];
		137
		138	enc [size] = c;
		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;
		144	}
		145
		146	assert (size < 256);
		147	}
		148
		149	#define MAX_DEC_LEN 500
		150	#define MAX_ENC_LEN (MAX_DEC_LEN * 2)
		151	#define MAX_LIMBS ((MAX_DEC_LEN * 8 + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS)
		152
		153	// ugly. minimum base is 16(!)
		154	struct basecoder
		155	{
		156	charmap cmap;
		157	unsigned int enc_len [MAX_DEC_LEN];
		158	unsigned int dec_len [MAX_ENC_LEN];
		159
		160	unsigned int encode_len (unsigned int len) const;
		161	unsigned int decode_len (unsigned int len) const;
		162
		163	unsigned int encode (char dst, u8 src, unsigned int len) const;
		164	unsigned int decode (u8 dst, char src, unsigned int len) const;
		165
		166	basecoder (const char *cmap);
		167	};
		168
		169	basecoder::basecoder (const char *cmap)
		170	: cmap (cmap)
		171	{
		172	for (unsigned int len = 0; len < MAX_DEC_LEN; ++len)
		173	{
		174	u8 src [MAX_DEC_LEN];
		175	u8 dst [MAX_ENC_LEN];
		176
		177	memset (src, 255, len);
		178
		179	mp_limb_t m [MAX_LIMBS];
		180	mp_size_t n;
		181
		182	n = mpn_set_str (m, src, len, 256);
		183	n = mpn_get_str (dst, this->cmap.size, m, n);
		184
		185	for (int i = 0; !dst [i]; ++i)
		186	n--;
		187
		188	enc_len [len] = n;
		189	dec_len [n] = len;
		190	}
		191	}
		192
		193	unsigned int
		194	basecoder::encode_len (unsigned int len) const
		195	{
		196	return enc_len [len];
		197	}
		198
		199	unsigned int
		200	basecoder::decode_len (unsigned int len) const
		201	{
		202	while (len && !dec_len [len])
		203	--len;
		204
		205	return dec_len [len];
		206	}
		207
		208	unsigned int
		209	basecoder::encode (char dst, u8 src, unsigned int len) const
		210	{
		211	if (!len \|\| len > MAX_DEC_LEN)
		212	return 0;
		213
		214	int elen = encode_len (len);
		215
		216	mp_limb_t m [MAX_LIMBS];
		217	mp_size_t n;
		218
		219	u8 dst_ [MAX_ENC_LEN];
		220
		221	n = mpn_set_str (m, src, len, 256);
		222	n = mpn_get_str (dst_, cmap.size, m, n);
		223
		224	int plen = elen; // for padding
		225
		226	while (n < plen)
		227	{
		228	*dst++ = cmap.encode [0];
		229	plen--;
		230	}
		231
		232	for (unsigned int i = n - plen; i < n; ++i)
		233	*dst++ = cmap.encode [dst_ [i]];
		234
		235	return elen;
		236	}
		237
		238	unsigned int
		239	basecoder::decode (u8 dst, char src, unsigned int len) const
		240	{
		241	if (!len \|\| len > MAX_ENC_LEN)
		242	return 0;
		243
		244	u8 src_ [MAX_ENC_LEN];
		245	unsigned int elen = 0;
103		246
104	while (len--)	247	while (len--)
105	{	248	{
106	accum <<= 8;	249	u8 val = cmap.decode [(u8)*src++];
107	accum \|= *src++;
108	bits += 8;
109		250
110	while (bits >= 6)	251	if (val != charmap::INVALID)
111	{	252	src_ [elen++] = val;
112	*dst++ = encode_chars [(accum >> (bits - 6)) & 63];	253	}
113	bits -= 6;	254
114	}	255	int dlen = decode_len (elen);
		256
		257	mp_limb_t m [MAX_LIMBS];
		258	mp_size_t n;
		259
		260	u8 dst_ [MAX_DEC_LEN];
		261
		262	n = mpn_set_str (m, src_, elen, cmap.size);
		263	n = mpn_get_str (dst_, 256, m, n);
		264
		265	if (n < dlen)
115	}	266	{
		267	memset (dst, 0, dlen - n);
		268	memcpy (dst + dlen - n, dst_, n);
		269	}
		270	else
		271	memcpy (dst, dst_ + n - dlen, dlen);
116		272
117	if (bits)	273	return dlen;
118	*dst++ = encode_chars [(accum << (6 - bits)) & 63];
119	}	274	}
120		275
121	void dns64::decode (u8 dst, char src, int len)	276	#if 0
122	{	277	struct test { test (); } test;
123	// slow, but easy to debug
124	unsigned int accum, bits = 0;
125		278
126	while (len--)	279	test::test ()
		280	{
		281	basecoder cdc ("0123456789abcdefghijklmnopqrstuvwxyz");
		282
		283	u8 in[] = "0123456789abcdefghijklmnopqrstuvwxyz";
		284	static char enc[200];
		285	static u8 dec[200];
		286
		287	for (int i = 1; i < 20; i++)
127	{	288	{
128	s8 chr = decode_chars [(u8)*src++];	289	int elen = cdc.encode (enc, in, i);
		290	int dlen = cdc.decode (dec, enc, elen);
129		291
		292	printf ("%d>%d>%d (%s>%s)\n", i, elen, dlen, enc, dec);
		293	}
		294	abort ();
		295	}
		296	#endif
130		297
131	if (!chr)	298	static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI"); // a-zA-Z0-9
		299	static basecoder cdc36 ("dPhZr06QmJkB34tSvL81xAeF92wGyO57uCnI"); // a-z0-9 for case-changers
		300	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyOuCnI"); // a-z
		301
		302	/////////////////////////////////////////////////////////////////////////////
		303
		304	#define HDRSIZE 5
		305
		306	inline void
		307	encode_header (char *data, int clientid, int seqno, int retry = 0)
		308	{
		309	assert (clientid < 256);
		310
		311	seqno &= SEQNO_MASK;
		312
		313	u8 hdr[3] = {
		314	seqno,
		315	(seqno >> 8) \| (retry << 6),
		316	clientid,
		317	};
		318
		319	cdc36.encode (data, hdr, 3);
		320	}
		321
		322	inline void
		323	decode_header (char *data, int &clientid, int &seqno)
		324	{
		325	u8 hdr[3];
		326
		327	cdc36.decode (hdr, data, HDRSIZE);
		328
		329	clientid = hdr[2];
		330	seqno = ((hdr[1] << 8) \| hdr[0]) & SEQNO_MASK;
		331	}
		332
		333	/////////////////////////////////////////////////////////////////////////////
		334
		335	struct byte_stream
		336	{
		337	u8 *data;
		338	int maxsize;
		339	int fill;
		340
		341	byte_stream (int maxsize);
		342	~byte_stream ();
		343
		344	bool empty () { return !fill; }
		345	int size () { return fill; }
		346
		347	bool put (u8 *data, unsigned int datalen);
		348	bool put (vpn_packet *pkt);
		349	vpn_packet *get ();
		350
		351	u8 *begin () { return data; }
		352	void remove (int count);
		353	};
		354
		355	byte_stream::byte_stream (int maxsize)
		356	: maxsize (maxsize), fill (0)
		357	{
		358	data = new u8 [maxsize];
		359	}
		360
		361	byte_stream::~byte_stream ()
		362	{
		363	delete data;
		364	}
		365
		366	void
		367	byte_stream::remove (int count)
		368	{
		369	if (count > fill)
		370	assert (count <= fill);
		371
		372	memmove (data, data + count, fill -= count);
		373	}
		374
		375	bool
		376	byte_stream::put (u8 *data, unsigned int datalen)
		377	{
		378	if (maxsize - fill < datalen)
		379	return false;
		380
		381	memcpy (this->data + fill, data, datalen); fill += datalen;
		382
		383	return true;
		384	}
		385
		386	bool
		387	byte_stream::put (vpn_packet *pkt)
		388	{
		389	if (maxsize - fill < pkt->len + 2)
		390	return false;
		391
		392	data [fill++] = pkt->len >> 8;
		393	data [fill++] = pkt->len;
		394
		395	memcpy (data + fill, pkt->at (0), pkt->len); fill += pkt->len;
		396
		397	return true;
		398	}
		399
		400	vpn_packet *byte_stream::get ()
		401	{
		402	unsigned int len;
		403
		404	for (;;)
		405	{
		406	len = (data [0] << 8) \| data [1];
		407
		408	if (len <= MAXSIZE \|\| fill < 2)
132	break;	409	break;
133		410
134	accum <<= 6;	411	// TODO: handle this better than skipping, e.g. by reset
135	accum \|= chr - 1;	412	slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
136	bits += 6;	413	remove (1);
137		414	}
138	while (bits >= 8)
139	{	415
140	*dst++ = accum >> (bits - 8);	416	if (fill < len + 2)
141	bits -= 8;	417	return 0;
142	}	418
143	}	419	vpn_packet *pkt = new vpn_packet;
		420
		421	pkt->len = len;
		422	memcpy (pkt->at (0), data + 2, len);
		423	remove (len + 2);
		424
		425	return pkt;
144	}	426	}
		427
		428	/////////////////////////////////////////////////////////////////////////////
145		429
146	#define FLAG_QUERY ( 0 << 15)	430	#define FLAG_QUERY ( 0 << 15)
147	#define FLAG_RESPONSE ( 1 << 15)	431	#define FLAG_RESPONSE ( 1 << 15)
148	#define FLAG_OP_MASK (15 << 14)	432	#define FLAG_OP_MASK (15 << 11)
149	#define FLAG_OP_QUERY ( 0 << 11)	433	#define FLAG_OP_QUERY ( 0 << 11)
150	#define FLAG_AA ( 1 << 10)	434	#define FLAG_AA ( 1 << 10)
151	#define FLAG_TC ( 1 << 9)	435	#define FLAG_TC ( 1 << 9)
152	#define FLAG_RD ( 1 << 8)	436	#define FLAG_RD ( 1 << 8)
153	#define FLAG_RA ( 1 << 7)	437	#define FLAG_RA ( 1 << 7)
		438	#define FLAG_AUTH ( 1 << 5)
154	#define FLAG_RCODE_MASK (15 << 0)	439	#define FLAG_RCODE_MASK (15 << 0)
155	#define FLAG_RCODE_OK ( 0 << 0)	440	#define FLAG_RCODE_OK ( 0 << 0)
156	#define FLAG_RCODE_FORMERR ( 1 << 0)	441	#define FLAG_RCODE_FORMERR ( 1 << 0)
157	#define FLAG_RCODE_SERVFAIL ( 2 << 0)	442	#define FLAG_RCODE_SERVFAIL ( 2 << 0)
158	#define FLAG_RCODE_NXDOMAIN ( 3 << 0)	443	#define FLAG_RCODE_NXDOMAIN ( 3 << 0)
159	#define FLAG_RCODE_REFUSED ( 5 << 0)	444	#define FLAG_RCODE_REFUSED ( 5 << 0)
160		445
161	#define DEFAULT_CLIENT_FLAGS (FLAG_QUERY \| FLAG_OP_QUERY \| FLAG_RD)	446	#define DEFAULT_CLIENT_FLAGS (FLAG_QUERY \| FLAG_OP_QUERY \| FLAG_RD)
162	#define DEFAULT_SERVER_FLAGS (FLAG_RESPONSE \| FLAG_OP_QUERY \| FLAG_AA \| FLAG_RD)	447	#define DEFAULT_SERVER_FLAGS (FLAG_RESPONSE \| FLAG_OP_QUERY \| FLAG_AA \| FLAG_RD \| FLAG_RA)
		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	}
163		541
164	struct dns_packet : net_packet	542	struct dns_packet : net_packet
165	{	543	{
166	u16 id;	544	u16 id;
167	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
168	u16 qdcount, ancount, nscount, arcount;	546	u16 qdcount, ancount, nscount, arcount;
169		547
170	u8 data[MAXSIZE - 6 * 2];	548	u8 data [MAXSIZE - 6 * 2];
171		549
172	int decode_label (char *data, int size, int &offs);	550	int decode_label (char *data, int size, int &offs);
173	};	551	};
174		552
		553	int
175	int dns_packet::decode_label (char *data, int size, int &offs)	554	dns_packet::decode_label (char *data, int size, int &offs)
176	{	555	{
177	char *orig = data;	556	char *orig = data;
178		557
179	memset (data, 0, size);	558	memset (data, 0, size);
180		559
…		…
204	}	583	}
205		584
206	return data - orig;	585	return data - orig;
207	}	586	}
208		587
		588	/////////////////////////////////////////////////////////////////////////////
		589
		590	static
		591	u16 next_id ()
		592	{
		593	static u16 dns_id = 0; // TODO: should be per-vpn
		594
		595	if (!dns_id)
		596	dns_id = time (0);
		597
		598	// the simplest lsfr with periodicity 65535 i could find
		599	dns_id = (dns_id << 1)
		600	\| (((dns_id >> 1)
		601	^ (dns_id >> 2)
		602	^ (dns_id >> 4)
		603	^ (dns_id >> 15)) & 1);
		604
		605	return dns_id;
		606	}
		607
209	struct dns_cfg	608	struct dns_rcv;
		609	struct dns_snd;
		610
		611	struct dns_connection
210	{	612	{
211	u8 id1, id2, id3;	613	connection *c;
212	u8 def_ttl;	614	struct vpn *vpn;
213	u8 unused1;	615
214	u16 max_size;	616	dns_cfg cfg;
215	u8 flags1, flags2;	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 ();
216	};	639	};
217		640
218	// reply to client-poll	641	struct dns_snd
219	void dnsv4_poll (dns_packet *pkt, int &offs)
220	{	642	{
221	int dlen = MAX_PKT_SIZE - offs - 2;	643	dns_packet *pkt;
		644	tstamp timeout, sent;
		645	int retry;
		646	struct dns_connection *dns;
		647	int seqno;
		648	bool stdhdr;
222		649
		650	void gen_stream_req (int seqno, byte_stream &stream);
		651	void gen_syn_req ();
		652
		653	dns_snd (dns_connection *dns);
		654	~dns_snd ();
		655	};
		656
		657	dns_snd::dns_snd (dns_connection *dns)
		658	: dns (dns)
		659	{
		660	timeout = 0;
		661	retry = 0;
		662	seqno = 0;
		663	sent = ev_now ();
		664	stdhdr = false;
		665
		666	pkt = new dns_packet;
		667
		668	pkt->id = next_id ();
		669	}
		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
223	(*pkt) [offs++] = 0;	689	pkt [offs++] = len;
224	(*pkt) [offs++] = 5;	690	memcpy (pkt.at (offs), domain, len);
225	memcpy (&((*pkt)[offs]), "\01H\02\xff\x00", 5);	691	offs += len;
226	offs += 5;
227		692
228	pkt->ancount = htons (1);	693	if (!*end)
229	pkt->flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	694	break;
230		695
231	printf ("we have room for %d bytes\n", dlen);	696	domain = end + 1;
		697	}
232	}	698	}
233		699
234	void	700	void
		701	dns_snd::gen_stream_req (int seqno, byte_stream &stream)
		702	{
		703	stdhdr = true;
		704	this->seqno = seqno;
		705
		706	timeout = ev_now () + INITIAL_TIMEOUT;
		707
		708	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
		709	pkt->qdcount = htons (1);
		710
		711	int offs = 6*2;
		712	int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
		713	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,
		714	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
		715
		716	char enc[256], *encp = enc;
		717	encode_header (enc, THISNODE->id, seqno);
		718
		719	int datalen = dns->cdc->decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
		720
		721	if (datalen > stream.size ())
		722	datalen = stream.size ();
		723
		724	int enclen = dns->cdc->encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
		725	stream.remove (datalen);
		726
		727	while (enclen)
		728	{
		729	int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
		730
		731	(*pkt)[offs++] = lbllen;
		732	memcpy (pkt->at (offs), encp, lbllen);
		733
		734	offs += lbllen;
		735	encp += lbllen;
		736
		737	enclen -= lbllen;
		738	}
		739
		740	append_domain (*pkt, offs, dns->c->conf->domain);
		741
		742	(*pkt)[offs++] = 0;
		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;
		769	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
		770
		771	pkt->len = offs;
		772	}
		773
		774	struct dns_rcv
		775	{
		776	int seqno;
		777	dns_packet *pkt; // reply packet
		778	u8 data [MAXSIZE]; // actually part of the reply packet...
		779	int datalen;
		780
		781	dns_rcv (int seqno, u8 *data, int datalen);
		782	~dns_rcv ();
		783	};
		784
		785	dns_rcv::dns_rcv (int seqno, u8 *data, int datalen)
		786	: seqno (seqno), pkt (new dns_packet), datalen (datalen)
		787	{
		788	memcpy (this->data, data, datalen);
		789	}
		790
		791	dns_rcv::~dns_rcv ()
		792	{
		793	delete pkt;
		794	}
		795
		796	/////////////////////////////////////////////////////////////////////////////
		797
		798	dns_connection::dns_connection (connection *c)
		799	: c (c)
		800	, rcvdq (MAX_BACKLOG * 2)
		801	, snddq (MAX_BACKLOG)
		802	{
		803	tw.set<dns_connection, &dns_connection::time_cb> (this);
		804
		805	vpn = c->vpn;
		806
		807	reset ();
		808	}
		809
		810	dns_connection::~dns_connection ()
		811	{
		812	reset ();
		813	}
		814
		815	void
		816	dns_connection::reset ()
		817	{
		818	while (!rcvpq.empty ())
		819	{
		820	delete rcvpq.back ();
		821	rcvpq.pop_back ();
		822	}
		823
		824	for (int i = vpn->dns_sndpq.size (); i--; )
		825	if (vpn->dns_sndpq [i]->dns == this)
		826	{
		827	vpn->dns_sndpq [i] = vpn->dns_sndpq.back ();
		828	vpn->dns_sndpq.pop_back ();
		829	}
		830
		831	established = false;
		832
		833	rcvseq = repseq = sndseq = 0;
		834
		835	last_sent = 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
		848	dns_connection::receive_rep (dns_rcv *r)
		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
		855	rcvpq.push_back (r);
		856
		857	redo:
		858
		859	// find next packet
		860	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
		861	if (SEQNO_EQ (rcvseq, (*i)->seqno))
		862	{
		863	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
		864	// enter the packet into our input stream
		865	r = *i;
		866
		867	// remove the oldest packet, look forward, as it's oldest first
		868	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
		869	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
		870	{
		871	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
		872	delete *j;
		873	rcvpq.erase (j);
		874	break;
		875	}
		876
		877	rcvseq = (rcvseq + 1) & SEQNO_MASK;
		878
		879	if (!rcvdq.put (r->data, r->datalen))
		880	{
		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	}
		886
		887	while (vpn_packet *pkt = rcvdq.get ())
		888	{
		889	sockinfo si;
		890	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
		891
		892	vpn->recv_vpn_packet (pkt, si);
		893	delete pkt;
		894	}
		895
		896	// check for further packets
		897	goto redo;
		898	}
		899	}
		900
		901	void
		902	vpn::dnsv4_server (dns_packet &pkt)
		903	{
		904	u16 flags = ntohs (pkt.flags);
		905
		906	int offs = 6 * 2; // skip header
		907
		908	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
		909
		910	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
		911	&& pkt.qdcount == htons (1))
		912	{
		913	char qname [MAXSIZE];
		914	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
		915
		916	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
		917	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
		918
		919	pkt.qdcount = htons (1);
		920	pkt.ancount = 0;
		921	pkt.nscount = 0; // should be self, as other nameservers reply like this
		922	pkt.arcount = 0; // a record for self, as other nameservers reply like this
		923
		924	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_SERVFAIL);
		925
		926	int dlen = strlen (THISNODE->domain);
		927
		928	if (qclass == RR_CLASS_IN
		929	&& qlen > dlen + 1
		930	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
		931	{
		932	// now generate reply
		933	pkt.ancount = htons (1); // one answer RR
		934	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
		935
		936	if ((qtype == RR_TYPE_ANY
		937	\|\| qtype == RR_TYPE_TXT
		938	\|\| qtype == RR_TYPE_NULL)
		939	&& qlen > dlen + 1 + HDRSIZE)
		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	{
		947	connection *c = conns [client - 1];
		948	dns_connection *dns = c->dns;
		949	dns_rcv *rcv;
		950
		951	if (dns)
		952	{
		953	u8 data[MAXSIZE];
		954	int datalen = dns->cdc->decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
		955
		956	for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
		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
		978	{
		979	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
		980
		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
		986
		987	int rdlen_offs = offs += 2;
		988
		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	}
		1044	}
		1045
		1046	duplicate_request: ;
		1047	}
		1048	else
		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);
		1057
		1058	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
		1059
		1060	pkt [offs++] = RR_TYPE_A >> 8; pkt [offs++] = RR_TYPE_A; // type
		1061	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
		1062	pkt [offs++] = 0; pkt [offs++] = 0;
		1063	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
		1064	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
		1065
		1066	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
		1067	pkt [offs++] = CMD_IP_REJ;
		1068
		1069	if (0 < client && client <= conns.size ())
		1070	{
		1071	connection *c = conns [client - 1];
		1072
		1073	if (cfg.valid ())
		1074	{
		1075	slog (L_INFO, _("DNS: client %d connects (version %d, req_cdc %d)"), client, cfg.version, cfg.req_cdc);
		1076
		1077	// check for any encoding mismatches - hints at a case problem
		1078	char qname2 [MAX_ENC_LEN];
		1079	cdc26.encode (qname2, (u8 *)&cfg, sizeof (dns_cfg));
		1080
		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	}
		1090	}
		1091	}
		1092	}
		1093
		1094	pkt.len = offs;
		1095	}
		1096	}
		1097
		1098	void
		1099	vpn::dnsv4_client (dns_packet &pkt)
		1100	{
		1101	u16 flags = ntohs (pkt.flags);
		1102	int offs = 6 * 2; // skip header
		1103
		1104	pkt.qdcount = ntohs (pkt.qdcount);
		1105	pkt.ancount = ntohs (pkt.ancount);
		1106
		1107	// go through our request list and find the corresponding request
		1108	for (vector<dns_snd *>::iterator i = dns_sndpq.begin ();
		1109	i != dns_sndpq.end ();
		1110	++i)
		1111	if ((*i)->pkt->id == pkt.id)
		1112	{
		1113	dns_connection dns = (i)->dns;
		1114	connection *c = dns->c;
		1115	int seqno = (*i)->seqno;
		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	}
		1143
		1144	delete *i;
		1145	dns_sndpq.erase (i);
		1146
		1147	if (flags & FLAG_RESPONSE && !(flags & FLAG_OP_MASK))
		1148	{
		1149	char qname[MAXSIZE];
		1150
		1151	while (pkt.qdcount-- && offs < MAXSIZE - 4)
		1152	{
		1153	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
		1154	offs += 4; // skip qtype, qclass
		1155	}
		1156
		1157	while (pkt.ancount-- && offs < MAXSIZE - 10 && datap)
		1158	{
		1159	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
		1160
		1161	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
		1162	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
		1163	u32 ttl = pkt [offs++] << 24;
		1164	ttl \|= pkt [offs++] << 16;
		1165	ttl \|= pkt [offs++] << 8;
		1166	ttl \|= pkt [offs++];
		1167	u16 rdlen = pkt [offs++] << 8; rdlen \|= pkt [offs++];
		1168
		1169	if (qtype == RR_TYPE_NULL \|\| qtype == RR_TYPE_TXT \|\| qtype == dns->cfg.rrtype)
		1170	{
		1171	if (rdlen <= MAXSIZE - offs)
		1172	{
		1173	// decode bytes, finally
		1174
		1175	while (rdlen)
		1176	{
		1177	int txtlen = pkt [offs++];
		1178
		1179	assert (txtlen + offs < MAXSIZE - 1);
		1180
		1181	memcpy (datap, pkt.at (offs), txtlen);
		1182	datap += txtlen; offs += txtlen;
		1183
		1184	rdlen -= txtlen + 1;
		1185	}
		1186	}
		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	}
		1247
		1248	int client, rseqno;
		1249	decode_header (qname, client, rseqno);
		1250
		1251	if (client != THISNODE->id)
		1252	{
		1253	slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
		1254	datap = 0;
		1255	}
		1256	else if (rseqno != seqno)
		1257	{
		1258	slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
		1259	datap = 0;
		1260	}
		1261	}
		1262	}
		1263
		1264	// todo: pkt now used
		1265	if (datap)
		1266	dns->receive_rep (new dns_rcv (seqno, data, datap - data));
		1267
		1268	break;
		1269	}
		1270	}
		1271
		1272	void
235	vpn::dnsv4_ev (io_watcher &w, short revents)	1273	vpn::dnsv4_ev (ev::io &w, int revents)
236	{	1274	{
237	if (revents & EVENT_READ)	1275	if (revents & EV_READ)
238	{	1276	{
239	dns_packet *pkt = new dns_packet;	1277	dns_packet *pkt = new dns_packet;
240	struct sockaddr_in sa;	1278	struct sockaddr_in sa;
241	socklen_t sa_len = sizeof (sa);	1279	socklen_t sa_len = sizeof (sa);
242		1280
243	int 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);
244	pkt->len = len;
245		1282
246	u16 flags = ntohs (pkt->flags);	1283	if (pkt->len > 0)
247
248	if (THISNODE->dns_port)
249	{	1284	{
250	// server	1285	if (ntohs (pkt->flags) & FLAG_RESPONSE)
251	pkt->flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	1286	dnsv4_client (*pkt);
252		1287	else
253	int offs = 6 * 2; // skip header
254
255	if (!(flags & (FLAG_RESPONSE \| FLAG_OP_MASK \| FLAG_TC))
256	&& pkt->qdcount == htons (1))
257	{	1288	{
258	char qname[MAXSIZE];	1289	dnsv4_server (*pkt);
259	int qlen = pkt->decode_label ((char *)qname, MAXSIZE, offs);	1290	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
260
261	printf ("rcvd packet len %d, id%04x flags%04x q%04x a%04x n%04x a%04x <%s>\n", len,
262	pkt->id, flags, pkt->qdcount, pkt->ancount, pkt->nscount, pkt->arcount, qname);//D
263
264	u16 qtype = (pkt) [offs++] << 8; qtype \|= (pkt) [offs++];
265	u16 qclass = (pkt) [offs++] << 8; qclass \|= (pkt) [offs++];
266
267	pkt->qdcount = htons (1);
268	pkt->ancount = 0;
269	pkt->nscount = 0; // should be self, as other nameservers reply like this
270	pkt->arcount = 0; // a record for self, as other nameservers reply like this
271
272	pkt->flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_NXDOMAIN);
273
274	int dlen = strlen (THISNODE->domain);
275
276	if (qclass == RR_CLASS_IN
277	&& (qtype == RR_TYPE_ANY \|\| qtype == RR_TYPE_TXT)
278	&& qlen > dlen + 1
279	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))
280	{
281	// correct class, now generate reply
282	pkt->ancount = htons (1); // one answer RR
283
284	(*pkt) [offs++] = 0xc0;
285	(pkt) [offs++] = 6 2; // same as in query section
286
287	(pkt) [offs++] = RR_TYPE_TXT >> 8; (pkt) [offs++] = RR_TYPE_TXT;
288	(pkt) [offs++] = RR_CLASS_IN >> 8; (pkt) [offs++] = RR_CLASS_IN;
289
290	(pkt) [offs++] = 0; (pkt) [offs++] = 0;
291	(pkt) [offs++] = 0; (pkt) [offs++] = 0; // TTL
292
293	dnsv4_poll (pkt, offs);
294	printf ("correct class\n");
295	}
296	}	1291	}
297		1292
298	sendto (w.fd, &((pkt)[0]), offs, 0, (sockaddr )&sa, sa_len);	1293	delete pkt;
		1294	}
		1295	}
		1296	}
		1297
		1298	bool
		1299	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
		1300	{
		1301	int client = ntohl (si.host);
		1302
		1303	assert (0 < client && client <= conns.size ());
		1304
		1305	connection *c = conns [client - 1];
		1306
		1307	if (!c->dns)
		1308	c->dns = new dns_connection (c);
		1309
		1310	if (c->dns->snddq.put (pkt))
		1311	{
		1312	min_it (c->dns->poll_interval, 0.25);
		1313	c->dns->tw ();
		1314	}
		1315
		1316	// always return true even if the buffer overflows
		1317	return true;
		1318	}
		1319
		1320	void
		1321	dns_connection::time_cb (ev::timer &w, int revents)
		1322	{
		1323	// servers have to be polled
		1324	if (THISNODE->dns_port)
		1325	return;
		1326
		1327	// check for timeouts and (re)transmit
		1328	tstamp next = 86400 * 365;
		1329	dns_snd *send = 0;
		1330
		1331	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
		1332	i != vpn->dns_sndpq.end ();
		1333	++i)
		1334	{
		1335	dns_snd r = i;
		1336
		1337	if (r->timeout <= ev_now ())
		1338	{
		1339	if (!send)
		1340	{
		1341	send = r;
		1342
		1343	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);
		1351	}
299	}	1352	}
300	else	1353	else
		1354	min_it (next, r->timeout - ev_now ());
		1355	}
		1356
		1357	if (!send)
		1358	{
		1359	// generate a new packet, if wise
		1360
		1361	if (!established)
301	{	1362	{
302	// client	1363	if (vpn->dns_sndpq.empty ())
		1364	{
		1365	send = new dns_snd (this);
		1366
		1367	cfg.reset (THISNODE->id);
		1368	set_cfg ();
		1369	send->gen_syn_req ();
		1370	}
303	}	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);
		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)
		1393	vpn->dns_sndpq.push_back (send);
		1394	}
		1395
		1396	if (send)
304	}	1397	{
305	}	1398	last_sent = ev_now ();
		1399	sendto (vpn->dnsv4_fd,
		1400	send->pkt->at (0), send->pkt->len, 0,
		1401	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
		1402	}
306		1403
307	bool	1404	min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ());
308	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1405
309	{	1406	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
310	//return i->send_packet (pkt, tos);	1407	poll_interval, send_interval, next - ev_now (),
		1408	vpn->dns_sndpq.size (), snddq.size (),
		1409	rcvpq.size ());
		1410
		1411	w.start (next);
311	}	1412	}
312		1413
313	#endif	1414	#endif
314		1415

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.2 by pcg, Tue Mar 1 04:38:21 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.2 by pcg, Tue Mar 1 04:38:21 2005 UTC vs.
Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC