cpgpdiskinterfacecomm.cpp

vc环境下的pgp源码

//////////////////////////////////////////////////////////////////////////////
// CPGPdiskInterfaceComm.cpp
//
// Functions for driver/application communication.
//////////////////////////////////////////////////////////////////////////////

// $Id: CPGPdiskInterfaceComm.cpp,v 1.4 1999/03/31 23:51:07 nryan Exp $

// Copyright (C) 1998 by Network Associates, Inc.
// All rights reserved.

#define	__w64
#include <vdw.h>

#include "Required.h"
#include "Packets.h"
#include "PGPdiskVersion.h"
#include "UtilityFunctions.h"

#include "CPGPdiskInterface.h"
#include "CPGPdiskInterfaceComm.h"
#include "Globals.h"
#include "KernelModeUtils.h"
#include "NtThreadSecurity.h"
#include "PGPdisk.h"


//////////////////////////////
// Packet processing functions
//////////////////////////////

// ProcessMountCallback mounts a PGPdisk in the context of our utility
// thread.

void 
CPGPdiskInterface::ProcessMountCallback(PGPUInt32 refData)
{
	DualErr		derr;
	HANDLE		token;
	PAD_Mount	pMNT;

	pMNT = (PAD_Mount) refData;
	pgpAssertAddrValid(pMNT, AD_Mount);

	// Make copy of security token of calling process.
	if (!IsImpersonationTokenSet())
		derr = SetImpersonationToken(Interface->mCallerProcId);

	if (derr.IsntError())
	{
		// Mount the PGPdisk.
		derr = Interface->MountPGPdisk(pMNT->path, pMNT->pContext, 
			pMNT->drive, pMNT->readOnly);
	}

	(* pMNT->header.pDerr) = derr;
}

// ProcessMount processes a kAD_Mount request.

DualErr 
CPGPdiskInterface::ProcessMount(PAD_Mount pMNT, PGPUInt32 size)
{
	DualErr		derr;
	PGPBoolean	mappedContext, mappedPath, mappedOutDrive;

	mappedContext = mappedPath = mappedOutDrive = FALSE;

	// Check packet size.
	if (size < sizeof(AD_Mount))
		derr = DualErr(kPGDMinorError_InvalidParameter);

	// Check desired drive letter.
	if (derr.IsntError())
	{
		if (!IsLegalDriveNumber(pMNT->drive))
			derr = DualErr(kPGDMinorError_InvalidParameter);
	}

	// Map embedded pointers.
	if (derr.IsntError())
	{
		derr = mUserMemManager.MapUserMem((void **) &pMNT->pContext, 
			sizeof(CipherContext));

		mappedContext = derr.IsntError();
	}

	if (derr.IsntError())
	{
		derr = mUserMemManager.MapUserMem((void **) &pMNT->path, 
			pMNT->sizePath);

		mappedPath = derr.IsntError();
	}

	if (derr.IsntError())
	{
		derr = mUserMemManager.MapUserMem((void **) &pMNT->pDrive, 
			sizeof(PGPUInt8));

		mappedOutDrive = derr.IsntError();
	}

	// Perform the mount.
	if (derr.IsntError())
	{
		// Save process ID of current process.
		mCallerProcId = (PGPUInt32) PsGetCurrentProcessId();

		// Perform the mount.
		derr = mUtilityThread.ScheduleSyncCallback(ProcessMountCallback, 
			(PGPUInt32) pMNT);
	}

	if (derr.IsntError())
	{
		derr = (* pMNT->header.pDerr);
	}

	// Find the drive of the mounted PGPdisk.
	if (derr.IsntError())
	{
		PGPdisk *pPGD = mPGPdisks.FindPGPdisk(pMNT->path);

		pgpAssertAddrValid(pPGD, PGPdisk);
		(* pMNT->pDrive) = pPGD->GetDrive();
	}

	// Unmap embedded pointers.
	if (mappedOutDrive)
	{
		mUserMemManager.UnlockUnmapUserMem((void *) pMNT->pDrive, 
			sizeof(PGPUInt8));
	}

	if (mappedPath)
	{
		mUserMemManager.UnlockUnmapUserMem((void *) pMNT->path, 
			pMNT->sizePath);
	}
	
	if (mappedContext)
	{
		mUserMemManager.UnlockUnmapUserMem((void *) pMNT->pContext, 
			sizeof(CipherContext));
	}

	return derr;
}


// ProcessUnmountCallback unmounts a PGPdisk in the context of our utility
// thread.

