ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/vpn_dns.C
(Generate patch)

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.5 by pcg, Thu Mar 3 07:24:57 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-2004 Marc Lehmann <pcg@goof.com> 3 Copyright (C) 2003-2008 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#define MIN_RETRY 1. 64#define MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data
45#define MAX_RETRY 60. 65#define ACTIVITY_INTERVAL 5.
46 66
47#define MAX_OUTSTANDING 40 // 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
48#define MAX_WINDOW 100 // max. for MAX_OUTSTANDING 72#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
49#define MAX_RATE 1000 // requests/s
50#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
51 74
52#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
53// 240 leaves about 4 bytes of server reply data 76// 240 leaves about 4 bytes of server reply data
54// every two request byte sless give room for one reply byte 77// every request byte less give room for two reply bytes
55 78
56#define SEQNO_MASK 0xffff 79#define SEQNO_MASK 0x3fff
57 80#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
58/*
59
60protocol, in shorthand :)
61
62client -> server <req> ANY?
63server -> client <req> TXT <rep>
64
65<req> is dns64-encoded <client-id:12><recv-seqno:10>[<send-seqno:10><data>]
66<rep> is dns64-encoded <0:12><recv-seqno:10>[<send-seqno:10><data>]
67
68if <client-id> is zero, the connection will be configured:
69
70<0:12><0:4>client-id:12><default-ttl:8><max-size:16><flags:16>
71
72*/
73 81
74#define MAX_LBL_SIZE 63 82#define MAX_LBL_SIZE 63
75#define MAX_PKT_SIZE 512 83#define MAX_PKT_SIZE 512
76 84
85#define RR_TYPE_A 1
86#define RR_TYPE_NULL 10
77#define RR_TYPE_TXT 16 87#define RR_TYPE_TXT 16
88#define RR_TYPE_AAAA 28
78#define RR_TYPE_ANY 255 89#define RR_TYPE_ANY 255
90
79#define RR_CLASS_IN 1 91#define RR_CLASS_IN 1
80 92
81// the "_" is not valid but widely accepted (all octets should be supported, but let's be conservative) 93#define CMD_IP_1 207
82struct dns64 94#define CMD_IP_2 46
83{ 95#define CMD_IP_3 236
84 static const char encode_chars[64 + 1]; 96#define CMD_IP_RST 29
85 static s8 decode_chars[256]; 97#define CMD_IP_SYN 113
98#define CMD_IP_REJ 32
86 99
87 static int encode_len (int bytes) { return (bytes * 8 + 5) / 6; } 100// works for cmaps up to 255 (not 256!)
88 static int decode_len (int bytes) { return (bytes * 6) / 8; } 101struct charmap
102{
103 enum { INVALID = (u8)255 };
104
105 char encode [256]; // index => char
106 u8 decode [256]; // char => index
107 unsigned int size;
108
109 charmap (const char *cmap);
110};
111
112charmap::charmap (const char *cmap)
113{
114 char *enc = encode;
115 u8 *dec = decode;
116
117 memset (enc, (char) 0, 256);
118 memset (dec, (char)INVALID, 256);
119
120 for (size = 0; cmap [size]; size++)
121 {
122 enc [size] = cmap [size];
123 dec [(u8)enc [size]] = size;
124 }
125
126 assert (size < 256);
127}
128
129#define MAX_DEC_LEN 500
130#define MAX_ENC_LEN (MAX_DEC_LEN * 2)
131#define MAX_LIMBS ((MAX_DEC_LEN * 8 + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS)
132
133// ugly. minimum base is 16(!)
134struct basecoder
135{
136 charmap cmap;
137 unsigned int enc_len [MAX_DEC_LEN];
138 unsigned int dec_len [MAX_ENC_LEN];
139
140 unsigned int encode_len (unsigned int len);
141 unsigned int decode_len (unsigned int len);
142
89 static int encode (char *dst, u8 *src, int len); 143 unsigned int encode (char *dst, u8 *src, unsigned int len);
90 static int decode (u8 *dst, char *src, int len); 144 unsigned int decode (u8 *dst, char *src, unsigned int len);
91 145
92 dns64 (); 146 basecoder (const char *cmap);
93} dns64; 147};
94 148
95const char dns64::encode_chars[64 + 1] = "_4B9dLphHzrqQmGjkTbJt5svlZX8xSaReEYfwKgF1DP2W6NyVOU70IouACcMn3i-"; 149basecoder::basecoder (const char *cmap)
96s8 dns64::decode_chars[256]; 150: cmap (cmap)
97
98dns64::dns64 ()
99{ 151{
100 for (int i = 0; i < 64; i++) 152 for (unsigned int len = 0; len < MAX_DEC_LEN; ++len)
101 decode_chars [encode_chars [i]] = i + 1; 153 {
102} 154 u8 src [MAX_DEC_LEN];
155 u8 dst [MAX_ENC_LEN];
103 156
157 memset (src, 255, len);
158
159 mp_limb_t m [MAX_LIMBS];
160 mp_size_t n;
161
162 n = mpn_set_str (m, src, len, 256);
163 n = mpn_get_str (dst, this->cmap.size, m, n);
164
165 for (int i = 0; !dst [i]; ++i)
166 n--;
167
168 enc_len [len] = n;
169 dec_len [n] = len;
170 }
171}
172
173unsigned int
174basecoder::encode_len (unsigned int len)
175{
176 return enc_len [len];
177}
178
179unsigned int
180basecoder::decode_len (unsigned int len)
181{
182 while (len && !dec_len [len])
183 --len;
184
185 return dec_len [len];
186}
187
188unsigned int
104int dns64::encode (char *dst, u8 *src, int len) 189basecoder::encode (char *dst, u8 *src, unsigned int len)
105{ 190{
106 // slow, but easy to debug 191 if (!len || len > MAX_DEC_LEN)
107 char *beg = dst; 192 return 0;
108 unsigned int accum, bits = 0; 193
194 int elen = encode_len (len);
195
196 mp_limb_t m [MAX_LIMBS];
197 mp_size_t n;
198
199 u8 dst_ [MAX_ENC_LEN];
200
201 n = mpn_set_str (m, src, len, 256);
202 n = mpn_get_str (dst_, cmap.size, m, n);
203
204 int plen = elen; // for padding
205
206 while (n < plen)
207 {
208 *dst++ = cmap.encode [0];
209 plen--;
210 }
211
212 for (unsigned int i = n - plen; i < n; ++i)
213 *dst++ = cmap.encode [dst_ [i]];
214
215 return elen;
216}
217
218unsigned int
219basecoder::decode (u8 *dst, char *src, unsigned int len)
220{
221 if (!len || len > MAX_ENC_LEN)
222 return 0;
223
224 u8 src_ [MAX_ENC_LEN];
225 unsigned int elen = 0;
109 226
110 while (len--) 227 while (len--)
111 { 228 {
112 accum <<= 8; 229 u8 val = cmap.decode [(u8)*src++];
113 accum |= *src++;
114 bits += 8;
115 230
116 while (bits >= 6) 231 if (val != charmap::INVALID)
117 { 232 src_ [elen++] = val;
118 *dst++ = encode_chars [(accum >> (bits - 6)) & 63]; 233 }
119 bits -= 6; 234
120 } 235 int dlen = decode_len (elen);
236
237 mp_limb_t m [MAX_LIMBS];
238 mp_size_t n;
239
240 u8 dst_ [MAX_DEC_LEN];
241
242 n = mpn_set_str (m, src_, elen, cmap.size);
243 n = mpn_get_str (dst_, 256, m, n);
244
245 if (n < dlen)
121 } 246 {
247 memset (dst, 0, dlen - n);
248 memcpy (dst + dlen - n, dst_, n);
249 }
250 else
251 memcpy (dst, dst_ + n - dlen, dlen);
122 252
123 if (bits) 253 return dlen;
124 *dst++ = encode_chars [(accum << (6 - bits)) & 63];
125
126 return dst - beg;
127} 254}
128 255
129int dns64::decode (u8 *dst, char *src, int len) 256#if 0
130{ 257struct test { test (); } test;
131 // slow, but easy to debug
132 u8 *beg = dst;
133 unsigned int accum, bits = 0;
134 258
135 while (len--) 259test::test ()
260{
261 basecoder cdc ("0123456789abcdefghijklmnopqrstuvwxyz");
262
263 u8 in[] = "0123456789abcdefghijklmnopqrstuvwxyz";
264 static char enc[200];
265 static u8 dec[200];
266
267 for (int i = 1; i < 20; i++)
136 { 268 {
137 s8 chr = decode_chars [(u8)*src++]; 269 int elen = cdc.encode (enc, in, i);
270 int dlen = cdc.decode (dec, enc, elen);
138 271
139 if (!chr) 272 printf ("%d>%d>%d (%s>%s)\n", i, elen, dlen, enc, dec);
140 continue;
141
142 accum <<= 6;
143 accum |= chr - 1;
144 bits += 6;
145
146 while (bits >= 8)
147 {
148 *dst++ = accum >> (bits - 8);
149 bits -= 8;
150 }
151 } 273 }
274 abort ();
275}
276#endif
152 277
153 return dst - beg; 278//static basecoder cdc64 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI-");
279//static basecoder cdc63 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
280static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
281//static basecoder cdc36 ("dphzr06qmjkb34tsvl81xaef92wgyo57ucni"); // unused as of yet
282static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
283
284/////////////////////////////////////////////////////////////////////////////
285
286#define HDRSIZE 6
287
288inline void
289encode_header (char *data, int clientid, int seqno, int retry = 0)
290{
291 seqno &= SEQNO_MASK;
292
293 u8 hdr[3] = {
294 clientid,
295 (seqno >> 8) | (retry << 6),
296 seqno,
297 };
298
299 assert (clientid < 256);
300
301 cdc26.encode (data, hdr, 3);
302}
303
304inline void
305decode_header (char *data, int &clientid, int &seqno)
306{
307 u8 hdr[3];
308
309 cdc26.decode (hdr, data, HDRSIZE);
310
311 clientid = hdr[0];
312 seqno = ((hdr[1] << 8) | hdr[2]) & SEQNO_MASK;
154} 313}
155 314
156///////////////////////////////////////////////////////////////////////////// 315/////////////////////////////////////////////////////////////////////////////
157 316
158struct byte_stream 317struct byte_stream
… …
184byte_stream::~byte_stream () 343byte_stream::~byte_stream ()
185{ 344{
186 delete data; 345 delete data;
187} 346}
188 347
348void
189void byte_stream::remove (int count) 349byte_stream::remove (int count)
190{ 350{
191 if (count > fill) 351 if (count > fill)
192 abort (); 352 assert (count <= fill);
193 353
194 memmove (data, data + count, fill -= count); 354 memmove (data, data + count, fill -= count);
195} 355}
196 356
357bool
197bool byte_stream::put (u8 *data, unsigned int datalen) 358byte_stream::put (u8 *data, unsigned int datalen)
198{ 359{
199 if (maxsize - fill < datalen) 360 if (maxsize - fill < datalen)
200 return false; 361 return false;
201 362
202 memcpy (this->data + fill, data, datalen); fill += datalen; 363 memcpy (this->data + fill, data, datalen); fill += datalen;
203 364
204 return true; 365 return true;
205} 366}
206 367
368bool
207bool byte_stream::put (vpn_packet *pkt) 369byte_stream::put (vpn_packet *pkt)
208{ 370{
209 if (maxsize - fill < pkt->len + 2) 371 if (maxsize - fill < pkt->len + 2)
210 return false; 372 return false;
211 373
212 data [fill++] = pkt->len >> 8; 374 data [fill++] = pkt->len >> 8;
213 data [fill++] = pkt->len; 375 data [fill++] = pkt->len;
214 376
215 memcpy (data + fill, &((*pkt)[0]), pkt->len); fill += pkt->len; 377 memcpy (data + fill, pkt->at (0), pkt->len); fill += pkt->len;
216 378
217 return true; 379 return true;
218} 380}
219 381
220vpn_packet *byte_stream::get () 382vpn_packet *byte_stream::get ()
221{ 383{
384 unsigned int len;
385
386 for (;;)
387 {
222 int len = (data [0] << 8) | data [1]; 388 len = (data [0] << 8) | data [1];
223 389
224 printf ("get len %d, fill %d\n", len, fill);//D
225
226 if (len > MAXSIZE && fill >= 2) 390 if (len <= MAXSIZE || fill < 2)
227 abort (); // TODO handle this gracefully, connection reset 391 break;
228 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
229 if (fill < len + 2) 398 if (fill < len + 2)
230 return 0; 399 return 0;
231 400
232 vpn_packet *pkt = new vpn_packet; 401 vpn_packet *pkt = new vpn_packet;
233 402
234 pkt->len = len; 403 pkt->len = len;
235 memcpy (&((*pkt)[0]), data + 2, len); 404 memcpy (pkt->at (0), data + 2, len);
236 remove (len + 2); 405 remove (len + 2);
237 406
238 return pkt; 407 return pkt;
239} 408}
240 409
241///////////////////////////////////////////////////////////////////////////// 410/////////////////////////////////////////////////////////////////////////////
242 411
243#define FLAG_QUERY ( 0 << 15) 412#define FLAG_QUERY ( 0 << 15)
244#define FLAG_RESPONSE ( 1 << 15) 413#define FLAG_RESPONSE ( 1 << 15)
245#define FLAG_OP_MASK (15 << 14) 414#define FLAG_OP_MASK (15 << 11)
246#define FLAG_OP_QUERY ( 0 << 11) 415#define FLAG_OP_QUERY ( 0 << 11)
247#define FLAG_AA ( 1 << 10) 416#define FLAG_AA ( 1 << 10)
248#define FLAG_TC ( 1 << 9) 417#define FLAG_TC ( 1 << 9)
249#define FLAG_RD ( 1 << 8) 418#define FLAG_RD ( 1 << 8)
250#define FLAG_RA ( 1 << 7) 419#define FLAG_RA ( 1 << 7)
… …
257#define FLAG_RCODE_REFUSED ( 5 << 0) 426#define FLAG_RCODE_REFUSED ( 5 << 0)
258 427
259#define DEFAULT_CLIENT_FLAGS (FLAG_QUERY | FLAG_OP_QUERY | FLAG_RD) 428#define DEFAULT_CLIENT_FLAGS (FLAG_QUERY | FLAG_OP_QUERY | FLAG_RD)
260#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)
261 430
431struct 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
459int dns_cfg::next_uid;
460
461void
462dns_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
486bool
487dns_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
262struct dns_packet : net_packet 501struct dns_packet : net_packet
263{ 502{
264 u16 id; 503 u16 id;
265 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
266 u16 qdcount, ancount, nscount, arcount; 505 u16 qdcount, ancount, nscount, arcount;
267 506
268 u8 data[MAXSIZE - 6 * 2]; 507 u8 data [MAXSIZE - 6 * 2];
269 508
270 int decode_label (char *data, int size, int &offs); 509 int decode_label (char *data, int size, int &offs);
271}; 510};
272 511
512int
273int dns_packet::decode_label (char *data, int size, int &offs) 513dns_packet::decode_label (char *data, int size, int &offs)
274{ 514{
275 char *orig = data; 515 char *orig = data;
276 516
277 memset (data, 0, size); 517 memset (data, 0, size);
278 518
… …
304 return data - orig; 544 return data - orig;
305} 545}
306 546
307///////////////////////////////////////////////////////////////////////////// 547/////////////////////////////////////////////////////////////////////////////
308 548
309struct dns_req 549static
550u16 next_id ()
310{ 551{
311 dns_packet *pkt;
312 tstamp next;
313 int retry;
314 connection *conn;
315 int seqno;
316
317 dns_req (connection *c);
318 void gen_stream_req (int seqno, byte_stream *stream);
319};
320
321static u16 dns_id = 12098; // TODO: should be per-vpn 552 static u16 dns_id = 0; // TODO: should be per-vpn
322 553
323static u16 next_id () 554 if (!dns_id)
324{ 555 dns_id = time (0);
556
325 // the simplest lsfr with periodicity 65535 i could find 557 // the simplest lsfr with periodicity 65535 i could find
326 dns_id = (dns_id << 1) 558 dns_id = (dns_id << 1)
327 | (((dns_id >> 1) 559 | (((dns_id >> 1)
328 ^ (dns_id >> 2) 560 ^ (dns_id >> 2)
329 ^ (dns_id >> 4) 561 ^ (dns_id >> 4)
330 ^ (dns_id >> 15)) & 1); 562 ^ (dns_id >> 15)) & 1);
331 563
332 return dns_id; 564 return dns_id;
333} 565}
334 566
335dns_req::dns_req (connection *c) 567struct dns_rcv;
336: conn (c) 568struct dns_snd;
569
570struct dns_connection
337{ 571{
338 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
596struct 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
612dns_snd::dns_snd (dns_connection *dns)
613: dns (dns)
614{
615 timeout = 0;
339 retry = 0; 616 retry = 0;
617 seqno = 0;
618 sent = ev_now ();
619 stdhdr = false;
340 620
341 pkt = new dns_packet; 621 pkt = new dns_packet;
342 622
343 pkt->id = next_id (); 623 pkt->id = next_id ();
344} 624}
345 625
626dns_snd::~dns_snd ()
627{
628 delete pkt;
629}
630
631static void
632append_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
655void
346void dns_req::gen_stream_req (int seqno, byte_stream *stream) 656dns_snd::gen_stream_req (int seqno, byte_stream &stream)
347{ 657{
658 stdhdr = true;
348 this->seqno = seqno; 659 this->seqno = seqno;
660
661 timeout = ev_now () + INITIAL_TIMEOUT;
349 662
350 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 663 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
351 pkt->qdcount = htons (1); 664 pkt->qdcount = htons (1);
352 665
353 int offs = 6*2; 666 int offs = 6*2;
354 int dlen = MAX_DOMAIN_SIZE - strlen (THISNODE->domain) - 2; 667 int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
355 // 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,
356 // 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
357 670
358 u8 data[256]; //TODO
359
360 data[0] = THISNODE->id; //TODO
361 data[1] = seqno >> 8; //TODO
362 data[2] = seqno; //TODO
363
364 int datalen = dns64::decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE) - 3;
365
366 if (datalen > stream->size ())
367 datalen = stream->size ();
368
369 char enc[256], *encp = enc; 671 char enc[256], *encp = enc;
370 672 encode_header (enc, THISNODE->id, seqno);
371 memcpy (data + 3, stream->begin (), datalen); 673
372 int enclen = dns64::encode (enc, data, datalen + 3); 674 int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
675
676 if (datalen > stream.size ())
677 datalen = stream.size ();
678
679 int enclen = cdc62.encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
373 stream->remove (datalen); 680 stream.remove (datalen);
374 681
375 while (enclen) 682 while (enclen)
376 { 683 {
377 int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE; 684 int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
378 685
… …
383 encp += lbllen; 690 encp += lbllen;
384 691
385 enclen -= lbllen; 692 enclen -= lbllen;
386 } 693 }
387 694
388 const char *suffix = THISNODE->domain; 695 append_domain (*pkt, offs, dns->c->conf->domain);
389
390 // add tunnel domain
391 for (;;)
392 {
393 const char *end = strchr (suffix, '.');
394
395 if (!end)
396 end = suffix + strlen (suffix);
397
398 int len = end - suffix;
399
400 (*pkt)[offs++] = len;
401 memcpy (&((*pkt)[offs]), suffix, len);
402 offs += len;
403
404 if (!*end)
405 break;
406
407 suffix = end + 1;
408 }
409 696
410 (*pkt)[offs++] = 0; 697 (*pkt)[offs++] = 0;
411 (*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
704void
705dns_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;
412 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN; 724 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
413 725
414 pkt->len = offs; 726 pkt->len = offs;
415} 727}
416 728
… …
419 int seqno; 731 int seqno;
420 dns_packet *pkt; // reply packet 732 dns_packet *pkt; // reply packet
421 u8 data [MAXSIZE]; // actually part of the reply packet... 733 u8 data [MAXSIZE]; // actually part of the reply packet...
422 int datalen; 734 int datalen;
423 735
424 dns_rcv (int seqno, dns_packet *req, u8 *data, int datalen); 736 dns_rcv (int seqno, u8 *data, int datalen);
425 ~dns_rcv (); 737 ~dns_rcv ();
426}; 738};
427 739
428dns_rcv::dns_rcv (int seqno, dns_packet *req, u8 *data, int datalen) 740dns_rcv::dns_rcv (int seqno, u8 *data, int datalen)
429: seqno (seqno), pkt (new dns_packet), datalen (datalen) 741: seqno (seqno), pkt (new dns_packet), datalen (datalen)
430{ 742{
431 memcpy (this->data, data, datalen); 743 memcpy (this->data, data, datalen);
432 pkt->len = req->len;
433 memcpy (pkt->at (0), req->at (0), req->len);
434} 744}
435 745
436dns_rcv::~dns_rcv () 746dns_rcv::~dns_rcv ()
437{ 747{
438 delete pkt; 748 delete pkt;
439} 749}
440 750
441///////////////////////////////////////////////////////////////////////////// 751/////////////////////////////////////////////////////////////////////////////
442 752
443struct dns_cfg 753dns_connection::dns_connection (connection *c)
754: c (c)
755, rcvdq (MAX_BACKLOG * 2)
756, snddq (MAX_BACKLOG)
444{ 757{
445 u8 id1, id2, id3; 758 tw.set<dns_connection, &dns_connection::time_cb> (this);
446 u8 def_ttl;
447 u8 unused1;
448 u16 max_size;
449 u8 flags1, flags2;
450};
451 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
772dns_connection::~dns_connection ()
773{
774 for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
775 i != rcvpq.end ();
776 ++i)
777 delete *i;
778}
779
780void
452void connection::dnsv4_receive_rep (struct dns_rcv *r) 781dns_connection::receive_rep (dns_rcv *r)
453{ 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
454 dns_rcvpq.push_back (r); 798 rcvpq.push_back (r);
455 799
456 redo: 800 redo:
457 801
802 // find next packet
458 for (vector<dns_rcv *>::iterator i = dns_rcvpq.begin (); 803 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
459 i != dns_rcvpq.end ();
460 ++i)
461 if (dns_rcvseq == (*i)->seqno) 804 if (SEQNO_EQ (rcvseq, (*i)->seqno))
462 { 805 {
806 //printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
807 // enter the packet into our input stream
463 dns_rcv *r = *i; 808 r = *i;
464 809
810 // remove the oldest packet, look forward, as it's oldest first
811 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
812 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
813 {
814 //printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
815 delete *j;
816 rcvpq.erase (j);
817 break;
818 }
819
465 dns_rcvseq = (dns_rcvseq + 1) & SEQNO_MASK; 820 rcvseq = (rcvseq + 1) & SEQNO_MASK;
466 821
467 if (!dns_snddq && !dns_rcvdq) 822 if (!rcvdq.put (r->data, r->datalen))
468 { 823 {
469 dns_rcvdq = new byte_stream (MAX_BACKLOG * 2); 824 slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
470 dns_snddq = new byte_stream (MAX_BACKLOG); 825 abort (); // MUST never overflow, can be caused by data corruption, TODO
471
472 dns_si.set (::conf.dns_forw_host, ::conf.dns_forw_port, PROT_DNSv4);
473 } 826 }
474 827
475 if (!dns_rcvdq->put (r->data, r->datalen))
476 abort (); // MUST never overflow, can be caused by data corruption, TODO
477
478 while (vpn_packet *pkt = dns_rcvdq->get ()) 828 while (vpn_packet *pkt = rcvdq.get ())
479 { 829 {
480 sockinfo si; 830 sockinfo si;
481 si.host = 0; si.port = 0; si.prot = PROT_DNSv4; 831 si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
482 832
483 vpn->recv_vpn_packet (pkt, si); 833 vpn->recv_vpn_packet (pkt, si);
834
835 delete pkt;
484 } 836 }
485 } 837
486 else if ((u32)dns_rcvseq - MAX_WINDOW - (u32)(*i)->seqno < MAX_WINDOW * 2) 838 // check for further packets
487 {
488 dns_rcvpq.erase (i);
489 goto redo; 839 goto redo;
490 } 840 }
491} 841}
492 842
493dns_packet * 843void
494vpn::dnsv4_server (dns_packet *pkt) 844vpn::dnsv4_server (dns_packet &pkt)
495{ 845{
496 u16 flags = ntohs (pkt->flags); 846 u16 flags = ntohs (pkt.flags);
497 847
498 //memcpy (&((*rep)[0]), &((*pkt)[0]), pkt->len);
499 int offs = 6 * 2; // skip header 848 int offs = 6 * 2; // skip header
500 849
501 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR); 850 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
502 851
503 if (!(flags & (FLAG_RESPONSE | FLAG_OP_MASK | FLAG_TC)) 852 if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK))
504 && pkt->qdcount == htons (1)) 853 && pkt.qdcount == htons (1))
505 { 854 {
506 char qname[MAXSIZE]; 855 char qname [MAXSIZE];
507 int qlen = pkt->decode_label ((char *)qname, MAXSIZE - offs, offs); 856 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
508 857
509 u16 qtype = (*pkt) [offs++] << 8; qtype |= (*pkt) [offs++]; 858 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++];
510 u16 qclass = (*pkt) [offs++] << 8; qclass |= (*pkt) [offs++]; 859 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++];
511 860
512 pkt->qdcount = htons (1); 861 pkt.qdcount = htons (1);
513 pkt->ancount = 0; 862 pkt.ancount = 0;
514 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
515 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
516 865
517 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_NXDOMAIN); 866 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_SERVFAIL);
518 867
519 int dlen = strlen (THISNODE->domain); 868 int dlen = strlen (THISNODE->domain);
520 869
521 if (qclass == RR_CLASS_IN 870 if (qclass == RR_CLASS_IN
522 && (qtype == RR_TYPE_ANY || qtype == RR_TYPE_TXT)
523 && qlen > dlen + 1 871 && qlen > dlen + 1
524 && !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen)) 872 && !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
525 { 873 {
526 // correct class, domain: parse 874 // now generate reply
527 u8 data[MAXSIZE]; 875 pkt.ancount = htons (1); // one answer RR
528 int datalen = dns64::decode (data, qname, qlen - dlen - 1); 876 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK);
529 877
530 int client = data[0]; 878 if ((qtype == RR_TYPE_ANY
531 int seqno = ((data[1] << 8) | data[2]) & SEQNO_MASK; 879 || qtype == RR_TYPE_TXT
532 880 || qtype == RR_TYPE_NULL)
533 if (0 < client && client <= conns.size ()) 881 && qlen > dlen + 1 + HDRSIZE)
534 { 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 {
535 connection *c = conns [client - 1]; 892 connection *c = conns [client - 1];
893 dns_connection *dns = c->dns;
894 dns_rcv *rcv;
536 895
537 for (vector<dns_rcv *>::iterator i = c->dns_rcvpq.begin (); 896 if (dns)
538 i != c->dns_rcvpq.end ();
539 ++i) 897 {
898 for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
540 if ((*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
541 { 920 {
542 // already seen that request, just reply with the original reply 921 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
543 dns_rcv *r = *i;
544 922
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
928
929 int rdlen_offs = offs += 2;
930
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
545 offs = r->pkt->len; 983 rcv->pkt->len = offs;
546 memcpy (pkt->at (0), r->pkt->at (0), offs); 984 memcpy (rcv->pkt->at (0), pkt.at (0), offs);
547 goto duplicate_request; 985 }
548 } 986 }
549 987
550 // new packet, queue 988 duplicate_request: ;
551 c->dnsv4_receive_rep (new dns_rcv (seqno, pkt, data + 3, datalen - 3)); 989 }
552 990 else
553 // now generate reply
554 pkt->ancount = htons (1); // one answer RR
555 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);
556 999
557 (*pkt) [offs++] = 0xc0;
558 (*pkt) [offs++] = 6 * 2; // same as in query section 1000 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
559 1001
560 (*pkt) [offs++] = RR_TYPE_TXT >> 8; (*pkt) [offs++] = RR_TYPE_TXT; 1002 pkt [offs++] = RR_TYPE_A >> 8; pkt [offs++] = RR_TYPE_A; // type
561 (*pkt) [offs++] = RR_CLASS_IN >> 8; (*pkt) [offs++] = RR_CLASS_IN; 1003 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
562
563 (*pkt) [offs++] = 0; (*pkt) [offs++] = 0; 1004 pkt [offs++] = 0; pkt [offs++] = 0;
564 (*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
565 1007
566 int dlen = MAX_PKT_SIZE - offs - 2; 1008 slog (L_INFO, _("DNS: client %d connects"), client);
567 1009
568 // 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;
569 dlen -= qlen; 1011 pkt [offs++] = CMD_IP_REJ;
570 1012
571 int rdlen_offs = offs += 2; 1013 if (0 < client && client <= conns.size ())
572
573 while (c->dns_snddq
574 && !c->dns_snddq->empty ()
575 && dlen > 1)
576 { 1014 {
577 int txtlen = dlen <= 255 ? dlen - 1 : 255; 1015 connection *c = conns [client - 1];
578 1016
579 if (txtlen > c->dns_snddq->size ()) 1017 if (cfg.valid ())
580 txtlen = c->dns_snddq->size (); 1018 {
1019 pkt [offs - 1] = CMD_IP_SYN;
581 1020
582 (*pkt)[offs++] = txtlen; 1021 delete c->dns;
583 memcpy (pkt->at (offs), c->dns_snddq->begin (), txtlen); 1022 c->dns = new dns_connection (c);
584 offs += txtlen; 1023 c->dns->cfg = cfg;
585 c->dns_snddq->remove (txtlen); 1024 }
586
587 dlen -= txtlen + 1;
588 } 1025 }
589
590 // avoid empty TXT rdata
591 if (offs == rdlen_offs)
592 (*pkt)[offs++] = 0;
593
594 int rdlen = offs - rdlen_offs;
595
596 (*pkt) [rdlen_offs - 2] = rdlen >> 8;
597 (*pkt) [rdlen_offs - 1] = rdlen;
598
599 duplicate_request: ;
600 } 1026 }
601 else
602 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
603 } 1027 }
604 }
605 else
606 offs = pkt->len;
607 1028
608 pkt->len = offs; 1029 pkt.len = offs;
609 return pkt; 1030 }
610} 1031}
611 1032
612void 1033void
613vpn::dnsv4_client (dns_packet *pkt) 1034vpn::dnsv4_client (dns_packet &pkt)
614{ 1035{
615 u16 flags = ntohs (pkt->flags); 1036 u16 flags = ntohs (pkt.flags);
616 int offs = 6 * 2; // skip header 1037 int offs = 6 * 2; // skip header
617 1038
618 pkt->qdcount = ntohs (pkt->qdcount); 1039 pkt.qdcount = ntohs (pkt.qdcount);
619 pkt->ancount = ntohs (pkt->ancount); 1040 pkt.ancount = ntohs (pkt.ancount);
620 1041
621 // go through our request list and find the corresponding request 1042 // go through our request list and find the corresponding request
622 for (vector<dns_req *>::iterator i = dns_sndpq.begin (); 1043 for (vector<dns_snd *>::iterator i = dns_sndpq.begin ();
623 i != dns_sndpq.end (); 1044 i != dns_sndpq.end ();
624 ++i) 1045 ++i)
625 if ((*i)->pkt->id == pkt->id) 1046 if ((*i)->pkt->id == pkt.id)
626 { 1047 {
1048 dns_connection *dns = (*i)->dns;
627 connection *c = (*i)->conn; 1049 connection *c = dns->c;
628 int seqno = (*i)->seqno; 1050 int seqno = (*i)->seqno;
629 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 }
630 1078
631 delete *i; 1079 delete *i;
632 dns_sndpq.erase (i); 1080 dns_sndpq.erase (i);
633 1081
634 if (flags & (FLAG_RESPONSE | FLAG_OP_MASK | FLAG_TC)) 1082 if (flags & FLAG_RESPONSE && !(flags & FLAG_OP_MASK))
635 { 1083 {
636 char qname[MAXSIZE]; 1084 char qname[MAXSIZE];
637 1085
638 while (pkt->qdcount-- && offs < MAXSIZE - 4) 1086 while (pkt.qdcount-- && offs < MAXSIZE - 4)
639 { 1087 {
640 int qlen = pkt->decode_label ((char *)qname, MAXSIZE - offs, offs); 1088 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
641 offs += 4; // skip qtype, qclass 1089 offs += 4; // skip qtype, qclass
642 } 1090 }
643 1091
644 while (pkt->ancount-- && offs < MAXSIZE - 10) 1092 while (pkt.ancount-- && offs < MAXSIZE - 10 && datap)
645 { 1093 {
646 pkt->decode_label ((char *)qname, MAXSIZE - offs, offs); 1094 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
647 1095
648 u16 qtype = (*pkt) [offs++] << 8; qtype |= (*pkt) [offs++]; 1096 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++];
649 u16 qclass = (*pkt) [offs++] << 8; qclass |= (*pkt) [offs++]; 1097 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++];
650 u32 ttl = (*pkt) [offs++] << 24; 1098 u32 ttl = pkt [offs++] << 24;
651 ttl |= (*pkt) [offs++] << 16; 1099 ttl |= pkt [offs++] << 16;
652 ttl |= (*pkt) [offs++] << 8; 1100 ttl |= pkt [offs++] << 8;
653 ttl |= (*pkt) [offs++]; 1101 ttl |= pkt [offs++];
654
655 u16 rdlen = (*pkt) [offs++] << 8; rdlen |= (*pkt) [offs++]; 1102 u16 rdlen = pkt [offs++] << 8; rdlen |= pkt [offs++];
656 1103
657 if (rdlen <= MAXSIZE - offs) 1104 if (qtype == RR_TYPE_NULL || qtype == RR_TYPE_TXT)
658 { 1105 {
659 // decode bytes, finally 1106 if (rdlen <= MAXSIZE - offs)
660
661 while (rdlen)
662 { 1107 {
1108 // decode bytes, finally
1109
1110 while (rdlen)
1111 {
663 int txtlen = (*pkt) [offs++]; 1112 int txtlen = pkt [offs++];
664 1113
665 assert (txtlen + offs < MAXSIZE - 1); 1114 assert (txtlen + offs < MAXSIZE - 1);
666 1115
667 memcpy (datap, pkt->at (offs), txtlen); 1116 memcpy (datap, pkt.at (offs), txtlen);
668 datap += txtlen; offs += txtlen; 1117 datap += txtlen; offs += txtlen;
669 1118
670 rdlen -= txtlen + 1; 1119 rdlen -= txtlen + 1;
1120 }
671 } 1121 }
672
673 } 1122 }
1123 else if (qtype == RR_TYPE_A)
1124 {
1125 u8 ip [4];
674 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 }
675 } 1179 }
676 } 1180 }
677 1181
1182 // todo: pkt now used
678 if (datap != data) 1183 if (datap)
679 printf ("%02x %02x %02x %02x\n",
680 data[0],
681 data[1],
682 data[2],
683 data[3]);
684
685 printf ("recv %d,%d\n", pkt->id, seqno, datap - data);//D
686 c->dnsv4_receive_rep (new dns_rcv (seqno, pkt, data, datap - data)); 1184 dns->receive_rep (new dns_rcv (seqno, data, datap - data));
687 1185
688 break; 1186 break;
689 } 1187 }
690
691 delete pkt;
692} 1188}
693 1189
694void 1190void
695vpn::dnsv4_ev (io_watcher &w, short revents) 1191vpn::dnsv4_ev (ev::io &w, int revents)
696{ 1192{
697 if (revents & EVENT_READ) 1193 if (revents & EV_READ)
698 { 1194 {
699 dns_packet *pkt = new dns_packet; 1195 dns_packet *pkt = new dns_packet;
700 struct sockaddr_in sa; 1196 struct sockaddr_in sa;
701 socklen_t sa_len = sizeof (sa); 1197 socklen_t sa_len = sizeof (sa);
702 1198
703 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);
704 1200
705 if (pkt->len > 0) 1201 if (pkt->len > 0)
706 { 1202 {
707 if (pkt->flags & htons (FLAG_TC)) 1203 if (ntohs (pkt->flags) & FLAG_RESPONSE)
1204 dnsv4_client (*pkt);
1205 else
708 { 1206 {
709 slog (L_WARN, _("DNS request/response truncated, check protocol settings.")); 1207 dnsv4_server (*pkt);
710 //TODO connection reset 1208 sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
711 } 1209 }
712 1210
713 if (THISNODE->dns_port) 1211 delete pkt;
714 {
715 pkt = dnsv4_server (pkt);
716 sendto (w.fd, &((*pkt)[0]), pkt->len, 0, (sockaddr *)&sa, sa_len);
717 }
718 else
719 dnsv4_client (pkt);
720 } 1212 }
721 } 1213 }
722} 1214}
723 1215
724bool 1216bool
725connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 1217vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
726{ 1218{
727 // never initialized 1219 int client = ntohl (si.host);
728 if (!dns_snddq && !dns_rcvdq)
729 {
730 dns_rcvdq = new byte_stream (MAX_BACKLOG * 2);
731 dns_snddq = new byte_stream (MAX_BACKLOG);
732 1220
733 //dns_rcvseq = dns_sndseq = 0; 1221 assert (0 < client && client <= conns.size ());
734 1222
735 dns_si.set (::conf.dns_forw_host, ::conf.dns_forw_port, PROT_DNSv4); 1223 connection *c = conns [client - 1];
736 } 1224
1225 if (!c->dns)
1226 c->dns = new dns_connection (c);
737 1227
738 if (!dns_snddq->put (pkt)) 1228 if (c->dns->snddq.put (pkt))
739 return false; 1229 c->dns->tw ();
740 1230
741 // start timer if neccessary 1231 // always return true even if the buffer overflows
742 if (!THISNODE->dns_port && !dnsv4_tw.active)
743 dnsv4_cb (dnsv4_tw);
744
745 return true; 1232 return true;
746} 1233}
747 1234
748void 1235void
749connection::dnsv4_cb (time_watcher &w) 1236connection::dnsv4_reset_connection ()
750{ 1237{
1238 //delete dns; dns = 0; //TODO
1239}
1240
1241#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1242
1243void
1244dns_connection::time_cb (ev::timer &w, int revents)
1245{
1246 // servers have to be polled
1247 if (THISNODE->dns_port)
1248 return;
1249
751 // check for timeouts and (re)transmit 1250 // check for timeouts and (re)transmit
752 tstamp next = NOW + 60; 1251 tstamp next = ev::now () + poll_interval;
753 dns_req *send = 0; 1252 dns_snd *send = 0;
754 1253
755 for (vector<dns_req *>::iterator i = vpn->dns_sndpq.begin (); 1254 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
756 i != vpn->dns_sndpq.end (); 1255 i != vpn->dns_sndpq.end ();
757 ++i) 1256 ++i)
758 { 1257 {
759 dns_req *r = *i; 1258 dns_snd *r = *i;
760 1259
761 if (r->next <= NOW) 1260 if (r->timeout <= ev_now ())
762 { 1261 {
763 if (!send) 1262 if (!send)
764 { 1263 {
765 send = r; 1264 send = r;
766 1265
767 if (r->retry)//D
768 printf ("req %d, retry %d\n", r->pkt->id, r->retry);
769 r->retry++; 1266 r->retry++;
770 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);
771 } 1274 }
772 } 1275 }
773 1276 else
774 if (r->next < next) 1277 NEXT (r->timeout);
775 next = r->next;
776 } 1278 }
777 1279
778 if (!send 1280 if (!send)
779 && vpn->dns_sndpq.size () < MAX_OUTSTANDING)
780 { 1281 {
1282 // generate a new packet, if wise
1283
1284 if (!established)
1285 {
1286 if (vpn->dns_sndpq.empty ())
1287 {
781 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);
782 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)
783 vpn->dns_sndpq.push_back (send); 1318 vpn->dns_sndpq.push_back (send);
784
785 dns_sndseq = (dns_sndseq + 1) & SEQNO_MASK;
786 } 1319 }
787
788 tstamp min_next = NOW + (1. / (tstamp)MAX_RATE);
789 1320
790 if (send) 1321 if (send)
791 { 1322 {
792 dns_packet *pkt = send->pkt; 1323 last_sent = ev_now ();
793 1324 sendto (vpn->dnsv4_fd,
794 next = min_next; 1325 send->pkt->at (0), send->pkt->len, 0,
795 1326 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
796 sendto (vpn->dnsv4_fd, &((*pkt)[0]), pkt->len, 0, dns_si.sav4 (), dns_si.salenv4 ());
797 } 1327 }
798 else if (next < min_next)
799 next = min_next;
800 1328
801 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 ());
802} 1340}
803 1341
804#endif 1342#endif
805 1343

Diff Legend

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