someerrorcode.c

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

/*
void WritePacketBuffer(
   		ULONG	uInputWriteLen,
		ULONG	*uOutputWriteLen,
		void	*pInputDataBuffer
	)
{
	ULONG uTempBytesTxd;

	// Get access to the packet buffer
	KeAcquireSpinLock(&PacketBufferLock,&PacketBufferIrql);

	//I trust the uInputWriteLen>0.So no this judge.

	
	//Calculate the size of translate data.
	if(uInputWriteLen> PacketBufferSize-PacketBufferDataLen)
	{
		uTempBytesTxd=uInputWriteLen;
	}else
	{
		uTempBytesTxd=PacketBufferSize-PacketBufferDataLen;
	}



	*uOutputWriteLen=uTempBytesTxd;

	// Release packet Buffer's lock.
	KeReleaseSpinLock(&PacketBufferLock,PacketBufferIrql);

}
*/

/*External Function*/
//Read the data from packet buffer.
//Called by MyDeviceRead().
/*
void ReadPacketBuffer(
		ULONG	uInputReadLen,
		ULONG	*uOutputReadLen,
		void	*pOutputDataBuffer
	)
{
	//Indicate the count of  Header to end of PacketBuffer.
	ULONG uTempBytesOfHead;
	
	ULONG uTempBytesTxd = 0;
		
	
	// Get access to the packet buffer
	KeAcquireSpinLock(&PacketBufferLock,&PacketBufferIrql);
	
	//Calculate the count of translate data.
	if(uInputReadLen>PacketBufferDataLen)
		uTempBytesTxd=PacketBufferDataLen;
	else
		uTempBytesTxd=uInputReadLen;
	
	//Now copy the data from old buffer to new.
	//Size : tempBytesTxd.
	if(HeaderOfPacketBuffer<TailOfPacketBuffer)
	{
		//Note : No "=".
		RtlCopyMemory(
			pOutputDataBuffer,
			HeaderOfPacketBuffer,
			uTempBytesTxd
			);
		
		HeaderOfPacketBuffer = (U8 *)
			( (ULONG)HeaderOfPacketBuffer + uTempBytesTxd );
		
	}else
	{
		//Indicate the count
		uTempBytesOfHead=(ULONG)PacketBuffer+PacketBufferSize-1
			-(ULONG)HeaderOfPacketBuffer+1;
		
		if( uTempBytesTxd <= uTempBytesOfHead )
		{
			RtlCopyMemory(
				pOutputDataBuffer,
				HeaderOfPacketBuffer,
				uTempBytesTxd
				);
			
			HeaderOfPacketBuffer = (U8 *)
				( (ULONG)HeaderOfPacketBuffer + uTempBytesTxd );
			
		}else
		{//You should copy the two part of data to one.
			
			//First Copy length is uTempBytesOfHead.
			RtlCopyMemory(
				pOutputDataBuffer,
				HeaderOfPacketBuffer,
				uTempBytesOfHead
				);
			
			RtlCopyMemory(
				((U8 *)pOutputDataBuffer) + uTempBytesOfHead,
				PacketBuffer,
				uTempBytesTxd-uTempBytesOfHead
				);
			
			HeaderOfPacketBuffer= (U8 *)(
				(ULONG)PacketBuffer + 
				uTempBytesTxd - uTempBytesOfHead);
		}	
	}
	
	//Note : it is necessary!
	if( (ULONG)HeaderOfPacketBuffer == 
		(ULONG)PacketBuffer+PacketBufferSize)
	{
		HeaderOfPacketBuffer=PacketBuffer;
	}
	
	*uOutputReadLen=uTempBytesTxd;

	// Release packet Buffer's lock.
	KeReleaseSpinLock(&PacketBufferLock,PacketBufferIrql);

}

*/

/*External Function*/
//Copy the Packet data from buffer.
//No Return value.
		/*
void CopyPacketByBuffer(
		void	*LookAheadBuffer,
		ULONG	LookAheadBufferSize
	)
{
	int i=0;
	
	SavedPacketEntry *pTempEntry;
	
	KeAcquireSpinLock(&SavedPacketEntryLock,&SavedPacketEntryIrql);

	pTempEntry=pSavedPacketEntry;

	while(i<iCurSavedPacketNum)
	{
		if(pTempEntry->uFilterFlag == 0)
		{//Has empty item to copy packet data.
	
			//Allocate buffer.
			pTempEntry->pSavedData->pPacketData=
					(SavedPacketData *)ExAllocatePool(
							NonPagedPool,
							LookAheadBufferSize
						);

			if(pTempEntry->pSavedData->pPacketData)
			{
				//Set Entry's property.
				NdisMoveMemory(
						pTempEntry->pSavedData->pPacketData,
						LookAheadBuffer,
						LookAheadBufferSize
					);

				pTempEntry->pSavedData->next=NULL;
				
				pTempEntry->pSavedData->uPacketLength=LookAheadBufferSize;

				pTempEntry->identity=GetIdentifyFromIpPacket(LookAheadBuffer);

				pTempEntry->uFilterFlag=1;

			}
			
			KeReleaseSpinLock(&SavedPacketEntryLock,SavedPacketEntryIrql);
				
			return ;
		}

		i++;
	}

	KeReleaseSpinLock(&SavedPacketEntryLock,SavedPacketEntryIrql);
}
*/

/****************Variable Declaration(External)*******************/
int iPacketBufferFlag;//The Filter flag indicate whether has IP to filter.
KSPIN_LOCK PacketBufferLock;
KIRQL PacketBufferIrql;

