1 |
root |
1.1 |
|
2 |
|
|
/* |
3 |
|
|
* static char *rcsid_loop_c = |
4 |
root |
1.2 |
* "$Id$"; |
5 |
root |
1.1 |
*/ |
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 |
|
|
|
30 |
|
|
/** |
31 |
|
|
* \file |
32 |
|
|
* Main client/server loops. |
33 |
|
|
* |
34 |
|
|
* \date 2003-12-02 |
35 |
|
|
* |
36 |
|
|
* loop.c mainly deals with initialization and higher level socket |
37 |
|
|
* maintenance (checking for lost connections and if data has arrived.) |
38 |
|
|
* The reading of data is handled in ericserver.c |
39 |
|
|
*/ |
40 |
|
|
|
41 |
|
|
|
42 |
|
|
#include <global.h> |
43 |
|
|
#ifndef __CEXTRACT__ |
44 |
|
|
#include <sproto.h> |
45 |
|
|
#include <sockproto.h> |
46 |
|
|
#endif |
47 |
|
|
|
48 |
|
|
#ifndef WIN32 /* ---win32 exclude unix headers */ |
49 |
|
|
#include <sys/types.h> |
50 |
|
|
#include <sys/time.h> |
51 |
|
|
#include <sys/socket.h> |
52 |
|
|
#include <netinet/in.h> |
53 |
|
|
#include <netdb.h> |
54 |
|
|
#endif /* end win32 */ |
55 |
|
|
|
56 |
|
|
#ifdef HAVE_UNISTD_H |
57 |
|
|
#include <unistd.h> |
58 |
|
|
#endif |
59 |
|
|
|
60 |
|
|
#ifdef HAVE_ARPA_INET_H |
61 |
|
|
#include <arpa/inet.h> |
62 |
|
|
#endif |
63 |
|
|
|
64 |
|
|
#include <loader.h> |
65 |
|
|
#include <newserver.h> |
66 |
|
|
|
67 |
|
|
/***************************************************************************** |
68 |
|
|
* Start of command dispatch area. |
69 |
|
|
* The commands here are protocol commands. |
70 |
|
|
****************************************************************************/ |
71 |
|
|
|
72 |
|
|
/* Either keep this near the start or end of the file so it is |
73 |
|
|
* at least reasonablye easy to find. |
74 |
|
|
* There are really 2 commands - those which are sent/received |
75 |
|
|
* before player joins, and those happen after the player has joined. |
76 |
|
|
* As such, we have function types that might be called, so |
77 |
|
|
* we end up having 2 tables. |
78 |
|
|
*/ |
79 |
|
|
|
80 |
|
|
typedef void (*func_uint8_int_ns) (char*, int, NewSocket *); |
81 |
|
|
|
82 |
|
|
struct NsCmdMapping { |
83 |
root |
1.2 |
const char *cmdname; |
84 |
root |
1.1 |
func_uint8_int_ns cmdproc; |
85 |
|
|
}; |
86 |
|
|
|
87 |
|
|
typedef void (*func_uint8_int_pl)(char*, int, player *); |
88 |
|
|
struct PlCmdMapping { |
89 |
root |
1.2 |
const char *cmdname; |
90 |
root |
1.1 |
func_uint8_int_pl cmdproc; |
91 |
|
|
uint8 flag; |
92 |
|
|
}; |
93 |
|
|
|
94 |
|
|
/** |
95 |
|
|
* Dispatch table for the server. |
96 |
|
|
* |
97 |
|
|
* CmdMapping is the dispatch table for the server, used in HandleClient, |
98 |
|
|
* which gets called when the client has input. All commands called here |
99 |
|
|
* use the same parameter form (char* data, int len, int clientnum. |
100 |
|
|
* We do implicit casts, because the data that is being passed is |
101 |
|
|
* unsigned (pretty much needs to be for binary data), however, most |
102 |
|
|
* of these treat it only as strings, so it makes things easier |
103 |
|
|
* to cast it here instead of a bunch of times in the function itself. |
104 |
|
|
* flag is 1 if the player must be in the playing state to issue the |
105 |
|
|
* command, 0 if they can issue it at any time. |
106 |
|
|
*/ |
107 |
|
|
static 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 |
root |
1.7 |
{ "mapredraw", MapRedrawCmd, 0}, /* Added: phil */ |
118 |
root |
1.6 |
{ "mapinfo", MapInfoCmd, 2}, /* CF+ */ |
119 |
root |
1.9 |
{ "ext", ExtCmd, 2}, /* CF+ */ |
120 |
root |
1.1 |
{ NULL, NULL, 0} /* terminator */ |
121 |
|
|
}; |
122 |
|
|
|
123 |
|
|
/** Face-related commands */ |
124 |
|
|
static struct NsCmdMapping nscommands[] = { |
125 |
|
|
{ "addme", AddMeCmd }, |
126 |
|
|
{ "askface", SendFaceCmd}, /* Added: phil */ |
127 |
|
|
{ "requestinfo", RequestInfo}, |
128 |
|
|
{ "setfacemode", SetFaceMode}, |
129 |
|
|
{ "setsound", SetSound}, |
130 |
|
|
{ "setup", SetUp}, |
131 |
|
|
{ "version", VersionCmd }, |
132 |
|
|
{ "toggleextendedinfos", ToggleExtendedInfos}, /*Added: tchize*/ |
133 |
|
|
{ "toggleextendedtext", ToggleExtendedText}, /*Added: tchize*/ |
134 |
|
|
{ "asksmooth", AskSmooth}, /*Added: tchize (smoothing technologies)*/ |
135 |
|
|
{ NULL, NULL} /* terminator (I, II & III)*/ |
136 |
|
|
}; |
137 |
|
|
|
138 |
|
|
/** |
139 |
|
|
* RequestInfo is sort of a meta command. There is some specific |
140 |
|
|
* request of information, but we call other functions to provide |
141 |
|
|
* that information. |
142 |
|
|
*/ |
143 |
|
|
void RequestInfo(char *buf, int len, NewSocket *ns) |
144 |
|
|
{ |
145 |
|
|
char *params=NULL, *cp; |
146 |
|
|
/* No match */ |
147 |
|
|
char bigbuf[MAX_BUF]; |
148 |
|
|
int slen; |
149 |
|
|
|
150 |
|
|
/* Set up replyinfo before we modify any of the buffers - this is used |
151 |
|
|
* if we don't find a match. |
152 |
|
|
*/ |
153 |
|
|
strcpy(bigbuf,"replyinfo "); |
154 |
|
|
slen = strlen(bigbuf); |
155 |
|
|
safe_strcat(bigbuf, buf, &slen, MAX_BUF); |
156 |
|
|
|
157 |
|
|
/* find the first space, make it null, and update the |
158 |
|
|
* params pointer. |
159 |
|
|
*/ |
160 |
|
|
for (cp = buf; *cp != '\0'; cp++) |
161 |
|
|
if (*cp==' ') { |
162 |
|
|
*cp = '\0'; |
163 |
|
|
params = cp + 1; |
164 |
|
|
break; |
165 |
|
|
} |
166 |
|
|
if (!strcmp(buf, "image_info")) send_image_info(ns, params); |
167 |
|
|
else if (!strcmp(buf,"image_sums")) send_image_sums(ns, params); |
168 |
|
|
else if (!strcmp(buf,"skill_info")) send_skill_info(ns, params); |
169 |
|
|
else if (!strcmp(buf,"spell_paths")) send_spell_paths(ns, params); |
170 |
|
|
else Write_String_To_Socket(ns, bigbuf, len); |
171 |
|
|
} |
172 |
|
|
|
173 |
|
|
/** |
174 |
|
|
* Handles old socket format. |
175 |
|
|
*/ |
176 |
|
|
void 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 |
root |
1.6 |
/* hack to disable old socket mode without creating too many conflicts */ |
190 |
|
|
if (1 || ns->inbuf.len >= MAXSOCKBUF-1) { |
191 |
root |
1.1 |
ns->status = Ns_Dead; |
192 |
|
|
LOG(llevDebug, "Old input socket sent too much data without newline\n"); |
193 |
|
|
return; |
194 |
|
|
} |
195 |
|
|
#ifdef WIN32 /* ***win32: change oldsocket read() to recv() */ |
196 |
|
|
stat = recv(ns->fd, ns->inbuf.buf + ns->inbuf.len, 1,0); |
197 |
|
|
|
198 |
|
|
if (stat==-1 && WSAGetLastError() !=WSAEWOULDBLOCK) { |
199 |
|
|
#else |
200 |
|
|
do { |
201 |
|
|
stat = read(ns->fd, ns->inbuf.buf + ns->inbuf.len, 1); |
202 |
|
|
} while ((stat<0) && (errno == EINTR)); |
203 |
|
|
|
204 |
|
|
if (stat<0 && errno != EAGAIN && errno !=EWOULDBLOCK) { |
205 |
|
|
#endif |
206 |
|
|
LOG(llevError, "Cannot read from socket: %s\n", strerror_local(errno)); |
207 |
|
|
ns->status = Ns_Dead; |
208 |
|
|
return; |
209 |
|
|
} |
210 |
|
|
if (stat == 0) return; |
211 |
|
|
} while (ns->inbuf.buf[ns->inbuf.len++]!='\n'); |
212 |
|
|
|
213 |
|
|
ns->inbuf.buf[ns->inbuf.len]=0; |
214 |
|
|
|
215 |
|
|
cp = strchr(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(ns->inbuf.buf,"quit")) { |
232 |
|
|
ns->status = Ns_Dead; |
233 |
|
|
return; |
234 |
|
|
} |
235 |
|
|
if (!strcasecmp(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(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(ns->inbuf.buf); |
291 |
|
|
if (!command && ns->old_mode==Old_Player) { |
292 |
|
|
command = find_oldsocket_command2(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 |
|
|
|
328 |
|
|
void HandleClient(NewSocket *ns, player *pl) |
329 |
|
|
{ |
330 |
root |
1.3 |
int len=0,i,cnt; |
331 |
root |
1.1 |
unsigned char *data; |
332 |
|
|
|
333 |
|
|
/* Loop through this - maybe we have several complete packets here. */ |
334 |
root |
1.4 |
// limit to a few commands only, though, as to not monopolise the server |
335 |
root |
1.6 |
for (cnt = 16; cnt--; ) { |
336 |
root |
1.1 |
/* 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(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 |
root |
1.10 |
// //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 |
root |
1.1 |
/* 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 = (unsigned char *)strchr((char*)ns->inbuf.buf +2, ' '); |
382 |
|
|
if (data) { |
383 |
|
|
*data='\0'; |
384 |
|
|
data++; |
385 |
|
|
len = ns->inbuf.len - (data - 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 |
root |
1.7 |
return;//D// not doing this causes random memory corruption |
395 |
root |
1.5 |
goto next_packet; |
396 |
root |
1.1 |
} |
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 |
root |
1.6 |
* the map they were on gets swapped out, yet things that try to look |
402 |
root |
1.1 |
* 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 |
root |
1.6 |
if (pl->state == ST_PLAYING || !(plcommands[i].flag & 1)) |
408 |
root |
1.1 |
plcommands[i].cmdproc((char*)data,len,pl); |
409 |
|
|
ns->inbuf.len=0; |
410 |
root |
1.7 |
//D// not doing this causes random memory corruption |
411 |
root |
1.6 |
if (plcommands[i].flag & 2) |
412 |
|
|
goto next_packet; |
413 |
|
|
return; |
414 |
root |
1.1 |
} |
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 |
root |
1.5 |
next_packet: |
422 |
|
|
; |
423 |
root |
1.1 |
} |
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 |
|
|
|
442 |
|
|
void watchdog(void) |
443 |
|
|
{ |
444 |
|
|
static int fd=-1; |
445 |
|
|
static struct sockaddr_in insock; |
446 |
|
|
|
447 |
|
|
if (fd==-1) |
448 |
|
|
{ |
449 |
|
|
struct protoent *protoent; |
450 |
|
|
|
451 |
|
|
if ((protoent=getprotobyname("udp"))==NULL || |
452 |
|
|
(fd=socket(PF_INET, SOCK_DGRAM, protoent->p_proto))==-1) |
453 |
|
|
{ |
454 |
|
|
return; |
455 |
|
|
} |
456 |
|
|
insock.sin_family=AF_INET; |
457 |
|
|
insock.sin_port=htons((unsigned short)13325); |
458 |
|
|
insock.sin_addr.s_addr=inet_addr("127.0.0.1"); |
459 |
|
|
} |
460 |
|
|
sendto(fd,(void *)&fd,1,0,(struct sockaddr *)&insock,sizeof(insock)); |
461 |
|
|
} |
462 |
|
|
#endif |
463 |
|
|
|
464 |
|
|
extern unsigned long todtick; |
465 |
|
|
|
466 |
|
|
/** Waits for new connection */ |
467 |
|
|
static void block_until_new_connection(void) |
468 |
|
|
{ |
469 |
|
|
|
470 |
|
|
struct timeval Timeout; |
471 |
|
|
fd_set readfs; |
472 |
|
|
int cycles; |
473 |
|
|
|
474 |
|
|
LOG(llevInfo, "Waiting for connections...\n"); |
475 |
|
|
|
476 |
|
|
cycles=1; |
477 |
|
|
do { |
478 |
|
|
/* Every minutes is a bit often for updates - especially if nothing is going |
479 |
|
|
* on. This slows it down to every 6 minutes. |
480 |
|
|
*/ |
481 |
|
|
cycles++; |
482 |
|
|
if (cycles%2 == 0) |
483 |
|
|
tick_the_clock(); |
484 |
|
|
|
485 |
|
|
FD_ZERO(&readfs); |
486 |
|
|
FD_SET((uint32)init_sockets[0].fd, &readfs); |
487 |
|
|
|
488 |
|
|
/* If fastclock is set, we need to seriously slow down the updates |
489 |
|
|
* to the metaserver as well as watchdog. Do same for flush_old_maps() - |
490 |
|
|
* that is time sensitive, so there is no good reason to call it 2000 times |
491 |
|
|
* a second. |
492 |
|
|
*/ |
493 |
|
|
if (settings.fastclock > 0) { |
494 |
|
|
#ifdef WATCHDOG |
495 |
|
|
if (cycles % 120000 == 0) { |
496 |
|
|
watchdog(); |
497 |
|
|
flush_old_maps(); |
498 |
|
|
} |
499 |
|
|
#endif |
500 |
|
|
if (cycles == 720000) { |
501 |
|
|
metaserver_update(); |
502 |
|
|
cycles=1; |
503 |
|
|
} |
504 |
|
|
Timeout.tv_sec=0; |
505 |
|
|
Timeout.tv_usec=50; |
506 |
|
|
} else { |
507 |
|
|
Timeout.tv_sec=60; |
508 |
|
|
Timeout.tv_usec=0; |
509 |
|
|
if (cycles == 7) { |
510 |
|
|
metaserver_update(); |
511 |
|
|
cycles=1; |
512 |
|
|
} |
513 |
|
|
flush_old_maps(); |
514 |
|
|
} |
515 |
|
|
} |
516 |
|
|
while (select(socket_info.max_filedescriptor, &readfs, NULL, NULL, &Timeout)==0); |
517 |
|
|
|
518 |
|
|
reset_sleep(); /* Or the game would go too fast */ |
519 |
|
|
} |
520 |
|
|
|
521 |
root |
1.8 |
void flush_sockets(void) |
522 |
|
|
{ |
523 |
|
|
player *pl; |
524 |
|
|
|
525 |
|
|
for (pl = first_player; pl != NULL; pl = pl->next) |
526 |
|
|
if (pl->socket.status != Ns_Dead) |
527 |
|
|
Socket_Flush (&pl->socket); |
528 |
|
|
} |
529 |
root |
1.1 |
|
530 |
|
|
/** |
531 |
|
|
* This checks the sockets for input and exceptions, does the right thing. |
532 |
|
|
* |
533 |
|
|
* A bit of this code is grabbed out of socket.c |
534 |
|
|
* There are 2 lists we need to look through - init_sockets is a list |
535 |
|
|
* |
536 |
|
|
*/ |
537 |
|
|
void doeric_server(void) |
538 |
|
|
{ |
539 |
|
|
int i, pollret; |
540 |
|
|
fd_set tmp_read, tmp_exceptions, tmp_write; |
541 |
|
|
struct sockaddr_in addr; |
542 |
|
|
socklen_t addrlen=sizeof(struct sockaddr); |
543 |
|
|
player *pl, *next; |
544 |
|
|
|
545 |
|
|
#ifdef CS_LOGSTATS |
546 |
|
|
if ((time(NULL)-cst_lst.time_start)>=CS_LOGTIME) |
547 |
|
|
write_cs_stats(); |
548 |
|
|
#endif |
549 |
|
|
|
550 |
|
|
FD_ZERO(&tmp_read); |
551 |
|
|
FD_ZERO(&tmp_write); |
552 |
|
|
FD_ZERO(&tmp_exceptions); |
553 |
|
|
|
554 |
|
|
for(i=0;i<socket_info.allocated_sockets;i++) { |
555 |
|
|
if (init_sockets[i].status == Ns_Dead) { |
556 |
|
|
free_newsocket(&init_sockets[i]); |
557 |
|
|
init_sockets[i].status = Ns_Avail; |
558 |
|
|
socket_info.nconns--; |
559 |
|
|
} else if (init_sockets[i].status != Ns_Avail){ |
560 |
|
|
FD_SET((uint32)init_sockets[i].fd, &tmp_read); |
561 |
|
|
FD_SET((uint32)init_sockets[i].fd, &tmp_write); |
562 |
|
|
FD_SET((uint32)init_sockets[i].fd, &tmp_exceptions); |
563 |
|
|
} |
564 |
|
|
} |
565 |
|
|
|
566 |
|
|
/* Go through the players. Let the loop set the next pl value, |
567 |
|
|
* since we may remove some |
568 |
|
|
*/ |
569 |
|
|
for (pl=first_player; pl!=NULL; ) { |
570 |
|
|
if (pl->socket.status == Ns_Dead) { |
571 |
|
|
player *npl=pl->next; |
572 |
|
|
|
573 |
|
|
save_player(pl->ob, 0); |
574 |
|
|
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
575 |
|
|
terminate_all_pets(pl->ob); |
576 |
|
|
remove_ob(pl->ob); |
577 |
|
|
} |
578 |
|
|
leave(pl,1); |
579 |
|
|
final_free_player(pl); |
580 |
|
|
pl=npl; |
581 |
|
|
} |
582 |
|
|
else { |
583 |
|
|
FD_SET((uint32)pl->socket.fd, &tmp_read); |
584 |
|
|
FD_SET((uint32)pl->socket.fd, &tmp_write); |
585 |
|
|
FD_SET((uint32)pl->socket.fd, &tmp_exceptions); |
586 |
|
|
pl=pl->next; |
587 |
|
|
} |
588 |
|
|
} |
589 |
|
|
|
590 |
root |
1.11 |
#if 0 |
591 |
|
|
// the event system and plugins require the server ti run at all times. |
592 |
|
|
// since its primarily cf.schmorp.de we are interested in, and |
593 |
|
|
// that is supposed to run all the time anyway, its globally disabled |
594 |
|
|
// until we can use Event. |
595 |
root |
1.1 |
if (socket_info.nconns==1 && first_player==NULL) |
596 |
|
|
block_until_new_connection(); |
597 |
root |
1.11 |
#endif |
598 |
root |
1.1 |
|
599 |
|
|
/* Reset timeout each time, since some OS's will change the values on |
600 |
|
|
* the return from select. |
601 |
|
|
*/ |
602 |
|
|
socket_info.timeout.tv_sec = 0; |
603 |
|
|
socket_info.timeout.tv_usec = 0; |
604 |
|
|
|
605 |
|
|
pollret= select(socket_info.max_filedescriptor, &tmp_read, &tmp_write, |
606 |
|
|
&tmp_exceptions, &socket_info.timeout); |
607 |
|
|
|
608 |
|
|
if (pollret==-1) { |
609 |
|
|
LOG(llevError, "select failed: %s\n", strerror_local(errno)); |
610 |
|
|
return; |
611 |
|
|
} |
612 |
|
|
|
613 |
|
|
/* We need to do some of the processing below regardless */ |
614 |
|
|
/* if (!pollret) return;*/ |
615 |
|
|
|
616 |
|
|
/* Following adds a new connection */ |
617 |
|
|
if (pollret && FD_ISSET(init_sockets[0].fd, &tmp_read)) { |
618 |
|
|
int newsocknum=0; |
619 |
|
|
|
620 |
|
|
#ifdef ESRV_DEBUG |
621 |
|
|
LOG(llevDebug,"doeric_server: New Connection\n"); |
622 |
|
|
#endif |
623 |
|
|
/* If this is the case, all sockets currently in used */ |
624 |
|
|
if (socket_info.allocated_sockets <= socket_info.nconns) { |
625 |
|
|
init_sockets = realloc(init_sockets,sizeof(NewSocket)*(socket_info.nconns+1)); |
626 |
|
|
if (!init_sockets) fatal(OUT_OF_MEMORY); |
627 |
|
|
newsocknum = socket_info.allocated_sockets; |
628 |
|
|
socket_info.allocated_sockets++; |
629 |
|
|
init_sockets[newsocknum].faces_sent_len = nrofpixmaps; |
630 |
|
|
init_sockets[newsocknum].faces_sent = malloc(nrofpixmaps*sizeof(*init_sockets[newsocknum].faces_sent)); |
631 |
|
|
if (!init_sockets[newsocknum].faces_sent) fatal(OUT_OF_MEMORY); |
632 |
|
|
init_sockets[newsocknum].status = Ns_Avail; |
633 |
|
|
} |
634 |
|
|
else { |
635 |
|
|
int j; |
636 |
|
|
|
637 |
|
|
for (j=1; j<socket_info.allocated_sockets; j++) |
638 |
|
|
if (init_sockets[j].status == Ns_Avail) { |
639 |
|
|
newsocknum=j; |
640 |
|
|
break; |
641 |
|
|
} |
642 |
|
|
} |
643 |
|
|
init_sockets[newsocknum].fd=accept(init_sockets[0].fd, (struct sockaddr *)&addr, &addrlen); |
644 |
|
|
if (init_sockets[newsocknum].fd==-1) { |
645 |
|
|
LOG(llevError, "accept failed: %s\n", strerror_local(errno)); |
646 |
|
|
} |
647 |
|
|
else { |
648 |
|
|
char buf[MAX_BUF]; |
649 |
|
|
long ip; |
650 |
|
|
NewSocket *ns; |
651 |
|
|
|
652 |
|
|
ns = &init_sockets[newsocknum]; |
653 |
|
|
|
654 |
|
|
ip = ntohl(addr.sin_addr.s_addr); |
655 |
|
|
sprintf(buf, "%ld.%ld.%ld.%ld", (ip>>24)&255, (ip>>16)&255, (ip>>8)&255, ip&255); |
656 |
|
|
|
657 |
|
|
if (checkbanned(NULL, buf)) { |
658 |
|
|
LOG(llevInfo, "Banned host tried to connect: [%s]\n", buf); |
659 |
|
|
close(init_sockets[newsocknum].fd); |
660 |
|
|
init_sockets[newsocknum].fd = -1; |
661 |
|
|
} |
662 |
|
|
else { |
663 |
|
|
InitConnection(ns, buf); |
664 |
|
|
socket_info.nconns++; |
665 |
|
|
} |
666 |
|
|
} |
667 |
|
|
} |
668 |
|
|
|
669 |
|
|
/* Check for any exceptions/input on the sockets */ |
670 |
|
|
if (pollret) for(i=1;i<socket_info.allocated_sockets;i++) { |
671 |
|
|
if (init_sockets[i].status == Ns_Avail) continue; |
672 |
|
|
if (FD_ISSET(init_sockets[i].fd,&tmp_exceptions)) { |
673 |
|
|
free_newsocket(&init_sockets[i]); |
674 |
|
|
init_sockets[i].status = Ns_Avail; |
675 |
|
|
socket_info.nconns--; |
676 |
|
|
continue; |
677 |
|
|
} |
678 |
|
|
if (FD_ISSET(init_sockets[i].fd, &tmp_read)) { |
679 |
|
|
HandleClient(&init_sockets[i], NULL); |
680 |
|
|
} |
681 |
|
|
if (FD_ISSET(init_sockets[i].fd, &tmp_write)) { |
682 |
|
|
init_sockets[i].can_write=1; |
683 |
|
|
} |
684 |
|
|
} |
685 |
|
|
|
686 |
|
|
/* This does roughly the same thing, but for the players now */ |
687 |
|
|
for (pl=first_player; pl!=NULL; pl=next) { |
688 |
|
|
|
689 |
|
|
next=pl->next; |
690 |
|
|
if (pl->socket.status==Ns_Dead) continue; |
691 |
|
|
|
692 |
|
|
if (FD_ISSET(pl->socket.fd,&tmp_write)) { |
693 |
|
|
if (!pl->socket.can_write) { |
694 |
|
|
#if 0 |
695 |
|
|
LOG(llevDebug,"Player %s socket now write enabled\n", pl->ob->name); |
696 |
|
|
#endif |
697 |
|
|
pl->socket.can_write=1; |
698 |
|
|
write_socket_buffer(&pl->socket); |
699 |
|
|
} |
700 |
|
|
/* if we get an error on the write_socket buffer, no reason to |
701 |
|
|
* continue on this socket. |
702 |
|
|
*/ |
703 |
|
|
if (pl->socket.status==Ns_Dead) continue; |
704 |
|
|
} |
705 |
|
|
else pl->socket.can_write=0; |
706 |
|
|
|
707 |
|
|
if (FD_ISSET(pl->socket.fd,&tmp_exceptions)) { |
708 |
|
|
save_player(pl->ob, 0); |
709 |
|
|
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
710 |
|
|
terminate_all_pets(pl->ob); |
711 |
|
|
remove_ob(pl->ob); |
712 |
|
|
} |
713 |
|
|
leave(pl,1); |
714 |
|
|
final_free_player(pl); |
715 |
|
|
} |
716 |
|
|
else { |
717 |
|
|
HandleClient(&pl->socket, pl); |
718 |
|
|
/* If the player has left the game, then the socket status |
719 |
|
|
* will be set to this be the leave function. We don't |
720 |
|
|
* need to call leave again, as it has already been called |
721 |
|
|
* once. |
722 |
|
|
*/ |
723 |
|
|
if (pl->socket.status==Ns_Dead) { |
724 |
|
|
save_player(pl->ob, 0); |
725 |
|
|
if(!QUERY_FLAG(pl->ob,FLAG_REMOVED)) { |
726 |
|
|
terminate_all_pets(pl->ob); |
727 |
|
|
remove_ob(pl->ob); |
728 |
|
|
} |
729 |
|
|
leave(pl,1); |
730 |
|
|
final_free_player(pl); |
731 |
|
|
} else { |
732 |
|
|
|
733 |
|
|
/* Update the players stats once per tick. More efficient than |
734 |
|
|
* sending them whenever they change, and probably just as useful |
735 |
|
|
*/ |
736 |
|
|
esrv_update_stats(pl); |
737 |
|
|
if (pl->last_weight != -1 && pl->last_weight != WEIGHT(pl->ob)) { |
738 |
|
|
esrv_update_item(UPD_WEIGHT, pl->ob, pl->ob); |
739 |
|
|
if(pl->last_weight != WEIGHT(pl->ob)) |
740 |
|
|
LOG(llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n", (unsigned long)pl->last_weight, WEIGHT(pl->ob)); |
741 |
|
|
} |
742 |
root |
1.2 |
/* draw_client_map does sanity checking that map is |
743 |
|
|
* valid, so don't do it here. |
744 |
|
|
*/ |
745 |
|
|
draw_client_map(pl->ob); |
746 |
root |
1.1 |
if (pl->socket.update_look) esrv_draw_look(pl->ob); |
747 |
|
|
} |
748 |
|
|
} |
749 |
|
|
} |
750 |
|
|
} |