windows-server-2003/net/1394/arp/sys/ip.c

/*++

Copyright (c) 1998-1999  Microsoft Corporation

Module Name:

    ip.c

Abstract:

    ARP1394 IP-related handlers.

Revision History:

    Who         When        What
    --------    --------    ----------------------------------------------
    josephj     01-06-98    Created (adapted from atmarpc.sys, arpif.c)

Notes:

--*/
#include <precomp.h>

//
// File-specific debugging defaults.
//
#define TM_CURRENT   TM_IP

#define CLASSA_MASK     0x000000ff
#define CLASSB_MASK     0x0000ffff
#define CLASSC_MASK     0x00ffffff
#define CLASSD_MASK     0x000000e0
#define CLASSE_MASK     0xffffffff




//=========================================================================
//                  L O C A L   P R O T O T Y P E S
//=========================================================================
  
ULONG ArpSendCompletes = 0;
ULONG ArpSends = 0;
ULONG ArpSendFailure = 0;


#define LOGSTATS_SendFifoCounts(_pIF, _pNdisPacket, _Status) \
            arpLogSendFifoCounts(_pIF, _pNdisPacket, _Status)
#define LOGSTATS_SendChannelCounts(_pIF, _pNdisPacket, _Status) \
            arpLogSendChannelCounts(_pIF, _pNdisPacket, _Status)
#define LOGSTATS_TotalArpCacheLookups(_pIF, _Status)        \
    NdisInterlockedIncrement(&((_pIF)->stats.arpcache.TotalLookups))

const
NIC1394_ENCAPSULATION_HEADER
Arp1394_IpEncapHeader =
{
    0x0000,     // Reserved
    H2N_USHORT(NIC1394_ETHERTYPE_IP)
};

//
// ZZZ This is a little-endian specific check.
//
#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)))

VOID
arpReStartInterface(
    IN  PNDIS_WORK_ITEM             pWorkItem,
    IN  PVOID                       IfContext
);

NDIS_STATUS
arpInitializeLocalIp(
    IN  ARPCB_LOCAL_IP * pLocalIp,  // LOCKIN NOLOCKOUT
    IN  UINT                        AddressType,
    IN  IP_ADDRESS                  IpAddress,
    IN  IP_MASK                     Mask,
    IN  PVOID                           context,
    IN  PRM_STACK_RECORD            pSR
    );

VOID
arpUnloadLocalIp(
    IN  ARPCB_LOCAL_IP * pLocalIp,  // LOCKIN NOLOCKOUT
    IN  PRM_STACK_RECORD            pSR
    );

INT
arpQueryIpEntityId(
    ARP1394_INTERFACE *             pIF,
    IN      UINT                    EntityType,
    IN      PNDIS_BUFFER            pNdisBuffer,
    IN OUT  PUINT                   pBufferSize,
    PRM_STACK_RECORD                pSR
    );

VOID
nicGetMacAddressFromEuid (
    UINT64 *pEuid, 
    ENetAddr *pMacAddr
    );

INT
arpQueryIpAddrXlatInfo(
    ARP1394_INTERFACE *             pIF,
    IN      PNDIS_BUFFER            pNdisBuffer,
    IN OUT  PUINT                   pBufferSize,
    PRM_STACK_RECORD                pSR
    );

INT
arpQueryIpAddrXlatEntries(
    ARP1394_INTERFACE *             pIF,
    IN      PNDIS_BUFFER            pNdisBuffer,
    IN OUT  PUINT                   pBufferSize,
    IN      PVOID                   QueryContext,
    PRM_STACK_RECORD                pSR
    );

INT
arpQueryIpMibStats(
    ARP1394_INTERFACE *             pIF,
    IN      PNDIS_BUFFER            pNdisBuffer,
    IN OUT  PUINT                   pBufferSize,
    PRM_STACK_RECORD                pSR
    );

PNDIS_BUFFER
arpCopyToNdisBuffer(
    IN  PNDIS_BUFFER                pDestBuffer,
    IN  PUCHAR                      pDataSrc,
    IN  UINT                        LenToCopy,
    IN OUT  PUINT                   pOffsetInBuffer
    );

VOID
arpSendIpPkt(
    IN  ARP1394_INTERFACE       *   pIF,            // LOCKIN NOLOCKOUT (IF send lk)
    IN  PARPCB_DEST                 pDest,
    IN  PNDIS_PACKET                pNdisPacket
    );

VOID
arpAddRce(
    IN  ARPCB_REMOTE_IP *pRemoteIp,
    IN  RouteCacheEntry *pRCE,
    IN  PRM_STACK_RECORD pSR
    );

VOID
arpDelRce(
    IN  RouteCacheEntry *pRce,  // IF send lock WRITELOCKIN WRITELOCKOUTD
    IN  PRM_STACK_RECORD pSR
    );

NDIS_STATUS
arpTaskSendPktsOnRemoteIp(
    IN  struct _RM_TASK *           pTask,
    IN  RM_TASK_OPERATION           Code,
    IN  UINT_PTR                    UserParam,  // Unused
    IN  PRM_STACK_RECORD            pSR
    );

VOID
arpTryResumeSuspendedCleanupTask(
    IN  ARP1394_INTERFACE   *   pIF,
    IN  ARPCB_DEST          *   pDest
    );

VOID
arpQueuePktOnRemoteIp(
    IN  ARPCB_REMOTE_IP     *   pRemoteIp,      // LOCKIN LOCKOUT
    IN  PNDIS_PACKET        pNdisPacket,
    IN  PRM_STACK_RECORD    pSR
    );

VOID
arpSendPktsQueuedOnRemoteIp(
    IN  ARP1394_INTERFACE   *   pIF,            // NOLOCKIN NOLOCKOUT
    IN  ARPCB_REMOTE_IP     *   pRemoteIp,      // NOLOCKIN NOLOCKOUT
    IN  PRM_STACK_RECORD    pSR
    );

MYBOOL
arpIsNonUnicastIpAddress(
    IN  PARP1394_INTERFACE          pIF,        // LOCKIN LOCKOUT
    IN  IP_ADDRESS                  Addr,
    IN  PRM_STACK_RECORD            pSR
    );

MYBOOL
arpIsNonUnicastEthAddress (
    IN  PARP1394_INTERFACE          pIF,        // LOCKIN LOCKOUT
    IN  ENetAddr*                   pAddr,
    IN  PRM_STACK_RECORD            pSR
);

VOID
arpLoopbackNdisPacket(
    IN PARP1394_INTERFACE pIF,
    IN PARPCB_DEST pBroadcastDest,
    IN PNDIS_PACKET pOldPacket
    );

NDIS_STATUS
arpTaskSendARPApi(
    IN  struct _RM_TASK *           pTask,
    IN  RM_TASK_OPERATION           Code,
    IN  UINT_PTR                    UserParam,
    IN  PRM_STACK_RECORD            pSR
    );



//=========================================================================
//                  I P     H A N D L E R S
//=========================================================================


INT
ArpIpDynRegister(
    IN  PNDIS_STRING                pAdapterString,
    IN  PVOID                       IpContext,
    IN  struct _IP_HANDLERS *       pIpHandlers,
    IN  struct LLIPBindInfo *       pBindInfo,
    IN  UINT                        InterfaceNumber
)
/*++

Routine Description:

    This routine is called from the IP layer when it wants to tell us,
    the ARP module, about its handlers for an Interface.

Arguments:

    pAdapterString      - Name of the logical adapter for this interface
    IpContext           - IP's context for this interface
    pIpHandlers         - Points to struct containing the IP handlers
    pBindInfo           - Pointer to bind info with our information
    InterfaceNumber     - ID for this interface

Return Value:

    TRUE always.

--*/
{
    ENTER("IfDynRegister", 0xc1b569b9)
    ARP1394_INTERFACE*          pIF;
    RM_DECLARE_STACK_RECORD(sr)
    pIF = (ARP1394_INTERFACE*)(pBindInfo->lip_context);

    TR_INFO(("pIF 0x%p\n", pIF));
    ASSERT(pIF->Hdr.Sig == MTAG_INTERFACE);

    LOCKOBJ(pIF, &sr);

    //
    // TODO: fail if we're not in a position to do this -- such as when shutting
    // down.
    //

    pIF->ip.Context         = IpContext;
    pIF->ip.RcvHandler      = pIpHandlers->IpRcvHandler;
    pIF->ip.TxCmpltHandler  = pIpHandlers->IpTxCompleteHandler;
    pIF->ip.StatusHandler   = pIpHandlers->IpStatusHandler;
    pIF->ip.TDCmpltHandler  = pIpHandlers->IpTransferCompleteHandler;
    pIF->ip.RcvCmpltHandler = pIpHandlers->IpRcvCompleteHandler;
    pIF->ip.PnPEventHandler = pIpHandlers->IpPnPHandler;
    pIF->ip.RcvPktHandler   = pIpHandlers->IpRcvPktHandler;
    pIF->ip.AddAddrCmplRtn  = pIpHandlers->IpAddAddrCompleteRtn;
    pIF->ip.IFIndex         = InterfaceNumber;

    UNLOCKOBJ(pIF, &sr);
    //
    RM_ASSERT_CLEAR(&sr);
    EXIT()

    return TRUE;
}


VOID
ArpIpOpen(
    IN  PVOID                       Context
)
/*++

Routine Description:

    This routine is called when IP is ready to use this interface.

Arguments:

    Context     - Actually a pointer to our ARP394_INTERFACE structure

--*/
{
    ARP1394_INTERFACE*          pIF;
    ENTER("ArpIpOpen", 0x7cae1e55)
    RM_DECLARE_STACK_RECORD(sr)

    TR_INFO(("Enter. pContext = 0x%p\n", Context));

    pIF = (ARP1394_INTERFACE*) Context;

    // Validate context.
    //
    ASSERT(pIF->Hdr.Sig == MTAG_INTERFACE);

    LOCKOBJ(pIF, &sr);

    // Get the local HW address if we don't have it yet
    //
    {
        // TODO (this is from ip/atm -- I think in our case we can assume we have
        // it?)
    }
    
    //  Mark interface as open.
    //
    {
        ASSERT(CHECK_IF_IP_STATE(pIF, ARPIF_IPS_CLOSED));
        SET_IF_IP_STATE(pIF, ARPIF_IPS_OPEN);
        pIF->stats.LastChangeTime = GetTimeTicks();

    }

    // Record the fact that we're open, to verify that the IF is closed before
    // the IF block is deallocated.
    //
    DBG_ADDASSOC(&pIF->Hdr, NULL, NULL, ARPASSOC_IP_OPEN, "    IP IF Open\n", &sr);

    UNLOCKOBJ(pIF, &sr);

    RM_ASSERT_CLEAR(&sr);
    EXIT()
}



VOID
ArpIpClose(
    IN  PVOID                       Context
)
/*++

Routine Description:

    IP wants to stop using this Interface.

Arguments:

    Context     - Actually a pointer to our ARP1394_INTERFACE structure

--*/
{
    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*) Context;
    PRM_TASK pTask;
    BOOLEAN fResumeTask = FALSE;
    ENTER("ArpIpClose", 0xdb8c8216)
    RM_DECLARE_STACK_RECORD(sr)

    TR_INFO(("Enter. pContext = 0x%p\n", Context));
    ASSERT(pIF->Hdr.Sig == MTAG_INTERFACE);

    LOCKOBJ(pIF, &sr);

    // if State has not opened, then do not close it.
    //
    pIF->stats.LastChangeTime= GetTimeTicks();

    if (!CHECK_IF_IP_STATE(pIF, ARPIF_IPS_CLOSED))
    {
        //
        //Set state to closed.
        //
    
        SET_IF_IP_STATE(pIF, ARPIF_IPS_CLOSED);

        // (delete "ARPASSOC_IP_OPEN" association added in arpIpOpen)
        //
        DBG_DELASSOC(&pIF->Hdr, NULL, NULL, ARPASSOC_IP_OPEN, &sr);

        // If there is a shutdown task pending, we notify it
        // Note: a task is protected by it's parent object's lock, which is
        // pIF in the case of the init and shutdown-interface tasks.
        //
        pTask = pIF->pActDeactTask;
        if (pTask && pTask->pfnHandler  ==  arpTaskDeactivateInterface)
        {
            TASK_DEACTIVATE_IF  *pShutdownTask = 
                                     (TASK_DEACTIVATE_IF    *) pTask;
            if (pShutdownTask->fPendingOnIpClose)
            {
                ASSERT(pIF->ip.Context == NULL);
                RmTmpReferenceObject(&pTask->Hdr, &sr);
                fResumeTask = TRUE;
            }
            else
            {
                // Hmm... unsolicited IpClose. We don't expect this currently.
                //
                ASSERT(FALSE);
                pIF->ip.Context = NULL;
            }
        }
    }
    UNLOCKOBJ(pIF, &sr);

    if (fResumeTask)
    {
        RmResumeTask(pTask, (UINT_PTR) 0, &sr);
        RmTmpDereferenceObject(&pTask->Hdr, &sr);
    }

    RM_ASSERT_CLEAR(&sr);
    EXIT()
}


UINT
ArpIpAddAddress(
    IN  PVOID                       Context,
    IN  UINT                        AddressType,
    IN  IP_ADDRESS                  IpAddress,
    IN  IP_MASK                     Mask,
    IN  PVOID                       Context2
)
/*++

Routine Description:

    The IP layer calls this when a new IP address (or block of IP addresses,
    as determined by AddressType) needs to be added to an Interface.

    We could see any of four address types: Local, Multicast, Broadcast
    and Proxy ARP. In the case of Proxy ARP, the address along with the mask
    can specify a block of contiguous IP addresses for which this host acts
    as a proxy. Currently, we only support the "Local", "Broadcast", and
    "Multicast" types.

Arguments:

    Context         - Actually a pointer to our structure
    AddressType     - Type of address(es) being added.
    IpAddress       - Address to be added.
    Mask            - For the above.
    Context2        - Additional context (We ignore this)

Return Value:

    TRUE if successful, FALSE otherwise.

--*/
{
    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*) Context;
    ENTER("ArpIpAddAddress", 0xd6630961)
    INT fCreated = FALSE;
    ARPCB_LOCAL_IP *pLocalIp = NULL;
    NDIS_STATUS Status = NDIS_STATUS_FAILURE;
    IP_STATUS   IpStatus;
    RM_DECLARE_STACK_RECORD(sr)

    TR_INFO(("Enter. pIF = 0x%p\n", pIF));
    ASSERT(pIF->Hdr.Sig == MTAG_INTERFACE);
    LOCKOBJ(pIF, &sr);

    // We're not yet in the open state -- we're "opening", so we don't assert...
    // ASSERT(!CHECK_IF_OPEN_STATE(pIF, ARPIF_CLOSED));

    do
    {
        //
        // Note: we could just as well have done the initialiation as part of
        // the creation of the LocalIpObject itself, by passing in all the
        // required initialization params in the pvCreateParams arg to
        // RmLookupObjectInGroup. Instead we choose to do the initialization
        // ourselves. Things are more explicit this way.
        //

        // Unfortunately, to do this we must first validate the args...
        //
        if (AddressType != LLIP_ADDR_BCAST &&
            AddressType != LLIP_ADDR_MCAST &&
            AddressType != LLIP_ADDR_LOCAL)
        {
            break;
        }

        Status = RmLookupObjectInGroup(
                            &pIF->LocalIpGroup,
                            RM_CREATE,
                            (PVOID) ULongToPtr (IpAddress),             // pKey
                            (PVOID) ULongToPtr (IpAddress),             // pvCreateParams
                            &(PRM_OBJECT_HEADER)pLocalIp,
                            &fCreated,
                            &sr
                            );
        if (FAIL(Status)) break;

        //
        // NOTE: we already have claimed the pIF lock, which
        // which is the same as the pIF lock.
        //
        RM_ASSERT_SAME_LOCK_AS_PARENT(pLocalIp);

        // (Dbg only) Change lock scope from pIF to pLocalIp.
        //
        RmDbgChangeLockScope(
            &pIF->Hdr,
            &pLocalIp->Hdr,
            0x9cbc0b52,             // LocID
            &sr
            );

        if (fCreated)
        {

            if (AddressType == LLIP_ADDR_BCAST)
            {
                // Update the interface's broadcast address...
                //
                pIF->ip.BroadcastAddress = IpAddress;
            }
            else if (AddressType == LLIP_ADDR_LOCAL)
            {
                // Update the interface's default local IP address.
                // TODO: need to find another one if this address is removed.
                //
                pIF->ip.DefaultLocalAddress = IpAddress;
            }



            Status = arpInitializeLocalIp(
                    pLocalIp,
                    AddressType,
                    IpAddress,
                    Mask,
                    Context2,
                    &sr
                    );
            //
            // pLocalIp's lock is released above (which is actually the IF lock).
            //
            RM_ASSERT_NOLOCKS(&sr);
        }
        else
        {
            //
            // Hmm... this IP address already existed. Apparently it's possible for
            // MCAST addreses (IP/ATM arp module dealt with this for the MCAST case).
            // We don't special-case LOCAL/BCAST/MCAST addresses at this stage,
            // so we support multiple adds for all types of local IP addresses.
            //
            ASSERTEX(pLocalIp->AddAddressCount>0, pLocalIp);
            pLocalIp->AddAddressCount++;
        }

        RmTmpDereferenceObject(&pLocalIp->Hdr, &sr);

    } while (FALSE);

    TR_INFO((
            "IF 0x%p, Type %d, Addr %d.%d.%d.%d, Mask 0x%p, pLocIp 0x%p, Ret %d\n",
            pIF,
            AddressType,
            ((PUCHAR)(&IpAddress))[0],
            ((PUCHAR)(&IpAddress))[1],
            ((PUCHAR)(&IpAddress))[2],
            ((PUCHAR)(&IpAddress))[3],
            Mask, pLocalIp, !FAIL(Status)));

    RmUnlockAll(&sr);

    RM_ASSERT_CLEAR(&sr);
    EXIT()

    //
    // Translate Ndis Status to IPStatus
    //
    if (NDIS_STATUS_PENDING == Status)
    {
        IpStatus = IP_PENDING;
    }
    else
    {
        //            
        // If we are not going to pend, then IpStatus should return 1 in the success case and
        // 0 in the failure case
        //
        IpStatus = (!FAIL(Status));
    }

    return IpStatus;
}


UINT
ArpIpDelAddress(
    IN  PVOID                       Context,
    IN  UINT                        AddressType,
    IN  IP_ADDRESS                  IpAddress,
    IN  IP_MASK                     Mask
)
/*++

Routine Description:

    This is called from the IP layer when an address added via ArpIpAddAddress
    is to be deleted.

    Assumption: the given address was successfully added earlier.

Arguments:

    Context         - Actually a pointer to our Interface structure
    AddressType     - Type of address(es) being deleted.
    IpAddress       - Address to be deleted.
    Mask            - For the above.

Return Value:

    TRUE if successful, FALSE otherwise.

--*/
{
    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*) Context;
    ENTER("ArpIpDelAddress", 0xd6630961)
    ARPCB_LOCAL_IP *pLocalIp = NULL;
    NDIS_STATUS Status = NDIS_STATUS_FAILURE;
    RM_DECLARE_STACK_RECORD(sr)

    TR_INFO(("Enter. pIF = 0x%p\n", Context));
    ASSERT(pIF->Hdr.Sig == MTAG_INTERFACE);

#if OBSOLETE // See ArpIpAddAddress
    //
    // WARNING: We SHOULD NOT grab the IF lock, because we request that
    // the pLocalIp's lock be grabbed in RmLookupObjectInGroup below,
    // AND the pLocalIp's lock is actually the same as the IF lock.
    // (This is asserted later on below).
    // So obviously we can't get the IF lock here! (And we don't need to either).
    //
#endif // OBSOLETE

    LOCKOBJ(pIF, &sr);

    ASSERT(!CHECK_IF_IP_STATE(pIF, ARPIF_IPS_CLOSED));

    do
    {

        Status = RmLookupObjectInGroup(
                            &pIF->LocalIpGroup,
                            0,                   // Flags
                            (PVOID) ULongToPtr (IpAddress),  // pKey
                            NULL,                // pvCreateParams
                            &(PRM_OBJECT_HEADER)pLocalIp,
                            NULL, // pfCreated
                            &sr
                            );
        if (FAIL(Status))
        {
            UNLOCKOBJ(pIF, &sr);
            break;
        }

        //
        // NOTE: we have the pLocalIp lock, which is the same as the pIF lock.
        //
        RM_ASSERT_SAME_LOCK_AS_PARENT(pLocalIp);

        // (Dbg only) Change lock scope from pIF to pLocalIp.
        //
        RmDbgChangeLockScope(
            &pIF->Hdr,
            &pLocalIp->Hdr,
            0x188ed5b3,         // LocID
            &sr
            );

        if (pLocalIp->AddAddressCount <= 1)
        {
            ASSERTEX(pLocalIp->AddAddressCount == 1, pLocalIp);

            arpUnloadLocalIp(
                    pLocalIp,
                    &sr
                    );
            //
            // pLocalIp's lock is released above.
            //
            RM_ASSERT_NOLOCKS(&sr);
        }
        else
        {
            pLocalIp->AddAddressCount--;
            UNLOCKOBJ(pLocalIp, &sr);
        }

        RmTmpDereferenceObject(&pLocalIp->Hdr, &sr);

    } while (FALSE);

    TR_INFO((
            "IF 0x%p, Type %d, Addr %d.%d.%d.%d, Mask 0x%p, pLocIp 0x%p, Ret %d\n",
            pIF,
            AddressType,
            ((PUCHAR)(&IpAddress))[0],
            ((PUCHAR)(&IpAddress))[1],
            ((PUCHAR)(&IpAddress))[2],
            ((PUCHAR)(&IpAddress))[3],
            Mask, pLocalIp, !FAIL(Status)));

    RM_ASSERT_CLEAR(&sr);
    EXIT()
    return !FAIL(Status);
}


