#include "ndissys.h"

Include dependency graph for protocol.c:

Classes
struct	_DMA_CONTEXT

Macros
#define	SERVICES_KEY L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"

#define	LINKAGE_KEY L"\\Linkage"

#define	PARAMETERS_KEY L"\\Parameters\\"

#define	WORKER_TEST 0

Typedefs
typedef struct _DMA_CONTEXT	DMA_CONTEXT

typedef struct _DMA_CONTEXT *	PDMA_CONTEXT

Functions
PNET_PNP_EVENT	ProSetupPnPEvent (NET_PNP_EVENT_CODE EventCode, PVOID EventBuffer, ULONG EventBufferLength)

NDIS_STATUS	ProSendAndFreePnPEvent (PLOGICAL_ADAPTER Adapter, PNET_PNP_EVENT PnPEvent, PIRP Irp)

NTSTATUS NTAPI	NdisIPwrSetPower (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)

NTSTATUS NTAPI	NdisIPwrQueryPower (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)

NTSTATUS NTAPI	NdisIPnPQueryStopDevice (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)

NTSTATUS NTAPI	NdisIPnPCancelStopDevice (IN PDEVICE_OBJECT DeviceObject, PIRP Irp)

VOID EXPORT	NdisCompleteBindAdapter (IN NDIS_HANDLE BindAdapterContext, IN NDIS_STATUS Status, IN NDIS_STATUS OpenStatus)

VOID EXPORT	NdisCompleteUnbindAdapter (IN NDIS_HANDLE UnbindAdapterContext, IN NDIS_STATUS Status)

NDIS_STATUS	ProIndicatePacket (PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)

NDIS_STATUS NTAPI	ProRequest (IN NDIS_HANDLE MacBindingHandle, IN PNDIS_REQUEST NdisRequest)

NDIS_STATUS NTAPI	ProReset (IN NDIS_HANDLE MacBindingHandle)

VOID NTAPI	ScatterGatherSendPacket (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PSCATTER_GATHER_LIST ScatterGather, IN PVOID Context)

NDIS_STATUS	proSendPacketToMiniport (PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)

NDIS_STATUS NTAPI	ProSend (IN NDIS_HANDLE MacBindingHandle, IN PNDIS_PACKET Packet)

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

NDIS_STATUS NTAPI	ProTransferData (IN NDIS_HANDLE MacBindingHandle, IN NDIS_HANDLE MacReceiveContext, IN UINT ByteOffset, IN UINT BytesToTransfer, IN OUT PNDIS_PACKET Packet, OUT PUINT BytesTransferred)

VOID EXPORT	NdisCloseAdapter (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle)

VOID EXPORT	NdisDeregisterProtocol (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisProtocolHandle)

VOID EXPORT	NdisOpenAdapter (OUT PNDIS_STATUS Status, OUT PNDIS_STATUS OpenErrorStatus, OUT PNDIS_HANDLE NdisBindingHandle, OUT PUINT SelectedMediumIndex, IN PNDIS_MEDIUM MediumArray, IN UINT MediumArraySize, IN NDIS_HANDLE NdisProtocolHandle, IN NDIS_HANDLE ProtocolBindingContext, IN PNDIS_STRING AdapterName, IN UINT OpenOptions, IN PSTRING AddressingInformation OPTIONAL)

PADAPTER_BINDING NTAPI	LocateAdapterBindingByName (IN PPROTOCOL_BINDING ProtocolBinding, IN PNDIS_STRING AdapterName)

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

VOID EXPORT	NdisRegisterProtocol (OUT PNDIS_STATUS Status, OUT PNDIS_HANDLE NdisProtocolHandle, IN PNDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics, IN UINT CharacteristicsLength)

VOID EXPORT	NdisRequest (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle, IN PNDIS_REQUEST NdisRequest)

VOID EXPORT	NdisReset (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle)

VOID EXPORT	NdisSend (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle, IN PNDIS_PACKET Packet)

VOID EXPORT	NdisSendPackets (IN NDIS_HANDLE NdisBindingHandle, IN PPNDIS_PACKET PacketArray, IN UINT NumberOfPackets)

VOID EXPORT	NdisTransferData (OUT PNDIS_STATUS Status, IN NDIS_HANDLE NdisBindingHandle, IN NDIS_HANDLE MacReceiveContext, IN UINT ByteOffset, IN UINT BytesToTransfer, IN OUT PNDIS_PACKET Packet, OUT PUINT BytesTransferred)

