cinterfaceimp.cpp

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C++ 代码 · 共 458 行

/*____________________________________________________________________________
		Copyright (C) 2002 PGP Corporation
        All rights reserved.

        $Id: CInterfaceImp.cpp,v 1.10 2002/08/06 20:09:34 dallen Exp $
____________________________________________________________________________*/

#include "pgpClassesConfig.h"

#include "UDebug.h"
#include "UConstantNames.h"

#include "CDriverSubsystems.h"
#include "CInterfaceImp.h"
#include "CMemoryLocker.h"
#include "CPGPdiskHandler.h"
#include "CVolume.h"
#include "SMappedMemory.h"

_USING_PGP

// Macros

#define DISPATCH_COMMAND(type, data, func)						\
	{															\
		type	*pObject	= reinterpret_cast<type *>(data);	\
																\
		SMappedMemory<type>	lmObject(pObject);					\
		error = lmObject.Status();								\
																\
		if (error.IsntError())									\
			error = func(lmObject.MappedAddress());				\
	}


// Class CInterfaceImp member functions

void 
CInterfaceImp::ProcessPacket(DriverAPI::CCommandHeader *pPacket) const
{
	pgpAssertAddrValid(pPacket, DriverAPI::CCommandHeader);

	CComboError	error;

	UDebug::DebugOut("Received a %s driver command.", 
		UConstantNames::NameDriverCommand(pPacket->Command()));

	switch (pPacket->Command())
	{
	case DriverAPI::kNoOpCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandNoOp, pPacket, 
			ProcessNoOp);
		break;

	case DriverAPI::kQueryVersionCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandQueryVersion, pPacket, 
			ProcessQueryVersion);
		break;

	case DriverAPI::kQueryMountedCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandQueryMounted, pPacket, 
			ProcessQueryMounted);
		break;

	case DriverAPI::kQueryAllMountedCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandQueryAllMounted, pPacket, 
			ProcessQueryAllMounted);
		break;

	case DriverAPI::kNotifyUserLogoffCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandNotifyUserLogoff, pPacket, 
			ProcessNotifyUserLogoff);
		break;
	
	case DriverAPI::kSetTimeoutCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandSetTimeout, pPacket, 
			ProcessSetTimeout);
		break;

	case DriverAPI::kAreDisksTimedOutCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandAreDisksTimedOut, pPacket, 
			ProcessAreDisksTimedOut);
		break;
	
	case DriverAPI::kResetTimedOutCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandResetTimedOut, pPacket, 
			ProcessResetTimedOut);
		break;

	case DriverAPI::kMountCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandMount, pPacket, 
			ProcessMount);
		break;

	case DriverAPI::kUnmountCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandUnmount, pPacket, 
			ProcessUnmount);
		break;

	case DriverAPI::kLockVolumeCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandLockVolume, pPacket, 
			ProcessLockVolume);
		break;

	case DriverAPI::kUnlockVolumeCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandUnlockVolume, pPacket, 
			ProcessUnlockVolume);
		break;

	case DriverAPI::kIOVolumeCmdId:
		DISPATCH_COMMAND(DriverAPI::CCommandIOVolume, pPacket, 
			ProcessIOVolume);
		break;

	default:
		error.pgpErr = kPGPError_BadParams;
		break;
	}

	pPacket->DriverError() = error;
}

// ProcessRawPacket returns TRUE if the given memory represents a valid
// packet and was processed, FALSE otherwise.

PGPBoolean 
CInterfaceImp::ProcessRawPacket(void *pMem, PGPUInt32 sizeMem) const
{
	PGPBoolean	isInvalidPacket	= FALSE;

	DriverAPI::CCommandHeader	*pPacket	= 
		static_cast<DriverAPI::CCommandHeader *>(pMem);

	// Is it of at least the correct size?
	if (sizeMem < sizeof(DriverAPI::CCommandHeader))
		isInvalidPacket = TRUE;

	// If so, make sure at least the header portion is valid memory by
	// locking and unlocking it.

	if (!isInvalidPacket)
	{
		SMappedMemory<DriverAPI::CCommandHeader>	smPacket(pPacket);

		// Was the locking successful?
		if (smPacket.Status().IsError())
			isInvalidPacket = TRUE;
	}

	if (!isInvalidPacket)
	{
		// Is the magic field valid?
		if (pPacket->VerifyMagic().IsError())
			isInvalidPacket = TRUE;

		// We have a valid packet header, process it.
		if (!isInvalidPacket)
			ProcessPacket(pPacket);
	}

	return !isInvalidPacket;
}

