3114 lines
86 KiB
C
3114 lines
86 KiB
C
/*++
|
|
|
|
Copyright (c) 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
eth.c
|
|
|
|
Abstract:
|
|
|
|
ARP1394 Ethernet emulation-related handlers.
|
|
|
|
Revision History:
|
|
|
|
Who When What
|
|
-------- -------- ----------------------------------------------
|
|
josephj 11-22-99 Created
|
|
Adube 10-2000 Added Bridging
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
#include <precomp.h>
|
|
|
|
//
|
|
// File-specific debugging defaults.
|
|
//
|
|
#define TM_CURRENT TM_ETH
|
|
|
|
|
|
UINT Arp1394ToIcs = 0;
|
|
|
|
//=========================================================================
|
|
// L O C A L P R O T O T Y P E S
|
|
//=========================================================================
|
|
|
|
|
|
// These are ethernet arp specific constants
|
|
//
|
|
#define ARP_ETH_ETYPE_IP 0x800
|
|
#define ARP_ETH_ETYPE_ARP 0x806
|
|
#define ARP_ETH_REQUEST 1
|
|
#define ARP_ETH_RESPONSE 2
|
|
#define ARP_ETH_HW_ENET 1
|
|
#define ARP_ETH_HW_802 6
|
|
|
|
|
|
//
|
|
// Check whether an address is multicast
|
|
//
|
|
#define ETH_IS_MULTICAST(Address) \
|
|
(BOOLEAN)(((PUCHAR)(Address))[0] & ((UCHAR)0x01))
|
|
|
|
|
|
//
|
|
// Check whether an address is broadcast.
|
|
//
|
|
#define ETH_IS_BROADCAST(Address) \
|
|
((((PUCHAR)(Address))[0] == ((UCHAR)0xff)) && (((PUCHAR)(Address))[1] == ((UCHAR)0xff)))
|
|
|
|
|
|
#pragma pack (push, 1)
|
|
|
|
//* Structure of an Ethernet header (taken from ip\arpdef.h).
|
|
typedef struct ENetHeader {
|
|
ENetAddr eh_daddr;
|
|
ENetAddr eh_saddr;
|
|
USHORT eh_type;
|
|
} ENetHeader;
|
|
|
|
const ENetAddr BroadcastENetAddr =
|
|
{
|
|
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
|
|
};
|
|
|
|
// Following is a template for creating Ethernet Multicast addresses
|
|
// from ip multicast addresses.
|
|
// The last 3 bytes are the last 3 bytes (network byte order) of the mcast
|
|
// address.
|
|
//
|
|
const ENetAddr MulticastENetAddr =
|
|
{
|
|
{0x01,0x00,0x5E,0x00, 0x00, 0x00}
|
|
};
|
|
|
|
//
|
|
// This is the Ethernet address to which the bridge sends STA packets.
|
|
// STA packets are used by the bridge to detect loops
|
|
//
|
|
|
|
// Size of a basic UDP header
|
|
#define SIZE_OF_UDP_HEADER 8 // bytes
|
|
|
|
// Minimum size of the payload of a BOOTP packet
|
|
#define SIZE_OF_BASIC_BOOTP_PACKET 236 // bytes
|
|
|
|
|
|
// The UDP IP protocol type
|
|
#define UDP_PROTOCOL 0x11
|
|
|
|
// Size of Ethernet header
|
|
#define ETHERNET_HEADER_SIZE (ETH_LENGTH_OF_ADDRESS * 2 ) + 2
|
|
|
|
|
|
|
|
UCHAR gSTAMacAddr[ETH_LENGTH_OF_ADDRESS] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x00 };
|
|
|
|
#define NIC1394_ETHERTYPE_STA 0x777
|
|
const
|
|
NIC1394_ENCAPSULATION_HEADER
|
|
Arp1394_StaEncapHeader =
|
|
{
|
|
0x0000, // Reserved
|
|
H2N_USHORT(NIC1394_ETHERTYPE_STA)
|
|
};
|
|
|
|
// Structure of an Ethernet ARP packet.
|
|
//
|
|
typedef struct {
|
|
ENetHeader header;
|
|
USHORT hardware_type;
|
|
USHORT protocol_type;
|
|
UCHAR hw_addr_len;
|
|
UCHAR IP_addr_len;
|
|
USHORT opcode; // Opcode.
|
|
ENetAddr sender_hw_address;
|
|
IP_ADDRESS sender_IP_address;
|
|
ENetAddr target_hw_address;
|
|
IP_ADDRESS target_IP_address;
|
|
|
|
} ETH_ARP_PKT, *PETH_ARP_PKT;
|
|
|
|
#pragma pack (pop)
|
|
|
|
// Parsed version of an ethernet ARP packet.
|
|
//
|
|
typedef struct {
|
|
|
|
ENetAddr SourceEthAddress; // Ethernet source h/w address.
|
|
ENetAddr DestEthAddress; // Ethernet source h/w address.
|
|
|
|
UINT OpCode; // ARP_ETH_REQUEST/RESPONSE
|
|
|
|
ENetAddr SenderEthAddress; // Ethernet source h/w address.
|
|
IP_ADDRESS SenderIpAddress; // IP source address
|
|
|
|
ENetAddr TargetEthAddress; // Ethernet destination h/w address.
|
|
IP_ADDRESS TargetIpAddress; // IP target address
|
|
|
|
} ETH_ARP_PKT_INFO, *PETH_ARP_PKT_INFO;
|
|
|
|
|
|
|
|
|
|
#define ARP_FAKE_ETH_ADDRESS(_AdapterNum) \
|
|
{ \
|
|
0x02 | (((UCHAR)(_AdapterNum) & 0x3f) << 2), \
|
|
((UCHAR)(_AdapterNum) & 0x3f), \
|
|
0,0,0,0 \
|
|
}
|
|
|
|
#define ARP_DEF_REMOTE_ETH_ADDRESS \
|
|
ARP_FAKE_ETH_ADDRESS(0xf)
|
|
|
|
|
|
#define ARP_IS_BOOTP_REQUEST(_pData) (_pData[0] == 0x1) // Byte 0 is the operation; 1 for a request, 2 for a reply
|
|
#define ARP_IS_BOOTP_RESPONSE(_pData) (_pData[0] == 0x2) // Byte 0 is the operation; 1 for a request, 2 for a reply
|
|
|
|
|
|
typedef struct _ARP_BOOTP_INFO
|
|
{
|
|
|
|
ULONG Xid;
|
|
|
|
BOOLEAN bIsRequest;
|
|
|
|
ENetAddr requestorMAC;
|
|
|
|
|
|
} ARP_BOOTP_INFO , *PARP_BOOTP_INFO;
|
|
|
|
|
|
|
|
|
|
NDIS_STATUS
|
|
arpIcsTranslateIpPkt(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PNDIS_PACKET pOrigPkt,
|
|
IN ARP_ICS_FORWARD_DIRECTION Direction,
|
|
IN MYBOOL fUnicast,
|
|
OUT PNDIS_PACKET *ppNewPkt,
|
|
OUT PREMOTE_DEST_KEY pDestAddress, // OPTIONAL
|
|
PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
NDIS_STATUS
|
|
arpGetEthHeaderFrom1394IpPkt(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PVOID pvData,
|
|
IN UINT cbData,
|
|
IN MYBOOL fUnicast,
|
|
OUT ENetHeader *pEthHdr,
|
|
OUT PIP_ADDRESS pDestIpAddress, // OPTIONAL
|
|
PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
NDIS_STATUS
|
|
arpGet1394HeaderFromEthIpPkt(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PNDIS_BUFFER pFirstBuffer,
|
|
IN PVOID pvData,
|
|
IN UINT cbData,
|
|
IN MYBOOL fUnicast,
|
|
OUT NIC1394_ENCAPSULATION_HEADER
|
|
*p1394Hdr,
|
|
OUT PREMOTE_DEST_KEY pDestIpAddress, // OPTIONAL
|
|
PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
NDIS_STATUS
|
|
arpGetEthAddrFromIpAddr(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN MYBOOL fUnicast,
|
|
IN IP_ADDRESS DestIpAddress,
|
|
OUT ENetAddr *pEthAddr,
|
|
PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
NDIS_STATUS
|
|
arpParseEthArpPkt(
|
|
IN PETH_ARP_PKT pArpPkt,
|
|
IN UINT cbBufferSize,
|
|
OUT PETH_ARP_PKT_INFO pPktInfo
|
|
);
|
|
|
|
VOID
|
|
arpPrepareEthArpPkt(
|
|
IN PETH_ARP_PKT_INFO pPktInfo,
|
|
OUT PETH_ARP_PKT pArpPkt
|
|
);
|
|
|
|
MYBOOL
|
|
arpIsUnicastEthDest(
|
|
IN UNALIGNED ENetHeader *pEthHdr
|
|
);
|
|
|
|
VOID
|
|
arpEthProcess1394ArpPkt(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PIP1394_ARP_PKT pArpPkt,
|
|
IN UINT HeaderSize
|
|
);
|
|
|
|
VOID
|
|
arpEthProcessEthArpPkt(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PETH_ARP_PKT pArpPkt,
|
|
IN UINT HeaderSize
|
|
);
|
|
|
|
NDIS_STATUS
|
|
arpConstructEthArpInfoFrom1394ArpInfo(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PIP1394_ARP_PKT_INFO p1394PktInfo,
|
|
OUT PETH_ARP_PKT_INFO pEthPktInfo,
|
|
PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
NDIS_STATUS
|
|
arpConstruct1394ArpInfoFromEthArpInfo(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PETH_ARP_PKT_INFO pEthPktInfo,
|
|
OUT PIP1394_ARP_PKT_INFO p1394PktInfo,
|
|
PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
VOID
|
|
arpIcsForwardIpPacket(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PNDIS_PACKET pPacket,
|
|
IN ARP_ICS_FORWARD_DIRECTION Direction,
|
|
IN MYBOOL fUnicast,
|
|
IN PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
NDIS_STATUS
|
|
arpGetSourceMacAddressFor1394Pkt (
|
|
IN PARP1394_ADAPTER pAdapter,
|
|
IN UCHAR SourceNodeAddress,
|
|
IN BOOLEAN fIsValidSourceNodeAddress,
|
|
OUT ENetAddr* pSourceMacAddress,
|
|
PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
NDIS_STATUS
|
|
arpEthConstructSTAEthHeader(
|
|
IN PUCHAR pvData,
|
|
IN UINT cbData,
|
|
OUT ENetHeader *pEthHdr
|
|
);
|
|
|
|
NDIS_STATUS
|
|
arpEthModifyBootPPacket(
|
|
IN PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT
|
|
IN ARP_ICS_FORWARD_DIRECTION Direction,
|
|
IN PREMOTE_DEST_KEY pDestAddress, // OPTIONAL
|
|
IN PUCHAR pucNewData,
|
|
IN ULONG PacketLength,
|
|
IN PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
BOOLEAN
|
|
arpEthPreprocessBootPPacket(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PUCHAR pPacketData,
|
|
IN PUCHAR pBootPData, // Actual BOOTP packet
|
|
OUT PBOOLEAN pbIsRequest,
|
|
PARP_BOOTP_INFO pInfoBootP,
|
|
PRM_STACK_RECORD pSR
|
|
);
|
|
|
|
|
|
VOID
|
|
arpIcsForwardIpPacket(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PNDIS_PACKET pPacket,
|
|
IN ARP_ICS_FORWARD_DIRECTION Direction,
|
|
IN MYBOOL fUnicast,
|
|
IN PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Forward a packet from the ip/1394 side to the ethernet side, or vice-versa.
|
|
|
|
Arguments:
|
|
|
|
|
|
--*/
|
|
{
|
|
NDIS_STATUS Status;
|
|
PNDIS_PACKET pNewPkt = NULL;
|
|
ENTER("arpIcsForwardIpPacket", 0x98630e8f)
|
|
|
|
do
|
|
{
|
|
PARPCB_DEST pDest = NULL;
|
|
|
|
//
|
|
// Create the translated packet.
|
|
//
|
|
Status = arpIcsTranslateIpPkt(
|
|
pIF,
|
|
pPacket,
|
|
Direction,
|
|
fUnicast,
|
|
&pNewPkt,
|
|
NULL, // Optional pIpDestAddr
|
|
pSR
|
|
);
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
if (Status == NDIS_STATUS_ALREADY_MAPPED)
|
|
{
|
|
//
|
|
// This is a loop-backed packet.
|
|
//
|
|
arpEthReceivePacket(
|
|
pIF,
|
|
pPacket
|
|
);
|
|
}
|
|
pNewPkt = NULL;
|
|
break;
|
|
}
|
|
|
|
// We special case unicast sends to 1394, because that requires
|
|
// special treatment: we need to lookup the destination and if
|
|
// required create a VC to that destination. This
|
|
// is done elsewhere (in arpEthernetReceivePacket), so we assert
|
|
// we never get this this case.
|
|
//
|
|
ASSERT(!(Direction == ARP_ICS_FORWARD_TO_1394 && fUnicast))
|
|
|
|
|
|
ARP_FASTREADLOCK_IF_SEND_LOCK(pIF);
|
|
|
|
//
|
|
// Determine destination
|
|
//
|
|
if (Direction == ARP_ICS_FORWARD_TO_1394)
|
|
{
|
|
pDest = pIF->pBroadcastDest;
|
|
}
|
|
else
|
|
{
|
|
ASSERT(Direction == ARP_ICS_FORWARD_TO_ETHERNET);
|
|
pDest = pIF->pEthernetDest;
|
|
};
|
|
|
|
arpSendControlPkt(
|
|
pIF, // LOCKIN NOLOCKOUT (IF send lk)
|
|
pNewPkt,
|
|
pDest,
|
|
pSR
|
|
);
|
|
|
|
} while (FALSE);
|
|
|
|
EXIT()
|
|
|
|
}
|
|
|
|
|
|
NDIS_STATUS
|
|
arpIcsTranslateIpPkt(
|
|
IN PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT
|
|
IN PNDIS_PACKET pOrigPkt,
|
|
IN ARP_ICS_FORWARD_DIRECTION Direction,
|
|
IN MYBOOL fUnicast,
|
|
OUT PNDIS_PACKET *ppNewPkt,
|
|
OUT PREMOTE_DEST_KEY pDestAddress, // OPTIONAL
|
|
PRM_STACK_RECORD pSR
|
|
)
|
|
{
|
|
|
|
NDIS_STATUS Status;
|
|
PNDIS_PACKET pNewPkt = NULL;
|
|
PVOID pvNewData = NULL;
|
|
|
|
|
|
do
|
|
{
|
|
PNDIS_BUFFER pOrigBuf = NULL;
|
|
PVOID pvOrigData = NULL;
|
|
UINT OrigBufSize;
|
|
PVOID pvNewHdr = NULL;
|
|
UINT OrigHdrSize;
|
|
UINT NewHdrSize;
|
|
UINT OrigPktSize;
|
|
UINT NewPktSize;
|
|
UINT BytesCopied;
|
|
NIC1394_ENCAPSULATION_HEADER
|
|
Nic1394Hdr;
|
|
ENetHeader EthHdr;
|
|
|
|
|
|
// Get size of 1st buffer and pointer to it's data.
|
|
// (We only bother about the 1st buffer)
|
|
//
|
|
NdisQueryPacket(
|
|
pOrigPkt,
|
|
NULL,
|
|
NULL,
|
|
&pOrigBuf,
|
|
&OrigPktSize
|
|
);
|
|
|
|
|
|
if (OrigPktSize > 0)
|
|
{
|
|
NdisQueryBuffer(
|
|
pOrigBuf,
|
|
&pvOrigData,
|
|
&OrigBufSize
|
|
);
|
|
}
|
|
else
|
|
{
|
|
OrigBufSize = 0;
|
|
}
|
|
|
|
if (pvOrigData == NULL)
|
|
{
|
|
Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
// Compute direction-specific information
|
|
//
|
|
if(Direction == ARP_ICS_FORWARD_TO_1394)
|
|
{
|
|
OrigHdrSize = sizeof(EthHdr);
|
|
NewHdrSize = sizeof(Nic1394Hdr);
|
|
|
|
Status = arpGet1394HeaderFromEthIpPkt(
|
|
pIF,
|
|
pOrigBuf,
|
|
pvOrigData,
|
|
OrigBufSize,
|
|
fUnicast,
|
|
&Nic1394Hdr,
|
|
pDestAddress,
|
|
pSR
|
|
);
|
|
pvNewHdr = (PVOID) &Nic1394Hdr;
|
|
}
|
|
else
|
|
{
|
|
ASSERT(Direction==ARP_ICS_FORWARD_TO_ETHERNET);
|
|
OrigHdrSize = sizeof(Nic1394Hdr);
|
|
NewHdrSize = sizeof(EthHdr);
|
|
|
|
Status = arpGetEthHeaderFrom1394IpPkt(
|
|
pIF,
|
|
pvOrigData,
|
|
OrigBufSize,
|
|
fUnicast,
|
|
&EthHdr,
|
|
&pDestAddress->IpAddress,
|
|
pSR
|
|
);
|
|
|
|
pvNewHdr = (PVOID) &EthHdr;
|
|
|
|
};
|
|
|
|
if (FAIL(Status)) break;
|
|
|
|
|
|
|
|
// Make sure the 1st buffer contains enough data for the header.
|
|
//
|
|
if (OrigBufSize < OrigHdrSize)
|
|
{
|
|
ASSERT(FALSE); // We should check why we're getting
|
|
// this kind of tiny 1st buffer.
|
|
Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
// Compute the new packet size.
|
|
//
|
|
NewPktSize = OrigPktSize - OrigHdrSize + NewHdrSize;
|
|
|
|
// Allocate an appropriately sized control packet.
|
|
//
|
|
Status = arpAllocateControlPacket(
|
|
pIF,
|
|
NewPktSize,
|
|
ARP1394_PACKET_FLAGS_ICS,
|
|
&pNewPkt,
|
|
&pvNewData,
|
|
pSR
|
|
);
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
ASSERT(FALSE); // we want to know if we hit this in regular use.
|
|
pNewPkt = NULL;
|
|
break;
|
|
}
|
|
|
|
// Copy over the new header.
|
|
//
|
|
NdisMoveMemory(pvNewData, pvNewHdr, NewHdrSize);
|
|
|
|
// Copy the rest of the packet contents.
|
|
//
|
|
NdisCopyFromPacketToPacket(
|
|
pNewPkt, // Dest pkt
|
|
NewHdrSize, // Dest offset
|
|
OrigPktSize - OrigHdrSize, // BytesToCopy
|
|
pOrigPkt, // Source,
|
|
OrigHdrSize, // SourceOffset
|
|
&BytesCopied
|
|
);
|
|
if (BytesCopied != (OrigPktSize - OrigHdrSize))
|
|
{
|
|
ASSERT(FALSE); // Should never get here.
|
|
Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
|
|
// Add the Bootp code here.
|
|
Status = arpEthModifyBootPPacket(pIF,
|
|
Direction,
|
|
pDestAddress,
|
|
(PUCHAR)pvNewData,
|
|
NewPktSize ,
|
|
pSR);
|
|
|
|
if (Status != NDIS_STATUS_SUCCESS)
|
|
{
|
|
ASSERT (!"TempAssert -arpEthModifyBootPPacket FAILED");
|
|
break;
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
if (FAIL(Status) && pNewPkt != NULL)
|
|
{
|
|
arpFreeControlPacket(
|
|
pIF,
|
|
pNewPkt,
|
|
pSR
|
|
);
|
|
|
|
*ppNewPkt = NULL;
|
|
}
|
|
else
|
|
{
|
|
*ppNewPkt = pNewPkt;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NDIS_STATUS
|
|
arpGetEthHeaderFrom1394IpPkt(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PVOID pvData,
|
|
IN UINT cbData,
|
|
IN MYBOOL fUnicast,
|
|
OUT ENetHeader *pEthHdr,
|
|
OUT PIP_ADDRESS pDestIpAddress, // OPTIONAL
|
|
PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
Return a fully filled ethernet header, with source and estination
|
|
MAC addresses and ethertype set to IP.
|
|
|
|
The source address is always the local adapter's MAC address.
|
|
|
|
The destination address is set by calling arpGetEthAddrFromIpAddr
|
|
|
|
|
|
--*/
|
|
{
|
|
ENTER("arpGetEthHeaderFrom1394IpPkt", 0x0)
|
|
static
|
|
ENetHeader
|
|
StaticEthernetHeader =
|
|
{
|
|
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, // eh_daddr == BCAST
|
|
ARP_DEF_REMOTE_ETH_ADDRESS,
|
|
H2N_USHORT(NIC1394_ETHERTYPE_IP) // eh_type
|
|
};
|
|
|
|
ARP1394_ADAPTER * pAdapter;
|
|
BOOLEAN fBridgeMode;
|
|
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
|
|
|
|
PNDIS1394_UNFRAGMENTED_HEADER pHeader = (PNDIS1394_UNFRAGMENTED_HEADER)pvData;
|
|
|
|
pAdapter = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
|
|
fBridgeMode = ARP_BRIDGE_ENABLED(pAdapter);
|
|
|
|
do
|
|
{
|
|
UNALIGNED IPHeader *pIpHdr;
|
|
IP_ADDRESS IpDest;
|
|
|
|
if (cbData < (sizeof(NIC1394_ENCAPSULATION_HEADER) + sizeof(IPHeader)))
|
|
{
|
|
//
|
|
// Packet is too small.
|
|
//
|
|
TR_INFO(("Discarding packet because pkt too small\n"));
|
|
break;
|
|
}
|
|
pIpHdr = (UNALIGNED IPHeader*)
|
|
(((PUCHAR) pvData)+sizeof(NIC1394_ENCAPSULATION_HEADER));
|
|
IpDest = pIpHdr->iph_dest;
|
|
|
|
if (pDestIpAddress != NULL)
|
|
{
|
|
*pDestIpAddress = IpDest;
|
|
}
|
|
|
|
|
|
if (!fBridgeMode)
|
|
{
|
|
//
|
|
// TODO: we currently return a hardcoded ethernet address.
|
|
// Need to constuct one by looking into the actual IP packet data.
|
|
//
|
|
*pEthHdr = StaticEthernetHeader;
|
|
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Following is specific to BRIDGE mode
|
|
//
|
|
|
|
|
|
// Always set the source address according to the sender.
|
|
//
|
|
{
|
|
ENetAddr SourceMacAddress;
|
|
|
|
Status = \
|
|
arpGetSourceMacAddressFor1394Pkt (pAdapter,
|
|
pHeader->u1.SourceAddress,
|
|
pHeader->u1.fHeaderHasSourceAddress,
|
|
&SourceMacAddress,
|
|
pSR);
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
break;
|
|
}
|
|
|
|
pEthHdr->eh_saddr = SourceMacAddress ;
|
|
|
|
}
|
|
|
|
//
|
|
// If we have a STA packet then construct the STA Header
|
|
// or else construct the sender/destination specific Ethernet
|
|
// Header
|
|
//
|
|
{
|
|
|
|
if (pHeader->u1.EtherType == N2H_USHORT(NIC1394_ETHERTYPE_STA) )
|
|
{
|
|
arpEthConstructSTAEthHeader(pvData,cbData, pEthHdr);
|
|
}
|
|
else
|
|
{
|
|
|
|
pEthHdr->eh_type = H2N_USHORT(ARP_ETH_ETYPE_IP);
|
|
Status = arpGetEthAddrFromIpAddr(
|
|
pIF,
|
|
fUnicast,
|
|
IpDest,
|
|
&pEthHdr->eh_daddr,
|
|
pSR
|
|
);
|
|
}
|
|
}
|
|
} while (FALSE);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
NDIS_STATUS
|
|
arpGet1394HeaderFromEthIpPkt(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PNDIS_BUFFER pFirstBuffer,
|
|
IN PVOID pvData,
|
|
IN UINT cbData,
|
|
IN MYBOOL fUnicast,
|
|
OUT NIC1394_ENCAPSULATION_HEADER
|
|
*p1394Hdr,
|
|
OUT PREMOTE_DEST_KEY pDestAddress, // OPTIONAL
|
|
PRM_STACK_RECORD pSR
|
|
)
|
|
{
|
|
MYBOOL fLoopBack = FALSE;
|
|
ENetHeader *pEthHdr = (ENetHeader *) pvData;
|
|
ARP1394_ADAPTER * pAdapter;
|
|
BOOLEAN fBridgeMode;
|
|
|
|
if (cbData < (sizeof(ENetHeader) ) )
|
|
{
|
|
//
|
|
// Packet is too small.
|
|
//
|
|
return NDIS_STATUS_FAILURE; // ***** EARLY RETURN ****
|
|
}
|
|
|
|
pAdapter = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
|
|
fBridgeMode = ARP_BRIDGE_ENABLED(pAdapter);
|
|
|
|
|
|
if (NdisEqualMemory(&pEthHdr->eh_daddr,
|
|
&pAdapter->info.EthernetMacAddress,
|
|
sizeof(ENetAddr)))
|
|
{
|
|
if (!fBridgeMode)
|
|
{
|
|
// We're not in bridge mode -- so this must be only on MILL
|
|
// This is addressed to our local mac address.
|
|
// We fail with special failure status
|
|
// NDIS_STATUS_ALREADY_MAPPED, indicating "loopback".
|
|
//
|
|
|
|
fLoopBack = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Do nothing ... because we can get unicasts to our fictitious gateway
|
|
//
|
|
}
|
|
|
|
if (fLoopBack)
|
|
{
|
|
return NDIS_STATUS_ALREADY_MAPPED;
|
|
}
|
|
else
|
|
{
|
|
|
|
BOOLEAN fIsSTAPacket ;
|
|
//
|
|
// We have an STA packet, if the destination is our special
|
|
// Multicast Destination
|
|
//
|
|
fIsSTAPacket = (TRUE == NdisEqualMemory (&pEthHdr->eh_daddr,
|
|
&gSTAMacAddr,
|
|
ETH_LENGTH_OF_ADDRESS) );
|
|
|
|
if (fIsSTAPacket == TRUE)
|
|
{
|
|
*p1394Hdr = Arp1394_StaEncapHeader;
|
|
}
|
|
else
|
|
{
|
|
*p1394Hdr = Arp1394_IpEncapHeader;
|
|
}
|
|
|
|
if (pDestAddress != NULL)
|
|
{
|
|
//
|
|
// Extract the Enet Address to use it as part of the lookup
|
|
//
|
|
UNALIGNED ENetAddr *pENetDest;
|
|
pENetDest = (UNALIGNED ENetAddr *)(pvData);
|
|
pDestAddress->ENetAddress = *pENetDest;
|
|
|
|
}
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
arpEthReceivePacket(
|
|
IN ARP1394_INTERFACE * pIF,
|
|
PNDIS_PACKET pNdisPacket
|
|
)
|
|
/*
|
|
This is the connectionLESS ethernet receive packet handler.
|
|
Following code adapted from the co receive packet handler.
|
|
*/
|
|
{
|
|
ENTER("arpEthReceivePacket", 0xc8afbabb)
|
|
UINT TotalLength; // Total bytes in packet
|
|
PNDIS_BUFFER pNdisBuffer; // Pointer to first buffer
|
|
UINT BufferLength;
|
|
UINT ReturnCount;
|
|
PVOID pvPktHeader;
|
|
ENetHeader * pEthHeader;
|
|
const UINT MacHeaderLength = sizeof(ENetHeader);
|
|
ARP1394_ADAPTER * pAdapter;
|
|
BOOLEAN fBridgeMode;
|
|
|
|
pAdapter = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
|
|
fBridgeMode = ARP_BRIDGE_ENABLED(pAdapter);
|
|
|
|
DBGMARK(0x2425d318);
|
|
|
|
ReturnCount = 0;
|
|
|
|
//
|
|
// Discard the packet if the IP interface is not activated
|
|
//
|
|
do
|
|
{
|
|
//
|
|
// Discard packet if adapter is in bridge mode.
|
|
//
|
|
if (fBridgeMode)
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Discard the packet if the adapter is not active
|
|
//
|
|
if (!CHECK_IF_ACTIVE_STATE(pIF, ARPAD_AS_ACTIVATED))
|
|
{
|
|
TR_INFO(("Eth:Discardning received Eth pkt because pIF 0x%p is not activated.\n", pIF));
|
|
|
|
break;
|
|
}
|
|
|
|
NdisQueryPacket(
|
|
pNdisPacket,
|
|
NULL,
|
|
NULL,
|
|
&pNdisBuffer,
|
|
&TotalLength
|
|
);
|
|
|
|
if (TotalLength > 0)
|
|
{
|
|
NdisQueryBuffer(
|
|
pNdisBuffer,
|
|
(PVOID *)&pvPktHeader,
|
|
&BufferLength
|
|
);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
pEthHeader = (ENetHeader*) pvPktHeader;
|
|
|
|
TR_INFO(
|
|
("EthRcv: NDISpkt 0x%x, NDISbuf 0x%x, Buflen %d, Totlen %d, Pkthdr 0x%x\n",
|
|
pNdisPacket,
|
|
pNdisBuffer,
|
|
BufferLength,
|
|
TotalLength,
|
|
pvPktHeader));
|
|
|
|
if (BufferLength < MacHeaderLength || pEthHeader == NULL)
|
|
{
|
|
// Packet is too small, discard.
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
// At this point, pEthHeader contains the Ethernet header.
|
|
// We look at the ethertype to decide what to do with it.
|
|
//
|
|
if (pEthHeader->eh_type == N2H_USHORT(ARP_ETH_ETYPE_IP))
|
|
{
|
|
//
|
|
// The EtherType is IP, so we pass up this packet to the IP layer.
|
|
// (Also we indicate all packets we receive on the broadcast channel
|
|
// to the ethernet VC).
|
|
//
|
|
|
|
TR_INFO(
|
|
("Rcv: pPkt 0x%x: EtherType is IP, passing up.\n", pNdisPacket));
|
|
|
|
ARP_IF_STAT_INCR(pIF, InNonUnicastPkts);
|
|
|
|
LOGSTATS_CopyRecvs(pIF, pNdisPacket);
|
|
#if MILLEN
|
|
ASSERT_PASSIVE();
|
|
#endif // MILLEN
|
|
pIF->ip.RcvHandler(
|
|
pIF->ip.Context,
|
|
(PVOID)((PUCHAR)pEthHeader+sizeof(*pEthHeader)),
|
|
BufferLength - MacHeaderLength,
|
|
TotalLength - MacHeaderLength,
|
|
(NDIS_HANDLE)pNdisPacket,
|
|
MacHeaderLength,
|
|
FALSE, // FALSE == NOT received via broadcast.
|
|
// Important, because we are reflecting directed
|
|
// packets up to IP. If we report TRUE here,
|
|
// IP assumes it's not a directed packet, and
|
|
// handles it differently.
|
|
NULL
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Discard packet -- unknown/bad EtherType
|
|
//
|
|
TR_INFO(("Encap hdr 0x%x, bad EtherType 0x%x\n",
|
|
pEthHeader, pEthHeader->eh_type));
|
|
ARP_IF_STAT_INCR(pIF, UnknownProtos);
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
EXIT()
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
arpEthProcess1394ArpPkt(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PIP1394_ARP_PKT pArpPkt,
|
|
IN UINT HeaderSize
|
|
)
|
|
/*++
|
|
|
|
Process an ip/1394 ARP packet. We do the following:
|
|
0. Parse the paket
|
|
1. Update our local RemoteIP cache.
|
|
2. Create and send an equivalent ethernet arp pkt on the ethernet VC.
|
|
(We look up the destination ethernet address in our ethernet cache)
|
|
|
|
This function must only be called when the adapter is in "Bridged mode."
|
|
|
|
--*/
|
|
{
|
|
IP1394_ARP_PKT_INFO Ip1394PktInfo;
|
|
ETH_ARP_PKT_INFO EthArpInfo;
|
|
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
|
|
ARP_DEST_PARAMS DestParams;
|
|
PARP1394_ADAPTER pAdapter =(PARP1394_ADAPTER ) RM_PARENT_OBJECT(pIF);
|
|
ENetAddr SenderEnetAddress;
|
|
IPAddr SenderIpAddress = 0;
|
|
REMOTE_DEST_KEY RemoteDestKey;
|
|
|
|
ENTER("arpEthProcess1394ArpPkt", 0x0)
|
|
RM_DECLARE_STACK_RECORD(Sr)
|
|
|
|
ARP_ZEROSTRUCT(&DestParams);
|
|
|
|
do {
|
|
|
|
PNDIS_PACKET pPkt = NULL;
|
|
PVOID pvData = NULL;
|
|
|
|
Status = arpParseArpPkt(
|
|
pArpPkt,
|
|
HeaderSize,
|
|
&Ip1394PktInfo
|
|
);
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
TR_WARN(("Failed parse of received 1394 ARP PKT.\n"));
|
|
break;
|
|
}
|
|
|
|
DestParams.HwAddr.AddressType = NIC1394AddressType_FIFO;
|
|
DestParams.HwAddr.FifoAddress = Ip1394PktInfo.SenderHwAddr; // Struct copy
|
|
|
|
REMOTE_DEST_KEY_INIT(&RemoteDestKey);
|
|
|
|
|
|
if ((ARP_BRIDGE_ENABLED(pAdapter) == TRUE) &&
|
|
(Ip1394PktInfo.fPktHasNodeAddress == FALSE))
|
|
{
|
|
// We do not have the sender's Node ID -- fail.
|
|
TR_WARN (("Did not Receive Sender's Node ID in Pkt"))
|
|
Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
if (ARP_BRIDGE_ENABLED(pAdapter) == TRUE)
|
|
{
|
|
// Extract the Source Mac address using the Sender Node Address
|
|
|
|
Status = arpGetSourceMacAddressFor1394Pkt(pAdapter,
|
|
Ip1394PktInfo.SourceNodeAdddress,
|
|
TRUE,
|
|
&Ip1394PktInfo.SourceMacAddress,
|
|
&Sr);
|
|
|
|
RemoteDestKey.ENetAddress = Ip1394PktInfo.SourceMacAddress;
|
|
|
|
}
|
|
else
|
|
{
|
|
RemoteDestKey.IpAddress = Ip1394PktInfo.SenderIpAddress;
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
if (Status != NDIS_STATUS_SUCCESS)
|
|
{
|
|
TR_WARN (("Unable to get valid Source MAC Address from Pkt"))
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
|
|
break;
|
|
}
|
|
|
|
// Update our 1394 ARP cache.
|
|
//
|
|
arpUpdateArpCache(
|
|
pIF,
|
|
RemoteDestKey.IpAddress , // Remote IP Address
|
|
&RemoteDestKey.ENetAddress,
|
|
&DestParams, // Remote Destination HW Address
|
|
TRUE, // Update even if we don't already have an entry
|
|
&Sr
|
|
);
|
|
|
|
Status = arpConstructEthArpInfoFrom1394ArpInfo(
|
|
pIF,
|
|
&Ip1394PktInfo,
|
|
&EthArpInfo,
|
|
&Sr
|
|
);
|
|
|
|
if (FAIL(Status)) break;
|
|
|
|
// Allocate an appropriately sized control packet.
|
|
//
|
|
Status = arpAllocateControlPacket(
|
|
pIF,
|
|
sizeof(ETH_ARP_PKT),
|
|
ARP1394_PACKET_FLAGS_ICS,
|
|
&pPkt,
|
|
&pvData,
|
|
&Sr
|
|
);
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
ASSERT(FALSE); // we want to know if we hit this in regular use.
|
|
pPkt = NULL;
|
|
break;
|
|
}
|
|
|
|
NdisInterlockedIncrement (&Arp1394ToIcs);
|
|
|
|
// Fill it out..
|
|
//
|
|
arpPrepareEthArpPkt(
|
|
&EthArpInfo,
|
|
(PETH_ARP_PKT) pvData
|
|
);
|
|
|
|
// Send the packet over the ethernet VC...
|
|
//
|
|
ARP_FASTREADLOCK_IF_SEND_LOCK(pIF);
|
|
|
|
arpSendControlPkt(
|
|
pIF, // LOCKIN NOLOCKOUT (IF send lk)
|
|
pPkt,
|
|
pIF->pEthernetDest,
|
|
&Sr
|
|
);
|
|
|
|
} while (FALSE);
|
|
|
|
RM_ASSERT_CLEAR(&Sr);
|
|
}
|
|
|
|
|
|
VOID
|
|
arpEthProcessEthArpPkt(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PETH_ARP_PKT pArpPkt,
|
|
IN UINT HeaderSize
|
|
)
|
|
/*++
|
|
|
|
Process an Ethernet ARP packet. We do the following:
|
|
0. Parse the packet
|
|
1. Update our local ethernet arp cache.
|
|
2. Create and send an equivalent 1394 arp pkt on the broadcast VC.
|
|
(We look up the destination ethernet address in our ethernet cache)
|
|
|
|
This function must only be called when the adapter is in "Bridged mode."
|
|
|
|
--*/
|
|
{
|
|
|
|
ETH_ARP_PKT_INFO EthPktInfo;
|
|
IP1394_ARP_PKT_INFO Ip1394ArpInfo;
|
|
NDIS_STATUS Status;
|
|
ARP_REMOTE_ETH_PARAMS CreateParams;
|
|
ENTER("arpEthProcessEthArpPkt", 0x0)
|
|
RM_DECLARE_STACK_RECORD(Sr)
|
|
|
|
ARP_ZEROSTRUCT(&CreateParams);
|
|
|
|
do {
|
|
|
|
PNDIS_PACKET pPkt = NULL;
|
|
PVOID pvData = NULL;
|
|
|
|
Status = arpParseEthArpPkt(
|
|
pArpPkt,
|
|
HeaderSize,
|
|
&EthPktInfo
|
|
);
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
TR_WARN(("Failed parse of received Ethernet ARP PKT.\n"));
|
|
break;
|
|
}
|
|
|
|
Status = arpConstruct1394ArpInfoFromEthArpInfo(
|
|
pIF,
|
|
&EthPktInfo,
|
|
&Ip1394ArpInfo,
|
|
&Sr
|
|
);
|
|
|
|
if (FAIL(Status)) break;
|
|
|
|
// Allocate an appropriately sized control packet.
|
|
//
|
|
Status = arpAllocateControlPacket(
|
|
pIF,
|
|
sizeof(IP1394_ARP_PKT),
|
|
ARP1394_PACKET_FLAGS_ICS,
|
|
&pPkt,
|
|
&pvData,
|
|
&Sr
|
|
);
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
ASSERT(FALSE); // we want to know if we hit this in regular use.
|
|
pPkt = NULL;
|
|
break;
|
|
}
|
|
|
|
// Fill it out..
|
|
//
|
|
arpPrepareArpPkt(
|
|
&Ip1394ArpInfo,
|
|
(PIP1394_ARP_PKT) pvData
|
|
);
|
|
|
|
// Send the packet over the ethernet VC...
|
|
//
|
|
ARP_FASTREADLOCK_IF_SEND_LOCK(pIF);
|
|
|
|
arpSendControlPkt(
|
|
pIF, // LOCKIN NOLOCKOUT (IF send lk)
|
|
pPkt,
|
|
pIF->pBroadcastDest,
|
|
&Sr
|
|
);
|
|
|
|
} while (FALSE);
|
|
|
|
RM_ASSERT_CLEAR(&Sr);
|
|
}
|
|
|
|
|
|
|
|
NDIS_STATUS
|
|
arpParseEthArpPkt(
|
|
IN PETH_ARP_PKT pArpPkt,
|
|
IN UINT cbBufferSize,
|
|
OUT PETH_ARP_PKT_INFO pPktInfo
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
|
|
Parse the contents of IP/Ethernet ARP packet data starting at
|
|
pArpPkt. Place the results into pPktInfo.
|
|
|
|
Arguments:
|
|
|
|
pArpPkt - Contains the unaligned contents of an ip/eth ARP Pkt.
|
|
pPktInfo - Unitialized structure to be filled with the parsed contents of the
|
|
pkt.
|
|
|
|
Return Value:
|
|
|
|
NDIS_STATUS_FAILURE if the parse failed (typically because of invalid pkt
|
|
contents.)
|
|
NDIS_STATUS_SUCCESS on successful parsing.
|
|
|
|
--*/
|
|
{
|
|
ENTER("arpParseEthArpPkt", 0x359e9bf2)
|
|
NDIS_STATUS Status;
|
|
DBGSTMT(CHAR *szError = "General failure";)
|
|
|
|
Status = NDIS_STATUS_FAILURE;
|
|
|
|
do
|
|
{
|
|
UINT OpCode;
|
|
|
|
// Verify length.
|
|
//
|
|
if (cbBufferSize < sizeof(*pArpPkt))
|
|
{
|
|
DBGSTMT(szError = "pkt size too small";)
|
|
break;
|
|
}
|
|
|
|
// Verify constant fields.
|
|
//
|
|
|
|
if (N2H_USHORT(pArpPkt->header.eh_type) != ARP_ETH_ETYPE_ARP)
|
|
{
|
|
DBGSTMT(szError = "header.eh_type!=ARP";)
|
|
break;
|
|
}
|
|
|
|
#if 0
|
|
ARP_ETH_HW_ENET OR ARP_ETH_HW_802
|
|
if (N2H_USHORT(pArpPkt->hardware_type) != IP1394_HARDWARE_TYPE)
|
|
{
|
|
DBGSTMT(szError = "Invalid hardware_type";)
|
|
break;
|
|
}
|
|
#endif // 0
|
|
|
|
// ARP_ETH_ETYPE_IP ARP_ETH_ETYPE_ARP
|
|
if (N2H_USHORT(pArpPkt->protocol_type) != ARP_ETH_ETYPE_IP)
|
|
{
|
|
DBGSTMT(szError = "Invalid protocol_type";)
|
|
break;
|
|
}
|
|
|
|
if (pArpPkt->hw_addr_len != ARP_802_ADDR_LENGTH)
|
|
{
|
|
DBGSTMT(szError = "Invalid hw_addr_len";)
|
|
break;
|
|
}
|
|
|
|
|
|
if (pArpPkt->IP_addr_len != sizeof(ULONG))
|
|
{
|
|
DBGSTMT(szError = "Invalid IP_addr_len";)
|
|
break;
|
|
}
|
|
|
|
|
|
// Opcode
|
|
//
|
|
{
|
|
OpCode = N2H_USHORT(pArpPkt->opcode);
|
|
|
|
if ( OpCode != ARP_ETH_REQUEST
|
|
&& OpCode != ARP_ETH_RESPONSE)
|
|
{
|
|
DBGSTMT(szError = "Invalid opcode";)
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Pkt appears valid, let's fill out the parsed information....
|
|
//
|
|
|
|
ARP_ZEROSTRUCT(pPktInfo);
|
|
|
|
pPktInfo->SourceEthAddress = pArpPkt->header.eh_saddr; // struct copy.
|
|
pPktInfo->DestEthAddress = pArpPkt->header.eh_daddr; // struct copy.
|
|
pPktInfo->OpCode = (USHORT) OpCode;
|
|
|
|
// These remain network byte order...
|
|
//
|
|
pPktInfo->SenderIpAddress = (IP_ADDRESS) pArpPkt->sender_IP_address;
|
|
pPktInfo->TargetIpAddress = (IP_ADDRESS) pArpPkt->target_IP_address;
|
|
|
|
pPktInfo->SenderEthAddress = pArpPkt->sender_hw_address; // struct copy
|
|
pPktInfo->TargetEthAddress = pArpPkt->target_hw_address; // struct copy
|
|
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
|
|
} while (FALSE);
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
TR_INFO(("Bad arp pkt data at 0x%p (%s)\n", pArpPkt, szError));
|
|
}
|
|
else
|
|
{
|
|
PUCHAR pSip = (PUCHAR)&pPktInfo->SenderIpAddress;
|
|
PUCHAR pTip = (PUCHAR)&pPktInfo->TargetIpAddress;
|
|
TR_VERB(("Received ETH ARP PKT. OP=%lu SIP=%d.%d.%d.%d TIP=%d.%d.%d.%d.\n",
|
|
pPktInfo->OpCode,
|
|
pSip[0],pSip[1],pSip[2],pSip[3],
|
|
pTip[0],pTip[1],pTip[2],pTip[3]
|
|
));
|
|
|
|
}
|
|
|
|
EXIT()
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
VOID
|
|
arpPrepareEthArpPkt(
|
|
IN PETH_ARP_PKT_INFO pPktInfo,
|
|
OUT PETH_ARP_PKT pArpPkt
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Use information in pArpPktInfo to prepare an ethernet arp packet starting at
|
|
pvArpPkt.
|
|
|
|
Arguments:
|
|
|
|
pPktInfo - Parsed version of the eth arp request/response packet.
|
|
pArpPkt - unitialized memory in which to store the packet contents.
|
|
This memory must have a min size of sizeof(*pArpPkt).
|
|
--*/
|
|
{
|
|
// UINT SenderMaxRec;
|
|
UINT OpCode;
|
|
|
|
ARP_ZEROSTRUCT(pArpPkt);
|
|
|
|
pArpPkt->header.eh_type = H2N_USHORT(ARP_ETH_ETYPE_ARP);
|
|
pArpPkt->header.eh_daddr = pPktInfo->DestEthAddress;
|
|
pArpPkt->header.eh_saddr = pPktInfo->SourceEthAddress;
|
|
pArpPkt->hardware_type = H2N_USHORT(ARP_ETH_HW_ENET); // TODO
|
|
// we always set the type
|
|
// to ARP_ETH_HW_ENET -- not sure
|
|
// if this a valid assumption or
|
|
// if we need to query the NIC.
|
|
pArpPkt->protocol_type = H2N_USHORT(ARP_ETH_ETYPE_IP);
|
|
pArpPkt->hw_addr_len = (UCHAR) ARP_802_ADDR_LENGTH;
|
|
pArpPkt->IP_addr_len = (UCHAR) sizeof(ULONG);
|
|
pArpPkt->opcode = H2N_USHORT(pPktInfo->OpCode);
|
|
|
|
|
|
// These are already in network byte order...
|
|
//
|
|
pArpPkt->sender_IP_address = (ULONG) pPktInfo->SenderIpAddress;
|
|
pArpPkt->target_IP_address = (ULONG) pPktInfo->TargetIpAddress;
|
|
pArpPkt->sender_hw_address = pPktInfo->SenderEthAddress; // struct copy
|
|
pArpPkt->target_hw_address = pPktInfo->TargetEthAddress; // struct copy
|
|
}
|
|
|
|
|
|
UINT
|
|
arpEthernetReceivePacket(
|
|
IN NDIS_HANDLE ProtocolBindingContext,
|
|
IN NDIS_HANDLE ProtocolVcContext,
|
|
IN PNDIS_PACKET pNdisPacket
|
|
)
|
|
/*++
|
|
|
|
NDIS Co receive packet for the ethernet VC.
|
|
|
|
We do the following:
|
|
|
|
If it's an ARP packet, we translate it and send it on the bcast channel.
|
|
Else if it was a ethernet unicast packet, we change the header
|
|
and treat it like an IP unicast packet -- SlowIpTransmit
|
|
Else we change the header and then send it on the bcast desination.
|
|
|
|
--*/
|
|
{
|
|
PARP_VC_HEADER pVcHdr;
|
|
PARPCB_DEST pDest;
|
|
PARP1394_INTERFACE pIF;
|
|
ARP1394_ADAPTER * pAdapter;
|
|
ENetHeader *pEthHdr;
|
|
|
|
UINT TotalLength; // Total bytes in packet
|
|
PNDIS_BUFFER pNdisBuffer; // Pointer to first buffer
|
|
UINT BufferLength;
|
|
PVOID pvPktHeader;
|
|
const UINT MacHeaderLength = sizeof(ENetHeader);
|
|
MYBOOL fBridgeMode;
|
|
MYBOOL fUnicast;
|
|
MYBOOL fIsSTAPacket;
|
|
ENTER("arpEthernetReceivePacket", 0x0)
|
|
RM_DECLARE_STACK_RECORD(sr)
|
|
|
|
DBGMARK(0x72435b28);
|
|
|
|
#if TESTPROGRAM
|
|
{
|
|
extern ARP1394_INTERFACE * g_pIF;
|
|
pIF = g_pIF;
|
|
}
|
|
#else // !TESTPROGRAM
|
|
pVcHdr = (PARP_VC_HEADER) ProtocolVcContext;
|
|
pDest = CONTAINING_RECORD( pVcHdr, ARPCB_DEST, VcHdr);
|
|
ASSERT_VALID_DEST(pDest);
|
|
pIF = (ARP1394_INTERFACE*) RM_PARENT_OBJECT(pDest);
|
|
#endif // TESTPROGRAM
|
|
|
|
ASSERT_VALID_INTERFACE(pIF);
|
|
pAdapter = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
|
|
fBridgeMode = ARP_BRIDGE_ENABLED(pAdapter);
|
|
|
|
do
|
|
{
|
|
|
|
if (!fBridgeMode) // This is really only for MILL
|
|
{
|
|
#if MILLEN
|
|
arpIcsForwardIpPacket(
|
|
pIF,
|
|
pNdisPacket,
|
|
ARP_ICS_FORWARD_TO_1394,
|
|
FALSE, // FALSE == NonUnicast
|
|
&sr
|
|
);
|
|
#endif // MILLEN
|
|
break;
|
|
}
|
|
|
|
NdisQueryPacket(
|
|
pNdisPacket,
|
|
NULL,
|
|
NULL,
|
|
&pNdisBuffer,
|
|
&TotalLength
|
|
);
|
|
|
|
|
|
if (TotalLength > 0)
|
|
{
|
|
NdisQueryBuffer(
|
|
pNdisBuffer,
|
|
(PVOID *)&pvPktHeader,
|
|
&BufferLength
|
|
);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
TR_VERB(
|
|
("Eth Rcv: NDISpkt 0x%x, NDISbuf 0x%x, Buflen %d, Totlen %d, Pkthdr 0x%x\n",
|
|
pNdisPacket,
|
|
pNdisBuffer,
|
|
BufferLength,
|
|
TotalLength,
|
|
pvPktHeader));
|
|
|
|
if (BufferLength < MacHeaderLength)
|
|
{
|
|
// Packet is too small, discard.
|
|
//
|
|
break;
|
|
}
|
|
|
|
if (pvPktHeader == NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
pEthHdr = (ENetHeader*) pvPktHeader;
|
|
|
|
|
|
fUnicast = arpIsUnicastEthDest(pEthHdr);
|
|
|
|
switch(N2H_USHORT(pEthHdr->eh_type))
|
|
{
|
|
|
|
case ARP_ETH_ETYPE_ARP:
|
|
{
|
|
PETH_ARP_PKT pArpPkt = (PETH_ARP_PKT) pEthHdr;
|
|
if (BufferLength < sizeof(*pArpPkt))
|
|
{
|
|
// discard packet.
|
|
break;
|
|
}
|
|
arpEthProcessEthArpPkt(pIF, pArpPkt, BufferLength);
|
|
}
|
|
break;
|
|
|
|
case ARP_ETH_ETYPE_IP:
|
|
{
|
|
//
|
|
// The EtherType is IP, so we translate the header and
|
|
// send if of on the appropriate 1394 FIFO vc.
|
|
//
|
|
|
|
if (fUnicast)
|
|
{
|
|
PNDIS_PACKET pNewPkt = NULL;
|
|
IP_ADDRESS IpDest;
|
|
NDIS_STATUS Status;
|
|
REMOTE_DEST_KEY Dest;
|
|
|
|
// is this meant for the 1394 net.
|
|
REMOTE_DEST_KEY_INIT(&Dest);
|
|
//
|
|
// Create the translated packet.
|
|
//
|
|
Status = arpIcsTranslateIpPkt(
|
|
pIF,
|
|
pNdisPacket,
|
|
ARP_ICS_FORWARD_TO_1394,
|
|
TRUE, // TRUE == fUnicast.
|
|
&pNewPkt,
|
|
&Dest,
|
|
&sr
|
|
);
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
break;
|
|
}
|
|
|
|
Status = arpSlowIpTransmit(
|
|
pIF,
|
|
pNewPkt,
|
|
Dest,
|
|
NULL // RCE
|
|
);
|
|
if (!PEND(Status))
|
|
{
|
|
// We need to deallocate the packet ourselves
|
|
//
|
|
arpFreeControlPacket(
|
|
pIF,
|
|
pNewPkt,
|
|
&sr
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This is a broadcast or multicast IP packet -- swith
|
|
// the link-layer header and send it over the 1394
|
|
// broadcast channel.
|
|
//
|
|
arpIcsForwardIpPacket(
|
|
pIF,
|
|
pNdisPacket,
|
|
ARP_ICS_FORWARD_TO_1394,
|
|
FALSE, // FALSE == NonUnicast
|
|
&sr
|
|
);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
//
|
|
// Last option is that it could be a Bridge STA packet.
|
|
// However the bridge does not use an Ethertype, so we
|
|
// have to check the destination mac address
|
|
//
|
|
fIsSTAPacket = (TRUE == NdisEqualMemory (&pEthHdr->eh_daddr,
|
|
&gSTAMacAddr,
|
|
ETH_LENGTH_OF_ADDRESS) );
|
|
|
|
if (fIsSTAPacket == TRUE)
|
|
{
|
|
//
|
|
// switch the link-layer header and send it over the 1394
|
|
// broadcast channel.
|
|
//
|
|
arpIcsForwardIpPacket(
|
|
pIF,
|
|
pNdisPacket,
|
|
ARP_ICS_FORWARD_TO_1394,
|
|
FALSE, // FALSE == NonUnicast
|
|
&sr );
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
} while (FALSE);
|
|
|
|
RM_ASSERT_CLEAR(&sr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
VOID
|
|
arpEthReceive1394Packet(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PNDIS_PACKET pNdisPacket,
|
|
IN PVOID pvHeader,
|
|
IN UINT HeaderSize,
|
|
IN MYBOOL IsChannel
|
|
)
|
|
/*++
|
|
Handle an incoming packet from the 1394 side when in bridged mode.
|
|
|
|
pEncapHeader -- the 1st buffer in the packet.
|
|
--*/
|
|
{
|
|
PNIC1394_ENCAPSULATION_HEADER pEncapHeader;
|
|
ENTER("arpEthReceived1394Packet", 0xe317990b)
|
|
RM_DECLARE_STACK_RECORD(sr)
|
|
|
|
pEncapHeader = (PNIC1394_ENCAPSULATION_HEADER) pvHeader;
|
|
|
|
do
|
|
{
|
|
//
|
|
// Discard the packet if the adapter is not active
|
|
//
|
|
if (!CHECK_IF_ACTIVE_STATE(pIF, ARPAD_AS_ACTIVATED))
|
|
{
|
|
TR_INFO(("Eth:Discardning received 1394 pkt because pIF 0x%p is not activated.\n", pIF));
|
|
|
|
break;
|
|
}
|
|
|
|
if (pEncapHeader->EtherType == H2N_USHORT(NIC1394_ETHERTYPE_IP))
|
|
{
|
|
LOGSTATS_CopyRecvs(pIF, pNdisPacket);
|
|
|
|
//
|
|
// The EtherType is IP, so we translate the header and
|
|
// send it off on the ethernet vc.
|
|
//
|
|
arpIcsForwardIpPacket(
|
|
pIF,
|
|
pNdisPacket,
|
|
ARP_ICS_FORWARD_TO_ETHERNET,
|
|
!IsChannel,
|
|
&sr
|
|
);
|
|
}
|
|
else if (pEncapHeader->EtherType == H2N_USHORT(NIC1394_ETHERTYPE_ARP))
|
|
{
|
|
PIP1394_ARP_PKT pArpPkt = (PIP1394_ARP_PKT) pEncapHeader;
|
|
if (HeaderSize < sizeof(*pArpPkt))
|
|
{
|
|
// discard packet.
|
|
break;
|
|
}
|
|
arpEthProcess1394ArpPkt(pIF, pArpPkt, HeaderSize);
|
|
}
|
|
else if (pEncapHeader->EtherType == H2N_USHORT(NIC1394_ETHERTYPE_MCAP))
|
|
{
|
|
PIP1394_MCAP_PKT pMcapPkt = (PIP1394_MCAP_PKT) pEncapHeader;
|
|
arpProcessMcapPkt(
|
|
pIF,
|
|
pMcapPkt,
|
|
HeaderSize
|
|
);
|
|
}
|
|
else if (pEncapHeader->EtherType == H2N_USHORT(NIC1394_ETHERTYPE_STA))
|
|
{
|
|
//
|
|
// The EtherType is STA, so we translate the header and
|
|
// send it off on the ethernet vc.
|
|
//
|
|
arpIcsForwardIpPacket(
|
|
pIF,
|
|
pNdisPacket,
|
|
ARP_ICS_FORWARD_TO_ETHERNET,
|
|
IsChannel,
|
|
&sr
|
|
);
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Discard packet -- unknown/bad EtherType
|
|
//
|
|
TR_INFO(("Encap hdr 0x%x, bad EtherType 0x%x\n",
|
|
pEncapHeader, pEncapHeader->EtherType));
|
|
}
|
|
} while (FALSE);
|
|
|
|
EXIT()
|
|
RM_ASSERT_CLEAR(&sr);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
MYBOOL
|
|
arpIsUnicastEthDest(
|
|
IN UNALIGNED ENetHeader *pEthHdr
|
|
)
|
|
/*++
|
|
Returns TRUE IFF the packet is either ethernet broadcast or
|
|
multicast.
|
|
|
|
//
|
|
// TODO: there's probably a quicker check (single bit?).
|
|
//
|
|
--*/
|
|
{
|
|
if (NdisEqualMemory(&pEthHdr->eh_daddr,
|
|
&BroadcastENetAddr,
|
|
sizeof(ENetAddr)))
|
|
{
|
|
// Broadcast address
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
if (NdisEqualMemory(&pEthHdr->eh_daddr,
|
|
&MulticastENetAddr,
|
|
3))
|
|
{
|
|
// 1st 3 bytes match our Ethernet multicast address template, so we
|
|
// conclude that this is a multicast address.
|
|
// TODO: verify this check.
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
NDIS_STATUS
|
|
arpGetEthAddrFromIpAddr(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN MYBOOL fUnicast,
|
|
IN IP_ADDRESS DestIpAddress,
|
|
OUT ENetAddr *pEthAddr,
|
|
PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
The destination address is set as follows:
|
|
if (fUnicast)
|
|
{
|
|
We look up our ethernet arp cache (pIF->RemoteEthGroup) and
|
|
if we find an entry there, we use the MAC address in that entry.
|
|
If we don't find, we fail this function.
|
|
}
|
|
else
|
|
{
|
|
if (destination IP address is class D)
|
|
{
|
|
we create the corresponding MAC address (based on the standard
|
|
formula for mapping IPv4 multicast addresses to MAC addresses).
|
|
}
|
|
else
|
|
{
|
|
we set the destination address to broadcast (all 0xff's).
|
|
(NOTE: we easily determine if the IP address is a broadast
|
|
address because we don't have the subnet mask, so instead we
|
|
assume that it's a broadcast destination if it's not class D
|
|
and it came over the broadcast channel (i.e. fUnicast == FALSE))
|
|
}
|
|
}
|
|
|
|
--*/
|
|
{
|
|
ENTER("arpGetEthAddrFromIpAddr", 0x0)
|
|
ARP1394_ADAPTER * pAdapter;
|
|
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
|
|
pAdapter = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
|
|
|
|
do
|
|
{
|
|
if (fUnicast)
|
|
{
|
|
// Lookup the ethernet MAC address in the MAC arp cache.
|
|
//
|
|
|
|
*pEthAddr = pAdapter->info.EthernetMacAddress;
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Set the destination address to Multicast if dest IP is
|
|
// class D, else multicast
|
|
//
|
|
|
|
if (CLASSD_ADDR(DestIpAddress))
|
|
{
|
|
//
|
|
// Construct the corresponding multicast ethernet address.
|
|
// This code is adapted from tcpip\arp.c
|
|
//
|
|
// Basically we copy over a "template" of the multicast
|
|
// address, and then or-in the LSB 23 bits (in network byte
|
|
// order) of the ip address.
|
|
//
|
|
|
|
#define ARP_MCAST_MASK 0xffff7f00
|
|
UINT UNALIGNED *pTmp;
|
|
|
|
*pEthAddr = MulticastENetAddr; // struct copy.
|
|
pTmp = (UINT UNALIGNED *) & pEthAddr->addr[2];
|
|
*pTmp |= (DestIpAddress & ARP_MCAST_MASK);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We assume DestIpAddress is a broadcast address -- see
|
|
// comments at the head of this function
|
|
//
|
|
*pEthAddr = BroadcastENetAddr; // struct copy
|
|
}
|
|
}
|
|
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
|
|
} while (FALSE);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NDIS_STATUS
|
|
arpConstructEthArpInfoFrom1394ArpInfo(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PIP1394_ARP_PKT_INFO p1394PktInfo,
|
|
OUT PETH_ARP_PKT_INFO pEthPktInfo,
|
|
PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
Translate a parsed version of an Ethernet ARP packet into
|
|
the parsed version of an equivalent 1394 arp packet.
|
|
|
|
We ALWAYS set the source ethernet address AND the target ethernet
|
|
address to OUR ethernet MAC address. So other ethernet nodes think of
|
|
us as a a single ethernet mic which hosts a whole bunch of IP addresses.
|
|
|
|
We COULD use our proprietary algorithm to convert from EU64 ID to MAC
|
|
addresses and then use those for the target addresses, but we're not
|
|
sure of the ramifications of that in the bridge mode.
|
|
|
|
--*/
|
|
{
|
|
ENTER("arpConstructEthArpInfoFrom1394ArpInfo", 0x8214aa14)
|
|
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
|
|
ENetAddr SourceMacAddress;
|
|
do
|
|
{
|
|
MYBOOL fUnicast;
|
|
IP_ADDRESS IpDest;
|
|
ARP1394_ADAPTER * pAdapter;
|
|
UINT Ip1394OpCode = p1394PktInfo->OpCode;
|
|
UINT EthOpCode;
|
|
|
|
pAdapter = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
|
|
|
|
ARP_ZEROSTRUCT(pEthPktInfo);
|
|
|
|
if (Ip1394OpCode == IP1394_ARP_REQUEST)
|
|
{
|
|
fUnicast = FALSE;
|
|
IpDest = 0xFFFFFFFF; // IP broadcast address.
|
|
EthOpCode= ARP_ETH_REQUEST;
|
|
}
|
|
else
|
|
{
|
|
// TODO: We expect TargetIpAddress to contain the address
|
|
// of the arp request that resulted in this reply. This
|
|
// is not per ip/1394 spec, which says that the TargetIpAddress
|
|
// is to be ignored. However Kaz has suggested that we
|
|
// utilize this field in this way -- search for "Kaz" in
|
|
// arp.c
|
|
//
|
|
// If we can't rely on this, then we must either
|
|
// (a) BROADCAST arp replies over ethernet OR
|
|
// (b) keep track of outstanding arp requests which need replies.
|
|
//
|
|
fUnicast = TRUE;
|
|
IpDest = p1394PktInfo->TargetIpAddress;
|
|
EthOpCode= ARP_ETH_RESPONSE;
|
|
}
|
|
|
|
Status = arpGetSourceMacAddressFor1394Pkt (pAdapter,
|
|
p1394PktInfo->SourceNodeAdddress,
|
|
p1394PktInfo->fPktHasNodeAddress,
|
|
&SourceMacAddress,
|
|
pSR );
|
|
|
|
if (FAIL(Status))
|
|
{
|
|
break;
|
|
}
|
|
|
|
pEthPktInfo->SourceEthAddress = SourceMacAddress ;
|
|
pEthPktInfo->SenderEthAddress = SourceMacAddress ;
|
|
pEthPktInfo->TargetEthAddress = pAdapter->info.EthernetMacAddress;
|
|
|
|
|
|
Status = arpGetEthAddrFromIpAddr(
|
|
pIF,
|
|
fUnicast,
|
|
IpDest,
|
|
&pEthPktInfo->DestEthAddress,
|
|
pSR
|
|
);
|
|
if (FAIL(Status))
|
|
{
|
|
break;
|
|
}
|
|
|
|
pEthPktInfo->OpCode = EthOpCode;
|
|
pEthPktInfo->SenderIpAddress = p1394PktInfo->SenderIpAddress;
|
|
pEthPktInfo->TargetIpAddress = p1394PktInfo->TargetIpAddress;
|
|
|
|
|
|
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
|
|
{
|
|
UCHAR pIp[4];
|
|
|
|
TR_WARN(("Received Arp - "));
|
|
|
|
if (EthOpCode == ARP_ETH_RESPONSE)
|
|
{
|
|
TR_WARN(("Response\n"));
|
|
}
|
|
else
|
|
{
|
|
TR_WARN (("Request\n"));
|
|
}
|
|
|
|
NdisMoveMemory (&pIp[0], &pEthPktInfo->SenderIpAddress, sizeof(IPAddr) );
|
|
|
|
TR_WARN(("Ethernet Source %x %x %x %x %x %x,IP source %d %d %d %d \n ",
|
|
pEthPktInfo->SourceEthAddress.addr[0],
|
|
pEthPktInfo->SourceEthAddress.addr[1],
|
|
pEthPktInfo->SourceEthAddress.addr[2],
|
|
pEthPktInfo->SourceEthAddress.addr[3],
|
|
pEthPktInfo->SourceEthAddress.addr[4],
|
|
pEthPktInfo->SourceEthAddress.addr[5],
|
|
pIp[0],
|
|
pIp[1],
|
|
pIp[2],
|
|
pIp[3]));
|
|
|
|
NdisMoveMemory (&pIp[0], &pEthPktInfo->TargetIpAddress, sizeof(IPAddr) );
|
|
|
|
TR_WARN(("Ethernet Target %x %x %x %x %x %x , IP Target %d %d %d %d \n",
|
|
pEthPktInfo->TargetEthAddress.addr[0],
|
|
pEthPktInfo->TargetEthAddress.addr[1],
|
|
pEthPktInfo->TargetEthAddress.addr[2],
|
|
pEthPktInfo->TargetEthAddress.addr[3],
|
|
pEthPktInfo->TargetEthAddress.addr[4],
|
|
pEthPktInfo->TargetEthAddress.addr[5],
|
|
pIp[0],
|
|
pIp[1],
|
|
pIp[2],
|
|
pIp[3]));
|
|
|
|
|
|
TR_WARN(("Ethernet Dest %x %x %x %x %x %x \n",
|
|
pEthPktInfo->DestEthAddress.addr[0],
|
|
pEthPktInfo->DestEthAddress.addr[1],
|
|
pEthPktInfo->DestEthAddress.addr[2],
|
|
pEthPktInfo->DestEthAddress.addr[3],
|
|
pEthPktInfo->DestEthAddress.addr[4],
|
|
pEthPktInfo->DestEthAddress.addr[5]));
|
|
|
|
|
|
TR_WARN(("Ethernet Sender %x %x %x %x %x %x \n\n",
|
|
pEthPktInfo->SenderEthAddress.addr[0],
|
|
pEthPktInfo->SenderEthAddress.addr[1],
|
|
pEthPktInfo->SenderEthAddress.addr[2],
|
|
pEthPktInfo->SenderEthAddress.addr[3],
|
|
pEthPktInfo->SenderEthAddress.addr[4],
|
|
pEthPktInfo->SenderEthAddress.addr[5]));
|
|
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
NDIS_STATUS
|
|
arpConstruct1394ArpInfoFromEthArpInfo(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PETH_ARP_PKT_INFO pEthPktInfo,
|
|
OUT PIP1394_ARP_PKT_INFO p1394PktInfo,
|
|
PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
Translate a parsed version of an IP1394 ARP packet into
|
|
the parsed version of an equivalent Ethernet arp packet.
|
|
|
|
We always report our own adapter info as the hw/specific info
|
|
in the arp packet. We do this for both arp requests and responses.
|
|
|
|
This means that we look like a single host with multiple ip addresses
|
|
to other ip/1394 nodes.
|
|
|
|
--*/
|
|
{
|
|
ARP1394_ADAPTER * pAdapter;
|
|
UINT Ip1394OpCode;
|
|
UINT EthOpCode = pEthPktInfo->OpCode;
|
|
|
|
pAdapter = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
|
|
|
|
ARP_ZEROSTRUCT(p1394PktInfo);
|
|
|
|
if (EthOpCode == ARP_ETH_REQUEST)
|
|
{
|
|
Ip1394OpCode= IP1394_ARP_REQUEST;
|
|
}
|
|
else
|
|
{
|
|
Ip1394OpCode= IP1394_ARP_RESPONSE;
|
|
}
|
|
|
|
p1394PktInfo->OpCode = Ip1394OpCode;
|
|
p1394PktInfo->SenderIpAddress = pEthPktInfo->SenderIpAddress;
|
|
p1394PktInfo->TargetIpAddress = pEthPktInfo->TargetIpAddress;
|
|
|
|
// Fill out adapter info..
|
|
//
|
|
p1394PktInfo->SenderHwAddr.UniqueID = pAdapter->info.LocalUniqueID;
|
|
p1394PktInfo->SenderHwAddr.Off_Low = pIF->recvinfo.offset.Off_Low;
|
|
p1394PktInfo->SenderHwAddr.Off_High = pIF->recvinfo.offset.Off_High;
|
|
p1394PktInfo->SenderMaxRec= pAdapter->info.MaxRec;
|
|
p1394PktInfo->SenderMaxSpeedCode= pAdapter->info.MaxSpeedCode;
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
NDIS_STATUS
|
|
arpGetSourceMacAddressFor1394Pkt (
|
|
IN PARP1394_ADAPTER pAdapter,
|
|
IN UCHAR SourceNodeAddress,
|
|
IN BOOLEAN fIsValidSourceNodeAddress,
|
|
OUT ENetAddr* pSourceMacAddress,
|
|
PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
If the Packet has a valid Source Node Address then return it or else fail
|
|
the function
|
|
--*/
|
|
{
|
|
ENetAddr InvalidMacAddress = {0,0,0,0,0,0};
|
|
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
|
|
|
|
NdisZeroMemory (pSourceMacAddress, sizeof(*pSourceMacAddress));
|
|
|
|
do
|
|
{
|
|
//
|
|
// Get the Mac Address from the Node Address
|
|
//
|
|
if (fIsValidSourceNodeAddress == TRUE)
|
|
{
|
|
*pSourceMacAddress = (pAdapter->EuidMap.Node[SourceNodeAddress].ENetAddress);
|
|
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Is the source address all zero's
|
|
//
|
|
if (NdisEqualMemory (pSourceMacAddress, &InvalidMacAddress, sizeof (ENetAddr) ) == 1)
|
|
{
|
|
//ASSERT (NdisEqualMemory (pSourceMacAddress, &InvalidMacAddress, sizeof (ENetAddr) ) != 1);
|
|
// Get the New Topology
|
|
//
|
|
arpGetEuidTopology (pAdapter,pSR);
|
|
Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// The SourceMacAddress should not be a broadcast or multicast address
|
|
//
|
|
if (ETH_IS_BROADCAST(pSourceMacAddress) || ETH_IS_MULTICAST(pSourceMacAddress))
|
|
{
|
|
ASSERT (ETH_IS_BROADCAST(pSourceMacAddress) == FALSE);
|
|
ASSERT (ETH_IS_MULTICAST(pSourceMacAddress) == FALSE);
|
|
Status = NDIS_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
|
|
}while (FALSE);
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
NDIS_STATUS
|
|
arpEthConstructSTAEthHeader(
|
|
IN PUCHAR pvData,
|
|
IN UINT cbData,
|
|
OUT ENetHeader *pEthHdr
|
|
)
|
|
/*++
|
|
Constructs the Ethernet header of the STA packet .
|
|
Expects that Source Mac Address has already been filled in
|
|
|
|
Arguments:
|
|
pvData - Start of the Data packet
|
|
cbData - Length of the data
|
|
pEthHdr - output value
|
|
--*/
|
|
|
|
{
|
|
UINT LenIpData = cbData - sizeof (NIC1394_ENCAPSULATION_HEADER);
|
|
//
|
|
// First set the destination Mac address in the Ethernet Header
|
|
//
|
|
NdisMoveMemory (&pEthHdr->eh_daddr, &gSTAMacAddr, sizeof (gSTAMacAddr));
|
|
|
|
|
|
//
|
|
// Use the length of the packet to store it in the packets. Should be 0x26 or 0x7
|
|
//
|
|
|
|
pEthHdr->eh_type = H2N_USHORT(LenIpData);
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// the Bootp Code is take heavily from the bridge module
|
|
//
|
|
|
|
|
|
BOOLEAN
|
|
arpDecodeIPHeader(
|
|
IN PUCHAR pHeader,
|
|
OUT PARP_IP_HEADER_INFO piphi
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Decodes basic information from the IP header (no options)
|
|
|
|
Arguments:
|
|
|
|
pHeader Pointer to an IP header
|
|
piphi Receives the info
|
|
|
|
Return Value:
|
|
|
|
TRUE: header was valid
|
|
FALSE: packet is not an IP packet
|
|
|
|
--*/
|
|
{
|
|
// First nibble of the header encodes the packet version, which must be 4.
|
|
if( (*pHeader >> 4) != 0x04 )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Next nibble of the header encodes the length of the header in 32-bit words.
|
|
// This length must be at least 20 bytes or something is amiss.
|
|
piphi->headerSize = (*pHeader & 0x0F) * 4;
|
|
if( piphi->headerSize < 20 )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Retrieve the protocol byte (offset 10)
|
|
piphi->protocol = pHeader[9];
|
|
|
|
// The source IP address begins at the 12th byte (most significant byte first)
|
|
#if 0
|
|
piphi->ipSource = 0L;
|
|
piphi->ipSource |= pHeader[12] << 24;
|
|
piphi->ipSource |= pHeader[13] << 16;
|
|
piphi->ipSource |= pHeader[14] << 8;
|
|
piphi->ipSource |= pHeader[15];
|
|
|
|
// The destination IP address is next
|
|
piphi->ipTarget = 0L;
|
|
piphi->ipTarget |= pHeader[16] << 24;
|
|
piphi->ipTarget |= pHeader[17] << 16;
|
|
piphi->ipTarget |= pHeader[18] << 8;
|
|
piphi->ipTarget |= pHeader[19];
|
|
#endif
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
PUCHAR
|
|
arpIsEthBootPPacket(
|
|
IN PUCHAR pPacketData,
|
|
IN UINT packetLen,
|
|
IN PARP_IP_HEADER_INFO piphi
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determines whether a given packet is a BOOTP packet
|
|
Requires a phy length of six
|
|
|
|
Different from the Bridge Code, packetLen is length of the Ip Packet
|
|
|
|
Arguments:
|
|
|
|
pPacketData Pointer to the packet's data buffer
|
|
packetLen Amount of data at pPacketDaa
|
|
piphi Info about the IP header of this packet
|
|
|
|
Return Value:
|
|
|
|
A pointer to the BOOTP payload within the packet, or NULL if the packet was not
|
|
a BOOTP Packet.
|
|
|
|
--*/
|
|
{
|
|
ENTER("arpIsEthBootPPacket",0xbcdce2dd);
|
|
// After the IP header, there must be enough room for a UDP header and
|
|
// a basic BOOTP packet
|
|
if( packetLen < (UINT)piphi->headerSize + SIZE_OF_UDP_HEADER +
|
|
SIZE_OF_BASIC_BOOTP_PACKET)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Protocol must be UDP
|
|
if( piphi->protocol != UDP_PROTOCOL )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Jump to the beginning of the UDP packet by skipping the IP header
|
|
pPacketData += piphi->headerSize;
|
|
|
|
// The first two bytes are the source port and should be the
|
|
// BOOTP Client port (0x0044) or the BOOTP Server port (0x0043)
|
|
if( (pPacketData[0] != 00) ||
|
|
((pPacketData[1] != 0x44) && (pPacketData[1] != 0x43)) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// The next two bytes are the destination port and should be the BOOTP
|
|
// server port (0x0043) or the BOOTP client port (0x44)
|
|
if( (pPacketData[2] != 00) ||
|
|
((pPacketData[3] != 0x43) && (pPacketData[3] != 0x44)) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Skip ahead to the beginning of the BOOTP packet
|
|
pPacketData += SIZE_OF_UDP_HEADER;
|
|
|
|
// The first byte is the op code and should be 0x01 for a request
|
|
// or 0x02 for a reply
|
|
if( pPacketData[0] > 0x02 )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// The next byte is the hardware type and should be 0x01 for Ethernet
|
|
// or 0x07 (officially arcnet) for ip1394
|
|
//
|
|
if( pPacketData[1] != 0x01 && pPacketData[1] != 0x07 )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// The next byte is the address length and should be 0x06 for Ethernet
|
|
if( pPacketData[2] != 0x06 )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Everything checks out; this looks like a BOOTP request packet.
|
|
TR_INFO ( ("Received Bootp Packet \n"));
|
|
EXIT()
|
|
return pPacketData;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// The IP and UDP checksums treat the data they are checksumming as a
|
|
// sequence of 16-bit words. The checksum is carried as the bitwise
|
|
// inverse of the actual checksum (~C). The formula for calculating
|
|
// the new checksum as transmitted, ~C', given that a 16-bit word of
|
|
// the checksummed data has changed from w to w' is
|
|
//
|
|
// ~C' = ~C + w + ~w' (addition in ones-complement)
|
|
//
|
|
// This function returns the updated checksum given the original checksum
|
|
// and the original and new values of a word in the checksummed data.
|
|
// RFC 1141
|
|
//
|
|
USHORT
|
|
arpEthCompRecalcChecksum(
|
|
IN USHORT oldChecksum,
|
|
IN USHORT oldWord,
|
|
IN USHORT newWord
|
|
)
|
|
{
|
|
ULONG sum,XSum;
|
|
ULONG RfcSum, RfcXSum;
|
|
|
|
|
|
|
|
sum = oldChecksum + oldWord + ((~(newWord)) & 0xFFFF);
|
|
XSum = (USHORT)((sum & 0xFFFF) + (sum >> 16));
|
|
|
|
RfcSum = oldWord + ((~(newWord)) & 0xffff);
|
|
RfcSum += oldChecksum;
|
|
RfcSum = (RfcSum& 0xffff) + (RfcSum >>16);
|
|
RfcXSum = (RfcSum + (RfcSum >>16));
|
|
|
|
ASSERT (RfcXSum == XSum);
|
|
return (USHORT)RfcXSum;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
arpEthRewriteBootPClientAddress(
|
|
IN PUCHAR pPacketData,
|
|
IN PARP_IP_HEADER_INFO piphi,
|
|
IN PUCHAR newMAC
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function writes New MAC to the HW address embedded in the DHCP packet
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
USHORT checkSum;
|
|
PUCHAR pBootPData, pCheckSum, pDestMAC, pSrcMAC;
|
|
UINT i;
|
|
|
|
// The BOOTP packet lives right after the UDP header
|
|
pBootPData = pPacketData + piphi->IpHeaderOffset + piphi->headerSize + SIZE_OF_UDP_HEADER;
|
|
|
|
// The checksum lives at offset 7 in the UDP packet.
|
|
pCheckSum = pPacketData + piphi->IpHeaderOffset + piphi->headerSize + 6;
|
|
checkSum = 0;
|
|
checkSum = pCheckSum[0] << 8;
|
|
checkSum |= pCheckSum[1];
|
|
|
|
if (checkSum == 0xffff)
|
|
{
|
|
// Tcpip Illustrated - Vol 1 'UDP Checksum'
|
|
checkSum = 0;
|
|
}
|
|
|
|
// Replace the client's hardware address, updating the checksum as we go.
|
|
// The client's hardware address lives at offset 29 in the BOOTP packet
|
|
pSrcMAC = newMAC;
|
|
pDestMAC = &pBootPData[28];
|
|
|
|
for( i = 0 ; i < ETH_LENGTH_OF_ADDRESS / 2; i++ )
|
|
{
|
|
checkSum = arpEthCompRecalcChecksum( checkSum,
|
|
(USHORT)(pDestMAC[0] << 8 | pDestMAC[1]),
|
|
(USHORT)(pSrcMAC[0] << 8 | pSrcMAC[1]) );
|
|
|
|
pDestMAC[0] = pSrcMAC[0];
|
|
pDestMAC[1] = pSrcMAC[1];
|
|
|
|
pDestMAC += 2;
|
|
pSrcMAC += 2;
|
|
}
|
|
|
|
// Write the new checksum back out
|
|
pCheckSum[0] = (UCHAR)(checkSum >> 8);
|
|
pCheckSum[1] = (UCHAR)(checkSum & 0xFF);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NDIS_STATUS
|
|
arpEthBootP1394ToEth(
|
|
IN PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT
|
|
IN ARP_ICS_FORWARD_DIRECTION Direction,
|
|
IN PREMOTE_DEST_KEY pDestAddress,
|
|
IN PUCHAR pucNewData,
|
|
IN PUCHAR pBootPData,
|
|
IN PARP_IP_HEADER_INFO piphi,
|
|
IN PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function handles the translation from 1394 to Eth. Essentially,
|
|
we look at the SRC MAC address in the Ethernet Packet, make sure the HW
|
|
Addr embedded is the same as the SRC MAC address.
|
|
|
|
We also make an entry in our table - XID, OldHWAddress, NewHWAddress.
|
|
|
|
The packet has already been rewritten into Ethernet by this time
|
|
|
|
Arguments:
|
|
pIF - pInterface
|
|
Direction - Eth To 1394 or 1394-To-Eth
|
|
pDestAddress - the Eth Hw address used in the translation
|
|
pucNewData - the Data in the new packet
|
|
pBootPdata - pointer to the Bootp part of the packet
|
|
piphi - ip header info
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
BOOLEAN bIsRequest = FALSE;
|
|
BOOLEAN bIsResponse;
|
|
ARP_BOOTP_INFO InfoBootP;
|
|
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
|
|
ENetHeader* pEnetHeader = (ENetHeader*)pucNewData;
|
|
ENetAddr NewMAC;
|
|
BOOLEAN bIs1394HwAlreadyInDhcpRequest;
|
|
|
|
ENTER ("arpEthBootP1394ToEth", 0x66206f0b);
|
|
NdisZeroMemory (&InfoBootP, sizeof(InfoBootP));
|
|
//
|
|
// Is this a DHCP Request
|
|
//
|
|
|
|
do
|
|
{
|
|
bIsResponse = ARP_IS_BOOTP_RESPONSE(pBootPData);
|
|
|
|
if (bIsResponse == TRUE)
|
|
{
|
|
//
|
|
// if this is a DHCP Reply , the do not touch the packet - there are no inconsistencies.
|
|
//
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
if( FALSE == arpEthPreprocessBootPPacket(pIF,pucNewData, pBootPData, &bIsRequest, &InfoBootP,pSR) )
|
|
{
|
|
// This is an invalid packet
|
|
ASSERT (FALSE);
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// This is a DHCP Request
|
|
//
|
|
|
|
|
|
//
|
|
// if the HWAddr and the Src Mac address the same.
|
|
// then are job is already done.
|
|
//
|
|
//At this point the 1394 packet is already in Ethernet format
|
|
|
|
NewMAC = pEnetHeader->eh_saddr;
|
|
|
|
TR_INFO(("DHCP REQUEST target MAC %x %x %x %x %x %x , SrcMAC %x %x %x %x %x %x \n",
|
|
InfoBootP.requestorMAC.addr[0],InfoBootP.requestorMAC.addr[1],InfoBootP.requestorMAC.addr[2],
|
|
InfoBootP.requestorMAC.addr[3],InfoBootP.requestorMAC.addr[4],InfoBootP.requestorMAC.addr[5],
|
|
NewMAC.addr[0],NewMAC.addr[1],NewMAC.addr[2],
|
|
NewMAC.addr[3],NewMAC.addr[4],NewMAC.addr[5]));
|
|
|
|
bIs1394HwAlreadyInDhcpRequest = NdisEqualMemory (&InfoBootP.requestorMAC, &NewMAC , sizeof (ENetAddr)) ;
|
|
|
|
|
|
if (TRUE == bIs1394HwAlreadyInDhcpRequest )
|
|
{
|
|
//
|
|
// Nothing to do , id the HW add and the src MAC are equal
|
|
//
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Make an entry into our table - consisting of the XID. OldHW Address and
|
|
// New HY address
|
|
// We've already done this.
|
|
|
|
//
|
|
// Overwrite the hw address embedded in the DHCP packet. - make sure to rewrite the
|
|
// checksum.
|
|
//
|
|
arpEthRewriteBootPClientAddress(pucNewData,piphi,&NewMAC.addr[0]);
|
|
|
|
TR_VERB (("arpEthBootP1394ToEth -Dhcp packet Rewriting BootpClient Address\n"));
|
|
|
|
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
}while (FALSE);
|
|
|
|
EXIT();
|
|
return Status;;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NDIS_STATUS
|
|
arpEthBootPEthTo1394(
|
|
IN PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT
|
|
IN ARP_ICS_FORWARD_DIRECTION Direction,
|
|
IN PREMOTE_DEST_KEY pDestAddress, // OPTIONAL
|
|
IN PUCHAR pucNewData,
|
|
IN PUCHAR pBootPData,
|
|
IN PARP_IP_HEADER_INFO piphi,
|
|
IN PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function translates BootP packet from the Ethernet Net to 1394. if this is a dhcp reply (offer),
|
|
then we need to rewrite the Hw Addr in the DHCP packlet
|
|
|
|
Arguments:
|
|
|
|
pIF - pInterface
|
|
Direction - Eth To 1394 or 1394-To-Eth
|
|
pDestAddress - the Eth Hw address used in the translation
|
|
pucNewData - the Data in the new packet
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
BOOLEAN fIsBootpRequest = FALSE;
|
|
ARP_BOOTP_INFO InfoBootP;
|
|
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
|
|
ENetHeader* pEnetHeader = (ENetHeader*)pucNewData;
|
|
ENetAddr NewMAC;
|
|
PUCHAR pMACInPkt = NULL;
|
|
BOOLEAN bIs1394HwAlreadyInDhcpResponse = FALSE;
|
|
|
|
ENTER("arpEthBootPEthTo1394", 0x383f9e33);
|
|
NdisZeroMemory (&InfoBootP, sizeof(InfoBootP));
|
|
//
|
|
// Is this a DHCP Request
|
|
//
|
|
|
|
do
|
|
{
|
|
|
|
// Do a quick check .
|
|
fIsBootpRequest = ARP_IS_BOOTP_REQUEST(pBootPData);
|
|
|
|
if (fIsBootpRequest == TRUE)
|
|
{
|
|
//
|
|
// if this is a DHCP Request, the do not modify the packet -
|
|
// there are no inconsistencies in this code path.
|
|
//
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
if( FALSE == arpEthPreprocessBootPPacket(pIF,pucNewData, pBootPData, &fIsBootpRequest, &InfoBootP,pSR) )
|
|
{
|
|
// This is an uninteresting packet
|
|
break;
|
|
}
|
|
|
|
//
|
|
// InfoBootP has the original HW addr used in the corresponding Dhcp request.
|
|
// We'll put the hw Addr back into dhcp reply
|
|
|
|
|
|
|
|
//
|
|
//offset of the chaddr in bootp packet
|
|
//
|
|
pMACInPkt = &pBootPData[28];
|
|
|
|
|
|
|
|
TR_INFO(("DHCP RESPONSE target MAC %x %x %x %x %x %x , SrcMAC %x %x %x %x %x %x \n",
|
|
InfoBootP.requestorMAC.addr[0],InfoBootP.requestorMAC.addr[1],InfoBootP.requestorMAC.addr[2],
|
|
InfoBootP.requestorMAC.addr[3],InfoBootP.requestorMAC.addr[4],InfoBootP.requestorMAC.addr[5],
|
|
pMACInPkt[0],pMACInPkt[1],pMACInPkt[2],
|
|
pMACInPkt[3],pMACInPkt[4],pMACInPkt[5]));
|
|
|
|
//
|
|
// Is the HWAddr in the dhcp packet the correct one.
|
|
//
|
|
|
|
bIs1394HwAlreadyInDhcpResponse = NdisEqualMemory(&InfoBootP.requestorMAC, pMACInPkt, sizeof (InfoBootP.requestorMAC)) ;
|
|
|
|
if (TRUE == bIs1394HwAlreadyInDhcpResponse)
|
|
{
|
|
//
|
|
// Yes, they are equal, we do not rewrite the packet
|
|
//
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
TR_VERB( ("DHCP RESPONSE Rewriting Bootp Response pBootpData %p Before\n",pBootPData));
|
|
|
|
//
|
|
// Replace the CL Addr in the DHCP packet with the original HW addr
|
|
//
|
|
arpEthRewriteBootPClientAddress(pucNewData,piphi,&InfoBootP.requestorMAC.addr[0]);
|
|
|
|
|
|
//
|
|
// recompute the checksum
|
|
//
|
|
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
|
|
} while (FALSE);
|
|
|
|
EXIT();
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
NDIS_STATUS
|
|
arpEthModifyBootPPacket(
|
|
IN PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT
|
|
IN ARP_ICS_FORWARD_DIRECTION Direction,
|
|
IN PREMOTE_DEST_KEY pDestAddress, // OPTIONAL
|
|
IN PUCHAR pucNewData,
|
|
IN ULONG PacketLength,
|
|
IN PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function contains the code to process a Bootp Packet. This basically ensures that the
|
|
MAC address entered in the DHCP packet matches the Src Mac address of the Ethernet Packet
|
|
(in the 1394 - Eth mode). In the other case (Eth-1394 mode), we replace the Ch address with
|
|
the correct CH addr (if we have to).
|
|
|
|
|
|
Arguments:
|
|
pIF - pInterface
|
|
Direction - Eth To 1394 or 1394-To-Eth
|
|
pDestAddress - the Eth Hw address used in the translation
|
|
pucNewData - the Data in the new packet
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
ARP_IP_HEADER_INFO iphi;
|
|
PUCHAR pBootPData = NULL;
|
|
NDIS_STATUS Status= NDIS_STATUS_FAILURE;
|
|
PARP1394_ADAPTER pAdapter = (PARP1394_ADAPTER)RM_PARENT_OBJECT(pIF);
|
|
ULONG IpHeaderOffset = 0;
|
|
PUCHAR pIPHeader = NULL;
|
|
BOOLEAN fIsIpPkt;
|
|
NdisZeroMemory(&iphi, sizeof (iphi));
|
|
|
|
|
|
do
|
|
{
|
|
//
|
|
// if we are not in bridge mode - exit.
|
|
//
|
|
if (ARP_BRIDGE_ENABLED(pAdapter) == FALSE)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (Direction == ARP_ICS_FORWARD_TO_ETHERNET)
|
|
{
|
|
// Packet is in the ethernet format
|
|
IpHeaderOffset = ETHERNET_HEADER_SIZE;
|
|
|
|
}
|
|
else
|
|
{
|
|
// Packet is in the IP 1394 format
|
|
IpHeaderOffset = sizeof (NIC1394_UNFRAGMENTED_HEADER); //4
|
|
}
|
|
|
|
iphi.IpHeaderOffset = IpHeaderOffset;
|
|
iphi.IpPktLength = PacketLength - IpHeaderOffset;
|
|
pIPHeader = pucNewData + IpHeaderOffset ;
|
|
|
|
//
|
|
// if this is not a bootp packet -exit
|
|
//
|
|
fIsIpPkt = arpDecodeIPHeader (pIPHeader , &iphi);
|
|
|
|
if (fIsIpPkt == FALSE)
|
|
{
|
|
//
|
|
// not an IP pkt
|
|
//
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
|
|
pBootPData = arpIsEthBootPPacket (pIPHeader ,PacketLength-IpHeaderOffset, &iphi);
|
|
|
|
if (pBootPData == NULL)
|
|
{
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
//
|
|
// are we doing 1394 - to- Eth
|
|
//
|
|
if (Direction == ARP_ICS_FORWARD_TO_ETHERNET)
|
|
{
|
|
|
|
Status = arpEthBootP1394ToEth(pIF, Direction,pDestAddress,pucNewData,pBootPData,&iphi, pSR);
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// are we doing Eth to 1394
|
|
//
|
|
Status = arpEthBootPEthTo1394(pIF, Direction,pDestAddress,pucNewData,pBootPData , &iphi,pSR);
|
|
|
|
}
|
|
Status = NDIS_STATUS_SUCCESS;
|
|
}while (FALSE);
|
|
|
|
// else we are doing Eth to 1394
|
|
return Status;
|
|
}
|
|
|
|
|
|
//
|
|
// This function is taken verbatim from the bridge
|
|
//
|
|
|
|
|
|
BOOLEAN
|
|
arpEthPreprocessBootPPacket(
|
|
IN PARP1394_INTERFACE pIF,
|
|
IN PUCHAR pPacketData,
|
|
IN PUCHAR pBootPData, // Actual BOOTP packet
|
|
OUT PBOOLEAN pbIsRequest,
|
|
PARP_BOOTP_INFO pInfoBootP,
|
|
PRM_STACK_RECORD pSR
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Does preliminary processing of a BOOTP packet common to the inbound and outbound case
|
|
|
|
Arguments:
|
|
|
|
pPacketData Pointer to a packet's data buffer
|
|
pBootPData Pointer to the BOOTP payload within the packet
|
|
pAdapt Receiving adapter (or NULL if this packet is outbound from
|
|
the local machine)
|
|
pbIsRequest Receives a flag indicating if this is a BOOTP request
|
|
ppTargetAdapt Receives the target adapter this packet should be relayed to
|
|
(only valid if bIsRequest == FALSE and return == TRUE)
|
|
requestorMAC The MAC address this packet should be relayed to (valid under
|
|
same conditions as ppTargetAdapt)
|
|
|
|
Return Value:
|
|
|
|
TRUE : packet was processed successfully
|
|
FALSE : an error occured or something is wrong with the packet
|
|
|
|
--*/
|
|
{
|
|
PARP1394_ETH_DHCP_ENTRY pEntry= NULL;
|
|
ULONG xid;
|
|
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
|
|
ENTER ("arpEthPreprocessBootPPacket",0x25427efc);
|
|
|
|
// Decode the xid (bytes 5 through 8)
|
|
xid = 0L;
|
|
xid |= pBootPData[4] << 24;
|
|
xid |= pBootPData[5] << 16;
|
|
xid |= pBootPData[6] << 8;
|
|
xid |= pBootPData[7];
|
|
|
|
// Byte 0 is the operation; 1 for a request, 2 for a reply
|
|
if( pBootPData[0] == 0x01 )
|
|
{
|
|
ULONG bIsNewEntry = FALSE;
|
|
|
|
// This is a request. We need to note the correspondence betweeen
|
|
// this client's XID and its adapter and MAC address
|
|
|
|
TR_INFO(("DHCP REQUEST XID: %x , HW %x %x %x %x %x %x \n", xid,
|
|
pBootPData[28],pBootPData[29],pBootPData[30],pBootPData[31],pBootPData[32],pBootPData[33]));
|
|
|
|
Status = RmLookupObjectInGroup(
|
|
&pIF->EthDhcpGroup,
|
|
RM_CREATE,
|
|
(PVOID) &xid, // pKey
|
|
(PVOID) &xid, // pvCreateParams
|
|
&(PRM_OBJECT_HEADER)pEntry,
|
|
&bIsNewEntry ,
|
|
pSR
|
|
);
|
|
|
|
|
|
if( pEntry != NULL )
|
|
{
|
|
if( bIsNewEntry )
|
|
{
|
|
// Initialize the entry.
|
|
// The client's hardware address is at offset 29
|
|
ETH_COPY_NETWORK_ADDRESS( &pEntry->requestorMAC.addr[0], &pBootPData[28] );
|
|
|
|
pEntry->xid = xid;
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// An entry already existed for this XID. This is fine if the existing information
|
|
// matches what we're trying to record, but it's also possible that two stations
|
|
// decided independently to use the same XID, or that the same station changed
|
|
// apparent MAC address and/or adapter due to topology changes. Our scheme breaks
|
|
// down under these circumstances.
|
|
//
|
|
// Either way, use the most recent information possible; clobber the existing
|
|
// information with the latest.
|
|
//
|
|
|
|
LOCKOBJ(pEntry, pSR);
|
|
|
|
{
|
|
UINT Result;
|
|
ETH_COMPARE_NETWORK_ADDRESSES_EQ( &pEntry->requestorMAC.addr[0], &pBootPData[28], &Result );
|
|
|
|
// Warn if the data changed, as this probably signals a problem
|
|
if( Result != 0 )
|
|
{
|
|
|
|
TR_WARN(("ARP1394 WARNING: Station with MAC address %02x:%02x:%02x:%02x:%02x:%02x is using DHCP XID %x at the same time as station %02x:%02x:%02x:%02x:%02x:%02x!\n",
|
|
pBootPData[28], pBootPData[29], pBootPData[30], pBootPData[31], pBootPData[32], pBootPData[33],
|
|
xid, pEntry->requestorMAC.addr[0], pEntry->requestorMAC.addr[1], pEntry->requestorMAC.addr[2],
|
|
pEntry->requestorMAC.addr[3], pEntry->requestorMAC.addr[4], pEntry->requestorMAC.addr[5] ));
|
|
}
|
|
}
|
|
|
|
ETH_COPY_NETWORK_ADDRESS( &pEntry->requestorMAC.addr[0], &pBootPData[28] );
|
|
|
|
UNLOCKOBJ (pEntry, pSR);
|
|
}
|
|
|
|
RmTmpDereferenceObject (&pEntry->Hdr, pSR);
|
|
|
|
}
|
|
else
|
|
{
|
|
// This packet could not be processed
|
|
TR_INFO(("Couldn't create table entry for BOOTP packet!\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
*pbIsRequest = TRUE;
|
|
pInfoBootP->bIsRequest = TRUE;
|
|
|
|
ETH_COPY_NETWORK_ADDRESS(&pInfoBootP->requestorMAC,&pEntry->requestorMAC);
|
|
|
|
return TRUE;
|
|
}
|
|
else if ( pBootPData[0] == 0x02 )
|
|
{
|
|
//
|
|
// NON-CREATE search
|
|
// Look up the xid for this transaction to recover the MAC address of the client
|
|
//
|
|
|
|
TR_INFO (("Seeing a DHCP response xid %x mac %x %x %x %x %x %x \n",
|
|
xid, pBootPData[28],pBootPData[29],pBootPData[30],pBootPData[31],pBootPData[32],pBootPData[33]));
|
|
Status = RmLookupObjectInGroup(
|
|
&pIF->EthDhcpGroup,
|
|
0, // do not create
|
|
(PVOID) &xid, // pKey
|
|
(PVOID) &xid, // pvCreateParams
|
|
&(PRM_OBJECT_HEADER)pEntry,
|
|
NULL,
|
|
pSR
|
|
);
|
|
|
|
|
|
if( pEntry != NULL )
|
|
{
|
|
LOCKOBJ( pEntry, pSR);
|
|
ETH_COPY_NETWORK_ADDRESS( &pInfoBootP->requestorMAC.addr, pEntry->requestorMAC.addr );
|
|
UNLOCKOBJ( pEntry, pSR );
|
|
|
|
//
|
|
// We will use this adapter outside the table lock. NULL is a permissible
|
|
// value that indicates that the local machine is the requestor for
|
|
// this xid.
|
|
//
|
|
RmTmpDereferenceObject(&pEntry->Hdr, pSR);
|
|
}
|
|
|
|
if( pEntry != NULL )
|
|
{
|
|
*pbIsRequest = FALSE;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
TR_INFO (("DHCP Response:Could not find xid %x in DHCP table \n",xid);)
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Someone passed us a crummy packet
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
#if DBG
|
|
VOID
|
|
Dump(
|
|
IN CHAR* p,
|
|
IN ULONG cb,
|
|
IN BOOLEAN fAddress,
|
|
IN ULONG ulGroup )
|
|
|
|
// Hex dump 'cb' bytes starting at 'p' grouping 'ulGroup' bytes together.
|
|
// For example, with 'ulGroup' of 1, 2, and 4:
|
|
//
|
|
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
|
|
// 0000 0000 0000 0000 0000 0000 0000 0000 |................|
|
|
// 00000000 00000000 00000000 00000000 |................|
|
|
//
|
|
// If 'fAddress' is true, the memory address dumped is prepended to each
|
|
// line.
|
|
//
|
|
{
|
|
while (cb)
|
|
{
|
|
INT cbLine;
|
|
|
|
cbLine = (cb < DUMP_BytesPerLine) ? cb : DUMP_BytesPerLine;
|
|
DumpLine( p, cbLine, fAddress, ulGroup );
|
|
cb -= cbLine;
|
|
p += cbLine;
|
|
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
#if DBG
|
|
VOID
|
|
DumpLine(
|
|
IN CHAR* p,
|
|
IN ULONG cb,
|
|
IN BOOLEAN fAddress,
|
|
IN ULONG ulGroup )
|
|
{
|
|
CHAR* pszDigits = "0123456789ABCDEF";
|
|
CHAR szHex[ ((2 + 1) * DUMP_BytesPerLine) + 1 ];
|
|
CHAR* pszHex = szHex;
|
|
CHAR szAscii[ DUMP_BytesPerLine + 1 ];
|
|
CHAR* pszAscii = szAscii;
|
|
ULONG ulGrouped = 0;
|
|
|
|
if (fAddress)
|
|
DbgPrint( "A13: %p: ", p );
|
|
else
|
|
DbgPrint( "A13: " );
|
|
|
|
while (cb)
|
|
{
|
|
*pszHex++ = pszDigits[ ((UCHAR )*p) / 16 ];
|
|
*pszHex++ = pszDigits[ ((UCHAR )*p) % 16 ];
|
|
|
|
if (++ulGrouped >= ulGroup)
|
|
{
|
|
*pszHex++ = ' ';
|
|
ulGrouped = 0;
|
|
}
|
|
|
|
*pszAscii++ = (*p >= 32 && *p < 128) ? *p : '.';
|
|
|
|
++p;
|
|
--cb;
|
|
}
|
|
|
|
*pszHex = '\0';
|
|
*pszAscii = '\0';
|
|
|
|
DbgPrint(
|
|
"%-*s|%-*s|\n",
|
|
(2 * DUMP_BytesPerLine) + (DUMP_BytesPerLine / ulGroup), szHex,
|
|
DUMP_BytesPerLine, szAscii );
|
|
}
|
|
#endif
|
|
|