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

   1 /*\r
   2  * FreeRTOS+TCP V2.2.0\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 size_t uxPayloadSize;\r
  82 \r
  83         /* Map the UDP packet onto the start of the frame. */\r
  84         pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;\r
  85 \r
  86 #if ipconfigSUPPORT_OUTGOING_PINGS == 1\r
  87         if( pxNetworkBuffer->usPort == ipPACKET_CONTAINS_ICMP_DATA )\r
  88         {\r
  89                 uxPayloadSize = pxNetworkBuffer->xDataLength - sizeof( ICMPPacket_t );\r
  90         }\r
  91         else\r
  92 #endif\r
  93         {\r
  94                 uxPayloadSize = pxNetworkBuffer->xDataLength - sizeof( UDPPacket_t );\r
  95         }\r
  96 \r
  97         /* Determine the ARP cache status for the requested IP address. */\r
  98         eReturned = eARPGetCacheEntry( &( ulIPAddress ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ) );\r
  99 \r
 100         if( eReturned != eCantSendPacket )\r
 101         {\r
 102                 if( eReturned == eARPCacheHit )\r
 103                 {\r
 104                         #if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )\r
 105                                 uint8_t ucSocketOptions;\r
 106                         #endif\r
 107                         iptraceSENDING_UDP_PACKET( pxNetworkBuffer->ulIPAddress );\r
 108 \r
 109                         /* Create short cuts to the data within the packet. */\r
 110                         pxIPHeader = &( pxUDPPacket->xIPHeader );\r
 111 \r
 112                 #if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )\r
 113                         /* Is it possible that the packet is not actually a UDP packet\r
 114                         after all, but an ICMP packet. */\r
 115                         if( pxNetworkBuffer->usPort != ipPACKET_CONTAINS_ICMP_DATA )\r
 116                 #endif /* ipconfigSUPPORT_OUTGOING_PINGS */\r
 117                         {\r
 118                         UDPHeader_t *pxUDPHeader;\r
 119 \r
 120                                 pxUDPHeader = &( pxUDPPacket->xUDPHeader );\r
 121 \r
 122                                 pxUDPHeader->usDestinationPort = pxNetworkBuffer->usPort;\r
 123                                 pxUDPHeader->usSourcePort = pxNetworkBuffer->usBoundPort;\r
 124                                 pxUDPHeader->usLength = ( uint16_t ) ( uxPayloadSize + sizeof( UDPHeader_t ) );\r
 125                                 pxUDPHeader->usLength = FreeRTOS_htons( pxUDPHeader->usLength );\r
 126                                 pxUDPHeader->usChecksum = 0u;\r
 127                         }\r
 128 \r
 129                         /* memcpy() the constant parts of the header information into\r
 130                         the     correct location within the packet.  This fills in:\r
 131                                 xEthernetHeader.xSourceAddress\r
 132                                 xEthernetHeader.usFrameType\r
 133                                 xIPHeader.ucVersionHeaderLength\r
 134                                 xIPHeader.ucDifferentiatedServicesCode\r
 135                                 xIPHeader.usLength\r
 136                                 xIPHeader.usIdentification\r
 137                                 xIPHeader.usFragmentOffset\r
 138                                 xIPHeader.ucTimeToLive\r
 139                                 xIPHeader.ucProtocol\r
 140                         and\r
 141                                 xIPHeader.usHeaderChecksum\r
 142                         */\r
 143                         /* Save options now, as they will be overwritten by memcpy */\r
 144                         #if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )\r
 145                                 ucSocketOptions = pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ];\r
 146                         #endif\r
 147                         /*\r
 148                          * Offset the memcpy by the size of a MAC address to start at the packet's\r
 149                          * Ethernet header 'source' MAC address; the preceding 'destination' should not be altered.\r
 150                          */\r
 151                         char *pxUdpSrcAddrOffset = ( char *) pxUDPPacket + sizeof( MACAddress_t );\r
 152                         memcpy( pxUdpSrcAddrOffset, xDefaultPartUDPPacketHeader.ucBytes, sizeof( xDefaultPartUDPPacketHeader ) );\r
 153 \r
 154                 #if ipconfigSUPPORT_OUTGOING_PINGS == 1\r
 155                         if( pxNetworkBuffer->usPort == ipPACKET_CONTAINS_ICMP_DATA )\r
 156                         {\r
 157                                 pxIPHeader->ucProtocol = ipPROTOCOL_ICMP;\r
 158                                 pxIPHeader->usLength = ( uint16_t ) ( uxPayloadSize + sizeof( IPHeader_t ) + sizeof( ICMPHeader_t ) );\r
 159                         }\r
 160                         else\r
 161                 #endif /* ipconfigSUPPORT_OUTGOING_PINGS */\r
 162                         {\r
 163                                 pxIPHeader->usLength = ( uint16_t ) ( uxPayloadSize + sizeof( IPHeader_t ) + sizeof( UDPHeader_t ) );\r
 164                         }\r
 165 \r
 166                         pxIPHeader->usLength = FreeRTOS_htons( pxIPHeader->usLength );\r
 167                         /* HT:endian: changed back to network endian */\r
 168                         pxIPHeader->ulDestinationIPAddress = pxNetworkBuffer->ulIPAddress;\r
 169 \r
 170                         #if( ipconfigUSE_LLMNR == 1 )\r
 171                         {\r
 172                                 /* LLMNR messages are typically used on a LAN and they're\r
 173                                  * not supposed to cross routers */\r
 174                                 if( pxNetworkBuffer->ulIPAddress == ipLLMNR_IP_ADDR )\r
 175                                 {\r
 176                                         pxIPHeader->ucTimeToLive = 0x01;\r
 177                                 }\r
 178                         }\r
 179                         #endif\r
 180 \r
 181                         #if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )\r
 182                         {\r
 183                                 pxIPHeader->usHeaderChecksum = 0u;\r
 184                                 pxIPHeader->usHeaderChecksum = usGenerateChecksum( 0UL, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ipSIZE_OF_IPv4_HEADER );\r
 185                                 pxIPHeader->usHeaderChecksum = ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum );\r
 186 \r
 187                                 if( ( ucSocketOptions & ( uint8_t ) FREERTOS_SO_UDPCKSUM_OUT ) != 0u )\r
 188                                 {\r
 189                                         usGenerateProtocolChecksum( (uint8_t*)pxUDPPacket, pxNetworkBuffer->xDataLength, pdTRUE );\r
 190                                 }\r
 191                                 else\r
 192                                 {\r
 193                                         pxUDPPacket->xUDPHeader.usChecksum = 0u;\r
 194                                 }\r
 195                         }\r
 196                         #endif\r
 197                 }\r
 198                 else if( eReturned == eARPCacheMiss )\r
 199                 {\r
 200                         /* Add an entry to the ARP table with a null hardware address.\r
 201                         This allows the ARP timer to know that an ARP reply is\r
 202                         outstanding, and perform retransmissions if necessary. */\r
 203                         vARPRefreshCacheEntry( NULL, ulIPAddress );\r
 204 \r
 205                         /* Generate an ARP for the required IP address. */\r
 206                         iptracePACKET_DROPPED_TO_GENERATE_ARP( pxNetworkBuffer->ulIPAddress );\r
 207                         pxNetworkBuffer->ulIPAddress = ulIPAddress;\r
 208                         vARPGenerateRequestPacket( pxNetworkBuffer );\r
 209                 }\r
 210                 else\r
 211                 {\r
 212                         /* The lookup indicated that an ARP request has already been\r
 213                         sent out for the queried IP address. */\r
 214                         eReturned = eCantSendPacket;\r
 215                 }\r
 216         }\r
 217 \r
 218         if( eReturned != eCantSendPacket )\r
 219         {\r
 220                 /* The network driver is responsible for freeing the network buffer\r
 221                 after the packet has been sent. */\r
 222 \r
 223                 #if defined( ipconfigETHERNET_MINIMUM_PACKET_BYTES )\r
 224                 {\r
 225                         if( pxNetworkBuffer->xDataLength < ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES )\r
 226                         {\r
 227                         BaseType_t xIndex;\r
 228 \r
 229                                 for( xIndex = ( BaseType_t ) pxNetworkBuffer->xDataLength; xIndex < ( BaseType_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES; xIndex++ )\r
 230                                 {\r
 231                                         pxNetworkBuffer->pucEthernetBuffer[ xIndex ] = 0u;\r
 232                                 }\r
 233                                 pxNetworkBuffer->xDataLength = ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES;\r
 234                         }\r
 235                 }\r
 236                 #endif\r
 237 \r
 238                 xNetworkInterfaceOutput( pxNetworkBuffer, pdTRUE );\r
 239         }\r
 240         else\r
 241         {\r
 242                 /* The packet can't be sent (DHCP not completed?).  Just drop the\r
 243                 packet. */\r
 244                 vReleaseNetworkBufferAndDescriptor( pxNetworkBuffer );\r
 245         }\r
 246 }\r
 247 /*-----------------------------------------------------------*/\r
 248 \r
 249 BaseType_t xProcessReceivedUDPPacket( NetworkBufferDescriptor_t *pxNetworkBuffer, uint16_t usPort )\r
 250 {\r
 251 BaseType_t xReturn = pdPASS;\r
 252 FreeRTOS_Socket_t *pxSocket;\r
 253 configASSERT(pxNetworkBuffer);\r
 254 configASSERT(pxNetworkBuffer->pucEthernetBuffer);\r
 255 \r
 256 \r
 257 UDPPacket_t *pxUDPPacket = (UDPPacket_t *) pxNetworkBuffer->pucEthernetBuffer;\r
 258 \r
 259         /* Caller must check for minimum packet size. */\r
 260         pxSocket = pxUDPSocketLookup( usPort );\r
 261 \r
 262         if( pxSocket )\r
 263         {\r
 264 \r
 265                 /* When refreshing the ARP cache with received UDP packets we must be\r
 266                 careful;  hundreds of broadcast messages may pass and if we're not\r
 267                 handling them, no use to fill the ARP cache with those IP addresses. */\r
 268                 vARPRefreshCacheEntry( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );\r
 269 \r
 270                 #if( ipconfigUSE_CALLBACKS == 1 )\r
 271                 {\r
 272                         /* Did the owner of this socket register a reception handler ? */\r
 273                         if( ipconfigIS_VALID_PROG_ADDRESS( pxSocket->u.xUDP.pxHandleReceive ) )\r
 274                         {\r
 275                                 struct freertos_sockaddr xSourceAddress, destinationAddress;\r
 276                                 void *pcData = ( void * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipUDP_PAYLOAD_OFFSET_IPv4 ] );\r
 277                                 FOnUDPReceive_t xHandler = ( FOnUDPReceive_t ) pxSocket->u.xUDP.pxHandleReceive;\r
 278                                 xSourceAddress.sin_port = pxNetworkBuffer->usPort;\r
 279                                 xSourceAddress.sin_addr = pxNetworkBuffer->ulIPAddress;\r
 280                                 destinationAddress.sin_port = usPort;\r
 281                                 destinationAddress.sin_addr = pxUDPPacket->xIPHeader.ulDestinationIPAddress;\r
 282 \r
 283                                 if( xHandler( ( Socket_t ) pxSocket, ( void* ) pcData, ( size_t ) pxNetworkBuffer->xDataLength,\r
 284                                         &xSourceAddress, &destinationAddress ) )\r
 285                                 {\r
 286                                         xReturn = pdFAIL; /* FAIL means that we did not consume or release the buffer */\r
 287                                 }\r
 288                         }\r
 289                 }\r
 290                 #endif /* ipconfigUSE_CALLBACKS */\r
 291 \r
 292                 #if( ipconfigUDP_MAX_RX_PACKETS > 0 )\r
 293                 {\r
 294                         if( xReturn == pdPASS )\r
 295                         {\r
 296                                 if ( listCURRENT_LIST_LENGTH( &( pxSocket->u.xUDP.xWaitingPacketsList ) ) >= pxSocket->u.xUDP.uxMaxPackets )\r
 297                                 {\r
 298                                         FreeRTOS_debug_printf( ( "xProcessReceivedUDPPacket: buffer full %ld >= %ld port %u\n",\r
 299                                                 listCURRENT_LIST_LENGTH( &( pxSocket->u.xUDP.xWaitingPacketsList ) ),\r
 300                                                 pxSocket->u.xUDP.uxMaxPackets, pxSocket->usLocalPort ) );\r
 301                                         xReturn = pdFAIL; /* we did not consume or release the buffer */\r
 302                                 }\r
 303                         }\r
 304                 }\r
 305                 #endif\r
 306 \r
 307                 if( xReturn == pdPASS )\r
 308                 {\r
 309                         vTaskSuspendAll();\r
 310                         {\r
 311                                 if( xReturn == pdPASS )\r
 312                                 {\r
 313                                         taskENTER_CRITICAL();\r
 314                                         {\r
 315                                                 /* Add the network packet to the list of packets to be\r
 316                                                 processed by the socket. */\r
 317                                                 vListInsertEnd( &( pxSocket->u.xUDP.xWaitingPacketsList ), &( pxNetworkBuffer->xBufferListItem ) );\r
 318                                         }\r
 319                                         taskEXIT_CRITICAL();\r
 320                                 }\r
 321                         }\r
 322                         xTaskResumeAll();\r
 323 \r
 324                         /* Set the socket's receive event */\r
 325                         if( pxSocket->xEventGroup != NULL )\r
 326                         {\r
 327                                 xEventGroupSetBits( pxSocket->xEventGroup, eSOCKET_RECEIVE );\r
 328                         }\r
 329 \r
 330                         #if( ipconfigSUPPORT_SELECT_FUNCTION == 1 )\r
 331                         {\r
 332                                 if( ( pxSocket->pxSocketSet != NULL ) && ( ( pxSocket->xSelectBits & eSELECT_READ ) != 0 ) )\r
 333                                 {\r
 334                                         xEventGroupSetBits( pxSocket->pxSocketSet->xSelectGroup, eSELECT_READ );\r
 335                                 }\r
 336                         }\r
 337                         #endif\r
 338 \r
 339                         #if( ipconfigSOCKET_HAS_USER_SEMAPHORE == 1 )\r
 340                         {\r
 341                                 if( pxSocket->pxUserSemaphore != NULL )\r
 342                                 {\r
 343                                         xSemaphoreGive( pxSocket->pxUserSemaphore );\r
 344                                 }\r
 345                         }\r
 346                         #endif\r
 347 \r
 348                         #if( ipconfigUSE_DHCP == 1 )\r
 349                         {\r
 350                                 if( xIsDHCPSocket( pxSocket ) )\r
 351                                 {\r
 352                                         xSendEventToIPTask( eDHCPEvent );\r
 353                                 }\r
 354                         }\r
 355                         #endif\r
 356                 }\r
 357         }\r
 358         else\r
 359         {\r
 360                 /* There is no socket listening to the target port, but still it might\r
 361                 be for this node. */\r
 362 \r
 363                 #if( ipconfigUSE_DNS == 1 ) && ( ipconfigDNS_USE_CALLBACKS == 1 )\r
 364                         /* A DNS reply, check for the source port.  Although the DNS client\r
 365                         does open a UDP socket to send a messages, this socket will be\r
 366                         closed after a short timeout.  Messages that come late (after the\r
 367                         socket is closed) will be treated here. */\r
 368                         if( FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usSourcePort ) == ipDNS_PORT )\r
 369                         {\r
 370                                 vARPRefreshCacheEntry( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );\r
 371                                 xReturn = ( BaseType_t )ulDNSHandlePacket( pxNetworkBuffer );\r
 372                         }\r
 373                         else\r
 374                 #endif\r
 375 \r
 376                 #if( ipconfigUSE_LLMNR == 1 )\r
 377                         /* a LLMNR request, check for the destination port. */\r
 378                         if( ( usPort == FreeRTOS_ntohs( ipLLMNR_PORT ) ) ||\r
 379                                 ( pxUDPPacket->xUDPHeader.usSourcePort == FreeRTOS_ntohs( ipLLMNR_PORT ) ) )\r
 380                         {\r
 381                                 vARPRefreshCacheEntry( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );\r
 382                                 xReturn = ( BaseType_t )ulDNSHandlePacket( pxNetworkBuffer );\r
 383                         }\r
 384                         else\r
 385                 #endif /* ipconfigUSE_LLMNR */\r
 386 \r
 387                 #if( ipconfigUSE_NBNS == 1 )\r
 388                         /* a NetBIOS request, check for the destination port */\r
 389                         if( ( usPort == FreeRTOS_ntohs( ipNBNS_PORT ) ) ||\r
 390                                 ( pxUDPPacket->xUDPHeader.usSourcePort == FreeRTOS_ntohs( ipNBNS_PORT ) ) )\r
 391                         {\r
 392                                 vARPRefreshCacheEntry( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );\r
 393                                 xReturn = ( BaseType_t )ulNBNSHandlePacket( pxNetworkBuffer );\r
 394                         }\r
 395                         else\r
 396                 #endif /* ipconfigUSE_NBNS */\r
 397                 {\r
 398                         xReturn = pdFAIL;\r
 399                 }\r
 400         }\r
 401 \r
 402         return xReturn;\r
 403 }\r
 404 /*-----------------------------------------------------------*/\r