network.c

   1 #include "skaterift.h"
   2 #include "vg/vg_steam.h"
   3 #include "vg/vg_steam_networking.h"
   4 #include "vg/vg_steam_auth.h"
   5 #include "vg/vg_steam_friends.h"
   6 #include "player.h"
   7 #include "network.h"
   8 #include "network_msg.h"
   9 #include "network_common.h"
  10 #include "player_remote.h"
  11 #include "world.h"
  12 #include "world_sfd.h"
  13 #include "world_routes.h"
  14 #include "vg/vg_ui/imgui.h"
  15 #include "gui.h"
  16 #include "ent_region.h"
  17 #include "vg/vg_loader.h"
  18
  19 #ifdef _WIN32
  20  #include <winsock2.h>
  21  #include <ws2tcpip.h>
  22 #else
  23  #include <sys/socket.h>
  24  #include <sys/types.h>
  25  #include <netdb.h>
  26 #endif
  27
  28 struct network_client network_client =
  29 {
  30    .auth_mode = eServerModeAuthentication,
  31    .state = k_ESteamNetworkingConnectionState_None,
  32    .last_intent_change = -99999.9
  33 };
  34
  35 static void scores_update(void);
  36
  37 int packet_minsize( SteamNetworkingMessage_t *msg, u32 size ){
  38    if( msg->m_cbSize < size ) {
  39       vg_error( "Invalid packet size (must be at least %u)\n", size );
  40       return 0;
  41    }
  42    else{
  43       return 1;
  44    }
  45 }
  46
  47 static void on_auth_ticket_recieved( void *result, void *context ){
  48    EncryptedAppTicketResponse_t *response = result;
  49
  50    if( response->m_eResult == k_EResultOK ){
  51       vg_info( "  New app ticket ready\n" );
  52    }
  53    else{
  54       vg_warn( "  Could not request new encrypted app ticket (%u)\n",
  55                   response->m_eResult );
  56    }
  57
  58    if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser,
  59             network_client.app_symmetric_key,
  60             vg_list_size(network_client.app_symmetric_key),
  61             &network_client.app_key_length )){
  62       vg_success( "  Loaded app ticket\n" );
  63    }
  64    else{
  65       vg_error( "  No ticket availible\n" );
  66       network_client.app_key_length = 0;
  67    }
  68 }
  69
  70 static void request_auth_ticket(void){
  71    /*
  72     * TODO Check for one thats cached on the disk and load it.
  73     * This might be OK though because steam seems to cache the result
  74     */
  75
  76    vg_info( "Requesting new authorization ticket\n" );
  77
  78    vg_steam_async_call *call = vg_alloc_async_steam_api_call();
  79    call->userdata = NULL;
  80    call->p_handler = on_auth_ticket_recieved;
  81    call->id =
  82       SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser, NULL, 0 );
  83 }
  84
  85 static void network_send_username(void){
  86    if( !network_connected() )
  87       return;
  88
  89    netmsg_playerusername *update = alloca( sizeof(netmsg_playerusername)+
  90                                            NETWORK_USERNAME_MAX );
  91    update->inetmsg_id = k_inetmsg_playerusername;
  92    update->index = 0xff;
  93
  94    ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
  95    const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends);
  96    u32 chs = str_utf8_collapse( username, update->name, NETWORK_USERNAME_MAX );
  97
  98    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
  99          hSteamNetworkingSockets, network_client.remote,
 100          update, sizeof(netmsg_playerusername)+chs+1,
 101          k_nSteamNetworkingSend_Reliable, NULL );
 102 }
 103
 104 void network_send_region(void)
 105 {
 106    if( !network_connected() )
 107       return;
 108
 109    netmsg_region *region = alloca( sizeof(netmsg_region) + NETWORK_REGION_MAX );
 110
 111    region->inetmsg_id = k_inetmsg_region;
 112    region->client = 0;
 113    region->flags = global_ent_region.flags;
 114
 115    u32 l = vg_strncpy( global_ent_region.location, region->loc,
 116                        NETWORK_REGION_MAX, k_strncpy_always_add_null );
 117
 118    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 119          hSteamNetworkingSockets, network_client.remote,
 120          region, sizeof(netmsg_region)+l+1,
 121          k_nSteamNetworkingSend_Reliable, NULL );
 122 }
 123
 124 static void network_send_request( netmsg_request *req, vg_msg *body,
 125                                   void (*callback)(
 126                                      netmsg_request *res, vg_msg *body,
 127                                      u64 userdata),
 128                                   u64 userdata ){
 129    u32 len = 0;
 130    if( body ){
 131       len = body->cur.co;
 132       vg_info( "Request scoreboard. Info (%u):\n", body->cur.co );
 133       vg_msg_print( body, len );
 134
 135       if( body->error != k_vg_msg_error_OK ){
 136          vg_error( "Body not OK\n" );
 137          return;
 138       }
 139    }
 140
 141    if( callback ){
 142       req->id = vg_pool_lru( &network_client.request_pool );
 143       if( req->id ){
 144          vg_pool_watch( &network_client.request_pool, req->id );
 145          struct network_request *pn =
 146             vg_pool_item( &network_client.request_pool, req->id );
 147          pn->callback = callback;
 148          pn->sendtime = vg.time_real;
 149          pn->userdata = userdata;
 150       }
 151       else{
 152          vg_error( "Unable to send request. Pool is full.\n" );
 153          return;
 154       }
 155    }
 156    else
 157       req->id = 0;
 158
 159    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 160          hSteamNetworkingSockets, network_client.remote,
 161          req, sizeof(netmsg_request)+len,
 162          k_nSteamNetworkingSend_Reliable, NULL );
 163 }
 164
 165 static void network_scoreboard_callback( netmsg_request *res, vg_msg *body,
 166                                          u64 userdata ){
 167    world_instance *world = world_current_instance();
 168
 169    world_routes_recv_scoreboard( world, body, userdata, res->status );
 170    if( userdata == world_sfd.active_route_board )
 171       world_sfd_compile_active_scores();
 172 }
 173
 174
 175
 176 /* mod_uid: world mod uid,
 177  * route_uid: run name (just a string)
 178  * week:
 179  *   0   ALL TIME
 180  *   1   CURRENT WEEK
 181  *   2   ALL TIME + CURRENT WEEK
 182  *   .
 183  *   10+ specific week index
 184  */
 185 void network_request_scoreboard( const char *mod_uid,
 186                                  const char *route_uid,
 187                                  u32 week, u64 userdata ){
 188    if( !network_connected() )
 189       return;
 190
 191    netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
 192    req->inetmsg_id = k_inetmsg_request;
 193
 194    vg_msg data;
 195    vg_msg_init( &data, req->q, 512 );
 196    vg_msg_wkvstr( &data, "endpoint", "scoreboard" );
 197    vg_msg_wkvstr( &data, "mod", mod_uid );
 198    vg_msg_wkvstr( &data, "route", route_uid );
 199    vg_msg_wkvnum( &data, "week", k_vg_msg_u32, 1, &week );
 200    network_send_request( req, &data, network_scoreboard_callback, userdata );
 201 }
 202
 203 static void network_publish_callback( netmsg_request *res, vg_msg *body,
 204                                       u64 userdata ){
 205    if( res->status != k_request_status_ok ){
 206       vg_error( "Publish laptime, server error #%d\n", (i32)res->status );
 207    }
 208 }
 209
 210 void network_publish_laptime( const char *mod_uid,
 211                               const char *route_uid, f64 lap_time ){
 212    if( !network_connected() )
 213       return;
 214
 215    i32 time_centiseconds = lap_time * 100.0;
 216
 217    netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
 218    req->inetmsg_id = k_inetmsg_request;
 219
 220    vg_msg data;
 221    vg_msg_init( &data, req->q, 512 );
 222    vg_msg_wkvstr( &data, "endpoint", "setlap" );
 223    vg_msg_wkvstr( &data, "mod", mod_uid );
 224    vg_msg_wkvstr( &data, "route", route_uid );
 225    vg_msg_wkvnum( &data, "time", k_vg_msg_i32, 1, &time_centiseconds );
 226    network_send_request( req, &data, network_publish_callback, 0 );
 227 }
 228
 229 static void network_request_rx_300_400( SteamNetworkingMessage_t *msg ){
 230    netmsg_blank *tmp = msg->m_pData;
 231
 232    if( tmp->inetmsg_id == k_inetmsg_request ){
 233
 234    }
 235    else if( tmp->inetmsg_id == k_inetmsg_response ){
 236       netmsg_request *res = (netmsg_request *)msg->m_pData;
 237
 238       vg_msg *body = NULL;
 239
 240       vg_msg data;
 241       if( res->status == k_request_status_ok ){
 242          vg_msg_init( &data, res->q, msg->m_cbSize - sizeof(netmsg_request) );
 243          vg_success( "Response to #%d:\n", (i32)res->id );
 244          vg_msg_print( &data, data.max );
 245          body = &data;
 246       }
 247       else {
 248          vg_warn( "Server response to #%d: %d\n", (i32)res->id, res->status );
 249       }
 250
 251       if( res->id ){
 252          struct network_request *pn =
 253             vg_pool_item( &network_client.request_pool, res->id );
 254          pn->callback( res, body, pn->userdata );
 255          vg_pool_unwatch( &network_client.request_pool, res->id );
 256       }
 257    }
 258 }
 259
 260 void network_send_item( enum netmsg_playeritem_type type )
 261 {
 262    if( !network_connected() )
 263       return;
 264
 265    netmsg_playeritem *item =
 266       alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
 267    item->inetmsg_id = k_inetmsg_playeritem;
 268    item->type_index = type;
 269    item->client = 0;
 270
 271    if( (type == k_netmsg_playeritem_world0) ||
 272        (type == k_netmsg_playeritem_world1) ){
 273
 274       enum world_purpose purpose = type - k_netmsg_playeritem_world0;
 275       addon_reg *reg = world_static.instance_addons[ purpose ];
 276
 277       if( reg )
 278          addon_alias_uid( &reg->alias, item->uid );
 279       else
 280          item->uid[0] = '\0';
 281    }
 282    else{
 283       u16 view_id = 0;
 284       enum addon_type addon_type = k_addon_type_none;
 285       if( type == k_netmsg_playeritem_board ){
 286          view_id = localplayer.board_view_slot;
 287          addon_type = k_addon_type_board;
 288       }
 289       else if( type == k_netmsg_playeritem_player ){
 290          view_id = localplayer.playermodel_view_slot;
 291          addon_type = k_addon_type_player;
 292       }
 293
 294       struct addon_cache *cache = &addon_system.cache[addon_type];
 295       vg_pool *pool = &cache->pool;
 296
 297       SDL_AtomicLock( &addon_system.sl_cache_using_resources );
 298       addon_cache_entry *entry = vg_pool_item( pool, view_id );
 299       addon_alias_uid( &entry->reg_ptr->alias, item->uid );
 300       SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
 301    }
 302
 303    vg_info( "send equip: [%u] %s\n",
 304             item->type_index, item->uid );
 305    u32 chs = strlen(item->uid);
 306
 307    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 308          hSteamNetworkingSockets, network_client.remote,
 309          item, sizeof(netmsg_playeritem)+chs+1,
 310          k_nSteamNetworkingSend_Reliable, NULL );
 311 }
 312
 313 static void network_disconnect(void){
 314    SteamAPI_ISteamNetworkingSockets_CloseConnection(
 315          hSteamNetworkingSockets, network_client.remote, 0, NULL, 0 );
 316    network_client.remote = 0;
 317    network_client.state = k_ESteamNetworkingConnectionState_None;
 318
 319    for( int i=0; i<vg_list_size(netplayers.list); i++ ){
 320       netplayers.list[i].active = 0;
 321    }
 322 }
 323
 324 void network_status_string( vg_str *str, u32 *colour )
 325 {
 326    if( skaterift.demo_mode ){
 327       vg_strcat( str, "Offline" );
 328       return;
 329    }
 330
 331    if( steam_ready ){
 332       if( network_client.user_intent == k_server_intent_offline ){
 333          vg_strcat( str, "Offline" );
 334       }
 335       else {
 336          ESteamNetworkingConnectionState state = network_client.state;
 337
 338          if( state == k_ESteamNetworkingConnectionState_None )
 339             vg_strcat( str, "No Connection" );
 340          else if( state == k_ESteamNetworkingConnectionState_Connecting )
 341          {
 342             vg_strcatf( str, "Connecting...\n%s", network_client.host_adress );
 343
 344             if( network_client.retries ){
 345                vg_strcat( str, "\n(" );
 346                vg_strcati32( str, network_client.retries );
 347                vg_strcat( str, " retries)" );
 348             }
 349          }
 350          else if( state == k_ESteamNetworkingConnectionState_Connected ){
 351             vg_strcatf( str, "Connected to:\n%s", network_client.host_adress );
 352             *colour = 0xff00a020;
 353          }
 354          else if( state == k_ESteamNetworkingConnectionState_ClosedByPeer )
 355             vg_strcat( str, "Connection Closed" );
 356          else if( state == k_ESteamNetworkingConnectionState_FindingRoute )
 357             vg_strcat( str, "Finding Route" );
 358          else if( state ==
 359                k_ESteamNetworkingConnectionState_ProblemDetectedLocally){
 360             vg_strcat( str, "Problem Detected\nLocally" );
 361             *colour = 0xff0000a0;
 362          }
 363          else
 364             vg_strcat( str, "???" );
 365       }
 366    }
 367    else {
 368       vg_strcat( str, "Steam Offline" );
 369       *colour = 0xff0000a0;
 370    }
 371 }
 372
 373 void render_server_status_gui(void)
 374 {
 375    render_fb_bind( gpipeline.fb_workshop_preview, 0 );
 376
 377    ui_set_screen( 128, 48 );
 378
 379    /* HACK */
 380         g_ui_ctx->cur_vert = 0;
 381         g_ui_ctx->cur_indice = 0;
 382    g_ui_ctx->vert_start = 0;
 383    g_ui_ctx->indice_start = 0;
 384
 385    ui_rect r = { 0, 0, 128, 48 };
 386
 387    char buf[128];
 388    vg_str str;
 389    vg_strnull( &str, buf, sizeof(buf) );
 390
 391    u32 bg = 0xff000000;
 392    network_status_string( &str, &bg );
 393
 394    ui_fill( r, bg );
 395    ui_text( r, buf, 1, k_ui_align_center, 0 );
 396    ui_flush( k_ui_shader_colour );
 397
 398    skaterift.rt_textures[ k_skaterift_rt_server_status ] =
 399       gpipeline.fb_workshop_preview->attachments[0].id;
 400 }
 401
 402 static void on_server_connect_status( CallbackMsg_t *msg ){
 403    SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
 404    vg_info( "  Connection status changed for %lu\n", info->m_hConn );
 405    vg_info( "  %s -> %s\n",
 406          string_ESteamNetworkingConnectionState(info->m_eOldState),
 407          string_ESteamNetworkingConnectionState(info->m_info.m_eState) );
 408
 409    if( info->m_hConn == network_client.remote ){
 410       network_client.state = info->m_info.m_eState;
 411
 412       if( info->m_info.m_eState ==
 413             k_ESteamNetworkingConnectionState_Connected ){
 414          vg_success("  Connected to remote server.. authenticating\n");
 415
 416          /* send version info to server */
 417          netmsg_version version;
 418          version.inetmsg_id = k_inetmsg_version;
 419          version.version = NETWORK_SKATERIFT_VERSION;
 420          SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 421                hSteamNetworkingSockets, network_client.remote, &version,
 422                sizeof(netmsg_version), k_nSteamNetworkingSend_Reliable, NULL );
 423
 424          /* TODO: We should really wait to see if the server is in auth mode
 425           * first... */
 426          u32 size = sizeof(netmsg_auth) + network_client.app_key_length;
 427          netmsg_auth *auth = alloca(size);
 428          auth->inetmsg_id = k_inetmsg_auth;
 429          auth->ticket_length = network_client.app_key_length;
 430          for( int i=0; i<network_client.app_key_length; i++ )
 431             auth->ticket[i] = network_client.app_symmetric_key[i];
 432
 433          SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 434                hSteamNetworkingSockets, network_client.remote, auth, size,
 435                k_nSteamNetworkingSend_Reliable, NULL );
 436       }
 437       else if( info->m_info.m_eState ==
 438             k_ESteamNetworkingConnectionState_ClosedByPeer ){
 439
 440          if( info->m_info.m_eEndReason ==
 441                k_ESteamNetConnectionEnd_Misc_InternalError ){
 442             network_client.retries = 40;
 443          }
 444          network_disconnect();
 445       }
 446       else if( info->m_info.m_eState ==
 447             k_ESteamNetworkingConnectionState_ProblemDetectedLocally ){
 448          network_disconnect();
 449       }
 450    }
 451    else{
 452       //vg_warn( "  Recieved signal from unknown connection\n" );
 453    }
 454
 455    render_server_status_gui();
 456 }
 457
 458 static void on_persona_state_change( CallbackMsg_t *msg ){
 459    if( !network_connected() )
 460       return;
 461
 462    PersonaStateChange_t *info = (void *)msg->m_pubParam;
 463    ISteamUser *hSteamUser = SteamAPI_SteamUser();
 464
 465    vg_info( "User: %llu, change: %u\n", info->m_ulSteamID,
 466                                         info->m_nChangeFlags );
 467
 468    if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) ){
 469       if( info->m_nChangeFlags & k_EPersonaChangeName ){
 470          network_send_username();
 471       }
 472    }
 473
 474    if( info->m_nChangeFlags & k_EPersonaChangeRelationshipChanged ){
 475       for( u32 i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
 476          struct network_player *rp = &netplayers.list[i];
 477          if( rp->steamid == info->m_ulSteamID ){
 478             player_remote_update_friendflags( rp );
 479          }
 480       }
 481    }
 482 }
 483
 484 void network_set_host( const char *host_str, const char *port_str )
 485 {
 486    vg_strncpy( host_str, network_client.host_adress,
 487                sizeof(network_client.host_adress), k_strncpy_overflow_fatal );
 488
 489    memset( &network_client.ip, 0, sizeof(network_client.ip) );
 490    network_client.ip_resolved = 0;
 491
 492    if( port_str )
 493    {
 494       vg_strncpy( port_str, network_client.host_port,
 495                   sizeof(network_client.host_port), k_strncpy_overflow_fatal );
 496    }
 497    else
 498    {
 499       vg_str str;
 500       vg_strnull( &str, network_client.host_port,
 501                   sizeof(network_client.host_port) );
 502       vg_strcati32( &str, NETWORK_PORT );
 503    }
 504
 505    network_client.ip.m_port = atoi( network_client.host_port );
 506 }
 507
 508 static void network_connect(void)
 509 {
 510    VG_ASSERT( network_client.ip_resolved );
 511
 512    vg_info( "connecting...\n" );
 513    network_client.remote = SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
 514                   hSteamNetworkingSockets, &network_client.ip, 0, NULL );
 515 }
 516
 517 static void network_sign_on_complete(void){
 518    vg_success( "Sign on completed\n" );
 519
 520    /* send our init info */
 521    network_send_username();
 522    for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
 523       network_send_item(i);
 524    }
 525    network_send_region();
 526 }
 527
 528 static void poll_remote_connection(void){
 529    SteamNetworkingMessage_t *messages[32];
 530    int len;
 531
 532    for( int i=0; i<10; i++ ){
 533       len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
 534             hSteamNetworkingSockets, network_client.remote,
 535             messages, vg_list_size(messages));
 536
 537       if( len <= 0 )
 538          return;
 539
 540       for( int i=0; i<len; i++ ){
 541          SteamNetworkingMessage_t *msg = messages[i];
 542
 543          if( msg->m_cbSize < sizeof(netmsg_blank) ){
 544             vg_warn( "Discarding message (too small: %d)\n", msg->m_cbSize );
 545             continue;
 546          }
 547
 548          netmsg_blank *tmp = msg->m_pData;
 549
 550          if( (tmp->inetmsg_id >= 200) && (tmp->inetmsg_id < 300) ){
 551             player_remote_rx_200_300( msg );
 552          }
 553          else if( (tmp->inetmsg_id >= 300) && (tmp->inetmsg_id < 400) ){
 554             network_request_rx_300_400( msg );
 555          }
 556          else {
 557             if( tmp->inetmsg_id == k_inetmsg_version ){
 558                netmsg_version *version = msg->m_pData;
 559                if( version->version != NETWORK_SKATERIFT_VERSION ){
 560                   network_disconnect();
 561                   /* we dont want to connect to this server ever */
 562                   network_client.retries = 999;
 563                   network_client.last_attempt = 999999999.9;
 564                   vg_error( "version mismatch with server\n" );
 565                }
 566                else {
 567                   network_client.remote_version = version->version;
 568                   network_sign_on_complete();
 569                }
 570             }
 571          }
 572
 573          SteamAPI_SteamNetworkingMessage_t_Release( msg );
 574       }
 575    }
 576 }
 577
 578 static void network_resolve_host_async( void *payload, u32 size )
 579 {
 580    u32 *status = payload;
 581    network_client.ip_resolved = *status;
 582
 583    char buf[256];
 584    SteamAPI_SteamNetworkingIPAddr_ToString( &network_client.ip, buf, 256, 1 );
 585    vg_info( "Resolved host address to: %s\n", buf );
 586 }
 587
 588 static void network_resolve_host_thread( void *_ )
 589 {
 590    vg_async_item *call = vg_async_alloc(8);
 591    u32 *status = call->payload;
 592    *status = 0;
 593
 594    if( (network_client.host_adress[0] >= '0') &&
 595        (network_client.host_adress[0] <= '9') )
 596    {
 597       SteamAPI_SteamNetworkingIPAddr_ParseString(
 598             &network_client.ip,
 599             network_client.host_adress );
 600       network_client.ip.m_port = atoi( network_client.host_port );
 601       *status = 1;
 602       goto end;
 603    }
 604
 605    vg_info( "Resolving host.. %s (:%s)\n",
 606              network_client.host_adress, network_client.host_port );
 607
 608    struct addrinfo  hints;
 609    struct addrinfo  *result;
 610
 611    /* Obtain address(es) matching host/port. */
 612
 613    memset( &hints, 0, sizeof(hints) );
 614    hints.ai_family = AF_INET6;
 615    hints.ai_socktype = SOCK_DGRAM;
 616    hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG;
 617    hints.ai_protocol = 0;
 618
 619    int s = getaddrinfo( network_client.host_adress, network_client.host_port,
 620                         &hints, &result);
 621    if( s != 0 )
 622    {
 623 #ifndef _WIN32
 624       vg_error( "getaddrinfo: %s\n", gai_strerror(s) );
 625 #endif
 626
 627       if( !strcmp( network_client.host_adress, "skaterift.com" ) )
 628       {
 629          vg_warn( "getaddrinfo failed for skaterift.com;\n "
 630                   "falling back to a hardcoded IPv4\n" );
 631          strcpy( network_client.host_adress, "46.101.34.155" );
 632          SteamAPI_SteamNetworkingIPAddr_ParseString(
 633                &network_client.ip,
 634                network_client.host_adress );
 635          network_client.ip.m_port = NETWORK_PORT;
 636          *status = 1;
 637       }
 638
 639       goto end;
 640    }
 641
 642    struct sockaddr_in6 *inaddr = (struct sockaddr_in6 *)result->ai_addr;
 643    memcpy( network_client.ip.m_ipv6, &inaddr->sin6_addr, 16 );
 644    freeaddrinfo( result );
 645
 646    *status = 1;
 647
 648 end: vg_async_dispatch( call, network_resolve_host_async );
 649 }
 650
 651 void network_update(void)
 652 {
 653    if( !steam_ready )
 654       return;
 655
 656    ESteamNetworkingConnectionState state = network_client.state;
 657
 658    if( network_client.user_intent == k_server_intent_offline )
 659    {
 660       if( state != k_ESteamNetworkingConnectionState_None )
 661          network_disconnect();
 662
 663       return;
 664    }
 665
 666    if( state == k_ESteamNetworkingConnectionState_Connected )
 667    {
 668       poll_remote_connection();
 669       f64 frame_delta = vg.time_real - network_client.last_frame;
 670
 671       if( frame_delta > NETWORK_FRAMERATE )
 672       {
 673          network_client.last_frame = vg.time_real;
 674          remote_player_send_playerframe();
 675          localplayer.sfx_buffer_count = 0;
 676       }
 677
 678       remote_player_debug_update();
 679    }
 680    else
 681    {
 682       if( (state == k_ESteamNetworkingConnectionState_Connecting) ||
 683           (state == k_ESteamNetworkingConnectionState_FindingRoute) )
 684       {
 685          return;
 686       }
 687       else
 688       {
 689          f64 waited = vg.time_real - network_client.last_attempt,
 690              min_wait = 1.0;
 691
 692          if( network_client.retries > 5 )
 693             min_wait = 60.0;
 694
 695          if( waited < min_wait )
 696             return;
 697
 698          if( !network_client.ip_resolved )
 699          {
 700             if( vg_loader_availible() )
 701             {
 702                vg_loader_start( network_resolve_host_thread, NULL );
 703             }
 704             else return;
 705          }
 706          else
 707             network_connect();
 708
 709          network_client.retries ++;
 710          network_client.last_attempt = vg.time_real;
 711       }
 712    }
 713 }
 714
 715 void chat_send_message( const char *message )
 716 {
 717    if( !network_connected() ){
 718       return;
 719    }
 720
 721    netmsg_chat *chat = alloca( sizeof(netmsg_chat) + NETWORK_MAX_CHAT );
 722    chat->inetmsg_id = k_inetmsg_chat;
 723    chat->client = 0;
 724
 725    u32 l = vg_strncpy( message, chat->msg, NETWORK_MAX_CHAT,
 726                        k_strncpy_always_add_null );
 727
 728    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 729          hSteamNetworkingSockets, network_client.remote,
 730          chat, sizeof(netmsg_chat)+l+1,
 731          k_nSteamNetworkingSend_Reliable, NULL );
 732 }
 733
 734 static int cmd_network_send_message( int argc, const char *argv[] ){
 735    char buf[ NETWORK_MAX_CHAT ];
 736    vg_str str;
 737    vg_strnull( &str, buf, NETWORK_MAX_CHAT );
 738
 739    for( int i=0; i<argc; i ++ ){
 740       vg_strcat( &str, argv[i] );
 741
 742       if( i < argc-1 )
 743          vg_strcatch( &str, ' ' );
 744    }
 745
 746    chat_send_message( buf );
 747    return 0;
 748 }
 749
 750 void network_init(void)
 751 {
 752    vg_console_reg_var( "network_info", &network_client.network_info,
 753                        k_var_dtype_i32, VG_VAR_PERSISTENT );
 754    vg_console_reg_var( "auto_connect", &network_client.auto_connect,
 755                        k_var_dtype_i32, VG_VAR_PERSISTENT );
 756    if( steam_ready ){
 757       u32 alloc_size = sizeof(struct network_request)*NETWORK_MAX_REQUESTS;
 758       network_client.request_buffer =
 759          vg_linear_alloc( vg_mem.rtmemory, alloc_size );
 760       memset( network_client.request_buffer, 0, alloc_size );
 761
 762       vg_pool *pool = &network_client.request_pool;
 763       pool->buffer = network_client.request_buffer;
 764       pool->count = NETWORK_MAX_REQUESTS;
 765       pool->stride = sizeof( struct network_request );
 766       pool->offset = offsetof( struct network_request, poolnode );
 767       vg_pool_init( pool );
 768
 769       steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack,
 770                                on_server_connect_status );
 771       steam_register_callback( k_iPersonaStateChange,
 772                                on_persona_state_change );
 773       request_auth_ticket();
 774
 775       vg_console_reg_cmd( "say", cmd_network_send_message, NULL );
 776    }
 777 }
 778
 779 void network_end(void)
 780 {
 781    /* TODO: Send buffered highscores that were not already */
 782    if( (network_client.state == k_ESteamNetworkingConnectionState_Connected) ||
 783        (network_client.state == k_ESteamNetworkingConnectionState_Connecting) )
 784    {
 785       SteamAPI_ISteamNetworkingSockets_CloseConnection(
 786             hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
 787    }
 788 }