filteritem.c

利用C++工具进行编程,NDIS的PASSTHRU层的驱动程序,是非常实用的程序.

//FilterItem.c
#include"precomp.h"


/************Variable Declaration(External)****************/
int iFilterFlag=0;//The Filter flag indicate whether has IP to filter.
KSPIN_LOCK FilterLock;
KIRQL FilterIrql;

KSPIN_LOCK FilterItemLock;//The Filter Entry's Spin Lock.
KIRQL FilterItemIrql;

FilterItemCtl pFilterEntry;//The Entry Filter Item.

/**************Function Declaration(Internal)****************/
//Judge whether the filter item match or not.
int FilterMatch(
		FilterItem *pInputSrcFilterItem,
		FilterItem *pInputDestFilterItem
		);

//Seek the match filter item in the FilterEntry.
FilterItem *SeekMatchFilterItem(
		FilterItem *pInputFilterItem,
		FilterItem *pInputFilterEntry
		);

//Remove a list Item from a item entry.
void RemoveEntryItem(
		FilterItem *pInputFilterItemHead
		);

//Judge Match One context.
//And Operate the retValue with current context's result,
//If indicate should return now,return 1;
//else return 0.
int MatchOneContext(						
			OperateType InputOperate,		
			int *InputRetFlag,
			U8 *InputValue,							
			U8 *InputMin,
			U8 *InputMax,					
			int InputCount							
		);


//Judge whether the input data Include in filter item or not.
//If Include,return NoZero;
//Else return Zero.

//Note: the filter only handle Ethernet packet!!!
int JudgeItemInclude(
		SpecialCode		*pInputSpecialCode,
		FilterContext	*pInputFilterContext
	);


//The Internal Function.
//	To Get the Special code from a plat buffer.
//If success ,return 0;
//else return NoZero.
int GetSpecialCode(
		U8				*pInputBuf,
		ULONG			uInputBufLen,
		SpecialCode		*pOutputSpecialCode
	);

/*********************************************/
/***********Function Bodies*******************/
/*********************************************/

/***The Filter Item Operate***/

//Remove a list Item from a item entry.
void RemoveEntryItem(FilterItem *pInputFilterItemHead)
{
	FilterItem *pTempFilterItemSrc, *pTempFilterItemDest;

	pTempFilterItemSrc=pInputFilterItemHead->pNext;
	
	while(pTempFilterItemSrc)
	{
		pTempFilterItemDest=pTempFilterItemSrc->pNext;

		pTempFilterItemSrc->iItemBufferLen=0;
		pTempFilterItemSrc->FilterType=NullFilter;
		pTempFilterItemSrc->pNext=NULL;
		pTempFilterItemSrc->pPre=NULL;

		ExFreePool(pTempFilterItemSrc);
		
		pTempFilterItemSrc=pTempFilterItemDest;
	}
	
	pInputFilterItemHead->pNext=NULL;
	pInputFilterItemHead->pPre=NULL;
	
}

/*External Function.*/
//The Filter module's Init.
//If Success,return Zero,
//Else return NoZero.
int InitFilterItem()
{
	KeAcquireSpinLock(&FilterLock,&FilterIrql);
		
	if(iFilterFlag)
	{//Remove the NoZero Filter Item.
		KeAcquireSpinLock(&FilterItemLock,&FilterItemIrql);
		
		RemoveEntryItem( &(pFilterEntry.RecExcludeQueue) );
		RemoveEntryItem( &(pFilterEntry.RecIncludeQueue) );
		RemoveEntryItem( &(pFilterEntry.SendExcludeQueue) );
		RemoveEntryItem( &(pFilterEntry.SendIncludeQueue) );
		
		KeReleaseSpinLock(&FilterItemLock,FilterItemIrql);

	///////////		
		iFilterFlag=1;

	}else
	{//Initialize.
		KeAcquireSpinLock(&FilterItemLock,&FilterItemIrql);
		
		pFilterEntry.RecExcludeQueue.pNext=NULL;
		pFilterEntry.RecIncludeQueue.pNext=NULL;
		pFilterEntry.SendExcludeQueue.pNext=NULL;
		pFilterEntry.SendIncludeQueue.pNext=NULL;
		
		KeReleaseSpinLock(&FilterItemLock,FilterItemIrql);

	///////////		
		iFilterFlag=1;
	}

	KeReleaseSpinLock(&FilterLock,FilterIrql);

	//Now no return value.only return success.
	return 0;
}

