|
|
/*++
Copyright (C) 1996-2001 Microsoft Corporation
Module Name:
REGEREQ.CPP
Abstract:
History:
--*/
#include "precomp.h"
#include "regereq.h"
#include "regcrc.h"
#include <genutils.h>
#include "regeprov.h"
//******************************************************************************
//******************************************************************************
//
// GENERIC REQUEST
//
//******************************************************************************
//******************************************************************************
CRegistryEventRequest::CRegistryEventRequest(CRegEventProvider* pProvider, WBEM_QL1_TOLERANCE& Tolerance, DWORD dwId, HKEY hHive, LPWSTR wszHive, LPWSTR wszKey) : m_hHive(hHive), m_wsKey(wszKey), m_pProvider(pProvider), m_wsHive(wszHive), m_lActiveCount(0), m_bNew(TRUE), m_lRef(0), m_bOK(TRUE), m_dwLastCRC(0), m_hKey(NULL), m_hEvent(NULL), m_hWaitRegistration(NULL){ if(Tolerance.m_bExact) { m_dwMsWait = 0; } else { m_dwMsWait = Tolerance.m_fTolerance * 1000; }
if ( CFlexArray::no_error != m_adwIds.Add(ULongToPtr(dwId)) ) { throw CX_MemoryException( ); }}
CRegistryEventRequest::~CRegistryEventRequest(){ if (m_hKey) { RegCloseKey(m_hKey); } if(m_hEvent) { CloseHandle(m_hEvent); }}
void CRegistryEventRequest::AddRef(){ InterlockedIncrement(&m_lRef);}
void CRegistryEventRequest::Release(){ if(InterlockedDecrement(&m_lRef) == 0) delete this;}
BOOL CRegistryEventRequest::IsSameAs(CRegistryEventRequest* pOther){ if(GetType() != pOther->GetType()) return FALSE;
if(m_hHive != pOther->m_hHive) return FALSE;
if(!m_wsHive.EqualNoCase(pOther->m_wsHive)) return FALSE;
if(!m_wsKey.EqualNoCase(pOther->m_wsKey)) return FALSE;
return TRUE;}
DWORD CRegistryEventRequest::GetPrimaryId(){ return PtrToLong(m_adwIds[0]);}
BOOL CRegistryEventRequest::DoesContainId(DWORD dwId){ // not called
for(int i = 0; i < m_adwIds.Size(); i++) { if(PtrToLong(m_adwIds[i]) == dwId) return TRUE; } return FALSE;}
HRESULT CRegistryEventRequest::Reactivate(DWORD dwId, DWORD dwMsWait){ // This is only called on active objects.
CInCritSec ics(&m_cs);
if(m_dwMsWait > dwMsWait) m_dwMsWait = dwMsWait;
m_adwIds.Add(ULongToPtr(dwId));
InterlockedIncrement(&m_lActiveCount);
return WBEM_S_NO_ERROR;}
HRESULT CRegistryEventRequest::Activate(){ // This function doesn't need to enter a critical section
// for the reasons explained in the following argument.
// This reasoning might be invalidated by design changes.
// This is only called on new objects before they are added
// to the active request array.
// Since all the independent COM client threads get access
// to these objects through that array, this object is locked to
// all threads but the current one.
// Once RegisterWaitForSingleObject is called this object is registered
// with the thread pool but it won't be accessed because no events will
// occur until ResetOnChangeHandle is called by the worker thread.
// When m_pProvider->EnqueueEvent(this) is called then the worker thread
// has access to the object. At this point there is nothing left to do
// but return.
// Open the key
// ============
#ifdef UNICODE
long lRes = RegOpenKeyEx(m_hHive, m_wsKey, 0, KEY_READ, &m_hKey);#else
LPSTR szName = m_wsKey.GetLPSTR(); long lRes = RegOpenKeyEx(m_hHive, szName, 0, KEY_READ, &m_hKey); delete [] szName;#endif
if(lRes) { return WBEM_E_INVALID_PARAMETER; }
// Create an event
// ===============
m_hEvent = CreateEvent(NULL, // lpEventAttributes
FALSE, // bManualReset
FALSE, // bInitialState
NULL); // lpName
if ( m_hEvent == NULL ) return WBEM_E_OUT_OF_MEMORY;
if ( !RegisterWaitForSingleObject( &m_hWaitRegistration, // phNewWaitObject
m_hEvent, // hObject
CRegEventProvider::EnqueueEvent, // Callback
this, // Context
INFINITE, // dwMilliseconds
WT_EXECUTEINWAITTHREAD) ) // dwFlags
{ return HRESULT_FROM_WIN32( GetLastError() ); } // This represents the thread pool's reference.
AddRef();
// It will be connected to the key by the worker thread
// because when the thread that calls RegNotifyChangeKeyValue
// exits the event is signaled. Therefore if this thread called
// RegNotifyChangeKeyValue then we would get a spurious event when
// this thread exits. When the worker thread exits all the event
// subscriptions will have already been cancelled.
// ==========================================================
m_bNew = TRUE;
CacheValue();
m_pProvider->EnqueueEvent(this);
return S_OK;}
BOOL CRegistryEventRequest::ResetOnChangeHandle(){ // This is only called from ProcessEvent which has already
// acquired the lock.
m_bNew = FALSE;
long lRes = RegNotifyChangeKeyValue( m_hKey, // hKey
(GetType() == e_RegTreeChange), // bWatchSubtree
REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_LAST_SET | REG_NOTIFY_CHANGE_ATTRIBUTES, // dwNotifyFilter
m_hEvent, // hEvent
TRUE); // fAsynchronous
return (lRes == 0);}
HANDLE CRegistryEventRequest::GetOnChangeHandle() { // not called
return m_hEvent;}
HRESULT CRegistryEventRequest::Deactivate(DWORD dwId){ CInCritSec ics(&m_cs);
// Remove the ID from the list
// ===========================
bool bFoundId = false; int nIdCount = m_adwIds.Size();
for(int i = 0; i < nIdCount; i++) { if(PtrToLong(m_adwIds[i]) == dwId) { m_adwIds.RemoveAt(i); bFoundId = true; break; } }
if(!bFoundId || (InterlockedDecrement(&m_lActiveCount) >= 0)) return WBEM_S_FALSE;
// Unregister the event with the thread pool and wait for
// pending requests to be processed.
// We wait because this object could be released and deleted when this
// function returns which would mean the thread pool holds an invalid
// pointer.
// When the thread pool processes a request it places it in the worker thread
// queue which AddRefs the request.
UnregisterWaitEx(m_hWaitRegistration, // WaitHandle
INVALID_HANDLE_VALUE); // CompletionEvent
m_hWaitRegistration = NULL;
// This will signal m_hEvent but we just unregistered it
// so nobody is waiting on it.
RegCloseKey(m_hKey); m_hKey = 0;
CloseHandle(m_hEvent); m_hEvent = 0;
// The thread pool no longer holds a reference
// so call Release on its behalf.
Release();
return S_OK;}
HRESULT CRegistryEventRequest::ForceDeactivate(void){ CInCritSec ics(&m_cs);
// deactivate the event request
InterlockedExchange(&m_lActiveCount, -1);
// Remove all IDs from the list
int nIdCount = m_adwIds.Size();
m_adwIds.Empty();
// Unregister the event with the thread pool and wait for
// pending requests to be processed.
// We wait because this object could be released and deleted when this
// function returns which would mean the thread pool holds an invalid
// pointer.
// When the thread pool processes a request it places it in the worker thread
// queue which AddRefs the request.
UnregisterWaitEx(m_hWaitRegistration, // WaitHandle
INVALID_HANDLE_VALUE); // CompletionEvent
m_hWaitRegistration = NULL;
// This will signal m_hEvent but we just unregistered it
// so nobody is waiting on it.
RegCloseKey(m_hKey); m_hKey = 0;
CloseHandle(m_hEvent); m_hEvent = 0;
// The thread pool no longer holds a reference
// so call Release on its behalf.
Release();
return S_OK;}
HRESULT CRegistryEventRequest::Execute(BOOL bOnTimer){ // If called by the timer, we need to check if anything actually changed
// =====================================================================
if(bOnTimer || GetType() == e_RegValueChange) { DWORD dwNewCRC; HRESULT hres = ComputeCRC(dwNewCRC); if(FAILED(hres)) { return hres; } if(dwNewCRC == m_dwLastCRC) { // No real change. Return
// ======================
return S_FALSE; }
m_dwLastCRC = dwNewCRC; }
// If here, a real change has occurred
// ===================================
IWbemClassObject* pEvent;
HRESULT hres = CreateNewEvent(&pEvent); if(FAILED(hres)) { return hres; }
hres = m_pProvider->RaiseEvent(pEvent); pEvent->Release(); return hres;}
HRESULT CRegistryEventRequest::SetCommonProperties(IWbemClassObject* pEvent){ // Set the hive name
// =================
VARIANT v; VariantInit(&v); V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(m_wsHive); pEvent->Put(REG_HIVE_PROPERTY_NAME, 0, &v, NULL); VariantClear(&v);
return WBEM_S_NO_ERROR;}
void CRegistryEventRequest::ProcessEvent(){ CInCritSec ics(&m_cs);
if(IsActive()) { // New requests are immediately queued in order for the worker
// thread to initialize them. They don't represent actual events.
// We need to save the new status because ResetOnChangeHandle
// erases it.
BOOL bIsNew = IsNew(); ResetOnChangeHandle();
if (!bIsNew) { Execute(FALSE); } }}
//******************************************************************************
//******************************************************************************
//
// VALUE REQUEST
//
//******************************************************************************
//******************************************************************************
HRESULT CRegistryValueEventRequest::CreateNewEvent(IWbemClassObject** ppEvent){ *ppEvent = NULL; // Create an instance
// ==================
IWbemClassObject* pEvent; if ( FAILED(m_pProvider->m_pValueClass->SpawnInstance(0, &pEvent))) return WBEM_E_OUT_OF_MEMORY;
// Set the hive property
// =====================
SetCommonProperties(pEvent);
// Set the key
// ===========
VARIANT v; VariantInit(&v); V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(m_wsKey); pEvent->Put(REG_KEY_PROPERTY_NAME, 0, &v, NULL); VariantClear(&v);
// Set the value
// =============
V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(m_wsValue); pEvent->Put(REG_VALUE_PROPERTY_NAME, 0, &v, NULL); VariantClear(&v);
*ppEvent = pEvent; return WBEM_S_NO_ERROR;}
HRESULT CRegistryValueEventRequest::ComputeCRC(DWORD& dwCRC){#ifdef UNICODE
HRESULT hres = CRegCRC::ComputeValueCRC(m_hKey, m_wsValue, STARTING_CRC32_VALUE, dwCRC);#else
LPSTR szValue = m_wsValue.GetLPSTR(); HRESULT hres = CRegCRC::ComputeValueCRC(m_hKey, szValue, STARTING_CRC32_VALUE, dwCRC); delete [] szValue;#endif
return hres;}
HRESULT CRegistryValueEventRequest::Execute(BOOL bOnTimer){ // Since NT does not allow per-value change registration, CRC needs to be
// computed no matter what
// ======================================================================
return CRegistryEventRequest::Execute(TRUE);}
void CRegistryValueEventRequest::CacheValue(){ ComputeCRC(m_dwLastCRC);}
BOOL CRegistryValueEventRequest::IsSameAs(CRegistryEventRequest* pOther){ if(!CRegistryEventRequest::IsSameAs(pOther)) return FALSE;
CRegistryValueEventRequest* pValueOther = (CRegistryValueEventRequest*)pOther;
if(!m_wsValue.EqualNoCase(pValueOther->m_wsValue)) return FALSE;
return TRUE;}
//******************************************************************************
//******************************************************************************
//
// KEY REQUEST
//
//******************************************************************************
//******************************************************************************
HRESULT CRegistryKeyEventRequest::CreateNewEvent(IWbemClassObject** ppEvent){ *ppEvent = NULL; // Create an instance
// ==================
IWbemClassObject* pEvent; if ( FAILED(m_pProvider->m_pKeyClass->SpawnInstance(0, &pEvent) ) ) return WBEM_E_OUT_OF_MEMORY;
// Set the hive property
// =====================
SetCommonProperties(pEvent);
// Set the key
// ===========
VARIANT v; VariantInit(&v); V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(m_wsKey); pEvent->Put(REG_KEY_PROPERTY_NAME, 0, &v, NULL); VariantClear(&v);
*ppEvent = pEvent; return WBEM_S_NO_ERROR;}
HRESULT CRegistryKeyEventRequest::ComputeCRC(DWORD& dwCRC){ HRESULT hres = CRegCRC::ComputeKeyCRC(m_hKey, STARTING_CRC32_VALUE, dwCRC); return hres;} //******************************************************************************
//******************************************************************************
//
// TREE REQUEST
//
//******************************************************************************
//******************************************************************************
HRESULT CRegistryTreeEventRequest::CreateNewEvent(IWbemClassObject** ppEvent){ *ppEvent = NULL; // Create an instance
// ==================
IWbemClassObject* pEvent; if ( FAILED(m_pProvider->m_pTreeClass->SpawnInstance(0, &pEvent) ) ) return WBEM_E_OUT_OF_MEMORY;
// Set the hive property
// =====================
SetCommonProperties(pEvent);
// Set the root
// ============
VARIANT v; VariantInit(&v); V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(m_wsKey); pEvent->Put(REG_ROOT_PROPERTY_NAME, 0, &v, NULL); VariantClear(&v);
*ppEvent = pEvent; return WBEM_S_NO_ERROR;}
HRESULT CRegistryTreeEventRequest::ComputeCRC(DWORD& dwCRC){ HRESULT hres = CRegCRC::ComputeTreeCRC(m_hKey, STARTING_CRC32_VALUE, dwCRC); return hres;}
|
