remove sub-world concept

[carveJwlIkooP6JGAAIwe30JlM.git] / gameserver.c

/*
 * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
 */

#define _DEFAULT_SOURCE
#include <signal.h>
#include <unistd.h>
#include <time.h>

volatile sig_atomic_t sig_stop;

#include "gameserver.h" 
#include "highscores.c"
#include "servermonitor_server.c"
#include "vg/vg_opt.h"
#include "network_common.h"
#include "gameserver_db.h"
#include "vg/vg_m.h"
#include "vg/vg_msg.h"

static void inthandler( int signum ) {
   sig_stop = 1;
}

static const u64 k_connection_unauthorized = 0xffffffffffffffff;

static u64_steamid get_connection_authsteamid( SteamNetworkingMessage_t *msg ){
   i64 userdata = SteamAPI_ISteamNetworkingSockets_GetConnectionUserData(
            hSteamNetworkingSockets, msg->m_conn );

   return *((u64_steamid *)&userdata);
}

static void set_connection_authsteamid(HSteamNetConnection con, u64_steamid id){
   i64 userdata = *((i64 *)&id);
   
   SteamAPI_ISteamNetworkingSockets_SetConnectionUserData(
         hSteamNetworkingSockets, con, userdata );
}

static void gameserver_send_to_all( int ignore, 
                                    const void *pData, u32 cbData, 
                                    int nSendFlags ){
   for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
      struct gameserver_client *client = &gameserver.clients[i];

      if( (i==ignore) || !client->active )
         continue;

      SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
            hSteamNetworkingSockets, client->connection,
            pData, cbData, nSendFlags, NULL );
   }
}

static void gameserver_player_join( int index ){
   struct gameserver_client *joiner = &gameserver.clients[index];
   
   netmsg_playerjoin join = { .inetmsg_id = k_inetmsg_playerjoin,
                              .index = index };
   gameserver_send_to_all( index, &join, sizeof(join),
                           k_nSteamNetworkingSend_Reliable );

   /* update the joining user about current connections */

   netmsg_playerusername *username = 
      alloca( sizeof(netmsg_playerusername) + NETWORK_USERNAME_MAX );
   username->inetmsg_id = k_inetmsg_playerusername;

   netmsg_playeritem *item = 
      alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
   item->inetmsg_id = k_inetmsg_playeritem;

   for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
      struct gameserver_client *client = &gameserver.clients[i];

      if( (i==index) || !client->active )
         continue;

      /* join */
      netmsg_playerjoin init = { .inetmsg_id = k_inetmsg_playerjoin,
                                 .index = i };
      SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
            hSteamNetworkingSockets, joiner->connection,
            &init, sizeof(init), k_nSteamNetworkingSend_Reliable, NULL );

      /* username */
      username->index = i;
      u32 chs = vg_strncpy( client->username, username->name, 
                            NETWORK_USERNAME_MAX,
                            k_strncpy_always_add_null );
      u32 size = sizeof(netmsg_playerusername) + chs + 1;
      SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
            hSteamNetworkingSockets, joiner->connection,
            username, size, k_nSteamNetworkingSend_Reliable, NULL );

      /* items */
      for( int j=0; j<k_netmsg_playeritem_max; j++ ){
         chs = vg_strncpy( client->items[j], item->uid, ADDON_UID_MAX, 
                           k_strncpy_always_add_null );
         item->type_index = j;
         item->client = i;
         size = sizeof(netmsg_playeritem) + chs + 1;
         SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
               hSteamNetworkingSockets, joiner->connection,
               item, size, k_nSteamNetworkingSend_Reliable, NULL );
      }
   }
}

static void gameserver_player_leave( int index ){
   netmsg_playerjoin leave;
   leave.inetmsg_id = k_inetmsg_playerleave;
   leave.index = index;

   vg_info( "Player leave (%d)\n", index );
   gameserver_send_to_all( index, &leave, sizeof(leave),
                           k_nSteamNetworkingSend_Reliable );
}

