+/*
+ * 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;
+
+static void inthandler( int signum ) {
+ sig_stop = 1;
+}
+
+#include "gameserver.h"
+#include "highscores.c"
+#include "servermonitor_server.c"
+#include "vg/vg_opt.h"
+
+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 new_client_connecting( HSteamNetConnection client ){
+ EResult accept_status = SteamAPI_ISteamNetworkingSockets_AcceptConnection(
+ hSteamNetworkingSockets, client );
+
+ if( accept_status == k_EResultOK ){
+ vg_success( "Accepted client (id: %u)\n", client );
+ SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup(
+ hSteamNetworkingSockets,
+ client, gameserver.client_group );
+
+ /* Just to be sure */
+ set_connection_authsteamid( client, -1 );
+ }
+ else{
+ vg_warn( "Error accepting client (id: %u)\n", client );
+ }
+}
+
+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 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 );
+ }
+}
+
+static void on_inet_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;
+}
+
+static void on_inet_score_request( SteamNetworkingMessage_t *msg ){
+ if( !inet_require_auth(msg) ) return;
+
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+ hSteamNetworkingSockets, msg->m_conn,
+ &scoreboard_client_data, sizeof(netmsg_scoreboard),
+ k_nSteamNetworkingSend_Reliable, NULL );
+}
+
+static void on_inet_set_nickname( SteamNetworkingMessage_t *msg ){
+ if(!inet_require_auth(msg)) return;
+
+ u64_steamid steamid = get_connection_authsteamid(msg);
+ netmsg_set_nickname *setnick = msg->m_pData;
+ if( msg->m_cbSize < sizeof(netmsg_set_nickname) ){
+ vg_warn( "Invalid nickname request from client: %u, steamid: %lu\n",
+ msg->m_conn, steamid );
+ return;
+ }
+
+ highscore_set_user_nickname( steamid, setnick->nickname );
+}
+
+static void on_inet_set_score( SteamNetworkingMessage_t *msg ){
+ if(!inet_require_auth(msg)) return;
+
+ u64_steamid steamid = get_connection_authsteamid(msg);
+
+ if( msg->m_cbSize < sizeof(netmsg_set_score) ){
+ vg_warn( "Invalid set score post from client: %u, steamid: %lu\n",
+ msg->m_conn, steamid );
+ return;
+ }
+
+ netmsg_set_score *info = msg->m_pData;
+
+ if( msg->m_cbSize < sizeof(netmsg_set_score) +
+ sizeof(struct netmsg_score_record)*info->record_count ){
+ vg_warn( "Malformed set score post from client: %u, steamid: %lu\n",
+ msg->m_conn, steamid );
+ return;
+ }
+
+ for( int i=0; i<info->record_count; i++ ){
+ highscore_record temp;
+ temp.trackid = info->records[i].trackid;
+ temp.datetime = time(NULL);
+ temp.playerid = steamid;
+ temp.points = info->records[i].points;
+ temp.time = info->records[i].time;
+
+ highscores_push_record( &temp );
+ }
+}
+
+static void on_inet_playerframe( SteamNetworkingMessage_t *msg ){
+ if( msg->m_cbSize < sizeof(netmsg_playerframe) ){
+ return;
+ }
+
+
+ netmsg_playerframe *info = msg->m_pData;
+ vg_info( "... @: %.2f %.2f %.2f\n",
+ //msg->m_identityPeer,
+ info->pos_temp[0], info->pos_temp[1], info->pos_temp[2] );
+}
+
+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 == k_inetmsg_auth )
+ on_inet_auth( msg );
+ else if( tmp->inetmsg_id == k_inetmsg_scores_request )
+ on_inet_score_request( msg );
+ else if( tmp->inetmsg_id == k_inetmsg_set_nickname )
+ on_inet_set_nickname( msg );
+ else if( tmp->inetmsg_id == k_inetmsg_set_score )
+ on_inet_set_score( msg );
+ else if( tmp->inetmsg_id == k_inetmsg_playerframe )
+ on_inet_playerframe( 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 generate_boards(void){
+ FILE *fp = fopen( "www/html/srhighscores.txt", "w" );
+
+ if( !fp ){
+ vg_error( "Can't write boards to www/html/srhighscores.txt\n" );
+ return;
+ }
+
+ for( int i=0; i<vg_list_size(track_infos); i++ ){
+ struct netmsg_board *board = &scoreboard_client_data.boards[i];
+
+ highscores_board_generate( board->data, i, 10 );
+ highscores_board_printf( fp, board->data, 10 );
+ }
+
+ fclose( fp );
+}
+
+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();
+
+ highscores_init( 250000, 10000 );
+
+ if( !highscores_read() )
+ highscores_create_db();
+
+ 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();
+
+ //hSteamHTTP = SteamAPI_SteamGameServerHTTP();
+ hSteamNetworkingSockets =
+ SteamAPI_SteamGameServerNetworkingSockets_SteamAPI();
+
+ /*
+ * Server code
+ */
+
+ 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;
+
+ generate_boards();
+ monitor_start_server();
+
+ 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( server_ticks > last_scoreboard_gen + seconds_to_server_ticks(60.0) ){
+ last_scoreboard_gen = server_ticks;
+ generate_boards();
+ }
+
+ if( server_ticks > last_record_save + seconds_to_server_ticks(10.0*60.0)){
+ last_record_save = server_ticks;
+ highscores_serialize_all();
+ }
+ }
+
+ highscores_serialize_all();
+
+ SteamAPI_ISteamNetworkingSockets_DestroyPollGroup( hSteamNetworkingSockets,
+ gameserver.client_group );
+ SteamAPI_ISteamNetworkingSockets_CloseListenSocket(
+ hSteamNetworkingSockets, listener );
+
+ vg_info( "Shutting down\n..." );
+ SteamGameServer_Shutdown();
+
+ return 0;
+}