pgpdiskengineexports.cpp

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

		switch (prop)
		{
		case kPGPdiskDiskProp_CustomTimeout:
			disk->SetCustomTimeout(number);
			break;

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

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskSetDiskDataProp(
	PGPdiskDiskRef		disk, 
	PGPdiskDiskPropName	prop, 
	const void			*pData, 
	PGPSize				dataLength)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidatePtr(pData);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		switch (prop)
		{
		case kPGPdiskDiskProp_DefaultRoot:
			disk->SetDefaultRoot(static_cast<const char *>(pData));
			break;

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

	return error;
}

/* Specialized PGPdiskDiskRef operations */

PGPError 
PGPdiskEngineExport 
PGPdiskLockDiskVolume(PGPdiskDiskRef disk, PGPBoolean forFormat)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));

	PGPError	error	= kPGPError_NoErr;

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

	return error;
}

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

	PGPError	error	= kPGPError_NoErr;

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

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskReadDiskVolume(
	PGPdiskDiskRef	disk, 
	void			*buffer, 
	PGPUInt64		blockPos, 
	PGPUInt32		blocksLength)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidatePtr(buffer);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		disk->ReadVolume(buffer, blockPos, blocksLength);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskWriteDiskVolume(
	PGPdiskDiskRef	disk, 
	const void		*buffer, 
	PGPUInt64		blockPos, 
	PGPUInt32		blocksLength)
{
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));
	PGPValidatePtr(buffer);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		disk->WriteVolume(buffer, blockPos, blocksLength);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

/* PGPdiskDiskSetRef functions */

