pgpmemlock.c

vc环境下的pgp源码

	g_pLockedList = pmli;

	return TRUE;
}


//----------------------------------------------------|
//  remove the specified memory block from list of locked blocks
//

BOOL
PGPmlRemoveBlockFromList (
	PDIOCPARAMETERS p,
	ULONG			ulPage,
	ULONG			ulNumPages)
{
	HANDLE			hProc		= NULL;
	DWORD			dwHandle	= NULL;
	PPGPMEMLOCKITEM	pmli		= NULL;
	PPGPMEMLOCKITEM	pPrev		= NULL;

	// get process handle of current process
	VxDCall (VWIN32_GetCurrentProcessHandle)
	_asm mov hProc, eax

	// get handle as used by calling app
	dwHandle = p->hDevice;

	// search list for specified block
	pPrev = NULL;
	pmli = g_pLockedList;
	while (pmli) 
	{
		if ((pmli->hProcess == hProc) &&
			(pmli->dwHandle == dwHandle))
		{
			if ((pmli->ulPage == ulPage)  && 
				(pmli->ulNumPages == ulNumPages))
			{
				if (pPrev)
				{
					pPrev->next = pmli->next;
				}
				else 
				{
					g_pLockedList = pmli->next;
				}
				PGPmlWipeBlock (ulPage, ulNumPages);
				PGPmlFreeItem (pmli);
				return TRUE;
			}
		}
		pPrev = pmli;
		pmli = pmli->next;
	}

	// didn't find specified block, return error
	return FALSE;
}


//----------------------------------------------------|
//  unlock and remove the memory blocks belonging to this handle
//

BOOL
PGPmlUnlockHandleBlocks (PDIOCPARAMETERS p)
{
	HANDLE			hProc		= NULL;
	DWORD			dwHandle	= NULL;
	PPGPMEMLOCKITEM	pmli		= NULL;
	PPGPMEMLOCKITEM	pPrev		= NULL;
	PPGPMEMLOCKITEM	pNext		= NULL;

	// get process handle of current process
	VxDCall (VWIN32_GetCurrentProcessHandle)
	_asm mov hProc, eax

	// get handle as used by calling app
	dwHandle = p->hDevice;

	// search list for block belonging to this process
	pPrev = NULL;
	pmli = g_pLockedList;
	while (pmli) 
	{
		if ((pmli->hProcess == hProc) &&
			(pmli->dwHandle == dwHandle))
		{
			if (pPrev)
			{
				pPrev->next = pmli->next;
			}
			else 
			{
				g_pLockedList = pmli->next;
			}
			pNext = pmli->next;
			PGPmlWipeBlock (pmli->ulPage, pmli->ulNumPages);
			_LinPageUnLock (pmli->ulPage, pmli->ulNumPages, 0);
			PGPmlFreeItem (pmli);
			pmli = pNext;
		}
		else 
		{
			pPrev = pmli;
			pmli = pmli->next;
		}
	}

	return TRUE;
}


//----------------------------------------------------|
//  unlock and remove all blocks in the list
//

BOOL
PGPmlUnlockAllBlocks ()
{
	PPGPMEMLOCKITEM	pmli	= NULL;
	PPGPMEMLOCKITEM	pNext	= NULL;

	pmli = g_pLockedList;
	while (pmli) 
	{
		pNext = pmli->next;
		PGPmlWipeBlock (pmli->ulPage, pmli->ulNumPages);
		_LinPageUnLock (pmli->ulPage, pmli->ulNumPages, 0);
		PGPmlFreeItem (pmli);
		pmli = pNext;
	}

	g_pLockedList = NULL;

	return TRUE;
}


//----------------------------------------------------|
//  lock the page(s) specified by structure

DWORD 
PGPmlLockPage (PDIOCPARAMETERS p) 
{
	PPGPMEMLOCKSTRUCT	pplsIn		= (PPGPMEMLOCKSTRUCT)(p->lpvInBuffer);
	PPGPMEMLOCKSTRUCT	pplsOut		= (PPGPMEMLOCKSTRUCT)(p->lpvOutBuffer);
	ULONG				ulPage		= 0;
	ULONG				ulNumPages	= 0;
	ULONG				ulError		= 0;

	PGPmlPrintf (("PGPmemlock: LockPage.\n"));

	// check buffer pointers
	if ((!pplsIn) || (!pplsOut))
	{
		return ERROR_INVALID_PARAMETER;
	}

	// check buffer lengths
	if ((p->cbInBuffer < sizeof(PGPMEMLOCKSTRUCT)) ||
		(p->cbOutBuffer < sizeof(PGPMEMLOCKSTRUCT)))
	{
		return ERROR_INVALID_PARAMETER;
	}

	// assume no error
	pplsOut->pMem = pplsIn->pMem;
	pplsOut->ulNumBytes = pplsIn->ulNumBytes;
	pplsOut->ulError = 0;

	// calculate page numbers
	ulPage = ((ULONG)(pplsIn->pMem)) >> WIN32PAGESIZE;
	ulNumPages = (((pplsIn->ulNumBytes)-1) >> WIN32PAGESIZE ) +1;
	PGPmlPrintf (("PGPmemlock: locking page(s) %x - %x.\n", 
					ulPage, ulPage+ulNumPages-1));

	// add the block to the list of locked pages
	if (PGPmlAddBlockToList (p, ulPage, ulNumPages))
	{
		// actually lock the page(s)
		ulError = _LinPageLock (ulPage, ulNumPages, 0);
		if (ulError == 0)	// error
		{
			PGPmlPrintf (("PGPmemlock: Err: _LinPageLock error.\n"));
			pplsOut->ulError = kPGPMemLockError_LockError;
			PGPmlRemoveBlockFromList (p, ulPage, ulNumPages);
		}
		else 
		{
			PGPmlPrintf (("PGPmemlock: successfully locked memory.\n"));
		}
	}
	else 
	{
		PGPmlPrintf (("PGPmemlock: Err: PGPmlAddBlockToList error.\n"));
		pplsOut->ulError = kPGPMemLockError_ListError;
	}

	return 0;
}   


