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.36 by pcg, Thu Mar 17 22:24:31 2005 UTC vs.
Revision 1.47 by pcg, Thu Aug 7 17:54:27 2008 UTC

1/* 1/*
2 vpn_dns.C -- handle the dns tunnel part of the protocol. 2 vpn_dns.C -- handle the dns tunnel part of the protocol.
3 Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de> 3 Copyright (C) 2003-2008 Marc Lehmann <gvpe@schmorp.de>
4 4
5 This file is part of GVPE. 5 This file is part of GVPE.
6 6
7 GVPE is free software; you can redistribute it and/or modify 7 GVPE is free software; you can redistribute it and/or modify it
8 it under the terms of the GNU General Public License as published by 8 under the terms of the GNU General Public License as published by the
9 the Free Software Foundation; either version 2 of the License, or 9 Free Software Foundation; either version 3 of the License, or (at your
10 (at your option) any later version. 10 option) any later version.
11 11
12 This program is distributed in the hope that it will be useful, 12 This program is distributed in the hope that it will be useful, but
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15 GNU General Public License for more details. 15 Public License for more details.
16 16
17 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License along
18 along with gvpe; if not, write to the Free Software 18 with this program; if not, see <http://www.gnu.org/licenses/>.
19 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19
20 Additional permission under GNU GPL version 3 section 7
21
22 If you modify this Program, or any covered work, by linking or
23 combining it with the OpenSSL project's OpenSSL library (or a modified
24 version of that library), containing parts covered by the terms of the
25 OpenSSL or SSLeay licenses, the licensors of this Program grant you
26 additional permission to convey the resulting work. Corresponding
27 Source for a non-source form of such a combination shall include the
28 source code for the parts of OpenSSL used as well as that of the
29 covered work.
20*/ 30*/
31
32// TODO: EDNS0 option to increase dns mtu?
33// TODO: re-write dns packet parsing/creation using a safe mem-buffer
34// to ensure no buffer overflows or similar problems.
21 35
22#include "config.h" 36#include "config.h"
23 37
24#if ENABLE_DNS 38#if ENABLE_DNS
25 39
… …
38#include <unistd.h> 52#include <unistd.h>
39#include <fcntl.h> 53#include <fcntl.h>
40 54
41#include <map> 55#include <map>
42 56
57#include <cstdio> /* bug in libgmp: gmp.h relies on cstdio being included */
43#include <gmp.h> 58#include <gmp.h>
44 59
45#include "netcompat.h" 60#include "netcompat.h"
46 61
47#include "vpn.h" 62#include "vpn.h"
48 63
49#define MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data 64#define MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data
50#define ACTIVITY_INTERVAL 5. 65#define ACTIVITY_INTERVAL 5.
51 66
52#define TIMEOUT_FACTOR 8.
53
54#define INITIAL_TIMEOUT 0.1 // retry timeouts 67#define INITIAL_TIMEOUT 0.1 // retry timeouts
55#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn 68#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
56 69
57#define MIN_SEND_INTERVAL 0.001 // wait at least this time between sending requests
58#define MAX_SEND_INTERVAL 2. // optimistic? 70#define MAX_SEND_INTERVAL 2. // optimistic?
59 71
60#define LATENCY_FACTOR 0.5 // RTT * LATENCY_FACTOR == sending rate
61#define MAX_OUTSTANDING 100 // max. outstanding requests
62#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog 72#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
63#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
64 74
65#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
66// 240 leaves about 4 bytes of server reply data 76// 240 leaves about 4 bytes of server reply data
… …
462 r4 = r5 = r6 = r7 = 0; 472 r4 = r5 = r6 = r7 = 0;
463} 473}
464 474
465bool dns_cfg::valid () 475bool dns_cfg::valid ()
466{ 476{
477 // although the protocol itself allows for some configurability,
478 // only the following encoding/decoding settings are implemented.
467 return id1 == 'G' 479 return id1 == 'G'
468 && id2 == 'V' 480 && id2 == 'V'
469 && id3 == 'P' 481 && id3 == 'P'
470 && id4 == 'E' 482 && id4 == 'E'
471 && seq_cdc == 26 483 && seq_cdc == 26
… …
558 vector<dns_rcv *> rcvpq; 570 vector<dns_rcv *> rcvpq;
559 571
560 byte_stream rcvdq; int rcvseq; int repseq; 572 byte_stream rcvdq; int rcvseq; int repseq;
561 byte_stream snddq; int sndseq; 573 byte_stream snddq; int sndseq;
562 574
563 void time_cb (time_watcher &w); time_watcher tw; 575 inline void time_cb (ev::timer &w, int revents); ev::timer tw;
564 void receive_rep (dns_rcv *r); 576 void receive_rep (dns_rcv *r);
565 577
566 dns_connection (connection *c); 578 dns_connection (connection *c);
567 ~dns_connection (); 579 ~dns_connection ();
568}; 580};
… …
587: dns (dns) 599: dns (dns)
588{ 600{
589 timeout = 0; 601 timeout = 0;
590 retry = 0; 602 retry = 0;
591 seqno = 0; 603 seqno = 0;
592 sent = NOW; 604 sent = ev_now ();
593 stdhdr = false; 605 stdhdr = false;
594 606
595 pkt = new dns_packet; 607 pkt = new dns_packet;
596 608
597 pkt->id = next_id (); 609 pkt->id = next_id ();
… …
628void dns_snd::gen_stream_req (int seqno, byte_stream &stream) 640void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
629{ 641{
630 stdhdr = true; 642 stdhdr = true;
631 this->seqno = seqno; 643 this->seqno = seqno;
632 644
633 timeout = NOW + INITIAL_TIMEOUT; 645 timeout = ev_now () + INITIAL_TIMEOUT;
634 646
635 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 647 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
636 pkt->qdcount = htons (1); 648 pkt->qdcount = htons (1);
637 649
638 int offs = 6*2; 650 int offs = 6*2;
… …
673 pkt->len = offs; 685 pkt->len = offs;
674} 686}
675 687
676void dns_snd::gen_syn_req () 688void dns_snd::gen_syn_req ()
677{ 689{
678 timeout = NOW + INITIAL_SYN_TIMEOUT; 690 timeout = ev_now () + INITIAL_SYN_TIMEOUT;
679 691
680 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 692 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
681 pkt->qdcount = htons (1); 693 pkt->qdcount = htons (1);
682 694
683 int offs = 6 * 2; 695 int offs = 6 * 2;
… …
723 735
724dns_connection::dns_connection (connection *c) 736dns_connection::dns_connection (connection *c)
725: c (c) 737: c (c)
726, rcvdq (MAX_BACKLOG * 2) 738, rcvdq (MAX_BACKLOG * 2)
727, snddq (MAX_BACKLOG) 739, snddq (MAX_BACKLOG)
728, tw (this, &dns_connection::time_cb)
729{ 740{
741 tw.set<dns_connection, &dns_connection::time_cb> (this);
742
730 vpn = c->vpn; 743 vpn = c->vpn;
731 744
732 established = false; 745 established = false;
733 746
734 rcvseq = repseq = sndseq = 0; 747 rcvseq = repseq = sndseq = 0;
… …
749 762
750void dns_connection::receive_rep (dns_rcv *r) 763void dns_connection::receive_rep (dns_rcv *r)
751{ 764{
752 if (r->datalen) 765 if (r->datalen)
753 { 766 {
754 last_received = NOW; 767 last_received = ev_now ();
755 tw.trigger (); 768 tw ();
756 769
757 poll_interval = send_interval; 770 poll_interval = send_interval;
758 } 771 }
759 else 772 else
760 { 773 {
… …
770 783
771 // find next packet 784 // find next packet
772 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); ) 785 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
773 if (SEQNO_EQ (rcvseq, (*i)->seqno)) 786 if (SEQNO_EQ (rcvseq, (*i)->seqno))
774 { 787 {
788 //printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
775 // enter the packet into our input stream 789 // enter the packet into our input stream
776 r = *i; 790 r = *i;
777 791
778 // remove the oldest packet, look forward, as it's oldest first 792 // remove the oldest packet, look forward, as it's oldest first
779 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j) 793 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
780 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW)) 794 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
781 { 795 {
796 //printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
782 delete *j; 797 delete *j;
783 rcvpq.erase (j); 798 rcvpq.erase (j);
784 break; 799 break;
785 } 800 }
786 801
… …
1014 { 1029 {
1015 dns_connection *dns = (*i)->dns; 1030 dns_connection *dns = (*i)->dns;
1016 connection *c = dns->c; 1031 connection *c = dns->c;
1017 int seqno = (*i)->seqno; 1032 int seqno = (*i)->seqno;
1018 u8 data[MAXSIZE], *datap = data; 1033 u8 data[MAXSIZE], *datap = data;
1034 //printf ("rcv pkt %x\n", seqno);//D
1019 1035
1020 if ((*i)->retry) 1036 if ((*i)->retry)
1021 { 1037 {
1022 dns->send_interval *= 1.01; 1038 dns->send_interval *= 1.01;
1023 if (dns->send_interval > MAX_SEND_INTERVAL) 1039 if (dns->send_interval > MAX_SEND_INTERVAL)
… …
1028#if 0 1044#if 0
1029 dns->send_interval *= 0.999; 1045 dns->send_interval *= 0.999;
1030#endif 1046#endif
1031 // the latency surely puts an upper bound on 1047 // the latency surely puts an upper bound on
1032 // the minimum send interval 1048 // the minimum send interval
1033 double latency = NOW - (*i)->sent; 1049 double latency = ev_now () - (*i)->sent;
1034 1050
1035 if (latency < dns->min_latency) 1051 if (latency < dns->min_latency)
1036 dns->min_latency = latency; 1052 dns->min_latency = latency;
1037 1053
1038 if (dns->send_interval > dns->min_latency * LATENCY_FACTOR) 1054 if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
1039 dns->send_interval = dns->min_latency * LATENCY_FACTOR; 1055 dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
1040 1056
1041 if (dns->send_interval < MIN_SEND_INTERVAL) 1057 if (dns->send_interval < conf.dns_send_interval)
1042 dns->send_interval = MIN_SEND_INTERVAL; 1058 dns->send_interval = conf.dns_send_interval;
1043 } 1059 }
1044 1060
1045 delete *i; 1061 delete *i;
1046 dns_sndpq.erase (i); 1062 dns_sndpq.erase (i);
1047 1063
… …
1152 break; 1168 break;
1153 } 1169 }
1154} 1170}
1155 1171
1156void 1172void
1157vpn::dnsv4_ev (io_watcher &w, short revents) 1173vpn::dnsv4_ev (ev::io &w, int revents)
1158{ 1174{
1159 if (revents & EVENT_READ) 1175 if (revents & EV_READ)
1160 { 1176 {
1161 dns_packet *pkt = new dns_packet; 1177 dns_packet *pkt = new dns_packet;
1162 struct sockaddr_in sa; 1178 struct sockaddr_in sa;
1163 socklen_t sa_len = sizeof (sa); 1179 socklen_t sa_len = sizeof (sa);
1164 1180
… …
1190 1206
1191 if (!c->dns) 1207 if (!c->dns)
1192 c->dns = new dns_connection (c); 1208 c->dns = new dns_connection (c);
1193 1209
1194 if (c->dns->snddq.put (pkt)) 1210 if (c->dns->snddq.put (pkt))
1195 c->dns->tw.trigger (); 1211 c->dns->tw ();
1196 1212
1197 // always return true even if the buffer overflows 1213 // always return true even if the buffer overflows
1198 return true; 1214 return true;
1199} 1215}
1200 1216
… …
1205} 1221}
1206 1222
1207#define NEXT(w) do { if (next > (w)) next = w; } while (0) 1223#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1208 1224
1209void 1225void
1210dns_connection::time_cb (time_watcher &w) 1226dns_connection::time_cb (ev::timer &w, int revents)
1211{ 1227{
1212 // servers have to be polled 1228 // servers have to be polled
1213 if (THISNODE->dns_port) 1229 if (THISNODE->dns_port)
1214 return; 1230 return;
1215 1231
1216 // check for timeouts and (re)transmit 1232 // check for timeouts and (re)transmit
1217 tstamp next = NOW + poll_interval; 1233 tstamp next = ev::now () + poll_interval;
1218 dns_snd *send = 0; 1234 dns_snd *send = 0;
1219 1235
1220 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin (); 1236 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1221 i != vpn->dns_sndpq.end (); 1237 i != vpn->dns_sndpq.end ();
1222 ++i) 1238 ++i)
1223 { 1239 {
1224 dns_snd *r = *i; 1240 dns_snd *r = *i;
1225 1241
1226 if (r->timeout <= NOW) 1242 if (r->timeout <= ev_now ())
1227 { 1243 {
1228 if (!send) 1244 if (!send)
1229 { 1245 {
1230 send = r; 1246 send = r;
1231 1247
1232 r->retry++; 1248 r->retry++;
1233 r->timeout = NOW + (r->retry * min_latency * TIMEOUT_FACTOR); 1249 r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
1250 //printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1234 1251
1235 // the following code changes the query section a bit, forcing 1252 // the following code changes the query section a bit, forcing
1236 // the forwarder to generate a new request 1253 // the forwarder to generate a new request
1237 if (r->stdhdr) 1254 if (r->stdhdr)
1238 {
1239 //printf ("reencoded header for ID %d retry %d:%d:%d (%p)\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);
1240 //encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry); 1255 encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry);
1241 }
1242 } 1256 }
1243 } 1257 }
1244 else 1258 else
1245 NEXT (r->timeout); 1259 NEXT (r->timeout);
1246 } 1260 }
… …
1257 1271
1258 cfg.reset (THISNODE->id); 1272 cfg.reset (THISNODE->id);
1259 send->gen_syn_req (); 1273 send->gen_syn_req ();
1260 } 1274 }
1261 } 1275 }
1262 else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING 1276 else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1263 && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1))) 1277 && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1264 { 1278 {
1265 if (last_sent + send_interval <= NOW) 1279 if (last_sent + send_interval <= ev_now ())
1266 { 1280 {
1267 //printf ("sending data request etc.\n"); //D 1281 //printf ("sending data request etc.\n"); //D
1268 if (!snddq.empty () || last_received + 1. > NOW) 1282 if (!snddq.empty () || last_received + 1. > ev_now ())
1269 { 1283 {
1270 poll_interval = send_interval; 1284 poll_interval = send_interval;
1271 NEXT (NOW + send_interval); 1285 NEXT (ev_now () + send_interval);
1272 } 1286 }
1273 1287
1274 send = new dns_snd (this); 1288 send = new dns_snd (this);
1275 send->gen_stream_req (sndseq, snddq); 1289 send->gen_stream_req (sndseq, snddq);
1276 send->timeout = NOW + min_latency * TIMEOUT_FACTOR; 1290 send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
1291 //printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1277 1292
1278 sndseq = (sndseq + 1) & SEQNO_MASK; 1293 sndseq = (sndseq + 1) & SEQNO_MASK;
1279 } 1294 }
1280 else 1295 else
1281 NEXT (last_sent + send_interval); 1296 NEXT (last_sent + send_interval);
… …
1285 vpn->dns_sndpq.push_back (send); 1300 vpn->dns_sndpq.push_back (send);
1286 } 1301 }
1287 1302
1288 if (send) 1303 if (send)
1289 { 1304 {
1290 last_sent = NOW; 1305 last_sent = ev_now ();
1291 sendto (vpn->dnsv4_fd, 1306 sendto (vpn->dnsv4_fd,
1292 send->pkt->at (0), send->pkt->len, 0, 1307 send->pkt->at (0), send->pkt->len, 0,
1293 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ()); 1308 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1294 } 1309 }
1295 1310
1296 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)", 1311 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1297 poll_interval, send_interval, next - NOW, 1312 poll_interval, send_interval, next - ev_now (),
1298 vpn->dns_sndpq.size (), snddq.size (), 1313 vpn->dns_sndpq.size (), snddq.size (),
1299 rcvpq.size ()); 1314 rcvpq.size ());
1300 1315
1301 // TODO: no idea when this happens, but when next < NOW, we have a problem 1316 // TODO: no idea when this happens, but when next < ev_now (), we have a problem
1317 // doesn't seem to happen anymore
1302 if (next < NOW + 0.001) 1318 if (next < ev_now () + 0.001)
1303 next = NOW + 0.1; 1319 next = ev_now () + 0.1;
1304 1320
1305 w.start (next); 1321 w.start (next - ev_now ());
1306} 1322}
1307 1323
1308#endif 1324#endif
1309 1325

Diff Legend

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