2005-03-21_protocol.c

NDIS的经典源码

 /*++
Copyright(c) 1992  Microsoft Corporation
Module Name:
	protocol.c
Abstract:
	Ndis Intermediate Miniport driver sample. This is a passthru driver.
--*/

#include "precomp.h"
//#include "MyDef.c"
#pragma hdrstop

#define MAX_PACKET_POOL_SIZE 0x0000FFFF
#define MIN_PACKET_POOL_SIZE 0x000000FF

//---------------------------------------------------------
//规则标志位（1表示过滤，0表示放行，你可以通过改这个数值来配置规则）
UINT        ICMP = 1;     //ICMP数据报规则
UINT        IGMP = 0;    //IGMP数据报规则
UINT        TCP = 0;    //TCP数据报规则
UINT        UDP = 0;    //UDP数据报规则

VOID
PtBindAdapter(
	OUT PNDIS_STATUS			Status,
	IN  NDIS_HANDLE				BindContext,
	IN  PNDIS_STRING			DeviceName,
	IN  PVOID					SystemSpecific1,
	IN  PVOID					SystemSpecific2
	)
/*++
Routine Description:

	Called by NDIS to bind to a miniport below.

Arguments:

	Status			- Return status of bind here.
	BindContext		- Can be passed to NdisCompleteBindAdapter if this call is pended.
	DeviceName 		- Device name to bind to. This is passed to NdisOpenAdapter.
	SystemSpecific1	- Can be passed to NdisOpenProtocolConfiguration to read per-binding information
	SystemSpecific2	- Unused for NDIS 4.0.

Return Value:

	NDIS_STATUS_PENDING	if this call is pended. In this case call NdisCompleteBindAdapter to complete.
	Anything else		Completes this call synchronously
--*/
{
	NDIS_HANDLE						ConfigHandle = NULL;
	PNDIS_CONFIGURATION_PARAMETER	Param;
	NDIS_STRING						DeviceStr = NDIS_STRING_CONST("UpperBindings");
	PADAPT							pAdapt = NULL;
	NDIS_STATUS						Sts;
	UINT							MediumIndex;

	PNDIS_CONFIGURATION_PARAMETER	BundleParam;
	NDIS_STRING						BundleStr = NDIS_STRING_CONST("BundleId");
	NDIS_STATUS						BundleStatus;
	
	DBGPRINT("==> Passthru Protocol Initialize\n");

	do
	{
		//
		// Start off by opening the config section and reading our instance which we want
		// to export for this binding
		//
		NdisOpenProtocolConfiguration(Status,
		  							 &ConfigHandle,
		  							 SystemSpecific1);
		if (*Status != NDIS_STATUS_SUCCESS)
		{
		  	break;
		}

		NdisReadConfiguration(Status,
							  &Param,
		  					  ConfigHandle,
		  					  &DeviceStr,
		  					  NdisParameterString);
		if (*Status != NDIS_STATUS_SUCCESS)
		{
		  	break;
		}

		//
		// Allocate memory for the Adapter structure. This represents both as the protocol-context
		// as well as the adapter structure when the miniport is initialized.
		//
		NdisAllocateMemoryWithTag(&pAdapt, sizeof(ADAPT), TAG);

		if (pAdapt == NULL)
		{
			*Status = NDIS_STATUS_RESOURCES;
		  	break;
		}

		//
		// Initialize the adapter structure
		//
		NdisZeroMemory(pAdapt, sizeof(ADAPT));

		//
		// Store the String used by the registry, this will be used in reading data from the registry
		//
		NdisAllocateMemoryWithTag( &(pAdapt->BundleUniString.Buffer), MAX_BUNDLEID_LENGTH ,TAG);

		if (pAdapt->BundleUniString.Buffer == NULL)
		{
		  	*Status = NDIS_STATUS_RESOURCES;
		  	break;
		}

		pAdapt->BundleUniString.MaximumLength = MAX_BUNDLEID_LENGTH ;

		NdisReadConfiguration(&BundleStatus,
		  					  &BundleParam,
							  ConfigHandle,
		  					  &BundleStr,
		  					  NdisParameterString);

		if (BundleStatus == NDIS_STATUS_SUCCESS)
		{
		  	//
		  	// Copy the bundle identifier to our own memory
		  	//
		  	ASSERT(pAdapt->BundleUniString.MaximumLength  >= BundleParam->ParameterData.StringData.Length);

		  	pAdapt->BundleUniString.Length = BundleParam->ParameterData.StringData.Length;

		  	RtlCopyUnicodeString(&pAdapt->BundleUniString, &BundleParam->ParameterData.StringData);
		}
		else 
		{
			//
			//	We do not have a bundle id entry in the registry. To play safe we will enter 
			//	make the escape sequence the Bundle Id, This ensures that no bundle id's are 
			//	spuriously formed
			//

			NDIS_STRING NoBundle = NDIS_STRING_CONST ("<no-bundle>");

			RtlCopyUnicodeString(&pAdapt->BundleUniString, &NoBundle);
		}

		//
		//	Initializing the Event and the lock
		//
		NdisInitializeEvent(&pAdapt->Event);

		KeInitializeSpinLock(&pAdapt->SpinLock);

		//
		// Allocate a packet pool for sends. We need this to pass sends down. We cannot use the same
		// packet descriptor that came down to our send handler
		//
		NdisAllocatePacketPoolEx(Status,
		  						 &pAdapt->SendPacketPoolHandle,
		  						 MIN_PACKET_POOL_SIZE,
		  						 MAX_PACKET_POOL_SIZE - MIN_PACKET_POOL_SIZE,
		  						 sizeof(RSVD));

		if (*Status != NDIS_STATUS_SUCCESS)
		{
		  	break;
		}

		//
		// Allocate a packet pool for receives. We need this to indicate receives. Same consideration
		// as sends
		//
		NdisAllocatePacketPoolEx(Status,
		  						 &pAdapt->RecvPacketPoolHandle,
		  						 MIN_PACKET_POOL_SIZE,
		  						 MAX_PACKET_POOL_SIZE - MIN_PACKET_POOL_SIZE,
		  						 sizeof(RSVD));

		if (*Status != NDIS_STATUS_SUCCESS)
		{
		  	break;
		}
		// 初始化RecvBufferPoolHandle
		NdisAllocateBufferPool(Status, &pAdapt->RecvBufferPoolHandle, MIN_PACKET_POOL_SIZE); 

		if (*Status != NDIS_STATUS_SUCCESS)
		{
		  	break;
		}

		//
		// Now open the adapter below and complete the initialization
		//
		NdisOpenAdapter(Status,
		  				&Sts,
		  				&pAdapt->BindingHandle,
		  				&MediumIndex,
		  				MediumArray,
		  				sizeof(MediumArray)/sizeof(NDIS_MEDIUM),
		  				ProtHandle,
		  				pAdapt,
		  				DeviceName,
		  				0,
		  				NULL);

		if(*Status == NDIS_STATUS_PENDING)
		{
		  	NdisWaitEvent(&pAdapt->Event, 0);
		  	*Status = pAdapt->Status;
		}

		if(*Status != NDIS_STATUS_SUCCESS)
		{
		  	break;
		}

		pAdapt->Medium = MediumArray[MediumIndex];

		//
		// Now ask NDIS to initialize our miniport
		//
		NdisIMInitializeDeviceInstanceEx(DriverHandle,
  										 &Param->ParameterData.StringData,
  										 pAdapt);

	

	} while(FALSE);

	if(ConfigHandle != NULL)
	{
		NdisCloseConfiguration(ConfigHandle);
	}

	if(*Status != NDIS_STATUS_SUCCESS)
	{
		if(pAdapt != NULL)
		{
			if(pAdapt->SendPacketPoolHandle != NULL)
			{
				 NdisFreePacketPool(pAdapt->SendPacketPoolHandle);
			}

			if(pAdapt->RecvPacketPoolHandle != NULL)
			{
				 NdisFreePacketPool(pAdapt->RecvPacketPoolHandle);
			}

			NdisFreeMemory(pAdapt, sizeof(ADAPT), 0);
		}
	}


	DBGPRINT("<== Passthru Protocol Initialize\n");
}