static void new_client_connecting( HSteamNetConnection client ){
   int index = -1;

   /* TODO: LRU */
   for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
      if( !gameserver.clients[i].active ){
         index = i;
         break;
      }
   }

   if( index == -1 ){
      vg_error( "Server full\n" );
      SteamAPI_ISteamNetworkingSockets_CloseConnection( 
            hSteamNetworkingSockets, client, 
            4500,
            NULL, 1 );
      return;
   }

   EResult accept_status = SteamAPI_ISteamNetworkingSockets_AcceptConnection(
            hSteamNetworkingSockets, client );
   if( accept_status == k_EResultOK ){
      vg_success( "Accepted client (id: %u, index: %d)\n", client, index );
      memset( &gameserver.clients[index], 0, sizeof(struct gameserver_client) );

      gameserver.clients[index].active = 1;
      gameserver.clients[index].connection = client;

      SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup(
            hSteamNetworkingSockets,
            client, gameserver.client_group );
      
      /* Just to be sure */
      set_connection_authsteamid( client, -1 );
      gameserver_player_join( index );
   }
   else{
      vg_warn( "Error accepting client (id: %u)\n", client );
      SteamAPI_ISteamNetworkingSockets_CloseConnection( 
            hSteamNetworkingSockets, client, 
            k_ESteamNetConnectionEnd_Misc_InternalError,
            NULL, 1 );
      gameserver.clients[index].active = 0;
      gameserver.clients[index].connection = 0;
   }
}

static void on_auth_status( CallbackMsg_t *msg ){
   SteamNetAuthenticationStatus_t *info = (void *)msg->m_pubParam;
   vg_info( "  Authentication availibility: %s\n", 
         string_ESteamNetworkingAvailability(info->m_eAvail) );
   vg_info( "  %s\n", info->m_debugMsg );
}

static int gameserver_client_index( HSteamNetConnection hconn ){
   for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
      struct gameserver_client *client = &gameserver.clients[i];

      if( client->active ){
         if( client->connection == hconn ){
            return i;
         }
      }
   }
   return -1;
}

static void on_connect_status( CallbackMsg_t *msg ){
   SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
   vg_info( "  Connection status changed for %lu\n", info->m_hConn );

   vg_info( "  %s -> %s\n", 
         string_ESteamNetworkingConnectionState(info->m_eOldState),
         string_ESteamNetworkingConnectionState(info->m_info.m_eState) );

   if( info->m_info.m_eState==k_ESteamNetworkingConnectionState_Connecting ){
      new_client_connecting( info->m_hConn );
   }

   if( (info->m_info.m_eState == 
            k_ESteamNetworkingConnectionState_ClosedByPeer ) ||
       (info->m_info.m_eState == 
        k_ESteamNetworkingConnectionState_ProblemDetectedLocally ) ){

      int client_id = gameserver_client_index( info->m_hConn );
      if( client_id != -1 ){
         struct gameserver_client *client = &gameserver.clients[client_id];
         client->connection = 0;
         client->active = 0;
         gameserver_player_leave(client_id);
      }

      vg_info( "End reason: %d\n", info->m_info.m_eEndReason );
      SteamAPI_ISteamNetworkingSockets_CloseConnection( 
            hSteamNetworkingSockets, info->m_hConn, 0, NULL, 0 );
   }
}

