windows-xp/Source/XPSP1/NT/ds/security/services/ca/capesnpn/caprop.cpp

//+----------------------------------------------------------------------------
//
//  Windows NT Directory Service Property Pages
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1999
//
//  File:       UserCert.cxx
//
//  Contents:   
//
//  History:    12-November-97 BryanWal created
//
//-----------------------------------------------------------------------------
#include "stdafx.h"
#include "certca.h"
#include "tfcprop.h"
#include "genpage.h"

#include "commdlg.h"
#include "caprop.h"


#define ByteOffset(base, offset) (((LPBYTE)base)+offset)


//+----------------------------------------------------------------------------
//
//  Member:     CDsCACertPage::CDsCACertPage
//
//-----------------------------------------------------------------------------
CDsCACertPage::CDsCACertPage(LPWSTR wszObjectDN,  UINT uIDD) : CAutoDeletePropPage(uIDD),
    m_strObjectDN(wszObjectDN),
	m_hCertStore (0),
	m_hImageList (0),
	m_hbmCert (0),
	m_nCertImageIndex (0)
{

	::ZeroMemory (&m_selCertStruct, sizeof (m_selCertStruct));
}


//+----------------------------------------------------------------------------
//
//  Member:     CDsCACertPage::~CDsCACertPage
//
//-----------------------------------------------------------------------------
CDsCACertPage::~CDsCACertPage()
{

	// Clean up enumerated store list
	for (DWORD dwIndex = 0; dwIndex < m_selCertStruct.cDisplayStores; dwIndex++)
	{
		ASSERT (m_selCertStruct.rghDisplayStores);
		::CertCloseStore (m_selCertStruct.rghDisplayStores[dwIndex], CERT_CLOSE_STORE_FORCE_FLAG);
	}
	if ( m_selCertStruct.rghDisplayStores )
		delete [] m_selCertStruct.rghDisplayStores;


	if ( m_hImageList )
		ImageList_Destroy (m_hImageList);
	if ( m_hbmCert )
		DeleteObject (m_hbmCert);
}



typedef struct _ENUM_ARG {
    DWORD				dwFlags;
    DWORD*              pcDisplayStores;          
    HCERTSTORE **       prghDisplayStores;        
} ENUM_ARG, *PENUM_ARG;

static BOOL WINAPI EnumStoresSysCallback(
    IN const void* pwszSystemStore,
    IN DWORD dwFlags,
    IN PCERT_SYSTEM_STORE_INFO pStoreInfo,
    IN OPTIONAL void *pvReserved,
    IN OPTIONAL void *pvArg
    )
{
    PENUM_ARG pEnumArg = (PENUM_ARG) pvArg;
	void*		pvPara = (void*)pwszSystemStore;



	HCERTSTORE	hNewStore  = ::CertOpenStore (CERT_STORE_PROV_SYSTEM, 
				X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, NULL, 
				CERT_SYSTEM_STORE_CURRENT_USER, pvPara);
	if ( !hNewStore )
	{
		hNewStore = ::CertOpenStore (CERT_STORE_PROV_SYSTEM, 
				X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, NULL, 
				CERT_SYSTEM_STORE_CURRENT_USER | CERT_STORE_READONLY_FLAG, pvPara);
	}
	if ( hNewStore )
	{
		DWORD		dwCnt = *(pEnumArg->pcDisplayStores);
		HCERTSTORE*	phStores = 0;

		phStores = new HCERTSTORE[dwCnt+1];
		if ( phStores )
		{
			DWORD	dwIndex = 0;
			if ( *(pEnumArg->prghDisplayStores) )
			{
				for (; dwIndex < dwCnt; dwIndex++)
				{
					phStores[dwIndex] = (*(pEnumArg->prghDisplayStores))[dwIndex];
				}
				delete [] (*(pEnumArg->prghDisplayStores));
			}
			(*(pEnumArg->pcDisplayStores))++;
			(*(pEnumArg->prghDisplayStores)) = phStores;
			(*(pEnumArg->prghDisplayStores))[dwIndex] = hNewStore;
		}
		else
		{
			SetLastError (ERROR_NOT_ENOUGH_MEMORY);
			return FALSE;
		}
	}

    return TRUE;
}



//+----------------------------------------------------------------------------
//
//  Method:     CDsCACertPage::OnInitDialog
//
//  Synopsis:   Set the initial control values from the corresponding DS
//              attributes.
//
//-----------------------------------------------------------------------------
BOOL CDsCACertPage::OnInitDialog(void)
{
    HRESULT hResult = S_OK;
    CWaitCursor WaitCursor;
	const	LPWSTR	CERT_PROPERTY_EXT = L"?cACertificate?base?objectclass=certificationAuthority";


	// Get the object name and open its Published Certificate store
	ASSERT (m_strObjectDN);
	if ( m_strObjectDN )
	{
		LPWSTR	pvPara = new WCHAR[wcslen (m_strObjectDN) + 
					wcslen (CERT_PROPERTY_EXT) + 1];
		if ( pvPara )
		{
			wcscpy (pvPara, m_strObjectDN);
			wcscat (pvPara, CERT_PROPERTY_EXT);

			m_hCertStore = ::CertOpenStore ("LDAP",
				X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, NULL,
				0,
				(void*) pvPara);
			if ( !m_hCertStore )
			{
				MessageBox (IDS_USER_TITLE_PUBLISHED_CERTS, IDS_CANT_OPEN_STORE,
						MB_ICONINFORMATION | MB_OK);
				hResult = E_FAIL;
				::EnableWindow (GetDlgItem (m_hWnd, IDC_ADD_FROM_STORE), FALSE);
				::EnableWindow (GetDlgItem (m_hWnd, IDC_ADD_FROM_FILE), FALSE);
			}
		}
	}


	// Set up result list view
	COLORREF	crMask = RGB (255, 0, 255);
	m_hImageList = ImageList_Create (16, 16, ILC_MASK, 10, 10);
	ASSERT (m_hImageList);
	if ( m_hImageList )
	{
		m_hbmCert = ::LoadBitmap (g_hInstance, MAKEINTRESOURCE (IDB_CERTIFICATE));
		ASSERT (m_hbmCert);
		if ( m_hbmCert )
		{
			m_nCertImageIndex = ImageList_AddMasked (m_hImageList, m_hbmCert,
					crMask);
			ASSERT (m_nCertImageIndex != -1);
			if ( m_nCertImageIndex != -1 )
			{
				ListView_SetImageList (::GetDlgItem (m_hWnd, IDC_CERT_LIST),
						m_hImageList, LVSIL_SMALL);		
			}
		}
	}


	hResult = AddListViewColumns ();
	if ( SUCCEEDED  (hResult) && m_hCertStore )
		hResult = PopulateListView ();

	EnableControls ();

	// Enumerate User's certificate stores for use in selecting certificates
	// from stores.
	ENUM_ARG	EnumArg;

	m_selCertStruct.dwSize = sizeof (CRYPTUI_SELECTCERTIFICATE_STRUCT);
	m_selCertStruct.hwndParent = m_hWnd;
	EnumArg.pcDisplayStores = &m_selCertStruct.cDisplayStores;
	EnumArg.prghDisplayStores = &m_selCertStruct.rghDisplayStores;

	::CertEnumSystemStore (CERT_SYSTEM_STORE_CURRENT_USER, 0, &EnumArg, 
			EnumStoresSysCallback);

    return (hResult == S_OK);
}

