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