void 
CPGPdiskInterface::ProcessUnmountCallback(PGPUInt32 refData)
{
	DualErr		derr;
	PAD_Unmount	pUNMNT;

	pUNMNT = (PAD_Unmount) refData;
	pgpAssertAddrValid(pUNMNT, AD_Unmount);

	derr = Interface->UnmountPGPdisk(pUNMNT->drive, pUNMNT->isThisEmergency);

	(* pUNMNT->header.pDerr) = derr;
}

// ProcessUnmount processes a kAD_Unmount request.

DualErr 
CPGPdiskInterface::ProcessUnmount(PAD_Unmount pUNMNT, PGPUInt32 size)
{
	DualErr derr;

	// Check packet size.
	if (size < sizeof(AD_Unmount))
		derr = DualErr(kPGDMinorError_InvalidParameter);

	// Check drive letter.
	if (derr.IsntError())
	{
		if (!IsLegalDriveNumber(pUNMNT->drive))
			derr = DualErr(kPGDMinorError_InvalidParameter);
	}

	// Perform the unmount.
	if (derr.IsntError())
	{
		derr = mUtilityThread.ScheduleSyncCallback(ProcessUnmountCallback, 
			(PGPUInt32) pUNMNT);
	}

	if (derr.IsntError())
	{
		derr = (* pUNMNT->header.pDerr);
	}

	return derr;
}

// ProcessQueryVersion processes a kAD_QueryVersion request.

DualErr 
CPGPdiskInterface::ProcessQueryVersion(PAD_QueryVersion pQV, PGPUInt32 size)
{
	DualErr		derr;
	PGPBoolean	mappedVerBool	= FALSE;

	// Check packet size.
	if (size < sizeof(AD_QueryVersion))
		derr = DualErr(kPGDMinorError_InvalidParameter);

	// Map embedded pointers.
	if (derr.IsntError())
	{
		derr = mUserMemManager.MapUserMem((void **) &pQV->pDriverVersion, 
			sizeof(PGPUInt32));

		mappedVerBool = derr.IsntError();
	}

	// Perform the query.
	if (derr.IsntError())
	{
		mPGPdiskAppVersion = pQV->appVersion;
		(* pQV->pDriverVersion) = kPGPdiskDriverVersion;
	}

	// Unmap embedded pointers.
	if (mappedVerBool)
	{
		mUserMemManager.UnlockUnmapUserMem((void *) pQV->pDriverVersion, 
			sizeof(PGPUInt32));
	}

	return derr;
}

// ProcessQueryMounted processes a kAD_QueryMounted request.

DualErr 
CPGPdiskInterface::ProcessQueryMounted(PAD_QueryMounted pQM, PGPUInt32 size)
{
	DualErr		derr;
	PGPBoolean	mappedIsDiskBool, mappedPath;

	mappedIsDiskBool = mappedPath = FALSE;

	// Check packet size.
	if (size < sizeof(AD_QueryMounted))
		derr = DualErr(kPGDMinorError_InvalidParameter);

	// Map embedded pointers and check parameters.
	if (derr.IsntError())
	{
		if (pQM->trueIfUsePath)
		{
			derr = mUserMemManager.MapUserMem((void **) &pQM->path, 
				pQM->sizePath);

			mappedPath = derr.IsntError();
		}
		else if (!IsLegalDriveNumber(pQM->drive))
		{
			derr = DualErr(kPGDMinorError_InvalidParameter);
		}
	}

	if (derr.IsntError())
	{
		derr = mUserMemManager.MapUserMem((void **) &pQM->pIsPGPdisk, 
			sizeof(PGPBoolean));

		mappedIsDiskBool = derr.IsntError();
	}

	// Perform the query.
	if (derr.IsntError())
	{
		if (pQM->trueIfUsePath)
		{
			if (IsntNull(Interface->mPGPdisks.FindPGPdisk(pQM->path)))
				(* pQM->pIsPGPdisk) = TRUE;
			else
				(* pQM->pIsPGPdisk) = FALSE;
		}
		else
		{
			if (IsntNull(Interface->mPGPdisks.FindPGPdisk(pQM->drive)))
				(* pQM->pIsPGPdisk) = TRUE;
			else
				(* pQM->pIsPGPdisk) = FALSE;
		}
	}

	// Unmap embedded pointers.
	if (mappedPath)
	{
		mUserMemManager.UnlockUnmapUserMem((void *) pQM->path, pQM->sizePath);
	}

	if (mappedIsDiskBool)
	{
		mUserMemManager.UnlockUnmapUserMem((void *) pQM->pIsPGPdisk, 
			sizeof(PGPBoolean));
	}

	return derr;
}