//+----------------------------------------------------------------------------
//
//  Method:     CDsCACertPage::OnApply
//
//  Synopsis:   Handles the Apply notification.
//
//-----------------------------------------------------------------------------
BOOL CDsCACertPage::OnApply(void)
{
    HRESULT hResult = S_OK;
    CWaitCursor WaitCursor;

	if ( m_hCertStore )
	{
		BOOL	bResult = ::CertControlStore (m_hCertStore, 0, 
				CERT_STORE_CTRL_COMMIT, NULL);
		if ( !bResult )
		{

			DWORD	dwErr = GetLastError ();
			ASSERT (dwErr == ERROR_NOT_SUPPORTED);
			if ( dwErr != ERROR_NOT_SUPPORTED )
			{
				MessageBox (IDS_USER_TITLE_PUBLISHED_CERTS, IDS_CANT_SAVE_STORE,
						MB_ICONINFORMATION | MB_OK);
				hResult = E_FAIL;
			}
		}
	}

    if(SUCCEEDED(hResult))
    {
        return CAutoDeletePropPage::OnApply();
    }
    else
    {
        return FALSE;
    }
}

//+----------------------------------------------------------------------------
//
//  Method:     CDsCACertPage::OnCommand
//
//  Synopsis:   Handle control notifications.
//
//-----------------------------------------------------------------------------
BOOL CDsCACertPage::OnCommand(WPARAM wParam, LPARAM lParam)
{
    switch (HIWORD(wParam))
    {
	case BN_CLICKED:
		switch (LOWORD(wParam))
		{
		case IDC_VIEW_CERT:
			return S_OK == OnClickedViewCert ();
			break;

		case IDC_ADD_FROM_STORE:
			return S_OK == OnClickedAddFromStore ();
			break;

		case IDC_ADD_FROM_FILE:
			return S_OK == OnClickedAddFromFile ();
			break;

		case IDC_REMOVE:
			return S_OK == OnClickedRemove ();
			break;

		case IDC_COPY_TO_FILE:
			return S_OK == OnClickedCopyToFile ();
			break;

		default:
			_ASSERT (0);
			return FALSE;
			break;
		}
		break;

	default:
        break;
    }
    return TRUE;
}


//+----------------------------------------------------------------------------
//
//  Method:     CDsCACertPage::OnNotify
//
//  Synopsis:   
//
//-----------------------------------------------------------------------------
BOOL
CDsCACertPage::OnNotify(UINT idCtrl, NMHDR* pNMHdr)
{
	if ( !pNMHdr )
		return FALSE;

	switch (pNMHdr->code)
	{
	case NM_DBLCLK:
        if ( idCtrl == IDC_CERT_LIST )
			return S_OK == OnDblClkCertList (pNMHdr);
		break;

	case LVN_COLUMNCLICK:

		if ( idCtrl == IDC_CERT_LIST )
			return S_OK == OnColumnClickCertList (pNMHdr);
		break;

	case LVN_DELETEALLITEMS:

		if ( idCtrl == IDC_CERT_LIST )
			return FALSE;	// Do not suppress LVN_DELETEITEM messages
		break;

	case LVN_DELETEITEM:
		if ( idCtrl == IDC_CERT_LIST )
			return S_OK == OnDeleteItemCertList ((LPNMLISTVIEW)pNMHdr);
		break;

	case LVN_ODSTATECHANGED:
		OnNotifyStateChanged ((LPNMLVODSTATECHANGE)pNMHdr);
		return TRUE;

	case LVN_ITEMCHANGED:
		OnNotifyItemChanged ((LPNMLISTVIEW)pNMHdr); 
		return TRUE;

	default:
        return FALSE;
        break;
	}

    return TRUE;
}


//+----------------------------------------------------------------------------
//
//  Method:     CDsCACertPage::OnDestroy
//
//  Synopsis:   Exit cleanup
//
//-----------------------------------------------------------------------------
void CDsCACertPage::OnDestroy(void)
{
	ListView_DeleteAllItems (::GetDlgItem (m_hWnd, IDC_CERT_LIST));

	if ( m_hCertStore )
	{
		// Back out of uncommitted changes before closing the store.
		BOOL	bResult = ::CertControlStore (m_hCertStore, 
			CERT_STORE_CTRL_COMMIT_CLEAR_FLAG, 
			CERT_STORE_CTRL_COMMIT, NULL);
		if ( !bResult )
		{
			DWORD	dwErr = GetLastError ();
			ASSERT (dwErr != ERROR_NOT_SUPPORTED && dwErr != ERROR_CALL_NOT_IMPLEMENTED);
		}
		::CertCloseStore (m_hCertStore, 0);
		m_hCertStore = 0;
	}

    // If an application processes this message, it should return zero.
    CAutoDeletePropPage::OnDestroy();
}




