clprefs.c

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1998 Network Associates, Inc.
	All rights reserved.
	
	CLprefs.c - handle PGP preferences dialogs
	

	$Id: CLprefs.c,v 1.77 1999/05/18 19:41:35 pbj Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"
#include <direct.h>
#include <shlobj.h>

// project header files
#include "pgpclx.h"
#include "pgpClientLib.h"
#include "pgpHotKeys.h"
#include "pgpTrayIPC.h"

// system header files
#include <commdlg.h>

#define ENABLE_TWOFISH			FALSE

#define MAXCACHETIMELIMIT		360000
#define MAXWIPEPASSES			32

#define PREFSEMAPHORENAME	("PGPprefsInstSem")

// default preferences
#define DEFAULT_ENCRYPTTOSELF			FALSE
#define DEFAULT_DECRYPTCACHEENABLE		TRUE
#define DEFAULT_DECRYPTCACHESECONDS		120
#define DEFAULT_SIGNCACHEENABLE			FALSE
#define DEFAULT_SIGNCACHESECONDS		120
#define DEFAULT_USEFASTKEYGEN			TRUE
#define	DEFAULT_WIPECONFIRM				TRUE
#define DEFAULT_MAILENCRYPTPGPMIME		FALSE
#define DEFAULT_USESECUREVIEWER			FALSE
#define DEFAULT_WORDWRAPWIDTH			70
#define DEFAULT_WORDWRAPENABLE			TRUE
#define DEFAULT_MAILENCRYPTDEFAULT		FALSE
#define DEFAULT_MAILSIGNDEFAULT			FALSE
#define DEFAULT_AUTODECRYPT				FALSE
#define DEFAULT_KEYSERVERSYNCONUNKNOWN	FALSE
#define DEFAULT_KEYSERVERSYNCONADDNAME	FALSE
#define DEFAULT_KEYSERVERSYNCONKEYSIGN	FALSE
#define DEFAULT_KEYSERVERSYNCONREVOKE	FALSE
#define DEFAULT_KEYSERVERSYNCONVERIFY	FALSE
#define DEFAULT_PREFERREDALGORITHM		kPGPCipherAlgorithm_CAST5
#define DEFAULT_DISPLAYMARGVALIDITY		TRUE
#define DEFAULT_MARGVALIDISINVALID		TRUE
#define DEFAULT_WARNONADK				TRUE
#define DEFAULT_WIPEPASSES				1
#define DEFAULT_EXPORTCOMPATIBLE		TRUE

#define COMMENTBLOCK_MAX_LENGTH			60

// external globals
extern HINSTANCE g_hInst;
extern CHAR g_szHelpFile[MAX_PATH];

// local globals
static PGPContextRef	ContextRef;

static HWND				hWndParent;
static HWND				hWndTree;
static HWND				hWndFocus;
static PGPKeySetRef		keysetMain;
static PGPError			returnErr;
static BOOL				bNeedsCentering;
static BOOL				bPrefsWritten;
static BOOL				bReloadKeyring;
static BOOL				bKeyserverPrefsWritten;
static BOOL				bUrlModified;
static BOOL				bRevUrlModified;
static PGPPrefRef		PrefRefClient;
static PGPPrefRef		PrefRefAdmin;
static CHAR				szInitDir[MAX_PATH];

typedef struct {
	PGPKeyRef	keyCert;
	PGPSigRef	sigCert;
} CAPREFSSTRUCT, *PCAPREFSSTRUCT;

typedef struct {
	HWND		hwndDecryptDuration;
	SYSTEMTIME	stDecryptDuration;
	HWND		hwndSignDuration;
	SYSTEMTIME	stSignDuration;
} CACHEDURATIONSTRUCT, *PCACHEDURATIONSTRUCT;


static DWORD aGeneralIds[] = {			// Help IDs
    IDC_ENCRYPTTOSELF,		IDH_PGPCLPREF_ENCRYPTTOSELF, 
	IDC_USEFASTKEYGEN,		IDH_PGPCLPREF_USEFASTKEYGEN,
	IDC_DECRYPTCACHEENABLE,	IDH_PGPCLPREF_PASSCACHEENABLE,
	IDC_DECRYPTCACHETIME,	IDH_PGPCLPREF_PASSCACHETIME,
	IDC_SIGNCACHEENABLE,	IDH_PGPCLPREF_SIGNCACHEENABLE,
	IDC_SIGNCACHETIME,		IDH_PGPCLPREF_SIGNCACHETIME,
	IDC_COMMENTBLOCK,		IDH_PGPCLPREF_COMMENTBLOCK,
	IDC_WIPECONFIRM,		IDH_PGPCLPREF_WIPECONFIRM,
	IDC_NUMPASSES,			IDH_PGPCLPREF_NUMWIPEPASSES,
	IDC_NUMPASSESSPIN,		IDH_PGPCLPREF_NUMWIPEPASSESSPIN,
	IDC_NUMPASSESTEXT,		IDH_PGPCLPREF_NUMWIPEPASSES,
	0,0
};

