Driver Develop

Development Platform:
Visual C++

common.c：Code Content
							/*===================================================================
 * Filename common.c
 * 
 * Author: kcrazy
 * Email:  thekcrazy@gmail.com
 *
 * Description: 通用模块,一些公用的函数在这里定义
 *
 * Date:   2007-3-12 Original from kcrazy
 *         
 * Version: 1.0
 ==================================================================*/
#include "common.h"
ULONG	AllCPURaised;
ULONG	NumberOfRaisedCPU;
/*========================================================================
*
* 函数名:	IoGetAttachedDevice
*
* 参数:		PDEVICE_OBJECT		[IN]	DeviceObject
*
* 功能描述:	来自ReactOS
*
* 返回值:	PDEVICE_OBJECT
*
=========================================================================*/
PDEVICE_OBJECT
STDCALL
IoGetAttachedDevice( PDEVICE_OBJECT DeviceObject )
{
    PDEVICE_OBJECT Current = DeviceObject;
    /* Get the last attached device */
    while (Current->AttachedDevice)
    {
        Current = Current->AttachedDevice;
    }
    /* Return it */
    return Current;
}
/*========================================================================
*
* 函数名:	MyISIoCallDriver
*
* 参数:		PDEVICE_OBJECT		[IN]	DeviceObject
*			PIRP				[IN]	Irp
*
* 功能描述:	自己实现的IoCallDriver
*
* 返回值:	NTSTATUS
*
=========================================================================*/
NTSTATUS FASTCALL
MyISIoCallDriver( PDEVICE_OBJECT DeviceObject,
          PIRP Irp )
{
	PDRIVER_OBJECT		DriverObject;
	PIO_STACK_LOCATION	Param;
	if ( Irp == NULL )
	{
		return STATUS_UNSUCCESSFUL;
	}
	if ( DeviceObject == NULL )
	{
		return STATUS_UNSUCCESSFUL;
	}
	DriverObject = DeviceObject->DriverObject;
	if( DriverObject == NULL )
	{
		return STATUS_UNSUCCESSFUL; 
	}
	IoSetNextIrpStackLocation(Irp);
	Param = IoGetCurrentIrpStackLocation(Irp);
	Param->DeviceObject = DeviceObject;
	return DriverObject->MajorFunction[Param->MajorFunction](DeviceObject, Irp);
}
/*========================================================================
*
* 函数名:	MyISCreateFile
*
* 参数:		PHANDLE		[OUT]	pFileHandle
*			LPCWSTR		[IN]	FileName
*			ACCESS_MASK	[IN]	DesiredAccess
*			ULONG		[IN]	ShareAccess
*
* 功能描述:	打开文件
*
* 返回值:	NTSTATUS
*
=========================================================================*/
NTSTATUS
MyISCreateFile(
	PHANDLE	pFileHandle,
	LPCWSTR FileName,
	ACCESS_MASK DesiredAccess,
	ULONG ShareAccess
	)
{
	NTSTATUS			Status;
	UNICODE_STRING		uniFileName;
	OBJECT_ATTRIBUTES	objectAttributes;
	IO_STATUS_BLOCK     ioStatus;
	if (KeGetCurrentIrql() > PASSIVE_LEVEL)
    {
        return STATUS_UNSUCCESSFUL;
    }
	RtlInitUnicodeString( &uniFileName, FileName );
	InitializeObjectAttributes(&objectAttributes, &uniFileName,
        OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
	Status = IoCreateFile(
				pFileHandle,
				DesiredAccess | SYNCHRONIZE,
				&objectAttributes,
				&ioStatus,
				0,
				FILE_READ_ATTRIBUTES,
				ShareAccess,
				FILE_OPEN,
				FILE_SYNCHRONOUS_IO_NONALERT,
				NULL,
				0,
				0,
				NULL,
				IO_NO_PARAMETER_CHECKING
				);
	return Status;
}
/*========================================================================
*
* 函数名:	GetInfoTable
*
* 参数:		SYSTEM_INFORMATION_CLASS		[IN]	SystemInformationClass
*
* 功能描述:	QuerySystemInformation
*
* 返回值:	PVOID
*
=========================================================================*/
PVOID GetInfoTable( SYSTEM_INFORMATION_CLASS SystemInformationClass )
{
	ULONG		mSize;
	PVOID		mPtr;
	NTSTATUS	Status;
	mSize = 0x4000;
	mPtr = NULL;
	do
	{
		mPtr = ExAllocatePool( PagedPool, mSize );
		memset( mPtr, 0, mSize );
		if ( mPtr != NULL )
		{
			Status = ZwQuerySystemInformation( SystemInformationClass, mPtr, mSize, NULL );
		}
		else
		{
			return NULL;
		}
		if ( Status == STATUS_INFO_LENGTH_MISMATCH )
		{
			ExFreePool( mPtr );
			mSize = mSize * 2;
		}
	} while ( Status == STATUS_INFO_LENGTH_MISMATCH );
	if (Status == STATUS_SUCCESS)
	{
		return mPtr;
	}
	ExFreePool( mPtr );
	return NULL;
}
/*========================================================================
*
* 函数名:	GetModuleBase
*
* 参数:		LPCSTR	[IN]	ModuleFileName
*
* 功能描述:	获取模块基地址
*
* 返回值:	PVOID
*
=========================================================================*/
PVOID
GetModuleBase(
    LPCSTR ModuleFileName
    )
{
	PMODULES					pMod;
	ULONG						NumberOfModules;
	ULONG						index;
	PSYSTEM_MODULE_INFORMATION	psmi;
	LPSTR						pStr;
	PVOID						Base;
	Base = NULL;
	pMod = (PMODULES)GetInfoTable( SystemModuleInformation );
	if ( pMod == NULL )
	{
		return NULL;
	}
	NumberOfModules = pMod->dwNumberOfModules;
	psmi = &pMod->smi;
	for ( index = 0; index < NumberOfModules; index++ )
	{
		pStr = strrchr( psmi->ImageName, '\' );
		if ( pStr != NULL )
		{
			pStr++;
		}
		else
		{
			pStr = psmi->ImageName;
		}
		if ( _stricmp( pStr, ModuleFileName ) == 0 )
		{
			Base = psmi->Base;
			
			break;
		}
		psmi++;
	}
	ExFreePool( pMod );
	return Base;
}
/*========================================================================
*
* 函数名:	MyISPrintDevObj
*
* 参数:		PVOID	[IN]	pDeviceObj
*
* 功能描述:	打印设备对象信息
*
* 返回值:	VOID
*
=========================================================================*/
VOID
MyISPrintDevObj( PVOID pDeviceObj )
{
	PDEVICE_OBJECT	pDevObj;
	PUNICODE_STRING	DriName;
	PUNICODE_STRING	DevName;
	CHAR			Name[128] = {0};
	CHAR			DName[128] = {0};
	pDevObj = pDeviceObj;
	while ( pDevObj->AttachedDevice != NULL )
	{
		pDevObj = pDevObj->AttachedDevice;
	}
	DbgPrint( "*********************************************" );
	DbgPrint( "*   !DevObjtt!DrvObjttttttttt!DevExtttObjectName" );
	while( 1 )
	{
		memset( Name, 0, 128 );
		memset( DName, 0, 128 );
		if ( MyISGetObjName( pDevObj->DriverObject, DName, 128 ) )
		{
			if ( pDeviceObj == pDevObj )
			{
				if ( MyISGetObjName( pDevObj, Name, 128 ) )
				{
					DbgPrint( "* ->%08xt%st%08xt%s", pDevObj, DName, pDevObj->DeviceExtension, Name );
				}
				else
				{
					DbgPrint( "* ->%08xt%st%08x", pDevObj, DName, pDevObj->DeviceExtension );
				}
			}
			else
			{
				if ( MyISGetObjName( pDevObj, Name, 128 ) )
				{
					DbgPrint( "*   %08xt%st%08xt%s", pDevObj, DName, pDevObj->DeviceExtension, Name );
				}
				else
				{
					DbgPrint( "*   %08xt%st%08x", pDevObj, DName, pDevObj->DeviceExtension );
				}
			}
		}
		if ( (*(PULONG)((ULONG)(pDevObj->DeviceObjectExtension) + 0x18)) == 0 )
		{
			break;
		}
		pDevObj = (PDEVICE_OBJECT)(*(PULONG)((ULONG)(pDevObj->DeviceObjectExtension) + 0x18));
		
	}
	DbgPrint( "*********************************************" );
}
/*========================================================================
*
* 函数名:	MyISGetObjName
*
* 参数:		PVOID	[IN]	pObj
*			PVOID	[IN]	Name
*			ULONG	[IN]	Size
*
* 功能描述:	根据对象获取对象名称
*
* 返回值:	BOOLEAN
*
=========================================================================*/
BOOLEAN
MyISGetObjName( PVOID pObj, PVOID Name, ULONG Size )
{
	POBJECT_HEADER				pObjHeader;
	POBJECT_HEADER_NAME_INFO	pObjNameInfo;
	ANSI_STRING					AnsiString;
	CHAR						Temp[64] = {0};
	CHAR						Temp2[64] = {0};
	pObjHeader = (POBJECT_HEADER)((ULONG)pObj - sizeof(OBJECT_HEADER));
	if ( pObjHeader->NameInfoOffset != 0 )
	{
		pObjNameInfo = (POBJECT_HEADER_NAME_INFO)((ULONG)pObjHeader - pObjHeader->NameInfoOffset);
		RtlUnicodeStringToAnsiString( &AnsiString, &pObjNameInfo->Name, TRUE );
		if ( AnsiString.Length >= 64 )
		{
			DbgPrint( "$MyIS:tAnsiString.Length >= 64" );
			return FALSE;
		}
		memcpy( Temp2, AnsiString.Buffer, AnsiString.Length );
		
		if ( pObjNameInfo->Directory != 0 )
		{
			if ( !MyISGetObjName( (PVOID)pObjNameInfo->Directory, Temp, 128 ) )
			{
				DbgPrint( "$MyIS:tMyISGetObjName() False" );
				return FALSE;
			}
			if ( strcmp( Temp, "\" ) == 0 )
			{
				if ( strlen(Temp) + strlen(Temp2) >= Size )
				{
					DbgPrint( "$MyIS:tstrlen(Temp) + strlen(Temp2) >= Size" );
					return FALSE;
				}
				strcat( Temp, Temp2 );
				strcpy( Name, Temp );
			}
			else
			{
				if ( strlen(Temp) + strlen(Temp2) + 1 >= Size )
				{
					DbgPrint( "$MyIS:tstrlen(Temp) + strlen(Temp2) + 1 >= Size" );
					return FALSE;
				}
				strcat( Temp, "\" );
				strcat( Temp, Temp2 );
				strcpy( Name, Temp );
			}
		}
		else
		{
			if ( strlen(Temp2) >= Size )
			{
				DbgPrint( "$MyIS:tstrlen(Temp2) >= Size" );
				return FALSE;
			}
			strcpy( Name, Temp2 ); 
		}
		RtlFreeAnsiString( &AnsiString );
		return TRUE;
	}
	return FALSE;
}
/*========================================================================
*
* 函数名:	MyISReferenceObject
*
* 参数:		PVOID	[IN]	Object
*
* 功能描述:	增加对象引用计数
*
* 返回值:	BOOLEAN
*
=========================================================================*/
BOOLEAN
MyISReferenceObject( PVOID Object )
{
    POBJECT_HEADER	ObjectHeader;
    ObjectHeader = (POBJECT_HEADER)((ULONG)Object - sizeof(OBJECT_HEADER));
	if (ObjectHeader->PointerCount == 0)
	{
		return FALSE;
	}
	InterlockedIncrement( &ObjectHeader->PointerCount );
	return TRUE;
}
/*========================================================================
*
* 函数名:	MyISDisableWriteProtect
*
* 参数:
*
* 功能描述:	禁止写保护
*
* 返回值:	VOID
*
=========================================================================*/
VOID
MyISDisableWriteProtect( VOID )
{
    __asm
    {
        push    eax
        mov     eax, cr0
        and     eax, 0FFFEFFFFh
        mov     cr0, eax
        pop     eax
        cli
    }
}
/*========================================================================
*
* 函数名:	MyISEnableWriteProtect
*
* 参数:
*
* 功能描述:	允许写保护
*
* 返回值:	VOID
*
=========================================================================*/
VOID
MyISEnableWriteProtect( VOID )
{
    __asm
    {
        sti
        push    eax
        mov     eax, cr0
		or      eax, 10000h
        mov     cr0, eax
        pop     eax
    }
}
LPWSTR
FullPathToFileName( LPWSTR FullPath, ULONG Length )
{
	LPWSTR	p;
	p = FullPath + Length - 1;
	while (p != FullPath)
	{
		if (*p == L'\')
		{
			p++;
			break;
		}
		p--;
	}
	return p;
}
PKDPC GainExclusivity( VOID )
{
	ULONG		u_currentCPU;
	UCHAR		i;
	PKDPC		pkdpc;
	PKDPC		temp_pkdpc;
	if (KeGetCurrentIrql() != DISPATCH_LEVEL)
	{
		return NULL;
	}
	__asm lock and AllCPURaised, 0
	__asm lock and NumberOfRaisedCPU, 0
	//InterlockedAnd( &AllCPURaised, 0 );
	//InterlockedAnd( &NumberOfRaisedCPU, 0 );
	temp_pkdpc = (PKDPC)ExAllocatePool( NonPagedPool,
										*KeNumberProcessors * sizeof(KDPC)
										);
	if (temp_pkdpc == NULL)
	{
		return NULL;
	}
	u_currentCPU = KeGetCurrentProcessorNumber();
	pkdpc = temp_pkdpc;
	for (i = 0; i < *KeNumberProcessors; i++, *temp_pkdpc++)
	{
		if (i != u_currentCPU)
		{
			KeInitializeDpc( temp_pkdpc,
							RaiseCPUIrqlAndWait,
							NULL );
			KeSetTargetProcessorDpc( temp_pkdpc, i );
			KeInsertQueueDpc( temp_pkdpc, NULL, NULL );
		}
	}
	while (InterlockedCompareExchange( &NumberOfRaisedCPU,
			*KeNumberProcessors - 1, *KeNumberProcessors - 1 ) !=
			*KeNumberProcessors - 1)
	{
		__asm	nop;
	}
	return pkdpc;
}
NTSTATUS ReleaseExclusivity( PVOID pkdpc )
{
	InterlockedIncrement( &AllCPURaised );
	while (InterlockedCompareExchange( &NumberOfRaisedCPU, 0, 0 ))
	{
		__asm nop;
	}
	if (pkdpc != NULL)
	{
		ExFreePool( pkdpc );
		pkdpc = NULL;
	}
	return STATUS_SUCCESS;
}
VOID
RaiseCPUIrqlAndWait( IN PKDPC Dpc,
					IN PVOID DeferredContext,
					IN PVOID SystemArgument1,
					IN PVOID SystemArgument2
					)
{
	InterlockedIncrement( &NumberOfRaisedCPU );
	while (InterlockedCompareExchange( &AllCPURaised, 1, 1 ) == 0)
	{
		__asm	nop;
	}
	InterlockedDecrement( &NumberOfRaisedCPU );
}

						