windows-xp/Source/XPSP1/NT/ds/security/cryptoapi/ui/wizards/mgrcert.cpp

//-------------------------------------------------------------
//  Copyright (C) Microsoft Corporation, 1996 - 1999
//
//  File:       mgrcert.cpp
//
//  Contents:   The cpp file to implement cert mgr dialogue
//
//  History:    Feb-26-98 xiaohs   created
//
//--------------------------------------------------------------
#include    "wzrdpvk.h"
#include    "winuser.h"     //need this file for VK_DELETE
#include    "mgrcert.h"

//context sensitive help for the main dialogue
static const HELPMAP CertMgrMainHelpMap[] = {
    {IDC_CERTMGR_LIST,              IDH_CERTMGR_LIST},
    {IDC_CERTMGR_PURPOSE_COMBO,     IDH_CERTMGR_PURPOSE_COMBO},
    {IDC_CERTMGR_IMPORT,            IDH_CERTMGR_IMPORT},
    {IDC_CERTMGR_EXPORT,            IDH_CERTMGR_EXPORT},
    {IDC_CERTMGR_VIEW,              IDH_CERTMGR_VIEW},
    {IDC_CERTMGR_REMOVE,            IDH_CERTMGR_REMOVE},
    {IDC_CERTMGR_ADVANCE,           IDH_CERTMGR_ADVANCE},
    {IDC_CERTMGR_PURPOSE,           IDH_CERTMGR_FIELD_PURPOSE},
};

//context sensitive help for the main dialogue
static const HELPMAP CertMgrAdvHelpMap[] = {
    {IDC_CERTMGR_ADV_LIST,              IDH_CERTMGR_ADV_LIST},
    {IDC_CERTMGR_EXPORT_COMBO,          IDH_CERTMGR_EXPORT_COMBO},
    {IDC_CERTMGR_EXPORT_CHECK,          IDH_CERTMGR_EXPORT_CHECK},
};

// Primary store associated with each tab. Store to be imported into.
static const LPCWSTR rgpwszTabStoreName[] = {
    L"My",                  // 0
    L"AddressBook",         // 1
    L"Ca",                  // 2
    L"Root",                // 3
    L"TrustedPublisher",    // 4
};
#define TAB_STORE_NAME_CNT (sizeof(rgpwszTabStoreName) / \
                                sizeof(rgpwszTabStoreName[0]))

/*
// The following code is obsolete due to new cert chain building code
//----------------------------------------------------------------------------
// AddCertChainToStore
//----------------------------------------------------------------------------
BOOL    AddCertChainToStore(HCERTSTORE          hStore,
                            PCCERT_CONTEXT      pCertContext)
{
    BOOL            fResult=FALSE;
    HCERTSTORE      rghCertStores[20];
    DWORD           chStores;
    PCCERT_CONTEXT  pChildCert;
    PCCERT_CONTEXT  pParentCert;
    FILETIME        fileTime;
    DWORD           i;

    if(!hStore || !pCertContext)
        goto InvalidArgErr;


    GetSystemTimeAsFileTime(&fileTime);

    if (!TrustOpenStores(NULL, &chStores, rghCertStores, 0))
        goto TraceErr;


    pChildCert = pCertContext;
    while (NULL != (pParentCert = TrustFindIssuerCertificate(
                                        pChildCert,
                                        pChildCert->dwCertEncodingType,
                                        chStores,
                                        rghCertStores,
                                        &fileTime,
                                        NULL,
                                        NULL,
                                        0)))
    {
        CertAddCertificateContextToStore(hStore, pParentCert, CERT_STORE_ADD_NEW, NULL);

        if (pChildCert != pCertContext)
        {
            CertFreeCertificateContext(pChildCert);
        }

        pChildCert = pParentCert;
    }

    if (pChildCert != pCertContext)
    {
        CertFreeCertificateContext(pChildCert);
    }

    for (i=0; i<chStores; i++)
    {
        CertCloseStore(rghCertStores[i], 0);
    }

    fResult=TRUE;

CommonReturn:

    return fResult;

ErrorReturn:

	fResult=FALSE;
	goto CommonReturn;

SET_ERROR(InvalidArgErr, E_INVALIDARG);
TRACE_ERROR(TraceErr);
}   */



int WINAPI TabCtrl_InsertItemU(
    HWND            hwnd, 	
    int             iItem,
    const LPTCITEMW pitem		
    )
{
    TCITEMA TCItemA;
    int     iRet;
    DWORD   cb = 0;


    if (FIsWinNT())
    {
        return ((int)SendMessage(hwnd, TCM_INSERTITEMW, iItem, (LPARAM) pitem));
    }

    memcpy(&TCItemA, pitem, sizeof(TCITEMA));


    cb = WideCharToMultiByte(
                    0,                      // codepage
                    0,                      // dwFlags
                    pitem->pszText,
                    -1,
                    NULL,
                    0,
                    NULL,
                    NULL);

    
    if ((0 == cb) || (NULL == (TCItemA.pszText = (LPSTR) WizardAlloc(cb)))) 
    {
        return -1;  // this is the unsuccessful return code for this call 
    }

    if( 0 == (WideCharToMultiByte(
            0, 
            0, 
            pitem->pszText, 
            -1, 
            TCItemA.pszText,
            cb,
            NULL,
            NULL)))
    {
        WizardFree(TCItemA.pszText);
        return -1;
    }

    iRet = (int)SendMessage(hwnd, TCM_INSERTITEMA, iItem, (LPARAM) &TCItemA);

    WizardFree(TCItemA.pszText);

    return iRet;
}


//----------------------------------------------------------------------------
// This is the rundll32 entry point for start menu, administartive tools,
// CertMgr.
//----------------------------------------------------------------------------
STDAPI CryptUIStartCertMgr(HINSTANCE hinst, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow)
{

    CRYPTUI_CERT_MGR_STRUCT          CertMgrStruct;

    memset(&CertMgrStruct, 0, sizeof(CRYPTUI_CERT_MGR_STRUCT));
    CertMgrStruct.dwSize=sizeof(CRYPTUI_CERT_MGR_STRUCT);

    CryptUIDlgCertMgr(&CertMgrStruct);

    return S_OK;

}

//----------------------------------------------------------------------------
// GetFileContentFromCert
//----------------------------------------------------------------------------
BOOL    GetFileContentFromCert(DWORD            dwExportFormat,
                               BOOL             fExportChain,
                               PCCERT_CONTEXT   pCertContext,
                               BYTE             **ppBlob,
                               DWORD            *pdwSize)
{
    BOOL            fResult=FALSE;
    void            *pData=NULL;
    DWORD           dwSize=0;
    HCERTSTORE      hMemoryStore=NULL;
    CRYPT_DATA_BLOB Blob;
    HRESULT         hr=E_INVALIDARG;


    if(!ppBlob || !pdwSize || !pCertContext)
        goto InvalidArgErr;

    *ppBlob=NULL;
    *pdwSize=0;

    switch(dwExportFormat)
    {
        case    CRYPTUI_WIZ_EXPORT_FORMAT_DER:

                dwSize=pCertContext->cbCertEncoded;

                pData=WizardAlloc(dwSize);
                if(!pData)
                    goto MemoryErr;

                memcpy(pData, pCertContext->pbCertEncoded, dwSize);

            break;
        case    CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
                //base 64 encode the BLOB
                if(!CryptBinaryToStringA(
                        pCertContext->pbCertEncoded,
                        pCertContext->cbCertEncoded,
                        CRYPT_STRING_BASE64,
                        NULL,
                        &dwSize))
                {
                    hr = GetLastError();
                    goto SetErrVar;
                }

                pData=WizardAlloc(dwSize * sizeof(CHAR));
                if(!pData)
                    goto MemoryErr;

                if(!CryptBinaryToStringA(
                        pCertContext->pbCertEncoded,
                        pCertContext->cbCertEncoded,
                        CRYPT_STRING_BASE64,
                        (char *)pData,
                        &dwSize))
                {
                    hr = GetLastError();
                    goto SetErrVar;
                }


            break;
        case    CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:

                //open a memory store
                hMemoryStore=CertOpenStore(
                    CERT_STORE_PROV_MEMORY,
					g_dwMsgAndCertEncodingType,
					NULL,
					0,
					NULL);

                if(!hMemoryStore)
                    goto TraceErr;

                if(FALSE == fExportChain)
                {
                    if(!CertAddCertificateContextToStore(
                        hMemoryStore,
                        pCertContext,
                        CERT_STORE_ADD_REPLACE_EXISTING,
                        NULL))
                        goto TraceErr;
                }
                else
                {
                    if(!AddChainToStore(
					    hMemoryStore,
					    pCertContext,
					    0,
					    NULL,
					    FALSE,
					    NULL))
                        goto TraceErr;
                }


                //save the store to a PKCS#7
                Blob.cbData=0;
                Blob.pbData=NULL;

                if(!CertSaveStore(hMemoryStore,
                                 g_dwMsgAndCertEncodingType,
                                 CERT_STORE_SAVE_AS_PKCS7,
                                 CERT_STORE_SAVE_TO_MEMORY,
                                 &Blob,
                                 0))
                       goto TraceErr;

                dwSize=Blob.cbData;
                pData=WizardAlloc(dwSize);
                if(!pData)
                    goto MemoryErr;

                Blob.pbData=(BYTE *)pData;

                if(!CertSaveStore(hMemoryStore,
                                 g_dwMsgAndCertEncodingType,
                                 CERT_STORE_SAVE_AS_PKCS7,
                                 CERT_STORE_SAVE_TO_MEMORY,
                                 &Blob,
                                 0))
                       goto TraceErr;

            break;
        default:
                goto InvalidArgErr;
            break;
    }


    //set up the return value
    *pdwSize=dwSize;
    *ppBlob=(BYTE *)pData;
    pData=NULL;

    fResult=TRUE;

CommonReturn:

    if(hMemoryStore)
        CertCloseStore(hMemoryStore, 0);

     return fResult;

ErrorReturn:

    if(pData)
        WizardFree(pData);

	fResult=FALSE;
	goto CommonReturn;

SET_ERROR(InvalidArgErr, E_INVALIDARG);
SET_ERROR(MemoryErr, E_OUTOFMEMORY);
SET_ERROR_VAR(SetErrVar, hr);
TRACE_ERROR(TraceErr);

}

//----------------------------------------------------------------------------
//  FreeFileNameAndContent
//----------------------------------------------------------------------------
BOOL    FreeFileNameAndContent( DWORD           dwCount,
                                LPWSTR          *prgwszFileName,
                                BYTE            **prgBlob,
                                DWORD           *prgdwSize)
{
    DWORD   dwIndex=0;

    if(prgwszFileName)
    {
        for(dwIndex=0; dwIndex < dwCount; dwIndex++)
        {
            if(prgwszFileName[dwIndex])
                WizardFree(prgwszFileName[dwIndex]);
        }

        WizardFree(prgwszFileName);
    }

    if(prgBlob)
    {
        for(dwIndex=0; dwIndex < dwCount; dwIndex++)
        {
            if(prgBlob[dwIndex])
                WizardFree(prgBlob[dwIndex]);
        }

        WizardFree(prgBlob);
    }

    if(prgdwSize)
        WizardFree(prgdwSize);

    return TRUE;
}


//----------------------------------------------------------------------------
// Get a valid friendly name of the certificate
//----------------------------------------------------------------------------
BOOL    GetValidFriendlyName(PCCERT_CONTEXT  pCertContext,
                        LPWSTR           *ppwszName)
{
    BOOL    fResult=FALSE;
    DWORD   dwChar=0;
    LPWSTR  pwsz=NULL;
    DWORD   dwIndex=0;


    if(!pCertContext || !ppwszName)
        return FALSE;

    //init
    *ppwszName=NULL;

    dwChar=0;

    if(CertGetCertificateContextProperty(
        pCertContext,
        CERT_FRIENDLY_NAME_PROP_ID,
        NULL,
        &dwChar) && (0!=dwChar))
    {
        pwsz=(LPWSTR)WizardAlloc(dwChar * sizeof(WCHAR));

        if(pwsz)
        {
           CertGetCertificateContextProperty(
                pCertContext,
                CERT_FRIENDLY_NAME_PROP_ID,
                pwsz,
                &dwChar);
        }
    }

    if(NULL==pwsz)
        goto CLEANUP;


    //make sure pwsz is a valid name
    if(0 == (dwChar=wcslen(pwsz)))
        goto CLEANUP;

    //the friendly name can not be spaces all the time
    for(dwIndex=0; dwIndex<dwChar; dwIndex++)
    {
        if(L' '!=pwsz[dwIndex])
            break;
    }

    if(dwIndex==dwChar)
        goto CLEANUP;   

    *ppwszName=WizardAllocAndCopyWStr(pwsz);

    if(NULL == (*ppwszName))
        goto CLEANUP;

    fResult=TRUE;

CLEANUP:

    if(pwsz)
        WizardFree(pwsz);

    return fResult;
}

//----------------------------------------------------------------------------
//  InvalidFileNameWch
//----------------------------------------------------------------------------
BOOL	InvalidFileNameWch(WCHAR wChar)
{
	if((wChar == L'\\') || (wChar == L':') || (wChar == L'/') || (wChar == L'*') || (wChar == L'|') || (wChar == L';'))
		return TRUE;

	return FALSE;
}

//----------------------------------------------------------------------------
//  Build the filenames and their content based on the export selection
//----------------------------------------------------------------------------
BOOL    GetFileNameFromCert(DWORD               dwExportFormat,
                            PCCERT_CONTEXT      pCertContext,
                            LPWSTR              pwszFileName)
{
    BOOL            fResult=FALSE;
    WCHAR           wszCertificate[MAX_TITLE_LENGTH];
    WCHAR           wszExt[MAX_TITLE_LENGTH];
    LPWSTR          pwszName=NULL;
    DWORD           dwChar=0;
    UINT            idsExt=0;
    LPWSTR          pwszFirstPart=NULL;
    LPWSTR          pwszFriendlyName=NULL;
	DWORD			dwIndex=0;

    if(!pCertContext || !pwszFileName)
        goto InvalidArgErr;

    //init
    *pwszFileName='\0';


    //get the friendly name for the certificate
    if(!GetValidFriendlyName(pCertContext,&pwszFriendlyName))
    {
        //if failed, we use subject
        //Subject
        dwChar=CertGetNameStringW(
            pCertContext,
            CERT_NAME_SIMPLE_DISPLAY_TYPE,
            0,
            NULL,
            NULL,
            0);

        if ((dwChar > 1) && (NULL != (pwszName = (LPWSTR)WizardAlloc(dwChar * sizeof(WCHAR)))))
        {

            if(!CertGetNameStringW(
                pCertContext,
                CERT_NAME_SIMPLE_DISPLAY_TYPE,
                0,
                NULL,
                pwszName,
                dwChar))
                goto GetNameErr;

            pwszFirstPart=pwszName;
        }
        else
        {
            //load the string for Certificate
            if(!LoadStringU(g_hmodThisDll, IDS_CERTIFICATE, wszCertificate, MAX_TITLE_LENGTH))
                goto LoadStringErr;

            pwszFirstPart=wszCertificate;
        }
    }
    else
        pwszFirstPart=pwszFriendlyName;

    //determine the extension for the file
    switch(dwExportFormat)
    {
        case    CRYPTUI_WIZ_EXPORT_FORMAT_DER:
                idsExt=IDS_CER;
            break;
        case    CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
                idsExt=IDS_CER;
            break;
        case    CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
                idsExt=IDS_P7C;
            break;
        default:
                idsExt=IDS_CER;
            break;
    }

    //load the string for Certificate
    if(!LoadStringU(g_hmodThisDll, idsExt, wszExt, MAX_TITLE_LENGTH))
            goto LoadStringErr;

    //determine the max length of the file name
    dwChar = wcslen(pwszFirstPart) > (CERTMGR_MAX_FILE_NAME - wcslen(wszExt) -1) ?
            (CERTMGR_MAX_FILE_NAME - wcslen(wszExt) -1) : wcslen(pwszFirstPart);

    wcsncpy(pwszFileName, pwszFirstPart, dwChar);

    *(pwszFileName + dwChar)=L'\0';
                              
    wcscat(pwszFileName, wszExt);

	//now, we replace the invalid file characters : ; /  \
	//with space

	dwChar = wcslen(pwszFileName);

	for(dwIndex =0; dwIndex<dwChar; dwIndex++)
	{
		if(InvalidFileNameWch(pwszFileName[dwIndex]))
			pwszFileName[dwIndex]=L'_';
	}

    fResult=TRUE;

CommonReturn:

    if(pwszName)
        WizardFree(pwszName);

    if(pwszFriendlyName)
        WizardFree(pwszFriendlyName);

    return fResult;

ErrorReturn:

	fResult=FALSE;
	goto CommonReturn;

SET_ERROR(InvalidArgErr, E_INVALIDARG);
TRACE_ERROR(GetNameErr);
TRACE_ERROR(LoadStringErr);
}


//----------------------------------------------------------------------------
//  Build the filenames and their content based on the export selection
//----------------------------------------------------------------------------
BOOL    GetFileNameAndContent(LPNMLISTVIEW      pvmn,
                                HWND            hwndControl,
                                DWORD           dwExportFormat,
                                BOOL            fExportChain,
                                DWORD           *pdwCount,
                                LPWSTR          **pprgwszFileName,
                                BYTE            ***pprgBlob,
                                DWORD           **pprgdwSize)
{

    BOOL            fResult=FALSE;
    DWORD           dwCount=0;
    DWORD           dwIndex=0;
    LVITEM          lvItem;
    int             iIndex=0;
    PCCERT_CONTEXT  pCertContext=NULL;

    if(!pvmn || !hwndControl || !pdwCount || !pprgwszFileName || !pprgBlob || !pprgdwSize)
        goto InvalidArgErr;

    //init
    *pdwCount=0;
    *pprgwszFileName=NULL;
    *pprgBlob=NULL;
    *pprgdwSize=NULL;

    //get the count of selected certificates
    dwCount=ListView_GetSelectedCount(hwndControl);

    if( 0 == dwCount)
        goto InvalidArgErr;

    //allocate memory
    if((*pprgwszFileName)=(LPWSTR *)WizardAlloc(sizeof(LPWSTR) * dwCount))
        memset(*pprgwszFileName, 0,  sizeof(LPWSTR) * dwCount);

    if((*pprgBlob)=(BYTE **)WizardAlloc(sizeof(BYTE *)*  dwCount))
        memset(*pprgBlob, 0,        sizeof(BYTE *)* dwCount);

    if((*pprgdwSize)=(DWORD *)WizardAlloc(sizeof(DWORD) * dwCount))
        memset(*pprgdwSize, 0,      sizeof(DWORD) * dwCount);

    if(!(*pprgwszFileName) || !(*pprgBlob) || !(*pprgdwSize))
        goto MemoryErr;

    //get the selected certificate
    memset(&lvItem, 0, sizeof(LV_ITEM));
    lvItem.mask=LVIF_PARAM;

    iIndex=-1;

    for(dwIndex=0; dwIndex < dwCount; dwIndex++)
    {

        iIndex=ListView_GetNextItem(hwndControl, 		
                                        iIndex, 		
                                        LVNI_SELECTED);

        if(-1 == iIndex)
            break;

        lvItem.iItem=iIndex;

        if(!ListView_GetItem(hwndControl,
                         &lvItem))
            goto ListViewErr;

        pCertContext=(PCCERT_CONTEXT)(lvItem.lParam);

        if(!pCertContext)
            goto InvalidArgErr;

        //get the file name of the ceritificate
        (*pprgwszFileName)[dwIndex]=(LPWSTR)WizardAlloc(sizeof(WCHAR) * CERTMGR_MAX_FILE_NAME);

        if(!((*pprgwszFileName)[dwIndex]))
            goto MemoryErr;

        if(!GetFileNameFromCert(dwExportFormat,
                                pCertContext,
                                (*pprgwszFileName)[dwIndex]))
            goto TraceErr;


        //get the BLOB for the certificate
        if(!GetFileContentFromCert(dwExportFormat, fExportChain, pCertContext,
                                &((*pprgBlob)[dwIndex]),
                                &((*pprgdwSize)[dwIndex])))
            goto TraceErr;

    }

    *pdwCount=dwIndex;

    fResult=TRUE;

CommonReturn:


    return fResult;

ErrorReturn:

    if(pdwCount && pprgwszFileName && pprgBlob && pprgdwSize)
    {
        FreeFileNameAndContent(*pdwCount, *pprgwszFileName, *pprgBlob, *pprgdwSize);
        *pdwCount=0;
        *pprgwszFileName=NULL;
        *pprgBlob=NULL;
        *pprgdwSize=NULL;
    }

	fResult=FALSE;
	goto CommonReturn;

SET_ERROR(InvalidArgErr, E_INVALIDARG);
SET_ERROR(MemoryErr, E_OUTOFMEMORY);
TRACE_ERROR(ListViewErr);
TRACE_ERROR(TraceErr);
}


//----------------------------------------------------------------------------
//  Get all the selected certificates and do some work vased on dwFlag
//----------------------------------------------------------------------------
BOOL    GetAllSelectedItem(HWND         hWndControl,
                           DWORD        dwFlag,
                           void         *pData)
{
    BOOL            fResult=FALSE;
    BOOL            fCanDelete=TRUE;
    HCERTSTORE      *phCertStore=NULL;
    PCCERT_CONTEXT  pCertContext=NULL;
    int             iIndex=0;
    LVITEM          lvItem;
    DWORD           dwData=0;
    DWORD           dwAccessFlag=0;

    if(!hWndControl)
        goto CLEANUP;

    if((ALL_SELECTED_CAN_DELETE == dwFlag) ||
       (ALL_SELECTED_COPY == dwFlag))
    {
        if(NULL == pData)
            goto CLEANUP;
    }

    //get the selected certificate
    memset(&lvItem, 0, sizeof(LV_ITEM));
    lvItem.mask=LVIF_PARAM;


    iIndex=-1;

    //loop through all the selected items
    while(-1 != (iIndex=ListView_GetNextItem(
                                        hWndControl, 		
                                        iIndex, 		
                                        LVNI_SELECTED		
                                        )))
    {
        lvItem.iItem=iIndex;

        if(!ListView_GetItem(hWndControl,
                         &lvItem))
            goto CLEANUP;

        pCertContext=(PCCERT_CONTEXT)(lvItem.lParam);

        if(!pCertContext)
            goto CLEANUP;

        switch(dwFlag)
        {
            case ALL_SELECTED_CAN_DELETE:
                    dwData=sizeof(dwAccessFlag);

                    //as far as one of the selected items can not be deleted,
                    //the whole selection can not be deleted
                    if( CertGetCertificateContextProperty(
                        pCertContext,
                        CERT_ACCESS_STATE_PROP_ID,
                        &dwAccessFlag,
                        &dwData))
                    {
                        if(0==(CERT_ACCESS_STATE_WRITE_PERSIST_FLAG & dwAccessFlag))
                            fCanDelete=FALSE;
                    }

                break;
            case ALL_SELECTED_DELETE:
                    CertDeleteCertificateFromStore(
                        CertDuplicateCertificateContext(pCertContext));
                break;
            case ALL_SELECTED_COPY:
                    CertAddCertificateContextToStore(
                        *((HCERTSTORE *)pData),
                        pCertContext,
                        CERT_STORE_ADD_ALWAYS,
                        NULL);
                break;
            default:
                    goto CLEANUP;
                break;
        }
    }

    //copy the can delete flag
     if(ALL_SELECTED_CAN_DELETE == dwFlag)
        *((BOOL *)pData)=fCanDelete;


     fResult=TRUE;

CLEANUP:


    return fResult;
}


//----------------------------------------------------------------------------
//  Check to see if <advanced> is selected
//----------------------------------------------------------------------------
BOOL    IsAdvancedSelected(HWND    hwndDlg)
{
    BOOL        fSelected=FALSE;
    int         iIndex=0;
    LPWSTR      pwszOIDName=NULL;
    WCHAR       wszText[MAX_STRING_SIZE];

    if(!hwndDlg)
        goto CLEANUP;

    //get the selected string from the combo box
    iIndex=(int)SendDlgItemMessage(hwndDlg, IDC_CERTMGR_PURPOSE_COMBO,
            CB_GETCURSEL, 0, 0);

    if(CB_ERR==iIndex)
        goto CLEANUP;

    //get the selected purpose name
    if(CB_ERR == SendDlgItemMessageU_GETLBTEXT(hwndDlg,
                IDC_CERTMGR_PURPOSE_COMBO,
              iIndex, &pwszOIDName))
        goto CLEANUP;

    //check to see if <advanced> is selected
    if(!LoadStringU(g_hmodThisDll, IDS_OID_ADVANCED,
                    wszText, MAX_STRING_SIZE))
        goto CLEANUP;

    //check if advanced option is selected
    if(0 == _wcsicmp(pwszOIDName, wszText))
        fSelected=TRUE;

CLEANUP:

    if(pwszOIDName)
        WizardFree(pwszOIDName);

    return fSelected;
}

//----------------------------------------------------------------------------
//  Update the window title based on the tab that user has selected
//----------------------------------------------------------------------------
BOOL    RefreshWindowTitle(HWND                         hwndDlg,
                           PCRYPTUI_CERT_MGR_STRUCT     pCertMgrStruct)
{
    BOOL    fResult=FALSE;
    WCHAR   wszTitle[MAX_TITLE_LENGTH];
    WCHAR   wszText[MAX_TITLE_LENGTH];
    LPWSTR  pwszTitle=NULL;
    LPWSTR  pwszText=NULL;
    UINT    ids=0;
    DWORD   dwTabIndex=0;

    if(!hwndDlg || !pCertMgrStruct)
        goto CLEANUP;

    //get the string ids based on the tab selected
    if (pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG)
        dwTabIndex = pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_TAB_MASK;
    else if(-1 == (dwTabIndex=TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_CERTMGR_TAB))))
        goto CLEANUP;

    //open the correct store based on the tab selected
    switch (dwTabIndex)
    {
        case 0:
                ids=IDS_TAB_PERSONAL;
            break;
        case 1:
                ids=IDS_TAB_OTHER;
            break;
        case 2:
                ids=IDS_TAB_CA;
            break;
        case 3:
                ids=IDS_TAB_ROOT;
            break;
        case 4:
                ids=IDS_TAB_PUBLISHER;
            break;
        default:
                goto CLEANUP;
            break;
    }

    //load the string for tabs
    if(!LoadStringU(g_hmodThisDll, ids, wszText, MAX_TITLE_LENGTH))
        goto CLEANUP;

    //get the window string
    if(pCertMgrStruct->pwszTitle)
        pwszTitle=(LPWSTR)(pCertMgrStruct->pwszTitle);
    else
    {
        if(!LoadStringU(g_hmodThisDll, IDS_CERT_MGR_TITLE, wszTitle, MAX_TITLE_LENGTH))
            goto CLEANUP;

        pwszTitle=wszTitle;
    }

    pwszText=(LPWSTR)WizardAlloc(sizeof(WCHAR) * (
        wcslen(pwszTitle) + wcslen(wszText) + wcslen(L" - ") +1));

    if(!pwszText)
        goto CLEANUP;

    //concatenate the window title as: "Certifiate Manager - Personal"
    *pwszText=L'\0';

    wcscat(pwszText, pwszTitle);

    wcscat(pwszText, L" - ");

    wcscat(pwszText, wszText);

    //set the window text
    SetWindowTextU(hwndDlg, pwszText);

    fResult=TRUE;


CLEANUP:

    if(pwszText)
        WizardFree(pwszText);

    return fResult;
}

//----------------------------------------------------------------------------
//  Check to see if the certificate's key usage is the same as
//  the one selected on the combo box
//
//----------------------------------------------------------------------------
BOOL    IsValidUsage(PCCERT_CONTEXT     pCertContext,
                     HWND               hwndDlg,
                     CERT_MGR_INFO      *pCertMgrInfo)
{
    BOOL        fValidUsage=FALSE;
    int         iIndex=0;
    LPWSTR      pwszOIDName=NULL;
    LPSTR       pszOID=NULL;
    WCHAR       wszText[MAX_STRING_SIZE];
    BOOL        fAdvanced=FALSE;
    DWORD       dwIndex=0;
    DWORD       dwAdvIndex=0;
    int         cNumOID=0;
    LPSTR       *rgOID=NULL;
    DWORD       cbOID=0;

    //input check
    if(!pCertContext || !hwndDlg || !pCertMgrInfo)
        return FALSE;

    //get the selected string from the combo box
    iIndex=(int)SendDlgItemMessage(hwndDlg, IDC_CERTMGR_PURPOSE_COMBO,
            CB_GETCURSEL, 0, 0);

    if(CB_ERR==iIndex)
        goto CLEANUP;

    //get the selected purpose name
    if(CB_ERR == SendDlgItemMessageU_GETLBTEXT(hwndDlg,
                IDC_CERTMGR_PURPOSE_COMBO,
              iIndex, &pwszOIDName))
        goto CLEANUP;

    //check to see if <all> is selected
    if(!LoadStringU(g_hmodThisDll, IDS_OID_ALL,
                    wszText, MAX_STRING_SIZE))
        goto CLEANUP;

    if(0 == _wcsicmp(pwszOIDName, wszText))
    {
        fValidUsage=TRUE;
        goto CLEANUP;
    }

    //check to see if <advanced> is selected
    if(!LoadStringU(g_hmodThisDll, IDS_OID_ADVANCED,
                    wszText, MAX_STRING_SIZE))
        goto CLEANUP;

    //check if advanced option is selected
    if(0 == _wcsicmp(pwszOIDName, wszText))
        fAdvanced=TRUE;


    if(FALSE==fAdvanced)
    {
        //determin the OID for the selected usage name
        for(dwIndex=0; dwIndex<pCertMgrInfo->dwOIDInfo; dwIndex++)
        {
            if(0==_wcsicmp(pwszOIDName,
                (pCertMgrInfo->rgOIDInfo[dwIndex]).pwszName))
               pszOID=(pCertMgrInfo->rgOIDInfo[dwIndex]).pszOID;
        }

        //we are in trouble if we can not find the maching OID based on
        //the name selected
        if(NULL==pszOID)
            goto CLEANUP;
    }

    //get the certificate's list of usage OIDs
    //get the OIDs from the cert
    if(!CertGetValidUsages(
        1,
        &pCertContext,
        &cNumOID,
        NULL,
        &cbOID))
        goto CLEANUP;

    rgOID=(LPSTR *)WizardAlloc(cbOID);

    if(NULL==rgOID)
        goto CLEANUP;

    if(!CertGetValidUsages(
        1,
        &pCertContext,
        &cNumOID,
        rgOID,
        &cbOID))
        goto CLEANUP;

    //-1 means the certiifcate is good for everything
    if(-1==cNumOID)
    {
        fValidUsage=TRUE;
        goto CLEANUP;
    }

    //we need to decide if the certificate include the selected
    //usage
    if(FALSE==fAdvanced)
    {
        for(dwIndex=0; dwIndex<(DWORD)cNumOID; dwIndex++)
        {
            if(0==_stricmp(pszOID,
                           rgOID[dwIndex]))
            {
                fValidUsage=TRUE;
                goto CLEANUP;
            }
        }
    }
    else
    {
        //the certificates have to have advanced OIDs
        for(dwAdvIndex=0; dwAdvIndex<pCertMgrInfo->dwOIDInfo; dwAdvIndex++)
        {
            //only interested in the OIDs with advanced marked
            if(TRUE==(pCertMgrInfo->rgOIDInfo[dwAdvIndex]).fSelected)
            {
                for(dwIndex=0; dwIndex<(DWORD)cNumOID; dwIndex++)
                {
                    if(0==_stricmp((pCertMgrInfo->rgOIDInfo[dwAdvIndex]).pszOID,
                                   rgOID[dwIndex]))
                    {
                        fValidUsage=TRUE;
                        goto CLEANUP;
                    }
                }
            }
        }


    }

    //now, we have examed all the possibilities
    fValidUsage=FALSE;

CLEANUP:

    if(pwszOIDName)
        WizardFree(pwszOIDName);

    if(rgOID)
        WizardFree(rgOID);

    return fValidUsage;

}


//----------------------------------------------------------------------------
//  Check to see if the certificate is an end-entity cert
//
//----------------------------------------------------------------------------
BOOL    IsCertificateEndEntity(PCCERT_CONTEXT   pCertContext)
{
    PCERT_EXTENSION                     pCertExt=NULL;
    BOOL                                fEndEntity=FALSE;
    DWORD                               cbData=0;
    PCERT_BASIC_CONSTRAINTS_INFO        pBasicInfo=NULL;
    PCERT_BASIC_CONSTRAINTS2_INFO       pBasicInfo2=NULL;

    if(!pCertContext)
        return FALSE;

    //get the extension szOID_BASIC_CONSTRAINTS2
    pCertExt=CertFindExtension(
              szOID_BASIC_CONSTRAINTS2,
              pCertContext->pCertInfo->cExtension,
              pCertContext->pCertInfo->rgExtension);


    if(pCertExt)
    {
        //deocde the extension
        cbData=0;

        if(!CryptDecodeObject(
                X509_ASN_ENCODING,
                X509_BASIC_CONSTRAINTS2,
                pCertExt->Value.pbData,
                pCertExt->Value.cbData,
                0,
                NULL,
                &cbData))
            goto CLEANUP;

       pBasicInfo2=(PCERT_BASIC_CONSTRAINTS2_INFO)WizardAlloc(cbData);

       if(NULL==pBasicInfo2)
           goto CLEANUP;

        if(!CryptDecodeObject(
                X509_ASN_ENCODING,
                X509_BASIC_CONSTRAINTS2,
                pCertExt->Value.pbData,
                pCertExt->Value.cbData,
                0,
                pBasicInfo2,
                &cbData))
            goto CLEANUP;

        if(pBasicInfo2->fCA)
            fEndEntity=FALSE;
        else
            fEndEntity=TRUE;
    }
    else
    {
        //get the extension szOID_BASIC_CONSTRAINTS
        pCertExt=CertFindExtension(
                  szOID_BASIC_CONSTRAINTS,
                  pCertContext->pCertInfo->cExtension,
                  pCertContext->pCertInfo->rgExtension);

        if(pCertExt)
        {
            //deocde the extension
            cbData=0;

            if(!CryptDecodeObject(
                    X509_ASN_ENCODING,
                    X509_BASIC_CONSTRAINTS,
                    pCertExt->Value.pbData,
                    pCertExt->Value.cbData,
                    0,
                    NULL,
                    &cbData))
                goto CLEANUP;

           pBasicInfo=(PCERT_BASIC_CONSTRAINTS_INFO)WizardAlloc(cbData);

           if(NULL==pBasicInfo)
               goto CLEANUP;

            if(!CryptDecodeObject(
                    X509_ASN_ENCODING,
                    X509_BASIC_CONSTRAINTS,
                    pCertExt->Value.pbData,
                    pCertExt->Value.cbData,
                    0,
                    pBasicInfo,
                    &cbData))
                goto CLEANUP;

            if(0 == pBasicInfo->SubjectType.cbData)
            {
                fEndEntity=FALSE;
            }
            else
            {

                if(CERT_END_ENTITY_SUBJECT_FLAG & (pBasicInfo->SubjectType.pbData[0]))
                    fEndEntity=TRUE;
                else
                {
                    if(CERT_CA_SUBJECT_FLAG & (pBasicInfo->SubjectType.pbData[0]))
                      fEndEntity=FALSE;
                }
            }
        }
    }


CLEANUP:

    if(pBasicInfo)
        WizardFree(pBasicInfo);

    if(pBasicInfo2)
        WizardFree(pBasicInfo2);

    return fEndEntity;

}

//----------------------------------------------------------------------------
//  Add certificate to the pCertMgrInfo
//
//----------------------------------------------------------------------------
BOOL    AddCertToCertMgrInfo(PCCERT_CONTEXT        pCertContext,
                          CERT_MGR_INFO         *pCertMgrInfo)
{


    pCertMgrInfo->prgCertContext=(PCCERT_CONTEXT *)WizardRealloc(
        pCertMgrInfo->prgCertContext,
        sizeof(PCCERT_CONTEXT *)*(pCertMgrInfo->dwCertCount +1));

    if(NULL==pCertMgrInfo->prgCertContext)
    {
        pCertMgrInfo->dwCertCount=0;
        return FALSE;
    }


    pCertMgrInfo->prgCertContext[pCertMgrInfo->dwCertCount]=pCertContext;

    pCertMgrInfo->dwCertCount++;

    return TRUE;
}


//----------------------------------------------------------------------------
//  Once a certificate is selected, refresh the static windows that display
//  the details of the certificate
//
//----------------------------------------------------------------------------
BOOL    RefreshCertDetails(HWND              hwndDlg,
                           PCCERT_CONTEXT    pCertContext)
{
    BOOL            fResult=FALSE;
    DWORD           dwChar=0;
    WCHAR           wszNone[MAX_TITLE_LENGTH];

    LPWSTR          pwszName=NULL;

    if(!hwndDlg || !pCertContext)
        return FALSE;

    //load the string for NONE
    if(!LoadStringU(g_hmodThisDll, IDS_NONE, wszNone, MAX_TITLE_LENGTH))
        wszNone[0]=L'\0';

    //Subject
   /* dwChar=CertGetNameStringW(
        pCertContext,
        CERT_NAME_SIMPLE_DISPLAY_TYPE,
        0,
        NULL,
        NULL,
        0);

    if ((dwChar != 0) && (NULL != (pwszName = (LPWSTR)WizardAlloc(dwChar * sizeof(WCHAR)))))
    {

        CertGetNameStringW(
            pCertContext,
            CERT_NAME_SIMPLE_DISPLAY_TYPE,
            0,
            NULL,
            pwszName,
            dwChar);

        SetDlgItemTextU(hwndDlg, IDC_CERTMGR_SUBJECT, pwszName);

    }
    else
    {
        SetDlgItemTextU(hwndDlg, IDC_CERTMGR_SUBJECT, wszNone);
    }


    //WizardFree the memory
    if(pwszName)
    {
        WizardFree(pwszName);
        pwszName=NULL;
    }

    //Issuer
    dwChar=CertGetNameStringW(
        pCertContext,
        CERT_NAME_SIMPLE_DISPLAY_TYPE,
        CERT_NAME_ISSUER_FLAG,
        NULL,
        NULL,
        0);

    if ((dwChar != 0) && (NULL != (pwszName = (LPWSTR)WizardAlloc(dwChar * sizeof(WCHAR)))))
    {

        CertGetNameStringW(
            pCertContext,
            CERT_NAME_SIMPLE_DISPLAY_TYPE,
            CERT_NAME_ISSUER_FLAG,
            NULL,
            pwszName,
            dwChar);

        SetDlgItemTextU(hwndDlg, IDC_CERTMGR_ISSUER, pwszName);

    }
    else
        SetDlgItemTextU(hwndDlg, IDC_CERTMGR_ISSUER, wszNone);


    //free the memory
    if(pwszName)
    {
        WizardFree(pwszName);
        pwszName=NULL;
    }



    //Expiration
    if(WizardFormatDateString(&pwszName,pCertContext->pCertInfo->NotAfter, FALSE))
        SetDlgItemTextU(hwndDlg, IDC_CERTMGR_EXPIRE, pwszName);
    else
        SetDlgItemTextU(hwndDlg, IDC_CERTMGR_EXPIRE, wszNone);


    //free the memory
    if(pwszName)
    {
        WizardFree(pwszName);
        pwszName=NULL;
    }   */

    //purpose
    if(MyFormatEnhancedKeyUsageString(&pwszName,pCertContext, FALSE, FALSE))
        
    {
        SetDlgItemTextU(hwndDlg, IDC_CERTMGR_PURPOSE, pwszName);
    }
    


    //free the memory
    if(pwszName)
    {
        WizardFree(pwszName);
        pwszName=NULL;
    }

    //friendly name
  /*  dwChar=0;

    if(CertGetCertificateContextProperty(
        pCertContext,
        CERT_FRIENDLY_NAME_PROP_ID,
        NULL,
        &dwChar) && (0!=dwChar))
    {
        pwszName = (LPWSTR)WizardAlloc(dwChar * sizeof(WCHAR));

        if(pwszName)
        {
           CertGetCertificateContextProperty(
                pCertContext,
                CERT_FRIENDLY_NAME_PROP_ID,
                pwszName,
                &dwChar);

        SetDlgItemTextU(hwndDlg, IDC_CERTMGR_NAME, pwszName);
        }
        else
            SetDlgItemTextU(hwndDlg, IDC_CERTMGR_NAME, wszNone);
    }
    else
        SetDlgItemTextU(hwndDlg, IDC_CERTMGR_NAME, wszNone);


    //free the memory
    if(pwszName)
    {
        WizardFree(pwszName);
        pwszName=NULL;
    }   */


    return TRUE;
}



//----------------------------------------------------------------------------
//  Add certificate to the ListView
//
//----------------------------------------------------------------------------
BOOL    AddCertToListView(HWND              hwndControl,
                      PCCERT_CONTEXT    pCertContext,
                      int               iItem)
{
    BOOL            fResult=FALSE;
    LV_ITEMW        lvItem;
    DWORD           dwChar=0;
    WCHAR           wszNone[MAX_TITLE_LENGTH];

    LPWSTR          pwszName=NULL;

    if(!hwndControl || !pCertContext)
        return FALSE;

     // set up the fields in the list view item struct that don't change from item to item
    lvItem.mask = LVIF_TEXT | LVIF_STATE | LVIF_IMAGE |LVIF_PARAM ;
    lvItem.state = 0;
    lvItem.stateMask = 0;
    lvItem.iItem=iItem;
    lvItem.iSubItem=0;
    lvItem.iImage = 0;
    lvItem.lParam = (LPARAM)pCertContext;


    //load the string for NONE
    if(!LoadStringU(g_hmodThisDll, IDS_NONE, wszNone, MAX_TITLE_LENGTH))
        wszNone[0]=L'\0';

    //Subject
    if (NULL == (pwszName = GetDisplayNameString(pCertContext, 0)))
    {
        lvItem.pszText=wszNone;
        ListView_InsertItemU(hwndControl, &lvItem);
    }
    else
    {
        lvItem.pszText=pwszName;
        ListView_InsertItemU(hwndControl, &lvItem);
        free(pwszName);
        pwszName = NULL;
    }

    //Issuer
    lvItem.iSubItem++;

    if (NULL == (pwszName = GetDisplayNameString(pCertContext, CERT_NAME_ISSUER_FLAG)))
    {
        ListView_SetItemTextU(hwndControl, lvItem.iItem, lvItem.iSubItem, wszNone);
    }
    else
    {
        ListView_SetItemTextU(hwndControl, lvItem.iItem, lvItem.iSubItem, pwszName);
        free(pwszName);
        pwszName = NULL;
    }

    //Expiration
    lvItem.iSubItem++;

    if(WizardFormatDateString(&pwszName,pCertContext->pCertInfo->NotAfter, FALSE))
    {

       ListView_SetItemTextU(hwndControl, lvItem.iItem, lvItem.iSubItem,
                      pwszName);

    }
    else
        ListView_SetItemTextU(hwndControl, lvItem.iItem, lvItem.iSubItem,
                       wszNone);

    //free the memory
    if(pwszName)
    {
        WizardFree(pwszName);
        pwszName=NULL;
    }

    //purpose
    /*lvItem.iSubItem++;

    if(WizardFormatEnhancedKeyUsageString(&pwszName,pCertContext, FALSE, FALSE) &&
        L'\0' != *pwszName)
    {

       ListView_SetItemTextU(hwndControl, lvItem.iItem, lvItem.iSubItem,
                      pwszName);

    }
    else
        ListView_SetItemTextU(hwndControl, lvItem.iItem, lvItem.iSubItem,
                       wszNone);

    //free the memory
    if(pwszName)
    {
        WizardFree(pwszName);
        pwszName=NULL;
    }               */

    //friendly name
    lvItem.iSubItem++;

    dwChar=0;

    if(CertGetCertificateContextProperty(
        pCertContext,
        CERT_FRIENDLY_NAME_PROP_ID,
        NULL,
        &dwChar) && (0!=dwChar))
    {
        pwszName = (LPWSTR)WizardAlloc(dwChar * sizeof(WCHAR));

        if(pwszName)
        {
           CertGetCertificateContextProperty(
                pCertContext,
                CERT_FRIENDLY_NAME_PROP_ID,
                pwszName,
                &dwChar);

            ListView_SetItemTextU(hwndControl, lvItem.iItem, lvItem.iSubItem,
                      pwszName);
        }
        else
            ListView_SetItemTextU(hwndControl, lvItem.iItem, lvItem.iSubItem,
                       wszNone);
    }
    else
    {
        ListView_SetItemTextU(hwndControl, lvItem.iItem, lvItem.iSubItem,
                       wszNone);
    }

    //free the memory
    if(pwszName)
    {
        WizardFree(pwszName);
        pwszName=NULL;
    }


    return TRUE;
}


//-----------------------------------------------------------------------
// Based on the tab(store) and the intended purpose selected,
// find the correct certificates and refresh the list view
// Criteria:
//      Tab 0:  My Store with private key
//      Tab 1:  Ca Store's end-entity cert and the "ADDRESSBOOK" store
//      Tab 2:  Ca Store's CA certs
//      Tab 3:  Root store's self signed certs
//      Tab 4:  Trusted publisher certs
//-----------------------------------------------------------------------
void    RefreshCertListView(HWND            hwndDlg,
                            CERT_MGR_INFO   *pCertMgrInfo)
{
    HWND            hwndControl=NULL;
    DWORD           dwIndex=0;
    DWORD           dwTabIndex=0;
    HCERTSTORE      rghCertStore[]={NULL, NULL};
    DWORD           dwStoreCount=0;
    PCCERT_CONTEXT  pCurCertContext=NULL;
    PCCERT_CONTEXT  pPreCertContext=NULL;
    BOOL            fValidCert=FALSE;
    DWORD           cbData=0;
    DWORD           dwSortParam=0;
    PCCRYPTUI_CERT_MGR_STRUCT pCertMgrStruct = NULL;


    HCURSOR                 hPreCursor=NULL;
    HCURSOR                 hWinPreCursor=NULL;


    if(!hwndDlg || !pCertMgrInfo)
        return;

    pCertMgrStruct = pCertMgrInfo->pCertMgrStruct;
    if(!pCertMgrStruct)
        return;

    //overwrite the cursor for this window class
    hWinPreCursor=(HCURSOR)SetClassLongPtr(hwndDlg, GCLP_HCURSOR, NULL);

    hPreCursor=SetCursor(LoadCursor(NULL, IDC_WAIT));


    //free all the original certificates
    hwndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_LIST);

    if(!hwndControl)
        goto CLEANUP;

    FreeCerts(pCertMgrInfo);

    //deletel all the certs from the listView
    ListView_DeleteAllItems(hwndControl);

    //clear the ceritificate details group box
    SetDlgItemTextU(hwndDlg, IDC_CERTMGR_PURPOSE, L" ");


    //get the tab that is selected
    if (pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG)
        dwTabIndex = pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_TAB_MASK;
    else if(-1 == (dwTabIndex=TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_CERTMGR_TAB))))
        goto CLEANUP;

    //open the correct store based on the tab selected
    switch (dwTabIndex)
    {
        case 0:
                //open my store
                if(rghCertStore[dwStoreCount]=CertOpenStore(
                            CERT_STORE_PROV_SYSTEM_W,
							g_dwMsgAndCertEncodingType,
							NULL,
							CERT_STORE_MAXIMUM_ALLOWED_FLAG |
                            CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG |
                            CERT_SYSTEM_STORE_CURRENT_USER,
                            (LPWSTR)L"my"))
                        dwStoreCount++;
                else
                    goto CLEANUP;
            break;
        case 1:
                //open ca store
                if(rghCertStore[dwStoreCount]=CertOpenStore(
                            CERT_STORE_PROV_SYSTEM_W,
							g_dwMsgAndCertEncodingType,
							NULL,
							CERT_STORE_MAXIMUM_ALLOWED_FLAG |
                            CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG |
                            CERT_SYSTEM_STORE_CURRENT_USER,
                            (LPWSTR)L"ca"))
                        dwStoreCount++;
                else
                    goto CLEANUP;


                //open the "AddressBook" store
                if(rghCertStore[dwStoreCount]=CertOpenStore(
                            CERT_STORE_PROV_SYSTEM_W,
							g_dwMsgAndCertEncodingType,
							NULL,
							CERT_STORE_MAXIMUM_ALLOWED_FLAG |
                            CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG |
                            CERT_SYSTEM_STORE_CURRENT_USER |
                            CERT_STORE_OPEN_EXISTING_FLAG,
                            (LPWSTR)L"ADDRESSBOOK"))
                        dwStoreCount++;
                else
                {
                    //it is OK that user does not have "AddressBook" store
                    rghCertStore[dwStoreCount]=NULL;
                }

            break;
        case 2:
                //open CA store
                if(rghCertStore[dwStoreCount]=CertOpenStore(
                            CERT_STORE_PROV_SYSTEM_W,
							g_dwMsgAndCertEncodingType,
							NULL,
							CERT_STORE_MAXIMUM_ALLOWED_FLAG |
                            CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG |
                            CERT_SYSTEM_STORE_CURRENT_USER,
                            (LPWSTR)L"ca"))
                        dwStoreCount++;
                else
                    goto CLEANUP;

            break;
        case 3:
                //open root store
                if(rghCertStore[dwStoreCount]=CertOpenStore(
                            CERT_STORE_PROV_SYSTEM_W,
							g_dwMsgAndCertEncodingType,
							NULL,
							CERT_STORE_MAXIMUM_ALLOWED_FLAG |
                            CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG |
                            CERT_SYSTEM_STORE_CURRENT_USER,
                            (LPWSTR)L"root"))
                        dwStoreCount++;
                else
                    goto CLEANUP;

            break;
        case 4:
                //open trusted publisher store
                if(rghCertStore[dwStoreCount]=CertOpenStore(
                            CERT_STORE_PROV_SYSTEM_W,
							g_dwMsgAndCertEncodingType,
							NULL,
							CERT_STORE_MAXIMUM_ALLOWED_FLAG |
                            CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG |
                            CERT_SYSTEM_STORE_CURRENT_USER,
                            (LPWSTR)L"TrustedPublisher"))
                        dwStoreCount++;
                else
                    goto CLEANUP;

            break;
        default:
                goto CLEANUP;
            break;
    }



    //gather new certificates from the store opened
    for(dwIndex=0; dwIndex < dwStoreCount; dwIndex++)
    {
        pPreCertContext=NULL;

        while(pCurCertContext=CertEnumCertificatesInStore(
                              rghCertStore[dwIndex],
                              pPreCertContext))
        {

            //make sure the certificate has the correct usage oid
            if(IsValidUsage(pCurCertContext,
                            hwndDlg,
                            pCertMgrInfo))
            {
                switch (dwTabIndex)
                {
                    case 0:
                            //certificate has to have private key associated
                            //with it
                            cbData=0;

                            if(
                                (CertGetCertificateContextProperty(
                                pCurCertContext,	
                                CERT_KEY_PROV_INFO_PROP_ID,	
                                NULL,	
                                &cbData) && (0!=cbData)) ||
                                (CertGetCertificateContextProperty(
                                pCurCertContext,	
                                CERT_PVK_FILE_PROP_ID,	
                                NULL,	
                                &cbData) && (0!=cbData))
                               )
                               fValidCert=TRUE;
                        break;
                    case 1:
                            //the certificate has to be end entity cert for CA cert
                            if(0 == dwIndex)
                            {
                                if(IsCertificateEndEntity(pCurCertContext))
                                    fValidCert=TRUE;
                            }

                            //we display everything in the addressbook store
                            if(1==dwIndex)
                                fValidCert=TRUE;
                        break;
                    case 2:
                            //for certificate in CA store, has to be CA cert
                            if(!IsCertificateEndEntity(pCurCertContext))
                                fValidCert=TRUE;

                        break;
                    case 4:
                        fValidCert=TRUE;
                        break;
                    case 3:
                    default:
                            //the certificate has to be self-signed
                            if(TrustIsCertificateSelfSigned(
                                pCurCertContext,
                                pCurCertContext->dwCertEncodingType, 0))
                                fValidCert=TRUE;

                        break;
                }

                if(fValidCert)
                {
                    AddCertToCertMgrInfo(
                        CertDuplicateCertificateContext(pCurCertContext),
                        pCertMgrInfo);
                }

                fValidCert=FALSE;
            }

            pPreCertContext=pCurCertContext;
            pCurCertContext=NULL;

        }
    }

    //put the certificate in the listView
    for(dwIndex=0; dwIndex<pCertMgrInfo->dwCertCount; dwIndex++)
        AddCertToListView(hwndControl,
                    (pCertMgrInfo->prgCertContext)[dwIndex],
                        dwIndex);

    // if there is no cert selected initially disable the
    // "view cert button", "export" and "remove" button
    if (ListView_GetSelectedCount(hwndControl) == 0)
    {
        EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_VIEW),   FALSE);
        EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT), FALSE);
        EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_REMOVE), FALSE);
    }

    //we sort by the 1st column
    dwSortParam=pCertMgrInfo->rgdwSortParam[pCertMgrInfo->iColumn];

    if(0!=dwSortParam)
    {
        //sort the 1st column
        SendDlgItemMessage(hwndDlg,
            IDC_CERTMGR_LIST,
            LVM_SORTITEMS,
            (WPARAM) (LPARAM) dwSortParam,
            (LPARAM) (PFNLVCOMPARE)CompareCertificate);
    }


CLEANUP:

    //close all the certificate stores
    for(dwIndex=0; dwIndex<dwStoreCount; dwIndex++)
        CertCloseStore(rghCertStore[dwIndex], 0);

    //set the cursor back
    SetCursor(hPreCursor);
    SetWindowLongPtr(hwndDlg, GCLP_HCURSOR, (LONG_PTR)hWinPreCursor);

    return;
}


//-----------------------------------------------------------------------
// Check if the input OID is considered to be the advanced OID
//-----------------------------------------------------------------------
BOOL    IsAdvancedOID(CERT_ENHKEY_USAGE     *pKeyUsage,
                      LPCSTR                pszOID)
{
    DWORD   dwIndex=0;

    for(dwIndex=0; dwIndex<pKeyUsage->cUsageIdentifier; dwIndex++)
    {
        if(0 == _stricmp(pKeyUsage->rgpszUsageIdentifier[dwIndex], pszOID))
            return FALSE;
    }

    return TRUE;
}

//-----------------------------------------------------------------------
//The call back function for enum
//-----------------------------------------------------------------------
static BOOL WINAPI EnumOidCallback(
    IN PCCRYPT_OID_INFO pInfo,
    IN void *pvArg
    )
{

    PURPOSE_OID_CALL_BACK       *pCallBackInfo=NULL;
    BOOL                        fResult=FALSE;

    pCallBackInfo=(PURPOSE_OID_CALL_BACK *)pvArg;
    if(NULL==pvArg || NULL==pInfo)
        goto InvalidArgErr;

    //increment the oid list
    (*(pCallBackInfo->pdwOIDCount))++;

    //get more memory for the pointer list
    *(pCallBackInfo->pprgOIDInfo)=(PURPOSE_OID_INFO *)WizardRealloc(*(pCallBackInfo->pprgOIDInfo),
                                      (*(pCallBackInfo->pdwOIDCount)) * sizeof(PURPOSE_OID_INFO));

    if(NULL==*(pCallBackInfo->pprgOIDInfo))
        goto MemoryErr;

    //memset
    memset(&((*(pCallBackInfo->pprgOIDInfo))[*(pCallBackInfo->pdwOIDCount)-1]), 0, sizeof(PURPOSE_OID_INFO));

    (*(pCallBackInfo->pprgOIDInfo))[*(pCallBackInfo->pdwOIDCount)-1].pszOID=WizardAllocAndCopyStr((LPSTR)(pInfo->pszOID));
    (*(pCallBackInfo->pprgOIDInfo))[*(pCallBackInfo->pdwOIDCount)-1].pwszName=WizardAllocAndCopyWStr((LPWSTR)(pInfo->pwszName));
    (*(pCallBackInfo->pprgOIDInfo))[*(pCallBackInfo->pdwOIDCount)-1].fSelected=FALSE;

    if(NULL==(*(pCallBackInfo->pprgOIDInfo))[*(pCallBackInfo->pdwOIDCount)-1].pszOID ||
       NULL==(*(pCallBackInfo->pprgOIDInfo))[*(pCallBackInfo->pdwOIDCount)-1].pwszName)
       goto MemoryErr;

    fResult=TRUE;

CommonReturn:

    return fResult;

ErrorReturn:

	fResult=FALSE;
	goto CommonReturn;

SET_ERROR(InvalidArgErr, E_INVALIDARG);
SET_ERROR(MemoryErr, E_OUTOFMEMORY);
}

//----------------------------------------------------------------------------
//  Get the list of supported enhanced key OIDs
//----------------------------------------------------------------------------
BOOL    InitPurposeOID(LPCSTR                 pszInitUsageOID,
                       DWORD                  *pdwOIDInfo,
                       PURPOSE_OID_INFO       **pprgOIDInfo)
{
    BOOL                    fResult=FALSE;
    DWORD                   dwIndex=0;
    PURPOSE_OID_CALL_BACK   OidInfoCallBack;
    DWORD                   dwOIDRequested=0;
    LPWSTR                  pwszName=NULL;


    if(!pdwOIDInfo || !pprgOIDInfo)
        goto InvalidArgErr;

    //init
    *pdwOIDInfo=0;
    *pprgOIDInfo=NULL;

    OidInfoCallBack.pdwOIDCount=pdwOIDInfo;
    OidInfoCallBack.pprgOIDInfo=pprgOIDInfo;


    //enum all the enhanced key usages
    if(!CryptEnumOIDInfo(
               CRYPT_ENHKEY_USAGE_OID_GROUP_ID,
                0,
                &OidInfoCallBack,
                EnumOidCallback))
        goto TraceErr;


    fResult=TRUE;

CommonReturn:

    //free the memory

    return fResult;

ErrorReturn:

    FreeUsageOID(*pdwOIDInfo,*pprgOIDInfo);

    *pdwOIDInfo=0;
    *pprgOIDInfo=NULL;

	fResult=FALSE;
	goto CommonReturn;

SET_ERROR(InvalidArgErr, E_INVALIDARG);
TRACE_ERROR(TraceErr);
}


//-----------------------------------------------------------------------
//   Initialize the tab control
//-----------------------------------------------------------------------
void    InitTabControl(HWND                         hWndControl,
                       PCCRYPTUI_CERT_MGR_STRUCT    pCertMgrStruct)
{

    DWORD       dwIndex=0;
    DWORD       dwCount=0;
    WCHAR       wszText[MAX_STRING_SIZE];

    UINT        rgIDS[]={IDS_TAB_PERSONAL,
                         IDS_TAB_OTHER,
                         IDS_TAB_CA,
                         IDS_TAB_ROOT,
                         IDS_TAB_PUBLISHER,
                        };

   TCITEMW      tcItem;

    if(!hWndControl)
        return;

    memset(&tcItem, 0, sizeof(TCITEM));

    tcItem.mask=TCIF_TEXT;
    tcItem.pszText=wszText;


    if (pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG)
    {
        dwIndex = pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_TAB_MASK;
        //get the column header
        wszText[0]=L'\0';

        LoadStringU(g_hmodThisDll, rgIDS[dwIndex], wszText, MAX_STRING_SIZE);

        TabCtrl_InsertItemU(hWndControl, 		
                           0, 		
                           &tcItem);		
    } else
    {
        dwCount=sizeof(rgIDS)/sizeof(rgIDS[0]);

        //insert the tabs one at a time
        for(dwIndex=0; dwIndex<dwCount; dwIndex++)
        {
            //get the column header
            wszText[0]=L'\0';

            LoadStringU(g_hmodThisDll, rgIDS[dwIndex], wszText, MAX_STRING_SIZE);

            TabCtrl_InsertItemU(hWndControl, 		
                           dwIndex, 		
                           &tcItem);		
        }
    }

    return;
}


//----------------------------------------------------------------------------
//
//  Free the array of usage OID info
//
//----------------------------------------------------------------------------
BOOL    FreeUsageOID(DWORD              dwOIDInfo,
                     PURPOSE_OID_INFO   *pOIDInfo)
{
    DWORD   dwIndex=0;

    if(pOIDInfo)
    {
        for(dwIndex=0; dwIndex < dwOIDInfo; dwIndex++)
        {
            if(pOIDInfo[dwIndex].pszOID)
                WizardFree(pOIDInfo[dwIndex].pszOID);

            if(pOIDInfo[dwIndex].pwszName)
                WizardFree(pOIDInfo[dwIndex].pwszName);
        }

        WizardFree(pOIDInfo);
    }

    return TRUE;
}


//-----------------------------------------------------------------------
//   Free the Certificates array
//-----------------------------------------------------------------------
void    FreeCerts(CERT_MGR_INFO     *pCertMgrInfo)
{
    DWORD   dwIndex=0;

    if(!pCertMgrInfo)
        return;

    if(pCertMgrInfo->prgCertContext)
    {
        for(dwIndex=0; dwIndex<pCertMgrInfo->dwCertCount; dwIndex++)
        {
            if(pCertMgrInfo->prgCertContext[dwIndex])
                CertFreeCertificateContext(pCertMgrInfo->prgCertContext[dwIndex]);
        }

        WizardFree(pCertMgrInfo->prgCertContext);
    }

    pCertMgrInfo->dwCertCount=0;

    pCertMgrInfo->prgCertContext=NULL;

    return;
}

//--------------------------------------------------------------
// Initialize the Purpose Combo
//--------------------------------------------------------------
void    InitPurposeCombo(HWND               hwndDlg,
                         CERT_MGR_INFO      *pCertMgrInfo)
{
    DWORD                           dwIndex=0;
    DWORD                           dwCount=0;
    WCHAR                           wszText[MAX_STRING_SIZE];

    UINT                            rgIDS[]={IDS_OID_ADVANCED,
                                             IDS_OID_ALL};
    LPWSTR                          pwszInitOIDName=NULL;
    CRYPTUI_CERT_MGR_STRUCT         *pCertMgrStruct=NULL;
    int                             iIndex=0;

    if(!hwndDlg || !pCertMgrInfo)
        return;

    pCertMgrStruct=(CRYPTUI_CERT_MGR_STRUCT *)(pCertMgrInfo->pCertMgrStruct);

    //delete all the entries in the comobox
    SendDlgItemMessage(hwndDlg, IDC_CERTMGR_PURPOSE_COMBO,
        CB_RESETCONTENT, 0, 0);

    //copy all the basic OIDs to the comobox
    for(dwIndex=0; dwIndex<pCertMgrInfo->dwOIDInfo; dwIndex++)
    {

        if(FALSE == (pCertMgrInfo->rgOIDInfo[dwIndex].fSelected))
        {
            SendDlgItemMessageU(hwndDlg, IDC_CERTMGR_PURPOSE_COMBO,
                    CB_ADDSTRING,
                    0, (LPARAM)(pCertMgrInfo->rgOIDInfo[dwIndex].pwszName));


            //looking for the initial OID
            if(pCertMgrStruct->pszInitUsageOID)
            {
                if(0 == _stricmp(pCertMgrStruct->pszInitUsageOID,
                                 pCertMgrInfo->rgOIDInfo[dwIndex].pszOID))
                    pwszInitOIDName=pCertMgrInfo->rgOIDInfo[dwIndex].pwszName;
            }
        }
    }

    //copy <advanced> and <all> to the list
    dwCount=sizeof(rgIDS)/sizeof(rgIDS[0]);

    //insert the column one at a time
    for(dwIndex=0; dwIndex<dwCount; dwIndex++)
    {
        //get the column header
        wszText[0]=L'\0';

        LoadStringU(g_hmodThisDll, rgIDS[dwIndex], wszText, MAX_STRING_SIZE);

        SendDlgItemMessageU(hwndDlg, IDC_CERTMGR_PURPOSE_COMBO,
                    CB_INSERTSTRING,
                    -1, (LPARAM)wszText);
    }


    //initialize the combo box
    //use <advanced> is what user specify is not either
    //client auth or secure e-mail
    if(pCertMgrStruct->pszInitUsageOID)
    {
        if(NULL==pwszInitOIDName)
        {
            wszText[0]=L'\0';

            LoadStringU(g_hmodThisDll, IDS_OID_ADVANCED, wszText, MAX_STRING_SIZE);

            pwszInitOIDName=wszText;
        }

    }

    //use <all> when NULL==pCertMgrStruct->pszInitUsageOID
    if(NULL==pwszInitOIDName)
    {
        //use <all> as the initial case
        wszText[0]=L'\0';

        LoadStringU(g_hmodThisDll, IDS_OID_ALL, wszText, MAX_STRING_SIZE);

        pwszInitOIDName=wszText;
    }

    iIndex=(int)SendDlgItemMessageU(
        hwndDlg,
        IDC_CERTMGR_PURPOSE_COMBO,
        CB_FINDSTRINGEXACT,
        -1,
        (LPARAM)pwszInitOIDName);

    if(CB_ERR == iIndex)
        return;

    //set the selection
    SendDlgItemMessageU(hwndDlg, IDC_CERTMGR_PURPOSE_COMBO, CB_SETCURSEL, iIndex,0);

    return;

}

//--------------------------------------------------------------
// Initialize the Purpose Combo
//--------------------------------------------------------------
void    RepopulatePurposeCombo(HWND                 hwndDlg,
                               CERT_MGR_INFO        *pCertMgrInfo)
{
    LPWSTR          pwszSelectedOIDName=NULL;
    int             iIndex=0;

    if(!hwndDlg || !pCertMgrInfo)
        return;

    //get the selected string from the combo box
    iIndex=(int)SendDlgItemMessage(hwndDlg, IDC_CERTMGR_PURPOSE_COMBO,
            CB_GETCURSEL, 0, 0);

    if(CB_ERR==iIndex)
        return;

    //get the selected purpose
    if(CB_ERR == SendDlgItemMessageU_GETLBTEXT(hwndDlg,
                IDC_CERTMGR_PURPOSE_COMBO,
              iIndex, &pwszSelectedOIDName))
        goto CLEANUP;

    InitPurposeCombo(hwndDlg, pCertMgrInfo);

    iIndex=(int)SendDlgItemMessageU(
            hwndDlg,
            IDC_CERTMGR_PURPOSE_COMBO,
            CB_FINDSTRINGEXACT,
            -1,
            (LPARAM)pwszSelectedOIDName);

    if(CB_ERR == iIndex)
        goto CLEANUP;

    //set the selection
    SendDlgItemMessageU(hwndDlg, IDC_CERTMGR_PURPOSE_COMBO, CB_SETCURSEL, iIndex,0);


CLEANUP:

    if(pwszSelectedOIDName)
        WizardFree(pwszSelectedOIDName);

    return;

}
//--------------------------------------------------------------
// The winProc for the advanced option diagloue for certMgr UI
//--------------------------------------------------------------
INT_PTR APIENTRY CertMgrAdvancedProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    CERT_MGR_INFO                   *pCertMgrInfo=NULL;
    PCCRYPTUI_CERT_MGR_STRUCT       pCertMgrStruct=NULL;

    UINT                            rgIDS[]={IDS_CERTMGR_DER,
                                             IDS_CERTMGR_BASE64,
                                             IDS_CERTMGR_PKCS7};

    WCHAR                           wszText[MAX_STRING_SIZE];
    DWORD                           dwCount=0;
    DWORD                           dwIndex=0;
    DWORD                           dwSelectedIndex=0;
    LV_ITEMW                        lvItem;
    LV_COLUMNW                      lvC;
    HWND                            hwndControl=NULL;
    int                             iIndex=0;
    int                             listIndex=0;
    NM_LISTVIEW FAR *               pnmv=NULL;
    HWND                            hwnd=NULL;

    switch ( msg )
    {
        case WM_INITDIALOG:

            pCertMgrInfo = (CERT_MGR_INFO   *) lParam;

            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR) pCertMgrInfo);

            pCertMgrStruct=pCertMgrInfo->pCertMgrStruct;

            if(NULL == pCertMgrStruct)
                break;

            //init the export format control
            dwCount=sizeof(rgIDS)/sizeof(rgIDS[0]);

            for(dwIndex=0; dwIndex < dwCount; dwIndex++)
            {
                LoadStringU(g_hmodThisDll,
                            rgIDS[dwIndex],
                            wszText,
                            MAX_STRING_SIZE);

                SendDlgItemMessageU(hwndDlg,
                            IDC_CERTMGR_EXPORT_COMBO,
                            CB_INSERTSTRING,
                            -1,
                            (LPARAM)wszText);
            }

            //select the export format based on the selection
            switch (pCertMgrInfo->dwExportFormat)
            {
                case   CRYPTUI_WIZ_EXPORT_FORMAT_DER:
                        dwSelectedIndex=0;
                    break;
                case   CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
                        dwSelectedIndex=1;
                    break;
                case   CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
                        dwSelectedIndex=2;
                    break;
                default:
                    dwSelectedIndex=0;
            }

            SendDlgItemMessageU(hwndDlg, IDC_CERTMGR_EXPORT_COMBO,
                CB_SETCURSEL, (WPARAM)dwSelectedIndex,0);

            //init the chain check-box
            if(pCertMgrInfo->fExportChain)
                SendDlgItemMessage(hwndDlg, IDC_CERTMGR_EXPORT_CHECK, BM_SETCHECK, 1, 0);
            else
                SendDlgItemMessage(hwndDlg, IDC_CERTMGR_EXPORT_CHECK, BM_SETCHECK, 0, 0);

            if(dwSelectedIndex != 2)
                EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT_CHECK), FALSE);
            else
                EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT_CHECK), TRUE);

            //init the advanced OID list
            hwndControl = GetDlgItem(hwndDlg, IDC_CERTMGR_ADV_LIST);

            //mark the list is selected by a check box
            ListView_SetExtendedListViewStyle(hwndControl, LVS_EX_CHECKBOXES);

            //insert a column into the list view
            memset(&lvC, 0, sizeof(LV_COLUMNW));

            lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
            lvC.fmt = LVCFMT_LEFT;  // Left-align the column.
            lvC.cx =10;       // (dwMaxSize+2)*7;            // Width of the column, in pixels.
            lvC.pszText = L"";   // The text for the column.
            lvC.iSubItem=0;

            if (ListView_InsertColumnU(hwndControl, 0, &lvC) == -1)
                break;

            //populate the list
            memset(&lvItem, 0, sizeof(LV_ITEMW));
            lvItem.mask=LVIF_TEXT | LVIF_STATE;

            for(dwIndex=0; dwIndex<pCertMgrInfo->dwOIDInfo; dwIndex++)
            {
                lvItem.iItem=dwIndex;

                lvItem.pszText=(pCertMgrInfo->rgOIDInfo[dwIndex]).pwszName;
                lvItem.cchTextMax=sizeof(WCHAR)*(1+wcslen((pCertMgrInfo->rgOIDInfo[dwIndex]).pwszName));
                lvItem.stateMask  = LVIS_STATEIMAGEMASK;
                lvItem.state      = (pCertMgrInfo->rgOIDInfo[dwIndex]).fSelected ? 0x00002000 : 0x00001000;

                // insert and set state
                ListView_SetItemState(hwndControl,
                                    ListView_InsertItemU(hwndControl, &lvItem),
                                    (pCertMgrInfo->rgOIDInfo[dwIndex]).fSelected ? 0x00002000 : 0x00001000,
                                    LVIS_STATEIMAGEMASK);
            }

            //autosize the column
            ListView_SetColumnWidth(hwndControl, 0, LVSCW_AUTOSIZE);

#if (1) // DSIE: bug 282268.
            ListView_SetItemState(hwndControl,
                                  0,
                                  LVIS_FOCUSED | LVIS_SELECTED,
                                  LVIS_FOCUSED | LVIS_SELECTED);
#endif
            break;

        case WM_NOTIFY:
            pCertMgrInfo = (CERT_MGR_INFO *) GetWindowLongPtr(hwndDlg, DWLP_USER);

            if(NULL == pCertMgrInfo)
                break;

            pCertMgrStruct=pCertMgrInfo->pCertMgrStruct;

            if(NULL == pCertMgrStruct)
                break;

            switch (((NMHDR FAR *) lParam)->code)
            {
                case    LVN_ITEMCHANGED:
                        //if the state of the advanced OID check box
                        //has been changed, mark the flag
                        pnmv = (NM_LISTVIEW FAR *) lParam;

                        if(NULL==pnmv)
                            break;

                        //see if the new item is de-selected
                        if(pnmv->uChanged & LVIF_STATE)
                            pCertMgrInfo->fAdvOIDChanged=TRUE;

                    break;
            }

            break;

        case WM_DESTROY:
            break;

        case WM_HELP:
        case WM_CONTEXTMENU:
            if (msg == WM_HELP)
            {
                hwnd = GetDlgItem(hwndDlg, ((LPHELPINFO)lParam)->iCtrlId);
            }
            else
            {
                hwnd = (HWND) wParam;
            }

            if ((hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_ADV_LIST))         &&
                (hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT_COMBO))     &&
                (hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT_CHECK))     &&
                (hwnd != GetDlgItem(hwndDlg, IDOK))                         &&
                (hwnd != GetDlgItem(hwndDlg, IDCANCEL)))
            {
                SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, TRUE);
                return TRUE;
            }
            else
            {
                return OnContextHelp(hwndDlg, msg, wParam, lParam, CertMgrAdvHelpMap);
            }

            break;

        case WM_COMMAND:
            pCertMgrInfo = (CERT_MGR_INFO *) GetWindowLongPtr(hwndDlg, DWLP_USER);

            if(NULL == pCertMgrInfo)
                break;

            pCertMgrStruct=pCertMgrInfo->pCertMgrStruct;

            if(NULL == pCertMgrStruct)
                break;

            //a control is clicked
            if(HIWORD(wParam) == BN_CLICKED)
            {
                 switch (LOWORD(wParam))
                 {
                     case IDCANCEL:
                         pCertMgrInfo->fAdvOIDChanged=FALSE;

                         EndDialog(hwndDlg, DIALOGUE_CANCEL);
                         break;

                     case IDOK:
                         //the OK button is selected
                         //get the default export format
                         iIndex=(int)SendDlgItemMessage(hwndDlg,
                                 IDC_CERTMGR_EXPORT_COMBO,
                                 CB_GETCURSEL, 0, 0);

                         if(CB_ERR==iIndex)
                             break;

                         switch(iIndex)
                         {
                             case 0:
                                 pCertMgrInfo->dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_DER;

                                 break;

                             case 1:
                                 pCertMgrInfo->dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_BASE64;
                                 break;

                             case 2:
                                 pCertMgrInfo->dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7;
                                 break;

                             default:
                                 pCertMgrInfo->dwExportFormat=0;
                                 break;
                         }

                         if(TRUE==SendDlgItemMessage(
                                     hwndDlg,
                                     IDC_CERTMGR_EXPORT_CHECK,
                                     BM_GETCHECK,
                                     0,0))
                             pCertMgrInfo->fExportChain=TRUE;
                         else
                             pCertMgrInfo->fExportChain=FALSE;

                         //get the list of advanded OIDs
                         if(NULL==(hwndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_ADV_LIST)))
                             break;

                         //get the count of selected OIDs and mark them
                         for(dwIndex=0; dwIndex<pCertMgrInfo->dwOIDInfo; dwIndex++)
                         {
                             //mark the selected OIDS.  Keep track of
                             //if the OID selections have been changed
                             if(ListView_GetCheckState(hwndControl, dwIndex))
                             {
                                 ((pCertMgrInfo->rgOIDInfo)[dwIndex]).fSelected=TRUE;
                             }
                             else
                             {
                                 ((pCertMgrInfo->rgOIDInfo)[dwIndex]).fSelected=FALSE;
                             }

                         }


                         //save the advanced options to the registry
                         SaveAdvValueToReg(pCertMgrInfo);

                         EndDialog(hwndDlg, DIALOGUE_OK);

                         break;
                 }
            }

            //a combo box's selection has been changed
            if(HIWORD(wParam) == CBN_SELCHANGE)
            {
                switch(LOWORD(wParam))
                {
                    case IDC_CERTMGR_EXPORT_COMBO:
                        //the export format combo box has been changed
                        //get the selected item index
                        iIndex=(int)SendDlgItemMessage(hwndDlg,
                                IDC_CERTMGR_EXPORT_COMBO,
                                CB_GETCURSEL, 0, 0);

                        if(CB_ERR==iIndex)
                            break;

                        //enable the check box for the chain if
                        //PKCS#7 option is selected
                        if(2 == iIndex)
                            EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT_CHECK), TRUE);
                        else
                            EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT_CHECK), FALSE);

                        break;
                }
            }

            break;
    }

    return FALSE;
}



//--------------------------------------------------------------
// The winProc for CertMgrDialogProc
//--------------------------------------------------------------
INT_PTR APIENTRY CertMgrDialogProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    CERT_MGR_INFO                   *pCertMgrInfo=NULL;
    PCCRYPTUI_CERT_MGR_STRUCT       pCertMgrStruct=NULL;

    HWND                            hWndListView=NULL;
    HWND                            hWndControl=NULL;
    DWORD                           dwIndex=0;
    DWORD                           dwCount=0;
    WCHAR                           wszText[MAX_STRING_SIZE];
    BOOL                            fCanDelete=FALSE;

    UINT                            rgIDS[]={IDS_COLUMN_SUBJECT,
                                             IDS_COLUMN_ISSUER,
                                             IDS_COLUMN_EXPIRE,
                                             IDS_COLUMN_NAME};


    NM_LISTVIEW FAR *               pnmv=NULL;
    LPNMLVKEYDOWN                   pnkd=NULL;
    LV_COLUMNW                      lvC;
    int                             listIndex=0;
    LV_ITEM                         lvItem;
    BOOL                            fPropertyChanged=FALSE;


    HIMAGELIST                      hIml=NULL;
    CRYPTUI_VIEWCERTIFICATE_STRUCT  CertViewStruct;
    CRYPTUI_WIZ_EXPORT_INFO         CryptUIWizExportInfo;
    UINT                            idsDeleteConfirm=0;
    int                             iIndex=0;
    DWORD                           dwSortParam=0;
    HCERTSTORE                      hCertStore=NULL;
    HWND                            hwnd=NULL;

    DWORD                           cbData=0;

    switch ( msg )
    {

        case WM_INITDIALOG:

                pCertMgrInfo = (CERT_MGR_INFO   *) lParam;

                SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR) pCertMgrInfo);

                pCertMgrStruct=pCertMgrInfo->pCertMgrStruct;

                if(NULL == pCertMgrStruct)
                    break;

                //
                // set the dialog title
                //
                if (pCertMgrStruct->pwszTitle)
                {
                    SetWindowTextU(hwndDlg, pCertMgrStruct->pwszTitle);
                }

                //create the image list

                hIml = ImageList_LoadImage(g_hmodThisDll, MAKEINTRESOURCE(IDB_CERT), 0, 1, RGB(255,0,255), IMAGE_BITMAP, 0);

                //
                // add the colums to the list view
                //
                hWndListView = GetDlgItem(hwndDlg, IDC_CERTMGR_LIST);

                if(NULL==hWndListView)
                    break;

                //set the image list
                if (hIml != NULL)
                {
                    ListView_SetImageList(hWndListView, hIml, LVSIL_SMALL);
                }

                dwCount=sizeof(rgIDS)/sizeof(rgIDS[0]);

                //set up the common info for the column
                memset(&lvC, 0, sizeof(LV_COLUMNW));

                lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
                lvC.fmt = LVCFMT_LEFT;  // Left-align the column.
                lvC.cx = 80;          // Width of the column, in pixels.
                lvC.iSubItem=0;
                lvC.pszText = wszText;   // The text for the column.

                //inser the column one at a time
                for(dwIndex=0; dwIndex<dwCount; dwIndex++)
                {
                    //get the column header
                    wszText[0]=L'\0';

                    //set the column width.  1st and 2nd to 100,
                    //and the expiration to 75, the rest to 80
                    if( dwIndex < 2)
                        lvC.cx=130;
                    else
                    {
                        if( 2 == dwIndex)
                            lvC.cx=70;
                        else
                            lvC.cx=105;
                    }


                    LoadStringU(g_hmodThisDll, rgIDS[dwIndex], wszText, MAX_STRING_SIZE);

                    ListView_InsertColumnU(hWndListView, dwIndex, &lvC);
                }

                // set the style in the list view so that it highlights an entire line
                SendMessageA(hWndListView, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);


                //Init tabs to the tab control.
                hWndControl = GetDlgItem(hwndDlg, IDC_CERTMGR_TAB);
                if(NULL==hWndControl)
                    break;

                //add the tabs to the tabl control
                InitTabControl(hWndControl, pCertMgrStruct);

                // If CRYPTUI_CERT_MGR_PUBLISHER_TAB was set, then,
                // select the 5th tab: Trusted Publishers, otherwise,
                // select the 1st tab: Personal Certificate
                TabCtrl_SetCurSel(
                    hWndControl,
                    (CRYPTUI_CERT_MGR_PUBLISHER_TAB ==
                        (pCertMgrStruct->dwFlags &
                            (CRYPTUI_CERT_MGR_TAB_MASK |
                                CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG) )) ?  4 : 0
                    );

                //Init the purpose combo box
                InitPurposeCombo(hwndDlg,pCertMgrInfo);

                //Init the certificates in the list view based on the tab selected
                //and the purpose selected
                RefreshCertListView(hwndDlg, pCertMgrInfo);

                //Set the correct window title based on the tab selection
               // RefreshWindowTitle(hwndDlg, (CRYPTUI_CERT_MGR_STRUCT *)pCertMgrStruct);

                //register the listView window as the drop desitination
                if(S_OK == CCertMgrDropTarget_CreateInstance(
                                           hwndDlg,
                                           pCertMgrInfo,
                                           &(pCertMgrInfo->pIDropTarget)))
                {
                    __try {
                        RegisterDragDrop(hWndListView, pCertMgrInfo->pIDropTarget);
                   } __except(EXCEPTION_EXECUTE_HANDLER) {

                   }
                }
            break;
        case WM_NOTIFY:

                pCertMgrInfo = (CERT_MGR_INFO *) GetWindowLongPtr(hwndDlg, DWLP_USER);

                if(NULL == pCertMgrInfo)
                    break;

                pCertMgrStruct=pCertMgrInfo->pCertMgrStruct;

                if(NULL == pCertMgrStruct)
                    break;


                switch (((NMHDR FAR *) lParam)->code)
                {

                    //the delete key has been pressed
                    case LVN_KEYDOWN:
                            pnkd = (LPNMLVKEYDOWN) lParam;

                            if(VK_DELETE == pnkd->wVKey)
                            {
                                if(NULL==(hWndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_LIST)))
                                    break;
                                
                                GetAllSelectedItem(hWndControl,
                                                      ALL_SELECTED_CAN_DELETE,
                                                      &fCanDelete);

                                if(!fCanDelete)
                                {
                                    I_MessageBox(
                                            hwndDlg,
                                            IDS_CANNOT_DELETE_CERTS,
                                            IDS_CERT_MGR_TITLE,
                                            pCertMgrStruct->pwszTitle,
                                            MB_ICONEXCLAMATION|MB_OK|MB_APPLMODAL);
                                }
                                else
                                {
                                    //same action as user has click on the DELETE button
                                    SendDlgItemMessage(hwndDlg,
                                                        IDC_CERTMGR_REMOVE,
                                                        BM_CLICK,
                                                        0,0);
                                }
                            }

                        break;
                    //drag drop operation has begun
                    case LVN_BEGINDRAG:
                    case LVN_BEGINRDRAG:

                            pnmv = (LPNMLISTVIEW) lParam;

                            if(!pnmv)
                                break;

                            if(NULL==(hWndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_LIST)))
                                                    break;

                            listIndex = ListView_GetNextItem(
                                    hWndControl, 		
                                    -1, 		
                                    LVNI_SELECTED		
                                    );

                            if(listIndex != -1)
                                //start the drag and drop
                                CertMgrUIStartDragDrop(pnmv, hWndControl,
                                pCertMgrInfo->dwExportFormat,
                                pCertMgrInfo->fExportChain);

                        break;
                    //the item has been selected
                    case LVN_ITEMCHANGED:
                            if(NULL==(hWndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_LIST)))
                                                    break;

                            pnmv = (LPNMLISTVIEW) lParam;

                            if(NULL==pnmv)
                                break;

                            if (pnmv->uNewState & LVIS_SELECTED)
                            {

                                //enable the export buttons
                                EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT), TRUE);

                                //if more than one certificates are selected, diable the view button
                                if(ListView_GetSelectedCount(hWndControl) > 1)
                                    EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_VIEW), FALSE);
                                else
                                    EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_VIEW), TRUE);

                                //enable the delete window only if the certificate is deletable
                                GetAllSelectedItem(hWndControl,
                                                      ALL_SELECTED_CAN_DELETE,
                                                      &fCanDelete);

                                if(fCanDelete)
                                    EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_REMOVE), TRUE);
                                else
                                    EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_REMOVE), FALSE);


                                //display the details of the certificate if
                                //only 1 cert is selected
                                if(1 == ListView_GetSelectedCount(hWndControl))
                                {
                                    RefreshCertDetails(hwndDlg, (PCCERT_CONTEXT)(pnmv->lParam));
                                }
                                else
                                {
                                    //clear the ceritificate details group box
                                    SetDlgItemTextU(hwndDlg, IDC_CERTMGR_PURPOSE, L" ");
                                }
                            }
                            else
                            {
                                //if the state is deselection
                                if(0 == ListView_GetSelectedCount(hWndControl))
                                {
                                    //we diable the buttons if no certificate is selected
                                    EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_VIEW),     FALSE);
                                    EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT),   FALSE);
                                    EnableWindow(GetDlgItem(hwndDlg, IDC_CERTMGR_REMOVE),   FALSE);

                                    //clear the ceritificate details group box
                                    SetDlgItemTextU(hwndDlg, IDC_CERTMGR_PURPOSE, L" ");
                                }
                            }

                        break;
                    //the column has been changed
                    case LVN_COLUMNCLICK:

                            pnmv = (NM_LISTVIEW FAR *) lParam;

                            //get the column number
                            dwSortParam=0;

                            switch(pnmv->iSubItem)
                            {
                                case 0:
                                case 1:
                                case 2:
                                case 3:
                                case 4:
                                        dwSortParam=pCertMgrInfo->rgdwSortParam[pnmv->iSubItem];
                                    break;
                                default:
                                        dwSortParam=0;
                                    break;
                            }

                            if(0!=dwSortParam)
                            {
                                //remember to flip the ascend ording

                                if(dwSortParam & SORT_COLUMN_ASCEND)
                                {
                                    dwSortParam &= 0x0000FFFF;
                                    dwSortParam |= SORT_COLUMN_DESCEND;
                                }
                                else
                                {
                                    if(dwSortParam & SORT_COLUMN_DESCEND)
                                    {
                                        dwSortParam &= 0x0000FFFF;
                                        dwSortParam |= SORT_COLUMN_ASCEND;
                                    }
                                }

                                //sort the column
                                SendDlgItemMessage(hwndDlg,
                                    IDC_CERTMGR_LIST,
                                    LVM_SORTITEMS,
                                    (WPARAM) (LPARAM) dwSortParam,
                                    (LPARAM) (PFNLVCOMPARE)CompareCertificate);

                                pCertMgrInfo->rgdwSortParam[pnmv->iSubItem]=dwSortParam;

                                //remember the column number
                                pCertMgrInfo->iColumn=pnmv->iSubItem;
                            }

                        break;


                    //the tab has been changed
                    case TCN_SELCHANGE:
                            //we need to refresh the column sorting state
                            pCertMgrInfo->rgdwSortParam[0]=SORT_COLUMN_SUBJECT | SORT_COLUMN_ASCEND;
                            pCertMgrInfo->rgdwSortParam[1]=SORT_COLUMN_ISSUER | SORT_COLUMN_DESCEND;
                            pCertMgrInfo->rgdwSortParam[2]=SORT_COLUMN_EXPIRATION | SORT_COLUMN_DESCEND;
                            pCertMgrInfo->rgdwSortParam[3]=SORT_COLUMN_NAME | SORT_COLUMN_DESCEND;
                            pCertMgrInfo->rgdwSortParam[4]=SORT_COLUMN_NAME | SORT_COLUMN_DESCEND;

                            pCertMgrInfo->iColumn=0;

                            //if the tab is changed, we need to
                            //refresh the list view and certificate's
                            //detailed view
                            RefreshCertListView(hwndDlg, pCertMgrInfo);

                            //we also we to update the window title
                            //based on the tabl selection
                            //RefreshWindowTitle(hwndDlg, (CRYPTUI_CERT_MGR_STRUCT *)pCertMgrStruct);
                        break;

                    //double-click on the list view of the certificates
                    case NM_DBLCLK:
                    {
                        switch (((NMHDR FAR *) lParam)->idFrom)
                        {
                            case IDC_CERTMGR_LIST:
                            {
                                //get the window handle of the cert list view
                                if(NULL==(hWndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_LIST)))
                                    break;

                                //get the selected cert
                                listIndex = ListView_GetNextItem(
                                    hWndControl, 		
                                    -1, 		
                                    LVNI_SELECTED		
                                    );

                                if (listIndex != -1)
                                {
                                    //get the selected certificate
                                    memset(&lvItem, 0, sizeof(LV_ITEM));
                                    lvItem.mask=LVIF_PARAM;
                                    lvItem.iItem=listIndex;

                                    if(ListView_GetItem(hWndControl, &lvItem))
                                    {
                                        //view certiificate
                                       if(pCertMgrInfo->dwCertCount > (DWORD)listIndex)
                                       {
                                            memset(&CertViewStruct, 0, sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT));
                                            CertViewStruct.dwSize=sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT);
                                            CertViewStruct.pCertContext=(PCCERT_CONTEXT)(lvItem.lParam);
                                            CertViewStruct.hwndParent=hwndDlg;

                                            fPropertyChanged=FALSE;

                                            CryptUIDlgViewCertificate(&CertViewStruct, &fPropertyChanged);

                                            if(fPropertyChanged)
                                            {
                                                RefreshCertListView(hwndDlg, pCertMgrInfo);

                                                //we reselect the one
                                                ListView_SetItemState(
                                                                    hWndControl,
                                                                    listIndex,
                                                                    LVIS_SELECTED,
                                                                    LVIS_SELECTED);
                                            }
                                       }
                                    }
                                }

                                break;
                            }
                        }

                        break;
                    }

#if (1) //DSIE: bug 264568.
                    case NM_SETFOCUS:
                    {
                        //get the window handle of the cert list view
                        if(NULL==(hWndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_LIST)))
                            break;

                        //get the selected cert
                        listIndex = ListView_GetNextItem(
                            hWndControl, 		
                            -1, 		
                            LVNI_FOCUSED		
                            );

                        //select first item to show hilite.
                        if (listIndex == -1)
                            ListView_SetItemState(hWndControl,
                                                  0,
                                                  LVIS_FOCUSED | LVIS_SELECTED,
                                                  LVIS_FOCUSED | LVIS_SELECTED);
                        break;
                    }
#endif
                }

            break;

        case WM_DESTROY:

               __try {
                    //revoke drag drop
                    RevokeDragDrop(GetDlgItem(hwndDlg, IDC_CERTMGR_LIST));
                 } __except(EXCEPTION_EXECUTE_HANDLER) {
                }

                pCertMgrInfo = (CERT_MGR_INFO *) GetWindowLongPtr(hwndDlg, DWLP_USER);

                if(pCertMgrInfo)
                {
                    if(pCertMgrInfo->pIDropTarget)
                        pCertMgrInfo->pIDropTarget->Release();
                }

                // destroy the image list in the list view        //
                hWndListView = GetDlgItem(hwndDlg, IDC_CERTMGR_LIST);

                if(NULL==hWndListView)
                    break;

                //no need to destroy the image list.  Handled by ListView
                //ImageList_Destroy(ListView_GetImageList(hWndListView, LVSIL_SMALL));

            break;
        case WM_HELP:
        case WM_CONTEXTMENU:
                if (msg == WM_HELP)
                {
                    hwnd = GetDlgItem(hwndDlg, ((LPHELPINFO)lParam)->iCtrlId);
                }
                else
                {
                    hwnd = (HWND) wParam;
                }


                if ((hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_LIST))             &&
                    (hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_PURPOSE_COMBO))    &&
                    (hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_IMPORT))           &&
                    (hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_EXPORT))           &&
                    (hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_VIEW))             &&
                    (hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_REMOVE))           &&
                    (hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_ADVANCE))          &&
                    (hwnd != GetDlgItem(hwndDlg, IDOK))                         &&
                    (hwnd != GetDlgItem(hwndDlg, IDC_CERTMGR_PURPOSE)))
                {
                    SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, TRUE);
                    return TRUE;
                }
                else
                {
                    return OnContextHelp(hwndDlg, msg, wParam, lParam, CertMgrMainHelpMap);
                }

            break;


        case WM_COMMAND:

                pCertMgrInfo = (CERT_MGR_INFO *) GetWindowLongPtr(hwndDlg, DWLP_USER);

                if(NULL == pCertMgrInfo)
                    break;

                pCertMgrStruct=pCertMgrInfo->pCertMgrStruct;

                if(NULL == pCertMgrStruct)
                    break;

                //a control is clicked
               if(HIWORD(wParam) == BN_CLICKED)
               {
                    switch (LOWORD(wParam))
                    {
                        case IDC_CERTMGR_ADVANCE:

                               //lauch the advanced dialogue
                                if(DIALOGUE_OK == DialogBoxParamU(
                                    g_hmodThisDll,
                                    (LPCWSTR)(MAKEINTRESOURCE(IDD_CERTMGR_ADVANCED)),
                                    hwndDlg,
                                    CertMgrAdvancedProc,
                                    (LPARAM) pCertMgrInfo))
                                {
                                    //if the advanced OIDs' list has been changed,
                                    //we need to refresh the list window
                                    if(TRUE == pCertMgrInfo->fAdvOIDChanged)
                                    {
                                        //mark the flag
                                        pCertMgrInfo->fAdvOIDChanged=FALSE;

                                        //repopulate the combo box based on
                                        //the new selection
                                        RepopulatePurposeCombo(hwndDlg,
                                            pCertMgrInfo);

                                        //refresh the list window only if
                                        //<advanced> is selected
                                        if(IsAdvancedSelected(hwndDlg))
                                            RefreshCertListView(hwndDlg, pCertMgrInfo);
                                    }
                                }

                            break;

                        case IDC_CERTMGR_REMOVE:
                                //get the selected certificate
                                if(NULL==(hWndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_LIST)))
                                    break;

                                //get the selected cert
                                listIndex = ListView_GetNextItem(
                                    hWndControl, 		
                                    -1, 		
                                    LVNI_SELECTED		
                                    );

                                if (listIndex != -1)
                                {
                                    //get the selected tab
                                    if (pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG)
                                        iIndex = pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_TAB_MASK;
                                    else
                                        iIndex=TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_CERTMGR_TAB));

                                    if(-1==iIndex)
                                        break;

                                    //delete confirmation
                                    switch(iIndex)
                                    {
                                        case 0:
                                                idsDeleteConfirm=IDS_CERTMGR_PERSONAL_REMOVE;
                                            break;
                                        case 1:
                                                idsDeleteConfirm=IDS_CERTMGR_OTHER_REMOVE;
                                            break;
                                        case 2:
                                                idsDeleteConfirm=IDS_CERTMGR_CA_REMOVE;
                                            break;
                                        case 3:
                                                idsDeleteConfirm=IDS_CERTMGR_ROOT_REMOVE;
                                            break;
                                        case 4:
                                                idsDeleteConfirm=IDS_CERTMGR_PUBLISHER_REMOVE;
                                            break;
                                        default:
                                                idsDeleteConfirm=IDS_CERTMGR_PERSONAL_REMOVE;
                                            break;
                                    }

                                    iIndex=I_MessageBox(hwndDlg,
                                            idsDeleteConfirm,
                                            IDS_CERT_MGR_TITLE,
                                            pCertMgrStruct->pwszTitle,
                                            MB_ICONEXCLAMATION|MB_YESNO|MB_APPLMODAL);

                                    if(IDYES == iIndex)
                                    {
                                        //delete all the selected certificates
                                        GetAllSelectedItem(hWndControl,
                                                      ALL_SELECTED_DELETE,
                                                      NULL);

                                        //refresh the list view since some certificates
                                        //might be deleted
                                        
                                        //send the tab control

                                        SendMessage(hwndDlg, WM_NEXTDLGCTL, (WPARAM) 0, (LPARAM) NULL);

                                        RefreshCertListView(hwndDlg, pCertMgrInfo);
                                    }

                                }
                                else
                                {
                                    //output the message
                                    I_MessageBox(hwndDlg, IDS_HAS_TO_SELECT_CERT,
                                            IDS_CERT_MGR_TITLE,
                                            pCertMgrStruct->pwszTitle,
                                            MB_ICONERROR|MB_OK|MB_APPLMODAL);
                                }

                            break;
                        case IDC_CERTMGR_IMPORT:
                            {
                                DWORD dwTabIndex;
                                HCERTSTORE hTabStore = NULL;

                                // Import into the store associated with the
                                // currently selected tab
                                if (pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG)
                                    dwTabIndex = pCertMgrStruct->dwFlags & CRYPTUI_CERT_MGR_TAB_MASK;
                                else
                                    dwTabIndex = TabCtrl_GetCurSel(
                                        GetDlgItem(hwndDlg, IDC_CERTMGR_TAB));

                                if (TAB_STORE_NAME_CNT > dwTabIndex) {
                                    hTabStore = CertOpenStore(
                                        CERT_STORE_PROV_SYSTEM_W,
                                        g_dwMsgAndCertEncodingType,
                                        NULL,
                                        CERT_STORE_MAXIMUM_ALLOWED_FLAG |
                                        CERT_STORE_SET_LOCALIZED_NAME_FLAG |
                                        CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG |
                                        CERT_SYSTEM_STORE_CURRENT_USER,
                                        rgpwszTabStoreName[dwTabIndex]
                                        );
                                }

                                //call the certificate import wizard
                                CryptUIWizImport(
                                    0,
                                    hwndDlg,
                                    NULL,
                                    NULL,
                                    hTabStore);

                                if (hTabStore)
                                    CertCloseStore(hTabStore, 0);

                                //refresh the list view since new certificates
                                //might be added
                                RefreshCertListView(hwndDlg, pCertMgrInfo);
                            }

                            break;

                        case IDC_CERTMGR_EXPORT:

                                //get the selected certificate
                                if(NULL==(hWndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_LIST)))
                                    break;

                                //get the selected cert
                                listIndex = ListView_GetNextItem(
                                    hWndControl, 		
                                    -1, 		
                                    LVNI_SELECTED		
                                    );

                                if (listIndex != -1)
                                {

                                    //we call the export wizard differently based
                                    //on single or multiple selection
                                    if(ListView_GetSelectedCount(hWndControl) > 1)
                                    {
                                        //open a memory store
                                        hCertStore=CertOpenStore(
                                            CERT_STORE_PROV_MEMORY,
						                    g_dwMsgAndCertEncodingType,
						                    NULL,
						                    0,
						                    NULL);


                                        if(hCertStore)
                                        {
                                            GetAllSelectedItem(hWndControl,
                                                          ALL_SELECTED_COPY,
                                                          &hCertStore);

                                            //call the export wizard
                                            memset(&CryptUIWizExportInfo, 0, sizeof(CRYPTUI_WIZ_EXPORT_INFO));
                                            CryptUIWizExportInfo.dwSize=sizeof(CRYPTUI_WIZ_EXPORT_INFO);
                                            CryptUIWizExportInfo.dwSubjectChoice=CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY;
                                            CryptUIWizExportInfo.hCertStore=hCertStore;

                                            CryptUIWizExport(0,
                                                            hwndDlg,
                                                            NULL,
                                                            &CryptUIWizExportInfo,
                                                            NULL);

                                            CertCloseStore(hCertStore, 0);
                                            hCertStore=NULL;
                                        }
                                    }
                                    else
                                    {
                                        memset(&lvItem, 0, sizeof(LV_ITEM));
                                        lvItem.mask=LVIF_PARAM;
                                        lvItem.iItem=listIndex;

                                        if(ListView_GetItem(hWndControl,
                                                         &lvItem))
                                        {
                                           if(pCertMgrInfo->dwCertCount > (DWORD)listIndex)
                                           {
                                                //call the export wizard
                                                memset(&CryptUIWizExportInfo, 0, sizeof(CRYPTUI_WIZ_EXPORT_INFO));
                                                CryptUIWizExportInfo.dwSize=sizeof(CRYPTUI_WIZ_EXPORT_INFO);
                                                CryptUIWizExportInfo.dwSubjectChoice=CRYPTUI_WIZ_EXPORT_CERT_CONTEXT;
                                                CryptUIWizExportInfo.pCertContext=(PCCERT_CONTEXT)(lvItem.lParam);

                                                CryptUIWizExport(0,
                                                                hwndDlg,
                                                                NULL,
                                                                &CryptUIWizExportInfo,
                                                                NULL);
                                           }
                                        }
                                    }
                                }
                                else
                                    //output the message
                                    I_MessageBox(hwndDlg, IDS_HAS_TO_SELECT_CERT,
                                            IDS_CERT_MGR_TITLE,
                                            pCertMgrStruct->pwszTitle,
                                            MB_ICONERROR|MB_OK|MB_APPLMODAL);

                            break;

                        case IDC_CERTMGR_VIEW:

                                //get the selected certificate
                                if(NULL==(hWndControl=GetDlgItem(hwndDlg, IDC_CERTMGR_LIST)))
                                    break;

                                //get the selected cert
                                listIndex = ListView_GetNextItem(
                                    hWndControl, 		
                                    -1, 		
                                    LVNI_SELECTED		
                                    );

                                if (listIndex != -1)
                                {
                                    //view certiificate
                                   if(pCertMgrInfo->dwCertCount > (DWORD)listIndex)
                                   {

                                        memset(&lvItem, 0, sizeof(LV_ITEM));
                                        lvItem.mask=LVIF_PARAM;
                                        lvItem.iItem=listIndex;

                                        if(ListView_GetItem(hWndControl,
                                                         &lvItem))
                                        {
                                            memset(&CertViewStruct, 0, sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT));
                                            CertViewStruct.dwSize=sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT);
                                            CertViewStruct.pCertContext=(PCCERT_CONTEXT)(lvItem.lParam);
                                            CertViewStruct.hwndParent=hwndDlg;


                                            fPropertyChanged=FALSE;

                                            CryptUIDlgViewCertificate(&CertViewStruct, &fPropertyChanged);

                                            if(fPropertyChanged)
                                            {
                                                RefreshCertListView(hwndDlg, pCertMgrInfo);

                                                //we reselect the one
                                                ListView_SetItemState(
                                                                    hWndControl,
                                                                    listIndex,
                                                                    LVIS_SELECTED,
                                                                    LVIS_SELECTED);
                                            }
                                        }
                                   }
                                }
                                else
                                    //output the message
                                    I_MessageBox(hwndDlg, IDS_HAS_TO_SELECT_CERT,
                                            IDS_CERT_MGR_TITLE,
                                            pCertMgrStruct->pwszTitle,
                                            MB_ICONERROR|MB_OK|MB_APPLMODAL);

                            break;

                        case IDOK:
                        case IDCANCEL:

                                EndDialog(hwndDlg, NULL);
                            break;

                        default:
                            break;
                    }
               }

                //a combo box's selection has been changed
                if(HIWORD(wParam) == CBN_SELCHANGE)
                {
                    switch(LOWORD(wParam))
                    {
                        case    IDC_CERTMGR_PURPOSE_COMBO:
                                //if the purpose is changed, we need to
                                //refresh the list view and certificate's
                                //detailed view
                                RefreshCertListView(hwndDlg, pCertMgrInfo);

                            break;
                    }

                }
            break;

    }

    return FALSE;
}

//--------------------------------------------------------------
//
// Save the advanced option from the registry
//--------------------------------------------------------------
void    SaveAdvValueToReg(CERT_MGR_INFO      *pCertMgrInfo)
{
    HKEY                hKeyExport=NULL;
    HKEY                hKeyPurpose=NULL;
    DWORD               dwDisposition=0;
    DWORD               dwExportFormat=0;
    DWORD               dwIndex=0;
    LPSTR               pszDefaultOID=NULL;
    LPSTR               pszOID=NULL;


    if(NULL==pCertMgrInfo)
        return;

    //open a registry entry for the export format under HKEY_CURRENT_USER
    if (ERROR_SUCCESS == RegCreateKeyExU(
                            HKEY_CURRENT_USER,
                            WSZCertMgrExportRegLocation,
                            0,
                            NULL,
                            REG_OPTION_NON_VOLATILE,
                            KEY_ALL_ACCESS,
                            NULL,
                            &hKeyExport,
                            &dwDisposition))
    {
        //set the value
        switch(pCertMgrInfo->dwExportFormat)
        {
            case CRYPTUI_WIZ_EXPORT_FORMAT_DER:
                    if(pCertMgrInfo->fExportChain)
                        dwExportFormat=4;
                    else
                        dwExportFormat=1;
                break;

            case CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
                    if(pCertMgrInfo->fExportChain)
                        dwExportFormat=5;
                    else
                        dwExportFormat=2;
                break;

            case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
                    if(pCertMgrInfo->fExportChain)
                        dwExportFormat=6;
                    else
                        dwExportFormat=3;
                break;

            default:
                break;
        }


        if(0 != dwExportFormat)
        {
            //set the value
            RegSetValueExU(
                hKeyExport,
                WSZCertMgrExportName,
                0,          // dwReserved
                REG_DWORD,
                (BYTE *) &dwExportFormat,
                sizeof(dwExportFormat));
        }

    }

    //open the registry entry for the advanced OIDs
    dwDisposition=0;

    if (ERROR_SUCCESS == RegCreateKeyExU(
                            HKEY_CURRENT_USER,
                            WSZCertMgrPurposeRegLocation,
                            0,
                            NULL,
                            REG_OPTION_NON_VOLATILE,
                            KEY_ALL_ACCESS,
                            NULL,
                            &hKeyPurpose,
                            &dwDisposition))
    {
        //build a char "," seperated string for simple OID
        pszDefaultOID=(LPSTR)WizardAlloc(sizeof(CHAR));
        if(NULL == pszDefaultOID)
            goto CLEANUP;

        *pszDefaultOID=L'\0';

        for(dwIndex=0; dwIndex<pCertMgrInfo->dwOIDInfo; dwIndex++)
        {
            if(FALSE==(pCertMgrInfo->rgOIDInfo)[dwIndex].fSelected)
            {
                if(strlen(pszDefaultOID)!=0)
                    strcat(pszDefaultOID, ",");

                pszOID=(pCertMgrInfo->rgOIDInfo)[dwIndex].pszOID;

                pszDefaultOID=(LPSTR)WizardRealloc(pszDefaultOID,
                    sizeof(CHAR)*(strlen(pszDefaultOID)+strlen(pszOID)+strlen(",")+1));

                if(NULL==pszDefaultOID)
                    goto CLEANUP;

                strcat(pszDefaultOID,pszOID);
            }
        }

        //set the value
        RegSetValueEx(
            hKeyPurpose,
            SZCertMgrPurposeName,
            0,
            REG_SZ,
            (BYTE *)(pszDefaultOID),
            (strlen(pszDefaultOID) + 1) * sizeof(CHAR));

    }

CLEANUP:

    if(pszDefaultOID)
        WizardFree(pszDefaultOID);

    //close the registry keys
    if(hKeyExport)
        RegCloseKey(hKeyExport);

    if(hKeyPurpose)
        RegCloseKey(hKeyPurpose);

}


//--------------------------------------------------------------
//
// Get init value from the registry
//--------------------------------------------------------------
void    GetInitValueFromReg(CERT_MGR_INFO      *pCertMgrInfo)
{
    HKEY                hKeyExport=NULL;
    HKEY                hKeyPurpose=NULL;
    DWORD               dwType=0;
    DWORD               dwExportFormat=0;
    DWORD               cbExportFormat=0;

    LPSTR               pszDefaultOID=NULL;
    DWORD               cbDefaultOID=0;

    LPSTR               pszTok=NULL;
    DWORD               cTok = 0;
    DWORD               cCount=0;
    CERT_ENHKEY_USAGE   KeyUsage;
    LPSTR               rgBasicOID[]={szOID_PKIX_KP_CLIENT_AUTH,
                                      szOID_PKIX_KP_EMAIL_PROTECTION};
    BOOL                fNoRegData=FALSE;

    if(NULL==pCertMgrInfo)
        return;

    //memset
    memset(&KeyUsage,0,sizeof(CERT_ENHKEY_USAGE));

    //open the registry key if user has saved the advaced options
    if(ERROR_SUCCESS == RegOpenKeyExU(HKEY_CURRENT_USER,
                    WSZCertMgrExportRegLocation,
                    0,
                    KEY_READ,
                    &hKeyExport))
    {
        //get the data
        cbExportFormat=sizeof(dwExportFormat);

        if(ERROR_SUCCESS == RegQueryValueExU(
                        hKeyExport,
                        WSZCertMgrExportName,
                        NULL,
                        &dwType,
                        (BYTE *)&dwExportFormat,
                        &cbExportFormat))
        {
            //      added check for reg_binary because on WIN95 OSR2 when the machine is changed
            //      from mutli-user profiles to single user profile, the registry DWORD values
            //      change to BINARY
            //
	        if ((dwType == REG_DWORD) ||
                (dwType == REG_BINARY))
	        {
                switch(dwExportFormat)
                {
                    case    1:
                            pCertMgrInfo->dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_DER;
                            pCertMgrInfo->fExportChain=FALSE;
                        break;
                    case    2:
                            pCertMgrInfo->dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_BASE64;
                            pCertMgrInfo->fExportChain=FALSE;
                        break;
                    case    3:
                            pCertMgrInfo->dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7;
                            pCertMgrInfo->fExportChain=FALSE;
                        break;
                    case    4:
                            pCertMgrInfo->dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_DER;
                            pCertMgrInfo->fExportChain=TRUE;
                        break;
                    case    5:
                            pCertMgrInfo->dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_BASE64;
                            pCertMgrInfo->fExportChain=TRUE;
                        break;
                    case    6:
                            pCertMgrInfo->dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7;
                            pCertMgrInfo->fExportChain=TRUE;
                        break;
                    default:
                        break;
                }

            }
        }
    }


    //get the advanced purposed
    if(ERROR_SUCCESS == RegOpenKeyExU(HKEY_CURRENT_USER,
                    WSZCertMgrPurposeRegLocation,
                    0,
                    KEY_READ,
                    &hKeyPurpose))
    {
        dwType=0;
        cbDefaultOID=0;

        if((ERROR_SUCCESS == RegQueryValueEx(
                        hKeyPurpose,
                        SZCertMgrPurposeName,
                        NULL,
                        &dwType,
                        NULL,
                        &cbDefaultOID))&&(cbDefaultOID!=0))
        {
            pszDefaultOID=(LPSTR)WizardAlloc(cbDefaultOID);

            if(NULL==pszDefaultOID)
                goto CLEANUP;

            if(ERROR_SUCCESS != RegQueryValueEx(
                        hKeyPurpose,
                        SZCertMgrPurposeName,
                        NULL,
                        &dwType,
                        (BYTE *)pszDefaultOID,
                        &cbDefaultOID))
                goto CLEANUP;

            //
            // Count the number of OIDs as well as converting from comma delimited
            // to NULL character delimited
            //
            if(0==strlen(pszDefaultOID))
                fNoRegData=TRUE;
            else
            {

                pszTok = strtok(pszDefaultOID, ",");
                while ( pszTok != NULL )
                {
                    cTok++;
                    pszTok = strtok(NULL, ",");
                }

                //
                // Allocate a cert enhanced key usage structure and fill it in with
                // the string tokens
                //

                pszTok = pszDefaultOID;
                KeyUsage.cUsageIdentifier = cTok;
                KeyUsage.rgpszUsageIdentifier = (LPSTR *)WizardAlloc(cTok * sizeof(LPSTR));

                if(NULL==KeyUsage.rgpszUsageIdentifier)
                    goto CLEANUP;

                for ( cCount = 0; cCount < cTok; cCount++ )
                {
                    KeyUsage.rgpszUsageIdentifier[cCount] = pszTok;
                    pszTok = pszTok+strlen(pszTok)+1;
                }

            }
        }
    }

    //set up the default OIDs if the registry is empty
    if(0 == KeyUsage.cUsageIdentifier && TRUE != fNoRegData)
    {
        KeyUsage.cUsageIdentifier=2;
        KeyUsage.rgpszUsageIdentifier=rgBasicOID;
    }


    //mark the OIDs as advanced for basic
    for(cCount=0; cCount<pCertMgrInfo->dwOIDInfo; cCount++)
    {
        if(IsAdvancedOID(&KeyUsage,
                         (pCertMgrInfo->rgOIDInfo)[cCount].pszOID))
            (pCertMgrInfo->rgOIDInfo)[cCount].fSelected=TRUE;
    }


CLEANUP:

   //free memory
    if(pszDefaultOID)
    {
        WizardFree(pszDefaultOID);

        if(KeyUsage.rgpszUsageIdentifier)
            WizardFree(KeyUsage.rgpszUsageIdentifier);
    }

    //close the registry keys
    if(hKeyExport)
        RegCloseKey(hKeyExport);

    if(hKeyPurpose)
        RegCloseKey(hKeyPurpose);

    return;
}
//--------------------------------------------------------------
//
//  Parameters:
//      pCryptUICertMgr       IN  Required
//
//
//--------------------------------------------------------------
BOOL
WINAPI
CryptUIDlgCertMgr(
        IN PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr)
{
    BOOL                fResult=FALSE;
    CERT_MGR_INFO       CertMgrInfo;
    HRESULT             hr=S_OK;
    DWORD               dwException=0;

    //check the input parameter
    if(NULL==pCryptUICertMgr)
        goto InvalidArgErr;

    if(sizeof(CRYPTUI_CERT_MGR_STRUCT) != pCryptUICertMgr->dwSize)
        goto InvalidArgErr;

    if ((pCryptUICertMgr->dwFlags & CRYPTUI_CERT_MGR_TAB_MASK) >
            CRYPTUI_CERT_MGR_PUBLISHER_TAB)
        goto InvalidArgErr;

    if (!WizardInit())
    {
        goto InitOIDErr;
    }

    //init struct
    memset(&CertMgrInfo, 0, sizeof(CertMgrInfo));

    CertMgrInfo.pCertMgrStruct=pCryptUICertMgr;

    //get all the enhanced key usage OIDs
    if(!InitPurposeOID(pCryptUICertMgr->pszInitUsageOID,
                       &(CertMgrInfo.dwOIDInfo),
                       &(CertMgrInfo.rgOIDInfo)))
        goto InitOIDErr;

    //init the column sort
    CertMgrInfo.rgdwSortParam[0]=SORT_COLUMN_SUBJECT | SORT_COLUMN_ASCEND;
    CertMgrInfo.rgdwSortParam[1]=SORT_COLUMN_ISSUER | SORT_COLUMN_DESCEND;
    CertMgrInfo.rgdwSortParam[2]=SORT_COLUMN_EXPIRATION | SORT_COLUMN_DESCEND;
    CertMgrInfo.rgdwSortParam[3]=SORT_COLUMN_NAME | SORT_COLUMN_DESCEND;
    CertMgrInfo.rgdwSortParam[4]=SORT_COLUMN_NAME | SORT_COLUMN_DESCEND;

    //we sort the 1st column
    CertMgrInfo.iColumn=0;


    //init the export format
    CertMgrInfo.dwExportFormat=CRYPTUI_WIZ_EXPORT_FORMAT_DER;
    CertMgrInfo.fExportChain=FALSE;
    CertMgrInfo.fAdvOIDChanged=FALSE;

    //init the OLE library

    __try {
        if(!SUCCEEDED(hr=OleInitialize(NULL)))
            goto OLEInitErr;

        //get the initialization from the registry
        GetInitValueFromReg(&CertMgrInfo);

        //call the dialog box
        if (DialogBoxParamU(
                    g_hmodThisDll,
                    (LPCWSTR)(MAKEINTRESOURCE(IDD_CERTMGR_MAIN)),
                    (pCryptUICertMgr->hwndParent != NULL) ? pCryptUICertMgr->hwndParent : GetDesktopWindow(),
                    CertMgrDialogProc,
                    (LPARAM) &CertMgrInfo) == -1)
        {
            OleUninitialize();
            goto DialogBoxErr;
        }


        OleUninitialize();
    } __except(EXCEPTION_EXECUTE_HANDLER) {
        dwException = GetExceptionCode();
        goto ExceptionErr;
    }

    fResult=TRUE;

CommonReturn:

    //free the cert arrays
    FreeCerts(&CertMgrInfo);

    //free the usage OID array
    FreeUsageOID(CertMgrInfo.dwOIDInfo,
                 CertMgrInfo.rgOIDInfo);


    return fResult;

ErrorReturn:

	fResult=FALSE;
	goto CommonReturn;

SET_ERROR(InvalidArgErr, E_INVALIDARG);
TRACE_ERROR(DialogBoxErr);
TRACE_ERROR(InitOIDErr);
SET_ERROR_VAR(OLEInitErr, hr);
SET_ERROR_VAR(ExceptionErr, dwException)

}