ccs.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
// ccs.cpp - "con command server" 
// Not to be confused with the game's server - this is a completely different thing that allows multiple game clients to connect to a single client, 
// so con commands can be sent simultaneously to multiple running game clients, screen captures can be sent in real-time to a single client for comparison purposes, 
// and all convar's can be diff'd between all connected clients and the server.
// The server portion of this code needs socketlib, which hasn't been ported to Linux yet, and shouldn't be shipped because it could be a security risk 
// (it's only intended for primarily graphics debugging and detailed comparisons of GL vs. D3D9).

#include "host_state.h"

//#define CON_COMMAND_SERVER_SUPPORT

#include "tier2/tier2.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"

#ifdef CON_COMMAND_SERVER_SUPPORT
#include <algorithm>
#include "socketlib/socketlib.h"
#define MINIZ_NO_ARCHIVE_APIS
#include "../../thirdparty/miniz/miniz.c"
#include "../../thirdparty/miniz/simple_bitmap.h"
#define STBI_NO_STDIO
#include "../../thirdparty/stb_image/stb_image.c"
#include "ivideomode.h"
#endif

#include "cmd.h"
#include "filesystem.h"
#include "render.h"
#include "icliententitylist.h"
#include "client.h"
#include "icliententity.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

//-----------------------------------------------------------------------------
#ifdef STAGING_ONLY
CON_COMMAND_F( ccs_write_convars, "Write all convars to file.", FCVAR_CHEAT )
{
	FILE* pFile = fopen( "convars.txt", "w" );
	if ( !pFile )
	{
		ConMsg( "Unable to open convars.txt\n" );
		return;
	}

	ICvar::Iterator iter( g_pCVar );
	for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() )
	{
		ConCommandBase *var = iter.Get();

		ConVar *pConVar = dynamic_cast< ConVar* >( var );
		if ( !pConVar )
			continue;

		const char *pName = pConVar->GetName();
		const char *pVal = pConVar->GetString();
		if ( ( !pName ) || ( !pVal ) )
			continue;

		fprintf( pFile, "%s=%s\n", pName, pVal );
	}
	fclose( pFile );
	ConMsg( "Wrote all convars to convars.txt\n" );
}
#endif

//-----------------------------------------------------------------------------

#ifdef CON_COMMAND_SERVER_SUPPORT

class frame_buf_window
{
	friend LRESULT CALLBACK static_window_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

	static LRESULT CALLBACK static_window_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
	{
		frame_buf_window* pApp = reinterpret_cast<frame_buf_window*>(GetWindowLong(hWnd, 0));
		if (!pApp)
			pApp = frame_buf_window::m_pCur_app;

		Assert(pApp);

		return pApp->window_proc(hWnd, message, wParam, lParam);
	}

public:
	frame_buf_window(const char* pTitle = "frame_buf_window", int width = 640, int height = 480, int scaleX = 1, int scaleY = 1);

	virtual ~frame_buf_window();

	// Return true if you handle the window message.
	typedef bool (*user_window_proc_ptr_t)(LRESULT& hres, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam, void *pData);   
	void set_window_proc_callback(user_window_proc_ptr_t windowProcPtr, void *pData) { m_pWindow_proc = windowProcPtr; m_pWindow_proc_data = pData; }

	int width(void) const { return m_width; }
	int height(void) const { return m_height; }      

	void update(void);

	void close(void);

	const simple_bgr_bitmap& frameBuffer(void) const { return m_frame_buffer; }

	simple_bgr_bitmap& frameBuffer(void) { return m_frame_buffer; }

private:
	int m_width, m_height;
	int m_orig_width, m_orig_height;
	int m_orig_x, m_orig_y;
	int m_scale_x, m_scale_y;
	WNDCLASS m_window_class;
	HWND m_window;
	char m_bitmap_info[16 + sizeof(BITMAPINFO)];
	BITMAPINFO* m_pBitmap_hdr;
	HDC m_windowHDC;
	simple_bgr_bitmap m_frame_buffer;
	static frame_buf_window* m_pCur_app;

	user_window_proc_ptr_t m_pWindow_proc;
	void *m_pWindow_proc_data;
		
	void create_window(const char* pTitle);

	void create_bitmap(void);

	LRESULT window_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

}; // class frame_buf_window


frame_buf_window* frame_buf_window::m_pCur_app;

frame_buf_window::frame_buf_window(const char* pTitle, int width, int height, int scaleX, int scaleY) :
    m_width(width),
    m_height(height),
    m_orig_width(0), 
    m_orig_height(0), 
    m_orig_x(0), 
    m_orig_y(0),
    m_window(0),
    m_pBitmap_hdr(NULL),
    m_windowHDC(0),
    m_pWindow_proc(NULL),
    m_pWindow_proc_data(NULL)
{
	m_scale_x = scaleX;
	m_scale_y = scaleY;

    create_window(pTitle);
      
    create_bitmap();           
}
      
frame_buf_window::~frame_buf_window()
{  
    close();
}

void frame_buf_window::update(void)
{
	if ( m_window )
	{
		InvalidateRect(m_window, NULL, FALSE);

		SendMessage(m_window, WM_PAINT, 0, 0);

		MSG msg;
		while (PeekMessage(&msg, m_window, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}

		//Sleep(0);
	}
}
      
void frame_buf_window::close(void)
{ 
    m_frame_buffer.clear();
      
    if (m_window)
    {
        ReleaseDC(m_window, m_windowHDC);
        DestroyWindow(m_window);
        m_window = 0;
        m_windowHDC = 0;
    }
}
                   
void frame_buf_window::create_window(const char* pTitle)
{
    memset( &m_window_class, 0, sizeof( m_window_class ) );
    m_window_class.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;
    m_window_class.lpfnWndProc = static_window_proc;
    m_window_class.cbWndExtra = sizeof(DWORD);
    m_window_class.hCursor = LoadCursor(0, IDC_ARROW);
    m_window_class.lpszClassName = pTitle;
    m_window_class.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH); //GetStockObject(NULL_BRUSH);
    RegisterClass(&m_window_class);
            
    RECT rect;
    rect.left = rect.top = 0;
    rect.right = m_width * m_scale_x;
    rect.bottom = m_height * m_scale_y;
    AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, 0);
    rect.right -= rect.left;
    rect.bottom -= rect.top;

    m_orig_x = (GetSystemMetrics(SM_CXSCREEN) - rect.right) / 2;
    m_orig_y = (GetSystemMetrics(SM_CYSCREEN) - rect.bottom) / 2;

    m_orig_width = rect.right;
    m_orig_height = rect.bottom;

    m_pCur_app = this;
      
    m_window = CreateWindowEx(
        0, pTitle, pTitle, 
        WS_OVERLAPPEDWINDOW, 
        m_orig_x, m_orig_y, rect.right, rect.bottom, 0, 0, 0, 0);

    SetWindowLong(m_window, 0, reinterpret_cast<LONG>(this));
      
    m_pCur_app = NULL;

    ShowWindow(m_window, SW_NORMAL);            
}

