pkuser.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.
	
	PKUser.c - miscellaneous user interface routines
	
	$Id: PKUser.c,v 1.25 2002/10/29 17:44:44 pbj Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"	/* or pgpConfig.h in the CDK */

// project header files
#include "PGPkeysx.h"
#include "pgpUnicodeWin32.h"
#include "UTF8Edit.h"

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

// local globals
static CHAR			s_szPubring[MAX_PATH];
static CHAR			s_szSecring[MAX_PATH];

// external global variables
extern HINSTANCE			g_hinst;
extern PGPContextRef		g_context;
extern PGPtlsContextRef		g_tlscontext;

//	____________________________________
//
//	Message box routine
//
//	iCaption and iMessage are string table resource IDs.

LRESULT 
PKMessageBox (
		HWND	hWnd, 
		INT		iCaption, 
		INT		iMessage,
		ULONG	ulFlags) 
{
	CHAR szCaption [128];
	CHAR szMessage [512];

	LoadString (g_hinst, iCaption, szCaption, sizeof(szCaption));
	LoadString (g_hinst, iMessage, szMessage, sizeof(szMessage));

	ulFlags |= MB_SETFOREGROUND;
	return (MessageBox (hWnd, szMessage, szCaption, ulFlags));
}

//	____________________________________
//
//	Backup warning dialog message procedure

static BOOL CALLBACK 
sBackupWarnDlgProc(
		HWND	hWndDlg, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	switch (uMsg) {

	case WM_INITDIALOG:
		return TRUE;

	case WM_COMMAND:

		switch (LOWORD(wParam)) {
		case IDC_BACKUPNOW:
			EndDialog (hWndDlg, IDC_BACKUPNOW);
			break;

		case IDC_DONTBACKUP :
			EndDialog (hWndDlg, IDC_DONTBACKUP);
			break;

		case IDCANCEL:
			EndDialog (hWndDlg, IDCANCEL);
			break;

		}
		return TRUE;
	}
	return FALSE;
}


//	____________________________________
//
//	Warn user of need for backup

BOOL 
PKBackupWarn (
	HWND	hWnd, 
	BOOL	bClosingPGPkeys,
	BOOL*	pbBackup) 
{
	INT		iReturn;

	if (bClosingPGPkeys)
	{
		iReturn = DialogBox (g_hinst, MAKEINTRESOURCE (IDD_BACKUPWARN), 
			hWnd, sBackupWarnDlgProc);
	}
	else
	{
		iReturn = DialogBox (g_hinst, MAKEINTRESOURCE (IDD_BACKUPWARN2), 
			hWnd, sBackupWarnDlgProc);
	}

	if (iReturn == IDCANCEL) {
		*pbBackup = FALSE;
		return FALSE;
	}

	else if (iReturn == IDC_BACKUPNOW) {
		*pbBackup = TRUE;
		return TRUE;
	}

	else {
		*pbBackup = FALSE;
		return TRUE;
	}
}


//	____________________________________
//
//	Warn user of existing split key dialogs

BOOL 
PKSplitKeyWarn (HWND hwnd) 
{
	PKMessageBox (hwnd, IDS_CAPTIONINFO, IDS_SPLITKEYWARNING, 
			MB_OK|MB_ICONINFORMATION|MB_SYSTEMMODAL);

	return FALSE;
}


//	______________________________________________
//
//  create the specified path if it doesn't already exist
//	assumes path ends in '\' if it is a folder name

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;
}


//	____________________________________
//
//	backup the keydb to the specified files

static PGPError
sBackupKeyDB (
		PGPKeyDBRef		keydbToBackup,
		LPSTR			pszPubring,
		LPSTR			pszSecring)
{
	PGPError	err;

	PGPFileSpecRef	filespecPubring;
	PGPFileSpecRef	filespecSecring;
	PGPKeyDBRef		keydb;

	if (PGPclTestPathNameStatus (pszPubring) & kPGPclIsFile)
	{
		if (!DeleteFile (pszPubring))
			return kPGPError_FileOpFailed;
	}

	if (PGPclTestPathNameStatus (pszSecring) & kPGPclIsFile)
	{
		if (!DeleteFile (pszSecring))
			return kPGPError_FileOpFailed;
	}
		
	err = PGPNewFileSpecFromFullPath (
			g_context, pszPubring, &filespecPubring);
	if (IsntPGPError (err))
	{
		err = PGPNewFileSpecFromFullPath (
				g_context, pszSecring, &filespecSecring);
		if (IsntPGPError (err))
		{
			err = PGPOpenKeyDBFile (g_context, 
					kPGPOpenKeyDBFileOptions_Create |
					kPGPOpenKeyDBFileOptions_Mutable,
					filespecPubring, filespecSecring, &keydb);

			if (IsntPGPError (err))
			{
				err = PGPCopyKeys (
						PGPPeekKeyDBRootKeySet (keydbToBackup),
						keydb, NULL);
			
				PGPFreeKeyDB (keydb);
			}
			PGPFreeFileSpec (filespecSecring);
		}
		PGPFreeFileSpec (filespecPubring);
	}

	return err;
}


