ptdisk.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 500 行

/*____________________________________________________________________________
 Copyright (C) 2002 PGP Corporation
 All rights reserved.
 
 $Id: PTdisk.c,v 1.34 2002/11/22 02:32:15 wjb Exp $
____________________________________________________________________________*/

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <shellapi.h>
#include <stdio.h>

#define WM_WTSSESSION_CHANGE            0x02B1
#define WTS_CONSOLE_CONNECT                0x1
#define WTS_CONSOLE_DISCONNECT             0x2
#define WTS_REMOTE_CONNECT                 0x3
#define WTS_REMOTE_DISCONNECT              0x4
#define WTS_SESSION_LOGON                  0x5
#define WTS_SESSION_LOGOFF                 0x6
#define WTS_SESSION_LOCK                   0x7
#define WTS_SESSION_UNLOCK                 0x8
#define WTS_SESSION_REMOTE_CONTROL         0x9

#define PGPDISK_DYNLINK

#include "pgpMem.h"
#include "pgpPflPriv.h"

#include "PGPclientlib.h"
#include "pgpClientErrors.h"
#include "pgpClientPrefs.h"
#include "PGPdiskEngine.h"
#include "PGPdiskUI.h"

#include "PTdisk.h"

//	________________________
//
// PGPdisk constants

static const char	*kPGPdiskNotAvailText	= 
	"Your PGPdisk installation is not valid. Please re-install PGP and try "
	"again.";
static const char	*kPGPdiskNoSleepOnUnmountFailure = 
	"Computer sleep has been prevented because PGPdisk could not unmount "
	"one or more of its volumes.";

//	________________________
//
// PGPdisk static variables

static PGPBoolean	PGPdiskInitialized=FALSE;
static PGPBoolean	PGPdiskEngineInitialized=FALSE;
static PGPBoolean	PGPdiskUIInitialized=FALSE;

static PGPdiskContextRef	PGPdiskContext	= kInvalidPGPdiskContextRef;

static PGPBoolean	PGPdiskUnmountOnSleep=FALSE;
static PGPBoolean	PGPdiskNoSleepIfUnmountFail=FALSE;
static UINT			uReloadKeyRingMsg=0;

//	_______________
//
//	Report an error

static 
VOID 
sReportError(const char *formatStr, PGPError error, HWND parent)
{
	pgpAssertStrValid(formatStr);

	if ((error != kPGPError_NoErr) && (error != kPGPError_UserAbort))
	{
		static char	pgpStrBuf[512];
		static char	errStrBuf[1024];

		PGPGetClientErrorString(error, 512, pgpStrBuf);
		sprintf(errStrBuf, formatStr, pgpStrBuf);

		MessageBox(parent, errStrBuf, "PGP Tray", MB_ICONERROR | MB_OK);
	}
}

//	________________________
//
//	Check if PGPdisk available

static 
PGPBoolean 
sCheckWarnPGPdiskAvailable(PGPBoolean silently, HWND parent)
{
	if (!PGPdiskInitialized)
	{
		if (!silently)
		{
			MessageBox(parent, kPGPdiskNotAvailText, "PGP Tray", 
				MB_ICONERROR | MB_OK);
		}

		return FALSE;
	}
	else
	{
		return TRUE;
	}
}

//	________________________
//
//	Perform PGPdisk initialization

VOID 
PTDiskStartup()
{
	PGPError	error	= kPGPError_NoErr;

	if (PGPdiskInitialized)
		return;

	uReloadKeyRingMsg = RegisterWindowMessage (kPGPclReloadKeyRingMsg);

	error = PGPdiskEngineInitLibrary(0);

	if (IsntPGPError(error))
	{
		PGPdiskEngineInitialized = TRUE;
		error = PGPdiskUIInitLibrary();
	}

	if (IsntPGPError(error))
	{
		PGPdiskUIInitialized = TRUE;
		error = PGPdiskNewContext(kPGPdiskAPIVersion, &PGPdiskContext);
	}

	if (IsntPGPError(error))
		PGPdiskInitialized = TRUE;
	else
		PTDiskShutdown();
}

//	________________________
//
//	Perform PGPdisk shutdown

VOID
PTDiskShutdown()
{
	if (PGPdiskContextRefIsValid(PGPdiskContext))
	{
		PGPdiskFreeContext(PGPdiskContext);
		PGPdiskContext = kInvalidPGPdiskContextRef;
	}

	if (PGPdiskUIInitialized)
	{
		PGPdiskUICleanupLibrary();
		PGPdiskUIInitialized = FALSE;
	}

	if (PGPdiskEngineInitialized)
	{
		PGPdiskEngineCleanupLibrary();
		PGPdiskEngineInitialized = FALSE;
	}

	PGPdiskInitialized = FALSE;
}