void frame_buf_window::create_bitmap(void)
{
    memset( &m_bitmap_info, 0, sizeof( m_bitmap_info ) );
      
    m_pBitmap_hdr = reinterpret_cast<BITMAPINFO*>(&m_bitmap_info);
    m_pBitmap_hdr->bmiHeader.biSize          = sizeof(BITMAPINFOHEADER);
    m_pBitmap_hdr->bmiHeader.biWidth         = m_width;
    m_pBitmap_hdr->bmiHeader.biHeight        = -m_height;
    m_pBitmap_hdr->bmiHeader.biBitCount      = 24;
    m_pBitmap_hdr->bmiHeader.biPlanes        = 1;
    m_pBitmap_hdr->bmiHeader.biCompression   = BI_RGB;//BI_BITFIELDS;
	// Only really needed for 32bpp BI_BITFIELDS
    reinterpret_cast<uint32*>(m_pBitmap_hdr->bmiColors)[0] = 0x00FF0000;
    reinterpret_cast<uint32*>(m_pBitmap_hdr->bmiColors)[1] = 0x0000FF00;
    reinterpret_cast<uint32*>(m_pBitmap_hdr->bmiColors)[2] = 0x000000FF;

    m_windowHDC = GetDC(m_window);
      
    m_frame_buffer.init( m_width, m_height );
	m_frame_buffer.cls( 30, 30, 30 );
	//m_frame_buffer.draw_text( 50, 200, 2, 255, 127, 128, "This is a test!" );
}         

LRESULT frame_buf_window::window_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    if (m_pWindow_proc)
    {
        LRESULT lres;
        bool status = m_pWindow_proc(lres, hWnd, message, wParam, lParam, m_pWindow_proc_data);
        if (status)
			return lres;
    }

    switch (message)
    {
        case WM_PAINT:
        {
			if (m_frame_buffer.is_valid())
			{
				RECT window_size;
				GetClientRect(hWnd, &window_size);

				StretchDIBits(m_windowHDC, 
					0, 0, window_size.right, window_size.bottom, 
					0, 0, m_width, m_height, 
					m_frame_buffer.get_ptr(), m_pBitmap_hdr, 
					DIB_RGB_COLORS, SRCCOPY);

				ValidateRect(hWnd, NULL);
			}
			break;
        }
        case WM_KEYDOWN:
        {
			const int cEscCode = 27;
			if (cEscCode != (wParam & 0xFF))
				break;
        }
        case WM_CLOSE:
        {
			close();

			break;
        }
    }            

	return DefWindowProc( hWnd, message, wParam, lParam );
}

class CConCommandServerProtocolTypes
{
public:
	enum 
	{ 
		cProtocolPort = 3779,
		cMaxClients = 4
	};

	struct PacketHeader_t
	{
		uint16 m_nID;
		uint16 m_nType;
		uint32 m_nTotalSize;
	};

	struct SetCameraPosPacket_t : PacketHeader_t
	{
		Vector m_Pos;
		QAngle m_Angle;
	};

	struct ScreenshotPacket_t : PacketHeader_t
	{
		uint m_nScreenshotID;
		char m_szFilename[256];
	};
			
	enum 
	{ 
		cPacketHeaderID = 0x1234,
		cPacketHeaderSize = sizeof( PacketHeader_t ),
	};

	enum PacketTypes_t
	{
		cPacketTypeMessage = 0,
		cPacketTypeCommand = 1,
		cPacketTypeScreenshotRequest = 2,
		cPacketTypeScreenshotReply = 3,
		cPacketTypeSetCameraPos = 4,
		cPacketTypeConVarDumpRequest = 5,
		cPacketTypeConVarDumpReply = 6,

		cPackerTypeTotalMessages
	};
};

struct DumpedConVar_t
{
	CUtlString m_Name;
	CUtlString m_Value;

	bool operator< (const DumpedConVar_t & rhs ) const { return V_strcmp( m_Name.Get(), rhs.m_Name.Get() ) < 0; }
};
typedef CUtlVector<DumpedConVar_t> DumpedConVarVector_t;

static void DumpConVars( DumpedConVarVector_t &conVars )
{
	ICvar::Iterator iter( g_pCVar );
	for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() )
	{
		ConCommandBase *var = iter.Get();

		ConVar *pConVar = dynamic_cast< ConVar* >( var );
		if ( !pConVar )
			continue;

		const char *pName = pConVar->GetName();
		const char *pVal = pConVar->GetString();
		if ( ( !pName ) || ( !pVal ) )
			continue;

		int nIndex = conVars.AddToTail();
		conVars[nIndex].m_Name.Set( pName );
		conVars[nIndex].m_Value.Set( pVal );
	}
}

class CConCommandConnection : public CConCommandServerProtocolTypes
{
public:
	CConCommandConnection() : 
		m_pSocket( NULL ), 
		m_bDeleteSocket( false ),
		m_nEndpointIndex( -1 ), 
		m_bClientFlag( false ),
		m_bReceivedNewCameraPos( false ),
		m_nSendBufOfs( 0 ),
		m_bHasNewScreenshot( false ),
		m_nScreenshotID( 0 )
	{
		memset( &m_NewCameraPos, 0, sizeof( m_NewCameraPos ) );
	}

	~CConCommandConnection()
	{
		Deinit();
	}

	bool IsConnected() const { return m_nEndpointIndex >= 0; }

	bool Init( const char *pAddress )
	{
		Deinit();
		
		m_nEndpointIndex = 0;
		m_bClientFlag = true;

		m_RecvBuf.EnsureCapacity( 4096 );
		m_SendBuf.EnsureCapacity( 4096 );
		m_RecvBuf.SetCountNonDestructively( 0 );
		m_SendBuf.SetCountNonDestructively( 0 );
		m_nSendBufOfs = 0;

		m_pSocket = new CSocketConnection;
		m_bDeleteSocket = true;
		m_pSocket->Init( CT_CLIENT, SP_TCP );

		SocketErrorCode_t err = m_pSocket->ConnectToServer( pAddress, cProtocolPort );
		if ( err != SOCKET_SUCCESS )
		{
			Warning( "CONCMDSRV: Failed connecting to con cmd server \"%s\"!\n", pAddress );
			
			Deinit();

			return false;
		}
		
		uint n = 0;
		while ( m_pSocket->GetEndpointSocketState( 0 ) == SSTATE_CONNECTION_IN_PROGRESS )
		{
			bool bIsConnected = false;
			err = m_pSocket->PollClientConnectionState( &bIsConnected );
			if ( err != SOCKET_SUCCESS )
			{
				Warning( "CONCMDSRV: Failed connecting to con cmd server \"%s\"!\n", pAddress );

				Deinit();

				return false;
			}

			if ( bIsConnected )
				break;
			
			ThreadSleep( 10 );
			
			if ( ++n >= 500 )
			{
				Warning( "CONCMDSRV: Failed connecting to con cmd server \"%s\"!\n", pAddress );

				Deinit();

				return false;
			}
		}

		if ( m_pSocket->GetEndpointSocketState( 0 ) != SSTATE_CONNECTED )
		{
			Warning( "CONCMDSRV: Failed connecting to con cmd server \"%s\"!\n", pAddress );

			Deinit();

			return false;
		}

		int nFlag = 1;
		m_pSocket->SetSocketOpt( 0, IPPROTO_TCP, TCP_NODELAY, &nFlag, sizeof( int ) );

		return TickConnection();
	}

