… | |
… | |
47 | |
47 | |
48 | #define MIN_POLL_INTERVAL .02 // how often to poll minimally when the server has data |
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 |
49 | #define MAX_POLL_INTERVAL 6. // 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. // retry timeouts |
52 | #define INITIAL_TIMEOUT 0.1 // retry timeouts |
53 | #define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn |
53 | #define INITIAL_SYN_TIMEOUT 10. // retry timeout for initial syn |
54 | |
54 | |
55 | #define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests |
55 | #define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests |
56 | #define MAX_SEND_INTERVAL 0.5 // optimistic? |
56 | #define MAX_SEND_INTERVAL 0.5 // optimistic? |
57 | |
57 | |
58 | #define MAX_OUTSTANDING 40 // max. outstanding requests |
58 | #define MAX_OUTSTANDING 10 // max. outstanding requests |
59 | #define MAX_WINDOW 100 // max. for MAX_OUTSTANDING |
59 | #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 |
60 | #define MAX_BACKLOG (100*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE |
61 | |
61 | |
62 | #define MAX_DOMAIN_SIZE 220 // 255 is legal limit, but bind doesn't compress well |
62 | #define MAX_DOMAIN_SIZE 220 // 255 is legal limit, but bind doesn't compress well |
63 | // 240 leaves about 4 bytes of server reply data |
63 | // 240 leaves about 4 bytes of server reply data |
64 | // every two request bytes less give room for one reply byte |
64 | // every two request bytes less give room for one reply byte |
65 | |
65 | |
66 | #define SEQNO_MASK 0xffff |
66 | #define SEQNO_MASK 0x3fff |
67 | #define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) ) |
67 | #define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) ) |
68 | |
68 | |
69 | #define MAX_LBL_SIZE 63 |
69 | #define MAX_LBL_SIZE 63 |
70 | #define MAX_PKT_SIZE 512 |
70 | #define MAX_PKT_SIZE 512 |
71 | |
71 | |
… | |
… | |
265 | |
265 | |
266 | ///////////////////////////////////////////////////////////////////////////// |
266 | ///////////////////////////////////////////////////////////////////////////// |
267 | |
267 | |
268 | #define HDRSIZE 6 |
268 | #define HDRSIZE 6 |
269 | |
269 | |
270 | inline void encode_header (char *data, int clientid, int seqno) |
270 | inline void encode_header (char *data, int clientid, int seqno, int retry = 0) |
271 | { |
271 | { |
272 | u8 hdr[3] = { clientid, seqno >> 8, seqno }; |
272 | seqno &= SEQNO_MASK; |
|
|
273 | |
|
|
274 | u8 hdr[3] = { |
|
|
275 | clientid, |
|
|
276 | (seqno >> 8) | (retry << 6), |
|
|
277 | seqno, |
|
|
278 | }; |
273 | |
279 | |
274 | assert (clientid < 256); |
280 | assert (clientid < 256); |
275 | |
281 | |
276 | cdc26.encode (data, hdr, 3); |
282 | cdc26.encode (data, hdr, 3); |
277 | } |
283 | } |
… | |
… | |
281 | u8 hdr[3]; |
287 | u8 hdr[3]; |
282 | |
288 | |
283 | cdc26.decode (hdr, data, HDRSIZE); |
289 | cdc26.decode (hdr, data, HDRSIZE); |
284 | |
290 | |
285 | clientid = hdr[0]; |
291 | clientid = hdr[0]; |
286 | seqno = (hdr[1] << 8) | hdr[2]; |
292 | seqno = ((hdr[1] << 8) | hdr[2]) & SEQNO_MASK; |
287 | } |
293 | } |
288 | |
294 | |
289 | ///////////////////////////////////////////////////////////////////////////// |
295 | ///////////////////////////////////////////////////////////////////////////// |
290 | |
296 | |
291 | struct byte_stream |
297 | struct byte_stream |
… | |
… | |
320 | } |
326 | } |
321 | |
327 | |
322 | void byte_stream::remove (int count) |
328 | void byte_stream::remove (int count) |
323 | { |
329 | { |
324 | if (count > fill) |
330 | if (count > fill) |
325 | abort (); |
331 | assert (count <= fill); |
326 | |
332 | |
327 | memmove (data, data + count, fill -= count); |
333 | memmove (data, data + count, fill -= count); |
328 | } |
334 | } |
329 | |
335 | |
330 | bool byte_stream::put (u8 *data, unsigned int datalen) |
336 | bool byte_stream::put (u8 *data, unsigned int datalen) |
… | |
… | |
353 | vpn_packet *byte_stream::get () |
359 | vpn_packet *byte_stream::get () |
354 | { |
360 | { |
355 | unsigned int len = (data [0] << 8) | data [1]; |
361 | unsigned int len = (data [0] << 8) | data [1]; |
356 | |
362 | |
357 | if (len > MAXSIZE && fill >= 2) |
363 | if (len > MAXSIZE && fill >= 2) |
358 | abort (); // TODO handle this gracefully, connection reset |
364 | assert (len <= MAXSIZE || fill < 2); // TODO handle this gracefully, connection reset |
359 | |
365 | |
360 | if (fill < len + 2) |
366 | if (fill < len + 2) |
361 | return 0; |
367 | return 0; |
362 | |
368 | |
363 | vpn_packet *pkt = new vpn_packet; |
369 | vpn_packet *pkt = new vpn_packet; |
… | |
… | |
422 | |
428 | |
423 | version = 1; |
429 | version = 1; |
424 | |
430 | |
425 | rrtype = RR_TYPE_TXT; |
431 | rrtype = RR_TYPE_TXT; |
426 | flags = 0; |
432 | flags = 0; |
427 | def_ttl = 0; |
433 | def_ttl = 1; |
428 | rcv_cdc = 0; |
434 | rcv_cdc = 0; |
429 | snd_cdc = 62; |
435 | snd_cdc = 62; |
430 | max_size = ntohs (MAX_PKT_SIZE); |
436 | max_size = ntohs (MAX_PKT_SIZE); |
431 | client = ntohs (clientid); |
437 | client = ntohs (clientid); |
432 | uid = next_uid++; |
438 | uid = next_uid++; |
… | |
… | |
499 | dns_packet *pkt; |
505 | dns_packet *pkt; |
500 | tstamp timeout, sent; |
506 | tstamp timeout, sent; |
501 | int retry; |
507 | int retry; |
502 | struct dns_connection *dns; |
508 | struct dns_connection *dns; |
503 | int seqno; |
509 | int seqno; |
|
|
510 | bool stdhdr; |
504 | |
511 | |
505 | void gen_stream_req (int seqno, byte_stream &stream); |
512 | void gen_stream_req (int seqno, byte_stream &stream); |
506 | void gen_syn_req (const dns_cfg &cfg); |
513 | void gen_syn_req (const dns_cfg &cfg); |
507 | |
514 | |
508 | dns_snd (dns_connection *dns); |
515 | dns_snd (dns_connection *dns); |
… | |
… | |
528 | { |
535 | { |
529 | timeout = 0; |
536 | timeout = 0; |
530 | retry = 0; |
537 | retry = 0; |
531 | seqno = 0; |
538 | seqno = 0; |
532 | sent = NOW; |
539 | sent = NOW; |
|
|
540 | stdhdr = false; |
533 | |
541 | |
534 | pkt = new dns_packet; |
542 | pkt = new dns_packet; |
535 | |
543 | |
536 | pkt->id = next_id (); |
544 | pkt->id = next_id (); |
537 | } |
545 | } |
… | |
… | |
564 | } |
572 | } |
565 | } |
573 | } |
566 | |
574 | |
567 | void dns_snd::gen_stream_req (int seqno, byte_stream &stream) |
575 | void dns_snd::gen_stream_req (int seqno, byte_stream &stream) |
568 | { |
576 | { |
|
|
577 | stdhdr = true; |
569 | this->seqno = seqno; |
578 | this->seqno = seqno; |
570 | |
579 | |
571 | timeout = NOW + INITIAL_TIMEOUT; |
580 | timeout = NOW + INITIAL_TIMEOUT; |
572 | |
581 | |
573 | pkt->flags = htons (DEFAULT_CLIENT_FLAGS); |
582 | pkt->flags = htons (DEFAULT_CLIENT_FLAGS); |
… | |
… | |
668 | |
677 | |
669 | bool established; |
678 | bool established; |
670 | |
679 | |
671 | tstamp last_received; |
680 | tstamp last_received; |
672 | tstamp last_sent; |
681 | tstamp last_sent; |
|
|
682 | double last_latency; |
673 | double poll_interval, send_interval; |
683 | double poll_interval, send_interval; |
674 | |
684 | |
675 | vector<dns_rcv *> rcvpq; |
685 | vector<dns_rcv *> rcvpq; |
676 | |
686 | |
677 | byte_stream rcvdq; int rcvseq; |
687 | byte_stream rcvdq; int rcvseq; |
… | |
… | |
696 | |
706 | |
697 | rcvseq = sndseq = 0; |
707 | rcvseq = sndseq = 0; |
698 | |
708 | |
699 | last_sent = last_received = 0; |
709 | last_sent = last_received = 0; |
700 | poll_interval = MIN_POLL_INTERVAL; |
710 | poll_interval = MIN_POLL_INTERVAL; |
701 | send_interval = 0.2; // starting rate |
711 | send_interval = 0.5; // starting rate |
|
|
712 | last_latency = INITIAL_TIMEOUT; |
702 | } |
713 | } |
703 | |
714 | |
704 | dns_connection::~dns_connection () |
715 | dns_connection::~dns_connection () |
705 | { |
716 | { |
706 | for (vector<dns_rcv *>::iterator i = rcvpq.begin (); |
717 | for (vector<dns_rcv *>::iterator i = rcvpq.begin (); |
… | |
… | |
718 | |
729 | |
719 | poll_interval = send_interval; |
730 | poll_interval = send_interval; |
720 | } |
731 | } |
721 | else |
732 | else |
722 | { |
733 | { |
723 | poll_interval *= 1.1; |
734 | poll_interval *= 1.5; |
724 | if (poll_interval > MAX_POLL_INTERVAL) |
735 | if (poll_interval > MAX_POLL_INTERVAL) |
725 | poll_interval = MAX_POLL_INTERVAL; |
736 | poll_interval = MAX_POLL_INTERVAL; |
726 | } |
737 | } |
727 | |
738 | |
728 | rcvpq.push_back (r); |
739 | rcvpq.push_back (r); |
… | |
… | |
746 | } |
757 | } |
747 | |
758 | |
748 | rcvseq = (rcvseq + 1) & SEQNO_MASK; |
759 | rcvseq = (rcvseq + 1) & SEQNO_MASK; |
749 | |
760 | |
750 | if (!rcvdq.put (r->data, r->datalen)) |
761 | if (!rcvdq.put (r->data, r->datalen)) |
|
|
762 | { |
|
|
763 | slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)"); |
751 | abort (); // MUST never overflow, can be caused by data corruption, TODO |
764 | abort (); // MUST never overflow, can be caused by data corruption, TODO |
|
|
765 | } |
752 | |
766 | |
753 | while (vpn_packet *pkt = rcvdq.get ()) |
767 | while (vpn_packet *pkt = rcvdq.get ()) |
754 | { |
768 | { |
755 | sockinfo si; |
769 | sockinfo si; |
756 | si.host = 0; si.port = 0; si.prot = PROT_DNSv4; |
770 | si.host = 0; si.port = 0; si.prot = PROT_DNSv4; |
… | |
… | |
815 | if (0 < client && client <= conns.size ()) |
829 | if (0 < client && client <= conns.size ()) |
816 | { |
830 | { |
817 | connection *c = conns [client - 1]; |
831 | connection *c = conns [client - 1]; |
818 | dns_connection *dns = c->dns; |
832 | dns_connection *dns = c->dns; |
819 | dns_rcv *rcv; |
833 | dns_rcv *rcv; |
|
|
834 | bool in_seq; |
820 | |
835 | |
821 | if (dns) |
836 | if (dns) |
822 | { |
837 | { |
823 | for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); ) |
838 | for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); ) |
824 | if (SEQNO_EQ ((*i)->seqno, seqno)) |
839 | if (SEQNO_EQ ((*i)->seqno, seqno)) |
825 | { |
840 | { |
826 | // already seen that request: simply reply with the cached reply |
841 | // already seen that request: simply reply with the cached reply |
827 | dns_rcv *r = *i; |
842 | dns_rcv *r = *i; |
828 | |
843 | |
829 | slog (L_DEBUG, "DUPLICATE %d\n", htons (r->pkt->id)); |
844 | slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno); |
|
|
845 | |
|
|
846 | // refresh header & id, as the retry count could have changed |
|
|
847 | memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE); |
|
|
848 | r->pkt->id = pkt.id; |
830 | |
849 | |
831 | memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len); |
850 | memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len); |
832 | pkt.id = r->pkt->id; |
851 | |
833 | goto duplicate_request; |
852 | goto duplicate_request; |
834 | } |
853 | } |
|
|
854 | |
|
|
855 | in_seq = dns->rcvseq == seqno; |
835 | |
856 | |
836 | // new packet, queue |
857 | // new packet, queue |
837 | rcv = new dns_rcv (seqno, data, datalen); |
858 | rcv = new dns_rcv (seqno, data, datalen); |
838 | dns->receive_rep (rcv); |
859 | dns->receive_rep (rcv); |
839 | } |
860 | } |
… | |
… | |
852 | // bind doesn't compress well, so reduce further by one label length |
873 | // bind doesn't compress well, so reduce further by one label length |
853 | dlen -= qlen; |
874 | dlen -= qlen; |
854 | |
875 | |
855 | if (dns) |
876 | if (dns) |
856 | { |
877 | { |
|
|
878 | // only put data into in-order sequence packets, if |
|
|
879 | // we receive out-of-order packets we generate empty |
|
|
880 | // replies |
857 | while (dlen > 1 && !dns->snddq.empty ()) |
881 | while (dlen > 1 && !dns->snddq.empty () && in_seq) |
858 | { |
882 | { |
859 | int txtlen = dlen <= 255 ? dlen - 1 : 255; |
883 | int txtlen = dlen <= 255 ? dlen - 1 : 255; |
860 | |
884 | |
861 | if (txtlen > dns->snddq.size ()) |
885 | if (txtlen > dns->snddq.size ()) |
862 | txtlen = dns->snddq.size (); |
886 | txtlen = dns->snddq.size (); |
… | |
… | |
871 | |
895 | |
872 | // avoid empty TXT rdata |
896 | // avoid empty TXT rdata |
873 | if (offs == rdlen_offs) |
897 | if (offs == rdlen_offs) |
874 | pkt[offs++] = 0; |
898 | pkt[offs++] = 0; |
875 | |
899 | |
876 | slog (L_NOISE, "snddq %d", dns->snddq.size ()); |
900 | slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ()); |
877 | } |
901 | } |
878 | else |
902 | else |
879 | { |
903 | { |
880 | // send RST |
904 | // send RST |
881 | pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; |
905 | pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; |
… | |
… | |
912 | pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class |
936 | pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class |
913 | pkt [offs++] = 0; pkt [offs++] = 0; |
937 | pkt [offs++] = 0; pkt [offs++] = 0; |
914 | pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL |
938 | pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL |
915 | pkt [offs++] = 0; pkt [offs++] = 4; // rdlength |
939 | pkt [offs++] = 0; pkt [offs++] = 4; // rdlength |
916 | |
940 | |
917 | slog (L_INFO, _("DNS tunnel: client %d tries to connect"), client); |
941 | slog (L_INFO, _("DNS: client %d tries to connect"), client); |
918 | |
942 | |
919 | pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; |
943 | pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; |
920 | pkt [offs++] = CMD_IP_REJ; |
944 | pkt [offs++] = CMD_IP_REJ; |
921 | |
945 | |
922 | if (0 < client && client <= conns.size ()) |
946 | if (0 < client && client <= conns.size ()) |
… | |
… | |
959 | int seqno = (*i)->seqno; |
983 | int seqno = (*i)->seqno; |
960 | u8 data[MAXSIZE], *datap = data; |
984 | u8 data[MAXSIZE], *datap = data; |
961 | |
985 | |
962 | if ((*i)->retry) |
986 | if ((*i)->retry) |
963 | { |
987 | { |
964 | dns->send_interval *= 1.001; |
988 | dns->send_interval *= 1.01; |
965 | if (dns->send_interval > MAX_SEND_INTERVAL) |
989 | if (dns->send_interval > MAX_SEND_INTERVAL) |
966 | dns->send_interval = MAX_SEND_INTERVAL; |
990 | dns->send_interval = MAX_SEND_INTERVAL; |
967 | } |
991 | } |
968 | else |
992 | else |
969 | { |
993 | { |
970 | #if 1 |
994 | #if 1 |
971 | dns->send_interval *= 0.9999; |
995 | dns->send_interval *= 0.999; |
972 | #endif |
996 | #endif |
973 | if (dns->send_interval < MIN_SEND_INTERVAL) |
997 | if (dns->send_interval < MIN_SEND_INTERVAL) |
974 | dns->send_interval = MIN_SEND_INTERVAL; |
998 | dns->send_interval = MIN_SEND_INTERVAL; |
975 | |
999 | |
976 | // the latency surely puts an upper bound on |
1000 | // the latency surely puts an upper bound on |
977 | // the minimum send interval |
1001 | // the minimum send interval |
978 | double latency = NOW - (*i)->sent; |
1002 | double latency = NOW - (*i)->sent; |
|
|
1003 | dns->last_latency = latency; |
979 | |
1004 | |
980 | if (dns->send_interval > latency) |
1005 | if (dns->send_interval > latency) |
981 | dns->send_interval = latency; |
1006 | dns->send_interval = latency; |
982 | } |
1007 | } |
983 | |
1008 | |
… | |
… | |
1036 | |
1061 | |
1037 | if (ip [0] == CMD_IP_1 |
1062 | if (ip [0] == CMD_IP_1 |
1038 | && ip [1] == CMD_IP_2 |
1063 | && ip [1] == CMD_IP_2 |
1039 | && ip [2] == CMD_IP_3) |
1064 | && ip [2] == CMD_IP_3) |
1040 | { |
1065 | { |
1041 | slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]); |
1066 | slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]); |
1042 | |
1067 | |
1043 | if (ip [3] == CMD_IP_RST) |
1068 | if (ip [3] == CMD_IP_RST) |
1044 | { |
1069 | { |
1045 | slog (L_DEBUG, _("got tunnel RST request")); |
1070 | slog (L_DEBUG, _("DNS: got tunnel RST request")); |
1046 | |
1071 | |
1047 | delete dns; c->dns = 0; |
1072 | delete dns; c->dns = 0; |
1048 | |
1073 | |
1049 | return; |
1074 | return; |
1050 | } |
1075 | } |
1051 | else if (ip [3] == CMD_IP_SYN) |
1076 | else if (ip [3] == CMD_IP_SYN) |
1052 | { |
1077 | { |
1053 | slog (L_DEBUG, _("got tunnel SYN reply, server likes us.")); |
1078 | slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us.")); |
1054 | dns->established = true; |
1079 | dns->established = true; |
1055 | } |
1080 | } |
1056 | else if (ip [3] == CMD_IP_REJ) |
1081 | else if (ip [3] == CMD_IP_REJ) |
1057 | { |
1082 | { |
1058 | slog (L_DEBUG, _("got tunnel REJ reply, server does not like us, aborting.")); |
1083 | slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting.")); |
1059 | abort (); |
1084 | abort (); |
1060 | } |
1085 | } |
1061 | else |
1086 | else |
1062 | slog (L_INFO, _("got unknown meta command %02x"), ip [3]); |
1087 | slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]); |
1063 | } |
1088 | } |
1064 | else |
1089 | else |
1065 | slog (L_INFO, _("got spurious a record %d.%d.%d.%d"), |
1090 | slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"), |
1066 | ip [0], ip [1], ip [2], ip [3]); |
1091 | ip [0], ip [1], ip [2], ip [3]); |
1067 | |
1092 | |
1068 | return; |
1093 | return; |
1069 | } |
1094 | } |
1070 | |
1095 | |
1071 | int client, rseqno; |
1096 | int client, rseqno; |
1072 | decode_header (qname, client, rseqno); |
1097 | decode_header (qname, client, rseqno); |
1073 | |
1098 | |
1074 | if (client != THISNODE->id) |
1099 | if (client != THISNODE->id) |
1075 | { |
1100 | { |
1076 | slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring")); |
1101 | slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring")); |
1077 | datap = 0; |
1102 | datap = 0; |
1078 | } |
1103 | } |
1079 | else if (rseqno != seqno) |
1104 | else if (rseqno != seqno) |
1080 | { |
1105 | { |
1081 | slog (L_DEBUG, _("got dns tunnel response with wrong seqno, badly caching nameserver?")); |
1106 | slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?")); |
1082 | datap = 0; |
1107 | datap = 0; |
1083 | } |
1108 | } |
1084 | } |
1109 | } |
1085 | } |
1110 | } |
1086 | |
1111 | |
… | |
… | |
1162 | if (!send) |
1187 | if (!send) |
1163 | { |
1188 | { |
1164 | send = r; |
1189 | send = r; |
1165 | |
1190 | |
1166 | r->retry++; |
1191 | r->retry++; |
1167 | r->timeout = NOW + r->retry; |
1192 | r->timeout = NOW + (r->retry * last_latency * 8.); |
|
|
1193 | |
|
|
1194 | // the following code changes the query section a bit, forcing |
|
|
1195 | // the forwarder to generate a new request |
|
|
1196 | if (r->stdhdr) |
|
|
1197 | { |
|
|
1198 | //printf ("reencoded header for ID %d retry %d:%d:%d\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);printf ("reencoded header for ID %d retry %d:%d:%d\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry); |
|
|
1199 | //encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry); |
|
|
1200 | } |
1168 | } |
1201 | } |
1169 | } |
1202 | } |
1170 | else |
1203 | else |
1171 | NEXT (r->timeout); |
1204 | NEXT (r->timeout); |
1172 | } |
1205 | } |
… | |
… | |
1185 | |
1218 | |
1186 | cfg.reset (THISNODE->id); |
1219 | cfg.reset (THISNODE->id); |
1187 | send->gen_syn_req (cfg); |
1220 | send->gen_syn_req (cfg); |
1188 | } |
1221 | } |
1189 | } |
1222 | } |
1190 | else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING) |
1223 | else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING |
|
|
1224 | && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1))) |
1191 | { |
1225 | { |
|
|
1226 | if (!snddq.empty ()) |
|
|
1227 | { |
|
|
1228 | poll_interval = send_interval; |
|
|
1229 | NEXT (NOW + send_interval); |
|
|
1230 | } |
|
|
1231 | |
1192 | send = new dns_snd (this); |
1232 | send = new dns_snd (this); |
1193 | send->gen_stream_req (sndseq, snddq); |
1233 | send->gen_stream_req (sndseq, snddq); |
|
|
1234 | send->timeout = NOW + last_latency * 8.; |
1194 | |
1235 | |
1195 | sndseq = (sndseq + 1) & SEQNO_MASK; |
1236 | sndseq = (sndseq + 1) & SEQNO_MASK; |
1196 | } |
1237 | } |
1197 | |
1238 | |
1198 | if (send) |
1239 | if (send) |
… | |
… | |
1208 | } |
1249 | } |
1209 | } |
1250 | } |
1210 | else |
1251 | else |
1211 | NEXT (last_sent + send_interval); |
1252 | NEXT (last_sent + send_interval); |
1212 | |
1253 | |
1213 | slog (L_NOISE, "pi %f si %f N %f (%d:%d)", |
1254 | slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d)", |
1214 | poll_interval, send_interval, next - NOW, |
1255 | poll_interval, send_interval, next - NOW, |
1215 | vpn->dns_sndpq.size (), snddq.size ()); |
1256 | vpn->dns_sndpq.size (), snddq.size ()); |
1216 | |
1257 | |
1217 | // TODO: no idea when this happens, but when next < NOW, we have a problem |
1258 | // TODO: no idea when this happens, but when next < NOW, we have a problem |
1218 | if (next < NOW + 0.0001) |
1259 | if (next < NOW + 0.0001) |