windows-xp/Source/XPSP1/NT/net/1394/arp/sys/ioctl.c

/*++

Copyright (c) 1996  Microsoft Corporation

Module Name:

    ioctl.c

Abstract:

    Handler routines for Internal IOCTLs, including IOCTL_ARP1394_REQUEST.

Revision History:

    Who         When        What
    --------    --------    ----------------------------------------------
    josephj     11-20-97    Created

Notes:

--*/

#include <precomp.h>
// #include "ioctl.h"

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


NTSTATUS
arpDoClientCommand(
        PARP1394_IOCTL_COMMAND              pCmd,
        UINT                                BufLen
        );

NTSTATUS
arpDoEthernetCommand(
        PARP1394_IOCTL_COMMAND              pCmd,
        UINT                                BufLen
        );

NTSTATUS
arpIoctlGetArpCache(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_GET_ARPCACHE         pGetCacheCmd,
        PRM_STACK_RECORD                    pSR
        );

NTSTATUS
arpIoctlAddArpEntry(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_ADD_ARP_ENTRY        pAddArpEntryCmd,
        PRM_STACK_RECORD                    pSR
        );

NTSTATUS
arpIoctlDelArpEntry(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_DEL_ARP_ENTRY        pDelArpEntryCmd,
        PRM_STACK_RECORD                    pSR
        );

NTSTATUS
arpIoctlPurgeArpCache(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_PURGE_ARPCACHE       pPurgeCmd,
        PRM_STACK_RECORD                    pSR
        );

NTSTATUS
arpIoctlGetPacketStats(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_GET_PACKET_STATS     pStatsCmd,
        PRM_STACK_RECORD                    pSR
        );

NTSTATUS
arpIoctlGetTaskStats(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_GET_TASK_STATS       pStatsCmd,
        PRM_STACK_RECORD                    pSR
        );


NTSTATUS
arpIoctlGetArpStats(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_GET_ARPCACHE_STATS   pStatsCmd,
        PRM_STACK_RECORD                    pSR
        );

NTSTATUS
arpIoctlGetCallStats(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_GET_CALL_STATS       pStatsCmd,
        PRM_STACK_RECORD                    pSR
        );

NTSTATUS
arpIoctlResetStats(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_RESET_STATS          pResetStatsCmd,
        PRM_STACK_RECORD                    pSR
        );

NTSTATUS
arpIoctlReinitIf(
        PARP1394_INTERFACE                  pIF,
        PARP1394_IOCTL_REINIT_INTERFACE     pReinitCmd,
        PRM_STACK_RECORD                    pSR
        );

PARP1394_INTERFACE
arpGetIfByIp(
        IN OUT IP_ADDRESS                   *pLocalIpAddress, // OPTIONAL
        PRM_STACK_RECORD                    pSR
        );

UINT
arpGetStatsDuration(
        PARP1394_INTERFACE pIF
        );

NTSTATUS
arpIoctlSendPacket(
        PARP1394_INTERFACE              pIF,
        PARP1394_IOCTL_SEND_PACKET      pSendPacket,
        PRM_STACK_RECORD                pSR
        );

NTSTATUS
arpIoctlRecvPacket(
        PARP1394_INTERFACE              pIF,
        PARP1394_IOCTL_RECV_PACKET      pRecvPacket,
        PRM_STACK_RECORD                pSR
        );

NTSTATUS
arpIoctlGetNicInfo(
        PARP1394_INTERFACE              pIF,
        PARP1394_IOCTL_NICINFO          pIoctlNicInfo,
        PRM_STACK_RECORD                pSR
        );

NTSTATUS
arpIoctlGetEuidNodeMacInfo(
        PARP1394_INTERFACE          pIF,
        PARP1394_IOCTL_EUID_NODE_MAC_INFO   pEuidInfo,
        PRM_STACK_RECORD            pSR
        );


NTSTATUS
ArpHandleIoctlRequest(
    IN  PIRP                    pIrp,
    IN  PIO_STACK_LOCATION      pIrpSp
    )
/*++

Routine Description:

    Private IOCTL interface to the ARP1394 administration utility.

--*/
{
    NTSTATUS                NtStatus = STATUS_UNSUCCESSFUL;
    PUCHAR                  pBuf;  
    UINT                    BufLen;
    ULONG                   Code;

    ENTER("Ioctl", 0x4e96d522)

    pIrp->IoStatus.Information = 0;
    pBuf    = pIrp->AssociatedIrp.SystemBuffer;
    BufLen  = pIrpSp->Parameters.DeviceIoControl.InputBufferLength;
    Code    = pIrpSp->Parameters.DeviceIoControl.IoControlCode;

    TR_WARN(("Code = 0x%p\n", Code));
    
    if (Code ==  ARP_IOCTL_CLIENT_OPERATION && pBuf != NULL)
    {
        PARP1394_IOCTL_COMMAND          pCmd;
        pCmd = (PARP1394_IOCTL_COMMAND) pBuf;

        if (   (pCmd->Hdr.Op >= ARP1394_IOCTL_OP_ETHERNET_FIRST)
            && (pCmd->Hdr.Op <= ARP1394_IOCTL_OP_ETHERNET_LAST))
        {
            // This is an ethernet-emulation related ioctl request (from
            // NIC1394.SYS). We handle these differently.
            //
            NtStatus = arpDoEthernetCommand(pCmd, BufLen);
        }
        else
        {
            NtStatus = arpDoClientCommand(pCmd, BufLen);
        }

        //
        // All commands return stuff in pCmd itself...
        //
        if (NtStatus == STATUS_SUCCESS)
        {
            pIrp->IoStatus.Information = BufLen;
        }
    }
    else
    {
        TR_WARN(("Unrecognized code.\n"));
    }

    EXIT()
    return NtStatus;
}