static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){
   if( gameserver.auth_mode != eServerModeAuthentication ){
      vg_error( "Running server without authentication. "
                "Connection %u tried to authenticate.\n", msg->m_conn );
      return;
   }

   if( get_connection_authsteamid( msg ) != k_connection_unauthorized ){
      vg_warn( "Already authorized this user but app ticket was sent"
               " again (%u)\n", msg->m_conn );
      return;
   }

   vg_low( "Attempting to verify user\n" );

   if( msg->m_cbSize < sizeof(netmsg_auth) ){
      vg_error( "Malformed auth ticket, too small (%u)\n", msg->m_conn );
      return;
   }

   netmsg_auth *auth = msg->m_pData;

   if( msg->m_cbSize < sizeof(netmsg_auth)+auth->ticket_length ||
       auth->ticket_length > 1024 ){
      vg_error( "Malformed auth ticket, ticket_length incorrect (%u)\n",
            auth->ticket_length );
      return;
   }

   u8 decrypted[1024];
   u32 ticket_len = 1024;

   int success = SteamEncryptedAppTicket_BDecryptTicket(
         auth->ticket, auth->ticket_length, decrypted,
         &ticket_len, gameserver.app_symmetric_key,
         k_nSteamEncryptedAppTicketSymmetricKeyLen );

   if( !success ){
      vg_error( "Failed to decrypt users ticket (client %u)\n", msg->m_conn );
      vg_error( "  ticket length: %u\n", auth->ticket_length );

      SteamAPI_ISteamNetworkingSockets_CloseConnection(
            hSteamNetworkingSockets,
            msg->m_conn, 0, NULL, 1 );
      return;
   }

   if( SteamEncryptedAppTicket_GetTicketIssueTime( decrypted, ticket_len )){
      RTime32 ctime = time(NULL),
              tickettime = SteamEncryptedAppTicket_GetTicketIssueTime(
                    decrypted, ticket_len ),
              expiretime = tickettime + 24*3*60*60;
      
      if( ctime > expiretime ){
         vg_error( "Ticket expired (client %u)\n", msg->m_conn );

         /* TODO: Send expired information */
         SteamAPI_ISteamNetworkingSockets_CloseConnection(
               hSteamNetworkingSockets,
               msg->m_conn, 0, NULL, 1 );
         return;
      }
   }

   CSteamID steamid;
   SteamEncryptedAppTicket_GetTicketSteamID( decrypted, ticket_len, &steamid );
   vg_success( "User is authenticated! steamid %lu (%u)\n", 
         steamid.m_unAll64Bits, msg->m_conn );

   set_connection_authsteamid( msg->m_conn, steamid.m_unAll64Bits );
}

static int inet_require_auth( SteamNetworkingMessage_t *msg ){
   if( gameserver.auth_mode == eServerModeNoAuthentication )
      return 1;

   if( get_connection_authsteamid( msg ) == k_connection_unauthorized ){
      vg_warn( "Unauthorized request! Disconnecting client: %u\n", 
               msg->m_conn );

      SteamAPI_ISteamNetworkingSockets_CloseConnection(
            hSteamNetworkingSockets,
            msg->m_conn, 0, NULL, 1 );

      return 0;
   }
   else return 1;
}

/*
 * Player updates sent to us
 * -----------------------------------------------------------------------------
 */

static int packet_minsize( SteamNetworkingMessage_t *msg, u32 size ){
   if( msg->m_cbSize < size ) {
      vg_error( "Invalid packet size (must be at least %u)\n", size );
      return 0;
   }
   else{
      return 1;
   }
}

struct db_set_username_thread_data {
   u64 steamid;
   char username[ NETWORK_USERNAME_MAX ];
};

static void gameserver_update_db_username( db_request *db_req ){
   struct db_set_username_thread_data *inf = (void *)db_req->data;

   if( inf->steamid == k_connection_unauthorized )
      return;

   int admin = 0;
   if( inf->steamid == 76561198072130043 )
      admin = 2;

   db_updateuser( inf->steamid, inf->username, admin );
}

