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.34 by pcg, Tue Mar 15 19:26:11 2005 UTC vs.
Revision 1.48 by pcg, Tue Jul 28 00:42:14 2009 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 2.
53
54#define INITIAL_TIMEOUT 0.1 // retry timeouts 67#define INITIAL_TIMEOUT 0.1 // retry timeouts
55#define INITIAL_SYN_TIMEOUT 10. // 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 (32*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
67// every request byte less give room for two reply bytes 77// every request byte less give room for two reply bytes
68 78
… …
73#define MAX_PKT_SIZE 512 83#define MAX_PKT_SIZE 512
74 84
75#define RR_TYPE_A 1 85#define RR_TYPE_A 1
76#define RR_TYPE_NULL 10 86#define RR_TYPE_NULL 10
77#define RR_TYPE_TXT 16 87#define RR_TYPE_TXT 16
88#define RR_TYPE_AAAA 28
78#define RR_TYPE_ANY 255 89#define RR_TYPE_ANY 255
79 90
80#define RR_CLASS_IN 1 91#define RR_CLASS_IN 1
81 92
82#define CMD_IP_1 207 93#define CMD_IP_1 207
… …
462 r4 = r5 = r6 = r7 = 0; 473 r4 = r5 = r6 = r7 = 0;
463} 474}
464 475
465bool dns_cfg::valid () 476bool dns_cfg::valid ()
466{ 477{
478 // although the protocol itself allows for some configurability,
479 // only the following encoding/decoding settings are implemented.
467 return id1 == 'G' 480 return id1 == 'G'
468 && id2 == 'V' 481 && id2 == 'V'
469 && id3 == 'P' 482 && id3 == 'P'
470 && id4 == 'E' 483 && id4 == 'E'
471 && seq_cdc == 26 484 && seq_cdc == 26
… …
558 vector<dns_rcv *> rcvpq; 571 vector<dns_rcv *> rcvpq;
559 572
560 byte_stream rcvdq; int rcvseq; int repseq; 573 byte_stream rcvdq; int rcvseq; int repseq;
561 byte_stream snddq; int sndseq; 574 byte_stream snddq; int sndseq;
562 575
563 void time_cb (time_watcher &w); time_watcher tw; 576 inline void time_cb (ev::timer &w, int revents); ev::timer tw;
564 void receive_rep (dns_rcv *r); 577 void receive_rep (dns_rcv *r);
565 578
566 dns_connection (connection *c); 579 dns_connection (connection *c);
567 ~dns_connection (); 580 ~dns_connection ();
568}; 581};
… …
587: dns (dns) 600: dns (dns)
588{ 601{
589 timeout = 0; 602 timeout = 0;
590 retry = 0; 603 retry = 0;
591 seqno = 0; 604 seqno = 0;
592 sent = NOW; 605 sent = ev_now ();
593 stdhdr = false; 606 stdhdr = false;
594 607
595 pkt = new dns_packet; 608 pkt = new dns_packet;
596 609
597 pkt->id = next_id (); 610 pkt->id = next_id ();
… …
628void dns_snd::gen_stream_req (int seqno, byte_stream &stream) 641void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
629{ 642{
630 stdhdr = true; 643 stdhdr = true;
631 this->seqno = seqno; 644 this->seqno = seqno;
632 645
633 timeout = NOW + INITIAL_TIMEOUT; 646 timeout = ev_now () + INITIAL_TIMEOUT;
634 647
635 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 648 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
636 pkt->qdcount = htons (1); 649 pkt->qdcount = htons (1);
637 650
638 int offs = 6*2; 651 int offs = 6*2;
… …
673 pkt->len = offs; 686 pkt->len = offs;
674} 687}
675 688
676void dns_snd::gen_syn_req () 689void dns_snd::gen_syn_req ()
677{ 690{
678 timeout = NOW + INITIAL_SYN_TIMEOUT; 691 timeout = ev_now () + INITIAL_SYN_TIMEOUT;
679 692
680 pkt->flags = htons (DEFAULT_CLIENT_FLAGS); 693 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
681 pkt->qdcount = htons (1); 694 pkt->qdcount = htons (1);
682 695
683 int offs = 6 * 2; 696 int offs = 6 * 2;
… …
723 736
724dns_connection::dns_connection (connection *c) 737dns_connection::dns_connection (connection *c)
725: c (c) 738: c (c)
726, rcvdq (MAX_BACKLOG * 2) 739, rcvdq (MAX_BACKLOG * 2)
727, snddq (MAX_BACKLOG) 740, snddq (MAX_BACKLOG)
728, tw (this, &dns_connection::time_cb)
729{ 741{
742 tw.set<dns_connection, &dns_connection::time_cb> (this);
743
730 vpn = c->vpn; 744 vpn = c->vpn;
731 745
732 established = false; 746 established = false;
733 747
734 rcvseq = repseq = sndseq = 0; 748 rcvseq = repseq = sndseq = 0;
… …
749 763
750void dns_connection::receive_rep (dns_rcv *r) 764void dns_connection::receive_rep (dns_rcv *r)
751{ 765{
752 if (r->datalen) 766 if (r->datalen)
753 { 767 {
754 last_received = NOW; 768 last_received = ev_now ();
755 tw.trigger (); 769 tw ();
756 770
757 poll_interval = send_interval; 771 poll_interval = send_interval;
758 } 772 }
759 else 773 else
760 { 774 {
… …
770 784
771 // find next packet 785 // find next packet
772 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); ) 786 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
773 if (SEQNO_EQ (rcvseq, (*i)->seqno)) 787 if (SEQNO_EQ (rcvseq, (*i)->seqno))
774 { 788 {
789 //printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
775 // enter the packet into our input stream 790 // enter the packet into our input stream
776 r = *i; 791 r = *i;
777 792
778 // remove the oldest packet, look forward, as it's oldest first 793 // remove the oldest packet, look forward, as it's oldest first
779 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j) 794 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
780 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW)) 795 if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
781 { 796 {
797 //printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
782 delete *j; 798 delete *j;
783 rcvpq.erase (j); 799 rcvpq.erase (j);
784 break; 800 break;
785 } 801 }
786 802
… …
1014 { 1030 {
1015 dns_connection *dns = (*i)->dns; 1031 dns_connection *dns = (*i)->dns;
1016 connection *c = dns->c; 1032 connection *c = dns->c;
1017 int seqno = (*i)->seqno; 1033 int seqno = (*i)->seqno;
1018 u8 data[MAXSIZE], *datap = data; 1034 u8 data[MAXSIZE], *datap = data;
1035 //printf ("rcv pkt %x\n", seqno);//D
1019 1036
1020 if ((*i)->retry) 1037 if ((*i)->retry)
1021 { 1038 {
1022 dns->send_interval *= 1.01; 1039 dns->send_interval *= 1.01;
1023 if (dns->send_interval > MAX_SEND_INTERVAL) 1040 if (dns->send_interval > MAX_SEND_INTERVAL)
… …
1028#if 0 1045#if 0
1029 dns->send_interval *= 0.999; 1046 dns->send_interval *= 0.999;
1030#endif 1047#endif
1031 // the latency surely puts an upper bound on 1048 // the latency surely puts an upper bound on
1032 // the minimum send interval 1049 // the minimum send interval
1033 double latency = NOW - (*i)->sent; 1050 double latency = ev_now () - (*i)->sent;
1034 1051
1035 if (latency < dns->min_latency) 1052 if (latency < dns->min_latency)
1036 dns->min_latency = latency; 1053 dns->min_latency = latency;
1037 1054
1038 if (dns->send_interval > dns->min_latency * LATENCY_FACTOR) 1055 if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
1039 dns->send_interval = dns->min_latency * LATENCY_FACTOR; 1056 dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
1040 1057
1041 if (dns->send_interval < MIN_SEND_INTERVAL) 1058 if (dns->send_interval < conf.dns_send_interval)
1042 dns->send_interval = MIN_SEND_INTERVAL; 1059 dns->send_interval = conf.dns_send_interval;
1043 } 1060 }
1044 1061
1045 delete *i; 1062 delete *i;
1046 dns_sndpq.erase (i); 1063 dns_sndpq.erase (i);
1047 1064
… …
1152 break; 1169 break;
1153 } 1170 }
1154} 1171}
1155 1172
1156void 1173void
1157vpn::dnsv4_ev (io_watcher &w, short revents) 1174vpn::dnsv4_ev (ev::io &w, int revents)
1158{ 1175{
1159 if (revents & EVENT_READ) 1176 if (revents & EV_READ)
1160 { 1177 {
1161 dns_packet *pkt = new dns_packet; 1178 dns_packet *pkt = new dns_packet;
1162 struct sockaddr_in sa; 1179 struct sockaddr_in sa;
1163 socklen_t sa_len = sizeof (sa); 1180 socklen_t sa_len = sizeof (sa);
1164 1181
… …
1190 1207
1191 if (!c->dns) 1208 if (!c->dns)
1192 c->dns = new dns_connection (c); 1209 c->dns = new dns_connection (c);
1193 1210
1194 if (c->dns->snddq.put (pkt)) 1211 if (c->dns->snddq.put (pkt))
1195 c->dns->tw.trigger (); 1212 c->dns->tw ();
1196 1213
1197 // always return true even if the buffer overflows 1214 // always return true even if the buffer overflows
1198 return true; 1215 return true;
1199} 1216}
1200 1217
… …
1205} 1222}
1206 1223
1207#define NEXT(w) do { if (next > (w)) next = w; } while (0) 1224#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1208 1225
1209void 1226void
1210dns_connection::time_cb (time_watcher &w) 1227dns_connection::time_cb (ev::timer &w, int revents)
1211{ 1228{
1212 // servers have to be polled 1229 // servers have to be polled
1213 if (THISNODE->dns_port) 1230 if (THISNODE->dns_port)
1214 return; 1231 return;
1215 1232
1216 // check for timeouts and (re)transmit 1233 // check for timeouts and (re)transmit
1217 tstamp next = NOW + poll_interval; 1234 tstamp next = ev::now () + poll_interval;
1218 dns_snd *send = 0; 1235 dns_snd *send = 0;
1219 1236
1220 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin (); 1237 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1221 i != vpn->dns_sndpq.end (); 1238 i != vpn->dns_sndpq.end ();
1222 ++i) 1239 ++i)
1223 { 1240 {
1224 dns_snd *r = *i; 1241 dns_snd *r = *i;
1225 1242
1226 if (r->timeout <= NOW) 1243 if (r->timeout <= ev_now ())
1227 { 1244 {
1228 if (!send) 1245 if (!send)
1229 { 1246 {
1230 send = r; 1247 send = r;
1231 1248
1232 r->retry++; 1249 r->retry++;
1233 r->timeout = NOW + (r->retry * min_latency * TIMEOUT_FACTOR); 1250 r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
1251 //printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
1234 1252
1235 // the following code changes the query section a bit, forcing 1253 // the following code changes the query section a bit, forcing
1236 // the forwarder to generate a new request 1254 // the forwarder to generate a new request
1237 if (r->stdhdr) 1255 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); 1256 encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry);
1241 }
1242 } 1257 }
1243 } 1258 }
1244 else 1259 else
1245 NEXT (r->timeout); 1260 NEXT (r->timeout);
1246 } 1261 }
… …
1257 1272
1258 cfg.reset (THISNODE->id); 1273 cfg.reset (THISNODE->id);
1259 send->gen_syn_req (); 1274 send->gen_syn_req ();
1260 } 1275 }
1261 } 1276 }
1262 else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING 1277 else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
1263 && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1))) 1278 && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1264 { 1279 {
1265 if (last_sent + send_interval <= NOW) 1280 if (last_sent + send_interval <= ev_now ())
1266 { 1281 {
1267 //printf ("sending data request etc.\n"); //D 1282 //printf ("sending data request etc.\n"); //D
1268 if (!snddq.empty () || last_received + 1. > NOW) 1283 if (!snddq.empty () || last_received + 1. > ev_now ())
1269 { 1284 {
1270 poll_interval = send_interval; 1285 poll_interval = send_interval;
1271 NEXT (NOW + send_interval); 1286 NEXT (ev_now () + send_interval);
1272 } 1287 }
1273 1288
1274 send = new dns_snd (this); 1289 send = new dns_snd (this);
1275 send->gen_stream_req (sndseq, snddq); 1290 send->gen_stream_req (sndseq, snddq);
1276 send->timeout = NOW + min_latency * TIMEOUT_FACTOR; 1291 send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
1292 //printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1277 1293
1278 sndseq = (sndseq + 1) & SEQNO_MASK; 1294 sndseq = (sndseq + 1) & SEQNO_MASK;
1279 } 1295 }
1280 else 1296 else
1281 NEXT (last_sent + send_interval); 1297 NEXT (last_sent + send_interval);
… …
1285 vpn->dns_sndpq.push_back (send); 1301 vpn->dns_sndpq.push_back (send);
1286 } 1302 }
1287 1303
1288 if (send) 1304 if (send)
1289 { 1305 {
1290 last_sent = NOW; 1306 last_sent = ev_now ();
1291 sendto (vpn->dnsv4_fd, 1307 sendto (vpn->dnsv4_fd,
1292 send->pkt->at (0), send->pkt->len, 0, 1308 send->pkt->at (0), send->pkt->len, 0,
1293 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ()); 1309 vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1294 } 1310 }
1295 1311
1296 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)", 1312 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1297 poll_interval, send_interval, next - NOW, 1313 poll_interval, send_interval, next - ev_now (),
1298 vpn->dns_sndpq.size (), snddq.size (), 1314 vpn->dns_sndpq.size (), snddq.size (),
1299 rcvpq.size ()); 1315 rcvpq.size ());
1300 1316
1301 // TODO: no idea when this happens, but when next < NOW, we have a problem 1317 // TODO: no idea when this happens, but when next < ev_now (), we have a problem
1318 // doesn't seem to happen anymore
1302 if (next < NOW + 0.001) 1319 if (next < ev_now () + 0.001)
1303 next = NOW + 0.1; 1320 next = ev_now () + 0.1;
1304 1321
1305 w.start (next); 1322 w.start (next - ev_now ());
1306} 1323}
1307 1324
1308#endif 1325#endif
1309 1326

Diff Legend

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