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"
+#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 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_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 };
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;
- netmsg_playerjoin init;
- gameserver_populate_join_msg( i, &init );
-
+ /* 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,
- &join, sizeof(join), k_nSteamNetworkingSend_Reliable, NULL );
+ 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 );
+ }
}
}
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;
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) ))
+ 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 );
+ 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 );
+ }
+ 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 );
}
}
-#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_client_index( msg->m_conn );
+ u32 len = 0;
+ if( status == k_request_status_ok ){
+ len = body->len;
+
+ vg_success( "[%d#%d] Response: %d\n", client_id, (i32)res->id, status );
+ vg_msg_print( body );
+ }
+ else{
+ vg_warn( "[%d#%d] Response: %d\n", client_id, (i32)res->id, status );
+ }
+
+ res->status = status;
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 );
+ SteamAPI_SteamNetworkingMessage_t_Release( msg );
}
-static void on_inet_set_nickname( SteamNetworkingMessage_t *msg ){
- if(!inet_require_auth(msg)) return;
+struct user_request_thread_data {
+ SteamNetworkingMessage_t *msg;
+};
+
+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;
- 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 );
+ int client_id = gameserver_client_index( msg->m_conn );
+ if( client_id == -1 ){
+ SteamAPI_SteamNetworkingMessage_t_Release( msg );
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 );
+ netmsg_request *req = (netmsg_request *)msg->m_pData;
+ vg_msg data = {0};
+ data.buf = req->q;
+ data.len = msg->m_cbSize - sizeof(netmsg_request);
+ data.max = data.len;
+
+ /* create response packet */
+ netmsg_request *res = alloca( sizeof(netmsg_request) + 512 );
+ res->inetmsg_id = k_inetmsg_response;
+ res->id = req->id;
+ vg_msg body = {0};
+ body.buf = res->q;
+ body.max = 512;
+
+ const char *endpoint = vg_msg_seekkvstr( &data, "endpoint", 0 );
+
+ if( !endpoint ){
+ gameserver_request_respond( k_request_status_invalid_endpoint,
+ res, NULL, msg );
return;
}
- netmsg_set_score *info = msg->m_pData;
+ if( !strcmp( endpoint, "scoreboard" ) ){
+ const char *mod = vg_msg_seekkvstr( &data, "mod", 0 );
+ const char *route = vg_msg_seekkvstr( &data, "route", 0 );
+ u32 week = vg_msg_seekkvu32( &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( 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 );
+ 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{
+ 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;
}
- 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;
+ if( tmp->inetmsg_id == k_inetmsg_request ){
+ if( !packet_minsize( msg, sizeof(netmsg_request)+1 ))
+ return;
- highscores_push_record( &temp );
+ 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 );
}
}
-#endif
static void poll_connections(void){
SteamNetworkingMessage_t *messages[32];
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 );
-#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 );
}
-
-
- SteamAPI_SteamNetworkingMessage_t_Release( 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 );
+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 );
+ }
}
-
- fclose( fp );
}
int main( int argc, char *argv[] ){
while( vg_argp( argc, argv ) ){
if( vg_long_opt( "noauth" ) )
gameserver.auth_mode = eServerModeNoAuthentication;
+
+ /* TODO: Options to override, ammend, remove etc */
}
- /* 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();
+ db_init();
+ db_request *req = db_alloc_request(0);
+ if( req ){
+ req->handler = test_runner;
+ db_send_request(req);
+ }
- steamworks_ensure_txt( "2103940" );
+ 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 )){
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 );
last_scoreboard_gen = 0,
last_monitor_heartbeat = 0;
- generate_boards();
- monitor_start_server();
-
while( !sig_stop ){
monitor_event_loop();
steamworks_event_loop( hsteampipe );
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