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 |
{ NULL, NULL, 0} /* terminator */ |
120 |
}; |
121 |
|
122 |
/** Face-related commands */ |
123 |
static struct NsCmdMapping nscommands[] = { |
124 |
{ "addme", AddMeCmd }, |
125 |
{ "askface", SendFaceCmd}, /* Added: phil */ |
126 |
{ "requestinfo", RequestInfo}, |
127 |
{ "setfacemode", SetFaceMode}, |
128 |
{ "setsound", SetSound}, |
129 |
{ "setup", SetUp}, |
130 |
{ "version", VersionCmd }, |
131 |
{ "toggleextendedinfos", ToggleExtendedInfos}, /*Added: tchize*/ |
132 |
{ "toggleextendedtext", ToggleExtendedText}, /*Added: tchize*/ |
133 |
{ "asksmooth", AskSmooth}, /*Added: tchize (smoothing technologies)*/ |
134 |
{ NULL, NULL} /* terminator (I, II & III)*/ |
135 |
}; |
136 |
|
137 |
/** |
138 |
* RequestInfo is sort of a meta command. There is some specific |
139 |
* request of information, but we call other functions to provide |
140 |
* that information. |
141 |
*/ |
142 |
void RequestInfo(char *buf, int len, NewSocket *ns) |
143 |
{ |
144 |
char *params=NULL, *cp; |
145 |
/* No match */ |
146 |
char bigbuf[MAX_BUF]; |
147 |
int slen; |
148 |
|
149 |
/* Set up replyinfo before we modify any of the buffers - this is used |
150 |
* if we don't find a match. |
151 |
*/ |
152 |
strcpy(bigbuf,"replyinfo "); |
153 |
slen = strlen(bigbuf); |
154 |
safe_strcat(bigbuf, buf, &slen, MAX_BUF); |
155 |
|
156 |
/* find the first space, make it null, and update the |
157 |
* params pointer. |
158 |
*/ |
159 |
for (cp = buf; *cp != '\0'; cp++) |
160 |
if (*cp==' ') { |
161 |
*cp = '\0'; |
162 |
params = cp + 1; |
163 |
break; |
164 |
} |
165 |
if (!strcmp(buf, "image_info")) send_image_info(ns, params); |
166 |
else if (!strcmp(buf,"image_sums")) send_image_sums(ns, params); |
167 |
else if (!strcmp(buf,"skill_info")) send_skill_info(ns, params); |
168 |
else if (!strcmp(buf,"spell_paths")) send_spell_paths(ns, params); |
169 |
else Write_String_To_Socket(ns, bigbuf, len); |
170 |
} |
171 |
|
172 |
/** |
173 |
* Handles old socket format. |
174 |
*/ |
175 |
void Handle_Oldsocket(NewSocket *ns) |
176 |
{ |
177 |
int stat,i; |
178 |
CommFunc command; |
179 |
char buf[MAX_BUF],*cp; |
180 |
object ob; |
181 |
player pl; |
182 |
|
183 |
/* This is not the most efficient block, but keeps the code simpler - |
184 |
* we basically read a byte at a time until we get a newline, error, |
185 |
* or no more characters to read. |
186 |
*/ |
187 |
do { |
188 |
/* hack to disable old socket mode without creating too many conflicts */ |
189 |
if (1 || ns->inbuf.len >= MAXSOCKBUF-1) { |
190 |
ns->status = Ns_Dead; |
191 |
LOG(llevDebug, "Old input socket sent too much data without newline\n"); |
192 |
return; |
193 |
} |
194 |
#ifdef WIN32 /* ***win32: change oldsocket read() to recv() */ |
195 |
stat = recv(ns->fd, ns->inbuf.buf + ns->inbuf.len, 1,0); |
196 |
|
197 |
if (stat==-1 && WSAGetLastError() !=WSAEWOULDBLOCK) { |
198 |
#else |
199 |
do { |
200 |
stat = read(ns->fd, ns->inbuf.buf + ns->inbuf.len, 1); |
201 |
} while ((stat<0) && (errno == EINTR)); |
202 |
|
203 |
if (stat<0 && errno != EAGAIN && errno !=EWOULDBLOCK) { |
204 |
#endif |
205 |
LOG(llevError, "Cannot read from socket: %s\n", strerror_local(errno)); |
206 |
ns->status = Ns_Dead; |
207 |
return; |
208 |
} |
209 |
if (stat == 0) return; |
210 |
} while (ns->inbuf.buf[ns->inbuf.len++]!='\n'); |
211 |
|
212 |
ns->inbuf.buf[ns->inbuf.len]=0; |
213 |
|
214 |
cp = strchr(ns->inbuf.buf, ' '); |
215 |
if (cp) { |
216 |
/* Replace the space with a null, skip any more spaces */ |
217 |
*cp++=0; |
218 |
while (isspace(*cp)) cp++; |
219 |
} |
220 |
|
221 |
/* Strip off all spaces and control characters from end of line */ |
222 |
for (i=ns->inbuf.len-1; i>=0; i--) { |
223 |
if (ns->inbuf.buf[i]<=32) ns->inbuf.buf[i]=0; |
224 |
else break; |
225 |
} |
226 |
ns->inbuf.len=0; /* reset for next read */ |
227 |
|
228 |
/* If just a return, don't do anything */ |
229 |
if (ns->inbuf.buf[0] == 0) return; |
230 |
if (!strcasecmp(ns->inbuf.buf,"quit")) { |
231 |
ns->status = Ns_Dead; |
232 |
return; |
233 |
} |
234 |
if (!strcasecmp(ns->inbuf.buf, "listen")) { |
235 |
if (cp) { |
236 |
char *buf="Socket switched to listen mode\n"; |
237 |
|
238 |
free(ns->comment); |
239 |
ns->comment = strdup_local(cp); |
240 |
ns->old_mode = Old_Listen; |
241 |
cs_write_string(ns, buf, strlen(buf)); |
242 |
} else { |
243 |
char *buf="Need to supply a comment/url to listen\n"; |
244 |
cs_write_string(ns, buf, strlen(buf)); |
245 |
} |
246 |
return; |
247 |
} |
248 |
if (!strcasecmp(ns->inbuf.buf, "name")) { |
249 |
char *cp1=NULL; |
250 |
if (cp) cp1= strchr(cp, ' '); |
251 |
if (cp1) { |
252 |
*cp1++ = 0; |
253 |
while (isspace(*cp1)) cp1++; |
254 |
} |
255 |
if (!cp || !cp1) { |
256 |
char *buf="Need to provide a name/password to name\n"; |
257 |
cs_write_string(ns, buf, strlen(buf)); |
258 |
return; |
259 |
} |
260 |
|
261 |
if (verify_player(cp, cp1)==0) { |
262 |
char *buf="Welcome back\n"; |
263 |
free(ns->comment); |
264 |
ns->comment = strdup_local(cp); |
265 |
ns->old_mode = Old_Player; |
266 |
cs_write_string(ns, buf, strlen(buf)); |
267 |
} |
268 |
else if (verify_player(cp, cp1)==2) { |
269 |
ns->password_fails++; |
270 |
if (ns->password_fails >= MAX_PASSWORD_FAILURES) { |
271 |
char *buf="You failed to log in too many times, you will now be kicked.\n"; |
272 |
LOG(llevInfo, "A player connecting from %s in oldsocketmode has been dropped for password failure\n", |
273 |
ns->host); |
274 |
cs_write_string(ns, buf, strlen(buf)); |
275 |
ns->status = Ns_Dead; |
276 |
} |
277 |
else { |
278 |
char *buf="Could not login you in. Check your name and password.\n"; |
279 |
cs_write_string(ns, buf, strlen(buf)); |
280 |
} |
281 |
} |
282 |
else { |
283 |
char *buf="Could not login you in. Check your name and password.\n"; |
284 |
cs_write_string(ns, buf, strlen(buf)); |
285 |
} |
286 |
return; |
287 |
} |
288 |
|
289 |
command = find_oldsocket_command(ns->inbuf.buf); |
290 |
if (!command && ns->old_mode==Old_Player) { |
291 |
command = find_oldsocket_command2(ns->inbuf.buf); |
292 |
} |
293 |
if (!command) { |
294 |
snprintf(buf, sizeof(buf), "Could not find command: %s\n", ns->inbuf.buf); |
295 |
cs_write_string(ns, buf, strlen(buf)); |
296 |
return; |
297 |
} |
298 |
|
299 |
/* This is a bit of a hack, but works. Basically, we make some |
300 |
* fake object and player pointers and give at it. |
301 |
* This works as long as the functions we are calling don't need |
302 |
* to do anything to the object structure (ie, they are only |
303 |
* outputting information and not actually updating anything much.) |
304 |
*/ |
305 |
ob.contr = &pl; |
306 |
pl.ob = &ob; |
307 |
ob.type = PLAYER; |
308 |
pl.listening = 10; |
309 |
pl.socket = *ns; |
310 |
pl.outputs_count = 1; |
311 |
ob.name = ns->comment; |
312 |
|
313 |
command(&ob, cp); |
314 |
} |
315 |
|
316 |
|
317 |
/** |
318 |
* Handle client input. |
319 |
* |
320 |
* HandleClient is actually not named really well - we only get here once |
321 |
* there is input, so we don't do exception or other stuff here. |
322 |
* sock is the output socket information. pl is the player associated |
323 |
* with this socket, null if no player (one of the init_sockets for just |
324 |
* starting a connection) |
325 |
*/ |
326 |
|
327 |
void HandleClient(NewSocket *ns, player *pl) |
328 |
{ |
329 |
int len=0,i,cnt; |
330 |
unsigned char *data; |
331 |
|
332 |
/* Loop through this - maybe we have several complete packets here. */ |
333 |
// limit to a few commands only, though, as to not monopolise the server |
334 |
for (cnt = 16; cnt--; ) { |
335 |
/* If it is a player, and they don't have any speed left, we |
336 |
* return, and will read in the data when they do have time. |
337 |
*/ |
338 |
if (pl && pl->state==ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0) { |
339 |
return; |
340 |
} |
341 |
|
342 |
if (ns->status == Ns_Old) { |
343 |
Handle_Oldsocket(ns); |
344 |
return; |
345 |
} |
346 |
i=SockList_ReadPacket(ns->fd, &ns->inbuf, MAXSOCKBUF-1); |
347 |
/* Special hack - let the user switch to old mode if in the Ns_Add |
348 |
* phase. Don't demand they add in the special length bytes |
349 |
*/ |
350 |
if (ns->status == Ns_Add) { |
351 |
if (!strncasecmp(ns->inbuf.buf,"oldsocketmode", 13)) { |
352 |
ns->status = Ns_Old; |
353 |
ns->inbuf.len=0; |
354 |
cs_write_string(ns, "Switched to old socket mode\n", 28); |
355 |
LOG(llevDebug,"Switched socket to old socket mode\n"); |
356 |
return; |
357 |
} |
358 |
} |
359 |
|
360 |
if (i<0) { |
361 |
#ifdef ESRV_DEBUG |
362 |
LOG(llevDebug,"HandleClient: Read error on connection player %s\n", (pl?pl->ob->name:"None")); |
363 |
#endif |
364 |
/* Caller will take care of cleaning this up */ |
365 |
ns->status =Ns_Dead; |
366 |
return; |
367 |
} |
368 |
/* Still dont have a full packet */ |
369 |
if (i==0) return; |
370 |
|
371 |
/* First, break out beginning word. There are at least |
372 |
* a few commands that do not have any paremeters. If |
373 |
* we get such a command, don't worry about trying |
374 |
* to break it up. |
375 |
*/ |
376 |
data = (unsigned char *)strchr((char*)ns->inbuf.buf +2, ' '); |
377 |
if (data) { |
378 |
*data='\0'; |
379 |
data++; |
380 |
len = ns->inbuf.len - (data - ns->inbuf.buf); |
381 |
} |
382 |
else len=0; |
383 |
|
384 |
ns->inbuf.buf[ns->inbuf.len]='\0'; /* Terminate buffer - useful for string data */ |
385 |
for (i=0; nscommands[i].cmdname !=NULL; i++) { |
386 |
if (strcmp((char*)ns->inbuf.buf+2,nscommands[i].cmdname)==0) { |
387 |
nscommands[i].cmdproc((char*)data,len,ns); |
388 |
ns->inbuf.len=0; |
389 |
return;//D// not doing this causes random memory corruption |
390 |
goto next_packet; |
391 |
} |
392 |
} |
393 |
/* Player must be in the playing state or the flag on the |
394 |
* the command must be zero for the user to use the command - |
395 |
* otherwise, a player cam save, be in the play_again state, and |
396 |
* the map they were on gets swapped out, yet things that try to look |
397 |
* at the map causes a crash. If the command is valid, but |
398 |
* one they can't use, we still swallow it up. |
399 |
*/ |
400 |
if (pl) for (i=0; plcommands[i].cmdname !=NULL; i++) { |
401 |
if (strcmp((char*)ns->inbuf.buf+2,plcommands[i].cmdname)==0) { |
402 |
if (pl->state == ST_PLAYING || !(plcommands[i].flag & 1)) |
403 |
plcommands[i].cmdproc((char*)data,len,pl); |
404 |
ns->inbuf.len=0; |
405 |
//D// not doing this causes random memory corruption |
406 |
if (plcommands[i].flag & 2) |
407 |
goto next_packet; |
408 |
return; |
409 |
} |
410 |
} |
411 |
/* If we get here, we didn't find a valid command. Logging |
412 |
* this might be questionable, because a broken client/malicious |
413 |
* user could certainly send a whole bunch of invalid commands. |
414 |
*/ |
415 |
LOG(llevDebug,"Bad command from client (%s)\n",ns->inbuf.buf+2); |
416 |
next_packet: |
417 |
; |
418 |
} |
419 |
} |
420 |
|
421 |
|
422 |
/***************************************************************************** |
423 |
* |
424 |
* Low level socket looping - select calls and watchdog udp packet |
425 |
* sending. |
426 |
* |
427 |
******************************************************************************/ |
428 |
|
429 |
#ifdef WATCHDOG |
430 |
/** |
431 |
* Tell watchdog that we are still alive |
432 |
* |
433 |
* I put the function here since we should hopefully already be getting |
434 |
* all the needed include files for socket support |
435 |
*/ |
436 |
|
437 |
void watchdog(void) |
438 |
{ |
439 |
static int fd=-1; |
440 |
static struct sockaddr_in insock; |
441 |
|
442 |
if (fd==-1) |
443 |
{ |
444 |
struct protoent *protoent; |
445 |
|
446 |
if ((protoent=getprotobyname("udp"))==NULL || |
447 |
(fd=socket(PF_INET, SOCK_DGRAM, protoent->p_proto))==-1) |
448 |
{ |
449 |
return; |
450 |
} |
451 |
insock.sin_family=AF_INET; |
452 |
insock.sin_port=htons((unsigned short)13325); |
453 |
insock.sin_addr.s_addr=inet_addr("127.0.0.1"); |
454 |
} |
455 |
sendto(fd,(void *)&fd,1,0,(struct sockaddr *)&insock,sizeof(insock)); |
456 |
} |
457 |
#endif |
458 |
|
459 |
extern unsigned long todtick; |
460 |
|
461 |
/** Waits for new connection */ |
462 |
static void block_until_new_connection(void) |
463 |
{ |
464 |
|
465 |
struct timeval Timeout; |
466 |
fd_set readfs; |
467 |
int cycles; |
468 |
|
469 |
LOG(llevInfo, "Waiting for connections...\n"); |
470 |
|
471 |
cycles=1; |
472 |
do { |
473 |
/* Every minutes is a bit often for updates - especially if nothing is going |
474 |
* on. This slows it down to every 6 minutes. |
475 |
*/ |
476 |
cycles++; |
477 |
if (cycles%2 == 0) |
478 |
tick_the_clock(); |
479 |
|
480 |
FD_ZERO(&readfs); |
481 |
FD_SET((uint32)init_sockets[0].fd, &readfs); |
482 |
|
483 |
/* If fastclock is set, we need to seriously slow down the updates |
484 |
* to the metaserver as well as watchdog. Do same for flush_old_maps() - |
485 |
* that is time sensitive, so there is no good reason to call it 2000 times |
486 |
* a second. |
487 |
*/ |
488 |
if (settings.fastclock > 0) { |
489 |
#ifdef WATCHDOG |
490 |
if (cycles % 120000 == 0) { |
491 |
watchdog(); |
492 |
flush_old_maps(); |
493 |
} |
494 |
#endif |
495 |
if (cycles == 720000) { |
496 |
metaserver_update(); |
497 |
cycles=1; |
498 |
} |
499 |
Timeout.tv_sec=0; |
500 |
Timeout.tv_usec=50; |
501 |
} else { |
502 |
Timeout.tv_sec=60; |
503 |
Timeout.tv_usec=0; |
504 |
if (cycles == 7) { |
505 |
metaserver_update(); |
506 |
cycles=1; |
507 |
} |
508 |
flush_old_maps(); |
509 |
} |
510 |
} |
511 |
while (select(socket_info.max_filedescriptor, &readfs, NULL, NULL, &Timeout)==0); |
512 |
|
513 |
reset_sleep(); /* Or the game would go too fast */ |
514 |
} |
515 |
|
516 |
void flush_sockets(void) |
517 |
{ |
518 |
player *pl; |
519 |
|
520 |
for (pl = first_player; pl != NULL; pl = pl->next) |
521 |
if (pl->socket.status != Ns_Dead) |
522 |
Socket_Flush (&pl->socket); |
523 |
} |
524 |
|
525 |
/** |
526 |
* This checks the sockets for input and exceptions, does the right thing. |
527 |
* |
528 |
* A bit of this code is grabbed out of socket.c |
529 |
* There are 2 lists we need to look through - init_sockets is a list |
530 |
* |
531 |
*/ |
532 |
void doeric_server(void) |
533 |
{ |
534 |
int i, pollret; |
535 |
fd_set tmp_read, tmp_exceptions, tmp_write; |
536 |
struct sockaddr_in addr; |
537 |
socklen_t addrlen=sizeof(struct sockaddr); |
538 |
player *pl, *next; |
539 |
|
540 |
#ifdef CS_LOGSTATS |
541 |
if ((time(NULL)-cst_lst.time_start)>=CS_LOGTIME) |
542 |
write_cs_stats(); |
543 |
#endif |
544 |
|
545 |
FD_ZERO(&tmp_read); |
546 |
FD_ZERO(&tmp_write); |
547 |
FD_ZERO(&tmp_exceptions); |
548 |
|
549 |
for(i=0;i<socket_info.allocated_sockets;i++) { |
550 |
if (init_sockets[i].status == Ns_Dead) { |
551 |
free_newsocket(&init_sockets[i]); |
552 |
init_sockets[i].status = Ns_Avail; |
553 |
socket_info.nconns--; |
554 |
} else if (init_sockets[i].status != Ns_Avail){ |
555 |
FD_SET((uint32)init_sockets[i].fd, &tmp_read); |
556 |
FD_SET((uint32)init_sockets[i].fd, &tmp_write); |
557 |
FD_SET((uint32)init_sockets[i].fd, &tmp_exceptions); |
558 |
} |
559 |
} |
560 |
|
561 |
/* Go through the players. Let the loop set the next pl value, |
562 |
* since we may remove some |
563 |
*/ |
564 |
for (pl=first_player; pl!=NULL; ) { |
565 |
if (pl->socket.status == Ns_Dead) { |
566 |
player *npl=pl->next; |
567 |
|
568 |
save_player(pl->ob, 0); |
569 |
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
570 |
terminate_all_pets(pl->ob); |
571 |
remove_ob(pl->ob); |
572 |
} |
573 |
leave(pl,1); |
574 |
final_free_player(pl); |
575 |
pl=npl; |
576 |
} |
577 |
else { |
578 |
FD_SET((uint32)pl->socket.fd, &tmp_read); |
579 |
FD_SET((uint32)pl->socket.fd, &tmp_write); |
580 |
FD_SET((uint32)pl->socket.fd, &tmp_exceptions); |
581 |
pl=pl->next; |
582 |
} |
583 |
} |
584 |
|
585 |
if (socket_info.nconns==1 && first_player==NULL) |
586 |
block_until_new_connection(); |
587 |
|
588 |
/* Reset timeout each time, since some OS's will change the values on |
589 |
* the return from select. |
590 |
*/ |
591 |
socket_info.timeout.tv_sec = 0; |
592 |
socket_info.timeout.tv_usec = 0; |
593 |
|
594 |
pollret= select(socket_info.max_filedescriptor, &tmp_read, &tmp_write, |
595 |
&tmp_exceptions, &socket_info.timeout); |
596 |
|
597 |
if (pollret==-1) { |
598 |
LOG(llevError, "select failed: %s\n", strerror_local(errno)); |
599 |
return; |
600 |
} |
601 |
|
602 |
/* We need to do some of the processing below regardless */ |
603 |
/* if (!pollret) return;*/ |
604 |
|
605 |
/* Following adds a new connection */ |
606 |
if (pollret && FD_ISSET(init_sockets[0].fd, &tmp_read)) { |
607 |
int newsocknum=0; |
608 |
|
609 |
#ifdef ESRV_DEBUG |
610 |
LOG(llevDebug,"doeric_server: New Connection\n"); |
611 |
#endif |
612 |
/* If this is the case, all sockets currently in used */ |
613 |
if (socket_info.allocated_sockets <= socket_info.nconns) { |
614 |
init_sockets = realloc(init_sockets,sizeof(NewSocket)*(socket_info.nconns+1)); |
615 |
if (!init_sockets) fatal(OUT_OF_MEMORY); |
616 |
newsocknum = socket_info.allocated_sockets; |
617 |
socket_info.allocated_sockets++; |
618 |
init_sockets[newsocknum].faces_sent_len = nrofpixmaps; |
619 |
init_sockets[newsocknum].faces_sent = malloc(nrofpixmaps*sizeof(*init_sockets[newsocknum].faces_sent)); |
620 |
if (!init_sockets[newsocknum].faces_sent) fatal(OUT_OF_MEMORY); |
621 |
init_sockets[newsocknum].status = Ns_Avail; |
622 |
} |
623 |
else { |
624 |
int j; |
625 |
|
626 |
for (j=1; j<socket_info.allocated_sockets; j++) |
627 |
if (init_sockets[j].status == Ns_Avail) { |
628 |
newsocknum=j; |
629 |
break; |
630 |
} |
631 |
} |
632 |
init_sockets[newsocknum].fd=accept(init_sockets[0].fd, (struct sockaddr *)&addr, &addrlen); |
633 |
if (init_sockets[newsocknum].fd==-1) { |
634 |
LOG(llevError, "accept failed: %s\n", strerror_local(errno)); |
635 |
} |
636 |
else { |
637 |
char buf[MAX_BUF]; |
638 |
long ip; |
639 |
NewSocket *ns; |
640 |
|
641 |
ns = &init_sockets[newsocknum]; |
642 |
|
643 |
ip = ntohl(addr.sin_addr.s_addr); |
644 |
sprintf(buf, "%ld.%ld.%ld.%ld", (ip>>24)&255, (ip>>16)&255, (ip>>8)&255, ip&255); |
645 |
|
646 |
if (checkbanned(NULL, buf)) { |
647 |
LOG(llevInfo, "Banned host tried to connect: [%s]\n", buf); |
648 |
close(init_sockets[newsocknum].fd); |
649 |
init_sockets[newsocknum].fd = -1; |
650 |
} |
651 |
else { |
652 |
InitConnection(ns, buf); |
653 |
socket_info.nconns++; |
654 |
} |
655 |
} |
656 |
} |
657 |
|
658 |
/* Check for any exceptions/input on the sockets */ |
659 |
if (pollret) for(i=1;i<socket_info.allocated_sockets;i++) { |
660 |
if (init_sockets[i].status == Ns_Avail) continue; |
661 |
if (FD_ISSET(init_sockets[i].fd,&tmp_exceptions)) { |
662 |
free_newsocket(&init_sockets[i]); |
663 |
init_sockets[i].status = Ns_Avail; |
664 |
socket_info.nconns--; |
665 |
continue; |
666 |
} |
667 |
if (FD_ISSET(init_sockets[i].fd, &tmp_read)) { |
668 |
HandleClient(&init_sockets[i], NULL); |
669 |
} |
670 |
if (FD_ISSET(init_sockets[i].fd, &tmp_write)) { |
671 |
init_sockets[i].can_write=1; |
672 |
} |
673 |
} |
674 |
|
675 |
/* This does roughly the same thing, but for the players now */ |
676 |
for (pl=first_player; pl!=NULL; pl=next) { |
677 |
|
678 |
next=pl->next; |
679 |
if (pl->socket.status==Ns_Dead) continue; |
680 |
|
681 |
if (FD_ISSET(pl->socket.fd,&tmp_write)) { |
682 |
if (!pl->socket.can_write) { |
683 |
#if 0 |
684 |
LOG(llevDebug,"Player %s socket now write enabled\n", pl->ob->name); |
685 |
#endif |
686 |
pl->socket.can_write=1; |
687 |
write_socket_buffer(&pl->socket); |
688 |
} |
689 |
/* if we get an error on the write_socket buffer, no reason to |
690 |
* continue on this socket. |
691 |
*/ |
692 |
if (pl->socket.status==Ns_Dead) continue; |
693 |
} |
694 |
else pl->socket.can_write=0; |
695 |
|
696 |
if (FD_ISSET(pl->socket.fd,&tmp_exceptions)) { |
697 |
save_player(pl->ob, 0); |
698 |
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
699 |
terminate_all_pets(pl->ob); |
700 |
remove_ob(pl->ob); |
701 |
} |
702 |
leave(pl,1); |
703 |
final_free_player(pl); |
704 |
} |
705 |
else { |
706 |
HandleClient(&pl->socket, pl); |
707 |
/* If the player has left the game, then the socket status |
708 |
* will be set to this be the leave function. We don't |
709 |
* need to call leave again, as it has already been called |
710 |
* once. |
711 |
*/ |
712 |
if (pl->socket.status==Ns_Dead) { |
713 |
save_player(pl->ob, 0); |
714 |
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
715 |
terminate_all_pets(pl->ob); |
716 |
remove_ob(pl->ob); |
717 |
} |
718 |
leave(pl,1); |
719 |
final_free_player(pl); |
720 |
} else { |
721 |
|
722 |
/* Update the players stats once per tick. More efficient than |
723 |
* sending them whenever they change, and probably just as useful |
724 |
*/ |
725 |
esrv_update_stats(pl); |
726 |
if (pl->last_weight != -1 && pl->last_weight != WEIGHT(pl->ob)) { |
727 |
esrv_update_item(UPD_WEIGHT, pl->ob, pl->ob); |
728 |
if(pl->last_weight != WEIGHT(pl->ob)) |
729 |
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)); |
730 |
} |
731 |
/* draw_client_map does sanity checking that map is |
732 |
* valid, so don't do it here. |
733 |
*/ |
734 |
draw_client_map(pl->ob); |
735 |
if (pl->socket.update_look) esrv_draw_look(pl->ob); |
736 |
} |
737 |
} |
738 |
} |
739 |
} |