cpgpdiskengine.h

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

	PGPSize				length)
{
	PGPError	error	= PGPdiskSetDiskDataProp(mDisk, prop, pData, length);
	THROW_IF_PGPERROR(error);
}


// Class CPGPdiskDiskSet member functions

inline 
CPGPdiskDiskSet::CPGPdiskDiskSet(PGPdiskContextRef context) : 
	mDiskSet(kInvalidPGPdiskDiskSetRef), mWeCreated(FALSE)
{
	Create(context);
}

inline 
CPGPdiskDiskSet::CPGPdiskDiskSet(PGPdiskDiskSetRef diskSet) : 
	mDiskSet(kInvalidPGPdiskDiskSetRef), mWeCreated(FALSE)
{
	Attach(diskSet);
}

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

inline 
PGPdiskContextRef 
CPGPdiskDiskSet::Context() const
{
	pgpAssert(IsAttached());
	return PGPdiskPeekDiskSetContext(mDiskSet);
}

inline 
PGPBoolean 
CPGPdiskDiskSet::IsAttached() const
{
	return PGPdiskDiskSetRefIsValid(mDiskSet);
}

inline 
PGPUInt32 
CPGPdiskDiskSet::Count() const
{
	pgpAssert(IsAttached());
	return PGPdiskDiskSetCount(mDiskSet);
}

inline 
void 
CPGPdiskDiskSet::Mount(
	const char		*path, 
	PGPdiskUserRef	userForCiphering, 
	const char		*root, 
	PGPBoolean		readOnly, 
	CPGPdiskDisk	&disk)
{
	PGPdiskDiskRef	diskRef;

	PGPError	error	= PGPdiskDiskSetMountDisk(mDiskSet, path, 
		userForCiphering, root, readOnly, &diskRef);
	THROW_IF_PGPERROR(error);

	disk.Attach(diskRef);
}

inline 
void 
CPGPdiskDiskSet::Unmount(PGPdiskDiskRef disk, PGPBoolean isForced)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskDiskSetUnmountDisk(mDiskSet, disk, isForced);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDiskSet::UnmountTimedOut(PGPBoolean isForced)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskDiskSetUnmountTimedOut(mDiskSet, isForced);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDiskSet::UnmountAll(PGPBoolean isForced)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskDiskSetUnmountAll(mDiskSet, isForced);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDiskSet::WipeAllUsers()
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskDiskSetWipeAllUsers(mDiskSet);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDiskSet::CreateDisk(
	const char					*path, 
	PGPUInt64					blocksDisk, 
	PGPdiskEncryptionAlgorithm	algorithm, 
	const char					*passphrase, 
	const char					*userName, 
	const char					*defaultRoot, 
	NewDiskStatusFuncType		statusFunc, 
	void						*userValue, 
	CPGPdiskDisk&				disk)
{
	pgpAssert(IsAttached());

	PGPdiskDiskRef	diskRef;
	PGPError		error	= PGPdiskDiskSetCreateDiskWithSym(mDiskSet, 
		path, blocksDisk, algorithm, passphrase, userName, defaultRoot, 
		statusFunc, userValue, &diskRef);
	THROW_IF_PGPERROR(error);

	disk.Attach(diskRef);
}

inline 
void 
CPGPdiskDiskSet::CreateDisk(
	const char					*path, 
	PGPUInt64					blocksDisk, 
	PGPdiskEncryptionAlgorithm	algorithm, 
	PGPKeyDBObjRef				key, 
	const char					*defaultRoot, 
	NewDiskStatusFuncType		statusFunc, 
	void						*userValue, 
	CPGPdiskDisk&				disk)
{
	pgpAssert(IsAttached());

	PGPdiskDiskRef	diskRef;
	PGPError		error	= PGPdiskDiskSetCreateDiskWithPub(mDiskSet, 
		path, blocksDisk, algorithm, key, defaultRoot, statusFunc, 
		userValue, &diskRef);
	THROW_IF_PGPERROR(error);

	disk.Attach(diskRef);
}

