pkuser.c

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

	}

	if (IsPGPError (err))
	{
		PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT, 
				IDS_AUTOBACKUPFAILED, MB_OK|MB_ICONEXCLAMATION);
	}
}


//	____________________________________
//
//	Actually do the backing-up

BOOL
PKUserBackup (
		HWND		hwnd,
		PGPKeyDBRef	keydbMain) 
{
	OPENFILENAME	OpenFileName;
	CHAR			szPubring[MAX_PATH];
	CHAR			szSecring[MAX_PATH];
	CHAR			szDir[MAX_PATH];
	CHAR			sz[MAX_PATH];
	CHAR			szDefExt[8];
	CHAR			szFilter[256];
	PGPError		err;
	CHAR*			p;

	do 
	{
		err = PGPclGetPath (kPGPclDefaultSaveAsFolder, szDir, sizeof(szDir)); 
		if (IsPGPError (err)) 
		{
			LoadString (g_hinst, 
					IDS_BACKUPDEFAULTDIR, szDir, sizeof(szDir));
		}

		OpenFileName.lStructSize       = sizeof (OPENFILENAME);
		OpenFileName.hwndOwner         = hwnd;
		OpenFileName.hInstance         = (HANDLE)g_hinst;
		LoadString (g_hinst, IDS_PUBBACKUPFILTER, 
				szFilter, sizeof(szFilter));
		while (p = strrchr (szFilter, '@')) *p = '\0';
		OpenFileName.lpstrFilter       = szFilter;
		OpenFileName.lpstrCustomFilter = (LPTSTR)NULL;
		OpenFileName.nMaxCustFilter    = 0L;
		OpenFileName.nFilterIndex      = 1L;

		err = PGPclGetPath (kPGPclPublicKeyringFile, sz, sizeof(sz));

		if (IsntPGPError (PGPclErrorBox (hwnd, err))) 
		{
			p = strrchr (sz, '\\');
			if (p) 
			{
				p++;
				lstrcpy (szPubring, p);
			}
			else 
				lstrcpy (szPubring, sz);

			p = strrchr (szPubring, '.');
			if (p)
				*p = '\0';
		}
		else
		{
			LoadString (g_hinst, IDS_PUBBACKUPDEFAULTFILE, 
					szPubring, sizeof(szPubring));
		}
				
		OpenFileName.lpstrFile         = szPubring;
		OpenFileName.nMaxFile          = sizeof (szPubring);
		OpenFileName.lpstrFileTitle    = NULL;
		OpenFileName.nMaxFileTitle     = 0;
		OpenFileName.lpstrInitialDir   = szDir;
		LoadString (g_hinst, IDS_PUBBACKUPCAPTION, sz, sizeof(sz));
		OpenFileName.lpstrTitle        = sz;
		OpenFileName.Flags			   = OFN_HIDEREADONLY|
										 OFN_OVERWRITEPROMPT|
										 OFN_NOREADONLYRETURN|
										 OFN_NOCHANGEDIR;
		OpenFileName.nFileOffset       = 0;
		OpenFileName.nFileExtension    = 0;
		LoadString (g_hinst, IDS_DEFPUBKEYRINGEXTENSION, 
								szDefExt, sizeof(szDefExt));
		OpenFileName.lpstrDefExt       = szDefExt;
		OpenFileName.lCustData         = 0;

		if (!GetSaveFileName (&OpenFileName)) 
		{
			DWORD dwErr = CommDlgExtendedError ();
			if (dwErr != 0)
			{
				PKMessageBox (hwnd, IDS_CAPTIONERROR, 
						IDS_BACKUPERROR, MB_OK|MB_ICONSTOP);
				continue;
			}
			return FALSE;
		}

		// backup private keyring file
		lstrcpy (szDir, szPubring);
		p = strrchr (szDir, '\\');
		if (p) *p = '\0';
		OpenFileName.lStructSize       = sizeof (OPENFILENAME);
		OpenFileName.hwndOwner         = hwnd;
		OpenFileName.hInstance         = (HANDLE)g_hinst;
		LoadString (g_hinst, IDS_BACKUPFILTER, 
			szFilter, sizeof(szFilter));
		while (p = strrchr (szFilter, '@')) *p = '\0';
		OpenFileName.lpstrFilter       = szFilter;
		OpenFileName.lpstrCustomFilter = (LPTSTR)NULL;
		OpenFileName.nMaxCustFilter    = 0L;
		OpenFileName.nFilterIndex      = 1L;

		err = PGPclGetPath (kPGPclPrivateKeyringFile, sz, sizeof(sz));

		if (IsntPGPError (PGPclErrorBox (hwnd, err))) 
		{
			p = strrchr (sz, '\\');
			if (p) 
			{
				p++;
				lstrcpy (szSecring, p);
			}
			else 
				lstrcpy (szSecring, sz);

			p = strrchr (szSecring, '.');
			if (p) 
				*p = '\0';
		}
		else 
		{
			LoadString (g_hinst, IDS_BACKUPDEFAULTFILE, 
					szSecring, sizeof(szSecring));
		}

		OpenFileName.lpstrFile         = szSecring;
		OpenFileName.nMaxFile          = sizeof (szSecring);
		OpenFileName.lpstrFileTitle    = NULL;
		OpenFileName.nMaxFileTitle     = 0;
		OpenFileName.lpstrInitialDir   = szDir;
		LoadString (g_hinst, IDS_BACKUPCAPTION, sz, sizeof(sz));
		OpenFileName.lpstrTitle        = sz;
		OpenFileName.Flags			   = OFN_HIDEREADONLY|
										 OFN_OVERWRITEPROMPT|
										 OFN_NOREADONLYRETURN|
										 OFN_NOCHANGEDIR;
		OpenFileName.nFileOffset       = 0;
		OpenFileName.nFileExtension    = 0;
		LoadString (g_hinst, IDS_DEFKEYRINGEXTENSION, 
								szDefExt, sizeof(szDefExt));
		OpenFileName.lpstrDefExt       = szDefExt;
		OpenFileName.lCustData         = 0;

		if (!GetSaveFileName (&OpenFileName)) 
		{
			DWORD dwErr = CommDlgExtendedError ();
			if (dwErr != 0)
			{
				PKMessageBox (hwnd, IDS_CAPTIONERROR, 
						IDS_BACKUPERROR, MB_OK|MB_ICONSTOP);
				continue;
			}
			return FALSE;
		}

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

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

		if (IsntPGPError (err))
			err = sBackupKeyDB (keydbMain, szPubring, szSecring);

		if (IsPGPError (PGPclErrorBox (hwnd, err)) &&
			(err != kPGPError_UserAbort))
		{
			PKMessageBox (hwnd, IDS_CAPTIONERROR, 
					IDS_BACKUPERROR, MB_OK|MB_ICONSTOP);
		}

	} while (IsPGPError (err));

	return TRUE;
}


//	____________________________________
//
//	Read-only warning dialog message procedure

static BOOL CALLBACK 
sReadOnlyDlgProc (
		HWND	hWndDlg, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	switch (uMsg) {
	case WM_COMMAND:

		switch (LOWORD(wParam)) {
		case IDOK:
			if (IsDlgButtonChecked (hWndDlg, IDC_WARNNOMORE) == BST_CHECKED)
				EndDialog (hWndDlg, 1);
			else 
				EndDialog (hWndDlg, 0);
			break;
		}
		return TRUE;
	}
	return FALSE;
}


//	____________________________________
//
// Warn user that keyrings are read-only

VOID 
PKReadOnlyWarning (HWND hWnd) 
{
	PGPBoolean		bWarn		= TRUE;
	PGPPrefRef		prefref		= kInvalidPGPPrefRef;
	PGPError		err;

	err = PGPclPeekClientLibPrefRefs (&prefref, NULL);

	if (IsntPGPError (err)) 
	{
		PGPGetPrefBoolean (prefref, kPGPPrefWarnOnReadOnlyKeyRings, &bWarn);

		if (bWarn) 
		{
			if (DialogBox (g_hinst, MAKEINTRESOURCE (IDD_READONLY), 
						hWnd, sReadOnlyDlgProc)) 
			{
				bWarn = FALSE;
				PGPSetPrefBoolean (
						prefref, kPGPPrefWarnOnReadOnlyKeyRings, bWarn);
				PGPclFlushClientLibPrefs (prefref, NULL);
			}
		}
	}
}


