server.c

   1 // Copyright (C) 2021 Harry Godden (hgn) - All Rights Reserved
   2
   3 /*
   4  * This server application requires steamclient.so to be present in the
   5  * executable directory. This is not provided by vg system, it must be
   6  * downloaded via steamcmd. It will likely be somewhere in /usr/.steam/ ...
   7  */
   8
   9 #define _DEFAULT_SOURCE
  10 #include <unistd.h>
  11 #include <signal.h>
  12
  13 volatile sig_atomic_t sig_stop;
  14
  15 void inthandler( int signum )
  16 {
  17    sig_stop = 1;
  18 }
  19
  20 #define VG_SERVER
  21 #include "vg/vg.h"
  22 #include "vg/vg_steam.h"
  23 #include "vg/vg_steam_networking.h"
  24 #include "vg/vg_steam_http.h"
  25 #include "vg/vg_steam_auth.h"
  26 #include "network_msg.h"
  27
  28 void  *hSteamHTTP,
  29       *hSteamNetworkingSockets;
  30
  31 u8 steam_symetric_key[ k_nSteamEncryptedAppTicketSymmetricKeyLen ];
  32 HSteamNetPollGroup client_pollgroup;
  33
  34 static void recieve_http( void *callresult, void *context )
  35 {
  36    HTTPRequestCompleted_t *result = callresult;
  37
  38    HTTPRequestHandle request = result->m_hRequest;
  39    u32 size = 0;
  40
  41    SteamAPI_ISteamHTTP_GetHTTPResponseBodySize( hSteamHTTP, request, &size );
  42
  43    u8 *buffer = malloc( size );
  44    SteamAPI_ISteamHTTP_GetHTTPResponseBodyData(
  45          hSteamHTTP, request, buffer, size );
  46
  47    buffer[size-1] = '\0';
  48    vg_info( "%s\n", (char *)buffer );
  49
  50    free( buffer );
  51    SteamAPI_ISteamHTTP_ReleaseHTTPRequest( hSteamHTTP, result->m_hRequest );
  52 }
  53
  54 static void new_client_connecting( HSteamNetConnection client )
  55 {
  56    EResult accept_status = SteamAPI_ISteamNetworkingSockets_AcceptConnection(
  57             hSteamNetworkingSockets, client );
  58
  59    if( accept_status == k_EResultOK )
  60    {
  61       vg_success( "Accepted client (id: %u)\n", client );
  62       SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup(
  63             hSteamNetworkingSockets,
  64             client, client_pollgroup );
  65    }
  66    else
  67    {
  68       vg_warn( "Error accepting client (id: %u)\n", client );
  69    }
  70 }
  71
  72 static void handle_steam_callback( CallbackMsg_t *msg )
  73 {
  74    if( msg->m_iCallback == k_iSteamNetConnectionStatusChangedCallBack )
  75    {
  76       SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
  77       vg_info( "  Connection status changed for %lu\n", info->m_hConn );
  78
  79       vg_info( "  %s -> %s\n",
  80             string_ESteamNetworkingConnectionState(info->m_info.m_eState),
  81             string_ESteamNetworkingConnectionState(info->m_eOldState) );
  82
  83       if( info->m_info.m_eState==k_ESteamNetworkingConnectionState_Connecting )
  84       {
  85          new_client_connecting( info->m_hConn );
  86       }
  87    }
  88    else if( msg->m_iCallback == k_iSteamNetAuthenticationStatus )
  89    {
  90       SteamNetAuthenticationStatus_t *info = (void *)msg->m_pubParam;
  91       vg_info( "  Authentication availibility: %s\n",
  92             string_ESteamNetworkingAvailability(info->m_eAvail) );
  93       vg_info( "  %s\n", info->m_debugMsg );
  94    }
  95 }
  96
  97 static void poll_connections(void)
  98 {
  99    SteamNetworkingMessage_t *messages[32];
 100    int len;
 101
 102    while(1)
 103    {
 104       len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup(
 105             hSteamNetworkingSockets,
 106             client_pollgroup, messages, vg_list_size(messages) );
 107
 108       if( len <= 0 )
 109          return;
 110
 111       for( int i=0; i<len; i++ )
 112       {
 113          SteamNetworkingMessage_t *msg = messages[i];
 114
 115          if( msg->m_cbSize < sizeof(netmsg_blank) )
 116          {
 117             vg_warn( "Discarding message (too small: %d)\n",
 118                   msg->m_cbSize );
 119             continue;
 120          }
 121
 122          netmsg_blank *tmp = msg->m_pData;
 123          if( tmp->inetmsg_id == k_inetmsg_scores_request )
 124          {
 125             vg_log( "Recieved score request, sending records. (id: %u)\n",
 126                      msg->m_conn );
 127
 128             /* Send back current scores */
 129             u32 data_size = sizeof(netmsg_scores_info) +
 130                               0*sizeof(struct netmsg_score_record);
 131             netmsg_scores_info *return_info = malloc( data_size );
 132
 133             return_info->inetmsg_id = k_inetmsg_scores_info;
 134             return_info->record_count = 0;
 135
 136             SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 137                   hSteamNetworkingSockets, msg->m_conn,
 138                   return_info, data_size,
 139                   k_nSteamNetworkingSend_Reliable, NULL );
 140          }
 141
 142          SteamAPI_SteamNetworkingMessage_t_Release( msg );
 143       }
 144    }
 145 }
 146
 147 int main( int argc, char *argv[] )
 148 {
 149    steamworks_ensure_txt( "2103940" );
 150
 151    signal( SIGINT, inthandler );
 152
 153    if( !vg_load_steam_symetric_key( "application_key", steam_symetric_key ) )
 154       return 0;
 155
 156    if( !SteamGameServer_Init( 0, 27400, 27401, eServerModeAuthentication,
 157                               "1.0.0.0" ) )
 158    {
 159       vg_error( "SteamGameServer_Init failed\n" );
 160       return 0;
 161    }
 162
 163    void *hSteamGameServer = SteamAPI_SteamGameServer();
 164    SteamAPI_ISteamGameServer_LogOnAnonymous( hSteamGameServer );
 165
 166    SteamAPI_ManualDispatch_Init();
 167    HSteamPipe hsteampipe = SteamGameServer_GetHSteamPipe();
 168
 169    //hSteamHTTP = SteamAPI_SteamGameServerHTTP();
 170    hSteamNetworkingSockets =
 171       SteamAPI_SteamGameServerNetworkingSockets_SteamAPI();
 172
 173    /*
 174     * Server code
 175     */
 176
 177    vg_success( "Steamworks API running\n" );
 178    steamworks_event_loop( hsteampipe, handle_steam_callback );
 179
 180    /*
 181     * Create a listener
 182     */
 183
 184    HSteamListenSocket listener;
 185    SteamNetworkingIPAddr localAddr;
 186    SteamAPI_SteamNetworkingIPAddr_Clear( &localAddr );
 187    localAddr.m_port = 27402;
 188
 189    listener = SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP(
 190                   hSteamNetworkingSockets, &localAddr, 0, NULL );
 191    client_pollgroup = SteamAPI_ISteamNetworkingSockets_CreatePollGroup(
 192          hSteamNetworkingSockets );
 193
 194 #if 0
 195    HTTPRequestHandle test_req = SteamAPI_ISteamHTTP_CreateHTTPRequest(
 196          hSteamHTTP, k_EHTTPMethodGET,
 197          "https://www.harrygodden.com/hello.txt" );
 198
 199    steam_async *call1 = steam_new_async();
 200    call1->data = NULL;
 201    call1->p_handler = recieve_http;
 202    SteamAPI_ISteamHTTP_SendHTTPRequest( hSteamHTTP, test_req, &call1->id );
 203 #endif
 204
 205    while( !sig_stop )
 206    {
 207       steamworks_event_loop( hsteampipe, handle_steam_callback );
 208       poll_connections();
 209
 210       usleep(100000);
 211    }
 212
 213    SteamAPI_ISteamNetworkingSockets_DestroyPollGroup( hSteamNetworkingSockets,
 214          client_pollgroup );
 215    SteamAPI_ISteamNetworkingSockets_CloseListenSocket(
 216          hSteamNetworkingSockets, listener );
 217
 218    vg_info( "Shutting down\n..." );
 219    SteamGameServer_Shutdown();
 220
 221    return 0;
 222 }