cpgpdiskapp.cpp

vc环境下的pgp源码

//////////////////////////////////////////////////////////////////////////////
// CPGPdiskApp.cpp
//
// Implementation of class CPGPdiskApp.
//////////////////////////////////////////////////////////////////////////////

// $Id: CPGPdiskApp.cpp,v 1.26 1999/02/26 04:09:57 nryan Exp $

// Copyright (C) 1998 by Network Associates, Inc.
// All rights reserved.

#include "StdAfx.h"

#include "Required.h"
#include "DriverComm.h"
#include "GlobalPGPContext.h"
#include "PGPdiskPrefs.h"
#include "PGPdiskResidentDefines.h"
#include "UtilityFunctions.h"

#include "CMainDialog.h"
#include "CNagBuyDialog.h"
#include "CPGPdiskApp.h"
#include "CPGPdiskCmdLine.h"
#include "CPreferencesSheet.h"

#undef IDB_CREDITS1
#undef IDB_CREDITS4
#undef IDB_CREDITS8
#undef IDC_CREDITS

#include "PGPclx.h"


////////////
// Constants
////////////

const PGPUInt32 kSplashTimeMs = 2500;

static LPCSTR kPGPdiskMainWndTitle	= kPGPdiskAppName;
static LPCSTR kSharedMemNamePrefix	= "PGPdiskSharedMem";


///////////////////////////
// Global variables for MFC
///////////////////////////

CPGPdiskApp theApp;


///////////////////////////////////////
// Global variables for the application
///////////////////////////////////////

CPGPdiskApp *App;		// pointer to application object


///////////////////////////
// MFC specific definitions
///////////////////////////

// MFC message map

BEGIN_MESSAGE_MAP(CPGPdiskApp, CWinApp)
	//{{AFX_MSG_MAP(CPGPdiskApp)
	ON_COMMAND(ID_CONTEXT_HELP, OnContextHelp) 
	ON_COMMAND(ID_HELP, OnHelp)
	//}}AFX_MSG
END_MESSAGE_MAP()


///////////////////////////////////////////////////////////////////////
// CPGPdiskApp public custom functions and non-default message handlers
///////////////////////////////////////////////////////////////////////

// The CPGPdiskApp constructor.

CPGPdiskApp::CPGPdiskApp()
{
	mPAII		= NULL;
	mMainDialog	= NULL;

	mCommandLineMode = FALSE;

	mAutoUnmount			= FALSE;
	mHotKeyEnabled			= FALSE;
	mHotKeyCode				= 0;
	mUnmountOnSleep			= FALSE;
	mNoSleepIfUnmountFail	= kDefaultNoSleepIfUnmountFail;
	mUnmountTimeout			= kDefaultUnmountTimeout;

	if (IsWin95CompatibleMachine())
	{
		mPlatformMaxKbSize = kPGPdiskMaxKbSizeWin95;
		mPlatformMinKbSize = kPGPdiskMinKbSizeWin95;
	}
	else
	{
		mPlatformMaxKbSize = kPGPdiskMaxKbSizeWinNT;
		mPlatformMinKbSize = kPGPdiskMinKbSizeWinNT;
	}
}

// AbortPGPdiskApp is the correct way to abort.

void 
CPGPdiskApp::AbortPGPdiskApp()
{
	exit(-1);
}

// CallShowAboutBox displays the PGPdisk about box.

void 
CPGPdiskApp::CallShowAboutBox()
{	
	AppCommandInfo ACI;

	ACI.op		= kAppOp_ShowAboutBox;
	ACI.flags	= NULL;
	ACI.drive	= kInvalidDrive;
	ACI.path[0]	= '\0';

	DispatchAppCommandInfo(&ACI);
}

// CallShowHelp displays the PGPdisk help file.

