[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.61 by root, Tue Jul 24 04:55:35 2007 UTC

1
2	/*	1	/*
3	* static char *rcsid_loop_c =	2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
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
		9	* it under the terms of the GNU General Public License as published by
		10	* the Free Software Foundation, either version 3 of the License, or
		11	* (at your option) any later version.
		12	*
		13	* This program is distributed in the hope that it will be useful,
		14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		16	* GNU General Public License for more details.
		17	*
		18	* You should have received a copy of the GNU General Public License
		19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
		20	*
		21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
5	*/	22	*/
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		23
30	/**	24	/**
31	* \file	25	* \file
32	* Main client/server loops.	26	* Main client/server loops.
33	*	27	*
34	* \date 2003-12-02	28	* \date 2003-12-02
35	*	29	*
36	* loop.c mainly deals with initialization and higher level socket	30	* loop.c mainly deals with initialization and higher level socket
37	* maintenance (checking for lost connections and if data has arrived.)	31	* maintanance (checking for lost connections and if data has arrived.)
38	* The reading of data is handled in ericserver.c
39	*/	32	*/
40		33
41
42	#include <global.h>	34	#include <global.h>
43	#ifndef __CEXTRACT__
44	# include <sproto.h>	35	#include <sproto.h>
45	# include <sockproto.h>	36	#include <sockproto.h>
46	#endif
47		37
48	#ifndef WIN32 /* ---win32 exclude unix headers */
49	# include <sys/types.h>	38	#include <sys/types.h>
50	# include <sys/time.h>	39	#include <sys/time.h>
51	# include <sys/socket.h>	40	#include <sys/socket.h>
52	# include <netinet/in.h>	41	#include <netinet/in.h>
53	# include <netdb.h>	42	#include <netdb.h>
54	#endif /* end win32 */
55		43
56	#ifdef HAVE_UNISTD_H
57	# include <unistd.h>	44	#include <unistd.h>
58	#endif
59
60	#ifdef HAVE_ARPA_INET_H
61	# include <arpa/inet.h>	45	#include <arpa/inet.h>
62	#endif
63		46
64	#include <loader.h>	47	#include <loader.h>
65	#include <newserver.h>
66		48
67	/*****************************************************************************	49	#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		50
72	/* Either keep this near the start or end of the file so it is	51	#define MAX_QUEUE_DEPTH 500
73	* at least reasonablye easy to find.	52	#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		53
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	54	void
146	RequestInfo (char buf, int len, NewSocket ns)	55	client::reset_state ()
147	{	56	{
148	char params = NULL, cp;	57	if (!pl)
		58	return;
149		59
150	/* No match */	60	pl->run_on = 0;
151	char bigbuf[MAX_BUF];	61	pl->fire_on = 0;
152	int slen;	62	}
153		63
154	/* Set up replyinfo before we modify any of the buffers - this is used	64	void
155	* if we don't find a match.	65	client::queue_command (packet_type handler, char data, int datalen)
156	*/	66	{
157	strcpy (bigbuf, "replyinfo ");	67	tstamp stamp = NOW;
158	slen = strlen (bigbuf);
159	safe_strcat (bigbuf, buf, &slen, MAX_BUF);
160		68
161	/* find the first space, make it null, and update the	69	if (cmd_queue.size () >= MAX_QUEUE_DEPTH)
162	* params pointer.
163	*/
164	for (cp = buf; *cp != '\0'; cp++)
165	if (*cp == ' ')
166	{	70	{
167	*cp = '\0';	71	//TODO: just disconnect here?
168	params = cp + 1;	72	reset_state ();
169	break;	73	send_packet_printf ("drawinfo %d command queue overflow, ignoring.", NDI_RED);
170	}	74	}
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	75	else
180	Write_String_To_Socket (ns, bigbuf, len);	76	{
181	}	77	cmd_queue.push_back (command ());
182		78	command &cmd = cmd_queue.back ();
183	/**	79	cmd.stamp = stamp;
184	* Handle client input.	80	cmd.handler = handler;
185	*	81	cmd.data = salloc<char> (datalen + 1, data);
186	* HandleClient is actually not named really well - we only get here once	82	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	{	83	}
203	/* If it is a player, and they don't have any speed left, we	84	}
204	* return, and will read in the data when they do have time.	85
205	*/	86	bool
206	if (pl && pl->state == ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0)	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 ();
		94
		95	if (cmd.stamp + MAX_QUEUE_BACKLOG < NOW)
207	{	96	{
208	return;	97	reset_state ();
209	}	98	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	}	99	}
242	else	100	else
243	len = 0;	101	execute (cmd.handler, cmd.data, cmd.datalen);
244		102
245	ns->inbuf.buf[ns->inbuf.len] = '\0'; /* Terminate buffer - useful for string data */	103	cmd_queue.pop_front ();
246	for (i = 0; nscommands[i].cmdname != NULL; i++)	104	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	}	105	}
		106	else
		107	return false;
