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.11 by pcg, Fri Mar 4 08:45:24 2005 UTC vs.
Revision 1.37 by pcg, Wed Mar 23 17:03:58 2005 UTC

… …
25 25
26// dns processing is EXTREMELY ugly. For obvious(?) reasons. 26// dns processing is EXTREMELY ugly. For obvious(?) reasons.
27// it's a hack, use only in emergency situations please. 27// it's a hack, use only in emergency situations please.
28 28
29#include <cstring> 29#include <cstring>
30#include <cassert>
30 31
31#include <sys/types.h> 32#include <sys/types.h>
32#include <sys/socket.h> 33#include <sys/socket.h>
33#include <sys/wait.h> 34#include <sys/wait.h>
34#include <sys/uio.h> 35#include <sys/uio.h>
… …
43 44
44#include "netcompat.h" 45#include "netcompat.h"
45 46
46#include "vpn.h" 47#include "vpn.h"
47 48
48#define MIN_POLL_INTERVAL .2 // 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 49#define MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data
50#define ACTIVITY_INTERVAL 5. 50#define ACTIVITY_INTERVAL 5.
51 51
52#define INITIAL_TIMEOUT 1. 52#define INITIAL_TIMEOUT 0.1 // retry timeouts
53#define INITIAL_SYN_TIMEOUT 2. 53#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54 54
55#define MIN_SEND_INTERVAL 0.001
56#define MAX_SEND_INTERVAL 0.5 // optimistic? 55#define MAX_SEND_INTERVAL 2. // optimistic?
57 56
58#define MAX_OUTSTANDING 400 // max. outstanding requests
59#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING 57#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
60#define MAX_BACKLOG (100*1024) // size of protocol backlog, must be > MAXSIZE 58#define MAX_BACKLOG (64*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
61 59
62#define MAX_DOMAIN_SIZE 220 // 255 is legal limit, but bind doesn't compress well 60#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 61// 240 leaves about 4 bytes of server reply data
64// every two request byte sless give room for one reply byte 62// every request byte less give room for two reply bytes
65 63
66#define SEQNO_MASK 0xffff 64#define SEQNO_MASK 0x3fff
67#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) ) 65#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
68 66
69#define MAX_LBL_SIZE 63 67#define MAX_LBL_SIZE 63
70#define MAX_PKT_SIZE 512 68#define MAX_PKT_SIZE 512
71 69
… …
264static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO"); 262static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
265 263
266///////////////////////////////////////////////////////////////////////////// 264/////////////////////////////////////////////////////////////////////////////
267 265
268#define HDRSIZE 6 266#define HDRSIZE 6
269 267
270inline void encode_header (char *data, int clientid, int seqno) 268inline void encode_header (char *data, int clientid, int seqno, int retry = 0)
271{ 269{
272 u8 hdr[3] = { clientid, seqno >> 8, seqno }; 270 seqno &= SEQNO_MASK;
271
272 u8 hdr[3] = {
273 clientid,
274 (seqno >> 8) | (retry << 6),
275 seqno,
276 };
273 277
274 assert (clientid < 256); 278 assert (clientid < 256);
275 279
276 cdc26.encode (data, hdr, 3); 280 cdc26.encode (data, hdr, 3);
277} 281}
… …
281 u8 hdr[3]; 285 u8 hdr[3];
282 286
283 cdc26.decode (hdr, data, HDRSIZE); 287 cdc26.decode (hdr, data, HDRSIZE);
284 288
285 clientid = hdr[0]; 289 clientid = hdr[0];
286 seqno = (hdr[1] << 8) | hdr[2]; 290 seqno = ((hdr[1] << 8) | hdr[2]) & SEQNO_MASK;
287} 291}
288 292
289///////////////////////////////////////////////////////////////////////////// 293/////////////////////////////////////////////////////////////////////////////
290 294
291struct byte_stream 295struct byte_stream
… …
320} 324}
321 325
322void byte_stream::remove (int count) 326void byte_stream::remove (int count)
323{ 327{
324 if (count > fill) 328 if (count > fill)
325 abort (); 329 assert (count <= fill);
326 330
327 memmove (data, data + count, fill -= count); 331 memmove (data, data + count, fill -= count);
328} 332}
329 333
330bool byte_stream::put (u8 *data, unsigned int datalen) 334bool byte_stream::put (u8 *data, unsigned int datalen)
… …
350 return true; 354 return true;
351} 355}
352 356
353vpn_packet *byte_stream::get () 357vpn_packet *byte_stream::get ()
354{ 358{
359 unsigned int len;
360
361 for (;;)
362 {
355 int len = (data [0] << 8) | data [1]; 363 len = (data [0] << 8) | data [1];
356 364
357 if (len > MAXSIZE && fill >= 2) 365 if (len <= MAXSIZE || fill < 2)
358 abort (); // TODO handle this gracefully, connection reset 366 break;
359 367
368 // TODO: handle this better than skipping, e.g. by reset
369 slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
370 remove (1);
371 }
372
360 if (fill < len + 2) 373 if (fill < len + 2)
361 return 0; 374 return 0;
362 375
363 vpn_packet *pkt = new vpn_packet; 376 vpn_packet *pkt = new vpn_packet;
364 377
… …
393struct dns_cfg 406struct dns_cfg
394{ 407{
395 static int next_uid; 408 static int next_uid;
396 409
397 u8 id1, id2, id3, id4; 410 u8 id1, id2, id3, id4;
411
398 u8 version; 412 u8 version;
413 u8 flags;
399 u8 rrtype; 414 u8 rrtype;
400 u8 flags;
401 u8 def_ttl; 415 u8 def_ttl;
402 u8 rcv_cdc; 416
403 u8 snd_cdc;
404 u16 max_size;
405 u16 client; 417 u16 client;
406 u16 uid; // to make request unique 418 u16 uid; // to make request unique
407 419
408 u8 reserved[8]; 420 u16 max_size;
421 u8 seq_cdc;
422 u8 req_cdc;
423
424 u8 rep_cdc;
425 u8 delay; // time in 0.01s units that the server may delay replying packets
426 u8 r3, r4;
427
428 u8 r5, r6, r7, r8;
409 429
410 void reset (int clientid); 430 void reset (int clientid);
411 bool valid (); 431 bool valid ();
412}; 432};
413 433
… …
423 version = 1; 443 version = 1;
424 444
425 rrtype = RR_TYPE_TXT; 445 rrtype = RR_TYPE_TXT;
426 flags = 0; 446 flags = 0;
427 def_ttl = 0; 447 def_ttl = 0;
448 seq_cdc = 26;
449 req_cdc = 62;
428 rcv_cdc = 0; 450 rep_cdc = 0;
429 snd_cdc = 62;
430 max_size = ntohs (MAX_PKT_SIZE); 451 max_size = htons (MAX_PKT_SIZE);
431 client = ntohs (clientid); 452 client = htons (clientid);
432 uid = next_uid++; 453 uid = next_uid++;
454 delay = 0;
433 455
434 memset (reserved, 0, 8); 456 r3 = r4 = 0;
457 r4 = r5 = r6 = r7 = 0;
435} 458}
436 459
437bool dns_cfg::valid () 460bool dns_cfg::valid ()
438{ 461{
439 return id1 == 'G' 462 return id1 == 'G'
440 && id2 == 'V' 463 && id2 == 'V'
441 && id3 == 'P' 464 && id3 == 'P'
442 && id4 == 'E' 465 && id4 == 'E'
466 && seq_cdc == 26
467 && req_cdc == 62
468 && rep_cdc == 0
443 && version == 1 469 && version == 1;
444 && flags == 0
445 && rcv_cdc == 0
446 && snd_cdc == 62
447 && max_size == ntohs (MAX_PKT_SIZE);
448} 470}
449 471
450struct dns_packet : net_packet 472struct dns_packet : net_packet
451{ 473{
452 u16 id; 474 u16 id;
453 u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4 475 u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
454 u16 qdcount, ancount, nscount, arcount; 476 u16 qdcount, ancount, nscount, arcount;
455 477
456 u8 data[MAXSIZE - 6 * 2]; 478 u8 data [MAXSIZE - 6 * 2];
457 479
458 int decode_label (char *data, int size, int &offs); 480 int decode_label (char *data, int size, int &offs);
459}; 481};
460 482
461int dns_packet::decode_label (char *data, int size, int &offs) 483int dns_packet::decode_label (char *data, int size, int &offs)
… …
492 return data - orig; 514 return data - orig;
493} 515}
494 516
495///////////////////////////////////////////////////////////////////////////// 517/////////////////////////////////////////////////////////////////////////////
496 518
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 519static u16 dns_id = 0; // TODO: should be per-vpn
513 520
514static u16 next_id () 521static u16 next_id ()
515{ 522{
523 if (!dns_id)
524 dns_id = time (0);
525
516 // the simplest lsfr with periodicity 65535 i could find 526 // the simplest lsfr with periodicity 65535 i could find
517 dns_id = (dns_id << 1) 527 dns_id = (dns_id << 1)
518 | (((dns_id >> 1) 528 | (((dns_id >> 1)
519 ^ (dns_id >> 2) 529 ^ (dns_id >> 2)
520 ^ (dns_id >> 4) 530 ^ (dns_id >> 4)
521 ^ (dns_id >> 15)) & 1); 531 ^ (dns_id >> 15)) & 1);
522 532
523 return dns_id; 533 return dns_id;
524} 534}
525 535
536struct dns_rcv;
537struct dns_snd;
538
539struct dns_connection
540{
541 connection *c;
542 struct vpn *vpn;
543
544 dns_cfg cfg;
545
546 bool established;
547
548 tstamp last_received;
549 tstamp last_sent;
550 double min_latency;
551 double poll_interval, send_interval;
552
553 vector<dns_rcv *> rcvpq;
554
555 byte_stream rcvdq; int rcvseq; int repseq;
556 byte_stream snddq; int sndseq;
557
558 void time_cb (time_watcher &w); time_watcher tw;
559 void receive_rep (dns_rcv *r);
560
561 dns_connection (connection *c);
562 ~dns_connection ();
563};
564
565struct dns_snd
566{
567 dns_packet *pkt;
568 tstamp timeout, sent;
569 int retry;
570 struct dns_connection *dns;
571 int seqno;
572 bool stdhdr;
573
574 void gen_stream_req (int seqno, byte_stream &stream);
575 void gen_syn_req ();
576
577 dns_snd (dns_connection *dns);
578 ~dns_snd ();
579};
580
526dns_snd::dns_snd (dns_connection *dns) 581dns_snd::dns_snd (dns_connection *dns)
527: dns (dns) 582: dns (dns)
528{ 583{
529 timeout = 0; 584 timeout = 0;
530 retry = 0; 585 retry = 0;
531 seqno = 0; 586 seqno = 0;
532 sent = NOW; 587 sent = NOW;
588 stdhdr = false;
533 589
534 pkt = new dns_packet; 590 pkt = new dns_packet;
535 591
536 pkt->id = next_id (); 592 pkt->id = next_id ();
537} 593}
… …
564 } 620 }
565} 621}
566 622
567void dns_snd::gen_stream_req (int seqno, byte_stream &stream) 623void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
568{ 624{
625 stdhdr = true;
569 this->seqno = seqno; 626 this->seqno = seqno;
570 627
571 timeout = NOW + INITIAL_TIMEOUT; 628 timeout = NOW + INITIAL_TIMEOUT;
572 629
573 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 630 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
574 pkt->qdcount = htons (1); 631 pkt->qdcount = htons (1);
575 632
576 int offs = 6*2; 633 int offs = 6*2;
577 int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2); 634 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, 635 // 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 636 // so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
580 637
581 char enc[256], *encp = enc; 638 char enc[256], *encp = enc;
582 encode_header (enc, THISNODE->id, seqno); 639 encode_header (enc, THISNODE->id, seqno);
… …
600 encp += lbllen; 657 encp += lbllen;
601 658
602 enclen -= lbllen; 659 enclen -= lbllen;
603 } 660 }
604 661
605 append_domain (*pkt, offs, THISNODE->domain); 662 append_domain (*pkt, offs, dns->c->conf->domain);
606 663
607 (*pkt)[offs++] = 0; 664 (*pkt)[offs++] = 0;
608 (*pkt)[offs++] = RR_TYPE_ANY >> 8; (*pkt)[offs++] = RR_TYPE_ANY; 665 (*pkt)[offs++] = RR_TYPE_ANY >> 8; (*pkt)[offs++] = RR_TYPE_ANY;
609 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN; 666 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
610 667
611 pkt->len = offs; 668 pkt->len = offs;
612} 669}
613 670
614void dns_snd::gen_syn_req (const dns_cfg &cfg) 671void dns_snd::gen_syn_req ()
615{ 672{
616 timeout = NOW + INITIAL_SYN_TIMEOUT; 673 timeout = NOW + INITIAL_SYN_TIMEOUT;
617 674
618 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 675 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
619 pkt->qdcount = htons (1); 676 pkt->qdcount = htons (1);
620 677
621 int offs = 6*2; 678 int offs = 6 * 2;
622 679
623 int elen = cdc26.encode ((char *)pkt->at (offs + 1), (u8 *)&cfg, sizeof (dns_cfg)); 680 int elen = cdc26.encode ((char *)pkt->at (offs + 1), (u8 *)&dns->cfg, sizeof (dns_cfg));
624 681
625 assert (elen <= MAX_LBL_SIZE); 682 assert (elen <= MAX_LBL_SIZE);
626 683
627 (*pkt)[offs] = elen; 684 (*pkt)[offs] = elen;
628 offs += elen + 1; 685 offs += elen + 1;
629 append_domain (*pkt, offs, THISNODE->domain); 686 append_domain (*pkt, offs, dns->c->conf->domain);
630 687
631 (*pkt)[offs++] = 0; 688 (*pkt)[offs++] = 0;
632 (*pkt)[offs++] = RR_TYPE_A >> 8; (*pkt)[offs++] = RR_TYPE_A; 689 (*pkt)[offs++] = RR_TYPE_A >> 8; (*pkt)[offs++] = RR_TYPE_A;
633 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN; 690 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
634 691
… …
657 delete pkt; 714 delete pkt;
658} 715}
659 716
660///////////////////////////////////////////////////////////////////////////// 717/////////////////////////////////////////////////////////////////////////////
661 718
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) 719dns_connection::dns_connection (connection *c)
688: c (c) 720: c (c)
689, rcvdq (MAX_BACKLOG * 2) 721, rcvdq (MAX_BACKLOG * 2)
690, snddq (MAX_BACKLOG * 2) 722, snddq (MAX_BACKLOG)
691, tw (this, &dns_connection::time_cb) 723, tw (this, &dns_connection::time_cb)
692{ 724{
693 vpn = c->vpn; 725 vpn = c->vpn;
694 726
695 established = false; 727 established = false;
696 728
697 rcvseq = sndseq = 0; 729 rcvseq = repseq = sndseq = 0;
698 730
699 last_sent = last_received = 0; 731 last_sent = last_received = 0;
700 poll_interval = MIN_POLL_INTERVAL; 732 poll_interval = 0.5; // starting here
701 send_interval = 0.2; // starting rate 733 send_interval = 0.5; // starting rate
734 min_latency = INITIAL_TIMEOUT;
702} 735}
703 736
704dns_connection::~dns_connection () 737dns_connection::~dns_connection ()
705{ 738{
706 for (vector<dns_rcv *>::iterator i = rcvpq.begin (); 739 for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
… …
714 if (r->datalen) 747 if (r->datalen)
715 { 748 {
716 last_received = NOW; 749 last_received = NOW;
717 tw.trigger (); 750 tw.trigger ();
718 751
719 poll_interval *= 0.99; 752 poll_interval = send_interval;
720 if (poll_interval > MIN_POLL_INTERVAL)
721 poll_interval = MIN_POLL_INTERVAL;
722 } 753 }
723 else 754 else
724 { 755 {
725 poll_interval *= 1.1; 756 poll_interval *= 1.5;
757
726 if (poll_interval > MAX_POLL_INTERVAL) 758 if (poll_interval > MAX_POLL_INTERVAL)
727 poll_interval = MAX_POLL_INTERVAL; 759 poll_interval = MAX_POLL_INTERVAL;
728 } 760 }
729 761
730 rcvpq.push_back (r); 762 rcvpq.push_back (r);
… …
748 } 780 }
749 781
750 rcvseq = (rcvseq + 1) & SEQNO_MASK; 782 rcvseq = (rcvseq + 1) & SEQNO_MASK;
751 783
752 if (!rcvdq.put (r->data, r->datalen)) 784 if (!rcvdq.put (r->data, r->datalen))
785 {
786 slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
753 abort (); // MUST never overflow, can be caused by data corruption, TODO 787 abort (); // MUST never overflow, can be caused by data corruption, TODO
788 }
754 789
755 while (vpn_packet *pkt = rcvdq.get ()) 790 while (vpn_packet *pkt = rcvdq.get ())
756 { 791 {
757 sockinfo si; 792 sockinfo si;
758 si.host = 0; si.port = 0; si.prot = PROT_DNSv4; 793 si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
759 794
760 vpn->recv_vpn_packet (pkt, si); 795 vpn->recv_vpn_packet (pkt, si);
761 796
762 delete pkt; 797 delete pkt;
763 } 798 }
… …
777 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR); 812 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
778 813
779 if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK)) 814 if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK))
780 && pkt.qdcount == htons (1)) 815 && pkt.qdcount == htons (1))
781 { 816 {
782 char qname[MAXSIZE]; 817 char qname [MAXSIZE];
783 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs); 818 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
784 819
785 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++]; 820 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++];
786 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++]; 821 u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++];
787 822
788 pkt.qdcount = htons (1); 823 pkt.qdcount = htons (1);
789 pkt.ancount = 0; 824 pkt.ancount = 0;
790 pkt.nscount = 0; // should be self, as other nameservers reply like this 825 pkt.nscount = 0; // should be self, as other nameservers reply like this
791 pkt.arcount = 0; // a record for self, as other nameservers reply like this 826 pkt.arcount = 0; // a record for self, as other nameservers reply like this
792 827
793 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_NXDOMAIN); 828 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_SERVFAIL);
794 829
795 int dlen = strlen (THISNODE->domain); 830 int dlen = strlen (THISNODE->domain);
796 831
797 if (qclass == RR_CLASS_IN 832 if (qclass == RR_CLASS_IN
798 && qlen > dlen + 1 833 && qlen > dlen + 1
799 && !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen)) 834 && !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
800 { 835 {
801 // now generate reply 836 // now generate reply
802 pkt.ancount = htons (1); // one answer RR 837 pkt.ancount = htons (1); // one answer RR
803 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK); 838 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK);
804 839
… …
826 if (SEQNO_EQ ((*i)->seqno, seqno)) 861 if (SEQNO_EQ ((*i)->seqno, seqno))
827 { 862 {
828 // already seen that request: simply reply with the cached reply 863 // already seen that request: simply reply with the cached reply
829 dns_rcv *r = *i; 864 dns_rcv *r = *i;
830 865
831 printf ("DUPLICATE %d\n", htons (r->pkt->id));//D 866 slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno);
867
868 // refresh header & id, as the retry count could have changed
869 memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE);
870 r->pkt->id = pkt.id;
832 871
833 memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len); 872 memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
834 pkt.id = r->pkt->id; 873
835 goto duplicate_request; 874 goto duplicate_request;
836 } 875 }
837 876
838 // new packet, queue 877 // new packet, queue
839 rcv = new dns_rcv (seqno, data, datalen); 878 rcv = new dns_rcv (seqno, data, datalen);
840 dns->receive_rep (rcv); 879 dns->receive_rep (rcv);
841 } 880 }
842 881
882 {
843 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section 883 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
844 884
845 int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A; 885 int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
846 pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type 886 pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
847 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class 887 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
848 pkt [offs++] = 0; pkt [offs++] = 0; 888 pkt [offs++] = 0; pkt [offs++] = 0;
849 pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL 889 pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
850 890
851 int rdlen_offs = offs += 2; 891 int rdlen_offs = offs += 2;
852 892
893 if (dns)
894 {
853 int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs; 895 int dlen = ntohs (dns->cfg.max_size) - offs;
896
854 // bind doesn't compress well, so reduce further by one label length 897 // bind doesn't compress well, so reduce further by one label length
855 dlen -= qlen; 898 dlen -= qlen;
856 899
857 if (dns) 900 // only put data into in-order sequence packets, if
858 { 901 // we receive out-of-order packets we generate empty
859 while (dlen > 1 && !dns->snddq.empty ()) 902 // replies
903 //printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
904 if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
860 { 905 {
906 dns->repseq = seqno;
907
908 while (dlen > 1 && !dns->snddq.empty ())
909 {
861 int txtlen = dlen <= 255 ? dlen - 1 : 255; 910 int txtlen = dlen <= 255 ? dlen - 1 : 255;
862 911
863 if (txtlen > dns->snddq.size ()) 912 if (txtlen > dns->snddq.size ())
864 txtlen = dns->snddq.size (); 913 txtlen = dns->snddq.size ();
865 914
866 pkt[offs++] = txtlen; 915 pkt[offs++] = txtlen;
867 memcpy (pkt.at (offs), dns->snddq.begin (), txtlen); 916 memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
868 offs += txtlen; 917 offs += txtlen;
869 dns->snddq.remove (txtlen); 918 dns->snddq.remove (txtlen);
870 919
871 dlen -= txtlen + 1; 920 dlen -= txtlen + 1;
921 }
872 } 922 }
873 923
874 // avoid empty TXT rdata 924 // avoid completely empty TXT rdata
875 if (offs == rdlen_offs) 925 if (offs == rdlen_offs)
876 pkt[offs++] = 0; 926 pkt[offs++] = 0;
927
928 slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
877 } 929 }
878 else 930 else
879 { 931 {
880 // send RST 932 // send RST
881 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; 933 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
882 pkt [offs++] = CMD_IP_RST; 934 pkt [offs++] = CMD_IP_RST;
883 } 935 }
884 936
885 int rdlen = offs - rdlen_offs; 937 int rdlen = offs - rdlen_offs;
886 938
887 pkt [rdlen_offs - 2] = rdlen >> 8; 939 pkt [rdlen_offs - 2] = rdlen >> 8;
888 pkt [rdlen_offs - 1] = rdlen; 940 pkt [rdlen_offs - 1] = rdlen;
889 941
890 if (dns) 942 if (dns)
891 { 943 {
892 // now update dns_rcv copy 944 // now update dns_rcv copy
893 rcv->pkt->len = offs; 945 rcv->pkt->len = offs;
894 memcpy (rcv->pkt->at (0), pkt.at (0), offs); 946 memcpy (rcv->pkt->at (0), pkt.at (0), offs);
895 } 947 }
948 }
896 949
897 duplicate_request: ; 950 duplicate_request: ;
898 } 951 }
899 else 952 else
900 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR); 953 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
… …
912 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class 965 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
913 pkt [offs++] = 0; pkt [offs++] = 0; 966 pkt [offs++] = 0; pkt [offs++] = 0;
914 pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL 967 pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
915 pkt [offs++] = 0; pkt [offs++] = 4; // rdlength 968 pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
916 969
917 slog (L_INFO, _("DNS tunnel: client %d tries to connect"), client); 970 slog (L_INFO, _("DNS: client %d connects"), client);
918 971
919 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; 972 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
920 pkt [offs++] = CMD_IP_REJ; 973 pkt [offs++] = CMD_IP_REJ;
921 974
922 if (0 < client && client <= conns.size ()) 975 if (0 < client && client <= conns.size ())
… …
953 i != dns_sndpq.end (); 1006 i != dns_sndpq.end ();
954 ++i) 1007 ++i)
955 if ((*i)->pkt->id == pkt.id) 1008 if ((*i)->pkt->id == pkt.id)
956 { 1009 {
957 dns_connection *dns = (*i)->dns; 1010 dns_connection *dns = (*i)->dns;
1011 connection *c = dns->c;
958 int seqno = (*i)->seqno; 1012 int seqno = (*i)->seqno;
959 u8 data[MAXSIZE], *datap = data; 1013 u8 data[MAXSIZE], *datap = data;
960 1014
961 if ((*i)->retry) 1015 if ((*i)->retry)
962 { 1016 {
963 dns->send_interval *= 1.01; 1017 dns->send_interval *= 1.01;
964 if (dns->send_interval < MAX_SEND_INTERVAL) 1018 if (dns->send_interval > MAX_SEND_INTERVAL)
965 dns->send_interval = MAX_SEND_INTERVAL; 1019 dns->send_interval = MAX_SEND_INTERVAL;
966 } 1020 }
967 else 1021 else
968 { 1022 {
1023#if 0
969 dns->send_interval *= 0.99; 1024 dns->send_interval *= 0.999;
970 if (dns->send_interval < MIN_SEND_INTERVAL) 1025#endif
971 dns->send_interval = MIN_SEND_INTERVAL;
972
973 // the latency surely puts an upper bound on 1026 // the latency surely puts an upper bound on
974 // the minimum send interval 1027 // the minimum send interval
975 if (dns->send_interval > NOW - (*i)->sent) 1028 double latency = NOW - (*i)->sent;
976 dns->send_interval = NOW - (*i)->sent; 1029
1030 if (latency < dns->min_latency)
1031 dns->min_latency = latency;
1032
1033 if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
1034 dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
1035
1036 if (dns->send_interval < conf.dns_send_interval)
1037 dns->send_interval = conf.dns_send_interval;
977 } 1038 }
978 1039
979 delete *i; 1040 delete *i;
980 dns_sndpq.erase (i); 1041 dns_sndpq.erase (i);
981 1042
… …
1031 1092
1032 if (ip [0] == CMD_IP_1 1093 if (ip [0] == CMD_IP_1
1033 && ip [1] == CMD_IP_2 1094 && ip [1] == CMD_IP_2
1034 && ip [2] == CMD_IP_3) 1095 && ip [2] == CMD_IP_3)
1035 { 1096 {
1036 slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]); 1097 slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1037 1098
1038 if (ip [3] == CMD_IP_RST) 1099 if (ip [3] == CMD_IP_RST)
1039 { 1100 {
1040 slog (L_DEBUG, _("got tunnel RST request")); 1101 slog (L_DEBUG, _("DNS: got tunnel RST request"));
1041 1102
1042 connection *c = dns->c;
1043 delete c->dns; c->dns = 0; 1103 delete dns; c->dns = 0;
1044 1104
1045 return; 1105 return;
1046 } 1106 }
1047 else if (ip [3] == CMD_IP_SYN) 1107 else if (ip [3] == CMD_IP_SYN)
1108 {
1109 slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1048 dns->established = true; 1110 dns->established = true;
1111 }
1112 else if (ip [3] == CMD_IP_REJ)
1113 {
1114 slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
1115 abort ();
1116 }
1049 else 1117 else
1050 slog (L_INFO, _("got unknown meta command %02x"), ip [3]); 1118 slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1051 } 1119 }
1052 else 1120 else
1053 slog (L_INFO, _("got spurious a record %d.%d.%d.%d"), 1121 slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1054 ip [0], ip [1], ip [2], ip [3]); 1122 ip [0], ip [1], ip [2], ip [3]);
1055 1123
1056 return; 1124 return;
1057 } 1125 }
1058 1126
1059 int client, rseqno; 1127 int client, rseqno;
1060 decode_header (qname, client, rseqno); 1128 decode_header (qname, client, rseqno);
1061 1129
1062 if (client != THISNODE->id) 1130 if (client != THISNODE->id)
1063 { 1131 {
1064 slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring")); 1132 slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1065 datap = 0; 1133 datap = 0;
1066 } 1134 }
1067 else if (rseqno != seqno) 1135 else if (rseqno != seqno)
1068 { 1136 {
1069 slog (L_DEBUG, _("got dns tunnel response with wrong seqno, badly caching nameserver?")); 1137 slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
1070 datap = 0; 1138 datap = 0;
1071 } 1139 }
1072 } 1140 }
1073 } 1141 }
1074 1142
… …
1091 1159
1092 pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len); 1160 pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1093 1161
1094 if (pkt->len > 0) 1162 if (pkt->len > 0)
1095 { 1163 {
1096 if (THISNODE->dns_port) 1164 if (ntohs (pkt->flags) & FLAG_RESPONSE)
1165 dnsv4_client (*pkt);
1166 else
1097 { 1167 {
1098 dnsv4_server (*pkt); 1168 dnsv4_server (*pkt);
1099 sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len); 1169 sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1100 } 1170 }
1101 else
1102 dnsv4_client (*pkt);
1103 1171
1104 delete pkt; 1172 delete pkt;
1105 } 1173 }
1106 } 1174 }
1107} 1175}
1108 1176
1109bool 1177bool
1110connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 1178vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1111{ 1179{
1180 int client = ntohl (si.host);
1181
1182 assert (0 < client && client <= conns.size ());
1183
1184 connection *c = conns [client - 1];
1185
1112 if (!dns) 1186 if (!c->dns)
1113 dns = new dns_connection (this); 1187 c->dns = new dns_connection (c);
1114 1188
1115 if (!dns->snddq.put (pkt)) 1189 if (c->dns->snddq.put (pkt))
1116 return false;
1117
1118 dns->tw.trigger (); 1190 c->dns->tw.trigger ();
1119 1191
1192 // always return true even if the buffer overflows
1120 return true; 1193 return true;
1194}
1195
1196void
1197connection::dnsv4_reset_connection ()
1198{
1199 //delete dns; dns = 0; //TODO
1121} 1200}
1122 1201
1123#define NEXT(w) do { if (next > (w)) next = w; } while (0) 1202#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1124 1203
1125void 1204void
… …
1144 if (!send) 1223 if (!send)
1145 { 1224 {
1146 send = r; 1225 send = r;
1147 1226
1148 r->retry++; 1227 r->retry++;
1149 r->timeout = NOW + r->retry; 1228 r->timeout = NOW + (r->retry * min_latency * conf.dns_timeout_factor);
1229
1230 // the following code changes the query section a bit, forcing
1231 // the forwarder to generate a new request
1232 if (r->stdhdr)
1233 {
1234 //printf ("reencoded header for ID %d retry %d:%d:%d (%p)\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);
1235 //encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry);
1236 }
1150 } 1237 }
1151 } 1238 }
1152 else 1239 else
1153 NEXT (r->timeout); 1240 NEXT (r->timeout);
1154 } 1241 }
1155 1242
1156 if (last_sent + send_interval <= NOW)
1157 {
1158 if (!send) 1243 if (!send)
1244 {
1245 // generate a new packet, if wise
1246
1247 if (!established)
1159 { 1248 {
1160 // generate a new packet, if wise
1161
1162 if (!established)
1163 {
1164 if (vpn->dns_sndpq.empty ()) 1249 if (vpn->dns_sndpq.empty ())
1165 {
1166 send = new dns_snd (this);
1167
1168 cfg.reset (THISNODE->id);
1169 send->gen_syn_req (cfg);
1170 }
1171 }
1172 else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING)
1173 { 1250 {
1174 send = new dns_snd (this); 1251 send = new dns_snd (this);
1252
1253 cfg.reset (THISNODE->id);
1254 send->gen_syn_req ();
1255 }
1256 }
1257 else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1258 && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1259 {
1260 if (last_sent + send_interval <= NOW)
1261 {
1262 //printf ("sending data request etc.\n"); //D
1263 if (!snddq.empty () || last_received + 1. > NOW)
1264 {
1265 poll_interval = send_interval;
1266 NEXT (NOW + send_interval);
1267 }
1268
1269 send = new dns_snd (this);
1175 send->gen_stream_req (sndseq, snddq); 1270 send->gen_stream_req (sndseq, snddq);
1271 send->timeout = NOW + min_latency * conf.dns_timeout_factor;
1176 1272
1177 sndseq = (sndseq + 1) & SEQNO_MASK; 1273 sndseq = (sndseq + 1) & SEQNO_MASK;
1178 } 1274 }
1179 1275 else
1180 if (send) 1276 NEXT (last_sent + send_interval);
1181 vpn->dns_sndpq.push_back (send);
1182 } 1277 }
1183 1278
1184 if (send) 1279 if (send)
1185 { 1280 vpn->dns_sndpq.push_back (send);
1281 }
1282
1283 if (send)
1284 {
1186 last_sent = NOW; 1285 last_sent = NOW;
1187
1188 sendto (vpn->dnsv4_fd, 1286 sendto (vpn->dnsv4_fd,
1189 send->pkt->at (0), send->pkt->len, 0, 1287 send->pkt->at (0), send->pkt->len, 0,
1190 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ()); 1288 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1191 }
1192 } 1289 }
1193 else
1194 NEXT (last_sent + send_interval);
1195 1290
1196 //printf ("pi %f si %f N %f (%d:%d)\n", poll_interval, send_interval, next - NOW, vpn->dns_sndpq.size (), snddq.size ()); 1291 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1292 poll_interval, send_interval, next - NOW,
1293 vpn->dns_sndpq.size (), snddq.size (),
1294 rcvpq.size ());
1197 1295
1198 // TODO: no idea when this happens, but when next < NOW, we have a problem 1296 // TODO: no idea when this happens, but when next < NOW, we have a problem
1297 // doesn't seem to happen anymore
1199 if (next < NOW + 0.0001) 1298 if (next < NOW + 0.001)
1200 next = NOW + 0.1; 1299 next = NOW + 0.1;
1201 1300
1202 w.start (next); 1301 w.start (next);
1203} 1302}
1204 1303

Diff Legend

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