	bool Init( CSocketConnection *pSocket, int nEndpointIndex, bool bClientFlag )
	{
		Deinit();
				
		int nFlag = 1;
		pSocket->SetSocketOpt( nEndpointIndex, IPPROTO_TCP, TCP_NODELAY, &nFlag, sizeof( int ) );
				
		m_pSocket = pSocket;
		m_bDeleteSocket = false;
		m_nEndpointIndex = nEndpointIndex;
		m_bClientFlag = bClientFlag;

		m_RecvBuf.EnsureCapacity( 4096 );
		m_SendBuf.EnsureCapacity( 4096 );

		m_RecvBuf.SetCountNonDestructively( 0 );
		m_SendBuf.SetCountNonDestructively( 0 );
		m_nSendBufOfs = 0;

		return TickConnection();
	}

	void Deinit()
	{
		if ( m_nEndpointIndex < 0 )
			return;

		ConMsg( "CONCMDSRV: Disconnecting endpoint %i\n", m_nEndpointIndex );

		if ( m_pSocket )
		{
			m_pSocket->ResetEndpoint( m_nEndpointIndex );
			
			if ( m_bDeleteSocket )
			{
				m_pSocket->Cleanup();
				delete m_pSocket;
			}
			m_pSocket = NULL;
		}

		m_nEndpointIndex = -1;
		m_bDeleteSocket = false;
		m_bClientFlag = false;
		
		m_RecvBuf.SetCountNonDestructively( 0 );
		m_SendBuf.SetCountNonDestructively( 0 );
		m_nSendBufOfs = 0;

		m_bHasNewScreenshot = false;
		m_nScreenshotID = 0;
		m_screenshot.clear();
		
		m_bReceivedNewCameraPos = false;
		memset( &m_NewCameraPos, 0, sizeof( m_NewCameraPos ) );
	}

	bool SendData( const void * pPacket, uint nSize )
	{
		if ( m_nEndpointIndex < 0 )
			return false;

		m_SendBuf.AddMultipleToTail( nSize, static_cast< const uint8 * >( pPacket ) );
		return TickConnectionSend();
	}

	bool TickConnectionRecv( )
	{
		for ( ; ; )
		{
			uint8 buf[4096];
			int nBytesRead = 0;
			SocketErrorCode_t nReadErr = m_pSocket->ReadFromEndpoint( m_nEndpointIndex, buf, sizeof( buf ), &nBytesRead );
			if ( nReadErr == SOCKET_ERR_READ_OPERATION_WOULD_BLOCK )
				break;
			else if ( nReadErr != SOCKET_SUCCESS )
			{
				Warning( "CONCMDSRV: Failed receiving data from client %i\n", m_nEndpointIndex );
				Deinit();
				return false;
			}

			m_RecvBuf.AddMultipleToTail( nBytesRead, buf );
			if ( m_RecvBuf.Count() >= cPacketHeaderSize )
			{
				if ( !ProcessMessages() )
				{
					Warning( "CONCMDSRV: Failed processing messages from client %i\n", m_nEndpointIndex );
					Deinit();
					return false;
				}
			}
		}
			
		return true;
	}

	bool TickConnectionSend( )
	{
		while ( m_nSendBufOfs < m_SendBuf.Count() )
		{
			int nBytesWritten = 0;
			SocketErrorCode_t nWriteErr = m_pSocket->WriteToEndpoint( m_nEndpointIndex, &m_SendBuf[ m_nSendBufOfs ], m_SendBuf.Count() - m_nSendBufOfs, &nBytesWritten );
			if ( nWriteErr == SOCKET_ERR_WRITE_OPERATION_WOULD_BLOCK )
				break;
			else if ( nWriteErr != SOCKET_SUCCESS )
			{
				Warning( "CONCMDSRV: Failed sending data to client %i\n", m_nEndpointIndex );
				Deinit();
				return false;
			}

			m_nSendBufOfs += nBytesWritten;
			if ( m_nSendBufOfs == m_SendBuf.Count() )
			{
				m_SendBuf.SetCountNonDestructively( 0 );
				m_nSendBufOfs = 0;
				break;
			}
		}

		return true;
	}

	bool TickConnection()
	{
		if ( !IsConnected() )
			return false;
				
		if ( !TickConnectionSend() )
			return false;
		if ( !TickConnectionRecv() )
			return false;

		if ( m_bReceivedNewCameraPos )
		{
			m_bReceivedNewCameraPos = false;
						
			char buf[256];
			//V_snprintf( buf, sizeof( buf ), "setpos_exact %f %f %f;setang_exact %f %f %f\n", m_NewCameraPos.m_Pos.x, m_NewCameraPos.m_Pos.y, m_NewCameraPos.m_Pos.z, m_NewCameraPos.m_Angle.x, m_NewCameraPos.m_Angle.y, m_NewCameraPos.m_Angle.z );
			V_snprintf( buf, sizeof( buf ), "setpos_exact 0x%X 0x%X 0x%X;setang_exact 0x%X 0x%X 0x%X\n", *(DWORD*)&m_NewCameraPos.m_Pos.x, *(DWORD*)&m_NewCameraPos.m_Pos.y, *(DWORD*)&m_NewCameraPos.m_Pos.z, *(DWORD*)&m_NewCameraPos.m_Angle.x, *(DWORD*)&m_NewCameraPos.m_Angle.y, *(DWORD*)&m_NewCameraPos.m_Angle.z );
			
			Cbuf_AddText( buf );
			Cbuf_Execute();
		}
				
		return true;
	}

	bool HasNewScreenshotFlag() const { return m_bHasNewScreenshot; }
	void ClearNewScreenshotFlag() { m_bHasNewScreenshot = false; }
	uint GetScreenshotID() const { return m_nScreenshotID; }
	simple_bitmap &GetScreenshot() { return m_screenshot; }

