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 static void network_send_username(void){
  61    netmsg_playerusername *update = alloca( sizeof(netmsg_playerusername)+
  62                                            NETWORK_USERNAME_MAX );
  63    update->inetmsg_id = k_inetmsg_playerusername;
  64    update->index = 0xff;
  65
  66    ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
  67    const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends);
  68    u32 chs = str_utf8_collapse( username, update->name, NETWORK_USERNAME_MAX );
  69
  70    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
  71          hSteamNetworkingSockets, network_client.remote,
  72          update, sizeof(netmsg_playerusername)+chs+1,
  73          k_nSteamNetworkingSend_Reliable, NULL );
  74 }
  75
  76 static void network_send_request( netmsg_request *req, vg_msg *body,
  77                                   void (*callback)(
  78                                      netmsg_request *res, vg_msg *body,
  79                                      u64 userdata),
  80                                   u64 userdata ){
  81    u32 len = 0;
  82    if( body ){
  83       len = body->cur.co;
  84       vg_info( "Request scoreboard. Info (%u):\n", body->cur.co );
  85       vg_msg_print( body, len );
  86
  87       if( body->error != k_vg_msg_error_OK ){
  88          vg_error( "Body not OK\n" );
  89          return;
  90       }
  91    }
  92
  93    if( callback ){
  94       req->id = vg_pool_lru( &network_client.request_pool );
  95       if( req->id ){
  96          vg_pool_watch( &network_client.request_pool, req->id );
  97          struct network_request *pn =
  98             vg_pool_item( &network_client.request_pool, req->id );
  99          pn->callback = callback;
 100          pn->sendtime = vg.time_real;
 101          pn->userdata = userdata;
 102       }
 103       else{
 104          vg_error( "Unable to send request. Pool is full.\n" );
 105          return;
 106       }
 107    }
 108    else
 109       req->id = 0;
 110
 111    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 112          hSteamNetworkingSockets, network_client.remote,
 113          req, sizeof(netmsg_request)+len,
 114          k_nSteamNetworkingSend_Reliable, NULL );
 115 }
 116
 117 static void network_scoreboard_callback( netmsg_request *res, vg_msg *body,
 118                                          u64 userdata ){
 119    world_instance *world = world_current_instance();
 120
 121    world_routes_recv_scoreboard( world, body, userdata, res->status );
 122    if( userdata == world_sfd.active_route_board )
 123       world_sfd_compile_active_scores();
 124 }
 125
 126
 127
 128 /* mod_uid: world mod uid,
 129  * route_uid: run name (just a string)
 130  * week:
 131  *   0   ALL TIME
 132  *   1   CURRENT WEEK
 133  *   2   ALL TIME + CURRENT WEEK
 134  *   .
 135  *   10+ specific week index
 136  */
 137 static void network_request_scoreboard( const char *mod_uid,
 138                                         const char *route_uid,
 139                                         u32 week, u64 userdata ){
 140    if( !network_client.remote )
 141       return;
 142
 143    netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
 144    req->inetmsg_id = k_inetmsg_request;
 145
 146    vg_msg data;
 147    vg_msg_init( &data, req->q, 512 );
 148    vg_msg_wkvstr( &data, "endpoint", "scoreboard" );
 149    vg_msg_wkvstr( &data, "mod", mod_uid );
 150    vg_msg_wkvstr( &data, "route", route_uid );
 151    vg_msg_wkvu32( &data, "week", week );
 152    network_send_request( req, &data, network_scoreboard_callback, userdata );
 153 }
 154
 155 static void network_publish_callback( netmsg_request *res, vg_msg *body,
 156                                       u64 userdata ){
 157    if( res->status != k_request_status_ok ){
 158       vg_error( "Publish laptime, server error #%d\n", (i32)res->status );
 159    }
 160 }
 161
 162 static void network_publish_laptime( const char *mod_uid,
 163                                      const char *route_uid, f64 lap_time ){
 164    if( !network_client.remote )
 165       return;
 166
 167    i32 time_centiseconds = lap_time * 100.0;
 168
 169    netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
 170    req->inetmsg_id = k_inetmsg_request;
 171
 172    vg_msg data;
 173    vg_msg_init( &data, req->q, 512 );
 174    vg_msg_wkvstr( &data, "endpoint", "setlap" );
 175    vg_msg_wkvstr( &data, "mod", mod_uid );
 176    vg_msg_wkvstr( &data, "route", route_uid );
 177    vg_msg_wkvi32( &data, "time", time_centiseconds );
 178    network_send_request( req, &data, network_publish_callback, 0 );
 179 }
 180
 181 static void network_request_rx_300_400( SteamNetworkingMessage_t *msg ){
 182    netmsg_blank *tmp = msg->m_pData;
 183
 184    if( tmp->inetmsg_id == k_inetmsg_request ){
 185
 186    }
 187    else if( tmp->inetmsg_id == k_inetmsg_response ){
 188       netmsg_request *res = (netmsg_request *)msg->m_pData;
 189
 190       vg_msg *body = NULL;
 191
 192       vg_msg data;
 193       if( res->status == k_request_status_ok ){
 194          vg_msg_init( &data, res->q, msg->m_cbSize - sizeof(netmsg_request) );
 195          vg_success( "Response to #%d:\n", (i32)res->id );
 196          vg_msg_print( &data, data.max );
 197          body = &data;
 198       }
 199       else {
 200          vg_warn( "Server response to #%d: %d\n", (i32)res->id, res->status );
 201       }
 202
 203       if( res->id ){
 204          struct network_request *pn =
 205             vg_pool_item( &network_client.request_pool, res->id );
 206          pn->callback( res, body, pn->userdata );
 207          vg_pool_unwatch( &network_client.request_pool, res->id );
 208       }
 209    }
 210 }
 211
 212 static void network_send_item( enum netmsg_playeritem_type type ){
 213    if( !network_client.remote )
 214       return;
 215
 216    netmsg_playeritem *item =
 217       alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
 218    item->inetmsg_id = k_inetmsg_playeritem;
 219    item->type_index = type;
 220    item->client = 0;
 221
 222    if( (type == k_netmsg_playeritem_world0) ||
 223        (type == k_netmsg_playeritem_world1) ){
 224
 225       enum world_purpose purpose = type - k_netmsg_playeritem_world0;
 226       addon_reg *reg = world_static.instance_addons[ purpose ];
 227
 228       if( reg )
 229          addon_alias_uid( &reg->alias, item->uid );
 230       else
 231          item->uid[0] = '\0';
 232    }
 233    else{
 234       u16 view_id = 0;
 235       enum addon_type addon_type = k_addon_type_none;
 236       if( type == k_netmsg_playeritem_board ){
 237          view_id = localplayer.board_view_slot;
 238          addon_type = k_addon_type_board;
 239       }
 240       else if( type == k_netmsg_playeritem_player ){
 241          view_id = localplayer.playermodel_view_slot;
 242          addon_type = k_addon_type_player;
 243       }
 244       else
 245          assert(0);
 246
 247       struct addon_cache *cache = &addon_system.cache[addon_type];
 248       vg_pool *pool = &cache->pool;
 249
 250       SDL_AtomicLock( &addon_system.sl_cache_using_resources );
 251       addon_cache_entry *entry = vg_pool_item( pool, view_id );
 252       addon_alias_uid( &entry->reg_ptr->alias, item->uid );
 253       SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
 254    }
 255
 256    vg_info( "send equip: [%u] %s\n",
 257             item->type_index, item->uid );
 258    u32 chs = strlen(item->uid);
 259
 260    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 261          hSteamNetworkingSockets, network_client.remote,
 262          item, sizeof(netmsg_playeritem)+chs+1,
 263          k_nSteamNetworkingSend_Reliable, NULL );
 264 }
 265
 266 static void network_disconnect(void){
 267    SteamAPI_ISteamNetworkingSockets_CloseConnection(
 268          hSteamNetworkingSockets, network_client.remote, 0, NULL, 0 );
 269    network_client.remote = 0;
 270
 271    for( int i=0; i<vg_list_size(netplayers.list); i++ ){
 272       netplayers.list[i].active = 0;
 273    }
 274 }
 275
 276 static void on_server_connect_status( CallbackMsg_t *msg ){
 277    SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
 278    vg_info( "  Connection status changed for %lu\n", info->m_hConn );
 279    vg_info( "  %s -> %s\n",
 280          string_ESteamNetworkingConnectionState(info->m_eOldState),
 281          string_ESteamNetworkingConnectionState(info->m_info.m_eState) );
 282
 283    if( info->m_hConn == network_client.remote ){
 284       network_client.state = info->m_info.m_eState;
 285
 286       if( info->m_info.m_eState ==
 287             k_ESteamNetworkingConnectionState_Connected ){
 288          vg_success("  Connected to remote server.. authenticating\n");
 289
 290          /* TODO: We should really wait to see if the server is in auth mode
 291           * first... */
 292          u32 size = sizeof(netmsg_auth) + network_client.app_key_length;
 293          netmsg_auth *auth = alloca(size);
 294          auth->inetmsg_id = k_inetmsg_auth;
 295          auth->ticket_length = network_client.app_key_length;
 296          for( int i=0; i<network_client.app_key_length; i++ )
 297             auth->ticket[i] = network_client.app_symmetric_key[i];
 298
 299          SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 300                hSteamNetworkingSockets, network_client.remote, auth, size,
 301                k_nSteamNetworkingSend_Reliable, NULL );
 302
 303          network_send_username();
 304
 305          for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
 306             network_send_item(i);
 307          }
 308       }
 309       else if( info->m_info.m_eState ==
 310             k_ESteamNetworkingConnectionState_ClosedByPeer ){
 311
 312          if( info->m_info.m_eEndReason ==
 313                k_ESteamNetConnectionEnd_Remote_Max ){
 314             network_client.retries = 40;
 315          }
 316          network_disconnect();
 317       }
 318       else if( info->m_info.m_eState ==
 319             k_ESteamNetworkingConnectionState_ProblemDetectedLocally ){
 320          network_disconnect();
 321       }
 322    }
 323    else{
 324       //vg_warn( "  Recieved signal from unknown connection\n" );
 325    }
 326 }
 327
 328 static void on_persona_state_change( CallbackMsg_t *msg ){
 329    if( network_client.remote ){
 330       PersonaStateChange_t *info = (void *)msg->m_pubParam;
 331
 332       ISteamUser *hSteamUser = SteamAPI_SteamUser();
 333
 334       vg_info( "User: %llu, change: %u\n", info->m_ulSteamID,
 335                                            info->m_nChangeFlags );
 336
 337       if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) ){
 338          if( info->m_nChangeFlags & k_EPersonaChangeName ){
 339             network_send_username();
 340          }
 341       }
 342    }
 343 }
 344
 345 static void network_connect(void){
 346    /* Connect to server if not connected */
 347    SteamNetworkingIPAddr remoteAddr;
 348    SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr,
 349                                                network_client.server_adress );
 350
 351    char buf[256];
 352    SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr, buf, 256, 1 );
 353    vg_info( "connect to: %s\n", buf );
 354
 355    network_client.remote = SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
 356                   hSteamNetworkingSockets, &remoteAddr, 0, NULL );
 357 }
 358
 359 static void poll_remote_connection(void){
 360    SteamNetworkingMessage_t *messages[32];
 361    int len;
 362
 363    for( int i=0; i<10; i++ ){
 364       len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
 365             hSteamNetworkingSockets, network_client.remote,
 366             messages, vg_list_size(messages));
 367
 368       if( len <= 0 )
 369          return;
 370
 371       for( int i=0; i<len; i++ ){
 372          SteamNetworkingMessage_t *msg = messages[i];
 373
 374          if( msg->m_cbSize < sizeof(netmsg_blank) ){
 375             vg_warn( "Discarding message (too small: %d)\n", msg->m_cbSize );
 376             continue;
 377          }
 378
 379          netmsg_blank *tmp = msg->m_pData;
 380
 381          if( (tmp->inetmsg_id >= 200) && (tmp->inetmsg_id < 300) ){
 382             player_remote_rx_200_300( msg );
 383          }
 384          else if( (tmp->inetmsg_id >= 300) && (tmp->inetmsg_id < 400) ){
 385             network_request_rx_300_400( msg );
 386          }
 387
 388          SteamAPI_SteamNetworkingMessage_t_Release( msg );
 389       }
 390    }
 391 }
 392
 393 static void network_update(void){
 394    if( !steam_ready )
 395       return;
 396
 397    ESteamNetworkingConnectionState state = network_client.state;
 398
 399    if( state == k_ESteamNetworkingConnectionState_Connected ){
 400       poll_remote_connection();
 401       f64 frame_delta = vg.time_real - network_client.last_frame;
 402
 403       if( frame_delta > NETWORK_FRAMERATE ){
 404          network_client.last_frame = vg.time_real;
 405          remote_player_send_playerframe();
 406          player__clear_sfx_buffer();
 407       }
 408
 409       remote_player_debug_update();
 410    }
 411    else {
 412       if( (state == k_ESteamNetworkingConnectionState_Connecting) ||
 413           (state == k_ESteamNetworkingConnectionState_FindingRoute) ){
 414          return;
 415       }
 416       else {
 417          f64 waited = vg.time_real - network_client.last_attempt,
 418              min_wait = 1.0;
 419
 420          if( network_client.retries > 5 )
 421             min_wait = 60.0;
 422
 423          if( waited < min_wait )
 424             return;
 425
 426          network_connect();
 427          network_client.retries ++;
 428          network_client.last_attempt = vg.time_real;
 429       }
 430    }
 431 }
 432
 433 static void network_init(void){
 434    vg_console_reg_var( "network_info", &network_client.network_info,
 435                        k_var_dtype_i32, VG_VAR_PERSISTENT );
 436    if( steam_ready ){
 437       u32 alloc_size = sizeof(struct network_request)*NETWORK_MAX_REQUESTS;
 438       network_client.request_buffer =
 439          vg_linear_alloc( vg_mem.rtmemory, alloc_size );
 440       memset( network_client.request_buffer, 0, alloc_size );
 441
 442       vg_pool *pool = &network_client.request_pool;
 443       pool->buffer = network_client.request_buffer;
 444       pool->count = NETWORK_MAX_REQUESTS;
 445       pool->stride = sizeof( struct network_request );
 446       pool->offset = offsetof( struct network_request, poolnode );
 447       vg_pool_init( pool );
 448
 449       steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack,
 450                                on_server_connect_status );
 451       steam_register_callback( k_iPersonaStateChange,
 452                                on_persona_state_change );
 453       request_auth_ticket();
 454    }
 455 }
 456
 457 static void network_end(void){
 458    /* TODO: Send buffered highscores that were not already */
 459    if( (network_client.state == k_ESteamNetworkingConnectionState_Connected) ||
 460        (network_client.state == k_ESteamNetworkingConnectionState_Connecting) )
 461    {
 462       SteamAPI_ISteamNetworkingSockets_CloseConnection(
 463             hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
 464    }
 465 }