cpgpdiskdisk.cpp

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

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

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

#include "pgpClassesConfig.h"

#include "CPGPKey.h"
#include "CPGPdiskDisk.h"
#include "CPGPdiskDiskImp.h"

_USING_PGP

// Class CPGPdiskDisk member functions

DEFINE_IMPHOST(CPGPdiskDisk, PGPdiskDiskImp, CEngineImpFactory)

PGPBoolean 
CPGPdiskDisk::operator==(const CPGPdiskDisk& disk) const
{
	return Imp()->operator==(disk);
}

const CPGPdiskContext * 
CPGPdiskDisk::Context() const
{
	return Imp()->Context();
}

PGPBoolean 
CPGPdiskDisk::IsMounted() const
{
	return Imp()->IsMounted();
}

PGPBoolean 
CPGPdiskDisk::IsUnmounted() const
{
	return Imp()->IsUnmounted();
}

PGPBoolean 
CPGPdiskDisk::IsOpened() const
{
	return Imp()->IsOpened();
}

PGPBoolean 
CPGPdiskDisk::IsReadOnly() const
{
	return Imp()->IsReadOnly();
}

PGPBoolean 
CPGPdiskDisk::IsLockedForFormat() const
{
	return Imp()->IsLockedForFormat();
}

PGPBoolean 
CPGPdiskDisk::IsLockedForIO() const
{
	return Imp()->IsLockedForIO();
}

const char * 
CPGPdiskDisk::Path() const
{
	return Imp()->Path();
}

const char * 
CPGPdiskDisk::Root() const
{
	return Imp()->Root();
}

const char * 
CPGPdiskDisk::DeviceName() const
{
	return Imp()->DeviceName();
}

PGPBoolean 
CPGPdiskDisk::ComparePaths(const char *path) const
{
	return Imp()->ComparePaths(path);
}

PGPBoolean 
CPGPdiskDisk::CompareRoots(const char *root) const
{
	return Imp()->CompareRoots(root);
}

PGPBoolean 
CPGPdiskDisk::HasOldHeaders() const
{
	return Imp()->HasOldHeaders();
}

PGPdiskEncryptionAlgorithm 
CPGPdiskDisk::Algorithm() const
{
	return Imp()->Algorithm();
}

PGPBoolean 
CPGPdiskDisk::IsBeingReEncrypted() const
{
	return Imp()->IsBeingReEncrypted();
}

PGPBoolean 
CPGPdiskDisk::AreUsersWiped() const
{
	return Imp()->AreUsersWiped();
}

PGPBoolean 
CPGPdiskDisk::HasInactivityTimedOut() const
{
	return Imp()->HasInactivityTimedOut();
}

PGPBoolean 
CPGPdiskDisk::UsesCustomTimeout() const
{
	return Imp()->UsesCustomTimeout();
}

const char * 
CPGPdiskDisk::DefaultRoot() const
{
	return Imp()->DefaultRoot();
}

PGPUInt32 
CPGPdiskDisk::CustomTimeout() const
{
	return Imp()->CustomTimeout();
}

PGPUInt64 
CPGPdiskDisk::BlocksDisk() const
{
	return Imp()->BlocksDisk();
}

void 
CPGPdiskDisk::AttachMounted(
	const CPGPdiskContext	*pContext, 
	const char				*path, 
	const char				*root, 
	const char				*deviceName, 
	PGPBoolean				readOnly, 
	PGPBoolean				hasTimedOut)
{
	Imp()->AttachMounted(pContext, path, root, deviceName, readOnly, 
		hasTimedOut);
}

void 
CPGPdiskDisk::ExportUserSet(CPGPdiskUserSet& userSet) const
{
	Imp()->ExportUserSet(userSet);
}

void 
CPGPdiskDisk::ImportUserSet(const CPGPdiskUserSet& userSet)
{
	Imp()->ImportUserSet(userSet);
}

void 
CPGPdiskDisk::EnableCipheringOnUser(
	CPGPdiskUser&	user, 
	const char		*passphrase,
	int				passkeylen)
{
	Imp()->EnableCipheringOnUser(user, passphrase, passkeylen);
}

void 
CPGPdiskDisk::WipeUsers()
{
	Imp()->WipeUsers();
}

void 
CPGPdiskDisk::SetUsesCustomTimeout(PGPBoolean usesCustom)
{
	Imp()->SetUsesCustomTimeout(usesCustom);
}

void 
CPGPdiskDisk::SetDefaultRoot(const char *root)
{
	Imp()->SetDefaultRoot(root);
}

void 
CPGPdiskDisk::SetCustomTimeout(PGPUInt32 customTimeout)
{
	Imp()->SetCustomTimeout(customTimeout);
}

void 
CPGPdiskDisk::ReEncrypt(
	const char					*masterPassphrase, 
	PGPdiskEncryptionAlgorithm	newAlgorithm, 
	ReEncryptDiskStatusFuncType	statusFunc, 
	void						*userValue)
{
	Imp()->ReEncrypt(masterPassphrase, newAlgorithm, statusFunc, userValue);
}

void 
CPGPdiskDisk::LockVolume(PGPBoolean forFormat)
{
	Imp()->LockVolume(forFormat);
}

void 
CPGPdiskDisk::UnlockVolume()
{
	Imp()->UnlockVolume();
}

void 
CPGPdiskDisk::ReadVolume(
	void		*buffer, 
	PGPUInt64	blockPos, 
	PGPUInt32	blocksLength)
{
	Imp()->ReadVolume(buffer, blockPos, blocksLength);
}

void 
CPGPdiskDisk::WriteVolume(
	const void	*buffer, 
	PGPUInt64	blockPos, 
	PGPUInt32	blocksLength)
{
	Imp()->WriteVolume(buffer, blockPos, blocksLength);
}

void 
CPGPdiskDisk::Open(
	const CPGPdiskContext	*pContext, 
	const char				*path, 
	PGPBoolean				readOnly)
{
	Imp()->Open(pContext, path, readOnly);
}

void 
CPGPdiskDisk::Close()
{
	Imp()->Close();
}

void 
CPGPdiskDisk::Create(
	const CPGPdiskContext		*pContext, 
	const char					*path, 
	PGPUInt64					blocksDisk, 
	PGPdiskEncryptionAlgorithm	algorithm, 
	const char					*passphrase, 
	const char					*userName, 
	const char					*defaultRoot, 
	NewDiskStatusFuncType		statusFunc, 
	void						*userValue)
{
	Imp()->Create(pContext, path, blocksDisk, algorithm, passphrase, 
		userName, defaultRoot, statusFunc, userValue);
}

void 
CPGPdiskDisk::Create(
	const CPGPdiskContext		*pContext, 
	const char					*path, 
	PGPUInt64					blocksDisk, 
	PGPdiskEncryptionAlgorithm	algorithm, 
	const CPGPKey&				pubKey, 
	const char					*defaultRoot, 
	NewDiskStatusFuncType		statusFunc, 
	void						*userValue)
{
	Imp()->Create(pContext, path, blocksDisk, algorithm, pubKey, 
		defaultRoot, statusFunc, userValue);
}

void 
CPGPdiskDisk::ResetTimedOut()
{
	Imp()->ResetTimedOut();
}

void 
CPGPdiskDisk::Mount(
	const CPGPdiskContext	*pContext, 
	const char				*path, 
	const CPGPdiskUser&		diskUser, 
	const char				*root, 
	PGPBoolean				readOnly)
{
	Imp()->Mount(pContext, path, diskUser, root, readOnly);
}

void 
CPGPdiskDisk::Unmount(PGPBoolean isForced)
{
	Imp()->Unmount(isForced);
}