VOID NTAPI	NdisReEnumerateProtocolBindings (IN NDIS_HANDLE NdisProtocolHandle)

VOID EXPORT	NdisGetDriverHandle (IN PNDIS_HANDLE NdisBindingHandle, OUT PNDIS_HANDLE NdisDriverHandle)

Variables
LIST_ENTRY	ProtocolListHead

KSPIN_LOCK	ProtocolListLock

Macro Definition Documentation

◆ LINKAGE_KEY

#define LINKAGE_KEY L"\\Linkage"

Definition at line 16 of file protocol.c.

◆ PARAMETERS_KEY

#define PARAMETERS_KEY L"\\Parameters\\"

Definition at line 17 of file protocol.c.

◆ SERVICES_KEY

#define SERVICES_KEY L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"

Definition at line 15 of file protocol.c.

◆ WORKER_TEST

#define WORKER_TEST 0

Definition at line 22 of file protocol.c.

Typedef Documentation

◆ DMA_CONTEXT

typedef struct _DMA_CONTEXT DMA_CONTEXT

◆ PDMA_CONTEXT

typedef struct _DMA_CONTEXT * PDMA_CONTEXT

Function Documentation

◆ LocateAdapterBindingByName()

PADAPTER_BINDING NTAPI LocateAdapterBindingByName	(	IN PPROTOCOL_BINDING	ProtocolBinding,
		IN PNDIS_STRING	AdapterName
	)

Definition at line 878 of file protocol.c.

{
    PLIST_ENTRY CurrentEntry;
    PADAPTER_BINDING AdapterBinding;
    KIRQL OldIrql;
 
    KeAcquireSpinLock(&ProtocolBinding->Lock, &OldIrql);
 
    CurrentEntry = ProtocolBinding->AdapterListHead.Flink;
 
    while (CurrentEntry != &ProtocolBinding->AdapterListHead)
    {
         AdapterBinding = CONTAINING_RECORD(CurrentEntry, ADAPTER_BINDING, ProtocolListEntry);
 
         if (RtlCompareUnicodeString(AdapterName, &AdapterBinding->Adapter->NdisMiniportBlock.MiniportName, TRUE) == 0)
         {
             KeReleaseSpinLock(&ProtocolBinding->Lock, OldIrql);
             return AdapterBinding;
         }
 
         CurrentEntry = CurrentEntry->Flink;
    }
 
    KeReleaseSpinLock(&ProtocolBinding->Lock, OldIrql);
 
    return NULL;
}

Referenced by ndisBindMiniportsToProtocol().

◆ 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);
    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);
 
    ExFreePoolWithTag(RegistryPathStr, NDIS_TAG);
 
    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);
            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"));
                    ExFreePoolWithTag(KeyInformation, NDIS_TAG);
                    KeyInformation = NULL;
                }
            }
        }
    }
 
    if (!NT_SUCCESS(NtStatus))
    {
        NDIS_DbgPrint(MID_TRACE, ("Performing global bind for protocol '%wZ'\n", &ProtocolCharacteristics->Name));
 
        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)
    {
        ExFreePoolWithTag(KeyInformation, NDIS_TAG);
    }
}

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

◆ NdisCloseAdapter()

VOID EXPORT NdisCloseAdapter	(	OUT PNDIS_STATUS	Status,
		IN NDIS_HANDLE	NdisBindingHandle
	)

Definition at line 703 of file protocol.c.

{
    PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(NdisBindingHandle);
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    /* Remove from protocol's bound adapters list */
    ExInterlockedRemoveEntryList(&AdapterBinding->ProtocolListEntry, &AdapterBinding->ProtocolBinding->Lock);
 
    /* Remove protocol from adapter's bound protocols list */
    ExInterlockedRemoveEntryList(&AdapterBinding->AdapterListEntry, &AdapterBinding->Adapter->NdisMiniportBlock.Lock);
 
    ExFreePool(AdapterBinding);
 
    *Status = NDIS_STATUS_SUCCESS;
}

Referenced by BindAdapterByName(), LANUnregisterAdapter(), and UnbindAdapterByContext().

◆ NdisCompleteBindAdapter()

VOID EXPORT NdisCompleteBindAdapter	(	IN NDIS_HANDLE	BindAdapterContext,
		IN NDIS_STATUS	Status,
		IN NDIS_STATUS	OpenStatus
	)

