/*++ Copyright (c) 1998-1999 Microsoft Corporation Module Name: arp.c Abstract: ARP1394 ARP request/response handling code. Revision History: Who When What -------- -------- ---------------------------------------------- josephj 03-28-99 Created Notes: --*/ #include // // File-specific debugging defaults. // #define TM_CURRENT TM_ARP // #define ARP_DEFAULT_MAXREC 0xD #define ARP_DEFAULT_MAXREC 0x8 #define LOGSTATS_SuccessfulArpQueries(_pIF) \ NdisInterlockedIncrement(&((_pIF)->stats.arpcache.SuccessfulQueries)) #define LOGSTATS_FailedArpQueried(_pIF) \ NdisInterlockedIncrement(&((_pIF)->stats.arpcache.FailedQueries)) #define LOGSTATS_TotalQueries(_pIF) \ NdisInterlockedIncrement(&((_pIF)->stats.arpcache.TotalQueries)) #define LOGSTATS_TotalArpResponses(_pIF) \ NdisInterlockedIncrement(&((_pIF)->stats.arpcache.TotalResponses)) //========================================================================= // L O C A L P R O T O T Y P E S //========================================================================= NDIS_STATUS arpSendArpRequest( PARPCB_REMOTE_IP pRemoteIp, PRM_STACK_RECORD pSR ); VOID arpProcessArpRequest( PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT PIP1394_ARP_PKT_INFO pPktInfo, PRM_STACK_RECORD pSR ); VOID arpProcessArpResponse( PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT PIP1394_ARP_PKT_INFO pPktInfo, PRM_STACK_RECORD pSR ); VOID arpTryAbortResolutionTask( PARPCB_REMOTE_IP pRemoteIp, PRM_STACK_RECORD pSR ); NDIS_STATUS arpParseArpPkt( IN PIP1394_ARP_PKT pArpPkt, IN UINT cbBufferSize, OUT PIP1394_ARP_PKT_INFO pPktInfo ) /*++ Routine Description: Parse the contents of IP/1394 ARP packet data starting at pArpPkt. Place the results into pPktInfo. Arguments: pArpPkt - Contains the unaligned contents of an ip/1394 ARP Pkt. pPktInfo - Unitialized structure to be filled with the parsed contents of the pkt. Return Value: NDIS_STATUS_FAILURE if the parse failed (typically because of invalid pkt contents.) NDIS_STATUS_SUCCESS on successful parsing. --*/ { ENTER("arpParseArpPkt", 0x20098dc0) NDIS_STATUS Status; DBGSTMT(CHAR *szError = "General failure";) Status = NDIS_STATUS_FAILURE; do { UINT SenderMaxRec; UINT OpCode; // Verify length. // if (cbBufferSize < sizeof(*pArpPkt)) { DBGSTMT(szError = "pkt size too small";) break; } // Verify constant fields. // #if 0 // Reserved is no "NodeId, which contains the nodeid of the sending // node, if known (0 otherwise). if (pArpPkt->header.Reserved != 0) { DBGSTMT(szError = "header.Reserved!=0";) break; } #endif // 0 if (N2H_USHORT(pArpPkt->header.EtherType) != NIC1394_ETHERTYPE_ARP) { DBGSTMT(szError = "header.EtherType!=ARP";) break; } if (N2H_USHORT(pArpPkt->hardware_type) != IP1394_HARDWARE_TYPE) { DBGSTMT(szError = "Invalid hardware_type";) break; } if (N2H_USHORT(pArpPkt->protocol_type) != IP1394_PROTOCOL_TYPE) { DBGSTMT(szError = "Invalid protocol_type";) break; } if (pArpPkt->hw_addr_len != IP1394_HW_ADDR_LEN) { DBGSTMT(szError = "Invalid hw_addr_len";) break; } if (pArpPkt->IP_addr_len != sizeof(ULONG)) { DBGSTMT(szError = "Invalid IP_addr_len";) break; } // Opcode // { OpCode = N2H_USHORT(pArpPkt->opcode); if ( OpCode != IP1394_ARP_REQUEST && OpCode != IP1394_ARP_RESPONSE) { DBGSTMT(szError = "Invalid opcode";) break; } } // Max send block size... // { UINT maxrec = pArpPkt->sender_maxrec; if (IP1394_IS_VALID_MAXREC(maxrec)) { SenderMaxRec = maxrec; } else { DBGSTMT(szError = "Invalid sender_maxrec";) break; } } // // Pkt appears valid, let's fill out the parsed information.... // ARP_ZEROSTRUCT(pPktInfo); pPktInfo->OpCode = OpCode; pPktInfo->SenderMaxRec = SenderMaxRec; // Speed code... // { UINT SenderMaxSpeedCode; // // We rely on the fact that the RFC speed code constants // (IP1394_SSPD_*) are identical to the corresponding // constants defined in 1394.h (SCODE_*). Let's ensure this... // #if (IP1394_SSPD_S100 != SCODE_100_RATE) #error "RFC Speed code out of sync with 1394.h" #endif #if (IP1394_SSPD_S200 != SCODE_200_RATE) #error "RFC Speed code out of sync with 1394.h" #endif #if (IP1394_SSPD_S400 != SCODE_400_RATE) #error "RFC Speed code out of sync with 1394.h" #endif #if (IP1394_SSPD_S800 != SCODE_800_RATE) #error "RFC Speed code out of sync with 1394.h" #endif #if (IP1394_SSPD_S1600 != SCODE_1600_RATE) #error "RFC Speed code out of sync with 1394.h" #endif #if (IP1394_SSPD_S3200 != SCODE_3200_RATE) #error "RFC Speed code out of sync with 1394.h" #endif SenderMaxSpeedCode = pArpPkt->sspd; if (SenderMaxSpeedCode > SCODE_3200_RATE) { // // This is either a bad value, or a rate higher than we know about. // We can't distinguish between the two, so we just set the speed to // the highest we know about. // TODO: 3/28/99 JosephJ not sure if this is the correct // behaviour -- maybe we should fail -- I'll be asking the // working group to rule on this shortly... // SenderMaxSpeedCode = SCODE_3200_RATE; } pPktInfo->SenderMaxSpeedCode = SenderMaxSpeedCode; } // Unique ID -- we also need to swap DWORDS to convert from network byte // order. // { PUINT puSrc = (PUINT) & (pArpPkt->sender_unique_ID); PUINT puDest = (PUINT) & (pPktInfo->SenderHwAddr.UniqueID); // pPktInfo->SenderHwAddr.UniqueID = pArpPkt->sender_unique_ID; puDest[0] = puSrc[1]; puDest[1] = puSrc[0]; } pPktInfo->SenderHwAddr.Off_Low =H2N_ULONG(pArpPkt->sender_unicast_FIFO_lo); pPktInfo->SenderHwAddr.Off_High =H2N_USHORT(pArpPkt->sender_unicast_FIFO_hi); // These remain network byte order... // pPktInfo->SenderIpAddress = (IP_ADDRESS) pArpPkt->sender_IP_address; pPktInfo->TargetIpAddress = (IP_ADDRESS) pArpPkt->target_IP_address; // Extract the Src Node Address // { PNDIS1394_UNFRAGMENTED_HEADER pHeader = (PNDIS1394_UNFRAGMENTED_HEADER)&pArpPkt->header; if (pHeader->u1.fHeaderHasSourceAddress == TRUE) { pPktInfo->SourceNodeAdddress = pHeader->u1.SourceAddress; pPktInfo->fPktHasNodeAddress = TRUE; } } Status = NDIS_STATUS_SUCCESS; } while (FALSE); if (FAIL(Status)) { TR_INFO(("Bad arp pkt data at 0x%p (%s)\n", pArpPkt, szError)); } else { TR_WARN(("Received ARP PKT. UID=0x%I64x FIFO=0x%04lx:0x%08lx OP=%lu SIP=0x%04lx TIP=0x%04lx.\n", pPktInfo->SenderHwAddr.UniqueID, pPktInfo->SenderHwAddr.Off_High, pPktInfo->SenderHwAddr.Off_Low, pPktInfo->OpCode, pPktInfo->SenderIpAddress, pPktInfo->TargetIpAddress )); } EXIT() return Status; } VOID arpPrepareArpPkt( IN PIP1394_ARP_PKT_INFO pPktInfo, // IN UINT SenderMaxRec, OUT PIP1394_ARP_PKT pArpPkt ) /*++ Routine Description: Use information in pArpPktInfo to prepare an arp packet starting at pvArpPkt. Arguments: pPktInfo - Parsed version of the arp request/response packet. // SenderMaxRec - max_rec value of the local host pArpPkt - unitialized memory in which to store the packet contents. This memory must have a min size of sizeof(*pArpPkt). --*/ { // UINT SenderMaxRec; UINT OpCode; ARP_ZEROSTRUCT(pArpPkt); pArpPkt->header.EtherType = H2N_USHORT(NIC1394_ETHERTYPE_ARP); pArpPkt->hardware_type = H2N_USHORT(IP1394_HARDWARE_TYPE); pArpPkt->protocol_type = H2N_USHORT(IP1394_PROTOCOL_TYPE); pArpPkt->hw_addr_len = (UCHAR) IP1394_HW_ADDR_LEN; pArpPkt->IP_addr_len = (UCHAR) sizeof(ULONG); pArpPkt->opcode = H2N_USHORT(pPktInfo->OpCode); pArpPkt->sender_maxrec = (UCHAR) pPktInfo->SenderMaxRec; // // We rely on the fact that the RFC speed code constants // (IP1394_SSPD_*) are identical to the corresponding // constants defined in 1394.h (SCODE_*). We have a bunch of compiler-time // checks to ensure this (see arpParseArpPkt(...)). // pArpPkt->sspd = (UCHAR) pPktInfo->SenderMaxSpeedCode; // Unique ID -- we also need to swap DWORDS to convert to network byte order. // { PUINT puSrc = (PUINT) & (pPktInfo->SenderHwAddr.UniqueID); PUINT puDest = (PUINT) & (pArpPkt->sender_unique_ID); // pArpPkt->sender_unique_ID = pPktInfo->SenderHwAddr.UniqueID; puDest[0] = puSrc[1]; puDest[1] = puSrc[0]; } pArpPkt->sender_unicast_FIFO_lo = N2H_ULONG(pPktInfo->SenderHwAddr.Off_Low); pArpPkt->sender_unicast_FIFO_hi = N2H_USHORT(pPktInfo->SenderHwAddr.Off_High); // These are already in network byte order... // pArpPkt->sender_IP_address = (ULONG) pPktInfo->SenderIpAddress; pArpPkt->target_IP_address = (ULONG) pPktInfo->TargetIpAddress; } NDIS_STATUS arpPrepareArpResponse( IN PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT IN PIP1394_ARP_PKT_INFO pArpRequest, OUT PIP1394_ARP_PKT_INFO pArpResponse, IN PRM_STACK_RECORD pSR ) /*++ Routine Description: If it makes sense to do so, prepare (in pArpResponse) an arp response to the arp request in pArpRequest. Arguments: pIF - Interface control block. pArpRequest - Parsed version of the ARP request packet. pArpResponse - Uninitialized memory to hold the parsed version of the ARP response packet (if there is a response). Return Value: NDIS_STATUS_SUCCESS if the response was filled out. Some NDIS error code otherwise. --*/ { ENTER("arpPrepareArpResponse", 0x0d7e0e60) NDIS_STATUS Status; PARPCB_LOCAL_IP pLocalIp; Status = NDIS_STATUS_FAILURE; pLocalIp = NULL; RM_ASSERT_OBJUNLOCKED(&pIF->Hdr, pSR); do { IP_ADDRESS TargetIpAddress = pArpRequest->TargetIpAddress; // Lookup local IP // Status = RM_LOOKUP_AND_LOCK_OBJECT_IN_GROUP( &pIF->LocalIpGroup, (PVOID) ULongToPtr (TargetIpAddress), (RM_OBJECT_HEADER**) &pLocalIp, pSR ); if (FAIL(Status)) { pLocalIp = NULL; break; } Status = NDIS_STATUS_FAILURE; RM_DBG_ASSERT_LOCKED(&pLocalIp->Hdr, pSR); ASSERT(TargetIpAddress == pLocalIp->IpAddress); if (ARP_LOCAL_IP_IS_UNLOADING(pLocalIp)) break; // // If the local IP is non-unicast, don't respond! // if (pLocalIp->IpAddressType != LLIP_ADDR_LOCAL) { TR_WARN(("Ignoring arp request for non-unicast address 0x%08lx.\n", TargetIpAddress)); break; } // // We do serve the target IP address. Let's fill out pArpResponse... // ARP_ZEROSTRUCT(pArpResponse); pArpResponse->OpCode = IP1394_ARP_RESPONSE; pArpResponse->SenderIpAddress = TargetIpAddress; // This field is unused in the response, but we fill it anyway.. // 11/19/1999 From Kaz Honda of Sony: we should fill it with destination // IP address (i.e. the ip address of the sender of the arp request). // because that is analogous to what ethernet arp does. Note that // the ip/1394 rfc says that the field should be ignored, but we do // this anyway. // // pArpResponse->TargetIpAddress = TargetIpAddress; pArpResponse->TargetIpAddress = pArpRequest->SenderIpAddress; // Fill out adapter info.. // { PARP1394_ADAPTER pAdapter = (PARP1394_ADAPTER) RM_PARENT_OBJECT(pIF); pArpResponse->SenderHwAddr.UniqueID = pAdapter->info.LocalUniqueID; pArpResponse->SenderHwAddr.Off_Low = pIF->recvinfo.offset.Off_Low; pArpResponse->SenderHwAddr.Off_High = pIF->recvinfo.offset.Off_High; pArpResponse->SenderMaxRec= pAdapter->info.MaxRec; pArpResponse->SenderMaxSpeedCode= pAdapter->info.MaxSpeedCode; } Status = NDIS_STATUS_SUCCESS; } while (FALSE); if (pLocalIp != NULL) { UNLOCKOBJ(pLocalIp, pSR); RmTmpDereferenceObject(&pLocalIp->Hdr, pSR); } RM_ASSERT_OBJUNLOCKED(&pIF->Hdr, pSR); EXIT() return Status; } NDIS_STATUS arpTaskResolveIpAddress( IN struct _RM_TASK * pTask, IN RM_TASK_OPERATION Code, IN UINT_PTR UserParam, IN PRM_STACK_RECORD pSR ) { NDIS_STATUS Status; PARPCB_REMOTE_IP pRemoteIp; PTASK_RESOLVE_IP_ADDRESS pResolutionTask; enum { PEND_ResponseTimeout }; ENTER("TaskResolveIpAddress", 0x3dd4b434) Status = NDIS_STATUS_FAILURE; pRemoteIp = (PARPCB_REMOTE_IP) RM_PARENT_OBJECT(pTask); pResolutionTask = (PTASK_RESOLVE_IP_ADDRESS) pTask; switch(Code) { case RM_TASKOP_START: { DBGMARK(0x7de307cc); // // There should NOT be another resolution task running // on pRemoteIp. Why? Because a resolution task is ONLY // started in the context of a send-pkts task, and there can be // ONLY one active send-pkts task on pRemoteIp at any one time. // LOCKOBJ(pRemoteIp, pSR); if (pRemoteIp->pResolutionTask != NULL) { ASSERT(!"pRemoteIp->pResolutionTask != NULL"); UNLOCKOBJ(pRemoteIp, pSR); Status = NDIS_STATUS_FAILURE; break; } // // Make ourselves the official resolution task. // // Although it's tempting to put pTask as entity1 and // pTask->Hdr.szDescption as entity2 below, we specify NULL for both so // that we can be sure that ONLY one resolution task can be active at any // one time. TODO: modify addassoc semantics to get both advantages. // DBG_ADDASSOC( &pRemoteIp->Hdr, NULL, // Entity1 NULL, // Entity2 ARPASSOC_RESOLUTION_IF_TASK, " Resolution task\n", pSR ); pRemoteIp->pResolutionTask = pTask; pResolutionTask->RetriesLeft = 3; // Now we do a fake suspend/resume so we move on to the next stage. // RmSuspendTask(pTask, PEND_ResponseTimeout, pSR); UNLOCKOBJ(pRemoteIp, pSR); RmResumeTask(pTask, NDIS_STATUS_SUCCESS, pSR); Status = NDIS_STATUS_PENDING; } break; case RM_TASKOP_PENDCOMPLETE: { switch(RM_PEND_CODE(pTask)) { case PEND_ResponseTimeout: { DBGMARK(0x3b5562e6); LOCKOBJ(pRemoteIp, pSR); // // Let's see if the address is resolved and/or we're // to abort the resolution task because perhaps pRemoteIp // is going away. // if (pRemoteIp->pUnloadTask != NULL) { OBJLOG0( pRemoteIp, "Aborting address resolution because we're unloading.\n" ); Status = NDIS_STATUS_FAILURE; UNLOCKOBJ(pRemoteIp, pSR); break; } if (pRemoteIp->pDest != NULL) { LOGSTATS_SuccessfulArpQueries(IF_FROM_REMOTEIP(pRemoteIp)); OBJLOG1( pRemoteIp, "Resolved Ip Address; pDest = 0x%p\n", pRemoteIp->pDest ); ASSERT( CHECK_REMOTEIP_RESOLVE_STATE(pRemoteIp, ARPREMOTEIP_RESOLVED) ); Status = NDIS_STATUS_SUCCESS; UNLOCKOBJ(pRemoteIp, pSR); break; } // // We need to resolve this address.. // if (pResolutionTask->RetriesLeft) { pResolutionTask->RetriesLeft--; // Build an ARP request and send it out. // Status = arpSendArpRequest(pRemoteIp, pSR); // pRemoteIp's lock is released by the above call. // RM_ASSERT_OBJUNLOCKED(&pRemoteIp->Hdr, pSR); // // We ignore the return status of the above call -- so // whether or not the request could be sent out, // we suspend this task for resolution-timeout seconds. // RmSuspendTask(pTask, PEND_ResponseTimeout, pSR); RmResumeTaskDelayed( pTask, 0, ARP1394_ADDRESS_RESOLUTION_TIMEOUT, &pResolutionTask->Timer, pSR ); Status = NDIS_STATUS_PENDING; } else { LOGSTATS_FailedArpQueried(IF_FROM_REMOTEIP(pRemoteIp)); // Oops -- couldn't resolve this address. // OBJLOG1( pRemoteIp, "Timed out trying to resolve address 0x%08lx\n", pRemoteIp->IpAddress ); UNLOCKOBJ(pRemoteIp, pSR); Status = NDIS_STATUS_FAILURE; } } break; } } break; case RM_TASKOP_END: { // // We are done with address resolution. Clear ourselves // as the official address resolution task of pRemoteIp. // LOCKOBJ(pRemoteIp, pSR); DBGMARK(0x6bd6d27a); if (pRemoteIp->pResolutionTask != pTask) { ASSERT(FALSE); } else { // Delete the association added when setting the resolution task // DBG_DELASSOC( &pRemoteIp->Hdr, NULL, NULL, ARPASSOC_RESOLUTION_IF_TASK, pSR ); pRemoteIp->pResolutionTask = NULL; } UNLOCKOBJ(pRemoteIp, pSR); // Propagate the status code // Status = (NDIS_STATUS) UserParam; } break; default: { ASSERTEX(!"Unknown task op", pTask); } break; } // switch (Code) RM_ASSERT_NOLOCKS(pSR); EXIT() return Status; } NDIS_STATUS arpSendArpRequest( PARPCB_REMOTE_IP pRemoteIp, // LOCKIN NOLOCKOUT PRM_STACK_RECORD pSR ) { NDIS_STATUS Status; PARP1394_INTERFACE pIF; PNDIS_PACKET pNdisPacket; PIP1394_ARP_PKT pPktData; IPAddr TargetIpAddress = 0; ENTER("arpSendArpRequest", 0xcecfc632) RM_ASSERT_OBJLOCKED(&pRemoteIp->Hdr, pSR); pIF = (PARP1394_INTERFACE) RM_PARENT_OBJECT(pRemoteIp); DBGMARK(0xb90e9ffc); Status = arpAllocateControlPacket( pIF, sizeof(IP1394_ARP_PKT), ARP1394_PACKET_FLAGS_ARP, &pNdisPacket, &pPktData, pSR ); if (FAIL(Status)) { UNLOCKOBJ(pRemoteIp, pSR); } else { IP1394_ARP_PKT_INFO PktInfo; PARP1394_ADAPTER pAdapter = (PARP1394_ADAPTER) RM_PARENT_OBJECT(pIF); // // If we are running in bridge the Target Ip Address is stored in // the BridgeTargetIpAddress Field. Otherwise it is in the Key. // ASSERT (pRemoteIp->IpAddress != 0); // Prepare the packet. // PktInfo.SenderHwAddr.UniqueID = pAdapter->info.LocalUniqueID; PktInfo.SenderHwAddr.Off_Low = pIF->recvinfo.offset.Off_Low; PktInfo.SenderHwAddr.Off_High = pIF->recvinfo.offset.Off_High; PktInfo.OpCode = IP1394_ARP_REQUEST; PktInfo.SenderMaxRec = pAdapter->info.MaxRec; PktInfo.SenderMaxSpeedCode = pAdapter->info.MaxSpeedCode; PktInfo.TargetIpAddress = pRemoteIp->IpAddress; PktInfo.SenderIpAddress = pIF->ip.DefaultLocalAddress; arpPrepareArpPkt( &PktInfo, // ARP_DEFAULT_MAXREC, // SenderMaxRec TODO pPktData ); RmTmpReferenceObject(&pIF->Hdr, pSR); UNLOCKOBJ(pRemoteIp, pSR); RM_ASSERT_NOLOCKS(pSR); TR_WARN(("Attempting to send ARP Req PKT. UID=0x%I64x FIFO=0x%04lx:0x%08lx OP=%lu SIP=0x%04lx TIP=0x%04lx.\n", PktInfo.SenderHwAddr.UniqueID, PktInfo.SenderHwAddr.Off_High, PktInfo.SenderHwAddr.Off_Low, PktInfo.OpCode, PktInfo.SenderIpAddress, PktInfo.TargetIpAddress )); LOGSTATS_TotalQueries(pIF); 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 ); RM_ASSERT_NOLOCKS(pSR); RmTmpDereferenceObject(&pIF->Hdr, pSR); } EXIT() return Status; } VOID arpSendControlPkt( IN ARP1394_INTERFACE * pIF, // LOCKIN NOLOCKOUT (IF send lk) IN PNDIS_PACKET pNdisPacket, PARPCB_DEST pDest, IN PRM_STACK_RECORD pSR ) /*++ Routine Description: Send a packet on the broadcast channel. Arguments: pIF - Our interface object pNdisPacket - Packet to send --*/ { NDIS_STATUS Status; MYBOOL fRet; ENTER("arpSendControlPkt", 0x2debf9b7) DBGMARK(0xe6823818); // // If we can't send now, we fail. // if (pDest==NULL || !ARP_CAN_SEND_ON_DEST(pDest)) { ARP_FASTUNLOCK_IF_SEND_LOCK(pIF); TR_WARN(("Couldn't send control pkt 0x%p.\n", pNdisPacket)); arpFreeControlPacket( pIF, pNdisPacket, pSR ); return; // EARLY RETURN } arpRefSendPkt( pNdisPacket, pDest); // Release the IF send lock. // ARP_FASTUNLOCK_IF_SEND_LOCK(pIF); // 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 EXIT() } VOID arpProcessArpPkt( PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT PIP1394_ARP_PKT pArpPkt, UINT cbBufferSize ) /*++ Process an arp packet (request OR response) from the 1394 bus. --*/ { NDIS_STATUS Status; IP1394_ARP_PKT_INFO PktInfo; ENTER("arpProcessArpPkt", 0x6e81a8fa) RM_DECLARE_STACK_RECORD(sr) DBGMARK(0x03f6830e); Status = arpParseArpPkt( pArpPkt, cbBufferSize, &PktInfo ); if (!FAIL(Status)) { if (PktInfo.OpCode == IP1394_ARP_REQUEST) { arpProcessArpRequest(pIF, &PktInfo, &sr); } else { ASSERT(PktInfo.OpCode == IP1394_ARP_RESPONSE); arpProcessArpResponse(pIF, &PktInfo, &sr); } } RM_ASSERT_CLEAR(&sr); EXIT() } VOID arpProcessArpRequest( PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT PIP1394_ARP_PKT_INFO pPktInfo, PRM_STACK_RECORD pSR ) { IP1394_ARP_PKT_INFO ResponsePktInfo; NDIS_STATUS Status; ENTER("arpProcessArpRequest", 0xd33fa61d) RM_ASSERT_NOLOCKS(pSR); // pStatsCmd->TotalResponses = pIF->stats.arpcache.TotalResponses; // pStatsCmd->TotalLookups = pIF->stats.arpcache.TotalLookups; Status = arpPrepareArpResponse( pIF, // NOLOCKIN NOLOCKOUT pPktInfo, &ResponsePktInfo, pSR ); if (!FAIL(Status)) { ARP_DEST_PARAMS DestParams; PNDIS_PACKET pNdisPacket; PIP1394_ARP_PKT pPktData; ARP_ZEROSTRUCT(&DestParams); DestParams.HwAddr.AddressType = NIC1394AddressType_FIFO; DestParams.HwAddr.FifoAddress = pPktInfo->SenderHwAddr; // Struct copy // // Update our arp cache with information from the sender's portion of // the arp request. // arpUpdateArpCache( pIF, pPktInfo->SenderIpAddress, // Remote IP Address, NULL, // Sender's Ethernet Address &DestParams, // Remote Destination HW Address TRUE, // If required, create an entry for this., pSR ); // // Let's send the response! // Status = arpAllocateControlPacket( pIF, sizeof(IP1394_ARP_PKT), ARP1394_PACKET_FLAGS_ARP, &pNdisPacket, &pPktData, pSR ); if (!FAIL(Status)) { LOGSTATS_TotalArpResponses(pIF); // Prepare the packet. // arpPrepareArpPkt( &ResponsePktInfo, // ARP_DEFAULT_MAXREC, // SenderMaxRec TODO pPktData ); RM_ASSERT_NOLOCKS(pSR); TR_WARN(("Attempting to send ARP Resp PKT. UID=0x%I64x FIFO=0x%04lx:0x%08lx OP=%lu SIP=0x%04lx TIP=0x%04lx.\n", pPktInfo->SenderHwAddr.UniqueID, pPktInfo->SenderHwAddr.Off_High, pPktInfo->SenderHwAddr.Off_Low, pPktInfo->OpCode, pPktInfo->SenderIpAddress, pPktInfo->TargetIpAddress )); 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 ); } } RM_ASSERT_NOLOCKS(pSR); } VOID arpProcessArpResponse( PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT PIP1394_ARP_PKT_INFO pPktInfo, PRM_STACK_RECORD pSR ) { ARP_DEST_PARAMS DestParams; RM_ASSERT_NOLOCKS(pSR); ARP_ZEROSTRUCT(&DestParams); DestParams.HwAddr.AddressType = NIC1394AddressType_FIFO; DestParams.HwAddr.FifoAddress = pPktInfo->SenderHwAddr; // Struct copy arpUpdateArpCache( pIF, pPktInfo->SenderIpAddress, // Remote IP Address NULL, // Senders Mac Address (Bridge only) &DestParams, // Remote Destination HW Address FALSE, // Don't update unless we already have an entry for it. pSR ); } VOID arpUpdateArpCache( PARP1394_INTERFACE pIF, // NOLOCKIN NOLOCKOUT IP_ADDRESS RemoteIpAddress, ENetAddr *pRemoteEthAddress, PARP_DEST_PARAMS pDestParams, MYBOOL fCreateIfRequired, PRM_STACK_RECORD pSR ) /*++ Update cache and also abort any resolution task that may be going on. --*/ { REMOTE_DEST_KEY RemoteDestKey; PARP1394_ADAPTER pAdapter = (PARP1394_ADAPTER)RM_PARENT_OBJECT(pIF); ENTER("arpUpdateArpCache", 0x3a16a415) LOCKOBJ(pIF, pSR); do { ARPCB_REMOTE_IP *pRemoteIp = NULL; INT fCreated = FALSE; UINT RemoteIpCreateFlags = 0; NDIS_STATUS Status; DBGMARK(0xd3b27d1f); if (fCreateIfRequired) { RemoteIpCreateFlags |= RM_CREATE; } // Create the Key from the passed in parameters // if (ARP_BRIDGE_ENABLED(pAdapter) == TRUE) { ASSERT (pRemoteEthAddress != NULL); RemoteDestKey.ENetAddress = *pRemoteEthAddress; TR_INFO(("Arp1394 - Bridge update cache Mac Address %x %x %x %x %x %x\n", RemoteDestKey.ENetAddress.addr[0], RemoteDestKey.ENetAddress.addr[1], RemoteDestKey.ENetAddress.addr[2], RemoteDestKey.ENetAddress.addr[3], RemoteDestKey.ENetAddress.addr[4], RemoteDestKey.ENetAddress.addr[5])); } else { REMOTE_DEST_KEY_INIT(&RemoteDestKey); RemoteDestKey.IpAddress = RemoteIpAddress; TR_INFO( ("Arp1394 - Non-Bridge update cache Mac Address %x %x %x %x %x %x\n", RemoteDestKey.ENetAddress.addr[0], RemoteDestKey.ENetAddress.addr[1], RemoteDestKey.ENetAddress.addr[2], RemoteDestKey.ENetAddress.addr[3], RemoteDestKey.ENetAddress.addr[4], RemoteDestKey.ENetAddress.addr[5])); } // Lookup/Create Remote IP Address // Status = RmLookupObjectInGroup( &pIF->RemoteIpGroup, RemoteIpCreateFlags, (PVOID) (&RemoteDestKey), (PVOID) (&RemoteDestKey), // pCreateParams (RM_OBJECT_HEADER**) &pRemoteIp, &fCreated, // pfCreated pSR ); if (FAIL(Status)) { OBJLOG1( pIF, "Couldn't add localIp entry with addr 0x%lx\n", RemoteIpAddress ); break; } // // Update the RemoteIp Last time checked here. This will refresh the // Arp Entry for this Remote Ip struct // pRemoteIp->sendinfo.TimeLastChecked = 0; UNLOCKOBJ(pIF, pSR); arpUpdateRemoteIpDest( pIF, pRemoteIp, pDestParams, pSR ); // If there is a resolution task going on for pRemoteIp we abort it. // arpTryAbortResolutionTask(pRemoteIp, pSR); // Finally, remove the tmprefs added in the lookups. // RmTmpDereferenceObject(&pRemoteIp->Hdr, pSR); return; // EARLY RETURN } while (FALSE); UNLOCKOBJ(pIF, pSR); EXIT() } VOID arpTryAbortResolutionTask( PARPCB_REMOTE_IP pRemoteIp, // NOLOCKIN NOLOCKOUT PRM_STACK_RECORD pSR ) { ENTER("arpTryAbortResolutionTask", 0xf34f16f2) PTASK_RESOLVE_IP_ADDRESS pResolutionTask; UINT TaskResumed; RM_ASSERT_NOLOCKS(pSR); LOCKOBJ(pRemoteIp, pSR); pResolutionTask = (PTASK_RESOLVE_IP_ADDRESS) pRemoteIp->pResolutionTask; if (pResolutionTask != NULL) { RmTmpReferenceObject(&pResolutionTask->TskHdr.Hdr, pSR); } UNLOCKOBJ(pRemoteIp, pSR); DBGMARK(0x5b93ad3e); if (pResolutionTask != NULL) { RmResumeDelayedTaskNow( &pResolutionTask->TskHdr, &pResolutionTask->Timer, &TaskResumed, pSR ); RmTmpDereferenceObject(&pResolutionTask->TskHdr.Hdr, pSR); } EXIT() }