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 #include "world_sfd.h"
   7
   8 static void scores_update(void);
   9
  10 static int packet_minsize( SteamNetworkingMessage_t *msg, u32 size ){
  11    if( msg->m_cbSize < size ) {
  12       vg_error( "Invalid packet size (must be at least %u)\n", size );
  13       return 0;
  14    }
  15    else{
  16       return 1;
  17    }
  18 }
  19
  20 static void on_auth_ticket_recieved( void *result, void *context ){
  21    EncryptedAppTicketResponse_t *response = result;
  22
  23    if( response->m_eResult == k_EResultOK ){
  24       vg_info( "  New app ticket ready\n" );
  25    }
  26    else{
  27       vg_warn( "  Could not request new encrypted app ticket (%u)\n",
  28                   response->m_eResult );
  29    }
  30
  31    if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser,
  32             network_client.app_symmetric_key,
  33             vg_list_size(network_client.app_symmetric_key),
  34             &network_client.app_key_length )){
  35       vg_success( "  Loaded app ticket\n" );
  36    }
  37    else{
  38       vg_error( "  No ticket availible\n" );
  39       network_client.app_key_length = 0;
  40    }
  41 }
  42
  43 static void request_auth_ticket(void){
  44    /*
  45     * TODO Check for one thats cached on the disk and load it.
  46     * This might be OK though because steam seems to cache the result
  47     */
  48
  49    vg_info( "Requesting new authorization ticket\n" );
  50
  51    vg_steam_async_call *call = vg_alloc_async_steam_api_call();
  52    call->userdata = NULL;
  53    call->p_handler = on_auth_ticket_recieved;
  54    call->id =
  55       SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser, NULL, 0 );
  56 }
  57
  58 #if 0
  59 static void send_score_request(void){
  60    vg_info( "Requesting scores\n" );
  61    netmsg_scores_request req;
  62    req.inetmsg_id = k_inetmsg_scores_request;
  63
  64    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
  65          hSteamNetworkingSockets, network_client.remote,
  66          &req, sizeof(netmsg_scores_request),
  67          k_nSteamNetworkingSend_Reliable, NULL );
  68 }
  69
  70 static void send_score_update(void){
  71    vg_info( "Sending scores\n" );
  72    u32 size = sizeof(netmsg_set_score) +
  73                   vg_list_size(track_infos)*sizeof(struct netmsg_score_record);
  74    netmsg_set_score *setscore = alloca( size );
  75    setscore->inetmsg_id = k_inetmsg_set_score;
  76
  77    int count = 0;
  78    for( u32 i=0; i<vg_list_size(track_infos); i++ ){
  79       if( track_infos[i].push ){
  80          track_infos[i].push = 0;
  81
  82 #if 0
  83          highscore_record *user_record = highscore_find_user_record( 0, i );
  84
  85          if( !user_record ){
  86             vg_error( "No score set but tried to upload for track %u\n", i );
  87             continue;
  88          }
  89 #endif
  90          highscore_record *user_record = &track_infos[i].record;
  91
  92          setscore->records[count].trackid = i;
  93          setscore->records[count].playerid = 0;
  94          setscore->records[count].points = user_record->points;
  95          setscore->records[count].time = user_record->time;
  96
  97          count ++;
  98       }
  99    }
 100
 101    if( count == 0 ) return;
 102    u32 send_size = sizeof(netmsg_set_score) +
 103                   count*sizeof(struct netmsg_score_record);
 104    setscore->record_count = count;
 105
 106    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 107          hSteamNetworkingSockets, network_client.remote, setscore, send_size,
 108          k_nSteamNetworkingSend_Reliable, NULL );
 109 }
 110
 111 static void send_nickname(void){
 112    netmsg_set_nickname nick;
 113    nick.inetmsg_id = k_inetmsg_set_nickname;
 114
 115    memset( nick.nickname, 0, 16 );
 116    vg_strncpy( steam_username_at_startup, nick.nickname, 16,
 117                k_strncpy_allow_cutoff );
 118
 119    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 120          hSteamNetworkingSockets, network_client.remote,
 121          &nick, sizeof(netmsg_set_nickname),
 122          k_nSteamNetworkingSend_Reliable, NULL );
 123
 124    network_client.name_update = 0;
 125 }
 126 #endif
 127
 128 #if 0
 129 static void server_routine_update(void){
 130    send_score_update();
 131    send_score_request();
 132 }
 133 #endif
 134
 135 static void network_send_username(void){
 136    netmsg_playerusername *update = alloca( sizeof(netmsg_playerusername)+
 137                                            NETWORK_USERNAME_MAX );
 138    update->inetmsg_id = k_inetmsg_playerusername;
 139    update->index = 0xff;
 140
 141    ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
 142    const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends);
 143    u32 chs = str_utf8_collapse( username, update->name, NETWORK_USERNAME_MAX );
 144
 145    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 146          hSteamNetworkingSockets, network_client.remote,
 147          update, sizeof(netmsg_playerusername)+chs+1,
 148          k_nSteamNetworkingSend_Reliable, NULL );
 149 }
 150
 151 static void network_send_request( netmsg_request *req, vg_msg *body,
 152                                   void (*callback)( netmsg_request *res,
 153                                                     vg_msg *body )){
 154    u32 len = 0;
 155    if( body ){
 156       len = body->cur.co;
 157       vg_info( "Request scoreboard. Info (%u):\n", body->cur.co );
 158       vg_msg_print( body, len );
 159
 160       if( body->error != k_vg_msg_error_OK ){
 161          vg_error( "Body not OK\n" );
 162          return;
 163       }
 164    }
 165
 166    if( callback ){
 167       req->id = vg_pool_lru( &network_client.request_pool );
 168       if( req->id ){
 169          vg_pool_watch( &network_client.request_pool, req->id );
 170          struct network_request *pn =
 171             vg_pool_item( &network_client.request_pool, req->id );
 172          pn->callback = callback;
 173          pn->sendtime = vg.time_real;
 174       }
 175       else{
 176          vg_error( "Unable to send request. Pool is full.\n" );
 177          return;
 178       }
 179    }
 180    else
 181       req->id = 0;
 182
 183    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 184          hSteamNetworkingSockets, network_client.remote,
 185          req, sizeof(netmsg_request)+len,
 186          k_nSteamNetworkingSend_Reliable, NULL );
 187 }
 188
 189 static void network_scoreboard_callback( netmsg_request *res, vg_msg *body ){
 190    for( u32 i=0; i<13; i++ )
 191       sfd_encode( i, "" );
 192
 193    if( res->status != k_request_status_ok ){
 194       char buf[32];
 195       vg_str s;
 196       vg_strnull( &s, buf, 32 );
 197       vg_strcat( &s, "Error: " );
 198       vg_strcati32( &s, res->status );
 199
 200       sfd_encode( 4, buf );
 201       return;
 202    }
 203
 204    u32 l = 0;
 205    if( vg_msg_seekframe( body, "rows" ) ){
 206       while( vg_msg_seekframe( body, NULL ) ){
 207          const char *username = vg_msg_getkvstr( body, "username" );
 208
 209          if( username )
 210             sfd_encode( l ++, username );
 211          else
 212             sfd_encode( l ++, "UNKNOWN USER" );
 213
 214          vg_msg_skip_frame( body );
 215       }
 216    }
 217 }
 218
 219 /* mod_uid: world mod uid,
 220  * route_uid: run name (just a string)
 221  * week: 0 for all-time, n for week #
 222  */
 223 static void network_request_scoreboard( const char *mod_uid,
 224                                         const char *route_uid,
 225                                         u32 week ){
 226    if( !network_client.remote )
 227       return;
 228
 229    netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
 230    req->inetmsg_id = k_inetmsg_request;
 231
 232    vg_msg data;
 233    vg_msg_init( &data, req->q, 512 );
 234    vg_msg_wkvstr( &data, "endpoint", "scoreboard" );
 235    vg_msg_wkvstr( &data, "mod", mod_uid );
 236    vg_msg_wkvstr( &data, "route", route_uid );
 237    vg_msg_wkvu32( &data, "week", week );
 238    network_send_request( req, &data, network_scoreboard_callback );
 239 }
 240
 241 static void network_publish_callback( netmsg_request *res, vg_msg *body ){
 242    if( res->status != k_request_status_ok ){
 243       vg_error( "Publish laptime, server error #%d\n", (i32)res->status );
 244    }
 245 }
 246
 247 static void network_publish_laptime( const char *mod_uid,
 248                                      const char *route_uid, f64 lap_time ){
 249    if( !network_client.remote )
 250       return;
 251
 252    i32 time_centiseconds = lap_time * 100.0;
 253
 254    netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
 255    req->inetmsg_id = k_inetmsg_request;
 256
 257    vg_msg data;
 258    vg_msg_init( &data, req->q, 512 );
 259    vg_msg_wkvstr( &data, "endpoint", "setlap" );
 260    vg_msg_wkvstr( &data, "mod", mod_uid );
 261    vg_msg_wkvstr( &data, "route", route_uid );
 262    vg_msg_wkvi32( &data, "time", time_centiseconds );
 263    network_send_request( req, &data, network_publish_callback );
 264 }
 265
 266 static void network_request_rx_300_400( SteamNetworkingMessage_t *msg ){
 267    netmsg_blank *tmp = msg->m_pData;
 268
 269    if( tmp->inetmsg_id == k_inetmsg_request ){
 270
 271    }
 272    else if( tmp->inetmsg_id == k_inetmsg_response ){
 273       netmsg_request *res = (netmsg_request *)msg->m_pData;
 274
 275       vg_msg *body = NULL;
 276
 277       vg_msg data;
 278       if( res->status == k_request_status_ok ){
 279          vg_msg_init( &data, res->q, msg->m_cbSize - sizeof(netmsg_request) );
 280          vg_success( "Response to #%d:\n", (i32)res->id );
 281          vg_msg_print( &data, data.max );
 282          body = &data;
 283       }
 284       else {
 285          vg_warn( "Server response to #%d: %d\n", (i32)res->id, res->status );
 286       }
 287
 288       if( res->id ){
 289          struct network_request *pn =
 290             vg_pool_item( &network_client.request_pool, res->id );
 291          pn->callback( res, body );
 292          vg_pool_unwatch( &network_client.request_pool, res->id );
 293       }
 294    }
 295 }
 296
 297 static void network_send_item( enum netmsg_playeritem_type type ){
 298    if( !network_client.remote )
 299       return;
 300
 301    netmsg_playeritem *item =
 302       alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
 303    item->inetmsg_id = k_inetmsg_playeritem;
 304    item->type_index = type;
 305    item->client = 0;
 306
 307    if( (type == k_netmsg_playeritem_world0) ||
 308        (type == k_netmsg_playeritem_world1) ){
 309
 310       addon_reg *reg = world_static.addon_hub;
 311
 312       if( type == k_netmsg_playeritem_world1 )
 313          reg = world_static.addon_client;
 314
 315       if( reg )
 316          addon_alias_uid( &reg->alias, item->uid );
 317       else
 318          item->uid[0] = '\0';
 319    }
 320    else{
 321       u16 view_id = 0;
 322       enum addon_type addon_type = k_addon_type_none;
 323       if( type == k_netmsg_playeritem_board ){
 324          view_id = localplayer.board_view_slot;
 325          addon_type = k_addon_type_board;
 326       }
 327       else if( type == k_netmsg_playeritem_player ){
 328          view_id = localplayer.playermodel_view_slot;
 329          addon_type = k_addon_type_player;
 330       }
 331       else
 332          assert(0);
 333
 334       struct addon_cache *cache = &addon_system.cache[addon_type];
 335       vg_pool *pool = &cache->pool;
 336
 337       SDL_AtomicLock( &addon_system.sl_cache_using_resources );
 338       addon_cache_entry *entry = vg_pool_item( pool, view_id );
 339       addon_alias_uid( &entry->reg_ptr->alias, item->uid );
 340       SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
 341    }
 342
 343    vg_info( "send equip: [%u] %s\n",
 344             item->type_index, item->uid );
 345    u32 chs = strlen(item->uid);
 346
 347    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 348          hSteamNetworkingSockets, network_client.remote,
 349          item, sizeof(netmsg_playeritem)+chs+1,
 350          k_nSteamNetworkingSend_Reliable, NULL );
 351 }
 352
 353 static void network_disconnect(void){
 354    SteamAPI_ISteamNetworkingSockets_CloseConnection(
 355          hSteamNetworkingSockets, network_client.remote, 0, NULL, 0 );
 356    network_client.remote = 0;
 357
 358    for( int i=0; i<vg_list_size(netplayers.list); i++ ){
 359       netplayers.list[i].active = 0;
 360    }
 361 }
 362
 363 static void on_server_connect_status( CallbackMsg_t *msg ){
 364    SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
 365    vg_info( "  Connection status changed for %lu\n", info->m_hConn );
 366    vg_info( "  %s -> %s\n",
 367          string_ESteamNetworkingConnectionState(info->m_eOldState),
 368          string_ESteamNetworkingConnectionState(info->m_info.m_eState) );
 369
 370    if( info->m_hConn == network_client.remote ){
 371       network_client.state = info->m_info.m_eState;
 372
 373       if( info->m_info.m_eState ==
 374             k_ESteamNetworkingConnectionState_Connected ){
 375          vg_success("  Connected to remote server.. authenticating\n");
 376
 377          /* TODO: We should really wait to see if the server is in auth mode
 378           * first... */
 379          u32 size = sizeof(netmsg_auth) + network_client.app_key_length;
 380          netmsg_auth *auth = alloca(size);
 381          auth->inetmsg_id = k_inetmsg_auth;
 382          auth->ticket_length = network_client.app_key_length;
 383          for( int i=0; i<network_client.app_key_length; i++ )
 384             auth->ticket[i] = network_client.app_symmetric_key[i];
 385
 386          SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 387                hSteamNetworkingSockets, network_client.remote, auth, size,
 388                k_nSteamNetworkingSend_Reliable, NULL );
 389
 390          network_send_username();
 391
 392          for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
 393             network_send_item(i);
 394          }
 395       }
 396       else if( info->m_info.m_eState ==
 397             k_ESteamNetworkingConnectionState_ClosedByPeer ){
 398
 399          if( info->m_info.m_eEndReason ==
 400                k_ESteamNetConnectionEnd_Remote_Max ){
 401             network_client.retries = 40;
 402          }
 403          network_disconnect();
 404       }
 405       else if( info->m_info.m_eState ==
 406             k_ESteamNetworkingConnectionState_ProblemDetectedLocally ){
 407          network_disconnect();
 408       }
 409    }
 410    else{
 411       //vg_warn( "  Recieved signal from unknown connection\n" );
 412    }
 413 }
 414
 415 static void on_persona_state_change( CallbackMsg_t *msg ){
 416    if( network_client.remote ){
 417       PersonaStateChange_t *info = (void *)msg->m_pubParam;
 418
 419       ISteamUser *hSteamUser = SteamAPI_SteamUser();
 420
 421       vg_info( "User: %llu, change: %u\n", info->m_ulSteamID,
 422                                            info->m_nChangeFlags );
 423
 424       if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) ){
 425          if( info->m_nChangeFlags & k_EPersonaChangeName ){
 426             network_send_username();
 427          }
 428       }
 429    }
 430 }
 431
 432 static void network_connect(void){
 433    /* Connect to server if not connected */
 434    SteamNetworkingIPAddr remoteAddr;
 435
 436 #ifdef SR_USE_LOCALHOST
 437    SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost( &remoteAddr, 27402 );
 438 #else
 439    const char *server_lon1 = "46.101.34.155:27402";
 440    SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, server_lon1 );
 441 #endif
 442    const char *server_lan = "192.168.1.32:27402";
 443    SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, server_lan );
 444
 445    char buf[256];
 446    SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr, buf, 256, 1 );
 447    vg_info( "connect to: %s\n", buf );
 448
 449    network_client.remote = SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
 450                   hSteamNetworkingSockets, &remoteAddr, 0, NULL );
 451 }
 452
 453 static void on_inet_scoreboard( SteamNetworkingMessage_t *msg ){
 454    netmsg_scoreboard *sb = msg->m_pData;
 455
 456    u32 base_size = sizeof(netmsg_scoreboard)-
 457       sizeof(struct netmsg_board)*vg_list_size(track_infos),
 458        expected = base_size+sizeof(struct netmsg_board)*sb->board_count;
 459
 460    if( msg->m_cbSize != expected ){
 461       vg_error( "Server scoreboard was corrupted. Size: %u != %u\n",
 462             msg->m_cbSize, expected );
 463    }
 464    else{
 465       if( vg_list_size(track_infos) > sb->board_count )
 466          vg_warn( "Server is out of date, not enough boards recieved\n");
 467       else if( vg_list_size(track_infos) < sb->board_count )
 468          vg_warn( "Client out of date, server sent more boards than we have\n");
 469       else
 470          vg_success( "Recieved new scoreboards from server\n" );
 471
 472       for( int i=0; i < vg_min(sb->board_count,vg_list_size(track_infos)); i++){
 473          scoreboard_client_data.boards[i] = sb->boards[i];
 474          highscores_board_printf( stdout, sb->boards[i].data, 10 );
 475       }
 476    }
 477
 478 #if 0
 479    /* We dont need to stay on the server currently */
 480    SteamAPI_ISteamNetworkingSockets_CloseConnection(
 481          hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
 482 #endif
 483
 484    network_scores_updated = 1;
 485 }
 486
 487 static void poll_remote_connection(void){
 488    SteamNetworkingMessage_t *messages[32];
 489    int len;
 490
 491    for( int i=0; i<10; i++ ){
 492       len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
 493             hSteamNetworkingSockets, network_client.remote,
 494             messages, vg_list_size(messages));
 495
 496       if( len <= 0 )
 497          return;
 498
 499       for( int i=0; i<len; i++ ){
 500          SteamNetworkingMessage_t *msg = messages[i];
 501
 502          if( msg->m_cbSize < sizeof(netmsg_blank) ){
 503             vg_warn( "Discarding message (too small: %d)\n", msg->m_cbSize );
 504             continue;
 505          }
 506
 507          netmsg_blank *tmp = msg->m_pData;
 508
 509          if( (tmp->inetmsg_id >= 200) && (tmp->inetmsg_id < 300) ){
 510             player_remote_rx_200_300( msg );
 511          }
 512          else if( (tmp->inetmsg_id >= 300) && (tmp->inetmsg_id < 400) ){
 513             network_request_rx_300_400( msg );
 514          }
 515
 516          SteamAPI_SteamNetworkingMessage_t_Release( msg );
 517       }
 518    }
 519 }
 520
 521 static void network_update(void){
 522    if( !steam_ready )
 523       return;
 524
 525    ESteamNetworkingConnectionState state = network_client.state;
 526
 527    if( state == k_ESteamNetworkingConnectionState_Connected ){
 528       poll_remote_connection();
 529       f64 frame_delta = vg.time_real - network_client.last_frame;
 530
 531       if( frame_delta > NETWORK_FRAMERATE ){
 532          network_client.last_frame = vg.time_real;
 533          remote_player_send_playerframe();
 534          player__clear_sfx_buffer();
 535       }
 536
 537       remote_player_debug_update();
 538    }
 539    else {
 540       if( (state == k_ESteamNetworkingConnectionState_Connecting) ||
 541           (state == k_ESteamNetworkingConnectionState_FindingRoute) ){
 542          return;
 543       }
 544       else {
 545          f64 waited = vg.time_real - network_client.last_attempt,
 546              min_wait = 1.0;
 547
 548          if( network_client.retries > 5 )
 549             min_wait = 60.0;
 550
 551          if( waited < min_wait )
 552             return;
 553
 554          network_connect();
 555          network_client.retries ++;
 556          network_client.last_attempt = vg.time_real;
 557       }
 558    }
 559 }
 560
 561 static void network_init(void){
 562    vg_console_reg_var( "network_info", &network_client.network_info,
 563                        k_var_dtype_i32, VG_VAR_PERSISTENT );
 564    if( steam_ready ){
 565       u32 alloc_size = sizeof(struct network_request)*NETWORK_MAX_REQUESTS;
 566       network_client.request_buffer =
 567          vg_linear_alloc( vg_mem.rtmemory, alloc_size );
 568       memset( network_client.request_buffer, 0, alloc_size );
 569
 570       vg_pool *pool = &network_client.request_pool;
 571       pool->buffer = network_client.request_buffer;
 572       pool->count = NETWORK_MAX_REQUESTS;
 573       pool->stride = sizeof( struct network_request );
 574       pool->offset = offsetof( struct network_request, poolnode );
 575       vg_pool_init( pool );
 576
 577       steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack,
 578                                on_server_connect_status );
 579       steam_register_callback( k_iPersonaStateChange,
 580                                on_persona_state_change );
 581       request_auth_ticket();
 582    }
 583 }
 584
 585 static void network_end(void){
 586    /* TODO: Send buffered highscores that were not already */
 587    if( (network_client.state == k_ESteamNetworkingConnectionState_Connected) ||
 588        (network_client.state == k_ESteamNetworkingConnectionState_Connecting) )
 589    {
 590       SteamAPI_ISteamNetworkingSockets_CloseConnection(
 591             hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
 592    }
 593 }