Definition at line 193 of file protocol.c.

{
  PROTOCOL_BINDING *Protocol = (PROTOCOL_BINDING *)BindAdapterContext;
 
  if (!NT_SUCCESS(Status)) {
      NDIS_DbgPrint(MIN_TRACE, ("Binding failed (%x)\n", Status));
      return;
  }
 
  /* Put protocol binding struct on global list */
  ExInterlockedInsertTailList(&ProtocolListHead, &Protocol->ListEntry, &ProtocolListLock);
}

◆ NdisCompleteUnbindAdapter()

VOID EXPORT NdisCompleteUnbindAdapter	(	IN NDIS_HANDLE	UnbindAdapterContext,
		IN NDIS_STATUS	Status
	)

Definition at line 224 of file protocol.c.

{
  /* We probably need to do more here but for now we just do
   * the opposite of what NdisCompleteBindAdapter does
   */
 
  PROTOCOL_BINDING *Protocol = (PROTOCOL_BINDING *)UnbindAdapterContext;
 
  if (!NT_SUCCESS(Status)) {
      NDIS_DbgPrint(MIN_TRACE, ("Unbinding failed (%x)\n", Status));
      return;
  }
 
  ExInterlockedRemoveEntryList(&Protocol->ListEntry, &ProtocolListLock);
}

◆ NdisDeregisterProtocol()

VOID EXPORT NdisDeregisterProtocol	(	OUT PNDIS_STATUS	Status,
		IN NDIS_HANDLE	NdisProtocolHandle
	)

Definition at line 734 of file protocol.c.

{
    PPROTOCOL_BINDING Protocol = GET_PROTOCOL_BINDING(NdisProtocolHandle);
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    /* FIXME: Make sure no adapter bindings exist */
 
    /* Remove protocol from global list */
    ExInterlockedRemoveEntryList(&Protocol->ListEntry, &ProtocolListLock);
 
    ExFreePool(Protocol);
 
    *Status = NDIS_STATUS_SUCCESS;
}

Referenced by LANUnregisterProtocol().

◆ NdisGetDriverHandle()

VOID EXPORT NdisGetDriverHandle	(	IN PNDIS_HANDLE	NdisBindingHandle,
		OUT PNDIS_HANDLE	NdisDriverHandle
	)

Definition at line 1353 of file protocol.c.

{
    PADAPTER_BINDING Binding = (PADAPTER_BINDING)NdisBindingHandle;
 
    if (!Binding)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Bad binding handle\n"));
        *NdisDriverHandle = NULL;
        return;
    }
 
    *NdisDriverHandle = Binding->Adapter->NdisMiniportBlock.DriverHandle;
}

◆ 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().

◆ NdisIPwrQueryPower()

NTSTATUS NTAPI NdisIPwrQueryPower	(	IN PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 132 of file protocol.c.

{
  PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
  PNET_PNP_EVENT PnPEvent;
  PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
 
  ASSERT(Stack->Parameters.Power.Type == DevicePowerState);
 
  PnPEvent = ProSetupPnPEvent(NetEventQueryPower, &Stack->Parameters.Power.State, sizeof(NDIS_DEVICE_POWER_STATE));
  if (!PnPEvent) {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
      return NDIS_STATUS_RESOURCES;
  }
 
  return ProSendAndFreePnPEvent(Adapter, PnPEvent, Irp);
}

◆ NdisIPwrSetPower()

NTSTATUS NTAPI NdisIPwrSetPower	(	IN PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 111 of file protocol.c.

{
  PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
  PNET_PNP_EVENT PnPEvent;
  PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
 
  ASSERT(Stack->Parameters.Power.Type == DevicePowerState);
 
  PnPEvent = ProSetupPnPEvent(NetEventSetPower, &Stack->Parameters.Power.State, sizeof(NDIS_DEVICE_POWER_STATE));
  if (!PnPEvent) {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
      return NDIS_STATUS_RESOURCES;
  }
 
  return ProSendAndFreePnPEvent(Adapter, PnPEvent, Irp);
}

◆ NdisOpenAdapter()

VOID EXPORT NdisOpenAdapter	(	OUT PNDIS_STATUS	Status,
		OUT PNDIS_STATUS	OpenErrorStatus,
		OUT PNDIS_HANDLE	NdisBindingHandle,
		OUT PUINT	SelectedMediumIndex,
		IN PNDIS_MEDIUM	MediumArray,
		IN UINT	MediumArraySize,
		IN NDIS_HANDLE	NdisProtocolHandle,
		IN NDIS_HANDLE	ProtocolBindingContext,
		IN PNDIS_STRING	AdapterName,
		IN UINT	OpenOptions,
		IN PSTRING AddressingInformation	OPTIONAL
	)

Definition at line 764 of file protocol.c.

{
  UINT i;
  BOOLEAN Found;
  PLOGICAL_ADAPTER Adapter;
  PADAPTER_BINDING AdapterBinding;
  PPROTOCOL_BINDING Protocol = GET_PROTOCOL_BINDING(NdisProtocolHandle);
 
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  if(!NdisProtocolHandle)
    {
      NDIS_DbgPrint(MIN_TRACE, ("NdisProtocolHandle is NULL\n"));
      *OpenErrorStatus = *Status = NDIS_STATUS_FAILURE;
      return;
    }
 
  Adapter = MiniLocateDevice(AdapterName);
  if (!Adapter)
    {
      NDIS_DbgPrint(MIN_TRACE, ("Adapter not found.\n"));
      *Status = NDIS_STATUS_ADAPTER_NOT_FOUND;
      return;
    }
 
  /* Find the media type in the list provided by the protocol driver */
  Found = FALSE;
  for (i = 0; i < MediumArraySize; i++)
    {
      if (Adapter->NdisMiniportBlock.MediaType == MediumArray[i])
        {
          *SelectedMediumIndex = i;
          Found = TRUE;
          break;
        }
    }
 
  if (!Found)
    {
      NDIS_DbgPrint(MIN_TRACE, ("Medium is not supported.\n"));
      *Status = NDIS_STATUS_UNSUPPORTED_MEDIA;
      return;
    }
 
  /* Now that we have confirmed that the adapter can be opened, create a binding */
 
  AdapterBinding = ExAllocatePool(NonPagedPool, sizeof(ADAPTER_BINDING));
  if (!AdapterBinding)
    {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
      *Status = NDIS_STATUS_RESOURCES;
      return;
    }
 
  RtlZeroMemory(AdapterBinding, sizeof(ADAPTER_BINDING));
 
  AdapterBinding->ProtocolBinding        = Protocol;
  AdapterBinding->Adapter                = Adapter;
  AdapterBinding->NdisOpenBlock.ProtocolBindingContext = ProtocolBindingContext;
 
  /* Set fields required by some NDIS macros */
  AdapterBinding->NdisOpenBlock.BindingHandle = (NDIS_HANDLE)AdapterBinding;
 
  /* Set handlers (some NDIS macros require these) */
 
  AdapterBinding->NdisOpenBlock.RequestHandler      = ProRequest;
  AdapterBinding->NdisOpenBlock.ResetHandler        = ProReset;
  AdapterBinding->NdisOpenBlock.SendHandler         = ProSend;
  AdapterBinding->NdisOpenBlock.SendPacketsHandler  = ProSendPackets;
  AdapterBinding->NdisOpenBlock.TransferDataHandler = ProTransferData;
 
  AdapterBinding->NdisOpenBlock.RequestCompleteHandler =
    Protocol->Chars.RequestCompleteHandler;
 
  /* Put on protocol's bound adapters list */
  ExInterlockedInsertTailList(&Protocol->AdapterListHead, &AdapterBinding->ProtocolListEntry, &Protocol->Lock);
 
  /* Put protocol on adapter's bound protocols list */
  NDIS_DbgPrint(MAX_TRACE, ("acquiring miniport block lock\n"));
  ExInterlockedInsertTailList(&Adapter->ProtocolListHead, &AdapterBinding->AdapterListEntry, &Adapter->NdisMiniportBlock.Lock);
 
  *NdisBindingHandle = (NDIS_HANDLE)AdapterBinding;
 
  *Status = NDIS_STATUS_SUCCESS;
}

Referenced by BindAdapterByName(), and LANRegisterAdapter().

◆ NdisReEnumerateProtocolBindings()

VOID NTAPI NdisReEnumerateProtocolBindings ( IN NDIS_HANDLE NdisProtocolHandle )

Definition at line 1340 of file protocol.c.

{
    NDIS_STATUS NdisStatus;
 
    ndisBindMiniportsToProtocol(&NdisStatus, NdisProtocolHandle);
}

◆ NdisRegisterProtocol()

VOID EXPORT NdisRegisterProtocol	(	OUT PNDIS_STATUS	Status,
		OUT PNDIS_HANDLE	NdisProtocolHandle,
		IN PNDIS_PROTOCOL_CHARACTERISTICS	ProtocolCharacteristics,
		IN UINT	CharacteristicsLength
	)

Definition at line 1114 of file protocol.c.

{
  PPROTOCOL_BINDING Protocol;
  NTSTATUS NtStatus;
  UINT MinSize;
  PNET_PNP_EVENT PnPEvent;
 
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  *NdisProtocolHandle = NULL;
 
  /* first validate the PROTOCOL_CHARACTERISTICS */
  switch (ProtocolCharacteristics->MajorNdisVersion)
    {
    case 0x03:
      /* we don't really want to support ndis3 drivers - so we complain for now */
      NDIS_DbgPrint(MID_TRACE, ("NDIS 3 protocol attempting to register\n"));
      MinSize = sizeof(NDIS30_PROTOCOL_CHARACTERISTICS);
      break;
 
    case 0x04:
      MinSize = sizeof(NDIS40_PROTOCOL_CHARACTERISTICS);
      break;
 
    case 0x05:
      /* Identical for both NDIS50 and NDIS51 */
      MinSize = sizeof(NDIS50_PROTOCOL_CHARACTERISTICS);
      break;
 
    default:
      *Status = NDIS_STATUS_BAD_VERSION;
      NDIS_DbgPrint(MIN_TRACE, ("Incorrect characteristics size\n"));
      return;
    }
 
  if (CharacteristicsLength < MinSize)
    {
      NDIS_DbgPrint(MIN_TRACE, ("Bad protocol characteristics.\n"));
      *Status = NDIS_STATUS_BAD_CHARACTERISTICS;
      return;
    }
 
  /* set up the protocol block */
  Protocol = ExAllocatePool(NonPagedPool, sizeof(PROTOCOL_BINDING));
  if (!Protocol)
    {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
      *Status = NDIS_STATUS_RESOURCES;
      return;
    }
 
  RtlZeroMemory(Protocol, sizeof(PROTOCOL_BINDING));
  RtlCopyMemory(&Protocol->Chars, ProtocolCharacteristics, MinSize);
 
  NtStatus = RtlUpcaseUnicodeString(&Protocol->Chars.Name, &ProtocolCharacteristics->Name, TRUE);
  if (!NT_SUCCESS(NtStatus))
    {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
      ExFreePool(Protocol);
      *Status = NDIS_STATUS_RESOURCES;
      return;
    }
 
  KeInitializeSpinLock(&Protocol->Lock);
 
  InitializeListHead(&Protocol->AdapterListHead);
 
  /* We must set this before the call to ndisBindMiniportsToProtocol because the protocol's
   * BindAdapter handler might need it */
 
  *NdisProtocolHandle = Protocol;
 
  ndisBindMiniportsToProtocol(Status, Protocol);
 
  /* Should we only send this if ndisBindMiniportsToProtocol succeeds? */
  PnPEvent = ProSetupPnPEvent(NetEventBindsComplete, NULL, 0);
  if (PnPEvent)
  {
      if (Protocol->Chars.PnPEventHandler)
      {
          /* We call this with a NULL binding context because it affects all bindings */
          NtStatus = (*Protocol->Chars.PnPEventHandler)(NULL,
                                                        PnPEvent);
 
          /* FIXME: We don't support this yet */
          ASSERT(NtStatus != NDIS_STATUS_PENDING);
      }
 
      ExFreePool(PnPEvent);
  }
 
  if (*Status == NDIS_STATUS_SUCCESS) {
      ExInterlockedInsertTailList(&ProtocolListHead, &Protocol->ListEntry, &ProtocolListLock);
  } else {
      NDIS_DbgPrint(MIN_TRACE, ("Binding failed (%x)\n", *Status));
      ExFreePool(Protocol);
      *NdisProtocolHandle = NULL;
  }
}

Referenced by DriverEntry(), and LANRegisterProtocol().

◆ NdisRequest()

VOID EXPORT NdisRequest	(	OUT PNDIS_STATUS	Status,
		IN NDIS_HANDLE	NdisBindingHandle,
		IN PNDIS_REQUEST	NdisRequest
	)

Definition at line 1239 of file protocol.c.

{
    *Status = ProRequest(NdisBindingHandle, NdisRequest);
}

◆ NdisReset()

VOID EXPORT NdisReset	(	OUT PNDIS_STATUS	Status,
		IN NDIS_HANDLE	NdisBindingHandle
	)

Definition at line 1259 of file protocol.c.

{
    *Status = ProReset(NdisBindingHandle);
}

◆ NdisSend()

VOID EXPORT NdisSend	(	OUT PNDIS_STATUS	Status,
		IN NDIS_HANDLE	NdisBindingHandle,
		IN PNDIS_PACKET	Packet
	)

Definition at line 1272 of file protocol.c.

{
    *Status = ProSend(NdisBindingHandle, Packet);
}

Referenced by LANTransmit(), and NduDispatchWrite().

◆ NdisSendPackets()

VOID EXPORT NdisSendPackets	(	IN NDIS_HANDLE	NdisBindingHandle,
		IN PPNDIS_PACKET	PacketArray,
		IN UINT	NumberOfPackets
	)

Definition at line 1293 of file protocol.c.

{
    ProSendPackets(NdisBindingHandle, PacketArray, NumberOfPackets);
}

◆ NdisTransferData()

VOID EXPORT NdisTransferData	(	OUT PNDIS_STATUS	Status,
		IN NDIS_HANDLE	NdisBindingHandle,
		IN NDIS_HANDLE	MacReceiveContext,
		IN UINT	ByteOffset,
		IN UINT	BytesToTransfer,
		IN OUT PNDIS_PACKET	Packet,
		OUT PUINT	BytesTransferred
	)

Definition at line 1307 of file protocol.c.

{
    *Status = ProTransferData(NdisBindingHandle,
                              MacReceiveContext,
                              ByteOffset,
                              BytesToTransfer,
                              Packet,
                              BytesTransferred);
}

Referenced by NduReceive(), and ProtocolReceive().

◆ 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().

◆ ProRequest()

NDIS_STATUS NTAPI ProRequest	(	IN NDIS_HANDLE	MacBindingHandle,
		IN PNDIS_REQUEST	NdisRequest
	)

Definition at line 308 of file protocol.c.

{
  PADAPTER_BINDING AdapterBinding;
  PLOGICAL_ADAPTER Adapter;
  PNDIS_REQUEST_MAC_BLOCK MacBlock = (PNDIS_REQUEST_MAC_BLOCK)NdisRequest->MacReserved;
 
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  ASSERT(MacBindingHandle);
  AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
 
  ASSERT(AdapterBinding->Adapter);
  Adapter = AdapterBinding->Adapter;
 
  MacBlock->Binding = &AdapterBinding->NdisOpenBlock;
 
#if WORKER_TEST
  MiniQueueWorkItem(Adapter, NdisWorkItemRequest, NdisRequest, FALSE);
  return NDIS_STATUS_PENDING;
#else
  if (MiniIsBusy(Adapter, NdisWorkItemRequest)) {
      MiniQueueWorkItem(Adapter, NdisWorkItemRequest, NdisRequest, FALSE);
      return NDIS_STATUS_PENDING;
  }
 
  return MiniDoRequest(Adapter, NdisRequest);
#endif
}

Referenced by NdisOpenAdapter(), and NdisRequest().

◆ ProReset()

NDIS_STATUS NTAPI ProReset ( IN NDIS_HANDLE MacBindingHandle )

Definition at line 349 of file protocol.c.

{
    PADAPTER_BINDING AdapterBinding = MacBindingHandle;
 
    /* FIXME: Wait for all packets to be sent */
 
    return MiniReset(AdapterBinding->Adapter);
}

Referenced by NdisOpenAdapter(), and NdisReset().

◆ ProSend()

NDIS_STATUS NTAPI ProSend	(	IN NDIS_HANDLE	MacBindingHandle,
		IN PNDIS_PACKET	Packet
	)

Definition at line 473 of file protocol.c.

{
  PADAPTER_BINDING AdapterBinding;
  PLOGICAL_ADAPTER Adapter;
  PNDIS_BUFFER NdisBuffer;
  PDMA_CONTEXT Context;
  NDIS_STATUS NdisStatus;
  UINT PacketLength;
  KIRQL OldIrql;
 
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  ASSERT(MacBindingHandle);
  AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
 
  ASSERT(AdapterBinding);
  Adapter = AdapterBinding->Adapter;
 
  ASSERT(Adapter);
 
  /* if the following is not true, KeRaiseIrql() below will break */
  ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
 
  /* XXX what is this crazy black magic? */
  Packet->Reserved[1] = (ULONG_PTR)MacBindingHandle;
 
  /*
   * Test the packet to see if it is a MAC loopback.
   *
   * We may have to loop this packet if miniport cannot.
   * If dest MAC address of packet == MAC address of adapter,
   * this is a loopback frame.
   */
 
  if ((Adapter->NdisMiniportBlock.MacOptions & NDIS_MAC_OPTION_NO_LOOPBACK) &&
      MiniAdapterHasAddress(Adapter, Packet))
    {
#if WORKER_TEST
        MiniQueueWorkItem(Adapter, NdisWorkItemSendLoopback, Packet, FALSE);
        return NDIS_STATUS_PENDING;
#else
        return ProIndicatePacket(Adapter, Packet);
#endif
    } else {
        if (Adapter->NdisMiniportBlock.ScatterGatherListSize != 0)
        {
            NDIS_DbgPrint(MID_TRACE, ("Using Scatter/Gather DMA\n"));
 
            NdisQueryPacket(Packet,
                            NULL,
                            NULL,
                            &NdisBuffer,
                            &PacketLength);
 
            Context = ExAllocatePool(NonPagedPool, sizeof(DMA_CONTEXT));
            if (!Context) {
                NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
                return NDIS_STATUS_RESOURCES;
            }
 
            Context->Adapter = Adapter;
            Context->Packet = Packet;
 
            KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
 
            KeFlushIoBuffers(NdisBuffer, FALSE, TRUE);
 
            NdisStatus = Adapter->NdisMiniportBlock.SystemAdapterObject->DmaOperations->GetScatterGatherList(
                          Adapter->NdisMiniportBlock.SystemAdapterObject,
                          Adapter->NdisMiniportBlock.PhysicalDeviceObject,
                          NdisBuffer,
                          MmGetMdlVirtualAddress(NdisBuffer),
                          PacketLength,
                          ScatterGatherSendPacket,
                          Context,
                          TRUE);
 
            KeLowerIrql(OldIrql);
 
            if (!NT_SUCCESS(NdisStatus)) {
                NDIS_DbgPrint(MIN_TRACE, ("GetScatterGatherList failed! (%x)\n", NdisStatus));
                return NdisStatus;
            }
 
            return NDIS_STATUS_PENDING;
        }
 
 
        return proSendPacketToMiniport(Adapter, Packet);
    }
}

Referenced by NdisOpenAdapter(), and NdisSend().

◆ ProSendAndFreePnPEvent()

NDIS_STATUS ProSendAndFreePnPEvent	(	PLOGICAL_ADAPTER	Adapter,
		PNET_PNP_EVENT	PnPEvent,
		PIRP	Irp
	)

Definition at line 66 of file protocol.c.

{
  PLIST_ENTRY CurrentEntry;
  NDIS_STATUS Status;
  PADAPTER_BINDING AdapterBinding;
 
  CurrentEntry = Adapter->ProtocolListHead.Flink;
 
  while (CurrentEntry != &Adapter->ProtocolListHead)
  {
     AdapterBinding = CONTAINING_RECORD(CurrentEntry, ADAPTER_BINDING, AdapterListEntry);
 
     Status = (*AdapterBinding->ProtocolBinding->Chars.PnPEventHandler)(
      AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
      PnPEvent);
 
     if (Status == NDIS_STATUS_PENDING)
     {
         IoMarkIrpPending(Irp);
         /* Yes, I know this is stupid */
         PnPEvent->NdisReserved[0] = (ULONG_PTR)Irp;
         PnPEvent->NdisReserved[1] = (ULONG_PTR)CurrentEntry->Flink;
         return NDIS_STATUS_PENDING;
     }
     else if (Status != NDIS_STATUS_SUCCESS)
     {
         if (PnPEvent->Buffer) ExFreePool(PnPEvent->Buffer);
         ExFreePool(PnPEvent);
         return Status;
     }
 
     CurrentEntry = CurrentEntry->Flink;
  }
 
  if (PnPEvent->Buffer) ExFreePool(PnPEvent->Buffer);
  ExFreePool(PnPEvent);
 
  return NDIS_STATUS_SUCCESS;
}

Referenced by NdisIPnPCancelStopDevice(), NdisIPnPQueryStopDevice(), NdisIPwrQueryPower(), and NdisIPwrSetPower().

◆ 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().

◆ ProSetupPnPEvent()

PNET_PNP_EVENT ProSetupPnPEvent	(	NET_PNP_EVENT_CODE	EventCode,
		PVOID	EventBuffer,
		ULONG	EventBufferLength
	)

Definition at line 30 of file protocol.c.

{
    PNET_PNP_EVENT PnPEvent;
 
    PnPEvent = ExAllocatePool(PagedPool, sizeof(NET_PNP_EVENT));
    if (!PnPEvent) {
        NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
        return NULL;
    }
 
    RtlZeroMemory(PnPEvent, sizeof(NET_PNP_EVENT));
 
    PnPEvent->NetEvent = EventCode;
 
    if (EventBuffer != NULL)
    {
        PnPEvent->Buffer = ExAllocatePool(PagedPool, EventBufferLength);
        if (!PnPEvent->Buffer)
        {
            NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
            ExFreePool(PnPEvent);
            return NULL;
        }
 
        PnPEvent->BufferLength = EventBufferLength;
 
        RtlCopyMemory(PnPEvent->Buffer, EventBuffer, PnPEvent->BufferLength);
    }
 
    return PnPEvent;
}

Referenced by NdisIPnPCancelStopDevice(), NdisIPnPQueryStopDevice(), NdisIPwrQueryPower(), NdisIPwrSetPower(), and NdisRegisterProtocol().

◆ ProTransferData()

NDIS_STATUS NTAPI ProTransferData	(	IN NDIS_HANDLE	MacBindingHandle,
		IN NDIS_HANDLE	MacReceiveContext,
		IN UINT	ByteOffset,
		IN UINT	BytesToTransfer,
		IN OUT PNDIS_PACKET	Packet,
		OUT PUINT	BytesTransferred
	)

Definition at line 639 of file protocol.c.

{
    PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
    PLOGICAL_ADAPTER Adapter        = AdapterBinding->Adapter;
    NDIS_STATUS Status;
    KIRQL OldIrql;
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    /* FIXME: Interrupts must be disabled for adapter */
    /* XXX sd - why is that true? */
 
    if (Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()]) {
    NDIS_DbgPrint(MAX_TRACE, ("LoopPacket\n"));
        /* NDIS is responsible for looping this packet */
        NdisCopyFromPacketToPacket(Packet,
                                   ByteOffset + Adapter->MediumHeaderSize,
                                   BytesToTransfer + Adapter->MediumHeaderSize,
                                   Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()],
                                   0,
                                   BytesTransferred);
        return NDIS_STATUS_SUCCESS;
    }
 
    ASSERT(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.TransferDataHandler);
 
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
 
    Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.TransferDataHandler)(
        Packet,
        BytesTransferred,
        Adapter->NdisMiniportBlock.MiniportAdapterContext,
        MacReceiveContext,
        ByteOffset,
        BytesToTransfer);
 
    KeLowerIrql(OldIrql);
 
    return Status;
}

