/*++

Copyright (c) 1990  Microsoft Corporation

Module Name:

    testmac.c

Abstract:

    simple MAC to test the NDIS wrapper.
    Mostly taken from the Elnkii code spec.

Author:

    Adam Barr (adamba) 14-Jul-1990

Environment:

    Kernel mode, FSD

Revision History:


--*/

#include <ntos.h>

#include <ndis.h>

#include "testmac.h"


/*++

Routine Description:

    This is the initialization routine for the driver.  It is invoked once
    when the driver is loaded into the system.  Its job is to initialize all
    the structures which will be used by the FSD.

Arguments:

    DriverObject - Pointer to driver object created by the system.

Return Value:

    None.

--*/



static
NTSTATUS
TestMacDispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine is the main dispatch routine for the FSD.  This routine
    accepts an I/O Request Packet (IRP) and either performs the request
    itself, or it passes it to the FSP for processing.

Arguments:

    DeviceObject - Pointer to the device object for this driver.

    Irp - Pointer to the request packet representing the I/O request.

Return Value:

    The function value is the status of the operation.


--*/

{
    KIRQL oldIrql;

    DeviceObject;

    KeRaiseIrql( DISPATCH_LEVEL, &oldIrql );
    IoCompleteRequest( Irp, 0 );
    KeLowerIrql( oldIrql );

    return STATUS_NOT_IMPLEMENTED;
}




MAC_BLOCK GlobalMacBlock;
UCHAR * AdapterNames[] = {
    "\\Device\\TestMac0",
    "\\Device\\TestMac1",
    "\\Device\\TestMac2"
    };


NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject
    )
{
    PMAC_BLOCK NewMacP = &GlobalMacBlock;
    NDIS_STATUS Status;
    CLONG i;
    STRING AdapterName;

    // Initialize the driver object with this driver's entry points.
    for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) {
        DriverObject->MajorFunction[i] = TestMacDispatch;
    }

    // Initialize the wrapper
    NdisInitializeWrapper( (PVOID)DriverObject, NULL, NULL);

    NewMacP->Debug = FALSE;

    // set up driver object, etc.
    NewMacP->DriverObject = DriverObject;
    KeInitializePowerStatus(&NewMacP->PowerStatus);
    NewMacP->PowerBoolean = FALSE;
    KeInsertQueuePowerStatus(&NewMacP->PowerStatus, &NewMacP->PowerBoolean);
    NdisAllocateSpinLock(&NewMacP->SpinLock);

    NewMacP->NumAdapters = 0;
    NewMacP->AdapterQueue = (PADAPTER_BLOCK)NULL;

    // get ready to call NdisRegisterMac
    NewMacP->MacCharacteristics.MajorNdisVersion = 3;
    NewMacP->MacCharacteristics.MinorNdisVersion = 0;
    NewMacP->MacCharacteristics.Reserved = 0;
    NewMacP->MacCharacteristics.OpenAdapterHandler = TestMacOpenAdapter;
    NewMacP->MacCharacteristics.CloseAdapterHandler = TestMacCloseAdapter;
    NewMacP->MacCharacteristics.SetPacketFilterHandler = TestMacSetPacketFilter;
    NewMacP->MacCharacteristics.AddMulticastAddressHandler =
                                                TestMacAddMulticastAddress;
    NewMacP->MacCharacteristics.DeleteMulticastAddressHandler =
                                                TestMacDeleteMulticastAddress;
    NewMacP->MacCharacteristics.SendHandler = TestMacSend;
    NewMacP->MacCharacteristics.TransferDataHandler = TestMacTransferData;
    NewMacP->MacCharacteristics.QueryInformationHandler =
                                                TestMacQueryInformation;
    NewMacP->MacCharacteristics.SetInformationHandler = TestMacSetInformation;
    NewMacP->MacCharacteristics.ResetHandler = TestMacReset;
    NewMacP->MacCharacteristics.TestHandler = TestMacTest;
    NewMacP->MacCharacteristics.NameLength = sizeof("TESTMAC");
    RtlMoveMemory(NewMacP->MacCharacteristics.Name, "TESTMAC", 8);

    NdisRegisterMac(&Status,
            &NewMacP->NdisMacHandle,
            &NewMacP->MacCharacteristics,
            sizeof(NewMacP->MacCharacteristics)+8);

    if (Status != NDIS_STATUS_SUCCESS) {
        // NdisRegisterMac failed
        if (NewMacP->Debug)
            DbgPrint(" [ RegisterMac FAILURE %d ] ", Status);
        KeRemoveQueuePowerStatus(&NewMacP->PowerStatus);
        NdisFreeSpinLock(&NewMacP->SpinLock);
        return STATUS_UNSUCCESSFUL;
    }

    for (i=0; i<3; i++) {
        RtlInitString(&AdapterName, AdapterNames[i]);
        if (TestMacRegisterAdapter(&AdapterName, i) != NDIS_STATUS_SUCCESS)
            return STATUS_UNSUCCESSFUL;
    }

    return STATUS_SUCCESS;
}