void 
CPGPdiskApp::CallShowHelp()
{	
	AppCommandInfo ACI;

	ACI.op		= kAppOp_ShowHelp;
	ACI.flags	= NULL;
	ACI.drive	= kInvalidDrive;
	ACI.path[0]	= '\0';

	DispatchAppCommandInfo(&ACI);
}

// CallShowPrefs displays the PGPdisk preferences.

void 
CPGPdiskApp::CallShowPrefs()
{	
	AppCommandInfo ACI;

	ACI.op		= kAppOp_ShowPrefs;
	ACI.flags	= NULL;
	ACI.drive	= kInvalidDrive;
	ACI.path[0]	= '\0';

	DispatchAppCommandInfo(&ACI);
}

// SetDriverPrefsFromApp informs the driver of the state of the application's
// preferences.

DualErr 
CPGPdiskApp::SetDriverPrefsFromApp()
{
	return SetDriverPrefs(mAutoUnmount, mUnmountTimeout);
}

// CreatePGPdiskResidentApp starts a normal PGPdisk resident application.

DualErr 
CPGPdiskApp::CreatePGPdiskResidentApp()
{
	DualErr				derr;
	PROCESS_INFORMATION	PI;
	STARTUPINFO			SI;

	pgpClearMemory(&SI, sizeof(SI));
	SI.cb = sizeof(SI);

	if (!CreateProcess(NULL, (LPSTR) kPGPdiskResAppName, NULL, NULL, FALSE, 
		0, NULL, NULL, &SI, &PI))
	{
		derr = DualErr(kPGDMinorError_CreateProcessFailed, GetLastError());
	}

	return derr;
}

// UpdatePGPdiskResident starts and/or updates the PGPdiskResident
// application.

PGPBoolean 
CPGPdiskApp::UpdatePGPdiskResident()
{
	DualErr			derr;
	PGPBoolean		succeeded	= FALSE;
	PGPdiskResInfo	*pgpDiskResInfo;
	SharedMemory	pgpDiskResInfoMem;

	// Try to find an existing PGPdiskResident application.
	derr = pgpDiskResInfoMem.Attach(kPGPdiskResSharedMemName);

	// If found, update it. If not, spawn another one.
	if (derr.IsntError())
	{
		pgpDiskResInfo = (PGPdiskResInfo *) 
			pgpDiskResInfoMem.GetMemPointer();

		PostMessage(pgpDiskResInfo->hiddenWindowHwnd, WM_PGPDISKRES_NEWPREFS, 
			kPGPdiskMessageMagic, NULL);

		succeeded = TRUE;
	}
	else
	{
		succeeded = CreatePGPdiskResidentApp().IsntError();
	}

	if (pgpDiskResInfoMem.IsMemAttached())
		pgpDiskResInfoMem.Detach();

	return succeeded;
}

// FindAndShowNonCommandLinePGPdiskApp looks for and shows a pre-existing
// non-command-line PGPdisk application. TRUE is returned if a match is
// found.

PGPBoolean 
CPGPdiskApp::FindAndShowNonCommandLinePGPdiskApp()
{
	PGPBoolean foundApp = FALSE;;

	try
	{
		CString				memName;
		DualErr				derr;
		PAppInstanceInfo	pAII;
		PGPUInt32			i;
		SharedMemory		sharedMem;

		// Step through all running apps.
		for (i = 0; i < kMaxPGPdiskApps; i++)
		{
			memName.Format("%s%d", kSharedMemNamePrefix, i);

			if (mSharedAppInfoMem.IsMemAttached() && 
				(memName == mSharedAppInfoMem.GetMemName()))
			{
				continue;
			}

			// Try to attach the shared memory.
			derr = sharedMem.Attach(memName);

			// If succeeded, examine the memory.
			if (derr.IsntError())
			{
				pAII = (PAppInstanceInfo) sharedMem.GetMemPointer();

				// If it's a non-command-line app, show it.
				if (!pAII->commandLineMode)
				{
					foundApp = TRUE;
					BringThisPGPdiskAppToFront(pAII->mainDialogHwnd);

					break;
				}
			}

			if (sharedMem.IsMemAttached())
				sharedMem.Detach();
		}
	}
	catch (CMemoryException *ex)
	{
		ex->Delete();
	}

	return foundApp;
}

