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

Comparing deliantra/server/socket/loop.C (file contents):
Revision 1.16 by root, Thu Dec 14 22:45:41 2006 UTC vs.
Revision 1.63 by root, Sat Jul 28 00:15:03 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) 2002-2003 Mark Wedel & The Crossfire Development Team	5	* Copyright (©) 2002-2003,2007 Mark Wedel & The Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Crossfire TRT is free software: you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
10	(at your option) any later version.	11	* (at your option) any later version.
11		12	*
12	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	*
20
21	The author can be reached via e-mail to <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/	22	*/
23		23
24	/**	24	/**
25	* \file	25	* \file
26	* Main client/server loops.	26	* Main client/server loops.
27	*	27	*
28	* \date 2003-12-02	28	* \date 2003-12-02
29	*	29	*
30	* loop.c mainly deals with initialization and higher level socket	30	* loop.c mainly deals with initialization and higher level socket
31	* maintenance (checking for lost connections and if data has arrived.)	31	* maintanance (checking for lost connections and if data has arrived.)
32	* The reading of data is handled in ericserver.c
33	*/	32	*/
34
35		33
36	#include <global.h>	34	#include <global.h>
37	#include <sproto.h>	35	#include <sproto.h>
38	#include <sockproto.h>	36	#include <sockproto.h>
39		37
45		43
46	#include <unistd.h>	44	#include <unistd.h>
47	#include <arpa/inet.h>	45	#include <arpa/inet.h>
48		46
49	#include <loader.h>	47	#include <loader.h>
50	#include <newserver.h>
51		48
52	/*****************************************************************************	49	#define BG_SCRUB_RATE 4 // how often to send a face in the background
53	* Start of command dispatch area.
54	* The commands here are protocol commands.
55	****************************************************************************/
56		50
57	/* Either keep this near the start or end of the file so it is	51	#define MAX_QUEUE_DEPTH 500
58	* at least reasonablye easy to find.	52	#define MAX_QUEUE_BACKLOG 3.
59	* There are really 2 commands - those which are sent/received
60	* before player joins, and those happen after the player has joined.
61	* As such, we have function types that might be called, so
62	* we end up having 2 tables.
63	*/
64		53
65	typedef void (func_uint8_int_ns) (char , int, client_socket *);
66
67	struct NsCmdMapping
68	{
69	const char *cmdname;
70	func_uint8_int_ns cmdproc;
71	uint8 flag;
72	};
73
74	typedef void (func_uint8_int_pl) (char , int, player *);
75	struct PlCmdMapping
76	{
77	const char *cmdname;
78	func_uint8_int_pl cmdproc;
79	uint8 flag;
80	};
81
82	/**
83	* Dispatch table for the server.
84	*
85	* CmdMapping is the dispatch table for the server, used in HandleClient,
86	* which gets called when the client has input. All commands called here
87	* use the same parameter form (char* data, int len, int clientnum.
88	* We do implicit casts, because the data that is being passed is
89	* unsigned (pretty much needs to be for binary data), however, most
90	* of these treat it only as strings, so it makes things easier
91	* to cast it here instead of a bunch of times in the function itself.
92	* flag is 1 if the player must be in the playing state to issue the
93	* command, 0 if they can issue it at any time.
94	*/
95	static struct PlCmdMapping plcommands[] = {
96	{"examine", ExamineCmd, 1},
97	{"apply", ApplyCmd, 1},
98	{"move", MoveCmd, 1},
99	{"reply", ReplyCmd, 0},
100	{"command", PlayerCmd, 1},
101	{"ncom", (func_uint8_int_pl) NewPlayerCmd, 1},
102	{"lookat", LookAt, 1},
103	{"lock", (func_uint8_int_pl) LockItem, 1},
104	{"mark", (func_uint8_int_pl) MarkItem, 1},
105	{"mapredraw", MapRedrawCmd, 0}, /* Added: phil */
106	{"mapinfo", MapInfoCmd, 2}, /* CF+ */
107	{"ext", ExtCmd, 2}, /* CF+ */
108	{ 0 } /* terminator */
109	};
110
111	/** Face-related commands */
112	static struct NsCmdMapping nscommands[] = {
113	{"addme", AddMeCmd, 2},
114	{"askface", SendFaceCmd}, /* Added: phil */
115	{"requestinfo", RequestInfo},
116	{"setfacemode", SetFaceMode, 2},
117	{"setsound", SetSound, 2},
118	{"setup", SetUp, 2},
119	{"version", VersionCmd, 2},
120	{"toggleextendedinfos", ToggleExtendedInfos, 2}, /Added: tchize /
121	{"toggleextendedtext", ToggleExtendedText, 2}, /Added: tchize /
122	{"asksmooth", AskSmooth}, /Added: tchize (smoothing technologies) /
123	{ 0 } /* terminator (I, II & III) */
124	};
125
126	/**
127	* RequestInfo is sort of a meta command. There is some specific
128	* request of information, but we call other functions to provide
129	* that information.
130	*/
131	void	54	void
132	RequestInfo (char buf, int len, client_socket ns)	55	client::reset_state ()
133	{	56	{
134	char params = NULL, cp;	57	if (!pl)
		58	return;
135		59
136	/* No match */	60	pl->run_on = 0;
137	char bigbuf[MAX_BUF];	61	pl->fire_on = 0;
138	int slen;	62	}
139		63
140	/* Set up replyinfo before we modify any of the buffers - this is used	64	void
141	* if we don't find a match.	65	client::queue_command (packet_type handler, char data, int datalen)
142	*/	66	{
143	strcpy (bigbuf, "replyinfo ");	67	tstamp stamp = NOW;
144	slen = strlen (bigbuf);
145	safe_strcat (bigbuf, buf, &slen, MAX_BUF);
146		68
147	/* find the first space, make it null, and update the	69	if (cmd_queue.size () >= MAX_QUEUE_DEPTH)
148	* params pointer.
149	*/
150	for (cp = buf; *cp != '\0'; cp++)
151	if (*cp == ' ')
152	{	70	{
153	*cp = '\0';	71	//TODO: just disconnect here?
154	params = cp + 1;	72	reset_state ();
155	break;	73	send_packet_printf ("drawinfo %d command queue overflow, ignoring.", NDI_RED);
156	}	74	}
157
158	if (!strcmp (buf, "image_info"))
159	send_image_info (ns, params);
160	else if (!strcmp (buf, "image_sums"))
161	send_image_sums (ns, params);
162	else if (!strcmp (buf, "skill_info"))
163	send_skill_info (ns, params);
164	else if (!strcmp (buf, "spell_paths"))
165	send_spell_paths (ns, params);
166	else	75	else
167	ns->send_packet (bigbuf, len);	76	{
168	}	77	cmd_queue.push_back (command ());
169		78	command &cmd = cmd_queue.back ();
170	/**	79	cmd.stamp = stamp;
171	* Handle client input.	80	cmd.handler = handler;
172	*	81	cmd.data = salloc<char> (datalen + 1, data);
173	* HandleClient is actually not named really well - we only get here once	82	cmd.datalen = datalen;
174	* there is input, so we don't do exception or other stuff here.
175	* sock is the output socket information. pl is the player associated
176	* with this socket, null if no player (one of the init_sockets for just
177	* starting a connection)
178	*/
179
180	void
181	HandleClient (client_socket ns, player pl)
182	{
183	/* Loop through this - maybe we have several complete packets here. */
184	// limit to a few commands only, though, as to not monopolise the server
185	for (int repeat = 16; repeat--;)
186	{	83	}
187	/* If it is a player, and they don't have any speed left, we	84	}
188	* return, and will read in the data when they do have time.
189	*/
190	if (pl && pl->state == ST_PLAYING && pl->ob && pl->ob->speed_left < 0)
191	return;
192		85
193	int pkt_len = ns->read_packet ();	86	bool
		87	client::handle_command ()
		88	{
		89	if (!cmd_queue.empty ()
		90	&& state == ST_PLAYING
		91	&& pl->ob->speed_left > 0.f)
		92	{
		93	command &cmd = cmd_queue.front ();
194		94
195	if (pkt_len < 0)	95	if (cmd.stamp + MAX_QUEUE_BACKLOG < NOW)
196	{	96	{
197	LOG (llevError, "read error on player %s\n", &pl->ob->name);	97	reset_state ();
198	/* Caller will take care of cleaning this up */	98	send_packet_printf ("drawinfo %d ignoring delayed commands.", NDI_RED);
199	ns->status = Ns_Dead;
200	return;
201	}
202	else if (pkt_len == 0)
203	/* Still dont have a full packet */
204	return;
205
206	/* First, break out beginning word. There are at least
207	* a few commands that do not have any paremeters. If
208	* we get such a command, don't worry about trying
209	* to break it up.
210	*/
211	int datalen;
212	char data = strchr ((char )ns->inbuf + 2, ' ');
213
214	if (data)
215	{
216	*data++ = 0;
217	datalen = pkt_len - (data - (char *)ns->inbuf);
218	}	99	}
219	else	100	else
220	{	101	execute (cmd.handler, cmd.data, cmd.datalen);
221	data = (char *)ns->inbuf + 2; // better read garbage than segfault
222	datalen = 0;
223	}
224		102
225	ns->inbuf [pkt_len] = 0; /* Terminate buffer - useful for string data */	103	cmd_queue.pop_front ();
226		104	return true;
227	for (int i = 0; nscommands[i].cmdname; i++)
228	{
229	if (!strcmp ((char *)ns->inbuf + 2, nscommands[i].cmdname))
230	{
231	nscommands[i].cmdproc (data, datalen, ns);
232	ns->skip_packet (pkt_len);
233	//D// not doing this causes random memory corruption
234	if (nscommands[i].flag & 2)
235	goto next_packet;
236	return;
237	}
238	}
239
240	/* Player must be in the playing state or the flag on the
241	* the command must be zero for the user to use the command -
242	* otherwise, a player cam save, be in the play_again state, and
243	* the map they were on gets swapped out, yet things that try to look
244	* at the map causes a crash. If the command is valid, but
245	* one they can't use, we still swallow it up.
246	*/
247	if (pl)
248	for (int i = 0; plcommands[i].cmdname; i++)
249	{
250	if (!strcmp ((char *)ns->inbuf + 2, plcommands[i].cmdname))
251	{
252	if (pl->state == ST_PLAYING \|\| !(plcommands[i].flag & 1))
253	plcommands[i].cmdproc ((char *) data, datalen, pl);
254
255	ns->skip_packet (pkt_len);
256	//D// not doing this causes random memory corruption
257	if (plcommands[i].flag & 2)
258	goto next_packet;
259
260	return;
261	}
262	}
263
264	/* If we get here, we didn't find a valid command. Logging
265	* this might be questionable, because a broken client/malicious
266	* user could certainly send a whole bunch of invalid commands.
267	*/
268	LOG (llevDebug, "Bad command from client (%s)\n", ns->inbuf + 2);
269	ns->skip_packet (pkt_len);
270	next_packet:
271	;
272	}	105	}
		106	else
		107	return false;
273	}	108	}
274		109
275	void	110	void
276	flush_sockets (void)	111	flush_sockets (void)
277	{	112	{
278	for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)	113	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
279	if ((*i)->status != Ns_Dead)
280	(*i)->flush ();	114	(*i)->flush ();
281	}	115	}
282		116
283	/**	117	/**
284	* This checks the sockets for input, does the right thing.	118	* This checks the sockets for input, does the right thing.
285	*	119	*
…		…
288	*	122	*
289	*/	123	*/
290	void	124	void
291	doeric_server (void)	125	doeric_server (void)
292	{	126	{
293	int i, pollret;	127	//TODO: should not be done here, either
294	fd_set tmp_read;	128	for (unsigned i = 0; i < clients.size (); ++i)
295	struct sockaddr_in addr;	129	{
296	socklen_t addrlen = sizeof (struct sockaddr);	130	client *ns = clients [i];
297	player pl, next;
298	int maxfd = 0;
299		131
300	#ifdef CS_LOGSTATS	132	ns->tick ();
301	if ((time (NULL) - cst_lst.time_start) >= CS_LOGTIME)	133	ns->refcnt_chk ();
302	write_cs_stats ();	134	}
		135	}
		136
		137	void
		138	client::tick ()
		139	{
		140	if (!pl \|\| destroyed ())
		141	return;
		142
		143	/* Update the players stats once per tick. More efficient than
		144	* sending them whenever they change, and probably just as useful
		145	*/
		146	esrv_update_stats (pl);
		147
		148	if (last_weight != -1 && last_weight != WEIGHT (pl->ob))
		149	{
		150	esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
		151	if (last_weight != WEIGHT (pl->ob))
		152	LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
		153	(unsigned long) last_weight, WEIGHT (pl->ob));
		154	}
		155
		156	draw_client_map (pl);
		157
		158	if (update_look)
		159	esrv_draw_look (pl);
		160
		161	if (ixface.empty ())
		162	{
		163	// regularly send a new face when queue is empty
		164	if (bg_scrub && !--bg_scrub && enable_bg_scrub)
		165	while (scrub_idx < faces.size () - 1)
		166	{
		167	++scrub_idx;
		168
		169	if (!faces_sent [scrub_idx])
		170	{
		171	send_face (scrub_idx, -120);
		172	flush_fx ();
		173
		174	bg_scrub = 1; // send up to one face per tick, unless an image was requested
		175	break;
		176	}
		177	}
		178
		179	rate_avail = max_rate - outputbuffer_len ();
		180	}
		181	else
		182	{
		183	bool overload = false;
		184
		185	#if HAVE_TCP_INFO
		186	// do bandwidth checking
		187	if (tcpi.tcpi_unacked + 1 > max (4, tcpi.tcpi_snd_cwnd))
		188	{
		189	overload = true;
		190	if (next_rate_adjust <= NOW)
		191	{
		192	next_rate_adjust = NOW + 2;
		193	max_rate = max (max_rate >> 1, int (5000 * TICK));
		194	LOG (llevDebug, "tcp %s overloaded (%d + 1 > 4 \| %d), rate now %d\n",
		195	host, (int)tcpi.tcpi_unacked, (int)tcpi.tcpi_snd_cwnd, int (max_rate / TICK));//D
		196	send_packet_printf ("drawinfo %d Due to possible network congestion, your output-rate has been reduced to %dbps.",
		197	NDI_RED, int (max_rate / TICK));
		198	}
		199	}
303	#endif	200	#endif
304		201
305	/* Go through the players. Let the loop set the next pl value,	202	if (!overload)
306	* since we may remove some
307	*/
308	//TODO: must be handled cleanly elsewhere
309	for (pl = first_player; pl; )
310	{
311	player *npl = pl->next;
312
313	//TODO: must be handled cleanly elsewhere
314	if (pl->socket->status == Ns_Dead)
315	{	203	{
316	save_player (pl->ob, 0);	204	int ol = outputbuffer_len ();
317		205
318	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))	206	rate_avail = min (max_rate, rate_avail + max_rate);
		207	rate_avail -= ol;
		208
		209	int avail = rate_avail;
		210
		211	// if we can split images, transfer up to mss-sized packets if possible
		212	// but never 768 bytes more.
		213	if (fxix) avail += min (768, mss - (ol % mss));
		214
		215	bg_scrub = BG_SCRUB_RATE;
		216
		217	while (avail > 0)
319	{	218	{
320	terminate_all_pets (pl->ob);	219	ixsend &ix = ixface.back ();
321	pl->ob->remove ();	220
		221	if (facedata *d = face_data (ix.idx, faceset))
		222	{
		223	if (fxix)
		224	{
		225	// only transfer something if the amount of data transferred
		226	// has a healthy relation to the header overhead
		227	if (avail <= 40)
		228	break;
		229
		230	// 9 bytes is enough for fx_FFFOOO
		231	int chunk = min (min (avail, MAXSOCKBUF - 9), (int)ix.ofs);
		232
		233	if (chunk <= 0)
		234	break;
		235
		236	ix.ofs -= chunk;
		237
		238	//fprintf (stderr, "i%dx %6d: %5d+%4d (%4d)\n", fxix, ix.idx,ix.ofs,chunk, ixface.size());//D
		239
		240	packet sl ("ix");
		241
		242	sl << ber32 (ix.idx)
		243	<< ber32 (ix.ofs)
		244	<< data (d->data.data () + ix.ofs, chunk);
		245
		246	send_packet (sl);
		247	}
		248	else
		249	{
		250	send_image (ix.idx);
		251	ix.ofs = 0;
		252	}
		253	}
		254	else
		255	ix.ofs = 0;
		256
		257	int consumed = outputbuffer_len () - ol;
		258
		259	avail -= consumed;
		260	rate_avail -= consumed;
		261
		262	ol = outputbuffer_len ();
		263
		264	if (!ix.ofs)
		265	{
		266	ixface.pop_back ();
		267
		268	if (ixface.empty ())
		269	break;
		270	}
322	}	271	}
323
324	leave (pl, 1);
325	final_free_player (pl);
326	}	272	}
327
328	pl = npl;
329	}
330
331	FD_ZERO (&tmp_read);
332
333	for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); )
334	{	273	}
335	client_socket s = i;
336
337	if (s->status == Ns_Dead)
338	{
339	client_sockets.erase (i);
340	delete s;
341	}
342	else
343	{
344	if (s->fd > maxfd) maxfd = s->fd;
345
346	FD_SET (s->fd, &tmp_read);
347
348	++i;
349	}
350	}
351
352	struct timeval timeout;
353
354	timeout.tv_sec = 0;
355	timeout.tv_usec = 0;
356
357	pollret = select (maxfd + 1,
358	&tmp_read, 0, 0,
359	&timeout);
360
361	if (pollret == -1)
362	{
363	LOG (llevError, "select failed: %s\n", strerror (errno));
364	return;
365	}
366
367	/* We need to do some of the processing below regardless */
368
369	/* Check for any input on the sockets */
370	for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)
371	{
372	client_socket s = i;
373	player *pl = s->pl;
374
375	//TODO: disassociate handleclient from socket readin
376	if (s->inbuf_len \|\| FD_ISSET (s->fd, &tmp_read))
377	HandleClient (s, pl);
378
379	//TODO: should not be done here, either
380	if (s->status != Ns_Dead && pl)
381	{
382	/* Update the players stats once per tick. More efficient than
383	* sending them whenever they change, and probably just as useful
384	*/
385	esrv_update_stats (pl);
386	if (pl->last_weight != -1 && pl->last_weight != WEIGHT (pl->ob))
387	{
388	esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
389	if (pl->last_weight != WEIGHT (pl->ob))
390	LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
391	(unsigned long) pl->last_weight, WEIGHT (pl->ob));
392	}
393
394	/* draw_client_map does sanity checking that map is
395	* valid, so don't do it here.
396	*/
397	draw_client_map (pl->ob);
398	if (s->update_look)
399	esrv_draw_look (pl->ob);
400	}
401	}
402	}	274	}
403		275

Diff Legend

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

Comparing deliantra/server/socket/loop.C (file contents): Revision 1.16 by root, Thu Dec 14 22:45:41 2006 UTC vs. Revision 1.63 by root, Sat Jul 28 00:15:03 2007 UTC

Diff Legend

Comparing deliantra/server/socket/loop.C (file contents):
Revision 1.16 by root, Thu Dec 14 22:45:41 2006 UTC vs.
Revision 1.63 by root, Sat Jul 28 00:15:03 2007 UTC