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.3 by root, Tue Aug 29 08:01:38 2006 UTC vs.
Revision 1.83 by root, Tue Nov 3 23:44:21 2009 UTC

1
2/* 1/*
3 * static char *rcsid_loop_c = 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
4 * "$Id: loop.C,v 1.3 2006/08/29 08:01:38 root Exp $"; 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 *
6 * Deliantra is free software: you can redistribute it and/or modify it under
7 * the terms of the Affero GNU General Public License as published by the
8 * Free Software Foundation, either version 3 of the License, or (at your
9 * option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the Affero GNU General Public License
17 * and the GNU General Public License along with this program. If not, see
18 * <http://www.gnu.org/licenses/>.
19 *
20 * The authors can be reached via e-mail to <support@deliantra.net>
5 */ 21 */
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 22
30/** 23/**
31 * \file 24 * \file
32 * Main client/server loops. 25 * Main client/server loops.
33 * 26 *
34 * \date 2003-12-02 27 * \date 2003-12-02
35 * 28 *
36 * loop.c mainly deals with initialization and higher level socket 29 * loop.c mainly deals with initialization and higher level socket
37 * maintenance (checking for lost connections and if data has arrived.) 30 * maintanance (checking for lost connections and if data has arrived.)
38 * The reading of data is handled in ericserver.c
39 */ 31 */
40 32
41
42#include <global.h> 33#include <global.h>
43#ifndef __CEXTRACT__
44#include <sproto.h> 34#include <sproto.h>
45#include <sockproto.h> 35#include <sockproto.h>
46#endif
47 36
48#ifndef WIN32 /* ---win32 exclude unix headers */
49#include <sys/types.h> 37#include <sys/types.h>
50#include <sys/time.h> 38#include <sys/time.h>
51#include <sys/socket.h> 39#include <sys/socket.h>
52#include <netinet/in.h> 40#include <netinet/in.h>
53#include <netdb.h> 41#include <netdb.h>
54#endif /* end win32 */
55 42
56#ifdef HAVE_UNISTD_H
57#include <unistd.h> 43#include <unistd.h>
44#include <arpa/inet.h>
45
46#include <loader.h>
47
48#define BG_SCRUB_RATE 4 // how often to send a face in the background
49
50#define MAX_QUEUE_DEPTH 50
51#define MAX_QUEUE_BACKLOG 3.
52
53void
54client::reset_state ()
55{
56 if (!pl)
57 return;
58
59 pl->run_on = 0;
60 pl->fire_on = 0;
61}
62
63void
64client::queue_command (packet_type *handler, char *data, int datalen)
65{
66 tstamp stamp = NOW;
67
68 if (cmd_queue.size () >= MAX_QUEUE_DEPTH)
69 {
70 //TODO: just disconnect here?
71 reset_state ();
72 send_packet_printf ("drawinfo %d command queue overflow, ignoring.", NDI_RED);
73 }
74 else
75 {
76 cmd_queue.resize (cmd_queue.size () + 1);
77 command &cmd = cmd_queue.back ();
78 cmd.stamp = stamp;
79 cmd.handler = handler;
80 cmd.data = salloc<char> (datalen + 1, data);
81 cmd.datalen = datalen;
82 }
83}
84
85bool
86client::handle_command ()
87{
88 if (!cmd_queue.empty ()
89 && state == ST_PLAYING
90 && pl->ob->speed_left > 0.f)
91 {
92 command &cmd = cmd_queue.front ();
93
94 if (cmd.stamp + MAX_QUEUE_BACKLOG < NOW)
95 {
96 reset_state (); // the command might actually reset some movement state etc.
97
98 if (pl)
99 pl->failmsg (
100 "Cannot keep up with your commands, ignoring them! "
101 "H<Your character cannot keep up with the instructions you give G<him|her>. "
102 "Try issuing commands slower, or, if G<he|she> is incapacitated (paralyzed and so on), "
103 "wait till your character can act again.\n\nIf G<he|she> is permanently stuck, then "
104 "try the B<suicide> command (or use B<chat> to ask somebody to B<invite> you out).>"
105 );
106 }
107 else
108 execute (cmd.handler, cmd.data, cmd.datalen);
109
110 sfree<char> (cmd.data, cmd.datalen + 1);
111 cmd_queue.pop_front ();
112 return true;
113 }
114 else
115 return false;
116}
117
118void
119client::tick ()
120{
121 if (!pl || destroyed ())
122 return;
123
124 pl->dirty = true;
125
126 /* Update the players stats once per tick. More efficient than
127 * sending them whenever they change, and probably just as useful
128 */
129 esrv_update_stats (pl);
130
131 sint32 weight = pl->ob->client_weight ();
132
133 if (last_weight != weight)
134 {
135 pl->ob->update_stats ();
136 esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
137 }
138
139 draw_client_map (pl);
140
141 if (update_look)
142 esrv_draw_look (pl);
143
144 mapinfo_queue_run ();
145
146#if HAVE_TCP_INFO
147 // check time of last ack, and, if too old, kill connection
148 socklen_t len = sizeof (tcpi);
149
150 if (!getsockopt (fd, IPPROTO_TCP, TCP_INFO, &tcpi, &len) && len == sizeof (tcpi))
151 {
152 if (tcpi.tcpi_snd_mss)
153 mss = tcpi.tcpi_snd_mss;
154
155#if 0
156 fprintf (stderr, "uack %d ack %d lost %d ret %d fack %d sst %d cwnd %d mss %d pmtu %d advmss %d EXC %d\n",
157 tcpi.tcpi_unacked,
158 tcpi.tcpi_sacked,
159 tcpi.tcpi_lost,
160 tcpi.tcpi_retrans,
161 tcpi.tcpi_fackets,
162 tcpi.tcpi_snd_ssthresh, tcpi.tcpi_snd_cwnd, tcpi.tcpi_advmss, tcpi.tcpi_pmtu, tcpi.tcpi_advmss,
163
164 tcpi.tcpi_snd_cwnd - (tcpi.tcpi_unacked - tcpi.tcpi_sacked));
58#endif 165#endif
59 166
60#ifdef HAVE_ARPA_INET_H 167 // fast-time-out a player by checking for missing acks
61#include <arpa/inet.h> 168 // do this only when player is active
169 if (pl && pl->active
170 && tcpi.tcpi_last_ack_recv > int (socket_timeout * 1000))
171 {
172 send_msg (NDI_RED | NDI_REPLY, "connection-timeout", "safety disconnect due to tcp/ip timeout (no packets received)");
173 write_outputbuffer ();
174
175 LOG (llevDebug, "connection on fd %d closed due to ack timeout (%u/%u/%u)\n", fd,
176 (unsigned)tcpi.tcpi_last_ack_recv, (unsigned)tcpi.tcpi_last_data_sent, (unsigned)tcpi.tcpi_unacked);
177 destroy ();
178 }
179 }
62#endif 180#endif
63 181
64#include <loader.h> 182 rate_avail = min (max_rate + mss, rate_avail + max_rate);
65#include <newserver.h>
66 183
67/***************************************************************************** 184 int max_send = rate_avail;
68 * Start of command dispatch area.
69 * The commands here are protocol commands.
70 ****************************************************************************/
71 185
72/* Either keep this near the start or end of the file so it is 186#if HAVE_TCP_INFO
73 * at least reasonablye easy to find. 187 // further restrict the available bandwidth by the excess bandwidth available
74 * There are really 2 commands - those which are sent/received 188 max_send = min (max_send, (tcpi.tcpi_snd_cwnd - tcpi.tcpi_unacked + tcpi.tcpi_sacked) * mss);
75 * before player joins, and those happen after the player has joined. 189#endif
76 * As such, we have function types that might be called, so
77 * we end up having 2 tables.
78 */
79 190
80typedef void (*func_uint8_int_ns) (char*, int, NewSocket *); 191 // round to next-lowest mss
192 max_send -= max_send % mss;
81 193
82struct NsCmdMapping { 194 if (ixface.empty ())
83 const char *cmdname; 195 {
84 func_uint8_int_ns cmdproc; 196 // regularly send a new face when queue is empty
85}; 197 if (bg_scrub && !--bg_scrub)
198 while (scrub_idx < faces.size () - 1)
199 {
200 ++scrub_idx;
86 201
87typedef void (*func_uint8_int_pl)(char*, int, player *); 202 if (!faces_sent [scrub_idx])
88struct PlCmdMapping { 203 if (faceinfo *f = face_info (scrub_idx))
89 const char *cmdname; 204 if (f->type == FT_FACE || f->type == FT_SOUND) // only scrub faces and sounds for now
90 func_uint8_int_pl cmdproc; 205 {
91 uint8 flag; 206 send_face (scrub_idx, -120);
92}; 207 flush_fx ();
93 208
94/** 209 bg_scrub = 1; // send up to one fx per tick, unless an image was requested
95 * Dispatch table for the server. 210 break;
96 * 211 }
97 * CmdMapping is the dispatch table for the server, used in HandleClient, 212 }
98 * which gets called when the client has input. All commands called here 213 }
99 * use the same parameter form (char* data, int len, int clientnum. 214 else
100 * We do implicit casts, because the data that is being passed is 215 {
101 * unsigned (pretty much needs to be for binary data), however, most 216 bg_scrub = BG_SCRUB_RATE;
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 217
123/** Face-related commands */ 218 for (;;)
124static struct NsCmdMapping nscommands[] = { 219 {
125 { "addme", AddMeCmd }, 220 int avail = max_send - outputbuffer_len ();
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 221
138/** 222 if (avail <= 0)
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; 223 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 224
173/** 225 ixsend &ix = ixface.back ();
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 226
184 /* This is not the most efficient block, but keeps the code simpler - 227 if (facedata *d = face_data (ix.idx, faceset))
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 { 228 {
201 stat = read(ns->fd, ns->inbuf.buf + ns->inbuf.len, 1); 229 // estimate the packet header overhead "ix " + idx + (new)ofs
202 } while ((stat<0) && (errno == EINTR)); 230 int pktlen = 3 + ber32::encoded_size (ix.idx) + ber32::encoded_size (ix.ofs);
231 int chunk = min (avail - packet::hdrlen, MAXSOCKBUF) - pktlen;
203 232
204 if (stat<0 && errno != EAGAIN && errno !=EWOULDBLOCK) { 233 // only transfer something if the amount of data transferred
205#endif 234 // has a healthy relation to the header overhead
206 LOG(llevError, "Cannot read from socket: %s\n", strerror_local(errno)); 235 if (chunk < 64)
207 ns->status = Ns_Dead; 236 break;
208 return;
209 }
210 if (stat == 0) return;
211 } while (ns->inbuf.buf[ns->inbuf.len++]!='\n');
212 237
213 ns->inbuf.buf[ns->inbuf.len]=0; 238 chunk = min (chunk, (int)ix.ofs);
214 239
215 cp = strchr((const char*)ns->inbuf.buf, ' '); 240 ix.ofs -= chunk;
216 if (cp) {
217 /* Replace the space with a null, skip any more spaces */
218 *cp++=0;
219 while (isspace(*cp)) cp++;
220 }
221 241
222 /* Strip off all spaces and control characters from end of line */ 242 //fprintf (stderr, "i%dx %6d: %5d+%4d (%4d)\n", fxix, ix.idx,ix.ofs,chunk, ixface.size());//D
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 243
229 /* If just a return, don't do anything */ 244 packet sl ("ix");
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 245
239 free(ns->comment); 246 sl << ber32 (ix.idx)
240 ns->comment = strdup_local(cp); 247 << ber32 (ix.ofs)
241 ns->old_mode = Old_Listen; 248 << data (d->data.data () + ix.ofs, chunk);
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 249
262 if (verify_player(cp, cp1)==0) { 250 send_packet (sl);
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 } 251 }
278 else { 252 else
279 char *buf="Could not login you in. Check your name and password.\n"; 253 ix.ofs = 0;
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 254
290 command = find_oldsocket_command((char*)ns->inbuf.buf); 255 if (!ix.ofs)
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 256 {
343 if (ns->status == Ns_Old) { 257 ixface.pop_back ();
344 Handle_Oldsocket(ns); 258
345 return; 259 if (ixface.empty ())
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; 260 break;
358 } 261 }
359 } 262 }
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 } 263 }
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 264
265 rate_avail -= outputbuffer_len ();
266}
267
268void
464void flush_sockets(void) 269client::flush_sockets (void)
465{ 270{
466 player *pl; 271 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
467 272 (*i)->flush ();
468 for (pl = first_player; pl != NULL; pl = pl->next)
469 if (pl->socket.status != Ns_Dead)
470 Socket_Flush (&pl->socket);
471} 273}
472 274
473/** 275void
474 * This checks the sockets for input and exceptions, does the right thing. 276client::clock (void)
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 */
480void doeric_server(void)
481{ 277{
482 int i, pollret; 278 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
483 fd_set tmp_read, tmp_exceptions, tmp_write; 279 (*i)->tick ();
484 struct sockaddr_in addr;
485 socklen_t addrlen=sizeof(struct sockaddr);
486 player *pl, *next;
487 280
488#ifdef CS_LOGSTATS 281 // give them all the same chances
489 if ((time(NULL)-cst_lst.time_start)>=CS_LOGTIME) 282 flush_sockets ();
490 write_cs_stats();
491#endif
492 283
493 FD_ZERO(&tmp_read); 284 //TODO: should not be done here, either
494 FD_ZERO(&tmp_write); 285 for (unsigned i = 0; i < clients.size (); ++i)
495 FD_ZERO(&tmp_exceptions); 286 clients[i]->refcnt_chk ();
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} 287}
288

Diff Legend

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