	bool HasNewConVarDumpFlag() const { return m_bHasNewConVarDump; }
	void ClearHasNewConVarDumpFlag() { m_bHasNewConVarDump = false; }
	DumpedConVarVector_t &GetConVarDumpVector() { return m_DumpedConVars; }
	const DumpedConVarVector_t &GetConVarDumpVector() const { return m_DumpedConVars; }

private:
	CSocketConnection *m_pSocket;
	bool m_bDeleteSocket;
	int m_nEndpointIndex;
	bool m_bClientFlag;

	CUtlVector<uint8> m_RecvBuf;

	CUtlVector<uint8> m_SendBuf;
	int m_nSendBufOfs;

	bool m_bReceivedNewCameraPos;
	SetCameraPosPacket_t m_NewCameraPos;

	simple_bitmap m_screenshot;
	bool m_bHasNewScreenshot;
	uint m_nScreenshotID;

	bool m_bHasNewConVarDump;
	DumpedConVarVector_t m_DumpedConVars;

	bool ProcessMessages()
	{
		while ( m_RecvBuf.Count() >= cPacketHeaderSize )
		{
			const int nCurRecvBufSize = m_RecvBuf.Count();

			const PacketHeader_t header( *reinterpret_cast<const PacketHeader_t *>( &m_RecvBuf[0] ) );
			if ( header.m_nID != cPacketHeaderID )
				return false;

			if ( header.m_nTotalSize < cPacketHeaderSize )
				return false;

			if ( header.m_nType >= cPackerTypeTotalMessages )
				return false;

			if ( (uint32)m_RecvBuf.Count() < header.m_nTotalSize )
				break;

			const uint nNumMessageBytes = header.m_nTotalSize - cPacketHeaderSize;
			const uint8 *pMsg = nNumMessageBytes ? &m_RecvBuf[cPacketHeaderSize] : NULL;

			switch ( header.m_nType )
			{
				case cPacketTypeMessage:
				{
					if ( nNumMessageBytes )
					{
						ConMsg( "CONCMDSRV: Message from client %i: ", m_nEndpointIndex );
						
						CUtlVectorFixedGrowable<char, 4096> buf;
						buf.SetCount( nNumMessageBytes + 1 );
						memcpy( &buf[0], pMsg, nNumMessageBytes );
						buf[nNumMessageBytes] = '\0';

						ConMsg( "%s\n", &buf[0] );
					}

					break;
				}
				case cPacketTypeScreenshotRequest:
				{
					const ScreenshotPacket_t &requestPacket = *reinterpret_cast<const ScreenshotPacket_t *>( &m_RecvBuf[0] );
					if ( requestPacket.m_nTotalSize != sizeof( ScreenshotPacket_t ) )
					{
						Warning( "CONCMDSRV: Invalid screenshot request packet!\n" );
						return false;
					}

					if ( !videomode )
						break;

					uint nWidth = videomode->GetModeWidth();
					uint nHeight = videomode->GetModeHeight();
					if ( !nWidth || !nHeight ) 
						break;

					static void *s_pBuf;
					if ( !s_pBuf )
					{
						s_pBuf = malloc( nWidth * nHeight * 3 );
					}
					videomode->ReadScreenPixels( 0, 0, nWidth, nHeight, s_pBuf, IMAGE_FORMAT_RGB888 );

					size_t nPNGSize = 0;
					void *pPNGData = tdefl_write_image_to_png_file_in_memory( s_pBuf, nWidth, nHeight, 3, &nPNGSize, true );

					if ( pPNGData )
					{
						ScreenshotPacket_t replyPacket;
						replyPacket.m_nID = cPacketHeaderID;
						replyPacket.m_nTotalSize = sizeof( replyPacket ) + nPNGSize;
						replyPacket.m_nType = cPacketTypeScreenshotReply;
						V_strcpy( replyPacket.m_szFilename, requestPacket.m_szFilename );
						replyPacket.m_nScreenshotID = requestPacket.m_nScreenshotID;
						
						if ( !SendData( &replyPacket, sizeof( replyPacket ) ) ) 
						{
							free( pPNGData );
							return false;
						}

						if ( !SendData( pPNGData, nPNGSize ) )
						{
							free( pPNGData );
							return false;
						}
						
						free( pPNGData );
					}
					
					break;
				}
				case cPacketTypeScreenshotReply:
				{
					const ScreenshotPacket_t &replyPacket = *reinterpret_cast<const ScreenshotPacket_t *>( &m_RecvBuf[0] );
					if ( replyPacket.m_nTotalSize <= sizeof( ScreenshotPacket_t ) )
					{
						Warning( "CONCMDSRV: Invalid screenshot reply packet!\n" );
						return false;
					}

					const void *pPNGData = &m_RecvBuf[sizeof(ScreenshotPacket_t)];
					uint nPNGDataSize = header.m_nTotalSize - sizeof(ScreenshotPacket_t);
					
					if ( !replyPacket.m_nScreenshotID )
					{
						char szFilename[512];
						V_snprintf( szFilename, sizeof( szFilename ), "%s_%u.png", replyPacket.m_szFilename, m_nEndpointIndex );

						FileHandle_t fh = g_pFullFileSystem->Open( szFilename, "wb" );
						if ( fh )
						{
							g_pFullFileSystem->Write( pPNGData, nPNGDataSize, fh );
							g_pFullFileSystem->Close(fh);
						}
					}
					else
					{
						int nWidth = 0, nHeight = 0, nComp = 3;
						unsigned char *pImageData = stbi_load_from_memory( reinterpret_cast< stbi_uc const * >( pPNGData ), nPNGDataSize, &nWidth, &nHeight, &nComp, 3);

						if ( !pImageData )
						{
							Warning( "CONCMDSRV: Failed unpacking PNG screenshot!\n" );
							return false;
						}

						m_bHasNewScreenshot = true;
						m_nScreenshotID = replyPacket.m_nScreenshotID;

						if ( ( (int)m_screenshot.width() != nWidth ) || ( (int)m_screenshot.height() != nHeight ) )
						{
							m_screenshot.init( nWidth, nHeight );
						}

						memcpy( m_screenshot.get_ptr(), pImageData, nWidth * nHeight * 3 );
													
						stbi_image_free( pImageData );
					}

					break;
				}
				case cPacketTypeCommand:
				{
					if ( nNumMessageBytes )
					{
						//ConMsg( "CONCMDSRV: Console command from client %i: ", m_nEndpointIndex );

						CUtlVectorFixedGrowable<char, 4096> buf;
						buf.SetCount( nNumMessageBytes + 1 );
						memcpy( &buf[0], pMsg, nNumMessageBytes );
						buf[nNumMessageBytes] = '\0';
					
						//ConMsg( "\"%s\"\n", &buf[0] );

						Cbuf_AddText( &buf[0] );
						Cbuf_AddText( "\n" );
						Cbuf_Execute();
					}

					break;
				}
				case cPacketTypeSetCameraPos:
				{
					const SetCameraPosPacket_t &setCameraPosPacket = reinterpret_cast<const SetCameraPosPacket_t &>( m_RecvBuf[0] );
					if ( setCameraPosPacket.m_nTotalSize != sizeof( SetCameraPosPacket_t ) )
					{
						Warning( "CONCMDSRV: Invalid set camera pos packet!\n" );
						return false;
					}

					m_bReceivedNewCameraPos = true;
					m_NewCameraPos = setCameraPosPacket;
					break;
				}
				case cPacketTypeConVarDumpRequest:
				{
					CUtlVector<uint8> conVarData;

					DumpedConVarVector_t conVars;
					DumpConVars( conVars );

					for ( int i = 0; i < conVars.Count(); i++ )
					{
						const char *pName = conVars[i].m_Name.Get();
						const char *pVal = conVars[i].m_Value.Get();
						if ( ( !pName ) || ( !pVal ) )
							continue;

						conVarData.AddMultipleToTail( V_strlen( pName ) + 1, reinterpret_cast<const uint8 *>( pName ) );
						conVarData.AddMultipleToTail( V_strlen( pVal ) + 1, reinterpret_cast<const uint8 *>( pVal ) );
					}

					PacketHeader_t replyPacket;
					replyPacket.m_nID = cPacketHeaderID;
					replyPacket.m_nTotalSize = sizeof( replyPacket ) + conVarData.Count();
					replyPacket.m_nType = cPacketTypeConVarDumpReply;
					if ( !SendData( &replyPacket, sizeof( replyPacket ) ) )
						return false;
					if ( conVarData.Count() )
					{
						if ( !SendData( &conVarData[0], conVarData.Count() ) )
							return false;
					}

					break;
				}
				case cPacketTypeConVarDumpReply:
				{
					m_bHasNewConVarDump = true;
					m_DumpedConVars.SetCountNonDestructively( 0 );
					m_DumpedConVars.EnsureCapacity( 4096 );

					const char *pCur = reinterpret_cast<const char *>( pMsg );
					const char *pEnd = reinterpret_cast<const char *>( pMsg ) + nNumMessageBytes;

					while ( pCur < pEnd )
					{
						const uint nBytesLeft = pEnd - pCur;

						uint nNameLen = V_strlen( pCur );
						if ( ( nNameLen + 1 ) >= nBytesLeft )
						{
							Warning( "CONCMDSRV: Failed parsing convar dump reply!\n" );
							Assert( 0 );
							return false;
						}

						uint nValLen = V_strlen( pCur + nNameLen + 1 );
						
						uint nTotalLenInBytes = nNameLen + 1 + nValLen + 1;
						if ( nTotalLenInBytes > nBytesLeft )
						{
							Warning( "CONCMDSRV: Failed parsing convar dump reply!\n" );
							Assert( 0 );
							return false;
						}

						int nIndex = m_DumpedConVars.AddToTail();
						m_DumpedConVars[nIndex].m_Name.Set( pCur );
						m_DumpedConVars[nIndex].m_Value.Set( pCur + nNameLen + 1 );
						
						pCur += nTotalLenInBytes;
					}

					ConMsg( "Received convar dump reply from endpoint %i, %u total convars\n", m_nEndpointIndex, m_DumpedConVars.Count() );
					
					break;
				}
				default:
				{
					return false;
				}
			}

			// In case the connection gets lost during a send to reply
			if ( ( m_nEndpointIndex < 0 ) || ( nCurRecvBufSize != m_RecvBuf.Count() ) )
				return false;

			int nNumBytesRemaining = m_RecvBuf.Count() - header.m_nTotalSize;
			Assert( nNumBytesRemaining >= 0 );
			if ( nNumBytesRemaining >= 0 )
			{
				memmove( &m_RecvBuf[0], &m_RecvBuf[0] + header.m_nTotalSize, nNumBytesRemaining );
				m_RecvBuf.SetCountNonDestructively( nNumBytesRemaining );
			}
		}

		return true;
	}
};