//	________________________
//
//	Mount startup PGPdisks.

VOID
PTDiskMountStartupDisks(HWND parent)
{
	PGPError	error	= kPGPError_NoErr;

	if (!sCheckWarnPGPdiskAvailable(TRUE, parent))
		return;

	error = PGPdiskMountStartupDisks(PGPdiskContext, NULL);

	if (IsPGPError(error))
	{
		sReportError("PGPdisk Mount At Startup failed because: \"%s.\"", 
			error, parent);
	}
}

//	________________________
//
//	Invoke app command line.

static 
VOID 
sInvokePGPdiskApp(const char *command, const char *path, HWND parent)
{
	static char	cmdLine[kPGPdiskMaxPathLength * 2];
	PGPUInt32	result;

	pgpAssertStrValid(command);

	strcpy(cmdLine, command);
	strcat(cmdLine, " ");

	if (IsntNull(path))
	{
		strcat(cmdLine, "\"");
		strcat(cmdLine, path);
		strcat(cmdLine, "\"");
	}

	result	= (PGPUInt32) ShellExecute(NULL, "open", PGPDISK_EXE_NAME, 
		cmdLine, NULL, SW_SHOWNORMAL);

	if (result < 32)
	{
		MessageBox(parent, kPGPdiskNotAvailText, "PGP Tray", 
			MB_ICONERROR | MB_OK);
	}
}

//	________________________
//
//	Create a PGPdisk.

static 
VOID 
sCreatePGPdisk(HWND parent)
{
	if (!sCheckWarnPGPdiskAvailable(FALSE, parent))
		return;

	// go to app for this command, should be in separate process
	sInvokePGPdiskApp("create", NULL, parent);
}

//	________________________
//
//	Edit a PGPdisk

static 
VOID 
sEditPGPdisk(HWND parent)
{
	char		path[kPGPdiskMaxPathLength];
	PGPError	error	= kPGPError_NoErr;

	if (!sCheckWarnPGPdiskAvailable(FALSE, parent))
		return;

	error = PGPdiskAskChooseDisk(PGPdiskContext, NULL, NULL, NULL, path, 
		kPGPdiskMaxPathLength);

	// go to app for this command, should be in separate process
	if (IsntPGPError(error))
		sInvokePGPdiskApp("edit", path, parent);

	if (IsPGPError(error))
		sReportError("PGPdisk Edit failed because: \"%s.\"", error, parent);
}

//	________________________
//
//	Mount a PGPdisk

static 
VOID 
sMountPGPdisk(HWND parent)
{
	char		path[kPGPdiskMaxPathLength];
	PGPError	error	= kPGPError_NoErr;

	if (!sCheckWarnPGPdiskAvailable(FALSE, parent))
		return;

	error = PGPdiskAskChooseDisk(PGPdiskContext, NULL, NULL, NULL, path, 
		kPGPdiskMaxPathLength);

	if (IsntPGPError(error))
		error = PGPdiskAskMountDisk(PGPdiskContext, path, NULL);

	if (IsPGPError(error))
		sReportError("PGPdisk Mount failed because: \"%s.\"", error, parent);
}

//	________________________
//
//	Unmount all PGPdisks

static 
PGPBoolean 
sUnmountAllPGPdisks(PGPBoolean timedOutOnly, PGPBoolean silently, 
					PGPBoolean shutdown, HWND parent)
{
	PGPError	error	= kPGPError_NoErr;
	PGPUInt32	flags	= kPGPdiskNoUnmountFlags;

	if (!sCheckWarnPGPdiskAvailable(silently, parent))
		return FALSE;

	if (silently)
		flags |= kPGPdiskSilentUnmountFlag;

	if (timedOutOnly)
		flags |= kPGPdiskTimedOutUnmountAllFlag;

	if (shutdown)
		flags |= kPGPdiskShutdown;

	error = PGPdiskAskUnmountAllDisks(PGPdiskContext, NULL, flags);

	if (IsPGPError(error) && !silently)
	{
		sReportError("PGPdisk Unmount All failed because: \"%s.\"", error, 
			parent);
	}

	return ((IsntPGPError(error))||(error==kPGPClientError_DiskNotMounted));
}

//	________________________
//
//	Perform user-initiated PGPdisk operation

