windows-server-2003/net/1394/arp/sys/eth.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