//
// MacRegisterAdapter
//
// NT will call this function when a new adapter should be opened
//
// - allocates space for adapter block and open blocks
// - initializes the open block
// - calls NdisRegisterAdapter
//

static
NDIS_STATUS
TestMacRegisterAdapter(
    IN PSTRING AdapterName,
    IN UINT AdapterNumber
    )
{
    PADAPTER_BLOCK NewAdaptP;
    NDIS_STATUS Status;
    UINT i;

    // OK to allocate memory now
    NewAdaptP = (PADAPTER_BLOCK)AllocPhys(sizeof(ADAPTER_BLOCK));
    if (NewAdaptP == (PADAPTER_BLOCK)NULL)
        return NDIS_STATUS_FAILURE;

    NewAdaptP->AdapterName = AdapterName;
    NewAdaptP->AdapterNumber = AdapterNumber;

    NewAdaptP->MaxOpens = 4;
    NewAdaptP->MulticastListMax = 8;
    NewAdaptP->MulticastDontModify = FALSE;

    // need to get this memory now
    NewAdaptP->OpenBlocks =
            (POPEN_BLOCK)AllocPhys(sizeof(OPEN_BLOCK) * NewAdaptP->MaxOpens);
    if (NewAdaptP->OpenBlocks == (POPEN_BLOCK)NULL)
    {
        FreePhys((PVOID)NewAdaptP);
        return NDIS_STATUS_FAILURE;
    }

    ++(NewAdaptP->MulticastListMax);        // to allow for broadcast address
    // need to get this memory now
    NewAdaptP->MulticastList = (PMULTICAST_ENTRY)
            AllocPhys(sizeof(MULTICAST_ENTRY) * (NewAdaptP->MulticastListMax));
    if (NewAdaptP->MulticastList == (PMULTICAST_ENTRY)NULL) {
        FreePhys((PVOID)NewAdaptP->OpenBlocks);
        FreePhys((PVOID)NewAdaptP);
        return NDIS_STATUS_FAILURE;
    }
    NdisAllocateSpinLock(&NewAdaptP->MulticastSpinLock);

    // set up the broadcast address as first multicast list entry
    NewAdaptP->MulticastListSize = 1;
    RtlMoveMemory(NewAdaptP->MulticastList->Address,
                        BroadcastAddress, ADDRESS_LEN);
    NewAdaptP->MulticastList->ProtocolMask = ~(MASK)0;      // not really needed

    NewAdaptP->LoopbackQueue = (PNDIS_PACKET)NULL;
    NdisAllocateSpinLock(&NewAdaptP->LoopbackSpinLock);

    NewAdaptP->NumOpens = 0;
    NewAdaptP->OpenQueue = (POPEN_BLOCK)NULL;

    // set up free list of open blocks
    NewAdaptP->FreeOpenQueue = NewAdaptP->OpenBlocks;
    for (i = 0; i < NewAdaptP->MaxOpens-1; i++)
        NewAdaptP->OpenBlocks[i].NextOpen = &(NewAdaptP->OpenBlocks[i+1]);
    NewAdaptP->OpenBlocks[i].NextOpen = (POPEN_BLOCK)NULL;

    NewAdaptP->MacBlock = &GlobalMacBlock;

    NdisAcquireSpinLock(&GlobalMacBlock.SpinLock);
    NewAdaptP->NextAdapter = GlobalMacBlock.AdapterQueue;
    GlobalMacBlock.AdapterQueue = NewAdaptP;
    NdisReleaseSpinLock(&GlobalMacBlock.SpinLock);

    NewAdaptP->Debug = GlobalMacBlock.Debug;

    Status = NdisRegisterAdapter(&NewAdaptP->NdisAdapterHandle,
        GlobalMacBlock.NdisMacHandle,
        (NDIS_HANDLE)NewAdaptP,
        AdapterName);

    if (Status != NDIS_STATUS_SUCCESS) {
        if (NewAdaptP->Debug)
            DbgPrint(" [ NdisRegisterAdapter FAILURE %d ] ", Status);
        //*\\ take us out of GlobalMacBlock.AdapterQueue;
        FreePhys((PVOID)NewAdaptP->OpenBlocks);
        FreePhys((PVOID)NewAdaptP);
        return NDIS_STATUS_FAILURE;
    }

    KeInitializeDpc(&NewAdaptP->IndicateDpc,
                    TestMacIndicateDpc, (PVOID)NewAdaptP);
    NewAdaptP->DpcQueued = FALSE;

    return NDIS_STATUS_SUCCESS;
}



//
// MacOpenAdapter
//
// NDIS function
//