static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){
   netmsg_blank *tmp = msg->m_pData;

   int client_id = gameserver_client_index( msg->m_conn );
   if( client_id == -1 ) return;

   if( tmp->inetmsg_id == k_inetmsg_playerusername ){
      if( !packet_minsize( msg, sizeof(netmsg_playerusername)+1 ))
         return;
      
      struct gameserver_client *client = &gameserver.clients[ client_id ];
      netmsg_playerusername *src = msg->m_pData;

      u32 name_len = network_msgstring( src->name, msg->m_cbSize, 
                                        sizeof(netmsg_playerusername),
                                        client->username, 
                                        NETWORK_USERNAME_MAX );

      /* update other users about this change */
      netmsg_playerusername *prop = alloca(sizeof(netmsg_playerusername)+
                                             NETWORK_USERNAME_MAX );
                                           
      prop->inetmsg_id = k_inetmsg_playerusername;
      prop->index = client_id;
      u32 chs = vg_strncpy( client->username, prop->name, NETWORK_USERNAME_MAX,
                            k_strncpy_always_add_null );

      vg_info( "client #%d changed name to: %s\n", client_id, prop->name );

      u32 propsize = sizeof(netmsg_playerusername) + chs + 1;
      gameserver_send_to_all( client_id, prop, propsize,
                              k_nSteamNetworkingSend_Reliable );

      /* update database about this */
      db_request *call = db_alloc_request( 
                           sizeof(struct db_set_username_thread_data) );
      struct db_set_username_thread_data *inf = (void *)call->data;
      inf->steamid = get_connection_authsteamid( msg );
      vg_strncpy( client->username, inf->username, 
                  sizeof(inf->username), k_strncpy_always_add_null );
      call->handler = gameserver_update_db_username;
      db_send_request( call );
   }
   else if( tmp->inetmsg_id == k_inetmsg_playerframe ){
      /* propogate */
      netmsg_playerframe *frame = alloca(msg->m_cbSize);
      memcpy( frame, msg->m_pData, msg->m_cbSize );
      frame->client = client_id;
      gameserver_send_to_all( client_id, frame, msg->m_cbSize, 
                              k_nSteamNetworkingSend_Unreliable );
   }
   else if( tmp->inetmsg_id == k_inetmsg_playeritem ){
      netmsg_playeritem *item = msg->m_pData;

      /* record */
      struct gameserver_client *client = &gameserver.clients[ client_id ];

      if( item->type_index >= k_netmsg_playeritem_max ){
         vg_warn( "Client #%d invalid equip type %u\n", 
                  client_id, (u32)item->type_index );
         return;
      }
      
      char *dest = client->items[ item->type_index ];

      network_msgstring( item->uid, msg->m_cbSize, sizeof(netmsg_playeritem),
                         dest, ADDON_UID_MAX );

      vg_info( "Client #%d equiped: [%s] %s\n", 
               client_id, 
               (const char *[]){[k_netmsg_playeritem_board]="board",
                                [k_netmsg_playeritem_player]="player",
                                [k_netmsg_playeritem_world0]="world0",
                                [k_netmsg_playeritem_world1]="world1"
               }[item->type_index], item->uid );
                           
      /* propogate */
      netmsg_playeritem *prop = alloca(msg->m_cbSize);
      memcpy( prop, msg->m_pData, msg->m_cbSize );
      prop->client = client_id;
      gameserver_send_to_all( client_id, prop, msg->m_cbSize, 
                              k_nSteamNetworkingSend_Reliable );
   }
   else {
      vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
               tmp->inetmsg_id );
   }
}

static void gameserver_request_respond( enum request_status status,
                                        netmsg_request *res, vg_msg *body,
                                        SteamNetworkingMessage_t *msg ){
   int client_id = gameserver_client_index( msg->m_conn );
   u32 len = 0;
   if( body ){
      len = body->cur.co;
      vg_low( "[%d#%d] Response: %d\n", client_id, (i32)res->id, status );
      vg_msg_print( body, len );
   }

   res->status = status;

   SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
         hSteamNetworkingSockets, msg->m_conn,
         res, sizeof(netmsg_request) + len,
         k_nSteamNetworkingSend_Reliable, NULL );
   SteamAPI_SteamNetworkingMessage_t_Release( msg );
}

