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

Comparing gvpe/src/vpn_tcp.C (file contents):
Revision 1.3 by pcg, Sun Apr 6 20:01:53 2003 UTC vs.
Revision 1.18 by pcg, Sat Nov 10 19:43:37 2007 UTC

…		…
1	/*	1	/*
2	vpn_tcp.C -- handle the tcp part of the protocol.	2	vpn_tcp.C -- handle the tcp part of the protocol.
		3	Copyright (C) 2003-2007 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
5	it under the terms of the GNU General Public License as published by	8	it under the terms of the GNU General Public License as published by
6	the Free Software Foundation; either version 2 of the License, or	9	the Free Software Foundation; either version 2 of the License, or
7	(at your option) any later version.	10	(at your 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,
10	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but 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
12	GNU General Public License for more details.	15	GNU General 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
15	along with this program; if not, write to the Free Software	18	along with gvpe; if not, write to the Free Software
16	Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	19	Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17	*/	20	*/
18		21
19	#include "config.h"	22	#include "config.h"
20		23
21	#if ENABLE_TCP	24	#if ENABLE_TCP
27		30
28	#include <cstring>	31	#include <cstring>
29		32
30	#include <sys/types.h>	33	#include <sys/types.h>
31	#include <sys/socket.h>	34	#include <sys/socket.h>
32	#include <sys/poll.h>
33	#include <sys/wait.h>	35	#include <sys/wait.h>
34	#include <netinet/in.h>
35	#include <sys/uio.h>	36	#include <sys/uio.h>
36	#include <arpa/inet.h>
37	#include <errno.h>	37	#include <errno.h>
38	#include <time.h>	38	#include <time.h>
39	#include <unistd.h>	39	#include <unistd.h>
		40	#include <fcntl.h>
40		41
41	#include <map>	42	#include <map>
42	#include <unistd.h>	43
43	#include <fcntl.h>	44	#include "netcompat.h"
44	#include <sys/poll.h>
45		45
46	#include "vpn.h"	46	#include "vpn.h"
		47
		48	#if ENABLE_HTTP_PROXY
		49	# include "conf.h"
		50	#endif
