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.94 by root, Sun Nov 4 02:20:11 2012 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,2010,2011,2012 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#define BG_SCRUB_RATE 4 // how often to send a face in the background
47
48#define MAX_QUEUE_DEPTH 50
49#define MAX_QUEUE_BACKLOG 3.
50
51void
52client::reset_state ()
53{
54 if (!pl)
55 return;
56
57 pl->run_on = 0;
58 pl->fire_on = 0;
59}
60
61void
62client::queue_command (packet_type *handler, char *data, int datalen)
63{
64 tstamp stamp = NOW;
65
66 if (cmd_queue.size () >= MAX_QUEUE_DEPTH)
67 {
68 reset_state ();
69 send_packet_printf ("drawinfo %d command queue overflow, ignoring.", NDI_RED);
70 }
71 else
72 {
73 cmd_queue.resize (cmd_queue.size () + 1);
74 command &cmd = cmd_queue.back ();
75 cmd.stamp = stamp;
76 cmd.handler = handler;
77 cmd.data = salloc<char> (datalen + 1, data);
78 cmd.datalen = datalen;
79 }
80}
81
82bool
83client::handle_command ()
84{
85 if (!cmd_queue.empty ()
86 && state == ST_PLAYING
87 && pl->ob->speed_left > 0.f)
88 {
89 command &cmd = cmd_queue.front ();
90
91 if (cmd.stamp + MAX_QUEUE_BACKLOG < NOW)
92 {
93 reset_state (); // the command might actually reset some movement state etc.
94
95 if (pl)
96 pl->failmsg (
97 "Cannot keep up with your commands, ignoring them! "
98 "H<Your character cannot keep up with the instructions you give G<him|her>. "
99 "Try issuing commands slower, or, if G<he|she> is incapacitated (paralyzed and so on), "
100 "wait till your character can act again.\n\nIf G<he|she> is permanently stuck, then "
101 "try the B<suicide> command (or use B<chat> to ask somebody to B<invite> you out).>"
102 );
103 }
104 else
105 execute (cmd.handler, cmd.data, cmd.datalen);
106
107 sfree<char> (cmd.data, cmd.datalen + 1);
108 cmd_queue.pop_front ();
109 return true;
110 }
111 else
112 return false;
113}
114
115void
116client::tick ()
117{
118 if (destroyed ())
119 return;
120
121 if (pl)
122 {
123 pl->dirty = true;
124
125 /* Update the players stats once per tick. More efficient than
126 * sending them whenever they change, and probably just as useful
127 */
128 pl->need_updated_stats ();
129 esrv_update_stats (pl);
130
131 if (pl->ns->update_spells)
132 esrv_update_spells (pl);
133
134 sint32 weight = pl->ob->client_weight ();
135
136 if (last_weight != weight)
137 {
138 pl->ob->update_stats ();
139 esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
140 }
141
142 draw_client_map (pl);
143
144 if (update_look)
145 esrv_draw_look (pl);
146
147 mapinfo_queue_run ();
148 }
149
150#if HAVE_TCP_INFO
151 // check time of last ack, and, if too old, kill connection
152 socklen_t len = sizeof (tcpi);
153
154 if (!getsockopt (fd, IPPROTO_TCP, TCP_INFO, &tcpi, &len) && len == sizeof (tcpi))
155 {
156 if (tcpi.tcpi_snd_mss)
157 mss = tcpi.tcpi_snd_mss;
158
159#if 0
160 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",
161 tcpi.tcpi_unacked,
162 tcpi.tcpi_sacked,
163 tcpi.tcpi_lost,
164 tcpi.tcpi_retrans,
165 tcpi.tcpi_fackets,
166 tcpi.tcpi_snd_ssthresh, tcpi.tcpi_snd_cwnd, tcpi.tcpi_advmss, tcpi.tcpi_pmtu, tcpi.tcpi_advmss,
167
168 tcpi.tcpi_snd_cwnd - (tcpi.tcpi_unacked - tcpi.tcpi_sacked));
58#endif 169#endif
59 170
60#ifdef HAVE_ARPA_INET_H 171 // fast-time-out a player by checking for missing acks
61#include <arpa/inet.h> 172 // do this only when player is active
173 if (pl && pl->active
174 && tcpi.tcpi_last_ack_recv > int (socket_timeout * 1000))
175 {
176 send_msg (NDI_RED | NDI_REPLY, "connection-timeout", "safety disconnect due to tcp/ip timeout (no packets received)");
177 write_outputbuffer ();
178
179 LOG (llevDebug, "connection on fd %d closed due to ack timeout (%u/%u/%u)\n", fd,
180 (unsigned)tcpi.tcpi_last_ack_recv, (unsigned)tcpi.tcpi_last_data_sent, (unsigned)tcpi.tcpi_unacked);
181 destroy ();
182 }
183 }
62#endif 184#endif
63 185
64#include <loader.h> 186 // limit budget surplus/deficit by one mss, add per-tick budget
65#include <newserver.h> 187 rate_avail = min (rate_avail, mss) + max_rate;
66 188
67/***************************************************************************** 189 int max_send = rate_avail;
68 * Start of command dispatch area.
69 * The commands here are protocol commands.
70 ****************************************************************************/
71 190
72/* Either keep this near the start or end of the file so it is 191#if HAVE_TCP_INFO
73 * at least reasonablye easy to find. 192 // further restrict the available bandwidth by the excess bandwidth available
74 * There are really 2 commands - those which are sent/received 193 min_it (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. 194#endif
76 * As such, we have function types that might be called, so
77 * we end up having 2 tables.
78 */
79 195
80typedef void (*func_uint8_int_ns) (char*, int, NewSocket *); 196 // round to next-lowest mss
197 max_send -= max_send % mss;
81 198
82struct NsCmdMapping { 199 if (ixface.empty ())
83 const char *cmdname; 200 {
84 func_uint8_int_ns cmdproc; 201 // regularly send a new face when queue is empty
85}; 202 if (bg_scrub && !--bg_scrub)
203 while (scrub_idx < faces.size () - 1)
204 {
205 ++scrub_idx;
86 206
87typedef void (*func_uint8_int_pl)(char*, int, player *); 207 if (!faces_sent [scrub_idx])
88struct PlCmdMapping { 208 if (faceinfo *f = face_info (scrub_idx))
89 const char *cmdname; 209 if (f->type == FT_FACE || f->type == FT_SOUND) // only scrub faces and sounds for now
90 func_uint8_int_pl cmdproc; 210 {
91 uint8 flag; 211 send_face (scrub_idx, -120);
92}; 212 flush_fx ();
93 213
94/** 214 bg_scrub = 1; // send up to one fx per tick, unless an image was requested
95 * Dispatch table for the server. 215 break;
96 * 216 }
97 * CmdMapping is the dispatch table for the server, used in HandleClient, 217 }
98 * which gets called when the client has input. All commands called here 218 }
99 * use the same parameter form (char* data, int len, int clientnum. 219 else
100 * We do implicit casts, because the data that is being passed is 220 {
101 * unsigned (pretty much needs to be for binary data), however, most 221 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 222
123/** Face-related commands */ 223 for (;;)
124static struct NsCmdMapping nscommands[] = { 224 {
125 { "addme", AddMeCmd }, 225 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 226
138/** 227 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; 228 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 229
173/** 230 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 231
184 /* This is not the most efficient block, but keeps the code simpler - 232 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 { 233 {
201 stat = read(ns->fd, ns->inbuf.buf + ns->inbuf.len, 1); 234 // estimate the packet header overhead "ix " + idx + (new)ofs
202 } while ((stat<0) && (errno == EINTR)); 235 int pktlen = 3 + ber32::encoded_size (ix.idx) + ber32::encoded_size (ix.ofs);
236 int chunk = min (avail - packet::hdrlen, MAXSOCKBUF) - pktlen;
203 237
204 if (stat<0 && errno != EAGAIN && errno !=EWOULDBLOCK) { 238 // only transfer something if the amount of data transferred
205#endif 239 // has a healthy relation to the header overhead
206 LOG(llevError, "Cannot read from socket: %s\n", strerror_local(errno)); 240 if (chunk < 64)
207 ns->status = Ns_Dead; 241 break;
208 return;
209 }
210 if (stat == 0) return;
211 } while (ns->inbuf.buf[ns->inbuf.len++]!='\n');
212 242
213 ns->inbuf.buf[ns->inbuf.len]=0; 243 chunk = min (chunk, (int)ix.ofs);
214 244
215 cp = strchr((const char*)ns->inbuf.buf, ' '); 245 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 246
222 /* Strip off all spaces and control characters from end of line */ 247 //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 248
229 /* If just a return, don't do anything */ 249 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 250
239 free(ns->comment); 251 sl << ber32 (ix.idx)
240 ns->comment = strdup_local(cp); 252 << ber32 (ix.ofs)
241 ns->old_mode = Old_Listen; 253 << data (d->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 254
262 if (verify_player(cp, cp1)==0) { 255 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 } 256 }
278 else { 257 else
279 char *buf="Could not login you in. Check your name and password.\n"; 258 ix.ofs = 0;
280 cs_write_string(ns, buf, strlen(buf)); 259
260 if (!ix.ofs)
261 {
262 ixface.pop_back ();
263
264 if (ixface.empty ())
265 break;
281 } 266 }
282 } 267 }
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 } 268 }
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 269
464void flush_sockets(void) 270 rate_avail -= outputbuffer_len ();
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} 271}
472 272
473/** 273void
474 * This checks the sockets for input and exceptions, does the right thing. 274client::flush_sockets ()
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{ 275{
482 int i, pollret; 276 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
483 fd_set tmp_read, tmp_exceptions, tmp_write; 277 (*i)->flush ();
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} 278}
279
280void
281client::clock ()
282{
283 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
284 (*i)->tick ();
285
286 // give them all the same chances
287 flush_sockets ();
288
289 //TODO: should not be done here, either
290 for (unsigned i = 0; i < clients.size (); ++i)
291 clients[i]->refcnt_chk ();
292}
293

Diff Legend

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