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.23 by pcg, Thu Jan 29 18:55:10 2004 UTC vs.
Revision 1.47 by pcg, Thu Aug 7 17:54:27 2008 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-2004 Marc Lehmann <pcg@goof.com> 3 Copyright (C) 2003-2008 Marc Lehmann <gvpe@schmorp.de>
4 4
5 This file is part of GVPE.
6
5 This program is free software; you can redistribute it and/or modify 7 GVPE is free software; you can redistribute it and/or modify it
6 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
7 the Free Software Foundation; either version 2 of the License, or 9 Free Software Foundation; either version 3 of the License, or (at your
8 (at your option) any later version. 10 option) any later version.
9 11
10 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
11 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
13 GNU General Public License for more details. 15 Public License for more details.
14 16
15 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
16 along with this program; if not, write to the Free Software 18 with this program; if not, see <http://www.gnu.org/licenses/>.
17 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.
18*/ 30*/
19 31
20#include "config.h" 32#include "config.h"
21 33
22#include <list> 34#include <list>
… …
44 56
45vpn network; // THE vpn (bad design...) 57vpn network; // THE vpn (bad design...)
46 58
47///////////////////////////////////////////////////////////////////////////// 59/////////////////////////////////////////////////////////////////////////////
48 60
49const 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 ()
50{ 75{
51 // the tunnel device mtu should be the physical mtu - overhead 76 // the tunnel device mtu should be the physical mtu - overhead
52 // the tricky part is rounding to the cipher key blocksize 77 // the tricky part is rounding to the cipher key blocksize
53 int mtu = conf.mtu - ETH_OVERHEAD - VPE_OVERHEAD - MAX_OVERHEAD; 78 int mtu = conf.mtu - ETH_OVERHEAD - VPE_OVERHEAD - MAX_OVERHEAD;
54 mtu += ETH_OVERHEAD - 6 - 6; // now we have the data portion 79 mtu += ETH_OVERHEAD - 6 - 6; // now we have the data portion
55 mtu -= mtu % EVP_CIPHER_block_size (CIPHER); // round 80 mtu -= mtu % EVP_CIPHER_block_size (CIPHER); // round
56 mtu -= ETH_OVERHEAD - 6 - 6; // and get interface mtu again 81 mtu -= ETH_OVERHEAD - 6 - 6; // and get interface mtu again
57 82
58 char *env; 83 char *env;
59 asprintf (&env, "CONFBASE=%s", confbase); putenv (env); 84 asprintf (&env, "CONFBASE=%s", confbase); putenv (env);
60 asprintf (&env, "NODENAME=%s", THISNODE->nodename); putenv (env);
61 asprintf (&env, "NODEID=%d", THISNODE->id); putenv (env);
62 asprintf (&env, "IFNAME=%s", tap->interface ()); putenv (env); 85 asprintf (&env, "IFNAME=%s", tap->interface ()); putenv (env);
63 asprintf (&env, "IFTYPE=%s", IFTYPE); putenv (env); 86 asprintf (&env, "IFTYPE=%s", IFTYPE); putenv (env);
64 asprintf (&env, "IFSUBTYPE=%s", IFSUBTYPE); putenv (env); 87 asprintf (&env, "IFSUBTYPE=%s", IFSUBTYPE); putenv (env);
65 asprintf (&env, "MTU=%d", mtu); putenv (env); 88 asprintf (&env, "MTU=%d", mtu); putenv (env);
66 asprintf (&env, "MAC=%02x:%02x:%02x:%02x:%02x:%02x", 89 asprintf (&env, "NODES=%d", conns.size ()); putenv (env);
67 0xfe, 0xfd, 0x80, 0x00, THISNODE->id >> 8, 90 asprintf (&env, "NODEID=%d", THISNODE->id); putenv (env);
68 THISNODE->id & 0xff);
69 putenv (env);
70 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,
71 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;
72} 122}
73 123
74int 124int
75vpn::setup () 125vpn::setup ()
76{ 126{
127 ipv4_tos = -1;
77 ipv4_fd = -1; 128 ipv4_fd = -1;
78 129
79 if (THISNODE->protocols & PROT_IPv4 && ::conf.ip_proto) 130 if (THISNODE->protocols & PROT_IPv4 && ::conf.ip_proto)
80 { 131 {
81 ipv4_fd = socket (PF_INET, SOCK_RAW, ::conf.ip_proto); 132 ipv4_fd = socket (PF_INET, SOCK_RAW, ::conf.ip_proto);
82 133
83 if (ipv4_fd < 0) 134 if (ipv4_fd < 0)
84 return -1; 135 return -1;
85 136
86 fcntl (ipv4_fd, F_SETFL, O_NONBLOCK); 137 fcntl (ipv4_fd, F_SETFL, O_NONBLOCK);
138 fcntl (ipv4_fd, F_SETFD, FD_CLOEXEC);
87 139
88#if defined(SOL_IP) && defined(IP_MTU_DISCOVER) 140#if defined(SOL_IP) && defined(IP_MTU_DISCOVER)
89 // this I really consider a linux bug. I am neither connected 141 // this I really consider a linux bug. I am neither connected
90 // nor do I fragment myself. Linux still sets DF and doesn't 142 // nor do I fragment myself. Linux still sets DF and doesn't
91 // fragment for me sometimes. 143 // fragment for me sometimes.
… …
101 { 153 {
102 slog (L_ERR, _("can't bind ipv4 socket on %s: %s"), (const char *)si, strerror (errno)); 154 slog (L_ERR, _("can't bind ipv4 socket on %s: %s"), (const char *)si, strerror (errno));
103 exit (EXIT_FAILURE); 155 exit (EXIT_FAILURE);
104 } 156 }
105 157
106 ipv4_ev_watcher.start (ipv4_fd, EVENT_READ); 158 ipv4_ev_watcher.start (ipv4_fd, EV_READ);
107 } 159 }
108 160
161 udpv4_tos = -1;
109 udpv4_fd = -1; 162 udpv4_fd = -1;
110 163
111 if (THISNODE->protocols & PROT_UDPv4 && THISNODE->udp_port) 164 if (THISNODE->protocols & PROT_UDPv4 && THISNODE->udp_port)
112 { 165 {
113 udpv4_fd = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP); 166 udpv4_fd = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
114 167
115 if (udpv4_fd < 0) 168 if (udpv4_fd < 0)
116 return -1; 169 return -1;
117 170
118 fcntl (udpv4_fd, F_SETFL, O_NONBLOCK); 171 fcntl (udpv4_fd, F_SETFL, O_NONBLOCK);
172 fcntl (udpv4_fd, F_SETFD, FD_CLOEXEC);
119 173
120 // standard daemon practise... 174 // standard daemon practise...
121 { 175 {
122 int oval = 1; 176 int oval = 1;
123 setsockopt (udpv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval); 177 setsockopt (udpv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval);
… …
139 { 193 {
140 slog (L_ERR, _("can't bind udpv4 on %s: %s"), (const char *)si, strerror (errno)); 194 slog (L_ERR, _("can't bind udpv4 on %s: %s"), (const char *)si, strerror (errno));
141 exit (EXIT_FAILURE); 195 exit (EXIT_FAILURE);
142 } 196 }
143 197
144 udpv4_ev_watcher.start (udpv4_fd, EVENT_READ); 198 udpv4_ev_watcher.start (udpv4_fd, EV_READ);
145 } 199 }
146 200
201 icmpv4_tos = -1;
147 icmpv4_fd = -1; 202 icmpv4_fd = -1;
148 203
149#if ENABLE_ICMP 204#if ENABLE_ICMP
150 if (THISNODE->protocols & PROT_ICMPv4) 205 if (THISNODE->protocols & PROT_ICMPv4)
151 { 206 {
152 icmpv4_fd = socket (PF_INET, SOCK_RAW, IPPROTO_ICMP); 207 icmpv4_fd = socket (PF_INET, SOCK_RAW, IPPROTO_ICMP);
153 208
154 if (icmpv4_fd < 0) 209 if (icmpv4_fd < 0)
155 return -1; 210 return -1;
156 211
157 fcntl (icmpv4_fd, F_SETFL, O_NONBLOCK); 212 fcntl (icmpv4_fd, F_SETFL, O_NONBLOCK);
213 fcntl (icmpv4_fd, F_SETFD, FD_CLOEXEC);
158 214
159#ifdef ICMP_FILTER 215#ifdef ICMP_FILTER
160 { 216 {
161 icmp_filter oval; 217 icmp_filter oval;
162 oval.data = 0xffffffff; 218 oval.data = 0xffffffff;
… …
171 // this I really consider a linux bug. I am neither connected 227 // this I really consider a linux bug. I am neither connected
172 // nor do I fragment myself. Linux still sets DF and doesn't 228 // nor do I fragment myself. Linux still sets DF and doesn't
173 // fragment for me sometimes. 229 // fragment for me sometimes.
174 { 230 {
175 int oval = IP_PMTUDISC_DONT; 231 int oval = IP_PMTUDISC_DONT;
176 setsockopt (udpv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval); 232 setsockopt (icmpv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval);
177 } 233 }
178#endif 234#endif
179 235
180 sockinfo si (THISNODE, PROT_ICMPv4); 236 sockinfo si (THISNODE, PROT_ICMPv4);
181 237
… …
183 { 239 {
184 slog (L_ERR, _("can't bind icmpv4 on %s: %s"), (const char *)si, strerror (errno)); 240 slog (L_ERR, _("can't bind icmpv4 on %s: %s"), (const char *)si, strerror (errno));
185 exit (EXIT_FAILURE); 241 exit (EXIT_FAILURE);
186 } 242 }
187 243
188 icmpv4_ev_watcher.start (icmpv4_fd, EVENT_READ); 244 icmpv4_ev_watcher.start (icmpv4_fd, EV_READ);
189 } 245 }
190#endif 246#endif
191 247
192 tcpv4_fd = -1; 248 tcpv4_fd = -1;
193 249
… …
198 254
199 if (tcpv4_fd < 0) 255 if (tcpv4_fd < 0)
200 return -1; 256 return -1;
201 257
202 fcntl (tcpv4_fd, F_SETFL, O_NONBLOCK); 258 fcntl (tcpv4_fd, F_SETFL, O_NONBLOCK);
259 fcntl (tcpv4_fd, F_SETFD, FD_CLOEXEC);
203 260
204 // standard daemon practise... 261 // standard daemon practise...
205 { 262 {
206 int oval = 1; 263 int oval = 1;
207 setsockopt (tcpv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval); 264 setsockopt (tcpv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval);
… …
219 { 276 {
220 slog (L_ERR, _("can't listen tcpv4 on %s: %s"), (const char *)si, strerror (errno)); 277 slog (L_ERR, _("can't listen tcpv4 on %s: %s"), (const char *)si, strerror (errno));
221 exit (EXIT_FAILURE); 278 exit (EXIT_FAILURE);
222 } 279 }
223 280
224 tcpv4_ev_watcher.start (tcpv4_fd, EVENT_READ); 281 tcpv4_ev_watcher.start (tcpv4_fd, EV_READ);
282 }
283#endif
284
285 dnsv4_tos = -1;
286 dnsv4_fd = -1;
287
288#if ENABLE_DNS
289 if (THISNODE->protocols & PROT_DNSv4)
290 {
291 dns_forwarder.set (::conf.dns_forw_host, ::conf.dns_forw_port, PROT_DNSv4);
292
293 dnsv4_fd = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
294
295 if (dnsv4_fd < 0)
296 return -1;
297
298 fcntl (dnsv4_fd, F_SETFL, O_NONBLOCK);
299 fcntl (dnsv4_fd, F_SETFD, FD_CLOEXEC);
300
301# if defined(SOL_IP) && defined(IP_MTU_DISCOVER)
302 // this I really consider a linux bug. I am neither connected
303 // nor do I fragment myself. Linux still sets DF and doesn't
304 // fragment for me sometimes.
305 {
306 int oval = IP_PMTUDISC_DONT;
307 setsockopt (dnsv4_fd, SOL_IP, IP_MTU_DISCOVER, &oval, sizeof oval);
225 } 308 }
226#endif 309# endif
310
311 // standard daemon practise...
312 {
313 int oval = 1;
314 setsockopt (dnsv4_fd, SOL_SOCKET, SO_REUSEADDR, &oval, sizeof oval);
315 }
316
317 sockinfo si (THISNODE->dns_hostname,
318 THISNODE->dns_hostname ? THISNODE->dns_port : 0,
319 PROT_DNSv4);
320
321 if (bind (dnsv4_fd, si.sav4 (), si.salenv4 ()))
322 {
323 slog (L_ERR, _("can't bind dnsv4 on %s: %s"), (const char *)si, strerror (errno));
324 exit (EXIT_FAILURE);
325 }
326
327 dnsv4_ev_watcher.start (dnsv4_fd, EV_READ);
328 }
329#endif
330
331 /////////////////////////////////////////////////////////////////////////////
332
333 reconnect_all ();
334
335 /////////////////////////////////////////////////////////////////////////////
227 336
228 tap = new tap_device (); 337 tap = new tap_device ();
229 if (!tap) //D this, of course, never catches 338 if (!tap) //D this, of course, never catches
230 { 339 {
231 slog (L_ERR, _("cannot create network interface '%s'"), conf.ifname); 340 slog (L_ERR, _("cannot create network interface '%s'"), conf.ifname);
232 exit (EXIT_FAILURE); 341 exit (EXIT_FAILURE);
233 } 342 }
234 343
235 run_script (run_script_cb (this, &vpn::script_if_up), true); 344 fcntl (tap->fd, F_SETFD, FD_CLOEXEC);
236 345
346 run_script_cb cb;
347 cb.set<vpn, &vpn::script_if_init> (this);
348
349 if (tap->if_up () &&
350 !run_script (cb, true))
351 {
352 slog (L_ERR, _("interface initialization command '%s' failed, exiting."),
353 tap->if_up ());
354 exit (EXIT_FAILURE);
355 }
356
357 cb.set<vpn, &vpn::script_if_up> (this);
358 if (!run_script (cb, true))
359 {
360 slog (L_ERR, _("if-up command execution failed, exiting."));
361 exit (EXIT_FAILURE);
362 }
363
237 tap_ev_watcher.start (tap->fd, EVENT_READ); 364 tap_ev_watcher.start (tap->fd, EV_READ);
238
239 reconnect_all ();
240 365
241 return 0; 366 return 0;
242}
243
244// send a vpn packet out to other hosts
245bool
246vpn::send_vpn_packet (vpn_packet *pkt, const sockinfo &si, int tos)
247{
248 switch (si.prot)
249 {
250 case PROT_IPv4:
251 return send_ipv4_packet (pkt, si, tos);
252
253 case PROT_UDPv4:
254 return send_udpv4_packet (pkt, si, tos);
255
256#if ENABLE_TCP
257 case PROT_TCPv4:
258 return send_tcpv4_packet (pkt, si, tos);
259#endif
260
261#if ENABLE_ICMP
262 case PROT_ICMPv4:
263 return send_icmpv4_packet (pkt, si, tos);
264#endif
265
266 default:
267 slog (L_CRIT, _("%s: FATAL: trying to send packet with unsupported protocol"), (const char *)si);
268 return false;
269 }
270} 367}
271 368
272bool 369bool
273vpn::send_ipv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 370vpn::send_ipv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
274{ 371{
275#if defined(SOL_IP) && defined(IP_TOS) 372 set_tos (ipv4_fd, ipv4_tos, tos);
276 setsockopt (ipv4_fd, SOL_IP, IP_TOS, &tos, sizeof tos);
277#endif
278 sendto (ipv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ()); 373 sendto (ipv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ());
279 374
280 return true; 375 return true;
281} 376}
282 377
… …
305 400
306#if ENABLE_ICMP 401#if ENABLE_ICMP
307bool 402bool
308vpn::send_icmpv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 403vpn::send_icmpv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
309{ 404{
310#if defined(SOL_IP) && defined(IP_TOS)
311 setsockopt (icmpv4_fd, SOL_IP, IP_TOS, &tos, sizeof tos);
312#endif
313
314 pkt->unshift_hdr (4); 405 pkt->unshift_hdr (4);
315 406
316 icmp_header *hdr = (icmp_header *)&((*pkt)[0]); 407 icmp_header *hdr = (icmp_header *)&((*pkt)[0]);
317 hdr->type = ::conf.icmp_type; 408 hdr->type = ::conf.icmp_type;
318 hdr->code = 255; 409 hdr->code = 255;
319 hdr->checksum = 0; 410 hdr->checksum = 0;
320 hdr->checksum = ipv4_checksum ((u16 *)hdr, pkt->len); 411 hdr->checksum = ipv4_checksum ((u16 *)hdr, pkt->len);
321 412
413 set_tos (icmpv4_fd, icmpv4_tos, tos);
322 sendto (icmpv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ()); 414 sendto (icmpv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ());
323 415
324 return true; 416 return true;
325} 417}
326#endif 418#endif
327 419
328bool 420bool
329vpn::send_udpv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 421vpn::send_udpv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
330{ 422{
331#if defined(SOL_IP) && defined(IP_TOS) 423 set_tos (udpv4_fd, udpv4_tos, tos);
332 setsockopt (udpv4_fd, SOL_IP, IP_TOS, &tos, sizeof tos);
333#endif
334 sendto (udpv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ()); 424 sendto (udpv4_fd, &((*pkt)[0]), pkt->len, 0, si.sav4 (), si.salenv4 ());
335 425
336 return true; 426 return true;
337} 427}
338 428
… …
349 { 439 {
350 // broadcast, this is ugly, but due to the security policy 440 // broadcast, this is ugly, but due to the security policy
351 // we have to connect to all hosts... 441 // we have to connect to all hosts...
352 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c) 442 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c)
353 if ((*c)->conf != THISNODE) 443 if ((*c)->conf != THISNODE)
354 (*c)->inject_data_packet (pkt, true); 444 (*c)->inject_data_packet (pkt);
355 } 445 }
356} 446}
357 447
358void 448void
359vpn::recv_vpn_packet (vpn_packet *pkt, const sockinfo &rsi) 449vpn::recv_vpn_packet (vpn_packet *pkt, const sockinfo &rsi)
… …
393 else 483 else
394 c->recv_vpn_packet (pkt, rsi); 484 c->recv_vpn_packet (pkt, rsi);
395 } 485 }
396} 486}
397 487
398void 488bool
489vpn::send_vpn_packet (vpn_packet *pkt, const sockinfo &si, int tos)
490{
491 switch (si.prot)
492 {
493 case PROT_IPv4:
494 return send_ipv4_packet (pkt, si, tos);
495
496 case PROT_UDPv4:
497 return send_udpv4_packet (pkt, si, tos);
498
499#if ENABLE_TCP
500 case PROT_TCPv4:
501 return send_tcpv4_packet (pkt, si, tos);
502#endif
503#if ENABLE_ICMP
504 case PROT_ICMPv4:
505 return send_icmpv4_packet (pkt, si, tos);
506#endif
507#if ENABLE_DNS
508 case PROT_DNSv4:
509 return send_dnsv4_packet (pkt, si, tos);
510#endif
511 default:
512 slog (L_CRIT, _("%s: FATAL: trying to send packet with unsupported protocol"), (const char *)si);
513 }
514
515 return false;
516}
517
518inline void
399vpn::ipv4_ev (io_watcher &w, short revents) 519vpn::ipv4_ev (ev::io &w, int revents)
400{ 520{
401 if (revents & EVENT_READ) 521 if (revents & EV_READ)
402 { 522 {
403 vpn_packet *pkt = new vpn_packet; 523 vpn_packet *pkt = new vpn_packet;
404 struct sockaddr_in sa; 524 struct sockaddr_in sa;
405 socklen_t sa_len = sizeof (sa); 525 socklen_t sa_len = sizeof (sa);
406 int len; 526 int len;
… …
411 531
412 if (len > 0) 532 if (len > 0)
413 { 533 {
414 pkt->len = len; 534 pkt->len = len;
415 535
416 // raw sockets deliver the ipv4, but don't expect it on sends 536 // raw sockets deliver the ipv4 header, but don't expect it on sends
417 // this is slow, but...
418 pkt->skip_hdr (IP_OVERHEAD); 537 pkt->skip_hdr (IP_OVERHEAD);
419 538
420 recv_vpn_packet (pkt, si); 539 recv_vpn_packet (pkt, si);
421 } 540 }
422 else 541 else
… …
428 delete pkt; 547 delete pkt;
429 } 548 }
430 else 549 else
431 { 550 {
432 slog (L_ERR, 551 slog (L_ERR,
433 _("FATAL: unknown revents %08x in socket, terminating\n"), 552 _("FATAL: unknown revents %08x in socket, terminating\n"),
434 revents); 553 revents);
435 exit (EXIT_FAILURE); 554 exit (EXIT_FAILURE);
436 } 555 }
437} 556}
438 557
439#if ENABLE_ICMP 558#if ENABLE_ICMP
440void 559inline void
441vpn::icmpv4_ev (io_watcher &w, short revents) 560vpn::icmpv4_ev (ev::io &w, int revents)
442{ 561{
443 if (revents & EVENT_READ) 562 if (revents & EV_READ)
444 { 563 {
445 vpn_packet *pkt = new vpn_packet; 564 vpn_packet *pkt = new vpn_packet;
446 struct sockaddr_in sa; 565 struct sockaddr_in sa;
447 socklen_t sa_len = sizeof (sa); 566 socklen_t sa_len = sizeof (sa);
448 int len; 567 int len;
… …
483 exit (EXIT_FAILURE); 602 exit (EXIT_FAILURE);
484 } 603 }
485} 604}
486#endif 605#endif
487 606
488void 607inline void
489vpn::udpv4_ev (io_watcher &w, short revents) 608vpn::udpv4_ev (ev::io &w, int revents)
490{ 609{
491 if (revents & EVENT_READ) 610 if (revents & EV_READ)
492 { 611 {
493 vpn_packet *pkt = new vpn_packet; 612 vpn_packet *pkt = new vpn_packet;
494 struct sockaddr_in sa; 613 struct sockaddr_in sa;
495 socklen_t sa_len = sizeof (sa); 614 socklen_t sa_len = sizeof (sa);
496 int len; 615 int len;
… …
520 revents); 639 revents);
521 exit (EXIT_FAILURE); 640 exit (EXIT_FAILURE);
522 } 641 }
523} 642}
524 643
525void 644inline void
526vpn::tap_ev (io_watcher &w, short revents) 645vpn::tap_ev (ev::io &w, int revents)
527{ 646{
528 if (revents & EVENT_READ) 647 if (revents & EV_READ)
529 { 648 {
530 /* process data */ 649 /* process data */
531 tap_packet *pkt; 650 tap_packet *pkt;
532 651
533 pkt = tap->recv (); 652 pkt = tap->recv ();
… …
540 int dst = mac2id (pkt->dst); 659 int dst = mac2id (pkt->dst);
541 int src = mac2id (pkt->src); 660 int src = mac2id (pkt->src);
542 661
543 if (src != THISNODE->id) 662 if (src != THISNODE->id)
544 { 663 {
545 slog (L_ERR, _("FATAL: tap packet not originating on current node received, exiting.")); 664 slog (L_ERR, _("FATAL: tap packet not originating on current node received (if-up script not working properly?), exiting."));
546 exit (EXIT_FAILURE); 665 exit (EXIT_FAILURE);
547 } 666 }
548 667
549 if (dst == THISNODE->id) 668 if (dst == THISNODE->id)
550 { 669 {
… …
562 } 681 }
563 else 682 else
564 abort (); 683 abort ();
565} 684}
566 685
567void 686inline void
568vpn::event_cb (time_watcher &w) 687vpn::event_cb (ev::timer &w, int)
569{ 688{
570 if (events) 689 if (events)
571 { 690 {
572 if (events & EVENT_SHUTDOWN) 691 if (events & EVENT_SHUTDOWN)
573 { 692 {
574 slog (L_INFO, _("preparing shutdown...")); 693 slog (L_INFO, _("preparing shutdown..."));
575 694
576 shutdown_all (); 695 shutdown_all ();
577 remove_pid (pidfilename); 696 remove_pid (conf.pidfilename);
578 slog (L_INFO, _("terminating")); 697 slog (L_INFO, _("terminating"));
579 exit (EXIT_SUCCESS); 698 exit (EXIT_SUCCESS);
580 } 699 }
581 700
582 if (events & EVENT_RECONNECT) 701 if (events & EVENT_RECONNECT)
… …
608 connection_init (); 727 connection_init ();
609 728
610 for (configuration::node_vector::iterator i = conf.nodes.begin (); 729 for (configuration::node_vector::iterator i = conf.nodes.begin ();
611 i != conf.nodes.end (); ++i) 730 i != conf.nodes.end (); ++i)
612 { 731 {
613 connection *conn = new connection (this); 732 connection *conn = new connection (this, *i);
614
615 conn->conf = *i;
616 conns.push_back (conn); 733 conns.push_back (conn);
617
618 conn->establish_connection (); 734 conn->establish_connection ();
619 } 735 }
620} 736}
621 737
622connection *vpn::find_router () 738connection *vpn::find_router ()
… …
667} 783}
668 784
669void 785void
670vpn::dump_status () 786vpn::dump_status ()
671{ 787{
672 slog (L_NOTICE, _("BEGIN status dump (%ld)"), (long)NOW); 788 slog (L_NOTICE, _("BEGIN status dump (%ld)"), (long)ev_now ());
673 789
674 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c) 790 for (conns_vector::iterator c = conns.begin (); c != conns.end (); ++c)
675 (*c)->dump_status (); 791 (*c)->dump_status ();
676 792
677 slog (L_NOTICE, _("END status dump")); 793 slog (L_NOTICE, _("END status dump"));
678} 794}
679 795
680vpn::vpn (void) 796vpn::vpn (void)
797{
681: event (this, &vpn::event_cb) 798 event .set<vpn, &vpn::event_cb > (this);
682, udpv4_ev_watcher (this, &vpn::udpv4_ev) 799 udpv4_ev_watcher .set<vpn, &vpn::udpv4_ev > (this);
683, ipv4_ev_watcher (this, &vpn::ipv4_ev) 800 ipv4_ev_watcher .set<vpn, &vpn::ipv4_ev > (this);
684#if ENABLE_TCP 801#if ENABLE_TCP
685, tcpv4_ev_watcher (this, &vpn::tcpv4_ev) 802 tcpv4_ev_watcher .set<vpn, &vpn::tcpv4_ev > (this);
686#endif 803#endif
687#if ENABLE_ICMP 804#if ENABLE_ICMP
688, icmpv4_ev_watcher(this, &vpn::icmpv4_ev) 805 icmpv4_ev_watcher.set<vpn, &vpn::icmpv4_ev> (this);
689#endif 806#endif
690, tap_ev_watcher (this, &vpn::tap_ev) 807#if ENABLE_DNS
691{ 808 dnsv4_ev_watcher .set<vpn, &vpn::dnsv4_ev > (this);
809#endif
810 tap_ev_watcher .set<vpn, &vpn::tap_ev > (this);
692} 811}
693 812
694vpn::~vpn () 813vpn::~vpn ()
695{ 814{
696} 815}

Diff Legend

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