// ProcessQueryOpenFilesCallback queries about open files on a volume in the
// context of our utility thread.

void 
CPGPdiskInterface::ProcessQueryOpenFilesCallback(PGPUInt32 refData)
{
	DualErr				derr;
	PAD_QueryOpenFiles	pQOF;
	Volume				vol;

	pQOF = (PAD_QueryOpenFiles) refData;
	pgpAssertAddrValid(pQOF, AD_QueryOpenFiles);

	derr = vol.AttachLocalVolume(pQOF->drive);

	if (derr.IsntError())
	{
		(* pQOF->pHasOpenFiles) = vol.HasOpenFiles();
	}

	if (vol.AttachedToLocalVolume())
		vol.DetachLocalVolume();

	(* pQOF->header.pDerr) = derr;
}

// ProcessQueryOpenFiles processes a kAD_QueryOpenFiles request.

DualErr 
CPGPdiskInterface::ProcessQueryOpenFiles(
	PAD_QueryOpenFiles	pQOF, 
 	PGPUInt32			size)
{
	DualErr		derr;
	PGPBoolean	mappedOpenBool	= FALSE;

	// Check packet size.
	if (size < sizeof(AD_QueryOpenFiles))
		derr = DualErr(kPGDMinorError_InvalidParameter);

	// Map embedded pointers.
	if (derr.IsntError())
	{
		derr = mUserMemManager.MapUserMem((void **) &pQOF->pHasOpenFiles, 
			sizeof(PGPBoolean));

		mappedOpenBool = derr.IsntError();
	}

	// Check drive letter.
	if (derr.IsntError())
	{
		if (!IsLegalDriveNumber(pQOF->drive))
			derr = DualErr(kPGDMinorError_InvalidParameter);
	}

	// Perform the query.
	if (derr.IsntError())
	{
		derr = mUtilityThread.ScheduleSyncCallback(
			ProcessQueryOpenFilesCallback, (PGPUInt32) pQOF);
	}

	if (derr.IsntError())
	{
		derr = (* pQOF->header.pDerr);
	}

	// Unmap embedded pointers.
	if (mappedOpenBool)
	{
		mUserMemManager.UnlockUnmapUserMem((void *) pQOF->pHasOpenFiles, 
			sizeof(PGPBoolean));
	}

	return derr;
}

// ProcessChangePrefs processes a DA_ChangePrefs request.

DualErr 
CPGPdiskInterface::ProcessChangePrefs(PAD_ChangePrefs pCP, PGPUInt32 size)
{
	DualErr derr;

	File dude;

	if (dude.Opened())
		dude.Close();

	// Check packet size.
	if (size < sizeof(AD_ChangePrefs))
		derr = DualErr(kPGDMinorError_InvalidParameter);

	// Check params.
	if (derr.IsntError())
	{
		if ((pCP->unmountTimeout == 0) || 
			(pCP->unmountTimeout > kMaxUnmountTimeout))
		{
			derr = DualErr(kPGDMinorError_InvalidParameter);
		}
	}

	// Update preferences.
	if (derr.IsntError())
	{
		mAutoUnmount = pCP->autoUnmount;
		mUnmountTimeout = pCP->unmountTimeout;
	}

	return derr;
}

// ProcessLockUnlockMem processes a DA_LockUnlockMem request.

DualErr 
CPGPdiskInterface::ProcessLockUnlockMem(
	PAD_LockUnlockMem	pLUM, 
 	PGPUInt32			size)
{
	DualErr derr;

	// Check packet size.
	if (size < sizeof(AD_LockUnlockMem))
		derr = DualErr(kPGDMinorError_InvalidParameter);

	// Lock/unlock the user memory.
	if (derr.IsntError())
	{
		if (pLUM->trueForLock)
		{
			derr = Interface->mUserMemManager.LockUserMem(pLUM->pMem, 
				pLUM->nBytes);
		}
		else
		{
			derr = Interface->mUserMemManager.UnlockUnmapUserMem(pLUM->pMem, 
				pLUM->nBytes);
		}
	}

	return derr;
}

// ProcessGetPGPdiskInfo processes a kAD_GetPGPdiskInfo request.

DualErr 
CPGPdiskInterface::ProcessGetPGPdiskInfo(
	PAD_GetPGPdiskInfo	pGPI, 
 	PGPUInt32			size)
{
	DualErr		derr;
	PGPBoolean	mappedArray	= FALSE;
	PGPUInt32	arraySize, i;

	// Check packet size.
	if (size < sizeof(AD_GetPGPdiskInfo))
		derr = DualErr(kPGDMinorError_InvalidParameter);