//	____________________________________
//
//	Post Help About dialog

VOID 
PKHelpAbout (HWND hWnd) 
{
	PGPclHelpAbout (g_context, hWnd, NULL, NULL, NULL); 
}


//	____________________________________
//
//	Wipe edit box clean

VOID 
PKWipeEditBox (
		HWND hDlg, 
		UINT uID) 
{
	CHAR* p;
	INT i;

	i = SendDlgItemMessage (hDlg, uID, WM_GETTEXTLENGTH, 0, 0);
	if (i > 0) {
		p = pkAlloc (i+1);
		if (p) {
			FillMemory (p, i, ' ');
			SendDlgItemMessage (hDlg, uID, WM_SETTEXT, 0, (LPARAM)p);
			pkFree (p);
		}
		SendDlgItemMessage (hDlg, uID, WM_SETTEXT, 0, (LPARAM)"");
	}
}


//	_______________________________________________
//
//	construct userid from name and address edit box contents

BOOL PKConstructUserID (
		HWND	hwnd, 
		UINT	uNameIDC, 
		UINT	uAddrIDC, 
		LPSTR*	ppszUserID) 
{
	BOOL		bReturn		= TRUE;

	UINT		uNameLen, uAddrLen;
	CHAR*		p;
	CHAR		szTemp[kPGPMaxUserIDSize];

	uNameLen = UTF8EditGetTextLength (GetDlgItem (hwnd, uNameIDC));
	if (uNameLen == 0) 
	{
		PKMessageBox (hwnd, IDS_CAPTIONINFO, 
				IDS_NOUSERNAME, MB_OK|MB_ICONINFORMATION);
		SetFocus (UTF8EditGetHandle (GetDlgItem (hwnd, uNameIDC)));
		return FALSE;
	}

	uAddrLen = UTF8EditGetTextLength (GetDlgItem (hwnd, uAddrIDC));
	if (uAddrLen == 0) 
	{
		if (PKMessageBox (hwnd, IDS_CAPTIONWARNING, IDS_NOUSERADDR, 
			MB_YESNO|MB_DEFBUTTON2|MB_ICONEXCLAMATION) == IDNO) 
		{
			SetFocus (UTF8EditGetHandle (GetDlgItem (hwnd, uAddrIDC)));
			return FALSE;
		}
	}

	p = szTemp;
	UTF8EditGetText (GetDlgItem (hwnd, uNameIDC), p, kPGPMaxUserIDSize/2);
	if (uAddrLen > 0) 
	{
		p += uNameLen;
		lstrcpy (p, " <");

		p += 2;
		UTF8EditGetText (GetDlgItem (hwnd, uAddrIDC), p, kPGPMaxUserIDSize/2);

		p += uAddrLen;
		lstrcpy (p, ">");
	}

	*ppszUserID = pkAlloc (kPGPMaxUserIDSize * sizeof(char));
	if (*ppszUserID)
		lstrcpy (*ppszUserID, szTemp);
	else
		bReturn = FALSE;

	return bReturn;
}


//	_______________________________________________
//
//	call clientlib function for keygen wizard and then send
//	update messages

VOID 
PKCreateKey (
		HWND		hwndParent, 
		PGPKeyDBRef keydb)
{
	PGPUInt32		uFlags;
	PGPKeyDBObjRef	keyNew;
	PGPError		err;

	err = PGPclKeyGenerationWizard (g_context, g_tlscontext, 
			hwndParent, keydb, &keyNew, &uFlags);

	if (IsntPGPError (err))
	{
		if (uFlags & kPGPclKeyCreate_NewKey)
		{
			SendMessage (hwndParent, PK_M_KEYCREATEDONE, 
					(WPARAM)uFlags, (LPARAM)keyNew);
			return;
		}
	}

	PostMessage (hwndParent, PK_M_KEYCREATEDONE, 0, 0);
}