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