X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=gameserver.c;h=e315fd0e69b7c096cbadd1d8b6d6abca6df12345;hb=HEAD;hp=b1058bb99ec56b243f1377622210c48027ddd9bb;hpb=d7fc81080aed9c32cbbb9c12a851be8248dd35ec;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/gameserver.c b/gameserver.c index b1058bb..e315fd0 100644 --- a/gameserver.c +++ b/gameserver.c @@ -6,12 +6,11 @@ #include #include #include +#include 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" @@ -24,14 +23,26 @@ static void inthandler( int signum ) { sig_stop = 1; } +static void release_message( SteamNetworkingMessage_t *msg ) +{ + msg->m_nUserData --; + + if( msg->m_nUserData == 0 ) + SteamAPI_SteamNetworkingMessage_t_Release( msg ); +} + /* * Send message to single client, with authentication checking */ static void gameserver_send_to_client( i32 client_id, const void *pData, u32 cbData, - int nSendFlags ){ + int nSendFlags ) +{ struct gameserver_client *client = &gameserver.clients[ client_id ]; + if( gameserver.loopback_test && !client->connection ) + return; + if( !client->steamid ) return; @@ -45,8 +56,10 @@ static void gameserver_send_to_client( i32 client_id, */ static void gameserver_send_to_all( int ignore, const void *pData, u32 cbData, - int nSendFlags ){ - for( int i=0; iconnection ) + 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 ); +} + /* * handle server update that client #'index' has joined */ -static void gameserver_player_join( int index ){ +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 ); username->inetmsg_id = k_inetmsg_playerusername; @@ -76,7 +110,11 @@ static void gameserver_player_join( int index ){ alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX ); item->inetmsg_id = k_inetmsg_playeritem; - for( int i=0; iinetmsg_id = k_inetmsg_region; + + for( int i=0; isteamid ) @@ -84,7 +122,8 @@ static void gameserver_player_join( int index ){ /* join */ netmsg_playerjoin init = { .inetmsg_id = k_inetmsg_playerjoin, - .index = i }; + .index = i, + .steamid = client->steamid }; gameserver_send_to_client( index, &init, sizeof(init), k_nSteamNetworkingSend_Reliable ); @@ -98,8 +137,9 @@ static void gameserver_player_join( int index ){ k_nSteamNetworkingSend_Reliable ); /* items */ - for( int j=0; jitems[j], item->uid, ADDON_UID_MAX, + for( int j=0; jitems[j].uid, item->uid, ADDON_UID_MAX, k_strncpy_always_add_null ); item->type_index = j; item->client = i; @@ -107,6 +147,17 @@ static void gameserver_player_join( int index ){ 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 ); } } @@ -119,7 +170,7 @@ static void gameserver_player_leave( int index ){ return; } - netmsg_playerjoin leave; + netmsg_playerleave leave; leave.inetmsg_id = k_inetmsg_playerleave; leave.index = index; @@ -128,6 +179,8 @@ static void gameserver_player_leave( int index ){ k_nSteamNetworkingSend_Reliable ); } +static void gameserver_update_all_knowledge( int client, int clear ); + /* * Deletes client at index and disconnects the connection handle if it was * set. @@ -143,13 +196,15 @@ static void remove_client( int index ){ 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 ){ +static void handle_new_connection( HSteamNetConnection conn ) +{ SteamAPI_ISteamNetworkingSockets_SetConnectionUserData( hSteamNetworkingSockets, conn, -1 ); @@ -175,7 +230,8 @@ static void handle_new_connection( HSteamNetConnection conn ){ EResult accept_status = SteamAPI_ISteamNetworkingSockets_AcceptConnection( hSteamNetworkingSockets, conn ); - if( accept_status == k_EResultOK ){ + if( accept_status == k_EResultOK ) + { vg_success( "Accepted client (id: %u, index: %d)\n", conn, index ); client->active = 1; @@ -186,13 +242,17 @@ static void handle_new_connection( HSteamNetConnection conn ){ SteamAPI_ISteamNetworkingSockets_SetConnectionUserData( hSteamNetworkingSockets, conn, index ); - - if( gameserver.auth_mode != eServerModeAuthentication ){ - client->steamid = k_steamid_max; - gameserver_player_join( 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{ + else + { vg_warn( "Error accepting connection (id: %u)\n", conn ); SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, conn, @@ -212,8 +272,19 @@ static void on_auth_status( CallbackMsg_t *msg ){ * 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 = SteamAPI_ISteamNetworkingSockets_GetConnectionUserData( +static i32 gameserver_conid( HSteamNetConnection hconn ) +{ + i64 id; + + if( hconn == 0 ) + { + if( gameserver.loopback_test ) + return 1; + else + return -1; + } + else + id = SteamAPI_ISteamNetworkingSockets_GetConnectionUserData( hSteamNetworkingSockets, hconn ); if( (id < 0) || (id >= NETWORK_MAX_PLAYERS) ) @@ -225,7 +296,8 @@ static i32 gameserver_conid( HSteamNetConnection hconn ){ /* * Callback for steam connection state change */ -static void on_connect_status( CallbackMsg_t *msg ){ +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 ); @@ -233,7 +305,8 @@ static void on_connect_status( CallbackMsg_t *msg ){ string_ESteamNetworkingConnectionState(info->m_eOldState), string_ESteamNetworkingConnectionState(info->m_info.m_eState) ); - if( info->m_info.m_eState==k_ESteamNetworkingConnectionState_Connecting ){ + if( info->m_info.m_eState==k_ESteamNetworkingConnectionState_Connecting ) + { handle_new_connection( info->m_hConn ); } @@ -249,25 +322,83 @@ static void on_connect_status( CallbackMsg_t *msg ){ vg_info( "End reason: %d\n", info->m_info.m_eEndReason ); int client_id = gameserver_conid( info->m_hConn ); - if( client_id != -1 ){ + 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 { + else + { SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, info->m_hConn, 0, NULL, 0 ); } } } +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, 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; } @@ -275,21 +406,30 @@ static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){ 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; + } + 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 ); + remove_client( client_id ); return; } @@ -298,7 +438,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; } @@ -372,7 +513,109 @@ static void gameserver_update_db_username( db_request *db_req ){ db_updateuser( inf->steamid, inf->username, admin ); } -static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ +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; isteamid ) + 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; iinstance == 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<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; int client_id = gameserver_conid( msg->m_conn ); @@ -380,7 +623,8 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ struct gameserver_client *client = &gameserver.clients[ client_id ]; - if( tmp->inetmsg_id == k_inetmsg_playerusername ){ + if( tmp->inetmsg_id == k_inetmsg_playerusername ) + { if( !packet_minsize( msg, sizeof(netmsg_playerusername)+1 )) return; @@ -416,26 +660,24 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ 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_playerframe ) + { + gameserver_propogate_player_frame( client_id, + msg->m_pData, msg->m_cbSize ); } - else if( tmp->inetmsg_id == k_inetmsg_playeritem ){ + else if( tmp->inetmsg_id == k_inetmsg_playeritem ) + { netmsg_playeritem *item = msg->m_pData; /* record */ - - if( item->type_index >= k_netmsg_playeritem_max ){ + 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 ]; + char *dest = client->items[ item->type_index ].uid; network_msgstring( item->uid, msg->m_cbSize, sizeof(netmsg_playeritem), dest, ADDON_UID_MAX ); @@ -447,6 +689,8 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ [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); @@ -455,7 +699,43 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){ gameserver_send_to_all( client_id, prop, msg->m_cbSize, k_nSteamNetworkingSend_Reliable ); } - else { + 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 ); } @@ -474,11 +754,18 @@ static void gameserver_request_respond( enum request_status status, res->status = status; + if( gameserver.loopback_test && !msg->m_conn ) + { + release_message( msg ); + return; + } + SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( hSteamNetworkingSockets, msg->m_conn, res, sizeof(netmsg_request) + len, k_nSteamNetworkingSend_Reliable, NULL ); - SteamAPI_SteamNetworkingMessage_t_Release( msg ); + + release_message( msg ); } struct user_request_thread_data { @@ -502,7 +789,7 @@ static enum request_status gameserver_cat_table( vg_strnull( &q, buf, 512 ); vg_strcat( &q, "SELECT * FROM \"" ); vg_strcat( &q, table_name ); - vg_strcat( &q, "\" ORDER BY time DESC LIMIT 10;" ); + vg_strcat( &q, "\" ORDER BY time ASC LIMIT 10;" ); if( !vg_strgood(&q) ) return k_request_status_out_of_memory; @@ -523,8 +810,8 @@ static enum request_status gameserver_cat_table( continue; vg_msg_frame( msg, "" ); - vg_msg_wkvu32( msg, "time", time ); - vg_msg_wkvu64( msg, "steamid", steamid ); + 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 ) ) @@ -545,13 +832,15 @@ static enum request_status gameserver_cat_table( return k_request_status_ok; } -static void gameserver_process_user_request( db_request *db_req ){ +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 ){ - SteamAPI_SteamNetworkingMessage_t_Release( msg ); + if( client_id == -1 ) + { + release_message( msg ); return; } @@ -562,11 +851,11 @@ static void gameserver_process_user_request( db_request *db_req ){ vg_msg_init( &data, req->q, msg->m_cbSize - sizeof(netmsg_request) ); /* create response packet */ - netmsg_request *res = alloca( sizeof(netmsg_request) + 512 ); + 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, 512 ); + vg_msg_init( &body, res->q, NETWORK_REQUEST_MAX ); const char *endpoint = vg_msg_getkvstr( &data, "endpoint" ); @@ -579,7 +868,8 @@ static void gameserver_process_user_request( db_request *db_req ){ 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 ); + 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, @@ -623,7 +913,8 @@ static void gameserver_process_user_request( db_request *db_req ){ return; } - i32 centiseconds = vg_msg_getkvi32( &data, "time", -1 ); + 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 ); @@ -632,7 +923,6 @@ static void gameserver_process_user_request( db_request *db_req ){ 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{ @@ -641,18 +931,30 @@ static void gameserver_process_user_request( db_request *db_req ){ } } -static void gameserver_rx_300_400( SteamNetworkingMessage_t *msg ){ +static void gameserver_rx_300_400( SteamNetworkingMessage_t *msg ) +{ netmsg_blank *tmp = msg->m_pData; int client_id = gameserver_conid( msg->m_conn ); - if( client_id == -1 ){ - SteamAPI_SteamNetworkingMessage_t_Release( msg ); + if( client_id == -1 ) + { + release_message( msg ); return; } - if( tmp->inetmsg_id == k_inetmsg_request ){ + 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) ); @@ -661,18 +963,54 @@ static void gameserver_rx_300_400( SteamNetworkingMessage_t *msg ){ call->handler = gameserver_process_user_request; db_send_request( call ); } - else { + else + { vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n", tmp->inetmsg_id ); - SteamAPI_SteamNetworkingMessage_t_Release( msg ); + release_message( msg ); } } -static void poll_connections(void){ +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; + } + + netmsg_blank *tmp = msg->m_pData; + + 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 ); + } +} + +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) ); @@ -680,33 +1018,21 @@ static void poll_connections(void){ if( len <= 0 ) return; - for( int i=0; im_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 ); - 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 ); - } + process_network_message( msg ); } } } @@ -715,43 +1041,24 @@ 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 ) ){ + while( vg_argp( argc, argv ) ) + { if( vg_long_opt( "noauth" ) ) gameserver.auth_mode = eServerModeNoAuthentication; - /* TODO: Options to override, ammend, remove etc */ + if( vg_long_opt( "loopback" ) ) + gameserver.loopback_test = 1; } 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 * --------------------------------------------------------------- */ @@ -802,23 +1109,15 @@ int main( int argc, char *argv[] ){ u64 server_ticks = 8000, last_record_save = 8000, - last_scoreboard_gen = 0, - last_monitor_heartbeat = 0; + 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( db_killed() ) break; }