pkmsgprc.c

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1998 Network Associates, Inc.
	All rights reserved.
	
	PKMsgPrc - main message processing and associated routines
	

	$Id: PKMsgPrc.c,v 1.182 1999/05/03 22:17:00 pbj Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"	/* or pgpConfig.h in the CDK */

// project header files
#include "pgpkeysx.h"
#include "search.h"
#include "PGPpk.h"
#include "pgpImage.h"

// pgp header files
#include "pgpKeyserverPrefs.h" 
#include "pgpSDKPrefs.h"

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

// constant defitions
#define RELOADDELAY		 200L		//delay to allow clearing of window
#define RELOADTIMERID	1112L		//

#define WRITELOCKTRIES	3			//num times to try keyring when locked
#define WRITELOCKDELAY	1500L		//ms delay when keyring is writelocked

#define LEDTIMER		111L
#define LEDTIMERPERIOD	100L

#define NUMLEDS 10
#define LEDWIDTH 6
#define LEDSPACING 2
#define TOTALLEDWIDTH (NUMLEDS*(LEDWIDTH+LEDSPACING+1))

#define LOCK_PANE			0
#define STATUS_MSG_PANE		1
#define PROGRESS_PANE		2

#define TLS_NOSEARCHYET			0
#define TLS_NOTAUTHENTICATED	1
#define TLS_AUTHENTICATED		2

#define LOCKWIDTH			18

#define STATUSBARHEIGHT		20
#define SEARCHCONTROLHEIGHT	100

#define GRABBARHEIGHT		2

#define MINSEARCHWINDOWHEIGHT	260
#define MINSEARCHWINDOWWIDTH	460

// External globals
extern HINSTANCE		g_hInst;
extern HWND				g_hWndMain;
extern CHAR				g_szHelpFile[MAX_PATH];
extern UINT				g_uReloadPrefsMessage;
extern UINT				g_uReloadKeyringMessage;
extern UINT				g_uReloadKeyserverPrefsMessage;
extern UINT				g_uPurgePassphraseCacheMessage;
extern UINT				g_uMouseWheelMessage;
extern PGPContextRef	g_Context;
extern PGPtlsContextRef	g_TLSContext;
extern PGPBoolean		g_bExpertMode;
extern PGPBoolean		g_bKeyGenEnabled;
extern PGPBoolean		g_bMarginalAsInvalid;
extern BOOL				g_bReadOnly;
extern BOOL				g_bShowGroups;
extern INT				g_iGroupsPercent;
extern INT				g_iToolHeight;

// Local globals
static BOOL			bKeyHasBeenGenerated = FALSE;
static BOOL			bMakeBackups = FALSE;
static BOOL			bIgnoreReloads = FALSE;
static HWND			hwndOpenSearch = NULL;
static BOOL			bFirstKeyringLoad = TRUE;
static ULONG		ulColumns = 0;
static HIMAGELIST	himlLocks = NULL;


//	____________________________________
//
//  Look for secret keys

static BOOL 
sPKCheckForSecretKeys (PGPKeySetRef KeySet) 
{
	PGPKeyListRef	KeyList;
	PGPKeyIterRef	KeyIter;
	PGPKeyRef		Key;
	PGPBoolean		bSecret;
	BOOL			bSecretKeys;

	PGPOrderKeySet (KeySet, kPGPAnyOrdering, &KeyList);
	PGPNewKeyIter (KeyList, &KeyIter);

	bSecretKeys = FALSE;
	PGPKeyIterNext (KeyIter, &Key);

	while (Key && !bSecretKeys) {
		PGPGetKeyBoolean (Key, kPGPKeyPropIsSecret, &bSecret);
		if (bSecret) {
			bSecretKeys = TRUE;
		}
		PGPKeyIterNext (KeyIter, &Key);
	}

	PGPFreeKeyIter (KeyIter);
	PGPFreeKeyList (KeyList);

	return bSecretKeys;
}

//	____________________________________
//
//  Process files in command line

