/////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 1999-2002 Microsoft Corporation
//
//  Module Name:
//      ClusKeys.cpp
//
//  Description:
//      Implementation of the cluster registry and crypto key collection
//      classes for the MSCLUS automation classes.
//
//  Author:
//      Galen Barbee    (galenb)    12-Feb-1999
//
//  Revision History:
//
//  Notes:
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"

#if CLUSAPI_VERSION >= 0x0500
    #include <PropList.h>
#else
    #include "PropList.h"
#endif // CLUSAPI_VERSION >= 0x0500

#include "ClusKeys.h"

/////////////////////////////////////////////////////////////////////////////
// Global variables
/////////////////////////////////////////////////////////////////////////////
static const IID *  iidCClusRegistryKeys[] =
{
    &IID_ISClusRegistryKeys
};

static const IID *  iidCClusCryptoKeys[] =
{
    &IID_ISClusCryptoKeys
};


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CKeys class
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::CKeys
//
//  Description:
//      Constructor.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CKeys::CKeys( void )
{
    m_pClusRefObject = NULL;

} //*** CKeys::CKeys()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::~CKeys
//
//  Description:
//      Destructor.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CKeys::~CKeys( void )
{
    Clear();

    if ( m_pClusRefObject != NULL )
    {
        m_pClusRefObject->Release();
        m_pClusRefObject = NULL;
    }

} //*** CKeys::~CKeys()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::HrCreate
//
//  Description:
//      Finish creating the object by doing things that cannot be done in
//      a light weight constructor.
//
//  Arguments:
//      pClusRefObject  [IN]    - Wraps the cluster handle.
//
//  Return Value:
//      S_OK if successful or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CKeys::HrCreate( IN ISClusRefObject * pClusRefObject )
{
    ASSERT( pClusRefObject != NULL );

    HRESULT _hr = E_POINTER;

    if ( pClusRefObject != NULL )
    {
        m_pClusRefObject = pClusRefObject;
        m_pClusRefObject->AddRef();
        _hr = S_OK;
    }

    return _hr;

} //*** CKeys::HrCreate()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::Clear
//
//  Description:
//      Empty the vector of keys.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CKeys::Clear( void )
{
    if ( ! m_klKeys.empty() )
    {
        KeyList::iterator   _itCurrent = m_klKeys.begin();
        KeyList::iterator   _itLast = m_klKeys.end();

        for ( ; _itCurrent != _itLast; _itCurrent++ )
        {
            delete (*_itCurrent);
        } // for:

        m_klKeys.erase( m_klKeys.begin(), _itLast );
    } // if:

} //*** CKeys::Clear()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::FindItem
//
//  Description:
//      Find the passed in key in the vector and return its index.
//
//  Arguments:
//      pwsKey  [IN]    - The node to find.
//      pnIndex [OUT]   - Catches the node's index.
//
//  Return Value:
//
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CKeys::FindItem(
    IN  LPWSTR  pwsKey,
    OUT ULONG * pnIndex
    )
{
    //ASSERT( pwsKey != NULL );
    //ASSERT( pnIndex != NULL );

    HRESULT _hr = E_POINTER;

    if ( ( pwsKey != NULL ) && ( pnIndex != NULL ) )
    {
        _hr = E_INVALIDARG;

        if ( ! m_klKeys.empty() )
        {
            CComBSTR *          _pKey = NULL;
            KeyList::iterator   _itCurrent = m_klKeys.begin();
            KeyList::iterator   _itLast = m_klKeys.end();
            ULONG               _iIndex;

            for ( _iIndex = 0; _itCurrent != _itLast; _itCurrent++, _iIndex++ )
            {
                _pKey = *_itCurrent;

                if ( _pKey && ( ClRtlStrICmp( pwsKey, (*_pKey) ) == 0 ) )
                {
                    *pnIndex = _iIndex;
                    _hr = S_OK;
                    break;
                } // if: match!
            } // for: each item in the vector
        } // if: the vector is not empty
    } // if: args not NULL

    return _hr;

} //*** CKeys::FindItem()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::HrGetIndex
//
//  Description:
//      Convert the passed in 1 based index into a 0 based index.
//
//  Arguments:
//      varIndex    [IN]    - holds the 1 based index.
//      pnIndex     [OUT]   - catches the 0 based index.
//
//  Return Value:
//      S_OK if successful, E_POINTER, or E_INVALIDARG if out of range.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CKeys::HrGetIndex( IN VARIANT varIndex, OUT ULONG * pnIndex )
{
    //ASSERT( pnIndex != NULL );

    HRESULT _hr = E_POINTER;

    if ( pnIndex != NULL )
    {
        ULONG       _nIndex = 0;
        CComVariant _var;

        *pnIndex = 0;

        _hr = _var.Attach( &varIndex );
        if ( SUCCEEDED( _hr ) )
        {
            // Check to see if the index is a number.
            _hr = _var.ChangeType( VT_I4 );
            if ( SUCCEEDED( _hr ) )
            {
                _nIndex = _var.lVal;
                _nIndex--; // Adjust index to be 0 relative instead of 1 relative
            } // if: the variant is a number
            else
            {
                // Check to see if the index is a string
                _hr = _var.ChangeType( VT_BSTR );
                if ( SUCCEEDED( _hr ) )
                {
                    _hr = FindItem( _var.bstrVal, &_nIndex );
                } // if: the variant is a string
            } // else:

            if ( SUCCEEDED( _hr ) )
            {
                if ( _nIndex < m_klKeys.size() )
                {
                    *pnIndex = _nIndex;
                } // if: in range
                else
                {
                    _hr = E_INVALIDARG;
                } // else: out of range
            } // if: we found an index value

            _var.Detach( &varIndex );
        } // if: we attched to the variant
    } // if: args not NULL

    return _hr;

} //*** CKeys::HrGetIndex()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::HrGetItem
//
//  Description:
//      Get the key at the passed in index.
//
//  Arguments:
//      varIndex    [IN]    - Contains the index of the requested key.
//      ppKey       [OUT]   - Catches the key.
//
//  Return Value:
//      S_OK if successful, E_POINTER, or E_INVALIDARG if out of range.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CKeys::HrGetItem( IN VARIANT varIndex, OUT BSTR * ppKey )
{
    //ASSERT( ppKey != NULL );

    HRESULT _hr = E_POINTER;

    if ( ppKey != NULL )
    {
        ULONG   _nIndex = 0;

        _hr = HrGetIndex( varIndex, &_nIndex );
        if ( SUCCEEDED( _hr ) )
        {
            *ppKey = m_klKeys[ _nIndex ]->Copy();
            _hr = S_OK;
        }
    }

    return _hr;

} //*** CKeys::HrGetItem()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::HrRemoveAt
//
//  Description:
//      Remove the object from the vector at the passed in position.
//
//  Arguments:
//      pos [IN]    - the position of the object to remove.
//
//  Return Value:
//      S_OK if successful, or E_INVALIDARG if the position is out of range.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CKeys::HrRemoveAt( size_t pos )
{
    KeyList::iterator       _itCurrent = m_klKeys.begin();
    KeyList::const_iterator _itLast = m_klKeys.end();
    HRESULT                 _hr = E_INVALIDARG;
    size_t                  _iIndex;

    for ( _iIndex = 0; ( _iIndex < pos ) && ( _itCurrent != _itLast ); _iIndex++, _itCurrent++ )
    {
    } // for:

    if ( _itCurrent != _itLast )
    {
        m_klKeys.erase( _itCurrent );
        _hr = S_OK;
    }

    return _hr;

} //*** CKeys::HrRemoveAt()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::HrFindItem
//
//  Description:
//      Find the passed in key in the collection.
//
//  Arguments:
//      bstrKey [IN]    - The key to find.
//      pnIndex [OUT]   - Catches the index.
//
//  Return Value:
//      S_OK if found, or E_INVALIDARG if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CKeys::HrFindItem( IN BSTR bstrKey, OUT ULONG * pnIndex )
{
    HRESULT _hr = E_INVALIDARG;

    if ( ! m_klKeys.empty() )
    {
        KeyList::iterator   _itCurrent = m_klKeys.begin();
        KeyList::iterator   _itLast = m_klKeys.end();
        ULONG               _iIndex;

        for ( _iIndex = 0; _itCurrent != _itLast; _itCurrent++, _iIndex++ )
        {
            if ( lstrcmp( *(*_itCurrent), bstrKey ) == 0 )
            {
                *pnIndex = _iIndex;
                _hr = S_OK;
                break;
            }
        }
    } // if:

    return _hr;

} //*** CKeys::HrFindItem()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::HrGetCount
//
//  Description:
//      Get the count of objects in the collection.
//
//  Arguments:
//      plCount [OUT]   - Catches the count.
//
//  Return Value:
//      S_OK if successful or E_POINTER.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CKeys::HrGetCount( OUT long * plCount )
{
    //ASSERT( plCount != NULL );

    HRESULT _hr = E_POINTER;

    if ( plCount != NULL )
    {
        *plCount = m_klKeys.size();
        _hr = S_OK;
    }

    return _hr;

} //*** CKeys::HrGetCount()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::HrAddItem
//
//  Description:
//      Create a new key and add it to the collection.
//
//  Arguments:
//      bstrKey [IN]    - Registry key to add to the collection.
//
//  Return Value:
//      S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CKeys::HrAddItem( IN BSTR bstrKey )
{
    //ASSERT( bstrKey != NULL );

    HRESULT _hr = E_POINTER;

    if ( bstrKey != NULL )
    {
        ULONG _nIndex;

        _hr = HrFindItem( bstrKey, &_nIndex );
        if ( FAILED( _hr ) )
        {
            CComBSTR *  pbstr = NULL;

            pbstr = new CComBSTR( bstrKey );
            if ( pbstr != NULL )
            {
                m_klKeys.insert( m_klKeys.end(), pbstr );
                _hr = S_OK;
            } // if:
            else
            {
                _hr = E_OUTOFMEMORY;
            } // else:
        }
        else
        {
            _hr = E_INVALIDARG;
        } // else:
    }

    return _hr;

} //*** CKeys::HrAddItem()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CKeys::HrRemoveItem
//
//  Description:
//      Remove the key at the passed in index.
//
//  Arguments:
//      varIndex    [IN]    - contains the index to remove.
//
//  Return Value:
//      S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CKeys::HrRemoveItem( IN VARIANT varIndex )
{
    HRESULT _hr = S_OK;
    ULONG   _nIndex = 0;

    _hr = HrGetIndex( varIndex, &_nIndex );
    if ( SUCCEEDED( _hr ) )
    {
        delete m_klKeys[ _nIndex ];
        HrRemoveAt( _nIndex );
    }

    return _hr;

} //*** CKeys::HrRemoveItem()


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CResourceKeys class
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CResourceKeys::HrRefresh
//
//  Description:
//      Load the collection from the cluster database.
//
//  Arguments:
//      dwControlCode   [IN]    - Control code
//
//  Return Value:
//      S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResourceKeys::HrRefresh( IN DWORD dwControlCode )
{
    HRESULT _hr = S_FALSE;
    PWSTR   _psz = NULL;
    DWORD   _cbPsz = 512;
    DWORD   _cbRequired = 0;
    DWORD   _sc = ERROR_SUCCESS;

    _psz = (PWSTR) ::LocalAlloc( LMEM_ZEROINIT, _cbPsz );
    if ( _psz != NULL )
    {
        _sc = ::ClusterResourceControl(
                        m_hResource,
                        NULL,
                        dwControlCode,
                        NULL,
                        0,
                        _psz,
                        _cbPsz,
                        &_cbRequired
                        );
        if ( _sc == ERROR_MORE_DATA )
        {
            ::LocalFree( _psz );
            _psz = NULL;
            _cbPsz = _cbRequired;

            _psz = (PWSTR) ::LocalAlloc( LMEM_ZEROINIT, _cbPsz );
            if ( _psz != NULL )
            {
                _sc = ::ClusterResourceControl(
                                m_hResource,
                                NULL,
                                dwControlCode,
                                NULL,
                                0,
                                _psz,
                                _cbPsz,
                                &_cbRequired
                                );
                _hr = HRESULT_FROM_WIN32( _sc );
            } // if: alloc OK
            else
            {
                _sc = GetLastError();
                _hr = HRESULT_FROM_WIN32( _sc );
            } // else: alloc failed
        } // if: error was no more item, re-alloc and try again.
        else
        {
            _hr = HRESULT_FROM_WIN32( _sc );
        } // else: error was not no more items -- could be no error

        if ( SUCCEEDED( _hr ) )
        {
            CComBSTR *  _pbstr = NULL;

            Clear();

            while( *_psz != L'\0' )
            {
                _pbstr = new CComBSTR( _psz );
                if ( _pbstr != NULL )
                {
                    m_klKeys.insert( m_klKeys.end(), _pbstr );
                    _psz += wcslen( _psz ) + 1;
                    _pbstr = NULL;
                } // if:
                else
                {
                    _hr = E_OUTOFMEMORY;
                    break;
                } // else:
            } // while: not EOS
        } // if: keys were retrieved ok

        ::LocalFree( _psz );
    } // if: alloc ok
    else
    {
        _sc = GetLastError();
        _hr = HRESULT_FROM_WIN32( _sc );
    } // else: alloc failed

    return _hr;

} //*** CResourceKeys::HrRefresh()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CResourceKeys::HrAddItem
//
//  Description:
//      Create a new key and add it to the collection.
//
//  Arguments:
//      bstrKey         [IN]    - Registry key to add to the collection.
//      dwControlCode   [IN]    - Control code
//
//  Return Value:
//      S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResourceKeys::HrAddItem(
    IN BSTR     bstrKey,
    IN DWORD    dwControlCode
    )
{
    //ASSERT( bstrKey != NULL );

    HRESULT _hr = E_POINTER;

    if ( bstrKey != NULL )
    {
        DWORD   _sc = ERROR_SUCCESS;

        _sc = ::ClusterResourceControl(
                        m_hResource,
                        NULL,
                        dwControlCode,
                        bstrKey,
                        ( wcslen( bstrKey ) + 1) * sizeof( WCHAR ),
                        NULL,
                        0,
                        NULL
                        );
        _hr = HRESULT_FROM_WIN32( _sc );
        if ( SUCCEEDED( _hr ) )
        {
            _hr = CKeys::HrAddItem( bstrKey );
        } // if:
    } // if:

    return _hr;

} //*** CResourceKeys::HrAddItem()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CResourceKeys::HrRemoveItem
//
//  Description:
//      Remove the key at the passed in index.
//
//  Arguments:
//      varIndex        [IN]    - contains the index to remove.
//      dwControlCode   [IN]    - Control code
//
//  Return Value:
//      S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResourceKeys::HrRemoveItem(
    IN VARIANT  varIndex,
    IN DWORD    dwControlCode
    )
{
    HRESULT _hr = S_OK;
    ULONG   _nIndex = 0;

    _hr = HrGetIndex( varIndex, &_nIndex );
    if ( SUCCEEDED( _hr ) )
    {
        DWORD       _sc = ERROR_SUCCESS;
        CComBSTR *  _pbstr = NULL;

        _pbstr = m_klKeys[ _nIndex ];

        _sc = ::ClusterResourceControl(
                        m_hResource,
                        NULL,
                        dwControlCode,
                        (BSTR) (*_pbstr),
                        ( _pbstr->Length() + 1 ) * sizeof( WCHAR ),
                        NULL,
                        0,
                        NULL
                        );
        _hr = HRESULT_FROM_WIN32( _sc );
        if ( SUCCEEDED( _hr ) )
        {
            _hr = CKeys::HrRemoveItem( varIndex );
        }
    }

    return _hr;

} //*** CResourceKeys::HrRemoveItem()


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CClusResourceRegistryKeys class
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceRegistryKeys::CClusResourceRegistryKeys
//
//  Description:
//      Constructor.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResourceRegistryKeys::CClusResourceRegistryKeys( void )
{
    m_hResource = NULL;
    m_piids     = (const IID *) iidCClusRegistryKeys;
    m_piidsSize = ARRAYSIZE( iidCClusRegistryKeys );

} //*** CClusResourceRegistryKeys::CClusResourceRegistryKeys()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceRegistryKeys::Create
//
//  Description:
//      Finish creating the object by doing things that cannot be done in
//      a light weight constructor.
//
//  Arguments:
//      hResource   [IN]    - Resource this collection belongs to.
//
//  Return Value:
//      S_OK if successful.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResourceRegistryKeys::Create( IN HRESOURCE hResource )
{
    m_hResource = hResource;

    return S_OK;

} //*** CClusResourceRegistryKeys::Create()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceRegistryKeys::get_Count
//
//  Description:
//      Get the count of objects in the collection.
//
//  Arguments:
//      plCount [OUT]   - Catches the count.
//
//  Return Value:
//      S_OK if successful or E_POINTER.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceRegistryKeys::get_Count( OUT long * plCount )
{
    return CKeys::HrGetCount( plCount );

} //*** CClusResourceRegistryKeys::get_Count()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceRegistryKeys::get_Item
//
//  Description:
//      Get the item (key) at the passed in index.
//
//  Arguments:
//      varIndex            [IN]    - Contains the index requested.
//      ppbstrRegistryKey   [OUT]   - Catches the key.
//
//  Return Value:
//      S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceRegistryKeys::get_Item(
    IN  VARIANT varIndex,
    OUT BSTR *  ppbstrRegistryKey
    )
{
    return HrGetItem( varIndex, ppbstrRegistryKey );

} //*** CClusResourceRegistryKeys::get_Item()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceRegistryKeys::get__NewEnum
//
//  Description:
//      Create and return a new enumeration for this collection.
//
//  Arguments:
//      ppunk   [OUT]   - Catches the new enumeration.
//
//  Return Value:
//      S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceRegistryKeys::get__NewEnum( IUnknown ** ppunk )
{
    return ::HrNewCComBSTREnum< KeyList >( ppunk, m_klKeys );

} //*** CClusResourceRegistryKeys::get__NewEnum()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceRegistryKeys::AddItem
//
//  Description:
//      Create a new item (key) and add it to the collection.
//
//  Arguments:
//      bstrRegistryKey [IN]    - Registry key to add to the collection.
//
//  Return Value:
//      S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceRegistryKeys::AddItem(
    IN BSTR bstrRegistryKey
    )
{
    return HrAddItem( bstrRegistryKey, CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT );

} //*** CClusResourceRegistryKeys::AddItem()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceRegistryKeys::RemoveItem
//
//  Description:
//      Remove the item (key) at the passed in index.
//
//  Arguments:
//      varIndex    [IN]    - contains the index to remove.
//
//  Return Value:
//      S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceRegistryKeys::RemoveItem( IN VARIANT varIndex )
{
    return HrRemoveItem( varIndex, CLUSCTL_RESOURCE_DELETE_REGISTRY_CHECKPOINT );

} //*** CClusResourceRegistryKeys::RemoveItem()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceRegistryKeys::Refresh
//
//  Description:
//      Load the collection from the cluster database.
//
//  Arguments:
//      None.
//
//  Return Value:
//      S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceRegistryKeys::Refresh( void )
{
    return HrRefresh( CLUSCTL_RESOURCE_GET_REGISTRY_CHECKPOINTS );

} //*** CClusResourceRegistryKeys::Refresh()


