pkmisc.c

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1998 Network Associates, Inc.
	All rights reserved.
	
	PKMisc.c - miscellaneous routines
	

	$Id: PKMisc.c,v 1.45 1999/03/29 20:58:58 pbj Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"	/* or pgpConfig.h in the CDK */

// project header files
#include "pgpkeysx.h"

// typedefs
typedef struct {
	PGPUInt32	uWindowShow;
	PGPInt32	iWindowPosX;
	PGPInt32	iWindowPosY;
	PGPInt32	iWindowWidth;
	PGPInt32	iWindowHeight;
	PGPBoolean	bGroupShow;
	PGPInt32	iGroupPercent;
	PGPInt32	iToolHeight;

} KEYSWINDOWSTRUCT, *PKEYSWINDOWSTRUCT;


// external global variables
extern HINSTANCE		g_hInst;
extern HWND				g_hWndMain;
extern UINT				g_uReloadKeyringMessage;
extern PGPContextRef	g_Context;
extern PGPtlsContextRef	g_TLSContext;
extern PGPBoolean		g_bExpertMode;
extern PGPBoolean		g_bMarginalAsInvalid;

//	____________________________________
//
//	Private memory allocation routine

VOID* 
pkAlloc (LONG size) 
{
	void* p;
	p = malloc (size);
	if (p) {
		memset (p, 0, size);
	}
	return p;
}

//	____________________________________
//
//	Private memory deallocation routine

VOID 
pkFree (VOID* p) 
{
	if (p) {
		free (p);
	}
}

//	____________________________________
//
//	Get PGPkeys private info from prefs file

BOOL 
PKGetPrivatePrefData (
			DWORD*	dwShow, 
			INT*	iX, 
			INT*	iY, 
			INT*	iWidth, 
			INT*	iHeight,
			BOOL*	bGroupShow,
			INT*	iGroupPercent,
			INT*	iToolHeight) 
{
	PKEYSWINDOWSTRUCT		pkws;
	PGPPrefRef				prefref;
	PGPError				err;
	PGPSize					size;

	*dwShow			= SW_SHOWNORMAL;
	*iX				= DEFAULTWINDOWX;
	*iY				= DEFAULTWINDOWY;
	*iWidth			= DEFAULTWINDOWWIDTH; 
	*iHeight		= DEFAULTWINDOWHEIGHT; 
	*bGroupShow		= DEFAULTGROUPSHOW;
	*iGroupPercent	= DEFAULTGROUPPERCENT;
	*iToolHeight	= DEFAULTTOOLHEIGHT;

	err = PGPclOpenClientPrefs (PGPGetContextMemoryMgr (g_Context), 
									&prefref);
	if (IsntPGPError (err)) {
		size = 0;
		err = PGPGetPrefData (prefref, kPGPPrefPGPkeysWinMainWinPos,
						&size, &pkws);
		PGPclCloseClientPrefs (prefref, FALSE);

		if (IsntPGPError (err)) {
			if (size == sizeof(KEYSWINDOWSTRUCT)) {
				*dwShow			= pkws->uWindowShow;
				*iX				= pkws->iWindowPosX;
				*iY				= pkws->iWindowPosY;
				*iWidth			= pkws->iWindowWidth;
				*iHeight		= pkws->iWindowHeight;
				*bGroupShow		= pkws->bGroupShow;
				*iGroupPercent	= pkws->iGroupPercent;
				*iToolHeight	= pkws->iToolHeight;
			}
			PGPDisposePrefData (prefref, pkws);
		}
	}

	return FALSE;
}

//	____________________________________
//
//	 Put window position information in registry

VOID 
PKSetPrivatePrefData (
		HWND	hWnd, 
		BOOL	bGroupShow,
		INT		iGroupPercent,
		INT		iToolHeight) 
{
	WINDOWPLACEMENT		wp;
	KEYSWINDOWSTRUCT	kws;
	PGPPrefRef			prefref;
	PGPError			err;

	wp.length = sizeof(WINDOWPLACEMENT);
	GetWindowPlacement (hWnd, &wp);

	err = PGPclOpenClientPrefs (PGPGetContextMemoryMgr (g_Context), 
									&prefref);
	if (IsntPGPError (err)) {
		kws.uWindowShow = wp.showCmd;
		kws.iWindowPosX = wp.rcNormalPosition.left;
		kws.iWindowPosY = wp.rcNormalPosition.top;
		kws.iWindowWidth = 
			wp.rcNormalPosition.right - wp.rcNormalPosition.left;
		kws.iWindowHeight = 
			wp.rcNormalPosition.bottom - wp.rcNormalPosition.top;
		kws.bGroupShow = bGroupShow;
		kws.iGroupPercent = iGroupPercent;
		kws.iToolHeight = iToolHeight;
		PGPSetPrefData (prefref, kPGPPrefPGPkeysWinMainWinPos, 
						sizeof(kws), &kws);

		PGPclCloseClientPrefs (prefref, TRUE);
	}
}

