- Merge aicom-network-fixes up to r36740
authorCameron Gutman <aicommander@gmail.com>
Mon, 13 Oct 2008 01:07:37 +0000 (01:07 +0000)
committerCameron Gutman <aicommander@gmail.com>
Mon, 13 Oct 2008 01:07:37 +0000 (01:07 +0000)
svn path=/trunk/; revision=36741

1  2 
reactos/drivers/network/dd/ne2000/include/ne2000.h
reactos/drivers/network/dd/ne2000/ne2000/main.c
reactos/drivers/network/dd/pcnet/pcnet.c
reactos/drivers/network/ndis/ndis/miniport.c
reactos/drivers/network/ndis/ndis/object.c
reactos/drivers/network/ndis/ndis/protocol.c
reactos/drivers/network/ndis/ndis/workitem.c
reactos/drivers/network/tcpip/datalink/lan.c
reactos/include/ddk/ndis.h
reactos/lib/drivers/ip/network/neighbor.c
reactos/lib/drivers/ip/network/transmit.c

index 0def256,0000000..0959b00
mode 100644,000000..100644
--- /dev/null
@@@ -1,1034 -1,0 +1,1051 @@@
-       }
 +/*
 + * COPYRIGHT:   See COPYING in the top level directory
 + * PROJECT:     ReactOS Novell Eagle 2000 driver
 + * FILE:        ne2000/main.c
 + * PURPOSE:     Driver entry point
 + * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
 + * REVISIONS:
 + *   CSH 27/08-2000 Created
 + */
 +#include <ne2000.h>
 +#include <debug.h>
 +
 +NTSTATUS
 +#ifndef _MSC_VER
 +STDCALL
 +#endif
 +DriverEntry(
 +    PDRIVER_OBJECT DriverObject,
 +    PUNICODE_STRING RegistryPath);
 +
 +
 +#ifdef DBG
 +
 +/* See debug.h for debug/trace constants */
 +ULONG DebugTraceLevel = 0;
 +
 +#endif /* DBG */
 +
 +
 +/* List of supported OIDs */
 +static ULONG MiniportOIDList[] = {
 +    OID_GEN_SUPPORTED_LIST,
 +    OID_GEN_HARDWARE_STATUS,
 +    OID_GEN_MEDIA_SUPPORTED,
 +    OID_GEN_MEDIA_IN_USE,
 +    OID_GEN_MAXIMUM_LOOKAHEAD,
 +    OID_GEN_MAXIMUM_FRAME_SIZE,
 +    OID_GEN_LINK_SPEED,
 +    OID_GEN_TRANSMIT_BUFFER_SPACE,
 +    OID_GEN_RECEIVE_BUFFER_SPACE,
 +    OID_GEN_TRANSMIT_BLOCK_SIZE,
 +    OID_GEN_RECEIVE_BLOCK_SIZE,
 +    OID_GEN_VENDOR_ID,
 +    OID_GEN_VENDOR_DESCRIPTION,
 +    OID_GEN_VENDOR_DRIVER_VERSION,
 +    OID_GEN_CURRENT_PACKET_FILTER,
 +    OID_GEN_CURRENT_LOOKAHEAD,
 +    OID_GEN_DRIVER_VERSION,
 +    OID_GEN_MAXIMUM_TOTAL_SIZE,
 +    OID_GEN_PROTOCOL_OPTIONS,
 +    OID_GEN_MAC_OPTIONS,
 +    OID_GEN_MEDIA_CONNECT_STATUS,
 +    OID_GEN_MAXIMUM_SEND_PACKETS,
 +    OID_802_3_PERMANENT_ADDRESS,
 +    OID_802_3_CURRENT_ADDRESS,
 +    OID_802_3_MULTICAST_LIST,
 +    OID_802_3_MAXIMUM_LIST_SIZE,
 +    OID_802_3_MAC_OPTIONS
 +};
 +
 +DRIVER_INFORMATION      DriverInfo = {0};
 +NDIS_PHYSICAL_ADDRESS   HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
 +
 +
 +static BOOLEAN STDCALL MiniportCheckForHang(
 +    IN  NDIS_HANDLE MiniportAdapterContext)
 +/*
 + * FUNCTION: Examines if an adapter has hung
 + * ARGUMENTS:
 + *     MiniportAdapterContext = Pointer to adapter context area
 + * RETURNS:
 + *     TRUE if the adapter has hung, FALSE if not
 + */
 +{
 +    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 +
 +    return FALSE;
 +}
 +
 +
 +static VOID STDCALL MiniportDisableInterrupt(
 +    IN  NDIS_HANDLE MiniportAdapterContext)
 +/*
 + * FUNCTION: Disables interrupts from an adapter
 + * ARGUMENTS:
 + *     MiniportAdapterContext = Pointer to adapter context area
 + */
 +{
 +    NDIS_DbgPrint(MAX_TRACE, ("Called. (MiniportDisableInterrupt).\n"));
 +#ifndef NOCARD
 +    NICDisableInterrupts((PNIC_ADAPTER)MiniportAdapterContext);
 +#endif
 +}
 +
 +
 +static VOID STDCALL MiniportEnableInterrupt(
 +    IN  NDIS_HANDLE MiniportAdapterContext)
 +/*
 + * FUNCTION: Enables interrupts from an adapter
 + * ARGUMENTS:
 + *     MiniportAdapterContext = Pointer to adapter context area
 + */
 +{
 +    NDIS_DbgPrint(MAX_TRACE, ("Called. (MiniportEnableInterrupt).\n"));
 +#ifndef NOCARD
 +    NICEnableInterrupts((PNIC_ADAPTER)MiniportAdapterContext);
 +#endif
 +}
 +
 +
 +static VOID STDCALL MiniportHalt(
 +    IN  NDIS_HANDLE MiniportAdapterContext)
 +/*
 + * FUNCTION: Deallocates resources for and halts an adapter
 + * ARGUMENTS:
 + *     MiniportAdapterContext = Pointer to adapter context area
 + */
 +{
 +    PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
 +
 +    ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 +#ifndef NOCARD
 +    /* Stop the NIC */
 +    NICStop(Adapter);
 +#endif
 +    /* Wait for any DPCs to complete. FIXME: Use something else */
 +    NdisStallExecution(250000);
 +
 +    if (Adapter->InterruptRegistered)
 +        /* Deregister interrupt */
 +        NdisMDeregisterInterrupt(&Adapter->Interrupt);
 +
 +    if (Adapter->IOPortRangeRegistered)
 +        /* Deregister I/O port range */
 +        NdisMDeregisterIoPortRange(
 +            Adapter->MiniportAdapterHandle,
 +            Adapter->IoBaseAddress,
 +            0x20,
 +            Adapter->IOBase);
 +
++    if (Adapter->ShutdownHandlerRegistered)
++        NdisMDeregisterAdapterShutdownHandler(Adapter->MiniportAdapterHandle);
++
 +    /* Remove adapter from global adapter list */
 +    if ((&Adapter->ListEntry)->Blink != NULL) {
 +        RemoveEntryList(&Adapter->ListEntry);
++    }
 +
 +    /* Free adapter context area */
 +    NdisFreeMemory(Adapter, sizeof(NIC_ADAPTER), 0);
 +}
 +
 +
 +static VOID STDCALL MiQueryResources(
 +    OUT PNDIS_STATUS    Status,
 +    IN  PNIC_ADAPTER    Adapter,
 +    IN  NDIS_HANDLE     WrapperConfigurationContext)
 +{
 +    PNDIS_RESOURCE_LIST AssignedResources;
 +    UINT BufferSize = 0;
 +    PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
 +    int i;
 +
 +    NdisMQueryAdapterResources(Status,
 +                               WrapperConfigurationContext,
 +                               NULL,
 +                               &BufferSize);
 +    if (*Status == NDIS_STATUS_SUCCESS)
 +        return;
 +
 +    *Status = NdisAllocateMemory((PVOID)&AssignedResources,
 +                                 BufferSize,
 +                                 0,
 +                                 HighestAcceptableMax);
 +    if (*Status != NDIS_STATUS_SUCCESS)
 +        return;
 +
 +    NdisMQueryAdapterResources(Status,
 +                               WrapperConfigurationContext,
 +                               AssignedResources,
 +                               &BufferSize);
 +    if (*Status != NDIS_STATUS_SUCCESS)
 +        return;
 +
 +    for (i = 0; i < AssignedResources->Count; i++)
 +    {
 +        Descriptor = AssignedResources->PartialDescriptors + i;
 +        switch (Descriptor->Type)
 +        {
 +            case CmResourceTypeInterrupt:
 +                 Adapter->InterruptLevel = Descriptor->u.Interrupt.Level;
 +                 Adapter->InterruptVector = Descriptor->u.Interrupt.Vector;
 +                 Adapter->InterruptShared = (Descriptor->ShareDisposition == CmResourceShareShared);
 +                 Adapter->InterruptMode = Descriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED ?
 +                                          NdisInterruptLatched : NdisInterruptLevelSensitive;
 +                 break;
 +            case CmResourceTypePort:
 +                 Adapter->IoBaseAddress = Descriptor->u.Port.Start.LowPart;
 +                 break;
 +        }
 +    }
 +}
 +
++VOID
++STDCALL
++MiniportShutdown(PVOID Context)
++{
++  #ifndef NOCARD
++    NICStop((PNIC_ADAPTER)Context);
++  #endif
++}
 +
 +static NDIS_STATUS STDCALL MiniportInitialize(
 +    OUT PNDIS_STATUS    OpenErrorStatus,
 +    OUT PUINT           SelectedMediumIndex,
 +    IN  PNDIS_MEDIUM    MediumArray,
 +    IN  UINT            MediumArraySize,
 +    IN  NDIS_HANDLE     MiniportAdapterHandle,
 +    IN  NDIS_HANDLE     WrapperConfigurationContext)
 +/*
 + * FUNCTION: Adapter initialization function
 + * ARGUMENTS:
 + *     OpenErrorStatus             = Address of buffer to place additional status information
 + *     SelectedMediumIndex         = Address of buffer to place selected medium index
 + *     MediumArray                 = Pointer to an array of NDIS_MEDIUMs
 + *     MediaArraySize              = Number of elements in MediumArray
 + *     MiniportAdapterHandle       = Miniport adapter handle assigned by NDIS
 + *     WrapperConfigurationContext = Handle used to identify configuration context
 + * RETURNS:
 + *     Status of operation
 + */
 +{
 +    UINT i;
 +    NDIS_STATUS Status;
 +    PNIC_ADAPTER Adapter;
 +
 +    ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Called (Adapter %X).\n", MiniportAdapterHandle));
 +
 +    /* Search for 802.3 media which is the only one we support */
 +    for (i = 0; i < MediumArraySize; i++) {
 +        if (MediumArray[i] == NdisMedium802_3)
 +            break;
 +    }
 +
 +    if (i == MediumArraySize) {
 +        NDIS_DbgPrint(MIN_TRACE, ("No supported media.\n"));
 +        return NDIS_STATUS_UNSUPPORTED_MEDIA;
 +    }
 +
 +    *SelectedMediumIndex = i;
 +
 +    Status = NdisAllocateMemory((PVOID)&Adapter,
 +                                sizeof(NIC_ADAPTER),
 +                                0,
 +                                HighestAcceptableMax);
 +    if (Status != NDIS_STATUS_SUCCESS) {
 +        NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
 +        return Status;
 +    }
 +
 +    NdisZeroMemory(Adapter, sizeof(NIC_ADAPTER));
 +    Adapter->MiniportAdapterHandle  = MiniportAdapterHandle;
 +    Adapter->IoBaseAddress          = DRIVER_DEFAULT_IO_BASE_ADDRESS;
 +    Adapter->InterruptLevel         = DRIVER_DEFAULT_INTERRUPT_NUMBER;
 +    Adapter->InterruptVector        = DRIVER_DEFAULT_INTERRUPT_NUMBER;
 +    Adapter->InterruptShared        = DRIVER_DEFAULT_INTERRUPT_SHARED;
 +    Adapter->InterruptMode          = DRIVER_DEFAULT_INTERRUPT_MODE;
 +    Adapter->MaxMulticastListSize   = DRIVER_MAX_MULTICAST_LIST_SIZE;
 +    Adapter->InterruptMask          = DRIVER_INTERRUPT_MASK;
 +    Adapter->LookaheadSize          = DRIVER_MAXIMUM_LOOKAHEAD;
 +
 +    /* Query the resources from PnP. */
 +    MiQueryResources(&Status, Adapter, WrapperConfigurationContext);
 +
 +    /* Get the port, irq, and MAC address from registry if the PnP
 +       failed. */
 +    if (Status != NDIS_STATUS_SUCCESS)
 +    {
 +        PNDIS_CONFIGURATION_PARAMETER ConfigurationParameter;
 +        NDIS_HANDLE ConfigurationHandle;
 +        UNICODE_STRING Keyword;
 +        UINT *RegNetworkAddress = 0;
 +        UINT RegNetworkAddressLength = 0;
 +
 +        NdisOpenConfiguration(&Status, &ConfigurationHandle, WrapperConfigurationContext);
 +        if (Status == NDIS_STATUS_SUCCESS)
 +        {
 +            NdisInitUnicodeString(&Keyword, L"Irq");
 +            NdisReadConfiguration(&Status, &ConfigurationParameter, ConfigurationHandle, &Keyword, NdisParameterHexInteger);
 +            if(Status == NDIS_STATUS_SUCCESS)
 +            {
 +                NDIS_DbgPrint(MID_TRACE,("NdisReadConfiguration for Irq returned successfully, irq 0x%x\n",
 +                        ConfigurationParameter->ParameterData.IntegerData));
 +                Adapter->InterruptLevel =
 +                Adapter->InterruptVector = ConfigurationParameter->ParameterData.IntegerData;
 +            }
 +
 +            NdisInitUnicodeString(&Keyword, L"Port");
 +            NdisReadConfiguration(&Status, &ConfigurationParameter, ConfigurationHandle, &Keyword, NdisParameterHexInteger);
 +            if(Status == NDIS_STATUS_SUCCESS)
 +            {
 +                NDIS_DbgPrint(MID_TRACE,("NdisReadConfiguration for Port returned successfully, port 0x%x\n",
 +                        ConfigurationParameter->ParameterData.IntegerData));
 +                Adapter->IoBaseAddress = ConfigurationParameter->ParameterData.IntegerData;
 +            }
 +
 +            /* the returned copy of the data is owned by NDIS and will be released on NdisCloseConfiguration */
 +            NdisReadNetworkAddress(&Status, (PVOID *)&RegNetworkAddress, &RegNetworkAddressLength, ConfigurationHandle);
 +            if(Status == NDIS_STATUS_SUCCESS && RegNetworkAddressLength == DRIVER_LENGTH_OF_ADDRESS)
 +            {
 +                int i;
 +                NDIS_DbgPrint(MID_TRACE,("NdisReadNetworkAddress returned successfully, address %x:%x:%x:%x:%x:%x\n",
 +                        RegNetworkAddress[0], RegNetworkAddress[1], RegNetworkAddress[2], RegNetworkAddress[3],
 +                        RegNetworkAddress[4], RegNetworkAddress[5]));
 +                for(i = 0; i < DRIVER_LENGTH_OF_ADDRESS; i++)
 +                    Adapter->StationAddress[i] = RegNetworkAddress[i];
 +            }
 +
 +            NdisCloseConfiguration(ConfigurationHandle);
 +        }
 +        else
 +        {
 +            NDIS_DbgPrint(MIN_TRACE,("NdisOpenConfiguration returned error 0x%x\n", Status));
 +        }
 +    }
 +
 +     /* find the nic */
 +    if (!NICCheck(Adapter)) {
 +        NDIS_DbgPrint(MID_TRACE, ("No adapter found at (0x%X).\n", Adapter->IoBaseAddress));
 +        NdisFreeMemory(Adapter, sizeof(NIC_ADAPTER), 0);
 +        return NDIS_STATUS_ADAPTER_NOT_FOUND;
 +    } else
 +        NDIS_DbgPrint(MID_TRACE, ("Adapter found at (0x%X).\n", Adapter->IoBaseAddress));
 +
 +    NdisMSetAttributes(
 +        MiniportAdapterHandle,
 +        (NDIS_HANDLE)Adapter,
 +        FALSE,
 +        NdisInterfaceIsa);
 +
 +    Status = NdisMRegisterIoPortRange(
 +        (PVOID*)&Adapter->IOBase,
 +        MiniportAdapterHandle,
 +        Adapter->IoBaseAddress,
 +        0x20);
 +
 +    if (Status != NDIS_STATUS_SUCCESS) {
 +        NDIS_DbgPrint(MIN_TRACE, ("Cannot register port range. Status (0x%X).\n", Status));
 +        MiniportHalt((NDIS_HANDLE)Adapter);
 +        return Status;
 +    }
 +
 +    Adapter->IOPortRangeRegistered = TRUE;
 +
 +    /* Initialize NIC */
 +#ifndef NOCARD
 +    Status = NICInitialize(Adapter);
 +    if (Status != NDIS_STATUS_SUCCESS) {
 +        NDIS_DbgPrint(MIN_TRACE,("No NE2000 or compatible network adapter found at address 0x%X.\n",
 +            Adapter->IOBase));
 +
 +        NDIS_DbgPrint(MID_TRACE, ("Status (0x%X).\n", Status));
 +        MiniportHalt((NDIS_HANDLE)Adapter);
 +        return Status;
 +    }
 +
 +    NDIS_DbgPrint(MID_TRACE, ("BOARDDATA:\n"));
 +    for (i = 0; i < 4; i++) {
 +        NDIS_DbgPrint(MID_TRACE, ("%02X %02X %02X %02X\n",
 +            Adapter->SAPROM[i*4+0],
 +            Adapter->SAPROM[i*4+1],
 +            Adapter->SAPROM[i*4+2],
 +            Adapter->SAPROM[i*4+3]));
 +    }
 +
 +    /* Setup adapter structure */
 +    Adapter->TXStart   = ((ULONG_PTR)Adapter->RamBase >> 8);
 +    Adapter->TXCount   = DRIVER_DEFAULT_TX_BUFFER_COUNT;
 +    Adapter->TXFree    = DRIVER_DEFAULT_TX_BUFFER_COUNT;
 +    Adapter->TXCurrent = -1;
 +    Adapter->PageStart = Adapter->TXStart + Adapter->TXCount;
 +    Adapter->PageStop  = Adapter->TXStart + (Adapter->RamSize >> 8);
 +
 +    /* Initialize multicast address mask to accept all */
 +    for (i = 0; i < 8; i++)
 +        Adapter->MulticastAddressMask[i] = 0xFF;
 +
 +    /* Setup the NIC */
 +    NICSetup(Adapter);
 +
 +    NDIS_DbgPrint(MID_TRACE, ("TXStart (0x%X)  TXCount (0x%X)  PageStart (0x%X)\n",
 +        Adapter->TXStart,
 +        Adapter->TXCount,
 +        Adapter->PageStart));
 +
 +    NDIS_DbgPrint(MID_TRACE, ("PageStop (0x%X)  CurrentPage (0x%X)  NextPacket (0x%X).\n",
 +        Adapter->PageStop,
 +        Adapter->CurrentPage,
 +        Adapter->NextPacket));
 +#endif
 +    /* Register the interrupt */
 +    Status = NdisMRegisterInterrupt(
 +        &Adapter->Interrupt,
 +        MiniportAdapterHandle,
 +        Adapter->InterruptVector,
 +        Adapter->InterruptLevel,
 +        FALSE,
 +        Adapter->InterruptShared,
 +        Adapter->InterruptMode);
 +    if (Status != NDIS_STATUS_SUCCESS) {
 +        NDIS_DbgPrint(MIN_TRACE, ("Cannot register interrupt. Status (0x%X).\n", Status));
 +        MiniportHalt((NDIS_HANDLE)Adapter);
 +        return Status;
 +    }
 +
 +    Adapter->InterruptRegistered = TRUE;
 +#ifndef NOCARD
 +    /* Start the NIC */
 +    NICStart(Adapter);
 +#endif
++
++    /* Register the shutdown handler */
++    NdisMRegisterAdapterShutdownHandler(MiniportAdapterHandle, Adapter, MiniportShutdown);
++
++    Adapter->ShutdownHandlerRegistered = TRUE;
++
 +    /* Add adapter to the global adapter list */
 +    InsertTailList(&DriverInfo.AdapterListHead, &Adapter->ListEntry);
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 +
 +    return NDIS_STATUS_SUCCESS;
 +}
 +
 +
 +static VOID STDCALL MiniportISR(
 +    OUT PBOOLEAN    InterruptRecognized,
 +    OUT PBOOLEAN    QueueMiniportHandleInterrupt,
 +    IN  NDIS_HANDLE MiniportAdapterContext)
 +/*
 + * FUNCTION: Interrupt Service Routine for controlled adapters
 + * ARGUMENTS:
 + *     InterruptRecognized          = Address of buffer to place wether
 + *                                    the adapter generated the interrupt
 + *     QueueMiniportHandleInterrupt = Address of buffer to place wether
 + *                                    MiniportHandleInterrupt should be called
 + *     MiniportAdapterContext       = Pointer to adapter context area
 + * NOTES:
 + *     All pending interrupts are handled
 + */
 +{
 +    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 +
 +    NICDisableInterrupts((PNIC_ADAPTER)MiniportAdapterContext);
 +
 +    *InterruptRecognized          = TRUE;
 +    *QueueMiniportHandleInterrupt = TRUE;
 +}
 +
 +
 +static NDIS_STATUS STDCALL MiniportQueryInformation(
 +    IN  NDIS_HANDLE MiniportAdapterContext,
 +    IN  NDIS_OID    Oid,
 +    IN  PVOID       InformationBuffer,
 +    IN  ULONG       InformationBufferLength,
 +    OUT PULONG      BytesWritten,
 +    OUT PULONG      BytesNeeded)
 +/*
 + * FUNCTION: Handler to process queries
 + * ARGUMENTS:
 + *     MiniportAdapterContext  = Pointer to adapter context area
 + *     Oid                     = OID code designating query operation
 + *     InformationBuffer       = Address of return buffer
 + *     InformationBufferLength = Length of return buffer
 + *     BytesWritten            = Address of buffer to place number of bytes returned
 + *     BytesNeeded             = Address of buffer to place number of bytes needed
 + *                               in InformationBuffer for specified OID
 + * RETURNS:
 + *     Status of operation
 + */
 +{
 +    NDIS_STATUS Status;
 +    PVOID CopyFrom;
 +    UINT CopySize;
 +    ULONG GenericULONG;
 +    USHORT GenericUSHORT;
 +    NDIS_MEDIUM Medium   = NdisMedium802_3;
 +    PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
 +
 +    ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Called. Oid (0x%X).\n", Oid));
 +
 +    Status   = NDIS_STATUS_SUCCESS;
 +    CopyFrom = (PVOID)&GenericULONG;
 +    CopySize = sizeof(ULONG);
 +
 +    switch (Oid) {
 +    case OID_GEN_SUPPORTED_LIST:
 +        CopyFrom = (PVOID)&MiniportOIDList;
 +        CopySize = sizeof(MiniportOIDList);
 +        break;
 +    case OID_GEN_HARDWARE_STATUS:
 +        GenericULONG = (ULONG)NdisHardwareStatusReady;
 +        break;
 +    case OID_GEN_MEDIA_SUPPORTED:
 +    case OID_GEN_MEDIA_IN_USE:
 +        CopyFrom = (PVOID)&Medium;
 +        CopySize = sizeof(NDIS_MEDIUM);
 +        break;
 +    case OID_GEN_MAXIMUM_LOOKAHEAD:
 +        GenericULONG = DRIVER_MAXIMUM_LOOKAHEAD;
 +        break;
 +    case OID_GEN_MAXIMUM_FRAME_SIZE:
 +        GenericULONG = DRIVER_FRAME_SIZE - DRIVER_HEADER_SIZE;
 +        break;
 +    case OID_GEN_LINK_SPEED:
 +        GenericULONG = 100000;  /* 10Mbps */
 +        break;
 +    case OID_GEN_TRANSMIT_BUFFER_SPACE:
 +        GenericULONG = Adapter->TXCount * DRIVER_BLOCK_SIZE;
 +        break;
 +    case OID_GEN_RECEIVE_BUFFER_SPACE:
 +        GenericULONG = Adapter->RamSize -
 +                       (ULONG_PTR)Adapter->RamBase -
 +                       (Adapter->TXCount * DRIVER_BLOCK_SIZE);
 +        break;
 +    case OID_GEN_TRANSMIT_BLOCK_SIZE:
 +        GenericULONG = DRIVER_BLOCK_SIZE;
 +        break;
 +    case OID_GEN_RECEIVE_BLOCK_SIZE:
 +        GenericULONG = DRIVER_BLOCK_SIZE;
 +        break;
 +    case OID_GEN_VENDOR_ID:
 +        NdisMoveMemory(&GenericULONG, &Adapter->PermanentAddress, 3);
 +        GenericULONG &= 0xFFFFFF00;
 +        GenericULONG |= 0x01;
 +        break;
 +    case OID_GEN_VENDOR_DESCRIPTION:
 +        CopyFrom = (PVOID)&DRIVER_VENDOR_DESCRIPTION;
 +        CopySize = sizeof(DRIVER_VENDOR_DESCRIPTION);
 +        break;
 +    case OID_GEN_VENDOR_DRIVER_VERSION:
 +        GenericUSHORT = (USHORT)DRIVER_VENDOR_DRIVER_VERSION;
 +        CopyFrom      = (PVOID)&GenericUSHORT;
 +        CopySize      = sizeof(USHORT);
 +        break;
 +    case OID_GEN_CURRENT_PACKET_FILTER:
 +        GenericULONG = Adapter->PacketFilter;
 +        break;
 +    case OID_GEN_CURRENT_LOOKAHEAD:
 +        GenericULONG = Adapter->LookaheadSize;
 +        break;
 +    case OID_GEN_DRIVER_VERSION:
 +        GenericUSHORT = ((USHORT)DRIVER_NDIS_MAJOR_VERSION << 8) | DRIVER_NDIS_MINOR_VERSION;
 +        CopyFrom      = (PVOID)&GenericUSHORT;
 +        CopySize      = sizeof(USHORT);
 +        break;
 +    case OID_GEN_MAXIMUM_TOTAL_SIZE:
 +        GenericULONG = DRIVER_FRAME_SIZE;
 +        break;
 +    case OID_GEN_PROTOCOL_OPTIONS:
 +        NDIS_DbgPrint(MID_TRACE, ("OID_GEN_PROTOCOL_OPTIONS.\n"));
 +        Status = NDIS_STATUS_NOT_SUPPORTED;
 +        break;
 +    case OID_GEN_MAC_OPTIONS:
 +        GenericULONG = NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
 +                       NDIS_MAC_OPTION_RECEIVE_SERIALIZED  |
 +                       NDIS_MAC_OPTION_TRANSFERS_NOT_PEND  |
 +                       NDIS_MAC_OPTION_NO_LOOPBACK;
 +        break;
 +    case OID_GEN_MEDIA_CONNECT_STATUS:
 +        GenericULONG = (ULONG)NdisMediaStateConnected;
 +        break;
 +    case OID_GEN_MAXIMUM_SEND_PACKETS:
 +        GenericULONG = 1;
 +        break;
 +    case OID_802_3_PERMANENT_ADDRESS:
 +        CopyFrom = (PVOID)&Adapter->PermanentAddress;
 +        CopySize = DRIVER_LENGTH_OF_ADDRESS;
 +        break;
 +    case OID_802_3_CURRENT_ADDRESS:
 +        CopyFrom = (PVOID)&Adapter->StationAddress;
 +        CopySize = DRIVER_LENGTH_OF_ADDRESS;
 +        break;
 +    case OID_802_3_MULTICAST_LIST:
 +        NDIS_DbgPrint(MID_TRACE, ("OID_802_3_MULTICAST_LIST.\n"));
 +        Status = NDIS_STATUS_NOT_SUPPORTED;
 +        break;
 +    case OID_802_3_MAXIMUM_LIST_SIZE:
 +        GenericULONG = Adapter->MaxMulticastListSize;
 +        break;
 +    case OID_802_3_MAC_OPTIONS:
 +        NDIS_DbgPrint(MID_TRACE, ("OID_802_3_MAC_OPTIONS.\n"));
 +        Status = NDIS_STATUS_NOT_SUPPORTED;
 +        break;
 +    default:
 +        NDIS_DbgPrint(MIN_TRACE, ("Unknown OID (0x%X).\n", Oid));
 +        Status = NDIS_STATUS_INVALID_OID;
 +        break;
 +    }
 +
 +    if (Status == NDIS_STATUS_SUCCESS) {
 +        if (CopySize > InformationBufferLength) {
 +            *BytesNeeded  = (CopySize - InformationBufferLength);
 +            *BytesWritten = 0;
 +            Status        = NDIS_STATUS_INVALID_LENGTH;
 +        } else {
 +            NdisMoveMemory(InformationBuffer, CopyFrom, CopySize);
 +            *BytesWritten = CopySize;
 +            *BytesNeeded  = 0;
 +         }
 +    }
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Leaving. Status is (0x%X).\n", Status));
 +
 +    return Status;
 +}
 +
 +
 +static NDIS_STATUS STDCALL MiniportReconfigure(
 +    OUT PNDIS_STATUS    OpenErrorStatus,
 +    IN  NDIS_HANDLE     MiniportAdapterContext,
 +    IN  NDIS_HANDLE     WrapperConfigurationContext)
 +/*
 + * FUNCTION: Reconfigures an adapter
 + * ARGUMENTS:
 + *     OpenErrorStatus             = Address of buffer to place additional status information
 + *     MiniportAdapterContext      = Pointer to adapter context area
 + *     WrapperConfigurationContext = Handle used to identify configuration context
 + * RETURNS:
 + *     Status of operation
 + * NOTES:
 + *     Never called by NDIS library
 + */
 +{
 +    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 +
 +    return NDIS_STATUS_FAILURE;
 +}
 +
 +
 +
 +static NDIS_STATUS STDCALL MiniportReset(
 +    OUT PBOOLEAN    AddressingReset,
 +    IN  NDIS_HANDLE MiniportAdapterContext)
 +/*
 + * FUNCTION: Resets an adapter
 + * ARGUMENTS:
 + *     AddressingReset        = Address of a buffer to place value indicating
 + *                              wether NDIS library should call MiniportSetInformation
 + *                              to restore addressing information
 + *     MiniportAdapterContext = Pointer to adapter context area
 + * RETURNS:
 + *     Status of operation
 + */
 +{
 +    ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 +
 +    return NDIS_STATUS_FAILURE;
 +}
 +
 +
 +static NDIS_STATUS STDCALL MiniportSend(
 +    IN  NDIS_HANDLE     MiniportAdapterContext,
 +    IN  PNDIS_PACKET    Packet,
 +    IN  UINT            Flags)
 +/*
 + * FUNCTION: Transmits a packet
 + * ARGUMENTS:
 + *     MiniportAdapterContext = Pointer to adapter context area
 + *     Packet                 = Pointer to a packet descriptor specifying
 + *                              the data to be transmitted
 + *     Flags                  = Specifies optional packet flags
 + * RETURNS:
 + *     Status of operation
 + */
 +{
 +    PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
 +
 +    ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
 +
 +#ifndef NOCARD
 +    NDIS_DbgPrint(MID_TRACE, ("Queueing packet.\n"));
 +
 +    /* Queue the packet on the transmit queue */
 +    RESERVED(Packet)->Next = NULL;
 +    if (Adapter->TXQueueHead == NULL) {
 +        Adapter->TXQueueHead = Packet;
 +    } else {
 +        RESERVED(Adapter->TXQueueTail)->Next = Packet;
 +    }
 +
 +    Adapter->TXQueueTail = Packet;
 +
 +    /* Transmit the packet */
 +    NICTransmit(Adapter);
 +
 +    return NDIS_STATUS_PENDING;
 +#else
 +    return NDIS_STATUS_SUCCESS;
 +#endif
 +}
 +
 +
 +static NDIS_STATUS STDCALL MiniportSetInformation(
 +    IN  NDIS_HANDLE MiniportAdapterContext,
 +    IN  NDIS_OID    Oid,
 +    IN  PVOID       InformationBuffer,
 +    IN  ULONG       InformationBufferLength,
 +    OUT PULONG      BytesRead,
 +    OUT PULONG      BytesNeeded)
 +/*
 + * FUNCTION: Changes state information in the driver
 + * ARGUMENTS:
 + *     MiniportAdapterContext  = Pointer to adapter context area
 + *     Oid                     = OID code designating set operation
 + *     InformationBuffer       = Pointer to buffer with state information
 + *     InformationBufferLength = Length of InformationBuffer
 + *     BytesRead               = Address of buffer to place number of bytes read
 + *     BytesNeeded             = Address of buffer to place number of extra bytes
 + *                               needed in InformationBuffer for specified OID
 + * RETURNS:
 + *     Status of operation
 + */
 +{
 +    ULONG GenericULONG;
 +    NDIS_STATUS Status   = NDIS_STATUS_SUCCESS;
 +    PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
 +
 +    ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Called. Oid (0x%X).\n", Oid));
 +
 +    switch (Oid) {
 +    case OID_GEN_CURRENT_PACKET_FILTER:
 +        /* Verify length */
 +        if (InformationBufferLength < sizeof(ULONG)) {
 +            *BytesRead   = 0;
 +            *BytesNeeded = sizeof(ULONG) - InformationBufferLength;
 +            Status       = NDIS_STATUS_INVALID_LENGTH;
 +            break;
 +        }
 +
 +        NdisMoveMemory(&GenericULONG, InformationBuffer, sizeof(ULONG));
 +        /* Check for properties the driver don't support */
 +        if (GenericULONG &
 +           (NDIS_PACKET_TYPE_ALL_FUNCTIONAL |
 +            NDIS_PACKET_TYPE_FUNCTIONAL     |
 +            NDIS_PACKET_TYPE_GROUP          |
 +            NDIS_PACKET_TYPE_MAC_FRAME      |
 +            NDIS_PACKET_TYPE_SMT            |
 +            NDIS_PACKET_TYPE_SOURCE_ROUTING)) {
 +            *BytesRead   = 4;
 +            *BytesNeeded = 0;
 +            Status       = NDIS_STATUS_NOT_SUPPORTED;
 +            break;
 +        }
 +
 +        Adapter->PacketFilter = GenericULONG;
 +
 +        /* FIXME: Set filter on hardware */
 +
 +        break;
 +    case OID_GEN_CURRENT_LOOKAHEAD:
 +        /* Verify length */
 +        if (InformationBufferLength < sizeof(ULONG)) {
 +            *BytesRead   = 0;
 +            *BytesNeeded = sizeof(ULONG) - InformationBufferLength;
 +            Status = NDIS_STATUS_INVALID_LENGTH;
 +            break;
 +        }
 +
 +        NdisMoveMemory(&GenericULONG, InformationBuffer, sizeof(ULONG));
 +        if (GenericULONG > DRIVER_MAXIMUM_LOOKAHEAD)
 +            Status = NDIS_STATUS_INVALID_LENGTH;
 +        else
 +            Adapter->LookaheadSize = GenericULONG;
 +        break;
 +    case OID_802_3_MULTICAST_LIST:
 +        /* Verify length. Must be multiplum of hardware address length */
 +        if ((InformationBufferLength % DRIVER_LENGTH_OF_ADDRESS) != 0) {
 +            *BytesRead   = 0;
 +            *BytesNeeded = 0;
 +            Status       = NDIS_STATUS_INVALID_LENGTH;
 +            break;
 +        }
 +
 +        /* Set new multicast address list */
 +        NdisMoveMemory(Adapter->Addresses, InformationBuffer, InformationBufferLength);
 +
 +        /* FIXME: Update hardware */
 +
 +        break;
 +    default:
 +        NDIS_DbgPrint(MIN_TRACE, ("Invalid object ID (0x%X).\n", Oid));
 +        *BytesRead   = 0;
 +        *BytesNeeded = 0;
 +        Status       = NDIS_STATUS_INVALID_OID;
 +        break;
 +    }
 +
 +    if (Status == NDIS_STATUS_SUCCESS) {
 +        *BytesRead   = InformationBufferLength;
 +        *BytesNeeded = 0;
 +    }
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Leaving. Status (0x%X).\n", Status));
 +
 +    return Status;
 +}
 +
 +
 +static NDIS_STATUS STDCALL MiniportTransferData(
 +    OUT PNDIS_PACKET    Packet,
 +    OUT PUINT           BytesTransferred,
 +    IN  NDIS_HANDLE     MiniportAdapterContext,
 +    IN  NDIS_HANDLE     MiniportReceiveContext,
 +    IN  UINT            ByteOffset,
 +    IN  UINT            BytesToTransfer)
 +/*
 + * FUNCTION: Transfers data from a received frame into an NDIS packet
 + * ARGUMENTS:
 + *     Packet                 = Address of packet to copy received data into
 + *     BytesTransferred       = Address of buffer to place number of bytes transmitted
 + *     MiniportAdapterContext = Pointer to adapter context area
 + *     MiniportReceiveContext = Pointer to receive context area (actually NULL)
 + *     ByteOffset             = Offset within received packet to begin copying
 + *     BytesToTransfer        = Number of bytes to copy into packet
 + * RETURNS:
 + *     Status of operation
 + */
 +{
 +    PNDIS_BUFFER DstBuffer;
 +    UINT BytesCopied, BytesToCopy, DstSize;
 +    ULONG SrcData;
 +    PUCHAR DstData;
 +    UINT RecvStart;
 +    UINT RecvStop;
 +    PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
 +
 +    ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Called. Packet (0x%X)  ByteOffset (0x%X)  BytesToTransfer (%d).\n",
 +        Packet, ByteOffset, BytesToTransfer));
 +
 +    if (BytesToTransfer == 0) {
 +        *BytesTransferred = 0;
 +        return NDIS_STATUS_SUCCESS;
 +    }
 +
 +    RecvStart = Adapter->PageStart * DRIVER_BLOCK_SIZE;
 +    RecvStop  = Adapter->PageStop  * DRIVER_BLOCK_SIZE;
 +
 +    NdisQueryPacket(Packet, NULL, NULL, &DstBuffer, NULL);
 +    NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
 +
 +    SrcData = Adapter->PacketOffset + sizeof(DISCARD_HEADER) + ByteOffset;
 +    if (ByteOffset + sizeof(DISCARD_HEADER) + BytesToTransfer >
 +      Adapter->PacketHeader.PacketLength)
 +        BytesToTransfer = Adapter->PacketHeader.PacketLength -
 +          sizeof(DISCARD_HEADER) - ByteOffset;
 +
 +    /* Start copying the data */
 +    BytesCopied = 0;
 +    for (;;) {
 +        BytesToCopy = (DstSize < BytesToTransfer) ? DstSize : BytesToTransfer;
 +        if (SrcData + BytesToCopy > RecvStop)
 +            BytesToCopy = (RecvStop - SrcData);
 +
 +        NICReadData(Adapter, DstData, SrcData, BytesToCopy);
 +
 +        BytesCopied     += BytesToCopy;
 +        SrcData         += BytesToCopy;
 +        DstData          = (PUCHAR)((ULONG_PTR) DstData + BytesToCopy);
 +        BytesToTransfer -= BytesToCopy;
 +        if (BytesToTransfer == 0)
 +            break;
 +
 +        DstSize -= BytesToCopy;
 +        if (DstSize == 0) {
 +            /* No more bytes in destination buffer. Proceed to
 +               the next buffer in the destination buffer chain */
 +            NdisGetNextBuffer(DstBuffer, &DstBuffer);
 +            if (!DstBuffer)
 +                break;
 +
 +            NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
 +        }
 +
 +        if (SrcData == RecvStop)
 +            SrcData = RecvStart;
 +    }
 +
 +    NDIS_DbgPrint(MID_TRACE, ("Transferred (%d) bytes.\n", BytesToTransfer));
 +
 +    *BytesTransferred = BytesCopied;
 +
 +    return NDIS_STATUS_SUCCESS;
 +}
 +
 +
 +NTSTATUS
 +#ifndef _MSC_VER
 +STDCALL
 +#endif
 +DriverEntry(
 +    PDRIVER_OBJECT DriverObject,
 +    PUNICODE_STRING RegistryPath)
 +/*
 + * FUNCTION: Main driver entry point
 + * ARGUMENTS:
 + *     DriverObject = Pointer to a driver object for this driver
 + *     RegistryPath = Registry node for configuration parameters
 + * RETURNS:
 + *     Status of driver initialization
 + */
 +{
 +    NDIS_STATUS Status;
 +    NDIS_HANDLE NdisWrapperHandle;
 +    NDIS_MINIPORT_CHARACTERISTICS Miniport;
 +
 +    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 +
 +    NdisZeroMemory(&Miniport, sizeof(Miniport));
 +    Miniport.MajorNdisVersion           = DRIVER_NDIS_MAJOR_VERSION;
 +    Miniport.MinorNdisVersion           = DRIVER_NDIS_MINOR_VERSION;
 +    Miniport.CheckForHangHandler        = MiniportCheckForHang;
 +    Miniport.DisableInterruptHandler    = MiniportDisableInterrupt;
 +    Miniport.EnableInterruptHandler     = MiniportEnableInterrupt;
 +    Miniport.HaltHandler                = MiniportHalt;
 +    Miniport.HandleInterruptHandler     = MiniportHandleInterrupt;
 +    Miniport.InitializeHandler          = MiniportInitialize;
 +    Miniport.ISRHandler                 = MiniportISR;
 +    Miniport.QueryInformationHandler    = MiniportQueryInformation;
 +    Miniport.ReconfigureHandler         = MiniportReconfigure;
 +    Miniport.ResetHandler               = MiniportReset;
 +    Miniport.SendHandler                = MiniportSend;
 +    Miniport.SetInformationHandler      = MiniportSetInformation;
 +    Miniport.TransferDataHandler        = MiniportTransferData;
 +
 +    NdisMInitializeWrapper(&NdisWrapperHandle,
 +                           DriverObject,
 +                           RegistryPath,
 +                           NULL);
 +
 +    if (!NdisWrapperHandle) {
 +        NDIS_DbgPrint(MIN_TRACE, ("NdisMInitializeWrapper() failed\n"));
 +        return STATUS_UNSUCCESSFUL;
 +    }
 +
 +    DriverInfo.NdisWrapperHandle = NdisWrapperHandle;
 +    DriverInfo.NdisMacHandle     = NULL;
 +    InitializeListHead(&DriverInfo.AdapterListHead);
 +
 +    Status = NdisMRegisterMiniport(NdisWrapperHandle,
 +                                   &Miniport,
 +                                   sizeof(NDIS_MINIPORT_CHARACTERISTICS));
 +    if (Status != NDIS_STATUS_SUCCESS) {
 +        NDIS_DbgPrint(MIN_TRACE, ("NdisMRegisterMiniport() failed with status code (0x%X).\n", Status));
 +        NdisTerminateWrapper(NdisWrapperHandle, NULL);
 +        return STATUS_UNSUCCESSFUL;
 +    }
 +
 +    return STATUS_SUCCESS;
 +}
 +
 +#if 0
 +        /* while i'm here - some basic registry sanity checks */
 +        {
 +            /* write tests */
 +            NDIS_CONFIGURATION_PARAMETER ParameterValue;
 +
 +            ParameterValue.ParameterType = NdisParameterInteger;
 +            ParameterValue.ParameterData.IntegerData = 0x12345678;
 +            NdisInitUnicodeString(&Keyword, L"DwordTest");
 +            NdisWriteConfiguration(&Status, ConfigurationHandle, &Keyword, &ParameterValue);
 +
 +            if(Status != NDIS_STATUS_SUCCESS)
 +            {
 +                DbgPrint("ne2000!MiniportInitialize: failed to set DwordTest: 0x%x\n", Status);
 +                KeBugCheck(0);
 +            }
 +
 +            DbgPrint("ne2000!MiniportInitialize: DwordTest successfully set\n");
 +
 +            NdisInitUnicodeString(&Keyword, L"StringTest");
 +            ParameterValue.ParameterType = NdisParameterString;
 +            NdisInitUnicodeString(&ParameterValue.ParameterData.StringData, L"Testing123");
 +
 +            NdisWriteConfiguration(&Status, ConfigurationHandle, &Keyword, &ParameterValue);
 +
 +            if(Status != NDIS_STATUS_SUCCESS)
 +            {
 +                DbgPrint("ne2000!MiniportInitialize: failed to set StringTest: 0x%x\n", Status);
 +                KeBugCheck(0);
 +            }
 +
 +            DbgPrint("ne2000!MiniportInitialize: StringTest successfully set\n");
 +        }
 +
 +        {
 +            /* read back the test values */
 +            NDIS_CONFIGURATION_PARAMETER *ParameterValue = 0;
 +
 +            NdisInitUnicodeString(&Keyword, L"DwordTest");
 +            NdisReadConfiguration(&Status, &ParameterValue, ConfigurationHandle, &Keyword, NdisParameterInteger);
 +
 +            if(Status != NDIS_STATUS_SUCCESS)
 +            {
 +                DbgPrint("ne2000!MiniportInitialize: failed to read DwordTest: 0x%x\n", Status);
 +                KeBugCheck(0);
 +            }
 +
 +            if(ParameterValue->ParameterData.IntegerData != 0x12345678)
 +            {
 +                DbgPrint("ne2000!MiniportInitialize: DwordTest value is wrong: 0x%x\n",
 +                    ParameterValue->ParameterData.IntegerData);
 +                KeBugCheck(0);
 +            }
 +
 +            DbgPrint("ne2000!MiniportInitialize: DwordTest value was correctly read\n");
 +
 +            NdisInitUnicodeString(&Keyword, L"StringTest");
 +            NdisReadConfiguration(&Status, &ParameterValue, ConfigurationHandle, &Keyword, NdisParameterString);
 +
 +            if(Status != NDIS_STATUS_SUCCESS)
 +            {
 +                DbgPrint("ne2000!MiniportInitialize: failed to read StringTest: 0x%x\n", Status);
 +                KeBugCheck(0);
 +            }
 +
 +            if(wcsncmp(ParameterValue->ParameterData.StringData.Buffer, L"Testing123",
 +                    wcslen(L"Testing123")))
 +            {
 +                DbgPrint("ne2000!MiniportInitialize: StringTest value is wrong: %wZ\n",
 +                    &ParameterValue->ParameterData.StringData);
 +                KeBugCheck(0);
 +            }
 +
 +            DbgPrint("ne2000!MiniportInitialize: StringTest value was correctly read\n");
 +        }
 +
 +#endif
 +/* EOF */
