Add IPv6 Demo (#937)

* Add demo changes

* Update kernel and library paths

* Update main.c

* Run uncrustify

* Fix spell checker

* CI check file headers update

* Add IPv6/v4 UDP echo server with zero copy/non-zero copy versions

* Add VS proj file changes to include the UDP echo sample code

* readme update

---------

Co-authored-by: Tony Josi <tonyjosi@amazon.com>

44 files changed, 10509 insertions, 0 deletions

diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOSConfig.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOSConfig.h
new file mode 100644
index 000000000..af07060b7
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOSConfig.h
@@ -0,0 +1,233 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef FREERTOS_CONFIG_H
+#define FREERTOS_CONFIG_H
+
+/*-----------------------------------------------------------
+* Application specific definitions.
+*
+* These definitions should be adjusted for your particular hardware and
+* application requirements.
+*
+* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE
+* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.
+* http://www.freertos.org/a00110.html
+*
+* The bottom of this file contains some constants specific to running the UDP
+* stack in this demo.  Constants specific to FreeRTOS+TCP itself (rather than
+* the demo) are contained in FreeRTOSIPConfig.h.
+*----------------------------------------------------------*/
+
+#define NETCAT_PORT_NR                             5555
+#define AMAZON_GO_SERVER                           9000
+#define XILINX_ZYNQ                                7
+
+/* Used for IPv6 validation */
+#define configECHO_SERVER_ADDR_STRING             "fe80::a53b:3371:d92f:970b"
+
+/* Used for IPv4 validation */
+/* #define configECHO_SERVER_ADDR_STRING              "192.168.1.3" */
+
+#define configECHO_SERVER_PORT                     AMAZON_GO_SERVER
+
+
+#define configENABLE_BACKWARD_COMPATIBILITY        1
+#define configUSE_PREEMPTION                       1
+#define configUSE_PORT_OPTIMISED_TASK_SELECTION    1
+#define configMAX_PRIORITIES                       ( 7 )
+#define configTICK_RATE_HZ                         ( 1000 )                  /* In this non-real time simulated environment the tick frequency has to be at least a multiple of the Win32 tick frequency, and therefore very slow. */
+#define configMINIMAL_STACK_SIZE                   ( ( unsigned short ) 60 ) /* In this simulated case, the stack only has to hold one small structure as the real stack is part of the Win32 thread. */
+#define configTOTAL_HEAP_SIZE                      ( ( size_t ) ( 2048U * 1024U ) )
+#define configMAX_TASK_NAME_LEN                    ( 15 )
+#define configUSE_TRACE_FACILITY                   1
+#define configUSE_16_BIT_TICKS                     0
+#define configIDLE_SHOULD_YIELD                    1
+#define configUSE_CO_ROUTINES                      0
+#define configUSE_MUTEXES                          1
+#define configUSE_RECURSIVE_MUTEXES                1
+#define configQUEUE_REGISTRY_SIZE                  0
+#define configUSE_APPLICATION_TASK_TAG             0
+#define configUSE_COUNTING_SEMAPHORES              1
+#define configUSE_ALTERNATIVE_API                  0
+#define configNUM_THREAD_LOCAL_STORAGE_POINTERS    3 /* FreeRTOS+FAT requires 2 pointers if a CWD is supported. */
+
+/* Hook function related definitions. */
+#define configUSE_TICK_HOOK                        0
+#define configUSE_IDLE_HOOK                        1
+#define configUSE_MALLOC_FAILED_HOOK               1
+#define configCHECK_FOR_STACK_OVERFLOW             0 /* Not applicable to the Win32 port. */
+
+/* Software timer related definitions. */
+#define configUSE_TIMERS                           1
+#define configTIMER_TASK_PRIORITY                  ( configMAX_PRIORITIES - 1 )
+#define configTIMER_QUEUE_LENGTH                   5
+#define configTIMER_TASK_STACK_DEPTH               ( configMINIMAL_STACK_SIZE * 2 )
+
+/* Event group related definitions. */
+#define configUSE_EVENT_GROUPS                     1
+
+/* Run time stats gathering definitions. */
+#define configGENERATE_RUN_TIME_STATS              0
+
+/* Co-routine definitions. */
+#define configUSE_CO_ROUTINES                      0
+#define configMAX_CO_ROUTINE_PRIORITIES            ( 2 )
+
+/* Set the following definitions to 1 to include the API function, or zero
+ * to exclude the API function. */
+#define INCLUDE_vTaskPrioritySet                   1
+#define INCLUDE_uxTaskPriorityGet                  1
+#define INCLUDE_vTaskDelete                        1
+#define INCLUDE_vTaskCleanUpResources              0
+#define INCLUDE_vTaskSuspend                       1
+#define INCLUDE_vTaskDelayUntil                    1
+#define INCLUDE_vTaskDelay                         1
+#define INCLUDE_uxTaskGetStackHighWaterMark        1
+#define INCLUDE_xTaskGetSchedulerState             1
+#define INCLUDE_xTimerGetTimerTaskHandle           0
+#define INCLUDE_xTaskGetIdleTaskHandle             0
+#define INCLUDE_xQueueGetMutexHolder               1
+#define INCLUDE_eTaskGetState                      1
+#define INCLUDE_xEventGroupSetBitsFromISR          1
+#define INCLUDE_xTimerPendFunctionCall             1
+#define INCLUDE_pcTaskGetTaskName                  1
+
+/* This demo makes use of one or more example stats formatting functions.  These
+ * format the raw data provided by the uxTaskGetSystemState() function in to human
+ * readable ASCII form.  See the notes in the implementation of vTaskList() within
+ * FreeRTOS/Source/tasks.c for limitations.  configUSE_STATS_FORMATTING_FUNCTIONS
+ * is set to 2 so the formatting functions are included without the stdio.h being
+ * included in tasks.c.  That is because this project defines its own sprintf()
+ * functions. */
+#define configUSE_STATS_FORMATTING_FUNCTIONS       1
+
+/* Assert call defined for debug builds. */
+#ifdef _DEBUG
+    extern void vAssertCalled( const char * pcFile,
+                               uint32_t ulLine );
+    #define configASSERT( x )    if( ( x ) == 0 ) vAssertCalled( __FILE__, __LINE__ )
+#endif /* _DEBUG */
+
+
+
+/* Application specific definitions follow. **********************************/
+
+/* If configINCLUDE_DEMO_DEBUG_STATS is set to one, then a few basic IP trace
+ * macros are defined to gather some UDP stack statistics that can then be viewed
+ * through the CLI interface. */
+#define configINCLUDE_DEMO_DEBUG_STATS         1
+
+/* The size of the global output buffer that is available for use when there
+ * are multiple command interpreters running at once (for example, one on a UART
+ * and one on TCP/IP).  This is done to prevent an output buffer being defined by
+ * each implementation - which would waste RAM.  In this case, there is only one
+ * command interpreter running, and it has its own local output buffer, so the
+ * global buffer is just set to be one byte long as it is not used and should not
+ * take up unnecessary RAM. */
+#define configCOMMAND_INT_MAX_OUTPUT_SIZE      1
+
+/* Only used when running in the FreeRTOS Windows simulator.  Defines the
+ * priority of the task used to simulate Ethernet interrupts. */
+#define configMAC_ISR_SIMULATOR_PRIORITY       ( configMAX_PRIORITIES - 1 )
+
+/* This demo creates a virtual network connection by accessing the raw Ethernet
+ * or WiFi data to and from a real network connection.  Many computers have more
+ * than one real network port, and configNETWORK_INTERFACE_TO_USE is used to tell
+ * the demo which real port should be used to create the virtual port.  The ports
+ * available are displayed on the console when the application is executed.  For
+ * example, on my development laptop setting configNETWORK_INTERFACE_TO_USE to 4
+ * results in the wired network being used, while setting
+ * configNETWORK_INTERFACE_TO_USE to 2 results in the wireless network being
+ * used. */
+#define configNETWORK_INTERFACE_TO_USE         1L
+#define configNETWORK_INTERFACE_TYPE_TO_USE    "Realtek"
+
+/* The address of an echo server that will be used by the two demo echo client
+ * tasks.
+ * http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/TCP_Echo_Clients.html
+ * http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/UDP_Echo_Clients.html */
+#define configECHO_SERVER_ADDR0                192
+#define configECHO_SERVER_ADDR1                168
+#define configECHO_SERVER_ADDR2                2
+#define configECHO_SERVER_ADDR3                5
+
+/* Default MAC address configuration.  The demo creates a virtual network
+ * connection that uses this MAC address by accessing the raw Ethernet/WiFi data
+ * to and from a real network connection on the host PC.  See the
+ * configNETWORK_INTERFACE_TO_USE definition above for information on how to
+ * configure the real network connection to use. */
+#define configMAC_ADDR0                        0x00
+#define configMAC_ADDR1                        0x11
+#define configMAC_ADDR2                        0x22
+#define configMAC_ADDR3                        0x33
+#define configMAC_ADDR4                        0x44
+#define configMAC_ADDR5                        0x41
+
+/* Default IP address configuration.  Used in ipconfigUSE_DNS is set to 0, or
+ * ipconfigUSE_DNS is set to 1 but a DNS server cannot be contacted. */
+#define configIP_ADDR0                         192
+#define configIP_ADDR1                         168
+#define configIP_ADDR2                         2
+#define configIP_ADDR3                         114
+
+/* Default gateway IP address configuration.  Used in ipconfigUSE_DNS is set to
+ * 0, or ipconfigUSE_DNS is set to 1 but a DNS server cannot be contacted. */
+#define configGATEWAY_ADDR0                    192
+#define configGATEWAY_ADDR1                    168
+#define configGATEWAY_ADDR2                    2
+#define configGATEWAY_ADDR3                    1
+
+/* Default DNS server configuration.  OpenDNS addresses are 208.67.222.222 and
+ * 208.67.220.220.  Used in ipconfigUSE_DNS is set to 0, or ipconfigUSE_DNS is set
+ * to 1 but a DNS server cannot be contacted.*/
+#define configDNS_SERVER_ADDR0                 180
+#define configDNS_SERVER_ADDR1                 250
+#define configDNS_SERVER_ADDR2                 245
+#define configDNS_SERVER_ADDR3                 182
+
+/* Default netmask configuration.  Used in ipconfigUSE_DNS is set to 0, or
+ * ipconfigUSE_DNS is set to 1 but a DNS server cannot be contacted. */
+#define configNET_MASK0                        255
+#define configNET_MASK1                        255
+#define configNET_MASK2                        255
+#define configNET_MASK3                        0
+
+/* The UDP port to which print messages are sent. */
+#define configPRINT_PORT                       ( 15000 )
+
+#if ( defined( _MSC_VER ) && ( _MSC_VER <= 1600 ) && !defined( snprintf ) )
+    /* Map to Windows names. */
+    #define snprintf     _snprintf
+    #define vsnprintf    _vsnprintf
+#endif
+
+/* Visual studio does not have an implementation of strcasecmp(). */
+#define strcasecmp     _stricmp
+#define strncasecmp    _strnicmp
+#define strcmpi        _strcmpi
+
+#endif /* FREERTOS_CONFIG_H */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOSIPConfig.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOSIPConfig.h
new file mode 100644
index 000000000..ae6a7bb2f
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOSIPConfig.h
@@ -0,0 +1,322 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+
+/*****************************************************************************
+*
+* See the following URL for configuration information.
+* http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/TCP_IP_Configuration.html
+*
+*****************************************************************************/
+
+#ifndef FREERTOS_IP_CONFIG_H
+#define FREERTOS_IP_CONFIG_H
+
+/* Prototype for the function used to print out.  In this case it prints to the
+ * console before the network is connected then a UDP port after the network has
+ * connected. */
+extern void vLoggingPrintf( const char * pcFormatString,
+                            ... );
+
+/* Set to 1 to print out debug messages.  If ipconfigHAS_DEBUG_PRINTF is set to
+ * 1 then FreeRTOS_debug_printf should be defined to the function used to print
+ * out the debugging messages. */
+#define ipconfigHAS_DEBUG_PRINTF    1
+#if ( ipconfigHAS_DEBUG_PRINTF == 1 )
+    #define FreeRTOS_debug_printf( X )    vLoggingPrintf X
+#endif
+
+/* Set to 1 to print out non debugging messages, for example the output of the
+ * FreeRTOS_netstat() command, and ping replies.  If ipconfigHAS_PRINTF is set to 1
+ * then FreeRTOS_printf should be set to the function used to print out the
+ * messages. */
+#define ipconfigHAS_PRINTF    1
+#if ( ipconfigHAS_PRINTF == 1 )
+    #define FreeRTOS_printf( X )    vLoggingPrintf X
+#endif
+
+/* Define the byte order of the target MCU (the MCU FreeRTOS+TCP is executing
+ * on).  Valid options are pdFREERTOS_BIG_ENDIAN and pdFREERTOS_LITTLE_ENDIAN. */
+#define ipconfigBYTE_ORDER                         pdFREERTOS_LITTLE_ENDIAN
+
+/* If the network card/driver includes checksum offloading (IP/TCP/UDP checksums)
+ * then set ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM to 1 to prevent the software
+ * stack repeating the checksum calculations. */
+#define ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM     1
+
+/* Several API's will block until the result is known, or the action has been
+ * performed, for example FreeRTOS_send() and FreeRTOS_recv().  The timeouts can be
+ * set per socket, using setsockopt().  If not set, the times below will be
+ * used as defaults. */
+#define ipconfigSOCK_DEFAULT_RECEIVE_BLOCK_TIME    ( 5000 )
+#define ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME       ( 5000 )
+
+/* Include support for LLMNR: Link-local Multicast Name Resolution
+ * (non-Microsoft) */
+#define ipconfigUSE_LLMNR                          ( 1 )
+
+/* Include support for NBNS: NetBIOS Name Service (Microsoft) */
+#define ipconfigUSE_NBNS                           ( 1 )
+
+/* Include support for DNS caching.  For TCP, having a small DNS cache is very
+ * useful.  When a cache is present, ipconfigDNS_REQUEST_ATTEMPTS can be kept low
+ * and also DNS may use small timeouts.  If a DNS reply comes in after the DNS
+ * socket has been destroyed, the result will be stored into the cache.  The next
+ * call to FreeRTOS_gethostbyname() will return immediately, without even creating
+ * a socket. */
+#define ipconfigUSE_DNS_CACHE                      ( 1 )
+#define ipconfigDNS_CACHE_NAME_LENGTH              ( 33 )
+#define ipconfigDNS_CACHE_ENTRIES                  ( 4 )
+#define ipconfigDNS_REQUEST_ATTEMPTS               ( 2 )
+
+/* Let DNS wait for 3 seconds for an answer. */
+#define ipconfigDNS_RECEIVE_BLOCK_TIME_TICKS       pdMS_TO_TICKS( 3000U )
+
+/* The IP stack executes it its own task (although any application task can make
+ * use of its services through the published sockets API). ipconfigUDP_TASK_PRIORITY
+ * sets the priority of the task that executes the IP stack.  The priority is a
+ * standard FreeRTOS task priority so can take any value from 0 (the lowest
+ * priority) to (configMAX_PRIORITIES - 1) (the highest priority).
+ * configMAX_PRIORITIES is a standard FreeRTOS configuration parameter defined in
+ * FreeRTOSConfig.h, not FreeRTOSIPConfig.h. Consideration needs to be given as to
+ * the priority assigned to the task executing the IP stack relative to the
+ * priority assigned to tasks that use the IP stack. */
+#define ipconfigIP_TASK_PRIORITY                   ( configMAX_PRIORITIES - 2 )
+
+/* The size, in words (not bytes), of the stack allocated to the FreeRTOS+TCP
+ * task.  This setting is less important when the FreeRTOS Win32 simulator is used
+ * as the Win32 simulator only stores a fixed amount of information on the task
+ * stack.  FreeRTOS includes optional stack overflow detection, see:
+ * http://www.freertos.org/Stacks-and-stack-overflow-checking.html */
+#define ipconfigIP_TASK_STACK_SIZE_WORDS           ( configMINIMAL_STACK_SIZE * 5 )
+
+/* ipconfigRAND32() is called by the IP stack to generate random numbers for
+ * things such as a DHCP transaction number or initial sequence number.  Random
+ * number generation is performed via this macro to allow applications to use their
+ * own random number generation method.  For example, it might be possible to
+ * generate a random number by sampling noise on an analogue input. */
+extern UBaseType_t uxRand();
+#define ipconfigRAND32()    uxRand()
+
+/* If ipconfigUSE_NETWORK_EVENT_HOOK is set to 1 then FreeRTOS+TCP will call the
+ * network event hook at the appropriate times.  If ipconfigUSE_NETWORK_EVENT_HOOK
+ * is not set to 1 then the network event hook will never be called.  See
+ * http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_UDP/API/vApplicationIPNetworkEventHook.shtml
+ */
+#define ipconfigUSE_NETWORK_EVENT_HOOK                 1
+
+/* Sockets have a send block time attribute.  If FreeRTOS_sendto() is called but
+ * a network buffer cannot be obtained then the calling task is held in the Blocked
+ * state (so other tasks can continue to executed) until either a network buffer
+ * becomes available or the send block time expires.  If the send block time expires
+ * then the send operation is aborted.  The maximum allowable send block time is
+ * capped to the value set by ipconfigMAX_SEND_BLOCK_TIME_TICKS.  Capping the
+ * maximum allowable send block time prevents prevents a deadlock occurring when
+ * all the network buffers are in use and the tasks that process (and subsequently
+ * free) the network buffers are themselves blocked waiting for a network buffer.
+ * ipconfigMAX_SEND_BLOCK_TIME_TICKS is specified in RTOS ticks.  A time in
+ * milliseconds can be converted to a time in ticks by dividing the time in
+ * milliseconds by portTICK_PERIOD_MS. */
+#define ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS          ( 5000U / portTICK_PERIOD_MS )
+
+/* If ipconfigUSE_DHCP is 1 then FreeRTOS+TCP will attempt to retrieve an IP
+ * address, netmask, DNS server address and gateway address from a DHCP server.  If
+ * ipconfigUSE_DHCP is 0 then FreeRTOS+TCP will use a static IP address.  The
+ * stack will revert to using the static IP address even when ipconfigUSE_DHCP is
+ * set to 1 if a valid configuration cannot be obtained from a DHCP server for any
+ * reason.  The static configuration used is that passed into the stack by the
+ * FreeRTOS_IPInit() function call. */
+#define ipconfigUSE_DHCP                               1
+
+/* When ipconfigUSE_DHCP is set to 1, DHCP requests will be sent out at
+ * increasing time intervals until either a reply is received from a DHCP server
+ * and accepted, or the interval between transmissions reaches
+ * ipconfigMAXIMUM_DISCOVER_TX_PERIOD.  The IP stack will revert to using the
+ * static IP address passed as a parameter to FreeRTOS_IPInit() if the
+ * re-transmission time interval reaches ipconfigMAXIMUM_DISCOVER_TX_PERIOD without
+ * a DHCP reply being received. */
+#define ipconfigMAXIMUM_DISCOVER_TX_PERIOD             ( 120000U / portTICK_PERIOD_MS )
+
+/* The ARP cache is a table that maps IP addresses to MAC addresses.  The IP
+ * stack can only send a UDP message to a remove IP address if it knowns the MAC
+ * address associated with the IP address, or the MAC address of the router used to
+ * contact the remote IP address.  When a UDP message is received from a remote IP
+ * address the MAC address and IP address are added to the ARP cache.  When a UDP
+ * message is sent to a remote IP address that does not already appear in the ARP
+ * cache then the UDP message is replaced by a ARP message that solicits the
+ * required MAC address information.  ipconfigARP_CACHE_ENTRIES defines the maximum
+ * number of entries that can exist in the ARP table at any one time. */
+#define ipconfigARP_CACHE_ENTRIES                      6
+
+/* ARP requests that do not result in an ARP response will be re-transmitted a
+ * maximum of ipconfigMAX_ARP_RETRANSMISSIONS times before the ARP request is
+ * aborted. */
+#define ipconfigMAX_ARP_RETRANSMISSIONS                ( 5 )
+
+/* ipconfigMAX_ARP_AGE defines the maximum time between an entry in the ARP
+ * table being created or refreshed and the entry being removed because it is stale.
+ * New ARP requests are sent for ARP cache entries that are nearing their maximum
+ * age.  ipconfigMAX_ARP_AGE is specified in tens of seconds, so a value of 150 is
+ * equal to 1500 seconds (or 25 minutes). */
+#define ipconfigMAX_ARP_AGE                            150
+
+/* Implementing FreeRTOS_inet_addr() necessitates the use of string handling
+ * routines, which are relatively large.  To save code space the full
+ * FreeRTOS_inet_addr() implementation is made optional, and a smaller and faster
+ * alternative called FreeRTOS_inet_addr_quick() is provided.  FreeRTOS_inet_addr()
+ * takes an IP in decimal dot format (for example, "192.168.0.1") as its parameter.
+ * FreeRTOS_inet_addr_quick() takes an IP address as four separate numerical octets
+ * (for example, 192, 168, 0, 1) as its parameters.  If
+ * ipconfigINCLUDE_FULL_INET_ADDR is set to 1 then both FreeRTOS_inet_addr() and
+ * FreeRTOS_indet_addr_quick() are available.  If ipconfigINCLUDE_FULL_INET_ADDR is
+ * not set to 1 then only FreeRTOS_indet_addr_quick() is available. */
+#define ipconfigINCLUDE_FULL_INET_ADDR                 1
+
+/* ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS defines the total number of network buffer that
+ * are available to the IP stack.  The total number of network buffers is limited
+ * to ensure the total amount of RAM that can be consumed by the IP stack is capped
+ * to a pre-determinable value. */
+#define ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS         60
+
+/* A FreeRTOS queue is used to send events from application tasks to the IP
+ * stack.  ipconfigEVENT_QUEUE_LENGTH sets the maximum number of events that can
+ * be queued for processing at any one time.  The event queue must be a minimum of
+ * 5 greater than the total number of network buffers. */
+#define ipconfigEVENT_QUEUE_LENGTH                     ( ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS + 5 )
+
+/* The address of a socket is the combination of its IP address and its port
+ * number.  FreeRTOS_bind() is used to manually allocate a port number to a socket
+ * (to 'bind' the socket to a port), but manual binding is not normally necessary
+ * for client sockets (those sockets that initiate outgoing connections rather than
+ * wait for incoming connections on a known port number).  If
+ * ipconfigALLOW_SOCKET_SEND_WITHOUT_BIND is set to 1 then calling
+ * FreeRTOS_sendto() on a socket that has not yet been bound will result in the IP
+ * stack automatically binding the socket to a port number from the range
+ * socketAUTO_PORT_ALLOCATION_START_NUMBER to 0xffff.  If
+ * ipconfigALLOW_SOCKET_SEND_WITHOUT_BIND is set to 0 then calling FreeRTOS_sendto()
+ * on a socket that has not yet been bound will result in the send operation being
+ * aborted. */
+#define ipconfigALLOW_SOCKET_SEND_WITHOUT_BIND         1
+
+/* Defines the Time To Live (TTL) values used in outgoing UDP packets. */
+#define ipconfigUDP_TIME_TO_LIVE                       128
+#define ipconfigTCP_TIME_TO_LIVE                       128 /* also defined in FreeRTOSIPConfigDefaults.h */
+
+/* USE_TCP: Use TCP and all its features */
+#define ipconfigUSE_TCP                                ( 1 )
+
+/* USE_WIN: Let TCP use windowing mechanism. */
+#define ipconfigUSE_TCP_WIN                            ( 1 )
+
+/* The MTU is the maximum number of bytes the payload of a network frame can
+ * contain.  For normal Ethernet V2 frames the maximum MTU is 1500.  Setting a
+ * lower value can save RAM, depending on the buffer management scheme used.  If
+ * ipconfigCAN_FRAGMENT_OUTGOING_PACKETS is 1 then (ipconfigNETWORK_MTU - 28) must
+ * be divisible by 8. */
+#define ipconfigNETWORK_MTU                            1200U
+
+/* Set ipconfigUSE_DNS to 1 to include a basic DNS client/resolver.  DNS is used
+ * through the FreeRTOS_gethostbyname() API function. */
+#define ipconfigUSE_DNS                                1
+
+#define ipconfigUSE_MDNS                               1
+
+/* If ipconfigREPLY_TO_INCOMING_PINGS is set to 1 then the IP stack will
+ * generate replies to incoming ICMP echo (ping) requests. */
+#define ipconfigREPLY_TO_INCOMING_PINGS                1
+
+/* If ipconfigSUPPORT_OUTGOING_PINGS is set to 1 then the
+ * FreeRTOS_SendPingRequest() API function is available. */
+#define ipconfigSUPPORT_OUTGOING_PINGS                 1
+
+/* If ipconfigSUPPORT_SELECT_FUNCTION is set to 1 then the FreeRTOS_select()
+ * (and associated) API function is available. */
+#define ipconfigSUPPORT_SELECT_FUNCTION                1
+
+/* If ipconfigFILTER_OUT_NON_ETHERNET_II_FRAMES is set to 1 then Ethernet frames
+ * that are not in Ethernet II format will be dropped.  This option is included for
+ * potential future IP stack developments. */
+#define ipconfigFILTER_OUT_NON_ETHERNET_II_FRAMES      1
+
+/* If ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES is set to 1 then it is the
+ * responsibility of the Ethernet interface to filter out packets that are of no
+ * interest.  If the Ethernet interface does not implement this functionality, then
+ * set ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES to 0 to have the IP stack
+ * perform the filtering instead (it is much less efficient for the stack to do it
+ * because the packet will already have been passed into the stack).  If the
+ * Ethernet driver does all the necessary filtering in hardware then software
+ * filtering can be removed by using a value other than 1 or 0. */
+#define ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES    1
+
+/* The windows simulator cannot really simulate MAC interrupts, and needs to
+ * block occasionally to allow other tasks to run. */
+#define configWINDOWS_MAC_INTERRUPT_SIMULATOR_DELAY    ( 20 / portTICK_PERIOD_MS )
+
+/* Advanced only: in order to access 32-bit fields in the IP packets with
+ * 32-bit memory instructions, all packets will be stored 32-bit-aligned, plus 16-bits.
+ * This has to do with the contents of the IP-packets: all 32-bit fields are
+ * 32-bit-aligned, plus 16-bit(!) */
+#define ipconfigPACKET_FILLER_SIZE                     2U
+
+/* Define the size of the pool of TCP window descriptors.  On the average, each
+ * TCP socket will use up to 2 x 6 descriptors, meaning that it can have 2 x 6
+ * outstanding packets (for Rx and Tx).  When using up to 10 TP sockets
+ * simultaneously, one could define TCP_WIN_SEG_COUNT as 120. */
+#define ipconfigTCP_WIN_SEG_COUNT                      240
+
+/* Each TCP socket has a circular buffers for Rx and Tx, which have a fixed
+ * maximum size.  Define the size of Rx buffer for TCP sockets. */
+#define ipconfigTCP_RX_BUFFER_LENGTH                   ( 1000 )
+
+/* Define the size of Tx buffer for TCP sockets. */
+#define ipconfigTCP_TX_BUFFER_LENGTH                   ( 1000 )
+
+/* When using call-back handlers, the driver may check if the handler points to
+ * real program memory (RAM or flash) or just has a random non-zero value. */
+#define ipconfigIS_VALID_PROG_ADDRESS( x )    ( ( x ) != NULL )
+
+/* Include support for TCP hang protection.  All sockets in a connecting or
+ * disconnecting stage will timeout after a period of non-activity. */
+#define ipconfigTCP_HANG_PROTECTION         ( 1 )
+#define ipconfigTCP_HANG_PROTECTION_TIME    ( 30 )
+
+/* Include support for TCP keep-alive messages. */
+#define ipconfigTCP_KEEP_ALIVE              ( 1 )
+#define ipconfigTCP_KEEP_ALIVE_INTERVAL     ( 20 ) /* in seconds */
+
+#define portINLINE                          __inline
+
+#define ipconfigMULTI_INTERFACE             1
+#define ipconfigCOMPATIBLE_WITH_SINGLE      0
+#define ipconfigUSE_NTP_DEMO                1
+#define ipconfigDNS_USE_CALLBACKS           1
+#define ipconfigSUPPORT_SIGNALS             1
+#define ipconfigUSE_IPv6                    1
+#define ipconfigUSE_IPv6                    1
+#define ipconfigUSE_RA                      0
+#define ipconfigSUPPORT_OUTGOING_PINGS      1
+
+#endif /* FREERTOS_IP_CONFIG_H */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOS_Plus_TCP_IPv6_Multi.props b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOS_Plus_TCP_IPv6_Multi.props
new file mode 100644
index 000000000..8760d44f4
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOS_Plus_TCP_IPv6_Multi.props
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <COMMENT>
+	The following macros define the locations where the FreeRTOS kernel and
+	other libraries can be found. Note that an absolut path may also used.
+	Please try to avoid paths that contain whitespace.
+	</COMMENT>
+    <FREERTOS_SOURCE_DIR>..\..\..\Source\FreeRTOS-Plus-TCP\test\FreeRTOS-Kernel</FREERTOS_SOURCE_DIR>
+    <FREERTOS_INCLUDE_DIR>..\..\..\Source\FreeRTOS-Plus-TCP\test\FreeRTOS-Kernel\include</FREERTOS_INCLUDE_DIR>
+    <DEMO_COMMON_SOURCE_DIR>..\common</DEMO_COMMON_SOURCE_DIR>
+    <PLUS_TCP_SOURCE_DIR>..\..\..\Source\FreeRTOS-Plus-TCP\source</PLUS_TCP_SOURCE_DIR>
+    <PLUS_TCP_INCLUDE_DIR>..\..\..\Source\FreeRTOS-Plus-TCP\source\include</PLUS_TCP_INCLUDE_DIR>
+	<UTILITIES_SOURCE_DIR>..\..\..\Source\FreeRTOS-Plus-TCP\tools\tcp_utilities</UTILITIES_SOURCE_DIR>
+ </PropertyGroup>
+  <PropertyGroup />
+  <ItemDefinitionGroup />
+  <ItemGroup>
+    <BuildMacro Include="PLUS_TCP_SOURCE_DIR">
+      <Value>$(PLUS_TCP_SOURCE_DIR)</Value>
+    </BuildMacro>
+    <BuildMacro Include="PLUS_TCP_INCLUDE_DIR">
+      <Value>$(PLUS_TCP_INCLUDE_DIR)</Value>
+    </BuildMacro>
+    <BuildMacro Include="FREERTOS_SOURCE_DIR">
+      <Value>$(FREERTOS_SOURCE_DIR)</Value>
+    </BuildMacro>
+    <BuildMacro Include="FREERTOS_INCLUDE_DIR">
+      <Value>$(FREERTOS_INCLUDE_DIR)</Value>
+    </BuildMacro>
+  </ItemGroup>
+</Project>
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOS_Plus_TCP_IPv6_Multi.sln b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOS_Plus_TCP_IPv6_Multi.sln
new file mode 100644
index 000000000..99fabe95e
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/FreeRTOS_Plus_TCP_IPv6_Multi.sln
@@ -0,0 +1,23 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RTOSDemo", "WIN32.vcxproj", "{C686325E-3261-42F7-AEB1-DDE5280E1CEB}"
+EndProject
+Global
+	GlobalSection(TestCaseManagementSettings) = postSolution
+		CategoryFile = FreeRTOS_Plus_TCP_IPv6_Multi.vsmdi
+	EndGlobalSection
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{C686325E-3261-42F7-AEB1-DDE5280E1CEB}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C686325E-3261-42F7-AEB1-DDE5280E1CEB}.Debug|Win32.Build.0 = Debug|Win32
+		{C686325E-3261-42F7-AEB1-DDE5280E1CEB}.Release|Win32.ActiveCfg = Release|Win32
+		{C686325E-3261-42F7-AEB1-DDE5280E1CEB}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/Logging_WinSim.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/Logging_WinSim.c
new file mode 100644
index 000000000..742c77d1c
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/Logging_WinSim.c
@@ -0,0 +1,553 @@
+/*

+ * FreeRTOS V202212.00

+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * https://www.FreeRTOS.org

+ * https://github.com/FreeRTOS

+ *

+ */

+

+/*

+ * Logging utility that allows FreeRTOS tasks to log to a UDP port, stdout, and

+ * disk file without making any Win32 system calls themselves.

+ *

+ * Messages logged to a UDP port are sent directly (using FreeRTOS+TCP), but as

+ * FreeRTOS tasks cannot make Win32 system calls messages sent to stdout or a

+ * disk file are sent via a stream buffer to a Win32 thread which then performs

+ * the actual output.

+ */

+

+/* Standard includes. */

+#include <stdio.h>

+#include <stdint.h>

+#include <stdarg.h>

+#include <io.h>

+#include <ctype.h>

+

+/* FreeRTOS includes. */

+#include <FreeRTOS.h>

+#include "task.h"

+

+/* FreeRTOS+TCP includes. */

+#include "FreeRTOS_IP.h"

+#include "FreeRTOS_Sockets.h"

+#include "FreeRTOS_Stream_Buffer.h"

+

+/* Demo includes. */

+#include "logging.h"

+

+/*-----------------------------------------------------------*/

+

+/* The maximum size to which the log file may grow, before being renamed

+ * to .ful. */

+#define dlLOGGING_FILE_SIZE             ( 40ul * 1024ul * 1024ul )

+

+/* Dimensions the arrays into which print messages are created. */

+#define dlMAX_PRINT_STRING_LENGTH       255

+

+/* The size of the stream buffer used to pass messages from FreeRTOS tasks to

+ * the Win32 thread that is responsible for making any Win32 system calls that are

+ * necessary for the selected logging method. */

+#define dlLOGGING_STREAM_BUFFER_SIZE    32768

+

+/* A block time of zero simply means don't block. */

+#define dlDONT_BLOCK                    0

+

+/*-----------------------------------------------------------*/

+

+/*

+ * Called from vLoggingInit() to start a new disk log file.

+ */

+static void prvFileLoggingInit( void );

+

+/*

+ * Attempt to write a message to the file.

+ */

+static void prvLogToFile( const char * pcMessage,

+                          size_t xLength );

+

+/*

+ * Simply close the logging file, if it is open.

+ */

+static void prvFileClose( void );

+

+/*

+ * Before the scheduler is started this function is called directly.  After the

+ * scheduler has started it is called from the Windows thread dedicated to

+ * outputting log messages.  Only the windows thread actually performs the

+ * writing so as not to disrupt the simulation by making Windows system calls

+ * from FreeRTOS tasks.

+ */

+static void prvLoggingFlushBuffer( void );

+

+/*

+ * The windows thread that performs the actual writing of messages that require

+ * Win32 system calls.  Only the windows thread can make system calls so as not

+ * to disrupt the simulation by making Windows calls from FreeRTOS tasks.

+ */

+static DWORD WINAPI prvWin32LoggingThread( void * pvParam );

+

+/*

+ * Creates the socket to which UDP messages are sent.  This function is not

+ * called directly to prevent the print socket being created from within the IP

+ * task - which could result in a deadlock.  Instead the function call is

+ * deferred to run in the RTOS daemon task - hence it prototype.

+ */

+static void prvCreatePrintSocket( void * pvParameter1,

+                                  uint32_t ulParameter2 );

+

+/*-----------------------------------------------------------*/

+

+/* Windows event used to wake the Win32 thread which performs any logging that

+ * needs Win32 system calls. */

+static void * pvLoggingThreadEvent = NULL;

+

+/* Stores the selected logging targets passed in as parameters to the

+ * vLoggingInit() function. */

+BaseType_t xStdoutLoggingUsed = pdFALSE, xDiskFileLoggingUsed = pdFALSE, xUDPLoggingUsed = pdFALSE;

+

+/* Circular buffer used to pass messages from the FreeRTOS tasks to the Win32

+ * thread that is responsible for making Win32 calls (when stdout or a disk log is

+ * used). */

+static StreamBuffer_t * xLogStreamBuffer = NULL;

+

+/* Handle to the file used for logging.  This is left open while there are

+ * messages waiting to be logged, then closed again in between logs. */

+static FILE * pxLoggingFileHandle = NULL;

+

+/* When true prints are performed directly.  After start up xDirectPrint is set

+ * to pdFALSE - at which time prints that require Win32 system calls are done by

+ * the Win32 thread responsible for logging. */

+BaseType_t xDirectPrint = pdTRUE;

+

+/* File names for the in use and complete (full) log files. */

+static const char * pcLogFileName = "RTOSDemo.log";

+static const char * pcFullLogFileName = "RTOSDemo.ful";

+

+/* As an optimization, the current file size is kept in a variable. */

+static size_t ulSizeOfLoggingFile = 0ul;

+

+/* The UDP socket and address on/to which print messages are sent. */

+Socket_t xPrintSocket = FREERTOS_INVALID_SOCKET;

+struct freertos_sockaddr xPrintUDPAddress;

+

+/*-----------------------------------------------------------*/

+

+void vLoggingInit( BaseType_t xLogToStdout,

+                   BaseType_t xLogToFile,

+                   BaseType_t xLogToUDP,

+                   uint32_t ulRemoteIPAddress,

+                   uint16_t usRemotePort )

+{

+    /* Can only be called before the scheduler has started. */

+    configASSERT( xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED );

+

+    #if ( ( ipconfigHAS_DEBUG_PRINTF == 1 ) || ( ipconfigHAS_PRINTF == 1 ) )

+        {

+            HANDLE Win32Thread;

+

+            /* Record which output methods are to be used. */

+            xStdoutLoggingUsed = xLogToStdout;

+            xDiskFileLoggingUsed = xLogToFile;

+            xUDPLoggingUsed = xLogToUDP;

+

+            /* If a disk file is used then initialize it now. */

+            if( xDiskFileLoggingUsed != pdFALSE )

+            {

+                prvFileLoggingInit();

+            }

+

+            /* If UDP logging is used then store the address to which the log data

+             * will be sent - but don't create the socket yet because the network is

+             * not initialized. */

+            if( xUDPLoggingUsed != pdFALSE )

+            {

+                /* Set the address to which the print messages are sent. */

+                xPrintUDPAddress.sin_port = FreeRTOS_htons( usRemotePort );

+                xPrintUDPAddress.sin_addr = ulRemoteIPAddress;

+            }

+

+            /* If a disk file or stdout are to be used then Win32 system calls will

+             * have to be made.  Such system calls cannot be made from FreeRTOS tasks

+             * so create a stream buffer to pass the messages to a Win32 thread, then

+             * create the thread itself, along with a Win32 event that can be used to

+             * unblock the thread. */

+            if( ( xStdoutLoggingUsed != pdFALSE ) || ( xDiskFileLoggingUsed != pdFALSE ) )

+            {

+                /* Create the buffer. */

+                xLogStreamBuffer = ( StreamBuffer_t * ) malloc( sizeof( *xLogStreamBuffer ) - sizeof( xLogStreamBuffer->ucArray ) + dlLOGGING_STREAM_BUFFER_SIZE + 1 );

+                configASSERT( xLogStreamBuffer );

+                memset( xLogStreamBuffer, '\0', sizeof( *xLogStreamBuffer ) - sizeof( xLogStreamBuffer->ucArray ) );

+                xLogStreamBuffer->LENGTH = dlLOGGING_STREAM_BUFFER_SIZE + 1;

+

+                /* Create the Windows event. */

+                pvLoggingThreadEvent = CreateEvent( NULL, FALSE, TRUE, "StdoutLoggingEvent" );

+

+                /* Create the thread itself. */

+                Win32Thread = CreateThread(

+                    NULL,                  /* Pointer to thread security attributes. */

+                    0,                     /* Initial thread stack size, in bytes. */

+                    prvWin32LoggingThread, /* Pointer to thread function. */

+                    NULL,                  /* Argument for new thread. */

+                    0,                     /* Creation flags. */

+                    NULL );

+

+                /* Use the cores that are not used by the FreeRTOS tasks. */

+                SetThreadAffinityMask( Win32Thread, ~0x01u );

+                SetThreadPriorityBoost( Win32Thread, TRUE );

+                SetThreadPriority( Win32Thread, THREAD_PRIORITY_IDLE );

+            }

+        }

+    #else /* if ( ( ipconfigHAS_DEBUG_PRINTF == 1 ) || ( ipconfigHAS_PRINTF == 1 ) ) */

+        {

+            /* FreeRTOSIPConfig is set such that no print messages will be output.

+             * Avoid compiler warnings about unused parameters. */

+            ( void ) xLogToStdout;

+            ( void ) xLogToFile;

+            ( void ) xLogToUDP;

+            ( void ) usRemotePort;

+            ( void ) ulRemoteIPAddress;

+        }

+    #endif /* ( ipconfigHAS_DEBUG_PRINTF == 1 ) || ( ipconfigHAS_PRINTF == 1 )  */

+}

+/*-----------------------------------------------------------*/

+

+static void prvCreatePrintSocket( void * pvParameter1,

+                                  uint32_t ulParameter2 )

+{

+    static const TickType_t xSendTimeOut = pdMS_TO_TICKS( 0 );

+    Socket_t xSocket;

+

+    /* The function prototype is that of a deferred function, but the parameters

+     * are not actually used. */

+    ( void ) pvParameter1;

+    ( void ) ulParameter2;

+

+    xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );

+

+    if( xSocket != FREERTOS_INVALID_SOCKET )

+    {

+        /* FreeRTOS+TCP decides which port to bind to. */

+        FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, &xSendTimeOut, sizeof( xSendTimeOut ) );

+        FreeRTOS_bind( xSocket, NULL, 0 );

+

+        /* Now the socket is bound it can be assigned to the print socket. */

+        xPrintSocket = xSocket;

+    }

+}

+/*-----------------------------------------------------------*/

+

+static TickType_t ulTicksToMS( TickType_t uxTicks )

+{

+    uint64_t ullCount = uxTicks;

+

+    ullCount = ullCount * ( 1000U / configTICK_RATE_HZ );

+    return ( uint32_t ) ullCount;

+}

+

+void vLoggingPrintf( const char * pcFormat,

+                     ... )

+{

+    char cPrintString[ dlMAX_PRINT_STRING_LENGTH ];

+    char cOutputString[ dlMAX_PRINT_STRING_LENGTH ];

+    char * pcSource, * pcTarget, * pcBegin;

+    size_t xLength, xLength2, rc;

+    static BaseType_t xMessageNumber = 0;

+    static BaseType_t xAfterLineBreak = pdTRUE;

+    va_list args;

+    unsigned ulIPAddress;

+    const char * pcTaskName;

+    const char * pcNoTask = "None";

+    int iOriginalPriority;

+    HANDLE xCurrentTask;

+

+

+    if( ( xStdoutLoggingUsed != pdFALSE ) || ( xDiskFileLoggingUsed != pdFALSE ) || ( xUDPLoggingUsed != pdFALSE ) )

+    {

+        /* There are a variable number of parameters. */

+        va_start( args, pcFormat );

+

+        /* Additional info to place at the start of the log. */

+        if( xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED )

+        {

+            pcTaskName = pcTaskGetName( NULL );

+        }

+        else

+        {

+            pcTaskName = pcNoTask;

+        }

+

+        if( ( xAfterLineBreak == pdTRUE ) && ( strcmp( pcFormat, "\r\n" ) != 0 ) )

+        {

+            TickType_t uxTickCount = ulTicksToMS( xTaskGetTickCount() );

+            TickType_t ulSeconds = uxTickCount / 1000U;

+            TickType_t ulMsecs = uxTickCount % 1000U;

+            xLength = snprintf( cPrintString, dlMAX_PRINT_STRING_LENGTH, "%u %u.%03u [%-*s] ",

+                                ( unsigned ) xMessageNumber++,

+                                ( unsigned ) ulSeconds,

+                                ( unsigned ) ulMsecs,

+                                configMAX_TASK_NAME_LEN,

+                                pcTaskName );

+            /* xAfterLineBreak = pdFALSE; */

+        }

+        else

+        {

+            xLength = 0;

+            memset( cPrintString, 0x00, dlMAX_PRINT_STRING_LENGTH );

+            xAfterLineBreak = pdTRUE;

+        }

+

+        xLength2 = vsnprintf( cPrintString + xLength, dlMAX_PRINT_STRING_LENGTH - xLength, pcFormat, args );

+

+        if( xLength2 < 0 )

+        {

+            /* Clean up. */

+            xLength2 = dlMAX_PRINT_STRING_LENGTH - 1 - xLength;

+            cPrintString[ dlMAX_PRINT_STRING_LENGTH - 1 ] = '\0';

+        }

+

+        xLength += xLength2;

+        va_end( args );

+

+        /* For ease of viewing, copy the string into another buffer, converting

+         * IP addresses to dot notation on the way. */

+        pcSource = cPrintString;

+        pcTarget = cOutputString;

+

+        while( ( *pcSource ) != '\0' )

+        {

+            *pcTarget = *pcSource;

+            pcTarget++;

+            pcSource++;

+

+            /* Look forward for an IP address denoted by 'ip'. */

+            if( ( isxdigit( pcSource[ 0 ] ) != pdFALSE ) && ( pcSource[ 1 ] == 'i' ) && ( pcSource[ 2 ] == 'p' ) )

+            {

+                *pcTarget = *pcSource;

+                pcTarget++;

+                *pcTarget = '\0';

+                pcBegin = pcTarget - 8;

+

+                while( ( pcTarget > pcBegin ) && ( isxdigit( pcTarget[ -1 ] ) != pdFALSE ) )

+                {

+                    pcTarget--;

+                }

+

+                ( void ) sscanf( pcTarget, "%8X", &ulIPAddress );

+                rc = sprintf( pcTarget, "%lu.%lu.%lu.%lu",

+                              ( unsigned long ) ( ulIPAddress >> 24UL ),

+                              ( unsigned long ) ( ( ulIPAddress >> 16UL ) & 0xffUL ),

+                              ( unsigned long ) ( ( ulIPAddress >> 8UL ) & 0xffUL ),

+                              ( unsigned long ) ( ulIPAddress & 0xffUL ) );

+                pcTarget += rc;

+                pcSource += 3; /* skip "<n>ip" */

+            }

+        }

+

+        /* How far through the buffer was written? */

+        xLength = ( BaseType_t ) ( pcTarget - cOutputString );

+

+        /* If the message is to be logged to a UDP port then it can be sent directly

+         * because it only uses FreeRTOS function (not Win32 functions). */

+        if( xUDPLoggingUsed != pdFALSE )

+        {

+            #if 0  /* _HT_ Logging doesn't need UDP logging for WinSim. */

+                if( ( xPrintSocket == FREERTOS_INVALID_SOCKET ) && ( FreeRTOS_IsNetworkUp() != pdFALSE ) )

+                {

+                    /* Create and bind the socket to which print messages are sent.  The

+                     * xTimerPendFunctionCall() function is used even though this is

+                     * not an interrupt because this function is called from the IP task

+                     * and the	IP task cannot itself wait for a socket to bind.  The

+                     * parameters to prvCreatePrintSocket() are not required so set to

+                     * NULL or 0. */

+                    xTimerPendFunctionCall( prvCreatePrintSocket, NULL, 0, dlDONT_BLOCK );

+                }

+

+                if( xPrintSocket != FREERTOS_INVALID_SOCKET )

+                {

+                    FreeRTOS_sendto( xPrintSocket, cOutputString, xLength, 0, &xPrintUDPAddress, sizeof( xPrintUDPAddress ) );

+

+                    /* Just because the UDP data logger I'm using is dumb. */

+                    FreeRTOS_sendto( xPrintSocket, "\r", sizeof( char ), 0, &xPrintUDPAddress, sizeof( xPrintUDPAddress ) );

+                }

+            #endif /* 0 */

+        }

+

+        /* If logging is also to go to either stdout or a disk file then it cannot

+         * be output here - so instead write the message to the stream buffer and wake

+         * the Win32 thread which will read it from the stream buffer and perform the

+         * actual output. */

+        if( ( xStdoutLoggingUsed != pdFALSE ) || ( xDiskFileLoggingUsed != pdFALSE ) )

+        {

+            configASSERT( xLogStreamBuffer );

+

+            /* How much space is in the buffer? */

+            xLength2 = uxStreamBufferGetSpace( xLogStreamBuffer );

+

+            /* There must be enough space to write both the string and the length of

+             * the string. */

+            if( xLength2 >= ( xLength + sizeof( xLength ) ) )

+            {

+                /* First write in the length of the data, then write in the data

+                 * itself.  Raising the thread priority is used as a critical section

+                 * as there are potentially multiple writers.  The stream buffer is

+                 * only thread safe when there is a single writer (likewise for

+                 * reading from the buffer). */

+                xCurrentTask = GetCurrentThread();

+                iOriginalPriority = GetThreadPriority( xCurrentTask );

+                SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL );

+                uxStreamBufferAdd( xLogStreamBuffer, 0, ( const uint8_t * ) &( xLength ), sizeof( xLength ) );

+                uxStreamBufferAdd( xLogStreamBuffer, 0, ( const uint8_t * ) cOutputString, xLength );

+                SetThreadPriority( GetCurrentThread(), iOriginalPriority );

+            }

+

+            /* xDirectPrint is initialized to pdTRUE, and while it remains true the

+             * logging output function is called directly.  When the system is running

+             * the output function cannot be called directly because it would get

+             * called from both FreeRTOS tasks and Win32 threads - so instead wake the

+             * Win32 thread responsible for the actual output. */

+            if( xDirectPrint != pdFALSE )

+            {

+                /* While starting up, the thread which calls prvWin32LoggingThread()

+                 * is not running yet and xDirectPrint will be pdTRUE. */

+                prvLoggingFlushBuffer();

+            }

+            else if( pvLoggingThreadEvent != NULL )

+            {

+                /* While running, wake up prvWin32LoggingThread() to send the

+                 * logging data. */

+                SetEvent( pvLoggingThreadEvent );

+            }

+        }

+    }

+}

+/*-----------------------------------------------------------*/

+

+static void prvLoggingFlushBuffer( void )

+{

+    size_t xLength;

+    char cPrintString[ dlMAX_PRINT_STRING_LENGTH ];

+

+    /* Is there more than the length value stored in the circular buffer

+     * used to pass data from the FreeRTOS simulator into this Win32 thread? */

+    while( uxStreamBufferGetSize( xLogStreamBuffer ) > sizeof( xLength ) )

+    {

+        memset( cPrintString, 0x00, dlMAX_PRINT_STRING_LENGTH );

+        uxStreamBufferGet( xLogStreamBuffer, 0, ( uint8_t * ) &xLength, sizeof( xLength ), pdFALSE );

+        uxStreamBufferGet( xLogStreamBuffer, 0, ( uint8_t * ) cPrintString, xLength, pdFALSE );

+

+        /* Write the message to standard out if requested to do so when

+         * vLoggingInit() was called, or if the network is not yet up. */

+        if( ( xStdoutLoggingUsed != pdFALSE ) || ( FreeRTOS_IsNetworkUp() == pdFALSE ) )

+        {

+            /* Write the message to stdout. */

+            _write( _fileno( stdout ), cPrintString, strlen( cPrintString ) );

+        }

+

+        /* Write the message to a file if requested to do so when

+         * vLoggingInit() was called. */

+        if( xDiskFileLoggingUsed != pdFALSE )

+        {

+            prvLogToFile( cPrintString, xLength );

+        }

+    }

+

+    prvFileClose();

+}

+/*-----------------------------------------------------------*/

+

+static DWORD WINAPI prvWin32LoggingThread( void * pvParameter )

+{

+    const DWORD xMaxWait = 1000;

+

+    ( void ) pvParameter;

+

+    /* From now on, prvLoggingFlushBuffer() will only be called from this

+     * Windows thread */

+    xDirectPrint = pdFALSE;

+

+    for( ; ; )

+    {

+        /* Wait to be told there are message waiting to be logged. */

+        WaitForSingleObject( pvLoggingThreadEvent, xMaxWait );

+

+        /* Write out all waiting messages. */

+        prvLoggingFlushBuffer();

+    }

+}

+/*-----------------------------------------------------------*/

+

+static void prvFileLoggingInit( void )

+{

+    FILE * pxHandle = fopen( pcLogFileName, "a" );

+

+    if( pxHandle != NULL )

+    {

+        fseek( pxHandle, SEEK_END, 0ul );

+        ulSizeOfLoggingFile = ftell( pxHandle );

+        fclose( pxHandle );

+    }

+    else

+    {

+        ulSizeOfLoggingFile = 0ul;

+    }

+}

+/*-----------------------------------------------------------*/

+

+static void prvFileClose( void )

+{

+    if( pxLoggingFileHandle != NULL )

+    {

+        fclose( pxLoggingFileHandle );

+        pxLoggingFileHandle = NULL;

+    }

+}

+/*-----------------------------------------------------------*/

+

+static void prvLogToFile( const char * pcMessage,

+                          size_t xLength )

+{

+    if( pxLoggingFileHandle == NULL )

+    {

+        pxLoggingFileHandle = fopen( pcLogFileName, "a" );

+    }

+

+    if( pxLoggingFileHandle != NULL )

+    {

+        fwrite( pcMessage, 1, xLength, pxLoggingFileHandle );

+        ulSizeOfLoggingFile += xLength;

+

+        /* If the file has grown to its maximum permissible size then close and

+         * rename it - then start with a new file. */

+        if( ulSizeOfLoggingFile > ( size_t ) dlLOGGING_FILE_SIZE )

+        {

+            prvFileClose();

+

+            if( _access( pcFullLogFileName, 00 ) == 0 )

+            {

+                remove( pcFullLogFileName );

+            }

+

+            rename( pcLogFileName, pcFullLogFileName );

+            ulSizeOfLoggingFile = 0;

+        }

+    }

+}

+/*-----------------------------------------------------------*/

diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/ReadMe.md b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/ReadMe.md
new file mode 100644
index 000000000..e08171cc5
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/ReadMe.md
@@ -0,0 +1,168 @@
+# FreeRTOS+TCP IPv6 Demo
+
+The FreeRTOS+TCP IPv6/multiple-interface source code and example projects are
+currently provided in the FreeRTOS+TCP repository's "feature/ipv6_multi_beta"
+branch. These demos only require the FreeRTOS+TCP IPv6/multiple Interface
+source code and the FreeRTOS-Kernel.
+
+## Setting up the workspace:
+
+Clone the submodules used in the FreeRTOS repo:
+
+`git submodule update --init --recursive`
+
+Make sure the FreeRTOS+TCP submodule is pointing to the [`dev/IPv6_integration`](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/tree/dev/IPv6_integration) branch
+by checking:
+
+``` sh
+cd FreeRTOS-Plus\Source\FreeRTOS-Plus-TCP
+git status
+```
+
+If not checkout to `dev/IPv6_integration`:
+
+`git checkout dev/IPv6_integration`
+
+Update submodules:
+
+``` sh
+git submodule update --init --recursive
+git submodule update --checkout
+```
+
+The FreeRTOS+TCP Multiple Interface Visual Studio project file is in the following
+directory: `FreeRTOS-Plus\Demo\FreeRTOS_Plus_TCP_IPv6_Demo\IPv6_Multi_WinSim_dem`
+
+In FreeRTOS_Plus_TCP_IPv6_Multi.props, you will find a couple of macros that indicate
+the location of source files:
+
+- FREERTOS_SOURCE_DIR    The kernel sources
+- FREERTOS_INCLUDE_DIR   The kernel header files
+- DEMO_COMMON_SOURCE_DIR The location of the "common" directory of the demos
+- PLUS_TCP_SOURCE_DIR    The FreeRTOS+TCP source files
+- PLUS_TCP_INCLUDE_DIR>  The FreeRTOS+TCP header files
+- UTILITIES_SOURCE_DIR   The location of the tcp_utilities directory
+
+You can changes these directory to let the proyejct work with a different
+source tree.
+
+The Multiple Interface Visual studio demo showcases the Multiple Interfaces (or
+rather the multiple endpoints) functionality of the FreeRTOS+TCP
+IPv6/multi-interface library. The Windows Simulator environment doesn't actually
+have multiple interfaces which can be used by FreeRTOS and thus, this demo shows
+the use of different endpoints which will be resolved by the OS having multiple
+interfaces. It shows that the library will use different endpoints (IP-addresses)
+to connect to IP-addresses on different subnets (or using different netmasks).
+The instructions for the full Windows demo are still relevant though as they
+describe how to set up the WinPCap development environment, how to set the IP
+address, and other such items. Note that, as delivered, configUSE_DHCP is set to 0,
+so a static IP address is used. The instructions are provided on the following URL,
+see the "Hardware Setup" section:
+http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html
+
+The IPv6_Multi_WinSim_demo demo performs some basic network activities:
+
+- ARP address resolution for IPv4 addresses on the LAN
+- Neighbour Discovery for IPv6 addresses on the LAN
+- Looking up a IPv4 or IPv6  address using DNS, either asynchronous or synchronous.
+- Looking up a local host ( IPv4/6 ) using LLMNR ( not considered safe anymore )
+- Talk with an NTP server and fetch the time using UDP, with IPv4/6
+- Download a file from any public server using TCP/HTTP
+- Ping any server on the web or on the LAN, , with IPv4 or IPv6
+
+The demo can be easily adapted to your own needs. It works like a command line
+interface ( CLI ) that performs the above tasks.
+
+Here are some examples of valid command lines, using the keywords “http”, “ping”,
+“dnsq”, and “ntp:
+
+    "http4 google.co.uk /index.html",
+    "http6 amazon.com /index.html",
+    "ping4 10.0.1.10",
+    "ping6 2001:470:ec54::",
+    "dnsq4 yahoo.com",
+    "ping6 aws.com",
+    "ntp6a 2.europe.pool.ntp.org",
+
+The last line will first lookup the mentioned NTP server, send a request, and wait
+for a reply. The time will be printed in the logging.
+
+Although it is called a CLI, the demo does not have a STDIN. The commands are
+hard-coded in main.c
+
+The keywords can have some single-letter suffices: 4 or 6 ( for IPv4/6 ), “a” to do
+an asynchronous DNS lookup, and “c” to clear all caches before starting the task.
+
+
+## Using the UDP Echo Client
+
+The demo also demonstrates a IPv4/IPv6 UDP echo client which can be enabled by
+setting the `mainCREATE_UDP_ECHO_SERVER_TASK` macro to 1 in the main file.
+
+The UDP Echo Client creates a task and sends messages to the IP address and port
+defined as `configECHO_SERVER_ADDR_STRING` (either v4 or v6 address) 
+and configECHO_SERVER_PORT respectively in the FreeRTOSConfig.h file and expect to
+get echo of the messages back. There should be a UDP echo server running in the 
+given IP and port.
+
+
+#### Sample UDP echo server in Go: 
+
+``` go
+
+// Filename: echo_server.go 
+// Run: go run echo_server.go <ip_address>:<port>
+// Example IPv4:  go run echo_server.go 192.168.1.2:9000
+// Example IPv6:  go run echo_server.go [fe80::1b99:a6bd:a344:b09d]:9000
+
+package main
+
+import (
+	"fmt"
+	"net"
+	"os"
+)
+
+func main() {
+
+	if len(os.Args) == 1 {
+		fmt.Println("Please provide host:port")
+		os.Exit(1)
+	}
+
+	// Resolve the string address to a UDP address
+	udpAddr, err := net.ResolveUDPAddr("udp", os.Args[1])
+
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	// Start listening for UDP packages on the given address
+	conn, err := net.ListenUDP("udp", udpAddr)
+
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	// Read from UDP listener 
+	for {
+		var buf [1024]byte
+		_, addr, err := conn.ReadFromUDP(buf[0:])
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		fmt.Print(string(buf[0:]))
+
+		// Write back the message over UDP
+		conn.WriteToUDP([]byte(buf[0:]), addr)
+	}
+}
+```
+
+The UDP Echo Client demo also demonstrates the UDP zero copy for both IPv4 and IPv6
+(based on the IP type), it can be enabled by setting `USE_ZERO_COPY` macro of the
+UDPEchoClient_SingleTasks.c file to 1.
\ No newline at end of file
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/Read_Me_Build_Instructions.url b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/Read_Me_Build_Instructions.url
new file mode 100644
index 000000000..f01ec1411
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/Read_Me_Build_Instructions.url
@@ -0,0 +1,6 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+URL=http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html
+IDList=
+HotKey=0
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/TCPEchoClient_SingleTasks.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/TCPEchoClient_SingleTasks.c
new file mode 100644
index 000000000..81eee31f7
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/TCPEchoClient_SingleTasks.c
@@ -0,0 +1,478 @@
+/*

+ * FreeRTOS V202212.00

+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * https://www.FreeRTOS.org

+ * https://github.com/FreeRTOS

+ *

+ */

+

+/*

+ * A set of tasks are created that send TCP echo requests to the standard echo

+ * port (port 7) on the IP address set by the configECHO_SERVER_ADDR0 to

+ * configECHO_SERVER_ADDR3 constants, then wait for and verify the reply

+ * (another demo is available that demonstrates the reception being performed in

+ * a task other than that from with the request was made).

+ *

+ * See the following web page for essential demo usage and configuration

+ * details:

+ * https://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html

+ */

+

+/* Standard includes. */

+#include <stdint.h>

+#include <stdio.h>

+#include <stdlib.h>

+

+/* FreeRTOS includes. */

+#include "FreeRTOS.h"

+#include "task.h"

+#include "queue.h"

+

+/* FreeRTOS+TCP includes. */

+#include "FreeRTOS_IP.h"

+#include "FreeRTOS_Sockets.h"

+#include "FreeRTOS_IP_Private.h"

+

+/*#include "tcp_echo_config.h" */

+

+/* Exclude the whole file if FreeRTOSIPConfig.h is configured to use UDP only. */

+#if ( ipconfigUSE_TCP == 1 )

+

+/* The echo tasks create a socket, send out a number of echo requests, listen

+ * for the echo reply, then close the socket again before starting over.  This

+ * delay is used between each iteration to ensure the network does not get too

+ * congested. */

+    #define echoLOOP_DELAY                pdMS_TO_TICKS( 2U )

+

+/* The size of the buffers is a multiple of the MSS - the length of the data

+ * sent is a pseudo random size between 20 and echoBUFFER_SIZES. */

+    #define echoBUFFER_SIZE_MULTIPLIER    ( 3 )

+    #define echoBUFFER_SIZES              ( ipconfigTCP_MSS * echoBUFFER_SIZE_MULTIPLIER )

+

+/* The number of instances of the echo client task to create. */

+    #define echoNUM_ECHO_CLIENTS          ( 1 )

+

+/*-----------------------------------------------------------*/

+

+/*

+ * Uses a socket to send data to, then receive data from, the standard echo

+ * port number 7.

+ */

+    static void prvEchoClientTask( void * pvParameters );

+

+/*

+ * Creates a pseudo random sized buffer of data to send to the echo server.

+ */

+    static BaseType_t prvCreateTxData( char * ucBuffer,

+                                       uint32_t ulBufferLength );

+

+/*-----------------------------------------------------------*/

+

+/* Rx and Tx time outs are used to ensure the sockets do not wait too long for

+ * missing data. */

+    static const TickType_t xReceiveTimeOut = pdMS_TO_TICKS( 4000 );

+    static const TickType_t xSendTimeOut = pdMS_TO_TICKS( 4000 );

+    static BaseType_t xHasStarted = pdFALSE;

+

+/* Counters for each created task - for inspection only. */

+    static uint32_t ulTxRxCycles[ echoNUM_ECHO_CLIENTS ] = { 0 },

+                    ulTxRxFailures[ echoNUM_ECHO_CLIENTS ] = { 0 },

+                    ulConnections[ echoNUM_ECHO_CLIENTS ] = { 0 };

+

+/* Rx and Tx buffers for each created task. */

+    static char cTxBuffers[ echoNUM_ECHO_CLIENTS ][ echoBUFFER_SIZES ],

+                cRxBuffers[ echoNUM_ECHO_CLIENTS ][ echoBUFFER_SIZES ];

+

+/*-----------------------------------------------------------*/

+

+    void vStartTCPEchoClientTasks_SingleTasks( uint16_t usTaskStackSize,

+                                               UBaseType_t uxTaskPriority )

+    {

+        if( xHasStarted == pdFALSE )

+        {

+            BaseType_t xCount = 0;

+            BaseType_t x;

+

+            xHasStarted = pdTRUE;

+

+            /* Create the echo client tasks. */

+            for( x = 0; x < echoNUM_ECHO_CLIENTS; x++ )

+            {

+                char ucName[ 16 ];

+                snprintf( ucName, sizeof ucName, "echo_%02d", ( int ) x );

+                BaseType_t rc = xTaskCreate( prvEchoClientTask, /* The function that implements the task. */

+                                             ucName,            /* Just a text name for the task to aid debugging. */

+                                             usTaskStackSize,   /* The stack size is defined in FreeRTOSIPConfig.h. */

+                                             ( void * ) x,      /* The task parameter, not used in this case. */

+                                             uxTaskPriority,    /* The priority assigned to the task is defined in FreeRTOSConfig.h. */

+                                             NULL );            /* The task handle is not used. */

+

+                if( rc == pdPASS )

+                {

+                    xCount++;

+                }

+            }

+

+            FreeRTOS_printf( ( "Started %d / %d tasks\n", ( int ) xCount, ( int ) echoNUM_ECHO_CLIENTS ) );

+        }

+        else

+        {

+            FreeRTOS_printf( ( "vStartTCPEchoClientTasks_SingleTasks: already started\n" ) );

+        }

+    }

+/*-----------------------------------------------------------*/

+

+    static BaseType_t xIsFatalError( BaseType_t xCode )

+    {

+        BaseType_t xReturn = pdFALSE;

+

+        if( ( xCode < 0 ) && ( xCode != -pdFREERTOS_ERRNO_EWOULDBLOCK ) )

+        {

+            xReturn = pdTRUE;

+        }

+

+        return xReturn;

+    }

+/*-----------------------------------------------------------*/

+

+    static void prvEchoClientTask( void * pvParameters )

+    {

+        Socket_t xSocket;

+        struct freertos_sockaddr xEchoServerAddress;

+        int32_t lLoopCount = 0UL;

+        const int32_t lMaxLoopCount = 1;

+        volatile uint32_t ulTxCount = 0UL;

+        BaseType_t xReceivedBytes, xReturned, xInstance;

+        BaseType_t lTransmitted, lStringLength;

+        char * pcTransmittedString, * pcReceivedString;

+        WinProperties_t xWinProps;

+        TickType_t xTimeOnEntering;

+        TickType_t uxDuration = 0;

+        size_t xTotalSent = 0U;

+        size_t xTotalRecv = 0U;

+        BaseType_t xFamily = FREERTOS_AF_INET;

+

+        /* Fill in the buffer and window sizes that will be used by the socket. */

+        #ifdef _WINDOWS_

+            xWinProps.lTxBufSize = 8 * ipconfigTCP_MSS;

+            xWinProps.lTxWinSize = 5;

+            xWinProps.lRxBufSize = 8 * ipconfigTCP_MSS;

+            xWinProps.lRxWinSize = 5;

+        #else

+            xWinProps.lTxBufSize = 3 * ipconfigTCP_MSS;

+            xWinProps.lTxWinSize = 2;

+            xWinProps.lRxBufSize = 3 * ipconfigTCP_MSS;

+            xWinProps.lRxWinSize = 2;

+        #endif

+

+        /* This task can be created a number of times.  Each instance is numbered

+         * to enable each instance to use a different Rx and Tx buffer.  The number is

+         * passed in as the task's parameter. */

+        xInstance = ( BaseType_t ) pvParameters;

+

+        /* Point to the buffers to be used by this instance of this task. */

+        pcTransmittedString = &( cTxBuffers[ xInstance ][ 0 ] );

+        pcReceivedString = &( cRxBuffers[ xInstance ][ 0 ] );

+

+        memset( &xEchoServerAddress, 0, sizeof( xEchoServerAddress ) );

+

+        /* Echo requests are sent to the echo server.  The address of the echo

+         * server is configured by the constants configECHO_SERVER_ADDR0 to

+         * configECHO_SERVER_ADDR3 in FreeRTOSConfig.h. */

+

+        #ifdef configECHO_SERVER_ADDR_STRING

+            {

+                BaseType_t rc = FreeRTOS_inet_pton( FREERTOS_AF_INET6, configECHO_SERVER_ADDR_STRING, ( void * ) xEchoServerAddress.sin_address.xIP_IPv6.ucBytes );

+

+                if( rc == pdPASS )

+                {

+                    xFamily = FREERTOS_AF_INET6;

+                }

+                else

+                {

+                    rc = FreeRTOS_inet_pton( FREERTOS_AF_INET4, configECHO_SERVER_ADDR_STRING, ( void * ) xEchoServerAddress.sin_address.xIP_IPv6.ucBytes );

+                    configASSERT( rc == pdPASS );

+                    xFamily = FREERTOS_AF_INET4;

+                }

+            }

+        #else  /* ifdef configECHO_SERVER_ADDR_STRING */

+            {

+                xEchoServerAddress.sin_addr = FreeRTOS_inet_addr_quick( configECHO_SERVER_ADDR0, configECHO_SERVER_ADDR1, configECHO_SERVER_ADDR2, configECHO_SERVER_ADDR3 );

+            }

+        #endif /* ifdef configECHO_SERVER_ADDR_STRING */

+

+        xEchoServerAddress.sin_len = sizeof( xEchoServerAddress );

+        xEchoServerAddress.sin_port = FreeRTOS_htons( configECHO_SERVER_PORT );

+        xEchoServerAddress.sin_family = xFamily;

+

+        for( ; ; )

+        {

+            BaseType_t xResult;

+            /* Create a TCP socket. */

+            xSocket = FreeRTOS_socket( xFamily, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP );

+            configASSERT( xSocket != FREERTOS_INVALID_SOCKET );

+

+            /* Set a time out so a missing reply does not cause the task to block

+             * indefinitely. */

+            FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );

+            FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, &xSendTimeOut, sizeof( xSendTimeOut ) );

+

+            /* Set the window and buffer sizes. */

+            FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_WIN_PROPERTIES, ( void * ) &xWinProps, sizeof( xWinProps ) );

+            xTotalSent = 0U;

+            xTotalRecv = 0U;

+

+            /* Connect to the echo server. */

+            xResult = FreeRTOS_connect( xSocket, &xEchoServerAddress, sizeof( xEchoServerAddress ) );

+            FreeRTOS_printf( ( "FreeRTOS_connect returns %d\n", ( int ) xResult ) );

+

+            if( xResult == 0 )

+            {

+                ulConnections[ xInstance ]++;

+

+                /* Send a number of echo requests. */

+                for( lLoopCount = 0; lLoopCount < lMaxLoopCount; lLoopCount++ )

+                {

+                    /* Create the string that is sent to the echo server. */

+                    lStringLength = prvCreateTxData( pcTransmittedString, echoBUFFER_SIZES );

+

+                    /* Add in some unique text at the front of the string. */

+                    sprintf( pcTransmittedString, "TxRx message number %u", ( unsigned ) ulTxCount );

+                    ulTxCount++;

+

+                    if( lLoopCount == ( lMaxLoopCount - 1 ) )

+                    {

+                        BaseType_t xTrue = pdTRUE;

+                        /*	FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_CLOSE_AFTER_SEND, &xTrue, sizeof( xTrue ) ); */

+                    }

+

+                    /* Send the string to the socket. */

+                    lTransmitted = FreeRTOS_send( xSocket,                        /* The socket being sent to. */

+                                                  ( void * ) pcTransmittedString, /* The data being sent. */

+                                                  lStringLength,                  /* The length of the data being sent. */

+                                                  0 );                            /* No flags. */

+                    FreeRTOS_printf( ( "FreeRTOS_send: %u/%u\n", ( unsigned ) lTransmitted, ( unsigned ) lStringLength ) );

+

+                    if( xIsFatalError( lTransmitted ) )

+                    {

+                        /* Error? */

+                        break;

+                    }

+

+                    xTotalSent += lTransmitted;

+

+                    /* Clear the buffer into which the echoed string will be

+                     * placed. */

+                    memset( ( void * ) pcReceivedString, 0x00, echoBUFFER_SIZES );

+                    xReceivedBytes = 0;

+

+                    /* Receive data echoed back to the socket. */

+                    while( xReceivedBytes < lTransmitted )

+                    {

+                        xReturned = FreeRTOS_recv( xSocket,                                 /* The socket being received from. */

+                                                   &( pcReceivedString[ xReceivedBytes ] ), /* The buffer into which the received data will be written. */

+                                                   lStringLength - xReceivedBytes,          /* The size of the buffer provided to receive the data. */

+                                                   0 );                                     /* No flags. */

+

+                        if( xIsFatalError( xReturned ) )

+                        {

+                            /* Error occurred.  Latch it so it can be detected

+                             * below. */

+                            break;

+                        }

+

+                        if( xReturned == 0 )

+                        {

+                            /* Timed out. */

+                            FreeRTOS_printf( ( "recv returned %u\n", ( unsigned ) xReturned ) );

+                            break;

+                        }

+

+                        /* Keep a count of the bytes received so far. */

+                        xReceivedBytes += xReturned;

+                        xTotalRecv += xReturned;

+                    }

+

+                    /* If an error occurred it will be latched in xReceivedBytes,

+                     * otherwise xReceived bytes will be just that - the number of

+                     * bytes received from the echo server. */

+                    if( xReceivedBytes > 0 )

+                    {

+                        /* Compare the transmitted string to the received string. */

+                        configASSERT( strncmp( pcReceivedString, pcTransmittedString, lTransmitted ) == 0 );

+

+                        if( strncmp( pcReceivedString, pcTransmittedString, lTransmitted ) == 0 )

+                        {

+                            /* The echo reply was received without error. */

+                            ulTxRxCycles[ xInstance ]++;

+                        }

+                        else

+                        {

+                            /* The received string did not match the transmitted

+                             * string. */

+                            ulTxRxFailures[ xInstance ]++;

+                            break;

+                        }

+                    }

+                    else if( xIsFatalError( xReturned ) )

+                    {

+                        /* FreeRTOS_recv() returned an error. */

+                        break;

+                    }

+                    else

+                    {

+                        /* Timed out without receiving anything? */

+                        break;

+                    }

+                }

+

+                /* Finished using the connected socket, initiate a graceful close:

+                 * FIN, FIN+ACK, ACK. */

+                FreeRTOS_shutdown( xSocket, FREERTOS_SHUT_RDWR );

+

+                /* Expect FreeRTOS_recv() to return an error once the shutdown is

+                 * complete. */

+                xTimeOnEntering = xTaskGetTickCount();

+

+                do

+                {

+                    xReturned = FreeRTOS_recv( xSocket,                    /* The socket being received from. */

+                                               &( pcReceivedString[ 0 ] ), /* The buffer into which the received data will be written. */

+                                               echoBUFFER_SIZES,           /* The size of the buffer provided to receive the data. */

+                                               0 );

+

+                    uxDuration = ( xTaskGetTickCount() - xTimeOnEntering );

+

+                    if( xReturned < 0 )

+                    {

+                        break;

+                    }

+                } while( uxDuration < xReceiveTimeOut );

+            }

+

+            FreeRTOS_printf( ( "Instance[%u]: Good %u/%u shutdown %u\n",

+                               ( unsigned ) xInstance,

+                               ( unsigned ) ( ulTxRxCycles[ xInstance ] - ulTxRxFailures[ xInstance ] ),

+                               ( unsigned ) ( ulTxRxCycles[ xInstance ] ),

+                               ( unsigned ) uxDuration ) );

+            FreeRTOS_printf( ( "%u x %u = %u Exchange %u/%u\n",

+                               ( unsigned ) echoBUFFER_SIZE_MULTIPLIER,

+                               ( unsigned ) echoBUFFER_SIZES,

+                               ( unsigned ) ( echoBUFFER_SIZE_MULTIPLIER * echoBUFFER_SIZES ),

+                               ( unsigned ) xTotalSent,

+                               ( unsigned ) xTotalRecv ) );

+

+            /* Close this socket before looping back to create another. */

+            FreeRTOS_closesocket( xSocket );

+

+            /* Pause for a short while to ensure the network is not too

+             * congested. */

+            vTaskDelay( echoLOOP_DELAY );

+        }

+    }

+/*-----------------------------------------------------------*/

+

+    static BaseType_t prvCreateTxData( char * cBuffer,

+                                       uint32_t ulBufferLength )

+    {

+        BaseType_t lCharactersToAdd, lCharacter;

+        char cChar = '0';

+        const BaseType_t lMinimumLength = 60;

+        uint32_t ulRandomNumber;

+        static uint32_t ulNextnumber = 1U;

+

+        /* Randomise the number of characters that will be sent in the echo

+         * request. */

+        do

+        {

+            ( void ) xApplicationGetRandomNumber( &ulRandomNumber );

+            lCharactersToAdd = ulRandomNumber % ( ulBufferLength - 20UL );

+        } while( ( lCharactersToAdd == 0 ) || ( lCharactersToAdd < lMinimumLength ) ); /* Must be at least enough to add the unique text to the start of the string later. */

+

+        /* Fill the buffer. */

+        for( lCharacter = 0; lCharacter < lCharactersToAdd; lCharacter++ )

+        {

+            cBuffer[ lCharacter ] = cChar;

+            cChar++;

+

+            if( cChar > '~' )

+            {

+                cChar = '0';

+            }

+        }

+

+        {

+            /* Replace the string "0123456789" with an increasing number. */

+            char pcBuf[ 16 ];

+            char * pcPtr = cBuffer;

+            const char * ucLast = &( cBuffer[ ulBufferLength ] );

+

+            for( ; ; )

+            {

+                char * next = strchr( pcPtr, '0' );

+

+                if( ( next == NULL ) || ( ( next + 10 ) >= ucLast ) )

+                {

+                    break;

+                }

+

+                snprintf( pcBuf, sizeof pcBuf, "%010u", ulNextnumber );

+                memcpy( next, pcBuf, 10 );

+                ulNextnumber++;

+                pcPtr = next + 10;

+            }

+        }

+        return lCharactersToAdd;

+    }

+/*-----------------------------------------------------------*/

+

+    BaseType_t xAreSingleTaskTCPEchoClientsStillRunning( void )

+    {

+        static uint32_t ulLastEchoSocketCount[ echoNUM_ECHO_CLIENTS ] = { 0 }, ulLastConnections[ echoNUM_ECHO_CLIENTS ] = { 0 };

+        BaseType_t xReturn = pdPASS, x;

+

+        /* Return fail is the number of cycles does not increment between

+         * consecutive calls. */

+        for( x = 0; x < echoNUM_ECHO_CLIENTS; x++ )

+        {

+            if( ulTxRxCycles[ x ] == ulLastEchoSocketCount[ x ] )

+            {

+                xReturn = pdFAIL;

+            }

+            else

+            {

+                ulLastEchoSocketCount[ x ] = ulTxRxCycles[ x ];

+            }

+

+            if( ulConnections[ x ] == ulLastConnections[ x ] )

+            {

+                xReturn = pdFAIL;

+            }

+            else

+            {

+                ulConnections[ x ] = ulLastConnections[ x ];

+            }

+        }

+

+        return xReturn;

+    }

+

+#endif /* ipconfigUSE_TCP */

diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/TCPEchoClient_SingleTasks.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/TCPEchoClient_SingleTasks.h
new file mode 100644
index 000000000..25965c939
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/TCPEchoClient_SingleTasks.h
@@ -0,0 +1,38 @@
+/*

+ * FreeRTOS V202212.00

+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * https://www.FreeRTOS.org

+ * https://github.com/FreeRTOS

+ *

+ */

+

+#ifndef SINGLE_TASK_TCP_ECHO_CLIENTS_H

+#define SINGLE_TASK_TCP_ECHO_CLIENTS_H

+

+/*

+ * Create the TCP echo client tasks.  This is the version where an echo request

+ * is made from the same task that listens for the echo reply.

+ */

+void vStartTCPEchoClientTasks_SingleTasks( uint16_t usTaskStackSize,

+                                           UBaseType_t uxTaskPriority );

+BaseType_t xAreSingleTaskTCPEchoClientsStillRunning( void );

+

+#endif /* SINGLE_TASK_TCP_ECHO_CLIENTS_H */

diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/UDPEchoClient_SingleTasks.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/UDPEchoClient_SingleTasks.c
new file mode 100644
index 000000000..e87d39298
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/UDPEchoClient_SingleTasks.c
@@ -0,0 +1,294 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+ /*
+  * A set of tasks are created that send UDP echo requests to the 
+  * IP address set by the configECHO_SERVER_ADDR0 to
+  * configECHO_SERVER_ADDR_STRING constant, then wait for and verify the reply
+  *
+  * See the following web page for essential demo usage and configuration
+  * details:
+  * https://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html
+  */
+
+  /* Standard includes. */
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* FreeRTOS includes. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
+
+/* FreeRTOS+TCP includes. */
+#include "FreeRTOS_IP.h"
+#include "FreeRTOS_Sockets.h"
+#include "FreeRTOS_IP_Private.h"
+
+
+#define USE_ZERO_COPY               ( 1 )
+
+/* The echo tasks create a socket, send out a number of echo requests, listen
+for the echo reply, then close the socket again before starting over.  This
+delay is used between each iteration to ensure the network does not get too
+congested. */
+#define echoLOOP_DELAY	pdMS_TO_TICKS( 2U )
+
+/* The number of instances of the echo client task to create. */
+#define echoNUM_ECHO_CLIENTS		( 1 )
+
+#define TX_RX_STR_SIZE              ( 25 )
+
+/* Rx and Tx time outs are used to ensure the sockets do not wait too long for
+missing data. */
+static const TickType_t xReceiveTimeOut = pdMS_TO_TICKS(4000);
+static const TickType_t xSendTimeOut = pdMS_TO_TICKS(4000);
+static BaseType_t xHasStarted = pdFALSE;
+
+/*
+* UDP echo client task
+*/
+static void prvUDPEchoClientTask(void* pvParameters);
+
+void vStartUDPEchoClientTasks_SingleTasks(uint16_t usTaskStackSize, UBaseType_t uxTaskPriority)
+{
+
+    if (xHasStarted == pdFALSE)
+    {
+        BaseType_t xCount = 0;
+        BaseType_t x;
+
+        xHasStarted = pdTRUE;
+        /* Create the echo client tasks. */
+        for (x = 0; x < echoNUM_ECHO_CLIENTS; x++)
+        {
+            char ucName[16];
+            snprintf(ucName, sizeof ucName, "echo_%02d", (int)x);
+            BaseType_t rc = xTaskCreate(prvUDPEchoClientTask,	/* The function that implements the task. */
+                ucName,				/* Just a text name for the task to aid debugging. */
+                usTaskStackSize,	/* The stack size is defined in FreeRTOSIPConfig.h. */
+                (void*)x,		/* The task parameter, not used in this case. */
+                uxTaskPriority,		/* The priority assigned to the task is defined in FreeRTOSConfig.h. */
+                NULL);				/* The task handle is not used. */
+            if (rc == pdPASS)
+            {
+                xCount++;
+            }
+        }
+        FreeRTOS_printf(("Started %d / %d tasks\n", (int)xCount, (int)echoNUM_ECHO_CLIENTS));
+    }
+    else
+    {
+        FreeRTOS_printf(("vStartUDPEchoClientTasks_SingleTasks: already started\n"));
+    }
+}
+/*-----------------------------------------------------------*/
+
+static void prvUDPEchoClientTask(void* pvParameters)
+{
+    Socket_t xSocket;
+    struct freertos_sockaddr xEchoServerAddress, xRxAddress;
+    int8_t cTxString[TX_RX_STR_SIZE], cRxString[TX_RX_STR_SIZE]; /* Make sure the stack is large enough to hold these.  Turn on stack overflow checking during debug to be sure. */
+    int32_t lLoopCount = 0UL;
+    int32_t lReturned;
+    const int32_t lMaxLoopCount = 50;
+    volatile uint32_t ulRxCount = 0UL, ulTxCount = 0UL;
+    uint32_t xAddressLength = sizeof(xEchoServerAddress);
+    BaseType_t xFamily = FREERTOS_AF_INET;
+    uint8_t ucIPType = ipTYPE_IPv4;
+
+    /* Remove compiler warning about unused parameters. */
+    (void)pvParameters;
+
+    memset(&xEchoServerAddress, 0, sizeof(xEchoServerAddress));
+    memset(&xRxAddress, 0, sizeof(xRxAddress));
+    /* Echo requests are sent to the echo server.  The address of the echo
+    server is configured by the constants configECHO_SERVER_ADDR0 to
+    configECHO_SERVER_ADDR3 in FreeRTOSConfig.h. */
+
+#ifdef configECHO_SERVER_ADDR_STRING
+    {
+        BaseType_t rc = FreeRTOS_inet_pton(FREERTOS_AF_INET6, configECHO_SERVER_ADDR_STRING, (void*)xEchoServerAddress.sin_address.xIP_IPv6.ucBytes);
+        if (rc == pdPASS)
+        {
+            xFamily = FREERTOS_AF_INET6;
+            ucIPType = ipTYPE_IPv6;
+        }
+        else
+        {
+            rc = FreeRTOS_inet_pton(FREERTOS_AF_INET4, configECHO_SERVER_ADDR_STRING, (void*)xEchoServerAddress.sin_address.xIP_IPv6.ucBytes);
+            configASSERT(rc == pdPASS);
+            xFamily = FREERTOS_AF_INET4;
+            ucIPType = ipTYPE_IPv4;
+        }
+    }
+#else
+    {
+        xEchoServerAddress.sin_addr = FreeRTOS_inet_addr_quick(configECHO_SERVER_ADDR0, configECHO_SERVER_ADDR1, configECHO_SERVER_ADDR2, configECHO_SERVER_ADDR3);
+    }
+#endif
+
+    xEchoServerAddress.sin_len = sizeof(xEchoServerAddress);
+    xEchoServerAddress.sin_port = FreeRTOS_htons(configECHO_SERVER_PORT);
+    xEchoServerAddress.sin_family = xFamily;
+
+
+    for (;; )
+    {
+        /* Create a socket. */
+        xSocket = FreeRTOS_socket(xFamily, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP);
+        configASSERT(xSocket != FREERTOS_INVALID_SOCKET);
+
+        /* Set a time out so a missing reply does not cause the task to block
+        indefinitely. */
+        FreeRTOS_setsockopt(xSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof(xReceiveTimeOut));
+
+        /* Send a number of echo requests. */
+        for (lLoopCount = 0; lLoopCount < lMaxLoopCount; lLoopCount++)
+        {
+            /* Create the string that is sent to the echo server. */
+            sprintf((char*)cTxString, "Message number %u\r\n", ulTxCount);
+
+#if USE_ZERO_COPY
+
+            /*
+            * First obtain a buffer of adequate length from the TCP/IP stack into which
+            * the string will be written. */
+            uint8_t* pucBuffer = FreeRTOS_GetUDPPayloadBuffer_ByIPType(TX_RX_STR_SIZE, portMAX_DELAY, ucIPType);
+            configASSERT(pucBuffer != NULL);
+            memcpy(pucBuffer, &cTxString, strlen((const char*)cTxString) + 1);
+
+            /* Send the string to the socket.  ulFlags is set to 0, so the zero
+            copy interface is not used.  That means the data from cTxString is
+            copied into a network buffer inside FreeRTOS_sendto(), and cTxString
+            can be reused as soon as FreeRTOS_sendto() has returned.  1 is added
+            to ensure the NULL string terminator is sent as part of the message. */
+            lReturned = FreeRTOS_sendto(xSocket,				/* The socket being sent to. */
+                (void*)pucBuffer,	/* The data being sent. */
+                strlen((const char*)pucBuffer) + 1, /* The length of the data being sent. */
+                FREERTOS_ZERO_COPY,						/* ulFlags with the FREERTOS_ZERO_COPY bit clear. */
+                &xEchoServerAddress,	/* The destination address. */
+                sizeof(xEchoServerAddress));
+
+#else
+
+            /* Send the string to the socket.  ulFlags is set to 0, so the zero
+            copy interface is not used.  That means the data from cTxString is
+            copied into a network buffer inside FreeRTOS_sendto(), and cTxString
+            can be reused as soon as FreeRTOS_sendto() has returned.  1 is added
+            to ensure the NULL string terminator is sent as part of the message. */
+            lReturned = FreeRTOS_sendto(xSocket,				/* The socket being sent to. */
+                (void*)cTxString,	/* The data being sent. */
+                strlen((const char*)cTxString) + 1, /* The length of the data being sent. */
+                0,						/* ulFlags with the FREERTOS_ZERO_COPY bit clear. */
+                &xEchoServerAddress,	/* The destination address. */
+                sizeof(xEchoServerAddress));
+
+#endif
+
+            if (lReturned == 0)
+            {
+                /* The send operation failed. */
+            }
+            else
+            {
+                /* The send was successful. */
+                FreeRTOS_debug_printf(("[Echo Client] Data sent...  \r\n"));
+            }
+
+            /* Keep a count of how many echo requests have been transmitted so
+            it can be compared to the number of echo replies received.  It would
+            be expected to loose at least one to an ARP message the first time
+            the	connection is created. */
+            ulTxCount++;
+
+            /* Receive data echoed back to the socket.  ulFlags is zero, so the
+            zero copy option is not being used and the received data will be
+            copied into the buffer pointed to by cRxString.  xAddressLength is
+            not actually used (at the time of writing this comment, anyway) by
+            FreeRTOS_recvfrom(), but is set appropriately in case future
+            versions do use it. */
+
+            memset((void*)cRxString, 0x00, sizeof(cRxString));
+
+
+#if USE_ZERO_COPY
+
+            uint8_t* pucReceivedUDPPayload = NULL;
+            lReturned = FreeRTOS_recvfrom(xSocket,
+                &pucReceivedUDPPayload,
+                0,
+                FREERTOS_ZERO_COPY,
+                &xRxAddress,
+                &xAddressLength);
+
+            if (pucReceivedUDPPayload != NULL) {
+                memcpy((void*)(cRxString), pucReceivedUDPPayload, TX_RX_STR_SIZE);
+
+                FreeRTOS_ReleaseUDPPayloadBuffer((void*)pucReceivedUDPPayload);
+            }
+#else
+
+            lReturned = FreeRTOS_recvfrom(xSocket,				/* The socket being received from. */
+                cRxString,				/* The buffer into which the received data will be written. */
+                sizeof(cRxString),	/* The size of the buffer provided to receive the data. */
+                0,						/* ulFlags with the FREERTOS_ZERO_COPY bit clear. */
+                &xRxAddress,	/* The address from where the data was sent (the source address). */
+                &xAddressLength);
+
+#endif /* USE_ZERO_COPY */
+
+
+
+            if (lReturned > 0)
+            {
+                /* Compare the transmitted string to the received string. */
+                if (strcmp((char*)cRxString, (char*)cTxString) == 0)
+                {
+                    /* The echo reply was received without error. */
+                    ulRxCount++;
+                    FreeRTOS_debug_printf(("[Echo Client] Data was received correctly.\r\n"));
+                }
+                else
+                {
+                    FreeRTOS_debug_printf(("[Echo Client] Data received was erreneous.\r\n"));
+                }
+            }
+            else
+            {
+                FreeRTOS_debug_printf(("[Echo Client] Data was not received\r\n"));
+            }
+        }
+
+        /* Pause for a short while to ensure the network is not too
+        congested. */
+        vTaskDelay(echoLOOP_DELAY);
+
+        /* Close this socket before looping back to create another. */
+        FreeRTOS_closesocket(xSocket);
+    }
+}
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/UDPEchoClient_SingleTasks.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/UDPEchoClient_SingleTasks.h
new file mode 100644
index 000000000..2dfe52497
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/UDPEchoClient_SingleTasks.h
@@ -0,0 +1,36 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef SINGLE_TASK_UDP_ECHO_CLIENTS_H
+#define SINGLE_TASK_UDP_ECHO_CLIENTS_H
+
+ /*
+  * Create the UDP echo client tasks.  This is the version where an echo request
+  * is made from the same task that listens for the echo reply.
+  */
+void vStartUDPEchoClientTasks_SingleTasks(uint16_t usTaskStackSize, UBaseType_t uxTaskPriority);
+
+#endif /* SINGLE_TASK_UDP_ECHO_CLIENTS_H */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/WIN32.vcxproj b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/WIN32.vcxproj
new file mode 100644
index 000000000..314dc8092
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/WIN32.vcxproj
@@ -0,0 +1,280 @@
+<?xml version="1.0" encoding="utf-8"?>

+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <ItemGroup Label="ProjectConfigurations">

+    <ProjectConfiguration Include="Debug|Win32">

+      <Configuration>Debug</Configuration>

+      <Platform>Win32</Platform>

+    </ProjectConfiguration>

+    <ProjectConfiguration Include="Release|Win32">

+      <Configuration>Release</Configuration>

+      <Platform>Win32</Platform>

+    </ProjectConfiguration>

+  </ItemGroup>

+  <PropertyGroup Label="Globals">

+    <ProjectGuid>{C686325E-3261-42F7-AEB1-DDE5280E1CEB}</ProjectGuid>

+    <ProjectName>RTOSDemo</ProjectName>

+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>

+  </PropertyGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

+    <ConfigurationType>Application</ConfigurationType>

+    <UseOfMfc>false</UseOfMfc>

+    <CharacterSet>MultiByte</CharacterSet>

+    <PlatformToolset>v142</PlatformToolset>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

+    <ConfigurationType>Application</ConfigurationType>

+    <UseOfMfc>false</UseOfMfc>

+    <CharacterSet>MultiByte</CharacterSet>

+    <PlatformToolset>v142</PlatformToolset>

+  </PropertyGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

+  <ImportGroup Label="ExtensionSettings">

+  </ImportGroup>

+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />

+    <Import Project="FreeRTOS_Plus_TCP_IPv6_Multi.props" />

+  </ImportGroup>

+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />

+    <Import Project="FreeRTOS_Plus_TCP_IPv6_Multi.props" />

+  </ImportGroup>

+  <PropertyGroup Label="UserMacros" />

+  <PropertyGroup>

+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>

+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\Debug\</OutDir>

+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\Debug\</IntDir>

+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>

+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\Release\</OutDir>

+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\Release\</IntDir>

+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>

+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>

+  </PropertyGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <Midl>

+      <TypeLibraryName>.\Debug/WIN32.tlb</TypeLibraryName>

+      <HeaderFileName>

+      </HeaderFileName>

+    </Midl>

+    <ClCompile>

+      <Optimization>Disabled</Optimization>

+      <AdditionalIncludeDirectories>

+$(FREERTOS_INCLUDE_DIR);

+$(FREERTOS_SOURCE_DIR)\portable\MSVC-MingW;

+$(UTILITIES_SOURCE_DIR)\include;

+$(PLUS_TCP_INCLUDE_DIR);

+$(PLUS_TCP_SOURCE_DIR)\protocols\include;

+$(PLUS_TCP_SOURCE_DIR)\portable\BufferManagement;

+$(PLUS_TCP_SOURCE_DIR)\portable\Compiler\MSVC;

+$(DEMO_COMMON_SOURCE_DIR)\WinPCap;

+$(DEMO_COMMON_SOURCE_DIR)\logging\include;

+..\common\NTP\include;

+.;

+..\common\Logging\windows

+</AdditionalIncludeDirectories>

+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_WIN32_WINNT=0x0500;WINVER=0x400;_CRT_SECURE_NO_WARNINGS;ipconfigUSE_PCAP=1;_NO_CRT_STDIO_INLINE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <MinimalRebuild>true</MinimalRebuild>

+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>

+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>

+      <PrecompiledHeaderOutputFile>.\Debug/WIN32.pch</PrecompiledHeaderOutputFile>

+      <AssemblerListingLocation>.\Debug/</AssemblerListingLocation>

+      <ObjectFileName>.\Debug/</ObjectFileName>

+      <ProgramDataBaseFileName>.\Debug/</ProgramDataBaseFileName>

+      <WarningLevel>Level4</WarningLevel>

+      <SuppressStartupBanner>true</SuppressStartupBanner>

+      <DisableLanguageExtensions>false</DisableLanguageExtensions>

+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>

+      <AdditionalOptions>/wd4210 /wd4127 /wd4214 /wd4201 /wd4244  /wd4310 %(AdditionalOptions)</AdditionalOptions>

+      <BrowseInformation>true</BrowseInformation>

+      <PrecompiledHeader>NotUsing</PrecompiledHeader>

+      <ExceptionHandling>false</ExceptionHandling>

+      <CompileAs>CompileAsC</CompileAs>

+    </ClCompile>

+    <ResourceCompile>

+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <Culture>0x0c09</Culture>

+    </ResourceCompile>

+    <Link>

+      <OutputFile>.\Debug/RTOSDemo.exe</OutputFile>

+      <SuppressStartupBanner>true</SuppressStartupBanner>

+      <GenerateDebugInformation>true</GenerateDebugInformation>

+      <ProgramDatabaseFile>.\Debug/WIN32.pdb</ProgramDatabaseFile>

+      <SubSystem>Console</SubSystem>

+      <TargetMachine>MachineX86</TargetMachine>

+      <AdditionalDependencies>wpcap.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalLibraryDirectories>$(DEMO_COMMON_SOURCE_DIR)\WinPCap</AdditionalLibraryDirectories>

+      <Profile>false</Profile>

+    </Link>

+    <Bscmake>

+      <SuppressStartupBanner>true</SuppressStartupBanner>

+      <OutputFile>.\Debug/WIN32.bsc</OutputFile>

+    </Bscmake>

+  </ItemDefinitionGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <Midl>

+      <TypeLibraryName>.\Release/WIN32.tlb</TypeLibraryName>

+      <HeaderFileName>

+      </HeaderFileName>

+    </Midl>

+    <ClCompile>

+      <Optimization>MaxSpeed</Optimization>

+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>

+      <PreprocessorDefinitions>_WINSOCKAPI_;WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <StringPooling>true</StringPooling>

+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+      <FunctionLevelLinking>true</FunctionLevelLinking>

+      <PrecompiledHeaderOutputFile>.\Release/WIN32.pch</PrecompiledHeaderOutputFile>

+      <AssemblerListingLocation>.\Release/</AssemblerListingLocation>

+      <ObjectFileName>.\Release/</ObjectFileName>

+      <ProgramDataBaseFileName>.\Release/</ProgramDataBaseFileName>

+      <WarningLevel>Level3</WarningLevel>

+      <SuppressStartupBanner>true</SuppressStartupBanner>

+    </ClCompile>

+    <ResourceCompile>

+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <Culture>0x0c09</Culture>

+    </ResourceCompile>

+    <Link>

+      <OutputFile>.\Release/RTOSDemo.exe</OutputFile>

+      <SuppressStartupBanner>true</SuppressStartupBanner>

+      <ProgramDatabaseFile>.\Release/WIN32.pdb</ProgramDatabaseFile>

+      <SubSystem>Console</SubSystem>

+      <TargetMachine>MachineX86</TargetMachine>

+      <AdditionalLibraryDirectories>

+      </AdditionalLibraryDirectories>

+      <AdditionalDependencies>

+      </AdditionalDependencies>

+    </Link>

+    <Bscmake>

+      <SuppressStartupBanner>true</SuppressStartupBanner>

+      <OutputFile>.\Release/WIN32.bsc</OutputFile>

+    </Bscmake>

+  </ItemDefinitionGroup>

+  <ItemGroup>

+    <ClCompile Include="$(UTILITIES_SOURCE_DIR)\date_and_time.c" />

+    <ClCompile Include="$(UTILITIES_SOURCE_DIR)\http_client_test.c" />

+    <ClCompile Include="$(UTILITIES_SOURCE_DIR)\plus_tcp_demo_cli.c" />

+    <ClCompile Include="$(UTILITIES_SOURCE_DIR)\tcp_dump_packets.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_BitConfig.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv4.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv4_Sockets.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv4_Utils.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv6.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv6_Sockets.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv6_Utils.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_IP_IPV4.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_IP_IPV6.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_State_Handling_IPV4.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_State_Handling_IPV6.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_Transmission_IPV4.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_Transmission_IPV6.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_Utils_IPV4.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_Utils_IPV6.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_Tiny_TCP.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_UDP_IPv4.c" />

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_UDP_IPv6.c" />

+    <ClCompile Include="Logging_WinSim.c" />

+    <ClCompile Include="printf-stdarg.c" />

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\event_groups.c" />

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\list.c" />

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\portable\MemMang\heap_4.c" />

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\portable\MSVC-MingW\port.c" />

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\queue.c" />

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\tasks.c" />

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\timers.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_ARP.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DHCP.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS_Cache.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS_Callback.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS_Networking.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS_Parser.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_ICMP.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_IP.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_IP_Timers.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_IP_Utils.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_Sockets.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_Stream_Buffer.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_IP.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_Reception.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_State_Handling.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_Transmission.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_Utils.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_WIN.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_UDP_IP.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_Routing.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\portable\BufferManagement\BufferAllocation_2.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\portable\NetworkInterface\WinPCap\NetworkInterface.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DHCPv6.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_ND.c" />

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_RA.c" />

+    <ClCompile Include="..\common\NTP\NTPDemo.c" />

+    <ClCompile Include="main.c">

+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>

+    </ClCompile>

+    <ClCompile Include="TCPEchoClient_SingleTasks.c" />

+    <ClCompile Include="UDPEchoClient_SingleTasks.c" />

+  </ItemGroup>

+  <ItemGroup>

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\event_groups.h" />

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\FreeRTOS.h" />

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\portable.h" />

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\projdefs.h" />

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\queue.h" />

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\semphr.h" />

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\task.h" />

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\timers.h" />

+    <ClInclude Include="$(FREERTOS_SOURCE_DIR)\portable\MSVC-MingW\portmacro.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOSIPConfigDefaults.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_ARP.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DHCP.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Cache.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Callback.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Globals.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Networking.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Parser.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_errno_TCP.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_ICMP.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_IP.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_IP_Private.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_IP_Timers.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_IP_Utils.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_Sockets.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_Stream_Buffer.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_IP.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_Reception.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_State_Handling.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_Transmission.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_Utils.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_WIN.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_UDP_IP.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_Routing.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_BitConfig.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DHCPv6.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_ND.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\IPTraceMacroDefaults.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\NetworkBufferManagement.h" />

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\NetworkInterface.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv4.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv4_Private.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv4_Sockets.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv4_Utils.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv6.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv6_Private.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv6_Sockets.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv6_Utils.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IP_Common.h" />

+    <ClInclude Include="FreeRTOSConfig.h" />

+    <ClInclude Include="FreeRTOSIPConfig.h" />

+    <ClInclude Include="TCPEchoClient_SingleTasks.h" />

+    <ClInclude Include="UDPEchoClient_SingleTasks.h" />

+  </ItemGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

+  <ImportGroup Label="ExtensionTargets">

+  </ImportGroup>

+</Project>
\ No newline at end of file
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/WIN32.vcxproj.filters b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/WIN32.vcxproj.filters
new file mode 100644
index 000000000..fdfbf67a7
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/WIN32.vcxproj.filters
@@ -0,0 +1,353 @@
+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <ItemGroup>

+    <Filter Include="Resource Files">

+      <UniqueIdentifier>{38712199-cebf-4124-bf15-398f7c3419ea}</UniqueIdentifier>

+      <Extensions>ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe</Extensions>

+    </Filter>

+    <Filter Include="FreeRTOS">

+      <UniqueIdentifier>{af3445a1-4908-4170-89ed-39345d90d30c}</UniqueIdentifier>

+    </Filter>

+    <Filter Include="FreeRTOS\Source">

+      <UniqueIdentifier>{f32be356-4763-4cae-9020-974a2638cb08}</UniqueIdentifier>

+      <Extensions>*.c</Extensions>

+    </Filter>

+    <Filter Include="FreeRTOS\Source\Portable">

+      <UniqueIdentifier>{88f409e6-d396-4ac5-94bd-7a99c914be46}</UniqueIdentifier>

+    </Filter>

+    <Filter Include="FreeRTOS+">

+      <UniqueIdentifier>{e5ad4ec7-23dc-4295-8add-2acaee488f5a}</UniqueIdentifier>

+    </Filter>

+    <Filter Include="FreeRTOS\Source\include">

+      <UniqueIdentifier>{d2dcd641-8d91-492b-852f-5563ffadaec6}</UniqueIdentifier>

+    </Filter>

+    <Filter Include="FreeRTOS+\FreeRTOS+TCP">

+      <UniqueIdentifier>{8672fa26-b119-481f-8b8d-086419c01a3e}</UniqueIdentifier>

+    </Filter>

+    <Filter Include="FreeRTOS+\FreeRTOS+TCP\portable">

+      <UniqueIdentifier>{4570be11-ec96-4b55-ac58-24b50ada980a}</UniqueIdentifier>

+    </Filter>

+    <Filter Include="FreeRTOS+\FreeRTOS+TCP\include">

+      <UniqueIdentifier>{5d93ed51-023a-41ad-9243-8d230165d34b}</UniqueIdentifier>

+    </Filter>

+    <Filter Include="DemoTasks">

+      <UniqueIdentifier>{b71e974a-9f28-4815-972b-d930ba8a34d0}</UniqueIdentifier>

+    </Filter>

+  </ItemGroup>

+  <ItemGroup>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_UDP_IP.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DHCP.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_Sockets.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\portable\BufferManagement\BufferAllocation_2.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\portable</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\portable\NetworkInterface\WinPCap\NetworkInterface.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\portable</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_ARP.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_IP.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_IP.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_WIN.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_Routing.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_Stream_Buffer.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DHCPv6.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_ND.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_RA.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\common\NTP\NTPDemo.c" />

+    <ClCompile Include="main.c" />

+    <ClCompile Include="$(UTILITIES_SOURCE_DIR)\tcp_dump_packets.c" />

+    <ClCompile Include="$(UTILITIES_SOURCE_DIR)\plus_tcp_demo_cli.c" />

+    <ClCompile Include="$(UTILITIES_SOURCE_DIR)\date_and_time.c" />

+    <ClCompile Include="$(UTILITIES_SOURCE_DIR)\http_client_test.c" />

+    <ClCompile Include="printf-stdarg.c" />

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\event_groups.c">

+      <Filter>FreeRTOS\Source</Filter>

+    </ClCompile>

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\list.c">

+      <Filter>FreeRTOS\Source</Filter>

+    </ClCompile>

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\portable\MemMang\heap_4.c">

+      <Filter>FreeRTOS\Source</Filter>

+    </ClCompile>

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\portable\MSVC-MingW\port.c">

+      <Filter>FreeRTOS\Source</Filter>

+    </ClCompile>

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\queue.c">

+      <Filter>FreeRTOS\Source</Filter>

+    </ClCompile>

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\timers.c">

+      <Filter>FreeRTOS\Source</Filter>

+    </ClCompile>

+    <ClCompile Include="$(FREERTOS_SOURCE_DIR)\tasks.c">

+      <Filter>FreeRTOS\Source</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_ICMP.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_IP_Timers.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_IP_Utils.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_Reception.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_State_Handling.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_Transmission.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_TCP_Utils.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS_Callback.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS_Networking.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS_Parser.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="$(PLUS_TCP_SOURCE_DIR)\FreeRTOS_DNS_Cache.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_BitConfig.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv4.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv4_Sockets.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv4_Utils.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv6.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv6_Sockets.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_IPv6_Utils.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_IP_IPV4.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_IP_IPV6.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_State_Handling_IPV4.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_State_Handling_IPV6.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_Transmission_IPV4.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_Transmission_IPV6.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_Utils_IPV4.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_TCP_Utils_IPV6.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_Tiny_TCP.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_UDP_IPv4.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\FreeRTOS_UDP_IPv6.c">

+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>

+    </ClCompile>

+    <ClCompile Include="TCPEchoClient_SingleTasks.c" />

+    <ClCompile Include="Logging_WinSim.c" />

+    <ClCompile Include="UDPEchoClient_SingleTasks.c" />

+  </ItemGroup>

+  <ItemGroup>

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\timers.h">

+      <Filter>FreeRTOS\Source\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\event_groups.h">

+      <Filter>FreeRTOS\Source\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\FreeRTOS.h">

+      <Filter>FreeRTOS\Source\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\queue.h">

+      <Filter>FreeRTOS\Source\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\semphr.h">

+      <Filter>FreeRTOS\Source\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\task.h">

+      <Filter>FreeRTOS\Source\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\portable.h">

+      <Filter>FreeRTOS\Source\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(FREERTOS_INCLUDE_DIR)\projdefs.h">

+      <Filter>FreeRTOS\Source\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\NetworkInterface.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_Sockets.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_UDP_IP.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_IP_Private.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\NetworkBufferManagement.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_ARP.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DHCP.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Cache.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Callback.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Globals.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Networking.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DNS_Parser.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_errno_TCP.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_ICMP.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_IP.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_IP_Timers.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_IP_Utils.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_IP.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_Reception.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_State_Handling.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_Transmission.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_Utils.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_TCP_WIN.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_Routing.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_BitConfig.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_DHCPv6.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_ND.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOSIPConfigDefaults.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\IPTraceMacroDefaults.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="$(PLUS_TCP_INCLUDE_DIR)\FreeRTOS_Stream_Buffer.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="FreeRTOSConfig.h" />

+    <ClInclude Include="FreeRTOSIPConfig.h" />

+    <ClInclude Include="$(FREERTOS_SOURCE_DIR)\portable\MSVC-MingW\portmacro.h" />

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IP_Common.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv4.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv4_Private.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv4_Sockets.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv4_Utils.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv6.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv6_Private.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv6_Sockets.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\source\include\FreeRTOS_IPv6_Utils.h">

+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>

+    </ClInclude>

+    <ClInclude Include="TCPEchoClient_SingleTasks.h" />

+    <ClInclude Include="UDPEchoClient_SingleTasks.h" />

+  </ItemGroup>

+</Project>
\ No newline at end of file
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/main.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/main.c
new file mode 100644
index 000000000..00bdec4be
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/main.c
@@ -0,0 +1,1109 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/*
+ * This project is a cut down version of the project described on the following
+ * link.  Only the simple UDP client and server and the TCP echo clients are
+ * included in the build:
+ * http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html
+ */
+
+/* Standard includes. */
+#include <stdio.h>
+#include <time.h>
+
+/* FreeRTOS includes. */
+#include <FreeRTOS.h>
+#include "task.h"
+#include "semphr.h"
+
+/* Demo application includes. */
+#include "FreeRTOS_IP.h"
+#include "FreeRTOS_Sockets.h"
+#include "FreeRTOS_Routing.h"
+
+#if ( ipconfigUSE_NTP_DEMO != 0 )
+    #include "NTPDemo.h"
+#endif
+
+#if ( ipconfigMULTI_INTERFACE == 1 )
+    #include "FreeRTOS_ND.h"
+#endif
+
+#include "logging.h"
+
+#include "plus_tcp_demo_cli.h"
+#include "TCPEchoClient_SingleTasks.h"
+#include "UDPEchoClient_SingleTasks.h"
+
+#ifndef ARRAY_SIZE
+    #define ARRAY_SIZE( x )    ( int ) ( sizeof( x ) / sizeof( x )[ 0 ] )
+#endif
+
+#ifdef ipconfigCOMPATIBLE_WITH_SINGLE
+    #undef ipconfigCOMPATIBLE_WITH_SINGLE
+#endif
+
+/* Simple UDP client and server task parameters. */
+#define mainSIMPLE_UDP_CLIENT_SERVER_TASK_PRIORITY    ( tskIDLE_PRIORITY )
+#define mainSIMPLE_UDP_CLIENT_SERVER_PORT             ( 5005UL )
+
+/* Echo client task parameters - used for both TCP and UDP echo clients. */
+#define mainECHO_CLIENT_TASK_STACK_SIZE               ( configMINIMAL_STACK_SIZE * 2 )      /* Not used in the Windows port. */
+#define mainECHO_CLIENT_TASK_PRIORITY                 ( tskIDLE_PRIORITY + 1 )
+
+/* Echo server task parameters. */
+#define mainECHO_SERVER_TASK_STACK_SIZE               ( configMINIMAL_STACK_SIZE * 2 )      /* Not used in the Windows port. */
+#define mainECHO_SERVER_TASK_PRIORITY                 ( tskIDLE_PRIORITY + 1 )
+
+/* Define a name that will be used for LLMNR and NBNS searches. */
+#define mainHOST_NAME                                 "RTOSDemo"
+#define mainDEVICE_NICK_NAME                          "windows_demo"
+
+/* Set the following constants to 1 or 0 to define which tasks to include and
+ * exclude:
+ *
+ * mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS:  When set to 1 two UDP client tasks
+ * and two UDP server tasks are created.  The clients talk to the servers.  One set
+ * of tasks use the standard sockets interface, and the other the zero copy sockets
+ * interface.  These tasks are self checking and will trigger a configASSERT() if
+ * they detect a difference in the data that is received from that which was sent.
+ * As these tasks use UDP, and can therefore loose packets, they will cause
+ * configASSERT() to be called when they are run in a less than perfect networking
+ * environment.
+ *
+ * mainCREATE_TCP_ECHO_TASKS_SINGLE:  When set to 1 a set of tasks are created that
+ * send TCP echo requests to the standard echo port (port 7), then wait for and
+ * verify the echo reply, from within the same task (Tx and Rx are performed in the
+ * same RTOS task).  The IP address of the echo server must be configured using the
+ * configECHO_SERVER_ADDR0 to configECHO_SERVER_ADDR3 constants in
+ * FreeRTOSConfig.h.
+ *
+ * mainCREATE_TCP_ECHO_SERVER_TASK:  When set to 1 a task is created that accepts
+ * connections on the standard echo port (port 7), then echos back any data
+ * received on that connection.
+ * 
+ * mainCREATE_UDP_ECHO_SERVER_TASK:  When set to 1 a task is created that sends data
+ * to the address configECHO_SERVER_ADDR_STRING (IPv4/Ipv6) where it is 
+ * expected to echo back the data, which, the created tasks receives.
+ * 
+ */
+#define mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS     0
+#define mainCREATE_TCP_ECHO_TASKS_SINGLE              1 /* 1 */
+#define mainCREATE_TCP_ECHO_SERVER_TASK               0
+#define mainCREATE_UDP_ECHO_SERVER_TASK               0
+/*-----------------------------------------------------------*/
+
+/* Define a task that is used to start and monitor several tests. */
+static void prvServerWorkTask( void * pvArgument );
+
+/* Let this task run at a low priority. */
+#define mainTCP_SERVER_TASK_PRIORITY    ( tskIDLE_PRIORITY + 1 )
+
+/* Give it an appropriate stack size. */
+#define mainTCP_SERVER_STACK_SIZE       2048
+
+/*
+ * Just seeds the simple pseudo random number generator.
+ */
+static void prvSRand( UBaseType_t ulSeed );
+
+/*
+ * Miscellaneous initialisation including preparing the logging and seeding the
+ * random number generator.
+ */
+static void prvMiscInitialisation( void );
+static void dns_test( const char * pcHostName );
+
+void showAddressInfo( struct freertos_addrinfo * pxAddrInfo );
+
+/* The default IP and MAC address used by the demo.  The address configuration
+ * defined here will be used if ipconfigUSE_DHCP is 0, or if ipconfigUSE_DHCP is
+ * 1 but a DHCP server could not be contacted.  See the online documentation for
+ * more information. */
+static const uint8_t ucIPAddress[ 4 ] = { configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 };
+static const uint8_t ucNetMask[ 4 ] = { configNET_MASK0, configNET_MASK1, configNET_MASK2, configNET_MASK3 };
+static const uint8_t ucGatewayAddress[ 4 ] = { configGATEWAY_ADDR0, configGATEWAY_ADDR1, configGATEWAY_ADDR2, configGATEWAY_ADDR3 };
+static const uint8_t ucDNSServerAddress[ 4 ] = { configDNS_SERVER_ADDR0, configDNS_SERVER_ADDR1, configDNS_SERVER_ADDR2, configDNS_SERVER_ADDR3 };
+
+/* Set the following constant to pdTRUE to log using the method indicated by the
+ * name of the constant, or pdFALSE to not log using the method indicated by the
+ * name of the constant.  Options include to standard out (xLogToStdout), to a disk
+ * file (xLogToFile), and to a UDP port (xLogToUDP).  If xLogToUDP is set to pdTRUE
+ * then UDP messages are sent to the IP address configured as the echo server
+ * address (see the configECHO_SERVER_ADDR0 definitions in FreeRTOSConfig.h) and
+ * the port number set by configPRINT_PORT in FreeRTOSConfig.h. */
+const BaseType_t xLogToStdout = pdTRUE, xLogToFile = pdFALSE, xLogToUDP = pdFALSE;
+
+/* Default MAC address configuration.  The demo creates a virtual network
+ * connection that uses this MAC address by accessing the raw Ethernet data
+ * to and from a real network connection on the host PC.  See the
+ * configNETWORK_INTERFACE_TO_USE definition for information on how to configure
+ * the real network connection to use. */
+const uint8_t ucMACAddress[ 6 ] = { configMAC_ADDR0, configMAC_ADDR1, configMAC_ADDR2, configMAC_ADDR3, configMAC_ADDR4, configMAC_ADDR5 };
+
+/* Use by the pseudo random number generator. */
+static UBaseType_t ulNextRand;
+
+#define USES_IPV6_ENDPOINT    1  /* 0 */
+
+/* A mask of end-points that are up. */
+#if ( USES_IPV6_ENDPOINT != 0 )
+    #define mainNETWORK_UP_COUNT    3U
+#else
+    #define mainNETWORK_UP_COUNT    1U
+#endif
+
+static uint32_t uxNetworkisUp = 0U;
+
+
+/* A semaphore to become idle. */
+SemaphoreHandle_t xServerSemaphore;
+
+/*-----------------------------------------------------------*/
+
+BaseType_t xHandleTestingCommand( char * pcCommand,
+                                  size_t uxLength );
+void xHandleTesting( void );
+void showEndPoint( NetworkEndPoint_t * pxEndPoint );
+
+#if ( ipconfigMULTI_INTERFACE == 1 ) && ( ipconfigCOMPATIBLE_WITH_SINGLE == 0 )
+    /* In case multiple interfaces are used, define them statically. */
+
+/* With WinPCap there is only 1 physical interface. */
+    static NetworkInterface_t xInterfaces[ 1 ];
+
+/* It will have several end-points. */
+    static NetworkEndPoint_t xEndPoints[ 4 ];
+
+/* A function from NetInterface.c to initialise the interface descriptor
+ * of type 'NetworkInterface_t'. */
+    NetworkInterface_t * pxWinPcap_FillInterfaceDescriptor( BaseType_t xEMACIndex,
+                                                            NetworkInterface_t * pxInterface );
+#endif /* ipconfigMULTI_INTERFACE */
+
+int main( void )
+{
+    const uint32_t ulLongTime_ms = pdMS_TO_TICKS( 1000UL );
+
+    /*
+     * Instructions for using this project are provided on:
+     * http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html
+     */
+
+    /* Miscellaneous initialisation including preparing the logging and seeding
+     * the random number generator. */
+    prvMiscInitialisation();
+
+    #if USE_LOG_EVENT
+        iEventLogInit();
+    #endif
+
+    /* Initialise the network interface.
+     *
+     ***NOTE*** Tasks that use the network are created in the network event hook
+     * when the network is connected and ready for use (see the definition of
+     * vApplicationIPNetworkEventHook() below).  The address values passed in here
+     * are used if ipconfigUSE_DHCP is set to 0, or if ipconfigUSE_DHCP is set to 1
+     * but a DHCP server cannot be	contacted. */
+
+    #if ( ipconfigMULTI_INTERFACE == 0 ) || ( ipconfigCOMPATIBLE_WITH_SINGLE == 1 )
+        /* Using the old /single /IPv4 library, or using backward compatible mode of the new /multi library. */
+        FreeRTOS_debug_printf( ( "FreeRTOS_IPInit\r\n" ) );
+        FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );
+    #else
+        /* Initialise the interface descriptor for WinPCap. */
+        pxWinPcap_FillInterfaceDescriptor( 0, &( xInterfaces[ 0 ] ) );
+
+        /* === End-point 0 === */
+        FreeRTOS_FillEndPoint( &( xInterfaces[ 0 ] ), &( xEndPoints[ 0 ] ), ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );
+        #if ( ipconfigUSE_DHCP != 0 )
+            {
+                /* End-point 0 wants to use DHCPv4. */
+                xEndPoints[ 0 ].bits.bWantDHCP = pdTRUE;
+            }
+        #endif /* ( ipconfigUSE_DHCP != 0 ) */
+
+        /*
+         *     End-point-1 : public
+         *     Network: 2001:470:ed44::/64
+         *     IPv6   : 2001:470:ed44::4514:89d5:4589:8b79/128
+         *     Gateway: fe80::ba27:ebff:fe5a:d751  // obtained from Router Advertisement
+         */
+        #if ( ipconfigUSE_IPv6 != 0 && USES_IPV6_ENDPOINT != 0 )
+            {
+                IPv6_Address_t xIPAddress;
+                IPv6_Address_t xPrefix;
+                IPv6_Address_t xGateWay;
+                IPv6_Address_t xDNSServer1, xDNSServer2;
+
+                FreeRTOS_inet_pton6( "2001:470:ed44::", xPrefix.ucBytes );
+
+                FreeRTOS_CreateIPv6Address( &xIPAddress, &xPrefix, 64, pdTRUE );
+                FreeRTOS_inet_pton6( "fe80::ba27:ebff:fe5a:d751", xGateWay.ucBytes );
+
+                FreeRTOS_FillEndPoint_IPv6( &( xInterfaces[ 0 ] ),
+                                            &( xEndPoints[ 1 ] ),
+                                            &( xIPAddress ),
+                                            &( xPrefix ),
+                                            64uL, /* Prefix length. */
+                                            &( xGateWay ),
+                                            NULL, /* pxDNSServerAddress: Not used yet. */
+                                            ucMACAddress );
+                FreeRTOS_inet_pton6( "2001:4860:4860::8888", xEndPoints[ 1 ].ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes );
+                FreeRTOS_inet_pton6( "fe80::1", xEndPoints[ 1 ].ipv6_settings.xDNSServerAddresses[ 1 ].ucBytes );
+                FreeRTOS_inet_pton6( "2001:4860:4860::8888", xEndPoints[ 1 ].ipv6_defaults.xDNSServerAddresses[ 0 ].ucBytes );
+                FreeRTOS_inet_pton6( "fe80::1", xEndPoints[ 1 ].ipv6_defaults.xDNSServerAddresses[ 1 ].ucBytes );
+
+                #if ( ipconfigUSE_RA != 0 )
+                    {
+                        /* End-point 1 wants to use Router Advertisement */
+                        xEndPoints[ 1 ].bits.bWantRA = pdTRUE;
+                    }
+                #endif /* #if( ipconfigUSE_RA != 0 ) */
+                #if ( ipconfigUSE_DHCPv6 != 0 )
+                    {
+                        /* End-point 1 wants to use DHCPv6. */
+                        xEndPoints[ 1 ].bits.bWantDHCP = pdTRUE;
+                    }
+                #endif /* ( ipconfigUSE_DHCPv6 != 0 ) */
+            }
+        #endif /* ( ipconfigUSE_IPv6 != 0 ) */
+        #if ( ipconfigUSE_IPv6 != 0 && USES_IPV6_ENDPOINT != 0 )
+            {
+                /*
+                 *     End-point-3 : private
+                 *     Network: fe80::/10 (link-local)
+                 *     IPv6   : fe80::d80e:95cc:3154:b76a/128
+                 *     Gateway: -
+                 */
+                {
+                    IPv6_Address_t xIPAddress;
+                    IPv6_Address_t xPrefix;
+
+                    FreeRTOS_inet_pton6( "fe80::", xPrefix.ucBytes );
+                    FreeRTOS_inet_pton6( "fe80::7009", xIPAddress.ucBytes );
+
+                    FreeRTOS_FillEndPoint_IPv6(
+                        &( xInterfaces[ 0 ] ),
+                        &( xEndPoints[ 2 ] ),
+                        &( xIPAddress ),
+                        &( xPrefix ),
+                        10U,  /* Prefix length. */
+                        NULL, /* No gateway */
+                        NULL, /* pxDNSServerAddress: Not used yet. */
+                        ucMACAddress );
+                }
+            }
+        #endif /* if ( ipconfigUSE_IPv6 != 0 ) */
+        /* === End-point 0 === */
+        #if ( ( mainNETWORK_UP_COUNT >= 4U ) || ( USES_IPV6_ENDPOINT == 0 && mainNETWORK_UP_COUNT >= 2U ) )
+            {
+                /*172.25.201.204 */
+                /*netmask 255.255.240.0 */
+                const uint8_t ucMACAddress2[ 6 ] = { 0x00, 0x22, 0x22, 0x22, 0x22, 82 };
+                const uint8_t ucIPAddress2[ 4 ] = { 192, 168, 2, 210 };
+                const uint8_t ucNetMask2[ 4 ] = { 255, 255, 255, 0 };
+                const uint8_t ucGatewayAddress2[ 4 ] = { 0, 0, 0, 0 };
+                FreeRTOS_FillEndPoint( &( xInterfaces[ 0 ] ), &( xEndPoints[ 3 ] ), ucIPAddress2, ucNetMask2, ucGatewayAddress2, ucDNSServerAddress, ucMACAddress2 );
+                #if ( ipconfigUSE_DHCP != 0 )
+                    {
+                        /* End-point 0 wants to use DHCPv4. */
+                        xEndPoints[ 3 ].bits.bWantDHCP = pdTRUE;
+                    }
+                #endif /* ( ipconfigUSE_DHCP != 0 ) */
+            }
+        #endif /* ( mainNETWORK_UP_COUNT >= 3U ) */
+
+        FreeRTOS_IPStart();
+    #endif /* if ( ipconfigMULTI_INTERFACE == 0 ) || ( ipconfigCOMPATIBLE_WITH_SINGLE == 1 ) */
+    xTaskCreate( prvServerWorkTask, "SvrWork", mainTCP_SERVER_STACK_SIZE, NULL, mainTCP_SERVER_TASK_PRIORITY, NULL );
+
+    /* Start the RTOS scheduler. */
+    FreeRTOS_debug_printf( ( "vTaskStartScheduler\r\n" ) );
+    vTaskStartScheduler();
+
+    /* If all is well, the scheduler will now be running, and the following
+     * line will never be reached.  If the following line does execute, then
+     * there was insufficient FreeRTOS heap memory available for the idle and/or
+     * timer tasks	to be created.  See the memory management section on the
+     * FreeRTOS web site for more details (this is standard text that is not not
+     * really applicable to the Win32 simulator port). */
+    for( ; ; )
+    {
+        Sleep( ulLongTime_ms );
+    }
+}
+/*-----------------------------------------------------------*/
+
+void vApplicationIdleHook( void )
+{
+    const uint32_t ulMSToSleep = 1;
+
+    /* This is just a trivial example of an idle hook.  It is called on each
+     * cycle of the idle task if configUSE_IDLE_HOOK is set to 1 in
+     * FreeRTOSConfig.h.  It must *NOT* attempt to block.  In this case the
+     * idle task just sleeps to lower the CPU usage. */
+    Sleep( ulMSToSleep );
+}
+/*-----------------------------------------------------------*/
+
+void vAssertCalled( const char * pcFile,
+                    uint32_t ulLine )
+{
+    const uint32_t ulLongSleep = 1000UL;
+    volatile uint32_t ulBlockVariable = 0UL;
+    volatile char * pcFileName = ( volatile char * ) pcFile;
+    volatile uint32_t ulLineNumber = ulLine;
+
+    ( void ) pcFileName;
+    ( void ) ulLineNumber;
+
+    FreeRTOS_debug_printf( ( "vAssertCalled( %s, %ld\r\n", pcFile, ulLine ) );
+
+    /* Setting ulBlockVariable to a non-zero value in the debugger will allow
+     * this function to be exited. */
+    taskDISABLE_INTERRUPTS();
+    {
+        while( ulBlockVariable == 0UL )
+        {
+            Sleep( ulLongSleep );
+        }
+    }
+    taskENABLE_INTERRUPTS();
+}
+/*-----------------------------------------------------------*/
+
+/* Called by FreeRTOS+TCP when the network connects or disconnects.  Disconnect
+ * events are only received if implemented in the MAC driver. */
+/* *INDENT-OFF* */
+#if ( ipconfigMULTI_INTERFACE != 0 ) || ( ipconfigCOMPATIBLE_WITH_SINGLE != 0 )
+    /* The multi version: each end-point comes up individually. */
+    void vApplicationIPNetworkEventHook( eIPCallbackEvent_t eNetworkEvent,
+                                         NetworkEndPoint_t * pxEndPoint )
+#else
+    /* The single version, the interface comes up as a whole. */
+    void vApplicationIPNetworkEventHook( eIPCallbackEvent_t eNetworkEvent )
+#endif
+/* *INDENT-ON* */
+{
+    static BaseType_t xTasksAlreadyCreated = pdFALSE;
+
+    /* If the network has just come up...*/
+    if( eNetworkEvent == eNetworkUp )
+    {
+        /* Create the tasks that use the IP stack if they have not already been
+         * created. */
+        uxNetworkisUp++;
+
+        if( ( xTasksAlreadyCreated == pdFALSE ) && ( uxNetworkisUp == mainNETWORK_UP_COUNT ) )
+        {
+            #if USE_LOG_EVENT
+                iEventLogClear();
+            #endif
+
+            /* See the comments above the definitions of these pre-processor
+             * macros at the top of this file for a description of the individual
+             * demo tasks. */
+            #if ( mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS == 1 )
+                {
+                    vStartSimpleUDPClientServerTasks( configMINIMAL_STACK_SIZE, mainSIMPLE_UDP_CLIENT_SERVER_PORT, mainSIMPLE_UDP_CLIENT_SERVER_TASK_PRIORITY );
+                }
+            #endif /* mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS */
+
+            #if ( mainCREATE_TCP_ECHO_TASKS_SINGLE == 1 )
+                {
+                    vStartTCPEchoClientTasks_SingleTasks( mainECHO_CLIENT_TASK_STACK_SIZE, mainECHO_CLIENT_TASK_PRIORITY );
+                }
+            #endif /* mainCREATE_TCP_ECHO_TASKS_SINGLE */
+
+            #if ( mainCREATE_TCP_ECHO_SERVER_TASK == 1 )
+                {
+                    vStartSimpleTCPServerTasks( mainECHO_SERVER_TASK_STACK_SIZE, mainECHO_SERVER_TASK_PRIORITY );
+                }
+            #endif
+
+            #if ( mainCREATE_UDP_ECHO_SERVER_TASK == 1 )
+                {
+                    vStartUDPEchoClientTasks_SingleTasks(mainECHO_SERVER_TASK_STACK_SIZE, mainECHO_SERVER_TASK_PRIORITY);
+                }
+            #endif
+
+            xTasksAlreadyCreated = pdTRUE;
+        }
+
+        FreeRTOS_printf( ( "uxNetworkisUp = %u\n", ( unsigned ) uxNetworkisUp ) );
+
+        if( pxEndPoint->bits.bIPv6 == 0U )
+        {
+            *ipLOCAL_IP_ADDRESS_POINTER = pxEndPoint->ipv4_settings.ulIPAddress;
+            FreeRTOS_printf( ( "IPv4 address = %xip\n", FreeRTOS_ntohl( pxEndPoint->ipv4_settings.ulIPAddress ) ) );
+        }
+
+        #if ( ipconfigMULTI_INTERFACE == 0 )
+            {
+                uint32_t ulIPAddress, ulNetMask, ulGatewayAddress, ulDNSServerAddress;
+
+                /* Print out the network configuration, which may have come from a DHCP
+                 * server. */
+                FreeRTOS_GetAddressConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress );
+                FreeRTOS_inet_ntoa( ulIPAddress, cBuffer );
+                FreeRTOS_printf( ( "\r\n\r\nIP Address: %s\r\n", cBuffer ) );
+
+                FreeRTOS_inet_ntoa( ulNetMask, cBuffer );
+                FreeRTOS_printf( ( "Subnet Mask: %s\r\n", cBuffer ) );
+
+                FreeRTOS_inet_ntoa( ulGatewayAddress, cBuffer );
+                FreeRTOS_printf( ( "Gateway Address: %s\r\n", cBuffer ) );
+
+                FreeRTOS_inet_ntoa( ulDNSServerAddress, cBuffer );
+                FreeRTOS_printf( ( "DNS Server Address: %s\r\n\r\n\r\n", cBuffer ) );
+            }
+        #else /* if ( ipconfigMULTI_INTERFACE == 0 ) */
+            {
+                /* Print out the network configuration, which may have come from a DHCP
+                 * server. */
+                showEndPoint( pxEndPoint );
+            }
+        #endif /* ipconfigMULTI_INTERFACE */
+    }
+}
+/*-----------------------------------------------------------*/
+
+void vApplicationMallocFailedHook( void )
+{
+    /* Called if a call to pvPortMalloc() fails because there is insufficient
+     * free memory available in the FreeRTOS heap.  pvPortMalloc() is called
+     * internally by FreeRTOS API functions that create tasks, queues, software
+     * timers, and semaphores.  The size of the FreeRTOS heap is set by the
+     * configTOTAL_HEAP_SIZE configuration constant in FreeRTOSConfig.h. */
+    vAssertCalled( __FILE__, __LINE__ );
+}
+/*-----------------------------------------------------------*/
+
+UBaseType_t uxRand( void )
+{
+    const uint32_t ulMultiplier = 0x015a4e35UL, ulIncrement = 1UL;
+
+    /* Utility function to generate a pseudo random number. */
+
+    ulNextRand = ( ulMultiplier * ulNextRand ) + ulIncrement;
+    return( ( int ) ( ulNextRand >> 16UL ) & 0x7fffUL );
+}
+/*-----------------------------------------------------------*/
+
+uint32_t uxRand32( void )
+{
+    /* uxRand only returns 15 random bits. Call it 3 times. */
+    uint32_t ul[ 3 ] = { uxRand(), uxRand(), uxRand() };
+    uint32_t uxReturn = ul[ 0 ] | ( ul[ 1 ] << 15 ) | ( ul[ 2 ] << 30 );
+
+    return uxReturn;
+}
+
+static void prvSRand( UBaseType_t ulSeed )
+{
+    /* Utility function to seed the pseudo random number generator. */
+    ulNextRand = ulSeed;
+}
+/*-----------------------------------------------------------*/
+
+static void prvMiscInitialisation( void )
+{
+    time_t xTimeNow;
+    uint32_t ulLoggingIPAddress;
+
+    ulLoggingIPAddress = FreeRTOS_inet_addr_quick( configECHO_SERVER_ADDR0, configECHO_SERVER_ADDR1, configECHO_SERVER_ADDR2, configECHO_SERVER_ADDR3 );
+    vLoggingInit( xLogToStdout, xLogToFile, xLogToUDP, ulLoggingIPAddress, configPRINT_PORT );
+
+    /* Seed the random number generator. */
+    time( &xTimeNow );
+    FreeRTOS_debug_printf( ( "Seed for randomiser: %lu\r\n", xTimeNow ) );
+    prvSRand( ( uint32_t ) xTimeNow );
+    FreeRTOS_debug_printf( ( "Random numbers: %08X %08X %08X %08X\r\n", ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32() ) );
+}
+/*-----------------------------------------------------------*/
+
+#if ( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 ) || ( ipconfigDHCP_REGISTER_HOSTNAME == 1 )
+
+    const char * pcApplicationHostnameHook( void )
+    {
+        /* Assign the name "FreeRTOS" to this network node.  This function will
+         * be called during the DHCP: the machine will be registered with an IP
+         * address plus this name. */
+        return mainHOST_NAME;
+    }
+
+#endif
+/*-----------------------------------------------------------*/
+
+#if ( ipconfigUSE_MDNS != 0 ) || ( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 )
+
+    #if ( ipconfigMULTI_INTERFACE != 0 ) && ( ipconfigUSE_IPv6 != 0 ) && ( TESTING_PATCH == 0 )
+        static BaseType_t setEndPoint( NetworkEndPoint_t * pxEndPoint )
+        {
+            NetworkEndPoint_t * px;
+            BaseType_t xDone = pdFALSE;
+            BaseType_t bDNS_IPv6 = ( pxEndPoint->usDNSType == dnsTYPE_AAAA_HOST ) ? 1 : 0;
+
+            FreeRTOS_printf( ( "Wanted v%c got v%c\n", bDNS_IPv6 ? '6' : '4', pxEndPoint->bits.bIPv6 ? '6' : '4' ) );
+
+            if( ( pxEndPoint->usDNSType == dnsTYPE_ANY_HOST ) ||
+                ( ( pxEndPoint->usDNSType == dnsTYPE_AAAA_HOST ) == ( pxEndPoint->bits.bIPv6 != 0U ) ) )
+            {
+                xDone = pdTRUE;
+            }
+            else
+            {
+                for( px = FreeRTOS_FirstEndPoint( pxEndPoint->pxNetworkInterface );
+                     px != NULL;
+                     px = FreeRTOS_NextEndPoint( pxEndPoint->pxNetworkInterface, px ) )
+                {
+                    BaseType_t bIPv6 = ENDPOINT_IS_IPv6( px );
+
+                    if( bIPv6 == bDNS_IPv6 )
+                    {
+                        if( bIPv6 != 0 )
+                        {
+                            memcpy( pxEndPoint->ipv6_settings.xIPAddress.ucBytes, px->ipv6_settings.xIPAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
+                        }
+                        else
+                        {
+                            pxEndPoint->ipv4_settings.ulIPAddress = px->ipv4_settings.ulIPAddress;
+                        }
+
+                        pxEndPoint->bits.bIPv6 = bDNS_IPv6;
+                        xDone = pdTRUE;
+                        break;
+                    }
+                }
+            }
+
+            if( pxEndPoint->bits.bIPv6 != 0 )
+            {
+                FreeRTOS_printf( ( "%s address %pip\n", xDone ? "Success" : "Failed", pxEndPoint->ipv6_settings.xIPAddress.ucBytes ) );
+            }
+            else
+            {
+                FreeRTOS_printf( ( "%s address %xip\n", xDone ? "Success" : "Failed", ( unsigned ) FreeRTOS_ntohl( pxEndPoint->ipv4_settings.ulIPAddress ) ) );
+            }
+
+            return xDone;
+        }
+    #endif /* ( ipconfigMULTI_INTERFACE != 0 ) */
+
+/*-----------------------------------------------------------*/
+
+    #if ( ipconfigMULTI_INTERFACE != 0 )
+        BaseType_t xApplicationDNSQueryHook( NetworkEndPoint_t * pxEndPoint,
+                                             const char * pcName )
+    #else
+        BaseType_t xApplicationDNSQueryHook( const char * pcName )
+    #endif
+    {
+        BaseType_t xReturn;
+
+        /* Determine if a name lookup is for this node.  Two names are given
+         * to this node: that returned by pcApplicationHostnameHook() and that set
+         * by mainDEVICE_NICK_NAME. */
+        const char * serviceName = ( strstr( pcName, ".local" ) != NULL ) ? "mDNS" : "LLMNR";
+
+        if( strncasecmp( pcName, "bong", 4 ) == 0 )
+        {
+            #if ( ipconfigUSE_IPv6 != 0 )
+                int ip6Preferred = ( pcName[ 4 ] == '6' ) ? pdTRUE : pdFALSE;
+
+                /*
+                 #define dnsTYPE_A_HOST            0x0001U // DNS type A host.
+                 #define dnsTYPE_AAAA_HOST         0x001CU // DNS type AAAA host.
+                 */
+                xReturn = ( pxEndPoint->usDNSType == dnsTYPE_AAAA_HOST ) == ( ip6Preferred == pdTRUE );
+            #else
+                xReturn = pdTRUE;
+            #endif
+        }
+        else if( ( strcasecmp( pcName, pcApplicationHostnameHook() ) == 0 ) ||
+                 ( strcasecmp( pcName, "winsim.local" ) == 0 ) ||
+                 ( strcasecmp( pcName, "winsim" ) == 0 ) ||
+                 ( strcasecmp( pcName, mainDEVICE_NICK_NAME ) == 0 ) )
+        {
+            xReturn = pdTRUE;
+        }
+        else
+        {
+            xReturn = pdFAIL;
+        }
+
+        #if ( ipconfigMULTI_INTERFACE != 0 ) && ( ipconfigUSE_IPv6 != 0 ) && ( TESTING_PATCH == 0 )
+            if( xReturn == pdTRUE )
+            {
+                xReturn = setEndPoint( pxEndPoint );
+            }
+        #endif
+        {
+            #if ( ipconfigMULTI_INTERFACE != 0 ) && ( ipconfigUSE_IPv6 != 0 )
+                FreeRTOS_printf( ( "%s query '%s' = %d IPv%c\n", serviceName, pcName, ( int ) xReturn, pxEndPoint->bits.bIPv6 ? '6' : '4' ) );
+            #else
+                FreeRTOS_printf( ( "%s query '%s' = %d IPv4 only\n", serviceName, pcName, ( int ) xReturn ) );
+            #endif
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+#endif /* if ( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 ) */
+/*-----------------------------------------------------------*/
+
+/*
+ * Callback that provides the inputs necessary to generate a randomized TCP
+ * Initial Sequence Number per RFC 6528.  THIS IS ONLY A DUMMY IMPLEMENTATION
+ * THAT RETURNS A PSEUDO RANDOM NUMBER SO IS NOT INTENDED FOR USE IN PRODUCTION
+ * SYSTEMS.
+ */
+extern uint32_t ulApplicationGetNextSequenceNumber( uint32_t ulSourceAddress,
+                                                    uint16_t usSourcePort,
+                                                    uint32_t ulDestinationAddress,
+                                                    uint16_t usDestinationPort )
+{
+    ( void ) ulSourceAddress;
+    ( void ) usSourcePort;
+    ( void ) ulDestinationAddress;
+    ( void ) usDestinationPort;
+
+    return uxRand32();
+}
+/*-----------------------------------------------------------*/
+
+/*
+ * Supply a random number to FreeRTOS+TCP stack.
+ * THIS IS ONLY A DUMMY IMPLEMENTATION THAT RETURNS A PSEUDO RANDOM NUMBER
+ * SO IS NOT INTENDED FOR USE IN PRODUCTION SYSTEMS.
+ */
+BaseType_t xApplicationGetRandomNumber( uint32_t * pulNumber )
+{
+    *( pulNumber ) = uxRand();
+    return pdTRUE;
+}
+/*-----------------------------------------------------------*/
+
+const char * pcCommandList[] =
+{
+    /*    "arpqc 2404:6800:4003:c0f::5e",    // a public IP-address */
+    /*    "arpqc fe80::ba27:ebff:fe5a:d751", // a gateway */
+    /*    "arpqc 192.168.2.1", */
+    /*    "arpqc 172.217.194.100", */
+    /*    "dnsq4 google.de", */
+    /*    "dnsq6 google.nl", */
+
+    /*    "arpqc 192.168.2.1", */
+    /*    "arpqc 192.168.2.10", */
+    /*    "arpqc 172.217.194.100", */
+    /*    "arpqc 2404:6800:4003:c0f::5e", */
+    "ifconfig",
+    /*      "udp 192.168.2.255@2402 Hello", */
+    /*      "udp 192.168.2.255@2402 Hello", */
+    /*      "udp 192.168.2.255@2402 Hello", */
+    /*      "udp 192.168.2.255@2402 Hello", */
+    /*      "http 192.168.2.11 /index.html 33001", */
+    /*      "http 2404:6800:4003:c05::5e /index.html 80", */
+    /*      "ping6 2606:4700:f1::1", */
+    /*      "ping6 2606:4700:f1::1", */
+    /*      "dnsq4  google.de", */
+    /*      "dnsq6  google.nl", */
+    /*      "dnsq4  google.es", */
+    /*      "dnsq6  google.co.uk", */
+    /*      "udp 192.168.2.11@7 Hello world 1\r\n", */
+    /*      "udp fe80::715e:482e:4a3e:d081@7 Hello world 1\r\n", */
+    /*      "dnsq4  google.de", */
+    /*      "dnsq6  google.nl", */
+    /*      "dnsq4  google.es", */
+    /*      "dnsq6  google.co.uk", */
+
+    /*      "ntp6a 2.europe.pool.ntp.org", */
+    /*      "ping4c 74.125.24.94", */
+    /*      "ping4c 192.168.2.1", */
+    /*      "ping4c 192.168.2.10", */
+    /*      "ping6c 2404:6800:4003:c11::5e", */
+    /*      "ping6c 2404:6800:4003:c11::5e", */
+
+    /*      "ping4 raspberrypi.local", */
+    /*      "ping6 2404:6800:4003:c0f::5e", */
+
+    /*      "http4 google.de /index.html", */
+    /*      "http6 google.nl /index.html", */
+    /*      "ping4 10.0.1.10", */
+    /*      "ping4 192.168.2.1", */
+    /*      "dnsq4 amazon.com", */
+    /*      "ping6 google.de", */
+    /*      "ntp6a 2.europe.pool.ntp.org", */
+};
+
+static void prvServerWorkTask( void * pvArgument )
+{
+    BaseType_t xCommandIndex = 0;
+    Socket_t xSocket;
+
+    ( void ) pvArgument;
+    FreeRTOS_printf( ( "prvServerWorkTask started\n" ) );
+
+    xServerSemaphore = xSemaphoreCreateBinary();
+    configASSERT( xServerSemaphore != NULL );
+
+    /* pcap_prepare(); */
+
+    /* Wait for all end-points to come up.
+     * They're counted with 'uxNetworkisUp'. */
+    do
+    {
+        vTaskDelay( pdMS_TO_TICKS( 100U ) );
+    } while( uxNetworkisUp != mainNETWORK_UP_COUNT );
+
+    xDNS_IP_Preference = xPreferenceIPv6;
+
+    {
+        xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );
+        struct freertos_sockaddr xAddress;
+
+        ( void ) memset( &( xAddress ), 0, sizeof( xAddress ) );
+        xAddress.sin_family = FREERTOS_AF_INET6;
+        xAddress.sin_port = FreeRTOS_htons( 5000U );
+
+        BaseType_t xReturn = FreeRTOS_bind( xSocket, &xAddress, ( socklen_t ) sizeof( xAddress ) );
+        FreeRTOS_printf( ( "Open socket %d bind = %d\n", xSocketValid( xSocket ), xReturn ) );
+        TickType_t xTimeoutTime = pdMS_TO_TICKS( 10U );
+        FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, &xTimeoutTime, sizeof( TickType_t ) );
+    }
+
+    for( ; ; )
+    {
+        char pcCommand[ 129 ];
+        TickType_t uxTickCount = pdMS_TO_TICKS( 200U );
+
+        if( xCommandIndex < ARRAY_SIZE( pcCommandList ) )
+        {
+            while( uxTickCount != 0 )
+            {
+                xHandleTesting();
+                xSemaphoreTake( xServerSemaphore, pdMS_TO_TICKS( 10 ) );
+                uxTickCount--;
+            }
+
+            /*          vTaskDelay( pdMS_TO_TICKS( 1000U ) ); */
+            FreeRTOS_printf( ( "\n" ) );
+
+            snprintf( pcCommand, sizeof( pcCommand ), "%s", pcCommandList[ xCommandIndex ] );
+            FreeRTOS_printf( ( "\n" ) );
+            FreeRTOS_printf( ( "/*==================== %s (%d/%d) ====================*/\n",
+                               pcCommand, xCommandIndex + 1, ARRAY_SIZE( pcCommandList ) ) );
+            FreeRTOS_printf( ( "\n" ) );
+            xHandleTestingCommand( pcCommand, sizeof( pcCommand ) );
+            xCommandIndex++;
+        }
+        else if( xCommandIndex == ARRAY_SIZE( pcCommandList ) )
+        {
+            FreeRTOS_printf( ( "Server task now ready.\n" ) );
+
+
+            #if ( ipconfigUSE_NTP_DEMO != 0 )
+                /* if (xNTPTaskIsRunning() != pdFALSE) */
+                {
+                    /* Ask once more for the current time. */
+                    /*   vStartNTPTask(0U, 0U); */
+                }
+            #endif
+
+            /*vTaskDelete( NULL ); */
+            xCommandIndex++;
+        }
+
+        {
+            char pcBuffer[ 1500 ];
+            struct freertos_sockaddr xSourceAddress;
+            socklen_t xLength = sizeof( socklen_t );
+            int32_t rc = FreeRTOS_recvfrom( xSocket, pcBuffer, sizeof( pcBuffer ), 0, &xSourceAddress, &xLength );
+
+            if( rc > 0 )
+            {
+                if( xSourceAddress.sin_family == FREERTOS_AF_INET6 )
+                {
+                    FreeRTOS_printf( ( "Recv UDP %d bytes from %pip port %u\n", rc, xSourceAddress.sin_address.xIP_IPv6.ucBytes, FreeRTOS_ntohs( xSourceAddress.sin_port ) ) );
+                }
+                else
+                {
+                    FreeRTOS_printf( ( "Recv UDP %d bytes from %xip port %u\n", rc, FreeRTOS_ntohl( xSourceAddress.sin_address.ulIP_IPv4 ), FreeRTOS_ntohs( xSourceAddress.sin_port ) ) );
+                }
+
+                if( rc == 14 )
+                {
+                    static BaseType_t xDone = 0;
+
+                    if( xDone == 3 )
+                    {
+                        BaseType_t xIPv6 = ( xSourceAddress.sin_family == FREERTOS_AF_INET6 ) ? pdTRUE : pdFALSE;
+                        FreeRTOS_printf( ( "%d: Clear %s table\n", xDone, xIPv6 ? "ND" : "ARP" ) );
+
+                        if( xIPv6 == pdTRUE )
+                        {
+                            FreeRTOS_ClearND();
+                        }
+                        else
+                        {
+                            FreeRTOS_ClearARP( NULL );
+                        }
+
+                        xDone = 0;
+                    }
+                    else
+                    {
+                        xDone++;
+                    }
+                }
+            }
+        }
+    }
+}
+
+#if ( ipconfigUSE_NTP_DEMO != 0 )
+
+/* Some functions to get NTP demo working. */
+
+    extern BaseType_t xNTPHasTime;
+    extern uint32_t ulNTPTime;
+
+    struct
+    {
+        uint32_t ntpTime;
+    }
+    time_guard;
+
+    int set_time( time_t * pxTime )
+    {
+        ( void ) pxTime;
+        time_guard.ntpTime = ulNTPTime - xTaskGetTickCount() / configTICK_RATE_HZ;
+        return 0;
+    }
+/*-----------------------------------------------------------*/
+
+    time_t get_time( time_t * puxTime )
+    {
+        time_t xTime = 0U;
+
+        if( xNTPHasTime != pdFALSE )
+        {
+            TickType_t passed = xTaskGetTickCount() / configTICK_RATE_HZ;
+            xTime = ( time_t ) time_guard.ntpTime + ( time_t ) passed;
+        }
+
+        if( puxTime != NULL )
+        {
+            *( puxTime ) = xTime;
+        }
+
+        return xTime;
+    }
+/*-----------------------------------------------------------*/
+
+    struct tm * gmtime_r( const time_t * pxTime,
+                          struct tm * tmStruct )
+    {
+        struct tm tm;
+
+        memcpy( &( tm ), gmtime( pxTime ), sizeof( tm ) );
+
+        if( tmStruct != NULL )
+        {
+            memcpy( tmStruct, &( tm ), sizeof tm );
+        }
+
+        return &( tm );
+    }
+/*-----------------------------------------------------------*/
+
+#endif /* ( ipconfigUSE_NTP_DEMO != 0 ) */
+
+BaseType_t xApplicationMemoryPermissions( uint32_t aAddress )
+{
+    ( void ) aAddress;
+    /* Return 1 for readable, 2 for writable, 3 for both. */
+    return 0x03;
+}
+/*-----------------------------------------------------------*/
+
+void vOutputChar( const char cChar,
+                  const TickType_t xTicksToWait )
+{
+    ( void ) cChar;
+    ( void ) xTicksToWait;
+}
+/*-----------------------------------------------------------*/
+
+#if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
+/*void vApplicationPingReplyHook(ePingReplyStatus_t eStatus, */
+/*    uint16_t usIdentifier) */
+/*{ */
+/*    ( void ) eStatus; */
+/*    FreeRTOS_printf( ( "vApplicationPingReplyHook called for %04x\n", usIdentifier ) ); */
+/*} */
+#endif
+
+#if ( ipconfigUSE_DHCP_HOOK != 0 )
+    eDHCPCallbackAnswer_t xApplicationDHCPHook( eDHCPCallbackPhase_t eDHCPPhase,
+                                                uint32_t ulIPAddress )
+    {
+        ( void ) eDHCPPhase;
+        ( void ) ulIPAddress;
+        return eDHCPContinue;
+    }
+#endif
+
+void handle_user_test( char * pcBuffer )
+{
+}
+
+void show_single_addressinfo( const char * pcFormat,
+                              const struct freertos_addrinfo * pxAddress )
+{
+    char cBuffer[ 40 ];
+    const uint8_t * pucAddress;
+
+    #if ( ipconfigUSE_IPv6 != 0 )
+        if( pxAddress->ai_family == FREERTOS_AF_INET6 )
+        {
+            struct freertos_sockaddr * sockaddr6 = ( ( struct freertos_sockaddr * ) pxAddress->ai_addr );
+
+            pucAddress = ( const uint8_t * ) &( sockaddr6->sin_addr6 );
+        }
+        else
+    #endif /* ( ipconfigUSE_IPv6 != 0 ) */
+    {
+        pucAddress = ( const uint8_t * ) &( pxAddress->ai_addr->sin_addr );
+    }
+
+    ( void ) FreeRTOS_inet_ntop( pxAddress->ai_family, ( const void * ) pucAddress, cBuffer, sizeof( cBuffer ) );
+
+    if( pcFormat != NULL )
+    {
+        FreeRTOS_printf( ( pcFormat, cBuffer ) );
+    }
+    else
+    {
+        FreeRTOS_printf( ( "Address: %s\n", cBuffer ) );
+    }
+}
+/*-----------------------------------------------------------*/
+
+/**
+ * @brief For testing purposes: print a list of DNS replies.
+ * @param[in] pxAddress: The first reply received ( or NULL )
+ */
+void show_addressinfo( const struct freertos_addrinfo * pxAddress )
+{
+    const struct freertos_addrinfo * ptr = pxAddress;
+    BaseType_t xIndex = 0;
+
+    while( ptr != NULL )
+    {
+        show_single_addressinfo( "Found Address: %s\n", ptr );
+
+        ptr = ptr->ai_next;
+    }
+
+    /* In case the function 'FreeRTOS_printf()` is not implemented. */
+    ( void ) xIndex;
+}
+static BaseType_t xDNSResult = -2;
+static void vDNSEvent( const char * pcName,
+                       void * pvSearchID,
+                       struct freertos_addrinfo * pxAddrInfo )
+{
+    FreeRTOS_printf( ( "vDNSEvent: called with %p\n", pxAddrInfo ) );
+    showAddressInfo( pxAddrInfo );
+
+    if( pxAddrInfo != NULL )
+    {
+        xDNSResult = 0;
+    }
+}
+
+static void dns_test( const char * pcHostName )
+{
+    uint32_t ulID = uxRand32();
+    BaseType_t rc;
+    TickType_t uxTimeout = pdMS_TO_TICKS( 2000U );
+
+    FreeRTOS_dnsclear();
+
+    struct freertos_addrinfo xHints;
+    struct freertos_addrinfo * pxResult = NULL;
+
+    memset( &xHints, 0, sizeof xHints );
+    xHints.ai_family = FREERTOS_AF_INET6;
+
+    rc = FreeRTOS_getaddrinfo( pcHostName, NULL, &xHints, &pxResult );
+
+    FreeRTOS_printf( ( "Lookup '%s': %d\n", pcHostName, rc ) );
+
+    FreeRTOS_dnsclear();
+    xDNSResult = -2;
+    rc = FreeRTOS_getaddrinfo_a( pcHostName,
+                                 NULL,
+                                 &xHints,
+                                 &pxResult, /* An allocated struct, containing the results. */
+                                 vDNSEvent,
+                                 ( void * ) ulID,
+                                 pdMS_TO_TICKS( 1000U ) );
+    vTaskDelay( pdMS_TO_TICKS( 1000U ) );
+    rc = xDNSResult;
+    FreeRTOS_printf( ( "Lookup '%s': %d\n", pcHostName, rc ) );
+    /*      FreeRTOS_gethostbyname( pcHostName ); */
+}
+
+void showAddressInfo( struct freertos_addrinfo * pxAddrInfo )
+{
+    if( pxAddrInfo == NULL )
+    {
+        FreeRTOS_printf( ( "No DNS results\n" ) );
+    }
+    else
+    {
+        struct freertos_addrinfo * pxIter = pxAddrInfo;
+
+        while( pxIter != NULL )
+        {
+            if( pxIter->ai_family == FREERTOS_AF_INET6 )
+            {
+                FreeRTOS_printf( ( "DNS result '%s': %pip\n", pxIter->ai_canonname, pxIter->ai_addr->sin_address.xIP_IPv6.ucBytes ) );
+            }
+            else
+            {
+                FreeRTOS_printf( ( "DNS result '%s': %xip\n", pxIter->ai_canonname, pxIter->ai_addr->sin_address.ulIP_IPv4 ) );
+            }
+
+            pxIter = pxIter->ai_next;
+        }
+    }
+}
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/printf-stdarg.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/printf-stdarg.c
new file mode 100644
index 000000000..82edb0d8b
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo/printf-stdarg.c
@@ -0,0 +1,1053 @@
+/*
+ *  Copyright 2001, 2002 Georges Menie (www.menie.org)
+ *  stdarg version contributed by Christian Ettinger
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Changes for the FreeRTOS ports:
+ *
+ *  - The dot in "%-8.8s"
+ *  - The specifiers 'l' (long) and 'L' (long long)
+ *  - The specifier 'u' for unsigned
+ *  - Dot notation for IP addresses:
+ *    sprintf("IP = %xip\n", 0xC0A80164);
+ *    will produce "IP = 192.168.1.100\n"
+ *    sprintf("IP = %pip\n", pxIPv6_Address);
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+
+#if ( USE_FREERTOS != 0 )
+    #include "FreeRTOS.h"
+#else
+    #include <stdint.h>
+    typedef int        BaseType_t;
+    typedef uint32_t   TickType_t;
+    #define pdTRUE     1
+    #define pdFALSE    0
+    #define pdMS_TO_TICKS( x )    ( x )
+#endif
+
+#define PAD_RIGHT    1
+#define PAD_ZERO     2
+
+int sprintf( char * apBuf,
+             const char * apFmt,
+             ... );
+
+/*
+ * Return 1 for readable, 2 for writable, 3 for both.
+ * Function must be provided by the application.
+ */
+extern BaseType_t xApplicationMemoryPermissions( uint32_t aAddress );
+extern void vOutputChar( const char cChar,
+                         const TickType_t xTicksToWait );
+
+#ifdef __GNUC__
+
+    __attribute__( ( weak ) ) BaseType_t xApplicationMemoryPermissions( uint32_t aAddress )
+    {
+        ( void ) aAddress;
+        /* Return 1 for readable, 2 for writable, 3 for both. */
+        return 0x03;
+    }
+
+
+    __attribute__( ( weak ) ) void vOutputChar( const char cChar,
+                                                const TickType_t xTicksToWait )
+    {
+        ( void ) cChar;
+        ( void ) xTicksToWait;
+        /* Do nothing. */
+    }
+
+#endif /* __GNUC__ */
+
+static const TickType_t xTicksToWait = pdMS_TO_TICKS( 20 );
+
+int tiny_printf( const char * format,
+                 ... );
+
+/* Defined here: write a large amount as GB, MB, KB or bytes */
+const char * mkSize( unsigned long long aSize,
+                     char * apBuf,
+                     int aLen );
+
+typedef union
+{
+    uint8_t ucBytes[ 4 ];
+    uint16_t ucShorts[ 2 ];
+    uint32_t ulWords[ 1 ];
+} _U32;
+
+struct xPrintFlags
+{
+    int base;
+    int width;
+    int printLimit;
+    unsigned
+        pad : 8,
+        letBase : 8,
+        isSigned : 1,
+        isNumber : 1,
+        long32 : 1,
+        long64 : 1;
+};
+
+struct SStringBuf
+{
+    char * str;
+    const char * orgStr;
+    const char * nulPos;
+    int curLen;
+    struct xPrintFlags flags;
+};
+
+#ifdef __GNUC__
+    const static _U32 u32 =
+    {
+        ucBytes : { 0, 1, 2, 3 }
+    };
+#else
+    const static _U32 u32 = { 0, 1, 2, 3 };
+#endif
+
+static void strbuf_init( struct SStringBuf * apStr,
+                         char * apBuf,
+                         const char * apMaxStr )
+{
+    apStr->str = apBuf;
+    apStr->orgStr = apBuf;
+    apStr->nulPos = apMaxStr - 1;
+    apStr->curLen = 0;
+
+    memset( &apStr->flags, '\0', sizeof apStr->flags );
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t strbuf_printchar( struct SStringBuf * apStr,
+                                    int c )
+{
+    if( apStr->str == NULL )
+    {
+        vOutputChar( ( char ) c, xTicksToWait );
+        apStr->curLen++;
+        return pdTRUE;
+    }
+
+    if( apStr->str < apStr->nulPos )
+    {
+        *( apStr->str++ ) = c;
+        apStr->curLen++;
+        return pdTRUE;
+    }
+
+    if( apStr->str == apStr->nulPos )
+    {
+        *( apStr->str++ ) = '\0';
+    }
+
+    return pdFALSE;
+}
+/*-----------------------------------------------------------*/
+
+static __inline BaseType_t strbuf_printchar_inline( struct SStringBuf * apStr,
+                                                    int c )
+{
+    if( apStr->str == NULL )
+    {
+        vOutputChar( ( char ) c, xTicksToWait );
+
+        if( c == 0 )
+        {
+            return pdFALSE;
+        }
+
+        apStr->curLen++;
+        return pdTRUE;
+    }
+
+    if( apStr->str < apStr->nulPos )
+    {
+        *( apStr->str++ ) = c;
+
+        if( c == 0 )
+        {
+            return pdFALSE;
+        }
+
+        apStr->curLen++;
+        return pdTRUE;
+    }
+
+    if( apStr->str == apStr->nulPos )
+    {
+        *( apStr->str++ ) = '\0';
+    }
+
+    return pdFALSE;
+}
+/*-----------------------------------------------------------*/
+
+static __inline int i2hex( int aCh )
+{
+    int iResult;
+
+    if( aCh < 10 )
+    {
+        iResult = '0' + aCh;
+    }
+    else
+    {
+        iResult = 'A' + aCh - 10;
+    }
+
+    return iResult;
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t prints( struct SStringBuf * apBuf,
+                          const char * apString )
+{
+    register int padchar = ' ';
+    int i, len;
+
+    if( xApplicationMemoryPermissions( ( uint32_t ) apString ) == 0 )
+    {
+        /* The user has probably made a mistake with the parameter
+         * for '%s', the memory is not readable. */
+        apString = "INV_MEM";
+    }
+
+    if( apBuf->flags.width > 0 )
+    {
+        register int count = 0;
+        register const char * ptr;
+
+        for( ptr = apString; *ptr; ++ptr )
+        {
+            ++count;
+        }
+
+        if( count >= apBuf->flags.width )
+        {
+            apBuf->flags.width = 0;
+        }
+        else
+        {
+            apBuf->flags.width -= count;
+        }
+
+        if( apBuf->flags.pad & PAD_ZERO )
+        {
+            padchar = '0';
+        }
+    }
+
+    if( ( apBuf->flags.pad & PAD_RIGHT ) == 0 )
+    {
+        for( ; apBuf->flags.width > 0; --apBuf->flags.width )
+        {
+            if( strbuf_printchar( apBuf, padchar ) == 0 )
+            {
+                return pdFALSE;
+            }
+        }
+    }
+
+    if( ( apBuf->flags.isNumber == pdTRUE ) && ( apBuf->flags.pad == pdTRUE ) )
+    {
+        /* The string to print represents an integer number.
+         * In this case, printLimit is the min number of digits to print
+         * If the length of the number to print is less than the min nb of i
+         * digits to display, we add 0 before printing the number
+         */
+        len = strlen( apString );
+
+        if( len < apBuf->flags.printLimit )
+        {
+            i = apBuf->flags.printLimit - len;
+
+            for( ; i; i-- )
+            {
+                if( strbuf_printchar( apBuf, '0' ) == 0 )
+                {
+                    return pdFALSE;
+                }
+            }
+        }
+    }
+
+    /* The string to print is not the result of a number conversion to ascii.
+     * For a string, printLimit is the max number of characters to display
+     */
+    for( ; apBuf->flags.printLimit && *apString; ++apString, --apBuf->flags.printLimit )
+    {
+        if( !strbuf_printchar( apBuf, *apString ) )
+        {
+            return pdFALSE;
+        }
+    }
+
+    for( ; apBuf->flags.width > 0; --apBuf->flags.width )
+    {
+        if( !strbuf_printchar( apBuf, padchar ) )
+        {
+            return pdFALSE;
+        }
+    }
+
+    return pdTRUE;
+}
+/*-----------------------------------------------------------*/
+
+/* the following should be enough for 32 bit int */
+#define PRINT_BUF_LEN    12 /* to print 4294967296 */
+
+#if SPRINTF_LONG_LONG
+    #warning 64-bit libraries will be included as well
+    static BaseType_t printll( struct SStringBuf * apBuf,
+                               long long i )
+    {
+        char print_buf[ 2 * PRINT_BUF_LEN ];
+        register char * s;
+        register int t, neg = 0;
+        register unsigned long long u = i;
+        lldiv_t lldiv_result;
+
+/* typedef struct
+ * {
+ *  long long int quot; // quotient
+ *  long long int rem;  // remainder
+ * } lldiv_t;
+ */
+
+        apBuf->flags.isNumber = pdTRUE; /* Parameter for prints */
+
+        if( i == 0LL )
+        {
+            print_buf[ 0 ] = '0';
+            print_buf[ 1 ] = '\0';
+            return prints( apBuf, print_buf );
+        }
+
+        if( ( apBuf->flags.isSigned == pdTRUE ) && ( apBuf->flags.base == 10 ) && ( i < 0LL ) )
+        {
+            neg = 1;
+            u = -i;
+        }
+
+        s = print_buf + sizeof print_buf - 1;
+
+        *s = '\0';
+
+        /* 18446744073709551616 */
+        while( u != 0 )
+        {
+            lldiv_result = lldiv( u, ( unsigned long long ) apBuf->flags.base );
+            t = lldiv_result.rem;
+
+            if( t >= 10 )
+            {
+                t += apBuf->flags.letBase - '0' - 10;
+            }
+
+            *( --s ) = t + '0';
+            u = lldiv_result.quot;
+        }
+
+        if( neg != 0 )
+        {
+            if( ( apBuf->flags.width != 0 ) && ( apBuf->flags.pad & PAD_ZERO ) )
+            {
+                if( !strbuf_printchar( apBuf, '-' ) )
+                {
+                    return pdFALSE;
+                }
+
+                --apBuf->flags.width;
+            }
+            else
+            {
+                *( --s ) = '-';
+            }
+        }
+
+        return prints( apBuf, s );
+    }
+#endif /* SPRINTF_LONG_LONG */
+/*-----------------------------------------------------------*/
+
+static BaseType_t printi( struct SStringBuf * apBuf,
+                          int i )
+{
+    char print_buf[ PRINT_BUF_LEN ];
+    register char * s;
+    register int t, neg = 0;
+    register unsigned int u = i;
+    register unsigned base = apBuf->flags.base;
+
+    apBuf->flags.isNumber = pdTRUE; /* Parameter for prints */
+
+    if( i == 0 )
+    {
+        print_buf[ 0 ] = '0';
+        print_buf[ 1 ] = '\0';
+        return prints( apBuf, print_buf );
+    }
+
+    if( ( apBuf->flags.isSigned == pdTRUE ) && ( base == 10 ) && ( i < 0 ) )
+    {
+        neg = 1;
+        u = -i;
+    }
+
+    s = print_buf + sizeof print_buf - 1;
+
+    *s = '\0';
+
+    switch( base )
+    {
+        case 16:
+
+            while( u != 0 )
+            {
+                t = u & 0xF;
+
+                if( t >= 10 )
+                {
+                    t += apBuf->flags.letBase - '0' - 10;
+                }
+
+                *( --s ) = t + '0';
+                u >>= 4;
+            }
+
+            break;
+
+        case 8:
+        case 10:
+
+            /* GCC compiles very efficient */
+            while( u )
+            {
+                t = u % base;
+                *( --s ) = t + '0';
+                u /= base;
+            }
+
+            break;
+
+/*
+ *  // The generic case, not yet in use
+ *  default:
+ *      while( u )
+ *      {
+ *          t = u % base;
+ *          if( t >= 10)
+ *          {
+ *              t += apBuf->flags.letBase - '0' - 10;
+ *          }
+ *( --s ) = t + '0';
+ *          u /= base;
+ *      }
+ *      break;
+ */
+    }
+
+    if( neg != 0 )
+    {
+        if( apBuf->flags.width && ( apBuf->flags.pad & PAD_ZERO ) )
+        {
+            if( strbuf_printchar( apBuf, '-' ) == 0 )
+            {
+                return pdFALSE;
+            }
+
+            --apBuf->flags.width;
+        }
+        else
+        {
+            *( --s ) = '-';
+        }
+    }
+
+    return prints( apBuf, s );
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t printIp( struct SStringBuf * apBuf,
+                           unsigned i )
+{
+    char print_buf[ 16 ];
+
+    sprintf( print_buf, "%u.%u.%u.%u",
+             i >> 24,
+             ( i >> 16 ) & 0xff,
+             ( i >> 8 ) & 0xff,
+             i & 0xff );
+    apBuf->flags.isNumber = pdTRUE; /* Parameter for prints */
+    prints( apBuf, print_buf );
+
+    return pdTRUE;
+}
+/*-----------------------------------------------------------*/
+
+static uint16_t usNetToHost( uint16_t usValue )
+{
+    if( u32.ulWords[ 0 ] == 0x00010203 )
+    {
+        return usValue;
+    }
+    else
+    {
+        return ( usValue << 8 ) | ( usValue >> 8 );
+    }
+}
+
+static BaseType_t printIPv6( struct SStringBuf * apBuf,
+                             uint16_t * pusAddress )
+{
+    int iIndex;
+    int iZeroStart = -1;
+    int iZeroLength = 0;
+    int iCurStart = 0;
+    int iCurLength = 0;
+
+    for( iIndex = 0; iIndex < 8; iIndex++ )
+    {
+        uint16_t usValue = pusAddress[ iIndex ];
+
+        if( usValue == 0 )
+        {
+            if( iCurLength == 0 )
+            {
+                iCurStart = iIndex;
+            }
+
+            iCurLength++;
+        }
+
+        if( ( usValue != 0 ) || ( iIndex == 7 ) )
+        {
+            if( iZeroLength < iCurLength )
+            {
+                iZeroLength = iCurLength;
+                iZeroStart = iCurStart;
+            }
+
+            iCurLength = 0;
+        }
+    }
+
+    apBuf->flags.base = 16;
+    apBuf->flags.letBase = 'a'; /* use lower-case letters 'a' to 'f' */
+
+    for( iIndex = 0; iIndex < 8; iIndex++ )
+    {
+        if( iIndex == iZeroStart )
+        {
+            iIndex += iZeroLength - 1;
+            strbuf_printchar( apBuf, ':' );
+
+            if( iIndex == 7 )
+            {
+                strbuf_printchar( apBuf, ':' );
+            }
+        }
+        else
+        {
+            if( iIndex > 0 )
+            {
+                strbuf_printchar( apBuf, ':' );
+            }
+
+            printi( apBuf, ( int ) ( ( uint32_t ) usNetToHost( pusAddress[ iIndex ] ) ) );
+        }
+    }
+
+    return pdTRUE;
+}
+/*-----------------------------------------------------------*/
+
+static void tiny_print( struct SStringBuf * apBuf,
+                        const char * format,
+                        va_list args )
+{
+    char scr[ 2 ];
+
+    for( ; ; )
+    {
+        int ch = *( format++ );
+
+        if( ch != '%' )
+        {
+            do
+            {
+                /* Put the most like flow in a small loop */
+                if( strbuf_printchar_inline( apBuf, ch ) == 0 )
+                {
+                    return;
+                }
+
+                ch = *( format++ );
+            } while( ch != '%' );
+        }
+
+        ch = *( format++ );
+        /* Now ch has character after '%', format pointing to next */
+
+        if( ch == '\0' )
+        {
+            break;
+        }
+
+        if( ch == '%' )
+        {
+            if( strbuf_printchar( apBuf, ch ) == 0 )
+            {
+                return;
+            }
+
+            continue;
+        }
+
+        memset( &apBuf->flags, '\0', sizeof apBuf->flags );
+
+        if( ch == '-' )
+        {
+            ch = *( format++ );
+            apBuf->flags.pad = PAD_RIGHT;
+        }
+
+        while( ch == '0' )
+        {
+            ch = *( format++ );
+            apBuf->flags.pad |= PAD_ZERO;
+        }
+
+        if( ch == '*' )
+        {
+            ch = *( format++ );
+            apBuf->flags.width = va_arg( args, int );
+        }
+        else
+        {
+            while( ch >= '0' && ch <= '9' )
+            {
+                apBuf->flags.width *= 10;
+                apBuf->flags.width += ch - '0';
+                ch = *( format++ );
+            }
+        }
+
+        if( ch == '.' )
+        {
+            ch = *( format++ );
+
+            if( ch == '*' )
+            {
+                apBuf->flags.printLimit = va_arg( args, int );
+                ch = *( format++ );
+            }
+            else
+            {
+                while( ch >= '0' && ch <= '9' )
+                {
+                    apBuf->flags.printLimit *= 10;
+                    apBuf->flags.printLimit += ch - '0';
+                    ch = *( format++ );
+                }
+            }
+        }
+
+        if( apBuf->flags.printLimit == 0 )
+        {
+            apBuf->flags.printLimit--; /* -1: make it unlimited */
+        }
+
+        if( ch == 'p' )
+        {
+            if( ( format[ 0 ] == 'i' ) && ( format[ 1 ] == 'p' ) )
+            {
+                format += 2; /* eat the "pi" of "pip" */
+
+                /* Print a IPv6 address */
+                if( printIPv6( apBuf, va_arg( args, uint16_t * ) ) == 0 )
+                {
+                    break;
+                }
+
+                continue;
+            }
+        }
+
+        if( ch == 's' )
+        {
+            register char * s = ( char * ) va_arg( args, int );
+
+            if( prints( apBuf, s ? s : "(null)" ) == 0 )
+            {
+                break;
+            }
+
+            continue;
+        }
+
+        if( ch == 'c' )
+        {
+            /* char are converted to int then pushed on the stack */
+            scr[ 0 ] = ( char ) va_arg( args, int );
+
+            if( strbuf_printchar( apBuf, scr[ 0 ] ) == 0 )
+            {
+                return;
+            }
+
+            continue;
+        }
+
+        if( ch == 'l' )
+        {
+            ch = *( format++ );
+            apBuf->flags.long32 = 1;
+            /* Makes not difference as u32 == long */
+        }
+
+        if( ch == 'L' )
+        {
+            ch = *( format++ );
+            apBuf->flags.long64 = 1;
+            /* Does make a difference */
+        }
+
+        apBuf->flags.base = 10;
+        apBuf->flags.letBase = 'a';
+
+        if( ( ch == 'd' ) || ( ch == 'u' ) )
+        {
+            apBuf->flags.isSigned = ( ch == 'd' );
+            #if SPRINTF_LONG_LONG
+                if( apBuf->flags.long64 != pdFALSE )
+                {
+                    if( printll( apBuf, va_arg( args, long long ) ) == 0 )
+                    {
+                        break;
+                    }
+                }
+                else
+            #endif /* SPRINTF_LONG_LONG */
+
+            if( printi( apBuf, va_arg( args, int ) ) == 0 )
+            {
+                break;
+            }
+
+            continue;
+        }
+
+        apBuf->flags.base = 16; /* From here all hexadecimal */
+
+        if( ( ch == 'x' ) && ( format[ 0 ] == 'i' ) && ( format[ 1 ] == 'p' ) )
+        {
+            format += 2; /* eat the "xi" of "xip" */
+
+            /* Will use base 10 again */
+            if( printIp( apBuf, va_arg( args, int ) ) == 0 )
+            {
+                break;
+            }
+
+            continue;
+        }
+
+        if( ( ch == 'x' ) || ( ch == 'X' ) || ( ch == 'p' ) || ( ch == 'o' ) )
+        {
+            if( ch == 'X' )
+            {
+                apBuf->flags.letBase = 'A';
+            }
+            else if( ch == 'o' )
+            {
+                apBuf->flags.base = 8;
+            }
+
+            #if SPRINTF_LONG_LONG
+                if( apBuf->flags.long64 != pdFALSE )
+                {
+                    if( printll( apBuf, va_arg( args, long long ) ) == 0 )
+                    {
+                        break;
+                    }
+                }
+                else
+            #endif /* SPRINTF_LONG_LONG */
+
+            if( printi( apBuf, va_arg( args, int ) ) == 0 )
+            {
+                break;
+            }
+
+            continue;
+        }
+    }
+
+    strbuf_printchar( apBuf, '\0' );
+}
+/*-----------------------------------------------------------*/
+
+int tiny_printf( const char * format,
+                 ... )
+{
+    va_list args;
+
+    va_start( args, format );
+    struct SStringBuf strBuf;
+    strbuf_init( &strBuf, NULL, ( const char * ) NULL );
+    tiny_print( &strBuf, format, args );
+    va_end( args );
+
+    return strBuf.curLen;
+}
+/*-----------------------------------------------------------*/
+
+int vsnprintf( char * apBuf,
+               size_t aMaxLen,
+               const char * apFmt,
+               va_list args )
+{
+    struct SStringBuf strBuf;
+
+    strbuf_init( &strBuf, apBuf, ( const char * ) apBuf + aMaxLen );
+    tiny_print( &strBuf, apFmt, args );
+
+    return strBuf.curLen;
+}
+/*-----------------------------------------------------------*/
+
+/*void timer_start( void ); */
+/*void timer_stop( void ); */
+
+int snprintf( char * apBuf,
+              size_t aMaxLen,
+              const char * apFmt,
+              ... )
+{
+    va_list args;
+
+/*timer_stop(); */
+    va_start( args, apFmt );
+    struct SStringBuf strBuf;
+    strbuf_init( &strBuf, apBuf, ( const char * ) apBuf + aMaxLen );
+    tiny_print( &strBuf, apFmt, args );
+    va_end( args );
+/*timer_start(); */
+
+    return strBuf.curLen;
+}
+/*-----------------------------------------------------------*/
+
+int sprintf( char * apBuf,
+             const char * apFmt,
+             ... )
+{
+    va_list args;
+
+    va_start( args, apFmt );
+    struct SStringBuf strBuf;
+    strbuf_init( &strBuf, apBuf, ( const char * ) apBuf + 1024 );
+    tiny_print( &strBuf, apFmt, args );
+    va_end( args );
+
+    return strBuf.curLen;
+}
+/*-----------------------------------------------------------*/
+
+int vsprintf( char * apBuf,
+              const char * apFmt,
+              va_list args )
+{
+    struct SStringBuf strBuf;
+
+    strbuf_init( &strBuf, apBuf, ( const char * ) apBuf + 1024 );
+    tiny_print( &strBuf, apFmt, args );
+
+    return strBuf.curLen;
+}
+/*-----------------------------------------------------------*/
+
+const char * mkSize( unsigned long long aSize,
+                     char * apBuf,
+                     int aLen )
+{
+    static char retString[ 33 ];
+    size_t gb, mb, kb, sb;
+
+    if( apBuf == NULL )
+    {
+        apBuf = retString;
+        aLen = sizeof retString;
+    }
+
+    gb = aSize / ( 1024 * 1024 * 1024 );
+    aSize -= gb * ( 1024 * 1024 * 1024 );
+    mb = aSize / ( 1024 * 1024 );
+    aSize -= mb * ( 1024 * 1024 );
+    kb = aSize / ( 1024 );
+    aSize -= kb * ( 1024 );
+    sb = aSize;
+
+    if( gb )
+    {
+        snprintf( apBuf, aLen, "%u.%02u GB", ( unsigned ) gb, ( unsigned ) ( ( 100 * mb ) / 1024ul ) );
+    }
+    else if( mb )
+    {
+        snprintf( apBuf, aLen, "%u.%02u MB", ( unsigned ) mb, ( unsigned ) ( ( 100 * kb ) / 1024ul ) );
+    }
+    else if( kb != 0ul )
+    {
+        snprintf( apBuf, aLen, "%u.%02u KB", ( unsigned ) kb, ( unsigned ) ( ( 100 * sb ) / 1024ul ) );
+    }
+    else
+    {
+        snprintf( apBuf, aLen, "%u bytes", ( unsigned ) sb );
+    }
+
+    return apBuf;
+}
+
+#ifdef _MSC_VER
+
+    #if defined( _NO_CRT_STDIO_INLINE )
+
+        int printf( char const * const _Format,
+                    ... )
+        {
+            int _Result;
+            va_list _ArgList;
+
+            __crt_va_start( _ArgList, _Format );
+            _Result = _vfprintf_l( stdout, _Format, NULL, _ArgList );
+            __crt_va_end( _ArgList );
+            return _Result;
+        }
+
+    #endif /* if defined( _NO_CRT_STDIO_INLINE ) */
+
+    #if defined( _NO_CRT_STDIO_INLINE )
+
+        int sscanf( char const * const _Buffer,
+                    char const * const _Format,
+                    ... )
+        {
+            int _Result;
+            va_list _ArgList;
+
+            __crt_va_start( _ArgList, _Format );
+            _Result = _vsscanf_l( _Buffer, _Format, NULL, _ArgList );
+            __crt_va_end( _ArgList );
+            return _Result;
+        }
+
+    #endif /* if defined( _NO_CRT_STDIO_INLINE ) */
+
+    #if defined( _NO_CRT_STDIO_INLINE )
+
+        int _vfprintf_l( FILE * const _Stream,
+                         char const * const _Format,
+                         _locale_t const _Locale,
+                         va_list _ArgList )
+        {
+            return __stdio_common_vfprintf( _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, _Stream, _Format, _Locale, _ArgList );
+        }
+
+    #endif
+
+    #if defined( _NO_CRT_STDIO_INLINE )
+
+        int _vsscanf_l( char const * const _Buffer,
+                        char const * const _Format,
+                        _locale_t const _Locale,
+                        va_list _ArgList )
+        {
+            return __stdio_common_vsscanf(
+                _CRT_INTERNAL_LOCAL_SCANF_OPTIONS,
+                _Buffer, ( size_t ) -1, _Format, _Locale, _ArgList );
+        }
+
+    #endif /* if defined( _NO_CRT_STDIO_INLINE ) */
+
+    #if defined( _NO_CRT_STDIO_INLINE )
+        int scanf( char const * const _Format,
+                   ... )
+        {
+            int _Result;
+            va_list _ArgList;
+
+            __crt_va_start( _ArgList, _Format );
+            _Result = _vfscanf_l( stdin, _Format, NULL, _ArgList );
+            __crt_va_end( _ArgList );
+            return _Result;
+        }
+    #endif /* if defined( _NO_CRT_STDIO_INLINE ) */
+
+    #if defined( _NO_CRT_STDIO_INLINE )
+        int _vfscanf_l( _Inout_ FILE * const _Stream,
+                        char const * const _Format,
+                        const _Locale,
+                        va_list _ArgList )
+        {
+            return __stdio_common_vfscanf(
+                _CRT_INTERNAL_LOCAL_SCANF_OPTIONS,
+                _Stream, _Format, _Locale, _ArgList );
+        }
+
+    #endif /* if defined( _NO_CRT_STDIO_INLINE ) */
+
+
+    #if defined( _NO_CRT_STDIO_INLINE )
+        int vsnprintf_s( char * const _Buffer,
+                         size_t const _BufferCount,
+                         size_t const _MaxCount,
+                         char const * const _Format,
+                         va_list _ArgList )
+        {
+            return _vsnprintf_s_l( _Buffer, _BufferCount, _MaxCount, _Format, NULL, _ArgList );
+        }
+        int _vsnprintf_s( char * const _Buffer,
+                          size_t const _BufferCount,
+                          size_t const _MaxCount,
+                          char const * const _Format,
+                          va_list _ArgList )
+        {
+            return _vsnprintf_s_l( _Buffer, _BufferCount, _MaxCount, _Format, NULL, _ArgList );
+        }
+
+    #endif /* if defined( _NO_CRT_STDIO_INLINE ) */
+
+    #if defined( _NO_CRT_STDIO_INLINE )
+        int _vsnprintf_s_l( char * const _Buffer,
+                            size_t const _BufferCount,
+                            size_t const _MaxCount,
+                            char const * const _Format,
+                            _locale_t const _Locale,
+                            va_list _ArgList )
+        {
+            int const _Result = __stdio_common_vsnprintf_s(
+                _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS,
+                _Buffer, _BufferCount, _MaxCount, _Format, _Locale, _ArgList );
+
+            return _Result < 0 ? -1 : _Result;
+        }
+    #endif /* if defined( _NO_CRT_STDIO_INLINE ) */
+
+#endif /* __WIN32__ */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/ReadMe_Logging.url b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/ReadMe_Logging.url
new file mode 100644
index 000000000..9ce8a7b18
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/ReadMe_Logging.url
@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,11
+[InternetShortcut]
+IDList=
+URL=https://www.freertos.org/logging.html
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/logging.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/logging.h
new file mode 100644
index 000000000..ef9b42b63
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/logging.h
@@ -0,0 +1,46 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef DEMO_LOGGING_H
+#define DEMO_LOGGING_H
+
+/*
+ * Initialize a logging system that can be used from FreeRTOS tasks and Win32
+ * threads.  Do not call printf() directly while the scheduler is running.
+ *
+ * Set xLogToStdout, xLogToFile and xLogToUDP to either pdTRUE or pdFALSE to
+ * lot to stdout, a disk file and a UDP port respectively.
+ *
+ * If xLogToUDP is pdTRUE then ulRemoteIPAddress and usRemotePort must be set
+ * to the IP address and port number to which UDP log messages will be sent.
+ */
+void vLoggingInit( BaseType_t xLogToStdout,
+                   BaseType_t xLogToFile,
+                   BaseType_t xLogToUDP,
+                   uint32_t ulRemoteIPAddress,
+                   uint16_t usRemotePort );
+
+#endif /* DEMO_LOGGING_H */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/logging_levels.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/logging_levels.h
new file mode 100644
index 000000000..56cdaf6f4
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/logging_levels.h
@@ -0,0 +1,113 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/**
+ * @file logging_levels.h
+ * @brief Defines the configuration constants for all logging verbosity levels.
+ */
+
+#ifndef LOGGING_LEVELS_H
+#define LOGGING_LEVELS_H
+
+/**
+ * @constantspage{logging,logging library}
+ *
+ * @section logging_constants_levels Log levels
+ * @brief Log levels for the libraries in this SDK.
+ *
+ * Each library should specify a log level by setting @ref LIBRARY_LOG_LEVEL.
+ * All log messages with a level at or below the specified level will be printed
+ * for that library.
+ *
+ * Currently, there are 4 log levels. In the order of lowest to highest, they are:
+ * - #LOG_NONE <br>
+ *   @copybrief LOG_NONE
+ * - #LOG_ERROR <br>
+ *   @copybrief LOG_ERROR
+ * - #LOG_WARN <br>
+ *   @copybrief LOG_WARN
+ * - #LOG_INFO <br>
+ *   @copybrief LOG_INFO
+ * - #LOG_DEBUG <br>
+ *   @copybrief LOG_DEBUG
+ */
+
+/**
+ * @brief No log messages.
+ *
+ * When @ref LIBRARY_LOG_LEVEL is #LOG_NONE, logging is disabled and no
+ * logging messages are printed.
+ */
+#define LOG_NONE     0
+
+/**
+ * @brief Represents erroneous application state or event.
+ *
+ * These messages describe the situations when a library encounters an error from
+ * which it cannot recover.
+ *
+ * These messages are printed when @ref LIBRARY_LOG_LEVEL is defined as either
+ * of #LOG_ERROR, #LOG_WARN, #LOG_INFO or #LOG_DEBUG.
+ */
+#define LOG_ERROR    1
+
+/**
+ * @brief Message about an abnormal event.
+ *
+ * These messages describe the situations when a library encounters
+ * abnormal event that may be indicative of an error. Libraries continue
+ * execution after logging a warning.
+ *
+ * These messages are printed when @ref LIBRARY_LOG_LEVEL is defined as either
+ * of #LOG_WARN, #LOG_INFO or #LOG_DEBUG.
+ */
+#define LOG_WARN     2
+
+/**
+ * @brief A helpful, informational message.
+ *
+ * These messages describe normal execution of a library. They provide
+ * the progress of the program at a coarse-grained level.
+ *
+ * These messages are printed when @ref LIBRARY_LOG_LEVEL is defined as either
+ * of #LOG_INFO or #LOG_DEBUG.
+ */
+#define LOG_INFO     3
+
+/**
+ * @brief Detailed and excessive debug information.
+ *
+ * Debug log messages are used to provide the
+ * progress of the program at a fine-grained level. These are mostly used
+ * for debugging and may contain excessive information such as internal
+ * variables, buffers, or other specific information.
+ *
+ * These messages are only printed when @ref LIBRARY_LOG_LEVEL is defined as
+ * #LOG_DEBUG.
+ */
+#define LOG_DEBUG    4
+
+#endif /* ifndef LOGGING_LEVELS_H */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/logging_stack.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/logging_stack.h
new file mode 100644
index 000000000..1150482fd
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/include/logging_stack.h
@@ -0,0 +1,129 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/**
+ * @file logging_stack.h
+ * @brief Utility header file that exposes macros for configuring logging implementation of logging macros (LogError, LogWarn, LogInfo, LogDebug).
+ */
+
+#ifndef LOGGING_STACK_H
+#define LOGGING_STACK_H
+
+/* Include header for logging level macros. */
+#include "logging_levels.h"
+
+/* Standard Include. */
+#include <stdio.h>
+#include <stdint.h>
+
+/**
+ * @brief The name of the library or demo to add as metadata in log messages
+ * from the library or demo.
+ *
+ * This metadata aids in identifying the module source of log messages.
+ * The metadata is logged in the format `[ <LIBRARY-NAME> ]` as a prefix to the
+ * log messages.
+ * Refer to #LOG_METADATA_FORMAT for the complete format of the metadata prefix in
+ * log messages.
+ */
+/* Check if LIBRARY_LOG_NAME macro has been defined. */
+#if !defined( LIBRARY_LOG_NAME )
+    #error "Please define LIBRARY_LOG_NAME for the library."
+#endif
+
+/* Metadata information to prepend to every log message. */
+#ifndef LOG_METADATA_FORMAT
+    #define LOG_METADATA_FORMAT    "[%s:%d] "                  /**< @brief Format of metadata prefix in log messages. */
+#endif
+
+#ifndef LOG_METADATA_ARGS
+    #define LOG_METADATA_ARGS    __FUNCTION__, __LINE__  /**< @brief Arguments into the metadata logging prefix format. */
+#endif
+
+/**
+ * @brief Common macro that maps all the logging interfaces,
+ * (#LogDebug, #LogInfo, #LogWarn, #LogError) to the platform-specific logging
+ * function.
+ *
+ * @note The default definition of the macro is an empty definition that does not
+ * generate any logging.
+ */
+#ifndef SdkLog
+    #define SdkLog( string )
+#endif
+
+/**
+ * Disable definition of logging interface macros when generating doxygen output,
+ * to avoid conflict with documentation of macros at the end of the file.
+ */
+/* Check that LIBRARY_LOG_LEVEL is defined and has a valid value. */
+#if !defined( LIBRARY_LOG_LEVEL ) ||       \
+    ( ( LIBRARY_LOG_LEVEL != LOG_NONE ) && \
+    ( LIBRARY_LOG_LEVEL != LOG_ERROR ) &&  \
+    ( LIBRARY_LOG_LEVEL != LOG_WARN ) &&   \
+    ( LIBRARY_LOG_LEVEL != LOG_INFO ) &&   \
+    ( LIBRARY_LOG_LEVEL != LOG_DEBUG ) )
+    #error "Please define LIBRARY_LOG_LEVEL as either LOG_NONE, LOG_ERROR, LOG_WARN, LOG_INFO, or LOG_DEBUG."
+#else
+    #if LIBRARY_LOG_LEVEL == LOG_DEBUG
+        /* All log level messages will logged. */
+        #define LogError( message )    SdkLog( ( "[ERROR] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+        #define LogWarn( message )     SdkLog( ( "[WARN] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+        #define LogInfo( message )     SdkLog( ( "[INFO] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+        #define LogDebug( message )    SdkLog( ( "[DEBUG] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+
+    #elif LIBRARY_LOG_LEVEL == LOG_INFO
+        /* Only INFO, WARNING and ERROR messages will be logged. */
+        #define LogError( message )    SdkLog( ( "[ERROR] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+        #define LogWarn( message )     SdkLog( ( "[WARN] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+        #define LogInfo( message )     SdkLog( ( "[INFO] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+        #define LogDebug( message )
+
+    #elif LIBRARY_LOG_LEVEL == LOG_WARN
+        /* Only WARNING and ERROR messages will be logged.*/
+        #define LogError( message )    SdkLog( ( "[ERROR] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+        #define LogWarn( message )     SdkLog( ( "[WARN] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+        #define LogInfo( message )
+        #define LogDebug( message )
+
+    #elif LIBRARY_LOG_LEVEL == LOG_ERROR
+        /* Only ERROR messages will be logged. */
+        #define LogError( message )    SdkLog( ( "[ERROR] [%s] "LOG_METADATA_FORMAT, LIBRARY_LOG_NAME, LOG_METADATA_ARGS ) ); SdkLog( message ); SdkLog( ( "\r\n" ) )
+        #define LogWarn( message )
+        #define LogInfo( message )
+        #define LogDebug( message )
+
+    #else /* if LIBRARY_LOG_LEVEL == LOG_ERROR */
+
+        #define LogError( message )
+        #define LogWarn( message )
+        #define LogInfo( message )
+        #define LogDebug( message )
+
+    #endif /* if LIBRARY_LOG_LEVEL == LOG_ERROR */
+#endif /* if !defined( LIBRARY_LOG_LEVEL ) || ( ( LIBRARY_LOG_LEVEL != LOG_NONE ) && ( LIBRARY_LOG_LEVEL != LOG_ERROR ) && ( LIBRARY_LOG_LEVEL != LOG_WARN ) && ( LIBRARY_LOG_LEVEL != LOG_INFO ) && ( LIBRARY_LOG_LEVEL != LOG_DEBUG ) ) */
+
+#endif /* ifndef LOGGING_STACK_H */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/windows/Logging_WinSim.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/windows/Logging_WinSim.c
new file mode 100644
index 000000000..120c99dd0
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/Logging/windows/Logging_WinSim.c
@@ -0,0 +1,552 @@
+/*

+ * FreeRTOS V202212.00

+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * https://www.FreeRTOS.org

+ * https://github.com/FreeRTOS

+ *

+ */

+

+/*

+ * Logging utility that allows FreeRTOS tasks to log to a UDP port, stdout, and

+ * disk file without making any Win32 system calls themselves.

+ *

+ * Messages logged to a UDP port are sent directly (using FreeRTOS+TCP), but as

+ * FreeRTOS tasks cannot make Win32 system calls messages sent to stdout or a

+ * disk file are sent via a stream buffer to a Win32 thread which then performs

+ * the actual output.

+ */

+

+/* Standard includes. */

+#include <stdio.h>

+#include <stdint.h>

+#include <stdarg.h>

+#include <io.h>

+#include <ctype.h>

+

+/* FreeRTOS includes. */

+#include <FreeRTOS.h>

+#include "task.h"

+

+/* FreeRTOS+TCP includes. */

+#include "FreeRTOS_IP.h"

+#include "FreeRTOS_Sockets.h"

+#include "FreeRTOS_Stream_Buffer.h"

+

+/* Demo includes. */

+#include "logging.h"

+

+/*-----------------------------------------------------------*/

+

+/* The maximum size to which the log file may grow, before being renamed

+ * to .ful. */

+#define dlLOGGING_FILE_SIZE             ( 40ul * 1024ul * 1024ul )

+

+/* Dimensions the arrays into which print messages are created. */

+#define dlMAX_PRINT_STRING_LENGTH       255

+

+/* The size of the stream buffer used to pass messages from FreeRTOS tasks to

+ * the Win32 thread that is responsible for making any Win32 system calls that are

+ * necessary for the selected logging method. */

+#define dlLOGGING_STREAM_BUFFER_SIZE    32768

+

+/* A block time of zero simply means don't block. */

+#define dlDONT_BLOCK                    0

+

+/*-----------------------------------------------------------*/

+

+/*

+ * Called from vLoggingInit() to start a new disk log file.

+ */

+static void prvFileLoggingInit( void );

+

+/*

+ * Attempt to write a message to the file.

+ */

+static void prvLogToFile( const char * pcMessage,

+                          size_t xLength );

+

+/*

+ * Simply close the logging file, if it is open.

+ */

+static void prvFileClose( void );

+

+/*

+ * Before the scheduler is started this function is called directly.  After the

+ * scheduler has started it is called from the Windows thread dedicated to

+ * outputting log messages.  Only the windows thread actually performs the

+ * writing so as not to disrupt the simulation by making Windows system calls

+ * from FreeRTOS tasks.

+ */

+static void prvLoggingFlushBuffer( void );

+

+/*

+ * The windows thread that performs the actual writing of messages that require

+ * Win32 system calls.  Only the windows thread can make system calls so as not

+ * to disrupt the simulation by making Windows calls from FreeRTOS tasks.

+ */

+static DWORD WINAPI prvWin32LoggingThread( void * pvParam );

+

+/*

+ * Creates the socket to which UDP messages are sent.  This function is not

+ * called directly to prevent the print socket being created from within the IP

+ * task - which could result in a deadlock.  Instead the function call is

+ * deferred to run in the RTOS daemon task - hence it prototype.

+ */

+static void prvCreatePrintSocket( void * pvParameter1,

+                                  uint32_t ulParameter2 );

+

+/*-----------------------------------------------------------*/

+

+/* Windows event used to wake the Win32 thread which performs any logging that

+ * needs Win32 system calls. */

+static void * pvLoggingThreadEvent = NULL;

+

+/* Stores the selected logging targets passed in as parameters to the

+ * vLoggingInit() function. */

+BaseType_t xStdoutLoggingUsed = pdFALSE, xDiskFileLoggingUsed = pdFALSE, xUDPLoggingUsed = pdFALSE;

+

+/* Circular buffer used to pass messages from the FreeRTOS tasks to the Win32

+ * thread that is responsible for making Win32 calls (when stdout or a disk log is

+ * used). */

+static StreamBuffer_t * xLogStreamBuffer = NULL;

+

+/* Handle to the file used for logging.  This is left open while there are

+ * messages waiting to be logged, then closed again in between logs. */

+static FILE * pxLoggingFileHandle = NULL;

+

+/* When true prints are performed directly.  After start up xDirectPrint is set

+ * to pdFALSE - at which time prints that require Win32 system calls are done by

+ * the Win32 thread responsible for logging. */

+BaseType_t xDirectPrint = pdTRUE;

+

+/* File names for the in use and complete (full) log files. */

+static const char * pcLogFileName = "RTOSDemo.log";

+static const char * pcFullLogFileName = "RTOSDemo.ful";

+

+/* As an optimization, the current file size is kept in a variable. */

+static size_t ulSizeOfLoggingFile = 0ul;

+

+/* The UDP socket and address on/to which print messages are sent. */

+Socket_t xPrintSocket = FREERTOS_INVALID_SOCKET;

+struct freertos_sockaddr xPrintUDPAddress;

+

+/*-----------------------------------------------------------*/

+

+void vLoggingInit( BaseType_t xLogToStdout,

+                   BaseType_t xLogToFile,

+                   BaseType_t xLogToUDP,

+                   uint32_t ulRemoteIPAddress,

+                   uint16_t usRemotePort )

+{

+    /* Can only be called before the scheduler has started. */

+    configASSERT( xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED );

+

+    #if ( ( ipconfigHAS_DEBUG_PRINTF == 1 ) || ( ipconfigHAS_PRINTF == 1 ) )

+        {

+            HANDLE Win32Thread;

+

+            /* Record which output methods are to be used. */

+            xStdoutLoggingUsed = xLogToStdout;

+            xDiskFileLoggingUsed = xLogToFile;

+            xUDPLoggingUsed = xLogToUDP;

+

+            /* If a disk file is used then initialize it now. */

+            if( xDiskFileLoggingUsed != pdFALSE )

+            {

+                prvFileLoggingInit();

+            }

+

+            /* If UDP logging is used then store the address to which the log data

+             * will be sent - but don't create the socket yet because the network is

+             * not initialized. */

+            if( xUDPLoggingUsed != pdFALSE )

+            {

+                /* Set the address to which the print messages are sent. */

+                xPrintUDPAddress.sin_port = FreeRTOS_htons( usRemotePort );

+                xPrintUDPAddress.sin_addr = ulRemoteIPAddress;

+            }

+

+            /* If a disk file or stdout are to be used then Win32 system calls will

+             * have to be made.  Such system calls cannot be made from FreeRTOS tasks

+             * so create a stream buffer to pass the messages to a Win32 thread, then

+             * create the thread itself, along with a Win32 event that can be used to

+             * unblock the thread. */

+            if( ( xStdoutLoggingUsed != pdFALSE ) || ( xDiskFileLoggingUsed != pdFALSE ) )

+            {

+                /* Create the buffer. */

+                xLogStreamBuffer = ( StreamBuffer_t * ) malloc( sizeof( *xLogStreamBuffer ) - sizeof( xLogStreamBuffer->ucArray ) + dlLOGGING_STREAM_BUFFER_SIZE + 1 );

+                configASSERT( xLogStreamBuffer );

+                memset( xLogStreamBuffer, '\0', sizeof( *xLogStreamBuffer ) - sizeof( xLogStreamBuffer->ucArray ) );

+                xLogStreamBuffer->LENGTH = dlLOGGING_STREAM_BUFFER_SIZE + 1;

+

+                /* Create the Windows event. */

+                pvLoggingThreadEvent = CreateEvent( NULL, FALSE, TRUE, "StdoutLoggingEvent" );

+

+                /* Create the thread itself. */

+                Win32Thread = CreateThread(

+                    NULL,                  /* Pointer to thread security attributes. */

+                    0,                     /* Initial thread stack size, in bytes. */

+                    prvWin32LoggingThread, /* Pointer to thread function. */

+                    NULL,                  /* Argument for new thread. */

+                    0,                     /* Creation flags. */

+                    NULL );

+

+                /* Use the cores that are not used by the FreeRTOS tasks. */

+                SetThreadAffinityMask( Win32Thread, ~0x01u );

+                SetThreadPriorityBoost( Win32Thread, TRUE );

+                SetThreadPriority( Win32Thread, THREAD_PRIORITY_IDLE );

+            }

+        }

+    #else /* if ( ( ipconfigHAS_DEBUG_PRINTF == 1 ) || ( ipconfigHAS_PRINTF == 1 ) ) */

+        {

+            /* FreeRTOSIPConfig is set such that no print messages will be output.

+             * Avoid compiler warnings about unused parameters. */

+            ( void ) xLogToStdout;

+            ( void ) xLogToFile;

+            ( void ) xLogToUDP;

+            ( void ) usRemotePort;

+            ( void ) ulRemoteIPAddress;

+        }

+    #endif /* ( ipconfigHAS_DEBUG_PRINTF == 1 ) || ( ipconfigHAS_PRINTF == 1 )  */

+}

+/*-----------------------------------------------------------*/

+

+static void prvCreatePrintSocket( void * pvParameter1,

+                                  uint32_t ulParameter2 )

+{

+    static const TickType_t xSendTimeOut = pdMS_TO_TICKS( 0 );

+    Socket_t xSocket;

+

+    /* The function prototype is that of a deferred function, but the parameters

+     * are not actually used. */

+    ( void ) pvParameter1;

+    ( void ) ulParameter2;

+

+    xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );

+

+    if( xSocket != FREERTOS_INVALID_SOCKET )

+    {

+        /* FreeRTOS+TCP decides which port to bind to. */

+        FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, &xSendTimeOut, sizeof( xSendTimeOut ) );

+        FreeRTOS_bind( xSocket, NULL, 0 );

+

+        /* Now the socket is bound it can be assigned to the print socket. */

+        xPrintSocket = xSocket;

+    }

+}

+/*-----------------------------------------------------------*/

+

+static TickType_t ulTicksToMS( TickType_t uxTicks )

+{

+    uint64_t ullCount = uxTicks;

+    ullCount = ullCount * (1000U / configTICK_RATE_HZ);

+    return ( uint32_t )ullCount;

+}

+

+void vLoggingPrintf( const char * pcFormat,

+                     ... )

+{

+    char cPrintString[ dlMAX_PRINT_STRING_LENGTH ];

+    char cOutputString[ dlMAX_PRINT_STRING_LENGTH ];

+    char * pcSource, * pcTarget, * pcBegin;

+    size_t xLength, xLength2, rc;

+    static BaseType_t xMessageNumber = 0;

+    static BaseType_t xAfterLineBreak = pdTRUE;

+    va_list args;

+    unsigned ulIPAddress;

+    const char * pcTaskName;

+    const char * pcNoTask = "None";

+    int iOriginalPriority;

+    HANDLE xCurrentTask;

+

+

+    if( ( xStdoutLoggingUsed != pdFALSE ) || ( xDiskFileLoggingUsed != pdFALSE ) || ( xUDPLoggingUsed != pdFALSE ) )

+    {

+        /* There are a variable number of parameters. */

+        va_start( args, pcFormat );

+

+        /* Additional info to place at the start of the log. */

+        if( xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED )

+        {

+            pcTaskName = pcTaskGetName( NULL );

+        }

+        else

+        {

+            pcTaskName = pcNoTask;

+        }

+

+        if( ( xAfterLineBreak == pdTRUE ) && ( strcmp( pcFormat, "\r\n" ) != 0 ) )

+        {

+            TickType_t uxTickCount = ulTicksToMS( xTaskGetTickCount() );

+            TickType_t ulSeconds = uxTickCount / 1000U;

+            TickType_t ulMsecs = uxTickCount % 1000U;

+            xLength = snprintf( cPrintString, dlMAX_PRINT_STRING_LENGTH, "%u %u.%03u [%-*s] ",

+                                ( unsigned ) xMessageNumber++,

+                                ( unsigned ) ulSeconds,

+                                ( unsigned ) ulMsecs,

+                                configMAX_TASK_NAME_LEN,

+                                pcTaskName );

+            /* xAfterLineBreak = pdFALSE; */

+        }

+        else

+        {

+            xLength = 0;

+            memset( cPrintString, 0x00, dlMAX_PRINT_STRING_LENGTH );

+            xAfterLineBreak = pdTRUE;

+        }

+

+        xLength2 = vsnprintf( cPrintString + xLength, dlMAX_PRINT_STRING_LENGTH - xLength, pcFormat, args );

+

+        if( xLength2 < 0 )

+        {

+            /* Clean up. */

+            xLength2 = dlMAX_PRINT_STRING_LENGTH - 1 - xLength;

+            cPrintString[ dlMAX_PRINT_STRING_LENGTH - 1 ] = '\0';

+        }

+

+        xLength += xLength2;

+        va_end( args );

+

+        /* For ease of viewing, copy the string into another buffer, converting

+         * IP addresses to dot notation on the way. */

+        pcSource = cPrintString;

+        pcTarget = cOutputString;

+

+        while( ( *pcSource ) != '\0' )

+        {

+            *pcTarget = *pcSource;

+            pcTarget++;

+            pcSource++;

+

+            /* Look forward for an IP address denoted by 'ip'. */

+            if( ( isxdigit( pcSource[ 0 ] ) != pdFALSE ) && ( pcSource[ 1 ] == 'i' ) && ( pcSource[ 2 ] == 'p' ) )

+            {

+                *pcTarget = *pcSource;

+                pcTarget++;

+                *pcTarget = '\0';

+                pcBegin = pcTarget - 8;

+

+                while( ( pcTarget > pcBegin ) && ( isxdigit( pcTarget[ -1 ] ) != pdFALSE ) )

+                {

+                    pcTarget--;

+                }

+

+                ( void ) sscanf( pcTarget, "%8X", &ulIPAddress );

+                rc = sprintf( pcTarget, "%lu.%lu.%lu.%lu",

+                              ( unsigned long ) ( ulIPAddress >> 24UL ),

+                              ( unsigned long ) ( ( ulIPAddress >> 16UL ) & 0xffUL ),

+                              ( unsigned long ) ( ( ulIPAddress >> 8UL ) & 0xffUL ),

+                              ( unsigned long ) ( ulIPAddress & 0xffUL ) );

+                pcTarget += rc;

+                pcSource += 3; /* skip "<n>ip" */

+            }

+        }

+

+        /* How far through the buffer was written? */

+        xLength = ( BaseType_t ) ( pcTarget - cOutputString );

+

+        /* If the message is to be logged to a UDP port then it can be sent directly

+         * because it only uses FreeRTOS function (not Win32 functions). */

+        if( xUDPLoggingUsed != pdFALSE )

+        {

+            #if 0  /* _HT_ Logging doesn't need UDP logging for WinSim. */

+            if( ( xPrintSocket == FREERTOS_INVALID_SOCKET ) && ( FreeRTOS_IsNetworkUp() != pdFALSE ) )

+            {

+                /* Create and bind the socket to which print messages are sent.  The

+                 * xTimerPendFunctionCall() function is used even though this is

+                 * not an interrupt because this function is called from the IP task

+                 * and the	IP task cannot itself wait for a socket to bind.  The

+                 * parameters to prvCreatePrintSocket() are not required so set to

+                 * NULL or 0. */

+                xTimerPendFunctionCall( prvCreatePrintSocket, NULL, 0, dlDONT_BLOCK );

+            }

+

+            if( xPrintSocket != FREERTOS_INVALID_SOCKET )

+            {

+                FreeRTOS_sendto( xPrintSocket, cOutputString, xLength, 0, &xPrintUDPAddress, sizeof( xPrintUDPAddress ) );

+

+                /* Just because the UDP data logger I'm using is dumb. */

+                FreeRTOS_sendto( xPrintSocket, "\r", sizeof( char ), 0, &xPrintUDPAddress, sizeof( xPrintUDPAddress ) );

+            }

+            #endif /* 0 */

+        }

+

+        /* If logging is also to go to either stdout or a disk file then it cannot

+         * be output here - so instead write the message to the stream buffer and wake

+         * the Win32 thread which will read it from the stream buffer and perform the

+         * actual output. */

+        if( ( xStdoutLoggingUsed != pdFALSE ) || ( xDiskFileLoggingUsed != pdFALSE ) )

+        {

+            configASSERT( xLogStreamBuffer );

+

+            /* How much space is in the buffer? */

+            xLength2 = uxStreamBufferGetSpace( xLogStreamBuffer );

+

+            /* There must be enough space to write both the string and the length of

+             * the string. */

+            if( xLength2 >= ( xLength + sizeof( xLength ) ) )

+            {

+                /* First write in the length of the data, then write in the data

+                 * itself.  Raising the thread priority is used as a critical section

+                 * as there are potentially multiple writers.  The stream buffer is

+                 * only thread safe when there is a single writer (likewise for

+                 * reading from the buffer). */

+                xCurrentTask = GetCurrentThread();

+                iOriginalPriority = GetThreadPriority( xCurrentTask );

+                SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL );

+                uxStreamBufferAdd( xLogStreamBuffer, 0, ( const uint8_t * ) &( xLength ), sizeof( xLength ) );

+                uxStreamBufferAdd( xLogStreamBuffer, 0, ( const uint8_t * ) cOutputString, xLength );

+                SetThreadPriority( GetCurrentThread(), iOriginalPriority );

+            }

+

+            /* xDirectPrint is initialized to pdTRUE, and while it remains true the

+             * logging output function is called directly.  When the system is running

+             * the output function cannot be called directly because it would get

+             * called from both FreeRTOS tasks and Win32 threads - so instead wake the

+             * Win32 thread responsible for the actual output. */

+            if( xDirectPrint != pdFALSE )

+            {

+                /* While starting up, the thread which calls prvWin32LoggingThread()

+                 * is not running yet and xDirectPrint will be pdTRUE. */

+                prvLoggingFlushBuffer();

+            }

+            else if( pvLoggingThreadEvent != NULL )

+            {

+                /* While running, wake up prvWin32LoggingThread() to send the

+                 * logging data. */

+                SetEvent( pvLoggingThreadEvent );

+            }

+        }

+    }

+}

+/*-----------------------------------------------------------*/

+

+static void prvLoggingFlushBuffer( void )

+{

+    size_t xLength;

+    char cPrintString[ dlMAX_PRINT_STRING_LENGTH ];

+

+    /* Is there more than the length value stored in the circular buffer

+     * used to pass data from the FreeRTOS simulator into this Win32 thread? */

+    while( uxStreamBufferGetSize( xLogStreamBuffer ) > sizeof( xLength ) )

+    {

+        memset( cPrintString, 0x00, dlMAX_PRINT_STRING_LENGTH );

+        uxStreamBufferGet( xLogStreamBuffer, 0, ( uint8_t * ) &xLength, sizeof( xLength ), pdFALSE );

+        uxStreamBufferGet( xLogStreamBuffer, 0, ( uint8_t * ) cPrintString, xLength, pdFALSE );

+

+        /* Write the message to standard out if requested to do so when

+         * vLoggingInit() was called, or if the network is not yet up. */

+        if( ( xStdoutLoggingUsed != pdFALSE ) || ( FreeRTOS_IsNetworkUp() == pdFALSE ) )

+        {

+            /* Write the message to stdout. */

+            _write( _fileno( stdout ), cPrintString, strlen( cPrintString ) );

+        }

+

+        /* Write the message to a file if requested to do so when

+         * vLoggingInit() was called. */

+        if( xDiskFileLoggingUsed != pdFALSE )

+        {

+            prvLogToFile( cPrintString, xLength );

+        }

+    }

+

+    prvFileClose();

+}

+/*-----------------------------------------------------------*/

+

+static DWORD WINAPI prvWin32LoggingThread( void * pvParameter )

+{

+    const DWORD xMaxWait = 1000;

+

+    ( void ) pvParameter;

+

+    /* From now on, prvLoggingFlushBuffer() will only be called from this

+     * Windows thread */

+    xDirectPrint = pdFALSE;

+

+    for( ; ; )

+    {

+        /* Wait to be told there are message waiting to be logged. */

+        WaitForSingleObject( pvLoggingThreadEvent, xMaxWait );

+

+        /* Write out all waiting messages. */

+        prvLoggingFlushBuffer();

+    }

+}

+/*-----------------------------------------------------------*/

+

+static void prvFileLoggingInit( void )

+{

+    FILE * pxHandle = fopen( pcLogFileName, "a" );

+

+    if( pxHandle != NULL )

+    {

+        fseek( pxHandle, SEEK_END, 0ul );

+        ulSizeOfLoggingFile = ftell( pxHandle );

+        fclose( pxHandle );

+    }

+    else

+    {

+        ulSizeOfLoggingFile = 0ul;

+    }

+}

+/*-----------------------------------------------------------*/

+

+static void prvFileClose( void )

+{

+    if( pxLoggingFileHandle != NULL )

+    {

+        fclose( pxLoggingFileHandle );

+        pxLoggingFileHandle = NULL;

+    }

+}

+/*-----------------------------------------------------------*/

+

+static void prvLogToFile( const char * pcMessage,

+                          size_t xLength )

+{

+    if( pxLoggingFileHandle == NULL )

+    {

+        pxLoggingFileHandle = fopen( pcLogFileName, "a" );

+    }

+

+    if( pxLoggingFileHandle != NULL )

+    {

+        fwrite( pcMessage, 1, xLength, pxLoggingFileHandle );

+        ulSizeOfLoggingFile += xLength;

+

+        /* If the file has grown to its maximum permissible size then close and

+         * rename it - then start with a new file. */

+        if( ulSizeOfLoggingFile > ( size_t ) dlLOGGING_FILE_SIZE )

+        {

+            prvFileClose();

+

+            if( _access( pcFullLogFileName, 00 ) == 0 )

+            {

+                remove( pcFullLogFileName );

+            }

+

+            rename( pcLogFileName, pcFullLogFileName );

+            ulSizeOfLoggingFile = 0;

+        }

+    }

+}

+/*-----------------------------------------------------------*/

diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/NTP/NTPDemo.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/NTP/NTPDemo.c
new file mode 100644
index 000000000..06c9c37c0
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/NTP/NTPDemo.c
@@ -0,0 +1,672 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/*
+ * NTPDemo.c
+ *
+ * An example of how to lookup a domain using DNS
+ * And also how to send and receive UDP messages to get the NTP time
+ *
+ */
+
+/* Standard includes. */
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+/* FreeRTOS includes. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "semphr.h"
+
+/* FreeRTOS+TCP includes. */
+#include "FreeRTOS_IP.h"
+#include "FreeRTOS_Sockets.h"
+#include "FreeRTOS_DNS.h"
+#include "FreeRTOS_Stream_Buffer.h"
+
+/* Use the date & time functions from +FAT. */
+#if ( USE_PLUS_FAT != 0 )
+    #include "ff_time.h"
+#endif /* ( USE_PLUS_FAT != 0 ) */
+
+#include "NTPDemo.h"
+#include "ntpClient.h"
+
+#include "date_and_time.h"
+
+#if ( ipconfigDNS_USE_CALLBACKS == 0 )
+    #error ipconfigDNS_USE_CALLBACKS must be 1
+#endif
+
+#if ( ipconfigMULTI_INTERFACE == 0 )
+    #ifndef ipSIZE_OF_IPv4_ADDRESS
+        #define ipSIZE_OF_IPv4_ADDRESS    4
+    #endif
+    #define FREERTOS_AF_INET4             FREERTOS_AF_INET
+#endif
+
+/* Set time: sets the current time in seconds-after-1/1/1970
+ * This function must be provided by the application. */
+
+time_t get_time( time_t * puxTime );
+int set_time( const time_t * t );
+
+enum EStatus
+{
+    EStatusLookup,
+    EStatusAsking,
+    EStatusPause,
+    EStatusFailed,
+};
+
+static struct SNtpPacket xNTPPacket;
+
+BaseType_t xNTPHasTime;
+uint32_t ulNTPTime;
+
+#if ( ipconfigUSE_CALLBACKS == 0 )
+    static char cRecvBuffer[ sizeof( struct SNtpPacket ) + 64 ];
+#endif
+
+static enum EStatus xStatus = EStatusLookup;
+
+static const char * pcTimeServers[] =
+{
+    "0.asia.pool.ntp.org",
+    "0.europe.pool.ntp.org",
+    "0.id.pool.ntp.org",
+    "0.south-america.pool.ntp.org",
+    "0.oceania.pool.ntp.org",
+    "0.north-america.pool.ntp.org"
+};
+
+static SemaphoreHandle_t xNTPWakeupSem = NULL;
+static uint32_t ulIPAddressFound;
+
+#if ( ipconfigUSE_IPv6 != 0 )
+    static struct freertos_sockaddr6 xIPAddressFound;
+#endif
+static BaseType_t xHasIPAddress = pdFALSE;
+
+static Socket_t xUDPSocket = NULL;
+static TaskHandle_t xNTPTaskhandle = NULL;
+static TickType_t uxSendTime;
+static BaseType_t xPreferredHostType = FREERTOS_AF_INET4;
+static BaseType_t xDNSAsynchronous = pdTRUE;
+static BaseType_t xDNSLogging = pdFALSE;
+
+static void prvNTPTask( void * pvParameters );
+
+static void vSignalTask( void )
+{
+    #if ( ipconfigUSE_CALLBACKS == 0 )
+        if( xUDPSocket != NULL )
+        {
+            /* Send a signal to the socket so that the
+             *  FreeRTOS_recvfrom will get interrupted. */
+            FreeRTOS_SignalSocket( xUDPSocket );
+        }
+        else
+    #endif
+
+    if( xNTPWakeupSem != NULL )
+    {
+        xSemaphoreGive( xNTPWakeupSem );
+    }
+}
+
+void vNTPClearCache( void )
+{
+    ulIPAddressFound = 0U;
+    #if ( ipconfigUSE_IPv6 != 0 )
+        {
+            memset( &( xIPAddressFound ), 0, sizeof xIPAddressFound );
+        }
+    #endif
+    xHasIPAddress = pdFALSE;
+}
+
+void vNTPSetNTPType( BaseType_t aIPType,
+                     BaseType_t xAsynchronous,
+                     BaseType_t xLogging )
+{
+    switch( aIPType )
+    {
+        case 4:
+            xPreferredHostType = FREERTOS_AF_INET4;
+            break;
+
+            #if ( ipconfigUSE_IPv6 != 0 )
+                case 6:
+                    xPreferredHostType = FREERTOS_AF_INET6;
+                    break;
+            #endif
+        default:
+            break;
+    }
+
+    xDNSAsynchronous = xAsynchronous;
+    xDNSLogging = xLogging;
+}
+
+void vStartNTPTask( uint16_t usTaskStackSize,
+                    UBaseType_t uxTaskPriority )
+{
+    /* The only public function in this module: start a task to contact
+     * some NTP server. */
+
+    if( xNTPTaskhandle != NULL )
+    {
+        switch( xStatus )
+        {
+            case EStatusPause:
+                xStatus = EStatusAsking;
+                vSignalTask();
+                break;
+
+            case EStatusLookup:
+                FreeRTOS_printf( ( "NTP looking up server\n" ) );
+                break;
+
+            case EStatusAsking:
+                FreeRTOS_printf( ( "NTP still asking\n" ) );
+                break;
+
+            case EStatusFailed:
+                FreeRTOS_printf( ( "NTP failed somehow\n" ) );
+                ulIPAddressFound = 0ul;
+                xStatus = EStatusLookup;
+                vSignalTask();
+                break;
+        }
+    }
+    else
+    {
+        xUDPSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );
+
+        if( xUDPSocket != NULL )
+        {
+            struct freertos_sockaddr xAddress;
+            #if ( ipconfigUSE_CALLBACKS != 0 )
+                BaseType_t xReceiveTimeOut = pdMS_TO_TICKS( 0 );
+            #else
+                BaseType_t xReceiveTimeOut = pdMS_TO_TICKS( 5000 );
+            #endif
+
+            xAddress.sin_addr = 0ul;
+            xAddress.sin_port = FreeRTOS_htons( NTP_PORT );
+
+            FreeRTOS_bind( xUDPSocket, &xAddress, sizeof( xAddress ) );
+            FreeRTOS_setsockopt( xUDPSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );
+            xTaskCreate( prvNTPTask,                    /* The function that implements the task. */
+                         ( const char * ) "NTP client", /* Just a text name for the task to aid debugging. */
+                         usTaskStackSize,               /* The stack size is defined in FreeRTOSIPConfig.h. */
+                         NULL,                          /* The task parameter, not used in this case. */
+                         uxTaskPriority,                /* The priority assigned to the task is defined in FreeRTOSConfig.h. */
+                         &xNTPTaskhandle );             /* The task handle. */
+        }
+        else
+        {
+            FreeRTOS_printf( ( "Creating socket failed\n" ) );
+        }
+    }
+}
+/*-----------------------------------------------------------*/
+
+#if ( ipconfigUSE_IPv6 != 0 )
+    static void vDNS_callback( const char * pcName,
+                               void * pvSearchID,
+                               struct freertos_addrinfo * pxAddress )
+    {
+        xStatus = EStatusAsking;
+
+        ( void ) pvSearchID;
+
+        if( pxAddress == NULL )
+        {
+            FreeRTOS_printf( ( "DNS lookup timed out\n" ) );
+        }
+        else
+        {
+            if( pxAddress->ai_family == FREERTOS_AF_INET4 )
+            {
+                char pcBuf[ 16 ];
+                uint32_t ulIPAddress;
+
+                /* The DNS lookup has a result, or it has reached the time-out. */
+                ulIPAddress = pxAddress->ai_addr->sin_addr;
+                FreeRTOS_inet_ntoa( ulIPAddress, pcBuf );
+                FreeRTOS_printf( ( "vDNS_callback: IP address of %s found: %s\n", pcName, pcBuf ) );
+
+                /*			if( ulIPAddressFound == 0U ) */
+                /*			{ */
+                /*				ulIPAddressFound = FreeRTOS_inet_addr_quick( 162, 159, 200, 1 ); */
+                /*			} */
+                if( ulIPAddressFound != 0U )
+                {
+                    memset( xIPAddressFound.sin_addrv6.ucBytes, 0, ipSIZE_OF_IPv6_ADDRESS );
+                    xHasIPAddress = pdTRUE;
+                }
+            }
+            else if( pxAddress->ai_family == FREERTOS_AF_INET6 )
+            {
+                /*  struct freertos_sockaddr * ai_addr */
+                struct freertos_sockaddr6 * sockaddr6 = ( struct freertos_sockaddr6 * ) pxAddress->ai_addr;
+
+                xIPAddressFound.sin_len = sizeof( xIPAddressFound ); /* Ignored, still present for backward compatibility. */
+                xIPAddressFound.sin_family = FREERTOS_AF_INET6;      /* Set to FREERTOS_AF_INET6. */
+                xIPAddressFound.sin_port = FreeRTOS_htons( NTP_PORT );
+                xIPAddressFound.sin_flowinfo = 0;                    /* IPv6 flow information. */
+                memcpy( xIPAddressFound.sin_addrv6.ucBytes, sockaddr6->sin_addrv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
+
+                FreeRTOS_printf( ( "vDNS_callback: using address %pip\n", xIPAddressFound.sin_addrv6.ucBytes ) );
+                ulIPAddressFound = 0U;
+                xHasIPAddress = pdTRUE;
+            }
+        }
+
+        vSignalTask();
+    }
+#else /* if ( ipconfigUSE_IPv6 != 0 ) */
+    static void vDNS_callback( const char * pcName,
+                               void * pvSearchID,
+                               uint32_t ulIPAddress )
+    {
+        char pcBuf[ 16 ];
+
+        /* The DNS lookup has a result, or it has reached the time-out. */
+        FreeRTOS_inet_ntoa( ulIPAddress, pcBuf );
+        FreeRTOS_printf( ( "IP address of %s found: %s\n", pcName, pcBuf ) );
+
+        if( ulIPAddressFound == 0U )
+        {
+            ulIPAddressFound = ulIPAddress;
+        }
+
+        /* For testing: in case DNS doesn't respond, still try some NTP server
+         * with a known IP-address. */
+/*		if( ulIPAddressFound == 0U ) */
+/*		{ */
+/*			ulIPAddressFound = FreeRTOS_inet_addr_quick( 184, 105, 182, 7 ); */
+/*			/ *		ulIPAddressFound = FreeRTOS_inet_addr_quick( 103, 242,  70, 4 );	* / */
+/*		} */
+        if( ulIPAddressFound != 0U )
+        {
+            xHasIPAddress = pdTRUE;
+            xStatus = EStatusAsking;
+        }
+
+        vSignalTask();
+    }
+#endif /* if ( ipconfigUSE_IPv6 != 0 ) */
+/*-----------------------------------------------------------*/
+
+static void prvSwapFields( struct SNtpPacket * pxPacket )
+{
+    /* NTP messages are big-endian */
+    pxPacket->rootDelay = FreeRTOS_htonl( pxPacket->rootDelay );
+    pxPacket->rootDispersion = FreeRTOS_htonl( pxPacket->rootDispersion );
+
+    pxPacket->referenceTimestamp.seconds = FreeRTOS_htonl( pxPacket->referenceTimestamp.seconds );
+    pxPacket->referenceTimestamp.fraction = FreeRTOS_htonl( pxPacket->referenceTimestamp.fraction );
+
+    pxPacket->originateTimestamp.seconds = FreeRTOS_htonl( pxPacket->originateTimestamp.seconds );
+    pxPacket->originateTimestamp.fraction = FreeRTOS_htonl( pxPacket->originateTimestamp.fraction );
+
+    pxPacket->receiveTimestamp.seconds = FreeRTOS_htonl( pxPacket->receiveTimestamp.seconds );
+    pxPacket->receiveTimestamp.fraction = FreeRTOS_htonl( pxPacket->receiveTimestamp.fraction );
+
+    pxPacket->transmitTimestamp.seconds = FreeRTOS_htonl( pxPacket->transmitTimestamp.seconds );
+    pxPacket->transmitTimestamp.fraction = FreeRTOS_htonl( pxPacket->transmitTimestamp.fraction );
+}
+/*-----------------------------------------------------------*/
+
+static void prvNTPPacketInit()
+{
+    memset( &xNTPPacket, '\0', sizeof( xNTPPacket ) );
+
+    xNTPPacket.flags = 0xDB;                /* value 0xDB : mode 3 (client), version 3, leap indicator unknown 3 */
+    xNTPPacket.poll = 10;                   /* 10 means 1 << 10 = 1024 seconds */
+    xNTPPacket.precision = 0xFA;            /* = 250 = 0.015625 seconds */
+    xNTPPacket.rootDelay = 0x5D2E;          /* 0x5D2E = 23854 or (23854/65535)= 0.3640 sec */
+    xNTPPacket.rootDispersion = 0x0008CAC8; /* 0x0008CAC8 = 8.7912  seconds */
+
+    /* use the recorded NTP time */
+    time_t uxSecs = get_time( NULL );               /* apTime may be NULL, returns seconds */
+
+    xNTPPacket.referenceTimestamp.seconds = uxSecs; /* Current time */
+    xNTPPacket.transmitTimestamp.seconds = uxSecs + 3;
+
+    /* Transform the contents of the fields from native to big endian. */
+    prvSwapFields( &xNTPPacket );
+}
+/*-----------------------------------------------------------*/
+
+static void prvReadTime( struct SNtpPacket * pxPacket )
+{
+    #if ( USE_PLUS_FAT != 0 )
+        FF_TimeStruct_t xTimeStruct;
+    #else
+        struct tm xTimeStruct;
+    #endif
+
+    time_t uxPreviousSeconds;
+    time_t uxPreviousMS;
+
+    time_t uxCurrentSeconds;
+    time_t uxCurrentMS;
+
+    const char * pcTimeUnit;
+    int32_t ilDiff;
+    TickType_t uxTravelTime;
+
+    uxTravelTime = xTaskGetTickCount() - uxSendTime;
+
+    /* Transform the contents of the fields from big to native endian. */
+    prvSwapFields( pxPacket );
+
+    uxCurrentSeconds = pxPacket->receiveTimestamp.seconds - TIME1970;
+    uxCurrentMS = pxPacket->receiveTimestamp.fraction / 4294967;
+    uxCurrentSeconds += uxCurrentMS / 1000;
+    uxCurrentMS = uxCurrentMS % 1000;
+
+    /* Get the last time recorded */
+    uxPreviousSeconds = FreeRTOS_get_secs_msec( &uxPreviousMS );
+
+    /* Set the new time with precision in msec. * / */
+    FreeRTOS_set_secs_msec( &uxCurrentSeconds, &uxCurrentMS );
+
+    if( uxCurrentSeconds >= uxPreviousSeconds )
+    {
+        ilDiff = ( int32_t ) ( uxCurrentSeconds - uxPreviousSeconds );
+    }
+    else
+    {
+        ilDiff = 0 - ( int32_t ) ( uxPreviousSeconds - uxCurrentSeconds );
+    }
+
+    if( ( ilDiff < -5 ) || ( ilDiff > 5 ) )
+    {
+        /* More than 5 seconds difference. */
+        pcTimeUnit = "sec";
+    }
+    else
+    {
+        /* Less than or equal to 5 second difference. */
+        pcTimeUnit = "ms";
+        uint32_t ulLowest = ( uxCurrentSeconds <= uxPreviousSeconds ) ? uxCurrentSeconds : uxPreviousSeconds;
+        int32_t iCurMS = 1000 * ( uxCurrentSeconds - ulLowest ) + uxCurrentMS;
+        int32_t iPrevMS = 1000 * ( uxPreviousSeconds - ulLowest ) + uxPreviousMS;
+        ilDiff = iCurMS - iPrevMS;
+    }
+
+    /*uxCurrentSeconds -= iTimeZone; */
+
+    #if ( USE_PLUS_FAT != 0 )
+        FreeRTOS_gmtime_r( &uxCurrentSeconds, &xTimeStruct );
+    #else
+        gmtime_r( &uxCurrentSeconds, &xTimeStruct );
+    #endif /* ( USE_PLUS_FAT != 0 ) */
+
+    /*
+     *  378.067 [NTP client] NTP time: 9/11/2015 16:11:19.559 Diff -20 ms (289 ms)
+     *  379.441 [NTP client] NTP time: 9/11/2015 16:11:20.933 Diff 0 ms (263 ms)
+     */
+    /* NTP time: -858993460/-858993459/-858991560 -858993460:-858993460:-858993460.158 Diff 1607503255 sec (60 ms) */
+    FreeRTOS_printf( ( "NTP time: %u/%u/%02u %2u:%02u:%02u.%03u Diff %d %s (%lu ms)\n",
+                       ( unsigned ) xTimeStruct.tm_mday,
+                       ( unsigned ) xTimeStruct.tm_mon + 1,
+                       ( unsigned ) xTimeStruct.tm_year + 1900,
+                       ( unsigned ) xTimeStruct.tm_hour,
+                       ( unsigned ) xTimeStruct.tm_min,
+                       ( unsigned ) xTimeStruct.tm_sec,
+                       ( unsigned ) uxCurrentMS,
+                       ( signed ) ilDiff,
+                       pcTimeUnit,
+                       uxTravelTime ) );
+
+    xNTPHasTime = pdTRUE;
+    ulNTPTime = uxCurrentSeconds;
+    set_time( &uxCurrentSeconds );
+
+    /* Remove compiler warnings in case FreeRTOS_printf() is not used. */
+    ( void ) pcTimeUnit;
+    ( void ) uxTravelTime;
+}
+/*-----------------------------------------------------------*/
+
+#if ( ipconfigUSE_CALLBACKS != 0 )
+
+    static BaseType_t xOnUDPReceive( Socket_t xSocket,
+                                     void * pvData,
+                                     size_t xLength,
+                                     const struct freertos_sockaddr * pxFrom,
+                                     const struct freertos_sockaddr * pxDest )
+    {
+        ( void ) xSocket;
+        ( void ) pxFrom;
+        ( void ) pxDest;
+
+        if( xLength >= sizeof( xNTPPacket ) )
+        {
+            prvReadTime( ( struct SNtpPacket * ) pvData );
+
+            if( xStatus != EStatusPause )
+            {
+                xStatus = EStatusPause;
+            }
+        }
+
+        vSignalTask();
+        /* Tell the driver not to store the RX data */
+        return 1;
+    }
+    /*-----------------------------------------------------------*/
+
+#endif /* ipconfigUSE_CALLBACKS != 0 */
+
+static void prvNTPTask( void * pvParameters )
+{
+    BaseType_t xServerIndex = 3;
+    struct freertos_sockaddr xAddress;
+
+    #if ( ipconfigUSE_CALLBACKS != 0 )
+        F_TCP_UDP_Handler_t xHandler;
+    #endif /* ipconfigUSE_CALLBACKS != 0 */
+
+    ( void ) pvParameters;
+
+    xStatus = EStatusLookup;
+    #if ( ipconfigSOCKET_HAS_USER_SEMAPHORE != 0 ) || ( ipconfigUSE_CALLBACKS != 0 )
+        {
+            xNTPWakeupSem = xSemaphoreCreateBinary();
+        }
+    #endif
+
+    #if ( ipconfigUSE_CALLBACKS != 0 )
+        {
+            memset( &xHandler, '\0', sizeof( xHandler ) );
+            xHandler.pxOnUDPReceive = xOnUDPReceive;
+            FreeRTOS_setsockopt( xUDPSocket, 0, FREERTOS_SO_UDP_RECV_HANDLER, ( void * ) &xHandler, sizeof( xHandler ) );
+        }
+    #endif
+    #if ( ipconfigSOCKET_HAS_USER_SEMAPHORE != 0 )
+        {
+            FreeRTOS_setsockopt( xUDPSocket, 0, FREERTOS_SO_SET_SEMAPHORE, ( void * ) &xNTPWakeupSem, sizeof( xNTPWakeupSem ) );
+        }
+    #endif
+
+    for( ; ; )
+    {
+        switch( xStatus )
+        {
+            case EStatusLookup:
+
+                if( xHasIPAddress == 0 )
+                {
+                    char pcServerName[ 64 ];
+
+                    if( ++xServerIndex == sizeof( pcTimeServers ) / sizeof( pcTimeServers[ 0 ] ) )
+                    {
+                        xServerIndex = 0;
+                    }
+
+                    snprintf( pcServerName, sizeof pcServerName, "%s", pcTimeServers[ xServerIndex ] );
+
+                    if( ( pcServerName[ 0 ] == '0' ) && ( xPreferredHostType == FREERTOS_AF_INET6 ) )
+                    {
+                        pcServerName[ 0 ] = '2';
+                    }
+
+                    FreeRTOS_printf( ( "Looking up server '%s' IPv%c\n",
+                                       pcServerName,
+                                       ( xPreferredHostType == FREERTOS_AF_INET4 ) ? '4' : '6' ) );
+                    #if ( ipconfigMULTI_INTERFACE != 0 )
+                        struct freertos_addrinfo xHints;
+                        struct freertos_addrinfo * pxResults = NULL;
+
+                        memset( &( xHints ), 0, sizeof xHints );
+                        xHints.ai_family = xPreferredHostType;
+
+                        if( xDNSAsynchronous != 0 )
+                        {
+                            FreeRTOS_getaddrinfo_a( pcServerName,    /* The name of the node or device */
+                                                    NULL,            /* Ignored for now. */
+                                                    &( xHints ),     /* If not NULL: preferences. */
+                                                    &( pxResults ),  /* An allocated struct, containing the results. */
+                                                    vDNS_callback,
+                                                    ( void * ) NULL, /* An object or a reference. */
+                                                    pdMS_TO_TICKS( 2500U ) );
+                        }
+                        else
+                        {
+                            FreeRTOS_getaddrinfo( pcServerName,     /* The name of the node or device */
+                                                  NULL,             /* Ignored for now. */
+                                                  &( xHints ),      /* If not NULL: preferences. */
+                                                  &( pxResults ) ); /* An allocated struct, containing the results. */
+
+                            if( pxResults != NULL )
+                            {
+                                vDNS_callback( pcServerName, NULL, pxResults );
+                            }
+                        }
+                    #else /* if ( ipconfigMULTI_INTERFACE != 0 ) */
+                        FreeRTOS_gethostbyname_a( pcServerName, vDNS_callback, ( void * ) NULL, 1200 );
+                    #endif /* if ( ipconfigMULTI_INTERFACE != 0 ) */
+                }
+                else
+                {
+                    xStatus = EStatusAsking;
+                }
+
+                break;
+
+            case EStatusAsking:
+                prvNTPPacketInit();
+                uxSendTime = xTaskGetTickCount();
+                #if ( ipconfigUSE_IPv6 != 0 )
+                    if( memcmp( xIPAddressFound.sin_addrv6.ucBytes, in6addr_any.ucBytes, ipSIZE_OF_IPv6_ADDRESS ) != 0 )
+                    {
+                        FreeRTOS_printf( ( "Sending UDP message to %pip:%u\n",
+                                           xIPAddressFound.sin_addrv6.ucBytes,
+                                           FreeRTOS_ntohs( xIPAddressFound.sin_port ) ) );
+
+                        FreeRTOS_sendto( xUDPSocket,
+                                         ( void * ) &xNTPPacket, sizeof( xNTPPacket ),
+                                         0,
+                                         ( const struct freertos_sockaddr * ) &( xIPAddressFound ),
+                                         sizeof( xIPAddressFound ) );
+                    }
+                    else
+                #endif /* ( ipconfigUSE_IPv6 != 0 ) */
+                {
+                    xAddress.sin_addr = ulIPAddressFound;
+                    xAddress.sin_port = FreeRTOS_htons( NTP_PORT );
+
+                    FreeRTOS_printf( ( "Sending UDP message to %lxip:%u\n",
+                                       FreeRTOS_ntohl( ulIPAddressFound ),
+                                       FreeRTOS_ntohs( xAddress.sin_port ) ) );
+
+                    FreeRTOS_sendto( xUDPSocket,
+                                     ( void * ) &xNTPPacket,
+                                     sizeof( xNTPPacket ),
+                                     0, &( xAddress ),
+                                     sizeof( xAddress ) );
+                }
+
+                break;
+
+            case EStatusPause:
+                break;
+
+            case EStatusFailed:
+                break;
+        }
+
+        #if ( ipconfigUSE_CALLBACKS != 0 )
+            {
+                xSemaphoreTake( xNTPWakeupSem, 5000 );
+            }
+        #else
+            {
+                uint32_t xAddressSize;
+                BaseType_t xReturned;
+
+                xAddressSize = sizeof( xAddress );
+                xReturned = FreeRTOS_recvfrom( xUDPSocket, ( void * ) cRecvBuffer, sizeof( cRecvBuffer ), 0, &xAddress, &xAddressSize );
+
+                switch( xReturned )
+                {
+                    case 0:
+                    case -pdFREERTOS_ERRNO_EAGAIN:
+                    case -pdFREERTOS_ERRNO_EINTR:
+                        break;
+
+                    default:
+
+                        if( xReturned < sizeof( xNTPPacket ) )
+                        {
+                            FreeRTOS_printf( ( "FreeRTOS_recvfrom: returns %ld\n", xReturned ) );
+                        }
+                        else
+                        {
+                            prvReadTime( ( struct SNtpPacket * ) cRecvBuffer );
+
+                            if( xStatus != EStatusPause )
+                            {
+                                xStatus = EStatusPause;
+                            }
+                        }
+
+                        break;
+                }
+            }
+        #endif /* if ( ipconfigUSE_CALLBACKS != 0 ) */
+    }
+}
+/*-----------------------------------------------------------*/
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/NTP/include/NTPDemo.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/NTP/include/NTPDemo.h
new file mode 100644
index 000000000..11362e06e
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/NTP/include/NTPDemo.h
@@ -0,0 +1,53 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/*
+ * A simple demo for NTP using FreeRTOS+TCP
+ */
+
+#ifndef NTPDEMO_H
+
+#define NTPDEMO_H
+
+void vStartNTPTask( uint16_t usTaskStackSize,
+                    UBaseType_t uxTaskPriority );
+
+/*
+ * xIPVersion = 4 or 6.
+ * xAsynchronous = true for asynchronous DNS lookups.
+ * xLogging = true to get more logging.
+ */
+void vNTPSetNTPType( BaseType_t aIPType,
+                     BaseType_t xAsynchronous,
+                     BaseType_t xLogging );
+
+/* Delete the IP-addresses of the NTP server to force a DNS lookup. */
+void vNTPClearCache( void );
+
+extern BaseType_t xNTPHasTime;
+extern uint32_t ulNTPTime;
+
+#endif /* ifndef NTPDEMO_H */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/NTP/include/ntpClient.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/NTP/include/ntpClient.h
new file mode 100644
index 000000000..753743ae6
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/NTP/include/ntpClient.h
@@ -0,0 +1,104 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/* */
+/*	ntpClient.h */
+/* */
+
+#ifndef __NTPCLIENT_H__
+
+#define __NTPCLIENT_H__
+
+#define NTP_PORT    123
+
+typedef uint32_t           quint32;
+typedef int32_t            qint32;
+typedef uint8_t            quint8;
+typedef int8_t             qint8;
+
+typedef union _SNtpFlags   SNtpFlags;
+
+#ifdef _MSC_VER
+    #define __attribute__( x )
+#endif
+
+/**
+ * 64-bit NTP timestamp.
+ */
+struct __attribute__( ( __packed__ ) ) _SNtpTimestamp
+{
+    /** Number of seconds passed since Jan 1 1900, in big-endian format. */
+    quint32 seconds;
+
+    /** Fractional time part, in <tt>1/0xFFFFFFFF</tt>s of a second. */
+    quint32 fraction;
+};
+
+typedef struct _SNtpTimestamp SNtpTimestamp;
+
+/**
+ * Mandatory part of an NTP packet
+ */
+struct SNtpPacket
+{
+    /** Flags. */
+    unsigned char flags; /* value 0xDB : mode 3 (client), version 3, leap indicator unknown 3 */
+
+    /** Stratum of the clock. */
+    quint8 stratum; /* value 0 : unspecified */
+
+    /** Maximum interval between successive messages, in log2 seconds. Note that the value is signed. */
+    qint8 poll; /* 10 means 1 << 10 = 1024 seconds */
+
+    /** Precision of the clock, in log2 seconds. Note that the value is signed. */
+    qint8 precision; /* 0xFA = 250 = 0.015625 seconds */
+
+    /** Round trip time to the primary reference source, in NTP short format. */
+    qint32 rootDelay; /* 0x5D2E = 23854 or (23854/65535)= 0.3640 sec */
+
+    /** Nominal error relative to the primary reference source. */
+    qint32 rootDispersion; /* 0x0008 CAC8 = 8.7912  seconds */
+
+    /** Reference identifier (either a 4 character string or an IP address). */
+    qint8 referenceID[ 4 ]; /* or just 0000 */
+
+    /** The time at which the clock was last set or corrected. */
+    SNtpTimestamp referenceTimestamp; /* Current time */
+
+    /** The time at which the request departed the client for the server. */
+    SNtpTimestamp originateTimestamp; /* Keep 0 */
+
+    /** The time at which the request arrived at the server. */
+    SNtpTimestamp receiveTimestamp; /* Keep 0 */
+
+    /** The time at which the reply departed the server for client. */
+    SNtpTimestamp transmitTimestamp;
+};
+
+/* Add this number to get secs since 1-1-1900 */
+#define TIME1970    2208988800UL
+
+#endif /* __NTPCLIENT_H__ */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/Packet32.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/Packet32.h
new file mode 100644
index 000000000..ab957dc2a
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/Packet32.h
@@ -0,0 +1,391 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/** @ingroup packetapi
+ *  @{
+ */
+
+/** @defgroup packet32h Packet.dll definitions and data structures
+ *  Packet32.h contains the data structures and the definitions used by packet.dll.
+ *  The file is used both by the Win9x and the WinNTx versions of packet.dll, and can be included
+ *  by the applications that use the functions of this library
+ *  @{
+ */
+
+#ifndef __PACKET32
+    #define __PACKET32
+
+    #include <winsock2.h>
+
+    #ifdef HAVE_AIRPCAP_API
+        #include <airpcap.h>
+    #else
+        #if !defined( AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_ )
+            #define AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_
+            typedef struct _AirpcapHandle * PAirpcapHandle;
+        #endif /* AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_ */
+    #endif /* HAVE_AIRPCAP_API */
+
+    #ifdef HAVE_DAG_API
+        #include <dagc.h>
+    #endif /* HAVE_DAG_API */
+
+/* Working modes */
+    #define PACKET_MODE_CAPT         0x0                   /*/< Capture mode */
+    #define PACKET_MODE_STAT         0x1                   /*/< Statistical mode */
+    #define PACKET_MODE_MON          0x2                   /*/< Monitoring mode */
+    #define PACKET_MODE_DUMP         0x10                  /*/< Dump mode */
+    #define PACKET_MODE_STAT_DUMP    MODE_DUMP | MODE_STAT /*/< Statistical dump Mode */
+
+
+/*/ Alignment macro. Defines the alignment size. */
+    #define Packet_ALIGNMENT    sizeof( int )
+/*/ Alignment macro. Rounds up to the next even multiple of Packet_ALIGNMENT. */
+    #define Packet_WORDALIGN( x )    ( ( ( x ) + ( Packet_ALIGNMENT - 1 ) ) & ~( Packet_ALIGNMENT - 1 ) )
+
+    #define NdisMediumNull          -1 /*/< Custom linktype: NDIS doesn't provide an equivalent */
+    #define NdisMediumCHDLC         -2 /*/< Custom linktype: NDIS doesn't provide an equivalent */
+    #define NdisMediumPPPSerial     -3 /*/< Custom linktype: NDIS doesn't provide an equivalent */
+    #define NdisMediumBare80211     -4 /*/< Custom linktype: NDIS doesn't provide an equivalent */
+    #define NdisMediumRadio80211    -5 /*/< Custom linktype: NDIS doesn't provide an equivalent */
+    #define NdisMediumPpi           -6 /*/< Custom linktype: NDIS doesn't provide an equivalent */
+
+/* Loopback behaviour definitions */
+    #define NPF_DISABLE_LOOPBACK    1 /*/< Drop the packets sent by the NPF driver */
+    #define NPF_ENABLE_LOOPBACK     2 /*/< Capture the packets sent by the NPF driver */
+
+/*!
+ * \brief Network type structure.
+ *
+ * This structure is used by the PacketGetNetType() function to return information on the current adapter's type and speed.
+ */
+    typedef struct NetType
+    {
+        UINT LinkType;       /*/< The MAC of the current network adapter (see function PacketGetNetType() for more information) */
+        ULONGLONG LinkSpeed; /*/< The speed of the network in bits per second */
+    } NetType;
+
+
+/*some definitions stolen from libpcap */
+
+    #ifndef BPF_MAJOR_VERSION
+
+/*!
+ * \brief A BPF pseudo-assembly program.
+ *
+ * The program will be injected in the kernel by the PacketSetBPF() function and applied to every incoming packet.
+ */
+        struct bpf_program
+        {
+            UINT bf_len;                /*/< Indicates the number of instructions of the program, i.e. the number of struct bpf_insn that will follow. */
+            struct bpf_insn * bf_insns; /*/< A pointer to the first instruction of the program. */
+        };
+
+/*!
+ * \brief A single BPF pseudo-instruction.
+ *
+ * bpf_insn contains a single instruction for the BPF register-machine. It is used to send a filter program to the driver.
+ */
+        struct bpf_insn
+        {
+            USHORT code; /*/< Instruction type and addressing mode. */
+            UCHAR jt;    /*/< Jump if true */
+            UCHAR jf;    /*/< Jump if false */
+            int k;       /*/< Generic field used for various purposes. */
+        };
+
+/*!
+ * \brief Structure that contains a couple of statistics values on the current capture.
+ *
+ * It is used by packet.dll to return statistics about a capture session.
+ */
+        struct bpf_stat
+        {
+            UINT bs_recv; /*/< Number of packets that the driver received from the network adapter */
+            /*/< from the beginning of the current capture. This value includes the packets */
+            /*/< lost by the driver. */
+            UINT bs_drop; /*/< number of packets that the driver lost from the beginning of a capture. */
+            /*/< Basically, a packet is lost when the the buffer of the driver is full. */
+            /*/< In this situation the packet cannot be stored and the driver rejects it. */
+            UINT ps_ifdrop; /*/< drops by interface. XXX not yet supported */
+            UINT bs_capt;   /*/< number of packets that pass the filter, find place in the kernel buffer and */
+            /*/< thus reach the application. */
+        };
+
+/*!
+ * \brief Packet header.
+ *
+ * This structure defines the header associated with every packet delivered to the application.
+ */
+        struct bpf_hdr
+        {
+            struct timeval bh_tstamp; /*/< The timestamp associated with the captured packet. */
+            /*/< It is stored in a TimeVal structure. */
+            UINT bh_caplen;           /*/< Length of captured portion. The captured portion <b>can be different</b> */
+            /*/< from the original packet, because it is possible (with a proper filter) */
+            /*/< to instruct the driver to capture only a portion of the packets. */
+            UINT bh_datalen;    /*/< Original length of packet */
+            USHORT bh_hdrlen;   /*/< Length of bpf header (this struct plus alignment padding). In some cases, */
+            /*/< a padding could be added between the end of this structure and the packet */
+            /*/< data for performance reasons. This filed can be used to retrieve the actual data */
+            /*/< of the packet. */
+        };
+
+/*!
+ * \brief Dump packet header.
+ *
+ * This structure defines the header associated with the packets in a buffer to be used with PacketSendPackets().
+ * It is simpler than the bpf_hdr, because it corresponds to the header associated by WinPcap and libpcap to a
+ * packet in a dump file. This makes straightforward sending WinPcap dump files to the network.
+ */
+        struct dump_bpf_hdr
+        {
+            struct timeval ts;  /*/< Time stamp of the packet */
+            UINT caplen;        /*/< Length of captured portion. The captured portion can smaller than the */
+            /*/< the original packet, because it is possible (with a proper filter) to */
+            /*/< instruct the driver to capture only a portion of the packets. */
+            UINT len;           /*/< Length of the original packet (off wire). */
+        };
+
+
+    #endif /* ifndef BPF_MAJOR_VERSION */
+
+    struct bpf_stat;
+
+    #define        DOSNAMEPREFIX           TEXT( "Packet_" ) /*/< Prefix added to the adapters device names to create the WinPcap devices */
+    #define        MAX_LINK_NAME_LENGTH    64                /*< Maximum length of the devices symbolic links */
+    #define        NMAX_PACKET             65535
+
+/*!
+ * \brief Addresses of a network adapter.
+ *
+ * This structure is used by the PacketGetNetInfoEx() function to return the IP addresses associated with
+ * an adapter.
+ */
+    typedef struct npf_if_addr
+    {
+        struct sockaddr_storage IPAddress;  /*/< IP address. */
+        struct sockaddr_storage SubnetMask; /*/< Netmask for that address. */
+        struct sockaddr_storage Broadcast;  /*/< Broadcast address. */
+    } npf_if_addr;
+
+
+    #define ADAPTER_NAME_LENGTH      256 + 12 /*/<  Maximum length for the name of an adapter. The value is the same used by the IP Helper API. */
+    #define ADAPTER_DESC_LENGTH      128      /*/<  Maximum length for the description of an adapter. The value is the same used by the IP Helper API. */
+    #define MAX_MAC_ADDR_LENGTH      8        /*/<  Maximum length for the link layer address of an adapter. The value is the same used by the IP Helper API. */
+    #define MAX_NETWORK_ADDRESSES    16       /*/<  Maximum length for the link layer address of an adapter. The value is the same used by the IP Helper API. */
+
+
+    typedef struct WAN_ADAPTER_INT WAN_ADAPTER;    /*/< Describes an opened wan (dialup, VPN...) network adapter using the NetMon API */
+    typedef WAN_ADAPTER            * PWAN_ADAPTER; /*/< Describes an opened wan (dialup, VPN...) network adapter using the NetMon API */
+
+    #define INFO_FLAG_NDIS_ADAPTER       0         /*/< Flag for ADAPTER_INFO: this is a traditional ndis adapter */
+    #define INFO_FLAG_NDISWAN_ADAPTER    1         /*/< Flag for ADAPTER_INFO: this is a NdisWan adapter, and it's managed by WANPACKET */
+    #define INFO_FLAG_DAG_CARD           2         /*/< Flag for ADAPTER_INFO: this is a DAG card */
+    #define INFO_FLAG_DAG_FILE           6         /*/< Flag for ADAPTER_INFO: this is a DAG file */
+    #define INFO_FLAG_DONT_EXPORT        8         /*/< Flag for ADAPTER_INFO: when this flag is set, the adapter will not be listed or openend by winpcap. This allows to prevent exporting broken network adapters, like for example FireWire ones. */
+    #define INFO_FLAG_AIRPCAP_CARD       16        /*/< Flag for ADAPTER_INFO: this is an airpcap card */
+    #define INFO_FLAG_NPFIM_DEVICE       32
+
+/*!
+ * \brief Describes an opened network adapter.
+ *
+ * This structure is the most important for the functioning of packet.dll, but the great part of its fields
+ * should be ignored by the user, since the library offers functions that avoid to cope with low-level parameters
+ */
+    typedef struct _ADAPTER
+    {
+        HANDLE hFile;                              /*/< \internal Handle to an open instance of the NPF driver. */
+        CHAR SymbolicLink[ MAX_LINK_NAME_LENGTH ]; /*/< \internal A string containing the name of the network adapter currently opened. */
+        int NumWrites;                             /*/< \internal Number of times a packets written on this adapter will be repeated */
+        /*/< on the wire. */
+        HANDLE ReadEvent;                          /*/< A notification event associated with the read calls on the adapter. */
+        /*/< It can be passed to standard Win32 functions (like WaitForSingleObject */
+        /*/< or WaitForMultipleObjects) to wait until the driver's buffer contains some */
+        /*/< data. It is particularly useful in GUI applications that need to wait */
+        /*/< concurrently on several events. In Windows NT/2000 the PacketSetMinToCopy() */
+        /*/< function can be used to define the minimum amount of data in the kernel buffer */
+        /*/< that will cause the event to be signalled. */
+
+        UINT ReadTimeOut;       /*/< \internal The amount of time after which a read on the driver will be released and */
+        /*/< ReadEvent will be signaled, also if no packets were captured */
+        CHAR Name[ ADAPTER_NAME_LENGTH ];
+        PWAN_ADAPTER pWanAdapter;
+        UINT Flags;             /*/< Adapter's flags. Tell if this adapter must be treated in a different way, using the Netmon API or the dagc API. */
+
+        #ifdef HAVE_AIRPCAP_API
+            PAirpcapHandle AirpcapAd;
+        #endif /* HAVE_AIRPCAP_API */
+
+        #ifdef HAVE_NPFIM_API
+            void * NpfImHandle;
+        #endif /* HAVE_NPFIM_API */
+
+        #ifdef HAVE_DAG_API
+            dagc_t * pDagCard;             /*/< Pointer to the dagc API adapter descriptor for this adapter */
+            PCHAR DagBuffer;               /*/< Pointer to the buffer with the packets that is received from the DAG card */
+            struct timeval DagReadTimeout; /*/< Read timeout. The dagc API requires a timeval structure */
+            unsigned DagFcsLen;            /*/< Length of the frame check sequence attached to any packet by the card. Obtained from the registry */
+            DWORD DagFastProcess;          /*/< True if the user requests fast capture processing on this card. Higher level applications can use this value to provide a faster but possibly unprecise capture (for example, libpcap doesn't convert the timestamps). */
+        #endif /* HAVE_DAG_API */
+    } ADAPTER, * LPADAPTER;
+
+/*!
+ * \brief Structure that contains a group of packets coming from the driver.
+ *
+ * This structure defines the header associated with every packet delivered to the application.
+ */
+    typedef struct _PACKET
+    {
+        HANDLE hEvent;          /*/< \deprecated Still present for compatibility with old applications. */
+        OVERLAPPED OverLapped;  /*/< \deprecated Still present for compatibility with old applications. */
+        PVOID Buffer;           /*/< Buffer with containing the packets. See the PacketReceivePacket() for */
+        /*/< details about the organization of the data in this buffer */
+        UINT Length;            /*/< Length of the buffer */
+        DWORD ulBytesReceived;  /*/< Number of valid bytes present in the buffer, i.e. amount of data */
+        /*/< received by the last call to PacketReceivePacket() */
+        BOOLEAN bIoComplete;    /*/< \deprecated Still present for compatibility with old applications. */
+    } PACKET, * LPPACKET;
+
+/*!
+ * \brief Structure containing an OID request.
+ *
+ * It is used by the PacketRequest() function to send an OID to the interface card driver.
+ * It can be used, for example, to retrieve the status of the error counters on the adapter, its MAC address,
+ * the list of the multicast groups defined on it, and so on.
+ */
+    struct _PACKET_OID_DATA
+    {
+        ULONG Oid;              /*/< OID code. See the Microsoft DDK documentation or the file ntddndis.h */
+        /*/< for a complete list of valid codes. */
+        ULONG Length;           /*/< Length of the data field */
+        UCHAR Data[ 1 ];        /*/< variable-lenght field that contains the information passed to or received */
+        /*/< from the adapter. */
+    };
+    typedef struct _PACKET_OID_DATA PACKET_OID_DATA, * PPACKET_OID_DATA;
+
+    #ifdef __cplusplus
+        extern "C" {
+    #endif
+
+/**
+ *  @}
+ */
+
+/*
+ * BOOLEAN QueryWinPcapRegistryStringA(CHAR *SubKeyName,
+ *                               CHAR *Value,
+ *                               UINT *pValueLen,
+ *                               CHAR *DefaultVal);
+ *
+ * BOOLEAN QueryWinPcapRegistryStringW(WCHAR *SubKeyName,
+ *                               WCHAR *Value,
+ *                               UINT *pValueLen,
+ *                               WCHAR *DefaultVal);
+ */
+
+/*--------------------------------------------------------------------------- */
+/* EXPORTED FUNCTIONS */
+/*--------------------------------------------------------------------------- */
+
+    PCHAR PacketGetVersion();
+    PCHAR PacketGetDriverVersion();
+    BOOLEAN PacketSetMinToCopy( LPADAPTER AdapterObject,
+                                int nbytes );
+    BOOLEAN PacketSetNumWrites( LPADAPTER AdapterObject,
+                                int nwrites );
+    BOOLEAN PacketSetMode( LPADAPTER AdapterObject,
+                           int mode );
+    BOOLEAN PacketSetReadTimeout( LPADAPTER AdapterObject,
+                                  int timeout );
+    BOOLEAN PacketSetBpf( LPADAPTER AdapterObject,
+                          struct bpf_program * fp );
+    BOOLEAN PacketSetLoopbackBehavior( LPADAPTER AdapterObject,
+                                       UINT LoopbackBehavior );
+    INT PacketSetSnapLen( LPADAPTER AdapterObject,
+                          int snaplen );
+    BOOLEAN PacketGetStats( LPADAPTER AdapterObject,
+                            struct bpf_stat * s );
+    BOOLEAN PacketGetStatsEx( LPADAPTER AdapterObject,
+                              struct bpf_stat * s );
+    BOOLEAN PacketSetBuff( LPADAPTER AdapterObject,
+                           int dim );
+    BOOLEAN PacketGetNetType( LPADAPTER AdapterObject,
+                              NetType * type );
+    LPADAPTER PacketOpenAdapter( PCHAR AdapterName );
+    BOOLEAN PacketSendPacket( LPADAPTER AdapterObject,
+                              LPPACKET pPacket,
+                              BOOLEAN Sync );
+    INT PacketSendPackets( LPADAPTER AdapterObject,
+                           PVOID PacketBuff,
+                           ULONG Size,
+                           BOOLEAN Sync );
+    LPPACKET PacketAllocatePacket( void );
+    VOID PacketInitPacket( LPPACKET lpPacket,
+                           PVOID Buffer,
+                           UINT Length );
+    VOID PacketFreePacket( LPPACKET lpPacket );
+    BOOLEAN PacketReceivePacket( LPADAPTER AdapterObject,
+                                 LPPACKET lpPacket,
+                                 BOOLEAN Sync );
+    BOOLEAN PacketSetHwFilter( LPADAPTER AdapterObject,
+                               ULONG Filter );
+    BOOLEAN PacketGetAdapterNames( PTSTR pStr,
+                                   PULONG BufferSize );
+    BOOLEAN PacketGetNetInfoEx( PCHAR AdapterName,
+                                npf_if_addr * buffer,
+                                PLONG NEntries );
+    BOOLEAN PacketRequest( LPADAPTER AdapterObject,
+                           BOOLEAN Set,
+                           PPACKET_OID_DATA OidData );
+    HANDLE PacketGetReadEvent( LPADAPTER AdapterObject );
+    BOOLEAN PacketSetDumpName( LPADAPTER AdapterObject,
+                               void * name,
+                               int len );
+    BOOLEAN PacketSetDumpLimits( LPADAPTER AdapterObject,
+                                 UINT maxfilesize,
+                                 UINT maxnpacks );
+    BOOLEAN PacketIsDumpEnded( LPADAPTER AdapterObject,
+                               BOOLEAN sync );
+    BOOL PacketStopDriver();
+    VOID PacketCloseAdapter( LPADAPTER lpAdapter );
+    BOOLEAN PacketStartOem( PCHAR errorString,
+                            UINT errorStringLength );
+    BOOLEAN PacketStartOemEx( PCHAR errorString,
+                              UINT errorStringLength,
+                              ULONG flags );
+    PAirpcapHandle PacketGetAirPcapHandle( LPADAPTER AdapterObject );
+
+/* */
+/* Used by PacketStartOemEx */
+/* */
+    #define PACKET_START_OEM_NO_NETMON    0x00000001
+
+    #ifdef __cplusplus
+        }
+    #endif
+
+#endif /*__PACKET32 */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/PacketData.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/PacketData.h
new file mode 100644
index 000000000..4b136febf
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/PacketData.h
@@ -0,0 +1,306 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+
+char pkt1[] = {
+    0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,
+    0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x30, 0x09, 0x9c, 0x40, 0x00, 0x80, 0x06,
+    0x6f, 0x07, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,
+    0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,
+    0xc7, 0x35, 0x00, 0x00, 0x00, 0x00, 0x70, 0x02,
+    0x40, 0x00, 0xdf, 0xab, 0x00, 0x00, 0x02, 0x04,
+    0x05, 0xb4, 0x01, 0x01, 0x04, 0x02
+};
+
+char pkt2[] = {
+    0x00, 0x14, 0x22, 0xcb, 0x18, 0x2d, 0x00, 0x01,
+    0x02, 0x45, 0x09, 0x11, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x2c, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06,
+    0xf8, 0xa6, 0xc0, 0xa8, 0x00, 0x0c, 0xc0, 0xa8,
+    0x00, 0xc8, 0x00, 0x50, 0x0f, 0xe2, 0x00, 0x00,
+    0x06, 0x68, 0x09, 0xe7, 0xc7, 0x36, 0x60, 0x12,
+    0x05, 0x92, 0x28, 0xca, 0x00, 0x00, 0x02, 0x04,
+    0x05, 0x92
+};
+
+char pkt3[] = {
+    0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,
+    0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x28, 0x09, 0x9e, 0x40, 0x00, 0x80, 0x06,
+    0x6f, 0x0d, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,
+    0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,
+    0xc7, 0x36, 0x00, 0x00, 0x06, 0x69, 0x50, 0x10,
+    0x42, 0xd8, 0x82, 0x3f, 0x00, 0x00
+};
+
+char pkt4[] = {
+    0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,
+    0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,
+    0x02, 0x27, 0x09, 0x9f, 0x40, 0x00, 0x80, 0x06,
+    0x6d, 0x0d, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,
+    0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,
+    0xc7, 0x36, 0x00, 0x00, 0x06, 0x69, 0x50, 0x18,
+    0x42, 0xd8, 0x84, 0x3e, 0x00, 0x00, 0x47, 0x45,
+    0x54, 0x20, 0x2f, 0x20, 0x48, 0x54, 0x54, 0x50,
+    0x2f, 0x31, 0x2e, 0x31, 0x0d, 0x0a, 0x41, 0x63,
+    0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x69, 0x6d,
+    0x61, 0x67, 0x65, 0x2f, 0x67, 0x69, 0x66, 0x2c,
+    0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x78,
+    0x2d, 0x78, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70,
+    0x2c, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f,
+    0x6a, 0x70, 0x65, 0x67, 0x2c, 0x20, 0x69, 0x6d,
+    0x61, 0x67, 0x65, 0x2f, 0x70, 0x6a, 0x70, 0x65,
+    0x67, 0x2c, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69,
+    0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76,
+    0x6e, 0x64, 0x2e, 0x6d, 0x73, 0x2d, 0x65, 0x78,
+    0x63, 0x65, 0x6c, 0x2c, 0x20, 0x61, 0x70, 0x70,
+    0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x2f, 0x6d, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x2c,
+    0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76, 0x6e, 0x64,
+    0x2e, 0x6d, 0x73, 0x2d, 0x70, 0x6f, 0x77, 0x65,
+    0x72, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2c, 0x20,
+    0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,
+    0x69, 0x6f, 0x6e, 0x2f, 0x78, 0x2d, 0x6d, 0x73,
+    0x2d, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x61, 0x70,
+    0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,
+    0x6e, 0x2f, 0x78, 0x2d, 0x6d, 0x73, 0x2d, 0x78,
+    0x62, 0x61, 0x70, 0x2c, 0x20, 0x61, 0x70, 0x70,
+    0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x2f, 0x76, 0x6e, 0x64, 0x2e, 0x6d, 0x73, 0x2d,
+    0x78, 0x70, 0x73, 0x64, 0x6f, 0x63, 0x75, 0x6d,
+    0x65, 0x6e, 0x74, 0x2c, 0x20, 0x61, 0x70, 0x70,
+    0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x2f, 0x78, 0x61, 0x6d, 0x6c, 0x2b, 0x78, 0x6d,
+    0x6c, 0x2c, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a,
+    0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x4c,
+    0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3a,
+    0x20, 0x65, 0x6e, 0x2d, 0x67, 0x62, 0x0d, 0x0a,
+    0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x45,
+    0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x3a,
+    0x20, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x20, 0x64,
+    0x65, 0x66, 0x6c, 0x61, 0x74, 0x65, 0x0d, 0x0a,
+    0x55, 0x73, 0x65, 0x72, 0x2d, 0x41, 0x67, 0x65,
+    0x6e, 0x74, 0x3a, 0x20, 0x4d, 0x6f, 0x7a, 0x69,
+    0x6c, 0x6c, 0x61, 0x2f, 0x34, 0x2e, 0x30, 0x20,
+    0x28, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69,
+    0x62, 0x6c, 0x65, 0x3b, 0x20, 0x4d, 0x53, 0x49,
+    0x45, 0x20, 0x36, 0x2e, 0x30, 0x3b, 0x20, 0x57,
+    0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x20, 0x4e,
+    0x54, 0x20, 0x35, 0x2e, 0x31, 0x3b, 0x20, 0x53,
+    0x56, 0x31, 0x3b, 0x20, 0x47, 0x6f, 0x6f, 0x67,
+    0x6c, 0x65, 0x54, 0x35, 0x3b, 0x20, 0x2e, 0x4e,
+    0x45, 0x54, 0x20, 0x43, 0x4c, 0x52, 0x20, 0x32,
+    0x2e, 0x30, 0x2e, 0x35, 0x30, 0x37, 0x32, 0x37,
+    0x3b, 0x20, 0x2e, 0x4e, 0x45, 0x54, 0x20, 0x43,
+    0x4c, 0x52, 0x20, 0x33, 0x2e, 0x30, 0x2e, 0x30,
+    0x34, 0x35, 0x30, 0x36, 0x2e, 0x36, 0x34, 0x38,
+    0x3b, 0x20, 0x2e, 0x4e, 0x45, 0x54, 0x20, 0x43,
+    0x4c, 0x52, 0x20, 0x33, 0x2e, 0x35, 0x2e, 0x32,
+    0x31, 0x30, 0x32, 0x32, 0x29, 0x0d, 0x0a, 0x48,
+    0x6f, 0x73, 0x74, 0x3a, 0x20, 0x31, 0x39, 0x32,
+    0x2e, 0x31, 0x36, 0x38, 0x2e, 0x30, 0x2e, 0x31,
+    0x32, 0x0d, 0x0a, 0x43, 0x6f, 0x6e, 0x6e, 0x65,
+    0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x4b,
+    0x65, 0x65, 0x70, 0x2d, 0x41, 0x6c, 0x69, 0x76,
+    0x65, 0x0d, 0x0a, 0x0d, 0x0a
+};
+
+char pkt5[] = {
+    0x00, 0x14, 0x22, 0xcb, 0x18, 0x2d, 0x00, 0x01,
+    0x02, 0x45, 0x09, 0x11, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x2c, 0x00, 0x02, 0x00, 0x00, 0x40, 0x06,
+    0xf8, 0xa5, 0xc0, 0xa8, 0x00, 0x0c, 0xc0, 0xa8,
+    0x00, 0xc8, 0x00, 0x50, 0x0f, 0xe2, 0x00, 0x00,
+    0x06, 0x68, 0x09, 0xe7, 0xc7, 0x36, 0x60, 0x12,
+    0x05, 0x92, 0x28, 0xca, 0x00, 0x00, 0x02, 0x04,
+    0x05, 0x92
+};
+
+char pkt6[] = {
+    0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,
+    0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x28, 0x09, 0xa1, 0x40, 0x00, 0x80, 0x06,
+    0x6f, 0x0a, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,
+    0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,
+    0xc9, 0x35, 0x00, 0x00, 0x06, 0x69, 0x50, 0x10,
+    0x42, 0xd8, 0x82, 0x3f, 0x00, 0x00
+};
+
+char pkt7[] = {
+    0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,
+    0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,
+    0x02, 0x27, 0x09, 0xa2, 0x40, 0x00, 0x80, 0x06,
+    0x6d, 0x0a, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,
+    0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,
+    0xc7, 0x36, 0x00, 0x00, 0x06, 0x69, 0x50, 0x18,
+    0x42, 0xd8, 0x84, 0x3e, 0x00, 0x00, 0x47, 0x45,
+    0x54, 0x20, 0x2f, 0x20, 0x48, 0x54, 0x54, 0x50,
+    0x2f, 0x31, 0x2e, 0x31, 0x0d, 0x0a, 0x41, 0x63,
+    0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x69, 0x6d,
+    0x61, 0x67, 0x65, 0x2f, 0x67, 0x69, 0x66, 0x2c,
+    0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x78,
+    0x2d, 0x78, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70,
+    0x2c, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f,
+    0x6a, 0x70, 0x65, 0x67, 0x2c, 0x20, 0x69, 0x6d,
+    0x61, 0x67, 0x65, 0x2f, 0x70, 0x6a, 0x70, 0x65,
+    0x67, 0x2c, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69,
+    0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76,
+    0x6e, 0x64, 0x2e, 0x6d, 0x73, 0x2d, 0x65, 0x78,
+    0x63, 0x65, 0x6c, 0x2c, 0x20, 0x61, 0x70, 0x70,
+    0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x2f, 0x6d, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x2c,
+    0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76, 0x6e, 0x64,
+    0x2e, 0x6d, 0x73, 0x2d, 0x70, 0x6f, 0x77, 0x65,
+    0x72, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2c, 0x20,
+    0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,
+    0x69, 0x6f, 0x6e, 0x2f, 0x78, 0x2d, 0x6d, 0x73,
+    0x2d, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x61, 0x70,
+    0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,
+    0x6e, 0x2f, 0x78, 0x2d, 0x6d, 0x73, 0x2d, 0x78,
+    0x62, 0x61, 0x70, 0x2c, 0x20, 0x61, 0x70, 0x70,
+    0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x2f, 0x76, 0x6e, 0x64, 0x2e, 0x6d, 0x73, 0x2d,
+    0x78, 0x70, 0x73, 0x64, 0x6f, 0x63, 0x75, 0x6d,
+    0x65, 0x6e, 0x74, 0x2c, 0x20, 0x61, 0x70, 0x70,
+    0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x2f, 0x78, 0x61, 0x6d, 0x6c, 0x2b, 0x78, 0x6d,
+    0x6c, 0x2c, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a,
+    0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x4c,
+    0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3a,
+    0x20, 0x65, 0x6e, 0x2d, 0x67, 0x62, 0x0d, 0x0a,
+    0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x45,
+    0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x3a,
+    0x20, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x20, 0x64,
+    0x65, 0x66, 0x6c, 0x61, 0x74, 0x65, 0x0d, 0x0a,
+    0x55, 0x73, 0x65, 0x72, 0x2d, 0x41, 0x67, 0x65,
+    0x6e, 0x74, 0x3a, 0x20, 0x4d, 0x6f, 0x7a, 0x69,
+    0x6c, 0x6c, 0x61, 0x2f, 0x34, 0x2e, 0x30, 0x20,
+    0x28, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69,
+    0x62, 0x6c, 0x65, 0x3b, 0x20, 0x4d, 0x53, 0x49,
+    0x45, 0x20, 0x36, 0x2e, 0x30, 0x3b, 0x20, 0x57,
+    0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x20, 0x4e,
+    0x54, 0x20, 0x35, 0x2e, 0x31, 0x3b, 0x20, 0x53,
+    0x56, 0x31, 0x3b, 0x20, 0x47, 0x6f, 0x6f, 0x67,
+    0x6c, 0x65, 0x54, 0x35, 0x3b, 0x20, 0x2e, 0x4e,
+    0x45, 0x54, 0x20, 0x43, 0x4c, 0x52, 0x20, 0x32,
+    0x2e, 0x30, 0x2e, 0x35, 0x30, 0x37, 0x32, 0x37,
+    0x3b, 0x20, 0x2e, 0x4e, 0x45, 0x54, 0x20, 0x43,
+    0x4c, 0x52, 0x20, 0x33, 0x2e, 0x30, 0x2e, 0x30,
+    0x34, 0x35, 0x30, 0x36, 0x2e, 0x36, 0x34, 0x38,
+    0x3b, 0x20, 0x2e, 0x4e, 0x45, 0x54, 0x20, 0x43,
+    0x4c, 0x52, 0x20, 0x33, 0x2e, 0x35, 0x2e, 0x32,
+    0x31, 0x30, 0x32, 0x32, 0x29, 0x0d, 0x0a, 0x48,
+    0x6f, 0x73, 0x74, 0x3a, 0x20, 0x31, 0x39, 0x32,
+    0x2e, 0x31, 0x36, 0x38, 0x2e, 0x30, 0x2e, 0x31,
+    0x32, 0x0d, 0x0a, 0x43, 0x6f, 0x6e, 0x6e, 0x65,
+    0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x4b,
+    0x65, 0x65, 0x70, 0x2d, 0x41, 0x6c, 0x69, 0x76,
+    0x65, 0x0d, 0x0a, 0x0d, 0x0a
+};
+
+char pkt8[] = {
+    0x00, 0x14, 0x22, 0xcb, 0x18, 0x2d, 0x00, 0x01,
+    0x02, 0x45, 0x09, 0x11, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x2c, 0x00, 0x03, 0x00, 0x00, 0x40, 0x06,
+    0xf8, 0xa4, 0xc0, 0xa8, 0x00, 0x0c, 0xc0, 0xa8,
+    0x00, 0xc8, 0x00, 0x50, 0x0f, 0xe2, 0x00, 0x00,
+    0x06, 0x68, 0x09, 0xe7, 0xc7, 0x36, 0x60, 0x12,
+    0x05, 0x92, 0x28, 0xca, 0x00, 0x00, 0x02, 0x04,
+    0x05, 0x92
+};
+
+char pkt9[] = {
+    0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,
+    0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x28, 0x09, 0xa3, 0x40, 0x00, 0x80, 0x06,
+    0x6f, 0x08, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,
+    0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,
+    0xc9, 0x35, 0x00, 0x00, 0x06, 0x69, 0x50, 0x10,
+    0x42, 0xd8, 0x82, 0x3f, 0x00, 0x00
+};
+
+char pkt10[] = {
+    0x00, 0x14, 0x22, 0xcb, 0x18, 0x2d, 0x00, 0x01,
+    0x02, 0x45, 0x09, 0x11, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x2c, 0x00, 0x04, 0x00, 0x00, 0x40, 0x06,
+    0xf8, 0xa3, 0xc0, 0xa8, 0x00, 0x0c, 0xc0, 0xa8,
+    0x00, 0xc8, 0x00, 0x50, 0x0f, 0xe2, 0x00, 0x00,
+    0x06, 0x68, 0x09, 0xe7, 0xc7, 0x36, 0x60, 0x12,
+    0x05, 0x92, 0x28, 0xca, 0x00, 0x00, 0x02, 0x04,
+    0x05, 0x92
+};
+
+char pkt11[] = {
+    0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,
+    0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x28, 0x09, 0xa6, 0x40, 0x00, 0x80, 0x06,
+    0x6f, 0x05, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,
+    0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,
+    0xc9, 0x35, 0x00, 0x00, 0x06, 0x69, 0x50, 0x10,
+    0x42, 0xd8, 0x82, 0x3f, 0x00, 0x00
+};
+
+char pkt12[] = {
+    0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,
+    0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,
+    0x00, 0x28, 0x09, 0xa7, 0x40, 0x00, 0x80, 0x06,
+    0x6f, 0x04, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,
+    0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,
+    0xc9, 0x35, 0x00, 0x00, 0x06, 0x69, 0x50, 0x14,
+    0x00, 0x00, 0x43, 0xf4, 0x00, 0x00
+};
+
+
+typedef struct
+{
+    char * pcData;
+    int iDataLen;
+} xPacketData;
+
+xPacketData xAllPackets[] =
+{
+    { pkt1,  sizeof( pkt1 )  },
+/*	{ pkt2, sizeof( pkt2 ) }, */
+    { pkt3,  sizeof( pkt3 )  },
+    { pkt4,  sizeof( pkt4 )  },
+/*	{ pkt5, sizeof( pkt5 ) }, */
+    { pkt6,  sizeof( pkt6 )  },
+    { pkt7,  sizeof( pkt7 )  },
+    { pkt8,  sizeof( pkt8 )  },
+    { pkt9,  sizeof( pkt9 )  },
+    { pkt10, sizeof( pkt10 ) },
+/*	{ pkt11, sizeof( pkt11 ) }, */
+/*	{ pkt12, sizeof( pkt12 ) }, */
+/*	{ pkt13, sizeof( pkt13 ) }, */
+/*	{ pkt14, sizeof( pkt14 ) }, */
+/*	{ pkt15, sizeof( pkt15 ) }, */
+/*	{ pkt16, sizeof( pkt16 ) }, */
+};
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/Win32-Extensions.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/Win32-Extensions.h
new file mode 100644
index 000000000..5d01b0f27
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/Win32-Extensions.h
@@ -0,0 +1,120 @@
+ /*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+
+#ifndef __WIN32_EXTENSIONS_H__
+    #define __WIN32_EXTENSIONS_H__
+
+    #ifdef __cplusplus
+        extern "C" {
+    #endif
+
+/* Definitions */
+
+/*!
+ * \brief A queue of raw packets that will be sent to the network with pcap_sendqueue_transmit().
+ */
+    struct pcap_send_queue
+    {
+        u_int maxlen;  /*/< Maximum size of the the queue, in bytes. This variable contains the size of the buffer field. */
+        u_int len;     /*/< Current size of the queue, in bytes. */
+        char * buffer; /*/< Buffer containing the packets to be sent. */
+    };
+
+    typedef struct pcap_send_queue      pcap_send_queue;
+
+/*!
+ * \brief This typedef is a support for the pcap_get_airpcap_handle() function
+ */
+    #if !defined( AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_ )
+        #define AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_
+        typedef struct _AirpcapHandle   * PAirpcapHandle;
+    #endif
+
+    #define     BPF_MEM_EX_IMM            0xc0
+    #define     BPF_MEM_EX_IND            0xe0
+
+/*used for ST*/
+    #define     BPF_MEM_EX                0xc0
+    #define     BPF_TME                   0x08
+
+    #define     BPF_LOOKUP                0x90
+    #define     BPF_EXECUTE               0xa0
+    #define     BPF_INIT                  0xb0
+    #define     BPF_VALIDATE              0xc0
+    #define     BPF_SET_ACTIVE            0xd0
+    #define     BPF_RESET                 0xe0
+    #define     BPF_SET_MEMORY            0x80
+    #define     BPF_GET_REGISTER_VALUE    0x70
+    #define     BPF_SET_REGISTER_VALUE    0x60
+    #define     BPF_SET_WORKING           0x50
+    #define     BPF_SET_ACTIVE_READ       0x40
+    #define     BPF_SET_AUTODELETION      0x30
+    #define     BPF_SEPARATION            0xff
+
+/* Prototypes */
+    pcap_send_queue * pcap_sendqueue_alloc( u_int memsize );
+
+    void pcap_sendqueue_destroy( pcap_send_queue * queue );
+
+    int pcap_sendqueue_queue( pcap_send_queue * queue,
+                              const struct pcap_pkthdr * pkt_header,
+                              const u_char * pkt_data );
+
+    u_int pcap_sendqueue_transmit( pcap_t * p,
+                                   pcap_send_queue * queue,
+                                   int sync );
+
+    HANDLE pcap_getevent( pcap_t * p );
+
+    struct pcap_stat * pcap_stats_ex( pcap_t * p,
+                                      int * pcap_stat_size );
+
+    int pcap_setuserbuffer( pcap_t * p,
+                            int size );
+
+    int pcap_live_dump( pcap_t * p,
+                        char * filename,
+                        int maxsize,
+                        int maxpacks );
+
+    int pcap_live_dump_ended( pcap_t * p,
+                              int sync );
+
+    int pcap_offline_filter( struct bpf_program * prog,
+                             const struct pcap_pkthdr * header,
+                             const u_char * pkt_data );
+
+    int pcap_start_oem( char * err_str,
+                        int flags );
+
+    PAirpcapHandle pcap_get_airpcap_handle( pcap_t * p );
+
+    #ifdef __cplusplus
+        }
+    #endif
+
+#endif /*__WIN32_EXTENSIONS_H__ */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/arch.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/arch.c
new file mode 100644
index 000000000..3342712aa
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/arch.c
@@ -0,0 +1,335 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/* WinPCap includes. */
+#include "pcap.h"
+#include "remote-ext.h"
+
+/* uIP includes. */
+#include "net/uip.h"
+#include "net/uip_arp.h"
+#include "net/clock-arch.h"
+
+/* FreeRTOS includes. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
+
+/*
+ * Query the computer the simulation is being executed on to find the network
+ * interfaces it has installed.
+ */
+static pcap_if_t * prvPrintAvailableNetworkInterfaces( void );
+
+/*
+ * Open the network interface.  The number of the interface to be opened is set
+ * by the configNETWORK_INTERFACE_TO_USE constant in FreeRTOSConfig.h.
+ */
+static void prvOpenSelectedNetworkInterface( pcap_if_t *pxAllNetworkInterfaces );
+
+/*
+ * Configure the capture filter to allow blocking reads, and to filter out
+ * packets that are not of interest to this demo.
+ */
+static void prvConfigureCaptureBehaviour( void );
+
+pcap_t *pxOpenedInterfaceHandle = NULL;
+LARGE_INTEGER freq, sys_start_time;
+
+#define archNUM_BUFFERS	5
+#define archNUM_BUFFER_POINTERS ( archNUM_BUFFERS - 1 )
+
+static void prvInterruptSimulator( void *pvParameters );
+
+static unsigned char ucEthernetBuffer[ archNUM_BUFFERS ][ UIP_CONF_BUFFER_SIZE ];
+static unsigned char *pucEthernetBufferPointers[ archNUM_BUFFER_POINTERS ];
+
+static long lLengthOfDataInBuffer[ archNUM_BUFFER_POINTERS ] = { 0 };
+static unsigned char ucNextBufferToFill = 0U, ucNextBufferToProcess = 0U;
+
+unsigned char *uip_buf = NULL;
+char cErrorBuffer[PCAP_ERRBUF_SIZE];
+
+void vNetifTx( void )
+{
+	pcap_sendpacket( pxOpenedInterfaceHandle, uip_buf, uip_len );
+	pcap_sendpacket( pxOpenedInterfaceHandle, uip_buf, uip_len );
+}
+/*-----------------------------------------------------------*/
+
+UBaseType_t uxNetifRx( void )
+{
+UBaseType_t xDataLen;
+unsigned char *pucTemp;
+
+	/* Check there is really data available. */
+	xDataLen = lLengthOfDataInBuffer[ ucNextBufferToProcess ];
+	if( xDataLen != 0L )
+	{
+
+		/* The buffer pointed to by uip_buf is going to change.  Remember which
+		buffer uip_buf is currently pointing to. */
+		pucTemp = uip_buf;
+
+		/* Point uip_buf at the next buffer that contains data. */
+		uip_buf = pucEthernetBufferPointers[ ucNextBufferToProcess ];
+
+		/* The buffer pointed to by 
+		pucEthernetBufferPointeres[ ucNextBufferToProcess ] is now in use by
+		uip_buf, but the buffer uip_buf was pointing to on entry to this
+		function is free.  Set 
+		pucEthernetBufferPointeres[ ucNextBufferToProcess ] to the free 
+		buffer. */
+		pucEthernetBufferPointers[ ucNextBufferToProcess ] = pucTemp;
+		lLengthOfDataInBuffer[ ucNextBufferToProcess ] = 0L;
+
+		ucNextBufferToProcess++;
+		if( ucNextBufferToProcess >= archNUM_BUFFER_POINTERS )
+		{
+			ucNextBufferToProcess = 0L;
+		}
+	}
+
+	return xDataLen;
+}
+/*-----------------------------------------------------------*/
+
+BaseType_t xNetifInit( void )
+{
+BaseType_t x;
+pcap_if_t *pxAllNetworkInterfaces;
+
+	/* Allocate a free buffer to each buffer pointer. */
+	for( x = 0; x < sizeof( pucEthernetBufferPointers ) / sizeof( unsigned char * ); x++ )
+	{
+		pucEthernetBufferPointers[ x ] = &( ucEthernetBuffer[ x ][ 0 ] );
+	}
+
+	/* Start with uip_buf pointing to a buffer that is not referenced from the
+	pucEthernetBufferPointers[] array. */
+	uip_buf = &( ucEthernetBuffer[ archNUM_BUFFERS - 1 ][ 0 ] );
+
+	/* Query the computer the simulation is being executed on to find the 
+	network interfaces it has installed. */
+	pxAllNetworkInterfaces = prvPrintAvailableNetworkInterfaces();
+	
+	/* Open the network interface.  The number of the interface to be opened is 
+	set by the configNETWORK_INTERFACE_TO_USE constant in FreeRTOSConfig.h.
+	Calling this function will set the pxOpenedInterfaceHandle variable.  If,
+	after calling this function, pxOpenedInterfaceHandle is equal to NULL, then
+	the interface could not be opened. */
+	if( pxAllNetworkInterfaces != NULL )
+	{
+		prvOpenSelectedNetworkInterface( pxAllNetworkInterfaces );
+	}
+	
+
+	return x;
+}
+/*-----------------------------------------------------------*/
+
+static pcap_if_t * prvPrintAvailableNetworkInterfaces( void )
+{    
+pcap_if_t * pxAllNetworkInterfaces = NULL, *xInterface;
+long lInterfaceNumber = 1;
+
+    if( pcap_findalldevs_ex( PCAP_SRC_IF_STRING, NULL, &pxAllNetworkInterfaces, cErrorBuffer ) == -1 )
+    {
+        printf( "\r\nCould not obtain a list of network interfaces\r\n%s\r\n", cErrorBuffer );
+        pxAllNetworkInterfaces = NULL;
+    }
+
+	if( pxAllNetworkInterfaces != NULL )
+	{
+		/* Print out the list of network interfaces.  The first in the list
+		is interface '1', not interface '0'. */
+		for( xInterface = pxAllNetworkInterfaces; xInterface != NULL; xInterface = xInterface->next )
+		{
+			printf( "%d. %s", lInterfaceNumber, xInterface->name );
+			
+			if( xInterface->description != NULL )
+			{
+				printf( " (%s)\r\n", xInterface->description );
+			}
+			else
+			{
+				printf( " (No description available)\r\n") ;
+			}
+			
+			lInterfaceNumber++;
+		}
+	}
+
+    if( lInterfaceNumber == 1 )
+    {
+		/* The interface number was never incremented, so the above for() loop
+		did not execute meaning no interfaces were found. */
+        printf( " \r\nNo network interfaces were found.\r\n" );
+        pxAllNetworkInterfaces = NULL;
+    }
+
+	printf( "\r\nThe interface that will be opened is set by configNETWORK_INTERFACE_TO_USE which should be defined in FreeRTOSConfig.h\r\n" );
+	printf( "Attempting to open interface number %d.\r\n", configNETWORK_INTERFACE_TO_USE );
+	
+    if( ( configNETWORK_INTERFACE_TO_USE < 1L ) || ( configNETWORK_INTERFACE_TO_USE > lInterfaceNumber ) )
+    {
+        printf("\r\nconfigNETWORK_INTERFACE_TO_USE is not in the valid range.\r\n" );
+		
+		if( pxAllNetworkInterfaces != NULL )
+		{
+			/* Free the device list, as no devices are going to be opened. */
+			pcap_freealldevs( pxAllNetworkInterfaces );
+			pxAllNetworkInterfaces = NULL;
+		}
+    }
+
+	return pxAllNetworkInterfaces;
+}
+/*-----------------------------------------------------------*/
+
+static void prvOpenSelectedNetworkInterface( pcap_if_t *pxAllNetworkInterfaces )
+{
+pcap_if_t *xInterface;
+long x;
+
+    /* Walk the list of devices until the selected device is located. */
+	xInterface = pxAllNetworkInterfaces;
+    for( x = 0L; x < ( configNETWORK_INTERFACE_TO_USE - 1L ); x++ )
+	{
+		xInterface = xInterface->next;
+	}
+
+    /* Open the selected interface. */
+	pxOpenedInterfaceHandle = pcap_open(	xInterface->name,          	/* The name of the selected interface. */
+											UIP_CONF_BUFFER_SIZE, 		/* The size of the packet to capture. */
+											PCAP_OPENFLAG_PROMISCUOUS,	/* Open in promiscious mode as the MAC and 
+																		IP address is going to be "simulated", and 
+																		not be the real MAC and IP address.  This allows
+																		trafic to the simulated IP address to be routed
+																		to uIP, and trafic to the real IP address to be
+																		routed to the Windows TCP/IP stack. */
+											0xfffffffL,             	/* The read time out.  This is going to block
+																		until data is available. */
+											NULL,             			/* No authentication is required as this is
+																		not a remote capture session. */
+											cErrorBuffer            
+									   );
+									   
+    if ( pxOpenedInterfaceHandle == NULL )
+    {
+        printf( "\r\n%s is not supported by WinPcap and cannot be opened\r\n", xInterface->name );
+    }
+	else
+	{
+		/* Configure the capture filter to allow blocking reads, and to filter 
+		out packets that are not of interest to this demo. */
+		prvConfigureCaptureBehaviour();
+	}
+
+	/* The device list is no longer required. */
+	pcap_freealldevs( pxAllNetworkInterfaces );
+}
+/*-----------------------------------------------------------*/
+
+static void prvConfigureCaptureBehaviour( void )
+{
+struct bpf_program xFilterCode;
+const long lMinBytesToCopy = 10L, lBlocking = 0L;
+unsigned long ulNetMask;
+
+	/* Unblock a read as soon as anything is received. */
+	pcap_setmintocopy( pxOpenedInterfaceHandle, lMinBytesToCopy );
+
+	/* Allow blocking. */
+	pcap_setnonblock( pxOpenedInterfaceHandle, lBlocking, cErrorBuffer );
+
+	/* Set up a filter so only the packets of interest are passed to the uIP
+	stack.  cErrorBuffer is used for convenience to create the string.  Don't
+	confuse this with an error message. */
+	sprintf( cErrorBuffer, "broadcast or multicast or host %d.%d.%d.%d", configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 );
+
+	ulNetMask = ( configNET_MASK3 << 24UL ) | ( configNET_MASK2 << 16UL ) | ( configNET_MASK1 << 8L ) | configNET_MASK0;
+
+	if( pcap_compile(pxOpenedInterfaceHandle, &xFilterCode, cErrorBuffer, 1, ulNetMask ) < 0 )
+    {
+        printf("\r\nThe packet filter string is invalid\r\n" );
+    }
+	else
+	{    
+		if( pcap_setfilter( pxOpenedInterfaceHandle, &xFilterCode ) < 0 )
+		{
+			printf( "\r\nAn error occurred setting the packet filter.\r\n" );
+		}
+	}
+
+	/* Create a task that simulates an interrupt in a real system.  This will
+	block waiting for packets, then send a message to the uIP task when data
+	is available. */
+	xTaskCreate( prvInterruptSimulator, ( signed char * ) "MAC_ISR", configMINIMAL_STACK_SIZE, NULL, ( configuIP_TASK_PRIORITY - 1 ), NULL );
+}
+/*-----------------------------------------------------------*/
+
+static void prvInterruptSimulator( void *pvParameters )
+{
+static struct pcap_pkthdr *pxHeader;
+const unsigned char *pucPacketData;
+extern QueueHandle_t xEMACEventQueue;
+const unsigned long ulRxEvent = uipETHERNET_RX_EVENT;
+long lResult;
+
+	/* Just to kill the compiler warning. */
+	( void ) pvParameters;
+
+	for( ;; )
+	{
+		/* Get the next packet. */
+		lResult = pcap_next_ex( pxOpenedInterfaceHandle, &pxHeader, &pucPacketData );
+		if( lResult )
+		{
+			/* Is the next buffer into which data should be placed free? */
+			if( lLengthOfDataInBuffer[ ucNextBufferToFill ] == 0L )
+			{
+				/* Copy the data from the captured packet into the buffer. */
+				memcpy( pucEthernetBufferPointers[ ucNextBufferToFill ], pucPacketData, pxHeader->len );
+
+				/* Note the amount of data that was copied. */
+				lLengthOfDataInBuffer[ ucNextBufferToFill ] = pxHeader->len;
+
+				/* Move onto the next buffer, wrapping around if necessary. */
+				ucNextBufferToFill++;
+				if( ucNextBufferToFill >= archNUM_BUFFER_POINTERS )
+				{
+					ucNextBufferToFill = 0U;
+				}
+
+				/* Data was received and stored.  Send a message to the uIP task
+				to let it know. */
+				xQueueSendToBack( xEMACEventQueue, &ulRxEvent, portMAX_DELAY );
+			}
+		}
+	}
+}
+
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/bittypes.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/bittypes.h
new file mode 100644
index 000000000..e2439026e
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/bittypes.h
@@ -0,0 +1,135 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef _BITTYPES_H
+#define _BITTYPES_H
+
+#ifndef HAVE_U_INT8_T
+
+    #if SIZEOF_CHAR == 1
+        typedef unsigned char   u_int8_t;
+        typedef signed char     _int8_t;
+    #elif SIZEOF_INT == 1
+        typedef unsigned int    u_int8_t;
+        typedef signed int      int8_t;
+    #else /* XXX */
+        #error "there's no appropriate type for u_int8_t"
+    #endif
+    #define HAVE_U_INT8_T    1
+    #define HAVE_INT8_T      1
+
+#endif /* HAVE_U_INT8_T */
+
+#ifndef HAVE_U_INT16_T
+
+    #if SIZEOF_SHORT == 2
+        typedef unsigned short   u_int16_t;
+        typedef signed short     _int16_t;
+    #elif SIZEOF_INT == 2
+        typedef unsigned int     u_int16_t;
+        typedef signed int       int16_t;
+    #elif SIZEOF_CHAR == 2
+        typedef unsigned char    u_int16_t;
+        typedef signed char      int16_t;
+    #else /* XXX */
+        #error "there's no appropriate type for u_int16_t"
+    #endif /* if SIZEOF_SHORT == 2 */
+    #define HAVE_U_INT16_T    1
+    #define HAVE_INT16_T      1
+
+#endif /* HAVE_U_INT16_T */
+
+#ifndef HAVE_U_INT32_T
+
+    #if SIZEOF_INT == 4
+        typedef unsigned int     u_int32_t;
+        typedef signed int       _int32_t;
+    #elif SIZEOF_LONG == 4
+        typedef unsigned long    u_int32_t;
+        typedef signed long      int32_t;
+    #elif SIZEOF_SHORT == 4
+        typedef unsigned short   u_int32_t;
+        typedef signed short     int32_t;
+    #else /* XXX */
+        #error "there's no appropriate type for u_int32_t"
+    #endif /* if SIZEOF_INT == 4 */
+    #define HAVE_U_INT32_T    1
+    #define HAVE_INT32_T      1
+
+#endif /* HAVE_U_INT32_T */
+
+#ifndef HAVE_U_INT64_T
+    #if SIZEOF_LONG_LONG == 8
+        typedef unsigned long long   u_int64_t;
+        typedef long long            int64_t;
+    #elif defined( _MSC_EXTENSIONS )
+        typedef unsigned _int64      u_int64_t;
+        typedef _int64               int64_t;
+    #elif SIZEOF_INT == 8
+        typedef unsigned int         u_int64_t;
+    #elif SIZEOF_LONG == 8
+        typedef unsigned long        u_int64_t;
+    #elif SIZEOF_SHORT == 8
+        typedef unsigned short       u_int64_t;
+    #else /* XXX */
+        #error "there's no appropriate type for u_int64_t"
+    #endif /* if SIZEOF_LONG_LONG == 8 */
+
+#endif /* HAVE_U_INT64_T */
+
+#ifndef PRId64
+    #ifdef _MSC_EXTENSIONS
+        #define PRId64    "I64d"
+    #else /* _MSC_EXTENSIONS */
+        #define PRId64    "lld"
+    #endif /* _MSC_EXTENSIONS */
+#endif /* PRId64 */
+
+#ifndef PRIo64
+    #ifdef _MSC_EXTENSIONS
+        #define PRIo64    "I64o"
+    #else /* _MSC_EXTENSIONS */
+        #define PRIo64    "llo"
+    #endif /* _MSC_EXTENSIONS */
+#endif /* PRIo64 */
+
+#ifndef PRIx64
+    #ifdef _MSC_EXTENSIONS
+        #define PRIx64    "I64x"
+    #else /* _MSC_EXTENSIONS */
+        #define PRIx64    "llx"
+    #endif /* _MSC_EXTENSIONS */
+#endif /* PRIx64 */
+
+#ifndef PRIu64
+    #ifdef _MSC_EXTENSIONS
+        #define PRIu64    "I64u"
+    #else /* _MSC_EXTENSIONS */
+        #define PRIu64    "llu"
+    #endif /* _MSC_EXTENSIONS */
+#endif /* PRIu64 */
+
+#endif /* _BITTYPES_H */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/ip6_misc.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/ip6_misc.h
new file mode 100644
index 000000000..c38bdf36b
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/ip6_misc.h
@@ -0,0 +1,164 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#include <winsock2.h>
+
+#include <ws2tcpip.h>
+
+#ifndef __MINGW32__
+    #define IN_MULTICAST( a )    IN_CLASSD( a )
+#endif
+
+#define IN_EXPERIMENTAL( a )     ( ( ( ( u_int32_t ) ( a ) ) & 0xf0000000 ) == 0xf0000000 )
+
+#define IN_LOOPBACKNET    127
+
+#if defined( __MINGW32__ ) && defined( DEFINE_ADDITIONAL_IPV6_STUFF )
+/* IPv6 address */
+    struct in6_addr
+    {
+        union
+        {
+            u_int8_t u6_addr8[ 16 ];
+            u_int16_t u6_addr16[ 8 ];
+            u_int32_t u6_addr32[ 4 ];
+        }
+        in6_u;
+    #define s6_addr                  in6_u.u6_addr8
+    #define s6_addr16                in6_u.u6_addr16
+    #define s6_addr32                in6_u.u6_addr32
+    #define s6_addr64                in6_u.u6_addr64
+    };
+
+    #define IN6ADDR_ANY_INIT         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+    #define IN6ADDR_LOOPBACK_INIT    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }
+#endif /* __MINGW32__ */
+
+
+#if ( defined _MSC_VER ) || ( defined( __MINGW32__ ) && defined( DEFINE_ADDITIONAL_IPV6_STUFF ) )
+    typedef unsigned short sa_family_t;
+#endif
+
+
+#if defined( __MINGW32__ ) && defined( DEFINE_ADDITIONAL_IPV6_STUFF )
+
+    #define __SOCKADDR_COMMON( sa_prefix ) \
+    sa_family_t sa_prefix ## family
+
+/* Ditto, for IPv6.  */
+    struct sockaddr_in6
+    {
+        __SOCKADDR_COMMON( sin6_ );
+        u_int16_t sin6_port;       /* Transport layer port # */
+        u_int32_t sin6_flowinfo;   /* IPv6 flow information */
+        struct in6_addr sin6_addr; /* IPv6 address */
+    };
+
+    #define IN6_IS_ADDR_V4MAPPED( a )                                                       \
+    ( ( ( ( u_int32_t * ) ( a ) )[ 0 ] == 0 ) && ( ( ( u_int32_t * ) ( a ) )[ 1 ] == 0 ) && \
+      ( ( ( u_int32_t * ) ( a ) )[ 2 ] == htonl( 0xffff ) ) )
+
+    #define IN6_IS_ADDR_MULTICAST( a )    ( ( ( u_int8_t * ) ( a ) )[ 0 ] == 0xff )
+
+    #define IN6_IS_ADDR_LINKLOCAL( a ) \
+    ( ( ( ( u_int32_t * ) ( a ) )[ 0 ] & htonl( 0xffc00000 ) ) == htonl( 0xfe800000 ) )
+
+    #define IN6_IS_ADDR_LOOPBACK( a )                                               \
+    ( ( ( u_int32_t * ) ( a ) )[ 0 ] == 0 && ( ( u_int32_t * ) ( a ) )[ 1 ] == 0 && \
+      ( ( u_int32_t * ) ( a ) )[ 2 ] == 0 && ( ( u_int32_t * ) ( a ) )[ 3 ] == htonl( 1 ) )
+#endif /* __MINGW32__ */
+
+#define ip6_vfc                  ip6_ctlun.ip6_un2_vfc
+#define ip6_flow                 ip6_ctlun.ip6_un1.ip6_un1_flow
+#define ip6_plen                 ip6_ctlun.ip6_un1.ip6_un1_plen
+#define ip6_nxt                  ip6_ctlun.ip6_un1.ip6_un1_nxt
+#define ip6_hlim                 ip6_ctlun.ip6_un1.ip6_un1_hlim
+#define ip6_hops                 ip6_ctlun.ip6_un1.ip6_un1_hlim
+
+#define nd_rd_type               nd_rd_hdr.icmp6_type
+#define nd_rd_code               nd_rd_hdr.icmp6_code
+#define nd_rd_cksum              nd_rd_hdr.icmp6_cksum
+#define nd_rd_reserved           nd_rd_hdr.icmp6_data32[ 0 ]
+
+/*
+ *	IPV6 extension headers
+ */
+#define IPPROTO_HOPOPTS          0   /* IPv6 hop-by-hop options	*/
+#define IPPROTO_IPV6             41  /* IPv6 header.  */
+#define IPPROTO_ROUTING          43  /* IPv6 routing header		*/
+#define IPPROTO_FRAGMENT         44  /* IPv6 fragmentation header	*/
+#define IPPROTO_ESP              50  /* encapsulating security payload */
+#define IPPROTO_AH               51  /* authentication header	*/
+#define IPPROTO_ICMPV6           58  /* ICMPv6			*/
+#define IPPROTO_NONE             59  /* IPv6 no next header		*/
+#define IPPROTO_DSTOPTS          60  /* IPv6 destination options	*/
+#define IPPROTO_PIM              103 /* Protocol Independent Multicast.  */
+
+#define  IPV6_RTHDR_TYPE_0       0
+
+/* Option types and related macros */
+#define IP6OPT_PAD1              0x00 /* 00 0 00000 */
+#define IP6OPT_PADN              0x01 /* 00 0 00001 */
+#define IP6OPT_JUMBO             0xC2 /* 11 0 00010 = 194 */
+#define IP6OPT_JUMBO_LEN         6
+#define IP6OPT_ROUTER_ALERT      0x05 /* 00 0 00101 */
+
+#define IP6OPT_RTALERT_LEN       4
+#define IP6OPT_RTALERT_MLD       0 /* Datagram contains an MLD message */
+#define IP6OPT_RTALERT_RSVP      1 /* Datagram contains an RSVP message */
+#define IP6OPT_RTALERT_ACTNET    2 /* contains an Active Networks msg */
+#define IP6OPT_MINLEN            2
+
+#define IP6OPT_BINDING_UPDATE    0xc6 /* 11 0 00110 */
+#define IP6OPT_BINDING_ACK       0x07 /* 00 0 00111 */
+#define IP6OPT_BINDING_REQ       0x08 /* 00 0 01000 */
+#define IP6OPT_HOME_ADDRESS      0xc9 /* 11 0 01001 */
+#define IP6OPT_EID               0x8a /* 10 0 01010 */
+
+#define IP6OPT_TYPE( o )    ( ( o ) & 0xC0 )
+#define IP6OPT_TYPE_SKIP         0x00
+#define IP6OPT_TYPE_DISCARD      0x40
+#define IP6OPT_TYPE_FORCEICMP    0x80
+#define IP6OPT_TYPE_ICMP         0xC0
+
+#define IP6OPT_MUTABLE           0x20
+
+
+#if defined( __MINGW32__ ) && defined( DEFINE_ADDITIONAL_IPV6_STUFF )
+    #ifndef EAI_ADDRFAMILY
+        struct addrinfo
+        {
+            int ai_flags;              /* AI_PASSIVE, AI_CANONNAME */
+            int ai_family;             /* PF_xxx */
+            int ai_socktype;           /* SOCK_xxx */
+            int ai_protocol;           /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
+            size_t ai_addrlen;         /* length of ai_addr */
+            char * ai_canonname;       /* canonical name for hostname */
+            struct sockaddr * ai_addr; /* binary address */
+            struct addrinfo * ai_next; /* next structure in linked list */
+        };
+    #endif /* ifndef EAI_ADDRFAMILY */
+#endif /* __MINGW32__ */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/netif.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/netif.h
new file mode 100644
index 000000000..b017d930c
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/netif.h
@@ -0,0 +1,51 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef NET_IF_H
+#define NET_IF_H
+
+/*
+ * Send uip_len bytes from uip_buf to the network interface selected by the
+ * configNETWORK_INTERFACE_TO_USE constant (defined in FreeRTOSConfig.h).
+ */
+void vNetifTx( void );
+
+/*
+ * Receive bytes from the network interface selected by the
+ * configNETWORK_INTERFACE_TO_USE constant (defined in FreeRTOSConfig.h).  The
+ * bytes are placed in uip_buf.  The number of bytes copied into uip_buf is
+ * returned.
+ */
+UBaseType_t uxNetifRx( void );
+
+/*
+ * Prepare a packet capture session.  This will print out all the network
+ * interfaces available, and the one actually used is set by the
+ * configNETWORK_INTERFACE_TO_USE constant that is defined in
+ * FreeRTOSConfig.h. */
+BaseType_t xNetifInit( void );
+
+#endif /* NET_IF_H */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap-bpf.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap-bpf.h
new file mode 100644
index 000000000..2e4d0592b
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap-bpf.h
@@ -0,0 +1,33 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/*
+ * For backwards compatibility.
+ *
+ * Note to OS vendors: do NOT get rid of this file!  Some applications
+ * might expect to be able to include <pcap-bpf.h>.
+ */
+#include <pcap/bpf.h>
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap-namedb.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap-namedb.h
new file mode 100644
index 000000000..7f5251512
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap-namedb.h
@@ -0,0 +1,33 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/*
+ * For backwards compatibility.
+ *
+ * Note to OS vendors: do NOT get rid of this file!  Some applications
+ * might expect to be able to include <pcap-namedb.h>.
+ */
+#include <pcap/namedb.h>
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap-stdinc.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap-stdinc.h
new file mode 100644
index 000000000..d45539d08
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap-stdinc.h
@@ -0,0 +1,86 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#define SIZEOF_CHAR             1
+#define SIZEOF_SHORT            2
+#define SIZEOF_INT              4
+#ifndef _MSC_EXTENSIONS
+    #define SIZEOF_LONG_LONG    8
+#endif
+
+/*
+ * Avoids a compiler warning in case this was already defined
+ * (someone defined _WINSOCKAPI_ when including 'windows.h', in order
+ * to prevent it from including 'winsock.h')
+ */
+#ifdef _WINSOCKAPI_
+    #undef _WINSOCKAPI_
+#endif
+#include <winsock2.h>
+
+#include <fcntl.h>
+
+#include "bittypes.h"
+#include <time.h>
+#include <io.h>
+
+#ifndef __MINGW32__
+    #include "IP6_misc.h"
+#endif
+
+#define caddr_t          char *
+
+#if _MSC_VER < 1500
+    #define snprintf     _snprintf
+    #define vsnprintf    _vsnprintf
+    #define strdup       _strdup
+#endif
+
+#define inline           __inline
+
+#ifdef __MINGW32__
+    #include <stdint.h>
+#else /*__MINGW32__*/
+/* MSVC compiler */
+    #ifndef _UINTPTR_T_DEFINED
+        #ifdef  _WIN64
+            typedef unsigned __int64    uintptr_t;
+        #else
+            typedef _W64 unsigned int   uintptr_t;
+        #endif
+        #define _UINTPTR_T_DEFINED
+    #endif
+
+    #ifndef _INTPTR_T_DEFINED
+        #ifdef  _WIN64
+            typedef __int64    intptr_t;
+        #else
+            typedef _W64 int   intptr_t;
+        #endif
+        #define _INTPTR_T_DEFINED
+    #endif
+
+#endif /*__MINGW32__*/
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap.h
new file mode 100644
index 000000000..6e996451c
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap.h
@@ -0,0 +1,36 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/*
+ * For backwards compatibility.
+ *
+ * Note to OS vendors: do NOT get rid of this file!  Many applications
+ * expect to be able to include <pcap.h>, and at least some of them
+ * go through contortions in their configure scripts to try to detect
+ * OSes that have "helpfully" moved pcap.h to <pcap/pcap.h> without
+ * leaving behind a <pcap.h> file.
+ */
+#include <pcap/pcap.h>
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/bluetooth.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/bluetooth.h
new file mode 100644
index 000000000..52a5fb38f
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/bluetooth.h
@@ -0,0 +1,39 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+ 
+#ifndef _PCAP_BLUETOOTH_STRUCTS_H__
+#define _PCAP_BLUETOOTH_STRUCTS_H__
+
+/*
+ * Header prepended libpcap to each bluetooth h:4 frame.
+ * fields are in network byte order
+ */
+typedef struct _pcap_bluetooth_h4_header {
+	u_int32_t direction; /* if first bit is set direction is incoming */
+} pcap_bluetooth_h4_header;
+
+
+#endif
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/bpf.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/bpf.h
new file mode 100644
index 000000000..ca91e5ab5
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/bpf.h
@@ -0,0 +1,918 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/*
+ * This is libpcap's cut-down version of bpf.h; it includes only
+ * the stuff needed for the code generator and the userland BPF
+ * interpreter, and the libpcap APIs for setting filters, etc..
+ *
+ * "pcap-bpf.c" will include the native OS version, as it deals with
+ * the OS's BPF implementation.
+ *
+ * XXX - should this all just be moved to "pcap.h"?
+ */
+
+#ifndef BPF_MAJOR_VERSION
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BSD style release date */
+#define BPF_RELEASE 199606
+
+#ifdef MSDOS /* must be 32-bit */
+typedef long          bpf_int32;
+typedef unsigned long bpf_u_int32;
+#else
+typedef	int bpf_int32;
+typedef	u_int bpf_u_int32;
+#endif
+
+/*
+ * Alignment macros.  BPF_WORDALIGN rounds up to the next 
+ * even multiple of BPF_ALIGNMENT. 
+ */
+#ifndef __NetBSD__
+#define BPF_ALIGNMENT sizeof(bpf_int32)
+#else
+#define BPF_ALIGNMENT sizeof(long)
+#endif
+#define BPF_WORDALIGN(x) (((x)+(BPF_ALIGNMENT-1))&~(BPF_ALIGNMENT-1))
+
+#define BPF_MAXBUFSIZE 0x8000
+#define BPF_MINBUFSIZE 32
+
+/*
+ * Structure for "pcap_compile()", "pcap_setfilter()", etc..
+ */
+struct bpf_program {
+	u_int bf_len;
+	struct bpf_insn *bf_insns;
+};
+ 
+/*
+ * Struct return by BIOCVERSION.  This represents the version number of 
+ * the filter language described by the instruction encodings below.
+ * bpf understands a program iff kernel_major == filter_major &&
+ * kernel_minor >= filter_minor, that is, if the value returned by the
+ * running kernel has the same major number and a minor number equal
+ * equal to or less than the filter being downloaded.  Otherwise, the
+ * results are undefined, meaning an error may be returned or packets
+ * may be accepted haphazardly.
+ * It has nothing to do with the source code version.
+ */
+struct bpf_version {
+	u_short bv_major;
+	u_short bv_minor;
+};
+/* Current version number of filter architecture. */
+#define BPF_MAJOR_VERSION 1
+#define BPF_MINOR_VERSION 1
+
+/*
+ * Data-link level type codes.
+ *
+ * Do *NOT* add new values to this list without asking
+ * "tcpdump-workers@lists.tcpdump.org" for a value.  Otherwise, you run
+ * the risk of using a value that's already being used for some other
+ * purpose, and of having tools that read libpcap-format captures not
+ * being able to handle captures with your new DLT_ value, with no hope
+ * that they will ever be changed to do so (as that would destroy their
+ * ability to read captures using that value for that other purpose).
+ */
+
+/*
+ * These are the types that are the same on all platforms, and that
+ * have been defined by <net/bpf.h> for ages.
+ */
+#define DLT_NULL	0	/* BSD loopback encapsulation */
+#define DLT_EN10MB	1	/* Ethernet (10Mb) */
+#define DLT_EN3MB	2	/* Experimental Ethernet (3Mb) */
+#define DLT_AX25	3	/* Amateur Radio AX.25 */
+#define DLT_PRONET	4	/* Proteon ProNET Token Ring */
+#define DLT_CHAOS	5	/* Chaos */
+#define DLT_IEEE802	6	/* 802.5 Token Ring */
+#define DLT_ARCNET	7	/* ARCNET, with BSD-style header */
+#define DLT_SLIP	8	/* Serial Line IP */
+#define DLT_PPP		9	/* Point-to-point Protocol */
+#define DLT_FDDI	10	/* FDDI */
+
+/*
+ * These are types that are different on some platforms, and that
+ * have been defined by <net/bpf.h> for ages.  We use #ifdefs to
+ * detect the BSDs that define them differently from the traditional
+ * libpcap <net/bpf.h>
+ *
+ * XXX - DLT_ATM_RFC1483 is 13 in BSD/OS, and DLT_RAW is 14 in BSD/OS,
+ * but I don't know what the right #define is for BSD/OS.
+ */
+#define DLT_ATM_RFC1483	11	/* LLC-encapsulated ATM */
+
+#ifdef __OpenBSD__
+#define DLT_RAW		14	/* raw IP */
+#else
+#define DLT_RAW		12	/* raw IP */
+#endif
+
+/*
+ * Given that the only OS that currently generates BSD/OS SLIP or PPP
+ * is, well, BSD/OS, arguably everybody should have chosen its values
+ * for DLT_SLIP_BSDOS and DLT_PPP_BSDOS, which are 15 and 16, but they
+ * didn't.  So it goes.
+ */
+#if defined(__NetBSD__) || defined(__FreeBSD__)
+#ifndef DLT_SLIP_BSDOS
+#define DLT_SLIP_BSDOS	13	/* BSD/OS Serial Line IP */
+#define DLT_PPP_BSDOS	14	/* BSD/OS Point-to-point Protocol */
+#endif
+#else
+#define DLT_SLIP_BSDOS	15	/* BSD/OS Serial Line IP */
+#define DLT_PPP_BSDOS	16	/* BSD/OS Point-to-point Protocol */
+#endif
+
+/*
+ * 17 is used for DLT_OLD_PFLOG in OpenBSD;
+ *     OBSOLETE: DLT_PFLOG is 117 in OpenBSD now as well. See below.
+ * 18 is used for DLT_PFSYNC in OpenBSD; don't use it for anything else.
+ */
+
+#define DLT_ATM_CLIP	19	/* Linux Classical-IP over ATM */
+
+/*
+ * Apparently Redback uses this for its SmartEdge 400/800.  I hope
+ * nobody else decided to use it, too.
+ */
+#define DLT_REDBACK_SMARTEDGE	32
+
+/*
+ * These values are defined by NetBSD; other platforms should refrain from
+ * using them for other purposes, so that NetBSD savefiles with link
+ * types of 50 or 51 can be read as this type on all platforms.
+ */
+#define DLT_PPP_SERIAL	50	/* PPP over serial with HDLC encapsulation */
+#define DLT_PPP_ETHER	51	/* PPP over Ethernet */
+
+/*
+ * The Axent Raptor firewall - now the Symantec Enterprise Firewall - uses
+ * a link-layer type of 99 for the tcpdump it supplies.  The link-layer
+ * header has 6 bytes of unknown data, something that appears to be an
+ * Ethernet type, and 36 bytes that appear to be 0 in at least one capture
+ * I've seen.
+ */
+#define DLT_SYMANTEC_FIREWALL	99
+
+/*
+ * Values between 100 and 103 are used in capture file headers as
+ * link-layer types corresponding to DLT_ types that differ
+ * between platforms; don't use those values for new DLT_ new types.
+ */
+
+/*
+ * This value was defined by libpcap 0.5; platforms that have defined
+ * it with a different value should define it here with that value -
+ * a link type of 104 in a save file will be mapped to DLT_C_HDLC,
+ * whatever value that happens to be, so programs will correctly
+ * handle files with that link type regardless of the value of
+ * DLT_C_HDLC.
+ *
+ * The name DLT_C_HDLC was used by BSD/OS; we use that name for source
+ * compatibility with programs written for BSD/OS.
+ *
+ * libpcap 0.5 defined it as DLT_CHDLC; we define DLT_CHDLC as well,
+ * for source compatibility with programs written for libpcap 0.5.
+ */
+#define DLT_C_HDLC	104	/* Cisco HDLC */
+#define DLT_CHDLC	DLT_C_HDLC
+
+#define DLT_IEEE802_11	105	/* IEEE 802.11 wireless */
+
+/*
+ * 106 is reserved for Linux Classical IP over ATM; it's like DLT_RAW,
+ * except when it isn't.  (I.e., sometimes it's just raw IP, and
+ * sometimes it isn't.)  We currently handle it as DLT_LINUX_SLL,
+ * so that we don't have to worry about the link-layer header.)
+ */
+
+/*
+ * Frame Relay; BSD/OS has a DLT_FR with a value of 11, but that collides
+ * with other values.
+ * DLT_FR and DLT_FRELAY packets start with the Q.922 Frame Relay header
+ * (DLCI, etc.).
+ */
+#define DLT_FRELAY	107
+
+/*
+ * OpenBSD DLT_LOOP, for loopback devices; it's like DLT_NULL, except
+ * that the AF_ type in the link-layer header is in network byte order.
+ *
+ * DLT_LOOP is 12 in OpenBSD, but that's DLT_RAW in other OSes, so
+ * we don't use 12 for it in OSes other than OpenBSD.
+ */
+#ifdef __OpenBSD__
+#define DLT_LOOP	12
+#else
+#define DLT_LOOP	108
+#endif
+
+/*
+ * Encapsulated packets for IPsec; DLT_ENC is 13 in OpenBSD, but that's
+ * DLT_SLIP_BSDOS in NetBSD, so we don't use 13 for it in OSes other
+ * than OpenBSD.
+ */
+#ifdef __OpenBSD__
+#define DLT_ENC		13
+#else
+#define DLT_ENC		109
+#endif
+
+/*
+ * Values between 110 and 112 are reserved for use in capture file headers
+ * as link-layer types corresponding to DLT_ types that might differ
+ * between platforms; don't use those values for new DLT_ types
+ * other than the corresponding DLT_ types.
+ */
+
+/*
+ * This is for Linux cooked sockets.
+ */
+#define DLT_LINUX_SLL	113
+
+/*
+ * Apple LocalTalk hardware.
+ */
+#define DLT_LTALK	114
+
+/*
+ * Acorn Econet.
+ */
+#define DLT_ECONET	115
+
+/*
+ * Reserved for use with OpenBSD ipfilter.
+ */
+#define DLT_IPFILTER	116
+
+/*
+ * OpenBSD DLT_PFLOG; DLT_PFLOG is 17 in OpenBSD, but that's DLT_LANE8023
+ * in SuSE 6.3, so we can't use 17 for it in capture-file headers.
+ *
+ * XXX: is there a conflict with DLT_PFSYNC 18 as well?
+ */
+#ifdef __OpenBSD__
+#define DLT_OLD_PFLOG	17
+#define DLT_PFSYNC	18
+#endif
+#define DLT_PFLOG	117
+
+/*
+ * Registered for Cisco-internal use.
+ */
+#define DLT_CISCO_IOS	118
+
+/*
+ * For 802.11 cards using the Prism II chips, with a link-layer
+ * header including Prism monitor mode information plus an 802.11
+ * header.
+ */
+#define DLT_PRISM_HEADER	119
+
+/*
+ * Reserved for Aironet 802.11 cards, with an Aironet link-layer header
+ * (see Doug Ambrisko's FreeBSD patches).
+ */
+#define DLT_AIRONET_HEADER	120
+
+/*
+ * Reserved for Siemens HiPath HDLC.
+ */
+#define DLT_HHDLC		121
+
+/*
+ * This is for RFC 2625 IP-over-Fibre Channel.
+ *
+ * This is not for use with raw Fibre Channel, where the link-layer
+ * header starts with a Fibre Channel frame header; it's for IP-over-FC,
+ * where the link-layer header starts with an RFC 2625 Network_Header
+ * field.
+ */
+#define DLT_IP_OVER_FC		122
+
+/*
+ * This is for Full Frontal ATM on Solaris with SunATM, with a
+ * pseudo-header followed by an AALn PDU.
+ *
+ * There may be other forms of Full Frontal ATM on other OSes,
+ * with different pseudo-headers.
+ *
+ * If ATM software returns a pseudo-header with VPI/VCI information
+ * (and, ideally, packet type information, e.g. signalling, ILMI,
+ * LANE, LLC-multiplexed traffic, etc.), it should not use
+ * DLT_ATM_RFC1483, but should get a new DLT_ value, so tcpdump
+ * and the like don't have to infer the presence or absence of a
+ * pseudo-header and the form of the pseudo-header.
+ */
+#define DLT_SUNATM		123	/* Solaris+SunATM */
+
+/* 
+ * Reserved as per request from Kent Dahlgren <kent@praesum.com>
+ * for private use.
+ */
+#define DLT_RIO                 124     /* RapidIO */
+#define DLT_PCI_EXP             125     /* PCI Express */
+#define DLT_AURORA              126     /* Xilinx Aurora link layer */
+
+/*
+ * Header for 802.11 plus a number of bits of link-layer information
+ * including radio information, used by some recent BSD drivers as
+ * well as the madwifi Atheros driver for Linux.
+ */
+#define DLT_IEEE802_11_RADIO	127	/* 802.11 plus radiotap radio header */
+
+/*
+ * Reserved for the TZSP encapsulation, as per request from
+ * Chris Waters <chris.waters@networkchemistry.com>
+ * TZSP is a generic encapsulation for any other link type,
+ * which includes a means to include meta-information
+ * with the packet, e.g. signal strength and channel
+ * for 802.11 packets.
+ */
+#define DLT_TZSP                128     /* Tazmen Sniffer Protocol */
+
+/*
+ * BSD's ARCNET headers have the source host, destination host,
+ * and type at the beginning of the packet; that's what's handed
+ * up to userland via BPF.
+ *
+ * Linux's ARCNET headers, however, have a 2-byte offset field
+ * between the host IDs and the type; that's what's handed up
+ * to userland via PF_PACKET sockets.
+ *
+ * We therefore have to have separate DLT_ values for them.
+ */
+#define DLT_ARCNET_LINUX	129	/* ARCNET */
+
+/*
+ * Juniper-private data link types, as per request from
+ * Hannes Gredler <hannes@juniper.net>.  The DLT_s are used
+ * for passing on chassis-internal metainformation such as
+ * QOS profiles, etc..
+ */
+#define DLT_JUNIPER_MLPPP       130
+#define DLT_JUNIPER_MLFR        131
+#define DLT_JUNIPER_ES          132
+#define DLT_JUNIPER_GGSN        133
+#define DLT_JUNIPER_MFR         134
+#define DLT_JUNIPER_ATM2        135
+#define DLT_JUNIPER_SERVICES    136
+#define DLT_JUNIPER_ATM1        137
+
+/*
+ * Apple IP-over-IEEE 1394, as per a request from Dieter Siegmund
+ * <dieter@apple.com>.  The header that's presented is an Ethernet-like
+ * header:
+ *
+ *	#define FIREWIRE_EUI64_LEN	8
+ *	struct firewire_header {
+ *		u_char  firewire_dhost[FIREWIRE_EUI64_LEN];
+ *		u_char  firewire_shost[FIREWIRE_EUI64_LEN];
+ *		u_short firewire_type;
+ *	};
+ *
+ * with "firewire_type" being an Ethernet type value, rather than,
+ * for example, raw GASP frames being handed up.
+ */
+#define DLT_APPLE_IP_OVER_IEEE1394	138
+
+/*
+ * Various SS7 encapsulations, as per a request from Jeff Morriss
+ * <jeff.morriss[AT]ulticom.com> and subsequent discussions.
+ */
+#define DLT_MTP2_WITH_PHDR	139	/* pseudo-header with various info, followed by MTP2 */
+#define DLT_MTP2		140	/* MTP2, without pseudo-header */
+#define DLT_MTP3		141	/* MTP3, without pseudo-header or MTP2 */
+#define DLT_SCCP		142	/* SCCP, without pseudo-header or MTP2 or MTP3 */
+
+/*
+ * DOCSIS MAC frames.
+ */
+#define DLT_DOCSIS		143
+
+/*
+ * Linux-IrDA packets. Protocol defined at http://www.irda.org.
+ * Those packets include IrLAP headers and above (IrLMP...), but
+ * don't include Phy framing (SOF/EOF/CRC & byte stuffing), because Phy
+ * framing can be handled by the hardware and depend on the bitrate.
+ * This is exactly the format you would get capturing on a Linux-IrDA
+ * interface (irdaX), but not on a raw serial port.
+ * Note the capture is done in "Linux-cooked" mode, so each packet include
+ * a fake packet header (struct sll_header). This is because IrDA packet
+ * decoding is dependant on the direction of the packet (incomming or
+ * outgoing).
+ * When/if other platform implement IrDA capture, we may revisit the
+ * issue and define a real DLT_IRDA...
+ * Jean II
+ */
+#define DLT_LINUX_IRDA		144
+
+/*
+ * Reserved for IBM SP switch and IBM Next Federation switch.
+ */
+#define DLT_IBM_SP		145
+#define DLT_IBM_SN		146
+
+/*
+ * Reserved for private use.  If you have some link-layer header type
+ * that you want to use within your organization, with the capture files
+ * using that link-layer header type not ever be sent outside your
+ * organization, you can use these values.
+ *
+ * No libpcap release will use these for any purpose, nor will any
+ * tcpdump release use them, either.
+ *
+ * Do *NOT* use these in capture files that you expect anybody not using
+ * your private versions of capture-file-reading tools to read; in
+ * particular, do *NOT* use them in products, otherwise you may find that
+ * people won't be able to use tcpdump, or snort, or Ethereal, or... to
+ * read capture files from your firewall/intrusion detection/traffic
+ * monitoring/etc. appliance, or whatever product uses that DLT_ value,
+ * and you may also find that the developers of those applications will
+ * not accept patches to let them read those files.
+ *
+ * Also, do not use them if somebody might send you a capture using them
+ * for *their* private type and tools using them for *your* private type
+ * would have to read them.
+ *
+ * Instead, ask "tcpdump-workers@lists.tcpdump.org" for a new DLT_ value,
+ * as per the comment above, and use the type you're given.
+ */
+#define DLT_USER0		147
+#define DLT_USER1		148
+#define DLT_USER2		149
+#define DLT_USER3		150
+#define DLT_USER4		151
+#define DLT_USER5		152
+#define DLT_USER6		153
+#define DLT_USER7		154
+#define DLT_USER8		155
+#define DLT_USER9		156
+#define DLT_USER10		157
+#define DLT_USER11		158
+#define DLT_USER12		159
+#define DLT_USER13		160
+#define DLT_USER14		161
+#define DLT_USER15		162
+
+/*
+ * For future use with 802.11 captures - defined by AbsoluteValue
+ * Systems to store a number of bits of link-layer information
+ * including radio information:
+ *
+ *	http://www.shaftnet.org/~pizza/software/capturefrm.txt
+ *
+ * but it might be used by some non-AVS drivers now or in the
+ * future.
+ */
+#define DLT_IEEE802_11_RADIO_AVS 163	/* 802.11 plus AVS radio header */
+
+/*
+ * Juniper-private data link type, as per request from
+ * Hannes Gredler <hannes@juniper.net>.  The DLT_s are used
+ * for passing on chassis-internal metainformation such as
+ * QOS profiles, etc..
+ */
+#define DLT_JUNIPER_MONITOR     164
+
+/*
+ * Reserved for BACnet MS/TP.
+ */
+#define DLT_BACNET_MS_TP	165
+
+/*
+ * Another PPP variant as per request from Karsten Keil <kkeil@suse.de>.
+ *
+ * This is used in some OSes to allow a kernel socket filter to distinguish
+ * between incoming and outgoing packets, on a socket intended to
+ * supply pppd with outgoing packets so it can do dial-on-demand and
+ * hangup-on-lack-of-demand; incoming packets are filtered out so they
+ * don't cause pppd to hold the connection up (you don't want random
+ * input packets such as port scans, packets from old lost connections,
+ * etc. to force the connection to stay up).
+ *
+ * The first byte of the PPP header (0xff03) is modified to accomodate
+ * the direction - 0x00 = IN, 0x01 = OUT.
+ */
+#define DLT_PPP_PPPD		166
+
+/*
+ * Names for backwards compatibility with older versions of some PPP
+ * software; new software should use DLT_PPP_PPPD.
+ */
+#define DLT_PPP_WITH_DIRECTION	DLT_PPP_PPPD
+#define DLT_LINUX_PPP_WITHDIRECTION	DLT_PPP_PPPD
+
+/*
+ * Juniper-private data link type, as per request from
+ * Hannes Gredler <hannes@juniper.net>.  The DLT_s are used
+ * for passing on chassis-internal metainformation such as
+ * QOS profiles, cookies, etc..
+ */
+#define DLT_JUNIPER_PPPOE       167
+#define DLT_JUNIPER_PPPOE_ATM   168
+
+#define DLT_GPRS_LLC		169	/* GPRS LLC */
+#define DLT_GPF_T		170	/* GPF-T (ITU-T G.7041/Y.1303) */
+#define DLT_GPF_F		171	/* GPF-F (ITU-T G.7041/Y.1303) */
+
+/*
+ * Requested by Oolan Zimmer <oz@gcom.com> for use in Gcom's T1/E1 line
+ * monitoring equipment.
+ */
+#define DLT_GCOM_T1E1		172
+#define DLT_GCOM_SERIAL		173
+
+/*
+ * Juniper-private data link type, as per request from
+ * Hannes Gredler <hannes@juniper.net>.  The DLT_ is used
+ * for internal communication to Physical Interface Cards (PIC)
+ */
+#define DLT_JUNIPER_PIC_PEER    174
+
+/*
+ * Link types requested by Gregor Maier <gregor@endace.com> of Endace
+ * Measurement Systems.  They add an ERF header (see
+ * http://www.endace.com/support/EndaceRecordFormat.pdf) in front of
+ * the link-layer header.
+ */
+#define DLT_ERF_ETH		175	/* Ethernet */
+#define DLT_ERF_POS		176	/* Packet-over-SONET */
+
+/*
+ * Requested by Daniele Orlandi <daniele@orlandi.com> for raw LAPD
+ * for vISDN (http://www.orlandi.com/visdn/).  Its link-layer header
+ * includes additional information before the LAPD header, so it's
+ * not necessarily a generic LAPD header.
+ */
+#define DLT_LINUX_LAPD		177
+
+/*
+ * Juniper-private data link type, as per request from
+ * Hannes Gredler <hannes@juniper.net>. 
+ * The DLT_ are used for prepending meta-information
+ * like interface index, interface name
+ * before standard Ethernet, PPP, Frelay & C-HDLC Frames
+ */
+#define DLT_JUNIPER_ETHER       178
+#define DLT_JUNIPER_PPP         179
+#define DLT_JUNIPER_FRELAY      180
+#define DLT_JUNIPER_CHDLC       181
+
+/*
+ * Multi Link Frame Relay (FRF.16)
+ */
+#define DLT_MFR                 182
+
+/*
+ * Juniper-private data link type, as per request from
+ * Hannes Gredler <hannes@juniper.net>. 
+ * The DLT_ is used for internal communication with a
+ * voice Adapter Card (PIC)
+ */
+#define DLT_JUNIPER_VP          183
+
+/*
+ * Arinc 429 frames.
+ * DLT_ requested by Gianluca Varenni <gianluca.varenni@cacetech.com>.
+ * Every frame contains a 32bit A429 label.
+ * More documentation on Arinc 429 can be found at
+ * http://www.condoreng.com/support/downloads/tutorials/ARINCTutorial.pdf
+ */
+#define DLT_A429                184
+
+/*
+ * Arinc 653 Interpartition Communication messages.
+ * DLT_ requested by Gianluca Varenni <gianluca.varenni@cacetech.com>.
+ * Please refer to the A653-1 standard for more information.
+ */
+#define DLT_A653_ICM            185
+
+/*
+ * USB packets, beginning with a USB setup header; requested by
+ * Paolo Abeni <paolo.abeni@email.it>.
+ */
+#define DLT_USB			186
+
+/*
+ * Bluetooth HCI UART transport layer (part H:4); requested by
+ * Paolo Abeni.
+ */
+#define DLT_BLUETOOTH_HCI_H4	187
+
+/*
+ * IEEE 802.16 MAC Common Part Sublayer; requested by Maria Cruz
+ * <cruz_petagay@bah.com>.
+ */
+#define DLT_IEEE802_16_MAC_CPS	188
+
+/*
+ * USB packets, beginning with a Linux USB header; requested by
+ * Paolo Abeni <paolo.abeni@email.it>.
+ */
+#define DLT_USB_LINUX		189
+
+/*
+ * Controller Area Network (CAN) v. 2.0B packets.
+ * DLT_ requested by Gianluca Varenni <gianluca.varenni@cacetech.com>.
+ * Used to dump CAN packets coming from a CAN Vector board.
+ * More documentation on the CAN v2.0B frames can be found at
+ * http://www.can-cia.org/downloads/?269
+ */
+#define DLT_CAN20B              190
+
+/*
+ * IEEE 802.15.4, with address fields padded, as is done by Linux
+ * drivers; requested by Juergen Schimmer.
+ */
+#define DLT_IEEE802_15_4_LINUX	191
+
+/*
+ * Per Packet Information encapsulated packets.
+ * DLT_ requested by Gianluca Varenni <gianluca.varenni@cacetech.com>.
+ */
+#define DLT_PPI			192
+
+/*
+ * Header for 802.16 MAC Common Part Sublayer plus a radiotap radio header;
+ * requested by Charles Clancy.
+ */
+#define DLT_IEEE802_16_MAC_CPS_RADIO	193
+
+/*
+ * Juniper-private data link type, as per request from
+ * Hannes Gredler <hannes@juniper.net>. 
+ * The DLT_ is used for internal communication with a
+ * integrated service module (ISM).
+ */
+#define DLT_JUNIPER_ISM         194
+
+/*
+ * IEEE 802.15.4, exactly as it appears in the spec (no padding, no
+ * nothing); requested by Mikko Saarnivala <mikko.saarnivala@sensinode.com>.
+ */
+#define DLT_IEEE802_15_4	195
+
+/*
+ * Various link-layer types, with a pseudo-header, for SITA
+ * (http://www.sita.aero/); requested by Fulko Hew (fulko.hew@gmail.com).
+ */
+#define DLT_SITA		196
+
+/*
+ * Various link-layer types, with a pseudo-header, for Endace DAG cards;
+ * encapsulates Endace ERF records.  Requested by Stephen Donnelly
+ * <stephen@endace.com>.
+ */
+#define DLT_ERF			197
+
+/*
+ * Special header prepended to Ethernet packets when capturing from a
+ * u10 Networks board.  Requested by Phil Mulholland
+ * <phil@u10networks.com>.
+ */
+#define DLT_RAIF1		198
+
+/*
+ * IPMB packet for IPMI, beginning with the I2C slave address, followed
+ * by the netFn and LUN, etc..  Requested by Chanthy Toeung
+ * <chanthy.toeung@ca.kontron.com>.
+ */
+#define DLT_IPMB		199
+
+/*
+ * Juniper-private data link type, as per request from
+ * Hannes Gredler <hannes@juniper.net>. 
+ * The DLT_ is used for capturing data on a secure tunnel interface.
+ */
+#define DLT_JUNIPER_ST          200
+
+/*
+ * Bluetooth HCI UART transport layer (part H:4), with pseudo-header
+ * that includes direction information; requested by Paolo Abeni.
+ */
+#define DLT_BLUETOOTH_HCI_H4_WITH_PHDR	201
+
+/*
+ * AX.25 packet with a 1-byte KISS header; see
+ *
+ *	http://www.ax25.net/kiss.htm
+ *
+ * as per Richard Stearn <richard@rns-stearn.demon.co.uk>.
+ */
+#define DLT_AX25_KISS		202
+
+/*
+ * LAPD packets from an ISDN channel, starting with the address field,
+ * with no pseudo-header.
+ * Requested by Varuna De Silva <varunax@gmail.com>.
+ */
+#define DLT_LAPD		203
+
+/*
+ * Variants of various link-layer headers, with a one-byte direction
+ * pseudo-header prepended - zero means "received by this host",
+ * non-zero (any non-zero value) means "sent by this host" - as per
+ * Will Barker <w.barker@zen.co.uk>.
+ */
+#define DLT_PPP_WITH_DIR	204	/* PPP - don't confuse with DLT_PPP_WITH_DIRECTION */
+#define DLT_C_HDLC_WITH_DIR	205	/* Cisco HDLC */
+#define DLT_FRELAY_WITH_DIR	206	/* Frame Relay */
+#define DLT_LAPB_WITH_DIR	207	/* LAPB */
+
+/*
+ * 208 is reserved for an as-yet-unspecified proprietary link-layer
+ * type, as requested by Will Barker.
+ */
+
+/*
+ * IPMB with a Linux-specific pseudo-header; as requested by Alexey Neyman
+ * <avn@pigeonpoint.com>.
+ */
+#define DLT_IPMB_LINUX		209
+
+/*
+ * FlexRay automotive bus - http://www.flexray.com/ - as requested
+ * by Hannes Kaelber <hannes.kaelber@x2e.de>.
+ */
+#define DLT_FLEXRAY		210
+
+/*
+ * Media Oriented Systems Transport (MOST) bus for multimedia
+ * transport - http://www.mostcooperation.com/ - as requested
+ * by Hannes Kaelber <hannes.kaelber@x2e.de>.
+ */
+#define DLT_MOST		211
+
+/*
+ * Local Interconnect Network (LIN) bus for vehicle networks -
+ * http://www.lin-subbus.org/ - as requested by Hannes Kaelber
+ * <hannes.kaelber@x2e.de>.
+ */
+#define DLT_LIN			212
+
+/*
+ * X2E-private data link type used for serial line capture,
+ * as requested by Hannes Kaelber <hannes.kaelber@x2e.de>.
+ */
+#define DLT_X2E_SERIAL		213
+
+/*
+ * X2E-private data link type used for the Xoraya data logger
+ * family, as requested by Hannes Kaelber <hannes.kaelber@x2e.de>.
+ */
+#define DLT_X2E_XORAYA		214
+
+/*
+ * IEEE 802.15.4, exactly as it appears in the spec (no padding, no
+ * nothing), but with the PHY-level data for non-ASK PHYs (4 octets
+ * of 0 as preamble, one octet of SFD, one octet of frame length+
+ * reserved bit, and then the MAC-layer data, starting with the
+ * frame control field).
+ *
+ * Requested by Max Filippov <jcmvbkbc@gmail.com>.
+ */
+#define DLT_IEEE802_15_4_NONASK_PHY	215
+
+
+/*
+ * DLT and savefile link type values are split into a class and
+ * a member of that class.  A class value of 0 indicates a regular
+ * DLT_/LINKTYPE_ value.
+ */
+#define DLT_CLASS(x)		((x) & 0x03ff0000)
+
+/*
+ * NetBSD-specific generic "raw" link type.  The class value indicates
+ * that this is the generic raw type, and the lower 16 bits are the
+ * address family we're dealing with.  Those values are NetBSD-specific;
+ * do not assume that they correspond to AF_ values for your operating
+ * system.
+ */
+#define	DLT_CLASS_NETBSD_RAWAF	0x02240000
+#define	DLT_NETBSD_RAWAF(af)	(DLT_CLASS_NETBSD_RAWAF | (af))
+#define	DLT_NETBSD_RAWAF_AF(x)	((x) & 0x0000ffff)
+#define	DLT_IS_NETBSD_RAWAF(x)	(DLT_CLASS(x) == DLT_CLASS_NETBSD_RAWAF)
+
+
+/*
+ * The instruction encodings.
+ */
+/* instruction classes */
+#define BPF_CLASS(code) ((code) & 0x07)
+#define		BPF_LD		0x00
+#define		BPF_LDX		0x01
+#define		BPF_ST		0x02
+#define		BPF_STX		0x03
+#define		BPF_ALU		0x04
+#define		BPF_JMP		0x05
+#define		BPF_RET		0x06
+#define		BPF_MISC	0x07
+
+/* ld/ldx fields */
+#define BPF_SIZE(code)	((code) & 0x18)
+#define		BPF_W		0x00
+#define		BPF_H		0x08
+#define		BPF_B		0x10
+#define BPF_MODE(code)	((code) & 0xe0)
+#define		BPF_IMM 	0x00
+#define		BPF_ABS		0x20
+#define		BPF_IND		0x40
+#define		BPF_MEM		0x60
+#define		BPF_LEN		0x80
+#define		BPF_MSH		0xa0
+
+/* alu/jmp fields */
+#define BPF_OP(code)	((code) & 0xf0)
+#define		BPF_ADD		0x00
+#define		BPF_SUB		0x10
+#define		BPF_MUL		0x20
+#define		BPF_DIV		0x30
+#define		BPF_OR		0x40
+#define		BPF_AND		0x50
+#define		BPF_LSH		0x60
+#define		BPF_RSH		0x70
+#define		BPF_NEG		0x80
+#define		BPF_JA		0x00
+#define		BPF_JEQ		0x10
+#define		BPF_JGT		0x20
+#define		BPF_JGE		0x30
+#define		BPF_JSET	0x40
+#define BPF_SRC(code)	((code) & 0x08)
+#define		BPF_K		0x00
+#define		BPF_X		0x08
+
+/* ret - BPF_K and BPF_X also apply */
+#define BPF_RVAL(code)	((code) & 0x18)
+#define		BPF_A		0x10
+
+/* misc */
+#define BPF_MISCOP(code) ((code) & 0xf8)
+#define		BPF_TAX		0x00
+#define		BPF_TXA		0x80
+
+/*
+ * The instruction data structure.
+ */
+struct bpf_insn {
+	u_short	code;
+	u_char 	jt;
+	u_char 	jf;
+	bpf_u_int32 k;
+};
+
+/*
+ * Macros for insn array initializers.
+ */
+#define BPF_STMT(code, k) { (u_short)(code), 0, 0, k }
+#define BPF_JUMP(code, k, jt, jf) { (u_short)(code), jt, jf, k }
+
+#if __STDC__ || defined(__cplusplus)
+extern int bpf_validate(const struct bpf_insn *, int);
+extern u_int bpf_filter(const struct bpf_insn *, const u_char *, u_int, u_int);
+#else
+extern int bpf_validate();
+extern u_int bpf_filter();
+#endif
+
+/*
+ * Number of scratch memory words (for BPF_LD|BPF_MEM and BPF_ST).
+ */
+#define BPF_MEMWORDS 16
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/namedb.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/namedb.h
new file mode 100644
index 000000000..48bd28dc1
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/namedb.h
@@ -0,0 +1,80 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef lib_pcap_namedb_h
+#define lib_pcap_namedb_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * As returned by the pcap_next_etherent()
+ * XXX this stuff doesn't belong in this interface, but this
+ * library already must do name to address translation, so
+ * on systems that don't have support for /etc/ethers, we
+ * export these hooks since they'll
+ */
+struct pcap_etherent {
+	u_char addr[6];
+	char name[122];
+};
+#ifndef PCAP_ETHERS_FILE
+#define PCAP_ETHERS_FILE "/etc/ethers"
+#endif
+struct	pcap_etherent *pcap_next_etherent(FILE *);
+u_char *pcap_ether_hostton(const char*);
+u_char *pcap_ether_aton(const char *);
+
+bpf_u_int32 **pcap_nametoaddr(const char *);
+#ifdef INET6
+struct addrinfo *pcap_nametoaddrinfo(const char *);
+#endif
+bpf_u_int32 pcap_nametonetaddr(const char *);
+
+int	pcap_nametoport(const char *, int *, int *);
+int	pcap_nametoportrange(const char *, int *, int *, int *);
+int	pcap_nametoproto(const char *);
+int	pcap_nametoeproto(const char *);
+int	pcap_nametollc(const char *);
+/*
+ * If a protocol is unknown, PROTO_UNDEF is returned.
+ * Also, pcap_nametoport() returns the protocol along with the port number.
+ * If there are ambiguous entried in /etc/services (i.e. domain
+ * can be either tcp or udp) PROTO_UNDEF is returned.
+ */
+#define PROTO_UNDEF		-1
+
+/* XXX move these to pcap-int.h? */
+int __pcap_atodn(const char *, bpf_u_int32 *);
+int __pcap_atoin(const char *, bpf_u_int32 *);
+u_short	__pcap_nametodnaddr(const char *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/pcap.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/pcap.h
new file mode 100644
index 000000000..50d88f14f
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/pcap.h
@@ -0,0 +1,397 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef lib_pcap_pcap_h
+#define lib_pcap_pcap_h
+
+#if defined(WIN32)
+  #include <pcap-stdinc.h>
+#elif defined(MSDOS)
+  #include <sys/types.h>
+  #include <sys/socket.h>  /* u_int, u_char etc. */
+#else /* UN*X */
+  #include <sys/types.h>
+  #include <sys/time.h>
+#endif /* WIN32/MSDOS/UN*X */
+
+#ifndef PCAP_DONT_INCLUDE_PCAP_BPF_H
+#include <pcap/bpf.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef HAVE_REMOTE
+	// We have to define the SOCKET here, although it has been defined in sockutils.h
+	// This is to avoid the distribution of the 'sockutils.h' file around
+	// (for example in the WinPcap developer's pack)
+	#ifndef SOCKET
+		#ifdef WIN32
+			#define SOCKET unsigned int
+		#else
+			#define SOCKET int
+		#endif
+	#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PCAP_VERSION_MAJOR 2
+#define PCAP_VERSION_MINOR 4
+
+#define PCAP_ERRBUF_SIZE 256
+
+/*
+ * Compatibility for systems that have a bpf.h that
+ * predates the bpf typedefs for 64-bit support.
+ */
+#if BPF_RELEASE - 0 < 199406
+typedef	int bpf_int32;
+typedef	u_int bpf_u_int32;
+#endif
+
+typedef struct pcap pcap_t;
+typedef struct pcap_dumper pcap_dumper_t;
+typedef struct pcap_if pcap_if_t;
+typedef struct pcap_addr pcap_addr_t;
+
+/*
+ * The first record in the file contains saved values for some
+ * of the flags used in the printout phases of tcpdump.
+ * Many fields here are 32 bit ints so compilers won't insert unwanted
+ * padding; these files need to be interchangeable across architectures.
+ *
+ * Do not change the layout of this structure, in any way (this includes
+ * changes that only affect the length of fields in this structure).
+ *
+ * Also, do not change the interpretation of any of the members of this
+ * structure, in any way (this includes using values other than
+ * LINKTYPE_ values, as defined in "savefile.c", in the "linktype"
+ * field).
+ *
+ * Instead:
+ *
+ *	introduce a new structure for the new format, if the layout
+ *	of the structure changed;
+ *
+ *	send mail to "tcpdump-workers@lists.tcpdump.org", requesting
+ *	a new magic number for your new capture file format, and, when
+ *	you get the new magic number, put it in "savefile.c";
+ *
+ *	use that magic number for save files with the changed file
+ *	header;
+ *
+ *	make the code in "savefile.c" capable of reading files with
+ *	the old file header as well as files with the new file header
+ *	(using the magic number to determine the header format).
+ *
+ * Then supply the changes as a patch at
+ *
+ *	http://sourceforge.net/projects/libpcap/
+ *
+ * so that future versions of libpcap and programs that use it (such as
+ * tcpdump) will be able to read your new capture file format.
+ */
+struct pcap_file_header {
+	bpf_u_int32 magic;
+	u_short version_major;
+	u_short version_minor;
+	bpf_int32 thiszone;	/* gmt to local correction */
+	bpf_u_int32 sigfigs;	/* accuracy of timestamps */
+	bpf_u_int32 snaplen;	/* max length saved portion of each pkt */
+	bpf_u_int32 linktype;	/* data link type (LINKTYPE_*) */
+};
+
+/*
+ * Macros for the value returned by pcap_datalink_ext().
+ * 
+ * If LT_FCS_LENGTH_PRESENT(x) is true, the LT_FCS_LENGTH(x) macro
+ * gives the FCS length of packets in the capture.
+ */
+#define LT_FCS_LENGTH_PRESENT(x)	((x) & 0x04000000)
+#define LT_FCS_LENGTH(x)		(((x) & 0xF0000000) >> 28)
+#define LT_FCS_DATALINK_EXT(x)		((((x) & 0xF) << 28) | 0x04000000)
+
+typedef enum {
+       PCAP_D_INOUT = 0,
+       PCAP_D_IN,
+       PCAP_D_OUT
+} pcap_direction_t;
+
+/*
+ * Generic per-packet information, as supplied by libpcap.
+ *
+ * The time stamp can and should be a "struct timeval", regardless of
+ * whether your system supports 32-bit tv_sec in "struct timeval",
+ * 64-bit tv_sec in "struct timeval", or both if it supports both 32-bit
+ * and 64-bit applications.  The on-disk format of savefiles uses 32-bit
+ * tv_sec (and tv_usec); this structure is irrelevant to that.  32-bit
+ * and 64-bit versions of libpcap, even if they're on the same platform,
+ * should supply the appropriate version of "struct timeval", even if
+ * that's not what the underlying packet capture mechanism supplies.
+ */
+struct pcap_pkthdr {
+	struct timeval ts;	/* time stamp */
+	bpf_u_int32 caplen;	/* length of portion present */
+	bpf_u_int32 len;	/* length this packet (off wire) */
+};
+
+/*
+ * As returned by the pcap_stats()
+ */
+struct pcap_stat {
+	u_int ps_recv;		/* number of packets received */
+	u_int ps_drop;		/* number of packets dropped */
+	u_int ps_ifdrop;	/* drops by interface XXX not yet supported */
+#ifdef HAVE_REMOTE
+	u_int ps_capt;		/* number of packets that are received by the application; please get rid off the Win32 ifdef */
+	u_int ps_sent;		/* number of packets sent by the server on the network */
+	u_int ps_netdrop;	/* number of packets lost on the network */
+#endif /* HAVE_REMOTE */
+};
+
+#ifdef MSDOS
+/*
+ * As returned by the pcap_stats_ex()
+ */
+struct pcap_stat_ex {
+       u_long  rx_packets;        /* total packets received       */
+       u_long  tx_packets;        /* total packets transmitted    */
+       u_long  rx_bytes;          /* total bytes received         */
+       u_long  tx_bytes;          /* total bytes transmitted      */
+       u_long  rx_errors;         /* bad packets received         */
+       u_long  tx_errors;         /* packet transmit problems     */
+       u_long  rx_dropped;        /* no space in Rx buffers       */
+       u_long  tx_dropped;        /* no space available for Tx    */
+       u_long  multicast;         /* multicast packets received   */
+       u_long  collisions;
+
+       /* detailed rx_errors: */
+       u_long  rx_length_errors;
+       u_long  rx_over_errors;    /* receiver ring buff overflow  */
+       u_long  rx_crc_errors;     /* recv'd pkt with crc error    */
+       u_long  rx_frame_errors;   /* recv'd frame alignment error */
+       u_long  rx_fifo_errors;    /* recv'r fifo overrun          */
+       u_long  rx_missed_errors;  /* recv'r missed packet         */
+
+       /* detailed tx_errors */
+       u_long  tx_aborted_errors;
+       u_long  tx_carrier_errors;
+       u_long  tx_fifo_errors;
+       u_long  tx_heartbeat_errors;
+       u_long  tx_window_errors;
+     };
+#endif
+
+/*
+ * Item in a list of interfaces.
+ */
+struct pcap_if {
+	struct pcap_if *next;
+	char *name;		/* name to hand to "pcap_open_live()" */
+	char *description;	/* textual description of interface, or NULL */
+	struct pcap_addr *addresses;
+	bpf_u_int32 flags;	/* PCAP_IF_ interface flags */
+};
+
+#define PCAP_IF_LOOPBACK	0x00000001	/* interface is loopback */
+
+/*
+ * Representation of an interface address.
+ */
+struct pcap_addr {
+	struct pcap_addr *next;
+	struct sockaddr *addr;		/* address */
+	struct sockaddr *netmask;	/* netmask for that address */
+	struct sockaddr *broadaddr;	/* broadcast address for that address */
+	struct sockaddr *dstaddr;	/* P2P destination address for that address */
+};
+
+typedef void (*pcap_handler)(u_char *, const struct pcap_pkthdr *,
+			     const u_char *);
+
+/*
+ * Error codes for the pcap API.
+ * These will all be negative, so you can check for the success or
+ * failure of a call that returns these codes by checking for a
+ * negative value.
+ */
+#define PCAP_ERROR			-1	/* generic error code */
+#define PCAP_ERROR_BREAK		-2	/* loop terminated by pcap_breakloop */
+#define PCAP_ERROR_NOT_ACTIVATED	-3	/* the capture needs to be activated */
+#define PCAP_ERROR_ACTIVATED		-4	/* the operation can't be performed on already activated captures */
+#define PCAP_ERROR_NO_SUCH_DEVICE	-5	/* no such device exists */
+#define PCAP_ERROR_RFMON_NOTSUP		-6	/* this device doesn't support rfmon (monitor) mode */
+#define PCAP_ERROR_NOT_RFMON		-7	/* operation supported only in monitor mode */
+#define PCAP_ERROR_PERM_DENIED		-8	/* no permission to open the device */
+#define PCAP_ERROR_IFACE_NOT_UP		-9	/* interface isn't up */
+
+/*
+ * Warning codes for the pcap API.
+ * These will all be positive and non-zero, so they won't look like
+ * errors.
+ */
+#define PCAP_WARNING			1	/* generic warning code */
+#define PCAP_WARNING_PROMISC_NOTSUP	2	/* this device doesn't support promiscuous mode */
+
+char	*pcap_lookupdev(char *);
+int	pcap_lookupnet(const char *, bpf_u_int32 *, bpf_u_int32 *, char *);
+
+pcap_t	*pcap_create(const char *, char *);
+int	pcap_set_snaplen(pcap_t *, int);
+int	pcap_set_promisc(pcap_t *, int);
+int	pcap_can_set_rfmon(pcap_t *);
+int	pcap_set_rfmon(pcap_t *, int);
+int	pcap_set_timeout(pcap_t *, int);
+int	pcap_set_buffer_size(pcap_t *, int);
+int	pcap_activate(pcap_t *);
+
+pcap_t	*pcap_open_live(const char *, int, int, int, char *);
+pcap_t	*pcap_open_dead(int, int);
+pcap_t	*pcap_open_offline(const char *, char *);
+#if defined(WIN32)
+pcap_t  *pcap_hopen_offline(intptr_t, char *);
+#if !defined(LIBPCAP_EXPORTS)
+#define pcap_fopen_offline(f,b) \
+	pcap_hopen_offline(_get_osfhandle(_fileno(f)), b)
+#else /*LIBPCAP_EXPORTS*/
+static pcap_t *pcap_fopen_offline(FILE *, char *);
+#endif
+#else /*WIN32*/
+pcap_t	*pcap_fopen_offline(FILE *, char *);
+#endif /*WIN32*/
+
+void	pcap_close(pcap_t *);
+int	pcap_loop(pcap_t *, int, pcap_handler, u_char *);
+int	pcap_dispatch(pcap_t *, int, pcap_handler, u_char *);
+const u_char*
+	pcap_next(pcap_t *, struct pcap_pkthdr *);
+int 	pcap_next_ex(pcap_t *, struct pcap_pkthdr **, const u_char **);
+void	pcap_breakloop(pcap_t *);
+int	pcap_stats(pcap_t *, struct pcap_stat *);
+int	pcap_setfilter(pcap_t *, struct bpf_program *);
+int 	pcap_setdirection(pcap_t *, pcap_direction_t);
+int	pcap_getnonblock(pcap_t *, char *);
+int	pcap_setnonblock(pcap_t *, int, char *);
+int	pcap_inject(pcap_t *, const void *, size_t);
+int	pcap_sendpacket(pcap_t *, const u_char *, int);
+const char *pcap_statustostr(int);
+const char *pcap_strerror(int);
+char	*pcap_geterr(pcap_t *);
+void	pcap_perror(pcap_t *, char *);
+int	pcap_compile(pcap_t *, struct bpf_program *, const char *, int,
+	    bpf_u_int32);
+int	pcap_compile_nopcap(int, int, struct bpf_program *,
+	    const char *, int, bpf_u_int32);
+void	pcap_freecode(struct bpf_program *);
+int	pcap_offline_filter(struct bpf_program *, const struct pcap_pkthdr *,
+	    const u_char *);
+int	pcap_datalink(pcap_t *);
+int	pcap_datalink_ext(pcap_t *);
+int	pcap_list_datalinks(pcap_t *, int **);
+int	pcap_set_datalink(pcap_t *, int);
+void	pcap_free_datalinks(int *);
+int	pcap_datalink_name_to_val(const char *);
+const char *pcap_datalink_val_to_name(int);
+const char *pcap_datalink_val_to_description(int);
+int	pcap_snapshot(pcap_t *);
+int	pcap_is_swapped(pcap_t *);
+int	pcap_major_version(pcap_t *);
+int	pcap_minor_version(pcap_t *);
+
+/* XXX */
+FILE	*pcap_file(pcap_t *);
+int	pcap_fileno(pcap_t *);
+
+pcap_dumper_t *pcap_dump_open(pcap_t *, const char *);
+pcap_dumper_t *pcap_dump_fopen(pcap_t *, FILE *fp);
+FILE	*pcap_dump_file(pcap_dumper_t *);
+long	pcap_dump_ftell(pcap_dumper_t *);
+int	pcap_dump_flush(pcap_dumper_t *);
+void	pcap_dump_close(pcap_dumper_t *);
+void	pcap_dump(u_char *, const struct pcap_pkthdr *, const u_char *);
+
+int	pcap_findalldevs(pcap_if_t **, char *);
+void	pcap_freealldevs(pcap_if_t *);
+
+const char *pcap_lib_version(void);
+
+/* XXX this guy lives in the bpf tree */
+u_int	bpf_filter(const struct bpf_insn *, const u_char *, u_int, u_int);
+int	bpf_validate(const struct bpf_insn *f, int len);
+char	*bpf_image(const struct bpf_insn *, int);
+void	bpf_dump(const struct bpf_program *, int);
+
+#if defined(WIN32)
+
+/*
+ * Win32 definitions
+ */
+
+int pcap_setbuff(pcap_t *p, int dim);
+int pcap_setmode(pcap_t *p, int mode);
+int pcap_setmintocopy(pcap_t *p, int size);
+
+#ifdef WPCAP
+/* Include file with the wpcap-specific extensions */
+#include <Win32-Extensions.h>
+#endif /* WPCAP */
+
+#define MODE_CAPT 0
+#define MODE_STAT 1
+#define MODE_MON 2
+
+#elif defined(MSDOS)
+
+/*
+ * MS-DOS definitions
+ */
+
+int  pcap_stats_ex (pcap_t *, struct pcap_stat_ex *);
+void pcap_set_wait (pcap_t *p, void (*yield)(void), int wait);
+u_long pcap_mac_packets (void);
+
+#else /* UN*X */
+
+/*
+ * UN*X definitions
+ */
+
+int	pcap_get_selectable_fd(pcap_t *);
+
+#endif /* WIN32/MSDOS/UN*X */
+
+#ifdef HAVE_REMOTE
+/* Includes most of the public stuff that is needed for the remote capture */
+#include <remote-ext.h>
+#endif	 /* HAVE_REMOTE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/sll.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/sll.h
new file mode 100644
index 000000000..b8950fab8
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/sll.h
@@ -0,0 +1,115 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/*
+ * For captures on Linux cooked sockets, we construct a fake header
+ * that includes:
+ *
+ *	a 2-byte "packet type" which is one of:
+ *
+ *		LINUX_SLL_HOST		packet was sent to us
+ *		LINUX_SLL_BROADCAST	packet was broadcast
+ *		LINUX_SLL_MULTICAST	packet was multicast
+ *		LINUX_SLL_OTHERHOST	packet was sent to somebody else
+ *		LINUX_SLL_OUTGOING	packet was sent *by* us;
+ *
+ *	a 2-byte Ethernet protocol field;
+ *
+ *	a 2-byte link-layer type;
+ *
+ *	a 2-byte link-layer address length;
+ *
+ *	an 8-byte source link-layer address, whose actual length is
+ *	specified by the previous value.
+ *
+ * All fields except for the link-layer address are in network byte order.
+ *
+ * DO NOT change the layout of this structure, or change any of the
+ * LINUX_SLL_ values below.  If you must change the link-layer header
+ * for a "cooked" Linux capture, introduce a new DLT_ type (ask
+ * "tcpdump-workers@lists.tcpdump.org" for one, so that you don't give it
+ * a value that collides with a value already being used), and use the
+ * new header in captures of that type, so that programs that can
+ * handle DLT_LINUX_SLL captures will continue to handle them correctly
+ * without any change, and so that capture files with different headers
+ * can be told apart and programs that read them can dissect the
+ * packets in them.
+ */
+
+#ifndef lib_pcap_sll_h
+#define lib_pcap_sll_h
+
+/*
+ * A DLT_LINUX_SLL fake link-layer header.
+ */
+#define SLL_HDR_LEN	16		/* total header length */
+#define SLL_ADDRLEN	8		/* length of address field */
+
+struct sll_header {
+	u_int16_t sll_pkttype;		/* packet type */
+	u_int16_t sll_hatype;		/* link-layer address type */
+	u_int16_t sll_halen;		/* link-layer address length */
+	u_int8_t sll_addr[SLL_ADDRLEN];	/* link-layer address */
+	u_int16_t sll_protocol;		/* protocol */
+};
+
+/*
+ * The LINUX_SLL_ values for "sll_pkttype"; these correspond to the
+ * PACKET_ values on Linux, but are defined here so that they're
+ * available even on systems other than Linux, and so that they
+ * don't change even if the PACKET_ values change.
+ */
+#define LINUX_SLL_HOST		0
+#define LINUX_SLL_BROADCAST	1
+#define LINUX_SLL_MULTICAST	2
+#define LINUX_SLL_OTHERHOST	3
+#define LINUX_SLL_OUTGOING	4
+
+/*
+ * The LINUX_SLL_ values for "sll_protocol"; these correspond to the
+ * ETH_P_ values on Linux, but are defined here so that they're
+ * available even on systems other than Linux.  We assume, for now,
+ * that the ETH_P_ values won't change in Linux; if they do, then:
+ *
+ *	if we don't translate them in "pcap-linux.c", capture files
+ *	won't necessarily be readable if captured on a system that
+ *	defines ETH_P_ values that don't match these values;
+ *
+ *	if we do translate them in "pcap-linux.c", that makes life
+ *	unpleasant for the BPF code generator, as the values you test
+ *	for in the kernel aren't the values that you test for when
+ *	reading a capture file, so the fixup code run on BPF programs
+ *	handed to the kernel ends up having to do more work.
+ *
+ * Add other values here as necessary, for handling packet types that
+ * might show up on non-Ethernet, non-802.x networks.  (Not all the ones
+ * in the Linux "if_ether.h" will, I suspect, actually show up in
+ * captures.)
+ */
+#define LINUX_SLL_P_802_3	0x0001	/* Novell 802.3 frames without 802.2 LLC header */
+#define LINUX_SLL_P_802_2	0x0004	/* 802.2 frames (not D/I/X Ethernet) */
+
+#endif
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/usb.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/usb.h
new file mode 100644
index 000000000..d4af47a15
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/usb.h
@@ -0,0 +1,81 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+ 
+#ifndef _PCAP_USB_STRUCTS_H__
+#define _PCAP_USB_STRUCTS_H__
+
+/* 
+ * possible transfer mode
+ */
+#define URB_TRANSFER_IN   0x80
+#define URB_ISOCHRONOUS   0x0
+#define URB_INTERRUPT     0x1
+#define URB_CONTROL       0x2
+#define URB_BULK          0x3
+
+/*
+ * possible event type
+ */
+#define URB_SUBMIT        'S'
+#define URB_COMPLETE      'C'
+#define URB_ERROR         'E'
+
+/*
+ * USB setup header as defined in USB specification.
+ * Appears at the front of each packet in DLT_USB captures.
+ */
+typedef struct _usb_setup {
+	u_int8_t bmRequestType;
+	u_int8_t bRequest;
+	u_int16_t wValue;
+	u_int16_t wIndex;
+	u_int16_t wLength;
+} pcap_usb_setup;
+
+
+/*
+ * Header prepended by linux kernel to each event.
+ * Appears at the front of each packet in DLT_USB_LINUX captures.
+ */
+typedef struct _usb_header {
+	u_int64_t id;
+	u_int8_t event_type;
+	u_int8_t transfer_type;
+	u_int8_t endpoint_number;
+	u_int8_t device_address;
+	u_int16_t bus_id;
+	char setup_flag;/*if !=0 the urb setup header is not present*/
+	char data_flag; /*if !=0 no urb data is present*/
+	int64_t ts_sec;
+	int32_t ts_usec;
+	int32_t status;
+	u_int32_t urb_len;
+	u_int32_t data_len; /* amount of urb data really present in this event*/
+	pcap_usb_setup setup;
+} pcap_usb_header;
+
+
+#endif
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/vlan.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/vlan.h
new file mode 100644
index 000000000..576395954
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/pcap/vlan.h
@@ -0,0 +1,37 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef lib_pcap_vlan_h
+#define lib_pcap_vlan_h
+
+struct vlan_tag {
+	u_int16_t	vlan_tpid;		/* ETH_P_8021Q */
+	u_int16_t	vlan_tci;		/* VLAN TCI */
+};
+
+#define VLAN_TAG_LEN	4
+
+#endif
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/remote-ext.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/remote-ext.h
new file mode 100644
index 000000000..cbc7421ac
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/remote-ext.h
@@ -0,0 +1,466 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+
+#ifndef __REMOTE_EXT_H__
+    #define __REMOTE_EXT_H__
+
+
+    #ifndef HAVE_REMOTE
+        #error Please do not include this file directly. Just define HAVE_REMOTE and then include pcap.h
+    #endif
+
+/* Definition for Microsoft Visual Studio */
+    #if _MSC_VER > 1000
+        #pragma once
+    #endif
+
+    #ifdef __cplusplus
+        extern "C" {
+    #endif
+
+/*!
+ *  \file remote-ext.h
+ *
+ *  The goal of this file it to include most of the new definitions that should be
+ *  placed into the pcap.h file.
+ *
+ *  It includes all new definitions (structures and functions like pcap_open().
+ *  Some of the functions are not really a remote feature, but, right now,
+ *  they are placed here.
+ */
+
+
+
+/* All this stuff is public */
+
+/*! \addtogroup remote_struct
+ \{
+ */
+
+
+
+/*!
+ *  \brief Defines the maximum buffer size in which address, port, interface names are kept.
+ *
+ *  In case the adapter name or such is larger than this value, it is truncated.
+ *  This is not used by the user; however it must be aware that an hostname / interface
+ *  name longer than this value will be truncated.
+ */
+    #define PCAP_BUF_SIZE    1024
+
+
+/*! \addtogroup remote_source_ID
+ \{
+ */
+
+
+/*!
+ *  \brief Internal representation of the type of source in use (file,
+ *  remote/local interface).
+ *
+ *  This indicates a file, i.e. the user want to open a capture from a local file.
+ */
+    #define PCAP_SRC_FILE        2
+
+/*!
+ *  \brief Internal representation of the type of source in use (file,
+ *  remote/local interface).
+ *
+ *  This indicates a local interface, i.e. the user want to open a capture from
+ *  a local interface. This does not involve the RPCAP protocol.
+ */
+    #define PCAP_SRC_IFLOCAL     3
+
+/*!
+ *  \brief Internal representation of the type of source in use (file,
+ *  remote/local interface).
+ *
+ *  This indicates a remote interface, i.e. the user want to open a capture from
+ *  an interface on a remote host. This does involve the RPCAP protocol.
+ */
+    #define PCAP_SRC_IFREMOTE    4
+
+/*!
+ \}
+ */
+
+
+
+/*! \addtogroup remote_source_string
+ *
+ *  The formats allowed by the pcap_open() are the following:
+ *  - file://path_and_filename [opens a local file]
+ *  - rpcap://devicename [opens the selected device devices available on the local host, without using the RPCAP protocol]
+ *  - rpcap://host/devicename [opens the selected device available on a remote host]
+ *  - rpcap://host:port/devicename [opens the selected device available on a remote host, using a non-standard port for RPCAP]
+ *  - adaptername [to open a local adapter; kept for compability, but it is strongly discouraged]
+ *  - (NULL) [to open the first local adapter; kept for compability, but it is strongly discouraged]
+ *
+ *  The formats allowed by the pcap_findalldevs_ex() are the following:
+ *  - file://folder/ [lists all the files in the given folder]
+ *  - rpcap:// [lists all local adapters]
+ *  - rpcap://host:port/ [lists the devices available on a remote host]
+ *
+ *  Referring to the 'host' and 'port' paramters, they can be either numeric or literal. Since
+ *  IPv6 is fully supported, these are the allowed formats:
+ *
+ *  - host (literal): e.g. host.foo.bar
+ *  - host (numeric IPv4): e.g. 10.11.12.13
+ *  - host (numeric IPv4, IPv6 style): e.g. [10.11.12.13]
+ *  - host (numeric IPv6): e.g. [1:2:3::4]
+ *  - port: can be either numeric (e.g. '80') or literal (e.g. 'http')
+ *
+ *  Here you find some allowed examples:
+ *  - rpcap://host.foo.bar/devicename [everything literal, no port number]
+ *  - rpcap://host.foo.bar:1234/devicename [everything literal, with port number]
+ *  - rpcap://10.11.12.13/devicename [IPv4 numeric, no port number]
+ *  - rpcap://10.11.12.13:1234/devicename [IPv4 numeric, with port number]
+ *  - rpcap://[10.11.12.13]:1234/devicename [IPv4 numeric with IPv6 format, with port number]
+ *  - rpcap://[1:2:3::4]/devicename [IPv6 numeric, no port number]
+ *  - rpcap://[1:2:3::4]:1234/devicename [IPv6 numeric, with port number]
+ *  - rpcap://[1:2:3::4]:http/devicename [IPv6 numeric, with literal port number]
+ *
+ \{
+ */
+
+
+/*!
+ *  \brief String that will be used to determine the type of source in use (file,
+ *  remote/local interface).
+ *
+ *  This string will be prepended to the interface name in order to create a string
+ *  that contains all the information required to open the source.
+ *
+ *  This string indicates that the user wants to open a capture from a local file.
+ */
+    #define PCAP_SRC_FILE_STRING    "file://"
+
+/*!
+ *  \brief String that will be used to determine the type of source in use (file,
+ *  remote/local interface).
+ *
+ *  This string will be prepended to the interface name in order to create a string
+ *  that contains all the information required to open the source.
+ *
+ *  This string indicates that the user wants to open a capture from a network interface.
+ *  This string does not necessarily involve the use of the RPCAP protocol. If the
+ *  interface required resides on the local host, the RPCAP protocol is not involved
+ *  and the local functions are used.
+ */
+    #define PCAP_SRC_IF_STRING      "rpcap://"
+
+/*!
+ \}
+ */
+
+
+
+/*!
+ *  \addtogroup remote_open_flags
+ \{
+ */
+
+/*!
+ *  \brief Defines if the adapter has to go in promiscuous mode.
+ *
+ *  It is '1' if you have to open the adapter in promiscuous mode, '0' otherwise.
+ *  Note that even if this parameter is false, the interface could well be in promiscuous
+ *  mode for some other reason (for example because another capture process with
+ *  promiscuous mode enabled is currently using that interface).
+ *  On on Linux systems with 2.2 or later kernels (that have the "any" device), this
+ *  flag does not work on the "any" device; if an argument of "any" is supplied,
+ *  the 'promisc' flag is ignored.
+ */
+    #define PCAP_OPENFLAG_PROMISCUOUS    1
+
+/*!
+ *  \brief Defines if the data trasfer (in case of a remote
+ *  capture) has to be done with UDP protocol.
+ *
+ *  If it is '1' if you want a UDP data connection, '0' if you want
+ *  a TCP data connection; control connection is always TCP-based.
+ *  A UDP connection is much lighter, but it does not guarantee that all
+ *  the captured packets arrive to the client workstation. Moreover,
+ *  it could be harmful in case of network congestion.
+ *  This flag is meaningless if the source is not a remote interface.
+ *  In that case, it is simply ignored.
+ */
+    #define PCAP_OPENFLAG_DATATX_UDP     2
+
+
+/*!
+ *  \brief Defines if the remote probe will capture its own generated traffic.
+ *
+ *  In case the remote probe uses the same interface to capture traffic and to send
+ *  data back to the caller, the captured traffic includes the RPCAP traffic as well.
+ *  If this flag is turned on, the RPCAP traffic is excluded from the capture, so that
+ *  the trace returned back to the collector is does not include this traffic.
+ */
+    #define PCAP_OPENFLAG_NOCAPTURE_RPCAP       4
+
+/*!
+ *  \brief Defines if the local adapter will capture its own generated traffic.
+ *
+ *  This flag tells the underlying capture driver to drop the packets that were sent by itself.
+ *  This is usefult when building applications like bridges, that should ignore the traffic
+ *  they just sent.
+ */
+    #define PCAP_OPENFLAG_NOCAPTURE_LOCAL       8
+
+/*!
+ *  \brief This flag configures the adapter for maximum responsiveness.
+ *
+ *  In presence of a large value for nbytes, WinPcap waits for the arrival of several packets before
+ *  copying the data to the user. This guarantees a low number of system calls, i.e. lower processor usage,
+ *  i.e. better performance, which is good for applications like sniffers. If the user sets the
+ *  PCAP_OPENFLAG_MAX_RESPONSIVENESS flag, the capture driver will copy the packets as soon as the application
+ *  is ready to receive them. This is suggested for real time applications (like, for example, a bridge)
+ *  that need the best responsiveness.*/
+    #define PCAP_OPENFLAG_MAX_RESPONSIVENESS    16
+
+/*!
+ \}
+ */
+
+
+/*!
+ *  \addtogroup remote_samp_methods
+ \{
+ */
+
+/*!
+ *  \brief No sampling has to be done on the current capture.
+ *
+ *  In this case, no sampling algorithms are applied to the current capture.
+ */
+    #define PCAP_SAMP_NOSAMP              0
+
+/*!
+ *  \brief It defines that only 1 out of N packets must be returned to the user.
+ *
+ *  In this case, the 'value' field of the 'pcap_samp' structure indicates the
+ *  number of packets (minus 1) that must be discarded before one packet got accepted.
+ *  In other words, if 'value = 10', the first packet is returned to the caller, while
+ *  the following 9 are discarded.
+ */
+    #define PCAP_SAMP_1_EVERY_N           1
+
+/*!
+ *  \brief It defines that we have to return 1 packet every N milliseconds.
+ *
+ *  In this case, the 'value' field of the 'pcap_samp' structure indicates the 'waiting
+ *  time' in milliseconds before one packet got accepted.
+ *  In other words, if 'value = 10', the first packet is returned to the caller; the next
+ *  returned one will be the first packet that arrives when 10ms have elapsed.
+ */
+    #define PCAP_SAMP_FIRST_AFTER_N_MS    2
+
+/*!
+ \}
+ */
+
+
+/*!
+ *  \addtogroup remote_auth_methods
+ \{
+ */
+
+/*!
+ *  \brief It defines the NULL authentication.
+ *
+ *  This value has to be used within the 'type' member of the pcap_rmtauth structure.
+ *  The 'NULL' authentication has to be equal to 'zero', so that old applications
+ *  can just put every field of struct pcap_rmtauth to zero, and it does work.
+ */
+    #define RPCAP_RMTAUTH_NULL    0
+
+/*!
+ *  \brief It defines the username/password authentication.
+ *
+ *  With this type of authentication, the RPCAP protocol will use the username/
+ *  password provided to authenticate the user on the remote machine. If the
+ *  authentication is successful (and the user has the right to open network devices)
+ *  the RPCAP connection will continue; otherwise it will be dropped.
+ *
+ *  This value has to be used within the 'type' member of the pcap_rmtauth structure.
+ */
+    #define RPCAP_RMTAUTH_PWD     1
+
+/*!
+ \}
+ */
+
+
+
+/*!
+ *
+ *  \brief This structure keeps the information needed to autheticate
+ *  the user on a remote machine.
+ *
+ *  The remote machine can either grant or refuse the access according
+ *  to the information provided.
+ *  In case the NULL authentication is required, both 'username' and
+ *  'password' can be NULL pointers.
+ *
+ *  This structure is meaningless if the source is not a remote interface;
+ *  in that case, the functions which requires such a structure can accept
+ *  a NULL pointer as well.
+ */
+    struct pcap_rmtauth
+    {
+        /*!
+         *  \brief Type of the authentication required.
+         *
+         *  In order to provide maximum flexibility, we can support different types
+         *  of authentication based on the value of this 'type' variable. The currently
+         *  supported authentication methods are defined into the
+         *  \link remote_auth_methods Remote Authentication Methods Section\endlink.
+         *
+         */
+        int type;
+
+        /*!
+         *  \brief Zero-terminated string containing the username that has to be
+         *  used on the remote machine for authentication.
+         *
+         *  This field is meaningless in case of the RPCAP_RMTAUTH_NULL authentication
+         *  and it can be NULL.
+         */
+        char * username;
+
+        /*!
+         *  \brief Zero-terminated string containing the password that has to be
+         *  used on the remote machine for authentication.
+         *
+         *  This field is meaningless in case of the RPCAP_RMTAUTH_NULL authentication
+         *  and it can be NULL.
+         */
+        char * password;
+    };
+
+
+/*!
+ *  \brief This structure defines the information related to sampling.
+ *
+ *  In case the sampling is requested, the capturing device should read
+ *  only a subset of the packets coming from the source. The returned packets depend
+ *  on the sampling parameters.
+ *
+ *  \warning The sampling process is applied <strong>after</strong> the filtering process.
+ *  In other words, packets are filtered first, then the sampling process selects a
+ *  subset of the 'filtered' packets and it returns them to the caller.
+ */
+    struct pcap_samp
+    {
+        /*!
+         *  Method used for sampling. Currently, the supported methods are listed in the
+         *  \link remote_samp_methods Sampling Methods Section\endlink.
+         */
+        int method;
+
+        /*!
+         *  This value depends on the sampling method defined. For its meaning, please check
+         *  at the \link remote_samp_methods Sampling Methods Section\endlink.
+         */
+        int value;
+    };
+
+
+
+/*! Maximum lenght of an host name (needed for the RPCAP active mode) */
+    #define RPCAP_HOSTLIST_SIZE    1024
+
+
+/*!
+ \}
+ *//* end of public documentation */
+
+
+/* Exported functions */
+
+
+
+/** \name New WinPcap functions
+ *
+ *  This section lists the new functions that are able to help considerably in writing
+ *  WinPcap programs because of their easiness of use.
+ */
+/*\{ */
+    pcap_t * pcap_open( const char * source,
+                        int snaplen,
+                        int flags,
+                        int read_timeout,
+                        struct pcap_rmtauth * auth,
+                        char * errbuf );
+    int pcap_createsrcstr( char * source,
+                           int type,
+                           const char * host,
+                           const char * port,
+                           const char * name,
+                           char * errbuf );
+    int pcap_parsesrcstr( const char * source,
+                          int * type,
+                          char * host,
+                          char * port,
+                          char * name,
+                          char * errbuf );
+    int pcap_findalldevs_ex( char * source,
+                             struct pcap_rmtauth * auth,
+                             pcap_if_t ** alldevs,
+                             char * errbuf );
+    struct pcap_samp * pcap_setsampling( pcap_t * p );
+
+/*\} */
+/* End of new winpcap functions */
+
+
+
+/** \name Remote Capture functions
+ */
+/*\{ */
+    SOCKET pcap_remoteact_accept( const char * address,
+                                  const char * port,
+                                  const char * hostlist,
+                                  char * connectinghost,
+                                  struct pcap_rmtauth * auth,
+                                  char * errbuf );
+    int pcap_remoteact_list( char * hostlist,
+                             char sep,
+                             int size,
+                             char * errbuf );
+    int pcap_remoteact_close( const char * host,
+                              char * errbuf );
+    void pcap_remoteact_cleanup();
+/*\} */
+/* End of remote capture functions */
+
+    #ifdef __cplusplus
+        }
+    #endif
+
+
+#endif /* ifndef __REMOTE_EXT_H__ */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/wpcap.lib b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/wpcap.lib
new file mode 100644
index 000000000..f832e0445
--- /dev/null
+++ b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/common/WinPCap/wpcap.lib
diff --git a/lexicon.txt b/lexicon.txt
index 047589b57..37a1fb434 100644
--- a/lexicon.txt
+++ b/lexicon.txt
@@ -58,6 +58,7 @@ aren't
 args
 armv
 arp
+arpqc
 arraynotifed
 asc
 ascii
@@ -625,6 +626,7 @@ ebdont
 eblocked
 ebset
 ebwait
+ebff
 ec
 ecc
 ecdh
@@ -720,6 +722,7 @@ esentdata
 esentstart
 eserver
 esp
+estatus
 etaskgetstate
 etaskstateget
 eth
@@ -1103,6 +1106,7 @@ isrtriggeredtask
 isset
 itemlength
 itesm
+itimezone
 itm
 itmc
 itteratio
@@ -1432,6 +1436,7 @@ netbios
 netif
 netifmax
 netiftx
+netinterface
 netmask
 netstat
 networkcontext
@@ -1441,6 +1446,7 @@ ni
 nic
 nirq
 nist
+nl
 nmemb
 nmi
 nnnn
@@ -1464,6 +1470,7 @@ nsec
 nspe
 nt
 ntp
+ntpclient
 ntpdemo
 nts
 ntt
@@ -1505,6 +1512,7 @@ optimiser
 optimising
 optionalquery
 org
+originatetimestamp
 os
 osc
 oszillation
@@ -1609,6 +1617,7 @@ pchead
 pchelpstring
 pchexoutput
 pchost
+pchostname
 pcinputstr
 pcjobdocument
 pcjobid
@@ -1657,6 +1666,7 @@ pcrootdir
 pcrxbuffer
 pcrxedchar
 pcserver
+pcservername
 pcshadowname
 pcsource
 pcstartheaderloc
@@ -2159,6 +2169,7 @@ pwd
 pwm
 pwpr
 pwr
+pxaddress
 pxaddresslen
 pxattrs
 pxbuffer
@@ -2177,6 +2188,7 @@ pxcontext
 pxctx
 pxcurrenttcb
 pxdeserializedinfo
+pxdnsserveraddress
 pxdptr
 pxecdsacontext
 pxecparams
@@ -2231,6 +2243,8 @@ pxreportdescriptor
 pxrequestheaders
 pxrequestinfo
 pxresponse
+pxresult
+pxresults
 pxreturninfo
 pxrng
 pxrngcontext
@@ -2285,6 +2299,7 @@ randomisation
 randomise
 randomised
 randomiser
+raspberrypi
 ratpriorities
 rb
 rbar
@@ -2307,6 +2322,7 @@ reblocked
 receiveloop
 receivetimeout
 receivetimeoutms
+receivetimestamp
 recmucontrolling
 recmutex
 recognisable
@@ -2317,6 +2333,7 @@ recorderdata
 recv
 recvfrom
 recvtimeout
+referenceid
 referencetimestamp
 reflash
 reg
@@ -2542,6 +2559,7 @@ sntperrorauthfailure
 sntpservernotauthenticated
 sntpsuccess
 sntptask
+sntptimestamp
 soc
 sockaddr
 socketauto
@@ -2812,6 +2830,7 @@ ucisstopneededintimerzerocallback
 ucline
 uclisten
 ucminallowablevalue
+ucname
 ucnextbuffertoprocess
 ucnormallyemptyreceivedvalues
 ucnormallyfullreceivedvalues
@@ -2843,6 +2862,7 @@ uihashlen
 uint
 uintptr
 uip
+uk
 ul
 uladditionaloffset
 ulamount
@@ -3015,6 +3035,7 @@ userguide
 usermode
 usernamesize
 usfrequencyhz
+usidentifier
 usindex
 usjobidlength
 usmaxjitter
@@ -3052,6 +3073,7 @@ uxbytesleft
 uxbytesreceived
 uxbytessent
 uxcreatortaskstackbuffer
+uxcurrentseconds
 uxerrorhasoccurred
 uxeventgroupgetnumber
 uxeventqueuelength
@@ -3068,6 +3090,7 @@ uxlistremove
 uxloopcount
 uxmaxcount
 uxmessageswaiting
+uxnetworkisup
 uxnewpriority
 uxnumbertocreate
 uxpacketsreceived
@@ -3115,6 +3138,7 @@ vapplicationidlehook
 vapplicationipnetworkeventhook
 vapplicationirqhandler
 vapplicationmallocfailedhook
+vapplicationpingreplyhook
 vapplicationsetupinterrupts
 vapplicationsetuptimerinterrupt
 vapplicationstackoverflowhook
@@ -3235,6 +3259,7 @@ vstartdefenderdemo
 vstartfleetprovisioningdemo
 vstartjobsdemo
 vstartmathtasks
+vstartntptask
 vstartotademo
 vstartshadowdemo
 vstartsimplehttpdemo
@@ -3307,6 +3332,7 @@ xa
 xactionlength
 xaddress
 xaddresslength
+xafterlinebreak
 xapplicationdhcpuserhook
 xaredynamicprioritytasksstillrunning
 xareflopregistertestsstillrunning
@@ -3318,6 +3344,7 @@ xarestreambuffertasksstillrunning
 xaretasknotificationarraytasksstillrunning
 xarraysize
 xasymmetricalgorithm
+xasynchronous
 xautoreload
 xautoreloadtimers
 xb
@@ -3431,6 +3458,7 @@ xhelpcommand
 xhigherprioritytaskwoken
 xhighprioritymutextask
 xhighprioritytaskwoken
+xhints
 xhostlen
 xhow
 xilinx
@@ -3440,7 +3468,9 @@ xinputstrlen
 xinsideinterrupt
 xinterface
 xinterruptcontroller
+xipaddressfound
 xiptracevalues
+xipversion
 xirqrequest
 xisinsideisr
 xisrautoreloadtimer
@@ -3463,6 +3493,7 @@ xlen
 xlength
 xlentosend
 xlimitedincrementhandle
+xlogging
 xlogtofile
 xlogtostdout
 xlogtoudp
@@ -3503,6 +3534,7 @@ xnextwaketime
 xnotifyarraytaskfromisr
 xntppacket
 xntptaskhandle
+xntptaskisrunning
 xnumberofleds
 xnumberofsuccessfulallocations
 xnumberofsuccessfulfrees
@@ -3764,6 +3796,7 @@ xtracerunning
 xtransfercompletedelay
 xtransfersocket
 xtransmitted
+xtrue
 xtrueobject
 xts
 xttcps