VOID
PtOpenAdapterComplete(
	IN  NDIS_HANDLE			 ProtocolBindingContext,
	IN  NDIS_STATUS			 Status,
	IN  NDIS_STATUS			 OpenErrorStatus
	)
/*++

Routine Description:

	Completion routine for NdisOpenAdapter issued from within the PtBindAdapter. Simply
	unblock the caller.

Arguments:

	ProtocolBindingContext	Pointer to the adapter
	Status					Status of the NdisOpenAdapter call
	OpenErrorStatus			Secondary status(ignored by us).

Return Value:

	None

--*/
{
	PADAPT	  pAdapt =(PADAPT)ProtocolBindingContext;

	DBGPRINT("==> Passthru PtOpenAdapterComplete\n");
	pAdapt->Status = Status;
	NdisSetEvent(&pAdapt->Event);
}


VOID
PtUnbindAdapter(
	OUT PNDIS_STATUS		Status,
	IN  NDIS_HANDLE			ProtocolBindingContext,
	IN  NDIS_HANDLE			UnbindContext
	)
/*++

Routine Description:

	Called by NDIS when we are required to unbind to the adapter below.
	This functions shares functionality with the miniport's HaltHandler.
	The code should ensure that NdisCloseAdapter and NdisFreeMemory is called
	only once between the two functions

Arguments:

	Status					Placeholder for return status
	ProtocolBindingContext	Pointer to the adapter structure
	UnbindContext			Context for NdisUnbindComplete() if this pends

Return Value:

	Status for NdisIMDeinitializeDeviceContext

--*/
{
	PADAPT		 pAdapt =(PADAPT)ProtocolBindingContext;
	NDIS_HANDLE BindingHandle = pAdapt->BindingHandle;

	DBGPRINT("==> Passthru PtUnbindAdapter\n");

	if(pAdapt->QueuedRequest == TRUE)
	{
		pAdapt->QueuedRequest = FALSE;

		PtRequestComplete(pAdapt,
		                 &pAdapt->Request,
		                 NDIS_STATUS_FAILURE );

	}
	//
	// Call NDIS to remove our device-instance. We do most of the work inside the HaltHandler
	//
	// The Handle will be Null if the passthru's miniport Halt Handler has been called or
	// If the IM device was never initialized
	//


	
	if(pAdapt->MiniportHandle != NULL)
	{
		*Status = NdisIMDeInitializeDeviceInstance(pAdapt->MiniportHandle);

		if(*Status != NDIS_STATUS_SUCCESS)
		{
			*Status = NDIS_STATUS_FAILURE;
		}
	}
	else
	{
		//
		// We need to do some work here. 
		// Close the binding below us 
		// and release the memory allocated.
		//
		if(pAdapt->BindingHandle != NULL)
		{
			NdisResetEvent(&pAdapt->Event);

			NdisCloseAdapter(Status, pAdapt->BindingHandle);

			//
			// Wait for it to complete
			//
			if(*Status == NDIS_STATUS_PENDING)
			{
				 NdisWaitEvent(&pAdapt->Event, 0);
				 *Status = pAdapt->Status;
			}
		}
		else
		{
			//
			// Both Our MiniportHandle and Binding Handle  should not be NULL.
			//
			*Status = NDIS_STATUS_FAILURE;
			ASSERT(0);
		}

		//
		//	Free the memory here, if was not released earlier(by calling the HaltHandler)
		//
		NdisFreeMemory(pAdapt, sizeof(ADAPT), 0);
	}

	DBGPRINT("<==Passthru UnbindAdapter\n");
}