VOID
PTDiskOperation(
		HWND	hwnd,
		UINT	uOperation)
{
	switch (uOperation) 
	{
		case PGPDISK_NEWDISK:
			sCreatePGPdisk(hwnd);
			break;

		case PGPDISK_EDITDISK:
			sEditPGPdisk(hwnd);
			break;

		case PGPDISK_MOUNTDISK:
			sMountPGPdisk(hwnd);
			break;

		case PGPDISK_UNMOUNTALL:
			sUnmountAllPGPdisks(FALSE, FALSE, FALSE, hwnd);
			break;
	}
}

//	________________________
//
//	prefs may have changed, do anything we need to do 

VOID
PTHandleDiskPrefsChange(
		HWND		hwnd,
		PGPPrefRef	prefref)
{
	if (!sCheckWarnPGPdiskAvailable(TRUE, hwnd))
		return;

	PGPGetPrefBoolean(prefref, kPGPPrefDiskAutoUnmountOnSleep, 
		&PGPdiskUnmountOnSleep);
	PGPGetPrefBoolean(prefref, kPGPPrefDiskNoSleepIfFailAU, 
		&PGPdiskNoSleepIfUnmountFail);

	PGPdiskPrefsChanged(PGPdiskContext, prefref);
}

//	________________________
//
//	Handle WM_POWERBROADCAST

LRESULT 
PTDiskHandlePowerBroadcast(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
	PGPError			error					= kPGPError_NoErr;
	PGPBoolean			denyThisMessage			= FALSE;
	static PGPBoolean	sawASleepRequest		= FALSE;
	static PGPBoolean	failAllSleepRequests	= FALSE;

	if (!sCheckWarnPGPdiskAvailable(TRUE, hwnd))
		return TRUE;

	// Windows will send us multiple sleep requests, but we will only process
	// the first one.

	switch (wParam)
	{
	case PBT_APMQUERYSUSPEND:
		if (sawASleepRequest)
		{
			denyThisMessage = failAllSleepRequests;
		}
		else
		{
			sawASleepRequest = TRUE;

			// Fail the sleep if error and the preference was set.
			if (PGPdiskUnmountOnSleep && 
				!sUnmountAllPGPdisks(FALSE, TRUE, FALSE, hwnd) && 
				PGPdiskNoSleepIfUnmountFail)
			{
				denyThisMessage = TRUE;
				failAllSleepRequests = TRUE;
			}
		}
		break;

	case PBT_APMQUERYSUSPENDFAILED:
		if (failAllSleepRequests)
		{
			MessageBox(hwnd, kPGPdiskNoSleepOnUnmountFailure, "PGP Tray", 
				MB_ICONERROR | MB_OK);
		}

		sawASleepRequest = FALSE;
		failAllSleepRequests = FALSE;
		break;

	case PBT_APMSUSPEND:
		sawASleepRequest = FALSE;
		failAllSleepRequests = FALSE;
		break;
	}

	if (denyThisMessage)
		return BROADCAST_QUERY_DENY;
	else
		return DefWindowProc(hwnd, WM_POWERBROADCAST, wParam, lParam);
}

//	________________________
//
//	Check for inactivity timed-out disks.

VOID 
PTDiskCheckForTimedOutDisks(HWND hwnd)
{
	if (!sCheckWarnPGPdiskAvailable(TRUE, hwnd))
		return;

	if (PGPdiskAreDisksTimedOut())
		sUnmountAllPGPdisks(TRUE, TRUE, FALSE, hwnd);
}

//	________________________
//
//	check incoming message for something pertaining to PGPdisk

VOID 
PTCheckForDiskMsg(
		HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam)
{
	if (!sCheckWarnPGPdiskAvailable(TRUE, hwnd))
		return;

	if(msg==uReloadKeyRingMsg)
	{
		// Make sure PGPdisk reloads the new keyring next time
		PGPdiskDirtyPGPKeyDB(PGPdiskContext);
	}

	switch (msg) 
	{
	case WM_ENDSESSION:
		if ((BOOL) wParam)
		{
			// Shutdown flag prevents prefs from being
			// accessed since pref service may have shutdown -wjb
			sUnmountAllPGPdisks(FALSE, TRUE, TRUE, hwnd);
			PGPdiskNotifyUserLogoff();
		}
		break;
	case WM_CLOSE:
		{
			sUnmountAllPGPdisks(FALSE, TRUE, TRUE, hwnd);
		break;
		}
	case WM_WTSSESSION_CHANGE:
		{
			switch(wParam)
			{
				case WTS_CONSOLE_DISCONNECT:
				case WTS_REMOTE_DISCONNECT:
				case WTS_SESSION_LOGOFF:
					sUnmountAllPGPdisks(FALSE, TRUE, TRUE, hwnd);
					break;
			}
			break;
		}
	}
}