[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.82 by root, Mon Oct 12 14:00:59 2009 UTC

1
2	/*	1	/*
3	* static char *rcsid_loop_c =	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
4	* "$Id: loop.C,v 1.6 2006/09/10 13:43:33 root Exp $";	3	*
		4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
		5	* Copyright (©) 2002-2003,2007 Mark Wedel & The Crossfire Development Team
		6	* Copyright (©) 1992,2007 Frank Tore Johansen
		7	*
		8	* Deliantra is free software: you can redistribute it and/or modify it under
		9	* the terms of the Affero GNU General Public License as published by the
		10	* Free Software Foundation, either version 3 of the License, or (at your
		11	* 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 Affero GNU General Public License
		19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
		21	*
		22	* The authors can be reached via e-mail to <support@deliantra.net>
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 50
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.resize (cmd_queue.size () + 1);
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 (); // the command might actually reset some movement state etc.
209	}
210		99
211	i = SockList_ReadPacket (ns->fd, &ns->inbuf, MAXSOCKBUF - 1);	100	if (pl)
212		101	pl->failmsg (
213	if (i < 0)	102	"Cannot keep up with your commands, ignoring them! "
214	{	103	"H<Your character cannot keep up with the instructions you give G<him\|her>. "
215	#ifdef ESRV_DEBUG	104	"Try issuing commands slower, or, if G<he\|she> is incapacitated (paralyzed and so on), "
216	LOG (llevDebug, "HandleClient: Read error on connection player %s\n", (pl ? pl->ob->name : "None"));	105	"wait till your character can act again.\n\nIf G<he\|she> is permanently stuck, then "
217	#endif	106	"try the B<suicide> command (or use B<chat> to ask somebody to B<invite> you out).>"
218	/* Caller will take care of cleaning this up */	107	);
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	}	108	}
242	else	109	else
243	len = 0;	110	execute (cmd.handler, cmd.data, cmd.datalen);
244		111
245	ns->inbuf.buf[ns->inbuf.len] = '\0'; /* Terminate buffer - useful for string data */	112	sfree<char> (cmd.data, cmd.datalen + 1);
246	for (i = 0; nscommands[i].cmdname != NULL; i++)	113	cmd_queue.pop_front ();
		114	return true;
		115	}
		116	else
		117	return false;
		118	}
		119
		120	void
		121	client::tick ()
		122	{
		123	if (!pl \|\| destroyed ())
		124	return;
		125
		126	pl->dirty = true;
		127
		128	/* Update the players stats once per tick. More efficient than
		129	* sending them whenever they change, and probably just as useful
		130	*/
		131	esrv_update_stats (pl);
		132
		133	sint32 weight = pl->ob->client_weight ();
		134
		135	if (last_weight != weight)
		136	{
		137	pl->ob->update_stats ();
		138	esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
		139	}
		140
		141	draw_client_map (pl);
		142
		143	if (update_look)
		144	esrv_draw_look (pl);
		145
		146	mapinfo_queue_run ();
		147
		148	#if HAVE_TCP_INFO
		149	// check time of last ack, and, if too old, kill connection
		150	socklen_t len = sizeof (tcpi);
		151
		152	if (!getsockopt (fd, IPPROTO_TCP, TCP_INFO, &tcpi, &len) && len == sizeof (tcpi))
		153	{
		154	if (tcpi.tcpi_snd_mss)
		155	mss = tcpi.tcpi_snd_mss;
		156
		157	#if 0
		158	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",
		159	tcpi.tcpi_unacked,
		160	tcpi.tcpi_sacked,
		161	tcpi.tcpi_lost,
		162	tcpi.tcpi_retrans,
		163	tcpi.tcpi_fackets,
		164	tcpi.tcpi_snd_ssthresh, tcpi.tcpi_snd_cwnd, tcpi.tcpi_advmss, tcpi.tcpi_pmtu, tcpi.tcpi_advmss,
		165
		166	tcpi.tcpi_snd_cwnd - (tcpi.tcpi_unacked - tcpi.tcpi_sacked));
		167	#endif
		168
		169	// fast-time-out a player by checking for missing acks
		170	// do this only when player is active
		171	if (pl && pl->active
		172	&& tcpi.tcpi_last_ack_recv > int (socket_timeout * 1000))
247	{	173	{
248	if (strcmp ((char *) ns->inbuf.buf + 2, nscommands[i].cmdname) == 0)	174	send_msg (NDI_RED \| NDI_REPLY, "connection-timeout", "safety disconnect due to tcp/ip timeout (no packets received)");
		175	write_outputbuffer ();
		176
		177	LOG (llevDebug, "connection on fd %d closed due to ack timeout (%u/%u/%u)\n", fd,
		178	(unsigned)tcpi.tcpi_last_ack_recv, (unsigned)tcpi.tcpi_last_data_sent, (unsigned)tcpi.tcpi_unacked);
		179	destroy ();
		180	}
		181	}
		182	#endif
		183
		184	rate_avail = min (max_rate + mss, rate_avail + max_rate);
		185
		186	int max_send = rate_avail;
		187
		188	#if HAVE_TCP_INFO
		189	// further restrict the available bandwidth by the excess bandwidth available
		190	max_send = min (max_send, (tcpi.tcpi_snd_cwnd - tcpi.tcpi_unacked + tcpi.tcpi_sacked) * mss);
		191	#endif
		192
		193	// round to next-lowest mss
		194	max_send -= max_send % mss;
		195
		196	if (ixface.empty ())
		197	{
		198	// regularly send a new face when queue is empty
		199	if (bg_scrub && !--bg_scrub)
		200	while (scrub_idx < faces.size () - 1)
		201	{
		202	++scrub_idx;
		203
		204	if (!faces_sent [scrub_idx])
		205	if (faceinfo *f = face_info (scrub_idx))
		206	if (f->type == FT_FACE \|\| f->type == FT_SOUND) // only scrub faces and sounds for now
		207	{
		208	send_face (scrub_idx, -120);
		209	flush_fx ();
		210
		211	bg_scrub = 1; // send up to one fx per tick, unless an image was requested
		212	break;
		213	}
		214	}
		215	}
		216	else
		217	{
		218	bg_scrub = BG_SCRUB_RATE;
		219
		220	for (;;)
		221	{
		222	int avail = max_send - outputbuffer_len ();
		223
		224	if (avail <= 0)
		225	break;
		226
		227	ixsend &ix = ixface.back ();
		228
		229	if (facedata *d = face_data (ix.idx, faceset))
249	{	230	{
250	nscommands[i].cmdproc ((char *) data, len, ns);	231	// estimate the packet header overhead "ix " + idx + (new)ofs
251	ns->inbuf.len = 0;	232	int pktlen = 3 + ber32::encoded_size (ix.idx) + ber32::encoded_size (ix.ofs);
252	return; //D// not doing this causes random memory corruption	233	int chunk = min (avail - packet::hdrlen, MAXSOCKBUF) - pktlen;
253	goto next_packet;	234
		235	// only transfer something if the amount of data transferred
		236	// has a healthy relation to the header overhead
		237	if (chunk < 64)
		238	break;
		239
		240	chunk = min (chunk, (int)ix.ofs);
		241
		242	ix.ofs -= chunk;
		243
		244	//fprintf (stderr, "i%dx %6d: %5d+%4d (%4d)\n", fxix, ix.idx,ix.ofs,chunk, ixface.size());//D
		245
		246	packet sl ("ix");
		247
		248	sl << ber32 (ix.idx)
		249	<< ber32 (ix.ofs)
		250	<< data (d->data.data () + ix.ofs, chunk);
		251
		252	send_packet (sl);
		253	}
		254	else
		255	ix.ofs = 0;
		256
		257	if (!ix.ofs)
		258	{
		259	ixface.pop_back ();
		260
		261	if (ixface.empty ())
		262	break;
254	}	263	}
255	}	264	}
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	}
285	}
286
287
288	/*****************************************************************************
289	*
290	* Low level socket looping - select calls and watchdog udp packet
291	* sending.
292	*
293	******************************************************************************/
294
295	#ifdef WATCHDOG
296
297	/**
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.
338	*
339	* 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
341	*
342	*/
343	void
344	doeric_server (void)
345	{
346	int i, pollret;
347	fd_set tmp_read, tmp_exceptions, tmp_write;
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	}
376
377	/* Go through the players. Let the loop set the next pl value,
378	* since we may remove some
379	*/
380	for (pl = first_player; pl != NULL;)
381	{
382	if (pl->socket.status == Ns_Dead)
383	{
384	player *npl = pl->next;
385
386	save_player (pl->ob, 0);
387	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
388	{
389	terminate_all_pets (pl->ob);
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
405	/* Reset timeout each time, since some OS's will change the values on
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	{
452	newsocknum = j;
453	break;
454	}
455	}
456	init_sockets[newsocknum].fd = accept (init_sockets[0].fd, (struct sockaddr *) &addr, &addrlen);
457	if (init_sockets[newsocknum].fd == -1)
458	{
459	LOG (llevError, "accept failed: %s\n", strerror (errno));
460	}
461	else
462	{
463	char buf[MAX_BUF];
464	long ip;
465	NewSocket *ns;
466
467	ns = &init_sockets[newsocknum];
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	{
474	LOG (llevInfo, "Banned host tried to connect: [%s]\n", buf);
475	close (init_sockets[newsocknum].fd);
476	init_sockets[newsocknum].fd = -1;
477	}
478	else
479	{
480	InitConnection (ns, buf);
481	socket_info.nconns++;
482	}
483	}
484	}
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	}	265	}
508		266
509	/* This does roughly the same thing, but for the players now */	267	rate_avail -= outputbuffer_len ();
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	}	268	}
		269
		270	void
		271	client::flush_sockets (void)
		272	{
		273	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
		274	(*i)->flush ();
		275	}
		276
		277	void
		278	client::clock (void)
		279	{
		280	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
		281	(*i)->tick ();
		282
		283	// give them all the same chances
		284	flush_sockets ();
		285
		286	//TODO: should not be done here, either
		287	for (unsigned i = 0; i < clients.size (); ++i)
		288	clients[i]->refcnt_chk ();
		289	}
		290

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.82 by root, Mon Oct 12 14:00:59 2009 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.82 by root, Mon Oct 12 14:00:59 2009 UTC