cpgpdiskappvolumes.cpp

vc环境下的pgp源码

//////////////////////////////////////////////////////////////////////////////
// CPGPdiskAppVolumes.cpp
//
// Helper functions for volume management.
//////////////////////////////////////////////////////////////////////////////

// $Id: CPGPdiskAppVolumes.cpp,v 1.15 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 "PGPdiskHighLevelUtils.h"
#include "PGPdiskPrefs.h"
#include "PGPdiskPublicKeyUtils.h"
#include "StringAssociation.h"
#include "UtilityFunctions.h"

#include "CConvertWizardSheet.h"
#include "CDiskWizardSheet.h"
#include "CGlobalCWizardSheet.h"
#include "CMainDialog.h"
#include "CNagBuyDialog.h"
#include "COpenPGPdiskDialog.h"
#include "CPGPdiskApp.h"
#include "CPGPdiskAppVolumes.h"
#include "CSavePGPdiskDialog.h"
#include "CSinglePassphraseDialog.h"
#include "CUnmountPGPdiskDialog.h"
#include "PGPdisk.h"


/////////////////////////////////////////
// High-Level Mount and Creation Routines
/////////////////////////////////////////

// AskUserMountPGPdisk asks the user to select a PGPdisk to mount.

void 
CPGPdiskApp::AskUserMountPGPdisk()
{
	AppCommandInfo		ACI;
	COpenPGPdiskDialog	mountPGPdiskDlg(kODT_Mount);
	CString				path;
	DualErr				derr;

	// Any drive letters free?
	if (!AreAnyDriveLettersFree())
	{
		derr = DualErr(kPGDMinorError_NoDriveLettersFree);
	}

	// Show the dialog.
	if (derr.IsntError())
	{
		derr = mountPGPdiskDlg.AskForPath(&path);
	}

	if (derr.IsntError())
	{
		// Now attempt the mount.
		ACI.op		= kAppOp_Mount;
		ACI.flags	= NULL;
		ACI.drive	= kInvalidDrive;
		strcpy(ACI.path, path);

		DispatchAppCommandInfo(&ACI);	
	}

	if (derr.IsError())
	{
		ReportError(kPGDMajorError_PGPdiskMountFailed, derr);
	}
}

// AskUserUnmountPGPdisk asks the user to select a PGPdisk to unmount.

void 
CPGPdiskApp::AskUserUnmountPGPdisk()
{
	CUnmountPGPdiskDialog	unmountPGPdiskDlg;
	DualErr					derr;

	// Get PGPdisk info.
	derr = UpdateAppPGPdiskInfo();

	// Complain if there are no PGPdisks to unmount.
	if (derr.IsntError())
	{
		if (mPGPdisks.GetNumPGPdisks() == 0)
		{
			DisplayMessage(kPGPdiskNoPGPdisksToUnmountString);
			return;
		}
	}

	// Show the dialog.
	if (derr.IsntError())
	{
		derr = unmountPGPdiskDlg.AskForDriveLetter();
	}

	// Attempt the unmount.
	if (derr.IsntError())
	{
		AppCommandInfo ACI;

		ACI.op		= kAppOp_Unmount;
		ACI.flags	= NULL;
		ACI.drive	= unmountPGPdiskDlg.mDriveToUnmount;
		ACI.path[0]	= '\0';

		DispatchAppCommandInfo(&ACI);
	}

	if (derr.IsError())
	{
		ReportError(kPGDMajorError_PGPdiskMountFailed, derr);
	}
}

// AskUserNewPGPdisk calls down to begin the PGPdisk creation process.

void 
CPGPdiskApp::AskUserNewPGPdisk()
{
	AppCommandInfo ACI;

	// We don't ask for the path here.
	ACI.op		= kAppOp_Create;
	ACI.flags	= NULL;
	ACI.drive	= kInvalidDrive;
	ACI.path[0]	= '\0';

	DispatchAppCommandInfo(&ACI);
}

// AskUserGlobalConvertPGPdisks starts the global PGPdisk conversion process.

void 
CPGPdiskApp::AskUserGlobalConvertPGPdisks()
{
	AppCommandInfo ACI;

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

	DispatchAppCommandInfo(&ACI);
}


/////////////////////////////////////////////////
// Low-Level Mount, Unmount and Creation Routines
/////////////////////////////////////////////////

// UpdateAppPGPdiskInfo asks the driver for info on all mounted PGPdisks and
// makes sure we are current.