NDIS_STATUS
ArpIpMultiTransmit(
    IN  PVOID                       Context,
    IN  PNDIS_PACKET *              pNdisPacketArray,
    IN  UINT                        NumberOfPackets,
    IN  IP_ADDRESS                  Destination,
    IN  RouteCacheEntry *           pRCE        OPTIONAL,
    IN  void *                  ArpCtxt
)
/*++

    TODO: implement send array-of-packets. Currenty we just call
    ArpIpTransmit multiple times. We'll gain a few cycles by processing
    all at once, although it's not going to be a big gain, because we're pretty
    fast with the single-packet case, provided the RCE is valid.

Routine Description:

    This is called from the IP layer when it has a sequence of datagrams,
    each in the form of an NDIS buffer chain, to send over an Interface.

Arguments:

    Context             - Actually a pointer to our Interface structure
    pNdisPacketArray    - Array of Packets to be sent on this Interface
    NumberOfPackets     - Length of array
    Destination         - IP address of next hop for this packet
    pRCE                - Optional pointer to Route Cache Entry structure.

Return Value:

    NDIS_STATUS_PENDING if all packets were queued for transmission.
    If one or more packets "failed", we set the packet status to reflect
    what happened to each, and return NDIS_STATUS_FAILURE.

--*/
{
    NDIS_STATUS         Status = NDIS_STATUS_SUCCESS;
    PNDIS_PACKET *      ppNdisPacket;

    for (ppNdisPacket = pNdisPacketArray;
         NumberOfPackets > 0;
         NumberOfPackets--, ppNdisPacket++)
    {
        PNDIS_PACKET            pNdisPacket;

        pNdisPacket = *ppNdisPacket;
        NDIS_SET_PACKET_STATUS(pNdisPacket, NDIS_STATUS_PENDING);
        ASSERTEX(pNdisPacket->Private.Head != NULL, pNdisPacket);

        Status = ArpIpTransmit(
                        Context,
                        *ppNdisPacket,
                        Destination,
                        pRCE
                        ,NULL
                        );

        if (Status != NDIS_STATUS_PENDING)
        {
            NDIS_SET_PACKET_STATUS(*ppNdisPacket, Status);
            break;
        }
    }

    return Status;
}


NDIS_STATUS
ArpIpTransmit(
    IN  PVOID                       Context,
    IN  PNDIS_PACKET                pNdisPacket,
    IN  IP_ADDRESS                  Destination,
    IN  RouteCacheEntry *           pRCE        OPTIONAL,
    IN  void *                  ArpCtxt
)
/*++

    HOT PATH
    
Routine Description:

    This is called from the IP layer when it has a datagram (in the form of
    an NDIS buffer chain) to send over an Interface.

    The destination IP address is passed to us in this routine, which may
    or may not be the final destination for the packet. 

    The Route Cache Entry is created by the IP layer, and is used to speed
    up our lookups. An RCE, if specified, uniquely identifies atleast the
    IP destination for this packet. The RCE contains space for the ARP layer
    to keep context information about this destination. When the first packet
    goes out to a Destination, our context info in the RCE will be NULL, and
    we search the ARP Table for the matching IP Entry. However, we then fill
    our context info (pointer to IP Entry) in the RCE, so that subsequent
    transmits aren't slowed down by an IP address lookup.

Arguments:

    Context             - Actually a pointer to our Interface structure
    pNdisPacket         - Packet to be sent on this Interface
    Destination         - IP address of next hop for this packet
    pRCE                - Optional pointer to Route Cache Entry structure.

Return Value:

    Status of the transmit: NDIS_STATUS_SUCCESS, NDIS_STATUS_PENDING, or
    a failure.

--*/
{
    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*) Context;
    ARP1394_ADAPTER * pAdapter = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF );
    NDIS_STATUS Status;
    REMOTE_DEST_KEY        DestinationKey;
    ARP_INIT_REENTRANCY_COUNT()
    ENTER("IfTransmit", 0x46f1973e)

    ARP_INC_REENTRANCY();
    ASSERT_VALID_INTERFACE(pIF);

    // IP does sometimes call this function before we set our state to OPEN,
    // so this is an incorrect assert...
    // ASSERT(!CHECK_IF_IP_STATE(pIF, ARPIF_IPS_CLOSED));

    TR_INFO((
        "pIf 0x%p, Pkt 0x%p, Dst 0x%p, pRCE 0x%p\n",
        pIF, pNdisPacket, Destination, pRCE));

    DBGMARK(0xf87d7fff);
    NdisInterlockedIncrement (&ArpSends);

    // Since we don't hold any locks, this check is approximate, but it should
    // prevent lots of useless activity while we're trying to shutdown.
    //
    // Check for not Inited Or Low Power
    if (!CHECK_IF_PRIMARY_STATE(pIF, ARPIF_PS_INITED) || 
        (! CHECK_POWER_STATE(pAdapter, ARPAD_POWER_NORMAL) ))

    {
        TR_INFO(("Failing ArpIpTransmit because pIF 0x%p is closing.\n", pIF));

        ARP_DEC_REENTRANCY();
        NdisInterlockedIncrement (&ArpSendCompletes);
        NdisInterlockedIncrement (&ArpSendFailure);
        return NDIS_STATUS_FAILURE;                             // EARLY_RETURN
    }

#define LOGSTATS_TotSends(_pIF, _pNdisPacket) \
    NdisInterlockedIncrement(&((_pIF)->stats.sendpkts.TotSends))

#define LOGSTATS_SetPktTimestamp(_pIF, _pNdisPacket)                    \
    {                                                                   \
        LARGE_INTEGER liTemp = KeQueryPerformanceCounter(NULL);         \
        *(PULONG) ((_pNdisPacket)->WrapperReservedEx) = liTemp.LowPart; \
    }

    LOGSTATS_TotSends(pIF, pNdisPacket);
    LOGSTATS_SetPktTimestamp(pIF, pNdisPacket);

    //
    // If there is a RCE, we'll try to quickly get all the information we need
    // and send off the packet. If we can't do this, we resort to the 
    //  "slow send path" (call arpIpSlowtransmit)...
    //
    if (pRCE != NULL)
    {
        ARP_RCE_CONTEXT *   pArpRceContext;
        ARPCB_REMOTE_IP *   pRemoteIp;
        
        pArpRceContext =  ARP_OUR_CTXT_FROM_RCE(pRCE);

        ARP_FASTREADLOCK_IF_SEND_LOCK(pIF);

        pRemoteIp =  pArpRceContext->pRemoteIp;

        //
        // Validate the Remote Ip. If it not meant for this packet
        // fall back to the slow path
        //
        if (pRemoteIp != NULL && pRemoteIp->IpAddress == Destination)
        {
            ARPCB_DEST      *   pDest;

            pDest = pRemoteIp->pDest;
            if (pDest != NULL )
            {
                //
                // Note: pDest->sendinfo is protected by the IF send lock.
                //
                if (ARP_CAN_SEND_ON_DEST(pDest))
                {

#define LOGSTATS_FastSends(_pIF, _pNdisPacket) \
    NdisInterlockedIncrement(&((_pIF)->stats.sendpkts.FastSends))

                    LOGSTATS_FastSends(pIF, pNdisPacket);

                    arpSendIpPkt(pIF, pDest, pNdisPacket);
                    //
                    // IF Send lock released above.

                    ARP_DEC_REENTRANCY();
                    return NDIS_STATUS_PENDING;                 // EARLY RETURN
                }
            }
        }
        else
        {
            // if we have a mismatched RCE , then the RCE should be ignored
            // i,e. not be propagated to the SlowIpTransmit.
            //
            if (pRemoteIp != NULL && pRemoteIp->IpAddress != Destination)
            {
                pRCE = NULL;
            }
            
        }

        //
        // If we get here, it's on to slow path...
        //
        ARP_FASTUNLOCK_IF_SEND_LOCK(pIF);

    }

    // The slow path...
    //
    REMOTE_DEST_KEY_INIT(&DestinationKey);
    DestinationKey.IpAddress = Destination;
    Status = arpSlowIpTransmit(
                    pIF,
                    pNdisPacket,
                    DestinationKey,
                    pRCE
                    );

    if (Status != NDIS_STATUS_PENDING)
    {
        LOGSTATS_SendFifoCounts(pIF, pNdisPacket, Status);
    }

    ARP_DEC_REENTRANCY();
    EXIT()

    return Status;
}


NDIS_STATUS
ArpIpTransfer(
    IN  PVOID                       Context,
    IN  NDIS_HANDLE                 Context1,
    IN  UINT                        ArpHdrOffset,
    IN  UINT                        ProtoOffset,
    IN  UINT                        BytesWanted,
    IN  PNDIS_PACKET                pNdisPacket,
    OUT PUINT                       pTransferCount
)
/*++

Routine Description:

    This routine is called from the IP layer in order to copy in the
    contents of a received packet that we indicated up earlier. The
    context we had passed up in the receive indication is given back to
    us, so that we can identify what it was that we passed up.

    We simply call NDIS to do the transfer.

Arguments:

    Context             - Actually a pointer to our Interface structure
    Context1            - Packet context we had passed up (pointer to NDIS packet)
    ArpHdrOffset        - Offset we had passed up in the receive indicate
    ProtoOffset         - The offset into higher layer protocol data to start copy from
    BytesWanted         - The amount of data to be copied
    pNdisPacket         - The packet to be copied into
    pTransferCount      - Where we return the actual #bytes copied

Return Value:

    NDIS_STATUS_SUCCESS always.

--*/
{
    ENTER("IfTransfer", 0xa084562c)

    TR_INFO((
     "Ctx 0x%p, Ctx1 0x%p, HdrOff %d, ProtOff %d, Wanted %d, Pkt 0x%p\n",
            Context,
            Context1,
            ArpHdrOffset,
            ProtoOffset,
            BytesWanted,
            pNdisPacket));

    NdisCopyFromPacketToPacket(
            pNdisPacket,
            0,
            BytesWanted,
            (PNDIS_PACKET)Context1,
            ArpHdrOffset+ProtoOffset,
            pTransferCount
            );

    EXIT()
    return NDIS_STATUS_SUCCESS;
}


VOID
ArpIpInvalidate(
    IN  PVOID                       Context,
    IN  RouteCacheEntry *           pRCE
)
/*++

Routine Description:

    This routine is called from the IP layer to invalidate a Route Cache
    Entry. If this RCE is associated with one of our IP Entries, unlink
    it from the list of RCE's pointing to that IP entry.

Arguments:

    Context             - Actually a pointer to our Interface structure
    pRCE                - Pointer to Route Cache Entry being invalidated.

--*/
{
    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*) Context;
    ENTER("ArpIpInvalidate", 0xee77fb09)
    RM_DECLARE_STACK_RECORD(sr)

    TR_INFO(("Enter. pIF = 0x%p pRCE=0x%p\n", pIF, pRCE));

    ASSERT_VALID_INTERFACE(pIF);
    ASSERT(pRCE != NULL);

    DBGMARK(0xe35c780d);

    ARP_WRITELOCK_IF_SEND_LOCK(pIF, &sr);
    arpDelRce(pRCE, &sr);
    ARP_UNLOCK_IF_SEND_LOCK(pIF, &sr);

    RM_ASSERT_CLEAR(&sr);
    EXIT()


}


INT
ArpIpQueryInfo(
    IN      PVOID                   Context,
    IN      TDIObjectID *           pID,
    IN      PNDIS_BUFFER            pNdisBuffer,
    IN OUT  PUINT                   pBufferSize,
    IN      PVOID                   QueryContext
)
/*++

Routine Description:

    This is called from the IP layer to query for statistics or other
    information about an interface.

Arguments:

    Context                 - Actually a pointer to our Interface
    pID                     - Describes the object being queried
    pNdisBuffer             - Space for returning information
    pBufferSize             - Pointer to size of above. On return, we fill
                              it with the actual bytes copied.
    QueryContext            - Context value pertaining to the query.

Return Value:

    TDI Status code.

--*/
{
    UINT                    EntityType;
    UINT                    Instance;
    INT                     ReturnStatus;
    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*) Context;
    ENTER("ArpIpQueryInfo", 0x15059be1)
    RM_DECLARE_STACK_RECORD(sr)


    EntityType = pID->toi_entity.tei_entity;
    Instance = pID->toi_entity.tei_instance;


    TR_VERB((
        "IfQueryInfo: pIf 0x%p, pID 0x%p, pBuf 0x%p, Size %d, Ent %d, Inst %d\n",
            pIF, pID, pNdisBuffer, *pBufferSize, EntityType, Instance));
    ASSERT(pIF->Hdr.Sig == MTAG_INTERFACE);

    //
    //  Initialize
    //
    ReturnStatus = TDI_INVALID_PARAMETER;

    LOCKOBJ(pIF, &sr);

    do
    {
        if (!CHECK_IF_PRIMARY_STATE(pIF, ARPIF_PS_INITED))
        {
            if (!CHECK_IF_ACTIVE_STATE(pIF, ARPIF_AS_ACTIVATING))
            {
                ReturnStatus = TDI_INVALID_REQUEST;
                break;
            }
        }

        //
        //  Check the Entity and Instance values.
        //

        if ((EntityType != AT_ENTITY || Instance != pIF->ip.ATInstance) &&
            (EntityType != IF_ENTITY || Instance != pIF->ip.IFInstance))
        {
            TR_INFO(
                ("Mismatch: Entity %d, AT_ENTITY %d, Inst %d, IF AT Inst %d, IF_ENTITY %d, IF IF Inst %d\n",
                    EntityType,
                    AT_ENTITY,
                    Instance,
                    pIF->ip.ATInstance,
                    IF_ENTITY,
                    pIF->ip.IFInstance
                ));

            ReturnStatus = TDI_INVALID_REQUEST;
            break;
        }


        TR_VERB(("QueryInfo: pID 0x%p, toi_type %d, toi_class %d, toi_id %d\n",
            pID, pID->toi_type, pID->toi_class, pID->toi_id));


        if (pID->toi_type != INFO_TYPE_PROVIDER)
        {
            TR_INFO(("toi_type %d != PROVIDER (%d)\n",
                    pID->toi_type,
                    INFO_TYPE_PROVIDER));

            break;
        }

        if (pID->toi_class == INFO_CLASS_GENERIC)
        {
            if (pID->toi_id == ENTITY_TYPE_ID)
            {
                ReturnStatus = arpQueryIpEntityId(
                                        pIF,
                                        EntityType,
                                        pNdisBuffer,
                                        pBufferSize,
                                        &sr
                                        );
            }
            break;
        }

        if (EntityType == AT_ENTITY)
        {
            //
            //  This query is for an Address Translation Object.
            //
            if (pID->toi_id == AT_MIB_ADDRXLAT_INFO_ID)
            {
                ReturnStatus = arpQueryIpAddrXlatInfo(
                                        pIF,
                                        pNdisBuffer,
                                        pBufferSize,
                                        &sr
                                        );
            }
            else if (pID->toi_id == AT_MIB_ADDRXLAT_ENTRY_ID)
            {
                ReturnStatus = arpQueryIpAddrXlatEntries(
                                        pIF,
                                        pNdisBuffer,
                                        pBufferSize,
                                        QueryContext,
                                        &sr
                                        );
            }
            else
            {
                ReturnStatus = TDI_INVALID_PARAMETER;
            }
            break;
        }

        if (    pID->toi_class == INFO_CLASS_PROTOCOL
            &&  pID->toi_id == IF_MIB_STATS_ID)
        {
            ReturnStatus = arpQueryIpMibStats(
                                        pIF,
                                        pNdisBuffer,
                                        pBufferSize,
                                        &sr
                                        );
        }
    }
    while (FALSE);

    if (    ReturnStatus != TDI_SUCCESS
         && ReturnStatus != TDI_BUFFER_OVERFLOW
         && ReturnStatus != TDI_INVALID_REQUEST)
    {
        //
        // This again preserves the semantics of QueryInfo from atmarpc.sys...
        //
        *pBufferSize = 0;
    }

    TR_VERB(("Returning 0x%p (%s), BufferSize %d\n",
                    ReturnStatus,
                    ((ReturnStatus == TDI_SUCCESS)? "SUCCESS": "FAILURE"),
                    *pBufferSize
            ));

    UNLOCKOBJ(pIF, &sr);
    RM_ASSERT_CLEAR(&sr);
    EXIT()

    return (ReturnStatus);
}


INT
ArpIpSetInfo(
    IN      PVOID                   Context,
    IN      TDIObjectID *           pID,
    IN      PVOID                   pBuffer,
    IN      UINT                    BufferSize
)
/*++

Routine Description:

    This is called from the IP layer to set the value of an object
    for an interface.

Arguments:
    Context                 - Actually a pointer to our Interface
    pID                     - Describes the object being set
    pBuffer                 - Value for the object
    BufferSize              - Size of above

Return Value:

    TDI Status code.

--*/
{
    ARP1394_INTERFACE *pIF = (ARP1394_INTERFACE*) Context;
    UINT Entity, Instance;
    IFEntry *pIFE = (IFEntry *) pBuffer;
    NTSTATUS ReturnStatus = TDI_INVALID_REQUEST;
    IPNetToMediaEntry *IPNME = NULL;

    ENTER("IpSetInfo", 0x05dabea3)
    RM_DECLARE_STACK_RECORD(sr)

    //
    // This code is taken from the tcpip Arp module with some changes to adjust 
    // it to arp1394's internal structures
    //
    // This code only supports deleting Arp Entries
    //

    Entity = pID->toi_entity.tei_entity;
    Instance = pID->toi_entity.tei_instance;


    do
    {

        // First, make sure it's possibly an ID we can handle.
        if (Entity != AT_ENTITY || Instance != pIF->ip.ATInstance) 
        {
            TR_INFO(
                ("Mismatch: Entity %d, AT_ENTITY %d, Inst %d, IF AT Inst %d, IF_ENTITY %d, IF IF Inst %d\n",
                    Entity,
                    AT_ENTITY,
                    Instance,
                    pIF->ip.ATInstance,
                    IF_ENTITY,
                    pIF->ip.IFInstance
                ));

            ReturnStatus = TDI_INVALID_REQUEST;
            break;
        }

                
        if (pID->toi_type != INFO_TYPE_PROVIDER) {
            ReturnStatus = TDI_INVALID_REQUEST;
            break;

        }

    
        if (pID->toi_id != AT_MIB_ADDRXLAT_ENTRY_ID ||
            BufferSize < sizeof(IPNetToMediaEntry)) 
        {
            ReturnStatus = TDI_INVALID_REQUEST;
            break;
        }            

        // He does want to set an ARP table entry. See if he's trying to
        // create or delete one.

        IPNME = (IPNetToMediaEntry *) pBuffer;

        if (IPNME->inme_type != INME_TYPE_INVALID) 
        {
        
            ReturnStatus = TDI_INVALID_REQUEST;
            break;

        }

        // We need to delete the IP address passed in the ipnme struct                        
        
        ReturnStatus = arpDelArpEntry (pIF, IPNME->inme_addr, &sr);
        

    }while (FALSE);            

    EXIT();
    return ReturnStatus; 
    
}



