cpgpdiskengine.h

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

{
	pgpAssert(IsAttached());
	return PGPdiskPeekContextPGPContext(mContext);
}

inline 
PGPKeyDBRef 
CPGPdiskContext::PGPKeyDB() const
{
	pgpAssert(IsAttached());

	PGPKeyDBRef	pgpKeyDB;

	PGPError	error	= PGPdiskOpenPeekContextPGPKeyDB(mContext, &pgpKeyDB);
	THROW_IF_PGPERROR(error);

	return pgpKeyDB;
}

inline 
PGPPrefRef 
CPGPdiskContext::PGPclPrefs() const
{
	pgpAssert(IsAttached());
	return PGPdiskPeekContextPGPclPrefs(mContext);
}

inline 
PGPBoolean 
CPGPdiskContext::IsThereADK() const
{
	PGPBoolean	isThereADK;
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskContextIsThereADK(mContext, &isThereADK);
	THROW_IF_PGPERROR(error);

	return isThereADK;
}

inline 
void 
CPGPdiskContext::GetADK(CPGPKey& adkKey) const
{
	PGPKeyDBObjRef	adkKeyRef;

	PGPError	error	= PGPdiskContextGetADK(mContext, &adkKeyRef);
	THROW_IF_PGPERROR(error);

	adkKey.Attach(adkKeyRef);
}

inline 
void 
CPGPdiskContext::GetADKUserID(CString& userID) const
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskContextGetADKUserID(mContext, 
		userID.GetBuffer(kPGPMaxUserIDSize), kPGPMaxUserIDSize);
	userID.ReleaseBuffer();

	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskContext::ReloadPGPKeyDB() const
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskReloadContextPGPKeyDB(mContext);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskContext::Attach(PGPdiskContextRef context)
{
	if (mContext == context)
		return;

	Clear();
	pgpAssert(PGPdiskContextRefIsValid(context));

	mContext = context;
	mWeCreated = FALSE;
}

inline 
void 
CPGPdiskContext::Create()
{
	Clear();

	PGPError	error	= PGPdiskNewContext(kPGPdiskAPIVersion, 
		&mContext);
	THROW_IF_PGPERROR(error);

	mWeCreated = TRUE;
}

inline 
void 
CPGPdiskContext::Clear()
{
	if (mWeCreated)
		PGPdiskFreeContext(mContext);

	mContext = kInvalidPGPdiskContextRef;
}


// Class CPGPdiskDisk member functions

inline 
CPGPdiskDisk::CPGPdiskDisk() : 
	mDisk(kInvalidPGPdiskDiskRef), mWeOpened(FALSE), mWeLocked(FALSE)
{
}

inline 
CPGPdiskDisk::CPGPdiskDisk(PGPdiskDiskRef disk) :
	mDisk(kInvalidPGPdiskDiskRef), mWeOpened(FALSE), mWeLocked(FALSE)
{
	Attach(disk);
}

inline 
CPGPdiskDisk::~CPGPdiskDisk()
{
	try
	{
		Clear();
	}
	catch (CComboError&) { }
}

inline 
CPGPdiskDisk& 
CPGPdiskDisk::operator=(PGPdiskDiskRef disk)
{
	Attach(disk);
	return *this;
}

inline 
PGPBoolean 
CPGPdiskDisk::IsAttached() const
{
	return PGPdiskDiskRefIsValid(mDisk);
}

inline 
PGPBoolean 
CPGPdiskDisk::IsMounted() const
{
	return (IsAttached() && GetBooleanProp(kPGPdiskDiskProp_IsMounted));
}

inline 
PGPBoolean 
CPGPdiskDisk::IsOpened() const
{
	return (IsAttached() && GetBooleanProp(kPGPdiskDiskProp_IsOpened));
}

inline 
PGPBoolean 
CPGPdiskDisk::IsReadOnly() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskDiskProp_IsReadOnly);
}

inline 
PGPBoolean 
CPGPdiskDisk::IsLockedForFormat() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskDiskProp_IsLockedForFormat);
}

inline 
PGPBoolean 
CPGPdiskDisk::IsLockedForIO() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskDiskProp_IsLockedForIO);
}

