[ViewVC] Diff of: cvs/deliantra/server/socket/lowlevel.C

Comparing deliantra/server/socket/lowlevel.C (file contents):
Revision 1.28 by root, Thu Dec 21 06:12:37 2006 UTC vs.
Revision 1.55 by root, Sun Jul 29 13:36:40 2007 UTC

…		…
1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3		3	*
		4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
4	Copyright (C) 1992 Frank Tore Johansen	5	* Copyright (©) 1992,2007 Frank Tore Johansen
5		6	*
6	This program is free software; you can redistribute it and/or modify	7	* Crossfire TRT is free software: you can redistribute it and/or modify
7	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
8	the Free Software Foundation; either version 2 of the License, or	9	* the Free Software Foundation, either version 3 of the License, or
9	(at your option) any later version.	10	* (at your option) any later version.
10		11	*
11	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,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.	15	* GNU General Public License for more details.
15		16	*
16	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
17	along with this program; if not, write to the Free Software	18	* along with this program. If not, see <http://www.gnu.org/licenses/>.
18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20	The author can be reached via e-mail to mark@pyramid.com
21	*/
22
23	/**
24	* \file
25	* Low-level socket-related functions.
26	*	19	*
27	* \date 2003-12-02	20	* The authors can be reached via e-mail to <crossfire@schmorp.de>
28	*
29	* Contains some base functions that both the client and server
30	* can use. As such, depending what we are being compiled for will
31	* determine what we can include. the client is designed have
32	* CFCLIENT defined as part of its compile flags.
33	*/	21	*/
34		22
35	using namespace std;	23	using namespace std;
36		24
37	#include <global.h>	25	#include <global.h>
38	#include <sproto.h>	26	#include <sproto.h>
39	#include <cstdarg>	27	#include <cstdarg>
40		28
41	#ifdef __linux__	29	#if HAVE_TCP_INFO
42	# include <sys/types.h>	30	# include <sys/types.h>
43	# include <sys/socket.h>	31	# include <sys/socket.h>
44	# include <netinet/in.h>	32	# include <netinet/in.h>
45	# include <netinet/tcp.h>	33	# include <netinet/tcp.h>
46	#endif	34	#endif
47		35
48	// use a really low timeout, as it doesn't cost any bandwidth, and you can	36	// disconnect a socket after this many seconds without an ack
49	// easily die in 20 seconds...
50	#define SOCKET_TIMEOUT1 10 * 1000	37	#define SOCKET_TIMEOUT 8.
51	#define SOCKET_TIMEOUT2 20 * 1000	38
		39	// force a packet when idle for more than this many seconds,
		40	// forcing an ack regularly.
		41	#define IDLE_PING 2.