INT
ArpIpGetEList(
    IN      PVOID                   Context,
    IN      TDIEntityID *           pEntityList,
    IN OUT  PUINT                   pEntityListSize
)
/*++

Routine Description:

    This routine is called when the interface starts up, in order to
    assign all relevant Entity Instance numbers for an interface.
    The ARP1394 module belongs to the "AT" and "IF" types. The entity
    list is a list of <Entity type, Instance number> tuples that have
    been filled in by other modules.

    For each of the entity types we support, we find the largest
    instance number in use (by walking thru the Entity list), and
    assign to ourselves the next larger number in each case. Using
    these numbers, we append our tuples to the end of the Entity list,
    if there is enough space.

    W2K: we may find that our entries are already present, in which
    case we don't create new entries.


Arguments:

    Context                 - Actually a pointer to our ARP1394_INTERFACE
    pEntityList             - Pointer to TDI Entity list
    pEntityListSize         - Pointer to length of above list. We update
                              this if we add our entries to the list.

Return Value:

    TRUE if successful, FALSE otherwise.

--*/
{
    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*) Context;
    UINT                EntityCount;    // Total elements in Entity list
    UINT                i;              // Iteration counter
    UINT                MyATInstance;   // "AT" Instance number we assign to ourselves
    UINT                MyIFInstance;   // "IF" Instance number we assign to ourselves
    INT                 ReturnValue;
    TDIEntityID *       pATEntity;      // Points to our AT entry
    TDIEntityID *       pIFEntity;      // Points to our IF entry
    ENTER("ArpIpGetEList", 0x8b5190e5)
    RM_DECLARE_STACK_RECORD(sr)

    ASSERT(pIF->Hdr.Sig == MTAG_INTERFACE);
    EntityCount = *pEntityListSize;
    pATEntity = NULL;
    pIFEntity = NULL;
    MyATInstance = MyIFInstance = 0;

    TR_INFO(("IfGetEList: pIf 0x%p, &pIF.ip 0x%p pList 0x%p, Cnt %d\n",
            pIF, &pIF->ip, pEntityList, EntityCount));

    LOCKOBJ(pIF, &sr);

    do
    {
        //
        //  Walk down the list, looking for AT/IF entries matching our
        //  instance values. Also remember the largest AT and IF instance
        //  values we see, so that we can allocate the next larger values
        //  for ourselves, in case we don't have instance values assigned.
        //
        for (i = 0; i < EntityCount; i++, pEntityList++)
        {
            //
            //  Skip invalid entries.
            //
            if (pEntityList->tei_instance == INVALID_ENTITY_INSTANCE)
            {
                continue;
            }

            if (pEntityList->tei_entity == AT_ENTITY)
            {
                if (pEntityList->tei_instance == pIF->ip.ATInstance)
                {
                    //
                    //  This is our AT entry.
                    //
                    pATEntity = pEntityList;
                }
                else
                {
                    if (MyATInstance < (pEntityList->tei_instance + 1))
                    {
                        MyATInstance = pEntityList->tei_instance + 1;
                    }
                }
            }
            else if (pEntityList->tei_entity == IF_ENTITY)
            {
                if (pEntityList->tei_instance == pIF->ip.IFInstance)
                {
                    //
                    //  This is our IF entry.
                    //
                    pIFEntity = pEntityList;
                }
                else
                {
                    if (MyIFInstance < (pEntityList->tei_instance + 1))
                    {
                        MyIFInstance = pEntityList->tei_instance + 1;
                    }
                }
            }
        }


        ReturnValue = TRUE;

        // WARNING: The following check is subtle -- we MUST set the instance
        // values to INVALID_ENTITY_INSTANCE when the interface is being
        // deactivated, but we MUST NOT do this if the interface is just opened
        // (ArpIpOpen called)  -- otherwise we could mess up the caller's state
        // to such an extent that a reboot is required. Basically our behaviour
        // here is what results in the proper acquiring AND release of instance IDs.
        //
        // So don't replace the following check by checking for
        // ARPIF_PS_INITED or ARPIF_IPS_OPEN or even ARPIF_PS_DEINITING.
        // The latter check (ARPIF_PS_DEINITING) would have been ok except for the
        // fact that the IF is deactivated/reactivated during ARPIF_PS_REINITING
        // as well, so the correct check is basically the one below...
        //
        //
        if(CHECK_IF_ACTIVE_STATE(pIF, ARPIF_AS_DEACTIVATING))
        {
            //
            // We're deactivating the interface, set values to invalid and
            // get out of here...
            //

            if (pATEntity)
            {
                pATEntity->tei_instance = INVALID_ENTITY_INSTANCE;
            }

            if (pIFEntity)
            {
                pIFEntity->tei_instance = INVALID_ENTITY_INSTANCE;
            }
            break;
        }

        //
        //  Update or create our Address Translation entry.
        //
        if (pATEntity)
        {
            //
            //  We found our entry, nothing to do...
            //
            TR_INFO(("YOWZA: Found existing AT entry.\n"));
        }
        else
        {
            //
            //  Grab an entry for ourselves...
            //
            TR_INFO(("YOWZA: Grabbing new AT entry 0x%lu.\n", MyATInstance));

            if (EntityCount >= MAX_TDI_ENTITIES)
            {
                ReturnValue = FALSE;
                break;
            }

            pEntityList->tei_entity = AT_ENTITY;
            pEntityList->tei_instance = MyATInstance;
            pIF->ip.ATInstance = MyATInstance;

            pEntityList++;
            (*pEntityListSize)++;
            EntityCount++;
        }

        //
        //  Update or create or IF entry.
        //
        if (pIFEntity)
        {
            //
            //  We found our entry, nothing to do...
            //
            TR_INFO(("YOWZA: Found existing IF entry.\n"));
        }
        else
        {
            //
            //  Grab an entry for ourselves.
            //
            TR_INFO(("YOWZA: Grabbing new IF entry 0x%lu.\n", MyIFInstance));

            if (EntityCount >= MAX_TDI_ENTITIES)
            {
                ReturnValue = FALSE;
                break;
            }

            pEntityList->tei_entity = IF_ENTITY;
            pEntityList->tei_instance = MyIFInstance;
            pIF->ip.IFInstance = MyIFInstance;

            pEntityList++;
            (*pEntityListSize)++;
            EntityCount++;
        }
    }
    while (FALSE);


    TR_INFO(
     ("IfGetEList: returning %d, MyAT %d, MyIF %d, pList 0x%p, Size %d\n",
        ReturnValue, MyATInstance, MyIFInstance, pEntityList, *pEntityListSize));

    UNLOCKOBJ(pIF, &sr);
    RM_ASSERT_CLEAR(&sr);
    EXIT()
    return (ReturnValue);
}



VOID
ArpIpPnPComplete(
    IN  PVOID                       Context,
    IN  NDIS_STATUS                 Status,
    IN  PNET_PNP_EVENT              pNetPnPEvent
)
/*++

Routine Description:

    This routine is called by IP when it completes a previous call
    we made to its PnP event handler. We complete the
    NDIS PNP notification that lead to this.

Arguments:

    Context                 - Actually a pointer to our ATMARP Interface
    Status                  - Completion status from IP
    pNetPnPEvent            - The PNP event

Return Value:

    None

--*/
{
    ENTER("ArpIpPnPComplete", 0x23b1941e)
    PARP1394_INTERFACE          pIF;

    pIF = (PARP1394_INTERFACE) Context;

    TR_INFO(("IfPnPComplete: IF 0x%p, Status 0x%p, Event 0x%p\n",
                    pIF, Status, pNetPnPEvent));

    if (pIF == NULL)
    {
        NdisCompletePnPEvent(
                    Status,
                    NULL,
                    pNetPnPEvent
                    );
    }
    else
    {
        PARP1394_ADAPTER pAdapter;
        ASSERT_VALID_INTERFACE(pIF);
        pAdapter = (PARP1394_ADAPTER) RM_PARENT_OBJECT(pIF);
        NdisCompletePnPEvent(
                Status,
                pAdapter->bind.AdapterHandle,
                pNetPnPEvent
                );
    }

    EXIT()
    return;
}


NDIS_STATUS         
ArpSendARPApi(
    void * pInterface, 
    IPAddr Destination, 
    void * pControlBlock
    )
/*++

Routine Description:

    This function is used by user mode components to ask us to 
    resolve an IP address.
    We Start a Task to do this. 

Arguments:

    Context                 - Actually a pointer to our Interface
    Dest                    - IP address to be resolved
    pControlBlock            - Used in completing the request

Return Value:

    None

--*/
{
    ENTER ("ArpResolveIP", 0xd631b91d)
    PARP1394_INTERFACE  pIF = (PARP1394_INTERFACE ) pInterface;
    PTASK_SEND_ARP_API  pSendArpTask = NULL;
    NDIS_STATUS         Status;
    RM_DECLARE_STACK_RECORD(sr)



    do
    {
        //
        // Let's start a resolution task and pend on it.
        //
        Status = arpAllocateTask(
                    &pIF->Hdr,                    // pParentObject
                    arpTaskSendARPApi,        // pfnHandler
                    0,                              // Timeout
                    "Task: SendARP API",       // szDescription
                    &(PRM_TASK)pSendArpTask ,
                    &sr
                    );
        if (FAIL(Status))
        {
            // Couldn't allocate task. We fail with STATUS_RESOURCES
            //
            Status = NDIS_STATUS_RESOURCES;
            break;
        }

        pSendArpTask->IPDest = Destination;
        pSendArpTask->pSendArpCB = pControlBlock;

        (VOID)RmStartTask(
                (PRM_TASK)pSendArpTask ,
                0, // UserParam unused
                &sr
                );
    
        Status = NDIS_STATUS_PENDING;

    } while (FALSE);

    return Status;
    EXIT()
}


NDIS_STATUS
arpTaskSendARPApi(
    IN  struct _RM_TASK *           pTask,
    IN  RM_TASK_OPERATION           Code,
    IN  UINT_PTR                    UserParam,
    IN  PRM_STACK_RECORD            pSR
    )
/*++

Routine Description:

    This task is called because of a call to the iphlpapi SenArp

    It sends out an ARP. If the IP address is present on the network,
    it will convert it to a 48 bit MAC address and return the MAC 
    address.

Arguments:

Return Value:

    None

--*/
{
    ENTER("arpTaskSendARPApi", 0x7b7d5d9d)

    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*)RM_PARENT_OBJECT (pTask);
    PARPCB_REMOTE_IP        pRemoteIp = ((PTASK_CONFLICT_IP)pTask)->pRemoteIp;
    NDIS_STATUS             Status = NDIS_STATUS_FAILURE;
    BOOLEAN                 fDerefRemoteIp = FALSE;
    PTASK_SEND_ARP_API      pSendArpTask= (PTASK_SEND_ARP_API )pTask;
    PRM_TASK                pResolutionTask = NULL;

    enum
    {
        PEND_AddressResolutionComplete,
    };




    switch(Code)
    {
        case RM_TASKOP_START:
        {
            REMOTE_DEST_KEY        Destination;
            UINT                 fRemoteIpCreated = FALSE;
            REMOTE_DEST_KEY_INIT(&Destination);
    
            //
            // Check to see if there is already a ResolveLocalIp Address Task
            // on this LocalIp
            //
            LOCKOBJ(pIF,pSR);

            //
            //Create the Remote Ip structure that will be used during resolve.
            //
            Destination.IpAddress = pSendArpTask->IPDest;

             //
            // Should we acquire the lock
            //
           
            Status = RmLookupObjectInGroup(
                            &pIF->RemoteIpGroup,
                            RM_CREATE,
                            (PVOID) &Destination,
                            (PVOID) (&Destination),   // pCreateParams
                            (RM_OBJECT_HEADER**) &pRemoteIp,
                            &fRemoteIpCreated,                   // pfCreated  (unused)
                            pSR
                            );
            LOGSTATS_TotalArpCacheLookups(pIF, Status);

            if (FAIL(Status))
            {
                OBJLOG1(
                    pIF,
                    "Couldn't lookup/create RemoteIpp entry with addr 0x%lx\n",
                    Destination.IpAddress
                    );
                Status = NDIS_STATUS_FAILURE;
                pRemoteIp = NULL;
                
                break;
            }
            

            pSendArpTask->fRemoteIpCreated = (fRemoteIpCreated == TRUE);

            fDerefRemoteIp  = TRUE;

            // First check if pRemoteIp is still allocated, if not we go away.
            //
            if (RM_IS_ZOMBIE(pRemoteIp))
            {
                Status = NDIS_STATUS_SUCCESS;
                break;
            }

            // pRemoteIp is allocated. Now check to see if we already have a destination
            //
            if (CHECK_REMOTEIP_RESOLVE_STATE(pRemoteIp,ARPREMOTEIP_RESOLVED)== TRUE)
            {
                ARPCB_DEST *pDest = pRemoteIp->pDest;
                ASSERT (pDest != NULL);
                ASSERT (pDest->Params.HwAddr.AddressType == NIC1394AddressType_FIFO);
                pSendArpTask->UniqueID = pDest->Params.HwAddr.FifoAddress.UniqueID;

                Status = NDIS_STATUS_SUCCESS;
                break;
            }
                
            
            // Now we check if there is an UnloadTask bound to pRemoteIP. This
            // is an IMPORTANT check -- because the unload task expects that
            // once it is bound to pRemoteIp, no new pSendPktsTasks will bind
            // themselves to pRemoteIp -- see arpTaskUnloadRemoteIp.
            //
            if (pRemoteIp->pUnloadTask != NULL)
            {
                Status = NDIS_STATUS_SUCCESS;
                break;
            }

            //
            // If there is a resolution task going, we  wait for it to complete.
            //

        #if RM_EXTRA_CHECKING
            RmLinkObjectsEx(
                &pRemoteIp->Hdr,
                &pTask->Hdr,
                0x34222bb1,
                ARPASSOC_REMOTEIP_RESOLVE_TASK,
                "    REMOTE_IP of 0x%p (%s)\n",
                ARPASSOC_TASK_TO_RESOLVE_REMOTEIP,
                "    TASK of 0x%p (%s)\n",
                pSR
                );
        #else // !RM_EXTRA_CHECKING
            RmLinkObjects(&pRemoteIp->Hdr, &pTask->Hdr, pSR);
        #endif // !RM_EXTRA_CHECKING

            pSendArpTask->pRemoteIp = pRemoteIp;
            pSendArpTask->fLinkedRemoteIp = TRUE;

            //
            // Let's start the address resolution task!
            //

            DBGMARK(0xd0da6726);

            //
            // Let's start a resolution task and pend on it.
            //
            Status = arpAllocateTask(
                        &pRemoteIp->Hdr,                    // pParentObject
                        arpTaskResolveIpAddress,        // pfnHandler
                        0,                              // Timeout
                        "Task: ResolveIpAddress",       // szDescription
                        &pResolutionTask,
                        pSR
                        );
            if (FAIL(Status))
            {
                // Couldn't allocate task. We fail with STATUS_RESOURCES
                //
                Status = NDIS_STATUS_RESOURCES;
            }
            else
            {
                UNLOCKOBJ(pIF,pSR);
                RmPendTaskOnOtherTask(
                    pTask,
                    PEND_AddressResolutionComplete,
                    pResolutionTask,
                    pSR
                    );

                (VOID)RmStartTask(
                        pResolutionTask,
                        0, // UserParam unused
                        pSR
                        );
            
                Status = NDIS_STATUS_PENDING;
            }
            break;
            
        } // START
        break;

        case  RM_TASKOP_PENDCOMPLETE:
        {
            switch(RM_PEND_CODE(pTask))
            {
                case  PEND_AddressResolutionComplete:
                {
                    
                        
                    ARPCB_DEST *pDest = pRemoteIp->pDest;
                    
                    ASSERT (pSendArpTask->UniqueID == 0);
                    //
                    // If we have a destination, then extract the Unique ID of that destination.
                    // We do not look at the state of the ResolveIpAddress Task
                    //
                    if (pDest != NULL &&                // The Resolve Task found a Destination
                        pDest->Params.HwAddr.AddressType == NIC1394AddressType_FIFO) // Dest is a Fifo
                    {
                        pSendArpTask->UniqueID = pDest->Params.HwAddr.FifoAddress.UniqueID;
                    }
                
                    Status = NDIS_STATUS_SUCCESS;
                    
                }
                break;

                default:
                {
                    ASSERTEX(!"Unknown pend op", pTask);
                }
                break;
    

            } // end switch(RM_PEND_CODE(pTask))

        } // case RM_TASKOP_PENDCOMPLETE
        break;

        case RM_TASKOP_END:
        {

            LOCKOBJ(pIF,pSR);
            
            if (pSendArpTask->fLinkedRemoteIp == TRUE)
            {
                #if RM_EXTRA_CHECKING
                    RmUnlinkObjectsEx(
                        &pRemoteIp->Hdr,
                        &pTask->Hdr,
                        0x5ad067aa,
                        ARPASSOC_REMOTEIP_RESOLVE_TASK,
                        ARPASSOC_TASK_TO_RESOLVE_REMOTEIP,
                        pSR
                        );
                #else // !RM_EXTRA_CHECKING
                    RmUnlinkObjects(&pRemoteIp->Hdr, &pTask->Hdr, pSR);
                #endif // !RM_EXTRA_CHECKING
            }

            UNLOCKOBJ(pIF,pSR);

            //
            // If the object is still alive and we were responsible for create it 
            // then delete the object.
            //
            if ((pSendArpTask->fRemoteIpCreated == TRUE) &&
                (!RM_IS_ZOMBIE(pRemoteIp))) 
            {
                PRM_TASK pUnloadTask= NULL;

                Status = arpAllocateTask(
                            &pRemoteIp->Hdr,                    // pParentObject
                            arpTaskUnloadRemoteIp,        // pfnHandler
                            0,                              // Timeout
                            "Task: Unload IP address",       // szDescription
                            &pUnloadTask,
                            pSR
                            );
                if (!FAIL(Status))
                {
                    (VOID)RmStartTask(
                            pUnloadTask,
                            0, // UserParam unused
                            pSR
                            );
                

                }
            }

            //
            // Complete the Send Arp Request
            //
            do
            {
                //
                // We check to see if a Unique ID has been filled in.
                //
                ENetAddr DestAddr;
                if (pSendArpTask->UniqueID == 0)
                {
                    pSendArpTask->IpStatus = IP_DEST_NET_UNREACHABLE;
                    break;
                }

                if (pSendArpTask->pSendArpCB->PhyAddrLen < sizeof (ENetAddr))
                {
                    pSendArpTask->IpStatus = IP_BUF_TOO_SMALL;
                    break;
                }

                //
                // Get the Ethernet version of the Unique ID
                //
                ASSERT(pSendArpTask->pSendArpCB->PhyAddr != NULL);
                nicGetMacAddressFromEuid(&pSendArpTask->UniqueID, &DestAddr);

                NdisMoveMemory(pSendArpTask->pSendArpCB->PhyAddr,&DestAddr, sizeof(DestAddr));
                pSendArpTask->pSendArpCB->PhyAddrLen = sizeof(ENetAddr);
              
                pSendArpTask->IpStatus = IP_SUCCESS;

            } while (FALSE);

            pSendArpTask->pSendArpCB->status = pSendArpTask->IpStatus ;

            ASSERT(pSendArpTask->pSendArpCB->CompletionRtn != NULL);

            pSendArpTask->pSendArpCB->CompletionRtn (pSendArpTask->pSendArpCB,pSendArpTask->IpStatus );

            
            
        }
        break; // RM_TASKOP_END:

        default:
        {
            ASSERTEX(!"Unexpected task op", pTask);
        }
        break;

    } // switch (Code)
        
    RmUnlockAll(pSR);

    if (fDerefRemoteIp== TRUE)
    {
        RmTmpDereferenceObject(&pRemoteIp->Hdr, pSR);
    }


    return Status;
}





NDIS_STATUS
arpTaskResolveLocalIp(
    IN  struct _RM_TASK *           pTask,
    IN  RM_TASK_OPERATION           Code,
    IN  UINT_PTR                    UserParam,
    IN  PRM_STACK_RECORD            pSR
    )
/*++

Routine Description:

    This routine is called to detect an IP address collision.
    When an IP address is set on this interface, it will attempt
    to resolve the IP address. If no machine responds to the ARP,
    it will succeed the AddAddress.

Arguments:

Return Value:


--*/

