network.c

   1 #include "player.h"
   2 #include "network.h"
   3 #include "network_msg.h"
   4 #include "player_remote.h"
   5
   6 static void scores_update(void);
   7
   8 static void on_auth_ticket_recieved( void *result, void *context ){
   9    EncryptedAppTicketResponse_t *response = result;
  10
  11    if( response->m_eResult == k_EResultOK ){
  12       vg_info( "  New app ticket ready\n" );
  13    }
  14    else{
  15       vg_warn( "  Could not request new encrypted app ticket (%u)\n",
  16                   response->m_eResult );
  17    }
  18
  19    if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser,
  20             network_client.app_symmetric_key,
  21             vg_list_size(network_client.app_symmetric_key),
  22             &network_client.app_key_length )){
  23       vg_success( "  Loaded app ticket\n" );
  24    }
  25    else{
  26       vg_error( "  No ticket availible\n" );
  27       network_client.app_key_length = 0;
  28    }
  29 }
  30
  31 static void request_auth_ticket(void){
  32    /*
  33     * TODO Check for one thats cached on the disk and load it.
  34     * This might be OK though because steam seems to cache the result
  35     */
  36
  37    vg_info( "Requesting new authorization ticket\n" );
  38
  39    vg_steam_async_call *call = vg_alloc_async_steam_api_call();
  40    call->userdata = NULL;
  41    call->p_handler = on_auth_ticket_recieved;
  42    call->id =
  43       SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser, NULL, 0 );
  44 }
  45
  46 static void send_auth_ticket(void){
  47    u32 size = sizeof(netmsg_auth) + network_client.app_key_length;
  48    netmsg_auth *auth = alloca(size);
  49
  50    auth->inetmsg_id = k_inetmsg_auth;
  51    auth->ticket_length = network_client.app_key_length;
  52    for( int i=0; i<network_client.app_key_length; i++ )
  53       auth->ticket[i] = network_client.app_symmetric_key[i];
  54
  55    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
  56          hSteamNetworkingSockets, network_client.remote, auth, size,
  57          k_nSteamNetworkingSend_Reliable, NULL );
  58 }
  59
  60 static void send_score_request(void){
  61    vg_info( "Requesting scores\n" );
  62    netmsg_scores_request req;
  63    req.inetmsg_id = k_inetmsg_scores_request;
  64
  65    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
  66          hSteamNetworkingSockets, network_client.remote,
  67          &req, sizeof(netmsg_scores_request),
  68          k_nSteamNetworkingSend_Reliable, NULL );
  69 }
  70
  71 static void send_score_update(void){
  72    vg_info( "Sending scores\n" );
  73    u32 size = sizeof(netmsg_set_score) +
  74                   vg_list_size(track_infos)*sizeof(struct netmsg_score_record);
  75    netmsg_set_score *setscore = alloca( size );
  76    setscore->inetmsg_id = k_inetmsg_set_score;
  77
  78    int count = 0;
  79    for( u32 i=0; i<vg_list_size(track_infos); i++ ){
  80       if( track_infos[i].push ){
  81          track_infos[i].push = 0;
  82
  83 #if 0
  84          highscore_record *user_record = highscore_find_user_record( 0, i );
  85
  86          if( !user_record ){
  87             vg_error( "No score set but tried to upload for track %u\n", i );
  88             continue;
  89          }
  90 #endif
  91          highscore_record *user_record = &track_infos[i].record;
  92
  93          setscore->records[count].trackid = i;
  94          setscore->records[count].playerid = 0;
  95          setscore->records[count].points = user_record->points;
  96          setscore->records[count].time = user_record->time;
  97
  98          count ++;
  99       }
 100    }
 101
 102    if( count == 0 ) return;
 103    u32 send_size = sizeof(netmsg_set_score) +
 104                   count*sizeof(struct netmsg_score_record);
 105    setscore->record_count = count;
 106
 107    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 108          hSteamNetworkingSockets, network_client.remote, setscore, send_size,
 109          k_nSteamNetworkingSend_Reliable, NULL );
 110 }
 111
 112 static void send_nickname(void){
 113    netmsg_set_nickname nick;
 114    nick.inetmsg_id = k_inetmsg_set_nickname;
 115
 116    memset( nick.nickname, 0, 16 );
 117    vg_strncpy( steam_username_at_startup, nick.nickname, 16,
 118                k_strncpy_allow_cutoff );
 119
 120    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 121          hSteamNetworkingSockets, network_client.remote,
 122          &nick, sizeof(netmsg_set_nickname),
 123          k_nSteamNetworkingSend_Reliable, NULL );
 124
 125    network_client.name_update = 0;
 126 }
 127
 128 static void network_send_playerframe(void){
 129    netmsg_playerframe frame;
 130    frame.inetmsg_id = k_inetmsg_playerframe;
 131    v3_copy( localplayer.rb.co, frame.pos_temp );
 132
 133    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 134          hSteamNetworkingSockets, network_client.remote,
 135          &frame, sizeof(frame),
 136          k_nSteamNetworkingSend_Unreliable, NULL );
 137 }
 138
 139 static void server_routine_update(void){
 140    if( network_client.name_update )
 141       send_nickname();
 142
 143    send_score_update();
 144    send_score_request();
 145 }
 146
 147 static void on_server_connect_status( CallbackMsg_t *msg ){
 148    SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
 149    vg_info( "  Connection status changed for %lu\n", info->m_hConn );
 150    vg_info( "  %s -> %s\n",
 151          string_ESteamNetworkingConnectionState(info->m_eOldState),
 152          string_ESteamNetworkingConnectionState(info->m_info.m_eState) );
 153
 154    if( info->m_hConn == network_client.remote ){
 155       network_client.state = info->m_info.m_eState;
 156
 157       if( info->m_info.m_eState ==
 158             k_ESteamNetworkingConnectionState_Connected ){
 159          vg_success("  Connected to remote server.. authenticating\n");
 160          send_auth_ticket();
 161       }
 162       else if( info->m_info.m_eState ==
 163             k_ESteamNetworkingConnectionState_ClosedByPeer ){
 164
 165          if( info->m_info.m_eEndReason ==
 166                k_ESteamNetConnectionEnd_Remote_Max ){
 167             network_client.retries = 40;
 168          }
 169
 170          SteamAPI_ISteamNetworkingSockets_CloseConnection(
 171                hSteamNetworkingSockets, info->m_hConn, 0, NULL, 0 );
 172          network_client.remote = 0;
 173       }
 174       else if( info->m_info.m_eState ==
 175             k_ESteamNetworkingConnectionState_ProblemDetectedLocally ){
 176          SteamAPI_ISteamNetworkingSockets_CloseConnection(
 177                hSteamNetworkingSockets, info->m_hConn, 0, NULL, 0 );
 178          network_client.remote = 0;
 179       }
 180    }
 181    else{
 182       //vg_warn( "  Recieved signal from unknown connection\n" );
 183    }
 184 }
 185
 186 static void network_connect(void){
 187    /* Connect to server if not connected */
 188    SteamNetworkingIPAddr remoteAddr;
 189
 190 #ifdef SR_USE_LOCALHOST
 191    SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost( &remoteAddr, 27402 );
 192 #else
 193    const char *server_lon1 = "46.101.34.155:27402";
 194    SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, server_lon1 );
 195 #endif
 196
 197    char buf[256];
 198    SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr, buf, 256, 1 );
 199    vg_info( "connect to: %s\n", buf );
 200
 201    network_client.remote = SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
 202                   hSteamNetworkingSockets, &remoteAddr, 0, NULL );
 203 }
 204
 205 static void on_inet_scoreboard( SteamNetworkingMessage_t *msg ){
 206    netmsg_scoreboard *sb = msg->m_pData;
 207
 208    u32 base_size = sizeof(netmsg_scoreboard)-
 209       sizeof(struct netmsg_board)*vg_list_size(track_infos),
 210        expected = base_size+sizeof(struct netmsg_board)*sb->board_count;
 211
 212    if( msg->m_cbSize != expected ){
 213       vg_error( "Server scoreboard was corrupted. Size: %u != %u\n",
 214             msg->m_cbSize, expected );
 215    }
 216    else{
 217       if( vg_list_size(track_infos) > sb->board_count )
 218          vg_warn( "Server is out of date, not enough boards recieved\n");
 219       else if( vg_list_size(track_infos) < sb->board_count )
 220          vg_warn( "Client out of date, server sent more boards than we have\n");
 221       else
 222          vg_success( "Recieved new scoreboards from server\n" );
 223
 224       for( int i=0; i < vg_min(sb->board_count,vg_list_size(track_infos)); i++){
 225          scoreboard_client_data.boards[i] = sb->boards[i];
 226          highscores_board_printf( stdout, sb->boards[i].data, 10 );
 227       }
 228    }
 229
 230 #if 0
 231    /* We dont need to stay on the server currently */
 232    SteamAPI_ISteamNetworkingSockets_CloseConnection(
 233          hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
 234 #endif
 235
 236    network_scores_updated = 1;
 237 }
 238
 239 static void poll_remote_connection(void){
 240    SteamNetworkingMessage_t *messages[32];
 241    int len;
 242
 243    for( int i=0; i<10; i++ ){
 244       len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
 245             hSteamNetworkingSockets, network_client.remote,
 246             messages, vg_list_size(messages));
 247
 248       if( len <= 0 )
 249          return;
 250
 251       for( int i=0; i<len; i++ ){
 252          SteamNetworkingMessage_t *msg = messages[i];
 253
 254          if( msg->m_cbSize < sizeof(netmsg_blank) ){
 255             vg_warn( "Discarding message (too small: %d)\n", msg->m_cbSize );
 256             continue;
 257          }
 258
 259          netmsg_blank *tmp = msg->m_pData;
 260
 261          if( tmp->inetmsg_id == k_inetmsg_scoreboard )
 262             on_inet_scoreboard( msg );
 263
 264          if( (tmp->inetmsg_id >= 200) && (tmp->inetmsg_id < 300) ){
 265             player_remote_packet( msg );
 266          }
 267
 268          SteamAPI_SteamNetworkingMessage_t_Release( msg );
 269       }
 270    }
 271 }
 272
 273 static void network_update(void){
 274    if( !steam_ready )
 275       return;
 276
 277    ESteamNetworkingConnectionState state = network_client.state;
 278
 279    if( state == k_ESteamNetworkingConnectionState_Connected ){
 280       poll_remote_connection();
 281       f64 frame_delta = vg.time_real - network_client.last_frame;
 282
 283       if( frame_delta > 0.1 ){
 284          network_client.last_frame = vg.time_real;
 285          network_send_playerframe();
 286       }
 287    }
 288    else {
 289       if( (state == k_ESteamNetworkingConnectionState_Connecting) ||
 290           (state == k_ESteamNetworkingConnectionState_FindingRoute) ){
 291          return;
 292       }
 293       else {
 294          f64 waited = vg.time_real - network_client.last_attempt,
 295              min_wait = 1.0;
 296
 297          if( network_client.retries > 5 )
 298             min_wait = 60.0;
 299
 300          if( waited < min_wait )
 301             return;
 302
 303          network_connect();
 304          network_client.retries ++;
 305          network_client.last_attempt = vg.time_real;
 306       }
 307    }
 308 }
 309
 310 static void network_init(void){
 311    vg_console_reg_var( "network_info", &network_client.network_info,
 312                        k_var_dtype_i32, VG_VAR_PERSISTENT );
 313    if( steam_ready ){
 314       steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack,
 315                                on_server_connect_status );
 316       request_auth_ticket();
 317    }
 318 }
 319
 320 static void network_end(void){
 321    /* TODO: Send buffered highscores that were not already */
 322    if( (network_client.state == k_ESteamNetworkingConnectionState_Connected) ||
 323        (network_client.state == k_ESteamNetworkingConnectionState_Connecting) )
 324    {
 325       SteamAPI_ISteamNetworkingSockets_CloseConnection(
 326             hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
 327    }
 328 }