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

Comparing deliantra/server/socket/loop.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:06 2006 UTC vs.
Revision 1.17 by root, Fri Dec 15 03:53:44 2006 UTC

…		…
1
2	/*
3	* static char *rcsid_loop_c =
4	* "$Id: loop.C,v 1.1 2006/08/13 17:16:06 elmex Exp $";
5	*/
6
7	/*	1	/*
8	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
9		3
10	Copyright (C) 2002-2003 Mark Wedel & The Crossfire Development Team	4	Copyright (C) 2002-2003 Mark Wedel & The Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen	5	Copyright (C) 1992 Frank Tore Johansen
22		16
23	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
24	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26		20
27	The author can be reached via e-mail to crossfire-devel@real-time.com	21	The author can be reached via e-mail to <crossfire@schmorp.de>
28	*/	22	*/
29		23
30	/**	24	/**
31	* \file	25	* \file
32	* Main client/server loops.	26	* Main client/server loops.
…		…
38	* The reading of data is handled in ericserver.c	32	* The reading of data is handled in ericserver.c
39	*/	33	*/
40		34
41		35
42	#include <global.h>	36	#include <global.h>
43	#ifndef __CEXTRACT__
44	#include <sproto.h>	37	#include <sproto.h>
45	#include <sockproto.h>	38	#include <sockproto.h>
46	#endif
47		39
48	#ifndef WIN32 /* ---win32 exclude unix headers */
49	#include <sys/types.h>	40	#include <sys/types.h>
50	#include <sys/time.h>	41	#include <sys/time.h>
51	#include <sys/socket.h>	42	#include <sys/socket.h>
52	#include <netinet/in.h>	43	#include <netinet/in.h>
53	#include <netdb.h>	44	#include <netdb.h>
54	#endif /* end win32 */
55		45
56	#ifdef HAVE_UNISTD_H
57	#include <unistd.h>	46	#include <unistd.h>
58	#endif
59
60	#ifdef HAVE_ARPA_INET_H
61	#include <arpa/inet.h>	47	#include <arpa/inet.h>
62	#endif
63		48
64	#include <loader.h>	49	#include <loader.h>
65	#include <newserver.h>	50	#include <newserver.h>
66		51
67	/*****************************************************************************	52	/*****************************************************************************
…		…
75	* before player joins, and those happen after the player has joined.	60	* before player joins, and those happen after the player has joined.
76	* As such, we have function types that might be called, so	61	* As such, we have function types that might be called, so
77	* we end up having 2 tables.	62	* we end up having 2 tables.
78	*/	63	*/
79		64
80	typedef void (func_uint8_int_ns) (char, int, NewSocket *);	65	enum {
81		66	PF_PLAYER = 0x01, // must have valid player
82	struct NsCmdMapping {	67	PF_IMMEDIATE = 0x02, // TODO: hack, can be executed immediately
83	const char *cmdname;	68	PF_PLAYING = 0x04, // must be in playing state
84	func_uint8_int_ns cmdproc;
85	};	69	};
86		70
87	typedef void (func_uint8_int_pl)(char, int, player *);	71	struct pkt_type
88	struct PlCmdMapping {	72	{
89	const char *cmdname;	73	const char *name;
90	func_uint8_int_pl cmdproc;	74	void *cb;
91	uint8 flag;	75	int flags;
		76
		77	bool may_execute (client_socket *ns)
		78	{
		79	return (!(flags & PF_PLAYER) \|\| ns->pl)
		80	&& (!(flags & PF_PLAYING) \|\| (ns->pl && ns->pl->state == ST_PLAYING));
		81	}
		82
		83	void execute (client_socket ns, char data, int datalen)
		84	{
		85	//TODO: only one format
		86	if (flags & PF_PLAYER)
		87	((void ()(char , int, player * ))cb)((char *)data, datalen, ns->pl);
		88	else
		89	((void ()(char , int, client_socket ))cb)((char )data, datalen, ns);
		90	}
92	};	91	};
93		92
		93	// SocketCommand, PlayingCommand, should not exist with those ugly casts
		94	#define SC(cb) (void )static_cast<void ()(char , int, client_socket )>(cb),
		95	#define PC(cb) (void )static_cast<void ()(char , int, player )>(cb), PF_PLAYER \|
		96
