protocol.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_PROTOCOL_BINDING
struct	_ADAPTER_BINDING
struct	_NDIS_REQUEST_MAC_BLOCK

Macros
#define	GET_PROTOCOL_BINDING(Handle)   ((PPROTOCOL_BINDING)Handle)
#define	GET_ADAPTER_BINDING(Handle)   ((PADAPTER_BINDING)Handle)

Typedefs
typedef struct _PROTOCOL_BINDING	PROTOCOL_BINDING
typedef struct _PROTOCOL_BINDING *	PPROTOCOL_BINDING
typedef struct _ADAPTER_BINDING	ADAPTER_BINDING
typedef struct _ADAPTER_BINDING *	PADAPTER_BINDING
typedef struct _NDIS_REQUEST_MAC_BLOCK	NDIS_REQUEST_MAC_BLOCK
typedef struct _NDIS_REQUEST_MAC_BLOCK *	PNDIS_REQUEST_MAC_BLOCK

Functions
NDIS_STATUS	ProIndicatePacket (PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
VOID NTAPI	ProSendPackets (IN NDIS_HANDLE NdisBindingHandle, IN PPNDIS_PACKET PacketArray, IN UINT NumberOfPackets)
NTSTATUS NTAPI	NdisIPnPQueryStopDevice (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	NdisIPnPCancelStopDevice (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)
NDIS_STATUS	proSendPacketToMiniport (PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
VOID NTAPI	ndisBindMiniportsToProtocol (OUT PNDIS_STATUS Status, IN PPROTOCOL_BINDING Protocol)

Variables
LIST_ENTRY	ProtocolListHead
KSPIN_LOCK	ProtocolListLock

Macro Definition Documentation

GET_ADAPTER_BINDING

#define GET_ADAPTER_BINDING

(

Handle

)

((PADAPTER_BINDING)Handle)

Definition at line 39 of file protocol.h.

GET_PROTOCOL_BINDING

#define GET_PROTOCOL_BINDING

(

Handle

)

((PPROTOCOL_BINDING)Handle)

Definition at line 18 of file protocol.h.

Typedef Documentation

ADAPTER_BINDING

typedef struct _ADAPTER_BINDING ADAPTER_BINDING

NDIS_REQUEST_MAC_BLOCK

typedef struct _NDIS_REQUEST_MAC_BLOCK NDIS_REQUEST_MAC_BLOCK

PADAPTER_BINDING

typedef struct _ADAPTER_BINDING * PADAPTER_BINDING

PNDIS_REQUEST_MAC_BLOCK

typedef struct _NDIS_REQUEST_MAC_BLOCK * PNDIS_REQUEST_MAC_BLOCK

PPROTOCOL_BINDING

typedef struct _PROTOCOL_BINDING * PPROTOCOL_BINDING

PROTOCOL_BINDING

typedef struct _PROTOCOL_BINDING PROTOCOL_BINDING

Function Documentation

ndisBindMiniportsToProtocol()

VOID NTAPI ndisBindMiniportsToProtocol	(	OUT PNDIS_STATUS	Status,
		IN PPROTOCOL_BINDING	Protocol
	)

Definition at line 908 of file protocol.c.

{
  /*
   * bind the protocol to all of its miniports
   *
   * open registry path
   * get list of devices from Bind key
   * call BindAdapterHandler for each
   */
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING RegistryPath;
    WCHAR *RegistryPathStr, *DataPtr = NULL;
    NTSTATUS NtStatus;
    HANDLE DriverKeyHandle = NULL;
    PKEY_VALUE_PARTIAL_INFORMATION KeyInformation = NULL;
    PNDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics = &Protocol->Chars;
    UNICODE_STRING ValueName;
    ULONG ResultLength;
    PLIST_ENTRY CurrentEntry = NULL;
 
    RegistryPathStr = ExAllocatePoolWithTag(PagedPool, sizeof(SERVICES_KEY) + ProtocolCharacteristics->Name.Length + sizeof(LINKAGE_KEY), NDIS_TAG + __LINE__);
    if(!RegistryPathStr)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
        *Status = NDIS_STATUS_RESOURCES;
        return;
    }
 
    wcscpy(RegistryPathStr, SERVICES_KEY);
    wcsncat(RegistryPathStr, ((WCHAR *)ProtocolCharacteristics->Name.Buffer), ProtocolCharacteristics->Name.Length / sizeof(WCHAR));
    RegistryPathStr[wcslen(SERVICES_KEY)+ProtocolCharacteristics->Name.Length/sizeof(WCHAR)] = 0;
    wcscat(RegistryPathStr, LINKAGE_KEY);
 
    RtlInitUnicodeString(&RegistryPath, RegistryPathStr);
    NDIS_DbgPrint(MAX_TRACE, ("Opening configuration key: %wZ\n", &RegistryPath));
 
    InitializeObjectAttributes(&ObjectAttributes, &RegistryPath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    NtStatus = ZwOpenKey(&DriverKeyHandle, KEY_READ, &ObjectAttributes);
 
    ExFreePool(RegistryPathStr);
 
    if(NT_SUCCESS(NtStatus))
    {
        NDIS_DbgPrint(MAX_TRACE, ("Successfully opened the registry configuration\n"));
 
        RtlInitUnicodeString(&ValueName, L"Bind");
 
        NtStatus = ZwQueryValueKey(DriverKeyHandle, &ValueName, KeyValuePartialInformation, NULL, 0, &ResultLength);
        if(NtStatus != STATUS_BUFFER_OVERFLOW && NtStatus != STATUS_BUFFER_TOO_SMALL && NtStatus != STATUS_SUCCESS)
        {
            NDIS_DbgPrint(MIN_TRACE, ("Unable to query the Bind value for size\n"));
            ZwClose(DriverKeyHandle);
        }
        else
        {
            KeyInformation = ExAllocatePoolWithTag(PagedPool, sizeof(KEY_VALUE_PARTIAL_INFORMATION) + ResultLength, NDIS_TAG + __LINE__);
            if(!KeyInformation)
            {
                NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
                ZwClose(DriverKeyHandle);
                NtStatus = STATUS_NO_MEMORY;
            }
            else
            {
                NtStatus = ZwQueryValueKey(DriverKeyHandle, &ValueName, KeyValuePartialInformation, KeyInformation,
                                           sizeof(KEY_VALUE_PARTIAL_INFORMATION) + ResultLength, &ResultLength);
 
                ZwClose(DriverKeyHandle);
 
                if(!NT_SUCCESS(NtStatus))
                {
                    NDIS_DbgPrint(MIN_TRACE, ("Unable to query the Bind value\n"));
                    ExFreePool(KeyInformation);
                    KeyInformation = NULL;
                }
            }
        }
    }
 
    if (!NT_SUCCESS(NtStatus))
    {
        NDIS_DbgPrint(MID_TRACE, ("Performing global bind for protocol '%wZ'\n", &ProtocolCharacteristics->Name));
        KeyInformation = NULL;
 
        CurrentEntry = AdapterListHead.Flink;
    }
    else
    {
        NDIS_DbgPrint(MID_TRACE, ("Performing standard bind for protocol '%wZ'\n", &ProtocolCharacteristics->Name));
 
        DataPtr = (WCHAR*)KeyInformation->Data;
    }
 
    /* Assume success for now */
    *Status = NDIS_STATUS_SUCCESS;
 
    while (TRUE)
    {
        /* BindContext is for tracking pending binding operations */
        VOID *BindContext = 0;
        NDIS_STRING DeviceName;
        NDIS_STRING RegistryPath;
        WCHAR *RegistryPathStr = NULL;
        ULONG PathLength = 0;
        PLOGICAL_ADAPTER Adapter;
 
        if (KeyInformation)
        {
            /* Parse the REG_MULTI_SZ entry for device names */
            if (!(*DataPtr))
                break;
 
            RtlInitUnicodeString(&DeviceName, DataPtr);
        }
        else
        {
            /* Use the device name from the global adapter list */
            if (CurrentEntry == &AdapterListHead)
                break;
 
            Adapter = CONTAINING_RECORD(CurrentEntry, LOGICAL_ADAPTER, ListEntry);
 
            DeviceName = Adapter->NdisMiniportBlock.MiniportName;
        }
 
        /* Make sure the adapter has started */
        if (!MiniLocateDevice(&DeviceName))
        {
            /* It wasn't in the global miniport list, so skip the bind entry */
            goto next;
        }
 
        /* Make sure this device isn't already bound to this protocol */
        if (LocateAdapterBindingByName(Protocol, &DeviceName))
        {
            /* It was already in this protocol's bound adapter list, so skip the bind entry */
            goto next;
        }
 
        /*
         * RegistryPath should be:
         *     \Registry\Machine\System\CurrentControlSet\Services\Nic1\Parameters\Tcpip
         *
         *  This is constructed as follows:
         *      SERVICES_KEY + extracted device name + Protocol name from characteristics
         */
 
        PathLength = sizeof(SERVICES_KEY) +                               /* \Registry\Machine\System\CurrentControlSet\Services\ */
        wcslen( DeviceName.Buffer + 8 ) * sizeof(WCHAR) + /* Adapter1  (extracted from \Device\Adapter1)          */
        sizeof(PARAMETERS_KEY) +                                      /* \Parameters\                                         */
        ProtocolCharacteristics->Name.Length + sizeof(WCHAR);                         /* Tcpip                                                */
 
        RegistryPathStr = ExAllocatePool(PagedPool, PathLength);
        if(!RegistryPathStr)
        {
            NDIS_DbgPrint(MIN_TRACE, ("insufficient resources.\n"));
            *Status = NDIS_STATUS_RESOURCES;
            break;
        }
 
        wcscpy(RegistryPathStr, SERVICES_KEY);
        wcscat(RegistryPathStr, DeviceName.Buffer + 8 );
        wcscat(RegistryPathStr, PARAMETERS_KEY);
        wcsncat(RegistryPathStr, ProtocolCharacteristics->Name.Buffer, ProtocolCharacteristics->Name.Length / sizeof(WCHAR) );
 
        RegistryPathStr[PathLength/sizeof(WCHAR) - 1] = 0;
 
        RtlInitUnicodeString(&RegistryPath, RegistryPathStr);
 
        NDIS_DbgPrint(MAX_TRACE, ("Calling protocol's BindAdapter handler with DeviceName %wZ and RegistryPath %wZ\n",
                                  &DeviceName, &RegistryPath));
 
        {
            BIND_HANDLER BindHandler = ProtocolCharacteristics->BindAdapterHandler;
            if(BindHandler)
            {
                BindHandler(Status, BindContext, &DeviceName, &RegistryPath, 0);
                NDIS_DbgPrint(MID_TRACE, ("%wZ's BindAdapter handler returned 0x%x for %wZ\n", &ProtocolCharacteristics->Name, *Status, &DeviceName));
            }
            else
                NDIS_DbgPrint(MID_TRACE, ("No protocol bind handler specified\n"));
        }
 
    next:
        if (KeyInformation)
        {
            /* Advance to the next adapter in the REG_MULTI_SZ */
            DataPtr += (DeviceName.Length / sizeof(WCHAR)) + 1;
        }
        else
        {
            /* Advance to the next adapter in the global list */
            CurrentEntry = CurrentEntry->Flink;
        }
    }
 
    if (KeyInformation)
    {
        ExFreePool(KeyInformation);
    }
}

Referenced by NdisIPnPStartDevice(), NdisReEnumerateProtocolBindings(), and NdisRegisterProtocol().

NdisIPnPCancelStopDevice()

NTSTATUS NTAPI NdisIPnPCancelStopDevice	(	IN PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 172 of file protocol.c.

{
  PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
  PNET_PNP_EVENT PnPEvent;
 
  PnPEvent = ProSetupPnPEvent(NetEventCancelRemoveDevice, NULL, 0);
  if (!PnPEvent) {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
      return NDIS_STATUS_RESOURCES;
  }
 
  return ProSendAndFreePnPEvent(Adapter, PnPEvent, Irp);
}

Referenced by NdisIDispatchPnp().

NdisIPnPQueryStopDevice()

NTSTATUS NTAPI NdisIPnPQueryStopDevice	(	IN PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 154 of file protocol.c.

{
  PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
  PNET_PNP_EVENT PnPEvent;
 
  PnPEvent = ProSetupPnPEvent(NetEventQueryRemoveDevice, NULL, 0);
  if (!PnPEvent) {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
      return NDIS_STATUS_RESOURCES;
  }
 
  return ProSendAndFreePnPEvent(Adapter, PnPEvent, Irp);
}

Referenced by NdisIDispatchPnp().

ProIndicatePacket()

NDIS_STATUS ProIndicatePacket	(	PLOGICAL_ADAPTER	Adapter,
		PNDIS_PACKET	Packet
	)

Definition at line 243 of file protocol.c.

{
  UINT BufferedLength;
  UINT PacketLength;
  KIRQL OldIrql;
  PUCHAR LookaheadBuffer;
 
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
#if DBG
  MiniDisplayPacket(Packet, "INDICATE");
#endif
 
  NdisQueryPacket(Packet, NULL, NULL, NULL, &PacketLength);
 
  LookaheadBuffer = ExAllocatePool(NonPagedPool, PacketLength);
  if (!LookaheadBuffer) {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
      return NDIS_STATUS_RESOURCES;
  }
 
  NDIS_DbgPrint(MAX_TRACE, ("acquiring miniport block lock\n"));
  KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
    {
      BufferedLength = CopyPacketToBuffer(LookaheadBuffer, Packet, 0, PacketLength);
      Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()] = Packet;
    }
  KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
 
  if (BufferedLength > Adapter->MediumHeaderSize)
    {
      /* XXX Change this to call SendPackets so we don't have to duplicate this wacky logic */
      MiniIndicateData(Adapter, NULL, LookaheadBuffer, Adapter->MediumHeaderSize,
          &LookaheadBuffer[Adapter->MediumHeaderSize], BufferedLength - Adapter->MediumHeaderSize,
          PacketLength - Adapter->MediumHeaderSize);
    }
  else
    {
      MiniIndicateData(Adapter, NULL, LookaheadBuffer, Adapter->MediumHeaderSize, NULL, 0, 0);
    }
 
  ExFreePool(LookaheadBuffer);
 
  KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
    {
      Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()] = NULL;
    }
  KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
 
  return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportWorker(), and ProSend().

ProSendPackets()

VOID NTAPI ProSendPackets	(	IN NDIS_HANDLE	NdisBindingHandle,
		IN PPNDIS_PACKET	PacketArray,
		IN UINT	NumberOfPackets
	)

Definition at line 577 of file protocol.c.

{
    PADAPTER_BINDING AdapterBinding = NdisBindingHandle;
    PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
    KIRQL RaiseOldIrql;
    NDIS_STATUS NdisStatus;
    UINT i;
 
    if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
    {
       if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
       {
          (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
           Adapter->NdisMiniportBlock.MiniportAdapterContext, PacketArray, NumberOfPackets);
       }
       else
       {
          /* SendPackets is called at DISPATCH_LEVEL for all serialized miniports */
          KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
          (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
           Adapter->NdisMiniportBlock.MiniportAdapterContext, PacketArray, NumberOfPackets);
          KeLowerIrql(RaiseOldIrql);
          for (i = 0; i < NumberOfPackets; i++)
          {
             NdisStatus = NDIS_GET_PACKET_STATUS(PacketArray[i]);
             if (NdisStatus != NDIS_STATUS_PENDING)
                 MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
          }
       }
     }
     else
     {
       if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
       {
          for (i = 0; i < NumberOfPackets; i++)
          {
             NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
                           Adapter->NdisMiniportBlock.MiniportAdapterContext, PacketArray[i], PacketArray[i]->Private.Flags);
             if (NdisStatus != NDIS_STATUS_PENDING)
                 MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
          }
       }
       else
       {
         /* Send is called at DISPATCH_LEVEL for all serialized miniports */
         KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
         for (i = 0; i < NumberOfPackets; i++)
         {
            NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
                           Adapter->NdisMiniportBlock.MiniportAdapterContext, PacketArray[i], PacketArray[i]->Private.Flags);
            if (NdisStatus != NDIS_STATUS_PENDING)
                MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
         }
         KeLowerIrql(RaiseOldIrql);
       }
     }
}

Referenced by NdisIPnPStartDevice(), NdisOpenAdapter(), and NdisSendPackets().

proSendPacketToMiniport()

NDIS_STATUS proSendPacketToMiniport	(	PLOGICAL_ADAPTER	Adapter,
		PNDIS_PACKET	Packet
	)

Definition at line 389 of file protocol.c.

{
#if WORKER_TEST
   MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet, FALSE);
   return NDIS_STATUS_PENDING;
#else
   KIRQL RaiseOldIrql;
   NDIS_STATUS NdisStatus;
 
   NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
   if(MiniIsBusy(Adapter, NdisWorkItemSend)) {
      NDIS_DbgPrint(MID_TRACE, ("Busy: NdisWorkItemSend.\n"));
 
      MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet, FALSE);
      return NDIS_STATUS_PENDING;
   }
 
#if DBG
   MiniDisplayPacket(Packet, "SEND");
#endif
 
   if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
   {
        if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
        {
            NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
            (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
             Adapter->NdisMiniportBlock.MiniportAdapterContext, &Packet, 1);
             NdisStatus = NDIS_STATUS_PENDING;
        } else {
            /* SendPackets is called at DISPATCH_LEVEL for all serialized miniports */
            KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
            {
               NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
               (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
                Adapter->NdisMiniportBlock.MiniportAdapterContext, &Packet, 1);
            }
            KeLowerIrql(RaiseOldIrql);
 
            NdisStatus = NDIS_GET_PACKET_STATUS(Packet);
            if (NdisStatus == NDIS_STATUS_RESOURCES) {
                MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet, TRUE);
                NdisStatus = NDIS_STATUS_PENDING;
            }
        }
 
        if (NdisStatus != NDIS_STATUS_PENDING) {
            MiniWorkItemComplete(Adapter, NdisWorkItemSend);
        }
 
        return NdisStatus;
   } else {
        if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
        {
            NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
            NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
                          Adapter->NdisMiniportBlock.MiniportAdapterContext, Packet, Packet->Private.Flags);
            NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
        } else {
            /* Send is called at DISPATCH_LEVEL for all serialized miniports */
            KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
            NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
            NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
                          Adapter->NdisMiniportBlock.MiniportAdapterContext, Packet, Packet->Private.Flags);
            NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
            KeLowerIrql(RaiseOldIrql);
 
            if (NdisStatus == NDIS_STATUS_RESOURCES) {
                MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet, TRUE);
                NdisStatus = NDIS_STATUS_PENDING;
            }
        }
 
        if (NdisStatus != NDIS_STATUS_PENDING) {
            MiniWorkItemComplete(Adapter, NdisWorkItemSend);
        }
 
        return NdisStatus;
   }
#endif
}

Referenced by ProSend(), and ScatterGatherSendPacket().

Variable Documentation

ProtocolListHead

LIST_ENTRY ProtocolListHead

extern

Definition at line 19 of file protocol.c.

Referenced by DriverEntry(), NdisCompleteBindAdapter(), NdisIPnPStartDevice(), and NdisRegisterProtocol().

ProtocolListLock

KSPIN_LOCK ProtocolListLock

extern

Definition at line 20 of file protocol.c.

Referenced by DriverEntry(), NdisCompleteBindAdapter(), NdisCompleteUnbindAdapter(), NdisDeregisterProtocol(), and NdisRegisterProtocol().