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.16 by pcg, Fri Mar 4 19:28:17 2005 UTC vs.
Revision 1.47 by pcg, Thu Aug 7 17:54:27 2008 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 has 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. // retry timeouts 67#define INITIAL_TIMEOUT 0.1 // retry timeouts
53#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn 68#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54 69
55#define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests
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 gvpe protocol backlog (bytes), 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 bytes less 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
… …
264static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO"); 277static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
265 278
266///////////////////////////////////////////////////////////////////////////// 279/////////////////////////////////////////////////////////////////////////////
267 280
268#define HDRSIZE 6 281#define HDRSIZE 6
269 282
270inline void encode_header (char *data, int clientid, int seqno) 283inline void encode_header (char *data, int clientid, int seqno, int retry = 0)
271{ 284{
272 u8 hdr[3] = { clientid, seqno >> 8, seqno }; 285 seqno &= SEQNO_MASK;
286
287 u8 hdr[3] = {
288 clientid,
289 (seqno >> 8) | (retry << 6),
290 seqno,
291 };
273 292
274 assert (clientid < 256); 293 assert (clientid < 256);
275 294
276 cdc26.encode (data, hdr, 3); 295 cdc26.encode (data, hdr, 3);
277} 296}
… …
281 u8 hdr[3]; 300 u8 hdr[3];
282 301
283 cdc26.decode (hdr, data, HDRSIZE); 302 cdc26.decode (hdr, data, HDRSIZE);
284 303
285 clientid = hdr[0]; 304 clientid = hdr[0];
286 seqno = (hdr[1] << 8) | hdr[2]; 305 seqno = ((hdr[1] << 8) | hdr[2]) & SEQNO_MASK;
287} 306}
288 307
289///////////////////////////////////////////////////////////////////////////// 308/////////////////////////////////////////////////////////////////////////////
290 309
291struct byte_stream 310struct byte_stream
… …
320} 339}
321 340
322void byte_stream::remove (int count) 341void byte_stream::remove (int count)
323{ 342{
324 if (count > fill) 343 if (count > fill)
325 abort (); 344 assert (count <= fill);
326 345
327 memmove (data, data + count, fill -= count); 346 memmove (data, data + count, fill -= count);
328} 347}
329 348
330bool byte_stream::put (u8 *data, unsigned int datalen) 349bool byte_stream::put (u8 *data, unsigned int datalen)
… …
350 return true; 369 return true;
351} 370}
352 371
353vpn_packet *byte_stream::get () 372vpn_packet *byte_stream::get ()
354{ 373{
374 unsigned int len;
375
376 for (;;)
377 {
355 unsigned int len = (data [0] << 8) | data [1]; 378 len = (data [0] << 8) | data [1];
356 379
357 if (len > MAXSIZE && fill >= 2) 380 if (len <= MAXSIZE || fill < 2)
358 abort (); // TODO handle this gracefully, connection reset 381 break;
359 382
383 // TODO: handle this better than skipping, e.g. by reset
384 slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
385 remove (1);
386 }
387
360 if (fill < len + 2) 388 if (fill < len + 2)
361 return 0; 389 return 0;
362 390
363 vpn_packet *pkt = new vpn_packet; 391 vpn_packet *pkt = new vpn_packet;
364 392
… …
393struct dns_cfg 421struct dns_cfg
394{ 422{
395 static int next_uid; 423 static int next_uid;
396 424
397 u8 id1, id2, id3, id4; 425 u8 id1, id2, id3, id4;
426
398 u8 version; 427 u8 version;
428 u8 flags;
399 u8 rrtype; 429 u8 rrtype;
400 u8 flags;
401 u8 def_ttl; 430 u8 def_ttl;
402 u8 rcv_cdc; 431
403 u8 snd_cdc;
404 u16 max_size;
405 u16 client; 432 u16 client;
406 u16 uid; // to make request unique 433 u16 uid; // to make request unique
407 434
408 u8 reserved[8]; 435 u16 max_size;
436 u8 seq_cdc;
437 u8 req_cdc;
438
439 u8 rep_cdc;
440 u8 delay; // time in 0.01s units that the server may delay replying packets
441 u8 r3, r4;
442
443 u8 r5, r6, r7, r8;
409 444
410 void reset (int clientid); 445 void reset (int clientid);
411 bool valid (); 446 bool valid ();
412}; 447};
413 448
… …
423 version = 1; 458 version = 1;
424 459
425 rrtype = RR_TYPE_TXT; 460 rrtype = RR_TYPE_TXT;
426 flags = 0; 461 flags = 0;
427 def_ttl = 0; 462 def_ttl = 0;
463 seq_cdc = 26;
464 req_cdc = 62;
428 rcv_cdc = 0; 465 rep_cdc = 0;
429 snd_cdc = 62;
430 max_size = ntohs (MAX_PKT_SIZE); 466 max_size = htons (MAX_PKT_SIZE);
431 client = ntohs (clientid); 467 client = htons (clientid);
432 uid = next_uid++; 468 uid = next_uid++;
469 delay = 0;
433 470
434 memset (reserved, 0, 8); 471 r3 = r4 = 0;
472 r4 = r5 = r6 = r7 = 0;
435} 473}
436 474
437bool dns_cfg::valid () 475bool dns_cfg::valid ()
438{ 476{
477 // although the protocol itself allows for some configurability,
478 // only the following encoding/decoding settings are implemented.
439 return id1 == 'G' 479 return id1 == 'G'
440 && id2 == 'V' 480 && id2 == 'V'
441 && id3 == 'P' 481 && id3 == 'P'
442 && id4 == 'E' 482 && id4 == 'E'
483 && seq_cdc == 26
484 && req_cdc == 62
485 && rep_cdc == 0
443 && version == 1 486 && version == 1;
444 && flags == 0
445 && rcv_cdc == 0
446 && snd_cdc == 62
447 && max_size == ntohs (MAX_PKT_SIZE);
448} 487}
449 488
450struct dns_packet : net_packet 489struct dns_packet : net_packet
451{ 490{
452 u16 id; 491 u16 id;
453 u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4 492 u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
454 u16 qdcount, ancount, nscount, arcount; 493 u16 qdcount, ancount, nscount, arcount;
455 494
456 u8 data[MAXSIZE - 6 * 2]; 495 u8 data [MAXSIZE - 6 * 2];
457 496
458 int decode_label (char *data, int size, int &offs); 497 int decode_label (char *data, int size, int &offs);
459}; 498};
460 499
461int dns_packet::decode_label (char *data, int size, int &offs) 500int dns_packet::decode_label (char *data, int size, int &offs)
… …
492 return data - orig; 531 return data - orig;
493} 532}
494 533
495///////////////////////////////////////////////////////////////////////////// 534/////////////////////////////////////////////////////////////////////////////
496 535
497struct dns_snd
498{
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 536static u16 dns_id = 0; // TODO: should be per-vpn
513 537
514static u16 next_id () 538static u16 next_id ()
515{ 539{
540 if (!dns_id)
541 dns_id = time (0);
542
516 // the simplest lsfr with periodicity 65535 i could find 543 // the simplest lsfr with periodicity 65535 i could find
517 dns_id = (dns_id << 1) 544 dns_id = (dns_id << 1)
518 | (((dns_id >> 1) 545 | (((dns_id >> 1)
519 ^ (dns_id >> 2) 546 ^ (dns_id >> 2)
520 ^ (dns_id >> 4) 547 ^ (dns_id >> 4)
521 ^ (dns_id >> 15)) & 1); 548 ^ (dns_id >> 15)) & 1);
522 549
523 return dns_id; 550 return dns_id;
524} 551}
525 552
553struct dns_rcv;
554struct dns_snd;
555
556struct dns_connection
557{
558 connection *c;
559 struct vpn *vpn;
560
561 dns_cfg cfg;
562
563 bool established;
564
565 tstamp last_received;
566 tstamp last_sent;
567 double min_latency;
568 double poll_interval, send_interval;
569
570 vector<dns_rcv *> rcvpq;
571
572 byte_stream rcvdq; int rcvseq; int repseq;
573 byte_stream snddq; int sndseq;
574
575 inline void time_cb (ev::timer &w, int revents); ev::timer tw;
576 void receive_rep (dns_rcv *r);
577
578 dns_connection (connection *c);
579 ~dns_connection ();
580};
581
582struct dns_snd
583{
584 dns_packet *pkt;
585 tstamp timeout, sent;
586 int retry;
587 struct dns_connection *dns;
588 int seqno;
589 bool stdhdr;
590
591 void gen_stream_req (int seqno, byte_stream &stream);
592 void gen_syn_req ();
593
594 dns_snd (dns_connection *dns);
595 ~dns_snd ();
596};
597
526dns_snd::dns_snd (dns_connection *dns) 598dns_snd::dns_snd (dns_connection *dns)
527: dns (dns) 599: dns (dns)
528{ 600{
529 timeout = 0; 601 timeout = 0;
530 retry = 0; 602 retry = 0;
531 seqno = 0; 603 seqno = 0;
532 sent = NOW; 604 sent = ev_now ();
605 stdhdr = false;
533 606
534 pkt = new dns_packet; 607 pkt = new dns_packet;
535 608
536 pkt->id = next_id (); 609 pkt->id = next_id ();
537} 610}
… …
564 } 637 }
565} 638}
566 639
567void dns_snd::gen_stream_req (int seqno, byte_stream &stream) 640void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
568{ 641{
642 stdhdr = true;
569 this->seqno = seqno; 643 this->seqno = seqno;
570 644
571 timeout = NOW + INITIAL_TIMEOUT; 645 timeout = ev_now () + INITIAL_TIMEOUT;
572 646
573 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 647 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
574 pkt->qdcount = htons (1); 648 pkt->qdcount = htons (1);
575 649
576 int offs = 6*2; 650 int offs = 6*2;
577 int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2); 651 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, 652 // 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 653 // so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
580 654
581 char enc[256], *encp = enc; 655 char enc[256], *encp = enc;
582 encode_header (enc, THISNODE->id, seqno); 656 encode_header (enc, THISNODE->id, seqno);
… …
600 encp += lbllen; 674 encp += lbllen;
601 675
602 enclen -= lbllen; 676 enclen -= lbllen;
603 } 677 }
604 678
605 append_domain (*pkt, offs, THISNODE->domain); 679 append_domain (*pkt, offs, dns->c->conf->domain);
606 680
607 (*pkt)[offs++] = 0; 681 (*pkt)[offs++] = 0;
608 (*pkt)[offs++] = RR_TYPE_ANY >> 8; (*pkt)[offs++] = RR_TYPE_ANY; 682 (*pkt)[offs++] = RR_TYPE_ANY >> 8; (*pkt)[offs++] = RR_TYPE_ANY;
609 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN; 683 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
610 684
611 pkt->len = offs; 685 pkt->len = offs;
612} 686}
613 687
614void dns_snd::gen_syn_req (const dns_cfg &cfg) 688void dns_snd::gen_syn_req ()
615{ 689{
616 timeout = NOW + INITIAL_SYN_TIMEOUT; 690 timeout = ev_now () + INITIAL_SYN_TIMEOUT;
617 691
618 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 692 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
619 pkt->qdcount = htons (1); 693 pkt->qdcount = htons (1);
620 694
621 int offs = 6*2; 695 int offs = 6 * 2;
622 696
623 int elen = cdc26.encode ((char *)pkt->at (offs + 1), (u8 *)&cfg, sizeof (dns_cfg)); 697 int elen = cdc26.encode ((char *)pkt->at (offs + 1), (u8 *)&dns->cfg, sizeof (dns_cfg));
624 698
625 assert (elen <= MAX_LBL_SIZE); 699 assert (elen <= MAX_LBL_SIZE);
626 700
627 (*pkt)[offs] = elen; 701 (*pkt)[offs] = elen;
628 offs += elen + 1; 702 offs += elen + 1;
629 append_domain (*pkt, offs, THISNODE->domain); 703 append_domain (*pkt, offs, dns->c->conf->domain);
630 704
631 (*pkt)[offs++] = 0; 705 (*pkt)[offs++] = 0;
632 (*pkt)[offs++] = RR_TYPE_A >> 8; (*pkt)[offs++] = RR_TYPE_A; 706 (*pkt)[offs++] = RR_TYPE_A >> 8; (*pkt)[offs++] = RR_TYPE_A;
633 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN; 707 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
634 708
… …
657 delete pkt; 731 delete pkt;
658} 732}
659 733
660///////////////////////////////////////////////////////////////////////////// 734/////////////////////////////////////////////////////////////////////////////
661 735
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) 736dns_connection::dns_connection (connection *c)
688: c (c) 737: c (c)
689, rcvdq (MAX_BACKLOG * 2) 738, rcvdq (MAX_BACKLOG * 2)
690, snddq (MAX_BACKLOG * 2) 739, snddq (MAX_BACKLOG)
691, tw (this, &dns_connection::time_cb)
692{ 740{
741 tw.set<dns_connection, &dns_connection::time_cb> (this);
742
693 vpn = c->vpn; 743 vpn = c->vpn;
694 744
695 established = false; 745 established = false;
696 746
697 rcvseq = sndseq = 0; 747 rcvseq = repseq = sndseq = 0;
698 748
699 last_sent = last_received = 0; 749 last_sent = last_received = 0;
700 poll_interval = MIN_POLL_INTERVAL; 750 poll_interval = 0.5; // starting here
701 send_interval = 0.2; // starting rate 751 send_interval = 0.5; // starting rate
752 min_latency = INITIAL_TIMEOUT;
702} 753}
703 754
704dns_connection::~dns_connection () 755dns_connection::~dns_connection ()
705{ 756{
706 for (vector<dns_rcv *>::iterator i = rcvpq.begin (); 757 for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
… …
711 762
712void dns_connection::receive_rep (dns_rcv *r) 763void dns_connection::receive_rep (dns_rcv *r)
713{ 764{
714 if (r->datalen) 765 if (r->datalen)
715 { 766 {
716 last_received = NOW; 767 last_received = ev_now ();
717 tw.trigger (); 768 tw ();
718 769
719 poll_interval = send_interval; 770 poll_interval = send_interval;
720 } 771 }
721 else 772 else
722 { 773 {
723 poll_interval *= 1.1; 774 poll_interval *= 1.5;
775
724 if (poll_interval > MAX_POLL_INTERVAL) 776 if (poll_interval > MAX_POLL_INTERVAL)
725 poll_interval = MAX_POLL_INTERVAL; 777 poll_interval = MAX_POLL_INTERVAL;
726 } 778 }
727 779
728 rcvpq.push_back (r); 780 rcvpq.push_back (r);
… …
731 783
732 // find next packet 784 // find next packet
733 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); ) 785 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
734 if (SEQNO_EQ (rcvseq, (*i)->seqno)) 786 if (SEQNO_EQ (rcvseq, (*i)->seqno))
735 { 787 {
788 //printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
736 // enter the packet into our input stream 789 // enter the packet into our input stream
737 r = *i; 790 r = *i;
738 791
739 // remove the oldest packet, look forward, as it's oldest first 792 // remove the oldest packet, look forward, as it's oldest first
740 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j) 793 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
741 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW)) 794 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
742 { 795 {
796 //printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
743 delete *j; 797 delete *j;
744 rcvpq.erase (j); 798 rcvpq.erase (j);
745 break; 799 break;
746 } 800 }
747 801
748 rcvseq = (rcvseq + 1) & SEQNO_MASK; 802 rcvseq = (rcvseq + 1) & SEQNO_MASK;
749 803
750 if (!rcvdq.put (r->data, r->datalen)) 804 if (!rcvdq.put (r->data, r->datalen))
805 {
806 slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
751 abort (); // MUST never overflow, can be caused by data corruption, TODO 807 abort (); // MUST never overflow, can be caused by data corruption, TODO
808 }
752 809
753 while (vpn_packet *pkt = rcvdq.get ()) 810 while (vpn_packet *pkt = rcvdq.get ())
754 { 811 {
755 sockinfo si; 812 sockinfo si;
756 si.host = 0; si.port = 0; si.prot = PROT_DNSv4; 813 si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
757 814
758 vpn->recv_vpn_packet (pkt, si); 815 vpn->recv_vpn_packet (pkt, si);
759 816
760 delete pkt; 817 delete pkt;
761 } 818 }
… …
775 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR); 832 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
776 833
777 if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK)) 834 if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK))
778 && pkt.qdcount == htons (1)) 835 && pkt.qdcount == htons (1))
779 { 836 {
780 char qname[MAXSIZE]; 837 char qname [MAXSIZE];
781 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs); 838 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
782 839
783 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++]; 840 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++];
784 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++]; 841 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++];
785 842
… …
792 849
793 int dlen = strlen (THISNODE->domain); 850 int dlen = strlen (THISNODE->domain);
794 851
795 if (qclass == RR_CLASS_IN 852 if (qclass == RR_CLASS_IN
796 && qlen > dlen + 1 853 && qlen > dlen + 1
797 && !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen)) 854 && !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
798 { 855 {
799 // now generate reply 856 // now generate reply
800 pkt.ancount = htons (1); // one answer RR 857 pkt.ancount = htons (1); // one answer RR
801 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK); 858 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK);
802 859
… …
824 if (SEQNO_EQ ((*i)->seqno, seqno)) 881 if (SEQNO_EQ ((*i)->seqno, seqno))
825 { 882 {
826 // already seen that request: simply reply with the cached reply 883 // already seen that request: simply reply with the cached reply
827 dns_rcv *r = *i; 884 dns_rcv *r = *i;
828 885
829 slog (L_DEBUG, "DUPLICATE %d\n", htons (r->pkt->id)); 886 slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno);
887
888 // refresh header & id, as the retry count could have changed
889 memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE);
890 r->pkt->id = pkt.id;
830 891
831 memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len); 892 memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
832 pkt.id = r->pkt->id; 893
833 goto duplicate_request; 894 goto duplicate_request;
834 } 895 }
835 896
836 // new packet, queue 897 // new packet, queue
837 rcv = new dns_rcv (seqno, data, datalen); 898 rcv = new dns_rcv (seqno, data, datalen);
838 dns->receive_rep (rcv); 899 dns->receive_rep (rcv);
839 } 900 }
840 901
902 {
841 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section 903 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
842 904
843 int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A; 905 int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
844 pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type 906 pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
845 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class 907 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
846 pkt [offs++] = 0; pkt [offs++] = 0; 908 pkt [offs++] = 0; pkt [offs++] = 0;
847 pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL 909 pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
848 910
849 int rdlen_offs = offs += 2; 911 int rdlen_offs = offs += 2;
850 912
913 if (dns)
914 {
851 int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs; 915 int dlen = ntohs (dns->cfg.max_size) - offs;
916
852 // bind doesn't compress well, so reduce further by one label length 917 // bind doesn't compress well, so reduce further by one label length
853 dlen -= qlen; 918 dlen -= qlen;
854 919
855 if (dns) 920 // only put data into in-order sequence packets, if
856 { 921 // we receive out-of-order packets we generate empty
857 while (dlen > 1 && !dns->snddq.empty ()) 922 // replies
923 //printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
924 if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
858 { 925 {
926 dns->repseq = seqno;
927
928 while (dlen > 1 && !dns->snddq.empty ())
929 {
859 int txtlen = dlen <= 255 ? dlen - 1 : 255; 930 int txtlen = dlen <= 255 ? dlen - 1 : 255;
860 931
861 if (txtlen > dns->snddq.size ()) 932 if (txtlen > dns->snddq.size ())
862 txtlen = dns->snddq.size (); 933 txtlen = dns->snddq.size ();
863 934
864 pkt[offs++] = txtlen; 935 pkt[offs++] = txtlen;
865 memcpy (pkt.at (offs), dns->snddq.begin (), txtlen); 936 memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
866 offs += txtlen; 937 offs += txtlen;
867 dns->snddq.remove (txtlen); 938 dns->snddq.remove (txtlen);
868 939
869 dlen -= txtlen + 1; 940 dlen -= txtlen + 1;
941 }
870 } 942 }
871 943
872 // avoid empty TXT rdata 944 // avoid completely empty TXT rdata
873 if (offs == rdlen_offs) 945 if (offs == rdlen_offs)
874 pkt[offs++] = 0; 946 pkt[offs++] = 0;
875 947
876 slog (L_NOISE, "snddq %d", dns->snddq.size ()); 948 slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
877 } 949 }
878 else 950 else
879 { 951 {
880 // send RST 952 // send RST
881 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; 953 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
882 pkt [offs++] = CMD_IP_RST; 954 pkt [offs++] = CMD_IP_RST;
883 } 955 }
884 956
885 int rdlen = offs - rdlen_offs; 957 int rdlen = offs - rdlen_offs;
886 958
887 pkt [rdlen_offs - 2] = rdlen >> 8; 959 pkt [rdlen_offs - 2] = rdlen >> 8;
888 pkt [rdlen_offs - 1] = rdlen; 960 pkt [rdlen_offs - 1] = rdlen;
889 961
890 if (dns) 962 if (dns)
891 { 963 {
892 // now update dns_rcv copy 964 // now update dns_rcv copy
893 rcv->pkt->len = offs; 965 rcv->pkt->len = offs;
894 memcpy (rcv->pkt->at (0), pkt.at (0), offs); 966 memcpy (rcv->pkt->at (0), pkt.at (0), offs);
895 } 967 }
968 }
896 969
897 duplicate_request: ; 970 duplicate_request: ;
898 } 971 }
899 else 972 else
900 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR); 973 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
… …
912 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class 985 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
913 pkt [offs++] = 0; pkt [offs++] = 0; 986 pkt [offs++] = 0; pkt [offs++] = 0;
914 pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL 987 pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
915 pkt [offs++] = 0; pkt [offs++] = 4; // rdlength 988 pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
916 989
917 slog (L_INFO, _("DNS tunnel: client %d tries to connect"), client); 990 slog (L_INFO, _("DNS: client %d connects"), client);
918 991
919 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; 992 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
920 pkt [offs++] = CMD_IP_REJ; 993 pkt [offs++] = CMD_IP_REJ;
921 994
922 if (0 < client && client <= conns.size ()) 995 if (0 < client && client <= conns.size ())
… …
956 { 1029 {
957 dns_connection *dns = (*i)->dns; 1030 dns_connection *dns = (*i)->dns;
958 connection *c = dns->c; 1031 connection *c = dns->c;
959 int seqno = (*i)->seqno; 1032 int seqno = (*i)->seqno;
960 u8 data[MAXSIZE], *datap = data; 1033 u8 data[MAXSIZE], *datap = data;
1034 //printf ("rcv pkt %x\n", seqno);//D
961 1035
962 if ((*i)->retry) 1036 if ((*i)->retry)
963 { 1037 {
964 dns->send_interval *= 1.001; 1038 dns->send_interval *= 1.01;
965 if (dns->send_interval > MAX_SEND_INTERVAL) 1039 if (dns->send_interval > MAX_SEND_INTERVAL)
966 dns->send_interval = MAX_SEND_INTERVAL; 1040 dns->send_interval = MAX_SEND_INTERVAL;
967 } 1041 }
968 else 1042 else
969 { 1043 {
970#if 1 1044#if 0
971 dns->send_interval *= 0.9999; 1045 dns->send_interval *= 0.999;
972#endif 1046#endif
973 if (dns->send_interval < MIN_SEND_INTERVAL)
974 dns->send_interval = MIN_SEND_INTERVAL;
975
976 // the latency surely puts an upper bound on 1047 // the latency surely puts an upper bound on
977 // the minimum send interval 1048 // the minimum send interval
978 double latency = NOW - (*i)->sent; 1049 double latency = ev_now () - (*i)->sent;
979 1050
980 if (dns->send_interval > latency) 1051 if (latency < dns->min_latency)
981 dns->send_interval = latency; 1052 dns->min_latency = latency;
1053
1054 if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
1055 dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
1056
1057 if (dns->send_interval < conf.dns_send_interval)
1058 dns->send_interval = conf.dns_send_interval;
982 } 1059 }
983 1060
984 delete *i; 1061 delete *i;
985 dns_sndpq.erase (i); 1062 dns_sndpq.erase (i);
986 1063
… …
1036 1113
1037 if (ip [0] == CMD_IP_1 1114 if (ip [0] == CMD_IP_1
1038 && ip [1] == CMD_IP_2 1115 && ip [1] == CMD_IP_2
1039 && ip [2] == CMD_IP_3) 1116 && ip [2] == CMD_IP_3)
1040 { 1117 {
1041 slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]); 1118 slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1042 1119
1043 if (ip [3] == CMD_IP_RST) 1120 if (ip [3] == CMD_IP_RST)
1044 { 1121 {
1045 slog (L_DEBUG, _("got tunnel RST request")); 1122 slog (L_DEBUG, _("DNS: got tunnel RST request"));
1046 1123
1047 delete dns; c->dns = 0; 1124 delete dns; c->dns = 0;
1048 1125
1049 return; 1126 return;
1050 } 1127 }
1051 else if (ip [3] == CMD_IP_SYN) 1128 else if (ip [3] == CMD_IP_SYN)
1052 { 1129 {
1053 slog (L_DEBUG, _("got tunnel SYN reply, server likes us.")); 1130 slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1054 dns->established = true; 1131 dns->established = true;
1055 } 1132 }
1056 else if (ip [3] == CMD_IP_REJ) 1133 else if (ip [3] == CMD_IP_REJ)
1057 { 1134 {
1058 slog (L_DEBUG, _("got tunnel REJ reply, server does not like us, aborting.")); 1135 slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
1059 abort (); 1136 abort ();
1060 } 1137 }
1061 else 1138 else
1062 slog (L_INFO, _("got unknown meta command %02x"), ip [3]); 1139 slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1063 } 1140 }
1064 else 1141 else
1065 slog (L_INFO, _("got spurious a record %d.%d.%d.%d"), 1142 slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1066 ip [0], ip [1], ip [2], ip [3]); 1143 ip [0], ip [1], ip [2], ip [3]);
1067 1144
1068 return; 1145 return;
1069 } 1146 }
1070 1147
1071 int client, rseqno; 1148 int client, rseqno;
1072 decode_header (qname, client, rseqno); 1149 decode_header (qname, client, rseqno);
1073 1150
1074 if (client != THISNODE->id) 1151 if (client != THISNODE->id)
1075 { 1152 {
1076 slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring")); 1153 slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1077 datap = 0; 1154 datap = 0;
1078 } 1155 }
1079 else if (rseqno != seqno) 1156 else if (rseqno != seqno)
1080 { 1157 {
1081 slog (L_DEBUG, _("got dns tunnel response with wrong seqno, badly caching nameserver?")); 1158 slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
1082 datap = 0; 1159 datap = 0;
1083 } 1160 }
1084 } 1161 }
1085 } 1162 }
1086 1163
… …
1091 break; 1168 break;
1092 } 1169 }
1093} 1170}
1094 1171
1095void 1172void
1096vpn::dnsv4_ev (io_watcher &w, short revents) 1173vpn::dnsv4_ev (ev::io &w, int revents)
1097{ 1174{
1098 if (revents & EVENT_READ) 1175 if (revents & EV_READ)
1099 { 1176 {
1100 dns_packet *pkt = new dns_packet; 1177 dns_packet *pkt = new dns_packet;
1101 struct sockaddr_in sa; 1178 struct sockaddr_in sa;
1102 socklen_t sa_len = sizeof (sa); 1179 socklen_t sa_len = sizeof (sa);
1103 1180
1104 pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len); 1181 pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1105 1182
1106 if (pkt->len > 0) 1183 if (pkt->len > 0)
1107 { 1184 {
1108 if (THISNODE->dns_port) 1185 if (ntohs (pkt->flags) & FLAG_RESPONSE)
1186 dnsv4_client (*pkt);
1187 else
1109 { 1188 {
1110 dnsv4_server (*pkt); 1189 dnsv4_server (*pkt);
1111 sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len); 1190 sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1112 } 1191 }
1113 else
1114 dnsv4_client (*pkt);
1115 1192
1116 delete pkt; 1193 delete pkt;
1117 } 1194 }
1118 } 1195 }
1119} 1196}
1120 1197
1121bool 1198bool
1122connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 1199vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1123{ 1200{
1201 int client = ntohl (si.host);
1202
1203 assert (0 < client && client <= conns.size ());
1204
1205 connection *c = conns [client - 1];
1206
1124 if (!dns) 1207 if (!c->dns)
1125 dns = new dns_connection (this); 1208 c->dns = new dns_connection (c);
1126 1209
1127 if (!dns->snddq.put (pkt)) 1210 if (c->dns->snddq.put (pkt))
1128 return false; 1211 c->dns->tw ();
1129 1212
1130 dns->tw.trigger (); 1213 // always return true even if the buffer overflows
1131
1132 return true; 1214 return true;
1133} 1215}
1134 1216
1135void 1217void
1136connection::dnsv4_reset_connection () 1218connection::dnsv4_reset_connection ()
… …
1139} 1221}
1140 1222
1141#define NEXT(w) do { if (next > (w)) next = w; } while (0) 1223#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1142 1224
1143void 1225void
1144dns_connection::time_cb (time_watcher &w) 1226dns_connection::time_cb (ev::timer &w, int revents)
1145{ 1227{
1146 // servers have to be polled 1228 // servers have to be polled
1147 if (THISNODE->dns_port) 1229 if (THISNODE->dns_port)
1148 return; 1230 return;
1149 1231
1150 // check for timeouts and (re)transmit 1232 // check for timeouts and (re)transmit
1151 tstamp next = NOW + poll_interval; 1233 tstamp next = ev::now () + poll_interval;
1152 dns_snd *send = 0; 1234 dns_snd *send = 0;
1153 1235
1154 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin (); 1236 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1155 i != vpn->dns_sndpq.end (); 1237 i != vpn->dns_sndpq.end ();
1156 ++i) 1238 ++i)
1157 { 1239 {
1158 dns_snd *r = *i; 1240 dns_snd *r = *i;
1159 1241
1160 if (r->timeout <= NOW) 1242 if (r->timeout <= ev_now ())
1161 { 1243 {
1162 if (!send) 1244 if (!send)
1163 { 1245 {
1164 send = r; 1246 send = r;
1165 1247
1166 r->retry++; 1248 r->retry++;
1167 r->timeout = NOW + r->retry; 1249 r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
1250 //printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1251
1252 // the following code changes the query section a bit, forcing
1253 // the forwarder to generate a new request
1254 if (r->stdhdr)
1255 encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry);
1168 } 1256 }
1169 } 1257 }
1170 else 1258 else
1171 NEXT (r->timeout); 1259 NEXT (r->timeout);
1172 } 1260 }
1173 1261
1174 if (last_sent + send_interval <= NOW)
1175 {
1176 if (!send) 1262 if (!send)
1263 {
1264 // generate a new packet, if wise
1265
1266 if (!established)
1177 { 1267 {
1178 // generate a new packet, if wise
1179
1180 if (!established)
1181 {
1182 if (vpn->dns_sndpq.empty ()) 1268 if (vpn->dns_sndpq.empty ())
1183 {
1184 send = new dns_snd (this);
1185
1186 cfg.reset (THISNODE->id);
1187 send->gen_syn_req (cfg);
1188 }
1189 }
1190 else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING)
1191 { 1269 {
1192 send = new dns_snd (this); 1270 send = new dns_snd (this);
1271
1272 cfg.reset (THISNODE->id);
1273 send->gen_syn_req ();
1274 }
1275 }
1276 else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1277 && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1278 {
1279 if (last_sent + send_interval <= ev_now ())
1280 {
1281 //printf ("sending data request etc.\n"); //D
1282 if (!snddq.empty () || last_received + 1. > ev_now ())
1283 {
1284 poll_interval = send_interval;
1285 NEXT (ev_now () + send_interval);
1286 }
1287
1288 send = new dns_snd (this);
1193 send->gen_stream_req (sndseq, snddq); 1289 send->gen_stream_req (sndseq, snddq);
1290 send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
1291 //printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1194 1292
1195 sndseq = (sndseq + 1) & SEQNO_MASK; 1293 sndseq = (sndseq + 1) & SEQNO_MASK;
1196 } 1294 }
1197 1295 else
1198 if (send) 1296 NEXT (last_sent + send_interval);
1199 vpn->dns_sndpq.push_back (send);
1200 } 1297 }
1201 1298
1202 if (send) 1299 if (send)
1203 { 1300 vpn->dns_sndpq.push_back (send);
1204 last_sent = NOW; 1301 }
1302
1303 if (send)
1304 {
1305 last_sent = ev_now ();
1205 sendto (vpn->dnsv4_fd, 1306 sendto (vpn->dnsv4_fd,
1206 send->pkt->at (0), send->pkt->len, 0, 1307 send->pkt->at (0), send->pkt->len, 0,
1207 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ()); 1308 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1208 }
1209 } 1309 }
1210 else
1211 NEXT (last_sent + send_interval);
1212 1310
1213 slog (L_NOISE, "pi %f si %f N %f (%d:%d)", 1311 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1214 poll_interval, send_interval, next - NOW, 1312 poll_interval, send_interval, next - ev_now (),
1215 vpn->dns_sndpq.size (), snddq.size ()); 1313 vpn->dns_sndpq.size (), snddq.size (),
1314 rcvpq.size ());
1216 1315
1217 // TODO: no idea when this happens, but when next < NOW, we have a problem 1316 // TODO: no idea when this happens, but when next < ev_now (), we have a problem
1317 // doesn't seem to happen anymore
1218 if (next < NOW + 0.0001) 1318 if (next < ev_now () + 0.001)
1219 next = NOW + 0.1; 1319 next = ev_now () + 0.1;
1220 1320
1221 w.start (next); 1321 w.start (next - ev_now ());
1222} 1322}
1223 1323
1224#endif 1324#endif
1225 1325

Diff Legend

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