1 |
|
2 |
/* |
3 |
* static char *rcsid_loop_c = |
4 |
* "$Id$"; |
5 |
*/ |
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 |
|
30 |
/** |
31 |
* \file |
32 |
* Main client/server loops. |
33 |
* |
34 |
* \date 2003-12-02 |
35 |
* |
36 |
* loop.c mainly deals with initialization and higher level socket |
37 |
* maintenance (checking for lost connections and if data has arrived.) |
38 |
* The reading of data is handled in ericserver.c |
39 |
*/ |
40 |
|
41 |
|
42 |
#include <global.h> |
43 |
#ifndef __CEXTRACT__ |
44 |
#include <sproto.h> |
45 |
#include <sockproto.h> |
46 |
#endif |
47 |
|
48 |
#ifndef WIN32 /* ---win32 exclude unix headers */ |
49 |
#include <sys/types.h> |
50 |
#include <sys/time.h> |
51 |
#include <sys/socket.h> |
52 |
#include <netinet/in.h> |
53 |
#include <netdb.h> |
54 |
#endif /* end win32 */ |
55 |
|
56 |
#ifdef HAVE_UNISTD_H |
57 |
#include <unistd.h> |
58 |
#endif |
59 |
|
60 |
#ifdef HAVE_ARPA_INET_H |
61 |
#include <arpa/inet.h> |
62 |
#endif |
63 |
|
64 |
#include <loader.h> |
65 |
#include <newserver.h> |
66 |
|
67 |
/***************************************************************************** |
68 |
* Start of command dispatch area. |
69 |
* The commands here are protocol commands. |
70 |
****************************************************************************/ |
71 |
|
72 |
/* Either keep this near the start or end of the file so it is |
73 |
* at least reasonablye easy to find. |
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 |
|
80 |
typedef void (*func_uint8_int_ns) (char*, int, NewSocket *); |
81 |
|
82 |
struct NsCmdMapping { |
83 |
const char *cmdname; |
84 |
func_uint8_int_ns cmdproc; |
85 |
}; |
86 |
|
87 |
typedef void (*func_uint8_int_pl)(char*, int, player *); |
88 |
struct PlCmdMapping { |
89 |
const char *cmdname; |
90 |
func_uint8_int_pl cmdproc; |
91 |
uint8 flag; |
92 |
}; |
93 |
|
94 |
/** |
95 |
* Dispatch table for the server. |
96 |
* |
97 |
* CmdMapping is the dispatch table for the server, used in HandleClient, |
98 |
* which gets called when the client has input. All commands called here |
99 |
* use the same parameter form (char* data, int len, int clientnum. |
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 |
|
123 |
/** Face-related commands */ |
124 |
static struct NsCmdMapping nscommands[] = { |
125 |
{ "addme", AddMeCmd }, |
126 |
{ "askface", SendFaceCmd}, /* Added: phil */ |
127 |
{ "requestinfo", RequestInfo}, |
128 |
{ "setfacemode", SetFaceMode}, |
129 |
{ "setsound", SetSound}, |
130 |
{ "setup", SetUp}, |
131 |
{ "version", VersionCmd }, |
132 |
{ "toggleextendedinfos", ToggleExtendedInfos}, /*Added: tchize*/ |
133 |
{ "toggleextendedtext", ToggleExtendedText}, /*Added: tchize*/ |
134 |
{ "asksmooth", AskSmooth}, /*Added: tchize (smoothing technologies)*/ |
135 |
{ NULL, NULL} /* terminator (I, II & III)*/ |
136 |
}; |
137 |
|
138 |
/** |
139 |
* RequestInfo is sort of a meta command. There is some specific |
140 |
* request of information, but we call other functions to provide |
141 |
* that information. |
142 |
*/ |
143 |
void RequestInfo(char *buf, int len, NewSocket *ns) |
144 |
{ |
145 |
char *params=NULL, *cp; |
146 |
/* No match */ |
147 |
char bigbuf[MAX_BUF]; |
148 |
int slen; |
149 |
|
150 |
/* Set up replyinfo before we modify any of the buffers - this is used |
151 |
* if we don't find a match. |
152 |
*/ |
153 |
strcpy(bigbuf,"replyinfo "); |
154 |
slen = strlen(bigbuf); |
155 |
safe_strcat(bigbuf, buf, &slen, MAX_BUF); |
156 |
|
157 |
/* find the first space, make it null, and update the |
158 |
* params pointer. |
159 |
*/ |
160 |
for (cp = buf; *cp != '\0'; cp++) |
161 |
if (*cp==' ') { |
162 |
*cp = '\0'; |
163 |
params = cp + 1; |
164 |
break; |
165 |
} |
166 |
if (!strcmp(buf, "image_info")) send_image_info(ns, params); |
167 |
else if (!strcmp(buf,"image_sums")) send_image_sums(ns, params); |
168 |
else if (!strcmp(buf,"skill_info")) send_skill_info(ns, params); |
169 |
else if (!strcmp(buf,"spell_paths")) send_spell_paths(ns, params); |
170 |
else Write_String_To_Socket(ns, bigbuf, len); |
171 |
} |
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(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(ns->inbuf.buf,"quit")) { |
232 |
ns->status = Ns_Dead; |
233 |
return; |
234 |
} |
235 |
if (!strcasecmp(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(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(ns->inbuf.buf); |
291 |
if (!command && ns->old_mode==Old_Player) { |
292 |
command = find_oldsocket_command2(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 |
|
318 |
/** |
319 |
* Handle client input. |
320 |
* |
321 |
* HandleClient is actually not named really well - we only get here once |
322 |
* there is input, so we don't do exception or other stuff here. |
323 |
* 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 |
325 |
* starting a connection) |
326 |
*/ |
327 |
|
328 |
void HandleClient(NewSocket *ns, player *pl) |
329 |
{ |
330 |
int len=0,i,cnt; |
331 |
unsigned char *data; |
332 |
|
333 |
/* Loop through this - maybe we have several complete packets here. */ |
334 |
// limit to a few commands only, though, as to not monopolise the server |
335 |
for (cnt = 16; cnt--; ) { |
336 |
/* 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. |
338 |
*/ |
339 |
if (pl && pl->state==ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0) { |
340 |
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(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 |
|
361 |
if (i<0) { |
362 |
#ifdef ESRV_DEBUG |
363 |
LOG(llevDebug,"HandleClient: Read error on connection player %s\n", (pl?pl->ob->name:"None")); |
364 |
#endif |
365 |
/* Caller will take care of cleaning this up */ |
366 |
ns->status =Ns_Dead; |
367 |
return; |
368 |
} |
369 |
/* Still dont have a full packet */ |
370 |
if (i==0) return; |
371 |
|
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 |
377 |
* a few commands that do not have any paremeters. If |
378 |
* we get such a command, don't worry about trying |
379 |
* to break it up. |
380 |
*/ |
381 |
data = (unsigned char *)strchr((char*)ns->inbuf.buf +2, ' '); |
382 |
if (data) { |
383 |
*data='\0'; |
384 |
data++; |
385 |
len = ns->inbuf.len - (data - ns->inbuf.buf); |
386 |
} |
387 |
else len=0; |
388 |
|
389 |
ns->inbuf.buf[ns->inbuf.len]='\0'; /* Terminate buffer - useful for string data */ |
390 |
for (i=0; nscommands[i].cmdname !=NULL; i++) { |
391 |
if (strcmp((char*)ns->inbuf.buf+2,nscommands[i].cmdname)==0) { |
392 |
nscommands[i].cmdproc((char*)data,len,ns); |
393 |
ns->inbuf.len=0; |
394 |
return;//D// not doing this causes random memory corruption |
395 |
goto next_packet; |
396 |
} |
397 |
} |
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 |
411 |
if (plcommands[i].flag & 2) |
412 |
goto next_packet; |
413 |
return; |
414 |
} |
415 |
} |
416 |
/* If we get here, we didn't find a valid command. Logging |
417 |
* this might be questionable, because a broken client/malicious |
418 |
* user could certainly send a whole bunch of invalid commands. |
419 |
*/ |
420 |
LOG(llevDebug,"Bad command from client (%s)\n",ns->inbuf.buf+2); |
421 |
next_packet: |
422 |
; |
423 |
} |
424 |
} |
425 |
|
426 |
|
427 |
/***************************************************************************** |
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 |
{ |
444 |
static int fd=-1; |
445 |
static struct sockaddr_in insock; |
446 |
|
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 |
} |
462 |
#endif |
463 |
|
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 |
/** |
531 |
* This checks the sockets for input and exceptions, does the right thing. |
532 |
* |
533 |
* 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 |
535 |
* |
536 |
*/ |
537 |
void doeric_server(void) |
538 |
{ |
539 |
int i, pollret; |
540 |
fd_set tmp_read, tmp_exceptions, tmp_write; |
541 |
struct sockaddr_in addr; |
542 |
socklen_t addrlen=sizeof(struct sockaddr); |
543 |
player *pl, *next; |
544 |
|
545 |
#ifdef CS_LOGSTATS |
546 |
if ((time(NULL)-cst_lst.time_start)>=CS_LOGTIME) |
547 |
write_cs_stats(); |
548 |
#endif |
549 |
|
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, |
567 |
* since we may remove some |
568 |
*/ |
569 |
for (pl=first_player; pl!=NULL; ) { |
570 |
if (pl->socket.status == Ns_Dead) { |
571 |
player *npl=pl->next; |
572 |
|
573 |
save_player(pl->ob, 0); |
574 |
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
575 |
terminate_all_pets(pl->ob); |
576 |
remove_ob(pl->ob); |
577 |
} |
578 |
leave(pl,1); |
579 |
final_free_player(pl); |
580 |
pl=npl; |
581 |
} |
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 |
} |
589 |
|
590 |
#if 0 |
591 |
// the event system and plugins require the server ti run at all times. |
592 |
// since its primarily cf.schmorp.de we are interested in, and |
593 |
// that is supposed to run all the time anyway, its globally disabled |
594 |
// until we can use Event. |
595 |
if (socket_info.nconns==1 && first_player==NULL) |
596 |
block_until_new_connection(); |
597 |
#endif |
598 |
|
599 |
/* Reset timeout each time, since some OS's will change the values on |
600 |
* the return from select. |
601 |
*/ |
602 |
socket_info.timeout.tv_sec = 0; |
603 |
socket_info.timeout.tv_usec = 0; |
604 |
|
605 |
pollret= select(socket_info.max_filedescriptor, &tmp_read, &tmp_write, |
606 |
&tmp_exceptions, &socket_info.timeout); |
607 |
|
608 |
if (pollret==-1) { |
609 |
LOG(llevError, "select failed: %s\n", strerror_local(errno)); |
610 |
return; |
611 |
} |
612 |
|
613 |
/* We need to do some of the processing below regardless */ |
614 |
/* if (!pollret) return;*/ |
615 |
|
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 = 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 = malloc(nrofpixmaps*sizeof(*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 */ |
670 |
if (pollret) for(i=1;i<socket_info.allocated_sockets;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 |
} |
685 |
|
686 |
/* This does roughly the same thing, but for the players now */ |
687 |
for (pl=first_player; pl!=NULL; pl=next) { |
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); |
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 |
|
733 |
/* Update the players stats once per tick. More efficient than |
734 |
* sending them whenever they change, and probably just as useful |
735 |
*/ |
736 |
esrv_update_stats(pl); |
737 |
if (pl->last_weight != -1 && pl->last_weight != WEIGHT(pl->ob)) { |
738 |
esrv_update_item(UPD_WEIGHT, pl->ob, pl->ob); |
739 |
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)); |
741 |
} |
742 |
/* draw_client_map does sanity checking that map is |
743 |
* valid, so don't do it here. |
744 |
*/ |
745 |
draw_client_map(pl->ob); |
746 |
if (pl->socket.update_look) esrv_draw_look(pl->ob); |
747 |
} |
748 |
} |
749 |
} |
750 |
} |