DualErr 
CPGPdiskApp::UpdateAppPGPdiskInfo()
{
	DualErr		derr;
	PGPBoolean	createdPDIArray;
	PGPdiskInfo	*pPDIArray;

	pgpAssert(IsDriverOpen());

	// Allocate space for the PGPdiskInfo array.
	try
	{
		pPDIArray = new PGPdiskInfo[kMaxDrives];
	}
	catch (CMemoryException *ex)
	{
		derr = DualErr(kPGDMinorError_OutOfMemory);
		ex->Delete();
	}

	createdPDIArray = derr.IsntError();

	// Ask the driver to fill in our array.
	if (derr.IsntError())
	{
		derr = GetPGPdiskInfo(pPDIArray, kMaxDrives);
	}

	// Update our list of PGPdisks accordingly.
	if (derr.IsntError())
	{
		PGPdisk		*pPGD;
		PGPdiskInfo	*pPDI;
		PGPUInt32	i;

		// Empty the container.
		mPGPdisks.ClearContainerWithDelete();

		// Parse the array.
		for (i = 0; i < kMaxDrives; i++)
		{
			pPDI = &pPDIArray[i];

			// Legal drive letters represent PGPdisks.
			if (IsLegalDriveNumber(pPDI->drive))
			{
				PGPBoolean createdPGPdiskObject = FALSE;

				// Create a new PGPdisk object.
				try
				{
					pPGD = new PGPdisk(pPDI->path, pPDI->drive, 
						pPDI->sessionId);
				}
				catch (CMemoryException *ex)
				{
					derr = DualErr(kPGDMinorError_OutOfMemory);
					ex->Delete();
				}

				createdPGPdiskObject = derr.IsntError();

				// Check if created successfully.
				if (derr.IsntError())
				{
					derr = pPGD->mInitErr;
				}

				// Put the PGPdisk in the global list.
				if (derr.IsntError())
				{
					mPGPdisks.AddPGPdisk(pPGD);
				}

				if (derr.IsError())
				{
					if (createdPGPdiskObject)
						delete pPGD;
				}
			}

			if (derr.IsError())
			{
				break;
			}		
		}
	}

	if (createdPDIArray)
		delete[] pPDIArray;

	return derr;
}

// GlobalConvertPGPdisks invokes the global PGPdisk conversion wizard.

DualErr 
CPGPdiskApp::GlobalConvertPGPdisks()
{
	DualErr				derr;
	CGlobalCWizardSheet	globalCPGPdiskSheet;

	derr = globalCPGPdiskSheet.mInitErr;

	if (derr.IsntError())
	{
		derr = globalCPGPdiskSheet.ExecuteWizard();
	}

	return derr;
}

// ConvertPGPdiskPriorToMount attempts to convert a PGPdisk with bad CAST to
// one with good CAST.

DualErr 
CPGPdiskApp::ConvertPGPdiskPriorToMount(LPCSTR path, PGPBoolean *pUserSaysNo)
{
	DualErr		derr;
	PGPBoolean	userSaysNo	= FALSE;

	pgpAssertStrValid(path);
	pgpAssertAddrValid(pUserSaysNo, PGPBoolean);

	if (IsFileReadOnly(path))
	{
		DisplayMessage(kPGPdiskBadCASTReadOnly);
		userSaysNo = TRUE;
	}
	else
	{
		PGPBoolean		restartingConversion;
		UserResponse	response;

		// Is this PGPdisk partially converted already?
		restartingConversion = WasPGPdiskConversionInterrupted(path);

		if (restartingConversion)
		{
			response = DisplayMessage(kPGPdiskBadCASTAskContinuePM, 
				kPMBS_YesNo, kPMBF_YesButton);
		}
		else
		{
			response = DisplayMessage(kPGPdiskBadCASTAskConvertPM, 
				kPMBS_YesNoCancel, kPMBF_YesButton);
		}

		// Do what the user wants in regards to conversion.
		switch (response)
		{
			case kUR_Yes:
				{
					CConvertWizardSheet convertPGPdiskSheet;

					derr = convertPGPdiskSheet.mInitErr;

					if (derr.IsntError())
					{
						derr = convertPGPdiskSheet.ExecuteWizard(path, 
							restartingConversion);
					}
				}
				break;

			case kUR_No:
				userSaysNo = TRUE;

				if (restartingConversion)
					derr = kPGDMinorError_UserAbort;
				break;

			case kUR_Cancel:
				derr = kPGDMinorError_UserAbort;
				break;
		}
	}

	(* pUserSaysNo) = userSaysNo;

	return derr;
}

// ConvertPGPdiskFromGlobalWizard attempts to convert a PGPdisk with bad CAST
// to one with good CAST.

DualErr 
CPGPdiskApp::ConvertPGPdiskFromGlobalWizard(
	LPCSTR		path, 
	PGPBoolean	*pUserSaysCancel)
{
	DualErr		derr;
	PGPBoolean	userSaysCancel	= FALSE;

	pgpAssertStrValid(path);
	pgpAssertAddrValid(pUserSaysCancel, PGPBoolean);

	if (IsFileReadOnly(path))
	{
		DisplayMessage(kPGPdiskBadCASTReadOnly);
	}
	else
	{
		PGPBoolean		restartingConversion;
		UserResponse	response;

		// Is this PGPdisk partially converted already?
		restartingConversion = WasPGPdiskConversionInterrupted(path);

		if (restartingConversion)
		{
			response = DisplayMessage(kPGPdiskBadCASTAskContinuePNM, 
				kPMBS_YesNoCancel, kPMBF_YesButton);
		}
		else
		{
			response = DisplayMessage(kPGPdiskBadCASTAskConvertPNM, 
				kPMBS_YesNoCancel, kPMBF_YesButton);
		}

		// Do what the user wants in regards to conversion.
		switch (response)
		{
			case kUR_Yes:
				{
					CConvertWizardSheet convertPGPdiskSheet;

					derr = convertPGPdiskSheet.mInitErr;

					if (derr.IsntError())
					{
						derr = convertPGPdiskSheet.ExecuteWizard(path, 
							restartingConversion);
					}
				}
				break;

			case kUR_No:
				derr = kPGDMinorError_UserAbort;
				break;

			case kUR_Cancel:
				userSaysCancel = TRUE;
				break;
		}
	}

	(* pUserSaysCancel) = userSaysCancel;