NTSTATUS
arpDoClientCommand(
    PARP1394_IOCTL_COMMAND  pCmd,
    UINT                    BufLen
    )
{
    ENTER("arpDoClientCommand", 0xd7985f1b)
    NTSTATUS NtStatus = STATUS_UNSUCCESSFUL;
    PARP1394_INTERFACE  pIF;
    RM_DECLARE_STACK_RECORD(sr)

    do
    {
        IP_ADDRESS          IpAddress;

        pIF = NULL;

        if (pCmd == NULL)
        {
            TR_WARN(("Invalid buffer %p\n", pCmd));
            break;

        }

        if (BufLen<sizeof(pCmd->Hdr))
        {
            TR_WARN(("Buffer too small (%lu)\n", BufLen));
            break;
        }

        if (pCmd->Hdr.Version != ARP1394_IOCTL_VERSION)
        {
            TR_WARN(("Incorrect version 0x%08lx\n", pCmd->Hdr.Version));
            break;
        }

        
        IpAddress = (IP_ADDRESS)  pCmd->Hdr.IfIpAddress;

        // IpAddress could be all-zeros, in which case we'll get the first IF,
        // and IpAddress will be set to one of the local IP addresses of this IF.
        // NOTE: pIF is tmpref'd.
        //
        pIF = arpGetIfByIp(&IpAddress, &sr);

        if (pIF == NULL)
        {
            TR_WARN(("Couldn't find IF with IP 0x%0x8lx\n", IpAddress));
            break;
        }

        pCmd->Hdr.IfIpAddress        = IpAddress;

        switch(pCmd->Hdr.Op)
        {
        case ARP1394_IOCTL_OP_GET_ARPCACHE:
            {
                PARP1394_IOCTL_GET_ARPCACHE pGetArpCache =  &pCmd->GetArpCache;
                if (BufLen >= sizeof(*pGetArpCache))
                {
                    //
                    // Check if there is enough space for all the arp entries.
                    //
                    ULONG EntrySpace;
                    EntrySpace = BufLen - FIELD_OFFSET(
                                                ARP1394_IOCTL_GET_ARPCACHE,
                                                Entries
                                                );
                    if ((EntrySpace/sizeof(pGetArpCache->Entries[0])) >
                        pGetArpCache->NumEntriesAvailable)
                    {
                        //
                        // Yes, there is enough space.
                        //
                        NtStatus = arpIoctlGetArpCache(pIF, pGetArpCache, &sr);
                    }
                }
            }
            break;
    
        case ARP1394_IOCTL_OP_ADD_STATIC_ENTRY:
            {
                PARP1394_IOCTL_ADD_ARP_ENTRY pAddCmd =  &pCmd->AddArpEntry;
                if (BufLen >= sizeof(*pAddCmd))
                {
                    NtStatus = arpIoctlAddArpEntry(pIF, pAddCmd, &sr);
                }
            }
            break;
    
        case ARP1394_IOCTL_OP_DEL_STATIC_ENTRY:
            {
                PARP1394_IOCTL_DEL_ARP_ENTRY pDelCmd =  &pCmd->DelArpEntry;
                if (BufLen >= sizeof(*pDelCmd))
                {
                    NtStatus = arpIoctlDelArpEntry(pIF, pDelCmd, &sr);
                }
            }
            break;
    
        case ARP1394_IOCTL_OP_PURGE_ARPCACHE:
            {
                PARP1394_IOCTL_PURGE_ARPCACHE pPurge =  &pCmd->PurgeArpCache;
                if (BufLen >= sizeof(*pPurge))
                {
                    NtStatus = arpIoctlPurgeArpCache(pIF, pPurge, &sr);
                }
            }
            break;
    
        case ARP1394_IOCTL_OP_GET_PACKET_STATS:
            {
                PARP1394_IOCTL_GET_PACKET_STATS pStats =  &pCmd->GetPktStats;
                if (BufLen >= sizeof(*pStats))
                {
                    NtStatus = arpIoctlGetPacketStats(pIF, pStats, &sr);
                }
            }
            break;
    
        case ARP1394_IOCTL_OP_GET_TASK_STATS:
            {
                PARP1394_IOCTL_GET_TASK_STATS pStats =  &pCmd->GetTaskStats;
                if (BufLen >= sizeof(*pStats))
                {
                    NtStatus = arpIoctlGetTaskStats(pIF, pStats, &sr);
                }
            }
            break;
    
        case ARP1394_IOCTL_OP_GET_ARPCACHE_STATS:
            {
                PARP1394_IOCTL_GET_ARPCACHE_STATS pStats =  &pCmd->GetArpStats;
                if (BufLen >= sizeof(*pStats))
                {
                    NtStatus = arpIoctlGetArpStats(pIF, pStats, &sr);
                }
            }
            break;
    
        case ARP1394_IOCTL_OP_GET_CALL_STATS:
            {
                PARP1394_IOCTL_GET_CALL_STATS pStats =  &pCmd->GetCallStats;
                if (BufLen >= sizeof(*pStats))
                {
                    NtStatus = arpIoctlGetCallStats(pIF, pStats, &sr);
                }
            }
            break;
    
        case ARP1394_IOCTL_OP_RESET_STATS:
            {
                PARP1394_IOCTL_RESET_STATS pResetStats =  &pCmd->ResetStats;
                if (BufLen >= sizeof(*pResetStats))
                {
                    NtStatus = arpIoctlResetStats(pIF, pResetStats, &sr);
                }
            }
            break;

        case ARP1394_IOCTL_OP_REINIT_INTERFACE:
            {
                PARP1394_IOCTL_REINIT_INTERFACE pReinitIf =  &pCmd->ReinitInterface;
                if (BufLen >= sizeof(*pReinitIf))
                {
                    NtStatus = arpIoctlReinitIf(pIF, pReinitIf, &sr);
                }
            }
            break;
    
        case  ARP1394_IOCTL_OP_SEND_PACKET:
            {
                ARP1394_IOCTL_SEND_PACKET *pSendPacket = &pCmd->SendPacket;
                if (BufLen >= sizeof(*pSendPacket))
                {
                    NtStatus = arpIoctlSendPacket(pIF, pSendPacket, &sr);
                }
            }
            break;
    
        case  ARP1394_IOCTL_OP_RECV_PACKET:
            {
                ARP1394_IOCTL_RECV_PACKET *pRecvPacket = &pCmd->RecvPacket;
                if (BufLen >= sizeof(*pRecvPacket))
                {
                    NtStatus = arpIoctlRecvPacket(pIF, pRecvPacket, &sr);
                }
            }
            break;
    
        case  ARP1394_IOCTL_OP_GET_NICINFO:
            {
                ARP1394_IOCTL_NICINFO *pIoctlNicInfo = &pCmd->IoctlNicInfo;
                if (BufLen >= sizeof(*pIoctlNicInfo))
                {
                    NtStatus = arpIoctlGetNicInfo(pIF, pIoctlNicInfo, &sr);
                }
            }
            break;
        case ARP1394_IOCTL_OP_GET_EUID_NODE_MAC_TABLE:
            {
                PARP1394_IOCTL_EUID_NODE_MAC_INFO pIoctlEuidInfo = &pCmd->EuidNodeMacInfo;
                if (BufLen >= sizeof(*pIoctlEuidInfo))
                {
                    NtStatus = arpIoctlGetEuidNodeMacInfo(pIF, pIoctlEuidInfo, &sr);
                }

            }
            break;

        default:
            TR_WARN(("Unknown op %lu\n",  pCmd->Hdr.Op));
            break;
    
        }
    } while (FALSE);

    if (NtStatus != STATUS_SUCCESS)
    {
        TR_WARN(("Command unsuccessful. NtStatus = 0x%lx\n", NtStatus));
    }

    if (pIF != NULL)
    {
        RmTmpDereferenceObject(&pIF->Hdr, &sr);
    }

    RM_ASSERT_CLEAR(&sr);
    EXIT()

    return NtStatus;
}