HRESULT CDsCACertPage::AddListViewColumns()
{
	// Add list view columns
	LVCOLUMN	lvCol;
	::ZeroMemory (&lvCol, sizeof (lvCol));
    CString strTemp;

    VERIFY(strTemp.LoadString (IDS_CERTCOL_ISSUED_TO) );

	lvCol.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM; 
    lvCol.fmt = LVCFMT_LEFT;
	lvCol.cx = 90;
    lvCol.pszText = const_cast<LPWSTR>((LPCWSTR)strTemp);     
	lvCol.iSubItem = CERTCOL_ISSUED_TO; 
	HWND	hWndList = ::GetDlgItem (m_hWnd, IDC_CERT_LIST);
	int	nIndex = ListView_InsertColumn (hWndList, CERTCOL_ISSUED_TO, &lvCol);
	_ASSERT (nIndex != -1);
	if ( nIndex == -1 )
		return E_UNEXPECTED;

    VERIFY(strTemp.LoadString (IDS_CERTCOL_ISSUED_BY) );

	lvCol.cx = 90;
    lvCol.pszText = const_cast<LPWSTR>((LPCWSTR)strTemp);      
	lvCol.iSubItem = CERTCOL_ISSUED_BY; 
	nIndex = ListView_InsertColumn (hWndList, IDS_CERTCOL_ISSUED_BY, &lvCol);
	_ASSERT (nIndex != -1);
	if ( nIndex == -1 )
		return E_UNEXPECTED;

    VERIFY(strTemp.LoadString (IDS_CERTCOL_PURPOSES) );

	lvCol.cx = 125;
    lvCol.pszText = const_cast<LPWSTR>((LPCWSTR)strTemp);      
	lvCol.iSubItem = CERTCOL_PURPOSES; 
	nIndex = ListView_InsertColumn (hWndList, IDS_CERTCOL_PURPOSES, &lvCol);
	_ASSERT (nIndex != -1);
	if ( nIndex == -1 )
		return E_UNEXPECTED;

    VERIFY(strTemp.LoadString (IDS_CERTCOL_EXP_DATE) );
	lvCol.cx = 125;
    lvCol.pszText = const_cast<LPWSTR>((LPCWSTR)strTemp);     
	lvCol.iSubItem = CERTCOL_EXP_DATE; 
	nIndex = ListView_InsertColumn (hWndList, IDS_CERTCOL_EXP_DATE, &lvCol);
	_ASSERT (nIndex != -1);
	if ( nIndex == -1 )
		return E_UNEXPECTED;

	return S_OK;
}

HRESULT CDsCACertPage::OnClickedViewCert()
{
	HRESULT	hResult = S_OK;
	int				nSelItem = -1;
	CCertificate*	pCert = GetSelectedCertificate (nSelItem);
	if ( pCert )
	{
		CRYPTUI_VIEWCERTIFICATE_STRUCT	vcs;
		HCERTSTORE						hCertStore = ::CertDuplicateStore (pCert->GetCertStore ());


		::ZeroMemory (&vcs, sizeof (vcs));
		vcs.dwSize = sizeof (vcs);
		vcs.hwndParent = m_hWnd;
		vcs.dwFlags = 0;
		vcs.cStores = 1;
		vcs.rghStores = &hCertStore;
		vcs.pCertContext = pCert->GetCertContext ();

		BOOL fPropertiesChanged = FALSE;
		BOOL bResult = ::CryptUIDlgViewCertificate (&vcs, &fPropertiesChanged);
		if ( bResult )
		{
			if ( fPropertiesChanged )
			{
				pCert->Refresh ();
				RefreshItemInList (pCert, nSelItem);
			}
		}
		::CertCloseStore (hCertStore, 0);
	}
	
	::SetFocus (::GetDlgItem (m_hWnd, IDC_CERT_LIST));
	return hResult;
}

HRESULT CDsCACertPage::OnClickedAddFromStore()
{
	HRESULT								hResult = S_OK;

	PCCERT_CONTEXT	pCertContext = ::CryptUIDlgSelectCertificate (&m_selCertStruct);
	if ( pCertContext )
	{
		hResult = AddCertToStore (pCertContext);
        SetModified();
	}
	

	::SetFocus (::GetDlgItem (m_hWnd, IDC_CERT_LIST));
	return hResult;
}

HRESULT CDsCACertPage::OnClickedAddFromFile()
{
	HRESULT			hResult = S_OK;
	HWND			hwndList = ::GetDlgItem (m_hWnd, IDC_CERT_LIST);


	CString strFilter;
	CString strDlgTitle;
	VERIFY(strFilter.LoadString (IDS_CERT_SAVE_FILTER));
	VERIFY(strDlgTitle.LoadString (IDS_OPEN_FILE_DLG_TITLE));

	{
		LPWSTR			pszDefExt = _T("cer");
		OPENFILENAME	ofn;
		WCHAR			szFile[MAX_PATH];



		::ZeroMemory (szFile, MAX_PATH * sizeof (WCHAR));
		::ZeroMemory (&ofn, sizeof (ofn));
		ofn.lStructSize = sizeof (OPENFILENAME);     
		ofn.hwndOwner = m_hWnd;
		ofn.lpstrFilter = const_cast<LPWSTR>((LPCWSTR)strFilter);
		ofn.lpstrFile = szFile;
		ofn.nMaxFile = MAX_PATH;     
		ofn.lpstrTitle = const_cast<LPWSTR>((LPCWSTR)strDlgTitle);
		ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST; 
		ofn.lpstrDefExt = pszDefExt;     


		BOOL bResult = GetOpenFileName (&ofn);
		if ( bResult )
		{
			DWORD			dwMsgAndCertEncodingType = 0;
			DWORD			dwContentType = 0;
			DWORD			dwFormatType = 0;
			PCERT_CONTEXT	pCertContext = 0;

			bResult = ::CryptQueryObject (
					CERT_QUERY_OBJECT_FILE,
					(void *) ofn.lpstrFile,
					CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT |
						CERT_QUERY_CONTENT_FLAG_CERT |
						CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED | 
						CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED |  
						CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED,
					CERT_QUERY_FORMAT_FLAG_ALL,
					0,
					&dwMsgAndCertEncodingType,
					&dwContentType,
					&dwFormatType,
					NULL,
					NULL,
					(const void **) &pCertContext);
			if ( bResult && pCertContext )
			{		
				hResult = AddCertToStore (pCertContext);
//				::CertFreeCertificateContext (pCertContext);
                SetModified();
			}
			else
			{
                MessageBox (IDS_UNKNOWN_CERT_FILE_TYPE, IDS_OPEN_FILE_DLG_TITLE, MB_ICONWARNING | MB_OK);

			}
		}
	}


	::SetFocus (hwndList);
	return hResult;
}