VOID
PtUnload(
	IN	PDRIVER_OBJECT		DriverObject
	)
{
	NDIS_STATUS Status;

	NdisDeregisterProtocol(&Status, ProtHandle);
}


VOID
PtCloseAdapterComplete(
	IN	NDIS_HANDLE			ProtocolBindingContext,
	IN	NDIS_STATUS			Status
	)
/*++
Routine Description:

	Completion for the CloseAdapter call.

Arguments:

	ProtocolBindingContext	Pointer to the adapter structure
	Status					Completion status

Return Value:

	None.
--*/
{
	PADAPT	  pAdapt =(PADAPT)ProtocolBindingContext;

	pAdapt->Status = Status;
	NdisSetEvent(&pAdapt->Event);
}


VOID
PtResetComplete(
	IN  NDIS_HANDLE			ProtocolBindingContext,
	IN  NDIS_STATUS			Status
	)
/*++
Routine Description:

	Completion for the reset.

Arguments:

	ProtocolBindingContext	Pointer to the adapter structure
	Status					Completion status

Return Value:

	None.
--*/
{
	PADAPT	pAdapt =(PADAPT)ProtocolBindingContext;

	//
	// We never issue a reset, so we should not be here.
	//
	ASSERT(0);
}


VOID
PtRequestComplete(
	IN  NDIS_HANDLE			ProtocolBindingContext,
	IN  PNDIS_REQUEST		NdisRequest,
	IN  NDIS_STATUS			Status
	)
/*++
Routine Description:

	Completion handler for the previously posted request. All OIDS are completed by and sent to
	the same miniport that they were requested for.
	If Oid == OID_PNP_QUERY_POWER then the data structure needs to returned with all entries =
	NdisDeviceStateUnspecified

Arguments:

	ProtocolBindingContext	Pointer to the adapter structure
	NdisRequest				The posted request
	Status					Completion status

Return Value:

	None
--*/
{
	PADAPT		pAdapt =(PADAPT)ProtocolBindingContext;
	NDIS_OID	Oid =	pAdapt->Request.DATA.SET_INFORMATION.Oid ;

	//
	//	Change to the pAdapt for which the request originated
	//
	if(MPIsSendOID(Oid))
	{
		  pAdapt = pAdapt->pPrimaryAdapt;
		  //
		  // Will point to itself if there is no bundle(see initialization)
		  //
	}

	//