CComboError 
CInterfaceImp::ProcessNoOp(DriverAPI::CCommandNoOp *pNoOp) const
{
	pgpAssertAddrValid(pNoOp, DriverAPI::CCommandNoOp);

	CComboError	error;

	return error;
}

CComboError 
CInterfaceImp::ProcessQueryVersion(DriverAPI::CCommandQueryVersion *pQV) const
{
	pgpAssertAddrValid(pQV, DriverAPI::CCommandQueryVersion);

	CComboError	error;
	pQV->DriverApiVersion() = DriverAPI::kVersion;

	return error;
}

CComboError 
CInterfaceImp::ProcessQueryMounted(DriverAPI::CCommandQueryMounted *pQM) const
{
	pgpAssertAddrValid(pQM, DriverAPI::CCommandQueryMounted);

	CComboError	error;

	if (pQM->TrueIfPath())
	{
		pQM->IsMountedPGPdisk() = CDriverSubsystems::PGPdiskHandler().
			IsFileAMountedPGPdisk(pQM->PathOrRoot());
	}
	else
	{
		pQM->IsMountedPGPdisk() = CDriverSubsystems::PGPdiskHandler().
			IsRootAMountedPGPdisk(pQM->PathOrRoot());
	}

	return error;
}

CComboError 
CInterfaceImp::ProcessQueryAllMounted(
	DriverAPI::CCommandQueryAllMounted	*pQAM) const
{
	pgpAssertAddrValid(pQAM, DriverAPI::CCommandQueryAllMounted);

	CComboError	error;

	PGPUInt32	numPGPdisks	= CDriverSubsystems::PGPdiskHandler().
		NumPGPdisks();

	// Create temporary info array.
	PGPdiskInfo	*pInfoArray	= new PGPdiskInfo[numPGPdisks];

	if (IsNull(pInfoArray))
		error.pgpErr = kPGPError_OutOfMemory;

	if (error.IsntError())
	{
		// Retrieve info about all PGPdisks.
		error = CDriverSubsystems::PGPdiskHandler().ExportPGPdiskInfo(
			pInfoArray, numPGPdisks, pQAM->ElemsFilled());

		if (error.IsntError())
		{
			// Store this info in the output array.
			for (PGPUInt32 i = 0; i < numPGPdisks; i++)
			{
				strcpy(pQAM->GetElem(i).path, pInfoArray[i].path);
				strcpy(pQAM->GetElem(i).root, pInfoArray[i].root);
				strcpy(pQAM->GetElem(i).deviceName, pInfoArray[i].deviceName);

				pQAM->GetElem(i).isReadOnly = pInfoArray[i].isReadOnly;
				pQAM->GetElem(i).hasTimedOut = pInfoArray[i].hasTimedOut;
			}
		}

		delete[] pInfoArray;
	}

	return error;
}

CComboError 
CInterfaceImp::ProcessNotifyUserLogoff(
	DriverAPI::CCommandNotifyUserLogoff	*pNUL) const
{
	pgpAssertAddrValid(pNUL, DriverAPI::CCommandNotifyUserLogoff);

	CComboError	error;

	// Keep trying to unmount all PGPdisks till we succeed.
	CDriverSubsystems::PGPdiskHandler().TurnOnUnmountAllMode();

	return error;
}

CComboError 
CInterfaceImp::ProcessSetTimeout(DriverAPI::CCommandSetTimeout *pST) const
{
	pgpAssertAddrValid(pST, DriverAPI::CCommandSetTimeout);

	CComboError	error;

	error = CDriverSubsystems::PGPdiskHandler().SetInactivityTimeout(
		pST->Root(), pST->Seconds());

	return error;
}

CComboError 
CInterfaceImp::ProcessAreDisksTimedOut(
	DriverAPI::CCommandAreDisksTimedOut	*pADTO) const
{
	pgpAssertAddrValid(pADTO, DriverAPI::CCommandAreDisksTimedOut);

	CComboError	error;

	pADTO->AreDisksTimedOut() = CDriverSubsystems::PGPdiskHandler().
		AreDisksTimedOut();

	return error;
}

CComboError 
CInterfaceImp::ProcessResetTimedOut(
	DriverAPI::CCommandResetTimedOut	*pRT) const
{
	pgpAssertAddrValid(pRT, DriverAPI::CCommandResetTimedOut);

	CComboError	error;
	CDriverSubsystems::PGPdiskHandler().ResetTimedOutDisk(pRT->Root());

	return error;
}

