network.c

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