struct user_request_thread_data {
   SteamNetworkingMessage_t *msg;
};

static u32 gameserver_get_current_week(void){
   return time(NULL) / (7*24*60*60);
}

static void gameserver_process_user_request( db_request *db_req ){
   struct user_request_thread_data *inf = (void *)db_req->data;
   SteamNetworkingMessage_t *msg = inf->msg;

   int client_id = gameserver_client_index( msg->m_conn );
   if( client_id == -1 ){
      SteamAPI_SteamNetworkingMessage_t_Release( msg );
      return;
   }

   netmsg_request *req = (netmsg_request *)msg->m_pData;
   vg_msg data;
   vg_msg_init( &data, req->q, msg->m_cbSize - sizeof(netmsg_request) );

   /* create response packet */
   netmsg_request *res = alloca( sizeof(netmsg_request) + 512 );
   res->inetmsg_id = k_inetmsg_response;
   res->id = req->id;
   vg_msg body;
   vg_msg_init( &body, res->q, 512 );

   const char *endpoint = vg_msg_getkvstr( &data, "endpoint" );

   if( !endpoint ){
      gameserver_request_respond( k_request_status_invalid_endpoint,
                                  res, NULL, msg );
      return;
   }

   if( !strcmp( endpoint, "scoreboard" ) ){
      const char *mod = vg_msg_getkvstr( &data, "mod" );
      const char *route = vg_msg_getkvstr( &data, "route" );
      u32 week = vg_msg_getkvu32( &data, "week", 0 );
      
      char table_name[ DB_TABLE_UID_MAX ];
      if( !db_get_highscore_table_name( mod, route, week, table_name ) ){
         gameserver_request_respond( k_request_status_out_of_memory,
                                     res, NULL, msg );
         return;
      }

      char buf[512];
      vg_str q;
      vg_strnull( &q, buf, 512 );
      vg_strcat( &q, "SELECT * FROM \"" );
      vg_strcat( &q, table_name );
      vg_strcat( &q, "\" ORDER BY time DESC LIMIT 10;" );
      if( !vg_strgood(&q) ) {
         gameserver_request_respond( k_request_status_out_of_memory,
                                     res, NULL, msg );
         return;
      }

      sqlite3_stmt *stmt = db_stmt( q.buffer );

      if( !stmt ){
         gameserver_request_respond( k_request_status_database_error,
                                     res, NULL, msg );
         return;
      }

      vg_msg_frame( &body, "rows" );
      for( u32 i=0; i<10; i ++ ){
         int fc = sqlite3_step( stmt );

         if( fc == SQLITE_ROW ){
            i32 time = sqlite3_column_int( stmt, 1 );
            i64 steamid_i64 = sqlite3_column_int64( stmt, 0 );
            u64 steamid = *((u64 *)&steamid_i64);

            if( steamid == k_connection_unauthorized )
               continue;

            vg_msg_frame( &body, "" );
            vg_msg_wkvu32( &body, "time", time );
            vg_msg_wkvu64( &body, "steamid", steamid );

            char username[32];
            if( db_getuserinfo( steamid, username, sizeof(username), NULL ) ){
               vg_msg_wkvstr( &body, "username", username );
            }

            vg_msg_end_frame( &body );
         }
         else if( fc == SQLITE_DONE ){
            break;
         }
         else {
            log_sqlite3( fc );
            break;
         }
      }

      sqlite3_finalize( stmt );
      vg_msg_end_frame( &body );

      if( body.error != k_vg_msg_error_OK ){
         gameserver_request_respond( k_request_status_out_of_memory,
                                     res, NULL, msg );
         return;
      }

      gameserver_request_respond( k_request_status_ok, res, &body, msg );
   }
   else if( !strcmp( endpoint, "setlap" ) ){
      /* TODO: we can change userdata to be the client ID and store that in
       *       the client structure. it also would save us scanning the 
       *       client array over and over..? 
       */
      u64 steamid = get_connection_authsteamid( msg );
      if( steamid == k_connection_unauthorized ){
         gameserver_request_respond( k_request_status_unauthorized,
                                     res, NULL, msg );
         return;
      }

      const char *mod = vg_msg_getkvstr( &data, "mod" );
      const char *route = vg_msg_getkvstr( &data, "route" );
      
      char weekly_table[ DB_TABLE_UID_MAX ],
           alltime_table[ DB_TABLE_UID_MAX ];

      u32 week = gameserver_get_current_week();

      if( !db_get_highscore_table_name( mod, route, 0, alltime_table ) ||
          !db_get_highscore_table_name( mod, route, week, weekly_table ) ){
         gameserver_request_respond( k_request_status_out_of_memory,
                                     res, NULL, msg );
         return;
      }

      i32 centiseconds = vg_msg_getkvi32( &data, "time", -1 );
      if( centiseconds < 5*100 ){
         gameserver_request_respond( k_request_status_client_error,
                                     res, NULL, msg );
         return;
      }

      db_writeusertime( alltime_table, steamid, centiseconds, 1 );
      db_writeusertime( weekly_table, steamid, centiseconds, 1 );

      gameserver_request_respond( k_request_status_ok, res, NULL, msg );
   }
   else{
      gameserver_request_respond( k_request_status_invalid_endpoint,
                                  res, NULL, msg );
   }
}

