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.4 by root, Wed Aug 30 16:30:37 2006 UTC vs.
Revision 1.6 by root, Sun Sep 10 13:43:33 2006 UTC

1 1
2/* 2/*
3 * static char *rcsid_loop_c = 3 * static char *rcsid_loop_c =
4 * "$Id: loop.C,v 1.4 2006/08/30 16:30:37 root Exp $"; 4 * "$Id: loop.C,v 1.6 2006/09/10 13:43:33 root Exp $";
5 */ 5 */
6 6
7/* 7/*
8 CrossFire, A Multiplayer game for X-windows 8 CrossFire, A Multiplayer game for X-windows
9 9
… …
39 */ 39 */
40 40
41 41
42#include <global.h> 42#include <global.h>
43#ifndef __CEXTRACT__ 43#ifndef __CEXTRACT__
44#include <sproto.h> 44# include <sproto.h>
45#include <sockproto.h> 45# include <sockproto.h>
46#endif 46#endif
47 47
48#ifndef WIN32 /* ---win32 exclude unix headers */ 48#ifndef WIN32 /* ---win32 exclude unix headers */
49#include <sys/types.h> 49# include <sys/types.h>
50#include <sys/time.h> 50# include <sys/time.h>
51#include <sys/socket.h> 51# include <sys/socket.h>
52#include <netinet/in.h> 52# include <netinet/in.h>
53#include <netdb.h> 53# include <netdb.h>
54#endif /* end win32 */ 54#endif /* end win32 */
55 55
56#ifdef HAVE_UNISTD_H 56#ifdef HAVE_UNISTD_H
57#include <unistd.h> 57# include <unistd.h>
58#endif 58#endif
59 59
60#ifdef HAVE_ARPA_INET_H 60#ifdef HAVE_ARPA_INET_H
61#include <arpa/inet.h> 61# include <arpa/inet.h>
62#endif 62#endif
63 63
64#include <loader.h> 64#include <loader.h>
65#include <newserver.h> 65#include <newserver.h>
66 66
… …
75 * before player joins, and those happen after the player has joined. 75 * before player joins, and those happen after the player has joined.
76 * As such, we have function types that might be called, so 76 * As such, we have function types that might be called, so
77 * we end up having 2 tables. 77 * we end up having 2 tables.
78 */ 78 */
79 79
80typedef void (*func_uint8_int_ns) (char*, int, NewSocket *); 80typedef void (*func_uint8_int_ns) (char *, int, NewSocket *);
81 81
82struct NsCmdMapping { 82struct NsCmdMapping
83{
83 const char *cmdname; 84 const char *cmdname;
84 func_uint8_int_ns cmdproc; 85 func_uint8_int_ns cmdproc;
85}; 86};
86 87
87typedef void (*func_uint8_int_pl)(char*, int, player *); 88typedef void (*func_uint8_int_pl) (char *, int, player *);
88struct PlCmdMapping { 89struct PlCmdMapping
90{
89 const char *cmdname; 91 const char *cmdname;
90 func_uint8_int_pl cmdproc; 92 func_uint8_int_pl cmdproc;
91 uint8 flag; 93 uint8 flag;
92}; 94};
93 95
94/** 96/**
95 * Dispatch table for the server. 97 * Dispatch table for the server.
96 * 98 *
… …
103 * to cast it here instead of a bunch of times in the function itself. 105 * 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 106 * 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. 107 * command, 0 if they can issue it at any time.
106 */ 108 */
107static struct PlCmdMapping plcommands[] = { 109static struct PlCmdMapping plcommands[] = {
108 { "examine", ExamineCmd, 1}, 110 {"examine", ExamineCmd, 1},
109 { "apply", ApplyCmd, 1}, 111 {"apply", ApplyCmd, 1},
110 { "move", MoveCmd, 1}, 112 {"move", MoveCmd, 1},
111 { "reply", ReplyCmd, 0}, 113 {"reply", ReplyCmd, 0},
112 { "command", PlayerCmd, 1}, 114 {"command", PlayerCmd, 1},
113 { "ncom", (func_uint8_int_pl)NewPlayerCmd, 1}, 115 {"ncom", (func_uint8_int_pl) NewPlayerCmd, 1},
114 { "lookat", LookAt, 1}, 116 {"lookat", LookAt, 1},
115 { "lock", (func_uint8_int_pl)LockItem, 1}, 117 {"lock", (func_uint8_int_pl) LockItem, 1},
116 { "mark", (func_uint8_int_pl)MarkItem, 1}, 118 {"mark", (func_uint8_int_pl) MarkItem, 1},
117 { "mapredraw", MapRedrawCmd, 0}, /* Added: phil */ 119 {"mapredraw", MapRedrawCmd, 0}, /* Added: phil */
118 { "mapinfo", MapInfoCmd, 2}, /* CF+ */ 120 {"mapinfo", MapInfoCmd, 2}, /* CF+ */
119 { "ext", ExtCmd, 2}, /* CF+ */ 121 {"ext", ExtCmd, 2}, /* CF+ */
120 { NULL, NULL, 0} /* terminator */ 122 {NULL, NULL, 0} /* terminator */
121}; 123};
122 124
123/** Face-related commands */ 125/** Face-related commands */
124static struct NsCmdMapping nscommands[] = { 126static struct NsCmdMapping nscommands[] = {
125 { "addme", AddMeCmd }, 127 {"addme", AddMeCmd},
126 { "askface", SendFaceCmd}, /* Added: phil */ 128 {"askface", SendFaceCmd}, /* Added: phil */
127 { "requestinfo", RequestInfo}, 129 {"requestinfo", RequestInfo},
128 { "setfacemode", SetFaceMode}, 130 {"setfacemode", SetFaceMode},
129 { "setsound", SetSound}, 131 {"setsound", SetSound},
130 { "setup", SetUp}, 132 {"setup", SetUp},
131 { "version", VersionCmd }, 133 {"version", VersionCmd},
132 { "toggleextendedinfos", ToggleExtendedInfos}, /*Added: tchize*/ 134 {"toggleextendedinfos", ToggleExtendedInfos}, /*Added: tchize */
133 { "toggleextendedtext", ToggleExtendedText}, /*Added: tchize*/ 135 {"toggleextendedtext", ToggleExtendedText}, /*Added: tchize */
134 { "asksmooth", AskSmooth}, /*Added: tchize (smoothing technologies)*/ 136 {"asksmooth", AskSmooth}, /*Added: tchize (smoothing technologies) */
135 { NULL, NULL} /* terminator (I, II & III)*/ 137 {NULL, NULL} /* terminator (I, II & III) */
136}; 138};
137 139
138/** 140/**
139 * RequestInfo is sort of a meta command. There is some specific 141 * RequestInfo is sort of a meta command. There is some specific
140 * request of information, but we call other functions to provide 142 * request of information, but we call other functions to provide
141 * that information. 143 * that information.
142 */ 144 */
145void
143void RequestInfo(char *buf, int len, NewSocket *ns) 146RequestInfo (char *buf, int len, NewSocket * ns)
144{ 147{
145 char *params=NULL, *cp; 148 char *params = NULL, *cp;
149
146 /* No match */ 150 /* No match */
147 char bigbuf[MAX_BUF]; 151 char bigbuf[MAX_BUF];
148 int slen; 152 int slen;
149 153
150 /* Set up replyinfo before we modify any of the buffers - this is used 154 /* Set up replyinfo before we modify any of the buffers - this is used
151 * if we don't find a match. 155 * if we don't find a match.
152 */ 156 */
153 strcpy(bigbuf,"replyinfo "); 157 strcpy (bigbuf, "replyinfo ");
154 slen = strlen(bigbuf); 158 slen = strlen (bigbuf);
155 safe_strcat(bigbuf, buf, &slen, MAX_BUF); 159 safe_strcat (bigbuf, buf, &slen, MAX_BUF);
156 160
157 /* find the first space, make it null, and update the 161 /* find the first space, make it null, and update the
158 * params pointer. 162 * params pointer.
159 */ 163 */
160 for (cp = buf; *cp != '\0'; cp++) 164 for (cp = buf; *cp != '\0'; cp++)
161 if (*cp==' ') { 165 if (*cp == ' ')
166 {
162 *cp = '\0'; 167 *cp = '\0';
163 params = cp + 1; 168 params = cp + 1;
164 break; 169 break;
165 } 170 }
166 if (!strcmp(buf, "image_info")) send_image_info(ns, params); 171 if (!strcmp (buf, "image_info"))
167 else if (!strcmp(buf,"image_sums")) send_image_sums(ns, params); 172 send_image_info (ns, params);
168 else if (!strcmp(buf,"skill_info")) send_skill_info(ns, params); 173 else if (!strcmp (buf, "image_sums"))
169 else if (!strcmp(buf,"spell_paths")) send_spell_paths(ns, params); 174 send_image_sums (ns, params);
175 else if (!strcmp (buf, "skill_info"))
176 send_skill_info (ns, params);
177 else if (!strcmp (buf, "spell_paths"))
178 send_spell_paths (ns, params);
179 else
170 else Write_String_To_Socket(ns, bigbuf, len); 180 Write_String_To_Socket (ns, bigbuf, len);
171} 181}
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(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 182
318/** 183/**
319 * Handle client input. 184 * Handle client input.
320 * 185 *
321 * HandleClient is actually not named really well - we only get here once 186 * HandleClient is actually not named really well - we only get here once
… …
323 * sock is the output socket information. pl is the player associated 188 * 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 189 * with this socket, null if no player (one of the init_sockets for just
325 * starting a connection) 190 * starting a connection)
326 */ 191 */
327 192
193void
328void HandleClient(NewSocket *ns, player *pl) 194HandleClient (NewSocket * ns, player *pl)
329{ 195{
330 int len=0,i,cnt; 196 int len = 0, i, cnt;
331 char *data; 197 char *data;
332 198
333 /* Loop through this - maybe we have several complete packets here. */ 199 /* Loop through this - maybe we have several complete packets here. */
334 // limit to a few commands only, though, as to not monopolise the server 200 // limit to a few commands only, though, as to not monopolise the server
335 for (cnt = 16; cnt--; ) { 201 for (cnt = 16; cnt--;)
202 {
336 /* If it is a player, and they don't have any speed left, we 203 /* 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. 204 * return, and will read in the data when they do have time.
338 */ 205 */
339 if (pl && pl->state==ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0) { 206 if (pl && pl->state == ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0)
207 {
340 return; 208 return;
341 }
342 209 }
343 if (ns->status == Ns_Old) { 210
344 Handle_Oldsocket(ns);
345 return;
346 }
347 i=SockList_ReadPacket(ns->fd, &ns->inbuf, MAXSOCKBUF-1); 211 i = SockList_ReadPacket (ns->fd, &ns->inbuf, MAXSOCKBUF - 1);
348 /* Special hack - let the user switch to old mode if in the Ns_Add 212
349 * phase. Don't demand they add in the special length bytes 213 if (i < 0)
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 } 214 {
360
361 if (i<0) {
362#ifdef ESRV_DEBUG 215#ifdef ESRV_DEBUG
363 LOG(llevDebug,"HandleClient: Read error on connection player %s\n", (pl?pl->ob->name:"None")); 216 LOG (llevDebug, "HandleClient: Read error on connection player %s\n", (pl ? pl->ob->name : "None"));
364#endif 217#endif
365 /* Caller will take care of cleaning this up */ 218 /* Caller will take care of cleaning this up */
366 ns->status =Ns_Dead; 219 ns->status = Ns_Dead;
367 return; 220 return;
368 } 221 }
369 /* Still dont have a full packet */ 222 /* Still dont have a full packet */
223 if (i == 0)
370 if (i==0) return; 224 return;
371 225
372// //D//TODO//temporarily log long commands 226// //D//TODO//temporarily log long commands
373// if (ns->inbuf.len >= 40 && pl && pl->ob) 227// 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); 228// LOG (llevDebug, "HandleClient: long comamnd from <%s,%s> %d<%s>\n", pl->ob->name, ns->host, ns->inbuf.len, ns->inbuf.buf + 2);
375 229
376 /* First, break out beginning word. There are at least 230 /* First, break out beginning word. There are at least
377 * a few commands that do not have any paremeters. If 231 * a few commands that do not have any paremeters. If
378 * we get such a command, don't worry about trying 232 * we get such a command, don't worry about trying
379 * to break it up. 233 * to break it up.
380 */ 234 */
381 data = (char *)strchr((char*)ns->inbuf.buf +2, ' '); 235 data = (char *) strchr ((char *) ns->inbuf.buf + 2, ' ');
382 if (data) { 236 if (data)
237 {
383 *data='\0'; 238 *data = '\0';
384 data++; 239 data++;
385 len = ns->inbuf.len - (data - (char*)ns->inbuf.buf); 240 len = ns->inbuf.len - (data - (char *) ns->inbuf.buf);
386 } 241 }
242 else
387 else len=0; 243 len = 0;
388 244
389 ns->inbuf.buf[ns->inbuf.len]='\0'; /* Terminate buffer - useful for string data */ 245 ns->inbuf.buf[ns->inbuf.len] = '\0'; /* Terminate buffer - useful for string data */
390 for (i=0; nscommands[i].cmdname !=NULL; i++) { 246 for (i = 0; nscommands[i].cmdname != NULL; i++)
247 {
391 if (strcmp((char*)ns->inbuf.buf+2,nscommands[i].cmdname)==0) { 248 if (strcmp ((char *) ns->inbuf.buf + 2, nscommands[i].cmdname) == 0)
249 {
392 nscommands[i].cmdproc((char*)data,len,ns); 250 nscommands[i].cmdproc ((char *) data, len, ns);
393 ns->inbuf.len=0; 251 ns->inbuf.len = 0;
394 return;//D// not doing this causes random memory corruption 252 return; //D// not doing this causes random memory corruption
395 goto next_packet; 253 goto next_packet;
396 }
397 } 254 }
255 }
398 /* Player must be in the playing state or the flag on the 256 /* 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 - 257 * 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 258 * 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 259 * 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 260 * at the map causes a crash. If the command is valid, but
403 * one they can't use, we still swallow it up. 261 * one they can't use, we still swallow it up.
404 */ 262 */
263 if (pl)
405 if (pl) for (i=0; plcommands[i].cmdname !=NULL; i++) { 264 for (i = 0; plcommands[i].cmdname != NULL; i++)
265 {
406 if (strcmp((char*)ns->inbuf.buf+2,plcommands[i].cmdname)==0) { 266 if (strcmp ((char *) ns->inbuf.buf + 2, plcommands[i].cmdname) == 0)
267 {
407 if (pl->state == ST_PLAYING || !(plcommands[i].flag & 1)) 268 if (pl->state == ST_PLAYING || !(plcommands[i].flag & 1))
408 plcommands[i].cmdproc((char*)data,len,pl); 269 plcommands[i].cmdproc ((char *) data, len, pl);
409 ns->inbuf.len=0; 270 ns->inbuf.len = 0;
410 //D// not doing this causes random memory corruption 271 //D// not doing this causes random memory corruption
411 if (plcommands[i].flag & 2) 272 if (plcommands[i].flag & 2)
412 goto next_packet; 273 goto next_packet;
413 return; 274 return;
414 } 275 }
415 } 276 }
416 /* If we get here, we didn't find a valid command. Logging 277 /* If we get here, we didn't find a valid command. Logging
417 * this might be questionable, because a broken client/malicious 278 * this might be questionable, because a broken client/malicious
418 * user could certainly send a whole bunch of invalid commands. 279 * user could certainly send a whole bunch of invalid commands.
419 */ 280 */
420 LOG(llevDebug,"Bad command from client (%s)\n",ns->inbuf.buf+2); 281 LOG (llevDebug, "Bad command from client (%s)\n", ns->inbuf.buf + 2);
421 next_packet: 282 next_packet:
422 ; 283 ;
423 } 284 }
424} 285}
425 286
426 287
427/***************************************************************************** 288/*****************************************************************************
… …
430 * sending. 291 * sending.
431 * 292 *
432 ******************************************************************************/ 293 ******************************************************************************/
433 294
434#ifdef WATCHDOG 295#ifdef WATCHDOG
296
435/** 297/**
436 * Tell watchdog that we are still alive 298 * Tell watchdog that we are still alive
437 * 299 *
438 * I put the function here since we should hopefully already be getting 300 * I put the function here since we should hopefully already be getting
439 * all the needed include files for socket support 301 * all the needed include files for socket support
440 */ 302 */
441 303
304void
442void watchdog(void) 305watchdog (void)
443{ 306{
444 static int fd=-1; 307 static int fd = -1;
445 static struct sockaddr_in insock; 308 static struct sockaddr_in insock;
446 309
447 if (fd==-1) 310 if (fd == -1)
448 { 311 {
449 struct protoent *protoent; 312 struct protoent *protoent;
450 313
451 if ((protoent=getprotobyname("udp"))==NULL || 314 if ((protoent = getprotobyname ("udp")) == NULL || (fd = socket (PF_INET, SOCK_DGRAM, protoent->p_proto)) == -1)
452 (fd=socket(PF_INET, SOCK_DGRAM, protoent->p_proto))==-1)
453 { 315 {
454 return; 316 return;
455 } 317 }
456 insock.sin_family=AF_INET; 318 insock.sin_family = AF_INET;
457 insock.sin_port=htons((unsigned short)13325); 319 insock.sin_port = htons ((unsigned short) 13325);
458 insock.sin_addr.s_addr=inet_addr("127.0.0.1"); 320 insock.sin_addr.s_addr = inet_addr ("127.0.0.1");
459 } 321 }
460 sendto(fd,(void *)&fd,1,0,(struct sockaddr *)&insock,sizeof(insock)); 322 sendto (fd, (void *) &fd, 1, 0, (struct sockaddr *) &insock, sizeof (insock));
461} 323}
462#endif 324#endif
463 325
326void
464void flush_sockets(void) 327flush_sockets (void)
465{ 328{
466 player *pl; 329 player *pl;
467 330
468 for (pl = first_player; pl != NULL; pl = pl->next) 331 for (pl = first_player; pl != NULL; pl = pl->next)
469 if (pl->socket.status != Ns_Dead) 332 if (pl->socket.status != Ns_Dead)
… …
475 * 338 *
476 * A bit of this code is grabbed out of socket.c 339 * 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 340 * There are 2 lists we need to look through - init_sockets is a list
478 * 341 *
479 */ 342 */
343void
480void doeric_server(void) 344doeric_server (void)
481{ 345{
482 int i, pollret; 346 int i, pollret;
483 fd_set tmp_read, tmp_exceptions, tmp_write; 347 fd_set tmp_read, tmp_exceptions, tmp_write;
484 struct sockaddr_in addr; 348 struct sockaddr_in addr;
485 socklen_t addrlen=sizeof(struct sockaddr); 349 socklen_t addrlen = sizeof (struct sockaddr);
486 player *pl, *next; 350 player *pl, *next;
487 351
488#ifdef CS_LOGSTATS 352#ifdef CS_LOGSTATS
489 if ((time(NULL)-cst_lst.time_start)>=CS_LOGTIME) 353 if ((time (NULL) - cst_lst.time_start) >= CS_LOGTIME)
490 write_cs_stats(); 354 write_cs_stats ();
491#endif 355#endif
492 356
493 FD_ZERO(&tmp_read); 357 FD_ZERO (&tmp_read);
494 FD_ZERO(&tmp_write); 358 FD_ZERO (&tmp_write);
495 FD_ZERO(&tmp_exceptions); 359 FD_ZERO (&tmp_exceptions);
496 360
497 for(i=0;i<socket_info.allocated_sockets;i++) { 361 for (i = 0; i < socket_info.allocated_sockets; i++)
362 {
498 if (init_sockets[i].status == Ns_Dead) { 363 if (init_sockets[i].status == Ns_Dead)
364 {
499 free_newsocket(&init_sockets[i]); 365 free_newsocket (&init_sockets[i]);
500 init_sockets[i].status = Ns_Avail; 366 init_sockets[i].status = Ns_Avail;
501 socket_info.nconns--; 367 socket_info.nconns--;
368 }
502 } else if (init_sockets[i].status != Ns_Avail){ 369 else if (init_sockets[i].status != Ns_Avail)
370 {
503 FD_SET((uint32)init_sockets[i].fd, &tmp_read); 371 FD_SET ((uint32) init_sockets[i].fd, &tmp_read);
504 FD_SET((uint32)init_sockets[i].fd, &tmp_write); 372 FD_SET ((uint32) init_sockets[i].fd, &tmp_write);
505 FD_SET((uint32)init_sockets[i].fd, &tmp_exceptions); 373 FD_SET ((uint32) init_sockets[i].fd, &tmp_exceptions);
506 } 374 }
507 } 375 }
508 376
509 /* Go through the players. Let the loop set the next pl value, 377 /* Go through the players. Let the loop set the next pl value,
510 * since we may remove some 378 * since we may remove some
511 */ 379 */
512 for (pl=first_player; pl!=NULL; ) { 380 for (pl = first_player; pl != NULL;)
381 {
513 if (pl->socket.status == Ns_Dead) { 382 if (pl->socket.status == Ns_Dead)
383 {
514 player *npl=pl->next; 384 player *npl = pl->next;
515 385
516 save_player(pl->ob, 0); 386 save_player (pl->ob, 0);
517 if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { 387 if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
388 {
518 terminate_all_pets(pl->ob); 389 terminate_all_pets (pl->ob);
519 remove_ob(pl->ob); 390 remove_ob (pl->ob);
520 } 391 }
521 leave(pl,1); 392 leave (pl, 1);
522 final_free_player(pl); 393 final_free_player (pl);
523 pl=npl; 394 pl = npl;
395 }
396 else
524 } 397 {
525 else {
526 FD_SET((uint32)pl->socket.fd, &tmp_read); 398 FD_SET ((uint32) pl->socket.fd, &tmp_read);
527 FD_SET((uint32)pl->socket.fd, &tmp_write); 399 FD_SET ((uint32) pl->socket.fd, &tmp_write);
528 FD_SET((uint32)pl->socket.fd, &tmp_exceptions); 400 FD_SET ((uint32) pl->socket.fd, &tmp_exceptions);
529 pl=pl->next; 401 pl = pl->next;
530 } 402 }
531 } 403 }
532 404
533 /* Reset timeout each time, since some OS's will change the values on 405 /* Reset timeout each time, since some OS's will change the values on
534 * the return from select. 406 * the return from select.
535 */ 407 */
536 socket_info.timeout.tv_sec = 0; 408 socket_info.timeout.tv_sec = 0;
537 socket_info.timeout.tv_usec = 0; 409 socket_info.timeout.tv_usec = 0;
538 410
539 pollret= select(socket_info.max_filedescriptor, &tmp_read, &tmp_write, 411 pollret = select (socket_info.max_filedescriptor, &tmp_read, &tmp_write, &tmp_exceptions, &socket_info.timeout);
540 &tmp_exceptions, &socket_info.timeout);
541 412
542 if (pollret==-1) { 413 if (pollret == -1)
414 {
543 LOG(llevError, "select failed: %s\n", strerror(errno)); 415 LOG (llevError, "select failed: %s\n", strerror (errno));
544 return; 416 return;
545 } 417 }
546 418
547 /* We need to do some of the processing below regardless */ 419 /* We need to do some of the processing below regardless */
420
548/* if (!pollret) return;*/ 421/* if (!pollret) return;*/
549 422
550 /* Following adds a new connection */ 423 /* Following adds a new connection */
551 if (pollret && FD_ISSET(init_sockets[0].fd, &tmp_read)) { 424 if (pollret && FD_ISSET (init_sockets[0].fd, &tmp_read))
425 {
552 int newsocknum=0; 426 int newsocknum = 0;
553 427
554#ifdef ESRV_DEBUG 428#ifdef ESRV_DEBUG
555 LOG(llevDebug,"doeric_server: New Connection\n"); 429 LOG (llevDebug, "doeric_server: New Connection\n");
556#endif 430#endif
557 /* If this is the case, all sockets currently in used */ 431 /* If this is the case, all sockets currently in used */
558 if (socket_info.allocated_sockets <= socket_info.nconns) { 432 if (socket_info.allocated_sockets <= socket_info.nconns)
433 {
559 init_sockets = (NewSocket *) realloc(init_sockets,sizeof(NewSocket)*(socket_info.nconns+1)); 434 init_sockets = (NewSocket *) realloc (init_sockets, sizeof (NewSocket) * (socket_info.nconns + 1));
435 if (!init_sockets)
560 if (!init_sockets) fatal(OUT_OF_MEMORY); 436 fatal (OUT_OF_MEMORY);
561 newsocknum = socket_info.allocated_sockets; 437 newsocknum = socket_info.allocated_sockets;
562 socket_info.allocated_sockets++; 438 socket_info.allocated_sockets++;
563 init_sockets[newsocknum].faces_sent_len = nrofpixmaps; 439 init_sockets[newsocknum].faces_sent_len = nrofpixmaps;
564 init_sockets[newsocknum].faces_sent = (uint8*) malloc(nrofpixmaps*sizeof(*init_sockets[newsocknum].faces_sent)); 440 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); 441 if (!init_sockets[newsocknum].faces_sent)
442 fatal (OUT_OF_MEMORY);
566 init_sockets[newsocknum].status = Ns_Avail; 443 init_sockets[newsocknum].status = Ns_Avail;
444 }
445 else
567 } 446 {
568 else {
569 int j; 447 int j;
570 448
571 for (j=1; j<socket_info.allocated_sockets; j++) 449 for (j = 1; j < socket_info.allocated_sockets; j++)
572 if (init_sockets[j].status == Ns_Avail) { 450 if (init_sockets[j].status == Ns_Avail)
451 {
573 newsocknum=j; 452 newsocknum = j;
574 break; 453 break;
575 } 454 }
576 } 455 }
577 init_sockets[newsocknum].fd=accept(init_sockets[0].fd, (struct sockaddr *)&addr, &addrlen); 456 init_sockets[newsocknum].fd = accept (init_sockets[0].fd, (struct sockaddr *) &addr, &addrlen);
578 if (init_sockets[newsocknum].fd==-1) { 457 if (init_sockets[newsocknum].fd == -1)
458 {
579 LOG(llevError, "accept failed: %s\n", strerror(errno)); 459 LOG (llevError, "accept failed: %s\n", strerror (errno));
460 }
461 else
580 } 462 {
581 else {
582 char buf[MAX_BUF]; 463 char buf[MAX_BUF];
583 long ip; 464 long ip;
584 NewSocket *ns; 465 NewSocket *ns;
585 466
586 ns = &init_sockets[newsocknum]; 467 ns = &init_sockets[newsocknum];
587 468
588 ip = ntohl(addr.sin_addr.s_addr); 469 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); 470 sprintf (buf, "%ld.%ld.%ld.%ld", (ip >> 24) & 255, (ip >> 16) & 255, (ip >> 8) & 255, ip & 255);
590 471
591 if (checkbanned(NULL, buf)) { 472 if (checkbanned (NULL, buf))
473 {
592 LOG(llevInfo, "Banned host tried to connect: [%s]\n", buf); 474 LOG (llevInfo, "Banned host tried to connect: [%s]\n", buf);
593 close(init_sockets[newsocknum].fd); 475 close (init_sockets[newsocknum].fd);
594 init_sockets[newsocknum].fd = -1; 476 init_sockets[newsocknum].fd = -1;
477 }
478 else
595 } 479 {
596 else {
597 InitConnection(ns, buf); 480 InitConnection (ns, buf);
598 socket_info.nconns++; 481 socket_info.nconns++;
599 }
600 } 482 }
483 }
601 } 484 }
602 485
603 /* Check for any exceptions/input on the sockets */ 486 /* Check for any exceptions/input on the sockets */
487 if (pollret)
604 if (pollret) for(i=1;i<socket_info.allocated_sockets;i++) { 488 for (i = 1; i < socket_info.allocated_sockets; i++)
489 {
605 if (init_sockets[i].status == Ns_Avail) continue; 490 if (init_sockets[i].status == Ns_Avail)
491 continue;
606 if (FD_ISSET(init_sockets[i].fd,&tmp_exceptions)) { 492 if (FD_ISSET (init_sockets[i].fd, &tmp_exceptions))
493 {
607 free_newsocket(&init_sockets[i]); 494 free_newsocket (&init_sockets[i]);
608 init_sockets[i].status = Ns_Avail; 495 init_sockets[i].status = Ns_Avail;
609 socket_info.nconns--; 496 socket_info.nconns--;
610 continue; 497 continue;
611 } 498 }
612 if (FD_ISSET(init_sockets[i].fd, &tmp_read)) { 499 if (FD_ISSET (init_sockets[i].fd, &tmp_read))
500 {
613 HandleClient(&init_sockets[i], NULL); 501 HandleClient (&init_sockets[i], NULL);
614 } 502 }
615 if (FD_ISSET(init_sockets[i].fd, &tmp_write)) { 503 if (FD_ISSET (init_sockets[i].fd, &tmp_write))
504 {
616 init_sockets[i].can_write=1; 505 init_sockets[i].can_write = 1;
617 } 506 }
618 } 507 }
619 508
620 /* This does roughly the same thing, but for the players now */ 509 /* This does roughly the same thing, but for the players now */
621 for (pl=first_player; pl!=NULL; pl=next) { 510 for (pl = first_player; pl != NULL; pl = next)
511 {
622 512
623 next=pl->next; 513 next = pl->next;
624 if (pl->socket.status==Ns_Dead) continue; 514 if (pl->socket.status == Ns_Dead)
515 continue;
625 516
626 if (FD_ISSET(pl->socket.fd,&tmp_write)) { 517 if (FD_ISSET (pl->socket.fd, &tmp_write))
518 {
627 if (!pl->socket.can_write) { 519 if (!pl->socket.can_write)
520 {
628#if 0 521#if 0
629 LOG(llevDebug,"Player %s socket now write enabled\n", pl->ob->name); 522 LOG (llevDebug, "Player %s socket now write enabled\n", pl->ob->name);
630#endif 523#endif
631 pl->socket.can_write=1; 524 pl->socket.can_write = 1;
632 write_socket_buffer(&pl->socket); 525 write_socket_buffer (&pl->socket);
633 } 526 }
634 /* if we get an error on the write_socket buffer, no reason to 527 /* if we get an error on the write_socket buffer, no reason to
635 * continue on this socket. 528 * continue on this socket.
636 */ 529 */
637 if (pl->socket.status==Ns_Dead) continue; 530 if (pl->socket.status == Ns_Dead)
531 continue;
638 } 532 }
533 else
639 else pl->socket.can_write=0; 534 pl->socket.can_write = 0;
640 535
641 if (FD_ISSET(pl->socket.fd,&tmp_exceptions)) { 536 if (FD_ISSET (pl->socket.fd, &tmp_exceptions))
537 {
642 save_player(pl->ob, 0); 538 save_player (pl->ob, 0);
643 if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { 539 if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
540 {
644 terminate_all_pets(pl->ob); 541 terminate_all_pets (pl->ob);
645 remove_ob(pl->ob); 542 remove_ob (pl->ob);
646 } 543 }
647 leave(pl,1); 544 leave (pl, 1);
648 final_free_player(pl); 545 final_free_player (pl);
546 }
547 else
649 } 548 {
650 else {
651 HandleClient(&pl->socket, pl); 549 HandleClient (&pl->socket, pl);
652 /* If the player has left the game, then the socket status 550 /* If the player has left the game, then the socket status
653 * will be set to this be the leave function. We don't 551 * will be set to this be the leave function. We don't
654 * need to call leave again, as it has already been called 552 * need to call leave again, as it has already been called
655 * once. 553 * once.
656 */ 554 */
657 if (pl->socket.status==Ns_Dead) { 555 if (pl->socket.status == Ns_Dead)
556 {
658 save_player(pl->ob, 0); 557 save_player (pl->ob, 0);
659 if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { 558 if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
559 {
660 terminate_all_pets(pl->ob); 560 terminate_all_pets (pl->ob);
661 remove_ob(pl->ob); 561 remove_ob (pl->ob);
662 } 562 }
663 leave(pl,1); 563 leave (pl, 1);
664 final_free_player(pl); 564 final_free_player (pl);
565 }
665 } else { 566 else
567 {
666 568
667 /* Update the players stats once per tick. More efficient than 569 /* Update the players stats once per tick. More efficient than
668 * sending them whenever they change, and probably just as useful 570 * sending them whenever they change, and probably just as useful
669 */ 571 */
670 esrv_update_stats(pl); 572 esrv_update_stats (pl);
671 if (pl->last_weight != -1 && pl->last_weight != WEIGHT(pl->ob)) { 573 if (pl->last_weight != -1 && pl->last_weight != WEIGHT (pl->ob))
574 {
672 esrv_update_item(UPD_WEIGHT, pl->ob, pl->ob); 575 esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
673 if(pl->last_weight != WEIGHT(pl->ob)) 576 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)); 577 LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
578 (unsigned long) pl->last_weight, WEIGHT (pl->ob));
675 } 579 }
676 /* draw_client_map does sanity checking that map is 580 /* draw_client_map does sanity checking that map is
677 * valid, so don't do it here. 581 * valid, so don't do it here.
678 */ 582 */
679 draw_client_map(pl->ob); 583 draw_client_map (pl->ob);
680 if (pl->socket.update_look) esrv_draw_look(pl->ob); 584 if (pl->socket.update_look)
585 esrv_draw_look (pl->ob);
681 } 586 }
682 } 587 }
683 } 588 }
684} 589}

Diff Legend

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