pgpdiskengineexports.cpp

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

PGPdiskUserSetRemoveUsers(
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserSetRef	usersToRemove)
{
	PGPValidateParam(PGPdiskUserSetRefIsValid(userSet));
	PGPValidateParam(PGPdiskUserSetRefIsValid(usersToRemove));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		userSet->Remove(*usersToRemove);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskUserSetRemoveUser(
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserRef		userToRemove)
{
	PGPValidateParam(PGPdiskUserSetRefIsValid(userSet));
	PGPValidateParam(PGPdiskUserRefIsValid(userToRemove));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		userSet->Remove(*userToRemove);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskUserSetEmptyUserSet(PGPdiskUserSetRef userSet)
{
	PGPValidateParam(PGPdiskUserSetRefIsValid(userSet));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		userSet->Empty();
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

/* PGPdiskUserIterRef functions */

PGPError 
PGPdiskEngineExport 
PGPdiskNewUserIter(PGPdiskUserSetRef userSet, PGPdiskUserIterRef *pUserIter)
{
	PGPValidateParam(PGPdiskUserSetRefIsValid(userSet));
	PGPValidatePtr(pUserIter);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pUserIter = new CPGPdiskUserIter(userSet);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

void 
PGPdiskEngineExport 
PGPdiskFreeUserIter(PGPdiskUserIterRef userIter)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));

	try
	{
		delete userIter;
	}
	catch (CComboError&) { }
}

PGPdiskUserSetRef 
PGPdiskEngineExport 
PGPdiskPeekUserSet(PGPdiskUserIterRef userIter)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));

	PGPdiskUserSetRef	userSet	= kInvalidPGPdiskUserSetRef;

	try
	{
		userSet = const_cast<CPGPdiskUserSet *>(userIter->UserSet());
	}
	catch (CComboError&) { }

	return userSet;
}

PGPUInt32 
PGPdiskEngineExport 
PGPdiskUserIterCount(PGPdiskUserIterRef userIter)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));

	PGPUInt32	count	= 0;

	try
	{
		count = userIter->Count();
	}
	catch (CComboError&) { }

	return count;
}

PGPInt32 
PGPdiskEngineExport 
PGPdiskUserIterIndex(PGPdiskUserIterRef userIter)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));

	PGPInt32	index	= -1;

	try
	{
		index = userIter->Index();
	}
	catch (CComboError&) { }

	return index;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskUserIterUser(PGPdiskUserIterRef userIter, PGPdiskUserRef *pUser)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));

	PGPBoolean	succeeded	= FALSE;

	try
	{
		*pUser = userIter->Current();
		succeeded = IsntNull(*pUser);
	}
	catch (CComboError&) { }

	return succeeded;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskUserIterMove(
	PGPdiskUserIterRef	userIter, 
	PGPInt32			relOffset, 
	PGPBoolean			fromStart, 
	PGPdiskUserRef		*pUser)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));
	pgpAssertAddrValid(pUser, PGPdiskUserRef);

	PGPBoolean	succeeded	= FALSE;

	try
	{
		*pUser = userIter->Move(relOffset, fromStart);
		succeeded = IsntNull(*pUser);
	}
	catch (CComboError&) { }

	return succeeded;
}

PGPInt32 
PGPdiskEngineExport 
PGPdiskUserIterSeek(PGPdiskUserIterRef userIter, PGPdiskUserRef user)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));
	pgpAssert(PGPdiskUserRefIsValid(user));

	PGPInt32	index	= -1;

	try
	{
		index = userIter->Seek(user);
	}
	catch (CComboError&) { }

	return index;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskUserIterNext(PGPdiskUserIterRef userIter, PGPdiskUserRef *pUser)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));
	pgpAssertAddrValid(pUser, PGPdiskUserRef);

	PGPBoolean	succeeded	= FALSE;

	try
	{
		*pUser = userIter->Next();
		succeeded = IsntNull(*pUser);
	}
	catch (CComboError&) { }

	return succeeded;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskUserIterPrev(PGPdiskUserIterRef userIter, PGPdiskUserRef *pUser)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));
	pgpAssertAddrValid(pUser, PGPdiskUserRef);

	PGPBoolean	succeeded	= FALSE;

	try
	{
		*pUser = userIter->Prev();
		succeeded = IsntNull(*pUser);
	}
	catch (CComboError&) { }

	return succeeded;
}