//*************************************************************************//


#if CLUSAPI_VERSION >= 0x0500

/////////////////////////////////////////////////////////////////////////////
// CClusResourceCryptoKeys class
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceCryptoKeys::CClusResourceCryptoKeys
//
//  Description:
//      Constructor.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResourceCryptoKeys::CClusResourceCryptoKeys( void )
{
    m_hResource = NULL;
    m_piids     = (const IID *) iidCClusCryptoKeys;
    m_piidsSize = ARRAYSIZE( iidCClusCryptoKeys );

} //*** CClusResourceCryptoKeys::CClusResourceCryptoKeys()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceCryptoKeys::Create
//
//  Description:
//      Finish creating the object by doing things that cannot be done in
//      a light weight constructor.
//
//  Arguments:
//      hResource   [IN]    - Resource this collection belongs to.
//
//  Return Value:
//      S_OK if successful.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResourceCryptoKeys::Create( IN HRESOURCE hResource )
{
    m_hResource = hResource;

    return S_OK;

} //*** CClusResourceCryptoKeys::Create()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceCryptoKeys::get_Count
//
//  Description:
//      Get the count of objects in the collection.
//
//  Arguments:
//      plCount [OUT]   - Catches the count.
//
//  Return Value:
//      S_OK if successful or E_POINTER.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceCryptoKeys::get_Count( OUT long * plCount )
{
    return CKeys::HrGetCount( plCount );

} //*** CClusResourceCryptoKeys::get_Count()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceCryptoKeys::get_Item
//
//  Description:
//      Get the item (key) at the passed in index.
//
//  Arguments:
//      varIndex            [IN]    - Contains the index requested.
//      ppbstrRegistryKey   [OUT]   - Catches the key.
//
//  Return Value:
//      S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceCryptoKeys::get_Item(
    IN  VARIANT varIndex,
    OUT BSTR *  ppbstrRegistryKey
    )
{
    return HrGetItem( varIndex, ppbstrRegistryKey );

} //*** CClusResourceCryptoKeys::get_Item()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceCryptoKeys::get__NewEnum
//
//  Description:
//      Create and return a new enumeration for this collection.
//
//  Arguments:
//      ppunk   [OUT]   - Catches the new enumeration.
//
//  Return Value:
//      S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceCryptoKeys::get__NewEnum( IUnknown ** ppunk )
{
    return ::HrNewCComBSTREnum< KeyList >( ppunk, m_klKeys );

} //*** CClusResourceCryptoKeys::get__NewEnum()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceCryptoKeys::AddItem
//
//  Description:
//      Create a new item (key) and add it to the collection.
//
//  Arguments:
//      bstrRegistryKey [IN]    - Registry key to add to the collection.
//
//  Return Value:
//      S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceCryptoKeys::AddItem(
    IN BSTR bstrRegistryKey
    )
{
    return HrAddItem( bstrRegistryKey, CLUSCTL_RESOURCE_ADD_CRYPTO_CHECKPOINT );

} //*** CClusResourceCryptoKeys::AddItem()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceCryptoKeys::RemoveItem
//
//  Description:
//      Remove the item (key) at the passed in index.
//
//  Arguments:
//      varIndex    [IN]    - contains the index to remove.
//
//  Return Value:
//      S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceCryptoKeys::RemoveItem( IN VARIANT varIndex )
{
    return HrRemoveItem( varIndex, CLUSCTL_RESOURCE_DELETE_CRYPTO_CHECKPOINT );

} //*** CClusResourceCryptoKeys::RemoveItem()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusResourceCryptoKeys::Refresh
//
//  Description:
//      Load the collection from the cluster database.
//
//  Arguments:
//      None.
//
//  Return Value:
//      S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResourceCryptoKeys::Refresh( void )
{
    return HrRefresh( CLUSCTL_RESOURCE_GET_CRYPTO_CHECKPOINTS );

} //*** CClusResourceCryptoKeys::Refresh()