static
NDIS_STATUS
TestMacOpenAdapter(
    OUT NDIS_HANDLE * MacBindingHandle,
    IN NDIS_HANDLE RequestHandle,
    IN NDIS_HANDLE NdisBindingContext,
    IN NDIS_HANDLE MacAdapterContext,
    IN PSTRING AddressingInformation OPTIONAL
    )
{
#define AdaptP ((PADAPTER_BLOCK)MacAdapterContext)
    POPEN_BLOCK NewOpenP;

    RequestHandle;

    // take care of linking us in to the appropriate lists
    NdisAcquireSpinLock(&AdaptP->MacBlock->SpinLock);
    if (AdaptP->NumOpens == AdaptP->MaxOpens) {
        NdisReleaseSpinLock(&AdaptP->MacBlock->SpinLock);
        return NDIS_STATUS_FAILURE;
    }
    // rearrange free list
    NewOpenP = AdaptP->FreeOpenQueue;
    AdaptP->FreeOpenQueue = NewOpenP->NextOpen;

    // and link us on to active list
    NewOpenP->NextOpen = AdaptP->OpenQueue;
    AdaptP->OpenQueue = NewOpenP;

    ++(AdaptP->NumOpens);
    NdisReleaseSpinLock(&AdaptP->MacBlock->SpinLock);

    // set up the open block
    NewOpenP->AdapterBlock = AdaptP;
    NewOpenP->MacBlock = AdaptP->MacBlock;
    NewOpenP->NdisBindingContext = NdisBindingContext;
    NewOpenP->AddressingInformation = AddressingInformation;
    // set nth bit of Multicast bit (where n is our index in AdaptP->OpenBlocks)
    NewOpenP->MulticastBit = 1;
    NewOpenP->MulticastBit <<= AdaptP->OpenBlocks - NewOpenP;

    NewOpenP->Debug = AdaptP->Debug;

    if (NewOpenP->Debug)
        DbgPrint("--> TestMacOpenAdapter %d\n", AdaptP->AdapterNumber);

    //*\\ initialize OpenData to zero

    *MacBindingHandle = (NDIS_HANDLE)NewOpenP;
    return NDIS_STATUS_SUCCESS;
#undef AdaptP
}



//
// MacCloseAdapter
//
// NDIS function
//

static
NDIS_STATUS
TestMacCloseAdapter(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle
    )
{
#define OpenP ((POPEN_BLOCK)MacBindingHandle)
    PADAPTER_BLOCK AdaptP = OpenP->AdapterBlock;
    POPEN_BLOCK TmpOpenP;

    RequestHandle;

    if (OpenP->Debug)
        DbgPrint("--> TestMacCloseAdapter %d\n", AdaptP->AdapterNumber);

    // first zap us off the multicast address list
    TestMacKillMulticastAddresses(AdaptP, OpenP->MulticastBit);

    // now remove us from the list of opens for this adapter
    NdisAcquireSpinLock(&AdaptP->MacBlock->SpinLock);

    // take us off active list
    if (OpenP == AdaptP->OpenQueue)
        AdaptP->OpenQueue = OpenP->NextOpen;
    else {
        TmpOpenP = AdaptP->OpenQueue;
        while (TmpOpenP->NextOpen != OpenP)
            TmpOpenP = TmpOpenP->NextOpen;
        TmpOpenP->NextOpen = OpenP->NextOpen;
    }

    // put us on free list
    OpenP->NextOpen = AdaptP->FreeOpenQueue;
    AdaptP->FreeOpenQueue = OpenP;

    --(AdaptP->NumOpens);
    NdisReleaseSpinLock(&AdaptP->MacBlock->SpinLock);

    return NDIS_STATUS_SUCCESS;
#undef OpenP
}




//
// MacSetPacketFilter
//
// NDIS function
//
// - set appropriate bits in the adapter filters
// - modify the card Receive Configuration Register if needed
//

static
NDIS_STATUS
TestMacSetPacketFilter(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle,
    IN UINT PacketFilter
    )
{
#define OpenP ((POPEN_BLOCK)MacBindingHandle)
    PADAPTER_BLOCK AdaptP = OpenP->AdapterBlock;
    MASK BitOn = OpenP->MulticastBit;
    MASK BitOff = ~(OpenP->MulticastBit);

    RequestHandle;

    if (OpenP->Debug)
        DbgPrint("--> TestMacSetPacketFilter %d\n", AdaptP->AdapterNumber);

    // acquire AdaptP->MulticastSpinLock
    TestMacGetMulticastAccess(AdaptP);

    if (PacketFilter & NDIS_PACKET_TYPE_DIRECTED)
        AdaptP->DirectedFilter |= BitOn;
    else
        AdaptP->DirectedFilter &= BitOff;

    if (PacketFilter & NDIS_PACKET_TYPE_MULTICAST)
        AdaptP->MulticastFilter |= BitOn;
    else
        AdaptP->MulticastFilter &= BitOff;

    if (PacketFilter & NDIS_PACKET_TYPE_ALL_MULTICAST)
        AdaptP->AllMulticastFilter |= BitOn;
    else
        AdaptP->AllMulticastFilter &= BitOff;

    if (PacketFilter & NDIS_PACKET_TYPE_BROADCAST)
        AdaptP->BroadcastFilter |= BitOn;
    else
        AdaptP->BroadcastFilter &= BitOff;

    if (PacketFilter & NDIS_PACKET_TYPE_PROMISCUOUS)
        AdaptP->PromiscuousFilter |= BitOn;
    else
        AdaptP->PromiscuousFilter &= BitOff;

    NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);

    return NDIS_STATUS_SUCCESS;
