cpgpdiskhandlerimp.cpp

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

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

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

#include "pgpClassesConfig.h"
#include <string.h>

#include "CString.h"
#include "UString.h"
#include "UTime.h"

#include "pgpClientErrors.h"
#include "CDriverSubsystems.h"
#include "CPGPdisk.h"
#include "CPGPdiskHandlerImp.h"

_USING_PGP

_UNNAMED_BEGIN

// Constants
const char	*kPGPdiskDeviceName	= "PGPdiskVolume";

_UNNAMED_END


// Types

enum CPGPdiskHandlerImp::HandlerTask
{
	kMountTask, 
	kUnmountAllTask, 
	kUnmountTask, 
	kEverySecondTask
};

struct CPGPdiskHandlerImp::TaskInfoHeader
{
	CPGPdiskHandlerImp	*origThis;

	PGPBoolean	trueIfSync;
	CComboError	error;
	HandlerTask	task;
};

struct CPGPdiskHandlerImp::MountTaskInfo
{
	TaskInfoHeader	header;

	const char *path;
	const char *root;
	PGPdiskEncryptionAlgorithm	algorithm;
	const void	*exportedContext;
	PGPUInt32	sizeContext;
	PGPUInt64	firstDataBlock;
	PGPUInt64	numDataBlocks;
	PGPUInt32	procId;
	char		*deviceName;
	PGPBoolean	isReadOnly;
};

struct CPGPdiskHandlerImp::UnmountTaskInfo
{
	TaskInfoHeader	header;

	const char	*root;
	PGPBoolean	isForced;
};

struct CPGPdiskHandlerImp::UnmountAllTaskInfo
{
	TaskInfoHeader	header;
	PGPBoolean		isForced;
};

struct CPGPdiskHandlerImp::EverySecondTaskInfo
{
	TaskInfoHeader	header;
};


// Class CPGPdiskHandlerImp member functions

CPGPdiskHandlerImp::CPGPdiskHandlerImp() : 
	mInUnmountAllMode(FALSE), mWorkerThreadCreated(FALSE)
{
	Status() = mPGPdiskAllocator.Status();

	if (Status().IsntError())
		Status() = mPGPdiskListLock.Status();

	if (Status().IsntError())
		Status() = mTaskThread.Status();

	if (Status().IsntError())
		Status() = mEverySecondTimer.Status();
}

const char * 
CPGPdiskHandlerImp::GetDiskDevNameByPath(const char *path) const
{
	CPGPdisk	*pDisk	= GetPGPdiskByPath(path);

	if (IsNull(pDisk))
		return NULL;

	return pDisk->DeviceName();
}

const char * 
CPGPdiskHandlerImp::GetDiskDevNameByRoot(const char *root) const
{
	CPGPdisk	*pDisk	= GetPGPdiskByRoot(root);

	if (IsNull(pDisk))
		return NULL;

	return pDisk->DeviceName();
}

CComboError 
CPGPdiskHandlerImp::ExportPGPdiskInfo(
	PGPdiskInfo	*pInfoArray, 
	PGPUInt32	numElems, 
	PGPUInt32	&elemsFilled) const
{
	pgpAssertAddrValid(pInfoArray, PGPdiskInfo);

	CComboError	error;;
	mPGPdiskListLock.StartReading();

	if (numElems < NumPGPdisks())
	{
		elemsFilled = NumPGPdisks();	// total number needed
		error.pgpErr = kPGPError_BufferTooSmall;
	}

	if (error.IsntError())
	{
		CPGPdisk	*pDisk	= mPGPdiskList.Head();
		PGPUInt32	i		= 0;

		while (IsntNull(pDisk))
		{
			strcpy(pInfoArray[i].path, pDisk->Path());
			strcpy(pInfoArray[i].root, pDisk->Root());
			strcpy(pInfoArray[i].deviceName, pDisk->DeviceName());

			pInfoArray[i].isReadOnly = pDisk->IsReadOnly();
			pInfoArray[i].hasTimedOut = pDisk->HasInactivityTimedOut();

			i++;
			pDisk = mPGPdiskList.Next(pDisk);
		}

		elemsFilled = i;
	}

	mPGPdiskListLock.StopReading();
	
	return error;
}

CComboError 
CPGPdiskHandlerImp::SetInactivityTimeout(const char *root, PGPUInt32 seconds)
{
	pgpAssertStrValid(root);

	CComboError	error;

	if (seconds > kPGPdiskMaxMinutesTimeout * 60)
		seconds = kPGPdiskMaxMinutesTimeout * 60;

	CPGPdisk	*pDisk	= GetPGPdiskByRoot(root);

	if (IsNull(pDisk))
		error.pgpErr = kPGPError_ItemNotFound;

	if (error.IsntError())
		error = pDisk->SetInactivityTimeout(seconds);

	return error;
}

PGPBoolean 
CPGPdiskHandlerImp::AreDisksTimedOut()
{
	PGPBoolean	areTimedOut	= FALSE;

	mPGPdiskListLock.StartReading();
	CPGPdisk	*pDisk	= mPGPdiskList.Head();

	while (IsntNull(pDisk))
	{
		if (pDisk->HasInactivityTimedOut())
			areTimedOut = TRUE;

		pDisk = mPGPdiskList.Next(pDisk);
	}

	mPGPdiskListLock.StopReading();

	return areTimedOut;
}