{
    ENTER("arpTaskResolveLocalIp", 0x42e587f3)

    ARPCB_LOCAL_IP *        pLocalIp = (ARPCB_LOCAL_IP *)RM_PARENT_OBJECT (pTask);
    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*)RM_PARENT_OBJECT (pLocalIp);
    PARPCB_REMOTE_IP        pRemoteIp = ((PTASK_CONFLICT_IP)pTask)->pRemoteIp;
    BOOLEAN                 fFailIpAddAddress = FALSE;
    NDIS_STATUS             Status = NDIS_STATUS_FAILURE;
    BOOLEAN                 fDerefRemoteIp = FALSE;
    PTASK_CONFLICT_IP       pConflictTask = (PTASK_CONFLICT_IP)pTask;
    enum
    {
        PEND_AddressResolutionComplete 
    };




    switch(Code)
    {
        case RM_TASKOP_START:
        {
            REMOTE_DEST_KEY        Destination;
            UINT                 fRemoteIpCreated = FALSE;
            REMOTE_DEST_KEY_INIT(&Destination);
    
            //
            // Check to see if there is already a ResolveLocalIp Address Task
            // on this LocalIp
            //
            LOCKOBJ(pLocalIp,pSR);

            if (pLocalIp->pConflictTask == NULL)
            {
                // if the current task is going to become the offical task, then
                // add a DbgAssoc
                //
                pLocalIp->pConflictTask = pTask;

            }
            else
            {
                Status = NDIS_STATUS_FAILURE;
                break;
            }

     
            //
            //Create the Remote Ip structure that will be used during resolve.
            //
            Destination.IpAddress = pLocalIp->IpAddress;

            //
            // Should we acquire the lock
            //
           
            Status = RmLookupObjectInGroup(
                            &pIF->RemoteIpGroup,
                            RM_CREATE,
                            (PVOID) &Destination,
                            (PVOID) (&Destination),   // pCreateParams
                            (RM_OBJECT_HEADER**) &pRemoteIp,
                            &fRemoteIpCreated,                   // pfCreated  (unused)
                            pSR
                            );
            LOGSTATS_TotalArpCacheLookups(pIF, Status);

            if (FAIL(Status))
            {
                OBJLOG1(
                    pIF,
                    "Couldn't lookup/create RemoteIpp entry with addr 0x%lx\n",
                    Destination.IpAddress
                    );
                Status = NDIS_STATUS_FAILURE;
                pRemoteIp = NULL;
                
                break;
            }
            
            pConflictTask->fRemoteIpCreated = (fRemoteIpCreated==TRUE); 
            fDerefRemoteIp  = TRUE;

            // First check if pRemoteIp is still allocated, if not we go away.
            //
            if (RM_IS_ZOMBIE(pRemoteIp))
            {
                Status = NDIS_STATUS_SUCCESS;
                break;
            }

            // pRemoteIp is allocated. Now check if there is already a
            // send-pkts task attached to pRemoteIp.
            //

            // Now we check if there is an UnloadTask bound to pRemoteIP. This
            // is an IMPORTANT check -- because the unload task expects that
            // once it is bound to pRemoteIp, no new pSendPktsTasks will bind
            // themselves to pRemoteIp -- see arpTaskUnloadRemoteIp.
            //
            if (pRemoteIp->pUnloadTask != NULL)
            {
                Status = NDIS_STATUS_SUCCESS;
                break;
            }


            //
            // If there is a resolution task going, we  wait for it to complete.
            //
            ASSERT (pRemoteIp->pResolutionTask == NULL);

            //
            // From this point on the Ref on the pRemote Ip will be derefed in this task.
            //
            pConflictTask->fLinkedRemoteIp= TRUE;
            
        #if RM_EXTRA_CHECKING
            RmLinkObjectsEx(
                &pRemoteIp->Hdr,
                &pTask->Hdr,
                0x34222bb1,
                ARPASSOC_REMOTEIP_RESOLVE_TASK,
                "    REMOTE_IP of 0x%p (%s)\n",
                ARPASSOC_TASK_TO_RESOLVE_REMOTEIP,
                "    TASK of 0x%p (%s)\n",
                pSR
                );
        #else // !RM_EXTRA_CHECKING
            RmLinkObjects(&pRemoteIp->Hdr, &pTask->Hdr, pSR);
        #endif // !RM_EXTRA_CHECKING

            pConflictTask->pRemoteIp = pRemoteIp; 


            if (pRemoteIp->pDest == NULL)
            {
                //
                // Let's start the address resolution task!
                //
                PRM_TASK pResolutionTask;
    
                DBGMARK(0xd0da6726);

                //
                // Let's start a resolution task and pend on it.
                //
                Status = arpAllocateTask(
                            &pRemoteIp->Hdr,                    // pParentObject
                            arpTaskResolveIpAddress,        // pfnHandler
                            0,                              // Timeout
                            "Task: ResolveIpAddress",       // szDescription
                            &pResolutionTask,
                            pSR
                            );
                if (FAIL(Status))
                {
                    // Couldn't allocate task. We fail with STATUS_RESOURCES
                    //
                    Status = NDIS_STATUS_RESOURCES;
                }
                else
                {
                    UNLOCKOBJ(pLocalIp,pSR);
                    RmPendTaskOnOtherTask(
                        pTask,
                        PEND_AddressResolutionComplete,
                        pResolutionTask,
                        pSR
                        );

    
                    (VOID)RmStartTask(
                            pResolutionTask,
                            0, // UserParam unused
                            pSR
                            );
                
                    Status = NDIS_STATUS_PENDING;
                }
            }
            else
            {
                //
                // if we already have a pDest, then we move on to the next stage
                // we do a fake suspend/resume so we move on to the next stage.
                //
                RmSuspendTask(pTask, PEND_AddressResolutionComplete, pSR);
                UNLOCKOBJ(pLocalIp, pSR);
                RmResumeTask(pTask, NDIS_STATUS_SUCCESS, pSR);

            }
          
        } // START
        break;

        case  RM_TASKOP_PENDCOMPLETE:
        {
            switch(RM_PEND_CODE(pTask))
            {
                case  PEND_AddressResolutionComplete:
                {
                    ARPCB_DEST *pDest = NULL;

                    
                    if (!ARP_ATPASSIVE())
                    {
                        // NOTE: we specify completion code PEND_AddressResolutionComplete
                        //       because we want to get back here (except
                        //       we'll be at passive).
                        //
                        RmSuspendTask(pTask, PEND_AddressResolutionComplete, pSR);
                        RmResumeTaskAsync(
                            pTask,
                            NDIS_STATUS_SUCCESS,
                            &(pConflictTask)->WorkItem,
                            pSR
                            );
                        Status = NDIS_STATUS_PENDING;
                        break;
                    }


                    // We ignore the status of address resolution -- instead
                    // we just check if there is a destination associated with
                    // pRemoteIp.
                    //
                    pDest = pRemoteIp->pDest;
                    pConflictTask->IpStatus=  IP_SUCCESS; 


                    if (pDest != NULL &&
                        pDest->Params.HwAddr.AddressType == NIC1394AddressType_FIFO )
                    {
                        // It is a Fifo destination, now match the unique ID
                        //
                        ARP1394_ADAPTER *pAdapter = (ARP1394_ADAPTER*)RM_PARENT_OBJECT(pIF);
                        UINT64 LocalUniqueId = pAdapter->info.LocalUniqueID;
                        UINT64 DestUniqueId = pDest->Params.HwAddr.FifoAddress.UniqueID ;

                        if(DestUniqueId != LocalUniqueId )
                        {

                            // The Unique Id's did not match.
                            // There is another card with this IP address 
                            //
                            pConflictTask->IpStatus=  IP_DUPLICATE_ADDRESS; 

                        }
                    
                    }
                        
                    //
                    // Call into Tcpip to indicate whether we found a conflict
                    //

                    ASSERT (pIF->ip.AddAddrCmplRtn!= NULL);

                    if (pIF->ip.AddAddrCmplRtn!= NULL)
                    {
                        pIF->ip.AddAddrCmplRtn (pLocalIp->IpAddress, 
                                                pLocalIp->pContext2,   
                                                pConflictTask->IpStatus);
                    }

                    
                }
                break;

                default:
                {
                    ASSERTEX(!"Unknown pend op", pTask);
                }
                break;
    

            } // end switch(RM_PEND_CODE(pTask))

        } // case RM_TASKOP_PENDCOMPLETE
        break;

        case RM_TASKOP_END:
        {
            //
            // if this task created the Remote Ip and the Remote Ip is still valid 
            // then delete it.
            //
            if ((pConflictTask->fRemoteIpCreated == TRUE) &&
                (!RM_IS_ZOMBIE(pRemoteIp) ) )
            {
                PRM_TASK pUnloadTask= NULL;

                Status = arpAllocateTask(
                            &pRemoteIp->Hdr,                    // pParentObject
                            arpTaskUnloadRemoteIp,        // pfnHandler
                            0,                              // Timeout
                            "Task: Unload IP address",       // szDescription
                            &pUnloadTask,
                            pSR
                            );
                if (!FAIL(Status))
                {
                    (VOID)RmStartTask(
                            pUnloadTask,
                            0, // UserParam unused
                            pSR
                            );
                
                }
            }


            // Clear out the pointer and association made above
            LOCKOBJ(pLocalIp,pSR);

            //
            //Add code to unload the Remote Ip structure once we are done with it.

            if (pLocalIp->pConflictTask == pTask)
            {
                // if the current task is going to become the offical task, then
                // add a DbgAssoc
                //
                pLocalIp->pConflictTask = NULL;

            }
            
            if (pConflictTask->fLinkedRemoteIp == TRUE)
            {
                // Unlink the Remote Ip from the current task

            #if RM_EXTRA_CHECKING
                RmUnlinkObjectsEx(
                    &pRemoteIp->Hdr,
                    &pTask->Hdr,
                    0x5ad067aa,
                    ARPASSOC_REMOTEIP_RESOLVE_TASK,
                    ARPASSOC_TASK_TO_RESOLVE_REMOTEIP,
                    pSR
                    );
            #else // !RM_EXTRA_CHECKING
                RmUnlinkObjects(&pRemoteIp->Hdr, &pTask->Hdr, pSR);
            #endif // !RM_EXTRA_CHECKING

            
                pConflictTask->pRemoteIp = NULL; 

            }

            UNLOCKOBJ (pLocalIp,pSR);


        }
        
        break; // RM_TASKOP_END:

        default:
        {
            ASSERTEX(!"Unexpected task op", pTask);
        }
        break;

    } // switch (Code)
        
    RmUnlockAll(pSR);

    if (fDerefRemoteIp == TRUE)
    {
        RmTmpDereferenceObject(&pRemoteIp->Hdr, pSR);
    }
    return Status;
}



NDIS_STATUS
arpCheckForAddressConflict (
    IN  ARPCB_LOCAL_IP * pLocalIp,  // LOCKIN NOLOCKOUT
    IN  UINT                        AddressType,
    IN  IP_ADDRESS                  IpAddress,
    IN  IP_MASK                     Mask,
    IN  PRM_STACK_RECORD            pSR
    )
/*++

Routine Description:

    This function check to see if there is another Destination on the Net with 
    the same IP address.

    It first creates a Task that will check for this Scenario.
    The Task will create a RemoteIp to represent the Destination.
    It will try and resolve the destination. If the Resolve Task succeeds then 
    arp1394 will invalidate the interface.

Arguments:

    pLocalIp        - The object to be initialized.
    AddressType     - One of the LLIP_ADDR_* constants.
    IpAddress       - The IP address of the object.
    Mask            - The mask associated with the IP address.

--*/
{

    NDIS_STATUS Status = NDIS_STATUS_FAILURE;
    PRM_TASK pTask = NULL;


    //
    // Allocate and start a task to unload pLocalIp;
    //
    do
    {

        Status = arpAllocateTask(
                    &pLocalIp->Hdr,             // pParentObject
                    arpTaskResolveLocalIp,       // pfnHandler
                    0,                              // Timeout
                    "Task: Resolve LocalIp", // szDescription
                    &pTask,
                    pSR
                    );

        if (Status != NDIS_STATUS_SUCCESS || pTask == NULL)
        {   
            pTask = NULL;
            break;
        }

        Status = RmStartTask(
                    pTask,
                    0, // UserParam (unused)
                    pSR
                    );

    } while (FALSE);

    return Status;
}
    


NDIS_STATUS
arpInitializeLocalIp(
    IN  ARPCB_LOCAL_IP * pLocalIp,  // LOCKIN NOLOCKOUT
    IN  UINT                        AddressType,
    IN  IP_ADDRESS                  IpAddress,
    IN  IP_MASK                     Mask,
    IN  PVOID                       pContext2,
    IN  PRM_STACK_RECORD            pSR
    )
/*++

Routine Description:

    Initialize the specified local ip object. This includines starting 
    address registration for the object.

Arguments:

    pLocalIp        - The object to be initialized.
    AddressType     - One of the LLIP_ADDR_* constants.
    IpAddress       - The IP address of the object.
    Mask            - The mask associated with the IP address.

--*/
{
    NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
    PARP1394_INTERFACE pIF = (PARP1394_INTERFACE)RM_PARENT_OBJECT(pLocalIp);
    ENTER("InitailizeLocalIp", 0x8a0ff47c)
        

    RM_DBG_ASSERT_LOCKED(&pLocalIp->Hdr, pSR);

    pLocalIp->IpAddress         = IpAddress;
    pLocalIp->IpMask            = Mask;
    pLocalIp->IpAddressType     = AddressType;
    pLocalIp->AddAddressCount   = 1;
    pLocalIp->pContext2          = pContext2;

    if (arpCanTryMcap(IpAddress))
    {
        SET_LOCALIP_MCAP(pLocalIp,  ARPLOCALIP_MCAP_CAPABLE);
    }

    UNLOCKOBJ(pLocalIp, pSR);

    if (AddressType == LLIP_ADDR_LOCAL)
    {
        Status = arpCheckForAddressConflict (pLocalIp,AddressType,IpAddress,Mask,pSR);
    }

    EXIT()
    return Status;        
}


VOID
arpUnloadLocalIp(
    IN  ARPCB_LOCAL_IP * pLocalIp,  // LOCKIN NOLOCKOUT
    IN  PRM_STACK_RECORD            pSR
    )
/*++

Routine Description:

    Starts a task to unload pLocalIp.
    The actual unload could happen asynchronously.

Arguments:

    pLocalIp        - The object to be unloaded.

--*/
{
    ARP1394_INTERFACE   *   pIF = (ARP1394_INTERFACE*) pLocalIp->Hdr.pParentObject;
    ENTER("arpDeinitializeLocalIp", 0x1db1015e)
    PRM_TASK pTask;
    NDIS_STATUS Status;

    TR_INFO(("Enter. pLocalIp = 0x%p\n", pLocalIp));

    RM_DBG_ASSERT_LOCKED(&pLocalIp->Hdr, pSR);

#if TODO // if it can be synchronously unloaded, no need to start a task
        // (on the other hand, I'm not sure we should bother)
    if (arpLocalIpReadyForSyncDeinit(pLocalIp, pSR))
    {
        arpSyncDeinitLocalIp(pLocalIp, pSR);    // Lock released on exit.
    }
#endif // TODO

    UNLOCKOBJ(pLocalIp, pSR);

    //
    // Allocate and start a task to unload pLocalIp;
    //

    Status = arpAllocateTask(
                &pLocalIp->Hdr,             // pParentObject
                arpTaskUnloadLocalIp,       // pfnHandler
                0,                              // Timeout
                "Task: unload LocalIp", // szDescription
                &pTask,
                pSR
                );


    if (FAIL(Status))
    {
        // TODO Need special allocation mechanism for unload-related tasks
        // that will block until a free task becomes available.
        // See notes.txt 03/09/1999 entry   "Special allocator for unload-related
        // tasks
        //
        TR_FATAL(("FATAL: couldn't alloc unload-local-ip task!\n"));
    }
    else
    {
        (void)RmStartTask(
                    pTask,
                    0, // UserParam (unused)
                    pSR
                    );
    }

    EXIT()
}


INT
arpQueryIpEntityId(
    ARP1394_INTERFACE *             pIF,                // LOCKIN LOCKOUT
    IN      UINT                    EntityType,
    IN      PNDIS_BUFFER            pNdisBuffer,
    IN OUT  PUINT                   pBufferSize,
    PRM_STACK_RECORD                pSR
)
/*++

Routine Description:

    Return  the entity ID for the specified EntityType.

Arguments:

    pIF                     - Interface
    EntityType              - QueryInfo entity type (AT_*)
    pNdisBuffer             - Space for returning information
    pBufferSize             - Pointer to size of above. On return, we fill
                              it with the actual bytes copied.
Return Value:

    TDI Status code.

--*/
{
    ENTER("arpQueryIpEntityId", 0x1ada17cb)
    UINT ReturnStatus;

    RM_DBG_ASSERT_LOCKED(&pIF->Hdr, pSR);

    if (*pBufferSize >= sizeof(UINT))
    {
        UINT EntityId;
        UINT ByteOffset = 0;
        TR_VERB(
            ("INFO GENERIC, ENTITY TYPE, BufferSize %d\n", *pBufferSize));

        EntityId = ((EntityType == AT_ENTITY) ? AT_ARP: IF_MIB);
        arpCopyToNdisBuffer(
                pNdisBuffer,
                (PUCHAR)&EntityId,
                sizeof(EntityId),
                &ByteOffset);

        // *pBufferSize = sizeof(UINT); << This was commented-out in atmarpc.sys
        *pBufferSize = 0; // To keep the same behavior as atmarpc.sys
        ReturnStatus = TDI_SUCCESS;
    }
    else
    {
        ReturnStatus = TDI_BUFFER_TOO_SMALL;
    }

    return ReturnStatus;
}


INT
arpQueryIpAddrXlatInfo(
    ARP1394_INTERFACE *             pIF,                // LOCKIN LOCKOUT
    IN      PNDIS_BUFFER            pNdisBuffer,
    IN OUT  PUINT                   pBufferSize,
    PRM_STACK_RECORD                pSR
)
/*++

Routine Description:

    Request for the number of entries in the address translation
    table, and the IF index.

Arguments:

    pIF                     - Interface
    pNdisBuffer             - Space for returning information
    pBufferSize             - Pointer to size of above. On return, we fill
                              it with the actual bytes copied.
    QueryContext            - Context value pertaining to the query.

Return Value:

    TDI Status code.

--*/
{
    UINT ReturnStatus;
    AddrXlatInfo    Info;
    ENTER("arpQueryIpXlatInfo", 0xd320b55a)

    RM_DBG_ASSERT_LOCKED(&pIF->Hdr, pSR);

    TR_INFO(("QueryInfo: AT Entity, for IF index, ATE size\n"));

    if (*pBufferSize >= sizeof(Info))
    {
        UINT ByteOffset = 0;

        ARP_ZEROSTRUCT(&Info);
        *pBufferSize = sizeof(Info);

        Info.axi_count =  RM_NUM_ITEMS_IN_GROUP(&pIF->RemoteIpGroup);
        Info.axi_index = pIF->ip.IFIndex;

        arpCopyToNdisBuffer(
                pNdisBuffer,
                (PUCHAR)&Info,
                sizeof(Info),
                &ByteOffset);

        ReturnStatus = TDI_SUCCESS;
    }
    else
    {
        ReturnStatus = TDI_BUFFER_TOO_SMALL;
    }

    EXIT()
    return ReturnStatus;
}


VOID
arpCopyDestInfoIntoInmeInfo (
    PUCHAR pinme_physaddr,
    PARPCB_DEST pDest
    )
/*++

Routine Description:

Copy the correct destination address to the location provided 
In the Fifo Send case, we need to report the Fake Mac Address
In all other cases, we'll report the first six bytes of the destination

Arguments:
    pinme_physaddr  - Location we need to fill up.
    pdest

Return Value:

    TDI Status code.

--*/

{
    PNIC1394_DESTINATION pNicDest = &pDest->Params.HwAddr;
    ENetAddr               FakeEnetAddress = {0,0,0,0,0,0};
    PUCHAR              pDestAddr = NULL;


    //
    // This assertion is important for this function to work. 
    // If it is changed, then we can no longer use FakeMac Addresses 
    // to identify remote nodes. We will have to revert back to using Unique IDs
    //
    ASSERT (sizeof(ENetAddr) == ARP1394_IP_PHYSADDR_LEN);

            
    if (NIC1394AddressType_FIFO == pNicDest->AddressType &&
        pDest->Params.ReceiveOnly== FALSE)
    {

        //
        // We are translating an entry that describes a SendFifo Destination
        //

        
        //
        // Use the same algorithm as nic1394 uses to get a 
        // MAC address to report back to IP
        //
        if (pNicDest->FifoAddress.UniqueID != 0)
        {
            nicGetMacAddressFromEuid(&pNicDest->FifoAddress.UniqueID, &FakeEnetAddress);
        }

        pDestAddr = (PUCHAR) &FakeEnetAddress;

    }   
    else
    {
        // We'll use the first six bytes of the NIC1394_DESTINATION
        //

        
        // We copy the 1st ARP1394_IP_PHYSADDR_LEN bytes of the address...
        // (In the case of a channel, only the 1st 4 bytes (UINT Channel)
        // are significant; The rest will be all zeros.)
        //
        pDestAddr = (PUCHAR)pNicDest;

    }


    NdisMoveMemory (pinme_physaddr, pDestAddr, ARP1394_IP_PHYSADDR_LEN);

}



arpQueryIpAddrXlatEntries(
    ARP1394_INTERFACE *             pIF,                // LOCKIN LOCKOUT
    IN      PNDIS_BUFFER            pNdisBuffer,
    IN OUT  PUINT                   pBufferSize,
    IN      PVOID                   QueryContext,
    PRM_STACK_RECORD                pSR
)
/*++

Routine Description:

    Return as many AddrXlat entries (aka arp entries) as will fit
    into the specified buffer.


Arguments:

    pIF                     - Interface
    pNdisBuffer             - Space for returning information
    pBufferSize             - Pointer to size of above. On return, we fill
                              it with the actual bytes copied.
    QueryContext            - Context value pertaining to the query.

Return Value:

    TDI Status code.

--*/
{
    //
    // Our context structure is laid out as follows
    //
    typedef struct
    {
        IP_ADDRESS IpAddr;

        // UINT TableSize; << TODO To deal with dynamic changes in table-size.

    } OUR_QUERY_CONTEXT;

    OUR_QUERY_CONTEXT * pOurCtxt;
    UINT                ReturnStatus;
    UINT                ByteOffset;
    UINT                BytesCopied;
    UINT                BufferSize;
    ARPCB_REMOTE_IP *   pRemoteIp;
    NDIS_STATUS         Status;
    ENTER("arpQueryIpXlatEntries", 0x61c86684)

    TR_INFO(("QueryInfo: AT Entity, for reading ATE\n"));
    RM_DBG_ASSERT_LOCKED(&pIF->Hdr, pSR);

    // See notes.txt entry ..
    //   03/04/1999   JosephJ  Size of the context passed in ArpIpQueryInfo.
    //
    ASSERT(sizeof(OUR_QUERY_CONTEXT) <= 16);

    BufferSize      = *pBufferSize;
    *pBufferSize    = 0;
    BytesCopied     = 0;
    ByteOffset      = 0;
    pOurCtxt        = (OUR_QUERY_CONTEXT*) QueryContext;
    pRemoteIp       = NULL;

    ReturnStatus = TDI_SUCCESS;

    //
    // Our context structure is supposed to be initialized with Zeros the 1st time
    // it's called.
    //
    if (pOurCtxt->IpAddr == 0)
    {
        //
        // This is a brand new context. So we get the 1st entry.
        //
        Status = RmGetNextObjectInGroup(
                    &pIF->RemoteIpGroup,
                    NULL,
                    &(PRM_OBJECT_HEADER)pRemoteIp,
                    pSR
                    );
        if (FAIL(Status))
        {
            // Presumably there are no entries.
            pRemoteIp = NULL;
        }
    }
    else
    {
        //
        // This is an ongoing context. Let's look up this IP address, which is
        // supposed to be the IP address of the next item in the arp table.
        //
        Status = RmLookupObjectInGroup(
                        &pIF->RemoteIpGroup,
                        0,                              // Flags
                        (PVOID) ULongToPtr (pOurCtxt->IpAddr),      // pKey
                        NULL,                           // pvCreateParams
                        &(PRM_OBJECT_HEADER)pRemoteIp,
                        NULL, // pfCreated
                        pSR
                        );
        if (FAIL(Status))
        {
            //
            // Ah well, things have changed since the last time we were called,
            // and now this entry is no longer around.
            //
            pRemoteIp = NULL;
        }
    }

    while (pRemoteIp != NULL)
    {
        ARPCB_REMOTE_IP *   pNextRemoteIp = NULL;
        IPNetToMediaEntry   ArpEntry;

        if (((INT)BufferSize - (INT)BytesCopied) < sizeof(ArpEntry))
        {
            //
            // out of space; Update the context, and set special return value.
            //
            ARP_ZEROSTRUCT(pOurCtxt);
            pOurCtxt->IpAddr = pRemoteIp->IpAddress;


            ReturnStatus = TDI_BUFFER_OVERFLOW;
            RmTmpDereferenceObject(&pRemoteIp->Hdr, pSR);
            pRemoteIp = NULL;
            break;
        }

        // Prepare the XlatEntry in ArpEntry.
        //
        {
            ARP_ZEROSTRUCT(&ArpEntry);

            ArpEntry.inme_index = pIF->ip.IFIndex;
            ArpEntry.inme_addr  = pRemoteIp->IpAddress;
            if (CHECK_REMOTEIP_RESOLVE_STATE(pRemoteIp, ARPREMOTEIP_RESOLVED))
            {
                ARPCB_DEST *pDest = pRemoteIp->pDest;

                TR_INFO(("ReadNext: found Remote IP Entry 0x%x, Addr %d.%d.%d.%d\n",
                            pRemoteIp,
                            ((PUCHAR)(&(pRemoteIp->IpAddress)))[0],
                            ((PUCHAR)(&(pRemoteIp->IpAddress)))[1],
                            ((PUCHAR)(&(pRemoteIp->IpAddress)))[2],
                            ((PUCHAR)(&(pRemoteIp->IpAddress)))[3]
                        ));
        
                // We assert that
                // IF lock is the same as pRemoteIp's and pDest's lock,
                // and that lock is locked.
                // We implicitly assert that pDest is non-NULl as well.
                //
                ASSERTEX(pRemoteIp->Hdr.pLock == pDest->Hdr.pLock, pRemoteIp);
                RM_DBG_ASSERT_LOCKED(&pRemoteIp->Hdr, pSR);

                ArpEntry.inme_physaddrlen =  ARP1394_IP_PHYSADDR_LEN;

                // We copy the 1st ARP1394_IP_PHYSADDR_LEN bytes of the address...
                // (In the case of a channel, only the 1st 4 bytes (UINT Channel)
                // are significant; The rest will be all zeros.)
                //
                ASSERT(sizeof(pDest->Params.HwAddr)>=ARP1394_IP_PHYSADDR_LEN);

                arpCopyDestInfoIntoInmeInfo (ArpEntry.inme_physaddr,pDest);
        
                if (CHECK_REMOTEIP_SDTYPE(pRemoteIp, ARPREMOTEIP_STATIC))
                {
                    ArpEntry.inme_type = INME_TYPE_STATIC;
                }
                else
                {
                    ArpEntry.inme_type = INME_TYPE_DYNAMIC;
                }
            }
            else
            {
                ArpEntry.inme_physaddrlen   = 0;
                ArpEntry.inme_type          = INME_TYPE_INVALID;
            }
        }

        // Copy into the supplied ndis buffer.
        //
        BytesCopied += sizeof(ArpEntry);
        pNdisBuffer = arpCopyToNdisBuffer(
                        pNdisBuffer,
                        (PUCHAR)&ArpEntry,
                        sizeof(ArpEntry),
                        &ByteOffset
                        );

        // Lookup next entry's IP address and save it in our context.
        //
        Status = RmGetNextObjectInGroup(
                        &pIF->RemoteIpGroup,
                        &pRemoteIp->Hdr,
                        &(PRM_OBJECT_HEADER)pNextRemoteIp,
                        pSR
                        );

        if (FAIL(Status))
        {
            //
            // we're presumably done. 
            //
            pNextRemoteIp = NULL;
        }

        // TmpDeref pRemoteIp and move on to the next one.
        //
        RmTmpDereferenceObject(&pRemoteIp->Hdr, pSR);
        pRemoteIp = pNextRemoteIp;

    }

    ASSERT(pRemoteIp == NULL);

    *pBufferSize = BytesCopied;


    EXIT()
    return ReturnStatus;
}


arpQueryIpMibStats(
    ARP1394_INTERFACE *             pIF,                // LOCKIN LOCKOUT
    IN      PNDIS_BUFFER            pNdisBuffer,
    IN OUT  PUINT                   pBufferSize,
    PRM_STACK_RECORD                pSR
)
/*++

Routine Description:

    Fill out Interface-level statistics.

Arguments:

    pIF                     - Interface
    pNdisBuffer             - Space for returning information
    pBufferSize             - Pointer to size of above. On return, we fill
                              it with the actual bytes copied.

Return Value:

    TDI Status code.

--*/
{
    ENTER("arpQueryIpMibStatus", 0xc5bc364f)
    UINT    ReturnStatus;
    UINT    BufferSize;
    
    TR_VERB(("QueryInfo: MIB statistics\n"));
    RM_DBG_ASSERT_LOCKED(&pIF->Hdr, pSR);

    BufferSize      = *pBufferSize;
    *pBufferSize    = 0;

    do
    {
        IFEntry             ife;
        ARP1394_ADAPTER *   pAdapter;
        UINT                ByteOffset;
        UINT                BytesCopied;
    
        //
        //  Check if we have enough space.
        //
        if (BufferSize < IFE_FIXED_SIZE)
        {
            ReturnStatus = TDI_BUFFER_TOO_SMALL;
            break;
        }
    
        ARP_ZEROSTRUCT(&ife);
        pAdapter        = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
        BytesCopied     = 0;
        ByteOffset      = 0;

        //
        // Fill out mib info...
        //

        ife.if_index    = pIF->ip.IFIndex;
        ife.if_mtu      = pIF->ip.MTU;
        ife.if_type     = IF_TYPE_IEEE1394;
        ife.if_speed    = pAdapter->info.Speed;
    
        // Set adminstatus and operstatus (computed from pIF->Hdr.State)
        //
        ife.if_adminstatus = IF_STATUS_UP;
        ife.if_operstatus = IF_OPER_STATUS_OPERATIONAL;
        
        if (CHECK_IF_PRIMARY_STATE(pIF, ARPIF_PS_DEINITING))
        {
            ife.if_adminstatus = IF_STATUS_DOWN;
        }
        if (!CHECK_IF_IP_STATE(pIF, ARPIF_IPS_OPEN))
        {
            ife.if_operstatus = IF_OPER_STATUS_NON_OPERATIONAL;
        }

        // Stats...
        //
        ife.if_lastchange       = pIF->stats.LastChangeTime;
        ife.if_inoctets         = pIF->stats.InOctets;
        ife.if_inucastpkts      = pIF->stats.InUnicastPkts;
        ife.if_innucastpkts     = pIF->stats.InNonUnicastPkts;
        ife.if_indiscards       = pIF->stats.InDiscards;
        ife.if_inerrors         = pIF->stats.InErrors;
        ife.if_inunknownprotos  = pIF->stats.UnknownProtos;
        ife.if_outoctets        = pIF->stats.OutOctets;
        ife.if_outucastpkts     = pIF->stats.OutUnicastPkts;
        ife.if_outnucastpkts    = pIF->stats.OutNonUnicastPkts;
        ife.if_outdiscards      = pIF->stats.OutDiscards;
        ife.if_outerrors        = pIF->stats.OutErrors;
        ife.if_outqlen          = pIF->stats.OutQlen;

        ife.if_descrlen         = pAdapter->info.DescriptionLength;

    
        ASSERT(ARP1394_IP_PHYSADDR_LEN <= sizeof(pAdapter->info.EthernetMacAddress));
        ife.if_physaddrlen = ARP1394_IP_PHYSADDR_LEN;

    #if 1 // MILLEN
        //
        //  Win98: winipcfg doesn't like more than 6 bytes repored here.
        //
        if (ife.if_physaddrlen > 6)
        {
            ife.if_physaddrlen = 6;
        }
    #endif// MILLEN


        //
        // Tell TCPIP that the Ethernet Address is the real physical address.
        // This helps us because now we have the same 'MAC' address whether 
        // we are in a network which is bridged to Ethernet or not.
        //
        NdisMoveMemory(
                ife.if_physaddr,
                &(pAdapter->info.EthernetMacAddress),
                ife.if_physaddrlen
                );
    
        arpCopyToNdisBuffer(
                pNdisBuffer,
                (PUCHAR)&ife,
                IFE_FIXED_SIZE,
                &ByteOffset);
    
        if (BufferSize >= (IFE_FIXED_SIZE + ife.if_descrlen))
        {
            if (ife.if_descrlen != 0)
            {
                arpCopyToNdisBuffer(
                        pNdisBuffer,
                        pAdapter->info.szDescription,
                        ife.if_descrlen,
                        &ByteOffset);
            }
            *pBufferSize = IFE_FIXED_SIZE + ife.if_descrlen;
            ReturnStatus = TDI_SUCCESS;
        }
        else
        {
            *pBufferSize = IFE_FIXED_SIZE;
            ReturnStatus = TDI_BUFFER_OVERFLOW;
        }

    } while (FALSE);

    EXIT()
    return ReturnStatus;
}


PNDIS_BUFFER
arpCopyToNdisBuffer(
    IN  PNDIS_BUFFER                pDestBuffer,
    IN  PUCHAR                      pDataSrc,
    IN  UINT                        LenToCopy,
    IN OUT  PUINT                   pOffsetInBuffer
)
/*++

Routine Description:

    Copy data into an NDIS buffer chain. Use up as much of the given
    NDIS chain as needed for "LenToCopy" bytes. After copying is over,
    return a pointer to the first NDIS buffer that has space for writing
    into (for the next Copy operation), and the offset within this from
    which to start writing.

Arguments:

    pDestBuffer     - First NDIS buffer in a chain of buffers
    pDataSrc        - Where to copy data from
    LenToCopy       - How much data to copy
    pOffsetInBuffer - Offset in pDestBuffer where we can start copying into.

Return Value:

    The NDIS buffer in the chain where the next Copy can be done. We also
    set *pOffsetInBuffer to the write offset in the returned NDIS buffer.

--*/
{
    //
    //  Size and destination for individual (contiguous) copy operations
    //
    UINT            CopySize;
    PUCHAR          pDataDst;

    //
    //  Start Virtual address for each NDIS buffer in chain.
    //
    PUCHAR          VirtualAddress;

    //
    //  Offset within pDestBuffer
    //
    UINT            OffsetInBuffer = *pOffsetInBuffer;

    //
    //  Bytes remaining in current buffer
    //
    UINT            DestSize;

    //
    //  Total Buffer Length
    //
    UINT            BufferLength;


    ASSERT(pDestBuffer != (PNDIS_BUFFER)NULL);
    ASSERT(pDataSrc != NULL);

#if MILLEN
    NdisQueryBuffer(
            pDestBuffer,
            &VirtualAddress,
            &BufferLength
            );
#else
    NdisQueryBufferSafe(
            pDestBuffer,
            &VirtualAddress,
            &BufferLength,
            NormalPagePriority
            );

    if (VirtualAddress == NULL)
    {
        return (NULL);
    }
#endif
    
    ASSERT(BufferLength >= OffsetInBuffer);

    pDataDst = VirtualAddress + OffsetInBuffer;
    DestSize = BufferLength - OffsetInBuffer;

    for (;;)
    {
        CopySize = LenToCopy;
        if (CopySize > DestSize)
        {
            CopySize = DestSize;
        }

        NdisMoveMemory(pDataDst, pDataSrc, CopySize);

        pDataDst += CopySize;
        pDataSrc += CopySize;

        LenToCopy -= CopySize;
        if (LenToCopy == 0)
        {
            break;
        }

        DestSize -= CopySize;

        if (DestSize == 0)
        {
            //
            //  Out of space in the current buffer. Move to the next.
            //
            pDestBuffer = NDIS_BUFFER_LINKAGE(pDestBuffer);

            if (pDestBuffer == NULL)
            {
                ASSERT(FALSE);
                return NULL;
            }
            else
            {
            #if MILLEN
                NdisQueryBuffer(
                        pDestBuffer,
                        &VirtualAddress,
                        &BufferLength
                        );
            #else // !MILLEN
                NdisQueryBufferSafe(
                        pDestBuffer,
                        &VirtualAddress,
                        &BufferLength,
                        NormalPagePriority
                        );
    
                if (VirtualAddress == NULL)
                {
                    return NULL;
                }
            #endif // !MILLEN
                pDataDst = VirtualAddress;
                DestSize = BufferLength;
            }
        }
    }

    *pOffsetInBuffer = (UINT) (pDataDst - VirtualAddress);

    return (pDestBuffer);
}


VOID
arpSendIpPkt(
    IN  ARP1394_INTERFACE       *   pIF,            // LOCKIN NOLOCKOUT (IF send lk)
    IN  PARPCB_DEST                 pDest,
    IN  PNDIS_PACKET                pNdisPacket
    )
