📄 cpgpdiskengine.h

📁 PGP8.0源码请认真阅读您的文件包然后写出其具体功能
💻 H
📖 第 1 页 / 共 4 页
字号:
12 3 4 下一页
/*____________________________________________________________________________
		Copyright (C) 2002 PGP Corporation
        All rights reserved.

        $Id: CPGPdiskEngine.h,v 1.19 2002/11/22 02:32:15 wjb Exp $
____________________________________________________________________________*/

#ifndef Included_CPGPdiskEngine_h	// [
#define Included_CPGPdiskEngine_h

#include "CArray.h"
#include "CString.h"
#include "UMath.h"

#include "pgpDiskEngine.h"
#include "CPGPKey.h"

_PGP_BEGIN

// Class CPGPdiskEngine

class CPGPdiskEngine
{
	DECLARE_MODALSTATE(CPGPdiskEngine);

public:
	static void	InitLibrary();
	static void	CleanupLibrary();

	static void			PrefsChanged(PGPdiskContextRef context, 
		PGPPrefRef prefs);
	static PGPBoolean	AreDisksTimedOut();

	static PGPBoolean	IsPathMountedPGPdisk(const char *path);
	static PGPBoolean	IsRootMountedPGPdisk(const char *root);

	static PGPUInt32	GetNumDiskAlgorithms();
	static void			GetDiskAlgorithmIdString(
		PGPdiskEncryptionAlgorithm algorithm, CString& idString);
	static void			GetSupportedDiskAlgorithms(
		CArray<PGPdiskEncryptionAlgorithm>& algArray, PGPSize *pUsedLength);
	static PGPUInt32	GetNeededRandomDataSize(
		PGPdiskEncryptionAlgorithm algorithm);

	static void			NotifyUserLogoff();
};


// Class CPGPdiskContext

class CPGPdiskContext
{
	NOT_COPYABLE(CPGPdiskContext)

public:
	CPGPdiskContext();
	CPGPdiskContext(PGPdiskContextRef context);

	~CPGPdiskContext();

	operator PGPdiskContextRef() const {return mContext;}
	CPGPdiskContext&	operator=(PGPdiskContextRef context);

	PGPdiskContextRef	Get() const {return mContext;}

	PGPBoolean	IsAttached() const;
	PGPBoolean	WeCreated() const {return mWeCreated;}
	PGPBoolean	IsThereADK() const;

	PGPContextRef	PGPContext() const;
	PGPKeyDBRef		PGPKeyDB() const;
	PGPPrefRef		PGPclPrefs() const;

	void	GetADK(CPGPKey& adkKey) const;
	void	GetADKUserID(CString& userID) const;
	void	ReloadPGPKeyDB() const;

	void	Attach(PGPdiskContextRef context);
	void	Create();
	void	Clear();

private:
	PGPBoolean			mWeCreated;
	PGPdiskContextRef	mContext;
};


// Class CPGPdiskDisk

class CPGPdiskDisk
{
	NOT_COPYABLE(CPGPdiskDisk)

public:
	CPGPdiskDisk();
	CPGPdiskDisk(PGPdiskDiskRef disk);
	~CPGPdiskDisk();

	CPGPdiskDisk&	operator=(PGPdiskDiskRef disk);

	operator PGPdiskDiskRef() const {return mDisk;}
	PGPdiskDiskRef	Get() const {return mDisk;}

	PGPBoolean	IsAttached() const;
	PGPBoolean	WeOpened() const {return mWeOpened;}
	PGPBoolean	WeLocked() const {return mWeLocked;}

	PGPBoolean	IsMounted() const;
	PGPBoolean	IsOpened() const;
	PGPBoolean	IsReadOnly() const;
	PGPBoolean	IsLockedForFormat() const;
	PGPBoolean	IsLockedForIO() const;
	PGPBoolean	IsBeingReEncrypted() const;
	PGPBoolean	HasOldHeaders() const;
	PGPBoolean	AreUsersWiped() const;
	PGPBoolean	HasInactivityTimedOut() const;
	PGPBoolean	GetUsesCustomTimeout() const;
	PGPdiskEncryptionAlgorithm	Algorithm() const;
	void		GetDefaultRoot(CString& root) const;
	PGPUInt32	GetCustomTimeout() const;
	PGPUInt64	GetBlocksDisk() const;

