You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
826 lines
22 KiB
826 lines
22 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: implementation of the rcon client |
|
// |
|
//===========================================================================// |
|
|
|
// If we are going to include winsock.h then we need to disable protected_things.h |
|
// or else we get many warnings. |
|
#undef PROTECTED_THINGS_ENABLE |
|
#include "tier0/platform.h" |
|
#ifdef POSIX |
|
#include "net_ws_headers.h" |
|
#define WSAGetLastError() errno |
|
#else |
|
#if !defined( _X360 ) |
|
#include <winsock.h> |
|
#else |
|
#include "winsockx.h" |
|
#endif |
|
#undef SetPort // winsock screws with the SetPort string... *sigh*8 |
|
#endif |
|
|
|
#include <tier0/dbg.h> |
|
#include "utlbuffer.h" |
|
#include "cl_rcon.h" |
|
#include "vprof_engine.h" |
|
#include "proto_oob.h" // PORT_RCON define |
|
#include "cmd.h" |
|
#include "tier2/fileutils.h" |
|
#include "zip/XUnzip.h" |
|
|
|
|
|
#if defined( _X360 ) |
|
#include "xbox/xbox_win32stubs.h" |
|
#endif |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
static CRConClient g_RCONClient; |
|
CRConClient & RCONClient() |
|
{ |
|
return g_RCONClient; |
|
} |
|
|
|
#ifdef ENABLE_RPT |
|
class CRPTClient : public CRConClient |
|
{ |
|
typedef CRConClient BaseClass; |
|
|
|
public: |
|
virtual void OnSocketAccepted( SocketHandle_t hSocket, const netadr_t & netAdr, void** ppData ) |
|
{ |
|
BaseClass::OnSocketAccepted( hSocket, netAdr, ppData ); |
|
|
|
// Immediately try to start vprofiling |
|
// Also, enable cheats on this client only |
|
Cmd_SetRptActive( true ); |
|
StartVProfData(); |
|
} |
|
|
|
virtual void OnSocketClosed( SocketHandle_t hSocket, const netadr_t & netAdr, void* pData ) |
|
{ |
|
StopVProfData(); |
|
Cmd_SetRptActive( false ); |
|
BaseClass::OnSocketClosed( hSocket, netAdr, pData ); |
|
} |
|
}; |
|
|
|
static CRPTClient g_RPTClient; |
|
CRConClient & RPTClient() |
|
{ |
|
return g_RPTClient; |
|
} |
|
#endif // ENABLE_RPT |
|
|
|
static void RconAddressChanged_f( IConVar *pConVar, const char *pOldString, float flOldValue ) |
|
{ |
|
#ifndef SWDS |
|
ConVarRef var( pConVar ); |
|
netadr_t to; |
|
|
|
const char *cmdargs = var.GetString(); |
|
if ( ( !cmdargs || !cmdargs[ 0 ] ) && cl.m_NetChannel ) |
|
{ |
|
to = cl.m_NetChannel->GetRemoteAddress(); |
|
} |
|
else if ( !NET_StringToAdr( cmdargs, &to ) ) |
|
{ |
|
Msg( "Unable to resolve rcon address %s\n", var.GetString() ); |
|
return; |
|
} |
|
|
|
Msg( "Setting rcon_address: %s:%d\n", to.ToString( true ), to.GetPort() ); |
|
RCONClient().SetAddress( to ); |
|
#endif |
|
} |
|
|
|
static ConVar rcon_address( "rcon_address", "", FCVAR_SERVER_CANNOT_QUERY|FCVAR_DONTRECORD, "Address of remote server if sending unconnected rcon commands (format x.x.x.x:p) ", RconAddressChanged_f ); |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Implementation of remote vprof |
|
//----------------------------------------------------------------------------- |
|
CRConVProfExport::CRConVProfExport() |
|
{ |
|
} |
|
|
|
void CRConVProfExport::AddListener() |
|
{ |
|
} |
|
|
|
void CRConVProfExport::RemoveListener() |
|
{ |
|
} |
|
|
|
void CRConVProfExport::SetBudgetFlagsFilter( int filter ) |
|
{ |
|
} |
|
|
|
int CRConVProfExport::GetNumBudgetGroups() |
|
{ |
|
return m_Info.Count(); |
|
} |
|
|
|
void CRConVProfExport::GetBudgetGroupInfos( CExportedBudgetGroupInfo *pInfos ) |
|
{ |
|
memcpy( pInfos, m_Info.Base(), GetNumBudgetGroups() * sizeof(CExportedBudgetGroupInfo) ); |
|
} |
|
|
|
void CRConVProfExport::GetBudgetGroupTimes( float times[IVProfExport::MAX_BUDGETGROUP_TIMES] ) |
|
{ |
|
int nGroups = min( m_Times.Count(), (int)IVProfExport::MAX_BUDGETGROUP_TIMES ); |
|
memset( times, 0, nGroups * sizeof(float) ); |
|
nGroups = min( GetNumBudgetGroups(), nGroups ); |
|
memcpy( times, m_Times.Base(), nGroups * sizeof(float) ); |
|
} |
|
|
|
void CRConVProfExport::PauseProfile() |
|
{ |
|
// NOTE: This only has effect when testing on a listen server |
|
// it shouldn't do anything in the wild. When drawing the budget panel |
|
// this will cause the time spent doing so to not be counted |
|
VProfExport_Pause(); |
|
} |
|
|
|
void CRConVProfExport::ResumeProfile() |
|
{ |
|
// NOTE: This only has effect when testing on a listen server |
|
// it shouldn't do anything in the wild |
|
VProfExport_Resume(); |
|
} |
|
|
|
void CRConVProfExport::CleanupGroupData() |
|
{ |
|
int nCount = m_Info.Count(); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
delete m_Info[i].m_pName; |
|
} |
|
|
|
m_Info.RemoveAll(); |
|
} |
|
|
|
void CRConVProfExport::OnRemoteGroupData( const void *data, int len ) |
|
{ |
|
CUtlBuffer buf( data, len, CUtlBuffer::READ_ONLY ); |
|
int nFirstGroup = buf.GetInt(); |
|
|
|
if ( nFirstGroup == 0 ) |
|
{ |
|
CleanupGroupData(); |
|
} |
|
else |
|
{ |
|
Assert( nFirstGroup == m_Info.Count() ); |
|
} |
|
|
|
// NOTE: See WriteRemoteVProfGroupData in vprof_engine.cpp |
|
// to see the encoding of this data |
|
int nGroupCount = buf.GetInt(); |
|
int nBase = m_Info.AddMultipleToTail( nGroupCount ); |
|
char temp[1024]; |
|
for ( int i = 0; i < nGroupCount; ++i ) |
|
{ |
|
CExportedBudgetGroupInfo *pInfo = &m_Info[nBase + i]; |
|
|
|
unsigned char red, green, blue, alpha; |
|
red = buf.GetUnsignedChar( ); |
|
green = buf.GetUnsignedChar( ); |
|
blue = buf.GetUnsignedChar( ); |
|
alpha = buf.GetUnsignedChar( ); |
|
buf.GetString( temp ); |
|
int nLen = Q_strlen( temp ); |
|
|
|
pInfo->m_Color.SetColor( red, green, blue, alpha ); |
|
char *pBuf = new char[ nLen + 1 ]; |
|
pInfo->m_pName = pBuf; |
|
memcpy( pBuf, temp, nLen+1 ); |
|
pInfo->m_BudgetFlags = 0; |
|
} |
|
} |
|
|
|
void CRConVProfExport::OnRemoteData( const void *data, int len ) |
|
{ |
|
// NOTE: See WriteRemoteVProfData in vprof_engine.cpp |
|
// to see the encoding of this data |
|
int nCount = len / sizeof(float); |
|
Assert( nCount == m_Info.Count() ); |
|
|
|
CUtlBuffer buf( data, len, CUtlBuffer::READ_ONLY ); |
|
m_Times.SetCount( nCount ); |
|
memcpy( m_Times.Base(), data, nCount * sizeof(float) ); |
|
} |
|
|
|
|
|
CON_COMMAND( vprof_remote_start, "Request a VProf data stream from the remote server (requires authentication)" ) |
|
{ |
|
// TODO: Make this work (it might already!) |
|
// RCONClient().StartVProfData(); |
|
} |
|
|
|
CON_COMMAND( vprof_remote_stop, "Stop an existing remote VProf data request" ) |
|
{ |
|
// TODO: Make this work (it might already!) |
|
// RCONClient().StopVProfData(); |
|
} |
|
|
|
#ifdef ENABLE_RPT |
|
CON_COMMAND_F( rpt_screenshot, "", FCVAR_HIDDEN | FCVAR_DONTRECORD ) |
|
{ |
|
RPTClient().TakeScreenshot(); |
|
} |
|
|
|
CON_COMMAND_F( rpt_download_log, "", FCVAR_HIDDEN | FCVAR_DONTRECORD ) |
|
{ |
|
RPTClient().GrabConsoleLog(); |
|
} |
|
#endif // ENABLE_RPT |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
//----------------------------------------------------------------------------- |
|
#pragma warning ( disable : 4355 ) |
|
|
|
CRConClient::CRConClient() : m_Socket( this ) |
|
{ |
|
m_bAuthenticated = false; |
|
m_iAuthRequestID = 1; // must start at 1 |
|
m_iReqID = 0; |
|
m_nScreenShotIndex = 0; |
|
m_nConsoleLogIndex = 0; |
|
} |
|
|
|
#pragma warning ( default : 4355 ) |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Destructor |
|
//----------------------------------------------------------------------------- |
|
CRConClient::~CRConClient() |
|
{ |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Changes the password |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::SetPassword( const char *pPassword ) |
|
{ |
|
m_Socket.CloseAllAcceptedSockets(); |
|
m_Password = pPassword; |
|
} |
|
|
|
void CRConClient::SetRemoteFileDirectory( const char *pDir ) |
|
{ |
|
m_RemoteFileDir = pDir; |
|
m_nScreenShotIndex = 0; |
|
m_nConsoleLogIndex = 0; |
|
g_pFullFileSystem->CreateDirHierarchy( pDir, "MOD" ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: set the addresss of the remote server |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::SetAddress( const netadr_t &netAdr ) |
|
{ |
|
m_Socket.CloseAllAcceptedSockets(); |
|
m_Address = netAdr; |
|
if ( m_Address.GetPort() == 0 ) |
|
{ |
|
m_Address.SetPort( PORT_SERVER ); // override the port setting, by default rcon tries to bind to the same port as the server |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Inherited from ISocketCreatorListener |
|
//----------------------------------------------------------------------------- |
|
bool CRConClient::ShouldAcceptSocket( SocketHandle_t hSocket, const netadr_t & netAdr ) |
|
{ |
|
// Can't connect if we're already connected |
|
return !IsConnected(); |
|
} |
|
|
|
void CRConClient::OnSocketAccepted( SocketHandle_t hSocket, const netadr_t & netAdr, void** ppData ) |
|
{ |
|
} |
|
|
|
void CRConClient::OnSocketClosed( SocketHandle_t hSocket, const netadr_t & netAdr, void* pData ) |
|
{ |
|
// reset state |
|
m_bAuthenticated = false; |
|
m_iReqID = 0; |
|
m_iAuthRequestID = 1; // must start at 1 |
|
m_SendBuffer.Purge(); |
|
m_RecvBuffer.Purge(); |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Connects to the address specified by SetAddress |
|
//----------------------------------------------------------------------------- |
|
bool CRConClient::ConnectSocket() |
|
{ |
|
if ( m_Socket.ConnectSocket( m_Address, true ) < 0 ) |
|
{ |
|
Warning( "Unable to connect to remote server (%s)\n", m_Address.ToString() ); |
|
return false; |
|
} |
|
return true; |
|
} |
|
|
|
void CRConClient::CloseSocket() |
|
{ |
|
m_Socket.CloseAllAcceptedSockets(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Are we connected? |
|
//----------------------------------------------------------------------------- |
|
bool CRConClient::IsConnected() const |
|
{ |
|
return m_Socket.GetAcceptedSocketCount() > 0; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Creates a listen server, connects to remote machines that connect to it |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::CreateListenSocket( const netadr_t &netAdr ) |
|
{ |
|
m_Socket.CreateListenSocket( netAdr ); |
|
} |
|
|
|
void CRConClient::CloseListenSocket() |
|
{ |
|
m_Socket.CloseListenSocket( ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: send queued messages |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::SendQueuedData() |
|
{ |
|
SocketHandle_t hSocket = GetSocketHandle(); |
|
while ( m_SendBuffer.TellMaxPut() - m_SendBuffer.TellGet() > sizeof(int) ) |
|
{ |
|
size_t nSize = *(int*)m_SendBuffer.PeekGet(); |
|
Assert( nSize >= m_SendBuffer.TellMaxPut() - m_SendBuffer.TellGet() - sizeof( int ) ); |
|
int ret = send( hSocket, (const char *)m_SendBuffer.PeekGet(), nSize + sizeof( int ), 0 ); |
|
if ( ret != -1 ) |
|
{ |
|
m_SendBuffer.SeekGet( CUtlBuffer::SEEK_CURRENT, nSize + sizeof( int ) ); |
|
continue; |
|
} |
|
|
|
if ( !SocketWouldBlock() ) |
|
{ |
|
Warning( "Lost RCON connection, please retry command.\n"); |
|
CloseSocket(); |
|
} |
|
break; |
|
} |
|
|
|
int nSizeRemaining = m_SendBuffer.TellMaxPut() - m_SendBuffer.TellGet(); |
|
if ( nSizeRemaining <= sizeof(int) ) |
|
{ |
|
m_SendBuffer.Purge(); |
|
return; |
|
} |
|
|
|
// In this case, we've still got queued messages to send |
|
// Keep the portion of the buffer we didn't process for next time |
|
CUtlBuffer tmpBuf; |
|
tmpBuf.Put( m_SendBuffer.PeekGet(), nSizeRemaining ); |
|
m_SendBuffer.Purge(); |
|
m_SendBuffer.Put( tmpBuf.Base(), tmpBuf.TellPut() ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: parse received data |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::ParseReceivedData() |
|
{ |
|
m_RecvBuffer.SeekGet( CUtlBuffer::SEEK_HEAD, 0 ); |
|
|
|
int size = m_RecvBuffer.GetInt(); |
|
while ( size && size <= m_RecvBuffer.TellPut() - m_RecvBuffer.TellGet() ) |
|
{ |
|
//DevMsg( "RCON: got packet %i long\n", size ); |
|
int reqID = m_RecvBuffer.GetInt(); |
|
int cmdID = m_RecvBuffer.GetInt(); // ignore the cmd id |
|
// DevMsg( "RCON Cmd: <-- %i %i %i\n", reqID, cmdID, readLen ); |
|
|
|
switch( cmdID ) |
|
{ |
|
case SERVERDATA_AUTH_RESPONSE: |
|
{ |
|
if ( reqID == -1 ) // bad password |
|
{ |
|
Msg( "Bad RCON password\n" ); |
|
m_bAuthenticated = false; |
|
} |
|
else |
|
{ |
|
Assert( reqID == m_iAuthRequestID ); |
|
m_bAuthenticated = true; |
|
} |
|
char dummy[2]; |
|
m_RecvBuffer.GetString( dummy ); |
|
m_RecvBuffer.GetString( dummy ); |
|
} |
|
break; |
|
|
|
case SERVERDATA_SCREENSHOT_RESPONSE: |
|
{ |
|
int nDataSize = m_RecvBuffer.GetInt(); |
|
SaveRemoteScreenshot( m_RecvBuffer.PeekGet(), nDataSize ); |
|
m_RecvBuffer.SeekGet( CUtlBuffer::SEEK_CURRENT, nDataSize ); |
|
} |
|
break; |
|
|
|
case SERVERDATA_CONSOLE_LOG_RESPONSE: |
|
{ |
|
int nDataSize = m_RecvBuffer.GetInt(); |
|
SaveRemoteConsoleLog( m_RecvBuffer.PeekGet(), nDataSize ); |
|
m_RecvBuffer.SeekGet( CUtlBuffer::SEEK_CURRENT, nDataSize ); |
|
} |
|
break; |
|
|
|
case SERVERDATA_VPROF_DATA: |
|
{ |
|
int nDataSize = m_RecvBuffer.GetInt(); |
|
m_VProfExport.OnRemoteData( m_RecvBuffer.PeekGet(), nDataSize ); |
|
m_RecvBuffer.SeekGet( CUtlBuffer::SEEK_CURRENT, nDataSize ); |
|
} |
|
break; |
|
|
|
case SERVERDATA_VPROF_GROUPS: |
|
{ |
|
int nDataSize = m_RecvBuffer.GetInt(); |
|
m_VProfExport.OnRemoteGroupData( m_RecvBuffer.PeekGet(), nDataSize ); |
|
m_RecvBuffer.SeekGet( CUtlBuffer::SEEK_CURRENT, nDataSize ); |
|
} |
|
break; |
|
|
|
case SERVERDATA_RESPONSE_STRING: |
|
{ |
|
char pBuf[2048]; |
|
m_RecvBuffer.GetString( pBuf ); |
|
Msg( "%s", pBuf ); |
|
} |
|
break; |
|
|
|
default: |
|
{ |
|
// Displays a message from the server |
|
int strLen = m_RecvBuffer.TellPut() - m_RecvBuffer.TellGet(); |
|
CUtlMemory<char> msg; |
|
msg.EnsureCapacity( strLen + 1 ); |
|
m_RecvBuffer.GetStringManualCharCount( msg.Base(), msg.Count() ); |
|
|
|
msg[ msg.Count() - 1 ] = '\0'; |
|
Msg( "%s", (const char *)msg.Base() ); |
|
m_RecvBuffer.GetStringManualCharCount( msg.Base(), msg.Count() ); // ignore the second string |
|
} |
|
break; |
|
} |
|
|
|
if ( m_RecvBuffer.TellPut() - m_RecvBuffer.TellGet() >= sizeof(int) ) |
|
{ |
|
size = m_RecvBuffer.GetInt(); // read how much is in this packet |
|
} |
|
else |
|
{ |
|
size = 0; // finished the packet |
|
} |
|
} |
|
|
|
if ( size || (m_RecvBuffer.TellPut() - m_RecvBuffer.TellGet() > 0) ) |
|
{ |
|
// In this case, we've got a partial message; we didn't get it all. |
|
// Keep the portion of the buffer we didn't process for next time |
|
CUtlBuffer tmpBuf; |
|
if ( m_RecvBuffer.TellPut() - m_RecvBuffer.TellGet() > 0 ) |
|
{ |
|
tmpBuf.Put( m_RecvBuffer.PeekGet(), m_RecvBuffer.TellPut() - m_RecvBuffer.TellGet() ); |
|
} |
|
m_RecvBuffer.Purge(); |
|
if ( size > 0 ) |
|
{ |
|
m_RecvBuffer.PutInt( size ); |
|
} |
|
if ( tmpBuf.TellPut() > 0 ) |
|
{ |
|
m_RecvBuffer.Put( tmpBuf.Base(), tmpBuf.TellPut() ); |
|
} |
|
} |
|
else |
|
{ |
|
m_RecvBuffer.Purge(); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: check for any server responses |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::RunFrame() |
|
{ |
|
m_Socket.RunFrame(); |
|
|
|
if ( !IsConnected() ) |
|
return; |
|
|
|
SendQueuedData(); |
|
|
|
SocketHandle_t hSocket = GetSocketHandle(); |
|
char ch; |
|
int pendingLen = recv( hSocket, &ch, sizeof(ch), MSG_PEEK ); |
|
if ( pendingLen == -1 && SocketWouldBlock() ) |
|
return; |
|
|
|
if ( pendingLen == 0 ) // socket got closed |
|
{ |
|
CloseSocket(); |
|
return; |
|
} |
|
|
|
if ( pendingLen < 0 ) |
|
{ |
|
CloseSocket(); |
|
Warning( "Lost RCON connection, please retry command (%s)\n", NET_ErrorString( WSAGetLastError() ) ); |
|
return; |
|
} |
|
|
|
// find out how much we have to read |
|
unsigned long readLen = 0; |
|
ioctlsocket( hSocket, FIONREAD, &readLen ); |
|
if ( readLen <= sizeof(int) ) |
|
return; |
|
|
|
// we have a command to process |
|
// Read data into a utlbuffer |
|
m_RecvBuffer.EnsureCapacity( m_RecvBuffer.TellPut() + readLen + 1 ); |
|
char *recvbuffer = (char *)_alloca( min( 1024ul, readLen + 1 ) ); |
|
unsigned int len = 0; |
|
while ( len < readLen ) |
|
{ |
|
int recvLen = recv( hSocket, recvbuffer , min( 1024ul, readLen - len ) , 0 ); |
|
if ( recvLen == 0 ) // socket was closed |
|
{ |
|
CloseSocket(); |
|
break; |
|
} |
|
|
|
if ( recvLen < 0 && !SocketWouldBlock() ) |
|
{ |
|
Warning( "RCON Cmd: recv error (%s)\n", NET_ErrorString( WSAGetLastError() ) ); |
|
break; |
|
} |
|
|
|
m_RecvBuffer.Put( recvbuffer, recvLen ); |
|
len += recvLen; |
|
} |
|
|
|
ParseReceivedData(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: send a response to the server |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::SendResponse( CUtlBuffer &response, bool bAutoAuthenticate ) |
|
{ |
|
if ( bAutoAuthenticate && !IsAuthenticated() ) |
|
{ |
|
Authenticate(); |
|
if ( IsConnected() ) |
|
{ |
|
m_SendBuffer.Put( response.Base(), response.TellMaxPut() ); |
|
} |
|
return; |
|
} |
|
|
|
int ret = send( GetSocketHandle(), (const char *)response.Base(), response.TellMaxPut(), 0 ); |
|
if ( ret == -1 ) |
|
{ |
|
if ( SocketWouldBlock() ) |
|
{ |
|
m_SendBuffer.Put( response.Base(), response.TellMaxPut() ); |
|
} |
|
else |
|
{ |
|
Warning( "Lost RCON connection, please retry command\n" ); |
|
CloseSocket(); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: builds a simple command to send to the server |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::BuildResponse( CUtlBuffer &response, ServerDataRequestType_t msg, const char *pString1, const char *pString2 ) |
|
{ |
|
// build the response |
|
response.PutInt(0); // the size, filled in below |
|
response.PutInt(m_iReqID++); |
|
response.PutInt(msg); |
|
response.PutString(pString1); |
|
response.PutString(pString2); |
|
int nSize = response.TellPut() - sizeof(int); |
|
response.SeekPut( CUtlBuffer::SEEK_HEAD, 0 ); |
|
response.PutInt( nSize ); // the size |
|
response.SeekPut( CUtlBuffer::SEEK_CURRENT, nSize ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: authenticate ourselves |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::Authenticate() |
|
{ |
|
CUtlBuffer response; |
|
|
|
// build the response |
|
response.PutInt(0); // the size, filled in below |
|
response.PutInt(++m_iAuthRequestID); |
|
response.PutInt(SERVERDATA_AUTH); |
|
response.PutString( m_Password.Get() ); |
|
|
|
// Use the otherwise-empty second string for the userid. The server will use this to |
|
// exec "mp_disable_autokick <userid>" upon successful authentication. |
|
bool addedUserID = false; |
|
if ( cl.IsConnected() ) |
|
{ |
|
if ( cl.m_nPlayerSlot < cl.m_nMaxClients && cl.m_nPlayerSlot >= 0 ) |
|
{ |
|
Assert( cl.m_pUserInfoTable ); |
|
if ( cl.m_pUserInfoTable ) |
|
{ |
|
player_info_t *pi = (player_info_t*) cl.m_pUserInfoTable->GetStringUserData( cl.m_nPlayerSlot, NULL ); |
|
if ( pi ) |
|
{ |
|
addedUserID = true; |
|
// Fixup from network order (little endian) |
|
response.PutString( va( "%d", LittleLong( pi->userID ) ) ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
if ( !addedUserID ) |
|
{ |
|
response.PutString( "" ); |
|
} |
|
int size = response.TellPut() - sizeof(int); |
|
response.SeekPut( CUtlBuffer::SEEK_HEAD, 0 ); |
|
response.PutInt(size); // the size |
|
response.SeekPut( CUtlBuffer::SEEK_CURRENT, size ); |
|
|
|
SendResponse( response, false ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: send an rcon command to a connected server |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::SendCmd( const char *msg ) |
|
{ |
|
if ( !IsConnected() ) |
|
{ |
|
if ( !ConnectSocket() ) |
|
return; |
|
} |
|
|
|
CUtlBuffer response; |
|
BuildResponse( response, SERVERDATA_EXECCOMMAND, msg, "" ); |
|
SendResponse( response ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Start vprofiling |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::StartVProfData() |
|
{ |
|
if ( !IsConnected() ) |
|
{ |
|
if ( !ConnectSocket() ) |
|
return; |
|
} |
|
|
|
// Override the vprof export to point to our local profiling data |
|
OverrideVProfExport( &m_VProfExport ); |
|
|
|
CUtlBuffer response; |
|
BuildResponse( response, SERVERDATA_VPROF, "", "" ); |
|
SendResponse( response ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Stop vprofiling |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::StopVProfData() |
|
{ |
|
// Reset the vprof export to point to the normal profiling data |
|
ResetVProfExport( &m_VProfExport ); |
|
|
|
// Don't bother restarting a connection to turn this off |
|
if ( !IsConnected() ) |
|
return; |
|
|
|
CUtlBuffer response; |
|
BuildResponse( response, SERVERDATA_REMOVE_VPROF, "", "" ); |
|
SendResponse( response ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: get data from the server |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::TakeScreenshot() |
|
{ |
|
if ( !IsConnected() ) |
|
{ |
|
if ( !ConnectSocket() ) |
|
return; |
|
} |
|
|
|
CUtlBuffer response; |
|
BuildResponse( response, SERVERDATA_TAKE_SCREENSHOT, "", "" ); |
|
SendResponse( response ); |
|
} |
|
|
|
void CRConClient::GrabConsoleLog() |
|
{ |
|
if ( !IsConnected() ) |
|
{ |
|
if ( !ConnectSocket() ) |
|
return; |
|
} |
|
|
|
CUtlBuffer response; |
|
BuildResponse( response, SERVERDATA_SEND_CONSOLE_LOG, "", "" ); |
|
SendResponse( response ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// We've got data from the server, save it |
|
//----------------------------------------------------------------------------- |
|
void CRConClient::SaveRemoteScreenshot( const void* pBuffer, int nBufLen ) |
|
{ |
|
char pScreenshotPath[MAX_PATH]; |
|
do |
|
{ |
|
Q_snprintf( pScreenshotPath, sizeof( pScreenshotPath ), "%s/screenshot%04d.jpg", m_RemoteFileDir.Get(), m_nScreenShotIndex++ ); |
|
} while ( g_pFullFileSystem->FileExists( pScreenshotPath, "MOD" ) ); |
|
|
|
char pFullPath[MAX_PATH]; |
|
GetModSubdirectory( pScreenshotPath, pFullPath, sizeof(pFullPath) ); |
|
HZIP hZip = OpenZip( (void*)pBuffer, nBufLen, ZIP_MEMORY ); |
|
|
|
int nIndex; |
|
ZIPENTRY zipInfo; |
|
FindZipItem( hZip, "screenshot.jpg", true, &nIndex, &zipInfo ); |
|
if ( nIndex >= 0 ) |
|
{ |
|
UnzipItem( hZip, nIndex, pFullPath, 0, ZIP_FILENAME ); |
|
} |
|
CloseZip( hZip ); |
|
} |
|
|
|
void CRConClient::SaveRemoteConsoleLog( const void* pBuffer, int nBufLen ) |
|
{ |
|
if ( nBufLen == 0 ) |
|
return; |
|
|
|
char pLogPath[MAX_PATH]; |
|
do |
|
{ |
|
Q_snprintf( pLogPath, sizeof( pLogPath ), "%s/console%04d.log", m_RemoteFileDir.Get(), m_nConsoleLogIndex++ ); |
|
} while ( g_pFullFileSystem->FileExists( pLogPath, "MOD" ) ); |
|
|
|
char pFullPath[MAX_PATH]; |
|
GetModSubdirectory( pLogPath, pFullPath, sizeof(pFullPath) ); |
|
HZIP hZip = OpenZip( (void*)pBuffer, nBufLen, ZIP_MEMORY ); |
|
|
|
int nIndex; |
|
ZIPENTRY zipInfo; |
|
FindZipItem( hZip, "console.log", true, &nIndex, &zipInfo ); |
|
if ( nIndex >= 0 ) |
|
{ |
|
UnzipItem( hZip, nIndex, pFullPath, 0, ZIP_FILENAME ); |
|
} |
|
CloseZip( hZip ); |
|
}
|
|
|