windows-xp/Source/XPSP1/NT/admin/snapin/certentp/compdata.cpp

//+---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1997-2001.
//
//  File:       compdata.cpp
//
//  Contents:   Implementation of CCertTmplComponentData
//
//----------------------------------------------------------------------------

#include "stdafx.h"

USE_HANDLE_MACROS ("CERTTMPL (compdata.cpp)")
#include "compdata.h"
#include "dataobj.h"
#include "cookie.h"
#include "uuids.h"
#include "TemplateGeneralPropertyPage.h"
#include "TemplateV1RequestPropertyPage.h"
#include "TemplateV2RequestPropertyPage.h"
#include "TemplateV1SubjectNamePropertyPage.h"
#include "TemplateV2SubjectNamePropertyPage.h"
#include "TemplateV2AuthenticationPropertyPage.h"
#include "TemplateV2SupercedesPropertyPage.h"
#include "TemplateExtensionsPropertyPage.h"
#include "SecurityPropertyPage.h"
#include "TemplatePropertySheet.h"
#include "ViewOIDDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#include "dbg.h"
#include "stdcdata.cpp" // CComponentData implementation

extern  HINSTANCE   g_hInstance;
POLICY_OID_LIST	    g_policyOIDList;

BOOL CALLBACK AddPageProc(HPROPSHEETPAGE hPage, LPARAM pCall);

extern bool g_bSchemaIsW2K;

//
// CCertTmplComponentData
//

CCertTmplComponentData::CCertTmplComponentData ()
    : m_RootCookie (CERTTMPL_SNAPIN),
    m_hRootScopeItem (0),
    m_pResultData (0),
    m_bIsUserAdministrator (FALSE),
    m_pHeader (0),
    m_bMultipleObjectsSelected (false),
	m_dwNumCertTemplates (0),
	m_pComponentConsole (0),
    m_fUseCache (false),
    m_bSchemaChecked (false)
{
    _TRACE (1, L"Entering CCertTmplComponentData::CCertTmplComponentData\n");

    // Get name of logged-in user
    DWORD   dwSize = 0;
    ::GetUserName (0, &dwSize);
    BOOL bRet = ::GetUserName (m_szLoggedInUser.GetBufferSetLength (dwSize), &dwSize);
    _ASSERT (bRet);
    m_szLoggedInUser.ReleaseBuffer ();

    // Get name of this computer
    dwSize = MAX_COMPUTERNAME_LENGTH + 1 ;
    bRet = ::GetComputerName (m_szThisComputer.GetBufferSetLength (MAX_COMPUTERNAME_LENGTH + 1 ), &dwSize);
    _ASSERT (bRet);
    m_szThisComputer.ReleaseBuffer ();

    // Find out if logged-in users is an Administrator
    HRESULT hr = IsUserAdministrator (m_bIsUserAdministrator);
    _ASSERT (SUCCEEDED (hr));

    // default help file name.
    SetHtmlHelpFileName (CERTTMPL_HTML_HELP_FILE);

    // Find out if we're joined to a domain.
    PDSROLE_PRIMARY_DOMAIN_INFO_BASIC    pInfo = 0;
    DWORD dwErr = ::DsRoleGetPrimaryDomainInformation (
            0,
            DsRolePrimaryDomainInfoBasic, 
            (PBYTE*) &pInfo);
    if ( ERROR_SUCCESS == dwErr )
    {
        if ( pInfo->Flags & DSROLE_PRIMARY_DS_RUNNING ||
				pInfo->Flags & DSROLE_PRIMARY_DOMAIN_GUID_PRESENT )
		{
			m_szThisDomainDns = pInfo->DomainNameDns;
			m_RootCookie.SetManagedDomainDNSName (m_szThisDomainDns);
			m_szThisDomainFlat = pInfo->DomainNameFlat;
		}
    }
    else
    {
        _TRACE (0, L"DsRoleGetPrimaryDomainInformation () failed: 0x%x\n", dwErr);
    }

    NetApiBufferFree (pInfo);

    _TRACE (-1, L"Leaving CCertTmplComponentData::CCertTmplComponentData\n");
}

CCertTmplComponentData::~CCertTmplComponentData ()
{
    _TRACE (1, L"Entering CCertTmplComponentData::~CCertTmplComponentData\n");
    CCookie& rootCookie = QueryBaseRootCookie ();
    while ( !rootCookie.m_listResultCookieBlocks.IsEmpty() )
    {
        (rootCookie.m_listResultCookieBlocks.RemoveHead())->Release();
    }

    if ( m_pResultData )
    {
        m_pResultData->Release ();
        m_pResultData = 0;
    }

    if ( m_pComponentConsole )
    {
        SAFE_RELEASE (m_pComponentConsole);
        m_pComponentConsole = 0;
    }

    _TRACE (-1, L"Leaving CCertTmplComponentData::~CCertTmplComponentData\n");
}

DEFINE_FORWARDS_MACHINE_NAME ( CCertTmplComponentData, (&m_RootCookie) )

CCookie& CCertTmplComponentData::QueryBaseRootCookie ()
{
    return (CCookie&) m_RootCookie;
}


STDMETHODIMP CCertTmplComponentData::CreateComponent (LPCOMPONENT* ppComponent)
{
    _TRACE (1, L"Entering CCertTmplComponentData::CreateComponent\n");
    _ASSERT (ppComponent);

    CComObject<CCertTmplComponent>* pObject = 0;
    CComObject<CCertTmplComponent>::CreateInstance (&pObject);
    _ASSERT (pObject);
    pObject->SetComponentDataPtr ( (CCertTmplComponentData*) this);

    _TRACE (-1, L"Leaving CCertTmplComponentData::CreateComponent\n");
    return pObject->QueryInterface (IID_PPV_ARG (IComponent, ppComponent));
}

HRESULT CCertTmplComponentData::LoadIcons (LPIMAGELIST pImageList, BOOL /*fLoadLargeIcons*/)
{
    _TRACE (1, L"Entering CCertTmplComponentData::LoadIcons\n");
    // Structure to map a Resource ID to an index of icon
    struct RESID2IICON
    {
        UINT uIconId;   // Icon resource ID
        int iIcon;      // Index of the icon in the image list
    };
    const static RESID2IICON rgzLoadIconList[] =
    {
        // Misc icons
        { IDI_CERT_TEMPLATEV1, iIconCertTemplateV1 },
        { IDI_CERT_TEMPLATEV2, iIconCertTemplateV2 },
        { 0, 0} // Must be last
    };


    for (int i = 0; rgzLoadIconList[i].uIconId != 0; i++)
    {
        HICON hIcon = ::LoadIcon (AfxGetInstanceHandle (),
                MAKEINTRESOURCE (rgzLoadIconList[i].uIconId));
        _ASSERT (hIcon && "Icon ID not found in resources");
        HRESULT hr = pImageList->ImageListSetIcon ( (PLONG_PTR) hIcon,
                rgzLoadIconList[i].iIcon);
        _ASSERT (SUCCEEDED (hr) && "Unable to add icon to ImageList");
    }
    _TRACE (-1, L"Leaving CCertTmplComponentData::LoadIcons\n");

    return S_OK;
}


