able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/cluster/mgmt/cluscfg/server/ccluscfgcallback.cpp

1026 lines
25 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000-2001 Microsoft Corporation
//
// Module Name:
// CClusCfgCallback.cpp
//
// Description:
// This file contains the definition of the CClusCfgCallback
// class.
//
// The class CClusCfgCallback inplements the callback
// interface between this server and its clients. It implements the
// IClusCfgCallback interface.
//
// Documentation:
//
// Header File:
// CClusCfgCallback.h
//
// Maintained By:
// Galen Barbee (GalenB) 22-FEB-2000
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// Include Files
//////////////////////////////////////////////////////////////////////////////
#include "pch.h"
#include "CClusCfgCallback.h"
//////////////////////////////////////////////////////////////////////////////
// Constant Definitions
//////////////////////////////////////////////////////////////////////////////
DEFINE_THISCLASS( "CClusCfgCallback" );
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusCfgCallback class
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusCfgCallback::S_HrCreateInstance
//
// Description:
// Create a CClusCfgCallback instance.
//
// Arguments:
// ppunkOut
// The IUnknown interface of the newly created object.
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULTs
// Object initialization failed.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CClusCfgCallback::S_HrCreateInstance( IUnknown ** ppunkOut )
{
TraceFunc( "" );
HRESULT hr;
CClusCfgCallback * lpccs = NULL;
if ( ppunkOut == NULL )
{
hr = THR( E_POINTER );
goto Cleanup;
} // if:
lpccs = new CClusCfgCallback();
if ( lpccs == NULL )
{
hr = THR( E_OUTOFMEMORY );
goto Cleanup;
} // if: error allocating object
hr = THR( lpccs->HrInit() );
if ( FAILED( hr ) )
{
goto Cleanup;
} // if: HrInit() succeeded
hr = THR( lpccs->TypeSafeQI( IUnknown, ppunkOut ) );
Cleanup:
if ( lpccs != NULL )
{
lpccs->Release();
} // if:
if ( FAILED( hr ) )
{
LogMsg( L"[SRV] CClusCfgCallback::S_HrCreateInstance() failed. (hr = %#08x)", hr );
} // if:
HRETURN( hr );
} //*** CClusCfgCallback::S_HrCreateInstance
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusCfgCallback::CClusCfgCallback
//
// Description:
// Constructor of the CClusCfgCallback class. This initializes
// the m_cRef variable to 1 instead of 0 to account of possible
// QueryInterface failure in DllGetClassObject.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
CClusCfgCallback::CClusCfgCallback( void )
: m_cRef( 1 )
{
TraceFunc( "" );
// Increment the count of components in memory so the DLL hosting this
// object cannot be unloaded.
InterlockedIncrement( &g_cObjects );
Assert( m_pccc == NULL );
Assert( m_hEvent == NULL );
Assert( m_pcszNodeName == NULL );
Assert( m_pclsidTaskMajor == NULL );
Assert( m_pclsidTaskMinor == NULL );
Assert( m_pulMin == NULL );
Assert( m_pulMax == NULL );
Assert( m_pulCurrent == NULL );
Assert( m_phrStatus == NULL );
Assert( m_pcszDescription == NULL );
Assert( m_pftTime == NULL );
Assert( m_pcszReference == NULL );
Assert( !m_fPollingMode );
Assert( m_bstrNodeName == NULL );
Assert( m_plLogger == NULL );
TraceFuncExit();
} //*** CClusCfgCallback::CClusCfgCallback
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusCfgCallback::~CClusCfgCallback
//
// Description:
// Desstructor of the CClusCfgCallback class.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
CClusCfgCallback::~CClusCfgCallback( void )
{
TraceFunc( "" );
if ( m_hEvent != NULL )
{
if ( CloseHandle( m_hEvent ) == false )
{
TW32( GetLastError() );
LogMsg( L"[SRV] Cannot close event handle. (sc = %#08x)", GetLastError() );
}
} // if:
TraceSysFreeString( m_bstrNodeName );
if ( m_pccc != NULL )
{
m_pccc->Release();
} // if:
if ( m_plLogger != NULL )
{
m_plLogger->Release();
} // if:
// There's going to be one less component in memory. Decrement component count.
InterlockedDecrement( &g_cObjects );
TraceFuncExit();
} //*** CClusCfgCallback::~CClusCfgCallback
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusterConfigurationInfo::SendStatusReport
//
// Description:
//
// Arguments:
//
// Return Value:
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CClusCfgCallback::SendStatusReport(
CLSID clsidTaskMajorIn,
CLSID clsidTaskMinorIn,
ULONG ulMinIn,
ULONG ulMaxIn,
ULONG ulCurrentIn,
HRESULT hrStatusIn,
const WCHAR * pcszDescriptionIn
)
{
TraceFunc1( "pcszDescriptionIn = '%ls'", pcszDescriptionIn == NULL ? L"<null>" : pcszDescriptionIn );
HRESULT hr = S_OK;
BSTR bstrDescription = NULL;
FILETIME ft;
bstrDescription = TraceSysAllocString( pcszDescriptionIn );
if ( bstrDescription == NULL )
{
hr = THR( E_OUTOFMEMORY );
goto Cleanup;
} // if:
GetSystemTimeAsFileTime( &ft );
hr = THR( SendStatusReport(
NULL,
clsidTaskMajorIn,
clsidTaskMinorIn,
ulMinIn,
ulMaxIn,
ulCurrentIn,
hrStatusIn,
bstrDescription,
&ft,
NULL
) );
Cleanup:
TraceSysFreeString( bstrDescription );
HRETURN( hr );
} //*** CClusCfgCallback::SendStatusReport
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusterConfigurationInfo::SendStatusReport
//
// Description:
//
// Arguments:
//
// Return Value:
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CClusCfgCallback::SendStatusReport(
CLSID clsidTaskMajorIn,
CLSID clsidTaskMinorIn,
ULONG ulMinIn,
ULONG ulMaxIn,
ULONG ulCurrentIn,
HRESULT hrStatusIn,
DWORD dwDescriptionIn
)
{
TraceFunc1( "dwDescriptionIn = %d", dwDescriptionIn );
HRESULT hr = S_OK;
BSTR bstrDescription = NULL;
FILETIME ft;
hr = THR( HrLoadStringIntoBSTR( g_hInstance, dwDescriptionIn, &bstrDescription ) );
if ( FAILED( hr ) )
{
goto Cleanup;
} // if:
GetSystemTimeAsFileTime( &ft );
hr = THR( SendStatusReport(
NULL,
clsidTaskMajorIn,
clsidTaskMinorIn,
ulMinIn,
ulMaxIn,
ulCurrentIn,
hrStatusIn,
bstrDescription,
&ft,
NULL
) );
Cleanup:
TraceSysFreeString( bstrDescription );
HRETURN( hr );
} //*** CClusCfgCallback::SendStatusReport
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusCfgCallback -- IUnknown interface.
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//++
//
// STDMETHODIMP_( ULONG )
// CClusCfgCallback:: [IUNKNOWN] AddRef
//
// Description:
// Increment the reference count of this object by one.
//
// Arguments:
// None.
//
// Return Value:
// The new reference count.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_( ULONG )
CClusCfgCallback::AddRef( void )
{
TraceFunc( "[IUnknown]" );
InterlockedIncrement( & m_cRef );
RETURN( m_cRef );
} //*** CClusCfgCallback::AddRef
//////////////////////////////////////////////////////////////////////////////
//++
//
// STDMETHODIMP_( ULONG )
// CClusCfgCallback:: [IUNKNOWN] Release
//
// Description:
// Decrement the reference count of this object by one.
//
// Arguments:
// None.
//
// Return Value:
// The new reference count.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_( ULONG )
CClusCfgCallback::Release( void )
{
TraceFunc( "[IUnknown]" );
InterlockedDecrement( &m_cRef );
if ( m_cRef > 0 )
{
RETURN( m_cRef );
} // if: reference count equal to zero
TraceDo( delete this );
RETURN( 0 );
} //*** CClusCfgCallback::Release
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusCfgCallback:: [INKNOWN] QueryInterface
//
// Description:
// Query this object for the passed in interface.
//
// Arguments:
// IN REFIID riid,
// Id of interface requested.
//
// OUT void ** ppv
// Pointer to the requested interface.
//
// Return Value:
// S_OK
// If the interface is available on this object.
//
// E_NOINTERFACE
// If the interface is not available.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CClusCfgCallback::QueryInterface( REFIID riid, void ** ppv )
{
TraceQIFunc( riid, ppv );
HRESULT hr = E_NOINTERFACE;
if ( IsEqualIID( riid, IID_IUnknown ) )
{
*ppv = static_cast< IClusCfgCallback * >( this );
hr = S_OK;
} // if: IUnknown
else if ( IsEqualIID( riid, IID_IClusCfgCallback ) )
{
*ppv = TraceInterface( __THISCLASS__, IClusCfgCallback, this, 0 );
hr = S_OK;
} // else if:
else if ( IsEqualIID( riid, IID_IClusCfgInitialize ) )
{
*ppv = TraceInterface( __THISCLASS__, IClusCfgInitialize, this, 0 );
hr = S_OK;
} // else if:
else if ( IsEqualIID( riid, IID_IClusCfgPollingCallback ) )
{
*ppv = TraceInterface( __THISCLASS__, IClusCfgPollingCallback, this, 0 );
hr = S_OK;
} // else if:
else if ( IsEqualIID( riid, IID_IClusCfgSetPollingCallback ) )
{
*ppv = TraceInterface( __THISCLASS__, IClusCfgSetPollingCallback, this, 0 );
hr = S_OK;
} // else if:
if ( SUCCEEDED( hr ) )
{
((IUnknown *) *ppv)->AddRef( );
} // if: success
QIRETURN_IGNORESTDMARSHALLING( hr, riid );
} //*** CClusCfgCallback::QueryInterface
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusCfgCallback -- IClusCfgCallback interface.
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusterConfigurationInfo::SendStatusReport
//
// Description:
//
// Arguments:
//
// Return Value:
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CClusCfgCallback::SendStatusReport(
LPCWSTR pcszNodeNameIn,
CLSID clsidTaskMajorIn,
CLSID clsidTaskMinorIn,
ULONG ulMinIn,
ULONG ulMaxIn,
ULONG ulCurrentIn,
HRESULT hrStatusIn,
LPCWSTR pcszDescriptionIn,
FILETIME * pftTimeIn,
LPCWSTR pcszReferenceIn
)
{
TraceFunc1( "[IClusCfgCallback] pcszDescriptionIn = '%s'", pcszDescriptionIn == NULL ? TEXT("<null>") : pcszDescriptionIn );
HRESULT hr = S_OK;
if ( pcszNodeNameIn == NULL )
{
pcszNodeNameIn = m_bstrNodeName;
} // if:
TraceMsg( mtfFUNC, L"pcszNodeNameIn = %s", pcszNodeNameIn );
TraceMsgGUID( mtfFUNC, "clsidTaskMajorIn ", clsidTaskMajorIn );
TraceMsgGUID( mtfFUNC, "clsidTaskMinorIn ", clsidTaskMinorIn );
TraceMsg( mtfFUNC, L"ulMinIn = %u", ulMinIn );
TraceMsg( mtfFUNC, L"ulMaxIn = %u", ulMaxIn );
TraceMsg( mtfFUNC, L"ulCurrentIn = %u", ulCurrentIn );
TraceMsg( mtfFUNC, L"hrStatusIn = %#x", hrStatusIn );
TraceMsg( mtfFUNC, L"pcszDescriptionIn = '%ws'", ( pcszDescriptionIn ? pcszDescriptionIn : L"<null>" ) );
//
// TODO: 21 NOV 2000 GalenB
//
// How do we log pftTimeIn?
//
TraceMsg( mtfFUNC, L"pcszReferenceIn = '%ws'", ( pcszReferenceIn ? pcszReferenceIn : L"<null>" ) );
hr = THR( CClCfgSrvLogger::S_HrLogStatusReport(
m_plLogger
, pcszNodeNameIn
, clsidTaskMajorIn
, clsidTaskMinorIn
, ulMinIn
, ulMaxIn
, ulCurrentIn
, hrStatusIn
, pcszDescriptionIn
, pftTimeIn
, pcszReferenceIn
) );
// Local logging - don't send up
if ( IsEqualIID( clsidTaskMajorIn, TASKID_Major_Server_Log ) )
{
goto Cleanup;
} // if:
if ( m_fPollingMode )
{
Assert( m_pccc == NULL );
TraceMsg( mtfFUNC, L"[SRV] Sending the status message with polling." );
hr = THR( HrQueueStatusReport(
pcszNodeNameIn,
clsidTaskMajorIn,
clsidTaskMinorIn,
ulMinIn,
ulMaxIn,
ulCurrentIn,
hrStatusIn,
pcszDescriptionIn,
pftTimeIn,
pcszReferenceIn
) );
} // if:
else if ( m_pccc != NULL )
{
TraceMsg( mtfFUNC, L"[SRV] Sending the status message without polling." );
hr = THR( m_pccc->SendStatusReport(
pcszNodeNameIn,
clsidTaskMajorIn,
clsidTaskMinorIn,
ulMinIn,
ulMaxIn,
ulCurrentIn,
hrStatusIn,
pcszDescriptionIn,
pftTimeIn,
pcszReferenceIn
) );
} // else if:
else
{
LogMsg( L"[SRV] Neither a polling callback or a regular callback were found. No messages are being sent to anyone!" );
} // else:
Cleanup:
HRETURN( hr );
} //*** CClusCfgCallback::SendStatusReport
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusCfgCallback -- IClusCfgPollingCallback interface.
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusterConfigurationInfo::GetStatusReport
//
// Description:
//
// Arguments:
//
// Return Value:
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CClusCfgCallback::GetStatusReport(
BSTR * pbstrNodeNameOut,
CLSID * pclsidTaskMajorOut,
CLSID * pclsidTaskMinorOut,
ULONG * pulMinOut,
ULONG * pulMaxOut,
ULONG * pulCurrentOut,
HRESULT * phrStatusOut,
BSTR * pbstrDescriptionOut,
FILETIME * pftTimeOut,
BSTR * pbstrReferenceOut
)
{
TraceFunc( "[IClusCfgPollingCallback]" );
HRESULT hr;
DWORD sc;
sc = WaitForSingleObject( m_hEvent, 0 );
if ( sc == WAIT_FAILED )
{
sc = TW32( GetLastError() );
hr = HRESULT_FROM_WIN32( sc );
goto Cleanup;
} // if:
if ( sc == WAIT_TIMEOUT )
{
Assert( *m_pcszNodeName != NULL );
*pbstrNodeNameOut = SysAllocString( m_pcszNodeName );
if ( *pbstrNodeNameOut == NULL )
{
goto OutOfMemory;
} // if:
*pclsidTaskMajorOut = *m_pclsidTaskMajor;
*pclsidTaskMinorOut = *m_pclsidTaskMinor;
*pulMinOut = *m_pulMin;
*pulMaxOut = *m_pulMax;
*pulCurrentOut = *m_pulCurrent;
*phrStatusOut = *m_phrStatus;
*pftTimeOut = *m_pftTime;
if ( m_pcszDescription != NULL )
{
*pbstrDescriptionOut = SysAllocString( m_pcszDescription );
if ( *pbstrDescriptionOut == NULL )
{
goto OutOfMemory;
} // if:
} // if:
else
{
*pbstrDescriptionOut = NULL;
} // else:
if ( m_pcszReference != NULL )
{
*pbstrReferenceOut = SysAllocString( m_pcszReference );
if ( *pbstrReferenceOut == NULL )
{
goto OutOfMemory;
} // if:
} // if:
else
{
*pbstrReferenceOut = NULL;
} // else:
hr = S_OK;
} // if: event was not signaled
else
{
hr = S_FALSE;
} // else: event was signaled
goto Cleanup;
OutOfMemory:
hr = E_OUTOFMEMORY;
Cleanup:
HRETURN( hr );
} //*** CClusCfgCallback::GetStatusReport
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusterConfigurationInfo::SetHResult
//
// Description:
//
// Arguments:
//
// Return Value:
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CClusCfgCallback::SetHResult( HRESULT hrIn )
{
TraceFunc( "[IClusCfgPollingCallback]" );
HRESULT hr = S_OK;
DWORD sc;
m_hr = hrIn;
if ( hrIn != S_OK )
{
LogMsg( L"[SRV] SetHResult(). (hrIn = %#08x)", hrIn );
} // if:
if ( !SetEvent( m_hEvent ) )
{
sc = TW32( GetLastError() );
hr = HRESULT_FROM_WIN32( sc );
LogMsg( L"[SRV] Could not signal event. (hr = %#08x)", hr );
} // if:
HRETURN( hr );
} //*** CClusCfgCallback::SetHResult
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusCfgCallback -- IClusCfgInitialize interface.
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusterConfigurationInfo::Initialize
//
// Description:
//
// Arguments:
//
// Return Value:
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CClusCfgCallback::Initialize( IUnknown * punkCallbackIn, LCID lcidIn )
{
TraceFunc( "[IClusCfgInitialize]" );
Assert( m_pccc == NULL );
HRESULT hr = S_OK;
m_lcid = lcidIn;
//
// KB: 13 DEC 2000 GalenB
//
// If the passed in callback object is NULL then we had better be doing a polling
// callback!
//
if ( punkCallbackIn != NULL )
{
Assert( !m_fPollingMode );
hr = THR( punkCallbackIn->TypeSafeQI( IClusCfgCallback, &m_pccc ) );
} // if:
else
{
Assert( m_fPollingMode );
} // else:
HRETURN( hr );
} //*** CClusCfgCallback::Initialize
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusCfgCallback -- IClusCfgSetPollingCallback interface.
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusCfgCallback::SetPollingMode
//
// Description:
//
// Arguments:
//
// Return Value:
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CClusCfgCallback::SetPollingMode( BOOL fUsePollingModeIn )
{
TraceFunc( "[IClusCfgPollingCallback]" );
HRESULT hr = S_OK;
m_fPollingMode = fUsePollingModeIn;
HRETURN( hr );
} //*** CClusCfgCallback::SetPollingMode
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusCfgCallback class -- Private Methods.
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusCfgCallback::HrInit
//
// Description:
// Initialize this component.
//
// Arguments:
// None.
//
// Return Value:
//
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CClusCfgCallback::HrInit( void )
{
TraceFunc( "" );
HRESULT hr = S_OK;
DWORD sc;
//
// Create the event in a signaled state. To prevent MT polling task from grabbing
// bad/empty data.
//
m_hEvent = CreateEvent( NULL, TRUE, TRUE, NULL );
if ( m_hEvent == NULL )
{
sc = TW32( GetLastError() );
hr = HRESULT_FROM_WIN32( sc );
LogMsg( L"[SRV] Could not create event. (hr = %#08x)", hr );
goto Cleanup;
} // if:
//
// Save off the local computer name.
//
hr = THR( HrGetComputerName( ComputerNameDnsFullyQualified, &m_bstrNodeName ) );
if ( FAILED( hr ) )
goto Cleanup;
//
// Get a ClCfgSrv ILogger instance.
//
hr = CClCfgSrvLogger::S_HrGetLogger( &m_plLogger );
if ( FAILED( hr ) )
goto Cleanup;
Cleanup:
HRETURN( hr );
} //*** CClusCfgCallback::HrInit
//////////////////////////////////////////////////////////////////////////////
//++
//
// CClusterConfigurationInfo::HrQueueStatusReport
//
// Description:
//
// Arguments:
//
// Return Value:
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CClusCfgCallback::HrQueueStatusReport(
LPCWSTR pcszNodeNameIn,
CLSID clsidTaskMajorIn,
CLSID clsidTaskMinorIn,
ULONG ulMinIn,
ULONG ulMaxIn,
ULONG ulCurrentIn,
HRESULT hrStatusIn,
LPCWSTR pcszDescriptionIn,
FILETIME * pftTimeIn,
LPCWSTR pcszReferenceIn
)
{
TraceFunc( "" );
HRESULT hr = S_OK;
DWORD sc;
MSG msg;
m_pcszNodeName = pcszNodeNameIn;
m_pclsidTaskMajor = &clsidTaskMajorIn;
m_pclsidTaskMinor = &clsidTaskMinorIn;
m_pulMin = &ulMinIn;
m_pulMax = &ulMaxIn;
m_pulCurrent = &ulCurrentIn;
m_phrStatus = &hrStatusIn;
m_pcszDescription = pcszDescriptionIn;
m_pftTime = pftTimeIn,
m_pcszReference = pcszReferenceIn;
if ( !ResetEvent( m_hEvent ) )
{
sc = TW32( GetLastError() );
hr = HRESULT_FROM_WIN32( sc );
LogMsg( L"[SRV] Could not reset event. (hr = %#08x)", hr );
goto Cleanup;
} // if:
for ( sc = (DWORD) -1; sc != WAIT_OBJECT_0; )
{
while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
} // while: PeekMessage
sc = MsgWaitForMultipleObjects( 1, &m_hEvent, FALSE, INFINITE, QS_ALLEVENTS | QS_ALLINPUT | QS_ALLPOSTMESSAGE );
if ( sc == -1 )
{
sc = TW32( GetLastError() );
hr = HRESULT_FROM_WIN32( sc );
LogMsg( L"[SRV] MsgWaitForMultipleObjects failed. (hr = %#08x)", hr );
goto Cleanup;
} // if:
} // for:
hr = m_hr;
Cleanup:
HRETURN( hr );
} //*** CClusCfgCallback::HrQueueStatusReport
Reference in a new issue Copy permalink