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