static void gameserver_rx_300_400( SteamNetworkingMessage_t *msg ){
   netmsg_blank *tmp = msg->m_pData;

   int client_id = gameserver_client_index( msg->m_conn );
   if( client_id == -1 ){
      SteamAPI_SteamNetworkingMessage_t_Release( msg );
      return;
   }

   if( tmp->inetmsg_id == k_inetmsg_request ){
      if( !packet_minsize( msg, sizeof(netmsg_request)+1 ))
         return;

      db_request *call = db_alloc_request( 
                           sizeof(struct user_request_thread_data) );
      struct user_request_thread_data *inf = (void *)call->data;
      inf->msg = msg;
      call->handler = gameserver_process_user_request;
      db_send_request( call );
   }
   else {
      vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
               tmp->inetmsg_id );
      SteamAPI_SteamNetworkingMessage_t_Release( msg );
   }
}

static void poll_connections(void){
   SteamNetworkingMessage_t *messages[32];
   int len;

   while(1){
      len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup(
            hSteamNetworkingSockets,
            gameserver.client_group, messages, vg_list_size(messages) );

      if( len <= 0 )
         return;

      for( int i=0; i<len; i++ ){
         SteamNetworkingMessage_t *msg = messages[i];

         if( msg->m_cbSize < sizeof(netmsg_blank) ){
            vg_warn( "Discarding message (too small: %d)\n", 
                  msg->m_cbSize );
            continue;
         }

         netmsg_blank *tmp = msg->m_pData;

         if( (tmp->inetmsg_id >= 200) && (tmp->inetmsg_id < 300) ){
            gameserver_rx_200_300( msg );
            SteamAPI_SteamNetworkingMessage_t_Release( msg );
         }
         else if( (tmp->inetmsg_id >= 300) && (tmp->inetmsg_id < 400) ){
            gameserver_rx_300_400( msg );
         }
         else{
            if( tmp->inetmsg_id == k_inetmsg_auth )
               gameserver_rx_auth( msg );
            else {
               vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
                        tmp->inetmsg_id );
            }
            SteamAPI_SteamNetworkingMessage_t_Release( msg );
         }
      }
   }
}

static u64 seconds_to_server_ticks( double s ){
   return s / 0.01;
}