94	/**	97	/**
95	* Dispatch table for the server.	98	* Dispatch table for the server.
96	*	99	*/
97	* CmdMapping is the dispatch table for the server, used in HandleClient,	100	static struct pkt_type packets[] = {
98	* which gets called when the client has input. All commands called here	101	{"ncom", PC(NewPlayerCmd) PF_PLAYING },
99	* use the same parameter form (char* data, int len, int clientnum.	102	{"command", PC(PlayerCmd) PF_PLAYING },
100	* We do implicit casts, because the data that is being passed is
101	* unsigned (pretty much needs to be for binary data), however, most
102	* of these treat it only as strings, so it makes things easier
103	* to cast it here instead of a bunch of times in the function itself.
104	* flag is 1 if the player must be in the playing state to issue the
105	* command, 0 if they can issue it at any time.
106	*/
107	static struct PlCmdMapping plcommands[] = {
108	{ "examine", ExamineCmd, 1},
109	{ "apply", ApplyCmd, 1},
110	{ "move", MoveCmd, 1},
111	{ "reply", ReplyCmd, 0},
112	{ "command", PlayerCmd, 1},
113	{ "ncom", (func_uint8_int_pl)NewPlayerCmd, 1},
114	{ "lookat", LookAt, 1},
115	{ "lock", (func_uint8_int_pl)LockItem, 1},
116	{ "mark", (func_uint8_int_pl)MarkItem, 1},
117	{ "mapredraw", MapRedrawCmd, 0}, /* Added: phil */
118	{ "mapinfo", MapInfoCmd, 2}, /* CF+ */
119	{ "ext", ExtCmd, 2}, /* CF+ */
120	{ NULL, NULL, 0} /* terminator */
121	};
122		103
123	/** Face-related commands */	104	{"examine", PC(ExamineCmd) PF_PLAYING \| PF_IMMEDIATE },
124	static struct NsCmdMapping nscommands[] = {	105	{"apply", PC(ApplyCmd) PF_PLAYING \| PF_IMMEDIATE },
125	{ "addme", AddMeCmd },	106	{"reply", PC(ReplyCmd) PF_IMMEDIATE },
		107	{"lookat", PC(LookAt) PF_PLAYING \| PF_IMMEDIATE },
		108	{"lock", PC(LockItem) PF_PLAYING \| PF_IMMEDIATE },
		109	{"mark", PC(MarkItem) PF_PLAYING \| PF_IMMEDIATE },
		110	{"move", PC(MoveCmd) PF_PLAYING \| PF_IMMEDIATE },
		111	{"ext", PC(ExtCmd) PF_IMMEDIATE }, /* CF+ */
		112	{"mapredraw", PC(MapRedrawCmd) PF_IMMEDIATE }, /* Added: phil */
		113	{"mapinfo", PC(MapInfoCmd) PF_IMMEDIATE }, /* CF+ */
		114
		115	{"addme", SC(AddMeCmd) PF_IMMEDIATE },
126	{ "askface", SendFaceCmd}, /* Added: phil */	116	{"askface", SC(SendFaceCmd) 0 }, /* Added: phil */
127	{ "requestinfo", RequestInfo},	117	{"requestinfo", SC(RequestInfo) 0 },
128	{ "setfacemode", SetFaceMode},	118	{"setfacemode", SC(SetFaceMode) PF_IMMEDIATE },
129	{ "setsound", SetSound},	119	{"setsound", SC(SetSound) PF_IMMEDIATE },
130	{ "setup", SetUp},	120	{"setup", SC(SetUp) PF_IMMEDIATE },
131	{ "version", VersionCmd },	121	{"version", SC(VersionCmd) PF_IMMEDIATE },
132	{ "toggleextendedinfos", ToggleExtendedInfos}, /Added: tchize/	122	{"toggleextendedinfos", SC(ToggleExtendedInfos) PF_IMMEDIATE }, /Added: tchize /
133	{ "toggleextendedtext", ToggleExtendedText}, /Added: tchize/	123	{"toggleextendedtext", SC(ToggleExtendedText) PF_IMMEDIATE }, /Added: tchize /
134	{ "asksmooth", AskSmooth}, /Added: tchize (smoothing technologies)/	124	{"asksmooth", SC(AskSmooth) 0 }, /Added: tchize (smoothing technologies) /
135	{ NULL, NULL} /* terminator (I, II & III)*/
136	};	125	};
137		126
138	/**	127	/**
139	* RequestInfo is sort of a meta command. There is some specific	128	* RequestInfo is sort of a meta command. There is some specific
140	* request of information, but we call other functions to provide	129	* request of information, but we call other functions to provide
141	* that information.	130	* that information.
142	*/	131	*/
		132	void
143	void RequestInfo(char buf, int len, NewSocket ns)	133	RequestInfo (char buf, int len, client_socket ns)
144	{	134	{
145	char params=NULL, cp;	135	char params = NULL, cp;
		136
146	/* No match */	137	/* No match */
147	char bigbuf[MAX_BUF];	138	char bigbuf[MAX_BUF];
148	int slen;	139	int slen;
149		140
150	/* Set up replyinfo before we modify any of the buffers - this is used	141	/* Set up replyinfo before we modify any of the buffers - this is used
151	* if we don't find a match.	142	* if we don't find a match.
152	*/	143	*/
153	strcpy(bigbuf,"replyinfo ");	144	strcpy (bigbuf, "replyinfo ");
154	slen = strlen(bigbuf);	145	slen = strlen (bigbuf);
155	safe_strcat(bigbuf, buf, &slen, MAX_BUF);	146	safe_strcat (bigbuf, buf, &slen, MAX_BUF);
156		147
157	/* find the first space, make it null, and update the	148	/* find the first space, make it null, and update the
158	* params pointer.	149	* params pointer.
159	*/	150	*/
160	for (cp = buf; *cp != '\0'; cp++)	151	for (cp = buf; *cp != '\0'; cp++)
161	if (*cp==' ') {	152	if (*cp == ' ')
		153	{
162	*cp = '\0';	154	*cp = '\0';
163	params = cp + 1;	155	params = cp + 1;
164	break;	156	break;
165	}	157	}
166	if (!strcmp(buf, "image_info")) send_image_info(ns, params);	158
167	else if (!strcmp(buf,"image_sums")) send_image_sums(ns, params);	159	if (!strcmp (buf, "image_info"))
168	else if (!strcmp(buf,"skill_info")) send_skill_info(ns, params);	160	send_image_info (ns, params);
169	else if (!strcmp(buf,"spell_paths")) send_spell_paths(ns, params);	161	else if (!strcmp (buf, "image_sums"))
170	else Write_String_To_Socket(ns, bigbuf, len);	162	send_image_sums (ns, params);
		163	else if (!strcmp (buf, "skill_info"))
		164	send_skill_info (ns, params);
		165	else if (!strcmp (buf, "spell_paths"))
		166	send_spell_paths (ns, params);
		167	else
		168	ns->send_packet (bigbuf, len);
171	}	169	}
172
173	/**
174	* Handles old socket format.
175	*/
176	void Handle_Oldsocket(NewSocket *ns)
177	{
178	int stat,i;
179	CommFunc command;
180	char buf[MAX_BUF],*cp;
181	object ob;
182	player pl;
183
184	/* This is not the most efficient block, but keeps the code simpler -
185	* we basically read a byte at a time until we get a newline, error,
186	* or no more characters to read.
187	*/
188	do {
189	/* hack to disable old socket mode without creating too many conflicts */
190	if (1 \|\| ns->inbuf.len >= MAXSOCKBUF-1) {
191	ns->status = Ns_Dead;
192	LOG(llevDebug, "Old input socket sent too much data without newline\n");
193	return;
194	}
195	#ifdef WIN32 /* **win32: change oldsocket read() to recv() /
196	stat = recv(ns->fd, ns->inbuf.buf + ns->inbuf.len, 1,0);
197
198	if (stat==-1 && WSAGetLastError() !=WSAEWOULDBLOCK) {
199	#else
200	do {
201	stat = read(ns->fd, ns->inbuf.buf + ns->inbuf.len, 1);
202	} while ((stat<0) && (errno == EINTR));
203
204	if (stat<0 && errno != EAGAIN && errno !=EWOULDBLOCK) {
205	#endif
206	LOG(llevError, "Cannot read from socket: %s\n", strerror_local(errno));
207	ns->status = Ns_Dead;
208	return;
209	}
210	if (stat == 0) return;
211	} while (ns->inbuf.buf[ns->inbuf.len++]!='\n');
212
213	ns->inbuf.buf[ns->inbuf.len]=0;
214
215	cp = strchr((const char*)ns->inbuf.buf, ' ');
216	if (cp) {
217	/* Replace the space with a null, skip any more spaces */
218	*cp++=0;
219	while (isspace(*cp)) cp++;
220	}
221
222	/* Strip off all spaces and control characters from end of line */
223	for (i=ns->inbuf.len-1; i>=0; i--) {
224	if (ns->inbuf.buf[i]<=32) ns->inbuf.buf[i]=0;
225	else break;
226	}
227	ns->inbuf.len=0; /* reset for next read */
228
229	/* If just a return, don't do anything */
230	if (ns->inbuf.buf[0] == 0) return;
231	if (!strcasecmp((const char*)ns->inbuf.buf,"quit")) {
232	ns->status = Ns_Dead;
233	return;
234	}
235	if (!strcasecmp((const char*)ns->inbuf.buf, "listen")) {
236	if (cp) {
237	char *buf="Socket switched to listen mode\n";
238
239	free(ns->comment);
240	ns->comment = strdup_local(cp);
241	ns->old_mode = Old_Listen;
242	cs_write_string(ns, buf, strlen(buf));
243	} else {
244	char *buf="Need to supply a comment/url to listen\n";
245	cs_write_string(ns, buf, strlen(buf));
246	}
247	return;
248	}
249	if (!strcasecmp((const char*)ns->inbuf.buf, "name")) {
250	char *cp1=NULL;
251	if (cp) cp1= strchr(cp, ' ');
252	if (cp1) {
253	*cp1++ = 0;
254	while (isspace(*cp1)) cp1++;
255	}
256	if (!cp \|\| !cp1) {
257	char *buf="Need to provide a name/password to name\n";
258	cs_write_string(ns, buf, strlen(buf));
259	return;
260	}
261
262	if (verify_player(cp, cp1)==0) {
263	char *buf="Welcome back\n";
264	free(ns->comment);
265	ns->comment = strdup_local(cp);
266	ns->old_mode = Old_Player;
267	cs_write_string(ns, buf, strlen(buf));
268	}
269	else if (verify_player(cp, cp1)==2) {
270	ns->password_fails++;
271	if (ns->password_fails >= MAX_PASSWORD_FAILURES) {
272	char *buf="You failed to log in too many times, you will now be kicked.\n";
273	LOG(llevInfo, "A player connecting from %s in oldsocketmode has been dropped for password failure\n",
274	ns->host);
275	cs_write_string(ns, buf, strlen(buf));
276	ns->status = Ns_Dead;
277	}
278	else {
279	char *buf="Could not login you in. Check your name and password.\n";
280	cs_write_string(ns, buf, strlen(buf));
281	}
282	}
283	else {
284	char *buf="Could not login you in. Check your name and password.\n";
285	cs_write_string(ns, buf, strlen(buf));
286	}
287	return;
288	}
289
290	command = find_oldsocket_command((char*)ns->inbuf.buf);
291	if (!command && ns->old_mode==Old_Player) {
292	command = find_oldsocket_command2((char*)ns->inbuf.buf);
293	}
294	if (!command) {
295	snprintf(buf, sizeof(buf), "Could not find command: %s\n", ns->inbuf.buf);
296	cs_write_string(ns, buf, strlen(buf));
297	return;
298	}
299
300	/* This is a bit of a hack, but works. Basically, we make some
301	* fake object and player pointers and give at it.
302	* This works as long as the functions we are calling don't need
303	* to do anything to the object structure (ie, they are only
304	* outputting information and not actually updating anything much.)
305	*/
306	ob.contr = &pl;
307	pl.ob = &ob;
308	ob.type = PLAYER;
309	pl.listening = 10;
310	pl.socket = *ns;
311	pl.outputs_count = 1;
312	ob.name = ns->comment;
313
314	command(&ob, cp);
315	}
316
317		170
318	/**	171	/**
319	* Handle client input.	172	* Handle client input.
320	*	173	*
321	* HandleClient is actually not named really well - we only get here once	174	* HandleClient is actually not named really well - we only get here once
…		…
323	* sock is the output socket information. pl is the player associated	176	* sock is the output socket information. pl is the player associated
324	* with this socket, null if no player (one of the init_sockets for just	177	* with this socket, null if no player (one of the init_sockets for just
325	* starting a connection)	178	* starting a connection)
326	*/	179	*/
327		180
		181	void
328	void HandleClient(NewSocket ns, player pl)	182	HandleClient (client_socket ns, player pl)
329	{	183	{
330	int len=0,i,cnt;
331	char *data;
332
333	/* Loop through this - maybe we have several complete packets here. */	184	/* Loop through this - maybe we have several complete packets here. */
334	// limit to a few commands only, though, as to not monopolise the server	185	// limit to a few commands only, though, as to not monopolise the server
335	for (cnt = 16; cnt--; ) {	186	for (int repeat = 16; repeat--;)
		187	{
336	/* If it is a player, and they don't have any speed left, we	188	/* If it is a player, and they don't have any speed left, we
337	* return, and will read in the data when they do have time.	189	* return, and will read in the data when they do have time.
338	*/	190	*/
339	if (pl && pl->state==ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0) {	191	if (pl && pl->state == ST_PLAYING && pl->ob && pl->ob->speed_left < 0)
340	return;	192	return;
341	}
342
343	if (ns->status == Ns_Old) {
344	Handle_Oldsocket(ns);
345	return;
346	}
347	i=SockList_ReadPacket(ns->fd, &ns->inbuf, MAXSOCKBUF-1);
348	/* Special hack - let the user switch to old mode if in the Ns_Add
349	* phase. Don't demand they add in the special length bytes
350	*/
351	if (ns->status == Ns_Add) {
352	if (!strncasecmp((const char*)ns->inbuf.buf,"oldsocketmode", 13)) {
353	ns->status = Ns_Old;
354	ns->inbuf.len=0;
355	cs_write_string(ns, "Switched to old socket mode\n", 28);
356	LOG(llevDebug,"Switched socket to old socket mode\n");
357	return;
358	}
359	}
360		193
361	if (i<0) {	194	int pkt_len = ns->read_packet ();
362	#ifdef ESRV_DEBUG	195
363	LOG(llevDebug,"HandleClient: Read error on connection player %s\n", (pl?pl->ob->name:"None"));	196	if (pkt_len < 0)
364	#endif	197	{
		198	LOG (llevError, "read error on player %s\n", &pl->ob->name);
365	/* Caller will take care of cleaning this up */	199	/* Caller will take care of cleaning this up */
366	ns->status =Ns_Dead;	200	ns->status = Ns_Dead;
367	return;	201	return;
368	}	202	}
		203	else if (pkt_len == 0)
369	/* Still dont have a full packet */	204	/* Still dont have a full packet */
370	if (i==0) return;	205	return;
371		206
372	// //D//TODO//temporarily log long commands
373	// if (ns->inbuf.len >= 40 && pl && pl->ob)
374	// LOG (llevDebug, "HandleClient: long comamnd from <%s,%s> %d<%s>\n", pl->ob->name, ns->host, ns->inbuf.len, ns->inbuf.buf + 2);
375
376	/* First, break out beginning word. There are at least	207	/* First, break out beginning word. There are at least
377	* a few commands that do not have any paremeters. If	208	* a few commands that do not have any paremeters. If
378	* we get such a command, don't worry about trying	209	* we get such a command, don't worry about trying
379	* to break it up.	210	* to break it up.
380	*/	211	*/
381	data = (char )strchr((char)ns->inbuf.buf +2, ' ');	212	int datalen;
382	if (data) {	213	char data = strchr ((char )ns->inbuf + 2, ' ');
383	*data='\0';
384	data++;
385	len = ns->inbuf.len - (data - (char*)ns->inbuf.buf);
386	}
387	else len=0;
388		214
		215	if (data)
		216	{
		217	*data++ = 0;
		218	datalen = pkt_len - (data - (char *)ns->inbuf);
		219	}
		220	else
		221	{
		222	data = (char *)ns->inbuf + 2; // better read garbage than segfault
		223	datalen = 0;
		224	}
		225
389	ns->inbuf.buf[ns->inbuf.len]='\0'; /* Terminate buffer - useful for string data */	226	ns->inbuf [pkt_len] = 0; /* Terminate buffer - useful for string data */
390	for (i=0; nscommands[i].cmdname !=NULL; i++) {	227
391	if (strcmp((char*)ns->inbuf.buf+2,nscommands[i].cmdname)==0) {	228	for (pkt_type *pkt = packets; pkt < packets + (sizeof (packets) / sizeof (packets[0])); ++pkt)
392	nscommands[i].cmdproc((char*)data,len,ns);	229	if (!strcmp ((char *)ns->inbuf + 2, pkt->name))
393	ns->inbuf.len=0;	230	{
394	return;//D// not doing this causes random memory corruption	231	if (pkt->may_execute (ns))
395	goto next_packet;	232	{
396	}	233	pkt->execute (ns, data, datalen);
397	}	234	ns->skip_packet (pkt_len);
398	/* Player must be in the playing state or the flag on the
399	* the command must be zero for the user to use the command -
400	* otherwise, a player cam save, be in the play_again state, and
401	* the map they were on gets swapped out, yet things that try to look
402	* at the map causes a crash. If the command is valid, but
403	* one they can't use, we still swallow it up.
404	*/
405	if (pl) for (i=0; plcommands[i].cmdname !=NULL; i++) {
406	if (strcmp((char*)ns->inbuf.buf+2,plcommands[i].cmdname)==0) {
407	if (pl->state == ST_PLAYING \|\| !(plcommands[i].flag & 1))
408	plcommands[i].cmdproc((char*)data,len,pl);
409	ns->inbuf.len=0;
410	//D// not doing this causes random memory corruption	235	//D//TODO not doing this causes random memory corruption
411	if (plcommands[i].flag & 2)	236	if (pkt->flags & PF_IMMEDIATE)
412	goto next_packet;	237	goto next_packet;
413	return;	238	return;
414	}	239	}
415	}	240	}
		241
416	/* If we get here, we didn't find a valid command. Logging	242	/* If we get here, we didn't find a valid command. Logging
417	* this might be questionable, because a broken client/malicious	243	* this might be questionable, because a broken client/malicious
418	* user could certainly send a whole bunch of invalid commands.	244	* user could certainly send a whole bunch of invalid commands.
419	*/	245	*/
420	LOG(llevDebug,"Bad command from client (%s)\n",ns->inbuf.buf+2);	246	LOG (llevDebug, "Bad command from client (%s)\n", ns->inbuf + 2);
		247	ns->skip_packet (pkt_len);
421	next_packet:	248	next_packet:
422	;	249	;
423	}	250	}
424	}	251	}
425		252
426		253	void
427	/*****************************************************************************	254	flush_sockets (void)
428	*
429	* Low level socket looping - select calls and watchdog udp packet
430	* sending.
431	*
432	******************************************************************************/
433
434	#ifdef WATCHDOG
435	/**
436	* Tell watchdog that we are still alive
437	*
438	* I put the function here since we should hopefully already be getting
439	* all the needed include files for socket support
440	*/
441
442	void watchdog(void)
443	{	255	{
444	static int fd=-1;	256	for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)
445	static struct sockaddr_in insock;	257	if ((*i)->status != Ns_Dead)
446		258	(*i)->flush ();
447	if (fd==-1)
448	{
449	struct protoent *protoent;
450
451	if ((protoent=getprotobyname("udp"))==NULL \|\|
452	(fd=socket(PF_INET, SOCK_DGRAM, protoent->p_proto))==-1)
453	{
454	return;
455	}
456	insock.sin_family=AF_INET;
457	insock.sin_port=htons((unsigned short)13325);
458	insock.sin_addr.s_addr=inet_addr("127.0.0.1");
459	}
460	sendto(fd,(void )&fd,1,0,(struct sockaddr )&insock,sizeof(insock));
461	}	259	}
462	#endif
463		260
464	extern unsigned long todtick;
465
466	/** Waits for new connection */
467	static void block_until_new_connection(void)
468	{
469
470	struct timeval Timeout;
471	fd_set readfs;
472	int cycles;
473
474	LOG(llevInfo, "Waiting for connections...\n");
475
476	cycles=1;
477	do {
478	/* Every minutes is a bit often for updates - especially if nothing is going
479	* on. This slows it down to every 6 minutes.
480	*/
481	cycles++;
482	if (cycles%2 == 0)
483	tick_the_clock();
484
485	FD_ZERO(&readfs);
486	FD_SET((uint32)init_sockets[0].fd, &readfs);
487
488	/* If fastclock is set, we need to seriously slow down the updates
489	* to the metaserver as well as watchdog. Do same for flush_old_maps() -
490	* that is time sensitive, so there is no good reason to call it 2000 times
491	* a second.
492	*/
493	if (settings.fastclock > 0) {
494	#ifdef WATCHDOG
495	if (cycles % 120000 == 0) {
496	watchdog();
497	flush_old_maps();
498	}
499	#endif
500	if (cycles == 720000) {
501	metaserver_update();
502	cycles=1;
503	}
504	Timeout.tv_sec=0;
505	Timeout.tv_usec=50;
506	} else {
507	Timeout.tv_sec=60;
508	Timeout.tv_usec=0;
509	if (cycles == 7) {
510	metaserver_update();
511	cycles=1;
512	}
513	flush_old_maps();
514	}
515	}
516	while (select(socket_info.max_filedescriptor, &readfs, NULL, NULL, &Timeout)==0);
517
518	reset_sleep(); /* Or the game would go too fast */
519	}
520
521	void flush_sockets(void)
522	{
523	player *pl;
524
525	for (pl = first_player; pl != NULL; pl = pl->next)
526	if (pl->socket.status != Ns_Dead)
527	Socket_Flush (&pl->socket);
528	}
529
530	/**	261	/**
531	* This checks the sockets for input and exceptions, does the right thing.	262	* This checks the sockets for input, does the right thing.
532	*	263	*
533	* A bit of this code is grabbed out of socket.c	264	* A bit of this code is grabbed out of socket.c
534	* There are 2 lists we need to look through - init_sockets is a list	265	* There are 2 lists we need to look through - init_sockets is a list
535	*	266	*
536	*/	267	*/
		268	void