index 41239f5,0000000..089369a
mode 100644,000000..100644
--- /dev/null
@@@ -1,5465 -1,0 +1,5478 @@@
 +/*
 + * ndis.h
 + *
 + * Network Device Interface Specification definitions
 + *
 + * This file is part of the w32api package.
 + *
 + * Contributors:
 + *   Created by Casper S. Hornstrup <chorns@users.sourceforge.net>
 + *
 + * THIS SOFTWARE IS NOT COPYRIGHTED
 + *
 + * This source code is offered for use in the public domain. You may
 + * use, modify or distribute it freely.
 + *
 + * This code is distributed in the hope that it will be useful but
 + * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
 + * DISCLAIMED. This includes but is not limited to warranties of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 + *
 + * DEFINES: i386                 - Target platform is i386
 + *          NDIS_WRAPPER         - Define only for NDIS library
 + *          NDIS_MINIPORT_DRIVER - Define only for NDIS miniport drivers
 + *          NDIS40               - Use NDIS 4.0 structures by default
 + *          NDIS50               - Use NDIS 5.0 structures by default
 + *          NDIS51               - Use NDIS 5.1 structures by default
 + *          NDIS40_MINIPORT      - Building NDIS 4.0 miniport driver
 + *          NDIS50_MINIPORT      - Building NDIS 5.0 miniport driver
 + *          NDIS51_MINIPORT      - Building NDIS 5.1 miniport driver
 + */
 +
 +#ifndef __NDIS_H
 +#define __NDIS_H
 +
 +#if __GNUC__ >=3
 +#pragma GCC system_header
 +#endif
 +
 +#include "ntddk.h"
 +#include "ntddndis.h"
 +#include "netpnp.h"
 +#include "netevent.h"
 +#include <qos.h>
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +#if defined(NDIS_WRAPPER)
 +  #define NDISAPI DECLSPEC_EXPORT
 +#else
 +  #define NDISAPI DECLSPEC_IMPORT
 +#endif
 +
 +#if defined(NDIS50_MINIPORT) && !defined(NDIS_MINIPORT_MAJOR_VERSION) && !defined(NDIS_MINIPORT_MINOR_VERSION)
 +#define NDIS_MINIPORT_MAJOR_VERSION 5
 +#define NDIS_MINIPORT_MINOR_VERSION 0
 +#endif
 +
 +#if defined(NDIS51_MINIPORT) && !defined(NDIS_MINIPORT_MAJOR_VERSION) && !defined(NDIS_MINIPORT_MINOR_VERSION)
 +#define NDIS_MINIPORT_MAJOR_VERSION 5
 +#define NDIS_MINIPORT_MINOR_VERSION 1
 +#endif
 +
 +#if defined(NDIS50) && !defined(NDIS_PROTOCOL_MAJOR_VERSION) && !defined(NDIS_PROTOCOL_MINOR_VERSION)
 +#define NDIS_PROTOCOL_MAJOR_VERSION 5
 +#define NDIS_PROTOCOL_MINOR_VERSION 0
 +#endif
 +
 +#if defined(NDIS51) && !defined(NDIS_PROTOCOL_MAJOR_VERSION) && !defined(NDIS_PROTOCOL_MINOR_VERSION)
 +#define NDIS_PROTOCOL_MAJOR_VERSION 5
 +#define NDIS_PROTOCOL_MINOR_VERSION 1
 +#endif
 +
 +#if defined(NDIS_MINIPORT_DRIVER) && !defined(BINARY_COMPATIBLE)
 +#define BINARY_COMPATIBLE 1
 +#endif
 +
 +#if !defined(_M_IX86) && BINARY_COMPATIBLE
 +#undef BINARY_COMPATIBLE
 +#define BINARY_COMPATIBLE 0
 +#endif
 +
 +#if 1
 +/* FIXME: */
 +typedef PVOID QUEUED_CLOSE;
 +#endif
 +
 +typedef ULONG NDIS_OID, *PNDIS_OID;
 +
 +typedef struct _X_FILTER FDDI_FILTER, *PFDDI_FILTER;
 +typedef struct _X_FILTER TR_FILTER, *PTR_FILTER;
 +typedef struct _X_FILTER NULL_FILTER, *PNULL_FILTER;
 +
 +typedef struct _REFERENCE {
 +      KSPIN_LOCK  SpinLock;
 +      USHORT  ReferenceCount;
 +      BOOLEAN  Closing;
 +} REFERENCE, * PREFERENCE;
 +
 +
 +/* NDIS base types */
 +
 +typedef struct _NDIS_SPIN_LOCK {
 +  KSPIN_LOCK  SpinLock;
 +  KIRQL  OldIrql;
 +} NDIS_SPIN_LOCK, * PNDIS_SPIN_LOCK;
 +
 +typedef struct _NDIS_EVENT {
 +  KEVENT  Event;
 +} NDIS_EVENT, *PNDIS_EVENT;
 +
 +typedef PVOID NDIS_HANDLE, *PNDIS_HANDLE;
 +typedef int NDIS_STATUS, *PNDIS_STATUS;
 +
 +typedef ANSI_STRING NDIS_ANSI_STRING, *PNDIS_ANSI_STRING;
 +typedef UNICODE_STRING NDIS_STRING, *PNDIS_STRING;
 +
 +typedef MDL NDIS_BUFFER, *PNDIS_BUFFER;
 +typedef ULONG NDIS_ERROR_CODE, *PNDIS_ERROR_CODE;
 +
 +
 +/* NDIS_STATUS constants */
 +#define NDIS_STATUS_SUCCESS                     ((NDIS_STATUS)STATUS_SUCCESS)
 +#define NDIS_STATUS_PENDING                     ((NDIS_STATUS)STATUS_PENDING)
 +#define NDIS_STATUS_NOT_RECOGNIZED              ((NDIS_STATUS)0x00010001L)
 +#define NDIS_STATUS_NOT_COPIED                  ((NDIS_STATUS)0x00010002L)
 +#define NDIS_STATUS_NOT_ACCEPTED                ((NDIS_STATUS)0x00010003L)
 +#define NDIS_STATUS_CALL_ACTIVE                 ((NDIS_STATUS)0x00010007L)
 +#define NDIS_STATUS_ONLINE                      ((NDIS_STATUS)0x40010003L)
 +#define NDIS_STATUS_RESET_START                 ((NDIS_STATUS)0x40010004L)
 +#define NDIS_STATUS_RESET_END                   ((NDIS_STATUS)0x40010005L)
 +#define NDIS_STATUS_RING_STATUS                 ((NDIS_STATUS)0x40010006L)
 +#define NDIS_STATUS_CLOSED                      ((NDIS_STATUS)0x40010007L)
 +#define NDIS_STATUS_WAN_LINE_UP                 ((NDIS_STATUS)0x40010008L)
 +#define NDIS_STATUS_WAN_LINE_DOWN               ((NDIS_STATUS)0x40010009L)
 +#define NDIS_STATUS_WAN_FRAGMENT                ((NDIS_STATUS)0x4001000AL)
 +#define       NDIS_STATUS_MEDIA_CONNECT               ((NDIS_STATUS)0x4001000BL)
 +#define       NDIS_STATUS_MEDIA_DISCONNECT            ((NDIS_STATUS)0x4001000CL)
 +#define NDIS_STATUS_HARDWARE_LINE_UP            ((NDIS_STATUS)0x4001000DL)
 +#define NDIS_STATUS_HARDWARE_LINE_DOWN          ((NDIS_STATUS)0x4001000EL)
 +#define NDIS_STATUS_INTERFACE_UP                ((NDIS_STATUS)0x4001000FL)
 +#define NDIS_STATUS_INTERFACE_DOWN              ((NDIS_STATUS)0x40010010L)
 +#define NDIS_STATUS_MEDIA_BUSY                  ((NDIS_STATUS)0x40010011L)
 +#define NDIS_STATUS_MEDIA_SPECIFIC_INDICATION   ((NDIS_STATUS)0x40010012L)
 +#define NDIS_STATUS_WW_INDICATION               NDIS_STATUS_MEDIA_SPECIFIC_INDICATION
 +#define NDIS_STATUS_LINK_SPEED_CHANGE           ((NDIS_STATUS)0x40010013L)
 +#define NDIS_STATUS_WAN_GET_STATS               ((NDIS_STATUS)0x40010014L)
 +#define NDIS_STATUS_WAN_CO_FRAGMENT             ((NDIS_STATUS)0x40010015L)
 +#define NDIS_STATUS_WAN_CO_LINKPARAMS           ((NDIS_STATUS)0x40010016L)
 +
 +#define NDIS_STATUS_NOT_RESETTABLE              ((NDIS_STATUS)0x80010001L)
 +#define NDIS_STATUS_SOFT_ERRORS                       ((NDIS_STATUS)0x80010003L)
 +#define NDIS_STATUS_HARD_ERRORS                 ((NDIS_STATUS)0x80010004L)
 +#define NDIS_STATUS_BUFFER_OVERFLOW               ((NDIS_STATUS)STATUS_BUFFER_OVERFLOW)
 +
 +#define NDIS_STATUS_FAILURE                       ((NDIS_STATUS)STATUS_UNSUCCESSFUL)
 +#define NDIS_STATUS_RESOURCES                   ((NDIS_STATUS)STATUS_INSUFFICIENT_RESOURCES)
 +#define NDIS_STATUS_CLOSING                       ((NDIS_STATUS)0xC0010002L)
 +#define NDIS_STATUS_BAD_VERSION                       ((NDIS_STATUS)0xC0010004L)
 +#define NDIS_STATUS_BAD_CHARACTERISTICS         ((NDIS_STATUS)0xC0010005L)
 +#define NDIS_STATUS_ADAPTER_NOT_FOUND           ((NDIS_STATUS)0xC0010006L)
 +#define NDIS_STATUS_OPEN_FAILED                       ((NDIS_STATUS)0xC0010007L)
 +#define NDIS_STATUS_DEVICE_FAILED               ((NDIS_STATUS)0xC0010008L)
 +#define NDIS_STATUS_MULTICAST_FULL              ((NDIS_STATUS)0xC0010009L)
 +#define NDIS_STATUS_MULTICAST_EXISTS            ((NDIS_STATUS)0xC001000AL)
 +#define NDIS_STATUS_MULTICAST_NOT_FOUND               ((NDIS_STATUS)0xC001000BL)
 +#define NDIS_STATUS_REQUEST_ABORTED               ((NDIS_STATUS)0xC001000CL)
 +#define NDIS_STATUS_RESET_IN_PROGRESS           ((NDIS_STATUS)0xC001000DL)
 +#define NDIS_STATUS_CLOSING_INDICATING          ((NDIS_STATUS)0xC001000EL)
 +#define NDIS_STATUS_NOT_SUPPORTED               ((NDIS_STATUS)STATUS_NOT_SUPPORTED)
 +#define NDIS_STATUS_INVALID_PACKET              ((NDIS_STATUS)0xC001000FL)
 +#define NDIS_STATUS_OPEN_LIST_FULL              ((NDIS_STATUS)0xC0010010L)
 +#define NDIS_STATUS_ADAPTER_NOT_READY           ((NDIS_STATUS)0xC0010011L)
 +#define NDIS_STATUS_ADAPTER_NOT_OPEN            ((NDIS_STATUS)0xC0010012L)
 +#define NDIS_STATUS_NOT_INDICATING              ((NDIS_STATUS)0xC0010013L)
 +#define NDIS_STATUS_INVALID_LENGTH              ((NDIS_STATUS)0xC0010014L)
 +#define NDIS_STATUS_INVALID_DATA                ((NDIS_STATUS)0xC0010015L)
 +#define NDIS_STATUS_BUFFER_TOO_SHORT            ((NDIS_STATUS)0xC0010016L)
 +#define NDIS_STATUS_INVALID_OID                       ((NDIS_STATUS)0xC0010017L)
 +#define NDIS_STATUS_ADAPTER_REMOVED               ((NDIS_STATUS)0xC0010018L)
 +#define NDIS_STATUS_UNSUPPORTED_MEDIA           ((NDIS_STATUS)0xC0010019L)
 +#define NDIS_STATUS_GROUP_ADDRESS_IN_USE        ((NDIS_STATUS)0xC001001AL)
 +#define NDIS_STATUS_FILE_NOT_FOUND              ((NDIS_STATUS)0xC001001BL)
 +#define NDIS_STATUS_ERROR_READING_FILE          ((NDIS_STATUS)0xC001001CL)
 +#define NDIS_STATUS_ALREADY_MAPPED              ((NDIS_STATUS)0xC001001DL)
 +#define NDIS_STATUS_RESOURCE_CONFLICT           ((NDIS_STATUS)0xC001001EL)
 +#define NDIS_STATUS_NO_CABLE                    ((NDIS_STATUS)0xC001001FL)
 +
 +#define NDIS_STATUS_INVALID_SAP                       ((NDIS_STATUS)0xC0010020L)
 +#define NDIS_STATUS_SAP_IN_USE                  ((NDIS_STATUS)0xC0010021L)
 +#define NDIS_STATUS_INVALID_ADDRESS             ((NDIS_STATUS)0xC0010022L)
 +#define NDIS_STATUS_VC_NOT_ACTIVATED            ((NDIS_STATUS)0xC0010023L)
 +#define NDIS_STATUS_DEST_OUT_OF_ORDER           ((NDIS_STATUS)0xC0010024L)
 +#define NDIS_STATUS_VC_NOT_AVAILABLE            ((NDIS_STATUS)0xC0010025L)
 +#define NDIS_STATUS_CELLRATE_NOT_AVAILABLE      ((NDIS_STATUS)0xC0010026L)
 +#define NDIS_STATUS_INCOMPATABLE_QOS            ((NDIS_STATUS)0xC0010027L)
 +#define NDIS_STATUS_AAL_PARAMS_UNSUPPORTED      ((NDIS_STATUS)0xC0010028L)
 +#define NDIS_STATUS_NO_ROUTE_TO_DESTINATION     ((NDIS_STATUS)0xC0010029L)
 +
 +#define NDIS_STATUS_TOKEN_RING_OPEN_ERROR       ((NDIS_STATUS)0xC0011000L)
 +#define NDIS_STATUS_INVALID_DEVICE_REQUEST      ((NDIS_STATUS)STATUS_INVALID_DEVICE_REQUEST)
 +#define NDIS_STATUS_NETWORK_UNREACHABLE         ((NDIS_STATUS)STATUS_NETWORK_UNREACHABLE)
 +
 +
 +/* NDIS error codes for error logging */
 +
 +#define NDIS_ERROR_CODE_RESOURCE_CONFLICT                                 EVENT_NDIS_RESOURCE_CONFLICT
 +#define NDIS_ERROR_CODE_OUT_OF_RESOURCES                                  EVENT_NDIS_OUT_OF_RESOURCE
 +#define NDIS_ERROR_CODE_HARDWARE_FAILURE                                  EVENT_NDIS_HARDWARE_FAILURE
 +#define NDIS_ERROR_CODE_ADAPTER_NOT_FOUND                                 EVENT_NDIS_ADAPTER_NOT_FOUND
 +#define NDIS_ERROR_CODE_INTERRUPT_CONNECT                                 EVENT_NDIS_INTERRUPT_CONNECT
 +#define NDIS_ERROR_CODE_DRIVER_FAILURE                                            EVENT_NDIS_DRIVER_FAILURE
 +#define NDIS_ERROR_CODE_BAD_VERSION                                                 EVENT_NDIS_BAD_VERSION
 +#define NDIS_ERROR_CODE_TIMEOUT                                                               EVENT_NDIS_TIMEOUT
 +#define NDIS_ERROR_CODE_NETWORK_ADDRESS                                           EVENT_NDIS_NETWORK_ADDRESS
 +#define NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION             EVENT_NDIS_UNSUPPORTED_CONFIGURATION
 +#define NDIS_ERROR_CODE_INVALID_VALUE_FROM_ADAPTER          EVENT_NDIS_INVALID_VALUE_FROM_ADAPTER
 +#define NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER         EVENT_NDIS_MISSING_CONFIGURATION_PARAMETER
 +#define NDIS_ERROR_CODE_BAD_IO_BASE_ADDRESS                             EVENT_NDIS_BAD_IO_BASE_ADDRESS
 +#define NDIS_ERROR_CODE_RECEIVE_SPACE_SMALL                             EVENT_NDIS_RECEIVE_SPACE_SMALL
 +#define NDIS_ERROR_CODE_ADAPTER_DISABLED                                  EVENT_NDIS_ADAPTER_DISABLED
 +
 +
 +/* Memory allocation flags. Used by Ndis[Allocate|Free]Memory */
 +#define NDIS_MEMORY_CONTIGUOUS            0x00000001
 +#define NDIS_MEMORY_NONCACHED             0x00000002
 +
 +/* NIC attribute flags. Used by NdisMSetAttributes(Ex) */
 +#define       NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT    0x00000001
 +#define NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT   0x00000002
 +#define NDIS_ATTRIBUTE_IGNORE_TOKEN_RING_ERRORS 0x00000004
 +#define NDIS_ATTRIBUTE_BUS_MASTER               0x00000008
 +#define NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER      0x00000010
 +#define NDIS_ATTRIBUTE_DESERIALIZE              0x00000020
 +#define NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND       0x00000040
 +#define NDIS_ATTRIBUTE_SURPRISE_REMOVE_OK       0x00000080
 +#define NDIS_ATTRIBUTE_NOT_CO_NDIS              0x00000100
 +#define NDIS_ATTRIBUTE_USES_SAFE_BUFFER_APIS    0x00000200
 +
 +
 +/* Lock */
 +
 +typedef union _NDIS_RW_LOCK_REFCOUNT {
 +  UINT  RefCount;
 +  UCHAR  cacheLine[16];
 +} NDIS_RW_LOCK_REFCOUNT;
 +
 +typedef struct _NDIS_RW_LOCK {
 +  union {
 +    struct {
 +      KSPIN_LOCK  SpinLock;
 +      PVOID  Context;
 +    };
 +    UCHAR  Reserved[16];
 +  };
 +
 +  NDIS_RW_LOCK_REFCOUNT  RefCount[MAXIMUM_PROCESSORS];
 +} NDIS_RW_LOCK, *PNDIS_RW_LOCK;
 +
 +typedef struct _LOCK_STATE {
 +  USHORT  LockState;
 +  KIRQL  OldIrql;
 +} LOCK_STATE, *PLOCK_STATE;
 +
 +
 +
 +/* Timer */
 +
 +typedef VOID DDKAPI
 +(*PNDIS_TIMER_FUNCTION)(
 +      IN PVOID  SystemSpecific1,
 +      IN PVOID  FunctionContext,
 +      IN PVOID  SystemSpecific2,
 +      IN PVOID  SystemSpecific3);
 +
 +typedef struct _NDIS_TIMER {
 +  KTIMER  Timer;
 +  KDPC  Dpc;
 +} NDIS_TIMER, *PNDIS_TIMER;
 +
 +
 +
 +/* Hardware */
 +
 +typedef CM_MCA_POS_DATA NDIS_MCA_POS_DATA, *PNDIS_MCA_POS_DATA;
 +typedef CM_EISA_SLOT_INFORMATION NDIS_EISA_SLOT_INFORMATION, *PNDIS_EISA_SLOT_INFORMATION;
 +typedef CM_EISA_FUNCTION_INFORMATION NDIS_EISA_FUNCTION_INFORMATION, *PNDIS_EISA_FUNCTION_INFORMATION;
 +typedef CM_PARTIAL_RESOURCE_LIST NDIS_RESOURCE_LIST, *PNDIS_RESOURCE_LIST;
 +
 +/* Hardware status codes (OID_GEN_HARDWARE_STATUS) */
 +typedef enum _NDIS_HARDWARE_STATUS {
 +  NdisHardwareStatusReady,
 +  NdisHardwareStatusInitializing,
 +  NdisHardwareStatusReset,
 +  NdisHardwareStatusClosing,
 +  NdisHardwareStatusNotReady
 +} NDIS_HARDWARE_STATUS, *PNDIS_HARDWARE_STATUS;
 +
 +/* OID_GEN_GET_TIME_CAPS */
 +typedef struct _GEN_GET_TIME_CAPS {
 +  ULONG  Flags;
 +  ULONG  ClockPrecision;
 +} GEN_GET_TIME_CAPS, *PGEN_GET_TIME_CAPS;
 +
 +/* Flag bits */
 +#define       READABLE_LOCAL_CLOCK                    0x00000001
 +#define       CLOCK_NETWORK_DERIVED                   0x00000002
 +#define       CLOCK_PRECISION                         0x00000004
 +#define       RECEIVE_TIME_INDICATION_CAPABLE         0x00000008
 +#define       TIMED_SEND_CAPABLE                      0x00000010
 +#define       TIME_STAMP_CAPABLE                      0x00000020
 +
 +/* OID_GEN_GET_NETCARD_TIME */
 +typedef struct _GEN_GET_NETCARD_TIME {
 +  ULONGLONG  ReadTime;
 +} GEN_GET_NETCARD_TIME, *PGEN_GET_NETCARD_TIME;
 +
 +/* NDIS driver medium (OID_GEN_MEDIA_SUPPORTED / OID_GEN_MEDIA_IN_USE) */
 +typedef enum _NDIS_MEDIUM {
 +  NdisMedium802_3,
 +  NdisMedium802_5,
 +  NdisMediumFddi,
 +  NdisMediumWan,
 +  NdisMediumLocalTalk,
 +  NdisMediumDix,
 +  NdisMediumArcnetRaw,
 +  NdisMediumArcnet878_2,
 +  NdisMediumAtm,
 +  NdisMediumWirelessWan,
 +  NdisMediumIrda,
 +  NdisMediumBpc,
 +  NdisMediumCoWan,
 +  NdisMedium1394,
 +  NdisMediumMax
 +} NDIS_MEDIUM, *PNDIS_MEDIUM;
 +
 +/* NDIS packet filter bits (OID_GEN_CURRENT_PACKET_FILTER) */
 +#define NDIS_PACKET_TYPE_DIRECTED               0x00000001
 +#define NDIS_PACKET_TYPE_MULTICAST              0x00000002
 +#define NDIS_PACKET_TYPE_ALL_MULTICAST          0x00000004
 +#define NDIS_PACKET_TYPE_BROADCAST              0x00000008
 +#define NDIS_PACKET_TYPE_SOURCE_ROUTING         0x00000010
 +#define NDIS_PACKET_TYPE_PROMISCUOUS            0x00000020
 +#define NDIS_PACKET_TYPE_SMT                    0x00000040
 +#define NDIS_PACKET_TYPE_ALL_LOCAL              0x00000080
 +#define NDIS_PACKET_TYPE_GROUP                  0x00001000
 +#define NDIS_PACKET_TYPE_ALL_FUNCTIONAL         0x00002000
 +#define NDIS_PACKET_TYPE_FUNCTIONAL             0x00004000
 +#define NDIS_PACKET_TYPE_MAC_FRAME              0x00008000
 +
 +/* NDIS protocol option bits (OID_GEN_PROTOCOL_OPTIONS) */
 +#define NDIS_PROT_OPTION_ESTIMATED_LENGTH       0x00000001
 +#define NDIS_PROT_OPTION_NO_LOOPBACK            0x00000002
 +#define NDIS_PROT_OPTION_NO_RSVD_ON_RCVPKT      0x00000004
 +
 +/* NDIS MAC option bits (OID_GEN_MAC_OPTIONS) */
 +#define NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA     0x00000001
 +#define NDIS_MAC_OPTION_RECEIVE_SERIALIZED      0x00000002
 +#define NDIS_MAC_OPTION_TRANSFERS_NOT_PEND      0x00000004
 +#define NDIS_MAC_OPTION_NO_LOOPBACK             0x00000008
 +#define NDIS_MAC_OPTION_FULL_DUPLEX             0x00000010
 +#define       NDIS_MAC_OPTION_EOTX_INDICATION         0x00000020
 +#define       NDIS_MAC_OPTION_8021P_PRIORITY          0x00000040
 +#define NDIS_MAC_OPTION_RESERVED                0x80000000
 +
 +/* State of the LAN media (OID_GEN_MEDIA_CONNECT_STATUS) */
 +typedef enum _NDIS_MEDIA_STATE {
 +      NdisMediaStateConnected,
 +      NdisMediaStateDisconnected
 +} NDIS_MEDIA_STATE, *PNDIS_MEDIA_STATE;
 +
 +/* OID_GEN_SUPPORTED_GUIDS */
 +typedef struct _NDIS_GUID {
 +      GUID  Guid;
 +      union {
 +              NDIS_OID  Oid;
 +              NDIS_STATUS  Status;
 +      } u;
 +      ULONG  Size;
 +      ULONG  Flags;
 +} NDIS_GUID, *PNDIS_GUID;
 +
 +#define       NDIS_GUID_TO_OID                  0x00000001
 +#define       NDIS_GUID_TO_STATUS               0x00000002
 +#define       NDIS_GUID_ANSI_STRING             0x00000004
 +#define       NDIS_GUID_UNICODE_STRING          0x00000008
 +#define       NDIS_GUID_ARRAY                   0x00000010
 +
 +typedef HANDLE PNDIS_PACKET_POOL;
 +
 +/* NDIS_PACKET_PRIVATE.Flags constants */
 +#define fPACKET_CONTAINS_MEDIA_SPECIFIC_INFO    0x40
 +#define fPACKET_ALLOCATED_BY_NDIS               0x80
 +
 +typedef struct _NDIS_PACKET_PRIVATE {
 +  UINT  PhysicalCount;
 +  UINT  TotalLength;
 +  PNDIS_BUFFER  Head;
 +  PNDIS_BUFFER  Tail;
 +  PNDIS_PACKET_POOL  Pool;
 +  UINT  Count;
 +  ULONG  Flags;
 +  BOOLEAN      ValidCounts;
 +  UCHAR  NdisPacketFlags;
 +  USHORT  NdisPacketOobOffset;
 +} NDIS_PACKET_PRIVATE, * PNDIS_PACKET_PRIVATE;
 +
 +typedef struct _NDIS_PACKET {
 +  NDIS_PACKET_PRIVATE  Private;
 +  union {
 +    struct {
 +      UCHAR  MiniportReserved[2 * sizeof(PVOID)];
 +      UCHAR  WrapperReserved[2 * sizeof(PVOID)];
 +    };
 +    struct {
 +      UCHAR  MiniportReservedEx[3 * sizeof(PVOID)];
 +      UCHAR  WrapperReservedEx[sizeof(PVOID)];
 +    };
 +    struct {
 +      UCHAR  MacReserved[4 * sizeof(PVOID)];
 +    };
 +  };
 +  ULONG_PTR  Reserved[2];
 +  UCHAR  ProtocolReserved[1];
 +} NDIS_PACKET, *PNDIS_PACKET, **PPNDIS_PACKET;
 +
 +typedef enum _NDIS_CLASS_ID {
 +      NdisClass802_3Priority,
 +      NdisClassWirelessWanMbxMailbox,
 +      NdisClassIrdaPacketInfo,
 +      NdisClassAtmAALInfo
 +} NDIS_CLASS_ID;
 +
 +typedef struct MediaSpecificInformation {
 +  UINT  NextEntryOffset;
 +  NDIS_CLASS_ID  ClassId;
 +  UINT  Size;
 +  UCHAR  ClassInformation[1];
 +} MEDIA_SPECIFIC_INFORMATION;
 +
 +typedef struct _NDIS_PACKET_OOB_DATA {
 +  _ANONYMOUS_UNION union {
 +    ULONGLONG  TimeToSend;
 +    ULONGLONG  TimeSent;
 +  } DUMMYUNIONNAME;
 +  ULONGLONG  TimeReceived;
 +  UINT  HeaderSize;
 +  UINT  SizeMediaSpecificInfo;
 +  PVOID  MediaSpecificInformation;
 +  NDIS_STATUS  Status;
 +} NDIS_PACKET_OOB_DATA, *PNDIS_PACKET_OOB_DATA;
 +
 +typedef struct _NDIS_PM_PACKET_PATTERN {
 +  ULONG  Priority;
 +  ULONG  Reserved;
 +  ULONG  MaskSize;
 +  ULONG  PatternOffset;
 +  ULONG  PatternSize;
 +  ULONG  PatternFlags;
 +} NDIS_PM_PACKET_PATTERN,  *PNDIS_PM_PACKET_PATTERN;
 +
 +
 +/* Request types used by NdisRequest */
 +typedef enum _NDIS_REQUEST_TYPE {
 +  NdisRequestQueryInformation,
 +  NdisRequestSetInformation,
 +  NdisRequestQueryStatistics,
 +  NdisRequestOpen,
 +  NdisRequestClose,
 +  NdisRequestSend,
 +  NdisRequestTransferData,
 +  NdisRequestReset,
 +  NdisRequestGeneric1,
 +  NdisRequestGeneric2,
 +  NdisRequestGeneric3,
 +  NdisRequestGeneric4
 +} NDIS_REQUEST_TYPE, *PNDIS_REQUEST_TYPE;
 +
 +typedef struct _NDIS_REQUEST {
 +  UCHAR  MacReserved[4 * sizeof(PVOID)];
 +  NDIS_REQUEST_TYPE  RequestType;
 +  union _DATA {
 +    struct QUERY_INFORMATION {
 +      NDIS_OID  Oid;
 +      PVOID  InformationBuffer;
 +      UINT  InformationBufferLength;
 +      UINT  BytesWritten;
 +      UINT  BytesNeeded;
 +    } QUERY_INFORMATION;
 +    struct SET_INFORMATION {
 +      NDIS_OID  Oid;
 +      PVOID  InformationBuffer;
 +      UINT  InformationBufferLength;
 +      UINT  BytesRead;
 +      UINT  BytesNeeded;
 +    } SET_INFORMATION;
 + } DATA;
 +#if (defined(NDIS50) || defined(NDIS51))
 +  UCHAR  NdisReserved[9 * sizeof(PVOID)];
 +  union {
 +    UCHAR  CallMgrReserved[2 * sizeof(PVOID)];
 +    UCHAR  ProtocolReserved[2 * sizeof(PVOID)];
 +  };
 +  UCHAR  MiniportReserved[2 * sizeof(PVOID)];
 +#endif
 +} NDIS_REQUEST, *PNDIS_REQUEST;
 +
 +
 +
 +/* Wide Area Networks definitions */
 +
 +typedef struct _NDIS_WAN_PACKET {
 +  LIST_ENTRY  WanPacketQueue;
 +  PUCHAR  CurrentBuffer;
 +  ULONG  CurrentLength;
 +  PUCHAR  StartBuffer;
 +  PUCHAR  EndBuffer;
 +  PVOID  ProtocolReserved1;
 +  PVOID  ProtocolReserved2;
 +  PVOID  ProtocolReserved3;
 +  PVOID  ProtocolReserved4;
 +  PVOID  MacReserved1;
 +  PVOID  MacReserved2;
 +  PVOID  MacReserved3;
 +  PVOID  MacReserved4;
 +} NDIS_WAN_PACKET, *PNDIS_WAN_PACKET;
 +
 +
 +
 +/* DMA channel information */
 +
 +typedef struct _NDIS_DMA_DESCRIPTION {
 +  BOOLEAN  DemandMode;
 +  BOOLEAN  AutoInitialize;
 +  BOOLEAN  DmaChannelSpecified;
 +  DMA_WIDTH  DmaWidth;
 +  DMA_SPEED  DmaSpeed;
 +  ULONG  DmaPort;
 +  ULONG  DmaChannel;
 +} NDIS_DMA_DESCRIPTION, *PNDIS_DMA_DESCRIPTION;
 +
 +typedef struct _NDIS_DMA_BLOCK {
 +  PVOID  MapRegisterBase;
 +  KEVENT  AllocationEvent;
 +  PADAPTER_OBJECT  SystemAdapterObject;
 +  PVOID  Miniport;
 +  BOOLEAN  InProgress;
 +} NDIS_DMA_BLOCK, *PNDIS_DMA_BLOCK;
 +
 +typedef UCHAR NDIS_DMA_SIZE;
 +
 +#define NDIS_DMA_24BITS                         ((NDIS_DMA_SIZE)0)
 +#define NDIS_DMA_32BITS                         ((NDIS_DMA_SIZE)1)
 +#define NDIS_DMA_64BITS                         ((NDIS_DMA_SIZE)2)
 +
 +typedef enum _NDIS_PROCESSOR_TYPE {
 +      NdisProcessorX86,
 +      NdisProcessorMips,
 +      NdisProcessorAlpha,
 +      NdisProcessorPpc,
 +      NdisProcessorAmd64
 +} NDIS_PROCESSOR_TYPE, *PNDIS_PROCESSOR_TYPE;
 +
 +typedef enum _NDIS_ENVIRONMENT_TYPE {
 +      NdisEnvironmentWindows,
 +      NdisEnvironmentWindowsNt
 +} NDIS_ENVIRONMENT_TYPE, *PNDIS_ENVIRONMENT_TYPE;
 +
 +/* Possible hardware architecture */
 +typedef enum _NDIS_INTERFACE_TYPE {
 +      NdisInterfaceInternal = Internal,
 +      NdisInterfaceIsa = Isa,
 +      NdisInterfaceEisa = Eisa,
 +      NdisInterfaceMca = MicroChannel,
 +      NdisInterfaceTurboChannel = TurboChannel,
 +      NdisInterfacePci = PCIBus,
 +      NdisInterfacePcMcia = PCMCIABus,
 +      NdisInterfaceCBus = CBus,
 +      NdisInterfaceMPIBus = MPIBus,
 +      NdisInterfaceMPSABus = MPSABus,
 +      NdisInterfaceProcessorInternal = ProcessorInternal,
 +      NdisInterfaceInternalPowerBus = InternalPowerBus,
 +      NdisInterfacePNPISABus = PNPISABus,
 +      NdisInterfacePNPBus = PNPBus,
 +      NdisMaximumInterfaceType
 +} NDIS_INTERFACE_TYPE, *PNDIS_INTERFACE_TYPE;
 +
 +#define NdisInterruptLevelSensitive       LevelSensitive
 +#define NdisInterruptLatched              Latched
 +typedef KINTERRUPT_MODE NDIS_INTERRUPT_MODE, *PNDIS_INTERRUPT_MODE;
 +
 +
 +typedef enum _NDIS_PARAMETER_TYPE {
 +  NdisParameterInteger,
 +  NdisParameterHexInteger,
 +  NdisParameterString,
 +  NdisParameterMultiString,
 +  NdisParameterBinary
 +} NDIS_PARAMETER_TYPE, *PNDIS_PARAMETER_TYPE;
 +
 +typedef struct {
 +      USHORT  Length;
 +      PVOID  Buffer;
 +} BINARY_DATA;
 +
 +typedef struct _NDIS_CONFIGURATION_PARAMETER {
 +  NDIS_PARAMETER_TYPE  ParameterType;
 +  union {
 +    ULONG  IntegerData;
 +    NDIS_STRING  StringData;
 +    BINARY_DATA  BinaryData;
 +  } ParameterData;
 +} NDIS_CONFIGURATION_PARAMETER, *PNDIS_CONFIGURATION_PARAMETER;
 +
 +
 +typedef PHYSICAL_ADDRESS NDIS_PHYSICAL_ADDRESS, *PNDIS_PHYSICAL_ADDRESS;
 +
 +typedef struct _NDIS_PHYSICAL_ADDRESS_UNIT {
 +  NDIS_PHYSICAL_ADDRESS  PhysicalAddress;
 +  UINT  Length;
 +} NDIS_PHYSICAL_ADDRESS_UNIT, *PNDIS_PHYSICAL_ADDRESS_UNIT;
 +
 +typedef struct _NDIS_WAN_LINE_DOWN {
 +  UCHAR  RemoteAddress[6];
 +  UCHAR  LocalAddress[6];
 +} NDIS_WAN_LINE_DOWN, *PNDIS_WAN_LINE_DOWN;
 +
 +typedef struct _NDIS_WAN_LINE_UP {
 +  ULONG  LinkSpeed;
 +  ULONG  MaximumTotalSize;
 +  NDIS_WAN_QUALITY  Quality;
 +  USHORT  SendWindow;
 +  UCHAR  RemoteAddress[6];
 +  OUT UCHAR  LocalAddress[6];
 +  ULONG  ProtocolBufferLength;
 +  PUCHAR  ProtocolBuffer;
 +  USHORT  ProtocolType;
 +  NDIS_STRING  DeviceName;
 +} NDIS_WAN_LINE_UP, *PNDIS_WAN_LINE_UP;
 +
 +
 +typedef VOID DDKAPI
 +(*ADAPTER_SHUTDOWN_HANDLER)(
 +  IN PVOID  ShutdownContext);
 +
 +
 +typedef struct _OID_LIST    OID_LIST, *POID_LIST;
 +
 +/* PnP state */
 +
 +typedef enum _NDIS_PNP_DEVICE_STATE {
 +  NdisPnPDeviceAdded,
 +  NdisPnPDeviceStarted,
 +  NdisPnPDeviceQueryStopped,
 +  NdisPnPDeviceStopped,
 +  NdisPnPDeviceQueryRemoved,
 +  NdisPnPDeviceRemoved,
 +  NdisPnPDeviceSurpriseRemoved
 +} NDIS_PNP_DEVICE_STATE;
 +
 +#define       NDIS_DEVICE_NOT_STOPPABLE                 0x00000001
 +#define       NDIS_DEVICE_NOT_REMOVEABLE                0x00000002
 +#define       NDIS_DEVICE_NOT_SUSPENDABLE                   0x00000004
 +#define NDIS_DEVICE_DISABLE_PM                    0x00000008
 +#define NDIS_DEVICE_DISABLE_WAKE_UP               0x00000010
 +#define NDIS_DEVICE_DISABLE_WAKE_ON_RECONNECT     0x00000020
 +#define NDIS_DEVICE_RESERVED                      0x00000040
 +#define NDIS_DEVICE_DISABLE_WAKE_ON_MAGIC_PACKET  0x00000080
 +#define NDIS_DEVICE_DISABLE_WAKE_ON_PATTERN_MATCH 0x00000100
 +
 +
 +/* OID_GEN_NETWORK_LAYER_ADDRESSES */
 +typedef struct _NETWORK_ADDRESS {
 +  USHORT  AddressLength;
 +  USHORT  AddressType;
 +  UCHAR  Address[1];
 +} NETWORK_ADDRESS, *PNETWORK_ADDRESS;
 +
 +typedef struct _NETWORK_ADDRESS_LIST {
 +      LONG  AddressCount;
 +      USHORT  AddressType;
 +      NETWORK_ADDRESS  Address[1];
 +} NETWORK_ADDRESS_LIST, *PNETWORK_ADDRESS_LIST;
 +
 +/* Protocol types supported by NDIS */
 +#define       NDIS_PROTOCOL_ID_DEFAULT        0x00
 +#define       NDIS_PROTOCOL_ID_TCP_IP         0x02
 +#define       NDIS_PROTOCOL_ID_IPX            0x06
 +#define       NDIS_PROTOCOL_ID_NBF            0x07
 +#define       NDIS_PROTOCOL_ID_MAX            0x0F
 +#define       NDIS_PROTOCOL_ID_MASK           0x0F
 +
 +
 +/* OID_GEN_TRANSPORT_HEADER_OFFSET */
 +typedef struct _TRANSPORT_HEADER_OFFSET {
 +      USHORT  ProtocolType;
 +      USHORT  HeaderOffset;
 +} TRANSPORT_HEADER_OFFSET, *PTRANSPORT_HEADER_OFFSET;
 +
 +
 +/* OID_GEN_CO_LINK_SPEED / OID_GEN_CO_MINIMUM_LINK_SPEED */
 +typedef struct _NDIS_CO_LINK_SPEED {
 +  ULONG  Outbound;
 +  ULONG  Inbound;
 +} NDIS_CO_LINK_SPEED, *PNDIS_CO_LINK_SPEED;
 +
 +typedef ULONG NDIS_AF, *PNDIS_AF;
 +#define CO_ADDRESS_FAMILY_Q2931           ((NDIS_AF)0x1)
 +#define CO_ADDRESS_FAMILY_PSCHED          ((NDIS_AF)0x2)
 +#define CO_ADDRESS_FAMILY_L2TP            ((NDIS_AF)0x3)
 +#define CO_ADDRESS_FAMILY_IRDA            ((NDIS_AF)0x4)
 +#define CO_ADDRESS_FAMILY_1394            ((NDIS_AF)0x5)
 +#define CO_ADDRESS_FAMILY_PPP             ((NDIS_AF)0x6)
 +#define CO_ADDRESS_FAMILY_TAPI            ((NDIS_AF)0x800)
 +#define CO_ADDRESS_FAMILY_TAPI_PROXY      ((NDIS_AF)0x801)
 +
 +#define CO_ADDRESS_FAMILY_PROXY           0x80000000
 +
 +typedef struct {
 +  NDIS_AF  AddressFamily;
 +  ULONG  MajorVersion;
 +  ULONG  MinorVersion;
 +} CO_ADDRESS_FAMILY, *PCO_ADDRESS_FAMILY;
 +
 +typedef struct _CO_SPECIFIC_PARAMETERS {
 +  ULONG  ParamType;
 +  ULONG  Length;
 +  UCHAR  Parameters[1];
 +} CO_SPECIFIC_PARAMETERS, *PCO_SPECIFIC_PARAMETERS;
 +
 +typedef struct _CO_CALL_MANAGER_PARAMETERS {
 +  FLOWSPEC  Transmit;
 +  FLOWSPEC  Receive;
 +  CO_SPECIFIC_PARAMETERS  CallMgrSpecific;
 +} CO_CALL_MANAGER_PARAMETERS, *PCO_CALL_MANAGER_PARAMETERS;
 +
 +/* CO_MEDIA_PARAMETERS.Flags constants */
 +#define RECEIVE_TIME_INDICATION           0x00000001
 +#define USE_TIME_STAMPS                   0x00000002
 +#define TRANSMIT_VC                         0x00000004
 +#define RECEIVE_VC                        0x00000008
 +#define INDICATE_ERRED_PACKETS            0x00000010
 +#define INDICATE_END_OF_TX                0x00000020
 +#define RESERVE_RESOURCES_VC              0x00000040
 +#define       ROUND_DOWN_FLOW                   0x00000080
 +#define       ROUND_UP_FLOW                     0x00000100
 +
 +typedef struct _CO_MEDIA_PARAMETERS {
 +  ULONG  Flags;
 +  ULONG  ReceivePriority;
 +  ULONG  ReceiveSizeHint;
 +  CO_SPECIFIC_PARAMETERS  MediaSpecific;
 +} CO_MEDIA_PARAMETERS, *PCO_MEDIA_PARAMETERS;
 +
 +/* CO_CALL_PARAMETERS.Flags constants */
 +#define PERMANENT_VC                      0x00000001
 +#define CALL_PARAMETERS_CHANGED           0x00000002
 +#define QUERY_CALL_PARAMETERS             0x00000004
 +#define BROADCAST_VC                      0x00000008
 +#define MULTIPOINT_VC                     0x00000010
 +
 +typedef struct _CO_CALL_PARAMETERS {
 +  ULONG  Flags;
 +  PCO_CALL_MANAGER_PARAMETERS  CallMgrParameters;
 +  PCO_MEDIA_PARAMETERS  MediaParameters;
 +} CO_CALL_PARAMETERS, *PCO_CALL_PARAMETERS;
 +
 +typedef struct _CO_SAP {
 +  ULONG  SapType;
 +  ULONG  SapLength;
 +  UCHAR  Sap[1];
 +} CO_SAP, *PCO_SAP;
 +
 +typedef struct _NDIS_IPSEC_PACKET_INFO {
 +  _ANONYMOUS_UNION union {
 +    struct {
 +      NDIS_HANDLE  OffloadHandle;
 +      NDIS_HANDLE  NextOffloadHandle;
 +    } Transmit;
 +    struct {
 +      ULONG  SA_DELETE_REQ : 1;
 +      ULONG  CRYPTO_DONE : 1;
 +      ULONG  NEXT_CRYPTO_DONE : 1;
 +      ULONG  CryptoStatus;
 +    } Receive;
 +  } DUMMYUNIONNAME;
 +} NDIS_IPSEC_PACKET_INFO, *PNDIS_IPSEC_PACKET_INFO;
 +
 +/* NDIS_MAC_FRAGMENT.Errors constants */
 +#define WAN_ERROR_CRC                                 0x00000001
 +#define WAN_ERROR_FRAMING                             0x00000002
 +#define WAN_ERROR_HARDWAREOVERRUN                     0x00000004
 +#define WAN_ERROR_BUFFEROVERRUN                       0x00000008
 +#define WAN_ERROR_TIMEOUT                             0x00000010
 +#define WAN_ERROR_ALIGNMENT                           0x00000020
 +
 +typedef struct _NDIS_MAC_FRAGMENT {
 +  NDIS_HANDLE  NdisLinkContext;
 +  ULONG  Errors;
 +} NDIS_MAC_FRAGMENT, *PNDIS_MAC_FRAGMENT;
 +
 +typedef struct _NDIS_MAC_LINE_DOWN {
 +  NDIS_HANDLE  NdisLinkContext;
 +} NDIS_MAC_LINE_DOWN, *PNDIS_MAC_LINE_DOWN;
 +
 +typedef struct _NDIS_MAC_LINE_UP {
 +  ULONG  LinkSpeed;
 +  NDIS_WAN_QUALITY  Quality;
 +  USHORT  SendWindow;
 +  NDIS_HANDLE  ConnectionWrapperID;
 +  NDIS_HANDLE  NdisLinkHandle;
 +  NDIS_HANDLE  NdisLinkContext;
 +} NDIS_MAC_LINE_UP, *PNDIS_MAC_LINE_UP;
 +
 +typedef struct _NDIS_PACKET_8021Q_INFO {
 +      _ANONYMOUS_UNION union {
 +              struct {
 +                      UINT32  UserPriority : 3;
 +                      UINT32  CanonicalFormatId : 1;
 +                      UINT32  VlanId : 12;
 +                      UINT32  Reserved : 16;
 +              } TagHeader;
 +              PVOID  Value;
 +      } DUMMYUNIONNAME;
 +} NDIS_PACKET_8021Q_INFO, *PNDIS_PACKET_8021Q_INFO;
 +
 +typedef enum _NDIS_PER_PACKET_INFO {
 +      TcpIpChecksumPacketInfo,
 +      IpSecPacketInfo,
 +      TcpLargeSendPacketInfo,
 +      ClassificationHandlePacketInfo,
 +      NdisReserved,
 +      ScatterGatherListPacketInfo,
 +      Ieee8021QInfo,
 +      OriginalPacketInfo,
 +      PacketCancelId,
 +      MaxPerPacketInfo
 +} NDIS_PER_PACKET_INFO, *PNDIS_PER_PACKET_INFO;
 +
 +typedef struct _NDIS_PACKET_EXTENSION {
 +  PVOID  NdisPacketInfo[MaxPerPacketInfo];
 +} NDIS_PACKET_EXTENSION, *PNDIS_PACKET_EXTENSION;
 +
