source-engine/engine/cl_rcon.cpp

//========= 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 );
}