//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1997 - 1999
//
//  File:       selcert.cpp
//
//--------------------------------------------------------------------------

#include "global.hxx"
#include <dbgdef.h>

extern HINSTANCE        HinstDll;
extern HMODULE          HmodRichEdit;

#define MAX_SIZE_OF_COLUMNS 400

static const HELPMAP helpmap[] = {
    {IDC_SELECTCERT_VIEWCERT_BUTTON,IDH_SELECTCERTIFICATE_VIEWCERT_BUTTON},
    {IDC_SELECTCERT_CERTLIST,       IDH_SELECTCERTIFICATE_CERTIFICATE_LIST}
};


class CertContextList { 
public: 
    CertContextList() : m_head(NULL) { }
    ~CertContextList(); 

    HRESULT Add(IN  PCCERT_CONTEXT pCertContext, 
		OUT BOOL           *pfReplacedExisting) ;

    HRESULT SyncWithStore(HCERTSTORE hStore, DWORD dwFlags); 

private:
    typedef struct _CertContextListEle { 
	PCCERT_CONTEXT               pCertContext; 
	struct _CertContextListEle * pNext; 
    } CertContextListEle; 

    CertContextListEle * m_head; 
};

typedef struct _CERT_SELECT_HELPER
{
    PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc;
    PCCERT_CONTEXT                      pSelectedCert;
    DWORD                               rgdwSortParam[6];
    BOOL                                fCertListDblClick;
    CertContextList                    *pCertsFromDS; 
} CERT_SELECT_HELPER, *PCERT_SELECT_HELPER;


//////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////

static void AddCertToList(HWND hWndListView, PCERT_SELECT_HELPER pviewhelp, PCCERT_CONTEXT pCertContext, int itemIndex)
{
    LPWSTR                                  pwszText;
    DWORD                                   cbText;
    WCHAR                                   szText[CRYPTUI_MAX_STRING_SIZE];
    int                                     subItemIndex;
    LV_ITEMW                                lvI;
    PCCRYPTUI_SELECTCERTIFICATE_STRUCTW     pcsc;

    pcsc = pviewhelp->pcsc;

    //
    // set up the fields in the list view item
    //
    lvI.mask = LVIF_PARAM | LVIF_STATE | LVIF_IMAGE;
    lvI.state = 0;
    lvI.stateMask = 0;
    lvI.iSubItem = 0;
    lvI.iImage = 0;
    lvI.lParam = (LPARAM) CertDuplicateCertificateContext(pCertContext);
    lvI.iItem = itemIndex;
    ListView_InsertItemU(hWndListView, &lvI);

    subItemIndex = 0;

    //
    // issued to
    //
    if (!(pcsc->dwDontUseColumn & CRYPTUI_SELECT_ISSUEDTO_COLUMN))
    {
        CertGetNameStringW(
                pCertContext,
                CERT_NAME_SIMPLE_DISPLAY_TYPE,
                0,//CERT_NAME_ISSUER_FLAG,
                NULL,
                szText,
                ARRAYSIZE(szText));
        ListView_SetItemTextU(hWndListView, itemIndex , subItemIndex++, szText);
    }

    //
    // issued by
    //
    if (!(pcsc->dwDontUseColumn & CRYPTUI_SELECT_ISSUEDBY_COLUMN))
    {
        CertGetNameStringW(
                pCertContext,
                CERT_NAME_SIMPLE_DISPLAY_TYPE,
                CERT_NAME_ISSUER_FLAG,
                NULL,
                szText,
                ARRAYSIZE(szText));
        ListView_SetItemTextU(hWndListView, itemIndex , subItemIndex++, szText);
    }

    //
    // intended use
    //
    if (!(pcsc->dwDontUseColumn & CRYPTUI_SELECT_INTENDEDUSE_COLUMN))
    {
        if (FormatEnhancedKeyUsageString(&pwszText, pCertContext, FALSE, FALSE))
        {
            ListView_SetItemTextU(hWndListView, itemIndex , subItemIndex, pwszText);
            free(pwszText);
        }
        subItemIndex++;
    }

    //
    // friendly name
    //
    if (!(pcsc->dwDontUseColumn & CRYPTUI_SELECT_FRIENDLYNAME_COLUMN))
    {
        cbText = 0;
        if (CertGetCertificateContextProperty(  pCertContext,
                                                CERT_FRIENDLY_NAME_PROP_ID,
                                                NULL,
                                                &cbText)                    &&
           (NULL != (pwszText = (LPWSTR) malloc(cbText))))
        {
            CertGetCertificateContextProperty(  pCertContext,
                                                CERT_FRIENDLY_NAME_PROP_ID,
                                                pwszText,
                                                &cbText);
            ListView_SetItemTextU(hWndListView, itemIndex , subItemIndex++, pwszText);
            free(pwszText);
        }
        else
        {
            LoadStringU(HinstDll, IDS_FRIENDLYNAME_NONE, szText, ARRAYSIZE(szText));
            ListView_SetItemTextU(hWndListView, itemIndex , subItemIndex++, szText);
        }
    }

    //
    // expiration
    //
    if (!(pcsc->dwDontUseColumn & CRYPTUI_SELECT_EXPIRATION_COLUMN))
    {
        if (!FormatDateString(&pwszText, pCertContext->pCertInfo->NotAfter, FALSE, FALSE, hWndListView))
        {
            LoadStringU(HinstDll, IDS_NOTAVAILABLE, szText, ARRAYSIZE(szText));
            ListView_SetItemTextU(hWndListView, itemIndex , subItemIndex++, szText);
        }
        else
        {
            ListView_SetItemTextU(hWndListView, itemIndex , subItemIndex++, pwszText);
            free(pwszText);
        }
    }

    //
    // location
    //
    if (!(pcsc->dwDontUseColumn & CRYPTUI_SELECT_LOCATION_COLUMN))
    {
        pwszText = (LPWSTR) GetStoreName(pCertContext->hCertStore, TRUE);
        if (pwszText == NULL)
        {
            LoadStringU(HinstDll, IDS_NOTAVAILABLE, szText, ARRAYSIZE(szText));
            ListView_SetItemTextU(hWndListView, itemIndex , subItemIndex++, szText);
        }
        else
        {
            ListView_SetItemTextU(hWndListView, itemIndex , subItemIndex++, pwszText);
            free(pwszText);
        }
    }
}


