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