537	void doeric_server(void)	269	doeric_server (void)
538	{	270	{
539	int i, pollret;	271	int i, pollret;
540	fd_set tmp_read, tmp_exceptions, tmp_write;	272	fd_set tmp_read;
541	struct sockaddr_in addr;	273	struct sockaddr_in addr;
542	socklen_t addrlen=sizeof(struct sockaddr);	274	socklen_t addrlen = sizeof (struct sockaddr);
543	player pl, next;	275	player pl, next;
		276	int maxfd = 0;
544		277
545	#ifdef CS_LOGSTATS	278	#ifdef CS_LOGSTATS
546	if ((time(NULL)-cst_lst.time_start)>=CS_LOGTIME)	279	if ((time (NULL) - cst_lst.time_start) >= CS_LOGTIME)
547	write_cs_stats();	280	write_cs_stats ();
548	#endif	281	#endif
549		282
550	FD_ZERO(&tmp_read);
551	FD_ZERO(&tmp_write);
552	FD_ZERO(&tmp_exceptions);
553
554	for(i=0;i<socket_info.allocated_sockets;i++) {
555	if (init_sockets[i].status == Ns_Dead) {
556	free_newsocket(&init_sockets[i]);
557	init_sockets[i].status = Ns_Avail;
558	socket_info.nconns--;
559	} else if (init_sockets[i].status != Ns_Avail){
560	FD_SET((uint32)init_sockets[i].fd, &tmp_read);
561	FD_SET((uint32)init_sockets[i].fd, &tmp_write);
562	FD_SET((uint32)init_sockets[i].fd, &tmp_exceptions);
563	}
564	}
565
566	/* Go through the players. Let the loop set the next pl value,	283	/* Go through the players. Let the loop set the next pl value,
567	* since we may remove some	284	* since we may remove some
568	*/	285	*/
		286	//TODO: must be handled cleanly elsewhere
569	for (pl=first_player; pl!=NULL; ) {	287	for (pl = first_player; pl; )
570	if (pl->socket.status == Ns_Dead) {	288	{
571	player *npl=pl->next;	289	player *npl = pl->next;
572		290
		291	//TODO: must be handled cleanly elsewhere
		292	if (pl->socket->status == Ns_Dead)
		293	{
573	save_player(pl->ob, 0);	294	save_player (pl->ob, 0);
		295
574	if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) {	296	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
		297	{
575	terminate_all_pets(pl->ob);	298	terminate_all_pets (pl->ob);
576	remove_ob(pl->ob);	299	pl->ob->remove ();
		300	}
		301
		302	leave (pl, 1);
		303	final_free_player (pl);
		304	}
		305
		306	pl = npl;
577	}	307	}
578	leave(pl,1);	308
579	final_free_player(pl);	309	FD_ZERO (&tmp_read);
580	pl=npl;	310
581	}	311	for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); )
582	else {
583	FD_SET((uint32)pl->socket.fd, &tmp_read);
584	FD_SET((uint32)pl->socket.fd, &tmp_write);
585	FD_SET((uint32)pl->socket.fd, &tmp_exceptions);
586	pl=pl->next;
587	}
588	}	312	{
		313	client_socket s = i;
589		314
590	#if 0	315	if (s->status == Ns_Dead)
591	// the event system and plugins require the server ti run at all times.	316	{
592	// since its primarily cf.schmorp.de we are interested in, and	317	client_sockets.erase (i);
593	// that is supposed to run all the time anyway, its globally disabled	318	delete s;
594	// until we can use Event.	319	}
595	if (socket_info.nconns==1 && first_player==NULL)	320	else
596	block_until_new_connection();	321	{
597	#endif	322	if (s->fd > maxfd) maxfd = s->fd;
598		323
599	/* Reset timeout each time, since some OS's will change the values on	324	FD_SET (s->fd, &tmp_read);
600	* the return from select.	325
601	*/	326	++i;
602	socket_info.timeout.tv_sec = 0;	327	}
		328	}
		329
		330	struct timeval timeout;
		331
		332	timeout.tv_sec = 0;
