1 |
|
2 |
/* |
3 |
* static char *rcsid_loop_c = |
4 |
* "$Id: loop.C,v 1.2 2006-08-24 13:13:49 root Exp $"; |
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((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 |
|
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 |
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((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 |
|
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 = (char *)strchr((char*)ns->inbuf.buf +2, ' '); |
382 |
if (data) { |
383 |
*data='\0'; |
384 |
data++; |
385 |
len = ns->inbuf.len - (data - (char*)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 |
void flush_sockets(void) |
465 |
{ |
466 |
player *pl; |
467 |
|
468 |
for (pl = first_player; pl != NULL; pl = pl->next) |
469 |
if (pl->socket.status != Ns_Dead) |
470 |
Socket_Flush (&pl->socket); |
471 |
} |
472 |
|
473 |
/** |
474 |
* This checks the sockets for input and exceptions, does the right thing. |
475 |
* |
476 |
* A bit of this code is grabbed out of socket.c |
477 |
* There are 2 lists we need to look through - init_sockets is a list |
478 |
* |
479 |
*/ |
480 |
void doeric_server(void) |
481 |
{ |
482 |
int i, pollret; |
483 |
fd_set tmp_read, tmp_exceptions, tmp_write; |
484 |
struct sockaddr_in addr; |
485 |
socklen_t addrlen=sizeof(struct sockaddr); |
486 |
player *pl, *next; |
487 |
|
488 |
#ifdef CS_LOGSTATS |
489 |
if ((time(NULL)-cst_lst.time_start)>=CS_LOGTIME) |
490 |
write_cs_stats(); |
491 |
#endif |
492 |
|
493 |
FD_ZERO(&tmp_read); |
494 |
FD_ZERO(&tmp_write); |
495 |
FD_ZERO(&tmp_exceptions); |
496 |
|
497 |
for(i=0;i<socket_info.allocated_sockets;i++) { |
498 |
if (init_sockets[i].status == Ns_Dead) { |
499 |
free_newsocket(&init_sockets[i]); |
500 |
init_sockets[i].status = Ns_Avail; |
501 |
socket_info.nconns--; |
502 |
} else if (init_sockets[i].status != Ns_Avail){ |
503 |
FD_SET((uint32)init_sockets[i].fd, &tmp_read); |
504 |
FD_SET((uint32)init_sockets[i].fd, &tmp_write); |
505 |
FD_SET((uint32)init_sockets[i].fd, &tmp_exceptions); |
506 |
} |
507 |
} |
508 |
|
509 |
/* Go through the players. Let the loop set the next pl value, |
510 |
* since we may remove some |
511 |
*/ |
512 |
for (pl=first_player; pl!=NULL; ) { |
513 |
if (pl->socket.status == Ns_Dead) { |
514 |
player *npl=pl->next; |
515 |
|
516 |
save_player(pl->ob, 0); |
517 |
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
518 |
terminate_all_pets(pl->ob); |
519 |
remove_ob(pl->ob); |
520 |
} |
521 |
leave(pl,1); |
522 |
final_free_player(pl); |
523 |
pl=npl; |
524 |
} |
525 |
else { |
526 |
FD_SET((uint32)pl->socket.fd, &tmp_read); |
527 |
FD_SET((uint32)pl->socket.fd, &tmp_write); |
528 |
FD_SET((uint32)pl->socket.fd, &tmp_exceptions); |
529 |
pl=pl->next; |
530 |
} |
531 |
} |
532 |
|
533 |
/* Reset timeout each time, since some OS's will change the values on |
534 |
* the return from select. |
535 |
*/ |
536 |
socket_info.timeout.tv_sec = 0; |
537 |
socket_info.timeout.tv_usec = 0; |
538 |
|
539 |
pollret= select(socket_info.max_filedescriptor, &tmp_read, &tmp_write, |
540 |
&tmp_exceptions, &socket_info.timeout); |
541 |
|
542 |
if (pollret==-1) { |
543 |
LOG(llevError, "select failed: %s\n", strerror_local(errno)); |
544 |
return; |
545 |
} |
546 |
|
547 |
/* We need to do some of the processing below regardless */ |
548 |
/* if (!pollret) return;*/ |
549 |
|
550 |
/* Following adds a new connection */ |
551 |
if (pollret && FD_ISSET(init_sockets[0].fd, &tmp_read)) { |
552 |
int newsocknum=0; |
553 |
|
554 |
#ifdef ESRV_DEBUG |
555 |
LOG(llevDebug,"doeric_server: New Connection\n"); |
556 |
#endif |
557 |
/* If this is the case, all sockets currently in used */ |
558 |
if (socket_info.allocated_sockets <= socket_info.nconns) { |
559 |
init_sockets = (NewSocket *) realloc(init_sockets,sizeof(NewSocket)*(socket_info.nconns+1)); |
560 |
if (!init_sockets) fatal(OUT_OF_MEMORY); |
561 |
newsocknum = socket_info.allocated_sockets; |
562 |
socket_info.allocated_sockets++; |
563 |
init_sockets[newsocknum].faces_sent_len = nrofpixmaps; |
564 |
init_sockets[newsocknum].faces_sent = (uint8*) malloc(nrofpixmaps*sizeof(*init_sockets[newsocknum].faces_sent)); |
565 |
if (!init_sockets[newsocknum].faces_sent) fatal(OUT_OF_MEMORY); |
566 |
init_sockets[newsocknum].status = Ns_Avail; |
567 |
} |
568 |
else { |
569 |
int j; |
570 |
|
571 |
for (j=1; j<socket_info.allocated_sockets; j++) |
572 |
if (init_sockets[j].status == Ns_Avail) { |
573 |
newsocknum=j; |
574 |
break; |
575 |
} |
576 |
} |
577 |
init_sockets[newsocknum].fd=accept(init_sockets[0].fd, (struct sockaddr *)&addr, &addrlen); |
578 |
if (init_sockets[newsocknum].fd==-1) { |
579 |
LOG(llevError, "accept failed: %s\n", strerror_local(errno)); |
580 |
} |
581 |
else { |
582 |
char buf[MAX_BUF]; |
583 |
long ip; |
584 |
NewSocket *ns; |
585 |
|
586 |
ns = &init_sockets[newsocknum]; |
587 |
|
588 |
ip = ntohl(addr.sin_addr.s_addr); |
589 |
sprintf(buf, "%ld.%ld.%ld.%ld", (ip>>24)&255, (ip>>16)&255, (ip>>8)&255, ip&255); |
590 |
|
591 |
if (checkbanned(NULL, buf)) { |
592 |
LOG(llevInfo, "Banned host tried to connect: [%s]\n", buf); |
593 |
close(init_sockets[newsocknum].fd); |
594 |
init_sockets[newsocknum].fd = -1; |
595 |
} |
596 |
else { |
597 |
InitConnection(ns, buf); |
598 |
socket_info.nconns++; |
599 |
} |
600 |
} |
601 |
} |
602 |
|
603 |
/* Check for any exceptions/input on the sockets */ |
604 |
if (pollret) for(i=1;i<socket_info.allocated_sockets;i++) { |
605 |
if (init_sockets[i].status == Ns_Avail) continue; |
606 |
if (FD_ISSET(init_sockets[i].fd,&tmp_exceptions)) { |
607 |
free_newsocket(&init_sockets[i]); |
608 |
init_sockets[i].status = Ns_Avail; |
609 |
socket_info.nconns--; |
610 |
continue; |
611 |
} |
612 |
if (FD_ISSET(init_sockets[i].fd, &tmp_read)) { |
613 |
HandleClient(&init_sockets[i], NULL); |
614 |
} |
615 |
if (FD_ISSET(init_sockets[i].fd, &tmp_write)) { |
616 |
init_sockets[i].can_write=1; |
617 |
} |
618 |
} |
619 |
|
620 |
/* This does roughly the same thing, but for the players now */ |
621 |
for (pl=first_player; pl!=NULL; pl=next) { |
622 |
|
623 |
next=pl->next; |
624 |
if (pl->socket.status==Ns_Dead) continue; |
625 |
|
626 |
if (FD_ISSET(pl->socket.fd,&tmp_write)) { |
627 |
if (!pl->socket.can_write) { |
628 |
#if 0 |
629 |
LOG(llevDebug,"Player %s socket now write enabled\n", pl->ob->name); |
630 |
#endif |
631 |
pl->socket.can_write=1; |
632 |
write_socket_buffer(&pl->socket); |
633 |
} |
634 |
/* if we get an error on the write_socket buffer, no reason to |
635 |
* continue on this socket. |
636 |
*/ |
637 |
if (pl->socket.status==Ns_Dead) continue; |
638 |
} |
639 |
else pl->socket.can_write=0; |
640 |
|
641 |
if (FD_ISSET(pl->socket.fd,&tmp_exceptions)) { |
642 |
save_player(pl->ob, 0); |
643 |
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
644 |
terminate_all_pets(pl->ob); |
645 |
remove_ob(pl->ob); |
646 |
} |
647 |
leave(pl,1); |
648 |
final_free_player(pl); |
649 |
} |
650 |
else { |
651 |
HandleClient(&pl->socket, pl); |
652 |
/* If the player has left the game, then the socket status |
653 |
* will be set to this be the leave function. We don't |
654 |
* need to call leave again, as it has already been called |
655 |
* once. |
656 |
*/ |
657 |
if (pl->socket.status==Ns_Dead) { |
658 |
save_player(pl->ob, 0); |
659 |
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
660 |
terminate_all_pets(pl->ob); |
661 |
remove_ob(pl->ob); |
662 |
} |
663 |
leave(pl,1); |
664 |
final_free_player(pl); |
665 |
} else { |
666 |
|
667 |
/* Update the players stats once per tick. More efficient than |
668 |
* sending them whenever they change, and probably just as useful |
669 |
*/ |
670 |
esrv_update_stats(pl); |
671 |
if (pl->last_weight != -1 && pl->last_weight != WEIGHT(pl->ob)) { |
672 |
esrv_update_item(UPD_WEIGHT, pl->ob, pl->ob); |
673 |
if(pl->last_weight != WEIGHT(pl->ob)) |
674 |
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)); |
675 |
} |
676 |
/* draw_client_map does sanity checking that map is |
677 |
* valid, so don't do it here. |
678 |
*/ |
679 |
draw_client_map(pl->ob); |
680 |
if (pl->socket.update_look) esrv_draw_look(pl->ob); |
681 |
} |
682 |
} |
683 |
} |
684 |
} |