ptprefs.c

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

		// setup code to monitor PGP prefs file
		hfile = CreateFile (s_szPGPPrefFile, 0,
				FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
				OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

		if (hfile == INVALID_HANDLE_VALUE)
			memset (&s_filetimePGPPrefs, 0, sizeof(FILETIME));
		else
		{
			GetFileTime (hfile, NULL, NULL, &s_filetimePGPPrefs);
			CloseHandle (hfile);
		}

		if (PGPclIsComponentInstalled (kPGPclPGPnet))
		{
			s_bNetInstalled = TRUE;

			// setup code to monitor PGPnet prefs file
			hfile = CreateFile (s_szNetPrefFile, 0,
					FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
					OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
			if (hfile == INVALID_HANDLE_VALUE)
				memset (&s_filetimePGPPrefs, 0, sizeof(FILETIME));
			else
			{
				GetFileTime (hfile, NULL, NULL, &s_filetimeNetPrefs);
				CloseHandle (hfile);
			}
		}

		s_heventKill = CreateEvent (
				NULL, FALSE, FALSE, NULL);

		if (IsntNull (s_heventKill))
		{
			s_hthreadPrefs = (HANDLE)_beginthreadex (
					NULL, 0, sFileChangeThread, NULL, 0, &dwID);
		}
	}

	return err;
}


//	______________________________________________
//
//	close down the prefs system

PGPError
PTClosePrefs (VOID)
{
	PGPError	err1	= kPGPError_NoErr;
	PGPError	err2	= kPGPError_NoErr;

	// kill the file change or hidden window thread
	if (IsntNull (s_hthreadPrefs))
	{
		if (s_bUsingPrefsService)
		{
			SendMessage (s_hwndHidden, WM_CLOSE, 0, 0);
			WaitForSingleObject (s_hthreadPrefs, INFINITE);
			CloseHandle (s_hthreadPrefs);
		}
		else
		{
			SetEvent (s_heventKill);
			WaitForSingleObject (s_hthreadPrefs, INFINITE);
			CloseHandle (s_hthreadPrefs);
		}
	}

	if (s_heventKill)
	{
		CloseHandle (s_heventKill);
		s_heventKill = NULL;
	}

	if (s_hContactService)
	{
		CloseHandle (s_hContactService);
		s_hContactService = NULL;
	}

	if (PGPPrefRefIsValid (s_prefref))
	{
		err1 = sClosePrefs (s_prefref, FALSE);
		s_prefref = kInvalidPGPPrefRef;
	}

	if (PGPPrefRefIsValid (s_prefrefNet))
	{
		err2 = sClosePrefs (s_prefrefNet, FALSE);
		s_prefrefNet = kInvalidPGPPrefRef;
	}

	if (IsPGPError (err1))
		return err1;
	else
		return err2;
}


//	______________________________________________
//
//	return the requested prefrefs to the caller

