[ViewVC] Diff of: cvs/gvpe/src/vpn.C

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

Diff Legend

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

Comparing gvpe/src/vpn.C (file contents): Revision 1.33 by pcg, Wed Mar 23 21:55:39 2005 UTC vs. Revision 1.69 by root, Sat Sep 5 17:40:22 2015 UTC

Diff Legend

Comparing gvpe/src/vpn.C (file contents):
Revision 1.33 by pcg, Wed Mar 23 21:55:39 2005 UTC vs.
Revision 1.69 by root, Sat Sep 5 17:40:22 2015 UTC