ConVar ccs_broadcast_camera( "ccs_broadcast_camera", "0", FCVAR_CHEAT );
ConVar ccs_camera_sync( "ccs_camera_sync", "0", FCVAR_CHEAT );
ConVar ccs_remote_screenshots( "ccs_remote_screenshots", "0", FCVAR_CHEAT );
ConVar ccs_remote_screenshots_delta( "ccs_remote_screenshots_delta", "1", FCVAR_CHEAT );

class CConCommandServer : public CConCommandServerProtocolTypes
{
	static bool UserWindowProc( LRESULT& hres, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam, void *pData )
	{
		CConCommandServer *pServer = static_cast< CConCommandServer * >( pData );

		switch ( message )
		{
			case WM_KEYDOWN:
			{
				uint cKey = ( wParam & 0xFF );
				if ( ( cKey >= '0' ) && ( cKey <= '9' ) )
				{
					pServer->m_nViewEndpointIndex = cKey - '0';
				}								
			}
		}

		return false;
	}

public:
	CConCommandServer() : 
		m_bInitialized( false ),
		m_pFrameBufWindow( NULL ),
		m_nViewEndpointIndex( 0 )
	{
	}

	~CConCommandServer()
	{
		Deinit();
	}

	bool Init()
	{
		Deinit();

		m_Socket.Init( CT_SERVER, SP_TCP );

		if ( m_Socket.Listen( cProtocolPort, cMaxClients ) != SOCKET_SUCCESS )
		{
			Warning( "CONCMDSRV: CConCommandServer:Init: Failed to create listen socket!\n" );
			return false;
		}

		ConMsg( "CONCMDSVR: Listening for connections\n" );
		
		uint nWidth = 1280, nHeight = 1024;
		if ( videomode )
		{
			nWidth = videomode->GetModeWidth();
			nHeight = videomode->GetModeHeight();
		}
		m_pFrameBufWindow = new frame_buf_window( "CCS", nWidth, nHeight );
		m_pFrameBufWindow->set_window_proc_callback( UserWindowProc, this );

		m_bInitialized = true;
		return true;
	}

	void Deinit()
	{
		if ( !m_bInitialized )
			return;

		delete m_pFrameBufWindow;
		m_pFrameBufWindow = NULL;
		
		for ( int i = 0; i < cMaxClients; i++ )
		{
			m_Clients[i].Deinit();
		}

		m_Socket.Cleanup();
		m_nViewEndpointIndex = 0;

		ConMsg( "CONCMDSVR: Deinitialized\n" );
				
		m_bInitialized = false;
	}

