3 #include "network_msg.h"
4 #include "network_common.h"
5 #include "player_remote.h"
8 static void scores_update(void);
10 static int packet_minsize( SteamNetworkingMessage_t
*msg
, u32 size
){
11 if( msg
->m_cbSize
< size
) {
12 vg_error( "Invalid packet size (must be at least %u)\n", size
);
20 static void on_auth_ticket_recieved( void *result
, void *context
){
21 EncryptedAppTicketResponse_t
*response
= result
;
23 if( response
->m_eResult
== k_EResultOK
){
24 vg_info( " New app ticket ready\n" );
27 vg_warn( " Could not request new encrypted app ticket (%u)\n",
28 response
->m_eResult
);
31 if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser
,
32 network_client
.app_symmetric_key
,
33 vg_list_size(network_client
.app_symmetric_key
),
34 &network_client
.app_key_length
)){
35 vg_success( " Loaded app ticket\n" );
38 vg_error( " No ticket availible\n" );
39 network_client
.app_key_length
= 0;
43 static void request_auth_ticket(void){
45 * TODO Check for one thats cached on the disk and load it.
46 * This might be OK though because steam seems to cache the result
49 vg_info( "Requesting new authorization ticket\n" );
51 vg_steam_async_call
*call
= vg_alloc_async_steam_api_call();
52 call
->userdata
= NULL
;
53 call
->p_handler
= on_auth_ticket_recieved
;
55 SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser
, NULL
, 0 );
59 static void send_score_request(void){
60 vg_info( "Requesting scores\n" );
61 netmsg_scores_request req
;
62 req
.inetmsg_id
= k_inetmsg_scores_request
;
64 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
65 hSteamNetworkingSockets
, network_client
.remote
,
66 &req
, sizeof(netmsg_scores_request
),
67 k_nSteamNetworkingSend_Reliable
, NULL
);
70 static void send_score_update(void){
71 vg_info( "Sending scores\n" );
72 u32 size
= sizeof(netmsg_set_score
) +
73 vg_list_size(track_infos
)*sizeof(struct netmsg_score_record
);
74 netmsg_set_score
*setscore
= alloca( size
);
75 setscore
->inetmsg_id
= k_inetmsg_set_score
;
78 for( u32 i
=0; i
<vg_list_size(track_infos
); i
++ ){
79 if( track_infos
[i
].push
){
80 track_infos
[i
].push
= 0;
83 highscore_record
*user_record
= highscore_find_user_record( 0, i
);
86 vg_error( "No score set but tried to upload for track %u\n", i
);
90 highscore_record
*user_record
= &track_infos
[i
].record
;
92 setscore
->records
[count
].trackid
= i
;
93 setscore
->records
[count
].playerid
= 0;
94 setscore
->records
[count
].points
= user_record
->points
;
95 setscore
->records
[count
].time
= user_record
->time
;
101 if( count
== 0 ) return;
102 u32 send_size
= sizeof(netmsg_set_score
) +
103 count
*sizeof(struct netmsg_score_record
);
104 setscore
->record_count
= count
;
106 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
107 hSteamNetworkingSockets
, network_client
.remote
, setscore
, send_size
,
108 k_nSteamNetworkingSend_Reliable
, NULL
);
111 static void send_nickname(void){
112 netmsg_set_nickname nick
;
113 nick
.inetmsg_id
= k_inetmsg_set_nickname
;
115 memset( nick
.nickname
, 0, 16 );
116 vg_strncpy( steam_username_at_startup
, nick
.nickname
, 16,
117 k_strncpy_allow_cutoff
);
119 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
120 hSteamNetworkingSockets
, network_client
.remote
,
121 &nick
, sizeof(netmsg_set_nickname
),
122 k_nSteamNetworkingSend_Reliable
, NULL
);
124 network_client
.name_update
= 0;
129 static void server_routine_update(void){
131 send_score_request();
135 static void network_send_username(void){
136 netmsg_playerusername
*update
= alloca( sizeof(netmsg_playerusername
)+
137 NETWORK_USERNAME_MAX
);
138 update
->inetmsg_id
= k_inetmsg_playerusername
;
139 update
->index
= 0xff;
141 ISteamFriends
*hSteamFriends
= SteamAPI_SteamFriends();
142 const char *username
= SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends
);
143 u32 chs
= str_utf8_collapse( username
, update
->name
, NETWORK_USERNAME_MAX
);
145 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
146 hSteamNetworkingSockets
, network_client
.remote
,
147 update
, sizeof(netmsg_playerusername
)+chs
+1,
148 k_nSteamNetworkingSend_Reliable
, NULL
);
151 static void network_send_request( netmsg_request
*req
, vg_msg
*body
,
152 void (*callback
)( netmsg_request
*res
,
157 vg_info( "Request scoreboard. Info (%u):\n", body
->cur
.co
);
158 vg_msg_print( body
, len
);
160 if( body
->error
!= k_vg_msg_error_OK
){
161 vg_error( "Body not OK\n" );
167 req
->id
= vg_pool_lru( &network_client
.request_pool
);
169 vg_pool_watch( &network_client
.request_pool
, req
->id
);
170 struct network_request
*pn
=
171 vg_pool_item( &network_client
.request_pool
, req
->id
);
172 pn
->callback
= callback
;
173 pn
->sendtime
= vg
.time_real
;
176 vg_error( "Unable to send request. Pool is full.\n" );
183 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
184 hSteamNetworkingSockets
, network_client
.remote
,
185 req
, sizeof(netmsg_request
)+len
,
186 k_nSteamNetworkingSend_Reliable
, NULL
);
189 static void network_scoreboard_callback( netmsg_request
*res
, vg_msg
*body
){
190 for( u32 i
=0; i
<13; i
++ )
193 if( res
->status
!= k_request_status_ok
){
196 vg_strnull( &s
, buf
, 32 );
197 vg_strcat( &s
, "Error: " );
198 vg_strcati32( &s
, res
->status
);
200 sfd_encode( 4, buf
);
205 if( vg_msg_seekframe( body
, "rows" ) ){
206 while( vg_msg_seekframe( body
, NULL
) ){
207 const char *username
= vg_msg_getkvstr( body
, "username" );
210 sfd_encode( l
++, username
);
212 sfd_encode( l
++, "UNKNOWN USER" );
214 vg_msg_skip_frame( body
);
219 /* mod_uid: world mod uid,
220 * route_uid: run name (just a string)
221 * week: 0 for all-time, n for week #
223 static void network_request_scoreboard( const char *mod_uid
,
224 const char *route_uid
,
226 if( !network_client
.remote
)
229 netmsg_request
*req
= alloca( sizeof(netmsg_request
) + 512 );
230 req
->inetmsg_id
= k_inetmsg_request
;
233 vg_msg_init( &data
, req
->q
, 512 );
234 vg_msg_wkvstr( &data
, "endpoint", "scoreboard" );
235 vg_msg_wkvstr( &data
, "mod", mod_uid
);
236 vg_msg_wkvstr( &data
, "route", route_uid
);
237 vg_msg_wkvu32( &data
, "week", week
);
238 network_send_request( req
, &data
, network_scoreboard_callback
);
241 static void network_publish_callback( netmsg_request
*res
, vg_msg
*body
){
242 if( res
->status
!= k_request_status_ok
){
243 vg_error( "Publish laptime, server error #%d\n", (i32
)res
->status
);
247 static void network_publish_laptime( const char *mod_uid
,
248 const char *route_uid
, f64 lap_time
){
249 if( !network_client
.remote
)
252 i32 time_centiseconds
= lap_time
* 100.0;
254 netmsg_request
*req
= alloca( sizeof(netmsg_request
) + 512 );
255 req
->inetmsg_id
= k_inetmsg_request
;
258 vg_msg_init( &data
, req
->q
, 512 );
259 vg_msg_wkvstr( &data
, "endpoint", "setlap" );
260 vg_msg_wkvstr( &data
, "mod", mod_uid
);
261 vg_msg_wkvstr( &data
, "route", route_uid
);
262 vg_msg_wkvi32( &data
, "time", time_centiseconds
);
263 network_send_request( req
, &data
, network_publish_callback
);
266 static void network_request_rx_300_400( SteamNetworkingMessage_t
*msg
){
267 netmsg_blank
*tmp
= msg
->m_pData
;
269 if( tmp
->inetmsg_id
== k_inetmsg_request
){
272 else if( tmp
->inetmsg_id
== k_inetmsg_response
){
273 netmsg_request
*res
= (netmsg_request
*)msg
->m_pData
;
278 if( res
->status
== k_request_status_ok
){
279 vg_msg_init( &data
, res
->q
, msg
->m_cbSize
- sizeof(netmsg_request
) );
280 vg_success( "Response to #%d:\n", (i32
)res
->id
);
281 vg_msg_print( &data
, data
.max
);
285 vg_warn( "Server response to #%d: %d\n", (i32
)res
->id
, res
->status
);
289 struct network_request
*pn
=
290 vg_pool_item( &network_client
.request_pool
, res
->id
);
291 pn
->callback( res
, body
);
292 vg_pool_unwatch( &network_client
.request_pool
, res
->id
);
297 static void network_send_item( enum netmsg_playeritem_type type
){
298 if( !network_client
.remote
)
301 netmsg_playeritem
*item
=
302 alloca( sizeof(netmsg_playeritem
) + ADDON_UID_MAX
);
303 item
->inetmsg_id
= k_inetmsg_playeritem
;
304 item
->type_index
= type
;
307 if( (type
== k_netmsg_playeritem_world0
) ||
308 (type
== k_netmsg_playeritem_world1
) ){
310 addon_reg
*reg
= world_static
.addon_hub
;
312 if( type
== k_netmsg_playeritem_world1
)
313 reg
= world_static
.addon_client
;
316 addon_alias_uid( ®
->alias
, item
->uid
);
322 enum addon_type addon_type
= k_addon_type_none
;
323 if( type
== k_netmsg_playeritem_board
){
324 view_id
= localplayer
.board_view_slot
;
325 addon_type
= k_addon_type_board
;
327 else if( type
== k_netmsg_playeritem_player
){
328 view_id
= localplayer
.playermodel_view_slot
;
329 addon_type
= k_addon_type_player
;
334 struct addon_cache
*cache
= &addon_system
.cache
[addon_type
];
335 vg_pool
*pool
= &cache
->pool
;
337 SDL_AtomicLock( &addon_system
.sl_cache_using_resources
);
338 addon_cache_entry
*entry
= vg_pool_item( pool
, view_id
);
339 addon_alias_uid( &entry
->reg_ptr
->alias
, item
->uid
);
340 SDL_AtomicUnlock( &addon_system
.sl_cache_using_resources
);
343 vg_info( "send equip: [%u] %s\n",
344 item
->type_index
, item
->uid
);
345 u32 chs
= strlen(item
->uid
);
347 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
348 hSteamNetworkingSockets
, network_client
.remote
,
349 item
, sizeof(netmsg_playeritem
)+chs
+1,
350 k_nSteamNetworkingSend_Reliable
, NULL
);
353 static void network_disconnect(void){
354 SteamAPI_ISteamNetworkingSockets_CloseConnection(
355 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 0 );
356 network_client
.remote
= 0;
358 for( int i
=0; i
<vg_list_size(netplayers
.list
); i
++ ){
359 netplayers
.list
[i
].active
= 0;
363 static void on_server_connect_status( CallbackMsg_t
*msg
){
364 SteamNetConnectionStatusChangedCallback_t
*info
= (void *)msg
->m_pubParam
;
365 vg_info( " Connection status changed for %lu\n", info
->m_hConn
);
366 vg_info( " %s -> %s\n",
367 string_ESteamNetworkingConnectionState(info
->m_eOldState
),
368 string_ESteamNetworkingConnectionState(info
->m_info
.m_eState
) );
370 if( info
->m_hConn
== network_client
.remote
){
371 network_client
.state
= info
->m_info
.m_eState
;
373 if( info
->m_info
.m_eState
==
374 k_ESteamNetworkingConnectionState_Connected
){
375 vg_success(" Connected to remote server.. authenticating\n");
377 /* TODO: We should really wait to see if the server is in auth mode
379 u32 size
= sizeof(netmsg_auth
) + network_client
.app_key_length
;
380 netmsg_auth
*auth
= alloca(size
);
381 auth
->inetmsg_id
= k_inetmsg_auth
;
382 auth
->ticket_length
= network_client
.app_key_length
;
383 for( int i
=0; i
<network_client
.app_key_length
; i
++ )
384 auth
->ticket
[i
] = network_client
.app_symmetric_key
[i
];
386 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
387 hSteamNetworkingSockets
, network_client
.remote
, auth
, size
,
388 k_nSteamNetworkingSend_Reliable
, NULL
);
390 network_send_username();
392 for( u32 i
=0; i
<k_netmsg_playeritem_max
; i
++ ){
393 network_send_item(i
);
396 else if( info
->m_info
.m_eState
==
397 k_ESteamNetworkingConnectionState_ClosedByPeer
){
399 if( info
->m_info
.m_eEndReason
==
400 k_ESteamNetConnectionEnd_Remote_Max
){
401 network_client
.retries
= 40;
403 network_disconnect();
405 else if( info
->m_info
.m_eState
==
406 k_ESteamNetworkingConnectionState_ProblemDetectedLocally
){
407 network_disconnect();
411 //vg_warn( " Recieved signal from unknown connection\n" );
415 static void on_persona_state_change( CallbackMsg_t
*msg
){
416 if( network_client
.remote
){
417 PersonaStateChange_t
*info
= (void *)msg
->m_pubParam
;
419 ISteamUser
*hSteamUser
= SteamAPI_SteamUser();
421 vg_info( "User: %llu, change: %u\n", info
->m_ulSteamID
,
422 info
->m_nChangeFlags
);
424 if( info
->m_ulSteamID
== SteamAPI_ISteamUser_GetSteamID(hSteamUser
) ){
425 if( info
->m_nChangeFlags
& k_EPersonaChangeName
){
426 network_send_username();
432 static void network_connect(void){
433 /* Connect to server if not connected */
434 SteamNetworkingIPAddr remoteAddr
;
436 #ifdef SR_USE_LOCALHOST
437 SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost( &remoteAddr
, 27402 );
439 const char *server_lon1
= "46.101.34.155:27402";
440 SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr
, server_lon1
);
442 const char *server_lan
= "192.168.1.32:27402";
443 SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr
, server_lan
);
446 SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr
, buf
, 256, 1 );
447 vg_info( "connect to: %s\n", buf
);
449 network_client
.remote
= SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
450 hSteamNetworkingSockets
, &remoteAddr
, 0, NULL
);
453 static void on_inet_scoreboard( SteamNetworkingMessage_t
*msg
){
454 netmsg_scoreboard
*sb
= msg
->m_pData
;
456 u32 base_size
= sizeof(netmsg_scoreboard
)-
457 sizeof(struct netmsg_board
)*vg_list_size(track_infos
),
458 expected
= base_size
+sizeof(struct netmsg_board
)*sb
->board_count
;
460 if( msg
->m_cbSize
!= expected
){
461 vg_error( "Server scoreboard was corrupted. Size: %u != %u\n",
462 msg
->m_cbSize
, expected
);
465 if( vg_list_size(track_infos
) > sb
->board_count
)
466 vg_warn( "Server is out of date, not enough boards recieved\n");
467 else if( vg_list_size(track_infos
) < sb
->board_count
)
468 vg_warn( "Client out of date, server sent more boards than we have\n");
470 vg_success( "Recieved new scoreboards from server\n" );
472 for( int i
=0; i
< vg_min(sb
->board_count
,vg_list_size(track_infos
)); i
++){
473 scoreboard_client_data
.boards
[i
] = sb
->boards
[i
];
474 highscores_board_printf( stdout
, sb
->boards
[i
].data
, 10 );
479 /* We dont need to stay on the server currently */
480 SteamAPI_ISteamNetworkingSockets_CloseConnection(
481 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 1 );
484 network_scores_updated
= 1;
487 static void poll_remote_connection(void){
488 SteamNetworkingMessage_t
*messages
[32];
491 for( int i
=0; i
<10; i
++ ){
492 len
= SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
493 hSteamNetworkingSockets
, network_client
.remote
,
494 messages
, vg_list_size(messages
));
499 for( int i
=0; i
<len
; i
++ ){
500 SteamNetworkingMessage_t
*msg
= messages
[i
];
502 if( msg
->m_cbSize
< sizeof(netmsg_blank
) ){
503 vg_warn( "Discarding message (too small: %d)\n", msg
->m_cbSize
);
507 netmsg_blank
*tmp
= msg
->m_pData
;
509 if( (tmp
->inetmsg_id
>= 200) && (tmp
->inetmsg_id
< 300) ){
510 player_remote_rx_200_300( msg
);
512 else if( (tmp
->inetmsg_id
>= 300) && (tmp
->inetmsg_id
< 400) ){
513 network_request_rx_300_400( msg
);
516 SteamAPI_SteamNetworkingMessage_t_Release( msg
);
521 static void network_update(void){
525 ESteamNetworkingConnectionState state
= network_client
.state
;
527 if( state
== k_ESteamNetworkingConnectionState_Connected
){
528 poll_remote_connection();
529 f64 frame_delta
= vg
.time_real
- network_client
.last_frame
;
531 if( frame_delta
> NETWORK_FRAMERATE
){
532 network_client
.last_frame
= vg
.time_real
;
533 remote_player_send_playerframe();
534 player__clear_sfx_buffer();
537 remote_player_debug_update();
540 if( (state
== k_ESteamNetworkingConnectionState_Connecting
) ||
541 (state
== k_ESteamNetworkingConnectionState_FindingRoute
) ){
545 f64 waited
= vg
.time_real
- network_client
.last_attempt
,
548 if( network_client
.retries
> 5 )
551 if( waited
< min_wait
)
555 network_client
.retries
++;
556 network_client
.last_attempt
= vg
.time_real
;
561 static void network_init(void){
562 vg_console_reg_var( "network_info", &network_client
.network_info
,
563 k_var_dtype_i32
, VG_VAR_PERSISTENT
);
565 u32 alloc_size
= sizeof(struct network_request
)*NETWORK_MAX_REQUESTS
;
566 network_client
.request_buffer
=
567 vg_linear_alloc( vg_mem
.rtmemory
, alloc_size
);
568 memset( network_client
.request_buffer
, 0, alloc_size
);
570 vg_pool
*pool
= &network_client
.request_pool
;
571 pool
->buffer
= network_client
.request_buffer
;
572 pool
->count
= NETWORK_MAX_REQUESTS
;
573 pool
->stride
= sizeof( struct network_request
);
574 pool
->offset
= offsetof( struct network_request
, poolnode
);
575 vg_pool_init( pool
);
577 steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack
,
578 on_server_connect_status
);
579 steam_register_callback( k_iPersonaStateChange
,
580 on_persona_state_change
);
581 request_auth_ticket();
585 static void network_end(void){
586 /* TODO: Send buffered highscores that were not already */
587 if( (network_client
.state
== k_ESteamNetworkingConnectionState_Connected
) ||
588 (network_client
.state
== k_ESteamNetworkingConnectionState_Connecting
) )
590 SteamAPI_ISteamNetworkingSockets_CloseConnection(
591 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 1 );