NTSTATUS
arpDoEthernetCommand(
    PARP1394_IOCTL_COMMAND  pCmd,
    UINT                    BufLen
    )
{
    ENTER("arpDoEthernetCommand", 0xa723f233)
    PARP1394_IOCTL_ETHERNET_NOTIFICATION pNotif;
    PARP1394_ADAPTER pAdapter = NULL;
    RM_DECLARE_STACK_RECORD(sr)

    pNotif = (PARP1394_IOCTL_ETHERNET_NOTIFICATION) pCmd;

    do
    {
        NDIS_STATUS NdisStatus = NDIS_STATUS_FAILURE;
        NDIS_STRING DeviceName;

        if (BufLen<sizeof(*pNotif))
        {
            TR_WARN(("Buffer too small (%lu)\n", BufLen));
            break;
        }

        if (pNotif->Hdr.Version != ARP1394_IOCTL_VERSION)
        {
            TR_WARN(("Incorrect version 0x%08lx\n", pCmd->Hdr.Version));
            break;
        }

        NdisInitUnicodeString(&DeviceName, pNotif->AdapterName);

        if (pNotif->Hdr.Op == ARP1394_IOCTL_OP_ETHERNET_START_EMULATION)
        {
            //
            // ArpNdBindAdapter will try to create the adapter in "Bridge
            // mode" if it passed in a NULL bind context.
            // It will of course fail if the adapter exists.
            //
            ArpNdBindAdapter(
                &NdisStatus,
                NULL,           // BindContext
                &DeviceName,    // pDeviceName
                NULL,           // SystemSpecific1
                NULL            // SystemSpecific2
                );
            break;
        }

        //
        // The remaining operations concern an existing adapter which has been
        // created in "bridge" mode. Let's look up this adapter based on it's
        // name.
        //

        NdisStatus = RmLookupObjectInGroup(
                            &ArpGlobals.adapters.Group,
                            0,                              // Flags
                            (PVOID) &DeviceName,            // pKey
                            NULL,                           // pvCreateParams
                            &(PRM_OBJECT_HEADER) pAdapter,  // pObj
                            NULL,                           // pfCreated
                            &sr
                            );
        if (FAIL(NdisStatus))
        {
            TR_WARN(("Couldn't find adapter object\n"));
            pAdapter = NULL;
            break;
        }

        if (!ARP_BRIDGE_ENABLED(pAdapter))
        {
            TR_WARN((
            "Ignoring Ethernet Emulation Ioctl Op 0x%x"
            " because adapter 0x%p is not in bridge mode.\n",
            pNotif->Hdr.Op,
            pAdapter));
            break;
        }

        //
        // OK -- we've found the adapter and the adapter is in bridged mode.
        // Let's look at the specific command.
        //

        switch(pNotif->Hdr.Op)
        {

        case  ARP1394_IOCTL_OP_ETHERNET_STOP_EMULATION:
            {
                // Calling ArpNdUnbindAdapter with NULL UnbindContext prevents
                // it from trying to call NdisCompleteUnbindAdapter.
                //
                ArpNdUnbindAdapter(
                    &NdisStatus,
                    (NDIS_HANDLE) pAdapter,
                    NULL // UnbindContext
                    );
            }
            break;

        case ARP1394_IOCTL_OP_ETHERNET_ADD_MULTICAST_ADDRESS:
            {
                // TODO: unimplemented.
            }
            break;

        case ARP1394_IOCTL_OP_ETHERNET_DEL_MULTICAST_ADDRESS:
            {
                // TODO: unimplemented.
            }
            break;

        case ARP1394_IOCTL_OP_ETHERNET_ENABLE_PROMISCUOUS_MODE:
            {
                // TODO: unimplemented.
            }
            break;

        case ARP1394_IOCTL_OP_ETHERNET_DISABLE_PROMISCUOUS_MODE:
            {
                // TODO: unimplemented.
            }
            break;
    
        default:
            TR_WARN(("Unknown op %lu\n",  pCmd->Hdr.Op));
            break;
    
        }

    } while (FALSE);

    if (pAdapter != NULL)
    {
        RmTmpDereferenceObject(&pAdapter->Hdr, &sr);
    }

    RM_ASSERT_CLEAR(&sr);
    EXIT()

    return STATUS_SUCCESS;
}


