ShuriZma
/
fceux
mirror of https://github.com/TASEmulators/fceux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
fceux/fceux-server/server.cpp

948 lines
24 KiB
C++
Raw Blame History

/* FCE Ultra Network Play Server
*
* Copyright notice for this file:
* Copyright (C) 2004 Xodnizel
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/param.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <unistd.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <exception>
#include "types.h"
#include "md5.h"
#include "throttle.h"
#define VERSION "0.0.5"
#define DEFAULT_PORT 4046
#define DEFAULT_MAX 100
#define DEFAULT_TIMEOUT 5
#define DEFAULT_FRAMEDIVISOR 1
#define DEFAULT_CONFIG "/etc/fceux-server.conf"
// MSG_NOSIGNAL and SOL_TCP have been depreciated on osx
#if defined (__APPLE__) || defined(BSD)
#define MSG_NOSIGNAL SO_NOSIGPIPE
#define SOL_TCP IPPROTO_TCP
#endif
typedef struct {
uint32 id; /* mainly for faster referencing when pointed to from the Games
entries.
*/
char *nickname;
int TCPSocket;
void *game; /* Pointer to the game this player is in. */
int localplayers; /* The number of local players, 1-4 */
time_t timeconnect; /* Time the client made the connection. */
/* Variables to handle non-blocking TCP reads. */
uint8 *nbtcp;
uint32 nbtcphas, nbtcplen;
uint32 nbtcptype;
} ClientEntry;
typedef struct
{
uint8 id[16]; /* Unique 128-bit identifier for this game session. */
uint8 joybuf[5]; /* 4 player data + 1 command byte */
int MaxPlayers; /* Maximum players for this game */
ClientEntry *Players[4]; /* Pointers to player data. */
int IsUnique[4]; /* Set to 1 if player is unique client, 0
if it's a duplicated entry to handle multiple players
per client.
*/
uint8 ExtraInfo[64]; /* Expansion information to be used in future versions
of FCE Ultra.
*/
} GameEntry;
typedef struct
{
unsigned int MaxClients; /* The maximum number of clients to allow. */
/* You should expect each client to use
65-70Kbps(not including save state loads) while
connected(and logged in), when using the default
FrameDivisor value of 1.
*/
unsigned int ConnectTimeout; /* How long to wait(in seconds) for the client to provide
login data before disconnecting the client.
*/
unsigned int FrameDivisor; /* The number of updates per second are divided
by this number. 1 = 60 updates/sec(approx),
2 = 30 updates/sec, etc. */
unsigned int Port; /* The port to listen on. */
uint8 *Password; /* The server password. */
} CONFIG;
CONFIG ServerConfig;
int LoadConfigFile(const char *fn)
{
FILE *fp;
ServerConfig.Port = ServerConfig.MaxClients = ServerConfig.ConnectTimeout = ServerConfig.FrameDivisor = ~0;
if(fp=fopen(fn,"rb"))
{
char buf[256];
while(fgets(buf, 256, fp) != NULL)
{
if(!strncasecmp(buf,"maxclients",strlen("maxclients")))
sscanf(buf,"%*s %d",&ServerConfig.MaxClients);
else if(!strncasecmp(buf,"connecttimeout",strlen("connecttimeout")))
sscanf(buf,"%*s %d",&ServerConfig.ConnectTimeout);
else if(!strncasecmp(buf,"framedivisor",strlen("framedivisor")))
sscanf(buf,"%*s %d",&ServerConfig.FrameDivisor);
else if(!strncasecmp(buf,"port",strlen("port")))
sscanf(buf,"%*s %d",&ServerConfig.Port);
else if(!strncasecmp(buf,"password",strlen("password")))
{
char *pass = 0;
sscanf(buf,"%*s %as",&pass);
if(pass)
{
struct md5_context md5;
ServerConfig.Password = (uint8 *)malloc(16);
md5_starts(&md5);
md5_update(&md5,(uint8*)pass,strlen(pass));
md5_finish(&md5,ServerConfig.Password);
puts("Password required to log in.");
}
}
}
}
else
{
printf("Cannot load configuration file %s.\n", fn);
return(0);
}
if(~0 == (ServerConfig.Port & ServerConfig.MaxClients & ServerConfig.ConnectTimeout & ServerConfig.FrameDivisor))
{
puts("Incomplete configuration file");
return(0);
}
//printf("%d,%d,%d\n",ServerConfig.MaxClients,ServerConfig.ConnectTimeout,ServerConfig.FrameDivisor);
printf("Using configuration file located at %s\n", fn);
return(1);
}
static ClientEntry *Clients;
static GameEntry *Games;
static void en32(uint8 *buf, uint32 morp)
{
buf[0]=morp;
buf[1]=morp>>8;
buf[2]=morp>>16;
buf[3]=morp>>24;
}
static uint32 de32(uint8 *morp)
{
return(morp[0]|(morp[1]<<8)|(morp[2]<<16)|(morp[3]<<24));
}
static char *CleanNick(char *nick);
static int NickUnique(ClientEntry *client);
static void AddClientToGame(ClientEntry *client, uint8 id[16], uint8 extra[64]) throw();
static void SendToAll(GameEntry *game, int cmd, uint8 *data, uint32 len) throw();
static void BroadcastText(GameEntry *game, const char *fmt, ...) throw();
static void TextToClient(ClientEntry *client, const char *fmt, ...) throw();
static void KillClient(ClientEntry *client);
#define NBTCP_LOGINLEN 0x100
#define NBTCP_LOGIN 0x200
#define NBTCP_COMMANDLEN 0x300
#define NBTCP_COMMAND 0x400
#define NBTCP_UPDATEDATA 0x800
static void StartNBTCPReceive(ClientEntry *client, uint32 type, uint32 len)
{
client->nbtcp = (uint8 *)malloc(len);
client->nbtcplen = len;
client->nbtcphas = 0;
client->nbtcptype = type;
}
static void RedoNBTCPReceive(ClientEntry *client)
{
client->nbtcphas = 0;
}
static void EndNBTCPReceive(ClientEntry *client)
{
free(client->nbtcp);
client->nbtcplen = client->localplayers;
client->nbtcphas = 0;
client->nbtcptype = 0;
client->nbtcp = 0;
}
static uint8 *MakeMPS(ClientEntry *client)
{
static uint8 buf[64];
uint8 *bp = buf;
int x;
GameEntry *game = (GameEntry *)client->game;
for(x=0;x<4;x++)
{
if(game->Players[x] == client)
{
*bp = '0' + x + 1;
bp++;
*bp = ',';
bp++;
}
}
if(*(bp-1) == ',') bp--;
*bp = 0;
return(buf);
}
/* Returns 1 if we are back to normal game mode, 0 if more data is yet to arrive. */
static int CheckNBTCPReceive(ClientEntry *client) throw()
{
if(!client->nbtcplen)
throw(1); /* Should not happen. */
int l;
while(l = recv(client->TCPSocket, client->nbtcp + client->nbtcphas, client->nbtcplen - client->nbtcphas, MSG_NOSIGNAL))
{
if(l == -1)
{
if(errno == EAGAIN || errno == EWOULDBLOCK)
break;
throw(1); /* Die now. NOW. */
}
client->nbtcphas += l;
//printf("Read: %d, %04x, %d, %d\n",l,client->nbtcptype,client->nbtcphas, client->nbtcplen);
/* We're all full. Yippie. */
if(client->nbtcphas == client->nbtcplen)
{
uint32 len;
switch(client->nbtcptype & 0xF00)
{
case NBTCP_UPDATEDATA:
{
GameEntry *game = (GameEntry *)client->game;
int x, wx;
if(client->nbtcp[0] == 0xFF)
{
EndNBTCPReceive(client);
StartNBTCPReceive(client, NBTCP_COMMANDLEN, 5);
return(1);
}
for(x=0,wx=0; x < 4; x++)
{
if(game->Players[x] == client)
{
game->joybuf[x] = client->nbtcp[wx];
wx++;
}
}
RedoNBTCPReceive(client);
}
return(1);
case NBTCP_COMMANDLEN:
{
uint8 cmd = client->nbtcp[4];
len = de32(client->nbtcp);
if(len > 200000) /* Sanity check. */
throw(1);
//printf("%02x, %d\n",cmd,len);
if(!len && !(cmd&0x80))
{
SendToAll((GameEntry*)client->game, client->nbtcp[4], 0, 0);
EndNBTCPReceive(client);
StartNBTCPReceive(client,NBTCP_UPDATEDATA,client->localplayers);
}
else if(client->nbtcp[4]&0x80)
{
EndNBTCPReceive(client);
if(len)
{
StartNBTCPReceive(client,NBTCP_COMMAND | cmd,len);
}
else
{
/* Woops. Client probably tried to send a text message of 0 length.
Or maybe a 0-length cheat file? Better be safe! */
StartNBTCPReceive(client,NBTCP_UPDATEDATA,client->localplayers);
}
}
else throw(1);
return(1);
}
case NBTCP_COMMAND:
{
len = client->nbtcplen;
uint32 tocmd = client->nbtcptype & 0xFF;
if(tocmd == 0x90) /* Text */
{
char *ma, *ma2;
ma = (char *) malloc(len + 1);
memcpy(ma, client->nbtcp, len);
ma[len] = 0;
asprintf(&ma2, "<%s> %s",client->nickname,ma);
free(ma);
ma = ma2;
len=strlen(ma);
SendToAll((GameEntry*)client->game, tocmd, (uint8 *)ma, len);
free(ma);
}
else
{
SendToAll((GameEntry*)client->game, tocmd, client->nbtcp, len);
}
EndNBTCPReceive(client);
StartNBTCPReceive(client,NBTCP_UPDATEDATA,client->localplayers);
return(1);
}
case NBTCP_LOGINLEN:
len = de32(client->nbtcp);
if(len > 1024 || len < (16 + 16 + 64 + 1))
throw(1);
EndNBTCPReceive(client);
StartNBTCPReceive(client,NBTCP_LOGIN,len);
return(1);
case NBTCP_LOGIN:
{
uint32 len;
uint8 gameid[16];
uint8 *sexybuf;
uint8 extra[64];
len = client->nbtcplen;
sexybuf = client->nbtcp;
/* Game ID(MD5'd game MD5 and password on client side). */
memcpy(gameid, sexybuf, 16);
sexybuf += 16;
len -= 16;
if(ServerConfig.Password)
if(memcmp(ServerConfig.Password,sexybuf,16))
{
TextToClient(client,"Invalid server password.");
throw(1);
}
sexybuf += 16;
len -= 16;
memcpy(extra, sexybuf, 64);
sexybuf += 64;
len -= 64;
client->localplayers = *sexybuf;
if(client->localplayers < 1 || client->localplayers > 4)
{
TextToClient(client,"Invalid number(%d) of local players!",client->localplayers);
throw(1);
}
sexybuf++;
len -= 1;
AddClientToGame(client, gameid, extra);
/* Get the nickname */
if(len)
{
client->nickname = (char *)malloc(len + 1);
memcpy(client->nickname, sexybuf, len);
client->nickname[len] = 0;
if((client->nickname = CleanNick(client->nickname)))
if(!NickUnique(client)) /* Nickname already exists */
{
free(client->nickname);
client->nickname = 0;
}
}
uint8 *mps = MakeMPS(client);
if(!client->nickname)
asprintf(&client->nickname,"*Player %s",mps);
printf("Client %d assigned to game %d as player %s <%s>\n",client->id,(GameEntry*)client->game - Games,mps, client->nickname);
int x;
GameEntry *tg=(GameEntry *)client->game;
for(x=0; x<tg->MaxPlayers; x++)
{
if(tg->Players[x] && tg->IsUnique[x])
{
if(tg->Players[x] != client)
{
try
{
TextToClient(tg->Players[x], "* Player %s has just connected as: %s",MakeMPS(client),client->nickname);
}
catch(int i)
{
KillClient(tg->Players[x]);
}
TextToClient(client, "* Player %s is already connected as: %s",MakeMPS(tg->Players[x]),tg->Players[x]->nickname);
}
else
TextToClient(client, "* You(Player %s) have just connected as: %s",MakeMPS(client),client->nickname);
}
}
}
EndNBTCPReceive(client);
StartNBTCPReceive(client,NBTCP_UPDATEDATA,client->localplayers);
return(1);
}
}
}
return(0);
}
int ListenSocket;
static char *CleanNick(char *nick)
{
int x;
for(x=0; x<strlen(nick); x++)
if(nick[x] == '<' || nick[x] == '>' || nick[x] == '*' || (nick[x] < 0x20))
nick[x] = 0;
if(!strlen(nick))
{
free(nick);
nick = 0;
}
return(nick);
}
static int NickUnique(ClientEntry *client)
{
int x;
GameEntry *game = (GameEntry *)client-> game;
for(x=0; x<game->MaxPlayers; x++)
if(game->Players[x] && client != game->Players[x])
if(!strcasecmp(client->nickname, game->Players[x]->nickname))
return(0);
return(1);
}
static int MakeSendTCP(ClientEntry *client, uint8 *data, uint32 len) throw()
{
if(send(client->TCPSocket, data, len, MSG_NOSIGNAL) != len)
throw(1);
return(1);
}
static void SendToAll(GameEntry *game, int cmd, uint8 *data, uint32 len) throw()
{
uint8 poo[5];
int x;
poo[4] = cmd;
for(x=0;x<game->MaxPlayers;x++)
{
if(!game->Players[x] || !game->IsUnique[x]) continue;
try
{
if(cmd & 0x80)
en32(poo, len);
MakeSendTCP(game->Players[x],poo,5);
if(cmd & 0x80)
{
MakeSendTCP(game->Players[x], data, len);
}
}
catch(int i)
{
KillClient(game->Players[x]);
}
}
}
static void TextToClient(ClientEntry *client, const char *fmt, ...) throw()
{
char *moo;
va_list ap;
va_start(ap,fmt);
vasprintf(&moo, fmt, ap);
va_end(ap);
uint8 poo[5];
uint32 len;
poo[4] = 0x90;
len = strlen(moo);
en32(poo, len);
MakeSendTCP(client, poo, 5);
MakeSendTCP(client, (uint8*)moo, len);
free(moo);
}
static void BroadcastText(GameEntry *game, const char *fmt, ...) throw()
{
char *moo;
va_list ap;
va_start(ap,fmt);
vasprintf(&moo, fmt, ap);
va_end(ap);
SendToAll(game, 0x90,(uint8 *)moo,strlen(moo));
free(moo);
}
static void KillClient(ClientEntry *client)
{
GameEntry *game;
uint8 *mps;
char *bmsg;
game = (GameEntry *)client->game;
if(game)
{
int w;
int tc = 0;
for(w=0;w<game->MaxPlayers;w++)
if(game->Players[w]) tc++;
for(w=0;w<game->MaxPlayers;w++)
if(game->Players[w])
if(game->Players[w] == client)
game->Players[w] = NULL;
time_t curtime = time(0);
printf("Player <%s> disconnected from game %d on %s",client->nickname,game-Games,ctime(&curtime));
asprintf(&bmsg, "* Player %s <%s> left.",MakeMPS(client),client->nickname);
if(tc == client->localplayers) /* If total players for this game = total local
players for this client, destroy the game.
*/
{
printf("Game %d destroyed.\n",game-Games);
memset(game, 0, sizeof(GameEntry));
game = 0;
}
}
else
{
time_t curtime = time(0);
printf("Unassigned client %d disconnected on %s",client->id, ctime(&curtime));
}
if(client->nbtcp)
free(client->nbtcp);
if(client->nickname)
free(client->nickname);
if(client->TCPSocket != -1)
close(client->TCPSocket);
memset(client, 0, sizeof(ClientEntry));
client->TCPSocket = -1;
if(game)
BroadcastText(game,"%s",bmsg);
}
static void AddClientToGame(ClientEntry *client, uint8 id[16], uint8 extra[64]) throw()
{
int wg;
GameEntry *game,*fegame;
retry:
game = NULL;
fegame = NULL;
/* First, find an available game. */
for(wg=0; wg<ServerConfig.MaxClients; wg++)
{
if(!Games[wg].MaxPlayers && !fegame)
{
if(!fegame)
fegame=&Games[wg];
}
else if(!memcmp(Games[wg].id,id,16)) /* A match was found! */
{
game = &Games[wg];
break;
}
}
if(!game) /* Hmm, no game found. Guess we'll have to create one. */
{
game=fegame;
printf("Game %d added\n",game-Games);
memset(game, 0, sizeof(GameEntry));
game->MaxPlayers = 4;
memcpy(game->id, id, 16);
memcpy(game->ExtraInfo, extra, 64);
}
int n;
for(n = 0; n < game->MaxPlayers; n++)
if(game->Players[n])
{
try
{
uint8 b[5];
b[4] = 0x81;
MakeSendTCP(game->Players[n], b, 5);
break;
}
catch(int i)
{
KillClient(game->Players[n]);
/* All right, now the client we sent the request to is killed. I HOPE YOU'RE HAPPY! */
/* Since killing a client can destroy a game, we'll need to see if the game was trashed.
If it was, then "goto retry", and try again. Ugly, yes. I LIKE UGLY.
*/
if(!game->MaxPlayers)
goto retry;
}
}
int instancecount = client->localplayers;
for(n=0; n<game->MaxPlayers; n++)
{
if(!game->Players[n])
{
game->Players[n] = client;
if(instancecount == client->localplayers)
game->IsUnique[n] = 1;
else
game->IsUnique[n] = 0;
instancecount --;
if(!instancecount)
break;
}
}
/* Game is full. */
if(n == game->MaxPlayers)
{
for(n=0; n<game->MaxPlayers; n++)
if(game->Players[n] == client)
game->Players[n] = 0;
TextToClient(client, "Sorry, game is full. %d instance(s) tried, %d available.",client->localplayers,client->localplayers - instancecount);
throw(1);
}
client->game = (void *)game;
}
int main(int argc, char *argv[])
{
struct sockaddr_in sockin;
socklen_t sockin_len;
int i;
char* pass = 0;
/* If we can't load the default config file, use some defined values */
if(!LoadConfigFile(DEFAULT_CONFIG))
{
ServerConfig.Port = DEFAULT_PORT;
ServerConfig.MaxClients = DEFAULT_MAX;
ServerConfig.ConnectTimeout = DEFAULT_TIMEOUT;
ServerConfig.FrameDivisor = DEFAULT_FRAMEDIVISOR;
}
char* configfile = 0;
for(i=1; i<argc ;i++)
{
if(!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h"))
{
printf("Usage: %s [OPTION]...\n" ,argv[0]);
printf("Begins the FCE Ultra game server with given options.\n");
printf("This server will first look in %s for options. If that \nfile does not exist, it will use the defaults given here. Any argument given \ndirectly will override any default values.\n\n", DEFAULT_CONFIG);
printf("-h\t--help\t\tDisplays this help message.\n");
printf("-v\t--version\t\tDisplays the version number and quits.\n");
printf("-p\t--port\t\tStarts server on given port. (default=%d)\n", DEFAULT_PORT);
printf("-w\t--password\tSpecifies a password for entry.\n");
printf("-m\t--maxclients\tSpecifies the maximum amount of clients allowed \n\t\t\tto access the server. (default=%d)\n", DEFAULT_MAX);
printf("-t\t--timeout\tSpecifies the amount of seconds before the server \n\t\t\ttimes out. (default=%d)\n", DEFAULT_TIMEOUT);
printf("-f\t--framedivisor\tSpecifies frame divisor.\n\t\t\t(eg: 60 / framedivisor = updates per second)(default=%d)\n", DEFAULT_FRAMEDIVISOR);
printf("-c\t--configfile\tLoads the given configuration file.\n");
return -1;
}
if(!strcmp(argv[i], "--port") || !strcmp(argv[i], "-p"))
{
i++;
if(argc == i)
{
printf("Please specify a port to use.\n");
return -1;
}
ServerConfig.Port = atoi(argv[i]);
continue;
}
if(!strcmp(argv[i], "--password") || !strcmp(argv[i], "-w"))
{
i++;
if(argc == i)
{
printf("Please specify a password.\n");
return -1;
}
pass = argv[i];
struct md5_context md5;
ServerConfig.Password = (uint8 *)malloc(16);
md5_starts(&md5);
md5_update(&md5,(uint8*)pass,strlen(pass));
md5_finish(&md5,ServerConfig.Password);
puts("Password required to log in.");
continue;
}
if(!strcmp(argv[i], "--maxclients") || !strcmp(argv[i], "-m"))
{
i++;
if(argc == i)
{
printf("Please specify the maximium amount of clients.\n");
return -1;
}
ServerConfig.MaxClients = atoi(argv[i]);
continue;
}
if(!strcmp(argv[i], "--timeout") || !strcmp(argv[i], "-t"))
{
i++;
if(argc == i)
{
printf("Please specify the connection timeout time in seconds.\n");
return -1;
}
ServerConfig.ConnectTimeout = atoi(argv[i]);
continue;
}
if(!strcmp(argv[i], "--framedivisor") || !strcmp(argv[i], "-f"))
{
i++;
if(argc == i)
{
printf("Please specify a framedivisor.\n");
return -1;
}
ServerConfig.FrameDivisor = atoi(argv[i]);
continue;
}
if(!strcmp(argv[i], "--configfile") || !strcmp(argv[i], "-c"))
{
i++;
if(argc == i)
{
printf("Please specify a configfile to load.\n");
return -1;
}
if(!LoadConfigFile(argv[i]))
{
puts("Error loading configuration file.");
exit(-1);
}
continue;
}
if(!strcmp(argv[i], "--version") || !strcmp(argv[i], "-v"))
{
printf("FCE Ultra network server version %s\n", VERSION);
return 0;
}
/* If we've gotten here, we don't know what the argument is */
printf("Invalid parameter: %s\n", argv[i]);
return -1;
}
Games = (GameEntry *)malloc(sizeof(GameEntry) * ServerConfig.MaxClients);
Clients = (ClientEntry *)malloc(sizeof(ClientEntry) * ServerConfig.MaxClients);
memset(Games,0,sizeof(GameEntry) * ServerConfig.MaxClients);
memset(Clients,0,sizeof(ClientEntry) * ServerConfig.MaxClients);
{
int x;
for(x=0; x<ServerConfig.MaxClients; x++)
Clients[x].TCPSocket = -1;
}
RefreshThrottleFPS(ServerConfig.FrameDivisor);
/* First, we need to create a socket to listen on. */
ListenSocket = socket(AF_INET, SOCK_STREAM, 0);
/* Set send buffer size to 262,144 bytes. */
int sndbufsize = 262144;
if(setsockopt(ListenSocket, SOL_SOCKET, SO_SNDBUF, &sndbufsize, sizeof(int)))
printf("Send buffer size set failed: %s",strerror(errno));
int tcpopt = 1;
if(setsockopt(ListenSocket, SOL_TCP, TCP_NODELAY, &tcpopt, sizeof(int)))
{
printf("Nodelay fail: %s",strerror(errno));
exit(-1);
}
memset(&sockin, 0, sizeof(sockin));
sockin.sin_family = AF_INET;
sockin.sin_addr.s_addr = INADDR_ANY;
sockin_len = sizeof(sockin);
sockin.sin_port = htons(ServerConfig.Port);
printf("Binding to port %d... ",ServerConfig.Port);
if(bind(ListenSocket, (struct sockaddr *)&sockin, sockin_len))
{
printf("Error: %s\n",strerror(errno));
exit(-1);
}
puts("Ok");
printf("Listening on socket... ");
if(listen(ListenSocket, 8))
{
printf("Error: %s",strerror(errno));
exit(-1);
}
puts("Ok");
/* We don't want to block on accept() */
fcntl(ListenSocket, F_SETFL, fcntl(ListenSocket, F_GETFL) | O_NONBLOCK);
/* Now for the BIG LOOP. */
while(1)
{
int n;
for(n=0; n<ServerConfig.MaxClients; n++)
{
if(Clients[n].TCPSocket != -1) continue;
if((Clients[n].TCPSocket = accept(ListenSocket, (struct sockaddr *)&sockin, &sockin_len)) != -1)
{
struct sockaddr_in usockin;
/* We have a new client. Yippie. */
fcntl(Clients[n].TCPSocket, F_SETFL, fcntl(Clients[n].TCPSocket, F_GETFL) | O_NONBLOCK);
Clients[n].timeconnect = time(0);
Clients[n].id = n;
printf("Client %d connecting from %s on %s",n,inet_ntoa(sockin.sin_addr),ctime(&Clients[n].timeconnect));
{
uint8 buf[1];
buf[0] = ServerConfig.FrameDivisor;
send(Clients[n].TCPSocket,buf,1,MSG_NOSIGNAL);
}
StartNBTCPReceive(&Clients[n], NBTCP_LOGINLEN, 4);
}
}
/* Check for users still in the login process(not yet assigned a game). BOING */
time_t curtime = time(0);
for(n = 0; n < ServerConfig.MaxClients; n++)
try
{
if(Clients[n].TCPSocket != -1 && !Clients[n].game)
{
if((Clients[n].timeconnect + ServerConfig.ConnectTimeout) < curtime)
{
KillClient(&Clients[n]);
}
else
while(CheckNBTCPReceive(&Clients[n])) {};
}
}
catch(int i)
{
KillClient(&Clients[n]);
}
int whichgame;
for(whichgame = 0; whichgame < ServerConfig.MaxClients; whichgame ++)
{
/* Now, the loop to get data from each client. Meep. */
for(n = 0; n < Games[whichgame].MaxPlayers; n++)
{
try
{
ClientEntry *client = Games[whichgame].Players[n];
if(!client || !Games[whichgame].IsUnique[n]) continue;
int localplayers = client->localplayers;
while(CheckNBTCPReceive(client)) {};
} // catch
catch(int i)
{
KillClient(Games[whichgame].Players[n]);
}
} // A games clients
/* Now we send the data to all the clients. */
for(n = 0; n < Games[whichgame].MaxPlayers; n++)
{
if(!Games[whichgame].Players[n] || !Games[whichgame].IsUnique[n]) continue;
try
{
MakeSendTCP(Games[whichgame].Players[n], Games[whichgame].joybuf, 5);
}
catch(int i)
{
KillClient(Games[whichgame].Players[n]);
}
} // A game's clients
} // Games
SpeedThrottle();
} // while(1)
}
Reference in New Issue View Git Blame Copy Permalink