static DWORD aFileIds[] = {			// Help IDs
    IDC_PRIVATEKEYRING,		IDH_PGPCLPREF_PRIVATEKEYRING, 
	IDC_SETPRIVATEKEYRING,	IDH_PGPCLPREF_BROWSEPRIVATEKEYRING,
    IDC_PUBLICKEYRING,		IDH_PGPCLPREF_PUBLICKEYRING, 
	IDC_SETPUBLICKEYRING,	IDH_PGPCLPREF_BROWSEPUBLICKEYRING,
	IDC_RNGSEEDFILE,		IDH_PGPCLPREF_RANDOMSEEDFILE,
	IDC_SETRNGSEEDFILE,		IDH_PGPCLPREF_BROWSERANDOMSEEDFILE,
	0,0
};

static DWORD aEmailIds[] = {			// Help IDs
	IDC_USEPGPMIME,			IDH_PGPCLPREF_USEPGPMIME,
	IDC_ENCRYPTBYDEFAULT,	IDH_PGPCLPREF_ENCRYPTBYDEFAULT,
	IDC_SIGNBYDEFAULT,		IDH_PGPCLPREF_SIGNBYDEFAULT,
	IDC_AUTODECRYPT,		IDH_PGPCLPREF_AUTODECRYPT,
	IDC_USESECUREVIEWER,	IDH_PGPCLPREF_ALWAYSUSESECUREVIEWER,
	IDC_WRAPENABLE,			IDH_PGPCLPREF_WORDWRAPENABLE,
	IDC_WRAPNUMBER,			IDH_PGPCLPREF_WORDWRAPCOLUMN,
	0,0
};

static DWORD aHotkeyIds[] = {			// Help IDs
	IDC_ENABLEPURGECACHE,	IDH_PGPCLPREF_ENABLEPURGEHOTKEY,
	IDC_PURGEHOTKEY,		IDH_PGPCLPREF_PURGEHOTKEY,
	IDC_ENABLEENCRYPT,		IDH_PGPCLPREF_ENABLEENCRYPTHOTKEY,
	IDC_ENCRYPTHOTKEY,		IDH_PGPCLPREF_ENCRYPTHOTKEY,
	IDC_ENABLESIGN,			IDH_PGPCLPREF_ENABLESIGNHOTKEY,
	IDC_SIGNHOTKEY,			IDH_PGPCLPREF_SIGNHOTKEY,
	IDC_ENABLEENCRYPTSIGN,	IDH_PGPCLPREF_ENABLEESHOTKEY,
	IDC_ENCRYPTSIGNHOTKEY,	IDH_PGPCLPREF_ENCRYPTSIGNHOTKEY,
	IDC_ENABLEDECRYPT,		IDH_PGPCLPREF_ENABLEDECRYPTHOTKEY,
	IDC_DECRYPTHOTKEY,		IDH_PGPCLPREF_DECRYPTHOTKEY,
	0,0
};

static DWORD aServerIds[] = {			// Help IDs
	IDC_NEWKEYSERVER,		IDH_PGPCLPREF_CREATESERVER,
	IDC_REMOVEKEYSERVER,	IDH_PGPCLPREF_REMOVESERVER,
	IDC_EDITKEYSERVER,		IDH_PGPCLPREF_EDITSERVER,
	IDC_SETASROOT,			IDH_PGPCLPREF_SETROOTSERVER,
	IDC_MOVEUP,				IDH_PGPCLPREF_MOVESERVERUP,
	IDC_MOVEDOWN,			IDH_PGPCLPREF_MOVESERVERDOWN,
	IDC_SYNCONUNKNOWN,		IDH_PGPCLPREF_SYNCONUNKNOWNKEYS,
	IDC_SYNCONADDNAME,		IDH_PGPCLPREF_SYNCONADDNAME,
	IDC_SYNCONKEYSIGN,		IDH_PGPCLPREF_SYNCONSIGN,
	IDC_SYNCONREVOKE,		IDH_PGPCLPREF_SYNCONREVOKE,
	IDC_SYNCONVERIFY,		IDH_PGPCLPREF_SYNCONVERIFY,
	IDC_KSTREELIST,			IDH_PGPCLPREF_SERVERLIST,
	0,0
};

static DWORD aCAIds[] = {			// Help IDs
	IDC_URL,				IDH_PGPCLPREF_CAURL,
	IDC_REVURL,				IDH_PGPCLPREF_CAREVOCATIONURL,
	IDC_TYPE,				IDH_PGPCLPREF_CATYPE,
	IDC_ROOTCERT,			IDH_PGPCLPREF_CAROOTCERT,
	IDC_CLEARCERT,			IDH_PGPCLPREF_CACLEARROOTCERT,
	IDC_SETCERT,			IDH_PGPCLPREF_CASELECTROOTCERT,
    0,0 
}; 

static DWORD aAdvancedIds[] = {			// Help IDs
	IDC_PREFERREDALG,		IDH_PGPCLPREF_PREFERREDALG,
	IDC_ENABLECAST,			IDH_PGPCLPREF_ENABLECAST,
	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,
    0,0 
}; 


//	______________________________________________
//
//  create the specified path if it doesn't already exist

static BOOL
sCreatePath (
		LPSTR	pszPath)
{
	DWORD	dw;
	LPSTR	p;

	dw = GetFileAttributes (pszPath);
	if ((dw != 0xFFFFFFFF) &&
		(dw & FILE_ATTRIBUTE_DIRECTORY))
		return TRUE;

	if (dw != 0xFFFFFFFF)
		return FALSE;

	p = strchr (pszPath, '\\');
	while (p)
	{
		*p = '\0';
		CreateDirectory (pszPath, NULL);
		*p = '\\';
		p++;
		p = strchr (p, '\\');
	}
	return TRUE;
}


//	____________________________________
//
//	get prefs files location based on which version of windows

PGPError PGPclExport
PGPclGetClientPrefsPath (
		LPSTR	pszPath, 
		UINT	uLen) 
{
	OSVERSIONINFO	osid;
	CHAR			sz[64];

	osid.dwOSVersionInfoSize = sizeof (osid);
	GetVersionEx (&osid);

	switch (osid.dwPlatformId) {
	// Windows NT
	case VER_PLATFORM_WIN32_NT :
	{
		// add the folder name
		LoadString (g_hInst, IDS_CLIENTPREFSFOLDER, sz, sizeof(sz));

		// decrease available space in pszPath by length of folder name
		uLen -= (lstrlen (sz) +1);

		// get the user profile path (e.g. "C:\WINNT\Profiles\username")
		if (GetEnvironmentVariable ("USERPROFILE", pszPath, uLen) == 0)
			return kPGPError_FileNotFound;

		if (pszPath[lstrlen(pszPath)-1] != '\\') 
			lstrcat (pszPath, "\\");

		// append the folder name
		lstrcat (pszPath, sz);
		break;
	}

	// otherwise use the PGP install path or, 
	// if all else fails, the Windows path 
	default :
	{
		PGPError	err;

		err = PGPclGetPGPPath (pszPath, uLen);
		if (IsPGPError (err)) 
			GetWindowsDirectory (pszPath, (uLen-1));
		break;
	}
	}

	if (pszPath[lstrlen(pszPath)-1] != '\\') 
		lstrcat (pszPath, "\\");

	return kPGPError_NoErr;
}


//	____________________________________
//
//	open prefs files based on which version of windows

PGPError PGPclExport
PGPclOpenClientPrefs (
		PGPMemoryMgrRef	memMgr, 
		PGPPrefRef*		pPrefRef) 
{
	CHAR			szPath[MAX_PATH];
	CHAR			sz[64];
	PFLFileSpecRef	FileRef;
	PGPPrefRef		ClientPrefRef;
	PGPError		err;

	err = PGPclGetClientPrefsPath (szPath, sizeof(szPath));
	if (IsPGPError (err))
		return err;

	// create the path if it doesn't exist
	sCreatePath (szPath);

	// create the name of the prefs file
	LoadString (g_hInst, IDS_CLIENTPREFSFILE, sz, sizeof(sz));
	lstrcat (szPath, sz);

	PFLNewFileSpecFromFullPath (memMgr, szPath, &FileRef);

	err = PGPOpenPrefFile (
			FileRef, clientDefaults, clientDefaultsSize, &ClientPrefRef);

	if ((err == kPGPError_FileOpFailed) ||
		(err == kPGPError_FileNotFound)) 
	{
		err = PFLFileSpecCreate (FileRef);
		pgpAssert (IsntPGPError (err));
		err = PGPOpenPrefFile(FileRef, clientDefaults, clientDefaultsSize,
				&ClientPrefRef);
		pgpAssert (IsntPGPError (err));
	}
	PFLFreeFileSpec (FileRef);

	if (IsPGPError (err)) {
		if (PGPRefIsValid (ClientPrefRef)) 
			PGPClosePrefFile (ClientPrefRef);
	}
	else {	
		*pPrefRef = ClientPrefRef;
	}

	return err;
}

//	______________________________________________
//
//  The following functions are wrappers for
//  the pfl prefs routines. These are needed so
//  groupwise plugin can access prefs (Delphi)
//  using code in the PGPcl DLL.

PGPError PGPclGetPrefBoolean(PGPPrefRef prefRef,
						   PGPPrefIndex prefIndex,
						   PGPBoolean *data)
{
	return PGPGetPrefBoolean(prefRef,
						   prefIndex,
						   data);
}

PGPError PGPclSetPrefBoolean(PGPPrefRef prefRef,
						   PGPPrefIndex prefIndex,
						   PGPBoolean data)
{
	return PGPSetPrefBoolean(prefRef,
						   prefIndex,
						   data);
}

PGPError PGPclGetPrefNumber(PGPPrefRef prefRef,
						  PGPPrefIndex prefIndex,
						  PGPUInt32 *data)
{
	return PGPGetPrefNumber(prefRef,
						  prefIndex,
						  data);
}

PGPError PGPclSetPrefNumber(PGPPrefRef prefRef,
						  PGPPrefIndex prefIndex,
						  PGPUInt32 data)
{
	return PGPSetPrefNumber(prefRef,
						  prefIndex,
						  data);
}

PGPError PGPclGetPrefStringAlloc(PGPPrefRef prefRef,
							   PGPPrefIndex prefIndex,
							   char **string)
{
	return PGPGetPrefStringAlloc(prefRef,
							   prefIndex,
							   string);
}

PGPError PGPclGetPrefStringBuffer(PGPPrefRef prefRef,
								PGPPrefIndex prefIndex,
								PGPSize maxSize,
								char *string)
{
	return PGPGetPrefStringBuffer(prefRef,
								prefIndex,
								maxSize,
								string);
}

PGPError PGPclSetPrefString(PGPPrefRef prefRef,
						  PGPPrefIndex prefIndex,
						  const char *string)
{
	return PGPSetPrefString(prefRef,
						  prefIndex,
						  string);
}

PGPError PGPclGetPrefData(PGPPrefRef prefRef, 
						PGPPrefIndex prefIndex, 
						PGPSize *dataLength, 
						void **inBuffer)
{
	return PGPGetPrefData(prefRef, 
						prefIndex, 
						dataLength, 
						inBuffer);
}

PGPError PGPclGetPrefFileSpec(PGPPrefRef prefRef,
								PFLFileSpecRef *prefFileSpec)
{
	return PGPGetPrefFileSpec(prefRef,
								prefFileSpec);
}

PGPError PGPclSetPrefData(PGPPrefRef prefRef, 
						PGPPrefIndex prefIndex, 
						PGPSize dataLength, 
						const void *outBuffer)
{
	return PGPSetPrefData(prefRef, 
						prefIndex, 
						dataLength, 
						outBuffer);
}

PGPError PGPclRemovePref(PGPPrefRef prefRef, 
					   PGPPrefIndex prefIndex)
{
	return PGPRemovePref(prefRef, 
					   prefIndex);
}

PGPError PGPclDisposePrefData(PGPPrefRef prefRef, 
							void *dataBuffer)
{
	return PGPDisposePrefData(prefRef, 
							dataBuffer);
}


//	______________________________________________
//
//  Get standard admin preferences file reference

static PGPError
sOpenAdminPrefs95 (
		PGPMemoryMgrRef	memMgr,
		PGPPrefRef*		pPrefRef, 
		BOOL			bLoadDefaults) 
{
	PGPError		err					= kPGPError_NoErr;
	PGPPrefRef		AdminPrefRef		= kInvalidPGPPrefRef;
	CHAR			szPath[MAX_PATH];
	CHAR			sz[64];
	PFLFileSpecRef	FileRef;
	DWORD			dw;

	err = PGPclGetPGPPath (szPath, sizeof(szPath));
	if (IsPGPError (err)) {
		GetWindowsDirectory (szPath, sizeof(szPath));
		if (szPath[lstrlen(szPath)-1] != '\\') lstrcat (szPath, "\\");