inline 
PGPBoolean 
CPGPdiskDisk::IsBeingReEncrypted() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskDiskProp_IsBeingReEncrypted);
}

inline 
PGPBoolean 
CPGPdiskDisk::HasOldHeaders() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskDiskProp_HasOldHeaders);
}

inline 
PGPBoolean 
CPGPdiskDisk::AreUsersWiped() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskDiskProp_AreUsersWiped);
}

inline 
PGPBoolean 
CPGPdiskDisk::HasInactivityTimedOut() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskDiskProp_HasTimedOut);
}

inline 
PGPBoolean 
CPGPdiskDisk::GetUsesCustomTimeout() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskDiskProp_UsesCustomTimeout);
}

inline 
PGPdiskEncryptionAlgorithm 
CPGPdiskDisk::Algorithm() const
{
	pgpAssert(IsAttached());

	return static_cast<PGPdiskEncryptionAlgorithm>(
		GetNumericProp(kPGPdiskDiskProp_Algorithm));
}

inline 
void 
CPGPdiskDisk::GetDefaultRoot(CString& root) const
{
	pgpAssert(IsAttached());

	GetDataProp(kPGPdiskDiskProp_DefaultRoot, 
		root.GetBuffer(kPGPdiskMaxPathLength), kPGPdiskMaxPathLength);
	root.ReleaseBuffer();
}

inline 
PGPUInt32 
CPGPdiskDisk::GetCustomTimeout() const
{
	pgpAssert(IsAttached());
	return GetNumericProp(kPGPdiskDiskProp_CustomTimeout);
}

inline 
PGPUInt64 
CPGPdiskDisk::GetBlocksDisk() const
{
	pgpAssert(IsAttached());

	return UMath::MakeQWord(GetNumericProp(kPGPdiskDiskProp_BlocksDiskLow), 
		GetNumericProp(kPGPdiskDiskProp_BlocksDiskHigh));
}

inline 
void 
CPGPdiskDisk::GetPath(CString& path) const
{
	pgpAssert(IsAttached());

	GetDataProp(kPGPdiskDiskProp_Path, 
		path.GetBuffer(kPGPdiskMaxPathLength), kPGPdiskMaxPathLength);
	path.ReleaseBuffer();
}

inline 
void 
CPGPdiskDisk::GetRoot(CString& root) const
{
	pgpAssert(IsAttached());

	GetDataProp(kPGPdiskDiskProp_Root, root.GetBuffer(kPGPdiskMaxPathLength), 
		kPGPdiskMaxPathLength);
	root.ReleaseBuffer();
}

inline 
void 
CPGPdiskDisk::GetDeviceName(CString& deviceName) const
{
	pgpAssert(IsAttached());

	GetDataProp(kPGPdiskDiskProp_DeviceName, 
		deviceName.GetBuffer(kPGPdiskMaxDeviceNameLength), 
		kPGPdiskMaxDeviceNameLength);
	deviceName.ReleaseBuffer();
}

inline 
PGPdiskContextRef 
CPGPdiskDisk::Context() const
{
	pgpAssert(IsAttached());
	return PGPdiskPeekDiskContext(mDisk);
}

inline 
void 
CPGPdiskDisk::ExportUserSet(PGPdiskUserSetRef userSet) const
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskDiskExportUserSet(mDisk, userSet);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::ImportUserSet(
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserRef		adminUserForCiphering)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskDiskImportUserSet(mDisk, userSet, 
		adminUserForCiphering);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::ChangeOnePassphrase(
	const char	*userName, 
	const char	*oldPassphrase, 
	const char	*newPassphrase)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskDiskChangeOnePassphrase(mDisk, userName, 
		oldPassphrase, newPassphrase);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::RemoveOneUser(PGPdiskUserRef userForCiphering)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskDiskRemoveOneUser(mDisk, userForCiphering);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::SetUsesCustomTimeout(PGPBoolean usesCustom)
{
	pgpAssert(IsAttached());
	SetBooleanProp(kPGPdiskDiskProp_UsesCustomTimeout, usesCustom);
}

inline 
void 
CPGPdiskDisk::SetDefaultRoot(const char *root)
{
	pgpAssert(IsAttached());
	SetDataProp(kPGPdiskDiskProp_DefaultRoot, root, strlen(root));
}

