clprefs.c

vc环境下的pgp源码

	}

	LoadString (g_hInst, IDS_ADMINPREFSFILE, sz, sizeof(sz));
	lstrcat (szPath, sz);

	// check for file existence
	dw = GetFileAttributes (szPath);
	if ((dw == 0xFFFFFFFF) || (dw & FILE_ATTRIBUTE_DIRECTORY)) {
		if (!bLoadDefaults)
			err = kPGPError_FileNotFound;
	}

	if (IsntPGPError (err)) {
		PFLNewFileSpecFromFullPath (memMgr, szPath, &FileRef);

		err = PGPOpenPrefFile (FileRef, adminDefaults, adminDefaultsSize,
				&AdminPrefRef);

		PFLFreeFileSpec (FileRef);
	}

	if (IsPGPError (err)) {
		PGPclMessageBox (NULL, IDS_CAPTIONERROR, IDS_NOADMINFILE,
									MB_OK|MB_ICONSTOP);
		if (PGPRefIsValid (AdminPrefRef)) 
			PGPClosePrefFile (AdminPrefRef);
	}
	else {	
		*pPrefRef = AdminPrefRef;
	}

	return err;
}


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

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

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

	// remove the username part
	p = strrchr(szPath, '\\');
	p++;
	*p = '\0';

	// add the location of the PGP files
	LoadString (g_hInst, IDS_ADMINPREFSFOLDER, sz, sizeof(sz));
	lstrcat (szPath, sz);

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

	LoadString (g_hInst, IDS_ADMINPREFSFILE, sz, sizeof(sz));
	lstrcat (szPath, sz);

	// check for file existence
	dw = GetFileAttributes (szPath);
	if ((dw == 0xFFFFFFFF) || (dw & FILE_ATTRIBUTE_DIRECTORY)) {
		if (!bLoadDefaults)
			err = kPGPError_FileNotFound;
	}

	if (IsntPGPError (err)) {
		PFLNewFileSpecFromFullPath (memMgr, szPath, &FileRef);

		err = PGPOpenPrefFile (FileRef, adminDefaults, adminDefaultsSize,
				&AdminPrefRef);

		// if an admin install and the file is corrupt, try deleting it
		// and reopening.
		if (bLoadDefaults && (err == kPGPError_CorruptData)) {
			DeleteFile (szPath);
			err = PGPOpenPrefFile (FileRef, adminDefaults, adminDefaultsSize,
				&AdminPrefRef);
		}

		PFLFreeFileSpec (FileRef);
	}

	if (IsPGPError (err)) {
		PGPclMessageBox (NULL, IDS_CAPTIONERROR, IDS_NOADMINFILE,
									MB_OK|MB_ICONSTOP);
		if (PGPRefIsValid (AdminPrefRef)) 
			PGPClosePrefFile (AdminPrefRef);
	}
	else {	
		*pPrefRef = AdminPrefRef;
	}

	return err;
}


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

PGPError PGPclExport
PGPclOpenAdminPrefs (
		PGPMemoryMgrRef	memMgr, 
		PGPPrefRef*		pPrefRef,
		BOOL			bLoadDefaults) 
{
	OSVERSIONINFO osid;

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

	switch (osid.dwPlatformId) {
	// Windows NT
	case VER_PLATFORM_WIN32_NT :
		return sOpenAdminPrefsNT (memMgr, pPrefRef, bLoadDefaults);

	// otherwise
	default :
		return sOpenAdminPrefs95 (memMgr, pPrefRef, bLoadDefaults);
	}
}


//	_______________________________________
//
//  Save and close down client preferences file

PGPError PGPclExport
PGPclCloseClientPrefs (
		PGPPrefRef	PrefRef, 
		BOOL		bSave) 
{
	PGPError		err;

	if (bSave) 
	{
		err = PGPSavePrefFile (PrefRef);
		pgpAssert (IsntPGPError(err));
	}

	if (IsPGPError (err))
		PGPClosePrefFile (PrefRef);
	else
	{
		err = PGPClosePrefFile (PrefRef);
		pgpAssert (IsntPGPError(err));
	}

	return err;
}

//	_______________________________________
//
//  Save and close down admin preferences file

PGPError PGPclExport
PGPclCloseAdminPrefs (
		PGPPrefRef	PrefRef, 
		BOOL		bSave) 
{
	PGPError		err;

	if (bSave) 
	{
		err = PGPSavePrefFile (PrefRef);
		pgpAssert (IsntPGPError(err));
	}

	if (IsPGPError (err))
		PGPClosePrefFile (PrefRef);
	else
	{
		err = PGPClosePrefFile (PrefRef);
		pgpAssert (IsntPGPError(err));
	}

	return err;
}

//	_______________________________________
//
//  Query registry to determine if client or admin installation