/*External Function.*/
//The Filter module's Free.
//No return value.
void FreeFilterItem(void)
{
	KeAcquireSpinLock(&FilterLock,&FilterIrql);

	if(iFilterFlag)
	{
		KeAcquireSpinLock(&FilterItemLock,&FilterItemIrql);
		
		RemoveEntryItem( &(pFilterEntry.RecExcludeQueue) );
		RemoveEntryItem( &(pFilterEntry.RecIncludeQueue) );
		RemoveEntryItem( &(pFilterEntry.SendExcludeQueue) );
		RemoveEntryItem( &(pFilterEntry.SendIncludeQueue) );

		KeReleaseSpinLock(&FilterItemLock,FilterItemIrql);

	//////////
		iFilterFlag=0;
	}
	
	KeReleaseSpinLock(&FilterLock,FilterIrql);
}

///////////////////////////////////////////////////////////

//Judge whether the filter item match or not.
//If the filter item matched,return 1;
//else return 0.
int FilterMatch(
		FilterItem *pInputSrcFilterItem,
		FilterItem *pInputDestFilterItem
		)
{
	int i;

	U8 *pTempSrc,*pTempDest;

//Note : the filter context locate different position.
	pTempSrc=pInputSrcFilterItem->pItemBuffer;
	pTempDest=(U8 *)GetFilterContext(pInputDestFilterItem);

	if(pInputSrcFilterItem->iItemBufferLen
		== pInputDestFilterItem->iItemBufferLen)
	{
		if(pInputSrcFilterItem->FilterType
			== pInputDestFilterItem->FilterType)
		{
			for(i=0;i<pInputSrcFilterItem->iItemBufferLen;i++)
				if( (*(pTempSrc + i)) != (*(pTempDest +i )) )
						return 0;
			//Match!
			return 1;
		}
	}
	
	return 0;
}

//Seek the match filter item in the FilterEntry.
//If Seeked the match filter item,return the match filter item.
//else return NULL.
FilterItem *SeekMatchFilterItem(
		FilterItem *pInputFilterItem,
		FilterItem *pInputFilterEntry
		)
{
	FilterItem *pTempFilterItem;

	pTempFilterItem=pInputFilterEntry->pNext;

	while(pTempFilterItem)
	{
		if( FilterMatch(pInputFilterItem,pTempFilterItem) )
			return pTempFilterItem;

		pTempFilterItem=pTempFilterItem->pNext;
	}
	
	return NULL;
}


/*External Function.*/
//Add a Filter Item.
void AddFilterItem(
		U32			  uInputBufferLength,
		FilterType	  uInputFilterType,
		PVOID		  pInputBuffer
		)
{
	FilterItem *pTempHeaderFilterItem;
	FilterItem *pTempAddFilterItem;

	FilterType tempFilterDirect;
	FilterType tempFilterOperate;

	FilterContext *pTempFilterContext;

	if(iFilterFlag)
	{
		//Add a Filter Item.
		KeAcquireSpinLock(&FilterItemLock,&FilterItemIrql);
			
		tempFilterDirect=GetFilterTypeDirect(uInputFilterType);
		tempFilterOperate=GetFilterTypeOperate(uInputFilterType);

		pTempFilterContext=(FilterContext *)pInputBuffer;

		while(1)
		{//Use while(1) because when 
		//			tempFilterDirect = FilterReceive | FilterSend.

			if(FilterReceive & tempFilterDirect)
			{
				//Receive Filter.
				if(pTempFilterContext->Include)
					pTempHeaderFilterItem=&(pFilterEntry.RecIncludeQueue);
				else
					pTempHeaderFilterItem=&(pFilterEntry.RecExcludeQueue);
				
				tempFilterDirect = tempFilterDirect & (~FilterReceive);
			}else
			{
				if(FilterSend & tempFilterDirect)
				{
					//Send Filter.
					if(pTempFilterContext->Include)
						pTempHeaderFilterItem=&(pFilterEntry.SendIncludeQueue);
					else
						pTempHeaderFilterItem=&(pFilterEntry.SendExcludeQueue);
					
					tempFilterDirect = tempFilterDirect & (~FilterSend);
				}else
				{
					//exit.No Handle!!
					KeReleaseSpinLock(&FilterItemLock,FilterItemIrql);
					return ;
				}
			}

			//Allocate a new filter item.
			pTempAddFilterItem=ExAllocatePool(
						NonPagedPool,
						uInputBufferLength + 
							sizeof(FilterItem)
					);
			
			pTempAddFilterItem->FilterType=tempFilterOperate;
			pTempAddFilterItem->iItemBufferLen=uInputBufferLength;
			
			pTempAddFilterItem->pItemBuffer=pInputBuffer;
			
			if(	!SeekMatchFilterItem(pTempAddFilterItem,pTempHeaderFilterItem) )
			{//No seeked match filter item.
			//Add the filter item to filter entry.	
				pTempAddFilterItem->pPre=pTempHeaderFilterItem;
				pTempAddFilterItem->pNext=pTempHeaderFilterItem->pNext;
				
				if( pTempHeaderFilterItem->pNext )
					pTempHeaderFilterItem->pNext->pPre=pTempAddFilterItem;
				
				pTempHeaderFilterItem->pNext=pTempAddFilterItem;
				
				//copy the filter context.			
				RtlCopyMemory(	
					GetFilterContext(pTempAddFilterItem),
					pInputBuffer,
					uInputBufferLength
					);

				pTempAddFilterItem->pItemBuffer=
							(U8 *)GetFilterContext(pTempAddFilterItem);
								
			}else
				ExFreePool(pTempAddFilterItem);
			
			KeReleaseSpinLock(&FilterItemLock,FilterItemIrql);

		}
	}
}

