lan.h File Reference

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

Go to the source code of this file.

Classes
struct	ETH_HEADER
struct	_LAN_ADDRESS_C
struct	LAN_ADAPTER
struct	_LAN_PACKET
struct	_LAN_PROTOCOL
struct	_LAN_DEVICE_EXT

Macros
#define	NDIS_VERSION_MAJOR   4
#define	NDIS_VERSION_MINOR   0
#define	MIN(value1, value2)    ((value1 < value2)? value1 : value2)
#define	MAX(value1, value2)    ((value1 > value2)? value1 : value2)
#define	NDIS_BUFFER_TAG   FOURCC('n','b','u','f')
#define	NDIS_PACKET_TAG   FOURCC('n','p','k','t')
#define	MEDIA_ETH   0
#define	MAX_MEDIA   1
#define	IEEE_802_ADDR_LENGTH   6
#define	MAX_MEDIA_ETH   sizeof(ETH_HEADER)
#define	BCAST_ETH_MASK   0x01
#define	BCAST_ETH_CHECK   0x01
#define	BCAST_ETH_OFFSET   0x00
#define	LAN_STATE_OPENING   0
#define	LAN_STATE_RESETTING   1
#define	LAN_STATE_STARTED   2
#define	LAN_STATE_STOPPED   3
#define	LOOKAHEAD_SIZE   128
#define	ETYPE_IPv4   WH2N(0x0800)
#define	ETYPE_IPv6   WH2N(0x86DD)
#define	ETYPE_ARP   WH2N(0x0806)
#define	LAN_PROTO_IPv4   0x0000 /* Internet Protocol version 4 */
#define	LAN_PROTO_IPv6   0x0001 /* Internet Protocol version 6 */
#define	LAN_PROTO_ARP   0x0002 /* Address Resolution Protocol */

Typedefs
typedef struct ETH_HEADER	ETH_HEADER
typedef struct ETH_HEADER *	PETH_HEADER
typedef struct _LAN_ADDRESS_C	LAN_ADDRESS_C
typedef struct _LAN_ADDRESS_C *	PLAN_ADDRESS_C
typedef struct LAN_ADAPTER	LAN_ADAPTER
typedef struct LAN_ADAPTER *	PLAN_ADAPTER
typedef struct _LAN_PACKET	LAN_PACKET
typedef struct _LAN_PACKET *	PLAN_PACKET
typedef struct _LAN_PROTOCOL	LAN_PROTOCOL
typedef struct _LAN_PROTOCOL *	PLAN_PROTOCOL
typedef struct _LAN_DEVICE_EXT	LAN_DEVICE_EXT
typedef struct _LAN_DEVICE_EXT *	PLAN_DEVICE_EXT

Functions
NDIS_STATUS	LANRegisterAdapter (PNDIS_STRING AdapterName, PNDIS_STRING RegistryPath)
	Registers protocol with an NDIS adapter.
NDIS_STATUS	LANUnregisterAdapter (PLAN_ADAPTER Adapter)
	Unregisters protocol with NDIS adapter.
NTSTATUS	LANRegisterProtocol (PNDIS_STRING Name)
	Registers this protocol driver with NDIS.
VOID	LANUnregisterProtocol (VOID)
	Unregisters this protocol driver with NDIS.
NDIS_STATUS	NDISCall (PLAN_ADAPTER Adapter, NDIS_REQUEST_TYPE Type, NDIS_OID OID, PVOID Buffer, UINT Length)
	Send a request to NDIS.
void	GetDataPtr (PNDIS_PACKET Packet, UINT Offset, PCHAR *DataOut, PUINT Size)
NDIS_STATUS	AllocatePacketWithBufferX (PNDIS_PACKET *NdisPacket, PCHAR Data, UINT Len, PCHAR File, UINT Line)
VOID	FreeNdisPacketX (PNDIS_PACKET Packet, PCHAR File, UINT Line)
NDIS_STATUS	InitNdisPools (VOID)
VOID	CloseNdisPools (VOID)
PLAN_ADAPTER	FindAdapterByIndex (PLAN_DEVICE_EXT DeviceExt, UINT Index)

