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

Comparing gvpe/src/vpn.C (file contents):
Revision 1.14 by pcg, Tue Oct 14 03:22:09 2003 UTC vs.
Revision 1.62 by root, Sat Dec 17 22:05:34 2011 UTC

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

Diff Legend

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

Comparing gvpe/src/vpn.C (file contents): Revision 1.14 by pcg, Tue Oct 14 03:22:09 2003 UTC vs. Revision 1.62 by root, Sat Dec 17 22:05:34 2011 UTC

Diff Legend

Comparing gvpe/src/vpn.C (file contents):
Revision 1.14 by pcg, Tue Oct 14 03:22:09 2003 UTC vs.
Revision 1.62 by root, Sat Dec 17 22:05:34 2011 UTC