X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=gameserver.c;h=9116a34eb3aa240fc4e556fbb54471496bd620ab;hb=8090b8da9ce1397ba47d7e2d91b4f1716f708f25;hp=840f9d08a40031a2b3e2111d89e552603535b133;hpb=f6bc1299d5b30e1aba87e6ce084bcd7eed22975f;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/gameserver.c b/gameserver.c index 840f9d0..9116a34 100644 --- a/gameserver.c +++ b/gameserver.c @@ -18,50 +18,71 @@ volatile sig_atomic_t sig_stop; #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; } -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 ); +/* + * 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 ]; - 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; iactive ) - 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_send_version_to_client( int index ){ + struct gameserver_client *client = &gameserver.clients[index]; + + 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 ); +} + +/* + * 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 = { .inetmsg_id = k_inetmsg_playerjoin, - .index = index }; + .index = index, + .steamid = joiner->steamid }; + gameserver_send_to_all( index, &join, sizeof(join), k_nSteamNetworkingSend_Reliable ); - /* update the joining user about current connections */ + /* + * 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 ); @@ -74,15 +95,15 @@ static void gameserver_player_join( int index ){ for( int i=0; iactive ) + if( (i == index) || !client->steamid ) 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 ); + .index = i, + .steamid = client->steamid }; + gameserver_send_to_client( index, &init, sizeof(init), + k_nSteamNetworkingSend_Reliable ); /* username */ username->index = i; @@ -90,9 +111,8 @@ static void gameserver_player_join( int index ){ 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 ); + gameserver_send_to_client( index, username, size, + k_nSteamNetworkingSend_Reliable ); /* items */ for( int j=0; jtype_index = j; item->client = i; size = sizeof(netmsg_playeritem) + chs + 1; - SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( - hSteamNetworkingSockets, joiner->connection, - item, size, k_nSteamNetworkingSend_Reliable, NULL ); + gameserver_send_to_client( index, item, 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; @@ -118,10 +145,33 @@ static void gameserver_player_leave( int index ){ k_nSteamNetworkingSend_Reliable ); } -static void new_client_connecting( HSteamNetConnection client ){ +/* + * 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) ); +} + +/* + * 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; iactive = 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 ); } else{ - vg_warn( "Error accepting client (id: %u)\n", client ); + 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; } } @@ -173,19 +220,23 @@ static void on_auth_status( CallbackMsg_t *msg ){ vg_info( " %s\n", info->m_debugMsg ); } -static int gameserver_client_index( HSteamNetConnection hconn ){ - for( int i=0; iactive ){ - if( client->connection == hconn ){ - return i; - } - } - } - return -1; + if( (id < 0) || (id >= NETWORK_MAX_PLAYERS) ) + return -1; + + return id; } +/* + * 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 ); @@ -195,38 +246,101 @@ static void on_connect_status( CallbackMsg_t *msg ){ string_ESteamNetworkingConnectionState(info->m_info.m_eState) ); if( info->m_info.m_eState==k_ESteamNetworkingConnectionState_Connecting ){ - new_client_connecting( info->m_hConn ); + handle_new_connection( info->m_hConn ); } if( (info->m_info.m_eState == k_ESteamNetworkingConnectionState_ClosedByPeer ) || (info->m_info.m_eState == - k_ESteamNetworkingConnectionState_ProblemDetectedLocally ) ){ + 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_client_index( info->m_hConn ); + int client_id = gameserver_conid( 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); + gameserver_player_leave( client_id ); + remove_client( client_id ); + } + 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 ); } } +/* + * 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; + } + + 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( get_connection_authsteamid( msg ) != k_connection_unauthorized ){ - vg_warn( "Already authorized this user but app ticket was sent" - " again (%u)\n", msg->m_conn ); + if( client->version == 0 ){ + vg_error( "Client has not sent their version yet (%u)\n", msg->m_conn ); + remove_client( client_id ); return; } @@ -234,6 +348,7 @@ static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){ if( msg->m_cbSize < sizeof(netmsg_auth) ){ vg_error( "Malformed auth ticket, too small (%u)\n", msg->m_conn ); + remove_client( client_id ); return; } @@ -242,7 +357,8 @@ static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){ 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; } @@ -257,10 +373,7 @@ static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){ 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; } @@ -272,11 +385,7 @@ static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){ 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; } } @@ -286,24 +395,8 @@ static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){ 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 ); } /* @@ -329,7 +422,7 @@ struct db_set_username_thread_data { 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 ) + if( inf->steamid == k_steamid_max ) return; int admin = 0; @@ -342,14 +435,15 @@ static void gameserver_update_db_username( db_request *db_req ){ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ netmsg_blank *tmp = msg->m_pData; - int client_id = gameserver_client_index( msg->m_conn ); + 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; - struct gameserver_client *client = &gameserver.clients[ client_id ]; netmsg_playerusername *src = msg->m_pData; u32 name_len = network_msgstring( src->name, msg->m_cbSize, @@ -376,7 +470,7 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ 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 ); + inf->steamid = client->steamid; vg_strncpy( client->username, inf->username, sizeof(inf->username), k_strncpy_always_add_null ); call->handler = gameserver_update_db_username; @@ -394,7 +488,6 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ 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", @@ -422,6 +515,19 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ 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, + k_nSteamNetworkingSend_Reliable ); + } else { vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n", tmp->inetmsg_id ); @@ -431,7 +537,7 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ 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 ); + int client_id = gameserver_conid( msg->m_conn ); u32 len = 0; if( body ){ len = body->cur.co; @@ -456,16 +562,74 @@ static u32 gameserver_get_current_week(void){ return time(NULL) / (7*24*60*60); } +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 DESC 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; + + vg_msg_frame( msg, "" ); + vg_msg_wkvu32( msg, "time", time ); + vg_msg_wkvu64( msg, "steamid", 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_client_index( msg->m_conn ); + int client_id = gameserver_conid( msg->m_conn ); if( client_id == -1 ){ SteamAPI_SteamNetworkingMessage_t_Release( msg ); return; } + 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) ); @@ -490,67 +654,17 @@ static void gameserver_process_user_request( db_request *db_req ){ 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; + if( week == NETWORK_LEADERBOARD_CURRENT_WEEK ){ + gameserver_cat_table( &body, mod, route, + gameserver_get_current_week(), "rows_weekly" ); } - - 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; + 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" ); } - - 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 ); + 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, @@ -561,12 +675,7 @@ static void gameserver_process_user_request( db_request *db_req ){ 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 ){ + if( client->steamid == k_steamid_max ){ gameserver_request_respond( k_request_status_unauthorized, res, NULL, msg ); return; @@ -594,8 +703,8 @@ static void gameserver_process_user_request( db_request *db_req ){ return; } - db_writeusertime( alltime_table, steamid, centiseconds, 1 ); - db_writeusertime( weekly_table, steamid, centiseconds, 1 ); + 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 ); } @@ -608,7 +717,7 @@ static void gameserver_process_user_request( db_request *db_req ){ static void gameserver_rx_300_400( SteamNetworkingMessage_t *msg ){ netmsg_blank *tmp = msg->m_pData; - int client_id = gameserver_client_index( msg->m_conn ); + int client_id = gameserver_conid( msg->m_conn ); if( client_id == -1 ){ SteamAPI_SteamNetworkingMessage_t_Release( msg ); return; @@ -665,6 +774,9 @@ static void poll_connections(void){ 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 ); @@ -730,7 +842,7 @@ int main( int argc, char *argv[] ){ 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; @@ -757,7 +869,7 @@ int main( int argc, char *argv[] ){ 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 );