static int ReplaceCertInList(HWND hWndListView, PCERT_SELECT_HELPER pviewhelp, PCCERT_CONTEXT pCertContext)
{
    int     nIndex = -1; 
    LV_ITEM lvitem; 

    while (-1 != (nIndex = ListView_GetNextItem(hWndListView, nIndex, LVNI_ALL)))
    {
        //DSIE: Bug 420717
        memset(&lvitem, 0, sizeof(lvitem));

        lvitem.iItem = nIndex; 
        lvitem.mask  = LVIF_PARAM; 
        if (ListView_GetItem(hWndListView, &lvitem))
        {
            PCCERT_CONTEXT pCurrent = (PCCERT_CONTEXT)lvitem.lParam; 
            if (pCurrent->dwCertEncodingType == pCertContext->dwCertEncodingType)
            {
                if (CertCompareCertificate(pCertContext->dwCertEncodingType, 
                                           pCertContext->pCertInfo, 
                                           pCurrent->pCertInfo))
                {
                    // Found a match, replace the certificate. 
                    CertFreeCertificateContext(pCurrent); 
                    ListView_DeleteItem(hWndListView, nIndex); 
                    // Now, add our new certificate at this index. 
                    AddCertToList(hWndListView, pviewhelp, pCertContext, nIndex);
                    goto CommonReturn; 
                }
            }
        }
    }
		    
    // No match, nothing to replace, just append to the list. 
    AddCertToList(hWndListView, pviewhelp, pCertContext, ListView_GetItemCount(hWndListView)); 
    
CommonReturn: 
    return nIndex; 
}


// DSIE: Bug 207106
BOOL SupportEncryptedFileSystem(PCCERT_CONTEXT pCertContext)
{
    BOOL                fSuccess = FALSE;
    DWORD               cbUsage  = 0;
    PCERT_ENHKEY_USAGE  pUsage   = NULL;

    if (!pCertContext)
        return FALSE;

    if (!CertGetEnhancedKeyUsage(pCertContext, 0, NULL, &cbUsage))
        goto CleanUp;

    if (NULL == (pUsage = (PCERT_ENHKEY_USAGE) malloc(cbUsage)))
        goto CleanUp;

    if (!CertGetEnhancedKeyUsage(pCertContext, 0, pUsage, &cbUsage))
        goto CleanUp;

    if (0 == pUsage->cUsageIdentifier)
    {
        if (CRYPT_E_NOT_FOUND == GetLastError())
        {
            fSuccess = TRUE;
        }
    }
    else
    {
        for (DWORD i = 0; i < pUsage->cUsageIdentifier; i++)
        {
            if (0 == strcmp(szOID_ENHANCED_KEY_USAGE, pUsage->rgpszUsageIdentifier[i]))
            {
                fSuccess = TRUE;
                goto CleanUp;
            }
        }
    }

CleanUp:
    if (pUsage)
        free(pUsage);

    return fSuccess;
}


//DSIE: Bug 314005. Major change to switch over to use Object Picker.
HRESULT AddFromDS(HWND hwndDlg, PCERT_SELECT_HELPER pviewhelp)
{
    static const int     SCOPE_INIT_COUNT = 1;
    IDsObjectPicker    * pDsObjectPicker  = NULL;
    IDataObject        * pdo              = NULL;
    DSOP_SCOPE_INIT_INFO aScopeInit[SCOPE_INIT_COUNT];
    DSOP_INIT_INFO       InitInfo;
    UINT                 cfDsObjectPicker = RegisterClipboardFormat(CFSTR_DSOP_DS_SELECTION_LIST);
    HWND                 hWndListView     = NULL; 

    BOOL                 fGotStgMedium    = FALSE;
    PDS_SELECTION_LIST   pDsSelList       = NULL;
    STGMEDIUM            stgmedium        = {TYMED_HGLOBAL, NULL, NULL};
    FORMATETC            formatetc        = {(CLIPFORMAT) cfDsObjectPicker, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};

    HRESULT              hr;
    HCERTSTORE           hDSCertStore     = NULL; 

    PCCERT_CONTEXT       pCertContext     = NULL; 
    PCCERT_CONTEXT       pCertContextPrev = NULL;     
    CertContextList    * pCertContextList = NULL; 

    WCHAR                errorString[512]; 
    WCHAR                errorTitle[512]; 
    BOOL                 fInitialSelectedCert = FALSE;
    PCCRYPTUI_SELECTCERTIFICATE_STRUCTW  pcsc = NULL;

    // Input validation: 
    if (NULL == hwndDlg         || 
	    NULL == pviewhelp       || 
	    NULL == pviewhelp->pcsc || 
	    NULL == pviewhelp->pCertsFromDS)
	return E_INVALIDARG; 

    // Init: 
    pcsc             = pviewhelp->pcsc; 
    pCertContextList = pviewhelp->pCertsFromDS; 
    hWndListView = GetDlgItem(hwndDlg, IDC_SELECTCERT_CERTLIST);

    CoInitialize(NULL);
    hr = CoCreateInstance(CLSID_DsObjectPicker,
                          NULL,
                          CLSCTX_INPROC_SERVER,
                          IID_IDsObjectPicker,
                          (void **) &pDsObjectPicker);
    if (FAILED(hr) || NULL == pDsObjectPicker)
	    goto ComError; 
 
    // Initialize the DSOP_SCOPE_INIT_INFO array.
    ZeroMemory(aScopeInit, sizeof(DSOP_SCOPE_INIT_INFO) * SCOPE_INIT_COUNT);
 
    // Combine multiple scope types in a single array entry.
    aScopeInit[0].cbSize = sizeof(DSOP_SCOPE_INIT_INFO);
    aScopeInit[0].flType = DSOP_SCOPE_TYPE_UPLEVEL_JOINED_DOMAIN
                         | DSOP_SCOPE_TYPE_DOWNLEVEL_JOINED_DOMAIN;
 
    // Set uplevel and downlevel filters to include only computer objects.
    // Uplevel filters apply to both mixed and native modes.
    // Notice that the uplevel and downlevel flags are different.
    aScopeInit[0].FilterFlags.Uplevel.flBothModes = DSOP_FILTER_USERS;
    aScopeInit[0].FilterFlags.flDownlevel = DSOP_DOWNLEVEL_FILTER_USERS;
 
    // Initialize the DSOP_INIT_INFO structure.
    ZeroMemory(&InitInfo, sizeof(InitInfo));
    InitInfo.cbSize = sizeof(InitInfo);
    InitInfo.pwzTargetComputer = NULL;  // Target is the local computer.
    InitInfo.cDsScopeInfos = SCOPE_INIT_COUNT;
    InitInfo.aDsScopeInfos = aScopeInit;
    //InitInfo.flOptions = DSOP_FLAG_MULTISELECT;
 
    // You can call Initialize multiple times; last call wins.
    // Note that object picker makes its own copy of InitInfo.
    hr = pDsObjectPicker->Initialize(&InitInfo);
    if (FAILED(hr))
        goto ComError;

    // Invoke the modal dialog.
    hr = pDsObjectPicker->InvokeDialog(hwndDlg, &pdo);
    if (FAILED(hr)) 
        goto ComError;

    // User pressed Cancel.
    if (hr == S_FALSE)
    {
        hr = E_ABORT;
        goto cleanup;
    }
 
    // Get the global memory block containing the user's selections.
    hr = pdo->GetData(&formatetc, &stgmedium);
    if (FAILED(hr)) 
        goto ComError;
    
    fGotStgMedium = TRUE;
 
    // Retrieve pointer to DS_SELECTION_LIST structure.
    pDsSelList = (PDS_SELECTION_LIST) GlobalLock(stgmedium.hGlobal);
    if (!pDsSelList) 
        goto ComError;
 
    // Loop through DS_SELECTION array of selected objects.
    for (ULONG i = 0; i < pDsSelList->cItems; i++) 
    {
	    WCHAR  pwszLdapUrl[2048]; 
        LPWSTR pTemp = pDsSelList->aDsSelection[i].pwzADsPath;
	    
	    BOOL   fReplacedExisting; 
	    BOOL   fHasEFSCerts = FALSE; 

        // Now is the time to get the certificate
	    LPCWSTR szCertAttr = L"?userCertificate"; 
	    
	    // Check if our buffer is too small to hold the query.  
	    if (wcslen(pTemp) + wcslen(szCertAttr) + 1 > (sizeof(pwszLdapUrl) / sizeof(pwszLdapUrl[0])))
		    goto UnexpectedErr; 

	    wcscpy(pwszLdapUrl, pTemp);
	    wcscat(pwszLdapUrl, szCertAttr);
	    
        // Now open the DS store using LDAP provider.
	    hDSCertStore = CertOpenStore(sz_CERT_STORE_PROV_LDAP,
		                             X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
		                             NULL,
		                             CERT_STORE_READONLY_FLAG,
		                             (void*) pwszLdapUrl);
	    if (NULL == hDSCertStore)
		    goto CertCliError; 
    
	    // We get the certificate store
	    pCertContext     = NULL; 
	    pCertContextPrev = NULL; 
	    int            nItemIndex;

	    while (NULL != (pCertContext = CertEnumCertificatesInStore(hDSCertStore, pCertContextPrev)))
	    {
		    // Apply our filter callback function to see if we should display this certificate. 
	        BOOL fAllowCert = FALSE;
            
            if (pcsc->pFilterCallback)
                fAllowCert = (*(pcsc->pFilterCallback))(pCertContext, &fInitialSelectedCert, pcsc->pvCallbackData);

            fAllowCert |= SupportEncryptedFileSystem(pCertContext); 

		    if (fAllowCert) 
            {
		        fHasEFSCerts = TRUE; 

		        if (S_OK != (hr = pCertContextList->Add(pCertContext, &fReplacedExisting)))
			        goto ErrorReturn; 

		        nItemIndex = ReplaceCertInList(hWndListView, pviewhelp, pCertContext); 

		        // if the select cert dialog caller said that this should be the initially
		        // selected cert then make it so.
		        if (fInitialSelectedCert)
			        ListView_SetItemState(hWndListView, nItemIndex, LVIS_SELECTED, LVIS_SELECTED);
		    }
		    
		    pCertContextPrev = pCertContext; 
	    }

	    // We didn't reach the end of the enumeration.  This is an error. 
	    if (GetLastError() != CRYPT_E_NOT_FOUND)
		    goto CertCliError; 

	    // We didn't find any EFS certs: display an error message and pop up the window again. 
	    if (!fHasEFSCerts)
		    goto NoEfsError; 
    }
 
    hr = S_OK;

 cleanup: 
    if (hDSCertStore)        
    { 
        CertCloseStore(hDSCertStore, 0); 
    } 

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

    if (pDsSelList)
    {
        GlobalUnlock(stgmedium.hGlobal);
    }

    if (fGotStgMedium)
    {
        ReleaseStgMedium(&stgmedium); 
    }

    if (pdo)
    {
        pdo->Release();
    }

    if (pDsObjectPicker)
    {
        pDsObjectPicker->Release();
    }

    CoUninitialize();

    return hr;

 ErrorReturn: 
    { 
        WCHAR wszText[MAX_STRING_SIZE]; 
        WCHAR errorTitle2[MAX_STRING_SIZE]; 
        LPWSTR pwszErrorMsg = NULL; 

        //get the text string
        if(LoadStringU(HinstDll, IDS_INTERNAL_ERROR, wszText, sizeof(wszText) / sizeof(wszText[0])))
        {
            if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                               FORMAT_MESSAGE_FROM_SYSTEM |
                               FORMAT_MESSAGE_IGNORE_INSERTS,
                               NULL,
                               hr,
                               MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                               (LPWSTR) &pwszErrorMsg,
                               0,
                               NULL))
            {
                if (LoadStringU(HinstDll, IDS_SELECT_CERTIFICATE_TITLE, errorTitle2, ARRAYSIZE(errorTitle2))) { 
                        MessageBoxU(hwndDlg, pwszErrorMsg, errorTitle2, MB_ICONERROR|MB_OK|MB_APPLMODAL);
                }
            }
        }
        
        if (NULL != pwszErrorMsg) { LocalFree(pwszErrorMsg); } 
    }
    goto cleanup; 

 CertCliError: 
    hr = HRESULT_FROM_WIN32(GetLastError()); 
    goto ErrorReturn; 

 ComError:
    goto ErrorReturn; 

 NoEfsError:
    LoadStringU(HinstDll, IDS_SELECT_CERT_NO_CERT_ERROR, errorString, ARRAYSIZE(errorString));
    if (pcsc->szTitle != NULL)
    {
	    MessageBoxU(hwndDlg, errorString, pcsc->szTitle, MB_OK | MB_ICONWARNING);
    }
    else
    {
	    LoadStringU(HinstDll, IDS_SELECT_CERTIFICATE_TITLE, errorTitle, ARRAYSIZE(errorTitle));
	    MessageBoxU(hwndDlg, errorString, errorTitle, MB_OK | MB_ICONWARNING);
    }
    hr = AddFromDS(hwndDlg, pviewhelp); 
    goto cleanup; 

 UnexpectedErr:
    hr = E_UNEXPECTED; 
    goto ErrorReturn; 
}


//////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////
static void AddCertsToList(HWND hWndListView, PCERT_SELECT_HELPER pviewhelp)
{
    DWORD                               i;
    PCCERT_CONTEXT                      pCertContext;
    int                                 itemIndex = 0;
    PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc;
    BOOL                                fInitialSelectedCert = FALSE;

    pcsc = pviewhelp->pcsc;

    //
    // loop for each store and display the certs in each store
    //
    for (i=0; i<pcsc->cDisplayStores; i++)
    {
        //
        // loop for each cert in the store
        //
        pCertContext = NULL;
        while (NULL != (pCertContext = CertEnumCertificatesInStore(pcsc->rghDisplayStores[i], pCertContext)))
        {
            fInitialSelectedCert = FALSE;

            if ((pcsc->pFilterCallback == NULL) ||
                ((*(pcsc->pFilterCallback))(pCertContext, &fInitialSelectedCert, pcsc->pvCallbackData) == TRUE))
            {
                AddCertToList(hWndListView, pviewhelp, pCertContext, itemIndex);

                //
                // if the select cert dialog caller said that this should be the initially
                // selected cert then make it so.
                //
                if (fInitialSelectedCert)
                {
                    ListView_SetItemState(hWndListView, itemIndex, LVIS_SELECTED, LVIS_SELECTED);
                }

                itemIndex++;
            }
        }
    }
}


//////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////
static int CalculateColumnWidth(DWORD dwDontUseColumn)
{
    int numColumns = 0;

    if (!(dwDontUseColumn & CRYPTUI_SELECT_ISSUEDTO_COLUMN))
    {
        numColumns++;
    }

    if (!(dwDontUseColumn & CRYPTUI_SELECT_ISSUEDBY_COLUMN))
    {
        numColumns++;
    }

    if (!(dwDontUseColumn & CRYPTUI_SELECT_INTENDEDUSE_COLUMN))
    {
        numColumns++;
    }

    if (!(dwDontUseColumn & CRYPTUI_SELECT_FRIENDLYNAME_COLUMN))
    {
        numColumns++;
    }

    if (!(dwDontUseColumn & CRYPTUI_SELECT_EXPIRATION_COLUMN))
    {
        numColumns++;
    }

    if (!(dwDontUseColumn & CRYPTUI_SELECT_LOCATION_COLUMN))
    {
        numColumns++;
    }

    if (numColumns >= 2)
    {
        return (MAX_SIZE_OF_COLUMNS / numColumns);
    }
    else
    {
        return MAX_SIZE_OF_COLUMNS;
    }
}


//////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////
INT_PTR APIENTRY SelectCertDialogProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    WCHAR                               szText[CRYPTUI_MAX_STRING_SIZE];
    HWND                                hWndListView;
    LV_COLUMNW                          lvC;
    int                                 iCol = 0;
    LV_ITEMW                            lvI;
    int                                 listIndex;
    LPNMLISTVIEW                        pnmv;
    PCERT_SELECT_HELPER                 pviewhelp;
    PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc;
    WCHAR                               errorString[CRYPTUI_MAX_STRING_SIZE];
    WCHAR                               errorTitle[CRYPTUI_MAX_STRING_SIZE];
    HWND                                hwnd;
    HIMAGELIST                          hIml;
    DWORD                               dwSortParam;
    int                                 SortParamIndex;

    switch ( msg ) {

    case WM_INITDIALOG:
        pviewhelp = (PCERT_SELECT_HELPER) lParam;
        SetWindowLongPtr(hwndDlg, DWLP_USER, (DWORD_PTR) pviewhelp);
        pcsc = pviewhelp->pcsc;

        //
        // set the dialog title and the display string
        //
        if (pcsc->szTitle != NULL)
        {
            SetWindowTextU(hwndDlg, pcsc->szTitle);
        }

        if (pcsc->szDisplayString != NULL)
        {
            SetDlgItemTextU(hwndDlg, IDC_SELECTCERT_DISPLAYSTRING, pcsc->szDisplayString);
        }
        else
        {
            if (pcsc->dwFlags & CRYPTUI_SELECTCERT_MULTISELECT)
            {
                LoadStringU(HinstDll, IDS_SELECT_MULTIPLE_CERT_DEFAULT, szText, ARRAYSIZE(szText));
            }
            else
            {
                LoadStringU(HinstDll, IDS_SELECT_CERT_DEFAULT, szText, ARRAYSIZE(szText));
            }
            SetDlgItemTextU(hwndDlg, IDC_SELECTCERT_DISPLAYSTRING, szText);
        }

        hWndListView = GetDlgItem(hwndDlg, IDC_SELECTCERT_CERTLIST);

        //
        // initialize the image list for the list view
        //
        hIml = ImageList_LoadImage(HinstDll, MAKEINTRESOURCE(IDB_CERT), 0, 1, RGB(255,0,255), IMAGE_BITMAP, 0);
        ListView_SetImageList(hWndListView, hIml, LVSIL_SMALL);

        //
        // add the colums to the list view
        //

        lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT;// | LVCF_SUBITEM;
        lvC.fmt = LVCFMT_LEFT;  // Left-align the column.
        lvC.pszText = szText;   // The text for the column.
        lvC.cx = CalculateColumnWidth(pviewhelp->pcsc->dwDontUseColumn);

        memset(&(pviewhelp->rgdwSortParam[0]), 0, ARRAYSIZE(pviewhelp->rgdwSortParam));
        SortParamIndex = 0;

        if (!(pviewhelp->pcsc->dwDontUseColumn & CRYPTUI_SELECT_ISSUEDTO_COLUMN))
        {
            LoadStringU(HinstDll, IDS_ISSUEDTO2, szText, ARRAYSIZE(szText));
            if (ListView_InsertColumnU(hWndListView, iCol++, &lvC) == -1)
            {
                // error
            }

            pviewhelp->rgdwSortParam[SortParamIndex++] = SORT_COLUMN_SUBJECT | SORT_COLUMN_ASCEND;
        }

        if (!(pviewhelp->pcsc->dwDontUseColumn & CRYPTUI_SELECT_ISSUEDBY_COLUMN))
        {
            LoadStringU(HinstDll, IDS_ISSUEDBY2, szText, ARRAYSIZE(szText));
            if (ListView_InsertColumnU(hWndListView, iCol++, &lvC) == -1)
            {
                // error
            }

            pviewhelp->rgdwSortParam[SortParamIndex++] = SORT_COLUMN_ISSUER | SORT_COLUMN_DESCEND;
        }

        if (!(pviewhelp->pcsc->dwDontUseColumn & CRYPTUI_SELECT_INTENDEDUSE_COLUMN))
        {
            LoadStringU(HinstDll, IDS_INTENDED_PURPOSE, szText, ARRAYSIZE(szText));
            if (ListView_InsertColumnU(hWndListView, iCol++, &lvC) == -1)
            {
                // error
            }

            pviewhelp->rgdwSortParam[SortParamIndex++] =SORT_COLUMN_PURPOSE | SORT_COLUMN_DESCEND;
        }

        if (!(pviewhelp->pcsc->dwDontUseColumn & CRYPTUI_SELECT_FRIENDLYNAME_COLUMN))
        {
            LoadStringU(HinstDll, IDS_CERTIFICATE_NAME, szText, ARRAYSIZE(szText));
            if (ListView_InsertColumnU(hWndListView, iCol++, &lvC) == -1)
            {
                // error
            }

            pviewhelp->rgdwSortParam[SortParamIndex++] = SORT_COLUMN_NAME | SORT_COLUMN_DESCEND;
        }

        if (!(pviewhelp->pcsc->dwDontUseColumn & CRYPTUI_SELECT_EXPIRATION_COLUMN))
        {
            LoadStringU(HinstDll, IDS_EXPIRATION_DATE, szText, ARRAYSIZE(szText));
            if (ListView_InsertColumnU(hWndListView, iCol++, &lvC) == -1)
            {
                // error
            }

            pviewhelp->rgdwSortParam[SortParamIndex++] = SORT_COLUMN_EXPIRATION | SORT_COLUMN_DESCEND;
        }

        if (!(pviewhelp->pcsc->dwDontUseColumn & CRYPTUI_SELECT_LOCATION_COLUMN))
        {
            LoadStringU(HinstDll, IDS_LOCATION, szText, ARRAYSIZE(szText));
            if (ListView_InsertColumnU(hWndListView, iCol++, &lvC) == -1)
            {
                // error
            }

            pviewhelp->rgdwSortParam[SortParamIndex++] = SORT_COLUMN_LOCATION | SORT_COLUMN_DESCEND; 
        }

        AddCertsToList(hWndListView, pviewhelp);

        //
        // if there is no cert selected initially disable the "view cert button"
        //
        if (ListView_GetSelectedCount(hWndListView) == 0)
        {
            EnableWindow(GetDlgItem(hwndDlg, IDC_SELECTCERT_VIEWCERT_BUTTON), FALSE);
        }

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

#if (1) // DSIE: bug 338852.
        HWND hwndFindUser;

        if (hwndFindUser = GetDlgItem(hwndDlg, IDC_SELECTCERT_ADDFROMDS_BUTTON))
        {
            LPBYTE pDCName = NULL;

            DWORD dwError = NetGetDCName(NULL, NULL, &pDCName);

            if (NERR_Success == dwError)
            {
                NetApiBufferFree(pDCName);
            }
            else
            {
                EnableWindow(hwndFindUser, FALSE);
            }
        }
#endif
        
        ListView_SetItemState(hWndListView,
                              0,
                              LVIS_FOCUSED | LVIS_SELECTED,
                              LVIS_FOCUSED | LVIS_SELECTED);
        SetFocus(hWndListView); 

        break;

    case WM_NOTIFY:
        pviewhelp = (PCERT_SELECT_HELPER) GetWindowLongPtr(hwndDlg, DWLP_USER);
        pcsc = pviewhelp->pcsc;

        hWndListView = GetDlgItem(hwndDlg, IDC_SELECTCERT_CERTLIST);

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

        case NM_DBLCLK:

            switch (((NMHDR FAR *) lParam)->idFrom)
            {
            case IDC_SELECTCERT_CERTLIST:

                if (IsWindowEnabled(GetDlgItem(hwndDlg, IDC_SELECTCERT_VIEWCERT_BUTTON)))
                {
                    pviewhelp->fCertListDblClick = TRUE;

                    SendMessage(
                            hwndDlg,
                            WM_COMMAND,
                            MAKELONG(IDC_SELECTCERT_VIEWCERT_BUTTON, BN_CLICKED),
                            (LPARAM) GetDlgItem(hwndDlg, IDC_SELECTCERT_VIEWCERT_BUTTON));
                }
                break;
            }

            break;

        case LVN_ITEMCHANGING:

            pnmv = (LPNMLISTVIEW) lParam;

            switch (((NMHDR FAR *) lParam)->idFrom)
            {
            case IDC_SELECTCERT_CERTLIST:

                if (!(pcsc->dwFlags & CRYPTUI_SELECTCERT_MULTISELECT))
                {
                    if (pnmv->uNewState & LVIS_SELECTED)
                    {
                        ListView_SetItemState(
                            hWndListView,
                            ListView_GetNextItem(hWndListView, -1, LVNI_SELECTED),
                            ~LVIS_SELECTED,
                            LVIS_SELECTED);
                    
                        EnableWindow(GetDlgItem(hwndDlg, IDC_SELECTCERT_VIEWCERT_BUTTON), TRUE);
                    }
                }

                break;
            }

            break;

        case LVN_ITEMCHANGED:
    
            pnmv = (LPNMLISTVIEW) lParam;

            switch (((NMHDR FAR *) lParam)->idFrom)
            {
            case IDC_SELECTCERT_CERTLIST:

                if (ListView_GetSelectedCount(hWndListView) == 1)
                {
                    EnableWindow(GetDlgItem(hwndDlg, IDC_SELECTCERT_VIEWCERT_BUTTON), TRUE);
                }
                else
                {
                    EnableWindow(GetDlgItem(hwndDlg, IDC_SELECTCERT_VIEWCERT_BUTTON), FALSE);
                }                
            }
                
            break;

        case  NM_SETFOCUS:

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

            case IDC_SELECTCERT_CERTLIST:
                hWndListView = GetDlgItem(hwndDlg, IDC_SELECTCERT_CERTLIST);

                if ((ListView_GetItemCount(hWndListView) != 0) && 
                    (ListView_GetNextItem(hWndListView, -1, LVNI_SELECTED) == -1))
                {
                    memset(&lvI, 0, sizeof(lvI));
                    lvI.mask = LVIF_STATE; 
                    lvI.iItem = 0;
                    lvI.state = LVIS_FOCUSED;
                    lvI.stateMask = LVIS_FOCUSED;
                    ListView_SetItem(hWndListView, &lvI);
                }

                break;
            }
            
            break;

        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:
                case 5:
                        dwSortParam = pviewhelp->rgdwSortParam[pnmv->iSubItem];
                    break;
                default:
                        dwSortParam = 0;
                    break;
            }

            if (0 != dwSortParam)
            {
                //
                // 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_SELECTCERT_CERTLIST,
                    LVM_SORTITEMS,
                    (WPARAM) (LPARAM) dwSortParam,
                    (LPARAM) (PFNLVCOMPARE)CompareCertificate);

                pviewhelp->rgdwSortParam[pnmv->iSubItem] = dwSortParam;
            }

            break;

        }

        break;

    case WM_COMMAND:
        pviewhelp = (PCERT_SELECT_HELPER) GetWindowLongPtr(hwndDlg, DWLP_USER);
        pcsc = pviewhelp->pcsc;

        hWndListView = GetDlgItem(hwndDlg, IDC_SELECTCERT_CERTLIST);

        switch (LOWORD(wParam))
        {

	case IDC_SELECTCERT_ADDFROMDS_BUTTON:
	    { 
		HRESULT hr = AddFromDS(hwndDlg, pviewhelp); 
		if (FAILED(hr))
		{
		    // Error
		}
		break; 
	    }

        case IDC_SELECTCERT_VIEWCERT_BUTTON:
            CRYPTUI_VIEWCERTIFICATE_STRUCTW cvps;
            BOOL                            fPropertiesChanged;

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

            if (listIndex != -1)
            {
                memset(&lvI, 0, sizeof(lvI));
                lvI.iItem = listIndex;
                lvI.mask = LVIF_PARAM;
                if (ListView_GetItemU(hWndListView, &lvI))
                {
                    //
                    // if the caller handed in a callback call them to see if they
                    // want to handle the display of the cert, otherwise display the cert
                    //
                    if ((pcsc->pDisplayCallback != NULL) &&
                        ((*(pcsc->pDisplayCallback))((PCCERT_CONTEXT) lvI.lParam, hwndDlg, pcsc->pvCallbackData) == TRUE))
                    {
                        //
                        // set the fPropertiesChanged bool to true so that the cert will
                        // get refreshed in the display.  this doesn't hurt anything even
                        // if the cert didn't change
                        //
                        fPropertiesChanged = TRUE;
                    }
                    else
                    {
                        memset(&cvps, 0, sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCTW));
                        cvps.dwSize = sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCTW);
                        cvps.hwndParent = hwndDlg;
                        cvps.pCertContext = (PCCERT_CONTEXT) lvI.lParam;
                        cvps.cStores = pviewhelp->pcsc->cStores;
                        cvps.rghStores = pviewhelp->pcsc->rghStores;
                        cvps.cPropSheetPages = pviewhelp->pcsc->cPropSheetPages;
                        cvps.rgPropSheetPages = pviewhelp->pcsc->rgPropSheetPages;
                        CryptUIDlgViewCertificateW(&cvps, &fPropertiesChanged);
                    }

                    //
                    // if the properties changed then refresh the cert in the list
                    //
                    if (fPropertiesChanged)
                    {
                        ListView_DeleteItem(hWndListView, listIndex);
                        AddCertToList(hWndListView, pviewhelp, (PCCERT_CONTEXT) lvI.lParam, listIndex);
                        ListView_SetItemState(hWndListView, listIndex, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
                    }

                    if (!pviewhelp->fCertListDblClick)
                    {
                        SetFocus(GetDlgItem(hwndDlg, IDC_SELECTCERT_VIEWCERT_BUTTON));
                    }

                    pviewhelp->fCertListDblClick = FALSE;
                }
            }

            break;

        case IDOK:
            listIndex = ListView_GetNextItem(
                                hWndListView, 		
                                -1, 		
                                LVNI_SELECTED		
                                );	

            if (listIndex != -1)
            {
                memset(&lvI, 0, sizeof(lvI));
                lvI.iItem = listIndex;
                lvI.mask = LVIF_PARAM;
                
                if (!(pcsc->dwFlags & CRYPTUI_SELECTCERT_MULTISELECT))
		{
                    if (ListView_GetItemU(hWndListView, &lvI))
                    {
                        pviewhelp->pSelectedCert = CertDuplicateCertificateContext((PCCERT_CONTEXT) lvI.lParam);
                    }
                }
                else 
                {
                    if (ListView_GetItemU(hWndListView, &lvI))
                    {
                        CertAddCertificateContextToStore(
                                pcsc->hSelectedCertStore,
                                (PCCERT_CONTEXT) lvI.lParam,
                                CERT_STORE_ADD_ALWAYS,
                                NULL);
                    }

                    while (-1 != (listIndex = ListView_GetNextItem(
                                                    hWndListView, 		
                                                    listIndex, 		
                                                    LVNI_SELECTED		
                                                    )))
                    {
                        lvI.iItem = listIndex;
                        if (ListView_GetItemU(hWndListView, &lvI))
                        {
                            CertAddCertificateContextToStore(
                                    pcsc->hSelectedCertStore,
                                    (PCCERT_CONTEXT) lvI.lParam,
                                    CERT_STORE_ADD_ALWAYS,
                                    NULL);
                        }
                    }
                }
            }
            else
            {
                LoadStringU(HinstDll, IDS_SELECT_CERT_ERROR, errorString, ARRAYSIZE(errorString));
                if (pcsc->szTitle != NULL)
                {
                    MessageBoxU(hwndDlg, errorString, pcsc->szTitle, MB_OK | MB_ICONWARNING);
                }
                else
                {
                    LoadStringU(HinstDll, IDS_SELECT_CERTIFICATE_TITLE, errorTitle, ARRAYSIZE(errorTitle));
                    MessageBoxU(hwndDlg, errorString, errorTitle, MB_OK | MB_ICONWARNING);
                }
                SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LRESULT)TRUE);
                return TRUE;
            }

            EndDialog(hwndDlg, NULL);
            break;

        case IDCANCEL:
            EndDialog(hwndDlg, NULL);
            break;
        }

        break;

    case WM_DESTROY:
        pviewhelp = (PCERT_SELECT_HELPER) GetWindowLongPtr(hwndDlg, DWLP_USER);
        hWndListView = GetDlgItem(hwndDlg, IDC_SELECTCERT_CERTLIST);

        memset(&lvI, 0, sizeof(lvI));
        lvI.iItem = ListView_GetItemCount(hWndListView) - 1;	
        lvI.mask = LVIF_PARAM;
        while (lvI.iItem >= 0)
        {
            if (ListView_GetItemU(hWndListView, &lvI))
            {
                CertFreeCertificateContext((PCCERT_CONTEXT) lvI.lParam);
            }
            lvI.iItem--;
        }
        
        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, IDOK))                             &&
            (hwnd != GetDlgItem(hwndDlg, IDCANCEL))                         &&
            (hwnd != GetDlgItem(hwndDlg, IDC_SELECTCERT_VIEWCERT_BUTTON))   &&
            (hwnd != GetDlgItem(hwndDlg, IDC_SELECTCERT_CERTLIST)))
        {
            SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LRESULT)TRUE);
            return TRUE;
        }
        else
        {
            return OnContextHelp(hwndDlg, msg, wParam, lParam, helpmap);
        }
    }

    return FALSE;
}


//////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////
PCCERT_CONTEXT
WINAPI
CryptUIDlgSelectCertificateW(
            PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc
            )
{
    CERT_SELECT_HELPER viewhelper;
    WORD               wDialogID; 

    if (CommonInit() == FALSE)
    {
        return NULL;
    }

    if ((pcsc->dwSize != sizeof(CRYPTUI_SELECTCERTIFICATE_STRUCTW)) &&
        (pcsc->dwSize != offsetof(CRYPTUI_SELECTCERTIFICATE_STRUCTW, hSelectedCertStore))) {
        SetLastError(E_INVALIDARG);
        return FALSE;
    }
    
    wDialogID = 
      pcsc->dwFlags & CRYPTUI_SELECTCERT_ADDFROMDS ? 
      IDD_SELECTCERT_DIALOG_WITH_DSPICKER          : 
      IDD_SELECTCERT_DIALOG; 

    viewhelper.pcsc              = pcsc;
    viewhelper.pSelectedCert     = NULL;
    viewhelper.fCertListDblClick = FALSE;
    viewhelper.pCertsFromDS      = new CertContextList; 
    if (NULL == viewhelper.pCertsFromDS)
    {
	SetLastError(E_OUTOFMEMORY); 
	return FALSE;
    }

    if (DialogBoxParamU(
                HinstDll,
                (LPWSTR) MAKEINTRESOURCE(wDialogID),
                (pcsc->hwndParent != NULL) ? pcsc->hwndParent : GetDesktopWindow(),
                SelectCertDialogProc,
                (LPARAM) &viewhelper) != -1)
    {
        SetLastError(0);
    }

    delete viewhelper.pCertsFromDS; 

    if (pcsc->dwFlags & CRYPTUI_SELECTCERT_MULTISELECT)
    {
        return NULL;
    }
    else
    {
        return(viewhelper.pSelectedCert);
    }
}


//////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////
PCCERT_CONTEXT
WINAPI
CryptUIDlgSelectCertificateA(
            PCCRYPTUI_SELECTCERTIFICATE_STRUCTA pcsc
            )
{
    CRYPTUI_SELECTCERTIFICATE_STRUCTW   cscW;
    PCCERT_CONTEXT                      pReturnCert = NULL;

    memcpy(&cscW, pcsc, sizeof(cscW));
    
    if (!ConvertToPropPageW(
                pcsc->rgPropSheetPages,
                pcsc->cPropSheetPages,
                &(cscW.rgPropSheetPages)))
    {
        return NULL;
    }

    if (pcsc->szTitle)
    {
        cscW.szTitle = CertUIMkWStr(pcsc->szTitle);
    }

    if (pcsc->szDisplayString)
    {
        cscW.szDisplayString = CertUIMkWStr(pcsc->szDisplayString);
    }

    pReturnCert = CryptUIDlgSelectCertificateW(&cscW);

    FreePropSheetPagesW((LPPROPSHEETPAGEW) cscW.rgPropSheetPages, cscW.cPropSheetPages);

    if (cscW.szTitle)
    {
        free((void *) cscW.szTitle);
    }

    if (cscW.szDisplayString)
    {
        free((void *) cscW.szDisplayString);
    }

    return(pReturnCert);
}

////////////////////////////////////////////////////////////
//
// Implementation of utility class:  CertContextList
//
////////////////////////////////////////////////////////////

CertContextList::~CertContextList()
{
    CertContextListEle  *pListEle;
    CertContextListEle  *pListEleNext;

    for (pListEle = m_head; pListEle != NULL; pListEle = pListEleNext)
    {
	pListEleNext = pListEle->pNext; 
	if (pListEle->pCertContext != NULL) { CertFreeCertificateContext(pListEle->pCertContext); } 
	delete pListEle; 
    }
}
    
HRESULT CertContextList::Add(IN  PCCERT_CONTEXT pCertContext, 
			     OUT BOOL           *pfReplacedExisting) 
{ 
    HRESULT               hr = S_OK; 
    CertContextListEle   *pListEle = NULL; 
    CertContextListEle   *pListElePrev = NULL; 

    if (pCertContext == NULL || pfReplacedExisting == NULL) 
	return E_INVALIDARG; 
    
    for (pListEle = m_head; pListEle != NULL; pListEle = pListEle->pNext)
    {
	PCCERT_CONTEXT pCurrent = pListEle->pCertContext; 

	if (pCurrent->dwCertEncodingType == pCertContext->dwCertEncodingType)
	{
	    if (CertCompareCertificate
		(pCertContext->dwCertEncodingType, 
		 pCertContext->pCertInfo,
		 pCurrent->pCertInfo))
	    {
		// We're replacing an existing element.  
		*pfReplacedExisting = TRUE; 
		CertFreeCertificateContext(pListEle->pCertContext); 
		pListEle->pCertContext = CertDuplicateCertificateContext(pCertContext); 
		goto CommonReturn; 
	    }
	}

	pListElePrev = pListEle;
    }
    
    // Didn't find the cert in the list, append it.
    if (pListElePrev == NULL)
    {
	// Special case: this is the first cert we've added.  
	pListElePrev = new CertContextListEle; 
	if (pListElePrev == NULL)
	    goto MemoryErr; 
	pListEle = pListElePrev; 
	m_head = pListEle; 
    }
    else
    {
	pListElePrev->pNext = new CertContextListEle; 
	if (pListElePrev->pNext == NULL)
	    goto MemoryErr; 
	pListEle = pListElePrev->pNext; 
    }

    pListEle->pCertContext = CertDuplicateCertificateContext(pCertContext); 
    pListEle->pNext        = NULL; 

 CommonReturn: 
    return hr; 

 MemoryErr: 
    hr = E_OUTOFMEMORY; 
    goto CommonReturn;
}

HRESULT CertContextList::SyncWithStore(HCERTSTORE hStore, DWORD dwFlags)
{
    CertContextListEle * pListEle; 

    for (pListEle = m_head; pListEle != NULL; pListEle = pListEle->pNext)
    {
	if (!CertAddCertificateContextToStore
	    (hStore, 
	     pListEle->pCertContext, 
	     dwFlags, 
	     NULL))
	    return HRESULT_FROM_WIN32(GetLastError()); 
    }

    return S_OK; 
}