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.14 by pcg, Fri Mar 4 09:51:23 2005 UTC vs.
Revision 1.49 by root, Tue Feb 8 23:11:36 2011 UTC

1/* 1/*
2 vpn_dns.C -- handle the dns tunnel part of the protocol. 2 vpn_dns.C -- handle the dns tunnel part of the protocol.
3 Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de> 3 Copyright (C) 2003-2008 Marc Lehmann <gvpe@schmorp.de>
4 4
5 This file is part of GVPE. 5 This file is part of GVPE.
6 6
7 GVPE is free software; you can redistribute it and/or modify 7 GVPE is free software; you can redistribute it and/or modify it
8 it under the terms of the GNU General Public License as published by 8 under the terms of the GNU General Public License as published by the
9 the Free Software Foundation; either version 2 of the License, or 9 Free Software Foundation; either version 3 of the License, or (at your
10 (at your option) any later version. 10 option) any later version.
11 11
12 This program is distributed in the hope that it will be useful, 12 This program is distributed in the hope that it will be useful, but
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15 GNU General Public License for more details. 15 Public License for more details.
16 16
17 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License along
18 along with gvpe; if not, write to the Free Software 18 with this program; if not, see <http://www.gnu.org/licenses/>.
19 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19
20 Additional permission under GNU GPL version 3 section 7
21
22 If you modify this Program, or any covered work, by linking or
23 combining it with the OpenSSL project's OpenSSL library (or a modified
24 version of that library), containing parts covered by the terms of the
25 OpenSSL or SSLeay licenses, the licensors of this Program grant you
26 additional permission to convey the resulting work. Corresponding
27 Source for a non-source form of such a combination shall include the
28 source code for the parts of OpenSSL used as well as that of the
29 covered work.
20*/ 30*/
31
32// TODO: EDNS0 option to increase dns mtu?
33// TODO: re-write dns packet parsing/creation using a safe mem-buffer
34// to ensure no buffer overflows or similar problems.
21 35
22#include "config.h" 36#include "config.h"
23 37
24#if ENABLE_DNS 38#if ENABLE_DNS
25 39
26// dns processing is EXTREMELY ugly. For obvious(?) reasons. 40// dns processing is EXTREMELY ugly. For obvious(?) reasons.
27// it's a hack, use only in emergency situations please. 41// it's a hack, use only in emergency situations please.
28 42
29#include <cstring> 43#include <cstring>
44#include <cassert>
30 45
31#include <sys/types.h> 46#include <sys/types.h>
32#include <sys/socket.h> 47#include <sys/socket.h>
33#include <sys/wait.h> 48#include <sys/wait.h>
34#include <sys/uio.h> 49#include <sys/uio.h>
… …
37#include <unistd.h> 52#include <unistd.h>
38#include <fcntl.h> 53#include <fcntl.h>
39 54
40#include <map> 55#include <map>
41 56
57#include <cstdio> /* bug in libgmp: gmp.h relies on cstdio being included */
42#include <gmp.h> 58#include <gmp.h>
43 59
44#include "netcompat.h" 60#include "netcompat.h"
45 61
46#include "vpn.h" 62#include "vpn.h"
47 63
48#define MIN_POLL_INTERVAL .02 // how often to poll minimally when the server is having data
49#define MAX_POLL_INTERVAL 6. // how often to poll minimally when the server has no data 64#define MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data
50#define ACTIVITY_INTERVAL 5. 65#define ACTIVITY_INTERVAL 5.
51 66
52#define INITIAL_TIMEOUT 1. 67#define INITIAL_TIMEOUT 0.1 // retry timeouts
53#define INITIAL_SYN_TIMEOUT 2. 68#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54 69
55#define MIN_SEND_INTERVAL 0.01
56#define MAX_SEND_INTERVAL 0.5 // optimistic? 70#define MAX_SEND_INTERVAL 2. // optimistic?
57 71
58#define MAX_OUTSTANDING 40 // max. outstanding requests
59#define MAX_WINDOW 100 // max. for MAX_OUTSTANDING 72#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
60#define MAX_BACKLOG (100*1024) // size of protocol backlog, must be > MAXSIZE 73#define MAX_BACKLOG (64*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
61 74
62#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
63// 240 leaves about 4 bytes of server reply data 76// 240 leaves about 4 bytes of server reply data
64// every two request byte sless give room for one reply byte 77// every request byte less give room for two reply bytes
65 78
66#define SEQNO_MASK 0xffff 79#define SEQNO_MASK 0x3fff
67#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) ) 80#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
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
72#define RR_TYPE_A 1 85#define RR_TYPE_A 1
73#define RR_TYPE_NULL 10 86#define RR_TYPE_NULL 10
74#define RR_TYPE_TXT 16 87#define RR_TYPE_TXT 16
88#define RR_TYPE_AAAA 28
75#define RR_TYPE_ANY 255 89#define RR_TYPE_ANY 255
76 90
77#define RR_CLASS_IN 1 91#define RR_CLASS_IN 1
78 92
79#define CMD_IP_1 207 93#define CMD_IP_1 207
… …
154 enc_len [len] = n; 168 enc_len [len] = n;
155 dec_len [n] = len; 169 dec_len [n] = len;
156 } 170 }
157} 171}
158 172
173unsigned int
159unsigned int basecoder::encode_len (unsigned int len) 174basecoder::encode_len (unsigned int len)
160{ 175{
161 return enc_len [len]; 176 return enc_len [len];
162} 177}
163 178
179unsigned int
164unsigned int basecoder::decode_len (unsigned int len) 180basecoder::decode_len (unsigned int len)
165{ 181{
166 while (len && !dec_len [len]) 182 while (len && !dec_len [len])
167 --len; 183 --len;
168 184
169 return dec_len [len]; 185 return dec_len [len];
170} 186}
171 187
188unsigned int
172unsigned int basecoder::encode (char *dst, u8 *src, unsigned int len) 189basecoder::encode (char *dst, u8 *src, unsigned int len)
173{ 190{
174 if (!len || len > MAX_DEC_LEN) 191 if (!len || len > MAX_DEC_LEN)
175 return 0; 192 return 0;
176 193
177 int elen = encode_len (len); 194 int elen = encode_len (len);
… …
196 *dst++ = cmap.encode [dst_ [i]]; 213 *dst++ = cmap.encode [dst_ [i]];
197 214
198 return elen; 215 return elen;
199} 216}
200 217
218unsigned int
201unsigned int basecoder::decode (u8 *dst, char *src, unsigned int len) 219basecoder::decode (u8 *dst, char *src, unsigned int len)
202{ 220{
203 if (!len || len > MAX_ENC_LEN) 221 if (!len || len > MAX_ENC_LEN)
204 return 0; 222 return 0;
205 223
206 u8 src_ [MAX_ENC_LEN]; 224 u8 src_ [MAX_ENC_LEN];
… …
264static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO"); 282static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
265 283
266///////////////////////////////////////////////////////////////////////////// 284/////////////////////////////////////////////////////////////////////////////
267 285
268#define HDRSIZE 6 286#define HDRSIZE 6
269 287
288inline void
270inline void encode_header (char *data, int clientid, int seqno) 289encode_header (char *data, int clientid, int seqno, int retry = 0)
271{ 290{
272 u8 hdr[3] = { clientid, seqno >> 8, seqno }; 291 seqno &= SEQNO_MASK;
292
293 u8 hdr[3] = {
294 clientid,
295 (seqno >> 8) | (retry << 6),
296 seqno,
297 };
273 298
274 assert (clientid < 256); 299 assert (clientid < 256);
275 300
276 cdc26.encode (data, hdr, 3); 301 cdc26.encode (data, hdr, 3);
277} 302}
278 303
304inline void
279inline void decode_header (char *data, int &clientid, int &seqno) 305decode_header (char *data, int &clientid, int &seqno)
280{ 306{
281 u8 hdr[3]; 307 u8 hdr[3];
282 308
283 cdc26.decode (hdr, data, HDRSIZE); 309 cdc26.decode (hdr, data, HDRSIZE);
284 310
285 clientid = hdr[0]; 311 clientid = hdr[0];
286 seqno = (hdr[1] << 8) | hdr[2]; 312 seqno = ((hdr[1] << 8) | hdr[2]) & SEQNO_MASK;
287} 313}
288 314
289///////////////////////////////////////////////////////////////////////////// 315/////////////////////////////////////////////////////////////////////////////
290 316
291struct byte_stream 317struct byte_stream
… …
317byte_stream::~byte_stream () 343byte_stream::~byte_stream ()
318{ 344{
319 delete data; 345 delete data;
320} 346}
321 347
348void
322void byte_stream::remove (int count) 349byte_stream::remove (int count)
323{ 350{
324 if (count > fill) 351 if (count > fill)
325 abort (); 352 assert (count <= fill);
326 353
327 memmove (data, data + count, fill -= count); 354 memmove (data, data + count, fill -= count);
328} 355}
329 356
357bool
330bool byte_stream::put (u8 *data, unsigned int datalen) 358byte_stream::put (u8 *data, unsigned int datalen)
331{ 359{
332 if (maxsize - fill < datalen) 360 if (maxsize - fill < datalen)
333 return false; 361 return false;
334 362
335 memcpy (this->data + fill, data, datalen); fill += datalen; 363 memcpy (this->data + fill, data, datalen); fill += datalen;
336 364
337 return true; 365 return true;
338} 366}
339 367
368bool
340bool byte_stream::put (vpn_packet *pkt) 369byte_stream::put (vpn_packet *pkt)
341{ 370{
342 if (maxsize - fill < pkt->len + 2) 371 if (maxsize - fill < pkt->len + 2)
343 return false; 372 return false;
344 373
345 data [fill++] = pkt->len >> 8; 374 data [fill++] = pkt->len >> 8;
… …
350 return true; 379 return true;
351} 380}
352 381
353vpn_packet *byte_stream::get () 382vpn_packet *byte_stream::get ()
354{ 383{
384 unsigned int len;
385
386 for (;;)
387 {
355 unsigned int len = (data [0] << 8) | data [1]; 388 len = (data [0] << 8) | data [1];
356 389
357 if (len > MAXSIZE && fill >= 2) 390 if (len <= MAXSIZE || fill < 2)
358 abort (); // TODO handle this gracefully, connection reset 391 break;
359 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
360 if (fill < len + 2) 398 if (fill < len + 2)
361 return 0; 399 return 0;
362 400
363 vpn_packet *pkt = new vpn_packet; 401 vpn_packet *pkt = new vpn_packet;
364 402
… …
393struct dns_cfg 431struct dns_cfg
394{ 432{
395 static int next_uid; 433 static int next_uid;
396 434
397 u8 id1, id2, id3, id4; 435 u8 id1, id2, id3, id4;
436
398 u8 version; 437 u8 version;
438 u8 flags;
399 u8 rrtype; 439 u8 rrtype;
400 u8 flags;
401 u8 def_ttl; 440 u8 def_ttl;
402 u8 rcv_cdc; 441
403 u8 snd_cdc;
404 u16 max_size;
405 u16 client; 442 u16 client;
406 u16 uid; // to make request unique 443 u16 uid; // to make request unique
407 444
408 u8 reserved[8]; 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;
409 454
410 void reset (int clientid); 455 void reset (int clientid);
411 bool valid (); 456 bool valid ();
412}; 457};
413 458
414int dns_cfg::next_uid; 459int dns_cfg::next_uid;
415 460
461void
416void dns_cfg::reset (int clientid) 462dns_cfg::reset (int clientid)
417{ 463{
418 id1 = 'G'; 464 id1 = 'G';
419 id2 = 'V'; 465 id2 = 'V';
420 id3 = 'P'; 466 id3 = 'P';
421 id4 = 'E'; 467 id4 = 'E';
… …
423 version = 1; 469 version = 1;
424 470
425 rrtype = RR_TYPE_TXT; 471 rrtype = RR_TYPE_TXT;
426 flags = 0; 472 flags = 0;
427 def_ttl = 0; 473 def_ttl = 0;
474 seq_cdc = 26;
475 req_cdc = 62;
428 rcv_cdc = 0; 476 rep_cdc = 0;
429 snd_cdc = 62;
430 max_size = ntohs (MAX_PKT_SIZE); 477 max_size = htons (MAX_PKT_SIZE);
431 client = ntohs (clientid); 478 client = htons (clientid);
432 uid = next_uid++; 479 uid = next_uid++;
480 delay = 0;
433 481
434 memset (reserved, 0, 8); 482 r3 = r4 = 0;
483 r4 = r5 = r6 = r7 = 0;
435} 484}
436 485
486bool
437bool dns_cfg::valid () 487dns_cfg::valid ()
438{ 488{
489 // although the protocol itself allows for some configurability,
490 // only the following encoding/decoding settings are implemented.
439 return id1 == 'G' 491 return id1 == 'G'
440 && id2 == 'V' 492 && id2 == 'V'
441 && id3 == 'P' 493 && id3 == 'P'
442 && id4 == 'E' 494 && id4 == 'E'
495 && seq_cdc == 26
496 && req_cdc == 62
497 && rep_cdc == 0
443 && version == 1 498 && version == 1;
444 && flags == 0
445 && rcv_cdc == 0
446 && snd_cdc == 62
447 && max_size == ntohs (MAX_PKT_SIZE);
448} 499}
449 500
450struct dns_packet : net_packet 501struct dns_packet : net_packet
451{ 502{
452 u16 id; 503 u16 id;
453 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
454 u16 qdcount, ancount, nscount, arcount; 505 u16 qdcount, ancount, nscount, arcount;
455 506
456 u8 data[MAXSIZE - 6 * 2]; 507 u8 data [MAXSIZE - 6 * 2];
457 508
458 int decode_label (char *data, int size, int &offs); 509 int decode_label (char *data, int size, int &offs);
459}; 510};
460 511
512int
461int dns_packet::decode_label (char *data, int size, int &offs) 513dns_packet::decode_label (char *data, int size, int &offs)
462{ 514{
463 char *orig = data; 515 char *orig = data;
464 516
465 memset (data, 0, size); 517 memset (data, 0, size);
466 518
… …
492 return data - orig; 544 return data - orig;
493} 545}
494 546
495///////////////////////////////////////////////////////////////////////////// 547/////////////////////////////////////////////////////////////////////////////
496 548
497struct dns_snd 549static
550u16 next_id ()
498{ 551{
499 dns_packet *pkt;
500 tstamp timeout, sent;
501 int retry;
502 struct dns_connection *dns;
503 int seqno;
504
505 void gen_stream_req (int seqno, byte_stream &stream);
506 void gen_syn_req (const dns_cfg &cfg);
507
508 dns_snd (dns_connection *dns);
509 ~dns_snd ();
510};
511
512static u16 dns_id = 12098; // TODO: should be per-vpn 552 static u16 dns_id = 0; // TODO: should be per-vpn
513 553
514static u16 next_id () 554 if (!dns_id)
515{ 555 dns_id = time (0);
556
516 // the simplest lsfr with periodicity 65535 i could find 557 // the simplest lsfr with periodicity 65535 i could find
517 dns_id = (dns_id << 1) 558 dns_id = (dns_id << 1)
518 | (((dns_id >> 1) 559 | (((dns_id >> 1)
519 ^ (dns_id >> 2) 560 ^ (dns_id >> 2)
520 ^ (dns_id >> 4) 561 ^ (dns_id >> 4)
521 ^ (dns_id >> 15)) & 1); 562 ^ (dns_id >> 15)) & 1);
522 563
523 return dns_id; 564 return dns_id;
524} 565}
525 566
567struct dns_rcv;
568struct dns_snd;
569
570struct dns_connection
571{
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
526dns_snd::dns_snd (dns_connection *dns) 612dns_snd::dns_snd (dns_connection *dns)
527: dns (dns) 613: dns (dns)
528{ 614{
529 timeout = 0; 615 timeout = 0;
530 retry = 0; 616 retry = 0;
531 seqno = 0; 617 seqno = 0;
532 sent = NOW; 618 sent = ev_now ();
619 stdhdr = false;
533 620
534 pkt = new dns_packet; 621 pkt = new dns_packet;
535 622
536 pkt->id = next_id (); 623 pkt->id = next_id ();
537} 624}
… …
539dns_snd::~dns_snd () 626dns_snd::~dns_snd ()
540{ 627{
541 delete pkt; 628 delete pkt;
542} 629}
543 630
631static void
544static void append_domain (dns_packet &pkt, int &offs, const char *domain) 632append_domain (dns_packet &pkt, int &offs, const char *domain)
545{ 633{
546 // add tunnel domain 634 // add tunnel domain
547 for (;;) 635 for (;;)
548 { 636 {
549 const char *end = strchr (domain, '.'); 637 const char *end = strchr (domain, '.');
… …
562 650
563 domain = end + 1; 651 domain = end + 1;
564 } 652 }
565} 653}
566 654
655void
567void dns_snd::gen_stream_req (int seqno, byte_stream &stream) 656dns_snd::gen_stream_req (int seqno, byte_stream &stream)
568{ 657{
658 stdhdr = true;
569 this->seqno = seqno; 659 this->seqno = seqno;
570 660
571 timeout = NOW + INITIAL_TIMEOUT; 661 timeout = ev_now () + INITIAL_TIMEOUT;
572 662
573 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 663 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
574 pkt->qdcount = htons (1); 664 pkt->qdcount = htons (1);
575 665
576 int offs = 6*2; 666 int offs = 6*2;
577 int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2); 667 int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
578 // 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,
579 // 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
580 670
581 char enc[256], *encp = enc; 671 char enc[256], *encp = enc;
582 encode_header (enc, THISNODE->id, seqno); 672 encode_header (enc, THISNODE->id, seqno);
… …
600 encp += lbllen; 690 encp += lbllen;
601 691
602 enclen -= lbllen; 692 enclen -= lbllen;
603 } 693 }
604 694
605 append_domain (*pkt, offs, THISNODE->domain); 695 append_domain (*pkt, offs, dns->c->conf->domain);
606 696
607 (*pkt)[offs++] = 0; 697 (*pkt)[offs++] = 0;
608 (*pkt)[offs++] = RR_TYPE_ANY >> 8; (*pkt)[offs++] = RR_TYPE_ANY; 698 (*pkt)[offs++] = RR_TYPE_ANY >> 8; (*pkt)[offs++] = RR_TYPE_ANY;
609 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN; 699 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
610 700
611 pkt->len = offs; 701 pkt->len = offs;
612} 702}
613 703
614void dns_snd::gen_syn_req (const dns_cfg &cfg) 704void
705dns_snd::gen_syn_req ()
615{ 706{
616 timeout = NOW + INITIAL_SYN_TIMEOUT; 707 timeout = ev_now () + INITIAL_SYN_TIMEOUT;
617 708
618 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 709 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
619 pkt->qdcount = htons (1); 710 pkt->qdcount = htons (1);
620 711
621 int offs = 6*2; 712 int offs = 6 * 2;
622 713
623 int elen = cdc26.encode ((char *)pkt->at (offs + 1), (u8 *)&cfg, sizeof (dns_cfg)); 714 int elen = cdc26.encode ((char *)pkt->at (offs + 1), (u8 *)&dns->cfg, sizeof (dns_cfg));
624 715
625 assert (elen <= MAX_LBL_SIZE); 716 assert (elen <= MAX_LBL_SIZE);
626 717
627 (*pkt)[offs] = elen; 718 (*pkt)[offs] = elen;
628 offs += elen + 1; 719 offs += elen + 1;
629 append_domain (*pkt, offs, THISNODE->domain); 720 append_domain (*pkt, offs, dns->c->conf->domain);
630 721
631 (*pkt)[offs++] = 0; 722 (*pkt)[offs++] = 0;
632 (*pkt)[offs++] = RR_TYPE_A >> 8; (*pkt)[offs++] = RR_TYPE_A; 723 (*pkt)[offs++] = RR_TYPE_A >> 8; (*pkt)[offs++] = RR_TYPE_A;
633 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN; 724 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
634 725
… …
657 delete pkt; 748 delete pkt;
658} 749}
659 750
660///////////////////////////////////////////////////////////////////////////// 751/////////////////////////////////////////////////////////////////////////////
661 752
662struct dns_connection
663{
664 connection *c;
665 struct vpn *vpn;
666
667 dns_cfg cfg;
668
669 bool established;
670
671 tstamp last_received;
672 tstamp last_sent;
673 double poll_interval, send_interval;
674
675 vector<dns_rcv *> rcvpq;
676
677 byte_stream rcvdq; int rcvseq;
678 byte_stream snddq; int sndseq;
679
680 void time_cb (time_watcher &w); time_watcher tw;
681 void receive_rep (dns_rcv *r);
682
683 dns_connection (connection *c);
684 ~dns_connection ();
685};
686
687dns_connection::dns_connection (connection *c) 753dns_connection::dns_connection (connection *c)
688: c (c) 754: c (c)
689, rcvdq (MAX_BACKLOG * 2) 755, rcvdq (MAX_BACKLOG * 2)
690, snddq (MAX_BACKLOG * 2) 756, snddq (MAX_BACKLOG)
691, tw (this, &dns_connection::time_cb)
692{ 757{
758 tw.set<dns_connection, &dns_connection::time_cb> (this);
759
693 vpn = c->vpn; 760 vpn = c->vpn;
694 761
695 established = false; 762 established = false;
696 763
697 rcvseq = sndseq = 0; 764 rcvseq = repseq = sndseq = 0;
698 765
699 last_sent = last_received = 0; 766 last_sent = last_received = 0;
700 poll_interval = MIN_POLL_INTERVAL; 767 poll_interval = 0.5; // starting here
701 send_interval = 0.2; // starting rate 768 send_interval = 0.5; // starting rate
769 min_latency = INITIAL_TIMEOUT;
702} 770}
703 771
704dns_connection::~dns_connection () 772dns_connection::~dns_connection ()
705{ 773{
706 for (vector<dns_rcv *>::iterator i = rcvpq.begin (); 774 for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
707 i != rcvpq.end (); 775 i != rcvpq.end ();
708 ++i) 776 ++i)
709 delete *i; 777 delete *i;
710} 778}
711 779
780void
712void dns_connection::receive_rep (dns_rcv *r) 781dns_connection::receive_rep (dns_rcv *r)
713{ 782{
714 if (r->datalen) 783 if (r->datalen)
715 { 784 {
716 last_received = NOW; 785 last_received = ev_now ();
717 tw.trigger (); 786 tw ();
718 787
719 poll_interval = send_interval; 788 poll_interval = send_interval;
720 } 789 }
721 else 790 else
722 { 791 {
723 poll_interval *= 1.1; 792 poll_interval *= 1.5;
793
724 if (poll_interval > MAX_POLL_INTERVAL) 794 if (poll_interval > MAX_POLL_INTERVAL)
725 poll_interval = MAX_POLL_INTERVAL; 795 poll_interval = MAX_POLL_INTERVAL;
726 } 796 }
727 797
728 rcvpq.push_back (r); 798 rcvpq.push_back (r);
… …
731 801
732 // find next packet 802 // find next packet
733 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); ) 803 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
734 if (SEQNO_EQ (rcvseq, (*i)->seqno)) 804 if (SEQNO_EQ (rcvseq, (*i)->seqno))
735 { 805 {
806 //printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
736 // enter the packet into our input stream 807 // enter the packet into our input stream
737 r = *i; 808 r = *i;
738 809
739 // remove the oldest packet, look forward, as it's oldest first 810 // remove the oldest packet, look forward, as it's oldest first
740 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j) 811 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
741 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW)) 812 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
742 { 813 {
814 //printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
743 delete *j; 815 delete *j;
744 rcvpq.erase (j); 816 rcvpq.erase (j);
745 break; 817 break;
746 } 818 }
747 819
748 rcvseq = (rcvseq + 1) & SEQNO_MASK; 820 rcvseq = (rcvseq + 1) & SEQNO_MASK;
749 821
750 if (!rcvdq.put (r->data, r->datalen)) 822 if (!rcvdq.put (r->data, r->datalen))
823 {
824 slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
751 abort (); // MUST never overflow, can be caused by data corruption, TODO 825 abort (); // MUST never overflow, can be caused by data corruption, TODO
826 }
752 827
753 while (vpn_packet *pkt = rcvdq.get ()) 828 while (vpn_packet *pkt = rcvdq.get ())
754 { 829 {
755 sockinfo si; 830 sockinfo si;
756 si.host = 0; si.port = 0; si.prot = PROT_DNSv4; 831 si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
757 832
758 vpn->recv_vpn_packet (pkt, si); 833 vpn->recv_vpn_packet (pkt, si);
759 834
760 delete pkt; 835 delete pkt;
761 } 836 }
… …
775 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR); 850 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
776 851
777 if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK)) 852 if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK))
778 && pkt.qdcount == htons (1)) 853 && pkt.qdcount == htons (1))
779 { 854 {
780 char qname[MAXSIZE]; 855 char qname [MAXSIZE];
781 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs); 856 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
782 857
783 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++]; 858 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++];
784 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++]; 859 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++];
785 860
786 pkt.qdcount = htons (1); 861 pkt.qdcount = htons (1);
787 pkt.ancount = 0; 862 pkt.ancount = 0;
788 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
789 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
790 865
791 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_NXDOMAIN); 866 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_SERVFAIL);
792 867
793 int dlen = strlen (THISNODE->domain); 868 int dlen = strlen (THISNODE->domain);
794 869
795 if (qclass == RR_CLASS_IN 870 if (qclass == RR_CLASS_IN
796 && qlen > dlen + 1 871 && qlen > dlen + 1
797 && !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen)) 872 && !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
798 { 873 {
799 // now generate reply 874 // now generate reply
800 pkt.ancount = htons (1); // one answer RR 875 pkt.ancount = htons (1); // one answer RR
801 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK); 876 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK);
802 877
… …
824 if (SEQNO_EQ ((*i)->seqno, seqno)) 899 if (SEQNO_EQ ((*i)->seqno, seqno))
825 { 900 {
826 // already seen that request: simply reply with the cached reply 901 // already seen that request: simply reply with the cached reply
827 dns_rcv *r = *i; 902 dns_rcv *r = *i;
828 903
829 slog (L_DEBUG, "DUPLICATE %d\n", htons (r->pkt->id)); 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;
830 909
831 memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len); 910 memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
832 pkt.id = r->pkt->id; 911
833 goto duplicate_request; 912 goto duplicate_request;
834 } 913 }
835 914
836 // new packet, queue 915 // new packet, queue
837 rcv = new dns_rcv (seqno, data, datalen); 916 rcv = new dns_rcv (seqno, data, datalen);
838 dns->receive_rep (rcv); 917 dns->receive_rep (rcv);
839 } 918 }
840 919
920 {
841 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section 921 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
842 922
843 int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A; 923 int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
844 pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type 924 pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
845 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class 925 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
846 pkt [offs++] = 0; pkt [offs++] = 0; 926 pkt [offs++] = 0; pkt [offs++] = 0;
847 pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL 927 pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
848 928
849 int rdlen_offs = offs += 2; 929 int rdlen_offs = offs += 2;
850 930
931 if (dns)
932 {
851 int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs; 933 int dlen = ntohs (dns->cfg.max_size) - offs;
934
852 // bind doesn't compress well, so reduce further by one label length 935 // bind doesn't compress well, so reduce further by one label length
853 dlen -= qlen; 936 dlen -= qlen;
854 937
855 if (dns) 938 // only put data into in-order sequence packets, if
856 { 939 // we receive out-of-order packets we generate empty
857 while (dlen > 1 && !dns->snddq.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)
858 { 943 {
944 dns->repseq = seqno;
945
946 while (dlen > 1 && !dns->snddq.empty ())
947 {
859 int txtlen = dlen <= 255 ? dlen - 1 : 255; 948 int txtlen = dlen <= 255 ? dlen - 1 : 255;
860 949
861 if (txtlen > dns->snddq.size ()) 950 if (txtlen > dns->snddq.size ())
862 txtlen = dns->snddq.size (); 951 txtlen = dns->snddq.size ();
863 952
864 pkt[offs++] = txtlen; 953 pkt[offs++] = txtlen;
865 memcpy (pkt.at (offs), dns->snddq.begin (), txtlen); 954 memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
866 offs += txtlen; 955 offs += txtlen;
867 dns->snddq.remove (txtlen); 956 dns->snddq.remove (txtlen);
868 957
869 dlen -= txtlen + 1; 958 dlen -= txtlen + 1;
959 }
870 } 960 }
871 961
872 // avoid empty TXT rdata 962 // avoid completely empty TXT rdata
873 if (offs == rdlen_offs) 963 if (offs == rdlen_offs)
874 pkt[offs++] = 0; 964 pkt[offs++] = 0;
965
966 slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
875 } 967 }
876 else 968 else
877 { 969 {
878 // send RST 970 // send RST
879 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; 971 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
880 pkt [offs++] = CMD_IP_RST; 972 pkt [offs++] = CMD_IP_RST;
881 } 973 }
882 974
883 int rdlen = offs - rdlen_offs; 975 int rdlen = offs - rdlen_offs;
884 976
885 pkt [rdlen_offs - 2] = rdlen >> 8; 977 pkt [rdlen_offs - 2] = rdlen >> 8;
886 pkt [rdlen_offs - 1] = rdlen; 978 pkt [rdlen_offs - 1] = rdlen;
887 979
888 if (dns) 980 if (dns)
889 { 981 {
890 // now update dns_rcv copy 982 // now update dns_rcv copy
891 rcv->pkt->len = offs; 983 rcv->pkt->len = offs;
892 memcpy (rcv->pkt->at (0), pkt.at (0), offs); 984 memcpy (rcv->pkt->at (0), pkt.at (0), offs);
893 } 985 }
986 }
894 987
895 duplicate_request: ; 988 duplicate_request: ;
896 } 989 }
897 else 990 else
898 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR); 991 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
… …
910 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class 1003 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
911 pkt [offs++] = 0; pkt [offs++] = 0; 1004 pkt [offs++] = 0; pkt [offs++] = 0;
912 pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL 1005 pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
913 pkt [offs++] = 0; pkt [offs++] = 4; // rdlength 1006 pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
914 1007
915 slog (L_INFO, _("DNS tunnel: client %d tries to connect"), client); 1008 slog (L_INFO, _("DNS: client %d connects"), client);
916 1009
917 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; 1010 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
918 pkt [offs++] = CMD_IP_REJ; 1011 pkt [offs++] = CMD_IP_REJ;
919 1012
920 if (0 < client && client <= conns.size ()) 1013 if (0 < client && client <= conns.size ())
… …
954 { 1047 {
955 dns_connection *dns = (*i)->dns; 1048 dns_connection *dns = (*i)->dns;
956 connection *c = dns->c; 1049 connection *c = dns->c;
957 int seqno = (*i)->seqno; 1050 int seqno = (*i)->seqno;
958 u8 data[MAXSIZE], *datap = data; 1051 u8 data[MAXSIZE], *datap = data;
1052 //printf ("rcv pkt %x\n", seqno);//D
959 1053
960 if ((*i)->retry) 1054 if ((*i)->retry)
961 { 1055 {
962 dns->send_interval *= 1.001; 1056 dns->send_interval *= 1.01;
963 if (dns->send_interval > MAX_SEND_INTERVAL) 1057 if (dns->send_interval > MAX_SEND_INTERVAL)
964 dns->send_interval = MAX_SEND_INTERVAL; 1058 dns->send_interval = MAX_SEND_INTERVAL;
965 } 1059 }
966 else 1060 else
967 { 1061 {
968#if 1 1062#if 0
969 dns->send_interval *= 0.9999; 1063 dns->send_interval *= 0.999;
970#endif 1064#endif
971 if (dns->send_interval < MIN_SEND_INTERVAL)
972 dns->send_interval = MIN_SEND_INTERVAL;
973
974 // the latency surely puts an upper bound on 1065 // the latency surely puts an upper bound on
975 // the minimum send interval 1066 // the minimum send interval
976 double latency = NOW - (*i)->sent; 1067 double latency = ev_now () - (*i)->sent;
977 1068
978 if (dns->send_interval > latency) 1069 if (latency < dns->min_latency)
979 dns->send_interval = 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;
980 } 1077 }
981 1078
982 delete *i; 1079 delete *i;
983 dns_sndpq.erase (i); 1080 dns_sndpq.erase (i);
984 1081
… …
1034 1131
1035 if (ip [0] == CMD_IP_1 1132 if (ip [0] == CMD_IP_1
1036 && ip [1] == CMD_IP_2 1133 && ip [1] == CMD_IP_2
1037 && ip [2] == CMD_IP_3) 1134 && ip [2] == CMD_IP_3)
1038 { 1135 {
1039 slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]); 1136 slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1040 1137
1041 if (ip [3] == CMD_IP_RST) 1138 if (ip [3] == CMD_IP_RST)
1042 { 1139 {
1043 slog (L_DEBUG, _("got tunnel RST request")); 1140 slog (L_DEBUG, _("DNS: got tunnel RST request"));
1044 1141
1045 delete dns; c->dns = 0; 1142 delete dns; c->dns = 0;
1046 1143
1047 return; 1144 return;
1048 } 1145 }
1049 else if (ip [3] == CMD_IP_SYN) 1146 else if (ip [3] == CMD_IP_SYN)
1050 { 1147 {
1051 slog (L_DEBUG, _("got tunnel SYN reply, server likes us.")); 1148 slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1052 dns->established = true; 1149 dns->established = true;
1053 } 1150 }
1054 else if (ip [3] == CMD_IP_REJ) 1151 else if (ip [3] == CMD_IP_REJ)
1055 { 1152 {
1056 slog (L_DEBUG, _("got tunnel REJ reply, server does not like us, aborting.")); 1153 slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
1057 abort (); 1154 abort ();
1058 } 1155 }
1059 else 1156 else
1060 slog (L_INFO, _("got unknown meta command %02x"), ip [3]); 1157 slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1061 } 1158 }
1062 else 1159 else
1063 slog (L_INFO, _("got spurious a record %d.%d.%d.%d"), 1160 slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1064 ip [0], ip [1], ip [2], ip [3]); 1161 ip [0], ip [1], ip [2], ip [3]);
1065 1162
1066 return; 1163 return;
1067 } 1164 }
1068 1165
1069 int client, rseqno; 1166 int client, rseqno;
1070 decode_header (qname, client, rseqno); 1167 decode_header (qname, client, rseqno);
1071 1168
1072 if (client != THISNODE->id) 1169 if (client != THISNODE->id)
1073 { 1170 {
1074 slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring")); 1171 slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1075 datap = 0; 1172 datap = 0;
1076 } 1173 }
1077 else if (rseqno != seqno) 1174 else if (rseqno != seqno)
1078 { 1175 {
1079 slog (L_DEBUG, _("got dns tunnel response with wrong seqno, badly caching nameserver?")); 1176 slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
1080 datap = 0; 1177 datap = 0;
1081 } 1178 }
1082 } 1179 }
1083 } 1180 }
1084 1181
… …
1089 break; 1186 break;
1090 } 1187 }
1091} 1188}
1092 1189
1093void 1190void
1094vpn::dnsv4_ev (io_watcher &w, short revents) 1191vpn::dnsv4_ev (ev::io &w, int revents)
1095{ 1192{
1096 if (revents & EVENT_READ) 1193 if (revents & EV_READ)
1097 { 1194 {
1098 dns_packet *pkt = new dns_packet; 1195 dns_packet *pkt = new dns_packet;
1099 struct sockaddr_in sa; 1196 struct sockaddr_in sa;
1100 socklen_t sa_len = sizeof (sa); 1197 socklen_t sa_len = sizeof (sa);
1101 1198
1102 pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len); 1199 pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1103 1200
1104 if (pkt->len > 0) 1201 if (pkt->len > 0)
1105 { 1202 {
1106 if (THISNODE->dns_port) 1203 if (ntohs (pkt->flags) & FLAG_RESPONSE)
1204 dnsv4_client (*pkt);
1205 else
1107 { 1206 {
1108 dnsv4_server (*pkt); 1207 dnsv4_server (*pkt);
1109 sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len); 1208 sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1110 } 1209 }
1111 else
1112 dnsv4_client (*pkt);
1113 1210
1114 delete pkt; 1211 delete pkt;
1115 } 1212 }
1116 } 1213 }
1117} 1214}
1118 1215
1119bool 1216bool
1120connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 1217vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1121{ 1218{
1219 int client = ntohl (si.host);
1220
1221 assert (0 < client && client <= conns.size ());
1222
1223 connection *c = conns [client - 1];
1224
1122 if (!dns) 1225 if (!c->dns)
1123 dns = new dns_connection (this); 1226 c->dns = new dns_connection (c);
1124 1227
1125 if (!dns->snddq.put (pkt)) 1228 if (c->dns->snddq.put (pkt))
1126 return false; 1229 c->dns->tw ();
1127 1230
1128 dns->tw.trigger (); 1231 // always return true even if the buffer overflows
1129
1130 return true; 1232 return true;
1131} 1233}
1132 1234
1133void 1235void
1134connection::dnsv4_reset_connection () 1236connection::dnsv4_reset_connection ()
… …
1137} 1239}
1138 1240
1139#define NEXT(w) do { if (next > (w)) next = w; } while (0) 1241#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1140 1242
1141void 1243void
1142dns_connection::time_cb (time_watcher &w) 1244dns_connection::time_cb (ev::timer &w, int revents)
1143{ 1245{
1144 // servers have to be polled 1246 // servers have to be polled
1145 if (THISNODE->dns_port) 1247 if (THISNODE->dns_port)
1146 return; 1248 return;
1147 1249
1148 // check for timeouts and (re)transmit 1250 // check for timeouts and (re)transmit
1149 tstamp next = NOW + poll_interval; 1251 tstamp next = ev::now () + poll_interval;
1150 dns_snd *send = 0; 1252 dns_snd *send = 0;
1151 1253
1152 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin (); 1254 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1153 i != vpn->dns_sndpq.end (); 1255 i != vpn->dns_sndpq.end ();
1154 ++i) 1256 ++i)
1155 { 1257 {
1156 dns_snd *r = *i; 1258 dns_snd *r = *i;
1157 1259
1158 if (r->timeout <= NOW) 1260 if (r->timeout <= ev_now ())
1159 { 1261 {
1160 if (!send) 1262 if (!send)
1161 { 1263 {
1162 send = r; 1264 send = r;
1163 1265
1164 r->retry++; 1266 r->retry++;
1165 r->timeout = 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);
1166 } 1274 }
1167 } 1275 }
1168 else 1276 else
1169 NEXT (r->timeout); 1277 NEXT (r->timeout);
1170 } 1278 }
1171 1279
1172 if (last_sent + send_interval <= NOW)
1173 {
1174 if (!send) 1280 if (!send)
1281 {
1282 // generate a new packet, if wise
1283
1284 if (!established)
1175 { 1285 {
1176 // generate a new packet, if wise
1177
1178 if (!established)
1179 {
1180 if (vpn->dns_sndpq.empty ()) 1286 if (vpn->dns_sndpq.empty ())
1181 {
1182 send = new dns_snd (this);
1183
1184 cfg.reset (THISNODE->id);
1185 send->gen_syn_req (cfg);
1186 }
1187 }
1188 else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING)
1189 { 1287 {
1190 send = new dns_snd (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);
1191 send->gen_stream_req (sndseq, 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
1192 1310
1193 sndseq = (sndseq + 1) & SEQNO_MASK; 1311 sndseq = (sndseq + 1) & SEQNO_MASK;
1194 } 1312 }
1195 1313 else
1196 if (send) 1314 NEXT (last_sent + send_interval);
1197 vpn->dns_sndpq.push_back (send);
1198 } 1315 }
1199 1316
1200 if (send) 1317 if (send)
1201 { 1318 vpn->dns_sndpq.push_back (send);
1202 last_sent = NOW; 1319 }
1320
1321 if (send)
1322 {
1323 last_sent = ev_now ();
1203 sendto (vpn->dnsv4_fd, 1324 sendto (vpn->dnsv4_fd,
1204 send->pkt->at (0), send->pkt->len, 0, 1325 send->pkt->at (0), send->pkt->len, 0,
1205 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ()); 1326 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1206 }
1207 } 1327 }
1208 else
1209 NEXT (last_sent + send_interval);
1210 1328
1211 slog (L_NOISE, "pi %f si %f N %f (%d:%d)", 1329 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1212 poll_interval, send_interval, next - NOW, 1330 poll_interval, send_interval, next - ev_now (),
1213 vpn->dns_sndpq.size (), snddq.size ()); 1331 vpn->dns_sndpq.size (), snddq.size (),
1332 rcvpq.size ());
1214 1333
1215 // TODO: no idea when this happens, but when next < NOW, we have a problem 1334 // TODO: no idea when this happens, but when next < ev_now (), we have a problem
1335 // doesn't seem to happen anymore
1216 if (next < NOW + 0.0001) 1336 if (next < ev_now () + 0.001)
1217 next = NOW + 0.1; 1337 next = ev_now () + 0.1;
1218 1338
1219 w.start (next); 1339 w.start (next - ev_now ());
1220} 1340}
1221 1341
1222#endif 1342#endif
1223 1343

Diff Legend

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