	bool IsInitialized()
	{
		return m_bInitialized;
	}
	
	void TickFrame( float flTime )
	{
		if ( !m_bInitialized )
			return;

		AcceptNewConnections();

		if ( ccs_broadcast_camera.GetBool() )
		{
			Vector vecOrigin = MainViewOrigin();
			QAngle angles( 0, 0, 0 );

			IClientEntity *localPlayer = entitylist ? entitylist->GetClientEntity( cl.m_nPlayerSlot + 1 ) : NULL;
			if ( localPlayer )
			{
				vecOrigin = localPlayer->GetAbsOrigin();
				angles = localPlayer->GetAbsAngles();
			}
				
			SetCameraPosPacket_t setCameraPacket;
			setCameraPacket.m_nID = cPacketHeaderID;
			setCameraPacket.m_nType = cPacketTypeSetCameraPos;
			setCameraPacket.m_nTotalSize = sizeof( setCameraPacket );
			setCameraPacket.m_Pos = vecOrigin;
			setCameraPacket.m_Angle = angles;
			SendDataToAllClients( &setCameraPacket, sizeof( setCameraPacket ) );

			if ( ccs_camera_sync.GetBool() )
			{
				ccs_camera_sync.SetValue( false );
				char buf[256];
				V_snprintf( buf, sizeof( buf ), "setpos_exact 0x%X 0x%X 0x%X;setang_exact 0x%X 0x%X 0x%X\n", *(DWORD*)&setCameraPacket.m_Pos.x, *(DWORD*)&setCameraPacket.m_Pos.y, *(DWORD*)&setCameraPacket.m_Pos.z, *(DWORD*)&setCameraPacket.m_Angle.x, *(DWORD*)&setCameraPacket.m_Angle.y, *(DWORD*)&setCameraPacket.m_Angle.z );
				Cbuf_AddText( buf );
				Cbuf_Execute();
			}
		}

		if ( ccs_remote_screenshots.GetBool() )
		{
			static double flTotalTime;
			flTotalTime += flTime;
			if ( flTotalTime > .5f )
			{
				flTotalTime = 0.0f;

				ScreenshotPacket_t screenshotPacket;
				screenshotPacket.m_nID = cPacketHeaderID;
				screenshotPacket.m_nType = cPacketTypeScreenshotRequest;
				screenshotPacket.m_nTotalSize = sizeof( screenshotPacket );
				screenshotPacket.m_szFilename[0] = '\0';
				screenshotPacket.m_nScreenshotID = 1;
				SendDataToAllClients( &screenshotPacket, sizeof( screenshotPacket ) );
			}
		}
						
		bool bHasUpdatedScreenshot = false;
				
		simple_bgr_bitmap &frameBuf = m_pFrameBufWindow->frameBuffer();						

		for ( int i = 0; i < cMaxClients; i++ )
		{
			CConCommandConnection &client = m_Clients[i];
			if ( !client.IsConnected() )
				continue;
			
			client.TickConnection();

			if ( client.HasNewConVarDumpFlag() )
			{
				client.ClearHasNewConVarDumpFlag();

				diffClientsDumpedConVars( i, client.GetConVarDumpVector() );
			}

			if ( m_nViewEndpointIndex == i )
			{
				if ( client.HasNewScreenshotFlag() )
				{
					client.ClearNewScreenshotFlag();

					simple_bitmap &clientScreenshot = client.GetScreenshot();

					if ( ccs_remote_screenshots_delta.GetBool() )
					{
						if ( videomode && !bHasUpdatedScreenshot )
						{
							bHasUpdatedScreenshot = true;

							uint nScreenWidth = videomode->GetModeWidth();
							uint nScreenHeight = videomode->GetModeHeight();

							if ( ( m_screenshot.width() != nScreenWidth ) || ( m_screenshot.height() != nScreenHeight ) )
							{
								m_screenshot.init( nScreenWidth, nScreenHeight );
							}

							videomode->ReadScreenPixels( 0, 0, nScreenWidth, nScreenHeight, m_screenshot.get_ptr(), IMAGE_FORMAT_RGB888 );
						}

						uint mx = MIN( clientScreenshot.width(), m_screenshot.width() ); 
						mx = MIN( mx, frameBuf.width() );
					
						uint my = MIN( clientScreenshot.height(), m_screenshot.height() );
						my = MIN( my, frameBuf.height() );

						for ( uint y = 0; y < my; ++y )
						{
							const uint8 *pSrc1 = clientScreenshot.get_scanline( y );
							const uint8 *pSrc2 = m_screenshot.get_scanline( y );
							uint8 *pDst = frameBuf.get_scanline( y );

							for ( uint x = 0; x < mx; ++x )
							{
								int r = 2 * ( pSrc1[0] - pSrc2[0] ) + 128; 
								int g = 2 * ( pSrc1[1] - pSrc2[1] ) + 128; 
								int b = 2 * ( pSrc1[2] - pSrc2[2] ) + 128; 

								if ( ( r | g | b ) & 0xFFFFFF00 ) 
								{
									if ( r & 0xFFFFFF00 ) { r = (~( r >> 31 )) & 0xFF; }
									if ( g & 0xFFFFFF00 ) { g = (~( g >> 31 )) & 0xFF; }
									if ( b & 0xFFFFFF00 ) { b = (~( b >> 31 )) & 0xFF; }
								}

								pDst[0] = (uint8)b;
								pDst[1] = (uint8)g;
								pDst[2] = (uint8)r;
							
								pSrc1 += 3;
								pSrc2 += 3;
								pDst += 3;
							}
						}

					}
					else
					{
						frameBuf.blit( 0, 0, (simple_bgr_bitmap &)clientScreenshot, true );
					}
				}
			}
		}

		if ( m_pFrameBufWindow )
		{
			m_pFrameBufWindow->update();
		}
	}

	void SendMessageToClients( const char * pCmd )
	{
		if ( !m_bInitialized )
			return;

		int n = V_strlen( pCmd );

		char buf[4096];
		if ( ( n >= 2 ) && ( pCmd[0] == '\"' ) && ( pCmd[ n - 1 ] == '\"' ) )
		{
			memcpy( buf, pCmd + 1, n - 2 );
			buf[n - 2] = '\0';
			pCmd = buf;
		}

		SendStringToClients( pCmd, cPacketTypeMessage );
	}

