1738 lines
40 KiB
C++
1738 lines
40 KiB
C++
//***************************************************************************
|
|
//
|
|
// Copyright (c) 2000 Microsoft Corporation
|
|
//
|
|
// REFRESHER.CPP
|
|
//
|
|
// alanbos 20-Jan-00 Created.
|
|
//
|
|
// Defines the implementation of ISWbemRefresher and ISWbemRefreshableItem
|
|
//
|
|
//***************************************************************************
|
|
|
|
#include "precomp.h"
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CSWbemRefresher::CSWbemRefresher
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Constructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CSWbemRefreshableItem::CSWbemRefreshableItem(
|
|
ISWbemRefresher *pRefresher,
|
|
long iIndex,
|
|
IDispatch *pServices,
|
|
IWbemClassObject *pObject,
|
|
IWbemHiPerfEnum *pObjectSet
|
|
)
|
|
: m_pISWbemRefresher (pRefresher),
|
|
m_iIndex (iIndex),
|
|
m_bIsSet (VARIANT_FALSE),
|
|
m_pISWbemObjectEx (NULL),
|
|
m_pISWbemObjectSet (NULL),
|
|
m_cRef (0)
|
|
{
|
|
m_Dispatch.SetObj (this, IID_ISWbemRefreshableItem,
|
|
CLSID_SWbemRefreshableItem, L"SWbemRefreshableItem");
|
|
|
|
// Note that we do NOT AddRef m_pISWbemRefresher. To do so would create
|
|
// a circular reference between this object and the refresher, since the
|
|
// refresher's map already holds a reference to this object.
|
|
|
|
if (pServices)
|
|
{
|
|
CComQIPtr<ISWbemInternalServices> pISWbemInternalServices (pServices);
|
|
|
|
if (pISWbemInternalServices)
|
|
{
|
|
CSWbemServices *pCSWbemServices = new CSWbemServices (pISWbemInternalServices);
|
|
|
|
if (pCSWbemServices)
|
|
pCSWbemServices->AddRef ();
|
|
|
|
if (pObject)
|
|
{
|
|
// Create a new CSWbemObject for ourselves
|
|
CSWbemObject *pCSWbemObject = new CSWbemObject (pCSWbemServices, pObject);
|
|
|
|
if (pCSWbemObject)
|
|
pCSWbemObject->QueryInterface (IID_ISWbemObjectEx, (void**) &m_pISWbemObjectEx);
|
|
}
|
|
|
|
if (pObjectSet)
|
|
{
|
|
// Create a new CSWbemHiPerfObjectSet for ourselves
|
|
CSWbemHiPerfObjectSet *pCSWbemHiPerfObjectSet =
|
|
new CSWbemHiPerfObjectSet (pCSWbemServices, pObjectSet);
|
|
|
|
if (pCSWbemHiPerfObjectSet)
|
|
{
|
|
pCSWbemHiPerfObjectSet->QueryInterface (IID_ISWbemObjectSet, (void**) &m_pISWbemObjectSet);
|
|
m_bIsSet = VARIANT_TRUE;
|
|
}
|
|
}
|
|
|
|
if (pCSWbemServices)
|
|
pCSWbemServices->Release ();
|
|
}
|
|
}
|
|
|
|
InterlockedIncrement(&g_cObj);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CSWbemRefreshableItem::~CSWbemRefreshableItem
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Destructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CSWbemRefreshableItem::~CSWbemRefreshableItem(void)
|
|
{
|
|
InterlockedDecrement(&g_cObj);
|
|
|
|
if (m_pISWbemObjectEx)
|
|
{
|
|
m_pISWbemObjectEx->Release ();
|
|
m_pISWbemObjectEx = NULL;
|
|
}
|
|
|
|
if (m_pISWbemObjectSet)
|
|
{
|
|
m_pISWbemObjectSet->Release ();
|
|
m_pISWbemObjectSet = NULL;
|
|
}
|
|
}
|
|
|
|
//***************************************************************************
|
|
// HRESULT CSWbemRefreshableItem::QueryInterface
|
|
// long CSWbemRefreshableItem::AddRef
|
|
// long CSWbemRefreshableItem::Release
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Standard Com IUNKNOWN functions.
|
|
//
|
|
//***************************************************************************
|
|
|
|
STDMETHODIMP CSWbemRefreshableItem::QueryInterface (
|
|
|
|
IN REFIID riid,
|
|
OUT LPVOID *ppv
|
|
)
|
|
{
|
|
*ppv=NULL;
|
|
|
|
if (IID_IUnknown==riid)
|
|
*ppv = reinterpret_cast<IUnknown*>(this);
|
|
else if (IID_ISWbemRefreshableItem==riid)
|
|
*ppv = (ISWbemRefresher *)this;
|
|
else if (IID_IDispatch==riid)
|
|
*ppv = (IDispatch *)this;
|
|
else if (IID_ISupportErrorInfo==riid)
|
|
*ppv = (ISupportErrorInfo *)this;
|
|
else if (IID_IProvideClassInfo==riid)
|
|
*ppv = (IProvideClassInfo *)this;
|
|
|
|
if (NULL!=*ppv)
|
|
{
|
|
((LPUNKNOWN)*ppv)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CSWbemRefreshableItem::AddRef(void)
|
|
{
|
|
InterlockedIncrement(&m_cRef);
|
|
return m_cRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CSWbemRefreshableItem::Release(void)
|
|
{
|
|
InterlockedDecrement(&m_cRef);
|
|
if (0L!=m_cRef)
|
|
return m_cRef;
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CSWbemRefresher::CSWbemRefresher
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Constructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CSWbemRefresher::CSWbemRefresher()
|
|
: m_iCount (0),
|
|
m_bAutoReconnect (VARIANT_TRUE),
|
|
m_pIWbemConfigureRefresher (NULL),
|
|
m_pIWbemRefresher (NULL),
|
|
m_cRef (0)
|
|
{
|
|
m_Dispatch.SetObj (this, IID_ISWbemRefresher,
|
|
CLSID_SWbemRefresher, L"SWbemRefresher");
|
|
InterlockedIncrement(&g_cObj);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CSWbemRefresher::~CSWbemRefresher
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Destructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CSWbemRefresher::~CSWbemRefresher(void)
|
|
{
|
|
InterlockedDecrement(&g_cObj);
|
|
|
|
// Remove all items from the refresher
|
|
DeleteAll ();
|
|
|
|
if (m_pIWbemConfigureRefresher)
|
|
m_pIWbemConfigureRefresher->Release ();
|
|
|
|
if (m_pIWbemRefresher)
|
|
m_pIWbemRefresher->Release ();
|
|
}
|
|
|
|
//***************************************************************************
|
|
// HRESULT CSWbemRefresher::QueryInterface
|
|
// long CSWbemRefresher::AddRef
|
|
// long CSWbemRefresher::Release
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Standard Com IUNKNOWN functions.
|
|
//
|
|
//***************************************************************************
|
|
|
|
STDMETHODIMP CSWbemRefresher::QueryInterface (
|
|
|
|
IN REFIID riid,
|
|
OUT LPVOID *ppv
|
|
)
|
|
{
|
|
*ppv=NULL;
|
|
|
|
if (IID_IUnknown==riid)
|
|
*ppv = reinterpret_cast<IUnknown*>(this);
|
|
else if (IID_ISWbemRefresher==riid)
|
|
*ppv = (ISWbemRefresher *)this;
|
|
else if (IID_IDispatch==riid)
|
|
*ppv = (IDispatch *)this;
|
|
else if (IID_IObjectSafety==riid)
|
|
*ppv = (IObjectSafety *)this;
|
|
else if (IID_ISupportErrorInfo==riid)
|
|
*ppv = (ISupportErrorInfo *)this;
|
|
else if (IID_IProvideClassInfo==riid)
|
|
*ppv = (IProvideClassInfo *)this;
|
|
|
|
if (NULL!=*ppv)
|
|
{
|
|
((LPUNKNOWN)*ppv)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CSWbemRefresher::AddRef(void)
|
|
{
|
|
InterlockedIncrement(&m_cRef);
|
|
return m_cRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CSWbemRefresher::Release(void)
|
|
{
|
|
InterlockedDecrement(&m_cRef);
|
|
if (0L!=m_cRef)
|
|
return m_cRef;
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemRefresher::get__NewEnum
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Return an IEnumVARIANT-supporting interface for collections
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// ppUnk on successful return addresses the IUnknown interface
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// S_OK success
|
|
// E_FAIL otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemRefresher::get__NewEnum (
|
|
IUnknown **ppUnk
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if (NULL != ppUnk)
|
|
{
|
|
*ppUnk = NULL;
|
|
CEnumRefresher *pEnumRefresher = new CEnumRefresher (this);
|
|
|
|
if (!pEnumRefresher)
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
else if (FAILED(hr = pEnumRefresher->QueryInterface (IID_IUnknown, (PPVOID) ppUnk)))
|
|
delete pEnumRefresher;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemRefresher::get_Count
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Return the number of items in the collection
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// plCount on successful return addresses the count
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// S_OK success
|
|
// E_FAIL otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemRefresher::get_Count (
|
|
long *plCount
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if (NULL != plCount)
|
|
{
|
|
*plCount = m_ObjectMap.size ();
|
|
hr = S_OK;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemRefresher::Add
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Add a single instance to the refresher
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pISWbemServicesEx the SWbemServicesEx to use
|
|
// bsInstancePath the relative path of the instance
|
|
// iFlags flags
|
|
// pSWbemContext context
|
|
// ppSWbemRefreshableItem addresses the SWbemRefreshableItem on successful return
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_INVALID_PARAMETER bad input parameters
|
|
// WBEM_E_NOT_FOUND index out of range
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemRefresher::Add (
|
|
ISWbemServicesEx *pISWbemServicesEx,
|
|
BSTR bsInstancePath,
|
|
long iFlags,
|
|
IDispatch *pSWbemContext,
|
|
ISWbemRefreshableItem **ppSWbemRefreshableItem
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if ((NULL == ppSWbemRefreshableItem) || (NULL == pISWbemServicesEx) || (NULL == bsInstancePath))
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
else
|
|
{
|
|
// Extract the context
|
|
CComPtr<IWbemContext> pIWbemContext;
|
|
|
|
//Can't assign directly because the raw pointer gets AddRef'd twice and we leak,
|
|
//So we use Attach() instead to prevent the smart pointer from AddRef'ing.
|
|
pIWbemContext.Attach(CSWbemNamedValueSet::GetIWbemContext (pSWbemContext));
|
|
|
|
// Extract the IWbemServices
|
|
CComPtr<IWbemServices> pIWbemServices = CSWbemServices::GetIWbemServices (pISWbemServicesEx);
|
|
|
|
if (pIWbemServices)
|
|
{
|
|
// Get our refresher - may need to create on demand
|
|
if (NULL == m_pIWbemConfigureRefresher)
|
|
CreateRefresher ();
|
|
|
|
if (m_pIWbemConfigureRefresher)
|
|
{
|
|
IWbemClassObject *pObject = NULL;
|
|
long iIndex = 0;
|
|
|
|
if (SUCCEEDED(hr = m_pIWbemConfigureRefresher->AddObjectByPath (pIWbemServices,
|
|
bsInstancePath, iFlags, pIWbemContext, &pObject, &iIndex)))
|
|
{
|
|
CSWbemRefreshableItem *pRefreshableItem = new
|
|
CSWbemRefreshableItem (this, iIndex,
|
|
pISWbemServicesEx, pObject, NULL);
|
|
|
|
if (!pRefreshableItem)
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
else if (SUCCEEDED(hr =pRefreshableItem->QueryInterface (IID_ISWbemRefreshableItem,
|
|
(void**) ppSWbemRefreshableItem)))
|
|
{
|
|
m_ObjectMap [iIndex] = pRefreshableItem;
|
|
pRefreshableItem->AddRef ();
|
|
}
|
|
else
|
|
delete pRefreshableItem;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemRefresher::AddEnum
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Add a single enum (shallow instance) to the refresher
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pISWbemServicesEx the SWbemServicesEx to use
|
|
// bsClassName the name of the class
|
|
// iFlags flags
|
|
// pSWbemContext context
|
|
// ppSWbemRefreshableItem addresses the SWbemRefreshableItem on successful return
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_INVALID_PARAMETER bad input parameters
|
|
// WBEM_E_NOT_FOUND index out of range
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemRefresher::AddEnum (
|
|
ISWbemServicesEx *pISWbemServicesEx,
|
|
BSTR bsClassName,
|
|
long iFlags,
|
|
IDispatch *pSWbemContext,
|
|
ISWbemRefreshableItem **ppSWbemRefreshableItem
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if ((NULL == ppSWbemRefreshableItem) || (NULL == pISWbemServicesEx)
|
|
|| (NULL == bsClassName))
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
else
|
|
{
|
|
// Extract the context
|
|
CComPtr<IWbemContext> pIWbemContext;
|
|
|
|
//Can't assign directly because the raw pointer gets AddRef'd twice and we leak,
|
|
//So we use Attach() instead to prevent the smart pointer from AddRef'ing.
|
|
pIWbemContext.Attach(CSWbemNamedValueSet::GetIWbemContext (pSWbemContext));
|
|
|
|
// Extract the IWbemServices
|
|
CComPtr<IWbemServices> pIWbemServices = CSWbemServices::GetIWbemServices (pISWbemServicesEx);
|
|
|
|
if (pIWbemServices)
|
|
{
|
|
// Get our refresher - may need to create on demand
|
|
if (NULL == m_pIWbemConfigureRefresher)
|
|
CreateRefresher ();
|
|
|
|
if (m_pIWbemConfigureRefresher)
|
|
{
|
|
IWbemHiPerfEnum *pIWbemHiPerfEnum = NULL;
|
|
long iIndex = 0;
|
|
|
|
if (SUCCEEDED(hr = m_pIWbemConfigureRefresher->AddEnum (pIWbemServices,
|
|
bsClassName, iFlags, pIWbemContext, &pIWbemHiPerfEnum, &iIndex)))
|
|
{
|
|
CSWbemRefreshableItem *pRefreshableItem = new
|
|
CSWbemRefreshableItem (this, iIndex,
|
|
pISWbemServicesEx, NULL, pIWbemHiPerfEnum);
|
|
|
|
if (!pRefreshableItem)
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
else if (SUCCEEDED(hr =pRefreshableItem->QueryInterface (IID_ISWbemRefreshableItem,
|
|
(void**) ppSWbemRefreshableItem)))
|
|
{
|
|
m_ObjectMap [iIndex] = pRefreshableItem;
|
|
pRefreshableItem->AddRef ();
|
|
}
|
|
else
|
|
delete pRefreshableItem;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemRefresher::Remove
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Remove object from refresher
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// iIndex Index of object to retrieve
|
|
// iFlags Flags
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_INVALID_PARAMETER bad input parameters
|
|
// WBEM_E_NOT_FOUND index out of range
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemRefresher::Remove (
|
|
long iIndex,
|
|
long iFlags
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
ResetLastErrors ();
|
|
|
|
if (m_pIWbemConfigureRefresher)
|
|
{
|
|
if (0 != iFlags)
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
else
|
|
{
|
|
hr = m_pIWbemConfigureRefresher->Remove (iIndex,
|
|
(VARIANT_TRUE == m_bAutoReconnect) ?
|
|
WBEM_FLAG_REFRESH_AUTO_RECONNECT :
|
|
WBEM_FLAG_REFRESH_NO_AUTO_RECONNECT);
|
|
|
|
if (WBEM_S_FALSE == hr)
|
|
hr = WBEM_E_NOT_FOUND;
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Now remove from our collection
|
|
RefreshableItemMap::iterator theIterator = m_ObjectMap.find (iIndex);
|
|
|
|
if (theIterator != m_ObjectMap.end ())
|
|
EraseItem (theIterator);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemRefresher::DeleteAll
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Remove all items from refresher
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// none
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_INVALID_PARAMETER bad input parameters
|
|
// WBEM_E_NOT_FOUND index out of range
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemRefresher::DeleteAll (
|
|
)
|
|
{
|
|
ResetLastErrors ();
|
|
RefreshableItemMap::iterator next;
|
|
|
|
while ((next = m_ObjectMap.begin ()) != m_ObjectMap.end ())
|
|
{
|
|
CSWbemRefreshableItem *pRefreshableItem = (*next).second;
|
|
long iIndex = 0;
|
|
|
|
if (m_pIWbemConfigureRefresher && pRefreshableItem &&
|
|
SUCCEEDED(pRefreshableItem->get_Index (&iIndex)))
|
|
{
|
|
HRESULT hr = m_pIWbemConfigureRefresher->Remove (iIndex,
|
|
(VARIANT_TRUE == m_bAutoReconnect) ?
|
|
WBEM_FLAG_REFRESH_AUTO_RECONNECT :
|
|
WBEM_FLAG_REFRESH_NO_AUTO_RECONNECT);
|
|
}
|
|
|
|
EraseItem (next);
|
|
}
|
|
|
|
return WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemRefresher::Refresh
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Refresh all objects in this refresher.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// lFlags Flags
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_INVALID_PARAMETER bad input parameters
|
|
// WBEM_E_NOT_FOUND index out of range
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemRefresher::Refresh (
|
|
long iFlags
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if (0 != iFlags)
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
else if (m_pIWbemRefresher)
|
|
{
|
|
hr = m_pIWbemRefresher->Refresh ((VARIANT_TRUE == m_bAutoReconnect) ?
|
|
WBEM_FLAG_REFRESH_AUTO_RECONNECT :
|
|
WBEM_FLAG_REFRESH_NO_AUTO_RECONNECT);
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemRefresher::Item
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Get object from the enumeration by index.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// iIndex Index of object to retrieve
|
|
// lFlags Flags
|
|
// ppSWbemRefreshableItem On successful return addresses the object
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_INVALID_PARAMETER bad input parameters
|
|
// WBEM_E_NOT_FOUND index out of range
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemRefresher::Item (
|
|
long iIndex,
|
|
ISWbemRefreshableItem **ppSWbemRefreshableItem
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_E_NOT_FOUND;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if (NULL == ppSWbemRefreshableItem)
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
else
|
|
{
|
|
*ppSWbemRefreshableItem = NULL;
|
|
RefreshableItemMap::iterator theIterator;
|
|
theIterator = m_ObjectMap.find (iIndex);
|
|
|
|
if (theIterator != m_ObjectMap.end ())
|
|
{
|
|
CSWbemRefreshableItem *pRefreshableItem = (*theIterator).second;
|
|
|
|
if (SUCCEEDED(pRefreshableItem->QueryInterface
|
|
(IID_ISWbemRefreshableItem, (PPVOID) ppSWbemRefreshableItem)))
|
|
{
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// void CSWbemRefresher::CreateRefresher
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Create the underlying WMI refresher objects.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// none
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// none
|
|
//***************************************************************************
|
|
|
|
void CSWbemRefresher::CreateRefresher ()
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (NULL == m_pIWbemRefresher)
|
|
{
|
|
if (SUCCEEDED(hr = CoCreateInstance( CLSID_WbemRefresher, NULL, CLSCTX_INPROC_SERVER,
|
|
IID_IWbemRefresher, (void**) &m_pIWbemRefresher )))
|
|
{
|
|
IWbemConfigureRefresher *pConfigureRefresher = NULL;
|
|
|
|
// Get ourselves a refresher configurator
|
|
hr = m_pIWbemRefresher->QueryInterface (IID_IWbemConfigureRefresher,
|
|
(void**) &m_pIWbemConfigureRefresher);
|
|
}
|
|
}
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// void CSWbemRefresher::EraseItem
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Scrub out an item.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// none
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// none
|
|
//***************************************************************************
|
|
|
|
void CSWbemRefresher::EraseItem (RefreshableItemMap::iterator iterator)
|
|
{
|
|
CSWbemRefreshableItem *pRefresherObject = (*iterator).second;
|
|
|
|
// Remove from the map
|
|
m_ObjectMap.erase (iterator);
|
|
|
|
// Ensure the item is unhooked from the parent.
|
|
pRefresherObject->UnhookRefresher ();
|
|
|
|
// Release the item as it is no longer in the map
|
|
pRefresherObject->Release ();
|
|
}
|
|
|
|
// CEnumRefresher Methods
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CEnumRefresher::CEnumRefresher
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Constructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CEnumRefresher::CEnumRefresher(CSWbemRefresher *pRefresher)
|
|
{
|
|
m_cRef=0;
|
|
m_pCSWbemRefresher = pRefresher;
|
|
m_pCSWbemRefresher->AddRef ();
|
|
|
|
m_Iterator = m_pCSWbemRefresher->m_ObjectMap.begin ();
|
|
InterlockedIncrement(&g_cObj);
|
|
}
|
|
|
|
CEnumRefresher::CEnumRefresher(CSWbemRefresher *pRefresher,
|
|
RefreshableItemMap::iterator iterator) :
|
|
m_Iterator (iterator)
|
|
{
|
|
m_cRef=0;
|
|
m_pCSWbemRefresher = pRefresher;
|
|
m_pCSWbemRefresher->AddRef ();
|
|
InterlockedIncrement(&g_cObj);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CEnumRefresher::~CEnumRefresher
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Destructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CEnumRefresher::~CEnumRefresher(void)
|
|
{
|
|
InterlockedDecrement(&g_cObj);
|
|
|
|
if (m_pCSWbemRefresher)
|
|
m_pCSWbemRefresher->Release ();
|
|
}
|
|
|
|
//***************************************************************************
|
|
// HRESULT CEnumRefresher::QueryInterface
|
|
// long CEnumRefresher::AddRef
|
|
// long CEnumRefresher::Release
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Standard Com IUNKNOWN functions.
|
|
//
|
|
//***************************************************************************
|
|
|
|
STDMETHODIMP CEnumRefresher::QueryInterface (
|
|
|
|
IN REFIID riid,
|
|
OUT LPVOID *ppv
|
|
)
|
|
{
|
|
*ppv=NULL;
|
|
|
|
if (IID_IUnknown==riid || IID_IEnumVARIANT==riid)
|
|
*ppv=this;
|
|
|
|
if (NULL!=*ppv)
|
|
{
|
|
((LPUNKNOWN)*ppv)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CEnumRefresher::AddRef(void)
|
|
{
|
|
long l = InterlockedIncrement(&m_cRef);
|
|
return l;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CEnumRefresher::Release(void)
|
|
{
|
|
long l = InterlockedDecrement(&m_cRef);
|
|
if (0L!=l)
|
|
return l;
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CEnumRefresher::Reset
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Reset the enumeration
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// S_OK success
|
|
// S_FALSE otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CEnumRefresher::Reset ()
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
m_Iterator = m_pCSWbemRefresher->m_ObjectMap.begin ();
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CEnumRefresher::Next
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Get the next object in the enumeration
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// lTimeout Number of ms to wait for object (or WBEM_INFINITE for
|
|
// indefinite)
|
|
// ppObject On return may contain the next element (if any)
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// S_OK success
|
|
// S_FALSE not all elements could be returned
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CEnumRefresher::Next (
|
|
ULONG cElements,
|
|
VARIANT FAR* pVar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG l2 = 0;
|
|
|
|
if (NULL != pcElementFetched)
|
|
*pcElementFetched = 0;
|
|
|
|
if ((NULL != pVar) && (m_pCSWbemRefresher))
|
|
{
|
|
for (ULONG l = 0; l < cElements; l++)
|
|
VariantInit (&pVar [l]);
|
|
|
|
// Retrieve the next cElements elements.
|
|
for (l2 = 0; l2 < cElements; l2++)
|
|
{
|
|
if (m_Iterator != m_pCSWbemRefresher->m_ObjectMap.end ())
|
|
{
|
|
CSWbemRefreshableItem *pCSWbemRefreshableItem = (*m_Iterator).second;
|
|
m_Iterator++;
|
|
|
|
ISWbemRefreshableItem *pISWbemRefreshableItem = NULL;
|
|
|
|
if (SUCCEEDED(pCSWbemRefreshableItem->QueryInterface
|
|
(IID_ISWbemRefreshableItem, (PPVOID) &pISWbemRefreshableItem)))
|
|
{
|
|
// Set the object into the variant array; note that pObject
|
|
// has been addref'd as a result of the QI() call above
|
|
pVar[l2].vt = VT_DISPATCH;
|
|
pVar[l2].pdispVal = pISWbemRefreshableItem;
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
if (NULL != pcElementFetched)
|
|
*pcElementFetched = l2;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
return (l2 < cElements) ? S_FALSE : S_OK;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CEnumRefresher::Clone
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Create a copy of this enumeration
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// ppEnum on successful return addresses the clone
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CEnumRefresher::Clone (
|
|
IEnumVARIANT **ppEnum
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (NULL != ppEnum)
|
|
{
|
|
*ppEnum = NULL;
|
|
|
|
if (m_pCSWbemRefresher)
|
|
{
|
|
CEnumRefresher *pEnum = new CEnumRefresher (m_pCSWbemRefresher, m_Iterator);
|
|
|
|
if (!pEnum)
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
else if (FAILED(hr = pEnum->QueryInterface (IID_IEnumVARIANT, (PPVOID) ppEnum)))
|
|
delete pEnum;;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CEnumRefresher::Skip
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Skip specified number of elements
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// ppEnum on successful return addresses the clone
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// S_OK success
|
|
// S_FALSE end of sequence reached prematurely
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CEnumRefresher::Skip(
|
|
ULONG cElements
|
|
)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
if (m_pCSWbemRefresher)
|
|
{
|
|
ULONG l2;
|
|
|
|
// Retrieve the next cElements elements.
|
|
for (l2 = 0; l2 < cElements; l2++)
|
|
{
|
|
if (m_Iterator != m_pCSWbemRefresher->m_ObjectMap.end ())
|
|
m_Iterator++;
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (l2 == cElements)
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// CSWbemHiPerfObjectSet methods
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CSWbemHiPerfObjectSet::CSWbemHiPerfObjectSet
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Constructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CSWbemHiPerfObjectSet::CSWbemHiPerfObjectSet(CSWbemServices *pService,
|
|
IWbemHiPerfEnum *pIWbemHiPerfEnum)
|
|
: m_SecurityInfo (NULL),
|
|
m_pSWbemServices (pService),
|
|
m_pIWbemHiPerfEnum (pIWbemHiPerfEnum),
|
|
m_cRef (0)
|
|
{
|
|
m_Dispatch.SetObj (this, IID_ISWbemObjectSet,
|
|
CLSID_SWbemObjectSet, L"SWbemObjectSet");
|
|
|
|
if (m_pIWbemHiPerfEnum)
|
|
m_pIWbemHiPerfEnum->AddRef ();
|
|
|
|
if (m_pSWbemServices)
|
|
{
|
|
m_pSWbemServices->AddRef ();
|
|
|
|
// Use the SWbemServices security object here since
|
|
// IWbemHiPerfEnum is not a remote interface
|
|
CSWbemSecurity *pSecurity = m_pSWbemServices->GetSecurityInfo ();
|
|
m_SecurityInfo = new CSWbemSecurity (pSecurity);
|
|
|
|
if (pSecurity)
|
|
pSecurity->Release ();
|
|
}
|
|
|
|
InterlockedIncrement(&g_cObj);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CSWbemHiPerfObjectSet::~CSWbemHiPerfObjectSet
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Destructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CSWbemHiPerfObjectSet::~CSWbemHiPerfObjectSet(void)
|
|
{
|
|
InterlockedDecrement(&g_cObj);
|
|
|
|
if (m_pSWbemServices)
|
|
m_pSWbemServices->Release ();
|
|
|
|
if (m_SecurityInfo)
|
|
m_SecurityInfo->Release ();
|
|
|
|
if (m_pIWbemHiPerfEnum)
|
|
m_pIWbemHiPerfEnum->Release ();
|
|
}
|
|
|
|
//***************************************************************************
|
|
// HRESULT CSWbemHiPerfObjectSet::QueryInterface
|
|
// long CSWbemHiPerfObjectSet::AddRef
|
|
// long CSWbemHiPerfObjectSet::Release
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Standard Com IUNKNOWN functions.
|
|
//
|
|
//***************************************************************************
|
|
|
|
STDMETHODIMP CSWbemHiPerfObjectSet::QueryInterface (
|
|
|
|
IN REFIID riid,
|
|
OUT LPVOID *ppv
|
|
)
|
|
{
|
|
*ppv=NULL;
|
|
|
|
if (IID_IUnknown==riid)
|
|
*ppv = reinterpret_cast<IUnknown*>(this);
|
|
else if (IID_ISWbemObjectSet==riid)
|
|
*ppv = (ISWbemObjectSet *)this;
|
|
else if (IID_IDispatch==riid)
|
|
*ppv = (IDispatch *)this;
|
|
else if (IID_ISupportErrorInfo==riid)
|
|
*ppv = (ISupportErrorInfo *)this;
|
|
else if (IID_IProvideClassInfo==riid)
|
|
*ppv = (IProvideClassInfo *)this;
|
|
|
|
if (NULL!=*ppv)
|
|
{
|
|
((LPUNKNOWN)*ppv)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CSWbemHiPerfObjectSet::AddRef(void)
|
|
{
|
|
InterlockedIncrement(&m_cRef);
|
|
return m_cRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CSWbemHiPerfObjectSet::Release(void)
|
|
{
|
|
InterlockedDecrement(&m_cRef);
|
|
if (0L!=m_cRef)
|
|
return m_cRef;
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemHiPerfObjectSet::ReadObjects
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Gets the objects out of the enumerator
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
IWbemObjectAccess **CSWbemHiPerfObjectSet::ReadObjects (
|
|
unsigned long & iCount
|
|
)
|
|
{
|
|
IWbemObjectAccess **ppIWbemObjectAccess = NULL;
|
|
iCount = 0;
|
|
|
|
if (m_pIWbemHiPerfEnum)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// Start by getting the object count
|
|
if (WBEM_E_BUFFER_TOO_SMALL == (hr = m_pIWbemHiPerfEnum->GetObjects (0L, 0L,
|
|
NULL, &iCount)))
|
|
{
|
|
ppIWbemObjectAccess = new IWbemObjectAccess*[iCount];
|
|
|
|
if (ppIWbemObjectAccess)
|
|
{
|
|
ZeroMemory( ppIWbemObjectAccess, iCount * sizeof(IWbemObjectAccess*) );
|
|
unsigned long dummy = 0;
|
|
hr = m_pIWbemHiPerfEnum->GetObjects ( 0L, iCount, ppIWbemObjectAccess, &dummy );
|
|
}
|
|
}
|
|
}
|
|
|
|
return ppIWbemObjectAccess;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemHiPerfObjectSet::get__NewEnum
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Return an IEnumVARIANT-supporting interface for collections
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// ppUnk on successful return addresses the IUnknown interface
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// S_OK success
|
|
// E_FAIL otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemHiPerfObjectSet::get__NewEnum (
|
|
IUnknown **ppUnk
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if (NULL != ppUnk)
|
|
{
|
|
*ppUnk = NULL;
|
|
CEnumVarHiPerf *pEnumVar = new CEnumVarHiPerf (this);
|
|
|
|
if (!pEnumVar)
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
else if (FAILED(hr = pEnumVar->QueryInterface (IID_IUnknown, (PPVOID) ppUnk)))
|
|
delete pEnumVar;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemHiPerfObjectSet::get_Count
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Return the number of items in the collection
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// plCount on successful return addresses the count
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// S_OK success
|
|
// E_FAIL otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemHiPerfObjectSet::get_Count (
|
|
long *plCount
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if (NULL == plCount)
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
else
|
|
{
|
|
unsigned long iCount = 0;
|
|
IWbemObjectAccess **ppIWbemObjectAccess = ReadObjects (iCount);
|
|
*plCount = iCount;
|
|
hr = WBEM_S_NO_ERROR;
|
|
|
|
if (ppIWbemObjectAccess)
|
|
delete [] ppIWbemObjectAccess;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemHiPerfObjectSet::Item
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Get object from the enumeration by path.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// bsObjectPath The path of the object to retrieve
|
|
// lFlags Flags
|
|
// ppNamedObject On successful return addresses the object
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_INVALID_PARAMETER bad input parameters
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemHiPerfObjectSet::Item (
|
|
BSTR bsObjectPath,
|
|
long lFlags,
|
|
ISWbemObject **ppObject
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if ((NULL == ppObject) || (NULL == bsObjectPath))
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
else
|
|
{
|
|
CWbemPathCracker objectPath;
|
|
|
|
if (objectPath = bsObjectPath)
|
|
{
|
|
unsigned long iCount = 0;
|
|
IWbemObjectAccess **ppIWbemObjectAccess = ReadObjects (iCount);
|
|
bool found = false;
|
|
|
|
for (unsigned long i = 0; !found && (i < iCount); i++)
|
|
{
|
|
CComPtr<IWbemClassObject> pIWbemClassObject;
|
|
hr = WBEM_E_NOT_FOUND;
|
|
|
|
// Iterate through the enumerator to try to find the element with the
|
|
// specified path.
|
|
if (SUCCEEDED(ppIWbemObjectAccess [i]->QueryInterface (IID_IWbemClassObject,
|
|
(void**) &pIWbemClassObject)))
|
|
{
|
|
if (CSWbemObjectPath::CompareObjectPaths (pIWbemClassObject, objectPath))
|
|
{
|
|
// Found it - assign to passed interface and break out
|
|
found = true;
|
|
CSWbemObject *pObject = new CSWbemObject (m_pSWbemServices,
|
|
pIWbemClassObject, m_SecurityInfo);
|
|
|
|
if (!pObject)
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
else if (FAILED(pObject->QueryInterface (IID_ISWbemObject,
|
|
(PPVOID) ppObject)))
|
|
{
|
|
hr = WBEM_E_FAILED;
|
|
delete pObject;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (found)
|
|
hr = S_OK;
|
|
|
|
if (ppIWbemObjectAccess)
|
|
delete [] ppIWbemObjectAccess;
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CSWbemHiPerfObjectSet::get_Security_
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Return the security configurator
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_INVALID_PARAMETER bad input parameters
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CSWbemHiPerfObjectSet::get_Security_ (
|
|
ISWbemSecurity **ppSecurity
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
ResetLastErrors ();
|
|
|
|
if (NULL == ppSecurity)
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
{
|
|
*ppSecurity = NULL;
|
|
|
|
if (m_SecurityInfo)
|
|
{
|
|
*ppSecurity = m_SecurityInfo;
|
|
(*ppSecurity)->AddRef ();
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
m_Dispatch.RaiseException (hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// CEnumVarHiPerfHiPerf methods
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CEnumVarHiPerf::CEnumVarHiPerf
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Constructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CEnumVarHiPerf::CEnumVarHiPerf(CSWbemHiPerfObjectSet *pCSWbemHiPerfObjectSet) :
|
|
m_cRef (0),
|
|
m_iCount (0),
|
|
m_iPos (0),
|
|
m_ppIWbemObjectAccess (NULL),
|
|
m_pCSWbemHiPerfObjectSet (NULL)
|
|
{
|
|
if (pCSWbemHiPerfObjectSet)
|
|
{
|
|
m_pCSWbemHiPerfObjectSet = pCSWbemHiPerfObjectSet;
|
|
m_pCSWbemHiPerfObjectSet->AddRef ();
|
|
m_ppIWbemObjectAccess = pCSWbemHiPerfObjectSet->ReadObjects (m_iCount);
|
|
}
|
|
|
|
InterlockedIncrement(&g_cObj);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// CEnumVarHiPerf::~CEnumVarHiPerf
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Destructor.
|
|
//
|
|
//***************************************************************************
|
|
|
|
CEnumVarHiPerf::~CEnumVarHiPerf(void)
|
|
{
|
|
InterlockedDecrement(&g_cObj);
|
|
|
|
if (m_pCSWbemHiPerfObjectSet)
|
|
m_pCSWbemHiPerfObjectSet->Release ();
|
|
|
|
if (m_ppIWbemObjectAccess)
|
|
delete [] m_ppIWbemObjectAccess;
|
|
}
|
|
|
|
//***************************************************************************
|
|
// HRESULT CEnumVarHiPerf::QueryInterface
|
|
// long CEnumVarHiPerf::AddRef
|
|
// long CEnumVarHiPerf::Release
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Standard Com IUNKNOWN functions.
|
|
//
|
|
//***************************************************************************
|
|
|
|
STDMETHODIMP CEnumVarHiPerf::QueryInterface (
|
|
|
|
IN REFIID riid,
|
|
OUT LPVOID *ppv
|
|
)
|
|
{
|
|
*ppv=NULL;
|
|
|
|
if (IID_IUnknown==riid || IID_IEnumVARIANT==riid)
|
|
*ppv=this;
|
|
|
|
if (NULL!=*ppv)
|
|
{
|
|
((LPUNKNOWN)*ppv)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CEnumVarHiPerf::AddRef(void)
|
|
{
|
|
InterlockedIncrement(&m_cRef);
|
|
return m_cRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CEnumVarHiPerf::Release(void)
|
|
{
|
|
InterlockedDecrement(&m_cRef);
|
|
if (0L!=m_cRef)
|
|
return m_cRef;
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CEnumVarHiPerf::Next
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Get the next object in the enumeration
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// lTimeout Number of ms to wait for object (or WBEM_INFINITE for
|
|
// indefinite)
|
|
// ppObject On return may contain the next element (if any)
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// S_OK success
|
|
// S_FALSE not all elements could be returned
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CEnumVarHiPerf::Next (
|
|
ULONG cElements,
|
|
VARIANT FAR* pVar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG l2 = 0;
|
|
|
|
if (NULL != pcElementFetched)
|
|
*pcElementFetched = 0;
|
|
|
|
if (NULL != pVar)
|
|
{
|
|
for (ULONG l = 0; l < cElements; l++)
|
|
VariantInit (&pVar [l]);
|
|
|
|
// Retrieve the next cElements elements.
|
|
for (l2 = 0; l2 < cElements; l2++)
|
|
{
|
|
CComPtr<IWbemClassObject> pIWbemClassObject;
|
|
|
|
if (m_iPos < m_iCount)
|
|
{
|
|
if (SUCCEEDED(hr = m_ppIWbemObjectAccess [m_iPos]->QueryInterface
|
|
(IID_IWbemClassObject, (void**) &pIWbemClassObject)))
|
|
{
|
|
m_iPos++;
|
|
|
|
// Make a new ISWbemObjectEx
|
|
CSWbemObject *pCSWbemObject = new CSWbemObject
|
|
(m_pCSWbemHiPerfObjectSet->GetSWbemServices (),
|
|
pIWbemClassObject);
|
|
|
|
ISWbemObjectEx *pISWbemObjectEx = NULL;
|
|
|
|
if (!pCSWbemObject)
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
else if (SUCCEEDED(hr = pCSWbemObject->QueryInterface (IID_ISWbemObjectEx,
|
|
(PPVOID) &pISWbemObjectEx)))
|
|
{
|
|
// Set the object into the variant array
|
|
pVar[l2].vt = VT_DISPATCH;
|
|
pVar[l2].pdispVal = pISWbemObjectEx;
|
|
}
|
|
else
|
|
{
|
|
delete pCSWbemObject;
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
break;
|
|
}
|
|
else
|
|
break; // No more elements
|
|
}
|
|
|
|
if (NULL != pcElementFetched)
|
|
*pcElementFetched = l2;
|
|
|
|
SetWbemError (m_pCSWbemHiPerfObjectSet->GetSWbemServices ());
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
return (l2 < cElements) ? S_FALSE : S_OK;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CEnumVarHiPerf::Clone
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Create a copy of this enumeration
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// ppEnum on successful return addresses the clone
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// WBEM_S_NO_ERROR success
|
|
// WBEM_E_FAILED otherwise
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CEnumVarHiPerf::Clone (
|
|
IEnumVARIANT **ppEnum
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (NULL != ppEnum)
|
|
{
|
|
*ppEnum = NULL;
|
|
CEnumVarHiPerf *pEnumVar = new CEnumVarHiPerf (m_pCSWbemHiPerfObjectSet);
|
|
|
|
if (!pEnumVar)
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
else if (FAILED(hr = pEnumVar->QueryInterface (IID_IEnumVARIANT, (PPVOID) ppEnum)))
|
|
delete pEnumVar;
|
|
|
|
SetWbemError (m_pCSWbemHiPerfObjectSet->GetSWbemServices ());
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE CEnumVarHiPerf::Skip
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Create a copy of this enumeration
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// ppEnum on successful return addresses the clone
|
|
//
|
|
// RETURN VALUES:
|
|
//
|
|
// S_OK success
|
|
// S_FALSE end of sequence reached prematurely
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT CEnumVarHiPerf::Skip(
|
|
ULONG cElements
|
|
)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
if (m_iPos + cElements > m_iCount)
|
|
m_iPos = m_iCount;
|
|
else
|
|
{
|
|
m_iPos += cElements;
|
|
hr = S_OK;
|
|
}
|
|
|
|
SetWbemError (m_pCSWbemHiPerfObjectSet->GetSWbemServices ());
|
|
return hr;
|
|
}
|
|
|
|
|