#endif // CLUSAPI_VERSION >= 0x0500


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CResTypeKeys class
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CResTypeKeys::HrRefresh
//
//  Description:
//      Load the collection from the cluster database.
//
//  Arguments:
//      dwControlCode   [IN]    - Control code
//
//  Return Value:
//      S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResTypeKeys::HrRefresh( IN DWORD dwControlCode )
{
    HRESULT     _hr = S_FALSE;
    PWSTR       _psz = NULL;
    DWORD       _cbPsz = 512;
    DWORD       _cbRequired = 0;
    DWORD       _sc = ERROR_SUCCESS;
    HCLUSTER    hCluster = NULL;

    _hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
    if ( SUCCEEDED( _hr ) )
    {
        _psz = (PWSTR) ::LocalAlloc( LMEM_ZEROINIT, _cbPsz );
        if ( _psz != NULL )
        {
            _sc = ::ClusterResourceTypeControl(
                            hCluster,
                            m_bstrResourceTypeName,
                            NULL,
                            dwControlCode,
                            NULL,
                            0,
                            _psz,
                            _cbPsz,
                            &_cbRequired
                            );
            if ( _sc == ERROR_MORE_DATA )
            {
                ::LocalFree( _psz );
                _psz = NULL;
                _cbPsz = _cbRequired;

                _psz = (PWSTR) ::LocalAlloc( LMEM_ZEROINIT, _cbPsz );
                if ( _psz != NULL )
                {
                    _sc = ::ClusterResourceTypeControl(
                                    hCluster,
                                    m_bstrResourceTypeName,
                                    NULL,
                                    dwControlCode,
                                    NULL,
                                    0,
                                    _psz,
                                    _cbPsz,
                                    &_cbRequired
                                    );
                    _hr = HRESULT_FROM_WIN32( _sc );
                } // if: alloc OK
                else
                {
                    _sc = GetLastError();
                    _hr = HRESULT_FROM_WIN32( _sc );
                } // else: alloc failed
            } // if: error was no more item, re-alloc and try again.
            else
            {
                _hr = HRESULT_FROM_WIN32( _sc );
            } // else: error was not no more items -- could be no error

            if ( SUCCEEDED( _hr ) )
            {
                CComBSTR *  _pbstr = NULL;

                Clear();

                while( *_psz != L'\0' )
                {
                    _pbstr = new CComBSTR( _psz );
                    if ( _pbstr != NULL )
                    {
                        m_klKeys.insert( m_klKeys.end(), _pbstr );
                        _psz += wcslen( _psz ) + 1;
                        _pbstr = NULL;
                    } // if:
                    else
                    {
                        _hr = E_OUTOFMEMORY;
                        break;
                    } // else:
                } // while: not EOS
            } // if: keys were retrieved ok
        } // if: alloc ok
        else
        {
            _sc = GetLastError();
            _hr = HRESULT_FROM_WIN32( _sc );
        } // else: alloc failed
    } // if: we got a cluster handle

    return _hr;

} //*** CResTypeKeys::HrRefresh()