PGPError
PTPeekPrefRefs (
		PGPPrefRef*		pprefref,
		PGPPrefRef*		pprefrefNet)
{
	PGPError		err			= kPGPError_NoErr;
	DWORD			dw;
	PFLFileSpecRef	fileref;
	PGPPrefRef		prefrefPrev;

	if (IsntNull (pprefref))
		*pprefref = kInvalidPGPPrefRef;
	if (IsntNull (pprefrefNet))
		*pprefrefNet = kInvalidPGPPrefRef;

	if (s_hContactService)
		WaitForSingleObject (s_hContactService, INFINITE);

	if (s_bUsingPrefsService)
	{
		if (IsntNull (pprefref))
		{
			prefrefPrev = s_prefref;

			if (SendMessageTimeout (s_hwndService, PGP_M_QUERYPREFS,
					(WPARAM)s_iPGPSequenceNumber, (LPARAM)s_hwndHidden,
					SMTO_NORMAL, SERVICE_MESSAGE_TIMEOUT, &dw) == 0)
			{
				err = kPGPError_Win32_NoPrefsServiceResponse;
			}

			if (IsPGPError (err))
			{
				if (PGPPrefRefIsValid (s_prefref))
					PGPFreePrefs (s_prefref);
				s_prefref = kInvalidPGPPrefRef;
				if (s_hContactService)
					ReleaseMutex (s_hContactService);
			}

			if (IsPGPError (err))
				return err;

			*pprefref = s_prefref;
		}

		if (IsntNull (pprefrefNet))
		{
			if (!s_bNetInstalled)
			{
				if (s_hContactService)
					ReleaseMutex (s_hContactService);
				return kPGPError_BadParams;
			}

			prefrefPrev = s_prefrefNet;

			if (SendMessageTimeout (s_hwndService, PGP_M_QUERYNETPREFS,
					(WPARAM)s_iNetSequenceNumber, (LPARAM)s_hwndHidden,
					SMTO_NORMAL, SERVICE_MESSAGE_TIMEOUT, &dw) == 0)
			{
				err = kPGPError_Win32_NoPrefsServiceResponse;
			}

			if (IsPGPError (err))
			{
				if (PGPPrefRefIsValid (s_prefrefNet))
					PGPFreePrefs (s_prefrefNet);
				s_prefrefNet = kInvalidPGPPrefRef;
				if (s_hContactService)
					ReleaseMutex (s_hContactService);
			}

			if (IsPGPError (err))
				return err;

			*pprefrefNet = s_prefrefNet;
		}
	}
	else
	{
		// we're using stand-alone file-based prefs
		if (PGPPrefRefIsValid (s_prefref))
		{
			if (s_bPGPPrefsModified || sPGPPrefsFileTimeChanged ())
			{
				PGPFreePrefs (s_prefref);
				s_prefref = kInvalidPGPPrefRef;
				s_bPGPPrefsModified = FALSE;
			}
		}

		if (PGPPrefRefIsValid (s_prefrefNet))
		{
			if (s_bNetPrefsModified || sNetPrefsFileTimeChanged ())
			{
				PGPFreePrefs (s_prefrefNet);
				s_prefrefNet = kInvalidPGPPrefRef;
				s_bNetPrefsModified = FALSE;
			}
		}

		if (IsntNull (pprefref))
		{
			if (!PGPPrefRefIsValid (s_prefref) &&
				(s_szPGPPrefFile[0] != '\0'))
			{
				PFLNewFileSpecFromFullPath (PGPPeekContextMemoryMgr (s_context),
						s_szPGPPrefFile, &fileref);

				err = PGPOpenPrefFile (fileref,
						clientDefaults, clientDefaultsSize, &s_prefref);

				if ((err == kPGPError_FileOpFailed) ||
					(err == kPGPError_FileNotFound))
				{
					err = PFLFileSpecCreate (fileref);
					err = PGPOpenPrefFile (fileref,
							clientDefaults, clientDefaultsSize, &s_prefref);
				}
				PFLFreeFileSpec (fileref);

				if (IsPGPError (err))
				{
					if (PGPPrefRefIsValid (s_prefref))
						PGPFreePrefs (s_prefref);
					s_prefref = kInvalidPGPPrefRef;
					if (s_hContactService)
						ReleaseMutex (s_hContactService);
				}

				if (IsPGPError (err))
					return err;
			}
			*pprefref = s_prefref;
		}

		if (IsntNull (pprefrefNet))
		{
			if (!s_bNetInstalled)
			{
				if (s_hContactService)
					ReleaseMutex (s_hContactService);
				return kPGPError_BadParams;
			}

			if (!PGPPrefRefIsValid (s_prefrefNet))
			{
				PFLNewFileSpecFromFullPath (PGPPeekContextMemoryMgr (s_context),
						s_szNetPrefFile, &fileref);

				err = PGPOpenPrefFile (fileref,
						netDefaults, netDefaultsSize, &s_prefrefNet);

				if ((err == kPGPError_FileOpFailed) ||
					(err == kPGPError_FileNotFound))
				{
					err = PFLFileSpecCreate (fileref);
					err = PGPOpenPrefFile (fileref, netDefaults,
							netDefaultsSize, &s_prefrefNet);
				}

				if (fileref)
					PFLFreeFileSpec (fileref);

				if (IsPGPError (err))
				{
					if (PGPPrefRefIsValid (s_prefrefNet))
						PGPFreePrefs (s_prefrefNet);
					s_prefrefNet = kInvalidPGPPrefRef;
					if (s_hContactService)
						ReleaseMutex (s_hContactService);
				}

				if (IsPGPError (err))
					return err;
			}
			*pprefrefNet = s_prefrefNet;
		}
	}

	if (s_hContactService)
		ReleaseMutex (s_hContactService);
	return err;
}


//	______________________________________________
//
//	flush the specified prefrefs to disk or service

