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.3 by pcg, Tue Mar 1 06:27:20 2005 UTC vs.
Revision 1.22 by pcg, Sun Mar 6 21:47:35 2005 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-2005 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
6 it under the terms of the GNU General Public License as published by 8 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or 9 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version. 10 (at your 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,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 but 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
13 GNU General Public License for more details. 15 GNU General 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
16 along with this program; if not, write to the Free Software 18 along with gvpe; if not, write to the Free Software
17 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18*/ 20*/
19 21
20#include "config.h" 22#include "config.h"
21 23
… …
23 25
24// dns processing is EXTREMELY ugly. For obvious(?) reasons. 26// dns processing is EXTREMELY ugly. For obvious(?) reasons.
25// it's a hack, use only in emergency situations please. 27// it's a hack, use only in emergency situations please.
26 28
27#include <cstring> 29#include <cstring>
30#include <cassert>
28 31
29#include <sys/types.h> 32#include <sys/types.h>
30#include <sys/socket.h> 33#include <sys/socket.h>
31#include <sys/wait.h> 34#include <sys/wait.h>
32#include <sys/uio.h> 35#include <sys/uio.h>
… …
35#include <unistd.h> 38#include <unistd.h>
36#include <fcntl.h> 39#include <fcntl.h>
37 40
38#include <map> 41#include <map>
39 42
43#include <gmp.h>
44
40#include "netcompat.h" 45#include "netcompat.h"
41 46
42#include "vpn.h" 47#include "vpn.h"
43 48
44#define MIN_RETRY 1. 49#define MIN_POLL_INTERVAL .02 // how often to poll minimally when the server has data
45#define MAX_RETRY 60. 50#define MAX_POLL_INTERVAL 6. // how often to poll minimally when the server has no data
51#define ACTIVITY_INTERVAL 5.
52
53#define INITIAL_TIMEOUT 0.1 // retry timeouts
54#define INITIAL_SYN_TIMEOUT 10. // retry timeout for initial syn
55
56#define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests
57#define MAX_SEND_INTERVAL 0.5 // optimistic?
46 58
47#define MAX_OUTSTANDING 10 // max. outstanding requests 59#define MAX_OUTSTANDING 10 // max. outstanding requests
60#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
61#define MAX_BACKLOG (100*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
48 62
49/* 63#define MAX_DOMAIN_SIZE 220 // 255 is legal limit, but bind doesn't compress well
64// 240 leaves about 4 bytes of server reply data
65// every two request bytes less give room for one reply byte
50 66
51protocol, in shorthand :) 67#define SEQNO_MASK 0x3fff
52 68#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
53client -> server <req> ANY?
54server -> client <req> TXT <rep>
55
56<req> is dns64-encoded <client-id:12><recv-seqno:10>[<send-seqno:10><data>]
57<rep> is dns64-encoded <0:12><recv-seqno:10>[<send-seqno:10><data>]
58
59if <client-id> is zero, the connection will be configured:
60
61<0:12><0:4>client-id:12><default-ttl:8><max-size:16><flags:16>
62
63*/
64 69
65#define MAX_LBL_SIZE 63 70#define MAX_LBL_SIZE 63
66#define MAX_PKT_SIZE 512 71#define MAX_PKT_SIZE 512
67 72
73#define RR_TYPE_A 1
74#define RR_TYPE_NULL 10
68#define RR_TYPE_TXT 16 75#define RR_TYPE_TXT 16
69#define RR_TYPE_ANY 255 76#define RR_TYPE_ANY 255
77
70#define RR_CLASS_IN 1 78#define RR_CLASS_IN 1
71 79
72// the "_" is not valid but widely accepted (all octets should be supported, but let's be conservative) 80#define CMD_IP_1 207
73struct dns64 81#define CMD_IP_2 46
74{ 82#define CMD_IP_3 236
75 static const char encode_chars[64 + 1]; 83#define CMD_IP_RST 29
76 static s8 decode_chars[256]; 84#define CMD_IP_SYN 113
85#define CMD_IP_REJ 32
77 86
78 static int encode_len (int bytes) { return (bytes * 8 + 5) / 6; } 87// works for cmaps up to 255 (not 256!)
79 static int decode_len (int bytes) { return (bytes * 6) / 8; } 88struct charmap
89{
90 enum { INVALID = (u8)255 };
91
92 char encode [256]; // index => char
93 u8 decode [256]; // char => index
94 unsigned int size;
95
96 charmap (const char *cmap);
97};
98
99charmap::charmap (const char *cmap)
100{
101 char *enc = encode;
102 u8 *dec = decode;
103
104 memset (enc, (char) 0, 256);
105 memset (dec, (char)INVALID, 256);
106
107 for (size = 0; cmap [size]; size++)
108 {
109 enc [size] = cmap [size];
110 dec [(u8)enc [size]] = size;
111 }
112
113 assert (size < 256);
114}
115
116#define MAX_DEC_LEN 500
117#define MAX_ENC_LEN (MAX_DEC_LEN * 2)
118#define MAX_LIMBS ((MAX_DEC_LEN * 8 + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS)
119
120// ugly. minimum base is 16(!)
121struct basecoder
122{
123 charmap cmap;
124 unsigned int enc_len [MAX_DEC_LEN];
125 unsigned int dec_len [MAX_ENC_LEN];
126
127 unsigned int encode_len (unsigned int len);
128 unsigned int decode_len (unsigned int len);
129
80 static void encode (char *dst, u8 *src, int len); 130 unsigned int encode (char *dst, u8 *src, unsigned int len);
81 static void decode (u8 *dst, char *src, int len); 131 unsigned int decode (u8 *dst, char *src, unsigned int len);
82 132
83 dns64 (); 133 basecoder (const char *cmap);
84} dns64; 134};
85 135
86const char dns64::encode_chars[64 + 1] = "0123456789-abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 136basecoder::basecoder (const char *cmap)
87s8 dns64::decode_chars[256]; 137: cmap (cmap)
88
89dns64::dns64 ()
90{ 138{
91 for (int i = 0; i < 64; i++) 139 for (unsigned int len = 0; len < MAX_DEC_LEN; ++len)
92 decode_chars [encode_chars [i]] = i + 1; 140 {
93} 141 u8 src [MAX_DEC_LEN];
142 u8 dst [MAX_ENC_LEN];
94 143
95void dns64::encode (char *dst, u8 *src, int len) 144 memset (src, 255, len);
145
146 mp_limb_t m [MAX_LIMBS];
147 mp_size_t n;
148
149 n = mpn_set_str (m, src, len, 256);
150 n = mpn_get_str (dst, this->cmap.size, m, n);
151
152 for (int i = 0; !dst [i]; ++i)
153 n--;
154
155 enc_len [len] = n;
156 dec_len [n] = len;
157 }
158}
159
160unsigned int basecoder::encode_len (unsigned int len)
96{ 161{
97 // slow, but easy to debug 162 return enc_len [len];
98 unsigned int accum, bits = 0; 163}
164
165unsigned int basecoder::decode_len (unsigned int len)
166{
167 while (len && !dec_len [len])
168 --len;
169
170 return dec_len [len];
171}
172
173unsigned int basecoder::encode (char *dst, u8 *src, unsigned int len)
174{
175 if (!len || len > MAX_DEC_LEN)
176 return 0;
177
178 int elen = encode_len (len);
179
180 mp_limb_t m [MAX_LIMBS];
181 mp_size_t n;
182
183 u8 dst_ [MAX_ENC_LEN];
184
185 n = mpn_set_str (m, src, len, 256);
186 n = mpn_get_str (dst_, cmap.size, m, n);
187
188 int plen = elen; // for padding
189
190 while (n < plen)
191 {
192 *dst++ = cmap.encode [0];
193 plen--;
194 }
195
196 for (unsigned int i = n - plen; i < n; ++i)
197 *dst++ = cmap.encode [dst_ [i]];
198
199 return elen;
200}
201
202unsigned int basecoder::decode (u8 *dst, char *src, unsigned int len)
203{
204 if (!len || len > MAX_ENC_LEN)
205 return 0;
206
207 u8 src_ [MAX_ENC_LEN];
208 unsigned int elen = 0;
99 209
100 while (len--) 210 while (len--)
101 { 211 {
102 accum <<= 8; 212 u8 val = cmap.decode [(u8)*src++];
103 accum |= *src++;
104 bits += 8;
105 213
106 while (bits >= 6) 214 if (val != charmap::INVALID)
107 { 215 src_ [elen++] = val;
108 *dst++ = encode_chars [(accum >> (bits - 6)) & 63]; 216 }
109 bits -= 6; 217
110 } 218 int dlen = decode_len (elen);
219
220 mp_limb_t m [MAX_LIMBS];
221 mp_size_t n;
222
223 u8 dst_ [MAX_DEC_LEN];
224
225 n = mpn_set_str (m, src_, elen, cmap.size);
226 n = mpn_get_str (dst_, 256, m, n);
227
228 if (n < dlen)
111 } 229 {
230 memset (dst, 0, dlen - n);
231 memcpy (dst + dlen - n, dst_, n);
232 }
233 else
234 memcpy (dst, dst_ + n - dlen, dlen);
112 235
113 if (bits) 236 return dlen;
114 *dst++ = encode_chars [(accum << (6 - bits)) & 63];
115} 237}
116 238
117void dns64::decode (u8 *dst, char *src, int len) 239#if 0
118{ 240struct test { test (); } test;
119 // slow, but easy to debug
120 unsigned int accum, bits = 0;
121 241
122 while (len--) 242test::test ()
243{
244 basecoder cdc ("0123456789abcdefghijklmnopqrstuvwxyz");
245
246 u8 in[] = "0123456789abcdefghijklmnopqrstuvwxyz";
247 static char enc[200];
248 static u8 dec[200];
249
250 for (int i = 1; i < 20; i++)
123 { 251 {
124 s8 chr = decode_chars [(u8)*src++]; 252 int elen = cdc.encode (enc, in, i);
253 int dlen = cdc.decode (dec, enc, elen);
125 254
255 printf ("%d>%d>%d (%s>%s)\n", i, elen, dlen, enc, dec);
256 }
257 abort ();
258}
259#endif
126 260
127 if (!chr) 261//static basecoder cdc64 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI-");
262//static basecoder cdc63 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
263static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
264//static basecoder cdc36 ("dphzr06qmjkb34tsvl81xaef92wgyo57ucni"); // unused as of yet
265static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
266
267/////////////////////////////////////////////////////////////////////////////
268
269#define HDRSIZE 6
270
271inline void encode_header (char *data, int clientid, int seqno, int retry = 0)
272{
273 seqno &= SEQNO_MASK;
274
275 u8 hdr[3] = {
276 clientid,
277 (seqno >> 8) | (retry << 6),
278 seqno,
279 };
280
281 assert (clientid < 256);
282
283 cdc26.encode (data, hdr, 3);
284}
285
286inline void decode_header (char *data, int &clientid, int &seqno)
287{
288 u8 hdr[3];
289
290 cdc26.decode (hdr, data, HDRSIZE);
291
292 clientid = hdr[0];
293 seqno = ((hdr[1] << 8) | hdr[2]) & SEQNO_MASK;
294}
295
296/////////////////////////////////////////////////////////////////////////////
297
298struct byte_stream
299{
300 u8 *data;
301 int maxsize;
302 int fill;
303
304 byte_stream (int maxsize);
305 ~byte_stream ();
306
307 bool empty () { return !fill; }
308 int size () { return fill; }
309
310 bool put (u8 *data, unsigned int datalen);
311 bool put (vpn_packet *pkt);
312 vpn_packet *get ();
313
314 u8 *begin () { return data; }
315 void remove (int count);
316};
317
318byte_stream::byte_stream (int maxsize)
319: maxsize (maxsize), fill (0)
320{
321 data = new u8 [maxsize];
322}
323
324byte_stream::~byte_stream ()
325{
326 delete data;
327}
328
329void byte_stream::remove (int count)
330{
331 if (count > fill)
332 assert (count <= fill);
333
334 memmove (data, data + count, fill -= count);
335}
336
337bool byte_stream::put (u8 *data, unsigned int datalen)
338{
339 if (maxsize - fill < datalen)
340 return false;
341
342 memcpy (this->data + fill, data, datalen); fill += datalen;
343
344 return true;
345}
346
347bool byte_stream::put (vpn_packet *pkt)
348{
349 if (maxsize - fill < pkt->len + 2)
350 return false;
351
352 data [fill++] = pkt->len >> 8;
353 data [fill++] = pkt->len;
354
355 memcpy (data + fill, pkt->at (0), pkt->len); fill += pkt->len;
356
357 return true;
358}
359
360vpn_packet *byte_stream::get ()
361{
362 unsigned int len;
363
364 for (;;)
365 {
366 len = (data [0] << 8) | data [1];
367
368 if (len <= MAXSIZE || fill < 2)
128 break; 369 break;
129 370
130 accum <<= 6; 371 // TODO: handle this better than skipping, e.g. by reset
131 accum |= chr - 1; 372 slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
132 bits += 6; 373 remove (1);
133 374 }
134 while (bits >= 8)
135 { 375
136 *dst++ = accum >> (bits - 8); 376 if (fill < len + 2)
137 bits -= 8; 377 return 0;
138 } 378
139 } 379 vpn_packet *pkt = new vpn_packet;
380
381 pkt->len = len;
382 memcpy (pkt->at (0), data + 2, len);
383 remove (len + 2);
384
385 return pkt;
140} 386}
141 387
142///////////////////////////////////////////////////////////////////////////// 388/////////////////////////////////////////////////////////////////////////////
143 389
144#define FLAG_QUERY ( 0 << 15) 390#define FLAG_QUERY ( 0 << 15)
145#define FLAG_RESPONSE ( 1 << 15) 391#define FLAG_RESPONSE ( 1 << 15)
146#define FLAG_OP_MASK (15 << 14) 392#define FLAG_OP_MASK (15 << 11)
147#define FLAG_OP_QUERY ( 0 << 11) 393#define FLAG_OP_QUERY ( 0 << 11)
148#define FLAG_AA ( 1 << 10) 394#define FLAG_AA ( 1 << 10)
149#define FLAG_TC ( 1 << 9) 395#define FLAG_TC ( 1 << 9)
150#define FLAG_RD ( 1 << 8) 396#define FLAG_RD ( 1 << 8)
151#define FLAG_RA ( 1 << 7) 397#define FLAG_RA ( 1 << 7)
398#define FLAG_AUTH ( 1 << 5)
152#define FLAG_RCODE_MASK (15 << 0) 399#define FLAG_RCODE_MASK (15 << 0)
153#define FLAG_RCODE_OK ( 0 << 0) 400#define FLAG_RCODE_OK ( 0 << 0)
154#define FLAG_RCODE_FORMERR ( 1 << 0) 401#define FLAG_RCODE_FORMERR ( 1 << 0)
155#define FLAG_RCODE_SERVFAIL ( 2 << 0) 402#define FLAG_RCODE_SERVFAIL ( 2 << 0)
156#define FLAG_RCODE_NXDOMAIN ( 3 << 0) 403#define FLAG_RCODE_NXDOMAIN ( 3 << 0)
157#define FLAG_RCODE_REFUSED ( 5 << 0) 404#define FLAG_RCODE_REFUSED ( 5 << 0)
158 405
159#define DEFAULT_CLIENT_FLAGS (FLAG_QUERY | FLAG_OP_QUERY | FLAG_RD) 406#define DEFAULT_CLIENT_FLAGS (FLAG_QUERY | FLAG_OP_QUERY | FLAG_RD)
160#define DEFAULT_SERVER_FLAGS (FLAG_RESPONSE | FLAG_OP_QUERY | FLAG_AA | FLAG_RD) 407#define DEFAULT_SERVER_FLAGS (FLAG_RESPONSE | FLAG_OP_QUERY | FLAG_AA | FLAG_RD | FLAG_RA)
408
409struct dns_cfg
410{
411 static int next_uid;
412
413 u8 id1, id2, id3, id4;
414 u8 version;
415 u8 rrtype;
416 u8 flags;
417 u8 def_ttl;
418 u8 rcv_cdc;
419 u8 snd_cdc;
420 u16 max_size;
421 u16 client;
422 u16 uid; // to make request unique
423
424 u8 reserved[8];
425
426 void reset (int clientid);
427 bool valid ();
428};
429
430int dns_cfg::next_uid;
431
432void dns_cfg::reset (int clientid)
433{
434 id1 = 'G';
435 id2 = 'V';
436 id3 = 'P';
437 id4 = 'E';
438
439 version = 1;
440
441 rrtype = RR_TYPE_TXT;
442 flags = 0;
443 def_ttl = 1;
444 rcv_cdc = 0;
445 snd_cdc = 62;
446 max_size = ntohs (MAX_PKT_SIZE);
447 client = ntohs (clientid);
448 uid = next_uid++;
449
450 memset (reserved, 0, 8);
451}
452
453bool dns_cfg::valid ()
454{
455 return id1 == 'G'
456 && id2 == 'V'
457 && id3 == 'P'
458 && id4 == 'E'
459 && version == 1
460 && flags == 0
461 && rcv_cdc == 0
462 && snd_cdc == 62
463 && max_size == ntohs (MAX_PKT_SIZE);
464}
161 465
162struct dns_packet : net_packet 466struct dns_packet : net_packet
163{ 467{
164 u16 id; 468 u16 id;
165 u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4 469 u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
… …
204 return data - orig; 508 return data - orig;
205} 509}
206 510
207///////////////////////////////////////////////////////////////////////////// 511/////////////////////////////////////////////////////////////////////////////
208 512
513static u16 dns_id = 0; // TODO: should be per-vpn
514
515static u16 next_id ()
516{
517 if (!dns_id)
518 dns_id = time (0);
519
520 // the simplest lsfr with periodicity 65535 i could find
521 dns_id = (dns_id << 1)
522 | (((dns_id >> 1)
523 ^ (dns_id >> 2)
524 ^ (dns_id >> 4)
525 ^ (dns_id >> 15)) & 1);
526
527 return dns_id;
528}
529
209struct dns_req 530struct dns_rcv;
531struct dns_snd;
532
533struct dns_connection
534{
535 connection *c;
536 struct vpn *vpn;
537
538 dns_cfg cfg;
539
540 bool established;
541
542 tstamp last_received;
543 tstamp last_sent;
544 double last_latency;
545 double poll_interval, send_interval;
546
547 vector<dns_rcv *> rcvpq;
548
549 byte_stream rcvdq; int rcvseq;
550 byte_stream snddq; int sndseq;
551
552 void time_cb (time_watcher &w); time_watcher tw;
553 void receive_rep (dns_rcv *r);
554
555 dns_connection (connection *c);
556 ~dns_connection ();
557};
558
559struct dns_snd
210{ 560{
211 dns_packet *pkt; 561 dns_packet *pkt;
212 tstamp next; 562 tstamp timeout, sent;
213 int retry; 563 int retry;
564 struct dns_connection *dns;
565 int seqno;
566 bool stdhdr;
214 567
215 dns_req (connection *c, vpn_packet *p, int &offs); 568 void gen_stream_req (int seqno, byte_stream &stream);
569 void gen_syn_req ();
570
571 dns_snd (dns_connection *dns);
572 ~dns_snd ();
216}; 573};
217 574
575dns_snd::dns_snd (dns_connection *dns)
576: dns (dns)
577{
578 timeout = 0;
579 retry = 0;
580 seqno = 0;
581 sent = NOW;
582 stdhdr = false;
583
584 pkt = new dns_packet;
585
586 pkt->id = next_id ();
587}
588
589dns_snd::~dns_snd ()
590{
591 delete pkt;
592}
593
594static void append_domain (dns_packet &pkt, int &offs, const char *domain)
595{
596 // add tunnel domain
597 for (;;)
598 {
599 const char *end = strchr (domain, '.');
600
601 if (!end)
602 end = domain + strlen (domain);
603
604 int len = end - domain;
605
606 pkt [offs++] = len;
607 memcpy (pkt.at (offs), domain, len);
608 offs += len;
609
610 if (!*end)
611 break;
612
613 domain = end + 1;
614 }
615}
616
617void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
618{
619 stdhdr = true;
620 this->seqno = seqno;
621
622 timeout = NOW + INITIAL_TIMEOUT;
623
624 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
625 pkt->qdcount = htons (1);
626
627 int offs = 6*2;
628 int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
629 // MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,
630 // so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
631
632 char enc[256], *encp = enc;
633 encode_header (enc, THISNODE->id, seqno);
634
635 int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
636
637 if (datalen > stream.size ())
638 datalen = stream.size ();
639
640 int enclen = cdc62.encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
641 stream.remove (datalen);
642
643 while (enclen)
644 {
645 int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
646
647 (*pkt)[offs++] = lbllen;
648 memcpy (pkt->at (offs), encp, lbllen);
649
650 offs += lbllen;
651 encp += lbllen;
652
653 enclen -= lbllen;
654 }
655
656 append_domain (*pkt, offs, dns->c->conf->domain);
657
658 (*pkt)[offs++] = 0;
659 (*pkt)[offs++] = RR_TYPE_ANY >> 8; (*pkt)[offs++] = RR_TYPE_ANY;
660 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
661
662 pkt->len = offs;
663}
664
665void dns_snd::gen_syn_req ()
666{
667 timeout = NOW + INITIAL_SYN_TIMEOUT;
668
669 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
670 pkt->qdcount = htons (1);
671
672 int offs = 6 * 2;
673
674 int elen = cdc26.encode ((char *)pkt->at (offs + 1), (u8 *)&dns->cfg, sizeof (dns_cfg));
675
676 assert (elen <= MAX_LBL_SIZE);
677
678 (*pkt)[offs] = elen;
679 offs += elen + 1;
680 append_domain (*pkt, offs, dns->c->conf->domain);
681
682 (*pkt)[offs++] = 0;
683 (*pkt)[offs++] = RR_TYPE_A >> 8; (*pkt)[offs++] = RR_TYPE_A;
684 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
685
686 pkt->len = offs;
687}
688
218struct dns_rep 689struct dns_rcv
219{ 690{
691 int seqno;
692 dns_packet *pkt; // reply packet
693 u8 data [MAXSIZE]; // actually part of the reply packet...
694 int datalen;
695
696 dns_rcv (int seqno, u8 *data, int datalen);
697 ~dns_rcv ();
220}; 698};
221 699
222static u16 dns_id; // TODO: should be per-vpn 700dns_rcv::dns_rcv (int seqno, u8 *data, int datalen)
223 701: seqno (seqno), pkt (new dns_packet), datalen (datalen)
224dns_req::dns_req (connection *c, vpn_packet *p, int &offs)
225{ 702{
226 next = 0; 703 memcpy (this->data, data, datalen);
227 retry = 0; 704}
228 705
229 pkt = new dns_packet; 706dns_rcv::~dns_rcv ()
230 707{
231 pkt->id = dns_id++; 708 delete pkt;
232 pkt->flags = DEFAULT_CLIENT_FLAGS;
233 pkt->qdcount = htons (1 * 0);
234 pkt->ancount = 0;
235 pkt->nscount = 0;
236 pkt->arcount = 0;
237
238 offs += 10000;
239
240 c->dns_sndq.push_back (this);
241} 709}
242 710
243///////////////////////////////////////////////////////////////////////////// 711/////////////////////////////////////////////////////////////////////////////
244 712
245struct dns_cfg 713dns_connection::dns_connection (connection *c)
714: c (c)
715, rcvdq (MAX_BACKLOG * 2)
716, snddq (MAX_BACKLOG * 2)
717, tw (this, &dns_connection::time_cb)
246{ 718{
247 u8 id1, id2, id3; 719 vpn = c->vpn;
248 u8 def_ttl;
249 u8 unused1;
250 u16 max_size;
251 u8 flags1, flags2;
252};
253 720
254// reply to client-poll 721 established = false;
255void dnsv4_poll (dns_packet *pkt, int &offs)
256{
257 int dlen = MAX_PKT_SIZE - offs - 2;
258 722
259 (*pkt) [offs++] = 0; 723 rcvseq = sndseq = 0;
260 (*pkt) [offs++] = 5;
261 memcpy (&((*pkt)[offs]), "\01H\02\xff\x00", 5);
262 offs += 5;
263 724
264 pkt->ancount = htons (1); 725 last_sent = last_received = 0;
726 poll_interval = MIN_POLL_INTERVAL;
727 send_interval = 0.5; // starting rate
728 last_latency = INITIAL_TIMEOUT;
729}
730
731dns_connection::~dns_connection ()
732{
733 for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
734 i != rcvpq.end ();
735 ++i)
736 delete *i;
737}
738
739void dns_connection::receive_rep (dns_rcv *r)
740{
741 if (r->datalen)
742 {
743 last_received = NOW;
744 tw.trigger ();
745
746 poll_interval = send_interval;
747 }
748 else
749 {
750 poll_interval *= 1.5;
751 if (poll_interval > MAX_POLL_INTERVAL)
752 poll_interval = MAX_POLL_INTERVAL;
753 }
754
755 rcvpq.push_back (r);
756
757 redo:
758
759 // find next packet
760 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
761 if (SEQNO_EQ (rcvseq, (*i)->seqno))
762 {
763 // enter the packet into our input stream
764 r = *i;
765
766 // remove the oldest packet, look forward, as it's oldest first
767 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
768 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
769 {
770 delete *j;
771 rcvpq.erase (j);
772 break;
773 }
774
775 rcvseq = (rcvseq + 1) & SEQNO_MASK;
776
777 if (!rcvdq.put (r->data, r->datalen))
778 {
779 slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
780 abort (); // MUST never overflow, can be caused by data corruption, TODO
781 }
782
783 while (vpn_packet *pkt = rcvdq.get ())
784 {
785 sockinfo si;
786 si.host = 0x01010101; si.port = htons (c->conf->id); si.prot = PROT_DNSv4;
787
788 vpn->recv_vpn_packet (pkt, si);
789
790 delete pkt;
791 }
792
793 // check for further packets
794 goto redo;
795 }
796}
797
798void
799vpn::dnsv4_server (dns_packet &pkt)
800{
801 u16 flags = ntohs (pkt.flags);
802
803 int offs = 6 * 2; // skip header
804
265 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK); 805 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
266 806
267 printf ("we have room for %d bytes\n", dlen); 807 if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK))
808 && pkt.qdcount == htons (1))
809 {
810 char qname[MAXSIZE];
811 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
812
813 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++];
814 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++];
815
816 pkt.qdcount = htons (1);
817 pkt.ancount = 0;
818 pkt.nscount = 0; // should be self, as other nameservers reply like this
819 pkt.arcount = 0; // a record for self, as other nameservers reply like this
820
821 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_SERVFAIL);
822
823 int dlen = strlen (THISNODE->domain);
824
825 if (qclass == RR_CLASS_IN
826 && qlen > dlen + 1
827 && !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))
828 {
829 // now generate reply
830 pkt.ancount = htons (1); // one answer RR
831 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK);
832
833 if ((qtype == RR_TYPE_ANY
834 || qtype == RR_TYPE_TXT
835 || qtype == RR_TYPE_NULL)
836 && qlen > dlen + 1 + HDRSIZE)
837 {
838 // correct class, domain: parse
839 int client, seqno;
840 decode_header (qname, client, seqno);
841
842 u8 data[MAXSIZE];
843 int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
844
845 if (0 < client && client <= conns.size ())
846 {
847 connection *c = conns [client - 1];
848 dns_connection *dns = c->dns;
849 dns_rcv *rcv;
850 bool in_seq;
851
852 if (dns)
853 {
854 for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
855 if (SEQNO_EQ ((*i)->seqno, seqno))
856 {
857 // already seen that request: simply reply with the cached reply
858 dns_rcv *r = *i;
859
860 slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno);
861
862 // refresh header & id, as the retry count could have changed
863 memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE);
864 r->pkt->id = pkt.id;
865
866 memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
867
868 goto duplicate_request;
869 }
870
871 in_seq = dns->rcvseq == seqno;
872
873 // new packet, queue
874 rcv = new dns_rcv (seqno, data, datalen);
875 dns->receive_rep (rcv);
876 }
877
878 {
879 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
880
881 int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
882 pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
883 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
884 pkt [offs++] = 0; pkt [offs++] = 0;
885 pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
886
887 int rdlen_offs = offs += 2;
888
889 int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;
890 // bind doesn't compress well, so reduce further by one label length
891 dlen -= qlen;
892
893 if (dns)
894 {
895 // only put data into in-order sequence packets, if
896 // we receive out-of-order packets we generate empty
897 // replies
898 while (dlen > 1 && !dns->snddq.empty () && in_seq)
899 {
900 int txtlen = dlen <= 255 ? dlen - 1 : 255;
901
902 if (txtlen > dns->snddq.size ())
903 txtlen = dns->snddq.size ();
904
905 pkt[offs++] = txtlen;
906 memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
907 offs += txtlen;
908 dns->snddq.remove (txtlen);
909
910 dlen -= txtlen + 1;
911 }
912
913 // avoid empty TXT rdata
914 if (offs == rdlen_offs)
915 pkt[offs++] = 0;
916
917 slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
918 }
919 else
920 {
921 // send RST
922 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
923 pkt [offs++] = CMD_IP_RST;
924 }
925
926 int rdlen = offs - rdlen_offs;
927
928 pkt [rdlen_offs - 2] = rdlen >> 8;
929 pkt [rdlen_offs - 1] = rdlen;
930
931 if (dns)
932 {
933 // now update dns_rcv copy
934 rcv->pkt->len = offs;
935 memcpy (rcv->pkt->at (0), pkt.at (0), offs);
936 }
937 }
938
939 duplicate_request: ;
940 }
941 else
942 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
943 }
944 else if (qtype == RR_TYPE_A
945 && qlen > dlen + 1 + cdc26.encode_len (sizeof (dns_cfg)))
946 {
947 dns_cfg cfg;
948 cdc26.decode ((u8 *)&cfg, qname, cdc26.encode_len (sizeof (dns_cfg)));
949 int client = ntohs (cfg.client);
950
951 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
952
953 pkt [offs++] = RR_TYPE_A >> 8; pkt [offs++] = RR_TYPE_A; // type
954 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
955 pkt [offs++] = 0; pkt [offs++] = 0;
956 pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
957 pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
958
959 slog (L_INFO, _("DNS: client %d tries to connect"), client);
960
961 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
962 pkt [offs++] = CMD_IP_REJ;
963
964 if (0 < client && client <= conns.size ())
965 {
966 connection *c = conns [client - 1];
967
968 if (cfg.valid ())
969 {
970 pkt [offs - 1] = CMD_IP_SYN;
971
972 delete c->dns;
973 c->dns = new dns_connection (c);
974 c->dns->cfg = cfg;
975 }
976 }
977 }
978 }
979
980 pkt.len = offs;
981 }
982}
983
984void
985vpn::dnsv4_client (dns_packet &pkt)
986{
987 u16 flags = ntohs (pkt.flags);
988 int offs = 6 * 2; // skip header
989
990 pkt.qdcount = ntohs (pkt.qdcount);
991 pkt.ancount = ntohs (pkt.ancount);
992
993 // go through our request list and find the corresponding request
994 for (vector<dns_snd *>::iterator i = dns_sndpq.begin ();
995 i != dns_sndpq.end ();
996 ++i)
997 if ((*i)->pkt->id == pkt.id)
998 {
999 dns_connection *dns = (*i)->dns;
1000 connection *c = dns->c;
1001 int seqno = (*i)->seqno;
1002 u8 data[MAXSIZE], *datap = data;
1003
1004 if ((*i)->retry)
1005 {
1006 dns->send_interval *= 1.01;
1007 if (dns->send_interval > MAX_SEND_INTERVAL)
1008 dns->send_interval = MAX_SEND_INTERVAL;
1009 }
1010 else
1011 {
1012#if 1
1013 dns->send_interval *= 0.999;
1014#endif
1015 if (dns->send_interval < MIN_SEND_INTERVAL)
1016 dns->send_interval = MIN_SEND_INTERVAL;
1017
1018 // the latency surely puts an upper bound on
1019 // the minimum send interval
1020 double latency = NOW - (*i)->sent;
1021 dns->last_latency = latency;
1022
1023 if (dns->send_interval > latency)
1024 dns->send_interval = latency;
1025 }
1026
1027 delete *i;
1028 dns_sndpq.erase (i);
1029
1030 if (flags & FLAG_RESPONSE && !(flags & FLAG_OP_MASK))
1031 {
1032 char qname[MAXSIZE];
1033
1034 while (pkt.qdcount-- && offs < MAXSIZE - 4)
1035 {
1036 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
1037 offs += 4; // skip qtype, qclass
1038 }
1039
1040 while (pkt.ancount-- && offs < MAXSIZE - 10 && datap)
1041 {
1042 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
1043
1044 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++];
1045 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++];
1046 u32 ttl = pkt [offs++] << 24;
1047 ttl |= pkt [offs++] << 16;
1048 ttl |= pkt [offs++] << 8;
1049 ttl |= pkt [offs++];
1050 u16 rdlen = pkt [offs++] << 8; rdlen |= pkt [offs++];
1051
1052 if (qtype == RR_TYPE_NULL || qtype == RR_TYPE_TXT)
1053 {
1054 if (rdlen <= MAXSIZE - offs)
1055 {
1056 // decode bytes, finally
1057
1058 while (rdlen)
1059 {
1060 int txtlen = pkt [offs++];
1061
1062 assert (txtlen + offs < MAXSIZE - 1);
1063
1064 memcpy (datap, pkt.at (offs), txtlen);
1065 datap += txtlen; offs += txtlen;
1066
1067 rdlen -= txtlen + 1;
1068 }
1069 }
1070 }
1071 else if (qtype == RR_TYPE_A)
1072 {
1073 u8 ip [4];
1074
1075 ip [0] = pkt [offs++];
1076 ip [1] = pkt [offs++];
1077 ip [2] = pkt [offs++];
1078 ip [3] = pkt [offs++];
1079
1080 if (ip [0] == CMD_IP_1
1081 && ip [1] == CMD_IP_2
1082 && ip [2] == CMD_IP_3)
1083 {
1084 slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1085
1086 if (ip [3] == CMD_IP_RST)
1087 {
1088 slog (L_DEBUG, _("DNS: got tunnel RST request"));
1089
1090 delete dns; c->dns = 0;
1091
1092 return;
1093 }
1094 else if (ip [3] == CMD_IP_SYN)
1095 {
1096 slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1097 dns->established = true;
1098 }
1099 else if (ip [3] == CMD_IP_REJ)
1100 {
1101 slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
1102 abort ();
1103 }
1104 else
1105 slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1106 }
1107 else
1108 slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1109 ip [0], ip [1], ip [2], ip [3]);
1110
1111 return;
1112 }
1113
1114 int client, rseqno;
1115 decode_header (qname, client, rseqno);
1116
1117 if (client != THISNODE->id)
1118 {
1119 slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1120 datap = 0;
1121 }
1122 else if (rseqno != seqno)
1123 {
1124 slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
1125 datap = 0;
1126 }
1127 }
1128 }
1129
1130 // todo: pkt now used
1131 if (datap)
1132 dns->receive_rep (new dns_rcv (seqno, data, datap - data));
1133
1134 break;
1135 }
268} 1136}
269 1137
270void 1138void
271vpn::dnsv4_ev (io_watcher &w, short revents) 1139vpn::dnsv4_ev (io_watcher &w, short revents)
272{ 1140{
… …
274 { 1142 {
275 dns_packet *pkt = new dns_packet; 1143 dns_packet *pkt = new dns_packet;
276 struct sockaddr_in sa; 1144 struct sockaddr_in sa;
277 socklen_t sa_len = sizeof (sa); 1145 socklen_t sa_len = sizeof (sa);
278 1146
279 int len = recvfrom (w.fd, &((*pkt)[0]), MAXSIZE, 0, (sockaddr *)&sa, &sa_len); 1147 pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
280 pkt->len = len;
281 1148
282 u16 flags = ntohs (pkt->flags); 1149 if (pkt->len > 0)
283
284 if (THISNODE->dns_port)
285 { 1150 {
286 // server 1151 if (THISNODE->dns_port)
287 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
288
289 int offs = 6 * 2; // skip header
290
291 if (!(flags & (FLAG_RESPONSE | FLAG_OP_MASK | FLAG_TC))
292 && pkt->qdcount == htons (1))
293 { 1152 {
294 char qname[MAXSIZE]; 1153 dnsv4_server (*pkt);
295 int qlen = pkt->decode_label ((char *)qname, MAXSIZE, offs); 1154 sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1155 }
1156 else
1157 dnsv4_client (*pkt);
296 1158
297 printf ("rcvd packet len %d, id%04x flags%04x q%04x a%04x n%04x a%04x <%s>\n", len, 1159 delete pkt;
298 pkt->id, flags, pkt->qdcount, pkt->ancount, pkt->nscount, pkt->arcount, qname);//D 1160 }
1161 }
1162}
299 1163
300 u16 qtype = (*pkt) [offs++] << 8; qtype |= (*pkt) [offs++]; 1164bool
301 u16 qclass = (*pkt) [offs++] << 8; qclass |= (*pkt) [offs++]; 1165vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1166{
1167 int client = ntohs (si.port);
302 1168
303 pkt->qdcount = htons (1); 1169 assert (0 < client && client <= conns.size ());
304 pkt->ancount = 0;
305 pkt->nscount = 0; // should be self, as other nameservers reply like this
306 pkt->arcount = 0; // a record for self, as other nameservers reply like this
307 1170
308 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_NXDOMAIN); 1171 connection *c = conns [client - 1];
309 1172
310 int dlen = strlen (THISNODE->domain); 1173 if (!c->dns)
1174 c->dns = new dns_connection (c);
1175
1176 if (!c->dns->snddq.put (pkt))
1177 return false;
311 1178
312 if (qclass == RR_CLASS_IN 1179 c->dns->tw.trigger ();
313 && (qtype == RR_TYPE_ANY || qtype == RR_TYPE_TXT) 1180
314 && qlen > dlen + 1 1181 return true;
315 && !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen)) 1182}
1183
1184void
1185connection::dnsv4_reset_connection ()
1186{
1187 //delete dns; dns = 0; //TODO
1188}
1189
1190#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1191
1192void
1193dns_connection::time_cb (time_watcher &w)
1194{
1195 // servers have to be polled
1196 if (THISNODE->dns_port)
1197 return;
1198
1199 // check for timeouts and (re)transmit
1200 tstamp next = NOW + poll_interval;
1201 dns_snd *send = 0;
1202
1203 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1204 i != vpn->dns_sndpq.end ();
1205 ++i)
1206 {
1207 dns_snd *r = *i;
1208
1209 if (r->timeout <= NOW)
1210 {
1211 if (!send)
1212 {
1213 send = r;
1214
1215 r->retry++;
1216 r->timeout = NOW + (r->retry * last_latency * 8.);
1217
1218 // the following code changes the query section a bit, forcing
1219 // the forwarder to generate a new request
1220 if (r->stdhdr)
316 { 1221 {
317 // correct class, now generate reply 1222 //printf ("reencoded header for ID %d retry %d:%d:%d\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);printf ("reencoded header for ID %d retry %d:%d:%d\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);
318 pkt->ancount = htons (1); // one answer RR 1223 //encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry);
319
320 (*pkt) [offs++] = 0xc0;
321 (*pkt) [offs++] = 6 * 2; // same as in query section
322
323 (*pkt) [offs++] = RR_TYPE_TXT >> 8; (*pkt) [offs++] = RR_TYPE_TXT;
324 (*pkt) [offs++] = RR_CLASS_IN >> 8; (*pkt) [offs++] = RR_CLASS_IN;
325
326 (*pkt) [offs++] = 0; (*pkt) [offs++] = 0;
327 (*pkt) [offs++] = 0; (*pkt) [offs++] = 0; // TTL
328
329 dnsv4_poll (pkt, offs);
330 printf ("correct class\n");
331 } 1224 }
332 } 1225 }
333
334 sendto (w.fd, &((*pkt)[0]), offs, 0, (sockaddr *)&sa, sa_len);
335 } 1226 }
336 else 1227 else
1228 NEXT (r->timeout);
1229 }
1230
1231 if (last_sent + send_interval <= NOW)
1232 {
1233 if (!send)
337 { 1234 {
338 // client 1235 // generate a new packet, if wise
1236
1237 if (!established)
1238 {
1239 if (vpn->dns_sndpq.empty ())
1240 {
1241 send = new dns_snd (this);
1242
1243 printf ("new conn %p %d\n", this, c->conf->id);//D
1244 cfg.reset (THISNODE->id);
1245 send->gen_syn_req ();
1246 }
1247 }
1248 else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING
1249 && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1250 {
1251 //printf ("sending data request etc.\n"); //D
1252 if (!snddq.empty ())
1253 {
1254 poll_interval = send_interval;
1255 NEXT (NOW + send_interval);
1256 }
1257
1258 send = new dns_snd (this);
1259 send->gen_stream_req (sndseq, snddq);
1260 send->timeout = NOW + last_latency * 8.;
1261
1262 sndseq = (sndseq + 1) & SEQNO_MASK;
1263 }
1264
1265 if (send)
1266 vpn->dns_sndpq.push_back (send);
339 } 1267 }
340 }
341}
342 1268
343bool 1269 if (send)
344connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
345{
346 if (dns_sndq.size () >= MAX_OUTSTANDING)
347 return false;
348
349 // split vpn packet into dns packets, add to sndq
350 for (int offs = 0; offs < pkt->len; )
351 new dns_req (this, pkt, offs);
352
353 // force transmit
354 dnsv4_cb (dnsv4_tw);
355
356 return true;
357}
358
359void
360connection::dnsv4_cb (time_watcher &w)
361{
362 // check for timeouts and (re)transmit
363 tstamp next = NOW + 60;
364
365 slog (L_NOISE, _("dnsv4, %d packets in send queue\n"), dns_sndq.size ());
366
367 if (dns_sndq.empty ())
368 {
369 next = NOW + 1;
370 // push poll packet
371 }
372
373 for (vector<dns_req *>::iterator i = dns_sndq.begin ();
374 i != dns_sndq.end ();
375 ++i)
376 {
377 dns_req *r = *i;
378
379 if (r->next <= NOW)
380 { 1270 {
381 slog (L_NOISE, _("dnsv4, send req %d\n"), r->pkt->id); 1271 last_sent = NOW;
382 r->retry++; 1272 sendto (vpn->dnsv4_fd,
383 r->next = NOW + r->retry; 1273 send->pkt->at (0), send->pkt->len, 0,
1274 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
384 } 1275 }
385
386 if (r->next < next)
387 next = r->next;
388 } 1276 }
1277 else
1278 NEXT (last_sent + send_interval);
389 1279
390 printf ("%f next\n", next); 1280 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d)",
1281 poll_interval, send_interval, next - NOW,
1282 vpn->dns_sndpq.size (), snddq.size ());
1283
1284 // TODO: no idea when this happens, but when next < NOW, we have a problem
1285 if (next < NOW + 0.0001)
1286 next = NOW + 0.1;
1287
391 w.start (next); 1288 w.start (next);
392} 1289}
393 1290
394#endif 1291#endif
395 1292

Diff Legend

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