// FindAndShowSimilarPGPdiskApp looks for a pre-existing PGPdisk
// application that is currently performing the same function that this
// application is performing now. If one is found, its frontmost window is
// shown and TRUE is returned.

PGPBoolean 
CPGPdiskApp::FindAndShowSimilarPGPdiskApp(PAppCommandInfo pACI)
{
	PGPBoolean foundApp = FALSE;

	try
	{
		CString				memName;
		DualErr				derr;
		PAppInstanceInfo	pAII;
		PGPUInt32			i;
		SharedMemory		sharedMem;

		pgpAssertAddrValid(pACI, AppCommandInfo);

		// Compare current command to commands of all running apps.
		for (i = 0; i < kMaxPGPdiskApps; i++)
		{
			memName.Format("%s%d", kSharedMemNamePrefix, i);

			// Don't consider ourselves.
			if (mSharedAppInfoMem.IsMemAttached() && 
				(memName == mSharedAppInfoMem.GetMemName()))
			{
				continue;
			}

			// Try to attach the shared memory.
			derr = sharedMem.Attach(memName);

			// If succeeded, examine the memory.
			if (derr.IsntError())
			{
				pAII = (PAppInstanceInfo) sharedMem.GetMemPointer();

				// Compare commands.
				if (AreAppCommandsSimilar(pACI, &pAII->ACI))
				{
					foundApp = TRUE;
					BringThisPGPdiskAppToFront(pAII->mainDialogHwnd);

					break;
				}
			}

			if (sharedMem.IsMemAttached())
				sharedMem.Detach();
		}
	}
	catch (CMemoryException *ex)
	{
		ex->Delete();
	}

	return foundApp;
}

// SetSharedMemoryCommandInfo sets the ACI structure.

void 
CPGPdiskApp::SetSharedMemoryCommandInfo(AppCommandInfo *pACI)
{
	pgpAssertAddrValid(pACI, AppCommandInfo);

	mPAII->ACI = (* pACI);
}

// ClearSharedMemoryCommandInfo sets the ACI structure in the app's shared
// memory object to a NULL op.

void 
CPGPdiskApp::ClearSharedMemoryCommandInfo()
{
	pgpAssertAddrValid(mPAII, AppInstanceInfo);

	mPAII->ACI.op		= kAppOp_InvalidRequest;
	mPAII->ACI.flags	= NULL;
	mPAII->ACI.drive	= kInvalidDrive;
	mPAII->ACI.path[0]	= NULL;
}

// ExitPGPdiskApp is the correct way to exit normally.

void 
CPGPdiskApp::ExitPGPdiskApp()
{
	// This works even when called from other threads.
	::PostThreadMessage(App->m_nThreadID, WM_QUIT, NULL, NULL);
}


//////////////////////////////////////////////
// CPGPdiskApp public default message handlers
//////////////////////////////////////////////

// ExitInstance is called right before the application dies.

int 
CPGPdiskApp::ExitInstance()
{
	DualErr derr;

	// Close our handle to the driver.
	derr = ClosePGPdiskDriver();
	pgpAssert(derr.IsntError());

	// Release our shared memory.
	derr = DeleteAppInfoStruct();
	pgpAssert(derr.IsntError());

	// Delete the main dialog.
	DeleteMainDialog();

	// Destroy the PGPcontext.
	FreeGlobalPGPContext();

	// Unintialize OLE.
	OleUninitialize();

	// Clear the PGPdisk container.
	mPGPdisks.ClearContainerWithDelete();

	// Cleanup explicit linkage.
	CleanupExplicitLinkage();

	return CWinApp::ExitInstance();
}

// InitInstance is called during application initialization.