static VOID 
sProcessFileList (LPSTR			pszList, 
				 BOOL			bCommandLine, 
				 BOOL			bAllowSelect,
				 PGPKeySetRef	keysetMain) 
{
	PGPFileSpecRef	fileref;
	PGPKeySetRef	keysetToAdd;
	LPSTR			p, p2;
	INT				iNumKeys;
	CHAR			cTerm;
	
	p = pszList;

	// skip over path of program 
	if (bCommandLine) {
		while (*p && (*p == ' ')) p++;
		if (*p) {
			if (*p == '"') {
				p++;
				cTerm = '"';
			}
			else cTerm = ' ';
		}
		while (*p && (*p != cTerm)) p++;
		if (*p && (cTerm == '"')) p++;
	}

	// parse file names
	// Unfortunately, the OS hands me names in the command line in all 
	// sorts of forms: space delimited; quoted and space delimited; space
	// delimiter after the program path but then NULL terminated.
	// And this is just NT ...
	while (p && *p) {
		while (*p && (*p == ' ')) p++;
		if (*p) {
			if (*p == '"') {
				p++;
				cTerm = '"';
			}
			else cTerm = ' ';

			p2 = strchr (p, cTerm);
			if (p2) {
				if (*(p2+2) == ':') *p2 = '\0';
			}

			PGPNewFileSpecFromFullPath (g_Context, p, &fileref);
			if (fileref) {
				PGPImportKeySet (g_Context, &keysetToAdd, 
								PGPOInputFile (g_Context, fileref),
								PGPOLastOption (g_Context));
				if (keysetToAdd) {
					PGPCountKeys (keysetToAdd, &iNumKeys);
					if (iNumKeys > 0) {
						if (bAllowSelect) {
							PGPclQueryAddKeys (g_Context, g_TLSContext,
								g_hWndMain, keysetToAdd, keysetMain);
						}
						else {
							PGPAddKeys (keysetToAdd, keysetMain);
							PKCommitKeyRingChanges (keysetMain, TRUE);
						}
					}
					PGPFreeKeySet (keysetToAdd);
				}
				PGPFreeFileSpec (fileref);
			}
			if (p2) *p2 = ' ';
		}
		while (*p && (*p != cTerm)) p++;
		if (*p && (cTerm == '"')) p++;
	}
}

//	____________________________________
//
//  Import keys from WM_COPYDATA struct

static BOOL 
sImportData (PGPKEYSSTRUCT* ppks, PCOPYDATASTRUCT pcds) 
{
	PGPKeySetRef	keyset		= kInvalidPGPKeySetRef;
	BOOL			bPrompt;
	PGPError		err;


	bPrompt = pcds->dwData & PGPPK_SELECTIVEIMPORT;

	switch (pcds->dwData & PGPPK_IMPORTKEYMASK) {
	case PGPPK_IMPORTKEYBUFFER :
		err = PGPImportKeySet (g_Context, &keyset, 
				PGPOInputBuffer (g_Context, pcds->lpData, pcds->cbData),
				PGPOLastOption (g_Context));
		if (IsntPGPError (err) && PGPKeySetRefIsValid (keyset)) {
			if (bPrompt) {
				PGPclQueryAddKeys (g_Context, g_TLSContext, 
								g_hWndMain, keyset, ppks->KeySetMain);
			}
			else {
				err = PGPAddKeys (keyset, ppks->KeySetMain);
				PKCommitKeyRingChanges (ppks->KeySetMain, TRUE);
				PGPkmReLoadKeySet (ppks->hKM, TRUE);
			}
		}
		if (PGPKeySetRefIsValid (keyset)) 
			PGPFreeKeySet (keyset);
		return (IsntPGPError (err));

	case PGPPK_IMPORTKEYFILELIST :
		sProcessFileList (pcds->lpData, FALSE, bPrompt, ppks->KeySetMain);
		return TRUE;

	case PGPPK_IMPORTKEYCOMMANDLINE :
		sProcessFileList (pcds->lpData, TRUE, bPrompt, ppks->KeySetMain);
		return TRUE;
	}

	return FALSE;
}

//	____________________________________
//
//  import keys from admin prefs file

static PGPError 
sImportPrefsKeys (PGPKeySetRef keysetMain)
{
	PGPError		err			= kPGPError_UnknownError;

#if PGP_BUSINESS_SECURITY
	PGPKeySetRef	keysetNew;
	PGPPrefRef		prefref;
	LPSTR			psz;

	err = PGPclOpenAdminPrefs (
				PGPGetContextMemoryMgr (g_Context),
				&prefref, 
				PGPclIsAdminInstall());

	if (IsntPGPError (err)) {
		err = PGPGetPrefStringAlloc (prefref, kPGPPrefDefaultKeys, &psz);
		if (IsntPGPError (err) && psz) {
			if (psz[0]) {
				err = PGPImportKeySet (g_Context, &keysetNew, 
						PGPOInputBuffer (g_Context, psz, lstrlen(psz)+1),
						PGPOLastOption (g_Context));

				if (IsntPGPError (err)) {
					PGPAddKeys (keysetNew, keysetMain);
					err = PKCommitKeyRingChanges (keysetMain, TRUE);
					PGPFreeKeySet (keysetNew);
				}
			}
			PGPDisposePrefData (prefref, psz);
		}
		PGPclCloseAdminPrefs (prefref, FALSE);
	}

#endif //PGP_BUSINESS_SECURITY

	return err;
}