BOOL PGPclExport
PGPclIsAdminInstall (VOID)
{
	HKEY		hKey;
	LONG		lResult;
	DWORD		dwValueType, dwSize;
	CHAR		szKey[128];

	LoadString (g_hInst, IDS_REGISTRYKEY, szKey, sizeof(szKey));
	lResult = RegOpenKeyEx (HKEY_LOCAL_MACHINE, szKey, 0, KEY_READ, &hKey);

	if (lResult == ERROR_SUCCESS) {
		dwSize = sizeof(szKey);
		lResult = RegQueryValueEx (
			hKey, "InstallDate", 0, &dwValueType, (LPBYTE)szKey, &dwSize);
		RegCloseKey (hKey);
	}

	return (lResult == ERROR_SUCCESS);
}

BOOL PGPclExport
PGPclIsClientInstall (VOID)
{
	return !PGPclIsAdminInstall();
}

//	____________________________
//
//  Check for illegal file names

static BOOL 
sIsFileNameOK (LPSTR sz) 
{
	UINT	uLen;
	DWORD	dwAttrib;

	uLen = lstrlen (sz);

	if (uLen < 4) return FALSE;
	if ((sz[1] != ':') && (sz[1] != '\\')) return FALSE;
	if ((sz[1] == ':') && (sz[2] != '\\')) return FALSE;
	if (strcspn (sz, "/*?""<>|") != uLen) return FALSE;
	if (sz[uLen-1] == ':') return FALSE;
	if (sz[uLen-1] == '\\') return FALSE;

	dwAttrib = GetFileAttributes (sz);
	if (dwAttrib == 0xFFFFFFFF) return TRUE;	// file doesn't exist
	if (dwAttrib & FILE_ATTRIBUTE_DIRECTORY) return FALSE;
	if (dwAttrib & FILE_ATTRIBUTE_SYSTEM) return FALSE;

	return TRUE;
}

//	_____________________________________________________
//
//  verify that file or backup of file exists.  
//	if not, replace with default file name in install dir
//	if no install dir found, use Windows dir

