able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/atm/arp/atmarpc/arppkt.c

2243 lines
51 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
arppkt.c - ATMARP Packet Routines.
Abstract:
Routines that build and parse ARP packets.
Revision History:
Who When What
-------- -------- ----------------------------------------------
arvindm 07-29-96 Created
Notes:
--*/
#include <precomp.h>
#define _FILENUMBER 'TKPA'
VOID
AtmArpSendPacketOnVc(
IN PATMARP_VC pVc LOCKIN NOLOCKOUT,
IN PNDIS_PACKET pNdisPacket
)
/*++
Routine Description:
Send a packet on the specified VC. Apart from calling NDIS to do
the job, we refresh the aging timer on this VC.
Arguments:
pVc - Pointer to ATMARP VC
pNdisPacket - Pointer to packet to be sent.
Return Value:
None
--*/
{
NDIS_HANDLE NdisVcHandle;
if (AA_IS_FLAG_SET(
pVc->Flags,
AA_VC_CALL_STATE_MASK,
AA_VC_CALL_STATE_ACTIVE) &&
!AA_IS_VC_GOING_DOWN(pVc))
{
//
// A call is active on this VC, so send the packet.
//
AtmArpRefreshTimer(&(pVc->Timer));
NdisVcHandle = pVc->NdisVcHandle;
#ifdef VC_REFS_ON_SENDS
AtmArpReferenceVc(pVc); // SendPacketOnVc
#endif // VC_REFS_ON_SENDS
pVc->OutstandingSends++; // SendPacketOnVc
AA_RELEASE_VC_LOCK(pVc);
AADEBUGP(AAD_EXTRA_LOUD+50,
("SendPacketOnVc: pVc 0x%x, Pkt 0x%x, VcHandle 0x%x\n",
pVc, pNdisPacket, NdisVcHandle));
#ifdef PERF
AadLogSendUpdate(pNdisPacket);
#endif // PERF
NDIS_CO_SEND_PACKETS(
NdisVcHandle,
&pNdisPacket,
1
);
}
else
{
if (!AA_IS_VC_GOING_DOWN(pVc))
{
//
// Call must be in progress. Queue this packet; it will
// be sent as soon as the call is fully set up.
//
AtmArpQueuePacketOnVc(pVc, pNdisPacket);
AA_RELEASE_VC_LOCK(pVc);
}
else
{
//
// This VC is going down. Complete the send with a failure.
//
#ifdef VC_REFS_ON_SENDS
AtmArpReferenceVc(pVc); // SendPacketOnVc2
#endif // VC_REFS_ON_SENDS
pVc->OutstandingSends++; // SendPacketOnVc - failure completion
AA_RELEASE_VC_LOCK(pVc);
#if DBG
#if DBG_CO_SEND
{
PULONG pContext;
pContext = (PULONG)&(pNdisPacket->WrapperReserved[0]);;
*pContext = 'AaAa';
}
#endif
#endif
AtmArpCoSendCompleteHandler(
NDIS_STATUS_FAILURE,
(NDIS_HANDLE)pVc,
pNdisPacket
);
}
}
return;
}
PNDIS_PACKET
AtmArpBuildARPPacket(
IN USHORT OperationType,
IN PATMARP_INTERFACE pInterface,
IN PUCHAR * ppArpPacket,
IN PAA_ARP_PKT_CONTENTS pArpContents
)
/*++
Routine Description:
Build a generic ARP packet with the given attributes.
Arguments:
OperationType - Op type (e.g. ARP Request, ARP Reply)
pInterface - Pointer to ATMARP Interface
ppArpPacket - Pointer to place to return start of packet
pArpContents - Pointer to structure describing contents
Return Value:
Pointer to NDIS packet if successful, NULL otherwise. If successful,
we also set *ppArpPacket to point to the first byte in the constructed
ARP packet.
--*/
{
PNDIS_PACKET pNdisPacket;
PNDIS_BUFFER pNdisBuffer;
ULONG BufferLength; // Length of ARP packet
ULONG Length; // Temp length
PUCHAR pPkt; // Start of allocated packet
PUCHAR pBuf; // Used to walk the packet
PAA_ARP_PKT_HEADER pArpHeader; // ARP packet header
//
// Calculate the length of what we're about to build
//
BufferLength = AA_ARP_PKT_HEADER_LENGTH +
(pArpContents->SrcAtmNumberTypeLen & ~AA_PKT_ATM_ADDRESS_BIT) +
(pArpContents->SrcAtmSubaddrTypeLen & ~AA_PKT_ATM_ADDRESS_BIT) +
(pArpContents->DstAtmNumberTypeLen & ~AA_PKT_ATM_ADDRESS_BIT) +
(pArpContents->DstAtmSubaddrTypeLen & ~AA_PKT_ATM_ADDRESS_BIT) +
0;
if (pArpContents->pSrcIPAddress != (PUCHAR)NULL)
{
BufferLength += AA_IPV4_ADDRESS_LENGTH;
}
if (pArpContents->pDstIPAddress != (PUCHAR)NULL)
{
BufferLength += AA_IPV4_ADDRESS_LENGTH;
}
pNdisPacket = AtmArpAllocatePacket(pInterface);
if (pNdisPacket != (PNDIS_PACKET)NULL)
{
pNdisBuffer = AtmArpAllocateProtoBuffer(
pInterface,
BufferLength,
&(pPkt)
);
if (pNdisBuffer != (PNDIS_BUFFER)NULL)
{
//
// Return value:
//
*ppArpPacket = pPkt;
//
// Initialize packet with all 0's
//
AA_SET_MEM(pPkt, 0, BufferLength);
pArpHeader = (PAA_ARP_PKT_HEADER)pPkt;
//
// Fixed-location fields:
//
pArpHeader->LLCSNAPHeader = AtmArpLlcSnapHeader;
pArpHeader->LLCSNAPHeader.EtherType = NET_SHORT(AA_PKT_ETHERTYPE_ARP);
pArpHeader->hrd = NET_SHORT(AA_PKT_ATM_FORUM_AF);
pArpHeader->pro = NET_SHORT(AA_PKT_PRO_IP);
pArpHeader->op = NET_SHORT(OperationType);
//
// Now fill in the variable length fields
//
pBuf = pArpHeader->Variable;
//
// Source ATM Number
//
Length = (pArpContents->SrcAtmNumberTypeLen & ~AA_PKT_ATM_ADDRESS_BIT);
if (Length > 0)
{
pArpHeader->shtl = pArpContents->SrcAtmNumberTypeLen;
AA_COPY_MEM(pBuf, pArpContents->pSrcAtmNumber, Length);
pBuf += Length;
}
//
// Source ATM subaddress
//
Length = (pArpContents->SrcAtmSubaddrTypeLen & ~AA_PKT_ATM_ADDRESS_BIT);
if (Length > 0)
{
pArpHeader->shtl = pArpContents->SrcAtmSubaddrTypeLen;
AA_COPY_MEM(pBuf, pArpContents->pSrcAtmSubaddress, Length);
pBuf += Length;
}
//
// Source Protocol (IP) address
//
if (pArpContents->pSrcIPAddress != (PUCHAR)NULL)
{
pArpHeader->spln = AA_IPV4_ADDRESS_LENGTH;
AA_COPY_MEM(pBuf, pArpContents->pSrcIPAddress, AA_IPV4_ADDRESS_LENGTH);
pBuf += AA_IPV4_ADDRESS_LENGTH;
}
//
// Target ATM Number
//
Length = (pArpContents->DstAtmNumberTypeLen & ~AA_PKT_ATM_ADDRESS_BIT);
if (Length > 0)
{
pArpHeader->thtl = pArpContents->DstAtmNumberTypeLen;
AA_COPY_MEM(pBuf, pArpContents->pDstAtmNumber, Length);
pBuf += Length;
}
//
// Target ATM subaddress
//
Length = (pArpContents->DstAtmSubaddrTypeLen & ~AA_PKT_ATM_ADDRESS_BIT);
if (Length > 0)
{
pArpHeader->thtl = pArpContents->DstAtmSubaddrTypeLen;
AA_COPY_MEM(pBuf, pArpContents->pDstAtmSubaddress, Length);
pBuf += Length;
}
//
// Target Protocol (IP) address
//
if (pArpContents->pDstIPAddress != (PUCHAR)NULL)
{
pArpHeader->tpln = AA_IPV4_ADDRESS_LENGTH;
AA_COPY_MEM(pBuf, pArpContents->pDstIPAddress, AA_IPV4_ADDRESS_LENGTH);
pBuf += AA_IPV4_ADDRESS_LENGTH;
}
NdisChainBufferAtFront(pNdisPacket, pNdisBuffer);
}
else
{
AtmArpFreePacket(pInterface, pNdisPacket);
pNdisPacket = (PNDIS_PACKET)NULL;
}
}
AADEBUGP(AAD_EXTRA_LOUD, ("BldArpPkt: pIf 0x%x, Op %d, NdisPkt 0x%x, NdisBuf 0x%x\n",
pInterface, OperationType, pNdisPacket, pNdisBuffer));
return (pNdisPacket);
}
VOID
AtmArpSendARPRequest(
PATMARP_INTERFACE pInterface,
IP_ADDRESS UNALIGNED * pSrcIPAddress,
IP_ADDRESS UNALIGNED * pDstIPAddress
)
/*++
Routine Description:
Send an ARP Request to the server, for the given interface.
Preconditions: the ATM interface is UP, and the AdminState
for the interface is IF_STATUS_UP.
We first build an ARP Request with the given parameters. Then,
if a Best Effort VC to the server's ATM address exists, the packet
is sent on this. Other possibilities:
- the Best Effort VC to the server is being set up: queue it
on the VC
- No Best Effort VC to the server exists: Create a new VC on this
ATM Entry, make a call with Best Effort flow specs, and queue
the request on this VC.
Arguments:
pInterface - Pointer to ATMARP Interface structure
pSrcIPAddress - Pointer to Source IP Address
pDstIPAddress - Pointer to Destination IP Address (to be
resolved)
Return Value:
None
--*/
{
PATMARP_ATM_ENTRY pAtmEntry; // Entry for the server's ATM address
PATMARP_VC pVc; // VC to the server
PNDIS_PACKET pNdisPacket;
PATMARP_FLOW_SPEC pFlowSpec;
PUCHAR pArpPacket; // Pointer to ARP packet being constructed
AA_ARP_PKT_CONTENTS ArpContents;// Describes the packet we want to build
NDIS_STATUS Status;
AADEBUGP(AAD_INFO,
("Sending ARP Request on IF 0x%x for IP Addr: %d.%d.%d.%d\n",
pInterface,
((PUCHAR)pDstIPAddress)[0],
((PUCHAR)pDstIPAddress)[1],
((PUCHAR)pDstIPAddress)[2],
((PUCHAR)pDstIPAddress)[3]
));
AA_ASSERT(pInterface->pCurrentServer != NULL_PATMARP_SERVER_ENTRY);
AA_ASSERT(pInterface->pCurrentServer->pAtmEntry != NULL_PATMARP_ATM_ENTRY);
//
// Prepare the ARP packet contents structure
//
AA_SET_MEM((PUCHAR)&ArpContents, 0, sizeof(AA_ARP_PKT_CONTENTS));
//
// Source ATM Number
//
ArpContents.pSrcAtmNumber = pInterface->LocalAtmAddress.Address;
ArpContents.SrcAtmNumberTypeLen =
AA_PKT_ATM_ADDRESS_TO_TYPE_LEN(&(pInterface->LocalAtmAddress));
//
// Source IP Address
//
ArpContents.pSrcIPAddress = (PUCHAR)pSrcIPAddress;
//
// Target IP Address
//
ArpContents.pDstIPAddress = (PUCHAR)pDstIPAddress;
//
// Build the ARP Request
//
pNdisPacket = AtmArpBuildARPPacket(
AA_PKT_OP_TYPE_ARP_REQUEST,
pInterface,
&pArpPacket,
&ArpContents
);
if (pNdisPacket != (PNDIS_PACKET)NULL)
{
//
// Find the ATM Entry for the in-use ATMARP Server:
//
AA_ACQUIRE_IF_LOCK(pInterface);
pAtmEntry = pInterface->pCurrentServer->pAtmEntry;
AA_RELEASE_IF_LOCK(pInterface);
AA_ACQUIRE_AE_LOCK(pAtmEntry);
//
// Get at the Best Effort VC going to this ATM address:
//
pVc = pAtmEntry->pBestEffortVc;
if (pVc != NULL_PATMARP_VC)
{
ULONG rc;
AA_ACQUIRE_VC_LOCK_DPC(pVc);
AtmArpReferenceVc(pVc); // temp ref
AA_RELEASE_VC_LOCK_DPC(pVc);
AA_RELEASE_AE_LOCK(pAtmEntry); // Not needed anymore
//
// A VC to the server exists; send this packet on the VC
//
AA_ACQUIRE_VC_LOCK(pVc);
rc = AtmArpDereferenceVc(pVc); // temp ref
if (rc != 0)
{
AtmArpSendPacketOnVc(pVc, pNdisPacket);
//
// The VC lock is released in SendPacketOnVc
//
}
else
{
//
// The VC has been deref'ed away! Set up pVc for the
// check coming up.
//
pVc = NULL_PATMARP_VC;
AA_ACQUIRE_AE_LOCK(pAtmEntry);
}
}
if (pVc == NULL_PATMARP_VC)
{
//
// We don't have an appropriate VC to the server, so create
// one, and queue this packet for transmission as soon as
// the call is made.
//
// AtmArpMakeCall needs the caller to hold the ATM Entry lock.
//
AA_GET_CONTROL_PACKET_SPECS(pInterface, &pFlowSpec);
Status = AtmArpMakeCall(
pInterface,
pAtmEntry,
pFlowSpec,
pNdisPacket
);
//
// The AE lock is released within the above.
//
}
}
}
VOID
AtmArpSendInARPRequest(
IN PATMARP_VC pVc
)
/*++
Routine Description:
Send an InATMARP Request on a VC.
Arguments:
pVc - Pointer to ATMARP VC on which we send the request
Return Value:
None
--*/
{
PATMARP_INTERFACE pInterface;
PNDIS_PACKET pNdisPacket;
PUCHAR pArpPacket; // Pointer to ARP packet being constructed
AA_ARP_PKT_CONTENTS ArpContents;// Describes the packet we want to build
//
// Prepare the ARP packet contents structure
//
AA_SET_MEM((PUCHAR)&ArpContents, 0, sizeof(AA_ARP_PKT_CONTENTS));
pInterface = pVc->pInterface;
//
// Source IP Address
//
ArpContents.pSrcIPAddress = (PUCHAR)&(pInterface->LocalIPAddress.IPAddress);
//
// Source ATM number
//
ArpContents.pSrcAtmNumber = pInterface->LocalAtmAddress.Address;
ArpContents.SrcAtmNumberTypeLen =
AA_PKT_ATM_ADDRESS_TO_TYPE_LEN(&(pInterface->LocalAtmAddress));
//
// Build the InATMARP Request packet
//
pNdisPacket = AtmArpBuildARPPacket(
AA_PKT_OP_TYPE_INARP_REQUEST,
pInterface,
&pArpPacket,
&ArpContents
);
if (pNdisPacket != (PNDIS_PACKET)NULL)
{
#ifndef VC_REFS_ON_SENDS
AA_ACQUIRE_VC_LOCK(pVc);
#endif // VC_REFS_ON_SENDS
AtmArpSendPacketOnVc(pVc, pNdisPacket);
//
// The VC lock is released by SendPacketOnVc
//
}
else
{
#ifdef VC_REFS_ON_SENDS
AA_RELEASE_VC_LOCK(pVc);
#endif // VC_REFS_ON_SENDS
}
}
UINT
AtmArpCoReceivePacketHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE ProtocolVcContext,
IN PNDIS_PACKET pNdisPacket
)
/*++
Routine Description:
This is routine is called when a packet is received on a VC owned
by the ATMARP module. If it is an ARP packet, we consume it ourselves.
Otherwise, we pass it up to IP.
In any case, we refresh the VC aging timer on this VC.
Arguments:
ProtocolBindingContext - Actually a pointer to our Adapter structure
ProtocolVcContext - Actually a pointer to our VC structure
pNdisPacket - NDIS packet being received.
Return Value:
0 always, because we don't hold on to ARP packets, and we assume
IP doesn't either.
--*/
{
PATMARP_INTERFACE pInterface;
PATMARP_VC pVc;
UINT TotalLength; // Total bytes in packet
PNDIS_BUFFER pNdisBuffer; // Pointer to first buffer
UINT BufferLength;
UINT IsNonUnicast; // Is this to a non-unicast destn MAC addr?
BOOLEAN Discarded; // Are we discarding this packet?
PAA_PKT_LLC_SNAP_HEADER pPktHeader; // LLC/SNAP header
UINT ReturnCount = 0;
#if DBG
pPktHeader = NULL;
#endif
pVc = (PATMARP_VC)ProtocolVcContext;
AA_STRUCT_ASSERT(pVc, avc);
pInterface = pVc->pInterface;
Discarded = FALSE;
IsNonUnicast = (UINT)FALSE;
if (pInterface->AdminState == IF_STATUS_UP)
{
//
// Refresh VC aging on this VC
//
AA_ACQUIRE_VC_LOCK(pVc);
AtmArpRefreshTimer(&(pVc->Timer));
AA_RELEASE_VC_LOCK(pVc);
NdisQueryPacket(
pNdisPacket,
NULL,
NULL,
&pNdisBuffer,
&TotalLength
);
//
// We expect atleast the LLC/SNAP header to be present
// Note: this precludes Null encapsulation.
//
if (TotalLength >= AA_PKT_LLC_SNAP_HEADER_LENGTH)
{
AA_IF_STAT_ADD(pInterface, InOctets, TotalLength);
NdisQueryBuffer(
pNdisBuffer,
(PVOID *)&pPktHeader,
&BufferLength
);
AADEBUGP(AAD_EXTRA_LOUD,
("Rcv: VC 0x%x, NDISpkt 0x%x, NDISbuf 0x%x, Buflen %d, Totlen %d, Pkthdr 0x%x\n",
pVc,
pNdisPacket,
pNdisBuffer,
BufferLength,
TotalLength,
pPktHeader));
AADEBUGPDUMP(AAD_EXTRA_LOUD+20, pPktHeader, BufferLength);
AA_ASSERT(BufferLength >= AA_PKT_LLC_SNAP_HEADER_LENGTH);
if (AA_PKT_LLC_SNAP_HEADER_OK(pPktHeader))
{
//
// If the EtherType is IP, pass up this packet to
// the IP layer
//
if (pPktHeader->EtherType == NET_SHORT(AA_PKT_ETHERTYPE_IP))
{
AADEBUGP(AAD_EXTRA_LOUD,
("Rcv: VC 0x%x, NDISpkt 0x%x: EtherType is IP, passing up\n"));
#if DBG
if (AaDataDebugLevel & AAD_DATA_IN)
{
IP_ADDRESS IPAddress;
if ((pVc->pAtmEntry != NULL_PATMARP_ATM_ENTRY) &&
(pVc->pAtmEntry->pIpEntryList != NULL_PATMARP_IP_ENTRY))
{
IPAddress = pVc->pAtmEntry->pIpEntryList->IPAddress;
}
else
{
IPAddress = 0;
}
AADEBUGP(AAD_WARNING,
("%d <= %d.%d.%d.%d\n",
TotalLength,
((PUCHAR)&IPAddress)[0],
((PUCHAR)&IPAddress)[1],
((PUCHAR)&IPAddress)[2],
((PUCHAR)&IPAddress)[3]));
}
#endif // DBG
if (IsNonUnicast)
{
AA_IF_STAT_INCR(pInterface, InNonUnicastPkts);
}
else
{
AA_IF_STAT_INCR(pInterface, InUnicastPkts);
}
#ifdef _PNP_POWER_
if (NDIS_GET_PACKET_STATUS(pNdisPacket) != NDIS_STATUS_RESOURCES)
{
UINT HeaderSize;
UINT DataSize;
#define ATMARP_MIN_1ST_RECV_BUFSIZE 512
HeaderSize = NDIS_GET_PACKET_HEADER_SIZE(pNdisPacket);
//
// 2/8/1998 JosephJ
// We set DataSize to the total payload size,
// unless the first buffer is too small to
// hold the IP header. In the latter case,
// we set DataSize to be the size of the 1st buffer
// (minus the LLS/SNAP header size).
//
// This is to work around a bug in tcpip.
//
// 2/25/1998 JosephJ
// Unfortunately we have to back out YET AGAIN
// because large pings (eg ping -l 4000) doesn't
// work -- bug#297784
// Hence the "0" in "0 && DataSize" below.
// Take out the "0" to put back the per fix.
//
DataSize = BufferLength - sizeof(AA_PKT_LLC_SNAP_HEADER);
if (0 && DataSize >= ATMARP_MIN_1ST_RECV_BUFSIZE)
{
DataSize = TotalLength - sizeof(AA_PKT_LLC_SNAP_HEADER);
}
(pInterface->IPRcvPktHandler)(
pInterface->IPContext,
(PVOID)((PUCHAR)pPktHeader+sizeof(AA_PKT_LLC_SNAP_HEADER)),
DataSize,
TotalLength,
(NDIS_HANDLE)pNdisPacket,
sizeof(AA_PKT_LLC_SNAP_HEADER),
IsNonUnicast,
0,
pNdisBuffer,
&ReturnCount
#if P2MP
,NULL
#endif //P2MP
);
}
else
{
(pInterface->IPRcvHandler)(
pInterface->IPContext,
(PVOID)((PUCHAR)pPktHeader+sizeof(AA_PKT_LLC_SNAP_HEADER)),
BufferLength - sizeof(AA_PKT_LLC_SNAP_HEADER),
TotalLength - sizeof(AA_PKT_LLC_SNAP_HEADER),
(NDIS_HANDLE)pNdisPacket,
sizeof(AA_PKT_LLC_SNAP_HEADER),
IsNonUnicast
#if P2MP
,NULL
#endif //P2MP
);
}
#else
// For Win98:
(pInterface->IPRcvHandler)(
pInterface->IPContext,
(PVOID)((PUCHAR)pPktHeader+sizeof(AA_PKT_LLC_SNAP_HEADER)),
BufferLength - sizeof(AA_PKT_LLC_SNAP_HEADER),
TotalLength - sizeof(AA_PKT_LLC_SNAP_HEADER),
(NDIS_HANDLE)pNdisPacket,
sizeof(AA_PKT_LLC_SNAP_HEADER),
IsNonUnicast
#if P2MP
,NULL
#endif //P2MP
);
#endif // _PNP_POWER_
}
else if (pPktHeader->EtherType == NET_SHORT(AA_PKT_ETHERTYPE_ARP))
{
//
// An ARP packet: we handle it ourselves
//
AA_ASSERT(BufferLength == TotalLength);
AA_IF_STAT_INCR(pInterface, InUnicastPkts);
AtmArpHandleARPPacket(
pVc,
pPktHeader,
BufferLength
);
}
else
{
//
// Discard packet -- bad EtherType
//
AADEBUGP(AAD_WARNING, ("VC: 0x%x, Pkt hdr 0x%x, bad EtherType 0x%x\n",
pVc, pPktHeader, (ULONG)pPktHeader->EtherType));
Discarded = TRUE;
AA_IF_STAT_INCR(pInterface, UnknownProtos);
}
}
else
{
#ifdef IPMCAST
Discarded = AtmArpMcProcessPacket(
pVc,
pNdisPacket,
pNdisBuffer,
pPktHeader,
TotalLength,
BufferLength
);
#else
//
// Discard packet -- bad LLC/SNAP
//
AADEBUGP(AAD_WARNING, ("VC: 0x%x, Pkt hdr 0x%x, bad LLC/SNAP\n",
pVc, pPktHeader));
Discarded = TRUE;
#endif // IPMCAST
}
}
else
{
//
// Discard packet -- too short
//
AADEBUGP(AAD_WARNING, ("VC: 0x%x, Pkt hdr 0x%x, too short: %d\n",
pVc, pPktHeader, TotalLength));
Discarded = TRUE;
}
}
else
{
//
// Discard packet -- IF down
//
AADEBUGP(AAD_WARNING, ("pInterface: 0x%x is down, discarding NDIS pkt 0x%x\n",
pInterface, pNdisPacket));
Discarded = TRUE;
}
if (Discarded)
{
AA_IF_STAT_INCR(pInterface, InDiscards);
}
return (ReturnCount);
}
VOID
AtmArpHandleARPPacket(
IN PATMARP_VC pVc,
IN PAA_PKT_LLC_SNAP_HEADER pPktHeader,
IN ULONG PacketLength
)
/*++
Routine Description:
Process a received ARP packet. We complete most of the packet checks
here, and then branch off to do different things based on the Op type
in the packet.
We do not hang on to the packet, i.e. when we return from here,
the packet is free.
Arguments:
pVc - Pointer to ATMARP VC on which packet arrived
pPktHeader - Pointer to start of packet (including LLC/SNAP)
PacketLength - Length including LLC/SNAP header
Return Value:
None
--*/
{
PATMARP_INTERFACE pInterface;
PAA_ARP_PKT_HEADER pArpHeader;
NDIS_STATUS Status;
//
// For walking down the packet
//
UCHAR UNALIGNED * pPacket;
//
// For storing pointers to the packet contents. We'll need this
// if we have to send a reply packet.
//
AA_ARP_PKT_CONTENTS ArpContents;
BOOLEAN SrcAtmBelongsToUs;
BOOLEAN SrcIPBelongsToUs;
//
// Initialize (Important: don't remove the zeroing of ArpContents)
//
AA_SET_MEM((PUCHAR)&ArpContents, 0, sizeof(AA_ARP_PKT_CONTENTS));
Status = NDIS_STATUS_SUCCESS;
pInterface = pVc->pInterface;
pArpHeader = STRUCT_OF(AA_ARP_PKT_HEADER, pPktHeader, LLCSNAPHeader);
AADEBUGP(AAD_EXTRA_LOUD+10,
("HandleARPPkt: VC 0x%x, IF 0x%x, pPktHdr 0x%x, Len %d\n",
pVc,
pInterface,
pPktHeader,
PacketLength));
do
{
if (PacketLength < AA_ARP_PKT_HEADER_LENGTH)
{
AADEBUGP(AAD_WARNING, ("HandleARPPkt: IF 0x%x, PacketLength %d < HdrLen %d\n",
pInterface, PacketLength, AA_ARP_PKT_HEADER_LENGTH));
Status = NDIS_STATUS_BUFFER_TOO_SHORT;
break;
}
if ((pArpHeader->hrd != NET_SHORT(AA_PKT_HRD)) ||
(pArpHeader->pro != NET_SHORT(AA_PKT_PRO)))
{
AADEBUGP(AAD_WARNING,
("HandleARPPkt: IF 0x%x, Bad hdr (%d != %d) or pro (%d != %d)\n",
pInterface,
pArpHeader->hrd,
AA_PKT_HRD,
pArpHeader->pro,
AA_PKT_PRO));
Status = NDIS_STATUS_NOT_RECOGNIZED;
break;
}
//
// Get at the variable part of the packet, and get pointers
// to all addresses.
//
// TBD: add more checks on ATM address lengths and combinations
// Note: we check for packet length later.
//
pPacket = pArpHeader->Variable;
//
// Source ATM Number
//
if (pArpHeader->shtl != 0)
{
ArpContents.SrcAtmNumberTypeLen = pArpHeader->shtl;
ArpContents.pSrcAtmNumber = pPacket;
pPacket += (pArpHeader->shtl & ~AA_PKT_ATM_ADDRESS_BIT);
}
//
// Source ATM Subaddress
//
if (pArpHeader->sstl != 0)
{
ArpContents.SrcAtmSubaddrTypeLen = pArpHeader->sstl;
ArpContents.pSrcAtmSubaddress = pPacket;
pPacket += (pArpHeader->sstl & ~AA_PKT_ATM_ADDRESS_BIT);
}
//
// Source IP Address. Older 1577 implementations may send an
// IP address field filled with all 0's to denote an unspecified
// IP address.
//
if (pArpHeader->spln != 0)
{
if (pArpHeader->spln != AA_IPV4_ADDRESS_LENGTH)
{
AADEBUGP(AAD_WARNING,
("HandleARPPkt: IF 0x%x, bad spln %d != %d\n",
pInterface,
pArpHeader->spln,
AA_IPV4_ADDRESS_LENGTH));
Status = NDIS_STATUS_INVALID_ADDRESS;
break;
}
if (!AtmArpIsZeroIPAddress(pPacket))
{
ArpContents.pSrcIPAddress = pPacket;
}
pPacket += AA_IPV4_ADDRESS_LENGTH;
}
//
// Target ATM Number
//
if (pArpHeader->thtl != 0)
{
ArpContents.DstAtmNumberTypeLen = pArpHeader->thtl;
ArpContents.pDstAtmNumber = pPacket;
pPacket += (pArpHeader->thtl & ~AA_PKT_ATM_ADDRESS_BIT);
}
//
// Target ATM Subaddress
//
if (pArpHeader->tstl != 0)
{
ArpContents.DstAtmSubaddrTypeLen = pArpHeader->tstl;
ArpContents.pDstAtmSubaddress = pPacket;
pPacket += (pArpHeader->tstl & ~AA_PKT_ATM_ADDRESS_BIT);
}
//
// Target IP Address [see comments for Source IP Address]
//
if (pArpHeader->tpln != 0)
{
if (pArpHeader->tpln != AA_IPV4_ADDRESS_LENGTH)
{
AADEBUGP(AAD_WARNING,
("HandleARPPkt: IF 0x%x, bad tpln %d != %d\n",
pInterface,
pArpHeader->tpln,
AA_IPV4_ADDRESS_LENGTH));
Status = NDIS_STATUS_INVALID_ADDRESS;
break;
}
if (!AtmArpIsZeroIPAddress(pPacket))
{
ArpContents.pDstIPAddress = pPacket;
}
pPacket += AA_IPV4_ADDRESS_LENGTH;
}
//
//
//
if ((ULONG)(pPacket - (PUCHAR)pArpHeader) > PacketLength)
{
AADEBUGP(AAD_WARNING,
("HandleARPPkt: IF 0x%x, pPktHdr 0x%x. Length %d TOO SMALL (want %d)\n",
pInterface,
pArpHeader,
PacketLength,
(pPacket - (PUCHAR)pArpHeader)));
Status = NDIS_STATUS_BUFFER_TOO_SHORT;
break;
}
//
// If this is an ARP NAK packet, swap Source and Target
// addresses, in preparation for what follows. This is
// because, unlike any other Reply packet where the Source
// and Target addresses get swapped, the ARP NAK
// packet is a copy of the ARP Request, with only the
// Op code changed.
//
if (NET_SHORT(pArpHeader->op) == AA_PKT_OP_TYPE_ARP_NAK)
{
UCHAR TypeLen;
UCHAR UNALIGNED * pAddress;
//
// IP Addresses:
//
pAddress = ArpContents.pSrcIPAddress;
ArpContents.pSrcIPAddress = ArpContents.pDstIPAddress;
ArpContents.pDstIPAddress = pAddress;
//
// ATM Number:
//
TypeLen = ArpContents.SrcAtmNumberTypeLen;
ArpContents.SrcAtmNumberTypeLen = ArpContents.DstAtmNumberTypeLen;
ArpContents.DstAtmNumberTypeLen = TypeLen;
pAddress = ArpContents.pSrcAtmNumber;
ArpContents.pSrcAtmNumber = ArpContents.pDstAtmNumber;
ArpContents.pDstAtmNumber = pAddress;
//
// ATM Subaddress:
//
TypeLen = ArpContents.SrcAtmSubaddrTypeLen;
ArpContents.SrcAtmSubaddrTypeLen = ArpContents.DstAtmSubaddrTypeLen;
ArpContents.DstAtmSubaddrTypeLen = TypeLen;
pAddress = ArpContents.pSrcAtmSubaddress;
ArpContents.pSrcAtmSubaddress = ArpContents.pDstAtmSubaddress;
ArpContents.pDstAtmSubaddress = pAddress;
}
SrcIPBelongsToUs = AtmArpIsLocalIPAddress(
pInterface,
ArpContents.pSrcIPAddress
);
SrcAtmBelongsToUs = AtmArpIsLocalAtmAddress(
pInterface,
ArpContents.pSrcAtmNumber,
ArpContents.SrcAtmNumberTypeLen
);
//
// Check if someone else is claiming to be the owner
// of "our" IP address:
//
if (SrcIPBelongsToUs && !SrcAtmBelongsToUs)
{
AADEBUGP(AAD_ERROR,
("Pkt 0x%x: src IP is ours, src ATM is bad!\n", pPktHeader));
AA_ACQUIRE_IF_LOCK(pInterface);
pInterface->State = IF_STATUS_DOWN;
pInterface->LastChangeTime = GetTimeTicks();
AA_RELEASE_IF_LOCK(pInterface);
AtmArpStartRegistration(pInterface);
Status = NDIS_STATUS_NOT_RECOGNIZED;
break;
}
//
// See if this is directed to someone else: if so, drop it.
//
//
// Check if the Target IP address is ours. A null IP address is
// acceptable (e.g. [In]ARP Request).
//
if ((ArpContents.pDstIPAddress != (PUCHAR)NULL) &&
!AtmArpIsLocalIPAddress(pInterface, ArpContents.pDstIPAddress))
{
//
// A target IP address is present, and it is not ours
//
AADEBUGP(AAD_WARNING,
("ArpPkt 0x%x has unknown target IP addr (%d.%d.%d.%d)\n",
pPktHeader,
ArpContents.pDstIPAddress[0],
ArpContents.pDstIPAddress[1],
ArpContents.pDstIPAddress[2],
ArpContents.pDstIPAddress[3]));
Status = NDIS_STATUS_NOT_RECOGNIZED;
break;
}
//
// If there is a Target ATM Number, check to see if it is ours.
//
if ((ArpContents.pDstAtmNumber != (PUCHAR)NULL) &&
(!AtmArpIsLocalAtmAddress(
pInterface,
ArpContents.pDstAtmNumber,
ArpContents.DstAtmNumberTypeLen))
)
{
//
// A target ATM number is present, and it is not ours
//
AADEBUGP(AAD_WARNING,
("ArpPkt 0x%x has unknown target ATM addr (0x%x, 0x%x)\n",
pPktHeader,
ArpContents.DstAtmNumberTypeLen,
ArpContents.pDstAtmNumber));
Status = NDIS_STATUS_NOT_RECOGNIZED;
break;
}
//
// Handle the various Op types
//
switch (NET_SHORT(pArpHeader->op))
{
case AA_PKT_OP_TYPE_ARP_REQUEST:
AtmArpHandleARPRequest(
pVc,
pInterface,
pArpHeader,
&ArpContents
);
break;
case AA_PKT_OP_TYPE_ARP_REPLY:
AtmArpHandleARPReply(
pVc,
pInterface,
pArpHeader,
&ArpContents,
SrcIPBelongsToUs,
SrcAtmBelongsToUs
);
break;
case AA_PKT_OP_TYPE_ARP_NAK:
AtmArpHandleARPNAK(
pVc,
pInterface,
pArpHeader,
&ArpContents
);
break;
case AA_PKT_OP_TYPE_INARP_REQUEST:
AtmArpHandleInARPRequest(
pVc,
pInterface,
pArpHeader,
&ArpContents
);
break;
case AA_PKT_OP_TYPE_INARP_REPLY:
AtmArpHandleInARPReply(
pVc,
pInterface,
pArpHeader,
&ArpContents
);
break;
default:
AADEBUGP(AAD_WARNING,
("HandleARPPkt: IF 0x%x, pArpHdr 0x%x, Op %d not known\n",
pInterface, pArpHeader, NET_SHORT(pArpHeader->op)));
Status = NDIS_STATUS_NOT_RECOGNIZED;
break;
}
}
while (FALSE);
return;
}
VOID
AtmArpHandleARPRequest(
IN PATMARP_VC pVc,
IN PATMARP_INTERFACE pInterface,
IN PAA_ARP_PKT_HEADER pArpHeader,
IN PAA_ARP_PKT_CONTENTS pArpContents
)
/*++
Routine Description:
Process a received ATMARP Request. All we need to do is send
an ATMARP Reply, since the calling routine has already verified
that the Target IP address is ours.
Arguments:
pVc - Pointer to VC on which the request arrived
pInterface - Pointer to ATMARP Interface containing this VC
pArpHeader - Pointer to ARP Header for this packet
pArpContents - Parsed contents of received ARP Request packet
Return Value:
None
--*/
{
//
// Temp locations used for swapping fields
//
UCHAR UNALIGNED * pAddress;
UCHAR Length;
//
// ARP Reply packet
//
PNDIS_PACKET pNdisPacket;
PUCHAR pArpPacket;
//
// Swap source and target addresses, and fill in our ATM info
// in the source ATM addresses fields.
//
//
// IP Addresses
//
pAddress = pArpContents->pSrcIPAddress;
pArpContents->pSrcIPAddress = pArpContents->pDstIPAddress;
pArpContents->pDstIPAddress = pAddress;
//
// ATM Numbers: set the target ATM number to the source ATM
// number, but set the source ATM number to the local ATM
// address.
//
pArpContents->pDstAtmNumber = pArpContents->pSrcAtmNumber;
pArpContents->DstAtmNumberTypeLen = pArpContents->SrcAtmNumberTypeLen;
pArpContents->pSrcAtmNumber = (pInterface->LocalAtmAddress.Address);
pArpContents->SrcAtmNumberTypeLen =
AA_PKT_ATM_ADDRESS_TO_TYPE_LEN(&(pInterface->LocalAtmAddress));
//
// ATM Subaddresses
//
pArpContents->pDstAtmSubaddress = pArpContents->pSrcAtmSubaddress;
pArpContents->DstAtmSubaddrTypeLen = pArpContents->SrcAtmSubaddrTypeLen;
pArpContents->pSrcAtmSubaddress = NULL;
pArpContents->SrcAtmSubaddrTypeLen = 0;
//
// Build the ARP Reply packet
//
pNdisPacket = AtmArpBuildARPPacket(
AA_PKT_OP_TYPE_ARP_REPLY,
pInterface,
&pArpPacket,
pArpContents
);
if (pNdisPacket != (PNDIS_PACKET)NULL)
{
//
// And send it off. Since we are in the context of a receive
// indication on this VC, we can safely access the VC now.
//
AA_ACQUIRE_VC_LOCK(pVc);
AtmArpSendPacketOnVc(pVc, pNdisPacket);
//
// The VC lock is released by SendPacketOnVc
//
}
}
VOID
AtmArpHandleARPReply(
IN PATMARP_VC pVc,
IN PATMARP_INTERFACE pInterface,
IN PAA_ARP_PKT_HEADER pArpHeader,
IN PAA_ARP_PKT_CONTENTS pArpContents,
IN BOOLEAN SrcIPAddressIsOurs,
IN BOOLEAN SrcAtmAddressIsOurs
)
/*++
Routine Description:
Process a received ATMARP Reply packet. There are two major
cases here:
(1) We were trying to register one of our IP addresses with
the server.
(2) We were trying to resolve a remote IP address.
In case (1), if we just registered the first of possibly many
IP addresses assigned to this interface, we register all the other
IP addresses.
In case (2), we set up an IP to ATM mapping and initiate a connection
if necessary.
Arguments:
pVc - Pointer to VC on which the reply arrived
pInterface - Pointer to ATMARP Interface containing this VC
pArpHeader - Pointer to ARP Header for this packet
pArpContents - Parsed contents of received ARP Request packet
SrcIPAddressIsOurs - The source IP address is one of ours
SrcAtmAddressIsOurs - The source ATM info is ours.
Return Value:
None
--*/
{
BOOLEAN TimerWasRunning;
BOOLEAN IsFirstRegistration;
PIP_ADDRESS_ENTRY pIPAddressEntry;
ULONG rc; // Ref Count
AADEBUGP(AAD_LOUD,
("Handle ARP Reply: pVc 0x%x, pIf 0x%x, IF Flags 0x%x, OurIP %d, OurATM %d\n",
pVc, pInterface, pInterface->Flags, SrcIPAddressIsOurs, SrcAtmAddressIsOurs));
AA_ACQUIRE_IF_LOCK(pInterface);
if (AA_IS_FLAG_SET(
pInterface->Flags,
AA_IF_SERVER_STATE_MASK,
AA_IF_SERVER_REGISTERING))
{
//
// We just completed registering with the server. Since we don't
// send ARP requests to resolve any other addresses while we
// are registering, the Source IP address must be ours.
//
//
// Stop the Registration timer
//
TimerWasRunning = AtmArpStopTimer(&(pInterface->Timer), pInterface);
AA_ASSERT(TimerWasRunning == TRUE);
if (TimerWasRunning)
{
rc = AtmArpDereferenceInterface(pInterface); // Timer reference
AA_ASSERT(rc > 0);
}
//
// We have already verified that the Target addresses are ours.
// Check that the source addresses are ours, too.
//
if (!SrcIPAddressIsOurs || !SrcAtmAddressIsOurs)
{
//
// Registration failure. Start recovery.
//
AtmArpHandleServerRegistrationFailure(pInterface, pVc);
//
// IF lock is released within the above.
//
}
else
{
//
// We registered an IP address successfully!
//
// Find the entry for the IP Address that we have registered,
// and mark it as registered.
//
pIPAddressEntry = &(pInterface->LocalIPAddress);
while (*((IP_ADDRESS UNALIGNED *)(pArpContents->pSrcIPAddress))
!= pIPAddressEntry->IPAddress)
{
AA_ASSERT(pIPAddressEntry->pNext != (PIP_ADDRESS_ENTRY)NULL);
pIPAddressEntry = pIPAddressEntry->pNext;
}
pIPAddressEntry->IsRegistered = TRUE;
IsFirstRegistration = pIPAddressEntry->IsFirstRegistration;
pIPAddressEntry->IsFirstRegistration = FALSE;
AADEBUGP(AAD_INFO,
("**** Registered IP Addr: %d.%d.%d.%d on IF 0x%x\n",
((PUCHAR)&(pIPAddressEntry->IPAddress))[0],
((PUCHAR)&(pIPAddressEntry->IPAddress))[1],
((PUCHAR)&(pIPAddressEntry->IPAddress))[2],
((PUCHAR)&(pIPAddressEntry->IPAddress))[3],
pInterface));
AA_SET_FLAG(
pInterface->Flags,
AA_IF_SERVER_STATE_MASK,
AA_IF_SERVER_REGISTERED);
pInterface->State = IF_STATUS_UP;
pInterface->LastChangeTime = GetTimeTicks();
//
// Start the Server refresh timer so that we send our ARP info
// to the server every so often (default = 15 minutes).
//
AtmArpStartTimer(
pInterface,
&(pInterface->Timer),
AtmArpServerRefreshTimeout,
pInterface->ServerRefreshTimeout,
(PVOID)pInterface // Context
);
AtmArpReferenceInterface(pInterface); // Timer reference
//
// If we have any more addresses to register, do so now.
//
AtmArpRegisterOtherIPAddresses(pInterface);
//
// IF Lock is freed in the above
//
#ifdef ATMARP_WMI
if (IsFirstRegistration)
{
//
// Send a WMI event, which carries the list of IP Addresses
// registered on this IF. We do this only if this is a new
// IP address.
//
AtmArpWmiSendTCIfIndication(
pInterface,
AAGID_QOS_TC_INTERFACE_UP_INDICATION,
0
);
}
#endif
}
}
else
{
//
// Resolved an IP to ATM address
//
AADEBUGP(AAD_INFO,
("ARP Reply: Resolved IP Addr: %d.%d.%d.%d\n",
((PUCHAR)(pArpContents->pSrcIPAddress))[0],
((PUCHAR)(pArpContents->pSrcIPAddress))[1],
((PUCHAR)(pArpContents->pSrcIPAddress))[2],
((PUCHAR)(pArpContents->pSrcIPAddress))[3]
));
AA_RELEASE_IF_LOCK(pInterface);
(VOID)AtmArpLearnIPToAtm(
pInterface,
(IP_ADDRESS *)pArpContents->pSrcIPAddress,
pArpContents->SrcAtmNumberTypeLen,
pArpContents->pSrcAtmNumber,
pArpContents->SrcAtmSubaddrTypeLen,
pArpContents->pSrcAtmSubaddress,
FALSE // Not a static entry
);
}
return;
}
VOID
AtmArpHandleARPNAK(
IN PATMARP_VC pVc,
IN PATMARP_INTERFACE pInterface,
IN PAA_ARP_PKT_HEADER pArpHeader,
IN PAA_ARP_PKT_CONTENTS pArpContents
)
/*++
Routine Description:
Process a received ARP-NAK packet. If this is in response to
an ARP Request we had sent to register ourselves, then we close
the VC to this ARP server, and try the next server in our list of
servers, after waiting for a while.
If we were trying to resolve a remote IP address, then we mark
the ARP IP entry corresponding to this IP address as having
received a NAK, and free any packets queued on this. We also make
a timestamp on the Entry so that we don't send another ARP Request
for the same IP address very soon.
Arguments:
pVc - Pointer to VC on which the NAK arrived
pInterface - Pointer to ATMARP Interface containing this VC
pArpHeader - Pointer to ARP Header for this packet
pArpContents - Parsed contents of received ARP Request packet
Return Value:
None
--*/
{
BOOLEAN TimerWasRunning;
ULONG rc; // Ref Count
PATMARP_IP_ENTRY pIpEntry;
PNDIS_PACKET PacketList; // Packets queued for sending
#if !BINARY_COMPATIBLE
#ifdef CUBDD
SINGLE_LIST_ENTRY PendingIrpList;
#endif // CUBDD
#endif // !BINARY_COMPATIBLE
AA_ACQUIRE_IF_LOCK(pInterface);
if (AA_IS_FLAG_SET(
pInterface->Flags,
AA_IF_SERVER_STATE_MASK,
AA_IF_SERVER_REGISTERING))
{
AADEBUGP(AAD_WARNING,
("Rcvd ARP NAK while registering: pIf 0x%x\n", pInterface));
//
// Registration was in progress, and it failed. Start recovery.
//
AtmArpHandleServerRegistrationFailure(pInterface, pVc);
//
// IF lock is released within the above.
//
}
else
{
//
// We were trying to resolve an IP address. Get the Address
// IP Entry corresponding to this IP address.
//
AA_RELEASE_IF_LOCK(pInterface);
AA_ACQUIRE_IF_TABLE_LOCK(pInterface);
pIpEntry = AtmArpSearchForIPAddress(
pInterface,
(IP_ADDRESS *)pArpContents->pSrcIPAddress,
IE_REFTYPE_TMP,
FALSE, // this isn't multicast/broadcast
FALSE // Don't create a new one
);
AA_RELEASE_IF_TABLE_LOCK(pInterface);
if (pIpEntry != NULL_PATMARP_IP_ENTRY)
{
AADEBUGP(AAD_INFO,
("Rcvd ARP NAK: pIf 0x%x, IP addr %d:%d:%d:%d\n",
pInterface,
((PUCHAR)(&(pIpEntry->IPAddress)))[0],
((PUCHAR)(&(pIpEntry->IPAddress)))[1],
((PUCHAR)(&(pIpEntry->IPAddress)))[2],
((PUCHAR)(&(pIpEntry->IPAddress)))[3]));
AA_ACQUIRE_IE_LOCK(pIpEntry);
AA_ASSERT(AA_IE_IS_ALIVE(pIpEntry));
//
// AtmArpSerchForIPAddress addrefd pIpEntry for us -- we deref it
// here now that we've locked it.
//
rc = AA_DEREF_IE(pIpEntry, IE_REFTYPE_TMP);
if (rc > 0)
{
#if !BINARY_COMPATIBLE
#ifdef CUBDD
//
// Take out the list of pending IRPs on this IP Entry.
//
PendingIrpList = pIpEntry->PendingIrpList;
pIpEntry->PendingIrpList.Next = (PSINGLE_LIST_ENTRY)NULL;
#endif // CUBDD
#endif // !BINARY_COMPATIBLE
//
// Take out all packets queued on this entry
//
PacketList = pIpEntry->PacketList;
pIpEntry->PacketList = (PNDIS_PACKET)NULL;
//
// The Address resolution timer must be running on this Entry;
// stop it.
//
TimerWasRunning = AtmArpStopTimer(&(pIpEntry->Timer), pInterface);
if (TimerWasRunning)
{
rc = AA_DEREF_IE(pIpEntry, IE_REFTYPE_TIMER); // Timer reference
}
else
{
rc = pIpEntry->RefCount;
}
}
//
// Continue only if the IP Entry hasn't gone away
//
if (rc > 0)
{
//
// Set the IP entry's state so that we don't send any
// address resolution traffic for this IP address for
// some time.
//
AA_SET_FLAG(pIpEntry->Flags,
AA_IP_ENTRY_STATE_MASK,
AA_IP_ENTRY_SEEN_NAK);
//
// Start a NAK Delay timer: until this expires, we won't
// send any ARP requests for this IP address. This makes
// sure that we don't keep pounding on the server with
// an unresolvable IP address.
//
AtmArpStartTimer(
pInterface,
&(pIpEntry->Timer),
AtmArpNakDelayTimeout,
pInterface->MinWaitAfterNak,
(PVOID)pIpEntry // Context
);
AA_REF_IE(pIpEntry, IE_REFTYPE_TIMER); // Timer ref
AA_RELEASE_IE_LOCK(pIpEntry);
}
// else the IP Entry lock would have been released.
//
// Free any packets that were queued up.
//
if (PacketList != (PNDIS_PACKET)NULL)
{
AtmArpFreeSendPackets(
pInterface,
PacketList,
FALSE // No headers on these
);
}
#if !BINARY_COMPATIBLE
#ifdef CUBDD
AtmArpCompleteArpIrpList(
PendingIrpList,
(PATM_ADDRESS)NULL
);
#endif // CUBDD
#endif // !BINARY_COMPATIBLE
}
else
{
//
// No IP Address Entry matching the IP address being
// ARP'ed for. Nothing to be done in this case.
//
}
}
return;
}
VOID
AtmArpHandleInARPRequest(
IN PATMARP_VC pVc,
IN PATMARP_INTERFACE pInterface,
IN PAA_ARP_PKT_HEADER pArpHeader,
IN PAA_ARP_PKT_CONTENTS pArpContents
)
/*++
Routine Description:
Process an InARP Request. We send back an InARP Reply packet
with our address information.
In case this is a PVC we were trying to resolve, it is possible
that we are waiting for an InARP Reply ourselves, and the remote
station came up only now. To speed up the resolution process,
we restart the InARP Wait timeout so that it expires soon, causing
another InARP Request to be sent.
Arguments:
pVc - Pointer to VC on which the request arrived
pInterface - Pointer to ATMARP Interface containing this VC
pArpHeader - Pointer to ARP Header for this packet
pArpContents - Parsed contents of received ARP Request packet
Return Value:
None
--*/
{
//
// Temp locations used for swapping fields
//
UCHAR UNALIGNED * pAddress;
UCHAR Length;
//
// ARP Reply packet
//
PNDIS_PACKET pNdisPacket;
PUCHAR pArpPacket;
//
// Copy the Source address (IP+ATM) info into the Target address
// fields, and fill in the Source info fields with our IP+ATM info.
//
//
// IP Addresses:
//
pArpContents->pDstIPAddress = pArpContents->pSrcIPAddress;
pArpContents->pSrcIPAddress = (PUCHAR)&(pInterface->LocalIPAddress.IPAddress);
//
// ATM Numbers: set the target ATM number to the source ATM
// number, but set the source ATM number to the local ATM
// address.
//
pArpContents->pDstAtmNumber = pArpContents->pSrcAtmNumber;
pArpContents->DstAtmNumberTypeLen = pArpContents->SrcAtmNumberTypeLen;
pArpContents->pSrcAtmNumber = (pInterface->LocalAtmAddress.Address);
pArpContents->SrcAtmNumberTypeLen =
AA_PKT_ATM_ADDRESS_TO_TYPE_LEN(&(pInterface->LocalAtmAddress));
//
// ATM Subaddresses
//
pArpContents->pDstAtmSubaddress = pArpContents->pSrcAtmSubaddress;
pArpContents->DstAtmSubaddrTypeLen = pArpContents->SrcAtmSubaddrTypeLen;
pArpContents->pSrcAtmSubaddress = NULL;
pArpContents->SrcAtmSubaddrTypeLen = 0;
//
// Build the InARP Reply packet
//
pNdisPacket = AtmArpBuildARPPacket(
AA_PKT_OP_TYPE_INARP_REPLY,
pInterface,
&pArpPacket,
pArpContents
);
if (pNdisPacket != (PNDIS_PACKET)NULL)
{
//
// Before we send it off, check if this is a PVC being InARP'ed.
// If so, restart the InARP Wait timer so that it expires soon.
//
// It is also possible that this PVC was once resolved, but
// the remote end had gone away long enough for us to age out
// the corresponding IP entry. This packet might be due to the
// remote end coming back up. Start off an Inverse ARP operation
// to get our end of the PVC re-resolved.
//
AA_ACQUIRE_VC_LOCK(pVc);
if (AA_IS_FLAG_SET(
pVc->Flags,
AA_VC_TYPE_MASK,
AA_VC_TYPE_PVC) &&
(AA_IS_FLAG_SET(
pVc->Flags,
AA_VC_ARP_STATE_MASK,
AA_VC_INARP_IN_PROGRESS) ||
((pVc->pAtmEntry != NULL_PATMARP_ATM_ENTRY) &&
(pVc->pAtmEntry->pIpEntryList == NULL_PATMARP_IP_ENTRY))))
{
BOOLEAN TimerWasRunning;
#if DBG
if ((pVc->pAtmEntry != NULL_PATMARP_ATM_ENTRY) &&
(pVc->pAtmEntry->pIpEntryList == NULL_PATMARP_IP_ENTRY))
{
AADEBUGP(AAD_LOUD,
("InARPReq: PVC %p, AtmEntry %p has NULL IP Entry, will InARP again!\n",
pVc, pVc->pAtmEntry));
}
#endif
AA_SET_FLAG(pVc->Flags,
AA_VC_ARP_STATE_MASK,
AA_VC_INARP_IN_PROGRESS);
//
// Stop the currently running InARP Wait timer
//
TimerWasRunning = AtmArpStopTimer(&(pVc->Timer), pInterface);
//
// Start it again, to fire in 1 second
//
AtmArpStartTimer(
pInterface,
&(pVc->Timer),
AtmArpPVCInARPWaitTimeout,
1,
(PVOID)pVc // Context
);
if (!TimerWasRunning)
{
AtmArpReferenceVc(pVc); // Timer reference
}
}
AtmArpSendPacketOnVc(pVc, pNdisPacket);
//
// The VC lock is released by SendPacketOnVc
//
}
}
VOID
AtmArpHandleInARPReply(
IN PATMARP_VC pVc,
IN PATMARP_INTERFACE pInterface,
IN PAA_ARP_PKT_HEADER pArpHeader,
IN PAA_ARP_PKT_CONTENTS pArpContents
)
/*++
Routine Description:
Process an InARP Reply packet, which should be a response to an InARP
Request we sent earlier.
There are two circumstances under which we send InARP Requests:
(1) To obtain the addresses at the other end of a PVC.
(2) In the process of revalidating an IP Address, if we aren't able
to contact the server AND a VC exists to this IP address, we send
an InARP Request to revalidate the IP entry.
In Case (1), we link the PVC to an ATM Address Entry. In Case (2),
we mark the IP entry for this VC as being "resolved", and start
data transfer to this IP address.
Arguments:
pVc - Pointer to ATMARP VC on which this packet arrived
pInterface - Pointer to ATMARP Interface
pArpHeader - Pointer to ARP Header for this packet
pArpContents - Parsed contents of received ARP Request packet
Return Value:
None
--*/
{
PATMARP_ATM_ENTRY pAtmEntry; // ATM entry to which this VC is linked
PATMARP_IP_ENTRY pIpEntry; // IP address entry
BOOLEAN TimerWasRunning;
PATMARP_VC * ppVc; // Used to unlink VC from unresolved list
ULONG rc; // Ref Count
PNDIS_PACKET PacketList; // Packets queued for sending
BOOLEAN IsBroadcast; // Is the IP Addr a broadcast/Class D addr?
if (pArpContents->pSrcIPAddress == NULL)
{
AADEBUGP(AAD_WARNING,
("HandleInARPReply: IF %x, Null source address, discarding pkt\n", pInterface));
return;
}
AADEBUGP(AAD_INFO,
("HandleInARPReply: IF %x, IP addr %d.%d.%d.%d\n",
pInterface,
((PUCHAR)pArpContents->pSrcIPAddress)[0],
((PUCHAR)pArpContents->pSrcIPAddress)[1],
((PUCHAR)pArpContents->pSrcIPAddress)[2],
((PUCHAR)pArpContents->pSrcIPAddress)[3]));
//
// Update our ARP cache with this information (regardless of whether
// this is a PVC or SVC).
//
pIpEntry = AtmArpLearnIPToAtm(
pInterface,
(PIP_ADDRESS)pArpContents->pSrcIPAddress,
pArpContents->SrcAtmNumberTypeLen,
pArpContents->pSrcAtmNumber,
pArpContents->SrcAtmSubaddrTypeLen,
pArpContents->pSrcAtmSubaddress,
FALSE // Not a static entry
);
//
// Acquire the locks that we need, in an ordered fashion...
//
AA_ACQUIRE_IF_LOCK(pInterface);
if (pIpEntry != NULL_PATMARP_IP_ENTRY)
{
AA_ACQUIRE_IE_LOCK_DPC(pIpEntry);
AA_ASSERT(AA_IE_IS_ALIVE(pIpEntry));
pAtmEntry = pIpEntry->pAtmEntry;
if (pAtmEntry != NULL_PATMARP_ATM_ENTRY)
{
AA_ACQUIRE_AE_LOCK_DPC(pAtmEntry);
}
}
else
{
pAtmEntry = NULL_PATMARP_ATM_ENTRY;
}
AA_ACQUIRE_VC_LOCK_DPC(pVc);
if (AA_IS_FLAG_SET(
pVc->Flags,
AA_VC_TYPE_MASK,
AA_VC_TYPE_PVC) &&
(pVc->pAtmEntry == NULL_PATMARP_ATM_ENTRY) )
{
//
// This is an unresolved PVC, whose remote address info
// we were trying to InARP for.
//
//
// Stop the InARP Wait timer running on this VC
//
TimerWasRunning = AtmArpStopTimer(&(pVc->Timer), pInterface);
AA_ASSERT(TimerWasRunning == TRUE);
if (TimerWasRunning)
{
rc = AtmArpDereferenceVc(pVc); // Timer reference
}
else
{
rc = pVc->RefCount;
}
//
// Do the rest only if the VC hasn't gone away.
//
if (rc != 0)
{
AA_SET_FLAG(
pVc->Flags,
AA_VC_ARP_STATE_MASK,
AA_VC_ARP_STATE_IDLE);
if (pAtmEntry != NULL_PATMARP_ATM_ENTRY)
{
//
// We are all set now. Take the VC out of the list of
// unresolved VCs on this Interface, and put it in the
// list of VCs attached to this ATM Entry.
//
// NOTE: we don't dereference the VC because we are just
// moving it from one list (Unresolved VCs) to another
// (ATM Entry's VC list).
//
ppVc = &(pInterface->pUnresolvedVcs);
while (*ppVc != pVc)
{
AA_ASSERT(*ppVc != NULL_PATMARP_VC);
ppVc = &((*ppVc)->pNextVc);
}
*ppVc = pVc->pNextVc;
AtmArpLinkVcToAtmEntry(pVc, pAtmEntry);
}
else
{
//
// No matching ATM Entry.
//
// We are really low on resources if we are here.
// Start the InARP Wait timer; when it fires, we'll try to
// send another InARP Request to resolve this VC.
//
AADEBUGP(AAD_FATAL,
("HandleInARPReply: no matching ATM entry: pInterface %x, pVc %x, pIpEntry %x\n",
pInterface,
pVc,
pIpEntry));
AA_ASSERT(FALSE);
AtmArpStartTimer(
pInterface,
&(pVc->Timer),
AtmArpPVCInARPWaitTimeout,
pInterface->InARPWaitTimeout,
(PVOID)pVc // Context
);
AtmArpReferenceVc(pVc); // InARP Timer ref
}
AA_RELEASE_VC_LOCK_DPC(pVc);
}
else
{
//
// The VC went away while we were InARPing
//
}
//
// Release any locks that we still hold.
//
if (pIpEntry != NULL_PATMARP_IP_ENTRY)
{
if (pAtmEntry != NULL_PATMARP_ATM_ENTRY)
{
AA_RELEASE_AE_LOCK_DPC(pAtmEntry);
}
AA_RELEASE_IE_LOCK_DPC(pIpEntry);
}
AA_RELEASE_IF_LOCK(pInterface);
}
else
{
//
// Revalidating on a PVC/SVC: case (2) in Routine Description
//
AA_SET_FLAG(
pVc->Flags,
AA_VC_ARP_STATE_MASK,
AA_VC_ARP_STATE_IDLE);
//
// Stop the INARP timer, if it is running.
//
TimerWasRunning = AtmArpStopTimer(&pVc->Timer, pInterface);
if (TimerWasRunning)
{
rc = AtmArpDereferenceVc(pVc); // InARP reply: stop InARP timer
}
else
{
rc = pVc->RefCount;
}
if (rc != 0)
{
AA_RELEASE_VC_LOCK_DPC(pVc);
}
//
// Update the IP Entry we were revaldating.
//
if (pIpEntry != NULL_PATMARP_IP_ENTRY)
{
//
// Stop the InARP timer running here
//
TimerWasRunning = AtmArpStopTimer(&(pIpEntry->Timer), pInterface);
if (TimerWasRunning)
{
rc = AA_DEREF_IE(pIpEntry, IE_REFTYPE_TIMER); // timer ref
}
else
{
rc = pIpEntry->RefCount;
}
//
// Continue only if the IP Entry hasn't gone away.
//
if (rc > 0)
{
//
// Update its state
//
AA_SET_FLAG(
pIpEntry->Flags,
AA_IP_ENTRY_STATE_MASK,
AA_IP_ENTRY_RESOLVED
);
AADEBUGP(AAD_INFO,
("InARP Reply: Revalidated pIpEntry 0x%x, IP Addr: %d.%d.%d.%d\n",
pIpEntry,
((PUCHAR)(&(pIpEntry->IPAddress)))[0],
((PUCHAR)(&(pIpEntry->IPAddress)))[1],
((PUCHAR)(&(pIpEntry->IPAddress)))[2],
((PUCHAR)(&(pIpEntry->IPAddress)))[3]
));
AA_ASSERT(pAtmEntry != NULL_PATMARP_ATM_ENTRY);
//
// Start the Aging timer.
//
AtmArpStartTimer(
pInterface,
&(pIpEntry->Timer),
AtmArpIPEntryAgingTimeout,
pInterface->ARPEntryAgingTimeout,
(PVOID)pIpEntry
);
AA_REF_IE(pIpEntry, IE_REFTYPE_TIMER); // Timer ref
//
// Take out the list of pending packets on this Entry
//
PacketList = pIpEntry->PacketList;
pIpEntry->PacketList = (PNDIS_PACKET)NULL;
IsBroadcast = AA_IS_FLAG_SET(pIpEntry->Flags,
AA_IP_ENTRY_ADDR_TYPE_MASK,
AA_IP_ENTRY_ADDR_TYPE_NUCAST);
AA_RELEASE_AE_LOCK_DPC(pAtmEntry);
AA_RELEASE_IE_LOCK_DPC(pIpEntry);
AA_RELEASE_IF_LOCK(pInterface);
//
// Send out all these packets
//
AtmArpSendPacketListOnAtmEntry(
pInterface,
pAtmEntry,
PacketList,
IsBroadcast
);
}
else
{
//
// the IP Entry is gone
//
AA_RELEASE_AE_LOCK_DPC(pAtmEntry);
AA_RELEASE_IF_LOCK(pInterface);
}
}
else
{
//
// No matching IP Entry
//
AA_RELEASE_IF_LOCK(pInterface);
}
}
return;
}
Reference in a new issue Copy permalink