	void	GetPath(CString& path) const;
	void	GetRoot(CString& root) const;
	void	GetDeviceName(CString& deviceName) const;

	PGPdiskContextRef	Context() const;

	void	ExportUserSet(PGPdiskUserSetRef userSet) const;
	void	ImportUserSet(PGPdiskUserSetRef userSet, 
		PGPdiskUserRef adminUserForCiphering);

	void	ChangeOnePassphrase(const char *userName, 
		const char *oldPassphrase, const char *newPassphrase);
	void	RemoveOneUser(PGPdiskUserRef userForCiphering);

	void	WipeUsers();

	void	SetUsesCustomTimeout(PGPBoolean usesCustom);
	void	SetDefaultRoot(const char *root);
	void	SetCustomTimeout(PGPUInt32 customTimeout);

	void	ReEncryptDisk(const char *adminPassphrase, 
		PGPdiskEncryptionAlgorithm newAlgorithm, 
		ReEncryptDiskStatusFuncType statusFunc, 
		void *userValue = NULL) const;

	void	LockVolume(PGPBoolean forFormat);
	void	UnlockVolume();

	void	ReadVolume(void *buffer, PGPUInt64 blockPos, 
		PGPUInt32 blocksLength);
	void	WriteVolume(const void *buffer, PGPUInt64 blockPos, 
		PGPUInt32 blocksLength);

	void	Open(PGPdiskContextRef context, const char *path, 
		PGPBoolean readOnly = FALSE);
	void	Close();

	void	Attach(PGPdiskDiskRef disk);
	void	Clear();

private:
	PGPdiskDiskRef	mDisk;

	PGPBoolean	mWeOpened;
	PGPBoolean	mWeLocked;

	PGPBoolean	GetBooleanProp(PGPdiskDiskPropName prop) const;
	PGPInt32	GetNumericProp(PGPdiskDiskPropName prop) const;
	void		GetDataProp(PGPdiskDiskPropName prop, void *pData, 
		PGPSize availLength, PGPSize *pUsedLength = NULL) const;

	void	SetBooleanProp(PGPdiskDiskPropName prop, PGPBoolean boolVal);
	void	SetNumericProp(PGPdiskDiskPropName prop, PGPInt32 number);
	void	SetDataProp(PGPdiskDiskPropName prop, const void *pData, 
		PGPSize length);
};


// Class CPGPdiskDiskSet

class CPGPdiskDiskSet
{
	NOT_COPYABLE(CPGPdiskDiskSet);

public:
	CPGPdiskDiskSet(PGPdiskContextRef context);
	CPGPdiskDiskSet(PGPdiskDiskSetRef diskSet);
	~CPGPdiskDiskSet();

	CPGPdiskDiskSet&	operator=(PGPdiskDiskSetRef diskSet);

	operator PGPdiskDiskSetRef() const {return mDiskSet;}
	PGPdiskDiskSetRef	Get() const {return mDiskSet;}

	PGPBoolean	IsAttached() const;
	PGPBoolean	WeCreated() const {return mWeCreated;}

	PGPdiskContextRef	Context() const;
	PGPUInt32			Count() const;

	void	Mount(const char *path, PGPdiskUserRef userForCiphering, 
		const char *root, PGPBoolean readOnly, CPGPdiskDisk& disk);
	void	Unmount(PGPdiskDiskRef disk, PGPBoolean isForced = FALSE);

	void	UnmountTimedOut(PGPBoolean isForced = FALSE);
	void	UnmountAll(PGPBoolean isForced = FALSE);
	void	WipeAllUsers();

	void	CreateDisk(const char *path, PGPUInt64 blocksDisk, 
		PGPdiskEncryptionAlgorithm algorithm, const char *passphrase, 
		const char *userName, const char *defaultRoot, 
		NewDiskStatusFuncType statusFunc, void *userValue, 
		CPGPdiskDisk& disk);

