cpgpdiskdiskimp.cpp

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

/*____________________________________________________________________________
		Copyright (C) 2002 PGP Corporation
        All rights reserved.

        $Id: CPGPdiskDiskImp.cpp,v 1.22 2002/08/06 20:09:36 dallen Exp $
____________________________________________________________________________*/

#include "pgpClassesConfig.h"

#include "UMath.h"
#include "UTime.h"

#include "pgpClientErrors.h"
#include "CCipherContext.h"
#include "CPGPKey.h"

#include "CDriverComm.h"
#include "CEngineSubsystems.h"
#include "CPGPdiskContext.h"
#include "CPGPdiskDiskImp.h"
#include "CPGPdiskUser.h"
#include "CPGPdiskUserSet.h"

_USING_PGP

// Class CPGPdiskDiskImp member functions

CPGPdiskDiskImp::CPGPdiskDiskImp() :

	mPContext(NULL), mDiskState(kDiskStateNone), mHasTimedOut(FALSE),
		mIsLockedForFormat(FALSE), mIsLockedForIO(FALSE), mLockHandle(0)
{
}

PGPBoolean
CPGPdiskDiskImp::operator==(const CPGPdiskDisk& disk) const
{
	return ComparePaths(disk.Path());
}

PGPBoolean 
CPGPdiskDiskImp::ComparePaths(const char *path) const
{
	CString	cpath(path);
	return cpath.CompareNoCase(Path());
}

PGPBoolean 
CPGPdiskDiskImp::CompareRoots(const char *root) const
{
	CString	croot(root);
	return croot.CompareNoCase(Root());
}

PGPBoolean
CPGPdiskDiskImp::HasOldHeaders() const
{
	MakeSureHeadersRead();
	return mHeaders.HasOldHeaders();
}

PGPdiskEncryptionAlgorithm
CPGPdiskDiskImp::Algorithm() const
{
	MakeSureHeadersRead();
	return mHeaders.Algorithm();
}

PGPBoolean
CPGPdiskDiskImp::IsBeingReEncrypted() const
{
	MakeSureHeadersRead();
	return mHeaders.IsBeingReEncrypted();
}

PGPBoolean
CPGPdiskDiskImp::AreUsersWiped() const
{
	MakeSureHeadersRead();
	return mHeaders.AreUsersWiped();
}

PGPBoolean
CPGPdiskDiskImp::HasInactivityTimedOut() const
{
	MakeSureHeadersRead();
	return mHasTimedOut;
}

PGPBoolean
CPGPdiskDiskImp::UsesCustomTimeout() const
{
	MakeSureHeadersRead();
	return mHeaders.UsesCustomTimeout();
}

const char *
CPGPdiskDiskImp::DefaultRoot() const
{
	MakeSureHeadersRead();
	return mHeaders.DefaultRoot();
}

PGPUInt32
CPGPdiskDiskImp::CustomTimeout() const
{
	MakeSureHeadersRead();
	return mHeaders.CustomTimeout();
}

PGPUInt64
CPGPdiskDiskImp::BlocksDisk() const
{
	MakeSureHeadersRead();
	return mHeaders.BlocksDisk();
}

void
CPGPdiskDiskImp::AttachMounted(
	const CPGPdiskContext	*pContext,
	const char				*path,
	const char				*root,
	const char				*deviceName,
	PGPBoolean				readOnly,
	PGPBoolean				hasTimedOut)
{
	pgpAssert(!IsOpened());
	pgpAssert(!IsMounted());
	pgpAssertAddrValid(pContext, CPGPdiskContext);

	mPContext		= pContext;
	mIsReadOnly		= readOnly;
	mHasTimedOut	= hasTimedOut;
	mPath			= path;
	mRoot			= root;
	mDeviceName		= deviceName;

	mDiskState = kDiskStateMounted;
}

void
CPGPdiskDiskImp::ExportUserSet(CPGPdiskUserSet& userSet) const
{
	MakeSureHeadersRead();
	mHeaders.ExportUserSet(userSet);
}

void
CPGPdiskDiskImp::ImportUserSet(const CPGPdiskUserSet& userSet)
{
	pgpAssert(IsOpened());

	VerifyModifiability();

	mHeaders.ImportUserSet(userSet);
	mHeaders.WriteHeaders(mDiskFile);
}

void
CPGPdiskDiskImp::EnableCipheringOnUser(
	CPGPdiskUser&	user,
	const char		*passphrase,
	int				passkeylen)
{
	MakeSureHeadersRead();
	mHeaders.EnableCipheringOnUser(user, passphrase, passkeylen);
}

void
CPGPdiskDiskImp::WipeUsers()
{
	pgpAssert(IsOpened());

	if (AreUsersWiped())
		THROW_PGPERROR(kPGPError_UserAbort);

	VerifyModifiability();
	mHeaders.WipeUsers(mDiskFile);	// writes out headers for us
}

void
CPGPdiskDiskImp::SetUsesCustomTimeout(PGPBoolean usesCustom)
{
	pgpAssert(IsOpened());

	VerifyModifiability();

	mHeaders.SetUsesCustomTimeout(usesCustom);
	mHeaders.WriteHeaders(mDiskFile);
}

void
CPGPdiskDiskImp::SetDefaultRoot(const char *root)
{
	pgpAssert(IsOpened());

	VerifyModifiability();
	mHeaders.SetDefaultRoot(root);
}

void
CPGPdiskDiskImp::SetCustomTimeout(PGPUInt32 customTimeout)
{
	pgpAssert(IsOpened());

	VerifyModifiability();

	mHeaders.SetCustomTimeout(customTimeout);
	mHeaders.WriteHeaders(mDiskFile);
}

void
CPGPdiskDiskImp::ReEncrypt(
	const char					*adminPassphrase,
	PGPdiskEncryptionAlgorithm	newAlgorithm,
	ReEncryptDiskStatusFuncType	statusFunc,
	void						*userValue)
{
	pgpAssert(IsOpened());
	pgpAssertStrValid(adminPassphrase);
	pgpAssertAddrValid(statusFunc, ReEncryptDiskStatusFuncType);

	if (IsReadOnly())
		THROW_PGPERROR(kPGPClientError_DiskDiskIsWriteProtected);

	if (AreUsersWiped())
		THROW_PGPERROR(kPGPClientError_DiskDiskUsersAreWiped);

	CCipherContext	oldCipher, newCipher;
	PGPUInt64		numBlocksReEncrypted;

	if (!mHeaders.IsBeingReEncrypted())
		mHeaders.BeginReEncryption(mDiskFile, adminPassphrase, newAlgorithm);

	mHeaders.GetReEncryptionInfo(adminPassphrase, oldCipher, newCipher,
		numBlocksReEncrypted);

	ReEncryptBlocks(oldCipher, newCipher, statusFunc, userValue,
		numBlocksReEncrypted);

	mHeaders.FinishReEncryption(mDiskFile);
}

void
CPGPdiskDiskImp::LockVolume(PGPBoolean forFormat)
{
	if (!IsMounted())
		THROW_PGPERROR(kPGPError_FeatureNotAvailable);

	mLockHandle = CEngineSubsystems::DriverComm().LockVolume(Root(),
		forFormat);

	if (forFormat)
		mIsLockedForFormat = TRUE;
	else
		mIsLockedForIO = TRUE;
}

void
CPGPdiskDiskImp::UnlockVolume()
{
	if (!IsLockedForFormat() && !IsLockedForIO())
		THROW_PGPERROR(kPGPError_FeatureNotAvailable);

	CEngineSubsystems::DriverComm().UnlockVolume(mLockHandle);

	mIsLockedForFormat = FALSE;
	mIsLockedForIO = FALSE;
	mLockHandle = 0;
}

void
CPGPdiskDiskImp::ReadVolume(
	void		*buffer,
	PGPUInt64	blockPos,
	PGPUInt32	blocksLength)
{
	pgpAssertAddrValid(buffer, VoidAlign);

	if (!IsLockedForFormat() && !IsLockedForIO())
		THROW_PGPERROR(kPGPError_FeatureNotAvailable);

	CEngineSubsystems::DriverComm().IOVolume(mLockHandle, TRUE, buffer,
		blockPos, blocksLength);
}

void
CPGPdiskDiskImp::WriteVolume(
	const void	*buffer,
	PGPUInt64	blockPos,
	PGPUInt32	blocksLength)
{
	pgpAssertAddrValid(buffer, VoidAlign);

	if (!IsLockedForFormat() && !IsLockedForIO())
		THROW_PGPERROR(kPGPError_FeatureNotAvailable);

	CEngineSubsystems::DriverComm().IOVolume(mLockHandle, FALSE,
		const_cast<void *>(buffer), blockPos, blocksLength);
}

void
CPGPdiskDiskImp::Open(
	const CPGPdiskContext	*pContext,
	const char				*path,
	PGPBoolean				readOnly)
{
	pgpAssertAddrValid(pContext, CPGPdiskContext);

	if (IsMounted() || IsOpened())
		THROW_PGPERROR(kPGPError_FeatureNotAvailable);

	PGPUInt32	openFlags	= CFile::kNoFlags;

	if (readOnly)
		openFlags |= CFile::kReadOnlyFlag | CFile::kShareWriteFlag;

	mDiskFile.Open(path, openFlags);

	try
	{
		mHeaders.ReadHeaders(pContext, mDiskFile);
	}
	catch (CComboError&)
	{
		mDiskFile.Close();
		throw;
	}

	mPContext	= pContext;
	mIsReadOnly	= readOnly;
	mPath		= path;
	mDiskState	= kDiskStateOpened;

	mRoot.Empty();
}

void
CPGPdiskDiskImp::Close()
{
	if (!IsOpened())
		THROW_PGPERROR(kPGPError_FeatureNotAvailable);

	try
	{
		if (!IsReadOnly())
			mHeaders.WriteHeaders(mDiskFile);
	}
	catch (CComboError&) { }

	mHeaders.ClearHeaders();
	mDiskFile.Close();

	mPContext = NULL;
	mPath.Empty();

	mDiskState = kDiskStateNone;
}

void
CPGPdiskDiskImp::MakeSureHeadersRead() const
{
	if (!mHeaders.HeadersRead())
	{
		PGPBoolean	weOpened	= FALSE;

		try
		{
			if (!mDiskFile.IsOpened())
			{
				const_cast<CFile *>(&mDiskFile)->Open(Path(),
					CFile::kReadOnlyFlag | CFile::kShareWriteFlag);
				weOpened = TRUE;
			}

			const_cast<CPGPdiskHeaders *>(&mHeaders)->ReadHeaders(
				Context(), mDiskFile);

			if (weOpened)
				const_cast<CFile *>(&mDiskFile)->Close();
		}
		catch (CComboError&)
		{
			if (weOpened)
				const_cast<CFile *>(&mDiskFile)->Close();
		}
	}
}

void
CPGPdiskDiskImp::VerifyModifiability()
{
	if (IsReadOnly())
		THROW_PGPERROR(kPGPClientError_DiskDiskIsWriteProtected);

	if (IsBeingReEncrypted())
		THROW_PGPERROR(kPGPClientError_DiskDiskIsBeingReEncrypted);

	if (AreUsersWiped())
		THROW_PGPERROR(kPGPClientError_DiskDiskUsersAreWiped);
}

void
CPGPdiskDiskImp::ResetTimedOut()
{
	mHasTimedOut = FALSE;
	CEngineSubsystems::DriverComm().ResetTimedOutDisk(Root());
}

void
CPGPdiskDiskImp::Mount(
	const CPGPdiskContext	*pContext,