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 #include "vg/vg_imgui.h"
  10
  11 static void scores_update(void);
  12
  13 static int packet_minsize( SteamNetworkingMessage_t *msg, u32 size ){
  14    if( msg->m_cbSize < size ) {
  15       vg_error( "Invalid packet size (must be at least %u)\n", size );
  16       return 0;
  17    }
  18    else{
  19       return 1;
  20    }
  21 }
  22
  23 static void on_auth_ticket_recieved( void *result, void *context ){
  24    EncryptedAppTicketResponse_t *response = result;
  25
  26    if( response->m_eResult == k_EResultOK ){
  27       vg_info( "  New app ticket ready\n" );
  28    }
  29    else{
  30       vg_warn( "  Could not request new encrypted app ticket (%u)\n",
  31                   response->m_eResult );
  32    }
  33
  34    if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser,
  35             network_client.app_symmetric_key,
  36             vg_list_size(network_client.app_symmetric_key),
  37             &network_client.app_key_length )){
  38       vg_success( "  Loaded app ticket\n" );
  39    }
  40    else{
  41       vg_error( "  No ticket availible\n" );
  42       network_client.app_key_length = 0;
  43    }
  44 }
  45
  46 static void request_auth_ticket(void){
  47    /*
  48     * TODO Check for one thats cached on the disk and load it.
  49     * This might be OK though because steam seems to cache the result
  50     */
  51
  52    vg_info( "Requesting new authorization ticket\n" );
  53
  54    vg_steam_async_call *call = vg_alloc_async_steam_api_call();
  55    call->userdata = NULL;
  56    call->p_handler = on_auth_ticket_recieved;
  57    call->id =
  58       SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser, NULL, 0 );
  59 }
  60
  61 static void network_send_username(void){
  62    if( !network_connected() )
  63       return;
  64
  65    netmsg_playerusername *update = alloca( sizeof(netmsg_playerusername)+
  66                                            NETWORK_USERNAME_MAX );
  67    update->inetmsg_id = k_inetmsg_playerusername;
  68    update->index = 0xff;
  69
  70    ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
  71    const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends);
  72    u32 chs = str_utf8_collapse( username, update->name, NETWORK_USERNAME_MAX );
  73
  74    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
  75          hSteamNetworkingSockets, network_client.remote,
  76          update, sizeof(netmsg_playerusername)+chs+1,
  77          k_nSteamNetworkingSend_Reliable, NULL );
  78 }
  79
  80 static void network_send_request( netmsg_request *req, vg_msg *body,
  81                                   void (*callback)(
  82                                      netmsg_request *res, vg_msg *body,
  83                                      u64 userdata),
  84                                   u64 userdata ){
  85    u32 len = 0;
  86    if( body ){
  87       len = body->cur.co;
  88       vg_info( "Request scoreboard. Info (%u):\n", body->cur.co );
  89       vg_msg_print( body, len );
  90
  91       if( body->error != k_vg_msg_error_OK ){
  92          vg_error( "Body not OK\n" );
  93          return;
  94       }
  95    }
  96
  97    if( callback ){
  98       req->id = vg_pool_lru( &network_client.request_pool );
  99       if( req->id ){
 100          vg_pool_watch( &network_client.request_pool, req->id );
 101          struct network_request *pn =
 102             vg_pool_item( &network_client.request_pool, req->id );
 103          pn->callback = callback;
 104          pn->sendtime = vg.time_real;
 105          pn->userdata = userdata;
 106       }
 107       else{
 108          vg_error( "Unable to send request. Pool is full.\n" );
 109          return;
 110       }
 111    }
 112    else
 113       req->id = 0;
 114
 115    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 116          hSteamNetworkingSockets, network_client.remote,
 117          req, sizeof(netmsg_request)+len,
 118          k_nSteamNetworkingSend_Reliable, NULL );
 119 }
 120
 121 static void network_scoreboard_callback( netmsg_request *res, vg_msg *body,
 122                                          u64 userdata ){
 123    world_instance *world = world_current_instance();
 124
 125    world_routes_recv_scoreboard( world, body, userdata, res->status );
 126    if( userdata == world_sfd.active_route_board )
 127       world_sfd_compile_active_scores();
 128 }
 129
 130
 131
 132 /* mod_uid: world mod uid,
 133  * route_uid: run name (just a string)
 134  * week:
 135  *   0   ALL TIME
 136  *   1   CURRENT WEEK
 137  *   2   ALL TIME + CURRENT WEEK
 138  *   .
 139  *   10+ specific week index
 140  */
 141 static void network_request_scoreboard( const char *mod_uid,
 142                                         const char *route_uid,
 143                                         u32 week, u64 userdata ){
 144    if( !network_connected() )
 145       return;
 146
 147    netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
 148    req->inetmsg_id = k_inetmsg_request;
 149
 150    vg_msg data;
 151    vg_msg_init( &data, req->q, 512 );
 152    vg_msg_wkvstr( &data, "endpoint", "scoreboard" );
 153    vg_msg_wkvstr( &data, "mod", mod_uid );
 154    vg_msg_wkvstr( &data, "route", route_uid );
 155    vg_msg_wkvu32( &data, "week", week );
 156    network_send_request( req, &data, network_scoreboard_callback, userdata );
 157 }
 158
 159 static void network_publish_callback( netmsg_request *res, vg_msg *body,
 160                                       u64 userdata ){
 161    if( res->status != k_request_status_ok ){
 162       vg_error( "Publish laptime, server error #%d\n", (i32)res->status );
 163    }
 164 }
 165
 166 static void network_publish_laptime( const char *mod_uid,
 167                                      const char *route_uid, f64 lap_time ){
 168    if( !network_connected() )
 169       return;
 170
 171    i32 time_centiseconds = lap_time * 100.0;
 172
 173    netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
 174    req->inetmsg_id = k_inetmsg_request;
 175
 176    vg_msg data;
 177    vg_msg_init( &data, req->q, 512 );
 178    vg_msg_wkvstr( &data, "endpoint", "setlap" );
 179    vg_msg_wkvstr( &data, "mod", mod_uid );
 180    vg_msg_wkvstr( &data, "route", route_uid );
 181    vg_msg_wkvi32( &data, "time", time_centiseconds );
 182    network_send_request( req, &data, network_publish_callback, 0 );
 183 }
 184
 185 static void network_request_rx_300_400( SteamNetworkingMessage_t *msg ){
 186    netmsg_blank *tmp = msg->m_pData;
 187
 188    if( tmp->inetmsg_id == k_inetmsg_request ){
 189
 190    }
 191    else if( tmp->inetmsg_id == k_inetmsg_response ){
 192       netmsg_request *res = (netmsg_request *)msg->m_pData;
 193
 194       vg_msg *body = NULL;
 195
 196       vg_msg data;
 197       if( res->status == k_request_status_ok ){
 198          vg_msg_init( &data, res->q, msg->m_cbSize - sizeof(netmsg_request) );
 199          vg_success( "Response to #%d:\n", (i32)res->id );
 200          vg_msg_print( &data, data.max );
 201          body = &data;
 202       }
 203       else {
 204          vg_warn( "Server response to #%d: %d\n", (i32)res->id, res->status );
 205       }
 206
 207       if( res->id ){
 208          struct network_request *pn =
 209             vg_pool_item( &network_client.request_pool, res->id );
 210          pn->callback( res, body, pn->userdata );
 211          vg_pool_unwatch( &network_client.request_pool, res->id );
 212       }
 213    }
 214 }
 215
 216 static void network_send_item( enum netmsg_playeritem_type type ){
 217    if( !network_connected() )
 218       return;
 219
 220    netmsg_playeritem *item =
 221       alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
 222    item->inetmsg_id = k_inetmsg_playeritem;
 223    item->type_index = type;
 224    item->client = 0;
 225
 226    if( (type == k_netmsg_playeritem_world0) ||
 227        (type == k_netmsg_playeritem_world1) ){
 228
 229       enum world_purpose purpose = type - k_netmsg_playeritem_world0;
 230       addon_reg *reg = world_static.instance_addons[ purpose ];
 231
 232       if( reg )
 233          addon_alias_uid( &reg->alias, item->uid );
 234       else
 235          item->uid[0] = '\0';
 236    }
 237    else{
 238       u16 view_id = 0;
 239       enum addon_type addon_type = k_addon_type_none;
 240       if( type == k_netmsg_playeritem_board ){
 241          view_id = localplayer.board_view_slot;
 242          addon_type = k_addon_type_board;
 243       }
 244       else if( type == k_netmsg_playeritem_player ){
 245          view_id = localplayer.playermodel_view_slot;
 246          addon_type = k_addon_type_player;
 247       }
 248       else
 249          assert(0);
 250
 251       struct addon_cache *cache = &addon_system.cache[addon_type];
 252       vg_pool *pool = &cache->pool;
 253
 254       SDL_AtomicLock( &addon_system.sl_cache_using_resources );
 255       addon_cache_entry *entry = vg_pool_item( pool, view_id );
 256       addon_alias_uid( &entry->reg_ptr->alias, item->uid );
 257       SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
 258    }
 259
 260    vg_info( "send equip: [%u] %s\n",
 261             item->type_index, item->uid );
 262    u32 chs = strlen(item->uid);
 263
 264    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 265          hSteamNetworkingSockets, network_client.remote,
 266          item, sizeof(netmsg_playeritem)+chs+1,
 267          k_nSteamNetworkingSend_Reliable, NULL );
 268 }
 269
 270 static void network_disconnect(void){
 271    SteamAPI_ISteamNetworkingSockets_CloseConnection(
 272          hSteamNetworkingSockets, network_client.remote, 0, NULL, 0 );
 273    network_client.remote = 0;
 274    network_client.state = k_ESteamNetworkingConnectionState_None;
 275
 276    for( int i=0; i<vg_list_size(netplayers.list); i++ ){
 277       netplayers.list[i].active = 0;
 278    }
 279 }
 280
 281 static void network_status_string( vg_str *str, u32 *colour ){
 282    if( steam_ready ){
 283       if( network_client.user_intent == k_server_intent_offline ){
 284          vg_strcat( str, "Offline" );
 285       }
 286       else {
 287          ESteamNetworkingConnectionState state = network_client.state;
 288
 289          if( state == k_ESteamNetworkingConnectionState_None )
 290             vg_strcat( str, "No Connection" );
 291          else if( state == k_ESteamNetworkingConnectionState_Connecting ){
 292             vg_strcat( str, "Connecting to:\nskaterift.com" );
 293
 294             if( network_client.retries ){
 295                vg_strcat( str, "\n(" );
 296                vg_strcati32( str, network_client.retries );
 297                vg_strcat( str, " retries)" );
 298             }
 299          }
 300          else if( state == k_ESteamNetworkingConnectionState_Connected ){
 301             vg_strcat( str, "Connected to:\nskaterift.com" );
 302             *colour = 0xff00a020;
 303          }
 304          else if( state == k_ESteamNetworkingConnectionState_ClosedByPeer )
 305             vg_strcat( str, "Connection Closed" );
 306          else if( state == k_ESteamNetworkingConnectionState_FindingRoute )
 307             vg_strcat( str, "Finding Route" );
 308          else if( state ==
 309                k_ESteamNetworkingConnectionState_ProblemDetectedLocally){
 310             vg_strcat( str, "Problem Detected\nLocally" );
 311             *colour = 0xff0000a0;
 312          }
 313          else
 314             vg_strcat( str, "???" );
 315       }
 316    }
 317    else {
 318       vg_strcat( str, "Steam Offline" );
 319       *colour = 0xff0000a0;
 320    }
 321 }
 322
 323 static void render_server_status_gui(void){
 324    render_fb_bind( gpipeline.fb_workshop_preview, 0 );
 325
 326    /* HACK */
 327         vg_ui.cur_vert = 0;
 328         vg_ui.cur_indice = 0;
 329    vg_ui.vert_start = 0;
 330    vg_ui.indice_start = 0;
 331
 332    ui_rect r = { 0, 0, 128, 48 };
 333
 334    char buf[128];
 335    vg_str str;
 336    vg_strnull( &str, buf, sizeof(buf) );
 337
 338    u32 bg = 0xff000000;
 339    network_status_string( &str, &bg );
 340
 341    ui_fill( r, bg );
 342    ui_text( r, buf, 1, k_ui_align_center, 0 );
 343    ui_flush( k_ui_shader_colour, 128, 48 );
 344
 345    skaterift.rt_textures[ k_skaterift_rt_server_status ] =
 346       gpipeline.fb_workshop_preview->attachments[0].id;
 347 }
 348
 349 static void on_server_connect_status( CallbackMsg_t *msg ){
 350    SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
 351    vg_info( "  Connection status changed for %lu\n", info->m_hConn );
 352    vg_info( "  %s -> %s\n",
 353          string_ESteamNetworkingConnectionState(info->m_eOldState),
 354          string_ESteamNetworkingConnectionState(info->m_info.m_eState) );
 355
 356    if( info->m_hConn == network_client.remote ){
 357       network_client.state = info->m_info.m_eState;
 358
 359       if( info->m_info.m_eState ==
 360             k_ESteamNetworkingConnectionState_Connected ){
 361          vg_success("  Connected to remote server.. authenticating\n");
 362
 363          /* send version info to server */
 364          netmsg_version version;
 365          version.inetmsg_id = k_inetmsg_version;
 366          version.version = NETWORK_SKATERIFT_VERSION;
 367          SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 368                hSteamNetworkingSockets, network_client.remote, &version,
 369                sizeof(netmsg_version), k_nSteamNetworkingSend_Reliable, NULL );
 370
 371          /* TODO: We should really wait to see if the server is in auth mode
 372           * first... */
 373          u32 size = sizeof(netmsg_auth) + network_client.app_key_length;
 374          netmsg_auth *auth = alloca(size);
 375          auth->inetmsg_id = k_inetmsg_auth;
 376          auth->ticket_length = network_client.app_key_length;
 377          for( int i=0; i<network_client.app_key_length; i++ )
 378             auth->ticket[i] = network_client.app_symmetric_key[i];
 379
 380          SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 381                hSteamNetworkingSockets, network_client.remote, auth, size,
 382                k_nSteamNetworkingSend_Reliable, NULL );
 383       }
 384       else if( info->m_info.m_eState ==
 385             k_ESteamNetworkingConnectionState_ClosedByPeer ){
 386
 387          if( info->m_info.m_eEndReason ==
 388                k_ESteamNetConnectionEnd_Misc_InternalError ){
 389             network_client.retries = 40;
 390          }
 391          network_disconnect();
 392       }
 393       else if( info->m_info.m_eState ==
 394             k_ESteamNetworkingConnectionState_ProblemDetectedLocally ){
 395          network_disconnect();
 396       }
 397    }
 398    else{
 399       //vg_warn( "  Recieved signal from unknown connection\n" );
 400    }
 401
 402    render_server_status_gui();
 403 }
 404
 405 static void on_persona_state_change( CallbackMsg_t *msg ){
 406    if( !network_connected() )
 407       return;
 408
 409    PersonaStateChange_t *info = (void *)msg->m_pubParam;
 410    ISteamUser *hSteamUser = SteamAPI_SteamUser();
 411
 412    vg_info( "User: %llu, change: %u\n", info->m_ulSteamID,
 413                                         info->m_nChangeFlags );
 414
 415    if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) ){
 416       if( info->m_nChangeFlags & k_EPersonaChangeName ){
 417          network_send_username();
 418       }
 419    }
 420
 421    if( info->m_nChangeFlags & k_EPersonaChangeRelationshipChanged ){
 422       for( u32 i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
 423          struct network_player *rp = &netplayers.list[i];
 424          if( rp->steamid == info->m_ulSteamID ){
 425             player_remote_update_friendflags( rp );
 426          }
 427       }
 428    }
 429 }
 430
 431 static void network_connect(void){
 432    char ip_buf[128];
 433    vg_str str;
 434    vg_strnull( &str, ip_buf, sizeof(ip_buf) );
 435    vg_strcat( &str, network_client.server_adress );
 436    vg_strcat( &str, ":" );
 437    vg_strcati32( &str, NETWORK_PORT );
 438
 439    if( !vg_strgood(&str) ) return;
 440
 441    /* Connect to server if not connected */
 442    SteamNetworkingIPAddr remoteAddr;
 443    SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, str.buffer );
 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 network_sign_on_complete(void){
 454    vg_success( "Sign on completed\n" );
 455
 456    /* send our init info */
 457    network_send_username();
 458    for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
 459       network_send_item(i);
 460    }
 461 }
 462
 463 static void poll_remote_connection(void){
 464    SteamNetworkingMessage_t *messages[32];
 465    int len;
 466
 467    for( int i=0; i<10; i++ ){
 468       len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
 469             hSteamNetworkingSockets, network_client.remote,
 470             messages, vg_list_size(messages));
 471
 472       if( len <= 0 )
 473          return;
 474
 475       for( int i=0; i<len; i++ ){
 476          SteamNetworkingMessage_t *msg = messages[i];
 477
 478          if( msg->m_cbSize < sizeof(netmsg_blank) ){
 479             vg_warn( "Discarding message (too small: %d)\n", msg->m_cbSize );
 480             continue;
 481          }
 482
 483          netmsg_blank *tmp = msg->m_pData;
 484
 485          if( (tmp->inetmsg_id >= 200) && (tmp->inetmsg_id < 300) ){
 486             player_remote_rx_200_300( msg );
 487          }
 488          else if( (tmp->inetmsg_id >= 300) && (tmp->inetmsg_id < 400) ){
 489             network_request_rx_300_400( msg );
 490          }
 491          else {
 492             if( tmp->inetmsg_id == k_inetmsg_version ){
 493                netmsg_version *version = msg->m_pData;
 494                if( version->version != NETWORK_SKATERIFT_VERSION ){
 495                   network_disconnect();
 496                   /* we dont want to connect to this server ever */
 497                   network_client.retries = 999;
 498                   network_client.last_attempt = 999999999.9;
 499                   vg_error( "version mismatch with server\n" );
 500                }
 501                else {
 502                   network_client.remote_version = version->version;
 503                   network_sign_on_complete();
 504                }
 505             }
 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( network_client.user_intent == k_server_intent_offline ){
 520       if( state != k_ESteamNetworkingConnectionState_None )
 521          network_disconnect();
 522
 523       return;
 524    }
 525
 526    if( state == k_ESteamNetworkingConnectionState_Connected ){
 527       poll_remote_connection();
 528       f64 frame_delta = vg.time_real - network_client.last_frame;
 529
 530       if( frame_delta > NETWORK_FRAMERATE ){
 531          network_client.last_frame = vg.time_real;
 532          remote_player_send_playerframe();
 533          player__clear_sfx_buffer();
 534       }
 535
 536       remote_player_debug_update();
 537    }
 538    else {
 539       if( (state == k_ESteamNetworkingConnectionState_Connecting) ||
 540           (state == k_ESteamNetworkingConnectionState_FindingRoute) ){
 541          return;
 542       }
 543       else {
 544          f64 waited = vg.time_real - network_client.last_attempt,
 545              min_wait = 1.0;
 546
 547          if( network_client.retries > 5 )
 548             min_wait = 60.0;
 549
 550          if( waited < min_wait )
 551             return;
 552
 553          network_connect();
 554          network_client.retries ++;
 555          network_client.last_attempt = vg.time_real;
 556       }
 557    }
 558 }
 559
 560 static void chat_send_message( const char *message ){
 561    if( !network_connected() ){
 562       return;
 563    }
 564
 565    netmsg_chat *chat = alloca( sizeof(netmsg_chat) + NETWORK_MAX_CHAT );
 566    chat->inetmsg_id = k_inetmsg_chat;
 567    chat->client = 0;
 568
 569    u32 l = vg_strncpy( message, chat->msg, NETWORK_MAX_CHAT,
 570                        k_strncpy_always_add_null );
 571
 572    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 573          hSteamNetworkingSockets, network_client.remote,
 574          chat, sizeof(netmsg_chat)+l+1,
 575          k_nSteamNetworkingSend_Reliable, NULL );
 576 }
 577
 578 static int cmd_network_send_message( int argc, const char *argv[] ){
 579    char buf[ NETWORK_MAX_CHAT ];
 580    vg_str str;
 581    vg_strnull( &str, buf, NETWORK_MAX_CHAT );
 582
 583    for( int i=0; i<argc; i ++ ){
 584       vg_strcat( &str, argv[i] );
 585
 586       if( i < argc-1 )
 587          vg_strcatch( &str, ' ' );
 588    }
 589
 590    chat_send_message( buf );
 591    return 0;
 592 }
 593
 594 static void network_init(void){
 595    vg_console_reg_var( "network_info", &network_client.network_info,
 596                        k_var_dtype_i32, VG_VAR_PERSISTENT );
 597    if( steam_ready ){
 598       u32 alloc_size = sizeof(struct network_request)*NETWORK_MAX_REQUESTS;
 599       network_client.request_buffer =
 600          vg_linear_alloc( vg_mem.rtmemory, alloc_size );
 601       memset( network_client.request_buffer, 0, alloc_size );
 602
 603       vg_pool *pool = &network_client.request_pool;
 604       pool->buffer = network_client.request_buffer;
 605       pool->count = NETWORK_MAX_REQUESTS;
 606       pool->stride = sizeof( struct network_request );
 607       pool->offset = offsetof( struct network_request, poolnode );
 608       vg_pool_init( pool );
 609
 610       steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack,
 611                                on_server_connect_status );
 612       steam_register_callback( k_iPersonaStateChange,
 613                                on_persona_state_change );
 614       request_auth_ticket();
 615
 616       vg_console_reg_cmd( "say", cmd_network_send_message, NULL );
 617    }
 618 }
 619
 620 static void network_end(void){
 621    /* TODO: Send buffered highscores that were not already */
 622    if( (network_client.state == k_ESteamNetworkingConnectionState_Connected) ||
 623        (network_client.state == k_ESteamNetworkingConnectionState_Connecting) )
 624    {
 625       SteamAPI_ISteamNetworkingSockets_CloseConnection(
 626             hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
 627    }
 628 }