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.5 by root, Sat Sep 9 21:48:29 2006 UTC vs.
Revision 1.17 by root, Fri Dec 15 03:53:44 2006 UTC

1
2/*
3 * static char *rcsid_loop_c =
4 * "$Id: loop.C,v 1.5 2006/09/09 21:48:29 root Exp $";
5 */
6
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
10 Copyright (C) 2002-2003 Mark Wedel & The Crossfire Development Team 4 Copyright (C) 2002-2003 Mark Wedel & The Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
22 16
23 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 20
27 The author can be reached via e-mail to crossfire-devel@real-time.com 21 The author can be reached via e-mail to <crossfire@schmorp.de>
28*/ 22*/
29 23
30/** 24/**
31 * \file 25 * \file
32 * Main client/server loops. 26 * Main client/server loops.
… …
38 * The reading of data is handled in ericserver.c 32 * The reading of data is handled in ericserver.c
39 */ 33 */
40 34
41 35
42#include <global.h> 36#include <global.h>
43#ifndef __CEXTRACT__
44#include <sproto.h> 37#include <sproto.h>
45#include <sockproto.h> 38#include <sockproto.h>
46#endif
47 39
48#ifndef WIN32 /* ---win32 exclude unix headers */
49#include <sys/types.h> 40#include <sys/types.h>
50#include <sys/time.h> 41#include <sys/time.h>
51#include <sys/socket.h> 42#include <sys/socket.h>
52#include <netinet/in.h> 43#include <netinet/in.h>
53#include <netdb.h> 44#include <netdb.h>
54#endif /* end win32 */
55 45
56#ifdef HAVE_UNISTD_H
57#include <unistd.h> 46#include <unistd.h>
58#endif
59
60#ifdef HAVE_ARPA_INET_H
61#include <arpa/inet.h> 47#include <arpa/inet.h>
62#endif
63 48
64#include <loader.h> 49#include <loader.h>
65#include <newserver.h> 50#include <newserver.h>
66 51
67/***************************************************************************** 52/*****************************************************************************
… …
75 * before player joins, and those happen after the player has joined. 60 * before player joins, and those happen after the player has joined.
76 * As such, we have function types that might be called, so 61 * As such, we have function types that might be called, so
77 * we end up having 2 tables. 62 * we end up having 2 tables.
78 */ 63 */
79 64
80typedef void (*func_uint8_int_ns) (char*, int, NewSocket *); 65enum {
81 66 PF_PLAYER = 0x01, // must have valid player
82struct NsCmdMapping { 67 PF_IMMEDIATE = 0x02, // TODO: hack, can be executed immediately
83 const char *cmdname; 68 PF_PLAYING = 0x04, // must be in playing state
84 func_uint8_int_ns cmdproc;
85}; 69};
86 70
87typedef void (*func_uint8_int_pl)(char*, int, player *); 71struct pkt_type
88struct PlCmdMapping { 72{
89 const char *cmdname; 73 const char *name;
90 func_uint8_int_pl cmdproc; 74 void *cb;
91 uint8 flag; 75 int flags;
76
77 bool may_execute (client_socket *ns)
78 {
79 return (!(flags & PF_PLAYER) || ns->pl)
80 && (!(flags & PF_PLAYING) || (ns->pl && ns->pl->state == ST_PLAYING));
81 }
82
83 void execute (client_socket *ns, char *data, int datalen)
84 {
85 //TODO: only one format
86 if (flags & PF_PLAYER)
87 ((void (*)(char *, int, player * ))cb)((char *)data, datalen, ns->pl);
88 else
89 ((void (*)(char *, int, client_socket *))cb)((char *)data, datalen, ns);
90 }
92}; 91};
93 92
93// SocketCommand, PlayingCommand, should not exist with those ugly casts
94#define SC(cb) (void *)static_cast<void (*)(char *, int, client_socket *)>(cb),
95#define PC(cb) (void *)static_cast<void (*)(char *, int, player *)>(cb), PF_PLAYER |
96
94/** 97/**
95 * Dispatch table for the server. 98 * Dispatch table for the server.
96 * 99 */
97 * CmdMapping is the dispatch table for the server, used in HandleClient, 100static struct pkt_type packets[] = {
98 * which gets called when the client has input. All commands called here 101 {"ncom", PC(NewPlayerCmd) PF_PLAYING },
99 * use the same parameter form (char* data, int len, int clientnum. 102 {"command", PC(PlayerCmd) PF_PLAYING },
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 103
123/** Face-related commands */ 104 {"examine", PC(ExamineCmd) PF_PLAYING | PF_IMMEDIATE },
124static struct NsCmdMapping nscommands[] = { 105 {"apply", PC(ApplyCmd) PF_PLAYING | PF_IMMEDIATE },
125 { "addme", AddMeCmd }, 106 {"reply", PC(ReplyCmd) PF_IMMEDIATE },
107 {"lookat", PC(LookAt) PF_PLAYING | PF_IMMEDIATE },
108 {"lock", PC(LockItem) PF_PLAYING | PF_IMMEDIATE },
109 {"mark", PC(MarkItem) PF_PLAYING | PF_IMMEDIATE },
110 {"move", PC(MoveCmd) PF_PLAYING | PF_IMMEDIATE },
111 {"ext", PC(ExtCmd) PF_IMMEDIATE }, /* CF+ */
112 {"mapredraw", PC(MapRedrawCmd) PF_IMMEDIATE }, /* Added: phil */
113 {"mapinfo", PC(MapInfoCmd) PF_IMMEDIATE }, /* CF+ */
114
115 {"addme", SC(AddMeCmd) PF_IMMEDIATE },
126 { "askface", SendFaceCmd}, /* Added: phil */ 116 {"askface", SC(SendFaceCmd) 0 }, /* Added: phil */
127 { "requestinfo", RequestInfo}, 117 {"requestinfo", SC(RequestInfo) 0 },
128 { "setfacemode", SetFaceMode}, 118 {"setfacemode", SC(SetFaceMode) PF_IMMEDIATE },
129 { "setsound", SetSound}, 119 {"setsound", SC(SetSound) PF_IMMEDIATE },
130 { "setup", SetUp}, 120 {"setup", SC(SetUp) PF_IMMEDIATE },
131 { "version", VersionCmd }, 121 {"version", SC(VersionCmd) PF_IMMEDIATE },
132 { "toggleextendedinfos", ToggleExtendedInfos}, /*Added: tchize*/ 122 {"toggleextendedinfos", SC(ToggleExtendedInfos) PF_IMMEDIATE }, /*Added: tchize */
133 { "toggleextendedtext", ToggleExtendedText}, /*Added: tchize*/ 123 {"toggleextendedtext", SC(ToggleExtendedText) PF_IMMEDIATE }, /*Added: tchize */
134 { "asksmooth", AskSmooth}, /*Added: tchize (smoothing technologies)*/ 124 {"asksmooth", SC(AskSmooth) 0 }, /*Added: tchize (smoothing technologies) */
135 { NULL, NULL} /* terminator (I, II & III)*/
136}; 125};
137 126
138/** 127/**
139 * RequestInfo is sort of a meta command. There is some specific 128 * RequestInfo is sort of a meta command. There is some specific
140 * request of information, but we call other functions to provide 129 * request of information, but we call other functions to provide
141 * that information. 130 * that information.
142 */ 131 */
132void
143void RequestInfo(char *buf, int len, NewSocket *ns) 133RequestInfo (char *buf, int len, client_socket * ns)
144{ 134{
145 char *params=NULL, *cp; 135 char *params = NULL, *cp;
136
146 /* No match */ 137 /* No match */
147 char bigbuf[MAX_BUF]; 138 char bigbuf[MAX_BUF];
148 int slen; 139 int slen;
149 140
150 /* Set up replyinfo before we modify any of the buffers - this is used 141 /* Set up replyinfo before we modify any of the buffers - this is used
151 * if we don't find a match. 142 * if we don't find a match.
152 */ 143 */
153 strcpy(bigbuf,"replyinfo "); 144 strcpy (bigbuf, "replyinfo ");
154 slen = strlen(bigbuf); 145 slen = strlen (bigbuf);
155 safe_strcat(bigbuf, buf, &slen, MAX_BUF); 146 safe_strcat (bigbuf, buf, &slen, MAX_BUF);
156 147
157 /* find the first space, make it null, and update the 148 /* find the first space, make it null, and update the
158 * params pointer. 149 * params pointer.
159 */ 150 */
160 for (cp = buf; *cp != '\0'; cp++) 151 for (cp = buf; *cp != '\0'; cp++)
161 if (*cp==' ') { 152 if (*cp == ' ')
153 {
162 *cp = '\0'; 154 *cp = '\0';
163 params = cp + 1; 155 params = cp + 1;
164 break; 156 break;
165 } 157 }
166 if (!strcmp(buf, "image_info")) send_image_info(ns, params); 158
167 else if (!strcmp(buf,"image_sums")) send_image_sums(ns, params); 159 if (!strcmp (buf, "image_info"))
168 else if (!strcmp(buf,"skill_info")) send_skill_info(ns, params); 160 send_image_info (ns, params);
169 else if (!strcmp(buf,"spell_paths")) send_spell_paths(ns, params); 161 else if (!strcmp (buf, "image_sums"))
170 else Write_String_To_Socket(ns, bigbuf, len); 162 send_image_sums (ns, params);
163 else if (!strcmp (buf, "skill_info"))
164 send_skill_info (ns, params);
165 else if (!strcmp (buf, "spell_paths"))
166 send_spell_paths (ns, params);
167 else
168 ns->send_packet (bigbuf, len);
171} 169}
172 170
173/** 171/**
174 * Handle client input. 172 * Handle client input.
175 * 173 *
… …
178 * sock is the output socket information. pl is the player associated 176 * sock is the output socket information. pl is the player associated
179 * with this socket, null if no player (one of the init_sockets for just 177 * with this socket, null if no player (one of the init_sockets for just
180 * starting a connection) 178 * starting a connection)
181 */ 179 */
182 180
181void
183void HandleClient(NewSocket *ns, player *pl) 182HandleClient (client_socket *ns, player *pl)
184{ 183{
185 int len=0,i,cnt;
186 char *data;
187
188 /* Loop through this - maybe we have several complete packets here. */ 184 /* Loop through this - maybe we have several complete packets here. */
189 // limit to a few commands only, though, as to not monopolise the server 185 // limit to a few commands only, though, as to not monopolise the server
190 for (cnt = 16; cnt--; ) { 186 for (int repeat = 16; repeat--;)
187 {
191 /* If it is a player, and they don't have any speed left, we 188 /* If it is a player, and they don't have any speed left, we
192 * return, and will read in the data when they do have time. 189 * return, and will read in the data when they do have time.
193 */ 190 */
194 if (pl && pl->state==ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0) { 191 if (pl && pl->state == ST_PLAYING && pl->ob && pl->ob->speed_left < 0)
195 return; 192 return;
193
194 int pkt_len = ns->read_packet ();
195
196 if (pkt_len < 0)
196 } 197 {
197 198 LOG (llevError, "read error on player %s\n", &pl->ob->name);
198 i=SockList_ReadPacket(ns->fd, &ns->inbuf, MAXSOCKBUF-1);
199
200 if (i<0) {
201#ifdef ESRV_DEBUG
202 LOG(llevDebug,"HandleClient: Read error on connection player %s\n", (pl?pl->ob->name:"None"));
203#endif
204 /* Caller will take care of cleaning this up */ 199 /* Caller will take care of cleaning this up */
205 ns->status =Ns_Dead; 200 ns->status = Ns_Dead;
206 return; 201 return;
207 } 202 }
203 else if (pkt_len == 0)
208 /* Still dont have a full packet */ 204 /* Still dont have a full packet */
209 if (i==0) return; 205 return;
210 206
211// //D//TODO//temporarily log long commands
212// if (ns->inbuf.len >= 40 && pl && pl->ob)
213// LOG (llevDebug, "HandleClient: long comamnd from <%s,%s> %d<%s>\n", pl->ob->name, ns->host, ns->inbuf.len, ns->inbuf.buf + 2);
214
215 /* First, break out beginning word. There are at least 207 /* First, break out beginning word. There are at least
216 * a few commands that do not have any paremeters. If 208 * a few commands that do not have any paremeters. If
217 * we get such a command, don't worry about trying 209 * we get such a command, don't worry about trying
218 * to break it up. 210 * to break it up.
219 */ 211 */
212 int datalen;
220 data = (char *)strchr((char*)ns->inbuf.buf +2, ' '); 213 char *data = strchr ((char *)ns->inbuf + 2, ' ');
214
221 if (data) { 215 if (data)
222 *data='\0';
223 data++;
224 len = ns->inbuf.len - (data - (char*)ns->inbuf.buf);
225 } 216 {
226 else len=0; 217 *data++ = 0;
227 218 datalen = pkt_len - (data - (char *)ns->inbuf);
228 ns->inbuf.buf[ns->inbuf.len]='\0'; /* Terminate buffer - useful for string data */
229 for (i=0; nscommands[i].cmdname !=NULL; i++) {
230 if (strcmp((char*)ns->inbuf.buf+2,nscommands[i].cmdname)==0) {
231 nscommands[i].cmdproc((char*)data,len,ns);
232 ns->inbuf.len=0;
233 return;//D// not doing this causes random memory corruption
234 goto next_packet;
235 } 219 }
220 else
236 } 221 {
237 /* Player must be in the playing state or the flag on the 222 data = (char *)ns->inbuf + 2; // better read garbage than segfault
238 * the command must be zero for the user to use the command - 223 datalen = 0;
239 * otherwise, a player cam save, be in the play_again state, and 224 }
240 * the map they were on gets swapped out, yet things that try to look 225
241 * at the map causes a crash. If the command is valid, but 226 ns->inbuf [pkt_len] = 0; /* Terminate buffer - useful for string data */
242 * one they can't use, we still swallow it up. 227
228 for (pkt_type *pkt = packets; pkt < packets + (sizeof (packets) / sizeof (packets[0])); ++pkt)
229 if (!strcmp ((char *)ns->inbuf + 2, pkt->name))
243 */ 230 {
244 if (pl) for (i=0; plcommands[i].cmdname !=NULL; i++) { 231 if (pkt->may_execute (ns))
245 if (strcmp((char*)ns->inbuf.buf+2,plcommands[i].cmdname)==0) { 232 {
246 if (pl->state == ST_PLAYING || !(plcommands[i].flag & 1)) 233 pkt->execute (ns, data, datalen);
247 plcommands[i].cmdproc((char*)data,len,pl); 234 ns->skip_packet (pkt_len);
248 ns->inbuf.len=0;
249 //D// not doing this causes random memory corruption 235 //D//TODO not doing this causes random memory corruption
250 if (plcommands[i].flag & 2) 236 if (pkt->flags & PF_IMMEDIATE)
251 goto next_packet; 237 goto next_packet;
252 return; 238 return;
253 } 239 }
254 } 240 }
241
255 /* If we get here, we didn't find a valid command. Logging 242 /* If we get here, we didn't find a valid command. Logging
256 * this might be questionable, because a broken client/malicious 243 * this might be questionable, because a broken client/malicious
257 * user could certainly send a whole bunch of invalid commands. 244 * user could certainly send a whole bunch of invalid commands.
258 */ 245 */
259 LOG(llevDebug,"Bad command from client (%s)\n",ns->inbuf.buf+2); 246 LOG (llevDebug, "Bad command from client (%s)\n", ns->inbuf + 2);
247 ns->skip_packet (pkt_len);
260 next_packet: 248 next_packet:
261 ; 249 ;
262 } 250 }
263} 251}
264 252
265 253void
266/***************************************************************************** 254flush_sockets (void)
267 *
268 * Low level socket looping - select calls and watchdog udp packet
269 * sending.
270 *
271 ******************************************************************************/
272
273#ifdef WATCHDOG
274/**
275 * Tell watchdog that we are still alive
276 *
277 * I put the function here since we should hopefully already be getting
278 * all the needed include files for socket support
279 */
280
281void watchdog(void)
282{ 255{
283 static int fd=-1; 256 for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)
284 static struct sockaddr_in insock; 257 if ((*i)->status != Ns_Dead)
285 258 (*i)->flush ();
286 if (fd==-1)
287 {
288 struct protoent *protoent;
289
290 if ((protoent=getprotobyname("udp"))==NULL ||
291 (fd=socket(PF_INET, SOCK_DGRAM, protoent->p_proto))==-1)
292 {
293 return;
294 }
295 insock.sin_family=AF_INET;
296 insock.sin_port=htons((unsigned short)13325);
297 insock.sin_addr.s_addr=inet_addr("127.0.0.1");
298 }
299 sendto(fd,(void *)&fd,1,0,(struct sockaddr *)&insock,sizeof(insock));
300} 259}
301#endif
302 260
303void flush_sockets(void)
304{
305 player *pl;
306
307 for (pl = first_player; pl != NULL; pl = pl->next)
308 if (pl->socket.status != Ns_Dead)
309 Socket_Flush (&pl->socket);
310}
311
312/** 261/**
313 * This checks the sockets for input and exceptions, does the right thing. 262 * This checks the sockets for input, does the right thing.
314 * 263 *
315 * A bit of this code is grabbed out of socket.c 264 * A bit of this code is grabbed out of socket.c
316 * There are 2 lists we need to look through - init_sockets is a list 265 * There are 2 lists we need to look through - init_sockets is a list
317 * 266 *
318 */ 267 */
268void
319void doeric_server(void) 269doeric_server (void)
320{ 270{
321 int i, pollret; 271 int i, pollret;
322 fd_set tmp_read, tmp_exceptions, tmp_write; 272 fd_set tmp_read;
323 struct sockaddr_in addr; 273 struct sockaddr_in addr;
324 socklen_t addrlen=sizeof(struct sockaddr); 274 socklen_t addrlen = sizeof (struct sockaddr);
325 player *pl, *next; 275 player *pl, *next;
276 int maxfd = 0;
326 277
327#ifdef CS_LOGSTATS 278#ifdef CS_LOGSTATS
328 if ((time(NULL)-cst_lst.time_start)>=CS_LOGTIME) 279 if ((time (NULL) - cst_lst.time_start) >= CS_LOGTIME)
329 write_cs_stats(); 280 write_cs_stats ();
330#endif 281#endif
331 282
332 FD_ZERO(&tmp_read);
333 FD_ZERO(&tmp_write);
334 FD_ZERO(&tmp_exceptions);
335
336 for(i=0;i<socket_info.allocated_sockets;i++) {
337 if (init_sockets[i].status == Ns_Dead) {
338 free_newsocket(&init_sockets[i]);
339 init_sockets[i].status = Ns_Avail;
340 socket_info.nconns--;
341 } else if (init_sockets[i].status != Ns_Avail){
342 FD_SET((uint32)init_sockets[i].fd, &tmp_read);
343 FD_SET((uint32)init_sockets[i].fd, &tmp_write);
344 FD_SET((uint32)init_sockets[i].fd, &tmp_exceptions);
345 }
346 }
347
348 /* Go through the players. Let the loop set the next pl value, 283 /* Go through the players. Let the loop set the next pl value,
349 * since we may remove some 284 * since we may remove some
350 */ 285 */
286 //TODO: must be handled cleanly elsewhere
351 for (pl=first_player; pl!=NULL; ) { 287 for (pl = first_player; pl; )
288 {
289 player *npl = pl->next;
290
291 //TODO: must be handled cleanly elsewhere
352 if (pl->socket.status == Ns_Dead) { 292 if (pl->socket->status == Ns_Dead)
353 player *npl=pl->next; 293 {
354
355 save_player(pl->ob, 0); 294 save_player (pl->ob, 0);
295
356 if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { 296 if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
297 {
357 terminate_all_pets(pl->ob); 298 terminate_all_pets (pl->ob);
358 remove_ob(pl->ob); 299 pl->ob->remove ();
359 } 300 }
301
360 leave(pl,1); 302 leave (pl, 1);
361 final_free_player(pl); 303 final_free_player (pl);
304 }
305
362 pl=npl; 306 pl = npl;
307 }
308
309 FD_ZERO (&tmp_read);
310
311 for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); )
312 {
313 client_socket *s = *i;
314
315 if (s->status == Ns_Dead)
363 } 316 {
317 client_sockets.erase (i);
318 delete s;
319 }
364 else { 320 else
365 FD_SET((uint32)pl->socket.fd, &tmp_read);
366 FD_SET((uint32)pl->socket.fd, &tmp_write);
367 FD_SET((uint32)pl->socket.fd, &tmp_exceptions);
368 pl=pl->next;
369 } 321 {
370 } 322 if (s->fd > maxfd) maxfd = s->fd;
371 323
372 /* Reset timeout each time, since some OS's will change the values on 324 FD_SET (s->fd, &tmp_read);
373 * the return from select. 325
374 */ 326 ++i;
375 socket_info.timeout.tv_sec = 0; 327 }
328 }
329
330 struct timeval timeout;
331
332 timeout.tv_sec = 0;
376 socket_info.timeout.tv_usec = 0; 333 timeout.tv_usec = 0;
377 334
378 pollret= select(socket_info.max_filedescriptor, &tmp_read, &tmp_write, 335 pollret = select (maxfd + 1,
379 &tmp_exceptions, &socket_info.timeout); 336 &tmp_read, 0, 0,
337 &timeout);
380 338
381 if (pollret==-1) { 339 if (pollret == -1)
340 {
382 LOG(llevError, "select failed: %s\n", strerror(errno)); 341 LOG (llevError, "select failed: %s\n", strerror (errno));
383 return; 342 return;
384 } 343 }
385 344
386 /* We need to do some of the processing below regardless */ 345 /* We need to do some of the processing below regardless */
387/* if (!pollret) return;*/
388 346
389 /* Following adds a new connection */ 347 /* Check for any input on the sockets */
390 if (pollret && FD_ISSET(init_sockets[0].fd, &tmp_read)) { 348 for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)
391 int newsocknum=0; 349 {
350 client_socket *s = *i;
351 player *pl = s->pl;
392 352
393#ifdef ESRV_DEBUG 353 //TODO: disassociate handleclient from socket readin
394 LOG(llevDebug,"doeric_server: New Connection\n"); 354 if (s->inbuf_len || FD_ISSET (s->fd, &tmp_read))
395#endif 355 HandleClient (s, pl);
396 /* If this is the case, all sockets currently in used */ 356
397 if (socket_info.allocated_sockets <= socket_info.nconns) { 357 //TODO: should not be done here, either
398 init_sockets = (NewSocket *) realloc(init_sockets,sizeof(NewSocket)*(socket_info.nconns+1)); 358 if (s->status != Ns_Dead && pl)
399 if (!init_sockets) fatal(OUT_OF_MEMORY);
400 newsocknum = socket_info.allocated_sockets;
401 socket_info.allocated_sockets++;
402 init_sockets[newsocknum].faces_sent_len = nrofpixmaps;
403 init_sockets[newsocknum].faces_sent = (uint8*) malloc(nrofpixmaps*sizeof(*init_sockets[newsocknum].faces_sent));
404 if (!init_sockets[newsocknum].faces_sent) fatal(OUT_OF_MEMORY);
405 init_sockets[newsocknum].status = Ns_Avail;
406 } 359 {
407 else { 360 /* Update the players stats once per tick. More efficient than
408 int j; 361 * sending them whenever they change, and probably just as useful
409 362 */
410 for (j=1; j<socket_info.allocated_sockets; j++) 363 esrv_update_stats (pl);
411 if (init_sockets[j].status == Ns_Avail) { 364 if (pl->last_weight != -1 && pl->last_weight != WEIGHT (pl->ob))
412 newsocknum=j;
413 break;
414 } 365 {
415 } 366 esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
416 init_sockets[newsocknum].fd=accept(init_sockets[0].fd, (struct sockaddr *)&addr, &addrlen); 367 if (pl->last_weight != WEIGHT (pl->ob))
417 if (init_sockets[newsocknum].fd==-1) { 368 LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
418 LOG(llevError, "accept failed: %s\n", strerror(errno)); 369 (unsigned long) pl->last_weight, WEIGHT (pl->ob));
419 }
420 else {
421 char buf[MAX_BUF];
422 long ip;
423 NewSocket *ns;
424
425 ns = &init_sockets[newsocknum];
426
427 ip = ntohl(addr.sin_addr.s_addr);
428 sprintf(buf, "%ld.%ld.%ld.%ld", (ip>>24)&255, (ip>>16)&255, (ip>>8)&255, ip&255);
429
430 if (checkbanned(NULL, buf)) {
431 LOG(llevInfo, "Banned host tried to connect: [%s]\n", buf);
432 close(init_sockets[newsocknum].fd);
433 init_sockets[newsocknum].fd = -1;
434 } 370 }
435 else {
436 InitConnection(ns, buf);
437 socket_info.nconns++;
438 }
439 }
440 }
441 371
442 /* Check for any exceptions/input on the sockets */
443 if (pollret) for(i=1;i<socket_info.allocated_sockets;i++) {
444 if (init_sockets[i].status == Ns_Avail) continue;
445 if (FD_ISSET(init_sockets[i].fd,&tmp_exceptions)) {
446 free_newsocket(&init_sockets[i]);
447 init_sockets[i].status = Ns_Avail;
448 socket_info.nconns--;
449 continue;
450 }
451 if (FD_ISSET(init_sockets[i].fd, &tmp_read)) {
452 HandleClient(&init_sockets[i], NULL);
453 }
454 if (FD_ISSET(init_sockets[i].fd, &tmp_write)) {
455 init_sockets[i].can_write=1;
456 }
457 }
458
459 /* This does roughly the same thing, but for the players now */
460 for (pl=first_player; pl!=NULL; pl=next) {
461
462 next=pl->next;
463 if (pl->socket.status==Ns_Dead) continue;
464
465 if (FD_ISSET(pl->socket.fd,&tmp_write)) {
466 if (!pl->socket.can_write) {
467#if 0
468 LOG(llevDebug,"Player %s socket now write enabled\n", pl->ob->name);
469#endif
470 pl->socket.can_write=1;
471 write_socket_buffer(&pl->socket);
472 }
473 /* if we get an error on the write_socket buffer, no reason to
474 * continue on this socket.
475 */
476 if (pl->socket.status==Ns_Dead) continue;
477 }
478 else pl->socket.can_write=0;
479
480 if (FD_ISSET(pl->socket.fd,&tmp_exceptions)) {
481 save_player(pl->ob, 0);
482 if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) {
483 terminate_all_pets(pl->ob);
484 remove_ob(pl->ob);
485 }
486 leave(pl,1);
487 final_free_player(pl);
488 }
489 else {
490 HandleClient(&pl->socket, pl);
491 /* If the player has left the game, then the socket status
492 * will be set to this be the leave function. We don't
493 * need to call leave again, as it has already been called
494 * once.
495 */
496 if (pl->socket.status==Ns_Dead) {
497 save_player(pl->ob, 0);
498 if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) {
499 terminate_all_pets(pl->ob);
500 remove_ob(pl->ob);
501 }
502 leave(pl,1);
503 final_free_player(pl);
504 } else {
505
506 /* Update the players stats once per tick. More efficient than
507 * sending them whenever they change, and probably just as useful
508 */
509 esrv_update_stats(pl);
510 if (pl->last_weight != -1 && pl->last_weight != WEIGHT(pl->ob)) {
511 esrv_update_item(UPD_WEIGHT, pl->ob, pl->ob);
512 if(pl->last_weight != WEIGHT(pl->ob))
513 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));
514 }
515 /* draw_client_map does sanity checking that map is 372 /* draw_client_map does sanity checking that map is
516 * valid, so don't do it here. 373 * valid, so don't do it here.
517 */ 374 */
518 draw_client_map(pl->ob); 375 draw_client_map (pl->ob);
519 if (pl->socket.update_look) esrv_draw_look(pl->ob); 376 if (s->update_look)
520 } 377 esrv_draw_look (pl->ob);
521 } 378 }
522 } 379 }
523} 380}
381

Diff Legend

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