/* * FreeRTOS+TCP * Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of * the Software, and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * * http://aws.amazon.com/freertos * http://www.FreeRTOS.org */ /** * @file FreeRTOS_IPv4.c * @brief Implements the basic functionality for the FreeRTOS+TCP network stack. */ /* Standard includes. */ #include #include #include /* FreeRTOS includes. */ #include "FreeRTOS.h" /* FreeRTOS+TCP includes. */ #include "FreeRTOS_IP.h" #include "FreeRTOS_IPv4.h" /* IPv4 multi-cast addresses range from 224.0.0.0.0 to 240.0.0.0. */ #define ipFIRST_MULTI_CAST_IPv4 0xE0000000U /**< Lower bound of the IPv4 multicast address. */ #define ipLAST_MULTI_CAST_IPv4 0xF0000000U /**< Higher bound of the IPv4 multicast address. */ /* Just make sure the contents doesn't get compiled if IPv4 is not enabled. */ /* *INDENT-OFF* */ #if( ipconfigUSE_IPv4 != 0 ) /* *INDENT-ON* */ #if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) /* Check IPv4 packet length. */ static BaseType_t xCheckIPv4SizeFields( const void * const pvEthernetBuffer, size_t uxBufferLength ); #endif /* ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) */ #if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) /** * @brief Check IPv4 packet length. * * @param[in] pvEthernetBuffer The Ethernet packet received. * @param[in] uxBufferLength The total number of bytes received. * * @return pdPASS when the length fields in the packet OK, pdFAIL when the packet * should be dropped. */ static BaseType_t xCheckIPv4SizeFields( const void * const pvEthernetBuffer, size_t uxBufferLength ) { size_t uxLength; UBaseType_t uxIPHeaderLength; uint8_t ucProtocol; uint16_t usLength; uint16_t ucVersionHeaderLength; size_t uxMinimumLength; BaseType_t xResult = pdFAIL; /* Map the buffer onto a IP-Packet struct to easily access the * fields of the IP packet. */ const IPPacket_t * const pxIPPacket = ( ( const IPPacket_t * ) pvEthernetBuffer ); DEBUG_DECLARE_TRACE_VARIABLE( BaseType_t, xLocation, 0 ); do { /* Check for minimum packet size: Ethernet header and an IP-header, 34 bytes */ if( uxBufferLength < sizeof( IPPacket_t ) ) { DEBUG_SET_TRACE_VARIABLE( xLocation, 1 ); break; } ucVersionHeaderLength = pxIPPacket->xIPHeader.ucVersionHeaderLength; /* Test if the length of the IP-header is between 20 and 60 bytes, * and if the IP-version is 4. */ if( ( ucVersionHeaderLength < ipIPV4_VERSION_HEADER_LENGTH_MIN ) || ( ucVersionHeaderLength > ipIPV4_VERSION_HEADER_LENGTH_MAX ) ) { DEBUG_SET_TRACE_VARIABLE( xLocation, 2 ); break; } ucVersionHeaderLength = ( uint16_t ) ( ( ucVersionHeaderLength & ( uint8_t ) 0x0FU ) << 2U ); uxIPHeaderLength = ( UBaseType_t ) ucVersionHeaderLength; /* Check if the complete IP-header is transferred. */ if( uxBufferLength < ( ipSIZE_OF_ETH_HEADER + uxIPHeaderLength ) ) { DEBUG_SET_TRACE_VARIABLE( xLocation, 3 ); break; } /* Check if the complete IP-header plus protocol data have been transferred: */ usLength = pxIPPacket->xIPHeader.usLength; usLength = FreeRTOS_ntohs( usLength ); if( uxBufferLength < ( size_t ) ( ipSIZE_OF_ETH_HEADER + ( size_t ) usLength ) ) { DEBUG_SET_TRACE_VARIABLE( xLocation, 4 ); break; } /* Identify the next protocol. */ ucProtocol = pxIPPacket->xIPHeader.ucProtocol; /* Switch on the Layer 3/4 protocol. */ if( ucProtocol == ( uint8_t ) ipPROTOCOL_UDP ) { /* Expect at least a complete UDP header. */ uxMinimumLength = uxIPHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_UDP_HEADER; } else if( ucProtocol == ( uint8_t ) ipPROTOCOL_TCP ) { uxMinimumLength = uxIPHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_TCP_HEADER; } else if( ( ucProtocol == ( uint8_t ) ipPROTOCOL_ICMP ) || ( ucProtocol == ( uint8_t ) ipPROTOCOL_IGMP ) ) { uxMinimumLength = uxIPHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_ICMPv4_HEADER; } else { /* Unhandled protocol, other than ICMP, IGMP, UDP, or TCP. */ DEBUG_SET_TRACE_VARIABLE( xLocation, 5 ); break; } if( uxBufferLength < uxMinimumLength ) { DEBUG_SET_TRACE_VARIABLE( xLocation, 6 ); break; } uxLength = ( size_t ) usLength; uxLength -= ( ( uint16_t ) uxIPHeaderLength ); /* normally, minus 20. */ if( ( uxLength < ( ( size_t ) sizeof( UDPHeader_t ) ) ) || ( uxLength > ( ( size_t ) ipconfigNETWORK_MTU - ( size_t ) uxIPHeaderLength ) ) ) { /* For incoming packets, the length is out of bound: either * too short or too long. For outgoing packets, there is a * serious problem with the format/length. */ DEBUG_SET_TRACE_VARIABLE( xLocation, 7 ); break; } xResult = pdPASS; } while( ipFALSE_BOOL ); if( xResult != pdPASS ) { /* NOP if ipconfigHAS_PRINTF != 1 */ FreeRTOS_printf( ( "xCheckIPv4SizeFields: location %ld\n", xLocation ) ); } return xResult; } #endif /* ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) */ /*-----------------------------------------------------------*/ /** * @brief Is the IP address an IPv4 multicast address. * * @param[in] ulIPAddress The IP address being checked. * * @return pdTRUE if the IP address is a multicast address or else, pdFALSE. */ BaseType_t xIsIPv4Multicast( uint32_t ulIPAddress ) { BaseType_t xReturn; uint32_t ulIP = FreeRTOS_ntohl( ulIPAddress ); if( ( ulIP >= ipFIRST_MULTI_CAST_IPv4 ) && ( ulIP < ipLAST_MULTI_CAST_IPv4 ) ) { xReturn = pdTRUE; } else { xReturn = pdFALSE; } return xReturn; } /*-----------------------------------------------------------*/ /** * @brief Checks if the IP address matches the global 255.255.255.255 broadcast address or * the broadcast address for any of our IPv4 endpoints. * * @param[in] ulIPAddress The IP address being checked. * * @param[out] ppxEndPoint Pointer to an end-point where we store the endpoint whose broadcast address we matched. Or NULL if no IPv4 endpoints were found. * * @return pdTRUE if the IP address is a broadcast address or else, pdFALSE. */ BaseType_t xIsIPv4Broadcast( uint32_t ulIPAddress, struct xNetworkEndPoint ** ppxEndPoint ) { BaseType_t xIsBroadcast; NetworkEndPoint_t * pxEndPoint; /* Assign a default answer based on the "global" broadcast. This way * we can still return the correct result even if there are no endpoints. */ xIsBroadcast = ( ulIPAddress == FREERTOS_INADDR_BROADCAST ) ? pdTRUE : pdFALSE; for( pxEndPoint = FreeRTOS_FirstEndPoint( NULL ); pxEndPoint != NULL; pxEndPoint = FreeRTOS_NextEndPoint( NULL, pxEndPoint ) ) { #if ( ipconfigUSE_IPv6 == ipconfigENABLE ) /* Skip over any IPv6 endpoints. */ if( pxEndPoint->bits.bIPv6 == ipTRUE_BOOL ) { continue; } #endif /* ( ipconfigUSE_IPv6 == ipconfigENABLE ) */ /* If we already know if ulIPAddress is a broadcast, * simply return this first matching IPv4 endpoint. */ if( xIsBroadcast == pdTRUE ) { break; } else if( ulIPAddress == pxEndPoint->ipv4_settings.ulBroadcastAddress ) { xIsBroadcast = pdTRUE; break; } else { /* do nothing, coverity happy */ } } /* If the caller wants to know the corresponding endpoint, copy the result. * Note that this may be null if ulIPAddress is 255.255.255.255 AND there are * no IPv4 endpoints. * Also, when ulIPAddress is 255.255.255.255, we will * return the first IPv4 endpoint that we run across. */ if( ( xIsBroadcast == pdTRUE ) && ( ppxEndPoint != NULL ) ) { *ppxEndPoint = pxEndPoint; } return xIsBroadcast; } /*-----------------------------------------------------------*/ /** * @brief Check if the packet is an illegal loopback packet. * * @param[in] pxIPHeader The IP-header being checked. * * @return Returns pdTRUE if the packet should be stopped, because either the source * or the target address is a loopback address. */ BaseType_t xBadIPv4Loopback( const IPHeader_t * const pxIPHeader ) { BaseType_t xReturn = pdFALSE; BaseType_t x1 = ( xIsIPv4Loopback( pxIPHeader->ulDestinationIPAddress ) != 0 ) ? pdTRUE : pdFALSE; BaseType_t x2 = ( xIsIPv4Loopback( pxIPHeader->ulSourceIPAddress ) != 0 ) ? pdTRUE : pdFALSE; if( x1 != x2 ) { /* Either the source or the destination address is an IPv4 loopback address. */ xReturn = pdTRUE; } return xReturn; } /*-----------------------------------------------------------*/ /** * @brief Is the IP address an IPv4 loopback address. * * @param[in] ulAddress The IP address being checked. * * @return pdTRUE if the IP address is a loopback address or else, pdFALSE. */ BaseType_t xIsIPv4Loopback( uint32_t ulAddress ) { BaseType_t xReturn = pdFALSE; uint32_t ulIP = FreeRTOS_ntohl( ulAddress ); if( ( ulIP >= ipFIRST_LOOPBACK_IPv4 ) && ( ulIP < ipLAST_LOOPBACK_IPv4 ) ) { xReturn = pdTRUE; } return xReturn; } /*-----------------------------------------------------------*/ /** * @brief Check whether this IPv4 packet is to be allowed or to be dropped. * * @param[in] pxIPPacket The IP packet under consideration. * @param[in] pxNetworkBuffer The whole network buffer. * @param[in] uxHeaderLength The length of the header. * * @return Whether the packet should be processed or dropped. */ enum eFrameProcessingResult prvAllowIPPacketIPv4( const struct xIP_PACKET * const pxIPPacket, const struct xNETWORK_BUFFER * const pxNetworkBuffer, UBaseType_t uxHeaderLength ) { eFrameProcessingResult_t eReturn = eProcessBuffer; #if ( ( ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 ) || ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 ) ) const IPHeader_t * pxIPHeader = &( pxIPPacket->xIPHeader ); #else /* or else, the parameter won't be used and the function will be optimised * away */ ( void ) pxIPPacket; #endif #if ( ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 ) { /* In systems with a very small amount of RAM, it might be advantageous * to have incoming messages checked earlier, by the network card driver. * This method may decrease the usage of scarce network buffers. */ uint32_t ulDestinationIPAddress = pxIPHeader->ulDestinationIPAddress; uint32_t ulSourceIPAddress = pxIPHeader->ulSourceIPAddress; /* Get a reference to the endpoint that the packet was assigned to during pxEasyFit() */ const NetworkEndPoint_t * pxEndPoint = pxNetworkBuffer->pxEndPoint; /* Ensure that the incoming packet is not fragmented because the stack * doesn't not support IP fragmentation. All but the last fragment coming in will have their * "more fragments" flag set and the last fragment will have a non-zero offset. * We need to drop the packet in either of those cases. */ if( ( ( pxIPHeader->usFragmentOffset & ipFRAGMENT_OFFSET_BIT_MASK ) != 0U ) || ( ( pxIPHeader->usFragmentOffset & ipFRAGMENT_FLAGS_MORE_FRAGMENTS ) != 0U ) ) { /* Can not handle, fragmented packet. */ eReturn = eReleaseBuffer; } /* Test if the length of the IP-header is between 20 and 60 bytes, * and if the IP-version is 4. */ else if( ( pxIPHeader->ucVersionHeaderLength < ipIPV4_VERSION_HEADER_LENGTH_MIN ) || ( pxIPHeader->ucVersionHeaderLength > ipIPV4_VERSION_HEADER_LENGTH_MAX ) ) { /* Can not handle, unknown or invalid header version. */ eReturn = eReleaseBuffer; } else if( ( xIsIPv4Loopback( ulDestinationIPAddress ) == pdTRUE ) || ( xIsIPv4Loopback( ulSourceIPAddress ) == pdTRUE ) ) { /* source OR destination is a loopback address. Make sure they BOTH are. */ if( xBadIPv4Loopback( &( pxIPPacket->xIPHeader ) ) == pdTRUE ) { /* The local loopback addresses must never appear outside a host. See RFC 1122 * section 3.2.1.3. */ eReturn = eReleaseBuffer; } } else if( memcmp( xBroadcastMACAddress.ucBytes, pxIPPacket->xEthernetHeader.xSourceAddress.ucBytes, sizeof( MACAddress_t ) ) == 0 ) { /* Ethernet source is a broadcast address. Drop the packet. */ eReturn = eReleaseBuffer; } else if( xIsIPv4Multicast( ulSourceIPAddress ) == pdTRUE ) { /* Source is a multicast IP address. Drop the packet in conformity with RFC 1112 section 7.2. */ eReturn = eReleaseBuffer; } /* Use ipv4_settings for filtering only after the endpoint is up, * so that DHCP packets that are exchanged for DHCP (example, DHCP unicast offers) * are not dropped/filtered. */ else if( FreeRTOS_IsEndPointUp( pxEndPoint ) != pdFALSE ) { if( /* Not destined for the assigned endpoint IPv4 address? */ ( ulDestinationIPAddress != pxEndPoint->ipv4_settings.ulIPAddress ) && /* Also not an IPv4 broadcast address ? */ ( ulDestinationIPAddress != pxEndPoint->ipv4_settings.ulBroadcastAddress ) && ( ulDestinationIPAddress != FREERTOS_INADDR_BROADCAST ) && /* And not an IPv4 multicast address ? */ ( xIsIPv4Multicast( ulDestinationIPAddress ) == pdFALSE ) ) { /* Packet is not for this node, release it */ eReturn = eReleaseBuffer; } /* Is the source address correct? */ else if( ( ulSourceIPAddress == pxEndPoint->ipv4_settings.ulBroadcastAddress ) || ( ulSourceIPAddress == FREERTOS_INADDR_BROADCAST ) ) { /* The source address cannot be broadcast address. Replying to this * packet may cause network storms. Drop the packet. */ eReturn = eReleaseBuffer; } else if( ( memcmp( xBroadcastMACAddress.ucBytes, pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, sizeof( MACAddress_t ) ) == 0 ) && ( ulDestinationIPAddress != pxEndPoint->ipv4_settings.ulBroadcastAddress ) && ( ulDestinationIPAddress != FREERTOS_INADDR_BROADCAST ) ) { /* Ethernet address is a broadcast address, but the IP address is not a * broadcast address. */ eReturn = eReleaseBuffer; } else { /* Packet is not fragmented, destination is this device, source IP and MAC * addresses are correct. */ } } else { /* Endpoint is down */ /* Check if the destination MAC address is a broadcast MAC address. */ if( memcmp( xBroadcastMACAddress.ucBytes, pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, sizeof( MACAddress_t ) ) == 0 ) { if( ulDestinationIPAddress != FREERTOS_INADDR_BROADCAST ) { /* Ethernet address is a broadcast address, but the IP address is not a * broadcast address. */ eReturn = eReleaseBuffer; } else { /* Accept valid broadcast packet. */ } } /* RFC 2131: https://datatracker.ietf.org/doc/html/rfc2131#autoid-8 * The TCP/IP software SHOULD accept and * forward to the IP layer any IP packets delivered to the client's * hardware address before the IP address is configured; DHCP servers * and BOOTP relay agents may not be able to deliver DHCP messages to * clients that cannot accept hardware unicast datagrams before the * TCP/IP software is configured. */ else if( ( memcmp( pxEndPoint->xMACAddress.ucBytes, pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, sizeof( MACAddress_t ) ) != 0 ) ) { /* The endpoint is not up, and the destination MAC address of the * packet is not matching the endpoint's MAC address nor broadcast * MAC address. Drop the packet. */ eReturn = eReleaseBuffer; } else { /* Endpoint is down, but the hardware address matches. Accept the * packet as per RFC 2131 */ } } } #endif /* ipconfigETHERNET_DRIVER_FILTERS_PACKETS */ #if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 ) { /* Some drivers of NIC's with checksum-offloading will enable the above * define, so that the checksum won't be checked again here */ if( eReturn == eProcessBuffer ) { /* Is the IP header checksum correct? * * NOTE: When the checksum of IP header is calculated while not omitting * the checksum field, the resulting value of the checksum always is 0xffff * which is denoted by ipCORRECT_CRC. See this wiki for more information: * https://en.wikipedia.org/wiki/IPv4_header_checksum#Verifying_the_IPv4_header_checksum * and this RFC: https://tools.ietf.org/html/rfc1624#page-4 */ if( usGenerateChecksum( 0U, ( const uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ( size_t ) uxHeaderLength ) != ipCORRECT_CRC ) { /* Check sum in IP-header not correct. */ eReturn = eReleaseBuffer; } /* Is the upper-layer checksum (TCP/UDP/ICMP) correct? */ else if( usGenerateProtocolChecksum( ( uint8_t * ) ( pxNetworkBuffer->pucEthernetBuffer ), pxNetworkBuffer->xDataLength, pdFALSE ) != ipCORRECT_CRC ) { /* Protocol checksum not accepted. */ eReturn = eReleaseBuffer; } else { /* The checksum of the received packet is OK. */ } } } #else /* if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 ) */ { if( eReturn == eProcessBuffer ) { if( xCheckIPv4SizeFields( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength ) != pdPASS ) { /* Some of the length checks were not successful. */ eReturn = eReleaseBuffer; } } #if ( ipconfigUDP_PASS_ZERO_CHECKSUM_PACKETS == 0 ) { /* Check if this is a UDP packet without a checksum. */ if( eReturn == eProcessBuffer ) { uint8_t ucProtocol; const ProtocolHeaders_t * pxProtocolHeaders; /* ipconfigUDP_PASS_ZERO_CHECKSUM_PACKETS is defined as 0, * and so UDP packets carrying a protocol checksum of 0, will * be dropped. */ ucProtocol = pxIPPacket->xIPHeader.ucProtocol; /* MISRA Ref 11.3.1 [Misaligned access] */ /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */ /* coverity[misra_c_2012_rule_11_3_violation] */ pxProtocolHeaders = ( ( ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ( size_t ) ipSIZE_OF_IPv4_HEADER ] ) ); /* Identify the next protocol. */ if( ucProtocol == ( uint8_t ) ipPROTOCOL_UDP ) { if( pxProtocolHeaders->xUDPHeader.usChecksum == ( uint16_t ) 0U ) { #if ( ipconfigHAS_PRINTF != 0 ) { static BaseType_t xCount = 0; /* Exclude this from branch coverage as this is only used for debugging. */ if( xCount < 5 ) /* LCOV_EXCL_BR_LINE */ { FreeRTOS_printf( ( "prvAllowIPPacket: UDP packet from %lxip without CRC dropped\n", ( unsigned long ) FreeRTOS_ntohl( pxIPPacket->xIPHeader.ulSourceIPAddress ) ) ); xCount++; } } #endif /* ( ipconfigHAS_PRINTF != 0 ) */ /* Protocol checksum not accepted. */ eReturn = eReleaseBuffer; } } } } #endif /* ( ipconfigUDP_PASS_ZERO_CHECKSUM_PACKETS == 0 ) */ /* to avoid warning unused parameters */ ( void ) pxNetworkBuffer; ( void ) uxHeaderLength; } #endif /* ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 */ return eReturn; } /*-----------------------------------------------------------*/ /** @brief Check if the IP-header is carrying options. * @param[in] pxNetworkBuffer the network buffer that contains the packet. * * @return Either 'eProcessBuffer' or 'eReleaseBuffer' */ enum eFrameProcessingResult prvCheckIP4HeaderOptions( struct xNETWORK_BUFFER * const pxNetworkBuffer ) { eFrameProcessingResult_t eReturn = eProcessBuffer; /* This function is only called for IPv4 packets, with an IP-header * which is larger than 20 bytes. The extra space is used for IP-options. * The options will either be removed, or the packet shall be dropped, * depending on a user define. */ #if ( ipconfigIP_PASS_PACKETS_WITH_IP_OPTIONS != 0 ) { /* MISRA Ref 11.3.1 [Misaligned access] */ /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */ /* coverity[misra_c_2012_rule_11_3_violation] */ IPHeader_t * pxIPHeader = ( ( IPHeader_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER ] ) ); /* All structs of headers expect a IP header size of 20 bytes * IP header options were included, we'll ignore them and cut them out. */ size_t uxLength = ( size_t ) pxIPHeader->ucVersionHeaderLength; /* Check if the IP headers are acceptable and if it has our destination. * The lowest four bits of 'ucVersionHeaderLength' indicate the IP-header * length in multiples of 4. */ size_t uxHeaderLength = ( size_t ) ( ( uxLength & 0x0FU ) << 2 ); /* Number of bytes contained in IPv4 header options. */ const size_t optlen = ( ( size_t ) uxHeaderLength ) - ipSIZE_OF_IPv4_HEADER; /* From: the previous start of UDP/ICMP/TCP data. */ const uint8_t * pucSource = ( const uint8_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ sizeof( EthernetHeader_t ) + uxHeaderLength ] ); /* To: the usual start of UDP/ICMP/TCP data at offset 20 (decimal ) from IP header. */ uint8_t * pucTarget = ( uint8_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ sizeof( EthernetHeader_t ) + ipSIZE_OF_IPv4_HEADER ] ); /* How many: total length minus the options and the lower headers. */ const size_t xMoveLen = pxNetworkBuffer->xDataLength - ( optlen + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_ETH_HEADER ); ( void ) memmove( pucTarget, pucSource, xMoveLen ); pxNetworkBuffer->xDataLength -= optlen; /* Update the total length of the IP packet after removing options. */ pxIPHeader->usLength = FreeRTOS_htons( FreeRTOS_ntohs( pxIPHeader->usLength ) - optlen ); /* Rewrite the Version/IHL byte to indicate that this packet has no IP options. */ pxIPHeader->ucVersionHeaderLength = ( uint8_t ) ( ( pxIPHeader->ucVersionHeaderLength & 0xF0U ) | /* High nibble is the version. */ ( ( ipSIZE_OF_IPv4_HEADER >> 2 ) & 0x0FU ) ); } #else /* if ( ipconfigIP_PASS_PACKETS_WITH_IP_OPTIONS != 0 ) */ { /* 'ipconfigIP_PASS_PACKETS_WITH_IP_OPTIONS' is not set, so packets carrying * IP-options will be dropped. */ eReturn = eReleaseBuffer; } #endif /* if ( ipconfigIP_PASS_PACKETS_WITH_IP_OPTIONS != 0 ) */ return eReturn; } /*-----------------------------------------------------------*/ /* *INDENT-OFF* */ #endif /* ipconfigUSE_IPv4 != 0 ) */ /* *INDENT-ON* */