	void SendConCommandToClients( const char * pCmd, bool bExecLocally = false )
	{
		int n = V_strlen( pCmd );

		char buf[4096];
		if ( ( n >= 2 ) && ( pCmd[0] == '\"' ) && ( pCmd[ n - 1 ] == '\"' ) )
		{
			memcpy( buf, pCmd + 1, n - 2 );
			buf[n - 2] = '\0';
			pCmd = buf;
		}

		if ( m_bInitialized )
		{
			SendStringToClients( pCmd, cPacketTypeCommand );
		}

		if ( bExecLocally )
		{
			Cbuf_AddText( pCmd );
			Cbuf_AddText( "\n" );
			Cbuf_Execute();
		}
	}
	
	void SendCameraPosAndAngleToClients( Vector &vecOrigin, QAngle &angles )
	{
		if ( !m_bInitialized )
			return;

		SetCameraPosPacket_t packet;

		packet.m_nID = cPacketHeaderID;
		packet.m_nType = cPacketTypeSetCameraPos;
		packet.m_nTotalSize = sizeof( packet );
		packet.m_Pos = vecOrigin;
		packet.m_Angle = angles;

		SendDataToAllClients( &packet, sizeof( packet ) );
	}

	void SendScreenshotRequestToClients( const char *pFilename )
	{
		if ( !m_bInitialized )
			return;

		ScreenshotPacket_t packet;

		packet.m_nID = cPacketHeaderID;
		packet.m_nType = cPacketTypeScreenshotRequest;
		packet.m_nTotalSize = sizeof( packet );
		V_strncpy( packet.m_szFilename, pFilename, sizeof( packet.m_szFilename ) );
		packet.m_nScreenshotID = 0;

		SendDataToAllClients( &packet, sizeof( packet ) );
	}

	void DiffConVarsOfAllClients()
	{
		if ( !m_bInitialized )
			return;

		PacketHeader_t packet;
		packet.m_nID = cPacketHeaderID;
		packet.m_nTotalSize = sizeof( PacketHeader_t );
		packet.m_nType = cPacketTypeConVarDumpRequest;
		SendDataToAllClients( &packet, sizeof( packet ) );
	}
	
private:
	bool m_bInitialized;
	CSocketConnection m_Socket;
			
	CConCommandConnection m_Clients[cMaxClients];
	frame_buf_window *m_pFrameBufWindow;

	simple_bitmap m_screenshot;
	int m_nViewEndpointIndex;
	
	void AcceptNewConnections()
	{
		for ( ; ; )
		{
			int nNewEndpointIndex = -1;
			SocketErrorCode_t err = m_Socket.TryAcceptIncomingConnection( &nNewEndpointIndex );
			if ( ( err != SOCKET_SUCCESS ) || ( nNewEndpointIndex < 0 ) )
				break;
			
			int i;
			for ( i = 0; i < cMaxClients; i++ )
			{
				if ( !m_Clients[i].IsConnected() )
					break;
			}
			if ( i == cMaxClients )
			{
				m_Socket.ResetEndpoint( nNewEndpointIndex );
				Warning( "CONCMDSRV: Too many active connections!\n" );
				break;
			}

			if ( !m_Clients[i].Init( &m_Socket, nNewEndpointIndex, false ) )
			{
				Warning( "CONCMDSRV: Failed accepting connection from endpoint %i\n", nNewEndpointIndex );
			}
			else
			{
				ConMsg( "CONCMDSRV: Accepting connection at endpoint %i\n", nNewEndpointIndex );
			}
		}
	}
	
	bool SendDataToAllClients( const void *p, uint nSize )
	{
		if ( !nSize )
			return true;

		bool bSuccess = true;

		for ( uint i = 0; i < cMaxClients; i++ )
		{
			if ( !m_Clients[i].IsConnected() )
				continue;

			if ( !m_Clients[i].SendData( p, nSize ) )
			{
				bSuccess = false;
			}
		}

		return bSuccess;
	}

	void SendStringToClients( const char *pCmd, PacketTypes_t nType )
	{
		uint8 buf[8192];

		uint nStrLen = strlen( pCmd );
		const uint nMaxStrLen = sizeof( buf ) - cPacketHeaderSize;
		nStrLen = MIN( nStrLen, nMaxStrLen );

		PacketHeader_t &hdr = reinterpret_cast<PacketHeader_t &>(buf[0]);
		hdr.m_nID = cPacketHeaderID;
		hdr.m_nType = nType;
		hdr.m_nTotalSize = cPacketHeaderSize + nStrLen;
		memcpy( buf + cPacketHeaderSize, pCmd, nStrLen );

		SendDataToAllClients( buf, hdr.m_nTotalSize );
	}
		
	static int FindConVar( const DumpedConVarVector_t &sortedConVars, const char *pName )
	{
		int l = 0, h = sortedConVars.Count() - 1;
		while ( l <= h )
		{
			int m = ( l + h ) >> 1;
			int d = V_strcmp( sortedConVars[m].m_Name.Get(), pName );
			if ( !d )
				return m;
			else if ( d > 0 )
				h = m - 1;
			else
				l = m + 1;
		}
		return -1;
	}

	static void DiffConVars( DumpedConVarVector_t &serverConVars, DumpedConVarVector_t &clientConVars )
	{
		if ( serverConVars.Count() ) 
		{
			std::sort( &serverConVars.Head(), &serverConVars.Tail() + 1 );
		}

		if ( clientConVars.Count() ) 
		{
			std::sort( &clientConVars.Head(), &clientConVars.Tail() + 1 );
		}

		CUtlVector<bool> clientConVarFoundFlags;
		clientConVarFoundFlags.SetCount( clientConVars.Count() );
		memset( &clientConVarFoundFlags.Head(), 0, sizeof( bool ) * clientConVars.Count() );

		uint nTotalNotFound = 0;
		uint nTotalMatches = 0;
		uint nTotalMismatches = 0;

		for ( int i = 0; i < serverConVars.Count(); i++ )
		{
			const DumpedConVar_t &serverConVar = serverConVars[i];
			const char *pServerConVarName = serverConVar.m_Name.Get();
			const char *pServerConVarValue = serverConVar.m_Value.Get();

			Assert( FindConVar( serverConVars, pServerConVarName ) != -1 );

			int nClientConVarIndex = FindConVar( clientConVars, pServerConVarName );
			if ( nClientConVarIndex < 0 )
			{
				Warning( "%s: Can't find server convar on client, value: \"%s\"\n", pServerConVarName, pServerConVarValue );
				nTotalNotFound++;
			}
			else
			{
				clientConVarFoundFlags[nClientConVarIndex] = true;

				if ( V_strcmp( pServerConVarValue, clientConVars[nClientConVarIndex].m_Value.Get() ) == 0 )
				{
					nTotalMatches++;
				}
				else
				{
					nTotalMismatches++;
					Warning( "%s: Convar diff: server=\"%s\", client=\"%s\"\n", pServerConVarName, pServerConVarValue, clientConVars[nClientConVarIndex].m_Value );
				}
			}
		}

		uint nTotalUnmatched = 0;
		for ( int i = 0; i < clientConVars.Count(); ++i )
		{
			if ( !clientConVarFoundFlags[i] )
			{
				nTotalUnmatched++;
				Warning( "%s: Client convar does not exist on server, value: \"%s\"\n", clientConVars[i].m_Name.Get(), clientConVars[i].m_Value.Get() );
			}
		}

		ConMsg( "--- Summary:\n");
		ConMsg( "Total server convars: %u\n", serverConVars.Count() );
		ConMsg( "Total client convars: %u\n", clientConVars.Count() );
		ConMsg( "Total server convars not found on client: %u\n", nTotalNotFound );
		ConMsg( "Total server convars that match clients: %u\n", nTotalMatches );
		ConMsg( "Total server convars that mismatch clients: %u\n", nTotalMismatches );
		ConMsg( "Total client convars that don't exist on server: %u\n", nTotalUnmatched );
	}