HRESULT CCertTmplComponentData::OnNotifyExpand (LPDATAOBJECT pDataObject, BOOL bExpanding, HSCOPEITEM hParent)
{
    _TRACE (1, L"Entering CCertTmplComponentData::OnNotifyExpand\n");
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    HRESULT     hr = S_OK;
    CWaitCursor waitCursor;

    _ASSERT (pDataObject && hParent && m_pConsoleNameSpace);
    if ( bExpanding )
    {
        // Need to check schema first before getting OIDs (sets g_bSchemaIsW2K)
        if ( !m_bSchemaChecked )
        {
            InstallWindows2002CertTemplates ();
            m_bSchemaChecked = true;
        }

        if ( 0 == g_policyOIDList.GetCount () )
        {
            hr = GetEnterpriseOIDs ();
            if ( FAILED (hr) )
            {
                if ( HRESULT_FROM_WIN32 (ERROR_DS_NO_SUCH_OBJECT) == hr )
                    g_bSchemaIsW2K = true;

                if ( !g_bSchemaIsW2K )
                {
                    CString caption;
                    CString text;

                    VERIFY (caption.LoadString (IDS_CERTTMPL));
                    text.FormatMessage (IDS_CANNOT_LOAD_OID_LIST, GetSystemMessage (hr));

                    int     iRetVal = 0;
                    VERIFY (SUCCEEDED (m_pConsole->MessageBox (text, caption,
                            MB_ICONWARNING | MB_OK, &iRetVal)));
                }
                else
                    hr = S_OK;
            }
        }


        GUID guidObjectType;
        hr = ExtractObjectTypeGUID (pDataObject, &guidObjectType);
        _ASSERT (SUCCEEDED (hr));

        // Beyond this point we are not dealing with extension node types.
        {
            CCertTmplCookie* pParentCookie = ConvertCookie (pDataObject);
            if ( pParentCookie )
            {
                hr = ExpandScopeNodes (pParentCookie, hParent, guidObjectType, pDataObject);
            }
            else
                hr = E_UNEXPECTED;
        }
    }
    else
        hr = S_OK;


    _TRACE (-1, L"Leaving CCertTmplComponentData::OnNotifyExpand: 0x%x\n", hr);
    return hr;
}

HRESULT CCertTmplComponentData::OnNotifyRelease (LPDATAOBJECT /*pDataObject*/, HSCOPEITEM hItem)
{
    _TRACE (1, L"Entering CCertTmplComponentData::OnNotifyRelease\n");
    // _ASSERT ( IsExtensionSnapin () );
    // This might also happen if I expand a node and then remove
    // the snapin via Snapin Manager
    HRESULT hr = DeleteChildren (hItem);

    _TRACE (-1, L"Leaving CCertTmplComponentData::OnNotifyRelease: 0x%x\n", hr);
    return hr;
}

// global space to store the string handed back to GetDisplayInfo ()
// CODEWORK should use "bstr" for ANSI-ization
CString g_strResultColumnText;

BSTR CCertTmplComponentData::QueryResultColumnText (CCookie& basecookie, int /*nCol*/)
{
    BSTR    strResult = L"";

    CCertTmplCookie& cookie = (CCertTmplCookie&) basecookie;
#ifndef UNICODE
#error not ANSI-enabled
#endif
    switch ( cookie.m_objecttype )
    {
        case CERTTMPL_SNAPIN:
            break;

        case CERTTMPL_CERT_TEMPLATE:
            _ASSERT (0);
            break;

        default:
            break;
    }

    return strResult;
}

int CCertTmplComponentData::QueryImage (CCookie& basecookie, BOOL /*fOpenImage*/)
{
    int             nIcon = 0;

    CCertTmplCookie& cookie = (CCertTmplCookie&)basecookie;
    switch ( cookie.m_objecttype )
    {
        case CERTTMPL_SNAPIN:
            nIcon = iIconCertTemplateV2;
            break;

        case CERTTMPL_CERT_TEMPLATE:
            {
                CCertTemplate& rCertTemplate = (CCertTemplate&) cookie;

                if ( 1 == rCertTemplate.GetType () )
                    nIcon = iIconCertTemplateV1;
                else
                    nIcon = iIconCertTemplateV2;
            }
            break;

        default:
            _TRACE (0, L"CCertTmplComponentData::QueryImage bad parent type\n");
            break;
    }
    return nIcon;
}


///////////////////////////////////////////////////////////////////////////////
/// IExtendPropertySheet

STDMETHODIMP CCertTmplComponentData::QueryPagesFor (LPDATAOBJECT pDataObject)
{
    _TRACE (1, L"Entering CCertTmplComponentData::QueryPagesFor\n");
    HRESULT hr = S_OK;
    _ASSERT (pDataObject);

    if ( pDataObject )
    {
        DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
        hr = ::ExtractData (pDataObject,
                CCertTemplatesDataObject::m_CFDataObjectType,
                 &dataobjecttype, sizeof (dataobjecttype));
        if ( SUCCEEDED (hr) )
        {
            switch (dataobjecttype)
            {
            case CCT_SNAPIN_MANAGER:
                hr = S_FALSE;
                break;

            case CCT_RESULT:
                {
                    hr = S_FALSE;
                    CCertTmplCookie* pParentCookie = ConvertCookie (pDataObject);
                    if ( pParentCookie )
                    {
                        switch (pParentCookie->m_objecttype)
                        {
                        case CERTTMPL_CERT_TEMPLATE:
                            hr = S_OK;
                            break;

                        default:
                            break;
                        }
                    }
                }
                break;

            case CCT_SCOPE:
                hr = S_FALSE;
                break;

            default:
                hr = S_FALSE;
                break;
            }
        }
    }
    else
        hr = E_POINTER;


    _TRACE (-1, L"Leaving CCertTmplComponentData::QueryPagesFor: 0x%x\n", hr);
    return hr;
}

STDMETHODIMP CCertTmplComponentData::CreatePropertyPages (
    LPPROPERTYSHEETCALLBACK pCallback,
    LONG_PTR lNotifyHandle,        // This handle must be saved in the property page object to notify the parent when modified
    LPDATAOBJECT pDataObject)
{
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    _TRACE (1, L"Entering CCertTmplComponentData::CreatePropertyPages\n");
    HRESULT hr = S_OK;


    _ASSERT (pCallback && pDataObject);
    if ( pCallback && pDataObject )
    {
        DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
        hr = ::ExtractData (pDataObject,
                CCertTemplatesDataObject::m_CFDataObjectType,
                 &dataobjecttype, sizeof (dataobjecttype));
        switch (dataobjecttype)
        {
        case CCT_SNAPIN_MANAGER:
            break;

        case CCT_RESULT:
            {
                CCertTmplCookie* pParentCookie = ConvertCookie (pDataObject);
                if ( pParentCookie )
                {
                    switch (pParentCookie->m_objecttype)
                    {
                    case CERTTMPL_CERT_TEMPLATE:
                        {
                            CCertTemplate* pCertTemplate = 
                                    dynamic_cast <CCertTemplate*> (pParentCookie);
                            _ASSERT (pCertTemplate);
                            if ( pCertTemplate )
                            {
                                hr = AddCertTemplatePropPages (pCertTemplate, 
                                        pCallback, lNotifyHandle);
                            }
                            else
                                hr = E_FAIL;
                        }
                        break;

                    default:
                        _ASSERT (0);
                        break;
                    }
                }
                else
                    hr = E_UNEXPECTED;
            }
            break;

        case CCT_SCOPE:
            {
                CCertTmplCookie* pParentCookie = ConvertCookie (pDataObject);
                if ( pParentCookie )
                {
                }
                else
                    hr = E_UNEXPECTED;
            }
            break;


        default:
            break;
        }
    }
    else
        hr = E_POINTER;

    _TRACE (-1, L"Leaving CCertTmplComponentData::CreatePropertyPages: 0x%x\n", hr);
    return hr;
}




BOOL IsMMCMultiSelectDataObject(IDataObject* pDataObject)
{
    if (pDataObject == NULL)
        return FALSE;

    static UINT s_cf = 0;
    if (s_cf == 0)
    {
        USES_CONVERSION;
        s_cf = RegisterClipboardFormat(W2T(CCF_MMC_MULTISELECT_DATAOBJECT));
    }

    FORMATETC fmt = {(CLIPFORMAT)s_cf, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};

    return (pDataObject->QueryGetData(&fmt) == S_OK);
}