HRESULT CDsCACertPage::OnClickedRemove()
{
	HRESULT			hResult = S_OK;
	int				nSelItem = -1;
	HWND			hwndList = ::GetDlgItem (m_hWnd, IDC_CERT_LIST);
	bool			bConfirmationRequested = false;
	int				iResult = 0;
	int				nSelCnt = ListView_GetSelectedCount (hwndList);

	if ( nSelCnt < 1 )
		return E_FAIL;

	while (1)
	{
		CCertificate*	pCert = GetSelectedCertificate (nSelItem);
		if ( pCert )
		{
			if ( !bConfirmationRequested )
			{
	            CString strCaption;
	            CString strMsg;
				int		textId = 0;


                iResult = MessageBox (( 1 == nSelCnt )?IDS_CONFIRM_DELETE_CERT:IDS_CONFIRM_DELETE_CERTS, IDS_REMOVE_CERT,
						MB_YESNO);
				
				bConfirmationRequested = true;
				if ( IDYES != iResult )
					break;
			}

			BOOL bResult = pCert->DeleteFromStore ();
			ASSERT (bResult);
			if ( bResult )
			{
				bResult = ListView_DeleteItem (
						hwndList, 
						nSelItem);
				ASSERT (bResult);
				if ( bResult )
                    SetModified();
				else
					hResult = E_FAIL;
			}
			else
			{
				DWORD dwErr = GetLastError ();
				DisplaySystemError (dwErr, IDS_REMOVE_CERT);
				hResult = HRESULT_FROM_WIN32 (dwErr);
				break;
			}
		}
		else
			break;
	}

	::SetFocus (hwndList);
	EnableControls ();

	return hResult;
}

HRESULT CDsCACertPage::OnClickedCopyToFile()
{
	HRESULT			hResult = S_OK;

	CString strFilter;
	CString strDlgTitle;
	VERIFY(strFilter.LoadString (IDS_CERT_SAVE_FILTER));
	VERIFY(strDlgTitle.LoadString (IDS_SAVE_FILE_DLG_TITLE));
	{
		LPWSTR			pszDefExt = _T("cer");
		OPENFILENAME	ofn;
		WCHAR			szFile[MAX_PATH];


		::ZeroMemory (szFile, MAX_PATH * sizeof (WCHAR));
		::ZeroMemory (&ofn, sizeof (ofn));
		ofn.lStructSize = sizeof (OPENFILENAME);     
		ofn.hwndOwner = m_hWnd;
		ofn.lpstrFilter = const_cast<LPWSTR>((LPCWSTR)strFilter);
		ofn.lpstrFile = szFile;
		ofn.nMaxFile = MAX_PATH;     
		ofn.lpstrTitle = const_cast<LPWSTR>((LPCWSTR)strDlgTitle);
		ofn.Flags = OFN_PATHMUSTEXIST | OFN_CREATEPROMPT | OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY; 
		ofn.lpstrDefExt = pszDefExt;     

		BOOL bResult = ::GetSaveFileName (&ofn);
		if ( bResult )
		{
			if ( wcsstr (_wcsupr (ofn.lpstrFile), _T(".CER")) )
			{
				HANDLE hFile = ::CreateFile (ofn.lpstrFile, // pointer to name of the file
					  GENERIC_READ | GENERIC_WRITE,         // access (read-write) mode
					  0,									// share mode
					  NULL,									// pointer to security attributes
					  CREATE_ALWAYS,						// how to create
					  FILE_ATTRIBUTE_NORMAL,				// file attributes
					  NULL);								// handle to file with attributes to copy
				ASSERT (hFile != INVALID_HANDLE_VALUE);
				if ( hFile != INVALID_HANDLE_VALUE )
				{
					int	iSelItem = -1;

					CCertificate* pCert = GetSelectedCertificate (iSelItem);
					ASSERT (pCert);
					if ( pCert )
					{
						// To cer file -> put out encoded blob
						// pbEncodedCert
						hResult = pCert->WriteToFile (hFile);
						if ( !SUCCEEDED (hResult) )
							DisplaySystemError (GetLastError (), IDS_COPY_TO_FILE);
					}

					if ( !CloseHandle (hFile) )
					{
						ASSERT (0);
						DisplaySystemError (GetLastError (), IDS_COPY_TO_FILE);
					}
				}
				else
					DisplaySystemError (GetLastError (), IDS_COPY_TO_FILE);
			}
			else
			{
				void* pvSaveToPara = (void*) ofn.lpstrFile;

				HCERTSTORE hCertStore = ::CertOpenStore (CERT_STORE_PROV_MEMORY, 
						X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, NULL, 
						CERT_FILE_STORE_COMMIT_ENABLE_FLAG, 0);
				if ( hCertStore )
				{
					int	iSelItem = -1;

					CCertificate* pCert = GetSelectedCertificate (iSelItem);
					ASSERT (pCert);
					if ( pCert )
					{
						bResult = ::CertAddCertificateContextToStore (
								hCertStore,
								::CertDuplicateCertificateContext (pCert->GetCertContext ()),
								CERT_STORE_ADD_ALWAYS,
								NULL);
						ASSERT (bResult);
						if ( bResult )
						{
							bResult = ::CertSaveStore (
									hCertStore,
									X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
									CERT_STORE_SAVE_AS_PKCS7,
									CERT_STORE_SAVE_TO_FILENAME,
									pvSaveToPara,
									0);
							ASSERT (bResult);
							if ( !bResult )
								DisplaySystemError (GetLastError (), IDS_COPY_TO_FILE);
						}
						else
							DisplaySystemError (GetLastError (), IDS_COPY_TO_FILE);
					}
					::CertCloseStore (hCertStore, 0);
				}
			}
		}
	}

	
	::SetFocus (::GetDlgItem (m_hWnd, IDC_CERT_LIST));
	return hResult;
}

HRESULT CDsCACertPage::OnDblClkCertList(LPNMHDR pNMHdr)
{
	HRESULT	hResult = S_OK;
	
	hResult = OnClickedViewCert ();
	return hResult;
}

