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

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

Diff Legend

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

Comparing gvpe/src/vpn.C (file contents): Revision 1.17 by pcg, Wed Oct 15 06:06:41 2003 UTC vs. Revision 1.70 by root, Thu Oct 6 03:03:09 2022 UTC

Diff Legend

Comparing gvpe/src/vpn.C (file contents):
Revision 1.17 by pcg, Wed Oct 15 06:06:41 2003 UTC vs.
Revision 1.70 by root, Thu Oct 6 03:03:09 2022 UTC