2 * FreeRTOS+TCP Labs Build 160919 (C) 2016 Real Time Engineers ltd.
\r
3 * Authors include Hein Tibosch and Richard Barry
\r
5 *******************************************************************************
\r
6 ***** NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ***
\r
9 *** FREERTOS+TCP IS STILL IN THE LAB (mainly because the FTP and HTTP ***
\r
10 *** demos have a dependency on FreeRTOS+FAT, which is only in the Labs ***
\r
13 *** FreeRTOS+TCP is functional and has been used in commercial products ***
\r
14 *** for some time. Be aware however that we are still refining its ***
\r
15 *** design, the source code does not yet quite conform to the strict ***
\r
16 *** coding and style standards mandated by Real Time Engineers ltd., and ***
\r
17 *** the documentation and testing is not necessarily complete. ***
\r
19 *** PLEASE REPORT EXPERIENCES USING THE SUPPORT RESOURCES FOUND ON THE ***
\r
20 *** URL: http://www.FreeRTOS.org/contact Active early adopters may, at ***
\r
21 *** the sole discretion of Real Time Engineers Ltd., be offered versions ***
\r
22 *** under a license other than that described below. ***
\r
25 ***** NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ***
\r
26 *******************************************************************************
\r
28 * FreeRTOS+TCP can be used under two different free open source licenses. The
\r
29 * license that applies is dependent on the processor on which FreeRTOS+TCP is
\r
30 * executed, as follows:
\r
32 * If FreeRTOS+TCP is executed on one of the processors listed under the Special
\r
33 * License Arrangements heading of the FreeRTOS+TCP license information web
\r
34 * page, then it can be used under the terms of the FreeRTOS Open Source
\r
35 * License. If FreeRTOS+TCP is used on any other processor, then it can be used
\r
36 * under the terms of the GNU General Public License V2. Links to the relevant
\r
39 * The FreeRTOS+TCP License Information Page: http://www.FreeRTOS.org/tcp_license
\r
40 * The FreeRTOS Open Source License: http://www.FreeRTOS.org/license
\r
41 * The GNU General Public License Version 2: http://www.FreeRTOS.org/gpl-2.0.txt
\r
43 * FreeRTOS+TCP is distributed in the hope that it will be useful. You cannot
\r
44 * use FreeRTOS+TCP unless you agree that you use the software 'as is'.
\r
45 * FreeRTOS+TCP is provided WITHOUT ANY WARRANTY; without even the implied
\r
46 * warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR
\r
47 * PURPOSE. Real Time Engineers Ltd. disclaims all conditions and terms, be they
\r
48 * implied, expressed, or statutory.
\r
50 * 1 tab == 4 spaces!
\r
52 * http://www.FreeRTOS.org
\r
53 * http://www.FreeRTOS.org/plus
\r
54 * http://www.FreeRTOS.org/labs
\r
58 /* Standard includes. */
\r
63 /* FreeRTOS includes. */
\r
64 #include "FreeRTOS.h"
\r
69 /* FreeRTOS+TCP includes. */
\r
70 #include "FreeRTOS_IP.h"
\r
71 #include "FreeRTOS_Sockets.h"
\r
72 #include "FreeRTOS_IP_Private.h"
\r
73 #include "FreeRTOS_ARP.h"
\r
74 #include "FreeRTOS_UDP_IP.h"
\r
75 #include "FreeRTOS_TCP_IP.h"
\r
76 #include "FreeRTOS_DHCP.h"
\r
77 #include "NetworkInterface.h"
\r
78 #include "NetworkBufferManagement.h"
\r
79 #include "FreeRTOS_DNS.h"
\r
82 /* Used to ensure the structure packing is having the desired effect. The
\r
83 'volatile' is used to prevent compiler warnings about comparing a constant with
\r
85 #define ipEXPECTED_EthernetHeader_t_SIZE ( ( size_t ) 14 )
\r
86 #define ipEXPECTED_ARPHeader_t_SIZE ( ( size_t ) 28 )
\r
87 #define ipEXPECTED_IPHeader_t_SIZE ( ( size_t ) 20 )
\r
88 #define ipEXPECTED_IGMPHeader__SIZE ( ( size_t ) 8 )
\r
89 #define ipEXPECTED_ICMPHeader_t_SIZE ( ( size_t ) 8 )
\r
90 #define ipEXPECTED_UDPHeader_t_SIZE ( ( size_t ) 8 )
\r
91 #define ipEXPECTED_TCPHeader_t_SIZE ( ( size_t ) 20 )
\r
94 /* ICMP protocol definitions. */
\r
95 #define ipICMP_ECHO_REQUEST ( ( uint8_t ) 8 )
\r
96 #define ipICMP_ECHO_REPLY ( ( uint8_t ) 0 )
\r
99 /* Time delay between repeated attempts to initialise the network hardware. */
\r
100 #ifndef ipINITIALISATION_RETRY_DELAY
\r
101 #define ipINITIALISATION_RETRY_DELAY ( pdMS_TO_TICKS( 3000 ) )
\r
104 /* Defines how often the ARP timer callback function is executed. The time is
\r
105 shorted in the Windows simulator as simulated time is not real time. */
\r
106 #ifndef ipARP_TIMER_PERIOD_MS
\r
108 #define ipARP_TIMER_PERIOD_MS ( 500 ) /* For windows simulator builds. */
\r
110 #define ipARP_TIMER_PERIOD_MS ( 10000 )
\r
114 #ifndef iptraceIP_TASK_STARTING
\r
115 #define iptraceIP_TASK_STARTING() do {} while( 0 )
\r
118 #if( ( ipconfigUSE_TCP == 1 ) && !defined( ipTCP_TIMER_PERIOD_MS ) )
\r
119 /* When initialising the TCP timer,
\r
120 give it an initial time-out of 1 second. */
\r
121 #define ipTCP_TIMER_PERIOD_MS ( 1000 )
\r
124 /* If ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES is set to 1, then the Ethernet
\r
125 driver will filter incoming packets and only pass the stack those packets it
\r
126 considers need processing. In this case ipCONSIDER_FRAME_FOR_PROCESSING() can
\r
127 be #defined away. If ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES is set to 0
\r
128 then the Ethernet driver will pass all received packets to the stack, and the
\r
129 stack must do the filtering itself. In this case ipCONSIDER_FRAME_FOR_PROCESSING
\r
130 needs to call eConsiderFrameForProcessing. */
\r
131 #if ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES == 0
\r
132 #define ipCONSIDER_FRAME_FOR_PROCESSING( pucEthernetBuffer ) eConsiderFrameForProcessing( ( pucEthernetBuffer ) )
\r
134 #define ipCONSIDER_FRAME_FOR_PROCESSING( pucEthernetBuffer ) eProcessBuffer
\r
137 /* The character used to fill ICMP echo requests, and therefore also the
\r
138 character expected to fill ICMP echo replies. */
\r
139 #define ipECHO_DATA_FILL_BYTE 'x'
\r
141 #if( ipconfigBYTE_ORDER == pdFREERTOS_LITTLE_ENDIAN )
\r
142 /* The bits in the two byte IP header field that make up the fragment offset value. */
\r
143 #define ipFRAGMENT_OFFSET_BIT_MASK ( ( uint16_t ) 0xff0f )
\r
145 /* The bits in the two byte IP header field that make up the fragment offset value. */
\r
146 #define ipFRAGMENT_OFFSET_BIT_MASK ( ( uint16_t ) 0x0fff )
\r
147 #endif /* ipconfigBYTE_ORDER */
\r
149 /* The maximum time the IP task is allowed to remain in the Blocked state if no
\r
150 events are posted to the network event queue. */
\r
151 #ifndef ipconfigMAX_IP_TASK_SLEEP_TIME
\r
152 #define ipconfigMAX_IP_TASK_SLEEP_TIME ( pdMS_TO_TICKS( 10000UL ) )
\r
155 /* When a new TCP connection is established, the value of
\r
156 'ulNextInitialSequenceNumber' will be used as the initial sequence number. It
\r
157 is very important that at start-up, 'ulNextInitialSequenceNumber' contains a
\r
158 random value. Also its value must be increased continuously in time, to prevent
\r
159 a third party guessing the next sequence number and take-over a TCP connection.
\r
160 It is advised to increment it by 1 ever 4us, which makes about 256 times
\r
162 #define ipINITIAL_SEQUENCE_NUMBER_FACTOR 256UL
\r
164 /* Returned as the (invalid) checksum when the protocol being checked is not
\r
165 handled. The value is chosen simply to be easy to spot when debugging. */
\r
166 #define ipUNHANDLED_PROTOCOL 0x4321u
\r
168 /* Returned to indicate a valid checksum when the checksum does not need to be
\r
170 #define ipCORRECT_CRC 0xffffu
\r
172 /* Returned as the (invalid) checksum when the length of the data being checked
\r
173 had an invalid length. */
\r
174 #define ipINVALID_LENGTH 0x1234u
\r
176 /*-----------------------------------------------------------*/
\r
178 typedef struct xIP_TIMER
\r
181 bActive : 1, /* This timer is running and must be processed. */
\r
182 bExpired : 1; /* Timer has expired and a task must be processed. */
\r
183 TimeOut_t xTimeOut;
\r
184 TickType_t ulRemainingTime;
\r
185 TickType_t ulReloadTime;
\r
188 /* Used in checksum calculation. */
\r
189 typedef union _xUnion32
\r
196 /* Used in checksum calculation. */
\r
197 typedef union _xUnionPtr
\r
204 /*-----------------------------------------------------------*/
\r
207 * The main TCP/IP stack processing task. This task receives commands/events
\r
208 * from the network hardware drivers and tasks that are using sockets. It also
\r
209 * maintains a set of protocol timers.
\r
211 static void prvIPTask( void *pvParameters );
\r
214 * Called when new data is available from the network interface.
\r
216 static void prvProcessEthernetPacket( NetworkBufferDescriptor_t * const pxNetworkBuffer );
\r
219 * Process incoming IP packets.
\r
221 static eFrameProcessingResult_t prvProcessIPPacket( const IPPacket_t * const pxIPPacket, NetworkBufferDescriptor_t * const pxNetworkBuffer );
\r
223 #if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) || ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
\r
225 * Process incoming ICMP packets.
\r
227 static eFrameProcessingResult_t prvProcessICMPPacket( ICMPPacket_t * const pxICMPPacket );
\r
228 #endif /* ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) || ( ipconfigSUPPORT_OUTGOING_PINGS == 1 ) */
\r
231 * Turns around an incoming ping request to convert it into a ping reply.
\r
233 #if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 )
\r
234 static eFrameProcessingResult_t prvProcessICMPEchoRequest( ICMPPacket_t * const pxICMPPacket );
\r
235 #endif /* ipconfigREPLY_TO_INCOMING_PINGS */
\r
238 * Processes incoming ping replies. The application callback function
\r
239 * vApplicationPingReplyHook() is called with the results.
\r
241 #if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
\r
242 static void prvProcessICMPEchoReply( ICMPPacket_t * const pxICMPPacket );
\r
243 #endif /* ipconfigSUPPORT_OUTGOING_PINGS */
\r
246 * Called to create a network connection when the stack is first started, or
\r
247 * when the network connection is lost.
\r
249 static void prvProcessNetworkDownEvent( void );
\r
252 * Checks the ARP, DHCP and TCP timers to see if any periodic or timeout
\r
253 * processing is required.
\r
255 static void prvCheckNetworkTimers( void );
\r
258 * Determine how long the IP task can sleep for, which depends on when the next
\r
259 * periodic or timeout processing must be performed.
\r
261 static TickType_t prvCalculateSleepTime( void );
\r
264 * The network card driver has received a packet. In the case that it is part
\r
265 * of a linked packet chain, walk through it to handle every message.
\r
267 static void prvHandleEthernetPacket( NetworkBufferDescriptor_t *pxBuffer );
\r
270 * Utility functions for the light weight IP timers.
\r
272 static void prvIPTimerStart( IPTimer_t *pxTimer, TickType_t xTime );
\r
273 static BaseType_t prvIPTimerCheck( IPTimer_t *pxTimer );
\r
274 static void prvIPTimerReload( IPTimer_t *pxTimer, TickType_t xTime );
\r
276 static eFrameProcessingResult_t prvAllowIPPacket( const IPPacket_t * const pxIPPacket,
\r
277 NetworkBufferDescriptor_t * const pxNetworkBuffer, UBaseType_t uxHeaderLength );
\r
279 /*-----------------------------------------------------------*/
\r
281 /* The queue used to pass events into the IP-task for processing. */
\r
282 QueueHandle_t xNetworkEventQueue = NULL;
\r
284 /*_RB_ Requires comment. */
\r
285 uint16_t usPacketIdentifier = 0U;
\r
287 /* For convenience, a MAC address of all 0xffs is defined const for quick
\r
289 const MACAddress_t xBroadcastMACAddress = { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };
\r
291 /* Structure that stores the netmask, gateway address and DNS server addresses. */
\r
292 NetworkAddressingParameters_t xNetworkAddressing = { 0, 0, 0, 0, 0 };
\r
294 /* Default values for the above struct in case DHCP
\r
295 does not lead to a confirmed request. */
\r
296 NetworkAddressingParameters_t xDefaultAddressing = { 0, 0, 0, 0, 0 };
\r
298 /* Used to ensure network down events cannot be missed when they cannot be
\r
299 posted to the network event queue because the network event queue is already
\r
301 static BaseType_t xNetworkDownEventPending = pdFALSE;
\r
303 /* Stores the handle of the task that handles the stack. The handle is used
\r
304 (indirectly) by some utility function to determine if the utility function is
\r
305 being called by a task (in which case it is ok to block) or by the IP task
\r
306 itself (in which case it is not ok to block). */
\r
307 static TaskHandle_t xIPTaskHandle = NULL;
\r
309 #if( ipconfigUSE_TCP != 0 )
\r
310 /* Set to a non-zero value if one or more TCP message have been processed
\r
311 within the last round. */
\r
312 static BaseType_t xProcessedTCPMessage;
\r
315 /* Simple set to pdTRUE or pdFALSE depending on whether the network is up or
\r
316 down (connected, not connected) respectively. */
\r
317 static BaseType_t xNetworkUp = pdFALSE;
\r
320 A timer for each of the following processes, all of which need attention on a
\r
322 1. ARP, to check its table entries
\r
323 2. DPHC, to send requests and to renew a reservation
\r
324 3. TCP, to check for timeouts, resends
\r
325 4. DNS, to check for timeouts when looking-up a domain.
\r
327 static IPTimer_t xARPTimer;
\r
328 #if( ipconfigUSE_DHCP != 0 )
\r
329 static IPTimer_t xDHCPTimer;
\r
331 #if( ipconfigUSE_TCP != 0 )
\r
332 static IPTimer_t xTCPTimer;
\r
334 #if( ipconfigDNS_USE_CALLBACKS != 0 )
\r
335 static IPTimer_t xDNSTimer;
\r
338 /* Set to pdTRUE when the IP task is ready to start processing packets. */
\r
339 static BaseType_t xIPTaskInitialised = pdFALSE;
\r
341 #if( ipconfigCHECK_IP_QUEUE_SPACE != 0 )
\r
342 /* Keep track of the lowest amount of space in 'xNetworkEventQueue'. */
\r
343 static UBaseType_t uxQueueMinimumSpace = ipconfigEVENT_QUEUE_LENGTH;
\r
346 /*-----------------------------------------------------------*/
\r
348 static void prvIPTask( void *pvParameters )
\r
350 IPStackEvent_t xReceivedEvent;
\r
351 TickType_t xNextIPSleep;
\r
352 FreeRTOS_Socket_t *pxSocket;
\r
353 struct freertos_sockaddr xAddress;
\r
355 /* Just to prevent compiler warnings about unused parameters. */
\r
356 ( void ) pvParameters;
\r
358 /* A possibility to set some additional task properties. */
\r
359 iptraceIP_TASK_STARTING();
\r
361 /* Generate a dummy message to say that the network connection has gone
\r
362 down. This will cause this task to initialise the network interface. After
\r
363 this it is the responsibility of the network interface hardware driver to
\r
364 send this message if a previously connected network is disconnected. */
\r
365 FreeRTOS_NetworkDown();
\r
367 #if( ipconfigUSE_TCP == 1 )
\r
369 /* Initialise the TCP timer. */
\r
370 prvIPTimerReload( &xTCPTimer, pdMS_TO_TICKS( ipTCP_TIMER_PERIOD_MS ) );
\r
374 /* Initialisation is complete and events can now be processed. */
\r
375 xIPTaskInitialised = pdTRUE;
\r
377 FreeRTOS_debug_printf( ( "prvIPTask started\n" ) );
\r
379 /* Loop, processing IP events. */
\r
382 ipconfigWATCHDOG_TIMER();
\r
384 /* Check the ARP, DHCP and TCP timers to see if there is any periodic
\r
385 or timeout processing to perform. */
\r
386 prvCheckNetworkTimers();
\r
388 /* Calculate the acceptable maximum sleep time. */
\r
389 xNextIPSleep = prvCalculateSleepTime();
\r
391 /* Wait until there is something to do. The event is initialised to "no
\r
392 event" in case the following call exits due to a time out rather than a
\r
393 message being received. */
\r
394 xReceivedEvent.eEventType = eNoEvent;
\r
395 xQueueReceive( xNetworkEventQueue, ( void * ) &xReceivedEvent, xNextIPSleep );
\r
397 #if( ipconfigCHECK_IP_QUEUE_SPACE != 0 )
\r
399 if( xReceivedEvent.eEventType != eNoEvent )
\r
401 UBaseType_t uxCount;
\r
403 uxCount = uxQueueSpacesAvailable( xNetworkEventQueue );
\r
404 if( uxQueueMinimumSpace > uxCount )
\r
406 uxQueueMinimumSpace = uxCount;
\r
410 #endif /* ipconfigCHECK_IP_QUEUE_SPACE */
\r
412 iptraceNETWORK_EVENT_RECEIVED( xReceivedEvent.eEventType );
\r
414 switch( xReceivedEvent.eEventType )
\r
416 case eNetworkDownEvent :
\r
417 /* Attempt to establish a connection. */
\r
418 xNetworkUp = pdFALSE;
\r
419 prvProcessNetworkDownEvent();
\r
422 case eNetworkRxEvent:
\r
423 /* The network hardware driver has received a new packet. A
\r
424 pointer to the received buffer is located in the pvData member
\r
425 of the received event structure. */
\r
426 prvHandleEthernetPacket( ( NetworkBufferDescriptor_t * ) ( xReceivedEvent.pvData ) );
\r
429 case eARPTimerEvent :
\r
430 /* The ARP timer has expired, process the ARP cache. */
\r
434 case eSocketBindEvent:
\r
435 /* FreeRTOS_bind (a user API) wants the IP-task to bind a socket
\r
436 to a port. The port number is communicated in the socket field
\r
437 usLocalPort. vSocketBind() will actually bind the socket and the
\r
438 API will unblock as soon as the eSOCKET_BOUND event is
\r
440 pxSocket = ( FreeRTOS_Socket_t * ) ( xReceivedEvent.pvData );
\r
441 xAddress.sin_addr = 0u; /* For the moment. */
\r
442 xAddress.sin_port = FreeRTOS_ntohs( pxSocket->usLocalPort );
\r
443 pxSocket->usLocalPort = 0u;
\r
444 vSocketBind( pxSocket, &xAddress, sizeof( xAddress ), pdFALSE );
\r
446 /* Before 'eSocketBindEvent' was sent it was tested that
\r
447 ( xEventGroup != NULL ) so it can be used now to wake up the
\r
449 pxSocket->xEventBits |= eSOCKET_BOUND;
\r
450 vSocketWakeUpUser( pxSocket );
\r
453 case eSocketCloseEvent :
\r
454 /* The user API FreeRTOS_closesocket() has sent a message to the
\r
455 IP-task to actually close a socket. This is handled in
\r
456 vSocketClose(). As the socket gets closed, there is no way to
\r
457 report back to the API, so the API won't wait for the result */
\r
458 vSocketClose( ( FreeRTOS_Socket_t * ) ( xReceivedEvent.pvData ) );
\r
461 case eStackTxEvent :
\r
462 /* The network stack has generated a packet to send. A
\r
463 pointer to the generated buffer is located in the pvData
\r
464 member of the received event structure. */
\r
465 vProcessGeneratedUDPPacket( ( NetworkBufferDescriptor_t * ) ( xReceivedEvent.pvData ) );
\r
469 /* The DHCP state machine needs processing. */
\r
470 #if( ipconfigUSE_DHCP == 1 )
\r
472 vDHCPProcess( pdFALSE );
\r
474 #endif /* ipconfigUSE_DHCP */
\r
477 case eSocketSelectEvent :
\r
478 /* FreeRTOS_select() has got unblocked by a socket event,
\r
479 vSocketSelect() will check which sockets actually have an event
\r
480 and update the socket field xSocketBits. */
\r
481 #if( ipconfigSUPPORT_SELECT_FUNCTION == 1 )
\r
483 vSocketSelect( ( SocketSelect_t * ) ( xReceivedEvent.pvData ) );
\r
485 #endif /* ipconfigSUPPORT_SELECT_FUNCTION == 1 */
\r
488 case eSocketSignalEvent :
\r
489 #if( ipconfigSUPPORT_SIGNALS != 0 )
\r
491 /* Some task wants to signal the user of this socket in
\r
492 order to interrupt a call to recv() or a call to select(). */
\r
493 FreeRTOS_SignalSocket( ( Socket_t ) xReceivedEvent.pvData );
\r
495 #endif /* ipconfigSUPPORT_SIGNALS */
\r
498 case eTCPTimerEvent :
\r
499 #if( ipconfigUSE_TCP == 1 )
\r
501 /* Simply mark the TCP timer as expired so it gets processed
\r
502 the next time prvCheckNetworkTimers() is called. */
\r
503 xTCPTimer.bExpired = pdTRUE_UNSIGNED;
\r
505 #endif /* ipconfigUSE_TCP */
\r
508 case eTCPAcceptEvent:
\r
509 /* The API FreeRTOS_accept() was called, the IP-task will now
\r
510 check if the listening socket (communicated in pvData) actually
\r
511 received a new connection. */
\r
512 #if( ipconfigUSE_TCP == 1 )
\r
514 pxSocket = ( FreeRTOS_Socket_t * ) ( xReceivedEvent.pvData );
\r
516 if( xTCPCheckNewClient( pxSocket ) != pdFALSE )
\r
518 pxSocket->xEventBits |= eSOCKET_ACCEPT;
\r
519 vSocketWakeUpUser( pxSocket );
\r
522 #endif /* ipconfigUSE_TCP */
\r
526 /* FreeRTOS_netstat() was called to have the IP-task print an
\r
527 overview of all sockets and their connections */
\r
528 #if( ( ipconfigUSE_TCP == 1 ) && ( ipconfigHAS_PRINTF == 1 ) )
\r
532 #endif /* ipconfigUSE_TCP */
\r
536 /* Should not get here. */
\r
540 if( xNetworkDownEventPending != pdFALSE )
\r
542 /* A network down event could not be posted to the network event
\r
543 queue because the queue was full. Try posting again. */
\r
544 FreeRTOS_NetworkDown();
\r
548 /*-----------------------------------------------------------*/
\r
550 BaseType_t xIsCallingFromIPTask( void )
\r
552 BaseType_t xReturn;
\r
554 if( xTaskGetCurrentTaskHandle() == xIPTaskHandle )
\r
565 /*-----------------------------------------------------------*/
\r
567 static void prvHandleEthernetPacket( NetworkBufferDescriptor_t *pxBuffer )
\r
569 #if( ipconfigUSE_LINKED_RX_MESSAGES == 0 )
\r
571 /* When ipconfigUSE_LINKED_RX_MESSAGES is not set to 0 then only one
\r
572 buffer will be sent at a time. This is the default way for +TCP to pass
\r
573 messages from the MAC to the TCP/IP stack. */
\r
574 prvProcessEthernetPacket( pxBuffer );
\r
576 #else /* ipconfigUSE_LINKED_RX_MESSAGES */
\r
578 NetworkBufferDescriptor_t *pxNextBuffer;
\r
580 /* An optimisation that is useful when there is high network traffic.
\r
581 Instead of passing received packets into the IP task one at a time the
\r
582 network interface can chain received packets together and pass them into
\r
583 the IP task in one go. The packets are chained using the pxNextBuffer
\r
584 member. The loop below walks through the chain processing each packet
\r
585 in the chain in turn. */
\r
588 /* Store a pointer to the buffer after pxBuffer for use later on. */
\r
589 pxNextBuffer = pxBuffer->pxNextBuffer;
\r
591 /* Make it NULL to avoid using it later on. */
\r
592 pxBuffer->pxNextBuffer = NULL;
\r
594 prvProcessEthernetPacket( pxBuffer );
\r
595 pxBuffer = pxNextBuffer;
\r
597 /* While there is another packet in the chain. */
\r
598 } while( pxBuffer != NULL );
\r
600 #endif /* ipconfigUSE_LINKED_RX_MESSAGES */
\r
602 /*-----------------------------------------------------------*/
\r
604 static TickType_t prvCalculateSleepTime( void )
\r
606 TickType_t xMaximumSleepTime;
\r
608 /* Start with the maximum sleep time, then check this against the remaining
\r
609 time in any other timers that are active. */
\r
610 xMaximumSleepTime = ipconfigMAX_IP_TASK_SLEEP_TIME;
\r
612 if( xARPTimer.bActive != pdFALSE_UNSIGNED )
\r
614 if( xARPTimer.ulRemainingTime < xMaximumSleepTime )
\r
616 xMaximumSleepTime = xARPTimer.ulReloadTime;
\r
620 #if( ipconfigUSE_DHCP == 1 )
\r
622 if( xDHCPTimer.bActive != pdFALSE_UNSIGNED )
\r
624 if( xDHCPTimer.ulRemainingTime < xMaximumSleepTime )
\r
626 xMaximumSleepTime = xDHCPTimer.ulRemainingTime;
\r
630 #endif /* ipconfigUSE_DHCP */
\r
632 #if( ipconfigUSE_TCP == 1 )
\r
634 if( xTCPTimer.ulRemainingTime < xMaximumSleepTime )
\r
636 xMaximumSleepTime = xTCPTimer.ulRemainingTime;
\r
641 #if( ipconfigDNS_USE_CALLBACKS != 0 )
\r
643 if( xDNSTimer.bActive != pdFALSE )
\r
645 if( xDNSTimer.ulRemainingTime < xMaximumSleepTime )
\r
647 xMaximumSleepTime = xDNSTimer.ulRemainingTime;
\r
653 return xMaximumSleepTime;
\r
655 /*-----------------------------------------------------------*/
\r
657 static void prvCheckNetworkTimers( void )
\r
659 /* Is it time for ARP processing? */
\r
660 if( prvIPTimerCheck( &xARPTimer ) != pdFALSE )
\r
662 xSendEventToIPTask( eARPTimerEvent );
\r
665 #if( ipconfigUSE_DHCP == 1 )
\r
667 /* Is it time for DHCP processing? */
\r
668 if( prvIPTimerCheck( &xDHCPTimer ) != pdFALSE )
\r
670 xSendEventToIPTask( eDHCPEvent );
\r
673 #endif /* ipconfigUSE_DHCP */
\r
675 #if( ipconfigDNS_USE_CALLBACKS != 0 )
\r
677 extern void vDNSCheckCallBack( void *pvSearchID );
\r
679 /* Is it time for DNS processing? */
\r
680 if( prvIPTimerCheck( &xDNSTimer ) != pdFALSE )
\r
682 vDNSCheckCallBack( NULL );
\r
685 #endif /* ipconfigDNS_USE_CALLBACKS */
\r
687 #if( ipconfigUSE_TCP == 1 )
\r
689 BaseType_t xWillSleep;
\r
690 /* xStart keeps a copy of the last time this function was active,
\r
691 and during every call it will be updated with xTaskGetTickCount()
\r
692 '0' means: not yet initialised (although later '0' might be returned
\r
693 by xTaskGetTickCount(), which is no problem). */
\r
694 static TickType_t xStart = ( TickType_t ) 0;
\r
695 TickType_t xTimeNow, xNextTime;
\r
696 BaseType_t xCheckTCPSockets;
\r
697 extern uint32_t ulNextInitialSequenceNumber;
\r
699 if( uxQueueMessagesWaiting( xNetworkEventQueue ) == 0u )
\r
701 xWillSleep = pdTRUE;
\r
705 xWillSleep = pdFALSE;
\r
708 xTimeNow = xTaskGetTickCount();
\r
710 if( xStart != ( TickType_t ) 0 )
\r
712 /* It is advised to increment the Initial Sequence Number every 4
\r
713 microseconds which makes 250 times per ms. This will make it harder
\r
714 for a third party to 'guess' our sequence number and 'take over'
\r
715 a TCP connection */
\r
716 ulNextInitialSequenceNumber += ipINITIAL_SEQUENCE_NUMBER_FACTOR * ( ( xTimeNow - xStart ) * portTICK_PERIOD_MS );
\r
721 /* Sockets need to be checked if the TCP timer has expired. */
\r
722 xCheckTCPSockets = prvIPTimerCheck( &xTCPTimer );
\r
724 /* Sockets will also be checked if there are TCP messages but the
\r
725 message queue is empty (indicated by xWillSleep being true). */
\r
726 if( ( xProcessedTCPMessage != pdFALSE ) && ( xWillSleep != pdFALSE ) )
\r
728 xCheckTCPSockets = pdTRUE;
\r
731 if( xCheckTCPSockets != pdFALSE )
\r
733 /* Attend to the sockets, returning the period after which the
\r
734 check must be repeated. */
\r
735 xNextTime = xTCPTimerCheck( xWillSleep );
\r
736 prvIPTimerStart( &xTCPTimer, xNextTime );
\r
737 xProcessedTCPMessage = 0;
\r
740 #endif /* ipconfigUSE_TCP == 1 */
\r
742 /*-----------------------------------------------------------*/
\r
744 static void prvIPTimerStart( IPTimer_t *pxTimer, TickType_t xTime )
\r
746 vTaskSetTimeOutState( &pxTimer->xTimeOut );
\r
747 pxTimer->ulRemainingTime = xTime;
\r
749 if( xTime == ( TickType_t ) 0 )
\r
751 pxTimer->bExpired = pdTRUE_UNSIGNED;
\r
755 pxTimer->bExpired = pdFALSE_UNSIGNED;
\r
758 pxTimer->bActive = pdTRUE_UNSIGNED;
\r
760 /*-----------------------------------------------------------*/
\r
762 static void prvIPTimerReload( IPTimer_t *pxTimer, TickType_t xTime )
\r
764 pxTimer->ulReloadTime = xTime;
\r
765 prvIPTimerStart( pxTimer, xTime );
\r
767 /*-----------------------------------------------------------*/
\r
769 static BaseType_t prvIPTimerCheck( IPTimer_t *pxTimer )
\r
771 BaseType_t xReturn;
\r
773 if( pxTimer->bActive == pdFALSE_UNSIGNED )
\r
775 /* The timer is not enabled. */
\r
780 /* The timer might have set the bExpired flag already, if not, check the
\r
781 value of xTimeOut against ulRemainingTime. */
\r
782 if( ( pxTimer->bExpired != pdFALSE_UNSIGNED ) ||
\r
783 ( xTaskCheckForTimeOut( &( pxTimer->xTimeOut ), &( pxTimer->ulRemainingTime ) ) != pdFALSE ) )
\r
785 prvIPTimerStart( pxTimer, pxTimer->ulReloadTime );
\r
796 /*-----------------------------------------------------------*/
\r
798 void FreeRTOS_NetworkDown( void )
\r
800 static const IPStackEvent_t xNetworkDownEvent = { eNetworkDownEvent, NULL };
\r
801 const TickType_t xDontBlock = ( TickType_t ) 0;
\r
803 /* Simply send the network task the appropriate event. */
\r
804 if( xSendEventStructToIPTask( &xNetworkDownEvent, xDontBlock ) != pdPASS )
\r
806 /* Could not send the message, so it is still pending. */
\r
807 xNetworkDownEventPending = pdTRUE;
\r
811 /* Message was sent so it is not pending. */
\r
812 xNetworkDownEventPending = pdFALSE;
\r
815 iptraceNETWORK_DOWN();
\r
817 /*-----------------------------------------------------------*/
\r
819 BaseType_t FreeRTOS_NetworkDownFromISR( void )
\r
821 static const IPStackEvent_t xNetworkDownEvent = { eNetworkDownEvent, NULL };
\r
822 BaseType_t xHigherPriorityTaskWoken = pdFALSE;
\r
824 /* Simply send the network task the appropriate event. */
\r
825 if( xQueueSendToBackFromISR( xNetworkEventQueue, &xNetworkDownEvent, &xHigherPriorityTaskWoken ) != pdPASS )
\r
827 xNetworkDownEventPending = pdTRUE;
\r
831 xNetworkDownEventPending = pdFALSE;
\r
834 iptraceNETWORK_DOWN();
\r
836 return xHigherPriorityTaskWoken;
\r
838 /*-----------------------------------------------------------*/
\r
840 void *FreeRTOS_GetUDPPayloadBuffer( size_t xRequestedSizeBytes, TickType_t xBlockTimeTicks )
\r
842 NetworkBufferDescriptor_t *pxNetworkBuffer;
\r
845 /* Cap the block time. The reason for this is explained where
\r
846 ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS is defined (assuming an official
\r
847 FreeRTOSIPConfig.h header file is being used). */
\r
848 if( xBlockTimeTicks > ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS )
\r
850 xBlockTimeTicks = ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS;
\r
853 /* Obtain a network buffer with the required amount of storage. */
\r
854 pxNetworkBuffer = pxGetNetworkBufferWithDescriptor( sizeof( UDPPacket_t ) + xRequestedSizeBytes, xBlockTimeTicks );
\r
856 if( pxNetworkBuffer != NULL )
\r
858 /* Leave space for the UPD header. */
\r
859 pvReturn = ( void * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipUDP_PAYLOAD_OFFSET_IPv4 ] );
\r
866 return ( void * ) pvReturn;
\r
868 /*-----------------------------------------------------------*/
\r
870 NetworkBufferDescriptor_t *pxDuplicateNetworkBufferWithDescriptor( NetworkBufferDescriptor_t * const pxNetworkBuffer,
\r
871 BaseType_t xNewLength )
\r
873 NetworkBufferDescriptor_t * pxNewBuffer;
\r
875 /* This function is only used when 'ipconfigZERO_COPY_TX_DRIVER' is set to 1.
\r
876 The transmit routine wants to have ownership of the network buffer
\r
877 descriptor, because it will pass the buffer straight to DMA. */
\r
878 pxNewBuffer = pxGetNetworkBufferWithDescriptor( ( size_t ) xNewLength, ( TickType_t ) 0 );
\r
880 if( pxNewBuffer != NULL )
\r
882 pxNewBuffer->ulIPAddress = pxNetworkBuffer->ulIPAddress;
\r
883 pxNewBuffer->usPort = pxNetworkBuffer->usPort;
\r
884 pxNewBuffer->usBoundPort = pxNetworkBuffer->usBoundPort;
\r
885 memcpy( pxNewBuffer->pucEthernetBuffer, pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength );
\r
888 return pxNewBuffer;
\r
890 /*-----------------------------------------------------------*/
\r
892 #if( ipconfigZERO_COPY_TX_DRIVER != 0 ) || ( ipconfigZERO_COPY_RX_DRIVER != 0 )
\r
894 NetworkBufferDescriptor_t *pxPacketBuffer_to_NetworkBuffer( const void *pvBuffer )
\r
896 uint8_t *pucBuffer;
\r
897 NetworkBufferDescriptor_t *pxResult;
\r
899 if( pvBuffer == NULL )
\r
905 /* Obtain the network buffer from the zero copy pointer. */
\r
906 pucBuffer = ( uint8_t * ) pvBuffer;
\r
908 /* The input here is a pointer to a payload buffer. Subtract the
\r
909 size of the header in the network buffer, usually 8 + 2 bytes. */
\r
910 pucBuffer -= ipBUFFER_PADDING;
\r
912 /* Here a pointer was placed to the network descriptor. As a
\r
913 pointer is dereferenced, make sure it is well aligned. */
\r
914 if( ( ( ( uint32_t ) pucBuffer ) & ( sizeof( pucBuffer ) - ( size_t ) 1 ) ) == ( uint32_t ) 0 )
\r
916 pxResult = * ( ( NetworkBufferDescriptor_t ** ) pucBuffer );
\r
927 #endif /* ipconfigZERO_COPY_TX_DRIVER != 0 */
\r
928 /*-----------------------------------------------------------*/
\r
930 NetworkBufferDescriptor_t *pxUDPPayloadBuffer_to_NetworkBuffer( void *pvBuffer )
\r
932 uint8_t *pucBuffer;
\r
933 NetworkBufferDescriptor_t *pxResult;
\r
935 if( pvBuffer == NULL )
\r
941 /* Obtain the network buffer from the zero copy pointer. */
\r
942 pucBuffer = ( uint8_t * ) pvBuffer;
\r
944 /* The input here is a pointer to a payload buffer. Subtract
\r
945 the total size of a UDP/IP header plus the size of the header in
\r
946 the network buffer, usually 8 + 2 bytes. */
\r
947 pucBuffer -= ( sizeof( UDPPacket_t ) + ipBUFFER_PADDING );
\r
949 /* Here a pointer was placed to the network descriptor,
\r
950 As a pointer is dereferenced, make sure it is well aligned */
\r
951 if( ( ( ( uint32_t ) pucBuffer ) & ( sizeof( pucBuffer ) - 1 ) ) == 0 )
\r
953 /* The following statement may trigger a:
\r
954 warning: cast increases required alignment of target type [-Wcast-align].
\r
955 It has been confirmed though that the alignment is suitable. */
\r
956 pxResult = * ( ( NetworkBufferDescriptor_t ** ) pucBuffer );
\r
966 /*-----------------------------------------------------------*/
\r
968 void FreeRTOS_ReleaseUDPPayloadBuffer( void *pvBuffer )
\r
970 vReleaseNetworkBufferAndDescriptor( pxUDPPayloadBuffer_to_NetworkBuffer( pvBuffer ) );
\r
972 /*-----------------------------------------------------------*/
\r
974 /*_RB_ Should we add an error or assert if the task priorities are set such that the servers won't function as expected? */
\r
975 /*_HT_ There was a bug in FreeRTOS_TCP_IP.c that only occurred when the applications' priority was too high.
\r
976 As that bug has been repaired, there is not an urgent reason to warn.
\r
977 It is better though to use the advised priority scheme. */
\r
978 BaseType_t FreeRTOS_IPInit( const uint8_t ucIPAddress[ ipIP_ADDRESS_LENGTH_BYTES ], const uint8_t ucNetMask[ ipIP_ADDRESS_LENGTH_BYTES ], const uint8_t ucGatewayAddress[ ipIP_ADDRESS_LENGTH_BYTES ], const uint8_t ucDNSServerAddress[ ipIP_ADDRESS_LENGTH_BYTES ], const uint8_t ucMACAddress[ ipMAC_ADDRESS_LENGTH_BYTES ] )
\r
980 BaseType_t xReturn = pdFALSE;
\r
982 /* This function should only be called once. */
\r
983 configASSERT( xIPIsNetworkTaskReady() == pdFALSE );
\r
984 configASSERT( xNetworkEventQueue == NULL );
\r
985 configASSERT( xIPTaskHandle == NULL );
\r
987 /* Check structure packing is correct. */
\r
988 configASSERT( sizeof( EthernetHeader_t ) == ipEXPECTED_EthernetHeader_t_SIZE );
\r
989 configASSERT( sizeof( ARPHeader_t ) == ipEXPECTED_ARPHeader_t_SIZE );
\r
990 configASSERT( sizeof( IPHeader_t ) == ipEXPECTED_IPHeader_t_SIZE );
\r
991 configASSERT( sizeof( ICMPHeader_t ) == ipEXPECTED_ICMPHeader_t_SIZE );
\r
992 configASSERT( sizeof( UDPHeader_t ) == ipEXPECTED_UDPHeader_t_SIZE );
\r
994 /* Attempt to create the queue used to communicate with the IP task. */
\r
995 xNetworkEventQueue = xQueueCreate( ( UBaseType_t ) ipconfigEVENT_QUEUE_LENGTH, ( UBaseType_t ) sizeof( IPStackEvent_t ) );
\r
996 configASSERT( xNetworkEventQueue );
\r
998 if( xNetworkEventQueue != NULL )
\r
1000 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
1002 /* A queue registry is normally used to assist a kernel aware
\r
1003 debugger. If one is in use then it will be helpful for the debugger
\r
1004 to show information about the network event queue. */
\r
1005 vQueueAddToRegistry( xNetworkEventQueue, "NetEvnt" );
\r
1007 #endif /* configQUEUE_REGISTRY_SIZE */
\r
1009 if( xNetworkBuffersInitialise() == pdPASS )
\r
1011 /* Store the local IP and MAC address. */
\r
1012 xNetworkAddressing.ulDefaultIPAddress = FreeRTOS_inet_addr_quick( ucIPAddress[ 0 ], ucIPAddress[ 1 ], ucIPAddress[ 2 ], ucIPAddress[ 3 ] );
\r
1013 xNetworkAddressing.ulNetMask = FreeRTOS_inet_addr_quick( ucNetMask[ 0 ], ucNetMask[ 1 ], ucNetMask[ 2 ], ucNetMask[ 3 ] );
\r
1014 xNetworkAddressing.ulGatewayAddress = FreeRTOS_inet_addr_quick( ucGatewayAddress[ 0 ], ucGatewayAddress[ 1 ], ucGatewayAddress[ 2 ], ucGatewayAddress[ 3 ] );
\r
1015 xNetworkAddressing.ulDNSServerAddress = FreeRTOS_inet_addr_quick( ucDNSServerAddress[ 0 ], ucDNSServerAddress[ 1 ], ucDNSServerAddress[ 2 ], ucDNSServerAddress[ 3 ] );
\r
1016 xNetworkAddressing.ulBroadcastAddress = ( xNetworkAddressing.ulDefaultIPAddress & xNetworkAddressing.ulNetMask ) | ~xNetworkAddressing.ulNetMask;
\r
1018 memcpy( &xDefaultAddressing, &xNetworkAddressing, sizeof( xDefaultAddressing ) );
\r
1020 #if ipconfigUSE_DHCP == 1
\r
1022 /* The IP address is not set until DHCP completes. */
\r
1023 *ipLOCAL_IP_ADDRESS_POINTER = 0x00UL;
\r
1027 /* The IP address is set from the value passed in. */
\r
1028 *ipLOCAL_IP_ADDRESS_POINTER = xNetworkAddressing.ulDefaultIPAddress;
\r
1030 /* Added to prevent ARP flood to gateway. Ensure the
\r
1031 gateway is on the same subnet as the IP address. */
\r
1032 if( xNetworkAddressing.ulGatewayAddress != 0ul )
\r
1034 configASSERT( ( ( *ipLOCAL_IP_ADDRESS_POINTER ) & xNetworkAddressing.ulNetMask ) == ( xNetworkAddressing.ulGatewayAddress & xNetworkAddressing.ulNetMask ) );
\r
1037 #endif /* ipconfigUSE_DHCP == 1 */
\r
1039 /* The MAC address is stored in the start of the default packet
\r
1040 header fragment, which is used when sending UDP packets. */
\r
1041 memcpy( ( void * ) ipLOCAL_MAC_ADDRESS, ( void * ) ucMACAddress, ( size_t ) ipMAC_ADDRESS_LENGTH_BYTES );
\r
1043 /* Prepare the sockets interface. */
\r
1044 vNetworkSocketsInit();
\r
1046 /* Create the task that processes Ethernet and stack events. */
\r
1047 xReturn = xTaskCreate( prvIPTask, "IP-task", ( uint16_t ) ipconfigIP_TASK_STACK_SIZE_WORDS, NULL, ( UBaseType_t ) ipconfigIP_TASK_PRIORITY, &xIPTaskHandle );
\r
1051 FreeRTOS_debug_printf( ( "FreeRTOS_IPInit: xNetworkBuffersInitialise() failed\n") );
\r
1054 vQueueDelete( xNetworkEventQueue );
\r
1055 xNetworkEventQueue = NULL;
\r
1060 FreeRTOS_debug_printf( ( "FreeRTOS_IPInit: Network event queue could not be created\n") );
\r
1065 /*-----------------------------------------------------------*/
\r
1067 void FreeRTOS_GetAddressConfiguration( uint32_t *pulIPAddress, uint32_t *pulNetMask, uint32_t *pulGatewayAddress, uint32_t *pulDNSServerAddress )
\r
1069 /* Return the address configuration to the caller. */
\r
1071 if( pulIPAddress != NULL )
\r
1073 *pulIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
\r
1076 if( pulNetMask != NULL )
\r
1078 *pulNetMask = xNetworkAddressing.ulNetMask;
\r
1081 if( pulGatewayAddress != NULL )
\r
1083 *pulGatewayAddress = xNetworkAddressing.ulGatewayAddress;
\r
1086 if( pulDNSServerAddress != NULL )
\r
1088 *pulDNSServerAddress = xNetworkAddressing.ulDNSServerAddress;
\r
1091 /*-----------------------------------------------------------*/
\r
1093 void FreeRTOS_SetAddressConfiguration( const uint32_t *pulIPAddress, const uint32_t *pulNetMask, const uint32_t *pulGatewayAddress, const uint32_t *pulDNSServerAddress )
\r
1095 /* Update the address configuration. */
\r
1097 if( pulIPAddress != NULL )
\r
1099 *ipLOCAL_IP_ADDRESS_POINTER = *pulIPAddress;
\r
1102 if( pulNetMask != NULL )
\r
1104 xNetworkAddressing.ulNetMask = *pulNetMask;
\r
1107 if( pulGatewayAddress != NULL )
\r
1109 xNetworkAddressing.ulGatewayAddress = *pulGatewayAddress;
\r
1112 if( pulDNSServerAddress != NULL )
\r
1114 xNetworkAddressing.ulDNSServerAddress = *pulDNSServerAddress;
\r
1117 /*-----------------------------------------------------------*/
\r
1119 #if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
\r
1121 BaseType_t FreeRTOS_SendPingRequest( uint32_t ulIPAddress, size_t xNumberOfBytesToSend, TickType_t xBlockTimeTicks )
\r
1123 NetworkBufferDescriptor_t *pxNetworkBuffer;
\r
1124 ICMPHeader_t *pxICMPHeader;
\r
1125 BaseType_t xReturn = pdFAIL;
\r
1126 static uint16_t usSequenceNumber = 0;
\r
1128 IPStackEvent_t xStackTxEvent = { eStackTxEvent, NULL };
\r
1130 if( (xNumberOfBytesToSend >= 1 ) && ( xNumberOfBytesToSend < ( ( ipconfigNETWORK_MTU - sizeof( IPHeader_t ) ) - sizeof( ICMPHeader_t ) ) ) && ( uxGetNumberOfFreeNetworkBuffers() >= 3 ) )
\r
1132 pxNetworkBuffer = pxGetNetworkBufferWithDescriptor( xNumberOfBytesToSend + sizeof( ICMPPacket_t ), xBlockTimeTicks );
\r
1134 if( pxNetworkBuffer != NULL )
\r
1136 pxICMPHeader = ( ICMPHeader_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipIP_PAYLOAD_OFFSET ] );
\r
1137 usSequenceNumber++;
\r
1139 /* Fill in the basic header information. */
\r
1140 pxICMPHeader->ucTypeOfMessage = ipICMP_ECHO_REQUEST;
\r
1141 pxICMPHeader->ucTypeOfService = 0;
\r
1142 pxICMPHeader->usIdentifier = usSequenceNumber;
\r
1143 pxICMPHeader->usSequenceNumber = usSequenceNumber;
\r
1145 /* Find the start of the data. */
\r
1146 pucChar = ( uint8_t * ) pxICMPHeader;
\r
1147 pucChar += sizeof( ICMPHeader_t );
\r
1149 /* Just memset the data to a fixed value. */
\r
1150 memset( ( void * ) pucChar, ( int ) ipECHO_DATA_FILL_BYTE, xNumberOfBytesToSend );
\r
1152 /* The message is complete, IP and checksum's are handled by
\r
1153 vProcessGeneratedUDPPacket */
\r
1154 pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] = FREERTOS_SO_UDPCKSUM_OUT;
\r
1155 pxNetworkBuffer->ulIPAddress = ulIPAddress;
\r
1156 pxNetworkBuffer->usPort = ipPACKET_CONTAINS_ICMP_DATA;
\r
1157 pxNetworkBuffer->xDataLength = xNumberOfBytesToSend + sizeof( ICMPHeader_t );
\r
1159 /* Send to the stack. */
\r
1160 xStackTxEvent.pvData = pxNetworkBuffer;
\r
1162 if( xSendEventStructToIPTask( &xStackTxEvent, xBlockTimeTicks) != pdPASS )
\r
1164 vReleaseNetworkBufferAndDescriptor( pxNetworkBuffer );
\r
1165 iptraceSTACK_TX_EVENT_LOST( ipSTACK_TX_EVENT );
\r
1169 xReturn = usSequenceNumber;
\r
1175 /* The requested number of bytes will not fit in the available space
\r
1176 in the network buffer. */
\r
1182 #endif /* ipconfigSUPPORT_OUTGOING_PINGS == 1 */
\r
1183 /*-----------------------------------------------------------*/
\r
1185 BaseType_t xSendEventToIPTask( eIPEvent_t eEvent )
\r
1187 IPStackEvent_t xEventMessage;
\r
1188 const TickType_t xDontBlock = ( TickType_t ) 0;
\r
1190 xEventMessage.eEventType = eEvent;
\r
1191 xEventMessage.pvData = ( void* )NULL;
\r
1193 return xSendEventStructToIPTask( &xEventMessage, xDontBlock );
\r
1195 /*-----------------------------------------------------------*/
\r
1197 BaseType_t xSendEventStructToIPTask( const IPStackEvent_t *pxEvent, TickType_t xTimeout )
\r
1199 BaseType_t xReturn, xSendMessage;
\r
1201 if( ( xIPIsNetworkTaskReady() == pdFALSE ) && ( pxEvent->eEventType != eNetworkDownEvent ) )
\r
1203 /* Only allow eNetworkDownEvent events if the IP task is not ready
\r
1204 yet. Not going to attempt to send the message so the send failed. */
\r
1209 xSendMessage = pdTRUE;
\r
1211 #if( ipconfigUSE_TCP == 1 )
\r
1213 if( pxEvent->eEventType == eTCPTimerEvent )
\r
1215 /* TCP timer events are sent to wake the timer task when
\r
1216 xTCPTimer has expired, but there is no point sending them if the
\r
1217 IP task is already awake processing other message. */
\r
1218 xTCPTimer.bExpired = pdTRUE_UNSIGNED;
\r
1220 if( uxQueueMessagesWaiting( xNetworkEventQueue ) != 0u )
\r
1222 /* Not actually going to send the message but this is not a
\r
1223 failure as the message didn't need to be sent. */
\r
1224 xSendMessage = pdFALSE;
\r
1228 #endif /* ipconfigUSE_TCP */
\r
1230 if( xSendMessage != pdFALSE )
\r
1232 /* The IP task cannot block itself while waiting for itself to
\r
1234 if( ( xIsCallingFromIPTask() == pdTRUE ) && ( xTimeout > ( TickType_t ) 0 ) )
\r
1236 xTimeout = ( TickType_t ) 0;
\r
1239 xReturn = xQueueSendToBack( xNetworkEventQueue, pxEvent, xTimeout );
\r
1241 if( xReturn == pdFAIL )
\r
1243 /* A message should have been sent to the IP task, but wasn't. */
\r
1244 FreeRTOS_debug_printf( ( "xSendEventStructToIPTask: CAN NOT ADD %d\n", pxEvent->eEventType ) );
\r
1245 iptraceSTACK_TX_EVENT_LOST( pxEvent->eEventType );
\r
1250 /* It was not necessary to send the message to process the event so
\r
1251 even though the message was not sent the call was successful. */
\r
1258 /*-----------------------------------------------------------*/
\r
1260 eFrameProcessingResult_t eConsiderFrameForProcessing( const uint8_t * const pucEthernetBuffer )
\r
1262 eFrameProcessingResult_t eReturn;
\r
1263 const EthernetHeader_t *pxEthernetHeader;
\r
1265 pxEthernetHeader = ( const EthernetHeader_t * ) pucEthernetBuffer;
\r
1267 if( memcmp( ( void * ) ipLOCAL_MAC_ADDRESS, ( void * ) &( pxEthernetHeader->xDestinationAddress ), sizeof( MACAddress_t ) ) == 0 )
\r
1269 /* The packet was directed to this node directly - process it. */
\r
1270 eReturn = eProcessBuffer;
\r
1272 else if( memcmp( ( void * ) xBroadcastMACAddress.ucBytes, ( void * ) pxEthernetHeader->xDestinationAddress.ucBytes, sizeof( MACAddress_t ) ) == 0 )
\r
1274 /* The packet was a broadcast - process it. */
\r
1275 eReturn = eProcessBuffer;
\r
1278 #if( ipconfigUSE_LLMNR == 1 )
\r
1279 if( memcmp( ( void * ) xLLMNR_MacAdress.ucBytes, ( void * ) pxEthernetHeader->xDestinationAddress.ucBytes, sizeof( MACAddress_t ) ) == 0 )
\r
1281 /* The packet is a request for LLMNR - process it. */
\r
1282 eReturn = eProcessBuffer;
\r
1285 #endif /* ipconfigUSE_LLMNR */
\r
1287 /* The packet was not a broadcast, or for this node, just release
\r
1288 the buffer without taking any other action. */
\r
1289 eReturn = eReleaseBuffer;
\r
1292 #if( ipconfigFILTER_OUT_NON_ETHERNET_II_FRAMES == 1 )
\r
1294 uint16_t usFrameType;
\r
1296 if( eReturn == eProcessBuffer )
\r
1298 usFrameType = pxEthernetHeader->usFrameType;
\r
1299 usFrameType = FreeRTOS_ntohs( usFrameType );
\r
1301 if( usFrameType <= 0x600U )
\r
1303 /* Not an Ethernet II frame. */
\r
1304 eReturn = eReleaseBuffer;
\r
1308 #endif /* ipconfigFILTER_OUT_NON_ETHERNET_II_FRAMES == 1 */
\r
1312 /*-----------------------------------------------------------*/
\r
1314 static void prvProcessNetworkDownEvent( void )
\r
1316 /* Stop the ARP timer while there is no network. */
\r
1317 xARPTimer.bActive = pdFALSE_UNSIGNED;
\r
1319 #if ipconfigUSE_NETWORK_EVENT_HOOK == 1
\r
1321 static BaseType_t xCallEventHook = pdFALSE;
\r
1323 /* The first network down event is generated by the IP stack itself to
\r
1324 initialise the network hardware, so do not call the network down event
\r
1325 the first time through. */
\r
1326 if( xCallEventHook == pdTRUE )
\r
1328 vApplicationIPNetworkEventHook( eNetworkDown );
\r
1330 xCallEventHook = pdTRUE;
\r
1334 /* The network has been disconnected (or is being initialised for the first
\r
1335 time). Perform whatever hardware processing is necessary to bring it up
\r
1336 again, or wait for it to be available again. This is hardware dependent. */
\r
1337 if( xNetworkInterfaceInitialise() != pdPASS )
\r
1339 /* Ideally the network interface initialisation function will only
\r
1340 return when the network is available. In case this is not the case,
\r
1341 wait a while before retrying the initialisation. */
\r
1342 vTaskDelay( ipINITIALISATION_RETRY_DELAY );
\r
1343 FreeRTOS_NetworkDown();
\r
1347 /* Set remaining time to 0 so it will become active immediately. */
\r
1348 #if ipconfigUSE_DHCP == 1
\r
1350 /* The network is not up until DHCP has completed. */
\r
1351 vDHCPProcess( pdTRUE );
\r
1352 xSendEventToIPTask( eDHCPEvent );
\r
1356 /* Perform any necessary 'network up' processing. */
\r
1357 vIPNetworkUpCalls();
\r
1362 /*-----------------------------------------------------------*/
\r
1364 void vIPNetworkUpCalls( void )
\r
1366 xNetworkUp = pdTRUE;
\r
1368 #if( ipconfigUSE_NETWORK_EVENT_HOOK == 1 )
\r
1370 vApplicationIPNetworkEventHook( eNetworkUp );
\r
1372 #endif /* ipconfigUSE_NETWORK_EVENT_HOOK */
\r
1374 #if( ipconfigDNS_USE_CALLBACKS != 0 )
\r
1376 /* The following function is declared in FreeRTOS_DNS.c and 'private' to
\r
1378 extern void vDNSInitialise( void );
\r
1381 #endif /* ipconfigDNS_USE_CALLBACKS != 0 */
\r
1383 /* Set remaining time to 0 so it will become active immediately. */
\r
1384 prvIPTimerReload( &xARPTimer, pdMS_TO_TICKS( ipARP_TIMER_PERIOD_MS ) );
\r
1386 /*-----------------------------------------------------------*/
\r
1388 static void prvProcessEthernetPacket( NetworkBufferDescriptor_t * const pxNetworkBuffer )
\r
1390 EthernetHeader_t *pxEthernetHeader;
\r
1391 volatile eFrameProcessingResult_t eReturned; /* Volatile to prevent complier warnings when ipCONSIDER_FRAME_FOR_PROCESSING just sets it to eProcessBuffer. */
\r
1393 configASSERT( pxNetworkBuffer );
\r
1395 /* Interpret the Ethernet frame. */
\r
1396 eReturned = ipCONSIDER_FRAME_FOR_PROCESSING( pxNetworkBuffer->pucEthernetBuffer );
\r
1397 pxEthernetHeader = ( EthernetHeader_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
\r
1399 if( eReturned == eProcessBuffer )
\r
1401 /* Interpret the received Ethernet packet. */
\r
1402 switch( pxEthernetHeader->usFrameType )
\r
1404 case ipARP_FRAME_TYPE :
\r
1405 /* The Ethernet frame contains an ARP packet. */
\r
1406 eReturned = eARPProcessPacket( ( ARPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer );
\r
1409 case ipIPv4_FRAME_TYPE :
\r
1410 /* The Ethernet frame contains an IP packet. */
\r
1411 eReturned = prvProcessIPPacket( ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer );
\r
1415 /* No other packet types are handled. Nothing to do. */
\r
1416 eReturned = eReleaseBuffer;
\r
1421 /* Perform any actions that resulted from processing the Ethernet frame. */
\r
1422 switch( eReturned )
\r
1424 case eReturnEthernetFrame :
\r
1425 /* The Ethernet frame will have been updated (maybe it was
\r
1426 an ARP request or a PING request?) and should be sent back to
\r
1428 vReturnEthernetFrame( pxNetworkBuffer, pdTRUE );
\r
1429 /* parameter pdTRUE: the buffer must be released once
\r
1430 the frame has been transmitted */
\r
1433 case eFrameConsumed :
\r
1434 /* The frame is in use somewhere, don't release the buffer
\r
1439 /* The frame is not being used anywhere, and the
\r
1440 NetworkBufferDescriptor_t structure containing the frame should
\r
1441 just be released back to the list of free buffers. */
\r
1442 vReleaseNetworkBufferAndDescriptor( pxNetworkBuffer );
\r
1446 /*-----------------------------------------------------------*/
\r
1448 static eFrameProcessingResult_t prvAllowIPPacket( const IPPacket_t * const pxIPPacket,
\r
1449 NetworkBufferDescriptor_t * const pxNetworkBuffer, UBaseType_t uxHeaderLength )
\r
1451 eFrameProcessingResult_t eReturn = eProcessBuffer;
\r
1453 #if( ( ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 ) || ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 ) )
\r
1454 const IPHeader_t * pxIPHeader = &( pxIPPacket->xIPHeader );
\r
1456 /* or else, the parameter won't be used and the function will be optimised
\r
1458 ( void ) pxIPPacket;
\r
1461 #if( ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 )
\r
1463 /* In systems with a very small amount of RAM, it might be advantageous
\r
1464 to have incoming messages checked earlier, by the network card driver.
\r
1465 This method may decrease the usage of sparse network buffers. */
\r
1466 uint32_t ulDestinationIPAddress = pxIPHeader->ulDestinationIPAddress;
\r
1468 /* Ensure that the incoming packet is not fragmented (fragmentation
\r
1469 was only supported for outgoing packets, and is not currently
\r
1470 not supported at all). */
\r
1471 if( ( pxIPHeader->usFragmentOffset & ipFRAGMENT_OFFSET_BIT_MASK ) != 0U )
\r
1473 /* Can not handle, fragmented packet. */
\r
1474 eReturn = eReleaseBuffer;
\r
1476 /* 0x45 means: IPv4 with an IP header of 5 x 4 = 20 bytes
\r
1477 * 0x47 means: IPv4 with an IP header of 7 x 4 = 28 bytes */
\r
1478 else if( ( pxIPHeader->ucVersionHeaderLength < 0x45u ) || ( pxIPHeader->ucVersionHeaderLength > 0x4Fu ) )
\r
1480 /* Can not handle, unknown or invalid header version. */
\r
1481 eReturn = eReleaseBuffer;
\r
1483 /* Is the packet for this IP address? */
\r
1484 else if( ( ulDestinationIPAddress != *ipLOCAL_IP_ADDRESS_POINTER ) &&
\r
1485 /* Is it the global broadcast address 255.255.255.255 ? */
\r
1486 ( ulDestinationIPAddress != ipBROADCAST_IP_ADDRESS ) &&
\r
1487 /* Is it a specific broadcast address 192.168.1.255 ? */
\r
1488 ( ulDestinationIPAddress != xNetworkAddressing.ulBroadcastAddress ) &&
\r
1489 #if( ipconfigUSE_LLMNR == 1 )
\r
1490 /* Is it the LLMNR multicast address? */
\r
1491 ( ulDestinationIPAddress != ipLLMNR_IP_ADDR ) &&
\r
1493 /* Or (during DHCP negotiation) we have no IP-address yet? */
\r
1494 ( *ipLOCAL_IP_ADDRESS_POINTER != 0UL ) )
\r
1496 /* Packet is not for this node, release it */
\r
1497 eReturn = eReleaseBuffer;
\r
1500 #endif /* ipconfigETHERNET_DRIVER_FILTERS_PACKETS */
\r
1502 #if( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 )
\r
1504 /* Some drivers of NIC's with checksum-offloading will enable the above
\r
1505 define, so that the checksum won't be checked again here */
\r
1506 if (eReturn == eProcessBuffer )
\r
1508 /* Is the IP header checksum correct? */
\r
1509 if( ( pxIPHeader->ucProtocol != ( uint8_t ) ipPROTOCOL_ICMP ) &&
\r
1510 ( usGenerateChecksum( 0UL, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ( size_t ) uxHeaderLength ) != ipCORRECT_CRC ) )
\r
1512 /* Check sum in IP-header not correct. */
\r
1513 eReturn = eReleaseBuffer;
\r
1515 /* Is the upper-layer checksum (TCP/UDP/ICMP) correct? */
\r
1516 else if( usGenerateProtocolChecksum( ( uint8_t * )( pxNetworkBuffer->pucEthernetBuffer ), pdFALSE ) != ipCORRECT_CRC )
\r
1518 /* Protocol checksum not accepted. */
\r
1519 eReturn = eReleaseBuffer;
\r
1525 /* to avoid warning unused parameters */
\r
1526 ( void ) pxNetworkBuffer;
\r
1527 ( void ) uxHeaderLength;
\r
1529 #endif /* ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 */
\r
1533 /*-----------------------------------------------------------*/
\r
1535 static eFrameProcessingResult_t prvProcessIPPacket( const IPPacket_t * const pxIPPacket, NetworkBufferDescriptor_t * const pxNetworkBuffer )
\r
1537 eFrameProcessingResult_t eReturn;
\r
1538 const IPHeader_t * pxIPHeader = &( pxIPPacket->xIPHeader );
\r
1539 UBaseType_t uxHeaderLength = ( UBaseType_t ) ( ( pxIPHeader->ucVersionHeaderLength & 0x0Fu ) << 2 );
\r
1540 uint8_t ucProtocol;
\r
1542 ucProtocol = pxIPPacket->xIPHeader.ucProtocol;
\r
1543 /* Check if the IP headers are acceptable and if it has our destination. */
\r
1544 eReturn = prvAllowIPPacket( pxIPPacket, pxNetworkBuffer, uxHeaderLength );
\r
1546 if( eReturn == eProcessBuffer )
\r
1548 if( uxHeaderLength > ipSIZE_OF_IPv4_HEADER )
\r
1550 /* All structs of headers expect a IP header size of 20 bytes
\r
1551 * IP header options were included, we'll ignore them and cut them out
\r
1552 * Note: IP options are mostly use in Multi-cast protocols */
\r
1553 const size_t optlen = ( ( size_t ) uxHeaderLength ) - ipSIZE_OF_IPv4_HEADER;
\r
1554 /* From: the previous start of UDP/ICMP/TCP data */
\r
1555 uint8_t *pucSource = ( ( uint8_t * ) pxIPHeader ) + uxHeaderLength;
\r
1556 /* To: the usual start of UDP/ICMP/TCP data at offset 20 from IP header */
\r
1557 uint8_t *pucTarget = ( ( uint8_t * ) pxIPHeader ) + ipSIZE_OF_IPv4_HEADER;
\r
1558 /* How many: total length minus the options and the lower headers */
\r
1559 const size_t xMoveLen = pxNetworkBuffer->xDataLength - optlen - ipSIZE_OF_IPv4_HEADER - ipSIZE_OF_ETH_HEADER;
\r
1561 memmove( pucTarget, pucSource, xMoveLen );
\r
1562 pxNetworkBuffer->xDataLength -= optlen;
\r
1564 /* Add the IP and MAC addresses to the ARP table if they are not
\r
1565 already there - otherwise refresh the age of the existing
\r
1567 if( ucProtocol != ( uint8_t ) ipPROTOCOL_UDP )
\r
1569 /* Refresh the ARP cache with the IP/MAC-address of the received packet
\r
1570 * For UDP packets, this will be done later in xProcessReceivedUDPPacket()
\r
1571 * as soon as know that the message will be handled by someone
\r
1572 * This will prevent that the ARP cache will get overwritten
\r
1573 * with the IP-address of useless broadcast packets
\r
1575 vARPRefreshCacheEntry( &( pxIPPacket->xEthernetHeader.xSourceAddress ), pxIPHeader->ulSourceIPAddress );
\r
1577 switch( ucProtocol )
\r
1579 case ipPROTOCOL_ICMP :
\r
1580 /* The IP packet contained an ICMP frame. Don't bother
\r
1581 checking the ICMP checksum, as if it is wrong then the
\r
1582 wrong data will also be returned, and the source of the
\r
1583 ping will know something went wrong because it will not
\r
1584 be able to validate what it receives. */
\r
1585 #if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) || ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
\r
1587 ICMPPacket_t *pxICMPPacket = ( ICMPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
\r
1588 if( pxIPHeader->ulDestinationIPAddress == *ipLOCAL_IP_ADDRESS_POINTER )
\r
1590 eReturn = prvProcessICMPPacket( pxICMPPacket );
\r
1593 #endif /* ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) || ( ipconfigSUPPORT_OUTGOING_PINGS == 1 ) */
\r
1596 case ipPROTOCOL_UDP :
\r
1598 /* The IP packet contained a UDP frame. */
\r
1599 UDPPacket_t *pxUDPPacket = ( UDPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
\r
1601 /* Note the header values required prior to the
\r
1602 checksum generation as the checksum pseudo header
\r
1603 may clobber some of these values. */
\r
1604 pxNetworkBuffer->xDataLength = FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) - sizeof( UDPHeader_t );
\r
1605 /* HT:endian: fields in pxNetworkBuffer (usPort, ulIPAddress) were network order */
\r
1606 pxNetworkBuffer->usPort = pxUDPPacket->xUDPHeader.usSourcePort;
\r
1607 pxNetworkBuffer->ulIPAddress = pxUDPPacket->xIPHeader.ulSourceIPAddress;
\r
1609 /* ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM:
\r
1610 * In some cases, the upper-layer checksum has been calculated
\r
1611 * by the NIC driver */
\r
1612 /* Pass the packet payload to the UDP sockets implementation. */
\r
1613 /* HT:endian: xProcessReceivedUDPPacket wanted network order */
\r
1614 if( xProcessReceivedUDPPacket( pxNetworkBuffer, pxUDPPacket->xUDPHeader.usDestinationPort ) == pdPASS )
\r
1616 eReturn = eFrameConsumed;
\r
1621 #if ipconfigUSE_TCP == 1
\r
1622 case ipPROTOCOL_TCP :
\r
1625 if( xProcessReceivedTCPPacket( pxNetworkBuffer ) == pdPASS )
\r
1627 eReturn = eFrameConsumed;
\r
1630 /* Setting this variable will cause xTCPTimerCheck()
\r
1631 to be called just before the IP-task blocks. */
\r
1632 xProcessedTCPMessage++;
\r
1637 /* Not a supported frame type. */
\r
1644 /*-----------------------------------------------------------*/
\r
1646 #if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
\r
1648 static void prvProcessICMPEchoReply( ICMPPacket_t * const pxICMPPacket )
\r
1650 ePingReplyStatus_t eStatus = eSuccess;
\r
1651 uint16_t usDataLength, usCount;
\r
1654 /* Find the total length of the IP packet. */
\r
1655 usDataLength = pxICMPPacket->xIPHeader.usLength;
\r
1656 usDataLength = FreeRTOS_ntohs( usDataLength );
\r
1658 /* Remove the length of the IP headers to obtain the length of the ICMP
\r
1659 message itself. */
\r
1660 usDataLength = ( uint16_t ) ( ( ( uint32_t ) usDataLength ) - ipSIZE_OF_IPv4_HEADER );
\r
1662 /* Remove the length of the ICMP header, to obtain the length of
\r
1663 data contained in the ping. */
\r
1664 usDataLength = ( uint16_t ) ( ( ( uint32_t ) usDataLength ) - ipSIZE_OF_ICMP_HEADER );
\r
1666 /* Checksum has already been checked before in prvProcessIPPacket */
\r
1668 /* Find the first byte of the data within the ICMP packet. */
\r
1669 pucByte = ( uint8_t * ) pxICMPPacket;
\r
1670 pucByte += sizeof( ICMPPacket_t );
\r
1672 /* Check each byte. */
\r
1673 for( usCount = 0; usCount < usDataLength; usCount++ )
\r
1675 if( *pucByte != ipECHO_DATA_FILL_BYTE )
\r
1677 eStatus = eInvalidData;
\r
1684 /* Call back into the application to pass it the result. */
\r
1685 vApplicationPingReplyHook( eStatus, pxICMPPacket->xICMPHeader.usIdentifier );
\r
1689 /*-----------------------------------------------------------*/
\r
1691 #if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 )
\r
1693 static eFrameProcessingResult_t prvProcessICMPEchoRequest( ICMPPacket_t * const pxICMPPacket )
\r
1695 ICMPHeader_t *pxICMPHeader;
\r
1696 IPHeader_t *pxIPHeader;
\r
1697 uint16_t usRequest;
\r
1699 pxICMPHeader = &( pxICMPPacket->xICMPHeader );
\r
1700 pxIPHeader = &( pxICMPPacket->xIPHeader );
\r
1702 /* HT:endian: changed back */
\r
1703 iptraceSENDING_PING_REPLY( pxIPHeader->ulSourceIPAddress );
\r
1705 /* The checksum can be checked here - but a ping reply should be
\r
1706 returned even if the checksum is incorrect so the other end can
\r
1707 tell that the ping was received - even if the ping reply contains
\r
1709 pxICMPHeader->ucTypeOfMessage = ( uint8_t ) ipICMP_ECHO_REPLY;
\r
1710 pxIPHeader->ulDestinationIPAddress = pxIPHeader->ulSourceIPAddress;
\r
1711 pxIPHeader->ulSourceIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
\r
1713 /* Update the checksum because the ucTypeOfMessage member in the header
\r
1714 has been changed to ipICMP_ECHO_REPLY. This is faster than calling
\r
1715 usGenerateChecksum(). */
\r
1717 /* due to compiler warning "integer operation result is out of range" */
\r
1719 usRequest = ( uint16_t ) ( ( uint16_t )ipICMP_ECHO_REQUEST << 8 );
\r
1721 if( pxICMPHeader->usChecksum >= FreeRTOS_htons( 0xFFFFu - usRequest ) )
\r
1723 pxICMPHeader->usChecksum = ( uint16_t )
\r
1724 ( ( ( uint32_t ) pxICMPHeader->usChecksum ) +
\r
1725 FreeRTOS_htons( usRequest + 1UL ) );
\r
1729 pxICMPHeader->usChecksum = ( uint16_t )
\r
1730 ( ( ( uint32_t ) pxICMPHeader->usChecksum ) +
\r
1731 FreeRTOS_htons( usRequest ) );
\r
1733 return eReturnEthernetFrame;
\r
1736 #endif /* ipconfigREPLY_TO_INCOMING_PINGS == 1 */
\r
1737 /*-----------------------------------------------------------*/
\r
1739 #if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) || ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
\r
1741 static eFrameProcessingResult_t prvProcessICMPPacket( ICMPPacket_t * const pxICMPPacket )
\r
1743 eFrameProcessingResult_t eReturn = eReleaseBuffer;
\r
1745 iptraceICMP_PACKET_RECEIVED();
\r
1746 switch( pxICMPPacket->xICMPHeader.ucTypeOfMessage )
\r
1748 case ipICMP_ECHO_REQUEST :
\r
1749 #if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 )
\r
1751 eReturn = prvProcessICMPEchoRequest( pxICMPPacket );
\r
1753 #endif /* ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) */
\r
1756 case ipICMP_ECHO_REPLY :
\r
1757 #if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
\r
1759 prvProcessICMPEchoReply( pxICMPPacket );
\r
1761 #endif /* ipconfigSUPPORT_OUTGOING_PINGS */
\r
1771 #endif /* ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) || ( ipconfigSUPPORT_OUTGOING_PINGS == 1 ) */
\r
1772 /*-----------------------------------------------------------*/
\r
1774 uint16_t usGenerateProtocolChecksum( const uint8_t * const pucEthernetBuffer, BaseType_t xOutgoingPacket )
\r
1776 uint32_t ulLength;
\r
1777 uint16_t usChecksum, *pusChecksum;
\r
1778 const IPPacket_t * pxIPPacket;
\r
1779 UBaseType_t uxIPHeaderLength;
\r
1780 ProtocolPacket_t *pxProtPack;
\r
1781 uint8_t ucProtocol;
\r
1782 #if( ipconfigHAS_DEBUG_PRINTF != 0 )
\r
1783 const char *pcType;
\r
1786 pxIPPacket = ( const IPPacket_t * ) pucEthernetBuffer;
\r
1787 uxIPHeaderLength = ( UBaseType_t ) ( 4u * ( pxIPPacket->xIPHeader.ucVersionHeaderLength & 0x0Fu ) ); /*_RB_ Why 4? */
\r
1788 pxProtPack = ( ProtocolPacket_t * ) ( pucEthernetBuffer + ( uxIPHeaderLength - ipSIZE_OF_IPv4_HEADER ) );
\r
1789 ucProtocol = pxIPPacket->xIPHeader.ucProtocol;
\r
1791 if( ucProtocol == ( uint8_t ) ipPROTOCOL_UDP )
\r
1793 pusChecksum = ( uint16_t * ) ( &( pxProtPack->xUDPPacket.xUDPHeader.usChecksum ) );
\r
1794 #if( ipconfigHAS_DEBUG_PRINTF != 0 )
\r
1798 #endif /* ipconfigHAS_DEBUG_PRINTF != 0 */
\r
1800 else if( ucProtocol == ( uint8_t ) ipPROTOCOL_TCP )
\r
1802 pusChecksum = ( uint16_t * ) ( &( pxProtPack->xTCPPacket.xTCPHeader.usChecksum ) );
\r
1803 #if( ipconfigHAS_DEBUG_PRINTF != 0 )
\r
1807 #endif /* ipconfigHAS_DEBUG_PRINTF != 0 */
\r
1809 else if( ( ucProtocol == ( uint8_t ) ipPROTOCOL_ICMP ) ||
\r
1810 ( ucProtocol == ( uint8_t ) ipPROTOCOL_IGMP ) )
\r
1812 pusChecksum = ( uint16_t * ) ( &( pxProtPack->xICMPPacket.xICMPHeader.usChecksum ) );
\r
1814 #if( ipconfigHAS_DEBUG_PRINTF != 0 )
\r
1816 if( ucProtocol == ( uint8_t ) ipPROTOCOL_ICMP )
\r
1825 #endif /* ipconfigHAS_DEBUG_PRINTF != 0 */
\r
1829 /* Unhandled protocol, other than ICMP, IGMP, UDP, or TCP. */
\r
1830 return ipUNHANDLED_PROTOCOL;
\r
1833 if( xOutgoingPacket != pdFALSE )
\r
1835 /* This is an outgoing packet. Before calculating the checksum, set it
\r
1837 *( pusChecksum ) = 0u;
\r
1839 else if( ( *pusChecksum == 0u ) && ( ucProtocol == ( uint8_t ) ipPROTOCOL_UDP ) )
\r
1841 /* Sender hasn't set the checksum, no use to calculate it. */
\r
1842 return ipCORRECT_CRC;
\r
1845 ulLength = ( uint32_t )
\r
1846 ( FreeRTOS_ntohs( pxIPPacket->xIPHeader.usLength ) - ( ( uint16_t ) uxIPHeaderLength ) ); /* normally minus 20 */
\r
1848 if( ( ulLength < sizeof( pxProtPack->xUDPPacket.xUDPHeader ) ) ||
\r
1849 ( ulLength > ( uint32_t )( ipconfigNETWORK_MTU - uxIPHeaderLength ) ) )
\r
1851 #if( ipconfigHAS_DEBUG_PRINTF != 0 )
\r
1853 FreeRTOS_debug_printf( ( "usGenerateProtocolChecksum[%s]: len invalid: %lu\n", pcType, ulLength ) );
\r
1855 #endif /* ipconfigHAS_DEBUG_PRINTF != 0 */
\r
1857 /* Again, in a 16-bit return value there is no space to indicate an
\r
1858 error. For incoming packets, 0x1234 will cause dropping of the packet.
\r
1859 For outgoing packets, there is a serious problem with the
\r
1861 return ipINVALID_LENGTH;
\r
1863 if( ucProtocol <= ( uint8_t ) ipPROTOCOL_IGMP )
\r
1865 /* ICMP/IGMP do not have a pseudo header for CRC-calculation. */
\r
1866 usChecksum = ( uint16_t )
\r
1867 ( ~usGenerateChecksum( 0UL,
\r
1868 ( uint8_t * ) &( pxProtPack->xTCPPacket.xTCPHeader ), ( size_t ) ulLength ) );
\r
1872 /* For UDP and TCP, sum the pseudo header, i.e. IP protocol + length
\r
1874 usChecksum = ( uint16_t ) ( ulLength + ( ( uint16_t ) ucProtocol ) );
\r
1876 /* And then continue at the IPv4 source and destination addresses. */
\r
1877 usChecksum = ( uint16_t )
\r
1878 ( ~usGenerateChecksum( ( uint32_t ) usChecksum, ( uint8_t * )&( pxIPPacket->xIPHeader.ulSourceIPAddress ),
\r
1879 ( size_t )( 2u * sizeof( pxIPPacket->xIPHeader.ulSourceIPAddress ) + ulLength ) ) );
\r
1881 /* Sum TCP header and data. */
\r
1884 if( xOutgoingPacket == pdFALSE )
\r
1886 /* This is in incoming packet. If the CRC is correct, it should be zero. */
\r
1887 if( usChecksum == 0u )
\r
1889 usChecksum = ( uint16_t )ipCORRECT_CRC;
\r
1894 if( ( usChecksum == 0u ) && ( ucProtocol == ( uint8_t ) ipPROTOCOL_UDP ) )
\r
1896 /* In case of UDP, a calculated checksum of 0x0000 is transmitted
\r
1897 as 0xffff. A value of zero would mean that the checksum is not used. */
\r
1898 #if( ipconfigHAS_DEBUG_PRINTF != 0 )
\r
1900 if( xOutgoingPacket != pdFALSE )
\r
1902 FreeRTOS_debug_printf( ( "usGenerateProtocolChecksum[%s]: crc swap: %04X\n", pcType, usChecksum ) );
\r
1905 #endif /* ipconfigHAS_DEBUG_PRINTF != 0 */
\r
1907 usChecksum = ( uint16_t )0xffffu;
\r
1910 usChecksum = FreeRTOS_htons( usChecksum );
\r
1912 if( xOutgoingPacket != pdFALSE )
\r
1914 *( pusChecksum ) = usChecksum;
\r
1916 #if( ipconfigHAS_DEBUG_PRINTF != 0 )
\r
1917 else if( ( xOutgoingPacket == pdFALSE ) && ( usChecksum != ipCORRECT_CRC ) )
\r
1919 FreeRTOS_debug_printf( ( "usGenerateProtocolChecksum[%s]: ID %04X: from %lxip to %lxip bad crc: %04X\n",
\r
1921 FreeRTOS_ntohs( pxIPPacket->xIPHeader.usIdentification ),
\r
1922 FreeRTOS_ntohl( pxIPPacket->xIPHeader.ulSourceIPAddress ),
\r
1923 FreeRTOS_ntohl( pxIPPacket->xIPHeader.ulDestinationIPAddress ),
\r
1924 FreeRTOS_ntohs( *pusChecksum ) ) );
\r
1926 #endif /* ipconfigHAS_DEBUG_PRINTF != 0 */
\r
1928 return usChecksum;
\r
1930 /*-----------------------------------------------------------*/
\r
1932 uint16_t usGenerateChecksum( uint32_t ulSum, const uint8_t * pucNextData, size_t uxDataLengthBytes )
\r
1934 xUnion32 xSum2, xSum, xTerm;
\r
1935 xUnionPtr xSource; /* Points to first byte */
\r
1936 xUnionPtr xLastSource; /* Points to last byte plus one */
\r
1937 uint32_t ulAlignBits, ulCarry = 0ul;
\r
1939 /* Small MCUs often spend up to 30% of the time doing checksum calculations
\r
1940 This function is optimised for 32-bit CPUs; Each time it will try to fetch
\r
1941 32-bits, sums it with an accumulator and counts the number of carries. */
\r
1943 /* Swap the input (little endian platform only). */
\r
1944 xSum.u32 = FreeRTOS_ntohs( ulSum );
\r
1947 xSource.u8ptr = ( uint8_t * ) pucNextData;
\r
1948 ulAlignBits = ( ( ( uint32_t ) pucNextData ) & 0x03u ); /* gives 0, 1, 2, or 3 */
\r
1950 /* If byte (8-bit) aligned... */
\r
1951 if( ( ( ulAlignBits & 1ul ) != 0ul ) && ( uxDataLengthBytes >= ( size_t ) 1 ) )
\r
1953 xTerm.u8[ 1 ] = *( xSource.u8ptr );
\r
1954 ( xSource.u8ptr )++;
\r
1955 uxDataLengthBytes--;
\r
1956 /* Now xSource is word (16-bit) aligned. */
\r
1959 /* If half-word (16-bit) aligned... */
\r
1960 if( ( ( ulAlignBits == 1u ) || ( ulAlignBits == 2u ) ) && ( uxDataLengthBytes >= 2u ) )
\r
1962 xSum.u32 += *(xSource.u16ptr);
\r
1963 ( xSource.u16ptr )++;
\r
1964 uxDataLengthBytes -= 2u;
\r
1965 /* Now xSource is word (32-bit) aligned. */
\r
1968 /* Word (32-bit) aligned, do the most part. */
\r
1969 xLastSource.u32ptr = ( xSource.u32ptr + ( uxDataLengthBytes / 4u ) ) - 3u;
\r
1971 /* In this loop, four 32-bit additions will be done, in total 16 bytes.
\r
1972 Indexing with constants (0,1,2,3) gives faster code than using
\r
1973 post-increments. */
\r
1974 while( xSource.u32ptr < xLastSource.u32ptr )
\r
1976 /* Use a secondary Sum2, just to see if the addition produced an
\r
1978 xSum2.u32 = xSum.u32 + xSource.u32ptr[ 0 ];
\r
1979 if( xSum2.u32 < xSum.u32 )
\r
1984 /* Now add the secondary sum to the major sum, and remember if there was
\r
1986 xSum.u32 = xSum2.u32 + xSource.u32ptr[ 1 ];
\r
1987 if( xSum2.u32 > xSum.u32 )
\r
1992 /* And do the same trick once again for indexes 2 and 3 */
\r
1993 xSum2.u32 = xSum.u32 + xSource.u32ptr[ 2 ];
\r
1994 if( xSum2.u32 < xSum.u32 )
\r
1999 xSum.u32 = xSum2.u32 + xSource.u32ptr[ 3 ];
\r
2001 if( xSum2.u32 > xSum.u32 )
\r
2006 /* And finally advance the pointer 4 * 4 = 16 bytes. */
\r
2007 xSource.u32ptr += 4;
\r
2010 /* Now add all carries. */
\r
2011 xSum.u32 = ( uint32_t )xSum.u16[ 0 ] + xSum.u16[ 1 ] + ulCarry;
\r
2013 uxDataLengthBytes %= 16u;
\r
2014 xLastSource.u8ptr = ( uint8_t * ) ( xSource.u8ptr + ( uxDataLengthBytes & ~( ( size_t ) 1 ) ) );
\r
2016 /* Half-word aligned. */
\r
2017 while( xSource.u16ptr < xLastSource.u16ptr )
\r
2019 /* At least one more short. */
\r
2020 xSum.u32 += xSource.u16ptr[ 0 ];
\r
2024 if( ( uxDataLengthBytes & ( size_t ) 1 ) != 0u ) /* Maybe one more ? */
\r
2026 xTerm.u8[ 0 ] = xSource.u8ptr[ 0 ];
\r
2028 xSum.u32 += xTerm.u32;
\r
2030 /* Now add all carries again. */
\r
2031 xSum.u32 = ( uint32_t ) xSum.u16[ 0 ] + xSum.u16[ 1 ];
\r
2033 /* The previous summation might have given a 16-bit carry. */
\r
2034 xSum.u32 = ( uint32_t ) xSum.u16[ 0 ] + xSum.u16[ 1 ];
\r
2036 if( ( ulAlignBits & 1u ) != 0u )
\r
2038 /* Quite unlikely, but pucNextData might be non-aligned, which would
\r
2039 mean that a checksum is calculated starting at an odd position. */
\r
2040 xSum.u32 = ( ( xSum.u32 & 0xffu ) << 8 ) | ( ( xSum.u32 & 0xff00u ) >> 8 );
\r
2043 /* swap the output (little endian platform only). */
\r
2044 return FreeRTOS_htons( ( (uint16_t) xSum.u32 ) );
\r
2046 /*-----------------------------------------------------------*/
\r
2048 void vReturnEthernetFrame( NetworkBufferDescriptor_t * pxNetworkBuffer, BaseType_t xReleaseAfterSend )
\r
2050 EthernetHeader_t *pxEthernetHeader;
\r
2052 #if( ipconfigZERO_COPY_TX_DRIVER != 0 )
\r
2053 NetworkBufferDescriptor_t *pxNewBuffer;
\r
2056 #if defined( ipconfigETHERNET_MINIMUM_PACKET_BYTES )
\r
2058 if( pxNetworkBuffer->xDataLength < ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES )
\r
2060 BaseType_t xIndex;
\r
2062 FreeRTOS_printf( ( "vReturnEthernetFrame: length %lu\n", ( uint32_t )pxNetworkBuffer->xDataLength ) );
\r
2063 for( xIndex = ( BaseType_t ) pxNetworkBuffer->xDataLength; xIndex < ( BaseType_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES; xIndex++ )
\r
2065 pxNetworkBuffer->pucEthernetBuffer[ xIndex ] = 0u;
\r
2067 pxNetworkBuffer->xDataLength = ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES;
\r
2072 #if( ipconfigZERO_COPY_TX_DRIVER != 0 )
\r
2074 if( xReleaseAfterSend == pdFALSE )
\r
2076 pxNewBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, ( BaseType_t ) pxNetworkBuffer->xDataLength );
\r
2077 xReleaseAfterSend = pdTRUE;
\r
2078 pxNetworkBuffer = pxNewBuffer;
\r
2081 if( pxNetworkBuffer != NULL )
\r
2084 pxEthernetHeader = ( EthernetHeader_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
\r
2086 /* Swap source and destination MAC addresses. */
\r
2087 memcpy( ( void * ) &( pxEthernetHeader->xDestinationAddress ), ( void * ) &( pxEthernetHeader->xSourceAddress ), sizeof( pxEthernetHeader->xDestinationAddress ) );
\r
2088 memcpy( ( void * ) &( pxEthernetHeader->xSourceAddress) , ( void * ) ipLOCAL_MAC_ADDRESS, ( size_t ) ipMAC_ADDRESS_LENGTH_BYTES );
\r
2091 xNetworkInterfaceOutput( pxNetworkBuffer, xReleaseAfterSend );
\r
2094 /*-----------------------------------------------------------*/
\r
2096 uint32_t FreeRTOS_GetIPAddress( void )
\r
2098 /* Returns the IP address of the NIC. */
\r
2099 return *ipLOCAL_IP_ADDRESS_POINTER;
\r
2101 /*-----------------------------------------------------------*/
\r
2103 void FreeRTOS_SetIPAddress( uint32_t ulIPAddress )
\r
2105 /* Sets the IP address of the NIC. */
\r
2106 *ipLOCAL_IP_ADDRESS_POINTER = ulIPAddress;
\r
2108 /*-----------------------------------------------------------*/
\r
2110 uint32_t FreeRTOS_GetGatewayAddress( void )
\r
2112 return xNetworkAddressing.ulGatewayAddress;
\r
2114 /*-----------------------------------------------------------*/
\r
2116 uint32_t FreeRTOS_GetDNSServerAddress( void )
\r
2118 return xNetworkAddressing.ulDNSServerAddress;
\r
2120 /*-----------------------------------------------------------*/
\r
2122 uint32_t FreeRTOS_GetNetmask( void )
\r
2124 return xNetworkAddressing.ulNetMask;
\r
2126 /*-----------------------------------------------------------*/
\r
2128 const uint8_t * FreeRTOS_GetMACAddress( void )
\r
2130 return ipLOCAL_MAC_ADDRESS;
\r
2132 /*-----------------------------------------------------------*/
\r
2134 void FreeRTOS_SetNetmask ( uint32_t ulNetmask )
\r
2136 xNetworkAddressing.ulNetMask = ulNetmask;
\r
2138 /*-----------------------------------------------------------*/
\r
2140 void FreeRTOS_SetGatewayAddress ( uint32_t ulGatewayAddress )
\r
2142 xNetworkAddressing.ulGatewayAddress = ulGatewayAddress;
\r
2144 /*-----------------------------------------------------------*/
\r
2146 #if( ipconfigUSE_DHCP == 1 )
\r
2147 void vIPSetDHCPTimerEnableState( BaseType_t xEnableState )
\r
2149 if( xEnableState != pdFALSE )
\r
2151 xDHCPTimer.bActive = pdTRUE_UNSIGNED;
\r
2155 xDHCPTimer.bActive = pdFALSE_UNSIGNED;
\r
2158 #endif /* ipconfigUSE_DHCP */
\r
2159 /*-----------------------------------------------------------*/
\r
2161 #if( ipconfigUSE_DHCP == 1 )
\r
2162 void vIPReloadDHCPTimer( uint32_t ulLeaseTime )
\r
2164 prvIPTimerReload( &xDHCPTimer, ulLeaseTime );
\r
2166 #endif /* ipconfigUSE_DHCP */
\r
2167 /*-----------------------------------------------------------*/
\r
2169 #if( ipconfigDNS_USE_CALLBACKS == 1 )
\r
2170 void vIPSetDnsTimerEnableState( BaseType_t xEnableState )
\r
2172 if( xEnableState != 0 )
\r
2174 xDNSTimer.bActive = pdTRUE;
\r
2178 xDNSTimer.bActive = pdFALSE;
\r
2181 #endif /* ipconfigUSE_DHCP */
\r
2182 /*-----------------------------------------------------------*/
\r
2184 #if( ipconfigDNS_USE_CALLBACKS != 0 )
\r
2185 void vIPReloadDNSTimer( uint32_t ulCheckTime )
\r
2187 prvIPTimerReload( &xDNSTimer, ulCheckTime );
\r
2189 #endif /* ipconfigDNS_USE_CALLBACKS != 0 */
\r
2190 /*-----------------------------------------------------------*/
\r
2192 BaseType_t xIPIsNetworkTaskReady( void )
\r
2194 return xIPTaskInitialised;
\r
2196 /*-----------------------------------------------------------*/
\r
2198 BaseType_t FreeRTOS_IsNetworkUp( void )
\r
2200 return xNetworkUp;
\r
2202 /*-----------------------------------------------------------*/
\r
2204 #if( ipconfigCHECK_IP_QUEUE_SPACE != 0 )
\r
2205 UBaseType_t uxGetMinimumIPQueueSpace( void )
\r
2207 return uxQueueMinimumSpace;
\r
2210 /*-----------------------------------------------------------*/
\r
projects / freertos / blob