windows-server-2003/admin/wmi/wbem/winmgmt/stdprov/regereq.cpp

/*++

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;
}