PGPError 
PGPdiskEngineExport 
PGPdiskNewDiskSet(PGPdiskContextRef context, PGPdiskDiskSetRef *pDiskSet)
{
	PGPValidateParam(PGPdiskContextRefIsValid(context));
	PGPValidatePtr(pDiskSet);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pDiskSet = new CPGPdiskDiskSet(context);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

void 
PGPdiskEngineExport 
PGPdiskFreeDiskSet(PGPdiskDiskSetRef diskSet)
{
	pgpAssert(PGPdiskDiskSetRefIsValid(diskSet));

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

PGPdiskContextRef 
PGPdiskEngineExport 
PGPdiskPeekDiskSetContext(PGPdiskDiskSetRef diskSet)
{
	pgpAssert(PGPdiskDiskSetRefIsValid(diskSet));

	PGPdiskContextRef	context	= kInvalidPGPdiskContextRef;

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

	return context;
}

PGPUInt32 
PGPdiskEngineExport 
PGPdiskDiskSetCount(PGPdiskDiskSetRef userSet)
{
	pgpAssert(PGPdiskDiskSetRefIsValid(userSet));

	PGPUInt32	count	= 0;

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

	return count;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskSetMountDisk(
	PGPdiskDiskSetRef	diskSet, 
	const char			*path, 
	PGPdiskUserRef		user, 
	const char			*root, 
	PGPBoolean			readOnly, 
	PGPdiskDiskRef		*pDisk)
{
	PGPValidateParam(PGPdiskDiskSetRefIsValid(diskSet));
	PGPValidatePtr(path);
	PGPValidateParam(PGPdiskUserRefIsValid(user));
	PGPValidatePtr(root);
	PGPValidatePtr(pDisk);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pDisk = diskSet->Mount(path, *user, root, readOnly);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskSetUnmountDisk(
	PGPdiskDiskSetRef	diskSet, 
	PGPdiskDiskRef		disk, 
	PGPBoolean			isForced)
{
	PGPValidateParam(PGPdiskDiskSetRefIsValid(diskSet));
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		diskSet->Unmount(disk, isForced);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}


PGPError 
PGPdiskEngineExport 
PGPdiskDiskSetCreateDiskWithSym(
	PGPdiskDiskSetRef			diskSet, 
	const char					*path, 
	PGPUInt64					blocksDisk, 
	PGPdiskEncryptionAlgorithm	algorithm, 
	const char					*passphrase, 
	const char					*userName, 
	const char					*defaultRoot, 
	NewDiskStatusFuncType		statusFunc, 
	void						*userValue, 
	PGPdiskDiskRef				*pDisk)
{
	PGPValidateParam(PGPdiskDiskSetRefIsValid(diskSet));
	PGPValidatePtr(path);
	PGPValidatePtr(passphrase);
	PGPValidatePtr(userName);
	PGPValidatePtr(defaultRoot);
	PGPValidatePtr(statusFunc);
	PGPValidatePtr(pDisk);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pDisk = diskSet->CreateDisk(path, blocksDisk, algorithm, 
			passphrase, userName, defaultRoot, statusFunc, userValue);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskSetCreateDiskWithPub(
	PGPdiskDiskSetRef			diskSet, 
	const char					*path, 
	PGPUInt64					blocksDisk, 
	PGPdiskEncryptionAlgorithm	algorithm, 
	PGPKeyDBObjRef				pubKey, 
	const char					*defaultRoot, 
	NewDiskStatusFuncType		statusFunc, 
	void						*userValue, 
	PGPdiskDiskRef				*pDisk)
{
	PGPValidateParam(PGPdiskDiskSetRefIsValid(diskSet));
	PGPValidatePtr(path);
	PGPValidateParam(PGPKeyDBObjRefIsValid(pubKey));
	PGPValidatePtr(defaultRoot);
	PGPValidatePtr(statusFunc);
	PGPValidatePtr(pDisk);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pDisk = diskSet->CreateDisk(path, blocksDisk, algorithm, pubKey, 
			defaultRoot, statusFunc, userValue);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskSetUnmountTimedOut(PGPdiskDiskSetRef diskSet, PGPBoolean isForced)
{
	PGPValidateParam(PGPdiskDiskSetRefIsValid(diskSet));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		diskSet->UnmountTimedOut(isForced);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskSetUnmountAll(PGPdiskDiskSetRef diskSet, PGPBoolean isForced)
{
	PGPValidateParam(PGPdiskDiskSetRefIsValid(diskSet));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		diskSet->UnmountAll(isForced);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDiskSetWipeAllUsers(PGPdiskDiskSetRef diskSet)
{
	PGPValidateParam(PGPdiskDiskSetRefIsValid(diskSet));

	PGPError	error	= kPGPError_NoErr;

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

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskUpdateDiskSet(PGPdiskDiskSetRef diskSet)
{
	PGPValidateParam(PGPdiskDiskSetRefIsValid(diskSet));

	PGPError	error	= kPGPError_NoErr;

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

	return error;
}

/* PGPdiskDiskIterRef functions */

PGPError 
PGPdiskEngineExport 
PGPdiskNewDiskIter(PGPdiskDiskSetRef diskSet, PGPdiskDiskIterRef *pDiskIter)
{
	PGPValidateParam(PGPdiskDiskSetRefIsValid(diskSet));
	PGPValidatePtr(pDiskIter);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pDiskIter = new CPGPdiskDiskIter(diskSet);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

void 
PGPdiskEngineExport 
PGPdiskFreeDiskIter(PGPdiskDiskIterRef diskIter)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));

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

PGPdiskDiskSetRef 
PGPdiskEngineExport 
PGPdiskPeekDiskIterDiskSet(PGPdiskDiskIterRef diskIter)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));

	PGPdiskDiskSetRef	diskSet	= kInvalidPGPdiskDiskSetRef;

	try
	{
		diskSet = const_cast<CPGPdiskDiskSet *>(diskIter->DiskSet());
	}
	catch (CComboError&) { }

	return diskSet;
}

PGPUInt32 
PGPdiskEngineExport 
PGPdiskDiskIterCount(PGPdiskDiskIterRef diskIter)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));

	PGPUInt32	count	= 0;

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

	return count;
}

PGPInt32 
PGPdiskEngineExport 
PGPdiskDiskIterIndex(PGPdiskDiskIterRef diskIter)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));

	PGPInt32	index	= -1;

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

	return index;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskDiskIterDisk(PGPdiskDiskIterRef diskIter, PGPdiskDiskRef *pDisk)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));

	PGPBoolean	succeeded	= FALSE;

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

	return succeeded;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskDiskIterMove(
	PGPdiskDiskIterRef	diskIter, 
	PGPInt32			relOffset, 
	PGPBoolean			fromStart, 
	PGPdiskDiskRef		*pDisk)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));
	pgpAssertAddrValid(pDisk, PGPdiskDiskRef);

	PGPBoolean	succeeded	= FALSE;

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

	return succeeded;
}

PGPInt32 
PGPdiskEngineExport 
PGPdiskDiskIterSeek(PGPdiskDiskIterRef diskIter, PGPdiskDiskRef disk)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));
	pgpAssert(PGPdiskDiskRefIsValid(disk));

	PGPInt32	index	= -1;

	try
	{
		index = diskIter->Seek(disk);
	}
	catch (CComboError&) { }

	return index;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskDiskIterNext(PGPdiskDiskIterRef diskIter, PGPdiskDiskRef *pDisk)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));
	pgpAssertAddrValid(pDisk, PGPdiskDiskRef);

	PGPBoolean	succeeded	= FALSE;

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

	return succeeded;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskDiskIterPrev(PGPdiskDiskIterRef diskIter, PGPdiskDiskRef *pDisk)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));
	pgpAssertAddrValid(pDisk, PGPdiskDiskRef);

	PGPBoolean	succeeded	= FALSE;

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

	return succeeded;
}

void 
PGPdiskEngineExport 
PGPdiskDiskIterRewind(PGPdiskDiskIterRef diskIter)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));

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