void 
PGPdiskEngineExport 
PGPdiskUserIterRewind(PGPdiskUserIterRef userIter)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));

	try
	{
		userIter->Rewind();
	}
	catch (CComboError&) { }
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskUserIterSearchOnUserName(
	PGPdiskUserIterRef	userIter, 
	const char			*userName, 
	PGPdiskUserRef		*pUser)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));
	pgpAssertStrValid(userName);
	pgpAssertAddrValid(pUser, PGPdiskUserRef);

	PGPBoolean	succeeded	= FALSE;

	try
	{
		*pUser = userIter->SearchOnUserName(userName);
		succeeded = IsntNull(*pUser);
	}
	catch (CComboError&) { }

	return succeeded;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskUserIterFindEqualUser(
	PGPdiskUserIterRef	userIter, 
	PGPdiskUserRef		user, 
	PGPdiskUserRef		*pEqualUser)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));
	pgpAssert(PGPdiskUserRefIsValid(user));
	pgpAssertAddrValid(pEqualUser, PGPdiskUserRef);

	PGPBoolean	succeeded	= FALSE;

	try
	{
		*pEqualUser = userIter->FindEqualUser(*user);
		succeeded = IsntNull(*pEqualUser);
	}
	catch (CComboError&) { }

	return succeeded;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskUserIterFindAdminUser(
	PGPdiskUserIterRef	userIter, 
	PGPdiskUserRef		*pAdminUser)
{
	pgpAssert(PGPdiskUserIterRefIsValid(userIter));
	pgpAssertAddrValid(pAdminUser, PGPdiskUserRef);

	PGPBoolean	succeeded	= FALSE;

	try
	{
		*pAdminUser = userIter->FindAdminUser();
		succeeded = IsntNull(*pAdminUser);
	}
	catch (CComboError&) { }

	return succeeded;
}

