git.sur5r.net Git - freertos/blob - FreeRTOS-Plus/Source/FreeRTOS-Plus-TCP/FreeRTOS_UDP_IP.c

   1 /*\r
   2  * FreeRTOS+TCP V2.0.11\r
   3  * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
   4  *\r
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
   6  * this software and associated documentation files (the "Software"), to deal in\r
   7  * the Software without restriction, including without limitation the rights to\r
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
   9  * the Software, and to permit persons to whom the Software is furnished to do so,\r
  10  * subject to the following conditions:\r
  11  *\r
  12  * The above copyright notice and this permission notice shall be included in all\r
  13  * copies or substantial portions of the Software.\r
  14  *\r
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
  17  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
  18  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  21  *\r
  22  * http://aws.amazon.com/freertos\r
  23  * http://www.FreeRTOS.org\r
  24  */\r
  25 \r
  26 /* Standard includes. */\r
  27 #include <stdint.h>\r
  28 #include <stdio.h>\r
  29 \r
  30 /* FreeRTOS includes. */\r
  31 #include "FreeRTOS.h"\r
  32 #include "task.h"\r
  33 #include "queue.h"\r
  34 #include "semphr.h"\r
  35 \r
  36 /* FreeRTOS+TCP includes. */\r
  37 #include "FreeRTOS_IP.h"\r
  38 #include "FreeRTOS_Sockets.h"\r
  39 #include "FreeRTOS_IP_Private.h"\r
  40 #include "FreeRTOS_UDP_IP.h"\r
  41 #include "FreeRTOS_ARP.h"\r
  42 #include "FreeRTOS_DHCP.h"\r
  43 #include "NetworkInterface.h"\r
  44 #include "NetworkBufferManagement.h"\r
  45 \r
  46 #if( ipconfigUSE_DNS == 1 )\r
  47         #include "FreeRTOS_DNS.h"\r
  48 #endif\r
  49 \r
  50 /* The expected IP version and header length coded into the IP header itself. */\r
  51 #define ipIP_VERSION_AND_HEADER_LENGTH_BYTE ( ( uint8_t ) 0x45 )\r
  52 \r
  53 /* Part of the Ethernet and IP headers are always constant when sending an IPv4\r
  54 UDP packet.  This array defines the constant parts, allowing this part of the\r
  55 packet to be filled in using a simple memcpy() instead of individual writes. */\r
  56 UDPPacketHeader_t xDefaultPartUDPPacketHeader =\r
  57 {\r
  58         /* .ucBytes : */\r
  59         {\r
  60                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* Ethernet source MAC address. */\r
  61                 0x08, 0x00,                                                     /* Ethernet frame type. */\r
  62                 ipIP_VERSION_AND_HEADER_LENGTH_BYTE,    /* ucVersionHeaderLength. */\r
  63                 0x00,                                                                   /* ucDifferentiatedServicesCode. */\r
  64                 0x00, 0x00,                                                     /* usLength. */\r
  65                 0x00, 0x00,                                                     /* usIdentification. */\r
  66                 0x00, 0x00,                                                     /* usFragmentOffset. */\r
  67                 ipconfigUDP_TIME_TO_LIVE,                               /* ucTimeToLive */\r
  68                 ipPROTOCOL_UDP,                                                 /* ucProtocol. */\r
  69                 0x00, 0x00,                                                     /* usHeaderChecksum. */\r
  70                 0x00, 0x00, 0x00, 0x00                                  /* Source IP address. */\r
  71         }\r
  72 };\r
  73 /*-----------------------------------------------------------*/\r
  74 \r
  75 void vProcessGeneratedUDPPacket( NetworkBufferDescriptor_t * const pxNetworkBuffer )\r
  76 {\r
  77 UDPPacket_t *pxUDPPacket;\r
  78 IPHeader_t *pxIPHeader;\r
  79 eARPLookupResult_t eReturned;\r
  80 uint32_t ulIPAddress = pxNetworkBuffer->ulIPAddress;\r
  81 \r
  82         /* Map the UDP packet onto the start of the frame. */\r
  83         pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;\r
  84 \r
  85         /* Determine the ARP cache status for the requested IP address. */\r
  86         eReturned = eARPGetCacheEntry( &( ulIPAddress ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ) );\r
  87 \r
  88         if( eReturned != eCantSendPacket )\r
  89         {\r
  90                 if( eReturned == eARPCacheHit )\r
  91                 {\r
  92                         #if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )\r
  93                                 uint8_t ucSocketOptions;\r
  94                         #endif\r
  95                         iptraceSENDING_UDP_PACKET( pxNetworkBuffer->ulIPAddress );\r
  96 \r
  97                         /* Create short cuts to the data within the packet. */\r
  98                         pxIPHeader = &( pxUDPPacket->xIPHeader );\r
  99 \r
 100                 #if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )\r
 101                         /* Is it possible that the packet is not actually a UDP packet\r
 102                         after all, but an ICMP packet. */\r
 103                         if( pxNetworkBuffer->usPort != ipPACKET_CONTAINS_ICMP_DATA )\r
 104                 #endif /* ipconfigSUPPORT_OUTGOING_PINGS */\r
 105                         {\r
 106                         UDPHeader_t *pxUDPHeader;\r
 107 \r
 108                                 pxUDPHeader = &( pxUDPPacket->xUDPHeader );\r
 109 \r
 110                                 pxUDPHeader->usDestinationPort = pxNetworkBuffer->usPort;\r
 111                                 pxUDPHeader->usSourcePort = pxNetworkBuffer->usBoundPort;\r
 112                                 pxUDPHeader->usLength = ( uint16_t ) ( pxNetworkBuffer->xDataLength + sizeof( UDPHeader_t ) );\r
 113                                 pxUDPHeader->usLength = FreeRTOS_htons( pxUDPHeader->usLength );\r
 114                                 pxUDPHeader->usChecksum = 0u;\r
 115                         }\r
 116 \r
 117                         /* memcpy() the constant parts of the header information into\r
 118                         the     correct location within the packet.  This fills in:\r
 119                                 xEthernetHeader.xSourceAddress\r
 120                                 xEthernetHeader.usFrameType\r
 121                                 xIPHeader.ucVersionHeaderLength\r
 122                                 xIPHeader.ucDifferentiatedServicesCode\r
 123                                 xIPHeader.usLength\r
 124                                 xIPHeader.usIdentification\r
 125                                 xIPHeader.usFragmentOffset\r
 126                                 xIPHeader.ucTimeToLive\r
 127                                 xIPHeader.ucProtocol\r
 128                         and\r
 129                                 xIPHeader.usHeaderChecksum\r
 130                         */\r
 131                         /* Save options now, as they will be overwritten by memcpy */\r
 132                         #if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )\r
 133                                 ucSocketOptions = pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ];\r
 134                         #endif\r
 135                         /*\r
 136                          * Offset the memcpy by the size of a MAC address to start at the packet's\r
 137                          * Ethernet header 'source' MAC address; the preceding 'destination' should not be altered.\r
 138                          */\r
 139                         char *pxUdpSrcAddrOffset = ( char *) pxUDPPacket + sizeof( MACAddress_t );\r
 140                         memcpy( pxUdpSrcAddrOffset, xDefaultPartUDPPacketHeader.ucBytes, sizeof( xDefaultPartUDPPacketHeader ) );\r
 141 \r
 142                 #if ipconfigSUPPORT_OUTGOING_PINGS == 1\r
 143                         if( pxNetworkBuffer->usPort == ipPACKET_CONTAINS_ICMP_DATA )\r
 144                         {\r
 145                                 pxIPHeader->ucProtocol = ipPROTOCOL_ICMP;\r
 146                                 pxIPHeader->usLength = ( uint16_t ) ( pxNetworkBuffer->xDataLength + sizeof( IPHeader_t ) );\r
 147                         }\r
 148                         else\r
 149                 #endif /* ipconfigSUPPORT_OUTGOING_PINGS */\r
 150                         {\r
 151                                 pxIPHeader->usLength = ( uint16_t ) ( pxNetworkBuffer->xDataLength + sizeof( IPHeader_t ) + sizeof( UDPHeader_t ) );\r
 152                         }\r
 153 \r
 154                         /* The total transmit size adds on the Ethernet header. */\r
 155                         pxNetworkBuffer->xDataLength = pxIPHeader->usLength + sizeof( EthernetHeader_t );\r
 156                         pxIPHeader->usLength = FreeRTOS_htons( pxIPHeader->usLength );\r
 157                         /* HT:endian: changed back to network endian */\r
 158                         pxIPHeader->ulDestinationIPAddress = pxNetworkBuffer->ulIPAddress;\r
 159 \r
 160                         #if( ipconfigUSE_LLMNR == 1 )\r
 161                         {\r
 162                                 /* LLMNR messages are typically used on a LAN and they're\r
 163                                  * not supposed to cross routers */\r
 164                                 if( pxNetworkBuffer->ulIPAddress == ipLLMNR_IP_ADDR )\r
 165                                 {\r
 166                                         pxIPHeader->ucTimeToLive = 0x01;\r
 167                                 }\r
 168                         }\r
 169                         #endif\r
 170 \r
 171                         #if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )\r
 172                         {\r
 173                                 pxIPHeader->usHeaderChecksum = 0u;\r
 174                                 pxIPHeader->usHeaderChecksum = usGenerateChecksum( 0UL, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ipSIZE_OF_IPv4_HEADER );\r
 175                                 pxIPHeader->usHeaderChecksum = ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum );\r
 176 \r
 177                                 if( ( ucSocketOptions & ( uint8_t ) FREERTOS_SO_UDPCKSUM_OUT ) != 0u )\r
 178                                 {\r
 179                                         usGenerateProtocolChecksum( (uint8_t*)pxUDPPacket, pxNetworkBuffer->xDataLength, pdTRUE );\r
 180                                 }\r
 181                                 else\r
 182                                 {\r
 183                                         pxUDPPacket->xUDPHeader.usChecksum = 0u;\r
 184                                 }\r
 185                         }\r
 186                         #endif\r
 187                 }\r
 188                 else if( eReturned == eARPCacheMiss )\r
 189                 {\r
 190                         /* Add an entry to the ARP table with a null hardware address.\r
 191                         This allows the ARP timer to know that an ARP reply is\r
 192                         outstanding, and perform retransmissions if necessary. */\r
 193                         vARPRefreshCacheEntry( NULL, ulIPAddress );\r
 194 \r
 195                         /* Generate an ARP for the required IP address. */\r
 196                         iptracePACKET_DROPPED_TO_GENERATE_ARP( pxNetworkBuffer->ulIPAddress );\r
 197                         pxNetworkBuffer->ulIPAddress = ulIPAddress;\r
 198                         vARPGenerateRequestPacket( pxNetworkBuffer );\r
 199                 }\r
 200                 else\r
 201                 {\r
 202                         /* The lookup indicated that an ARP request has already been\r
 203                         sent out for the queried IP address. */\r
 204                         eReturned = eCantSendPacket;\r
 205                 }\r
 206         }\r
 207 \r
 208         if( eReturned != eCantSendPacket )\r
 209         {\r
 210                 /* The network driver is responsible for freeing the network buffer\r
 211                 after the packet has been sent. */\r
 212 \r
 213                 #if defined( ipconfigETHERNET_MINIMUM_PACKET_BYTES )\r
 214                 {\r
 215                         if( pxNetworkBuffer->xDataLength < ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES )\r
 216                         {\r
 217                         BaseType_t xIndex;\r
 218 \r
 219                                 for( xIndex = ( BaseType_t ) pxNetworkBuffer->xDataLength; xIndex < ( BaseType_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES; xIndex++ )\r
 220                                 {\r
 221                                         pxNetworkBuffer->pucEthernetBuffer[ xIndex ] = 0u;\r
 222                                 }\r
 223                                 pxNetworkBuffer->xDataLength = ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES;\r
 224                         }\r
 225                 }\r
 226                 #endif\r
 227 \r
 228                 xNetworkInterfaceOutput( pxNetworkBuffer, pdTRUE );\r
 229         }\r
 230         else\r
 231         {\r
 232                 /* The packet can't be sent (DHCP not completed?).  Just drop the\r
 233                 packet. */\r
 234                 vReleaseNetworkBufferAndDescriptor( pxNetworkBuffer );\r
 235         }\r
 236 }\r
 237 /*-----------------------------------------------------------*/\r
 238 \r
 239 BaseType_t xProcessReceivedUDPPacket( NetworkBufferDescriptor_t *pxNetworkBuffer, uint16_t usPort )\r
 240 {\r
 241 BaseType_t xReturn = pdPASS;\r
 242 FreeRTOS_Socket_t *pxSocket;\r
 243 UDPPacket_t *pxUDPPacket;\r
 244 \r
 245         configASSERT( pxNetworkBuffer );\r
 246         configASSERT( pxNetworkBuffer->pucEthernetBuffer );\r
 247 \r
 248         pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;\r
 249         \r
 250         /* Caller must check for minimum packet size. */\r
 251         pxSocket = pxUDPSocketLookup( usPort );\r
 252 \r
 253         if( pxSocket )\r
 254         {\r
 255 \r
 256                 /* When refreshing the ARP cache with received UDP packets we must be\r
 257                 careful;  hundreds of broadcast messages may pass and if we're not\r
 258                 handling them, no use to fill the ARP cache with those IP addresses. */\r
 259                 vARPRefreshCacheEntry( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );\r
 260 \r
 261                 #if( ipconfigUSE_CALLBACKS == 1 )\r
 262                 {\r
 263                         /* Did the owner of this socket register a reception handler ? */\r
 264                         if( ipconfigIS_VALID_PROG_ADDRESS( pxSocket->u.xUDP.pxHandleReceive ) )\r
 265                         {\r
 266                                 struct freertos_sockaddr xSourceAddress, destinationAddress;\r
 267                                 void *pcData = ( void * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipUDP_PAYLOAD_OFFSET_IPv4 ] );\r
 268                                 FOnUDPReceive_t xHandler = ( FOnUDPReceive_t ) pxSocket->u.xUDP.pxHandleReceive;\r
 269                                 xSourceAddress.sin_port = pxNetworkBuffer->usPort;\r
 270                                 xSourceAddress.sin_addr = pxNetworkBuffer->ulIPAddress;\r
 271                                 destinationAddress.sin_port = usPort;\r
 272                                 destinationAddress.sin_addr = pxUDPPacket->xIPHeader.ulDestinationIPAddress;\r
 273 \r
 274                                 if( xHandler( ( Socket_t * ) pxSocket, ( void* ) pcData, ( size_t ) pxNetworkBuffer->xDataLength,\r
 275                                         &xSourceAddress, &destinationAddress ) )\r
 276                                 {\r
 277                                         xReturn = pdFAIL; /* FAIL means that we did not consume or release the buffer */\r
 278                                 }\r
 279                         }\r
 280                 }\r
 281                 #endif /* ipconfigUSE_CALLBACKS */\r
 282 \r
 283                 #if( ipconfigUDP_MAX_RX_PACKETS > 0 )\r
 284                 {\r
 285                         if( xReturn == pdPASS )\r
 286                         {\r
 287                                 if ( listCURRENT_LIST_LENGTH( &( pxSocket->u.xUDP.xWaitingPacketsList ) ) >= pxSocket->u.xUDP.uxMaxPackets )\r
 288                                 {\r
 289                                         FreeRTOS_debug_printf( ( "xProcessReceivedUDPPacket: buffer full %ld >= %ld port %u\n",\r
 290                                                 listCURRENT_LIST_LENGTH( &( pxSocket->u.xUDP.xWaitingPacketsList ) ),\r
 291                                                 pxSocket->u.xUDP.uxMaxPackets, pxSocket->usLocalPort ) );\r
 292                                         xReturn = pdFAIL; /* we did not consume or release the buffer */\r
 293                                 }\r
 294                         }\r
 295                 }\r
 296                 #endif\r
 297 \r
 298                 if( xReturn == pdPASS )\r
 299                 {\r
 300                         vTaskSuspendAll();\r
 301                         {\r
 302                                 if( xReturn == pdPASS )\r
 303                                 {\r
 304                                         taskENTER_CRITICAL();\r
 305                                         {\r
 306                                                 /* Add the network packet to the list of packets to be\r
 307                                                 processed by the socket. */\r
 308                                                 vListInsertEnd( &( pxSocket->u.xUDP.xWaitingPacketsList ), &( pxNetworkBuffer->xBufferListItem ) );\r
 309                                         }\r
 310                                         taskEXIT_CRITICAL();\r
 311                                 }\r
 312                         }\r
 313                         xTaskResumeAll();\r
 314 \r
 315                         /* Set the socket's receive event */\r
 316                         if( pxSocket->xEventGroup != NULL )\r
 317                         {\r
 318                                 xEventGroupSetBits( pxSocket->xEventGroup, eSOCKET_RECEIVE );\r
 319                         }\r
 320 \r
 321                         #if( ipconfigSUPPORT_SELECT_FUNCTION == 1 )\r
 322                         {\r
 323                                 if( ( pxSocket->pxSocketSet != NULL ) && ( ( pxSocket->xSelectBits & eSELECT_READ ) != 0 ) )\r
 324                                 {\r
 325                                         xEventGroupSetBits( pxSocket->pxSocketSet->xSelectGroup, eSELECT_READ );\r
 326                                 }\r
 327                         }\r
 328                         #endif\r
 329 \r
 330                         #if( ipconfigSOCKET_HAS_USER_SEMAPHORE == 1 )\r
 331                         {\r
 332                                 if( pxSocket->pxUserSemaphore != NULL )\r
 333                                 {\r
 334                                         xSemaphoreGive( pxSocket->pxUserSemaphore );\r
 335                                 }\r
 336                         }\r
 337                         #endif\r
 338 \r
 339                         #if( ipconfigUSE_DHCP == 1 )\r
 340                         {\r
 341                                 if( xIsDHCPSocket( pxSocket ) )\r
 342                                 {\r
 343                                         xSendEventToIPTask( eDHCPEvent );\r
 344                                 }\r
 345                         }\r
 346                         #endif\r
 347                 }\r
 348         }\r
 349         else\r
 350         {\r
 351                 /* There is no socket listening to the target port, but still it might\r
 352                 be for this node. */\r
 353 \r
 354                 #if( ipconfigUSE_LLMNR == 1 )\r
 355                         /* a LLMNR request, check for the destination port. */\r
 356                         if( ( usPort == FreeRTOS_ntohs( ipLLMNR_PORT ) ) ||\r
 357                                 ( pxUDPPacket->xUDPHeader.usSourcePort == FreeRTOS_ntohs( ipLLMNR_PORT ) ) )\r
 358                         {\r
 359                                 vARPRefreshCacheEntry( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );\r
 360                                 xReturn = ( BaseType_t )ulDNSHandlePacket( pxNetworkBuffer );\r
 361                         }\r
 362                         else\r
 363                 #endif /* ipconfigUSE_LLMNR */\r
 364 \r
 365                 #if( ipconfigUSE_NBNS == 1 )\r
 366                         /* a NetBIOS request, check for the destination port */\r
 367                         if( ( usPort == FreeRTOS_ntohs( ipNBNS_PORT ) ) ||\r
 368                                 ( pxUDPPacket->xUDPHeader.usSourcePort == FreeRTOS_ntohs( ipNBNS_PORT ) ) )\r
 369                         {\r
 370                                 vARPRefreshCacheEntry( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );\r
 371                                 xReturn = ( BaseType_t )ulNBNSHandlePacket( pxNetworkBuffer );\r
 372                         }\r
 373                         else\r
 374                 #endif /* ipconfigUSE_NBNS */\r
 375                 {\r
 376                         xReturn = pdFAIL;\r
 377                 }\r
 378         }\r
 379 \r
 380         return xReturn;\r
 381 }\r
 382 /*-----------------------------------------------------------*/\r