U8*	PacketBuffer=NULL;//The buffer of packet saved.
U8* HeaderOfPacketBuffer=NULL;//The header of packet buffer.
U8* TailOfPacketBuffer=NULL;//the tail of packet buffer.

U32	PacketBufferSize=0;//The size of saved packet buffer.
U32 PacketBufferDataLen=0;//The data's length of packet buffer.

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

/*External*/
//Initialize the buffer of saved packet.
//mainly allocate some buffer and initialize it.
//If Success,return zero,
//else return NoZero.
int InitPacketBuffer(void)
{
	KeAcquireSpinLock(&PacketBufferLock,&PacketBufferIrql);
	
	//Allocate size,
	//Now only 4k.
	PacketBufferSize=4*1024;

	PacketBufferDataLen=0;
	
	//template allocate buffer must success!
	PacketBuffer=ExAllocatePool(
				NonPagedPoolMustSucceed,
				PacketBufferSize*sizeof(U8)
			);

	HeaderOfPacketBuffer = TailOfPacketBuffer = PacketBuffer;
	

	KeReleaseSpinLock(&PacketBufferLock,PacketBufferIrql);
	
	return 0;
}

/*External*/
//Free the buffer of saved packet.
//No return value.
void FreePacketBuffer(void)
{
	KeAcquireSpinLock(&PacketBufferLock,&PacketBufferIrql);
	
	PacketBufferSize=0;

	PacketBufferDataLen=0;

	ExFreePool(PacketBuffer);

	PacketBuffer = HeaderOfPacketBuffer = TailOfPacketBuffer=NULL;

	KeReleaseSpinLock(&PacketBufferLock,PacketBufferIrql);
}

/*External*/
//Zap the buffer of saved packet.
//Zero it!!
//You can call it when you Create and Close the Gui device.
void ZapPacketBuffer(void)
{
	KeAcquireSpinLock(&PacketBufferLock,&PacketBufferIrql);
	
	PacketBufferSize=0;	

	HeaderOfPacketBuffer = TailOfPacketBuffer = PacketBuffer;
	
	KeReleaseSpinLock(&PacketBufferLock,PacketBufferIrql);
	
}

/*External*/
//ReAllocate the Buffer Size of saved packet.
//If success,return Zero;
//else return NoZero.
int ReAllocatePacketBuffer(ULONG iInputReAllocSize)
{
	U8* pTempBuffer;

	if(iInputReAllocSize>0)
	{
		KeAcquireSpinLock(&PacketBufferLock,&PacketBufferIrql);
		
		//Now Must Success is not Necessary.
		pTempBuffer=ExAllocatePool(
				NonPagedPool,
				iInputReAllocSize
			);

		if(pTempBuffer==NULL)
		{
			//Reallocate Fail.
			KeReleaseSpinLock(&PacketBufferLock,PacketBufferIrql);

			return 1;
		}

	//ReAllocate Success.

		//Copy buffer data from old buffer to new buffer.	
		if(PacketBufferDataLen>0)
		{
			if(PacketBufferDataLen>iInputReAllocSize)
			{
				//The size of new buffer is too small.
				//You should delete some data!
				//I Only Set the Tail's position to Delete the tail data.
				ULONG uTempDelLength;

				uTempDelLength=PacketBufferDataLen-iInputReAllocSize;
				
				TailOfPacketBuffer = 
					(U8 *)( 
						(ULONG)TailOfPacketBuffer - uTempDelLength
					);

				if(TailOfPacketBuffer < PacketBuffer)
				{
					//Set Tail to the loop .
					TailOfPacketBuffer = (U8 *)((ULONG)TailOfPacketBuffer + PacketBufferSize);
				}

				PacketBufferDataLen=iInputReAllocSize;
			}	

			//Now Only copy the data from old buffer to new.
			if(HeaderOfPacketBuffer<TailOfPacketBuffer)
			{
				//Note : No "=".
				RtlCopyMemory(
					pTempBuffer,
					HeaderOfPacketBuffer,
					PacketBufferDataLen
					);
				
			}else
			{
				//Header > Tail.
				//You should copy the two part of data to one.
				RtlCopyMemory(
					pTempBuffer,
					HeaderOfPacketBuffer,
					(ULONG)PacketBuffer+ (PacketBufferSize - 1 )
						- (ULONG)HeaderOfPacketBuffer +1
					);
				
				//Note:copy length is (TailOfPacketBuffer - PacketBuffer)
				//		Not (TailOfPacketBuffer - PacketBuffer +1).
				RtlCopyMemory(
					pTempBuffer + 
						(ULONG)PacketBuffer+ (PacketBufferSize - 1 )
						- (ULONG)HeaderOfPacketBuffer +1,
					PacketBuffer,
					(ULONG)TailOfPacketBuffer - (ULONG)PacketBuffer
					);
				
			}
		}
	
		ExFreePool(PacketBuffer);

		PacketBuffer=pTempBuffer;

		PacketBufferSize=iInputReAllocSize;	

		HeaderOfPacketBuffer=PacketBuffer;
		
		if(PacketBufferDataLen==PacketBufferSize)
			TailOfPacketBuffer=PacketBuffer;
		else
		{//Note: not (PacketBuffer+ PacketBufferDataLen -1)
			TailOfPacketBuffer=PacketBuffer+ PacketBufferDataLen;
		}
		
		KeReleaseSpinLock(&PacketBufferLock,PacketBufferIrql);

		return 0;

	}else
	{
		//Input Parameter Error!
		//Must above Zero.
		return 1;
	}
}