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