2 * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
5 #define _DEFAULT_SOURCE
10 volatile sig_atomic_t sig_stop
;
12 static void inthandler( int signum
) {
16 #include "gameserver.h"
17 #include "highscores.c"
18 #include "servermonitor_server.c"
19 #include "vg/vg_opt.h"
20 #include "network_common.h"
22 static const u64 k_connection_unauthorized
= 0xffffffffffffffff;
24 static u64_steamid
get_connection_authsteamid( SteamNetworkingMessage_t
*msg
){
25 i64 userdata
= SteamAPI_ISteamNetworkingSockets_GetConnectionUserData(
26 hSteamNetworkingSockets
, msg
->m_conn
);
28 return *((u64_steamid
*)&userdata
);
31 static void set_connection_authsteamid(HSteamNetConnection con
, u64_steamid id
){
32 i64 userdata
= *((i64
*)&id
);
34 SteamAPI_ISteamNetworkingSockets_SetConnectionUserData(
35 hSteamNetworkingSockets
, con
, userdata
);
38 static void gameserver_send_to_all( int ignore
,
39 const void *pData
, u32 cbData
,
41 for( int i
=0; i
<vg_list_size(gameserver
.clients
); i
++ ){
42 struct gameserver_client
*client
= &gameserver
.clients
[i
];
44 if( (i
==ignore
) || !client
->active
)
47 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
48 hSteamNetworkingSockets
, client
->connection
,
49 pData
, cbData
, nSendFlags
, NULL
);
53 static void gameserver_player_join( int index
){
54 struct gameserver_client
*joiner
= &gameserver
.clients
[index
];
56 netmsg_playerjoin join
= { .inetmsg_id
= k_inetmsg_playerjoin
,
58 gameserver_send_to_all( index
, &join
, sizeof(join
),
59 k_nSteamNetworkingSend_Reliable
);
61 /* update the joining user about current connections */
63 netmsg_playerusername
*username
=
64 alloca( sizeof(netmsg_playerusername
) + NETWORK_USERNAME_MAX
);
65 username
->inetmsg_id
= k_inetmsg_playerusername
;
67 netmsg_playeritem
*item
=
68 alloca( sizeof(netmsg_playeritem
) + ADDON_UID_MAX
);
69 item
->inetmsg_id
= k_inetmsg_playeritem
;
71 for( int i
=0; i
<vg_list_size(gameserver
.clients
); i
++ ){
72 struct gameserver_client
*client
= &gameserver
.clients
[i
];
74 if( (i
==index
) || !client
->active
)
78 netmsg_playerjoin init
= { .inetmsg_id
= k_inetmsg_playerjoin
,
80 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
81 hSteamNetworkingSockets
, joiner
->connection
,
82 &init
, sizeof(init
), k_nSteamNetworkingSend_Reliable
, NULL
);
86 u32 chs
= vg_strncpy( client
->username
, username
->name
,
88 k_strncpy_always_add_null
);
89 u32 size
= sizeof(netmsg_playerusername
) + chs
+ 1;
90 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
91 hSteamNetworkingSockets
, joiner
->connection
,
92 username
, size
, k_nSteamNetworkingSend_Reliable
, NULL
);
95 for( int j
=0; j
<k_netmsg_playeritem_max
; j
++ ){
96 chs
= vg_strncpy( client
->items
[j
], item
->uid
, ADDON_UID_MAX
,
97 k_strncpy_always_add_null
);
100 size
= sizeof(netmsg_playeritem
) + chs
+ 1;
101 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
102 hSteamNetworkingSockets
, joiner
->connection
,
103 item
, size
, k_nSteamNetworkingSend_Reliable
, NULL
);
108 static void gameserver_player_leave( int index
){
109 netmsg_playerjoin leave
;
110 leave
.inetmsg_id
= k_inetmsg_playerleave
;
113 vg_info( "Player leave (%d)\n", index
);
114 gameserver_send_to_all( index
, &leave
, sizeof(leave
),
115 k_nSteamNetworkingSend_Reliable
);
118 static void new_client_connecting( HSteamNetConnection client
){
122 for( int i
=0; i
<vg_list_size(gameserver
.clients
); i
++ ){
123 if( !gameserver
.clients
[i
].active
){
130 vg_error( "Server full\n" );
131 SteamAPI_ISteamNetworkingSockets_CloseConnection(
132 hSteamNetworkingSockets
, client
,
138 EResult accept_status
= SteamAPI_ISteamNetworkingSockets_AcceptConnection(
139 hSteamNetworkingSockets
, client
);
140 if( accept_status
== k_EResultOK
){
141 vg_success( "Accepted client (id: %u, index: %d)\n", client
, index
);
142 memset( &gameserver
.clients
[index
], 0, sizeof(struct gameserver_client
) );
144 gameserver
.clients
[index
].active
= 1;
145 gameserver
.clients
[index
].connection
= client
;
147 SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup(
148 hSteamNetworkingSockets
,
149 client
, gameserver
.client_group
);
151 /* Just to be sure */
152 set_connection_authsteamid( client
, -1 );
153 gameserver_player_join( index
);
156 vg_warn( "Error accepting client (id: %u)\n", client
);
157 SteamAPI_ISteamNetworkingSockets_CloseConnection(
158 hSteamNetworkingSockets
, client
,
159 k_ESteamNetConnectionEnd_Misc_InternalError
,
161 gameserver
.clients
[index
].active
= 0;
162 gameserver
.clients
[index
].connection
= 0;
166 static void on_auth_status( CallbackMsg_t
*msg
){
167 SteamNetAuthenticationStatus_t
*info
= (void *)msg
->m_pubParam
;
168 vg_info( " Authentication availibility: %s\n",
169 string_ESteamNetworkingAvailability(info
->m_eAvail
) );
170 vg_info( " %s\n", info
->m_debugMsg
);
173 static int gameserver_client_index( HSteamNetConnection hconn
){
174 for( int i
=0; i
<vg_list_size(gameserver
.clients
); i
++ ){
175 struct gameserver_client
*client
= &gameserver
.clients
[i
];
177 if( client
->active
){
178 if( client
->connection
== hconn
){
186 static void on_connect_status( CallbackMsg_t
*msg
){
187 SteamNetConnectionStatusChangedCallback_t
*info
= (void *)msg
->m_pubParam
;
188 vg_info( " Connection status changed for %lu\n", info
->m_hConn
);
190 vg_info( " %s -> %s\n",
191 string_ESteamNetworkingConnectionState(info
->m_eOldState
),
192 string_ESteamNetworkingConnectionState(info
->m_info
.m_eState
) );
194 if( info
->m_info
.m_eState
==k_ESteamNetworkingConnectionState_Connecting
){
195 new_client_connecting( info
->m_hConn
);
198 if( (info
->m_info
.m_eState
==
199 k_ESteamNetworkingConnectionState_ClosedByPeer
) ||
200 (info
->m_info
.m_eState
==
201 k_ESteamNetworkingConnectionState_ProblemDetectedLocally
) ){
203 int client_id
= gameserver_client_index( info
->m_hConn
);
204 if( client_id
!= -1 ){
205 struct gameserver_client
*client
= &gameserver
.clients
[client_id
];
206 client
->connection
= 0;
208 gameserver_player_leave(client_id
);
211 vg_info( "End reason: %d\n", info
->m_info
.m_eEndReason
);
212 SteamAPI_ISteamNetworkingSockets_CloseConnection(
213 hSteamNetworkingSockets
, info
->m_hConn
, 0, NULL
, 0 );
217 static void gameserver_rx_auth( SteamNetworkingMessage_t
*msg
){
218 if( gameserver
.auth_mode
!= eServerModeAuthentication
){
219 vg_error( "Running server without authentication. "
220 "Connection %u tried to authenticate.\n", msg
->m_conn
);
224 if( get_connection_authsteamid( msg
) != k_connection_unauthorized
){
225 vg_warn( "Already authorized this user but app ticket was sent"
226 " again (%u)\n", msg
->m_conn
);
230 vg_low( "Attempting to verify user\n" );
232 if( msg
->m_cbSize
< sizeof(netmsg_auth
) ){
233 vg_error( "Malformed auth ticket, too small (%u)\n", msg
->m_conn
);
237 netmsg_auth
*auth
= msg
->m_pData
;
239 if( msg
->m_cbSize
< sizeof(netmsg_auth
)+auth
->ticket_length
||
240 auth
->ticket_length
> 1024 ){
241 vg_error( "Malformed auth ticket, ticket_length incorrect (%u)\n",
242 auth
->ticket_length
);
247 u32 ticket_len
= 1024;
249 int success
= SteamEncryptedAppTicket_BDecryptTicket(
250 auth
->ticket
, auth
->ticket_length
, decrypted
,
251 &ticket_len
, gameserver
.app_symmetric_key
,
252 k_nSteamEncryptedAppTicketSymmetricKeyLen
);
255 vg_error( "Failed to decrypt users ticket (client %u)\n", msg
->m_conn
);
256 vg_error( " ticket length: %u\n", auth
->ticket_length
);
258 SteamAPI_ISteamNetworkingSockets_CloseConnection(
259 hSteamNetworkingSockets
,
260 msg
->m_conn
, 0, NULL
, 1 );
264 if( SteamEncryptedAppTicket_GetTicketIssueTime( decrypted
, ticket_len
)){
265 RTime32 ctime
= time(NULL
),
266 tickettime
= SteamEncryptedAppTicket_GetTicketIssueTime(
267 decrypted
, ticket_len
),
268 expiretime
= tickettime
+ 24*3*60*60;
270 if( ctime
> expiretime
){
271 vg_error( "Ticket expired (client %u)\n", msg
->m_conn
);
273 /* TODO: Send expired information */
274 SteamAPI_ISteamNetworkingSockets_CloseConnection(
275 hSteamNetworkingSockets
,
276 msg
->m_conn
, 0, NULL
, 1 );
282 SteamEncryptedAppTicket_GetTicketSteamID( decrypted
, ticket_len
, &steamid
);
283 vg_success( "User is authenticated! steamid %lu (%u)\n",
284 steamid
.m_unAll64Bits
, msg
->m_conn
);
286 set_connection_authsteamid( msg
->m_conn
, steamid
.m_unAll64Bits
);
289 static int inet_require_auth( SteamNetworkingMessage_t
*msg
){
290 if( gameserver
.auth_mode
== eServerModeNoAuthentication
)
293 if( get_connection_authsteamid( msg
) == k_connection_unauthorized
){
294 vg_warn( "Unauthorized request! Disconnecting client: %u\n",
297 SteamAPI_ISteamNetworkingSockets_CloseConnection(
298 hSteamNetworkingSockets
,
299 msg
->m_conn
, 0, NULL
, 1 );
307 * Player updates sent to us
308 * -----------------------------------------------------------------------------
311 static int packet_minsize( SteamNetworkingMessage_t
*msg
, u32 size
){
312 if( msg
->m_cbSize
< size
) {
313 vg_error( "Invalid packet size (must be at least %u)\n", size
);
321 static void gameserver_rx_200_300( SteamNetworkingMessage_t
*msg
){
322 netmsg_blank
*tmp
= msg
->m_pData
;
324 int client_id
= gameserver_client_index( msg
->m_conn
);
325 if( client_id
== -1 ) return;
327 if( tmp
->inetmsg_id
== k_inetmsg_playerusername
){
328 if( !packet_minsize( msg
, sizeof(netmsg_playerusername
)+1 ))
331 struct gameserver_client
*client
= &gameserver
.clients
[ client_id
];
332 netmsg_playerusername
*src
= msg
->m_pData
;
334 u32 name_len
= network_msgstring( src
->name
, msg
->m_cbSize
,
335 sizeof(netmsg_playerusername
),
337 NETWORK_USERNAME_MAX
);
339 /* update other users about this change */
340 netmsg_playerusername
*prop
= alloca(sizeof(netmsg_playerusername
)+
341 NETWORK_USERNAME_MAX
);
343 prop
->inetmsg_id
= k_inetmsg_playerusername
;
344 prop
->index
= client_id
;
345 u32 chs
= vg_strncpy( client
->username
, prop
->name
, NETWORK_USERNAME_MAX
,
346 k_strncpy_always_add_null
);
348 vg_info( "client #%d changed name to: %s\n", client_id
, prop
->name
);
350 u32 propsize
= sizeof(netmsg_playerusername
) + chs
+ 1;
351 gameserver_send_to_all( client_id
, prop
, propsize
,
352 k_nSteamNetworkingSend_Reliable
);
354 else if( tmp
->inetmsg_id
== k_inetmsg_playerframe
){
356 netmsg_playerframe
*frame
= alloca(msg
->m_cbSize
);
357 memcpy( frame
, msg
->m_pData
, msg
->m_cbSize
);
358 frame
->client
= client_id
;
359 gameserver_send_to_all( client_id
, frame
, msg
->m_cbSize
,
360 k_nSteamNetworkingSend_Unreliable
);
362 else if( tmp
->inetmsg_id
== k_inetmsg_playeritem
){
363 netmsg_playeritem
*item
= msg
->m_pData
;
366 struct gameserver_client
*client
= &gameserver
.clients
[ client_id
];
368 if( item
->type_index
>= k_netmsg_playeritem_max
){
369 vg_warn( "Client #%d invalid equip type %u\n",
370 client_id
, (u32
)item
->type_index
);
374 char *dest
= client
->items
[ item
->type_index
];
376 network_msgstring( item
->uid
, msg
->m_cbSize
, sizeof(netmsg_playeritem
),
377 dest
, ADDON_UID_MAX
);
379 vg_info( "Client #%d equiped: [%s] %s\n",
381 (const char *[]){[k_netmsg_playeritem_board
]="board",
382 [k_netmsg_playeritem_player
]="player",
383 [k_netmsg_playeritem_world0
]="world0",
384 [k_netmsg_playeritem_world1
]="world1"
385 }[item
->type_index
], item
->uid
);
388 netmsg_playeritem
*prop
= alloca(msg
->m_cbSize
);
389 memcpy( prop
, msg
->m_pData
, msg
->m_cbSize
);
390 prop
->client
= client_id
;
391 gameserver_send_to_all( client_id
, prop
, msg
->m_cbSize
,
392 k_nSteamNetworkingSend_Reliable
);
397 static void on_inet_score_request( SteamNetworkingMessage_t
*msg
){
398 if( !inet_require_auth(msg
) ) return;
400 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
401 hSteamNetworkingSockets
, msg
->m_conn
,
402 &scoreboard_client_data
, sizeof(netmsg_scoreboard
),
403 k_nSteamNetworkingSend_Reliable
, NULL
);
406 static void on_inet_set_nickname( SteamNetworkingMessage_t
*msg
){
407 if(!inet_require_auth(msg
)) return;
409 u64_steamid steamid
= get_connection_authsteamid(msg
);
410 netmsg_set_nickname
*setnick
= msg
->m_pData
;
411 if( msg
->m_cbSize
< sizeof(netmsg_set_nickname
) ){
412 vg_warn( "Invalid nickname request from client: %u, steamid: %lu\n",
413 msg
->m_conn
, steamid
);
417 highscore_set_user_nickname( steamid
, setnick
->nickname
);
420 static void on_inet_set_score( SteamNetworkingMessage_t
*msg
){
421 if(!inet_require_auth(msg
)) return;
423 u64_steamid steamid
= get_connection_authsteamid(msg
);
425 if( msg
->m_cbSize
< sizeof(netmsg_set_score
) ){
426 vg_warn( "Invalid set score post from client: %u, steamid: %lu\n",
427 msg
->m_conn
, steamid
);
431 netmsg_set_score
*info
= msg
->m_pData
;
433 if( msg
->m_cbSize
< sizeof(netmsg_set_score
) +
434 sizeof(struct netmsg_score_record
)*info
->record_count
){
435 vg_warn( "Malformed set score post from client: %u, steamid: %lu\n",
436 msg
->m_conn
, steamid
);
440 for( int i
=0; i
<info
->record_count
; i
++ ){
441 highscore_record temp
;
442 temp
.trackid
= info
->records
[i
].trackid
;
443 temp
.datetime
= time(NULL
);
444 temp
.playerid
= steamid
;
445 temp
.points
= info
->records
[i
].points
;
446 temp
.time
= info
->records
[i
].time
;
448 highscores_push_record( &temp
);
453 static void poll_connections(void){
454 SteamNetworkingMessage_t
*messages
[32];
458 len
= SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup(
459 hSteamNetworkingSockets
,
460 gameserver
.client_group
, messages
, vg_list_size(messages
) );
465 for( int i
=0; i
<len
; i
++ ){
466 SteamNetworkingMessage_t
*msg
= messages
[i
];
468 if( msg
->m_cbSize
< sizeof(netmsg_blank
) ){
469 vg_warn( "Discarding message (too small: %d)\n",
474 netmsg_blank
*tmp
= msg
->m_pData
;
476 if( (tmp
->inetmsg_id
>= 200) && (tmp
->inetmsg_id
< 300) ){
477 gameserver_rx_200_300( msg
);
480 if( tmp
->inetmsg_id
== k_inetmsg_auth
)
481 gameserver_rx_auth( msg
);
483 else if( tmp
->inetmsg_id
== k_inetmsg_scores_request
)
484 on_inet_score_request( msg
);
485 else if( tmp
->inetmsg_id
== k_inetmsg_set_nickname
)
486 on_inet_set_nickname( msg
);
487 else if( tmp
->inetmsg_id
== k_inetmsg_set_score
)
488 on_inet_set_score( msg
);
489 else if( tmp
->inetmsg_id
== k_inetmsg_playerframe
)
490 on_inet_playerframe( msg
);
493 vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
499 SteamAPI_SteamNetworkingMessage_t_Release( msg
);
504 static u64
seconds_to_server_ticks( double s
){
508 static void generate_boards(void){
509 FILE *fp
= fopen( "www/html/srhighscores.txt", "w" );
512 vg_error( "Can't write boards to www/html/srhighscores.txt\n" );
516 for( int i
=0; i
<vg_list_size(track_infos
); i
++ ){
517 struct netmsg_board
*board
= &scoreboard_client_data
.boards
[i
];
519 highscores_board_generate( board
->data
, i
, 10 );
520 highscores_board_printf( fp
, board
->data
, 10 );
526 int main( int argc
, char *argv
[] ){
527 signal( SIGINT
, inthandler
);
528 signal( SIGQUIT
, inthandler
);
529 signal( SIGPIPE
, SIG_IGN
);
532 while( vg_argp( argc
, argv
) ){
533 if( vg_long_opt( "noauth" ) )
534 gameserver
.auth_mode
= eServerModeNoAuthentication
;
537 /* TODO: Options to override, ammend, remove etc */
539 vg_set_mem_quota( 80*1024*1024 );
542 highscores_init( 250000, 10000 );
544 if( !highscores_read() )
545 highscores_create_db();
547 steamworks_ensure_txt( "2103940" );
549 if( gameserver
.auth_mode
== eServerModeAuthentication
){
550 if( !vg_load_steam_symetric_key( "application_key",
551 gameserver
.app_symmetric_key
)){
556 vg_warn( "Running without user authentication.\n" );
559 if( !SteamGameServer_Init( 0, 27400, 27401,
560 gameserver
.auth_mode
, "1.0.0.0" ) ){
561 vg_error( "SteamGameServer_Init failed\n" );
565 void *hSteamGameServer
= SteamAPI_SteamGameServer();
566 SteamAPI_ISteamGameServer_LogOnAnonymous( hSteamGameServer
);
568 SteamAPI_ManualDispatch_Init();
569 HSteamPipe hsteampipe
= SteamGameServer_GetHSteamPipe();
571 //hSteamHTTP = SteamAPI_SteamGameServerHTTP();
572 hSteamNetworkingSockets
=
573 SteamAPI_SteamGameServerNetworkingSockets_SteamAPI();
579 steam_register_callback( k_iSteamNetAuthenticationStatus
, on_auth_status
);
580 steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack
,
583 vg_success( "Steamworks API running\n" );
584 steamworks_event_loop( hsteampipe
);
590 HSteamListenSocket listener
;
591 SteamNetworkingIPAddr localAddr
;
592 SteamAPI_SteamNetworkingIPAddr_Clear( &localAddr
);
593 localAddr
.m_port
= 27402;
595 listener
= SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP(
596 hSteamNetworkingSockets
, &localAddr
, 0, NULL
);
597 gameserver
.client_group
= SteamAPI_ISteamNetworkingSockets_CreatePollGroup(
598 hSteamNetworkingSockets
);
600 u64 server_ticks
= 8000,
601 last_record_save
= 8000,
602 last_scoreboard_gen
= 0,
603 last_monitor_heartbeat
= 0;
606 monitor_start_server();
609 monitor_event_loop();
610 steamworks_event_loop( hsteampipe
);
617 (last_monitor_heartbeat
+ seconds_to_server_ticks(10.0))){
618 last_monitor_heartbeat
= server_ticks
;
622 if( server_ticks
> last_scoreboard_gen
+ seconds_to_server_ticks(60.0) ){
623 last_scoreboard_gen
= server_ticks
;
627 if( server_ticks
> last_record_save
+ seconds_to_server_ticks(10.0*60.0)){
628 last_record_save
= server_ticks
;
629 highscores_serialize_all();
633 highscores_serialize_all();
635 SteamAPI_ISteamNetworkingSockets_DestroyPollGroup( hSteamNetworkingSockets
,
636 gameserver
.client_group
);
637 SteamAPI_ISteamNetworkingSockets_CloseListenSocket(
638 hSteamNetworkingSockets
, listener
);
640 vg_info( "Shutting down\n..." );
641 SteamGameServer_Shutdown();