CComboError 
CInterfaceImp::ProcessMount(DriverAPI::CCommandMount *pM) const
{
	pgpAssertAddrValid(pM, DriverAPI::CCommandMount);

	CComboError	error;

	// Lock down the exported context memory.
	SMappedMemory<PGPUInt8>	smExportedContext(
		static_cast<const PGPUInt8 *>(pM->ExportedContext()), 
		pM->SizeContext());

	error = smExportedContext.Status();

	if (error.IsntError())
	{
		// Mount the PGPdisk.
		error = CDriverSubsystems::PGPdiskHandler().MountPGPdisk(pM->Path(), 
			pM->Root(), pM->Algorithm(), smExportedContext.MappedAddress(), 
			pM->SizeContext(), pM->FirstDataBlock(), pM->NumDataBlocks(), 
			pM->DeviceName(), pM->IsReadOnly());
	}

	return error;
}

CComboError 
CInterfaceImp::ProcessUnmount(DriverAPI::CCommandUnmount *pU) const
{
	pgpAssertAddrValid(pU, DriverAPI::CCommandUnmount);

	CComboError	error;

	// Unmount the PGPdisk.
	error = CDriverSubsystems::PGPdiskHandler().UnmountPGPdisk(pU->Root(), 
		pU->IsForced());

	return error;
}

CComboError 
CInterfaceImp::ProcessLockVolume(DriverAPI::CCommandLockVolume *pLV) const
{
	pgpAssertAddrValid(pLV, DriverAPI::CCommandLockVolume);

	CComboError	error;
	CVolume		*pVolume	= new CVolume;

	if (IsNull(pVolume))
		error.pgpErr = kPGPError_OutOfMemory;

	if (error.IsntError())
	{
		// Must be a PGPdisk.
		if (!CDriverSubsystems::PGPdiskHandler().IsRootAMountedPGPdisk(
			pLV->Root()))
		{
			error.pgpErr = kPGPError_BadParams;
		}
	}

	if (error.IsntError())
	{
		// Attach volume and lock it.
		error = pVolume->AttachVolume(pLV->Root(), 
			CDriverSubsystems::PGPdiskHandler().GetDiskDevNameByRoot(
				pLV->Root()));

		if (error.IsntError())
		{
			if (pLV->ForFormat())
				error = pVolume->LockForFormat();
			else
				error = pVolume->LockForIO();
		}

		// Volume object itself is handle.
		pLV->Handle() = reinterpret_cast<PGPUInt32>(pVolume);

		if (error.IsError())
			delete pVolume;
	}

	return error;
}

CComboError 
CInterfaceImp::ProcessUnlockVolume(
	DriverAPI::CCommandUnlockVolume	*pULV) const
{
	pgpAssertAddrValid(pULV, DriverAPI::CCommandUnlockVolume);

	CComboError	error;
	CVolume		*pVolume	= reinterpret_cast<CVolume *>(pULV->Handle());

	// Make sure memory is valid by locking and unlocking it.
	{
		SMappedMemory<CVolume>	smVolume(pVolume);

		if (smVolume.Status().IsError())
			error.pgpErr = kPGPError_BadParams;
	}

	if (error.IsntError())
	{
		pVolume->Unlock();
		delete pVolume;
	}

	return error;
}

CComboError 
CInterfaceImp::ProcessIOVolume(DriverAPI::CCommandIOVolume *pIOV) const
{
	pgpAssertAddrValid(pIOV, DriverAPI::CCommandIOVolume);

	CComboError	error;
	CVolume		*pVolume	= reinterpret_cast<CVolume *>(pIOV->Handle());

	// Make sure memory is valid by locking and unlocking it.
	{
		SMappedMemory<CVolume>	smVolume(pVolume);

		if (smVolume.Status().IsError())
			error.pgpErr = kPGPError_BadParams;
	}

	if (error.IsntError())
	{
		// Lock down buffer.
		SMappedMemory<PGPUInt8>	smBuffer(
			static_cast<PGPUInt8 *>(pIOV->Buffer()), 
			pIOV->BlocksLength() * kPGPdiskBlockSize);

		if (smBuffer.Status().IsError())
			error.pgpErr = kPGPError_BadParams;

		// Perform the read/write.
		if (error.IsntError())
		{
			if (pIOV->TrueIfRead())
			{
				error = pVolume->Read(smBuffer.MappedAddress(), 
					pIOV->BlockPos(), pIOV->BlocksLength());
			}
			else
			{
				error = pVolume->Write(smBuffer.MappedAddress(), 
					pIOV->BlockPos(), pIOV->BlocksLength());
			}
		}
	}

	return error;
}