PGPError 
PGPdiskEngineExport 
PGPdiskUserIterSetAdminUser(
	PGPdiskUserIterRef	userIter, 
	PGPdiskUserRef		userForCiphering, 
	PGPdiskUserRef		oldAdminForCiphering)
{
	PGPValidateParam(PGPdiskUserIterRefIsValid(userIter));
	PGPValidateParam(PGPdiskUserRefIsValid(userForCiphering));

	// oldAdminForCiphering may not be needed

	PGPError	error	= kPGPError_NoErr;

	try
	{
		userIter->SafeSetAdminUser(userForCiphering, oldAdminForCiphering);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

/* PGPdiskDiskRef operations */

PGPError 
PGPdiskEngineExport 
PGPdiskOpenDisk(
	PGPdiskContextRef	context, 
	const char			*path, 
	PGPBoolean			readOnly, 
	PGPdiskDiskRef		*pDisk)
{
	PGPValidateParam(PGPdiskContextRefIsValid(context));
	PGPValidatePtr(path);
	PGPValidatePtr(pDisk);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		auto_ptr<CPGPdiskDisk>	pNewDisk(new CPGPdiskDisk);
		pNewDisk->Open(context, path, readOnly);

		*pDisk = pNewDisk.release();
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskCloseDisk(PGPdiskDiskRef disk)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		disk->Close();
		delete disk;
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPdiskContextRef 
PGPdiskEngineExport 
PGPdiskPeekDiskContext(PGPdiskDiskRef disk)
{
	pgpAssert(PGPdiskDiskRefIsValid(disk));

	PGPdiskContextRef	context	= kInvalidPGPdiskContextRef;

	try
	{
		context = const_cast<CPGPdiskContext *>(disk->Context());
	}
	catch (CComboError&) { }

	return context;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskExportUserSet(PGPdiskDiskRef disk, PGPdiskUserSetRef userSet)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidateParam(PGPdiskUserSetRefIsValid(userSet));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		disk->ExportUserSet(*userSet);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskImportUserSet(
	PGPdiskDiskRef		disk, 
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserRef		adminUserForCiphering)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidateParam(PGPdiskUserSetRefIsValid(userSet));
	PGPValidateParam(PGPdiskUserRefIsValid(adminUserForCiphering));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		CPGPdiskUserIter	userIter(userSet);
		CPGPdiskUser		*pAdminUser	= userIter.FindAdminUser();

		if ((*adminUserForCiphering != *pAdminUser) || 
			(!adminUserForCiphering->IsCipheringEnabled()))
		{
			THROW_PGPERROR(kPGPError_BadParams);
		}

		disk->ImportUserSet(*userSet);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskChangeOnePassphrase(
	PGPdiskDiskRef	disk, 
	const char		*userName, 
	const char		*oldPassphrase, 
	const char		*newPassphrase)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidatePtr(userName);
	PGPValidatePtr(oldPassphrase);
	PGPValidatePtr(newPassphrase);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		CPGPdiskUserSet	userSet;
		disk->ExportUserSet(userSet);

		CPGPdiskUserIter	userIter(&userSet);
		CPGPdiskUser		*pUser	= userIter.SearchOnUserName(userName);

		if (IsNull(pUser) || !pUser->HasSymmetricKey())
			THROW_PGPERROR(kPGPError_BadParams);

		// This is just conventional and the zero ok -wjb
		disk->EnableCipheringOnUser(*pUser, oldPassphrase, 0); 
		pUser->ChangePassphrase(newPassphrase);

		disk->ImportUserSet(userSet);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskRemoveOneUser(PGPdiskDiskRef disk, PGPdiskUserRef userForCiphering)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidateParam(PGPdiskUserRefIsValid(userForCiphering));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		CPGPdiskUserSet	userSet;
		disk->ExportUserSet(userSet);

		CPGPdiskUserIter	userIter(&userSet);
		
		if (!userIter.Seek(userForCiphering) || 
			!userForCiphering->IsCipheringEnabled())
		{
			THROW_PGPERROR(kPGPError_BadParams);
		}

		CPGPdiskUserSet	usersToRemove(*userForCiphering);
		userSet.Remove(usersToRemove);

		disk->ImportUserSet(userSet);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskWipeUsersOnDisk(PGPdiskDiskRef disk)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		disk->WipeUsers();
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskReEncryptDisk(
	PGPdiskDiskRef				disk, 
	const char					*adminPassphrase, 
	PGPdiskEncryptionAlgorithm	newAlgorithm, 
	ReEncryptDiskStatusFuncType	statusFunc, 
	void						*userValue)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidatePtr(adminPassphrase);
	PGPValidatePtr(statusFunc);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		disk->ReEncrypt(adminPassphrase, newAlgorithm, statusFunc, userValue);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskGetDiskBooleanProp(
	PGPdiskDiskRef		disk, 
	PGPdiskDiskPropName	prop, 
	PGPBoolean			*pBool)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidatePtr(pBool);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		switch (prop)
		{
		case kPGPdiskDiskProp_IsMounted:
			*pBool = disk->IsMounted();
			break;

		case kPGPdiskDiskProp_IsOpened:
			*pBool = disk->IsOpened();
			break;

		case kPGPdiskDiskProp_IsReadOnly:
			*pBool = disk->IsReadOnly();
			break;

		case kPGPdiskDiskProp_IsLockedForFormat:
			*pBool = disk->IsLockedForFormat();
			break;

		case kPGPdiskDiskProp_IsLockedForIO:
			*pBool = disk->IsLockedForIO();
			break;

		case kPGPdiskDiskProp_IsBeingReEncrypted:
			*pBool = disk->IsBeingReEncrypted();
			break;

		case kPGPdiskDiskProp_HasOldHeaders:
			*pBool = disk->HasOldHeaders();
			break;

		case kPGPdiskDiskProp_AreUsersWiped:
			*pBool = disk->AreUsersWiped();
			break;

		case kPGPdiskDiskProp_HasTimedOut:
			*pBool = disk->HasInactivityTimedOut();
			break;

		case kPGPdiskDiskProp_UsesCustomTimeout:
			*pBool = disk->UsesCustomTimeout();
			break;

		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskGetDiskNumericProp(
	PGPdiskDiskRef		disk, 
	PGPdiskDiskPropName	prop, 
	PGPInt32			*pNumber)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidatePtr(pNumber);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		switch (prop)
		{
		case kPGPdiskDiskProp_Algorithm:
			*pNumber = disk->Algorithm();
			break;

		case kPGPdiskDiskProp_CustomTimeout:
			*pNumber = disk->CustomTimeout();
			break;

		case kPGPdiskDiskProp_BlocksDiskLow:
			*pNumber = UMath::GetLowDWord(disk->BlocksDisk());
			break;

		case kPGPdiskDiskProp_BlocksDiskHigh:
			*pNumber = UMath::GetHighDWord(disk->BlocksDisk());
			break;

		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskGetDiskDataProp(
	PGPdiskDiskRef		disk, 
	PGPdiskDiskPropName	prop, 
	void				*pData, 
	PGPSize				availLength, 
	PGPSize				*pUsedLength)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidatePtr(pData);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		PGPSize	usedLength;

		switch (prop)
		{
		case kPGPdiskDiskProp_Path:
			if (availLength < strlen(disk->Path()) + 1)
				THROW_PGPERROR(kPGPError_BufferTooSmall);

			strcpy(static_cast<char *>(pData), disk->Path());
			usedLength = strlen(disk->Path()) + 1;
			break;

		case kPGPdiskDiskProp_Root:
			if (availLength < strlen(disk->Root()) + 1)
				THROW_PGPERROR(kPGPError_BufferTooSmall);

			strcpy(static_cast<char *>(pData), disk->Root());
			usedLength = strlen(disk->Root()) + 1;
			break;
		
		case kPGPdiskDiskProp_DefaultRoot:
			if (availLength < strlen(disk->DefaultRoot()) + 1)
				THROW_PGPERROR(kPGPError_BufferTooSmall);

			strcpy(static_cast<char *>(pData), disk->DefaultRoot());
			usedLength = strlen(disk->DefaultRoot()) + 1;
			break;

		case kPGPdiskDiskProp_DeviceName:
			if (availLength < strlen(disk->DeviceName()) + 1)
				THROW_PGPERROR(kPGPError_BufferTooSmall);

			strcpy(static_cast<char *>(pData), disk->DeviceName());
			usedLength = strlen(disk->DeviceName()) + 1;
			break;

		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}

		if (IsntNull(pUsedLength))
			*pUsedLength = usedLength;
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskSetDiskBooleanProp(
	PGPdiskDiskRef		disk, 
	PGPdiskDiskPropName	prop, 
	PGPBoolean			boolVal)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		switch (prop)
		{
		case kPGPdiskDiskProp_UsesCustomTimeout:
			disk->SetUsesCustomTimeout(boolVal);
			break;

		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskSetDiskNumericProp(
	PGPdiskDiskRef		disk, 
	PGPdiskDiskPropName	prop, 
	PGPInt32			number)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));

	PGPError	error	= kPGPError_NoErr;

	try
	{