	void diffClientsDumpedConVars( int nClientIndex, DumpedConVarVector_t &clientConVars )
	{
		DumpedConVarVector_t serverConVars;
		DumpConVars( serverConVars );
		ConMsg( "Convar diff of client %i:\n", nClientIndex );
		DiffConVars( serverConVars, clientConVars );
	}
};

CConCommandServer g_ConCommandServer;

CON_COMMAND_F( ccs_start, "Start the con command server.", FCVAR_CHEAT )
{
	if ( !g_ConCommandServer.IsInitialized() )
	{
		g_ConCommandServer.Init();
	}
	else
	{
		Warning( "CONCMDSVR: Already initialized\n" );
	}
}

CON_COMMAND_F( ccs_stop, "Stop the con command server.", FCVAR_CHEAT )
{
	if ( g_ConCommandServer.IsInitialized() )
	{
		g_ConCommandServer.Deinit();
	}
	else
	{
		Warning( "CONCMDSVR: Not initialized\n" );
	}
}

CON_COMMAND_F( ccs_msg, "Send a message to any connected con command server clients.", FCVAR_CHEAT )
{
	if ( g_ConCommandServer.IsInitialized() )
	{
		if ( args.ArgC() < 2 )
		{
			Warning( "Usage: ccs_msg \"message\"\n" );
			return;
		}

		g_ConCommandServer.SendMessageToClients( args.ArgS() );
	}
	else
	{
		Warning( "CONCMDSVR: Not initialized\n" );
	}
}

CON_COMMAND_F( ccs_cmd, "Send a console message to any connected con command server clients.", FCVAR_CHEAT )
{
	if ( g_ConCommandServer.IsInitialized() )
	{
		if ( args.ArgC() < 2 )
		{
			ConMsg( "Usage: ccs_cmd \"command\"\n" );
			return;
		}

		g_ConCommandServer.SendConCommandToClients( args.ArgS() );
	}
	else
	{
		Warning( "CONCMDSVR: Not initialized\n" );
	}
}

CON_COMMAND_F( ccs_cmd_local, "Send a console message to any connected con command server clients, and also issue the command locally.", FCVAR_CHEAT )
{
	if ( g_ConCommandServer.IsInitialized() )
	{
		if ( args.ArgC() < 2 )
		{
			ConMsg( "Usage: ccs_cmd_local \"command\"\n" );
			return;
		}

		g_ConCommandServer.SendConCommandToClients( args.ArgS(), true );
	}
	else
	{
		Warning( "CONCMDSVR: Not initialized\n" );
	}
}

CON_COMMAND_F( ccs_screenshot, "Request screenshots from connected clients", FCVAR_CHEAT )
{
	if ( g_ConCommandServer.IsInitialized() )
	{
		const char *pBaseFileName = "ccs_screenshot";
		if ( args.ArgC() >= 2 )
		{
			pBaseFileName = args.Arg( 1 );
		}
		g_ConCommandServer.SendScreenshotRequestToClients( pBaseFileName );
	}
	else
	{
		Warning( "CONCMDSVR: Not initialized\n" );
	}
}

CON_COMMAND_F( ccs_diff_convars, "Diffs server's convars vs. all connected clients", FCVAR_CHEAT )
{ 
	if ( g_ConCommandServer.IsInitialized() )
	{
		g_ConCommandServer.DiffConVarsOfAllClients();
	}
	else
	{
		Warning( "CONCMDSVR: Not initialized\n" );
	}
}

CON_COMMAND_F( ccs_dump_convars, "Dump all convars to console", FCVAR_CHEAT )
{ 
	DumpedConVarVector_t conVars;
	DumpConVars( conVars );

	for ( int i = 0; i < conVars.Count(); i++ )
	{
		ConMsg( "%s %s\n", conVars[i].m_Name.Get(), conVars[i].m_Value.Get() );
	}
	ConMsg( "Dumped %i convars\n", conVars.Count() );
}

CConCommandConnection g_ConCommandConnection;

CON_COMMAND_F( ccs_connect, "Connect to a con cmd server.", FCVAR_CHEAT )
{
	if ( args.ArgC() < 2 )
	{
		ConMsg( "Usage: ccs_connect \"address\"\n" );
		return;
	}

	if ( g_ConCommandConnection.IsConnected() )
	{
		g_ConCommandConnection.Deinit();
		Warning( "CONCMDSRV: Disconnected\n" );
	}

	if ( g_ConCommandConnection.Init( args.ArgS() ) )
	{
		ConMsg( "CONCMDSRV: Connected\n" );
	}
	else
	{
		Warning( "CONCMDSRV: Failed to connect!\n" );
	}
}

CON_COMMAND_F( ccs_disconnect, "Disconnect from a con cmd server.", FCVAR_CHEAT )
{
	if ( !g_ConCommandConnection.IsConnected() )
	{
		Warning( "CONCMDSRV: Not connected!\n" );
	}
	else
	{	
		g_ConCommandConnection.Deinit();
		
		Warning( "CONCMDSRV: Disconnected\n" );
	}
}

#endif // CON_COMMAND_SERVER_SUPPORT

void CCS_Init()
{
}

void CCS_Shutdown()
{
#ifdef CON_COMMAND_SERVER_SUPPORT
	g_ConCommandConnection.Deinit();
	g_ConCommandServer.Deinit();
#endif
}

void CCS_Tick( float flTime )
{
	(void)flTime;

#ifdef CON_COMMAND_SERVER_SUPPORT
	if ( g_ConCommandConnection.IsConnected() )
	{
		g_ConCommandConnection.TickConnection();
	}
	if ( g_ConCommandServer.IsInitialized() )
	{
		g_ConCommandServer.TickFrame( flTime );
	}
#endif
}