#undef OpenP
}



//
// MacAddMulticastAddress
//
// NDIS function
//
// - add the address to the list if needed
// - modify the card multicast registers if needed
//

static
NDIS_STATUS
TestMacAddMulticastAddress(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle,
    IN PSTRING MulticastAddress
    )
{
#define OpenP ((POPEN_BLOCK)MacBindingHandle)
    PADAPTER_BLOCK AdaptP = OpenP->AdapterBlock;
    PMULTICAST_ENTRY MCSlot;

    RequestHandle;

    if (OpenP->Debug)
        DbgPrint("--> TestMacAddMulticastAddress %d\n", AdaptP->AdapterNumber);

    // acquire AdaptP->MulticastSpinLock
    TestMacGetMulticastAccess(AdaptP);

    // see if this address exists in our list
    MCSlot = TestMacFindMulticastAddress(AdaptP->MulticastList,
            AdaptP->MulticastListSize, MulticastAddress->Buffer);
    if (MCSlot == (PMULTICAST_ENTRY)NULL) {
        // see if our list is full
        if (AdaptP->MulticastListSize == AdaptP->MulticastListMax) {
            NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);
            return NDIS_MULTICAST_LIST_FULL;
        }
        // add us at the end
        MCSlot = &(AdaptP->MulticastList[AdaptP->MulticastListSize]);
        ++(AdaptP->MulticastListSize);
        RtlMoveMemory(MCSlot->Address, MulticastAddress->Buffer, ADDRESS_LEN);
        MCSlot->ProtocolMask = OpenP->MulticastBit;     // so far, only us
    } else {
        if (MCSlot->ProtocolMask & OpenP->MulticastBit) {
            NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);
            return NDIS_MULTICAST_EXISTS;
        }
        MCSlot->ProtocolMask |= OpenP->MulticastBit;
    }

    NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);

    return NDIS_STATUS_SUCCESS;
#undef OpenP
}


//
// GetMulticastAccess
//
// - acquire AdaptP->MulticastSpinLock in a lazy fashion
//

static
VOID
TestMacGetMulticastAccess(
    IN PADAPTER_BLOCK AdaptP
    )
{
    for (;;) {
        NdisAcquireSpinLock(&AdaptP->MulticastSpinLock);
        if (AdaptP->MulticastDontModify) {
            NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);
            // wait a little bit..
        } else
            return;
    }
}


// just hack this in
static
UINT
ExCompareMemory(
    PUCHAR s,
    PUCHAR t,
    UINT l
    )
{
    UINT i;

    for (i=0; i<l; i++) {
        if (s[i] != t[i])
            return -1;
    }
    return 0;
}


//
// FindMulticastAddress
//
// finds a multicast address in a list
//
// - call this with a spin lock held
//

static
PMULTICAST_ENTRY
TestMacFindMulticastAddress(
    IN PMULTICAST_ENTRY List,
    IN UINT Size,
    IN PUCHAR MulticastAddress
    )
{
    PMULTICAST_ENTRY End = &List[Size];

    for ( ; List<End; ++List) {
        // thanks to HenrySa for this idea...
        if (MulticastAddress[4] != List->Address[4])
            continue;
        if (ExCompareMemory(MulticastAddress, List->Address, ADDRESS_LEN) == 0)
            return List;
    }
    return (PMULTICAST_ENTRY)NULL;
}


//
// KillMulticastAddresses
//
// removes all multicast entries with MulticastBit on
//
// - called when an open is closed
// - if this is the last reference to an entry, remove it
//

static
VOID
TestMacKillMulticastAddresses(
    IN PADAPTER_BLOCK AdaptP,
    IN MASK MulticastBit
    )
{
    PMULTICAST_ENTRY List = AdaptP->MulticastList;
    PMULTICAST_ENTRY End = &List[AdaptP->MulticastListSize];
    PMULTICAST_ENTRY Dest;

    // acquire AdaptP->MulticastSpinLock
    TestMacGetMulticastAccess(AdaptP);

    Dest = List;
    while (List < End) {
        List->ProtocolMask &= ~MulticastBit;
        if (List->ProtocolMask != 0) {
            if (Dest < List)
                RtlMoveMemory(Dest, List, sizeof(MULTICAST_ENTRY));
            ++Dest;
        }
        ++List;
    }
    AdaptP->MulticastListSize = Dest - AdaptP->MulticastList;

    NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);
}