HRESULT CDsCACertPage::OnColumnClickCertList(LPNMHDR pNMHdr)
{
	HRESULT	hResult = S_OK;
	
	return hResult;
}

HRESULT	CDsCACertPage::OnDeleteItemCertList (LPNMLISTVIEW pNMListView)
{
	HRESULT	hResult = S_OK;

	ASSERT (pNMListView);
	if ( pNMListView )
	{
		LVITEM	lvItem;

		::ZeroMemory (&lvItem, sizeof (lvItem));

		lvItem.mask = LVIF_PARAM;
		lvItem.iItem = pNMListView->iItem;

		if ( ListView_GetItem (::GetDlgItem (m_hWnd, IDC_CERT_LIST), &lvItem) )
		{
			CCertificate* pCert = (CCertificate*) lvItem.lParam;
			ASSERT (pCert);
			if ( pCert )
			{
				delete pCert;
			}
			else
				hResult = E_UNEXPECTED;
		}
		else
			hResult = E_UNEXPECTED;
	}
	else
		hResult = E_POINTER;

	return hResult;
}

HRESULT CDsCACertPage::PopulateListView()
{
	CWaitCursor			cursor;
    PCCERT_CONTEXT		pCertContext = 0;
	HRESULT				hResult = S_OK;
	CCertificate*		pCert = 0;

	//	Iterate through the list of certificates in the system store,
	//	allocate new certificates with the CERT_CONTEXT returned,
	//	and store them in the certificate list.
	int	nIndex = 0;
	int	nItem = -1;
	while ( SUCCEEDED (hResult) )
	{
		pCertContext = ::CertEnumCertificatesInStore (m_hCertStore, pCertContext);
		if ( !pCertContext )
			break;

		pCert = new CCertificate (pCertContext,	m_hCertStore);
		if ( pCert )
		{
			nItem++;

			hResult = InsertCertInList (pCert, nItem);
			if ( !SUCCEEDED (hResult) )
				delete pCert;
		}
		else
		{
			hResult = E_OUTOFMEMORY;
		}
	}


	return hResult;
}

// Get the first selected certificate, starting at the end of the list
// and previous to the passed in nSelItem.  Pass in a -1 to search
// the entire list
CCertificate* CDsCACertPage::GetSelectedCertificate (int& nSelItem)
{
	HWND			hWndList = ::GetDlgItem (m_hWnd, IDC_CERT_LIST);
	int				nCnt = ListView_GetItemCount (hWndList);
	CCertificate*	pCert = 0;
	PCCERT_CONTEXT	pCertContext = 0;
	int				nSelCnt = ListView_GetSelectedCount (hWndList);
	LVITEM			lvItem;

	::ZeroMemory (&lvItem, sizeof (lvItem));
	lvItem.mask = LVIF_PARAM;


	if ( nSelCnt >= 1 )
	{
		if ( -1 != nSelItem )
			nCnt = nSelItem;

		while (--nCnt >= 0)
		{
			UINT	flag = ListView_GetItemState (hWndList, 
				nCnt, LVIS_SELECTED);
			if ( flag & LVNI_SELECTED )
			{
				lvItem.iItem = nCnt;

				if ( ListView_GetItem (::GetDlgItem (m_hWnd, 
						IDC_CERT_LIST),
						&lvItem) )
				{
					pCert = (CCertificate*) lvItem.lParam;
					ASSERT (pCert);
					if ( pCert )
					{
						nSelItem = nCnt;
					}
				}
				else
				{
					ASSERT (0);
				}
				break; 
			}
		}
	}

	return pCert;
}

void CDsCACertPage::RefreshItemInList (CCertificate * pCert, int nItem)
{
	HWND			hWndList = ::GetDlgItem (m_hWnd, IDC_CERT_LIST);
	BOOL	bResult = (BOOL)::SendMessage (hWndList, LVM_DELETEITEM, nItem, 0);
	ASSERT (bResult);

	HRESULT	hResult = InsertCertInList (pCert, nItem);
	if ( SUCCEEDED (hResult) )
	{
		bResult = ListView_Update (hWndList, nItem);
		ASSERT (bResult);
	}
	else
		delete pCert;	
}


HRESULT CDsCACertPage::InsertCertInList(CCertificate * pCert, int nItem)
{
	HRESULT			hResult = S_OK;
	HWND			hWndList = ::GetDlgItem (m_hWnd, IDC_CERT_LIST);
	LVITEM			lvItem;
	PWSTR			pszText = 0;
	BOOL			bResult = FALSE;
	int				nIndex = 0;


	// Insert icon and subject name
	::ZeroMemory (&lvItem, sizeof (lvItem));
	lvItem.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
	lvItem.iItem = nItem;
	lvItem.iSubItem = CERTCOL_ISSUED_TO;
	lvItem.iImage = m_nCertImageIndex;
	lvItem.lParam = (LPARAM) pCert;
	hResult = pCert->GetSubjectName (&pszText);
	if ( SUCCEEDED (hResult) )
		lvItem.pszText = pszText;
	else
	{
		hResult = pCert->GetAlternateSubjectName (&pszText);
		if ( SUCCEEDED (hResult) )
			lvItem.pszText = pszText;
	}
	if ( SUCCEEDED (hResult) )
	{
		nIndex = ListView_InsertItem (hWndList, &lvItem);		
		_ASSERT (nIndex != -1);
		if ( nIndex == -1 )
		{
			delete pCert;
			hResult = E_UNEXPECTED;
		}
	}
	else
	{
		delete pCert;
		hResult = E_UNEXPECTED;
	}


	if ( SUCCEEDED (hResult) )
	{
		// Insert issuer name
		::ZeroMemory (&lvItem, sizeof (lvItem));
		HRESULT	hResult1 = pCert->GetIssuerName (&pszText);
		if ( !SUCCEEDED (hResult1) )
		{
			hResult1 = pCert->GetAlternateIssuerName (&pszText);
		}
		if ( SUCCEEDED (hResult1) )
		{
			ListView_SetItemText (hWndList, nIndex, CERTCOL_ISSUED_BY, pszText);
		}
	}

	// Insert intended purpose
	if ( SUCCEEDED (hResult) )
	{
		HRESULT	hResult1 = pCert->GetEnhancedKeyUsage (&pszText);
		if ( SUCCEEDED (hResult1) && pszText )
		{
			ListView_SetItemText (hWndList, nIndex, CERTCOL_PURPOSES, pszText);
		}
	}

	// Insert expiration date
	if ( SUCCEEDED (hResult) )
	{
		HRESULT	hResult1 = pCert->GetValidNotAfter (&pszText);
		if ( SUCCEEDED (hResult1) )
		{
			ListView_SetItemText (hWndList, nIndex, CERTCOL_EXP_DATE, pszText);
		}
	}

	if ( pszText )
		delete [] pszText;

	return hResult;
}

void CDsCACertPage::DisplaySystemError(DWORD dwErr, int iCaptionText)
{
	LPVOID lpMsgBuf = 0;
		
	if (0 != FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,    
			NULL,
			dwErr,
			MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
			(LPTSTR) &lpMsgBuf, 0, NULL))
        {
		
	// Display the string.
	CString	strCaption;	
	VERIFY(strCaption.LoadString(iCaptionText));

	::MessageBox (m_hWnd, (LPWSTR) lpMsgBuf, strCaption, MB_ICONWARNING | MB_OK);

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

void CDsCACertPage::EnableControls()
{
	HWND	hWndDlg = m_hWnd;
	HWND	hWndList = ::GetDlgItem (hWndDlg, IDC_CERT_LIST);
	int		nSelCnt = ListView_GetSelectedCount (hWndList);
	int		nSelItem = -1;
	bool	bCanDelete = true;

	while (bCanDelete)
	{
		CCertificate*	pCert = GetSelectedCertificate (nSelItem);
		if ( pCert )
			bCanDelete = pCert->CanDelete ();
		else
			break;
	}

	::EnableWindow (::GetDlgItem (hWndDlg, IDC_REMOVE), bCanDelete && nSelCnt > 0);
	::EnableWindow (::GetDlgItem (hWndDlg, IDC_COPY_TO_FILE), nSelCnt == 1);
	::EnableWindow (::GetDlgItem (hWndDlg, IDC_VIEW_CERT), nSelCnt == 1);
}

void CDsCACertPage::OnNotifyStateChanged(LPNMLVODSTATECHANGE pStateChange)
{
	EnableControls ();
}

void CDsCACertPage::OnNotifyItemChanged (LPNMLISTVIEW pnmv)
{
	EnableControls ();
}

HRESULT CDsCACertPage::AddCertToStore(PCCERT_CONTEXT pCertContext)
{
	HRESULT	hResult = S_OK;

	BOOL bResult = ::CertAddCertificateContextToStore (
				m_hCertStore,
				pCertContext,
				CERT_STORE_ADD_NEW,
				0);
	if ( bResult )
	{
		CCertificate* pCert = new CCertificate (pCertContext, m_hCertStore); 
		if ( pCert )
		{
			hResult = InsertCertInList (pCert, 
					ListView_GetItemCount (
					::GetDlgItem (m_hWnd, IDC_CERT_LIST)));
			if ( !SUCCEEDED (hResult) )
				delete pCert;
		}
		else
		{
			hResult = E_OUTOFMEMORY;
		}
	}
	else
	{
		DWORD	dwErr = GetLastError ();
		if ( dwErr == CRYPT_E_EXISTS )
		{
			MessageBox (IDS_DUPLICATE_CERT, IDS_ADD_FROM_STORE, 
					MB_ICONINFORMATION | MB_OK);
			hResult = E_FAIL;

		}
		else
		{
			DisplaySystemError (dwErr, IDS_ADD_FROM_STORE);
			hResult = HRESULT_FROM_WIN32 (dwErr);
		}
	}

	return hResult;
}

int CDsCACertPage::MessageBox(int caption, int text, UINT flags)
{
	int	iReturn = -1;

	CString strCaption;
	CString strMsg;
	VERIFY(strCaption.LoadString (caption));
	VERIFY(strMsg.LoadString (text));

	iReturn = ::MessageBox (m_hWnd, strMsg, strCaption, flags);

	return iReturn;
}

/*----------------------------------------------------------------------
					IShellExtInit Implementation.
------------------------------------------------------------------------*/

STDMETHODIMP CCAShellExt::Initialize
(
	IN LPCITEMIDLIST	pidlFolder,		// Points to an ITEMIDLIST structure
	IN LPDATAOBJECT	    pDataObj,		// Points to an IDataObject interface
	IN HKEY			    hkeyProgID		// Registry key for the file object or folder type
)
{

  HRESULT hr = 0;
  FORMATETC fmte = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  STGMEDIUM medium = { TYMED_NULL };
  CString csClass, csPath;
  USES_CONVERSION;

  LPWSTR wszTypeDN = NULL, wszType = NULL;

  AFX_MANAGE_STATE(AfxGetStaticModuleState());

  // if we have a pDataObj then try and get the first name from it

  if ( pDataObj ) 
  {
    // get path and class

    fmte.cfFormat = (CLIPFORMAT) RegisterClipboardFormat(CFSTR_DSOBJECTNAMES);
    if ( SUCCEEDED(pDataObj->GetData(&fmte, &medium)) ) 
    {
        // Note:  We take ownership of the HGLOBAL, so it needs to be freed with a GlobalFree.
        m_Names = (LPDSOBJECTNAMES)medium.hGlobal;
    }
  }
  hr = S_OK;                  // success
  
  
  return hr;

}


STDMETHODIMP CCAShellExt::AddPages
(
	IN LPFNADDPROPSHEETPAGE lpfnAddPage, 
	IN LPARAM lParam
)

{
    PropertyPage* pBasePage;
    LPWSTR        wszClassType = NULL;
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    if(m_Names->cItems != 1)
    {
        // Don't add the properties page if we have no or many objects selected
        return S_OK;
    }

    if(m_Names->aObjects[0].offsetName == 0)
    {
        return E_UNEXPECTED;
    }
    if(m_Names->aObjects[0].offsetClass)
    {
        wszClassType = (LPWSTR)ByteOffset(m_Names, m_Names->aObjects[0].offsetClass);
    }

    if(wszClassType == NULL)
    {
        return S_OK;
    }

    if(_wcsicmp(wszClassType, L"certificationAuthority") == 0)
    {
    
        CDsCACertPage* pControlPage = new CDsCACertPage((LPWSTR)ByteOffset(m_Names, m_Names->aObjects[0].offsetName));
        if(pControlPage)
        {
            pBasePage = pControlPage;
            HPROPSHEETPAGE hPage = CreatePropertySheetPage(&pBasePage->m_psp);
            if (hPage == NULL)
            {
                delete (pControlPage);
                return E_UNEXPECTED;
            }
            lpfnAddPage(hPage, lParam);                          
        }
    }
                                                                         
    return S_OK;                                                            
}


STDMETHODIMP CCAShellExt::ReplacePage
(
	IN UINT uPageID, 
    IN LPFNADDPROPSHEETPAGE lpfnReplaceWith, 
    IN LPARAM lParam
)
{
    return E_FAIL;
}


// IContextMenu methods
STDMETHODIMP CCAShellExt::GetCommandString
(    
    UINT_PTR idCmd,    
    UINT uFlags,    
    UINT *pwReserved,
    LPSTR pszName,    
    UINT cchMax   
)
{
    return E_NOTIMPL;
}


STDMETHODIMP CCAShellExt::InvokeCommand
(    
    LPCMINVOKECOMMANDINFO lpici   
)
{
    HRESULT hr = S_OK;

    LPWSTR        wszClassType = NULL;
    if(m_Names->cItems != 1)
    {
        // Don't add the properties page if we have no or many objects selected
        return S_OK;
    }

    if(m_Names->aObjects[0].offsetName == 0)
    {
        return E_UNEXPECTED;
    }
    if(m_Names->aObjects[0].offsetClass)
    {
        wszClassType = (LPWSTR)ByteOffset(m_Names, m_Names->aObjects[0].offsetClass);
    }

    if(wszClassType == NULL)
    {
        return S_OK;
    }


    if (!HIWORD(lpici->lpVerb))    
    {        
        UINT idCmd = LOWORD(lpici->lpVerb);
        if(_wcsicmp(wszClassType, L"pKIEnrollmentService") == 0)
        {
            if(idCmd == m_idManage)
            {
                return _SpawnCertServerSnapin((LPWSTR)ByteOffset(m_Names, m_Names->aObjects[0].offsetName));
            }
        }
        else if(_wcsicmp(wszClassType, L"cRLDistributionPoint") == 0)
        {
            PCCRL_CONTEXT pCRL = NULL;
            _CRLFromDN((LPWSTR)ByteOffset(m_Names, m_Names->aObjects[0].offsetName),
                       &pCRL);
            if(pCRL)
            {
                if(idCmd == m_idOpen)
                {
                    hr = _LaunchCRLDialog(pCRL);
                }
                else if(idCmd == m_idExport)
                {
                    hr = _OnExportCRL(pCRL);
                }

                CertFreeCRLContext(pCRL);
                return hr;
            }

        }
    }

    return E_NOTIMPL;
}


STDMETHODIMP CCAShellExt::_SpawnCertServerSnapin(LPWSTR wszServiceDN)
{
    // Determine the config string.  Strinp the CN out of the service DN, look it up via certca.h api's.

    HRESULT hr = S_OK;
    HCAINFO hCAInfo = NULL;
    LPWSTR wszTypeDN;
    LPWSTR *awszDNSName = NULL;
    LPWSTR wszArgs = NULL;
    
    LPWSTR wszCN= NULL;


    wszTypeDN = wcsstr(wszServiceDN, L"CN=");
    if(wszTypeDN == NULL)
    {
        return E_UNEXPECTED;
    }
    wszTypeDN += 3;


    wszCN = (LPWSTR)LocalAlloc(LMEM_FIXED, sizeof(WCHAR)*(wcslen(wszTypeDN)+1));
    if(wszCN == NULL)
    {
        return E_OUTOFMEMORY;
    }
    wcscpy(wszCN, wszTypeDN);
    wszTypeDN = wcschr(wszCN, L',');
    if(wszTypeDN)
    {
        *wszTypeDN = 0;
    }

    hr = CAFindByName(
		wszCN,
		NULL,
		CA_FIND_INCLUDE_UNTRUSTED | CA_FIND_INCLUDE_NON_TEMPLATE_CA,
		&hCAInfo);
    if(hr != S_OK)
    {
        goto error;
    }

    hr = CAGetCAProperty(hCAInfo, CA_PROP_DNSNAME, &awszDNSName);
    if(hr != S_OK)
    {
        goto error;
    }
    if((awszDNSName == NULL) || (awszDNSName[0] == NULL))
    {
        hr = E_UNEXPECTED;
        goto error;
    }



    wszArgs = (LPWSTR) LocalAlloc (LMEM_FIXED, (wcslen (awszDNSName[0]) + wcslen(wszCN) + 30) * sizeof(WCHAR));

    if (!wszArgs)
    {
        hr = E_OUTOFMEMORY;
        goto error;
    }

    //
    // Build the command line arguments
    //

    wsprintf (wszArgs, L"/s /machine:%s", awszDNSName[0]);


    ShellExecute (NULL, TEXT("open"), TEXT("certsrv.msc"), wszArgs,
                  NULL, SW_SHOWNORMAL);

error:
    if(wszArgs)
    {
        LocalFree(wszArgs);
    }

    if(wszCN)
    {
        LocalFree(wszCN);
    }
    if(hCAInfo)
    {
        if(awszDNSName)
        {
            CAFreeCAProperty(hCAInfo, awszDNSName);
        }
        CACloseCA(hCAInfo);
    }
    return hr;
}


STDMETHODIMP CCAShellExt::_CRLFromDN(LPWSTR wszCDPDN, PCCRL_CONTEXT *ppCRL)
{
    HCERTSTORE              hStore = NULL;
    HRESULT                 hResult = S_OK;
	const	LPWSTR	CDP_PROPERTY_EXT = L"?certificateRevocationList?base?objectclass=cRLDistributionPoint";

    LPWSTR  pvPara = NULL;

	ASSERT (wszCDPDN);
    *ppCRL = NULL;
	if ( wszCDPDN )
	{
		pvPara = new WCHAR[wcslen (wszCDPDN) + 
					wcslen (CDP_PROPERTY_EXT) + 1];
		if ( pvPara )
		{
			wcscpy (pvPara, wszCDPDN);
			wcscat (pvPara, CDP_PROPERTY_EXT);

			hStore = ::CertOpenStore ("LDAP",
				X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, NULL,
				0,
				(void*) pvPara);
			if ( !hStore )
			{
				hResult = E_FAIL;
                goto error;
			}
		}
	}

    if (NULL != hStore)
    {
    *ppCRL = CertFindCRLInStore(hStore, 
                              X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
                              0,
                              CRL_FIND_ANY,
                              NULL,
                              NULL);
    }

error:
    if(hStore)
    {
        CertCloseStore(hStore, 0);
    }

    if(pvPara)
    {
        LocalFree(pvPara);
    }
    return hResult;
}

STDMETHODIMP CCAShellExt::_LaunchCRLDialog(PCCRL_CONTEXT pCRL)
{

        CRYPTUI_VIEWCRL_STRUCT  vcs;
        HWND                    hwndParent = NULL;
        HRESULT                 hr = S_OK;

        ::ZeroMemory (&vcs, sizeof (vcs));
        vcs.dwSize = sizeof (vcs);
        vcs.hwndParent = hwndParent;
        vcs.dwFlags = 0;
        vcs.pCRLContext = pCRL;

        if(!::CryptUIDlgViewCRL (&vcs))
        {
            hr = GetLastError();
            hr = HRESULT_FROM_WIN32(hr);
        }

        return hr;
}

HRESULT CCAShellExt::_OnExportCRL (PCCRL_CONTEXT pCRL)
{
	AFX_MANAGE_STATE (AfxGetStaticModuleState ());
	HRESULT	hr = S_OK;


	CRYPTUI_WIZ_EXPORT_INFO	cwi;
	HWND	hwndParent = 0;

	::ZeroMemory (&cwi, sizeof (cwi));
	cwi.dwSize = sizeof (cwi);

	cwi.dwSubjectChoice = CRYPTUI_WIZ_EXPORT_CRL_CONTEXT;
	ASSERT (pCRL);
	if ( pCRL )
		cwi.pCRLContext = pCRL;
	else
		return E_UNEXPECTED;

	if(!::CryptUIWizExport (
			0,
			hwndParent,
			0,
			&cwi,
			NULL))
    {
	hr = GetLastError();
	hr = HRESULT_FROM_WIN32(hr);
    }

	return hr;
}

STDMETHODIMP CCAShellExt::QueryContextMenu
(
    HMENU hmenu,
    UINT indexMenu,
    UINT idCmdFirst,
    UINT idCmdLast,
    UINT uFlags
)
{
    LPWSTR        wszClassType = NULL;
    if(m_Names->cItems != 1)
    {
        // Don't add the properties page if we have no or many objects selected
        return S_OK;
    }

    if(m_Names->aObjects[0].offsetName == 0)
    {
        return E_UNEXPECTED;
    }
    if(m_Names->aObjects[0].offsetClass)
    {
        wszClassType = (LPWSTR)ByteOffset(m_Names, m_Names->aObjects[0].offsetClass);
    }

    if(wszClassType == NULL)
    {
        return S_OK;
    }

    if(((m_Names->aObjects[0].dwProviderFlags & DSPROVIDER_ADVANCED) != 0) &&
        (_wcsicmp(wszClassType, L"pKIEnrollmentService") == 0))
    {
        // Add a "manage" option
        CString szEdit;
        MENUITEMINFO mii;
        UINT idLastUsedCmd = idCmdFirst;
        AFX_MANAGE_STATE(AfxGetStaticModuleState());


        ZeroMemory(&mii, sizeof(mii));


        mii.cbSize = sizeof(mii);   
        mii.fMask = MIIM_TYPE | MIIM_ID;
        mii.fType = MFT_STRING;    
        mii.wID = idLastUsedCmd; 

        szEdit.LoadString(IDS_MANAGE);

        mii.dwTypeData = (LPTSTR)(LPCTSTR)szEdit;
        mii.cch = szEdit.GetLength();

        m_idManage = indexMenu;

        // Add new menu items to the context menu.    //
        ::InsertMenuItem(hmenu, 
                     indexMenu++, 
                     TRUE,
                     &mii);

        idLastUsedCmd++;

        return ResultFromScode (MAKE_SCODE (SEVERITY_SUCCESS, 0,
                                USHORT (idLastUsedCmd )));


    }
    else if(((m_Names->aObjects[0].dwProviderFlags & DSPROVIDER_ADVANCED) != 0) &&
            (_wcsicmp(wszClassType, L"cRLDistributionPoint") == 0))
    {
        // Add a "manage" option
        CString szName;
        MENUITEMINFO mii;
        UINT idLastUsedCmd = idCmdFirst;
        AFX_MANAGE_STATE(AfxGetStaticModuleState());


        ZeroMemory(&mii, sizeof(mii));


        mii.cbSize = sizeof(mii);   
        mii.fMask = MIIM_TYPE | MIIM_ID;
        mii.fType = MFT_STRING;    
        mii.wID = idLastUsedCmd; 

        szName.LoadString(IDS_OPEN);

        mii.dwTypeData = (LPTSTR)(LPCTSTR)szName;
        mii.cch = szName.GetLength();

        m_idOpen = indexMenu;
        // Add new menu items to the context menu.    //
        ::InsertMenuItem(hmenu, 
                     indexMenu++, 
                     TRUE,
                     &mii);
         idLastUsedCmd++;



        ZeroMemory(&mii, sizeof(mii));


        mii.cbSize = sizeof(mii);   
        mii.fMask = MIIM_TYPE | MIIM_ID;
        mii.fType = MFT_STRING;    
        mii.wID = idLastUsedCmd; 

        szName.LoadString(IDS_EXPORT);

        mii.dwTypeData = (LPTSTR)(LPCTSTR)szName;
        mii.cch = szName.GetLength();

        m_idExport = indexMenu;
        // Add new menu items to the context menu.    //
        ::InsertMenuItem(hmenu, 
                     indexMenu++, 
                     TRUE,
                     &mii);
        idLastUsedCmd++;



        return ResultFromScode (MAKE_SCODE (SEVERITY_SUCCESS, 0,
                                USHORT (idLastUsedCmd)));


    }

    return S_OK;
}