47		51
48	struct tcp_connection;	52	struct tcp_connection;
49		53
50	struct lt_sockinfo	54	struct lt_sockinfo
51	{	55	{
…		…
54	return a < b;	58	return a < b;
55	}	59	}
56	};	60	};
57		61
58	struct tcp_si_map : public map<const sockinfo , tcp_connection , lt_sockinfo> {	62	struct tcp_si_map : public map<const sockinfo , tcp_connection , lt_sockinfo> {
59	void cleaner_cb (time_watcher &w); time_watcher cleaner;	63	void cleaner_cb (ev::timer &w, int revents); ev::timer cleaner;
60		64
61	tcp_si_map ()	65	tcp_si_map ()
62	: cleaner(this, &tcp_si_map::cleaner_cb)	66	: cleaner(this, &tcp_si_map::cleaner_cb)
63	{	67	{
64	cleaner.start (0);	68	cleaner.start (300, 300);
65	}	69	}
		70
66	} tcp_si;	71	} tcp_si;
67		72
68	struct tcp_connection : io_watcher {	73	struct tcp_connection : ev::io {
69	tstamp last_activity;	74	tstamp last_activity;
70	const sockinfo si;	75	const sockinfo si;
71	vpn &v;	76	vpn &v;
72	bool active; // this connection has been actively established	77	bool active; // this connection has been actively established
73	enum { ERROR, IDLE, CONNECTING, ESTABLISHED } state;	78	enum { ERROR, IDLE, CONNECTING, CONNECTING_PROXY, ESTABLISHED } state;
74		79
75	vpn_packet *r_pkt;	80	vpn_packet *r_pkt;
76	u32 r_len, r_ofs;	81	u32 r_len, r_ofs;
77		82
78	vpn_packet *w_pkt;	83	vpn_packet *w_pkt;
79	u32 w_len, w_ofs;	84	u32 w_len, w_ofs;
80		85
		86	#if ENABLE_HTTP_PROXY
		87	char *proxy_req;
		88	int proxy_req_len;
		89	#endif
		90
81	void tcpv4_ev (io_watcher &w, short revents);	91	void tcpv4_ev (ev::io &w, int revents);
82		92
83	bool send_packet (vpn_packet *pkt, int tos);	93	bool send_packet (vpn_packet *pkt, int tos);
84	bool write_packet ();	94	bool write_packet ();
85		95
86	void error (); // abort conenction && cleanup	96	void error (); // abort conenction && cleanup
87		97
88	operator tcp_si_map::value_type()	98	operator tcp_si_map::value_type()
89	{	99	{
90	return tcp_si_map::value_type (&si, this);	100	return tcp_si_map::value_type (&si, this);
91	}	101	}
92		102
93	tcp_connection (int fd_, const sockinfo &si_, vpn &v_);	103	tcp_connection (int fd_, const sockinfo &si_, vpn &v_);
94	~tcp_connection ();	104	~tcp_connection ();
95	};	105	};
96		106
97	void tcp_si_map::cleaner_cb (time_watcher &w)	107	void tcp_si_map::cleaner_cb (ev::timer &w, int revents)
98	{	108	{
99	w.at = NOW + 600;
100	tstamp to = NOW - ::conf.keepalive - 30 - 60;	109	tstamp to = ev::ev_now () - ::conf.keepalive - 30 - 60;
101		110
102	for (iterator i = begin (); i != end(); )	111	for (iterator i = begin (); i != end(); )
103	if (i->second->last_activity >= to)	112	if (i->second->last_activity >= to)
104	++i;	113	++i;
105	else	114	else
…		…
108	i = begin ();	117	i = begin ();
109	}	118	}
110	}	119	}
111		120
112	void	121	void
113	vpn::tcpv4_ev (io_watcher &w, short revents)	122	vpn::tcpv4_ev (ev::io &w, int revents)
114	{	123	{
115	if (revents & (POLLIN \| POLLERR))	124	if (revents & EV_READ)
116	{	125	{
117	struct sockaddr_in sa;	126	struct sockaddr_in sa;
118	socklen_t sa_len = sizeof (sa);	127	socklen_t sa_len = sizeof (sa);
119	int len;	128	int len;
120		129
121	int fd = accept (w.fd, (sockaddr *)&sa, &sa_len);	130	int fd = accept (w.fd, (sockaddr *)&sa, &sa_len);
122		131
123	if (fd >= 0)	132	if (fd >= 0)
124	{	133	{
		134	fcntl (fd, F_SETFL, O_NONBLOCK);
		135	fcntl (fd, F_SETFD, FD_CLOEXEC);
		136
125	sockinfo si(sa, PROT_TCPv4);	137	sockinfo si(sa, PROT_TCPv4);
126		138
127	slog (L_DEBUG, _("%s: accepted tcp connection"), (const char *)si);//D	139	slog (L_DEBUG, _("%s: accepted tcp connection"), (const char *)si);//D
128
129	fcntl (fd, F_SETFL, O_NONBLOCK);
130		140
131	tcp_connection i = new tcp_connection (fd, si, this);	141	tcp_connection i = new tcp_connection (fd, si, this);
132	tcp_si.insert (*i);	142	tcp_si.insert (*i);
133	}	143	}
134	}	144	}
…		…
150	i = info->second;	160	i = info->second;
151		161
152	return i->send_packet (pkt, tos);	162	return i->send_packet (pkt, tos);
153	}	163	}
154		164
155	void tcp_connection::error ()
156	{
157	if (fd >= 0)
158	{
159	close (fd);
160	fd = -1;
161	}
162
163	delete r_pkt; r_pkt = 0;
164	delete w_pkt; w_pkt = 0;
165
166	stop ();
167	state = active ? IDLE : ERROR;
168	}
169
170	bool	165	bool
171	tcp_connection::write_packet ()	166	tcp_connection::write_packet ()
172	{	167	{
173	ssize_t len;	168	ssize_t len;
174		169
175	if (w_ofs < 2)	170	if (w_ofs < 2)
176	{	171	{
177	u16 plen = htons (w_pkt->len);	172	u16 plen = htons (w_pkt->len);
178		173
179	iovec vec[2];	174	iovec vec[2];
		175	//TODO: char* is the right type? hardly...
180	vec[0].iov_base = ((u8 *)&plen) + w_ofs;	176	vec[0].iov_base = (char )((u8 )&plen) + w_ofs;
181	vec[0].iov_len = 2 - w_ofs;	177	vec[0].iov_len = 2 - w_ofs;
182	vec[1].iov_base = &((*w_pkt)[0]);	178	vec[1].iov_base = (char )&((w_pkt)[0]);
183	vec[1].iov_len = w_len - 2;	179	vec[1].iov_len = w_len - 2;
184		180
185	len = writev (fd, vec, 2);	181	len = writev (fd, vec, 2);
186	}	182	}
187	else	183	else
…		…
202	return false;	198	return false;
203	}	199	}
204	}	200	}
205		201
206	void	202	void
207	tcp_connection::tcpv4_ev (io_watcher &w, short revents)	203	tcp_connection::tcpv4_ev (ev::io &w, int revents)
208	{	204	{
209	last_activity = NOW;	205	last_activity = ev::ev_now ();
210		206
211	if (revents & (POLLERR \| POLLHUP))	207	if (revents & EV_WRITE)
212	{
213	error ();
214	return;
215	}
216
217	if (revents & POLLOUT)
218	{	208	{
219	if (state == CONNECTING)	209	if (state == CONNECTING)
220	{	210	{
221	state = ESTABLISHED;	211	state = ESTABLISHED;
222	set (POLLIN);	212	set (EV_READ);
		213	#if ENABLE_HTTP_PROXY
		214	if (::conf.proxy_host && ::conf.proxy_port)
		215	{
		216	state = CONNECTING_PROXY;
		217
		218	if (write (fd, proxy_req, proxy_req_len) == 0)
		219	{
		220	error ();
		221	return;
		222	}
		223
		224	free (proxy_req); proxy_req = 0;
		225	}
		226	#endif
223	}	227	}
224	else if (state == ESTABLISHED)	228	else if (state == ESTABLISHED)
225	{	229	{
226	if (w_pkt)	230	if (w_pkt)
227	{	231	{
228	if (write_packet ())	232	if (write_packet ())
229	{	233	{
230	delete w_pkt; w_pkt = 0;	234	delete w_pkt; w_pkt = 0;
231		235
232	set (POLLIN);	236	set (EV_READ);
233	}	237	}
234	}	238	}
235	else	239	else
236	set (POLLIN);	240	set (EV_READ);
237	}	241	}
238	else	242	else
239	set (POLLIN);	243	set (EV_READ);
240	}
241
242	if (revents & POLLIN)
243	{	244	}
		245
		246	if (revents & EV_READ)
		247	{
		248	if (state == ESTABLISHED)
244	for (;;)	249	for (;;)
245	{	250	{
246	if (!r_pkt)	251	if (!r_pkt)
247	{	252	{
248	r_pkt = new vpn_packet;	253	r_pkt = new vpn_packet;
249	r_ofs = 0;	254	r_ofs = 0;
250	r_len = 2; // header	255	r_len = 2; // header
251	}	256	}
252		257
253	ssize_t len = read (fd, &((*r_pkt)[r_ofs < 2 ? r_ofs : r_ofs - 2]), r_len);	258	ssize_t len = read (fd, &((*r_pkt)[r_ofs < 2 ? r_ofs : r_ofs - 2]), r_len);
254		259
255	if (len > 0)	260	if (len > 0)
256	{	261	{
257	r_len -= len;	262	r_len -= len;
258	r_ofs += len;	263	r_ofs += len;
259		264
260	if (r_len == 0)	265	if (r_len == 0)
		266	{
		267	if (r_ofs == 2)
		268	{
		269	r_len = ntohs ((u16 )&((*r_pkt)[0]));
		270	r_pkt->len = r_len;
		271
		272	if (r_len > 0 && r_len < MAXSIZE)
		273	continue;
		274	}
		275	else
		276	{
		277	v.recv_vpn_packet (r_pkt, si);
		278	delete r_pkt;
		279	r_pkt = 0;
		280
		281	continue;
		282	}
		283	}
		284	else
		285	break;
		286	}
		287	else if (len < 0 && (errno == EINTR \|\| errno == EAGAIN))
		288	break;
		289
		290	// len == 0 <-> EOF
		291	error ();
		292	break;
		293	}
		294	#if ENABLE_HTTP_PROXY
		295	else if (state == CONNECTING_PROXY)
		296	{
		297	fcntl (fd, F_SETFL, 0);
		298	char r[1024];
		299	int i;
		300	bool emptyline = false;
		301
		302	// we do a blocking read of the response, to hell with it
		303	for (i = 0; i < 1023; i++)
		304	{
		305	int l = read (fd, &r[i], 1);
		306
		307	if (l <= 0)
261	{	308	{
262	if (r_ofs == 2)	309	error ();
263	{	310	return;
264	r_len = ntohs ((u16 )&((*r_pkt)[0]));
265	r_pkt->len = r_len;
266
267	if (r_len > 0 && r_len < MAXSIZE)
268	continue;
269	}	311	}
		312
		313	if (r[i] == '\012')
		314	{
		315	if (emptyline)
		316	break;
270	else	317	else
271	{
272	v.recv_vpn_packet (r_pkt, si);
273	delete r_pkt;
274	r_pkt = 0;
275
276	continue;	318	emptyline = true;
277	}	319	}
		320	else if (r[i] != '\015')
		321	emptyline = false;
		322	}
		323
		324	fcntl (fd, F_SETFL, O_NONBLOCK);
		325
		326	if (i < 12)
		327	{
		328	slog (L_ERR, _("(%s): unable to do proxy-forwarding, short response"),
		329	(const char *)si);
		330	error ();
		331	}
		332	else if (r[0] != 'H' \|\| r[1] != 'T' \|\| r[2] != 'T' \|\| r[3] != 'P' \|\| r[4] != '/'
		333	\|\| r[5] != '1' // http-major
		334	\|\| r[9] != '2') // response
		335	{
		336	slog (L_ERR, _("(%s): malformed or unexpected proxy response (%.12s)"),
		337	(const char *)si, r);
		338	error ();
		339	}
		340	else
		341	state = ESTABLISHED;
		342	}
		343	#endif
		344	}
		345	}
		346
		347	bool
		348	tcp_connection::send_packet (vpn_packet *pkt, int tos)
		349	{
		350	last_activity = ev::ev_now ();
		351
		352	if (state == IDLE)
		353	{
		354	// woaw, the first lost packet ;)
		355	fd = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
		356
		357	if (fd >= 0)
		358	{
		359	const sockinfo *csi = &si;
		360
		361	#if ENABLE_HTTP_PROXY
		362	sockinfo psi;
		363
		364	if (::conf.proxy_host && ::conf.proxy_port)
		365	{
		366	psi.set (::conf.proxy_host, ::conf.proxy_port, PROT_TCPv4);
		367
		368	if (psi.valid ())
		369	{
		370	csi = ψ
		371
		372	proxy_req_len = asprintf (&proxy_req,
		373	"CONNECT %s:%d HTTP/1.0\015\012"
		374	"%s%s%s" // optional proxy-auth
		375	"\015\012",
		376	si.ntoa (),
		377	ntohs (si.port),
		378	::conf.proxy_auth ? "Proxy-Authorization: Basic " : "",
		379	::conf.proxy_auth ? ::conf.proxy_auth : "",
		380	::conf.proxy_auth ? "\015\012" : "");
		381
278	}	382	}
279	else	383	else
280	break;	384	slog (L_ERR, _("unable to resolve http proxy hostname '%s', trying direct"),
		385	::conf.proxy_host);
		386	}
		387	#endif
281	}	388
282	else if (len < 0 && (errno == EINTR \|\| errno == EAGAIN))
283	break;
284
285	error ();
286	break;
287	}
288	}
289	}
290
291	bool
292	tcp_connection::send_packet (vpn_packet *pkt, int tos)
293	{
294	last_activity = NOW;
295
296	if (state == IDLE)
297	{
298	// woaw, the first lost packet ;)
299	fd = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
300
301	if (fd >= 0)
302	{
303	fcntl (fd, F_SETFL, O_NONBLOCK);	389	fcntl (fd, F_SETFL, O_NONBLOCK);
304		390
305	if (connect (fd, si.sav4 (), si.salenv4 ()) >= 0	391	if (connect (fd, csi->sav4 (), csi->salenv4 ()) >= 0
306	\|\| errno == EINPROGRESS)	392	\|\| errno == EINPROGRESS)
307	{	393	{
		394	fcntl (fd, F_SETFL, O_NONBLOCK);
		395	fcntl (fd, F_SETFD, FD_CLOEXEC);
		396
308	state = CONNECTING;	397	state = CONNECTING;
309	start (fd, POLLOUT);	398	start (fd, EV_WRITE);
310	}	399	}
311	else	400	else
312	close (fd);	401	close (fd);
313	}	402	}
314	}	403	}
…		…
318	// right thing to do, not using tcp is the right thing to do.	407	// right thing to do, not using tcp is the right thing to do.
319	if (!w_pkt)	408	if (!w_pkt)
320	{	409	{
321	// how this maps to the underlying tcp packets we don't know	410	// how this maps to the underlying tcp packets we don't know
322	// and we don't care. at least we tried ;)	411	// and we don't care. at least we tried ;)
		412	#if defined(SOL_IP) && defined(IP_TOS)
323	setsockopt (fd, SOL_IP, IP_TOS, &tos, sizeof tos);	413	setsockopt (fd, SOL_IP, IP_TOS, &tos, sizeof tos);
		414	#endif
324		415
325	w_pkt = pkt;	416	w_pkt = pkt;
326	w_ofs = 0;	417	w_ofs = 0;
327	w_len = pkt->len + 2; // length + size header	418	w_len = pkt->len + 2; // length + size header
328		419
…		…
331	else	422	else
332	{	423	{
333	w_pkt = new vpn_packet;	424	w_pkt = new vpn_packet;
334	w_pkt->set (*pkt);	425	w_pkt->set (*pkt);
335		426
336	set (POLLIN \| POLLOUT);	427	set (EV_READ \| EV_WRITE);
337	}	428	}
338	}	429	}
339	}	430	}
340		431
341	return state != ERROR;	432	return state != ERROR;
342	}	433	}
343		434
		435	void tcp_connection::error ()
		436	{
		437	stop ();
		438
		439	if (fd >= 0)
		440	{
		441	close (fd);
		442	fd = -1;
		443	}
		444
		445	delete r_pkt; r_pkt = 0;
		446	delete w_pkt; w_pkt = 0;
		447	#if ENABLE_HTTP_PROXY
		448	free (proxy_req); proxy_req = 0;
		449	#endif
		450
		451	state = active ? IDLE : ERROR;
		452	}
		453
