mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1042 lines
30 KiB
1042 lines
30 KiB
//***************************************************************************
|
|
|
|
//
|
|
|
|
// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
|
|
//
|
|
// Provider.CPP
|
|
//
|
|
// Purpose: Implementation of Provider class
|
|
//
|
|
//***************************************************************************
|
|
|
|
#include "precomp.h"
|
|
#include <assertbreak.h>
|
|
#include <objpath.h>
|
|
#include <cominit.h>
|
|
#include <brodcast.h>
|
|
#include <createmutexasprocess.h>
|
|
#include <stopwatch.h>
|
|
#include <SmartPtr.h>
|
|
#include <frqueryex.h>
|
|
#include "FWStrings.h"
|
|
#include "MultiPlat.h"
|
|
|
|
// Must instantiate static members
|
|
CHString Provider::s_strComputerName;
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: Provider ctor
|
|
//
|
|
//
|
|
//
|
|
// Inputs: name of this provider
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments: suggest that derived classes implement their provider's ctor thusly:
|
|
//
|
|
// MyProvider::MyProvider(const CHString& setName) :
|
|
// Provider(setName)
|
|
//
|
|
// that way, a *further* derived class can specify its own name
|
|
//
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
Provider::Provider( LPCWSTR a_setName, LPCWSTR a_pszNameSpace /*=NULL*/ )
|
|
: CThreadBase(),
|
|
m_pIMosProvider( NULL ),
|
|
m_piClassObject( NULL ),
|
|
m_name( a_setName ),
|
|
m_strNameSpace( a_pszNameSpace )
|
|
{
|
|
// Initialize the computer name, then register with the framework.
|
|
|
|
InitComputerName();
|
|
|
|
CWbemProviderGlue::FrameworkLogin( a_setName, this, a_pszNameSpace );
|
|
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: Provider dtor
|
|
//
|
|
//
|
|
//
|
|
// Inputs: none.
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments: cleans up our pointer to the IMosProvider
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
Provider::~Provider( void )
|
|
{
|
|
// get out of the framework's hair
|
|
CWbemProviderGlue::FrameworkLogoff( (LPCWSTR)m_name, (LPCWSTR)m_strNameSpace );
|
|
|
|
// we can't release the interfaces here because CIMOM has a habit
|
|
// of shutting down when it still has interface pointers open.
|
|
/********************
|
|
// Release the pointer returned to us by GetNamespaceConnection(), which
|
|
// will return us an AddRefed pointer.
|
|
|
|
if ( NULL != m_pIMosProvider )
|
|
{
|
|
m_pIMosProvider->Release();
|
|
}
|
|
|
|
// The class object is returned to us by IMOSProvider::GetObject, so
|
|
// we should try to release it here when we're done with it.
|
|
|
|
if ( NULL != m_piClassObject )
|
|
{
|
|
m_piClassObject->Release();
|
|
}
|
|
******************************/
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: Provider::InitComputerName
|
|
//
|
|
// Initializes our static computer name variable.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: None.
|
|
//
|
|
// Return: None.
|
|
//
|
|
// Comments: Because the idea behind creating providers is that
|
|
// a single static instance is instantiated, this function
|
|
// will most likely be called as part of DLL loading, we'll
|
|
// introduce some thread safety here using a named mutex
|
|
// but won't worry too much about it other than that.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
void Provider::InitComputerName( void )
|
|
{
|
|
// For performance, check if the value is empty. Only if it
|
|
// is, should we then bother with going through a thread-safe
|
|
// static initialization. Because we are using a named mutex,
|
|
// multiple threads will get the same kernel object, and will
|
|
// be stop-gapped by the OS as they each acquire the mutex
|
|
// in turn.
|
|
|
|
if ( s_strComputerName.IsEmpty() )
|
|
{
|
|
CreateMutexAsProcess createMutexAsProcess(WBEMPROVIDERSTATICMUTEX);
|
|
|
|
// Double check in case there was a conflict and somebody else
|
|
// got here first.
|
|
|
|
if ( s_strComputerName.IsEmpty() )
|
|
{
|
|
DWORD dwBuffSize = MAX_COMPUTERNAME_LENGTH + 1;
|
|
|
|
// Make sure the string buffer will be big enough to handle the
|
|
// value.
|
|
|
|
LPWSTR pszBuffer = s_strComputerName.GetBuffer( dwBuffSize );
|
|
|
|
if ( NULL != pszBuffer )
|
|
{
|
|
// Now grab the computer name and release the buffer, forcing
|
|
// it to reallocate itself to the new length.
|
|
|
|
if (!FRGetComputerName( pszBuffer, &dwBuffSize )) {
|
|
wcscpy(pszBuffer, L"DEFAULT");
|
|
}
|
|
s_strComputerName.ReleaseBuffer();
|
|
} // IF NULL != pszBuffer
|
|
|
|
} // IF strComputerName.IsEmpty()
|
|
|
|
} // IF strComputerName.IsEmpty()
|
|
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: Flush
|
|
//
|
|
// flushes out all unnecessary memory usage
|
|
// inlcuding the (unimplemented) cache
|
|
// and the class object we clone from
|
|
//
|
|
// Inputs: nope
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return: the eternal void
|
|
//
|
|
// Comments:
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
void Provider::Flush()
|
|
{
|
|
// TODO: implement cache flush
|
|
BeginWrite();
|
|
|
|
try
|
|
{
|
|
if (m_piClassObject)
|
|
{
|
|
m_piClassObject->Release();
|
|
m_piClassObject = NULL;
|
|
}
|
|
|
|
if ( NULL != m_pIMosProvider )
|
|
{
|
|
m_pIMosProvider->Release();
|
|
m_pIMosProvider = NULL;
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
EndWrite();
|
|
throw;
|
|
}
|
|
EndWrite();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: ValidateIMOSPointer
|
|
//
|
|
// Verifies in a threadsafe manner, that our IWBEMServices pointer
|
|
// is okay.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return: TRUE/FALSE success/failure
|
|
//
|
|
// Comments: Requires that our NameSpace be valid.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL Provider::ValidateIMOSPointer( )
|
|
{
|
|
|
|
// if we don't have a Namespace connection, get one. Be aware that for
|
|
// speed's sake we are testing the value outside of a critical section, but
|
|
// because two threads may enter this block of code simultaneously, this
|
|
// block is testing one more time inside the critical sections.
|
|
|
|
// if ( NULL == m_pIMosProvider )
|
|
// {
|
|
// BeginWrite();
|
|
//
|
|
// try
|
|
// {
|
|
//
|
|
// // See above (it's a redundant test), but keeps us from leaking and
|
|
// // overwriting the value twice.
|
|
//
|
|
// if ( NULL == m_pIMosProvider )
|
|
// {
|
|
// m_pIMosProvider = CWbemProviderGlue::GetNamespaceConnection( m_strNameSpace, pwszIID );
|
|
// }
|
|
// }
|
|
// catch ( ... )
|
|
// {
|
|
// EndWrite();
|
|
// throw;
|
|
// }
|
|
//
|
|
// EndWrite();
|
|
// }
|
|
//
|
|
// if (m_pIMosProvider == NULL)
|
|
// {
|
|
// throw CFramework_Exception(L"ValidateIMOSPointer failed");
|
|
// }
|
|
//
|
|
// return ( NULL != m_pIMosProvider );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CreateNewInstance
|
|
//
|
|
//
|
|
//
|
|
// Inputs: MethodContext* - context that this instance belongs to
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return: CInstance*
|
|
//
|
|
// Comments: caller is responsible for memory
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
CInstance* Provider::CreateNewInstance( MethodContext* pMethodContext )
|
|
{
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
CInstance* pNewInstance = NULL;
|
|
IWbemClassObjectPtr pClassObject (GetClassObjectInterface(pMethodContext), false);
|
|
|
|
IWbemClassObjectPtr piClone;
|
|
hr = pClassObject->SpawnInstance(0, &piClone);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// The Instance is responsible for its own AddRef/Releasing
|
|
pNewInstance = new CInstance(piClone, pMethodContext);
|
|
|
|
if (pNewInstance == NULL)
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
throw CFramework_Exception(L"SpawnInstance failed", hr);
|
|
}
|
|
|
|
|
|
return pNewInstance;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: Commit
|
|
//
|
|
// sends instance to CIMOM
|
|
//
|
|
// Inputs: CInstance* pInstance - the instance to pass off to cimom,
|
|
// bool bCache - should we cache this puppy? (unimplemented)
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments: do not reference pointer once committed, it may not exist any more!
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::Commit(CInstance* pInstance, bool bCache /* = false*/)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR;
|
|
|
|
// allow derived classes to fill out extra info.
|
|
// GetExtendedProperties(pInstance);
|
|
hRes = pInstance->Commit();
|
|
|
|
// TODO: Implement cache
|
|
// if !bCache...
|
|
|
|
// We're done with pInstance, so...
|
|
pInstance->Release();
|
|
|
|
return hRes;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: ExecuteQuery
|
|
//
|
|
//
|
|
//
|
|
// Inputs: IWbemContext __RPC_FAR * pCtx,
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return: HRESULT
|
|
//
|
|
// Comments: Calls a provider's ExecQuery function, or returns
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::ExecuteQuery( MethodContext* pContext, CFrameworkQuery& pQuery, long lFlags /*= 0L*/ )
|
|
{
|
|
HRESULT hr = ValidateQueryFlags(lFlags);
|
|
|
|
// Make sure we've got Managed Object Services avaliable, as we will need
|
|
// it to get WBEMClassObjects for constructing Instances.
|
|
|
|
if ( SUCCEEDED(hr) && ValidateIMOSPointer( ) )
|
|
{
|
|
// Check to see if this is an extended query
|
|
CFrameworkQueryEx *pQuery2 = static_cast <CFrameworkQueryEx*>(&pQuery);
|
|
if (pQuery2->IsExtended())
|
|
{
|
|
// It is an extended query. Does the provider support them?
|
|
if (FAILED(ValidateQueryFlags(WBEM_FLAG_FORWARD_ONLY)))
|
|
{
|
|
// We have an extended query, but the provider doesn't support it
|
|
hr = WBEM_E_INVALID_QUERY;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Tell cimom he's got work to do on the instances when we send
|
|
// them back.
|
|
pContext->QueryPostProcess();
|
|
|
|
// If the client hasn't overridden the class, we get back
|
|
// WBEM_E_PROVIDER_NOT_CAPABLE. In that case, call the enumerate, and let
|
|
// CIMOM do the work
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::ProviderTimer);
|
|
hr = ExecQuery(pContext, pQuery, lFlags);
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::FrameworkTimer);
|
|
|
|
if (hr == WBEM_E_PROVIDER_NOT_CAPABLE)
|
|
{
|
|
// Get the instances
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::ProviderTimer);
|
|
hr = CreateInstanceEnum(pContext, lFlags);
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::FrameworkTimer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_QUERY;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: CreateInstanceEnum
|
|
//
|
|
//
|
|
//
|
|
// Inputs: IWbemContext __RPC_FAR * pCtx,
|
|
// IWbemObjectSink __RPC_FAR * pResponseHandler
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments: enumerate all instances of this class
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::CreateInstanceEnum( MethodContext* pContext, long lFlags /*= 0L*/ )
|
|
{
|
|
HRESULT sc = ValidateEnumerationFlags(lFlags);
|
|
|
|
// Make sure we've got Managed Object Services avaliable, as we will need
|
|
// it to get WBEMClassObjects for constructing Instances.
|
|
|
|
if ( SUCCEEDED(sc) && ValidateIMOSPointer( ) )
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::ProviderTimer);
|
|
sc = EnumerateInstances( pContext, lFlags );
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::FrameworkTimer);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: PutInstance
|
|
//
|
|
// CIMOM wants us to put this instance.
|
|
//
|
|
// Inputs:
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments:
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::PutInstance(const CInstance& newInstance, long lFlags /*= 0L*/)
|
|
{
|
|
return WBEM_E_PROVIDER_NOT_CAPABLE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: PutInstance
|
|
//
|
|
// CIMOM wants us to put this instance.
|
|
//
|
|
// Inputs:
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments:
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::PutInstance( IWbemClassObject __RPC_FAR *pInst,
|
|
long lFlags,
|
|
MethodContext* pContext )
|
|
{
|
|
HRESULT scode = ValidatePutInstanceFlags(lFlags);
|
|
|
|
// No need to AddRef()/Release() pInst here, since we're just
|
|
// passing it into the CInstance object, which should take
|
|
// care of that for us internally.
|
|
|
|
if (SUCCEEDED(scode))
|
|
{
|
|
CInstancePtr pInstance (new CInstance( pInst, pContext ), false);
|
|
|
|
if ( NULL != pInstance )
|
|
{
|
|
scode = PutInstance(*pInstance, lFlags);
|
|
}
|
|
else
|
|
{
|
|
throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
|
|
}
|
|
}
|
|
|
|
return scode;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: DeleteInstance
|
|
//
|
|
// CIMOM wants us to delete this instance.
|
|
//
|
|
// Inputs:
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments:
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::DeleteInstance(const CInstance& newInstance, long lFlags /*= 0L*/)
|
|
{
|
|
return WBEM_E_PROVIDER_NOT_CAPABLE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: DeleteInstance
|
|
//
|
|
// CIMOM wants us to put this instance.
|
|
//
|
|
// Inputs:
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments:
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::DeleteInstance( ParsedObjectPath* pParsedObjectPath,
|
|
long lFlags,
|
|
MethodContext* pContext )
|
|
{
|
|
HRESULT sc = ValidateDeletionFlags(lFlags);
|
|
|
|
// Make sure we've got Managed Object Services avaliable, as we will
|
|
// need it in order to create a brand new instance.
|
|
|
|
if ( SUCCEEDED(sc) && ValidateIMOSPointer( ) )
|
|
{
|
|
CInstancePtr pInstance (CreateNewInstance( pContext ), false);
|
|
|
|
// Load up the instance keys
|
|
if ( SetKeyFromParsedObjectPath( pInstance, pParsedObjectPath ) )
|
|
{
|
|
sc = DeleteInstance(*pInstance, lFlags);
|
|
}
|
|
else
|
|
{
|
|
sc = WBEM_E_INVALID_OBJECT_PATH;
|
|
}
|
|
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: ExecMethod
|
|
//
|
|
// CIMOM wants us to execute this method on this instance
|
|
//
|
|
// Inputs:
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments:
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::ExecMethod(const CInstance& pInstance,
|
|
BSTR bstrMethodName,
|
|
CInstance *pInParams,
|
|
CInstance *pOutParams,
|
|
long lFlags /*= 0L*/)
|
|
{
|
|
return WBEM_E_PROVIDER_NOT_CAPABLE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: ExecMethod
|
|
//
|
|
// CIMOM wants us to Execute this method on this instance
|
|
//
|
|
// Inputs:
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments:
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::ExecMethod( ParsedObjectPath *pParsedObjectPath,
|
|
BSTR bstrMethodName,
|
|
long lFlags,
|
|
CInstance *pInParams,
|
|
CInstance *pOutParams,
|
|
MethodContext *pContext )
|
|
{
|
|
HRESULT sc = ValidateMethodFlags(lFlags);
|
|
|
|
// Make sure we've got Managed Object Services avaliable, as we will
|
|
// need it in order to create a brand new instance.
|
|
|
|
if ( SUCCEEDED(sc) && ValidateIMOSPointer( ) )
|
|
{
|
|
|
|
CInstancePtr pInstance(CreateNewInstance( pContext ), false);
|
|
|
|
if ( SetKeyFromParsedObjectPath( pInstance, pParsedObjectPath ) )
|
|
{
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::ProviderTimer);
|
|
sc = ExecMethod(*pInstance, bstrMethodName, pInParams, pOutParams, lFlags);
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::FrameworkTimer);
|
|
}
|
|
else
|
|
{
|
|
sc = WBEM_E_INVALID_OBJECT_PATH;
|
|
}
|
|
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: GetObject
|
|
//
|
|
// called by the framework in response to a GetObject from CIMOM
|
|
//
|
|
// Inputs: ParsedObjectPath* pParsedObjectPath - All the news
|
|
// thats fit to print.
|
|
// IWbemContext __RPC_FAR* pCtx
|
|
// IWbemObjectSink __RPC_FAR*pResponseHandler
|
|
//
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return:
|
|
//
|
|
// Comments:
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT Provider::GetObject( ParsedObjectPath *pParsedObjectPath,
|
|
MethodContext *pContext,
|
|
long lFlags /*= 0L*/ )
|
|
{
|
|
HRESULT hr = ValidateGetObjFlags(lFlags);
|
|
|
|
// Make sure we've got Managed Object Services avaliable, as we will
|
|
// need it in order to create a brand new instance.
|
|
|
|
if ( SUCCEEDED(hr) && ValidateIMOSPointer( ) )
|
|
{
|
|
CInstancePtr pInstance (CreateNewInstance( pContext ), false);
|
|
|
|
// Load up the instance keys
|
|
if ( SetKeyFromParsedObjectPath( pInstance, pParsedObjectPath ) )
|
|
{
|
|
// Look for per-property gets
|
|
IWbemContextPtr pWbemContext (pContext->GetIWBEMContext(), false);
|
|
|
|
CFrameworkQueryEx CQuery;
|
|
hr = CQuery.Init(pParsedObjectPath, pWbemContext, GetProviderName(), m_strNameSpace);
|
|
|
|
// Note that 'SUCCEEDED' DOESN'T mean that we have per-property gets. It
|
|
// just means that the query object was successfully initialized.
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Fill in key properties on query object
|
|
IWbemClassObjectPtr pWbemClassObject(pInstance->GetClassObjectInterface(), false);
|
|
CQuery.Init2(pWbemClassObject);
|
|
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::ProviderTimer);
|
|
hr = GetObject(pInstance, lFlags, CQuery);
|
|
PROVIDER_INSTRUMENTATION_START(pContext, StopWatch::FrameworkTimer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_OBJECT_PATH;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Account for the possibility that we have a SUCCESS code back from GetObject.
|
|
HRESULT hRes = pInstance->Commit();
|
|
hr = __max((ULONG)hRes, (ULONG)hr);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: Provider::GetInstancePath
|
|
//
|
|
// Attempts to build an instance path for the supplied CInstance pointer.
|
|
//
|
|
// Inputs: const CInstance* pInstance - Instance to build path for.
|
|
//
|
|
// Outputs: CHString& strPath - Path from instance.
|
|
//
|
|
// Return: BOOL Success/Failure.
|
|
//
|
|
// Comments: This function was created to help support the internal
|
|
// short circuit we performed for obtaining local WBEM
|
|
// Provider objects. In this instance, we will use our
|
|
// computer system name, namespace and instance relative
|
|
// path to munge together a full WBEM Object Path. This
|
|
// is because only CIMOM objects will have this value set
|
|
// and when we perform our short circuit, we cut CIMOM
|
|
// out of the loop, so our instances don't have full
|
|
// object paths. This mostly helps out our association
|
|
// logic, although a weakness of this solution is that
|
|
// if the path that gets stored by CIMOM changes, we
|
|
// will then need to change this function.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
bool Provider::GetLocalInstancePath( const CInstance *pInstance,
|
|
CHString& strPath )
|
|
{
|
|
bool fReturn = false;
|
|
CHString strRelativePath;
|
|
|
|
if (pInstance && pInstance->GetCHString( L"__RELPATH", strRelativePath ) )
|
|
{
|
|
// We may want to use the OBJPath classes to piece this
|
|
// together for us at a later time.
|
|
|
|
strPath = MakeLocalPath(strRelativePath);
|
|
|
|
fReturn = true;
|
|
}
|
|
|
|
return fReturn;
|
|
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: Provider::MakeLocalPath
|
|
//
|
|
// Builds a full instance path from a relative path
|
|
//
|
|
// Inputs: const CHString &strRelPath - Relative path
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return: CHString& strPath - Path
|
|
//
|
|
// Comments: Consider using GetLocalInstance path before using
|
|
// this function.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
CHString Provider::MakeLocalPath( const CHString &strRelPath )
|
|
{
|
|
|
|
ASSERT_BREAK( (strRelPath.Find(L':') == -1) || ((strRelPath.Find(L'=') != -1) && (strRelPath.Find(L':') >= strRelPath.Find(L'=')) ));
|
|
|
|
CHString sBase;
|
|
|
|
sBase.Format(L"\\\\%s\\%s:%s",
|
|
(LPCWSTR)s_strComputerName,
|
|
m_strNameSpace.IsEmpty() ? DEFAULT_NAMESPACE: (LPCWSTR) m_strNameSpace,
|
|
(LPCWSTR)strRelPath);
|
|
|
|
return sBase;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: SetKeyFromParsedObjectPath
|
|
//
|
|
// called by the DeleteInstance and GetObject in order to load a
|
|
// CInstance* with the key values in an object path.
|
|
//
|
|
// Inputs: CInstance* pInstance - Instance to store
|
|
// key values in.
|
|
// ParsedObjectPath* pParsedObjectPath - All the news
|
|
// thats fit to print.
|
|
//
|
|
//
|
|
// Outputs:
|
|
//
|
|
// Return: BOOL Success/Failure
|
|
//
|
|
// Comments:
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL Provider::SetKeyFromParsedObjectPath( CInstance *pInstance,
|
|
ParsedObjectPath *pParsedPath )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
SAFEARRAY *pNames = NULL;
|
|
long lLBound, lUBound;
|
|
|
|
// populate instance - This exact same routine is in wbemglue.cpp. Changes here should be
|
|
// reflected there (or someone should move these two somewhere else. instance.cpp?).
|
|
for (DWORD i = 0; fReturn && i < (pParsedPath->m_dwNumKeys); i++)
|
|
{
|
|
if (pParsedPath->m_paKeys[i])
|
|
{
|
|
// If a name was specified in the form class.keyname=value
|
|
if (pParsedPath->m_paKeys[i]->m_pName != NULL)
|
|
{
|
|
fReturn = pInstance->SetVariant(pParsedPath->m_paKeys[i]->m_pName, pParsedPath->m_paKeys[i]->m_vValue);
|
|
}
|
|
else
|
|
{
|
|
// There is a special case that you can say class=value
|
|
fReturn = FALSE;
|
|
|
|
// only one key allowed in the format. Check the names on the path
|
|
if (pParsedPath->m_dwNumKeys == 1)
|
|
{
|
|
|
|
// Get the names from the object
|
|
if (m_piClassObject->GetNames(NULL, WBEM_FLAG_KEYS_ONLY, NULL, &pNames) == WBEM_S_NO_ERROR)
|
|
{
|
|
BSTR t_bstrName = NULL ;
|
|
|
|
try
|
|
{
|
|
SafeArrayGetLBound(pNames, 1, &lLBound);
|
|
SafeArrayGetUBound(pNames, 1, &lUBound);
|
|
|
|
// Only one key?
|
|
if ((lUBound - lLBound) == 0)
|
|
{
|
|
// Get the name of the key field and set it
|
|
SafeArrayGetElement(pNames, &lUBound, &t_bstrName );
|
|
|
|
fReturn = pInstance->SetVariant( t_bstrName, pParsedPath->m_paKeys[i]->m_vValue);
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
if( NULL != t_bstrName )
|
|
{
|
|
SysFreeString( t_bstrName ) ;
|
|
}
|
|
|
|
SafeArrayDestroy(pNames);
|
|
throw;
|
|
}
|
|
|
|
SafeArrayDestroy(pNames);
|
|
}
|
|
}
|
|
ASSERT_BREAK(fReturn); // somebody lied about the number of keys or the datatype was wrong
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT_BREAK(0); // somebody lied about the number of keys!
|
|
fReturn = FALSE;
|
|
}
|
|
}
|
|
|
|
return fReturn;
|
|
}
|
|
|
|
// sets the CreationClassName to the name of this provider
|
|
bool Provider::SetCreationClassName(CInstance* pInstance)
|
|
{
|
|
if (pInstance)
|
|
{
|
|
return pInstance->SetCHString(IDS_CreationClassName, m_name);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// flag validation - returns WBEM_E_UNSUPPORTED parameter if
|
|
// lFlags contains any flags not found in lAcceptableFlags
|
|
HRESULT Provider::ValidateFlags(long lFlags, FlagDefs lAcceptableFlags)
|
|
{
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
// invert the acceptable flags, which then are the UNacceptable flags
|
|
if (lFlags & ~((long)lAcceptableFlags))
|
|
hr = WBEM_E_UNSUPPORTED_PARAMETER;
|
|
else
|
|
hr = WBEM_S_NO_ERROR;
|
|
|
|
return hr;
|
|
}
|
|
// base level validation routines
|
|
// you can override these in order to support a flag
|
|
// that is unknown to the base class
|
|
HRESULT Provider::ValidateEnumerationFlags(long lFlags)
|
|
{
|
|
return ValidateFlags(lFlags, EnumerationFlags);
|
|
}
|
|
HRESULT Provider::ValidateGetObjFlags(long lFlags)
|
|
{
|
|
return ValidateFlags(lFlags, GetObjFlags);
|
|
}
|
|
HRESULT Provider::ValidateMethodFlags(long lFlags)
|
|
{
|
|
return ValidateFlags(lFlags, MethodFlags);
|
|
}
|
|
HRESULT Provider::ValidateQueryFlags(long lFlags)
|
|
{
|
|
return ValidateFlags(lFlags, QueryFlags);
|
|
}
|
|
HRESULT Provider::ValidateDeletionFlags(long lFlags)
|
|
{
|
|
return ValidateFlags(lFlags, DeletionFlags);
|
|
}
|
|
HRESULT Provider::ValidatePutInstanceFlags(long lFlags)
|
|
{
|
|
return ValidateFlags(lFlags, PutInstanceFlags);
|
|
}
|
|
|
|
IWbemClassObject* Provider::GetClassObjectInterface(MethodContext *pMethodContext)
|
|
{
|
|
IWbemClassObject *pObject = NULL;
|
|
|
|
if (ValidateIMOSPointer())
|
|
{
|
|
BOOL bWriting = TRUE;
|
|
BeginWrite();
|
|
|
|
try
|
|
{
|
|
if ( NULL == m_piClassObject )
|
|
{
|
|
bWriting = FALSE;
|
|
|
|
//calling back into winmgmt - no critsec!
|
|
EndWrite();
|
|
|
|
IWbemContextPtr pWbemContext;
|
|
|
|
if ( NULL != pMethodContext )
|
|
{
|
|
pWbemContext.Attach(pMethodContext->GetIWBEMContext());
|
|
}
|
|
|
|
IWbemServicesPtr pServices(CWbemProviderGlue::GetNamespaceConnection( m_strNameSpace, pMethodContext ), false);
|
|
|
|
|
|
HRESULT hr = pServices->GetObject( bstr_t( m_name ), 0L, pWbemContext, &pObject, NULL);
|
|
|
|
BeginWrite();
|
|
bWriting = TRUE;
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (m_piClassObject == NULL)
|
|
{
|
|
m_piClassObject = pObject;
|
|
pObject->AddRef();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// belt & suspenders check. Won't hurt.
|
|
m_piClassObject = NULL;
|
|
|
|
throw CFramework_Exception(L"SpawnInstance failed", hr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pObject = m_piClassObject;
|
|
pObject->AddRef();
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
if (bWriting)
|
|
{
|
|
EndWrite();
|
|
}
|
|
|
|
if (pObject)
|
|
{
|
|
pObject->Release();
|
|
pObject = NULL;
|
|
}
|
|
|
|
throw;
|
|
}
|
|
|
|
EndWrite();
|
|
}
|
|
|
|
return pObject;
|
|
}
|
|
|
|
// If a provider wants to process queries, they should override this
|
|
HRESULT Provider::ExecQuery(MethodContext *pMethodContext, CFrameworkQuery& pQuery, long lFlags /*= 0L*/)
|
|
{
|
|
return WBEM_E_PROVIDER_NOT_CAPABLE;
|
|
}
|
|
|
|
// find and create all instances of your class
|
|
HRESULT Provider::EnumerateInstances(MethodContext* pMethodContext, long lFlags /*= 0L*/)
|
|
{
|
|
return WBEM_E_PROVIDER_NOT_CAPABLE;
|
|
}
|
|
|
|
// you will be given an object with the key properties filled in.
|
|
// you need to fill in all of the rest of the properties
|
|
HRESULT Provider::GetObject(CInstance* pInstance, long lFlags /*= 0L*/)
|
|
{
|
|
return WBEM_E_PROVIDER_NOT_CAPABLE;
|
|
}
|
|
|
|
// You will be given an object with the key properties filled in.
|
|
// You can either fill in all the properties, or check the Query object
|
|
// to see what properties are required.
|
|
HRESULT Provider::GetObject(CInstance *pInstance, long lFlags, CFrameworkQuery &Query)
|
|
{
|
|
// If we are here, the provider didn't override this method. Fall back to the older
|
|
// call.
|
|
return GetObject(pInstance, lFlags);
|
|
}
|
|
|