/*External Function.*/
//Delete a Filter Item.
void DeleteFilterItem(
		U32 uInputBufferLength,
		FilterType	  uInputFilterType,
		PVOID pInputBuffer
		)
{
	FilterItem *pTempHeaderFilterItem;
	FilterItem *pTempDelFilterItem;
	FilterItem *pTempFilterItem;

	FilterType tempFilterDirect;
	FilterType tempFilterOperate;

	FilterContext *pTempFilterContext;

	if(iFilterFlag)
	{
		//Delete a Filter Item.
		KeAcquireSpinLock(&FilterItemLock,&FilterItemIrql);
			
		tempFilterDirect=GetFilterTypeDirect(uInputFilterType);
		tempFilterOperate=GetFilterTypeOperate(uInputFilterType);

		pTempFilterContext=(FilterContext *)pInputBuffer;

		while(1)
		{//Use while(1) because when 
		//			tempFilterDirect = FilterReceive | FilterSend.

			if(FilterReceive & tempFilterDirect)
			{
				//Receive Filter.
				if(pTempFilterContext->Include)
					pTempHeaderFilterItem=&(pFilterEntry.RecIncludeQueue);
				else
					pTempHeaderFilterItem=&(pFilterEntry.RecExcludeQueue);
				
				tempFilterDirect = tempFilterDirect & (~FilterReceive);
			}else
			{
				if(FilterSend & tempFilterDirect)
				{
					//Send Filter.
					if(pTempFilterContext->Include)
						pTempHeaderFilterItem=&(pFilterEntry.SendIncludeQueue);
					else
						pTempHeaderFilterItem=&(pFilterEntry.SendExcludeQueue);
					
					tempFilterDirect = tempFilterDirect & (~FilterSend);
				}else
				{
					//exit.No Handle!!
					KeReleaseSpinLock(&FilterItemLock,FilterItemIrql);
					return ;
				}
			}
			
			//Allocate a new filter item.
			pTempDelFilterItem=ExAllocatePool(
						NonPagedPool,
						sizeof(FilterItem)
					);
			
			pTempDelFilterItem->FilterType=tempFilterOperate;
			pTempDelFilterItem->iItemBufferLen=uInputBufferLength;
			
			pTempDelFilterItem->pItemBuffer=pInputBuffer;
						
			if(	pTempFilterItem=SeekMatchFilterItem(
						pTempDelFilterItem,
						pTempHeaderFilterItem
					)	)
			{//seeked match filter item.
				//Remove the filter item from filter entry.	
				if(pTempFilterItem->pPre)
					pTempFilterItem->pPre->pNext=pTempFilterItem->pNext;
				
				if(pTempFilterItem->pNext)
					pTempFilterItem->pNext->pPre=pTempFilterItem->pPre;
				
				ExFreePool(pTempFilterItem);
			}
			
			ExFreePool(pTempDelFilterItem);
			
			KeReleaseSpinLock(&FilterItemLock,FilterItemIrql);
		}
	}
}

//////////////////////////////////////////////////////////

/*the Define not Declared in header.*/
//Judge the record include Or not.
//If match retValue equare 1;
//Else retValue equare 0.
#define JudgeRecordInclude(						\
		src,									\
		min,									\
		max,									\
		count,									\
		retValue								\
	)											\
{												\
	int tempDefNum=0;												\
																	\
	(retValue)=1;													\
	while(retValue && (tempDefNum<(count)) )						\
	{																\
		if(	( *((src)+tempDefNum) > *((max)+tempDefNum))			\
			||	( *((src)+tempDefNum) < *((min)+tempDefNum) ) )		\
				(retValue)=0;										\
		tempDefNum++;												\
	}																\
}

//Judge Match One context.
//And Operate the retValue with current context's result,
//If indicate should return now,return 1;
//else return 0.
int MatchOneContext(						
			OperateType InputOperate,		
			int *InputRetFlag,
			U8 *InputValue,							
			U8 *InputMin,
			U8 *InputMax,					
			int InputCount							
		)
{
	int iTempFlag;
		
	if(InputOperate)							
	{