NTSTATUS
arpIoctlGetArpCache(
        PARP1394_INTERFACE           pIF,
        PARP1394_IOCTL_GET_ARPCACHE pGetCacheCmd,
        PRM_STACK_RECORD            pSR
        )
{
    ENTER("GetArpCache", 0xa64453c7)
    NTSTATUS            NtStatus;
    TR_WARN(("GET ARP CACHE\n"));

    pGetCacheCmd->NumEntriesUsed    = 0;
    NtStatus                        = STATUS_UNSUCCESSFUL;

    do
    {
        PARP1394_ADAPTER pAdapter;
        PARP1394_ARP_ENTRY  pEntry;
        ARPCB_REMOTE_IP *   pRemoteIp;
        NDIS_STATUS         Status;
        UINT                EntriesAvailable;
        UINT                EntriesUsed;
        UINT                CurIndex;
        UINT                Index;


        LOCKOBJ(pIF, pSR);

        pAdapter =  (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);
        pGetCacheCmd->NumEntriesInArpCache   = pIF->RemoteIpGroup.HashTable.NumItems;
        pGetCacheCmd->LocalHwAddress.UniqueID= pAdapter->info.LocalUniqueID;
        pGetCacheCmd->LocalHwAddress.Off_Low = pIF->recvinfo.offset.Off_Low;
        pGetCacheCmd->LocalHwAddress.Off_High= pIF->recvinfo.offset.Off_High;

        //
        // Pick up pGetCacheCmd->NumEntriesAvailable arp entries starting
        // from the (pGetCacheCmd->Index)'th one.
        //
    
        pRemoteIp       = NULL;
        EntriesAvailable = pGetCacheCmd->NumEntriesAvailable;
        EntriesUsed = 0;
        Index = pGetCacheCmd->Index;
        pEntry = pGetCacheCmd->Entries;
        CurIndex = 0;
    
        // Get the 1st entry...
        //
        Status = RmGetNextObjectInGroup(
                    &pIF->RemoteIpGroup,
                    NULL,
                    &(PRM_OBJECT_HEADER)pRemoteIp,
                    pSR
                    );
        if (FAIL(Status))
        {
            // Presumably there are no entries.
            pRemoteIp = NULL;
        }
    
        while (pRemoteIp != NULL)
        {
            ARPCB_REMOTE_IP *   pNextRemoteIp = NULL;
    
            if (EntriesUsed >= EntriesAvailable)
            {
                //
                // out of space; Update the context, and set special return value.
                //
                RmTmpDereferenceObject(&pRemoteIp->Hdr, pSR);
                pRemoteIp = NULL;
                break;
            }
    
            // If this entry is within the range asked for, we copy the IP and
            // HW address over onto pEntry...
            //
            if (CurIndex >= Index)
            {
                ARP_ZEROSTRUCT(pEntry);
                pEntry->IpAddress = pRemoteIp->Key.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);
    
                    pEntry->HwAddress.UniqueID  = pDest->Params.HwAddr.FifoAddress.UniqueID;
                    pEntry->HwAddress.Off_Low   = pDest->Params.HwAddr.FifoAddress.Off_Low;
                    pEntry->HwAddress.Off_High  = pDest->Params.HwAddr.FifoAddress.Off_High;
    
                    if (CHECK_REMOTEIP_SDTYPE(pRemoteIp, ARPREMOTEIP_STATIC))
                    {
                        // TODO
                    }
                    else
                    {
                        // TODO
                    }
                }
                else
                {
                    // TODO
                }
    
                pEntry++;
                EntriesUsed++;
            }
    
            // 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);
        UNLOCKOBJ(pIF, pSR);

        ASSERT(EntriesUsed <= pGetCacheCmd->NumEntriesAvailable);
        pGetCacheCmd->NumEntriesUsed = EntriesUsed;
        NtStatus = STATUS_SUCCESS;

    } while (FALSE);

    EXIT()
    return NtStatus;
}