void 
CPGPdiskHandlerImp::ResetTimedOutDisk(const char *root)
{
	pgpAssertStrValid(root);

	CPGPdisk	*pDisk	= GetPGPdiskByRoot(root);
	pDisk->ResetTimedOut();
}

CComboError 
CPGPdiskHandlerImp::MountPGPdisk(
	const char *path, 
	const char *root, 
	PGPdiskEncryptionAlgorithm	algorithm, 
	const void	*exportedContext, 
	PGPUInt32	sizeContext, 
	PGPUInt64	firstDataBlock, 
	PGPUInt64	numDataBlocks, 
	char		*deviceName, 
	PGPBoolean	readOnly)
{
	pgpAssertStrValid(path);
	pgpAssertStrValid(root);
	pgpAssertAddrValid(exportedContext, VoidAlign);

	CComboError	error;

	// Execute this command in thread context.
	MountTaskInfo	MTI;

	MTI.path			= path;
	MTI.root			= root;
	MTI.algorithm		= algorithm;
	MTI.exportedContext	= exportedContext;
	MTI.sizeContext		= sizeContext;
	MTI.firstDataBlock	= firstDataBlock;
	MTI.numDataBlocks	= numDataBlocks;
	MTI.procId			= GetPlatformProcessId();
	MTI.deviceName		= deviceName;
	MTI.isReadOnly		= readOnly;

	error = PerformPGPdiskTask(&MTI.header, kMountTask);

	return error;
}

CComboError 
CPGPdiskHandlerImp::UnmountPGPdisk(const char *root, PGPBoolean isForced)
{
	pgpAssertStrValid(root);

	CComboError	error;

	// Execute this command in thread context.
	UnmountTaskInfo	UTI;

	UTI.root = root;
	UTI.isForced = isForced;

	error = PerformPGPdiskTask(&UTI.header, kUnmountTask);

	return error;
}

CComboError 
CPGPdiskHandlerImp::UnmountAllPGPdisks(PGPBoolean isForced)
{
	CComboError	error;

	// Execute this command in thread context.
	UnmountAllTaskInfo	UATI;
	UATI.isForced = isForced;

	error = PerformPGPdiskTask(&UATI.header, kUnmountAllTask);

	return error;
}

void 
CPGPdiskHandlerImp::Shutdown()
{
	if (mWorkerThreadCreated)
	{
		UnmountAllPGPdisks(TRUE);
		DestroyWorkerThread();
	}
}

CComboError 
CPGPdiskHandlerImp::Startup()
{
	// Can't create thread and timer during boot because 98 barfs.
	return CComboError();
}

CComboError 
CPGPdiskHandlerImp::CreateWorkerThread()
{
	pgpAssert(!mWorkerThreadCreated);

	CComboError	error;
	error = mTaskThread.StartThread(MaxQueuedTasks);

	if (error.IsntError())
	{
		mWorkerThreadCreated = TRUE;

		error = mEverySecondTimer.StartTimer(EverySecondTimerCallback, this, 
			1000);

		if (error.IsError())
		{
			mTaskThread.KillThread();
			mWorkerThreadCreated = FALSE;
		}
	}

	return error;
}

void 
CPGPdiskHandlerImp::DestroyWorkerThread()
{
	pgpAssert(mWorkerThreadCreated);

	mEverySecondTimer.StopTimer();
	mTaskThread.KillThread();

	mWorkerThreadCreated = FALSE;
}

CComboError 
CPGPdiskHandlerImp::ConstructDeviceName(CString& deviceName) const
{
	CComboError	error;
	PGPBoolean	foundSpace	= FALSE;

	for (PGPUInt32 i = 1; i <= kPGPdiskMaxMountedDisks; i++)
	{
		error = deviceName.Format("%s%d", kPGPdiskDeviceName, i);

		if (error.IsntError())
			foundSpace = IsNull(GetPGPdiskByDeviceName(deviceName));

		if (foundSpace || error.IsError())
			break;
	}

	if (error.IsntError())
	{
		if (!foundSpace)
			error.pgpErr = kPGPClientError_MaxDisksMounted;
	}

	return error;
}

CPGPdisk * 
CPGPdiskHandlerImp::GetPGPdiskByPath(const char *path) const
{
	pgpAssertStrValid(path);

	mPGPdiskListLock.StartReading();
	CPGPdisk	*pDisk	= mPGPdiskList.Head();

	while (IsntNull(pDisk))
	{
		CString	cpath(path);

		if (cpath.Status().IsntError())
		{
			if (cpath.CompareNoCase(pDisk->Path()))
				break;
		}

		pDisk = mPGPdiskList.Next(pDisk);
	}

	mPGPdiskListLock.StopReading();

	return pDisk;
}

CPGPdisk *  
CPGPdiskHandlerImp::GetPGPdiskByRoot(const char *root) const
{
	pgpAssertStrValid(root);

	mPGPdiskListLock.StartReading();
	CPGPdisk	*pDisk	= mPGPdiskList.Head();

	while (IsntNull(pDisk))
	{
		CString	croot(root);

		if (croot.Status().IsntError())
		{
			if (croot.CompareNoCase(pDisk->Root()))
				break;
		}

		pDisk = mPGPdiskList.Next(pDisk);
	}