Referenced by NdisOpenAdapter(), and NdisTransferData().

◆ ScatterGatherSendPacket()

VOID NTAPI ScatterGatherSendPacket	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PSCATTER_GATHER_LIST	ScatterGather,
		IN PVOID	Context
	)

Definition at line 360 of file protocol.c.

{
   PDMA_CONTEXT DmaContext = Context;
   PLOGICAL_ADAPTER Adapter = DmaContext->Adapter;
   PNDIS_PACKET Packet = DmaContext->Packet;
   NDIS_STATUS Status;
 
   NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
   NDIS_PER_PACKET_INFO_FROM_PACKET(Packet,
                                    ScatterGatherListPacketInfo) = ScatterGather;
 
   Status = proSendPacketToMiniport(Adapter, Packet);
 
   if (Status != NDIS_STATUS_PENDING) {
       NDIS_DbgPrint(MAX_TRACE, ("Completing packet.\n"));
       MiniSendComplete(Adapter,
                        Packet,
                        Status);
   }
 
   ExFreePool(DmaContext);
}

Referenced by ProSend().

Variable Documentation

◆ ProtocolListHead

LIST_ENTRY ProtocolListHead

Definition at line 19 of file protocol.c.

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

◆ ProtocolListLock

KSPIN_LOCK ProtocolListLock

Definition at line 20 of file protocol.c.

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

Classes

Macros

Typedefs

Functions

Variables