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

Diff Legend

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