#include <signal.h>
#include <unistd.h>
#include <time.h>
+#include <string.h>
volatile sig_atomic_t sig_stop;
+#include "gameserver.h"
+#include "vg/vg_opt.h"
+#include "network_common.h"
+#include "gameserver_db.h"
+#include "vg/vg_m.h"
+#include "vg/vg_msg.h"
+
+static u64 const k_steamid_max = 0xffffffffffffffff;
+
static void inthandler( int signum ) {
sig_stop = 1;
}
-#include "gameserver.h"
-#include "highscores.c"
-#include "servermonitor_server.c"
-#include "vg/vg_opt.h"
+static void release_message( SteamNetworkingMessage_t *msg )
+{
+ msg->m_nUserData --;
+
+ if( msg->m_nUserData == 0 )
+ SteamAPI_SteamNetworkingMessage_t_Release( msg );
+}
-static const u64 k_connection_unauthorized = 0xffffffffffffffff;
+/*
+ * Send message to single client, with authentication checking
+ */
+static void gameserver_send_to_client( i32 client_id,
+ const void *pData, u32 cbData,
+ int nSendFlags )
+{
+ struct gameserver_client *client = &gameserver.clients[ client_id ];
-static u64_steamid get_connection_authsteamid( SteamNetworkingMessage_t *msg ){
- i64 userdata = SteamAPI_ISteamNetworkingSockets_GetConnectionUserData(
- hSteamNetworkingSockets, msg->m_conn );
+ if( gameserver.loopback_test && !client->connection )
+ return;
- return *((u64_steamid *)&userdata);
-}
+ if( !client->steamid )
+ return;
-static void set_connection_authsteamid(HSteamNetConnection con, u64_steamid id){
- i64 userdata = *((i64 *)&id);
-
- SteamAPI_ISteamNetworkingSockets_SetConnectionUserData(
- hSteamNetworkingSockets, con, userdata );
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+ hSteamNetworkingSockets, client->connection,
+ pData, cbData, nSendFlags, NULL );
}
+/*
+ * Send message to all clients if they are authenticated
+ */
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++ ){
+ 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 );
+ if( i != ignore )
+ gameserver_send_to_client( i, pData, cbData, nSendFlags );
}
}
-static void gameserver_populate_join_msg( int index, netmsg_playerjoin *msg ){
- memset( msg, 0, sizeof(*msg) );
- msg->inetmsg_id = k_inetmsg_playerjoin;
- msg->index = index;
- vg_strncpy( gameserver.clients[index].username, msg->username,
- sizeof(msg->username), k_strncpy_always_add_null );
+static void gameserver_send_version_to_client( int index )
+{
+ struct gameserver_client *client = &gameserver.clients[index];
+
+ if( gameserver.loopback_test && !client->connection )
+ return;
+
+ netmsg_version version;
+ version.inetmsg_id = k_inetmsg_version;
+ version.version = NETWORK_SKATERIFT_VERSION;
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+ hSteamNetworkingSockets, client->connection,
+ &version, sizeof(netmsg_version),
+ k_nSteamNetworkingSend_Reliable, NULL );
}
-static void gameserver_player_join( int index ){
+/*
+ * handle server update that client #'index' has joined
+ */
+static void gameserver_player_join( int index )
+{
struct gameserver_client *joiner = &gameserver.clients[index];
- netmsg_playerjoin join;
- gameserver_populate_join_msg( index, &join );
+ netmsg_playerjoin join = { .inetmsg_id = k_inetmsg_playerjoin,
+ .index = index,
+ .steamid = joiner->steamid };
+
gameserver_send_to_all( index, &join, sizeof(join),
k_nSteamNetworkingSend_Reliable );
- /* update the joining user about current connections */
- for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
+ /*
+ * update the joining user about current connections and our version
+ */
+ gameserver_send_version_to_client( index );
+
+ 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;
+
+ netmsg_region *region = alloca( sizeof(netmsg_region) + NETWORK_REGION_MAX );
+ region->inetmsg_id = k_inetmsg_region;
+
+ for( int i=0; i<vg_list_size(gameserver.clients); i++ )
+ {
struct gameserver_client *client = &gameserver.clients[i];
- if( (i==index) || !client->active )
+ if( (i == index) || !client->steamid )
continue;
- netmsg_playerjoin init;
- gameserver_populate_join_msg( i, &init );
+ /* join */
+ netmsg_playerjoin init = { .inetmsg_id = k_inetmsg_playerjoin,
+ .index = i,
+ .steamid = client->steamid };
+ gameserver_send_to_client( index, &init, sizeof(init),
+ k_nSteamNetworkingSend_Reliable );
- 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;
+ gameserver_send_to_client( index, username, size,
+ k_nSteamNetworkingSend_Reliable );
+
+ /* items */
+ for( int j=0; j<k_netmsg_playeritem_max; j++ )
+ {
+ chs = vg_strncpy( client->items[j].uid, item->uid, ADDON_UID_MAX,
+ k_strncpy_always_add_null );
+ item->type_index = j;
+ item->client = i;
+ size = sizeof(netmsg_playeritem) + chs + 1;
+ gameserver_send_to_client( index, item, size,
+ k_nSteamNetworkingSend_Reliable );
+ }
+
+ /* region */
+
+ region->client = i;
+ region->flags = client->region_flags;
+ u32 l = vg_strncpy( client->region, region->loc, NETWORK_REGION_MAX,
+ k_strncpy_always_add_null );
+ size = sizeof(netmsg_region) + l + 1;
+
+ gameserver_send_to_client( index, region, size,
+ k_nSteamNetworkingSend_Reliable );
}
}
+/*
+ * Handle server update that player has left
+ */
static void gameserver_player_leave( int index ){
- netmsg_playerjoin leave;
+ if( gameserver.auth_mode == eServerModeAuthentication ){
+ if( !gameserver.clients[ index ].steamid )
+ return;
+ }
+
+ netmsg_playerleave leave;
leave.inetmsg_id = k_inetmsg_playerleave;
leave.index = index;
k_nSteamNetworkingSend_Reliable );
}
-static void new_client_connecting( HSteamNetConnection client ){
+static void gameserver_update_all_knowledge( int client, int clear );
+
+/*
+ * Deletes client at index and disconnects the connection handle if it was
+ * set.
+ */
+static void remove_client( int index ){
+ struct gameserver_client *client = &gameserver.clients[index];
+ if( client->connection ){
+ SteamAPI_ISteamNetworkingSockets_SetConnectionUserData(
+ hSteamNetworkingSockets, client->connection, -1 );
+ SteamAPI_ISteamNetworkingSockets_CloseConnection(
+ hSteamNetworkingSockets, client->connection,
+ k_ESteamNetConnectionEnd_Misc_InternalError,
+ NULL, 1 );
+ }
+ memset( client, 0, sizeof(struct gameserver_client) );
+ gameserver_update_all_knowledge( index, 1 );
+}
+
+/*
+ * Handle incoming new connection and init flags on the steam handle. if the
+ * server is full the userdata (client_id) will be set to -1 on the handle.
+ */
+static void handle_new_connection( HSteamNetConnection conn )
+{
+ SteamAPI_ISteamNetworkingSockets_SetConnectionUserData(
+ hSteamNetworkingSockets, conn, -1 );
+
int index = -1;
- /* TODO: LRU */
for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
if( !gameserver.clients[i].active ){
index = i;
if( index == -1 ){
vg_error( "Server full\n" );
SteamAPI_ISteamNetworkingSockets_CloseConnection(
- hSteamNetworkingSockets, client,
+ hSteamNetworkingSockets, conn,
4500,
NULL, 1 );
return;
}
+ struct gameserver_client *client = &gameserver.clients[index];
EResult accept_status = SteamAPI_ISteamNetworkingSockets_AcceptConnection(
- hSteamNetworkingSockets, client );
- if( accept_status == k_EResultOK ){
- vg_success( "Accepted client (id: %u, index: %d)\n", client, index );
+ hSteamNetworkingSockets, conn );
+
+ if( accept_status == k_EResultOK )
+ {
+ vg_success( "Accepted client (id: %u, index: %d)\n", conn, index );
- gameserver.clients[index].active = 1;
- gameserver.clients[index].connection = client;
+ client->active = 1;
+ client->connection = conn;
SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup(
- hSteamNetworkingSockets,
- client, gameserver.client_group );
+ hSteamNetworkingSockets, conn, gameserver.client_group );
- /* Just to be sure */
- set_connection_authsteamid( client, -1 );
- gameserver_player_join( index );
+ SteamAPI_ISteamNetworkingSockets_SetConnectionUserData(
+ hSteamNetworkingSockets, conn, index );
+
+ if( gameserver.loopback_test )
+ {
+ vg_warn( "[DEV] Creating loopback client\n" );
+ struct gameserver_client *loopback = &gameserver.clients[1];
+ loopback->active = 1;
+ loopback->connection = 0;
+ }
}
- else{
- vg_warn( "Error accepting client (id: %u)\n", client );
+ else
+ {
+ vg_warn( "Error accepting connection (id: %u)\n", conn );
SteamAPI_ISteamNetworkingSockets_CloseConnection(
- hSteamNetworkingSockets, client,
+ hSteamNetworkingSockets, conn,
k_ESteamNetConnectionEnd_Misc_InternalError,
NULL, 1 );
- gameserver.clients[index].active = 0;
- gameserver.clients[index].connection = 0;
}
}
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;
- }
- }
+/*
+ * Get client id of connection handle. Will be -1 if unkown to us either because
+ * the server is full or we already disconnected them
+ */
+static i32 gameserver_conid( HSteamNetConnection hconn )
+{
+ i64 id;
+
+ if( hconn == 0 )
+ {
+ if( gameserver.loopback_test )
+ return 1;
+ else
+ return -1;
}
- return -1;
+ else
+ id = SteamAPI_ISteamNetworkingSockets_GetConnectionUserData(
+ hSteamNetworkingSockets, hconn );
+
+ if( (id < 0) || (id >= NETWORK_MAX_PLAYERS) )
+ return -1;
+
+ return id;
}
-static void on_connect_status( CallbackMsg_t *msg ){
+/*
+ * Callback for steam connection state change
+ */
+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 );
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_Connecting )
+ {
+ handle_new_connection( 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);
+ k_ESteamNetworkingConnectionState_ProblemDetectedLocally ) ||
+ (info->m_info.m_eState ==
+ k_ESteamNetworkingConnectionState_Dead) ||
+ (info->m_info.m_eState ==
+ k_ESteamNetworkingConnectionState_None) )
+ {
+ vg_info( "End reason: %d\n", info->m_info.m_eEndReason );
+
+ int client_id = gameserver_conid( info->m_hConn );
+ if( client_id != -1 )
+ {
+ gameserver_player_leave( client_id );
+ remove_client( client_id );
+
+ if( gameserver.loopback_test )
+ {
+ gameserver_player_leave( 1 );
+ remove_client( 1 );
+ }
+ }
+ else
+ {
+ SteamAPI_ISteamNetworkingSockets_CloseConnection(
+ hSteamNetworkingSockets, info->m_hConn, 0, NULL, 0 );
}
+ }
+}
- vg_info( "End reason: %d\n", info->m_info.m_eEndReason );
+static void gameserver_rx_version( SteamNetworkingMessage_t *msg )
+{
+ netmsg_version *version = msg->m_pData;
+
+ int client_id = gameserver_conid( msg->m_conn );
+ if( client_id == -1 )
+ {
+ vg_warn( "Recieved version from unkown connection (%u)\n", msg->m_conn );
SteamAPI_ISteamNetworkingSockets_CloseConnection(
- hSteamNetworkingSockets, info->m_hConn, 0, NULL, 0 );
+ hSteamNetworkingSockets, msg->m_conn,
+ k_ESteamNetConnectionEnd_Misc_InternalError,
+ NULL, 1 );
+ return;
+ }
+
+ struct gameserver_client *client = &gameserver.clients[ client_id ];
+
+ if( client->version )
+ {
+ vg_warn( "Already have version for this client (%d conn: %u)",
+ client_id, msg->m_conn );
+ return;
+ }
+
+ client->version = version->version;
+
+ if( client->version != NETWORK_SKATERIFT_VERSION )
+ {
+ gameserver_send_version_to_client( client_id );
+ remove_client( client_id );
+ return;
+ }
+
+ /* this is the sign on point for non-auth servers,
+ * for auth servers it comes at the end of rx_auth
+ */
+ if( gameserver.auth_mode != eServerModeAuthentication )
+ {
+ client->steamid = k_steamid_max;
+ gameserver_player_join( client_id );
+
+ if( gameserver.loopback_test )
+ {
+ struct gameserver_client *loopback = &gameserver.clients[1];
+ loopback->steamid = k_steamid_max;
+ gameserver_player_join( 1 );
+ }
}
}
+/*
+ * recieve auth ticket from connection. will only accept it if we've added them
+ * to the client list first.
+ */
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 );
+ vg_warn( "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 );
+ int client_id = gameserver_conid( msg->m_conn );
+ if( client_id == -1 ) {
+ vg_warn( "Recieved auth ticket from unkown connection (%u)\n",
+ msg->m_conn );
+ SteamAPI_ISteamNetworkingSockets_CloseConnection(
+ hSteamNetworkingSockets, msg->m_conn,
+ k_ESteamNetConnectionEnd_Misc_InternalError, NULL, 1 );
+ return;
+ }
+
+ struct gameserver_client *client = &gameserver.clients[ client_id ];
+ if( client->steamid ){
+ vg_warn( "Already authorized this user but another app ticket was sent"
+ " again (%d conn: %u)\n", client_id, msg->m_conn );
+ return;
+ }
+
+ if( client->version == 0 ){
+ vg_error( "Client has not sent their version yet (%u)\n", msg->m_conn );
+ remove_client( client_id );
return;
}
if( msg->m_cbSize < sizeof(netmsg_auth) ){
vg_error( "Malformed auth ticket, too small (%u)\n", msg->m_conn );
+ remove_client( client_id );
return;
}
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 );
+ auth->ticket_length );
+ remove_client( client_id );
return;
}
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 );
+ remove_client( client_id );
return;
}
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 );
+ remove_client( client_id );
return;
}
}
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;
+ client->steamid = steamid.m_unAll64Bits;
+ gameserver_player_join( client_id );
}
/*
}
}
-static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){
+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_steamid_max )
+ return;
+
+ int admin = 0;
+ if( inf->steamid == 76561198072130043 )
+ admin = 2;
+
+ db_updateuser( inf->steamid, inf->username, admin );
+}
+
+static int gameserver_item_eq( struct gameserver_item *ia,
+ struct gameserver_item *ib ){
+ if( ia->hash == ib->hash )
+ if( !strcmp(ia->uid,ib->uid) )
+ return 1;
+
+ return 0;
+}
+
+/*
+ * Match addons between two player IDs. if clear is set, then the flags between
+ * those two IDs will all be set to 0.
+ */
+static void gameserver_update_knowledge_table( int client0, int client1,
+ int clear ){
+ u32 idx = network_pair_index( client0, client1 );
+
+ struct gameserver_client *c0 = &gameserver.clients[client0],
+ *c1 = &gameserver.clients[client1];
+
+ u8 flags = 0x00;
+
+ if( !clear ){
+ if( gameserver_item_eq(&c0->items[k_netmsg_playeritem_world0],
+ &c1->items[k_netmsg_playeritem_world0]))
+ flags |= CLIENT_KNOWLEDGE_SAME_WORLD0;
+
+ if( gameserver_item_eq(&c0->items[k_netmsg_playeritem_world1],
+ &c1->items[k_netmsg_playeritem_world1]))
+ flags |= CLIENT_KNOWLEDGE_SAME_WORLD1;
+ }
+
+ gameserver.client_knowledge_mask[idx] = flags;
+}
+
+/*
+ * If a change has been made on this client, then it will adjust the entire
+ * table of other players. if clear is set, all references to client will be set
+ * to 0.
+ */
+static void gameserver_update_all_knowledge( int client, int clear ){
+ for( int i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
+ if( i == client )
+ continue;
+
+ struct gameserver_client *ci = &gameserver.clients[i];
+
+ if( ci->steamid )
+ gameserver_update_knowledge_table( client, i, clear );
+ }
+}
+
+static void gameserver_propogate_player_frame( int client_id,
+ netmsg_playerframe *frame,
+ u32 size ){
+ u32 basic_size = sizeof(netmsg_playerframe) + ((24*3)/8);
+ netmsg_playerframe *full = alloca(size),
+ *basic= alloca(basic_size);
+
+ memcpy( full, frame, size );
+ memcpy( basic, frame, basic_size );
+
+ full->client = client_id;
+ basic->client = client_id;
+ basic->subsystem = 4; /* (.._basic_info: 24f*3 animator ) */
+ basic->sound_effects = 0;
+
+ struct gameserver_client *c0 = &gameserver.clients[client_id];
+ c0->instance = frame->flags & NETMSG_PLAYERFRAME_INSTANCE_ID;
+
+ for( int i=0; i<vg_list_size(gameserver.clients); i++ )
+ {
+ if( i == client_id )
+ continue;
+
+ struct gameserver_client *ci = &gameserver.clients[i];
+
+ int send_full = 0;
+
+ if( c0->instance == ci->instance )
+ {
+ u32 k_index = network_pair_index( client_id, i );
+ u8 k_mask = gameserver.client_knowledge_mask[ k_index ];
+
+ if( (k_mask & (CLIENT_KNOWLEDGE_SAME_WORLD0<<c0->instance)) )
+ send_full = 1;
+ }
+
+ if( send_full )
+ {
+ gameserver_send_to_client( i, full, size,
+ k_nSteamNetworkingSend_Unreliable );
+ }
+ else
+ {
+ gameserver_send_to_client( i, basic, basic_size,
+ k_nSteamNetworkingSend_Unreliable );
+ }
+ }
+}
+
+static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg )
+{
netmsg_blank *tmp = msg->m_pData;
- if( tmp->inetmsg_id == k_inetmsg_playerusername ){
- if( !packet_minsize( msg, sizeof(netmsg_playerusername) ))
+ int client_id = gameserver_conid( msg->m_conn );
+ if( client_id == -1 ) return;
+
+ struct gameserver_client *client = &gameserver.clients[ client_id ];
+
+ if( tmp->inetmsg_id == k_inetmsg_playerusername )
+ {
+ if( !packet_minsize( msg, sizeof(netmsg_playerusername)+1 ))
return;
- int client_id = gameserver_client_index( msg->m_conn );
- if( client_id != -1 ){
- struct gameserver_client *client = &gameserver.clients[ client_id ];
- netmsg_playerusername *src = msg->m_pData;
-
- vg_strncpy( src->username, client->username, sizeof(client->username),
- k_strncpy_always_add_null );
-
- /* update other users about this change */
- netmsg_playerusername msg;
- memset( &msg, 0, sizeof(msg) );
- msg.inetmsg_id = k_inetmsg_playerusername;
- msg.index = client_id;
- vg_strncpy( client->username, msg.username, sizeof(msg.username),
- k_strncpy_always_add_null );
-
- gameserver_send_to_all( client_id, &msg, sizeof(msg),
- k_nSteamNetworkingSend_Reliable );
+ 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 = client->steamid;
+ 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 )
+ {
+ gameserver_propogate_player_frame( client_id,
+ msg->m_pData, msg->m_cbSize );
+ }
+ else if( tmp->inetmsg_id == k_inetmsg_playeritem )
+ {
+ netmsg_playeritem *item = msg->m_pData;
+
+ /* record */
+ 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 ].uid;
+
+ 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 );
+
+ gameserver_update_all_knowledge( client_id, 0 );
+
+ /* 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 if( tmp->inetmsg_id == k_inetmsg_chat )
+ {
+ netmsg_chat *chat = msg->m_pData,
+ *prop = alloca( sizeof(netmsg_chat) + NETWORK_MAX_CHAT );
+ prop->inetmsg_id = k_inetmsg_chat;
+ prop->client = client_id;
+
+ u32 l = network_msgstring( chat->msg, msg->m_cbSize, sizeof(netmsg_chat),
+ prop->msg, NETWORK_MAX_CHAT );
+ vg_info( "[%d]: %s\n", client_id, prop->msg );
+
+ gameserver_send_to_all( client_id, prop, sizeof(netmsg_chat)+l+1,
+ k_nSteamNetworkingSend_Reliable );
+ }
+ else if( tmp->inetmsg_id == k_inetmsg_region )
+ {
+ netmsg_region *region = msg->m_pData,
+ *prop = alloca( sizeof(netmsg_region) + NETWORK_REGION_MAX );
+
+ prop->inetmsg_id = k_inetmsg_region;
+ prop->client = client_id;
+ prop->flags = region->flags;
+
+ u32 l = network_msgstring(
+ region->loc, msg->m_cbSize, sizeof(netmsg_region),
+ client->region, NETWORK_REGION_MAX );
+ client->region_flags = region->flags;
+
+ l = vg_strncpy( client->region, prop->loc, NETWORK_REGION_MAX,
+ k_strncpy_always_add_null );
+
+ gameserver_send_to_all( client_id, prop, sizeof(netmsg_region)+l+1,
+ k_nSteamNetworkingSend_Reliable );
+ vg_info( "client %d moved to region: %s\n", client_id, client->region );
+ }
+ else
+ {
+ vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
+ tmp->inetmsg_id );
}
}
-#if 0
-static void on_inet_score_request( SteamNetworkingMessage_t *msg ){
- if( !inet_require_auth(msg) ) return;
+static void gameserver_request_respond( enum request_status status,
+ netmsg_request *res, vg_msg *body,
+ SteamNetworkingMessage_t *msg ){
+ int client_id = gameserver_conid( 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;
+
+ if( gameserver.loopback_test && !msg->m_conn )
+ {
+ release_message( msg );
+ return;
+ }
SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, msg->m_conn,
- &scoreboard_client_data, sizeof(netmsg_scoreboard),
+ hSteamNetworkingSockets, msg->m_conn,
+ res, sizeof(netmsg_request) + len,
k_nSteamNetworkingSend_Reliable, NULL );
+
+ release_message( 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 on_inet_set_nickname( SteamNetworkingMessage_t *msg ){
- if(!inet_require_auth(msg)) return;
+static enum request_status gameserver_cat_table(
+ vg_msg *msg,
+ const char *mod, const char *route, u32 week, const char *alias )
+{
+ char table_name[ DB_TABLE_UID_MAX ];
+ if( !db_get_highscore_table_name( mod, route, week, table_name ) )
+ return k_request_status_out_of_memory;
+
+ 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 ASC LIMIT 10;" );
+ if( !vg_strgood(&q) )
+ return k_request_status_out_of_memory;
+
+ sqlite3_stmt *stmt = db_stmt( q.buffer );
+ if( !stmt )
+ return k_request_status_database_error;
+
+ vg_msg_frame( msg, alias );
+ 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_steamid_max )
+ continue;
- 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 );
+ vg_msg_frame( msg, "" );
+ vg_msg_wkvnum( msg, "time", k_vg_msg_u32, 1, &time );
+ vg_msg_wkvnum( msg, "steamid", k_vg_msg_u64, 1, &steamid );
+
+ char username[32];
+ if( db_getuserinfo( steamid, username, sizeof(username), NULL ) )
+ vg_msg_wkvstr( msg, "username", username );
+ vg_msg_end_frame( msg );
+ }
+ else if( fc == SQLITE_DONE ){
+ break;
+ }
+ else {
+ log_sqlite3( fc );
+ break;
+ }
+ }
+
+ sqlite3_finalize( stmt );
+ vg_msg_end_frame( msg );
+ return k_request_status_ok;
+}
+
+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_conid( msg->m_conn );
+ if( client_id == -1 )
+ {
+ release_message( msg );
return;
}
-
- highscore_set_user_nickname( steamid, setnick->nickname );
+
+ struct gameserver_client *client = &gameserver.clients[ client_id ];
+
+ 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) + NETWORK_REQUEST_MAX );
+ res->inetmsg_id = k_inetmsg_response;
+ res->id = req->id;
+ vg_msg body;
+ vg_msg_init( &body, res->q, NETWORK_REQUEST_MAX );
+
+ 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_getkvintg( &data, "week", k_vg_msg_u32, &week, NULL );
+
+ if( week == NETWORK_LEADERBOARD_CURRENT_WEEK ){
+ gameserver_cat_table( &body, mod, route,
+ gameserver_get_current_week(), "rows_weekly" );
+ }
+ else if( week == NETWORK_LEADERBOARD_ALLTIME_AND_CURRENT_WEEK ){
+ gameserver_cat_table( &body, mod, route, 0, "rows" );
+ gameserver_cat_table( &body, mod, route,
+ gameserver_get_current_week(), "rows_weekly" );
+ }
+ else
+ gameserver_cat_table( &body, mod, route, week, "rows" );
+
+ 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" ) ){
+ if( client->steamid == k_steamid_max ){
+ 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_getkvintg( &data, "time", k_vg_msg_i32, ¢iseconds, NULL );
+ if( centiseconds < 5*100 ){
+ gameserver_request_respond( k_request_status_client_error,
+ res, NULL, msg );
+ return;
+ }
+
+ db_writeusertime( alltime_table, client->steamid, centiseconds, 1 );
+ db_writeusertime( weekly_table, client->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 on_inet_set_score( SteamNetworkingMessage_t *msg ){
- if(!inet_require_auth(msg)) return;
+static void gameserver_rx_300_400( SteamNetworkingMessage_t *msg )
+{
+ netmsg_blank *tmp = msg->m_pData;
- 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 );
+ int client_id = gameserver_conid( msg->m_conn );
+ if( client_id == -1 )
+ {
+ release_message( msg );
return;
}
- netmsg_set_score *info = msg->m_pData;
+ if( tmp->inetmsg_id == k_inetmsg_request )
+ {
+ if( gameserver.loopback_test && (client_id == 1) )
+ {
+ release_message( msg );
+ return;
+ }
+
+ if( !packet_minsize( msg, sizeof(netmsg_request)+1 ))
+ {
+ release_message( msg );
+ 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 );
+ release_message( msg );
+ }
+}
- 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 );
+static void process_network_message( SteamNetworkingMessage_t *msg )
+{
+ if( msg->m_cbSize < sizeof(netmsg_blank) ){
+ vg_warn( "Discarding message (too small: %d)\n",
+ msg->m_cbSize );
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;
+ netmsg_blank *tmp = msg->m_pData;
- highscores_push_record( &temp );
+ if( (tmp->inetmsg_id >= 200) && (tmp->inetmsg_id < 300) )
+ {
+ gameserver_rx_200_300( msg );
+ release_message( 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 if( tmp->inetmsg_id == k_inetmsg_version ){
+ gameserver_rx_version( msg );
+ }
+ else {
+ vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
+ tmp->inetmsg_id );
+ }
+ release_message( msg );
}
}
-#endif
-static void poll_connections(void){
+static void poll_connections(void)
+{
SteamNetworkingMessage_t *messages[32];
int len;
- while(1){
+ 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++ ){
+ 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;
+ msg->m_nUserData = 1;
+
+ if( gameserver.loopback_test )
+ {
+ HSteamNetConnection conid = msg->m_conn;
+ msg->m_conn = 0;
+ msg->m_nUserData ++;
+ process_network_message( msg );
+ msg->m_conn = conid;
}
- netmsg_blank *tmp = msg->m_pData;
-
- if( (tmp->inetmsg_id >= 200) && (tmp->inetmsg_id < 300) ){
- gameserver_rx_200_300( msg );
- }
- else{
- if( tmp->inetmsg_id == k_inetmsg_auth )
- gameserver_rx_auth( msg );
-#if 0
- 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 );
-#endif
- else {
- vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
- tmp->inetmsg_id );
- }
- }
-
-
- SteamAPI_SteamNetworkingMessage_t_Release( msg );
+ process_network_message( msg );
}
}
}
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 ) ){
+ while( vg_argp( argc, argv ) )
+ {
if( vg_long_opt( "noauth" ) )
gameserver.auth_mode = eServerModeNoAuthentication;
+
+ if( vg_long_opt( "loopback" ) )
+ gameserver.loopback_test = 1;
}
- /* TODO: Options to override, ammend, remove etc */
-
vg_set_mem_quota( 80*1024*1024 );
vg_alloc_quota();
+ db_init();
- highscores_init( 250000, 10000 );
-
- if( !highscores_read() )
- highscores_create_db();
-
+ /* steamworks init
+ * --------------------------------------------------------------- */
steamworks_ensure_txt( "2103940" );
-
if( gameserver.auth_mode == eServerModeAuthentication ){
if( !vg_load_steam_symetric_key( "application_key",
gameserver.app_symmetric_key )){
vg_warn( "Running without user authentication.\n" );
}
- if( !SteamGameServer_Init( 0, 27400, 27401,
+ if( !SteamGameServer_Init( 0, NETWORK_PORT, NETWORK_PORT+1,
gameserver.auth_mode, "1.0.0.0" ) ){
vg_error( "SteamGameServer_Init failed\n" );
return 0;
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 );
/*
* Create a listener
*/
-
HSteamListenSocket listener;
SteamNetworkingIPAddr localAddr;
SteamAPI_SteamNetworkingIPAddr_Clear( &localAddr );
- localAddr.m_port = 27402;
+ localAddr.m_port = NETWORK_PORT;
listener = SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP(
hSteamNetworkingSockets, &localAddr, 0, NULL );
u64 server_ticks = 8000,
last_record_save = 8000,
- last_scoreboard_gen = 0,
- last_monitor_heartbeat = 0;
-
- generate_boards();
- monitor_start_server();
+ last_scoreboard_gen = 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( 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();
- }
+ if( db_killed() )
+ break;
}
- highscores_serialize_all();
-
SteamAPI_ISteamNetworkingSockets_DestroyPollGroup( hSteamNetworkingSockets,
gameserver.client_group );
SteamAPI_ISteamNetworkingSockets_CloseListenSocket(
vg_info( "Shutting down\n..." );
SteamGameServer_Shutdown();
+ db_kill();
+ db_free();
return 0;
}
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff