clprefsadvanced.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 1,083 行 · 第 1/2 页

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.
	
	CLprefsAdvanced.c - handle PGP advanced preferences dialogs

	$Id: CLprefsAdvanced.c,v 1.32 2002/11/20 16:48:32 pbj Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"

// project header files
#include "PGPclx.h"
#include "CLprefs.h"

#include <shlobj.h>
#include <commdlg.h>

#define	MAX_NUM_ALG				7

#define SMARTCARD_NONE			0
#define SMARTCARD_ALADDIN		1
#define SMARTCARD_GEMPLUS		2
#define SMARTCARD_RAINBOW		3
#define SMARTCARD_SCHLUMBERGER	4
#define SMARTCARD_OTHER			5
#define SMARTCARD_CUSTOM		6


// external globals
extern HINSTANCE g_hInst;

static DWORD aAdvancedIds[] = {			// Help IDs
	IDC_PREFERREDALG,		IDH_PGPCLPREF_PREFERREDALG,
	IDC_ENABLECAST,			IDH_PGPCLPREF_ENABLECAST,
	IDC_ENABLEAES,			IDH_PGPCLPREF_ENABLEAES,
	IDC_ENABLE3DES,			IDH_PGPCLPREF_ENABLE3DES,
	IDC_ENABLEIDEA,			IDH_PGPCLPREF_ENABLEIDEA,
	IDC_ENABLETWOFISH,		IDH_PGPCLPREF_ENABLETWOFISH,
	IDC_DISPMARGVALIDITY,	IDH_PGPCLPREF_DISPMARGVALIDITY,
	IDC_MARGVALIDISINVALID,	IDH_PGPCLPREF_WARNONMARGINAL,
	IDC_WARNONADK,			IDH_PGPCLPREF_WARNONADK,
	IDC_EXPORTCOMPATIBLE,	IDH_PGPCLPREF_EXPORTCOMPATIBLE,
	IDC_EXPORTCOMPLETE,		IDH_PGPCLPREF_EXPORTCOMPLETE,
	IDC_SMARTCARD,			IDH_PGPCLPREF_SMARTCARDDRIVER,
	IDC_AUTOBACKUP,			IDH_PGPCLPREF_ENABLEAUTOBACKUP,
	IDC_USEKEYRINGFOLDER,	IDH_PGPCLPREF_BACKUPTOKEYRINGFOLDER,
	IDC_BACKUPTO,			IDH_PGPCLPREF_BACKUPFOLDER,
	IDC_BACKUPFOLDER,		IDH_PGPCLPREF_BACKUPFOLDER,
	IDC_BACKUPBROWSE,		IDH_PGPCLPREF_BROWSEBACKUPFOLDER,
    0,0
};

static DWORD aSmartCardDllIds[] = {		// Help IDs
	IDC_DLLFILENAME,		IDH_PGPCLPREF_SMARTCARDDRIVEROTHER,
	IDC_BROWSE,				IDH_PGPCLPREF_SMARTCARDDRIVERBROWSE,
	0,0
};

//	_____________________________________________________
//
//  Initialize preferred algorithm combo box on basis of
//	enabled algorithms

static VOID
sInitPreferredAlgComboBox (
		HWND	hwnd, 
		UINT	uInit) 
{
	INT		iIdx, iPrevAlg;
	CHAR	sz[32];
	UINT	uIndex;

	if (uInit) 
		iPrevAlg = uInit;
	else {
		iIdx = SendDlgItemMessage (hwnd, IDC_PREFERREDALG,
									CB_GETCURSEL, 0, 0);
		if (iIdx != CB_ERR)
			iPrevAlg = SendDlgItemMessage (hwnd, IDC_PREFERREDALG,
									CB_GETITEMDATA, iIdx, 0);
		else
			iPrevAlg = kPGPCipherAlgorithm_None;
	}
	SendDlgItemMessage (hwnd, IDC_PREFERREDALG, CB_RESETCONTENT, 0, 0);

	iIdx = -1;

	// put item into combobox for each enabled algorithm
	if (IsDlgButtonChecked (hwnd, IDC_ENABLEAES) == BST_CHECKED) {
		LoadString (g_hInst, IDS_AES, sz, sizeof(sz));
		uIndex = SendDlgItemMessage (hwnd, IDC_PREFERREDALG,
								CB_ADDSTRING, 0, (LPARAM)sz);
		if (uIndex != CB_ERR)
			SendDlgItemMessage (hwnd, IDC_PREFERREDALG, CB_SETITEMDATA,
				uIndex, (LPARAM)kPGPCipherAlgorithm_AES256);
		if (iPrevAlg == kPGPCipherAlgorithm_AES256) iIdx = uIndex;
	}

	if (IsDlgButtonChecked (hwnd, IDC_ENABLECAST) == BST_CHECKED) {
		LoadString (g_hInst, IDS_CAST, sz, sizeof(sz));
		uIndex = SendDlgItemMessage (hwnd, IDC_PREFERREDALG,
								CB_ADDSTRING, 0, (LPARAM)sz);
		if (uIndex != CB_ERR)
			SendDlgItemMessage (hwnd, IDC_PREFERREDALG, CB_SETITEMDATA,
				uIndex, (LPARAM)kPGPCipherAlgorithm_CAST5);
		if (iPrevAlg == kPGPCipherAlgorithm_CAST5) iIdx = uIndex;
	}
	// switched above two AES/CAST -wjb

	if (IsDlgButtonChecked (hwnd, IDC_ENABLE3DES) == BST_CHECKED) {
		LoadString (g_hInst, IDS_3DES, sz, sizeof(sz));
		uIndex = SendDlgItemMessage (hwnd, IDC_PREFERREDALG,
								CB_ADDSTRING, 0, (LPARAM)sz);
		if (uIndex != CB_ERR)
			SendDlgItemMessage (hwnd, IDC_PREFERREDALG, CB_SETITEMDATA,
				uIndex, (LPARAM)kPGPCipherAlgorithm_3DES);
		if (iPrevAlg == kPGPCipherAlgorithm_3DES) iIdx = uIndex;
	}

	if (IsDlgButtonChecked (hwnd, IDC_ENABLEIDEA) == BST_CHECKED) {
		LoadString (g_hInst, IDS_IDEA, sz, sizeof(sz));
		uIndex = SendDlgItemMessage (hwnd, IDC_PREFERREDALG,
								CB_ADDSTRING, 0, (LPARAM)sz);
		if (uIndex != CB_ERR)
			SendDlgItemMessage (hwnd, IDC_PREFERREDALG, CB_SETITEMDATA,
				uIndex, (LPARAM)kPGPCipherAlgorithm_IDEA);
		if (iPrevAlg == kPGPCipherAlgorithm_IDEA) iIdx = uIndex;
	}

	if (IsDlgButtonChecked (hwnd, IDC_ENABLETWOFISH) == BST_CHECKED) {
		LoadString (g_hInst, IDS_TWOFISH, sz, sizeof(sz));
		uIndex = SendDlgItemMessage (hwnd, IDC_PREFERREDALG,
								CB_ADDSTRING, 0, (LPARAM)sz);
		if (uIndex != CB_ERR)
			SendDlgItemMessage (hwnd, IDC_PREFERREDALG, CB_SETITEMDATA,
				uIndex, (LPARAM)kPGPCipherAlgorithm_Twofish256);
		if (iPrevAlg == kPGPCipherAlgorithm_Twofish256) iIdx = uIndex;
	}

	if (iIdx < 0) iIdx = 0;
	SendDlgItemMessage (hwnd, IDC_PREFERREDALG, CB_SETCURSEL, iIdx, 0);

}


//	_______________________________________________
//
//  set the prefs string based on the just selected index

static INT 
sGetSmartCardIndexFromString (
		LPSTR	pszPath)
{
	INT		ilen	= lstrlen (pszPath);

	if (ilen == 0)
		return SMARTCARD_NONE;

	if (ilen >= 9)
	{
		if (lstrcmpi (&pszPath[ilen-9], "SLBck.dll") == 0)
			return SMARTCARD_SCHLUMBERGER;
	}

	if (ilen >= 11)
	{
		if (lstrcmpi (&pszPath[ilen-11], "PK2priv.dll") == 0)
			return SMARTCARD_GEMPLUS;

		if (lstrcmpi (&pszPath[ilen-11], "DKck232.dll") == 0)
			return SMARTCARD_RAINBOW;
	}

	if (ilen >= 12)
	{
		if (lstrcmpi (&pszPath[ilen-12], "eTpkcs11.dll") == 0)
			return SMARTCARD_ALADDIN;
	}

	return SMARTCARD_CUSTOM;
}


//	____________________________________
//
//  let user browse to DLL file

static BOOL
sBrowseDLL (
		HWND	hwnd,
		LPSTR	pszFile,
		INT		iLen)
{
	CHAR			szInitDir[MAX_PATH];
	CHAR			szFilter[128];
	CHAR			szTitle[128];
	CHAR			szDefExt[16];
	OPENFILENAME	ofn;
	CHAR*			p;

	LoadString (g_hInst, IDS_DRIVERFILECAPTION, szTitle, sizeof(szTitle));
	LoadString (g_hInst, IDS_DRIVERFILEEXT, szDefExt, sizeof(szDefExt));
	LoadString (g_hInst, IDS_DRIVERFILEFILTER, szFilter, sizeof(szFilter));

	while (p = strrchr (szFilter, '@')) *p = '\0';

	if (pszFile[0])
		lstrcpy (szInitDir, pszFile);
	else
		GetSystemDirectory (szInitDir, sizeof(szInitDir));

	p = strrchr (szInitDir, '\\');
	if (p)
		*p = '\0';

	ofn.lStructSize			= sizeof (ofn);
	ofn.hwndOwner			= hwnd;
	ofn.hInstance			= (HANDLE)g_hInst;
	ofn.lpstrFilter			= szFilter;
	ofn.lpstrCustomFilter	= (LPTSTR)NULL;
	ofn.nMaxCustFilter		= 0L;
	ofn.nFilterIndex		= 1L;
	ofn.lpstrFile			= pszFile;
	ofn.nMaxFile			= iLen;
	ofn.lpstrFileTitle		= NULL;
	ofn.nMaxFileTitle		= 0;
	ofn.lpstrInitialDir		= szInitDir;
	ofn.lpstrTitle			= szTitle;
	ofn.Flags				=	OFN_HIDEREADONLY|
								OFN_FILEMUSTEXIST|
								OFN_PATHMUSTEXIST|
								OFN_NOCHANGEDIR;
	ofn.nFileOffset			= 0;
	ofn.nFileExtension		= 0;
	ofn.lpstrDefExt			= szDefExt;
	ofn.lCustData			= 0;

	return (GetOpenFileName (&ofn));
}


//	_______________________________________________
//
//  set the prefs string based on the just selected index

static LRESULT WINAPI
sSmartCardDllDlgProc (
		HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam)
{
	switch (uMsg) {

	case WM_INITDIALOG:
		SetWindowLong (hwnd, GWL_USERDATA, lParam);
		SetDlgItemText (hwnd, IDC_DLLFILENAME, (CHAR*)lParam);
		return TRUE;

	case WM_HELP :
	case WM_CONTEXTMENU :
		return PGPclHtmlHelp (hwnd, uMsg, wParam, lParam, 
				(char*)kPGPclHelpFile, aSmartCardDllIds);

	case WM_COMMAND :
		switch (LOWORD (wParam)) {
		case IDOK :
		{
			LPSTR	psz;

			psz = (LPSTR)GetWindowLong (hwnd, GWL_USERDATA);
			GetDlgItemText (hwnd, IDC_DLLFILENAME, psz, MAX_PATH);

			if (!strchr (psz, '.'))
				lstrcat (psz, ".dll");

			EndDialog (hwnd, 1);
			break;
		}

		case IDCANCEL :
			EndDialog (hwnd, 0);
			break;

		case IDC_BROWSE :
		{
			CHAR	sz[MAX_PATH];

			sz[0] = '\0';
			GetDlgItemText (hwnd, IDC_DLLFILENAME, sz, sizeof(sz));
			if (sBrowseDLL (hwnd, sz, sizeof(sz)))
				SetDlgItemText (hwnd, IDC_DLLFILENAME, sz);

			break;
		}
		}
		break;
	}

	return FALSE;
}


//	_______________________________________________
//
//  set the prefs string based on the just selected index

static BOOL 
sSelectSmartCard (
		HWND			hwnd,
		PPREFSDLGSTRUCT	ppds,
		INT				index)
{
	BOOL	bReturn		= TRUE;

	switch (index) {
	case SMARTCARD_CUSTOM :
		break;

	case SMARTCARD_ALADDIN :
		lstrcpy (ppds->szSmartCardDriver, "eTpkcs11.dll");
		break;

	case SMARTCARD_GEMPLUS :
		lstrcpy (ppds->szSmartCardDriver, "PK2priv.dll");
		break;

	case SMARTCARD_RAINBOW :
		lstrcpy (ppds->szSmartCardDriver, "DKck232.dll");
		break;

	case SMARTCARD_SCHLUMBERGER :
		lstrcpy (ppds->szSmartCardDriver, "SLBck.dll");
		break;

	case SMARTCARD_OTHER :
		bReturn = (BOOL)DialogBoxParam (g_hInst, 
				MAKEINTRESOURCE(IDD_SMARTCARDDLL), hwnd, 
				sSmartCardDllDlgProc, (LPARAM)ppds->szSmartCardDriver);
		break;

	default :
		ppds->szSmartCardDriver[0] = '\0';
		break;
	}

	return bReturn;
}


//	_______________________________________________
//
//  browse folder callback function used to set initial folder location

static INT CALLBACK 
sBrowseCallbackProc (
		HWND	hwnd, 
		UINT	uMsg, 
		LPARAM	lParam, 
		LPARAM	lpData)
{
	if (uMsg == BFFM_INITIALIZED)
	{
		CHAR	sz[MAX_PATH];
		UINT	ulen;

		GetWindowText ((HWND)lpData, sz, sizeof(sz));
		ulen = lstrlen (sz);

		if (sz[ulen-1] == '\\')
			sz[ulen-1] = '\0';

		SendMessage (hwnd, BFFM_SETSELECTION, TRUE, (LPARAM)sz);
	}

	return 0;
}

 
//	_____________________________________________________
//
//  allow user to browse for backup folder

static VOID
sBrowseForBackupFolder (
		HWND	hwnd)
{
	BROWSEINFO				bi;
	LPITEMIDLIST			pidl;
	LPMALLOC				pMalloc;
	CHAR					sz[128];
	CHAR					szFolder[MAX_PATH];

	// get task allocator
	if (SHGetMalloc (&pMalloc) != NOERROR)
		return;

	// get prompt string
	LoadString (g_hInst, IDS_SELECTBACKUPFOLDER, sz, sizeof(sz));

	// load initial string
	GetDlgItemText (hwnd, IDC_BACKUPFOLDER, szFolder, sizeof(szFolder));

	// initialize structure
	bi.hwndOwner = hwnd;
	bi.pidlRoot = NULL;
	bi.pszDisplayName = szFolder;
	bi.lpszTitle = sz;
	bi.ulFlags = BIF_RETURNONLYFSDIRS;
	bi.lpfn = sBrowseCallbackProc;
	bi.lParam = (LPARAM)GetDlgItem (hwnd, IDC_BACKUPFOLDER);

	// allow user to browse
	pidl = SHBrowseForFolder (&bi);
	if (pidl == NULL)
		return;
	SHGetPathFromIDList (pidl, szFolder);
	pMalloc->lpVtbl->Free(pMalloc, pidl);

	// set folder to that selected
	SetDlgItemText (hwnd, IDC_BACKUPFOLDER, szFolder);
}


//	_____________________________________________________
//
//  Message processing function for property sheet dialog

LRESULT WINAPI
CLAdvancedPropDlgProc (
		HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam)
{
	PPREFSDLGSTRUCT			ppds;

	switch (uMsg) {

	case WM_INITDIALOG:
	{
		PGPBoolean			b, b1;
		PGPCipherAlgorithm	nAlg;
		PGPPrefArray*		pprefArray;
		PGPError			err;
		UINT				u, uNumAlgs;
		CHAR				sz[MAX_PATH];
		PGPPrefRef			prefref;

		SetWindowLong (hwnd, GWL_USERDATA, ((PROPSHEETPAGE*)lParam)->lParam);
		ppds = (PPREFSDLGSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		ppds->bSmartCardExpirationWarned = FALSE;

		if (ppds->bNeedsCentering) 
		{
			PGPclCenterWindowOnMonitor (GetParent (hwnd), kPGPclWindowMonitor);
			ppds->bNeedsCentering = FALSE;
		}

		prefref = CLGetPrefRef (ppds);

		// enable checkboxes of those ciphers supported by SDK
		err =
			PGPclCheckSDKSupportForCipherAlg (kPGPCipherAlgorithm_CAST5);
		if (IsntPGPError (err))
			EnableWindow (GetDlgItem (hwnd, IDC_ENABLECAST), TRUE);
		err =
			PGPclCheckSDKSupportForCipherAlg (kPGPCipherAlgorithm_AES256);
		if (IsntPGPError (err))
			EnableWindow (GetDlgItem (hwnd, IDC_ENABLEAES), TRUE);
		err =
			PGPclCheckSDKSupportForCipherAlg (kPGPCipherAlgorithm_3DES);
		if (IsntPGPError (err))
			EnableWindow (GetDlgItem (hwnd, IDC_ENABLE3DES), TRUE);
		err =
			PGPclCheckSDKSupportForCipherAlg (kPGPCipherAlgorithm_IDEA);
		if (IsntPGPError (err))
			EnableWindow (GetDlgItem (hwnd, IDC_ENABLEIDEA), TRUE);
		err =
			PGPclCheckSDKSupportForCipherAlg (kPGPCipherAlgorithm_Twofish256);
		if (IsntPGPError (err))
			EnableWindow (GetDlgItem (hwnd, IDC_ENABLETWOFISH), TRUE);

		// check boxes of enabled algorithms
		pprefArray = NULL;
		PGPGetPrefArray (prefref, kPGPPrefAllowedAlgorithmsList,
							  &pprefArray);
		uNumAlgs = pprefArray->numElements;

		for (u=0; u<uNumAlgs; u++) 
		{
			nAlg = (PGPCipherAlgorithm) pprefArray->elements[u].data;
			err = PGPclCheckSDKSupportForCipherAlg (nAlg);
			if (IsntPGPError (err)) 
			{
				switch (nAlg) {
				case kPGPCipherAlgorithm_CAST5 :
					CheckDlgButton (hwnd, IDC_ENABLECAST, BST_CHECKED);
					break;

				case kPGPCipherAlgorithm_AES256 :
					CheckDlgButton (hwnd, IDC_ENABLEAES, BST_CHECKED);
					break;

				case kPGPCipherAlgorithm_3DES :
					CheckDlgButton (hwnd, IDC_ENABLE3DES, BST_CHECKED);
					break;

				case kPGPCipherAlgorithm_IDEA :
					CheckDlgButton (hwnd, IDC_ENABLEIDEA, BST_CHECKED);
					break;

				case kPGPCipherAlgorithm_Twofish256 :
					CheckDlgButton (hwnd, IDC_ENABLETWOFISH, BST_CHECKED);
					break;
				}
			}
		}
		if (pprefArray) 
			PGPFreePrefArray (pprefArray);

		CLDisablePrefControl (hwnd, IDC_ENABLECAST, 
				ppds, prefref, kPGPPrefAllowedAlgorithmsList);
		CLDisablePrefControl (hwnd, IDC_ENABLEAES, 
				ppds, prefref, kPGPPrefAllowedAlgorithmsList);
		CLDisablePrefControl (hwnd, IDC_ENABLE3DES, 
				ppds, prefref, kPGPPrefAllowedAlgorithmsList);
		CLDisablePrefControl (hwnd, IDC_ENABLEIDEA, 
				ppds, prefref, kPGPPrefAllowedAlgorithmsList);
		CLDisablePrefControl (hwnd, IDC_ENABLETWOFISH, 
				ppds, prefref, kPGPPrefAllowedAlgorithmsList);

		// initialize preferred algorithm
		PGPGetPrefNumber (prefref, kPGPPrefPreferredAlgorithm, &u);
		sInitPreferredAlgComboBox (hwnd, u);

		CLDisablePrefControl (hwnd, IDC_PREFERREDALG, 
				ppds, prefref, kPGPPrefPreferredAlgorithm);

		// initialize trust model preferences
		CLLoadCheckBoxPref (hwnd, IDC_DISPMARGVALIDITY,
				ppds, prefref, kPGPPrefDisplayMarginalValidity);