static VOID
sVerifyFileExists (LPSTR lpszFile, PGPBoolean KeyRing)
{
	CHAR	sz[MAX_PATH];
	DWORD	dwAttrib;
	CHAR*	p;

	dwAttrib = GetFileAttributes (lpszFile);
	if ((dwAttrib == 0xFFFFFFFF) || 
			(dwAttrib & FILE_ATTRIBUTE_DIRECTORY)) {
		lstrcpy (sz, lpszFile);
		p = strrchr (sz, '\\');
		if (p) p++;
		else p = sz;

		if (IsPGPError (PGPclGetPGPPath (lpszFile, MAX_PATH))) 
			GetWindowsDirectory (lpszFile, MAX_PATH);
		else
		{
			if(KeyRing)
			{
				// We don't really want install directory.. we want 
				// PGP Keyrings subdirectory. Otherwise we'll just 
				// take windows like everything else -wjb

				CHAR	sz2[128];

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

				LoadString (g_hInst, IDS_KEYRINGFOLDER, sz2, sizeof(sz2));
				lstrcat (lpszFile, sz2);

				_mkdir (lpszFile); // just in case user deleted it
			}
		}

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

//	_____________________________________________________
//
//  Message processing function for property sheet dialog

static LRESULT WINAPI 
sFilePropDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	OPENFILENAME	OpenFileName;
	CHAR			szFile[MAX_PATH];
	CHAR			szRing[MAX_PATH];
	CHAR			szTemp[MAX_PATH];
	CHAR			szFilter[128];
	CHAR			szTitle[128];
	CHAR			szDefExt[8];
	CHAR*			p;
	HWND			hParent;
	RECT			rc;
	PGPError		err;
	PGPFileSpecRef	fileRef;
	LPSTR			lpsz;
	HANDLE			hfile;
	
	switch (uMsg) {

	case WM_INITDIALOG:
		if (bNeedsCentering) {
			hParent = GetParent (hDlg);
			GetWindowRect (hParent, &rc);
			SetWindowPos (hParent, NULL,
				(GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2,
				(GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 3,
				0, 0, SWP_NOSIZE | SWP_NOZORDER);
			bNeedsCentering = FALSE;
		}

		err = PGPsdkPrefGetFileSpec (ContextRef, kPGPsdkPref_PublicKeyring,
									&fileRef);
		if (IsntPGPError (err) && fileRef) {
			PGPGetFullPathFromFileSpec (fileRef, &lpsz);
			lstrcpy (szTemp, lpsz);
			PGPFreeData (lpsz);
			PGPFreeFileSpec (fileRef);

			sVerifyFileExists (szTemp, TRUE);
			SetDlgItemText (hDlg, IDC_PUBLICKEYRING, szTemp);
		}

		err = PGPsdkPrefGetFileSpec (ContextRef, kPGPsdkPref_PrivateKeyring,
									&fileRef);
		if (IsntPGPError (err) && fileRef) {
			PGPGetFullPathFromFileSpec (fileRef, &lpsz);
			lstrcpy (szTemp, lpsz);
			PGPFreeData (lpsz);
			PGPFreeFileSpec (fileRef);

			sVerifyFileExists (szTemp, TRUE);
			SetDlgItemText (hDlg, IDC_PRIVATEKEYRING, szTemp);
		}

		err = PGPsdkPrefGetFileSpec (ContextRef, kPGPsdkPref_RandomSeedFile,
									&fileRef);
		if (IsntPGPError (err) && fileRef) {
			PGPGetFullPathFromFileSpec (fileRef, &lpsz);
			lstrcpy (szTemp, lpsz);
			PGPFreeData (lpsz);
			PGPFreeFileSpec (fileRef);

			sVerifyFileExists (szTemp, FALSE);
			SetDlgItemText (hDlg, IDC_RNGSEEDFILE, szTemp);
		}

		szInitDir[0] = '\0';

		return TRUE;

    case WM_HELP: 
        WinHelp (((LPHELPINFO) lParam)->hItemHandle, g_szHelpFile, 
            HELP_WM_HELP, (DWORD) (LPSTR) aFileIds); 
        break; 
 
    case WM_CONTEXTMENU: 
        WinHelp ((HWND) wParam, g_szHelpFile, HELP_CONTEXTMENU, 
            (DWORD) (LPVOID) aFileIds); 
        break; 

	case WM_COMMAND :
		switch (LOWORD (wParam)) {
		case IDC_SETPRIVATEKEYRING :
			GetDlgItemText (hDlg, IDC_PRIVATEKEYRING, szFile, sizeof(szFile));
			if (GetFileAttributes (szFile) & FILE_ATTRIBUTE_DIRECTORY) {
				lstrcpy (szInitDir, szFile);
				szFile[0] = '\0';
			}
			else {
				if (szInitDir[0])
					szFile[0] = '\0';
			}
			LoadString (g_hInst, IDS_PRIVKEYRINGFILTER, szFilter, 
								sizeof(szFilter));
			while (p = strrchr (szFilter, '@')) *p = '\0';
			LoadString (g_hInst, IDS_PRIVKEYCAPTION, szTitle, 
								sizeof(szTitle));
			OpenFileName.lStructSize       = sizeof (OPENFILENAME);
			OpenFileName.hwndOwner         = hDlg;
			OpenFileName.hInstance         = (HANDLE)g_hInst;
			OpenFileName.lpstrFilter       = szFilter;
			OpenFileName.lpstrCustomFilter = (LPTSTR)NULL;
			OpenFileName.nMaxCustFilter    = 0L;
			OpenFileName.nFilterIndex      = 1L;
			OpenFileName.lpstrFile         = szFile;
			OpenFileName.nMaxFile          = sizeof (szFile);
			OpenFileName.lpstrFileTitle    = NULL;
			OpenFileName.nMaxFileTitle     = 0;
			OpenFileName.lpstrInitialDir   = szInitDir;
			OpenFileName.lpstrTitle        = szTitle;
			OpenFileName.Flags			   = OFN_HIDEREADONLY;
			OpenFileName.nFileOffset       = 0;
			OpenFileName.nFileExtension    = 0;
			LoadString (g_hInst, IDS_DEFPRIVRINGEXT, szDefExt, 
								sizeof(szDefExt));
			OpenFileName.lpstrDefExt       = szDefExt;
			OpenFileName.lCustData         = 0;
			if (GetOpenFileName (&OpenFileName)) {
				SetDlgItemText (hDlg, IDC_PRIVATEKEYRING, szFile);
				if (OpenFileName.nFileOffset > 0) 
					szFile[OpenFileName.nFileOffset-1] = '\0';
				lstrcpy (szInitDir, szFile);
			}
			break;

		case IDC_SETPUBLICKEYRING :
			GetDlgItemText (hDlg, IDC_PUBLICKEYRING, szFile, sizeof(szFile));
			if (GetFileAttributes (szFile) & FILE_ATTRIBUTE_DIRECTORY) {
				lstrcpy (szInitDir, szFile);
				szFile[0] = '\0';
			}
			else {
				if (szInitDir[0])
					szFile[0] = '\0';
			}
			LoadString (g_hInst, IDS_PUBKEYRINGFILTER, szFilter, 
								sizeof(szFilter));
			while (p = strrchr (szFilter, '@')) *p = '\0';
			LoadString (g_hInst, IDS_PUBKEYCAPTION, szTitle, sizeof(szTitle));
			OpenFileName.lStructSize       = sizeof (OPENFILENAME);
			OpenFileName.hwndOwner         = hDlg;
			OpenFileName.hInstance         = (HANDLE)g_hInst;
			OpenFileName.lpstrFilter       = szFilter;
			OpenFileName.lpstrCustomFilter = (LPTSTR)NULL;
			OpenFileName.nMaxCustFilter    = 0L;
			OpenFileName.nFilterIndex      = 1L;
			OpenFileName.lpstrFile         = szFile;
			OpenFileName.nMaxFile          = sizeof (szFile);
			OpenFileName.lpstrFileTitle    = NULL;
			OpenFileName.nMaxFileTitle     = 0;
			OpenFileName.lpstrInitialDir   = szInitDir;
			OpenFileName.lpstrTitle        = szTitle;
			OpenFileName.Flags			   = OFN_HIDEREADONLY;
			OpenFileName.nFileOffset       = 0;