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_ADAPTER

Macros
#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	IP_MAX_RECV_BACKLOG   0x20
#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_ADAPTER	LAN_ADAPTER
typedef struct LAN_ADAPTER *	PLAN_ADAPTER

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 NTAPI	LANUnregisterProtocol (VOID)
	Unregisters this protocol driver with NDIS.
VOID	LANStartup (VOID)
VOID	LANShutdown (VOID)
NTSTATUS	TcpipLanGetDwordOid (PIP_INTERFACE Interface, NDIS_OID Oid, PULONG Result)
NDIS_STATUS	NDISCall (PLAN_ADAPTER Adapter, NDIS_REQUEST_TYPE Type, NDIS_OID OID, PVOID Buffer, UINT Length)
	Send a request to NDIS.

Macro Definition Documentation

BCAST_ETH_CHECK

#define BCAST_ETH_CHECK   0x01

Definition at line 30 of file lan.h.

BCAST_ETH_MASK

#define BCAST_ETH_MASK   0x01

Definition at line 27 of file lan.h.

BCAST_ETH_OFFSET

#define BCAST_ETH_OFFSET   0x00

Definition at line 33 of file lan.h.

ETYPE_ARP

#define ETYPE_ARP   WH2N(0x0806)

Definition at line 77 of file lan.h.

ETYPE_IPv4

#define ETYPE_IPv4   WH2N(0x0800)

Definition at line 75 of file lan.h.

ETYPE_IPv6

#define ETYPE_IPv6   WH2N(0x86DD)

Definition at line 76 of file lan.h.

IEEE_802_ADDR_LENGTH

#define IEEE_802_ADDR_LENGTH   6

Definition at line 15 of file lan.h.

IP_MAX_RECV_BACKLOG

#define IP_MAX_RECV_BACKLOG   0x20

Definition at line 36 of file lan.h.

LAN_PROTO_ARP

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

Definition at line 82 of file lan.h.

LAN_PROTO_IPv4

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

Definition at line 80 of file lan.h.

LAN_PROTO_IPv6

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

Definition at line 81 of file lan.h.

LAN_STATE_OPENING

#define LAN_STATE_OPENING   0

Definition at line 65 of file lan.h.

LAN_STATE_RESETTING

#define LAN_STATE_RESETTING   1

Definition at line 66 of file lan.h.

LAN_STATE_STARTED

#define LAN_STATE_STARTED   2

Definition at line 67 of file lan.h.

LAN_STATE_STOPPED

#define LAN_STATE_STOPPED   3

Definition at line 68 of file lan.h.

LOOKAHEAD_SIZE

#define LOOKAHEAD_SIZE   128

Definition at line 71 of file lan.h.

MAX_MEDIA

#define MAX_MEDIA   1

Definition at line 13 of file lan.h.

MAX_MEDIA_ETH

#define MAX_MEDIA_ETH   sizeof(ETH_HEADER)

Definition at line 24 of file lan.h.

MEDIA_ETH

#define MEDIA_ETH   0

Definition at line 11 of file lan.h.

Typedef Documentation

ETH_HEADER

typedef struct ETH_HEADER ETH_HEADER

LAN_ADAPTER

typedef struct LAN_ADAPTER LAN_ADAPTER

PETH_HEADER

typedef struct ETH_HEADER * PETH_HEADER

PLAN_ADAPTER

typedef struct LAN_ADAPTER * PLAN_ADAPTER

Function Documentation

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;
}

Referenced by ProtocolBindAdapter().

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

LANShutdown()

VOID LANShutdown

(

VOID

)

LANStartup()

VOID LANStartup

(

VOID

)

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;
}

Referenced by LANUnregisterProtocol(), and ProtocolUnbindAdapter().

LANUnregisterProtocol()

VOID NTAPI 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 LANRegisterProtocol(), and LanUnload().

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 BindAdapter(), LANRegisterAdapter(), ReconfigureAdapter(), and TcpipLanGetDwordOid().

TcpipLanGetDwordOid()

NTSTATUS TcpipLanGetDwordOid	(	PIP_INTERFACE	Interface,
		NDIS_OID	Oid,
		PULONG	Result
	)

Definition at line 183 of file lan.c.

                  {
    /* Get maximum frame size */
    if( Interface->Context ) {
        return NDISCall((PLAN_ADAPTER)Interface->Context,
                        NdisRequestQueryInformation,
                        Oid,
                        Result,
                        sizeof(ULONG));
    } else switch( Oid ) { /* Loopback Case */
    case OID_GEN_HARDWARE_STATUS:
        *Result = NdisHardwareStatusReady;
        return STATUS_SUCCESS;
    case OID_GEN_MEDIA_CONNECT_STATUS:
        *Result = NdisMediaStateConnected;
        return STATUS_SUCCESS;
    default:
        return STATUS_INVALID_PARAMETER;
    }
}