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.10 by pcg, Fri Mar 4 08:15:04 2005 UTC vs.
Revision 1.15 by pcg, Fri Mar 4 10:15:45 2005 UTC

… …
43 43
44#include "netcompat.h" 44#include "netcompat.h"
45 45
46#include "vpn.h" 46#include "vpn.h"
47 47
48#define MIN_POLL_INTERVAL .2 // how often to poll minimally when the server is having 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. 52#define INITIAL_TIMEOUT 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 (1./1000.) 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 400 // max. outstanding requests 58#define MAX_OUTSTANDING 40 // max. outstanding requests
59#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING 59#define MAX_WINDOW 100 // max. for MAX_OUTSTANDING
60#define MAX_RATE 100 // requests/s
61#define MAX_BACKLOG (100*1024) // size of protocol backlog, must be > MAXSIZE 60#define MAX_BACKLOG (100*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
62 61
63#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
64// 240 leaves about 4 bytes of server reply data 63// 240 leaves about 4 bytes of server reply data
65// every two request byte sless give room for one reply byte 64// every two request bytes less give room for one reply byte
66 65
67#define SEQNO_MASK 0xffff 66#define SEQNO_MASK 0xffff
68#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) ) 67#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
69 68
70#define MAX_LBL_SIZE 63 69#define MAX_LBL_SIZE 63
… …
351 return true; 350 return true;
352} 351}
353 352
354vpn_packet *byte_stream::get () 353vpn_packet *byte_stream::get ()
355{ 354{
356 int len = (data [0] << 8) | data [1]; 355 unsigned int len = (data [0] << 8) | data [1];
357 356
358 if (len > MAXSIZE && fill >= 2) 357 if (len > MAXSIZE && fill >= 2)
359 abort (); // TODO handle this gracefully, connection reset 358 abort (); // TODO handle this gracefully, connection reset
360 359
361 if (fill < len + 2) 360 if (fill < len + 2)
… …
501 tstamp timeout, sent; 500 tstamp timeout, sent;
502 int retry; 501 int retry;
503 struct dns_connection *dns; 502 struct dns_connection *dns;
504 int seqno; 503 int seqno;
505 504
506 dns_snd (dns_connection *dns);
507 void gen_stream_req (int seqno, byte_stream &stream); 505 void gen_stream_req (int seqno, byte_stream &stream);
508 void gen_syn_req (const dns_cfg &cfg); 506 void gen_syn_req (const dns_cfg &cfg);
507
508 dns_snd (dns_connection *dns);
509 ~dns_snd ();
509}; 510};
510 511
511static u16 dns_id = 12098; // TODO: should be per-vpn 512static u16 dns_id = 12098; // TODO: should be per-vpn
512 513
513static u16 next_id () 514static u16 next_id ()
… …
526: dns (dns) 527: dns (dns)
527{ 528{
528 timeout = 0; 529 timeout = 0;
529 retry = 0; 530 retry = 0;
530 seqno = 0; 531 seqno = 0;
532 sent = NOW;
531 533
532 pkt = new dns_packet; 534 pkt = new dns_packet;
533 535
534 pkt->id = next_id (); 536 pkt->id = next_id ();
537}
538
539dns_snd::~dns_snd ()
540{
541 delete pkt;
535} 542}
536 543
537static void append_domain (dns_packet &pkt, int &offs, const char *domain) 544static void append_domain (dns_packet &pkt, int &offs, const char *domain)
538{ 545{
539 // add tunnel domain 546 // add tunnel domain
… …
707 if (r->datalen) 714 if (r->datalen)
708 { 715 {
709 last_received = NOW; 716 last_received = NOW;
710 tw.trigger (); 717 tw.trigger ();
711 718
712 poll_interval *= 0.99; 719 poll_interval = send_interval;
713 if (poll_interval > MIN_POLL_INTERVAL)
714 poll_interval = MIN_POLL_INTERVAL;
715 } 720 }
716 else 721 else
717 { 722 {
718 poll_interval *= 1.1; 723 poll_interval *= 1.1;
719 if (poll_interval > MAX_POLL_INTERVAL) 724 if (poll_interval > MAX_POLL_INTERVAL)
… …
749 { 754 {
750 sockinfo si; 755 sockinfo si;
751 si.host = 0; si.port = 0; si.prot = PROT_DNSv4; 756 si.host = 0; si.port = 0; si.prot = PROT_DNSv4;
752 757
753 vpn->recv_vpn_packet (pkt, si); 758 vpn->recv_vpn_packet (pkt, si);
759
760 delete pkt;
754 } 761 }
755 762
756 // check for further packets 763 // check for further packets
757 goto redo; 764 goto redo;
758 } 765 }
… …
817 if (SEQNO_EQ ((*i)->seqno, seqno)) 824 if (SEQNO_EQ ((*i)->seqno, seqno))
818 { 825 {
819 // already seen that request: simply reply with the cached reply 826 // already seen that request: simply reply with the cached reply
820 dns_rcv *r = *i; 827 dns_rcv *r = *i;
821 828
822 printf ("DUPLICATE %d\n", htons (r->pkt->id));//D 829 slog (L_DEBUG, "DUPLICATE %d\n", htons (r->pkt->id));
823 830
824 memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len); 831 memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
825 pkt.id = r->pkt->id; 832 pkt.id = r->pkt->id;
826 goto duplicate_request; 833 goto duplicate_request;
827 } 834 }
… …
831 dns->receive_rep (rcv); 838 dns->receive_rep (rcv);
832 } 839 }
833 840
834 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section 841 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
835 842
836 // type
837 int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A; 843 int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
838 pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; 844 pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
839
840 // class
841 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; 845 pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
842
843 // TTL
844 pkt [offs++] = 0; pkt [offs++] = 0; 846 pkt [offs++] = 0; pkt [offs++] = 0;
845 pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; 847 pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
846 848
847 int rdlen_offs = offs += 2; 849 int rdlen_offs = offs += 2;
848 850
849 int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs; 851 int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;
850 // bind doesn't compress well, so reduce further by one label length 852 // bind doesn't compress well, so reduce further by one label length
… …
868 } 870 }
869 871
870 // avoid empty TXT rdata 872 // avoid empty TXT rdata
871 if (offs == rdlen_offs) 873 if (offs == rdlen_offs)
872 pkt[offs++] = 0; 874 pkt[offs++] = 0;
875
876 slog (L_NOISE, "snddq %d", dns->snddq.size ());
873 } 877 }
874 else 878 else
875 { 879 {
876 // send RST 880 // send RST
877 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3; 881 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
… …
949 i != dns_sndpq.end (); 953 i != dns_sndpq.end ();
950 ++i) 954 ++i)
951 if ((*i)->pkt->id == pkt.id) 955 if ((*i)->pkt->id == pkt.id)
952 { 956 {
953 dns_connection *dns = (*i)->dns; 957 dns_connection *dns = (*i)->dns;
958 connection *c = dns->c;
954 int seqno = (*i)->seqno; 959 int seqno = (*i)->seqno;
955 u8 data[MAXSIZE], *datap = data; 960 u8 data[MAXSIZE], *datap = data;
956 961
957 if ((*i)->retry) 962 if ((*i)->retry)
958 { 963 {
959 dns->send_interval *= 1.01; 964 dns->send_interval *= 1.001;
960 if (dns->send_interval < MAX_SEND_INTERVAL) 965 if (dns->send_interval > MAX_SEND_INTERVAL)
961 dns->send_interval = MAX_SEND_INTERVAL; 966 dns->send_interval = MAX_SEND_INTERVAL;
962 } 967 }
963 else 968 else
964 { 969 {
970#if 1
965 dns->send_interval *= 0.99; 971 dns->send_interval *= 0.9999;
972#endif
966 if (dns->send_interval < MIN_SEND_INTERVAL) 973 if (dns->send_interval < MIN_SEND_INTERVAL)
967 dns->send_interval = MIN_SEND_INTERVAL; 974 dns->send_interval = MIN_SEND_INTERVAL;
968 975
969 // the latency surely puts an upper bound on 976 // the latency surely puts an upper bound on
970 // the minimum send interval 977 // the minimum send interval
978 double latency = NOW - (*i)->sent;
979
971 if (dns->send_interval > NOW - (*i)->sent) 980 if (dns->send_interval > latency)
972 dns->send_interval = NOW - (*i)->sent; 981 dns->send_interval = latency;
973 } 982 }
974 983
975 delete *i; 984 delete *i;
976 dns_sndpq.erase (i); 985 dns_sndpq.erase (i);
977 986
… …
1033 1042
1034 if (ip [3] == CMD_IP_RST) 1043 if (ip [3] == CMD_IP_RST)
1035 { 1044 {
1036 slog (L_DEBUG, _("got tunnel RST request")); 1045 slog (L_DEBUG, _("got tunnel RST request"));
1037 1046
1038 connection *c = dns->c;
1039 delete c->dns; c->dns = 0; 1047 delete dns; c->dns = 0;
1040 1048
1041 return; 1049 return;
1042 } 1050 }
1043 else if (ip [3] == CMD_IP_SYN) 1051 else if (ip [3] == CMD_IP_SYN)
1052 {
1053 slog (L_DEBUG, _("got tunnel SYN reply, server likes us."));
1044 dns->established = true; 1054 dns->established = true;
1055 }
1056 else if (ip [3] == CMD_IP_REJ)
1057 {
1058 slog (L_DEBUG, _("got tunnel REJ reply, server does not like us, aborting."));
1059 abort ();
1060 }
1045 else 1061 else
1046 slog (L_INFO, _("got unknown meta command %02x"), ip [3]); 1062 slog (L_INFO, _("got unknown meta command %02x"), ip [3]);
1047 } 1063 }
1048 else 1064 else
1049 slog (L_INFO, _("got spurious a record %d.%d.%d.%d"), 1065 slog (L_INFO, _("got spurious a record %d.%d.%d.%d"),
… …
1114 dns->tw.trigger (); 1130 dns->tw.trigger ();
1115 1131
1116 return true; 1132 return true;
1117} 1133}
1118 1134
1135void
1136connection::dnsv4_reset_connection ()
1137{
1138 //delete dns; dns = 0; //TODO
1139}
1140
1119#define NEXT(w) do { if (next > (w)) next = w; } while (0) 1141#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1120 1142
1121void 1143void
1122dns_connection::time_cb (time_watcher &w) 1144dns_connection::time_cb (time_watcher &w)
1123{ 1145{
… …
1143 1165
1144 r->retry++; 1166 r->retry++;
1145 r->timeout = NOW + r->retry; 1167 r->timeout = NOW + r->retry;
1146 } 1168 }
1147 } 1169 }
1148 else if (r->timeout < next) 1170 else
1149 NEXT (r->timeout); 1171 NEXT (r->timeout);
1150 } 1172 }
1151 1173
1152 if (last_sent + send_interval <= NOW) 1174 if (last_sent + send_interval <= NOW)
1153 { 1175 {
… …
1177 vpn->dns_sndpq.push_back (send); 1199 vpn->dns_sndpq.push_back (send);
1178 } 1200 }
1179 1201
1180 if (send) 1202 if (send)
1181 { 1203 {
1182 printf ("send pkt\n");
1183 last_sent = NOW; 1204 last_sent = NOW;
1184
1185 if (!send->retry)
1186 send->sent = NOW;
1187
1188 sendto (vpn->dnsv4_fd, 1205 sendto (vpn->dnsv4_fd,
1189 send->pkt->at (0), send->pkt->len, 0, 1206 send->pkt->at (0), send->pkt->len, 0,
1190 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ()); 1207 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1191 } 1208 }
1192 } 1209 }
1193 else 1210 else
1194 NEXT (last_sent + send_interval); 1211 NEXT (last_sent + send_interval);
1195 1212
1196 printf ("pi %f si %f N %f (%d:%d)\n", poll_interval, send_interval, next - NOW, vpn->dns_sndpq.size (), snddq.size ()); 1213 slog (L_NOISE, "pi %f si %f N %f (%d:%d)",
1214 poll_interval, send_interval, next - NOW,
1215 vpn->dns_sndpq.size (), snddq.size ());
1216
1217 // TODO: no idea when this happens, but when next < NOW, we have a problem
1218 if (next < NOW + 0.0001)
1219 next = NOW + 0.1;
1197 1220
1198 w.start (next); 1221 w.start (next);
1199} 1222}
1200 1223
1201#endif 1224#endif

Diff Legend

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