inline 
void 
CPGPdiskDiskSet::Update()
{
	PGPError	error	= PGPdiskUpdateDiskSet(mDiskSet);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskDiskSet::Attach(PGPdiskDiskSetRef diskSet)
{
	if (mDiskSet == diskSet)
		return;

	Clear();

	mDiskSet = diskSet;
	mWeCreated = FALSE;
}

inline 
void 
CPGPdiskDiskSet::Create(PGPdiskContextRef context)
{
	Clear();

	PGPError	error	= PGPdiskNewDiskSet(context, &mDiskSet);
	THROW_IF_PGPERROR(error);

	mWeCreated = TRUE;
}

inline 
void 
CPGPdiskDiskSet::Clear()
{
	if (WeCreated())
		PGPdiskFreeDiskSet(mDiskSet);

	mDiskSet = kInvalidPGPdiskDiskSetRef;
	mWeCreated = FALSE;
}


// Class CPGPdiskDiskIter member functions

inline 
CPGPdiskDiskIter::CPGPdiskDiskIter(PGPdiskDiskSetRef diskSet) : 
	mDiskIter(kInvalidPGPdiskDiskIterRef), mWeCreated(FALSE)
{
	Create(diskSet);
}

inline 
CPGPdiskDiskIter::CPGPdiskDiskIter(PGPdiskDiskIterRef diskIter) : 
	mDiskIter(kInvalidPGPdiskDiskIterRef), mWeCreated(FALSE)
{
	Attach(diskIter);
}

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

inline 
PGPdiskDiskSetRef 
CPGPdiskDiskIter::DiskSet() const
{
	pgpAssert(IsAttached());
	return PGPdiskPeekDiskIterDiskSet(mDiskIter);
}

inline 
PGPBoolean 
CPGPdiskDiskIter::IsAttached() const
{
	return PGPdiskDiskIterRefIsValid(mDiskIter);
}

inline 
PGPUInt32 
CPGPdiskDiskIter::Count() const
{
	pgpAssert(IsAttached());
	return PGPdiskDiskIterCount(mDiskIter);
}

inline 
PGPInt32 
CPGPdiskDiskIter::Index() const
{
	pgpAssert(IsAttached());
	return PGPdiskDiskIterIndex(mDiskIter);
}

inline 
PGPBoolean 
CPGPdiskDiskIter::Current(CPGPdiskDisk& disk) const
{
	pgpAssert(IsAttached());

	PGPdiskDiskRef	diskRef;
	PGPBoolean		succeeded	= PGPdiskDiskIterDisk(mDiskIter, &diskRef);

	if (succeeded)
		disk = diskRef;

	return succeeded;
}

inline 
PGPBoolean 
CPGPdiskDiskIter::Move(
	PGPInt32		relOffset, 
	PGPBoolean		fromStart, 
	CPGPdiskDisk&	disk)
{
	pgpAssert(IsAttached());

	PGPdiskDiskRef	diskRef;
	PGPBoolean		succeeded	= PGPdiskDiskIterMove(mDiskIter, relOffset, 
		fromStart, &diskRef);

	if (succeeded)
		disk = diskRef;

	return succeeded;
}

inline 
PGPInt32 
CPGPdiskDiskIter::Seek(PGPdiskDiskRef soughtDisk)
{
	pgpAssert(IsAttached());
	return PGPdiskDiskIterSeek(mDiskIter, soughtDisk);
}

inline 
PGPBoolean 
CPGPdiskDiskIter::Next(CPGPdiskDisk& disk)
{
	pgpAssert(IsAttached());

	PGPdiskDiskRef	diskRef;
	PGPBoolean		succeeded	= PGPdiskDiskIterNext(mDiskIter, &diskRef);

	if (succeeded)
		disk = diskRef;

	return succeeded;
}

inline 
PGPBoolean 
CPGPdiskDiskIter::Prev(CPGPdiskDisk& disk)
{
	pgpAssert(IsAttached());

	PGPdiskDiskRef	diskRef;
	PGPBoolean		succeeded	= PGPdiskDiskIterPrev(mDiskIter, &diskRef);

	if (succeeded)
		disk = diskRef;

	return succeeded;
}

inline 
void 
CPGPdiskDiskIter::Rewind()
{
	pgpAssert(IsAttached());
	PGPdiskDiskIterRewind(mDiskIter);
}

inline 
PGPBoolean 
CPGPdiskDiskIter::SearchOnPath(const char *path, CPGPdiskDisk& disk)
{
	pgpAssert(IsAttached());

	PGPdiskDiskRef	diskRef;
	PGPBoolean		succeeded	= PGPdiskDiskIterSearchOnPath(mDiskIter, 
		path, &diskRef);

	if (succeeded)
		disk = diskRef;

	return succeeded;
}

inline 
PGPBoolean 
CPGPdiskDiskIter::SearchOnRoot(const char *root, CPGPdiskDisk& disk)
{
	pgpAssert(IsAttached());

	PGPdiskDiskRef	diskRef;
	PGPBoolean		succeeded	= PGPdiskDiskIterSearchOnRoot(mDiskIter, 
		root, &diskRef);

	if (succeeded)
		disk = diskRef;

	return succeeded;
}

inline 
void 
CPGPdiskDiskIter::Attach(PGPdiskDiskIterRef diskIter)
{
	if (mDiskIter == diskIter)
		return;

	Clear();

	mDiskIter = diskIter;
	mWeCreated = FALSE;
}

inline 
void 
CPGPdiskDiskIter::Create(PGPdiskDiskSetRef diskSet)
{
	Clear();

	PGPError	error	= PGPdiskNewDiskIter(diskSet, &mDiskIter);
	THROW_IF_PGPERROR(error);

	mWeCreated = TRUE;
}

inline 
void 
CPGPdiskDiskIter::Clear()
{
	if (WeCreated())
		PGPdiskFreeDiskIter(mDiskIter);

	mDiskIter = kInvalidPGPdiskDiskIterRef;
	mWeCreated = FALSE;
}


// Class CPGPdiskUser member functions

inline 
CPGPdiskUser::CPGPdiskUser() : 
	mUser(kInvalidPGPdiskUserRef), mWeCreated(FALSE)
{
}

inline 
CPGPdiskUser::CPGPdiskUser(PGPdiskUserRef user) :
	mUser(kInvalidPGPdiskUserRef), mWeCreated(FALSE)
{
	Attach(user);
}

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

inline 
CPGPdiskUser& 
CPGPdiskUser::operator=(PGPdiskUserRef user)
{
	Attach(user);
	return *this;
}

inline 
PGPBoolean 
CPGPdiskUser::IsAttached() const
{
	return PGPdiskUserRefIsValid(mUser);
}

inline 
PGPBoolean 
CPGPdiskUser::IsEqualUser(PGPdiskUserRef user) const
{
	return PGPdiskUserAreUsersEqual(mUser, user);
}

inline 
PGPBoolean 
CPGPdiskUser::HasPublicKey() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_HasPublicKey);
}