//	____________________________________
//
//  Reload keyrings

static BOOL 
sReloadKeyrings (
		PGPKEYSSTRUCT*	ppks) 
{
	BOOL				bMutable			= TRUE;
	PGPKeyRingOpenFlags	flags				= kPGPKeyRingOpenFlags_Mutable;
	INT					iLockTries			= 0;

	PGPError			pgpError;
	HCURSOR				hCursorOld;

	hCursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
	PGPsdkLoadDefaultPrefs (g_Context);
	pgpError = PGPOpenDefaultKeyRings (g_Context, flags, 
										&(ppks->KeySetMain));
	SetCursor (hCursorOld);

	while (!PGPKeySetRefIsValid (ppks->KeySetMain) || 
		   PGPkmLoadKeySet (ppks->hKM, ppks->KeySetMain, ppks->KeySetMain)) 
	{
		switch (pgpError) {

		case kPGPError_FilePermissions :
			bMutable = FALSE;
			break;

		case kPGPError_FileLocked :
			iLockTries++;
			if (iLockTries < WRITELOCKTRIES) {
				Sleep (WRITELOCKDELAY);
			}
			else {
				PKMessageBox (g_hWndMain, IDS_CAPTION, IDS_LOCKEDKEYRING,
					MB_OK|MB_ICONSTOP);
				if (!PKPGPPreferences (ppks, g_hWndMain, PGPCL_KEYRINGPREFS)) 
				{
					SendMessage (g_hWndMain, WM_CLOSE, 0, 0);
					return FALSE;
				}
			}
			break;

		case kPGPError_CantOpenFile :
		case kPGPError_FileNotFound :
			if (!PKPGPPreferences (ppks, g_hWndMain, PGPCL_KEYRINGPREFS)) 
			{
				SendMessage (g_hWndMain, WM_CLOSE, 0, 0);
				return FALSE;
			}
			break;

		default :
			PKMessageBox (g_hWndMain, IDS_CAPTION, IDS_CORRUPTKEYRING, 
				MB_OK|MB_ICONSTOP);
			if (!PKPGPPreferences (ppks, g_hWndMain, PGPCL_KEYRINGPREFS)) 
			{
				SendMessage (g_hWndMain, WM_CLOSE, 0, 0);
				return FALSE;
			}
			break;
		}
		hCursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
		flags = 0;
		if (bMutable) flags |= kPGPKeyRingOpenFlags_Mutable;
		pgpError = PGPOpenDefaultKeyRings (g_Context, flags, 
											&(ppks->KeySetMain));

		SetCursor (hCursorOld);
	}

	PGPPropagateTrust (ppks->KeySetMain);
	g_bReadOnly = !bMutable;

	if (g_bReadOnly) 
	{
		ppks->kmConfig.ulOptionFlags |= KMF_READONLY;
		PKReadOnlyWarning (ppks->hWndMain);
	}
	else 
		ppks->kmConfig.ulOptionFlags &= ~KMF_READONLY;

	// pass readonly flag to keymanager
	ppks->kmConfig.ulMask = PGPKM_OPTIONS;
	PGPkmConfigure (ppks->hKM, &(ppks->kmConfig));

	// reload the groups file
	ppks->gmConfig.keysetMain = ppks->KeySetMain;
	PGPgmConfigure (ppks->hGM, &(ppks->gmConfig));
	PGPgmLoadGroups (ppks->hGM);

	return TRUE;
}

//	____________________________________
//
//  Draw the owner-drawn part of the status bar