static void test_runner( db_request *req ){
   vg_warn( "RUNNER\n" );
   char table[DB_TABLE_UID_MAX];
   if( db_get_highscore_table_name( "sr002-local-mp_mtzero", 
                                    "Coastal Run", 0, table ) ){
      if( db_writeusertime( table, 76561198072130043, 232, 1 ) ){
         vg_success( "Written time\n" );
         i32 v = db_readusertime( table, 76561198072130043 );
         vg_success( "Returned time: %u\n", v );
      }
   }
}

int main( int argc, char *argv[] ){
   signal( SIGINT, inthandler );
   signal( SIGQUIT, inthandler );
   signal( SIGPIPE, SIG_IGN );

   char *arg;
   while( vg_argp( argc, argv ) ){
      if( vg_long_opt( "noauth" ) )
         gameserver.auth_mode = eServerModeNoAuthentication;

      /* TODO: Options to override, ammend, remove etc */
   }
   
   vg_set_mem_quota( 80*1024*1024 );
   vg_alloc_quota();

   db_init();
   db_request *req = db_alloc_request(0);
   if( req ){
      req->handler = test_runner;
      db_send_request(req);
   }

   monitor_start_server(); /* UNIX socket monitor */

   /* steamworks init 
    * --------------------------------------------------------------- */
   steamworks_ensure_txt( "2103940" );
   if( gameserver.auth_mode == eServerModeAuthentication ){
      if( !vg_load_steam_symetric_key( "application_key", 
                                       gameserver.app_symmetric_key )){
         return 0;
      }
   }
   else{
      vg_warn( "Running without user authentication.\n" );
   }

   if( !SteamGameServer_Init( 0, 27400, 27401, 
                              gameserver.auth_mode, "1.0.0.0" ) ){
      vg_error( "SteamGameServer_Init failed\n" );
      return 0;
   }

   void *hSteamGameServer = SteamAPI_SteamGameServer();
   SteamAPI_ISteamGameServer_LogOnAnonymous( hSteamGameServer );

   SteamAPI_ManualDispatch_Init();
   HSteamPipe hsteampipe = SteamGameServer_GetHSteamPipe();
   hSteamNetworkingSockets = 
      SteamAPI_SteamGameServerNetworkingSockets_SteamAPI();

   steam_register_callback( k_iSteamNetAuthenticationStatus, on_auth_status );
   steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack,
                             on_connect_status );

   vg_success( "Steamworks API running\n" );
   steamworks_event_loop( hsteampipe );

   /*
    * Create a listener
    */
   HSteamListenSocket listener;
   SteamNetworkingIPAddr localAddr;
   SteamAPI_SteamNetworkingIPAddr_Clear( &localAddr );
   localAddr.m_port = 27402;

   listener = SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP(
                  hSteamNetworkingSockets, &localAddr, 0, NULL );
   gameserver.client_group = SteamAPI_ISteamNetworkingSockets_CreatePollGroup(
         hSteamNetworkingSockets );

   u64 server_ticks = 8000,
       last_record_save = 8000,
       last_scoreboard_gen = 0,
       last_monitor_heartbeat = 0;

   while( !sig_stop ){
      monitor_event_loop();
      steamworks_event_loop( hsteampipe );
      poll_connections();

      usleep(10000);
      server_ticks ++;

      if( server_ticks > 
            (last_monitor_heartbeat + seconds_to_server_ticks(10.0))){
         last_monitor_heartbeat = server_ticks;
         monitor_heartbeat();
      }

      if( db_killed() )
         break;
   }
   
   SteamAPI_ISteamNetworkingSockets_DestroyPollGroup( hSteamNetworkingSockets,
         gameserver.client_group );
   SteamAPI_ISteamNetworkingSockets_CloseListenSocket( 
         hSteamNetworkingSockets, listener );
   
   vg_info( "Shutting down\n..." );
   SteamGameServer_Shutdown();
   db_kill();
   db_free();

   return 0;
}