NTSTATUS
arpIoctlAddArpEntry(
        PARP1394_INTERFACE           pIF,
        PARP1394_IOCTL_ADD_ARP_ENTRY pAddArpEntryCmd,
        PRM_STACK_RECORD            pSR
        )
{
    ENTER("AddArpEntry", 0xcda56c6f)
    NTSTATUS            NtStatus;

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

    do
    {
        NDIS_STATUS         Status;
        NIC1394_FIFO_ADDRESS    FifoAddress;

        LOCKOBJ(pIF, pSR);

        FifoAddress.UniqueID    = pAddArpEntryCmd->HwAddress.UniqueID;
        FifoAddress.Off_Low     = pAddArpEntryCmd->HwAddress.Off_Low;
        FifoAddress.Off_High    = pAddArpEntryCmd->HwAddress.Off_High;

        // 
        // TODO -- we hardcode the Off_Low and Off_High values for now...
        //
        FifoAddress.Off_Low     = 0x0;
        FifoAddress.Off_High    = 0x100;

        // Actually add the entry...
        //
        Status = arpAddOneStaticArpEntry(
                    pIF,
                    pAddArpEntryCmd->IpAddress,
                    &FifoAddress,
                    pSR
                    );
    
        UNLOCKOBJ(pIF, pSR);

        if (!FAIL(Status))
        {
            NtStatus = STATUS_SUCCESS;
        }

    } while (FALSE);


    EXIT()
    return NtStatus;
}

NTSTATUS
arpIoctlDelArpEntry(
        PARP1394_INTERFACE           pIF,
        PARP1394_IOCTL_DEL_ARP_ENTRY pDelArpEntryCmd,
        PRM_STACK_RECORD            pSR
        )
{
    ENTER("DelArpEntry", 0x3427306a)
    NTSTATUS            NtStatus;

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

    NtStatus = arpDelArpEntry(pIF,pDelArpEntryCmd->IpAddress,pSR);
    EXIT()
    return NtStatus;
}



NTSTATUS
arpIoctlPurgeArpCache(
        PARP1394_INTERFACE           pIF,
        PARP1394_IOCTL_PURGE_ARPCACHE pPurgeCmd,
        PRM_STACK_RECORD            pSR
        )
{
    ENTER("PurgeArpCache", 0x2bebb833)
    TR_WARN(("PURGE ARP CACHE\n"));
    return 0;
}

NTSTATUS
arpIoctlGetPacketStats(
    PARP1394_INTERFACE           pIF,
    PARP1394_IOCTL_GET_PACKET_STATS pStatsCmd,
    PRM_STACK_RECORD            pSR
    )
{
    ENTER("GetPacketStats", 0xe7c75fdb)
    NTSTATUS            NtStatus;

    TR_WARN(("GET PACKET STATS\n"));
    NtStatus                        = STATUS_UNSUCCESSFUL;

    do
    {
        NDIS_STATUS             Status;

        pStatsCmd->StatsDuration        = arpGetStatsDuration(pIF);
    
        pStatsCmd->TotSends             = pIF->stats.sendpkts.TotSends;
        pStatsCmd->FastSends            = pIF->stats.sendpkts.FastSends;
        pStatsCmd->MediumSends          = pIF->stats.sendpkts.MediumSends;
        pStatsCmd->SlowSends            = pIF->stats.sendpkts.SlowSends;
        pStatsCmd->BackFills            = pIF->stats.sendpkts.BackFills;
        // TODO: report  pIF->sendinfo.HeaderPool.stats.TotAllocFails
        pStatsCmd->HeaderBufUses        = 
                                    pIF->sendinfo.HeaderPool.stats.TotBufAllocs
                                 + pIF->sendinfo.HeaderPool.stats.TotCacheAllocs;
        pStatsCmd->HeaderBufCacheHits   =
                                 pIF->sendinfo.HeaderPool.stats.TotCacheAllocs;
    
        pStatsCmd->TotRecvs             = pIF->stats.recvpkts.TotRecvs;
        pStatsCmd->NoCopyRecvs          = pIF->stats.recvpkts.NoCopyRecvs;
        pStatsCmd->CopyRecvs            = pIF->stats.recvpkts.CopyRecvs;
        pStatsCmd->ResourceRecvs        = pIF->stats.recvpkts.ResourceRecvs;
    
        pStatsCmd->SendFifoCounts       = pIF->stats.sendpkts.SendFifoCounts;
        pStatsCmd->RecvFifoCounts       = pIF->stats.recvpkts.RecvFifoCounts;

        pStatsCmd->SendChannelCounts    = pIF->stats.sendpkts.SendChannelCounts;
        pStatsCmd->RecvChannelCounts    = pIF->stats.recvpkts.RecvChannelCounts;

        NtStatus = STATUS_SUCCESS;

    } while (FALSE);

    EXIT()
    return NtStatus;
}



NTSTATUS
arpIoctlGetTaskStats(
    PARP1394_INTERFACE           pIF,
    PARP1394_IOCTL_GET_TASK_STATS pStatsCmd,
    PRM_STACK_RECORD            pSR
    )
{
    ENTER("GetTaskStats", 0x4abc46b5)
    TR_WARN(("GET TASK STATS\n"));
    return 0;
}


NTSTATUS
arpIoctlGetArpStats(
    PARP1394_INTERFACE           pIF,
    PARP1394_IOCTL_GET_ARPCACHE_STATS pStatsCmd,
    PRM_STACK_RECORD            pSR
    )
{
    ENTER("GetArpStats", 0x5482de10)
    TR_WARN(("GET ARP STATS\n"));

    pStatsCmd->StatsDuration        = arpGetStatsDuration(pIF);
    pStatsCmd->TotalQueries         = pIF->stats.arpcache.TotalQueries;
    pStatsCmd->SuccessfulQueries    = pIF->stats.arpcache.SuccessfulQueries;
    pStatsCmd->FailedQueries        = pIF->stats.arpcache.FailedQueries;
    pStatsCmd->TotalResponses       = pIF->stats.arpcache.TotalResponses;
    pStatsCmd->TotalLookups         = pIF->stats.arpcache.TotalLookups;
    pStatsCmd->TraverseRatio        = RM_HASH_TABLE_TRAVERSE_RATIO(
                                                &(pIF->RemoteIpGroup.HashTable)
                                                );

    EXIT()
    return  STATUS_SUCCESS;
}