//
// MacDeleteMulticastAddress
//
// NDIS function
//

static
NDIS_STATUS
TestMacDeleteMulticastAddress(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle,
    IN PSTRING MulticastAddress
    )
{
#define OpenP ((POPEN_BLOCK)MacBindingHandle)
    PADAPTER_BLOCK AdaptP = OpenP->AdapterBlock;
    PMULTICAST_ENTRY MCSlot;

    RequestHandle;

    if (OpenP->Debug)
        DbgPrint("--> TestMacDeleteMulticastAddress %d\n", AdaptP->AdapterNumber);

    // acquire AdaptP->MulticastSpinLock
    TestMacGetMulticastAccess(AdaptP);

    MCSlot = TestMacFindMulticastAddress(AdaptP->MulticastList,
            AdaptP->MulticastListSize, MulticastAddress->Buffer);
    if (MCSlot == (PMULTICAST_ENTRY)NULL) {
        NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);
        return NDIS_MULTICAST_NOT_FOUND;
    } else {
        if (!(MCSlot->ProtocolMask & OpenP->MulticastBit)) {
            NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);
            return NDIS_MULTICAST_NOT_FOUND;
        } else {
            MCSlot->ProtocolMask &= ~(OpenP->MulticastBit);
            if (MCSlot->ProtocolMask == 0) {        // nobody using it
                // remove this entry from the list
                --(AdaptP->MulticastListSize);
                if (MCSlot != &AdaptP->MulticastList[AdaptP->MulticastListSize])
                    RtlMoveMemory(MCSlot,
                        &AdaptP->MulticastList[AdaptP->MulticastListSize],
                        sizeof(MULTICAST_ENTRY));
            }
        }
    }
    NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);

    return NDIS_STATUS_SUCCESS;
#undef OpenP
}



//
// MacSend
//
// NDIS function
//

static
NDIS_STATUS
TestMacSend(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle,
    IN PNDIS_PACKET Packet
    )
{
#define OpenP ((POPEN_BLOCK)MacBindingHandle)
    PADAPTER_BLOCK AdaptP = ((POPEN_BLOCK)MacBindingHandle)->AdapterBlock;
    PMAC_RESERVED Reserved = RESERVED(Packet);

    if (OpenP->Debug)
        DbgPrint("--> TestMacSend %d\n", AdaptP->AdapterNumber);

    if (OpenP->Debug) {
        UCHAR Buf[80];
        UINT Len;
        Len = TestMacCopyOver(Buf, Packet, 0, 80);
        DbgPrint("Message <%.*s>\n", Len, Buf);
    }

    Reserved->RequestHandle = RequestHandle;
    Reserved->OpenBlock = (POPEN_BLOCK)MacBindingHandle;
    Reserved->NextPacket = (PNDIS_PACKET)NULL;
    TestMacSetLoopbackFlag(Packet);

    if (Reserved->Loopback) {
        Reserved->Status = 1;
        NdisAcquireSpinLock(&AdaptP->LoopbackSpinLock);
        TestMacLoopbackPacket(AdaptP, Packet);
        NdisReleaseSpinLock(&AdaptP->LoopbackSpinLock);
    }

    return NDIS_STATUS_PENDING;     // will complete when looped back
#undef OpenP
}


//
// SetLoopbackFlag
//
// sets the loopback flag in the reserved section of a packet
//  if it has a multicast destination address
//

static
VOID
TestMacSetLoopbackFlag(
    IN OUT PNDIS_PACKET Packet
    )
{
    UINT Dummy;
    PNDIS_BUFFER FirstBuf;
    PVOID BufVA;
    PMAC_RESERVED Reserved = RESERVED(Packet);

#if 0
    NdisQueryPacket(Packet, NULL, &Dummy, &FirstBuf, NULL);
    NdisQueryBuffer(FirstBuf, NULL, &BufVA, &Dummy);
    Reserved->Loopback = (BOOLEAN)((((PUCHAR)BufVA)[0] & 1) != 0);
#else
    Dummy; FirstBuf; BufVA;
    Reserved->Loopback = TRUE;
#endif
}


//
// LoopbackPacket
//
// put a packet on the loopback queue
//
// - call this with LoopbackSpinLock held
//
//

static
VOID
TestMacLoopbackPacket(
    IN PADAPTER_BLOCK AdaptP,
    IN OUT PNDIS_PACKET Packet
    )
{
    PMAC_RESERVED Reserved = RESERVED(Packet);

    if (AdaptP->LoopbackQueue == (PNDIS_PACKET)NULL) {
        AdaptP->LoopbackQueue = Packet;
        AdaptP->LoopbackQTail = Packet;
    } else {
        PMAC_RESERVED Res2 = RESERVED(AdaptP->LoopbackQTail);
        Res2->NextPacket = Packet;
        AdaptP->LoopbackQTail = Packet;
    }
    Reserved->NextPacket = (PNDIS_PACKET)NULL;

    if (!AdaptP->DpcQueued) {
        AdaptP->DpcQueued = TRUE;
        KeInsertQueueDpc(&AdaptP->IndicateDpc, NULL, NULL);
    }
}