inline 
PGPBoolean 
CPGPdiskUser::HasSymmetricKey() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_HasSymmetricKey);
}

inline 
PGPBoolean 
CPGPdiskUser::IsReadOnly() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_IsReadOnly);
}

inline 
PGPBoolean 
CPGPdiskUser::IsLocked() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_IsLocked);
}

inline 
PGPBoolean 
CPGPdiskUser::IsAdminUser() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_IsAdminUser);
}

inline 
PGPBoolean 
CPGPdiskUser::IsDisabled() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_IsDisabled);
}

inline 
PGPBoolean 
CPGPdiskUser::IsCipheringEnabled() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_IsCipheringEnabled);
}

inline 
PGPBoolean 
CPGPdiskUser::CanSetReadOnly() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_CanSetReadOnly);
}

inline 
PGPBoolean 
CPGPdiskUser::CanSetLocked() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_CanSetLocked);
}

inline 
PGPBoolean 
CPGPdiskUser::CanSetUserName() const
{
	pgpAssert(IsAttached());
	return GetBooleanProp(kPGPdiskUserProp_CanSetUserName);
}

inline 
PGPdiskContextRef 
CPGPdiskUser::Context() const
{
	pgpAssert(IsAttached());
	return PGPdiskPeekUserContext(mUser);
}

inline 
void 
CPGPdiskUser::GetUserName(CString& userName) const
{
	pgpAssert(IsAttached());

	GetDataProp(kPGPdiskUserProp_UserName, 
		userName.GetBuffer(kPGPdiskMaxUserNameSize), 
		kPGPdiskMaxUserNameSize);
	userName.ReleaseBuffer();
}

inline 
void 
CPGPdiskUser::GetPGPKeyID(CPGPKeyID& keyID) const
{
	pgpAssert(IsAttached());

	PGPKeyID	theKeyID;

	PGPError	error	= PGPdiskUserGetPGPKeyID(mUser, &theKeyID);
	THROW_IF_PGPERROR(error);

	keyID = theKeyID;
}

inline 
void 
CPGPdiskUser::SetIsReadOnly(PGPBoolean isReadOnly)
{
	pgpAssert(IsAttached());
	SetBooleanProp(kPGPdiskUserProp_IsReadOnly, isReadOnly);