//	____________________________________
//
//	the main keydb has been opened

VOID
PKKeyDBOpened (
		PPGPKEYSSTRUCT	ppks)
{
	ppks->uBackupFlags = 0;
	PGPclGetPath (kPGPclPublicKeyringFile, s_szPubring, sizeof(s_szPubring));
	PGPclGetPath (kPGPclPrivateKeyringFile, s_szSecring, sizeof(s_szSecring));
}


//	____________________________________
//
//	the main keydb has been modified

VOID
PKKeyDBModified (
		PPGPKEYSSTRUCT	ppks,
		UINT			uModIndex)
{
	ppks->uBackupFlags |= uModIndex;
	if ((ppks->uFlags & (PK_MAINWINDOW|PK_PDAWINDOW)) ||
		((ppks->uFlags & PK_SEARCHWINDOW) && (ppks->bLocalKeySet)))
	{
		PKPostMessageWindowList (
				PK_M_REFRESHKEYRINGS, (WPARAM)ppks->hwndMain, TRUE);
	}
}


//	____________________________________
//
//	auto backup the keyring

VOID
PKAutoBackup (
		PPGPKEYSSTRUCT	ppks)
{
	PGPError	err				= kPGPError_NoErr;

	CHAR		szPubring[MAX_PATH];
	CHAR		szSecring[MAX_PATH];
	CHAR		szTempPubring[MAX_PATH];
	CHAR		szTempSecring[MAX_PATH];
	CHAR		sz[MAX_PATH];
	PGPPrefRef	prefref;
	PGPBoolean	b;
	CHAR*		p;

	PGPclPeekClientLibPrefRefs (&prefref, NULL);
	PGPGetPrefBoolean (prefref, kPGPPrefAutoBackupKeyring, &b);
	if (b)
	{
		PGPGetPrefBoolean (prefref, kPGPPrefAutoBackupToKeyringFolder, &b);
		// use the keyring file path as the base path
		if (b)
		{
			lstrcpy (szPubring, s_szPubring);
			lstrcpy (szSecring, s_szSecring);
		}
		// append the keyring file names to the backup folder
		else
		{
			PGPGetPrefStringBuffer (prefref, 
					kPGPPrefAutoBackupFolder, sizeof(szPubring), szPubring);
			if (szPubring [lstrlen(szPubring)-1] != '\\')
				lstrcat (szPubring, "\\");
			sCreatePath (szPubring);

			lstrcpy (szSecring, szPubring);

			lstrcpy (sz, s_szPubring);
			p = strrchr (sz, '\\');
			if (p) 
				p++;
			else
				p = &sz[0];
			lstrcat (szPubring, p);

			lstrcpy (sz, s_szSecring);
			p = strrchr (sz, '\\');
			if (p)
				p++;
			else
				p = &sz[0];
			lstrcat (szSecring, p);
		}

		// construct the temp backup file names 
		// and the actual backup file names
		p = strrchr (szPubring, '.');
		if (p)
		{
			lstrcpy (sz, p);
			*p = '\0';
		}
		lstrcpy (szTempPubring, szPubring);
		lstrcat (szTempPubring, "-tmp");
		lstrcat (szTempPubring, sz);

		lstrcat (szPubring, "-bak");
		lstrcat (szPubring, sz);

		p = strrchr (szSecring, '.');
		if (p)
		{
			lstrcpy (sz, p);
			*p = '\0';
		}
		lstrcpy (szTempSecring, szSecring);
		lstrcat (szTempSecring, "-tmp");
		lstrcat (szTempSecring, sz);

		lstrcat (szSecring, "-bak");
		lstrcat (szSecring, sz);

		// actually perform the backup if the flags indicate a backup
		// is due, or if the backup files do not already exist
		if ((ppks->uBackupFlags) ||
			!(PGPclTestPathNameStatus (szPubring) & kPGPclIsFile) ||
			!(PGPclTestPathNameStatus (szSecring) & kPGPclIsFile))
		{
			// backup to temp files
			err = sBackupKeyDB (ppks->keydbMain, szTempPubring, szTempSecring);
			if (IsntPGPError (err))
			{
				// delete pre-existing backups
				if (PGPclTestPathNameStatus (szPubring) & kPGPclIsFile)
				{
					if (!DeleteFile (szPubring))
						err = kPGPError_FileOpFailed;
				}

				if (PGPclTestPathNameStatus (szSecring) & kPGPclIsFile)
				{
					if (!DeleteFile (szSecring))
						err = kPGPError_FileOpFailed;
				}

				// rename temp files to backups
				if (!MoveFile (szTempPubring, szPubring))
					err = kPGPError_FileOpFailed;

				if (!MoveFile (szTempSecring, szSecring))
					err = kPGPError_FileOpFailed;

				if (IsntPGPError (err))
					ppks->uBackupFlags = 0;
			}
		}