4422 lines
135 KiB
C++
4422 lines
135 KiB
C++
//***************************************************************************
|
|
|
|
//
|
|
|
|
// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
|
|
//
|
|
// WBEMGLUE.CPP
|
|
//
|
|
// Purpose: Implementation of CWbemProviderGlue class
|
|
//
|
|
//***************************************************************************
|
|
|
|
#include "precomp.h"
|
|
#include <assertbreak.h>
|
|
#include <eventProvider.h>
|
|
#include <FRQueryEx.h>
|
|
#include <cnvmacros.h>
|
|
#include <BrodCast.h>
|
|
#include <cominit.h>
|
|
#include <StopWatch.h>
|
|
#include <comdef.h>
|
|
#include <SmartPtr.h>
|
|
#include <lmcons.h>
|
|
#define SECURITY_WIN32
|
|
#include <sspi.h>
|
|
#include <Secext.h>
|
|
#include "FWStrings.h"
|
|
#include "MultiPlat.h"
|
|
#include <AutoImpRevert.h>
|
|
#include <lockwrap.h>
|
|
|
|
#include <winbasep.h>
|
|
|
|
class CWbemGlueImpersonation
|
|
{
|
|
CWbemGlueImpersonation ( const CWbemGlueImpersonation& ) {}
|
|
|
|
HRESULT m_hr;
|
|
|
|
public:
|
|
|
|
CWbemGlueImpersonation () : m_hr ( E_FAIL )
|
|
{
|
|
m_hr = CWbemProviderGlue::CheckImpersonationLevel ();
|
|
}
|
|
|
|
~CWbemGlueImpersonation ()
|
|
{
|
|
if SUCCEEDED ( m_hr )
|
|
{
|
|
WbemCoRevertToSelf ();
|
|
}
|
|
}
|
|
|
|
HRESULT IsImpersonated () const
|
|
{
|
|
return m_hr;
|
|
}
|
|
};
|
|
|
|
#define GLUETIMEOUT WBEM_INFINITE //(3 * 60 * 1000)
|
|
|
|
// Used in ASSERT_BREAK to give meaningful messages
|
|
#define DEPRECATED 1
|
|
#define MEMORY_EXHAUSTED 0
|
|
#define FRAMEWORK_EXCEPTION 0
|
|
#define UNSPECIFIED_EXCEPTION 0
|
|
#define STRUCTURED_EXCEPTION 0
|
|
#define DUPLICATE_RELEASE 0
|
|
#define IMPERSONATION_REVERTED 0
|
|
#define UNNECESSARY_CWBEMPROVIDERGLUE_INSTANCE 0
|
|
|
|
// Initialize Statics
|
|
STRING2LPVOID CWbemProviderGlue::s_providersmap;
|
|
CCritSec CWbemProviderGlue::s_csFactoryMap;
|
|
PTR2PLONG CWbemProviderGlue::s_factorymap;
|
|
CCritSec CWbemProviderGlue::s_csProviderMap;
|
|
CCritSec CWbemProviderGlue::m_csStatusObject;
|
|
IWbemClassObject *CWbemProviderGlue::m_pStatusObject = NULL;
|
|
BOOL CWbemProviderGlue::s_bInitted = FALSE;
|
|
DWORD CWbemProviderGlue::s_dwPlatform = 0;
|
|
DWORD CWbemProviderGlue::s_dwMajorVersion = 0;
|
|
WCHAR CWbemProviderGlue::s_wstrCSDVersion[128] = {0};
|
|
|
|
long CWbemProviderGlue::s_lObjects = 0;
|
|
|
|
// Static Provider we use to initialize, uninitialize our static
|
|
// data. We should be able to assume at Construct/Destruct time that
|
|
// we (the DLL) are being loaded/unloaded.
|
|
// later on -- we should, but we can't. Current model is that we
|
|
// uninitialize when the last DLL that we service has called DLLLogoff,
|
|
// which had better be in response to "DllCanUnloadNow"
|
|
|
|
CWbemProviderGlue g_wbemprovider;
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::CWbemProviderGlue
|
|
//
|
|
// Class CTor. Uses static initialization functon to get static data
|
|
// ready if this is the first instance of our object.
|
|
//
|
|
// Inputs: None
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: None.
|
|
//
|
|
// Comments:
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
CWbemProviderGlue::CWbemProviderGlue()
|
|
: m_strNamespace(),
|
|
m_lRefCount(0),
|
|
m_pCount(NULL),
|
|
m_pServices(NULL)
|
|
{
|
|
Init();
|
|
}
|
|
|
|
CWbemProviderGlue::CWbemProviderGlue(PLONG pCount)
|
|
: m_strNamespace(),
|
|
m_lRefCount(0),
|
|
m_pCount(pCount),
|
|
m_pServices(NULL)
|
|
{
|
|
CWbemProviderGlue::IncrementMapCount(pCount);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::~CWbemProviderGlue
|
|
//
|
|
// Class DTor.
|
|
//
|
|
// Inputs: None
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: None.
|
|
//
|
|
// Comments:
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
CWbemProviderGlue::~CWbemProviderGlue()
|
|
{
|
|
// Note that the item we are destructing here was not added in
|
|
// the constructor, but in Initialize().
|
|
if (m_pServices)
|
|
{
|
|
m_pServices->Release();
|
|
}
|
|
|
|
if (m_pCount != NULL) // Indicates the static instance
|
|
{
|
|
if (DecrementMapCount(m_pCount) == 0)
|
|
{
|
|
FlushAll();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UnInit();
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::Init
|
|
//
|
|
// Static initialization function for initializing critical sections
|
|
// and such for making our static data thread-safe.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: None.
|
|
//
|
|
// Comments: Because we are protecting static data, we are using
|
|
// a named mutex. Construction and Destruction of object
|
|
// instances should call these functions.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
void CWbemProviderGlue::Init( void )
|
|
{
|
|
LogMessage(IDS_GLUEINIT);
|
|
|
|
if (!s_bInitted)
|
|
{
|
|
// Note that we *have* to use the ansi version at this point,
|
|
// since this is where we decide whether to use the ansi functions
|
|
// or the unicode ones.
|
|
OSVERSIONINFOA OsVersionInfoA;
|
|
|
|
OsVersionInfoA.dwOSVersionInfoSize = sizeof (OSVERSIONINFOA) ;
|
|
GetVersionExA(&OsVersionInfoA);
|
|
|
|
s_dwPlatform = OsVersionInfoA.dwPlatformId;
|
|
s_dwMajorVersion = OsVersionInfoA.dwMajorVersion;
|
|
|
|
if (OsVersionInfoA.szCSDVersion == NULL)
|
|
{
|
|
s_wstrCSDVersion[0] = L'\0';
|
|
}
|
|
else
|
|
{
|
|
bool t_ConversionFailure = false ;
|
|
WCHAR *wcsBuffer = NULL ;
|
|
ANSISTRINGTOWCS(OsVersionInfoA.szCSDVersion, wcsBuffer, t_ConversionFailure );
|
|
if ( ! t_ConversionFailure )
|
|
{
|
|
if ( wcsBuffer )
|
|
{
|
|
wcscpy(s_wstrCSDVersion, wcsBuffer);
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Should do something here since we know version is not initialised.
|
|
}
|
|
}
|
|
|
|
s_bInitted = TRUE;
|
|
}
|
|
else
|
|
{
|
|
ASSERT_BREAK(UNNECESSARY_CWBEMPROVIDERGLUE_INSTANCE);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::UnInit
|
|
//
|
|
// Static cleanup function for cleaning up critical sections
|
|
// and such for making our static data thread-safe.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: None.
|
|
//
|
|
// Comments: Because we are protecting static data, we are using
|
|
// a named mutex. Construction and Destruction of object
|
|
// instances should call these functions.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
void CWbemProviderGlue::UnInit( void )
|
|
{
|
|
LogMessage(IDS_GLUEUNINIT);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetStaticMutex
|
|
//
|
|
// Creates and returns an instance of the named mutex used to
|
|
// protect our static initialization functions.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: None.
|
|
//
|
|
// Comments: The mutex, although it is named, makes the process
|
|
// id part of the name, guaranteeing that it is still
|
|
// unique across processes.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::QueryInterface
|
|
//
|
|
// COM function called to ask us if we support a particular
|
|
// face type. If so, we addref ourselves and return the
|
|
// ourselves as an LPVOID.
|
|
//
|
|
// Inputs: REFIID riid - Interface being queried for.
|
|
//
|
|
// Outputs: LPVOID FAR* ppvObj - Interface pointer.
|
|
//
|
|
// Returns: None.
|
|
//
|
|
// Comments: The only interfaces we support are IID_IUnknown and
|
|
// IID_IWbemServices.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
STDMETHODIMP CWbemProviderGlue::QueryInterface( REFIID riid, LPVOID FAR *ppvObj )
|
|
{
|
|
LogMessage(L"CWbemProviderGlue::QueryInterface");
|
|
|
|
if (IsEqualIID(riid, IID_IUnknown))
|
|
{
|
|
*ppvObj = (IWbemServices *) this;
|
|
}
|
|
else if (IsEqualIID(riid, IID_IWbemServices))
|
|
{
|
|
*ppvObj = (IWbemServices *) this;
|
|
}
|
|
else if (IsEqualIID(riid, IID_IWbemProviderInit))
|
|
{
|
|
*ppvObj = (IWbemProviderInit *) this;
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
*ppvObj = NULL ;
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
WCHAR wcID[128];
|
|
StringFromGUID2(riid, wcID, 128);
|
|
|
|
LogMessage2(L"CWbemProviderGlue::QueryInterface - unsupported interface (%s)", wcID);
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE) ;
|
|
}
|
|
|
|
AddRef() ;
|
|
|
|
return NOERROR ;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::AddRef
|
|
//
|
|
// Increments the reference count on this object.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: ULONG - Our Reference Count.
|
|
//
|
|
// Comments: Requires that a correponding call to Release be
|
|
// performed.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG CWbemProviderGlue::AddRef( void )
|
|
{
|
|
CSetStructuredExceptionHandler t_ExceptionHandler;
|
|
|
|
try
|
|
{
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
// this will be an approximation because another thread could come through...
|
|
LogMessage2(L"CWbemProviderGlue::AddRef, count is (approx) %d", m_lRefCount +1);
|
|
};
|
|
}
|
|
catch ( ... )
|
|
{
|
|
}
|
|
|
|
// InterlockedIncrement does not necessarily return the
|
|
// correct value, only whether the value is <, =, > 0.
|
|
// However it is guaranteed threadsafe.
|
|
|
|
return InterlockedIncrement( &m_lRefCount );
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::Intialize
|
|
//
|
|
// Inputs: Many.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns:
|
|
//
|
|
// Comments: any global initializations, esp those that call CIMOM should go here.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemProviderGlue::Initialize(
|
|
/* [in] */ LPWSTR pszUser,
|
|
/* [in] */ LONG lFlags,
|
|
/* [in] */ LPWSTR pszNamespace,
|
|
/* [in] */ LPWSTR pszLocale,
|
|
/* [in] */ IWbemServices __RPC_FAR *pNamespace,
|
|
/* [in] */ IWbemContext __RPC_FAR *pCtx,
|
|
/* [in] */ IWbemProviderInitSink __RPC_FAR *pInitSink)
|
|
{
|
|
CSetStructuredExceptionHandler t_ExceptionHandler;
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
try
|
|
{
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s(%s)", IDS_GLUEINITINTERFACE, pszNamespace);
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
}
|
|
|
|
if ( (NULL != pszNamespace) && (NULL != pNamespace) )
|
|
{
|
|
try
|
|
{
|
|
// this may come back to bite me
|
|
// CIMOM promises that this will only be called on one thread, once per object
|
|
// and that no queries will be issued until after initialize is called.
|
|
// therefore - I don't need a critical section, here -
|
|
m_strNamespace = pszNamespace;
|
|
m_strNamespace.MakeUpper();
|
|
|
|
pNamespace->AddRef();
|
|
m_pServices = pNamespace;
|
|
}
|
|
catch ( CFramework_Exception e_FR )
|
|
{
|
|
ASSERT_BREAK(FRAMEWORK_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( CHeap_Exception e_HE )
|
|
{
|
|
ASSERT_BREAK(MEMORY_EXHAUSTED);
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
catch(CStructured_Exception e_SE)
|
|
{
|
|
ASSERT_BREAK(STRUCTURED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
ASSERT_BREAK(UNSPECIFIED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
|
|
if (pInitSink)
|
|
{
|
|
pInitSink->SetStatus(hr, 0);
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::Release
|
|
//
|
|
// Decrements the reference count on this object.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: ULONG - Our Reference Count.
|
|
//
|
|
// Comments: When the ref count hits zero, the object is deleted.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG CWbemProviderGlue::Release()
|
|
{
|
|
// InterlockedDecrement does not necessarily return the
|
|
// correct value, only whether the value is <, =, > 0.
|
|
// However it is guaranteed threadsafe.
|
|
|
|
// We want to hold the value locally in case two threads
|
|
// Release at the same time and one gets a final release,
|
|
// and deletes, leaving a potential window in which a thread
|
|
// deletes the object before the other returns and tries to
|
|
// reference the value from within the deleted object.
|
|
|
|
CSetStructuredExceptionHandler t_ExceptionHandler;
|
|
ULONG nRet = InterlockedDecrement( &m_lRefCount );
|
|
|
|
try
|
|
{
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage2(L"CWbemProviderGlue::Release, count is (approx) %d", m_lRefCount);
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
}
|
|
|
|
if( 0 == nRet )
|
|
{
|
|
try
|
|
{
|
|
LogMessage(IDS_GLUEREFCOUNTZERO);
|
|
}
|
|
catch ( ... )
|
|
{
|
|
}
|
|
delete this;
|
|
} else if (nRet > 0x80000000)
|
|
{
|
|
ASSERT_BREAK(DUPLICATE_RELEASE);
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::FlushAll
|
|
//
|
|
// Inputs: voidness
|
|
//
|
|
// Outputs: more voidness
|
|
//
|
|
// Returns: see above
|
|
//
|
|
// Comments: flushes caches, calls all of the provider's flushes.
|
|
// no need to flush event providers map, flush will be
|
|
// called on the provider pointer
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
void CWbemProviderGlue::FlushAll(void)
|
|
{
|
|
PROVIDERPTRS::iterator setIter;
|
|
|
|
// We DEFINITELY want to protect the Map while this is running!
|
|
LockProviderMap();
|
|
|
|
try
|
|
{
|
|
// pProvider doesn't get addref'ed, so doesn't need to be released
|
|
Provider *pProvider = NULL;
|
|
|
|
CLockWrapper lockwrap(m_csFlushPtrs);
|
|
|
|
for (setIter = m_FlushPtrs.begin(); setIter != m_FlushPtrs.end(); setIter++)
|
|
{
|
|
pProvider = (Provider*) *setIter;
|
|
if ( pProvider != NULL )
|
|
{
|
|
// If one provider poops out, try the others.
|
|
try
|
|
{
|
|
pProvider->Flush();
|
|
}
|
|
catch ( ... )
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
m_FlushPtrs.clear();
|
|
}
|
|
catch ( ... )
|
|
{
|
|
UnlockProviderMap();
|
|
throw;
|
|
}
|
|
|
|
UnlockProviderMap();
|
|
|
|
if (m_pStatusObject)
|
|
{
|
|
m_csStatusObject.Enter();
|
|
if (m_pStatusObject)
|
|
{
|
|
m_pStatusObject->Release();
|
|
m_pStatusObject = NULL;
|
|
}
|
|
m_csStatusObject.Leave();
|
|
}
|
|
}
|
|
|
|
// SetStatusObject
|
|
// sets the properties in the extended status object so that it can be returned when
|
|
// the glue layer calls SetStatus at the end of the method invocation.
|
|
// will return false if the status object has already been filled.
|
|
// (first one in wins)
|
|
bool CWbemProviderGlue::SetStatusObject(
|
|
|
|
MethodContext *pContext,
|
|
LPCWSTR pNamespace,
|
|
LPCWSTR pDescription,
|
|
HRESULT hr,
|
|
const SAFEARRAY *pPrivilegesNotHeld,/* = NULL */
|
|
const SAFEARRAY *pPrivilegesRequired/* = NULL */
|
|
)
|
|
{
|
|
bool bRet = false;
|
|
|
|
ASSERT_BREAK(pContext != NULL);
|
|
if (pContext)
|
|
{
|
|
IWbemClassObjectPtr pObj ( GetStatusObject(pContext, pNamespace), false );
|
|
|
|
if (pObj != NULL)
|
|
{
|
|
// Variant_t handles the VariantInit/VariantClear
|
|
variant_t v;
|
|
|
|
pContext->SetStatusObject(pObj);
|
|
|
|
// set hresult ("StatusCode")
|
|
v.vt = VT_I4;
|
|
v.lVal = (long)hr;
|
|
pObj->Put(IDS_STATUSCODE, 0, &v, NULL);
|
|
v.Clear();
|
|
|
|
// set description
|
|
if (pDescription)
|
|
{
|
|
v = pDescription;
|
|
|
|
if (v.bstrVal != NULL)
|
|
{
|
|
bRet = SUCCEEDED(pObj->Put(IDS_DESCRIPTION, 0, &v, NULL));
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
|
|
v.Clear();
|
|
}
|
|
|
|
// privileges properties
|
|
if (pPrivilegesNotHeld)
|
|
{
|
|
SAFEARRAY *pSafeArray = NULL;
|
|
// blithy casting away the const...
|
|
if ( SUCCEEDED ( SafeArrayCopy ((SAFEARRAY*)pPrivilegesNotHeld, &pSafeArray ) ) )
|
|
{
|
|
v.vt = VT_BSTR | VT_ARRAY;
|
|
v.parray = pSafeArray;
|
|
pObj->Put(IDS_PRIVILEGESNOTHELD, 0, &v, NULL);
|
|
v.Clear();
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
|
|
if (pPrivilegesRequired)
|
|
{
|
|
SAFEARRAY *pSafeArray = NULL;
|
|
// blithy casting away the const...
|
|
if ( SUCCEEDED ( SafeArrayCopy ((SAFEARRAY*)pPrivilegesRequired, &pSafeArray ) ) )
|
|
{
|
|
v.vt = VT_BSTR | VT_ARRAY;
|
|
v.parray = pSafeArray;
|
|
pObj->Put(IDS_PRIVILEGESREQUIRED, 0, &v, NULL);
|
|
v.Clear();
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
IWbemClassObject *CWbemProviderGlue::GetStatusObject(
|
|
|
|
MethodContext *pContext,
|
|
LPCWSTR pNamespace
|
|
)
|
|
{
|
|
ASSERT_BREAK(pContext != NULL);
|
|
IWbemClassObject *pStatusObj = NULL;
|
|
|
|
if (pContext != NULL)
|
|
{
|
|
// first time in, we cache the class object
|
|
if (!m_pStatusObject)
|
|
{
|
|
m_csStatusObject.Enter();
|
|
|
|
// check again - someone might have snuck in!
|
|
if (!m_pStatusObject)
|
|
{
|
|
IWbemServicesPtr pSrvc;
|
|
IWbemContextPtr pWbemContext (pContext->GetIWBEMContext(), false);
|
|
|
|
pSrvc.Attach ( GetNamespaceConnection( pNamespace, pContext ) ) ;
|
|
if ( pSrvc )
|
|
{
|
|
// not checking return code, error object should be NULL on error
|
|
pSrvc->GetObject( bstr_t( IDS_WIN32PRIVILEGESSTATUS ), 0, pWbemContext, &m_pStatusObject, NULL );
|
|
}
|
|
|
|
}
|
|
m_csStatusObject.Leave();
|
|
}
|
|
|
|
if (m_pStatusObject)
|
|
m_pStatusObject->SpawnInstance(0, &pStatusObj);
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage(L"NULL parameter to GetStatusObject");
|
|
}
|
|
|
|
return pStatusObj;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::ExecQueryAsync
|
|
//
|
|
// Place holder for the ExecQuery function.
|
|
//
|
|
// Inputs: const BSTR QueryFormat - Query Format String
|
|
// const BSTR Query - The actual query
|
|
// long lFlags - Additional flags.
|
|
// IWbemContext __RPC_FAR *pCtx - Context we were called in.
|
|
// IWbemObjectSink FAR *pResponseHandler - Response Handler
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: ULONG - Our Reference Count.
|
|
//
|
|
// Comments:
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CWbemProviderGlue::ExecQueryAsync(
|
|
|
|
const BSTR QueryFormat,
|
|
const BSTR Query,
|
|
long lFlags,
|
|
IWbemContext __RPC_FAR *pCtx,
|
|
IWbemObjectSink FAR *pResponseHandler
|
|
)
|
|
{
|
|
// make sure we don't disappear while running
|
|
AddRef();
|
|
|
|
CSetStructuredExceptionHandler t_ExceptionHandler;
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
StopWatch stopWatch(CHString(IDS_EXECQUERY) + CHString(Query));
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
IWbemClassObjectPtr pStatusObject;
|
|
|
|
try
|
|
{
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s%s", IDS_EXECQUERY, Query);
|
|
}
|
|
|
|
// Now create an External Method Context object and go to town
|
|
ExternalMethodContextPtr pContext (new ExternalMethodContext( pResponseHandler, pCtx, this ), false);
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
pContext->pStopWatch = &stopWatch;
|
|
#endif
|
|
|
|
if (pContext != NULL)
|
|
{
|
|
CFrameworkQueryEx CQuery;
|
|
// hr = CQuery.InitEx(QueryFormat, Query, lFlags, m_strNamespace);
|
|
hr = CQuery.Init(QueryFormat, Query, lFlags, m_strNamespace);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Find the class name for the query
|
|
bstr_t bstrClass (CQuery.GetQueryClassName(), false);
|
|
if ((WCHAR *)bstrClass != NULL)
|
|
{
|
|
// Search for the class name in our map of providers, we know which
|
|
// namespace we are when we get constructed.
|
|
// pProvider doesn't get addref'ed, so doesn't need to be released.
|
|
Provider *pProvider = SearchMapForProvider( bstrClass, m_strNamespace );
|
|
if ( NULL != pProvider )
|
|
{
|
|
|
|
// Initialize the CQuery.m_keysonly variable. Note that we CAN'T do this as part
|
|
// of Init, because we need the pProvider pointer. And we can do the init
|
|
// down here, because we need the bstrClass that we get from Init. And we can't
|
|
// do this as part of CQuery.KeysOnly because you can't get the IWbemClassObject
|
|
// from there.
|
|
IWbemClassObjectPtr IClass(pProvider->GetClassObjectInterface(pContext), false);
|
|
if (IClass != NULL)
|
|
{
|
|
CQuery.Init2(IClass);
|
|
|
|
// Impersonate connected user
|
|
CWbemGlueImpersonation impersonate;
|
|
if SUCCEEDED ( hr = impersonate.IsImpersonated () )
|
|
{
|
|
// Set up to call FlushAll
|
|
AddFlushPtr(pProvider);
|
|
|
|
WCHAR wszName[UNLEN + DNLEN + 1 + 1] = {0};
|
|
WCHAR wszName2[UNLEN + DNLEN + 1 + 1] = {0}; // domain + \ + name + null
|
|
DWORD dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName, &dwLen);
|
|
|
|
// Everything is in place, run the query
|
|
hr = pProvider->ExecuteQuery( pContext, CQuery, lFlags );
|
|
|
|
dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName2, &dwLen);
|
|
|
|
if (wcscmp(wszName, wszName2) != 0)
|
|
{
|
|
ASSERT_BREAK(IMPERSONATION_REVERTED);
|
|
LogErrorMessage4(L"Warning! User name at exit (%s) != user name at entry (%s) for %s",
|
|
wszName2, wszName, Query);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we don't know WHY we couldn't get the interface,
|
|
// generic error it is...
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage4(L"%s (%s:%s)", IDS_PROVIDERNOTFOUND, (LPCWSTR)m_strNamespace, (LPCWSTR)bstrClass);
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage(IDS_INVALIDCLASSNAME);
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
}
|
|
}
|
|
|
|
pStatusObject.Attach(pContext->GetStatusObject());
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
LogMessage3(L"%s%s - Succeeded", IDS_EXECQUERY, Query);
|
|
else
|
|
LogMessage4(L"%s%s - FAILED (%x)", IDS_EXECQUERY, Query, hr);
|
|
}
|
|
}
|
|
catch ( CFramework_Exception e_FR )
|
|
{
|
|
ASSERT_BREAK(FRAMEWORK_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( CHeap_Exception e_HE )
|
|
{
|
|
ASSERT_BREAK(MEMORY_EXHAUSTED);
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
catch(CStructured_Exception e_SE)
|
|
{
|
|
ASSERT_BREAK(STRUCTURED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
ASSERT_BREAK(UNSPECIFIED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
|
|
// We must call SetStatus so CIMOM doesn't lose any threads.
|
|
if ((hr != WBEM_E_INVALID_CLASS) && (hr != WBEM_E_UNSUPPORTED_PARAMETER))
|
|
{
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::WinMgmtTimer);
|
|
#endif
|
|
pResponseHandler->SetStatus( 0, hr, NULL, pStatusObject);
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
Release();
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Stop();
|
|
stopWatch.LogResults();
|
|
#endif
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::CreateInstanceEnumAsync
|
|
//
|
|
// Locates the provider for the specified class name and
|
|
// calls its CreateInstanceEnum function.
|
|
//
|
|
// Inputs: const BSTR Class - Name of provider
|
|
// long lFlags - Enumeration flags.
|
|
// IWbemContext __RPC_FAR *pCtxt - Context pointer
|
|
// IWbemObjectSink __RPC_FAR *pResponseHandler - Response
|
|
// handler.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: SCCODE - COM Status.
|
|
//
|
|
// Comments: None.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CWbemProviderGlue::CreateInstanceEnumAsync(
|
|
|
|
const BSTR a_bstrClass,
|
|
long lFlags,
|
|
IWbemContext __RPC_FAR *pCtx,
|
|
IWbemObjectSink __RPC_FAR *pResponseHandler
|
|
)
|
|
{
|
|
// make sure we don't disappear while running
|
|
AddRef();
|
|
|
|
CSetStructuredExceptionHandler t_ExceptionHandler;
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
StopWatch stopWatch(CHString(IDS_CREATEINSTANCEENUM) + CHString(Class));
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
|
|
HRESULT hr = WBEM_E_INVALID_CLASS;
|
|
IWbemClassObjectPtr pStatusObject;
|
|
bool bSendStatus = true;
|
|
|
|
try
|
|
{
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s%s", IDS_CREATEINSTANCEENUM, a_bstrClass);
|
|
}
|
|
|
|
// Check for per-property gets
|
|
CFrameworkQueryEx CQuery;
|
|
hr = CQuery.Init(NULL, pCtx, a_bstrClass, m_strNamespace);
|
|
|
|
// Note that we AREN'T calling Init2, which means if they specified "__RELPATH"
|
|
// as their property, we won't expand that out to the key names. However, since
|
|
// we are going to call ExecQuery, and it reprocesses the query and DOES call
|
|
// Init2, this isn't an issue.
|
|
// CQuery.Init2(pWbemClassObject);
|
|
|
|
// If they are doing per-property gets, then turn this into a query.
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (CQuery.AllPropertiesAreRequired())
|
|
{
|
|
// Search for the class name in our map of providers, we know which
|
|
// namespace we are when we get constructed.
|
|
// pProvider doesn't get addref'ed, so no release necessary
|
|
Provider *pProvider = SearchMapForProvider( a_bstrClass, m_strNamespace );
|
|
|
|
if ( NULL != pProvider )
|
|
{
|
|
// Now create an External Method Context object and go to town
|
|
ExternalMethodContextPtr pContext (new ExternalMethodContext( pResponseHandler, pCtx, this ), false);
|
|
|
|
if ( NULL != pContext )
|
|
{
|
|
CWbemGlueImpersonation impersonate;
|
|
if SUCCEEDED ( hr = impersonate.IsImpersonated () )
|
|
{
|
|
// Set up to call FlushAll
|
|
AddFlushPtr(pProvider);
|
|
|
|
WCHAR wszName[UNLEN + DNLEN + 1 + 1] = {0};
|
|
WCHAR wszName2[UNLEN + DNLEN + 1 + 1] = {0}; // domain + \ + name + null
|
|
DWORD dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName, &dwLen);
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
pContext->pStopWatch = &stopWatch;
|
|
#endif
|
|
hr = pProvider->CreateInstanceEnum( pContext, lFlags );
|
|
|
|
dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName2, &dwLen);
|
|
|
|
if (wcscmp(wszName, wszName2) != 0)
|
|
{
|
|
ASSERT_BREAK(IMPERSONATION_REVERTED);
|
|
LogErrorMessage4(L"Warning! User name at exit (%s) != user name at entry (%s) for %s",
|
|
wszName2, wszName, a_bstrClass);
|
|
}
|
|
}
|
|
pStatusObject.Attach(pContext->GetStatusObject());
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage4(L"%s (%s:%s)", IDS_PROVIDERNOTFOUND, (LPCWSTR)m_strNamespace, a_bstrClass);
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
bSendStatus = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bstr_t bstrtQuery = CQuery.GetQuery();
|
|
|
|
hr =
|
|
ExecQueryAsync(
|
|
L"WQL",
|
|
bstrtQuery,
|
|
lFlags,
|
|
pCtx,
|
|
pResponseHandler);
|
|
|
|
// Since execquery sent whatever status is necessary
|
|
bSendStatus = false;
|
|
}
|
|
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
LogMessage3(L"%s%s - Succeeded", IDS_CREATEINSTANCEENUM, a_bstrClass);
|
|
else
|
|
LogMessage4(L"%s%s - FAILED (%x)", IDS_CREATEINSTANCEENUM, a_bstrClass, hr);
|
|
}
|
|
}
|
|
|
|
catch ( CFramework_Exception e_FR )
|
|
{
|
|
ASSERT_BREAK(FRAMEWORK_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( CHeap_Exception e_HE )
|
|
{
|
|
ASSERT_BREAK(MEMORY_EXHAUSTED);
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
catch(CStructured_Exception e_SE)
|
|
{
|
|
ASSERT_BREAK(STRUCTURED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
ASSERT_BREAK(UNSPECIFIED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
|
|
if ((hr != WBEM_E_INVALID_CLASS) && (hr != WBEM_E_UNSUPPORTED_PARAMETER) && bSendStatus)
|
|
{
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::WinMgmtTimer);
|
|
#endif
|
|
|
|
pResponseHandler->SetStatus( 0, hr, NULL, pStatusObject );
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
Release();
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Stop();
|
|
stopWatch.LogResults();
|
|
#endif
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetObjectAsync
|
|
//
|
|
// Parses the supplied object path and hands the request off
|
|
// to the appropriate provider.
|
|
//
|
|
// Inputs: const BSTR ObjPath - Object Path containing
|
|
// keys to required object.
|
|
// long lFlags - Get Object flags.
|
|
// IWbemContext __RPC_FAR *pCtxt - Context pointer
|
|
// IWbemObjectSink __RPC_FAR *pResponseHandler - Response
|
|
// handler.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: SCCODE - COM Status.
|
|
//
|
|
// Comments: None.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CWbemProviderGlue::GetObjectAsync(
|
|
|
|
const BSTR ObjectPath,
|
|
long lFlags,
|
|
IWbemContext __RPC_FAR *pCtx,
|
|
IWbemObjectSink __RPC_FAR *pResponseHandler
|
|
)
|
|
{
|
|
// make sure we don't disappear while running
|
|
AddRef();
|
|
|
|
CSetStructuredExceptionHandler t_ExceptionHandler;
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
StopWatch stopWatch(CHString(IDS_GETOBJECTASYNC) + CHString(ObjectPath));
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
bool bLocalError = false;
|
|
IWbemClassObjectPtr pStatusObject;
|
|
ParsedObjectPath *pParsedPath = NULL;
|
|
CObjectPathParser objpathParser;
|
|
|
|
try
|
|
{
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s%s", IDS_GETOBJECTASYNC, ObjectPath);
|
|
}
|
|
|
|
// Parse the object path passed to us by CIMOM
|
|
// ==========================================
|
|
int nStatus = objpathParser.Parse( ObjectPath, &pParsedPath );
|
|
|
|
if ( 0 == nStatus )
|
|
{
|
|
|
|
// Now try to find the provider based on the class name
|
|
// pProvider doesn't get addref'ed, so no release necessary
|
|
Provider *pProvider = SearchMapForProvider( pParsedPath->m_pClass, m_strNamespace );
|
|
|
|
// If we got a provider, let it handle itself like a grown-up provider
|
|
// should.
|
|
|
|
if ( NULL != pProvider )
|
|
{
|
|
// Now create an External Method Context object and go to town
|
|
|
|
ExternalMethodContextPtr pContext (new ExternalMethodContext( pResponseHandler, pCtx, this ), false);
|
|
|
|
if ( NULL != pContext )
|
|
{
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
pContext->pStopWatch = &stopWatch;
|
|
#endif
|
|
CWbemGlueImpersonation impersonate;
|
|
if SUCCEEDED ( hr = impersonate.IsImpersonated () )
|
|
{
|
|
// Set up to call FlushAll
|
|
AddFlushPtr(pProvider);
|
|
|
|
WCHAR wszName[UNLEN + DNLEN + 1 + 1] = {0};
|
|
WCHAR wszName2[UNLEN + DNLEN + 1 + 1] = {0}; // domain + \ + name + null
|
|
DWORD dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName, &dwLen);
|
|
|
|
hr = pProvider->GetObject( pParsedPath, pContext, lFlags );
|
|
dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName2, &dwLen);
|
|
|
|
if (wcscmp(wszName, wszName2) != 0)
|
|
{
|
|
ASSERT_BREAK(IMPERSONATION_REVERTED);
|
|
LogErrorMessage4(L"Warning! User name at exit (%s) != user name at entry (%s) for %s",
|
|
wszName2, wszName, ObjectPath);
|
|
}
|
|
}
|
|
|
|
pStatusObject.Attach(pContext->GetStatusObject());
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage4(L"%s (%s:%s)", IDS_PROVIDERNOTFOUND, (LPCWSTR)m_strNamespace, pParsedPath->m_pClass);
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
bLocalError = true;
|
|
}
|
|
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
LogMessage3(L"%s%s - Succeeded", IDS_GETOBJECTASYNC, ObjectPath);
|
|
else
|
|
LogMessage4(L"%s%s - FAILED (%x)", IDS_GETOBJECTASYNC, ObjectPath, hr);
|
|
}
|
|
|
|
}
|
|
catch ( CFramework_Exception e_FR )
|
|
{
|
|
ASSERT_BREAK(FRAMEWORK_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( CHeap_Exception e_HE )
|
|
{
|
|
ASSERT_BREAK(MEMORY_EXHAUSTED);
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
catch(CStructured_Exception e_SE)
|
|
{
|
|
ASSERT_BREAK(STRUCTURED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
ASSERT_BREAK(UNSPECIFIED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
|
|
if ((hr != WBEM_E_INVALID_CLASS) && (hr != WBEM_E_UNSUPPORTED_PARAMETER) && !bLocalError)
|
|
{
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::WinMgmtTimer);
|
|
#endif
|
|
pResponseHandler->SetStatus( 0, hr, NULL, pStatusObject );
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
// Clean up the Parsed Path
|
|
if (pParsedPath)
|
|
{
|
|
objpathParser.Free( pParsedPath );
|
|
}
|
|
|
|
Release();
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Stop();
|
|
stopWatch.LogResults();
|
|
#endif
|
|
return hr;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::PutInstanceAsync
|
|
//
|
|
// Locates the provider for the specified class name and
|
|
// calls its CreateInstanceEnum function.
|
|
//
|
|
// Inputs: IWbemClassObject __RPC_FAR *pInst - Instance whose
|
|
// values to use.
|
|
// long lFlags - PutInstance flags.
|
|
// IWbemContext __RPC_FAR *pCtxt - Context pointer
|
|
// IWbemObjectSink __RPC_FAR *pResponseHandler - Response
|
|
// handler.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: SCCODE - COM Status.
|
|
//
|
|
// Comments: None.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CWbemProviderGlue::PutInstanceAsync(
|
|
|
|
IWbemClassObject __RPC_FAR *pInst,
|
|
long lFlags,
|
|
IWbemContext __RPC_FAR *pCtx,
|
|
IWbemObjectSink __RPC_FAR *pResponseHandler
|
|
)
|
|
{
|
|
// make sure we don't disappear while running
|
|
AddRef();
|
|
|
|
CSetStructuredExceptionHandler t_ExceptionHandler;
|
|
|
|
HRESULT hr = WBEM_E_INVALID_CLASS;
|
|
variant_t vClass;
|
|
bool bLocalError = false;
|
|
IWbemClassObjectPtr pStatusObject;
|
|
|
|
try
|
|
{
|
|
// Set up to get the class name of the instance being passed to us
|
|
// ask the framework if it has this class registered for support
|
|
// ===============================================================
|
|
|
|
// Get the class name
|
|
pInst->Get( IDS_CLASS, 0, &vClass, NULL, NULL );
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s%s", IDS_PUTINSTANCEASYNC, vClass.bstrVal);
|
|
}
|
|
|
|
// pProvider doesn't get addref'ed, so no release necessary
|
|
Provider *pProvider = SearchMapForProvider( vClass.bstrVal, m_strNamespace );
|
|
|
|
// If we got a provider, let it handle itself like a grown-up provider
|
|
// should.
|
|
if ( NULL != pProvider )
|
|
{
|
|
// Now create an External Method Context object and go to town
|
|
ExternalMethodContextPtr pContext (new ExternalMethodContext( pResponseHandler, pCtx, this ), false);
|
|
|
|
if ( NULL != pContext )
|
|
{
|
|
IWbemClassObjectPtr pInstPostProcess;
|
|
if (SUCCEEDED(hr = PreProcessPutInstanceParms(pInst, &pInstPostProcess, pCtx)))
|
|
{
|
|
CWbemGlueImpersonation impersonate;
|
|
if SUCCEEDED ( hr = impersonate.IsImpersonated () )
|
|
{
|
|
// Set up to call FlushAll
|
|
AddFlushPtr(pProvider);
|
|
|
|
WCHAR wszName[UNLEN + DNLEN + 1 + 1] = {0};
|
|
WCHAR wszName2[UNLEN + DNLEN + 1 + 1] = {0}; // domain + \ + name + null
|
|
DWORD dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName, &dwLen);
|
|
|
|
hr = pProvider->PutInstance( pInstPostProcess, lFlags, pContext );
|
|
|
|
dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName2, &dwLen);
|
|
|
|
if (wcscmp(wszName, wszName2) != 0)
|
|
{
|
|
ASSERT_BREAK(IMPERSONATION_REVERTED);
|
|
LogErrorMessage4(L"Warning! User name at exit (%s) != user name at entry (%s) for %s",
|
|
wszName2, wszName, vClass.bstrVal);
|
|
}
|
|
}
|
|
}
|
|
pStatusObject.Attach(pContext->GetStatusObject());
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage4(L"%s (%s:%s)", IDS_PROVIDERNOTFOUND, (LPCWSTR)m_strNamespace, vClass.bstrVal);
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
bLocalError = true;
|
|
}
|
|
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
LogMessage3(L"%s%s - Succeeded", IDS_PUTINSTANCEASYNC, vClass.bstrVal);
|
|
else
|
|
LogMessage4(L"%s%s - FAILED (%x)", IDS_PUTINSTANCEASYNC, vClass.bstrVal, hr);
|
|
}
|
|
}
|
|
|
|
catch ( CFramework_Exception e_FR )
|
|
{
|
|
ASSERT_BREAK(FRAMEWORK_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( CHeap_Exception e_HE )
|
|
{
|
|
ASSERT_BREAK(MEMORY_EXHAUSTED);
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
catch(CStructured_Exception e_SE)
|
|
{
|
|
ASSERT_BREAK(STRUCTURED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
ASSERT_BREAK(UNSPECIFIED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
|
|
if ((hr != WBEM_E_INVALID_CLASS) && (hr != WBEM_E_UNSUPPORTED_PARAMETER) && !bLocalError)
|
|
{
|
|
pResponseHandler->SetStatus( 0, hr, NULL, pStatusObject );
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
Release();
|
|
return hr;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::PreProcessPutInstanceParms()
|
|
//
|
|
// IF __PUT_EXT_PROPERTIES is specified, will parse out the intended properties
|
|
// and set to NULL those props that are not explicitly being put.
|
|
//
|
|
// Inputs: [IN] IWbemClassObject __RPC_FAR *pInstIn - Instance whose values to use.
|
|
// [OUT] IWbemClassObject __RPC_FAR **pInstOut - processed instance
|
|
// IWbemContext __RPC_FAR *pCtxt - Context pointer
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: WBEM_S_NO_ERROR if the only extension specified is __PUT_EXT_PROPERTIES
|
|
// or if no extensions are specified
|
|
// WBEM_E_UNSUPPORTED_PUT_EXTENSION if any other flag is set.
|
|
// WBEM_E_SEVERE_SCREWUP if some other darn thing happened.
|
|
//
|
|
// Comments: You may get a different IWbemObject out than you put in
|
|
// it's your responsibility to release it.
|
|
// On error - pInstOut is undefined.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemProviderGlue::PreProcessPutInstanceParms(
|
|
|
|
IWbemClassObject __RPC_FAR *pInstIn,
|
|
IWbemClassObject __RPC_FAR **pInstOut,
|
|
IWbemContext __RPC_FAR *pCtx
|
|
)
|
|
{
|
|
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
// Variant_t handles the VariantInit/VariantClear
|
|
variant_t vValue;
|
|
|
|
if (
|
|
pCtx != NULL &&
|
|
SUCCEEDED(hr = pCtx->GetValue( L"__PUT_EXTENSIONS", 0, &vValue)) &&
|
|
V_VT(&vValue) == VT_BOOL &&
|
|
V_BOOL(&vValue) == VARIANT_TRUE
|
|
)
|
|
{
|
|
// easy checks first, are there unsupported parms?
|
|
vValue.Clear();
|
|
if (SUCCEEDED(hr = pCtx->GetValue( L"__PUT_EXT_STRICT_NULLS", 0, &vValue))
|
|
&& (V_VT(&vValue) == VT_BOOL)
|
|
&& (V_BOOL(&vValue) == VARIANT_TRUE))
|
|
hr = WBEM_E_UNSUPPORTED_PUT_EXTENSION;
|
|
else
|
|
{
|
|
vValue.Clear();
|
|
if (SUCCEEDED(hr = pCtx->GetValue( L"__PUT_EXT_ATOMIC", 0, &vValue))
|
|
&& (V_VT(&vValue) == VT_BOOL)
|
|
&& (V_BOOL(&vValue) == VARIANT_TRUE))
|
|
hr = WBEM_E_UNSUPPORTED_PUT_EXTENSION;
|
|
}
|
|
|
|
vValue.Clear();
|
|
if ((SUCCEEDED(hr) || (hr != WBEM_E_UNSUPPORTED_PUT_EXTENSION))
|
|
&& SUCCEEDED(hr = pCtx->GetValue( L"__PUT_EXT_PROPERTIES", 0, &vValue)))
|
|
{
|
|
if (V_VT(&vValue) == (VT_BSTR|VT_ARRAY))
|
|
hr = NullOutUnsetProperties(pInstIn, pInstOut, vValue);
|
|
else
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
else if (hr == WBEM_E_NOT_FOUND)
|
|
{
|
|
// well, if we've never heard of it, it MUST be wrong...
|
|
hr = WBEM_E_UNSUPPORTED_PUT_EXTENSION;
|
|
}
|
|
}
|
|
else if (hr == WBEM_E_NOT_FOUND)
|
|
{
|
|
// no extensions - no problems.
|
|
// out interface is same as in interface
|
|
hr = WBEM_S_NO_ERROR;
|
|
*pInstOut = pInstIn;
|
|
(*pInstOut)->AddRef();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::NullOutUnsetProperties
|
|
//
|
|
// returns a copy of the input class, any properties whose names are listed
|
|
// in the variant are set to NULL in the output class
|
|
//
|
|
//
|
|
// Inputs: IWbemClassObject __RPC_FAR *pInst - Instance whose
|
|
// values to NULL
|
|
// VARIANT contains names to not NULL out.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: the ubiquitous HRESULT
|
|
//
|
|
// Comments: Assumes you've done your homework and the Variant
|
|
// is a BSTR Array containing property names.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemProviderGlue::NullOutUnsetProperties(
|
|
|
|
IWbemClassObject __RPC_FAR *pInstIn,
|
|
IWbemClassObject __RPC_FAR **pInstOut,
|
|
const VARIANT& vValue
|
|
)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR;
|
|
|
|
// get ourselves a copy to work with
|
|
CInstancePtr pInstance;
|
|
|
|
// Variant_t handles the VariantInit/VariantClear
|
|
variant_t vName;
|
|
variant_t vNameSpace;
|
|
|
|
hRes = pInstIn->Get(IDS_CLASS, 0, &vName, NULL, NULL);
|
|
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
hRes = pInstIn->Get(L"__NAMESPACE", 0, &vNameSpace, NULL, NULL);
|
|
}
|
|
|
|
if (SUCCEEDED(hRes) && SUCCEEDED( hRes = GetEmptyInstance(vName.bstrVal, &pInstance, vNameSpace.bstrVal)))
|
|
{
|
|
// and off we go...
|
|
SAFEARRAY *pNames = vValue.parray;
|
|
long nBiggestName;
|
|
if (SUCCEEDED(hRes = SafeArrayGetUBound(pNames, 1, &nBiggestName)))
|
|
{
|
|
BSTR t_bstrName = NULL ;
|
|
*pInstOut = pInstance->GetClassObjectInterface();
|
|
|
|
variant_t value;
|
|
|
|
// wander through the names, for every one we find
|
|
// copy the property value to the out pointer
|
|
for (long i = 0; i <= nBiggestName; i++)
|
|
{
|
|
SafeArrayGetElement(pNames, &i, t_bstrName ) ;
|
|
try
|
|
{
|
|
pInstIn->Get( t_bstrName, 0, &value, NULL, NULL);
|
|
(*pInstOut)->Put( t_bstrName, 0, &value, 0);
|
|
}
|
|
catch( ... )
|
|
{
|
|
SysFreeString( t_bstrName ) ;
|
|
throw ;
|
|
}
|
|
SysFreeString( t_bstrName ) ;
|
|
}
|
|
|
|
// and, oh what the heck - let's copy the keys, too...
|
|
SAFEARRAY *pKeyNames = NULL;
|
|
if (SUCCEEDED(hRes = pInstIn->GetNames(NULL, WBEM_FLAG_KEYS_ONLY, NULL, &pKeyNames)))
|
|
{
|
|
try
|
|
{
|
|
SafeArrayGetUBound(pKeyNames, 1, &nBiggestName);
|
|
for (i = 0; i <= nBiggestName; i++)
|
|
{
|
|
try
|
|
{
|
|
SafeArrayGetElement( pKeyNames, &i, t_bstrName );
|
|
pInstIn->Get( t_bstrName, 0, &value, NULL, NULL );
|
|
(*pInstOut)->Put( t_bstrName, 0, &value, 0 );
|
|
}
|
|
catch( ... )
|
|
{
|
|
SysFreeString( t_bstrName ) ;
|
|
throw ;
|
|
}
|
|
SysFreeString( t_bstrName ) ;
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
SafeArrayDestroy(pKeyNames);
|
|
throw ;
|
|
}
|
|
|
|
SafeArrayDestroy(pKeyNames);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// failed to get array upper bound!
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
return hRes;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::DeleteInstanceAsync
|
|
//
|
|
// Locates the provider for the specified class name and
|
|
// calls its DeleteInstance function.
|
|
//
|
|
// Inputs: IWbemClassObject __RPC_FAR *pInst - Instance whose
|
|
// values to use.
|
|
// long lFlags - PutInstance flags.
|
|
// IWbemContext __RPC_FAR *pCtxt - Context pointer
|
|
// IWbemObjectSink __RPC_FAR *pResponseHandler - Response
|
|
// handler.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: SCCODE - COM Status.
|
|
//
|
|
// Comments: None.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemProviderGlue::DeleteInstanceAsync(
|
|
|
|
const BSTR ObjectPath,
|
|
long lFlags,
|
|
IWbemContext __RPC_FAR *pCtx,
|
|
IWbemObjectSink __RPC_FAR *pResponseHandler
|
|
)
|
|
{
|
|
// make sure we don't disappear while running
|
|
AddRef();
|
|
|
|
CSetStructuredExceptionHandler t_ExceptionHandler;
|
|
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
bool bLocalError = false;
|
|
IWbemClassObjectPtr pStatusObject;
|
|
|
|
ParsedObjectPath *pParsedPath = NULL;
|
|
CObjectPathParser objpathParser;
|
|
|
|
try
|
|
{
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s%s", IDS_DELETEINSTANCEASYNC, ObjectPath);
|
|
}
|
|
|
|
// Parse the object path passed to us by CIMOM
|
|
// ==========================================
|
|
int nStatus = objpathParser.Parse( ObjectPath, &pParsedPath );
|
|
|
|
if ( 0 == nStatus )
|
|
{
|
|
// Now try to find the provider based on the class name
|
|
// pProvider doesn't get addref'ed, so no release necessary
|
|
Provider *pProvider = SearchMapForProvider( pParsedPath->m_pClass, m_strNamespace );
|
|
|
|
// If we got a provider, let it handle itself like a grown-up provider
|
|
// should.
|
|
|
|
if ( NULL != pProvider )
|
|
{
|
|
// Now create an External Method Context object and go to town
|
|
|
|
ExternalMethodContextPtr pContext (new ExternalMethodContext( pResponseHandler, pCtx, this ), false);
|
|
|
|
if ( NULL != pContext )
|
|
{
|
|
CWbemGlueImpersonation impersonate;
|
|
if SUCCEEDED ( hr = impersonate.IsImpersonated () )
|
|
{
|
|
// Set up to call FlushAll
|
|
AddFlushPtr(pProvider);
|
|
|
|
WCHAR wszName[UNLEN + DNLEN + 1 + 1] = {0};
|
|
WCHAR wszName2[UNLEN + DNLEN + 1 + 1] = {0}; // domain + \ + name + null
|
|
DWORD dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName, &dwLen);
|
|
|
|
hr = pProvider->DeleteInstance( pParsedPath, lFlags, pContext );
|
|
|
|
dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName2, &dwLen);
|
|
|
|
if (wcscmp(wszName, wszName2) != 0)
|
|
{
|
|
ASSERT_BREAK(IMPERSONATION_REVERTED);
|
|
LogErrorMessage4(L"Warning! User name at exit (%s) != user name at entry (%s) for %s",
|
|
wszName2, wszName, ObjectPath);
|
|
}
|
|
}
|
|
pStatusObject.Attach(pContext->GetStatusObject());
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
LogErrorMessage4(L"%s (%s:%s)", IDS_PROVIDERNOTFOUND, (LPCWSTR)m_strNamespace, pParsedPath->m_pClass);
|
|
bLocalError = true;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage3(L"%s (%s)", IDS_COULDNOTPARSE, ObjectPath);
|
|
bLocalError = true;
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
LogMessage3(L"%s%s - Succeeded", IDS_DELETEINSTANCEASYNC, ObjectPath);
|
|
else
|
|
LogMessage4(L"%s%s - FAILED (%x)", IDS_DELETEINSTANCEASYNC, ObjectPath, hr);
|
|
}
|
|
}
|
|
|
|
catch ( CFramework_Exception e_FR )
|
|
{
|
|
ASSERT_BREAK(FRAMEWORK_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( CHeap_Exception e_HE )
|
|
{
|
|
ASSERT_BREAK(MEMORY_EXHAUSTED);
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
catch(CStructured_Exception e_SE)
|
|
{
|
|
ASSERT_BREAK(STRUCTURED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
ASSERT_BREAK(UNSPECIFIED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
|
|
if ((hr != WBEM_E_INVALID_CLASS) && (hr != WBEM_E_UNSUPPORTED_PARAMETER) && !bLocalError)
|
|
{
|
|
pResponseHandler->SetStatus( 0, hr, NULL, pStatusObject);
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
// Clean up the Parsed Path
|
|
if (pParsedPath)
|
|
{
|
|
objpathParser.Free( pParsedPath );
|
|
}
|
|
|
|
Release();
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::ExecMethodAsync
|
|
//
|
|
// Locates the provider for the specified class name and
|
|
// calls its ExecMethod function.
|
|
//
|
|
// Inputs:
|
|
// const BSTR ObjectPath, - Object path on which to execute the method
|
|
// const BSTR MethodName, - Name of the method to execute
|
|
// long lFlags, - Any flags
|
|
// IWbemContext __RPC_FAR *pCtx,
|
|
// IWbemClassObject __RPC_FAR *pInParams, - Pointer to IWbemClassObject
|
|
// that contains parms
|
|
// IWbemObjectSink __RPC_FAR *pResponseHandler)
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: SCCODE - COM Status.
|
|
//
|
|
// Comments: None.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CWbemProviderGlue::ExecMethodAsync(
|
|
|
|
const BSTR ObjectPath,
|
|
const BSTR MethodName,
|
|
long lFlags,
|
|
IWbemContext __RPC_FAR *pCtx,
|
|
IWbemClassObject __RPC_FAR *pInParams,
|
|
IWbemObjectSink __RPC_FAR *pResponseHandler
|
|
)
|
|
{
|
|
// make sure we don't disappear while running
|
|
AddRef();
|
|
|
|
CSetStructuredExceptionHandler t_ExceptionHandler;
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
StopWatch stopWatch(CHString(IDS_EXECMETHODASYNC) + CHString(ObjectPath) + CHString(MethodName));
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
bool bLocalError = false;
|
|
IWbemClassObjectPtr pStatusObject;
|
|
|
|
ParsedObjectPath *pParsedPath = NULL;
|
|
CObjectPathParser objpathParser;
|
|
|
|
try
|
|
{
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage4(L"%s%s.%s", IDS_EXECMETHODASYNC, ObjectPath, MethodName);
|
|
}
|
|
|
|
// Parse the object path passed to us by CIMOM
|
|
// ==========================================
|
|
int nStatus = objpathParser.Parse( ObjectPath, &pParsedPath );
|
|
|
|
if ( 0 == nStatus )
|
|
{
|
|
// Now try to find the provider based on the class name
|
|
// pProvider doesn't get addref'ed, so no release necessary
|
|
Provider *pProvider = SearchMapForProvider( pParsedPath->m_pClass, m_strNamespace );
|
|
|
|
// If we got a provider, let it handle itself like a grown-up provider
|
|
// should.
|
|
|
|
if ( NULL != pProvider )
|
|
{
|
|
IWbemClassObjectPtr pOutClass;
|
|
IWbemClassObjectPtr pOutParams;
|
|
CInstancePtr COutParam;
|
|
CInstancePtr CInParam;
|
|
hr = WBEM_S_NO_ERROR;
|
|
|
|
// Now create an External Method Context object and go to town
|
|
ExternalMethodContextPtr pContext (new ExternalMethodContext( pResponseHandler, pCtx, this ), false);
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
pContext->pStopWatch = &stopWatch;
|
|
#endif
|
|
|
|
// Check for out of memory
|
|
if (NULL == pContext)
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
|
|
// add check to ensure that we do not call a static method
|
|
// on an instance of a class.
|
|
if (SUCCEEDED(hr) && pParsedPath->IsInstance())
|
|
{
|
|
IWbemClassObjectPtr pObj(pProvider->GetClassObjectInterface(pContext), false);
|
|
if (pObj)
|
|
{
|
|
IWbemQualifierSetPtr pSet;
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::WinMgmtTimer);
|
|
#endif
|
|
if (SUCCEEDED(pObj->GetMethodQualifierSet(MethodName, &pSet)))
|
|
{
|
|
// disallow an instance to invoke a static method
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::WinMgmtTimer);
|
|
#endif
|
|
if (SUCCEEDED(pSet->Get( IDS_Static, 0, NULL, NULL)))
|
|
hr = WBEM_E_INVALID_METHOD;
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
// If there are in params, convert them to a cinstance.
|
|
if (SUCCEEDED(hr) && (NULL != pInParams) )
|
|
{
|
|
CInParam.Attach(new CInstance(pInParams, pContext));
|
|
|
|
if (NULL == CInParam)
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
|
|
// Get the output class for the method
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IWbemClassObjectPtr pObj(pProvider->GetClassObjectInterface(pContext), false);
|
|
if (pObj != NULL)
|
|
{
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::WinMgmtTimer);
|
|
#endif
|
|
hr = pObj->GetMethod(MethodName, 0, NULL, &pOutClass);
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
// If there is no output class, pOutClass is null (by design). So, if there was no error
|
|
// and we got an pOutClass, get an instance and wrap it in a CInstance
|
|
if (SUCCEEDED(hr) && (pOutClass != NULL))
|
|
{
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::WinMgmtTimer);
|
|
#endif
|
|
hr = pOutClass->SpawnInstance(0, &pOutParams);
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
COutParam.Attach(new CInstance(pOutParams, pContext));
|
|
|
|
// Out of memory
|
|
if (NULL == COutParam)
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
CWbemGlueImpersonation impersonate;
|
|
if SUCCEEDED ( hr = impersonate.IsImpersonated () )
|
|
{
|
|
// Set up to call FlushAll
|
|
AddFlushPtr(pProvider);
|
|
|
|
WCHAR wszName[UNLEN + DNLEN + 1 + 1] = {0};
|
|
WCHAR wszName2[UNLEN + DNLEN + 1 + 1] = {0}; // domain + \ + name + null
|
|
DWORD dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName, &dwLen);
|
|
|
|
hr = pProvider->ExecMethod( pParsedPath, MethodName, lFlags, CInParam, COutParam, pContext );
|
|
|
|
dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
GetUserNameEx(NameSamCompatible, wszName2, &dwLen);
|
|
|
|
if (wcscmp(wszName, wszName2) != 0)
|
|
{
|
|
ASSERT_BREAK(IMPERSONATION_REVERTED);
|
|
LogErrorMessage5(L"Warning! User name at exit (%s) != user name at entry (%s) for %s.%s",
|
|
wszName2, wszName, ObjectPath, MethodName);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If there is an output object
|
|
if (COutParam != NULL)
|
|
{
|
|
|
|
// Only send back an output object if the method succeeded
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
|
|
// Send the object back
|
|
IWbemClassObjectPtr pObj(COutParam->GetClassObjectInterface(), false);
|
|
IWbemClassObject *pObj2 = (IWbemClassObject *)pObj;
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::WinMgmtTimer);
|
|
#endif
|
|
|
|
pResponseHandler->Indicate( 1, &pObj2);
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
pStatusObject.Attach(pContext->GetStatusObject());
|
|
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage3(L"%s (%s)", IDS_PROVIDERNOTFOUND, pParsedPath->m_pClass);
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
bLocalError = true;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage3(L"%s (%s)", IDS_COULDNOTPARSE, ObjectPath);
|
|
bLocalError = true;
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
LogMessage4(L"%s%s.%s - Succeeded", IDS_EXECMETHODASYNC, ObjectPath, MethodName);
|
|
else
|
|
LogMessage5(L"%s%s.%s - FAILED (%x)", IDS_EXECMETHODASYNC, ObjectPath, MethodName, hr);
|
|
}
|
|
}
|
|
|
|
catch ( CFramework_Exception e_FR )
|
|
{
|
|
ASSERT_BREAK(FRAMEWORK_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( CHeap_Exception e_HE )
|
|
{
|
|
ASSERT_BREAK(MEMORY_EXHAUSTED);
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
catch(CStructured_Exception e_SE)
|
|
{
|
|
ASSERT_BREAK(STRUCTURED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
ASSERT_BREAK(UNSPECIFIED_EXCEPTION);
|
|
hr = WBEM_E_PROVIDER_FAILURE;
|
|
}
|
|
|
|
if ((hr != WBEM_E_INVALID_CLASS) && (hr != WBEM_E_UNSUPPORTED_PARAMETER) && !bLocalError)
|
|
{
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::WinMgmtTimer);
|
|
#endif
|
|
pResponseHandler->SetStatus( 0, hr, NULL, pStatusObject );
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Start(StopWatch::FrameworkTimer);
|
|
#endif
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
// Clean up the Parsed Path
|
|
if (pParsedPath)
|
|
{
|
|
objpathParser.Free( pParsedPath );
|
|
}
|
|
|
|
Release();
|
|
|
|
#ifdef PROVIDER_INSTRUMENTATION
|
|
stopWatch.Stop();
|
|
stopWatch.LogResults();
|
|
#endif
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetNamespaceConnection
|
|
//
|
|
// Establishes a connection to the supplied namespace by first
|
|
// assigning a default if needed, then searching our map, and if
|
|
// that fails, then actually connecting.
|
|
//
|
|
// Inputs: const BSTR NameSpace - NameSpace of provider
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: IWbemServices *pointer to IWbemServices corresponding
|
|
// to the connected namespace.
|
|
//
|
|
// Comments: Default Namespace is Root\\Default
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
IWbemServices *CWbemProviderGlue::GetNamespaceConnection(
|
|
|
|
LPCWSTR pwszNameSpace
|
|
)
|
|
{
|
|
ASSERT_BREAK(DEPRECATED);
|
|
|
|
bstr_t bstrNamespace(pwszNameSpace);
|
|
|
|
// Root\CimV2 is the default name space
|
|
if ( NULL == pwszNameSpace
|
|
|| L'\0' == *pwszNameSpace )
|
|
{
|
|
bstrNamespace = DEFAULT_NAMESPACE;
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s%s", IDS_GETNAMESPACECONNECTION, (LPCWSTR)bstrNamespace);
|
|
}
|
|
|
|
IWbemLocatorPtr pIWbemLocator;
|
|
IWbemServices *pWbemServices = NULL;
|
|
|
|
HRESULT hRes = CoCreateInstance (
|
|
|
|
CLSID_WbemLocator, //CLSID_WbemAdministrativeLocator,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
|
|
IID_IUnknown,
|
|
( void ** ) &pIWbemLocator
|
|
) ;
|
|
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
hRes = pIWbemLocator->ConnectServer(bstrNamespace, // Namespace
|
|
NULL, // Userid
|
|
NULL, // PW
|
|
NULL, // Locale
|
|
0, // flags
|
|
NULL, // Authority
|
|
NULL, // Context
|
|
&pWbemServices
|
|
);
|
|
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage3(L"Failed to Connectserver to namespace %s (%x)", (LPCWSTR)bstrNamespace, hRes);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage2(L"Failed to get locator (%x)", hRes);
|
|
}
|
|
|
|
return pWbemServices;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::FrameworkLogin
|
|
//
|
|
// Static entry point for providers to login to the framework,
|
|
// providing us with info for our map, and allowing us to return
|
|
// an IWbemServices pointer for the base provider class to
|
|
// manipulate to its heart's content.
|
|
//
|
|
// Inputs: LPCWSTR& strName - Name of object for map.
|
|
// Provider *pProvider - Pointer Name Maps to.
|
|
// LPCWSTR pszNameSpace - NameSpace of provider
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: None.
|
|
//
|
|
// Comments: None.
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
void CWbemProviderGlue::FrameworkLogin(
|
|
|
|
LPCWSTR a_szName,
|
|
Provider *a_pProvider,
|
|
LPCWSTR a_pszNameSpace
|
|
)
|
|
{
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (a_pszNameSpace != NULL)
|
|
{
|
|
LogMessage4(L"%s%s:%s", IDS_FRAMEWORKLOGIN, a_pszNameSpace, a_szName);
|
|
}
|
|
else
|
|
{
|
|
LogMessage4(L"%s%s:%s", IDS_FRAMEWORKLOGIN, DEFAULT_NAMESPACE, a_szName);
|
|
}
|
|
}
|
|
|
|
// AddProviderToMap, searches the Map for a match first.
|
|
// If one is found, it does not perform the actual add.
|
|
// Check that the pointers are the same. If they're
|
|
// different, this is what happened.
|
|
|
|
// pProvider doesn't get addref'ed, so no release necessary
|
|
Provider *t_pTestProvider = AddProviderToMap( a_szName, a_pszNameSpace, a_pProvider );
|
|
|
|
if ( t_pTestProvider != a_pProvider )
|
|
{
|
|
// this should never happen
|
|
// a provider should login only once at construction and out at destruction
|
|
// this should coincide with DLLs being loaded and unloaded.
|
|
LogErrorMessage4(L"%s (%s:%s)", IDS_LOGINDISALLOWED, a_pszNameSpace, a_szName);
|
|
ASSERT_BREAK( FALSE );
|
|
}
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::FrameworkLogoff
|
|
//
|
|
// Static entry point for providers to log out of the framework,
|
|
// this should be called from the provider's dtor so that we release
|
|
// all of our pointers so they don't dangle.
|
|
//
|
|
// Inputs: LPCWSTR& strName - Name of object for map.
|
|
// LPCWSTR pszNameSpace - NameSpace of provider
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: usually.
|
|
//
|
|
// Comments: We don't bother removing entries from the namespace map.
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
void CWbemProviderGlue::FrameworkLogoff(
|
|
|
|
LPCWSTR a_pszName,
|
|
LPCWSTR a_pszNamespace
|
|
)
|
|
{
|
|
STRING2LPVOID::iterator mapIter;
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s%s", IDS_FRAMEWORKLOGOFF, a_pszName);
|
|
}
|
|
|
|
CHString strQualifiedName( a_pszName );
|
|
|
|
// If our NameSpace is non-NULL (we use DEFAULT_NAMESPACE then), AND it
|
|
// is not DEFAULT_NAMESPACE, concat the namespace to the provider name
|
|
// so we can differentiate providers across namespaces.
|
|
|
|
if ( (a_pszNamespace != NULL) && (a_pszNamespace[0] != L'\0')
|
|
&& 0 != _wcsicmp(a_pszNamespace, DEFAULT_NAMESPACE ) )
|
|
{
|
|
strQualifiedName += a_pszNamespace;
|
|
}
|
|
|
|
// Convert characters to upper case before searching for
|
|
// them in the map. Since we convert to upper case when
|
|
// we store the map associations, this effectively makes
|
|
// us case-insensitive.
|
|
|
|
strQualifiedName.MakeUpper();
|
|
|
|
LockProviderMap();
|
|
|
|
try
|
|
{
|
|
if( ( mapIter = s_providersmap.find( strQualifiedName ) ) != s_providersmap.end() )
|
|
s_providersmap.erase(mapIter);
|
|
else
|
|
ASSERT_BREAK(0 /* did not find provider to log off!*/);
|
|
}
|
|
catch ( ... )
|
|
{
|
|
UnlockProviderMap();
|
|
throw;
|
|
}
|
|
|
|
UnlockProviderMap();
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetAllInstances
|
|
//
|
|
// Static entry point for providers to obtain instance lists from
|
|
// other providers.
|
|
//
|
|
// Inputs: LPCWSTR pszProviderName - Name of provider to
|
|
// get list for.
|
|
// TRefPointerCollection<CInstance> *pList - List to fill.
|
|
// LPCWSTR pszNamespace - Namespace of provider.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments: This is an internal entry point, allowing providers
|
|
// to short circuit having to go through WBEM to access
|
|
// data from other providers.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetAllInstances(
|
|
|
|
LPCWSTR pszClassName,
|
|
TRefPointerCollection<CInstance> *pList,
|
|
LPCWSTR pszNamespace, /* = NULL*/
|
|
MethodContext *pMethodContext /* = NULL*/
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
if (pszClassName)
|
|
{
|
|
CHString sQuery;
|
|
|
|
sQuery.Format(L"SELECT * FROM %s where __CLASS = \"%s\"", pszClassName, pszClassName);
|
|
hr = GetInstancesByQuery( sQuery, pList, pMethodContext, pszNamespace);
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetAllInstancesAsynch
|
|
//
|
|
// Static entry point for providers to obtain instances from
|
|
// other providers. Note that this is not, strictly speaking,
|
|
// an asynchronous implementation - it does HELP the asynch calls
|
|
// in that it does not build a big list and that the callback allows
|
|
// the provider to respond asynchronously
|
|
//
|
|
// Inputs: LPCWSTR pszProviderName - Name of provider to
|
|
// get instances from.
|
|
//
|
|
// Provider * this is the "this" pointer for the requester
|
|
// LPProviderInstanceCallback callback function to eat the instances provided
|
|
// LPCWSTR pszNamespace - Namespace of provider.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments: This is an internal entry point, allowing providers
|
|
// to short circuit having to go through WBEM to access
|
|
// data from other providers.
|
|
// this puppy shares a lot of code with GetAllInstances, but I
|
|
// can't find a clean way to combine them.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetAllInstancesAsynch(
|
|
|
|
LPCWSTR pszClassName,
|
|
Provider *pRequester,
|
|
LPProviderInstanceCallback pCallback,
|
|
LPCWSTR pszNamespace,
|
|
MethodContext *pMethodContext,
|
|
void *pUserData
|
|
)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
if (pszClassName)
|
|
{
|
|
CHString sQuery;
|
|
sQuery.Format(L"SELECT * FROM %s where __CLASS = \"%s\"", pszClassName, pszClassName);
|
|
hr = GetInstancesByQueryAsynch( sQuery, pRequester, pCallback, pszNamespace, pMethodContext, pUserData);
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetAllDerivedInstances
|
|
//
|
|
// Static entry point for providers to obtain instance lists from
|
|
// other providers. This one will return all instances derived from
|
|
// the base class passed in.
|
|
//
|
|
// Inputs: LPCWSTR pszBaseClassName - Name of base class
|
|
// to get list for.
|
|
// TRefPointerCollection<CInstance> *pList - List to fill.
|
|
// LPCWSTR pszNamespace - Namespace of provider.
|
|
// MethodContext *pMethodContext, // must not be NULL
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments: This is an internal entry point, allowing providers
|
|
// to short circuit having to go through WBEM to access
|
|
// data from other providers.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetAllDerivedInstances(
|
|
|
|
LPCWSTR pszBaseClassName,
|
|
TRefPointerCollection<CInstance> *pList,
|
|
MethodContext *pMethodContext,
|
|
LPCWSTR pszNamespace
|
|
)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
if (pszBaseClassName)
|
|
{
|
|
CHString sQuery;
|
|
sQuery.Format(L"SELECT * FROM %s", pszBaseClassName);
|
|
hr = GetInstancesByQuery( sQuery, pList, pMethodContext, pszNamespace);
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetAllDerivedInstancesAsynch
|
|
//
|
|
// Static entry point for providers to obtain instances from
|
|
// other providers. Note that this is not, strictly speaking,
|
|
// an asynchronous implementation - it does HELP the asynch calls
|
|
// in that it does not build a big list and that the callback allows
|
|
// the provider to respond asynchronously
|
|
//
|
|
// Inputs: LPCWSTR pszProviderName - Name of provider to
|
|
// get instances from.
|
|
//
|
|
// Provider* this is the "this" pointer for the requester
|
|
// LPProviderInstanceCallback callback function to eat the instances provided
|
|
// LPCWSTR pszNamespace - Namespace of provider.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments: This is an internal entry point, allowing providers
|
|
// to short circuit having to go through WBEM to access
|
|
// data from other providers.
|
|
// this puppy shares a lot of code with GetAllInstances, but I
|
|
// can't find a clean way to combine them.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetAllDerivedInstancesAsynch(
|
|
|
|
LPCWSTR pszProviderName,
|
|
Provider *pRequester,
|
|
LPProviderInstanceCallback pCallback,
|
|
LPCWSTR pszNamespace,
|
|
MethodContext *pMethodContext,
|
|
void *pUserData
|
|
)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
if (pszProviderName)
|
|
{
|
|
CHString sQuery;
|
|
sQuery.Format(L"SELECT * FROM %s", pszProviderName);
|
|
hr = GetInstancesByQueryAsynch( sQuery, pRequester, pCallback, pszNamespace, pMethodContext, pUserData);
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetInstancesByQuery
|
|
//
|
|
// Static entry point for providers to obtain instance lists from
|
|
// other providers. This one will return all instances matching a query.
|
|
//
|
|
// Inputs: LPCWSTR Query to execute "Select * from win32_foo where bar = "baz""
|
|
// TRefPointerCollection<CInstance> *pList - List to fill.
|
|
// MethodContext *pMethodContext, // must not be NULL
|
|
// LPCWSTR pointer to namespace - may be NULL (means default -- root\cimv2)
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetInstancesByQuery( LPCWSTR query,
|
|
TRefPointerCollection<CInstance> *pList,
|
|
MethodContext *pMethodContext,
|
|
LPCWSTR pszNamespace /* = NULL*/)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s (%s)", IDS_GETINSTANCESBYQUERY, query);
|
|
}
|
|
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
if ( (query != NULL) &&
|
|
(pList != NULL) &&
|
|
(pMethodContext != NULL) )
|
|
{
|
|
IEnumWbemClassObjectPtr pEnum;
|
|
|
|
IWbemContextPtr pWbemContext;
|
|
if (pMethodContext)
|
|
{
|
|
pWbemContext.Attach(pMethodContext->GetIWBEMContext());
|
|
}
|
|
|
|
IWbemServicesPtr piService;
|
|
|
|
// get a service interface
|
|
if (pszNamespace == NULL || pszNamespace[0] == L'\0')
|
|
{
|
|
piService.Attach(GetNamespaceConnection(NULL, pMethodContext));
|
|
}
|
|
else
|
|
{
|
|
piService.Attach(GetNamespaceConnection( pszNamespace, pMethodContext));
|
|
}
|
|
|
|
if ( piService != NULL)
|
|
{
|
|
{
|
|
// Assures that impersonation goes
|
|
// back to the way it was before the
|
|
// call to CIMOM.
|
|
CAutoImpRevert air;
|
|
DWORD dwImpErr = air.LastError();
|
|
if(dwImpErr == ERROR_SUCCESS)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::WinMgmtTimer);
|
|
hr = piService->ExecQuery(bstr_t(IDS_WQL), bstr_t(query), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, pWbemContext, &pEnum);
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage2(L"Failed to open current thread token for checking impersonation, with error %d", dwImpErr);
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if ( SUCCEEDED( hr ) )
|
|
{
|
|
IWbemClassObjectPtr pObj;
|
|
ULONG nReturned;
|
|
|
|
// author's apology:
|
|
// we loop through, using Next() to get each instance
|
|
// we bail when we get WBEM_S_FALSE because that's the end of the enumeration
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::WinMgmtTimer);
|
|
for (hr = pEnum->Next(GLUETIMEOUT, 1, &pObj, &nReturned);
|
|
(SUCCEEDED(hr) && (hr != WBEM_S_FALSE) && (hr != WBEM_S_TIMEDOUT) ) ;
|
|
hr = pEnum->Next(GLUETIMEOUT, 1, &pObj, &nReturned))
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
if (pObj != NULL && nReturned)
|
|
{
|
|
CInstancePtr pInstance(new CInstance(pObj, pMethodContext), false);
|
|
|
|
if (pInstance != NULL)
|
|
{
|
|
// Check to see if adding to the list succeeds
|
|
if (!pList->Add(pInstance))
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
// the Next will return WBEM_S_FALSE when it is done. However, that
|
|
// means that THIS function had no error.
|
|
if (hr == WBEM_S_FALSE)
|
|
{
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
// fencepost check - the last error might have been access denied
|
|
// but it's okay if we got any instances at all
|
|
else if (hr == WBEM_E_ACCESS_DENIED)
|
|
if (pList->GetSize() > 0)
|
|
hr = WBEM_S_NO_ERROR;
|
|
|
|
|
|
} // IF SUCCEEDED
|
|
}
|
|
else
|
|
LogErrorMessage(IDS_FAILED);
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
LogErrorMessage(L"NULL parameter to GetInstancesByQuery");
|
|
ASSERT_BREAK(WBEM_E_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LogMessage3(L"%s (%s) - Succeeded", IDS_GETINSTANCESBYQUERY, query);
|
|
}
|
|
else
|
|
{
|
|
LogMessage4(L"%s (%s) - FAILED (%x)", IDS_GETINSTANCESBYQUERY, query, hr);
|
|
}
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::IsDerivedFrom
|
|
//
|
|
// Static entry point for providers to obtain derivation information
|
|
//
|
|
// Inputs: LPCWSTR pszBaseClassName - Name of base class
|
|
// LPCWSTR pszDerivedClassName - Name of class we're testing
|
|
// MethodContext *pMethodContext
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: true iff pszDerivedClassName is derived from pszBaseClassName
|
|
//
|
|
// Comments: This function cannot short circuit, because a derived class may be external
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
bool CWbemProviderGlue::IsDerivedFrom(
|
|
|
|
LPCWSTR pszBaseClassName,
|
|
LPCWSTR pszDerivedClassName,
|
|
MethodContext *pMethodContext,
|
|
LPCWSTR pszNamespace /* = NULL*/
|
|
)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
bool bRet = false;
|
|
|
|
if ( (pszBaseClassName != NULL) &&
|
|
(pszDerivedClassName != NULL) &&
|
|
(pMethodContext != NULL) )
|
|
{
|
|
IWbemServicesPtr piService;
|
|
|
|
// get a service interface
|
|
piService.Attach(GetNamespaceConnection( pszNamespace, pMethodContext ));
|
|
|
|
// find the derived class object
|
|
if (piService != NULL)
|
|
{
|
|
IWbemClassObjectPtr pObj;
|
|
IWbemContextPtr pWbemContext;
|
|
if (pMethodContext)
|
|
{
|
|
pWbemContext.Attach(pMethodContext->GetIWBEMContext());
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::WinMgmtTimer);
|
|
HRESULT hr = piService->GetObject( bstr_t( pszDerivedClassName ), 0, pWbemContext, &pObj, NULL);
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
if (SUCCEEDED(hr) && (pObj != NULL))
|
|
{
|
|
// Variant_t handles the VariantInit/VariantClear
|
|
variant_t v;
|
|
|
|
if (SUCCEEDED(pObj->Get((unsigned short *)IDS_DERIVATION, 0, &v, NULL, NULL)))
|
|
{
|
|
BSTR bstrTemp = NULL;
|
|
SAFEARRAY *psa = V_ARRAY(&v);
|
|
LONG uBound;
|
|
SafeArrayGetUBound(psa, 1, &uBound);
|
|
|
|
// if base class is in the list in the derivation, we're true!
|
|
for (LONG i = 0; !bRet && (i <= uBound); i++)
|
|
{
|
|
SafeArrayGetElement(psa, &i, &bstrTemp);
|
|
try
|
|
{
|
|
bRet = (_wcsicmp(pszBaseClassName, bstrTemp) == 0);
|
|
}
|
|
catch ( ... )
|
|
{
|
|
SysFreeString(bstrTemp);
|
|
throw ;
|
|
}
|
|
SysFreeString(bstrTemp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage(L"NULL parameter to IsDerivedFrom");
|
|
ASSERT_BREAK(WBEM_E_INVALID_PARAMETER);
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetEmptyInstance
|
|
//
|
|
// Static entry point for providers to obtain a single empty instance
|
|
// of a provider object.
|
|
//
|
|
// Inputs: LPCWSTR pszProviderName - Name of provider to
|
|
// get list for.
|
|
// LPCWSTR pszNamespace - Namespace of provider.
|
|
//
|
|
// Outputs: CInstance **ppInstance - Pointer to store new
|
|
// pInstance in. Must be Released by
|
|
// caller.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments: This is an internal entry point, allowing providers
|
|
// to short circuit having to go through WBEM to access
|
|
// data from other providers.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
// DEPRECATED
|
|
HRESULT WINAPI CWbemProviderGlue::GetEmptyInstance(
|
|
|
|
LPCWSTR pszClassName,
|
|
CInstance **ppInstance,
|
|
LPCWSTR pszNamespace
|
|
)
|
|
{
|
|
ASSERT_BREAK(DEPRECATED);
|
|
|
|
HRESULT hr = WBEM_E_INVALID_CLASS;
|
|
|
|
if ( (pszClassName != NULL) &&
|
|
(ppInstance != NULL) )
|
|
{
|
|
// Search for the class name in our map of providers, we know which
|
|
// namespace we are when we get constructed.
|
|
|
|
// pProvider doesn't get addref'ed, so no release is necessary
|
|
Provider *pProvider = SearchMapForProvider( pszClassName, pszNamespace );
|
|
|
|
if ( NULL != pProvider )
|
|
{
|
|
// Now create an Internal Method Context object, since this function
|
|
// only gets called internal to our DLL. Using a NULL for the
|
|
// list pointer, essentially creates a dummy context so we can
|
|
// do our commit dance as painlessly as possible.
|
|
|
|
InternalMethodContextPtr pContext (new InternalMethodContext( NULL, NULL, NULL ), false);
|
|
|
|
if ( NULL != pContext )
|
|
{
|
|
// Assume things will go wrong like a good liitle paranoiac
|
|
hr = WBEM_E_FAILED;
|
|
|
|
// Before asking for a new instance, we MUST verify that the
|
|
// provider has a valid IMOS pointer. If it does'nt, CreateNewInstance
|
|
// may GPF (this is a safety check we must do because of our
|
|
// little short circuit.
|
|
|
|
// We don't do short circuits anymore.
|
|
// if ( pProvider->ValidateIMOSPointer() )
|
|
{
|
|
// Set the error code appropriately depending on whether or
|
|
// not the Instance gets created correctly.
|
|
|
|
// The instance returned will have been AddRefed, so it will
|
|
// be up to the caller to Release() it.
|
|
|
|
if ( ( *ppInstance = pProvider->CreateNewInstance( pContext ) ) != NULL )
|
|
{
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
LogErrorMessage(L"NULL parameter to GetEmptyInstance");
|
|
ASSERT_BREAK(WBEM_E_INVALID_PARAMETER);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetEmptyInstance
|
|
//
|
|
// Static entry point for providers to obtain a single empty instance
|
|
// of a provider object. This alternate form makes a call back
|
|
// into WINMGMT.
|
|
//
|
|
// Inputs: MethodContext *Context object for this call
|
|
// LPCWSTR pszProviderName - Name of provider to
|
|
// get instance of.
|
|
// LPCWSTR pszNamespace - Namespace of class.
|
|
//
|
|
// Outputs: CInstance **ppInstance - Pointer to store new
|
|
// pInstance in. Must be Released by
|
|
// caller.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments:
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetEmptyInstance(
|
|
|
|
MethodContext *pMethodContext,
|
|
LPCWSTR pszProviderName,
|
|
CInstance **ppOutInstance,
|
|
LPCWSTR a_pszNamespace
|
|
)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
if ( (pMethodContext != NULL) &&
|
|
(pszProviderName != NULL) &&
|
|
(ppOutInstance != NULL) )
|
|
{
|
|
|
|
CInstancePtr pClassInstance;
|
|
|
|
hr = GetInstanceFromCIMOM(pszProviderName, a_pszNamespace, pMethodContext, &pClassInstance);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IWbemClassObjectPtr pClassObject(pClassInstance->GetClassObjectInterface(), false);
|
|
if (pClassObject != NULL)
|
|
{
|
|
IWbemClassObjectPtr pObj;
|
|
hr = pClassObject->SpawnInstance(0, &pObj);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*ppOutInstance = new CInstance(pObj, pMethodContext);
|
|
if (*ppOutInstance == NULL)
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
LogErrorMessage(L"NULL parameter to GetEmptyInstance");
|
|
ASSERT_BREAK(WBEM_E_INVALID_PARAMETER);
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::FillInstance
|
|
//
|
|
// Static entry point for providers to pass us an instance with
|
|
// key data filled out, which we will use to locate the correct
|
|
// provider and ask it to fill out completely.
|
|
//
|
|
// Inputs: CInstance *pInstance - Instance to fill out.
|
|
// LPCWSTR pszNamespace - Namespace for provider.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments: This is an internal entry point, allowing providers
|
|
// to short circuit having to go through WBEM to access
|
|
// data from other providers.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
// DEPRECATED!
|
|
HRESULT WINAPI CWbemProviderGlue::FillInstance(
|
|
|
|
CInstance *pInstance,
|
|
LPCWSTR pszNamespace /*= NULL*/
|
|
)
|
|
{
|
|
ASSERT_BREAK(DEPRECATED);
|
|
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
if (pInstance != NULL)
|
|
{
|
|
// Check that we have an instance pointer, then pull out the
|
|
// class name and name space. From there we can find the
|
|
// appropriate provider and ask it to get the object.
|
|
|
|
if ( NULL != pInstance )
|
|
{
|
|
CHString strProviderName;
|
|
pInstance->GetCHString( IDS_CLASS, strProviderName );
|
|
|
|
// Search for the class name in our map of providers, we know which
|
|
// namespace we are when we get constructed.
|
|
|
|
// pProvider is not addref'ed, so no release is necessary
|
|
Provider *pProvider = SearchMapForProvider( strProviderName, pszNamespace );
|
|
|
|
if ( NULL != pProvider )
|
|
{
|
|
// Pass the pInstance off to the provider and let it take care
|
|
// of obtaining the correct values.
|
|
|
|
hr = pProvider->GetObject( pInstance );
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
LogErrorMessage(L"NULL parameter to FillInstance");
|
|
ASSERT_BREAK(WBEM_E_INVALID_PARAMETER);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::FillInstance
|
|
//
|
|
// Static entry point for providers to pass us an instance with
|
|
// key data filled out, use to make a call back into winmgmt.
|
|
//
|
|
// Inputs: MethodContext *Context object for this call
|
|
// CInstance *pInstance - Instance to fill out.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments:
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::FillInstance(
|
|
|
|
MethodContext *pMethodContext,
|
|
CInstance *pInstance
|
|
)
|
|
{
|
|
ASSERT_BREAK(DEPRECATED);
|
|
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
if ( (pMethodContext != NULL) &&
|
|
(pInstance != NULL) )
|
|
{
|
|
// Check that we have an instance pointer, then pull out the path
|
|
// and send it to cimom.
|
|
CHString strPathName;
|
|
|
|
pInstance->GetCHString( L"__RELPATH", strPathName );
|
|
hr = GetInstanceByPath(strPathName, &pInstance, pMethodContext);
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
LogErrorMessage(L"NULL parameter to FillInstance");
|
|
ASSERT_BREAK(WBEM_E_INVALID_PARAMETER);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetInstanceKeysByPath
|
|
//
|
|
// Static entry point for providers to pass us an instance path
|
|
// to retrieve. This class uses per-property gets to request
|
|
// only the keys on the object we are retrieving.
|
|
//
|
|
// Inputs: pszInstancePath Object path to retrieve
|
|
// CInstance *pInstance - Instance to fill out.
|
|
// MethodContext *Context object for this call
|
|
//
|
|
// Outputs: None
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments:
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetInstanceKeysByPath(
|
|
|
|
LPCWSTR pszInstancePath,
|
|
CInstance **ppInstance,
|
|
MethodContext *pMethodContext
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
if ( (pMethodContext != NULL) &&
|
|
(pszInstancePath != NULL) &&
|
|
(ppInstance != NULL) )
|
|
{
|
|
|
|
IWbemContextPtr pWbemContext(pMethodContext->GetIWBEMContext(), false);
|
|
|
|
// We need to have a real context object, not an internal method context
|
|
if (pWbemContext != NULL)
|
|
{
|
|
VARIANT vValue;
|
|
V_VT(&vValue) = VT_BOOL;
|
|
V_BOOL(&vValue) = VARIANT_TRUE;
|
|
|
|
// Set the appropriate properties on the context object
|
|
if ( (SUCCEEDED(hr = pWbemContext->SetValue(L"__GET_EXTENSIONS", 0L, &vValue))) &&
|
|
(SUCCEEDED(hr = pWbemContext->SetValue(L"__GET_EXT_KEYS_ONLY", 0L, &vValue))) &&
|
|
(SUCCEEDED(hr = pWbemContext->SetValue(L"__GET_EXT_CLIENT_REQUEST", 0L, &vValue))))
|
|
{
|
|
LogMessage2(L"GetInstanceKeysByPath: %s", pszInstancePath);
|
|
hr = GetInstanceByPath(pszInstancePath, ppInstance, pMethodContext);
|
|
|
|
V_BOOL(&vValue) = VARIANT_FALSE;
|
|
pWbemContext->SetValue(L"__GET_EXTENSIONS", 0L, &vValue);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT_BREAK(FALSE);
|
|
LogErrorMessage(L"Can't use InternalMethodContext to GetInstanceKeysByPath");
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetInstancePropertiesByPath
|
|
//
|
|
// Static entry point for providers to pass us an instance path
|
|
// to retrieve. This class uses per-property gets to request
|
|
// only the properties specified in the array.
|
|
//
|
|
// Inputs: pszInstancePath Object path to retrieve
|
|
// CInstance *pInstance - Instance to fill out.
|
|
// MethodContext *Context object for this call
|
|
// csaProperties Properties to request
|
|
//
|
|
// Outputs: None
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments:
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetInstancePropertiesByPath(
|
|
|
|
LPCWSTR pszInstancePath,
|
|
CInstance **ppInstance,
|
|
MethodContext *pMethodContext,
|
|
CHStringArray &csaProperties
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
if ( (pMethodContext != NULL) &&
|
|
(pszInstancePath != NULL) &&
|
|
(ppInstance != NULL) )
|
|
{
|
|
|
|
IWbemContextPtr pWbemContext(pMethodContext->GetIWBEMContext(), false);
|
|
|
|
// We need to have a real context object, not an internal method context
|
|
if (pWbemContext != NULL)
|
|
{
|
|
variant_t vValue;
|
|
V_VT(&vValue) = VT_BOOL;
|
|
V_BOOL(&vValue) = VARIANT_TRUE;
|
|
|
|
// First set the value that says we are using Get extensions
|
|
if ((SUCCEEDED(hr = pWbemContext->SetValue(L"__GET_EXTENSIONS", 0L, &vValue))) &&
|
|
(SUCCEEDED(hr = pWbemContext->SetValue(L"__GET_EXT_CLIENT_REQUEST", 0L, &vValue))) )
|
|
{
|
|
// Delete any unneeded properties
|
|
pWbemContext->DeleteValue(L"__GET_EXT_KEYS_ONLY", 0L);
|
|
|
|
// Now build the array of properties
|
|
SAFEARRAYBOUND rgsabound [ 1 ] ;
|
|
|
|
rgsabound[0].cElements = csaProperties.GetSize() ;
|
|
rgsabound[0].lLbound = 0 ;
|
|
V_ARRAY(&vValue) = SafeArrayCreate ( VT_BSTR, 1, rgsabound ) ;
|
|
if ( V_ARRAY(&vValue) )
|
|
{
|
|
V_VT(&vValue) = VT_BSTR | VT_ARRAY;
|
|
|
|
for (long x=0; x < csaProperties.GetSize(); x++)
|
|
{
|
|
bstr_t bstrProp = csaProperties[x];
|
|
|
|
SafeArrayPutElement(
|
|
V_ARRAY(&vValue),
|
|
&x,
|
|
(LPVOID) (BSTR) bstrProp);
|
|
}
|
|
|
|
// Put the array into the context object
|
|
if (SUCCEEDED(hr = pWbemContext->SetValue(L"__GET_EXT_PROPERTIES", 0L, &vValue)))
|
|
{
|
|
LogMessage2(L"GetInstancePropertiesByPath: %s", pszInstancePath);
|
|
// Make the call
|
|
hr = GetInstanceByPath(pszInstancePath, ppInstance, pMethodContext);
|
|
|
|
vValue.Clear();
|
|
V_VT(&vValue) = VT_BOOL;
|
|
V_BOOL(&vValue) = VARIANT_FALSE;
|
|
pWbemContext->SetValue(L"__GET_EXTENSIONS", 0L, &vValue);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT_BREAK(FALSE);
|
|
LogErrorMessage(L"Can't use InternalMethodContext to GetInstanceKeysByPath");
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetInstanceByPath
|
|
//
|
|
// Static entry point for providers to obtain a single empty instance
|
|
// of a provider object.
|
|
//
|
|
// Inputs: LPCWSTR pszInstancePath - Path to Object. This
|
|
// MUST be a full path,
|
|
// MethodContext *pMethodContext - Method Context containing
|
|
// (hopefully) the WbemContext we need
|
|
// to propogate.
|
|
//
|
|
// Outputs: CInstance** ppInstance - Pointer to store new
|
|
// pInstance in. Must be Released by
|
|
// caller.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
// Comments: This is an internal entry point, allowing providers
|
|
// to short circuit having to go through WBEM to access
|
|
// data from other providers.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetInstanceByPath(
|
|
|
|
LPCWSTR pszInstancePath,
|
|
CInstance **ppInstance,
|
|
MethodContext *pMethodContext /* = NULL */
|
|
)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
if ( (pszInstancePath != NULL) &&
|
|
(ppInstance != NULL) )
|
|
{
|
|
CHString strComputerName;
|
|
GetComputerName( strComputerName );
|
|
|
|
// For this revision, we DO NOT support getting paths that are not local.
|
|
// This is because if the machine name is anything other than the local
|
|
// one, we run the risk of freezing while CIMOM goes out and tries to find
|
|
// the machine (up to around 5 minutes according to his Levness.
|
|
|
|
ParsedObjectPath *pParsedPath = NULL;
|
|
CObjectPathParser objpathParser;
|
|
|
|
// Parse the object path passed to us by CIMOM
|
|
// ==========================================
|
|
int nStatus = objpathParser.Parse( pszInstancePath, &pParsedPath );
|
|
|
|
try
|
|
{
|
|
if ( 0 == nStatus )
|
|
{
|
|
// Machine names MUST match. Null indicates no machine name specified.
|
|
|
|
if (( pParsedPath->m_pServer == NULL) ||
|
|
( strComputerName.CompareNoCase( pParsedPath->m_pServer ) == 0 ) ||
|
|
( wcscmp(pParsedPath->m_pServer, L".") == 0 )
|
|
)
|
|
{
|
|
// Now try to find the provider based on the class name
|
|
CHString strNamespace;
|
|
|
|
// Pull out the name space parts, and concatenate them using a '\\'
|
|
// character. e.g. root\default.
|
|
|
|
for ( DWORD dwCtr = 0; dwCtr < pParsedPath->m_dwNumNamespaces; dwCtr++ )
|
|
{
|
|
if ( dwCtr != 0 )
|
|
{
|
|
strNamespace += L"\\";
|
|
}
|
|
|
|
strNamespace += pParsedPath->m_paNamespaces[dwCtr];
|
|
}
|
|
|
|
// We need to propogate the Wbem Context if we are going out
|
|
// to CIMOM!
|
|
|
|
IWbemContextPtr pWbemContext;
|
|
CWbemProviderGlue *pGlue = NULL;
|
|
|
|
if ( NULL != pMethodContext )
|
|
{
|
|
pWbemContext.Attach(pMethodContext->GetIWBEMContext());
|
|
pGlue = pMethodContext->GetProviderGlue();
|
|
}
|
|
else
|
|
{
|
|
ASSERT_BREAK(DEPRECATED);
|
|
}
|
|
|
|
InternalMethodContextPtr pInternalContext (
|
|
new InternalMethodContext(
|
|
NULL,
|
|
pWbemContext,
|
|
pGlue), false);
|
|
|
|
if ( NULL != pInternalContext )
|
|
{
|
|
hr = GetInstanceFromCIMOM( pszInstancePath, strNamespace, pInternalContext, ppInstance );
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
|
|
|
|
} // IF Machine Names MATCH
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER; // INVALID MACHINE NAME
|
|
}
|
|
|
|
// Clean up the Parsed Path
|
|
objpathParser.Free( pParsedPath );
|
|
|
|
} // IF nStatus == 0
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_OBJECT_PATH;
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
// Clean up the Parsed Path
|
|
if (pParsedPath)
|
|
{
|
|
objpathParser.Free( pParsedPath );
|
|
}
|
|
throw ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
LogErrorMessage(L"NULL parameter to GetInstanceByPath");
|
|
ASSERT_BREAK(WBEM_E_INVALID_PARAMETER);
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetInstanceFromCIMOM
|
|
//
|
|
// Static entry point for providers to obtain a single instance
|
|
// of a WBEM Object. obtaining said object from CIMOM.
|
|
//
|
|
// Inputs: LPCWSTR pszInstancePath - Path to Object. This
|
|
// MUST be a full path,
|
|
// LPCWSTR pszNameSpace - NameSpace of Object.
|
|
// MethodContext *pMethodContext - Method Context
|
|
//
|
|
// Outputs: CInstance **ppInstance - Pointer to store new
|
|
// pInstance in. Must be Released by
|
|
// caller.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
// will return WBEM_E_INVALID_NAMESPACE if it's not a namespace we support
|
|
// (might otherwise be valid, but not so far as WE are concerned).
|
|
//
|
|
// Comments: This is an internal entry point, allowing providers
|
|
// that failed the short circuit to be propogated
|
|
// by calling into CIMOM.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetInstanceFromCIMOM(
|
|
|
|
LPCWSTR pszInstancePath,
|
|
LPCWSTR pszNamespace,
|
|
MethodContext *pMethodContext,
|
|
CInstance **ppInstance
|
|
)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s (%s)", IDS_INSTANCEFROMCIMOM, pszInstancePath);
|
|
}
|
|
|
|
// We need to propogate the Wbem Context (if any) that was passed to
|
|
// us by CIMOM.
|
|
IWbemContextPtr pWbemContext;
|
|
|
|
if ( NULL != pMethodContext )
|
|
{
|
|
pWbemContext.Attach(pMethodContext->GetIWBEMContext());
|
|
}
|
|
else
|
|
{
|
|
ASSERT_BREAK(DEPRECATED);
|
|
}
|
|
|
|
// If we failed to find the provider, try using CIMOM to do our
|
|
// dirty work for us.
|
|
|
|
IWbemServicesPtr piService;
|
|
IWbemClassObjectPtr piObject;
|
|
|
|
// get a service interface
|
|
if ( (pszNamespace == NULL) || (pszNamespace[0] == L'\0' ))
|
|
{
|
|
piService.Attach(GetNamespaceConnection(NULL, pMethodContext));
|
|
}
|
|
else
|
|
{
|
|
piService.Attach(GetNamespaceConnection( pszNamespace, pMethodContext ));
|
|
}
|
|
|
|
if ( NULL != piService )
|
|
{
|
|
|
|
// No go out to CIMOM to get the object, if this succeeds, new an
|
|
// instance and store everything internally.
|
|
{
|
|
// Assures that impersonation goes
|
|
// back to the way it was before the
|
|
// call to CIMOM.
|
|
CAutoImpRevert air;
|
|
DWORD dwImpErr = air.LastError();
|
|
|
|
if(dwImpErr == ERROR_SUCCESS)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::WinMgmtTimer);
|
|
hr = piService->GetObject( bstr_t(pszInstancePath), 0, pWbemContext, &piObject, NULL );
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage2(L"Failed to open current thread token for checking impersonation, with error %d", dwImpErr);
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
*ppInstance = new CInstance( piObject, pMethodContext );
|
|
if (*ppInstance == NULL)
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage(IDS_FAILED);
|
|
hr = WBEM_E_INVALID_NAMESPACE;
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LogMessage3(L"%s (%s) - Succeeded", IDS_INSTANCEFROMCIMOM, pszInstancePath);
|
|
}
|
|
else
|
|
{
|
|
LogMessage4(L"%s (%s) - FAILED (%x)", IDS_INSTANCEFROMCIMOM, pszInstancePath, hr);
|
|
}
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::SearchMapForProvider
|
|
//
|
|
// Searches our Provider map for a match against the supplied
|
|
// provider name/NameSpace combination
|
|
//
|
|
// Inputs: const LPCWSTR& strName - Provider Name to find.
|
|
// const LPCWSTR& strNamespace - Provider's Namespace
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: Provider *pointer to a provider that was given to
|
|
// us by a call to FrameworkLogin.
|
|
//
|
|
// Comments: None.
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
Provider *CWbemProviderGlue::SearchMapForProvider(
|
|
|
|
LPCWSTR a_pszProviderName,
|
|
LPCWSTR a_pszNamespace
|
|
)
|
|
{
|
|
Provider *pProvider = NULL;
|
|
STRING2LPVOID::iterator mapIter;
|
|
|
|
// If our NameSpace is non-NULL (we use DEFAULT_NAMEPSACE then), AND it
|
|
// is not DEFAULT_NAMESPACE, concat the namespace to the provider name
|
|
// so we can differentiate providers across namespaces.
|
|
|
|
CHString strQualifiedName( a_pszProviderName );
|
|
CHString strLocNamespace( a_pszNamespace );
|
|
|
|
if ( !strLocNamespace.IsEmpty()
|
|
&& 0 != strLocNamespace.CompareNoCase( DEFAULT_NAMESPACE ) )
|
|
{
|
|
|
|
// Convert the / characters to \ for comparison
|
|
WCHAR *pszBuff;
|
|
pszBuff = strLocNamespace.GetBuffer(0);
|
|
while ((pszBuff = wcschr(pszBuff, '/')) != NULL)
|
|
{
|
|
*pszBuff = '\\';
|
|
}
|
|
strLocNamespace.ReleaseBuffer();
|
|
|
|
strQualifiedName += strLocNamespace;
|
|
}
|
|
|
|
// Convert characters to upper case before searching for
|
|
// them in the map. Since we convert to upper case when
|
|
// we store the map associations, this effectively makes
|
|
// us case-insensitive.
|
|
|
|
strQualifiedName.MakeUpper();
|
|
|
|
// Protect the map while we're inside this
|
|
|
|
LockProviderMap();
|
|
|
|
try
|
|
{
|
|
if( ( mapIter = s_providersmap.find( strQualifiedName ) ) != s_providersmap.end() )
|
|
{
|
|
pProvider = (Provider*) (*mapIter).second;
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
UnlockProviderMap();
|
|
throw;
|
|
}
|
|
|
|
UnlockProviderMap();
|
|
|
|
return pProvider;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::AddProviderToMap
|
|
//
|
|
// Adds a provider to our map. Searches the map first, and if it's
|
|
// not in it, adds it to the map.
|
|
//
|
|
// Inputs: const LPCWSTR strName - Provider Name to Add.
|
|
// const LPCWSTR strNamespace - Namespace for provider.
|
|
// Provider *pProvider - Provider to add to map.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: Provider *pointer to a provider in the map (may
|
|
// be different from the supplied one)
|
|
//
|
|
// Comments: None.
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
Provider *CWbemProviderGlue::AddProviderToMap(
|
|
|
|
LPCWSTR a_szProviderName,
|
|
LPCWSTR a_pszNamespace,
|
|
Provider *a_pProvider
|
|
)
|
|
{
|
|
STRING2LPVOID::iterator mapIter;
|
|
|
|
// If our NameSpace is non-NULL (we use DEFAULT_NAMEPSACE then), AND it
|
|
// is not DEFAULT_NAMESPACE, concat the namespace to the provider name
|
|
// so we can differentiate providers across namespaces.
|
|
|
|
CHString strQualifiedName( a_szProviderName );
|
|
|
|
if ( ( a_pszNamespace != NULL) && (a_pszNamespace[0] != L'\0')
|
|
&& (0 != _wcsicmp(a_pszNamespace, DEFAULT_NAMESPACE )) )
|
|
{
|
|
strQualifiedName += a_pszNamespace;
|
|
}
|
|
|
|
// Convert characters to upper case before searching for
|
|
// them in the map. Since we convert to upper case when
|
|
// we store the map associations, this effectively makes
|
|
// us case-insensitive.
|
|
|
|
strQualifiedName.MakeUpper();
|
|
|
|
// Protect the map while we're inside this
|
|
|
|
Provider *pReturnProvider = NULL;
|
|
LockProviderMap();
|
|
|
|
try
|
|
{
|
|
// First check if we've already got a provider.
|
|
if( ( mapIter = s_providersmap.find( strQualifiedName ) ) != s_providersmap.end() )
|
|
{
|
|
pReturnProvider = (Provider*) (*mapIter).second;
|
|
|
|
//delete it, we're gonna update it shortly
|
|
s_providersmap.erase(mapIter);
|
|
}
|
|
|
|
if ( NULL == pReturnProvider )
|
|
{
|
|
pReturnProvider = a_pProvider;
|
|
}
|
|
|
|
//add in the newly logged in provider
|
|
s_providersmap[strQualifiedName] = (LPVOID) a_pProvider;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
UnlockProviderMap();
|
|
throw;
|
|
}
|
|
|
|
UnlockProviderMap();
|
|
|
|
return pReturnProvider;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CWbemProviderGlue::GetComputerName( CHString& strComputerName )
|
|
{
|
|
// Fill the supplied CHString with the local machine name
|
|
DWORD dwBufferLength = MAX_COMPUTERNAME_LENGTH + 1;
|
|
|
|
FRGetComputerName(strComputerName.GetBuffer( dwBufferLength ), &dwBufferLength);
|
|
strComputerName.ReleaseBuffer();
|
|
|
|
if (strComputerName.IsEmpty())
|
|
{
|
|
strComputerName = L"DEFAULT";
|
|
}
|
|
}
|
|
|
|
BOOL CWbemProviderGlue::FrameworkLoginDLL(LPCWSTR a_pszName)
|
|
{
|
|
return CWbemProviderGlue::FrameworkLoginDLL(a_pszName, NULL);
|
|
}
|
|
|
|
BOOL CWbemProviderGlue::FrameworkLogoffDLL(LPCWSTR a_pszNname)
|
|
{
|
|
return CWbemProviderGlue::FrameworkLogoffDLL(a_pszNname, NULL);
|
|
}
|
|
|
|
void CWbemProviderGlue::IncrementObjectCount(void)
|
|
{
|
|
InterlockedIncrement(&s_lObjects);
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage2(L"CWbemProviderGlue::IncrementObjectCount. Count is (approx) %d", s_lObjects);
|
|
}
|
|
}
|
|
|
|
LONG CWbemProviderGlue::DecrementObjectCount(void)
|
|
{
|
|
LONG lRet = InterlockedDecrement(&s_lObjects);
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage2(L"CWbemProviderGlue::DecrementObjectCount. Count is (approx) %d", s_lObjects);
|
|
}
|
|
|
|
return lRet;
|
|
}
|
|
|
|
// checks impersonation level
|
|
// impersonates client if allowed
|
|
HRESULT WINAPI CWbemProviderGlue::CheckImpersonationLevel()
|
|
{
|
|
HRESULT hr = WBEM_E_ACCESS_DENIED;
|
|
|
|
if (CWbemProviderGlue::GetPlatform() == VER_PLATFORM_WIN32_NT)
|
|
{
|
|
HRESULT hRes = WbemCoImpersonateClient();
|
|
if (SUCCEEDED(hRes)) // From cominit.cpp - needed for nt3.51
|
|
{
|
|
// Now, let's check the impersonation level. First, get the thread token
|
|
HANDLE hThreadTok;
|
|
DWORD dwImp, dwBytesReturned;
|
|
|
|
if (!OpenThreadToken(
|
|
GetCurrentThread(),
|
|
TOKEN_QUERY,
|
|
TRUE,
|
|
&hThreadTok
|
|
))
|
|
{
|
|
DWORD dwLastError = GetLastError();
|
|
|
|
if (dwLastError == ERROR_NO_TOKEN)
|
|
{
|
|
// If the CoImpersonate works, but the OpenThreadToken fails due to ERROR_NO_TOKEN, we
|
|
// are running under the process token (either local system, or if we are running
|
|
// with /exe, the rights of the logged in user). In either case, impersonation rights
|
|
// don't apply. We have the full rights of that user.
|
|
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
else
|
|
{
|
|
// If we failed to get the thread token for any other reason, log an error.
|
|
LogErrorMessage2(L"Impersonation failure - OpenThreadToken failed (0x%x)", dwLastError);
|
|
hr = WBEM_E_ACCESS_DENIED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We really do have a thread token, so let's retrieve its level
|
|
|
|
if (GetTokenInformation(
|
|
hThreadTok,
|
|
TokenImpersonationLevel,
|
|
&dwImp,
|
|
sizeof(DWORD),
|
|
&dwBytesReturned
|
|
))
|
|
{
|
|
// Is the impersonation level Impersonate?
|
|
if ((dwImp == SecurityImpersonation) || (dwImp == SecurityDelegation))
|
|
{
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_ACCESS_DENIED;
|
|
LogErrorMessage3(L"%s Level(%d)", IDS_ImpersonationFailed, dwImp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_FAILED;
|
|
LogErrorMessage3(L"%s Token(%d)", IDS_ImpersonationFailed, GetLastError());
|
|
}
|
|
|
|
// Done with this handle
|
|
CloseHandle(hThreadTok);
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
WbemCoRevertToSelf();
|
|
}
|
|
}
|
|
else if (hRes == E_NOTIMPL)
|
|
{
|
|
// On 3.51 or vanilla 95, this call is not implemented, we should work anyway
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage3(L"%s CoImpersonate(%d)", IDS_ImpersonationFailed, hRes);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// let win9X in...
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
WCHAR wszName[UNLEN + DNLEN + 1 + 1]; // domain + \ + name + null
|
|
DWORD dwLen = UNLEN + DNLEN + 1 + 1;
|
|
|
|
if (GetUserNameEx(NameSamCompatible, wszName, &dwLen))
|
|
{
|
|
LogMessage2(L"Impersonation running as: %s", wszName);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetInstancesByQueryAsynch
|
|
//
|
|
// Static entry point for providers to obtain instances from
|
|
// other providers. Note that this is not, strictly speaking,
|
|
// an asynchronous implementation - it does HELP the asynch calls
|
|
// in that it does not build a big list and that the callback allows
|
|
// the provider to respond asynchronously
|
|
//
|
|
// Inputs: LPCWSTR Query to execute "Select * from win32_foo where bar = "baz""
|
|
// Provider * this is the "this" pointer for the requester
|
|
// LPProviderInstanceCallback callback function to eat the instances provided
|
|
// LPCWSTR pszNamespace - Namespace of provider.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Returns: HRESULT hr - Status code.
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT WINAPI CWbemProviderGlue::GetInstancesByQueryAsynch(
|
|
|
|
LPCWSTR query,
|
|
Provider *pRequester,
|
|
LPProviderInstanceCallback pCallback,
|
|
LPCWSTR pszNamespace,
|
|
MethodContext *pMethodContext,
|
|
void *pUserData
|
|
)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage2(L"GetInstancesByQueryAsynch (%s)", query);
|
|
}
|
|
|
|
HRESULT hr = WBEM_E_FAILED;
|
|
|
|
if ( (query != NULL) &&
|
|
(pRequester != NULL) &&
|
|
(pCallback != NULL) &&
|
|
(pMethodContext != NULL) )
|
|
{
|
|
|
|
// We need to propogate the WBEM context...ESPECIALLY...if we are going out
|
|
// to CIMOM.
|
|
|
|
IWbemContextPtr pWbemContext;
|
|
if (pMethodContext)
|
|
{
|
|
pWbemContext.Attach(pMethodContext->GetIWBEMContext());
|
|
}
|
|
else
|
|
{
|
|
ASSERT_BREAK(DEPRECATED);
|
|
}
|
|
|
|
// Now create an Internal Method Context object, since this function
|
|
// only gets called internal to our DLLs
|
|
InternalMethodContextAsynchPtr pInternalContext (new InternalMethodContextAsynch(pRequester,
|
|
pCallback,
|
|
pWbemContext,
|
|
pMethodContext,
|
|
pUserData), false);
|
|
|
|
if ( NULL != pInternalContext )
|
|
{
|
|
// using CIMOM to do our dirty work for us.
|
|
IWbemServicesPtr piService;
|
|
|
|
// get a service interface
|
|
if (pszNamespace == NULL || pszNamespace[0] == L'\0')
|
|
{
|
|
piService.Attach(GetNamespaceConnection(NULL, pMethodContext));
|
|
}
|
|
else
|
|
{
|
|
piService.Attach(GetNamespaceConnection( pszNamespace, pMethodContext ));
|
|
}
|
|
|
|
if ( NULL != piService )
|
|
{
|
|
IEnumWbemClassObjectPtr pEnum;
|
|
{
|
|
// Assures that impersonation goes
|
|
// back to the way it was before the
|
|
// call to CIMOM.
|
|
CAutoImpRevert air;
|
|
DWORD dwImpErr = air.LastError();
|
|
|
|
if(dwImpErr == ERROR_SUCCESS)
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::WinMgmtTimer);
|
|
hr = piService->ExecQuery(bstr_t(IDS_WQL),
|
|
bstr_t(query),
|
|
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
pWbemContext,
|
|
&pEnum);
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage2(L"Failed to open current thread token for checking impersonation, with error %d", dwImpErr);
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if ( SUCCEEDED( hr ) )
|
|
{
|
|
IWbemClassObjectPtr pObj;
|
|
ULONG nReturned;
|
|
|
|
// we retrieve all instances of this class and it's children. Note that
|
|
// the next returns WBEM_S_FALSE at the end which PASSES the SUCCEEDED()
|
|
// test, but fails the pObj test.
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::WinMgmtTimer);
|
|
while (SUCCEEDED(hr) && SUCCEEDED(hr = pEnum->Next(GLUETIMEOUT, 1, &pObj, &nReturned)) && (pObj != NULL))
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
CInstancePtr pInstance(new CInstance(pObj, pMethodContext), false);
|
|
if (pInstance != NULL)
|
|
{
|
|
// For reasons quite beyond me, InternalContext::Commit doesn't
|
|
// release, but external does. Note that the smartptr is doing
|
|
// the release here.
|
|
hr = pInternalContext->Commit(pInstance);
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::FrameworkTimer);
|
|
|
|
// the Next will return WBEM_S_FALSE when it is done. However, that
|
|
// means that THIS function had no error.
|
|
if (hr == WBEM_S_FALSE)
|
|
{
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
} // IF SUCCEEDED
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage(IDS_FAILED);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
LogErrorMessage(L"NULL parameter to GetInstancesByQueryAsynch");
|
|
ASSERT_BREAK(WBEM_E_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LogMessage2(L"GetInstancesByQueryAsynch (%s) - Succeeded", query);
|
|
}
|
|
else
|
|
{
|
|
LogMessage3(L"GetInstancesByQueryAsynch (%s) - FAILED (%x)", query, hr);
|
|
}
|
|
}
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pMethodContext, StopWatch::ProviderTimer);
|
|
|
|
return hr;
|
|
}
|
|
|
|
IWbemServices *CWbemProviderGlue::InternalGetNamespaceConnection(
|
|
|
|
LPCWSTR pwszNameSpace
|
|
)
|
|
{
|
|
IWbemServices *pWbemServices = NULL;
|
|
|
|
bstr_t bstrNamespace;
|
|
|
|
// Root\CimV2 is the default name space
|
|
if ( NULL != pwszNameSpace && L'\0' != *pwszNameSpace )
|
|
{
|
|
bstrNamespace = pwszNameSpace;
|
|
}
|
|
else
|
|
{
|
|
ASSERT_BREAK(DEPRECATED);
|
|
bstrNamespace = DEFAULT_NAMESPACE;
|
|
}
|
|
|
|
if (IsVerboseLoggingEnabled())
|
|
{
|
|
LogMessage3(L"%s%s", IDS_GETNAMESPACECONNECTION, (LPCWSTR)bstrNamespace);
|
|
}
|
|
|
|
_wcsupr(bstrNamespace);
|
|
|
|
// If we are looking for the namespace our class is in, we already
|
|
// got an IWbemServices pointer for this from Initialize
|
|
if (m_strNamespace.Compare(bstrNamespace) == 0)
|
|
{
|
|
pWbemServices = m_pServices;
|
|
pWbemServices->AddRef();
|
|
}
|
|
else
|
|
{
|
|
IWbemLocatorPtr pIWbemLocator;
|
|
|
|
HRESULT hRes = CoCreateInstance (
|
|
|
|
CLSID_WbemLocator, //CLSID_WbemAdministrativeLocator,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
|
|
IID_IUnknown,
|
|
( void ** ) &pIWbemLocator
|
|
) ;
|
|
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
hRes = pIWbemLocator->ConnectServer(bstrNamespace, // Namespace
|
|
NULL, // Userid
|
|
NULL, // PW
|
|
NULL, // Locale
|
|
0, // flags
|
|
NULL, // Authority
|
|
NULL, // Context
|
|
&pWbemServices
|
|
);
|
|
|
|
if (FAILED(hRes))
|
|
{
|
|
LogErrorMessage3(L"Failed to Connectserver to namespace %s (%x)",
|
|
(LPCWSTR)bstrNamespace, hRes);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage2(L"Failed to get locator (%x)", hRes);
|
|
}
|
|
}
|
|
|
|
return pWbemServices;
|
|
}
|
|
|
|
IWbemServices *WINAPI CWbemProviderGlue::GetNamespaceConnection( LPCWSTR wszNameSpace, MethodContext *pMethodContext )
|
|
{
|
|
IWbemServices *pServices = NULL;
|
|
CWbemProviderGlue *pGlue = NULL;
|
|
|
|
if ( pMethodContext && (pGlue = pMethodContext->GetProviderGlue()) )
|
|
{
|
|
pServices = pGlue->InternalGetNamespaceConnection(wszNameSpace);
|
|
}
|
|
else
|
|
{
|
|
pServices = GetNamespaceConnection(wszNameSpace);
|
|
}
|
|
|
|
return pServices;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::FrameworkLoginDLL
|
|
//
|
|
// Static entry point for providers to register their DLL with
|
|
// the framework. This PLONG must be the same one used in
|
|
// FrameworkLogoffDll and as the parameter to the CWbemGlueFactory
|
|
// constructor.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL CWbemProviderGlue::FrameworkLoginDLL(LPCWSTR pszName, PLONG plRefCount)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
LogMessage3(L"%s%s", IDS_DLLLOGGED, pszName);
|
|
|
|
// If this *is* null, that means we are using the backword compatibility
|
|
// version of FrameworkLoginDLL, which uses CWbemProviderGlue::s_lObjects
|
|
// which has already been initialized.
|
|
if (plRefCount != NULL)
|
|
{
|
|
*plRefCount = 0;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::FrameworkLogoffDLL
|
|
//
|
|
// Static entry point for providers to determine whether they
|
|
// should return TRUE to DllCanUnloadNow. This PLONG must be the
|
|
// same one used in FrameworkLoginDLL and as the parameter to the
|
|
// CWbemGlueFactory constructor.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL CWbemProviderGlue::FrameworkLogoffDLL(LPCWSTR pszName, PLONG plRefCount)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
LogMessage3(L"%s%s", IDS_DLLUNLOGGED, pszName);
|
|
|
|
// If this *is* null, that means we are using the backword compatibility
|
|
// version of FrameworkLoginDLL
|
|
if (plRefCount != NULL)
|
|
{
|
|
bRet = *plRefCount == 0;
|
|
}
|
|
else
|
|
{
|
|
bRet = CWbemProviderGlue::s_lObjects == 0;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::AddToFactoryMap
|
|
//
|
|
// Adds a new CWbemGlueFactory to the s_factorymap map.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
VOID CWbemProviderGlue::AddToFactoryMap(const CWbemGlueFactory *pGlue, PLONG plRefCount)
|
|
{
|
|
LockFactoryMap();
|
|
|
|
try
|
|
{
|
|
// If this *is* null, that means we are using the backword compatibility
|
|
// version of FrameworkLoginDLL
|
|
if (plRefCount != NULL)
|
|
{
|
|
CWbemProviderGlue::s_factorymap[pGlue] = plRefCount;
|
|
}
|
|
else
|
|
{
|
|
CWbemProviderGlue::s_factorymap[pGlue] = &CWbemProviderGlue::s_lObjects;
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
UnlockFactoryMap();
|
|
throw;
|
|
}
|
|
|
|
UnlockFactoryMap();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::RemoveFromFactoryMap
|
|
//
|
|
// Removes a CWbemGlueFactory from the s_factorymap map.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
VOID CWbemProviderGlue::RemoveFromFactoryMap(const CWbemGlueFactory *pGlue)
|
|
{
|
|
LockFactoryMap();
|
|
|
|
try
|
|
{
|
|
bool bFound = false;
|
|
PTR2PLONG::iterator mapIter;
|
|
|
|
mapIter = s_factorymap.find(pGlue);
|
|
|
|
if ( mapIter != s_factorymap.end() )
|
|
{
|
|
s_factorymap.erase(mapIter);
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage2(L"Can't find factory in map: %p", pGlue);
|
|
}
|
|
}
|
|
catch( ... )
|
|
{
|
|
UnlockFactoryMap();
|
|
throw;
|
|
}
|
|
|
|
UnlockFactoryMap();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::IncrementMapCount
|
|
//
|
|
// Increments the refcount on a DLL
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
LONG CWbemProviderGlue::IncrementMapCount(const CWbemGlueFactory *pGlue)
|
|
{
|
|
LONG lRet = -1;
|
|
LockFactoryMap();
|
|
|
|
try
|
|
{
|
|
PTR2PLONG::iterator mapIter;
|
|
mapIter = CWbemProviderGlue::s_factorymap.find( pGlue );
|
|
|
|
if (mapIter != CWbemProviderGlue::s_factorymap.end())
|
|
{
|
|
lRet = InterlockedIncrement((*mapIter).second);
|
|
}
|
|
else
|
|
{
|
|
// This is very bad. This should have been created
|
|
// at CWbemGlueFactory constructor time.
|
|
LogErrorMessage2(L"Can't find factory in map: %p", pGlue);
|
|
}
|
|
}
|
|
catch( ... )
|
|
{
|
|
UnlockFactoryMap();
|
|
throw;
|
|
}
|
|
|
|
UnlockFactoryMap();
|
|
return lRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::IncrementMapCount
|
|
//
|
|
// Increments the refcount on a DLL
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
LONG CWbemProviderGlue::IncrementMapCount(PLONG pCount)
|
|
{
|
|
return InterlockedIncrement(pCount);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::DecrementMapCount
|
|
//
|
|
// Decrements the refcount on a DLL
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
LONG CWbemProviderGlue::DecrementMapCount(const CWbemGlueFactory *pGlue)
|
|
{
|
|
LONG lRet = -1;
|
|
LockFactoryMap();
|
|
|
|
try
|
|
{
|
|
// Find the matching CWbemGlueFactory in the CWbemGlueFactory<->refcount map
|
|
PTR2PLONG::iterator mapIter;
|
|
mapIter = CWbemProviderGlue::s_factorymap.find( pGlue );
|
|
|
|
if (mapIter != CWbemProviderGlue::s_factorymap.end())
|
|
{
|
|
lRet = InterlockedDecrement((*mapIter).second);
|
|
|
|
if (lRet < 0)
|
|
{
|
|
LogErrorMessage2(L"RefCount < 0 for glue %p", pGlue);
|
|
ASSERT_BREAK(DUPLICATE_RELEASE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage2(L"Can't find factory in map: %p", pGlue);
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
UnlockFactoryMap();
|
|
throw;
|
|
}
|
|
|
|
UnlockFactoryMap();
|
|
return lRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::DecrementMapCount
|
|
//
|
|
// Decrements the refcount on a DLL
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
LONG CWbemProviderGlue::DecrementMapCount(PLONG pCount)
|
|
{
|
|
LONG lRet = InterlockedDecrement(pCount);
|
|
|
|
if (lRet < 0)
|
|
{
|
|
LogErrorMessage2(L"RefCount < 0 for %p", pCount);
|
|
ASSERT_BREAK(DUPLICATE_RELEASE);
|
|
}
|
|
|
|
return lRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::GetMapCountPtr
|
|
//
|
|
// Returns the pointer to the plong for this glue factory
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
PLONG CWbemProviderGlue::GetMapCountPtr(const CWbemGlueFactory *pGlue)
|
|
{
|
|
PLONG pRet = NULL;
|
|
LockFactoryMap();
|
|
|
|
try
|
|
{
|
|
// Find the matching CWbemGlueFactory in the CWbemGlueFactory<->refcount map
|
|
PTR2PLONG::iterator mapIter;
|
|
mapIter = CWbemProviderGlue::s_factorymap.find( pGlue );
|
|
|
|
if (mapIter != CWbemProviderGlue::s_factorymap.end())
|
|
{
|
|
pRet = mapIter->second;
|
|
}
|
|
else
|
|
{
|
|
LogErrorMessage2(L"Can't find factory in map: %p", pGlue);
|
|
}
|
|
}
|
|
catch( ... )
|
|
{
|
|
UnlockFactoryMap();
|
|
throw;
|
|
}
|
|
|
|
UnlockFactoryMap();
|
|
return pRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CWbemProviderGlue::AddFlushPtr
|
|
//
|
|
// Add the this pointer to a provider to the list of providers
|
|
// that need to be flushed.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
void CWbemProviderGlue::AddFlushPtr(LPVOID pVoid)
|
|
{
|
|
CLockWrapper lockwrap(m_csFlushPtrs);
|
|
|
|
m_FlushPtrs.insert(pVoid);
|
|
}
|