1883 lines
57 KiB
C
1883 lines
57 KiB
C
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil -*- (for GNU Emacs)
|
|
//
|
|
// Copyright (c) 1985-2000 Microsoft Corporation
|
|
//
|
|
// This file is part of the Microsoft Research IPv6 Network Protocol Stack.
|
|
// You should have received a copy of the Microsoft End-User License Agreement
|
|
// for this software along with this release; see the file "license.txt".
|
|
// If not, please see http://www.research.microsoft.com/msripv6/license.htm,
|
|
// or write to Microsoft Research, One Microsoft Way, Redmond, WA 98052-6399.
|
|
//
|
|
// Abstract:
|
|
//
|
|
// Internet Protocol Version 6 link-level support for some common
|
|
// LAN types: Ethernet, Token Ring, etc.
|
|
//
|
|
|
|
|
|
//
|
|
// This manifest constant causes the NDIS_PROTOCOL_CHARACTERISTICS struct to
|
|
// use the NDIS 5 format if compiled using the NT 5 ddk. If using the NT4 ddk
|
|
// this has no effect.
|
|
//
|
|
#ifndef NDIS50
|
|
#define NDIS50 1
|
|
#endif
|
|
|
|
#include "oscfg.h"
|
|
#include "ndis.h"
|
|
#include "tunuser.h"
|
|
#include "ip6imp.h"
|
|
#include "llip6if.h"
|
|
#include "lan.h"
|
|
#include "ntddip6.h"
|
|
|
|
#ifndef NDIS_API
|
|
#define NDIS_API
|
|
#endif
|
|
|
|
uint NdisVersion; // The major NDIS version we actualy register with.
|
|
|
|
static ulong LanLookahead = LOOKAHEAD_SIZE;
|
|
|
|
#define LAN_TUNNEL_DEFAULT_PREFERENCE 1
|
|
#define NdisMediumTunnel NdisMediumMax
|
|
|
|
static WCHAR LanName[] = TCPIPV6_NAME;
|
|
|
|
NDIS_HANDLE LanHandle; // Our NDIS protocol handle.
|
|
|
|
typedef struct LanRequest {
|
|
NDIS_REQUEST Request;
|
|
KEVENT Event;
|
|
NDIS_STATUS Status;
|
|
} LanRequest;
|
|
|
|
//* DoNDISRequest - Submit a request to an NDIS driver.
|
|
//
|
|
// This is a utility routine to submit a general request to an NDIS
|
|
// driver. The caller specifes the request code (OID), a buffer and
|
|
// a length. This routine allocates a request structure, fills it in,
|
|
// and submits the request.
|
|
//
|
|
NDIS_STATUS
|
|
DoNDISRequest(
|
|
LanInterface *Adapter, // Pointer to the LanInterface adapter strucuture.
|
|
NDIS_REQUEST_TYPE RT, // Type of request to be done (Set or Query).
|
|
NDIS_OID OID, // Value to be set/queried.
|
|
void *Info, // Pointer to the buffer to be passed.
|
|
uint Length, // Length of data in above buffer.
|
|
uint *Needed) // Location to fill in with bytes needed in buffer.
|
|
{
|
|
LanRequest Request;
|
|
NDIS_STATUS Status;
|
|
|
|
// Now fill it in.
|
|
Request.Request.RequestType = RT;
|
|
if (RT == NdisRequestSetInformation) {
|
|
Request.Request.DATA.SET_INFORMATION.Oid = OID;
|
|
Request.Request.DATA.SET_INFORMATION.InformationBuffer = Info;
|
|
Request.Request.DATA.SET_INFORMATION.InformationBufferLength = Length;
|
|
} else {
|
|
Request.Request.DATA.QUERY_INFORMATION.Oid = OID;
|
|
Request.Request.DATA.QUERY_INFORMATION.InformationBuffer = Info;
|
|
Request.Request.DATA.QUERY_INFORMATION.InformationBufferLength = Length;
|
|
}
|
|
|
|
//
|
|
// Note that we can NOT use Adapter->ai_event and ai_status here.
|
|
// There may be multiple concurrent DoNDISRequest calls.
|
|
//
|
|
|
|
// Initialize our event.
|
|
KeInitializeEvent(&Request.Event, SynchronizationEvent, FALSE);
|
|
|
|
if (!Adapter->ai_resetting) {
|
|
// Submit the request.
|
|
NdisRequest(&Status, Adapter->ai_handle, &Request.Request);
|
|
|
|
// Wait for it to finish.
|
|
if (Status == NDIS_STATUS_PENDING) {
|
|
(void) KeWaitForSingleObject(&Request.Event, UserRequest,
|
|
KernelMode, FALSE, NULL);
|
|
Status = Request.Status;
|
|
}
|
|
} else
|
|
Status = NDIS_STATUS_NOT_ACCEPTED;
|
|
|
|
if (Needed != NULL)
|
|
*Needed = Request.Request.DATA.QUERY_INFORMATION.BytesNeeded;
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
//* LanRequestComplete - Lan request complete handler.
|
|
//
|
|
// This routine is called by the NDIS driver when a general request
|
|
// completes. Lan blocks on all requests, so we'll just wake up
|
|
// whoever's blocked on this request.
|
|
//
|
|
void NDIS_API
|
|
LanRequestComplete(
|
|
NDIS_HANDLE Handle, // Binding handle (really our LanInterface).
|
|
PNDIS_REQUEST Context, // Request that completed.
|
|
NDIS_STATUS Status) // Final status of requested command.
|
|
{
|
|
LanRequest *Request = (LanRequest *) Context;
|
|
|
|
//
|
|
// Signal the completion of a generic synchronous request.
|
|
// See DoNDISRequest.
|
|
//
|
|
Request->Status = Status;
|
|
KeSetEvent(&Request->Event, 0, FALSE);
|
|
}
|
|
|
|
|
|
//* LanTransmitComplete - Lan transmit complete handler.
|
|
//
|
|
// This routine is called by the NDIS driver when a send completes.
|
|
// This is a pretty time critical operation, we need to get through here
|
|
// quickly. We just take statistics and call the upper layer send
|
|
// complete handler.
|
|
//
|
|
void NDIS_API
|
|
LanTransmitComplete(
|
|
NDIS_HANDLE Handle, // Binding handle (really LanInterface we sent on).
|
|
PNDIS_PACKET Packet, // Packet that was sent.
|
|
NDIS_STATUS Status) // Final status of send.
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Handle;
|
|
|
|
Interface->ai_qlen--;
|
|
|
|
//
|
|
// Take statistics.
|
|
//
|
|
if (Status == NDIS_STATUS_SUCCESS) {
|
|
UINT TotalLength;
|
|
|
|
NdisQueryPacket(Packet, NULL, NULL, NULL, &TotalLength);
|
|
Interface->ai_outoctets += TotalLength;
|
|
} else {
|
|
if (Status == NDIS_STATUS_RESOURCES)
|
|
Interface->ai_outdiscards++;
|
|
else
|
|
Interface->ai_outerrors++;
|
|
}
|
|
|
|
UndoAdjustPacketBuffer(Packet);
|
|
|
|
IPv6SendComplete(Interface->ai_context, Packet,
|
|
((Status == NDIS_STATUS_SUCCESS) ?
|
|
IP_SUCCESS : IP_GENERAL_FAILURE));
|
|
}
|
|
|
|
|
|
//* LanTransmit - Send a frame.
|
|
//
|
|
// The main Lan transmit routine, called by the upper layer.
|
|
//
|
|
void
|
|
LanTransmit(
|
|
void *Context, // A pointer to the LanInterface.
|
|
PNDIS_PACKET Packet, // Packet to send.
|
|
uint Offset, // Offset from start of packet to IP header.
|
|
const void *LinkAddress) // Link-level address of destination.
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Context;
|
|
void *BufAddr;
|
|
NDIS_STATUS Status;
|
|
|
|
//
|
|
// Loopback (for both unicast & multicast) happens in IPv6SendLL.
|
|
// We never want the link layer to loopback.
|
|
//
|
|
Packet->Private.Flags = NDIS_FLAGS_DONT_LOOPBACK;
|
|
|
|
//
|
|
// Obtain a pointer to space for the link-level header.
|
|
//
|
|
BufAddr = AdjustPacketBuffer(Packet, Offset, Interface->ai_hdrsize);
|
|
|
|
switch (Interface->ai_media) {
|
|
case NdisMedium802_3: {
|
|
EtherHeader *Ether;
|
|
|
|
// This is an Ethernet.
|
|
Ether = (EtherHeader *)BufAddr;
|
|
RtlCopyMemory(Ether->eh_daddr, LinkAddress, IEEE_802_ADDR_LENGTH);
|
|
RtlCopyMemory(Ether->eh_saddr, Interface->ai_addr,
|
|
IEEE_802_ADDR_LENGTH);
|
|
Ether->eh_type = net_short(ETYPE_IPv6);
|
|
|
|
#if 0
|
|
//
|
|
// See if we're using SNAP here.
|
|
//
|
|
if (Interface->ai_hdrsize != sizeof(EtherHeader)) {
|
|
...
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
case NdisMediumFddi: {
|
|
FDDIHeader *FDDI;
|
|
SNAPHeader *SNAP;
|
|
|
|
// This is a FDDI link.
|
|
FDDI = (FDDIHeader *)BufAddr;
|
|
FDDI->fh_pri = FDDI_PRI; // Default frame code.
|
|
RtlCopyMemory(FDDI->fh_daddr, LinkAddress, IEEE_802_ADDR_LENGTH);
|
|
RtlCopyMemory(FDDI->fh_saddr, Interface->ai_addr,
|
|
IEEE_802_ADDR_LENGTH);
|
|
|
|
// FDDI always uses SNAP.
|
|
SNAP = (SNAPHeader *)(FDDI + 1);
|
|
SNAP->sh_dsap = SNAP_SAP;
|
|
SNAP->sh_ssap = SNAP_SAP;
|
|
SNAP->sh_ctl = SNAP_UI;
|
|
SNAP->sh_protid[0] = 0;
|
|
SNAP->sh_protid[1] = 0;
|
|
SNAP->sh_protid[2] = 0;
|
|
SNAP->sh_etype = net_short(ETYPE_IPv6);
|
|
|
|
break;
|
|
}
|
|
|
|
case NdisMediumTunnel: {
|
|
|
|
//
|
|
// There is no header to construct!
|
|
//
|
|
break;
|
|
}
|
|
|
|
default:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INTERNAL_ERROR,
|
|
"LanTransmit: Unknown media type\n"));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Send the packet down to NDIS.
|
|
//
|
|
|
|
(Interface->ai_outpcount[AI_UCAST_INDEX])++;
|
|
Interface->ai_qlen++;
|
|
|
|
if (!Interface->ai_resetting) {
|
|
NdisSend(&Status, Interface->ai_handle, Packet);
|
|
} else
|
|
Status = NDIS_STATUS_NOT_ACCEPTED;
|
|
|
|
if (Status != NDIS_STATUS_PENDING) {
|
|
//
|
|
// The send finished synchronously.
|
|
// Call LanTransmitComplete, unifying our treatment
|
|
// of the synchronous and asynchronous cases.
|
|
//
|
|
LanTransmitComplete((NDIS_HANDLE)Interface, Packet, Status);
|
|
}
|
|
}
|
|
|
|
|
|
//* LanOpenAdapterComplete - LanOpen completion handler.
|
|
//
|
|
// This routine is called by the NDIS driver when an open adapter
|
|
// call completes. Wakeup anyone who is waiting for this event.
|
|
//
|
|
void NDIS_API
|
|
LanOpenAdapterComplete(
|
|
NDIS_HANDLE Handle, // Binding handle (really our LanInterface).
|
|
NDIS_STATUS Status, // Final status of command.
|
|
NDIS_STATUS ErrorStatus) // Final error status.
|
|
{
|
|
LanInterface *ai = (LanInterface *)Handle;
|
|
|
|
UNREFERENCED_PARAMETER(ErrorStatus);
|
|
|
|
//
|
|
// Signal whoever is waiting and pass the final status.
|
|
//
|
|
ai->ai_status = Status;
|
|
KeSetEvent(&ai->ai_event, 0, FALSE);
|
|
}
|
|
|
|
|
|
//* LanCloseAdapterComplete - Lan close adapter complete handler.
|
|
//
|
|
// This routine is called by the NDIS driver when a close adapter
|
|
// call completes.
|
|
//
|
|
// At this point, NDIS guarantees that it has no other outstanding
|
|
// calls to us.
|
|
//
|
|
void NDIS_API
|
|
LanCloseAdapterComplete(
|
|
NDIS_HANDLE Handle, // Binding handle (really our LanInterface).
|
|
NDIS_STATUS Status) // Final status of command.
|
|
{
|
|
LanInterface *ai = (LanInterface *)Handle;
|
|
|
|
//
|
|
// Signal whoever is waiting and pass the final status.
|
|
//
|
|
ai->ai_status = Status;
|
|
KeSetEvent(&ai->ai_event, 0, FALSE);
|
|
}
|
|
|
|
|
|
//* LanTDComplete - Lan transfer data complete handler.
|
|
//
|
|
// This routine is called by the NDIS driver when a transfer data
|
|
// call completes. Hopefully we now have a complete packet we can
|
|
// pass up to IP. Recycle our TD packet descriptor in any event.
|
|
//
|
|
void NDIS_API
|
|
LanTDComplete(
|
|
NDIS_HANDLE Handle, // Binding handle (really our LanInterface).
|
|
PNDIS_PACKET Packet, // The packet used for the Transfer Data (TD).
|
|
NDIS_STATUS Status, // Final status of command.
|
|
uint BytesCopied) // Number of bytes copied.
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Handle;
|
|
|
|
//
|
|
// If things went well, pass TD packet up to IP.
|
|
//
|
|
if (Status == NDIS_STATUS_SUCCESS) {
|
|
PNDIS_BUFFER Buffer;
|
|
IPv6Packet IPPacket;
|
|
|
|
RtlZeroMemory(&IPPacket, sizeof IPPacket);
|
|
|
|
NdisGetFirstBufferFromPacket(Packet, &Buffer, &IPPacket.FlatData,
|
|
&IPPacket.ContigSize,
|
|
&IPPacket.TotalSize);
|
|
ASSERT(IPPacket.ContigSize == IPPacket.TotalSize);
|
|
IPPacket.Data = IPPacket.FlatData;
|
|
|
|
if (PC(Packet)->pc_nucast)
|
|
IPPacket.Flags |= PACKET_NOT_LINK_UNICAST;
|
|
|
|
IPPacket.NTEorIF = Interface->ai_context;
|
|
(void) IPv6Receive(&IPPacket);
|
|
}
|
|
|
|
//
|
|
// In any case, put the packet back on the list.
|
|
//
|
|
KeAcquireSpinLockAtDpcLevel(&Interface->ai_lock);
|
|
PC(Packet)->pc_link = Interface->ai_tdpacket;
|
|
Interface->ai_tdpacket = Packet;
|
|
KeReleaseSpinLockFromDpcLevel(&Interface->ai_lock);
|
|
}
|
|
|
|
|
|
//* LanResetComplete - Lan reset complete handler.
|
|
//
|
|
// This routine is called by the NDIS driver when a reset completes.
|
|
//
|
|
void NDIS_API
|
|
LanResetComplete(
|
|
NDIS_HANDLE Handle, // Binding handle (really LanInterface which reset)
|
|
NDIS_STATUS Status) // Final status of command.
|
|
{
|
|
UNREFERENCED_PARAMETER(Handle);
|
|
UNREFERENCED_PARAMETER(Status);
|
|
|
|
// REVIEW: Do anything here? Axe this routine?
|
|
}
|
|
|
|
|
|
//* LanReceive - Lan receive data handler.
|
|
//
|
|
// This routine is called when data arrives from the NDIS driver.
|
|
// Note that newer NDIS drivers are likely to call LanReceivePacket to
|
|
// indicate data arrival instead of this routine.
|
|
//
|
|
NDIS_STATUS // Indication of whether or not we took the packet.
|
|
NDIS_API
|
|
LanReceive(
|
|
NDIS_HANDLE Handle, // The binding handle we gave NDIS earlier.
|
|
NDIS_HANDLE Context, // NDIS Context for TransferData operations.
|
|
void *Header, // Pointer to packet link-level header.
|
|
uint HeaderSize, // Size of above header (in bytes).
|
|
void *Data, // Pointer to look-ahead received data buffer.
|
|
uint Size, // Size of above data (in bytes).
|
|
uint TotalSize) // Total received data size (in bytes).
|
|
{
|
|
LanInterface *Interface = Handle; // Interface for this driver.
|
|
ushort Type; // Protocol type.
|
|
uint ProtOffset; // Offset in Data to non-media info.
|
|
uint NUCast; // TRUE if the frame is not unicast.
|
|
IPv6Packet IPPacket;
|
|
|
|
if (Interface->ai_state != INTERFACE_UP) {
|
|
//
|
|
// Interface is marked as down.
|
|
//
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_RARE,
|
|
"IPv6 LanReceive: Interface down\n"));
|
|
return NDIS_STATUS_NOT_RECOGNIZED;
|
|
}
|
|
|
|
Interface->ai_inoctets += TotalSize;
|
|
|
|
switch (Interface->ai_media) {
|
|
|
|
case NdisMedium802_3: {
|
|
EtherHeader UNALIGNED *Ether = (EtherHeader UNALIGNED *)Header;
|
|
|
|
if (HeaderSize < sizeof(*Ether)) {
|
|
//
|
|
// Header region too small to contain Ethernet header.
|
|
//
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_BAD_PACKET,
|
|
"IPv6 LanReceive: Bogus header size (%d bytes)\n",
|
|
HeaderSize));
|
|
return NDIS_STATUS_NOT_RECOGNIZED;
|
|
}
|
|
if ((Type = net_short(Ether->eh_type)) >= ETYPE_MIN) {
|
|
//
|
|
// Classic Ethernet, no SNAP header.
|
|
//
|
|
ProtOffset = 0;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// 802.3 Ethernet w/ SNAP header. Protocol type is in
|
|
// different spot. This is handled the same as FDDI, so
|
|
// just fall into that code...
|
|
//
|
|
}
|
|
|
|
case NdisMediumFddi: {
|
|
SNAPHeader UNALIGNED *SNAP = (SNAPHeader UNALIGNED *)Data;
|
|
|
|
//
|
|
// If we have a SNAP header that's all we need to look at.
|
|
//
|
|
if (Size >= sizeof(SNAPHeader) && SNAP->sh_dsap == SNAP_SAP &&
|
|
SNAP->sh_ssap == SNAP_SAP && SNAP->sh_ctl == SNAP_UI) {
|
|
|
|
Type = net_short(SNAP->sh_etype);
|
|
ProtOffset = sizeof(SNAPHeader);
|
|
} else {
|
|
// handle XID/TEST here.
|
|
Interface->ai_uknprotos++;
|
|
return NDIS_STATUS_NOT_RECOGNIZED;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case NdisMediumTunnel: {
|
|
//
|
|
// We accept everything over the tunnel.
|
|
//
|
|
Type = ETYPE_IPv6;
|
|
ProtOffset = 0;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// Should never happen.
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INTERNAL_ERROR,
|
|
"IPv6 LanReceive: Got a packet from an unknown media!?!\n"));
|
|
return NDIS_STATUS_NOT_RECOGNIZED;
|
|
}
|
|
|
|
//
|
|
// See if the packet is for a protocol we handle.
|
|
//
|
|
if (Type != ETYPE_IPv6) {
|
|
Interface->ai_uknprotos++;
|
|
return NDIS_STATUS_NOT_RECOGNIZED;
|
|
}
|
|
|
|
//
|
|
// Notice if this packet wasn't received in a unicast frame.
|
|
// REVIEW: Is this really a media independent solution? Do we care?
|
|
//
|
|
NUCast = ((*((uchar UNALIGNED *)Header + Interface->ai_bcastoff) &
|
|
Interface->ai_bcastmask) == Interface->ai_bcastval) ?
|
|
AI_NONUCAST_INDEX : AI_UCAST_INDEX;
|
|
|
|
(Interface->ai_inpcount[NUCast])++;
|
|
|
|
//
|
|
// Check to see if we have the entire packet.
|
|
//
|
|
if (Size < TotalSize) {
|
|
uint Transferred;
|
|
NDIS_STATUS Status;
|
|
PNDIS_PACKET TdPacket; // Packet used by NdisTransferData.
|
|
|
|
//
|
|
// We need to issue a Transfer Data request to get the
|
|
// portion of the packet we're missing, so we might as well
|
|
// get the whole packet this way and have it be contiguous.
|
|
//
|
|
|
|
//
|
|
// Pull a packet to use for the Transfer Data off the queue.
|
|
//
|
|
KeAcquireSpinLockAtDpcLevel(&Interface->ai_lock);
|
|
TdPacket = Interface->ai_tdpacket;
|
|
if (TdPacket == (PNDIS_PACKET)NULL) {
|
|
// Don't have a packet to put it in.
|
|
// Have to drop it, but let NDIS know we recognized it.
|
|
KeReleaseSpinLockFromDpcLevel(&Interface->ai_lock);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
Interface->ai_tdpacket = PC(TdPacket)->pc_link;
|
|
KeReleaseSpinLockFromDpcLevel(&Interface->ai_lock);
|
|
|
|
//
|
|
// Remember NUCast in a handy field in the packet context.
|
|
//
|
|
PC(TdPacket)->pc_nucast = NUCast;
|
|
|
|
//
|
|
// Issue the TD. Start transfer at the IP header.
|
|
//
|
|
NdisTransferData(&Status, Interface->ai_handle, Context,
|
|
ProtOffset, TotalSize - ProtOffset,
|
|
TdPacket, &Transferred);
|
|
|
|
if (Status != NDIS_STATUS_PENDING) {
|
|
//
|
|
// TD completed synchronously,
|
|
// so call the completion function directly.
|
|
//
|
|
LanTDComplete(Handle, TdPacket, Status, Transferred);
|
|
}
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// We were given all the data directly. Just need to skip
|
|
// over any link level headers.
|
|
//
|
|
(uchar *)Data += ProtOffset;
|
|
ASSERT(Size == TotalSize);
|
|
TotalSize -= ProtOffset;
|
|
|
|
//
|
|
// Pass incoming data up to IPv6.
|
|
//
|
|
RtlZeroMemory(&IPPacket, sizeof IPPacket);
|
|
|
|
IPPacket.FlatData = Data;
|
|
IPPacket.Data = Data;
|
|
IPPacket.ContigSize = TotalSize;
|
|
IPPacket.TotalSize = TotalSize;
|
|
|
|
if (NUCast)
|
|
IPPacket.Flags |= PACKET_NOT_LINK_UNICAST;
|
|
|
|
IPPacket.NTEorIF = Interface->ai_context;
|
|
(void) IPv6Receive(&IPPacket);
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
//* LanReceiveComplete - Lan receive complete handler.
|
|
//
|
|
// This routine is called by the NDIS driver after some number of
|
|
// receives. In some sense, it indicates 'idle time'.
|
|
//
|
|
void NDIS_API
|
|
LanReceiveComplete(
|
|
NDIS_HANDLE Handle) // Binding handle (really our LanInterface).
|
|
{
|
|
UNREFERENCED_PARAMETER(Handle);
|
|
|
|
IPv6ReceiveComplete();
|
|
}
|
|
|
|
|
|
//* LanReceivePacket - Lan receive data handler.
|
|
//
|
|
// This routine is called when data arrives from the NDIS driver.
|
|
// Note that older NDIS drivers are likely to call LanReceive to
|
|
// indicate data arrival instead of this routine.
|
|
//
|
|
int // Returns: number of references we hold to Packet upon return.
|
|
LanReceivePacket(
|
|
NDIS_HANDLE Handle, // The binding handle we gave NDIS earlier.
|
|
PNDIS_PACKET Packet) // Packet descriptor for incoming packet.
|
|
{
|
|
LanInterface *Interface = Handle; // Interface for this driver.
|
|
PNDIS_BUFFER Buffer; // Buffer in packet chain.
|
|
void *Address; // Address of above Buffer.
|
|
uint Length, TotalLength; // Length of Buffer, Packet.
|
|
EtherHeader UNALIGNED *Ether; // Header for Ethernet media.
|
|
ushort Type; // Protocol type.
|
|
uint Position; // Offset to non-media info.
|
|
uint NUCast; // TRUE if the frame is not unicast.
|
|
IPv6Packet IPPacket;
|
|
|
|
if (Interface->ai_state != INTERFACE_UP) {
|
|
// Interface is marked as down.
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Find out about the packet we've been handed.
|
|
//
|
|
NdisGetFirstBufferFromPacket(Packet, &Buffer, &Address, &Length,
|
|
&TotalLength);
|
|
|
|
Interface->ai_inoctets += TotalLength; // Take statistic.
|
|
|
|
//
|
|
// Check for obviously bogus packets.
|
|
//
|
|
if (TotalLength < (uint)Interface->ai_hdrsize) {
|
|
//
|
|
// Packet too small to hold media header, drop it.
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
if (Length < (uint)Interface->ai_hdrsize) {
|
|
//
|
|
// First buffer in chain too small to hold header.
|
|
// This shouldn't happen because of LanLookahead.
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Figure out what protocol type this packet is by looking in the
|
|
// media-specific header field for this type of media.
|
|
//
|
|
switch (Interface->ai_media) {
|
|
|
|
case NdisMedium802_3: {
|
|
Ether = (EtherHeader UNALIGNED *)Address;
|
|
|
|
if ((Type = net_short(Ether->eh_type)) >= ETYPE_MIN) {
|
|
//
|
|
// Classic Ethernet, no SNAP header.
|
|
//
|
|
Position = sizeof(EtherHeader);
|
|
} else {
|
|
//
|
|
// 802.3 Ethernet w/ SNAP header. Protocol type is in
|
|
// different spot and we have to remember to skip over it.
|
|
// The great thing about standards is that there are so
|
|
// many to choose from.
|
|
//
|
|
SNAPHeader UNALIGNED *SNAP = (SNAPHeader UNALIGNED *)
|
|
((char *)Address + sizeof(EtherHeader));
|
|
|
|
if (Length >= (sizeof(EtherHeader) + sizeof(SNAPHeader))
|
|
&& SNAP->sh_dsap == SNAP_SAP && SNAP->sh_ssap == SNAP_SAP
|
|
&& SNAP->sh_ctl == SNAP_UI) {
|
|
|
|
Type = net_short(SNAP->sh_etype);
|
|
Position = sizeof(EtherHeader) + sizeof(SNAPHeader);
|
|
} else {
|
|
// handle XID/TEST here.
|
|
Interface->ai_uknprotos++;
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case NdisMediumFddi: {
|
|
SNAPHeader UNALIGNED *SNAP = (SNAPHeader UNALIGNED *)
|
|
((char *)Address + sizeof(FDDIHeader));
|
|
|
|
if (Length >= (sizeof(FDDIHeader) + sizeof(SNAPHeader))
|
|
&& SNAP->sh_dsap == SNAP_SAP && SNAP->sh_ssap == SNAP_SAP
|
|
&& SNAP->sh_ctl == SNAP_UI) {
|
|
|
|
Type = net_short(SNAP->sh_etype);
|
|
Position = sizeof(FDDIHeader) + sizeof(SNAPHeader);
|
|
} else {
|
|
// handle XID/TEST here.
|
|
Interface->ai_uknprotos++;
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case NdisMediumTunnel: {
|
|
//
|
|
// We accept everything over the tunnel.
|
|
//
|
|
Type = ETYPE_IPv6;
|
|
Position = 0;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// Should never happen.
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INTERNAL_ERROR,
|
|
"IPv6: Got a packet from an unknown media!?!\n"));
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Notice if this packet wasn't received in a unicast frame.
|
|
// REVIEW: Is this really a media independent solution?
|
|
//
|
|
NUCast = ((*((uchar UNALIGNED *)Address + Interface->ai_bcastoff) &
|
|
Interface->ai_bcastmask) == Interface->ai_bcastval) ?
|
|
AI_NONUCAST_INDEX : AI_UCAST_INDEX;
|
|
|
|
//
|
|
// See if the packet is for a protocol we handle.
|
|
//
|
|
if (Type == ETYPE_IPv6) {
|
|
|
|
(Interface->ai_inpcount[NUCast])++;
|
|
|
|
//
|
|
// Skip over any link level headers.
|
|
//
|
|
(uchar *)Address += Position;
|
|
Length -= Position;
|
|
TotalLength -= Position;
|
|
|
|
//
|
|
// Pass incoming data up to IPv6.
|
|
//
|
|
RtlZeroMemory(&IPPacket, sizeof IPPacket);
|
|
|
|
IPPacket.Position = Position;
|
|
IPPacket.Data = Address;
|
|
IPPacket.ContigSize = Length;
|
|
IPPacket.TotalSize = TotalLength;
|
|
IPPacket.NdisPacket = Packet;
|
|
|
|
if (NUCast)
|
|
IPPacket.Flags |= PACKET_NOT_LINK_UNICAST;
|
|
|
|
IPPacket.NTEorIF = Interface->ai_context;
|
|
return IPv6Receive(&IPPacket);
|
|
|
|
} else {
|
|
//
|
|
// Not a protocol we handle.
|
|
//
|
|
Interface->ai_uknprotos++;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
//* LanStatus - Lan status handler.
|
|
//
|
|
// Called by the NDIS driver when some sort of status change occurs.
|
|
// We take action depending on the type of status.
|
|
//
|
|
// Entry:
|
|
// Handle - The binding handle we specified (really a pointer to an AI).
|
|
// GStatus - General type of status that caused the call.
|
|
// Status - Pointer to a buffer of status specific information.
|
|
// StatusSize - Size of the status buffer.
|
|
//
|
|
// Exit: Nothing.
|
|
//
|
|
void NDIS_API
|
|
LanStatus(
|
|
NDIS_HANDLE Handle, // Binding handle (really our LanInterface).
|
|
NDIS_STATUS GStatus, // General status type which caused the call.
|
|
void *Status, // Pointer to buffer of status specific info.
|
|
uint StatusSize) // Size of the above status buffer.
|
|
{
|
|
LanInterface *Interface = Handle; // Interface for this driver.
|
|
void *Context = Interface->ai_context;
|
|
uint Index;
|
|
|
|
switch (GStatus) {
|
|
case NDIS_STATUS_RESET_START:
|
|
//
|
|
// While the interface is resetting, we must avoid calling
|
|
// NdisSendPackets, NdisSend, and NdisRequest.
|
|
//
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanStatus(%p) - start reset\n", Interface));
|
|
Interface->ai_resetting = TRUE;
|
|
break;
|
|
case NDIS_STATUS_RESET_END:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanStatus(%p) - end reset\n", Interface));
|
|
Interface->ai_resetting = FALSE;
|
|
break;
|
|
case NDIS_STATUS_MEDIA_CONNECT:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanStatus(%p/%p) - media connect\n",
|
|
Interface, Context));
|
|
if (Interface->ai_state == INTERFACE_UP)
|
|
SetInterfaceLinkStatus(Context, TRUE);
|
|
break;
|
|
case NDIS_STATUS_MEDIA_DISCONNECT:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanStatus(%p/%p) - media disconnect\n",
|
|
Interface, Context));
|
|
if (Interface->ai_state == INTERFACE_UP)
|
|
SetInterfaceLinkStatus(Context, FALSE);
|
|
break;
|
|
default:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"IPv6: LanStatus(%p) - status %x\n",
|
|
Interface, GStatus));
|
|
for (Index = 0; Index < StatusSize/4; Index++)
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
" status %08x\n", ((uint *)Status)[Index]));
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//* LanStatusComplete - Lan status complete handler.
|
|
//
|
|
// A routine called by the NDIS driver so that we can do postprocessing
|
|
// after a status event.
|
|
//
|
|
void NDIS_API
|
|
LanStatusComplete(
|
|
NDIS_HANDLE Handle) // Binding handle (really our LanInterface).
|
|
{
|
|
UNREFERENCED_PARAMETER(Handle);
|
|
|
|
// REVIEW: Do anything here?
|
|
}
|
|
|
|
extern void NDIS_API
|
|
LanBindAdapter(PNDIS_STATUS RetStatus, NDIS_HANDLE BindContext,
|
|
PNDIS_STRING AdapterName, PVOID SS1, PVOID SS2);
|
|
|
|
extern void NDIS_API
|
|
LanUnbindAdapter(PNDIS_STATUS RetStatus, NDIS_HANDLE ProtBindContext,
|
|
NDIS_HANDLE UnbindContext);
|
|
|
|
extern NDIS_STATUS NDIS_API
|
|
LanPnPEvent(NDIS_HANDLE ProtocolBindingContext,
|
|
PNET_PNP_EVENT NetPnPEvent);
|
|
|
|
//
|
|
// Structure passed to NDIS to tell it how to call Lan Interfaces.
|
|
//
|
|
// This is carefully arranged so that it can build
|
|
// with either the NT 4 or NT 5 DDK, and then in either case
|
|
// run on NT 4 (registering with NDIS 4) and
|
|
// run on NT 5 (registering with NDIS 5).
|
|
//
|
|
NDIS50_PROTOCOL_CHARACTERISTICS LanCharacteristics = {
|
|
0, // NdisMajorVersion
|
|
0, // NdisMinorVersion
|
|
// This field was added in NT 5. (Previously it was just a hole.)
|
|
#ifdef NDIS_FLAGS_DONT_LOOPBACK
|
|
0, // Filler
|
|
#endif
|
|
0, // Flags
|
|
LanOpenAdapterComplete,
|
|
LanCloseAdapterComplete,
|
|
LanTransmitComplete,
|
|
LanTDComplete,
|
|
LanResetComplete,
|
|
LanRequestComplete,
|
|
LanReceive,
|
|
LanReceiveComplete,
|
|
LanStatus,
|
|
LanStatusComplete,
|
|
{ 0, 0, 0 }, // Name
|
|
LanReceivePacket,
|
|
LanBindAdapter,
|
|
LanUnbindAdapter,
|
|
// The type of this field changed between NT 4 and NT 5.
|
|
#ifdef NDIS_FLAGS_DONT_LOOPBACK
|
|
LanPnPEvent,
|
|
#else
|
|
(TRANSLATE_HANDLER) LanPnPEvent,
|
|
#endif
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
|
|
|
|
#pragma BEGIN_INIT
|
|
//* LanInit
|
|
//
|
|
// This functions intializes the Lan module.
|
|
// In particular, it registers with NDIS.
|
|
//
|
|
// Returns FALSE to indicate failure to initialize.
|
|
//
|
|
int
|
|
LanInit(void)
|
|
{
|
|
NDIS_STATUS Status;
|
|
|
|
RtlInitUnicodeString(&LanCharacteristics.Name, LanName);
|
|
|
|
//
|
|
// We try to register with NDIS major version = 5. If this fails we try
|
|
// again for NDIS major version = 4. If this also fails we exit without
|
|
// any further attempts to register with NDIS.
|
|
//
|
|
LanCharacteristics.MajorNdisVersion = 5;
|
|
NdisRegisterProtocol(&Status, &LanHandle,
|
|
(NDIS_PROTOCOL_CHARACTERISTICS *) &LanCharacteristics,
|
|
sizeof(NDIS50_PROTOCOL_CHARACTERISTICS));
|
|
if (Status != NDIS_STATUS_SUCCESS) {
|
|
LanCharacteristics.MajorNdisVersion = 4;
|
|
//
|
|
// NDIS 4 has a different semantics - it has TranslateHandler
|
|
// instead of PnPEventHandler. So do not supply that handler.
|
|
//
|
|
#ifdef NDIS_FLAGS_DONT_LOOPBACK
|
|
LanCharacteristics.PnPEventHandler = NULL;
|
|
#else
|
|
LanCharacteristics.TranslateHandler = NULL;
|
|
#endif
|
|
NdisRegisterProtocol(&Status, &LanHandle,
|
|
(NDIS_PROTOCOL_CHARACTERISTICS *) &LanCharacteristics,
|
|
sizeof(NDIS40_PROTOCOL_CHARACTERISTICS));
|
|
if (Status != NDIS_STATUS_SUCCESS) {
|
|
//
|
|
// Can't register at all. Just bail out...
|
|
//
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
|
"LanInit: could not register -> %x\n", Status));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We've registered OK using NDIS.
|
|
//
|
|
NdisVersion = LanCharacteristics.MajorNdisVersion;
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanInit: registered with NDIS %u.\n", NdisVersion));
|
|
return TRUE;
|
|
}
|
|
#pragma END_INIT
|
|
|
|
|
|
//* LanUnload
|
|
//
|
|
// Called when then IPv6 stack is unloading.
|
|
// We need to disconnect from NDIS.
|
|
//
|
|
void
|
|
LanUnload(void)
|
|
{
|
|
NDIS_STATUS Status;
|
|
|
|
//
|
|
// At this point, the adapters should already all be closed
|
|
// because IPUnload is called first and does that.
|
|
//
|
|
|
|
NdisDeregisterProtocol(&Status, LanHandle);
|
|
}
|
|
|
|
|
|
//* LanFreeInterface - Free a Lan interface
|
|
//
|
|
// Called in the event of some sort of initialization failure. We free all
|
|
// the memory associated with an Lan interface.
|
|
//
|
|
void
|
|
LanFreeInterface(
|
|
LanInterface *Interface) // Interface structure to be freed.
|
|
{
|
|
NDIS_STATUS Status;
|
|
KIRQL OldIrql;
|
|
|
|
//
|
|
// If we're bound to the adapter, close it now.
|
|
//
|
|
if (Interface->ai_handle != NULL) {
|
|
KeInitializeEvent(&Interface->ai_event, SynchronizationEvent, FALSE);
|
|
|
|
NdisCloseAdapter(&Status, Interface->ai_handle);
|
|
|
|
if (Status == NDIS_STATUS_PENDING) {
|
|
(void) KeWaitForSingleObject(&Interface->ai_event, UserRequest,
|
|
KernelMode, FALSE, NULL);
|
|
Status = Interface->ai_status;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Free the Transfer Data Packet, if any, for this interface.
|
|
//
|
|
if (Interface->ai_tdpacket != NULL)
|
|
IPv6FreePacket(Interface->ai_tdpacket);
|
|
|
|
//
|
|
// Free the interface structure itself.
|
|
//
|
|
ExFreePool(Interface);
|
|
}
|
|
|
|
|
|
//* LanAllocateTDPacket
|
|
//
|
|
// Allocate a packet for NdisTransferData.
|
|
// We always allocate contiguous space for a full MTU of data.
|
|
//
|
|
PNDIS_PACKET
|
|
LanAllocateTDPacket(
|
|
LanInterface *Interface) // Interface for which to allocate TD packet.
|
|
{
|
|
PNDIS_PACKET Packet;
|
|
void *Mem;
|
|
NDIS_STATUS Status;
|
|
|
|
Status = IPv6AllocatePacket(Interface->ai_mtu, &Packet, &Mem);
|
|
if (Status != NDIS_STATUS_SUCCESS)
|
|
return NULL;
|
|
|
|
return Packet;
|
|
}
|
|
|
|
extern uint UseEtherSNAP(PNDIS_STRING Name);
|
|
|
|
|
|
//* LanRegister - Register a protocol with the Lan module.
|
|
//
|
|
// We register an adapter for Lan processing and create a LanInterface
|
|
// structure to represent it. We also open the NDIS adapter here.
|
|
//
|
|
// REVIEW: Should we set the packet filter to NOT accept broadcast packets?
|
|
// REVIEW: Broadcast isn't used in IPv6. Junk bcast* stuff as well? Switch
|
|
// REVIEW: this to keeping track of multicasts?
|
|
//
|
|
int
|
|
LanRegister(
|
|
PNDIS_STRING Adapter, // Name of the adapter to bind to.
|
|
struct LanInterface **Interface) // Where to return new interace.
|
|
{
|
|
LanInterface *ai; // Pointer to interface struct for this interface.
|
|
NDIS_STATUS Status, OpenStatus; // Status values.
|
|
uint i = 0; // Medium index.
|
|
NDIS_MEDIUM MediaArray[2];
|
|
uchar *buffer; // Pointer to our buffers.
|
|
uint instance;
|
|
uint mss;
|
|
uint speed;
|
|
uint Needed;
|
|
uchar bcastmask, bcastval, bcastoff, addrlen, hdrsize;
|
|
NDIS_OID OID;
|
|
uint PF;
|
|
PNDIS_BUFFER Buffer;
|
|
|
|
//
|
|
// Allocate memory to hold new interface.
|
|
//
|
|
ai = (LanInterface *) ExAllocatePool(NonPagedPool, sizeof(LanInterface));
|
|
if (ai == NULL)
|
|
return FALSE; // Couldn't allocate memory for this one.
|
|
RtlZeroMemory(ai, sizeof(LanInterface));
|
|
|
|
//
|
|
// In actual practice, we've only tested Ethernet and FDDI.
|
|
// So disallow other media for now.
|
|
//
|
|
MediaArray[0] = NdisMedium802_3;
|
|
MediaArray[1] = NdisMediumFddi;
|
|
#if 0
|
|
MediaArray[2] = NdisMedium802_5;
|
|
#endif
|
|
|
|
// Initialize this adapter interface structure.
|
|
ai->ai_state = INTERFACE_INIT;
|
|
|
|
// Initialize the locks.
|
|
KeInitializeSpinLock(&ai->ai_lock);
|
|
|
|
KeInitializeEvent(&ai->ai_event, SynchronizationEvent, FALSE);
|
|
|
|
// Open the NDIS adapter.
|
|
NdisOpenAdapter(&Status, &OpenStatus, &ai->ai_handle,
|
|
&i, MediaArray, 2,
|
|
LanHandle, ai, Adapter, 0, NULL);
|
|
|
|
// Block for open to complete.
|
|
if (Status == NDIS_STATUS_PENDING) {
|
|
(void) KeWaitForSingleObject(&ai->ai_event, UserRequest, KernelMode,
|
|
FALSE, NULL);
|
|
Status = ai->ai_status;
|
|
}
|
|
|
|
ai->ai_media = MediaArray[i]; // Fill in media type.
|
|
|
|
//
|
|
// Open adapter completed. If it succeeded, we'll finish our
|
|
// intialization. If it failed, bail out now.
|
|
//
|
|
if (Status != NDIS_STATUS_SUCCESS) {
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
|
"LanRegister: Adapter failed to initialize."
|
|
" Status = 0x%x\n", Status));
|
|
ai->ai_handle = NULL;
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
//
|
|
// Read the maximum frame size.
|
|
//
|
|
Status = DoNDISRequest(ai, NdisRequestQueryInformation,
|
|
OID_GEN_MAXIMUM_FRAME_SIZE, &mss,
|
|
sizeof(mss), NULL);
|
|
|
|
if (Status != NDIS_STATUS_SUCCESS) {
|
|
//
|
|
// Failed to get maximum frame size. Bail.
|
|
//
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
|
"LanRegister: Failed to get maximum frame size. "
|
|
"Status = 0x%x\n", Status));
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
//
|
|
// Read the local link-level address from the adapter.
|
|
//
|
|
switch (ai->ai_media) {
|
|
case NdisMedium802_3:
|
|
addrlen = IEEE_802_ADDR_LENGTH;
|
|
bcastmask = ETHER_BCAST_MASK;
|
|
bcastval = ETHER_BCAST_VAL;
|
|
bcastoff = ETHER_BCAST_OFF;
|
|
OID = OID_802_3_CURRENT_ADDRESS;
|
|
hdrsize = sizeof(EtherHeader);
|
|
if (UseEtherSNAP(Adapter)) {
|
|
hdrsize += sizeof(SNAPHeader);
|
|
}
|
|
|
|
PF = NDIS_PACKET_TYPE_BROADCAST | NDIS_PACKET_TYPE_DIRECTED |
|
|
NDIS_PACKET_TYPE_MULTICAST;
|
|
break;
|
|
|
|
case NdisMedium802_5:
|
|
addrlen = IEEE_802_ADDR_LENGTH;
|
|
bcastmask = TR_BCAST_MASK;
|
|
bcastval = TR_BCAST_VAL;
|
|
bcastoff = TR_BCAST_OFF;
|
|
OID = OID_802_5_CURRENT_ADDRESS;
|
|
hdrsize = sizeof(TRHeader) + sizeof(SNAPHeader);
|
|
PF = NDIS_PACKET_TYPE_BROADCAST | NDIS_PACKET_TYPE_DIRECTED;
|
|
|
|
//
|
|
// Figure out the RC len stuff now.
|
|
//
|
|
mss -= (sizeof(RC) + (MAX_RD * sizeof(ushort)));
|
|
break;
|
|
|
|
case NdisMediumFddi:
|
|
addrlen = IEEE_802_ADDR_LENGTH;
|
|
bcastmask = FDDI_BCAST_MASK;
|
|
bcastval = FDDI_BCAST_VAL;
|
|
bcastoff = FDDI_BCAST_OFF;
|
|
OID = OID_FDDI_LONG_CURRENT_ADDR;
|
|
hdrsize = sizeof(FDDIHeader) + sizeof(SNAPHeader);
|
|
PF = NDIS_PACKET_TYPE_BROADCAST | NDIS_PACKET_TYPE_DIRECTED |
|
|
NDIS_PACKET_TYPE_MULTICAST;
|
|
mss = MIN(mss, FDDI_MSS);
|
|
break;
|
|
|
|
default:
|
|
ASSERT(!"bad medium from Ndis");
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
//
|
|
// NDIS exposes the tunnel interface as 802_3, but ensures that it's the
|
|
// only interface for which OID_CUSTOM_TUNMP_INSTANCE_ID returns success.
|
|
//
|
|
if (DoNDISRequest(ai, NdisRequestQueryInformation,
|
|
OID_CUSTOM_TUNMP_INSTANCE_ID, &instance,
|
|
sizeof(instance), NULL) == NDIS_STATUS_SUCCESS) {
|
|
ai->ai_media = NdisMediumTunnel;
|
|
|
|
//
|
|
// These values are chosen so NUCast returns FALSE.
|
|
//
|
|
bcastmask = 0;
|
|
bcastval = 1;
|
|
bcastoff = 0;
|
|
|
|
hdrsize = 0;
|
|
|
|
//
|
|
// Since we do not construct an ethernet header on transmission, or
|
|
// expect one on receive, we need to ensure that NDIS does not attempt
|
|
// to parse frames on this interface. On transmission this is achieved
|
|
// by setting the NDIS_FLAGS_DONT_LOOPBACK flag. Receives are made
|
|
// NDIS-Safe by setting the interface in promiscuous mode.
|
|
//
|
|
PF |= NDIS_PACKET_TYPE_PROMISCUOUS;
|
|
|
|
//
|
|
// This is what NDIS should have provided us.
|
|
//
|
|
mss = IPv6_MINIMUM_MTU;
|
|
}
|
|
|
|
ai->ai_bcastmask = bcastmask;
|
|
ai->ai_bcastval = bcastval;
|
|
ai->ai_bcastoff = bcastoff;
|
|
ai->ai_addrlen = addrlen;
|
|
ai->ai_hdrsize = hdrsize;
|
|
ai->ai_pfilter = PF;
|
|
ai->ai_mtu = (ushort)mss;
|
|
|
|
Status = DoNDISRequest(ai, NdisRequestQueryInformation, OID,
|
|
ai->ai_addr, addrlen, NULL);
|
|
|
|
if (Status != NDIS_STATUS_SUCCESS) {
|
|
//
|
|
// Failed to get link-level address. Bail.
|
|
//
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
|
"LanRegister: Failed to get link-level address. "
|
|
"Status = 0x%x\n", Status));
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
//
|
|
// Read the speed for local purposes.
|
|
// If we can't read the speed that's OK.
|
|
//
|
|
Status = DoNDISRequest(ai, NdisRequestQueryInformation,
|
|
OID_GEN_LINK_SPEED, &speed, sizeof(speed), NULL);
|
|
|
|
if (Status == NDIS_STATUS_SUCCESS) {
|
|
ai->ai_speed = speed * 100L;
|
|
}
|
|
|
|
//
|
|
// Set the lookahead. This is the minimum amount of packet data
|
|
// that we wish to see contiguously for every packet received.
|
|
//
|
|
Status = DoNDISRequest(ai, NdisRequestSetInformation,
|
|
OID_GEN_CURRENT_LOOKAHEAD,
|
|
&LanLookahead, sizeof LanLookahead, NULL);
|
|
if (Status != NDIS_STATUS_SUCCESS) {
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
|
"LanRegister: Failed to set lookahead. "
|
|
"Status = 0x%x\n", Status));
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
//
|
|
// Allocate a Tranfer Data packet for this interface.
|
|
//
|
|
ai->ai_tdpacket = LanAllocateTDPacket(ai);
|
|
|
|
*Interface = ai;
|
|
return TRUE;
|
|
|
|
ErrorReturn:
|
|
LanFreeInterface(ai);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//* LanCreateToken
|
|
//
|
|
// Given a link-layer address, creates a 64-bit "interface identifier"
|
|
// in the low eight bytes of an IPv6 address.
|
|
// Does not modify the other bytes in the IPv6 address.
|
|
//
|
|
void
|
|
LanCreateToken(
|
|
void *Context, // Interface from which to take interface identifier.
|
|
IPv6Addr *Address) // IPv6 address to place token into.
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Context;
|
|
uchar *IEEEAddress = Interface->ai_addr;
|
|
|
|
//
|
|
// This is formed the same way for Ethernet, FDDI and Tunnel.
|
|
//
|
|
Address->s6_bytes[8] = IEEEAddress[0] ^ 0x2;
|
|
Address->s6_bytes[9] = IEEEAddress[1];
|
|
Address->s6_bytes[10] = IEEEAddress[2];
|
|
Address->s6_bytes[11] = 0xff;
|
|
Address->s6_bytes[12] = 0xfe;
|
|
Address->s6_bytes[13] = IEEEAddress[3];
|
|
Address->s6_bytes[14] = IEEEAddress[4];
|
|
Address->s6_bytes[15] = IEEEAddress[5];
|
|
}
|
|
|
|
|
|
//* LanReadLinkLayerAddressOption - Parse a ND link-layer address option.
|
|
//
|
|
// Parses a Neighbor Discovery link-layer address option
|
|
// and if valid, returns a pointer to the link-layer address.
|
|
//
|
|
const void *
|
|
LanReadLinkLayerAddressOption(
|
|
void *Context, // Interface for which ND option applies.
|
|
const uchar *OptionData) // Option data to parse.
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Context;
|
|
|
|
//
|
|
// Check that the option length is correct,
|
|
// allowing for the option type/length bytes
|
|
// and rounding up to 8-byte units.
|
|
//
|
|
if (((Interface->ai_addrlen + 2 + 7)/8) != OptionData[1])
|
|
return NULL;
|
|
|
|
//
|
|
// Skip over the option type and length bytes,
|
|
// and return a pointer to the option data.
|
|
//
|
|
return OptionData + 2;
|
|
}
|
|
|
|
|
|
//* LanWriteLinkLayerAddressOption - Create a ND link-layer address option.
|
|
//
|
|
// Creates a Neighbor Discovery link-layer address option.
|
|
// Our caller takes care of the option type & length fields.
|
|
// We handle the padding/alignment/placement of the link address
|
|
// into the option data.
|
|
//
|
|
// (Our caller allocates space for the option by adding 2 to the
|
|
// link address length and rounding up to a multiple of 8.)
|
|
//
|
|
void
|
|
LanWriteLinkLayerAddressOption(
|
|
void *Context, // Interface to create option regarding.
|
|
uchar *OptionData, // Where the option data resides.
|
|
const void *LinkAddress) // Link-level address.
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Context;
|
|
|
|
//
|
|
// Place the address after the option type/length bytes.
|
|
//
|
|
RtlCopyMemory(OptionData + 2, LinkAddress, Interface->ai_addrlen);
|
|
}
|
|
|
|
|
|
//
|
|
// From ip6def.h.
|
|
//
|
|
__inline int
|
|
IsMulticast(const IPv6Addr *Addr)
|
|
{
|
|
return Addr->s6_bytes[0] == 0xff;
|
|
}
|
|
|
|
|
|
//* LanTunnelConvertAddress
|
|
//
|
|
// LanTunnel does not use Neighbor Discovery or link-layer addresses.
|
|
//
|
|
ushort
|
|
LanTunnelConvertAddress(
|
|
void *Context, // Unused (nominally, our LanInterface).
|
|
const IPv6Addr *Address, // IPv6 multicast address.
|
|
void *LinkAddress) // Where link-level address to be filled resides.
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Context;
|
|
ASSERT(Interface->ai_media == NdisMediumTunnel);
|
|
|
|
RtlCopyMemory(LinkAddress, Interface->ai_addr, Interface->ai_addrlen);
|
|
|
|
//
|
|
// Make the neighbor link layer address different from our own. This
|
|
// ensures that IPv6SendLL does not loop back packets destined for them.
|
|
// In fact, a link layer address on the tunnel interface is faked only
|
|
// because IPv6SendLL does not handle zero length link layer addresses!
|
|
//
|
|
ASSERT(Interface->ai_addrlen != 0);
|
|
((PUCHAR) LinkAddress)[Interface->ai_addrlen - 1] =
|
|
~((PUCHAR) LinkAddress)[Interface->ai_addrlen - 1];
|
|
|
|
return ND_STATE_PERMANENT;
|
|
}
|
|
|
|
|
|
//* LanConvertAddress
|
|
//
|
|
// Converts an IPv6 multicast address to a link-layer address.
|
|
// Generally this requires hashing the IPv6 address into a set
|
|
// of link-layer addresses, in a link-layer-specific way.
|
|
//
|
|
ushort
|
|
LanConvertAddress(
|
|
void *Context, // Unused (nominally, our LanInterface).
|
|
const IPv6Addr *Address, // IPv6 multicast address.
|
|
void *LinkAddress) // Where link-level address to be filled resides.
|
|
{
|
|
if (IsMulticast(Address)) {
|
|
uchar *IEEEAddress = (uchar *)LinkAddress;
|
|
|
|
//
|
|
// This is formed the same way for Ethernet and FDDI.
|
|
//
|
|
IEEEAddress[0] = 0x33;
|
|
IEEEAddress[1] = 0x33;
|
|
IEEEAddress[2] = Address->s6_bytes[12];
|
|
IEEEAddress[3] = Address->s6_bytes[13];
|
|
IEEEAddress[4] = Address->s6_bytes[14];
|
|
IEEEAddress[5] = Address->s6_bytes[15];
|
|
return ND_STATE_PERMANENT;
|
|
}
|
|
else {
|
|
//
|
|
// We can't guess at the correct link-layer address.
|
|
//
|
|
return ND_STATE_INCOMPLETE;
|
|
}
|
|
}
|
|
|
|
|
|
//* LanSetMulticastAddressList
|
|
//
|
|
// Takes an array of link-layer multicast addresses
|
|
// (from LanConvertMulticastAddress) from which we should
|
|
// receive packets. Passes them to NDIS.
|
|
//
|
|
NDIS_STATUS
|
|
LanSetMulticastAddressList(
|
|
void *Context,
|
|
const void *LinkAddresses,
|
|
uint NumKeep,
|
|
uint NumAdd,
|
|
uint NumDel)
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Context;
|
|
NDIS_STATUS Status;
|
|
NDIS_OID OID;
|
|
|
|
//
|
|
// Set the multicast address list to the current list.
|
|
// The OID to do this depends upon the media type.
|
|
//
|
|
switch (Interface->ai_media) {
|
|
case NdisMedium802_3:
|
|
OID = OID_802_3_MULTICAST_LIST;
|
|
break;
|
|
case NdisMediumFddi:
|
|
OID = OID_FDDI_LONG_MULTICAST_LIST;
|
|
break;
|
|
default:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INTERNAL_ERROR,
|
|
"LanSetMulticastAddressList: Unknown media type\n"));
|
|
return NDIS_STATUS_FAILURE;
|
|
}
|
|
Status = DoNDISRequest(Interface, NdisRequestSetInformation,
|
|
OID, (char *)LinkAddresses,
|
|
(NumKeep + NumAdd) * Interface->ai_addrlen, NULL);
|
|
|
|
//
|
|
// If the above request was successful, then turn off the all-multicast
|
|
// or all-packets filter if we had previously set one of them.
|
|
//
|
|
if (Status == NDIS_STATUS_SUCCESS) {
|
|
if (Interface->ai_pfilter & NDIS_PACKET_TYPE_ALL_MULTICAST ||
|
|
Interface->ai_pfilter & NDIS_PACKET_TYPE_PROMISCUOUS) {
|
|
|
|
Interface->ai_pfilter &= ~(NDIS_PACKET_TYPE_ALL_MULTICAST |
|
|
NDIS_PACKET_TYPE_PROMISCUOUS);
|
|
DoNDISRequest(Interface, NdisRequestSetInformation,
|
|
OID_GEN_CURRENT_PACKET_FILTER, &Interface->ai_pfilter,
|
|
sizeof(uint), NULL);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// We get here only if the NDIS request to set the multicast list fails.
|
|
// First we try to set the packet filter for all multicast packets, and if
|
|
// this fails, we try to set the packet filter for all packets.
|
|
//
|
|
|
|
// This code was swiped from the V4 stack: arp.c
|
|
Interface->ai_pfilter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
|
|
Status = DoNDISRequest(Interface, NdisRequestSetInformation,
|
|
OID_GEN_CURRENT_PACKET_FILTER, &Interface->ai_pfilter,
|
|
sizeof(uint), NULL);
|
|
|
|
if (Status != NDIS_STATUS_SUCCESS) {
|
|
// All multicast failed, try all packets.
|
|
Interface->ai_pfilter &= ~(NDIS_PACKET_TYPE_ALL_MULTICAST);
|
|
Interface->ai_pfilter |= NDIS_PACKET_TYPE_PROMISCUOUS;
|
|
Status = DoNDISRequest(Interface, NdisRequestSetInformation,
|
|
OID_GEN_CURRENT_PACKET_FILTER, &Interface->ai_pfilter,
|
|
sizeof(uint), NULL);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
//* LanCloseAdapter
|
|
//
|
|
// The IPv6 layer calls this function to close a connection to an adapter.
|
|
//
|
|
void
|
|
LanCloseAdapter(void *Context)
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Context;
|
|
|
|
//
|
|
// Mark adapter down.
|
|
//
|
|
Interface->ai_state = INTERFACE_DOWN;
|
|
|
|
//
|
|
// Shut adapter up, so we don't get any more frames.
|
|
//
|
|
Interface->ai_pfilter = 0;
|
|
DoNDISRequest(Interface, NdisRequestSetInformation,
|
|
OID_GEN_CURRENT_PACKET_FILTER,
|
|
&Interface->ai_pfilter, sizeof(uint), NULL);
|
|
|
|
//
|
|
// Release our reference for the interface.
|
|
//
|
|
ReleaseInterface(Interface->ai_context);
|
|
}
|
|
|
|
|
|
//* LanCleanupAdapter
|
|
//
|
|
// Perform final cleanup of the adapter.
|
|
//
|
|
void
|
|
LanCleanupAdapter(void *Context)
|
|
{
|
|
LanInterface *Interface = (LanInterface *)Context;
|
|
NDIS_STATUS Status;
|
|
|
|
KeInitializeEvent(&Interface->ai_event, SynchronizationEvent, FALSE);
|
|
|
|
//
|
|
// Close the connection to NDIS.
|
|
//
|
|
NdisCloseAdapter(&Status, Interface->ai_handle);
|
|
|
|
//
|
|
// Block for close to complete.
|
|
//
|
|
if (Status == NDIS_STATUS_PENDING) {
|
|
(void) KeWaitForSingleObject(&Interface->ai_event,
|
|
UserRequest, KernelMode,
|
|
FALSE, NULL);
|
|
Status = Interface->ai_status;
|
|
}
|
|
|
|
if (Status != NDIS_STATUS_SUCCESS) {
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
|
"LanCleanupAdapter(%p) - NdisCloseAdapter -> %x\n",
|
|
Interface, Status));
|
|
}
|
|
|
|
//
|
|
// Tell NDIS that we are done.
|
|
// NOTE: IOCTL_IPV6_DELETE_INTERFACE does not set ai_unbind, this
|
|
// ensures that NdisCompleteUnbindAdapter is not invoked along its path.
|
|
//
|
|
if (Interface->ai_unbind != NULL)
|
|
NdisCompleteUnbindAdapter(Interface->ai_unbind, NDIS_STATUS_SUCCESS);
|
|
|
|
//
|
|
// Free adapter memory.
|
|
//
|
|
IPv6FreePacket(Interface->ai_tdpacket);
|
|
ExFreePool(Interface);
|
|
}
|
|
|
|
|
|
//* LanBindAdapter - Bind and initialize an adapter.
|
|
//
|
|
// Called in a PNP environment to initialize and bind an adapter. We open
|
|
// the adapter and get it running, and then we call up to IP to tell him
|
|
// about it. IP will initialize, and if all goes well call us back to start
|
|
// receiving.
|
|
//
|
|
void NDIS_API
|
|
LanBindAdapter(
|
|
PNDIS_STATUS RetStatus, // Where to return status of this call.
|
|
NDIS_HANDLE BindContext, // Handle for calling BindingAdapterComplete.
|
|
PNDIS_STRING AdapterName, // Name of adapeter.
|
|
PVOID SS1, // System specific parameter 1.
|
|
PVOID SS2) // System specific parameter 2.
|
|
{
|
|
LanInterface *Interface; // Newly created interface.
|
|
LLIPBindInfo BindInfo; // Binding information for IP.
|
|
GUID Guid;
|
|
UNICODE_STRING GuidName;
|
|
uint BindPrefixLength;
|
|
uint MediaStatus;
|
|
NDIS_STATUS Status;
|
|
|
|
//
|
|
// Convert the NDIS AdapterName to a Guid.
|
|
//
|
|
BindPrefixLength = sizeof(IPV6_BIND_STRING_PREFIX) - sizeof(WCHAR);
|
|
GuidName.Buffer = (PVOID)((char *)AdapterName->Buffer + BindPrefixLength);
|
|
GuidName.Length = AdapterName->Length - BindPrefixLength;
|
|
GuidName.MaximumLength = AdapterName->MaximumLength - BindPrefixLength;
|
|
|
|
if (((int)GuidName.Length < 0) ||
|
|
! NT_SUCCESS(RtlGUIDFromString(&GuidName, &Guid))) {
|
|
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INTERNAL_ERROR,
|
|
"LanBindAdapter(%.*ls) - bad guid\n",
|
|
AdapterName->Length / sizeof(WCHAR),
|
|
AdapterName->Buffer));
|
|
*RetStatus = NDIS_STATUS_FAILURE;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Now open the adapter and get the info.
|
|
//
|
|
if (!LanRegister(AdapterName, &Interface)) {
|
|
*RetStatus = NDIS_STATUS_FAILURE;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// OK, we've opened the adapter. Notify IP about it.
|
|
//
|
|
BindInfo.lip_context = Interface;
|
|
BindInfo.lip_transmit = LanTransmit;
|
|
BindInfo.lip_token = LanCreateToken;
|
|
BindInfo.lip_close = LanCloseAdapter;
|
|
BindInfo.lip_cleanup = LanCleanupAdapter;
|
|
BindInfo.lip_defmtu = BindInfo.lip_maxmtu = Interface->ai_mtu;
|
|
BindInfo.lip_hdrsize = Interface->ai_hdrsize;
|
|
BindInfo.lip_addrlen = Interface->ai_addrlen;
|
|
BindInfo.lip_addr = Interface->ai_addr;
|
|
|
|
switch (Interface->ai_media) {
|
|
case NdisMediumTunnel:
|
|
BindInfo.lip_type = IF_TYPE_TUNNEL_TEREDO;
|
|
|
|
BindInfo.lip_rdllopt = NULL;
|
|
BindInfo.lip_wrllopt = NULL;
|
|
BindInfo.lip_cvaddr = LanTunnelConvertAddress;
|
|
BindInfo.lip_mclist = NULL;
|
|
BindInfo.lip_flags = IF_FLAG_ROUTER_DISCOVERS | IF_FLAG_MULTICAST;
|
|
BindInfo.lip_dadxmit = 0;
|
|
BindInfo.lip_pref = LAN_TUNNEL_DEFAULT_PREFERENCE;
|
|
break;
|
|
|
|
case NdisMedium802_3:
|
|
BindInfo.lip_type = IF_TYPE_ETHERNET;
|
|
goto Default;
|
|
|
|
case NdisMediumFddi:
|
|
BindInfo.lip_type = IF_TYPE_FDDI;
|
|
goto Default;
|
|
|
|
default:
|
|
ASSERT(! "unrecognized ai_media type");
|
|
BindInfo.lip_type = 0;
|
|
|
|
Default:
|
|
BindInfo.lip_rdllopt = LanReadLinkLayerAddressOption;
|
|
BindInfo.lip_wrllopt = LanWriteLinkLayerAddressOption;
|
|
BindInfo.lip_cvaddr = LanConvertAddress;
|
|
BindInfo.lip_mclist = LanSetMulticastAddressList;
|
|
BindInfo.lip_flags = IF_FLAG_NEIGHBOR_DISCOVERS |
|
|
IF_FLAG_ROUTER_DISCOVERS | IF_FLAG_MULTICAST;
|
|
BindInfo.lip_dadxmit = 1; // Per RFC 2462.
|
|
BindInfo.lip_pref = 0;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Should we create the interface in the disconnected state?
|
|
//
|
|
Status = DoNDISRequest(Interface, NdisRequestQueryInformation,
|
|
OID_GEN_MEDIA_CONNECT_STATUS,
|
|
&MediaStatus, sizeof MediaStatus, NULL);
|
|
if (Status == NDIS_STATUS_SUCCESS) {
|
|
if (MediaStatus == NdisMediaStateDisconnected) {
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanBindAdapter(%p) - media disconnect\n", Interface));
|
|
BindInfo.lip_flags |= IF_FLAG_MEDIA_DISCONNECTED;
|
|
}
|
|
}
|
|
|
|
if (CreateInterface(&Guid, &BindInfo, &Interface->ai_context) !=
|
|
NDIS_STATUS_SUCCESS) {
|
|
//
|
|
// Attempt to create IP interface failed. Need to close the binding.
|
|
// LanFreeInterface will do that, as well as freeing resources.
|
|
//
|
|
LanFreeInterface(Interface);
|
|
*RetStatus = NDIS_STATUS_FAILURE;
|
|
return;
|
|
}
|
|
|
|
Status = DoNDISRequest(Interface, NdisRequestSetInformation,
|
|
OID_GEN_CURRENT_PACKET_FILTER,
|
|
&Interface->ai_pfilter,
|
|
sizeof Interface->ai_pfilter,
|
|
NULL);
|
|
if (Status == NDIS_STATUS_SUCCESS)
|
|
Interface->ai_state = INTERFACE_UP;
|
|
else
|
|
Interface->ai_state = INTERFACE_DOWN;
|
|
|
|
*RetStatus = NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
//* LanUnbindAdapter - Unbind from an adapter.
|
|
//
|
|
// Called when we need to unbind from an adapter.
|
|
// We'll notify IP, then free our memory and return.
|
|
//
|
|
void NDIS_API // Returns: Nothing.
|
|
LanUnbindAdapter(
|
|
PNDIS_STATUS RetStatus, // Where to return status from this call.
|
|
NDIS_HANDLE ProtBindContext, // Context we gave NDIS earlier.
|
|
NDIS_HANDLE UnbindContext) // Context for completing this request.
|
|
{
|
|
LanInterface *Interface = (LanInterface *)ProtBindContext;
|
|
|
|
Interface->ai_unbind = UnbindContext;
|
|
|
|
//
|
|
// Call IP to destroy the interface.
|
|
// IP will call LanCloseAdapter then LanCleanupAdapter.
|
|
//
|
|
DestroyInterface(Interface->ai_context);
|
|
|
|
//
|
|
// We will call NdisCompleteUnbindAdapter later,
|
|
// when NdisCloseAdapter completes.
|
|
//
|
|
*RetStatus = NDIS_STATUS_PENDING;
|
|
}
|
|
|
|
|
|
//* LanPnPEvent
|
|
//
|
|
// Gets called for plug'n'play and power-management events.
|
|
//
|
|
NDIS_STATUS NDIS_API
|
|
LanPnPEvent(
|
|
NDIS_HANDLE ProtocolBindingContext,
|
|
PNET_PNP_EVENT NetPnPEvent)
|
|
{
|
|
LanInterface *Interface = (LanInterface *) ProtocolBindingContext;
|
|
|
|
switch (NetPnPEvent->NetEvent) {
|
|
case NetEventSetPower: {
|
|
NET_DEVICE_POWER_STATE PowerState;
|
|
|
|
//
|
|
// Get the power state of the interface.
|
|
//
|
|
ASSERT(NetPnPEvent->BufferLength >= sizeof PowerState);
|
|
PowerState = * (NET_DEVICE_POWER_STATE *) NetPnPEvent->Buffer;
|
|
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanPnPEvent(%p) - set power %u\n",
|
|
Interface, PowerState));
|
|
|
|
//
|
|
// We ignore the events that tell us about power going away.
|
|
// But when power comes back, we query for connect status.
|
|
// NDIS does not report connect/disconnect events that occur
|
|
// while there is no power.
|
|
//
|
|
if (PowerState == NetDeviceStateD0) {
|
|
uint MediaStatus;
|
|
NDIS_STATUS Status;
|
|
|
|
Status = DoNDISRequest(Interface,
|
|
NdisRequestQueryInformation,
|
|
OID_GEN_MEDIA_CONNECT_STATUS,
|
|
&MediaStatus,
|
|
sizeof MediaStatus,
|
|
NULL);
|
|
if (Status == NDIS_STATUS_SUCCESS) {
|
|
//
|
|
// Note that we may be redundantly setting the link status.
|
|
// For example saying that it is disconnected when the
|
|
// IPv6 interface status is already disconnected,
|
|
// or vice-versa. The IPv6 code must deal with this.
|
|
//
|
|
SetInterfaceLinkStatus(Interface->ai_context,
|
|
MediaStatus != NdisMediaStateDisconnected);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case NetEventBindsComplete:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanPnPEvent(%p) - binds complete\n", Interface));
|
|
IPv6ProviderReady();
|
|
break;
|
|
|
|
case NetEventQueryPower:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanPnPEvent(%p) - query power\n", Interface));
|
|
break;
|
|
|
|
case NetEventQueryRemoveDevice:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanPnPEvent(%p) - query remove device\n", Interface));
|
|
break;
|
|
|
|
case NetEventCancelRemoveDevice:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanPnPEvent(%p) - cancel remove device\n", Interface));
|
|
break;
|
|
|
|
case NetEventReconfigure:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanPnPEvent(%p) - reconfigure\n", Interface));
|
|
break;
|
|
|
|
case NetEventBindList:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanPnPEvent(%p) - bind list\n", Interface));
|
|
break;
|
|
|
|
case NetEventPnPCapabilities:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanPnPEvent(%p) - pnp capabilities\n", Interface));
|
|
break;
|
|
|
|
default:
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_INFO_STATE,
|
|
"LanPnPEvent(%p) - unknown code %u length %u\n",
|
|
Interface,
|
|
NetPnPEvent->NetEvent,
|
|
NetPnPEvent->BufferLength));
|
|
break;
|
|
}
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|