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.51 by root, Sun Mar 6 19:40:28 2011 UTC vs.
Revision 1.52 by root, Sun Mar 6 21:01:37 2011 UTC

… …
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 240 // 255 is legal limit, but bind doesn't compress well
… …
830 830
831 established = false; 831 established = false;
832 832
833 rcvseq = repseq = sndseq = 0; 833 rcvseq = repseq = sndseq = 0;
834 834
835 last_sent = last_received = 0; 835 last_sent = 0;
836 poll_interval = 0.5; // starting here 836 poll_interval = 0.5; // starting here
837 send_interval = 0.5; // starting rate 837 send_interval = 0.5; // starting rate
838 min_latency = INITIAL_TIMEOUT; 838 min_latency = INITIAL_TIMEOUT;
839} 839}
840 840
… …
846 846
847void 847void
848dns_connection::receive_rep (dns_rcv *r) 848dns_connection::receive_rep (dns_rcv *r)
849{ 849{
850 if (r->datalen) 850 if (r->datalen)
851 { 851 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 852 else
858 { 853 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 854
865 rcvpq.push_back (r); 855 rcvpq.push_back (r);
866 856
867 redo: 857 redo:
868 858
… …
1123 dns_connection *dns = (*i)->dns; 1113 dns_connection *dns = (*i)->dns;
1124 connection *c = dns->c; 1114 connection *c = dns->c;
1125 int seqno = (*i)->seqno; 1115 int seqno = (*i)->seqno;
1126 u8 data[MAXSIZE], *datap = data; 1116 u8 data[MAXSIZE], *datap = data;
1127 //printf ("rcv pkt %x\n", seqno);//D 1117 //printf ("rcv pkt %x\n", seqno);//D
1128 bool back_off = (*i)->retry;
1129 1118
1130 if (back_off) 1119 if ((*i)->retry)
1131 { 1120 {
1132 dns->send_interval *= 1.01; 1121 dns->send_interval *= 1.01;
1133 if (dns->send_interval > MAX_SEND_INTERVAL) 1122 if (dns->send_interval > MAX_SEND_INTERVAL)
1134 dns->send_interval = MAX_SEND_INTERVAL; 1123 dns->send_interval = MAX_SEND_INTERVAL;
1135 } 1124 }
… …
1273 } 1262 }
1274 1263
1275 // todo: pkt now used 1264 // todo: pkt now used
1276 if (datap) 1265 if (datap)
1277 dns->receive_rep (new dns_rcv (seqno, data, datap - data)); 1266 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 1267
1289 break; 1268 break;
1290 } 1269 }
1291} 1270}
1292 1271
… …
1327 1306
1328 if (!c->dns) 1307 if (!c->dns)
1329 c->dns = new dns_connection (c); 1308 c->dns = new dns_connection (c);
1330 1309
1331 if (c->dns->snddq.put (pkt)) 1310 if (c->dns->snddq.put (pkt))
1311 {
1312 min_it (c->dns->poll_interval, 0.25);
1332 c->dns->tw (); 1313 c->dns->tw ();
1314 }
1333 1315
1334 // always return true even if the buffer overflows 1316 // always return true even if the buffer overflows
1335 return true; 1317 return true;
1336} 1318}
1337
1338#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1339 1319
1340void 1320void
1341dns_connection::time_cb (ev::timer &w, int revents) 1321dns_connection::time_cb (ev::timer &w, int revents)
1342{ 1322{
1343 // servers have to be polled 1323 // servers have to be polled
1344 if (THISNODE->dns_port) 1324 if (THISNODE->dns_port)
1345 return; 1325 return;
1346 1326
1347 // check for timeouts and (re)transmit 1327 // check for timeouts and (re)transmit
1348 tstamp next = ev::now () + poll_interval; 1328 tstamp next = 86400 * 365;
1349 dns_snd *send = 0; 1329 dns_snd *send = 0;
1350 1330
1351 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin (); 1331 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1352 i != vpn->dns_sndpq.end (); 1332 i != vpn->dns_sndpq.end ();
1353 ++i) 1333 ++i)
… …
1359 if (!send) 1339 if (!send)
1360 { 1340 {
1361 send = r; 1341 send = r;
1362 1342
1363 r->retry++; 1343 r->retry++;
1364 r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor); 1344 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 1345 //printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1366 1346
1367 // the following code changes the query section a bit, forcing 1347 // the following code changes the query section a bit, forcing
1368 // the forwarder to generate a new request 1348 // the forwarder to generate a new request
1369 if (r->stdhdr) 1349 if (r->stdhdr)
1370 encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry); 1350 encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry);
1371 } 1351 }
1372 } 1352 }
1373 else 1353 else
1374 NEXT (r->timeout); 1354 min_it (next, r->timeout - ev_now ());
1375 } 1355 }
1376 1356
1377 if (!send) 1357 if (!send)
1378 { 1358 {
1379 // generate a new packet, if wise 1359 // generate a new packet, if wise
… …
1393 && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1))) 1373 && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1394 { 1374 {
1395 if (last_sent + send_interval <= ev_now ()) 1375 if (last_sent + send_interval <= ev_now ())
1396 { 1376 {
1397 //printf ("sending data request etc.\n"); //D 1377 //printf ("sending data request etc.\n"); //D
1398 if (!snddq.empty () || last_received + 1. > ev_now ()) 1378 if (!snddq.empty ())
1399 {
1400 poll_interval = send_interval; 1379 min_it (next, send_interval);
1401 NEXT (ev_now () + send_interval);
1402 }
1403 1380
1404 send = new dns_snd (this); 1381 send = new dns_snd (this);
1405 send->gen_stream_req (sndseq, snddq); 1382 send->gen_stream_req (sndseq, snddq);
1406 send->timeout = ev_now () + min_latency * conf.dns_timeout_factor; 1383 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 1384 //printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1408 1385
1409 sndseq = (sndseq + 1) & SEQNO_MASK; 1386 sndseq = (sndseq + 1) & SEQNO_MASK;
1410 } 1387 }
1411 else 1388 else
1412 NEXT (last_sent + send_interval); 1389 min_it (next, last_sent + send_interval - ev_now ());
1413 } 1390 }
1414 1391
1415 if (send) 1392 if (send)
1416 vpn->dns_sndpq.push_back (send); 1393 vpn->dns_sndpq.push_back (send);
1417 } 1394 }
… …
1422 sendto (vpn->dnsv4_fd, 1399 sendto (vpn->dnsv4_fd,
1423 send->pkt->at (0), send->pkt->len, 0, 1400 send->pkt->at (0), send->pkt->len, 0,
1424 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ()); 1401 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1425 } 1402 }
1426 1403
1404 min_it (next, last_sent + max (poll_interval, send_interval) - ev_now ());
1405
1427 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)", 1406 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1428 poll_interval, send_interval, next - ev_now (), 1407 poll_interval, send_interval, next - ev_now (),
1429 vpn->dns_sndpq.size (), snddq.size (), 1408 vpn->dns_sndpq.size (), snddq.size (),
1430 rcvpq.size ()); 1409 rcvpq.size ());
1431 1410
1432 // TODO: no idea when this happens, but when next < ev_now (), we have a problem 1411 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} 1412}
1439 1413
1440#endif 1414#endif
1441 1415

Diff Legend

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