//
// IndicateLoopbackPacket
//
// indicates a loopback packet to the protocols
//
// - the protocol must want to receive multicast/broadcast packets
// - the address must be on his multicast list
//

static
VOID
TestMacIndicateLoopbackPacket(
    IN PADAPTER_BLOCK AdaptP,
    IN PNDIS_PACKET Packet
    )
{
    PMULTICAST_ENTRY MCSlot;
    POPEN_BLOCK CurOpen;
    MASK EffectiveMask;
    UINT IndicateLen;
    UINT PacketLen;
    NDIS_STATUS Status;

    // copy destination address of packet into AdaptP->Lookahead
    if (TestMacCopyOver(AdaptP->Lookahead, Packet, 0, ADDRESS_LEN) < ADDRESS_LEN) {
        return;
        // error, runt packet
    }

    NdisAcquireSpinLock(&AdaptP->MulticastSpinLock);
    AdaptP->MulticastDontModify = TRUE;
    NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);

    if (AdaptP->Lookahead[0] & 1) {
        // if bit x in EffectiveMask is on, the protocol x wants this packet
        MCSlot = TestMacFindMulticastAddress(AdaptP->MulticastList,
            AdaptP->MulticastListSize, AdaptP->Lookahead);
        if (MCSlot == (PMULTICAST_ENTRY)NULL)
            EffectiveMask = AdaptP->MulticastFilter | AdaptP->PromiscuousFilter;
        else if (MCSlot == &AdaptP->MulticastList[0])       // broadcast
            EffectiveMask = AdaptP->BroadcastFilter | AdaptP->PromiscuousFilter;
        else
            EffectiveMask = MCSlot->ProtocolMask &
                        (AdaptP->MulticastFilter | AdaptP->AllMulticastFilter |
                         AdaptP->PromiscuousFilter);
    } else {
        EffectiveMask = AdaptP->DirectedFilter | AdaptP->PromiscuousFilter;
    }

    // as long as somebody wants it, indicate it
    if (EffectiveMask != 0) {
        PacketLen = TestMacPacketSize(Packet);
        IndicateLen = (PacketLen > 256) ? 256 : PacketLen;
        // copy the lookahead data into a contiguous buffer
        TestMacCopyOver(AdaptP->Lookahead+ADDRESS_LEN,
                    Packet, ADDRESS_LEN, IndicateLen-ADDRESS_LEN);
        CurOpen = AdaptP->OpenQueue;
        while (CurOpen) {
            if (CurOpen->MulticastBit & EffectiveMask) {
                NdisIndicateReceive(&Status,
                                CurOpen->NdisBindingContext,
                                (NDIS_HANDLE)AdaptP,
                                AdaptP->Lookahead,
                                IndicateLen,
                                PacketLen);
            }
            CurOpen = CurOpen->NextOpen;
        }
    }

    NdisAcquireSpinLock(&AdaptP->MulticastSpinLock);
    AdaptP->MulticastDontModify = FALSE;
    NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);
}


//
// PacketSize
//
// returns the number of bytes of data in a packet
//

static
UINT
TestMacPacketSize(
    IN PNDIS_PACKET Packet
    )
{
    PNDIS_BUFFER CurBuffer;
    UINT Dummy;
    UINT BufLen;
    UINT TotLen;

    TotLen = 0;
    NdisQueryPacket(Packet, NULL, &Dummy, &CurBuffer, NULL);
    while (CurBuffer != (PNDIS_BUFFER)NULL) {
        NdisQueryBuffer(CurBuffer, NULL, NULL, &BufLen);
        TotLen += BufLen;
        NdisGetNextBuffer(CurBuffer, &CurBuffer);
    }
    return TotLen;
}


//
// CopyOver
//
// copy bytes from a packet into a buffer
//
// - returns the actual number of bytes copied
//

static
UINT
TestMacCopyOver(
    OUT PUCHAR Buf,                 // destination
    IN PNDIS_PACKET Packet,         // source packet
    IN UINT Offset,                 // offset in packet
    IN UINT Length                  // number of bytes to copy
    )
{
    PNDIS_BUFFER CurBuffer;
    UINT Dummy;
    UINT BytesCopied;
    PUCHAR BufVA;
    UINT BufLen;
    UINT ToCopy;
    UINT CurOffset;

    BytesCopied = 0;
    // first move to Offset bytes into the packet
    CurOffset = 0;
    NdisQueryPacket(Packet, NULL, &Dummy, &CurBuffer, NULL);
    while (CurBuffer != (PNDIS_BUFFER)NULL) {
        NdisQueryBuffer(CurBuffer, NULL, (PVOID *) &BufVA, &BufLen);
        if (CurOffset + BufLen > Offset)
            break;
        CurOffset += BufLen;
        NdisGetNextBuffer(CurBuffer, &CurBuffer);
    }
    // see if we went off the end of the packet
    if (CurBuffer == (PNDIS_BUFFER)NULL)
        return 0;
    // now copy over Length bytes
    BufVA += (Offset - CurOffset);
    BufLen -= (Offset - CurOffset);
    for (;;) {
        ToCopy = (BytesCopied+BufLen > Length) ? Length - BytesCopied : BufLen;
        RtlMoveMemory(Buf+BytesCopied, BufVA, ToCopy);
        BytesCopied += ToCopy;
        if (BytesCopied == Length)
            return BytesCopied;
        NdisGetNextBuffer(CurBuffer, &CurBuffer);
        if (CurBuffer == (PNDIS_BUFFER)NULL)
            break;
        NdisQueryBuffer(CurBuffer, NULL, (PVOID *) &BufVA, &BufLen);
    }
    return BytesCopied;
}



//
// NdisTransferData
//
// NDIS function
//
// - AdaptP->LoopbackPacket will be FALSE if this is for a normal
//   indication, otherwise it will point to a loopback packet
//

static
NDIS_STATUS
TestMacTransferData(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle,
    IN NDIS_HANDLE MacReceiveContext,
    IN UINT ByteOffset,
    IN UINT BytesToTransfer,
    OUT PNDIS_PACKET Packet,
    OUT PUINT BytesTransferred
    )
{
#define OpenP   ((POPEN_BLOCK)MacBindingHandle)
#define AdaptP  ((PADAPTER_BLOCK)MacReceiveContext)

    RequestHandle; ByteOffset; BytesToTransfer; Packet; BytesTransferred;

    if (OpenP->Debug)
        DbgPrint("--> TestMacTransferData %d\n", AdaptP->AdapterNumber);

    if (AdaptP->LoopbackPacket != (PNDIS_PACKET)NULL) {
        PNDIS_BUFFER CurBuffer;
        UINT Dummy;
        PUCHAR BufVA;
        UINT BufLen, Copied;
        UINT CurOff;

        // have to copy data from AdaptP->LoopbackPacket into Packet
        NdisQueryPacket(Packet, NULL, &Dummy, &CurBuffer, NULL);
        CurOff = ByteOffset;
        while (CurBuffer != (PNDIS_BUFFER)NULL) {
            NdisQueryBuffer(CurBuffer, NULL, (PVOID *) &BufVA, &BufLen);
            Copied = TestMacCopyOver(BufVA, AdaptP->LoopbackPacket,
                                     CurOff, BufLen);
            CurOff += Copied;
            if (Copied < BufLen)
                break;
            NdisGetNextBuffer(CurBuffer, &CurBuffer);
        }
        *BytesTransferred = CurOff - ByteOffset;
    }

    return NDIS_STATUS_SUCCESS;
#undef AdaptP
#undef OpenP
}



//
// MacQueryInformation
//
// NDIS function
//

static
NDIS_STATUS
TestMacQueryInformation(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle,
    IN NDIS_INFORMATION_CLASS InformationClass,
    OUT PVOID Buffer,
    IN UINT BufferLength
    )
{
#define OpenP   ((POPEN_BLOCK)MacBindingHandle)
    PADAPTER_BLOCK AdaptP = OpenP->AdapterBlock;
    UINT i;
    static UCHAR StationAddress[] = { 0x00, 0x00, 0x00, 0x01, 0x02, 0x03 };

    RequestHandle; InformationClass; Buffer; BufferLength;

    if (OpenP->Debug)
        DbgPrint("--> TestMacQueryInformation %d\n", AdaptP->AdapterNumber);


    switch (InformationClass) {

    case NdisInfoStationAddress:
        RtlMoveMemory(Buffer, StationAddress, 6);
        break;

    }

#if 0
    if ((UINT)InformationClass == 1) {
        // show multicast list
        PMULTICAST_ENTRY MCSlot, End;
        POPEN_BLOCK CurOpen;
        PUCHAR Tcp;

        NdisAcquireSpinLock(&AdaptP->MulticastSpinLock);
        AdaptP->MulticastDontModify = TRUE;
        NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);

        MCSlot = AdaptP->MulticastList;
        End = &AdaptP->MulticastList[AdaptP->MulticastListSize];
        while (MCSlot < End) {
            Tcp = MCSlot->Address;
            for (i=0; i<6; i++) {
                if (Tcp[i] >= ' ' && Tcp[i] <= 'z')
                    DbgPrint(" %c ", Tcp[i]);
                else
                    DbgPrint("%2x ", Tcp[i]);
            }
            CurOpen = AdaptP->OpenQueue;
            while (CurOpen != (POPEN_BLOCK)NULL) {
                if (CurOpen->MulticastBit & MCSlot->ProtocolMask)
                    DbgPrint(CurOpen == OpenP ? "  X" : "  x");
                else
                    DbgPrint("   ");
                CurOpen = CurOpen->NextOpen;
            }
            DbgPrint("\n");
            ++MCSlot;
        }

        NdisAcquireSpinLock(&AdaptP->MulticastSpinLock);
        AdaptP->MulticastDontModify = FALSE;
        NdisReleaseSpinLock(&AdaptP->MulticastSpinLock);
    }
#else
    i;
#endif

    return NDIS_STATUS_SUCCESS;
#undef OpenP
}



//
// MacSetInformation
//
// NDIS function
//

static
NDIS_STATUS
TestMacSetInformation(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle,
    IN NDIS_INFORMATION_CLASS InformationClass,
    IN PVOID Buffer,
    IN UINT BufferLength
    )
{
#define OpenP   ((POPEN_BLOCK)MacBindingHandle)
    PADAPTER_BLOCK AdaptP = OpenP->AdapterBlock;

    RequestHandle; InformationClass; Buffer; BufferLength;

    if (OpenP->Debug)
        DbgPrint("--> TestMacSetInformation %d\n", AdaptP->AdapterNumber);

    // this will involve the OpenData and AdapterData structures

    return NDIS_STATUS_SUCCESS;
#undef OpenP
}



//
// MacReset
//
// NDIS function
//

static
NDIS_STATUS
TestMacReset(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle
    )
{
#define OpenP   ((POPEN_BLOCK)MacBindingHandle)
    PADAPTER_BLOCK AdaptP = OpenP->AdapterBlock;
    POPEN_BLOCK TmpOpenP;

    RequestHandle;

    if (OpenP->Debug)
        DbgPrint("--> TestMacReset %d\n", AdaptP->AdapterNumber);

    TmpOpenP = AdaptP->OpenQueue;
    while (TmpOpenP != (POPEN_BLOCK)NULL) {
        NdisIndicateStatus(TmpOpenP->NdisBindingContext, NDIS_STATUS_RESET, 0);
        TmpOpenP = TmpOpenP->NextOpen;
    }

    return NDIS_STATUS_SUCCESS;
#undef OpenP
}



//
// MacTest
//
// NDIS function
//

static
NDIS_STATUS
TestMacTest(
    IN NDIS_HANDLE MacBindingHandle,
    IN NDIS_HANDLE RequestHandle
    )
{
#define OpenP   ((POPEN_BLOCK)MacBindingHandle)
    PADAPTER_BLOCK AdaptP = OpenP->AdapterBlock;

    RequestHandle;

    if (OpenP->Debug)
        DbgPrint("--> TestMacTest %d\n", AdaptP->AdapterNumber);

    return NDIS_STATUS_SUCCESS;
#undef OpenP
}


static
VOID
TestMacIndicateDpc(
    IN PKDPC Dpc,
    IN PVOID DeferredContext,
    IN PVOID SystemArgument1,
    IN PVOID SystemArgument2
    )
{
#define AdaptP ((PADAPTER_BLOCK)DeferredContext)
    PNDIS_PACKET LPacket;
    PMAC_RESERVED Reserved;
    POPEN_BLOCK CurOpen;

    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemArgument1);
    UNREFERENCED_PARAMETER(SystemArgument2);

    // loopback any waiting packets
    NdisAcquireSpinLock(&AdaptP->LoopbackSpinLock);
    while (AdaptP->LoopbackQueue) {
        // take the first packet off the queue
        LPacket = AdaptP->LoopbackQueue;
        Reserved = RESERVED(LPacket);
        AdaptP->LoopbackQueue = RESERVED(AdaptP->LoopbackQueue)->NextPacket;
        NdisReleaseSpinLock(&AdaptP->LoopbackSpinLock);
        AdaptP->LoopbackPacket = LPacket;
        // actually indicate it
        TestMacIndicateLoopbackPacket(AdaptP, AdaptP->LoopbackPacket);
        NdisAcquireSpinLock(&AdaptP->LoopbackSpinLock);
        // complete the packet if needed
        if (Reserved->RequestHandle != 0) {
            NdisCompleteSend(
                        Reserved->OpenBlock->NdisBindingContext,
                        Reserved->RequestHandle,
                        NDIS_STATUS_SUCCESS);
        }
    }
    AdaptP->DpcQueued = FALSE;
    NdisReleaseSpinLock(&AdaptP->LoopbackSpinLock);

    // indicate ReceiveComplete
    CurOpen = AdaptP->OpenQueue;
    while (CurOpen) {
        NdisIndicateReceiveComplete(CurOpen->NdisBindingContext);
        CurOpen = CurOpen->NextOpen;
    }

#undef AdaptP
}