NTSTATUS
arpIoctlGetCallStats(
    PARP1394_INTERFACE           pIF,
    PARP1394_IOCTL_GET_CALL_STATS pStatsCmd,
    PRM_STACK_RECORD            pSR
    )
{
    ENTER("GetCallStats", 0xf81ed4cf)
    TR_WARN(("GET CALL STATS\n"));

    //
    // FIFO-related call stats.
    //
    pStatsCmd->TotalSendFifoMakeCalls   =
                                pIF->stats.calls.TotalSendFifoMakeCalls;
    pStatsCmd->SuccessfulSendFifoMakeCalls =
                                pIF->stats.calls.SuccessfulSendFifoMakeCalls;
    pStatsCmd->FailedSendFifoMakeCalls =
                                pIF->stats.calls.FailedSendFifoMakeCalls;
    pStatsCmd->IncomingClosesOnSendFifos =
                                pIF->stats.calls.IncomingClosesOnSendFifos;

    //
    // Channel-related call stats.
    //
    pStatsCmd->TotalChannelMakeCalls =
                                pIF->stats.calls.TotalChannelMakeCalls;
    pStatsCmd->SuccessfulChannelMakeCalls =
                                pIF->stats.calls.SuccessfulChannelMakeCalls;
    pStatsCmd->FailedChannelMakeCalls =
                                pIF->stats.calls.FailedChannelMakeCalls;
    pStatsCmd->IncomingClosesOnChannels =
                                pIF->stats.calls.IncomingClosesOnChannels;

    return STATUS_SUCCESS;
}

NTSTATUS
arpIoctlResetStats(
        PARP1394_INTERFACE           pIF,
        PARP1394_IOCTL_RESET_STATS pResetStatsCmd,
        PRM_STACK_RECORD            pSR
        )
{
    NTSTATUS            NtStatus;
    ENTER("ResetStats", 0xfa50cfc9)
    TR_WARN(("RESET STATS\n"));

    NtStatus                        = STATUS_UNSUCCESSFUL;

    do
    {
        NDIS_STATUS         Status;
        NIC1394_FIFO_ADDRESS    FifoAddress;


        LOCKOBJ(pIF, pSR);
        arpResetIfStats(pIF, pSR);
        UNLOCKOBJ(pIF, pSR);
        NtStatus = STATUS_SUCCESS;

    } while (FALSE);

    EXIT()
    return NtStatus;
}

NTSTATUS
arpIoctlReinitIf(
        PARP1394_INTERFACE           pIF,
        PARP1394_IOCTL_REINIT_INTERFACE pReinitIfCmd,
        PRM_STACK_RECORD            pSR
        )
{
    ENTER("ReinitIf", 0xed00187a)
    NTSTATUS            NtStatus;

    TR_WARN(("REINIT IF\n"));
    NtStatus                        = STATUS_UNSUCCESSFUL;

    do
    {
        NDIS_STATUS         Status;
        NIC1394_FIFO_ADDRESS    FifoAddress;


        Status = arpTryReconfigureIf(pIF, NULL, pSR);

        if (PEND(Status) || !FAIL(Status))
        {
            NtStatus = STATUS_SUCCESS;
        }

    } while (FALSE);

    EXIT()
    return NtStatus;
}


PARP1394_INTERFACE
arpGetIfByIp(
    IN OUT IP_ADDRESS *pLocalIpAddress, // OPTIONAL
    PRM_STACK_RECORD pSR
    )