//	____________________________________
//
//	Put PGPkeys application path into registry

VOID 
PKSetPathRegistryData (void) 
{
	HKEY	hKey;
	LONG	lResult;
	CHAR	szPath[MAX_PATH];
	DWORD	dw;
	CHAR	sz[256];
	CHAR*	p;

	LoadString (g_hInst, IDS_REGISTRYKEY, sz, sizeof(sz));
	lResult = RegCreateKeyEx (HKEY_LOCAL_MACHINE, sz, 0, NULL,
				REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dw);

	if (lResult == ERROR_SUCCESS) {

		// get full path of PGPkeys.exe
		GetModuleFileName (NULL, szPath, sizeof(szPath));

		// lop off file name
		if (p = strrchr (szPath, '\\'))
			*(++p) = '\0';

		// write it to the registry
		RegSetValueEx (hKey, "InstallPath", 0, REG_SZ, (LPBYTE)szPath, 
			lstrlen(szPath)+1);
		RegCloseKey (hKey);
	}
}

//	____________________________________
//
//  Put up preferences property sheet

VOID 
PKReloadPGPPreferences (PGPKEYSSTRUCT* ppks) 
{
	PGPPrefRef	prefs;
	PGPBoolean	b, bUpdate;

	bUpdate = FALSE;
	PGPclOpenClientPrefs (PGPGetContextMemoryMgr (g_Context), &prefs);

	// has the validity dot vs. bar pref changed?
	PGPGetPrefBoolean (prefs, kPGPPrefDisplayMarginalValidity, &b);
	if (b != g_bExpertMode) {
		g_bExpertMode = b;
		bUpdate = TRUE;
		if (!g_bExpertMode) {
			ppks->kmConfig.ulOptionFlags |= KMF_NOVICEMODE;
			ppks->gmConfig.ulOptionFlags |= GMF_NOVICEMODE;
		}
		else {
			ppks->kmConfig.ulOptionFlags &= ~KMF_NOVICEMODE;
			ppks->gmConfig.ulOptionFlags &= ~GMF_NOVICEMODE;
		}
	}

	// has the display marginal validity as invalid pref changed?
	PGPGetPrefBoolean (prefs, kPGPPrefMarginalIsInvalid, &b);
	if (b != g_bMarginalAsInvalid) {
		g_bMarginalAsInvalid = b;
		bUpdate = TRUE;
		if (g_bMarginalAsInvalid) {
			ppks->kmConfig.ulOptionFlags |= KMF_MARGASINVALID;
			ppks->gmConfig.ulOptionFlags |= GMF_MARGASINVALID;
		}
		else {
			ppks->kmConfig.ulOptionFlags &= ~KMF_MARGASINVALID;
			ppks->gmConfig.ulOptionFlags &= ~GMF_MARGASINVALID;
		}
	}

	PGPclCloseClientPrefs (prefs, FALSE);

	// if prefs have changed => redraw the windows
	if (bUpdate) {
		ppks->kmConfig.ulMask = PGPKM_OPTIONS;
		PGPkmConfigure (ppks->hKM, &(ppks->kmConfig));
		PGPkmLoadKeySet (ppks->hKM, ppks->KeySetMain, ppks->KeySetMain);
		PGPgmConfigure (ppks->hGM, &(ppks->gmConfig));
		PGPgmLoadGroups (ppks->hGM);
	}
}

//	____________________________________
//
//  Put up preferences property sheet

BOOL 
PKPGPPreferences (
		PGPKEYSSTRUCT*	ppks, 
		HWND			hWnd, 
		INT				iPage) 
{
	PGPError	err;

	EnableWindow (hWnd, FALSE);
	err = PGPclPreferences (g_Context, hWnd, iPage, ppks->KeySetMain);
	if (err != kPGPError_Win32_AlreadyOpen) SetForegroundWindow (hWnd);

	EnableWindow (hWnd, TRUE);
	SetFocus (ppks->hWndTreeList);

	PKReloadPGPPreferences (ppks);

	if (err == kPGPError_NoErr) return TRUE;
	else return FALSE;
}


//	___________________________________________________
//
//  commit keyring changes and broadcast reload message

INT 
PKCommitKeyRingChanges (PGPKeySetRef KeySet, BOOL bBroadcast) 
{
	PGPError	err;
	HCURSOR		hcursorOld;

	hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
	err = PGPCommitKeyRingChanges (KeySet);
	if (IsntPGPError (PGPclErrorBox (NULL, err)) && bBroadcast) {
		PostMessage (HWND_BROADCAST, g_uReloadKeyringMessage,
			MAKEWPARAM (LOWORD (g_hWndMain), FALSE),
			(LPARAM)GetCurrentProcessId ());
	}
	SetCursor (hcursorOld);
	return err;
}


//	____________________________________
//
//	Auto update all keys in keyring

BOOL 
PKAutoUpdateAllKeys (
		HWND			hwnd, 
		PGPKeySetRef	keysetMain,
		BOOL			bForce) 
{
	PGPError		err					= kPGPError_NoErr;
	PGPKeySetRef	keysetUpdated		= kInvalidPGPKeySetRef;
	BOOL			bImported			= FALSE;

	INT				iNumKeys;
	HCURSOR			hcursorOld;

	// update entire keyset from key-based server
	err = PGPclUpdateKeySetFromServer (g_Context, g_TLSContext, hwnd, 
					keysetMain, PGPCL_USERIDBASEDSERVER, keysetMain, 
					&keysetUpdated); CKERR;

	// if we got updated keys, query user and commit the changes
	if (PGPKeySetRefIsValid (keysetUpdated)) 
	{
		if (bForce) 
		{
			hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
			err = PGPAddKeys (keysetUpdated, keysetMain);
			if (IsntPGPError (err)) {
				bImported = TRUE;
				err = PKCommitKeyRingChanges (keysetMain, TRUE);
			}
			SetCursor (hcursorOld);
		}
		else 
		{
			PGPCountKeys (keysetUpdated, &iNumKeys);
			if (iNumKeys > 0)
			{
				err = PGPclQueryAddKeys (g_Context, 
										 g_TLSContext,
										 hwnd,
										 keysetUpdated, 
										 keysetMain);
				if (IsntPGPError (err)) {
					bImported = TRUE;
					err = PKCommitKeyRingChanges (keysetMain, TRUE);
				}
			}
			else
				PKMessageBox (hwnd, IDS_AUTOUPDATECAPTION, 
						IDS_NOUPDATEDKEYS, MB_OK|MB_ICONEXCLAMATION);
		}
	}

done :
	if (PGPKeySetRefIsValid (keysetUpdated))
		PGPFreeKeySet (keysetUpdated);

	PGPclErrorBox (hwnd, err);

	return bImported;
}


//	____________________________________
//
//	derive meta introducers from keyset

static PGPError 
sGetMetaIntroducers (
		PGPKeySetRef	keysetMain,
		PGPKeySetRef*	pkeysetMeta)
{
	PGPError		err					= kPGPError_NoErr;
	PGPKeyListRef	keylist				= kInvalidPGPKeyListRef;
	PGPKeyIterRef	keyiter				= kInvalidPGPKeyIterRef;
	PGPKeyRef		key					= kInvalidPGPKeyRef;
	PGPKeySetRef	keysetMeta			= kInvalidPGPKeySetRef;
	PGPKeySetRef	keysetSingle		= kInvalidPGPKeySetRef;
	PGPBoolean		bMargIsInvalid;
	PGPValidity		validityThreshold;
	PGPPrefRef		prefs;

	// use prefs to determine validity threshold
	PGPclOpenClientPrefs (PGPGetContextMemoryMgr (g_Context), &prefs);
	PGPGetPrefBoolean (prefs, kPGPPrefMarginalIsInvalid, &bMargIsInvalid);
	PGPclCloseClientPrefs (prefs, FALSE);

	if (bMargIsInvalid) 
		validityThreshold = kPGPValidity_Complete;
	else
		validityThreshold = kPGPValidity_Marginal;