PGPError
PTFlushPrefs (
		PGPPrefRef		prefref,
		PGPPrefRef		prefrefNet)
{
	PGPError	err			= kPGPError_NoErr;
	BOOL		bPGPSaved	= FALSE;
	BOOL		bNetSaved	= FALSE;
	PGPByte*	pbyte;
	DWORD		dw;

	if (s_bUsingPrefsService)
	{
		COPYDATASTRUCT					cds;
		PGPPrefsCopyDataStructure*		ppcds;

		if (PGPPrefRefIsValid (prefref))
		{
			err = PGPExportPrefsToBuffer (s_prefref, &dw, &pbyte);
			if (IsntPGPError (err))
			{
				ppcds = PGPNewData (
						PGPPeekContextMemoryMgr (s_context),
						dw + sizeof (PGPPrefsCopyDataStructure) - 1, 0);

				if (IsntNull (ppcds))
				{
					ppcds->sequenceNumber = s_iPGPSequenceNumber;
					ppcds->bufferLength = dw;
					pgpCopyMemory (pbyte, ppcds->buffer, dw);
					PGPFreeData (pbyte);

					cds.cbData = sizeof(PGPPrefsCopyDataStructure) + dw - 1;
					cds.lpData = ppcds;
					cds.dwData = PGP_PGPPREFSDATA;

					if (SendMessageTimeout (s_hwndService, WM_COPYDATA,
							(WPARAM)s_hwndHidden, (LPARAM) &cds,
							SMTO_NORMAL, SERVICE_MESSAGE_TIMEOUT, &dw) == 0)
					{
						err = kPGPError_Win32_NoPrefsServiceResponse;
					}
					else
					{
						if (dw == PGP_INVALIDPREFSEQUENCE)
							err = kPGPError_Win32_PrefRefNoLongerValid;
						else
							s_iPGPSequenceNumber = dw;
					}
					PGPFreeData (ppcds);
				}
			}
		}

		if (s_bNetInstalled && PGPPrefRefIsValid (prefrefNet))
		{
			err = PGPExportPrefsToBuffer (s_prefrefNet, &dw, &pbyte);
			if (IsntPGPError (err))
			{
				ppcds = PGPNewData (
						PGPPeekContextMemoryMgr (s_context),
						dw + sizeof (PGPPrefsCopyDataStructure) - 1, 0);

				if (IsntNull (ppcds))
				{
					ppcds->sequenceNumber = s_iNetSequenceNumber;
					ppcds->bufferLength = dw;
					pgpCopyMemory (pbyte, ppcds->buffer, dw);
					PGPFreeData (pbyte);

					cds.cbData = sizeof(PGPPrefsCopyDataStructure) + dw - 1;
					cds.lpData = ppcds;
					cds.dwData = PGP_PGPNETPREFSDATA;

					if (SendMessageTimeout (s_hwndService, WM_COPYDATA,
							(WPARAM)s_hwndHidden, (LPARAM) &cds,
							SMTO_NORMAL, SERVICE_MESSAGE_TIMEOUT, &dw) == 0)
					{
						err = kPGPError_Win32_NoPrefsServiceResponse;
					}
					else
					{
						if (dw == PGP_INVALIDPREFSEQUENCE)
							err = kPGPError_Win32_PrefRefNoLongerValid;
						else
							s_iNetSequenceNumber = dw;
					}
					PGPFreeData (ppcds);
				}
			}
		}
	}
	else
	{
		if (s_bPGPPrefsModified && PGPPrefRefIsValid (s_prefref))
		{
			PGPFreePrefs (s_prefref);
			s_prefref = kInvalidPGPPrefRef;
			s_bPGPPrefsModified = FALSE;
		}

		if (s_bNetPrefsModified && PGPPrefRefIsValid (s_prefrefNet))
		{
			PGPFreePrefs (s_prefrefNet);
			s_prefrefNet = kInvalidPGPPrefRef;
			s_bNetPrefsModified = FALSE;
		}

		if (PGPPrefRefIsValid (prefref))
		{
			if (prefref == s_prefref)
			{
				err = PGPSavePrefFile (prefref);
				if (IsntPGPError (err))
					bPGPSaved = TRUE;
			}
			else
				err = kPGPError_Win32_PrefRefNoLongerValid;
		}

		if (IsPGPError (err))
			return err;

		if (s_bNetInstalled && PGPPrefRefIsValid (prefrefNet))
		{
			if (prefrefNet == s_prefrefNet)
			{
				err = PGPSavePrefFile (prefrefNet);
				if (IsntPGPError (err))
					bNetSaved = TRUE;
			}
			else
				err = kPGPError_Win32_PrefRefNoLongerValid;
		}

		if (bPGPSaved || bNetSaved)
			Sleep (100);

		if (bPGPSaved)
		{
			s_bPGPPrefsModified = FALSE;
			memset (&s_filetimePGPPrefs, 0, sizeof(FILETIME));
			PGPclNotifyPrefsChanges (0);
		}

		if (bNetSaved)
		{
			s_bNetPrefsModified = FALSE;
			memset (&s_filetimeNetPrefs, 0, sizeof(FILETIME));
			PGPclNotifyNetPrefsChanges (0);
		}
	}

	return err;
}