	void	CreateDisk(const char *path, PGPUInt64 blocksDisk, 
		PGPdiskEncryptionAlgorithm algorithm, PGPKeyDBObjRef key, 
		const char *defaultRoot, NewDiskStatusFuncType statusFunc, 
		void *userValue, CPGPdiskDisk& disk);

	void	Update();

	void	Attach(PGPdiskDiskSetRef diskSet);
	void	Create(PGPdiskContextRef context);
	void	Clear();

private:
	PGPdiskDiskSetRef	mDiskSet;
	PGPBoolean			mWeCreated;
};


// Class CPGPdiskDiskIter

class CPGPdiskDiskIter
{
	NOT_COPYABLE(CPGPdiskDiskIter)

public:
	CPGPdiskDiskIter(PGPdiskDiskSetRef diskSet);
	CPGPdiskDiskIter(PGPdiskDiskIterRef diskIter);
	~CPGPdiskDiskIter();

	CPGPdiskDiskIter&	operator=(PGPdiskDiskIterRef diskIter);

	operator PGPdiskDiskIterRef() const {return mDiskIter;}
	PGPdiskDiskIterRef	Get() const {return mDiskIter;}

	PGPBoolean	IsAttached() const;
	PGPBoolean	WeCreated() const {return mWeCreated;}

	PGPdiskDiskSetRef	DiskSet() const;
	PGPUInt32			Count() const;
	PGPInt32			Index() const;

	PGPBoolean	Current(CPGPdiskDisk& disk) const;
	PGPBoolean	Move(PGPInt32 relOffset, PGPBoolean fromStart, 
		CPGPdiskDisk& disk);
	PGPInt32	Seek(PGPdiskDiskRef soughtDisk);
	PGPBoolean	Next(CPGPdiskDisk& disk);
	PGPBoolean	Prev(CPGPdiskDisk& disk);
	void		Rewind();
	
	PGPBoolean	SearchOnPath(const char *path, CPGPdiskDisk& disk);
	PGPBoolean	SearchOnRoot(const char *root, CPGPdiskDisk& disk);

	void	Attach(PGPdiskDiskIterRef diskIter);
	void	Create(PGPdiskDiskSetRef diskSet);
	void	Clear();

private:
	PGPdiskDiskIterRef	mDiskIter;
	PGPBoolean			mWeCreated;
};


// Class CPGPdiskUser

class CPGPdiskUser
{
	NOT_COPYABLE(CPGPdiskUser)

public:
	CPGPdiskUser();
	CPGPdiskUser(PGPdiskUserRef user);
	~CPGPdiskUser();

	CPGPdiskUser&	operator=(PGPdiskUserRef user);

	operator PGPdiskUserRef() const {return mUser;}
	PGPdiskUserRef	Get() const {return mUser;}

	PGPBoolean	IsAttached() const;
	PGPBoolean	WeCreated() const {return mWeCreated;}

	PGPBoolean	IsEqualUser(PGPdiskUserRef user) const;

	PGPBoolean	HasPublicKey() const;
	PGPBoolean	HasSymmetricKey() const;
	PGPBoolean	IsReadOnly() const;
	PGPBoolean	IsLocked() const;
	PGPBoolean	IsAdminUser() const;
	PGPBoolean	IsDisabled() const;
	PGPBoolean	IsCipheringEnabled() const;
	PGPBoolean	CanSetReadOnly() const;
	PGPBoolean	CanSetLocked() const;
	PGPBoolean	CanSetUserName() const;

	PGPdiskContextRef	Context() const;

	void	GetUserName(CString& userName) const;
	void	GetPGPKeyID(CPGPKeyID& keyID) const;

	void	SetIsReadOnly(PGPBoolean isReadOnly);
	void	SetIsLocked(PGPBoolean isLocked);
	void	SetIsDisabled(PGPBoolean isDisabled);
	void	SetUserName(const char *userName);

	void	EnableCiphering(PGPdiskDiskRef disk, const char *passphrase, int passkeylen);
	void	DisableCiphering();

