417 lines
12 KiB
C++
417 lines
12 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Deals with remote perf testing on customer machines
|
|
//
|
|
// $Workfile: $
|
|
// $NoKeywords: $
|
|
//===========================================================================//
|
|
|
|
#include "server_pch.h"
|
|
#include "cl_rcon.h"
|
|
#include "cl_steamauth.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#ifdef ENABLE_RPT
|
|
//-----------------------------------------------------------------------------
|
|
// Remote perf testing
|
|
//
|
|
// Description: Here's how rpt works. The 'customer' machine is the one
|
|
// we want to do testing on. The 'valve' machine is the programmer machine
|
|
// that has rcon access to the customer machine. The 'server' machine is the
|
|
// machine running a dedicated or listen server which both the customer + valve
|
|
// machines are connected to.
|
|
//
|
|
// Step 0) Customer runs with -rpt on the commandline, which turns on -condebug,
|
|
// clears out the console.log, and potentially other things.
|
|
//
|
|
// Step 1) Customer machine types rpt_password <password>. We store the password
|
|
// on the customer machine only and never forward it to the server to avoid
|
|
// having to worry about malicious servers. The password is stored in the RPTServer
|
|
// password The customer machine then forwards
|
|
// a command "rpt_client_enable 1" to the server indicating that it is a client
|
|
// which can be controlled via rpt.
|
|
//
|
|
// Step 2) Server machine receives the "rpt_client_enable 1" command. It stores
|
|
// some state indicating the client it received that message from can be rpt controlled.
|
|
//
|
|
// Step 3) Valve machine types rpt_start <password> [<port #>]. The port specification
|
|
// is optional. The valve machine's rpt rcon client puts itself into a listening
|
|
// mode, waiting for connection requests from the customer machine. Once
|
|
// connected, the RPTClient rcon client will be the mechanism by which the valve
|
|
// machine sends rcon commands to the customer machine. After this is done,
|
|
// the Valve machine sends a command "rpt_server_enable 1" to the server, indicating
|
|
// it wishes to connect to an rpt_client.
|
|
//
|
|
// Step 4) Server machine receives the 'rpt_server_enable 1' command. This
|
|
// command can only be received from IP addresses we know are at Valve,
|
|
// and from steam clients in the Valve group. This will turn cheats on on the
|
|
// server and will forward a message to the customer machine 'rpt_connect <valve ip address>'.
|
|
// It will only try to send this message to a client which has previously
|
|
// enabled rpt with the 'rpt_client_enable 1' command.
|
|
//
|
|
// Step 5) Customer machine receives the 'rpt_connect' command. This command
|
|
// can only work if the ip address specified comes from IP addresses we know
|
|
// are at Valve. The customer machine then attempts to connect to the RPTClient
|
|
// on the Valve machine, which establishes the connection to the customer
|
|
// RPTServer. The rcon classes will handle password authentication.
|
|
//
|
|
// Step 6) Valve machine types rpt <console commands> which are then sent
|
|
// to the customer machine through the custom tcp connection set up by the previous steps
|
|
//
|
|
// Step 7) Customer types 'rpt_password' with no password, which sends the
|
|
// message to the server 'rpt_client_enable 0'.
|
|
//
|
|
// Step 8) Server receives 'rpt_client_enable 0', which marks it as not
|
|
// willing to accept rpt connections. Future attempts to connect via
|
|
// 'rpt_server_enable 1' will fail.
|
|
//
|
|
// Step 9) Valve machine types rpt_end, which sends a command 'rpt_server_enable 0'
|
|
// to the server, which deactivates cheats on the server. It also disconnects
|
|
// the tcp connection to the customer machine.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static int g_nRptClientSlot = -1;
|
|
static int g_nRptServerSlot = -1;
|
|
|
|
|
|
// NOTE: This is expected to be executed by the customer, using rpt_password <password>
|
|
// This data will be stored in the client only. Server doesn't get access to the password
|
|
// to prevent malicious servers from running nasty commands on clients
|
|
#ifndef SWDS
|
|
|
|
CON_COMMAND_F( rpt_password, "", FCVAR_DONTRECORD | FCVAR_HIDDEN )
|
|
{
|
|
if ( CommandLine()->FindParm( "-rpt" ) == 0 )
|
|
{
|
|
ConMsg( "This command will not work unless the game is launched with -rpt\n" );
|
|
return;
|
|
}
|
|
|
|
if ( args.ArgC() > 2 )
|
|
{
|
|
ConMsg( "Incorrect # of arguments.\n" );
|
|
return;
|
|
}
|
|
|
|
// Doesn't work on dedicated servers
|
|
if ( NET_IsDedicated() || !NET_IsMultiplayer() || ( args.ArgC() > 2 ) )
|
|
{
|
|
ConMsg( "Failed!\n" );
|
|
return;
|
|
}
|
|
|
|
bool bWasEnabled = RPTServer().HasPassword();
|
|
char buf[255];
|
|
if ( args.ArgC() == 1 )
|
|
{
|
|
if ( !bWasEnabled )
|
|
return;
|
|
|
|
RPTServer().SetPassword( NULL );
|
|
ConMsg( "Disabling...\n" );
|
|
Q_snprintf( buf, sizeof( buf ), "rpt_client_enable 0" );
|
|
}
|
|
else if ( args.ArgC() == 2 )
|
|
{
|
|
RPTServer().SetPassword( args.Arg( 1 ) );
|
|
ConMsg( "New password : %s\n", args.Arg( 1 ) );
|
|
if ( bWasEnabled )
|
|
return;
|
|
|
|
ConMsg( "Enabling...\n" );
|
|
Q_snprintf( buf, sizeof( buf ), "rpt_client_enable 1" );
|
|
}
|
|
|
|
// Send a command to the server indicating this client can be rpted
|
|
CCommand argsClient;
|
|
argsClient.Tokenize( buf );
|
|
Cmd_ForwardToServer( argsClient, true );
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
// NOTE: This is autogenerated by clients typing rpt_password. The client keeps the
|
|
// password, but tells the server it can be rpted. Only 1 client can be rpted at a time.
|
|
CON_COMMAND_F( rpt_client_enable, "", FCVAR_DONTRECORD | FCVAR_HIDDEN | FCVAR_CLIENTCMD_CAN_EXECUTE )
|
|
{
|
|
if ( args.ArgC() != 2 )
|
|
return;
|
|
|
|
if ( cmd_clientslot < 0 )
|
|
return;
|
|
|
|
CGameClient *pClient = sv.Client( cmd_clientslot );
|
|
if ( !pClient )
|
|
return;
|
|
|
|
bool bEnable = ( atoi( args.Arg( 1 ) ) != 0 );
|
|
g_nRptClientSlot = bEnable ? cmd_clientslot : -1;
|
|
}
|
|
|
|
void SV_NotifyRPTOfDisconnect( int nClientSlot )
|
|
{
|
|
if ( nClientSlot == g_nRptClientSlot )
|
|
{
|
|
g_nRptClientSlot = -1;
|
|
}
|
|
|
|
if ( nClientSlot == g_nRptServerSlot )
|
|
{
|
|
g_nRptServerSlot = -1;
|
|
}
|
|
|
|
RPTServer().SetPassword( NULL );
|
|
#ifndef SWDS
|
|
RPTClient().SetPassword( NULL );
|
|
RPTClient().CloseListenSocket( );
|
|
#endif
|
|
}
|
|
|
|
#ifndef SWDS
|
|
|
|
void CL_NotifyRPTOfDisconnect( )
|
|
{
|
|
RPTServer().SetPassword( NULL );
|
|
RPTClient().SetPassword( NULL );
|
|
RPTClient().CloseListenSocket( );
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifndef SWDS
|
|
|
|
// This runs on the valve client machine
|
|
CON_COMMAND_F( rpt_start, "", FCVAR_DONTRECORD | FCVAR_HIDDEN )
|
|
{
|
|
if ( args.ArgC() < 2 || args.ArgC() > 3 )
|
|
{
|
|
ConMsg( "Incorrect # of arguments.\n" );
|
|
return;
|
|
}
|
|
|
|
// Listen for connections from the customer machine
|
|
netadr_t rptAddr = net_local_adr;
|
|
if ( args.ArgC() == 3 )
|
|
{
|
|
rptAddr.SetPort( atoi( args.Arg( 2 ) ) );
|
|
}
|
|
else
|
|
{
|
|
rptAddr.SetPort( PORT_RPT_LISTEN );
|
|
}
|
|
|
|
RPTClient().SetPassword( args.Arg( 1 ) );
|
|
RPTClient().CreateListenSocket( rptAddr );
|
|
|
|
char pDir[MAX_PATH];
|
|
#ifdef WIN32
|
|
int nDay, nMonth, nYear;
|
|
GetCurrentDate( &nDay, &nMonth, &nYear );
|
|
Q_snprintf( pDir, sizeof(pDir), "rpt/%d_%d_%d", nMonth, nDay, nYear );
|
|
#elif POSIX
|
|
time_t now = time(NULL);
|
|
struct tm *tm = localtime( &now );
|
|
Q_snprintf( pDir, sizeof(pDir), "rpt/%d_%d_%d", tm->tm_mon, tm->tm_wday, tm->tm_year + 1900 );
|
|
#else
|
|
#error
|
|
#endif
|
|
RPTClient().SetRemoteFileDirectory( pDir );
|
|
|
|
// Send a command to the server indicating we want to connect to a remote client
|
|
char pBuf[256];
|
|
Q_snprintf( pBuf, sizeof(pBuf), "rpt_server_enable 1 %s\n", rptAddr.ToString() );
|
|
CCommand argsClient;
|
|
argsClient.Tokenize( pBuf );
|
|
Cmd_ForwardToServer( argsClient, true );
|
|
}
|
|
|
|
CON_COMMAND_F( rpt_end, "", FCVAR_DONTRECORD | FCVAR_HIDDEN )
|
|
{
|
|
if ( args.ArgC() != 1 )
|
|
{
|
|
ConMsg( "Incorrect # of arguments.\n" );
|
|
return;
|
|
}
|
|
|
|
RPTClient().SetPassword( NULL );
|
|
RPTClient().CloseListenSocket( );
|
|
|
|
// Send a command to the server indicating we want to disconnect from a remote client
|
|
char pBuf[256];
|
|
Q_snprintf( pBuf, sizeof(pBuf), "rpt_server_enable 0\n" );
|
|
CCommand argsClient;
|
|
argsClient.Tokenize( pBuf );
|
|
Cmd_ForwardToServer( argsClient, true );
|
|
}
|
|
|
|
#endif
|
|
|
|
// This is the steam id for user 'remote_perf_test'. See wiki for password.
|
|
// http://intranet.valvesoftware.com/wiki/index.php/Debugging_problems_on_customer_machines
|
|
static uint64 s_ValveMask = 0xFAB2423BFFA352AFull;
|
|
static uint64 s_pValveIDs[] =
|
|
{
|
|
76561197995463203ll ^ s_ValveMask,
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
static bool IsValveIPAddress( const netadr_t &adr )
|
|
{
|
|
// Only accept this from clients inside of valve
|
|
netadr_t valveIP1, valveIP2;
|
|
valveIP1.SetIP( 0xCF, 0xAD, 0xB2, 0xFF );
|
|
valveIP2.SetIP( 0xCF, 0xAD, 0xB3, 0xFF );
|
|
return ( adr.CompareClassCAdr( valveIP1 ) || adr.CompareClassCAdr( valveIP2 ) || adr.IsLoopback() );
|
|
}
|
|
|
|
static bool PlayerIsValveEmployee( int nClientSlot )
|
|
{
|
|
CGameClient *pClient = sv.Client( nClientSlot );
|
|
if ( !pClient )
|
|
return false;
|
|
|
|
const netadr_t& adr = pClient->m_NetChannel->GetRemoteAddress();
|
|
if ( !IsValveIPAddress( adr ) )
|
|
return false;
|
|
|
|
// If Steam is running and connected to beta, player is valve
|
|
if ( k_EUniverseBeta == GetSteamUniverse() )
|
|
return true;
|
|
|
|
if ( !pClient->IsFullyAuthenticated() )
|
|
return false;
|
|
|
|
player_info_t pi;
|
|
if ( !sv.GetPlayerInfo( nClientSlot, &pi ) )
|
|
return false;
|
|
|
|
if ( !pi.friendsID )
|
|
return false;
|
|
|
|
CSteamID steamIDForPlayer( pi.friendsID, 1, k_EUniversePublic, k_EAccountTypeIndividual );
|
|
for ( int i = 0; i < ARRAYSIZE(s_pValveIDs); i++ )
|
|
{
|
|
if ( steamIDForPlayer.ConvertToUint64() == (s_pValveIDs[i] ^ s_ValveMask) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// NOTE: This is expected to be called on the server as a result of rpt running
|
|
CON_COMMAND_F( rpt_server_enable, "", FCVAR_DONTRECORD | FCVAR_HIDDEN | FCVAR_CLIENTCMD_CAN_EXECUTE )
|
|
{
|
|
if ( args.ArgC() != 5 && args.ArgC() != 2 )
|
|
return;
|
|
|
|
if ( cmd_clientslot < 0 )
|
|
return;
|
|
|
|
if ( g_nRptServerSlot >= 0 && g_nRptServerSlot != cmd_clientslot )
|
|
return;
|
|
|
|
if ( !PlayerIsValveEmployee( cmd_clientslot ) )
|
|
return;
|
|
|
|
if ( g_nRptClientSlot < 0 )
|
|
{
|
|
ConMsg( "No valid clients.\n" );
|
|
g_nRptServerSlot = -1;
|
|
return;
|
|
}
|
|
|
|
bool bEnable = atoi( args.Arg( 1 ) ) != 0;
|
|
if ( !bEnable )
|
|
{
|
|
g_nRptServerSlot = -1;
|
|
return;
|
|
}
|
|
|
|
// Tell the customer machine to connect to the ip specified if the password matches
|
|
CGameClient *pClient = sv.Client( cmd_clientslot );
|
|
netadr_t adr( args.Arg( 2 ) );
|
|
netadr_t adrClient = pClient->m_NetChannel->GetRemoteAddress();
|
|
if ( !adrClient.IsLoopback() && !adr.CompareAdr( adrClient, true ) )
|
|
{
|
|
ConMsg( "Invalid server IP address.\n" );
|
|
return;
|
|
}
|
|
|
|
adr.SetPort( atoi( args.Arg( 4 ) ) );
|
|
|
|
// NOTE: Trickiness. Need to activate cheats, and that *must* be controlled via
|
|
// the server in a method protected by IP checks.
|
|
if ( g_nRptServerSlot < 0 )
|
|
{
|
|
g_nRptServerSlot = cmd_clientslot;
|
|
}
|
|
|
|
char pBuf[256];
|
|
Q_snprintf( pBuf, sizeof(pBuf), "rpt_connect %s\n", adr.ToString() );
|
|
SV_ExecuteRemoteCommand( pBuf, g_nRptClientSlot );
|
|
}
|
|
|
|
#ifndef SWDS
|
|
|
|
// NOTE: This executes on the client, and is generated by the server automatically
|
|
// when another client tries to connect
|
|
CON_COMMAND_F( rpt_connect, "", FCVAR_DONTRECORD | FCVAR_HIDDEN | FCVAR_SERVER_CAN_EXECUTE )
|
|
{
|
|
if ( CommandLine()->FindParm( "-rpt" ) == 0 )
|
|
return;
|
|
|
|
if ( args.ArgC() != 4 )
|
|
return;
|
|
|
|
const char *pAddress = args.Arg( 1 );
|
|
netadr_t adr( pAddress );
|
|
adr.SetPort( atoi( args.Arg( 3 ) ) );
|
|
|
|
// Only accept this from clients inside of valve
|
|
if ( !IsValveIPAddress( adr ) )
|
|
return;
|
|
|
|
RPTServer().ConnectToListeningClient( adr, true );
|
|
}
|
|
|
|
|
|
// Method to run rcon commands on an rpt-controlled machine
|
|
CON_COMMAND_F( rpt, "Issue an rpt command.", FCVAR_DONTRECORD | FCVAR_HIDDEN )
|
|
{
|
|
char message[1024]; // Command message
|
|
char szParam[ 256 ];
|
|
message[0] = 0;
|
|
for (int i=1 ; i<args.ArgC() ; i++)
|
|
{
|
|
const char *pParam = args[i];
|
|
// put quotes around empty arguments so we can pass things like this: rcon sv_password ""
|
|
// otherwise the "" on the end is lost
|
|
if ( strchr( pParam, ' ' ) || ( Q_strlen( pParam ) == 0 ) )
|
|
{
|
|
Q_snprintf( szParam, sizeof( szParam ), "\"%s\"", pParam );
|
|
Q_strncat( message, szParam, sizeof( message ), COPY_ALL_CHARACTERS );
|
|
}
|
|
else
|
|
{
|
|
Q_strncat( message, pParam, sizeof( message ), COPY_ALL_CHARACTERS );
|
|
}
|
|
if ( i != ( args.ArgC() - 1 ) )
|
|
{
|
|
Q_strncat (message, " ", sizeof( message ), COPY_ALL_CHARACTERS);
|
|
}
|
|
}
|
|
|
|
RPTClient().SendCmd( message );
|
|
}
|
|
|
|
|
|
#endif // SWDS
|
|
|
|
#endif // ENABLE_RPT
|