52		42
53	void	43	void
54	client::flush ()	44	client::flush ()
55	{	45	{
56	#ifdef __linux__	46	if (destroyed ())
		47	return;
		48
		49	#if HAVE_TCP_INFO
57	// check time of last ack, and, if too old, kill connection	50	// check time of last ack, and, if too old, kill connection
58	struct tcp_info tcpi;
59	socklen_t len = sizeof (tcpi);	51	socklen_t len = sizeof (tcpi);
60		52
61	if (!getsockopt (fd, IPPROTO_TCP, TCP_INFO, &tcpi, &len) && len == sizeof (tcpi))	53	if (!getsockopt (fd, IPPROTO_TCP, TCP_INFO, &tcpi, &len) && len == sizeof (tcpi))
62	{	54	{
63	unsigned int diff = tcpi.tcpi_last_ack_recv - tcpi.tcpi_last_data_sent;	55	if (tcpi.tcpi_snd_mss)
		56	mss = tcpi.tcpi_snd_mss;
64		57
65	rtt = tcpi.tcpi_rtt;	58	#if 0
66	rttvar = tcpi.tcpi_rttvar;	59	fprintf (stderr, "uack %d ack %d lost %d ret %d fack %d sst %d cwnd %d mss %d pmtu %d advmss %d EXC %d\n",
		60	tcpi.tcpi_unacked,
		61	tcpi.tcpi_sacked,
		62	tcpi.tcpi_lost,
		63	tcpi.tcpi_retrans,
		64	tcpi.tcpi_fackets,
		65	tcpi.tcpi_snd_ssthresh, tcpi.tcpi_snd_cwnd, tcpi.tcpi_advmss, tcpi.tcpi_pmtu, tcpi.tcpi_advmss,
		66
		67	tcpi.tcpi_snd_cwnd - (tcpi.tcpi_unacked - tcpi.tcpi_sacked));
		68	#endif
67		69
68	if (tcpi.tcpi_unacked && SOCKET_TIMEOUT1 < diff && diff < 0x80000000UL // ack delayed for 20s	70	// do this only when player is active
69	&& SOCKET_TIMEOUT2 < tcpi.tcpi_last_data_sent) // no data sent for 10s	71	if (pl && pl->active
		72	&& tcpi.tcpi_last_ack_recv > int (SOCKET_TIMEOUT * 1000))
70	{	73	{
		74	send_msg (NDI_RED \| NDI_REPLY, "connection-timeout", "safety disconnect due to tcp/ip timeout (no packets received)");
		75	write_outputbuffer ();
		76
71	LOG (llevDebug, "Connection on fd %d closed due to ack timeout (%u/%u/%u)\n", fd,	77	LOG (llevDebug, "connection on fd %d closed due to ack timeout (%u/%u/%u)\n", fd,
72	(unsigned) tcpi.tcpi_last_ack_recv, (unsigned) tcpi.tcpi_last_data_sent, (unsigned) tcpi.tcpi_unacked);	78	(unsigned)tcpi.tcpi_last_ack_recv, (unsigned)tcpi.tcpi_last_data_sent, (unsigned)tcpi.tcpi_unacked);
73	destroy ();	79	destroy ();
74	}	80	}
75	}	81	}
76	#endif	82	#endif
77		83
80	*	86	*
81	* When the socket is clear to write, and we have backlogged data, this	87	* When the socket is clear to write, and we have backlogged data, this
82	* is called to write it out.	88	* is called to write it out.
83	*/	89	*/
84		90
85	if (!outputbuffer.len \|\| socket_ev.poll () & PE_W)	91	// write a nop to the socket at least every IDLE_NOP seconds.
		92	if (!outputbuffer.len)
		93	{
		94	if (last_send + IDLE_PING <= NOW && pl && pl->active)
		95	{
		96	// this is a bit ugly, but map1/map1a seem to be the only
		97	// nop'able commands and they are quite small.
		98	packet sl (mapmode == Map1Cmd ? "map1" : "map1a");
		99	send_packet (sl);
		100	}
		101	else
		102	return;
		103	}
		104
		105	if (socket_ev.poll () & PE_W)
86	return;	106	return;
87		107
		108	last_send = NOW;
88	write_outputbuffer ();	109	write_outputbuffer ();
89	}	110	}
90		111
91	void	112	void
92	client::write_outputbuffer ()	113	client::write_outputbuffer ()
…		…
102	/* wrap back to start of buffer */	123	/* wrap back to start of buffer */
103	if (outputbuffer.start == SOCKETBUFSIZE)	124	if (outputbuffer.start == SOCKETBUFSIZE)
104	outputbuffer.start = 0;	125	outputbuffer.start = 0;
105		126
106	outputbuffer.len -= res;	127	outputbuffer.len -= res;
107	#ifdef CS_LOGSTATS
108	cst_tot.obytes += res;
109	cst_lst.obytes += res;
110	#endif
111	}	128	}
112	else if (res == 0)	129	else if (res == 0)
113	{	130	{
114	LOG (llevError, "socket write failed, connection closed.\n");	131	LOG (llevError, "socket write failed, connection closed.\n");
115	destroy ();	132	destroy ();
…		…
153	if (inbuf_len >= 2 + pkt_len)	170	if (inbuf_len >= 2 + pkt_len)
154	return 2 + pkt_len;	171	return 2 + pkt_len;
155		172
156	if (inbuf_len == sizeof (inbuf))	173	if (inbuf_len == sizeof (inbuf))
157	{	174	{
158	send_packet_printf ("drawinfo %d input buffer overflow - closing connection.", NDI_RED);	175	send_packet_printf ("drawinfo %d input buffer overflow - closing connection.", NDI_RED \| NDI_REPLY);
159	destroy ();	176	destroy ();
160	return -1;	177	return -1;
161	}	178	}
162	}	179	}
163		180
…		…
182		199
183	/**	200	/**
184	* Dispatch table for the server.	201	* Dispatch table for the server.
185	*/	202	*/
186	static struct packet_type packets[] = {	203	static struct packet_type packets[] = {
187	{"ncom", PC(NewPlayerCmd) PF_PLAYING },	204	{"ncom", PC(NewPlayerCmd) PF_PLAYING \| PF_COMMAND6 },
188	{"command", PC(PlayerCmd) PF_PLAYING },	205	{"command", PC(PlayerCmd) PF_PLAYING \| PF_COMMAND0 },
189		206
190	{"examine", PC(ExamineCmd) PF_PLAYING },	207	{"examine", PC(ExamineCmd) PF_PLAYING },
		208	{"ex", PC(ExCmd) PF_PLAYING },
191	{"apply", PC(ApplyCmd) PF_PLAYING },	209	{"apply", PC(ApplyCmd) PF_PLAYING },
192	{"lookat", PC(LookAt) PF_PLAYING },	210	{"lookat", PC(LookAt) PF_PLAYING },
193	{"lock", PC(LockItem) PF_PLAYING },	211	{"lock", PC(LockItem) PF_PLAYING },
194	{"mark", PC(MarkItem) PF_PLAYING },	212	{"mark", PC(MarkItem) PF_PLAYING },
195	{"move", PC(MoveCmd) PF_PLAYING },	213	{"move", PC(MoveCmd) PF_PLAYING },
196	{"ext", PC(ExtCmd) 0 }, /* CF+ */	214	{"ext", PC(ExtCmd) 0 }, // CF+
197	{"mapredraw", PC(MapRedrawCmd) 0 }, /* Added: phil */	215	{"mapredraw", PC(MapRedrawCmd) 0 },
198	{"mapinfo", PC(MapInfoCmd) 0 }, /* CF+ */	216	{"mapinfo", PC(MapInfoCmd) 0 }, // CF+
199		217
200	{"reply", SC(ReplyCmd) 0 },	218	{"reply", SC(ReplyCmd) 0 },
201	{"exti", SC(ExtiCmd) 0 }, /* CF+ */	219	{"exti", SC(ExtiCmd) 0 }, // CF+
202	{"addme", SC(AddMeCmd) 0 },	220	{"addme", SC(AddMeCmd) 0 },
203	{"askface", SC(SendFaceCmd) 0 }, /* Added: phil */	221	{"askface", SC(AskFaceCmd) 0 },
204	{"requestinfo", SC(RequestInfo) 0 },	222	{"requestinfo", SC(RequestInfo) 0 },
205	{"setfacemode", SC(SetFaceMode) 0 },	223	{"setfacemode", SC(SetFaceMode) 0 },
206	{"setsound", SC(SetSound) 0 },	224	{"setsound", SC(SetSound) 0 },
207	{"setup", SC(SetUp) 0 },	225	{"setup", SC(SetUp) 0 },
208	{"version", SC(VersionCmd) 0 },	226	{"version", SC(VersionCmd) 0 },
…		…
213		231
214	bool	232	bool
215	client::may_execute (const packet_type *pkt) const	233	client::may_execute (const packet_type *pkt) const
216	{	234	{
217	return (!(pkt->flags & PF_PLAYER) \|\| pl)	235	return (!(pkt->flags & PF_PLAYER) \|\| pl)
218	&& (!(pkt->flags & PF_PLAYING) \|\| (pl && pl->state == ST_PLAYING));	236	&& (!(pkt->flags & PF_PLAYING) \|\| state == ST_PLAYING);
		237	}
		238
		239	// HACK: some commands currently should be executed
		240	// even when the player is frozen. this hack detects
		241	// those commands. it should be folded into may_execute,
		242	// but kept seperate to emphasise the hack aspect, i.e.
		243	// do it better, then remove.
		244	static bool
		245	always_immediate (const client ns, const packet_type pkt, const char *data, int len)
		246	{
		247	if (!(pkt->flags & (PF_COMMAND0 \| PF_COMMAND6)))
		248	return false;
		249
		250	if (!ns->pl \|\| !ns->pl->ob \|\| !ns->pl->ob->map)
		251	return false;
		252
		253	if (pkt->flags & PF_COMMAND6)
		254	{
		255	data += 6;
		256	len -= 6;
		257	}
		258
		259	if (len > 4 && !strncmp (data, "say " , 4))
		260	return true;
		261	if (len > 5 && !strncmp (data, "chat ", 5))
		262	return true;
		263
		264	return false;
219	}	265	}
220		266
221	void	267	void
222	client::execute (const packet_type pkt, char data, int datalen)	268	client::execute (const packet_type pkt, char data, int datalen)
223	{	269	{
224	if (may_execute (pkt))	270	if (may_execute (pkt) \|\| always_immediate (this, pkt, data, datalen))
225	{	271	{
226	//TODO: only one format	272	//TODO: only one format
227	if (pkt->flags & PF_PLAYER)	273	if (pkt->flags & PF_PLAYER)
228	((void ()(char , int, player ))pkt->cb)((char )data, datalen, pl);	274	((void ()(char , int, player ))pkt->cb)((char )data, datalen, pl);
229	else	275	else
230	((void ()(char , int, client ))pkt->cb)((char )data, datalen, this);	276	((void ()(char , int, client ))pkt->cb)((char )data, datalen, this);
231	}	277	}
232	else	278	else
233	send_packet_printf ("drawinfo %d ERROR: you cannot execute '%s' now.", NDI_RED, pkt->name);	279	send_packet_printf ("drawinfo %d ERROR: you cannot execute '%s' now.", NDI_RED \| NDI_REPLY, pkt->name);
234	}	280	}
235		281
236	bool	282	bool
237	client::handle_packet ()	283	client::handle_packet ()
238	{	284	{
…		…
270	}	316	}
271		317
272	for (packet_type *pkt = packets; pkt < packets + (sizeof (packets) / sizeof (packets[0])); ++pkt)	318	for (packet_type *pkt = packets; pkt < packets + (sizeof (packets) / sizeof (packets[0])); ++pkt)
273	if (!strcmp ((char *)inbuf + 2, pkt->name))	319	if (!strcmp ((char *)inbuf + 2, pkt->name))
274	{	320	{
275	if (pkt->flags & PF_PLAYER)	321	if (pkt->flags & PF_PLAYER && !always_immediate (this, pkt, data, datalen))
276	queue_command (pkt, data, datalen);	322	queue_command (pkt, data, datalen);
277	else	323	else
278	execute (pkt, data, datalen);	324	execute (pkt, data, datalen);
279		325
280	goto next_packet;	326	goto next_packet;
281	}	327	}
282		328
283	// If we get here, we didn't find a valid command.	329	// If we get here, we didn't find a valid command.
284	send_packet_printf ("drawinfo %d ERROR: command '%s' not supported.", NDI_RED, (char *)inbuf + 2);	330	send_packet_printf ("drawinfo %d ERROR: command '%s' not supported.", NDI_RED \| NDI_REPLY, (char *)inbuf + 2);
285	next_packet:	331	next_packet:
286	skip_packet (pkt_len);	332	skip_packet (pkt_len);
287		333
288	// input buffer has space again	334	// input buffer has space again
289	socket_ev.poll (socket_ev.poll () \| PE_R);	335	socket_ev.poll (socket_ev.poll () \| PE_R);
…		…
294	// callback called when socket is either readable or writable	340	// callback called when socket is either readable or writable
295	void	341	void
296	client::socket_cb (iow &w, int got)	342	client::socket_cb (iow &w, int got)
297	{	343	{
298	//TODO remove when we have better socket cleanup logic	344	//TODO remove when we have better socket cleanup logic
299	if (destroyed)	345	if (destroyed ())
300	{	346	{
301	socket_ev.poll (0);	347	socket_ev.poll (0);
302	return;	348	return;
303	}	349	}
304		350
…		…
343	}	389	}
344	else	390	else
345	{	391	{
346	inbuf_len += amount;	392	inbuf_len += amount;
347		393
348	cst_tot.ibytes += amount;
349	cst_lst.ibytes += amount;
350
351	cmd_ev.start ();	394	cmd_ev.start ();
352	}	395	}
353	}	396	}
354	}	397	}
355		398
…		…
377	*/	420	*/
378	void	421	void
379	client::send (void *buf_, int len)	422	client::send (void *buf_, int len)
380	{	423	{
381	char buf = (char )buf_;	424	char buf = (char )buf_;
382	char *pos = buf;
383	int amt = 0;
384		425
385	if (destroyed \|\| !buf)	426	if (destroyed () \|\| !buf)
386	return;	427	return;
387		428
388	if ((len + outputbuffer.len) > SOCKETBUFSIZE)	429	if (len + outputbuffer.len > SOCKETBUFSIZE)
389	{	430	{
390	LOG (llevDebug, "socket on fd %d has overrun internal buffer - marking as dead\n", fd);	431	LOG (llevDebug, "socket on fd %d has overrun internal buffer - marking as dead\n", fd);
391	destroy ();	432	// shutdown the socket, this is safer than destroying it immediately
		433	// as lots of code in the callchain might still access the map etc.
		434	shutdown (fd, SHUT_RDWR);
392	return;	435	return;
393	}	436	}
394		437
395	int avail, end;	438	int avail, end;
396		439
…		…
421	* shortcut function.	464	* shortcut function.
422	*/	465	*/
423	void	466	void
424	client::send_packet (packet &sl)	467	client::send_packet (packet &sl)
425	{	468	{
426	if (destroyed)	469	if (destroyed ())
427	return;	470	return;
428		471
429	if (sl.length () >= MAXSOCKBUF)	472	if (sl.length () > MAXSOCKBUF)
430	{	473	{
431	LOG (llevError, "Trying to send a buffer beyond properly size, len =%d\n", sl.length ());	474	LOG (llevError, "Trying to send a buffer beyond properly size, len =%d\n", sl.length ());
432	/* Almost certainly we've overflowed a buffer, so quit now to make	475	/* Almost certainly we've overflowed a buffer, so quit now to make
433	* it easier to debug.	476	* it easier to debug.
434	*/	477	*/
…		…
472	va_end (ap);	515	va_end (ap);
473		516
474	send_packet (sl);	517	send_packet (sl);
475	}	518	}
476		519
		520	// returns true when the message needs special (read: perl) treatment
		521	static bool
		522	msg_is_special (const char *msg)
		523	{
		524	return msg [strcspn (msg, "<[&\n")];
		525	}
		526
		527	void
		528	client::send_msg (int color, const char type, const char msg)
		529	{
		530	if (msg_is_special (msg))
		531	cfperl_send_msg (this, color, type, msg);
		532	else if (can_msg)
		533	send_packet_printf ("msg %d %s %s", color & NDI_CLIENT_MASK, type, msg);
		534	else if (color < 0)
		535	return; // client cannot handle this
		536	else
		537	send_packet_printf ("drawinfo %d %s", color & NDI_COLOR_MASK, msg);
		538	}
		539
		540	void
		541	client::send_drawinfo (const char *msg, int flags)
		542	{
		543	send_msg (flags, "log", msg);
		544	}
		545
477	/***********************************************************************	546	/***********************************************************************
478	*	547	*
479	* packet functions/utilities	548	* packet functions/utilities
480	*	549	*
481	**********************************************************************/	550	**********************************************************************/
…		…
487	int len = strlen (name);	556	int len = strlen (name);
488	memcpy (cur, name, len); cur += len;	557	memcpy (cur, name, len); cur += len;
489	*cur++ = ' ';	558	*cur++ = ' ';
490	}	559	}
491		560
		561	packet &packet::operator <<(const ber32 v)
		562	{
		563	enum { maxlen = 32 / 7 + 1};
		564	uint8 buf[maxlen];
		565	uint8 *p = buf + maxlen;
		566	uint32 val = v.val;
		567
		568	*--p = val & 0x7F;
		569
		570	while (val > 0x7F)
		571	{
		572	val >>= 7;
		573	*--p = (val & 0x7F) \| 0x80;
		574	}
		575
		576	return *this << data (p, buf + maxlen - p);
		577	}
		578
492	packet &packet::operator <<(const data &v)	579	packet &packet::operator <<(const data &v)
493	{	580	{
494	if (room () < v.len)	581	if (room () < v.len)
495	reset ();	582	reset ();
496	else	583	else
…		…
533	return reset ();	620	return reset ();
534		621
535	cur += len;	622	cur += len;
536	}	623	}
537		624
538	/******************************************************************************
539	*
540	* statistics logging functions.
541	*
542	******************************************************************************/
543
544	#ifdef CS_LOGSTATS
545
546	/* cst_tot is for the life of the server, cst_last is for the last series of
547	* stats
548	*/
549	CS_Stats cst_tot, cst_lst;
550
551	/**
552	* Writes out the gathered stats. We clear cst_lst.
553	*/
554	void
555	write_cs_stats (void)
556	{
557	time_t now = time (NULL);
558
559	/* If no connections recently, don't both to log anything */
560	if (cst_lst.ibytes == 0 && cst_lst.obytes == 0)
561	return;
562
563	/* CSSTAT is put in so scripts can easily find the line */
564	LOG (llevInfo, "CSSTAT: %.16s tot %d %d %d %d inc %d %d %d %d\n",
565	ctime (&now), cst_tot.ibytes, cst_tot.obytes, cst_tot.max_conn,
566	now - cst_tot.time_start, cst_lst.ibytes, cst_lst.obytes, cst_lst.max_conn, now - cst_lst.time_start);
567	cst_lst.ibytes = 0;
568	cst_lst.obytes = 0;
569	cst_lst.time_start = now;
570	}
571	#endif
572

Diff Legend

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

Comparing deliantra/server/socket/lowlevel.C (file contents): Revision 1.28 by root, Thu Dec 21 06:12:37 2006 UTC vs. Revision 1.55 by root, Sun Jul 29 13:36:40 2007 UTC

Diff Legend

Comparing deliantra/server/socket/lowlevel.C (file contents):
Revision 1.28 by root, Thu Dec 21 06:12:37 2006 UTC vs.
Revision 1.55 by root, Sun Jul 29 13:36:40 2007 UTC