	void	ChangePassphrase(const char *newPassphrase);

	void	Create(PGPdiskUserRef cipheringUser, const char *userName,  
		const char *passphrase, PGPBoolean isReadOnly = FALSE);
	void	Create(PGPdiskUserRef cipheringUser, PGPKeyDBObjRef pubKey, 
		PGPBoolean isReadOnly = FALSE, PGPBoolean isLocked = FALSE);
	void	DuplicateUser(PGPdiskUserRef user);

	void	Attach(PGPdiskUserRef user);
	void	Clear();

private:
	PGPdiskUserRef	mUser;
	PGPBoolean		mWeCreated;

	PGPBoolean	GetBooleanProp(PGPdiskUserPropName prop) const;
	PGPInt32	GetNumericProp(PGPdiskUserPropName prop) const;
	void		GetDataProp(PGPdiskUserPropName prop, void *pData, 
		PGPSize availLength, PGPSize *pUsedLength = NULL) const;

	void	SetBooleanProp(PGPdiskUserPropName prop, PGPBoolean boolVal);
	void	SetNumericProp(PGPdiskUserPropName prop, PGPInt32 number);
	void	SetDataProp(PGPdiskUserPropName prop, const void *pData, 
		PGPSize length);
};


// Class CPGPdiskUserSet

class CPGPdiskUserSet
{
	NOT_COPYABLE(CPGPdiskUserSet);

public:
	CPGPdiskUserSet();
	CPGPdiskUserSet(PGPdiskUserRef user);
	CPGPdiskUserSet(PGPdiskUserSetRef userSet);
	~CPGPdiskUserSet();

	CPGPdiskUserSet&	operator=(PGPdiskUserSetRef userSet);

	operator PGPdiskUserSetRef() const {return mUserSet;}
	PGPdiskUserSetRef	Get() const {return mUserSet;}

	PGPBoolean	IsAttached() const;
	PGPBoolean	WeCreated() const {return mWeCreated;}

	PGPUInt32	Count() const;

	void	Add(PGPdiskUserSetRef usersToAdd);
	void	Add(PGPdiskUserRef userToAdd);
	void	Remove(PGPdiskUserSetRef usersToRemove);
	void	Remove(PGPdiskUserRef userToRemove);
	void	Empty();

	void	Attach(PGPdiskUserSetRef userSet);
	void	CreateEmpty();
	void	CreateSingleton(PGPdiskUserRef user);
	void	Clear();

private:
	PGPdiskUserSetRef	mUserSet;
	PGPBoolean			mWeCreated;
};


// Class CPGPdiskUserIter

class CPGPdiskUserIter
{
	NOT_COPYABLE(CPGPdiskUserIter)

public:
	CPGPdiskUserIter(PGPdiskUserSetRef userSet);
	CPGPdiskUserIter(PGPdiskUserIterRef userIter);
	~CPGPdiskUserIter();

	CPGPdiskUserIter&	operator=(PGPdiskUserIterRef userIter);

	operator PGPdiskUserIterRef() const {return mUserIter;}
	PGPdiskUserIterRef	Get() const {return mUserIter;}

	PGPBoolean	IsAttached() const;
	PGPBoolean	WeCreated() const {return mWeCreated;}

	PGPdiskUserSetRef	UserSet() const;
	PGPUInt32			Count() const;
	PGPInt32			Index() const;

	PGPBoolean	Current(CPGPdiskUser& user) const;
	PGPBoolean	Move(PGPInt32 relOffset, PGPBoolean fromStart, 
		CPGPdiskUser& user);
	PGPInt32	Seek(PGPdiskUserRef soughtUser);
	PGPBoolean	Next(CPGPdiskUser& user);
	PGPBoolean	Prev(CPGPdiskUser& user);
	void		Rewind();
	
	PGPBoolean	SearchOnUserName(const char *userName, CPGPdiskUser& user);
	PGPBoolean	FindEqualUser(const CPGPdiskUser& user, 
		CPGPdiskUser& equalUser);
	PGPBoolean	FindAdminUser(CPGPdiskUser& user);