/*++
Routine Description:

    Find and return the 1st (and usually only) interface which has
    *pLocalIpAddress as a local IP address.

    If pLocalIpAddress is NULL, or *pLocalIpAddress is 0, return the
    first interface.

    Tmpref the interface before returning it.

--*/
{
    ENTER("arpGetIfByIp", 0xe9667c54)
    PARP1394_ADAPTER   pAdapter      = NULL;
    PARP1394_INTERFACE pIF = NULL;
    PARP1394_INTERFACE pFirstIF = NULL;
    NDIS_STATUS        Status;
    IP_ADDRESS         LocalIpAddress = 0;

    if (pLocalIpAddress != NULL)
    {
        LocalIpAddress = *pLocalIpAddress;
    }

    //
    // We iterate through all adapters, and for each adapter we look
    // for the specified ip address in the IF's LocalIp group.
    //

    // Get the 1st adapter...
    //
    Status = RmGetNextObjectInGroup(
                    &ArpGlobals.adapters.Group,
                    NULL,
                    &(PRM_OBJECT_HEADER)pAdapter,
                    pSR
                    );

    if (FAIL(Status))
    {
        pAdapter = NULL;
    }

    while (pAdapter != NULL)
    {
        ARP1394_ADAPTER *   pNextAdapter = NULL;


        // Check if this adapter's interface has the local ip address.
        //
        LOCKOBJ(pAdapter, pSR);
        ASSERT(pIF==NULL);
        pIF = pAdapter->pIF;
        if (pIF != NULL)
        {
            RmTmpReferenceObject(&pIF->Hdr, pSR);
            if (pFirstIF == NULL)
            {
                pFirstIF = pIF;
                RmTmpReferenceObject(&pFirstIF->Hdr, pSR);
            }
        }
        UNLOCKOBJ(pAdapter, pSR);

        if (pIF != NULL)
        {
            PARPCB_LOCAL_IP pLocalIp;
            LOCKOBJ(pIF, pSR);

            if (LocalIpAddress != 0)
            {
                Status = RmLookupObjectInGroup(
                                    &pIF->LocalIpGroup,
                                    0,                      // Flags
                                    (PVOID) ULongToPtr (LocalIpAddress),    // pKey
                                    NULL,                   // pvCreateParams
                                    &(PRM_OBJECT_HEADER)pLocalIp,
                                    NULL, // pfCreated
                                    pSR
                                    );
            }
            else
            {
                PARPCB_LOCAL_IP pPrevLocalIp = NULL;

                do
                {
                    Status = RmGetNextObjectInGroup(
                                    &pIF->LocalIpGroup,
                                    &(pPrevLocalIp)->Hdr,
                                    &(PRM_OBJECT_HEADER)pLocalIp,
                                    pSR
                                    );
                    if (pPrevLocalIp != NULL)
                    {
                        RmTmpDereferenceObject(&pPrevLocalIp->Hdr, pSR);
                    }
                    pPrevLocalIp = pLocalIp;

                    //
                    // we need to keep looking until we find a UNICAST
                    // local ip address!
                    //

                } while (!FAIL(Status) && pLocalIp->IpAddressType!=LLIP_ADDR_LOCAL);
            }

            UNLOCKOBJ(pIF, pSR);

            if (FAIL(Status))
            {
                // This IF is not the one, sorry...
                //
                RmTmpDereferenceObject(&pIF->Hdr, pSR);
                pIF = NULL;
            }
            else
            {
                // Found a local IP address (either matching or first one).
                // Let's get out of here...
                //
                if (pLocalIpAddress != NULL)
                {
                    *pLocalIpAddress = pLocalIp->IpAddress;
                }
                RmTmpDereferenceObject(&pLocalIp->Hdr, pSR);
                RmTmpDereferenceObject(&pAdapter->Hdr, pSR);
                pLocalIp = NULL;
                pAdapter = NULL;
                //
                // Note: we keep the reference on pIF, which we return.
                //
                break; // break out of the enclosing while(adapters-left) loop.
            }
        }

        // Lookup next adapter.
        //
        Status = RmGetNextObjectInGroup(
                        &ArpGlobals.adapters.Group,
                        &pAdapter->Hdr,
                        &(PRM_OBJECT_HEADER)pNextAdapter,
                        pSR
                        );

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


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

    }

    //
    // If LocalipAddress ==0 AND
    // if we couldn't find any IF with any local IP address
    // (this would be because we haven't started an IF as yet)
    // we return the first IF we find.
    //
    if (LocalIpAddress == 0 && pIF == NULL)
    {
        pIF = pFirstIF;
        pFirstIF = NULL;
    }

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

    return pIF;
}

UINT
arpGetStatsDuration(
        PARP1394_INTERFACE pIF
        )
/*++
    Return duration in seconds since start of statistics gathering.
--*/
{
    LARGE_INTEGER liCurrent;

    // Get the current time (in 100-nanosecond units).
    //
    NdisGetCurrentSystemTime(&liCurrent);

    // Compute the difference since the start of stats collection.
    //
    liCurrent.QuadPart -=  pIF->stats.StatsResetTime.QuadPart;

    // Convert to seconds.
    //
    liCurrent.QuadPart /= 10000000;

    // return low part.
    //
    return liCurrent.LowPart;
}

NTSTATUS
arpIoctlSendPacket(
        PARP1394_INTERFACE              pIF,
        PARP1394_IOCTL_SEND_PACKET      pSendPacket,
        PRM_STACK_RECORD                pSR
        )
/*++
    Send the pSendPacket->PacketSize bytes of data in pSendPacket->Data as
    a single packet on the broadcast channel. The encap header is expected
    to be already in the packet.
--*/
{
    ENTER("IoctlSendPacket", 0x59746279)
    NTSTATUS            NtStatus;

    RM_ASSERT_NOLOCKS(pSR);

    TR_WARN(("SEND PACKET\n"));
    NtStatus                        = STATUS_UNSUCCESSFUL;

    do
    {
        NDIS_STATUS         Status;
        PNDIS_PACKET        pNdisPacket;
        PVOID               pPktData;
        UINT                Size = pSendPacket->PacketSize;

        //
        // Validate contents of pSendPacket.
        //
        if (Size > sizeof(pSendPacket->Data))
        {
            TR_WARN(("PacketSize value %lu is too large.\n", Size));
            break;
        }

        //
        // Allocate a control packet and copy over the contents.
        //
        Status = arpAllocateControlPacket(
                    pIF,
                    Size,
                    ARP1394_PACKET_FLAGS_IOCTL,
                    &pNdisPacket,
                    &pPktData,
                    pSR
                    );

        if (FAIL(Status))
        {
            TR_WARN(("Couldn't allocate send packet.\n"));
            break;
        }

        NdisMoveMemory(pPktData, pSendPacket->Data, Size);

        ARP_FASTREADLOCK_IF_SEND_LOCK(pIF);

        // Actually send the packet (this will silently fail and free the pkt
        // if we're not in a position to send the pkt.)
        //
        arpSendControlPkt(
                pIF,            // LOCKIN NOLOCKOUT (IF send lk)
                pNdisPacket,
                pIF->pBroadcastDest,
                pSR
                );

        NtStatus = STATUS_SUCCESS;

    } while (FALSE);

    RM_ASSERT_NOLOCKS(pSR);

    EXIT()
    return NtStatus;
}


