ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/socket/loop.C
(Generate patch)

Comparing deliantra/server/socket/loop.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:06 2006 UTC vs.
Revision 1.54 by root, Sun Jul 1 04:08:14 2007 UTC

1
2/* 1/*
3 * static char *rcsid_loop_c = 2 * This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game.
4 * "$Id: loop.C,v 1.1 2006/08/13 17:16:06 elmex Exp $"; 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5 * Copyright (©) 2002-2003,2007 Mark Wedel & The Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 *
8 * Crossfire TRT is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; either version 2 of the License, or (at your option)
11 * any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 * for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * The authors can be reached via e-mail to <crossfire@schmorp.de>
5 */ 23 */
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 24
30/** 25/**
31 * \file 26 * \file
32 * Main client/server loops. 27 * Main client/server loops.
33 * 28 *
34 * \date 2003-12-02 29 * \date 2003-12-02
35 * 30 *
36 * loop.c mainly deals with initialization and higher level socket 31 * loop.c mainly deals with initialization and higher level socket
37 * maintenance (checking for lost connections and if data has arrived.) 32 * maintanance (checking for lost connections and if data has arrived.)
38 * The reading of data is handled in ericserver.c
39 */ 33 */
40 34
41
42#include <global.h> 35#include <global.h>
43#ifndef __CEXTRACT__
44#include <sproto.h> 36#include <sproto.h>
45#include <sockproto.h> 37#include <sockproto.h>
46#endif
47 38
48#ifndef WIN32 /* ---win32 exclude unix headers */
49#include <sys/types.h> 39#include <sys/types.h>
50#include <sys/time.h> 40#include <sys/time.h>
51#include <sys/socket.h> 41#include <sys/socket.h>
52#include <netinet/in.h> 42#include <netinet/in.h>
53#include <netdb.h> 43#include <netdb.h>
54#endif /* end win32 */
55 44
56#ifdef HAVE_UNISTD_H
57#include <unistd.h> 45#include <unistd.h>
58#endif
59
60#ifdef HAVE_ARPA_INET_H
61#include <arpa/inet.h> 46#include <arpa/inet.h>
62#endif
63 47
64#include <loader.h> 48#include <loader.h>
65#include <newserver.h>
66 49
67/***************************************************************************** 50#define BG_SCRUB_RATE 4 // how often to send a face in the background
68 * Start of command dispatch area.
69 * The commands here are protocol commands.
70 ****************************************************************************/
71 51
72/* Either keep this near the start or end of the file so it is 52#define MAX_QUEUE_DEPTH 500
73 * at least reasonablye easy to find. 53#define MAX_QUEUE_BACKLOG 3.
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 54
80typedef void (*func_uint8_int_ns) (char*, int, NewSocket *); 55void
56client::reset_state ()
57{
58 if (!pl)
59 return;
81 60
82struct NsCmdMapping { 61 pl->run_on = 0;
83 const char *cmdname; 62 pl->fire_on = 0;
84 func_uint8_int_ns cmdproc; 63}
85};
86 64
87typedef void (*func_uint8_int_pl)(char*, int, player *); 65void
88struct PlCmdMapping { 66client::queue_command (packet_type *handler, char *data, int datalen)
89 const char *cmdname; 67{
90 func_uint8_int_pl cmdproc; 68 tstamp stamp = NOW;
91 uint8 flag; 69
92}; 70 if (cmd_queue.size () >= MAX_QUEUE_DEPTH)
71 {
72 //TODO: just disconnect here?
73 reset_state ();
74 send_packet_printf ("drawinfo %d command queue overflow, ignoring.", NDI_RED);
75 }
76 else
77 {
78 cmd_queue.push_back (command ());
79 command &cmd = cmd_queue.back ();
80 cmd.stamp = stamp;
81 cmd.handler = handler;
82 cmd.data = salloc<char> (datalen + 1, data);
83 cmd.datalen = datalen;
84 }
85}
86
87bool
88client::handle_command ()
89{
90 if (!cmd_queue.empty ()
91 && state == ST_PLAYING
92 && pl->ob->speed_left > 0.f)
93 {
94 command &cmd = cmd_queue.front ();
95
96 if (cmd.stamp + MAX_QUEUE_BACKLOG < NOW)
97 {
98 reset_state ();
99 send_packet_printf ("drawinfo %d ignoring delayed commands.", NDI_RED);
100 }
101 else
102 execute (cmd.handler, cmd.data, cmd.datalen);
103
104 cmd_queue.pop_front ();
105 return true;
106 }
107 else
108 return false;
109}
110
111void
112flush_sockets (void)
113{
114 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
115 (*i)->flush ();
116}
93 117
94/** 118/**
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 */
107static 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 */
124static 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 */
143void 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 */
176void 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
328void 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
442void 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
464extern unsigned long todtick;
465
466/** Waits for new connection */
467static 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
521void 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. 119 * This checks the sockets for input, does the right thing.
532 * 120 *
533 * A bit of this code is grabbed out of socket.c 121 * 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 122 * There are 2 lists we need to look through - init_sockets is a list
535 * 123 *
536 */ 124 */
125void
537void doeric_server(void) 126doeric_server (void)
538{ 127{
539 int i, pollret; 128 //TODO: should not be done here, either
540 fd_set tmp_read, tmp_exceptions, tmp_write; 129 for (unsigned i = 0; i < clients.size (); ++i)
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 } 130 {
131 client *ns = clients [i];
565 132
566 /* Go through the players. Let the loop set the next pl value, 133 ns->tick ();
567 * since we may remove some 134 ns->refcnt_chk ();
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 } 135 }
578 leave(pl,1); 136}
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 137
590#if 0 138void
591 // the event system and plugins require the server ti run at all times. 139client::tick ()
592 // since its primarily cf.schmorp.de we are interested in, and 140{
593 // that is supposed to run all the time anyway, its globally disabled 141 if (!pl || destroyed ())
594 // until we can use Event. 142 return;
595 if (socket_info.nconns==1 && first_player==NULL)
596 block_until_new_connection();
597#endif
598 143
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 = (NewSocket *) realloc(init_sockets,sizeof(NewSocket)*(socket_info.nconns+1));
626 if (!init_sockets) fatal(OUT_OF_MEMORY);
627 newsocknum = socket_info.allocated_sockets;
628 socket_info.allocated_sockets++;
629 init_sockets[newsocknum].faces_sent_len = nrofpixmaps;
630 init_sockets[newsocknum].faces_sent = (uint8*) malloc(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 144 /* Update the players stats once per tick. More efficient than
734 * sending them whenever they change, and probably just as useful 145 * sending them whenever they change, and probably just as useful
735 */ 146 */
736 esrv_update_stats(pl); 147 esrv_update_stats (pl);
148
737 if (pl->last_weight != -1 && pl->last_weight != WEIGHT(pl->ob)) { 149 if (last_weight != -1 && last_weight != WEIGHT (pl->ob))
150 {
738 esrv_update_item(UPD_WEIGHT, pl->ob, pl->ob); 151 esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
739 if(pl->last_weight != WEIGHT(pl->ob)) 152 if (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)); 153 LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
741 } 154 (unsigned long) last_weight, WEIGHT (pl->ob));
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 } 155 }
748 } 156
157 draw_client_map (pl);
158
159 if (update_look)
160 esrv_draw_look (pl);
161
162 if (ixface.empty ())
749 } 163 {
164 // regularly send a new face when queue is empty
165 if (bg_scrub && !--bg_scrub && enable_bg_scrub)
166 while (scrub_idx < faces.size () - 1)
167 {
168 ++scrub_idx;
169
170 if (!faces_sent [scrub_idx])
171 {
172 send_face (scrub_idx);
173 flush_fx ();
174
175 bg_scrub = 1; // send up to one face per tick, unless an image was requested
176 break;
177 }
178 }
179
180 rate_avail = max_rate - outputbuffer_len ();
181 }
182 else
183 {
184 int ol = outputbuffer_len ();
185
186 rate_avail = min (max_rate, rate_avail + max_rate);
187 rate_avail -= ol;
188
189 int avail = rate_avail;
190
191 // if we can split images, transfer up to mss-sized packets if possible
192 // but never 768 bytes more.
193 if (fxix) avail += min (768, mss - (ol % mss));
194
195 bg_scrub = BG_SCRUB_RATE;
196
197 while (avail > 0)
198 {
199 ixsend &ix = ixface.back ();
200
201 if (facedata *d = face_data (ix.idx, faceset))
202 {
203 if (fxix)
204 {
205 // 9 bytes is enough for fx_FFFOOO, 40 leaves some room for image data
206 int chunk = min (min (avail - 40, MAXSOCKBUF - 9), ix.ofs);
207
208 if (chunk <= 0)
209 break;
210
211 ix.ofs -= chunk;
212
213 packet sl ("ix");
214
215 sl << ber32 (ix.idx)
216 << ber32 (ix.ofs)
217 << data (d->data.data () + ix.ofs, chunk);
218
219 send_packet (sl);
220 }
221 else
222 {
223 send_image (ix.idx);
224 ix.ofs = 0;
225 }
226 }
227 else
228 ix.ofs = 0;
229
230 int consumed = ol - outputbuffer_len ();
231
232 avail -= consumed;
233 rate_avail -= consumed;
234
235 ol = outputbuffer_len ();
236
237 if (!ix.ofs)
238 {
239 ixface.pop_back ();
240 if (ixface.empty ())
241 break;
242 }
243 }
244 }
750} 245}
246

Diff Legend

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