344	tcp_connection::tcp_connection (int fd_, const sockinfo &si_, vpn &v_)	454	tcp_connection::tcp_connection (int fd_, const sockinfo &si_, vpn &v_)
345	: v(v_), si(si_), io_watcher(this, &tcp_connection::tcpv4_ev)	455	: v(v_), si(si_), ev::io(this, &tcp_connection::tcpv4_ev)
346	{	456	{
347	last_activity = NOW;	457	if (!tcp_si.cleaner.active)
		458	tcp_si.cleaner.start (0);
		459
		460	last_activity = ev::ev_now ();
348	r_pkt = 0;	461	r_pkt = 0;
349	w_pkt = 0;	462	w_pkt = 0;
350	fd = fd_;	463	fd = fd_;
		464	#if ENABLE_HTTP_PROXY
		465	proxy_req = 0;
		466	#endif
351		467
352	if (fd < 0)	468	if (fd < 0)
353	{	469	{
354	active = true;	470	active = true;
355	state = IDLE;	471	state = IDLE;
356	}	472	}
357	else	473	else
358	{	474	{
359	active = false;	475	active = false;
360	state = ESTABLISHED;	476	state = ESTABLISHED;
361	start (fd, POLLIN);	477	start (fd, EV_READ);
362	}	478	}
363	}	479	}
364		480
365	tcp_connection::~tcp_connection ()	481	tcp_connection::~tcp_connection ()
366	{	482	{

Diff Legend

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

Comparing gvpe/src/vpn_tcp.C (file contents): Revision 1.3 by pcg, Sun Apr 6 20:01:53 2003 UTC vs. Revision 1.18 by pcg, Sat Nov 10 19:43:37 2007 UTC

Diff Legend

Comparing gvpe/src/vpn_tcp.C (file contents):
Revision 1.3 by pcg, Sun Apr 6 20:01:53 2003 UTC vs.
Revision 1.18 by pcg, Sat Nov 10 19:43:37 2007 UTC