938 lines
19 KiB
C++
938 lines
19 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
|
|
#ifndef VALVE_IPC_WIN32
|
|
#define VALVE_IPC_WIN32
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include <rpcdce.h>
|
|
|
|
// Fwd declarations
|
|
class CValveIpcMgr;
|
|
class CValveIpcServer;
|
|
class CValveIpcClient;
|
|
class CValveIpcChannel;
|
|
|
|
// Version of the protocol
|
|
#define VALVE_IPC_PROTOCOL_VER "1"
|
|
|
|
// Memory used for Valve IPC manager = 256 kB
|
|
#define VALVE_IPC_MGR_MEMORY 256 * 1024
|
|
// Name for Valve IPC manager
|
|
#define VALVE_IPC_MGR_NAME "VALVE_IPC_MGR_"
|
|
|
|
// Default IPC manager interaction timeout = 5 sec
|
|
#define VALVE_IPC_TIMEOUT 5 * 1000
|
|
|
|
// Valve IPC client-server pipe timeout = 5 sec
|
|
#define VALVE_IPC_CS_TIMEOUT 5 * 1000
|
|
|
|
// Valve IPC client-server pipe buffer = 64 kB
|
|
#define VALVE_IPC_CS_BUFFER 64 * 1024
|
|
|
|
#define VALVE_IPC_IMPL inline
|
|
|
|
//
|
|
// CValveIpcMgr
|
|
// Used to discover, register, unregister IPC servers
|
|
//
|
|
// Internally the memory is stored as:
|
|
// [zero-terminated server name-1] [128-bit UUID]
|
|
// [zero-terminated server name-2] [128-bit UUID]
|
|
// ...
|
|
// [zero-terminated server name-N] [128-bit UUID]
|
|
// [<empty string>] [GUID_NULL]
|
|
//
|
|
class CValveIpcMgr
|
|
{
|
|
friend CValveIpcServer;
|
|
friend CValveIpcClient;
|
|
|
|
protected: // Create-able only by server/client
|
|
CValveIpcMgr();
|
|
~CValveIpcMgr();
|
|
|
|
public:
|
|
BOOL Init( DWORD dwTimeout );
|
|
|
|
public:
|
|
BOOL DiscoverServer( char const *szServerName, RPC_CSTR *pszServerUID );
|
|
BOOL RegisterServer( char const *szServerName, RPC_CSTR *pszServerUID );
|
|
BOOL UnregisterServer( RPC_CSTR szServerUID );
|
|
|
|
public:
|
|
HANDLE DuplicateMemorySegmentHandle();
|
|
|
|
private:
|
|
BOOL Shutdown();
|
|
|
|
private:
|
|
HANDLE m_hMutex;
|
|
HANDLE m_hMemorySegment;
|
|
char *m_pMemory;
|
|
|
|
private:
|
|
class Iterator
|
|
{
|
|
public:
|
|
explicit Iterator( char *m_pMemory = NULL )
|
|
{
|
|
m_szServerName = m_pMemory ? m_pMemory : "";
|
|
if ( *m_szServerName )
|
|
{
|
|
memcpy( &m_uuid, m_szServerName + strlen( m_szServerName ) + 1, sizeof( UUID ) );
|
|
}
|
|
else
|
|
{
|
|
m_uuid = GUID_NULL;
|
|
}
|
|
}
|
|
|
|
public:
|
|
BOOL IsValid() const
|
|
{
|
|
return m_szServerName && *m_szServerName &&
|
|
memcmp( &m_uuid, &GUID_NULL, sizeof( UUID ) );
|
|
}
|
|
|
|
Iterator Next() const
|
|
{
|
|
return IsValid() ?
|
|
Iterator( m_szServerName + strlen( m_szServerName ) + 1 + sizeof( UUID ) ) :
|
|
Iterator( NULL );
|
|
}
|
|
|
|
public:
|
|
char * WriteIntoMemory( char *pMemory ) const
|
|
{
|
|
size_t nLen = strlen( m_szServerName ) + 1;
|
|
memmove( pMemory, m_szServerName, strlen( m_szServerName ) + 1 );
|
|
memmove( pMemory + nLen, &m_uuid, sizeof( UUID ) );
|
|
return pMemory + nLen + sizeof( UUID );
|
|
}
|
|
|
|
public:
|
|
char *m_szServerName;
|
|
UUID m_uuid;
|
|
};
|
|
};
|
|
|
|
//
|
|
// CValveIpcServer
|
|
// Used to host an IPC server
|
|
//
|
|
class CValveIpcServer
|
|
{
|
|
public:
|
|
explicit CValveIpcServer( char const *szServerName );
|
|
~CValveIpcServer();
|
|
|
|
public:
|
|
BOOL Register();
|
|
BOOL Unregister();
|
|
|
|
public:
|
|
virtual BOOL ExecuteCommand( char *bufCommand, DWORD numCommandBytes, char *bufResult, DWORD &numResultBytes ) = 0;
|
|
|
|
public:
|
|
BOOL Start();
|
|
BOOL Stop();
|
|
BOOL IsRunning() const { return m_hThread && m_bRunning; }
|
|
|
|
public:
|
|
BOOL EnsureRegisteredAndRunning()
|
|
{
|
|
if ( IsRunning() )
|
|
return TRUE;
|
|
|
|
if ( Register() &&
|
|
Start() &&
|
|
IsRunning() )
|
|
return TRUE;
|
|
|
|
Unregister();
|
|
return FALSE;
|
|
}
|
|
BOOL EnsureStoppedAndUnregistered()
|
|
{
|
|
Unregister();
|
|
return TRUE;
|
|
}
|
|
|
|
public:
|
|
static DWORD WINAPI RunDelegate( LPVOID lpvParam );
|
|
DWORD RunImpl();
|
|
|
|
protected:
|
|
BOOL WaitForEvent();
|
|
BOOL WaitForClient();
|
|
BOOL WaitForCommand();
|
|
BOOL WaitForResult();
|
|
|
|
protected:
|
|
char *m_szServerName;
|
|
RPC_CSTR m_szServerUID;
|
|
|
|
HANDLE m_hMemorySegment;
|
|
HANDLE m_hServerAlive;
|
|
|
|
HANDLE m_hServerPipe;
|
|
HANDLE m_hPipeEvent;
|
|
|
|
HANDLE m_hThread;
|
|
BOOL m_bRunning;
|
|
|
|
char *m_pBufferRead;
|
|
DWORD m_cbBufferRead;
|
|
|
|
char *m_pBufferWrite;
|
|
DWORD m_cbBufferWrite;
|
|
};
|
|
|
|
//
|
|
// CValveIpcClient
|
|
// Used to discover a server and establish a comm channel
|
|
//
|
|
class CValveIpcClient
|
|
{
|
|
public:
|
|
explicit CValveIpcClient( char const *szServerName );
|
|
~CValveIpcClient();
|
|
|
|
public:
|
|
BOOL Connect();
|
|
BOOL Disconnect();
|
|
|
|
public:
|
|
BOOL ExecuteCommand( LPVOID bufIn, DWORD numInBytes, LPVOID bufOut, DWORD &numOutBytes );
|
|
|
|
protected:
|
|
char *m_szServerName;
|
|
RPC_CSTR m_szServerUID;
|
|
|
|
HANDLE m_hClientPipe;
|
|
};
|
|
|
|
|
|
#ifdef UTLBUFFER_H
|
|
|
|
|
|
class CValveIpcServerUtl : public CValveIpcServer
|
|
{
|
|
public:
|
|
explicit CValveIpcServerUtl( char const *szServerName ) : CValveIpcServer( szServerName ) {}
|
|
virtual BOOL ExecuteCommand( char *bufCommand, DWORD numCommandBytes, char *bufResult, DWORD &numResultBytes )
|
|
{
|
|
CUtlBuffer cmd( bufCommand, numCommandBytes, CUtlBuffer::READ_ONLY );
|
|
CUtlBuffer res( bufResult, VALVE_IPC_CS_BUFFER, int( 0 ) );
|
|
if ( !ExecuteCommand( cmd, res ) )
|
|
return FALSE;
|
|
numResultBytes = res.TellPut();
|
|
return TRUE;
|
|
}
|
|
virtual BOOL ExecuteCommand( CUtlBuffer &cmd, CUtlBuffer &res ) = 0;
|
|
};
|
|
|
|
class CValveIpcClientUtl : public CValveIpcClient
|
|
{
|
|
public:
|
|
explicit CValveIpcClientUtl( char const *szServerName ) : CValveIpcClient( szServerName ) {}
|
|
using CValveIpcClient::ExecuteCommand;
|
|
BOOL ExecuteCommand( CUtlBuffer &cmd, CUtlBuffer &res )
|
|
{
|
|
DWORD numResBytes = res.Size();
|
|
if ( !ExecuteCommand( cmd.Base(), cmd.TellPut(), res.Base(), numResBytes ) )
|
|
return FALSE;
|
|
res.SeekPut( CUtlBuffer::SEEK_HEAD, numResBytes );
|
|
return TRUE;
|
|
}
|
|
};
|
|
|
|
|
|
#endif // UTLBUFFER_H
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Implementation section of CValveIpcMgr
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
VALVE_IPC_IMPL CValveIpcMgr::CValveIpcMgr() :
|
|
m_hMutex( NULL ),
|
|
m_hMemorySegment( NULL ),
|
|
m_pMemory( NULL )
|
|
{
|
|
}
|
|
|
|
VALVE_IPC_IMPL CValveIpcMgr::~CValveIpcMgr()
|
|
{
|
|
Shutdown();
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcMgr::Init( DWORD dwTimeout )
|
|
{
|
|
if ( m_pMemory )
|
|
return TRUE;
|
|
|
|
m_hMutex = ::CreateMutex( NULL, FALSE, VALVE_IPC_MGR_NAME "_MTX_" VALVE_IPC_PROTOCOL_VER );
|
|
DWORD dwWaitResult = m_hMutex ? ::WaitForSingleObject( m_hMutex, dwTimeout ) : WAIT_FAILED;
|
|
|
|
if ( dwWaitResult == WAIT_OBJECT_0 ||
|
|
dwWaitResult == WAIT_ABANDONED_0 )
|
|
{
|
|
// We own the mgr segment
|
|
|
|
m_hMemorySegment = ::CreateFileMapping( INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, VALVE_IPC_MGR_MEMORY,
|
|
VALVE_IPC_MGR_NAME "_MEM_" VALVE_IPC_PROTOCOL_VER );
|
|
|
|
if ( m_hMemorySegment )
|
|
{
|
|
LPVOID lpvMemSegment = ::MapViewOfFile( m_hMemorySegment, FILE_MAP_ALL_ACCESS, 0, 0, 0 );
|
|
|
|
if ( lpvMemSegment )
|
|
{
|
|
m_pMemory = ( char * ) lpvMemSegment;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( dwWaitResult == WAIT_OBJECT_0 ||
|
|
dwWaitResult == WAIT_ABANDONED_0 )
|
|
{
|
|
::ReleaseMutex( m_hMutex );
|
|
::CloseHandle( m_hMutex );
|
|
m_hMutex = NULL;
|
|
}
|
|
|
|
// Otherwise shutdown due to an init error
|
|
Shutdown();
|
|
return FALSE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcMgr::Shutdown()
|
|
{
|
|
if ( m_pMemory )
|
|
{
|
|
::UnmapViewOfFile( m_pMemory );
|
|
m_pMemory = NULL;
|
|
}
|
|
|
|
if ( m_hMemorySegment )
|
|
{
|
|
::CloseHandle( m_hMemorySegment );
|
|
m_hMemorySegment = NULL;
|
|
}
|
|
|
|
if ( m_hMutex )
|
|
{
|
|
::ReleaseMutex( m_hMutex );
|
|
::CloseHandle( m_hMutex );
|
|
m_hMutex = NULL;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcMgr::DiscoverServer( char const *szServerName, RPC_CSTR *pszServerUID )
|
|
{
|
|
if ( !szServerName || !*szServerName )
|
|
return FALSE;
|
|
|
|
for ( Iterator it( m_pMemory ); it.IsValid(); it = it.Next() )
|
|
{
|
|
if ( !stricmp( szServerName, it.m_szServerName ) )
|
|
{
|
|
if ( pszServerUID )
|
|
{
|
|
UuidToString( &it.m_uuid, pszServerUID );
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcMgr::RegisterServer( char const *szServerName, RPC_CSTR *pszServerUID )
|
|
{
|
|
if ( !szServerName || !*szServerName )
|
|
return FALSE;
|
|
|
|
Iterator it( m_pMemory );
|
|
for ( ; it.IsValid(); it = it.Next() )
|
|
{
|
|
if ( !stricmp( szServerName, it.m_szServerName ) )
|
|
{
|
|
// Server with same name already registered,
|
|
// check if it is alive
|
|
char chAliveName[ MAX_PATH ];
|
|
RPC_CSTR szBaseName;
|
|
UuidToString( &it.m_uuid, &szBaseName );
|
|
sprintf( chAliveName, "%s" "_ALIVE_" VALVE_IPC_PROTOCOL_VER, szBaseName );
|
|
RpcStringFree( &szBaseName );
|
|
HANDLE hAliveTest = ::OpenMutex( MUTEX_ALL_ACCESS, FALSE, chAliveName );
|
|
if ( hAliveTest )
|
|
{
|
|
::CloseHandle( hAliveTest );
|
|
return FALSE; // Server is alive, can't register again
|
|
}
|
|
else
|
|
{
|
|
// Server is dead, re-use its UID
|
|
if ( pszServerUID )
|
|
{
|
|
UuidToString( &it.m_uuid, pszServerUID );
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Iterator points at the last element in the list, write the new server info
|
|
Iterator itNewServer;
|
|
itNewServer.m_szServerName = const_cast< char * >( szServerName );
|
|
UuidCreate( &itNewServer.m_uuid );
|
|
|
|
// Check that there's enough memory left in the storage
|
|
char *pUpdateMemory = it.m_szServerName;
|
|
if ( pUpdateMemory + strlen( szServerName ) + 1 + 32 + 2 * sizeof( UUID ) >
|
|
m_pMemory + VALVE_IPC_MGR_MEMORY )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Insert the new server in the list
|
|
pUpdateMemory = itNewServer.WriteIntoMemory( pUpdateMemory );
|
|
pUpdateMemory = Iterator().WriteIntoMemory( pUpdateMemory );
|
|
|
|
if ( pszServerUID )
|
|
{
|
|
UuidToString( &itNewServer.m_uuid, pszServerUID );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcMgr::UnregisterServer( RPC_CSTR szServerUID )
|
|
{
|
|
if ( !szServerUID || !*szServerUID )
|
|
return FALSE;
|
|
|
|
RPC_STATUS rpcS;
|
|
UUID uuid;
|
|
if ( RPC_S_OK != UuidFromString( szServerUID, &uuid ) )
|
|
return FALSE;
|
|
|
|
for ( Iterator it( m_pMemory ); it.IsValid(); it = it.Next() )
|
|
{
|
|
if ( UuidEqual( &it.m_uuid, &uuid, &rpcS ) )
|
|
{
|
|
// This is our server, remove it from the list
|
|
char *pMemoryUpdate = it.m_szServerName;
|
|
for ( Iterator itRemaining = it.Next(); itRemaining.IsValid(); )
|
|
{
|
|
Iterator itNext = itRemaining.Next();
|
|
pMemoryUpdate = itRemaining.WriteIntoMemory( pMemoryUpdate );
|
|
itRemaining = itNext;
|
|
}
|
|
Iterator().WriteIntoMemory( pMemoryUpdate );
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL HANDLE CValveIpcMgr::DuplicateMemorySegmentHandle()
|
|
{
|
|
if ( !m_hMemorySegment )
|
|
return NULL;
|
|
|
|
HANDLE hDup = NULL;
|
|
::DuplicateHandle( GetCurrentProcess(), m_hMemorySegment,
|
|
GetCurrentProcess(), &hDup, DUPLICATE_SAME_ACCESS,
|
|
FALSE, DUPLICATE_SAME_ACCESS );
|
|
|
|
return hDup;
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Implementation section of CValveIpcServer
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
VALVE_IPC_IMPL CValveIpcServer::CValveIpcServer( char const *szServerName )
|
|
{
|
|
// Copy server name
|
|
size_t nLen = szServerName ? strlen( szServerName ) : 0;
|
|
m_szServerName = new char[ nLen + 1 ];
|
|
strcpy( m_szServerName, szServerName ? szServerName : "" );
|
|
|
|
// Init remaining
|
|
m_szServerUID = NULL;
|
|
m_hMemorySegment = NULL;
|
|
m_hServerAlive = NULL;
|
|
m_hServerPipe = NULL;
|
|
m_hPipeEvent = NULL;
|
|
m_hThread = NULL;
|
|
m_bRunning = FALSE;
|
|
|
|
m_pBufferRead = NULL;
|
|
m_cbBufferRead = 0;
|
|
m_pBufferWrite = NULL;
|
|
m_cbBufferWrite = 0;
|
|
}
|
|
|
|
VALVE_IPC_IMPL CValveIpcServer::~CValveIpcServer()
|
|
{
|
|
Unregister();
|
|
|
|
if ( m_szServerName )
|
|
{
|
|
delete [] m_szServerName;
|
|
m_szServerName = NULL;
|
|
}
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcServer::Register()
|
|
{
|
|
if ( m_szServerUID )
|
|
return TRUE;
|
|
|
|
CValveIpcMgr mgr;
|
|
if ( !mgr.Init( VALVE_IPC_TIMEOUT ) )
|
|
return FALSE;
|
|
|
|
// Try registering the server
|
|
if ( !mgr.RegisterServer( m_szServerName, &m_szServerUID ) )
|
|
return FALSE;
|
|
|
|
// Server got registered, duplicate memory segment handle
|
|
m_hMemorySegment = mgr.DuplicateMemorySegmentHandle();
|
|
|
|
// create the "server alive" object
|
|
char chAliveName[ MAX_PATH ];
|
|
sprintf( chAliveName, "%s" "_ALIVE_" VALVE_IPC_PROTOCOL_VER, m_szServerUID );
|
|
m_hServerAlive = ::CreateMutex( NULL, FALSE, chAliveName );
|
|
if ( !m_hServerAlive )
|
|
{
|
|
Unregister();
|
|
return FALSE;
|
|
}
|
|
|
|
// Create the server pipe event
|
|
m_hPipeEvent = ::CreateEvent( NULL, TRUE, FALSE, NULL );
|
|
if ( !m_hPipeEvent )
|
|
{
|
|
Unregister();
|
|
return FALSE;
|
|
}
|
|
|
|
// Create the server end of the pipe
|
|
char chPipeName[ MAX_PATH ];
|
|
sprintf( chPipeName, "\\\\.\\pipe\\" "%s" "_PIPE_" VALVE_IPC_PROTOCOL_VER, m_szServerUID );
|
|
m_hServerPipe = ::CreateNamedPipe(
|
|
chPipeName,
|
|
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_WRITE_THROUGH,
|
|
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE,
|
|
1,
|
|
VALVE_IPC_CS_BUFFER, VALVE_IPC_CS_BUFFER,
|
|
VALVE_IPC_CS_TIMEOUT,
|
|
NULL
|
|
);
|
|
if ( !m_hServerPipe )
|
|
{
|
|
Unregister();
|
|
return FALSE;
|
|
}
|
|
|
|
// Allocate the pipe buffer
|
|
m_pBufferRead = new char [ VALVE_IPC_CS_BUFFER ];
|
|
if ( !m_pBufferRead )
|
|
{
|
|
Unregister();
|
|
return FALSE;
|
|
}
|
|
m_pBufferWrite = new char [ VALVE_IPC_CS_BUFFER ];
|
|
if ( !m_pBufferWrite )
|
|
{
|
|
Unregister();
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcServer::Unregister()
|
|
{
|
|
if ( !m_szServerUID )
|
|
return FALSE;
|
|
else
|
|
{
|
|
CValveIpcMgr mgr;
|
|
if ( mgr.Init( VALVE_IPC_TIMEOUT ) )
|
|
{
|
|
mgr.UnregisterServer( m_szServerUID );
|
|
}
|
|
}
|
|
|
|
// Stop the server if it is running
|
|
Stop();
|
|
|
|
m_cbBufferRead = 0;
|
|
delete [] m_pBufferRead;
|
|
m_pBufferRead = NULL;
|
|
|
|
m_cbBufferWrite = 0;
|
|
delete [] m_pBufferWrite;
|
|
m_pBufferWrite = NULL;
|
|
|
|
if ( m_hServerPipe )
|
|
{
|
|
::CloseHandle( m_hServerPipe );
|
|
m_hServerPipe = NULL;
|
|
}
|
|
|
|
if ( m_hPipeEvent )
|
|
{
|
|
::CloseHandle( m_hPipeEvent );
|
|
m_hPipeEvent = NULL;
|
|
}
|
|
|
|
if ( m_hServerAlive )
|
|
{
|
|
::CloseHandle( m_hServerAlive );
|
|
m_hServerAlive = NULL;
|
|
}
|
|
|
|
if ( m_hMemorySegment )
|
|
{
|
|
::CloseHandle( m_hMemorySegment );
|
|
m_hMemorySegment = NULL;
|
|
}
|
|
|
|
if ( m_szServerUID )
|
|
{
|
|
RpcStringFree( &m_szServerUID );
|
|
m_szServerUID = NULL;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcServer::WaitForEvent()
|
|
{
|
|
for ( ; m_bRunning ; )
|
|
{
|
|
DWORD dwWaitResult = ::WaitForSingleObject( m_hPipeEvent, 50 );
|
|
switch ( dwWaitResult )
|
|
{
|
|
case WAIT_TIMEOUT:
|
|
continue;
|
|
|
|
case WAIT_OBJECT_0:
|
|
case WAIT_ABANDONED_0:
|
|
::ResetEvent( m_hPipeEvent );
|
|
return m_bRunning;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcServer::WaitForClient()
|
|
{
|
|
OVERLAPPED ov;
|
|
memset( &ov, 0, sizeof( ov ) );
|
|
ov.hEvent = m_hPipeEvent;
|
|
|
|
BOOL bResult = ::ConnectNamedPipe( m_hServerPipe, &ov );
|
|
if ( bResult ) // Overlapped "ConnectNamedPipe" always returns FALSE
|
|
return FALSE;
|
|
|
|
switch ( GetLastError() )
|
|
{
|
|
case ERROR_IO_PENDING:
|
|
// Wait for client to connect
|
|
break;
|
|
|
|
case ERROR_PIPE_CONNECTED:
|
|
SetEvent( ov.hEvent );
|
|
return TRUE;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !WaitForEvent() )
|
|
return FALSE;
|
|
|
|
DWORD dwConnectDummy;
|
|
if ( !::GetOverlappedResult( m_hServerPipe, &ov, &dwConnectDummy, FALSE ) )
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcServer::WaitForCommand()
|
|
{
|
|
OVERLAPPED ov;
|
|
memset( &ov, 0, sizeof( ov ) );
|
|
ov.hEvent = m_hPipeEvent;
|
|
|
|
m_cbBufferRead = 0;
|
|
BOOL bRead = ::ReadFile( m_hServerPipe, m_pBufferRead, VALVE_IPC_CS_BUFFER, &m_cbBufferRead, &ov );
|
|
|
|
if ( bRead &&
|
|
m_cbBufferRead )
|
|
return TRUE;
|
|
|
|
if ( !bRead &&
|
|
GetLastError() == ERROR_IO_PENDING )
|
|
{
|
|
if ( !WaitForEvent() )
|
|
return FALSE;
|
|
|
|
bRead = GetOverlappedResult( m_hServerPipe, &ov, &m_cbBufferRead, FALSE );
|
|
if ( !bRead || !m_cbBufferRead )
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcServer::WaitForResult()
|
|
{
|
|
OVERLAPPED ov;
|
|
memset( &ov, 0, sizeof( ov ) );
|
|
ov.hEvent = m_hPipeEvent;
|
|
|
|
DWORD cbWrite;
|
|
BOOL bWrite = ::WriteFile( m_hServerPipe, m_pBufferWrite, m_cbBufferWrite, &cbWrite, &ov );
|
|
|
|
if ( bWrite &&
|
|
cbWrite == m_cbBufferWrite )
|
|
return TRUE;
|
|
|
|
if ( !bWrite &&
|
|
GetLastError() == ERROR_IO_PENDING )
|
|
{
|
|
if ( !WaitForEvent() )
|
|
return FALSE;
|
|
|
|
bWrite = GetOverlappedResult( m_hServerPipe, &ov, &cbWrite, FALSE );
|
|
if ( !bWrite ||
|
|
cbWrite != m_cbBufferWrite )
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL DWORD WINAPI CValveIpcServer::RunDelegate( LPVOID lpvParam )
|
|
{
|
|
return reinterpret_cast< CValveIpcServer * >( lpvParam )->RunImpl();
|
|
}
|
|
|
|
VALVE_IPC_IMPL DWORD CValveIpcServer::RunImpl()
|
|
{
|
|
for ( ; WaitForClient() ; )
|
|
{
|
|
for ( ; WaitForCommand() ; )
|
|
{
|
|
m_cbBufferWrite = 0;
|
|
BOOL bResult = ExecuteCommand( m_pBufferRead, m_cbBufferRead, m_pBufferWrite, m_cbBufferWrite );
|
|
if ( !bResult || !m_cbBufferWrite )
|
|
break;
|
|
|
|
bResult = WaitForResult();
|
|
if ( !bResult )
|
|
break;
|
|
}
|
|
|
|
::DisconnectNamedPipe( m_hServerPipe );
|
|
}
|
|
|
|
m_bRunning = FALSE;
|
|
return FALSE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcServer::Start()
|
|
{
|
|
if ( m_hThread )
|
|
return FALSE;
|
|
|
|
m_hThread = ::CreateThread( NULL, 0, RunDelegate, this, CREATE_SUSPENDED, NULL );
|
|
if ( !m_hThread )
|
|
return FALSE;
|
|
|
|
m_bRunning = TRUE;
|
|
::ResumeThread( m_hThread );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcServer::Stop()
|
|
{
|
|
if ( !m_hThread )
|
|
return FALSE;
|
|
|
|
m_bRunning = FALSE;
|
|
::WaitForSingleObject( m_hThread, INFINITE );
|
|
|
|
::CloseHandle( m_hThread );
|
|
m_hThread = NULL;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Implementation section of CValveIpcClient
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
VALVE_IPC_IMPL CValveIpcClient::CValveIpcClient( char const *szServerName )
|
|
{
|
|
// Copy server name
|
|
size_t nLen = szServerName ? strlen( szServerName ) : 0;
|
|
m_szServerName = new char[ nLen + 1 ];
|
|
strcpy( m_szServerName, szServerName ? szServerName : "" );
|
|
|
|
// Init remaining
|
|
m_szServerUID = NULL;
|
|
m_hClientPipe = NULL;
|
|
}
|
|
|
|
VALVE_IPC_IMPL CValveIpcClient::~CValveIpcClient()
|
|
{
|
|
Disconnect();
|
|
|
|
if ( m_szServerName )
|
|
{
|
|
delete [] m_szServerName;
|
|
m_szServerName = NULL;
|
|
}
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcClient::Connect()
|
|
{
|
|
if ( m_szServerUID )
|
|
return TRUE;
|
|
|
|
CValveIpcMgr mgr;
|
|
if ( !mgr.Init( VALVE_IPC_TIMEOUT ) )
|
|
return FALSE;
|
|
|
|
// Try discovering the server
|
|
if ( !mgr.DiscoverServer( m_szServerName, &m_szServerUID ) )
|
|
return FALSE;
|
|
|
|
// Server got discovered
|
|
// check the "server alive" object
|
|
char chAliveName[ MAX_PATH ];
|
|
sprintf( chAliveName, "%s" "_ALIVE_" VALVE_IPC_PROTOCOL_VER, m_szServerUID );
|
|
|
|
HANDLE hServerAlive = ::OpenMutex( MUTEX_ALL_ACCESS, FALSE, chAliveName );
|
|
if ( !hServerAlive )
|
|
{
|
|
Disconnect();
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
::CloseHandle( hServerAlive );
|
|
hServerAlive = NULL;
|
|
}
|
|
|
|
// Connect the server pipe
|
|
char chPipeName[ MAX_PATH ];
|
|
sprintf( chPipeName, "\\\\.\\pipe\\" "%s" "_PIPE_" VALVE_IPC_PROTOCOL_VER, m_szServerUID );
|
|
m_hClientPipe = ::CreateFile(
|
|
chPipeName,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_WRITE_THROUGH,
|
|
NULL
|
|
);
|
|
if ( !m_hClientPipe )
|
|
{
|
|
Disconnect();
|
|
return FALSE;
|
|
}
|
|
|
|
DWORD dwPipeMode = PIPE_READMODE_MESSAGE;
|
|
SetNamedPipeHandleState( m_hClientPipe, &dwPipeMode, NULL, NULL );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcClient::Disconnect()
|
|
{
|
|
if ( !m_szServerUID )
|
|
return FALSE;
|
|
|
|
if ( m_hClientPipe )
|
|
{
|
|
::CloseHandle( m_hClientPipe );
|
|
m_hClientPipe = NULL;
|
|
}
|
|
|
|
if ( m_szServerUID )
|
|
{
|
|
RpcStringFree( &m_szServerUID );
|
|
m_szServerUID = NULL;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VALVE_IPC_IMPL BOOL CValveIpcClient::ExecuteCommand( LPVOID bufIn, DWORD numInBytes, LPVOID bufOut, DWORD &numOutBytes )
|
|
{
|
|
if ( !m_szServerUID || !m_hClientPipe )
|
|
return FALSE;
|
|
|
|
BOOL bTransact = TransactNamedPipe( m_hClientPipe,
|
|
bufIn, numInBytes,
|
|
bufOut, numOutBytes,
|
|
&numOutBytes,
|
|
NULL );
|
|
if ( !bTransact &&
|
|
GetLastError() == ERROR_MORE_DATA )
|
|
{
|
|
bTransact = TRUE;
|
|
}
|
|
return bTransact;
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif // #ifndef VALVE_IPC_WIN32
|