///////////////////////////////////////////////////////////////////////////////
// IExtendContextMenu implementation
//
STDMETHODIMP CCertTmplComponentData::AddMenuItems (LPDATAOBJECT pDataObject,
                                            LPCONTEXTMENUCALLBACK pContextMenuCallback,
                                            long *pInsertionAllowed)
{
    _TRACE (1, L"Entering CCertTmplComponentData::AddMenuItems\n");
    HRESULT                         hr = S_OK;

    CCertTmplCookie*                 pCookie = 0;

    LPDATAOBJECT    pMSDO = ExtractMultiSelect (pDataObject);
    m_bMultipleObjectsSelected = false;

    if ( pMSDO )
    {
        m_bMultipleObjectsSelected = true;

        CCertTemplatesDataObject* pDO = dynamic_cast <CCertTemplatesDataObject*>(pMSDO);
        _ASSERT (pDO);
        if ( pDO )
        {
            // Get first cookie - all items should be the same?
            // Is this a valid assumption?
            // TODO: Verify
            pDO->Reset();
            if ( pDO->Next(1, reinterpret_cast<MMC_COOKIE*>(&pCookie), NULL) == S_FALSE )
                return S_FALSE;
        }
        else
            return E_UNEXPECTED;

    }
    else
        pCookie = ConvertCookie (pDataObject);
    _ASSERT (pCookie);
    if ( !pCookie )
        return E_UNEXPECTED;

    CertTmplObjectType    objType = pCookie->m_objecttype;


    if ( *pInsertionAllowed & CCM_INSERTIONALLOWED_TOP )
    {
        switch (objType)
        {
        case CERTTMPL_CERT_TEMPLATE:
            if ( !m_bMultipleObjectsSelected )
            {
                CCertTemplate* pCertTemplate = dynamic_cast <CCertTemplate*> (pCookie);
                _ASSERT (pCertTemplate);
                if ( pCertTemplate )
                {
                    if ( !g_bSchemaIsW2K )
                    {
                        hr = AddCloneTemplateMenuItem (pContextMenuCallback,
                                CCM_INSERTIONPOINTID_PRIMARY_TOP);
                        if ( SUCCEEDED (hr) )
                        {
                            hr = AddReEnrollAllCertsMenuItem (pContextMenuCallback,
                                CCM_INSERTIONPOINTID_PRIMARY_TOP);
                        }
                    }
                }
                else
                    hr = E_FAIL;
            }
            break;

        case CERTTMPL_SNAPIN:
            _ASSERT (!m_bMultipleObjectsSelected);
            hr = AddViewOIDsMenuItem (pContextMenuCallback,
                                CCM_INSERTIONPOINTID_PRIMARY_TOP);
            break;


        default:
            break;
        }
    }
    if ( *pInsertionAllowed & CCM_INSERTIONALLOWED_NEW  )
    {
    }
    if ( *pInsertionAllowed & CCM_INSERTIONALLOWED_TASK )
    {
        switch (objType)
        {
        case CERTTMPL_CERT_TEMPLATE:
            if ( !m_bMultipleObjectsSelected )
            {
                CCertTemplate* pCertTemplate = dynamic_cast <CCertTemplate*> (pCookie);
                _ASSERT (pCertTemplate);
                if ( pCertTemplate )
                {
                    if ( !g_bSchemaIsW2K )
                    {
                        hr = AddCloneTemplateMenuItem (pContextMenuCallback,
                                CCM_INSERTIONPOINTID_PRIMARY_TASK);
                        if ( SUCCEEDED (hr) )
                        {
                            hr = AddReEnrollAllCertsMenuItem (pContextMenuCallback,
                                CCM_INSERTIONPOINTID_PRIMARY_TASK);
                        }
                    }
                }
                else
                    hr = E_FAIL;
            }
            break;

        case CERTTMPL_SNAPIN:
            _ASSERT (!m_bMultipleObjectsSelected);
            hr = AddViewOIDsMenuItem (pContextMenuCallback,
                                CCM_INSERTIONPOINTID_PRIMARY_TASK);
            break;
        }
    }
    if ( *pInsertionAllowed & CCM_INSERTIONALLOWED_VIEW )
    {
        switch (objType)
        {
        case CERTTMPL_SNAPIN:
            _ASSERT (!m_bMultipleObjectsSelected);
            break;

        case CERTTMPL_CERT_TEMPLATE:
            _ASSERT (0);
            break;

        default:
            break;
        }
    }

    _TRACE (-1, L"Leaving CCertTmplComponentData::AddMenuItems: 0x%x\n", hr);
    return hr;
}


STDMETHODIMP CCertTmplComponentData::Command (long nCommandID, LPDATAOBJECT pDataObject)
{
    HRESULT hr = S_OK;

    switch (nCommandID)
    {
    case IDM_CLONE_TEMPLATE:
        hr = OnCloneTemplate (pDataObject);
        break;

    case IDM_REENROLL_ALL_CERTS:
        hr = OnReEnrollAllCerts (pDataObject);
        break;

    case IDM_VIEW_OIDS:
        OnViewOIDs ();
        break;

    case -1:    // Received on forward/back buttons from toolbar
        break;

    default:
        _ASSERT (0);
        break;
    }

    return hr;
}




HRESULT CCertTmplComponentData::RefreshScopePane (LPDATAOBJECT pDataObject)
{
    _TRACE (1, L"Entering CCertTmplComponentData::RefreshScopePane\n");
    HRESULT hr = S_OK;
    CCertTmplCookie* pCookie = 0;

    if ( pDataObject )
        pCookie = ConvertCookie (pDataObject);
    if ( !pDataObject || pCookie )
    {
        hr = DeleteScopeItems ();
        _ASSERT (SUCCEEDED (hr));
        GUID    guid;
        hr = ExpandScopeNodes (&m_RootCookie, m_hRootScopeItem, guid, pDataObject);
    }
    _TRACE (-1, L"Leaving CCertTmplComponentData::RefreshScopePane: 0x%x\n", hr);
    return hr;
}


HRESULT CCertTmplComponentData::ExpandScopeNodes (
        CCertTmplCookie* pParentCookie,
        HSCOPEITEM      hParent,
        const GUID&     /*guidObjectType*/,
        LPDATAOBJECT    /*pDataObject*/)
{
    _TRACE (1, L"Entering CCertTmplComponentData::ExpandScopeNodes\n");
    _ASSERT (hParent);
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    CWaitCursor waitCursor;
    HRESULT     hr = S_OK;

    if ( pParentCookie )
    {
        CString     objectName;

        switch ( pParentCookie->m_objecttype )
        {
            // These node types have no children yet
            case CERTTMPL_SNAPIN:
                // We don't expect the handle of the root scope item to change, ever!
                _ASSERT ( m_hRootScopeItem ? (m_hRootScopeItem == hParent) : 1);
                if ( !m_hRootScopeItem )
                    m_hRootScopeItem = hParent;
                break;

            case CERTTMPL_CERT_TEMPLATE:
                _ASSERT (0);
                break;

            // This node type has no children
            default:
                _TRACE (0, L"CCertTmplComponentData::EnumerateScopeChildren bad parent type\n");
                hr = S_OK;
                break;
        }
    }
    else
    {
        // If parentCookie not passed in, then this is an extension snap-in
    }

    _TRACE (-1, L"Leaving CCertTmplComponentData::ExpandScopeNodes: 0x%x\n", hr);
    return hr;
}

HRESULT CCertTmplComponentData::DeleteScopeItems ()
{
    _TRACE (1, L"Entering CCertTmplComponentData::DeleteScopeItems\n");
    HRESULT hr = S_OK;

    hr = DeleteChildren (m_hRootScopeItem);

    _TRACE (-1, L"Leaving CCertTmplComponentData::DeleteScopeItems: 0x%x\n", hr);
    return hr;
}


HRESULT CCertTmplComponentData::DeleteChildren (HSCOPEITEM hParent)
{
    _TRACE (1, L"Entering CCertTmplComponentData::DeleteChildren\n");
    HRESULT         hr = S_OK;
    if ( hParent )
    {
        HSCOPEITEM      hChild = 0;
        HSCOPEITEM      hNextChild = 0;
        MMC_COOKIE      lCookie = 0;

        // Optimization:  If we're deleting everything below the root, free all
        // the result items here so we don't have to go looking for them later by
        // store
        if ( hParent == m_hRootScopeItem )
        {
            LPRESULTDATA    pResultData = 0;
			hr = GetResultData (&pResultData);
            if ( SUCCEEDED (hr) )
            {
                hr = pResultData->DeleteAllRsltItems ();
                if ( SUCCEEDED (hr) || E_UNEXPECTED == hr ) // returns E_UNEXPECTED if console shutting down
                {
                    RemoveResultCookies (pResultData);
                }
				pResultData->Release ();
            }
        }


        hr = m_pConsoleNameSpace->GetChildItem (hParent, &hChild, &lCookie);
        _ASSERT (SUCCEEDED (hr) || E_FAIL == hr);    // appears to return E_FAIL when there are no children
        while ( SUCCEEDED (hr) && hChild )
        {
            hr = m_pConsoleNameSpace->GetNextItem (hChild, &hNextChild, &lCookie);
            _ASSERT (SUCCEEDED (hr));

            hr = DeleteChildren (hChild);
            _ASSERT (SUCCEEDED (hr));
            if ( SUCCEEDED (hr) )
            {
                m_pConsoleNameSpace->DeleteItem (hChild, TRUE);
            }
            hChild = hNextChild;
        }
   }


    _TRACE (-1, L"Leaving CCertTmplComponentData::DeleteChildren: 0x%x\n", hr);
    return hr;
}


