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

Comparing deliantra/server/socket/loop.C (file contents):
Revision 1.6 by root, Sun Sep 10 13:43:33 2006 UTC vs.
Revision 1.54 by root, Sun Jul 1 04:08:14 2007 UTC

1
2	/*	1	/*
3	* static char *rcsid_loop_c =	2	* This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game.
4	* "$Id: loop.C,v 1.6 2006/09/10 13:43:33 root Exp $";	3	*
		4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
		5	* Copyright (©) 2002-2003,2007 Mark Wedel & The Crossfire Development Team
		6	* Copyright (©) 1992,2007 Frank Tore Johansen
		7	*
		8	* Crossfire TRT is free software; you can redistribute it and/or modify it
		9	* under the terms of the GNU General Public License as published by the Free
		10	* Software Foundation; either version 2 of the License, or (at your option)
		11	* any later version.
		12	*
		13	* This program is distributed in the hope that it will be useful, but
		14	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
		15	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
		16	* for more details.
		17	*
		18	* You should have received a copy of the GNU General Public License along
		19	* with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
		20	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		21	*
		22	* The authors can be reached via e-mail to <crossfire@schmorp.de>
5	*/	23	*/
6
7	/*
8	CrossFire, A Multiplayer game for X-windows
9
10	Copyright (C) 2002-2003 Mark Wedel & The Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen
12
13	This program is free software; you can redistribute it and/or modify
14	it under the terms of the GNU General Public License as published by
15	the Free Software Foundation; either version 2 of the License, or
16	(at your option) any later version.
17
18	This program is distributed in the hope that it will be useful,
19	but WITHOUT ANY WARRANTY; without even the implied warranty of
20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	GNU General Public License for more details.
22
23	You should have received a copy of the GNU General Public License
24	along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
27	The author can be reached via e-mail to crossfire-devel@real-time.com
28	*/
29		24
30	/**	25	/**
31	* \file	26	* \file
32	* Main client/server loops.	27	* Main client/server loops.
33	*	28	*
34	* \date 2003-12-02	29	* \date 2003-12-02
35	*	30	*
36	* loop.c mainly deals with initialization and higher level socket	31	* loop.c mainly deals with initialization and higher level socket
37	* maintenance (checking for lost connections and if data has arrived.)	32	* maintanance (checking for lost connections and if data has arrived.)
38	* The reading of data is handled in ericserver.c
39	*/	33	*/
40		34
41
42	#include <global.h>	35	#include <global.h>
43	#ifndef __CEXTRACT__
44	# include <sproto.h>	36	#include <sproto.h>
45	# include <sockproto.h>	37	#include <sockproto.h>
46	#endif
47		38
48	#ifndef WIN32 /* ---win32 exclude unix headers */
49	# include <sys/types.h>	39	#include <sys/types.h>
50	# include <sys/time.h>	40	#include <sys/time.h>
51	# include <sys/socket.h>	41	#include <sys/socket.h>
52	# include <netinet/in.h>	42	#include <netinet/in.h>
53	# include <netdb.h>	43	#include <netdb.h>
54	#endif /* end win32 */
55		44
56	#ifdef HAVE_UNISTD_H
57	# include <unistd.h>	45	#include <unistd.h>
58	#endif
59
60	#ifdef HAVE_ARPA_INET_H
61	# include <arpa/inet.h>	46	#include <arpa/inet.h>
62	#endif
63		47
64	#include <loader.h>	48	#include <loader.h>
65	#include <newserver.h>
66		49
67	/*****************************************************************************	50	#define BG_SCRUB_RATE 4 // how often to send a face in the background
68	* Start of command dispatch area.
69	* The commands here are protocol commands.
70	****************************************************************************/
71		51
72	/* Either keep this near the start or end of the file so it is	52	#define MAX_QUEUE_DEPTH 500
73	* at least reasonablye easy to find.	53	#define MAX_QUEUE_BACKLOG 3.
74	* There are really 2 commands - those which are sent/received
75	* before player joins, and those happen after the player has joined.
76	* As such, we have function types that might be called, so
77	* we end up having 2 tables.
78	*/
79		54
80	typedef void (func_uint8_int_ns) (char , int, NewSocket *);
81
82	struct NsCmdMapping
83	{
84	const char *cmdname;
85	func_uint8_int_ns cmdproc;
86	};
87
88	typedef void (func_uint8_int_pl) (char , int, player *);
89	struct PlCmdMapping
90	{
91	const char *cmdname;
92	func_uint8_int_pl cmdproc;
93	uint8 flag;
94	};
95
96	/**
97	* Dispatch table for the server.
98	*
99	* CmdMapping is the dispatch table for the server, used in HandleClient,
100	* which gets called when the client has input. All commands called here
101	* use the same parameter form (char* data, int len, int clientnum.
102	* We do implicit casts, because the data that is being passed is
103	* unsigned (pretty much needs to be for binary data), however, most
104	* of these treat it only as strings, so it makes things easier
105	* to cast it here instead of a bunch of times in the function itself.
106	* flag is 1 if the player must be in the playing state to issue the
107	* command, 0 if they can issue it at any time.
108	*/
109	static struct PlCmdMapping plcommands[] = {
110	{"examine", ExamineCmd, 1},
111	{"apply", ApplyCmd, 1},
112	{"move", MoveCmd, 1},
113	{"reply", ReplyCmd, 0},
114	{"command", PlayerCmd, 1},
115	{"ncom", (func_uint8_int_pl) NewPlayerCmd, 1},
116	{"lookat", LookAt, 1},
117	{"lock", (func_uint8_int_pl) LockItem, 1},
118	{"mark", (func_uint8_int_pl) MarkItem, 1},
119	{"mapredraw", MapRedrawCmd, 0}, /* Added: phil */
120	{"mapinfo", MapInfoCmd, 2}, /* CF+ */
121	{"ext", ExtCmd, 2}, /* CF+ */
122	{NULL, NULL, 0} /* terminator */
123	};
124
125	/** Face-related commands */
126	static struct NsCmdMapping nscommands[] = {
127	{"addme", AddMeCmd},
128	{"askface", SendFaceCmd}, /* Added: phil */
129	{"requestinfo", RequestInfo},
130	{"setfacemode", SetFaceMode},
131	{"setsound", SetSound},
132	{"setup", SetUp},
133	{"version", VersionCmd},
134	{"toggleextendedinfos", ToggleExtendedInfos}, /Added: tchize /
135	{"toggleextendedtext", ToggleExtendedText}, /Added: tchize /
136	{"asksmooth", AskSmooth}, /Added: tchize (smoothing technologies) /
137	{NULL, NULL} /* terminator (I, II & III) */
138	};
139
140	/**
141	* RequestInfo is sort of a meta command. There is some specific
142	* request of information, but we call other functions to provide
143	* that information.
144	*/
145	void	55	void
146	RequestInfo (char buf, int len, NewSocket ns)	56	client::reset_state ()
147	{	57	{
148	char params = NULL, cp;	58	if (!pl)
		59	return;
149		60
150	/* No match */	61	pl->run_on = 0;
151	char bigbuf[MAX_BUF];	62	pl->fire_on = 0;
152	int slen;	63	}
153		64
154	/* Set up replyinfo before we modify any of the buffers - this is used	65	void
155	* if we don't find a match.	66	client::queue_command (packet_type handler, char data, int datalen)
156	*/	67	{
157	strcpy (bigbuf, "replyinfo ");	68	tstamp stamp = NOW;
158	slen = strlen (bigbuf);
159	safe_strcat (bigbuf, buf, &slen, MAX_BUF);
160		69
161	/* find the first space, make it null, and update the	70	if (cmd_queue.size () >= MAX_QUEUE_DEPTH)
162	* params pointer.
163	*/
164	for (cp = buf; *cp != '\0'; cp++)
165	if (*cp == ' ')
166	{	71	{
167	*cp = '\0';	72	//TODO: just disconnect here?
168	params = cp + 1;	73	reset_state ();
169	break;	74	send_packet_printf ("drawinfo %d command queue overflow, ignoring.", NDI_RED);
170	}	75	}
171	if (!strcmp (buf, "image_info"))
172	send_image_info (ns, params);
173	else if (!strcmp (buf, "image_sums"))
174	send_image_sums (ns, params);
175	else if (!strcmp (buf, "skill_info"))
176	send_skill_info (ns, params);
177	else if (!strcmp (buf, "spell_paths"))
178	send_spell_paths (ns, params);
179	else	76	else
180	Write_String_To_Socket (ns, bigbuf, len);	77	{
181	}	78	cmd_queue.push_back (command ());
182		79	command &cmd = cmd_queue.back ();
183	/**	80	cmd.stamp = stamp;
184	* Handle client input.	81	cmd.handler = handler;
185	*	82	cmd.data = salloc<char> (datalen + 1, data);
186	* HandleClient is actually not named really well - we only get here once	83	cmd.datalen = datalen;
187	* there is input, so we don't do exception or other stuff here.
188	* sock is the output socket information. pl is the player associated
189	* with this socket, null if no player (one of the init_sockets for just
190	* starting a connection)
191	*/
192
193	void
194	HandleClient (NewSocket * ns, player *pl)
195	{
196	int len = 0, i, cnt;
197	char *data;
198
199	/* Loop through this - maybe we have several complete packets here. */
200	// limit to a few commands only, though, as to not monopolise the server
201	for (cnt = 16; cnt--;)
202	{	84	}
203	/* If it is a player, and they don't have any speed left, we	85	}
204	* return, and will read in the data when they do have time.	86
205	*/	87	bool
206	if (pl && pl->state == ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0)	88	client::handle_command ()
		89	{
		90	if (!cmd_queue.empty ()
		91	&& state == ST_PLAYING
		92	&& pl->ob->speed_left > 0.f)
		93	{
		94	command &cmd = cmd_queue.front ();
		95
		96	if (cmd.stamp + MAX_QUEUE_BACKLOG < NOW)
207	{	97	{
208	return;	98	reset_state ();
209	}	99	send_packet_printf ("drawinfo %d ignoring delayed commands.", NDI_RED);
210
211	i = SockList_ReadPacket (ns->fd, &ns->inbuf, MAXSOCKBUF - 1);
212
213	if (i < 0)
214	{
215	#ifdef ESRV_DEBUG
216	LOG (llevDebug, "HandleClient: Read error on connection player %s\n", (pl ? pl->ob->name : "None"));
217	#endif
218	/* Caller will take care of cleaning this up */
219	ns->status = Ns_Dead;
220	return;
221	}
222	/* Still dont have a full packet */
223	if (i == 0)
224	return;
225
226	// //D//TODO//temporarily log long commands
227	// if (ns->inbuf.len >= 40 && pl && pl->ob)
228	// LOG (llevDebug, "HandleClient: long comamnd from <%s,%s> %d<%s>\n", pl->ob->name, ns->host, ns->inbuf.len, ns->inbuf.buf + 2);
229
230	/* First, break out beginning word. There are at least
231	* a few commands that do not have any paremeters. If
232	* we get such a command, don't worry about trying
233	* to break it up.
234	*/
235	data = (char ) strchr ((char ) ns->inbuf.buf + 2, ' ');
236	if (data)
237	{
238	*data = '\0';
239	data++;
240	len = ns->inbuf.len - (data - (char *) ns->inbuf.buf);
241	}	100	}
242	else	101	else
243	len = 0;	102	execute (cmd.handler, cmd.data, cmd.datalen);
244		103
245	ns->inbuf.buf[ns->inbuf.len] = '\0'; /* Terminate buffer - useful for string data */	104	cmd_queue.pop_front ();
246	for (i = 0; nscommands[i].cmdname != NULL; i++)	105	return true;
247	{
248	if (strcmp ((char *) ns->inbuf.buf + 2, nscommands[i].cmdname) == 0)
249	{
250	nscommands[i].cmdproc ((char *) data, len, ns);
251	ns->inbuf.len = 0;
252	return; //D// not doing this causes random memory corruption
253	goto next_packet;
254	}
255	}
256	/* Player must be in the playing state or the flag on the
257	* the command must be zero for the user to use the command -
258	* otherwise, a player cam save, be in the play_again state, and
259	* the map they were on gets swapped out, yet things that try to look
260	* at the map causes a crash. If the command is valid, but
261	* one they can't use, we still swallow it up.
262	*/
263	if (pl)
264	for (i = 0; plcommands[i].cmdname != NULL; i++)
265	{
266	if (strcmp ((char *) ns->inbuf.buf + 2, plcommands[i].cmdname) == 0)
267	{
268	if (pl->state == ST_PLAYING \|\| !(plcommands[i].flag & 1))
269	plcommands[i].cmdproc ((char *) data, len, pl);
270	ns->inbuf.len = 0;
271	//D// not doing this causes random memory corruption
272	if (plcommands[i].flag & 2)
273	goto next_packet;
274	return;
275	}
276	}
277	/* If we get here, we didn't find a valid command. Logging
278	* this might be questionable, because a broken client/malicious
279	* user could certainly send a whole bunch of invalid commands.
280	*/
281	LOG (llevDebug, "Bad command from client (%s)\n", ns->inbuf.buf + 2);
282	next_packet:
283	;
284	}	106	}
		107	else
		108	return false;
285	}	109	}
286		110
287		111	void
288	/*****************************************************************************	112	flush_sockets (void)
289	*	113	{
290	* Low level socket looping - select calls and watchdog udp packet	114	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
291	* sending.	115	(*i)->flush ();
292	*	116	}
293	******************************************************************************/
294
295	#ifdef WATCHDOG
296		117
297	/**	118	/**
298	* Tell watchdog that we are still alive
299	*
300	* I put the function here since we should hopefully already be getting
301	* all the needed include files for socket support
302	*/
303
304	void
305	watchdog (void)
306	{
307	static int fd = -1;
308	static struct sockaddr_in insock;
309
310	if (fd == -1)
311	{
312	struct protoent *protoent;
313
314	if ((protoent = getprotobyname ("udp")) == NULL \|\| (fd = socket (PF_INET, SOCK_DGRAM, protoent->p_proto)) == -1)
315	{
316	return;
317	}
318	insock.sin_family = AF_INET;
319	insock.sin_port = htons ((unsigned short) 13325);
320	insock.sin_addr.s_addr = inet_addr ("127.0.0.1");
321	}
322	sendto (fd, (void ) &fd, 1, 0, (struct sockaddr ) &insock, sizeof (insock));
323	}
324	#endif
325
326	void
327	flush_sockets (void)
328	{
329	player *pl;
330
331	for (pl = first_player; pl != NULL; pl = pl->next)
332	if (pl->socket.status != Ns_Dead)
333	Socket_Flush (&pl->socket);
334	}
335
336	/**
337	* This checks the sockets for input and exceptions, does the right thing.	119	* This checks the sockets for input, does the right thing.
338	*	120	*
339	* A bit of this code is grabbed out of socket.c	121	* A bit of this code is grabbed out of socket.c
340	* There are 2 lists we need to look through - init_sockets is a list	122	* There are 2 lists we need to look through - init_sockets is a list
341	*	123	*
342	*/	124	*/
343	void	125	void
344	doeric_server (void)	126	doeric_server (void)
345	{	127	{
346	int i, pollret;	128	//TODO: should not be done here, either
347	fd_set tmp_read, tmp_exceptions, tmp_write;	129	for (unsigned i = 0; i < clients.size (); ++i)
348	struct sockaddr_in addr;
349	socklen_t addrlen = sizeof (struct sockaddr);
350	player pl, next;
351
352	#ifdef CS_LOGSTATS
353	if ((time (NULL) - cst_lst.time_start) >= CS_LOGTIME)
354	write_cs_stats ();
355	#endif
356
357	FD_ZERO (&tmp_read);
358	FD_ZERO (&tmp_write);
359	FD_ZERO (&tmp_exceptions);
360
361	for (i = 0; i < socket_info.allocated_sockets; i++)
362	{
363	if (init_sockets[i].status == Ns_Dead)
364	{
365	free_newsocket (&init_sockets[i]);
366	init_sockets[i].status = Ns_Avail;
367	socket_info.nconns--;
368	}
369	else if (init_sockets[i].status != Ns_Avail)
370	{
371	FD_SET ((uint32) init_sockets[i].fd, &tmp_read);
372	FD_SET ((uint32) init_sockets[i].fd, &tmp_write);
373	FD_SET ((uint32) init_sockets[i].fd, &tmp_exceptions);
374	}
375	}	130	{
		131	client *ns = clients [i];
376		132
377	/* Go through the players. Let the loop set the next pl value,	133	ns->tick ();
378	* since we may remove some	134	ns->refcnt_chk ();
		135	}
		136	}
		137
		138	void
		139	client::tick ()
		140	{
		141	if (!pl \|\| destroyed ())
		142	return;
		143
		144	/* Update the players stats once per tick. More efficient than
		145	* sending them whenever they change, and probably just as useful
379	*/	146	*/
380	for (pl = first_player; pl != NULL;)	147	esrv_update_stats (pl);
		148
		149	if (last_weight != -1 && last_weight != WEIGHT (pl->ob))
		150	{
		151	esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
		152	if (last_weight != WEIGHT (pl->ob))
		153	LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
		154	(unsigned long) last_weight, WEIGHT (pl->ob));
381	{	155	}
382	if (pl->socket.status == Ns_Dead)
383	{
384	player *npl = pl->next;
385		156
386	save_player (pl->ob, 0);	157	draw_client_map (pl);
387	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))	158
		159	if (update_look)
		160	esrv_draw_look (pl);
		161
		162	if (ixface.empty ())
		163	{
		164	// regularly send a new face when queue is empty
		165	if (bg_scrub && !--bg_scrub && enable_bg_scrub)
		166	while (scrub_idx < faces.size () - 1)
388	{	167	{
389	terminate_all_pets (pl->ob);	168	++scrub_idx;
390	remove_ob (pl->ob);
391	}
392	leave (pl, 1);
393	final_free_player (pl);
394	pl = npl;
395	}
396	else
397	{
398	FD_SET ((uint32) pl->socket.fd, &tmp_read);
399	FD_SET ((uint32) pl->socket.fd, &tmp_write);
400	FD_SET ((uint32) pl->socket.fd, &tmp_exceptions);
401	pl = pl->next;
402	}
403	}
404		169
405	/* Reset timeout each time, since some OS's will change the values on	170	if (!faces_sent [scrub_idx])
406	* the return from select.
407	*/
408	socket_info.timeout.tv_sec = 0;
409	socket_info.timeout.tv_usec = 0;
410
411	pollret = select (socket_info.max_filedescriptor, &tmp_read, &tmp_write, &tmp_exceptions, &socket_info.timeout);
412
413	if (pollret == -1)
414	{
415	LOG (llevError, "select failed: %s\n", strerror (errno));
416	return;
417	}
418
419	/* We need to do some of the processing below regardless */
420
421	/* if (!pollret) return;*/
422
423	/* Following adds a new connection */
424	if (pollret && FD_ISSET (init_sockets[0].fd, &tmp_read))
425	{
426	int newsocknum = 0;
427
428	#ifdef ESRV_DEBUG
429	LOG (llevDebug, "doeric_server: New Connection\n");
430	#endif
431	/* If this is the case, all sockets currently in used */
432	if (socket_info.allocated_sockets <= socket_info.nconns)
433	{
434	init_sockets = (NewSocket ) realloc (init_sockets, sizeof (NewSocket) (socket_info.nconns + 1));
435	if (!init_sockets)
436	fatal (OUT_OF_MEMORY);
437	newsocknum = socket_info.allocated_sockets;
438	socket_info.allocated_sockets++;
439	init_sockets[newsocknum].faces_sent_len = nrofpixmaps;
440	init_sockets[newsocknum].faces_sent = (uint8 ) malloc (nrofpixmaps sizeof (*init_sockets[newsocknum].faces_sent));
441	if (!init_sockets[newsocknum].faces_sent)
442	fatal (OUT_OF_MEMORY);
443	init_sockets[newsocknum].status = Ns_Avail;
444	}
445	else
446	{
447	int j;
448
449	for (j = 1; j < socket_info.allocated_sockets; j++)
450	if (init_sockets[j].status == Ns_Avail)
451	{	171	{
452	newsocknum = j;	172	send_face (scrub_idx);
		173	flush_fx ();
		174
		175	bg_scrub = 1; // send up to one face per tick, unless an image was requested
453	break;	176	break;
454	}	177	}
455	}	178	}
456	init_sockets[newsocknum].fd = accept (init_sockets[0].fd, (struct sockaddr *) &addr, &addrlen);	179
457	if (init_sockets[newsocknum].fd == -1)	180	rate_avail = max_rate - outputbuffer_len ();
		181	}
		182	else
		183	{
		184	int ol = outputbuffer_len ();
		185
		186	rate_avail = min (max_rate, rate_avail + max_rate);
		187	rate_avail -= ol;
		188
		189	int avail = rate_avail;
		190
		191	// if we can split images, transfer up to mss-sized packets if possible
		192	// but never 768 bytes more.
		193	if (fxix) avail += min (768, mss - (ol % mss));
		194
		195	bg_scrub = BG_SCRUB_RATE;
		196
		197	while (avail > 0)
458	{	198	{
459	LOG (llevError, "accept failed: %s\n", strerror (errno));	199	ixsend &ix = ixface.back ();
460	}
461	else
462	{
463	char buf[MAX_BUF];
464	long ip;
465	NewSocket *ns;
466		200
467	ns = &init_sockets[newsocknum];	201	if (facedata *d = face_data (ix.idx, faceset))
468
469	ip = ntohl (addr.sin_addr.s_addr);
470	sprintf (buf, "%ld.%ld.%ld.%ld", (ip >> 24) & 255, (ip >> 16) & 255, (ip >> 8) & 255, ip & 255);
471
472	if (checkbanned (NULL, buf))
473	{	202	{
474	LOG (llevInfo, "Banned host tried to connect: [%s]\n", buf);	203	if (fxix)
475	close (init_sockets[newsocknum].fd);	204	{
476	init_sockets[newsocknum].fd = -1;	205	// 9 bytes is enough for fx_FFFOOO, 40 leaves some room for image data
		206	int chunk = min (min (avail - 40, MAXSOCKBUF - 9), ix.ofs);
		207
		208	if (chunk <= 0)
		209	break;
		210
		211	ix.ofs -= chunk;
		212
		213	packet sl ("ix");
		214
		215	sl << ber32 (ix.idx)
		216	<< ber32 (ix.ofs)
		217	<< data (d->data.data () + ix.ofs, chunk);
		218
		219	send_packet (sl);
		220	}
		221	else
		222	{
		223	send_image (ix.idx);
		224	ix.ofs = 0;
		225	}
477	}	226	}
478	else	227	else
		228	ix.ofs = 0;
		229
		230	int consumed = ol - outputbuffer_len ();
		231
		232	avail -= consumed;
		233	rate_avail -= consumed;
		234
		235	ol = outputbuffer_len ();
		236
		237	if (!ix.ofs)
479	{	238	{
480	InitConnection (ns, buf);	239	ixface.pop_back ();
481	socket_info.nconns++;	240	if (ixface.empty ())
		241	break;
482	}	242	}
483	}	243	}
484	}	244	}
485
486	/* Check for any exceptions/input on the sockets */
487	if (pollret)
488	for (i = 1; i < socket_info.allocated_sockets; i++)
489	{
490	if (init_sockets[i].status == Ns_Avail)
491	continue;
492	if (FD_ISSET (init_sockets[i].fd, &tmp_exceptions))
493	{
494	free_newsocket (&init_sockets[i]);
495	init_sockets[i].status = Ns_Avail;
496	socket_info.nconns--;
497	continue;
498	}
499	if (FD_ISSET (init_sockets[i].fd, &tmp_read))
500	{
501	HandleClient (&init_sockets[i], NULL);
502	}
503	if (FD_ISSET (init_sockets[i].fd, &tmp_write))
504	{
505	init_sockets[i].can_write = 1;
506	}
507	}
508
509	/* This does roughly the same thing, but for the players now */
510	for (pl = first_player; pl != NULL; pl = next)
511	{
512
513	next = pl->next;
514	if (pl->socket.status == Ns_Dead)
515	continue;
516
517	if (FD_ISSET (pl->socket.fd, &tmp_write))
518	{
519	if (!pl->socket.can_write)
520	{
521	#if 0
522	LOG (llevDebug, "Player %s socket now write enabled\n", pl->ob->name);
523	#endif
524	pl->socket.can_write = 1;
525	write_socket_buffer (&pl->socket);
526	}
527	/* if we get an error on the write_socket buffer, no reason to
528	* continue on this socket.
529	*/
530	if (pl->socket.status == Ns_Dead)
531	continue;
532	}
533	else
534	pl->socket.can_write = 0;
535
536	if (FD_ISSET (pl->socket.fd, &tmp_exceptions))
537	{
538	save_player (pl->ob, 0);
539	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
540	{
541	terminate_all_pets (pl->ob);
542	remove_ob (pl->ob);
543	}
544	leave (pl, 1);
545	final_free_player (pl);
546	}
547	else
548	{
549	HandleClient (&pl->socket, pl);
550	/* If the player has left the game, then the socket status
551	* will be set to this be the leave function. We don't
552	* need to call leave again, as it has already been called
553	* once.
554	*/
555	if (pl->socket.status == Ns_Dead)
556	{
557	save_player (pl->ob, 0);
558	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
559	{
560	terminate_all_pets (pl->ob);
561	remove_ob (pl->ob);
562	}
563	leave (pl, 1);
564	final_free_player (pl);
565	}
566	else
567	{
568
569	/* Update the players stats once per tick. More efficient than
570	* sending them whenever they change, and probably just as useful
571	*/
572	esrv_update_stats (pl);
573	if (pl->last_weight != -1 && pl->last_weight != WEIGHT (pl->ob))
574	{
575	esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
576	if (pl->last_weight != WEIGHT (pl->ob))
577	LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
578	(unsigned long) pl->last_weight, WEIGHT (pl->ob));
579	}
580	/* draw_client_map does sanity checking that map is
581	* valid, so don't do it here.
582	*/
583	draw_client_map (pl->ob);
584	if (pl->socket.update_look)
585	esrv_draw_look (pl->ob);
586	}
587	}
588	}
589	}	245	}
		246

Diff Legend

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

Comparing deliantra/server/socket/loop.C (file contents): Revision 1.6 by root, Sun Sep 10 13:43:33 2006 UTC vs. Revision 1.54 by root, Sun Jul 1 04:08:14 2007 UTC

Diff Legend

Comparing deliantra/server/socket/loop.C (file contents):
Revision 1.6 by root, Sun Sep 10 13:43:33 2006 UTC vs.
Revision 1.54 by root, Sun Jul 1 04:08:14 2007 UTC