mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1446 lines
33 KiB
1446 lines
33 KiB
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 2000-2001 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// CClusCfgPartitionInfo.cpp
|
|
//
|
|
// Description:
|
|
// This file contains the definition of the CClusCfgPartitionInfo
|
|
// class.
|
|
//
|
|
// The class CClusCfgPartitionInfo represents a disk partition.
|
|
// It implements the IClusCfgPartitionInfo interface.
|
|
//
|
|
// Documentation:
|
|
//
|
|
// Header File:
|
|
// CClusCfgPartitionInfo.h
|
|
//
|
|
// Maintained By:
|
|
// Galen Barbee (GalenB) 05-JUN-2000
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Include Files
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
#include "pch.h"
|
|
#include "CClusCfgPartitionInfo.h"
|
|
#include <StdIo.h>
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Constant Definitions
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
DEFINE_THISCLASS( "CClusCfgPartitionInfo" );
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusCfgPartitionInfo class
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::S_HrCreateInstance()
|
|
//
|
|
// Description:
|
|
// Create a CClusCfgPartitionInfo instance.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// Pointer to CClusCfgPartitionInfo instance.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CClusCfgPartitionInfo::S_HrCreateInstance( IUnknown ** ppunkOut )
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
HRESULT hr;
|
|
CClusCfgPartitionInfo * lpccs = NULL;
|
|
|
|
if ( ppunkOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
lpccs = new CClusCfgPartitionInfo();
|
|
if ( lpccs == NULL )
|
|
{
|
|
hr = THR( E_OUTOFMEMORY );
|
|
goto Cleanup;
|
|
} // if: error allocating object
|
|
|
|
hr = THR( lpccs->HrInit() );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if: HrInit() failed
|
|
|
|
hr = THR( lpccs->TypeSafeQI( IUnknown, ppunkOut ) );
|
|
|
|
Cleanup:
|
|
|
|
if ( FAILED( hr ) )
|
|
{
|
|
LogMsg( L"[SRV] CClusCfgPartitionInfo::S_HrCreateInstance() failed. (hr = %#08x)", hr );
|
|
} // if:
|
|
|
|
if ( lpccs != NULL )
|
|
{
|
|
lpccs->Release();
|
|
} // if:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::S_HrCreateInstance()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::CClusCfgPartitionInfo()
|
|
//
|
|
// Description:
|
|
// Constructor of the CClusCfgPartitionInfo 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.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
CClusCfgPartitionInfo::CClusCfgPartitionInfo( 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_pIWbemServices == NULL );
|
|
Assert( m_bstrName == NULL );
|
|
Assert( m_bstrDescription == NULL );
|
|
Assert( m_bstrUID == NULL );
|
|
Assert( m_prgLogicalDisks == NULL );
|
|
Assert( m_idxNextLogicalDisk == 0 );
|
|
Assert( m_ulPartitionSize == 0 );
|
|
Assert( m_picccCallback == NULL );
|
|
|
|
TraceFuncExit();
|
|
|
|
} //*** CClusCfgPartitionInfo::CClusCfgPartitionInfo
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::~CClusCfgPartitionInfo()
|
|
//
|
|
// Description:
|
|
// Desstructor of the CClusCfgPartitionInfo class.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
CClusCfgPartitionInfo::~CClusCfgPartitionInfo( void )
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
ULONG idx;
|
|
|
|
TraceSysFreeString( m_bstrName );
|
|
TraceSysFreeString( m_bstrDescription );
|
|
TraceSysFreeString( m_bstrUID );
|
|
|
|
for ( idx = 0; idx < m_idxNextLogicalDisk; idx++ )
|
|
{
|
|
((*m_prgLogicalDisks)[ idx ])->Release();
|
|
} // for:
|
|
|
|
TraceFree( m_prgLogicalDisks );
|
|
|
|
if ( m_pIWbemServices != NULL )
|
|
{
|
|
m_pIWbemServices->Release();
|
|
} // if:
|
|
|
|
if ( m_picccCallback != NULL )
|
|
{
|
|
m_picccCallback->Release();
|
|
} // if:
|
|
|
|
// There's going to be one less component in memory. Decrement component count.
|
|
InterlockedDecrement( &g_cObjects );
|
|
|
|
TraceFuncExit();
|
|
|
|
} //*** CClusCfgPartitionInfo::~CClusCfgPartitionInfo
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusCfgPartitionInfo -- IUknkown interface.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// STDMETHODIMP_( ULONG )
|
|
// CClusCfgPartitionInfo:: [IUNKNOWN] AddRef()
|
|
//
|
|
// Description:
|
|
// Increment the reference count of this object by one.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// The new reference count.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_( ULONG )
|
|
CClusCfgPartitionInfo::AddRef( void )
|
|
{
|
|
TraceFunc( "[IUnknown]" );
|
|
|
|
InterlockedIncrement( & m_cRef );
|
|
|
|
RETURN( m_cRef );
|
|
|
|
} //*** CClusCfgPartitionInfo::AddRef()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// STDMETHODIMP_( ULONG )
|
|
// CClusCfgPartitionInfo:: [IUNKNOWN] Release()
|
|
//
|
|
// Description:
|
|
// Decrement the reference count of this object by one.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// The new reference count.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_( ULONG )
|
|
CClusCfgPartitionInfo::Release( void )
|
|
{
|
|
TraceFunc( "[IUnknown]" );
|
|
|
|
LONG cRef;
|
|
|
|
cRef = InterlockedDecrement( &m_cRef );
|
|
if ( cRef == 0 )
|
|
{
|
|
TraceDo( delete this );
|
|
} // if: reference count equal to zero
|
|
|
|
RETURN( cRef );
|
|
|
|
} //*** CClusCfgPartitionInfo::Release()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo:: [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
|
|
CClusCfgPartitionInfo::QueryInterface( REFIID riid, void ** ppv )
|
|
{
|
|
TraceQIFunc( riid, ppv );
|
|
|
|
HRESULT hr = E_NOINTERFACE;
|
|
|
|
if ( IsEqualIID( riid, IID_IUnknown ) )
|
|
{
|
|
*ppv = static_cast< IClusCfgPartitionInfo * >( this );
|
|
hr = S_OK;
|
|
} // if: IUnknown
|
|
else if ( IsEqualIID( riid, IID_IClusCfgPartitionInfo ) )
|
|
{
|
|
*ppv = TraceInterface( __THISCLASS__, IClusCfgPartitionInfo, this, 0 );
|
|
hr = S_OK;
|
|
} // else if:
|
|
else if ( IsEqualIID( riid, IID_IClusCfgWbemServices ) )
|
|
{
|
|
*ppv = TraceInterface( __THISCLASS__, IClusCfgWbemServices, 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_IClusCfgPartitionProperties ) )
|
|
{
|
|
*ppv = TraceInterface( __THISCLASS__, IClusCfgPartitionProperties, this, 0 );
|
|
hr = S_OK;
|
|
} // else if:
|
|
else if ( IsEqualIID( riid, IID_IClusCfgSetWbemObject ) )
|
|
{
|
|
*ppv = TraceInterface( __THISCLASS__, IClusCfgSetWbemObject, this, 0 );
|
|
hr = S_OK;
|
|
} // else if:
|
|
|
|
|
|
if ( SUCCEEDED( hr ) )
|
|
{
|
|
((IUnknown *) *ppv)->AddRef( );
|
|
} // if: success
|
|
|
|
QIRETURN_IGNORESTDMARSHALLING( hr, riid );
|
|
|
|
} //*** CClusCfgPartitionInfo::QueryInterface()
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusCfgPartitionInfo -- IClusCfgWbemServices interface.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::SetWbemServices()
|
|
//
|
|
// Description:
|
|
// Set the WBEM services provider.
|
|
//
|
|
// Arguments:
|
|
// IN IWbemServices pIWbemServicesIn
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// Success
|
|
//
|
|
// E_POINTER
|
|
// The pIWbemServicesIn param is NULL.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::SetWbemServices( IWbemServices * pIWbemServicesIn )
|
|
{
|
|
TraceFunc( "[IClusCfgWbemServices]" );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( pIWbemServicesIn == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_SetWbemServices_Partition, IDS_ERROR_NULL_POINTER, hr );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
m_pIWbemServices = pIWbemServicesIn;
|
|
m_pIWbemServices->AddRef();
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::SetWbemServices()
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusCfgPartitionInfo -- IClusCfgPartitionInfo interface.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::GetUID()
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::GetUID( BSTR * pbstrUIDOut )
|
|
{
|
|
TraceFunc( "[IClusCfgPartitionInfo]" );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( pbstrUIDOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_PartitionInfo_GetUID_Pointer, IDS_ERROR_NULL_POINTER, hr );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
*pbstrUIDOut = SysAllocString( m_bstrUID );
|
|
if ( *pbstrUIDOut == NULL )
|
|
{
|
|
hr = THR( E_OUTOFMEMORY );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_PartitionInfo_GetUID_Memory, IDS_ERROR_OUTOFMEMORY, hr );
|
|
} // if:
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::GetUID()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::GetName()
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::GetName( BSTR * pbstrNameOut )
|
|
{
|
|
TraceFunc( "[IClusCfgPartitionInfo]" );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( pbstrNameOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_PartitionInfo_GetName_Pointer, IDS_ERROR_NULL_POINTER, hr );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
*pbstrNameOut = SysAllocString( m_bstrName );
|
|
if (*pbstrNameOut == NULL )
|
|
{
|
|
hr = THR( E_OUTOFMEMORY );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_GetName_Memory, IDS_ERROR_OUTOFMEMORY, hr );
|
|
} // if:
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::GetName()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::SetName()
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::SetName( LPCWSTR pcszNameIn )
|
|
{
|
|
TraceFunc1( "[IClusCfgPartitionInfo] pcszNameIn = '%ls'", pcszNameIn == NULL ? L"<null>" : pcszNameIn );
|
|
|
|
HRESULT hr = THR( E_NOTIMPL );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::SetName()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::GetDescription()
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::GetDescription( BSTR * pbstrDescriptionOut )
|
|
{
|
|
TraceFunc( "[IClusCfgPartitionInfo]" );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( pbstrDescriptionOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_PartitionInfo_GetDescription_Pointer, IDS_ERROR_NULL_POINTER, hr );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
*pbstrDescriptionOut = SysAllocString( m_bstrDescription );
|
|
if (*pbstrDescriptionOut == NULL )
|
|
{
|
|
hr = THR( E_OUTOFMEMORY );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_PartitionInfo_GetDescription_Memory, IDS_ERROR_OUTOFMEMORY, hr );
|
|
} // if:
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::GetDescription()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::SetDescription()
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::SetDescription( LPCWSTR pcszDescriptionIn )
|
|
{
|
|
TraceFunc1( "[IClusCfgPartitionInfo] pcszDescriptionIn = '%ls'", pcszDescriptionIn == NULL ? L"<null>" : pcszDescriptionIn );
|
|
|
|
HRESULT hr;
|
|
|
|
if ( pcszDescriptionIn == NULL )
|
|
{
|
|
hr = THR( E_INVALIDARG );
|
|
} // if:
|
|
else
|
|
{
|
|
hr = THR( E_NOTIMPL );
|
|
} // else:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::SetDescription()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::GetDriveLetterMappings()
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::GetDriveLetterMappings(
|
|
SDriveLetterMapping * pdlmDriveLetterMappingOut
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgPartitionInfo]" );
|
|
|
|
HRESULT hr = S_FALSE;
|
|
IWbemClassObject * pLogicalDisk = NULL;
|
|
VARIANT var;
|
|
ULONG idx;
|
|
int idxDrive;
|
|
|
|
if ( pdlmDriveLetterMappingOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_GetDriveLetterMappings_Partition, IDS_ERROR_NULL_POINTER, hr );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
VariantInit( & var );
|
|
|
|
for ( idx = 0; idx < m_idxNextLogicalDisk; idx++ )
|
|
{
|
|
hr = THR( ((*m_prgLogicalDisks)[ idx ])->TypeSafeQI( IWbemClassObject, &pLogicalDisk ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
VariantClear( &var );
|
|
|
|
hr = THR( HrGetWMIProperty( pLogicalDisk, L"Name", VT_BSTR, &var ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
CharUpper( var.bstrVal );
|
|
|
|
idxDrive = var.bstrVal[ 0 ] - 'A';
|
|
|
|
VariantClear( &var );
|
|
|
|
hr = THR( HrGetWMIProperty( pLogicalDisk, L"DriveType", VT_I4, &var ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
pdlmDriveLetterMappingOut->dluDrives[ idx ] = (EDriveLetterUsage) var.iVal;
|
|
|
|
pLogicalDisk->Release();
|
|
pLogicalDisk = NULL;
|
|
} // for:
|
|
|
|
Cleanup:
|
|
|
|
VariantClear( &var );
|
|
|
|
if ( pLogicalDisk != NULL )
|
|
{
|
|
pLogicalDisk->Release();
|
|
} // if:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::GetDriveLetterMappings()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::SetDriveLetterMappings()
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::SetDriveLetterMappings(
|
|
SDriveLetterMapping dlmDriveLetterMappingIn
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgPartitionInfo]" );
|
|
|
|
HRESULT hr = THR( E_NOTIMPL );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::SetDriveLetterMappings()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::GetSize()
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::GetSize( ULONG * pcMegaBytes )
|
|
{
|
|
TraceFunc( "[IClusCfgPartitionInfo]" );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( pcMegaBytes == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_GetSize, IDS_ERROR_NULL_POINTER, hr );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
*pcMegaBytes = m_ulPartitionSize;
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::GetSize()
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusCfgPartitionInfo class -- Private Methods.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::SetWbemObject()
|
|
//
|
|
// Description:
|
|
// Initialize this component.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
//
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CClusCfgPartitionInfo::SetWbemObject(
|
|
IWbemClassObject * pPartitionIn
|
|
, bool * pfRetainObjectOut
|
|
)
|
|
{
|
|
TraceFunc( "" );
|
|
Assert( pPartitionIn != NULL );
|
|
Assert( pfRetainObjectOut != NULL );
|
|
|
|
HRESULT hr = S_OK;
|
|
VARIANT var;
|
|
ULONGLONG ull;
|
|
|
|
VariantInit( &var );
|
|
|
|
hr = THR( HrGetWMIProperty( pPartitionIn, L"Description", VT_BSTR, &var ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
m_bstrDescription = TraceSysAllocString( var.bstrVal );
|
|
if ( m_bstrDescription == NULL )
|
|
{
|
|
goto OutOfMemory;
|
|
} // if:
|
|
|
|
VariantClear( &var );
|
|
|
|
hr = THR( HrGetWMIProperty( pPartitionIn, L"Size", VT_BSTR, &var ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
swscanf( var.bstrVal, L"%I64u", &ull );
|
|
|
|
m_ulPartitionSize = (ULONG) ( ull / ( 1024 * 1024 ) );
|
|
|
|
hr = THR( HrGetLogicalDisks( pPartitionIn ) );
|
|
|
|
*pfRetainObjectOut = true;
|
|
goto Cleanup;
|
|
|
|
OutOfMemory:
|
|
|
|
hr = THR( E_OUTOFMEMORY );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_SetWbemObject_Partition, IDS_ERROR_OUTOFMEMORY, hr );
|
|
|
|
Cleanup:
|
|
|
|
VariantClear( &var );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::SetWbemObject()
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusCfgPartitionInfo -- IClusCfgInitialize interface.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::Initialize()
|
|
//
|
|
// Description:
|
|
// Initialize this component.
|
|
//
|
|
// Arguments:
|
|
// IN IUknown * punkCallbackIn
|
|
//
|
|
// IN LCID lcidIn
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// Success
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::Initialize(
|
|
IUnknown * punkCallbackIn,
|
|
LCID lcidIn
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgInitialize]" );
|
|
Assert( m_picccCallback == NULL );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
m_lcid = lcidIn;
|
|
|
|
if ( punkCallbackIn == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
hr = THR( punkCallbackIn->TypeSafeQI( IClusCfgCallback, &m_picccCallback ) );
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::Initialize()
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusCfgPartitionInfo -- IClusCfgPartitionProperties interface.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::IsThisLogicalDisk()
|
|
//
|
|
// Description:
|
|
// Does this partition have the passed in logical disk?
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// Success, the partition has the logical disk.
|
|
//
|
|
// S_FALSE
|
|
// Success, the partition does not have the logical disk.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::IsThisLogicalDisk( WCHAR cLogicalDiskIn )
|
|
{
|
|
TraceFunc( "[IClusCfgPartitionProperties]" );
|
|
|
|
HRESULT hr = S_FALSE;
|
|
DWORD idx;
|
|
IWbemClassObject * piwco = NULL;
|
|
VARIANT var;
|
|
bool fFoundIt = false;
|
|
|
|
if ( m_idxNextLogicalDisk == 0 )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
VariantInit( &var );
|
|
|
|
for ( idx = 0; idx < m_idxNextLogicalDisk; idx++ )
|
|
{
|
|
hr = THR( ((*m_prgLogicalDisks)[ idx ])->TypeSafeQI( IWbemClassObject, &piwco ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
hr = THR( HrGetWMIProperty( piwco, L"DeviceID", VT_BSTR, &var ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
if ( cLogicalDiskIn == var.bstrVal[ 0 ] )
|
|
{
|
|
fFoundIt = true;
|
|
break;
|
|
} // if:
|
|
|
|
VariantClear( &var );
|
|
|
|
piwco->Release();
|
|
piwco = NULL;
|
|
} // for:
|
|
|
|
if ( !fFoundIt )
|
|
{
|
|
hr = S_FALSE;
|
|
} // if:
|
|
|
|
Cleanup:
|
|
|
|
VariantClear( &var );
|
|
|
|
if ( piwco != NULL )
|
|
{
|
|
piwco->Release();
|
|
} // if:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::IsThisLogicalDisk()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::IsNTFS()
|
|
//
|
|
// Description:
|
|
// Is this an NTFS partition?
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// Success, the partition is NTFS.
|
|
//
|
|
// S_FALSE
|
|
// Success, the partition is not NTFS.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::IsNTFS( void )
|
|
{
|
|
TraceFunc( "[IClusCfgPartitionProperties]" );
|
|
|
|
HRESULT hr = S_FALSE;
|
|
VARIANT var;
|
|
ULONG idx;
|
|
IWbemClassObject * piwco = NULL;
|
|
|
|
VariantInit( &var );
|
|
|
|
for ( idx = 0, hr = S_OK; idx < m_idxNextLogicalDisk; idx++ )
|
|
{
|
|
hr = THR( ((*m_prgLogicalDisks)[ idx ])->TypeSafeQI( IWbemClassObject, &piwco ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
VariantClear( &var );
|
|
|
|
hr = HrGetWMIProperty( piwco, L"FileSystem", VT_BSTR, &var );
|
|
if ( ( hr == E_PROPTYPEMISMATCH ) && ( var.vt == VT_NULL ) )
|
|
{
|
|
VariantClear( &var );
|
|
|
|
hr = S_FALSE;
|
|
THR( HrGetWMIProperty( piwco, L"DeviceID", VT_BSTR, &var ) );
|
|
STATUS_REPORT_STRING( TASKID_Major_Find_Devices, TASKID_Minor_Phys_Disk_No_File_System, IDS_ERROR_PHYSDISK_NO_FILE_SYSTEM, var.bstrVal, hr );
|
|
break;
|
|
} // if:
|
|
else if ( FAILED( hr ) )
|
|
{
|
|
THR( hr );
|
|
goto Cleanup;
|
|
} // else if:
|
|
|
|
if ( wcscmp( var.bstrVal, L"NTFS" ) != 0 )
|
|
{
|
|
VariantClear( &var );
|
|
|
|
hr = S_FALSE;
|
|
THR( HrGetWMIProperty( piwco, L"DeviceID", VT_BSTR, &var ) );
|
|
STATUS_REPORT_STRING( TASKID_Major_Find_Devices, TASKID_Minor_Phys_Disk_Not_NTFS, IDS_ERROR_PHYSDISK_NOT_NTFS, var.bstrVal, hr );
|
|
break;
|
|
} // if:
|
|
|
|
piwco->Release();
|
|
piwco = NULL;
|
|
} // for:
|
|
|
|
Cleanup:
|
|
|
|
VariantClear( &var );
|
|
|
|
if ( piwco != NULL )
|
|
{
|
|
piwco->Release();
|
|
} // if:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::IsNTFS()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::GetFriendlyName()
|
|
//
|
|
// Description:
|
|
// Get the friendly name of this partition. This name will be the
|
|
// logical disk names of all logical disks on this partition.
|
|
//
|
|
// Arguments:
|
|
// BSTR * pbstrNameOut
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// Success.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CClusCfgPartitionInfo::GetFriendlyName( BSTR * pbstrNameOut )
|
|
{
|
|
TraceFunc( "[IClusCfgPartitionProperties]" );
|
|
|
|
HRESULT hr = S_FALSE;
|
|
DWORD idx;
|
|
IWbemClassObject * piwco = NULL;
|
|
WCHAR * psz = NULL;
|
|
WCHAR * pszTmp = NULL;
|
|
DWORD cch = 0;
|
|
VARIANT var;
|
|
|
|
if ( m_idxNextLogicalDisk == 0 )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
if ( pbstrNameOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_GetFriendlyName, IDS_ERROR_NULL_POINTER, hr );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
VariantInit( &var );
|
|
|
|
for ( idx = 0; idx < m_idxNextLogicalDisk; idx++ )
|
|
{
|
|
hr = THR( ((*m_prgLogicalDisks)[ idx ])->TypeSafeQI( IWbemClassObject, &piwco ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
hr = THR( HrGetWMIProperty( piwco, L"DeviceID", VT_BSTR, &var ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
cch += ( UINT ) wcslen( var.bstrVal ) + 2; // a space and the '\0'
|
|
|
|
pszTmp = (WCHAR *) TraceReAlloc( psz, sizeof( WCHAR ) * cch, HEAP_ZERO_MEMORY );
|
|
if ( pszTmp == NULL )
|
|
{
|
|
goto OutOfMemory;
|
|
} // if:
|
|
|
|
psz = pszTmp;
|
|
pszTmp = NULL;
|
|
|
|
wcscat( psz, L" " );
|
|
wcscat( psz, var.bstrVal );
|
|
|
|
VariantClear( &var );
|
|
|
|
piwco->Release();
|
|
piwco = NULL;
|
|
} // for:
|
|
|
|
*pbstrNameOut = TraceSysAllocString( psz );
|
|
if ( *pbstrNameOut == NULL )
|
|
{
|
|
goto OutOfMemory;
|
|
} // if:
|
|
|
|
goto Cleanup;
|
|
|
|
OutOfMemory:
|
|
|
|
hr = THR( E_OUTOFMEMORY );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_GetFriendlyName, IDS_ERROR_OUTOFMEMORY, hr );
|
|
|
|
Cleanup:
|
|
|
|
VariantClear( &var );
|
|
|
|
if ( piwco != NULL )
|
|
{
|
|
piwco->Release();
|
|
} // if:
|
|
|
|
if ( psz != NULL )
|
|
{
|
|
TraceFree( psz );
|
|
} // if:
|
|
|
|
if ( pszTmp != NULL )
|
|
{
|
|
free( pszTmp );
|
|
} // if:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::GetFriendlyName()
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusCfgPartitionInfo class -- Private Methods.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo::HrInit()
|
|
//
|
|
// Description:
|
|
// Initialize this component.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
//
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CClusCfgPartitionInfo::HrInit( void )
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::HrInit()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo:HrAddLogicalDiskToArray()
|
|
//
|
|
// Description:
|
|
// Add the passed in logical disk to the array of punks that holds the
|
|
// logical disks.
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// Success
|
|
//
|
|
// E_OUTOFMEMORY
|
|
// Couldn't allocate memeory.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CClusCfgPartitionInfo::HrAddLogicalDiskToArray( IWbemClassObject * pLogicalDiskIn )
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
HRESULT hr = S_OK;
|
|
IUnknown * punk;
|
|
IUnknown * ((*prgpunks)[]) = NULL;
|
|
|
|
prgpunks = (IUnknown *((*)[])) TraceReAlloc( m_prgLogicalDisks, sizeof( IUnknown * ) * ( m_idxNextLogicalDisk + 1 ), HEAP_ZERO_MEMORY );
|
|
if ( prgpunks == NULL )
|
|
{
|
|
hr = THR( E_OUTOFMEMORY );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_HrAddLogicalDiskToArray, IDS_ERROR_OUTOFMEMORY, hr );
|
|
goto Cleanup;
|
|
} // else:
|
|
|
|
m_prgLogicalDisks = prgpunks;
|
|
|
|
hr = THR( pLogicalDiskIn->TypeSafeQI( IUnknown, &punk ) );
|
|
if ( SUCCEEDED( hr ) )
|
|
{
|
|
(*m_prgLogicalDisks)[ m_idxNextLogicalDisk++ ] = punk;
|
|
} // if:
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::HrAddLogicalDiskToArray()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusCfgPartitionInfo:HrGetLogicalDisks()
|
|
//
|
|
// Description:
|
|
// Get the logical disks for the passed in partition.
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// Success
|
|
//
|
|
// S_FALSE
|
|
// The file system was not NTFS.
|
|
//
|
|
// E_OUTOFMEMORY
|
|
// Couldn't allocate memeory.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CClusCfgPartitionInfo::HrGetLogicalDisks(
|
|
IWbemClassObject * pPartitionIn
|
|
)
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
HRESULT hr;
|
|
VARIANT var;
|
|
WCHAR szBuf[ 256 ];
|
|
IEnumWbemClassObject * pLogicalDisks = NULL;
|
|
IWbemClassObject * pLogicalDisk = NULL;
|
|
ULONG ulReturned;
|
|
BSTR bstrQuery = NULL;
|
|
BSTR bstrWQL = NULL;
|
|
|
|
bstrWQL = TraceSysAllocString( L"WQL" );
|
|
if ( bstrWQL == NULL )
|
|
{
|
|
goto OutOfMemory;
|
|
} // if:
|
|
|
|
VariantInit( &var );
|
|
|
|
//
|
|
// Need to enum the logical disk(s) of this partition to determine if it is booted
|
|
// bootable.
|
|
//
|
|
hr = THR( HrGetWMIProperty( pPartitionIn, L"DeviceID", VT_BSTR, &var ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
_snwprintf( szBuf, ARRAYSIZE( szBuf ), L"Associators of {Win32_DiskPartition.DeviceID='%s'} where AssocClass=Win32_LogicalDiskToPartition", var.bstrVal );
|
|
|
|
bstrQuery = TraceSysAllocString( szBuf );
|
|
if ( bstrQuery == NULL )
|
|
{
|
|
goto OutOfMemory;
|
|
} // if:
|
|
|
|
hr = THR( m_pIWbemServices->ExecQuery( bstrWQL, bstrQuery, WBEM_FLAG_FORWARD_ONLY, NULL, &pLogicalDisks ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_WMI_Logical_Disks_Qry_Failed, IDS_ERROR_WMI_PHYS_DISKS_QRY_FAILED, hr );
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
for ( ; ; )
|
|
{
|
|
hr = pLogicalDisks->Next( WBEM_INFINITE, 1, &pLogicalDisk, &ulReturned );
|
|
if ( ( hr == S_OK ) && ( ulReturned == 1 ) )
|
|
{
|
|
hr = THR( HrAddLogicalDiskToArray( pLogicalDisk ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if:
|
|
|
|
pLogicalDisk->Release();
|
|
pLogicalDisk = NULL;
|
|
} // if:
|
|
else if ( ( hr == S_FALSE ) && ( ulReturned == 0 ) )
|
|
{
|
|
hr = S_OK;
|
|
break;
|
|
} // else if:
|
|
else
|
|
{
|
|
STATUS_REPORT_STRING( TASKID_Major_Find_Devices, TASKID_Minor_HrGetLogicalDisks_Next, IDS_ERROR_WQL_QRY_NEXT_FAILED, bstrQuery, hr );
|
|
goto Cleanup;
|
|
} // else:
|
|
} // for:
|
|
|
|
goto Cleanup;
|
|
|
|
OutOfMemory:
|
|
|
|
hr = THR( E_OUTOFMEMORY );
|
|
STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_HrGetLogicalDisks, IDS_ERROR_OUTOFMEMORY, hr );
|
|
|
|
Cleanup:
|
|
|
|
VariantClear( &var );
|
|
|
|
TraceSysFreeString( bstrQuery );
|
|
TraceSysFreeString( bstrWQL );
|
|
|
|
if ( pLogicalDisk != NULL )
|
|
{
|
|
pLogicalDisk->Release();
|
|
} // if:
|
|
|
|
if ( pLogicalDisks != NULL )
|
|
{
|
|
pLogicalDisks->Release();
|
|
} // if:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CClusCfgPartitionInfo::HrGetLogicalDisks()
|