static VOID
sDrawStatus (
		LPDRAWITEMSTRUCT lpdis, 
		PGPKEYSSTRUCT* ppks) 
{
	HBRUSH	hBrushLit, hBrushUnlit, hBrushOld;
	HPEN	hPen, hPenOld;
	INT		i;
	INT		itop, ibot, ileft, iright;

	if(lpdis->itemID == PROGRESS_PANE)
	{
		if (ppks->iStatusValue < -1) return;

		// draw 3D shadow
		itop = lpdis->rcItem.top+3;
		ibot = lpdis->rcItem.bottom-5;

		ileft = lpdis->rcItem.left + 4;
		for (i=0; i<NUMLEDS; i++) {
			iright = ileft + LEDWIDTH;

			MoveToEx (lpdis->hDC, ileft, ibot, NULL);
			LineTo (lpdis->hDC, iright, ibot);
			LineTo (lpdis->hDC, iright, itop);

			ileft += LEDWIDTH + LEDSPACING;
		}

		hPen = CreatePen (PS_SOLID, 0, RGB (128, 128, 128));
		hPenOld = SelectObject (lpdis->hDC, hPen);
		hBrushLit = CreateSolidBrush (RGB (0, 255, 0));
		hBrushUnlit = CreateSolidBrush (RGB (0, 128, 0));

		ileft = lpdis->rcItem.left + 4;

		// draw "Knight Rider" LEDs
		if (ppks->iStatusDirection) {
			hBrushOld = SelectObject (lpdis->hDC, hBrushUnlit);
			for (i=0; i<NUMLEDS; i++) {
				iright = ileft + LEDWIDTH;
		
				if (i == ppks->iStatusValue) {
					SelectObject (lpdis->hDC, hBrushLit);
					Rectangle (lpdis->hDC, ileft, itop, iright, ibot);
					SelectObject (lpdis->hDC, hBrushUnlit);
				}
				else  {
					Rectangle (lpdis->hDC, ileft, itop, iright, ibot);
				}
		
				ileft += LEDWIDTH + LEDSPACING;
			}
		}

		// draw "progress bar" LEDs
		else { 
			if (ppks->iStatusValue >= 0) 
				hBrushOld = SelectObject (lpdis->hDC, hBrushLit);
			else
				hBrushOld = SelectObject (lpdis->hDC, hBrushUnlit);

			for (i=0; i<NUMLEDS; i++) {
				iright = ileft + LEDWIDTH;
		
				if (i > ppks->iStatusValue) {
					SelectObject (lpdis->hDC, hBrushUnlit);
				}
				Rectangle (lpdis->hDC, ileft, itop, iright, ibot);
		
				ileft += LEDWIDTH + LEDSPACING;
			}
		}

		SelectObject (lpdis->hDC, hBrushOld);
		SelectObject (lpdis->hDC, hPenOld);
		DeleteObject (hPen);
		DeleteObject (hBrushLit);
		DeleteObject (hBrushUnlit);
	}
	else if(lpdis->itemID == LOCK_PANE)
	{
		BOOL bSecure = (BOOL) lpdis->itemData;

		if (bSecure) {
			bSecure = TRUE;
		}

		ImageList_Draw (himlLocks, (bSecure ? IDX_CLOSEDLOCK:IDX_OPENLOCK),
			lpdis->hDC, 1, 3, ILD_TRANSPARENT);

	}
}


//	____________________________________
//
//  display downloaded key count in status bar

static INT
sDisplayKSKeyResult (
		PGPKeySetRef	keyset, 
		HWND			hwnd, 
		PGPError		err) 
{
	CHAR sz1[256];
	CHAR sz2[256];
	INT	 iCount;

	if (keyset)
		(void)PGPCountKeys (keyset, &iCount);
	else 
		iCount = 0;

	if (err == kPGPError_ServerPartialSearchResults)
		LoadString (g_hInst, IDS_KSTOOMANYKEYCOUNT, sz1, sizeof(sz1));
	else 
		LoadString (g_hInst, IDS_KSKEYCOUNT, sz1, sizeof(sz1));
	wsprintf (sz2, sz1, iCount);
	SendMessage (hwnd, SB_SETTEXT, STATUS_MSG_PANE, (LPARAM)sz2);
	
	return iCount;
}

//	____________________________________
//
//  get number of wheel scroll lines and pass to treelist controls

static VOID
sUpdateWheelScrollLines (PGPKEYSSTRUCT* ppks)
{
	UINT uLines;

	if (!SystemParametersInfo (SPI_GETWHEELSCROLLLINES, 0, &uLines, 0)) 
	{
		HWND hwnd = NULL;
		UINT umsg = 0;

		umsg = RegisterWindowMessage (MSH_SCROLL_LINES);
		hwnd = FindWindow (MSH_WHEELMODULE_CLASS, MSH_WHEELMODULE_TITLE);