++typedef struct _NDIS_OBJECT_HEADER {
++  UCHAR  Type;
++  UCHAR  Revision;
++  USHORT  Size;
++} NDIS_OBJECT_HEADER, *PNDIS_OBJECT_HEADER;
++
++typedef struct _NDIS_GENERIC_OBJECT {
++  NDIS_OBJECT_HEADER  Header;
++  PVOID  Caller;
++  PVOID  CallersCaller;
++  PDRIVER_OBJECT  DriverObject;
++} NDIS_GENERIC_OBJECT, *PNDIS_GENERIC_OBJECT;
++
 +/*
 + * PNDIS_PACKET
 + * NDIS_GET_ORIGINAL_PACKET(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_GET_ORIGINAL_PACKET(Packet) \
 +  NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, OriginalPacketInfo)
 +
 +/*
 + * PVOID
 + * NDIS_GET_PACKET_CANCEL_ID(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_GET_PACKET_CANCEL_ID(Packet) \
 +  NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, PacketCancelId)
 +
 +/*
 + * PNDIS_PACKET_EXTENSION
 + * NDIS_PACKET_EXTENSION_FROM_PACKET(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_PACKET_EXTENSION_FROM_PACKET(Packet) \
 +  ((PNDIS_PACKET_EXTENSION)((PUCHAR)(Packet) \
 +    + (Packet)->Private.NdisPacketOobOffset + sizeof(NDIS_PACKET_OOB_DATA)))
 +
 +/*
 + * PVOID
 + * NDIS_PER_PACKET_INFO_FROM_PACKET(
 + *   IN OUT  PNDIS_PACKET  Packet,
 + *   IN NDIS_PER_PACKET_INFO  InfoType);
 + */
 +#define NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, InfoType) \
 +  ((PNDIS_PACKET_EXTENSION)((PUCHAR)(Packet) + (Packet)->Private.NdisPacketOobOffset \
 +    + sizeof(NDIS_PACKET_OOB_DATA)))->NdisPacketInfo[(InfoType)]
 +
 +/*
 + * VOID
 + * NDIS_SET_ORIGINAL_PACKET(
 + *   IN OUT  PNDIS_PACKET  Packet,
 + *   IN PNDIS_PACKET  OriginalPacket);
 + */
 +#define NDIS_SET_ORIGINAL_PACKET(Packet, OriginalPacket) \
 +  NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, OriginalPacketInfo) = (OriginalPacket)
 +
 +/*
 + * VOID
 + * NDIS_SET_PACKET_CANCEL_ID(
 + *  IN PNDIS_PACKET  Packet
 + *  IN ULONG_PTR  CancelId);
 + */
 +#define NDIS_SET_PACKET_CANCEL_ID(Packet, CancelId) \
 +  NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, PacketCancelId) = (CancelId)
 +
 +typedef enum _NDIS_TASK {
 +  TcpIpChecksumNdisTask,
 +  IpSecNdisTask,
 +  TcpLargeSendNdisTask,
 +  MaxNdisTask
 +} NDIS_TASK, *PNDIS_TASK;
 +
 +typedef struct _NDIS_TASK_IPSEC {
 +  struct {
 +    ULONG  AH_ESP_COMBINED;
 +    ULONG  TRANSPORT_TUNNEL_COMBINED;
 +    ULONG  V4_OPTIONS;
 +    ULONG  RESERVED;
 +  } Supported;
 +
 +  struct {
 +    ULONG  MD5 : 1;
 +    ULONG  SHA_1 : 1;
 +    ULONG  Transport : 1;
 +    ULONG  Tunnel : 1;
 +    ULONG  Send : 1;
 +    ULONG  Receive : 1;
 +  } V4AH;
 +
 +  struct {
 +    ULONG  DES : 1;
 +    ULONG  RESERVED : 1;
 +    ULONG  TRIPLE_DES : 1;
 +    ULONG  NULL_ESP : 1;
 +    ULONG  Transport : 1;
 +    ULONG  Tunnel : 1;
 +    ULONG  Send : 1;
 +    ULONG  Receive : 1;
 +  } V4ESP;
 +} NDIS_TASK_IPSEC, *PNDIS_TASK_IPSEC;
 +
 +typedef struct _NDIS_TASK_OFFLOAD {
 +  ULONG  Version;
 +  ULONG  Size;
 +  NDIS_TASK  Task;
 +  ULONG  OffsetNextTask;
 +  ULONG  TaskBufferLength;
 +  UCHAR  TaskBuffer[1];
 +} NDIS_TASK_OFFLOAD, *PNDIS_TASK_OFFLOAD;
 +
 +/* NDIS_TASK_OFFLOAD_HEADER.Version constants */
 +#define NDIS_TASK_OFFLOAD_VERSION 1
 +
 +typedef enum _NDIS_ENCAPSULATION {
 +  UNSPECIFIED_Encapsulation,
 +  NULL_Encapsulation,
 +  IEEE_802_3_Encapsulation,
 +  IEEE_802_5_Encapsulation,
 +  LLC_SNAP_ROUTED_Encapsulation,
 +  LLC_SNAP_BRIDGED_Encapsulation
 +} NDIS_ENCAPSULATION;
 +
 +typedef struct _NDIS_ENCAPSULATION_FORMAT {
 +  NDIS_ENCAPSULATION  Encapsulation;
 +  struct {
 +    ULONG  FixedHeaderSize : 1;
 +    ULONG  Reserved : 31;
 +  } Flags;
 +  ULONG  EncapsulationHeaderSize;
 +} NDIS_ENCAPSULATION_FORMAT, *PNDIS_ENCAPSULATION_FORMAT;
 +
 +typedef struct _NDIS_TASK_TCP_IP_CHECKSUM {
 +  struct {
 +    ULONG  IpOptionsSupported:1;
 +    ULONG  TcpOptionsSupported:1;
 +    ULONG  TcpChecksum:1;
 +    ULONG  UdpChecksum:1;
 +    ULONG  IpChecksum:1;
 +  } V4Transmit;
 +
 +  struct {
 +    ULONG  IpOptionsSupported : 1;
 +    ULONG  TcpOptionsSupported : 1;
 +    ULONG  TcpChecksum : 1;
 +    ULONG  UdpChecksum : 1;
 +    ULONG  IpChecksum : 1;
 +  } V4Receive;
 +
 +  struct {
 +    ULONG  IpOptionsSupported : 1;
 +    ULONG  TcpOptionsSupported : 1;
 +    ULONG  TcpChecksum : 1;
 +    ULONG  UdpChecksum : 1;
 +  } V6Transmit;
 +
 +  struct {
 +    ULONG  IpOptionsSupported : 1;
 +    ULONG  TcpOptionsSupported : 1;
 +    ULONG  TcpChecksum : 1;
 +    ULONG  UdpChecksum : 1;
 +  } V6Receive;
 +} NDIS_TASK_TCP_IP_CHECKSUM, *PNDIS_TASK_TCP_IP_CHECKSUM;
 +
 +typedef struct _NDIS_TASK_TCP_LARGE_SEND {
 +  ULONG  Version;
 +  ULONG  MaxOffLoadSize;
 +  ULONG  MinSegmentCount;
 +  BOOLEAN  TcpOptions;
 +  BOOLEAN  IpOptions;
 +} NDIS_TASK_TCP_LARGE_SEND, *PNDIS_TASK_TCP_LARGE_SEND;
 +
 +typedef struct _NDIS_TCP_IP_CHECKSUM_PACKET_INFO {
 +  _ANONYMOUS_UNION union {
 +    struct {
 +      ULONG  NdisPacketChecksumV4 : 1;
 +      ULONG  NdisPacketChecksumV6 : 1;
 +      ULONG  NdisPacketTcpChecksum : 1;
 +      ULONG  NdisPacketUdpChecksum : 1;
 +      ULONG  NdisPacketIpChecksum : 1;
 +      } Transmit;
 +
 +    struct {
 +      ULONG  NdisPacketTcpChecksumFailed : 1;
 +      ULONG  NdisPacketUdpChecksumFailed : 1;
 +      ULONG  NdisPacketIpChecksumFailed : 1;
 +      ULONG  NdisPacketTcpChecksumSucceeded : 1;
 +      ULONG  NdisPacketUdpChecksumSucceeded : 1;
 +      ULONG  NdisPacketIpChecksumSucceeded : 1;
 +      ULONG  NdisPacketLoopback : 1;
 +    } Receive;
 +    ULONG  Value;
 +  } DUMMYUNIONNAME;
 +} NDIS_TCP_IP_CHECKSUM_PACKET_INFO, *PNDIS_TCP_IP_CHECKSUM_PACKET_INFO;
 +
 +typedef struct _NDIS_WAN_CO_FRAGMENT {
 +  ULONG  Errors;
 +} NDIS_WAN_CO_FRAGMENT, *PNDIS_WAN_CO_FRAGMENT;
 +
 +typedef struct _NDIS_WAN_FRAGMENT {
 +  UCHAR  RemoteAddress[6];
 +  UCHAR  LocalAddress[6];
 +} NDIS_WAN_FRAGMENT, *PNDIS_WAN_FRAGMENT;
 +
 +typedef struct _WAN_CO_LINKPARAMS {
 +  ULONG  TransmitSpeed;
 +  ULONG  ReceiveSpeed;
 +  ULONG  SendWindow;
 +} WAN_CO_LINKPARAMS, *PWAN_CO_LINKPARAMS;
 +
 +
 +/* Call Manager */
 +
 +typedef VOID DDKAPI
 +(*CM_ACTIVATE_VC_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  CallMgrVcContext,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CM_ADD_PARTY_HANDLER)(
 +  IN NDIS_HANDLE  CallMgrVcContext,
 +  IN OUT PCO_CALL_PARAMETERS  CallParameters,
 +  IN NDIS_HANDLE  NdisPartyHandle,
 +  OUT PNDIS_HANDLE  CallMgrPartyContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CM_CLOSE_AF_HANDLER)(
 +  IN NDIS_HANDLE  CallMgrAfContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CM_CLOSE_CALL_HANDLER)(
 +  IN NDIS_HANDLE  CallMgrVcContext,
 +  IN NDIS_HANDLE  CallMgrPartyContext  OPTIONAL,
 +  IN PVOID  CloseData  OPTIONAL,
 +  IN UINT  Size  OPTIONAL);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CM_DEREG_SAP_HANDLER)(
 +  IN NDIS_HANDLE  CallMgrSapContext);
 +
 +typedef VOID DDKAPI
 +(*CM_DEACTIVATE_VC_COMPLETE_HANDLER)(
 +      IN NDIS_STATUS  Status,
 +      IN NDIS_HANDLE  CallMgrVcContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CM_DROP_PARTY_HANDLER)(
 +  IN NDIS_HANDLE  CallMgrPartyContext,
 +  IN PVOID  CloseData  OPTIONAL,
 +  IN UINT  Size  OPTIONAL);
 +
 +typedef VOID DDKAPI
 +(*CM_INCOMING_CALL_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  CallMgrVcContext,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CM_MAKE_CALL_HANDLER)(
 +  IN NDIS_HANDLE  CallMgrVcContext,
 +  IN OUT PCO_CALL_PARAMETERS  CallParameters,
 +  IN NDIS_HANDLE  NdisPartyHandle     OPTIONAL,
 +  OUT PNDIS_HANDLE  CallMgrPartyContext  OPTIONAL);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CM_MODIFY_CALL_QOS_HANDLER)(
 +  IN NDIS_HANDLE  CallMgrVcContext,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CM_OPEN_AF_HANDLER)(
 +      IN NDIS_HANDLE  CallMgrBindingContext,
 +      IN PCO_ADDRESS_FAMILY  AddressFamily,
 +      IN NDIS_HANDLE  NdisAfHandle,
 +      OUT PNDIS_HANDLE  CallMgrAfContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CM_REG_SAP_HANDLER)(
 +  IN NDIS_HANDLE  CallMgrAfContext,
 +  IN PCO_SAP  Sap,
 +  IN NDIS_HANDLE  NdisSapHandle,
 +  OUT PNDIS_HANDLE  CallMgrSapContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CO_CREATE_VC_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolAfContext,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  OUT PNDIS_HANDLE  ProtocolVcContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CO_DELETE_VC_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolVcContext);
 +
 +typedef VOID DDKAPI
 +(*CO_REQUEST_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolAfContext  OPTIONAL,
 +  IN NDIS_HANDLE  ProtocolVcContext  OPTIONAL,
 +  IN NDIS_HANDLE  ProtocolPartyContext  OPTIONAL,
 +  IN PNDIS_REQUEST  NdisRequest);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CO_REQUEST_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolAfContext,
 +  IN NDIS_HANDLE  ProtocolVcContext  OPTIONAL,
 +  IN NDIS_HANDLE      ProtocolPartyContext  OPTIONAL,
 +  IN OUT PNDIS_REQUEST  NdisRequest);
 +
 +typedef struct _NDIS_CALL_MANAGER_CHARACTERISTICS {
 +      UCHAR  MajorVersion;
 +      UCHAR  MinorVersion;
 +      USHORT  Filler;
 +      UINT  Reserved;
 +      CO_CREATE_VC_HANDLER  CmCreateVcHandler;
 +      CO_DELETE_VC_HANDLER  CmDeleteVcHandler;
 +      CM_OPEN_AF_HANDLER  CmOpenAfHandler;
 +      CM_CLOSE_AF_HANDLER      CmCloseAfHandler;
 +      CM_REG_SAP_HANDLER  CmRegisterSapHandler;
 +      CM_DEREG_SAP_HANDLER  CmDeregisterSapHandler;
 +      CM_MAKE_CALL_HANDLER  CmMakeCallHandler;
 +      CM_CLOSE_CALL_HANDLER  CmCloseCallHandler;
 +      CM_INCOMING_CALL_COMPLETE_HANDLER  CmIncomingCallCompleteHandler;
 +      CM_ADD_PARTY_HANDLER  CmAddPartyHandler;
 +      CM_DROP_PARTY_HANDLER  CmDropPartyHandler;
 +      CM_ACTIVATE_VC_COMPLETE_HANDLER  CmActivateVcCompleteHandler;
 +      CM_DEACTIVATE_VC_COMPLETE_HANDLER  CmDeactivateVcCompleteHandler;
 +      CM_MODIFY_CALL_QOS_HANDLER  CmModifyCallQoSHandler;
 +      CO_REQUEST_HANDLER  CmRequestHandler;
 +      CO_REQUEST_COMPLETE_HANDLER  CmRequestCompleteHandler;
 +} NDIS_CALL_MANAGER_CHARACTERISTICS, *PNDIS_CALL_MANAGER_CHARACTERISTICS;
 +
 +
 +
 +/* Call Manager clients */
 +
 +typedef VOID (*CL_OPEN_AF_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS Status,
 +  IN NDIS_HANDLE ProtocolAfContext,
 +  IN NDIS_HANDLE NdisAfHandle);
 +
 +typedef VOID DDKAPI
 +(*CL_CLOSE_AF_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolAfContext);
 +
 +typedef VOID DDKAPI
 +(*CL_REG_SAP_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolSapContext,
 +  IN PCO_SAP  Sap,
 +  IN NDIS_HANDLE  NdisSapHandle);
 +
 +typedef VOID DDKAPI
 +(*CL_DEREG_SAP_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolSapContext);
 +
 +typedef VOID DDKAPI
 +(*CL_MAKE_CALL_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolVcContext,
 +  IN NDIS_HANDLE  NdisPartyHandle  OPTIONAL,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +typedef VOID DDKAPI
 +(*CL_MODIFY_CALL_QOS_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolVcContext,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +typedef VOID DDKAPI
 +(*CL_CLOSE_CALL_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolVcContext,
 +  IN NDIS_HANDLE  ProtocolPartyContext  OPTIONAL);
 +
 +typedef VOID DDKAPI
 +(*CL_ADD_PARTY_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolPartyContext,
 +  IN NDIS_HANDLE  NdisPartyHandle,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +typedef VOID DDKAPI
 +(*CL_DROP_PARTY_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolPartyContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*CL_INCOMING_CALL_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolSapContext,
 +  IN NDIS_HANDLE  ProtocolVcContext,
 +  IN OUT PCO_CALL_PARAMETERS  CallParameters);
 +
 +typedef VOID DDKAPI
 +(*CL_INCOMING_CALL_QOS_CHANGE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolVcContext,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +typedef VOID DDKAPI
 +(*CL_INCOMING_CLOSE_CALL_HANDLER)(
 +  IN NDIS_STATUS  CloseStatus,
 +  IN NDIS_HANDLE  ProtocolVcContext,
 +  IN PVOID  CloseData  OPTIONAL,
 +  IN UINT  Size  OPTIONAL);
 +
 +typedef VOID DDKAPI
 +(*CL_INCOMING_DROP_PARTY_HANDLER)(
 +  IN NDIS_STATUS  DropStatus,
 +  IN NDIS_HANDLE  ProtocolPartyContext,
 +  IN PVOID  CloseData  OPTIONAL,
 +  IN UINT  Size  OPTIONAL);
 +
 +typedef VOID DDKAPI
 +(*CL_CALL_CONNECTED_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolVcContext);
 +
 +
 +typedef struct _NDIS_CLIENT_CHARACTERISTICS {
 +  UCHAR  MajorVersion;
 +  UCHAR  MinorVersion;
 +  USHORT  Filler;
 +  UINT  Reserved;
 +  CO_CREATE_VC_HANDLER  ClCreateVcHandler;
 +  CO_DELETE_VC_HANDLER  ClDeleteVcHandler;
 +  CO_REQUEST_HANDLER  ClRequestHandler;
 +  CO_REQUEST_COMPLETE_HANDLER  ClRequestCompleteHandler;
 +  CL_OPEN_AF_COMPLETE_HANDLER  ClOpenAfCompleteHandler;
 +  CL_CLOSE_AF_COMPLETE_HANDLER  ClCloseAfCompleteHandler;
 +  CL_REG_SAP_COMPLETE_HANDLER  ClRegisterSapCompleteHandler;
 +  CL_DEREG_SAP_COMPLETE_HANDLER  ClDeregisterSapCompleteHandler;
 +  CL_MAKE_CALL_COMPLETE_HANDLER  ClMakeCallCompleteHandler;
 +  CL_MODIFY_CALL_QOS_COMPLETE_HANDLER  ClModifyCallQoSCompleteHandler;
 +  CL_CLOSE_CALL_COMPLETE_HANDLER  ClCloseCallCompleteHandler;
 +  CL_ADD_PARTY_COMPLETE_HANDLER  ClAddPartyCompleteHandler;
 +  CL_DROP_PARTY_COMPLETE_HANDLER  ClDropPartyCompleteHandler;
 +  CL_INCOMING_CALL_HANDLER  ClIncomingCallHandler;
 +  CL_INCOMING_CALL_QOS_CHANGE_HANDLER  ClIncomingCallQoSChangeHandler;
 +  CL_INCOMING_CLOSE_CALL_HANDLER  ClIncomingCloseCallHandler;
 +  CL_INCOMING_DROP_PARTY_HANDLER  ClIncomingDropPartyHandler;
 +  CL_CALL_CONNECTED_HANDLER  ClCallConnectedHandler;
 +} NDIS_CLIENT_CHARACTERISTICS, *PNDIS_CLIENT_CHARACTERISTICS;
 +
 +
 +/* NDIS protocol structures */
 +
 +/* Prototypes for NDIS 3.0 protocol characteristics */
 +
 +typedef VOID DDKAPI
 +(*OPEN_ADAPTER_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_STATUS  OpenErrorStatus);
 +
 +typedef VOID DDKAPI
 +(*CLOSE_ADAPTER_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN NDIS_STATUS  Status);
 +
 +typedef VOID DDKAPI
 +(*RESET_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN NDIS_STATUS  Status);
 +
 +typedef VOID DDKAPI
 +(*REQUEST_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN PNDIS_REQUEST  NdisRequest,
 +  IN NDIS_STATUS  Status);
 +
 +typedef VOID DDKAPI
 +(*STATUS_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN NDIS_STATUS  GeneralStatus,
 +  IN PVOID  StatusBuffer,
 +  IN UINT  StatusBufferSize);
 +
 +typedef VOID DDKAPI
 +(*STATUS_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext);
 +
 +typedef VOID DDKAPI
 +(*SEND_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN PNDIS_PACKET  Packet,
 +  IN NDIS_STATUS  Status);
 +
 +typedef VOID DDKAPI
 +(*WAN_SEND_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN PNDIS_WAN_PACKET  Packet,
 +  IN NDIS_STATUS  Status);
 +
 +typedef VOID DDKAPI
 +(*TRANSFER_DATA_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN PNDIS_PACKET  Packet,
 +  IN NDIS_STATUS  Status,
 +  IN UINT  BytesTransferred);
 +
 +typedef VOID DDKAPI
 +(*WAN_TRANSFER_DATA_COMPLETE_HANDLER)(
 +    VOID);
 +
 +
 +typedef NDIS_STATUS DDKAPI
 +(*RECEIVE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN NDIS_HANDLE  MacReceiveContext,
 +  IN PVOID  HeaderBuffer,
 +  IN UINT  HeaderBufferSize,
 +  IN PVOID  LookAheadBuffer,
 +  IN UINT  LookaheadBufferSize,
 +  IN UINT  PacketSize);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*WAN_RECEIVE_HANDLER)(
 +  IN NDIS_HANDLE  NdisLinkHandle,
 +  IN PUCHAR  Packet,
 +  IN ULONG  PacketSize);
 +
 +typedef VOID DDKAPI
 +(*RECEIVE_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext);
 +
 +
 +/* Protocol characteristics for NDIS 3.0 protocols */
 +
 +#define NDIS30_PROTOCOL_CHARACTERISTICS_S \
 +  UCHAR  MajorNdisVersion; \
 +  UCHAR  MinorNdisVersion; \
 +  USHORT  Filler; \
 +  _ANONYMOUS_UNION union { \
 +    UINT  Reserved; \
 +    UINT  Flags; \
 +  } DUMMYUNIONNAME; \
 +  OPEN_ADAPTER_COMPLETE_HANDLER  OpenAdapterCompleteHandler; \
 +  CLOSE_ADAPTER_COMPLETE_HANDLER  CloseAdapterCompleteHandler; \
 +  _ANONYMOUS_UNION union { \
 +    SEND_COMPLETE_HANDLER  SendCompleteHandler; \
 +    WAN_SEND_COMPLETE_HANDLER  WanSendCompleteHandler; \
 +  } DUMMYUNIONNAME2; \
 +  _ANONYMOUS_UNION union { \
 +    TRANSFER_DATA_COMPLETE_HANDLER  TransferDataCompleteHandler; \
 +    WAN_TRANSFER_DATA_COMPLETE_HANDLER  WanTransferDataCompleteHandler; \
 +  } DUMMYUNIONNAME3; \
 +  RESET_COMPLETE_HANDLER  ResetCompleteHandler; \
 +  REQUEST_COMPLETE_HANDLER  RequestCompleteHandler; \
 +  _ANONYMOUS_UNION union { \
 +    RECEIVE_HANDLER    ReceiveHandler; \
 +    WAN_RECEIVE_HANDLER  WanReceiveHandler; \
 +  } DUMMYUNIONNAME4; \
 +  RECEIVE_COMPLETE_HANDLER  ReceiveCompleteHandler; \
 +  STATUS_HANDLER  StatusHandler; \
 +  STATUS_COMPLETE_HANDLER  StatusCompleteHandler; \
 +  NDIS_STRING  Name;
 +
 +typedef struct _NDIS30_PROTOCOL_CHARACTERISTICS {
 +  NDIS30_PROTOCOL_CHARACTERISTICS_S
 +} NDIS30_PROTOCOL_CHARACTERISTICS, *PNDIS30_PROTOCOL_CHARACTERISTICS;
 +
 +
 +/* Prototypes for NDIS 4.0 protocol characteristics */
 +
 +typedef INT DDKAPI
 +(*RECEIVE_PACKET_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN PNDIS_PACKET  Packet);
 +
 +typedef VOID DDKAPI
 +(*BIND_HANDLER)(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  BindContext,
 +  IN PNDIS_STRING  DeviceName,
 +  IN PVOID  SystemSpecific1,
 +  IN PVOID  SystemSpecific2);
 +
 +typedef VOID DDKAPI
 +(*UNBIND_HANDLER)(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN NDIS_HANDLE  UnbindContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*PNP_EVENT_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN PNET_PNP_EVENT  NetPnPEvent);
 +
 +typedef VOID DDKAPI
 +(*UNLOAD_PROTOCOL_HANDLER)(
 +  VOID);
 +
 +
 +/* Protocol characteristics for NDIS 4.0 protocols */
 +
 +#ifdef __cplusplus
 +
 +#define NDIS40_PROTOCOL_CHARACTERISTICS_S \
 +  NDIS30_PROTOCOL_CHARACTERISTICS  Ndis30Chars; \
 +  RECEIVE_PACKET_HANDLER  ReceivePacketHandler; \
 +  BIND_HANDLER  BindAdapterHandler; \
 +  UNBIND_HANDLER  UnbindAdapterHandler; \
 +  PNP_EVENT_HANDLER  PnPEventHandler; \
 +  UNLOAD_PROTOCOL_HANDLER  UnloadHandler;
 +
 +#else /* !__cplusplus */
 +
 +#define NDIS40_PROTOCOL_CHARACTERISTICS_S \
 +  NDIS30_PROTOCOL_CHARACTERISTICS_S \
 +  RECEIVE_PACKET_HANDLER  ReceivePacketHandler; \
 +  BIND_HANDLER  BindAdapterHandler; \
 +  UNBIND_HANDLER  UnbindAdapterHandler; \
 +  PNP_EVENT_HANDLER  PnPEventHandler; \
 +  UNLOAD_PROTOCOL_HANDLER  UnloadHandler;
 +
 +#endif /* __cplusplus */
 +
 +typedef struct _NDIS40_PROTOCOL_CHARACTERISTICS {
 +  NDIS40_PROTOCOL_CHARACTERISTICS_S
 +} NDIS40_PROTOCOL_CHARACTERISTICS, *PNDIS40_PROTOCOL_CHARACTERISTICS;
 +
 +/* Prototypes for NDIS 5.0 protocol characteristics */
 +
 +typedef VOID DDKAPI
 +(*CO_SEND_COMPLETE_HANDLER)(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ProtocolVcContext,
 +  IN PNDIS_PACKET  Packet);
 +
 +typedef VOID DDKAPI
 +(*CO_STATUS_HANDLER)(
 +      IN NDIS_HANDLE  ProtocolBindingContext,
 +      IN NDIS_HANDLE  ProtocolVcContext  OPTIONAL,
 +      IN NDIS_STATUS  GeneralStatus,
 +      IN PVOID  StatusBuffer,
 +      IN UINT  StatusBufferSize);
 +
 +typedef UINT DDKAPI
 +(*CO_RECEIVE_PACKET_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN NDIS_HANDLE  ProtocolVcContext,
 +  IN PNDIS_PACKET  Packet);
 +
 +typedef VOID DDKAPI
 +(*CO_AF_REGISTER_NOTIFY_HANDLER)(
 +  IN NDIS_HANDLE  ProtocolBindingContext,
 +  IN PCO_ADDRESS_FAMILY  AddressFamily);
 +
 +#ifdef __cplusplus \
 +
 +#define NDIS50_PROTOCOL_CHARACTERISTICS_S \
 +  NDIS40_PROTOCOL_CHARACTERISTICS  Ndis40Chars; \
 +  PVOID  ReservedHandlers[4]; \
 +  CO_SEND_COMPLETE_HANDLER  CoSendCompleteHandler; \
 +  CO_STATUS_HANDLER  CoStatusHandler; \
 +  CO_RECEIVE_PACKET_HANDLER  CoReceivePacketHandler; \
 +  CO_AF_REGISTER_NOTIFY_HANDLER  CoAfRegisterNotifyHandler;
 +
 +#else /* !__cplusplus */
 +
 +#define NDIS50_PROTOCOL_CHARACTERISTICS_S \
 +  NDIS40_PROTOCOL_CHARACTERISTICS_S \
 +  PVOID  ReservedHandlers[4]; \
 +  CO_SEND_COMPLETE_HANDLER  CoSendCompleteHandler; \
 +  CO_STATUS_HANDLER  CoStatusHandler; \
 +  CO_RECEIVE_PACKET_HANDLER  CoReceivePacketHandler; \
 +  CO_AF_REGISTER_NOTIFY_HANDLER  CoAfRegisterNotifyHandler;
 +
 +#endif /* !__cplusplus */
 +
 +typedef struct _NDIS50_PROTOCOL_CHARACTERISTICS {
 +  NDIS50_PROTOCOL_CHARACTERISTICS_S
 +} NDIS50_PROTOCOL_CHARACTERISTICS, *PNDIS50_PROTOCOL_CHARACTERISTICS;
 +
 +#if defined(NDIS50) || defined(NDIS51)
 +typedef struct _NDIS_PROTOCOL_CHARACTERISTICS {
 +  NDIS50_PROTOCOL_CHARACTERISTICS_S;
 +} NDIS_PROTOCOL_CHARACTERISTICS, *PNDIS_PROTOCOL_CHARACTERISTICS;
 +#elif defined(NDIS40)
 +typedef struct _NDIS_PROTOCOL_CHARACTERISTICS {
 +  NDIS40_PROTOCOL_CHARACTERISTICS_S;
 +} NDIS_PROTOCOL_CHARACTERISTICS, *PNDIS_PROTOCOL_CHARACTERISTICS;
 +#else /* NDIS30 */
 +typedef struct _NDIS_PROTOCOL_CHARACTERISTICS {
 +  NDIS30_PROTOCOL_CHARACTERISTICS_S
 +} NDIS_PROTOCOL_CHARACTERISTICS, *PNDIS_PROTOCOL_CHARACTERISTICS;
 +#endif
 +
 +
 +
 +/* Buffer management routines */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisAllocateBuffer(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_BUFFER  *Buffer,
 +  IN NDIS_HANDLE  PoolHandle,
 +  IN PVOID  VirtualAddress,
 +  IN UINT  Length);
 +
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisAllocateBufferPool(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_HANDLE  PoolHandle,
 +  IN UINT  NumberOfDescriptors);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisAllocatePacket(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_PACKET  *Packet,
 +  IN NDIS_HANDLE  PoolHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisAllocatePacketPool(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_HANDLE  PoolHandle,
 +  IN UINT  NumberOfDescriptors,
 +  IN UINT  ProtocolReservedLength);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCopyBuffer(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_BUFFER  *Buffer,
 +  IN NDIS_HANDLE  PoolHandle,
 +  IN PVOID  MemoryDescriptor,
 +  IN UINT  Offset,
 +  IN UINT  Length);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCopyFromPacketToPacket(
 +  IN PNDIS_PACKET  Destination,
 +  IN UINT  DestinationOffset,
 +  IN UINT  BytesToCopy,
 +  IN PNDIS_PACKET  Source,
 +  IN UINT  SourceOffset,
 +  OUT PUINT  BytesCopied);
 +
 +/*
 + * VOID
 + * NdisCopyLookaheadData(
 + *   IN PVOID Destination,
 + *   IN PVOID Source,
 + *   IN ULONG Length,
 + *   IN ULONG ReceiveFlags);
 + */
 +
 +#if defined(_M_IX86) || defined(_M_AMD64)
 +#define NdisCopyLookaheadData(Destination, Source, Length, MacOptions) \
 +  RtlCopyMemory(Destination, Source, Length)
 +#else
 +#define NdisCopyLookaheadData(Destination, Source, Length, MacOptions) \
 +  { \
 +    if ((MacOptions) & NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA) \
 +    { \
 +      RtlCopyMemory(_Destination, _Source, _Length); \
 +    } \
 +    else \
 +    { \
 +      PUCHAR _Src = (PUCHAR)(Source); \
 +      PUCHAR _Dest = (PUCHAR)(Destination); \
 +      PUCHAR _End = _Dest + (Length); \
 +      while (_Dest < _End) \
 +        *_Dest++ = *_Src++; \
 +    } \
 +  }
 +#endif
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisDprAllocatePacket(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_PACKET  *Packet,
 +  IN NDIS_HANDLE  PoolHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisDprAllocatePacketNonInterlocked(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_PACKET  *Packet,
 +  IN NDIS_HANDLE  PoolHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisDprFreePacket(
 +  IN PNDIS_PACKET  Packet);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisDprFreePacketNonInterlocked(
 +  IN PNDIS_PACKET  Packet);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisFreeBufferPool(
 +  IN NDIS_HANDLE  PoolHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisFreePacket(
 +  IN PNDIS_PACKET  Packet);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisFreePacketPool(
 +  IN NDIS_HANDLE  PoolHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisReturnPackets(
 +  IN PNDIS_PACKET  *PacketsToReturn,
 +  IN UINT  NumberOfPackets);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisUnchainBufferAtBack(
 +  IN OUT PNDIS_PACKET  Packet,
 +  OUT PNDIS_BUFFER  *Buffer);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisUnchainBufferAtFront(
 +  IN OUT PNDIS_PACKET  Packet,
 +  OUT PNDIS_BUFFER  *Buffer);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisAdjustBufferLength(
 +  IN PNDIS_BUFFER  Buffer,
 +  IN UINT  Length);
 +
 +NDISAPI
 +ULONG
 +DDKAPI
 +NdisBufferLength(
 +  IN PNDIS_BUFFER  Buffer);
 +
 +NDISAPI
 +PVOID
 +DDKAPI
 +NdisBufferVirtualAddress(
 +  IN PNDIS_BUFFER  Buffer);
 +
 +NDISAPI
 +ULONG
 +DDKAPI
 +NDIS_BUFFER_TO_SPAN_PAGES(
 +  IN PNDIS_BUFFER  Buffer);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisFreeBuffer(
 +  IN PNDIS_BUFFER  Buffer);
 +
 +#if BINARY_COMPATIBLE
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisGetBufferPhysicalArraySize(
 +  IN PNDIS_BUFFER  Buffer,
 +  OUT PUINT  ArraySize);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisGetFirstBufferFromPacket(
 +  IN PNDIS_PACKET  _Packet,
 +  OUT PNDIS_BUFFER  *_FirstBuffer,
 +  OUT PVOID  *_FirstBufferVA,
 +  OUT PUINT  _FirstBufferLength,
 +  OUT PUINT  _TotalBufferLength);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisQueryBuffer(
 +  IN PNDIS_BUFFER  Buffer,
 +  OUT PVOID  *VirtualAddress OPTIONAL,
 +  OUT PUINT  Length);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisQueryBufferOffset(
 +  IN PNDIS_BUFFER  Buffer,
 +  OUT PUINT  Offset,
 +  OUT PUINT  Length);
 +
 +#else
 +
 +/*
 + * VOID
 + * NdisGetBufferPhysicalArraySize(
 + *   IN PNDIS_BUFFER  Buffer,
 + *   OUT PUINT  ArraySize);
 + */
 +#define NdisGetBufferPhysicalArraySize(Buffer,        \
 +                                       ArraySize)     \
 +{                                                     \
 +  (*(ArraySize) = NDIS_BUFFER_TO_SPAN_PAGES(Buffer))  \
 +}
 +
 +/*
 + * VOID
 + * NdisGetFirstBufferFromPacket(
 + *   IN PNDIS_PACKET  _Packet,
 + *   OUT PNDIS_BUFFER  * _FirstBuffer,
 + *   OUT PVOID  * _FirstBufferVA,
 + *   OUT PUINT  _FirstBufferLength,
 + *   OUT PUINT  _TotalBufferLength)
 + */
 +#define       NdisGetFirstBufferFromPacket(_Packet,             \
 +                                     _FirstBuffer,        \
 +                                     _FirstBufferVA,      \
 +                                     _FirstBufferLength,  \
 +                                     _TotalBufferLength)  \
 +{                                                         \
 +  PNDIS_BUFFER _Buffer;                                   \
 +                                                          \
 +  _Buffer         = (_Packet)->Private.Head;              \
 +  *(_FirstBuffer) = _Buffer;                              \
 +  if (_Buffer != NULL)                                    \
 +    {                                                     \
 +          *(_FirstBufferVA)     = MmGetSystemAddressForMdl(_Buffer);  \
 +          *(_FirstBufferLength) = MmGetMdlByteCount(_Buffer);         \
 +          _Buffer = _Buffer->Next;                                    \
 +                *(_TotalBufferLength) = *(_FirstBufferLength);              \
 +                while (_Buffer != NULL) {                                   \
 +                  *(_TotalBufferLength) += MmGetMdlByteCount(_Buffer);      \
 +                  _Buffer = _Buffer->Next;                                  \
 +                }                                                           \
 +    }                             \
 +  else                            \
 +    {                             \
 +      *(_FirstBufferVA) = 0;      \
 +      *(_FirstBufferLength) = 0;  \
 +      *(_TotalBufferLength) = 0;  \
 +    } \
 +}
 +
 +/*
 + * VOID
 + * NdisQueryBuffer(
 + *   IN PNDIS_BUFFER  Buffer,
 + *   OUT PVOID  *VirtualAddress OPTIONAL,
 + *   OUT PUINT  Length)
 + */
 +#define NdisQueryBuffer(Buffer,         \
 +                        VirtualAddress, \
 +                        Length)         \
 +{                                       \
 +      if (ARGUMENT_PRESENT(VirtualAddress))                   \
 +              *((PVOID*)VirtualAddress) = MmGetSystemAddressForMdl(Buffer); \
 +                                        \
 +      *((PUINT)Length) = MmGetMdlByteCount(Buffer); \
 +}
 +
 +
 +/*
 + * VOID
 + * NdisQueryBufferOffset(
 + *   IN PNDIS_BUFFER  Buffer,
 + *   OUT PUINT  Offset,
 + *   OUT PUINT  Length);
 + */
 +#define NdisQueryBufferOffset(Buffer,             \
 +                              Offset,             \
 +                              Length)             \
 +{                                                 \
 +  *((PUINT)Offset) = MmGetMdlByteOffset(Buffer);  \
 +  *((PUINT)Length) = MmGetMdlByteCount(Buffer);   \
 +}
 +
 +#endif /* BINARY_COMPATIBLE */
 +
 +/*
 + * PVOID
 + * NDIS_BUFFER_LINKAGE(
 + *   IN PNDIS_BUFFER  Buffer);
 + */
 +#define NDIS_BUFFER_LINKAGE(Buffer)(Buffer)->Next;
 +
 +
 +/*
 + * VOID
 + * NdisChainBufferAtBack(
 + *   IN OUT PNDIS_PACKET  Packet,
 + *   IN OUT PNDIS_BUFFER  Buffer)
 + */
 +#define NdisChainBufferAtBack(Packet,           \
 +                              Buffer)           \
 +{                                               \
 +      PNDIS_BUFFER NdisBuffer = (Buffer);           \
 +                                                \
 +      while (NdisBuffer->Next != NULL)              \
 +   NdisBuffer = NdisBuffer->Next;               \
 +                                                    \
 +      NdisBuffer->Next = NULL;                      \
 +                                                    \
 +      if ((Packet)->Private.Head != NULL)           \
 +    (Packet)->Private.Tail->Next = (Buffer);    \
 +      else                                          \
 +    (Packet)->Private.Head = (Buffer);          \
 +                                                    \
 +      (Packet)->Private.Tail = NdisBuffer;          \
 +      (Packet)->Private.ValidCounts = FALSE;        \
 +}
 +
 +
 +/*
 + * VOID
 + * NdisChainBufferAtFront(
 + *   IN OUT PNDIS_PACKET  Packet,
 + *   IN OUT PNDIS_BUFFER  Buffer)
 + */
 +#define NdisChainBufferAtFront(Packet,        \
 +                               Buffer)        \
 +{                                             \
 +      PNDIS_BUFFER _NdisBuffer = (Buffer);        \
 +                                              \
 +  while (_NdisBuffer->Next != NULL)           \
 +    _NdisBuffer = _NdisBuffer->Next;          \
 +                                              \
 +  if ((Packet)->Private.Head == NULL)         \
 +    (Packet)->Private.Tail = _NdisBuffer;     \
 +                                              \
 +      _NdisBuffer->Next = (Packet)->Private.Head; \
 +      (Packet)->Private.Head = (Buffer);          \
 +      (Packet)->Private.ValidCounts = FALSE;      \
 +}
 +
 +
 +/*
 + * VOID
 + * NdisGetNextBuffer(
 + *   IN PNDIS_BUFFER  CurrentBuffer,
 + *   OUT PNDIS_BUFFER  * NextBuffer)
 + */
 +#define NdisGetNextBuffer(CurrentBuffer,  \
 +                          NextBuffer)     \
 +{                                         \
 +  *(NextBuffer) = (CurrentBuffer)->Next;  \
 +}
 +
 +
 +/*
 + * UINT
 + * NdisGetPacketFlags(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NdisGetPacketFlags(Packet)(Packet)->Private.Flags;
 +
 +
 +/*
 + * VOID
 + * NdisClearPacketFlags(
 + *   IN PNDIS_PACKET  Packet,
 + *   IN UINT  Flags);
 + */
 +#define NdisClearPacketFlags(Packet, Flags) \
 +  (Packet)->Private.Flags &= ~(Flags)
 +
 +
 +/*
 + * VOID
 + * NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(
 + *   IN PNDIS_PACKET    Packet,
 + *   IN PPVOID          pMediaSpecificInfo,
 + *   IN PUINT           pSizeMediaSpecificInfo);
 + */
 +#define NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(_Packet,                                  \
 +                                            _pMediaSpecificInfo,                      \
 +                                            _pSizeMediaSpecificInfo)                  \
 +{                                                                                     \
 +  if (!((_Packet)->Private.NdisPacketFlags & fPACKET_ALLOCATED_BY_NDIS) ||            \
 +      !((_Packet)->Private.NdisPacketFlags & fPACKET_CONTAINS_MEDIA_SPECIFIC_INFO))   \
 +        {                                                                                 \
 +          *(_pMediaSpecificInfo) = NULL;                                                  \
 +          *(_pSizeMediaSpecificInfo) = 0;                                                 \
 +        }                                                                                 \
 +  else                                                                                \
 +        {                                                                                 \
 +          *(_pMediaSpecificInfo) = ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +           \
 +        (_Packet)->Private.NdisPacketOobOffset))->MediaSpecificInformation;           \
 +          *(_pSizeMediaSpecificInfo) = ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +       \
 +            (_Packet)->Private.NdisPacketOobOffset))->SizeMediaSpecificInfo;              \
 +        }                                                                                 \
 +}
 +
 +
 +/*
 + * ULONG
 + * NDIS_GET_PACKET_PROTOCOL_TYPE(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_GET_PACKET_PROTOCOL_TYPE(_Packet) \
 +  ((_Packet)->Private.Flags & NDIS_PROTOCOL_ID_MASK)
 +
 +/*
 + * ULONG
 + * NDIS_GET_PACKET_HEADER_SIZE(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_GET_PACKET_HEADER_SIZE(_Packet) \
 +      ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) + \
 +      (_Packet)->Private.NdisPacketOobOffset))->HeaderSize
 +
 +
 +/*
 + * NDIS_STATUS
 + * NDIS_GET_PACKET_STATUS(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_GET_PACKET_STATUS(_Packet) \
 +      ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) + \
 +      (_Packet)->Private.NdisPacketOobOffset))->Status
 +
 +
 +/*
 + * ULONGLONG
 + * NDIS_GET_PACKET_TIME_RECEIVED(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_GET_PACKET_TIME_RECEIVED(_Packet)  \
 +      ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +  \
 +      (_Packet)->Private.NdisPacketOobOffset))->TimeReceived
 +
 +
 +/*
 + * ULONGLONG
 + * NDIS_GET_PACKET_TIME_SENT(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_GET_PACKET_TIME_SENT(_Packet)      \
 +      ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +  \
 +      (_Packet)->Private.NdisPacketOobOffset))->TimeSent
 +
 +
 +/*
 + * ULONGLONG
 + * NDIS_GET_PACKET_TIME_TO_SEND(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_GET_PACKET_TIME_TO_SEND(_Packet)   \
 +      ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +  \
 +      (_Packet)->Private.NdisPacketOobOffset))->TimeToSend
 +
 +
 +/*
 + * PNDIS_PACKET_OOB_DATA
 + * NDIS_OOB_DATA_FROM_PACKET(
 + *   IN PNDIS_PACKET  Packet);
 + */
 +#define NDIS_OOB_DATA_FROM_PACKET(_Packet)    \
 +  (PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) + \
 +  (_Packet)->Private.NdisPacketOobOffset)
 +
 +
 +/*
 + * VOID
 + * NdisQueryPacket(
 + *   IN PNDIS_PACKET  Packet,
 + *   OUT PUINT  PhysicalBufferCount  OPTIONAL,
 + *   OUT PUINT  BufferCount  OPTIONAL,
 + *   OUT PNDIS_BUFFER  *FirstBuffer  OPTIONAL,
 + *   OUT PUINT  TotalPacketLength  OPTIONAL);
 + */
 +static __inline
 +VOID
 +NdisQueryPacket(
 +    IN PNDIS_PACKET  Packet,
 +    OUT PUINT  PhysicalBufferCount  OPTIONAL,
 +    OUT PUINT  BufferCount  OPTIONAL,
 +    OUT PNDIS_BUFFER  *FirstBuffer  OPTIONAL,
 +    OUT PUINT  TotalPacketLength  OPTIONAL)
 +{
 +    if (FirstBuffer)
 +        *FirstBuffer = Packet->Private.Head;
 +    if (TotalPacketLength || BufferCount || PhysicalBufferCount)
 +    {
 +        if (!Packet->Private.ValidCounts)
 +        {
 +            UINT Offset;
 +            UINT PacketLength;
 +            PNDIS_BUFFER NdisBuffer;
 +            UINT PhysicalBufferCount = 0;
 +            UINT TotalPacketLength = 0;
 +            UINT Count = 0;
 +
 +            for (NdisBuffer = Packet->Private.Head;
 +                 NdisBuffer != (PNDIS_BUFFER)NULL;
 +                 NdisBuffer = NdisBuffer->Next)
 +            {
 +                PhysicalBufferCount += NDIS_BUFFER_TO_SPAN_PAGES(NdisBuffer);
 +                NdisQueryBufferOffset(NdisBuffer, &Offset, &PacketLength);
 +                TotalPacketLength += PacketLength;
 +                Count++;
 +            }
 +            Packet->Private.PhysicalCount = PhysicalBufferCount;
 +            Packet->Private.TotalLength = TotalPacketLength;
 +            Packet->Private.Count = Count;
 +            Packet->Private.ValidCounts = TRUE;
 +        }
 +
 +        if (PhysicalBufferCount)
 +            *PhysicalBufferCount = Packet->Private.PhysicalCount;
 +
 +        if (BufferCount)
 +            *BufferCount = Packet->Private.Count;
 +
 +        if (TotalPacketLength)
 +            *TotalPacketLength = Packet->Private.TotalLength;
 +    }
 +}
 +
 +/*
 + * VOID
 + * NdisQueryPacketLength(
 + *   IN PNDIS_PACKET  Packet,
 + *   OUT PUINT  PhysicalBufferCount  OPTIONAL,
 + *   OUT PUINT  BufferCount  OPTIONAL,
 + *   OUT PNDIS_BUFFER  *FirstBuffer  OPTIONAL,
 + *   OUT PUINT  TotalPacketLength  OPTIONAL);
 + */
 +#define NdisQueryPacketLength(Packet,                                     \
 +                              TotalPacketLength)                          \
 +{                                                                         \
 +  if ((TotalPacketLength))                                                \
 +  {                                                                       \
 +    if (!(Packet)->Private.ValidCounts) {                                 \
 +      UINT _Offset;                                                       \
 +      UINT _PacketLength;                                                 \
 +      PNDIS_BUFFER _NdisBuffer;                                           \
 +      UINT _PhysicalBufferCount = 0;                                      \
 +      UINT _TotalPacketLength   = 0;                                      \
 +      UINT _Count               = 0;                                      \
 +                                                                          \
 +      for (_NdisBuffer = (Packet)->Private.Head;                          \
 +        _NdisBuffer != (PNDIS_BUFFER)NULL;                                \
 +        _NdisBuffer = _NdisBuffer->Next)                                  \
 +      {                                                                   \
 +        _PhysicalBufferCount += NDIS_BUFFER_TO_SPAN_PAGES(_NdisBuffer);   \
 +        NdisQueryBufferOffset(_NdisBuffer, &_Offset, &_PacketLength);     \
 +        _TotalPacketLength += _PacketLength;                              \
 +        _Count++;                                                         \
 +      }                                                                   \
 +      (Packet)->Private.PhysicalCount = _PhysicalBufferCount;             \
 +      (Packet)->Private.TotalLength   = _TotalPacketLength;               \
 +      (Packet)->Private.Count         = _Count;                           \
 +      (Packet)->Private.ValidCounts   = TRUE;                             \
 +  }                                                                       \
 +                                                                          \
 +  if (TotalPacketLength)                                                  \
 +      *((PUINT)TotalPacketLength) = (Packet)->Private.TotalLength;        \
 +  } \
 +}
 +
 +
 +/*
 + * VOID
 + * NdisRecalculatePacketCounts(
 + *   IN OUT  PNDIS_PACKET  Packet);
 + */
 +#define NdisRecalculatePacketCounts(Packet)       \
 +{                                                 \
 +  PNDIS_BUFFER _Buffer = (Packet)->Private.Head;  \
 +  if (_Buffer != NULL)                            \
 +  {                                               \
 +      while (_Buffer->Next != NULL)               \
 +      {                                           \
 +          ยด_Buffer = _Buffer->Next;               \
 +      }                                           \
 +      (Packet)->Private.Tail = _Buffer;           \
 +  }                                               \
 +  (Packet)->Private.ValidCounts = FALSE;          \
 +}
 +
 +
 +/*
 + * VOID
 + * NdisReinitializePacket(
 + *   IN OUT  PNDIS_PACKET  Packet);
 + */
 +#define NdisReinitializePacketCounts(Packet)    \
 +{                                               \
 +      (Packet)->Private.Head = (PNDIS_BUFFER)NULL;  \
 +      (Packet)->Private.ValidCounts = FALSE;        \
 +}
 +
 +
 +/*
 + * VOID
 + * NdisSetPacketFlags(
 + *   IN PNDIS_PACKET  Packet,
 + *   IN UINT  Flags);
 + */
 +#define NdisSetPacketFlags(Packet, Flags) \
 +  (Packet)->Private.Flags |= (Flags);
 +
 +
 +/*
 + * VOID
 + * NDIS_SET_PACKET_HEADER_SIZE(
 + *   IN PNDIS_PACKET  Packet,
 + *   IN UINT  HdrSize);
 + */
 +#define NDIS_SET_PACKET_HEADER_SIZE(_Packet, _HdrSize)              \
 +  ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +                      \
 +  (_Packet)->Private.NdisPacketOobOffset))->HeaderSize = (_HdrSize)
 +
 +
 +/*
 + * VOID
 + * NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(
 + *   IN PNDIS_PACKET  Packet,
 + *   IN PVOID  MediaSpecificInfo,
 + *   IN UINT  SizeMediaSpecificInfo);
 + */
 +#define NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(_Packet,                      \
 +                                            _MediaSpecificInfo,           \
 +                                            _SizeMediaSpecificInfo)       \
 +{                                                                         \
 +  if ((_Packet)->Private.NdisPacketFlags & fPACKET_ALLOCATED_BY_NDIS)     \
 +        {                                                                     \
 +      (_Packet)->Private.NdisPacketFlags |= fPACKET_CONTAINS_MEDIA_SPECIFIC_INFO; \
 +      ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +                        \
 +        (_Packet)->Private.NdisPacketOobOffset))->MediaSpecificInformation = \
 +          (_MediaSpecificInfo);                                           \
 +      ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +                        \
 +        (_Packet)->Private.NdisPacketOobOffset))->SizeMediaSpecificInfo = \
 +          (_SizeMediaSpecificInfo);                                       \
 +        }                                                                     \
 +}
 +
 +
 +/*
 + * VOID
 + * NDIS_SET_PACKET_STATUS(
 + *   IN PNDIS_PACKET    Packet,
 + *   IN NDIS_STATUS     Status);
 + */
 +#define NDIS_SET_PACKET_STATUS(_Packet, _Status)  \
 +  ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +    \
 +  (_Packet)->Private.NdisPacketOobOffset))->Status = (_Status)
 +
 +
 +/*
 + * VOID
 + * NDIS_SET_PACKET_TIME_RECEIVED(
 + *   IN PNDIS_PACKET  Packet,
 + *   IN ULONGLONG  TimeReceived);
 + */
 +#define NDIS_SET_PACKET_TIME_RECEIVED(_Packet, _TimeReceived) \
 +  ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +                \
 +  (_Packet)->Private.NdisPacketOobOffset))->TimeReceived = (_TimeReceived)
 +
 +
 +/*
 + * VOID
 + * NDIS_SET_PACKET_TIME_SENT(
 + *   IN PNDIS_PACKET  Packet,
 + *   IN ULONGLONG  TimeSent);
 + */
 +#define NDIS_SET_PACKET_TIME_SENT(_Packet, _TimeSent) \
 +  ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +        \
 +  (_Packet)->Private.NdisPacketOobOffset))->TimeSent = (_TimeSent)
 +
 +
 +/*
 + * VOID
 + * NDIS_SET_PACKET_TIME_TO_SEND(
 + *   IN PNDIS_PACKET  Packet,
 + *   IN ULONGLONG  TimeToSend);
 + */
 +#define NDIS_SET_PACKET_TIME_TO_SEND(_Packet, _TimeToSend)  \
 +  ((PNDIS_PACKET_OOB_DATA)((PUCHAR)(_Packet) +              \
 +  (_Packet)->Private.NdisPacketOobOffset))->TimeToSend = (_TimeToSend)
 +
 +
 +/*
 + * VOID
 + * NdisSetSendFlags(
 + *   IN PNDIS_PACKET  Packet,
 + *   IN UINT  Flags);
 + */
 +#define NdisSetSendFlags(_Packet,_Flags)(_Packet)->Private.Flags = (_Flags)
 +
 +
 +
 +/* Memory management routines */
 +
 +#if BINARY_COMPATIBLE
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCreateLookaheadBufferFromSharedMemory(
 +  IN PVOID  pSharedMemory,
 +  IN UINT  LookaheadLength,
 +  OUT PVOID  *pLookaheadBuffer);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisDestroyLookaheadBufferFromSharedMemory(
 +  IN PVOID  pLookaheadBuffer);
 +
 +#else
 +
 +/*
 + * VOID
 + * NdisCreateLookaheadBufferFromSharedMemory(
 + *   IN PVOID  pSharedMemory,
 + *   IN UINT  LookaheadLength,
 + *   OUT PVOID  *pLookaheadBuffer)
 + */
 +#define NdisCreateLookaheadBufferFromSharedMemory(_pSharedMemory,     \
 +                                                  _LookaheadLength,   \
 +                                                  _pLookaheadBuffer)  \
 +  ((*(_pLookaheadBuffer)) = (_pSharedMemory))
 +
 +/*
 + * VOID
 + * NdisDestroyLookaheadBufferFromSharedMemory(
 + *   IN PVOID  pLookaheadBuffer)
 + */
 +#define NdisDestroyLookaheadBufferFromSharedMemory(_pLookaheadBuffer)
 +
 +#endif
 +
 +#if defined(_M_IX86) || defined(_M_AMD64) || defined(_M_ARM) || defined(_M_PPC)
 +
 +/*
 + * VOID
 + * NdisMoveMappedMemory(
 + *   OUT PVOID  Destination,
 + *   IN PVOID  Source,
 + *   IN ULONG  Length);
 + */
 +#define NdisMoveMappedMemory(Destination, Source, Length) \
 +  RtlCopyMemory(Destination, Source, Length)
 +
 +/*
 + * VOID
 + * NdisZeroMappedMemory(
 + *   IN PVOID  Destination,
 + *   IN ULONG  Length);
 + */
 +#define NdisZeroMappedMemory(Destination, Length) \
 +  RtlZeroMemory(Destination, Length)
 +
 +#else
 +
 +#define NdisMoveMappedMemory(Destination, Source, Length) \
 +{ \
 +  PUCHAR _Dest = Destination, _Src = Source, _End = _Dest + Length; \
 +  while (_Dest < _End) \
 +    *_Dest++ = _Src++; \
 +}
 +
 +#define NdisZeroMappedMemory(Destination, Length) \
 +{ \
 +  PUCHAR _Dest = Destination, _End = _Dest + Length; \
 +  while (_Dest < _End) \
 +    *_Dest++ = 0; \
 +}
 +
 +#endif /* _M_IX86 or _M_AMD64 */
 +
 +/*
 + * VOID
 + * NdisMoveFromMappedMemory(
 + *   OUT PVOID  Destination,
 + *   IN PVOID  Source,
 + *   IN ULONG  Length);
 + */
 +#define NdisMoveFromMappedMemory(Destination, Source, Length) \
 +  NdisMoveMappedMemory(Destination, Source, Length)
 +
 +/*
 + * VOID
 + * NdisMoveToMappedMemory(
 + *   OUT PVOID  Destination,
 + *   IN PVOID  Source,
 + *   IN ULONG  Length);
 + */
 +#define NdisMoveToMappedMemory(Destination, Source, Length) \
 +  NdisMoveMappedMemory(Destination, Source, Length)
 +
 +/*
 + * VOID
 + * NdisMUpdateSharedMemory(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle,
 + *   IN ULONG  Length,
 + *   IN PVOID  VirtualAddress,
 + *   IN NDIS_PHYSICAL_ADDRESS  PhysicalAddress);
 + */
 +#define NdisMUpdateSharedMemory(_H, _L, _V, _P) \
 +  NdisUpdateSharedMemory(_H, _L, _V, _P)
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisAllocateMemory(
 +  OUT  PVOID  *VirtualAddress,
 +  IN UINT  Length,
 +  IN UINT  MemoryFlags,
 +  IN NDIS_PHYSICAL_ADDRESS  HighestAcceptableAddress);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisFreeMemory(
 +  IN PVOID  VirtualAddress,
 +  IN UINT  Length,
 +  IN UINT  MemoryFlags);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisImmediateReadSharedMemory(
 +  IN NDIS_HANDLE WrapperConfigurationContext,
 +  IN ULONG       SharedMemoryAddress,
 +  OUT PUCHAR      Buffer,
 +  IN ULONG       Length);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisImmediateWriteSharedMemory(
 +  IN NDIS_HANDLE WrapperConfigurationContext,
 +  IN ULONG       SharedMemoryAddress,
 +  IN PUCHAR      Buffer,
 +  IN ULONG       Length);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMAllocateSharedMemory(
 +  IN  NDIS_HANDLE  MiniportAdapterHandle,
 +  IN  ULONG  Length,
 +  IN  BOOLEAN  Cached,
 +  OUT  PVOID  *VirtualAddress,
 +  OUT  PNDIS_PHYSICAL_ADDRESS  PhysicalAddress);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMAllocateSharedMemoryAsync(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN ULONG  Length,
 +  IN BOOLEAN  Cached,
 +  IN PVOID  Context);
 +
 +#if defined(NDIS50)
 +
 +#define NdisUpdateSharedMemory(NdisAdapterHandle, \
 +                               Length,            \
 +                               VirtualAddress,    \
 +                               PhysicalAddress)
 +
 +#else
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisUpdateSharedMemory(
 +  IN NDIS_HANDLE             NdisAdapterHandle,
 +  IN ULONG                   Length,
 +  IN PVOID                   VirtualAddress,
 +  IN NDIS_PHYSICAL_ADDRESS   PhysicalAddress);
 +
 +#endif /* defined(NDIS50) */
 +
 +/*
 + * ULONG
 + * NdisGetPhysicalAddressHigh(
 + *   IN NDIS_PHYSICAL_ADDRESS  PhysicalAddress);
 + */
 +#define NdisGetPhysicalAddressHigh(PhysicalAddress) \
 +  ((PhysicalAddress).HighPart)
 +
 +/*
 + * VOID
 + * NdisSetPhysicalAddressHigh(
 + *   IN NDIS_PHYSICAL_ADDRESS  PhysicalAddress,
 + *   IN ULONG  Value);
 + */
 +#define NdisSetPhysicalAddressHigh(PhysicalAddress, Value) \
 +  ((PhysicalAddress).HighPart) = (Value)
 +
 +/*
 + * ULONG
 + * NdisGetPhysicalAddressLow(
 + *   IN NDIS_PHYSICAL_ADDRESS  PhysicalAddress);
 + */
 +#define NdisGetPhysicalAddressLow(PhysicalAddress) \
 +  ((PhysicalAddress).LowPart)
 +
 +
 +/*
 + * VOID
 + * NdisSetPhysicalAddressLow(
 + *   IN NDIS_PHYSICAL_ADDRESS  PhysicalAddress,
 + *   IN ULONG  Value);
 + */
 +#define NdisSetPhysicalAddressLow(PhysicalAddress, Value) \
 +  ((PhysicalAddress).LowPart) = (Value)
 +
 +/*
 + * VOID
 + * NDIS_PHYSICAL_ADDRESS_CONST(
 + *   IN ULONG  Low,
 + *   IN LONG  High);
 + */
 +#define NDIS_PHYSICAL_ADDRESS_CONST(Low, High)  \
 +    { {(ULONG)(Low), (LONG)(High)} }
 +
 +/*
 + * ULONG
 + * NdisEqualMemory(
 + *  IN CONST VOID  *Source1,
 + *  IN CONST VOID  *Source2,
 + *  IN ULONG  Length);
 + */
 +#define NdisEqualMemory(Source1, Source2, Length) \
 +  RtlEqualMemory(Source1, Source2, Length)
 +
 +/*
 + * VOID
 + * NdisFillMemory(
 + *   IN PVOID  Destination,
 + *   IN ULONG  Length,
 + *   IN UCHAR  Fill);
 + */
 +#define NdisFillMemory(Destination, Length, Fill) \
 +  RtlFillMemory(Destination, Length, Fill)
 +
 +/*
 + * VOID
 + * NdisMoveMemory(
 + *   OUT  PVOID  Destination,
 + *   IN PVOID  Source,
 + *   IN ULONG  Length);
 + */
 +#define NdisMoveMemory(Destination, Source, Length) \
 +  RtlCopyMemory(Destination, Source, Length)
 +
 +
 +/*
 + * VOID
 + * NdisRetrieveUlong(
 + *   IN PULONG  DestinationAddress,
 + *   IN PULONG  SourceAddress);
 + */
 +#define NdisRetrieveUlong(DestinationAddress, SourceAddress) \
 +  RtlRetrieveUlong(DestinationAddress, SourceAddress)
 +
 +
 +/*
 + * VOID
 + * NdisStoreUlong(
 + *   IN PULONG  DestinationAddress,
 + *   IN ULONG  Value);
 + */
 +#define NdisStoreUlong(DestinationAddress, Value) \
 +  RtlStoreUlong(DestinationAddress, Value)
 +
 +
 +/*
 + * VOID
 + * NdisZeroMemory(
 + *   IN PVOID  Destination,
 + *   IN ULONG  Length)
 + */
 +#define NdisZeroMemory(Destination, Length) \
 +  RtlZeroMemory(Destination, Length)
 +
 +
 +
 +/* Configuration routines */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisOpenConfiguration(
 +  OUT  PNDIS_STATUS  Status,
 +  OUT  PNDIS_HANDLE  ConfigurationHandle,
 +  IN NDIS_HANDLE  WrapperConfigurationContext);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisReadNetworkAddress(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PVOID  *NetworkAddress,
 +  OUT PUINT  NetworkAddressLength,
 +  IN NDIS_HANDLE  ConfigurationHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisReadEisaSlotInformation(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  WrapperConfigurationContext,
 +  OUT PUINT  SlotNumber,
 +  OUT PNDIS_EISA_FUNCTION_INFORMATION  EisaData);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisReadEisaSlotInformationEx(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  WrapperConfigurationContext,
 +  OUT PUINT  SlotNumber,
 +  OUT PNDIS_EISA_FUNCTION_INFORMATION  *EisaData,
 +  OUT PUINT  NumberOfFunctions);
 +
 +NDISAPI
 +ULONG
 +DDKAPI
 +NdisReadPciSlotInformation(
 +  IN NDIS_HANDLE  NdisAdapterHandle,
 +  IN ULONG  SlotNumber,
 +  IN ULONG  Offset,
 +  IN PVOID  Buffer,
 +  IN ULONG  Length);
 +
 +NDISAPI
 +ULONG
 +DDKAPI
 +NdisWritePciSlotInformation(
 +  IN NDIS_HANDLE  NdisAdapterHandle,
 +  IN ULONG  SlotNumber,
 +  IN ULONG  Offset,
 +  IN PVOID  Buffer,
 +  IN ULONG  Length);
 +
 +
 +
 +/* String management routines */
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisAnsiStringToUnicodeString(
 +  IN OUT PNDIS_STRING  DestinationString,
 +  IN PNDIS_ANSI_STRING  SourceString);
 +
 +/*
 + * BOOLEAN
 + * NdisEqualString(
 + *   IN PNDIS_STRING  String1,
 + *   IN PNDIS_STRING  String2,
 + *   IN BOOLEAN  CaseInsensitive);
 + */
 +#define NdisEqualString(_String1, _String2, _CaseInsensitive) \
 +  RtlEqualUnicodeString(_String1, _String2, _CaseInsensitive)
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisInitAnsiString(
 +  IN OUT PNDIS_ANSI_STRING  DestinationString,
 +  IN PCSTR  SourceString);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisInitUnicodeString(
 +  IN OUT PNDIS_STRING  DestinationString,
 +  IN PCWSTR  SourceString);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisUnicodeStringToAnsiString(
 +  IN OUT PNDIS_ANSI_STRING  DestinationString,
 +  IN PNDIS_STRING  SourceString);
 +
 +#define NdisFreeString(_s)  NdisFreeMemory((_s).Buffer, (_s).MaximumLength, 0)
 +#define NdisPrintString(_s) DbgPrint("%ls", (_s).Buffer)
 +
 +
 +/* Spin lock reoutines */
 +
 +#if BINARY_COMPATIBLE
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisAllocateSpinLock(
 +  IN PNDIS_SPIN_LOCK  SpinLock);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisFreeSpinLock(
 +  IN PNDIS_SPIN_LOCK  SpinLock);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisAcquireSpinLock(
 +  IN PNDIS_SPIN_LOCK  SpinLock);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisReleaseSpinLock(
 +  IN PNDIS_SPIN_LOCK  SpinLock);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisDprAcquireSpinLock(
 +  IN PNDIS_SPIN_LOCK  SpinLock);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisDprReleaseSpinLock(
 +  IN PNDIS_SPIN_LOCK  SpinLock);
 +
 +#else
 +
 +/*
 + * VOID
 + * NdisAllocateSpinLock(
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 + */
 +#define NdisAllocateSpinLock(_SpinLock) \
 +  KeInitializeSpinLock(&(_SpinLock)->SpinLock)
 +
 +/*
 + * VOID
 + * NdisFreeSpinLock(
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 + */
 +#define NdisFreeSpinLock(_SpinLock)
 +
 +/*
 + * VOID
 + * NdisAcquireSpinLock(
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 + */
 +#define NdisAcquireSpinLock(_SpinLock) \
 +  KeAcquireSpinLock(&(_SpinLock)->SpinLock, &(_SpinLock)->OldIrql)
 +
 +/*
 + * VOID
 + * NdisReleaseSpinLock(
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 + */
 +#define NdisReleaseSpinLock(_SpinLock) \
 +  KeReleaseSpinLock(&(_SpinLock)->SpinLock, (_SpinLock)->OldIrql)
 +
 +/*
 + * VOID
 + * NdisDprAcquireSpinLock(
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 + */
 +#define NdisDprAcquireSpinLock(_SpinLock)                \
 +{                                                       \
 +    KeAcquireSpinLockAtDpcLevel(&(_SpinLock)->SpinLock); \
 +    (_SpinLock)->OldIrql = DISPATCH_LEVEL;               \
 +}
 +
 +/*
 + * VOID
 + * NdisDprReleaseSpinLock(
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 + */
 +#define NdisDprReleaseSpinLock(_SpinLock) \
 +  KeReleaseSpinLockFromDpcLevel(&(_SpinLock)->SpinLock)
 +
 +#endif /* BINARY_COMPATIBLE */
 +
 +/* I/O routines */
 +
 +/*
 + * VOID
 + * NdisRawReadPortBufferUchar(
 + *   IN ULONG  Port,
 + *   OUT PUCHAR  Buffer,
 + *   IN ULONG  Length);
 + */
 +#define NdisRawReadPortBufferUchar(Port, Buffer, Length)    \
 +  READ_PORT_BUFFER_UCHAR((PUCHAR)(Port), (PUCHAR)(Buffer), (Length))
 +
 +/*
 + * VOID
 + * NdisRawReadPortBufferUlong(
 + *   IN ULONG  Port,
 + *   OUT PULONG  Buffer,
 + *   IN ULONG  Length);
 + */
 +#define NdisRawReadPortBufferUlong(Port, Buffer, Length)  \
 +  READ_PORT_BUFFER_ULONG((PULONG)(Port), (PULONG)(Buffer), (Length))
 +
 +/*
 + * VOID
 + * NdisRawReadPortBufferUshort(
 + *   IN ULONG  Port,
 + *   OUT PUSHORT  Buffer,
 + *   IN ULONG  Length);
 + */
 +#define NdisRawReadPortBufferUshort(Port, Buffer, Length) \
 +  READ_PORT_BUFFER_USHORT((PUSHORT)(Port), (PUSHORT)(Buffer), (Length))
 +
 +
 +/*
 + * VOID
 + * NdisRawReadPortUchar(
 + *   IN ULONG  Port,
 + *   OUT PUCHAR  Data);
 + */
 +#define NdisRawReadPortUchar(Port, Data) \
 +  *(Data) = READ_PORT_UCHAR((PUCHAR)(Port))
 +
 +/*
 + * VOID
 + * NdisRawReadPortUlong(
 + *   IN ULONG  Port,
 + *   OUT PULONG  Data);
 + */
 +#define NdisRawReadPortUlong(Port, Data) \
 +  *(Data) = READ_PORT_ULONG((PULONG)(Port))
 +
 +/*
 + * VOID
 + * NdisRawReadPortUshort(
 + *   IN ULONG   Port,
 + *   OUT PUSHORT Data);
 + */
 +#define NdisRawReadPortUshort(Port, Data) \
 +  *(Data) = READ_PORT_USHORT((PUSHORT)(Port))
 +
 +
 +/*
 + * VOID
 + * NdisRawWritePortBufferUchar(
 + *   IN ULONG  Port,
 + *   IN PUCHAR  Buffer,
 + *   IN ULONG  Length);
 + */
 +#define NdisRawWritePortBufferUchar(Port, Buffer, Length) \
 +  WRITE_PORT_BUFFER_UCHAR((PUCHAR)(Port), (PUCHAR)(Buffer), (Length))
 +
 +/*
 + * VOID
 + * NdisRawWritePortBufferUlong(
 + *   IN ULONG  Port,
 + *   IN PULONG  Buffer,
 + *   IN ULONG  Length);
 + */
 +#define NdisRawWritePortBufferUlong(Port, Buffer, Length) \
 +  WRITE_PORT_BUFFER_ULONG((PULONG)(Port), (PULONG)(Buffer), (Length))
 +
 +/*
 + * VOID
 + * NdisRawWritePortBufferUshort(
 + *   IN ULONG   Port,
 + *   IN PUSHORT Buffer,
 + *   IN ULONG   Length);
 + */
 +#define NdisRawWritePortBufferUshort(Port, Buffer, Length) \
 +  WRITE_PORT_BUFFER_USHORT((PUSHORT)(Port), (PUSHORT)(Buffer), (Length))
 +
 +
 +/*
 + * VOID
 + * NdisRawWritePortUchar(
 + *   IN ULONG  Port,
 + *   IN UCHAR  Data);
 + */
 +#define NdisRawWritePortUchar(Port, Data) \
 +  WRITE_PORT_UCHAR((PUCHAR)(Port), (UCHAR)(Data))
 +
 +/*
 + * VOID
 + * NdisRawWritePortUlong(
 + *   IN ULONG  Port,
 + *   IN ULONG  Data);
 + */
 +#define NdisRawWritePortUlong(Port, Data)   \
 +  WRITE_PORT_ULONG((PULONG)(Port), (ULONG)(Data))
 +
 +/*
 + * VOID
 + * NdisRawWritePortUshort(
 + *   IN ULONG  Port,
 + *   IN USHORT  Data);
 + */
 +#define NdisRawWritePortUshort(Port, Data) \
 +  WRITE_PORT_USHORT((PUSHORT)(Port), (USHORT)(Data))
 +
 +
 +/*
 + * VOID
 + * NdisReadRegisterUchar(
 + *   IN PUCHAR  Register,
 + *   OUT PUCHAR  Data);
 + */
 +#define NdisReadRegisterUchar(Register, Data) \
 +  *(Data) = *(Register)
 +
 +/*
 + * VOID
 + * NdisReadRegisterUlong(
 + *   IN PULONG  Register,
 + *   OUT PULONG  Data);
 + */
 +#define NdisReadRegisterUlong(Register, Data)   \
 +  *(Data) = *(Register)
 +
 +/*
 + * VOID
 + * NdisReadRegisterUshort(
 + *   IN PUSHORT  Register,
 + *   OUT PUSHORT  Data);
 + */
 +#define NdisReadRegisterUshort(Register, Data)  \
 +    *(Data) = *(Register)
 +
 +/*
 + * VOID
 + * NdisReadRegisterUchar(
 + *   IN PUCHAR  Register,
 + *   IN UCHAR  Data);
 + */
 +#define NdisWriteRegisterUchar(Register, Data) \
 +  WRITE_REGISTER_UCHAR((Register), (Data))
 +
 +/*
 + * VOID
 + * NdisReadRegisterUlong(
 + *   IN PULONG  Register,
 + *   IN ULONG  Data);
 + */
 +#define NdisWriteRegisterUlong(Register, Data) \
 +  WRITE_REGISTER_ULONG((Register), (Data))
 +
 +/*
 + * VOID
 + * NdisReadRegisterUshort(
 + *   IN PUSHORT  Register,
 + *   IN USHORT  Data);
 + */
 +#define NdisWriteRegisterUshort(Register, Data) \
 +  WRITE_REGISTER_USHORT((Register), (Data))
 +
 +
 +/* Linked lists */
 +
 +/*
 + * VOID
 + * NdisInitializeListHead(
 + *   IN PLIST_ENTRY  ListHead);
 + */
 +#define NdisInitializeListHead(_ListHead) \
 +  InitializeListHead(_ListHead)
 +
 +/*
 + * PLIST_ENTRY
 + * NdisInterlockedInsertHeadList(
 + *   IN PLIST_ENTRY  ListHead,
 + *   IN PLIST_ENTRY  ListEntry,
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 + */
 +#define NdisInterlockedInsertHeadList(_ListHead, _ListEntry, _SpinLock) \
 +  ExInterlockedInsertHeadList(_ListHead, _ListEntry, &(_SpinLock)->SpinLock)
 +
 +/*
 + * PLIST_ENTRY
 + * NdisInterlockedInsertTailList(
 + *   IN PLIST_ENTRY  ListHead,
 + *   IN PLIST_ENTRY  ListEntry,
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 + */
 +#define NdisInterlockedInsertTailList(_ListHead, _ListEntry, _SpinLock) \
 +  ExInterlockedInsertTailList(_ListHead, _ListEntry, &(_SpinLock)->SpinLock)
 +
 +/*
 + * PLIST_ENTRY
 + * NdisInterlockedRemoveHeadList(
 + *   IN PLIST_ENTRY  ListHead,
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 +*/
 +#define NdisInterlockedRemoveHeadList(_ListHead, _SpinLock) \
 +  ExInterlockedRemoveHeadList(_ListHead, &(_SpinLock)->SpinLock)
 +
 +/*
 + * VOID
 + * NdisInitializeSListHead(
 + *   IN PSLIST_HEADER  SListHead);
 + */
 +#define NdisInitializeSListHead(SListHead) ExInitializeSListHead(SListHead)
 +
 +/*
 + * USHORT NdisQueryDepthSList(
 + *   IN PSLIST_HEADER  SListHead);
 + */
 +#define NdisQueryDepthSList(SListHead) ExQueryDepthSList(SListHead)
 +
 +
 +
 +/* Interlocked routines */
 +
 +/*
 + * LONG
 + * NdisInterlockedDecrement(
 + *   IN PLONG  Addend);
 + */
 +#define NdisInterlockedDecrement(Addend) InterlockedDecrement(Addend)
 +
 +/*
 + * LONG
 + * NdisInterlockedIncrement(
 + *   IN PLONG  Addend);
 + */
 +#define NdisInterlockedIncrement(Addend) InterlockedIncrement(Addend)
 +
 +/*
 + * VOID
 + * NdisInterlockedAddUlong(
 + *   IN PULONG  Addend,
 + *   IN ULONG  Increment,
 + *   IN PNDIS_SPIN_LOCK  SpinLock);
 + */
 +#define NdisInterlockedAddUlong(_Addend, _Increment, _SpinLock) \
 +  ExInterlockedAddUlong(_Addend, _Increment, &(_SpinLock)->SpinLock)
 +
 +
 +
 +/* Miscellaneous routines */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCloseConfiguration(
 +  IN NDIS_HANDLE  ConfigurationHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisReadConfiguration(
 +  OUT  PNDIS_STATUS  Status,
 +  OUT  PNDIS_CONFIGURATION_PARAMETER  *ParameterValue,
 +  IN NDIS_HANDLE  ConfigurationHandle,
 +  IN PNDIS_STRING  Keyword,
 +  IN NDIS_PARAMETER_TYPE  ParameterType);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisWriteConfiguration(
 +  OUT  PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  WrapperConfigurationContext,
 +  IN PNDIS_STRING  Keyword,
 +  IN PNDIS_CONFIGURATION_PARAMETER  ParameterValue);
 +
 +NDISAPI
 +VOID
 +DDKCDECLAPI
 +NdisWriteErrorLogEntry(
 +      IN NDIS_HANDLE  NdisAdapterHandle,
 +      IN NDIS_ERROR_CODE  ErrorCode,
 +      IN ULONG  NumberOfErrorValues,
 +      IN ...);
 +
 +/*
 + * VOID
 + * NdisStallExecution(
 + *   IN UINT  MicrosecondsToStall)
 + */
 +#define NdisStallExecution KeStallExecutionProcessor
 +
 +#if BINARY_COMPATIBLE
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisGetCurrentSystemTime(
 +  IN PLARGE_INTEGER  pSystemTime);
 +
 +#else
 +
 +/*
 + * VOID
 + * NdisGetCurrentSystemTime(
 + *   IN PLARGE_INTEGER  pSystemTime);
 + */
 +#define NdisGetCurrentSystemTime KeQuerySystemTime
 +
 +#endif
 +
 +NDISAPI
 +CCHAR
 +DDKAPI
 +NdisSystemProcessorCount(VOID);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisGetCurrentProcessorCpuUsage(
 +  OUT PULONG  pCpuUsage);
 +
 +
 +
 +/* NDIS helper macros */
 +
 +/*
 + * VOID
 + * NDIS_INIT_FUNCTION(FunctionName)
 + */
 +#define NDIS_INIT_FUNCTION(FunctionName)    \
 +  alloc_text(init, FunctionName)
 +
 +/*
 + * VOID
 + * NDIS_PAGABLE_FUNCTION(FunctionName)
 + */
 +#define NDIS_PAGEABLE_FUNCTION(FunctionName) \
 +  alloc_text(page, FunctionName)
 +
 +#define NDIS_PAGABLE_FUNCTION NDIS_PAGEABLE_FUNCTION
 +
 +
 +/* NDIS 4.0 extensions */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMFreeSharedMemory(
 +      IN NDIS_HANDLE  MiniportAdapterHandle,
 +      IN ULONG  Length,
 +      IN BOOLEAN  Cached,
 +      IN PVOID  VirtualAddress,
 +      IN NDIS_PHYSICAL_ADDRESS  PhysicalAddress);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMWanIndicateReceive(
 +      OUT PNDIS_STATUS  Status,
 +      IN NDIS_HANDLE  MiniportAdapterHandle,
 +      IN NDIS_HANDLE  NdisLinkContext,
 +      IN PUCHAR  PacketBuffer,
 +      IN UINT  PacketSize);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMWanIndicateReceiveComplete(
 +  IN NDIS_HANDLE  MiniportAdapterHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMWanSendComplete(
 +      IN NDIS_HANDLE  MiniportAdapterHandle,
 +      IN PNDIS_WAN_PACKET  Packet,
 +      IN NDIS_STATUS  Status);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisPciAssignResources(
 +      IN NDIS_HANDLE  NdisMacHandle,
 +      IN NDIS_HANDLE  NdisWrapperHandle,
 +      IN NDIS_HANDLE  WrapperConfigurationContext,
 +      IN ULONG  SlotNumber,
 +      OUT PNDIS_RESOURCE_LIST  *AssignedResources);
 +
 +
 +/* NDIS 5.0 extensions */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisAcquireReadWriteLock(
 +  IN PNDIS_RW_LOCK  Lock,
 +  IN BOOLEAN  fWrite,
 +  IN PLOCK_STATE  LockState);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisAllocateMemoryWithTag(
 +  OUT PVOID  *VirtualAddress,
 +  IN UINT  Length,
 +  IN ULONG  Tag);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisAllocatePacketPoolEx(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_HANDLE  PoolHandle,
 +  IN UINT  NumberOfDescriptors,
 +  IN UINT  NumberOfOverflowDescriptors,
 +  IN UINT  ProtocolReservedLength);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCompletePnPEvent(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisBindingHandle,
 +  IN PNET_PNP_EVENT  NetPnPEvent);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisGetCurrentProcessorCounts(
 +  OUT PULONG  pIdleCount,
 +  OUT PULONG  pKernelAndUser,
 +  OUT PULONG  pIndex);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisGetDriverHandle(
 +  IN PNDIS_HANDLE  NdisBindingHandle,
 +  OUT PNDIS_HANDLE  NdisDriverHandle);
 +
 +NDISAPI
 +PNDIS_PACKET
 +DDKAPI
 +NdisGetReceivedPacket(
 +  IN PNDIS_HANDLE  NdisBindingHandle,
 +  IN PNDIS_HANDLE  MacContext);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisGetSystemUpTime(
 +  OUT PULONG  pSystemUpTime);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisInitializeReadWriteLock(
 +  IN PNDIS_RW_LOCK  Lock);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMDeregisterDevice(
 +  IN NDIS_HANDLE  NdisDeviceHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMGetDeviceProperty(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN OUT PDEVICE_OBJECT  *PhysicalDeviceObject  OPTIONAL,
 +  IN OUT PDEVICE_OBJECT  *FunctionalDeviceObject  OPTIONAL,
 +  IN OUT PDEVICE_OBJECT  *NextDeviceObject  OPTIONAL,
 +  IN OUT PCM_RESOURCE_LIST  *AllocatedResources  OPTIONAL,
 +  IN OUT PCM_RESOURCE_LIST  *AllocatedResourcesTranslated  OPTIONAL);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMInitializeScatterGatherDma(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN BOOLEAN  Dma64BitAddresses,
 +  IN ULONG  MaximumPhysicalMapping);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMPromoteMiniport(
 +  IN NDIS_HANDLE  MiniportAdapterHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMQueryAdapterInstanceName(
 +  OUT PNDIS_STRING  AdapterInstanceName,
 +  IN NDIS_HANDLE  MiniportAdapterHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMRegisterDevice(
 +  IN NDIS_HANDLE  NdisWrapperHandle,
 +  IN PNDIS_STRING  DeviceName,
 +  IN PNDIS_STRING  SymbolicName,
 +  IN PDRIVER_DISPATCH  MajorFunctions[],
 +  OUT PDEVICE_OBJECT  *pDeviceObject,
 +  OUT NDIS_HANDLE  *NdisDeviceHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMRegisterUnloadHandler(
 +  IN NDIS_HANDLE  NdisWrapperHandle,
 +  IN PDRIVER_UNLOAD  UnloadHandler);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMRemoveMiniport(
 +  IN NDIS_HANDLE  MiniportAdapterHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMSetMiniportSecondary(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN NDIS_HANDLE  PrimaryMiniportAdapterHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisOpenConfigurationKeyByIndex(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ConfigurationHandle,
 +  IN ULONG  Index,
 +  OUT PNDIS_STRING  KeyName,
 +  OUT PNDIS_HANDLE  KeyHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisOpenConfigurationKeyByName(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  ConfigurationHandle,
 +  IN PNDIS_STRING  SubKeyName,
 +  OUT PNDIS_HANDLE  SubKeyHandle);
 +
 +NDISAPI
 +UINT
 +DDKAPI
 +NdisPacketPoolUsage(
 +  IN NDIS_HANDLE  PoolHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisQueryAdapterInstanceName(
 +  OUT PNDIS_STRING  AdapterInstanceName,
 +  IN NDIS_HANDLE  NdisBindingHandle);
 +
 +NDISAPI
 +ULONG
 +DDKAPI
 +NdisReadPcmciaAttributeMemory(
 +  IN NDIS_HANDLE  NdisAdapterHandle,
 +  IN ULONG  Offset,
 +  IN PVOID  Buffer,
 +  IN ULONG  Length);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisReleaseReadWriteLock(
 +  IN PNDIS_RW_LOCK  Lock,
 +  IN PLOCK_STATE  LockState);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisWriteEventLogEntry(
 +  IN PVOID  LogHandle,
 +  IN NDIS_STATUS  EventCode,
 +  IN ULONG  UniqueEventValue,
 +  IN USHORT  NumStrings,
 +  IN PVOID  StringsList  OPTIONAL,
 +  IN ULONG  DataSize,
 +  IN PVOID  Data  OPTIONAL);
 +
 +NDISAPI
 +ULONG
 +DDKAPI
 +NdisWritePcmciaAttributeMemory(
 +  IN NDIS_HANDLE  NdisAdapterHandle,
 +  IN ULONG  Offset,
 +  IN PVOID  Buffer,
 +  IN ULONG  Length);
 +
 +
 +/* Connectionless services */
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisClAddParty(
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN NDIS_HANDLE  ProtocolPartyContext,
 +  IN OUT PCO_CALL_PARAMETERS  CallParameters,
 +  OUT PNDIS_HANDLE  NdisPartyHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisClCloseAddressFamily(
 +  IN NDIS_HANDLE  NdisAfHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisClCloseCall(
 +  IN NDIS_HANDLE NdisVcHandle,
 +  IN NDIS_HANDLE NdisPartyHandle  OPTIONAL,
 +  IN PVOID  Buffer  OPTIONAL,
 +  IN UINT  Size);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisClDeregisterSap(
 +  IN NDIS_HANDLE  NdisSapHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisClDropParty(
 +  IN NDIS_HANDLE  NdisPartyHandle,
 +  IN PVOID  Buffer  OPTIONAL,
 +  IN UINT  Size);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisClIncomingCallComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisClMakeCall(
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN OUT PCO_CALL_PARAMETERS  CallParameters,
 +  IN NDIS_HANDLE  ProtocolPartyContext  OPTIONAL,
 +  OUT PNDIS_HANDLE  NdisPartyHandle  OPTIONAL);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisClModifyCallQoS(
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisClOpenAddressFamily(
 +  IN NDIS_HANDLE  NdisBindingHandle,
 +  IN PCO_ADDRESS_FAMILY  AddressFamily,
 +  IN NDIS_HANDLE  ProtocolAfContext,
 +  IN PNDIS_CLIENT_CHARACTERISTICS  ClCharacteristics,
 +  IN UINT  SizeOfClCharacteristics,
 +  OUT PNDIS_HANDLE  NdisAfHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisClRegisterSap(
 +  IN NDIS_HANDLE  NdisAfHandle,
 +  IN NDIS_HANDLE  ProtocolSapContext,
 +  IN PCO_SAP  Sap,
 +  OUT PNDIS_HANDLE  NdisSapHandle);
 +
 +
 +/* Call Manager services */
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisCmActivateVc(
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN OUT PCO_CALL_PARAMETERS  CallParameters);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmAddPartyComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisPartyHandle,
 +  IN NDIS_HANDLE  CallMgrPartyContext  OPTIONAL,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmCloseAddressFamilyComplete(
 +  IN NDIS_STATUS Status,
 +  IN NDIS_HANDLE NdisAfHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmCloseCallComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN NDIS_HANDLE  NdisPartyHandle  OPTIONAL);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisCmDeactivateVc(
 +  IN NDIS_HANDLE  NdisVcHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmDeregisterSapComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisSapHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmDispatchCallConnected(
 +  IN NDIS_HANDLE  NdisVcHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisCmDispatchIncomingCall(
 +  IN NDIS_HANDLE  NdisSapHandle,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmDispatchIncomingCallQoSChange(
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmDispatchIncomingCloseCall(
 +  IN NDIS_STATUS  CloseStatus,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PVOID  Buffer  OPTIONAL,
 +  IN UINT  Size);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmDispatchIncomingDropParty(
 +  IN NDIS_STATUS  DropStatus,
 +  IN NDIS_HANDLE  NdisPartyHandle,
 +  IN PVOID  Buffer  OPTIONAL,
 +  IN UINT  Size);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmDropPartyComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisPartyHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmMakeCallComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN NDIS_HANDLE  NdisPartyHandle  OPTIONAL,
 +  IN NDIS_HANDLE  CallMgrPartyContext  OPTIONAL,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmModifyCallQoSComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmOpenAddressFamilyComplete(
 +  IN NDIS_STATUS Status,
 +  IN NDIS_HANDLE NdisAfHandle,
 +  IN NDIS_HANDLE CallMgrAfContext);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisCmRegisterAddressFamily(
 +  IN NDIS_HANDLE  NdisBindingHandle,
 +  IN PCO_ADDRESS_FAMILY  AddressFamily,
 +  IN PNDIS_CALL_MANAGER_CHARACTERISTICS  CmCharacteristics,
 +  IN UINT  SizeOfCmCharacteristics);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCmRegisterSapComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisSapHandle,
 +  IN NDIS_HANDLE  CallMgrSapContext);
 +
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMCmActivateVc(
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMCmCreateVc(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN NDIS_HANDLE  NdisAfHandle,
 +  IN NDIS_HANDLE  MiniportVcContext,
 +  OUT  PNDIS_HANDLE  NdisVcHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMCmDeactivateVc(
 +  IN NDIS_HANDLE  NdisVcHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMCmDeleteVc(
 +  IN NDIS_HANDLE  NdisVcHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMCmRegisterAddressFamily(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN PCO_ADDRESS_FAMILY  AddressFamily,
 +  IN PNDIS_CALL_MANAGER_CHARACTERISTICS  CmCharacteristics,
 +  IN UINT  SizeOfCmCharacteristics);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMCmRequest(
 +  IN NDIS_HANDLE  NdisAfHandle,
 +  IN NDIS_HANDLE  NdisVcHandle  OPTIONAL,
 +  IN NDIS_HANDLE  NdisPartyHandle  OPTIONAL,
 +  IN OUT  PNDIS_REQUEST  NdisRequest);
 +
 +
 +/* Connection-oriented services */
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisCoCreateVc(
 +  IN NDIS_HANDLE  NdisBindingHandle,
 +  IN NDIS_HANDLE  NdisAfHandle  OPTIONAL,
 +  IN NDIS_HANDLE  ProtocolVcContext,
 +  IN OUT PNDIS_HANDLE  NdisVcHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisCoDeleteVc(
 +  IN NDIS_HANDLE  NdisVcHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisCoRequest(
 +  IN NDIS_HANDLE  NdisBindingHandle,
 +  IN NDIS_HANDLE  NdisAfHandle  OPTIONAL,
 +  IN NDIS_HANDLE  NdisVcHandle  OPTIONAL,
 +  IN NDIS_HANDLE  NdisPartyHandle  OPTIONAL,
 +  IN OUT  PNDIS_REQUEST  NdisRequest);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCoRequestComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisAfHandle,
 +  IN NDIS_HANDLE  NdisVcHandle  OPTIONAL,
 +  IN NDIS_HANDLE  NdisPartyHandle  OPTIONAL,
 +  IN PNDIS_REQUEST  NdisRequest);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCoSendPackets(
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PPNDIS_PACKET  PacketArray,
 +  IN UINT  NumberOfPackets);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMCoActivateVcComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PCO_CALL_PARAMETERS  CallParameters);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMCoDeactivateVcComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisVcHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMCoIndicateReceivePacket(
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PPNDIS_PACKET  PacketArray,
 +  IN UINT  NumberOfPackets);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMCoIndicateStatus(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN NDIS_HANDLE  NdisVcHandle  OPTIONAL,
 +  IN NDIS_STATUS  GeneralStatus,
 +  IN PVOID  StatusBuffer  OPTIONAL,
 +  IN ULONG  StatusBufferSize);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMCoReceiveComplete(
 +  IN NDIS_HANDLE  MiniportAdapterHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMCoRequestComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN PNDIS_REQUEST  Request);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMCoSendComplete(
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  IN PNDIS_PACKET  Packet);
 +
 +
 +/* NDIS 5.0 extensions for intermediate drivers */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisIMAssociateMiniport(
 +  IN NDIS_HANDLE  DriverHandle,
 +  IN NDIS_HANDLE  ProtocolHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisIMCancelInitializeDeviceInstance(
 +  IN NDIS_HANDLE  DriverHandle,
 +  IN PNDIS_STRING  DeviceInstance);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisIMCopySendCompletePerPacketInfo(
 +  IN PNDIS_PACKET  DstPacket,
 +  IN PNDIS_PACKET  SrcPacket);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisIMCopySendPerPacketInfo(
 +  IN PNDIS_PACKET  DstPacket,
 +  IN PNDIS_PACKET  SrcPacket);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisIMDeregisterLayeredMiniport(
 +  IN NDIS_HANDLE  DriverHandle);
 +
 +NDISAPI
 +NDIS_HANDLE
 +DDKAPI
 +NdisIMGetBindingContext(
 +  IN NDIS_HANDLE  NdisBindingHandle);
 +
 +NDISAPI
 +NDIS_HANDLE
 +DDKAPI
 +NdisIMGetDeviceContext(
 +  IN NDIS_HANDLE  MiniportAdapterHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisIMInitializeDeviceInstanceEx(
 +  IN NDIS_HANDLE  DriverHandle,
 +  IN PNDIS_STRING  DriverInstance,
 +  IN NDIS_HANDLE  DeviceContext  OPTIONAL);
 +
 +NDISAPI
 +PSINGLE_LIST_ENTRY
 +DDKAPI
 +NdisInterlockedPopEntrySList(
 +  IN PSLIST_HEADER  ListHead,
 +  IN PKSPIN_LOCK  Lock);
 +
 +NDISAPI
 +PSINGLE_LIST_ENTRY
 +DDKAPI
 +NdisInterlockedPushEntrySList(
 +  IN PSLIST_HEADER  ListHead,
 +  IN PSINGLE_LIST_ENTRY  ListEntry,
 +  IN PKSPIN_LOCK  Lock);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisQueryBufferSafe(
 +  IN PNDIS_BUFFER  Buffer,
 +  OUT PVOID  *VirtualAddress  OPTIONAL,
 +  OUT PUINT  Length,
 +  IN UINT  Priority);
 +
 +/* Prototypes for NDIS_MINIPORT_CHARACTERISTICS */
 +
 +typedef BOOLEAN DDKAPI
 +(*W_CHECK_FOR_HANG_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext);
 +
 +typedef VOID DDKAPI
 +(*W_DISABLE_INTERRUPT_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext);
 +
 +typedef VOID DDKAPI
 +(*W_ENABLE_INTERRUPT_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext);
 +
 +typedef VOID DDKAPI
 +(*W_HALT_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext);
 +
 +typedef VOID DDKAPI
 +(*W_HANDLE_INTERRUPT_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_INITIALIZE_HANDLER)(
 +  OUT PNDIS_STATUS  OpenErrorStatus,
 +  OUT PUINT  SelectedMediumIndex,
 +  IN PNDIS_MEDIUM  MediumArray,
 +  IN UINT  MediumArraySize,
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN NDIS_HANDLE  WrapperConfigurationContext);
 +
 +typedef VOID DDKAPI
 +(*W_ISR_HANDLER)(
 +  OUT PBOOLEAN  InterruptRecognized,
 +  OUT PBOOLEAN  QueueMiniportHandleInterrupt,
 +  IN  NDIS_HANDLE  MiniportAdapterContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_QUERY_INFORMATION_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN NDIS_OID  Oid,
 +  IN PVOID  InformationBuffer,
 +  IN ULONG  InformationBufferLength,
 +  OUT PULONG  BytesWritten,
 +  OUT PULONG  BytesNeeded);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_RECONFIGURE_HANDLER)(
 +  OUT PNDIS_STATUS  OpenErrorStatus,
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN NDIS_HANDLE      WrapperConfigurationContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_RESET_HANDLER)(
 +  OUT PBOOLEAN  AddressingReset,
 +  IN NDIS_HANDLE  MiniportAdapterContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_SEND_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN PNDIS_PACKET  Packet,
 +  IN UINT  Flags);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*WM_SEND_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN NDIS_HANDLE  NdisLinkHandle,
 +  IN PNDIS_WAN_PACKET  Packet);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_SET_INFORMATION_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN NDIS_OID  Oid,
 +  IN PVOID  InformationBuffer,
 +  IN ULONG  InformationBufferLength,
 +  OUT PULONG  BytesRead,
 +  OUT PULONG  BytesNeeded);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_TRANSFER_DATA_HANDLER)(
 +  OUT PNDIS_PACKET  Packet,
 +  OUT PUINT  BytesTransferred,
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN NDIS_HANDLE  MiniportReceiveContext,
 +  IN UINT  ByteOffset,
 +  IN UINT  BytesToTransfer);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*WM_TRANSFER_DATA_HANDLER)(
 +  VOID);
 +
 +
 +/* NDIS structures available only to miniport drivers */
 +
 +#define NDIS30_MINIPORT_CHARACTERISTICS_S \
 +  UCHAR  MajorNdisVersion; \
 +  UCHAR  MinorNdisVersion; \
 +  USHORT Filler; \
 +  UINT  Reserved; \
 +  W_CHECK_FOR_HANG_HANDLER  CheckForHangHandler; \
 +  W_DISABLE_INTERRUPT_HANDLER  DisableInterruptHandler; \
 +  W_ENABLE_INTERRUPT_HANDLER  EnableInterruptHandler; \
 +  W_HALT_HANDLER  HaltHandler; \
 +  W_HANDLE_INTERRUPT_HANDLER  HandleInterruptHandler; \
 +  W_INITIALIZE_HANDLER  InitializeHandler; \
 +  W_ISR_HANDLER  ISRHandler; \
 +  W_QUERY_INFORMATION_HANDLER  QueryInformationHandler; \
 +  W_RECONFIGURE_HANDLER  ReconfigureHandler; \
 +  W_RESET_HANDLER  ResetHandler; \
 +  _ANONYMOUS_UNION union { \
 +    W_SEND_HANDLER  SendHandler; \
 +    WM_SEND_HANDLER  WanSendHandler; \
 +  } _UNION_NAME(u1); \
 +  W_SET_INFORMATION_HANDLER  SetInformationHandler; \
 +  _ANONYMOUS_UNION union { \
 +    W_TRANSFER_DATA_HANDLER  TransferDataHandler; \
 +    WM_TRANSFER_DATA_HANDLER  WanTransferDataHandler; \
 +  } _UNION_NAME(u2);
 +
 +typedef struct _NDIS30_MINIPORT_CHARACTERISTICS {
 +  NDIS30_MINIPORT_CHARACTERISTICS_S
 +} NDIS30_MINIPORT_CHARACTERISTICS, *PSNDIS30_MINIPORT_CHARACTERISTICS;
 +
 +
 +/* Extensions for NDIS 4.0 miniports */
 +
 +typedef VOID DDKAPI
 +(*W_SEND_PACKETS_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN PPNDIS_PACKET  PacketArray,
 +  IN UINT  NumberOfPackets);
 +
 +typedef VOID DDKAPI
 +(*W_RETURN_PACKET_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN PNDIS_PACKET  Packet);
 +
 +typedef VOID DDKAPI
 +(*W_ALLOCATE_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN PVOID  VirtualAddress,
 +  IN PNDIS_PHYSICAL_ADDRESS  PhysicalAddress,
 +  IN ULONG  Length,
 +  IN PVOID  Context);
 +
 +#ifdef __cplusplus
 +
 +#define NDIS40_MINIPORT_CHARACTERISTICS_S \
 +  NDIS30_MINIPORT_CHARACTERISTICS  Ndis30Chars; \
 +  W_RETURN_PACKET_HANDLER  ReturnPacketHandler; \
 +  W_SEND_PACKETS_HANDLER  SendPacketsHandler; \
 +  W_ALLOCATE_COMPLETE_HANDLER  AllocateCompleteHandler;
 +
 +#else /* !__cplusplus */
 +
 +#define NDIS40_MINIPORT_CHARACTERISTICS_S \
 +  NDIS30_MINIPORT_CHARACTERISTICS_S \
 +  W_RETURN_PACKET_HANDLER  ReturnPacketHandler; \
 +  W_SEND_PACKETS_HANDLER  SendPacketsHandler; \
 +  W_ALLOCATE_COMPLETE_HANDLER  AllocateCompleteHandler;
 +
 +#endif /* !__cplusplus */
 +
 +typedef struct _NDIS40_MINIPORT_CHARACTERISTICS {
 +  NDIS40_MINIPORT_CHARACTERISTICS_S
 +} NDIS40_MINIPORT_CHARACTERISTICS, *PNDIS40_MINIPORT_CHARACTERISTICS;
 +
 +
 +/* Extensions for NDIS 5.0 miniports */
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_CO_CREATE_VC_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN NDIS_HANDLE  NdisVcHandle,
 +  OUT PNDIS_HANDLE  MiniportVcContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_CO_DELETE_VC_HANDLER)(
 +  IN NDIS_HANDLE  MiniportVcContext);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_CO_ACTIVATE_VC_HANDLER)(
 +  IN NDIS_HANDLE  MiniportVcContext,
 +  IN OUT PCO_CALL_PARAMETERS  CallParameters);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_CO_DEACTIVATE_VC_HANDLER)(
 +  IN NDIS_HANDLE  MiniportVcContext);
 +
 +typedef VOID DDKAPI
 +(*W_CO_SEND_PACKETS_HANDLER)(
 +  IN NDIS_HANDLE  MiniportVcContext,
 +  IN PPNDIS_PACKET  PacketArray,
 +  IN UINT  NumberOfPackets);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*W_CO_REQUEST_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN NDIS_HANDLE  MiniportVcContext  OPTIONAL,
 +  IN OUT PNDIS_REQUEST  NdisRequest);
 +
 +#ifdef __cplusplus
 +
 +#define NDIS50_MINIPORT_CHARACTERISTICS_S \
 +  NDIS40_MINIPORT_CHARACTERISTICS  Ndis40Chars; \
 +  W_CO_CREATE_VC_HANDLER  CoCreateVcHandler; \
 +  W_CO_DELETE_VC_HANDLER  CoDeleteVcHandler; \
 +  W_CO_ACTIVATE_VC_HANDLER  CoActivateVcHandler; \
 +  W_CO_DEACTIVATE_VC_HANDLER  CoDeactivateVcHandler; \
 +  W_CO_SEND_PACKETS_HANDLER  CoSendPacketsHandler; \
 +  W_CO_REQUEST_HANDLER  CoRequestHandler;
 +
 +#else /* !__cplusplus */
 +
 +#define NDIS50_MINIPORT_CHARACTERISTICS_S \
 +  NDIS40_MINIPORT_CHARACTERISTICS_S \
 +  W_CO_CREATE_VC_HANDLER  CoCreateVcHandler; \
 +  W_CO_DELETE_VC_HANDLER  CoDeleteVcHandler; \
 +  W_CO_ACTIVATE_VC_HANDLER  CoActivateVcHandler; \
 +  W_CO_DEACTIVATE_VC_HANDLER  CoDeactivateVcHandler; \
 +  W_CO_SEND_PACKETS_HANDLER  CoSendPacketsHandler; \
 +  W_CO_REQUEST_HANDLER  CoRequestHandler;
 +
 +#endif /* !__cplusplus */
 +
 +typedef struct _NDIS50_MINIPORT_CHARACTERISTICS {
 +   NDIS50_MINIPORT_CHARACTERISTICS_S
 +} NDIS50_MINIPORT_CHARACTERISTICS, *PSNDIS50_MINIPORT_CHARACTERISTICS;
 +
 +
 +/* Extensions for NDIS 5.1 miniports */
 +
 +typedef VOID DDKAPI
 +(*W_CANCEL_SEND_PACKETS_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN PVOID  CancelId);
 +
 +
 +#if defined(NDIS51_MINIPORT)
 +typedef struct _NDIS_MINIPORT_CHARACTERISTICS {
 +  NDIS50_MINIPORT_CHARACTERISTICS_S
 +} NDIS_MINIPORT_CHARACTERISTICS, *PNDIS_MINIPORT_CHARACTERISTICS;
 +#elif defined(NDIS50_MINIPORT)
 +typedef struct _NDIS_MINIPORT_CHARACTERISTICS {
 +  NDIS50_MINIPORT_CHARACTERISTICS_S
 +} NDIS_MINIPORT_CHARACTERISTICS, *PNDIS_MINIPORT_CHARACTERISTICS;
 +#elif defined(NDIS40_MINIPORT)
 +typedef struct _NDIS_MINIPORT_CHARACTERISTICS {
 +  NDIS40_MINIPORT_CHARACTERISTICS_S
 +} NDIS_MINIPORT_CHARACTERISTICS, *PNDIS_MINIPORT_CHARACTERISTICS;
 +#else /* NDIS30 */
 +typedef struct _NDIS_MINIPORT_CHARACTERISTICS {
 +  NDIS30_MINIPORT_CHARACTERISTICS_S
 +} NDIS_MINIPORT_CHARACTERISTICS, *PNDIS_MINIPORT_CHARACTERISTICS;
 +#endif
 +
 +
 +typedef NDIS_STATUS DDKAPI
 +(*SEND_HANDLER)(
 +  IN NDIS_HANDLE  MacBindingHandle,
 +  IN PNDIS_PACKET  Packet);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*TRANSFER_DATA_HANDLER)(
 +  IN NDIS_HANDLE  MacBindingHandle,
 +  IN NDIS_HANDLE  MacReceiveContext,
 +  IN UINT  ByteOffset,
 +  IN UINT  BytesToTransfer,
 +  OUT PNDIS_PACKET  Packet,
 +  OUT PUINT  BytesTransferred);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*RESET_HANDLER)(
 +  IN NDIS_HANDLE  MacBindingHandle);
 +
 +typedef NDIS_STATUS DDKAPI
 +(*REQUEST_HANDLER)(
 +  IN NDIS_HANDLE   MacBindingHandle,
 +  IN PNDIS_REQUEST   NdisRequest);
 +
 +
 +
 +/* Structures available only to full MAC drivers */
 +
 +typedef BOOLEAN DDKAPI
 +(*PNDIS_INTERRUPT_SERVICE)(
 +  IN PVOID  InterruptContext);
 +
 +typedef VOID DDKAPI
 +(*PNDIS_DEFERRED_PROCESSING)(
 +  IN PVOID  SystemSpecific1,
 +  IN PVOID  InterruptContext,
 +  IN PVOID  SystemSpecific2,
 +  IN PVOID  SystemSpecific3);
 +
 +
 +
 +typedef struct _NDIS_MINIPORT_BLOCK NDIS_MINIPORT_BLOCK, *PNDIS_MINIPORT_BLOCK;
 +typedef struct _NDIS_PROTOCOL_BLOCK NDIS_PROTOCOL_BLOCK, *PNDIS_PROTOCOL_BLOCK;
 +typedef struct _NDIS_OPEN_BLOCK               NDIS_OPEN_BLOCK,     *PNDIS_OPEN_BLOCK;
 +typedef struct _NDIS_M_DRIVER_BLOCK NDIS_M_DRIVER_BLOCK, *PNDIS_M_DRIVER_BLOCK;
 +typedef       struct _NDIS_AF_LIST        NDIS_AF_LIST,        *PNDIS_AF_LIST;
 +
 +
 +typedef struct _NDIS_MINIPORT_INTERRUPT {
 +  PKINTERRUPT  InterruptObject;
 +  KSPIN_LOCK  DpcCountLock;
 +  PVOID  MiniportIdField;
 +  W_ISR_HANDLER  MiniportIsr;
 +  W_HANDLE_INTERRUPT_HANDLER  MiniportDpc;
 +  KDPC  InterruptDpc;
 +  PNDIS_MINIPORT_BLOCK  Miniport;
 +  UCHAR  DpcCount;
 +  BOOLEAN  Filler1;
 +  KEVENT  DpcsCompletedEvent;
 +  BOOLEAN  SharedInterrupt;
 +  BOOLEAN  IsrRequested;
 +} NDIS_MINIPORT_INTERRUPT, *PNDIS_MINIPORT_INTERRUPT;
 +
 +typedef struct _NDIS_MINIPORT_TIMER {
 +  KTIMER  Timer;
 +  KDPC  Dpc;
 +  PNDIS_TIMER_FUNCTION  MiniportTimerFunction;
 +  PVOID  MiniportTimerContext;
 +  PNDIS_MINIPORT_BLOCK  Miniport;
 +  struct _NDIS_MINIPORT_TIMER  *NextDeferredTimer;
 +} NDIS_MINIPORT_TIMER, *PNDIS_MINIPORT_TIMER;
 +
 +typedef struct _NDIS_INTERRUPT {
 +  PKINTERRUPT  InterruptObject;
 +  KSPIN_LOCK  DpcCountLock;
 +  PNDIS_INTERRUPT_SERVICE  MacIsr;
 +  PNDIS_DEFERRED_PROCESSING  MacDpc;
 +  KDPC  InterruptDpc;
 +  PVOID  InterruptContext;
 +  UCHAR  DpcCount;
 +  BOOLEAN      Removing;
 +  KEVENT  DpcsCompletedEvent;
 +} NDIS_INTERRUPT, *PNDIS_INTERRUPT;
 +
 +
 +typedef enum _NDIS_WORK_ITEM_TYPE {
 +  NdisWorkItemRequest,
 +  NdisWorkItemSend,
 +  NdisWorkItemReturnPackets,
 +  NdisWorkItemResetRequested,
 +  NdisWorkItemResetInProgress,
 +  NdisWorkItemHalt,
 +  NdisWorkItemSendLoopback,
 +  NdisWorkItemMiniportCallback,
 +  NdisMaxWorkItems
 +} NDIS_WORK_ITEM_TYPE, *PNDIS_WORK_ITEM_TYPE;
 +
 +#define       NUMBER_OF_WORK_ITEM_TYPES         NdisMaxWorkItems
 +#define       NUMBER_OF_SINGLE_WORK_ITEMS       6
 +
 +typedef struct _NDIS_MINIPORT_WORK_ITEM {
 +      SINGLE_LIST_ENTRY  Link;
 +      NDIS_WORK_ITEM_TYPE  WorkItemType;
 +      PVOID  WorkItemContext;
 +} NDIS_MINIPORT_WORK_ITEM, *PNDIS_MINIPORT_WORK_ITEM;
 +
 +/* Forward declare to pick up a consistent type */
 +typedef struct _NDIS_WORK_ITEM;
 +#pragma warning(push)
 +typedef VOID    (*NDIS_PROC)(struct _NDIS_WORK_ITEM *, PVOID);
 +#pragma warning(pop)
 +typedef struct _NDIS_WORK_ITEM
 +{
 +    PVOID Context;
 +    NDIS_PROC Routine;
 +    UCHAR WrapperReserved[8*sizeof(PVOID)];
 +} NDIS_WORK_ITEM, *PNDIS_WORK_ITEM;
 +
 +typedef struct _NDIS_BIND_PATHS {
 +      UINT  Number;
 +      NDIS_STRING  Paths[1];
 +} NDIS_BIND_PATHS, *PNDIS_BIND_PATHS;
 +
 +#define DECLARE_UNKNOWN_STRUCT(BaseName) \
 +  typedef struct _##BaseName BaseName, *P##BaseName;
 +
 +#define DECLARE_UNKNOWN_PROTOTYPE(Name) \
 +  typedef VOID (*(Name))(VOID);
 +
 +#define ETH_LENGTH_OF_ADDRESS 6
 +
 +DECLARE_UNKNOWN_STRUCT(ETH_BINDING_INFO)
 +
 +DECLARE_UNKNOWN_PROTOTYPE(ETH_ADDRESS_CHANGE)
 +DECLARE_UNKNOWN_PROTOTYPE(ETH_FILTER_CHANGE)
 +DECLARE_UNKNOWN_PROTOTYPE(ETH_DEFERRED_CLOSE)
 +
 +typedef struct _ETH_FILTER {
 +  PNDIS_SPIN_LOCK  Lock;
 +  CHAR  (*MCastAddressBuf)[ETH_LENGTH_OF_ADDRESS];
 +  struct _NDIS_MINIPORT_BLOCK  *Miniport;
 +  UINT  CombinedPacketFilter;
 +  PETH_BINDING_INFO  OpenList;
 +  ETH_ADDRESS_CHANGE  AddressChangeAction;
 +  ETH_FILTER_CHANGE  FilterChangeAction;
 +  ETH_DEFERRED_CLOSE  CloseAction;
 +  UINT  MaxMulticastAddresses;
 +  UINT  NumAddresses;
 +  UCHAR AdapterAddress[ETH_LENGTH_OF_ADDRESS];
 +  UINT  OldCombinedPacketFilter;
 +  CHAR  (*OldMCastAddressBuf)[ETH_LENGTH_OF_ADDRESS];
 +  UINT  OldNumAddresses;
 +  PETH_BINDING_INFO  DirectedList;
 +  PETH_BINDING_INFO  BMList;
 +  PETH_BINDING_INFO  MCastSet;
 +#if defined(NDIS_WRAPPER)
 +  UINT  NumOpens;
 +  PVOID  BindListLock;
 +#endif
 +} ETH_FILTER, *PETH_FILTER;
 +
 +typedef VOID DDKAPI
 +(*ETH_RCV_COMPLETE_HANDLER)(
 +  IN PETH_FILTER  Filter);
 +
 +typedef VOID DDKAPI
 +(*ETH_RCV_INDICATE_HANDLER)(
 +  IN PETH_FILTER  Filter,
 +  IN NDIS_HANDLE  MacReceiveContext,
 +  IN PCHAR  Address,
 +  IN PVOID  HeaderBuffer,
 +  IN UINT  HeaderBufferSize,
 +  IN PVOID  LookaheadBuffer,
 +  IN UINT  LookaheadBufferSize,
 +  IN UINT  PacketSize);
 +
 +typedef VOID DDKAPI
 +(*FDDI_RCV_COMPLETE_HANDLER)(
 +  IN PFDDI_FILTER  Filter);
 +
 +typedef VOID DDKAPI
 +(*FDDI_RCV_INDICATE_HANDLER)(
 +  IN PFDDI_FILTER  Filter,
 +  IN NDIS_HANDLE  MacReceiveContext,
 +  IN PCHAR  Address,
 +  IN UINT  AddressLength,
 +  IN PVOID  HeaderBuffer,
 +  IN UINT  HeaderBufferSize,
 +  IN PVOID  LookaheadBuffer,
 +  IN UINT  LookaheadBufferSize,
 +  IN UINT  PacketSize);
 +
 +typedef VOID DDKAPI
 +(*FILTER_PACKET_INDICATION_HANDLER)(
 +  IN NDIS_HANDLE  Miniport,
 +  IN PPNDIS_PACKET  PacketArray,
 +  IN UINT  NumberOfPackets);
 +
 +typedef VOID DDKAPI
 +(*TR_RCV_COMPLETE_HANDLER)(
 +  IN PTR_FILTER  Filter);
 +
 +typedef VOID DDKAPI
 +(*TR_RCV_INDICATE_HANDLER)(
 +  IN PTR_FILTER  Filter,
 +  IN NDIS_HANDLE  MacReceiveContext,
 +  IN PVOID  HeaderBuffer,
 +  IN UINT  HeaderBufferSize,
 +  IN PVOID  LookaheadBuffer,
 +  IN UINT  LookaheadBufferSize,
 +  IN UINT  PacketSize);
 +
 +typedef VOID DDKAPI
 +(*WAN_RCV_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN NDIS_HANDLE  NdisLinkContext);
 +
 +typedef VOID DDKAPI
 +(*WAN_RCV_HANDLER)(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN NDIS_HANDLE  NdisLinkContext,
 +  IN PUCHAR  Packet,
 +  IN ULONG  PacketSize);
 +
 +typedef VOID FASTCALL
 +(*NDIS_M_DEQUEUE_WORK_ITEM)(
 +  IN PNDIS_MINIPORT_BLOCK  Miniport,
 +  IN NDIS_WORK_ITEM_TYPE  WorkItemType,
 +  OUT PVOID  *WorkItemContext);
 +
 +typedef NDIS_STATUS FASTCALL
 +(*NDIS_M_QUEUE_NEW_WORK_ITEM)(
 +  IN PNDIS_MINIPORT_BLOCK  Miniport,
 +  IN NDIS_WORK_ITEM_TYPE  WorkItemType,
 +  IN PVOID  WorkItemContext);
 +
 +typedef NDIS_STATUS FASTCALL
 +(*NDIS_M_QUEUE_WORK_ITEM)(
 +  IN PNDIS_MINIPORT_BLOCK  Miniport,
 +  IN NDIS_WORK_ITEM_TYPE  WorkItemType,
 +  IN PVOID  WorkItemContext);
 +
 +typedef VOID DDKAPI
 +(*NDIS_M_REQ_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN NDIS_STATUS  Status);
 +
 +typedef VOID DDKAPI
 +(*NDIS_M_RESET_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN NDIS_STATUS  Status,
 +  IN BOOLEAN  AddressingReset);
 +
 +typedef VOID DDKAPI
 +(*NDIS_M_SEND_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN PNDIS_PACKET  Packet,
 +  IN NDIS_STATUS  Status);
 +
 +typedef VOID DDKAPI
 +(*NDIS_M_SEND_RESOURCES_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterHandle);
 +
 +typedef BOOLEAN FASTCALL
 +(*NDIS_M_START_SENDS)(
 +  IN PNDIS_MINIPORT_BLOCK  Miniport);
 +
 +typedef VOID DDKAPI
 +(*NDIS_M_STATUS_HANDLER)(
 +  IN NDIS_HANDLE  MiniportHandle,
 +  IN NDIS_STATUS  GeneralStatus,
 +  IN PVOID  StatusBuffer,
 +  IN UINT  StatusBufferSize);
 +
 +typedef VOID DDKAPI
 +(*NDIS_M_STS_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterHandle);
 +
 +typedef VOID DDKAPI
 +(*NDIS_M_TD_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN PNDIS_PACKET  Packet,
 +  IN NDIS_STATUS  Status,
 +  IN UINT  BytesTransferred);
 +
 +typedef VOID (DDKAPI *NDIS_WM_SEND_COMPLETE_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN PVOID  Packet,
 +  IN NDIS_STATUS  Status);
 +
 +
 +#if ARCNET
 +
 +#define ARC_SEND_BUFFERS                  8
 +#define ARC_HEADER_SIZE                   4
 +
 +typedef struct _NDIS_ARC_BUF {
 +  NDIS_HANDLE  ArcnetBufferPool;
 +  PUCHAR  ArcnetLookaheadBuffer;
 +  UINT  NumFree;
 +  ARC_BUFFER_LIST ArcnetBuffers[ARC_SEND_BUFFERS];
 +} NDIS_ARC_BUF, *PNDIS_ARC_BUF;
 +
 +#endif /* ARCNET */
 +
 +typedef struct _NDIS_LOG {
 +  PNDIS_MINIPORT_BLOCK  Miniport;
 +  KSPIN_LOCK  LogLock;
 +  PIRP  Irp;
 +  UINT  TotalSize;
 +  UINT  CurrentSize;
 +  UINT  InPtr;
 +  UINT  OutPtr;
 +  UCHAR  LogBuf[1];
 +} NDIS_LOG, *PNDIS_LOG;
 +
 +#if ARCNET
 +#define FILTERDBS_ARCNET_S \
 +  PARC_FILTER  ArcDB;
 +#else /* !ARCNET */
 +#define FILTERDBS_ARCNET_S \
 +  PVOID  XXXDB;
 +#endif /* !ARCNET */
 +
 +#define FILTERDBS_S \
 +  _ANONYMOUS_UNION union { \
 +    PETH_FILTER  EthDB; \
 +    PNULL_FILTER  NullDB; \
 +  } DUMMYUNIONNAME; \
 +  PTR_FILTER  TrDB; \
 +  PFDDI_FILTER  FddiDB; \
 +  FILTERDBS_ARCNET_S
 +
 +typedef struct _FILTERDBS {
 +  FILTERDBS_S
 +} FILTERDBS, *PFILTERDBS;
 +
 +
 +struct _NDIS_MINIPORT_BLOCK {
 +  PVOID  Signature;
 +  PNDIS_MINIPORT_BLOCK  NextMiniport;
 +  PNDIS_M_DRIVER_BLOCK  DriverHandle;
 +  NDIS_HANDLE  MiniportAdapterContext;
 +  UNICODE_STRING  MiniportName;
 +  PNDIS_BIND_PATHS  BindPaths;
 +  NDIS_HANDLE  OpenQueue;
 +  REFERENCE  ShortRef;
 +  NDIS_HANDLE  DeviceContext;
 +  UCHAR  Padding1;
 +  UCHAR  LockAcquired;
 +  UCHAR  PmodeOpens;
 +  UCHAR  AssignedProcessor;
 +  KSPIN_LOCK  Lock;
 +  PNDIS_REQUEST  MediaRequest;
 +  PNDIS_MINIPORT_INTERRUPT  Interrupt;
 +  ULONG  Flags;
 +  ULONG  PnPFlags;
 +  LIST_ENTRY  PacketList;
 +  PNDIS_PACKET  FirstPendingPacket;
 +  PNDIS_PACKET  ReturnPacketsQueue;
 +  ULONG  RequestBuffer;
 +  PVOID  SetMCastBuffer;
 +  PNDIS_MINIPORT_BLOCK  PrimaryMiniport;
 +  PVOID  WrapperContext;
 +  PVOID  BusDataContext;
 +  ULONG  PnPCapabilities;
 +  PCM_RESOURCE_LIST  Resources;
 +  NDIS_TIMER  WakeUpDpcTimer;
 +  UNICODE_STRING  BaseName;
 +  UNICODE_STRING  SymbolicLinkName;
 +  ULONG  CheckForHangSeconds;
 +  USHORT  CFHangTicks;
 +  USHORT  CFHangCurrentTick;
 +  NDIS_STATUS  ResetStatus;
 +  NDIS_HANDLE  ResetOpen;
 +  FILTERDBS_S
 +  FILTER_PACKET_INDICATION_HANDLER  PacketIndicateHandler;
 +  NDIS_M_SEND_COMPLETE_HANDLER  SendCompleteHandler;
 +  NDIS_M_SEND_RESOURCES_HANDLER  SendResourcesHandler;
 +  NDIS_M_RESET_COMPLETE_HANDLER  ResetCompleteHandler;
 +  NDIS_MEDIUM  MediaType;
 +  ULONG  BusNumber;
 +  NDIS_INTERFACE_TYPE  BusType;
 +  NDIS_INTERFACE_TYPE  AdapterType;
 +  PDEVICE_OBJECT  DeviceObject;
 +  PDEVICE_OBJECT  PhysicalDeviceObject;
 +  PDEVICE_OBJECT  NextDeviceObject;
 +  PMAP_REGISTER_ENTRY  MapRegisters;
 +  PNDIS_AF_LIST  CallMgrAfList;
 +  PVOID  MiniportThread;
 +  PVOID  SetInfoBuf;
 +  USHORT  SetInfoBufLen;
 +  USHORT  MaxSendPackets;
 +  NDIS_STATUS  FakeStatus;
 +  PVOID  LockHandler;
 +  PUNICODE_STRING  pAdapterInstanceName;
 +  PNDIS_MINIPORT_TIMER  TimerQueue;
 +  UINT  MacOptions;
 +  PNDIS_REQUEST  PendingRequest;
 +  UINT  MaximumLongAddresses;
 +  UINT  MaximumShortAddresses;
 +  UINT  CurrentLookahead;
 +  UINT  MaximumLookahead;
 +  W_HANDLE_INTERRUPT_HANDLER  HandleInterruptHandler;
 +  W_DISABLE_INTERRUPT_HANDLER  DisableInterruptHandler;
 +  W_ENABLE_INTERRUPT_HANDLER  EnableInterruptHandler;
 +  W_SEND_PACKETS_HANDLER  SendPacketsHandler;
 +  NDIS_M_START_SENDS  DeferredSendHandler;
 +  ETH_RCV_INDICATE_HANDLER  EthRxIndicateHandler;
 +  TR_RCV_INDICATE_HANDLER  TrRxIndicateHandler;
 +  FDDI_RCV_INDICATE_HANDLER  FddiRxIndicateHandler;
 +  ETH_RCV_COMPLETE_HANDLER  EthRxCompleteHandler;
 +  TR_RCV_COMPLETE_HANDLER  TrRxCompleteHandler;
 +  FDDI_RCV_COMPLETE_HANDLER  FddiRxCompleteHandler;
 +  NDIS_M_STATUS_HANDLER  StatusHandler;
 +  NDIS_M_STS_COMPLETE_HANDLER  StatusCompleteHandler;
 +  NDIS_M_TD_COMPLETE_HANDLER  TDCompleteHandler;
 +  NDIS_M_REQ_COMPLETE_HANDLER  QueryCompleteHandler;
 +  NDIS_M_REQ_COMPLETE_HANDLER  SetCompleteHandler;
 +  NDIS_WM_SEND_COMPLETE_HANDLER  WanSendCompleteHandler;
 +  WAN_RCV_HANDLER  WanRcvHandler;
 +  WAN_RCV_COMPLETE_HANDLER  WanRcvCompleteHandler;
 +#if defined(NDIS_WRAPPER)
 +  PNDIS_MINIPORT_BLOCK  NextGlobalMiniport;
 +  SINGLE_LIST_ENTRY  WorkQueue[NUMBER_OF_WORK_ITEM_TYPES];
 +  SINGLE_LIST_ENTRY  SingleWorkItems[NUMBER_OF_SINGLE_WORK_ITEMS];
 +  UCHAR  SendFlags;
 +  UCHAR  TrResetRing;
 +  UCHAR  ArcnetAddress;
 +  UCHAR  XState;
 +  _ANONYMOUS_UNION union {
 +#if ARCNET
 +    PNDIS_ARC_BUF  ArcBuf;
 +#endif
 +    PVOID  BusInterface;
 +  } DUMMYUNIONNAME;
 +  PNDIS_LOG  Log;
 +  ULONG  SlotNumber;
 +  PCM_RESOURCE_LIST  AllocatedResources;
 +  PCM_RESOURCE_LIST  AllocatedResourcesTranslated;
 +  SINGLE_LIST_ENTRY  PatternList;
 +  NDIS_PNP_CAPABILITIES  PMCapabilities;
 +  DEVICE_CAPABILITIES  DeviceCaps;
 +  ULONG  WakeUpEnable;
 +  DEVICE_POWER_STATE  CurrentDevicePowerState;
 +  PIRP  pIrpWaitWake;
 +  SYSTEM_POWER_STATE  WaitWakeSystemState;
 +  LARGE_INTEGER  VcIndex;
 +  KSPIN_LOCK  VcCountLock;
 +  LIST_ENTRY  WmiEnabledVcs;
 +  PNDIS_GUID  pNdisGuidMap;
 +  PNDIS_GUID  pCustomGuidMap;
 +  USHORT  VcCount;
 +  USHORT  cNdisGuidMap;
 +  USHORT  cCustomGuidMap;
 +  USHORT  CurrentMapRegister;
 +  PKEVENT  AllocationEvent;
 +  USHORT  BaseMapRegistersNeeded;
 +  USHORT  SGMapRegistersNeeded;
 +  ULONG  MaximumPhysicalMapping;
 +  NDIS_TIMER  MediaDisconnectTimer;
 +  USHORT  MediaDisconnectTimeOut;
 +  USHORT  InstanceNumber;
 +  NDIS_EVENT  OpenReadyEvent;
 +  NDIS_PNP_DEVICE_STATE  PnPDeviceState;
 +  NDIS_PNP_DEVICE_STATE  OldPnPDeviceState;
 +  PGET_SET_DEVICE_DATA  SetBusData;
 +  PGET_SET_DEVICE_DATA  GetBusData;
 +  KDPC  DeferredDpc;
 +#if 0
 +  /* FIXME: */
 +  NDIS_STATS  NdisStats;
 +#else
 +  ULONG  NdisStats;
 +#endif
 +  PNDIS_PACKET  IndicatedPacket[MAXIMUM_PROCESSORS];
 +  PKEVENT  RemoveReadyEvent;
 +  PKEVENT  AllOpensClosedEvent;
 +  PKEVENT  AllRequestsCompletedEvent;
 +  ULONG  InitTimeMs;
 +  NDIS_MINIPORT_WORK_ITEM  WorkItemBuffer[NUMBER_OF_SINGLE_WORK_ITEMS];
 +  PDMA_ADAPTER  SystemAdapterObject;
 +  ULONG  DriverVerifyFlags;
 +  POID_LIST  OidList;
 +  USHORT  InternalResetCount;
 +  USHORT  MiniportResetCount;
 +  USHORT  MediaSenseConnectCount;
 +  USHORT  MediaSenseDisconnectCount;
 +  PNDIS_PACKET  *xPackets;
 +  ULONG  UserModeOpenReferences;
 +  _ANONYMOUS_UNION union {
 +    PVOID  SavedSendHandler;
 +    PVOID  SavedWanSendHandler;
 +  } DUMMYUNIONNAME2;
 +  PVOID  SavedSendPacketsHandler;
 +  PVOID  SavedCancelSendPacketsHandler;
 +  W_SEND_PACKETS_HANDLER  WSendPacketsHandler;
 +  ULONG  MiniportAttributes;
 +  PDMA_ADAPTER  SavedSystemAdapterObject;
 +  USHORT  NumOpens;
 +  USHORT  CFHangXTicks;
 +  ULONG  RequestCount;
 +  ULONG  IndicatedPacketsCount;
 +  ULONG  PhysicalMediumType;
 +  PNDIS_REQUEST  LastRequest;
 +  LONG  DmaAdapterRefCount;
 +  PVOID  FakeMac;
 +  ULONG  LockDbg;
 +  ULONG  LockDbgX;
 +  PVOID  LockThread;
 +  ULONG  InfoFlags;
 +  KSPIN_LOCK  TimerQueueLock;
 +  PKEVENT  ResetCompletedEvent;
 +  PKEVENT  QueuedBindingCompletedEvent;
 +  PKEVENT  DmaResourcesReleasedEvent;
 +  FILTER_PACKET_INDICATION_HANDLER  SavedPacketIndicateHandler;
 +  ULONG  RegisteredInterrupts;
 +  PNPAGED_LOOKASIDE_LIST  SGListLookasideList;
 +  ULONG  ScatterGatherListSize;
 +#endif /* _NDIS_ */
 +};
 +
 +
 +/* Handler prototypes for NDIS_OPEN_BLOCK */
 +
 +typedef NDIS_STATUS (DDKAPI *WAN_SEND_HANDLER)(
 +  IN NDIS_HANDLE  MacBindingHandle,
 +  IN NDIS_HANDLE  LinkHandle,
 +  IN PVOID  Packet);
 +
 +/* NDIS 4.0 extension */
 +
 +typedef VOID (DDKAPI *SEND_PACKETS_HANDLER)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN PPNDIS_PACKET  PacketArray,
 +  IN UINT  NumberOfPackets);
 +
 +#if defined(NDIS_WRAPPER)
 +#define NDIS_COMMON_OPEN_BLOCK_WRAPPER_S \
 +  ULONG  Flags; \
 +  ULONG  References; \
 +  KSPIN_LOCK  SpinLock; \
 +  NDIS_HANDLE  FilterHandle; \
 +  ULONG  ProtocolOptions; \
 +  USHORT  CurrentLookahead; \
 +  USHORT  ConnectDampTicks; \
 +  USHORT  DisconnectDampTicks; \
 +  W_SEND_HANDLER  WSendHandler; \
 +  W_TRANSFER_DATA_HANDLER  WTransferDataHandler; \
 +  W_SEND_PACKETS_HANDLER  WSendPacketsHandler; \
 +  W_CANCEL_SEND_PACKETS_HANDLER  CancelSendPacketsHandler; \
 +  ULONG  WakeUpEnable; \
 +  PKEVENT  CloseCompleteEvent; \
 +  QUEUED_CLOSE  QC; \
 +  ULONG  AfReferences; \
 +  PNDIS_OPEN_BLOCK  NextGlobalOpen;
 +#else
 +#define NDIS_COMMON_OPEN_BLOCK_WRAPPER_S
 +#endif
 +
 +#define NDIS_COMMON_OPEN_BLOCK_S \
 +  PVOID  MacHandle; \
 +  NDIS_HANDLE  BindingHandle; \
 +  PNDIS_MINIPORT_BLOCK  MiniportHandle; \
 +  PNDIS_PROTOCOL_BLOCK  ProtocolHandle; \ 
 +  NDIS_HANDLE  ProtocolBindingContext; \
 +  PNDIS_OPEN_BLOCK  MiniportNextOpen; \
 +  PNDIS_OPEN_BLOCK  ProtocolNextOpen; \
 +  NDIS_HANDLE  MiniportAdapterContext; \
 +  BOOLEAN  Reserved1; \
 +  BOOLEAN  Reserved2; \
 +  BOOLEAN  Reserved3; \
 +  BOOLEAN  Reserved4; \
 +  PNDIS_STRING  BindDeviceName; \
 +  KSPIN_LOCK  Reserved5; \
 +  PNDIS_STRING  RootDeviceName; \
 +  _ANONYMOUS_UNION union { \
 +    SEND_HANDLER  SendHandler; \
 +    WAN_SEND_HANDLER  WanSendHandler; \
 +  } DUMMYUNIONNAME; \
 +  TRANSFER_DATA_HANDLER  TransferDataHandler; \
 +  SEND_COMPLETE_HANDLER  SendCompleteHandler; \
 +  TRANSFER_DATA_COMPLETE_HANDLER  TransferDataCompleteHandler; \
 +  RECEIVE_HANDLER  ReceiveHandler; \
 +  RECEIVE_COMPLETE_HANDLER  ReceiveCompleteHandler; \
 +  WAN_RECEIVE_HANDLER  WanReceiveHandler; \
 +  REQUEST_COMPLETE_HANDLER  RequestCompleteHandler; \
 +  RECEIVE_PACKET_HANDLER  ReceivePacketHandler; \
 +  SEND_PACKETS_HANDLER  SendPacketsHandler; \
 +  RESET_HANDLER  ResetHandler; \
 +  REQUEST_HANDLER  RequestHandler; \
 +  RESET_COMPLETE_HANDLER  ResetCompleteHandler; \
 +  STATUS_HANDLER  StatusHandler; \
 +  STATUS_COMPLETE_HANDLER  StatusCompleteHandler; \
 +  NDIS_COMMON_OPEN_BLOCK_WRAPPER_S
 +
 +typedef struct _NDIS_COMMON_OPEN_BLOCK {
 +  NDIS_COMMON_OPEN_BLOCK_S
 +} NDIS_COMMON_OPEN_BLOCK;
 +
 +struct _NDIS_OPEN_BLOCK
 +{
 +#ifdef __cplusplus
 +  NDIS_COMMON_OPEN_BLOCK NdisCommonOpenBlock;
 +#else
 +  NDIS_COMMON_OPEN_BLOCK_S
 +#endif
 +#if defined(NDIS_WRAPPER)
 +  struct _NDIS_OPEN_CO
 +  {
 +    struct _NDIS_CO_AF_BLOCK *  NextAf;
 +    W_CO_CREATE_VC_HANDLER      MiniportCoCreateVcHandler;
 +    W_CO_REQUEST_HANDLER        MiniportCoRequestHandler;
 +    CO_CREATE_VC_HANDLER        CoCreateVcHandler;
 +    CO_DELETE_VC_HANDLER        CoDeleteVcHandler;
 +    PVOID                       CmActivateVcCompleteHandler;
 +    PVOID                       CmDeactivateVcCompleteHandler;
 +    PVOID                       CoRequestCompleteHandler;
 +    LIST_ENTRY                  ActiveVcHead;
 +    LIST_ENTRY                  InactiveVcHead;
 +    LONG                        PendingAfNotifications;
 +    PKEVENT                     AfNotifyCompleteEvent;
 +  };
 +#endif /* _NDIS_ */
 +};
 +
 +
 +
 +/* Routines for NDIS miniport drivers */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisInitializeWrapper(
 +  OUT PNDIS_HANDLE  NdisWrapperHandle,
 +  IN PVOID  SystemSpecific1,
 +  IN PVOID  SystemSpecific2,
 +  IN PVOID  SystemSpecific3);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMAllocateMapRegisters(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN UINT  DmaChannel,
 +  IN NDIS_DMA_SIZE  DmaSize,
 +  IN ULONG  PhysicalMapRegistersNeeded,
 +  IN ULONG  MaximumPhysicalMapping);
 +
 +/*
 + * VOID
 + * NdisMArcIndicateReceive(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle,
 + *   IN PUCHAR  HeaderBuffer,
 + *   IN PUCHAR  DataBuffer,
 + *   IN UINT  Length);
 + */
 +#define NdisMArcIndicateReceive(MiniportAdapterHandle, \
 +                                HeaderBuffer,          \
 +                                DataBuffer,            \
 +                                Length)                \
 +{                                                      \
 +    ArcFilterDprIndicateReceive(                       \
 +        (((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->ArcDB), \
 +        (HeaderBuffer), \
 +        (DataBuffer),   \
 +        (Length));      \
 +}
 +
 +/*
 + * VOID
 + * NdisMArcIndicateReceiveComplete(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle);
 + */
 +#define NdisMArcIndicateReceiveComplete(MiniportAdapterHandle) \
 +{                                                              \
 +    if (((PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle)->EthDB)  \
 +          {                                                        \
 +              NdisMEthIndicateReceiveComplete(_H);                 \
 +          }                                                        \
 +                                                               \
 +    ArcFilterDprIndicateReceiveComplete(                       \
 +      ((PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle)->ArcDB);   \
 +}
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMCloseLog(
 +  IN NDIS_HANDLE  LogHandle);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMCreateLog(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN UINT  Size,
 +  OUT PNDIS_HANDLE  LogHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMDeregisterAdapterShutdownHandler(
 +  IN NDIS_HANDLE  MiniportHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMDeregisterInterrupt(
 +  IN PNDIS_MINIPORT_INTERRUPT  Interrupt);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMDeregisterIoPortRange(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN UINT  InitialPort,
 +  IN UINT  NumberOfPorts,
 +  IN PVOID  PortOffset);
 +
 +/*
 + * VOID
 + * NdisMEthIndicateReceive(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle,
 + *   IN NDIS_HANDLE  MiniportReceiveContext,
 + *   IN PVOID  HeaderBuffer,
 + *   IN UINT  HeaderBufferSize,
 + *   IN PVOID  LookaheadBuffer,
 + *   IN UINT  LookaheadBufferSize,
 + *   IN UINT  PacketSize);
 + */
 +#define NdisMEthIndicateReceive(MiniportAdapterHandle,  \
 +                                MiniportReceiveContext, \
 +                                HeaderBuffer,           \
 +                                HeaderBufferSize,       \
 +                                LookaheadBuffer,        \
 +                                LookaheadBufferSize,    \
 +                                PacketSize)             \
 +{                                                       \
 +    (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->EthRxIndicateHandler)( \
 +              ((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->EthDB,  \
 +              (MiniportReceiveContext), \
 +              (HeaderBuffer),           \
 +              (HeaderBuffer),           \
 +              (HeaderBufferSize),       \
 +              (LookaheadBuffer),        \
 +              (LookaheadBufferSize),    \
 +              (PacketSize));            \
 +}
 +
 +/*
 + * VOID
 + * NdisMEthIndicateReceiveComplete(
 + *   IN NDIS_HANDLE MiniportAdapterHandle);
 + */
 +#define NdisMEthIndicateReceiveComplete(MiniportAdapterHandle) \
 +{                                                              \
 +    (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->EthRxCompleteHandler)( \
 +        ((PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle)->EthDB);    \
 +}
 +
 +/*
 + * VOID
 + * NdisMFddiIndicateReceive(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle,
 + *   IN NDIS_HANDLE  MiniportReceiveContext,
 + *   IN PVOID  HeaderBuffer,
 + *   IN UINT  HeaderBufferSize,
 + *   IN PVOID  LookaheadBuffer,
 + *   IN UINT  LookaheadBufferSize,
 + *   IN UINT  PacketSize);
 + */
 +#define NdisMFddiIndicateReceive(MiniportAdapterHandle,  \
 +                                 MiniportReceiveContext, \
 +                                 HeaderBuffer,           \
 +                                 HeaderBufferSize,       \
 +                                 LookaheadBuffer,        \
 +                                 LookaheadBufferSize,    \
 +                                 PacketSize)             \
 +{                                                        \
 +    (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->FddiRxIndicateHandler)( \
 +        (((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->FddiDB),   \
 +        (MiniportReceiveContext),              \
 +        (PUCHAR)(HeaderBuffer) + 1,            \
 +        (((*(PUCHAR*)(HeaderBuffer)) & 0x40) ? \
 +            FDDI_LENGTH_OF_LONG_ADDRESS :      \
 +                  FDDI_LENGTH_OF_SHORT_ADDRESS),     \
 +        (HeaderBuffer),                        \
 +        (HeaderBufferSize),                    \
 +        (LookaheadBuffer),                     \
 +        (LookaheadBufferSize),                 \
 +        (PacketSize));                         \
 +}
 +
 +
 +
 +/*
 + * VOID
 + * NdisMFddiIndicateReceiveComplete(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle);
 + */
 +#define NdisMFddiIndicateReceiveComplete(MiniportAdapterHandle) \
 +{                                                               \
 +    (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->FddiRxCompleteHandler)( \
 +        ((PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle)->FddiDB);      \
 +}
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMFlushLog(
 +  IN NDIS_HANDLE  LogHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMFreeMapRegisters(
 +  IN NDIS_HANDLE  MiniportAdapterHandle);
 +
 +/*
 + * VOID
 + * EXPORT
 + * NdisMIndicateReceivePacket(
 + *  IN NDIS_HANDLE  MiniportAdapterHandle,
 + *  IN PPNDIS_PACKET  ReceivePackets,
 + *  IN UINT  NumberOfPackets);
 + */
 +#define NdisMIndicateReceivePacket(MiniportAdapterHandle, \
 +  ReceivePackets, NumberOfPackets)                        \
 +  (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->PacketIndicateHandler)( \
 +  MiniportAdapterHandle, ReceivePackets, NumberOfPackets)
 +
 +/*
 + * VOID
 + * NdisMIndicateStatus(
 + *  IN NDIS_HANDLE  MiniportAdapterHandle,
 + *  IN NDIS_STATUS  GeneralStatus,
 + *  IN PVOID  StatusBuffer,
 + *  IN UINT  StatusBufferSize);
 + */
 +
 +#define NdisMIndicateStatus(MiniportAdapterHandle,  \
 +   GeneralStatus, StatusBuffer, StatusBufferSize)   \
 +  (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->StatusHandler)(   \
 +  MiniportAdapterHandle, GeneralStatus, StatusBuffer, StatusBufferSize)
 +
 +/*
 + * VOID
 + * NdisMIndicateStatusComplete(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle);
 + */
 +#define NdisMIndicateStatusComplete(MiniportAdapterHandle) \
 +  (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->StatusCompleteHandler)( \
 +    MiniportAdapterHandle)
 +
 +/*
 + * VOID
 + * NdisMInitializeWrapper(
 + *   OUT PNDIS_HANDLE  NdisWrapperHandle,
 + *   IN PVOID  SystemSpecific1,
 + *   IN PVOID  SystemSpecific2,
 + *   IN PVOID  SystemSpecific3);
 + */
 +#define NdisMInitializeWrapper(NdisWrapperHandle, \
 +                               SystemSpecific1,   \
 +                               SystemSpecific2,   \
 +                               SystemSpecific3)   \
 +    NdisInitializeWrapper((NdisWrapperHandle),    \
 +                          (SystemSpecific1),      \
 +                          (SystemSpecific2),      \
 +                          (SystemSpecific3))
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMMapIoSpace(
 +  OUT PVOID  *VirtualAddress,
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN NDIS_PHYSICAL_ADDRESS  PhysicalAddress,
 +  IN UINT  Length);
 +
 +/*
 + * VOID
 + * NdisMQueryInformationComplete(
 + *  IN NDIS_HANDLE  MiniportAdapterHandle,
 + *  IN NDIS_STATUS  Status);
 + */
 +#define NdisMQueryInformationComplete(MiniportAdapterHandle, Status) \
 +  (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->QueryCompleteHandler)(MiniportAdapterHandle, Status)
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMRegisterAdapterShutdownHandler(
 +  IN NDIS_HANDLE  MiniportHandle,
 +  IN PVOID  ShutdownContext,
 +  IN ADAPTER_SHUTDOWN_HANDLER  ShutdownHandler);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMRegisterInterrupt(
 +  OUT PNDIS_MINIPORT_INTERRUPT  Interrupt,
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN UINT  InterruptVector,
 +  IN UINT  InterruptLevel,
 +  IN BOOLEAN  RequestIsr,
 +  IN BOOLEAN  SharedInterrupt,
 +  IN NDIS_INTERRUPT_MODE  InterruptMode);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMRegisterIoPortRange(
 +  OUT PVOID  *PortOffset,
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN UINT  InitialPort,
 +  IN UINT  NumberOfPorts);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMRegisterMiniport(
 +  IN NDIS_HANDLE  NdisWrapperHandle,
 +  IN PNDIS_MINIPORT_CHARACTERISTICS  MiniportCharacteristics,
 +  IN UINT  CharacteristicsLength);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMSetTimer(
 +  IN PNDIS_MINIPORT_TIMER  Timer,
 +  IN UINT  MillisecondsToDelay);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMInitializeTimer(
 +  IN OUT PNDIS_MINIPORT_TIMER Timer,
 +  IN NDIS_HANDLE MiniportAdapterHandle,
 +  IN PNDIS_TIMER_FUNCTION TimerFunction,
 +  IN PVOID FunctionContext);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMSetPeriodicTimer(
 +  IN PNDIS_MINIPORT_TIMER  Timer,
 +  IN UINT  MillisecondPeriod);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMCancelTimer(
 +  IN PNDIS_MINIPORT_TIMER  Timer,
 +  OUT PBOOLEAN  TimerCancelled);
 +
 +#if !defined(NDIS_WRAPPER)
 +
 +/*
 + * VOID
 + * NdisMResetComplete(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle,
 + *   IN NDIS_STATUS  Status,
 + *   IN BOOLEAN  AddressingReset);
 + */
 +#define       NdisMResetComplete(MiniportAdapterHandle, \
 +                           Status,                \
 +                           AddressingReset)       \
 +{                                                 \
 +    (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->ResetCompleteHandler)( \
 +        MiniportAdapterHandle, Status, AddressingReset); \
 +}
 +
 +/*
 + * VOID
 + * NdisMSendComplete(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle,
 + *   IN PNDIS_PACKET  Packet,
 + *   IN NDIS_STATUS  Status);
 + */
 +#define       NdisMSendComplete(MiniportAdapterHandle, \
 +                          Packet,                \
 +                          Status)                \
 +{                                                \
 +    (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->SendCompleteHandler)( \
 +        MiniportAdapterHandle, Packet, Status);  \
 +}
 +
 +/*
 + * VOID
 + * NdisMSendResourcesAvailable(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle);
 + */
 +#define       NdisMSendResourcesAvailable(MiniportAdapterHandle) \
 +{                                                \
 +    (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->SendResourcesHandler)( \
 +        MiniportAdapterHandle); \
 +}
 +
 +/*
 + * VOID
 + * NdisMTransferDataComplete(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle,
 + *   IN PNDIS_PACKET  Packet,
 + *   IN NDIS_STATUS  Status,
 + *   IN UINT  BytesTransferred);
 + */
 +#define       NdisMTransferDataComplete(MiniportAdapterHandle, \
 +                                  Packet,                \
 +                                  Status,                \
 +                                  BytesTransferred)      \
 +{                                                        \
 +    (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->TDCompleteHandler)( \
 +        MiniportAdapterHandle, Packet, Status, BytesTransferred)           \
 +}
 +
 +#endif /* !_NDIS_ */
 +
 +
 +/*
 + * VOID
 + * NdisMSetAttributes(
 + *  IN NDIS_HANDLE  MiniportAdapterHandle,
 + *  IN NDIS_HANDLE  MiniportAdapterContext,
 + *  IN BOOLEAN  BusMaster,
 + *  IN NDIS_INTERFACE_TYPE  AdapterType);
 + */
 +#define NdisMSetAttributes(MiniportAdapterHandle,   \
 +                           MiniportAdapterContext,  \
 +                           BusMaster,               \
 +                           AdapterType)             \
 +  NdisMSetAttributesEx(MiniportAdapterHandle,       \
 +    MiniportAdapterContext,                         \
 +    0,                                              \
 +    (BusMaster) ? NDIS_ATTRIBUTE_BUS_MASTER : 0,    \
 +    AdapterType)
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMSetAttributesEx(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN UINT  CheckForHangTimeInSeconds   OPTIONAL,
 +  IN ULONG  AttributeFlags,
 +  IN NDIS_INTERFACE_TYPE AdapterType);
 +
 +/*
 + * VOID
 + * NdisMSetInformationComplete(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle,
 + *   IN NDIS_STATUS  Status);
 + */
 +#define NdisMSetInformationComplete(MiniportAdapterHandle, \
 +                                    Status) \
 +  (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->SetCompleteHandler)( \
 +    MiniportAdapterHandle, Status)
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMSleep(
 +  IN ULONG  MicrosecondsToSleep);
 +
 +NDISAPI
 +BOOLEAN
 +DDKAPI
 +NdisMSynchronizeWithInterrupt(
 +  IN PNDIS_MINIPORT_INTERRUPT  Interrupt,
 +  IN PVOID  SynchronizeFunction,
 +  IN PVOID  SynchronizeContext);
 +
 +/*
 + * VOID
 + * NdisMTrIndicateReceive(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle,
 + *   IN NDIS_HANDLE  MiniportReceiveContext,
 + *   IN PVOID  HeaderBuffer,
 + *   IN UINT  HeaderBufferSize,
 + *   IN PVOID  LookaheadBuffer,
 + *   IN UINT  LookaheadBufferSize,
 + *   IN UINT  PacketSize);
 + */
 +#define NdisMTrIndicateReceive(MiniportAdapterHandle,  \
 +                               MiniportReceiveContext, \
 +                               HeaderBuffer,           \
 +                               HeaderBufferSize,       \
 +                               LookaheadBuffer,        \
 +                               LookaheadBufferSize,    \
 +                               PacketSize)             \
 +{                                                      \
 +    (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->TrRxIndicateHandler)( \
 +      (((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->TrDB),     \
 +              (MiniportReceiveContext), \
 +              (HeaderBuffer),           \
 +              (HeaderBuffer),           \
 +              (HeaderBufferSize),       \
 +              (LookaheadBuffer),        \
 +              (LookaheadBufferSize),    \
 +              (PacketSize));            \
 +}
 +
 +/*
 + * VOID
 + * NdisMTrIndicateReceiveComplete(
 + *   IN NDIS_HANDLE  MiniportAdapterHandle);
 + */
 +#define NdisMTrIndicateReceiveComplete(MiniportAdapterHandle) \
 +{                                                             \
 +      (*((PNDIS_MINIPORT_BLOCK)(MiniportAdapterHandle))->TrRxCompleteHandler)( \
 +    ((PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle)->TrDB);    \
 +}
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisMWriteLogData(
 +  IN NDIS_HANDLE  LogHandle,
 +  IN PVOID  LogBuffer,
 +  IN UINT  LogBufferSize);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMQueryAdapterResources(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  WrapperConfigurationContext,
 +  OUT PNDIS_RESOURCE_LIST  ResourceList,
 +  IN OUT PUINT  BufferSize);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisTerminateWrapper(
 +  IN NDIS_HANDLE  NdisWrapperHandle,
 +  IN PVOID  SystemSpecific);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisMUnmapIoSpace(
 +  IN NDIS_HANDLE  MiniportAdapterHandle,
 +  IN PVOID  VirtualAddress,
 +  IN UINT  Length);
 +
 +
 +
 +/* Event functions */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisInitializeEvent(
 +  IN PNDIS_EVENT  Event);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisSetEvent(
 +  IN PNDIS_EVENT  Event);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisResetEvent(
 +  IN PNDIS_EVENT  Event);
 +
 +NDISAPI
 +BOOLEAN
 +DDKAPI
 +NdisWaitEvent(
 +  IN PNDIS_EVENT  Event,
 +  IN UINT  Timeout);
 +
 +
 +
 +/* NDIS intermediate miniport structures */
 +
 +typedef VOID (DDKAPI *W_MINIPORT_CALLBACK)(
 +  IN NDIS_HANDLE  MiniportAdapterContext,
 +  IN PVOID  CallbackContext);
 +
 +
 +
 +/* Routines for intermediate miniport drivers */
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisIMDeInitializeDeviceInstance(
 +  IN NDIS_HANDLE NdisMiniportHandle);
 +
 +/*
 + * NDIS_STATUS
 + * NdisIMInitializeDeviceInstance(
 + *   IN NDIS_HANDLE  DriverHandle,
 + *   IN PNDIS_STRING  DeviceInstance);
 + */
 +#define NdisIMInitializeDeviceInstance(DriverHandle, DeviceInstance) \
 +  NdisIMInitializeDeviceInstanceEx(DriverHandle, DeviceInstance, NULL)
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisIMRegisterLayeredMiniport(
 +  IN NDIS_HANDLE  NdisWrapperHandle,
 +  IN PNDIS_MINIPORT_CHARACTERISTICS  MiniportCharacteristics,
 +  IN UINT  CharacteristicsLength,
 +  OUT PNDIS_HANDLE  DriverHandle);
 +
 +
 +/* Functions obsoleted by NDIS 5.0 */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisFreeDmaChannel(
 +  IN PNDIS_HANDLE  NdisDmaHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisSetupDmaTransfer(
 +  OUT PNDIS_STATUS  Status,
 +  IN PNDIS_HANDLE  NdisDmaHandle,
 +  IN PNDIS_BUFFER  Buffer,
 +  IN ULONG  Offset,
 +  IN ULONG  Length,
 +  IN BOOLEAN  WriteToDevice);
 +
 +NDISAPI
 +NTSTATUS
 +DDKAPI
 +NdisUpcaseUnicodeString(
 +  OUT PUNICODE_STRING  DestinationString,
 +  IN PUNICODE_STRING  SourceString);
 +
 +
 +/* Routines for NDIS protocol drivers */
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisRequest(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisBindingHandle,
 +  IN PNDIS_REQUEST  NdisRequest);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisReset(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisBindingHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisSend(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisBindingHandle,
 +  IN PNDIS_PACKET  Packet);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisSendPackets(
 +  IN NDIS_HANDLE  NdisBindingHandle,
 +  IN PPNDIS_PACKET  PacketArray,
 +  IN UINT  NumberOfPackets);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +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);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCloseAdapter(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisBindingHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCompleteBindAdapter(
 +  IN NDIS_HANDLE  BindAdapterContext,
 +  IN NDIS_STATUS  Status,
 +  IN NDIS_STATUS  OpenStatus);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisCompleteUnbindAdapter(
 +  IN NDIS_HANDLE  UnbindAdapterContext,
 +  IN NDIS_STATUS  Status);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisDeregisterProtocol(
 +  OUT PNDIS_STATUS  Status,
 +  IN NDIS_HANDLE  NdisProtocolHandle);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +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);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisOpenProtocolConfiguration(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_HANDLE  ConfigurationHandle,
 +  IN PNDIS_STRING  ProtocolSection);
 +
 +NDISAPI
 +VOID
 +DDKAPI
 +NdisRegisterProtocol(
 +  OUT PNDIS_STATUS  Status,
 +  OUT PNDIS_HANDLE  NdisProtocolHandle,
 +  IN PNDIS_PROTOCOL_CHARACTERISTICS  ProtocolCharacteristics,
 +  IN UINT  CharacteristicsLength);
 +
 +NDISAPI
 +NDIS_STATUS
 +DDKAPI
 +NdisScheduleWorkItem(
 +  IN  PNDIS_WORK_ITEM WorkItem);
 +
 +/* Obsoleted in Windows XP */
 +
 +/* Prototypes for NDIS_MAC_CHARACTERISTICS */
 +
 +typedef NDIS_STATUS (*OPEN_ADAPTER_HANDLER)(
 +  OUT PNDIS_STATUS  OpenErrorStatus,
 +  OUT NDIS_HANDLE  *MacBindingHandle,
 +  OUT PUINT  SelectedMediumIndex,
 +  IN PNDIS_MEDIUM  MediumArray,
 +  IN UINT  MediumArraySize,
 +  IN NDIS_HANDLE  NdisBindingContext,
 +  IN NDIS_HANDLE  MacAdapterContext,
 +  IN UINT  OpenOptions,
 +  IN PSTRING  AddressingInformation  OPTIONAL);
 +
 +typedef NDIS_STATUS (DDKAPI *CLOSE_ADAPTER_HANDLER)(
 +  IN NDIS_HANDLE  MacBindingHandle);
 +
 +typedef NDIS_STATUS (DDKAPI *WAN_TRANSFER_DATA_HANDLER)(
 +  VOID);
 +
 +typedef NDIS_STATUS (DDKAPI *QUERY_GLOBAL_STATISTICS_HANDLER)(
 +  IN NDIS_HANDLE  MacAdapterContext,
 +  IN PNDIS_REQUEST  NdisRequest);
 +
 +typedef VOID (DDKAPI *UNLOAD_MAC_HANDLER)(
 +  IN NDIS_HANDLE  MacMacContext);
 +
 +typedef NDIS_STATUS (DDKAPI *ADD_ADAPTER_HANDLER)(
 +  IN NDIS_HANDLE  MacMacContext,
 +  IN NDIS_HANDLE  WrapperConfigurationContext,
 +  IN PNDIS_STRING  AdapterName);
 +
 +typedef VOID (*REMOVE_ADAPTER_HANDLER)(
 +  IN NDIS_HANDLE  MacAdapterContext);
 +
 +typedef struct _NDIS_MAC_CHARACTERISTICS {
 +  UCHAR  MajorNdisVersion;
 +  UCHAR  MinorNdisVersion;
 +  USHORT  Filler;
 +  UINT  Reserved;
 +  OPEN_ADAPTER_HANDLER  OpenAdapterHandler;
 +  CLOSE_ADAPTER_HANDLER  CloseAdapterHandler;
 +  SEND_HANDLER  SendHandler;
 +  TRANSFER_DATA_HANDLER  TransferDataHandler;
 +  RESET_HANDLER  ResetHandler;
 +  REQUEST_HANDLER  RequestHandler;
 +  QUERY_GLOBAL_STATISTICS_HANDLER  QueryGlobalStatisticsHandler;
 +  UNLOAD_MAC_HANDLER  UnloadMacHandler;
 +  ADD_ADAPTER_HANDLER  AddAdapterHandler;
 +  REMOVE_ADAPTER_HANDLER  RemoveAdapterHandler;
 +  NDIS_STRING  Name;
 +} NDIS_MAC_CHARACTERISTICS, *PNDIS_MAC_CHARACTERISTICS;
 +
 +typedef       NDIS_MAC_CHARACTERISTICS        NDIS_WAN_MAC_CHARACTERISTICS;
 +typedef       NDIS_WAN_MAC_CHARACTERISTICS    *PNDIS_WAN_MAC_CHARACTERISTICS;
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +
 +#endif /* __NDIS_H */
 +
 +/* EOF */