285	}	108	}
286		109
287		110	void
288	/*****************************************************************************	111	flush_sockets (void)
289	*	112	{
290	* Low level socket looping - select calls and watchdog udp packet	113	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
291	* sending.	114	(*i)->flush ();
292	*	115	}
293	******************************************************************************/
294
295	#ifdef WATCHDOG
296		116
297	/**	117	/**
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.	118	* This checks the sockets for input, does the right thing.
338	*	119	*
339	* A bit of this code is grabbed out of socket.c	120	* 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	121	* There are 2 lists we need to look through - init_sockets is a list
341	*	122	*
342	*/	123	*/
343	void	124	void
344	doeric_server (void)	125	doeric_server (void)
345	{	126	{
346	int i, pollret;	127	//TODO: should not be done here, either
347	fd_set tmp_read, tmp_exceptions, tmp_write;	128	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	}	129	{
		130	client *ns = clients [i];
376		131
377	/* Go through the players. Let the loop set the next pl value,	132	ns->tick ();
378	* since we may remove some	133	ns->refcnt_chk ();
		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
379	*/	145	*/
380	for (pl = first_player; pl != NULL;)	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));
381	{	154	}
382	if (pl->socket.status == Ns_Dead)
383	{
384	player *npl = pl->next;
385		155
386	save_player (pl->ob, 0);	156	draw_client_map (pl);
387	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))	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)
388	{	166	{
389	terminate_all_pets (pl->ob);	167	++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		168
405	/* Reset timeout each time, since some OS's will change the values on	169	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	{	170	{
452	newsocknum = j;	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
453	break;	175	break;
454	}	176	}
455	}	177	}
456	init_sockets[newsocknum].fd = accept (init_sockets[0].fd, (struct sockaddr *) &addr, &addrlen);	178
457	if (init_sockets[newsocknum].fd == -1)	179	rate_avail = max_rate - outputbuffer_len ();
		180	}
		181	else if (!outq) // only send when bandwidth allows it
		182	{
		183	int ol = outputbuffer_len ();
		184
		185	rate_avail = min (max_rate, rate_avail + max_rate);
		186	rate_avail -= ol;
		187
		188	int avail = rate_avail;
		189
		190	// if we can split images, transfer up to mss-sized packets if possible
		191	// but never 768 bytes more.
		192	if (fxix) avail += min (768, mss - (ol % mss));
		193
		194	bg_scrub = BG_SCRUB_RATE;
		195
		196	while (avail > 0)
458	{	197	{
459	LOG (llevError, "accept failed: %s\n", strerror (errno));	198	ixsend &ix = ixface.back ();
460	}
461	else
462	{
463	char buf[MAX_BUF];
464	long ip;
465	NewSocket *ns;
466		199
467	ns = &init_sockets[newsocknum];	200	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	{	201	{
474	LOG (llevInfo, "Banned host tried to connect: [%s]\n", buf);	202	if (fxix)
475	close (init_sockets[newsocknum].fd);	203	{
476	init_sockets[newsocknum].fd = -1;	204	// only transfer something if the amount of data transferred
		205	// has a healthy relation to the header overhead
		206	if (avail <= 40)
		207	break;
		208
		209	// 9 bytes is enough for fx_FFFOOO
		210	int chunk = min (min (avail, MAXSOCKBUF - 9), (int)ix.ofs);
		211
		212	if (chunk <= 0)
		213	break;
		214
		215	ix.ofs -= chunk;
		216
		217	//fprintf (stderr, "i%dx %6d: %5d+%4d (%4d)\n", fxix, ix.idx,ix.ofs,chunk, ixface.size());//D
		218
		219	packet sl ("ix");
		220
		221	sl << ber32 (ix.idx)
		222	<< ber32 (ix.ofs)
		223	<< data (d->data.data () + ix.ofs, chunk);
		224
		225	send_packet (sl);
		226	}
		227	else
		228	{
		229	send_image (ix.idx);
		230	ix.ofs = 0;
		231	}
477	}	232	}
478	else	233	else
		234	ix.ofs = 0;
		235
		236	int consumed = outputbuffer_len () - ol;
		237
		238	avail -= consumed;
		239	rate_avail -= consumed;
		240
		241	ol = outputbuffer_len ();
		242
		243	if (!ix.ofs)
479	{	244	{
480	InitConnection (ns, buf);	245	ixface.pop_back ();
481	socket_info.nconns++;	246
		247	if (ixface.empty ())
		248	break;
482	}	249	}
483	}	250	}
484	}	251	}
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	}	252	}
		253

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.61 by root, Tue Jul 24 04:55:35 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.61 by root, Tue Jul 24 04:55:35 2007 UTC