1256 lines
40 KiB
C++
1256 lines
40 KiB
C++
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|||
|
|
//
|
|||
|
|
// REFRESHR.CPP
|
|||
|
|
//
|
|||
|
|
// Mapped NT5 Perf Counter Provider
|
|||
|
|
//
|
|||
|
|
// raymcc 02-Dec-97 Created.
|
|||
|
|
// raymcc 20-Feb-98 Updated to use new initializer.
|
|||
|
|
// bobw 8-Jub-98 optimized for use with NT Perf counters
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
|
|||
|
|
#include "wpheader.h"
|
|||
|
|
#include <stdio.h>
|
|||
|
|
#include "oahelp.inl"
|
|||
|
|
|
|||
|
|
// Timeout for our wait calls
|
|||
|
|
#define REFRESHER_MUTEX_WAIT_TIMEOUT 10000
|
|||
|
|
|
|||
|
|
class CMutexReleaseMe
|
|||
|
|
{
|
|||
|
|
private:
|
|||
|
|
HANDLE m_hMutex;
|
|||
|
|
|
|||
|
|
public:
|
|||
|
|
CMutexReleaseMe( HANDLE hMutex ) : m_hMutex( hMutex ) {};
|
|||
|
|
~CMutexReleaseMe() { if ( NULL != m_hMutex ) ReleaseMutex( m_hMutex ); };
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// RefresherCacheEl::RefresherCacheEl
|
|||
|
|
//
|
|||
|
|
// Constructor
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
RefresherCacheEl::RefresherCacheEl()
|
|||
|
|
{
|
|||
|
|
m_dwPerfObjIx = 0;
|
|||
|
|
m_pClassMap = NULL;
|
|||
|
|
m_pSingleton = NULL;
|
|||
|
|
m_lSingletonId = 0;
|
|||
|
|
m_plIds = NULL; // array of ID's
|
|||
|
|
m_lEnumArraySize = 0; // size of ID array in elements
|
|||
|
|
m_pHiPerfEnum = NULL;
|
|||
|
|
m_lEnumId = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// RefresherCacheEl::~RefresherCacheEl()
|
|||
|
|
//
|
|||
|
|
// Destructor
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
RefresherCacheEl::~RefresherCacheEl()
|
|||
|
|
{
|
|||
|
|
LONG nNumInstances;
|
|||
|
|
int i;
|
|||
|
|
|
|||
|
|
delete m_pClassMap;
|
|||
|
|
|
|||
|
|
if (m_pSingleton != NULL) {
|
|||
|
|
m_pSingleton->Release();
|
|||
|
|
m_pSingleton = NULL;
|
|||
|
|
m_lSingletonId = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
nNumInstances = m_aInstances.Size();
|
|||
|
|
for (i = 0; i < nNumInstances; i++) {
|
|||
|
|
delete (CachedInst *) m_aInstances[i];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
nNumInstances = m_aEnumInstances.Size();
|
|||
|
|
if (nNumInstances> 0) {
|
|||
|
|
IWbemObjectAccess *pAccess;
|
|||
|
|
for (i = 0; i < nNumInstances ; i++) {
|
|||
|
|
pAccess = (IWbemObjectAccess *)(m_aEnumInstances.GetAt(i));
|
|||
|
|
if (pAccess != NULL) {
|
|||
|
|
pAccess->Release();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
m_aEnumInstances.Empty();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_plIds != NULL) {
|
|||
|
|
delete (m_plIds);
|
|||
|
|
m_plIds = NULL;
|
|||
|
|
m_lEnumArraySize = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_pHiPerfEnum != NULL) {
|
|||
|
|
m_pHiPerfEnum->Release();
|
|||
|
|
m_pHiPerfEnum = NULL;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher constructor
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
CNt5Refresher::CNt5Refresher(CNt5PerfProvider *pPerfProviderArg)
|
|||
|
|
{
|
|||
|
|
assert (pPerfProviderArg != NULL);
|
|||
|
|
|
|||
|
|
m_ClsidType = pPerfProviderArg->m_OriginClsid;
|
|||
|
|
m_pPerfProvider = pPerfProviderArg;
|
|||
|
|
|
|||
|
|
m_pPerfProvider = NULL; // for testing of local class map
|
|||
|
|
|
|||
|
|
if (m_pPerfProvider != NULL) {
|
|||
|
|
m_pPerfProvider->AddRef();
|
|||
|
|
}
|
|||
|
|
m_hAccessMutex = CreateMutex (NULL, TRUE, NULL);
|
|||
|
|
m_dwGetGetNextClassIndex = 0;
|
|||
|
|
m_lRef = 0; // COM Ref Count
|
|||
|
|
m_lProbableId = 1; // Used for new IDs
|
|||
|
|
m_aCache.Empty(); // clear and reset the array
|
|||
|
|
RELEASE_MUTEX (m_hAccessMutex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher destructor
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
CNt5Refresher::~CNt5Refresher()
|
|||
|
|
{
|
|||
|
|
int nNumElements;
|
|||
|
|
int i;
|
|||
|
|
|
|||
|
|
PRefresherCacheEl pCacheEl;
|
|||
|
|
|
|||
|
|
assert (m_lRef == 0);
|
|||
|
|
|
|||
|
|
// Make sure we get access to the mutex before we try and clean things up.
|
|||
|
|
// If we don't get it in a reasonable time, something's up. Since we're
|
|||
|
|
// destructing, we'll just quietly let stuff go.
|
|||
|
|
|
|||
|
|
if ( WaitForSingleObject( m_hAccessMutex, REFRESHER_MUTEX_WAIT_TIMEOUT ) == WAIT_OBJECT_0 )
|
|||
|
|
{
|
|||
|
|
// This will auto-release the mutex in case something bad happens
|
|||
|
|
CMutexReleaseMe mrm( m_hAccessMutex );
|
|||
|
|
|
|||
|
|
nNumElements = m_aCache.Size();
|
|||
|
|
for (i = 0; i < nNumElements; i++) {
|
|||
|
|
pCacheEl = (PRefresherCacheEl)m_aCache[i];
|
|||
|
|
|
|||
|
|
// We want to call this once for each instance
|
|||
|
|
for ( int n = 0; n < pCacheEl->m_aInstances.Size(); n++ )
|
|||
|
|
{
|
|||
|
|
m_PerfObj.RemoveClass (pCacheEl->m_pClassMap->m_pClassDef);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// If we have a Singleton value, RemoveClass should be
|
|||
|
|
// called once more
|
|||
|
|
if ( NULL != pCacheEl->m_pSingleton )
|
|||
|
|
{
|
|||
|
|
m_PerfObj.RemoveClass (pCacheEl->m_pClassMap->m_pClassDef);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// And finally if we have an enumerator, remove the class
|
|||
|
|
// once more.
|
|||
|
|
if ( NULL != pCacheEl->m_pHiPerfEnum )
|
|||
|
|
{
|
|||
|
|
m_PerfObj.RemoveClass (pCacheEl->m_pClassMap->m_pClassDef);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
delete pCacheEl;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_pPerfProvider != NULL) {
|
|||
|
|
m_pPerfProvider->Release();
|
|||
|
|
m_pPerfProvider = NULL;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
CloseHandle (m_hAccessMutex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::Refresh
|
|||
|
|
//
|
|||
|
|
// Executed to refresh a set of instances bound to the particular
|
|||
|
|
// refresher.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
HRESULT CNt5Refresher::Refresh(/* [in] */ long lFlags)
|
|||
|
|
{
|
|||
|
|
HRESULT hrReturn = WBEM_S_NO_ERROR;
|
|||
|
|
HRESULT hReturn = S_OK;
|
|||
|
|
BOOL bRes;
|
|||
|
|
|
|||
|
|
UNREFERENCED_PARAMETER(lFlags);
|
|||
|
|
|
|||
|
|
BOOL bNeedCoImpersonate = FALSE;
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// this is ugly
|
|||
|
|
// wmicookr is not impersonating, because
|
|||
|
|
// it relys on other provider to do that
|
|||
|
|
// but, it calls the IWbemRefresher::Refresh when it's inside winmgmt or wmiprvse
|
|||
|
|
// and it calls it from an UN-Impersonated thread
|
|||
|
|
// so, we need that the provider calls CoImpersonateClient
|
|||
|
|
// on a Refresh invocation, that is expensive in general,
|
|||
|
|
// only if the provider has been invoked through the Server CLSID
|
|||
|
|
//
|
|||
|
|
BOOL fRevert;
|
|||
|
|
if (CNt5PerfProvider::CLSID_SERVER == m_ClsidType)
|
|||
|
|
{
|
|||
|
|
hReturn = CoImpersonateClient(); // make sure we're legit.
|
|||
|
|
|
|||
|
|
fRevert = SUCCEEDED( hReturn );
|
|||
|
|
|
|||
|
|
// The following error appears to occur when we are in-proc and there is no
|
|||
|
|
// proxy/stub, so we are effectively impersonating already
|
|||
|
|
|
|||
|
|
if ( RPC_E_CALL_COMPLETE == hReturn ) {
|
|||
|
|
hReturn = S_OK;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (S_OK == hReturn) {
|
|||
|
|
hReturn = CNt5PerfProvider::CheckImpersonationLevel();
|
|||
|
|
}
|
|||
|
|
// Check Registry security here.
|
|||
|
|
if ((hReturn != S_OK) || (!CNt5PerfProvider::HasPermission())) {
|
|||
|
|
// if Impersonation level is incorrect or
|
|||
|
|
// the caller doesn't have permission to read
|
|||
|
|
// from the registry, then they cannot continue
|
|||
|
|
hReturn = WBEM_E_ACCESS_DENIED;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (hReturn == S_OK)
|
|||
|
|
{
|
|||
|
|
// Make sure we get access to the mutex before we continue. If we can't
|
|||
|
|
// get to it, something's wrong, so we'll just assume we are busy.
|
|||
|
|
|
|||
|
|
if ( WaitForSingleObject( m_hAccessMutex, REFRESHER_MUTEX_WAIT_TIMEOUT ) == WAIT_OBJECT_0 )
|
|||
|
|
{
|
|||
|
|
// This will auto-release the mutex in case something bad happens
|
|||
|
|
CMutexReleaseMe mrm( m_hAccessMutex );
|
|||
|
|
|
|||
|
|
bRes = PerfHelper::RefreshInstances(this);
|
|||
|
|
if (!bRes) {
|
|||
|
|
hrReturn = WBEM_E_FAILED;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
hrReturn = WBEM_E_REFRESHER_BUSY;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (CNt5PerfProvider::CLSID_SERVER == m_ClsidType)
|
|||
|
|
{
|
|||
|
|
// Revert if we successfuly impersonated the user
|
|||
|
|
if ( fRevert )
|
|||
|
|
{
|
|||
|
|
CoRevertToSelf();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
return hrReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::AddRef
|
|||
|
|
//
|
|||
|
|
// Standard COM AddRef().
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
|
|||
|
|
ULONG CNt5Refresher::AddRef()
|
|||
|
|
{
|
|||
|
|
return InterlockedIncrement(&m_lRef);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::Release
|
|||
|
|
//
|
|||
|
|
// Standard COM Release().
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
|
|||
|
|
ULONG CNt5Refresher::Release()
|
|||
|
|
{
|
|||
|
|
long lRef = InterlockedDecrement(&m_lRef);
|
|||
|
|
if(lRef == 0)
|
|||
|
|
delete this;
|
|||
|
|
return lRef;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::QueryInterface
|
|||
|
|
//
|
|||
|
|
// Standard COM QueryInterface().
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
|
|||
|
|
HRESULT CNt5Refresher::QueryInterface(REFIID riid, void** ppv)
|
|||
|
|
{
|
|||
|
|
if (riid == IID_IUnknown || riid == IID_IWbemRefresher)
|
|||
|
|
{
|
|||
|
|
*ppv = (IWbemRefresher *) this;
|
|||
|
|
AddRef();
|
|||
|
|
return S_OK;
|
|||
|
|
}
|
|||
|
|
else return E_NOINTERFACE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::RemoveObject
|
|||
|
|
//
|
|||
|
|
// Removes an object from the refresher. Since we don't know
|
|||
|
|
// by ID alone which class it is, we loop through all the ones we
|
|||
|
|
// have until somebody claims it and returns TRUE for a removal.(
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
BOOL CNt5Refresher::RemoveObject(LONG lId)
|
|||
|
|
{
|
|||
|
|
BOOL bReturn = FALSE;
|
|||
|
|
BOOL bRes;
|
|||
|
|
PRefresherCacheEl pCacheEl;
|
|||
|
|
int nNumElements;
|
|||
|
|
|
|||
|
|
// Make sure we get access to the mutex before we continue. If we can't
|
|||
|
|
// get to it, something's wrong, so we'll just assume we are busy.
|
|||
|
|
|
|||
|
|
if ( WaitForSingleObject( m_hAccessMutex, REFRESHER_MUTEX_WAIT_TIMEOUT ) == WAIT_OBJECT_0 )
|
|||
|
|
{
|
|||
|
|
// This will auto-release the mutex in case something bad happens
|
|||
|
|
CMutexReleaseMe mrm( m_hAccessMutex );
|
|||
|
|
|
|||
|
|
nNumElements = m_aCache.Size();
|
|||
|
|
for (int i = 0; i < nNumElements; i++)
|
|||
|
|
{
|
|||
|
|
pCacheEl = PRefresherCacheEl(m_aCache[i]);
|
|||
|
|
assert (pCacheEl != NULL);
|
|||
|
|
|
|||
|
|
bRes = pCacheEl->RemoveInst(lId);
|
|||
|
|
if (bRes == TRUE) {
|
|||
|
|
// found the matching instance so
|
|||
|
|
// de register this with the perf library
|
|||
|
|
m_PerfObj.RemoveClass (pCacheEl->m_pClassMap->m_pClassDef);
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
SetLastError( (ULONG) WBEM_E_REFRESHER_BUSY );
|
|||
|
|
bReturn = FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return bReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::FindSingletonInst
|
|||
|
|
//
|
|||
|
|
// Based on a perf object identification, locates a singleton WBEM
|
|||
|
|
// instance of that class within this refresher and returns the pointer
|
|||
|
|
// to it and its WBEM class info.
|
|||
|
|
//
|
|||
|
|
// Note that the <dwPerfObjIx> maps directly to a WBEM Class entry.
|
|||
|
|
//
|
|||
|
|
// To save execution time, we don't AddRef() the return value and the
|
|||
|
|
// caller doesn't Release().
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
BOOL CNt5Refresher::FindSingletonInst(
|
|||
|
|
IN DWORD dwPerfObjIx,
|
|||
|
|
OUT IWbemObjectAccess **pInst,
|
|||
|
|
OUT CClassMapInfo **pClsMap
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
BOOL bReturn = FALSE;
|
|||
|
|
PRefresherCacheEl pCacheEl;
|
|||
|
|
|
|||
|
|
int l = 0;
|
|||
|
|
int u = m_aCache.Size() - 1;
|
|||
|
|
int m;
|
|||
|
|
|
|||
|
|
// Binary search the cache.
|
|||
|
|
// ========================
|
|||
|
|
|
|||
|
|
while (l <= u) {
|
|||
|
|
|
|||
|
|
m = (l + u) / 2;
|
|||
|
|
|
|||
|
|
pCacheEl = PRefresherCacheEl(m_aCache[m]);
|
|||
|
|
|
|||
|
|
if (dwPerfObjIx < pCacheEl->m_dwPerfObjIx) {
|
|||
|
|
u = m - 1;
|
|||
|
|
} else if (dwPerfObjIx > pCacheEl->m_dwPerfObjIx) {
|
|||
|
|
l = m + 1;
|
|||
|
|
} else {
|
|||
|
|
*pClsMap = pCacheEl->m_pClassMap;
|
|||
|
|
*pInst = pCacheEl->m_pSingleton; // No AddRef() caller doesn't
|
|||
|
|
// change ref count
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Not found
|
|||
|
|
// =========
|
|||
|
|
|
|||
|
|
return bReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::FindInst
|
|||
|
|
//
|
|||
|
|
// Based on a perf object identification, locates a WBEM instance of
|
|||
|
|
// that class within this refresher and returns the pointer to it.
|
|||
|
|
//
|
|||
|
|
// Note that the <dwPerfObjIx> maps directly to a WBEM Class entry.
|
|||
|
|
//
|
|||
|
|
// To save execution time, we don't AddRef() the return value and the
|
|||
|
|
// caller doesn't Release().
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
|
|||
|
|
BOOL CNt5Refresher::FindInst(
|
|||
|
|
IN DWORD dwPerfObjIx,
|
|||
|
|
IN LPWSTR pszInstName,
|
|||
|
|
OUT IWbemObjectAccess **pInst,
|
|||
|
|
OUT CClassMapInfo **pClsMap
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
BOOL bReturn = FALSE;
|
|||
|
|
IWbemObjectAccess *pTmp;
|
|||
|
|
PRefresherCacheEl pCacheEl;
|
|||
|
|
|
|||
|
|
int l = 0;
|
|||
|
|
int u = m_aCache.Size() - 1;
|
|||
|
|
int m;
|
|||
|
|
|
|||
|
|
// Binary search the cache.
|
|||
|
|
// ========================
|
|||
|
|
|
|||
|
|
while (l <= u) {
|
|||
|
|
m = (l + u) / 2;
|
|||
|
|
|
|||
|
|
pCacheEl = PRefresherCacheEl(m_aCache[m]);
|
|||
|
|
|
|||
|
|
if (dwPerfObjIx < pCacheEl->m_dwPerfObjIx) {
|
|||
|
|
u = m - 1;
|
|||
|
|
} else if (dwPerfObjIx > pCacheEl->m_dwPerfObjIx) {
|
|||
|
|
l = m + 1;
|
|||
|
|
} else {
|
|||
|
|
// We found the class. Now do we have the instance?
|
|||
|
|
// =================================================
|
|||
|
|
pTmp = pCacheEl->FindInst(pszInstName);
|
|||
|
|
if (pTmp == 0) {
|
|||
|
|
bReturn = FALSE; // Didn't have it.
|
|||
|
|
} else {
|
|||
|
|
*pInst = pTmp;
|
|||
|
|
*pClsMap = pCacheEl->m_pClassMap;
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Not found
|
|||
|
|
// =========
|
|||
|
|
|
|||
|
|
return bReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::GetObjectIds
|
|||
|
|
//
|
|||
|
|
// Gets a list of all the perf object Ids corresponding to the instances
|
|||
|
|
// in the refresher.
|
|||
|
|
//
|
|||
|
|
// Caller uses operator delete to deallocate the returned array.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
BOOL CNt5Refresher::GetObjectIds(
|
|||
|
|
DWORD *pdwNumIds,
|
|||
|
|
DWORD **pdwIdList
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
DWORD *pdwIds;
|
|||
|
|
int nNumElements;
|
|||
|
|
BOOL bReturn;
|
|||
|
|
|
|||
|
|
nNumElements = m_aCache.Size();
|
|||
|
|
|
|||
|
|
pdwIds = new DWORD[nNumElements ];
|
|||
|
|
|
|||
|
|
if (pdwIds != NULL) {
|
|||
|
|
for (int i = 0; i < nNumElements; i++) {
|
|||
|
|
pdwIds[i] = PRefresherCacheEl(m_aCache[i])->m_dwPerfObjIx;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
*pdwIdList = pdwIds;
|
|||
|
|
*pdwNumIds = nNumElements;
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
} else {
|
|||
|
|
// unable to create buffer
|
|||
|
|
bReturn = FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return bReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::FindUnusedId
|
|||
|
|
//
|
|||
|
|
// Finds an ID not in use for new objects to be added to the refresher.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
LONG CNt5Refresher::FindUnusedId()
|
|||
|
|
{
|
|||
|
|
PRefresherCacheEl pEl;
|
|||
|
|
PCachedInst pInst;
|
|||
|
|
int nRetries = 0x100000; // A hundred thousand retries
|
|||
|
|
LONG lReturn = -1;
|
|||
|
|
int i;
|
|||
|
|
int i2;
|
|||
|
|
int nNumElements;
|
|||
|
|
int nNumInstances;
|
|||
|
|
// assume the object is locked for access
|
|||
|
|
|
|||
|
|
Restart:
|
|||
|
|
while (nRetries--) {
|
|||
|
|
i = 0;
|
|||
|
|
nNumElements = m_aCache.Size();
|
|||
|
|
while(i < nNumElements) {
|
|||
|
|
pEl = PRefresherCacheEl(m_aCache[i]);
|
|||
|
|
// test enum Id first
|
|||
|
|
if (pEl->m_lEnumId == m_lProbableId) {
|
|||
|
|
m_lProbableId++;
|
|||
|
|
goto Restart;
|
|||
|
|
}
|
|||
|
|
i2 = 0;
|
|||
|
|
nNumInstances = pEl->m_aInstances.Size();
|
|||
|
|
while (i2 < nNumInstances) {
|
|||
|
|
pInst = (PCachedInst) pEl->m_aInstances[i2];
|
|||
|
|
if (pInst->m_lId == m_lProbableId) {
|
|||
|
|
m_lProbableId++;
|
|||
|
|
goto Restart;
|
|||
|
|
}
|
|||
|
|
i2++;
|
|||
|
|
}
|
|||
|
|
i++;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
lReturn = m_lProbableId;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return lReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// RefresherCacheEl::RemoveInst
|
|||
|
|
//
|
|||
|
|
// Removes the requested instances from the cache element for a particular
|
|||
|
|
// class.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
|
|||
|
|
BOOL RefresherCacheEl::RemoveInst(LONG lId)
|
|||
|
|
{
|
|||
|
|
BOOL bReturn = FALSE;
|
|||
|
|
int i;
|
|||
|
|
PCachedInst pInst;
|
|||
|
|
int nNumInstances;
|
|||
|
|
|
|||
|
|
if (lId == m_lEnumId) {
|
|||
|
|
// then clean out the enumerator for this object
|
|||
|
|
nNumInstances = m_aEnumInstances.Size();
|
|||
|
|
if (nNumInstances> 0) {
|
|||
|
|
IWbemObjectAccess *pAccess;
|
|||
|
|
for (i = 0; i < nNumInstances ; i++) {
|
|||
|
|
pAccess = (IWbemObjectAccess *)(m_aEnumInstances.GetAt(i));
|
|||
|
|
if (pAccess != NULL) {
|
|||
|
|
pAccess->Release();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
m_aEnumInstances.Empty();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_plIds != NULL) {
|
|||
|
|
delete (m_plIds);
|
|||
|
|
m_plIds = NULL;
|
|||
|
|
m_lEnumArraySize = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_pHiPerfEnum != NULL) {
|
|||
|
|
m_pHiPerfEnum->Release();
|
|||
|
|
m_pHiPerfEnum = NULL;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Now, if this is a singleton (m_pSingleton != NULL),
|
|||
|
|
// then check if m_aInstances is empty. If so, then
|
|||
|
|
// no instances are referencing the singleton object
|
|||
|
|
// so we can free up its resources.
|
|||
|
|
|
|||
|
|
if ( NULL != m_pSingleton && 0 == m_aInstances.Size() )
|
|||
|
|
{
|
|||
|
|
m_pSingleton->Release();
|
|||
|
|
m_pSingleton = NULL;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return TRUE;
|
|||
|
|
} else {
|
|||
|
|
// walk the instances to find a match
|
|||
|
|
nNumInstances = m_aInstances.Size();
|
|||
|
|
for (i = 0; i < nNumInstances; i++) {
|
|||
|
|
pInst = (PCachedInst) m_aInstances[i];
|
|||
|
|
if (lId == pInst->m_lId) {
|
|||
|
|
delete pInst;
|
|||
|
|
m_aInstances.RemoveAt(i);
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Now, if we removed an instance, m_aInstances is empty
|
|||
|
|
// and this is a singleton (m_pSingleton != NULL), then
|
|||
|
|
// check if m_pHiPerfEnum is NULL, meaning no Enumerator
|
|||
|
|
// exists, so none of its instances will be referencing
|
|||
|
|
// the singleton object, so we can free up its resources.
|
|||
|
|
|
|||
|
|
if ( NULL != m_pSingleton
|
|||
|
|
&& bReturn
|
|||
|
|
&& 0 == m_aInstances.Size()
|
|||
|
|
&& NULL == m_pHiPerfEnum )
|
|||
|
|
{
|
|||
|
|
m_pSingleton->Release();
|
|||
|
|
m_pSingleton = NULL;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( bReturn )
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return bReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::AddEnum
|
|||
|
|
//
|
|||
|
|
// Creates an enumerator for the specified class
|
|||
|
|
// to it.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ?
|
|||
|
|
BOOL CNt5Refresher::AddEnum (
|
|||
|
|
IN IWbemHiPerfEnum *pEnum, // enum interface pointer
|
|||
|
|
IN CClassMapInfo *pClsMap, // Class of object
|
|||
|
|
OUT LONG *plId // id for new enum
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
BOOL bRes = FALSE;
|
|||
|
|
LONG lStatus;
|
|||
|
|
LONG lNewId;
|
|||
|
|
PRefresherCacheEl pWorkEl;
|
|||
|
|
int iReturn;
|
|||
|
|
|
|||
|
|
// Make sure we get access to the mutex before we continue. If we can't
|
|||
|
|
// get to it, something's wrong, so we'll just assume we are busy.
|
|||
|
|
|
|||
|
|
if ( WaitForSingleObject( m_hAccessMutex, REFRESHER_MUTEX_WAIT_TIMEOUT ) == WAIT_OBJECT_0 )
|
|||
|
|
{
|
|||
|
|
// This will auto-release the mutex in case something bad happens
|
|||
|
|
CMutexReleaseMe mrm( m_hAccessMutex );
|
|||
|
|
|
|||
|
|
lNewId = FindUnusedId();
|
|||
|
|
|
|||
|
|
if (lNewId != -1) {
|
|||
|
|
// First, find the cache element corresponding to this object.
|
|||
|
|
// ===========================================================
|
|||
|
|
pWorkEl = GetCacheEl(pClsMap);
|
|||
|
|
|
|||
|
|
// If <pWorkEl> is NULL, we didn't have anything in the cache
|
|||
|
|
// and have to add a new one.
|
|||
|
|
// ==========================================================
|
|||
|
|
|
|||
|
|
if (pWorkEl == NULL) {
|
|||
|
|
bRes = AddNewCacheEl(pClsMap, &pWorkEl);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (pWorkEl != NULL) {
|
|||
|
|
if (pWorkEl->m_pHiPerfEnum == NULL) {
|
|||
|
|
// then we can init it as it hasn't been opened
|
|||
|
|
pEnum->AddRef();
|
|||
|
|
pWorkEl->m_pHiPerfEnum = pEnum;
|
|||
|
|
pWorkEl->m_lEnumId = lNewId;
|
|||
|
|
|
|||
|
|
assert (pWorkEl->m_aEnumInstances.Size() == 0L);
|
|||
|
|
bRes = TRUE;
|
|||
|
|
|
|||
|
|
if (pClsMap->IsSingleton()) {
|
|||
|
|
LONG lNumObjInstances;
|
|||
|
|
// then create the singleton IWbemObjectAccess entry here
|
|||
|
|
|
|||
|
|
lNumObjInstances = 1;
|
|||
|
|
|
|||
|
|
// If we do NOT have a singleton pointer, make it so.
|
|||
|
|
if ( NULL == pWorkEl->m_pSingleton )
|
|||
|
|
{
|
|||
|
|
// add the new IWbemObjectAccess pointers
|
|||
|
|
IWbemClassObject *pClsObj = NULL;
|
|||
|
|
|
|||
|
|
pWorkEl->m_pClassMap->m_pClassDef->SpawnInstance(0, &pClsObj);
|
|||
|
|
if( NULL != pClsObj ){
|
|||
|
|
pClsObj->QueryInterface(IID_IWbemObjectAccess, (LPVOID *) &pWorkEl->m_pSingleton);
|
|||
|
|
pClsObj->Release(); // We only need the IWbemObjectAccess pointer
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// We don't really care about the singleton id anymore
|
|||
|
|
// pWorkEl->m_lSingletonId = pWorkEl->m_plIds[0];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (pWorkEl->m_aEnumInstances.Size() < lNumObjInstances) {
|
|||
|
|
// alloc and init the ID array
|
|||
|
|
if (pWorkEl->m_plIds != NULL) {
|
|||
|
|
delete (pWorkEl->m_plIds);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
pWorkEl->m_lEnumArraySize = lNumObjInstances;
|
|||
|
|
pWorkEl->m_plIds = new LONG[lNumObjInstances];
|
|||
|
|
|
|||
|
|
if (pWorkEl->m_plIds != NULL) {
|
|||
|
|
pWorkEl->m_plIds[0] = 0;
|
|||
|
|
|
|||
|
|
// AddRef the singleton class and place it in the enuminstances array
|
|||
|
|
pWorkEl->m_pSingleton->AddRef();
|
|||
|
|
iReturn = pWorkEl->m_aEnumInstances.Add (pWorkEl->m_pSingleton);
|
|||
|
|
if (iReturn == CFlexArray::no_error) {
|
|||
|
|
// Add the singleton object to the enumerator. Then, all we have to
|
|||
|
|
// do is update this object and we will, by default update the
|
|||
|
|
// enumerator, since the number of objects in it will always
|
|||
|
|
// be one.
|
|||
|
|
|
|||
|
|
pWorkEl->m_pHiPerfEnum->AddObjects(
|
|||
|
|
0,
|
|||
|
|
1,
|
|||
|
|
pWorkEl->m_plIds,
|
|||
|
|
(IWbemObjectAccess __RPC_FAR *__RPC_FAR *)pWorkEl->m_aEnumInstances.GetArrayPtr());
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
SetLastError((ULONG) WBEM_E_OUT_OF_MEMORY);
|
|||
|
|
bRes = FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
SetLastError ((ULONG)WBEM_E_OUT_OF_MEMORY);
|
|||
|
|
bRes = FALSE;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
assert (pWorkEl->m_aEnumInstances.Size() >= lNumObjInstances);
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// load provider library since all went OK so far
|
|||
|
|
lStatus = m_PerfObj.AddClass (pClsMap->m_pClassDef, FALSE);
|
|||
|
|
if (lStatus == ERROR_SUCCESS) {
|
|||
|
|
// return new ID & successful status
|
|||
|
|
*plId = lNewId;
|
|||
|
|
bRes = TRUE;
|
|||
|
|
} else {
|
|||
|
|
// set error: Class or library failed to load
|
|||
|
|
SetLastError ((ULONG)WBEM_E_PROVIDER_FAILURE);
|
|||
|
|
bRes = FALSE;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
// this class already has an enumerator
|
|||
|
|
// what to do here?
|
|||
|
|
// for now we'll return the id of the existing one
|
|||
|
|
SetLastError ((ULONG)WBEM_E_ILLEGAL_OPERATION);
|
|||
|
|
bRes = FALSE;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} // IF WaitForSingleObject
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
bRes = FALSE;
|
|||
|
|
// We're locked out of the mutex
|
|||
|
|
SetLastError ((ULONG)WBEM_E_REFRESHER_BUSY);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return bRes;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::AddObject
|
|||
|
|
//
|
|||
|
|
// Adds the requested object to the refresher and assigns an ID
|
|||
|
|
// to it.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ?
|
|||
|
|
BOOL CNt5Refresher::AddObject(
|
|||
|
|
IN IWbemObjectAccess **ppObj, // Object to add
|
|||
|
|
IN CClassMapInfo *pClsMap, // Class of object
|
|||
|
|
OUT LONG *plId // The id of the object added
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
BOOL bRes = FALSE;
|
|||
|
|
LONG lStatus;
|
|||
|
|
LONG lNewId;
|
|||
|
|
PRefresherCacheEl pWorkEl;
|
|||
|
|
|
|||
|
|
// Make sure we get access to the mutex before we continue. If we can't
|
|||
|
|
// get to it, something's wrong, so we'll just assume we are busy.
|
|||
|
|
|
|||
|
|
if ( WaitForSingleObject( m_hAccessMutex, REFRESHER_MUTEX_WAIT_TIMEOUT ) == WAIT_OBJECT_0 )
|
|||
|
|
{
|
|||
|
|
// This will auto-release the mutex in case something bad happens
|
|||
|
|
CMutexReleaseMe mrm( m_hAccessMutex );
|
|||
|
|
|
|||
|
|
lNewId = FindUnusedId();
|
|||
|
|
|
|||
|
|
if (lNewId != -1) {
|
|||
|
|
// First, find the cache element corresponding to this object.
|
|||
|
|
// ===========================================================
|
|||
|
|
pWorkEl = GetCacheEl(pClsMap);
|
|||
|
|
|
|||
|
|
// If <pWorkEl> is NULL, we didn't have anything in the cache
|
|||
|
|
// and have to add a new one.
|
|||
|
|
// ==========================================================
|
|||
|
|
|
|||
|
|
if (pWorkEl == NULL) {
|
|||
|
|
bRes = AddNewCacheEl(pClsMap, &pWorkEl);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (pWorkEl != NULL) {
|
|||
|
|
// If here, we have successfully added a new cache element.
|
|||
|
|
// ========================================================
|
|||
|
|
bRes = pWorkEl->InsertInst(ppObj, lNewId);
|
|||
|
|
|
|||
|
|
if (bRes) {
|
|||
|
|
// load provider library since all went OK so far
|
|||
|
|
lStatus = m_PerfObj.AddClass (pClsMap->m_pClassDef, FALSE);
|
|||
|
|
|
|||
|
|
if (lStatus == ERROR_SUCCESS) {
|
|||
|
|
// return new ID & successful status
|
|||
|
|
*plId = lNewId;
|
|||
|
|
bRes = TRUE;
|
|||
|
|
} else {
|
|||
|
|
// set error: Class or library failed to load
|
|||
|
|
SetLastError ((ULONG)WBEM_E_PROVIDER_FAILURE);
|
|||
|
|
bRes = FALSE;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} // IF acquired mutex
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
bRes = FALSE;
|
|||
|
|
// Return a busy error
|
|||
|
|
SetLastError ((ULONG)WBEM_E_REFRESHER_BUSY);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return bRes;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::AddNewCacheEl
|
|||
|
|
//
|
|||
|
|
// Adds a new cache element in the proper position so that a binary
|
|||
|
|
// search on perf object id can occur later.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
BOOL CNt5Refresher::AddNewCacheEl(
|
|||
|
|
IN CClassMapInfo *pClsMap,
|
|||
|
|
PRefresherCacheEl *pOutput
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
// assumes the object is locked for access
|
|||
|
|
|
|||
|
|
PRefresherCacheEl pWorkEl;
|
|||
|
|
PRefresherCacheEl pNew = 0;
|
|||
|
|
|
|||
|
|
int i;
|
|||
|
|
int nNumElements;
|
|||
|
|
BOOL bReturn = FALSE;
|
|||
|
|
|
|||
|
|
* pOutput = NULL;
|
|||
|
|
pNew = new RefresherCacheEl;
|
|||
|
|
|
|||
|
|
if (pNew != NULL) {
|
|||
|
|
pNew->m_dwPerfObjIx = pClsMap->GetObjectId();
|
|||
|
|
pNew->m_pClassMap = pClsMap->CreateDuplicate();
|
|||
|
|
|
|||
|
|
if (pNew->m_pClassMap != NULL) {
|
|||
|
|
nNumElements = m_aCache.Size();
|
|||
|
|
for (i = 0; i < nNumElements; i++) {
|
|||
|
|
// walk through the list of cache elements
|
|||
|
|
// and find the first entry that has a
|
|||
|
|
// larger index then the one we are adding
|
|||
|
|
pWorkEl = PRefresherCacheEl(m_aCache[i]);
|
|||
|
|
if (pNew->m_dwPerfObjIx < pWorkEl->m_dwPerfObjIx) {
|
|||
|
|
m_aCache.InsertAt(i, pNew);
|
|||
|
|
*pOutput = pNew;
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (i == nNumElements) {
|
|||
|
|
// this entry is larger than anyone in the list
|
|||
|
|
// so Add it to the end.
|
|||
|
|
// =====-===============
|
|||
|
|
m_aCache.Add(pNew);
|
|||
|
|
*pOutput = pNew;
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
// cannot duplicate ClassMap,
|
|||
|
|
// delte allocated object and return false
|
|||
|
|
delete pNew;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
// return false
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return bReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CNt5Refresher::GetCacheEl
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
PRefresherCacheEl CNt5Refresher::GetCacheEl(
|
|||
|
|
CClassMapInfo *pClsMap
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
// assumes the structure is locked for access
|
|||
|
|
PRefresherCacheEl pReturn = NULL;
|
|||
|
|
PRefresherCacheEl pWorkEl;
|
|||
|
|
int i;
|
|||
|
|
int nNumElements;
|
|||
|
|
DWORD dwObjectIdToFind;
|
|||
|
|
|
|||
|
|
if (pClsMap != NULL) {
|
|||
|
|
dwObjectIdToFind = pClsMap->GetObjectId();
|
|||
|
|
nNumElements = m_aCache.Size();
|
|||
|
|
for (i = 0; i < nNumElements; i++) {
|
|||
|
|
pWorkEl = PRefresherCacheEl(m_aCache[i]);
|
|||
|
|
if (pWorkEl->m_pClassMap->GetObjectId() == dwObjectIdToFind) {
|
|||
|
|
pReturn = pWorkEl;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return pReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// RefresherCacheEl::FindInstance
|
|||
|
|
//
|
|||
|
|
// Finds an instance in the current cache element for a particular instance.
|
|||
|
|
// For this to work, the instances have to be sorted by name.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
IWbemObjectAccess *RefresherCacheEl::FindInst(
|
|||
|
|
LPWSTR pszInstName
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
// Binary search the cache.
|
|||
|
|
// ========================
|
|||
|
|
|
|||
|
|
int l = 0;
|
|||
|
|
int u = m_aInstances.Size() - 1;
|
|||
|
|
int m;
|
|||
|
|
CachedInst *pInst;
|
|||
|
|
|
|||
|
|
while (l <= u) {
|
|||
|
|
m = (l + u) / 2;
|
|||
|
|
|
|||
|
|
pInst = PCachedInst(m_aInstances[m]);
|
|||
|
|
|
|||
|
|
if (_wcsicmp(pszInstName, pInst->m_pName) < 0) {
|
|||
|
|
u = m - 1;
|
|||
|
|
} else if (_wcsicmp(pszInstName, pInst->m_pName) > 0) {
|
|||
|
|
l = m + 1;
|
|||
|
|
} else {
|
|||
|
|
// We found the instance.
|
|||
|
|
// ======================
|
|||
|
|
return pInst->m_pInst;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Not found
|
|||
|
|
// =========
|
|||
|
|
|
|||
|
|
return NULL;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// Inserts a new instance.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
BOOL RefresherCacheEl::InsertInst(IWbemObjectAccess **ppNew, LONG lNewId)
|
|||
|
|
{
|
|||
|
|
// Save the value passed in
|
|||
|
|
IWbemObjectAccess* pNew = *ppNew;
|
|||
|
|
|
|||
|
|
IWbemClassObject *pObj;
|
|||
|
|
VARIANT v;
|
|||
|
|
PCachedInst pNewInst;
|
|||
|
|
DWORD dwInstanceNameLength;
|
|||
|
|
PCachedInst pTest;
|
|||
|
|
BOOL bReturn = FALSE;
|
|||
|
|
HRESULT hRes;
|
|||
|
|
int nNumInstances;
|
|||
|
|
CBSTR cbName(cszName);
|
|||
|
|
|
|||
|
|
if( NULL == (BSTR)cbName ){
|
|||
|
|
return FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Check for singleton.
|
|||
|
|
// ====================
|
|||
|
|
if (m_pClassMap->IsSingleton()) {
|
|||
|
|
|
|||
|
|
// If we don't already have an object, use the one passed in. Otherwise
|
|||
|
|
// we will replace it.
|
|||
|
|
|
|||
|
|
if ( NULL == m_pSingleton )
|
|||
|
|
{
|
|||
|
|
m_pSingleton = pNew;
|
|||
|
|
m_pSingleton->AddRef();
|
|||
|
|
// We don't really need the id anymore
|
|||
|
|
// m_lSingletonId = lNewId;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// Now we're sneaking around by replacing *ppNew with the
|
|||
|
|
// singleton we already have. We must release *ppNew in
|
|||
|
|
// order to get away with this.
|
|||
|
|
|
|||
|
|
(*ppNew)->Release();
|
|||
|
|
|
|||
|
|
// We need to AddRef() this because *ppNew is now referencing it
|
|||
|
|
m_pSingleton->AddRef();
|
|||
|
|
*ppNew = m_pSingleton;
|
|||
|
|
pNew = m_pSingleton;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Now we will Add this instance just like any other
|
|||
|
|
|
|||
|
|
pNewInst = new CachedInst;
|
|||
|
|
// assert (pNewInst != NULL);
|
|||
|
|
|
|||
|
|
if ( pNewInst != NULL )
|
|||
|
|
{
|
|||
|
|
// For singletons, none of the other pointers
|
|||
|
|
// should matter.
|
|||
|
|
|
|||
|
|
pNewInst->m_lId = lNewId;
|
|||
|
|
pNewInst->m_pInst = pNew;
|
|||
|
|
pNewInst->m_pInst->AddRef();
|
|||
|
|
|
|||
|
|
// We are saving the name just to be safe (It will
|
|||
|
|
// really only be an "@", and I don't believe it
|
|||
|
|
// will be accessed anywhere else. I hope...)
|
|||
|
|
pNewInst->m_pName = Macro_CloneLPWSTR(L"@");
|
|||
|
|
// assert (pNewInst->m_pName != NULL);
|
|||
|
|
|
|||
|
|
if ( NULL != pNewInst->m_pName )
|
|||
|
|
{
|
|||
|
|
// We can just add this in, since any entries will all be the
|
|||
|
|
// same anyway.
|
|||
|
|
|
|||
|
|
m_aInstances.Add(pNewInst);
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
}
|
|||
|
|
else // Memory Allocation failed
|
|||
|
|
{
|
|||
|
|
bReturn = FALSE;
|
|||
|
|
SetLastError ((DWORD)WBEM_E_OUT_OF_MEMORY);
|
|||
|
|
delete(pNewInst);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
else // Memory allocation failed
|
|||
|
|
{
|
|||
|
|
bReturn = FALSE;
|
|||
|
|
SetLastError ((DWORD)WBEM_E_OUT_OF_MEMORY);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
VariantInit(&v);
|
|||
|
|
|
|||
|
|
// For multi-instance, get the instance name.
|
|||
|
|
// ==========================================
|
|||
|
|
hRes = pNew->QueryInterface(IID_IWbemClassObject, (LPVOID *) &pObj);
|
|||
|
|
assert (hRes == NO_ERROR);
|
|||
|
|
|
|||
|
|
if (hRes == NO_ERROR) {
|
|||
|
|
|
|||
|
|
hRes = pObj->Get( cbName, 0, &v, 0, 0);
|
|||
|
|
assert (hRes == NO_ERROR);
|
|||
|
|
if (hRes == NO_ERROR) {
|
|||
|
|
if (v.vt == VT_BSTR) {
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
} else {
|
|||
|
|
bReturn = FALSE;
|
|||
|
|
// the object passed in should have an instance name
|
|||
|
|
SetLastError ((DWORD)WBEM_E_INVALID_OBJECT_PATH);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
pObj->Release();
|
|||
|
|
|
|||
|
|
if (bReturn) {
|
|||
|
|
// Construct the new instance.
|
|||
|
|
// ===========================
|
|||
|
|
pNewInst = new CachedInst;
|
|||
|
|
// assert (pNewInst != NULL);
|
|||
|
|
|
|||
|
|
if (pNewInst != NULL) {
|
|||
|
|
pNewInst->m_lId = lNewId;
|
|||
|
|
pNewInst->m_pInst = pNew;
|
|||
|
|
pNewInst->m_pInst->AddRef();
|
|||
|
|
pNewInst->m_pName = Macro_CloneLPWSTR(V_BSTR(&v));
|
|||
|
|
|
|||
|
|
if (pNewInst->m_pName != NULL) {
|
|||
|
|
dwInstanceNameLength = lstrlenW (pNewInst->m_pName) + 1;
|
|||
|
|
|
|||
|
|
// parse the instance string now to save processing time later
|
|||
|
|
pNewInst->m_szParentName = new WCHAR[dwInstanceNameLength];
|
|||
|
|
|
|||
|
|
pNewInst->m_szInstanceName = new WCHAR[dwInstanceNameLength];
|
|||
|
|
|
|||
|
|
if ((pNewInst->m_szParentName != NULL) &&
|
|||
|
|
(pNewInst->m_szInstanceName != NULL)) {
|
|||
|
|
|
|||
|
|
// break the instance name into components
|
|||
|
|
bReturn = PerfHelper::ParseInstanceName (pNewInst->m_pName,
|
|||
|
|
pNewInst->m_szInstanceName,
|
|||
|
|
dwInstanceNameLength,
|
|||
|
|
pNewInst->m_szParentName,
|
|||
|
|
dwInstanceNameLength,
|
|||
|
|
&pNewInst->m_dwIndex);
|
|||
|
|
|
|||
|
|
if (bReturn) {
|
|||
|
|
bReturn = FALSE; // to prime it.
|
|||
|
|
// Now place the name in the instance cache element.
|
|||
|
|
// =================================================
|
|||
|
|
nNumInstances = m_aInstances.Size();
|
|||
|
|
for (int i = 0; i < nNumInstances; i++) {
|
|||
|
|
// see if it belongs in the list
|
|||
|
|
pTest = PCachedInst(m_aInstances[i]);
|
|||
|
|
if (_wcsicmp(V_BSTR(&v), pTest->m_pName) < 0) {
|
|||
|
|
m_aInstances.InsertAt(i, pNewInst);
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
// once it's been added,
|
|||
|
|
// there's no point in continuing
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!bReturn) {
|
|||
|
|
// this goes at the end of the list
|
|||
|
|
m_aInstances.Add(pNewInst);
|
|||
|
|
bReturn = TRUE;
|
|||
|
|
} else {
|
|||
|
|
// unable to create instance
|
|||
|
|
SetLastError ((DWORD)WBEM_E_INVALID_OBJECT_PATH);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
// clean up if there's an error
|
|||
|
|
if (!bReturn) {
|
|||
|
|
if (pNewInst->m_szParentName != NULL) {
|
|||
|
|
delete (pNewInst->m_szParentName);
|
|||
|
|
}
|
|||
|
|
if (pNewInst->m_szInstanceName != NULL) {
|
|||
|
|
delete pNewInst->m_szInstanceName;
|
|||
|
|
}
|
|||
|
|
delete (pNewInst->m_pName);
|
|||
|
|
bReturn = FALSE;
|
|||
|
|
delete (pNewInst);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
// unable to alloc memory
|
|||
|
|
bReturn = FALSE;
|
|||
|
|
SetLastError ((DWORD)WBEM_E_OUT_OF_MEMORY);
|
|||
|
|
delete (pNewInst);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
// unable to alloc memory
|
|||
|
|
bReturn = FALSE;
|
|||
|
|
SetLastError ((DWORD)WBEM_E_OUT_OF_MEMORY);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
// return FALSE
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
// return FALSE
|
|||
|
|
}
|
|||
|
|
VariantClear(&v);
|
|||
|
|
}
|
|||
|
|
return bReturn;
|
|||
|
|
}
|