603	socket_info.timeout.tv_usec = 0;	333	timeout.tv_usec = 0;
604		334
605	pollret= select(socket_info.max_filedescriptor, &tmp_read, &tmp_write,	335	pollret = select (maxfd + 1,
606	&tmp_exceptions, &socket_info.timeout);	336	&tmp_read, 0, 0,
		337	&timeout);
607		338
608	if (pollret==-1) {	339	if (pollret == -1)
		340	{
609	LOG(llevError, "select failed: %s\n", strerror_local(errno));	341	LOG (llevError, "select failed: %s\n", strerror (errno));
610	return;	342	return;
611	}	343	}
612		344
613	/* We need to do some of the processing below regardless */	345	/* We need to do some of the processing below regardless */
614	/* if (!pollret) return;*/
615		346
616	/* Following adds a new connection */
617	if (pollret && FD_ISSET(init_sockets[0].fd, &tmp_read)) {
618	int newsocknum=0;
619
620	#ifdef ESRV_DEBUG
621	LOG(llevDebug,"doeric_server: New Connection\n");
622	#endif
623	/* If this is the case, all sockets currently in used */
624	if (socket_info.allocated_sockets <= socket_info.nconns) {
625	init_sockets = (NewSocket ) realloc(init_sockets,sizeof(NewSocket)(socket_info.nconns+1));
626	if (!init_sockets) fatal(OUT_OF_MEMORY);
627	newsocknum = socket_info.allocated_sockets;
628	socket_info.allocated_sockets++;
629	init_sockets[newsocknum].faces_sent_len = nrofpixmaps;
630	init_sockets[newsocknum].faces_sent = (uint8) malloc(nrofpixmapssizeof(*init_sockets[newsocknum].faces_sent));
631	if (!init_sockets[newsocknum].faces_sent) fatal(OUT_OF_MEMORY);
632	init_sockets[newsocknum].status = Ns_Avail;
633	}
634	else {
635	int j;
636
637	for (j=1; j<socket_info.allocated_sockets; j++)
638	if (init_sockets[j].status == Ns_Avail) {
639	newsocknum=j;
640	break;
641	}
642	}
643	init_sockets[newsocknum].fd=accept(init_sockets[0].fd, (struct sockaddr *)&addr, &addrlen);
644	if (init_sockets[newsocknum].fd==-1) {
645	LOG(llevError, "accept failed: %s\n", strerror_local(errno));
646	}
647	else {
648	char buf[MAX_BUF];
649	long ip;
650	NewSocket *ns;
651
652	ns = &init_sockets[newsocknum];
653
654	ip = ntohl(addr.sin_addr.s_addr);
655	sprintf(buf, "%ld.%ld.%ld.%ld", (ip>>24)&255, (ip>>16)&255, (ip>>8)&255, ip&255);
656
657	if (checkbanned(NULL, buf)) {
658	LOG(llevInfo, "Banned host tried to connect: [%s]\n", buf);
659	close(init_sockets[newsocknum].fd);
660	init_sockets[newsocknum].fd = -1;
661	}
662	else {
663	InitConnection(ns, buf);
664	socket_info.nconns++;
665	}
666	}
667	}
668
669	/* Check for any exceptions/input on the sockets */	347	/* Check for any input on the sockets */
670	if (pollret) for(i=1;i<socket_info.allocated_sockets;i++) {	348	for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)
671	if (init_sockets[i].status == Ns_Avail) continue;
672	if (FD_ISSET(init_sockets[i].fd,&tmp_exceptions)) {
673	free_newsocket(&init_sockets[i]);
674	init_sockets[i].status = Ns_Avail;
675	socket_info.nconns--;
676	continue;
677	}
678	if (FD_ISSET(init_sockets[i].fd, &tmp_read)) {
679	HandleClient(&init_sockets[i], NULL);
680	}
681	if (FD_ISSET(init_sockets[i].fd, &tmp_write)) {
682	init_sockets[i].can_write=1;
683	}
684	}	349	{
		350	client_socket s = i;
		351	player *pl = s->pl;
685		352
686	/* This does roughly the same thing, but for the players now */	353	//TODO: disassociate handleclient from socket readin
687	for (pl=first_player; pl!=NULL; pl=next) {	354	if (s->inbuf_len \|\| FD_ISSET (s->fd, &tmp_read))
688
689	next=pl->next;
690	if (pl->socket.status==Ns_Dead) continue;
691
692	if (FD_ISSET(pl->socket.fd,&tmp_write)) {
693	if (!pl->socket.can_write) {
694	#if 0
695	LOG(llevDebug,"Player %s socket now write enabled\n", pl->ob->name);
696	#endif
697	pl->socket.can_write=1;
698	write_socket_buffer(&pl->socket);
699	}
700	/* if we get an error on the write_socket buffer, no reason to
701	* continue on this socket.
702	*/
703	if (pl->socket.status==Ns_Dead) continue;
704	}
705	else pl->socket.can_write=0;
706
707	if (FD_ISSET(pl->socket.fd,&tmp_exceptions)) {
708	save_player(pl->ob, 0);
709	if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) {
710	terminate_all_pets(pl->ob);
711	remove_ob(pl->ob);
712	}
713	leave(pl,1);
714	final_free_player(pl);
715	}
716	else {
717	HandleClient(&pl->socket, pl);	355	HandleClient (s, pl);
718	/* If the player has left the game, then the socket status
719	* will be set to this be the leave function. We don't
720	* need to call leave again, as it has already been called
721	* once.
722	*/
723	if (pl->socket.status==Ns_Dead) {
724	save_player(pl->ob, 0);
725	if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) {
726	terminate_all_pets(pl->ob);
727	remove_ob(pl->ob);
728	}
729	leave(pl,1);
730	final_free_player(pl);
731	} else {
732		356
		357	//TODO: should not be done here, either
		358	if (s->status != Ns_Dead && pl)
		359	{
733	/* Update the players stats once per tick. More efficient than	360	/* Update the players stats once per tick. More efficient than
734	* sending them whenever they change, and probably just as useful	361	* sending them whenever they change, and probably just as useful
735	*/	362	*/
736	esrv_update_stats(pl);	363	esrv_update_stats (pl);
737	if (pl->last_weight != -1 && pl->last_weight != WEIGHT(pl->ob)) {	364	if (pl->last_weight != -1 && pl->last_weight != WEIGHT (pl->ob))
		365	{
738	esrv_update_item(UPD_WEIGHT, pl->ob, pl->ob);	366	esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
739	if(pl->last_weight != WEIGHT(pl->ob))	367	if (pl->last_weight != WEIGHT (pl->ob))
740	LOG(llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n", (unsigned long)pl->last_weight, WEIGHT(pl->ob));	368	LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
741	}	369	(unsigned long) pl->last_weight, WEIGHT (pl->ob));
		370	}
		371
742	/* draw_client_map does sanity checking that map is	372	/* draw_client_map does sanity checking that map is
743	* valid, so don't do it here.	373	* valid, so don't do it here.
744	*/	374	*/
745	draw_client_map(pl->ob);	375	draw_client_map (pl->ob);
746	if (pl->socket.update_look) esrv_draw_look(pl->ob);	376	if (s->update_look)
747	}	377	esrv_draw_look (pl->ob);
748	}	378	}
749	}	379	}
750	}	380	}
		381

Diff Legend

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

Comparing deliantra/server/socket/loop.C (file contents): Revision 1.1 by elmex, Sun Aug 13 17:16:06 2006 UTC vs. Revision 1.17 by root, Fri Dec 15 03:53:44 2006 UTC

Diff Legend

Comparing deliantra/server/socket/loop.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:06 2006 UTC vs.
Revision 1.17 by root, Fri Dec 15 03:53:44 2006 UTC