//=============================================================================
//
// Copyright (c) 1996-1999, Microsoft Corporation, All rights reserved
//
// NSREP.CPP
//
// See nsrep.h for documentation
//
// History:
//
//=============================================================================
#include "precomp.h"
#include <stdio.h>
#include "ess.h"
#include "esssink.h"
#include "permbind.h"
#include "aggreg.h"
#include "persistcfg.h"
#include "WinMgmtR.h"
#include <ql.h>
#include <cominit.h>
#include <genutils.h>
#include "NCEvents.h" // For the non-COM event stuff
#include <tempbind.h>
#include <wbemutil.h>
#include <tchar.h>
long g_lNumNamespaces = 0;
long g_lNumInternalTempSubscriptions = 0;
long g_lNumTempSubscriptions = 0;
#define ENSURE_INITIALIZED \
hres = EnsureInitPending(); \
if ( FAILED(hres) ) \
return hres; \
hres = WaitForInitialization(); \
if ( FAILED(hres) ) \
return hres; \
CInUpdate iu(this);
// The use of this pointer to initialize parent class is valid in this context
#pragma warning(disable : 4355)
class CEnumSink : public CObjectSink
{
protected:
CEssNamespace* m_pNamespace;
HANDLE m_hEvent;
CEssThreadObject* m_pThreadObj;
public:
CEnumSink(CEssNamespace* pNamespace)
: m_pNamespace(pNamespace),
m_hEvent(CreateEvent(NULL, FALSE, FALSE, NULL)),
m_pThreadObj(GetCurrentEssThreadObject())
{}
~CEnumSink(){SetEvent(m_hEvent);}
void ReleaseAndWait()
{
HANDLE h = m_hEvent;
Release();
WaitForSingleObject(h, INFINITE);
CloseHandle(h);
}
virtual HRESULT Process(IWbemClassObject* pObj) = 0;
STDMETHOD(Indicate)(long lNumObjects, IWbemClassObject** apObjects)
{
SetConstructedEssThreadObject(m_pThreadObj);
for(int i = 0; i < lNumObjects; i++)
Process(apObjects[i]);
return S_OK;
}
STDMETHOD(SetStatus)(long, HRESULT, BSTR, IWbemClassObject*)
{
return S_OK;
}
};
class CFilterEnumSink : public CEnumSink
{
public:
CFilterEnumSink(CEssNamespace* pNamespace) : CEnumSink(pNamespace){}
virtual HRESULT Process(IWbemClassObject* pObj)
{
return m_pNamespace->AddEventFilter(pObj, TRUE);
}
};
class CConsumerEnumSink : public CEnumSink
{
public:
CConsumerEnumSink(CEssNamespace* pNamespace) : CEnumSink(pNamespace){}
virtual HRESULT Process(IWbemClassObject* pObj)
{
return m_pNamespace->AddEventConsumer(pObj, 0, TRUE);
}
};
class CBindingEnumSink : public CEnumSink
{
public:
CBindingEnumSink(CEssNamespace* pNamespace) : CEnumSink(pNamespace){}
virtual HRESULT Process(IWbemClassObject* pObj)
{
return m_pNamespace->AddBinding(pObj);
}
};
#ifdef __WHISTLER_UNCUT
class CMonitorEnumSink : public CEnumSink
{
public:
CMonitorEnumSink(CEssNamespace* pNamespace) : CEnumSink(pNamespace){}
virtual HRESULT Process(IWbemClassObject* pObj)
{
return m_pNamespace->AddMonitor(pObj);
}
};
#endif
class CPostponedReleaseRequest : public CPostponedRequest
{
protected:
IUnknown* m_pUnk;
public:
CPostponedReleaseRequest(IUnknown* pToRelease) : m_pUnk(pToRelease)
{
try
{
if(m_pUnk)
m_pUnk->AddRef();
}
catch(...)
{
}
}
HRESULT Execute(CEssNamespace* pNamespace)
{
try
{
if(m_pUnk)
m_pUnk->Release();
}
catch(...)
{
}
return WBEM_S_NO_ERROR;
}
~CPostponedReleaseRequest()
{
try
{
if(m_pUnk)
m_pUnk->Release();
}
catch(...)
{
}
}
};
class CPostponedRegisterNotificationSinkRequest : public CPostponedRequest
{
protected:
WString m_wsQuery;
WString m_wsQueryLanguage;
DWORD m_lFlags;
DWORD m_dwQosFlags;
CWbemPtr<IWbemObjectSink> m_pSink;
CWbemPtr<CEssNamespace> m_pNamespace;
CNtSid m_OwnerSid;
public:
HRESULT SetRegistration( CEssNamespace* pNamespace,
LPCWSTR wszQueryLanguage,
LPCWSTR wszQuery,
long lFlags,
DWORD dwQosFlags,
IWbemObjectSink* pSink,
PSID pOwnerSid )
{
m_pSink = pSink;
m_lFlags = lFlags;
m_dwQosFlags = dwQosFlags;
m_pNamespace = pNamespace;
try
{
m_wsQuery = wszQuery;
m_wsQueryLanguage = wszQueryLanguage;
m_OwnerSid = CNtSid(pOwnerSid);
}
catch( CX_MemoryException )
{
return WBEM_E_OUT_OF_MEMORY;
}
return WBEM_S_NO_ERROR;
}
HRESULT Execute( CEssNamespace* pNamespace )
{
HRESULT hr;
//
// we must set up a new thread object and then restore the
// old one where we're done. Reason for this is that we don't
// want our call into the other namespace to affect the postponed
// list of this one.
//
CEssThreadObject* pOldThreadObject = GetCurrentEssThreadObject();
SetCurrentEssThreadObject(NULL);
if ( GetCurrentEssThreadObject() == NULL )
{
return WBEM_E_OUT_OF_MEMORY;
}
{
CInUpdate iu( m_pNamespace );
hr = m_pNamespace->InternalRegisterNotificationSink(
m_wsQueryLanguage,
m_wsQuery,
m_lFlags,
WMIMSG_QOS_FLAG(m_dwQosFlags),
NULL,
m_pSink,
TRUE,
m_OwnerSid.GetPtr() );
}
if ( SUCCEEDED(hr) )
{
hr = m_pNamespace->FirePostponedOperations();
}
else
{
m_pNamespace->FirePostponedOperations();
}
delete GetCurrentEssThreadObject();
SetConstructedEssThreadObject( pOldThreadObject );
return hr;
}
};
class CPostponedRemoveNotificationSinkRequest : public CPostponedRequest
{
protected:
CWbemPtr<IWbemObjectSink> m_pSink;
CWbemPtr<CEssNamespace> m_pNamespace;
public:
CPostponedRemoveNotificationSinkRequest( CEssNamespace* pNamespace,
IWbemObjectSink* pSink )
: m_pSink( pSink ), m_pNamespace( pNamespace ) { }
HRESULT Execute( CEssNamespace* pNamespace )
{
HRESULT hr;
//
// we must set up a new thread object and then restore the
// old one where we're done. Reason for this is that we don't
// want our call into the other namespace to affect the postponed
// list of this one.
//
CEssThreadObject* pOldThreadObject = GetCurrentEssThreadObject();
SetCurrentEssThreadObject(NULL);
if ( GetCurrentEssThreadObject() == NULL )
{
return WBEM_E_OUT_OF_MEMORY;
}
{
CInUpdate iu( m_pNamespace );
hr = m_pNamespace->InternalRemoveNotificationSink( m_pSink );
}
if ( SUCCEEDED(hr) )
{
hr = m_pNamespace->FirePostponedOperations();
}
else
{
m_pNamespace->FirePostponedOperations();
}
delete GetCurrentEssThreadObject();
SetConstructedEssThreadObject( pOldThreadObject );
return hr;
}
};
//******************************************************************************
// public
//
// See ess.h for documentation
//
//******************************************************************************
CEssNamespace::CEssNamespace(CEss* pEss) :
m_ClassDeletionSink(this), m_bInResync(FALSE),
m_Bindings(this), m_hInitComplete(INVALID_HANDLE_VALUE),
m_EventProviderCache(this), m_Poller(this),
m_ConsumerProviderCache(this), m_hresInit(WBEM_E_CRITICAL_ERROR),
m_ClassCache(this), m_eState(e_Quiet),
m_pMonitorProvider(NULL), m_pCoreEventProvider(NULL),
m_pEss(pEss), m_wszName(NULL), m_pCoreSvc(NULL), m_pFullSvc(NULL),
m_lRef(0), m_pInternalCoreSvc(NULL), m_pInternalFullSvc(NULL),
m_pProviderFactory(NULL), m_bStage1Complete(FALSE)
{
PSID pRawSid;
SID_IDENTIFIER_AUTHORITY id = SECURITY_NT_AUTHORITY;
g_lNumNamespaces++;
if(AllocateAndInitializeSid( &id, 2,
SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
0,0,0,0,0,0,&pRawSid))
{
m_sidAdministrators = CNtSid(pRawSid);
// We're done with this
FreeSid( pRawSid );
}
}
ULONG CEssNamespace::AddRef()
{
return InterlockedIncrement(&m_lRef);
}
ULONG CEssNamespace::Release()
{
long lRef = InterlockedDecrement(&m_lRef);
if(lRef == 0)
delete this;
return lRef;
}
//
// this function is intended to be called in the same control path as
// the one which constructs the namespace object. Any initialization that
// cannot be defferred is done here.
//
HRESULT CEssNamespace::PreInitialize( LPCWSTR wszName )
{
HRESULT hres;
m_wszName = new WCHAR[wcslen(wszName)+1];
if(m_wszName == NULL)
{
hres = WBEM_E_OUT_OF_MEMORY;
return hres;
}
wcscpy(m_wszName, wszName);
//
// create the event that will be used to signal any threads waiting
// for initialization to finish.
//
m_hInitComplete = CreateEvent( NULL, TRUE, FALSE, NULL );
if ( NULL == m_hInitComplete )
{
return WBEM_E_CRITICAL_ERROR;
}
//
// Obtain repository only service. This is used for acessing all
// static ess objects.
//
hres = m_pEss->GetNamespacePointer( m_wszName, TRUE, &m_pCoreSvc );
if(FAILED(hres))
{
return WBEM_E_INVALID_NAMESPACE; // not there anymore!
}
hres = m_pCoreSvc->QueryInterface( IID_IWbemInternalServices,
(void**)&m_pInternalCoreSvc );
if(FAILED(hres))
{
return WBEM_E_CRITICAL_ERROR;
}
//
// Obtain full service. This is used accessing class objects
// ( which may involve accessing class providers.
//
hres = m_pEss->GetNamespacePointer( m_wszName, FALSE, &m_pFullSvc );
if(FAILED(hres))
{
return WBEM_E_INVALID_NAMESPACE; // not there anymore!
}
hres = m_pFullSvc->QueryInterface( IID_IWbemInternalServices,
(void**)&m_pInternalFullSvc );
if(FAILED(hres))
{
return WBEM_E_CRITICAL_ERROR;
}
//
// Get provider factory
//
hres = m_pEss->GetProviderFactory( m_wszName,
m_pFullSvc,
&m_pProviderFactory);
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS, "No provider factory in %S: 0x%X\n",
m_wszName, hres));
}
//
// we want to ensure that core stays loaded between the PreInitialize()
// call and the Initialize() call. This is only ever an issue when the
// Initialize() call is defferred. Reason to ensure this is because we
// must keep core loaded when we have permanent subscriptions. If we
// haven't initialized yet, then we don't know if we have any. AddRef()
// core here and will then decrement in Initialize() to ensure this.
//
IncrementObjectCount();
//
// Namespace always starts out in the Quiet state. Caller must make
// a MarkAsInitPendingIfQuiet() call if they are going to schedule
// initialization.
//
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::EnsureInitPending()
{
{
CInCritSec ics(&m_csLevel1);
if ( m_eState != e_Quiet )
{
return WBEM_S_FALSE;
}
}
CWbemPtr<CEssNamespace> pNamespace;
return m_pEss->GetNamespaceObject( m_wszName, TRUE, &pNamespace );
}
BOOL CEssNamespace::MarkAsInitPendingIfQuiet()
{
CInCritSec ics( &m_csLevel1 );
if ( m_eState != e_Quiet )
{
return FALSE;
}
m_eState = e_InitializePending;
return TRUE;
};
HRESULT CEssNamespace::Initialize()
{
HRESULT hres;
DEBUGTRACE((LOG_ESS,"Initializing namespace %S\n", m_wszName ));
//
// need to modify level2 members. Grab namespace lock.
//
{
CInUpdate iu(this);
{
CInCritSec ics( &m_csLevel1 );
if ( m_eState == e_Shutdown )
{
return WBEM_E_SHUTTING_DOWN;
}
_DBG_ASSERT( m_eState == e_InitializePending );
}
//
// Load and process subscription objects
//
hres = PerformSubscriptionInitialization();
m_bStage1Complete = TRUE;
}
//
// execute postponed operations outside of namespace lock.
// if some of them fail to execute, it doesn't mean that the namespace
// can't be initialized. just log the error.
//
HRESULT hres2 = FirePostponedOperations();
if ( FAILED(hres2) )
{
ERRORTRACE((LOG_ESS,"Failed to execute postponed operations when "
"performing initialization in namespace %S. HR=0x%x\n",
m_wszName, hres2));
}
return hres;
}
HRESULT CEssNamespace::CompleteInitialization()
{
HRESULT hres;
DEBUGTRACE((LOG_ESS,"Completing Initialization for namespace %S\n",
m_wszName));
//
// need to modify level2 members. Grab namespace lock.
//
{
CInUpdate iu(this);
{
CInCritSec ics( &m_csLevel1 );
if ( m_eState == e_Shutdown )
{
return WBEM_E_SHUTTING_DOWN;
}
_DBG_ASSERT( m_eState == e_InitializePending );
}
//
// load and process all objects that deal with event providers.
//
hres = PerformProviderInitialization();
}
//
// execute postponed operations outside of namespace lock.
// if some of them fail to execute, it doesn't mean that the namespace
// can't be initialized. just log the error.
//
HRESULT hres2 = FirePostponedOperations();
if ( FAILED(hres2) )
{
ERRORTRACE((LOG_ESS,"Failed to execute postponed operations when "
"completing initialization in namespace %S. HR=0x%x\n",
m_wszName, hres2));
}
return hres;
}
void CEssNamespace::MarkAsInitialized( HRESULT hres )
{
//
// we need to grab the level1 critsec here because we're going to be
// modifying the state of the namespace and because we're going to be
// using the defferred events list.
//
CInCritSec ics( &m_csLevel1 );
if ( m_eState == e_Shutdown )
{
return;
}
_DBG_ASSERT( m_eState == e_InitializePending );
//
// transition to Initialized.
//
if ( SUCCEEDED(hres) && m_pCoreEventProvider != NULL )
{
//
// while holding level1, handle any deferred events
//
for( int i=0; i < m_aDeferredEvents.GetSize(); i++ )
{
//
// iterate through 1 by 1 because later we may propagate
// context for each event here.
//
HRESULT hr;
CEventContext Context;
hr = m_pCoreEventProvider->Fire( *m_aDeferredEvents[i], &Context );
if ( FAILED(hr) )
{
ERRORTRACE((LOG_ESS,"Could not fire deferred event in "
"namespace '%S'. HR=0x%x\n", m_wszName, hr ));
}
delete m_aDeferredEvents[i];
}
if ( m_aDeferredEvents.GetSize() > 0 )
{
DEBUGTRACE((LOG_ESS,"Fired %d deferred events after init "
"complete in namespace '%S'.\n",
m_aDeferredEvents.GetSize(),m_wszName));
}
m_aDeferredEvents.RemoveAll();
}
//
// release the ref we were holding to keep core loaded between PreInit()
// and now.
//
DecrementObjectCount();
m_eState = e_Initialized;
m_hresInit = hres;
SetEvent( m_hInitComplete );
}
HRESULT CEssNamespace::WaitForInitialization()
{
HRESULT hres;
//
// The level1 or level2 locks cannot be held when calling this function.
// The reason for this is because we may be we waiting on the initialize
// event.
//
CInCritSec ics(&m_csLevel1);
if ( m_eState == e_Shutdown )
{
return WBEM_E_SHUTTING_DOWN;
}
if ( m_eState == e_Initialized )
{
return m_hresInit;
}
_DBG_ASSERT( m_eState == e_InitializePending );
_DBG_ASSERT( m_hInitComplete != INVALID_HANDLE_VALUE )
//
// wait for initialization to complete.
//
LeaveCriticalSection( &m_csLevel1 );
m_pEss->TriggerDeferredInitialization();
DWORD dwRes = WaitForSingleObject( m_hInitComplete, 20*60*1000 );
EnterCriticalSection( &m_csLevel1 );
if ( dwRes != WAIT_OBJECT_0 )
{
return WBEM_E_CRITICAL_ERROR;
}
return m_hresInit;
}
BOOL CEssNamespace::DoesThreadOwnNamespaceLock()
{
return m_csLevel2.GetLockCount() != -1 &&
m_csLevel2.GetOwningThreadId() == GetCurrentThreadId();
}
void CEssNamespace::LogOp( LPCWSTR wszOp, IWbemClassObject* pObj )
{
if ( LoggingLevelEnabled(2) )
{
_DBG_ASSERT(pObj!=NULL);
BSTR bstrText;
if ( SUCCEEDED(pObj->GetObjectText( 0, &bstrText )) )
{
DEBUGTRACE((LOG_ESS,"%S in namespace %S. Object is %S\n",
wszOp, m_wszName, bstrText ));
SysFreeString( bstrText );
}
}
}
CQueueingEventSink* CEssNamespace::GetQueueingEventSink( LPCWSTR wszSinkName )
{
HRESULT hr;
//
// TODO: For now there is a 1 to 1 mapping between a sink and a consumer.
// ( consumer inherits from queueing sink ). This will not always be
// the case. Here, the sink name is really the standard path to the cons.
//
CEventConsumer* pCons;
hr = m_Bindings.FindEventConsumer( wszSinkName, &pCons );
if ( FAILED(hr) )
{
return NULL;
}
return pCons;
}
//******************************************************************************
// public
//
// See ess.h for documentation
//
//******************************************************************************
BOOL CEssNamespace::IsNeededOnStartup()
{
return m_Bindings.DoesHavePermanentConsumers();
}
void CEssNamespace::SetActive()
{
//
// Inform ESS of our newely active status so that it can make sure
// we are reloaded the next time around
//
m_pEss->SetNamespaceActive(m_wszName);
}
void CEssNamespace::SetInactive()
{
//
// Inform ESS of our newely inactive status so that it does not have to
// reload us the next time around
//
m_pEss->SetNamespaceInactive(m_wszName);
}
//
// This is a quick and dirty shutdown of the namespace that is used when the
// process is shutting down.
//
HRESULT CEssNamespace::Park()
{
// bool bSkipClean = true;
//
// DWORD dwVal = 0;
// Registry r(WBEM_REG_WINMGMT);
//
// if ( r.GetDWORDStr( _TEXT("Force Clean Shutdown"), &dwVal )
// == Registry::no_error)
// {
// bSkipClean = false;
// }
//
// m_Bindings.Clear( bSkipClean );
m_Bindings.Clear( false );
FirePostponedOperations();
return S_OK;
}
//
// This is the slow and clean shutdown that is used when the namespace is
// purged.
//
HRESULT CEssNamespace::Shutdown()
{
{
//
// we want to wait until all update operations have completed, then
// we'll mark the namespace as shutdown.
//
CInUpdate iu(this);
//
// we will also be modifying the level1 members too so need level1
// lock.
//
CInCritSec ics(&m_csLevel1);
m_eState = e_Shutdown;
}
//
// at this point all new calls into the namespace will be rejected.
//
//
// wake up any threads waiting for Initialization.
//
SetEvent( m_hInitComplete );
InternalRemoveNotificationSink(&m_ClassDeletionSink);
m_EventProviderCache.Shutdown();
m_Bindings.Clear( false );
m_Poller.Clear();
m_ConsumerProviderCache.Clear();
FirePostponedOperations();
return WBEM_S_NO_ERROR;
}
CEssNamespace::~CEssNamespace()
{
//
// Do not call shutdown here. Shutdown() is an operation that incurrs
// postponed operations and triggering them to fire here is not usually
// expected by the caller. If the caller wants to call shutdown on their
// own then they are welcome to do so.
//
g_lNumNamespaces--;
delete [] m_wszName;
if(m_pCoreSvc)
m_pCoreSvc->Release();
if(m_pFullSvc)
m_pFullSvc->Release();
if(m_pInternalCoreSvc)
m_pInternalCoreSvc->Release();
if(m_pInternalFullSvc)
m_pInternalFullSvc->Release();
if(m_pProviderFactory)
m_pProviderFactory->Release();
if(m_pCoreEventProvider)
m_pCoreEventProvider->Release();
if(m_pMonitorProvider)
m_pMonitorProvider->Release();
if ( m_hInitComplete != INVALID_HANDLE_VALUE )
CloseHandle( m_hInitComplete );
for( int i=0; i < m_aDeferredEvents.GetSize(); i++ )
delete m_aDeferredEvents[i];
}
HRESULT CEssNamespace::GetNamespacePointer(
RELEASE_ME IWbemServices** ppNamespace)
{
//
// This function returns the full svc pointer for use outside this class.
// We want to ensure that we don't use the full service ptr until we've
// completed stage 1 initialization. Reason is that we don't want to
// load class providers until the second stage of initialization.
//
_DBG_ASSERT( m_bStage1Complete );
if(m_pFullSvc == NULL)
return WBEM_E_CRITICAL_ERROR;
*ppNamespace = m_pFullSvc;
(*ppNamespace)->AddRef();
return S_OK;
}
HRESULT CEssNamespace::ActOnSystemEvent(CEventRepresentation& Event,
long lFlags)
{
HRESULT hres;
// This macro will execute its parameter if updates are allowed at this time on
// this thread, and schedule it otherwise (in the case of an event provider
// calling back
#define PERFORM_IF_ALLOWED(OP) OP
// Check the type
// ==============
if(Event.IsInstanceEvent())
{
// Instance creation, deletion or modification event. Check class
// ==============================================================
if(!wbem_wcsicmp(CLASS_OF(Event), EVENT_FILTER_CLASS))
{
return PERFORM_IF_ALLOWED(ReloadEventFilter(OBJECT_OF(Event)));
}
else if(!wbem_wcsicmp(CLASS_OF(Event), BINDING_CLASS))
{
return PERFORM_IF_ALLOWED(ReloadBinding(OBJECT_OF(Event)));
}
#ifdef __WHISTLER_UNCUT
else if(!wbem_wcsicmp(CLASS_OF(Event), MONITOR_CLASS))
{
return PERFORM_IF_ALLOWED(ReloadMonitor(OBJECT_OF(Event)));
}
#endif
else if(!wbem_wcsicmp(CLASS_OF(Event),
EVENT_PROVIDER_REGISTRATION_CLASS))
{
return PERFORM_IF_ALLOWED(
ReloadEventProviderRegistration(OBJECT_OF(Event)));
}
else if(!wbem_wcsicmp(CLASS_OF(Event),
CONSUMER_PROVIDER_REGISTRATION_CLASS))
{
return PERFORM_IF_ALLOWED(
ReloadConsumerProviderRegistration(OBJECT_OF(Event)));
}
else if(OBJECT_OF(Event)->InheritsFrom(PROVIDER_CLASS) == S_OK)
{
return PERFORM_IF_ALLOWED(ReloadProvider(OBJECT_OF(Event)));
}
else if(OBJECT_OF(Event)->InheritsFrom(CONSUMER_CLASS) == S_OK)
{
return PERFORM_IF_ALLOWED(ReloadEventConsumer(OBJECT_OF(Event),
lFlags));
}
else if(OBJECT_OF(Event)->InheritsFrom(TIMER_BASE_CLASS) == S_OK)
{
return PERFORM_IF_ALLOWED(ReloadTimerInstruction(OBJECT_OF(Event)));
}
else
{
return WBEM_S_FALSE;
}
}
else if(Event.type == e_EventTypeClassDeletion)
{
//
// For now --- only for deletions. Force-mode modifications are not
// properly handled at the moment.
//
return PERFORM_IF_ALLOWED(
HandleClassChange(CLASS_OF(Event), OBJECT_OF(Event)));
}
else if(Event.type == e_EventTypeClassCreation)
{
return PERFORM_IF_ALLOWED(
HandleClassCreation(CLASS_OF(Event), OBJECT_OF(Event)));
}
else if(Event.type == e_EventTypeNamespaceDeletion)
{
// Construct full namespace name (ours + child)
// ============================================
LPWSTR wszFullName = new WCHAR[
wcslen(m_wszName) + wcslen(Event.wsz2) + 2];
if(wszFullName == NULL)
return WBEM_E_OUT_OF_MEMORY;
CVectorDeleteMe<WCHAR> vdm( wszFullName );
swprintf(wszFullName, L"%s\\%s", m_wszName, Event.wsz2);
// Get the main object to purge that namespace
// ===========================================
return m_pEss->PurgeNamespace(wszFullName);
}
else
{
// Not of interest
// ===============
return WBEM_S_FALSE;
}
}
HRESULT CEssNamespace::ValidateSystemEvent(CEventRepresentation& Event)
{
HRESULT hr;
// Check the type
// ==============
if(Event.IsInstanceEvent())
{
IWbemClassObject* pPrevObj = NULL;
IWbemClassObject* pObj = NULL;
if(Event.type == e_EventTypeInstanceCreation)
pObj = OBJECT_OF(Event);
else if(Event.type == e_EventTypeInstanceDeletion)
pPrevObj = OBJECT_OF(Event);
else if(Event.type == e_EventTypeInstanceModification)
{
pObj = OBJECT_OF(Event);
pPrevObj = OTHER_OBJECT_OF(Event);
}
// Instance creation, deletion or modification event. Check class
// ==============================================================
if(!wbem_wcsicmp(CLASS_OF(Event), EVENT_FILTER_CLASS))
{
hr = CheckEventFilter(pPrevObj, pObj);
}
else if(!wbem_wcsicmp(CLASS_OF(Event), BINDING_CLASS))
{
hr = CheckBinding(pPrevObj, pObj);
}
else if(!wbem_wcsicmp(CLASS_OF(Event),
EVENT_PROVIDER_REGISTRATION_CLASS))
{
hr = CheckEventProviderRegistration(OBJECT_OF(Event));
}
else if(OBJECT_OF(Event)->InheritsFrom(CONSUMER_CLASS) == S_OK)
{
hr = CheckEventConsumer(pPrevObj, pObj);
}
else if(OBJECT_OF(Event)->InheritsFrom(TIMER_BASE_CLASS) == S_OK)
{
hr = CheckTimerInstruction(pObj);
}
else
{
hr = WBEM_S_FALSE;
}
//
// even some of the validation routines use postponed operations.
//
FirePostponedOperations();
}
else
{
// Not of interest
// ===============
hr = WBEM_S_FALSE;
}
return hr;
}
HRESULT CEssNamespace::CheckEventConsumer(IWbemClassObject* pPrevConsumerObj,
IWbemClassObject* pConsumerObj)
{
HRESULT hres;
ENSURE_INITIALIZED
hres = CheckSecurity(pPrevConsumerObj, pConsumerObj);
return hres;
}
PSID CEssNamespace::GetSidFromObject(IWbemClassObject* pObj)
{
HRESULT hres;
VARIANT vSid;
VariantInit(&vSid);
CClearMe cm1(&vSid);
hres = pObj->Get(OWNER_SID_PROPNAME, 0, &vSid, NULL, NULL);
if(FAILED(hres) || V_VT(&vSid) != (VT_UI1 | VT_ARRAY))
{
return NULL;
}
// Construct an actual PSID from the SAFEARRAY
// ===========================================
PSID pOriginal = NULL;
hres = SafeArrayAccessData(V_ARRAY(&vSid), (void**)&pOriginal);
if(FAILED(hres))
{
return NULL;
}
CUnaccessMe uam(V_ARRAY(&vSid));
long cOriginal;
if ( FAILED(SafeArrayGetUBound( V_ARRAY(&vSid), 1, &cOriginal ) ))
{
return NULL;
}
cOriginal++; // SafeArrayGetUBound() is -1 based
//
// validate SID.
//
DWORD dwSidLength = GetLengthSid(pOriginal);
if ( dwSidLength > cOriginal || !IsValidSid(pOriginal) )
{
return NULL;
}
// Make a copy and return it
// =========================
PSID pCopy = (PSID)new BYTE[dwSidLength];
if(pCopy == NULL)
return NULL;
if(!CopySid(dwSidLength, pCopy, pOriginal))
{
delete [] (BYTE*)pCopy;
return NULL;
}
return pCopy;
}
HRESULT CEssNamespace::CheckSecurity(IWbemClassObject* pPrevObj,
IWbemClassObject* pObj)
{
HRESULT hres;
if(!IsNT())
return WBEM_S_NO_ERROR;
// Retrieve the SID of the calling user
// ====================================
hres = WbemCoImpersonateClient();
if(FAILED(hres))
return hres;
CNtSid Sid;
hres = CDerivedObjectSecurity::RetrieveSidFromCall(&Sid);
WbemCoRevertToSelf();
if(FAILED(hres))
return hres;
// If modifying an existing object, check override security
// ========================================================
if(pPrevObj)
{
hres = CheckOverwriteSecurity(pPrevObj, Sid);
if(FAILED(hres))
return hres;
}
// If creating a new version of an object, ensure Sid correctness
// ==============================================================
if(pObj)
{
hres = EnsureSessionSid(pObj, Sid);
if(FAILED(hres))
return hres;
}
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::EnsureSessionSid(IWbemClassObject* pObj, CNtSid& Sid)
{
HRESULT hres;
//
// Check for the special case of administrators --- they can use the
// Administrators SID instead of their own for off-line operations.
//
hres = IsCallerAdministrator();
if(FAILED(hres) && hres != WBEM_E_ACCESS_DENIED)
return hres;
if(SUCCEEDED(hres))
{
//
// This is an admin --- check if there is a SID in the object already
//
PSID pOldSid = GetSidFromObject(pObj);
if(pOldSid == NULL)
{
//
// No SID --- just put an owner SID in there
//
return PutSidInObject(pObj, Sid);
}
else
{
CVectorDeleteMe<BYTE> vdm((BYTE*)pOldSid);
//
// There is a SID there already --- the only allowed ones are the
// user himself or the Administrators. Make sure it is one of those
//
if(!EqualSid(pOldSid, Sid.GetPtr()) &&
!EqualSid(pOldSid, GetAdministratorsSid().GetPtr()))
{
//
// Invalid SID found --- replace with the owner SID
//
return PutSidInObject(pObj, Sid);
}
//
// Valid SID found --- leave it there
//
return WBEM_S_NO_ERROR;
}
}
//
// User not an administrator --- just stick his SID into the object
//
return PutSidInObject(pObj, Sid);
}
HRESULT CEssNamespace::PutSidInObject(IWbemClassObject* pObj, CNtSid& Sid)
{
HRESULT hres;
//
// Clear it first
//
VARIANT vSid;
VariantInit(&vSid);
V_VT(&vSid) = VT_NULL;
CClearMe cm1(&vSid);
hres = pObj->Put(OWNER_SID_PROPNAME, 0, &vSid, 0);
if(FAILED(hres))
return hres;
//
// Construct a safearray for it
//
V_VT(&vSid) = VT_ARRAY | VT_UI1;
SAFEARRAYBOUND sab;
sab.cElements = Sid.GetSize();
sab.lLbound = 0;
V_ARRAY(&vSid) = SafeArrayCreate(VT_UI1, 1, &sab);
if(V_ARRAY(&vSid) == NULL)
return WBEM_E_OUT_OF_MEMORY;
// Copy the SID in there
// =====================
BYTE* abSid = NULL;
hres = SafeArrayAccessData(V_ARRAY(&vSid), (void**)&abSid);
if(FAILED(hres))
return WBEM_E_OUT_OF_MEMORY;
CUnaccessMe uam(V_ARRAY(&vSid));
if(!CopySid(Sid.GetSize(), (PSID)abSid, Sid.GetPtr()))
return WBEM_E_OUT_OF_MEMORY;
// Put it into the consumer
// ========================
hres = pObj->Put(OWNER_SID_PROPNAME, 0, &vSid, 0);
return hres;
}
HRESULT CEssNamespace::CheckOverwriteSecurity(IWbemClassObject* pPrevObj,
CNtSid& ActingSid)
{
HRESULT hres;
if(!IsNT())
return WBEM_S_NO_ERROR;
// Retrieve owner SID from the old object
// ======================================
PSID pOwnerSid = GetSidFromObject(pPrevObj);
if(pOwnerSid == NULL)
return WBEM_E_OUT_OF_MEMORY;
CVectorDeleteMe<BYTE> vdm((BYTE*)pOwnerSid);
// Compare the owner sid with the acting SID. If same, allow access
// =================================================================
if(EqualSid(pOwnerSid, ActingSid.GetPtr()))
return WBEM_S_NO_ERROR;
// Not the same --- still hope that the acting SID is an Admin
// ===========================================================
hres = IsCallerAdministrator();
if(FAILED(hres))
return hres;
//
// OK --- an admin can overwrite
//
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::IsCallerAdministrator()
{
HRESULT hres;
hres = WbemCoImpersonateClient();
if(FAILED(hres))
return hres;
HANDLE hToken;
if(!OpenThreadToken(GetCurrentThread(), TOKEN_READ, TRUE, &hToken))
return WBEM_E_FAILED;
CCloseMe ccm(hToken);
if(CNtSecurity::IsUserInGroup(hToken, GetAdministratorsSid()))
return WBEM_S_NO_ERROR;
return WBEM_E_ACCESS_DENIED;
}
HRESULT CEssNamespace::CheckEventFilter(IWbemClassObject* pOldFilterObj,
IWbemClassObject* pFilterObj)
{
HRESULT hres;
ENSURE_INITIALIZED
// Check security
// ==============
hres = CheckSecurity(pOldFilterObj, pFilterObj);
if(FAILED(hres))
return hres;
// Check everything else
// =====================
return CPermanentFilter::CheckValidity(pFilterObj);
}
HRESULT CEssNamespace::ReloadEventFilter(IWbemClassObject* pFilterObjTemplate)
{
HRESULT hres;
LogOp( L"ReloadEventFilter", pFilterObjTemplate );
ENSURE_INITIALIZED
// Start by deleting this event filter from our records, if there
// ==============================================================
hres = RemoveEventFilter(pFilterObjTemplate);
if(FAILED(hres))
return hres;
// Determine the current state of this filter in the database
// ==========================================================
IWbemClassObject* pFilterObj = NULL;
hres = GetCurrentState(pFilterObjTemplate, &pFilterObj);
if(FAILED(hres))
return hres;
if(pFilterObj == NULL)
{
// The filter has been deleted --- no further action is needed
// ===========================================================
return S_OK;
}
CReleaseMe rm1(pFilterObj);
// Now create it if necessary
// ==========================
hres = AddEventFilter(pFilterObj);
if(FAILED(hres))
return hres;
return hres;
}
//******************************************************************************
//
// Starting with the namespace locked and the filter deleted from the records,
// AddEventFilter updates the records to the state of this filter in the
// database.
//
//******************************************************************************
HRESULT CEssNamespace::AddEventFilter(IWbemClassObject* pFilterObj,
BOOL bInRestart)
{
HRESULT hres;
// Construct the new filter
// ========================
CPermanentFilter* pFilter = new CPermanentFilter(this);
if(pFilter == NULL)
return WBEM_E_OUT_OF_MEMORY;
pFilter->AddRef();
CReleaseMe rm2(pFilter);
// Initialize it
// =============
hres = pFilter->Initialize(pFilterObj);
if(FAILED(hres))
return hres;
// Add it to the table
// ===================
hres = m_Bindings.AddEventFilter(pFilter);
if(FAILED(hres))
return hres;
if(!bInRestart)
{
// Process all the bindings that this filter might have
// ====================================================
hres = AssertBindings(pFilterObj);
if(FAILED(hres))
return hres;
}
return hres;
}
//******************************************************************************
//
// Starting with the namespace locked, RemoveEventFilter updates the records
// to remove all mention of this filter. Note: this is *not* the function to be
// called in response to the database instance-deletion event, as the filter
// could have been recreated in the interim.
//
//******************************************************************************
HRESULT CEssNamespace::RemoveEventFilter(IWbemClassObject* pFilterObj)
{
HRESULT hres;
// Calculate the key for this filter
// =================================
BSTR strKey = CPermanentFilter::ComputeKeyFromObj(pFilterObj);
if(strKey == NULL)
return WBEM_E_OUT_OF_MEMORY;
CSysFreeMe sfm1(strKey);
// Remove it from the table, thus deactivating it
// ==============================================
hres = m_Bindings.RemoveEventFilter(strKey);
if(hres == WBEM_E_NOT_FOUND)
return S_FALSE;
return hres;
}
//*****************************************************************************
//
// Called in response to an instance operation event related to an event
// consumer object.
//
//*****************************************************************************
HRESULT CEssNamespace::ReloadEventConsumer(
IWbemClassObject* pConsumerObjTemplate,
long lFlags)
{
HRESULT hres;
LogOp( L"ReloadConsumer", pConsumerObjTemplate );
ENSURE_INITIALIZED
// Start by deleting this event consumer from our records, if there
// ================================================================
hres = RemoveEventConsumer(pConsumerObjTemplate);
if(FAILED(hres))
return hres;
// Determine the current state of this Consumer in the database
// ============================================================
IWbemClassObject* pConsumerObj = NULL;
hres = GetCurrentState(pConsumerObjTemplate, &pConsumerObj);
if(FAILED(hres))
return hres;
if(pConsumerObj == NULL)
{
// The Consumer has been deleted --- no further action is needed
// =============================================================
return S_OK;
}
CReleaseMe rm1(pConsumerObj);
// Now create it if necessary
// ==========================
hres = AddEventConsumer(pConsumerObjTemplate, lFlags, FALSE);
return hres;
}
//******************************************************************************
//
// Starting with the namespace locked and the consumer deleted from the records
// AddEventConsumer updates the records to the state of this consumer in the
// database.
//
//******************************************************************************
HRESULT CEssNamespace::AddEventConsumer(IWbemClassObject* pConsumerObj,
long lFlags,
BOOL bInRestart)
{
HRESULT hres;
// Construct the new Consumer
// ==========================
CPermanentConsumer* pConsumer = new CPermanentConsumer(this);
if(pConsumer == NULL)
return WBEM_E_OUT_OF_MEMORY;
pConsumer->AddRef();
CReleaseMe rm2(pConsumer);
// Initialize it
// =============
hres = pConsumer->Initialize(pConsumerObj);
if(FAILED(hres))
return hres;
//
// Validate if required
//
if(lFlags & WBEM_FLAG_STRONG_VALIDATION)
{
hres = pConsumer->Validate(pConsumerObj);
if(FAILED(hres))
{
return hres;
}
}
// Add it to the table
// ===================
hres = m_Bindings.AddEventConsumer(pConsumer);
if(FAILED(hres))
return hres;
if(!bInRestart)
{
// Process all the bindings that this consumer might have
// ======================================================
hres = AssertBindings(pConsumerObj);
if(FAILED(hres))
return hres;
}
return hres;
}
//******************************************************************************
//
// Starting with the namespace locked, RemoveEventConsumer updates the records
// to remove all mention of this consumer.
//
//******************************************************************************
HRESULT CEssNamespace::RemoveEventConsumer(IWbemClassObject* pConsumerObj)
{
HRESULT hres;
// Calculate the key for this filter
// =================================
BSTR strKey = CPermanentConsumer::ComputeKeyFromObj(this, pConsumerObj);
if(strKey == NULL)
return WBEM_E_OUT_OF_MEMORY;
CSysFreeMe sfm1(strKey);
// Remove it from the table
// ========================
hres = m_Bindings.RemoveEventConsumer(strKey);
if(hres == WBEM_E_NOT_FOUND)
return S_FALSE;
return hres;
}
HRESULT CEssNamespace::CheckBinding(IWbemClassObject* pPrevBindingObj,
IWbemClassObject* pBindingObj)
{
HRESULT hres;
ENSURE_INITIALIZED
//
// Check security
//
hres = CheckSecurity(pPrevBindingObj, pBindingObj);
if(FAILED(hres))
return hres;
//
// Construct a fake binding to test correctness
//
CPermanentBinding* pBinding = new CPermanentBinding;
if(pBinding == NULL)
return WBEM_E_OUT_OF_MEMORY;
pBinding->AddRef();
CTemplateReleaseMe<CPermanentBinding> trm(pBinding);
hres = pBinding->Initialize(pBindingObj);
if(FAILED(hres))
return hres;
return S_OK;
}
//******************************************************************************
//
// Called in response to an instance operation event related to a binding
// instance.
//
//******************************************************************************
HRESULT CEssNamespace::ReloadBinding(IWbemClassObject* pBindingObjTemplate)
{
HRESULT hres;
LogOp( L"ReloadBinding", pBindingObjTemplate );
ENSURE_INITIALIZED
// Retrieve consumer and provider keys from the binding
// ====================================================
BSTR strPrelimConsumerKey = NULL;
BSTR strFilterKey = NULL;
hres = CPermanentBinding::ComputeKeysFromObject(pBindingObjTemplate,
&strPrelimConsumerKey, &strFilterKey);
if(FAILED(hres))
return hres;
CSysFreeMe sfm1(strPrelimConsumerKey);
CSysFreeMe sfm2(strFilterKey);
// Get real paths from these possibly abbreviated ones
// ===================================================
BSTR strConsumerKey = NULL;
hres = m_pInternalCoreSvc->GetNormalizedPath( strPrelimConsumerKey,
&strConsumerKey);
if(FAILED(hres))
return hres;
CSysFreeMe sfm3(strConsumerKey);
// Start by deleting this binding from our records, if there
// =========================================================
hres = RemoveBinding(strFilterKey, strConsumerKey);
if(FAILED(hres) && hres != WBEM_E_NOT_FOUND)
return hres;
// Determine the current state of this binding in the database
// ============================================================
IWbemClassObject* pBindingObj = NULL;
hres = GetCurrentState(pBindingObjTemplate, &pBindingObj);
if(FAILED(hres))
return hres;
if(pBindingObj == NULL)
{
// The Binding has been deleted --- no further action is needed
// =============================================================
return S_OK;
}
CReleaseMe rm1(pBindingObj);
// Now create it if necessary
// ==========================
hres = AddBinding(strFilterKey, strConsumerKey, pBindingObjTemplate);
return hres;
}
HRESULT CEssNamespace::AddBinding(IWbemClassObject* pBindingObj)
{
HRESULT hres;
// Retrieve consumer and provider keys from the binding
// ====================================================
BSTR strPrelimConsumerKey = NULL;
BSTR strFilterKey = NULL;
hres = CPermanentBinding::ComputeKeysFromObject(pBindingObj,
&strPrelimConsumerKey, &strFilterKey);
if(FAILED(hres))
return hres;
CSysFreeMe sfm1(strPrelimConsumerKey);
CSysFreeMe sfm2(strFilterKey);
// Get real paths from these possibly abbreviated ones
// ===================================================
BSTR strConsumerKey = NULL;
hres = m_pInternalCoreSvc->GetNormalizedPath( strPrelimConsumerKey,
&strConsumerKey );
if(FAILED(hres))
return hres;
CSysFreeMe sfm3(strConsumerKey);
return AddBinding(strFilterKey, strConsumerKey, pBindingObj);
}
HRESULT CEssNamespace::AddBinding(LPCWSTR wszFilterKey, LPCWSTR wszConsumerKey,
IWbemClassObject* pBindingObj)
{
HRESULT hres;
// Create a new binding
// ====================
CPermanentBinding* pBinding = new CPermanentBinding;
if(pBinding == NULL)
return WBEM_E_OUT_OF_MEMORY;
pBinding->AddRef();
CReleaseMe rm1(pBinding);
// Initialize it with the information we have
// ==========================================
hres = pBinding->Initialize(pBindingObj);
if(FAILED(hres))
return hres;
// Extract its creator's SID
// ========================
PSID pSid = CPermanentBinding::GetSidFromObject(pBindingObj);
if ( pSid == NULL )
{
return WBEM_E_OUT_OF_MEMORY;
}
hres = m_Bindings.Bind( wszFilterKey, wszConsumerKey, pBinding, pSid );
delete [] pSid;
return hres;
}
HRESULT CEssNamespace::RemoveBinding(LPCWSTR wszFilterKey,
LPCWSTR wszConsumerKey)
{
HRESULT hres;
hres = m_Bindings.Unbind(wszFilterKey, wszConsumerKey);
if(hres == WBEM_E_NOT_FOUND)
return S_FALSE;
return hres;
}
//******************************************************************************
//
// Reads all the bindings referencing a given objects from the database and
// asserts them.
//
//******************************************************************************
class CAssertBindingsSink : public CObjectSink
{
protected:
CEssNamespace* m_pNamespace;
public:
CAssertBindingsSink(CEssNamespace* pNamespace) : m_pNamespace(pNamespace)
{
AddRef();
}
STDMETHOD(Indicate)(long lNumObjects, IWbemClassObject** apObjects)
{
for(long i = 0; i < lNumObjects; i++)
{
m_pNamespace->AddBinding(apObjects[i]);
}
return S_OK;
}
};
HRESULT CEssNamespace::AssertBindings(IWbemClassObject* pEndpoint)
{
// Get the relative path of the endpoint
// =====================================
VARIANT vRelPath;
VariantInit(&vRelPath);
CClearMe cm1(&vRelPath);
HRESULT hres = pEndpoint->Get(L"__RELPATH", 0, &vRelPath, NULL, NULL);
if(FAILED(hres))
return hres;
if(V_VT(&vRelPath) != VT_BSTR)
return WBEM_E_INVALID_OBJECT;
BSTR strRelPath = V_BSTR(&vRelPath);
// Issue the query
// ===============
BSTR strQuery = SysAllocStringLen(NULL, 200 + wcslen(strRelPath));
if(strQuery == NULL)
return WBEM_E_OUT_OF_MEMORY;
CSysFreeMe sfm1(strQuery);
swprintf(strQuery, L"references of {%s} where "
L"ResultClass = __FilterToConsumerBinding", strRelPath);
CAssertBindingsSink Sink(this);
hres = ExecQuery(strQuery, 0, &Sink);
return hres;
}
HRESULT CEssNamespace::ReloadTimerInstruction(
IWbemClassObject* pInstObjTemplate)
{
HRESULT hres;
LogOp( L"ReloadTimerInstruction", pInstObjTemplate );
ENSURE_INITIALIZED
hres = RemoveTimerInstruction(pInstObjTemplate);
if(FAILED(hres))
return hres;
// Get the current version from the namespace
// ==========================================
IWbemClassObject* pInstObj = NULL;
hres = GetCurrentState(pInstObjTemplate, &pInstObj);
if(FAILED(hres))
return hres;
if(pInstObj == NULL)
{
// The instruction has been deleted --- no further action is needed
// ================================================================
return S_OK;
}
CReleaseMe rm1(pInstObj);
// Add it to the generator
// =======================
hres = AddTimerInstruction(pInstObj);
if(FAILED(hres))
return hres;
return hres;
}
HRESULT CEssNamespace::AddTimerInstruction(IWbemClassObject* pInstObj)
{
return m_pEss->GetTimerGenerator().
LoadTimerEventObject(m_wszName, pInstObj);
}
//******************************************************************************
// public
//
// See ess.h for documentation
//
//******************************************************************************
HRESULT CEssNamespace::RemoveTimerInstruction(IWbemClassObject* pOldObject)
{
HRESULT hres;
VARIANT vID;
VariantInit(&vID);
hres = pOldObject->Get(TIMER_ID_PROPNAME, 0, &vID, NULL, NULL);
if(FAILED(hres)) return hres;
m_pEss->GetTimerGenerator().Remove(m_wszName, V_BSTR(&vID));
VariantClear(&vID);
return S_OK;
}
//******************************************************************************
// public
//
// See ess.h for documentation
//
//******************************************************************************
#ifdef __WHISTLER_UNCUT
HRESULT CEssNamespace::CheckMonitor(IWbemClassObject* pOldMonitorObj,
IWbemClassObject* pMonitorObj)
{
HRESULT hres;
ENSURE_INITIALIZED
// Check security
// ==============
hres = CheckSecurity(pOldMonitorObj, pMonitorObj);
if(FAILED(hres))
return hres;
// BUGBUG: any other checks?
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::ReloadMonitor(IWbemClassObject* pMonitorObjTemplate)
{
HRESULT hres;
LogOp( L"ReloadMonitor", pMonitorObjTemplate );
ENSURE_INITIALIZED
//
// Start by deleting this monitor from our records, if there
//
hres = RemoveMonitor(pMonitorObjTemplate);
if(FAILED(hres))
return hres;
//
// Determine the current state of this monitor in the database
//
IWbemClassObject* pMonitorObj = NULL;
hres = GetCurrentState(pMonitorObjTemplate, &pMonitorObj);
if(FAILED(hres))
return hres;
if(pMonitorObj == NULL)
{
//
// The monitor has been deleted --- no further action is needed
//
return S_OK;
}
CReleaseMe rm1(pMonitorObj);
// Now create it if necessary
// ==========================
hres = AddMonitor(pMonitorObj);
if(FAILED(hres))
return hres;
return hres;
}
//******************************************************************************
//
//
//******************************************************************************
HRESULT CEssNamespace::AddMonitor(IWbemClassObject* pMonitorObj)
{
HRESULT hres;
if(m_pMonitorProvider == NULL)
return WBEM_E_UNEXPECTED;
//
// Get the information from the monitor object
//
BSTR strKey, strQuery;
long lFlags;
hres = CMonitorProvider::GetMonitorInfo(pMonitorObj, &strKey,
&strQuery, &lFlags);
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS, "A monitor was could not be cracked "
"in namespace '%S' as invalid: 0x%X\n", GetName(), hres));
return hres;
}
CSysFreeMe sfm1(strKey);
CSysFreeMe sfm2(strQuery);
//
// Attempt to add the monitor to the monitor provider
//
hres = m_pMonitorProvider->AddMonitor(strKey, strQuery,
lFlags, GetCurrentEssContext());
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS, "Monitor '%S' at '%S' was rejected in "
"namespace '%S' with error code 0x%X\n",
strQuery, strKey, GetName()));
return hres;
}
return hres;
}
//******************************************************************************
//
// Starting with the namespace locked, RemoveMonitor updates the records
// to remove all mention of this monitor. Note: this is *not* the function to
// be
// called in response to the database instance-deletion event, as the monitor
// could have been recreated in the interim.
//
//******************************************************************************
HRESULT CEssNamespace::RemoveMonitor(IWbemClassObject* pMonitorObj)
{
HRESULT hres;
if(m_pMonitorProvider == NULL)
return WBEM_E_UNEXPECTED;
//
// Calculate the key form this monitor
//
BSTR strKey;
hres = CMonitorProvider::GetMonitorInfo(pMonitorObj, &strKey,
NULL, NULL);
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS, "A monitor was could not be cracked "
"in namespace '%S' as invalid: 0x%X\n", GetName(), hres));
return hres;
}
CSysFreeMe sfm1(strKey);
//
// Remove it from the provider
//
hres = m_pMonitorProvider->RemoveMonitor(strKey, GetCurrentEssContext());
if(hres == WBEM_E_NOT_FOUND)
return S_FALSE;
return hres;
}
#endif
HRESULT CEssNamespace::SignalEvent( READ_ONLY CEventRepresentation& Event,
long lFlags )
{
HRESULT hres;
//
// we cannot hold any turns in an exec line or hold the namespace lock
// when calling this function. This is because this function will
// aquire the proxy lock.
//
CPostponedList* pList;
_DBG_ASSERT( !DoesThreadOwnNamespaceLock() );
_DBG_ASSERT( !(pList=GetCurrentPostponedList()) ||
!pList->IsHoldingTurns() );
// BUGBUG: need to propagate security context to this function ?
CWbemPtr<CCoreEventProvider> pCoreEventProvider;
{
//
// we need to figure out if we need to deffer the event or signal it.
// we deffer events when we are in the init pending or init state.
//
CInCritSec ics( &m_csLevel1 );
if ( m_eState == e_Initialized )
{
pCoreEventProvider = m_pCoreEventProvider;
}
else if ( m_eState == e_InitializePending )
{
//
// Copy and add to defferred list.
//
CEventRepresentation* pEvRep = Event.MakePermanentCopy();
if ( pEvRep == NULL )
{
return WBEM_E_OUT_OF_MEMORY;
}
if ( m_aDeferredEvents.Add( pEvRep ) < 0 )
{
delete pEvRep;
return WBEM_E_OUT_OF_MEMORY;
}
}
}
if ( pCoreEventProvider != NULL )
{
CEventContext Context;
hres = pCoreEventProvider->Fire( Event, &Context );
if(FAILED(hres))
{
return hres;
}
}
return WBEM_S_NO_ERROR;
}
//******************************************************************************
// public
//
// See ess.h for documentation
//
//******************************************************************************
HRESULT CEssNamespace::ProcessEvent(READ_ONLY CEventRepresentation& Event,
long lFlags)
{
// Ignore internal operations
// ==========================
if(Event.wsz2 != NULL &&
(!wbem_wcsicmp(Event.wsz2, L"__TimerNextFiring") ||
!wbem_wcsicmp(Event.wsz2, L"__ListOfEventActiveNamespaces")))
{
return WBEM_S_NO_ERROR;
}
HRESULT hres, hresReturn = WBEM_S_NO_ERROR;
// Analyze it for system changes
// =============================
hres = ActOnSystemEvent(Event, lFlags);
if(FAILED(hres))
{
//
// Check if this operation needs to be failed if invalid
//
if( lFlags & WBEM_FLAG_STRONG_VALIDATION )
{
hresReturn = hres;
}
else
{
ERRORTRACE((LOG_ESS, "Event subsystem was unable to perform the "
"necessary operations to accomodate a change to the system "
"state.\nThe state of the database may not reflect the state "
"of the event subsystem (%X)\n", hres));
}
}
// Fire postponed operations
// =========================
hres = FirePostponedOperations();
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS,"Event subsystem was unable to perform the (post) "
"necessary operations to accomodate a change to the system state.\n"
"The state of the database may not reflect the state of the event "
"subsystem (%X)\n", hres));
}
// Deliver it to consumers
// =======================
hres = SignalEvent( Event, lFlags );
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS, "Event subsystem was unable to deliver a "
"repository intrinsic event to some consumers (%X)\n", hres));
}
return hresReturn;
}
HRESULT CEssNamespace::ProcessQueryObjectSinkEvent( READ_ONLY CEventRepresentation& Event )
{
HRESULT hres = S_FALSE;
CRefedPointerArray< CEventFilter > apEventFilters;
if ( m_Bindings.GetEventFilters( apEventFilters ) )
{
if ( apEventFilters.GetSize( ) > 0 )
{
//
// Convert to real event
//
IWbemClassObject* pEvent;
HRESULT hr = Event.MakeWbemObject( this, &pEvent );
if( FAILED( hr ) )
{
return hr;
}
CReleaseMe rm1( pEvent );
//
// Fire all matching filters
//
for( int i = 0; i < apEventFilters.GetSize( ); ++i )
{
CEventContext Context;
CEventFilter* pEventFilter = apEventFilters[i];
hr = pEventFilter->Indicate( 1, &pEvent, &Context );
if ( FAILED( hr ) )
{
return hr;
}
//
// Return S_FALSE if all of the Indicates returns S_FALSE
//
if ( S_FALSE != hr )
{
hres = S_OK;
}
}
}
}
else
{
return E_FAIL;
}
return hres;
}
HRESULT CEssNamespace::RegisterNotificationSink( WBEM_CWSTR wszQueryLanguage,
WBEM_CWSTR wszQuery,
long lFlags,
WMIMSG_QOS_FLAG lQosFlags,
IWbemContext* pContext,
IWbemObjectSink* pSink )
{
HRESULT hres;
//
// Report the MSFT_WmiRegisterNotificationSink event.
//
FIRE_NCEVENT( g_hNCEvents[MSFT_WmiRegisterNotificationSink],
WMI_SENDCOMMIT_SET_NOT_REQUIRED,
// Data follows...
(LPCWSTR) m_wszName,
wszQueryLanguage,
wszQuery,
(DWORD64) pSink);
DEBUGTRACE((LOG_ESS,"Registering notification sink with query %S in "
"namespace %S.\n", wszQuery, m_wszName ));
{
ENSURE_INITIALIZED
hres = InternalRegisterNotificationSink( wszQueryLanguage,
wszQuery,
lFlags,
lQosFlags,
pContext,
pSink,
FALSE,
NULL );
}
if(FAILED(hres))
{
// Clean up and return
FirePostponedOperations();
return hres;
}
// Filter and consumer are in place --- fire external operations
// =============================================================
hres = FirePostponedOperations();
if(FAILED(hres))
{
{
CInUpdate iu(this);
InternalRemoveNotificationSink( pSink );
}
//
// need to make sure that we fire postponed here too. Remember that
// we cannot hold the namespace lock when firing postponed ops.
//
FirePostponedOperations();
}
else
{
InterlockedIncrement(&g_lNumTempSubscriptions);
}
return hres;
}
HRESULT CEssNamespace::InternalRegisterNotificationSink(
WBEM_CWSTR wszQueryLanguage,
WBEM_CWSTR wszQuery,
long lFlags,
WMIMSG_QOS_FLAG lQosFlags,
IWbemContext* pContext,
IWbemObjectSink* pSink,
bool bInternal,
PSID pOwnerSid )
{
HRESULT hres;
if(wbem_wcsicmp(wszQueryLanguage, L"WQL"))
return WBEM_E_INVALID_QUERY_TYPE;
LPWSTR wszConsumerKey = NULL;
CVectorDeleteMe<WCHAR> vdm2(&wszConsumerKey);
wszConsumerKey = CTempConsumer::ComputeKeyFromSink(pSink);
if ( NULL == wszConsumerKey )
{
return WBEM_E_OUT_OF_MEMORY;
}
bool bInterNamespace = pOwnerSid != NULL;
#ifdef __WHISTLER_UNCUT
//
// Check if this is a monitoring request
//
if(lFlags & WBEM_FLAG_MONITOR)
{
if(m_pMonitorProvider == NULL)
return WBEM_E_NOT_SUPPORTED;
//
// Issue a subscription for anything eminating from the monitor we are
// about to create. We are going to use the consumer key as the key
// for the monitor --- this means that ONE CANNOT issue more than one
// monitor against the same sink!
//
WCHAR* wszNewQuery = new WCHAR[wcslen(wszConsumerKey) + 200];
if ( wszNewQuery == NULL )
{
return WBEM_E_OUT_MEMORY;
}
CVectorDeleteMe<WCHAR> vdm1(wszNewQuery);
swprintf(wszNewQuery, L"select * from "MONITOR_BASE_EVENT_CLASS
L" where "MONITORNAME_EVENT_PROPNAME L" = \"%s\"",
wszConsumerKey);
hres = InternalRegisterNotificationSink(L"WQL", wszNewQuery,
lFlags & ~WBEM_FLAG_MONITOR, lQosFlags, pContext, pSink, NULL);
if(FAILED(hres))
return hres;
//
// Construct the new monitor
//
hres = m_pMonitorProvider->AddMonitor(wszConsumerKey, wszQuery,
lFlags, pContext);
if(FAILED(hres))
return hres;
return WBEM_S_NO_ERROR;
}
//
// Normal subscription
//
#endif
LPWSTR wszFilterKey = NULL;
CVectorDeleteMe<WCHAR> vdm1(&wszFilterKey);
{
// Create a new temporary filter and add it to the binding table
// =============================================================
CTempFilter* pFilter = new CTempFilter(this);
if(pFilter == NULL)
return WBEM_E_OUT_OF_MEMORY;
hres = pFilter->Initialize( wszQueryLanguage,
wszQuery,
lFlags,
pOwnerSid,
bInternal,
pContext,
pSink );
if(FAILED(hres))
{
delete pFilter;
return hres;
}
hres = m_Bindings.AddEventFilter(pFilter);
if(FAILED(hres))
{
delete pFilter;
return hres;
}
wszFilterKey = pFilter->GetKey().CreateLPWSTRCopy();
if(wszFilterKey == NULL)
return WBEM_E_OUT_OF_MEMORY;
// Check if this sink has already been used by looking for it in the
// binding table
// =================================================================
CTempConsumer* pConsumer = NULL;
if(FAILED(m_Bindings.FindEventConsumer(wszConsumerKey, NULL)))
{
// Create a new temporary consumer and add it to the table
// =======================================================
pConsumer = _new CTempConsumer(this);
if(pConsumer == NULL)
return WBEM_E_OUT_OF_MEMORY;
hres = pConsumer->Initialize( bInterNamespace, pSink);
if(FAILED(hres))
return hres;
hres = m_Bindings.AddEventConsumer(pConsumer);
if(FAILED(hres))
{
// Undo filter creation
// ====================
m_Bindings.RemoveEventFilter(wszFilterKey);
return hres;
}
}
// Bind them together
// ==================
CBinding* pBinding = new CTempBinding( lFlags,
lQosFlags,
bInterNamespace );
if(pBinding == NULL)
return WBEM_E_OUT_OF_MEMORY;
pBinding->AddRef();
CReleaseMe rm1(pBinding);
//
// SPAGETTI WARNING: From this point on, we must flush the postponed
// operation cache, or we may leak memory. But not before all the
// CReleaseMe calls have fired.
//
hres = m_Bindings.Bind(wszFilterKey, wszConsumerKey, pBinding, NULL);
// Check that the filter is active --- otherwise activatioin must have
// failed.
// ===================================================================
if(SUCCEEDED(hres) && !pFilter->IsActive())
hres = pFilter->GetFilterError();
if(FAILED(hres))
{
//
// The core will deliver the SetStatus call to the consumer based
// on the return code from the ESS. Since we are failing, we should
// not call SetStatus ourselves.
//
if(pConsumer)
pConsumer->Shutdown(true); // quiet
m_Bindings.RemoveEventFilter(wszFilterKey);
m_Bindings.RemoveEventConsumer(wszConsumerKey);
}
else
{
InterlockedIncrement(&g_lNumInternalTempSubscriptions);
}
}
return hres;
}
HRESULT CEssNamespace::RemoveNotificationSink( IWbemObjectSink* pSink )
{
// Fire a MSFT_WmiCancelNotificationSink if necessary.
if (IS_NCEVENT_ACTIVE(MSFT_WmiCancelNotificationSink))
{
LPWSTR wszConsumerKey = CTempConsumer::ComputeKeyFromSink(pSink);
if (wszConsumerKey != NULL)
{
CVectorDeleteMe<WCHAR> vdm0(wszConsumerKey);
CInUpdate iu(this);
// Find the consumer in question
CEventConsumer *pConsumer = NULL;
if (SUCCEEDED(m_Bindings.FindEventConsumer(wszConsumerKey, &pConsumer)))
{
CRefedPointerSmallArray<CEventFilter>
apFilters;
CReleaseMe rm1(pConsumer);
// Make addrefed copies of all its associated filters
if (SUCCEEDED(pConsumer->GetAssociatedFilters(apFilters))
&& apFilters.GetSize())
{
int nFilters = apFilters.GetSize();
LPWSTR wszQuery = NULL,
wszQueryLanguage = NULL;
BOOL bExact;
apFilters[0]->
GetCoveringQuery(wszQueryLanguage, wszQuery, bExact, NULL);
CVectorDeleteMe<WCHAR> vdm1(wszQueryLanguage);
CVectorDeleteMe<WCHAR> vdm2(wszQuery);
//
// Report the MSFT_WmiRegisterNotificationSink event.
//
FIRE_NCEVENT(
g_hNCEvents[MSFT_WmiCancelNotificationSink],
WMI_SENDCOMMIT_SET_NOT_REQUIRED,
// Data follows...
(LPCWSTR) m_wszName,
wszQueryLanguage,
wszQuery,
(DWORD64) pSink);
}
}
}
}
HRESULT hres;
{
CInUpdate iu( this );
hres = InternalRemoveNotificationSink( pSink );
}
FirePostponedOperations();
if ( SUCCEEDED(hres) )
{
InterlockedDecrement( &g_lNumTempSubscriptions );
}
return hres;
}
HRESULT CEssNamespace::InternalRemoveNotificationSink(IWbemObjectSink* pSink)
{
HRESULT hres;
LPWSTR wszKey = CTempConsumer::ComputeKeyFromSink(pSink);
if(wszKey == NULL)
return WBEM_E_OUT_OF_MEMORY;
CVectorDeleteMe<WCHAR> vdm1(wszKey);
#ifdef __WHISTLER_UNCUT
//
// Remove any monitors that may be associated with it
//
if(m_pMonitorProvider)
m_pMonitorProvider->RemoveMonitor(wszKey, GetCurrentEssContext());
#endif
// Find the consumer container
// ===========================
hres = m_Bindings.RemoveConsumerWithFilters(wszKey);
if(FAILED(hres))
return hres;
else
InterlockedDecrement( &g_lNumInternalTempSubscriptions );
return hres;
}
void CEssNamespace::FireNCFilterEvent(DWORD dwIndex, CEventFilter *pFilter)
{
if (IS_NCEVENT_ACTIVE(dwIndex))
{
LPWSTR wszQuery = NULL;
LPWSTR wszQueryLanguage = NULL;
BOOL bExact;
CWbemPtr<CEssNamespace> pNamespace;
GetFilterEventNamespace(pFilter, &pNamespace);
// I'll assume we should use the current namespace if it's null.
if (!pNamespace)
pNamespace = this;
pFilter->GetCoveringQuery(wszQueryLanguage, wszQuery, bExact, NULL);
CVectorDeleteMe<WCHAR> vdm1(wszQueryLanguage);
CVectorDeleteMe<WCHAR> vdm2(wszQuery);
//
// Report the event.
//
FIRE_NCEVENT(
g_hNCEvents[dwIndex],
WMI_SENDCOMMIT_SET_NOT_REQUIRED,
// Data follows...
pNamespace ? (LPCWSTR) pNamespace->GetName() : NULL,
(LPCWSTR) (WString) pFilter->GetKey(),
wszQueryLanguage,
wszQuery);
}
}
//*****************************************************************************
//
// Called by the filter when it notices that it has consumers. The filter is
// guaranteed to be either valid or temporarily invalid and not active. It is
// guaranteed that no more than 1 activation/deactivation can occur on the
// same filter at the same time.
//
//*****************************************************************************
HRESULT CEssNamespace::ActivateFilter(READ_ONLY CEventFilter* pFilter)
{
HRESULT hres, hresAttempt;
hresAttempt = AttemptToActivateFilter(pFilter);
if(FAILED(hresAttempt))
{
pFilter->MarkAsTemporarilyInvalid(hresAttempt);
//
// We need to log an event about our inability to activate the filter
// unless we shall report this failure to the caller. We can only
// report this to the caller if the filter is being created (not
// reactivated), and the caller is not using a force-mode
//
if(pFilter->DoesAllowInvalid() || pFilter->HasBeenValid())
{
LPWSTR wszQuery = NULL;
LPWSTR wszQueryLanguage = NULL;
BOOL bExact;
hres = pFilter->GetCoveringQuery( wszQueryLanguage,
wszQuery,
bExact,
NULL);
if(FAILED(hres))
return hres;
CVectorDeleteMe<WCHAR> vdm1(wszQueryLanguage);
CVectorDeleteMe<WCHAR> vdm2(wszQuery);
//
// Don't change this one: could be Nova customer dependencies
//
m_pEss->GetEventLog().Report( EVENTLOG_ERROR_TYPE,
WBEM_MC_CANNOT_ACTIVATE_FILTER,
m_wszName,
wszQuery,
(CHex)hresAttempt );
ERRORTRACE((LOG_ESS, "Could not activate filter %S in namespace "
"%S. HR=0x%x\n", wszQuery, m_wszName, hresAttempt ));
}
}
else
{
//
// Report the MSFT_WmiFilterActivated event.
//
FireNCFilterEvent(MSFT_WmiFilterActivated, pFilter);
pFilter->MarkAsValid();
}
return hresAttempt;
}
//******************************************************************************
//
// Worker for ActivateFilter --- does all the work but does not mark the filter
// status
//
//******************************************************************************
HRESULT CEssNamespace::AttemptToActivateFilter(READ_ONLY CEventFilter* pFilter)
{
HRESULT hres = WBEM_S_NO_ERROR;
//
// Get the query information from the filter
//
LPWSTR wszQueryLanguage = NULL;
LPWSTR wszQuery = NULL;
BOOL bExact;
QL_LEVEL_1_RPN_EXPRESSION* pExp = NULL;
hres = pFilter->GetCoveringQuery(wszQueryLanguage, wszQuery, bExact, &pExp);
if(FAILED(hres))
{
WMIESS_REPORT((WMIESS_CANNOT_GET_FILTER_QUERY, m_wszName, pFilter));
return hres;
}
CVectorDeleteMe<WCHAR> vdm1(wszQueryLanguage);
CVectorDeleteMe<WCHAR> vdm2(wszQuery);
CDeleteMe<QL_LEVEL_1_RPN_EXPRESSION> dm1(pExp);
if(!bExact)
{
//
// We don't support inexact filter, nor do we have any now
//
return WBEM_E_NOT_SUPPORTED;
}
//
// Check if the events are supposed to come from this namespace or some
// other one. Cross-namespace filters are all we are interested in the
// initialize phase, since we're going to reprocess normal filters
// after loading provider registrations ( In CompleteInitialization() )
//
CEssNamespace* pOtherNamespace = NULL;
hres = GetFilterEventNamespace(pFilter, &pOtherNamespace);
if(FAILED(hres))
return hres;
if( pOtherNamespace )
{
CTemplateReleaseMe<CEssNamespace> rm0(pOtherNamespace);
if ( m_bInResync )
{
//
// we don't need to do anything in the other namespace during
// resync of this one, so no work to do here. Actually, since
// resync doesn't do a deactivate, the registration is still there
// so be careful of double registration if removing this check.
//
return WBEM_S_FALSE;
}
DEBUGTRACE((LOG_ESS,"Activating cross-namespace filter %p with query "
"%S in namespace %S from namespace %S.\n", pFilter,
wszQuery, pOtherNamespace->GetName(), m_wszName ));
//
// Register this notification sink with the other namespace, as
// if it were a temporary consumer. Make the registration
// synchronous, as whatever asynchronicity we need will be
// provided by the ultimate consumer handling. This needs to be a
// postponed operation though, else we could have a deadlock
// scenario if at the same time cross namespace subscriptions
// were registered in both namespaces.
//
//
// BUGBUG: security propagation
//
CPostponedRegisterNotificationSinkRequest* pReq;
pReq = new CPostponedRegisterNotificationSinkRequest;
if ( pReq == NULL )
{
return WBEM_E_OUT_OF_MEMORY;
}
hres = pReq->SetRegistration( pOtherNamespace,
wszQueryLanguage,
wszQuery,
pFilter->GetForceFlags(),
WMIMSG_FLAG_QOS_SYNCHRONOUS,
pFilter->GetNonFilteringSink(),
pFilter->GetOwner() );
if(FAILED(hres))
{
return hres;
}
CPostponedList* pList = GetCurrentPostponedList();
_DBG_ASSERT( pList != NULL );
hres = pList->AddRequest( this, pReq );
if ( FAILED(hres) )
{
return hres;
}
return WBEM_S_NO_ERROR;
}
else if ( m_eState == e_Initialized || m_bInResync )
{
//
// Filter is being activated in this namespace. We must avoid
// processing filters before we're fully initialized. This can
// happen when one namespace is initializing its cross namespace
// subscription to one that is still initializing. We do not process
// filters before we're initialized because (1) we are not allowed to
// access class providers during stage1 init and (2) we're going to
// resync everything anyways during stage2 init.
//
DEBUGTRACE((LOG_ESS,"Activating filter %p with query %S "
"in namespace %S.\n", pFilter, wszQuery, m_wszName ));
// Retrieve its non-filtering sink
// ===============================
CAbstractEventSink* pNonFilter = pFilter->GetNonFilteringSink();
if(pNonFilter == NULL)
return WBEM_E_OUT_OF_MEMORY;
//
// Register for class modification events of relevance for this filter
//
hres = RegisterFilterForAllClassChanges(pFilter, pExp);
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS,"Unable to register for class changes related "
"to filter %S in namespace %S: 0x%x\n", wszQuery, GetName(),
hres));
return hres;
}
//
// Prepare filter for action
//
hres = pFilter->GetReady(wszQuery, pExp);
if( SUCCEEDED(hres) )
{
//
// Register it in the core tables
//
hres = m_EventProviderCache.LoadProvidersForQuery(wszQuery,
pExp, pNonFilter);
if(SUCCEEDED(hres))
{
hres = m_Poller.ActivateFilter(pFilter, wszQuery, pExp);
if(FAILED(hres))
{
// Need to deactivate providers
// ============================
m_EventProviderCache.ReleaseProvidersForQuery(
pNonFilter);
}
}
}
}
if(FAILED(hres))
{
//
// Keep this filter registered for its class change events, as one of
// them could make it valid!
//
}
return hres;
}
//*****************************************************************************
//
// Retrieves the namespace pointer for the event namespace for this filter.
// If current, returns NULL.
//
//*****************************************************************************
HRESULT CEssNamespace::GetFilterEventNamespace(CEventFilter* pFilter,
RELEASE_ME CEssNamespace** ppNamespace)
{
HRESULT hres;
*ppNamespace = NULL;
LPWSTR wszNamespace = NULL;
hres = pFilter->GetEventNamespace(&wszNamespace);
if(FAILED(hres))
{
WMIESS_REPORT((WMIESS_INVALID_FILTER_NAMESPACE, m_wszName, pFilter,
wszNamespace));
return hres;
}
CVectorDeleteMe<WCHAR> vdm0(wszNamespace);
if(wszNamespace && wbem_wcsicmp(wszNamespace, m_wszName))
{
//
// Different namespace: Find it in the list.
//
hres = m_pEss->GetNamespaceObject( wszNamespace, TRUE, ppNamespace );
if(FAILED(hres))
{
WMIESS_REPORT((WMIESS_CANNOT_OPEN_FILTER_NAMESPACE, m_wszName,
pFilter, wszNamespace));
return hres;
}
//
// Check if we got back our current namespace --- could happen if the
// spelling is different, etc
//
if(*ppNamespace == this)
{
(*ppNamespace)->Release();
*ppNamespace = NULL;
}
return S_OK;
}
else
{
// Same namespace
*ppNamespace = NULL;
return S_OK;
}
}
HRESULT CEssNamespace::RegisterFilterForAllClassChanges(CEventFilter* pFilter,
QL_LEVEL_1_RPN_EXPRESSION* pExpr)
{
HRESULT hres;
//
// Do nothing for class operation filters. They simply serve as their own
// "class change" filters
//
if(!wbem_wcsicmp(pExpr->bsClassName, L"__ClassOperationEvent") ||
!wbem_wcsicmp(pExpr->bsClassName, L"__ClassCreationEvent") ||
!wbem_wcsicmp(pExpr->bsClassName, L"__ClassDeletionEvent") ||
!wbem_wcsicmp(pExpr->bsClassName, L"__ClassModificationEvent"))
{
pFilter->MarkReconstructOnHit();
return WBEM_S_NO_ERROR;
}
//
// get the sink for class change notifications.
//
IWbemObjectSink* pClassChangeSink = pFilter->GetClassChangeSink(); // NOREF
_DBG_ASSERT( pClassChangeSink != NULL );
//
// since the class change sink will be modifying internal namespace
// structures, we must wrap with an internal operations sink. This is so
// the thread that performs the indicate will be guaranteed to have a
// valid thread object associated with it.
//
CWbemPtr<CEssInternalOperationSink> pInternalOpSink;
pInternalOpSink = new CEssInternalOperationSink( pClassChangeSink );
if ( pInternalOpSink == NULL )
{
return WBEM_E_OUT_OF_MEMORY;
}
//
// store the new sink with the filter because we need it later to unreg
//
CWbemPtr<IWbemObjectSink> pOldInternalOpSink;
hres = pFilter->SetActualClassChangeSink( pInternalOpSink,
&pOldInternalOpSink );
if ( FAILED(hres) )
{
return hres;
}
_DBG_ASSERT( pOldInternalOpSink == NULL );
return RegisterSinkForAllClassChanges( pInternalOpSink, pExpr );
}
HRESULT CEssNamespace::RegisterSinkForAllClassChanges(IWbemObjectSink* pSink,
QL_LEVEL_1_RPN_EXPRESSION* pExpr)
{
HRESULT hres;
//
// First of all, the class we are looking for is of interest
//
hres = RegisterSinkForClassChanges(pSink, pExpr->bsClassName);
if(FAILED(hres))
return hres;
//
// Now, iterate over all the tokens looking for ISAs. We need those classes
// too.
//
for(int i = 0; i < pExpr->nNumTokens; i++)
{
QL_LEVEL_1_TOKEN* pToken = pExpr->pArrayOfTokens + i;
if(pToken->nTokenType == QL1_OP_EXPRESSION &&
(pToken->nOperator == QL1_OPERATOR_ISA ||
pToken->nOperator == QL1_OPERATOR_ISNOTA) &&
V_VT(&pToken->vConstValue) == VT_BSTR)
{
hres = RegisterSinkForClassChanges(pSink,
V_BSTR(&pToken->vConstValue));
if(FAILED(hres))
{
UnregisterSinkFromAllClassChanges(pSink);
return hres;
}
}
}
// Somehow need to keep this filter subscribed to various events until all
// the classes show up
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::RegisterSinkForClassChanges(IWbemObjectSink* pSink,
LPCWSTR wszClassName)
{
//
// Do not register for changes to system classes --- they do not change!
//
if(wszClassName[0] == L'_')
{
return WBEM_S_NO_ERROR;
}
//
// Just issue the appropriate query against the namespace. The filter
// will know what to do when called
//
LPWSTR wszQuery = new WCHAR[wcslen(wszClassName) + 100];
if ( wszQuery == NULL )
{
return WBEM_E_OUT_OF_MEMORY;
}
swprintf(wszQuery, L"select * from __ClassOperationEvent where "
L"TargetClass isa \"%s\"", wszClassName);
CVectorDeleteMe<WCHAR> vdm( wszQuery );
return InternalRegisterNotificationSink(L"WQL",
wszQuery, 0, WMIMSG_FLAG_QOS_SYNCHRONOUS,
GetCurrentEssContext(), pSink, true, NULL );
}
HRESULT CEssNamespace::RegisterProviderForClassChanges( LPCWSTR wszClassName,
LPCWSTR wszProvName )
{
try
{
CInCritSec ics(&m_csLevel1);
m_mapProviderInterestClasses[wszClassName].insert( wszProvName );
}
catch(CX_MemoryException)
{
return WBEM_E_OUT_OF_MEMORY;
}
return S_OK;
}
HRESULT CEssNamespace::UnregisterFilterFromAllClassChanges(
CEventFilter* pFilter)
{
HRESULT hres;
//
// unbind the filter from the actual class change sink and use it to unreg
//
CWbemPtr<IWbemObjectSink> pActualClassChangeSink;
hres = pFilter->SetActualClassChangeSink( NULL, &pActualClassChangeSink );
if ( FAILED(hres) )
{
return hres;
}
if ( pActualClassChangeSink != NULL )
{
hres = UnregisterSinkFromAllClassChanges( pActualClassChangeSink );
}
return hres;
}
HRESULT CEssNamespace::UnregisterSinkFromAllClassChanges(
IWbemObjectSink* pSink)
{
return InternalRemoveNotificationSink(pSink);
}
HRESULT CEssNamespace::DeactivateFilter( READ_ONLY CEventFilter* pFilter )
{
HRESULT hres;
DEBUGTRACE((LOG_ESS,"Deactivating filter %p\n", pFilter ));
HRESULT hresGlobal = WBEM_S_NO_ERROR;
//
// Check if the events are supposed to come from this namespace or some
// other one.
//
CEssNamespace* pOtherNamespace = NULL;
hres = GetFilterEventNamespace(pFilter, &pOtherNamespace);
if(FAILED(hres))
return hres;
if( pOtherNamespace )
{
CTemplateReleaseMe<CEssNamespace> rm0(pOtherNamespace);
//
// Unregister this notification sink with the other namespace,
// as if it were a temporary consumer. This needs to be a
// postponed operation though, else we could have a deadlock
// scenario if at the same time cross namespace subscriptions
// were registered in both namespaces.
//
CPostponedRemoveNotificationSinkRequest* pReq;
pReq = new CPostponedRemoveNotificationSinkRequest(
pOtherNamespace,
pFilter->GetNonFilteringSink() );
if ( pReq == NULL )
{
return WBEM_E_OUT_OF_MEMORY;
}
CPostponedList* pList = GetCurrentPostponedList();
_DBG_ASSERT( pList != NULL );
hres = pList->AddRequest( this, pReq );
if ( FAILED(hres) )
{
delete pReq;
return hres;
}
return WBEM_S_NO_ERROR;
}
else
{
//
// Current namespace --- unregister for real
//
// Retrieve its non-filtering sink
// ===============================
CAbstractEventSink* pNonFilter = pFilter->GetNonFilteringSink();
if(pNonFilter == NULL)
return WBEM_E_OUT_OF_MEMORY;
//
// Report the MSFT_WmiFilterDeactivated event.
//
FireNCFilterEvent(MSFT_WmiFilterDeactivated, pFilter);
//
// Unregister it from class change notifications
//
hres = UnregisterFilterFromAllClassChanges(pFilter);
if(FAILED(hres))
hresGlobal = hres;
// Deactivate in providers, poller, and static search
// ==================================================
hres = m_EventProviderCache.ReleaseProvidersForQuery(pNonFilter);
if(FAILED(hres))
hresGlobal = hres;
hres = m_Poller.DeactivateFilter(pFilter);
if(FAILED(hres))
hresGlobal = hres;
pFilter->SetInactive();
return hres;
}
}
HRESULT CEssNamespace::HandleClassCreation( LPCWSTR wszClassName,
IWbemClassObject* pClass)
{
//
// Check if this is a class that a provider is waiting for.
//
ProviderSet setProviders;
{
CInCritSec ics( &m_csLevel1 );
ClassToProviderMap::iterator it;
it = m_mapProviderInterestClasses.find( wszClassName );
if ( it != m_mapProviderInterestClasses.end() )
{
//
// copy the interested provider list.
//
setProviders = it->second;
//
// remove the entry from the map.
//
m_mapProviderInterestClasses.erase( it );
}
}
if ( setProviders.size() > 0 )
{
//
// reload interested providers.
//
DEBUGTRACE((LOG_ESS,"Reloading some providers in namespace %S due to "
"creation of %S class\n", m_wszName, wszClassName ));
ProviderSet::iterator itProv;
for( itProv=setProviders.begin(); itProv!=setProviders.end(); itProv++)
{
ReloadProvider( 0, *itProv );
}
}
return S_OK;
}
//*****************************************************************************
//
// Updates internal structures to reflect a change to this class. Assumes that
// the namespace is already locked.
// Very few errors are reported from this function, since class changes cannot
// be vetoed.
//
//*****************************************************************************
HRESULT CEssNamespace::HandleClassChange(LPCWSTR wszClassName,
IWbemClassObject* pClass)
{
// Check if the class in question is an event consumer class
// =========================================================
if(pClass->InheritsFrom(CONSUMER_CLASS) == S_OK)
{
CInUpdate iu(this);
HandleConsumerClassDeletion(wszClassName);
}
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::HandleConsumerClassDeletion(LPCWSTR wszClassName)
{
// There are two varieties: non-singleton and singleton
// ====================================================
LPWSTR wszPrefix = new WCHAR[wcslen(wszClassName) + 2];
if(wszPrefix == NULL)
return WBEM_E_OUT_OF_MEMORY;
CVectorDeleteMe<WCHAR> vdm( wszPrefix );
swprintf(wszPrefix, L"%s.", wszClassName);
m_Bindings.RemoveConsumersStartingWith(wszPrefix);
swprintf(wszPrefix, L"%s=", wszClassName);
m_Bindings.RemoveConsumersStartingWith(wszPrefix);
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::ReloadProvider( long lFlags, LPCWSTR wszProvider )
{
HRESULT hres;
WString wsRelpath;
//
// we only have to do this for event providers. Check to see if
// we know about this try to see if we even have any event providers to reload ...
//
try
{
wsRelpath = L"__Win32Provider.Name='";
wsRelpath += wszProvider;
wsRelpath += L"'";
}
catch( CX_MemoryException )
{
return WBEM_E_OUT_OF_MEMORY;
}
CWbemPtr<_IWmiObject> pObj;
hres = GetInstance( wsRelpath, &pObj );
if ( SUCCEEDED(hres) )
{
{
ENSURE_INITIALIZED
CInResync ir(this);
//
// note : in case of reloading event provider due to notification
// from provss, we only need to handle event providers since
// consumer providers already have a reloading mechanism.
//
m_EventProviderCache.RemoveProvider(pObj);
hres = AddProvider( pObj );
}
if ( SUCCEEDED(hres) )
{
hres = FirePostponedOperations();
}
else
{
FirePostponedOperations();
}
}
return hres;
}
HRESULT CEssNamespace::ReloadProvider(IWbemClassObject* pProvObjTemplate)
{
HRESULT hres;
LogOp( L"ReloadProvider", pProvObjTemplate );
ENSURE_INITIALIZED
CInResync ir(this);
// Start by deleting this provider from our records, if there
// ==========================================================
hres = RemoveProvider(pProvObjTemplate);
if(FAILED(hres))
return hres;
// Determine the current state of this provider in the database
// ============================================================
IWbemClassObject* pProvObj = NULL;
hres = GetCurrentState(pProvObjTemplate, &pProvObj);
if(FAILED(hres))
return hres;
if(pProvObj == NULL)
{
// The provider has been deleted --- no further action is needed
// =============================================================
return S_OK;
}
CReleaseMe rm1(pProvObj);
// Now create it if necessary
// ==========================
hres = AddProvider(pProvObj);
if(FAILED(hres))
return hres;
return hres;
}
HRESULT CEssNamespace::ReloadEventProviderRegistration(
IWbemClassObject* pProvRegObjTemplate)
{
HRESULT hres;
LogOp( L"ReloadEventProviderRegistration", pProvRegObjTemplate );
ENSURE_INITIALIZED
CInResync ir(this);
// Start by deleting this provider from our records, if there
// ==========================================================
hres = RemoveEventProviderRegistration(pProvRegObjTemplate);
if(FAILED(hres))
return hres;
// Determine the current state of this registration in the database
// ================================================================
IWbemClassObject* pProvRegObj = NULL;
hres = GetCurrentState(pProvRegObjTemplate, &pProvRegObj);
if(FAILED(hres))
return hres;
if(pProvRegObj == NULL)
{
// The registration has been deleted --- no further action is needed
// =================================================================
return S_OK;
}
CReleaseMe rm1(pProvRegObj);
// Now create it if necessary
// ==========================
hres = AddEventProviderRegistration(pProvRegObj);
if(FAILED(hres))
return hres;
return hres;
}
HRESULT CEssNamespace::ReloadConsumerProviderRegistration(
IWbemClassObject* pProvRegObjTemplate)
{
CInUpdate iu(this);
// Reset consumer provider info in all the consumers using this consumer
// provider. That's all we need to do --- they will simply pick up the new
// data on next delivery. We don't even need to get the current version,
// since all we need is the key
// ========================================================================
return RemoveConsumerProviderRegistration(pProvRegObjTemplate);
}
//*****************************************************************************
//
// Assumes that the namespace is locked and PrepareForResync has been called
// Adds this provider to the records. Expects ReactivateAllFilters and
// CommitResync to be called later
//
//*****************************************************************************
HRESULT CEssNamespace::AddProvider(READ_ONLY IWbemClassObject* pProv)
{
HRESULT hres;
hres = m_EventProviderCache.AddProvider(pProv);
return hres;
}
HRESULT CEssNamespace::CheckEventProviderRegistration(IWbemClassObject* pReg)
{
HRESULT hres;
ENSURE_INITIALIZED
hres = m_EventProviderCache.CheckProviderRegistration(pReg);
return hres;
}
HRESULT CEssNamespace::CheckTimerInstruction(IWbemClassObject* pInst)
{
HRESULT hres;
ENSURE_INITIALIZED
hres = GetTimerGenerator().CheckTimerInstruction(pInst);
return hres;
}
//*****************************************************************************
//
// Assumes that the namespace is locked and PrepareForResync has been called
// Adds this event provider registration to the records. Expects
// ReactivateAllFilters and CommitResync to be called later
//
//*****************************************************************************
HRESULT CEssNamespace::AddEventProviderRegistration(
IWbemClassObject* pReg)
{
HRESULT hres;
hres = m_EventProviderCache.AddProviderRegistration(pReg);
return hres;
}
//*****************************************************************************
//
// Assumes that the namespace is locked and PrepareForResync has been called
// Removes this provider from the records. Expects ReactivateAllFilters and
// CommitResync to be called later
//
//*****************************************************************************
HRESULT CEssNamespace::RemoveProvider(READ_ONLY IWbemClassObject* pProv)
{
HRESULT hres;
// Handle event consumer providers
// ===============================
IWbemClassObject* pConsProvReg;
hres = m_ConsumerProviderCache.
GetConsumerProviderRegFromProviderReg(pProv, &pConsProvReg);
if(SUCCEEDED(hres))
{
RemoveConsumerProviderRegistration(pConsProvReg);
pConsProvReg->Release();
}
// Handle event providers
// ======================
hres = m_EventProviderCache.RemoveProvider(pProv);
return hres;
}
//*****************************************************************************
//
// Assumes that the namespace is locked and PrepareForResync has been called
// Adds this event provider registration to the records. Expects
// ReactivateAllFilters and CommitResync to be called later
//
//*****************************************************************************
HRESULT CEssNamespace::RemoveEventProviderRegistration(
READ_ONLY IWbemClassObject* pReg)
{
HRESULT hres;
hres = m_EventProviderCache.RemoveProviderRegistration(pReg);
return hres;
}
DWORD CEssNamespace::GetProvidedEventMask(IWbemClassObject* pClass)
{
return m_EventProviderCache.GetProvidedEventMask(pClass);
}
//*****************************************************************************
//
// This function is called before a major update to the records. Without any
// calls to external components, it "deactivates" all the filters, in a sense
// that when all of them are "reactivated", the system will arrive in a
// consistent state (usage counts, etc). CommitResync will then perform any
// necessary activations/deactivations based on the new state
//
//*****************************************************************************
HRESULT CEssNamespace::PrepareForResync()
{
m_bInResync = TRUE;
// Ask the poller to "virtually" stop all polling instructions, without
// actually stopping them physically
// ====================================================================
m_Poller.VirtuallyStopPolling();
// Ask provider cache to "virtually" release all its providers, without
// actually releasing them physically
// ====================================================================
m_EventProviderCache.VirtuallyReleaseProviders();
// Ask core search to mark all filters so that it would know which ones are
// gone after the resync
// ========================================================================
DEBUGTRACE((LOG_ESS,"Prepared resync in namespace %S\n", m_wszName ));
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::ReactivateAllFilters()
{
DEBUGTRACE((LOG_ESS,"Reactivating all filters in namespace %S\n",
m_wszName ));
return m_Bindings.ReactivateAllFilters();
}
HRESULT CEssNamespace::CommitResync()
{
m_bInResync = FALSE;
// Tell provider cache to perform all the loadings and unloadings it
// needs to perform based on the new data
// =================================================================
m_EventProviderCache.CommitProviderUsage();
// Tell the poller to cancel unnecessary instructions
// ==================================================
m_Poller.CancelUnnecessaryPolling();
DEBUGTRACE((LOG_ESS,"Committed resync in namespace %S\n", m_wszName ));
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::RemoveConsumerProviderRegistration(
IWbemClassObject* pReg)
{
// Get the name of the consumer provider being deleteed
// ====================================================
BSTR strProvRef = CConsumerProviderCache::GetProviderRefFromRecord(pReg);
if(strProvRef == NULL)
{
ERRORTRACE((LOG_ESS, "Invalid consumer provider record is being deleted"
"\n"));
return WBEM_S_FALSE;
}
CSysFreeMe sfm1(strProvRef);
// Reset it in all the consumers
// =============================
m_Bindings.ResetProviderRecords(strProvRef);
// Remove it from the cache
// ========================
m_ConsumerProviderCache.RemoveConsumerProvider(strProvRef);
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::ScheduleDelivery(CQueueingEventSink* pDest)
{
return m_pEss->EnqueueDeliver(pDest);
}
HRESULT CEssNamespace::DecorateObject(IWbemClassObject* pObj)
{
return m_pEss->DecorateObject(pObj, m_wszName);
}
HRESULT CEssNamespace::EnsureConsumerWatchInstruction()
{
return m_Bindings.EnsureConsumerWatchInstruction();
}
HRESULT CEssNamespace::AddSleepCharge(DWORD dwSleep)
{
return m_pEss->AddSleepCharge(dwSleep);
}
HRESULT CEssNamespace::AddCache()
{
return m_pEss->AddCache();
}
HRESULT CEssNamespace::RemoveCache()
{
return m_pEss->RemoveCache();
}
HRESULT CEssNamespace::AddToCache(DWORD dwAdd, DWORD dwMemberTotal,
DWORD* pdwSleep)
{
return m_pEss->AddToCache(dwAdd, dwMemberTotal, pdwSleep);
}
HRESULT CEssNamespace::RemoveFromCache(DWORD dwRemove)
{
return m_pEss->RemoveFromCache(dwRemove);
}
HRESULT CEssNamespace::PerformSubscriptionInitialization()
{
HRESULT hres;
DWORD dwRead;
//
// must use repository only svc ptr here, else we can deadlock when
// class providers try to call back in.
//
#ifdef __WHISTLER_UNCUT
// Enumerator all EventMonitors
// ============================
CMonitorEnumSink* pMonitorSink = new CMonitorEnumSink(this);
if ( NULL == pMonitorSink )
{
return WBEM_E_OUT_OF_MEMORY;
}
pMonitorSink->AddRef();
m_pInternalCoreSvc->InternalCreateInstanceEnum(MONITOR_CLASS, 0,
pMonitorSink);
pMonitorSink->ReleaseAndWait();
#endif
// Enumerator all EventFilters
// ===========================
CFilterEnumSink* pFilterSink = new CFilterEnumSink(this);
if ( NULL == pFilterSink )
{
return WBEM_E_OUT_OF_MEMORY;
}
pFilterSink->AddRef();
m_pInternalCoreSvc->InternalCreateInstanceEnum( EVENT_FILTER_CLASS, 0,
pFilterSink);
pFilterSink->ReleaseAndWait();
// Enumerator all consumers
// ========================
CConsumerEnumSink* pConsumerSink = new CConsumerEnumSink(this);
if ( NULL == pConsumerSink )
{
return WBEM_E_OUT_OF_MEMORY;
}
pConsumerSink->AddRef();
m_pInternalCoreSvc->InternalCreateInstanceEnum( CONSUMER_CLASS, 0,
pConsumerSink);
pConsumerSink->ReleaseAndWait();
// Enumerator all bindings
// =======================
CBindingEnumSink* pBindingSink = new CBindingEnumSink(this);
if ( NULL == pBindingSink )
{
return WBEM_E_OUT_OF_MEMORY;
}
pBindingSink->AddRef();
m_pInternalCoreSvc->InternalCreateInstanceEnum( BINDING_CLASS, 0,
pBindingSink);
pBindingSink->ReleaseAndWait();
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::PerformProviderInitialization()
{
HRESULT hres;
DWORD dwRead;
//
// make sure that we resync all subscriptions after we've processed
// provider objs
//
CInResync ir( this );
//
// Enumerate all the providers
//
IEnumWbemClassObject* penumProvs;
hres = m_pCoreSvc->CreateInstanceEnum( PROVIDER_CLASS,
WBEM_FLAG_DEEP,
GetCurrentEssContext(),
&penumProvs );
if ( SUCCEEDED(hres) )
{
CReleaseMe rm1(penumProvs);
// Add them all to ESS
// ===================
IWbemClassObject* pProvObj;
while((hres=penumProvs->Next(INFINITE, 1, &pProvObj, &dwRead)) == S_OK)
{
hres = AddProvider(pProvObj);
pProvObj->Release();
if(FAILED(hres))
{
// Already logged.
}
}
}
if ( FAILED(hres) )
{
ERRORTRACE((LOG_ESS, "Error 0x%X occurred enumerating event providers "
"in namespace %S. Some event providers may not be active\n", hres,
m_wszName));
}
//
// Enumerate all the provider registrations
//
IEnumWbemClassObject* penumRegs;
hres = m_pCoreSvc->CreateInstanceEnum( EVENT_PROVIDER_REGISTRATION_CLASS,
WBEM_FLAG_DEEP,
GetCurrentEssContext(),
&penumRegs);
if ( SUCCEEDED(hres) )
{
CReleaseMe rm2(penumRegs);
// Add them all to ESS
// ===================
IWbemClassObject* pRegObj;
while((hres = penumRegs->Next(INFINITE, 1, &pRegObj, &dwRead)) == S_OK)
{
hres = AddEventProviderRegistration(pRegObj);
pRegObj->Release();
if(FAILED(hres))
{
// Already logged
}
}
}
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS, "Error 0x%X occurred enumerating event providers "
"registrations in namespace %S. "
"Some event providers may not be active\n", hres, m_wszName));
}
//
// Create and initialize the core provider.
//
CWbemPtr<CCoreEventProvider> pCoreEventProvider = new CCoreEventProvider;
if ( pCoreEventProvider != NULL )
{
hres = pCoreEventProvider->SetNamespace(this);
if ( SUCCEEDED(hres) )
{
LPCWSTR awszQuery[5] =
{
L"select * from __InstanceOperationEvent",
L"select * from __ClassOperationEvent",
L"select * from __NamespaceOperationEvent",
L"select * from __SystemEvent",
L"select * from __TimerEvent"
};
hres = m_EventProviderCache.AddSystemProvider(pCoreEventProvider,
L"$Core",
5,
awszQuery );
}
}
else
{
hres = WBEM_E_OUT_OF_MEMORY;
}
if ( SUCCEEDED(hres) )
{
pCoreEventProvider->AddRef();
m_pCoreEventProvider = pCoreEventProvider;
}
else
{
ERRORTRACE((LOG_ESS, "Core event provider cannot initialize due "
"to critical errors. HR=0x%x\n", hres));
}
#ifdef __WHISTLER_UNCUT
//
// Create and initialize the monitor provider.
//
CWbemPtr<CMonitorProvider> pMonitorProvider = new CMonitorProvider;
if ( pMonitorProvider != NULL )
{
hres = pMonitorProvider->SetNamespace(this);
if ( SUCCEEDED(hres) )
{
LPCWSTR wszQuery = L"select * from "MONITOR_BASE_EVENT_CLASS;
hres = m_EventProviderCache.AddSystemProvider( pMonitorProvider,
L"__Monitor",
1,
&wszQuery );
}
}
else
{
hres = WBEM_E_OUT_OF_MEMORY;
}
if ( SUCCEEDED(hres) )
{
pMonitorProvider->AddRef();
m_pMonitorProvider = pMonitorProvider;
}
else
{
ERRORTRACE((LOG_ESS, "Monitor event provider cannot initialize due "
"to critical errors. HR=0x%x\n", hres));
}
#endif
// Initialize timer generator
// ==========================
hres = InitializeTimerGenerator();
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS, "Error 0x%X occurred initializing the timer "
"in namespace %S. Some timer instructions may not be active\n",
hres, m_wszName));
}
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::InitializeTimerGenerator()
{
return m_pEss->InitializeTimerGenerator( m_wszName, m_pCoreSvc );
}
HRESULT CEssNamespace::FirePostponedOperations()
{
HRESULT hr, hrReturn = WBEM_S_NO_ERROR;
//
// Update lock cannot be held when calling this function and there
// are operations to execute.
//
_DBG_ASSERT( !DoesThreadOwnNamespaceLock() );
//
// execute both primary and event postponed ops until empty.
//
CPostponedList* pList = GetCurrentPostponedList();
CPostponedList* pEventList = GetCurrentPostponedEventList();
do
{
//
// execute the primary postponed ops.
//
if( pList != NULL )
{
hr = pList->Execute(this, CPostponedList::e_ReturnOneError);
if ( SUCCEEDED(hrReturn) )
{
hrReturn = hr;
}
}
//
// now execute postponed events
//
if ( pEventList != NULL )
{
hr = pEventList->Execute(this, CPostponedList::e_ReturnOneError);
if ( SUCCEEDED(hrReturn) )
{
hrReturn = hr;
}
}
}
while( pList != NULL && !pList->IsEmpty() );
return hrReturn;
}
HRESULT CEssNamespace::PostponeRelease(IUnknown* pUnk)
{
CPostponedList* pList = GetCurrentPostponedList();
if(pList == NULL)
{
//
// Just execute it
//
pUnk->Release();
return WBEM_S_NO_ERROR;
}
CPostponedReleaseRequest* pReq = new CPostponedReleaseRequest(pUnk);
if(pReq == NULL)
return WBEM_E_OUT_OF_MEMORY;
//
// this is a namespace agnostic postponed request, so specify null.
//
return pList->AddRequest( NULL, pReq );
}
HRESULT CEssNamespace::GetProviderNamespacePointer(IWbemServices** ppServices)
{
IWbemServices* pServices = NULL;
HRESULT hres = m_pEss->GetNamespacePointer(m_wszName, FALSE, &pServices);
if(FAILED(hres))
return hres;
IWbemUnloadingControl* pControl = NULL;
pServices->QueryInterface(IID_IWbemUnloadingControl,
(void**)&pControl);
if(pControl)
{
pControl->SetMustPreventUnloading(true);
pControl->Release();
}
*ppServices = pServices;
return WBEM_S_NO_ERROR;
}
void CEssNamespace::IncrementObjectCount()
{
m_pEss->IncrementObjectCount();
}
void CEssNamespace::DecrementObjectCount()
{
m_pEss->DecrementObjectCount();
}
HRESULT CEssNamespace::LockForUpdate()
{
m_csLevel2.Enter();
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::UnlockForUpdate()
{
m_ClassCache.Clear();
m_csLevel2.Leave();
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::GetCurrentState( IWbemClassObject* pTemplate,
IWbemClassObject** ppObj)
{
HRESULT hres;
*ppObj = NULL;
// Retrieve the path
// =================
VARIANT vPath;
hres = pTemplate->Get(L"__RELPATH", 0, &vPath, NULL, NULL);
if(FAILED(hres))
return hres;
CClearMe cm1(&vPath);
if(V_VT(&vPath) != VT_BSTR)
return WBEM_E_INVALID_OBJECT;
// Get it from the namespace
// =========================
_IWmiObject* pObj;
hres = GetInstance( V_BSTR(&vPath), &pObj );
if( hres == WBEM_E_NOT_FOUND )
return WBEM_S_FALSE;
*ppObj = pObj;
return hres;
}
CWinMgmtTimerGenerator& CEssNamespace::GetTimerGenerator()
{
return m_pEss->GetTimerGenerator();
}
HRESULT CEssNamespace::RaiseErrorEvent(IWbemEvent* pEvent)
{
CEventRepresentation Event;
Event.type = e_EventTypeSystem;
Event.nObjects = 1;
Event.apObjects = &pEvent;
HRESULT hres;
hres = SignalEvent( Event, 0 );
if(FAILED(hres))
{
ERRORTRACE((LOG_ESS, "Event subsystem was unable to deliver an "
"error event to some consumers (%X)\n", hres));
}
return S_OK;
}
HRESULT CEssNamespace::GetClassFromCore( LPCWSTR wszClassName,
_IWmiObject** ppClass )
{
HRESULT hres;
CWbemPtr<IWbemClassObject> pClass;
*ppClass = NULL;
//
// want to ensure that we don't use the full service ptr until we've
// completed stage 1 initialization. Reason is that we don't want to
// load class providers until the second stage of initialization.
//
_DBG_ASSERT( m_bStage1Complete );
//
// must use full service because will need to support dynamic classes.
//
hres = m_pInternalFullSvc->InternalGetClass( wszClassName, &pClass );
if ( FAILED(hres) )
{
return hres;
}
return pClass->QueryInterface( IID__IWmiObject, (void**)ppClass );
}
HRESULT CEssNamespace::GetInstance( LPCWSTR wszPath,
_IWmiObject** ppInstance )
{
HRESULT hres;
CWbemPtr<IWbemClassObject> pInstance;
*ppInstance = NULL;
hres = m_pInternalCoreSvc->InternalGetInstance( wszPath, &pInstance );
if ( FAILED(hres) )
{
return hres;
}
return pInstance->QueryInterface( IID__IWmiObject, (void**)ppInstance );
}
HRESULT CEssNamespace::GetDbInstance( LPCWSTR wszDbKey,
_IWmiObject** ppInstance)
{
HRESULT hres;
CWbemPtr<IWbemClassObject> pInstance;
*ppInstance = NULL;
hres = m_pInternalCoreSvc->GetDbInstance( wszDbKey, &pInstance );
if ( FAILED(hres) )
{
return hres;
}
return pInstance->QueryInterface( IID__IWmiObject, (void**)ppInstance );
}
HRESULT CEssNamespace::CreateInstanceEnum(LPCWSTR wszClass, long lFlags,
IWbemObjectSink* pSink)
{
return m_pInternalCoreSvc->InternalCreateInstanceEnum(wszClass, lFlags, pSink);
}
HRESULT CEssNamespace::ExecQuery(LPCWSTR wszQuery, long lFlags,
IWbemObjectSink* pSink)
{
return m_pInternalCoreSvc->InternalExecQuery(L"WQL", wszQuery, lFlags, pSink);
}
HRESULT CEssNamespace::GetToken(PSID pSid, IWbemToken** ppToken)
{
return m_pEss->GetToken(pSid, ppToken);
}
void CEssNamespace::DumpStatistics(FILE* f, long lFlags)
{
CInUpdate iu(this);
fprintf(f, "------- Namespace '%S' ----------\n", m_wszName);
m_Bindings.DumpStatistics(f, lFlags);
m_ConsumerProviderCache.DumpStatistics(f, lFlags);
m_EventProviderCache.DumpStatistics(f, lFlags);
m_Poller.DumpStatistics(f, lFlags);
}
HRESULT CEssMetaData::GetClass( LPCWSTR wszName, IWbemContext* pContext,
_IWmiObject** ppClass)
{
return m_pNamespace->m_ClassCache.GetClass(wszName, pContext, ppClass);
}
STDMETHODIMP CEssNamespace::CConsumerClassDeletionSink::Indicate(
long lNumObjects,
IWbemClassObject** apObjects)
{
HRESULT hres;
for(long i = 0; i < lNumObjects; i++)
{
_IWmiObject* pEvent = NULL;
apObjects[i]->QueryInterface(IID__IWmiObject, (void**)&pEvent);
CReleaseMe rm1(pEvent);
//
// Get the class name of the class being deleted
//
VARIANT vObj;
hres = pEvent->Get(L"TargetClass", 0, &vObj, NULL, NULL);
if(SUCCEEDED(hres))
{
CClearMe cm1(&vObj);
IWbemClassObject* pClass;
V_UNKNOWN(&vObj)->QueryInterface(IID_IWbemClassObject,
(void**)&pClass);
CReleaseMe rm2(pClass);
VARIANT vClass;
hres = pClass->Get(L"__CLASS", 0, &vClass, NULL, NULL);
if(SUCCEEDED(hres))
{
CClearMe cm(&vClass);
m_pOuter->HandleConsumerClassDeletion(V_BSTR(&vClass));
}
}
}
return WBEM_S_NO_ERROR;
}
HRESULT CEssNamespace::LoadEventProvider(LPCWSTR wszProviderName,
IWbemEventProvider** ppProv)
{
HRESULT hres;
*ppProv = NULL;
//
// Get provider pointer from the provider subsystem
//
if(m_pProviderFactory == NULL)
return WBEM_E_CRITICAL_ERROR;
WmiInternalContext t_InternalContext ;
ZeroMemory ( & t_InternalContext , sizeof ( t_InternalContext ) ) ;
hres = m_pProviderFactory->GetProvider(
t_InternalContext ,
0, // lFlags
GetCurrentEssContext(),
0,
NULL,
NULL,
0,
wszProviderName,
IID_IWbemEventProvider,
(LPVOID *) ppProv
);
return hres;
}
HRESULT CEssNamespace::LoadConsumerProvider(LPCWSTR wszProviderName,
IUnknown** ppProv)
{
HRESULT hres;
*ppProv = NULL;
//
// Get provider pointer from the provider subsystem
//
if(m_pProviderFactory == NULL)
return WBEM_E_CRITICAL_ERROR;
WmiInternalContext t_InternalContext ;
ZeroMemory ( & t_InternalContext , sizeof ( t_InternalContext ) ) ;
hres = m_pProviderFactory->GetProvider(
t_InternalContext ,
0, // lFlags
GetCurrentEssContext(),
0,
NULL,
NULL,
0,
wszProviderName,
IID_IUnknown,
(LPVOID *) ppProv
);
return hres;
}