//----------------------------------------------------|
//  unlock the page(s) specified by structure

DWORD 
PGPmlUnlockPage (PDIOCPARAMETERS p) 
{
	PPGPMEMLOCKSTRUCT	pplsIn		= (PPGPMEMLOCKSTRUCT)(p->lpvInBuffer);
	PPGPMEMLOCKSTRUCT	pplsOut		= (PPGPMEMLOCKSTRUCT)(p->lpvOutBuffer);
	ULONG				ulPage;
	ULONG				ulNumPages;
	ULONG				ulError;

	PGPmlPrintf (("PGPmemlock: UnlockPage.\n"));

	// check buffer pointers
	if ((!pplsIn) || (!pplsOut))
	{
		return ERROR_INVALID_PARAMETER;
	}

	// check buffer lengths
	if ((p->cbInBuffer < sizeof(PGPMEMLOCKSTRUCT)) ||
		(p->cbOutBuffer < sizeof(PGPMEMLOCKSTRUCT)))
	{
		return ERROR_INVALID_PARAMETER;
	}

	// assume no error
	pplsOut->pMem = pplsIn->pMem;
	pplsOut->ulNumBytes = pplsIn->ulNumBytes;
	pplsOut->ulError = 0;

	// calculate page numbers
	ulPage = ((ULONG)(pplsIn->pMem)) >> WIN32PAGESIZE;
	ulNumPages = (((pplsIn->ulNumBytes)-1) >> WIN32PAGESIZE ) +1;
	PGPmlPrintf (("PGPmemlock: unlocking page(s) %x - %x.\n", 
					ulPage, ulPage+ulNumPages-1));

	// remove the pages from the list of locked pages
	if (PGPmlRemoveBlockFromList (p, ulPage, ulNumPages))
	{
		// actually unlock the page(s)
		ulError = _LinPageUnLock (ulPage, ulNumPages, 0);
		if (ulError == 0)		// error
		{
			PGPmlPrintf (("PGPmemlock: Err: _LinPageUnLock error.\n"));
			pplsOut->ulError = kPGPMemLockError_UnlockError;
		}
		else 
		{
			PGPmlPrintf (("PGPmemlock: successfully unlocked memory.\n"));
		}
	}
	else 
	{
		PGPmlPrintf (("PGPmemlock: Err: PGPmlRemoveBlockFromList error.\n"));
		pplsOut->ulError = kPGPMemLockError_ListError;
	}

	return 0; 
}   


//----------------------------------------------------|
//  called upon initialization of VxD

BOOL 
OnSysDynamicDeviceInit () 
{ 
	PGPmlPrintf (("PGPmemlock: OnSysDynamicDeviceInit.\n"));

	// initialize critical section mutex
	g_mutexHeap = 
		_CreateMutex (CRITICAL_SECTION_BOOST, MUTEX_MUST_COMPLETE);
	if (g_mutexHeap == NULL)
		return FALSE;	// failure

	// initialize heap
	PGPmlEnterCriticalSection ();
	g_pLockedList = NULL;
	PGPmlHeapInit ();
	PGPmlLeaveCriticalSection ();

	return TRUE;    	// success
}


//----------------------------------------------------|
//  called upon shutdown of VxD

BOOL 
OnSysDynamicDeviceExit () 
{

	PGPmlPrintf (("PGPmemlock: OnSysDynamicDeviceExit.\n"));

	PGPmlEnterCriticalSection ();
	PGPmlUnlockAllBlocks ();
	PGPmlHeapDestroy ();
	PGPmlLeaveCriticalSection ();

	_DestroyMutex (g_mutexHeap);

    return TRUE;    // success
}   


//----------------------------------------------------|
//  called upon as result of call to DeviceIoControl

DWORD 
OnDeviceIoControl (PDIOCPARAMETERS p) 
{
	DWORD	dwReturn;

    switch (p->dwIoControlCode) {
    case DIOC_GETVERSION :
        dwReturn = 0;	// no error
		break;

	case IOCTL_PGPMEMLOCK_LOCK_MEMORY :
		PGPmlEnterCriticalSection ();
		dwReturn = PGPmlLockPage (p);
		PGPmlLeaveCriticalSection ();
		break;

	case IOCTL_PGPMEMLOCK_UNLOCK_MEMORY :
		PGPmlEnterCriticalSection ();
		dwReturn = PGPmlUnlockPage (p);
		PGPmlLeaveCriticalSection ();
		break;

	case DIOC_CLOSEHANDLE :
		PGPmlPrintf (("PGPmemlock: DIOC_CLOSEHANDLE.\n"));
		PGPmlEnterCriticalSection ();
		PGPmlUnlockHandleBlocks (p);
		PGPmlLeaveCriticalSection ();
		dwReturn = 0;	// no error
		break;

    default :
		PGPmlPrintf (("PGPmemlock: Err: unknown IoControlCode: %X.\n",
						p->dwIoControlCode));
		dwReturn = ERROR_BAD_COMMAND;
    }

	return dwReturn;
}