inline 
void 
CPGPdiskDisk::SetCustomTimeout(PGPUInt32 customTimeout)
{
	pgpAssert(IsAttached());
	SetNumericProp(kPGPdiskDiskProp_CustomTimeout, customTimeout);
}

inline 
void 
CPGPdiskDisk::WipeUsers()
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskWipeUsersOnDisk(mDisk);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::ReEncryptDisk(
	const char					*adminPassphrase, 
	PGPdiskEncryptionAlgorithm	newAlgorithm, 
	ReEncryptDiskStatusFuncType	statusFunc, 
	void						*userValue) const
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskReEncryptDisk(mDisk, adminPassphrase, 
		newAlgorithm, statusFunc, userValue);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::LockVolume(PGPBoolean forFormat)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskLockDiskVolume(mDisk, forFormat);
	THROW_IF_PGPERROR(error);

	mWeLocked = TRUE;
}

inline 
void 
CPGPdiskDisk::UnlockVolume()
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskUnlockDiskVolume(mDisk);
	THROW_IF_PGPERROR(error);

	mWeLocked = FALSE;
}

inline 
void 
CPGPdiskDisk::ReadVolume(
	void		*buffer, 
	PGPUInt64	blockPos, 
	PGPUInt32	blocksLength)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskReadDiskVolume(mDisk, buffer, blockPos, 
		blocksLength);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::WriteVolume(
	const void	*buffer, 
	PGPUInt64	blockPos, 
	PGPUInt32	blocksLength)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskWriteDiskVolume(mDisk, buffer, blockPos, 
		blocksLength);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::Open(
	PGPdiskContextRef	context, 
	const char			*path, 
	PGPBoolean			readOnly)
{
	pgpAssert(!WeOpened());

	PGPError	error	= PGPdiskOpenDisk(context, path, readOnly, &mDisk);
	THROW_IF_PGPERROR(error);

	mWeOpened = TRUE;
}

inline 
void 
CPGPdiskDisk::Close()
{
	pgpAssert(WeOpened());

	PGPError	error	= PGPdiskCloseDisk(mDisk);
	THROW_IF_PGPERROR(error);

	mWeOpened = FALSE;
	mDisk = kInvalidPGPdiskDiskRef;
}

inline 
void 
CPGPdiskDisk::Attach(PGPdiskDiskRef disk)
{
	if (mDisk == disk)
		return;

	Clear();

	mDisk = disk;
	mWeOpened = FALSE;
}

inline 
void 
CPGPdiskDisk::Clear()
{
	if (WeOpened())
		Close();

	if (WeLocked())
		UnlockVolume();

	mDisk = kInvalidPGPdiskDiskRef;
	mWeOpened = mWeLocked = FALSE;
}

inline 
PGPBoolean 
CPGPdiskDisk::GetBooleanProp(PGPdiskDiskPropName prop) const
{
	pgpAssert(IsAttached());

	PGPBoolean	boolVal;

	PGPError	error	= PGPdiskGetDiskBooleanProp(mDisk, prop, &boolVal);
	THROW_IF_PGPERROR(error);

	return boolVal;
}

inline 
PGPInt32 
CPGPdiskDisk::GetNumericProp(PGPdiskDiskPropName prop) const
{
	pgpAssert(IsAttached());

	PGPInt32	number;

	PGPError	error	= PGPdiskGetDiskNumericProp(mDisk, prop, &number);
	THROW_IF_PGPERROR(error);

	return number;
}

inline 
void 
CPGPdiskDisk::GetDataProp(
	PGPdiskDiskPropName	prop, 
	void				*pData, 
	PGPSize				availLength, 
	PGPSize				*pUsedLength) const
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskGetDiskDataProp(mDisk, prop, pData, 
		availLength, pUsedLength);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::SetBooleanProp(PGPdiskDiskPropName prop, PGPBoolean boolVal)
{
	PGPError	error	= PGPdiskSetDiskBooleanProp(mDisk, prop, boolVal);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::SetNumericProp(PGPdiskDiskPropName prop, PGPInt32 number)
{
	PGPError	error	= PGPdiskSetDiskNumericProp(mDisk, prop, number);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDisk::SetDataProp(
	PGPdiskDiskPropName	prop, 
	const void			*pData,