/*++

    HOT PATH

Routine Description:

    Send a packet to the FIFO/channel associated with destination object pDest.

Arguments:

    pIF             - Our interface object
    pDest           - Destination object on which to send packet
    pNdisPacket     - Packet to send

--*/
{
    NDIS_STATUS Status;
    MYBOOL      fRet;
    ARP1394_ADAPTER *   pAdapter =
                            (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
    MYBOOL      fBridgeMode = ARP_BRIDGE_ENABLED(pAdapter);

    DBGMARK(0xdaab68c3);

    //
    // If we can't send now, we immediately call IP's send complete handler.
    //
    if (!ARP_CAN_SEND_ON_DEST(pDest))
    {
        ARP_FASTUNLOCK_IF_SEND_LOCK(pIF);

        if (ARP_DEST_IS_FIFO(pDest))
        {
            LOGSTATS_SendFifoCounts(pIF, pNdisPacket, NDIS_STATUS_FAILURE);
        }
        else
        {
            LOGSTATS_SendChannelCounts(pIF, pNdisPacket, NDIS_STATUS_FAILURE);
        }
        #if MILLEN
            ASSERT_PASSIVE();
        #endif // MILLEN
        NdisInterlockedIncrement (&ArpSendCompletes);
        NdisInterlockedIncrement (&ArpSendFailure);


        if (fBridgeMode)
        {
            // In bridge (ethernet emulation) mode, we created the
            // packets ourselves, so we delete them here, instead
            // of calling Ip's completion handler, which in fact
            // is NULL.
            //
            RM_DECLARE_STACK_RECORD(sr)
            arpFreeControlPacket(
                    pIF,
                    pNdisPacket,
                    &sr
                    );
        }
        else
        {
            (*(pIF->ip.TxCmpltHandler))(
                        pIF->ip.Context,
                        pNdisPacket,
                        NDIS_STATUS_FAILURE
                        );
        }
        return;                                         // EARLY RETURN
    }

    arpRefSendPkt( pNdisPacket, pDest);

    // Release the IF send lock.
    //
    ARP_FASTUNLOCK_IF_SEND_LOCK(pIF);


    // NOW (with IF send lock released), we prepare the IP packet for sending....
    //
    // We do this only if not in ethernet emulation (bridge) mode,
    // because all IP packets in bridge mode already have the
    // proper 1394 header on them.
    //
    if (!fBridgeMode)
    {
        PNDIS_BUFFER            pNdisBuffer;    // First buffer in the IP packet
    
    // TODO: is this safe? How about a check for the size by which this is possible!
    #if !MILLEN
        #define ARP_BACK_FILL_POSSIBLE(_pBuf) \
                    (((_pBuf)->MdlFlags & MDL_NETWORK_HEADER) != 0)
    #else // MILLEN
        #define ARP_BACK_FILL_POSSIBLE(_pBuf)   (0)
    #endif // MILLEN
    
        //
        //  We look at the first buffer in the IP packet, to see whether
        //  it has space reserved for low-layer headers. If so, we just
        //  use it up. Otherwise, we allocate a header buffer of our own.
        //
        NdisQueryPacket(pNdisPacket, NULL, NULL, &pNdisBuffer, NULL);

        ASSERTEX(pNdisBuffer != NULL, pNdisPacket);
        if (ARP_BACK_FILL_POSSIBLE(pNdisBuffer))
        {
            const ULONG EncapLength = sizeof(Arp1394_IpEncapHeader);
    
        #if MILLEN
    
            ASSERT(!"We shouldn't be here -- check ARP_BACK_FILL_POSSIBLE()");
    
        #else   // !MILLEN


            (PUCHAR)pNdisBuffer->MappedSystemVa -= EncapLength;
            pNdisBuffer->ByteOffset             -= EncapLength;
            pNdisBuffer->ByteCount              += EncapLength;
            NdisMoveMemory(
                pNdisBuffer->MappedSystemVa,
                &Arp1394_IpEncapHeader,
                EncapLength
                );


#define LOGSTATS_BackFills(_pIF, _pNdisPacket) \
    NdisInterlockedIncrement(&((_pIF)->stats.sendpkts.BackFills))

            LOGSTATS_BackFills(pIF, pNdisPacket);
    
        #endif  // !MILLEN
        }
        else
        {
            //
            // Backfill wasn't possible for this packet. Let's try to allocate
            // an encapsulation header buffer from the IF pool...
            //
    
            pNdisBuffer =  arpAllocateConstBuffer(&pIF->sendinfo.HeaderPool);
    
            if (pNdisBuffer != (PNDIS_BUFFER)NULL)
            {
                // Our send complete handler relies on this assertion to decide
                // whether backfill happened or not.
                //
                ASSERT(!ARP_BACK_FILL_POSSIBLE(pNdisBuffer));

                NdisChainBufferAtFront(pNdisPacket, pNdisBuffer);
            }
            else
            {
                //
                // Oops, we couldn't allocate an encapsulation buffer!
                // We've already referenced the destination for sends.
                //

                //
                // Cop out for now (we haven't implemented all the  queuing
                // code for now) by calling our own send complete handler with
                // status failure.
                //
                // We use the special return value NDIS_STATUS_NOT_RESETTABLE
                // to indicate that we haven't inserted our own buffer,
                // (and so the packet shouldn't be "reset"). Ok this is a bit
                // hacky, but it works.
                //
                arpCompleteSentPkt(
                        NDIS_STATUS_NOT_RESETTABLE,
                        pIF,
                        pDest,
                        pNdisPacket
                        );

                return;                                 // EARLY RETURN
            }
        }
    }

    

    
    // Actually send the packet
    //
#if ARPDBG_FAKE_SEND
    arpDbgFakeNdisCoSendPackets(
            pDest->VcHdr.NdisVcHandle,
            &pNdisPacket,
            1,
            &pDest->Hdr,
            &pDest->VcHdr
        );
#else   // !ARPDBG_FAKE_SEND
    NdisCoSendPackets(
            pDest->VcHdr.NdisVcHandle,
            &pNdisPacket,
            1
        );
#endif  // !ARPDBG_FAKE_SEND

}


NDIS_STATUS
arpSlowIpTransmit(
    IN  ARP1394_INTERFACE       *   pIF,
    IN  PNDIS_PACKET                pNdisPacket,
    IN  REMOTE_DEST_KEY             Destination,
    IN  RouteCacheEntry *           pRCE        OPTIONAL
    )
/*++

Routine Description:

    This is the path taken (hopefully only for a small fraction of the packets)
    when something has prevented the packet from being immediately sent down to
    the miniport. Typically we're here for one of the following reasons:
    1. IP Address is not resolved yet.
    2. RCE entry has not been initialized yet.
    3. Couldn't allocate an encapsulation-header buffer.
    4. The Vc to the destination doesn't exist or is not ready for sending yet.


Arguments:

    pIF             - Our interface object
    pNdisPacket     - Packet to send
    Destination     - IP address of destination
    pRCE            - (OPTIONAL) Route Cache Entry associated with this
                      destination

Return Value:
    
    NDIS_STATUS_SUCCESS         on synchronous success.
    NDIS_STATUS_PENDING         if completion is asynchronous
    Other ndis status code      on other kinds of failure.

--*/
{
    NDIS_STATUS Status = NDIS_STATUS_FAILURE;
    ARP1394_ADAPTER *   pAdapter = (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
    ENTER("arpSlowIpTransmit", 0xe635299c)
    BOOLEAN fBridgeMode = ARP_BRIDGE_ENABLED(pAdapter);
    ULONG   LookupFlags = 0;
    UINT fRemoteIpCreated = FALSE;
    RM_DECLARE_STACK_RECORD(sr)

    DBGMARK(0x30b6f7e2);

    do
    {
        ARP_RCE_CONTEXT *   pArpRceContext  = NULL;
        ARPCB_REMOTE_IP *   pRemoteIp       = NULL;
        ARPCB_DEST      *   pDest           = NULL;

#define LOGSTATS_SlowSends(_pIF, _pNdisPacket) \
    NdisInterlockedIncrement(&((_pIF)->stats.sendpkts.SlowSends))
#define LOGSTATS_MediumSends(_pIF, _pNdisPacket) \
    NdisInterlockedIncrement(&((_pIF)->stats.sendpkts.MediumSends))

        //
        // If there is a RCE, we try to get the pRemoteIp from it  If not
        // successful, we'll need to actually lookup/create the pRemoteIp from the
        // IF RemoteIpGroup.
        //

        if (pRCE != NULL)
        {
            pArpRceContext  = ARP_OUR_CTXT_FROM_RCE(pRCE);

            // All RCE linkages are protected by the IF send lock.
            //
            ARP_READLOCK_IF_SEND_LOCK(pIF, &sr);
            pRemoteIp       = pArpRceContext->pRemoteIp;
            if (pRemoteIp != NULL)
            {
                RmTmpReferenceObject(&pRemoteIp->Hdr, &sr);
            }
            ARP_UNLOCK_IF_SEND_LOCK(pIF, &sr);
        }

        if (pRemoteIp == NULL)
        {
            //
            // Either there was no RCE or it was uninitialized.
            // We'll lookup/create the pRemoteIp based on the destination
            // IP address...
            //

            RM_ASSERT_NOLOCKS(&sr);

            //
            // Create the destination, this will cause us to resolve IP Addresses, etc/
            //                                        
            LookupFlags  = RM_CREATE; 


            if (fBridgeMode == TRUE)
            {
                //
                // do not create a remote IP struct, only look it up.
                // In bridge mode, Remote Structs are created while
                // translating ARP packets.
                //
                LookupFlags = 0;
            }
            // if in bridge mode
            // set flags to zero , else RM_CREATE

            Status = RmLookupObjectInGroup(
                            &pIF->RemoteIpGroup,
                            LookupFlags,
                            (PVOID) &Destination,
                            (PVOID) (&Destination),   // pCreateParams
                            (RM_OBJECT_HEADER**) &pRemoteIp,
                            &fRemoteIpCreated,                   // pfCreated  (unused)
                            &sr
                            );
            LOGSTATS_TotalArpCacheLookups(pIF, Status);
            if (FAIL(Status))
            {
                OBJLOG1(
                    pIF,
                    "Couldn't lookup/create localIp entry with addr 0x%lx\n",
                    Destination.IpAddress
                    );
                Status = NDIS_STATUS_FAILURE;
                break;
            }

          
            //
            // If there is a RCE, we make it point to pRemoteIp.
            //
            if (pRCE != NULL)
            {

                // All RCE linkages are protected by the IF send lock.
                //
                ARP_WRITELOCK_IF_SEND_LOCK(pIF, &sr);

                if (pArpRceContext->pRemoteIp != NULL)
                {
                    if (pArpRceContext->pRemoteIp != pRemoteIp)
                    {
                        ARPCB_REMOTE_IP *   pStaleRemoteIp;
                        //
                        // We've got a wierd situation here: initially
                        // pRCE didn't point to any pRemoteIp, so we looked up
                        // a pRemoteIp ourselves. Now that we've got the IF send
                        // lock, we find that pRCE is pointing to a different
                        // pRemoteIp than the one we looked up!
                        //
                        // What to do? We ignore pRemoteIp (the one we looked up)
                        // and instead use pArpRceContext->pRemoteIp...
                        //
                        ASSERTEX(!"RCE pRemoteIp mismatch", pArpRceContext);
                        pStaleRemoteIp = pRemoteIp;
                        pRemoteIp = pArpRceContext->pRemoteIp;
                        RmTmpReferenceObject(&pRemoteIp->Hdr, &sr);
                        ARP_UNLOCK_IF_SEND_LOCK(pIF, &sr);
                        RM_ASSERT_NOLOCKS(&sr);
                        RmTmpDereferenceObject(&pStaleRemoteIp->Hdr, &sr);
                        ARP_WRITELOCK_IF_SEND_LOCK(pIF, &sr);
                    }
                }
                else
                {
                    // Add the association between pRCE and pRemoteIp...
                    //
                    arpAddRce(pRemoteIp, pRCE, &sr);   // LOCKIN LOCKOUT (IF send lk)
                }

                ARP_UNLOCK_IF_SEND_LOCK(pIF, &sr);
            }
        }

        //
        // At this point, we should have a pRemoteIp, with a tmpref on it,
        // and no locks held.
        //
        ASSERT_VALID_REMOTE_IP(pRemoteIp);
        RM_ASSERT_NOLOCKS(&sr);

        //
        // Queue the packet on pRemoteIp's send pkt queue, and start the 
        // SendPkts task on this pRemoteIp if required.
        //
        {
        
            LOCKOBJ(pRemoteIp, &sr);

            // NOTE: This field is not always modified with the lock held -- in
            // the fast send path, it's simply set to true.
            // This field is used in garbage collecting pRemoteIps.
            //
            pRemoteIp->sendinfo.TimeLastChecked = 0;

            //
            // Stats.
            // TODO -- we need to directly deal with "medium sends"
            // instead of starting up a task just because the RCEs are NULL
            // -- mcast and udp pkts have null RCEs, it turns out.
            //

            if (    pRemoteIp->pDest != NULL
                 && ARP_CAN_SEND_ON_DEST(pRemoteIp->pDest))
            {
                LOGSTATS_MediumSends(pIF, pNdisPacket);
            }
            else
            {
                LOGSTATS_SlowSends(pIF, pNdisPacket);
            }

            
            if (pRemoteIp->pSendPktsTask == NULL)
            {
                PRM_TASK pTask;

                // There is no send-pkts task. Let's try to alloc and start one..
                Status = arpAllocateTask(
                            &pRemoteIp->Hdr,            // pParentObject
                            arpTaskSendPktsOnRemoteIp,      // pfnHandler
                            0,                              // Timeout
                            "Task: SendPktsOnRemoteIp", // szDescription
                            &pTask,
                            &sr
                            );
                if (FAIL(Status))
                {
                    // Oops, couldn't allocate task. We fail with STATUS_RESOURCES
                    UNLOCKOBJ(pRemoteIp, &sr);
                    Status = NDIS_STATUS_RESOURCES;
                    break;
                }

                //
                // Queue the pkt first, THEN start the task. This makes sure that
                // the packet WILL be taken care of.
                // TODO: Currently, it's possible that the RemoteIp's unload
                // task will not wait for send pkts to be cleared up IF it checks
                // BEFORE the task before is started. This hole needs
                // to be fixed.
                //
                arpQueuePktOnRemoteIp(
                    pRemoteIp,      // LOCKIN LOCKOUT
                    pNdisPacket,
                    &sr
                    );

                UNLOCKOBJ(pRemoteIp, &sr);

                (VOID) RmStartTask( pTask, 0, &sr);
            }
            else
            {
                //
                // There is already a send-pkts task. Simply queue the pkt.
                //
                arpQueuePktOnRemoteIp(
                    pRemoteIp,      // LOCKIN LOCKOUT
                    pNdisPacket,
                    &sr
                    );
                UNLOCKOBJ(pRemoteIp, &sr);
            }

            // We're done!
            // Remove the tmp reference on pRemoteIp, and set status to PENDING.
            //
            RM_ASSERT_NOLOCKS(&sr);
            RmTmpDereferenceObject(&pRemoteIp->Hdr, &sr);
            Status = NDIS_STATUS_PENDING;
        }

    } while (FALSE);
    
    RM_ASSERT_CLEAR(&sr)

    EXIT()
    return Status;
}



VOID
arpAddRce(
    IN  ARPCB_REMOTE_IP *pRemoteIp, // IF send lock WRITELOCKIN WRITELOCKOUT
    IN  RouteCacheEntry *pRce,
    IN  PRM_STACK_RECORD pSR
    )
/*++

Routine Description:

        Link the RCE pRce with the remote ip object pRemoteIp.
--*/
{
    ARP_RCE_CONTEXT *   pArpRceContext;
    MYBOOL              fDoRef;

    pArpRceContext  = ARP_OUR_CTXT_FROM_RCE(pRce);
    fDoRef          = (pRemoteIp->sendinfo.pRceList == NULL);

    ASSERT(pArpRceContext->pRemoteIp == NULL);

    // Add pRce to pRemoteIP's list of RCEs.
    //
    pArpRceContext->pNextRce = pRemoteIp->sendinfo.pRceList;
    pRemoteIp->sendinfo.pRceList = pRce;

    // Add pointer from pRce to pRemoteIp
    //
    pArpRceContext->pRemoteIp = pRemoteIp;


    // The following macros are just so that we can make the proper debug association
    // depending on how closely we are tracking outstanding send packets.
    //
#if ARPDBG_REF_EVERY_RCE
    fDoRef = TRUE;
    #define OUR_EXTERNAL_ENTITY ((UINT_PTR) pRce)
    #define szARPSSOC_EXTLINK_RIP_TO_RCE_FORMAT "    Linked to pRce 0x%p\n"
#else // !ARPDBG_REF_EVERY_RCE
    #define OUR_EXTERNAL_ENTITY ((UINT_PTR)  &pRemoteIp->sendinfo)
    #define szARPSSOC_EXTLINK_RIP_TO_RCE_FORMAT "    Outstanding RCEs exist. &si=0x%p\n"
#endif // !ARPDBG_REF_EVERY_RCE


    if (fDoRef)
    {
        //
        // If ARPDBG_REF_EVERY_RCE
        //      We add an "external" link for EVERY RCE. We'll later remove this
        //      reference when the RCE is invalidated.
        // else
        //      Only a transition from zero to non-zero RCEs, we
        //      add an "external" link. We'll later remove this link when the
        //      transition from non-zero to zero happens.
        //

    #if RM_EXTRA_CHECKING

        RM_DECLARE_STACK_RECORD(sr)

        RmLinkToExternalEx(
            &pRemoteIp->Hdr,                            // pHdr
            0x22224c96,                             // LUID
            OUR_EXTERNAL_ENTITY,                    // External entity
            ARPASSOC_EXTLINK_RIP_TO_RCE,            // AssocID
            szARPSSOC_EXTLINK_RIP_TO_RCE_FORMAT,
            &sr
            );

    #else   // !RM_EXTRA_CHECKING

        RmLinkToExternalFast(&pRemoteIp->Hdr);

    #endif // !RM_EXTRA_CHECKING

    }

    #undef  OUR_EXTERNAL_ENTITY
    #undef  szARPSSOC_EXTLINK_RIP_TO_RCE
}


VOID
arpDelRce(
    IN  RouteCacheEntry *pRce,  // IF send lock WRITELOCKIN WRITELOCKOUTD
    IN  PRM_STACK_RECORD pSR
    )
/*++

Routine Description:

        Unlink RCE pRce from remote ip object pRemoteIp.

--*/
{
    ARPCB_REMOTE_IP *   pRemoteIp;
    ARP_RCE_CONTEXT *   pArpRceContext;
    MYBOOL              fDoDeref;
    RouteCacheEntry **  ppRce;

    pArpRceContext  = ARP_OUR_CTXT_FROM_RCE(pRce);
    pRemoteIp       = pArpRceContext->pRemoteIp;

    if (pRemoteIp == NULL)
    {
        // We haven't initialized this RCE yet. Nothing to do...
        //
        return;                                                 // EARLY RETURN
    }


    if (VALID_REMOTE_IP(pRemoteIp)== FALSE)
    {
        return;
    }

    // Remove pRce from pRemoteIP's list of RCEs.
    //
    for(
        ppRce = &pRemoteIp->sendinfo.pRceList;
        *ppRce != NULL;
        ppRce = &(ARP_OUR_CTXT_FROM_RCE(*ppRce)->pNextRce))
    {
        if (*ppRce == pRce) break;

    }
    if (*ppRce == pRce)
    {
        *ppRce =  pArpRceContext->pNextRce;
    }
    else
    {
        ASSERTEX(!"RCE Not in pRemoteIp's list!", pRce);
    }
    ARP_ZEROSTRUCT(pArpRceContext);

    fDoDeref        = (pRemoteIp->sendinfo.pRceList == NULL);

    // The following macros are just so that we can make the proper debug association
    // depending on how closely we are tracking outstanding send packets.
    //
#if ARPDBG_REF_EVERY_RCE
    fDoDeref = TRUE;
    #define OUR_EXTERNAL_ENTITY ((UINT_PTR) pRce)
#else // !ARPDBG_REF_EVERY_RCE
    #define OUR_EXTERNAL_ENTITY ((UINT_PTR)  &pRemoteIp->sendinfo)
#endif // !ARPDBG_REF_EVERY_RCE

    if (fDoDeref)
    {
        //
        // If ARPDBG_REF_EVERY_RCE
        //      We add an "external" link for EVERY RCE. We'll later remove this
        //      reference when the RCE is invalidated.
        // else
        //      Only a transition from zero to non-zero RCEs, we
        //      add an "external" link. We'll later remove this link when the
        //      transition from non-zero to zero happens.
        //

    #if RM_EXTRA_CHECKING

        RM_DECLARE_STACK_RECORD(sr)

        RmUnlinkFromExternalEx(
            &pRemoteIp->Hdr,                        // pHdr
            0x940df668,                             // LUID
            OUR_EXTERNAL_ENTITY,                    // External entity
            ARPASSOC_EXTLINK_RIP_TO_RCE,            // AssocID
            &sr
            );

    #else   // !RM_EXTRA_CHECKING

        RmUnlinkFromExternalFast(&pRemoteIp->Hdr);

    #endif // !RM_EXTRA_CHECKING

    }

    #undef  OUR_EXTERNAL_ENTITY
}


VOID
arpDelRceList(
    IN  PARPCB_REMOTE_IP  pRemoteIp,    // IF send lock WRITELOCKIN WRITELOCKOUTD
    IN  PRM_STACK_RECORD pSR
    )
/*++

Routine Description:
    Walks the RCE List, deleting each RoutCache Entry


--*/
{

    RouteCacheEntry *   pRce = pRemoteIp->sendinfo.pRceList;

    //
    // Delete all the Rce present on this remote Ip
    //

    while (pRce!= NULL)
    {
        //
        // Delete the Rce and reduce the Ref
        //
        arpDelRce (pRce, pSR);

        //
        // Get the next RCE
        //
        pRce = pRemoteIp->sendinfo.pRceList;
    }


}


NDIS_STATUS
arpTaskSendPktsOnRemoteIp(
    IN  struct _RM_TASK *           pTask,
    IN  RM_TASK_OPERATION           Code,
    IN  UINT_PTR                    UserParam,  // Unused
    IN  PRM_STACK_RECORD            pSR
    )
/*++

Routine Description:

    Task handler responsible for  sending queued packets on the pRemoteIp which
    is its parent object. If required it must start the registration task and/or
    the make-call task on the destination object.

Arguments:
    
    UserParam   for (Code ==  RM_TASKOP_START)          : unused

--*/
{
    ENTER("TaskSendPktsOnRemoteIp", 0xbc285d98)
    NDIS_STATUS         Status;
    ARPCB_REMOTE_IP*    pRemoteIp;
    ARP1394_INTERFACE * pIF;
    ARPCB_DEST        * pDest;
    MYBOOL              fMakeCallIfRequired;
    PARP1394_ADAPTER    pAdapter;
    MYBOOL              fBridgeMode;

    // Following are the list of pending states for this task.
    //
    enum
    {
        PEND_AddressResolutionComplete,
        PEND_MakeCallComplete
    };

    Status              = NDIS_STATUS_FAILURE;
    pRemoteIp           = (ARPCB_REMOTE_IP*) RM_PARENT_OBJECT(pTask);
    pIF                 = (ARP1394_INTERFACE*) RM_PARENT_OBJECT(pRemoteIp);
    pAdapter            = (PARP1394_ADAPTER) RM_PARENT_OBJECT(pIF);
    pDest               = NULL;
    fMakeCallIfRequired = FALSE;
    fBridgeMode         = ARP_BRIDGE_ENABLED(pAdapter);
            


    ASSERT_VALID_INTERFACE(pIF);
    ASSERT_VALID_REMOTE_IP(pRemoteIp);

    DBGMARK(0x6f31a739);

    switch(Code)
    {
        case RM_TASKOP_START:
        {
            LOCKOBJ(pRemoteIp, pSR);

            // First check if pRemoteIp is still allocated, if not we go away.
            //
            if (RM_IS_ZOMBIE(pRemoteIp))
            {
                Status = NDIS_STATUS_SUCCESS;
                break;
            }

            // pRemoteIp is allocated. Now check if there is already a
            // send-pkts task attached to pRemoteIp.
            //
            if (pRemoteIp->pSendPktsTask != NULL)
            {
                //
                // There is a sendpkts task. Nothing for us to do -- simply return.
                //
                Status = NDIS_STATUS_SUCCESS;
                break;
            }

            // Now we check if there is an UnloadTask bound to pRemoteIP. This
            // is an IMPORTANT check -- because the unload task expects that
            // once it is bound to pRemoteIp, no new pSendPktsTasks will bind
            // themselves to pRemoteIp -- see arpTaskUnloadRemoteIp.
            //
            if (pRemoteIp->pUnloadTask != NULL)
            {
                Status = NDIS_STATUS_SUCCESS;
                break;
            }

            //
            // There is no sendpkts task going on. Let's
            // make this task THE sendpkts task.
            // 
            pRemoteIp->pSendPktsTask = pTask;

            //
            // Since we're THE sendpks task, add an association to pRemoteIp,
            // which will only get cleared when the  pRemoteIp->pSendPktsTask field
            // above is cleared.
            //
            DBG_ADDASSOC(
                &pRemoteIp->Hdr,                    // pObject
                pTask,                              // Instance1
                pTask->Hdr.szDescription,           // Instance2
                ARPASSOC_REMOTEIP_SENDPKTS_TASK,    // AssociationID
                "    Official sendpkts task 0x%p (%s)\n", // szFormat
                pSR
                );

            if (pRemoteIp->pDest == NULL)
            {   
                MYBOOL bIsDestNonUnicastAddr = FALSE;
                //
                // There is no pDest associated with pRemoteIp.
                // If this is an on-unicast address, we link the local ip
                // object to the broadcast object and proceed.
                // NOTE: arpIsNonUnicastIpAddress is not a trivial operation -- it
                // actually enumerates all local IP addresses. Fortunately we only
                // call it for the FIRST packet sent out to an unresolved address.
                //
                bIsDestNonUnicastAddr  = arpIsNonUnicastIpAddress(pIF, pRemoteIp->IpAddress, pSR);

                //
                // In the Bridge mode, we always have Dest structure for each
                // pRemoteIP. This is because they are created simultaeneously
                // when translating ARP packets
                //
                ASSERT (fBridgeMode == FALSE);
                
                if (bIsDestNonUnicastAddr == TRUE)
                {
                    ASSERT(pIF->pBroadcastDest != NULL); // Don't really expect it.

                    if (pIF->pBroadcastDest != NULL)
                    {
                        //
                        // Note: arpLinkRemoteIpToDest expects the locks
                        // on both pRemoteIp and pIF->pBroadcastDest to be
                        // held. We know that this is the case because both
                        // share the same lock, which is the IF lock.
                        //
                        RM_DBG_ASSERT_LOCKED(&pIF->pBroadcastDest->Hdr, pSR);
                        arpLinkRemoteIpToDest(
                                pRemoteIp,
                                pIF->pBroadcastDest,
                                pSR
                                );
                        SET_REMOTEIP_FCTYPE(pRemoteIp, ARPREMOTEIP_CHANNEL);
                        SET_REMOTEIP_SDTYPE(pRemoteIp, ARPREMOTEIP_DYNAMIC);
                #if 0
                        if (CHECK_REMOTEIP_MCAP(pRemoteIp,  ARPREMOTEIP_MCAP_CAPABLE))
                        {
                            SET_REMOTEIP_SDTYPE(pRemoteIp, ARPREMOTEIP_DYNAMIC);
                        }
                        else
                        {
                            //
                            // We don't age out broadcast addresses.
                            //
                            SET_REMOTEIP_SDTYPE(pRemoteIp, ARPREMOTEIP_STATIC);
                        }
                #endif // 0
                    }
                }
            }


            //
            // If there is a resolution task going, we  wait for it to complete.
            //
            if (pRemoteIp->pResolutionTask != NULL)
            {
                PRM_TASK pOtherTask = pRemoteIp->pResolutionTask;
                ASSERT (fBridgeMode == FALSE);
                TR_WARN(("Resolution task %p exists; pending on it.\n", pOtherTask));
                RmTmpReferenceObject(&pOtherTask->Hdr, pSR);

                UNLOCKOBJ(pRemoteIp, pSR);
                RmPendTaskOnOtherTask(
                    pTask,
                    PEND_AddressResolutionComplete,
                    pOtherTask,
                    pSR
                    );
                RmTmpDereferenceObject(&pOtherTask->Hdr, pSR);
                Status = NDIS_STATUS_PENDING;
                break;
            }

            //
            // There is no address resolution task. Let's see if the
            // address has been resolved. If not, we need to start the address
            // resolution task.
            //
            if (pRemoteIp->pDest == NULL)
            {
                //
                // Let's start the address resolution task!
                //
                PRM_TASK pResolutionTask;
                ASSERT (fBridgeMode == FALSE);
                DBGMARK(0xd0da6726);

                //
                // Let's start a resolution task and pend on it.
                //
                Status = arpAllocateTask(
                            &pRemoteIp->Hdr,                    // pParentObject
                            arpTaskResolveIpAddress,        // pfnHandler
                            0,                              // Timeout
                            "Task: ResolveIpAddress",       // szDescription
                            &pResolutionTask,
                            pSR
                            );
                if (FAIL(Status))
                {
                    // Couldn't allocate task. We fail with STATUS_RESOURCES
                    //
                    Status = NDIS_STATUS_RESOURCES;
                }
                else
                {
                    UNLOCKOBJ(pRemoteIp, pSR);
                    RmPendTaskOnOtherTask(
                        pTask,
                        PEND_AddressResolutionComplete,
                        pResolutionTask,
                        pSR
                        );
    
                    (VOID)RmStartTask(
                            pResolutionTask,
                            0, // UserParam unused
                            pSR
                            );
                
                    Status = NDIS_STATUS_PENDING;
                }
                break;
            }

            pDest = pRemoteIp->pDest;

            //
            // We do have a pDest. Now see if there is a make call task on that
            // pDest, and if so, we pend on it.
            fMakeCallIfRequired = TRUE;


            //
            // We're here because there is no more async work to be done.
            // We simply return and finish synchronous work in the END
            // handler for this task.
            //
            
        } // START
        break;

        case  RM_TASKOP_PENDCOMPLETE:
        {
            switch(RM_PEND_CODE(pTask))
            {
                case  PEND_AddressResolutionComplete:
                {
                    //
                    // There was address-resolution going on, but how it's
                    // complete. We should be go on to try to make a call now...
                    //
                    // If we're here, that means we're THE official SendPkts
                    // task. Let's assert that fact.
                    // (no need to get the lock on the object).
                    //
                    LOCKOBJ(pRemoteIp, pSR);
                    ASSERT(pRemoteIp->pSendPktsTask == pTask);

                    // We ignore the status of address resolution -- instead
                    // we just check if there is a destination associated with
                    // pRemoteIp.
                    //
                    pDest = pRemoteIp->pDest;
                    if (pDest == NULL)
                    {
                        // Nope -- no pDest. We fail the packets.
                        Status = NDIS_STATUS_FAILURE;
                    }
                    else
                    {
                        // Yup,  there is a destination. Now check if we need
                        // to make a call, etc...
                        //
                        fMakeCallIfRequired = TRUE;
                    }
                }
                break;

                case  PEND_MakeCallComplete:
                {
                    LOCKOBJ(pRemoteIp, pSR);
                    //
                    // If we're here, that means we're THE official SendPkts
                    // task. Let's assert that fact.
                    // (no need to get the lock on the object).
                    //
                    ASSERT(pRemoteIp->pSendPktsTask == pTask);

                    //
                    // There was a make-call task going on, but how it's
                    // complete. We're done with async processing.
                    // We actually send/fail queued packets in our END handler...
                    //
                    Status      = (NDIS_STATUS) UserParam;
                    ASSERT(!PEND(Status));
                }
                break;

                default:
                {
                    ASSERTEX(!"Unknown pend op", pTask);
                }
                break;
    

            } // end switch(RM_PEND_CODE(pTask))

        } // case RM_TASKOP_PENDCOMPLETE
        break;

        case RM_TASKOP_END:
        {
            LOCKOBJ(pRemoteIp, pSR);

            //
            // We're done. There should be no async activities left to do.
            // At this point, if we can't immediately send packets on the FIFO,
            // we simply fail all the packets.
            //

            //
            // We don't bother to look at the Status. Instead we go ahead and
            // try to send any queued packets.
            //

            //
            // If we're THE sentpkts task, we go on actually send the packets.
            //
            if (pRemoteIp->pSendPktsTask == pTask)
            {
                DBGMARK(0xc627713c);

                arpSendPktsQueuedOnRemoteIp(
                        pIF,
                        pRemoteIp,
                        pSR
                        );

                // Delete the association we added when we set
                // pRemoteIp->pSendPktsTask to pTask.
                //
                ASSERT(pRemoteIp->pSendPktsTask == pTask);
                ASSERT(IsListEmpty(&pRemoteIp->sendinfo.listSendPkts) ==TRUE);
                DBG_DELASSOC(
                    &pRemoteIp->Hdr,                    // pObject
                    pTask,                              // Instance1
                    pTask->Hdr.szDescription,           // Instance2
                    ARPASSOC_REMOTEIP_SENDPKTS_TASK,    // AssociationID
                    pSR
                    );
                pRemoteIp->pSendPktsTask = NULL;
                Status = NDIS_STATUS_SUCCESS;
            }
            else
            {
                //
                // We weren't THE unload task, nothing left to do.
                //
                Status = NDIS_STATUS_SUCCESS;
            }
        }
        break; // RM_TASKOP_END:

        default:
        {
            ASSERTEX(!"Unexpected task op", pTask);
        }
        break;

    } // switch (Code)

    if (fMakeCallIfRequired)
    {
        //
        // If necessary, make a call. If a make-call is already in process, pend
        // on it.
        //

        // We rely on the fact that
        // we share the same lock as pDest, and therefore is locked...
        //
        RM_DBG_ASSERT_LOCKED(&pDest->Hdr, pSR);

        Status = arpMakeCallOnDest(pRemoteIp,
                                    pDest, 
                                    pTask, 
                                    PEND_MakeCallComplete, 
                                    pSR);

    }

    RmUnlockAll(pSR);

    EXIT()

    return Status;
}


VOID
arpCompleteSentPkt(
    IN  NDIS_STATUS             Status,
    IN  ARP1394_INTERFACE   *   pIF,
    IN  ARPCB_DEST          *   pDest,
    IN  PNDIS_PACKET            pNdisPacket
)
/*++

Routine Description:

    Handle the completion (by the miniport) of a packet sent on a FIFO or Channel VC.
    We strip out the encapsulation header we had tacked on prior to sending the
    packet. If the packet belongs to IP, we call IP's send complete handler, else
    we return it to our packet pool.

Arguments:

    Status      - Status of the completed send.
    pIF         - Interface object
    pDest       - Destination object on which packet was sent
    pNdisPacket - Ndis packet that was sent.

--*/
{
    PacketContext                   *PC;            // IP/ARP Info about this packet
    PNDIS_BUFFER                    pNdisBuffer;    // First Buffer in this packet
    ENTER("CompleteSentPkt", 0xc2b623b6)
    UINT                            TotalLength;
    MYBOOL                          IsFifo;
    MYBOOL                          IsControlPacket;


    ASSERT(pNdisPacket->Private.Head != NULL);

    NdisQueryPacket(
            pNdisPacket,
            NULL,           // we don't need PhysicalBufferCount
            NULL,           // we don't need BufferCount
            NULL,           // we don't need FirstBuffer (yet)
            &TotalLength
            );

    IsFifo = pDest->sendinfo.IsFifo;

    // Update stats...
    //
    {
        if (IsFifo)
        {
            LOGSTATS_SendFifoCounts(pIF, pNdisPacket, Status);
        }
        else
        {
            LOGSTATS_SendChannelCounts(pIF, pNdisPacket, Status);
        }

        if (Status == NDIS_STATUS_SUCCESS)
        {
            ARP_IF_STAT_ADD(pIF, OutOctets, TotalLength);

            if (IsFifo)
            {
                ARP_IF_STAT_INCR(pIF, OutUnicastPkts);
            }
            else
            {
                ARP_IF_STAT_INCR(pIF, OutNonUnicastPkts);
            }
        }
        else if (Status == NDIS_STATUS_RESOURCES)
        {
            ARP_IF_STAT_INCR(pIF, OutDiscards);
        }
        else
        {
            ARP_IF_STAT_INCR(pIF, OutErrors);
        }
    }

    PC = (PacketContext *)pNdisPacket->ProtocolReserved;

    TR_INFO(
        ("[%s]: pDest 0x%x, Pkt 0x%x, Status 0x%x:\n",
                ((PC->pc_common.pc_owner != PACKET_OWNER_LINK)? "IP": "ARP"),
                pDest, pNdisPacket, Status));

    NdisQueryPacket(pNdisPacket, NULL, NULL, &pNdisBuffer, NULL);
    ASSERT(pNdisBuffer != NULL);

    // Delete association added when sending packets.
    //
    {
        MYBOOL      DoDeref;
    
        DoDeref =(InterlockedDecrement(&pDest->sendinfo.NumOutstandingSends)==0);

        if (DoDeref)
        {
            MYBOOL TryResumeSuspendedCleanupTask = FALSE;

            // The count of outstanding sends has touched zero. Let's
            // check if there is a CleanupCall task waiting for all outstanding
            // sends to complete, and if it makes sense to do so, we
            // will resume it.
            //
            ARP_FASTREADLOCK_IF_SEND_LOCK(pIF);
            if (pDest->sendinfo.pSuspendedCleanupCallTask!=NULL)
            {
                // It's likely that we'll need to resume this task.
                //
                TryResumeSuspendedCleanupTask = TRUE;
            }
            else
            {
                // We do not need to resume any task. Nothing more to do...
                //
            }
            ARP_FASTUNLOCK_IF_SEND_LOCK(pIF);

            if (TryResumeSuspendedCleanupTask)
            {
                arpTryResumeSuspendedCleanupTask(pIF, pDest);
            }
        }
    
        // The following macros are just so that we can make the proper debug
        // association depending on how closely we are tracking outstanding send
        // packets.
        //
    #if ARPDBG_REF_EVERY_PACKET
        DoDeref = TRUE;
        #define OUR_EXTERNAL_ENTITY ((UINT_PTR) pNdisPacket)
    #else // !ARPDBG_REF_EVERY_PACKET
        #define OUR_EXTERNAL_ENTITY ((UINT_PTR)  &pDest->sendinfo)
    #endif // !ARPDBG_REF_EVERY_PACKET
    
    
        if (DoDeref)
        {
            //
            // If ARPDBG_REF_EVERY_PKT
            //      We remove the "external" link added for EVERY packet.
            // else
            //      Only a transition from non-zero to zero outstanding sends, we
            //      remove the "external" link.
            //
    
        #if RM_EXTRA_CHECKING
    
            RM_DECLARE_STACK_RECORD(sr)
    
            RmUnlinkFromExternalEx(
                &pDest->Hdr,                            // pHdr
                0x753db96f,                             // LUID
                OUR_EXTERNAL_ENTITY,                    // External entity
                ARPASSOC_EXTLINK_DEST_TO_PKT,           // AssocID
                &sr
                );
    
        #else   // !RM_EXTRA_CHECKING
    
            RmUnlinkFromExternalFast(&pDest->Hdr);
    
        #endif // !RM_EXTRA_CHECKING
    
        }
        #undef  OUR_EXTERNAL_ENTITY
    
    }

    //
    //  Check who generated this packet.
    //
    IsControlPacket = FALSE;

    if (PC->pc_common.pc_owner == PACKET_OWNER_LINK)
    {
        IsControlPacket = TRUE;
    }

    if (IsControlPacket)
    {
        arpHandleControlPktSendCompletion(pIF, pNdisPacket);
    }
    else
    {
        //
        //  Belongs to IP.
        //

        DBGMARK(0x2c48c626);

        //
        //  Now check if we had attached a header buffer or not.
        //  NOTE: We rely on the fact that if we DID attach a header buffer,
        //  ARP_BACK_FILL_POSSIBLE will be false for this buffer.
        //
        DBGMARK(0x2f3b96f3);
        if (ARP_BACK_FILL_POSSIBLE(pNdisBuffer))
        {
            const UINT  HeaderLength =  sizeof(Arp1394_IpEncapHeader);

            //
            //  We would have back-filled IP's buffer with the Ip encapsulation
            //  header.
            //  Remove the back-fill.
            //
            (PUCHAR)pNdisBuffer->MappedSystemVa += HeaderLength;
            pNdisBuffer->ByteOffset += HeaderLength;
            pNdisBuffer->ByteCount -= HeaderLength;
        }
        else if (Status != NDIS_STATUS_NOT_RESETTABLE)
        {
            //
            //  The first buffer is our header buffer. Remove
            //  it from the packet and return to our pool.
            //
            NdisUnchainBufferAtFront(pNdisPacket, &pNdisBuffer);
            arpDeallocateConstBuffer(
                &pIF->sendinfo.HeaderPool,
                pNdisBuffer
                );
        }

        //  Inform IP of send completion.
        //  NOTE: we don't get here in bridge mode because we only use
        //  control packets in bridge mode.
        //
        #if MILLEN
            ASSERT_PASSIVE();
        #endif // MILLEN
        (*(pIF->ip.TxCmpltHandler))(
                    pIF->ip.Context,
                    pNdisPacket,
                    Status
                    );
    }

    EXIT()
}


VOID
arpTryResumeSuspendedCleanupTask(
    IN  ARP1394_INTERFACE   *   pIF,        // NOLOCKIN NOLOCKOUT
    IN  ARPCB_DEST          *   pDest       // NOLOCKIN NOLOCKOUT
    )
/*++

Routine Description:

    If there is a cleanup task associated with destination oject pDest that
    is suspended waiting for the outstanding send count to go to zero, AND
    if the outstanding send count has gone to zero, we resume the task. Otherwise
    we do nothing.

Arguments:

    pIF         - Interface object
    pDest       - Destination object.

--*/
{
    PRM_TASK pTask;
    ENTER("TryResumeSuspendedCleanupTask", 0x1eccb1aa)
    RM_DECLARE_STACK_RECORD(sr)

    ARP_WRITELOCK_IF_SEND_LOCK(pIF, &sr);
    pTask = pDest->sendinfo.pSuspendedCleanupCallTask;
    if (pTask != NULL)
    {
        ASSERT(!ARP_CAN_SEND_ON_DEST(pDest));
        if (pDest->sendinfo.NumOutstandingSends==0)
        {
            // We need to resume this task...
            //
            pDest->sendinfo.pSuspendedCleanupCallTask = NULL;

            // Clear the association added when pTask started waiting for
            // outstanding sends to complete.
            //
            DBG_DELASSOC(
                &pDest->Hdr,                        // pObject
                pTask,                              // Instance1
                pTask->Hdr.szDescription,           // Instance2
                ARPASSOC_DEST_CLEANUPCALLTASK_WAITING_ON_SENDS,
                &sr
                );
            RmTmpReferenceObject(&pTask->Hdr, &sr);
        }
        else
        {
            // There are other outstanding sends now. No need to do anything...
            //
            pTask = NULL;
        }
    }
    ARP_UNLOCK_IF_SEND_LOCK(pIF, &sr);


    if (pTask != NULL)
    {
        // Resume the CleanupCall task...
        //
        RmResumeTask(pTask, NDIS_STATUS_SUCCESS, &sr);
        RmTmpDereferenceObject(&pTask->Hdr, &sr);
    }

    RM_ASSERT_CLEAR(&sr);
    EXIT()
}

VOID
arpQueuePktOnRemoteIp(
    IN  PARPCB_REMOTE_IP    pRemoteIp,      // LOCKIN LOCKOUT
    IN  PNDIS_PACKET        pNdisPacket,
    IN  PRM_STACK_RECORD    pSR
    )
/*++

Routine Description:

    Appends pkt pNdisPacket on remote object pRemoteIp's queue.

--*/
{
    ARP_SEND_PKT_MPR_INFO *pOurPktInfo =
                        ARP_OUR_CTXT_FROM_SEND_PACKET(pNdisPacket);
    

    RM_DBG_ASSERT_LOCKED(&pRemoteIp->Hdr, pSR);

#if RM_EXTRA_CHECKING
    {
        //
        // If ARPDBG_REF_EVERY_PKT
        //      We add an dbgassociation for EVERY packet. We'll later remove
        //      this association when the send completes for this packet.
        // else
        //      Only a transition from zero to non-zero queued pkts, we
        //      add an dbg association. We'll later remove this association when
        //      the transition from non-zero to zero happens.
        //
        MYBOOL DoAssoc;

    #if ARPDBG_REF_EVERY_PACKET
        DoAssoc = TRUE;
        #define OUR_EXTERNAL_ENTITY ((UINT_PTR) pNdisPacket)
        #define szARPSSOC_QUEUED_PKT_FORMAT "    Queued pkt 0x%p\n"
    #else // !ARPDBG_REF_EVERY_PACKET
        #define OUR_EXTERNAL_ENTITY ((UINT_PTR)  &pDest->)
        #define szARPSSOC_QUEUED_PKT_FORMAT "    Outstanding pkts. &si=0x%p\n"
        DoAssoc =  IsListEmpty(&pRemoteIp->sendinfo.listSendPkts);
    #endif // !ARPDBG_REF_EVERY_PACKET
    
        if (DoAssoc)
        {
    
            RM_DECLARE_STACK_RECORD(sr)
    
            RmDbgAddAssociation(
                0x3c08a7f5,                             // LOCID
                &pRemoteIp->Hdr,                        // pHdr
                (UINT_PTR) OUR_EXTERNAL_ENTITY,         // Entity1
                0,                                      // Entity2
                ARPASSOC_PKTS_QUEUED_ON_REMOTEIP,       // AssocID
                szARPSSOC_QUEUED_PKT_FORMAT,
                &sr
                );
        }
    #undef  OUR_EXTERNAL_ENTITY
    #undef  szARPSSOC_EXTLINK_DEST_TO_PKT_FORMAT
    }
#endif // !RM_EXTRA_CHECKING
    DBGMARK(0x007a0585);

    InsertHeadList(
        &pRemoteIp->sendinfo.listSendPkts,
        &pOurPktInfo->linkQueue
        );
}



VOID
arpSendPktsQueuedOnRemoteIp(
    IN  ARP1394_INTERFACE   *   pIF,            // NOLOCKIN NOLOCKOUT
    IN  ARPCB_REMOTE_IP     *   pRemoteIp,      // NOLOCKIN NOLOCKOUT
    IN  PRM_STACK_RECORD    pSR
    )
/*++

Routine Description:

    Send all packets queued on remote ip object pRemoteIp. If packets can't
    be sent at this time for any reason, fail the sends.

    ASSUMPTION: We expect pIF and pRemoteIp to be around while we're in this
                function.

    ASSUMPTION: This is called with the lock held.                

--*/

{
    ENTER("SendPktsQueuedOnRemoteIp", 0x2b125d7f)

    DBGMARK(0xe4950c47);
    do
    {
        PARPCB_DEST pDest = NULL;

        if(RM_IS_ZOMBIE(pRemoteIp))
        {
            break;
        }


        pDest = pRemoteIp->pDest;

        if (pDest != NULL)
        {
            RmTmpReferenceObject(&pDest->Hdr, pSR);
        }

        //
        // Send or fail all packets in our queue.
        // TODO: Implement send multiple pkts.
        //
        while (!IsListEmpty(&pRemoteIp->sendinfo.listSendPkts))
        {
            PLIST_ENTRY                 plinkPkt;
            PNDIS_PACKET                pNdisPacket;
            ARP_SEND_PKT_MPR_INFO *     pOurPktCtxt;

            //
            // Extract pkt from tail and send it on it's merry way...
            //

            plinkPkt = RemoveTailList(&pRemoteIp->sendinfo.listSendPkts);

            // From link to our pkt context...
            //
            pOurPktCtxt = CONTAINING_RECORD(
                            plinkPkt,
                            ARP_SEND_PKT_MPR_INFO, 
                            linkQueue
                            );

            // From our pkt context to the ndis pkt.
            //
            pNdisPacket = ARP_SEND_PKT_FROM_OUR_CTXT(pOurPktCtxt);
    

        #if RM_EXTRA_CHECKING
            {
                //
                // If ARPDBG_REF_EVERY_PKT
                //      We delete thhe dbgassociation added for EVERY packet.
                // else
                //      Only a transition from non-zero zero queued pkts, we
                //      delete the dbg association added when the
                //      transition from zero to non-zero happened.
                //
                MYBOOL DoDelAssoc;
        
            #if ARPDBG_REF_EVERY_PACKET
                DoDelAssoc = TRUE;
                #define OUR_EXTERNAL_ENTITY ((UINT_PTR) pNdisPacket)
            #else // !ARPDBG_REF_EVERY_PACKET
                #define OUR_EXTERNAL_ENTITY ((UINT_PTR)  &pDest->)
                DoDelAssoc =  IsListEmpty(&pRemoteIp->sendinfo.listSendPkts);
            #endif // !ARPDBG_REF_EVERY_PACKET
            
                if (DoDelAssoc)
                {
            
                    RM_DECLARE_STACK_RECORD(sr)
            
                    RmDbgDeleteAssociation(
                        0x3c08a7f5,                             // LOCID
                        &pRemoteIp->Hdr,                        // pHdr
                        (UINT_PTR) OUR_EXTERNAL_ENTITY,         // Entity1
                        0,                                      // Entity2
                        ARPASSOC_PKTS_QUEUED_ON_REMOTEIP,       // AssocID
                        &sr
                        );
                }
            #undef  OUR_EXTERNAL_ENTITY
            }
        #endif // !RM_EXTRA_CHECKING

            UNLOCKOBJ(pRemoteIp, pSR);
            RM_ASSERT_NOLOCKS(pSR);
    
            if (pDest == NULL
                || (   g_DiscardNonUnicastPackets
                    &&  CHECK_REMOTEIP_FCTYPE( pRemoteIp, ARPREMOTEIP_CHANNEL)))

            {
                ARP1394_ADAPTER *   pAdapter =
                                    (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
                MYBOOL      fBridgeMode = ARP_BRIDGE_ENABLED(pAdapter);
            
                // Fail the packet right here...
                //
                // TODO: we current update the SendFifoCounts here, because
                // all non-unicast bcasts resolve to the already existing
                // broadcast channel. Once we have MCAP going, we need to keep
                // a flag in pRemoteIp indicating whether or not this is a
                // unicast address.
                //
                LOGSTATS_SendFifoCounts(pIF, pNdisPacket, NDIS_STATUS_FAILURE);
                  
                if (fBridgeMode)
                {
                    // In bridge (ethernet emulation) mode, we created the
                    // packets ourselves, so we delete them here, instead
                    // of calling Ip's completion handler, which in fact
                    // is NULL.
                    //
                    arpFreeControlPacket(
                            pIF,
                            pNdisPacket,
                            pSR
                            );
                }
                else
                {
                #if MILLEN
                    ASSERT_PASSIVE();
                #endif // MILLEN

                    NdisInterlockedIncrement (&ArpSendCompletes);
                    NdisInterlockedIncrement (&ArpSendFailure);


                    (*(pIF->ip.TxCmpltHandler))(
                                pIF->ip.Context,
                                pNdisPacket,
                                NDIS_STATUS_FAILURE
                                );
                }
            }
            else
            {
                // Get IF send lock (fast version)
                //
                ARP_FASTREADLOCK_IF_SEND_LOCK(pIF);
        
                arpSendIpPkt(
                    pIF,                // IF send lock: LOCKING NOLOCKOUT
                    pDest,
                    pNdisPacket
                    );
        
                // Note that we're locking pRemoteIp's lock, not the IF send lock
                // here. pRemoteIp->sendinfo.listSendPkts is protected by the
                // the following lock, not the IF send lock.
                //
            }
            LOCKOBJ(pRemoteIp, pSR);
        }

        if (pDest != NULL)
        {
            RmTmpDereferenceObject(&pDest->Hdr, pSR);
        }

    } while (FALSE);

    EXIT()
}


VOID
arpLogSendFifoCounts(
    IN  PARP1394_INTERFACE  pIF,            // NOLOCKIN NOLOCKOUT
    IN  PNDIS_PACKET        pNdisPacket,
    IN  NDIS_STATUS         Status
    )
/*++
    TODO:  Very similar to arpLogSendChannelCounts, consider merging these two 
            functions.
--*/
{
    PULONG  pCount;
    ULONG   SizeBin, TimeBin;

    arpGetPktCountBins(pIF, pNdisPacket, &SizeBin, &TimeBin);

    //
    // Increment the count
    if (Status == NDIS_STATUS_SUCCESS)
    {
        pCount = &(pIF->stats.sendpkts.SendFifoCounts.GoodCounts[SizeBin][TimeBin]);
    }
    else
    {
        pCount = &(pIF->stats.sendpkts.SendFifoCounts.BadCounts[SizeBin][TimeBin]);
    }
    NdisInterlockedIncrement(pCount);
}


VOID
arpLogRecvFifoCounts(
    IN  PARP1394_INTERFACE  pIF,            // NOLOCKIN NOLOCKOUT
    IN  PNDIS_PACKET        pNdisPacket
    )
{
    PULONG  pCount;
    ULONG   SizeBin;

    arpGetPktCountBins(pIF, pNdisPacket, &SizeBin, NULL);

    //
    // Increment the count
    pCount = &(pIF->stats.recvpkts.RecvFifoCounts.GoodCounts[SizeBin][0]);
    NdisInterlockedIncrement(pCount);
}


VOID
arpLogSendChannelCounts(
    IN  PARP1394_INTERFACE  pIF,            // NOLOCKIN NOLOCKOUT
    IN  PNDIS_PACKET        pNdisPacket,
    IN  NDIS_STATUS         Status
    )
{
    PULONG  pCount;
    ULONG   SizeBin, TimeBin;

    arpGetPktCountBins(pIF, pNdisPacket, &SizeBin, &TimeBin);

    //
    // Increment the count
    if (Status == NDIS_STATUS_SUCCESS)
    {
        pCount =&(pIF->stats.sendpkts.SendChannelCounts.GoodCounts[SizeBin][TimeBin]);
    }
    else
    {
        pCount =&(pIF->stats.sendpkts.SendChannelCounts.BadCounts[SizeBin][TimeBin]);
    }
    NdisInterlockedIncrement(pCount);
}


VOID
arpLogRecvChannelCounts(
    IN  PARP1394_INTERFACE  pIF,            // NOLOCKIN NOLOCKOUT
    IN  PNDIS_PACKET        pNdisPacket
    )
{
    PULONG  pCount;
    ULONG   SizeBin;

    arpGetPktCountBins(pIF, pNdisPacket, &SizeBin, NULL);

    //
    // Increment the count
    pCount = &(pIF->stats.recvpkts.RecvChannelCounts.GoodCounts[SizeBin][0]);
    NdisInterlockedIncrement(pCount);
}

VOID
arpGetPktCountBins(
    IN  PARP1394_INTERFACE  pIF,            // NOLOCKIN NOLOCKOUT
    IN  PNDIS_PACKET        pNdisPacket,
    OUT PULONG              pSizeBin,       
    OUT PULONG              pTimeBin        // OPTIONAL
    )
{
    ULONG   Size;
    ULONG   SizeBin;

    if (pTimeBin != NULL)
    {
        //
        // Compute the packet send duration
        //
    
        ULONG           StartSendTick, EndSendTick;
        LARGE_INTEGER   liTemp;
        ULONG           TimeDelta;
        ULONG           TimeBin;

        liTemp = KeQueryPerformanceCounter(NULL);
        EndSendTick = liTemp.LowPart;
        StartSendTick =  *(PULONG) ((pNdisPacket)->WrapperReservedEx);
        if (EndSendTick > StartSendTick)
        {
            TimeDelta = EndSendTick - StartSendTick;
        }
        else
        {
            TimeDelta = (ULONG) (((ULONG) -1) - (StartSendTick - EndSendTick));
        }

        // Convert from ticks to microseconds.
        // (Check that the frequence is non zero -- we could be in the middle
        // of a stats-reset, and don't want to cause a devide-by-zero exception).
        //
        liTemp =  pIF->stats.PerformanceFrequency;
        if (liTemp.QuadPart != 0)
        {
            ULONGLONG ll;
            ll = TimeDelta;
            ll *= 1000000;
            ll /=  liTemp.QuadPart;
            ASSERT(ll == (ULONG)ll);
            TimeDelta = (ULONG) ll;
        }
        else
        {
            TimeDelta = 0; // bogus value.
        }

        //
        // Compute the time bin based on the send duration
        //
        if (TimeDelta <= 100)
        {
            TimeBin = ARP1394_PKTTIME_100US;
        }
        else if (TimeDelta <= 1000)
        {
            TimeBin = ARP1394_PKTTIME_1MS;
        }
        else if (TimeDelta <= 10000)
        {
            TimeBin =   ARP1394_PKTTIME_10MS;
        }
        else if (TimeDelta <= 100000)
        {
            TimeBin =   ARP1394_PKTTIME_100MS;
        }
        else // (TimeDelta > 100000)
        {
            TimeBin = ARP1394_PKTTIME_G100MS;
        }

        *pTimeBin = TimeBin;
    }

    //
    // Compute the packet size
    NdisQueryPacket(
            pNdisPacket,
            NULL,
            NULL,
            NULL,
            &Size
            );

    //
    // Compute the size bin based on the packet size
    if (Size <= 128)
    {
        SizeBin =  ARP1394_PKTSIZE_128;
    }
    else if (Size <= 256)
    {
        SizeBin = ARP1394_PKTSIZE_256;
    }
    else if (Size <= 1024)
    {
        SizeBin = ARP1394_PKTSIZE_1K;
    }
    else if (Size <= 2048)
    {
        SizeBin = ARP1394_PKTSIZE_2K;
    }
    else // Size > 2048
    {
        SizeBin = ARP1394_PKTSIZE_G2K;
    }

    *pSizeBin = SizeBin;

}

// This table is used in the calculations to determine if a particular address is
// non-unicast.
// TODO: Make this and all other static data into const.
//
IP_MASK  g_ArpIPMaskTable[] =
{
    CLASSA_MASK,
    CLASSA_MASK,
    CLASSA_MASK,
    CLASSA_MASK,
    CLASSA_MASK,
    CLASSA_MASK,
    CLASSA_MASK,
    CLASSA_MASK,
    CLASSB_MASK,
    CLASSB_MASK,
    CLASSB_MASK,
    CLASSB_MASK,
    CLASSC_MASK,
    CLASSC_MASK,
    CLASSD_MASK,
    CLASSE_MASK
};


#define ARP_IPNETMASK(a)    g_ArpIPMaskTable[(*(uchar *)&(a)) >> 4]


// Context passed to the enum function for checking if a particular
// address is non-unicast.
//
typedef struct
{
    IP_ADDRESS IpAddress;
    IP_ADDRESS BroadcastAddress;
    MYBOOL     IsNonUnicast;
    

} ARP_NONUNICAST_CTXT, *PARP_NONUNICAST_CTXT;


// The enum function for the above operation.
//
INT
arpCheckForNonUnicastAddress(
        PRM_OBJECT_HEADER   pHdr,
        PVOID               pvContext,
        PRM_STACK_RECORD    pSR
        )
{
    PARPCB_LOCAL_IP         pLocalIp;
    PARP_NONUNICAST_CTXT    pOurCtxt;
    IP_ADDRESS              Addr;
    IP_ADDRESS              BCast;
    IP_ADDRESS              LocalAddr;
    IP_MASK                 Mask;

    pLocalIp =  (PARPCB_LOCAL_IP) pHdr;

    // If this local ip address is non-unicast, skip it.
    //
    if (pLocalIp->IpAddressType != LLIP_ADDR_LOCAL)
    {
        return TRUE;                // *** EARLY RETURN *** (continue to enumerate)
    }

    pOurCtxt =   (PARP_NONUNICAST_CTXT) pvContext;
    Addr     =  pOurCtxt->IpAddress;
    LocalAddr=  pLocalIp->IpAddress;
    BCast    =  pOurCtxt->BroadcastAddress;

    // First check for subnet bcast.
    //
    Mask = pLocalIp->IpMask;
    if (IP_ADDR_EQUAL((LocalAddr & Mask) | (BCast & ~Mask), Addr))
    {
        pOurCtxt->IsNonUnicast = TRUE;
        return  FALSE;                  // Stop enumerating
    }

    // Now check all nets broadcast.
    Mask = ARP_IPNETMASK(LocalAddr);
    if (IP_ADDR_EQUAL((LocalAddr & Mask) | (BCast & ~Mask), Addr))
    {
        pOurCtxt->IsNonUnicast = TRUE;
        return FALSE;                   // Stop enumerating
    }

    return TRUE; // Continue to enumerate.
}



MYBOOL
arpIsNonUnicastEthAddress (
    IN  PARP1394_INTERFACE          pIF,        // LOCKIN LOCKOUT
    IN  ENetAddr*                   pAddr,
    IN  PRM_STACK_RECORD            pSR
)
/*++

Routine Description:

    Check if the given IP address is a non-unicast (broadcast or multicast) address
    for the interface.

    Copied from IP/ATM module (atmarpc.sys)

Arguments:

    Addr            - The Eth Address to be checked
    pInterface      - Pointer to our Interface structure

Return Value:

    TRUE if the address is a non-unicast address, FALSE otherwise.

--*/
{
    MYBOOL fIsNonUnicastEthAddress = FALSE;
    MYBOOL fIsMulticast  = FALSE; 
    MYBOOL fIsBroadcast = FALSE;
    
    fIsMulticast = ETH_IS_MULTICAST (pAddr);

    fIsBroadcast = ETH_IS_BROADCAST (pAddr);

    //
    // if it is either a Multicast or a Unicast address than 
    // it is a non-unicast address
    //
    fIsNonUnicastEthAddress  = (fIsMulticast  || fIsBroadcast );

    return (fIsNonUnicastEthAddress  );
}


MYBOOL
arpIsNonUnicastIpAddress(
    IN  PARP1394_INTERFACE          pIF,        // LOCKIN LOCKOUT
    IN  IP_ADDRESS                  Addr,
    IN  PRM_STACK_RECORD            pSR
)
/*++

Routine Description:

    Check if the given IP address is a non-unicast (broadcast or multicast) address
    for the interface.

    Copied from IP/ATM module (atmarpc.sys)

Arguments:

    Addr            - The IP Address to be checked
    pInterface      - Pointer to our Interface structure

Return Value:

    TRUE if the address is a non-unicast address, FALSE otherwise.

--*/
{
    IP_ADDRESS              BCast;
    IP_MASK                 Mask;
    // PIP_ADDRESS_ENTRY        pIpAddressEntry;
    IP_ADDRESS              LocalAddr;

    // Get the interface broadcast address.
    BCast = pIF->ip.BroadcastAddress;

    // Check for global broadcast and multicast.
    if (IP_ADDR_EQUAL(BCast, Addr) || CLASSD_ADDR(Addr))
        return TRUE;

    // Look through all our local ip addresses, checking for subnet and net
    // broadcast addresses.
    //
    {
        ARP_NONUNICAST_CTXT Ctxt;
        Ctxt.IsNonUnicast = FALSE;
        Ctxt.IpAddress  =   Addr;
        Ctxt.BroadcastAddress = BCast;

        RmEnumerateObjectsInGroup(
            &pIF->LocalIpGroup,
            arpCheckForNonUnicastAddress,
            &Ctxt,
            TRUE,                           // Choose strong enumeration
            pSR
            );

        return Ctxt.IsNonUnicast;
    }
}

VOID
arpRefSendPkt(
    PNDIS_PACKET    pNdisPacket,
    PARPCB_DEST     pDest               // LOCKIN LOCKOUT (readlock, IF Send lock)
    )
{
    MYBOOL      DoRef;
        
    // Note, we just have a READ lock on the IF send lock. So the following
    // needs to be an interlocked operation ...
    //
    DoRef =  (InterlockedIncrement(&pDest->sendinfo.NumOutstandingSends) == 1);

    // The following macros are just so that we can make the proper debug association
    // depending on how closely we are tracking outstanding send packets.
    //
#if ARPDBG_REF_EVERY_PACKET
    DoRef = TRUE;
    #define OUR_EXTERNAL_ENTITY ((UINT_PTR) pNdisPacket)
    #define szARPSSOC_EXTLINK_DEST_TO_PKT_FORMAT "    Outstanding send pkt 0x%p\n"
#else // !ARPDBG_REF_EVERY_PACKET
    #define OUR_EXTERNAL_ENTITY ((UINT_PTR)  &pDest->sendinfo)
    #define szARPSSOC_EXTLINK_DEST_TO_PKT_FORMAT "    Outstanding pkts. &si=0x%p\n"
#endif // !ARPDBG_REF_EVERY_PACKET


    if (DoRef)
    {
        //
        // If ARPDBG_REF_EVERY_PKT
        //      We add an "external" link for EVERY packet. We'll later remove this
        //      reference when the send completes for this packet.
        // else
        //      Only a transition from zero to non-zero outstanding sends, we
        //      add an "external" link. We'll later remove this link when the
        //      transition from non-zero to zero happens.
        //

    #if RM_EXTRA_CHECKING

        RM_DECLARE_STACK_RECORD(sr)

        RmLinkToExternalEx(
            &pDest->Hdr,                            // pHdr
            0x13f839b4,                             // LUID
            OUR_EXTERNAL_ENTITY,                    // External entity
            ARPASSOC_EXTLINK_DEST_TO_PKT,           // AssocID
            szARPSSOC_EXTLINK_DEST_TO_PKT_FORMAT,
            &sr
            );

    #else   // !RM_EXTRA_CHECKING

        RmLinkToExternalFast(&pDest->Hdr);

    #endif // !RM_EXTRA_CHECKING

    }
    #undef  OUR_EXTERNAL_ENTITY
    #undef  szARPSSOC_EXTLINK_DEST_TO_PKT_FORMAT
}

VOID
arpHandleControlPktSendCompletion(
    IN  ARP1394_INTERFACE   *   pIF,
    IN  PNDIS_PACKET            pNdisPacket
    )
{
    RM_DECLARE_STACK_RECORD(sr)

    arpFreeControlPacket(
            pIF,
            pNdisPacket,
            &sr
            );
}



BOOLEAN
arpCanTryMcap(
    IP_ADDRESS  IpAddress
    )
/*++
    Return TRUE IFF this is an MCAP compatible address.

    For now that means that it's a class D address, but not
    224.0.0.1 or 224.0.0.2

--*/
{
    // 1st check if it's a multicast address.
    //
    if ( (IpAddress & 0xf0) == 0xe0)
    {
        //
        // Then check for special multicast addresses 224.0.0.1 and 224.0.0.2
        // The ip/1395 rfc states that these two addresses must be
        // send on the broadcast channel.
        //
        if ( (IpAddress != 0x010000e0) && (IpAddress != 0x020000e0))
        {
            return TRUE;
        }
    }

    return FALSE;
}



VOID
arpLoopbackNdisPacket(
    PARP1394_INTERFACE pIF,
    PARPCB_DEST pBroadcastDest,
    PNDIS_PACKET pOldPacket
    )
/*++

Routine Description:
    if this is being sent to a broadcast destination, then allocate a new
    packet and loop it back up to the protocols.

Arguments:

    pIF - Pointer to the Interface on which the packet is sent
    pBroadcastDest - The Destination to which the packet is being sent.

Return Value:

    TRUE if the address is a non-unicast address, FALSE otherwise.

--*/
{
    PNDIS_PACKET    pNewPkt = NULL;
    const UINT      MacHeaderLength = sizeof(NIC1394_ENCAPSULATION_HEADER);
    PUCHAR          pPayloadDataVa = NULL;
    UINT            TotalLength  = 0;
    NDIS_STATUS     Status = NDIS_STATUS_FAILURE;
    UINT            HeadBufferLength  = 0;
    PUCHAR          pHeadBufferVa = NULL;  
    
    do
    {
        //Allocate the packet


        NdisAllocatePacket(
                &Status,
                &pNewPkt,
                pIF->arp.PacketPool
            );

        if (Status != NDIS_STATUS_SUCCESS || pNewPkt == NULL)
        {
            pNewPkt = NULL;
            break;

        }

        
        // set up the head and tail

        pNewPkt->Private.Head = pOldPacket->Private.Head;
        pNewPkt->Private.Tail = pOldPacket->Private.Tail;

        pNewPkt->Private.ValidCounts = FALSE;

        
        // indicate the packet with a status of resources

        NDIS_SET_PACKET_STATUS (pNewPkt,  NDIS_STATUS_RESOURCES);

        HeadBufferLength = NdisBufferLength (pNewPkt->Private.Head);
        pHeadBufferVa = NdisBufferVirtualAddressSafe (pNewPkt->Private.Head, NormalPagePriority );

        if (pHeadBufferVa ==NULL)
        {
            Status = NDIS_STATUS_FAILURE;
            break;
        }

        if (HeadBufferLength <= MacHeaderLength)
        {
            // we need to go the next NdisBuffer to get the Start of data
            // 
            pPayloadDataVa = NdisBufferVirtualAddressSafe (pNewPkt->Private.Head->Next, NormalPagePriority );

            if (pPayloadDataVa == NULL)
            {
                Status = NDIS_STATUS_FAILURE;
                break;
            }
            if (HeadBufferLength != MacHeaderLength)
            {
                pPayloadDataVa += (MacHeaderLength - HeadBufferLength);            
            }
        }
        else
        {
            // The payload is within the Buffer
            pPayloadDataVa += MacHeaderLength ;

        }

        if (pOldPacket->Private.ValidCounts == TRUE)
        {
            TotalLength = pOldPacket->Private.TotalLength;

        }
        else
        {
            NdisQueryPacket(pOldPacket, NULL, NULL, NULL, &TotalLength);

        }

        
        pIF->ip.RcvHandler(
                pIF->ip.Context,
                (PVOID)(pPayloadDataVa),
                HeadBufferLength - MacHeaderLength,
                TotalLength - MacHeaderLength,
                (NDIS_HANDLE)pNewPkt,
                MacHeaderLength,
                TRUE, //IsChannel
                NULL
                );


    }while (FALSE);

    if (pNewPkt != NULL)
    {
        NdisFreePacket (pNewPkt);
        pNewPkt = NULL;            
    }



}



REMOTE_DEST_KEY
RemoteIPKeyFromIPAddress (
    IPAddr IpAddress
    )
/*++

Routine Description:
    Creates a RemoteIPKey structure from an IP Address
    by tagging two constant bytes

Arguments:


Return Value:
    New Remote Ip Key

--*/
{
    REMOTE_DEST_KEY RemoteIpKey ={0,0,0,0,0,0} ;

    ASSERT (sizeof (REMOTE_DEST_KEY)==sizeof(ENetAddr));
    
    RemoteIpKey.IpAddress = IpAddress;
    
    return RemoteIpKey;
}



NTSTATUS
arpDelArpEntry(
        PARP1394_INTERFACE           pIF,
        IPAddr                       IpAddress,
        PRM_STACK_RECORD            pSR
        )
{
    ENTER("DelArpEntry", 0x3427306a)
    NTSTATUS            NtStatus;

    TR_WARN(("DEL ARP ENTRY\n"));
    NtStatus                        = STATUS_UNSUCCESSFUL;

    do
    {
        NDIS_STATUS             Status;
        NIC1394_FIFO_ADDRESS    FifoAddress;
        PARPCB_REMOTE_IP        pRemoteIp;
        PRM_TASK                pUnloadObjectTask;
        REMOTE_DEST_KEY        RemoteDestKey;

        // If this is a Subnet broadcast IP address, then skip the delete
        //
#define ARP1394_SUBNET_BROADCAST_IP  0xffff0000      

        if ((IpAddress & ARP1394_SUBNET_BROADCAST_IP  ) == ARP1394_SUBNET_BROADCAST_IP  )
        {
            break;
        }
            
        LOCKOBJ(pIF, pSR);

        //
        // Initialize the RemoteDestKey
        //
        REMOTE_DEST_KEY_INIT(&RemoteDestKey);

        RemoteDestKey.IpAddress  = IpAddress;                 
        // 
        // Lookup the RemoteIp entry corresponding to this entry and unload
        // it.
        //
        Status = RmLookupObjectInGroup(
                        &pIF->RemoteIpGroup,
                        0,                                      // Flags
                        (PVOID) &RemoteDestKey,     // pKey
                        NULL,                                   // pvCreateParams
                        &(PRM_OBJECT_HEADER)pRemoteIp,
                        NULL, // pfCreated
                        pSR
                        );

        UNLOCKOBJ(pIF, pSR);

        if (FAIL(Status))
        {
            break;
        }

        //
        // Found pRemoteIp. Let's initiate the unload of pRemoteIp. We won't wait
        // around for it to complete.
        //
        Status =  arpAllocateTask(
                    &pRemoteIp->Hdr,        // pParentObject,
                    arpTaskUnloadRemoteIp,  // pfnHandler,
                    0,                      // Timeout,
                    "Task:Unload RemoteIp (DelArpEntry)",
                    &pUnloadObjectTask,
                    pSR
                    );
        RmTmpDereferenceObject(&pRemoteIp->Hdr, pSR);

        if (FAIL(Status))
        {
            TR_WARN(("Couldn't allocate unload remoteip task."));
            break;
        }
        
        RmStartTask(
            pUnloadObjectTask,
            0, // UserParam (unused)
            pSR
            );

        NtStatus = STATUS_SUCCESS; // always succeed

    } while (FALSE);

    EXIT()
    return NtStatus;
}