ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/vpn.C
(Generate patch)

Comparing gvpe/src/vpn.C (file contents):
Revision 1.31 by pcg, Sat Mar 5 19:13:16 2005 UTC vs.
Revision 1.62 by root, Sat Dec 17 22:05:34 2011 UTC

1/* 1/*
2 vpn.C -- handle the protocol, encryption, handshaking etc. 2 vpn.C -- handle the protocol, encryption, handshaking etc.
3 Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de> 3 Copyright (C) 2003-2008,2010,2011 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*/
21 31
22#include "config.h" 32#include "config.h"
23 33
24#include <list> 34#include <list>
… …
46 56
47vpn network; // THE vpn (bad design...) 57vpn network; // THE vpn (bad design...)
48 58
49///////////////////////////////////////////////////////////////////////////// 59/////////////////////////////////////////////////////////////////////////////
50 60
51const char *vpn::script_if_up () 61static void inline
62set_tos (int fd, int &tos_prev, int tos)
63{
64#if defined(SOL_IP) && defined(IP_TOS)
65 if (tos_prev == tos)
66 return;
67
68 tos_prev = tos;
69 setsockopt (fd, SOL_IP, IP_TOS, &tos, sizeof tos);
70#endif
71}
72
73void
74vpn::script_init_env ()
52{ 75{
53 // the tunnel device mtu should be the physical mtu - overhead 76 // the tunnel device mtu should be the physical mtu - overhead
54 // the tricky part is rounding to the cipher key blocksize 77 // the tricky part is rounding to the cipher key blocksize
55 int mtu = conf.mtu - ETH_OVERHEAD - VPE_OVERHEAD - MAX_OVERHEAD; 78 int mtu = conf.mtu - ETH_OVERHEAD - VPE_OVERHEAD - MAX_OVERHEAD;
56 mtu += ETH_OVERHEAD - 6 - 6; // now we have the data portion 79 mtu += ETH_OVERHEAD - 6 - 6; // now we have the data portion
57 mtu -= mtu % EVP_CIPHER_block_size (CIPHER); // round 80 mtu -= mtu % EVP_CIPHER_block_size (CIPHER); // round
58 mtu -= ETH_OVERHEAD - 6 - 6; // and get interface mtu again 81 mtu -= ETH_OVERHEAD - 6 - 6; // and get interface mtu again
59 82
60 char *env; 83 char *env;
61 asprintf (&env, "CONFBASE=%s", confbase); putenv (env); 84 asprintf (&env, "CONFBASE=%s", confbase); putenv (env);
62 asprintf (&env, "NODENAME=%s", THISNODE->nodename); putenv (env);
63 asprintf (&env, "NODEID=%d", THISNODE->id); putenv (env);
64 asprintf (&env, "IFNAME=%s", tap->interface ()); putenv (env); 85 asprintf (&env, "IFNAME=%s", tap->interface ()); putenv (env);
65 asprintf (&env, "IFTYPE=%s", IFTYPE); putenv (env); 86 asprintf (&env, "IFTYPE=%s", IFTYPE); putenv (env);
66 asprintf (&env, "IFSUBTYPE=%s", IFSUBTYPE); putenv (env); 87 asprintf (&env, "IFSUBTYPE=%s", IFSUBTYPE); putenv (env);
67 asprintf (&env, "MTU=%d", mtu); putenv (env); 88 asprintf (&env, "MTU=%d", mtu); putenv (env);
68 asprintf (&env, "MAC=%02x:%02x:%02x:%02x:%02x:%02x", 89 asprintf (&env, "NODES=%d", conns.size ()); putenv (env);
69 0xfe, 0xfd, 0x80, 0x00, THISNODE->id >> 8, 90 asprintf (&env, "NODEID=%d", THISNODE->id); putenv (env);
70 THISNODE->id & 0xff);
71 putenv (env);
72 91
92 conns [THISNODE->id - 1]->script_init_env ("");
93
94 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c)
95 {
96 char ext[16];
97 snprintf (ext, 16, "_%d", (*c)->conf->id);
98 (*c)->script_init_env (ext);
99 }
100}
101
102inline const char *
103vpn::script_if_init ()
104{
105 script_init_env ();
106
107 return tap->if_up ();
108}
109
110inline const char *
111vpn::script_if_up ()
112{
113 script_init_env ();
114
115 char *filename;
116 asprintf (&filename,
117 "%s/%s",
118 confbase,
73 return ::conf.script_if_up ? ::conf.script_if_up : "if-up"; 119 ::conf.script_if_up ? ::conf.script_if_up : "if-up");
120
121 return filename;
122}
123
124int
125vpn::setup_socket (u8 prot, int family, int type, int proto)
126{
127 int fd = socket (family, type, proto);
128
129 if (fd < 0)
130 {
131 slog (L_ERR, _("unable to create %s socket: %s."), strprotocol (prot), strerror (errno));
132 return fd;
133 }
134
135 fcntl (fd, F_SETFL, O_NONBLOCK);
136 fcntl (fd, F_SETFD, FD_CLOEXEC);
137
138#ifdef SO_MARK
139 if (::conf.nfmark)
140 if (setsockopt (fd, SOL_SOCKET, SO_MARK, &::conf.nfmark, sizeof ::conf.nfmark))
141 slog (L_WARN, _("unable to set nfmark on %s socket: %s"), strprotocol (prot), strerror (errno));
142#endif
143
144 return fd;
74} 145}
75 146
76int 147int
77vpn::setup () 148vpn::setup ()
78{ 149{
150 int success = 0;
151
152#if 1//D2
153 ipv42_tos = -1;
79 ipv4_fd = -1; 154 ipv42_fd = -1;
80 155
81 if (THISNODE->protocols & PROT_IPv4 && ::conf.ip_proto) 156 if (THISNODE->protocols & PROT_IPv42 && ::conf.ip_proto)
82 { 157 {
83 ipv4_fd = socket (PF_INET, SOCK_RAW, ::conf.ip_proto); 158 ipv42_fd = setup_socket (PROT_IPv42, PF_INET, SOCK_RAW, ::conf.ip2_proto);
84 159
85 if (ipv4_fd < 0) 160 if (ipv42_fd < 0)
86 return -1; 161 return -1;
87
88 fcntl (ipv4_fd, F_SETFL, O_NONBLOCK);
89 162
90#if defined(SOL_IP) && defined(IP_MTU_DISCOVER) 163#if defined(SOL_IP) && defined(IP_MTU_DISCOVER)
91 // this I really consider a linux bug. I am neither connected 164 // this I really consider a linux bug. I am neither connected
92 // nor do I fragment myself. Linux still sets DF and doesn't 165 // nor do I fragment myself. Linux still sets DF and doesn't
93 // fragment for me sometimes. 166 // fragment for me sometimes.
94 { 167 {
95 int oval = IP_PMTUDISC_DONT; 168 int oval = IP_PMTUDISC_DONT;
96 setsockopt (ipv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval); 169 setsockopt (ipv42_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval);
97 } 170 }
98#endif 171#endif
99 172
100 sockinfo si (THISNODE, PROT_IPv4); 173 sockinfo si (THISNODE, PROT_IPv42);
101 174
102 if (bind (ipv4_fd, si.sav4 (), si.salenv4 ())) 175 if (bind (ipv42_fd, si.sav4 (), si.salenv4 ()))
103 { 176 {
104 slog (L_ERR, _("can't bind ipv4 socket on %s: %s"), (const char *)si, strerror (errno)); 177 slog (L_ERR, _("can't bind ipv42 socket on %s: %s, exiting."), (const char *)si, strerror (errno));
105 exit (EXIT_FAILURE); 178 return -1;
106 } 179 }
107 180
108 ipv4_ev_watcher.start (ipv4_fd, EVENT_READ); 181 ipv42_ev_watcher.start (ipv42_fd, EV_READ);
182 ++success;
109 } 183 }
184 else
185 THISNODE->protocols &= ~PROT_IPv42;
186#endif
110 187
188 ipv4_tos = -1;
111 udpv4_fd = -1; 189 ipv4_fd = -1;
112 190
113 if (THISNODE->protocols & PROT_UDPv4 && THISNODE->udp_port) 191 if (THISNODE->protocols & PROT_IPv4 && ::conf.ip_proto)
114 { 192 {
115 udpv4_fd = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP); 193 ipv4_fd = setup_socket (PROT_IPv4, PF_INET, SOCK_RAW, ::conf.ip_proto);
116 194
117 if (udpv4_fd < 0) 195 if (ipv4_fd < 0)
118 return -1; 196 return -1;
119
120 fcntl (udpv4_fd, F_SETFL, O_NONBLOCK);
121
122 // standard daemon practise...
123 {
124 int oval = 1;
125 setsockopt (udpv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval);
126 }
127 197
128#if defined(SOL_IP) && defined(IP_MTU_DISCOVER) 198#if defined(SOL_IP) && defined(IP_MTU_DISCOVER)
129 // this I really consider a linux bug. I am neither connected 199 // this I really consider a linux bug. I am neither connected
130 // nor do I fragment myself. Linux still sets DF and doesn't 200 // nor do I fragment myself. Linux still sets DF and doesn't
131 // fragment for me sometimes. 201 // fragment for me sometimes.
132 { 202 {
133 int oval = IP_PMTUDISC_DONT; 203 int oval = IP_PMTUDISC_DONT;
204 setsockopt (ipv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval);
205 }
206#endif
207
208 sockinfo si (THISNODE, PROT_IPv4);
209
210 if (bind (ipv4_fd, si.sav4 (), si.salenv4 ()))
211 {
212 slog (L_ERR, _("can't bind ipv4 socket on %s: %s, exiting."), (const char *)si, strerror (errno));
213 return -1;
214 }
215
216 ipv4_ev_watcher.start (ipv4_fd, EV_READ);
217 ++success;
218 }
219 else
220 THISNODE->protocols &= ~PROT_IPv4;
221
222 udpv4_tos = -1;
223 udpv4_fd = -1;
224
225 if (THISNODE->protocols & PROT_UDPv4 && THISNODE->udp_port)
226 {
227 udpv4_fd = setup_socket (PROT_UDPv4, PF_INET, SOCK_DGRAM, IPPROTO_UDP);
228
229 if (udpv4_fd < 0)
230 return -1;
231
232 // standard daemon practise...
233 {
234 int oval = 1;
235 setsockopt (udpv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval);
236 }
237
238#if defined(SOL_IP) && defined(IP_MTU_DISCOVER)
239 // this I really consider a linux bug. I am neither connected
240 // nor do I fragment myself. Linux still sets DF and doesn't
241 // fragment for me sometimes.
242 {
243 int oval = IP_PMTUDISC_DONT;
134 setsockopt (udpv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval); 244 setsockopt (udpv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval);
135 } 245 }
136#endif 246#endif
137 247
138 sockinfo si (THISNODE, PROT_UDPv4); 248 sockinfo si (THISNODE, PROT_UDPv4);
139 249
140 if (bind (udpv4_fd, si.sav4 (), si.salenv4 ())) 250 if (bind (udpv4_fd, si.sav4 (), si.salenv4 ()))
141 { 251 {
142 slog (L_ERR, _("can't bind udpv4 on %s: %s"), (const char *)si, strerror (errno)); 252 slog (L_ERR, _("can't bind udpv4 on %s: %s, exiting."), (const char *)si, strerror (errno));
143 exit (EXIT_FAILURE); 253 return -1;
144 } 254 }
145 255
146 udpv4_ev_watcher.start (udpv4_fd, EVENT_READ); 256 udpv4_ev_watcher.start (udpv4_fd, EV_READ);
257 ++success;
147 } 258 }
259 else
260 THISNODE->protocols &= ~PROT_UDPv4;
148 261
262 icmpv4_tos = -1;
149 icmpv4_fd = -1; 263 icmpv4_fd = -1;
150 264
151#if ENABLE_ICMP 265#if ENABLE_ICMP
152 if (THISNODE->protocols & PROT_ICMPv4) 266 if (THISNODE->protocols & PROT_ICMPv4)
153 { 267 {
154 icmpv4_fd = socket (PF_INET, SOCK_RAW, IPPROTO_ICMP); 268 icmpv4_fd = setup_socket (PROT_ICMPv4, PF_INET, SOCK_RAW, IPPROTO_ICMP);
155 269
156 if (icmpv4_fd < 0) 270 if (icmpv4_fd < 0)
157 return -1; 271 return -1;
158
159 fcntl (icmpv4_fd, F_SETFL, O_NONBLOCK);
160 272
161#ifdef ICMP_FILTER 273#ifdef ICMP_FILTER
162 { 274 {
163 icmp_filter oval; 275 icmp_filter oval;
164 oval.data = 0xffffffff; 276 oval.data = 0xffffffff;
… …
173 // this I really consider a linux bug. I am neither connected 285 // this I really consider a linux bug. I am neither connected
174 // nor do I fragment myself. Linux still sets DF and doesn't 286 // nor do I fragment myself. Linux still sets DF and doesn't
175 // fragment for me sometimes. 287 // fragment for me sometimes.
176 { 288 {
177 int oval = IP_PMTUDISC_DONT; 289 int oval = IP_PMTUDISC_DONT;
178 setsockopt (udpv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval); 290 setsockopt (icmpv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval);
179 } 291 }
180#endif 292#endif
181 293
182 sockinfo si (THISNODE, PROT_ICMPv4); 294 sockinfo si (THISNODE, PROT_ICMPv4);
183 295
184 if (bind (icmpv4_fd, si.sav4 (), si.salenv4 ())) 296 if (bind (icmpv4_fd, si.sav4 (), si.salenv4 ()))
185 { 297 {
186 slog (L_ERR, _("can't bind icmpv4 on %s: %s"), (const char *)si, strerror (errno)); 298 slog (L_ERR, _("can't bind icmpv4 on %s: %s, exiting."), (const char *)si, strerror (errno));
187 exit (EXIT_FAILURE); 299 return -1;
188 } 300 }
189 301
190 icmpv4_ev_watcher.start (icmpv4_fd, EVENT_READ); 302 icmpv4_ev_watcher.start (icmpv4_fd, EV_READ);
303 ++success;
191 } 304 }
192#endif 305#endif
193 306
194 tcpv4_fd = -1; 307 tcpv4_fd = -1;
195 308
196#if ENABLE_TCP 309#if ENABLE_TCP
197 if (THISNODE->protocols & PROT_TCPv4 && THISNODE->tcp_port) 310 if (THISNODE->protocols & PROT_TCPv4 && THISNODE->tcp_port)
198 { 311 {
199 tcpv4_fd = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP); 312 tcpv4_fd = setup_socket (PROT_TCPv4, PF_INET, SOCK_STREAM, IPPROTO_TCP);
200 313
201 if (tcpv4_fd < 0) 314 if (tcpv4_fd < 0)
202 return -1; 315 return -1;
203 316
204 fcntl (tcpv4_fd, F_SETFL, O_NONBLOCK);
205
206 // standard daemon practise... 317 // standard daemon practise...
207 { 318 {
208 int oval = 1; 319 int oval = 1;
209 setsockopt (tcpv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval); 320 setsockopt (tcpv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval);
210 } 321 }
211 322
212 sockinfo si (THISNODE, PROT_TCPv4); 323 sockinfo si (THISNODE, PROT_TCPv4);
213 324
214 if (bind (tcpv4_fd, si.sav4 (), si.salenv4 ())) 325 if (bind (tcpv4_fd, si.sav4 (), si.salenv4 ()))
215 { 326 {
216 slog (L_ERR, _("can't bind tcpv4 on %s: %s"), (const char *)si, strerror (errno)); 327 slog (L_ERR, _("can't bind tcpv4 on %s: %s, exiting."), (const char *)si, strerror (errno));
217 exit (EXIT_FAILURE); 328 return -1;
218 } 329 }
219 330
220 if (listen (tcpv4_fd, 5)) 331 if (listen (tcpv4_fd, 5))
221 { 332 {
222 slog (L_ERR, _("can't listen tcpv4 on %s: %s"), (const char *)si, strerror (errno)); 333 slog (L_ERR, _("can't listen tcpv4 on %s: %s, exiting."), (const char *)si, strerror (errno));
223 exit (EXIT_FAILURE); 334 return -1;
224 } 335 }
225 336
226 tcpv4_ev_watcher.start (tcpv4_fd, EVENT_READ); 337 tcpv4_ev_watcher.start (tcpv4_fd, EV_READ);
338 ++success;
227 } 339 }
340 else
341 THISNODE->protocols &= ~PROT_TCPv4;
228#endif 342#endif
343
344 dnsv4_tos = -1;
345 dnsv4_fd = -1;
229 346
230#if ENABLE_DNS 347#if ENABLE_DNS
231 if (THISNODE->protocols & PROT_DNSv4) 348 if (THISNODE->protocols & PROT_DNSv4)
232 { 349 {
233 dns_forwarder.set (::conf.dns_forw_host, ::conf.dns_forw_port, PROT_DNSv4); 350 dns_forwarder.set (::conf.dns_forw_host, ::conf.dns_forw_port, PROT_DNSv4);
234 351
235 dnsv4_fd = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP); 352 dnsv4_fd = setup_socket (PROT_DNSv4, PF_INET, SOCK_DGRAM, IPPROTO_UDP);
236 353
237 if (dnsv4_fd < 0) 354 if (dnsv4_fd < 0)
238 return -1; 355 return -1;
356
357# if defined(SOL_IP) && defined(IP_MTU_DISCOVER)
358 // this I really consider a linux bug. I am neither connected
359 // nor do I fragment myself. Linux still sets DF and doesn't
360 // fragment for me sometimes.
361 {
362 int oval = IP_PMTUDISC_DONT;
363 setsockopt (dnsv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval);
364 }
365# endif
239 366
240 // standard daemon practise... 367 // standard daemon practise...
241 { 368 {
242 int oval = 1; 369 int oval = 1;
243 setsockopt (dnsv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval); 370 setsockopt (dnsv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval);
… …
247 THISNODE->dns_hostname ? THISNODE->dns_port : 0, 374 THISNODE->dns_hostname ? THISNODE->dns_port : 0,
248 PROT_DNSv4); 375 PROT_DNSv4);
249 376
250 if (bind (dnsv4_fd, si.sav4 (), si.salenv4 ())) 377 if (bind (dnsv4_fd, si.sav4 (), si.salenv4 ()))
251 { 378 {
252 slog (L_ERR, _("can't bind dnsv4 on %s: %s"), (const char *)si, strerror (errno)); 379 slog (L_ERR, _("can't bind dnsv4 on %s: %s, exiting."), (const char *)si, strerror (errno));
253 exit (EXIT_FAILURE); 380 return -1;
254 } 381 }
255 382
256 dnsv4_ev_watcher.start (dnsv4_fd, EVENT_READ); 383 dnsv4_ev_watcher.start (dnsv4_fd, EV_READ);
384 ++success;
385 }
386#endif
387
388 /////////////////////////////////////////////////////////////////////////////
389
390 if (!success)
257 } 391 {
258#endif 392 slog (L_ERR, _("no protocols enabled."));
393 return -1;
394 }
395
396 reconnect_all ();
397
398 /////////////////////////////////////////////////////////////////////////////
259 399
260 tap = new tap_device (); 400 tap = new tap_device ();
261 if (!tap) //D this, of course, never catches 401 if (!tap) //D this, of course, never catches
262 { 402 {
263 slog (L_ERR, _("cannot create network interface '%s'"), conf.ifname); 403 slog (L_ERR, _("cannot create network interface '%s'."), conf.ifname);
264 exit (EXIT_FAILURE); 404 return -1;
265 } 405 }
266 406
267 run_script (run_script_cb (this, &vpn::script_if_up), true); 407 fcntl (tap->fd, F_SETFD, FD_CLOEXEC);
268 408
409 run_script_cb cb;
410 cb.set<vpn, &vpn::script_if_init> (this);
411
412 if (tap->if_up () &&
413 !run_script (cb, true))
414 {
415 slog (L_ERR, _("interface initialization command '%s' failed."),
416 tap->if_up ());
417 return -1;
418 }
419
420 cb.set<vpn, &vpn::script_if_up> (this);
421 if (!run_script (cb, true))
422 {
423 slog (L_ERR, _("if-up command execution failed."));
424 return -1;
425 }
426
269 tap_ev_watcher.start (tap->fd, EVENT_READ); 427 tap_ev_watcher.start (tap->fd, EV_READ);
270
271 reconnect_all ();
272 428
273 return 0; 429 return 0;
274} 430}
275 431
276bool 432bool
277vpn::send_ipv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 433vpn::send_ipv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
278{ 434{
279#if defined(SOL_IP) && defined(IP_TOS) 435 set_tos (ipv4_fd, ipv4_tos, tos);
280 setsockopt (ipv4_fd, SOL_IP, IP_TOS, &tos, sizeof tos);
281#endif
282 sendto (ipv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ()); 436 sendto (ipv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ());
283 437
284 return true; 438 return true;
285} 439}
440
441#if 1 //D
442bool
443vpn::send_ipv42_packet (vpn_packet *pkt, const sockinfo &si, int tos)
444{
445 set_tos (ipv42_fd, ipv42_tos, tos);
446 sendto (ipv42_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ());
447
448 return true;
449}
450#endif
286 451
287static u16 452static u16
288ipv4_checksum (u16 *data, unsigned int len) 453ipv4_checksum (u16 *data, unsigned int len)
289{ 454{
290 // use 32 bit accumulator and fold back carry bits at the end 455 // use 32 bit accumulator and fold back carry bits at the end
… …
309 474
310#if ENABLE_ICMP 475#if ENABLE_ICMP
311bool 476bool
312vpn::send_icmpv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 477vpn::send_icmpv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
313{ 478{
314#if defined(SOL_IP) && defined(IP_TOS)
315 setsockopt (icmpv4_fd, SOL_IP, IP_TOS, &tos, sizeof tos);
316#endif
317
318 pkt->unshift_hdr (4); 479 pkt->unshift_hdr (4);
319 480
320 icmp_header *hdr = (icmp_header *)&((*pkt)[0]); 481 icmp_header *hdr = (icmp_header *)&((*pkt)[0]);
321 hdr->type = ::conf.icmp_type; 482 hdr->type = ::conf.icmp_type;
322 hdr->code = 255; 483 hdr->code = 255;
323 hdr->checksum = 0; 484 hdr->checksum = 0;
324 hdr->checksum = ipv4_checksum ((u16 *)hdr, pkt->len); 485 hdr->checksum = ipv4_checksum ((u16 *)hdr, pkt->len);
325 486
487 set_tos (icmpv4_fd, icmpv4_tos, tos);
326 sendto (icmpv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ()); 488 sendto (icmpv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ());
327 489
328 return true; 490 return true;
329} 491}
330#endif 492#endif
331 493
332bool 494bool
333vpn::send_udpv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 495vpn::send_udpv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
334{ 496{
335#if defined(SOL_IP) && defined(IP_TOS) 497 set_tos (udpv4_fd, udpv4_tos, tos);
336 setsockopt (udpv4_fd, SOL_IP, IP_TOS, &tos, sizeof tos);
337#endif
338 sendto (udpv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ()); 498 sendto (udpv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ());
339 499
340 return true; 500 return true;
341} 501}
342 502
… …
353 { 513 {
354 // broadcast, this is ugly, but due to the security policy 514 // broadcast, this is ugly, but due to the security policy
355 // we have to connect to all hosts... 515 // we have to connect to all hosts...
356 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c) 516 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c)
357 if ((*c)->conf != THISNODE) 517 if ((*c)->conf != THISNODE)
358 (*c)->inject_data_packet (pkt, true); 518 (*c)->inject_data_packet (pkt);
359 } 519 }
360} 520}
361 521
362void 522void
363vpn::recv_vpn_packet (vpn_packet *pkt, const sockinfo &rsi) 523vpn::recv_vpn_packet (vpn_packet *pkt, const sockinfo &rsi)
364{ 524{
365 unsigned int src = pkt->src (); 525 unsigned int src = pkt->src ();
366 unsigned int dst = pkt->dst (); 526 unsigned int dst = pkt->dst ();
367 527
368 slog (L_NOISE, _("<<?/%s received possible vpn packet type %d from %d to %d, length %d"), 528 slog (L_NOISE, _("<<?/%s received possible vpn packet type %d from %d to %d, length %d."),
369 (const char *)rsi, pkt->typ (), pkt->src (), pkt->dst (), pkt->len); 529 (const char *)rsi, pkt->typ (), pkt->src (), pkt->dst (), pkt->len);
370 530
371 if (src == 0 || src > conns.size () 531 if (src == 0 || src > conns.size ()
372 || dst > conns.size () 532 || dst > conns.size ()
373 || pkt->typ () >= vpn_packet::PT_MAX) 533 || pkt->typ () >= vpn_packet::PT_MAX)
374 slog (L_WARN, _("(%s): received corrupted packet type %d (src %d, dst %d)"), 534 slog (L_WARN, _("(%s): received corrupted packet type %d (src %d, dst %d)."),
375 (const char *)rsi, pkt->typ (), pkt->src (), pkt->dst ()); 535 (const char *)rsi, pkt->typ (), pkt->src (), pkt->dst ());
376 else if (dst > conns.size ())
377 slog (L_WARN, _("(%s): received corrupted packet type %d (src %d, dst %d)"),
378 (const char *)rsi, pkt->typ (), pkt->src (), pkt->dst ());
379 else 536 else
380 { 537 {
381 connection *c = conns[src - 1]; 538 connection *c = conns[src - 1];
382 539
383 if (dst == 0) 540 if (dst == 0)
384 slog (L_WARN, _("%s(%s): received broadcast (protocol violation)"), 541 slog (L_WARN, _("%s(%s): received broadcast (protocol violation)."),
385 c->conf->nodename, (const char *)rsi); 542 c->conf->nodename, (const char *)rsi);
386 else if (dst != THISNODE->id) 543 else if (dst != THISNODE->id)
387 { 544 {
388 if (THISNODE->routerprio) 545 if (THISNODE->routerprio)
389 // the tos setting gets lost here. who cares. 546 // the tos setting gets lost here. who cares.
390 conns[dst - 1]->inject_vpn_packet (pkt); 547 conns[dst - 1]->inject_vpn_packet (pkt);
391 else 548 else
392 slog (L_WARN, 549 slog (L_WARN,
393 _("%s(%s): forwarding request (=> %s), but we are no router"), 550 _("%s(%s): request to forward packet to %s, but we are no router (config mismatch?)."),
394 c->conf->nodename, (const char *)rsi, 551 c->conf->nodename, (const char *)rsi,
395 conns[dst - 1]->conf->nodename); 552 conns[dst - 1]->conf->nodename);
396 } 553 }
397 else 554 else
398 c->recv_vpn_packet (pkt, rsi); 555 c->recv_vpn_packet (pkt, rsi);
… …
402bool 559bool
403vpn::send_vpn_packet (vpn_packet *pkt, const sockinfo &si, int tos) 560vpn::send_vpn_packet (vpn_packet *pkt, const sockinfo &si, int tos)
404{ 561{
405 switch (si.prot) 562 switch (si.prot)
406 { 563 {
564#if 1//D2
565 case PROT_IPv42:
566 return send_ipv42_packet (pkt, si, tos);
567#endif
568
407 case PROT_IPv4: 569 case PROT_IPv4:
408 return send_ipv4_packet (pkt, si, tos); 570 return send_ipv4_packet (pkt, si, tos);
571
409 case PROT_UDPv4: 572 case PROT_UDPv4:
410 return send_udpv4_packet (pkt, si, tos); 573 return send_udpv4_packet (pkt, si, tos);
574
411#if ENABLE_TCP 575#if ENABLE_TCP
412 case PROT_TCPv4: 576 case PROT_TCPv4:
413 return send_tcpv4_packet (pkt, si, tos); 577 return send_tcpv4_packet (pkt, si, tos);
414#endif 578#endif
415#if ENABLE_ICMP 579#if ENABLE_ICMP
416 case PROT_ICMPv4: 580 case PROT_ICMPv4:
… …
418#endif 582#endif
419#if ENABLE_DNS 583#if ENABLE_DNS
420 case PROT_DNSv4: 584 case PROT_DNSv4:
421 return send_dnsv4_packet (pkt, si, tos); 585 return send_dnsv4_packet (pkt, si, tos);
422#endif 586#endif
423
424 default: 587 default:
425 slog (L_CRIT, _("%s: FATAL: trying to send packet with unsupported protocol"), (const char *)si); 588 slog (L_CRIT, _("%s: FATAL: trying to send packet with unsupported protocol."), (const char *)si);
426 } 589 }
427 590
428 return false; 591 return false;
429} 592}
430 593
431void 594#if 1//D2
595inline void
432vpn::ipv4_ev (io_watcher &w, short revents) 596vpn::ipv42_ev (ev::io &w, int revents)
433{ 597{
434 if (revents & EVENT_READ) 598 if (revents & EV_READ)
435 { 599 {
436 vpn_packet *pkt = new vpn_packet; 600 vpn_packet *pkt = new vpn_packet;
437 struct sockaddr_in sa; 601 struct sockaddr_in sa;
438 socklen_t sa_len = sizeof (sa); 602 socklen_t sa_len = sizeof (sa);
439 int len; 603 int len;
440 604
441 len = recvfrom (w.fd, &((*pkt)[0]), MAXSIZE, 0, (sockaddr *)&sa, &sa_len); 605 len = recvfrom (w.fd, &((*pkt)[0]), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
442 606
443 sockinfo si(sa, PROT_IPv4); 607 sockinfo si(sa, PROT_IPv42);
444 608
445 if (len > 0) 609 if (len > 0)
446 { 610 {
447 pkt->len = len; 611 pkt->len = len;
448 612
449 // raw sockets deliver the ipv4 header, but don't expect it on sends 613 // raw sockets deliver the ipv4 header, but don't expect it on sends
450 pkt->skip_hdr (IP_OVERHEAD); 614 pkt->skip_hdr (pkt->ipv4_hdr_len ());
451 615
452 recv_vpn_packet (pkt, si); 616 recv_vpn_packet (pkt, si);
453 } 617 }
454 else 618 else
455 { 619 {
456 // probably ECONNRESET or somesuch 620 // probably ECONNRESET or somesuch
457 slog (L_DEBUG, _("%s: %s"), (const char *)si, strerror (errno)); 621 slog (L_DEBUG, _("%s: %s."), (const char *)si, strerror (errno));
458 } 622 }
459 623
460 delete pkt; 624 delete pkt;
461 } 625 }
462 else 626 else
463 { 627 {
464 slog (L_ERR, 628 slog (L_ERR,
465 _("FATAL: unknown revents %08x in socket, terminating\n"), 629 _("FATAL: unknown revents %08x in socket, exiting.\n"),
466 revents); 630 revents);
467 exit (EXIT_FAILURE); 631 exit (EXIT_FAILURE);
468 } 632 }
469} 633}
634#endif
635
636inline void
637vpn::ipv4_ev (ev::io &w, int revents)
638{
639 if (revents & EV_READ)
640 {
641 vpn_packet *pkt = new vpn_packet;
642 struct sockaddr_in sa;
643 socklen_t sa_len = sizeof (sa);
644 int len;
645
646 len = recvfrom (w.fd, &((*pkt)[0]), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
647
648 sockinfo si(sa, PROT_IPv4);
649
650 if (len > 0)
651 {
652 pkt->len = len;
653
654 // raw sockets deliver the ipv4 header, but don't expect it on sends
655 pkt->skip_hdr (pkt->ipv4_hdr_len ());
656
657 recv_vpn_packet (pkt, si);
658 }
659 else
660 {
661 // probably ECONNRESET or somesuch
662 slog (L_DEBUG, _("%s: %s."), (const char *)si, strerror (errno));
663 }
664
665 delete pkt;
666 }
667 else
668 {
669 slog (L_ERR,
670 _("FATAL: unknown revents %08x in socket, exiting.\n"),
671 revents);
672 exit (EXIT_FAILURE);
673 }
674}
470 675
471#if ENABLE_ICMP 676#if ENABLE_ICMP
472void 677inline void
473vpn::icmpv4_ev (io_watcher &w, short revents) 678vpn::icmpv4_ev (ev::io &w, int revents)
474{ 679{
475 if (revents & EVENT_READ) 680 if (revents & EV_READ)
476 { 681 {
477 vpn_packet *pkt = new vpn_packet; 682 vpn_packet *pkt = new vpn_packet;
478 struct sockaddr_in sa; 683 struct sockaddr_in sa;
479 socklen_t sa_len = sizeof (sa); 684 socklen_t sa_len = sizeof (sa);
480 int len; 685 int len;
… …
492 if (hdr->type == ::conf.icmp_type 697 if (hdr->type == ::conf.icmp_type
493 && hdr->code == 255) 698 && hdr->code == 255)
494 { 699 {
495 // raw sockets deliver the ipv4, but don't expect it on sends 700 // raw sockets deliver the ipv4, but don't expect it on sends
496 // this is slow, but... 701 // this is slow, but...
497 pkt->skip_hdr (ICMP_OVERHEAD); 702 pkt->skip_hdr (pkt->ipv4_hdr_len () + (ICMP_OVERHEAD - IP_OVERHEAD));
498 703
499 recv_vpn_packet (pkt, si); 704 recv_vpn_packet (pkt, si);
500 } 705 }
501 } 706 }
502 else 707 else
503 { 708 {
504 // probably ECONNRESET or somesuch 709 // probably ECONNRESET or somesuch
505 slog (L_DEBUG, _("%s: %s"), (const char *)si, strerror (errno)); 710 slog (L_DEBUG, _("%s: %s."), (const char *)si, strerror (errno));
506 } 711 }
507 712
508 delete pkt; 713 delete pkt;
509 } 714 }
510 else 715 else
511 { 716 {
512 slog (L_ERR, 717 slog (L_ERR,
513 _("FATAL: unknown revents %08x in socket, terminating\n"), 718 _("FATAL: unknown revents %08x in socket, exiting.\n"),
514 revents); 719 revents);
515 exit (EXIT_FAILURE); 720 exit (EXIT_FAILURE);
516 } 721 }
517} 722}
518#endif 723#endif
519 724
520void 725inline void
521vpn::udpv4_ev (io_watcher &w, short revents) 726vpn::udpv4_ev (ev::io &w, int revents)
522{ 727{
523 if (revents & EVENT_READ) 728 if (revents & EV_READ)
524 { 729 {
525 vpn_packet *pkt = new vpn_packet; 730 vpn_packet *pkt = new vpn_packet;
526 struct sockaddr_in sa; 731 struct sockaddr_in sa;
527 socklen_t sa_len = sizeof (sa); 732 socklen_t sa_len = sizeof (sa);
528 int len; 733 int len;
… …
538 recv_vpn_packet (pkt, si); 743 recv_vpn_packet (pkt, si);
539 } 744 }
540 else 745 else
541 { 746 {
542 // probably ECONNRESET or somesuch 747 // probably ECONNRESET or somesuch
543 slog (L_DEBUG, _("%s: fd %d, %s"), (const char *)si, w.fd, strerror (errno)); 748 slog (L_DEBUG, _("%s: fd %d, %s."), (const char *)si, w.fd, strerror (errno));
544 } 749 }
545 750
546 delete pkt; 751 delete pkt;
547 } 752 }
548 else 753 else
549 { 754 {
550 slog (L_ERR, 755 slog (L_ERR,
551 _("FATAL: unknown revents %08x in socket, terminating\n"), 756 _("FATAL: unknown revents %08x in socket, exiting.\n"),
552 revents); 757 revents);
553 exit (EXIT_FAILURE); 758 exit (EXIT_FAILURE);
554 } 759 }
555} 760}
556 761
557void 762inline void
558vpn::tap_ev (io_watcher &w, short revents) 763vpn::tap_ev (ev::io &w, int revents)
559{ 764{
560 if (revents & EVENT_READ) 765 if (revents & EV_READ)
561 { 766 {
562 /* process data */ 767 /* process data */
563 tap_packet *pkt; 768 tap_packet *pkt;
564 769
565 pkt = tap->recv (); 770 pkt = tap->recv ();
… …
594 } 799 }
595 else 800 else
596 abort (); 801 abort ();
597} 802}
598 803
599void 804inline void
600vpn::event_cb (time_watcher &w) 805vpn::event_cb (ev::timer &w, int)
601{ 806{
602 if (events) 807 if (events)
603 { 808 {
604 if (events & EVENT_SHUTDOWN) 809 if (events & EVENT_SHUTDOWN)
605 { 810 {
606 slog (L_INFO, _("preparing shutdown...")); 811 slog (L_INFO, _("preparing shutdown..."));
607 812
608 shutdown_all (); 813 shutdown_all ();
609 remove_pid (conf.pidfilename); 814 remove_pid (conf.pidfilename);
610 slog (L_INFO, _("terminating")); 815 slog (L_INFO, _("exiting."));
611 exit (EXIT_SUCCESS); 816 exit (EXIT_SUCCESS);
612 } 817 }
613 818
614 if (events & EVENT_RECONNECT) 819 if (events & EVENT_RECONNECT)
615 { 820 {
616 slog (L_INFO, _("forced reconnect")); 821 slog (L_INFO, _("forced reconnect."));
617 822
618 reconnect_all (); 823 reconnect_all ();
619 } 824 }
620 825
621 events = 0; 826 events = 0;
… …
637 842
638 conns.clear (); 843 conns.clear ();
639 844
640 connection_init (); 845 connection_init ();
641 846
642 for (configuration::node_vector::iterator i = conf.nodes.begin (); 847 for (configuration::node_vector::iterator i = conf.nodes.begin (); i != conf.nodes.end (); ++i)
643 i != conf.nodes.end (); ++i) 848 conns.push_back (new connection (this, *i));
644 { 849
645 connection *conn = new connection (this, *i); 850 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c)
646 conns.push_back (conn);
647 conn->establish_connection (); 851 (*c)->establish_connection ();
648 }
649} 852}
650 853
651connection *vpn::find_router () 854bool
855vpn::can_direct (conf_node *src, conf_node *dst) const
652{ 856{
653 u32 prio = 1; 857 return src != dst
858 && src->may_direct (dst)
859 && dst->may_direct (src)
860 && (((src->protocols & dst->protocols) && src->connectmode == conf_node::C_ALWAYS)
861 || (src->protocols & dst->connectable_protocols ()));
862}
863
864// only works for indirect and routed connections: find a router
865// from THISNODE to dst
866connection *
867vpn::find_router_for (const connection *dst)
868{
654 connection *router = 0; 869 connection *router = 0;
655 870
871 // first try to find a router with a direct connection, route there
872 // regardless of any other considerations.
873 {
874 u32 prio = 1;
875
876 for (conns_vector::iterator i = conns.begin (); i != conns.end (); ++i)
877 {
878 connection *c = *i;
879
880 if (c->conf->routerprio > prio
881 && c->conf != THISNODE
882 && can_direct (c->conf, dst->conf)
883 && c->ictx && c->octx)
884 {
885 prio = c->conf->routerprio;
886 router = c;
887 }
888 }
889 }
890
891 if (router)
892 return router;
893
894 // second try find the router with the highest priority, higher than ours
895 {
896 u32 prio = THISNODE->routerprio ? THISNODE->routerprio : 1;
897
898 for (conns_vector::iterator i = conns.begin (); i != conns.end (); ++i)
899 {
900 connection *c = *i;
901
902 if (c->conf->routerprio > prio
903 && c != dst
904 && c->conf != THISNODE
905 && c->ictx && c->octx)
906 {
907 prio = c->conf->routerprio;
908 router = c;
909 }
910 }
911 }
912
913 return router;
914}
915
916void
917vpn::connection_established (connection *c)
918{
656 for (conns_vector::iterator i = conns.begin (); i != conns.end (); ++i) 919 for (conns_vector::iterator i = conns.begin (); i != conns.end (); ++i)
657 { 920 {
658 connection *c = *i; 921 connection *o = *i;
659 922
660 if (c->conf->routerprio > prio 923 if (!o->is_direct
661 && c->connectmode == conf_node::C_ALWAYS // so we don't drop the connection if in use 924 && o->si.valid ()
662 && c->ictx && c->octx 925 && c->si != o->si
663 && c->conf != THISNODE) // redundant, since ictx==octx==0 always on thisnode 926 && c == find_router_for (o))
664 {
665 prio = c->conf->routerprio;
666 router = c;
667 } 927 {
928 slog (L_DEBUG, _("%s: can now route packets via %s, re-keying connection."),
929 o->conf->nodename, c->conf->nodename);
930 o->rekey ();
931 }
668 } 932 }
669
670 return router;
671} 933}
672 934
935void
673void vpn::send_connect_request (int id) 936vpn::send_connect_request (connection *c)
674{ 937{
675 connection *c = find_router (); 938 connection *r = find_router_for (c);
676 939
677 if (c) 940 if (r)
941 {
942 slog (L_TRACE, _("%s: no address known, sending mediated connection request via %s."),
943 c->conf->nodename, r->conf->nodename);
678 c->send_connect_request (id); 944 r->send_connect_request (c->conf->id);
945 }
679 else 946 else
680 // no router found, aggressively connect to all routers 947 slog (L_DEBUG, _("%s: no way to connect and no router found: unable to connect at this time."),
681 for (conns_vector::iterator i = conns.begin (); i != conns.end (); ++i) 948 c->conf->nodename);
682 if ((*i)->conf->routerprio && (*i)->conf != THISNODE)
683 (*i)->establish_connection ();
684} 949}
685 950
686void 951void
687connection::dump_status () 952connection::dump_status ()
688{ 953{
689 slog (L_NOTICE, _("node %s (id %d)"), conf->nodename, conf->id); 954 slog (L_NOTICE, _("node %s (id %d)"), conf->nodename, conf->id);
690 slog (L_NOTICE, _(" connectmode %d (%d) / sockaddr %s / minor %d"), 955 slog (L_NOTICE, _(" connectmode %d (%d) / sockaddr %s / minor %d"),
691 connectmode, conf->connectmode, (const char *)si, (int)prot_minor); 956 connectmode, conf->connectmode, (const char *)si, (int)prot_minor);
692 slog (L_NOTICE, _(" ictx/octx %08lx/%08lx / oseqno %d / retry_cnt %d"), 957 slog (L_NOTICE, _(" ictx/octx %08lx/%08lx / oseqno %d / retry_cnt %d"),
693 (long)ictx, (long)octx, (int)oseqno, (int)retry_cnt); 958 (long)ictx, (long)octx, (int)oseqno, (int)retry_cnt);
694 slog (L_NOTICE, _(" establish_conn %ld / rekey %ld / keepalive %ld"),
695 (long)(establish_connection.at), (long)(rekey.at), (long)(keepalive.at));
696} 959}
697 960
698void 961void
699vpn::dump_status () 962vpn::dump_status ()
700{ 963{
701 slog (L_NOTICE, _("BEGIN status dump (%ld)"), (long)NOW); 964 slog (L_NOTICE, _("BEGIN status dump (%ld)"), (long)ev_now ());
702 965
703 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c) 966 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c)
704 (*c)->dump_status (); 967 (*c)->dump_status ();
705 968
706 slog (L_NOTICE, _("END status dump")); 969 slog (L_NOTICE, _("END status dump"));
707} 970}
708 971
709vpn::vpn (void) 972vpn::vpn (void)
973{
710: event (this, &vpn::event_cb) 974 event .set<vpn, &vpn::event_cb > (this);
711, udpv4_ev_watcher (this, &vpn::udpv4_ev) 975 udpv4_ev_watcher .set<vpn, &vpn::udpv4_ev > (this);
712, ipv4_ev_watcher (this, &vpn::ipv4_ev) 976 ipv4_ev_watcher .set<vpn, &vpn::ipv4_ev > (this);
977#if 1//D2
978 ipv42_ev_watcher .set<vpn, &vpn::ipv42_ev > (this);
979#endif
713#if ENABLE_TCP 980#if ENABLE_TCP
714, tcpv4_ev_watcher (this, &vpn::tcpv4_ev) 981 tcpv4_ev_watcher .set<vpn, &vpn::tcpv4_ev > (this);
715#endif 982#endif
716#if ENABLE_ICMP 983#if ENABLE_ICMP
717, icmpv4_ev_watcher(this, &vpn::icmpv4_ev) 984 icmpv4_ev_watcher.set<vpn, &vpn::icmpv4_ev> (this);
718#endif 985#endif
719#if ENABLE_DNS 986#if ENABLE_DNS
720, dnsv4_ev_watcher (this, &vpn::dnsv4_ev) 987 dnsv4_ev_watcher .set<vpn, &vpn::dnsv4_ev > (this);
721#endif 988#endif
722, tap_ev_watcher (this, &vpn::tap_ev) 989 tap_ev_watcher .set<vpn, &vpn::tap_ev > (this);
723{
724} 990}
725 991
726vpn::~vpn () 992vpn::~vpn ()
727{ 993{
728} 994}

Diff Legend

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