… | |
… | |
59 | |
59 | |
60 | #include "netcompat.h" |
60 | #include "netcompat.h" |
61 | |
61 | |
62 | #include "vpn.h" |
62 | #include "vpn.h" |
63 | |
63 | |
64 | #define MIN_POLL_INTERVAL 0.1 // poll at most this often when no data received |
64 | #define MIN_POLL_INTERVAL 0.025 // poll at most this often when no data received |
65 | #define MAX_POLL_INTERVAL 1. // how often to poll minimally when the server has no data |
65 | #define MAX_POLL_INTERVAL 1. // how often to poll minimally when the server has no data |
66 | |
66 | |
67 | #define INITIAL_TIMEOUT 0.1 // retry timeouts |
67 | #define INITIAL_TIMEOUT 0.1 // retry timeouts |
68 | #define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn |
68 | #define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn |
69 | |
69 | |
70 | #define MAX_SEND_INTERVAL 2. // optimistic? |
70 | #define MAX_SEND_INTERVAL 5. // optimistic? |
71 | |
71 | |
72 | #define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog |
72 | #define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog |
73 | #define MAX_BACKLOG (64*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 |
74 | |
74 | |
75 | #define MAX_DOMAIN_SIZE 240 // 255 is legal limit, but bind doesn't compress well |
75 | #define MAX_DOMAIN_SIZE 235 // 255 is legal limit, but bind doesn't compress well |
76 | // 240 leaves about 4 bytes of server reply data |
76 | // 240 leaves about 4 bytes of server reply data |
77 | // every request byte less give room for two reply bytes |
77 | // every request byte less give room for two reply bytes |
78 | |
78 | |
79 | #define SEQNO_MASK 0x3fff |
79 | #define SEQNO_MASK 0x3fff |
80 | #define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) ) |
80 | #define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) ) |
… | |
… | |
590 | static |
590 | static |
591 | u16 next_id () |
591 | u16 next_id () |
592 | { |
592 | { |
593 | static u16 dns_id = 0; // TODO: should be per-vpn |
593 | static u16 dns_id = 0; // TODO: should be per-vpn |
594 | |
594 | |
|
|
595 | #if 1 |
595 | if (!dns_id) |
596 | if (!dns_id) |
596 | dns_id = time (0); |
597 | dns_id = time (0); |
597 | |
598 | |
598 | // the simplest lsfr with periodicity 65535 i could find |
599 | // the simplest lsfr with periodicity 65535 i could find |
599 | dns_id = (dns_id << 1) |
600 | dns_id = (dns_id << 1) |
… | |
… | |
601 | ^ (dns_id >> 2) |
602 | ^ (dns_id >> 2) |
602 | ^ (dns_id >> 4) |
603 | ^ (dns_id >> 4) |
603 | ^ (dns_id >> 15)) & 1); |
604 | ^ (dns_id >> 15)) & 1); |
604 | |
605 | |
605 | return dns_id; |
606 | return dns_id; |
|
|
607 | #else |
|
|
608 | dns_id++;//D |
|
|
609 | |
|
|
610 | return htons (dns_id); |
|
|
611 | #endif |
606 | } |
612 | } |
607 | |
613 | |
608 | struct dns_rcv; |
614 | struct dns_rcv; |
609 | struct dns_snd; |
615 | struct dns_snd; |
610 | |
616 | |
… | |
… | |
830 | |
836 | |
831 | established = false; |
837 | established = false; |
832 | |
838 | |
833 | rcvseq = repseq = sndseq = 0; |
839 | rcvseq = repseq = sndseq = 0; |
834 | |
840 | |
835 | last_sent = last_received = 0; |
841 | last_sent = 0; |
836 | poll_interval = 0.5; // starting here |
842 | poll_interval = 0.5; // starting here |
837 | send_interval = 0.5; // starting rate |
843 | send_interval = 0.5; // starting rate |
838 | min_latency = INITIAL_TIMEOUT; |
844 | min_latency = INITIAL_TIMEOUT; |
839 | } |
845 | } |
840 | |
846 | |
… | |
… | |
846 | |
852 | |
847 | void |
853 | void |
848 | dns_connection::receive_rep (dns_rcv *r) |
854 | dns_connection::receive_rep (dns_rcv *r) |
849 | { |
855 | { |
850 | if (r->datalen) |
856 | if (r->datalen) |
851 | { |
857 | poll_interval = max (poll_interval * (1. / 1.2), MIN_POLL_INTERVAL); |
852 | last_received = ev_now (); |
|
|
853 | tw (); |
|
|
854 | |
|
|
855 | poll_interval = send_interval; |
|
|
856 | } |
|
|
857 | else |
858 | else |
858 | { |
859 | poll_interval = min (poll_interval * 1.1, MAX_POLL_INTERVAL); |
859 | poll_interval *= 1.5; |
|
|
860 | |
|
|
861 | if (poll_interval > MAX_POLL_INTERVAL) |
|
|
862 | poll_interval = MAX_POLL_INTERVAL; |
|
|
863 | } |
|
|
864 | |
860 | |
865 | rcvpq.push_back (r); |
861 | rcvpq.push_back (r); |
866 | |
862 | |
867 | redo: |
863 | redo: |
868 | |
864 | |
… | |
… | |
1123 | dns_connection *dns = (*i)->dns; |
1119 | dns_connection *dns = (*i)->dns; |
1124 | connection *c = dns->c; |
1120 | connection *c = dns->c; |
1125 | int seqno = (*i)->seqno; |
1121 | int seqno = (*i)->seqno; |
1126 | u8 data[MAXSIZE], *datap = data; |
1122 | u8 data[MAXSIZE], *datap = data; |
1127 | //printf ("rcv pkt %x\n", seqno);//D |
1123 | //printf ("rcv pkt %x\n", seqno);//D |
1128 | bool back_off = (*i)->retry; |
|
|
1129 | |
1124 | |
1130 | if (back_off) |
1125 | if ((*i)->retry) |
1131 | { |
1126 | { |
1132 | dns->send_interval *= 1.01; |
1127 | dns->send_interval *= 1.01; |
1133 | if (dns->send_interval > MAX_SEND_INTERVAL) |
1128 | if (dns->send_interval > MAX_SEND_INTERVAL) |
1134 | dns->send_interval = MAX_SEND_INTERVAL; |
1129 | dns->send_interval = MAX_SEND_INTERVAL; |
1135 | } |
1130 | } |
… | |
… | |
1273 | } |
1268 | } |
1274 | |
1269 | |
1275 | // todo: pkt now used |
1270 | // todo: pkt now used |
1276 | if (datap) |
1271 | if (datap) |
1277 | dns->receive_rep (new dns_rcv (seqno, data, datap - data)); |
1272 | dns->receive_rep (new dns_rcv (seqno, data, datap - data)); |
1278 | else if (dns_sndpq.empty ()) // no data received, and nothing to send - idle |
|
|
1279 | { |
|
|
1280 | dns->send_interval *= 1.1; |
|
|
1281 | |
|
|
1282 | if (dns->send_interval < MIN_POLL_INTERVAL) |
|
|
1283 | dns->send_interval = MIN_POLL_INTERVAL; |
|
|
1284 | |
|
|
1285 | if (dns->send_interval > MAX_POLL_INTERVAL && !back_off) |
|
|
1286 | dns->send_interval = MAX_POLL_INTERVAL; |
|
|
1287 | } |
|
|
1288 | |
1273 | |
1289 | break; |
1274 | break; |
1290 | } |
1275 | } |
1291 | } |
1276 | } |
1292 | |
1277 | |
… | |
… | |
1327 | |
1312 | |
1328 | if (!c->dns) |
1313 | if (!c->dns) |
1329 | c->dns = new dns_connection (c); |
1314 | c->dns = new dns_connection (c); |
1330 | |
1315 | |
1331 | if (c->dns->snddq.put (pkt)) |
1316 | if (c->dns->snddq.put (pkt)) |
|
|
1317 | { |
|
|
1318 | min_it (c->dns->poll_interval, 0.25); |
1332 | c->dns->tw (); |
1319 | c->dns->tw (); |
|
|
1320 | } |
1333 | |
1321 | |
1334 | // always return true even if the buffer overflows |
1322 | // always return true even if the buffer overflows |
1335 | return true; |
1323 | return true; |
1336 | } |
1324 | } |
1337 | |
|
|
1338 | #define NEXT(w) do { if (next > (w)) next = w; } while (0) |
|
|
1339 | |
1325 | |
1340 | void |
1326 | void |
1341 | dns_connection::time_cb (ev::timer &w, int revents) |
1327 | dns_connection::time_cb (ev::timer &w, int revents) |
1342 | { |
1328 | { |
1343 | // servers have to be polled |
1329 | // servers have to be polled |
1344 | if (THISNODE->dns_port) |
1330 | if (THISNODE->dns_port) |
1345 | return; |
1331 | return; |
1346 | |
1332 | |
1347 | // check for timeouts and (re)transmit |
1333 | // check for timeouts and (re)transmit |
1348 | tstamp next = ev::now () + poll_interval; |
1334 | tstamp next = 86400 * 365; |
1349 | dns_snd *send = 0; |
1335 | dns_snd *send = 0; |
1350 | |
1336 | |
1351 | for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin (); |
1337 | for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin (); |
1352 | i != vpn->dns_sndpq.end (); |
1338 | i != vpn->dns_sndpq.end (); |
1353 | ++i) |
1339 | ++i) |
… | |
… | |
1359 | if (!send) |
1345 | if (!send) |
1360 | { |
1346 | { |
1361 | send = r; |
1347 | send = r; |
1362 | |
1348 | |
1363 | r->retry++; |
1349 | r->retry++; |
1364 | r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor); |
1350 | r->timeout = ev_now () + r->retry * min_latency * conf.dns_timeout_factor; |
1365 | //printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D |
1351 | //printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D |
1366 | |
1352 | |
1367 | // the following code changes the query section a bit, forcing |
1353 | // the following code changes the query section a bit, forcing |
1368 | // the forwarder to generate a new request |
1354 | // the forwarder to generate a new request |
1369 | if (r->stdhdr) |
1355 | if (r->stdhdr) |
1370 | encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry); |
1356 | encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry); |
1371 | } |
1357 | } |
1372 | } |
1358 | } |
1373 | else |
1359 | else |
1374 | NEXT (r->timeout); |
1360 | min_it (next, r->timeout - ev_now ()); |
1375 | } |
1361 | } |
1376 | |
1362 | |
1377 | if (!send) |
1363 | if (!send) |
1378 | { |
1364 | { |
1379 | // generate a new packet, if wise |
1365 | // generate a new packet, if wise |
… | |
… | |
1393 | && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1))) |
1379 | && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1))) |
1394 | { |
1380 | { |
1395 | if (last_sent + send_interval <= ev_now ()) |
1381 | if (last_sent + send_interval <= ev_now ()) |
1396 | { |
1382 | { |
1397 | //printf ("sending data request etc.\n"); //D |
1383 | //printf ("sending data request etc.\n"); //D |
1398 | if (!snddq.empty () || last_received + 1. > ev_now ()) |
1384 | if (!snddq.empty ()) |
1399 | { |
|
|
1400 | poll_interval = send_interval; |
1385 | min_it (next, send_interval); |
1401 | NEXT (ev_now () + send_interval); |
|
|
1402 | } |
|
|
1403 | |
1386 | |
1404 | send = new dns_snd (this); |
1387 | send = new dns_snd (this); |
1405 | send->gen_stream_req (sndseq, snddq); |
1388 | send->gen_stream_req (sndseq, snddq); |
1406 | send->timeout = ev_now () + min_latency * conf.dns_timeout_factor; |
1389 | send->timeout = ev_now () + min_latency * conf.dns_timeout_factor; |
1407 | //printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D |
1390 | //printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D |
1408 | |
1391 | |
1409 | sndseq = (sndseq + 1) & SEQNO_MASK; |
1392 | sndseq = (sndseq + 1) & SEQNO_MASK; |
1410 | } |
1393 | } |
1411 | else |
1394 | else |
1412 | NEXT (last_sent + send_interval); |
1395 | min_it (next, last_sent + send_interval - ev_now ()); |
1413 | } |
1396 | } |
1414 | |
1397 | |
1415 | if (send) |
1398 | if (send) |
1416 | vpn->dns_sndpq.push_back (send); |
1399 | vpn->dns_sndpq.push_back (send); |
1417 | } |
1400 | } |
… | |
… | |
1422 | sendto (vpn->dnsv4_fd, |
1405 | sendto (vpn->dnsv4_fd, |
1423 | send->pkt->at (0), send->pkt->len, 0, |
1406 | send->pkt->at (0), send->pkt->len, 0, |
1424 | vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ()); |
1407 | vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ()); |
1425 | } |
1408 | } |
1426 | |
1409 | |
|
|
1410 | min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ()); |
|
|
1411 | |
1427 | slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)", |
1412 | slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)", |
1428 | poll_interval, send_interval, next - ev_now (), |
1413 | poll_interval, send_interval, next - ev_now (), |
1429 | vpn->dns_sndpq.size (), snddq.size (), |
1414 | vpn->dns_sndpq.size (), snddq.size (), |
1430 | rcvpq.size ()); |
1415 | rcvpq.size ()); |
1431 | |
1416 | |
1432 | // TODO: no idea when this happens, but when next < ev_now (), we have a problem |
1417 | w.start (next); |
1433 | // doesn't seem to happen anymore |
|
|
1434 | if (next < ev_now () + 0.001) |
|
|
1435 | next = ev_now () + 0.1; |
|
|
1436 | |
|
|
1437 | w.start (next - ev_now ()); |
|
|
1438 | } |
1418 | } |
1439 | |
1419 | |
1440 | #endif |
1420 | #endif |
1441 | |
1421 | |