Macro Definition Documentation

BCAST_ETH_CHECK

#define BCAST_ETH_CHECK   0x01

Definition at line 45 of file lan.h.

BCAST_ETH_MASK

#define BCAST_ETH_MASK   0x01

Definition at line 42 of file lan.h.

BCAST_ETH_OFFSET

#define BCAST_ETH_OFFSET   0x00

Definition at line 48 of file lan.h.

ETYPE_ARP

#define ETYPE_ARP   WH2N(0x0806)

Definition at line 123 of file lan.h.

ETYPE_IPv4

#define ETYPE_IPv4   WH2N(0x0800)

Definition at line 121 of file lan.h.

ETYPE_IPv6

#define ETYPE_IPv6   WH2N(0x86DD)

Definition at line 122 of file lan.h.

IEEE_802_ADDR_LENGTH

#define IEEE_802_ADDR_LENGTH   6

Definition at line 30 of file lan.h.

LAN_PROTO_ARP

#define LAN_PROTO_ARP   0x0002 /* Address Resolution Protocol */

Definition at line 128 of file lan.h.

LAN_PROTO_IPv4

#define LAN_PROTO_IPv4   0x0000 /* Internet Protocol version 4 */

Definition at line 126 of file lan.h.

LAN_PROTO_IPv6

#define LAN_PROTO_IPv6   0x0001 /* Internet Protocol version 6 */

Definition at line 127 of file lan.h.

LAN_STATE_OPENING

#define LAN_STATE_OPENING   0

Definition at line 111 of file lan.h.

LAN_STATE_RESETTING

#define LAN_STATE_RESETTING   1

Definition at line 112 of file lan.h.

LAN_STATE_STARTED

#define LAN_STATE_STARTED   2

Definition at line 113 of file lan.h.

LAN_STATE_STOPPED

#define LAN_STATE_STOPPED   3

Definition at line 114 of file lan.h.

LOOKAHEAD_SIZE

#define LOOKAHEAD_SIZE   128

Definition at line 117 of file lan.h.

MAX

#define MAX	(		value1,
			value2
	)		((value1 > value2)? value1 : value2)

Definition at line 19 of file lan.h.

MAX_MEDIA

#define MAX_MEDIA   1

Definition at line 28 of file lan.h.

MAX_MEDIA_ETH

#define MAX_MEDIA_ETH   sizeof(ETH_HEADER)

Definition at line 39 of file lan.h.

MEDIA_ETH

#define MEDIA_ETH   0

Definition at line 26 of file lan.h.

MIN

#define MIN	(		value1,
			value2
	)		((value1 < value2)? value1 : value2)

Definition at line 16 of file lan.h.

NDIS_BUFFER_TAG

#define NDIS_BUFFER_TAG   FOURCC('n','b','u','f')

Definition at line 22 of file lan.h.

NDIS_PACKET_TAG

#define NDIS_PACKET_TAG   FOURCC('n','p','k','t')

Definition at line 23 of file lan.h.

NDIS_VERSION_MAJOR

#define NDIS_VERSION_MAJOR   4

Definition at line 11 of file lan.h.

NDIS_VERSION_MINOR

#define NDIS_VERSION_MINOR   0

Definition at line 12 of file lan.h.

Typedef Documentation

ETH_HEADER

typedef struct ETH_HEADER ETH_HEADER

LAN_ADAPTER

typedef struct LAN_ADAPTER LAN_ADAPTER

LAN_ADDRESS_C

typedef struct _LAN_ADDRESS_C LAN_ADDRESS_C

LAN_DEVICE_EXT

typedef struct _LAN_DEVICE_EXT LAN_DEVICE_EXT

LAN_PACKET

typedef struct _LAN_PACKET LAN_PACKET

LAN_PROTOCOL

typedef struct _LAN_PROTOCOL LAN_PROTOCOL

PETH_HEADER

typedef struct ETH_HEADER * PETH_HEADER

PLAN_ADAPTER

typedef struct LAN_ADAPTER * PLAN_ADAPTER

PLAN_ADDRESS_C

typedef struct _LAN_ADDRESS_C * PLAN_ADDRESS_C

PLAN_DEVICE_EXT

typedef struct _LAN_DEVICE_EXT * PLAN_DEVICE_EXT

PLAN_PACKET

typedef struct _LAN_PACKET * PLAN_PACKET

PLAN_PROTOCOL

typedef struct _LAN_PROTOCOL * PLAN_PROTOCOL

Function Documentation

AllocatePacketWithBufferX()

NDIS_STATUS AllocatePacketWithBufferX	(	PNDIS_PACKET *	NdisPacket,
		PCHAR	Data,
		UINT	Len,
		PCHAR	File,
		UINT	Line
	)

Definition at line 82 of file routines.c.

                                               {
    PNDIS_PACKET Packet;
    PNDIS_BUFFER Buffer;
    NDIS_STATUS Status;
    PCHAR NewData;
 
    NewData = exAllocatePool( NonPagedPool, Len );
    if( !NewData ) return NDIS_STATUS_NOT_ACCEPTED; // XXX
 
    if( Data )
    RtlCopyMemory(NewData, Data, Len);
 
    NdisAllocatePacket( &Status, &Packet, GlobalPacketPool );
    if( Status != NDIS_STATUS_SUCCESS ) {
    exFreePool( NewData );
    return Status;
    }
    TrackWithTag(NDIS_PACKET_TAG, Packet, File, Line);
 
    NdisAllocateBuffer( &Status, &Buffer, GlobalBufferPool, NewData, Len );
    if( Status != NDIS_STATUS_SUCCESS ) {
    exFreePool( NewData );
    FreeNdisPacket( Packet );
    }
    TrackWithTag(NDIS_BUFFER_TAG, Buffer, File, Line);
 
    NdisChainBufferAtFront( Packet, Buffer );
    *NdisPacket = Packet;
 
    return NDIS_STATUS_SUCCESS;
}

CloseNdisPools()

VOID CloseNdisPools

(

VOID

)

FindAdapterByIndex()

PLAN_ADAPTER FindAdapterByIndex	(	PLAN_DEVICE_EXT	DeviceExt,
		UINT	Index
	)

Definition at line 1073 of file lan.c.

{
    PLIST_ENTRY ListEntry;
    PLAN_ADAPTER Current, Target = NULL;
 
    for (ListEntry = DeviceExt->AdapterListHead.Flink;
         ListEntry != &DeviceExt->AdapterListHead;
         ListEntry = ListEntry->Flink)
    {
        Current = CONTAINING_RECORD(ListEntry, LAN_ADAPTER, ListEntry);
        if (Current->Index == Index)
        {
            Target = Current;
            break;
        }
    }
 
    return Target;
}

Referenced by LanAdapterInfo(), and LANTransmitInternal().

FreeNdisPacketX()

VOID FreeNdisPacketX	(	PNDIS_PACKET	Packet,
		PCHAR	File,
		UINT	Line
	)

Definition at line 117 of file routines.c.

{
    PNDIS_BUFFER Buffer, NextBuffer;
 
    LA_DbgPrint(DEBUG_PBUFFER, ("Packet (0x%X)\n", Packet));
 
    /* Free all the buffers in the packet first */
    NdisQueryPacket(Packet, NULL, NULL, &Buffer, NULL);
    for (; Buffer != NULL; Buffer = NextBuffer) {
        PVOID Data;
        UINT Length;
 
        NdisGetNextBuffer(Buffer, &NextBuffer);
        NdisQueryBuffer(Buffer, &Data, &Length);
        NdisFreeBuffer(Buffer);
    UntrackFL(File,Line,Buffer);
        exFreePool(Data);
    }
 
    /* Finally free the NDIS packet descriptor */
    NdisFreePacket(Packet);
    UntrackFL(File,Line,Packet);
}

GetDataPtr()

void GetDataPtr	(	PNDIS_PACKET	Packet,
		UINT	Offset,
		PCHAR *	DataOut,
		PUINT	Size
	)

Definition at line 65 of file routines.c.

                      {
    PNDIS_BUFFER Buffer;
 
    NdisQueryPacket(Packet, NULL, NULL, &Buffer, NULL);
    if( !Buffer ) return;
    SkipToOffset( Buffer, Offset, DataOut, Size );
}

Referenced by AddGenericHeaderIPv4(), LANTransmit(), LANTransmitInternal(), LoopTransmit(), PrepareARPPacket(), ProtocolReceive(), SendFragments(), SendPacket(), and TCPSendDataCallback().

InitNdisPools()

NDIS_STATUS InitNdisPools

(

VOID

)

LANRegisterAdapter()

NDIS_STATUS LANRegisterAdapter	(	PNDIS_STRING	AdapterName,
		PNDIS_STRING	RegistryPath
	)

Registers protocol with an NDIS adapter.

Parameters

AdapterName	= Pointer to string with name of adapter to register
Adapter	= Address of pointer to a LAN_ADAPTER structure

Returns

Status of operation

Definition at line 637 of file lan.c.

{
    PLAN_ADAPTER Adapter;
    NDIS_MEDIUM MediaArray[MAX_MEDIA];
    NDIS_STATUS NdisStatus;
    NDIS_STATUS OpenStatus;
    UINT MediaIndex;
    UINT AddressOID;
    UINT Speed;
    PLAN_DEVICE_EXT DeviceExt = LanDeviceObject->DeviceExtension;
 
    LA_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 
    Adapter = exAllocatePool(NonPagedPool, sizeof(LAN_ADAPTER));
    if (!Adapter)
    {
        LA_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
        return NDIS_STATUS_RESOURCES;
    }
 
    RtlZeroMemory(Adapter, sizeof(LAN_ADAPTER));
 
    /* Put adapter in stopped state */
    Adapter->State = LAN_STATE_STOPPED;
    Adapter->Index = DeviceExt->AdapterId++;
 
    InitializeListHead(&Adapter->AddressList);
    InitializeListHead(&Adapter->ForeignList);
 
    /* Initialize protecting spin lock */
    KeInitializeSpinLock(&Adapter->Lock);
 
    KeInitializeEvent(&Adapter->Event, SynchronizationEvent, FALSE);
 
    /* Initialize array with media IDs we support */
    MediaArray[MEDIA_ETH] = NdisMedium802_3;
 
    LA_DbgPrint(DEBUG_DATALINK,("opening adapter %wZ\n", AdapterName));
 
    /* Open the adapter. */
    NdisOpenAdapter(&NdisStatus,
                    &OpenStatus,
                    &Adapter->NdisHandle,
                    &MediaIndex,
                    MediaArray,
                    MAX_MEDIA,
                    DeviceExt->NdisProtocolHandle,
                    Adapter,
                    AdapterName,
                    0,
                    NULL);
 
    /* Wait until the adapter is opened */
    if (NdisStatus == NDIS_STATUS_PENDING)
        KeWaitForSingleObject(&Adapter->Event, UserRequest, KernelMode, FALSE, NULL);
    else if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        exFreePool(Adapter);
        return NdisStatus;
    }
 
    Adapter->Media = MediaArray[MediaIndex];
 
    /* Fill LAN_ADAPTER structure with some adapter specific information */
    switch (Adapter->Media)
    {
    case NdisMedium802_3:
        Adapter->HWAddressLength = IEEE_802_ADDR_LENGTH;
        Adapter->BCastMask       = BCAST_ETH_MASK;
        Adapter->BCastCheck      = BCAST_ETH_CHECK;
        Adapter->BCastOffset     = BCAST_ETH_OFFSET;
        Adapter->HeaderSize      = sizeof(ETH_HEADER);
        Adapter->MinFrameSize    = 60;
        AddressOID          = OID_802_3_CURRENT_ADDRESS;
        Adapter->PacketFilter    =
            NDIS_PACKET_TYPE_BROADCAST |
            NDIS_PACKET_TYPE_DIRECTED  |
            NDIS_PACKET_TYPE_MULTICAST;
        break;
 
    default:
        /* Unsupported media */
        LA_DbgPrint(MIN_TRACE, ("Unsupported media.\n"));
        exFreePool(Adapter);
        return NDIS_STATUS_NOT_SUPPORTED;
    }
 
    /* Get maximum frame size */
    NdisStatus = NDISCall(Adapter,
                          NdisRequestQueryInformation,
                          OID_GEN_MAXIMUM_FRAME_SIZE,
                          &Adapter->MTU,
                          sizeof(UINT));
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        exFreePool(Adapter);
        return NdisStatus;
    }
 
    /* Get maximum packet size */
    NdisStatus = NDISCall(Adapter,
                          NdisRequestQueryInformation,
                          OID_GEN_MAXIMUM_TOTAL_SIZE,
                          &Adapter->MaxPacketSize,
                          sizeof(UINT));
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        LA_DbgPrint(MIN_TRACE, ("Query for maximum packet size failed.\n"));
        exFreePool(Adapter);
        return NdisStatus;
    }
 
    /* Get maximum number of packets we can pass to NdisSend(Packets) at one time */
    NdisStatus = NDISCall(Adapter,
                          NdisRequestQueryInformation,
                          OID_GEN_MAXIMUM_SEND_PACKETS,
                          &Adapter->MaxSendPackets,
                          sizeof(UINT));
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        /* Legacy NIC drivers may not support this query, if it fails we
           assume it can send at least one packet per call to NdisSend(Packets) */
        Adapter->MaxSendPackets = 1;
    }
 
    /* Get current hardware address */
    NdisStatus = NDISCall(Adapter,
                          NdisRequestQueryInformation,
                          AddressOID,
                          Adapter->HWAddress,
                          Adapter->HWAddressLength);
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        LA_DbgPrint(MIN_TRACE, ("Query for current hardware address failed.\n"));
        exFreePool(Adapter);
        return NdisStatus;
    }
 
    /* Get maximum link speed */
    NdisStatus = NDISCall(Adapter,
                          NdisRequestQueryInformation,
                          OID_GEN_LINK_SPEED,
                          &Speed,
                          sizeof(UINT));
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        LA_DbgPrint(MIN_TRACE, ("Query for maximum link speed failed.\n"));
        exFreePool(Adapter);
        return NdisStatus;
    }
 
    /* Convert returned link speed to bps (it is in 100bps increments) */
    Adapter->Speed = Speed * 100L;
 
    /* Add adapter to the adapter list */
    ExInterlockedInsertTailList(&DeviceExt->AdapterListHead,
                                &Adapter->ListEntry,
                                &DeviceExt->Lock);
 
    Adapter->RegistryPath.Buffer =
        ExAllocatePool(NonPagedPool, RegistryPath->MaximumLength);
    if (!Adapter->RegistryPath.Buffer)
        return NDIS_STATUS_RESOURCES;
 
    RtlCopyUnicodeString(&Adapter->RegistryPath, RegistryPath);
 
    NdisStatus = NDISCall(Adapter,
                          NdisRequestSetInformation,
                          OID_GEN_CURRENT_LOOKAHEAD,
                          &Adapter->Lookahead,
                          sizeof(ULONG));
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        LA_DbgPrint(MID_TRACE,
                    ("Could not set lookahead buffer size (0x%X).\n",
                     NdisStatus));
        return NdisStatus;
    }
 
    /* Set packet filter so we can send and receive packets */
    NdisStatus = NDISCall(Adapter,
                          NdisRequestSetInformation,
                          OID_GEN_CURRENT_PACKET_FILTER,
                          &Adapter->PacketFilter,
                          sizeof(UINT));
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        LA_DbgPrint(MID_TRACE, ("Could not set packet filter (0x%X).\n",
                                NdisStatus));
        return NdisStatus;
    }
 
    Adapter->State = LAN_STATE_STARTED;
 
    LA_DbgPrint(DEBUG_DATALINK, ("Leaving.\n"));
 
    return NDIS_STATUS_SUCCESS;
}

LANRegisterProtocol()

NTSTATUS LANRegisterProtocol

(

PNDIS_STRING

Name

)

Registers this protocol driver with NDIS.

Parameters

Name	= Name of this protocol driver

Returns

Status of operation

Definition at line 893 of file lan.c.

{
    NDIS_STATUS NdisStatus;
    NDIS_PROTOCOL_CHARACTERISTICS ProtChars;
    PLAN_DEVICE_EXT DeviceExt = LanDeviceObject->DeviceExtension;
 
    LA_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 
    InitializeListHead(&DeviceExt->AdapterListHead);
    InitializeListHead(&DeviceExt->ProtocolListHead);
 
    /* Set up protocol characteristics */
    RtlZeroMemory(&ProtChars, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
    ProtChars.MajorNdisVersion               = NDIS_VERSION_MAJOR;
    ProtChars.MinorNdisVersion               = NDIS_VERSION_MINOR;
    ProtChars.Name.Length                    = Name->Length;
    ProtChars.Name.Buffer                    = Name->Buffer;
    ProtChars.Name.MaximumLength             = Name->MaximumLength;
    ProtChars.OpenAdapterCompleteHandler     = ProtocolOpenAdapterComplete;
    ProtChars.CloseAdapterCompleteHandler    = ProtocolCloseAdapterComplete;
    ProtChars.ResetCompleteHandler           = ProtocolResetComplete;
    ProtChars.RequestCompleteHandler         = ProtocolRequestComplete;
    ProtChars.SendCompleteHandler            = ProtocolSendComplete;
    ProtChars.TransferDataCompleteHandler    = ProtocolTransferDataComplete;
    ProtChars.ReceiveHandler                 = ProtocolReceive;
    ProtChars.ReceiveCompleteHandler         = ProtocolReceiveComplete;
    ProtChars.StatusHandler                  = ProtocolStatus;
    ProtChars.StatusCompleteHandler          = ProtocolStatusComplete;
    ProtChars.BindAdapterHandler             = ProtocolBindAdapter;
 
    /* Try to register protocol */
    NdisRegisterProtocol(&NdisStatus,
                         &DeviceExt->NdisProtocolHandle,
                         &ProtChars,
                         sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        LA_DbgPrint(MID_TRACE, ("NdisRegisterProtocol failed, status 0x%x\n", NdisStatus));
        return (NTSTATUS)NdisStatus;
    }
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

LANUnregisterAdapter()

NDIS_STATUS LANUnregisterAdapter

(

PLAN_ADAPTER

Adapter

)

Unregisters protocol with NDIS adapter.

Parameters

Adapter

= Pointer to a LAN_ADAPTER structure

Returns

Status of operation

Definition at line 847 of file lan.c.

{
    KIRQL OldIrql;
    NDIS_HANDLE NdisHandle;
    NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
 
    LA_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 
    /* Unlink the adapter from the list */
    RemoveEntryList(&Adapter->ListEntry);
 
    KeAcquireSpinLock(&Adapter->Lock, &OldIrql);
    NdisHandle = Adapter->NdisHandle;
    if (NdisHandle)
    {
        Adapter->NdisHandle = NULL;
        KeReleaseSpinLock(&Adapter->Lock, OldIrql);
 
        NdisCloseAdapter(&NdisStatus, NdisHandle);
        if (NdisStatus == NDIS_STATUS_PENDING)
        {
            KeWaitForSingleObject(&Adapter->Event,
                                  UserRequest,
                                  KernelMode,
                                  FALSE,
                                  NULL);
            NdisStatus = Adapter->NdisStatus;
        }
    }
    else
        KeReleaseSpinLock(&Adapter->Lock, OldIrql);
 
    FreeAdapter(Adapter);
 
    return NDIS_STATUS_SUCCESS;
}

LANUnregisterProtocol()

VOID LANUnregisterProtocol

(

VOID

)

Unregisters this protocol driver with NDIS.

Note

Does not care wether we are already registered

Definition at line 943 of file lan.c.

{
    PLAN_DEVICE_EXT DeviceExt = LanDeviceObject->DeviceExtension;
 
    LA_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 
    NDIS_STATUS NdisStatus;
    PLIST_ENTRY CurrentEntry;
    PLIST_ENTRY NextEntry;
    PLAN_ADAPTER Current;
    KIRQL OldIrql;
 
    KeAcquireSpinLock(&DeviceExt->Lock, &OldIrql);
 
    /* Search the list and remove every adapter we find */
    CurrentEntry = DeviceExt->AdapterListHead.Flink;
    while (CurrentEntry != &DeviceExt->AdapterListHead)
    {
        NextEntry = CurrentEntry->Flink;
        Current = CONTAINING_RECORD(CurrentEntry, LAN_ADAPTER, ListEntry);
        /* Unregister it */
        LANUnregisterAdapter(Current);
        CurrentEntry = NextEntry;
    }
 
    NdisDeregisterProtocol(&NdisStatus, DeviceExt->NdisProtocolHandle);
}

Referenced by TiUnload().

NDISCall()

NDIS_STATUS NDISCall	(	PLAN_ADAPTER	Adapter,
		NDIS_REQUEST_TYPE	Type,
		NDIS_OID	OID,
		PVOID	Buffer,
		UINT	Length
	)

Send a request to NDIS.

Parameters

Adapter	= Pointer to a LAN_ADAPTER structure
Type	= Type of request (Set or Query)
OID	= Value to be set/queried for
Buffer	= Pointer to a buffer to use
Length	= Number of bytes in Buffer

Returns

Status of operation

Definition at line 29 of file lan.c.

{
    NDIS_REQUEST Request;
    NDIS_STATUS NdisStatus;
 
    Request.RequestType = Type;
    if (Type == NdisRequestSetInformation)
    {
        Request.DATA.SET_INFORMATION.Oid = OID;
        Request.DATA.SET_INFORMATION.InformationBuffer = Buffer;
        Request.DATA.SET_INFORMATION.InformationBufferLength = Length;
    }
    else
    {
        Request.DATA.QUERY_INFORMATION.Oid = OID;
        Request.DATA.QUERY_INFORMATION.InformationBuffer = Buffer;
        Request.DATA.QUERY_INFORMATION.InformationBufferLength = Length;
    }
 
    if (Adapter->State != LAN_STATE_RESETTING)
    {
        NdisRequest(&NdisStatus, Adapter->NdisHandle, &Request);
    }
    else
    {
        NdisStatus = NDIS_STATUS_NOT_ACCEPTED;
    }
 
    /* Wait for NDIS to complete the request */
    if (NdisStatus == NDIS_STATUS_PENDING)
    {
        KeWaitForSingleObject(&Adapter->Event,
                              UserRequest,
                              KernelMode,
                              FALSE,
                              NULL);
        NdisStatus = Adapter->NdisStatus;
    }
 
    return NdisStatus;
}

Referenced by InfoTdiQueryGetInterfaceMIB().