NTSTATUS
arpIoctlRecvPacket(
        PARP1394_INTERFACE              pIF,
        PARP1394_IOCTL_RECV_PACKET      pRecvPacket,
        PRM_STACK_RECORD                pSR
        )
{
    ENTER("IoctlRecvPacket", 0x59746279)
    NTSTATUS            NtStatus;

    RM_ASSERT_NOLOCKS(pSR);

    TR_WARN(("RECV PACKET\n"));
    NtStatus                        = STATUS_UNSUCCESSFUL;

    do
    {
        NDIS_STATUS         Status;
        PNDIS_PACKET        pNdisPacket;
        PVOID               pPktData;
        UINT                Size = pRecvPacket->PacketSize;

        //
        // Validate contents of pRecvPacket.
        //
        if (Size > sizeof(pRecvPacket->Data))
        {
            TR_WARN(("PacketSize value %lu is too large.\n", Size));
            break;
        }

        //
        // Allocate a control packet and copy over the contents.
        //
        Status = arpAllocateControlPacket(
                    pIF,
                    Size,
                    ARP1394_PACKET_FLAGS_IOCTL,
                    &pNdisPacket,
                    &pPktData,
                    pSR
                    );

        if (FAIL(Status))
        {
            TR_WARN(("Couldn't allocate recv packet.\n"));
            break;
        }

        NdisMoveMemory(pPktData, pRecvPacket->Data, Size);

        //
        // Set the packet flags to STATUS_RESOURCES, so that our receive-
        // indicate handler will return synchronously.
        //
        NDIS_SET_PACKET_STATUS (pNdisPacket,  NDIS_STATUS_RESOURCES);

        //
        // Call our internal common receive packet handler.
        //
        arpProcessReceivedPacket(
                    pIF,
                    pNdisPacket,
                    TRUE                    // IsChannel
                    );

        //
        // Now we free the packet.
        //
        arpFreeControlPacket(
            pIF,
            pNdisPacket,
            pSR
            );

        NtStatus = STATUS_SUCCESS;

    } while (FALSE);

    RM_ASSERT_NOLOCKS(pSR);

    EXIT()
    return NtStatus;
}


NTSTATUS
arpIoctlGetNicInfo(
        PARP1394_INTERFACE          pIF,
        PARP1394_IOCTL_NICINFO      pIoctlNicInfo,
        PRM_STACK_RECORD            pSR
        )
{
    ENTER("IoctlGetNicInfo", 0x637c44e0)
    NTSTATUS            NtStatus = STATUS_UNSUCCESSFUL;
    ARP_NDIS_REQUEST    ArpNdisRequest;
    PARP1394_ADAPTER    pAdapter;

    pAdapter =  (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);

    do
    {
        NDIS_STATUS Status;

        if (pIoctlNicInfo->Info.Hdr.Version != NIC1394_NICINFO_VERSION)
        {
            TR_WARN(("NicInfo version mismatch. Want 0x%lx, got 0x%lx.\n",
                    NIC1394_NICINFO_VERSION, pIoctlNicInfo->Info.Hdr.Version));
            break;
        }

        //
        // Copy over all the fields.
        //

        Status =  arpPrepareAndSendNdisRequest(
                    pAdapter,
                    &ArpNdisRequest,
                    NULL,                   // pTask (NULL==BLOCK)
                    0,                      // unused
                    OID_1394_NICINFO,
                    &pIoctlNicInfo->Info,
                    sizeof(pIoctlNicInfo->Info),
                    NdisRequestQueryInformation,
                    pSR
                    );

        if (FAIL(Status))
        {
            TR_WARN(("NdisRequest failed with error 0x%08lx.\n", Status));
            break;
        }

        if (pIoctlNicInfo->Info.Hdr.Version !=  NIC1394_NICINFO_VERSION)
        {
            TR_WARN(("Unexpected NIC NicInfo version 0x%lx returned.\n",
                    pIoctlNicInfo->Info.Hdr.Version));
            break;
        }

        NtStatus = NDIS_STATUS_SUCCESS;

    } while (FALSE);

    return NtStatus;
}





NTSTATUS
arpIoctlGetEuidNodeMacInfo(
        PARP1394_INTERFACE          pIF,
        PARP1394_IOCTL_EUID_NODE_MAC_INFO   pEuidInfo,
        PRM_STACK_RECORD            pSR
        )
{
    ENTER("IoctlGetNicInfo", 0x34db9cf4)
    NTSTATUS            NtStatus = STATUS_UNSUCCESSFUL;
    ARP_NDIS_REQUEST    ArpNdisRequest;
    PARP1394_ADAPTER    pAdapter;

    pAdapter =  (ARP1394_ADAPTER*) RM_PARENT_OBJECT(pIF);

    do
    {
        NDIS_STATUS Status;


        //
        // Copy over all the fields.
        //

        Status =  arpPrepareAndSendNdisRequest(
                    pAdapter,
                    &ArpNdisRequest,
                    NULL,                   // pTask (NULL==BLOCK)
                    0,                      // unused
                    OID_1394_QUERY_EUID_NODE_MAP,
                    &pEuidInfo->Map,
                    sizeof(pEuidInfo->Map),
                    NdisRequestQueryInformation,
                    pSR
                    );

        if (FAIL(Status))
        {
            TR_WARN(("NdisRequest failed with error 0x%08lx.\n", Status));
            break;
        }

        NtStatus = NDIS_STATUS_SUCCESS;

    } while (FALSE);

    return NtStatus;
}