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

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