PGPBoolean 
PGPdiskEngineExport 
PGPdiskDiskIterSearchOnPath(
	PGPdiskDiskIterRef	diskIter, 
	const char			*path, 
	PGPdiskDiskRef		*pDisk)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));
	pgpAssertStrValid(path);
	pgpAssertAddrValid(pDisk, PGPdiskDiskRef);

	PGPBoolean	succeeded	= FALSE;

	try
	{
		*pDisk = diskIter->SearchOnPath(path);
		succeeded = IsntNull(*pDisk);
	}
	catch (CComboError&) { }

	return succeeded;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskDiskIterSearchOnRoot(
	PGPdiskDiskIterRef	diskIter, 
	const char			*root, 
	PGPdiskDiskRef		*pDisk)
{
	pgpAssert(PGPdiskDiskIterRefIsValid(diskIter));
	pgpAssertStrValid(root);
	pgpAssertAddrValid(pDisk, PGPdiskDiskRef);

	PGPBoolean	succeeded	= FALSE;

	try
	{
		*pDisk = diskIter->SearchOnRoot(root);
		succeeded = IsntNull(*pDisk);
	}
	catch (CComboError&) { }

	return succeeded;
}

/* Miscellaneous functions */

void 
PGPdiskEngineExport 
PGPdiskPrefsChanged(PGPdiskContextRef context, PGPPrefRef prefs)
{
	pgpAssert(PGPdiskContextRefIsValid(context));
	pgpAssert(PGPPrefRefIsValid(prefs));

	try
	{
		CPGPdiskDiskSet	diskSet(context);
		diskSet.UpdateTimeouts();
	}
	catch (CComboError&) { }
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskAreDisksTimedOut()
{
	PGPBoolean	result	= FALSE;

	try
	{
		result = CEngineSubsystems::DriverComm().AreDisksTimedOut();
	}
	catch (CComboError&) { }

	return result;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskIsPathMountedPGPdisk(const char *path)
{
	pgpAssertStrValid(path);

	PGPBoolean	result	= FALSE;

	try
	{
		CEngineSubsystems::DriverComm().QueryMountedPath(path, result);
	}
	catch (CComboError&) { }

	return result;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskIsRootMountedPGPdisk(const char *root)
{
	pgpAssertStrValid(root);

	PGPBoolean	result	= FALSE;

	try
	{
		CEngineSubsystems::DriverComm().QueryMountedRoot(root, result);
	}
	catch (CComboError&) { }

	return result;
}

PGPUInt32 
PGPdiskEngineExport 
PGPdiskGetNumDiskAlgorithms()
{
	PGPUInt32	numAlgorithms	= 0;

	try
	{
		numAlgorithms = UCryptoFactory::GetNumAlgorithms();
	}
	catch (CComboError&) { }

	return numAlgorithms;
}

void 
PGPdiskEngineExport 
PGPdiskGetDiskAlgorithmIdString(
	PGPdiskEncryptionAlgorithm	algorithm, 
	char						*idString, 
	PGPUInt32					availLength)
{
	pgpAssertAddrValid(idString, char);

	try
	{
		CString	cidString;

		UCryptoFactory::GetAlgorithmIdString(algorithm, cidString);
		UString::SmartStringCopy(idString, cidString, availLength);
	}
	catch (CComboError&) { }
}

void 
PGPdiskEngineExport 
PGPdiskGetSupportedDiskAlgorithms(
	PGPdiskEncryptionAlgorithm	*pAlgArray,	
	PGPSize						availLength, 
	PGPSize						*pUsedLength)
{
	pgpAssertAddrValid(pAlgArray, PGPdiskEncryptionAlgorithm);

	try
	{
		CArray<PGPdiskEncryptionAlgorithm>	algArray;
		PGPUInt32							usedLength;

		UCryptoFactory::GetSupportedAlgorithms(algArray, usedLength);

		for (PGPUInt32 i = 0; i < usedLength; i++)
		{
			pAlgArray[i] = algArray[i];
		}

		if (IsntNull(pUsedLength))
			*pUsedLength = usedLength;
	}
	catch (CComboError&) { }
}

PGPUInt32 
PGPdiskEngineExport 
PGPdiskGetNeededRandomDataSize(PGPdiskEncryptionAlgorithm algorithm)
{
	PGPUInt32	result	= 0;

	try
	{
		CCipherContext	cipher(algorithm);
		result = cipher.GetNeededRandomDataSize();
	}
	catch (CComboError&) { }

	return result;
}

PGPError 
PGPdiskEngineExport 
PGPdiskNotifyUserLogoff()
{
	PGPError	error	= kPGPError_NoErr;

	try
	{
		CEngineSubsystems::DriverComm().NotifyUserLogoff();
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}