CertTmplObjectType CCertTmplComponentData::GetObjectType (LPDATAOBJECT pDataObject)
{
    _ASSERT (pDataObject);
    CCertTmplCookie* pCookie = ConvertCookie (pDataObject);
    if ( ((CCertTmplCookie*) MMC_MULTI_SELECT_COOKIE) == pCookie )
        return CERTTMPL_MULTISEL;
    else if ( pCookie )
        return pCookie->m_objecttype;

    return CERTTMPL_INVALID;
}


HRESULT CCertTmplComponentData::IsUserAdministrator (BOOL & bIsAdministrator)
{
    HRESULT hr = S_OK;
    DWORD   dwErr = 0;

    bIsAdministrator = FALSE;
    if ( IsWindowsNT () )
    {
        PSID                        psidAdministrators;
        SID_IDENTIFIER_AUTHORITY    siaNtAuthority = SECURITY_NT_AUTHORITY;

        BOOL bResult = AllocateAndInitializeSid (&siaNtAuthority, 2,
                SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
                0, 0, 0, 0, 0, 0, &psidAdministrators);
        _ASSERT (bResult);
        if ( bResult )
        {
            bResult = CheckTokenMembership (0, psidAdministrators,
                    &bIsAdministrator);
            _ASSERT (bResult);
            if ( !bResult )
            {
                dwErr = GetLastError ();
                DisplaySystemError (dwErr);
                hr = HRESULT_FROM_WIN32 (dwErr);
            }
            FreeSid (psidAdministrators);
        }
        else
        {
            dwErr = GetLastError ();
            DisplaySystemError (dwErr);
            hr = HRESULT_FROM_WIN32 (dwErr);
        }
    }
    return hr;
}


void CCertTmplComponentData::DisplaySystemError (DWORD dwErr)
{
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    LPVOID lpMsgBuf;

    FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
            NULL,
            dwErr,
            MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
             (PWSTR) &lpMsgBuf,    0,    NULL );

    // Display the string.
    CString caption;
    VERIFY (caption.LoadString (IDS_CERTTMPL));
    int     iRetVal = 0;
    if ( m_pConsole )
    {
        HRESULT hr = m_pConsole->MessageBox ( (PWSTR) lpMsgBuf, caption,
            MB_ICONWARNING | MB_OK, &iRetVal);
        _ASSERT (SUCCEEDED (hr));
    }
    else
    {
        CThemeContextActivator activator;
        ::MessageBox (NULL, (PWSTR) lpMsgBuf, caption, MB_ICONWARNING | MB_OK);
    }
    // Free the buffer.
    LocalFree (lpMsgBuf);
}

HRESULT CCertTmplComponentData::AddSeparator (LPCONTEXTMENUCALLBACK pContextMenuCallback)
{
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    _ASSERT (pContextMenuCallback);
    CONTEXTMENUITEM menuItem;

    ::ZeroMemory (&menuItem, sizeof (menuItem));
    menuItem.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TASK;
    menuItem.fSpecialFlags = 0;
    menuItem.strName = _T ("Separator");            // Dummy name
    menuItem.strStatusBarText = _T ("Separator");// Dummy status text
    menuItem.lCommandID = ID_SEPARATOR;         // Command ID
    menuItem.fFlags = MF_SEPARATOR;             // most important the flag
    HRESULT hr = pContextMenuCallback->AddItem (&menuItem);
//  _ASSERT (SUCCEEDED (hr));

    return hr;
}

LPCONSOLENAMESPACE CCertTmplComponentData::GetConsoleNameSpace () const
{
    return m_pConsoleNameSpace;
}

CCertTmplCookie* CCertTmplComponentData::ConvertCookie (LPDATAOBJECT pDataObject)
{
    CCertTmplCookie* pParentCookie = 0;
    CCookie*        pBaseParentCookie = 0;
    HRESULT         hr = ::ExtractData (pDataObject,
            CCertTemplatesDataObject::m_CFRawCookie,
             &pBaseParentCookie,
             sizeof (pBaseParentCookie) );
    if ( SUCCEEDED (hr) )
    {
        pParentCookie = ActiveCookie (pBaseParentCookie);
        _ASSERT (pParentCookie);
    }
    return pParentCookie;
}




HRESULT CCertTmplComponentData::AddScopeNode(CCertTmplCookie * pNewCookie, HSCOPEITEM hParent)
{
    _TRACE (1, L"Entering CCertTmplComponentData::AddScopeNode\n");
    _ASSERT (pNewCookie);
    HRESULT hr = S_OK;
    if ( pNewCookie )
    {
        SCOPEDATAITEM tSDItem;

        ::ZeroMemory (&tSDItem,sizeof (tSDItem));
        tSDItem.mask = SDI_STR | SDI_IMAGE | SDI_OPENIMAGE |
            SDI_STATE | SDI_PARAM | SDI_PARENT | SDI_CHILDREN;
        tSDItem.displayname = MMC_CALLBACK;
        tSDItem.relativeID = hParent;
        tSDItem.nState = 0;
        tSDItem.cChildren = 0;

        if ( pNewCookie != &m_RootCookie )
            m_RootCookie.m_listScopeCookieBlocks.AddHead ( (CBaseCookieBlock*) pNewCookie);
        tSDItem.lParam = reinterpret_cast<LPARAM> ( (CCookie*) pNewCookie);
        tSDItem.nImage = QueryImage (*pNewCookie, FALSE);
        tSDItem.nOpenImage = QueryImage (*pNewCookie, FALSE);
        hr = m_pConsoleNameSpace->InsertItem (&tSDItem);
        if ( SUCCEEDED (hr) )
            pNewCookie->m_hScopeItem = tSDItem.ID;
    }
    else
        hr = E_POINTER;

    _TRACE (-1, L"Leaving CCertTmplComponentData::AddScopeNode: 0x%x\n", hr);
    return hr;
}

HRESULT CCertTmplComponentData::ReleaseResultCookie (
        CBaseCookieBlock *  pResultCookie,
        CCookie&            /*rootCookie*/,
        POSITION            /*pos2*/)
{
    _TRACE (1, L"Entering CCertTmplComponentData::ReleaseResultCookie\n");
    CCertTmplCookie* pCookie = dynamic_cast <CCertTmplCookie*> (pResultCookie);
    _ASSERT (pCookie);
    if ( pCookie )
    {
        switch (pCookie->m_objecttype)
        {
        case CERTTMPL_CERT_TEMPLATE:
            _ASSERT (0);
            break;

        default:
            _ASSERT (0);
            break;
        }
    }

    _TRACE (-1, L"Leaving CCertTmplComponentData::ReleaseResultCookie\n");
    return S_OK;
}

void CCertTmplComponentData::SetResultData(LPRESULTDATA pResultData)
{
    _ASSERT (pResultData);
    if ( pResultData && !m_pResultData )
    {
        m_pResultData = pResultData;
        m_pResultData->AddRef ();
    }
}

HRESULT CCertTmplComponentData::GetResultData(LPRESULTDATA* ppResultData)
{
	HRESULT	hr = S_OK;

	if ( !ppResultData )
		hr = E_POINTER;
	else if ( !m_pResultData )
    {
        if ( m_pConsole )
        {
            hr = m_pConsole->QueryInterface(IID_PPV_ARG (IResultData, &m_pResultData));
            _ASSERT (SUCCEEDED (hr));
        }
        else
            hr = E_FAIL;
    }
	
    if ( SUCCEEDED (hr) && m_pResultData )
	{
		*ppResultData = m_pResultData;
		m_pResultData->AddRef ();
	}

    return hr;
}


void CCertTmplComponentData::DisplayAccessDenied ()
{
    DWORD   dwErr = GetLastError ();
    _ASSERT (E_ACCESSDENIED == dwErr);
    if ( E_ACCESSDENIED == dwErr )
    {
        LPVOID lpMsgBuf;

        FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                NULL,
                GetLastError (),
                MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                 (PWSTR) &lpMsgBuf,    0,    NULL );

        // Display the string.
        CString caption;
        VERIFY (caption.LoadString (IDS_CERTTMPL));
        int     iRetVal = 0;
        VERIFY (SUCCEEDED (m_pConsole->MessageBox ( (PWSTR) lpMsgBuf, caption,
            MB_ICONWARNING | MB_OK, &iRetVal)));

        // Free the buffer.
        LocalFree (lpMsgBuf);
    }
}



CString CCertTmplComponentData::GetThisComputer() const
{
    return m_szThisComputer;
}

HRESULT CCertTmplComponentData::OnPropertyChange (LPARAM param)
{
    _TRACE (1, L"Entering CCertTmplComponentData::OnPropertyChange\n");
    _ASSERT (param);
    HRESULT         hr = S_OK;
    if ( param )
    {
        CCertTmplCookie* pCookie = reinterpret_cast<CCertTmplCookie*> (param);
        if ( pCookie )
        {
            switch (pCookie->m_objecttype)
            {
            case CERTTMPL_CERT_TEMPLATE:
                {
                    HRESULTITEM	itemID = 0;
		            hr = pCookie->m_resultDataID->FindItemByLParam ((LPARAM) pCookie, &itemID);
		            _ASSERT (SUCCEEDED (hr));
		            if ( SUCCEEDED (hr) )
		            {
			            hr = m_pResultData->UpdateItem (itemID);
			            _ASSERT (SUCCEEDED (hr));
    	            }
                }
                break;

            default:
                break;
            }
        }
    }
    else
        hr = E_FAIL;


    _TRACE (-1, L"Leaving CCertTmplComponentData::OnPropertyChange: 0x%x\n", hr);
    return hr;
}


///////////////////////////////////////////////////////////////////////////////
//
// CCertTmplComponentData::RemoveResultCookies
//
// Remove and delete all the result cookies corresponding to the LPRESULTDATA
// object passed in.  Thus all cookies added to pResultData are released and
// removed from the master list.
//
///////////////////////////////////////////////////////////////////////////////
void CCertTmplComponentData::RemoveResultCookies(LPRESULTDATA pResultData)
{
    _TRACE (1, L"Entering CCertTmplComponentData::RemoveResultCookies\n");
    CCertTmplCookie* pCookie = 0;

    CCookie& rootCookie = QueryBaseRootCookie ();

    POSITION        curPos = 0;

    for (POSITION nextPos = rootCookie.m_listResultCookieBlocks.GetHeadPosition (); nextPos; )
    {
        curPos = nextPos;
        pCookie = dynamic_cast <CCertTmplCookie*> (rootCookie.m_listResultCookieBlocks.GetNext (nextPos));
        _ASSERT (pCookie);
        if ( pCookie )
        {
            if ( pCookie->m_resultDataID == pResultData )
            {
                pCookie->Release ();
                rootCookie.m_listResultCookieBlocks.RemoveAt (curPos);
            }
        }
    }
    _TRACE (-1, L"Leaving CCertTmplComponentData::RemoveResultCookies\n");
}

HRESULT CCertTmplComponentData::AddVersion1CertTemplatePropPages (CCertTemplate* pCertTemplate, LPPROPERTYSHEETCALLBACK pCallback)
{
    _TRACE (1, L"Entering CCertTmplComponentData::AddVersion1CertTemplatePropPages\n");
    HRESULT         hr = S_OK;
    _ASSERT (pCertTemplate && pCallback);
    if ( pCertTemplate && pCallback )
    {
        _ASSERT (1 == pCertTemplate->GetType ());

        // Add General page
        CTemplateGeneralPropertyPage * pGeneralPage = new CTemplateGeneralPropertyPage (
                *pCertTemplate, this);
        if ( pGeneralPage )
        {
            HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pGeneralPage->m_psp);
            _ASSERT (hPage);
            hr = pCallback->AddPage (hPage);
            _ASSERT (SUCCEEDED (hr));
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }

        // Add Request page only if subject is not a CA
        if ( SUCCEEDED (hr) && !pCertTemplate->SubjectIsCA () )
        {
            CTemplateV1RequestPropertyPage * pRequestPage = 
                    new CTemplateV1RequestPropertyPage (*pCertTemplate);
            if ( pRequestPage )
            {
                HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pRequestPage->m_psp);
                _ASSERT (hPage);
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }

    
        // Add Subject Name page only if subject is not a CA
        if ( SUCCEEDED (hr) && !pCertTemplate->SubjectIsCA () )
        {
            CTemplateV1SubjectNamePropertyPage * pSubjectNamePage = 
                    new CTemplateV1SubjectNamePropertyPage (*pCertTemplate);
            if ( pSubjectNamePage )
            {
                HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pSubjectNamePage->m_psp);
                _ASSERT (hPage);
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }

        // Add extensions page - always add this page last (except for security)
        if ( SUCCEEDED (hr) )
        {
            CTemplateExtensionsPropertyPage * pExtensionsPage = 
                    new CTemplateExtensionsPropertyPage (*pCertTemplate, 
                    pGeneralPage->m_bIsDirty);
            if ( pExtensionsPage )
            {
                HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pExtensionsPage->m_psp);
                _ASSERT (hPage);
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }

        // Add security page
        if ( SUCCEEDED (hr) )
        {
            // if error, don't display this page
            LPSECURITYINFO pCertTemplateSecurity = NULL;

            hr = CreateCertTemplateSecurityInfo (pCertTemplate, 
                    &pCertTemplateSecurity);
            if ( SUCCEEDED (hr) )
            {
                // save the pCASecurity pointer for later releasing
                pGeneralPage->SetAllocedSecurityInfo (pCertTemplateSecurity);

                HPROPSHEETPAGE hPage = CreateSecurityPage (pCertTemplateSecurity);
                if (hPage == NULL)
                {
                    hr = HRESULT_FROM_WIN32 (GetLastError());
                    _TRACE (0, L"CreateSecurityPage () failed: 0x%x\n", hr);
                }
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
            }
        }
    }
    _TRACE (-1, L"Leaving CCertTmplComponentData::AddVersion1CertTemplatePropPages: 0x%x\n", hr);
    return hr;
}

HRESULT CCertTmplComponentData::AddVersion2CertTemplatePropPages (CCertTemplate* pCertTemplate, LPPROPERTYSHEETCALLBACK pCallback, LONG_PTR lNotifyHandle)
{
    _TRACE (1, L"Entering CCertTmplComponentData::AddVersion2CertTemplatePropPages\n");
    HRESULT         hr = S_OK;
    _ASSERT (pCertTemplate && pCallback);
    if ( pCertTemplate && pCallback )
    {
        _ASSERT (2 == pCertTemplate->GetType ());
        int nPage = 0;

        // Add General page
        CTemplateGeneralPropertyPage * pGeneralPage = new CTemplateGeneralPropertyPage (
                *pCertTemplate, this);
        if ( pGeneralPage )
        {
   			pGeneralPage->m_lNotifyHandle = lNotifyHandle;
            HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pGeneralPage->m_psp);
            _ASSERT (hPage);
            hr = pCallback->AddPage (hPage);
            _ASSERT (SUCCEEDED (hr));
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }

        // Add Request page only if subject is not a CA
        if ( SUCCEEDED (hr) && !pCertTemplate->SubjectIsCA () )
        {
            CTemplateV2RequestPropertyPage * pRequestPage = 
                    new CTemplateV2RequestPropertyPage (*pCertTemplate, 
                    pGeneralPage->m_bIsDirty);
            if ( pRequestPage )
            {
                HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pRequestPage->m_psp);
                _ASSERT (hPage);
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
                if ( SUCCEEDED (hr) )
                {
                    nPage++;
                    pGeneralPage->SetV2RequestPageNumber (nPage);
                }
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }

    
        // Add Subject Name page only if subject is not a CA
        if ( SUCCEEDED (hr) && !pCertTemplate->SubjectIsCA () )
        {
            CTemplateV2SubjectNamePropertyPage * pSubjectNamePage = 
                    new CTemplateV2SubjectNamePropertyPage (*pCertTemplate, 
                    pGeneralPage->m_bIsDirty);
            if ( pSubjectNamePage )
            {
                HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pSubjectNamePage->m_psp);
                _ASSERT (hPage);
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
                if ( SUCCEEDED (hr) )
                    nPage++;
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }


        // Add Authentication Name page
        if ( SUCCEEDED (hr) )
        {
            CTemplateV2AuthenticationPropertyPage * pAuthenticationPage = 
                    new CTemplateV2AuthenticationPropertyPage (*pCertTemplate, 
                    pGeneralPage->m_bIsDirty);
            if ( pAuthenticationPage )
            {
                HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pAuthenticationPage->m_psp);
                _ASSERT (hPage);
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
                if ( SUCCEEDED (hr) )
                {
                    nPage++;
                    pGeneralPage->SetV2AuthPageNumber (nPage);
                }
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }

        // Add Superceded page
        if ( SUCCEEDED (hr) )
        {
            CTemplateV2SupercedesPropertyPage * pSupercededPage = 
                    new CTemplateV2SupercedesPropertyPage (*pCertTemplate, 
                            pGeneralPage->m_bIsDirty,
                            this);
            if ( pSupercededPage )
            {
                HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pSupercededPage->m_psp);
                _ASSERT (hPage);
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }

        // Add extensions page - always add this page last (except for security)
        if ( SUCCEEDED (hr) )
        {
            CTemplateExtensionsPropertyPage * pExtensionsPage = 
                    new CTemplateExtensionsPropertyPage (*pCertTemplate, 
                    pGeneralPage->m_bIsDirty);
            if ( pExtensionsPage )
            {
                HPROPSHEETPAGE hPage = MyCreatePropertySheetPage (&pExtensionsPage->m_psp);
                _ASSERT (hPage);
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }


        // Add security page
        if ( SUCCEEDED (hr) )
        {
            // if error, don't display this page
            LPSECURITYINFO pCertTemplateSecurity = NULL;

            hr = CreateCertTemplateSecurityInfo (pCertTemplate, 
                    &pCertTemplateSecurity);
            if ( SUCCEEDED (hr) )
            {
                // save the pCertTemplateSecurity pointer for later releasing
                pGeneralPage->SetAllocedSecurityInfo (pCertTemplateSecurity);

                HPROPSHEETPAGE hPage = CreateSecurityPage (pCertTemplateSecurity);
                if (hPage == NULL)
                {
                    hr = HRESULT_FROM_WIN32 (GetLastError());
                    _TRACE (0, L"CreateSecurityPage () failed: 0x%x\n", hr);
                }
                hr = pCallback->AddPage (hPage);
                _ASSERT (SUCCEEDED (hr));
            }
        }
    }
    _TRACE (-1, L"Leaving CCertTmplComponentData::AddVersion2CertTemplatePropPages: 0x%x\n", hr);
    return hr;
}

HRESULT CCertTmplComponentData::AddCertTemplatePropPages (
            CCertTemplate* pCertTemplate, 
            LPPROPERTYSHEETCALLBACK pCallback,
            LONG_PTR lNotifyHandle)
{
    _TRACE (1, L"Entering CCertTmplComponentData::AddCertTemplatePropPages\n");
    HRESULT         hr = S_OK;
    _ASSERT (pCertTemplate && pCallback);
    if ( pCertTemplate && pCallback )
    {
        switch (pCertTemplate->GetType ())
        {
        case 1:
            hr = AddVersion1CertTemplatePropPages (pCertTemplate, pCallback);
            break;

        case 2:
            hr = AddVersion2CertTemplatePropPages (pCertTemplate, pCallback, lNotifyHandle);
            break;

        default:
            _ASSERT (0);
            break;
        }
    }
    else
        hr = E_POINTER;

    _TRACE(-1, L"Leaving CCertTmplComponentData::AddCertTemplatePropPages: 0x%x\n", hr);
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
// IExtendPropertySheet Implementation

//+----------------------------------------------------------------------------
//
//  Function:   AddPageProc
//
//  Synopsis:   The IShellPropSheetExt->AddPages callback.
//
//-----------------------------------------------------------------------------
BOOL CALLBACK
AddPageProc(HPROPSHEETPAGE hPage, LPARAM pCall)
{
    TRACE(_T("xx.%03x> AddPageProc()\n"), GetCurrentThreadId());

    HRESULT hr = ((LPPROPERTYSHEETCALLBACK)pCall)->AddPage(hPage);

    return hr == S_OK;
}


HRESULT CCertTmplComponentData::AddCloneTemplateMenuItem(LPCONTEXTMENUCALLBACK pContextMenuCallback, LONG lInsertionPointID)
{
    _TRACE (1, L"Entering CCertTmplComponentData::AddCloneTemplateMenuItem\n");
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    _ASSERT (pContextMenuCallback);
    HRESULT         hr = S_OK;
    CONTEXTMENUITEM menuItem;
    CString         szMenu;
    CString         szHint;

    ::ZeroMemory (&menuItem, sizeof (menuItem));
    menuItem.lInsertionPointID = lInsertionPointID;
    menuItem.fFlags = 0;
    menuItem.fSpecialFlags = 0;
    VERIFY (szMenu.LoadString (IDS_CLONE_TEMPLATE));
    menuItem.strName = (PWSTR) (PCWSTR) szMenu;
    VERIFY (szHint.LoadString (IDS_CLONE_TEMPLATE_HINT));
    menuItem.strStatusBarText = (PWSTR) (PCWSTR) szHint;
    menuItem.lCommandID = IDM_CLONE_TEMPLATE;

    hr = pContextMenuCallback->AddItem (&menuItem);
    _ASSERT (SUCCEEDED (hr));

    _TRACE (-1, L"Leaving CCertTmplComponentData::AddCloneTemplateMenuItem\n");
    return hr;
}

HRESULT CCertTmplComponentData::AddReEnrollAllCertsMenuItem(LPCONTEXTMENUCALLBACK pContextMenuCallback, LONG lInsertionPointID)
{
    _TRACE (1, L"Entering CCertTmplComponentData::AddReEnrollAllCertsMenuItem\n");
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    _ASSERT (pContextMenuCallback);
    HRESULT         hr = S_OK;
    CONTEXTMENUITEM menuItem;
    CString         szMenu;
    CString         szHint;

    ::ZeroMemory (&menuItem, sizeof (menuItem));
    menuItem.lInsertionPointID = lInsertionPointID;
    menuItem.fFlags = 0;
    menuItem.fSpecialFlags = 0;
    VERIFY (szMenu.LoadString (IDS_REENROLL_ALL_CERTS));
    menuItem.strName = (PWSTR) (PCWSTR) szMenu;
    VERIFY (szHint.LoadString (IDS_REENROLL_ALL_CERTS_HINT));
    menuItem.strStatusBarText = (PWSTR) (PCWSTR) szHint;
    menuItem.lCommandID = IDM_REENROLL_ALL_CERTS;

    hr = pContextMenuCallback->AddItem (&menuItem);
    _ASSERT (SUCCEEDED (hr));

    _TRACE (-1, L"Leaving CCertTmplComponentData::AddReEnrollAllCertsMenuItem\n");
    return hr;
}

HRESULT CCertTmplComponentData::RefreshServer()
{
    //  Delete all the scope items and result items, attempt recreate the
    // server and force a reexpansion
    HRESULT hr = DeleteScopeItems ();
    if ( m_pResultData )
    {
        m_pResultData->DeleteAllRsltItems ();
    }

    HWND    hWndConsole = 0;

    m_pConsole->GetMainWindow (&hWndConsole);
    GUID    guid;
    hr = ExpandScopeNodes (
            &(m_RootCookie), m_hRootScopeItem,
            guid);

    return hr;
}


///////////////////////////////////////////////////////////////////////////////
//
//	ChangeRootNodeName ()
//
//  Purpose:	Change the text of the root node
//
//	Input:		newName - the new machine name that the snapin manages
//  Output:		Returns S_OK on success
//
///////////////////////////////////////////////////////////////////////////////
HRESULT CCertTmplComponentData::ChangeRootNodeName()
{
	_TRACE (1, L"Entering CCertTmplComponentData::ChangeRootNodeName\n");

    if ( !QueryBaseRootCookie ().m_hScopeItem )
    {
        if ( m_hRootScopeItem )
            QueryBaseRootCookie ().m_hScopeItem = m_hRootScopeItem;
        else
		    return E_UNEXPECTED;
    }

	CString		formattedName;

	if ( m_szManagedDomain.IsEmpty () )
		formattedName.FormatMessage (IDS_CERTTMPL_ROOT_NODE_NAME, m_szThisDomainDns);
	else
		formattedName.FormatMessage (IDS_CERTTMPL_ROOT_NODE_NAME, m_szManagedDomain);

	SCOPEDATAITEM	item;
	::ZeroMemory (&item, sizeof (SCOPEDATAITEM));
	item.mask = SDI_STR;
	item.displayname = (PWSTR) (PCWSTR) formattedName;
	item.ID = QueryBaseRootCookie ().m_hScopeItem;

	HRESULT	hr = m_pConsoleNameSpace->SetItem (&item);
    if ( FAILED (hr) )
    {
        _TRACE (0, L"IConsoleNameSpace2::SetItem () failed: 0x%x\n", hr);        
    }
	_TRACE (-1, L"Leaving CCertTmplComponentData::ChangeRootNodeName: 0x%x\n", hr);
	return hr;
}

HRESULT CCertTmplComponentData::OnNotifyPreload(LPDATAOBJECT /*pDataObject*/, HSCOPEITEM hRootScopeItem)
{
	_TRACE (1, L"Entering CCertTmplComponentData::OnNotifyPreload\n");
	HRESULT	hr = S_OK;

	QueryBaseRootCookie ().m_hScopeItem = hRootScopeItem;
	hr = ChangeRootNodeName ();

	_TRACE (-1, L"Leaving CCertTmplComponentData::OnNotifyPreload: 0x%x\n", hr);
	return hr;
}

// Help on IComponentData just returns the file and no particular topic
STDMETHODIMP CCertTmplComponentData::GetHelpTopic(LPOLESTR* lpCompiledHelpFile)
{
  if (lpCompiledHelpFile == NULL)
      return E_INVALIDARG;

  CString szHelpFilePath;
  HRESULT hr = GetHtmlHelpFilePath( szHelpFilePath );
  if ( FAILED(hr) )
    return hr;

  *lpCompiledHelpFile = reinterpret_cast <LPOLESTR> (
      CoTaskMemAlloc ((szHelpFilePath.GetLength () + 1) * sizeof (wchar_t)));
  if ( NULL == *lpCompiledHelpFile )
    return E_OUTOFMEMORY;
  USES_CONVERSION;
  wcscpy (*lpCompiledHelpFile, T2OLE ((LPTSTR)(LPCTSTR) szHelpFilePath));
  
  return S_OK;
}

HRESULT CCertTmplComponentData::GetHtmlHelpFilePath( CString& strref ) const
{
  UINT nLen = ::GetSystemWindowsDirectory (strref.GetBufferSetLength(2 * MAX_PATH), 2 * MAX_PATH);
  strref.ReleaseBuffer();
  if (0 == nLen)
  {
    _ASSERT(FALSE);
    return E_FAIL;
  }

  strref += CERTTMPL_HELP_PATH;
  strref += CERTTMPL_HTML_HELP_FILE;
  
  return S_OK;
}


HRESULT CCertTmplComponentData::OnReEnrollAllCerts (LPDATAOBJECT pDataObject)
{
    _TRACE (1, L"Entering CCertTmplComponentData::OnReEnrollAllCerts");
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    HRESULT hr = S_OK;

    if ( pDataObject )
    {
        CCertTmplCookie* pCookie = ConvertCookie (pDataObject);
        if ( pCookie )
        {
            _ASSERT (CERTTMPL_CERT_TEMPLATE == pCookie->m_objecttype);
            CCertTemplate* pCertTemplate = dynamic_cast <CCertTemplate*> (pCookie);
            if ( pCertTemplate )
            {
                hr = pCertTemplate->IncrementMajorVersion ();
                if ( SUCCEEDED (hr) )
                {
                    // Don't increment minor version - was set to 0 in 
                    // IncrementMajorVersion
                    hr = pCertTemplate->SaveChanges (false);
                    if ( SUCCEEDED (hr) )
                    {
                        HRESULTITEM	itemID = 0;
		                hr = pCookie->m_resultDataID->FindItemByLParam ((LPARAM) pCookie, &itemID);
		                _ASSERT (SUCCEEDED (hr));
		                if ( SUCCEEDED (hr) )
		                {
			                hr = m_pResultData->UpdateItem (itemID);
			                _ASSERT (SUCCEEDED (hr));
    	                }
                    }
                }
            }    
            else
                hr = E_FAIL;
        }
        else
            hr = E_FAIL;
    }
    else
        hr = E_POINTER;

    _TRACE (-1, L"Leaving CCertTmplComponentData::OnReEnrollAllCerts");
    return hr;
}

HRESULT CCertTmplComponentData::OnCloneTemplate (LPDATAOBJECT pDataObject)
{
    _TRACE (1, L"Entering CCertTmplComponentData::OnCloneTemplate");
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    HRESULT     hr = S_OK;
    CWaitCursor waitCursor;

    if ( pDataObject )
    {
        CCertTmplCookie* pCookie = ConvertCookie (pDataObject);
        if ( pCookie )
        {
            _ASSERT (CERTTMPL_CERT_TEMPLATE == pCookie->m_objecttype);
            CCertTemplate* pOldTemplate = dynamic_cast <CCertTemplate*> (pCookie);
            if ( pOldTemplate )
            {
                static  PCWSTR  pszDomainController = L"DomainController";
                static  PCWSTR  pszComputer = L"Machine";
                bool    bIsComputerOrDC = pOldTemplate->GetTemplateName () == pszDomainController ||
                                    pOldTemplate->GetTemplateName () == pszComputer;

                HWND    hWndConsole = 0;

                m_pConsole->GetMainWindow (&hWndConsole);
                CWnd    mainWindow;
                mainWindow.Attach (hWndConsole);

                CCertTemplate* pNewTemplate = new CCertTemplate (*pOldTemplate, 
                        true, false, m_fUseCache);
                if ( pNewTemplate )
                {
                    // Generate a unique name for the new template
                    int     nCopy = 1;
                    CString newName;

                    while ( 1 )
                    {
                        if ( 1 == nCopy )
                        {
                            newName.FormatMessage (IDS_COPY_OF_TEMPLATE, 
                                    (PCWSTR) pOldTemplate->GetDisplayName ());
                        }
                        else
                        {
                            newName.FormatMessage (IDS_COPY_X_OF_TEMPLATE, nCopy, 
                                    (PCWSTR) pOldTemplate->GetDisplayName ());
                        }

                        HCERTTYPE   hCertType = 0;
                        HRESULT     hr1 = CAFindCertTypeByName (newName, 
                                NULL,
                                CT_ENUM_MACHINE_TYPES | CT_ENUM_USER_TYPES | CT_FLAG_NO_CACHE_LOOKUP,
                                &hCertType);
                        _TRACE (0, L"checking to see if %s exists: %s\n", 
                                (PCWSTR) newName,
                                SUCCEEDED (hr) ? L"was found" : L"was not found");
                        if ( SUCCEEDED (hr1) )
                        {
                            hr1 = CACloseCertType (hCertType);
                            if ( FAILED (hr1) )
                            {
                                _TRACE (0, L"CACloseCertType () failed: 0x%x", hr);
                            }

                            // This one exists, try another.
                            nCopy++;
                            continue;
                        }
                        else
                        {
                            // This one does not exist.  Use it as the new name.
                            break;
                        }
                    }
                    
                    if ( SUCCEEDED (hr) )
                    {
                        hr = pNewTemplate->Clone (*pOldTemplate, 
                                newName, newName);
                        if ( SUCCEEDED (hr) )
                        {

                            CString title;

                            VERIFY (title.LoadString (IDS_PROPERTIES_OF_NEW_TEMPLATE));
                            CTemplatePropertySheet  propSheet (title, *pNewTemplate, &mainWindow);

                            CTemplateGeneralPropertyPage* pGeneralPage = 
                                    new CTemplateGeneralPropertyPage (
                                            *pNewTemplate,
                                            this);

                            if ( pGeneralPage )
                            {
                                propSheet.AddPage (pGeneralPage);
                                int nPage = 0;


                                // Add Request and Subject pages if subject is not a CA
                                if ( !pNewTemplate->SubjectIsCA () )
                                {
                                    propSheet.AddPage (new CTemplateV2RequestPropertyPage (
                                            *pNewTemplate, pGeneralPage->m_bIsDirty));
                                    nPage++;
                                    pGeneralPage->SetV2RequestPageNumber (nPage);
                                    propSheet.AddPage (new CTemplateV2SubjectNamePropertyPage (
                                            *pNewTemplate, pGeneralPage->m_bIsDirty,
                                            bIsComputerOrDC));
                                    nPage++;
                                }

                                propSheet.AddPage (new CTemplateV2AuthenticationPropertyPage ( 
                                        *pNewTemplate, pGeneralPage->m_bIsDirty));
                                nPage++;
                                pGeneralPage->SetV2AuthPageNumber (nPage);

                                propSheet.AddPage (new CTemplateV2SupercedesPropertyPage (
                                        *pNewTemplate, pGeneralPage->m_bIsDirty,
                                        this));

                                // Add template extension page - always add this page last (except for security)
                                propSheet.AddPage (new CTemplateExtensionsPropertyPage (
                                        *pNewTemplate, pGeneralPage->m_bIsDirty));


                                CThemeContextActivator activator;
                                INT_PTR iResult = propSheet.DoModal ();
                                switch (iResult)
                                {
                                case IDOK:
                                    {
                                        hr = pNewTemplate->DoAutoEnrollmentPendingSave ();

                                        // unselect old template
	                                    HRESULTITEM	itemID = 0;

	                                    ASSERT (m_pResultData);
	                                    if ( m_pResultData )
	                                    {
		                                    hr = m_pResultData->FindItemByLParam (
                                                    (LPARAM) pCookie, &itemID);
		                                    ASSERT (SUCCEEDED (hr));
		                                    if ( SUCCEEDED (hr) )
		                                    {
                                                RESULTDATAITEM  rdItem;
                                                ::ZeroMemory (&rdItem, sizeof (RESULTDATAITEM));
                                                rdItem.itemID = itemID;

                                                rdItem.mask = RDI_STATE;
                                                rdItem.nState &= ~(LVIS_FOCUSED | LVIS_SELECTED);
                                                hr = m_pResultData->SetItem (&rdItem);
                                                if ( SUCCEEDED (hr) )
                                                {
			                                        hr = m_pResultData->UpdateItem (itemID);
			                                        ASSERT (SUCCEEDED (hr));
                                                }
		                                    }
	                                    }
	                                    else
		                                    hr = E_FAIL;


                                        // Add certificate template to result pane
	                                    RESULTDATAITEM			rdItem;
	                                    CCookie&				rootCookie = QueryBaseRootCookie ();

	                                    ::ZeroMemory (&rdItem, sizeof (rdItem));
	                                    rdItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM | RDI_STATE;
	                                    rdItem.nImage = iIconCertTemplateV2;
	                                    rdItem.nCol = 0;
                                        rdItem.nState = LVIS_SELECTED | LVIS_FOCUSED;
	                                    rdItem.str = MMC_TEXTCALLBACK;

		                                rootCookie.m_listResultCookieBlocks.AddHead (pNewTemplate);
		                                rdItem.lParam = (LPARAM) pNewTemplate;
		                                pNewTemplate->m_resultDataID = m_pResultData;
		                                hr = m_pResultData->InsertItem (&rdItem);
                                        if ( FAILED (hr) )
                                        {
                                             _TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
                                        }
                                        else
                                        {
                                            m_dwNumCertTemplates++;
                                            DisplayObjectCountInStatusBar (
                                                    m_pConsole, 
                                                    m_dwNumCertTemplates);
                                            pNewTemplate = 0;
                                        }
                                    }
                                    break;

                                case IDCANCEL:
                                    // Delete cloned template
                                    if ( pNewTemplate->CanBeDeletedOnCancel () )
                                        hr = pNewTemplate->Delete ();
                                    else   // was created - let's update
                                    {
                                        hr = pNewTemplate->DoAutoEnrollmentPendingSave ();

                                        // Add certificate template to result pane
	                                    RESULTDATAITEM			rdItem;
	                                    CCookie&				rootCookie = QueryBaseRootCookie ();

	                                    ::ZeroMemory (&rdItem, sizeof (rdItem));
	                                    rdItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM | RDI_STATE;
	                                    rdItem.nImage = iIconCertTemplateV2;
	                                    rdItem.nCol = 0;
                                        rdItem.nState = LVIS_SELECTED | LVIS_FOCUSED;
	                                    rdItem.str = MMC_TEXTCALLBACK;

		                                rootCookie.m_listResultCookieBlocks.AddHead (pNewTemplate);
		                                rdItem.lParam = (LPARAM) pNewTemplate;
		                                pNewTemplate->m_resultDataID = m_pResultData;
		                                hr = m_pResultData->InsertItem (&rdItem);
                                        if ( FAILED (hr) )
                                        {
                                             _TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
                                        }
                                        else
                                        {
                                            m_dwNumCertTemplates++;
                                            DisplayObjectCountInStatusBar (
                                                    m_pConsole, 
                                                    m_dwNumCertTemplates);
                                            pNewTemplate = 0;
                                        }
                                    }
                                    break;
                                }
                            }
                            else
                                hr = E_OUTOFMEMORY;

                        }
                        else
                        {
                            CString caption;
                            CString text;

                            VERIFY (caption.LoadString (IDS_CERTTMPL));
                            text.FormatMessage (IDS_UNABLE_TO_CLONE_TEMPLATE, 
                                    pOldTemplate->GetDisplayName (), 
                                    GetSystemMessage (hr));

                            int     iRetVal = 0;
                            VERIFY (SUCCEEDED (m_pConsole->MessageBox (text, caption,
                                    MB_ICONWARNING | MB_OK, &iRetVal)));
                        }
                    }

                    if ( pNewTemplate )
                        delete pNewTemplate;
                }
                else
                    hr = E_OUTOFMEMORY;

                mainWindow.Detach ();
            }
            else
                hr = E_UNEXPECTED;
        }
        else
            hr = E_FAIL;
    }
    else
        hr = E_POINTER;

    _TRACE (-1, L"Leaving CCertTmplComponentData::OnCloneTemplate");
    return hr;
}
    
HRESULT CCertTmplComponentData::AddViewOIDsMenuItem (
                LPCONTEXTMENUCALLBACK pContextMenuCallback, 
                LONG lInsertionPointID)
{
    _TRACE (1, L"Entering CCertTmplComponentData::AddViewOIDsMenuItem\n");
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    _ASSERT (pContextMenuCallback);
    HRESULT         hr = S_OK;
    CONTEXTMENUITEM menuItem;
    CString         szMenu;
    CString         szHint;

    ::ZeroMemory (&menuItem, sizeof (menuItem));
    menuItem.lInsertionPointID = lInsertionPointID;
    menuItem.fFlags = 0;
    menuItem.fSpecialFlags = 0;
    VERIFY (szMenu.LoadString (IDS_VIEW_OIDS));
    menuItem.strName = (PWSTR) (PCWSTR) szMenu;
    VERIFY (szHint.LoadString (IDS_VIEW_OIDS_HINT));
    menuItem.strStatusBarText = (PWSTR) (PCWSTR) szHint;
    menuItem.lCommandID = IDM_VIEW_OIDS;

    hr = pContextMenuCallback->AddItem (&menuItem);
    _ASSERT (SUCCEEDED (hr));

    _TRACE (-1, L"Leaving CCertTmplComponentData::AddViewOIDsMenuItem\n");
    return hr;

}

void CCertTmplComponentData::OnViewOIDs ()
{
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
    HWND    hWndConsole = 0;

    m_pConsole->GetMainWindow (&hWndConsole);
    CWnd    mainWindow;
    mainWindow.Attach (hWndConsole);

    CViewOIDDlg dlg (&mainWindow);

    CThemeContextActivator activator;
    dlg.DoModal ();

    mainWindow.Detach ();
}