	void	SetAdminUser(PGPdiskUserRef userForCiphering, 
		PGPdiskUserRef oldAdminForCiphering = kInvalidPGPdiskUserRef);

	void	Attach(PGPdiskUserIterRef userIter);
	void	Create(PGPdiskUserSetRef userSet);
	void	Clear();

private:
	PGPdiskUserIterRef	mUserIter;
	PGPBoolean			mWeCreated;
};


// Class CPGPdiskEngine member functions

inline 
void 
CPGPdiskEngine::InitLibrary()
{
	PGPError	error	= PGPdiskEngineInitLibrary(
		kPGPclEnableNewUserWizard | kPGPclForceNewUserWizard);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskEngine::CleanupLibrary()
{
	PGPdiskEngineCleanupLibrary();
}

inline 
void 
CPGPdiskEngine::PrefsChanged(PGPdiskContextRef context, PGPPrefRef prefs)
{
	PGPdiskPrefsChanged(context, prefs);
}

inline 
PGPBoolean 
CPGPdiskEngine::AreDisksTimedOut()
{
	return PGPdiskAreDisksTimedOut();
}

inline 
PGPBoolean 
CPGPdiskEngine::IsPathMountedPGPdisk(const char *path)
{
	return PGPdiskIsPathMountedPGPdisk(path);
}

inline 
PGPBoolean 
CPGPdiskEngine::IsRootMountedPGPdisk(const char *root)
{
	return PGPdiskIsRootMountedPGPdisk(root);
}

inline 
PGPUInt32 
CPGPdiskEngine::GetNumDiskAlgorithms()
{
	return PGPdiskGetNumDiskAlgorithms();
}

inline 
void 
CPGPdiskEngine::GetDiskAlgorithmIdString(
	PGPdiskEncryptionAlgorithm	algorithm, 
	CString&					idString)
{
	PGPdiskGetDiskAlgorithmIdString(algorithm, 
		idString.GetBuffer(kPGPdiskMaxAlgStringIdLength), 
		kPGPdiskMaxAlgStringIdLength);
	idString.ReleaseBuffer();
}

inline 
void 
CPGPdiskEngine::GetSupportedDiskAlgorithms(
	CArray<PGPdiskEncryptionAlgorithm>&	algArray, 
	PGPSize								*pUsedLength)
{
	algArray.Resize(GetNumDiskAlgorithms());

	PGPdiskGetSupportedDiskAlgorithms(algArray.Get(), algArray.Size(), 
		pUsedLength);
}

inline 
PGPUInt32 
CPGPdiskEngine::GetNeededRandomDataSize(PGPdiskEncryptionAlgorithm algorithm)
{
	return PGPdiskGetNeededRandomDataSize(algorithm);
}

inline 
void 
CPGPdiskEngine::NotifyUserLogoff()
{
	PGPdiskNotifyUserLogoff();
}


// Class CPGPdiskContext member functions

inline 
CPGPdiskContext::CPGPdiskContext() : 
	mContext(kInvalidPGPdiskContextRef), mWeCreated(FALSE)
{
}

inline 
CPGPdiskContext::CPGPdiskContext(PGPdiskContextRef context) :
	mContext(kInvalidPGPdiskContextRef), mWeCreated(FALSE)
{
	Attach(context);
}

inline 
CPGPdiskContext::CPGPdiskContext(const CPGPdiskContext& context) :
	mContext(kInvalidPGPdiskContextRef), mWeCreated(FALSE)
{
	Attach(context);
}

inline 
CPGPdiskContext::~CPGPdiskContext()
{
	try
	{
		Clear();
	}
	catch (PGPError&) { }
}

inline 
CPGPdiskContext& 
CPGPdiskContext::operator=(PGPdiskContextRef context)
{
	Attach(context);
	return *this;
}

inline 
PGPBoolean 
CPGPdiskContext::IsAttached() const
{
	return PGPdiskContextRefIsValid(mContext);
}

inline 
PGPContextRef 
CPGPdiskContext::PGPContext() const
12 3 4 下一页
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -