Logo Search packages:      
Sourcecode: fceu-server version File versions  Download package

server.cpp

/* 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 <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/fceu-standard.conf"

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(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) > 0)
  {
   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(int);
static void SendToAll(GameEntry *game, int cmd, uint8 *data, uint32 len) throw(int);
static void BroadcastText(GameEntry *game, const char *fmt, ...) throw(int);
static void TextToClient(ClientEntry *client, const char *fmt, ...) throw(int);
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(int)
{
 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(int)
{
 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(int)
{
 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(int)
{
 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(int)
{
 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)
{
 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 ammount 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 conenction 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)
}

Generated by  Doxygen 1.6.0   Back to index