]> git.sur5r.net Git - freertos/commitdiff
Restart the task pool demo, this time using the minimal FreeRTOS+TCP project as a...
authorrtel <rtel@1d2547de-c912-0410-9cb9-b8ca96c0e9e2>
Sun, 14 Jul 2019 18:01:57 +0000 (18:01 +0000)
committerrtel <rtel@1d2547de-c912-0410-9cb9-b8ca96c0e9e2>
Sun, 14 Jul 2019 18:01:57 +0000 (18:01 +0000)
git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@2677 1d2547de-c912-0410-9cb9-b8ca96c0e9e2

31 files changed:
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/DemoTasks/SimpleUDPClientAndServer.c [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/DemoTasks/include/SimpleUDPClientAndServer.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/FreeRTOSConfig.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/FreeRTOSIPConfig.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/FreeRTOS_Plus_TCP_Minimal.sln [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WIN32.vcxproj [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WIN32.vcxproj.filters [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/Packet32.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/PacketData.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/Win32-Extensions.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/arch.c [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/bittypes.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/ip6_misc.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/netif.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap-bpf.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap-namedb.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap-stdinc.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/bluetooth.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/bpf.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/namedb.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/pcap.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/sll.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/usb.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/vlan.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/remote-ext.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/wpcap.lib [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/demo_logging.c [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/demo_logging.h [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/main.c [new file with mode: 0644]
FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/printf-stdarg.c [new file with mode: 0644]

diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/DemoTasks/SimpleUDPClientAndServer.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/DemoTasks/SimpleUDPClientAndServer.c
new file mode 100644 (file)
index 0000000..54143c3
--- /dev/null
@@ -0,0 +1,355 @@
+/*\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
+\r
+/*\r
+ * Creates two transmitting tasks and two receiving tasks.  The transmitting\r
+ * tasks send values that are received by the receiving tasks.  One set of tasks\r
+ * uses the standard API.  The other set of tasks uses the zero copy API.\r
+ *\r
+ * See the following web page for essential demo usage and configuration\r
+ * details:\r
+ * http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html\r
+ */\r
+\r
+/* Standard includes. */\r
+#include <stdint.h>\r
+#include <stdio.h>\r
+\r
+/* FreeRTOS includes. */\r
+#include "FreeRTOS.h"\r
+#include "task.h"\r
+\r
+/* FreeRTOS+TCP includes. */\r
+#include "FreeRTOS_IP.h"\r
+#include "FreeRTOS_Sockets.h"\r
+\r
+#define simpTINY_DELAY ( ( TickType_t ) 2 )\r
+\r
+/*\r
+ * Uses a socket to send data without using the zero copy option.\r
+ * prvSimpleServerTask() will receive the data.\r
+ */\r
+static void prvSimpleClientTask( void *pvParameters );\r
+\r
+/*\r
+ * Uses a socket to receive the data sent by the prvSimpleClientTask() task.\r
+ * Does not use the zero copy option.\r
+ */\r
+static void prvSimpleServerTask( void *pvParameters );\r
+\r
+/*\r
+ * Uses a socket to send data using the zero copy option.\r
+ * prvSimpleZeroCopyServerTask() will receive the data.\r
+ */\r
+static void prvSimpleZeroCopyUDPClientTask( void *pvParameters );\r
+\r
+/*\r
+ * Uses a socket to receive the data sent by the prvSimpleZeroCopyUDPClientTask()\r
+ * task.  Uses the zero copy option.\r
+ */\r
+static void prvSimpleZeroCopyServerTask( void *pvParameters );\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+void vStartSimpleUDPClientServerTasks( uint16_t usStackSize, uint32_t ulPort, UBaseType_t uxPriority )\r
+{\r
+       /* Create the client and server tasks that do not use the zero copy\r
+       interface. */\r
+       xTaskCreate( prvSimpleClientTask, "SimpCpyClnt", usStackSize, ( void * ) ulPort, uxPriority, NULL );\r
+       xTaskCreate( prvSimpleServerTask, "SimpCpySrv", usStackSize, ( void * ) ulPort, uxPriority + 1, NULL );\r
+\r
+       /* Create the client and server tasks that do use the zero copy interface. */\r
+       xTaskCreate( prvSimpleZeroCopyUDPClientTask, "SimpZCpyClnt", usStackSize, ( void * ) ( ulPort + 1 ), uxPriority, NULL );\r
+       xTaskCreate( prvSimpleZeroCopyServerTask, "SimpZCpySrv", usStackSize, ( void * ) ( ulPort + 1 ), uxPriority + 1, NULL );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvSimpleClientTask( void *pvParameters )\r
+{\r
+Socket_t xClientSocket;\r
+struct freertos_sockaddr xDestinationAddress;\r
+uint8_t cString[ 65 ];\r
+BaseType_t lReturned;\r
+uint32_t ulCount = 0UL, ulIPAddress;\r
+const uint32_t ulLoopsPerSocket = 10UL;\r
+const TickType_t x150ms = 150UL / portTICK_PERIOD_MS;\r
+\r
+       /* Remove compiler warning about unused parameters. */\r
+       ( void ) pvParameters;\r
+\r
+       /* It is assumed that this task is not created until the network is up,\r
+       so the IP address can be obtained immediately.  store the IP address being\r
+       used in ulIPAddress.  This is done so the socket can send to a different\r
+       port on the same IP address. */\r
+       FreeRTOS_GetAddressConfiguration( &ulIPAddress, NULL, NULL, NULL );\r
+\r
+       /* This test sends to itself, so data sent from here is received by a server\r
+       socket on the same IP address.  Setup the freertos_sockaddr structure with\r
+       this nodes IP address, and the port number being sent to.  The strange\r
+       casting is to try and remove compiler warnings on 32 bit machines. */\r
+       xDestinationAddress.sin_addr = ulIPAddress;\r
+       xDestinationAddress.sin_port = ( uint16_t ) ( ( uint32_t ) pvParameters ) & 0xffffUL;\r
+       xDestinationAddress.sin_port = FreeRTOS_htons( xDestinationAddress.sin_port );\r
+\r
+       for( ;; )\r
+       {\r
+               /* Create the socket. */\r
+               xClientSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );\r
+               configASSERT( xClientSocket != FREERTOS_INVALID_SOCKET );\r
+\r
+               /* The count is used to differentiate between different messages sent to\r
+               the server, and to break out of the do while loop below. */\r
+               ulCount = 0UL;\r
+\r
+               do\r
+               {\r
+                       /* Create the string that is sent to the server. */\r
+                       sprintf( ( char * ) cString, "Server received (not zero copy): Message number %lu\r\n", ulCount );\r
+\r
+                       /* Send the string to the socket.  ulFlags is set to 0, so the zero\r
+                       copy option is not selected.  That means the data from cString[] is\r
+                       copied into a network buffer inside FreeRTOS_sendto(), and cString[]\r
+                       can be reused as soon as FreeRTOS_sendto() has returned. */\r
+                       lReturned = FreeRTOS_sendto( xClientSocket, ( void * ) cString, strlen( ( const char * ) cString ), 0, &xDestinationAddress, sizeof( xDestinationAddress ) );\r
+\r
+                       ulCount++;\r
+\r
+               } while( ( lReturned != FREERTOS_SOCKET_ERROR ) && ( ulCount < ulLoopsPerSocket ) );\r
+\r
+               FreeRTOS_closesocket( xClientSocket );\r
+\r
+               /* A short delay to prevent the messages printed by the server task\r
+               scrolling off the screen too quickly, and to prevent reduce the network\r
+               loading. */\r
+               vTaskDelay( x150ms );\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvSimpleServerTask( void *pvParameters )\r
+{\r
+int32_t lBytes;\r
+uint8_t cReceivedString[ 60 ];\r
+struct freertos_sockaddr xClient, xBindAddress;\r
+uint32_t xClientLength = sizeof( xClient );\r
+Socket_t xListeningSocket;\r
+\r
+       /* Just to prevent compiler warnings. */\r
+       ( void ) pvParameters;\r
+\r
+       /* Attempt to open the socket. */\r
+       xListeningSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );\r
+       configASSERT( xListeningSocket != FREERTOS_INVALID_SOCKET );\r
+\r
+       /* This test receives data sent from a different port on the same IP\r
+       address.  Configure the freertos_sockaddr structure with the address being\r
+       bound to.  The strange casting is to try and remove     compiler warnings on 32\r
+       bit machines.  Note that this task is only created after the network is up,\r
+       so the IP address is valid here. */\r
+       xBindAddress.sin_port = ( uint16_t ) ( ( uint32_t ) pvParameters ) & 0xffffUL;\r
+       xBindAddress.sin_port = FreeRTOS_htons( xBindAddress.sin_port );\r
+\r
+       /* Bind the socket to the port that the client task will send to. */\r
+       FreeRTOS_bind( xListeningSocket, &xBindAddress, sizeof( xBindAddress ) );\r
+\r
+       for( ;; )\r
+       {\r
+               /* Zero out the receive array so there is NULL at the end of the string\r
+               when it is printed out. */\r
+               memset( cReceivedString, 0x00, sizeof( cReceivedString ) );\r
+\r
+               /* Receive data on the socket.  ulFlags is zero, so the zero copy option\r
+               is not set and the received data is copied into the buffer pointed to by\r
+               cReceivedString.  By default the block time is portMAX_DELAY.\r
+               xClientLength is not actually used by FreeRTOS_recvfrom(), but is set\r
+               appropriately in case future versions do use it. */\r
+               lBytes = FreeRTOS_recvfrom( xListeningSocket, cReceivedString, sizeof( cReceivedString ), 0, &xClient, &xClientLength );\r
+\r
+               /* Error check. */\r
+               configASSERT( lBytes == ( BaseType_t ) strlen( ( const char * ) cReceivedString ) );\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvSimpleZeroCopyUDPClientTask( void *pvParameters )\r
+{\r
+Socket_t xClientSocket;\r
+uint8_t *pucUDPPayloadBuffer;\r
+struct freertos_sockaddr xDestinationAddress;\r
+BaseType_t lReturned;\r
+uint32_t ulCount = 0UL, ulIPAddress;\r
+const uint32_t ulLoopsPerSocket = 10UL;\r
+const char *pcStringToSend = "Server received (using zero copy): Message number ";\r
+const TickType_t x150ms = 150UL / portTICK_PERIOD_MS;\r
+/* 15 is added to ensure the number, \r\n and terminating zero fit. */\r
+const size_t xStringLength = strlen( pcStringToSend ) + 15;\r
+\r
+       /* Remove compiler warning about unused parameters. */\r
+       ( void ) pvParameters;\r
+\r
+       /* It is assumed that this task is not created until the network is up,\r
+       so the IP address can be obtained immediately.  store the IP address being\r
+       used in ulIPAddress.  This is done so the socket can send to a different\r
+       port on the same IP address. */\r
+       FreeRTOS_GetAddressConfiguration( &ulIPAddress, NULL, NULL, NULL );\r
+\r
+       /* This test sends to itself, so data sent from here is received by a server\r
+       socket on the same IP address.  Setup the freertos_sockaddr structure with\r
+       this nodes IP address, and the port number being sent to.  The strange\r
+       casting is to try and remove compiler warnings on 32 bit machines. */\r
+       xDestinationAddress.sin_addr = ulIPAddress;\r
+       xDestinationAddress.sin_port = ( uint16_t ) ( ( uint32_t ) pvParameters ) & 0xffffUL;\r
+       xDestinationAddress.sin_port = FreeRTOS_htons( xDestinationAddress.sin_port );\r
+\r
+       for( ;; )\r
+       {\r
+               /* Create the socket. */\r
+               xClientSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );\r
+               configASSERT( xClientSocket != FREERTOS_INVALID_SOCKET );\r
+\r
+               /* The count is used to differentiate between different messages sent to\r
+               the server, and to break out of the do while loop below. */\r
+               ulCount = 0UL;\r
+\r
+               do\r
+               {\r
+                       /* This task is going to send using the zero copy interface.  The\r
+                       data being sent is therefore written directly into a buffer that is\r
+                       passed into, rather than copied into, the FreeRTOS_sendto()\r
+                       function.\r
+\r
+                       First obtain a buffer of adequate length from the IP stack into which\r
+                       the string will be written.  Although a max delay is used, the actual\r
+                       delay will be capped to ipconfigMAX_SEND_BLOCK_TIME_TICKS, hence\r
+                       the do while loop is used to ensure a buffer is obtained. */\r
+                       do\r
+                       {\r
+                       } while( ( pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( xStringLength, portMAX_DELAY ) ) == NULL );\r
+\r
+                       /* A buffer was successfully obtained.  Create the string that is\r
+                       sent to the server.  First the string is filled with zeros as this will\r
+                       effectively be the null terminator when the string is received at the other\r
+                       end.  Note that the string is being written directly into the buffer\r
+                       obtained from the IP stack above. */\r
+                       memset( ( void * ) pucUDPPayloadBuffer, 0x00, xStringLength );\r
+                       sprintf( ( char * ) pucUDPPayloadBuffer, "%s%lu\r\n", pcStringToSend, ulCount );\r
+\r
+                       /* Pass the buffer into the send function.  ulFlags has the\r
+                       FREERTOS_ZERO_COPY bit set so the IP stack will take control of the\r
+                       buffer rather than copy data out of the buffer. */\r
+                       lReturned = FreeRTOS_sendto( xClientSocket,                             /* The socket being sent to. */\r
+                                                                               ( void * ) pucUDPPayloadBuffer, /* A pointer to the the data being sent. */\r
+                                                                               strlen( ( const char * ) pucUDPPayloadBuffer ) + 1, /* The length of the data being sent - including the string's null terminator. */\r
+                                                                               FREERTOS_ZERO_COPY,                     /* ulFlags with the FREERTOS_ZERO_COPY bit set. */\r
+                                                                               &xDestinationAddress,                   /* Where the data is being sent. */\r
+                                                                               sizeof( xDestinationAddress ) );\r
+\r
+                       if( lReturned == 0 )\r
+                       {\r
+                               /* The send operation failed, so this task is still responsible\r
+                               for the buffer obtained from the IP stack.  To ensure the buffer\r
+                               is not lost it must either be used again, or, as in this case,\r
+                               returned to the IP stack using FreeRTOS_ReleaseUDPPayloadBuffer().\r
+                               pucUDPPayloadBuffer can be safely re-used after this call. */\r
+                               FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayloadBuffer );\r
+                       }\r
+                       else\r
+                       {\r
+                               /* The send was successful so the IP stack is now managing the\r
+                               buffer pointed to by pucUDPPayloadBuffer, and the IP stack will\r
+                               return the buffer once it has been sent.  pucUDPPayloadBuffer can\r
+                               be safely re-used. */\r
+                       }\r
+\r
+                       ulCount++;\r
+\r
+               } while( ( lReturned != FREERTOS_SOCKET_ERROR ) && ( ulCount < ulLoopsPerSocket ) );\r
+\r
+               FreeRTOS_closesocket( xClientSocket );\r
+\r
+               /* A short delay to prevent the messages scrolling off the screen too\r
+               quickly. */\r
+               vTaskDelay( x150ms );\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvSimpleZeroCopyServerTask( void *pvParameters )\r
+{\r
+int32_t lBytes;\r
+uint8_t *pucUDPPayloadBuffer;\r
+struct freertos_sockaddr xClient, xBindAddress;\r
+uint32_t xClientLength = sizeof( xClient ), ulIPAddress;\r
+Socket_t xListeningSocket;\r
+\r
+       /* Just to prevent compiler warnings. */\r
+       ( void ) pvParameters;\r
+\r
+       /* Attempt to open the socket. */\r
+       xListeningSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );\r
+       configASSERT( xListeningSocket != FREERTOS_INVALID_SOCKET );\r
+\r
+       /* This test receives data sent from a different port on the same IP address.\r
+       Obtain the nodes IP address.  Configure the freertos_sockaddr structure with\r
+       the address being bound to.  The strange casting is to try and remove\r
+       compiler warnings on 32 bit machines.  Note that this task is only created\r
+       after the network is up, so the IP address is valid here. */\r
+       FreeRTOS_GetAddressConfiguration( &ulIPAddress, NULL, NULL, NULL );\r
+       xBindAddress.sin_addr = ulIPAddress;\r
+       xBindAddress.sin_port = ( uint16_t ) ( ( uint32_t ) pvParameters ) & 0xffffUL;\r
+       xBindAddress.sin_port = FreeRTOS_htons( xBindAddress.sin_port );\r
+\r
+       /* Bind the socket to the port that the client task will send to. */\r
+       FreeRTOS_bind( xListeningSocket, &xBindAddress, sizeof( xBindAddress ) );\r
+\r
+       for( ;; )\r
+       {\r
+               /* Receive data on the socket.  ulFlags has the zero copy bit set\r
+               (FREERTOS_ZERO_COPY) indicating to the stack that a reference to the\r
+               received data should be passed out to this task using the second\r
+               parameter to the FreeRTOS_recvfrom() call.  When this is done the\r
+               IP stack is no longer responsible for releasing the buffer, and\r
+               the task *must* return the buffer to the stack when it is no longer\r
+               needed.  By default the block time is portMAX_DELAY. */\r
+               lBytes = FreeRTOS_recvfrom( xListeningSocket, ( void * ) &pucUDPPayloadBuffer, 0, FREERTOS_ZERO_COPY, &xClient, &xClientLength );\r
+\r
+               /* Print the received characters. */\r
+               if( lBytes > 0 )\r
+               {\r
+                       /* It is expected to receive one more byte than the string length as\r
+                       the NULL terminator is also transmitted. */\r
+                       configASSERT( lBytes == ( ( BaseType_t ) strlen( ( const char * ) pucUDPPayloadBuffer ) + 1 ) );\r
+               }\r
+\r
+               if( lBytes >= 0 )\r
+               {\r
+                       /* The buffer *must* be freed once it is no longer needed. */\r
+                       FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayloadBuffer );\r
+               }\r
+       }\r
+}\r
+\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/DemoTasks/include/SimpleUDPClientAndServer.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/DemoTasks/include/SimpleUDPClientAndServer.h
new file mode 100644 (file)
index 0000000..342ab12
--- /dev/null
@@ -0,0 +1,33 @@
+/*\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
+\r
+#ifndef SIMPLE_UDP_CLIENT_AND_SERVER_H\r
+#define SIMPLE_UDPCLIENT_AND_SERVER_H\r
+\r
+void vStartSimpleUDPClientServerTasks( uint16_t usStackSize, uint32_t ulsPort, UBaseType_t uxPriority );\r
+\r
+#endif /* SIMPLE_UDPCLIENT_AND_SERVER_H */\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/FreeRTOSConfig.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/FreeRTOSConfig.h
new file mode 100644 (file)
index 0000000..e68bd81
--- /dev/null
@@ -0,0 +1,205 @@
+/*\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
+\r
+#ifndef FREERTOS_CONFIG_H\r
+#define FREERTOS_CONFIG_H\r
+\r
+/*-----------------------------------------------------------\r
+ * Application specific definitions.\r
+ *\r
+ * These definitions should be adjusted for your particular hardware and\r
+ * application requirements.\r
+ *\r
+ * THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE\r
+ * FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.\r
+ * http://www.freertos.org/a00110.html\r
+ *\r
+ * The bottom of this file contains some constants specific to running the UDP\r
+ * stack in this demo.  Constants specific to FreeRTOS+TCP itself (rather than\r
+ * the demo) are contained in FreeRTOSIPConfig.h.\r
+ *----------------------------------------------------------*/\r
+#define configUSE_PREEMPTION                                   1\r
+#define configUSE_PORT_OPTIMISED_TASK_SELECTION        1\r
+#define configMAX_PRIORITIES                                   ( 7 )\r
+#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. */\r
+#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. */\r
+#define configTOTAL_HEAP_SIZE                                  ( ( size_t ) ( 2048U * 1024U ) )\r
+#define configMAX_TASK_NAME_LEN                                        ( 15 )\r
+#define configUSE_TRACE_FACILITY                               1\r
+#define configUSE_16_BIT_TICKS                                 0\r
+#define configIDLE_SHOULD_YIELD                                        1\r
+#define configUSE_CO_ROUTINES                                  0\r
+#define configUSE_MUTEXES                                              1\r
+#define configUSE_RECURSIVE_MUTEXES                            1\r
+#define configQUEUE_REGISTRY_SIZE                              0\r
+#define configUSE_APPLICATION_TASK_TAG                 0\r
+#define configUSE_COUNTING_SEMAPHORES                  1\r
+#define configUSE_ALTERNATIVE_API                              0\r
+#define configNUM_THREAD_LOCAL_STORAGE_POINTERS        0\r
+#define configENABLE_BACKWARD_COMPATIBILITY            1\r
+\r
+/* Hook function related definitions. */\r
+#define configUSE_TICK_HOOK                            0\r
+#define configUSE_IDLE_HOOK                            1\r
+#define configUSE_MALLOC_FAILED_HOOK   1\r
+#define configCHECK_FOR_STACK_OVERFLOW 0 /* Not applicable to the Win32 port. */\r
+\r
+/* Software timer related definitions. */\r
+#define configUSE_TIMERS                               1\r
+#define configTIMER_TASK_PRIORITY              ( configMAX_PRIORITIES - 1 )\r
+#define configTIMER_QUEUE_LENGTH               5\r
+#define configTIMER_TASK_STACK_DEPTH   ( configMINIMAL_STACK_SIZE * 2 )\r
+\r
+/* Event group related definitions. */\r
+#define configUSE_EVENT_GROUPS                 1\r
+\r
+/* Run time stats gathering definitions. */\r
+#define configGENERATE_RUN_TIME_STATS  0\r
+\r
+/* Co-routine definitions. */\r
+#define configUSE_CO_ROUTINES                  0\r
+#define configMAX_CO_ROUTINE_PRIORITIES ( 2 )\r
+\r
+/* Set the following definitions to 1 to include the API function, or zero\r
+to exclude the API function. */\r
+#define INCLUDE_vTaskPrioritySet                               1\r
+#define INCLUDE_uxTaskPriorityGet                              1\r
+#define INCLUDE_vTaskDelete                                            1\r
+#define INCLUDE_vTaskCleanUpResources                  0\r
+#define INCLUDE_vTaskSuspend                                   1\r
+#define INCLUDE_vTaskDelayUntil                                        1\r
+#define INCLUDE_vTaskDelay                                             1\r
+#define INCLUDE_uxTaskGetStackHighWaterMark            1\r
+#define INCLUDE_xTaskGetSchedulerState                 1\r
+#define INCLUDE_xTimerGetTimerTaskHandle               0\r
+#define INCLUDE_xTaskGetIdleTaskHandle                 0\r
+#define INCLUDE_xQueueGetMutexHolder                   1\r
+#define INCLUDE_eTaskGetState                                  1\r
+#define INCLUDE_xEventGroupSetBitsFromISR              1\r
+#define INCLUDE_xTimerPendFunctionCall                 1\r
+#define INCLUDE_pcTaskGetTaskName                              1\r
+\r
+/* This demo makes use of one or more example stats formatting functions.  These\r
+format the raw data provided by the uxTaskGetSystemState() function in to human\r
+readable ASCII form.  See the notes in the implementation of vTaskList() within\r
+FreeRTOS/Source/tasks.c for limitations.  configUSE_STATS_FORMATTING_FUNCTIONS\r
+is set to 2 so the formatting functions are included without the stdio.h being\r
+included in tasks.c.  That is because this project defines its own sprintf()\r
+functions. */\r
+#define configUSE_STATS_FORMATTING_FUNCTIONS   1\r
+\r
+/* Assert call defined for debug builds. */\r
+#ifdef _DEBUG\r
+       extern void vAssertCalled( const char *pcFile, uint32_t ulLine );\r
+       #define configASSERT( x ) if( ( x ) == 0 ) vAssertCalled( __FILE__, __LINE__ )\r
+#endif /* _DEBUG */\r
+\r
+\r
+\r
+/* Application specific definitions follow. **********************************/\r
+\r
+/* Only used when running in the FreeRTOS Windows simulator.  Defines the\r
+priority of the task used to simulate Ethernet interrupts. */\r
+#define configMAC_ISR_SIMULATOR_PRIORITY       ( configMAX_PRIORITIES - 1 )\r
+\r
+/* This demo creates a virtual network connection by accessing the raw Ethernet\r
+or WiFi data to and from a real network connection.  Many computers have more\r
+than one real network port, and configNETWORK_INTERFACE_TO_USE is used to tell\r
+the demo which real port should be used to create the virtual port.  The ports\r
+available are displayed on the console when the application is executed.  For\r
+example, on my development laptop setting configNETWORK_INTERFACE_TO_USE to 4\r
+results in the wired network being used, while setting\r
+configNETWORK_INTERFACE_TO_USE to 2 results in the wireless network being\r
+used. */\r
+#define configNETWORK_INTERFACE_TO_USE 4L\r
+\r
+/* The address of an echo server that will be used by the two demo echo client\r
+tasks.\r
+http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/TCP_Echo_Clients.html\r
+http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/UDP_Echo_Clients.html */\r
+#define configECHO_SERVER_ADDR0        192\r
+#define configECHO_SERVER_ADDR1 168\r
+#define configECHO_SERVER_ADDR2 0\r
+#define configECHO_SERVER_ADDR3 11\r
+\r
+/* Default MAC address configuration.  The demo creates a virtual network\r
+connection that uses this MAC address by accessing the raw Ethernet/WiFi data\r
+to and from a real network connection on the host PC.  See the\r
+configNETWORK_INTERFACE_TO_USE definition above for information on how to\r
+configure the real network connection to use. */\r
+#define configMAC_ADDR0                0x00\r
+#define configMAC_ADDR1                0x11\r
+#define configMAC_ADDR2                0x22\r
+#define configMAC_ADDR3                0x33\r
+#define configMAC_ADDR4                0x44\r
+#define configMAC_ADDR5                0x41\r
+\r
+/* Default IP address configuration.  Used in ipconfigUSE_DNS is set to 0, or\r
+ipconfigUSE_DNS is set to 1 but a DNS server cannot be contacted. */\r
+#define configIP_ADDR0         10\r
+#define configIP_ADDR1         10\r
+#define configIP_ADDR2         10\r
+#define configIP_ADDR3         200\r
+\r
+/* Default gateway IP address configuration.  Used in ipconfigUSE_DNS is set to\r
+0, or ipconfigUSE_DNS is set to 1 but a DNS server cannot be contacted. */\r
+#define configGATEWAY_ADDR0    10\r
+#define configGATEWAY_ADDR1    10\r
+#define configGATEWAY_ADDR2    10\r
+#define configGATEWAY_ADDR3    1\r
+\r
+/* Default DNS server configuration.  OpenDNS addresses are 208.67.222.222 and\r
+208.67.220.220.  Used in ipconfigUSE_DNS is set to 0, or ipconfigUSE_DNS is set\r
+to 1 but a DNS server cannot be contacted.*/\r
+#define configDNS_SERVER_ADDR0         208\r
+#define configDNS_SERVER_ADDR1         67\r
+#define configDNS_SERVER_ADDR2         222\r
+#define configDNS_SERVER_ADDR3         222\r
+\r
+/* Default netmask configuration.  Used in ipconfigUSE_DNS is set to 0, or\r
+ipconfigUSE_DNS is set to 1 but a DNS server cannot be contacted. */\r
+#define configNET_MASK0                255\r
+#define configNET_MASK1                0\r
+#define configNET_MASK2                0\r
+#define configNET_MASK3                0\r
+\r
+/* The UDP port to which print messages are sent. */\r
+#define configPRINT_PORT       ( 15000 )\r
+\r
+#if( defined( _MSC_VER ) && ( _MSC_VER <= 1600 ) && !defined( snprintf ) )\r
+       /* Map to Windows names. */\r
+       #define snprintf        _snprintf\r
+       #define vsnprintf       _vsnprintf\r
+#endif\r
+\r
+/* Visual studio does not have an implementation of strcasecmp(). */\r
+#define strcasecmp _stricmp\r
+#define strncasecmp _strnicmp\r
+#define strcmpi _strcmpi\r
+\r
+#endif /* FREERTOS_CONFIG_H */\r
+\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/FreeRTOSIPConfig.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/FreeRTOSIPConfig.h
new file mode 100644 (file)
index 0000000..ff980e3
--- /dev/null
@@ -0,0 +1,307 @@
+/*\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
+\r
+\r
+/*****************************************************************************\r
+ *\r
+ * See the following URL for configuration information.\r
+ * http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/TCP_IP_Configuration.html\r
+ *\r
+ *****************************************************************************/\r
+\r
+#ifndef FREERTOS_IP_CONFIG_H\r
+#define FREERTOS_IP_CONFIG_H\r
+\r
+/* Prototype for the function used to print out.  In this case it prints to the\r
+console before the network is connected then a UDP port after the network has\r
+connected. */\r
+extern void vLoggingPrintf( const char *pcFormatString, ... );\r
+\r
+/* Set to 1 to print out debug messages.  If ipconfigHAS_DEBUG_PRINTF is set to\r
+1 then FreeRTOS_debug_printf should be defined to the function used to print\r
+out the debugging messages. */\r
+#define ipconfigHAS_DEBUG_PRINTF       0\r
+#if( ipconfigHAS_DEBUG_PRINTF == 1 )\r
+       #define FreeRTOS_debug_printf(X)        vLoggingPrintf X\r
+#endif\r
+\r
+/* Set to 1 to print out non debugging messages, for example the output of the\r
+FreeRTOS_netstat() command, and ping replies.  If ipconfigHAS_PRINTF is set to 1\r
+then FreeRTOS_printf should be set to the function used to print out the\r
+messages. */\r
+#define ipconfigHAS_PRINTF                     1\r
+#if( ipconfigHAS_PRINTF == 1 )\r
+       #define FreeRTOS_printf(X)                      vLoggingPrintf X\r
+#endif\r
+\r
+/* Define the byte order of the target MCU (the MCU FreeRTOS+TCP is executing\r
+on).  Valid options are pdFREERTOS_BIG_ENDIAN and pdFREERTOS_LITTLE_ENDIAN. */\r
+#define ipconfigBYTE_ORDER pdFREERTOS_LITTLE_ENDIAN\r
+\r
+/* If the network card/driver includes checksum offloading (IP/TCP/UDP checksums)\r
+then set ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM to 1 to prevent the software\r
+stack repeating the checksum calculations. */\r
+#define ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM   1\r
+\r
+/* Several API's will block until the result is known, or the action has been\r
+performed, for example FreeRTOS_send() and FreeRTOS_recv().  The timeouts can be\r
+set per socket, using setsockopt().  If not set, the times below will be\r
+used as defaults. */\r
+#define ipconfigSOCK_DEFAULT_RECEIVE_BLOCK_TIME        ( 5000 )\r
+#define        ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME    ( 5000 )\r
+\r
+/* Include support for LLMNR: Link-local Multicast Name Resolution\r
+(non-Microsoft) */\r
+#define ipconfigUSE_LLMNR                                      ( 1 )\r
+\r
+/* Include support for NBNS: NetBIOS Name Service (Microsoft) */\r
+#define ipconfigUSE_NBNS                                       ( 1 )\r
+\r
+/* Include support for DNS caching.  For TCP, having a small DNS cache is very\r
+useful.  When a cache is present, ipconfigDNS_REQUEST_ATTEMPTS can be kept low\r
+and also DNS may use small timeouts.  If a DNS reply comes in after the DNS\r
+socket has been destroyed, the result will be stored into the cache.  The next\r
+call to FreeRTOS_gethostbyname() will return immediately, without even creating\r
+a socket. */\r
+#define ipconfigUSE_DNS_CACHE                          ( 1 )\r
+#define ipconfigDNS_CACHE_NAME_LENGTH          ( 16 )\r
+#define ipconfigDNS_CACHE_ENTRIES                      ( 4 )\r
+#define ipconfigDNS_REQUEST_ATTEMPTS           ( 2 )\r
+\r
+/* The IP stack executes it its own task (although any application task can make\r
+use of its services through the published sockets API). ipconfigUDP_TASK_PRIORITY\r
+sets the priority of the task that executes the IP stack.  The priority is a\r
+standard FreeRTOS task priority so can take any value from 0 (the lowest\r
+priority) to (configMAX_PRIORITIES - 1) (the highest priority).\r
+configMAX_PRIORITIES is a standard FreeRTOS configuration parameter defined in\r
+FreeRTOSConfig.h, not FreeRTOSIPConfig.h. Consideration needs to be given as to\r
+the priority assigned to the task executing the IP stack relative to the\r
+priority assigned to tasks that use the IP stack. */\r
+#define ipconfigIP_TASK_PRIORITY                       ( configMAX_PRIORITIES - 2 )\r
+\r
+/* The size, in words (not bytes), of the stack allocated to the FreeRTOS+TCP\r
+task.  This setting is less important when the FreeRTOS Win32 simulator is used\r
+as the Win32 simulator only stores a fixed amount of information on the task\r
+stack.  FreeRTOS includes optional stack overflow detection, see:\r
+http://www.freertos.org/Stacks-and-stack-overflow-checking.html */\r
+#define ipconfigIP_TASK_STACK_SIZE_WORDS       ( configMINIMAL_STACK_SIZE * 5 )\r
+\r
+/* ipconfigRAND32() is called by the IP stack to generate random numbers for\r
+things such as a DHCP transaction number or initial sequence number.  Random\r
+number generation is performed via this macro to allow applications to use their\r
+own random number generation method.  For example, it might be possible to\r
+generate a random number by sampling noise on an analogue input. */\r
+extern UBaseType_t uxRand();\r
+#define ipconfigRAND32()       uxRand()\r
+\r
+/* If ipconfigUSE_NETWORK_EVENT_HOOK is set to 1 then FreeRTOS+TCP will call the\r
+network event hook at the appropriate times.  If ipconfigUSE_NETWORK_EVENT_HOOK\r
+is not set to 1 then the network event hook will never be called.  See\r
+http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_UDP/API/vApplicationIPNetworkEventHook.shtml\r
+*/\r
+#define ipconfigUSE_NETWORK_EVENT_HOOK 1\r
+\r
+/* Sockets have a send block time attribute.  If FreeRTOS_sendto() is called but\r
+a network buffer cannot be obtained then the calling task is held in the Blocked\r
+state (so other tasks can continue to executed) until either a network buffer\r
+becomes available or the send block time expires.  If the send block time expires\r
+then the send operation is aborted.  The maximum allowable send block time is\r
+capped to the value set by ipconfigMAX_SEND_BLOCK_TIME_TICKS.  Capping the\r
+maximum allowable send block time prevents prevents a deadlock occurring when\r
+all the network buffers are in use and the tasks that process (and subsequently\r
+free) the network buffers are themselves blocked waiting for a network buffer.\r
+ipconfigMAX_SEND_BLOCK_TIME_TICKS is specified in RTOS ticks.  A time in\r
+milliseconds can be converted to a time in ticks by dividing the time in\r
+milliseconds by portTICK_PERIOD_MS. */\r
+#define ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS ( 5000 / portTICK_PERIOD_MS )\r
+\r
+/* If ipconfigUSE_DHCP is 1 then FreeRTOS+TCP will attempt to retrieve an IP\r
+address, netmask, DNS server address and gateway address from a DHCP server.  If\r
+ipconfigUSE_DHCP is 0 then FreeRTOS+TCP will use a static IP address.  The\r
+stack will revert to using the static IP address even when ipconfigUSE_DHCP is\r
+set to 1 if a valid configuration cannot be obtained from a DHCP server for any\r
+reason.  The static configuration used is that passed into the stack by the\r
+FreeRTOS_IPInit() function call. */\r
+#define ipconfigUSE_DHCP       0\r
+\r
+/* When ipconfigUSE_DHCP is set to 1, DHCP requests will be sent out at\r
+increasing time intervals until either a reply is received from a DHCP server\r
+and accepted, or the interval between transmissions reaches\r
+ipconfigMAXIMUM_DISCOVER_TX_PERIOD.  The IP stack will revert to using the\r
+static IP address passed as a parameter to FreeRTOS_IPInit() if the\r
+re-transmission time interval reaches ipconfigMAXIMUM_DISCOVER_TX_PERIOD without\r
+a DHCP reply being received. */\r
+#define ipconfigMAXIMUM_DISCOVER_TX_PERIOD             ( 120000 / portTICK_PERIOD_MS )\r
+\r
+/* The ARP cache is a table that maps IP addresses to MAC addresses.  The IP\r
+stack can only send a UDP message to a remove IP address if it knowns the MAC\r
+address associated with the IP address, or the MAC address of the router used to\r
+contact the remote IP address.  When a UDP message is received from a remote IP\r
+address the MAC address and IP address are added to the ARP cache.  When a UDP\r
+message is sent to a remote IP address that does not already appear in the ARP\r
+cache then the UDP message is replaced by a ARP message that solicits the\r
+required MAC address information.  ipconfigARP_CACHE_ENTRIES defines the maximum\r
+number of entries that can exist in the ARP table at any one time. */\r
+#define ipconfigARP_CACHE_ENTRIES              6\r
+\r
+/* ARP requests that do not result in an ARP response will be re-transmitted a\r
+maximum of ipconfigMAX_ARP_RETRANSMISSIONS times before the ARP request is\r
+aborted. */\r
+#define ipconfigMAX_ARP_RETRANSMISSIONS ( 5 )\r
+\r
+/* ipconfigMAX_ARP_AGE defines the maximum time between an entry in the ARP\r
+table being created or refreshed and the entry being removed because it is stale.\r
+New ARP requests are sent for ARP cache entries that are nearing their maximum\r
+age.  ipconfigMAX_ARP_AGE is specified in tens of seconds, so a value of 150 is\r
+equal to 1500 seconds (or 25 minutes). */\r
+#define ipconfigMAX_ARP_AGE                    150\r
+\r
+/* Implementing FreeRTOS_inet_addr() necessitates the use of string handling\r
+routines, which are relatively large.  To save code space the full\r
+FreeRTOS_inet_addr() implementation is made optional, and a smaller and faster\r
+alternative called FreeRTOS_inet_addr_quick() is provided.  FreeRTOS_inet_addr()\r
+takes an IP in decimal dot format (for example, "192.168.0.1") as its parameter.\r
+FreeRTOS_inet_addr_quick() takes an IP address as four separate numerical octets\r
+(for example, 192, 168, 0, 1) as its parameters.  If\r
+ipconfigINCLUDE_FULL_INET_ADDR is set to 1 then both FreeRTOS_inet_addr() and\r
+FreeRTOS_indet_addr_quick() are available.  If ipconfigINCLUDE_FULL_INET_ADDR is\r
+not set to 1 then only FreeRTOS_indet_addr_quick() is available. */\r
+#define ipconfigINCLUDE_FULL_INET_ADDR 1\r
+\r
+/* ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS defines the total number of network buffer that\r
+are available to the IP stack.  The total number of network buffers is limited\r
+to ensure the total amount of RAM that can be consumed by the IP stack is capped\r
+to a pre-determinable value. */\r
+#define ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS         60\r
+\r
+/* A FreeRTOS queue is used to send events from application tasks to the IP\r
+stack.  ipconfigEVENT_QUEUE_LENGTH sets the maximum number of events that can\r
+be queued for processing at any one time.  The event queue must be a minimum of\r
+5 greater than the total number of network buffers. */\r
+#define ipconfigEVENT_QUEUE_LENGTH             ( ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS + 5 )\r
+\r
+/* The address of a socket is the combination of its IP address and its port\r
+number.  FreeRTOS_bind() is used to manually allocate a port number to a socket\r
+(to 'bind' the socket to a port), but manual binding is not normally necessary\r
+for client sockets (those sockets that initiate outgoing connections rather than\r
+wait for incoming connections on a known port number).  If\r
+ipconfigALLOW_SOCKET_SEND_WITHOUT_BIND is set to 1 then calling\r
+FreeRTOS_sendto() on a socket that has not yet been bound will result in the IP\r
+stack automatically binding the socket to a port number from the range\r
+socketAUTO_PORT_ALLOCATION_START_NUMBER to 0xffff.  If\r
+ipconfigALLOW_SOCKET_SEND_WITHOUT_BIND is set to 0 then calling FreeRTOS_sendto()\r
+on a socket that has not yet been bound will result in the send operation being\r
+aborted. */\r
+#define ipconfigALLOW_SOCKET_SEND_WITHOUT_BIND 1\r
+\r
+/* Defines the Time To Live (TTL) values used in outgoing UDP packets. */\r
+#define ipconfigUDP_TIME_TO_LIVE               128\r
+#define ipconfigTCP_TIME_TO_LIVE               128 /* also defined in FreeRTOSIPConfigDefaults.h */\r
+\r
+/* USE_TCP: Use TCP and all its features */\r
+#define ipconfigUSE_TCP                                ( 1 )\r
+\r
+/* USE_WIN: Let TCP use windowing mechanism. */\r
+#define ipconfigUSE_TCP_WIN                    ( 1 )\r
+\r
+/* The MTU is the maximum number of bytes the payload of a network frame can\r
+contain.  For normal Ethernet V2 frames the maximum MTU is 1500.  Setting a\r
+lower value can save RAM, depending on the buffer management scheme used.  If\r
+ipconfigCAN_FRAGMENT_OUTGOING_PACKETS is 1 then (ipconfigNETWORK_MTU - 28) must\r
+be divisible by 8. */\r
+#define ipconfigNETWORK_MTU            1200\r
+\r
+/* Set ipconfigUSE_DNS to 1 to include a basic DNS client/resolver.  DNS is used\r
+through the FreeRTOS_gethostbyname() API function. */\r
+#define ipconfigUSE_DNS                        1\r
+\r
+/* If ipconfigREPLY_TO_INCOMING_PINGS is set to 1 then the IP stack will\r
+generate replies to incoming ICMP echo (ping) requests. */\r
+#define ipconfigREPLY_TO_INCOMING_PINGS                                1\r
+\r
+/* If ipconfigSUPPORT_OUTGOING_PINGS is set to 1 then the\r
+FreeRTOS_SendPingRequest() API function is available. */\r
+#define ipconfigSUPPORT_OUTGOING_PINGS                         0\r
+\r
+/* If ipconfigSUPPORT_SELECT_FUNCTION is set to 1 then the FreeRTOS_select()\r
+(and associated) API function is available. */\r
+#define ipconfigSUPPORT_SELECT_FUNCTION                                1\r
+\r
+/* If ipconfigFILTER_OUT_NON_ETHERNET_II_FRAMES is set to 1 then Ethernet frames\r
+that are not in Ethernet II format will be dropped.  This option is included for\r
+potential future IP stack developments. */\r
+#define ipconfigFILTER_OUT_NON_ETHERNET_II_FRAMES  1\r
+\r
+/* If ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES is set to 1 then it is the\r
+responsibility of the Ethernet interface to filter out packets that are of no\r
+interest.  If the Ethernet interface does not implement this functionality, then\r
+set ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES to 0 to have the IP stack\r
+perform the filtering instead (it is much less efficient for the stack to do it\r
+because the packet will already have been passed into the stack).  If the\r
+Ethernet driver does all the necessary filtering in hardware then software\r
+filtering can be removed by using a value other than 1 or 0. */\r
+#define ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES    1\r
+\r
+/* The windows simulator cannot really simulate MAC interrupts, and needs to\r
+block occasionally to allow other tasks to run. */\r
+#define configWINDOWS_MAC_INTERRUPT_SIMULATOR_DELAY ( 20 / portTICK_PERIOD_MS )\r
+\r
+/* Advanced only: in order to access 32-bit fields in the IP packets with\r
+32-bit memory instructions, all packets will be stored 32-bit-aligned, plus 16-bits.\r
+This has to do with the contents of the IP-packets: all 32-bit fields are\r
+32-bit-aligned, plus 16-bit(!) */\r
+#define ipconfigPACKET_FILLER_SIZE 2\r
+\r
+/* Define the size of the pool of TCP window descriptors.  On the average, each\r
+TCP socket will use up to 2 x 6 descriptors, meaning that it can have 2 x 6\r
+outstanding packets (for Rx and Tx).  When using up to 10 TP sockets\r
+simultaneously, one could define TCP_WIN_SEG_COUNT as 120. */\r
+#define ipconfigTCP_WIN_SEG_COUNT              240\r
+\r
+/* Each TCP socket has a circular buffers for Rx and Tx, which have a fixed\r
+maximum size.  Define the size of Rx buffer for TCP sockets. */\r
+#define ipconfigTCP_RX_BUFFER_LENGTH                   ( 1000 )\r
+\r
+/* Define the size of Tx buffer for TCP sockets. */\r
+#define ipconfigTCP_TX_BUFFER_LENGTH                   ( 1000 )\r
+\r
+/* When using call-back handlers, the driver may check if the handler points to\r
+real program memory (RAM or flash) or just has a random non-zero value. */\r
+#define ipconfigIS_VALID_PROG_ADDRESS(x) ( (x) != NULL )\r
+\r
+/* Include support for TCP hang protection.  All sockets in a connecting or\r
+disconnecting stage will timeout after a period of non-activity. */\r
+#define ipconfigTCP_HANG_PROTECTION                    ( 1 )\r
+#define ipconfigTCP_HANG_PROTECTION_TIME       ( 30 )\r
+\r
+/* Include support for TCP keep-alive messages. */\r
+#define ipconfigTCP_KEEP_ALIVE                         ( 1 )\r
+#define ipconfigTCP_KEEP_ALIVE_INTERVAL                ( 20 ) /* in seconds */\r
+\r
+#define portINLINE __inline\r
+\r
+#endif /* FREERTOS_IP_CONFIG_H */\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/FreeRTOS_Plus_TCP_Minimal.sln b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/FreeRTOS_Plus_TCP_Minimal.sln
new file mode 100644 (file)
index 0000000..b362f36
--- /dev/null
@@ -0,0 +1,23 @@
+\r
+Microsoft Visual Studio Solution File, Format Version 11.00\r
+# Visual Studio 2010\r
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RTOSDemo", "WIN32.vcxproj", "{C686325E-3261-42F7-AEB1-DDE5280E1CEB}"\r
+EndProject\r
+Global\r
+       GlobalSection(TestCaseManagementSettings) = postSolution\r
+               CategoryFile = FreeRTOS_Plus_TCP_Minimal.vsmdi\r
+       EndGlobalSection\r
+       GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+               Debug|Win32 = Debug|Win32\r
+               Release|Win32 = Release|Win32\r
+       EndGlobalSection\r
+       GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+               {C686325E-3261-42F7-AEB1-DDE5280E1CEB}.Debug|Win32.ActiveCfg = Debug|Win32\r
+               {C686325E-3261-42F7-AEB1-DDE5280E1CEB}.Debug|Win32.Build.0 = Debug|Win32\r
+               {C686325E-3261-42F7-AEB1-DDE5280E1CEB}.Release|Win32.ActiveCfg = Release|Win32\r
+               {C686325E-3261-42F7-AEB1-DDE5280E1CEB}.Release|Win32.Build.0 = Release|Win32\r
+       EndGlobalSection\r
+       GlobalSection(SolutionProperties) = preSolution\r
+               HideSolutionNode = FALSE\r
+       EndGlobalSection\r
+EndGlobal\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WIN32.vcxproj b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WIN32.vcxproj
new file mode 100644 (file)
index 0000000..44615e2
--- /dev/null
@@ -0,0 +1,197 @@
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+  <ItemGroup Label="ProjectConfigurations">\r
+    <ProjectConfiguration Include="Debug|Win32">\r
+      <Configuration>Debug</Configuration>\r
+      <Platform>Win32</Platform>\r
+    </ProjectConfiguration>\r
+    <ProjectConfiguration Include="Release|Win32">\r
+      <Configuration>Release</Configuration>\r
+      <Platform>Win32</Platform>\r
+    </ProjectConfiguration>\r
+  </ItemGroup>\r
+  <PropertyGroup Label="Globals">\r
+    <ProjectGuid>{C686325E-3261-42F7-AEB1-DDE5280E1CEB}</ProjectGuid>\r
+    <ProjectName>RTOSDemo</ProjectName>\r
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>\r
+  </PropertyGroup>\r
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">\r
+    <ConfigurationType>Application</ConfigurationType>\r
+    <UseOfMfc>false</UseOfMfc>\r
+    <CharacterSet>MultiByte</CharacterSet>\r
+    <PlatformToolset>v142</PlatformToolset>\r
+  </PropertyGroup>\r
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">\r
+    <ConfigurationType>Application</ConfigurationType>\r
+    <UseOfMfc>false</UseOfMfc>\r
+    <CharacterSet>MultiByte</CharacterSet>\r
+    <PlatformToolset>v142</PlatformToolset>\r
+  </PropertyGroup>\r
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+  <ImportGroup Label="ExtensionSettings">\r
+  </ImportGroup>\r
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">\r
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />\r
+  </ImportGroup>\r
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">\r
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />\r
+  </ImportGroup>\r
+  <PropertyGroup Label="UserMacros" />\r
+  <PropertyGroup>\r
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\Debug\</OutDir>\r
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\Debug\</IntDir>\r
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>\r
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\Release\</OutDir>\r
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\Release\</IntDir>\r
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>\r
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>\r
+  </PropertyGroup>\r
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">\r
+    <Midl>\r
+      <TypeLibraryName>.\Debug/WIN32.tlb</TypeLibraryName>\r
+      <HeaderFileName>\r
+      </HeaderFileName>\r
+    </Midl>\r
+    <ClCompile>\r
+      <Optimization>Disabled</Optimization>\r
+      <AdditionalIncludeDirectories>..\..\..\Source\FreeRTOS-Plus-FAT\include;..\..\..\Source\FreeRTOS-Plus-FAT\portable\common;..\..\..\Source\FreeRTOS-Plus-TCP\protocols\include;..\..\..\Source\FreeRTOS-Plus-TCP\portable\BufferManagement;.\DemoTasks\include;..\..\..\Source\FreeRTOS-Plus-TCP\portable\Compiler\MSVC;.\WinPCap;..\..\..\..\FreeRTOS\Source\include;..\..\..\..\FreeRTOS\Source\portable\MSVC-MingW;..\..\..\Source\FreeRTOS-Plus-CLI;.\TraceMacros\Example1;..\..\..\Source\FreeRTOS-Plus-TCP\include;.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_WIN32_WINNT=0x0500;WINVER=0x400;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+      <MinimalRebuild>true</MinimalRebuild>\r
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>\r
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>\r
+      <PrecompiledHeaderOutputFile>.\Debug/WIN32.pch</PrecompiledHeaderOutputFile>\r
+      <AssemblerListingLocation>.\Debug/</AssemblerListingLocation>\r
+      <ObjectFileName>.\Debug/</ObjectFileName>\r
+      <ProgramDataBaseFileName>.\Debug/</ProgramDataBaseFileName>\r
+      <WarningLevel>Level4</WarningLevel>\r
+      <SuppressStartupBanner>true</SuppressStartupBanner>\r
+      <DisableLanguageExtensions>false</DisableLanguageExtensions>\r
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>\r
+      <AdditionalOptions>/wd4210 /wd4127 /wd4214 /wd4201 /wd4244  /wd4310 %(AdditionalOptions)</AdditionalOptions>\r
+      <BrowseInformation>true</BrowseInformation>\r
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>\r
+      <ExceptionHandling>false</ExceptionHandling>\r
+      <CompileAs>CompileAsC</CompileAs>\r
+    </ClCompile>\r
+    <ResourceCompile>\r
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+      <Culture>0x0c09</Culture>\r
+    </ResourceCompile>\r
+    <Link>\r
+      <OutputFile>.\Debug/RTOSDemo.exe</OutputFile>\r
+      <SuppressStartupBanner>true</SuppressStartupBanner>\r
+      <GenerateDebugInformation>true</GenerateDebugInformation>\r
+      <ProgramDatabaseFile>.\Debug/WIN32.pdb</ProgramDatabaseFile>\r
+      <SubSystem>Console</SubSystem>\r
+      <TargetMachine>MachineX86</TargetMachine>\r
+      <AdditionalDependencies>wpcap.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+      <AdditionalLibraryDirectories>.\WinPCap</AdditionalLibraryDirectories>\r
+      <Profile>false</Profile>\r
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>\r
+    </Link>\r
+    <Bscmake>\r
+      <SuppressStartupBanner>true</SuppressStartupBanner>\r
+      <OutputFile>.\Debug/WIN32.bsc</OutputFile>\r
+    </Bscmake>\r
+  </ItemDefinitionGroup>\r
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">\r
+    <Midl>\r
+      <TypeLibraryName>.\Release/WIN32.tlb</TypeLibraryName>\r
+      <HeaderFileName>\r
+      </HeaderFileName>\r
+    </Midl>\r
+    <ClCompile>\r
+      <Optimization>MaxSpeed</Optimization>\r
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>\r
+      <PreprocessorDefinitions>_WINSOCKAPI_;WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+      <StringPooling>true</StringPooling>\r
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>\r
+      <FunctionLevelLinking>true</FunctionLevelLinking>\r
+      <PrecompiledHeaderOutputFile>.\Release/WIN32.pch</PrecompiledHeaderOutputFile>\r
+      <AssemblerListingLocation>.\Release/</AssemblerListingLocation>\r
+      <ObjectFileName>.\Release/</ObjectFileName>\r
+      <ProgramDataBaseFileName>.\Release/</ProgramDataBaseFileName>\r
+      <WarningLevel>Level3</WarningLevel>\r
+      <SuppressStartupBanner>true</SuppressStartupBanner>\r
+      <AdditionalIncludeDirectories>..\Common\Utils;..\Common\ethernet\lwip-1.4.0\ports\win32\WinPCap;..\Common\ethernet\lwip-1.4.0\src\include\ipv4;..\Common\ethernet\lwip-1.4.0\src\include;..\..\..\Source\include;..\..\..\Source\portable\MSVC-MingW;..\Common\ethernet\lwip-1.4.0\ports\win32\include;..\Common\Include;.\lwIP_Apps;.;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+    </ClCompile>\r
+    <ResourceCompile>\r
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+      <Culture>0x0c09</Culture>\r
+    </ResourceCompile>\r
+    <Link>\r
+      <OutputFile>.\Release/RTOSDemo.exe</OutputFile>\r
+      <SuppressStartupBanner>true</SuppressStartupBanner>\r
+      <ProgramDatabaseFile>.\Release/WIN32.pdb</ProgramDatabaseFile>\r
+      <SubSystem>Console</SubSystem>\r
+      <TargetMachine>MachineX86</TargetMachine>\r
+      <AdditionalLibraryDirectories>..\Common\ethernet\lwip-1.4.0\ports\win32\WinPCap</AdditionalLibraryDirectories>\r
+      <AdditionalDependencies>wpcap.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+    </Link>\r
+    <Bscmake>\r
+      <SuppressStartupBanner>true</SuppressStartupBanner>\r
+      <OutputFile>.\Release/WIN32.bsc</OutputFile>\r
+    </Bscmake>\r
+  </ItemDefinitionGroup>\r
+  <ItemGroup>\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\event_groups.c" />\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\list.c" />\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\portable\MemMang\heap_4.c" />\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\portable\MSVC-MingW\port.c" />\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\queue.c" />\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\tasks.c" />\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\timers.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_ARP.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_DHCP.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_DNS.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_IP.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_Sockets.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_Stream_Buffer.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_TCP_IP.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_TCP_WIN.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_UDP_IP.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\portable\BufferManagement\BufferAllocation_2.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\portable\NetworkInterface\WinPCap\NetworkInterface.c" />\r
+    <ClCompile Include="DemoTasks\SimpleUDPClientAndServer.c" />\r
+    <ClCompile Include="demo_logging.c" />\r
+    <ClCompile Include="main.c">\r
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+    </ClCompile>\r
+  </ItemGroup>\r
+  <ItemGroup>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\event_groups.h" />\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\FreeRTOS.h" />\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\portable.h" />\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\projdefs.h" />\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\queue.h" />\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\semphr.h" />\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\task.h" />\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\timers.h" />\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\portable\MSVC-MingW\portmacro.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOSIPConfigDefaults.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_ARP.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_DHCP.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_DNS.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_IP.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_IP_Private.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_Sockets.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_Stream_Buffer.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_TCP_IP.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_TCP_WIN.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_UDP_IP.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\IPTraceMacroDefaults.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\NetworkBufferManagement.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\NetworkInterface.h" />\r
+    <ClInclude Include="FreeRTOSConfig.h" />\r
+    <ClInclude Include="FreeRTOSIPConfig.h" />\r
+  </ItemGroup>\r
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+  <ImportGroup Label="ExtensionTargets">\r
+  </ImportGroup>\r
+</Project>
\ No newline at end of file
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WIN32.vcxproj.filters b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WIN32.vcxproj.filters
new file mode 100644 (file)
index 0000000..4dee640
--- /dev/null
@@ -0,0 +1,171 @@
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+  <ItemGroup>\r
+    <Filter Include="Resource Files">\r
+      <UniqueIdentifier>{38712199-cebf-4124-bf15-398f7c3419ea}</UniqueIdentifier>\r
+      <Extensions>ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe</Extensions>\r
+    </Filter>\r
+    <Filter Include="FreeRTOS">\r
+      <UniqueIdentifier>{af3445a1-4908-4170-89ed-39345d90d30c}</UniqueIdentifier>\r
+    </Filter>\r
+    <Filter Include="FreeRTOS\Source">\r
+      <UniqueIdentifier>{f32be356-4763-4cae-9020-974a2638cb08}</UniqueIdentifier>\r
+      <Extensions>*.c</Extensions>\r
+    </Filter>\r
+    <Filter Include="FreeRTOS\Source\Portable">\r
+      <UniqueIdentifier>{88f409e6-d396-4ac5-94bd-7a99c914be46}</UniqueIdentifier>\r
+    </Filter>\r
+    <Filter Include="FreeRTOS+">\r
+      <UniqueIdentifier>{e5ad4ec7-23dc-4295-8add-2acaee488f5a}</UniqueIdentifier>\r
+    </Filter>\r
+    <Filter Include="FreeRTOS\Source\include">\r
+      <UniqueIdentifier>{d2dcd641-8d91-492b-852f-5563ffadaec6}</UniqueIdentifier>\r
+    </Filter>\r
+    <Filter Include="FreeRTOS+\FreeRTOS+TCP">\r
+      <UniqueIdentifier>{8672fa26-b119-481f-8b8d-086419c01a3e}</UniqueIdentifier>\r
+    </Filter>\r
+    <Filter Include="FreeRTOS+\FreeRTOS+TCP\portable">\r
+      <UniqueIdentifier>{4570be11-ec96-4b55-ac58-24b50ada980a}</UniqueIdentifier>\r
+    </Filter>\r
+    <Filter Include="FreeRTOS+\FreeRTOS+TCP\include">\r
+      <UniqueIdentifier>{5d93ed51-023a-41ad-9243-8d230165d34b}</UniqueIdentifier>\r
+    </Filter>\r
+    <Filter Include="DemoTasks">\r
+      <UniqueIdentifier>{b71e974a-9f28-4815-972b-d930ba8a34d0}</UniqueIdentifier>\r
+    </Filter>\r
+  </ItemGroup>\r
+  <ItemGroup>\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\portable\MSVC-MingW\port.c">\r
+      <Filter>FreeRTOS\Source\Portable</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\timers.c">\r
+      <Filter>FreeRTOS\Source</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\list.c">\r
+      <Filter>FreeRTOS\Source</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\queue.c">\r
+      <Filter>FreeRTOS\Source</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\tasks.c">\r
+      <Filter>FreeRTOS\Source</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="DemoTasks\SimpleUDPClientAndServer.c">\r
+      <Filter>DemoTasks</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_UDP_IP.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_DHCP.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_DNS.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_Sockets.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\portable\BufferManagement\BufferAllocation_2.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\portable</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\portable\NetworkInterface\WinPCap\NetworkInterface.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\portable</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_ARP.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_IP.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_TCP_IP.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_TCP_WIN.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\event_groups.c">\r
+      <Filter>FreeRTOS\Source</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="..\..\..\..\FreeRTOS\Source\portable\MemMang\heap_4.c">\r
+      <Filter>FreeRTOS\Source\Portable</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="main.c" />\r
+    <ClCompile Include="..\..\..\Source\FreeRTOS-Plus-TCP\FreeRTOS_Stream_Buffer.c">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="demo_logging.c" />\r
+  </ItemGroup>\r
+  <ItemGroup>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\NetworkInterface.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_DNS.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_Sockets.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_UDP_IP.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\timers.h">\r
+      <Filter>FreeRTOS\Source\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\event_groups.h">\r
+      <Filter>FreeRTOS\Source\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\FreeRTOS.h">\r
+      <Filter>FreeRTOS\Source\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\queue.h">\r
+      <Filter>FreeRTOS\Source\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\semphr.h">\r
+      <Filter>FreeRTOS\Source\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\task.h">\r
+      <Filter>FreeRTOS\Source\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\portable\MSVC-MingW\portmacro.h">\r
+      <Filter>FreeRTOS\Source\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_IP_Private.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\NetworkBufferManagement.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_ARP.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_DHCP.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_IP.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_TCP_IP.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_TCP_WIN.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOSIPConfigDefaults.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\IPTraceMacroDefaults.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="FreeRTOSConfig.h" />\r
+    <ClInclude Include="FreeRTOSIPConfig.h" />\r
+    <ClInclude Include="..\..\..\Source\FreeRTOS-Plus-TCP\include\FreeRTOS_Stream_Buffer.h">\r
+      <Filter>FreeRTOS+\FreeRTOS+TCP\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\portable.h">\r
+      <Filter>FreeRTOS\Source\include</Filter>\r
+    </ClInclude>\r
+    <ClInclude Include="..\..\..\..\FreeRTOS\Source\include\projdefs.h">\r
+      <Filter>FreeRTOS\Source\include</Filter>\r
+    </ClInclude>\r
+  </ItemGroup>\r
+</Project>
\ No newline at end of file
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/Packet32.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/Packet32.h
new file mode 100644 (file)
index 0000000..1e0eacd
--- /dev/null
@@ -0,0 +1,359 @@
+/*\r
+ * Copyright (c) 1999 - 2005 NetGroup, Politecnico di Torino (Italy)\r
+ * Copyright (c) 2005 - 2007 CACE Technologies, Davis (California)\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ *\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ * 3. Neither the name of the Politecnico di Torino, CACE Technologies \r
+ * nor the names of its contributors may be used to endorse or promote \r
+ * products derived from this software without specific prior written \r
+ * permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ *\r
+ */\r
+\r
+/** @ingroup packetapi\r
+ *  @{ \r
+ */\r
+\r
+/** @defgroup packet32h Packet.dll definitions and data structures\r
+ *  Packet32.h contains the data structures and the definitions used by packet.dll.\r
+ *  The file is used both by the Win9x and the WinNTx versions of packet.dll, and can be included\r
+ *  by the applications that use the functions of this library\r
+ *  @{\r
+ */\r
+\r
+#ifndef __PACKET32\r
+#define __PACKET32\r
+\r
+#include <winsock2.h>\r
+\r
+#ifdef HAVE_AIRPCAP_API\r
+#include <airpcap.h>\r
+#else\r
+#if !defined(AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_)\r
+#define AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_\r
+typedef struct _AirpcapHandle *PAirpcapHandle;\r
+#endif /* AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_ */\r
+#endif /* HAVE_AIRPCAP_API */\r
+\r
+#ifdef HAVE_DAG_API\r
+#include <dagc.h>\r
+#endif /* HAVE_DAG_API */\r
+\r
+// Working modes\r
+#define PACKET_MODE_CAPT 0x0 ///< Capture mode\r
+#define PACKET_MODE_STAT 0x1 ///< Statistical mode\r
+#define PACKET_MODE_MON 0x2 ///< Monitoring mode\r
+#define PACKET_MODE_DUMP 0x10 ///< Dump mode\r
+#define PACKET_MODE_STAT_DUMP MODE_DUMP | MODE_STAT ///< Statistical dump Mode\r
+\r
+\r
+/// Alignment macro. Defines the alignment size.\r
+#define Packet_ALIGNMENT sizeof(int)\r
+/// Alignment macro. Rounds up to the next even multiple of Packet_ALIGNMENT. \r
+#define Packet_WORDALIGN(x) (((x)+(Packet_ALIGNMENT-1))&~(Packet_ALIGNMENT-1))\r
+\r
+#define NdisMediumNull -1              ///< Custom linktype: NDIS doesn't provide an equivalent\r
+#define NdisMediumCHDLC        -2              ///< Custom linktype: NDIS doesn't provide an equivalent\r
+#define NdisMediumPPPSerial    -3      ///< Custom linktype: NDIS doesn't provide an equivalent\r
+#define NdisMediumBare80211    -4      ///< Custom linktype: NDIS doesn't provide an equivalent\r
+#define NdisMediumRadio80211   -5      ///< Custom linktype: NDIS doesn't provide an equivalent\r
+#define NdisMediumPpi          -6      ///< Custom linktype: NDIS doesn't provide an equivalent\r
+\r
+// Loopback behaviour definitions\r
+#define NPF_DISABLE_LOOPBACK   1       ///< Drop the packets sent by the NPF driver\r
+#define NPF_ENABLE_LOOPBACK            2       ///< Capture the packets sent by the NPF driver\r
+\r
+/*!\r
+  \brief Network type structure.\r
+\r
+  This structure is used by the PacketGetNetType() function to return information on the current adapter's type and speed.\r
+*/\r
+typedef struct NetType\r
+{\r
+       UINT LinkType;  ///< The MAC of the current network adapter (see function PacketGetNetType() for more information)\r
+       ULONGLONG LinkSpeed;    ///< The speed of the network in bits per second\r
+}NetType;\r
+\r
+\r
+//some definitions stolen from libpcap\r
+\r
+#ifndef BPF_MAJOR_VERSION\r
+\r
+/*!\r
+  \brief A BPF pseudo-assembly program.\r
+\r
+  The program will be injected in the kernel by the PacketSetBPF() function and applied to every incoming packet. \r
+*/\r
+struct bpf_program \r
+{\r
+       UINT bf_len;                            ///< Indicates the number of instructions of the program, i.e. the number of struct bpf_insn that will follow.\r
+       struct bpf_insn *bf_insns;      ///< A pointer to the first instruction of the program.\r
+};\r
+\r
+/*!\r
+  \brief A single BPF pseudo-instruction.\r
+\r
+  bpf_insn contains a single instruction for the BPF register-machine. It is used to send a filter program to the driver.\r
+*/\r
+struct bpf_insn \r
+{\r
+       USHORT  code;           ///< Instruction type and addressing mode.\r
+       UCHAR   jt;                     ///< Jump if true\r
+       UCHAR   jf;                     ///< Jump if false\r
+       int k;                          ///< Generic field used for various purposes.\r
+};\r
+\r
+/*!\r
+  \brief Structure that contains a couple of statistics values on the current capture.\r
+\r
+  It is used by packet.dll to return statistics about a capture session.\r
+*/\r
+struct bpf_stat \r
+{\r
+       UINT bs_recv;           ///< Number of packets that the driver received from the network adapter \r
+                                               ///< from the beginning of the current capture. This value includes the packets \r
+                                               ///< lost by the driver.\r
+       UINT bs_drop;           ///< number of packets that the driver lost from the beginning of a capture. \r
+                                               ///< Basically, a packet is lost when the the buffer of the driver is full. \r
+                                               ///< In this situation the packet cannot be stored and the driver rejects it.\r
+       UINT ps_ifdrop;         ///< drops by interface. XXX not yet supported\r
+       UINT bs_capt;           ///< number of packets that pass the filter, find place in the kernel buffer and\r
+                                               ///< thus reach the application.\r
+};\r
+\r
+/*!\r
+  \brief Packet header.\r
+\r
+  This structure defines the header associated with every packet delivered to the application.\r
+*/\r
+struct bpf_hdr \r
+{\r
+       struct timeval  bh_tstamp;      ///< The timestamp associated with the captured packet. \r
+                                                               ///< It is stored in a TimeVal structure.\r
+       UINT    bh_caplen;                      ///< Length of captured portion. The captured portion <b>can be different</b>\r
+                                                               ///< from the original packet, because it is possible (with a proper filter)\r
+                                                               ///< to instruct the driver to capture only a portion of the packets.\r
+       UINT    bh_datalen;                     ///< Original length of packet\r
+       USHORT          bh_hdrlen;              ///< Length of bpf header (this struct plus alignment padding). In some cases,\r
+                                                               ///< a padding could be added between the end of this structure and the packet\r
+                                                               ///< data for performance reasons. This filed can be used to retrieve the actual data \r
+                                                               ///< of the packet.\r
+};\r
+\r
+/*!\r
+  \brief Dump packet header.\r
+\r
+  This structure defines the header associated with the packets in a buffer to be used with PacketSendPackets().\r
+  It is simpler than the bpf_hdr, because it corresponds to the header associated by WinPcap and libpcap to a\r
+  packet in a dump file. This makes straightforward sending WinPcap dump files to the network.\r
+*/\r
+struct dump_bpf_hdr{\r
+    struct timeval     ts;                     ///< Time stamp of the packet\r
+    UINT                       caplen;         ///< Length of captured portion. The captured portion can smaller than the \r
+                                                               ///< the original packet, because it is possible (with a proper filter) to \r
+                                                               ///< instruct the driver to capture only a portion of the packets. \r
+    UINT                       len;            ///< Length of the original packet (off wire).\r
+};\r
+\r
+\r
+#endif\r
+\r
+struct bpf_stat;\r
+\r
+#define        DOSNAMEPREFIX   TEXT("Packet_") ///< Prefix added to the adapters device names to create the WinPcap devices\r
+#define        MAX_LINK_NAME_LENGTH    64                      //< Maximum length of the devices symbolic links\r
+#define        NMAX_PACKET 65535\r
+\r
+/*!\r
+  \brief Addresses of a network adapter.\r
+\r
+  This structure is used by the PacketGetNetInfoEx() function to return the IP addresses associated with \r
+  an adapter.\r
+*/\r
+typedef struct npf_if_addr {\r
+       struct sockaddr_storage IPAddress;      ///< IP address.\r
+       struct sockaddr_storage SubnetMask;     ///< Netmask for that address.\r
+       struct sockaddr_storage Broadcast;      ///< Broadcast address.\r
+}npf_if_addr;\r
+\r
+\r
+#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.\r
+#define ADAPTER_DESC_LENGTH 128                        ///<  Maximum length for the description of an adapter. The value is the same used by the IP Helper API.\r
+#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.\r
+#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.\r
+\r
+\r
+typedef struct WAN_ADAPTER_INT WAN_ADAPTER; ///< Describes an opened wan (dialup, VPN...) network adapter using the NetMon API\r
+typedef WAN_ADAPTER *PWAN_ADAPTER; ///< Describes an opened wan (dialup, VPN...) network adapter using the NetMon API\r
+\r
+#define INFO_FLAG_NDIS_ADAPTER         0       ///< Flag for ADAPTER_INFO: this is a traditional ndis adapter\r
+#define INFO_FLAG_NDISWAN_ADAPTER      1       ///< Flag for ADAPTER_INFO: this is a NdisWan adapter, and it's managed by WANPACKET\r
+#define INFO_FLAG_DAG_CARD                     2       ///< Flag for ADAPTER_INFO: this is a DAG card\r
+#define INFO_FLAG_DAG_FILE                     6       ///< Flag for ADAPTER_INFO: this is a DAG file\r
+#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.\r
+#define INFO_FLAG_AIRPCAP_CARD         16      ///< Flag for ADAPTER_INFO: this is an airpcap card\r
+#define INFO_FLAG_NPFIM_DEVICE         32\r
+\r
+/*!\r
+  \brief Describes an opened network adapter.\r
+\r
+  This structure is the most important for the functioning of packet.dll, but the great part of its fields\r
+  should be ignored by the user, since the library offers functions that avoid to cope with low-level parameters\r
+*/\r
+typedef struct _ADAPTER  { \r
+       HANDLE hFile;                           ///< \internal Handle to an open instance of the NPF driver.\r
+       CHAR  SymbolicLink[MAX_LINK_NAME_LENGTH]; ///< \internal A string containing the name of the network adapter currently opened.\r
+       int NumWrites;                          ///< \internal Number of times a packets written on this adapter will be repeated \r
+                                                               ///< on the wire.\r
+       HANDLE ReadEvent;                       ///< A notification event associated with the read calls on the adapter.\r
+                                                               ///< It can be passed to standard Win32 functions (like WaitForSingleObject\r
+                                                               ///< or WaitForMultipleObjects) to wait until the driver's buffer contains some \r
+                                                               ///< data. It is particularly useful in GUI applications that need to wait \r
+                                                               ///< concurrently on several events. In Windows NT/2000 the PacketSetMinToCopy()\r
+                                                               ///< function can be used to define the minimum amount of data in the kernel buffer\r
+                                                               ///< that will cause the event to be signalled. \r
+       \r
+       UINT ReadTimeOut;                       ///< \internal The amount of time after which a read on the driver will be released and \r
+                                                               ///< ReadEvent will be signaled, also if no packets were captured\r
+       CHAR Name[ADAPTER_NAME_LENGTH];\r
+       PWAN_ADAPTER pWanAdapter;\r
+       UINT Flags;                                     ///< Adapter's flags. Tell if this adapter must be treated in a different way, using the Netmon API or the dagc API.\r
+\r
+#ifdef HAVE_AIRPCAP_API\r
+       PAirpcapHandle  AirpcapAd;\r
+#endif // HAVE_AIRPCAP_API\r
+\r
+#ifdef HAVE_NPFIM_API\r
+       void* NpfImHandle;\r
+#endif // HAVE_NPFIM_API\r
+\r
+#ifdef HAVE_DAG_API\r
+       dagc_t *pDagCard;                       ///< Pointer to the dagc API adapter descriptor for this adapter\r
+       PCHAR DagBuffer;                        ///< Pointer to the buffer with the packets that is received from the DAG card\r
+       struct timeval DagReadTimeout;  ///< Read timeout. The dagc API requires a timeval structure\r
+       unsigned DagFcsLen;                     ///< Length of the frame check sequence attached to any packet by the card. Obtained from the registry\r
+       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).\r
+#endif // HAVE_DAG_API\r
+}  ADAPTER, *LPADAPTER;\r
+\r
+/*!\r
+  \brief Structure that contains a group of packets coming from the driver.\r
+\r
+  This structure defines the header associated with every packet delivered to the application.\r
+*/\r
+typedef struct _PACKET {  \r
+       HANDLE       hEvent;            ///< \deprecated Still present for compatibility with old applications.\r
+       OVERLAPPED   OverLapped;        ///< \deprecated Still present for compatibility with old applications.\r
+       PVOID        Buffer;            ///< Buffer with containing the packets. See the PacketReceivePacket() for\r
+                                                               ///< details about the organization of the data in this buffer\r
+       UINT         Length;            ///< Length of the buffer\r
+       DWORD        ulBytesReceived;   ///< Number of valid bytes present in the buffer, i.e. amount of data\r
+                                                                       ///< received by the last call to PacketReceivePacket()\r
+       BOOLEAN      bIoComplete;       ///< \deprecated Still present for compatibility with old applications.\r
+}  PACKET, *LPPACKET;\r
+\r
+/*!\r
+  \brief Structure containing an OID request.\r
+\r
+  It is used by the PacketRequest() function to send an OID to the interface card driver. \r
+  It can be used, for example, to retrieve the status of the error counters on the adapter, its MAC address, \r
+  the list of the multicast groups defined on it, and so on.\r
+*/\r
+struct _PACKET_OID_DATA {\r
+    ULONG Oid;                                 ///< OID code. See the Microsoft DDK documentation or the file ntddndis.h\r
+                                                               ///< for a complete list of valid codes.\r
+    ULONG Length;                              ///< Length of the data field\r
+    UCHAR Data[1];                             ///< variable-lenght field that contains the information passed to or received \r
+                                                               ///< from the adapter.\r
+}; \r
+typedef struct _PACKET_OID_DATA PACKET_OID_DATA, *PPACKET_OID_DATA;\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+/**\r
+ *  @}\r
+ */\r
+\r
+/*\r
+BOOLEAN QueryWinPcapRegistryStringA(CHAR *SubKeyName,\r
+                                                                CHAR *Value,\r
+                                                                UINT *pValueLen,\r
+                                                                CHAR *DefaultVal);\r
+\r
+BOOLEAN QueryWinPcapRegistryStringW(WCHAR *SubKeyName,\r
+                                                                WCHAR *Value,\r
+                                                                UINT *pValueLen,\r
+                                                                WCHAR *DefaultVal);\r
+*/\r
+                                                                \r
+//---------------------------------------------------------------------------\r
+// EXPORTED FUNCTIONS\r
+//---------------------------------------------------------------------------\r
+\r
+PCHAR PacketGetVersion();\r
+PCHAR PacketGetDriverVersion();\r
+BOOLEAN PacketSetMinToCopy(LPADAPTER AdapterObject,int nbytes);\r
+BOOLEAN PacketSetNumWrites(LPADAPTER AdapterObject,int nwrites);\r
+BOOLEAN PacketSetMode(LPADAPTER AdapterObject,int mode);\r
+BOOLEAN PacketSetReadTimeout(LPADAPTER AdapterObject,int timeout);\r
+BOOLEAN PacketSetBpf(LPADAPTER AdapterObject,struct bpf_program *fp);\r
+BOOLEAN PacketSetLoopbackBehavior(LPADAPTER  AdapterObject, UINT LoopbackBehavior);\r
+INT PacketSetSnapLen(LPADAPTER AdapterObject,int snaplen);\r
+BOOLEAN PacketGetStats(LPADAPTER AdapterObject,struct bpf_stat *s);\r
+BOOLEAN PacketGetStatsEx(LPADAPTER AdapterObject,struct bpf_stat *s);\r
+BOOLEAN PacketSetBuff(LPADAPTER AdapterObject,int dim);\r
+BOOLEAN PacketGetNetType (LPADAPTER AdapterObject,NetType *type);\r
+LPADAPTER PacketOpenAdapter(PCHAR AdapterName);\r
+BOOLEAN PacketSendPacket(LPADAPTER AdapterObject,LPPACKET pPacket,BOOLEAN Sync);\r
+INT PacketSendPackets(LPADAPTER AdapterObject,PVOID PacketBuff,ULONG Size, BOOLEAN Sync);\r
+LPPACKET PacketAllocatePacket(void);\r
+VOID PacketInitPacket(LPPACKET lpPacket,PVOID  Buffer,UINT  Length);\r
+VOID PacketFreePacket(LPPACKET lpPacket);\r
+BOOLEAN PacketReceivePacket(LPADAPTER AdapterObject,LPPACKET lpPacket,BOOLEAN Sync);\r
+BOOLEAN PacketSetHwFilter(LPADAPTER AdapterObject,ULONG Filter);\r
+BOOLEAN PacketGetAdapterNames(PTSTR pStr,PULONG  BufferSize);\r
+BOOLEAN PacketGetNetInfoEx(PCHAR AdapterName, npf_if_addr* buffer, PLONG NEntries);\r
+BOOLEAN PacketRequest(LPADAPTER  AdapterObject,BOOLEAN Set,PPACKET_OID_DATA  OidData);\r
+HANDLE PacketGetReadEvent(LPADAPTER AdapterObject);\r
+BOOLEAN PacketSetDumpName(LPADAPTER AdapterObject, void *name, int len);\r
+BOOLEAN PacketSetDumpLimits(LPADAPTER AdapterObject, UINT maxfilesize, UINT maxnpacks);\r
+BOOLEAN PacketIsDumpEnded(LPADAPTER AdapterObject, BOOLEAN sync);\r
+BOOL PacketStopDriver();\r
+VOID PacketCloseAdapter(LPADAPTER lpAdapter);\r
+BOOLEAN PacketStartOem(PCHAR errorString, UINT errorStringLength);\r
+BOOLEAN PacketStartOemEx(PCHAR errorString, UINT errorStringLength, ULONG flags);\r
+PAirpcapHandle PacketGetAirPcapHandle(LPADAPTER AdapterObject);\r
+\r
+//\r
+// Used by PacketStartOemEx\r
+//\r
+#define PACKET_START_OEM_NO_NETMON     0x00000001\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif \r
+\r
+#endif //__PACKET32\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/PacketData.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/PacketData.h
new file mode 100644 (file)
index 0000000..8124db6
--- /dev/null
@@ -0,0 +1,267 @@
+char pkt1[] = {\r
+0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,\r
+0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x30, 0x09, 0x9c, 0x40, 0x00, 0x80, 0x06,\r
+0x6f, 0x07, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,\r
+0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,\r
+0xc7, 0x35, 0x00, 0x00, 0x00, 0x00, 0x70, 0x02,\r
+0x40, 0x00, 0xdf, 0xab, 0x00, 0x00, 0x02, 0x04,\r
+0x05, 0xb4, 0x01, 0x01, 0x04, 0x02 };\r
+\r
+char pkt2[] = {\r
+0x00, 0x14, 0x22, 0xcb, 0x18, 0x2d, 0x00, 0x01,\r
+0x02, 0x45, 0x09, 0x11, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x2c, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06,\r
+0xf8, 0xa6, 0xc0, 0xa8, 0x00, 0x0c, 0xc0, 0xa8,\r
+0x00, 0xc8, 0x00, 0x50, 0x0f, 0xe2, 0x00, 0x00,\r
+0x06, 0x68, 0x09, 0xe7, 0xc7, 0x36, 0x60, 0x12,\r
+0x05, 0x92, 0x28, 0xca, 0x00, 0x00, 0x02, 0x04,\r
+0x05, 0x92 };\r
+\r
+char pkt3[] = {\r
+0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,\r
+0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x28, 0x09, 0x9e, 0x40, 0x00, 0x80, 0x06,\r
+0x6f, 0x0d, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,\r
+0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,\r
+0xc7, 0x36, 0x00, 0x00, 0x06, 0x69, 0x50, 0x10,\r
+0x42, 0xd8, 0x82, 0x3f, 0x00, 0x00 };\r
+\r
+char pkt4[] = {\r
+0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,\r
+0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,\r
+0x02, 0x27, 0x09, 0x9f, 0x40, 0x00, 0x80, 0x06,\r
+0x6d, 0x0d, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,\r
+0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,\r
+0xc7, 0x36, 0x00, 0x00, 0x06, 0x69, 0x50, 0x18,\r
+0x42, 0xd8, 0x84, 0x3e, 0x00, 0x00, 0x47, 0x45,\r
+0x54, 0x20, 0x2f, 0x20, 0x48, 0x54, 0x54, 0x50,\r
+0x2f, 0x31, 0x2e, 0x31, 0x0d, 0x0a, 0x41, 0x63,\r
+0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x69, 0x6d,\r
+0x61, 0x67, 0x65, 0x2f, 0x67, 0x69, 0x66, 0x2c,\r
+0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x78,\r
+0x2d, 0x78, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70,\r
+0x2c, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f,\r
+0x6a, 0x70, 0x65, 0x67, 0x2c, 0x20, 0x69, 0x6d,\r
+0x61, 0x67, 0x65, 0x2f, 0x70, 0x6a, 0x70, 0x65,\r
+0x67, 0x2c, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69,\r
+0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76,\r
+0x6e, 0x64, 0x2e, 0x6d, 0x73, 0x2d, 0x65, 0x78,\r
+0x63, 0x65, 0x6c, 0x2c, 0x20, 0x61, 0x70, 0x70,\r
+0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,\r
+0x2f, 0x6d, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x2c,\r
+0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,\r
+0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76, 0x6e, 0x64,\r
+0x2e, 0x6d, 0x73, 0x2d, 0x70, 0x6f, 0x77, 0x65,\r
+0x72, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2c, 0x20,\r
+0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,\r
+0x69, 0x6f, 0x6e, 0x2f, 0x78, 0x2d, 0x6d, 0x73,\r
+0x2d, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,\r
+0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x61, 0x70,\r
+0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,\r
+0x6e, 0x2f, 0x78, 0x2d, 0x6d, 0x73, 0x2d, 0x78,\r
+0x62, 0x61, 0x70, 0x2c, 0x20, 0x61, 0x70, 0x70,\r
+0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,\r
+0x2f, 0x76, 0x6e, 0x64, 0x2e, 0x6d, 0x73, 0x2d,\r
+0x78, 0x70, 0x73, 0x64, 0x6f, 0x63, 0x75, 0x6d,\r
+0x65, 0x6e, 0x74, 0x2c, 0x20, 0x61, 0x70, 0x70,\r
+0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,\r
+0x2f, 0x78, 0x61, 0x6d, 0x6c, 0x2b, 0x78, 0x6d,\r
+0x6c, 0x2c, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a,\r
+0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x4c,\r
+0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3a,\r
+0x20, 0x65, 0x6e, 0x2d, 0x67, 0x62, 0x0d, 0x0a,\r
+0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x45,\r
+0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x3a,\r
+0x20, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x20, 0x64,\r
+0x65, 0x66, 0x6c, 0x61, 0x74, 0x65, 0x0d, 0x0a,\r
+0x55, 0x73, 0x65, 0x72, 0x2d, 0x41, 0x67, 0x65,\r
+0x6e, 0x74, 0x3a, 0x20, 0x4d, 0x6f, 0x7a, 0x69,\r
+0x6c, 0x6c, 0x61, 0x2f, 0x34, 0x2e, 0x30, 0x20,\r
+0x28, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69,\r
+0x62, 0x6c, 0x65, 0x3b, 0x20, 0x4d, 0x53, 0x49,\r
+0x45, 0x20, 0x36, 0x2e, 0x30, 0x3b, 0x20, 0x57,\r
+0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x20, 0x4e,\r
+0x54, 0x20, 0x35, 0x2e, 0x31, 0x3b, 0x20, 0x53,\r
+0x56, 0x31, 0x3b, 0x20, 0x47, 0x6f, 0x6f, 0x67,\r
+0x6c, 0x65, 0x54, 0x35, 0x3b, 0x20, 0x2e, 0x4e,\r
+0x45, 0x54, 0x20, 0x43, 0x4c, 0x52, 0x20, 0x32,\r
+0x2e, 0x30, 0x2e, 0x35, 0x30, 0x37, 0x32, 0x37,\r
+0x3b, 0x20, 0x2e, 0x4e, 0x45, 0x54, 0x20, 0x43,\r
+0x4c, 0x52, 0x20, 0x33, 0x2e, 0x30, 0x2e, 0x30,\r
+0x34, 0x35, 0x30, 0x36, 0x2e, 0x36, 0x34, 0x38,\r
+0x3b, 0x20, 0x2e, 0x4e, 0x45, 0x54, 0x20, 0x43,\r
+0x4c, 0x52, 0x20, 0x33, 0x2e, 0x35, 0x2e, 0x32,\r
+0x31, 0x30, 0x32, 0x32, 0x29, 0x0d, 0x0a, 0x48,\r
+0x6f, 0x73, 0x74, 0x3a, 0x20, 0x31, 0x39, 0x32,\r
+0x2e, 0x31, 0x36, 0x38, 0x2e, 0x30, 0x2e, 0x31,\r
+0x32, 0x0d, 0x0a, 0x43, 0x6f, 0x6e, 0x6e, 0x65,\r
+0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x4b,\r
+0x65, 0x65, 0x70, 0x2d, 0x41, 0x6c, 0x69, 0x76,\r
+0x65, 0x0d, 0x0a, 0x0d, 0x0a };\r
+\r
+char pkt5[] = {\r
+0x00, 0x14, 0x22, 0xcb, 0x18, 0x2d, 0x00, 0x01,\r
+0x02, 0x45, 0x09, 0x11, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x2c, 0x00, 0x02, 0x00, 0x00, 0x40, 0x06,\r
+0xf8, 0xa5, 0xc0, 0xa8, 0x00, 0x0c, 0xc0, 0xa8,\r
+0x00, 0xc8, 0x00, 0x50, 0x0f, 0xe2, 0x00, 0x00,\r
+0x06, 0x68, 0x09, 0xe7, 0xc7, 0x36, 0x60, 0x12,\r
+0x05, 0x92, 0x28, 0xca, 0x00, 0x00, 0x02, 0x04,\r
+0x05, 0x92 };\r
+\r
+char pkt6[] = {\r
+0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,\r
+0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x28, 0x09, 0xa1, 0x40, 0x00, 0x80, 0x06,\r
+0x6f, 0x0a, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,\r
+0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,\r
+0xc9, 0x35, 0x00, 0x00, 0x06, 0x69, 0x50, 0x10,\r
+0x42, 0xd8, 0x82, 0x3f, 0x00, 0x00 };\r
+\r
+char pkt7[] = {\r
+0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,\r
+0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,\r
+0x02, 0x27, 0x09, 0xa2, 0x40, 0x00, 0x80, 0x06,\r
+0x6d, 0x0a, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,\r
+0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,\r
+0xc7, 0x36, 0x00, 0x00, 0x06, 0x69, 0x50, 0x18,\r
+0x42, 0xd8, 0x84, 0x3e, 0x00, 0x00, 0x47, 0x45,\r
+0x54, 0x20, 0x2f, 0x20, 0x48, 0x54, 0x54, 0x50,\r
+0x2f, 0x31, 0x2e, 0x31, 0x0d, 0x0a, 0x41, 0x63,\r
+0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x69, 0x6d,\r
+0x61, 0x67, 0x65, 0x2f, 0x67, 0x69, 0x66, 0x2c,\r
+0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x78,\r
+0x2d, 0x78, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70,\r
+0x2c, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f,\r
+0x6a, 0x70, 0x65, 0x67, 0x2c, 0x20, 0x69, 0x6d,\r
+0x61, 0x67, 0x65, 0x2f, 0x70, 0x6a, 0x70, 0x65,\r
+0x67, 0x2c, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69,\r
+0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76,\r
+0x6e, 0x64, 0x2e, 0x6d, 0x73, 0x2d, 0x65, 0x78,\r
+0x63, 0x65, 0x6c, 0x2c, 0x20, 0x61, 0x70, 0x70,\r
+0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,\r
+0x2f, 0x6d, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x2c,\r
+0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,\r
+0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76, 0x6e, 0x64,\r
+0x2e, 0x6d, 0x73, 0x2d, 0x70, 0x6f, 0x77, 0x65,\r
+0x72, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2c, 0x20,\r
+0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,\r
+0x69, 0x6f, 0x6e, 0x2f, 0x78, 0x2d, 0x6d, 0x73,\r
+0x2d, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,\r
+0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x61, 0x70,\r
+0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,\r
+0x6e, 0x2f, 0x78, 0x2d, 0x6d, 0x73, 0x2d, 0x78,\r
+0x62, 0x61, 0x70, 0x2c, 0x20, 0x61, 0x70, 0x70,\r
+0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,\r
+0x2f, 0x76, 0x6e, 0x64, 0x2e, 0x6d, 0x73, 0x2d,\r
+0x78, 0x70, 0x73, 0x64, 0x6f, 0x63, 0x75, 0x6d,\r
+0x65, 0x6e, 0x74, 0x2c, 0x20, 0x61, 0x70, 0x70,\r
+0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,\r
+0x2f, 0x78, 0x61, 0x6d, 0x6c, 0x2b, 0x78, 0x6d,\r
+0x6c, 0x2c, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a,\r
+0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x4c,\r
+0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3a,\r
+0x20, 0x65, 0x6e, 0x2d, 0x67, 0x62, 0x0d, 0x0a,\r
+0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x45,\r
+0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x3a,\r
+0x20, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x20, 0x64,\r
+0x65, 0x66, 0x6c, 0x61, 0x74, 0x65, 0x0d, 0x0a,\r
+0x55, 0x73, 0x65, 0x72, 0x2d, 0x41, 0x67, 0x65,\r
+0x6e, 0x74, 0x3a, 0x20, 0x4d, 0x6f, 0x7a, 0x69,\r
+0x6c, 0x6c, 0x61, 0x2f, 0x34, 0x2e, 0x30, 0x20,\r
+0x28, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69,\r
+0x62, 0x6c, 0x65, 0x3b, 0x20, 0x4d, 0x53, 0x49,\r
+0x45, 0x20, 0x36, 0x2e, 0x30, 0x3b, 0x20, 0x57,\r
+0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x20, 0x4e,\r
+0x54, 0x20, 0x35, 0x2e, 0x31, 0x3b, 0x20, 0x53,\r
+0x56, 0x31, 0x3b, 0x20, 0x47, 0x6f, 0x6f, 0x67,\r
+0x6c, 0x65, 0x54, 0x35, 0x3b, 0x20, 0x2e, 0x4e,\r
+0x45, 0x54, 0x20, 0x43, 0x4c, 0x52, 0x20, 0x32,\r
+0x2e, 0x30, 0x2e, 0x35, 0x30, 0x37, 0x32, 0x37,\r
+0x3b, 0x20, 0x2e, 0x4e, 0x45, 0x54, 0x20, 0x43,\r
+0x4c, 0x52, 0x20, 0x33, 0x2e, 0x30, 0x2e, 0x30,\r
+0x34, 0x35, 0x30, 0x36, 0x2e, 0x36, 0x34, 0x38,\r
+0x3b, 0x20, 0x2e, 0x4e, 0x45, 0x54, 0x20, 0x43,\r
+0x4c, 0x52, 0x20, 0x33, 0x2e, 0x35, 0x2e, 0x32,\r
+0x31, 0x30, 0x32, 0x32, 0x29, 0x0d, 0x0a, 0x48,\r
+0x6f, 0x73, 0x74, 0x3a, 0x20, 0x31, 0x39, 0x32,\r
+0x2e, 0x31, 0x36, 0x38, 0x2e, 0x30, 0x2e, 0x31,\r
+0x32, 0x0d, 0x0a, 0x43, 0x6f, 0x6e, 0x6e, 0x65,\r
+0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x4b,\r
+0x65, 0x65, 0x70, 0x2d, 0x41, 0x6c, 0x69, 0x76,\r
+0x65, 0x0d, 0x0a, 0x0d, 0x0a };\r
+\r
+char pkt8[] = {\r
+0x00, 0x14, 0x22, 0xcb, 0x18, 0x2d, 0x00, 0x01,\r
+0x02, 0x45, 0x09, 0x11, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x2c, 0x00, 0x03, 0x00, 0x00, 0x40, 0x06,\r
+0xf8, 0xa4, 0xc0, 0xa8, 0x00, 0x0c, 0xc0, 0xa8,\r
+0x00, 0xc8, 0x00, 0x50, 0x0f, 0xe2, 0x00, 0x00,\r
+0x06, 0x68, 0x09, 0xe7, 0xc7, 0x36, 0x60, 0x12,\r
+0x05, 0x92, 0x28, 0xca, 0x00, 0x00, 0x02, 0x04,\r
+0x05, 0x92 };\r
+\r
+char pkt9[] = {\r
+0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,\r
+0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x28, 0x09, 0xa3, 0x40, 0x00, 0x80, 0x06,\r
+0x6f, 0x08, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,\r
+0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,\r
+0xc9, 0x35, 0x00, 0x00, 0x06, 0x69, 0x50, 0x10,\r
+0x42, 0xd8, 0x82, 0x3f, 0x00, 0x00 };\r
+\r
+char pkt10[] = {\r
+0x00, 0x14, 0x22, 0xcb, 0x18, 0x2d, 0x00, 0x01,\r
+0x02, 0x45, 0x09, 0x11, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x2c, 0x00, 0x04, 0x00, 0x00, 0x40, 0x06,\r
+0xf8, 0xa3, 0xc0, 0xa8, 0x00, 0x0c, 0xc0, 0xa8,\r
+0x00, 0xc8, 0x00, 0x50, 0x0f, 0xe2, 0x00, 0x00,\r
+0x06, 0x68, 0x09, 0xe7, 0xc7, 0x36, 0x60, 0x12,\r
+0x05, 0x92, 0x28, 0xca, 0x00, 0x00, 0x02, 0x04,\r
+0x05, 0x92 };\r
+\r
+char pkt11[] = {\r
+0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,\r
+0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x28, 0x09, 0xa6, 0x40, 0x00, 0x80, 0x06,\r
+0x6f, 0x05, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,\r
+0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,\r
+0xc9, 0x35, 0x00, 0x00, 0x06, 0x69, 0x50, 0x10,\r
+0x42, 0xd8, 0x82, 0x3f, 0x00, 0x00 };\r
+\r
+char pkt12[] = {\r
+0x00, 0x01, 0x02, 0x45, 0x09, 0x11, 0x00, 0x14,\r
+0x22, 0xcb, 0x18, 0x2d, 0x08, 0x00, 0x45, 0x00,\r
+0x00, 0x28, 0x09, 0xa7, 0x40, 0x00, 0x80, 0x06,\r
+0x6f, 0x04, 0xc0, 0xa8, 0x00, 0xc8, 0xc0, 0xa8,\r
+0x00, 0x0c, 0x0f, 0xe2, 0x00, 0x50, 0x09, 0xe7,\r
+0xc9, 0x35, 0x00, 0x00, 0x06, 0x69, 0x50, 0x14,\r
+0x00, 0x00, 0x43, 0xf4, 0x00, 0x00 };\r
+\r
+\r
+typedef struct\r
+{\r
+       char *pcData;\r
+       int iDataLen;\r
+} xPacketData;\r
+\r
+xPacketData xAllPackets[] =\r
+{\r
+       { pkt1, sizeof( pkt1 ) },\r
+//     { pkt2, sizeof( pkt2 ) },\r
+       { pkt3, sizeof( pkt3 ) },\r
+       { pkt4, sizeof( pkt4 ) },\r
+//     { pkt5, sizeof( pkt5 ) },\r
+       { pkt6, sizeof( pkt6 ) },\r
+       { pkt7, sizeof( pkt7 ) },\r
+       { pkt8, sizeof( pkt8 ) },\r
+       { pkt9, sizeof( pkt9 ) },\r
+       { pkt10, sizeof( pkt10 ) },\r
+//     { pkt11, sizeof( pkt11 ) },\r
+//     { pkt12, sizeof( pkt12 ) },\r
+//     { pkt13, sizeof( pkt13 ) },\r
+//     { pkt14, sizeof( pkt14 ) },\r
+//     { pkt15, sizeof( pkt15 ) },\r
+//     { pkt16, sizeof( pkt16 ) },\r
+};\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/Win32-Extensions.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/Win32-Extensions.h
new file mode 100644 (file)
index 0000000..be71c85
--- /dev/null
@@ -0,0 +1,114 @@
+/*\r
+ * Copyright (c) 1999 - 2005 NetGroup, Politecnico di Torino (Italy)\r
+ * Copyright (c) 2005 - 2006 CACE Technologies, Davis (California)\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ *\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ * 3. Neither the name of the Politecnico di Torino, CACE Technologies \r
+ * nor the names of its contributors may be used to endorse or promote \r
+ * products derived from this software without specific prior written \r
+ * permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ *\r
+ */\r
+\r
+\r
+#ifndef __WIN32_EXTENSIONS_H__\r
+#define __WIN32_EXTENSIONS_H__\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+/* Definitions */\r
+\r
+/*!\r
+  \brief A queue of raw packets that will be sent to the network with pcap_sendqueue_transmit().\r
+*/\r
+struct pcap_send_queue\r
+{\r
+       u_int maxlen;           ///< Maximum size of the the queue, in bytes. This variable contains the size of the buffer field.\r
+       u_int len;                      ///< Current size of the queue, in bytes.\r
+       char *buffer;           ///< Buffer containing the packets to be sent.\r
+};\r
+\r
+typedef struct pcap_send_queue pcap_send_queue;\r
+\r
+/*!\r
+  \brief This typedef is a support for the pcap_get_airpcap_handle() function\r
+*/\r
+#if !defined(AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_)\r
+#define AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_\r
+typedef struct _AirpcapHandle *PAirpcapHandle;\r
+#endif\r
+\r
+#define                BPF_MEM_EX_IMM  0xc0\r
+#define                BPF_MEM_EX_IND  0xe0\r
+\r
+/*used for ST*/\r
+#define                BPF_MEM_EX              0xc0\r
+#define                BPF_TME                                 0x08\r
+\r
+#define                BPF_LOOKUP                              0x90   \r
+#define                BPF_EXECUTE                             0xa0\r
+#define                BPF_INIT                                0xb0\r
+#define                BPF_VALIDATE                    0xc0\r
+#define                BPF_SET_ACTIVE                  0xd0\r
+#define                BPF_RESET                               0xe0\r
+#define                BPF_SET_MEMORY                  0x80\r
+#define                BPF_GET_REGISTER_VALUE  0x70\r
+#define                BPF_SET_REGISTER_VALUE  0x60\r
+#define                BPF_SET_WORKING                 0x50\r
+#define                BPF_SET_ACTIVE_READ             0x40\r
+#define                BPF_SET_AUTODELETION    0x30\r
+#define                BPF_SEPARATION                  0xff\r
+\r
+/* Prototypes */\r
+pcap_send_queue* pcap_sendqueue_alloc(u_int memsize);\r
+\r
+void pcap_sendqueue_destroy(pcap_send_queue* queue);\r
+\r
+int pcap_sendqueue_queue(pcap_send_queue* queue, const struct pcap_pkthdr *pkt_header, const u_char *pkt_data);\r
+\r
+u_int pcap_sendqueue_transmit(pcap_t *p, pcap_send_queue* queue, int sync);\r
+\r
+HANDLE pcap_getevent(pcap_t *p);\r
+\r
+struct pcap_stat *pcap_stats_ex(pcap_t *p, int *pcap_stat_size);\r
+\r
+int pcap_setuserbuffer(pcap_t *p, int size);\r
+\r
+int pcap_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks);\r
+\r
+int pcap_live_dump_ended(pcap_t *p, int sync);\r
+\r
+int pcap_offline_filter(struct bpf_program *prog, const struct pcap_pkthdr *header, const u_char *pkt_data);\r
+\r
+int pcap_start_oem(char* err_str, int flags);\r
+\r
+PAirpcapHandle pcap_get_airpcap_handle(pcap_t *p);\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+#endif //__WIN32_EXTENSIONS_H__\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/arch.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/arch.c
new file mode 100644 (file)
index 0000000..d704da8
--- /dev/null
@@ -0,0 +1,336 @@
+/*\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
+\r
+/* WinPCap includes. */\r
+#include "pcap.h"\r
+#include "remote-ext.h"\r
+\r
+/* uIP includes. */\r
+#include "net/uip.h"\r
+#include "net/uip_arp.h"\r
+#include "net/clock-arch.h"\r
+\r
+/* FreeRTOS includes. */\r
+#include "FreeRTOS.h"\r
+#include "task.h"\r
+#include "queue.h"\r
+\r
+/*\r
+ * Query the computer the simulation is being executed on to find the network\r
+ * interfaces it has installed.\r
+ */\r
+static pcap_if_t * prvPrintAvailableNetworkInterfaces( void );\r
+\r
+/*\r
+ * Open the network interface.  The number of the interface to be opened is set\r
+ * by the configNETWORK_INTERFACE_TO_USE constant in FreeRTOSConfig.h.\r
+ */\r
+static void prvOpenSelectedNetworkInterface( pcap_if_t *pxAllNetworkInterfaces );\r
+\r
+/*\r
+ * Configure the capture filter to allow blocking reads, and to filter out\r
+ * packets that are not of interest to this demo.\r
+ */\r
+static void prvConfigureCaptureBehaviour( void );\r
+\r
+pcap_t *pxOpenedInterfaceHandle = NULL;\r
+LARGE_INTEGER freq, sys_start_time;\r
+\r
+#define archNUM_BUFFERS        5\r
+#define archNUM_BUFFER_POINTERS ( archNUM_BUFFERS - 1 )\r
+\r
+static void prvInterruptSimulator( void *pvParameters );\r
+\r
+static unsigned char ucEthernetBuffer[ archNUM_BUFFERS ][ UIP_CONF_BUFFER_SIZE ];\r
+static unsigned char *pucEthernetBufferPointers[ archNUM_BUFFER_POINTERS ];\r
+\r
+static long lLengthOfDataInBuffer[ archNUM_BUFFER_POINTERS ] = { 0 };\r
+static unsigned char ucNextBufferToFill = 0U, ucNextBufferToProcess = 0U;\r
+\r
+unsigned char *uip_buf = NULL;\r
+char cErrorBuffer[PCAP_ERRBUF_SIZE];\r
+\r
+void vNetifTx( void )\r
+{\r
+       pcap_sendpacket( pxOpenedInterfaceHandle, uip_buf, uip_len );\r
+       pcap_sendpacket( pxOpenedInterfaceHandle, uip_buf, uip_len );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+UBaseType_t uxNetifRx( void )\r
+{\r
+UBaseType_t xDataLen;\r
+unsigned char *pucTemp;\r
+\r
+       /* Check there is really data available. */\r
+       xDataLen = lLengthOfDataInBuffer[ ucNextBufferToProcess ];\r
+       if( xDataLen != 0L )\r
+       {\r
+\r
+               /* The buffer pointed to by uip_buf is going to change.  Remember which\r
+               buffer uip_buf is currently pointing to. */\r
+               pucTemp = uip_buf;\r
+\r
+               /* Point uip_buf at the next buffer that contains data. */\r
+               uip_buf = pucEthernetBufferPointers[ ucNextBufferToProcess ];\r
+\r
+               /* The buffer pointed to by \r
+               pucEthernetBufferPointeres[ ucNextBufferToProcess ] is now in use by\r
+               uip_buf, but the buffer uip_buf was pointing to on entry to this\r
+               function is free.  Set \r
+               pucEthernetBufferPointeres[ ucNextBufferToProcess ] to the free \r
+               buffer. */\r
+               pucEthernetBufferPointers[ ucNextBufferToProcess ] = pucTemp;\r
+               lLengthOfDataInBuffer[ ucNextBufferToProcess ] = 0L;\r
+\r
+               ucNextBufferToProcess++;\r
+               if( ucNextBufferToProcess >= archNUM_BUFFER_POINTERS )\r
+               {\r
+                       ucNextBufferToProcess = 0L;\r
+               }\r
+       }\r
+\r
+       return xDataLen;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+BaseType_t xNetifInit( void )\r
+{\r
+BaseType_t x;\r
+pcap_if_t *pxAllNetworkInterfaces;\r
+\r
+       /* Allocate a free buffer to each buffer pointer. */\r
+       for( x = 0; x < sizeof( pucEthernetBufferPointers ) / sizeof( unsigned char * ); x++ )\r
+       {\r
+               pucEthernetBufferPointers[ x ] = &( ucEthernetBuffer[ x ][ 0 ] );\r
+       }\r
+\r
+       /* Start with uip_buf pointing to a buffer that is not referenced from the\r
+       pucEthernetBufferPointers[] array. */\r
+       uip_buf = &( ucEthernetBuffer[ archNUM_BUFFERS - 1 ][ 0 ] );\r
+\r
+       /* Query the computer the simulation is being executed on to find the \r
+       network interfaces it has installed. */\r
+       pxAllNetworkInterfaces = prvPrintAvailableNetworkInterfaces();\r
+       \r
+       /* Open the network interface.  The number of the interface to be opened is \r
+       set by the configNETWORK_INTERFACE_TO_USE constant in FreeRTOSConfig.h.\r
+       Calling this function will set the pxOpenedInterfaceHandle variable.  If,\r
+       after calling this function, pxOpenedInterfaceHandle is equal to NULL, then\r
+       the interface could not be opened. */\r
+       if( pxAllNetworkInterfaces != NULL )\r
+       {\r
+               prvOpenSelectedNetworkInterface( pxAllNetworkInterfaces );\r
+       }\r
+       \r
+\r
+       return x;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static pcap_if_t * prvPrintAvailableNetworkInterfaces( void )\r
+{    \r
+pcap_if_t * pxAllNetworkInterfaces = NULL, *xInterface;\r
+long lInterfaceNumber = 1;\r
+\r
+    if( pcap_findalldevs_ex( PCAP_SRC_IF_STRING, NULL, &pxAllNetworkInterfaces, cErrorBuffer ) == -1 )\r
+    {\r
+        printf( "\r\nCould not obtain a list of network interfaces\r\n%s\r\n", cErrorBuffer );\r
+        pxAllNetworkInterfaces = NULL;\r
+    }\r
+\r
+       if( pxAllNetworkInterfaces != NULL )\r
+       {\r
+               /* Print out the list of network interfaces.  The first in the list\r
+               is interface '1', not interface '0'. */\r
+               for( xInterface = pxAllNetworkInterfaces; xInterface != NULL; xInterface = xInterface->next )\r
+               {\r
+                       printf( "%d. %s", lInterfaceNumber, xInterface->name );\r
+                       \r
+                       if( xInterface->description != NULL )\r
+                       {\r
+                               printf( " (%s)\r\n", xInterface->description );\r
+                       }\r
+                       else\r
+                       {\r
+                               printf( " (No description available)\r\n") ;\r
+                       }\r
+                       \r
+                       lInterfaceNumber++;\r
+               }\r
+       }\r
+\r
+    if( lInterfaceNumber == 1 )\r
+    {\r
+               /* The interface number was never incremented, so the above for() loop\r
+               did not execute meaning no interfaces were found. */\r
+        printf( " \r\nNo network interfaces were found.\r\n" );\r
+        pxAllNetworkInterfaces = NULL;\r
+    }\r
+\r
+       printf( "\r\nThe interface that will be opened is set by configNETWORK_INTERFACE_TO_USE which should be defined in FreeRTOSConfig.h\r\n" );\r
+       printf( "Attempting to open interface number %d.\r\n", configNETWORK_INTERFACE_TO_USE );\r
+       \r
+    if( ( configNETWORK_INTERFACE_TO_USE < 1L ) || ( configNETWORK_INTERFACE_TO_USE > lInterfaceNumber ) )\r
+    {\r
+        printf("\r\nconfigNETWORK_INTERFACE_TO_USE is not in the valid range.\r\n" );\r
+               \r
+               if( pxAllNetworkInterfaces != NULL )\r
+               {\r
+                       /* Free the device list, as no devices are going to be opened. */\r
+                       pcap_freealldevs( pxAllNetworkInterfaces );\r
+                       pxAllNetworkInterfaces = NULL;\r
+               }\r
+    }\r
+\r
+       return pxAllNetworkInterfaces;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvOpenSelectedNetworkInterface( pcap_if_t *pxAllNetworkInterfaces )\r
+{\r
+pcap_if_t *xInterface;\r
+long x;\r
+\r
+    /* Walk the list of devices until the selected device is located. */\r
+       xInterface = pxAllNetworkInterfaces;\r
+    for( x = 0L; x < ( configNETWORK_INTERFACE_TO_USE - 1L ); x++ )\r
+       {\r
+               xInterface = xInterface->next;\r
+       }\r
+\r
+    /* Open the selected interface. */\r
+       pxOpenedInterfaceHandle = pcap_open(    xInterface->name,               /* The name of the selected interface. */\r
+                                                                                       UIP_CONF_BUFFER_SIZE,           /* The size of the packet to capture. */\r
+                                                                                       PCAP_OPENFLAG_PROMISCUOUS,      /* Open in promiscious mode as the MAC and \r
+                                                                                                                                               IP address is going to be "simulated", and \r
+                                                                                                                                               not be the real MAC and IP address.  This allows\r
+                                                                                                                                               trafic to the simulated IP address to be routed\r
+                                                                                                                                               to uIP, and trafic to the real IP address to be\r
+                                                                                                                                               routed to the Windows TCP/IP stack. */\r
+                                                                                       0xfffffffL,                     /* The read time out.  This is going to block\r
+                                                                                                                                               until data is available. */\r
+                                                                                       NULL,                                   /* No authentication is required as this is\r
+                                                                                                                                               not a remote capture session. */\r
+                                                                                       cErrorBuffer            \r
+                                                                          );\r
+                                                                          \r
+    if ( pxOpenedInterfaceHandle == NULL )\r
+    {\r
+        printf( "\r\n%s is not supported by WinPcap and cannot be opened\r\n", xInterface->name );\r
+    }\r
+       else\r
+       {\r
+               /* Configure the capture filter to allow blocking reads, and to filter \r
+               out packets that are not of interest to this demo. */\r
+               prvConfigureCaptureBehaviour();\r
+       }\r
+\r
+       /* The device list is no longer required. */\r
+       pcap_freealldevs( pxAllNetworkInterfaces );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvConfigureCaptureBehaviour( void )\r
+{\r
+struct bpf_program xFilterCode;\r
+const long lMinBytesToCopy = 10L, lBlocking = 0L;\r
+unsigned long ulNetMask;\r
+\r
+       /* Unblock a read as soon as anything is received. */\r
+       pcap_setmintocopy( pxOpenedInterfaceHandle, lMinBytesToCopy );\r
+\r
+       /* Allow blocking. */\r
+       pcap_setnonblock( pxOpenedInterfaceHandle, lBlocking, cErrorBuffer );\r
+\r
+       /* Set up a filter so only the packets of interest are passed to the uIP\r
+       stack.  cErrorBuffer is used for convenience to create the string.  Don't\r
+       confuse this with an error message. */\r
+       sprintf( cErrorBuffer, "broadcast or multicast or host %d.%d.%d.%d", configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 );\r
+\r
+       ulNetMask = ( configNET_MASK3 << 24UL ) | ( configNET_MASK2 << 16UL ) | ( configNET_MASK1 << 8L ) | configNET_MASK0;\r
+\r
+       if( pcap_compile(pxOpenedInterfaceHandle, &xFilterCode, cErrorBuffer, 1, ulNetMask ) < 0 )\r
+    {\r
+        printf("\r\nThe packet filter string is invalid\r\n" );\r
+    }\r
+       else\r
+       {    \r
+               if( pcap_setfilter( pxOpenedInterfaceHandle, &xFilterCode ) < 0 )\r
+               {\r
+                       printf( "\r\nAn error occurred setting the packet filter.\r\n" );\r
+               }\r
+       }\r
+\r
+       /* Create a task that simulates an interrupt in a real system.  This will\r
+       block waiting for packets, then send a message to the uIP task when data\r
+       is available. */\r
+       xTaskCreate( prvInterruptSimulator, ( signed char * ) "MAC_ISR", configMINIMAL_STACK_SIZE, NULL, ( configuIP_TASK_PRIORITY - 1 ), NULL );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvInterruptSimulator( void *pvParameters )\r
+{\r
+static struct pcap_pkthdr *pxHeader;\r
+const unsigned char *pucPacketData;\r
+extern QueueHandle_t xEMACEventQueue;\r
+const unsigned long ulRxEvent = uipETHERNET_RX_EVENT;\r
+long lResult;\r
+\r
+       /* Just to kill the compiler warning. */\r
+       ( void ) pvParameters;\r
+\r
+       for( ;; )\r
+       {\r
+               /* Get the next packet. */\r
+               lResult = pcap_next_ex( pxOpenedInterfaceHandle, &pxHeader, &pucPacketData );\r
+               if( lResult )\r
+               {\r
+                       /* Is the next buffer into which data should be placed free? */\r
+                       if( lLengthOfDataInBuffer[ ucNextBufferToFill ] == 0L )\r
+                       {\r
+                               /* Copy the data from the captured packet into the buffer. */\r
+                               memcpy( pucEthernetBufferPointers[ ucNextBufferToFill ], pucPacketData, pxHeader->len );\r
+\r
+                               /* Note the amount of data that was copied. */\r
+                               lLengthOfDataInBuffer[ ucNextBufferToFill ] = pxHeader->len;\r
+\r
+                               /* Move onto the next buffer, wrapping around if necessary. */\r
+                               ucNextBufferToFill++;\r
+                               if( ucNextBufferToFill >= archNUM_BUFFER_POINTERS )\r
+                               {\r
+                                       ucNextBufferToFill = 0U;\r
+                               }\r
+\r
+                               /* Data was received and stored.  Send a message to the uIP task\r
+                               to let it know. */\r
+                               xQueueSendToBack( xEMACEventQueue, &ulRxEvent, portMAX_DELAY );\r
+                       }\r
+               }\r
+       }\r
+}\r
+\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/bittypes.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/bittypes.h
new file mode 100644 (file)
index 0000000..f55fcec
--- /dev/null
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 1999 WIDE Project.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#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
+#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
+#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
+
+#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_IoT_SDK/task_pool/WinPCap/ip6_misc.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/ip6_misc.h
new file mode 100644 (file)
index 0000000..562fa61
--- /dev/null
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 1993, 1994, 1997
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that: (1) source code distributions
+ * retain the above copyright notice and this paragraph in its entirety, (2)
+ * distributions including binary code include the above copyright notice and
+ * this paragraph in its entirety in the documentation or other materials
+ * provided with the distribution, and (3) all advertising materials mentioning
+ * features or use of this software display the following acknowledgement:
+ * ``This product includes software developed by the University of California,
+ * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
+ * the University nor the names of its contributors may be used to endorse
+ * or promote products derived from this software without specific prior
+ * written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/Win32/Include/ip6_misc.h,v 1.5 2006-01-22 18:02:18 gianluca Exp $ (LBL)
+ */
+
+/*
+ * This file contains a collage of declarations for IPv6 from FreeBSD not present in Windows
+ */
+
+#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
+#endif /* __MINGW32__ */
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/netif.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/netif.h
new file mode 100644 (file)
index 0000000..8fe5393
--- /dev/null
@@ -0,0 +1,52 @@
+/*\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
+\r
+#ifndef NET_IF_H\r
+#define NET_IF_H\r
+\r
+/*\r
+ * Send uip_len bytes from uip_buf to the network interface selected by the \r
+ * configNETWORK_INTERFACE_TO_USE constant (defined in FreeRTOSConfig.h). \r
+ */\r
+void vNetifTx( void );\r
+\r
+/*\r
+ * Receive bytes from the network interface selected by the \r
+ * configNETWORK_INTERFACE_TO_USE constant (defined in FreeRTOSConfig.h).  The\r
+ * bytes are placed in uip_buf.  The number of bytes copied into uip_buf is\r
+ * returned.\r
+ */\r
+UBaseType_t uxNetifRx( void );\r
+\r
+/*\r
+ * Prepare a packet capture session.  This will print out all the network \r
+ * interfaces available, and the one actually used is set by the \r
+ * configNETWORK_INTERFACE_TO_USE constant that is defined in \r
+ * FreeRTOSConfig.h. */\r
+BaseType_t xNetifInit( void );\r
+\r
+#endif /* NET_IF_H */\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap-bpf.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap-bpf.h
new file mode 100644 (file)
index 0000000..5fe129d
--- /dev/null
@@ -0,0 +1,47 @@
+/*-
+ * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from the Stanford/CMU enet packet filter,
+ * (net/enet.c) distributed as part of 4.3BSD, and code contributed
+ * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence 
+ * Berkeley Laboratory.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap-bpf.h,v 1.50 2007/04/01 21:43:55 guy Exp $ (LBL)
+ */
+
+/*
+ * 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_IoT_SDK/task_pool/WinPCap/pcap-namedb.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap-namedb.h
new file mode 100644 (file)
index 0000000..80a2f00
--- /dev/null
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 1994, 1996
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the Computer Systems
+ *     Engineering Group at Lawrence Berkeley Laboratory.
+ * 4. Neither the name of the University nor of the Laboratory may be used
+ *    to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap-namedb.h,v 1.13 2006/10/04 18:13:32 guy Exp $ (LBL)
+ */
+
+/*
+ * 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_IoT_SDK/task_pool/WinPCap/pcap-stdinc.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap-stdinc.h
new file mode 100644 (file)
index 0000000..cbd62d1
--- /dev/null
@@ -0,0 +1,93 @@
+/*\r
+ * Copyright (c) 2002 - 2005 NetGroup, Politecnico di Torino (Italy)\r
+ * Copyright (c) 2005 - 2009 CACE Technologies, Inc. Davis (California)\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ *\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ * 3. Neither the name of the Politecnico di Torino nor the names of its\r
+ * contributors may be used to endorse or promote products derived from\r
+ * this software without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ *\r
+ * @(#) $Header: /tcpdump/master/libpcap/pcap-stdinc.h,v 1.10.2.1 2008-10-06 15:38:39 gianluca Exp $ (LBL)\r
+ */\r
+\r
+#define SIZEOF_CHAR 1\r
+#define SIZEOF_SHORT 2\r
+#define SIZEOF_INT 4\r
+#ifndef _MSC_EXTENSIONS\r
+#define SIZEOF_LONG_LONG 8\r
+#endif\r
+\r
+/*\r
+ * Avoids a compiler warning in case this was already defined      \r
+ * (someone defined _WINSOCKAPI_ when including 'windows.h', in order\r
+ * to prevent it from including 'winsock.h')\r
+ */\r
+#ifdef _WINSOCKAPI_\r
+#undef _WINSOCKAPI_\r
+#endif\r
+#include <winsock2.h>\r
+\r
+#include <fcntl.h>\r
+\r
+#include "bittypes.h"\r
+#include <time.h>\r
+#include <io.h>\r
+\r
+#ifndef __MINGW32__\r
+#include "IP6_misc.h"\r
+#endif\r
+\r
+#define caddr_t char*\r
+\r
+#if _MSC_VER < 1500\r
+#define snprintf _snprintf\r
+#define vsnprintf _vsnprintf\r
+#define strdup _strdup\r
+#endif\r
+\r
+#define inline __inline \r
+\r
+#ifdef __MINGW32__\r
+#include <stdint.h>\r
+#else /*__MINGW32__*/\r
+/* MSVC compiler */\r
+#ifndef _UINTPTR_T_DEFINED\r
+#ifdef  _WIN64\r
+typedef unsigned __int64    uintptr_t;\r
+#else\r
+typedef _W64 unsigned int   uintptr_t;\r
+#endif\r
+#define _UINTPTR_T_DEFINED\r
+#endif\r
+\r
+#ifndef _INTPTR_T_DEFINED\r
+#ifdef  _WIN64\r
+typedef __int64    intptr_t;\r
+#else\r
+typedef _W64 int   intptr_t;\r
+#endif\r
+#define _INTPTR_T_DEFINED\r
+#endif \r
+\r
+#endif /*__MINGW32__*/\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap.h
new file mode 100644 (file)
index 0000000..935f949
--- /dev/null
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 1993, 1994, 1995, 1996, 1997
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the Computer Systems
+ *     Engineering Group at Lawrence Berkeley Laboratory.
+ * 4. Neither the name of the University nor of the Laboratory may be used
+ *    to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap.h,v 1.59 2006/10/04 18:09:22 guy Exp $ (LBL)
+ */
+
+/*
+ * 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_IoT_SDK/task_pool/WinPCap/pcap/bluetooth.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/bluetooth.h
new file mode 100644 (file)
index 0000000..7bf65df
--- /dev/null
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2006 Paolo Abeni (Italy)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote 
+ * products derived from this software without specific prior written 
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * bluetooth data struct
+ * By Paolo Abeni <paolo.abeni@email.it>
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap/bluetooth.h,v 1.1 2007/09/22 02:10:17 guy Exp $
+ */
+#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_IoT_SDK/task_pool/WinPCap/pcap/bpf.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/bpf.h
new file mode 100644 (file)
index 0000000..9f4ca33
--- /dev/null
@@ -0,0 +1,934 @@
+/*-
+ * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from the Stanford/CMU enet packet filter,
+ * (net/enet.c) distributed as part of 4.3BSD, and code contributed
+ * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence 
+ * Berkeley Laboratory.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      @(#)bpf.h       7.1 (Berkeley) 5/7/91
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap/bpf.h,v 1.19.2.8 2008-09-22 20:16:01 guy Exp $ (LBL)
+ */
+
+/*
+ * 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_IoT_SDK/task_pool/WinPCap/pcap/namedb.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/namedb.h
new file mode 100644 (file)
index 0000000..9002c75
--- /dev/null
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 1994, 1996
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the Computer Systems
+ *     Engineering Group at Lawrence Berkeley Laboratory.
+ * 4. Neither the name of the University nor of the Laboratory may be used
+ *    to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap/namedb.h,v 1.1 2006/10/04 18:09:22 guy Exp $ (LBL)
+ */
+
+#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_IoT_SDK/task_pool/WinPCap/pcap/pcap.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/pcap.h
new file mode 100644 (file)
index 0000000..ad8fc40
--- /dev/null
@@ -0,0 +1,407 @@
+/* -*- Mode: c; tab-width: 8; indent-tabs-mode: 1; c-basic-offset: 8; -*- */
+/*
+ * Copyright (c) 1993, 1994, 1995, 1996, 1997
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the Computer Systems
+ *     Engineering Group at Lawrence Berkeley Laboratory.
+ * 4. Neither the name of the University nor of the Laboratory may be used
+ *    to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap/pcap.h,v 1.4.2.11 2008-10-06 15:38:39 gianluca Exp $ (LBL)
+ */
+
+#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_IoT_SDK/task_pool/WinPCap/pcap/sll.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/sll.h
new file mode 100644 (file)
index 0000000..e9d5452
--- /dev/null
@@ -0,0 +1,129 @@
+/*-
+ * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from the Stanford/CMU enet packet filter,
+ * (net/enet.c) distributed as part of 4.3BSD, and code contributed
+ * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
+ * Berkeley Laboratory.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap/sll.h,v 1.2.2.1 2008-05-30 01:36:06 guy Exp $ (LBL)
+ */
+
+/*
+ * 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_IoT_SDK/task_pool/WinPCap/pcap/usb.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/usb.h
new file mode 100644 (file)
index 0000000..adcd19c
--- /dev/null
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2006 Paolo Abeni (Italy)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote 
+ * products derived from this software without specific prior written 
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Basic USB data struct
+ * By Paolo Abeni <paolo.abeni@email.it>
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap/usb.h,v 1.6 2007/09/22 02:06:08 guy Exp $
+ */
+#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_IoT_SDK/task_pool/WinPCap/pcap/vlan.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/pcap/vlan.h
new file mode 100644 (file)
index 0000000..b0cb794
--- /dev/null
@@ -0,0 +1,46 @@
+/*-
+ * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#) $Header: /tcpdump/master/libpcap/pcap/vlan.h,v 1.1.2.2 2008-08-06 07:45:59 guy Exp $
+ */
+
+#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_IoT_SDK/task_pool/WinPCap/remote-ext.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/remote-ext.h
new file mode 100644 (file)
index 0000000..9f54d69
--- /dev/null
@@ -0,0 +1,444 @@
+/*\r
+ * Copyright (c) 2002 - 2003\r
+ * NetGroup, Politecnico di Torino (Italy)\r
+ * All rights reserved.\r
+ * \r
+ * Redistribution and use in source and binary forms, with or without \r
+ * modification, are permitted provided that the following conditions \r
+ * are met:\r
+ * \r
+ * 1. Redistributions of source code must retain the above copyright \r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright \r
+ * notice, this list of conditions and the following disclaimer in the \r
+ * documentation and/or other materials provided with the distribution. \r
+ * 3. Neither the name of the Politecnico di Torino nor the names of its \r
+ * contributors may be used to endorse or promote products derived from \r
+ * this software without specific prior written permission. \r
+ * \r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR \r
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, \r
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY \r
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ * \r
+ */\r
+\r
+\r
+#ifndef __REMOTE_EXT_H__\r
+#define __REMOTE_EXT_H__\r
+\r
+\r
+#ifndef HAVE_REMOTE\r
+#error Please do not include this file directly. Just define HAVE_REMOTE and then include pcap.h\r
+#endif\r
+\r
+// Definition for Microsoft Visual Studio\r
+#if _MSC_VER > 1000\r
+#pragma once\r
+#endif\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+/*!\r
+       \file remote-ext.h\r
+\r
+       The goal of this file it to include most of the new definitions that should be\r
+       placed into the pcap.h file.\r
+\r
+       It includes all new definitions (structures and functions like pcap_open().\r
+    Some of the functions are not really a remote feature, but, right now, \r
+       they are placed here.\r
+*/\r
+\r
+\r
+\r
+// All this stuff is public\r
+/*! \addtogroup remote_struct\r
+       \{\r
+*/\r
+\r
+\r
+\r
+\r
+/*!\r
+       \brief Defines the maximum buffer size in which address, port, interface names are kept.\r
+\r
+       In case the adapter name or such is larger than this value, it is truncated.\r
+       This is not used by the user; however it must be aware that an hostname / interface\r
+       name longer than this value will be truncated.\r
+*/\r
+#define PCAP_BUF_SIZE 1024\r
+\r
+\r
+/*! \addtogroup remote_source_ID\r
+       \{\r
+*/\r
+\r
+\r
+/*!\r
+       \brief Internal representation of the type of source in use (file, \r
+       remote/local interface).\r
+\r
+       This indicates a file, i.e. the user want to open a capture from a local file.\r
+*/\r
+#define PCAP_SRC_FILE 2\r
+/*!\r
+       \brief Internal representation of the type of source in use (file, \r
+       remote/local interface).\r
+\r
+       This indicates a local interface, i.e. the user want to open a capture from \r
+       a local interface. This does not involve the RPCAP protocol.\r
+*/\r
+#define PCAP_SRC_IFLOCAL 3\r
+/*!\r
+       \brief Internal representation of the type of source in use (file, \r
+       remote/local interface).\r
+\r
+       This indicates a remote interface, i.e. the user want to open a capture from \r
+       an interface on a remote host. This does involve the RPCAP protocol.\r
+*/\r
+#define PCAP_SRC_IFREMOTE 4\r
+\r
+/*!\r
+       \}\r
+*/\r
+\r
+\r
+\r
+/*! \addtogroup remote_source_string\r
+\r
+       The formats allowed by the pcap_open() are the following:\r
+       - file://path_and_filename [opens a local file]\r
+       - rpcap://devicename [opens the selected device devices available on the local host, without using the RPCAP protocol]\r
+       - rpcap://host/devicename [opens the selected device available on a remote host]\r
+       - rpcap://host:port/devicename [opens the selected device available on a remote host, using a non-standard port for RPCAP]\r
+       - adaptername [to open a local adapter; kept for compability, but it is strongly discouraged]\r
+       - (NULL) [to open the first local adapter; kept for compability, but it is strongly discouraged]\r
+\r
+       The formats allowed by the pcap_findalldevs_ex() are the following:\r
+       - file://folder/ [lists all the files in the given folder]\r
+       - rpcap:// [lists all local adapters]\r
+       - rpcap://host:port/ [lists the devices available on a remote host]\r
+\r
+       Referring to the 'host' and 'port' paramters, they can be either numeric or literal. Since\r
+       IPv6 is fully supported, these are the allowed formats:\r
+\r
+       - host (literal): e.g. host.foo.bar\r
+       - host (numeric IPv4): e.g. 10.11.12.13\r
+       - host (numeric IPv4, IPv6 style): e.g. [10.11.12.13]\r
+       - host (numeric IPv6): e.g. [1:2:3::4]\r
+       - port: can be either numeric (e.g. '80') or literal (e.g. 'http')\r
+\r
+       Here you find some allowed examples:\r
+       - rpcap://host.foo.bar/devicename [everything literal, no port number]\r
+       - rpcap://host.foo.bar:1234/devicename [everything literal, with port number]\r
+       - rpcap://10.11.12.13/devicename [IPv4 numeric, no port number]\r
+       - rpcap://10.11.12.13:1234/devicename [IPv4 numeric, with port number]\r
+       - rpcap://[10.11.12.13]:1234/devicename [IPv4 numeric with IPv6 format, with port number]\r
+       - rpcap://[1:2:3::4]/devicename [IPv6 numeric, no port number]\r
+       - rpcap://[1:2:3::4]:1234/devicename [IPv6 numeric, with port number]\r
+       - rpcap://[1:2:3::4]:http/devicename [IPv6 numeric, with literal port number]\r
+       \r
+       \{\r
+*/\r
+\r
+\r
+/*!\r
+       \brief String that will be used to determine the type of source in use (file,\r
+       remote/local interface).\r
+\r
+       This string will be prepended to the interface name in order to create a string\r
+       that contains all the information required to open the source.\r
+\r
+       This string indicates that the user wants to open a capture from a local file.\r
+*/\r
+#define PCAP_SRC_FILE_STRING "file://"\r
+/*!\r
+       \brief String that will be used to determine the type of source in use (file,\r
+       remote/local interface).\r
+\r
+       This string will be prepended to the interface name in order to create a string\r
+       that contains all the information required to open the source.\r
+\r
+       This string indicates that the user wants to open a capture from a network interface.\r
+       This string does not necessarily involve the use of the RPCAP protocol. If the\r
+       interface required resides on the local host, the RPCAP protocol is not involved\r
+       and the local functions are used.\r
+*/\r
+#define PCAP_SRC_IF_STRING "rpcap://"\r
+\r
+/*!\r
+       \}\r
+*/\r
+\r
+\r
+\r
+\r
+\r
+/*!\r
+       \addtogroup remote_open_flags\r
+       \{\r
+*/\r
+\r
+/*!\r
+       \brief Defines if the adapter has to go in promiscuous mode.\r
+\r
+       It is '1' if you have to open the adapter in promiscuous mode, '0' otherwise.\r
+       Note that even if this parameter is false, the interface could well be in promiscuous\r
+       mode for some other reason (for example because another capture process with \r
+       promiscuous mode enabled is currently using that interface).\r
+       On on Linux systems with 2.2 or later kernels (that have the "any" device), this\r
+       flag does not work on the "any" device; if an argument of "any" is supplied,\r
+       the 'promisc' flag is ignored.\r
+*/\r
+#define PCAP_OPENFLAG_PROMISCUOUS              1\r
+\r
+/*!\r
+       \brief Defines if the data trasfer (in case of a remote\r
+       capture) has to be done with UDP protocol.\r
+\r
+       If it is '1' if you want a UDP data connection, '0' if you want\r
+       a TCP data connection; control connection is always TCP-based.\r
+       A UDP connection is much lighter, but it does not guarantee that all\r
+       the captured packets arrive to the client workstation. Moreover, \r
+       it could be harmful in case of network congestion.\r
+       This flag is meaningless if the source is not a remote interface.\r
+       In that case, it is simply ignored.\r
+*/\r
+#define PCAP_OPENFLAG_DATATX_UDP                       2\r
+\r
+\r
+/*!\r
+       \brief Defines if the remote probe will capture its own generated traffic.\r
+\r
+       In case the remote probe uses the same interface to capture traffic and to send\r
+       data back to the caller, the captured traffic includes the RPCAP traffic as well.\r
+       If this flag is turned on, the RPCAP traffic is excluded from the capture, so that\r
+       the trace returned back to the collector is does not include this traffic.\r
+*/\r
+#define PCAP_OPENFLAG_NOCAPTURE_RPCAP  4\r
+\r
+/*!\r
+       \brief Defines if the local adapter will capture its own generated traffic.\r
+\r
+       This flag tells the underlying capture driver to drop the packets that were sent by itself. \r
+       This is usefult when building applications like bridges, that should ignore the traffic\r
+       they just sent.\r
+*/\r
+#define PCAP_OPENFLAG_NOCAPTURE_LOCAL  8\r
+\r
+/*!\r
+       \brief This flag configures the adapter for maximum responsiveness.\r
+\r
+       In presence of a large value for nbytes, WinPcap waits for the arrival of several packets before \r
+       copying the data to the user. This guarantees a low number of system calls, i.e. lower processor usage, \r
+       i.e. better performance, which is good for applications like sniffers. If the user sets the \r
+       PCAP_OPENFLAG_MAX_RESPONSIVENESS flag, the capture driver will copy the packets as soon as the application \r
+       is ready to receive them. This is suggested for real time applications (like, for example, a bridge) \r
+       that need the best responsiveness.*/\r
+#define PCAP_OPENFLAG_MAX_RESPONSIVENESS       16\r
+\r
+/*!\r
+       \}\r
+*/\r
+\r
+\r
+/*!\r
+       \addtogroup remote_samp_methods\r
+       \{\r
+*/\r
+\r
+/*!\r
+       \brief No sampling has to be done on the current capture.\r
+\r
+       In this case, no sampling algorithms are applied to the current capture.\r
+*/\r
+#define PCAP_SAMP_NOSAMP       0\r
+\r
+/*!\r
+       \brief It defines that only 1 out of N packets must be returned to the user.\r
+\r
+       In this case, the 'value' field of the 'pcap_samp' structure indicates the\r
+       number of packets (minus 1) that must be discarded before one packet got accepted.\r
+       In other words, if 'value = 10', the first packet is returned to the caller, while\r
+       the following 9 are discarded.\r
+*/\r
+#define PCAP_SAMP_1_EVERY_N    1\r
+\r
+/*!\r
+       \brief It defines that we have to return 1 packet every N milliseconds.\r
+\r
+       In this case, the 'value' field of the 'pcap_samp' structure indicates the 'waiting\r
+       time' in milliseconds before one packet got accepted.\r
+       In other words, if 'value = 10', the first packet is returned to the caller; the next \r
+       returned one will be the first packet that arrives when 10ms have elapsed. \r
+*/\r
+#define PCAP_SAMP_FIRST_AFTER_N_MS 2\r
+\r
+/*!\r
+       \}\r
+*/\r
+\r
+\r
+/*!\r
+       \addtogroup remote_auth_methods\r
+       \{\r
+*/\r
+\r
+/*!\r
+       \brief It defines the NULL authentication.\r
+\r
+       This value has to be used within the 'type' member of the pcap_rmtauth structure.\r
+       The 'NULL' authentication has to be equal to 'zero', so that old applications\r
+       can just put every field of struct pcap_rmtauth to zero, and it does work.\r
+*/\r
+#define RPCAP_RMTAUTH_NULL 0\r
+/*!\r
+       \brief It defines the username/password authentication.\r
+\r
+       With this type of authentication, the RPCAP protocol will use the username/\r
+       password provided to authenticate the user on the remote machine. If the\r
+       authentication is successful (and the user has the right to open network devices)\r
+       the RPCAP connection will continue; otherwise it will be dropped.\r
+\r
+       This value has to be used within the 'type' member of the pcap_rmtauth structure.\r
+*/\r
+#define RPCAP_RMTAUTH_PWD 1\r
+\r
+/*!\r
+       \}\r
+*/\r
+\r
+\r
+\r
+\r
+/*!\r
+\r
+       \brief This structure keeps the information needed to autheticate\r
+       the user on a remote machine.\r
+       \r
+       The remote machine can either grant or refuse the access according \r
+       to the information provided.\r
+       In case the NULL authentication is required, both 'username' and\r
+       'password' can be NULL pointers.\r
+       \r
+       This structure is meaningless if the source is not a remote interface;\r
+       in that case, the functions which requires such a structure can accept\r
+       a NULL pointer as well.\r
+*/\r
+struct pcap_rmtauth\r
+{\r
+       /*!\r
+               \brief Type of the authentication required.\r
+\r
+               In order to provide maximum flexibility, we can support different types\r
+               of authentication based on the value of this 'type' variable. The currently \r
+               supported authentication methods are defined into the\r
+               \link remote_auth_methods Remote Authentication Methods Section\endlink.\r
+\r
+       */\r
+       int type;\r
+       /*!\r
+               \brief Zero-terminated string containing the username that has to be \r
+               used on the remote machine for authentication.\r
+               \r
+               This field is meaningless in case of the RPCAP_RMTAUTH_NULL authentication\r
+               and it can be NULL.\r
+       */\r
+       char *username;\r
+       /*!\r
+               \brief Zero-terminated string containing the password that has to be \r
+               used on the remote machine for authentication.\r
+               \r
+               This field is meaningless in case of the RPCAP_RMTAUTH_NULL authentication\r
+               and it can be NULL.\r
+       */\r
+       char *password;\r
+};\r
+\r
+\r
+/*!\r
+       \brief This structure defines the information related to sampling.\r
+\r
+       In case the sampling is requested, the capturing device should read\r
+       only a subset of the packets coming from the source. The returned packets depend\r
+       on the sampling parameters.\r
+\r
+       \warning The sampling process is applied <strong>after</strong> the filtering process.\r
+       In other words, packets are filtered first, then the sampling process selects a\r
+       subset of the 'filtered' packets and it returns them to the caller.\r
+*/\r
+struct pcap_samp\r
+{\r
+       /*!\r
+               Method used for sampling. Currently, the supported methods are listed in the\r
+               \link remote_samp_methods Sampling Methods Section\endlink.\r
+       */\r
+       int method;\r
+\r
+       /*!\r
+               This value depends on the sampling method defined. For its meaning, please check\r
+               at the \link remote_samp_methods Sampling Methods Section\endlink.\r
+       */\r
+       int value;\r
+};\r
+\r
+\r
+\r
+\r
+//! Maximum lenght of an host name (needed for the RPCAP active mode)\r
+#define RPCAP_HOSTLIST_SIZE 1024\r
+\r
+\r
+/*!\r
+       \}\r
+*/ // end of public documentation\r
+\r
+\r
+// Exported functions\r
+\r
+\r
+\r
+/** \name New WinPcap functions\r
+\r
+       This section lists the new functions that are able to help considerably in writing\r
+       WinPcap programs because of their easiness of use.\r
+ */\r
+//\{\r
+pcap_t *pcap_open(const char *source, int snaplen, int flags, int read_timeout, struct pcap_rmtauth *auth, char *errbuf);\r
+int pcap_createsrcstr(char *source, int type, const char *host, const char *port, const char *name, char *errbuf);\r
+int pcap_parsesrcstr(const char *source, int *type, char *host, char *port, char *name, char *errbuf);\r
+int pcap_findalldevs_ex(char *source, struct pcap_rmtauth *auth, pcap_if_t **alldevs, char *errbuf);\r
+struct pcap_samp *pcap_setsampling(pcap_t *p);\r
+\r
+//\}\r
+// End of new winpcap functions\r
+\r
+\r
+\r
+/** \name Remote Capture functions\r
+ */\r
+//\{ \r
+SOCKET pcap_remoteact_accept(const char *address, const char *port, const char *hostlist, char *connectinghost, struct pcap_rmtauth *auth, char *errbuf);\r
+int pcap_remoteact_list(char *hostlist, char sep, int size, char *errbuf);\r
+int pcap_remoteact_close(const char *host, char *errbuf);\r
+void pcap_remoteact_cleanup();\r
+//\}\r
+// End of remote capture functions\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+\r
+#endif\r
+\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/wpcap.lib b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/wpcap.lib
new file mode 100644 (file)
index 0000000..f832e04
Binary files /dev/null and b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/WinPCap/wpcap.lib differ
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/demo_logging.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/demo_logging.c
new file mode 100644 (file)
index 0000000..d6a1d25
--- /dev/null
@@ -0,0 +1,526 @@
+/*\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
+\r
+/*\r
+ * Logging utility that allows FreeRTOS tasks to log to a UDP port, stdout, and\r
+ * disk file without making any Win32 system calls themselves.\r
+ *\r
+ * Messages logged to a UDP port are sent directly (using FreeRTOS+TCP), but as\r
+ * FreeRTOS tasks cannot make Win32 system calls messages sent to stdout or a\r
+ * disk file are sent via a stream buffer to a Win32 thread which then performs\r
+ * the actual output.\r
+ */\r
+\r
+/* Standard includes. */\r
+#include <stdio.h>\r
+#include <stdint.h>\r
+#include <stdarg.h>\r
+#include <io.h>\r
+#include <ctype.h>\r
+\r
+/* FreeRTOS includes. */\r
+#include <FreeRTOS.h>\r
+#include "task.h"\r
+\r
+/* FreeRTOS+TCP includes. */\r
+#include "FreeRTOS_IP.h"\r
+#include "FreeRTOS_Sockets.h"\r
+#include "FreeRTOS_Stream_Buffer.h"\r
+\r
+/* Demo includes. */\r
+#include "demo_logging.h"\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+/* The maximum size to which the log file may grow, before being renamed\r
+to .ful. */\r
+#define dlLOGGING_FILE_SIZE            ( 40ul * 1024ul * 1024ul )\r
+\r
+/* Dimensions the arrays into which print messages are created. */\r
+#define dlMAX_PRINT_STRING_LENGTH      255\r
+\r
+/* The size of the stream buffer used to pass messages from FreeRTOS tasks to\r
+the Win32 thread that is responsible for making any Win32 system calls that are\r
+necessary for the selected logging method. */\r
+#define dlLOGGING_STREAM_BUFFER_SIZE  32768\r
+\r
+/* A block time of zero simply means don't block. */\r
+#define dlDONT_BLOCK   0\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Called from vLoggingInit() to start a new disk log file.\r
+ */\r
+static void prvFileLoggingInit( void );\r
+\r
+/*\r
+ * Attempt to write a message to the file.\r
+ */\r
+static void prvLogToFile( const char *pcMessage, size_t xLength );\r
+\r
+/*\r
+ * Simply close the logging file, if it is open.\r
+ */\r
+static void prvFileClose( void );\r
+\r
+/*\r
+ * Before the scheduler is started this function is called directly.  After the\r
+ * scheduler has started it is called from the Windows thread dedicated to\r
+ * outputting log messages.  Only the windows thread actually performs the\r
+ * writing so as not to disrupt the simulation by making Windows system calls\r
+ * from FreeRTOS tasks.\r
+ */\r
+static void prvLoggingFlushBuffer( void );\r
+\r
+/*\r
+ * The windows thread that performs the actual writing of messages that require\r
+ * Win32 system calls.  Only the windows thread can make system calls so as not\r
+ * to disrupt the simulation by making Windows calls from FreeRTOS tasks.\r
+ */\r
+static DWORD WINAPI prvWin32LoggingThread( void *pvParam );\r
+\r
+/*\r
+ * Creates the socket to which UDP messages are sent.  This function is not\r
+ * called directly to prevent the print socket being created from within the IP\r
+ * task - which could result in a deadlock.  Instead the function call is\r
+ * deferred to run in the RTOS daemon task - hence it prototype.\r
+ */\r
+static void prvCreatePrintSocket( void *pvParameter1, uint32_t ulParameter2 );\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+/* Windows event used to wake the Win32 thread which performs any logging that\r
+needs Win32 system calls. */\r
+static void *pvLoggingThreadEvent = NULL;\r
+\r
+/* Stores the selected logging targets passed in as parameters to the\r
+vLoggingInit() function. */\r
+BaseType_t xStdoutLoggingUsed = pdFALSE, xDiskFileLoggingUsed = pdFALSE, xUDPLoggingUsed = pdFALSE;\r
+\r
+/* Circular buffer used to pass messages from the FreeRTOS tasks to the Win32\r
+thread that is responsible for making Win32 calls (when stdout or a disk log is\r
+used). */\r
+static StreamBuffer_t *xLogStreamBuffer = NULL;\r
+\r
+/* Handle to the file used for logging.  This is left open while there are\r
+messages waiting to be logged, then closed again in between logs. */\r
+static FILE *pxLoggingFileHandle = NULL;\r
+\r
+/* When true prints are performed directly.  After start up xDirectPrint is set\r
+to pdFALSE - at which time prints that require Win32 system calls are done by\r
+the Win32 thread responsible for logging. */\r
+BaseType_t xDirectPrint = pdTRUE;\r
+\r
+/* File names for the in use and complete (full) log files. */\r
+static const char *pcLogFileName = "RTOSDemo.log";\r
+static const char *pcFullLogFileName = "RTOSDemo.ful";\r
+\r
+/* Keep the current file size in a variable, as an optimisation. */\r
+static size_t ulSizeOfLoggingFile = 0ul;\r
+\r
+/* The UDP socket and address on/to which print messages are sent. */\r
+Socket_t xPrintSocket = FREERTOS_INVALID_SOCKET;\r
+struct freertos_sockaddr xPrintUDPAddress;\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+void vLoggingInit( BaseType_t xLogToStdout, BaseType_t xLogToFile, BaseType_t xLogToUDP, uint32_t ulRemoteIPAddress, uint16_t usRemotePort )\r
+{\r
+       /* Can only be called before the scheduler has started. */\r
+       configASSERT( xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED );\r
+\r
+       #if( ( ipconfigHAS_DEBUG_PRINTF == 1 ) || ( ipconfigHAS_PRINTF == 1 ) )\r
+       {\r
+               HANDLE Win32Thread;\r
+\r
+               /* Record which output methods are to be used. */\r
+               xStdoutLoggingUsed = xLogToStdout;\r
+               xDiskFileLoggingUsed = xLogToFile;\r
+               xUDPLoggingUsed = xLogToUDP;\r
+\r
+               /* If a disk file is used then initialise it now. */\r
+               if( xDiskFileLoggingUsed != pdFALSE )\r
+               {\r
+                       prvFileLoggingInit();\r
+               }\r
+\r
+               /* If UDP logging is used then store the address to which the log data\r
+               will be sent - but don't create the socket yet because the network is\r
+               not initialised. */\r
+               if( xUDPLoggingUsed != pdFALSE )\r
+               {\r
+                       /* Set the address to which the print messages are sent. */\r
+                       xPrintUDPAddress.sin_port = FreeRTOS_htons( usRemotePort );\r
+                       xPrintUDPAddress.sin_addr = ulRemoteIPAddress;\r
+               }\r
+\r
+               /* If a disk file or stdout are to be used then Win32 system calls will\r
+               have to be made.  Such system calls cannot be made from FreeRTOS tasks\r
+               so create a stream buffer to pass the messages to a Win32 thread, then\r
+               create the thread itself, along with a Win32 event that can be used to\r
+               unblock the thread. */\r
+               if( ( xStdoutLoggingUsed != pdFALSE ) || ( xDiskFileLoggingUsed != pdFALSE ) )\r
+               {\r
+                       /* Create the buffer. */\r
+                       xLogStreamBuffer = ( StreamBuffer_t * ) malloc( sizeof( *xLogStreamBuffer ) - sizeof( xLogStreamBuffer->ucArray ) + dlLOGGING_STREAM_BUFFER_SIZE + 1 );\r
+                       configASSERT( xLogStreamBuffer );\r
+                       memset( xLogStreamBuffer, '\0', sizeof( *xLogStreamBuffer ) - sizeof( xLogStreamBuffer->ucArray ) );\r
+                       xLogStreamBuffer->LENGTH = dlLOGGING_STREAM_BUFFER_SIZE + 1;\r
+\r
+                       /* Create the Windows event. */\r
+                       pvLoggingThreadEvent = CreateEvent( NULL, FALSE, TRUE, "StdoutLoggingEvent" );\r
+\r
+                       /* Create the thread itself. */\r
+                       Win32Thread = CreateThread(\r
+                               NULL,   /* Pointer to thread security attributes. */\r
+                               0,              /* Initial thread stack size, in bytes. */\r
+                               prvWin32LoggingThread,  /* Pointer to thread function. */\r
+                               NULL,   /* Argument for new thread. */\r
+                               0,              /* Creation flags. */\r
+                               NULL );\r
+\r
+                       /* Use the cores that are not used by the FreeRTOS tasks. */\r
+                       SetThreadAffinityMask( Win32Thread, ~0x01u );\r
+                       SetThreadPriorityBoost( Win32Thread, TRUE );\r
+                       SetThreadPriority( Win32Thread, THREAD_PRIORITY_IDLE );\r
+               }\r
+       }\r
+       #else\r
+       {\r
+               /* FreeRTOSIPConfig is set such that no print messages will be output.\r
+               Avoid compiler warnings about unused parameters. */\r
+               ( void ) xLogToStdout;\r
+               ( void ) xLogToFile;\r
+               ( void ) xLogToUDP;\r
+               ( void ) usRemotePort;\r
+               ( void ) ulRemoteIPAddress;\r
+       }\r
+       #endif /* ( ipconfigHAS_DEBUG_PRINTF == 1 ) || ( ipconfigHAS_PRINTF == 1 )  */\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvCreatePrintSocket( void *pvParameter1, uint32_t ulParameter2 )\r
+{\r
+static const TickType_t xSendTimeOut = pdMS_TO_TICKS( 0 );\r
+Socket_t xSocket;\r
+\r
+       /* The function prototype is that of a deferred function, but the parameters\r
+       are not actually used. */\r
+       ( void ) pvParameter1;\r
+       ( void ) ulParameter2;\r
+\r
+       xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );\r
+\r
+       if( xSocket != FREERTOS_INVALID_SOCKET )\r
+       {\r
+               /* FreeRTOS+TCP decides which port to bind to. */\r
+               FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, &xSendTimeOut, sizeof( xSendTimeOut ) );\r
+               FreeRTOS_bind( xSocket, NULL, 0 );\r
+\r
+               /* Now the socket is bound it can be assigned to the print socket. */\r
+               xPrintSocket = xSocket;\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+void vLoggingPrintf( const char *pcFormat, ... )\r
+{\r
+char cPrintString[ dlMAX_PRINT_STRING_LENGTH ];\r
+char cOutputString[ dlMAX_PRINT_STRING_LENGTH ];\r
+char *pcSource, *pcTarget, *pcBegin;\r
+size_t xLength, xLength2, rc;\r
+static BaseType_t xMessageNumber = 0;\r
+va_list args;\r
+uint32_t ulIPAddress;\r
+const char *pcTaskName;\r
+const char *pcNoTask = "None";\r
+int iOriginalPriority;\r
+HANDLE xCurrentTask;\r
+\r
+\r
+       if( ( xStdoutLoggingUsed != pdFALSE ) || ( xDiskFileLoggingUsed != pdFALSE ) || ( xUDPLoggingUsed != pdFALSE ) )\r
+       {\r
+               /* There are a variable number of parameters. */\r
+               va_start( args, pcFormat );\r
+\r
+               /* Additional info to place at the start of the log. */\r
+               if( xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED )\r
+               {\r
+                       pcTaskName = pcTaskGetName( NULL );\r
+               }\r
+               else\r
+               {\r
+                       pcTaskName = pcNoTask;\r
+               }\r
+\r
+               if( strcmp( pcFormat, "\n" ) != 0 )\r
+               {\r
+                       xLength = snprintf( cPrintString, dlMAX_PRINT_STRING_LENGTH, "%lu %lu [%s] ",\r
+                               xMessageNumber++,\r
+                               ( unsigned long ) xTaskGetTickCount(),\r
+                               pcTaskName );\r
+               }\r
+               else\r
+               {\r
+                       xLength = 0;\r
+                       memset( cPrintString, 0x00, dlMAX_PRINT_STRING_LENGTH );\r
+               }\r
+\r
+               xLength2 = vsnprintf( cPrintString + xLength, dlMAX_PRINT_STRING_LENGTH - xLength, pcFormat, args );\r
+\r
+               if( xLength2 <  0 )\r
+               {\r
+                       /* Clean up. */\r
+                       xLength2 = dlMAX_PRINT_STRING_LENGTH - 1 - xLength;\r
+                       cPrintString[ dlMAX_PRINT_STRING_LENGTH - 1 ] = '\0';\r
+               }\r
+\r
+               xLength += xLength2;\r
+               va_end( args );\r
+\r
+               /* For ease of viewing, copy the string into another buffer, converting\r
+               IP addresses to dot notation on the way. */\r
+               pcSource = cPrintString;\r
+               pcTarget = cOutputString;\r
+\r
+               while( ( *pcSource ) != '\0' )\r
+               {\r
+                       *pcTarget = *pcSource;\r
+                       pcTarget++;\r
+                       pcSource++;\r
+\r
+                       /* Look forward for an IP address denoted by 'ip'. */\r
+                       if( ( isxdigit( pcSource[ 0 ] ) != pdFALSE ) && ( pcSource[ 1 ] == 'i' ) && ( pcSource[ 2 ] == 'p' ) )\r
+                       {\r
+                               *pcTarget = *pcSource;\r
+                               pcTarget++;\r
+                               *pcTarget = '\0';\r
+                               pcBegin = pcTarget - 8;\r
+\r
+                               while( ( pcTarget > pcBegin ) && ( isxdigit( pcTarget[ -1 ] ) != pdFALSE ) )\r
+                               {\r
+                                       pcTarget--;\r
+                               }\r
+\r
+                               sscanf( pcTarget, "%8X", &ulIPAddress );\r
+                               rc = sprintf( pcTarget, "%lu.%lu.%lu.%lu",\r
+                                       ( unsigned long ) ( ulIPAddress >> 24UL ),\r
+                                       ( unsigned long ) ( (ulIPAddress >> 16UL) & 0xffUL ),\r
+                                       ( unsigned long ) ( (ulIPAddress >> 8UL) & 0xffUL ),\r
+                                       ( unsigned long ) ( ulIPAddress & 0xffUL ) );\r
+                               pcTarget += rc;\r
+                               pcSource += 3; /* skip "<n>ip" */\r
+                       }\r
+               }\r
+\r
+               /* How far through the buffer was written? */\r
+               xLength = ( BaseType_t ) ( pcTarget - cOutputString );\r
+\r
+               /* If the message is to be logged to a UDP port then it can be sent directly\r
+               because it only uses FreeRTOS function (not Win32 functions). */\r
+               if( xUDPLoggingUsed != pdFALSE )\r
+               {\r
+                       if( ( xPrintSocket == FREERTOS_INVALID_SOCKET ) && ( FreeRTOS_IsNetworkUp() != pdFALSE ) )\r
+                       {\r
+                               /* Create and bind the socket to which print messages are sent.  The\r
+                               xTimerPendFunctionCall() function is used even though this is\r
+                               not an interrupt because this function is called from the IP task\r
+                               and the IP task cannot itself wait for a socket to bind.  The\r
+                               parameters to prvCreatePrintSocket() are not required so set to\r
+                               NULL or 0. */\r
+                               xTimerPendFunctionCall( prvCreatePrintSocket, NULL, 0, dlDONT_BLOCK );\r
+                       }\r
+\r
+                       if( xPrintSocket != FREERTOS_INVALID_SOCKET )\r
+                       {\r
+                               FreeRTOS_sendto( xPrintSocket, cOutputString, xLength, 0, &xPrintUDPAddress, sizeof( xPrintUDPAddress ) );\r
+\r
+                               /* Just because the UDP data logger I'm using is dumb. */\r
+                               FreeRTOS_sendto( xPrintSocket, "\r", sizeof( char ), 0, &xPrintUDPAddress, sizeof( xPrintUDPAddress ) );\r
+                       }\r
+               }\r
+\r
+               /* If logging is also to go to either stdout or a disk file then it cannot\r
+               be output here - so instead write the message to the stream buffer and wake\r
+               the Win32 thread which will read it from the stream buffer and perform the\r
+               actual output. */\r
+               if( ( xStdoutLoggingUsed != pdFALSE ) || ( xDiskFileLoggingUsed != pdFALSE ) )\r
+               {\r
+                       configASSERT( xLogStreamBuffer );\r
+\r
+                       /* How much space is in the buffer? */\r
+                       xLength2 = uxStreamBufferGetSpace( xLogStreamBuffer );\r
+\r
+                       /* There must be enough space to write both the string and the length of\r
+                       the string. */\r
+                       if( xLength2 >= ( xLength + sizeof( xLength ) ) )\r
+                       {\r
+                               /* First write in the length of the data, then write in the data\r
+                               itself.  Raising the thread priority is used as a critical section\r
+                               as there are potentially multiple writers.  The stream buffer is\r
+                               only thread safe when there is a single writer (likewise for\r
+                               reading from the buffer). */\r
+                               xCurrentTask = GetCurrentThread();\r
+                               iOriginalPriority = GetThreadPriority( xCurrentTask );\r
+                               SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL );\r
+                               uxStreamBufferAdd( xLogStreamBuffer, 0, ( const uint8_t * ) &( xLength ), sizeof( xLength ) );\r
+                               uxStreamBufferAdd( xLogStreamBuffer, 0, ( const uint8_t * ) cOutputString, xLength );\r
+                               SetThreadPriority( GetCurrentThread(), iOriginalPriority );\r
+                       }\r
+\r
+                       /* xDirectPrint is initialised to pdTRUE, and while it remains true the\r
+                       logging output function is called directly.  When the system is running\r
+                       the output function cannot be called directly because it would get\r
+                       called from both FreeRTOS tasks and Win32 threads - so instead wake the\r
+                       Win32 thread responsible for the actual output. */\r
+                       if( xDirectPrint != pdFALSE )\r
+                       {\r
+                               /* While starting up, the thread which calls prvWin32LoggingThread()\r
+                               is not running yet and xDirectPrint will be pdTRUE. */\r
+                               prvLoggingFlushBuffer();\r
+                       }\r
+                       else if( pvLoggingThreadEvent != NULL )\r
+                       {\r
+                               /* While running, wake up prvWin32LoggingThread() to send the\r
+                               logging data. */\r
+                               SetEvent( pvLoggingThreadEvent );\r
+                       }\r
+               }\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvLoggingFlushBuffer( void )\r
+{\r
+size_t xLength;\r
+char cPrintString[ dlMAX_PRINT_STRING_LENGTH ];\r
+\r
+       /* Is there more than the length value stored in the circular buffer\r
+       used to pass data from the FreeRTOS simulator into this Win32 thread? */\r
+       while( uxStreamBufferGetSize( xLogStreamBuffer ) > sizeof( xLength ) )\r
+       {\r
+               memset( cPrintString, 0x00, dlMAX_PRINT_STRING_LENGTH );\r
+               uxStreamBufferGet( xLogStreamBuffer, 0, ( uint8_t * ) &xLength, sizeof( xLength ), pdFALSE );\r
+               uxStreamBufferGet( xLogStreamBuffer, 0, ( uint8_t * ) cPrintString, xLength, pdFALSE );\r
+\r
+               /* Write the message to standard out if requested to do so when\r
+               vLoggingInit() was called, or if the network is not yet up. */\r
+               if( ( xStdoutLoggingUsed != pdFALSE ) || ( FreeRTOS_IsNetworkUp() == pdFALSE ) )\r
+               {\r
+                       /* Write the message to stdout. */\r
+                       printf( "%s", cPrintString ); /*_RB_ Replace with _write(). */\r
+               }\r
+\r
+               /* Write the message to a file if requested to do so when\r
+               vLoggingInit() was called. */\r
+               if( xDiskFileLoggingUsed != pdFALSE )\r
+               {\r
+                       prvLogToFile( cPrintString, xLength );\r
+               }\r
+       }\r
+\r
+       prvFileClose();\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static DWORD WINAPI prvWin32LoggingThread( void *pvParameter )\r
+{\r
+const DWORD xMaxWait = 1000;\r
+\r
+       ( void ) pvParameter;\r
+\r
+       /* From now on, prvLoggingFlushBuffer() will only be called from this\r
+       Windows thread */\r
+       xDirectPrint = pdFALSE;\r
+\r
+       for( ;; )\r
+       {\r
+               /* Wait to be told there are message waiting to be logged. */\r
+               WaitForSingleObject( pvLoggingThreadEvent, xMaxWait );\r
+\r
+               /* Write out all waiting messages. */\r
+               prvLoggingFlushBuffer();\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvFileLoggingInit( void )\r
+{\r
+FILE *pxHandle = fopen( pcLogFileName, "a" );\r
+\r
+       if( pxHandle != NULL )\r
+       {\r
+               fseek( pxHandle, SEEK_END, 0ul );\r
+               ulSizeOfLoggingFile = ftell( pxHandle );\r
+               fclose( pxHandle );\r
+       }\r
+       else\r
+       {\r
+               ulSizeOfLoggingFile = 0ul;\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvFileClose( void )\r
+{\r
+       if( pxLoggingFileHandle != NULL )\r
+       {\r
+               fclose( pxLoggingFileHandle );\r
+               pxLoggingFileHandle = NULL;\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvLogToFile( const char *pcMessage, size_t xLength )\r
+{\r
+       if( pxLoggingFileHandle == NULL )\r
+       {\r
+               pxLoggingFileHandle = fopen( pcLogFileName, "a" );\r
+       }\r
+\r
+       if( pxLoggingFileHandle != NULL )\r
+       {\r
+               fwrite( pcMessage, 1, xLength, pxLoggingFileHandle );\r
+               ulSizeOfLoggingFile += xLength;\r
+\r
+               /* If the file has grown to its maximum permissible size then close and\r
+               rename it - then start with a new file. */\r
+               if( ulSizeOfLoggingFile > ( size_t ) dlLOGGING_FILE_SIZE )\r
+               {\r
+                       prvFileClose();\r
+                       if( _access( pcFullLogFileName, 00 ) == 0 )\r
+                       {\r
+                               remove( pcFullLogFileName );\r
+                       }\r
+                       rename( pcLogFileName, pcFullLogFileName );\r
+                       ulSizeOfLoggingFile = 0;\r
+               }\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/demo_logging.h b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/demo_logging.h
new file mode 100644 (file)
index 0000000..62ae46a
--- /dev/null
@@ -0,0 +1,48 @@
+/*\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
+\r
+#ifndef DEMO_LOGGING_H\r
+#define DEMO_LOGGING_H\r
+\r
+/*\r
+ * Initialise a logging system that can be used from FreeRTOS tasks and Win32\r
+ * threads.  Do not call printf() directly while the scheduler is running.\r
+ *\r
+ * Set xLogToStdout, xLogToFile and xLogToUDP to either pdTRUE or pdFALSE to\r
+ * lot to stdout, a disk file and a UDP port respectively.\r
+ *\r
+ * If xLogToUDP is pdTRUE then ulRemoteIPAddress and usRemotePort must be set\r
+ * to the IP address and port number to which UDP log messages will be sent.\r
+ */\r
+void vLoggingInit(     BaseType_t xLogToStdout,\r
+                                       BaseType_t xLogToFile,\r
+                                       BaseType_t xLogToUDP,\r
+                                       uint32_t ulRemoteIPAddress,\r
+                                       uint16_t usRemotePort );\r
+\r
+#endif /* DEMO_LOGGING_H */\r
+\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/main.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/main.c
new file mode 100644 (file)
index 0000000..fa52947
--- /dev/null
@@ -0,0 +1,361 @@
+/*\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
+\r
+/*\r
+ * This project is a cut down version of the project described on the following\r
+ * link.  Only the simple UDP client and server and the TCP echo clients are\r
+ * included in the build:\r
+ * http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html\r
+ */\r
+\r
+/* Standard includes. */\r
+#include <stdio.h>\r
+#include <time.h>\r
+\r
+/* FreeRTOS includes. */\r
+#include <FreeRTOS.h>\r
+#include "task.h"\r
+\r
+/* Demo application includes. */\r
+#include "FreeRTOS_IP.h"\r
+#include "FreeRTOS_Sockets.h"\r
+#include "SimpleUDPClientAndServer.h"\r
+#include "demo_logging.h"\r
+\r
+/* Simple UDP client and server task parameters. */\r
+#define mainSIMPLE_UDP_CLIENT_SERVER_TASK_PRIORITY             ( tskIDLE_PRIORITY )\r
+#define mainSIMPLE_UDP_CLIENT_SERVER_PORT                              ( 5005UL )\r
+\r
+/* Define a name that will be used for LLMNR and NBNS searches. */\r
+#define mainHOST_NAME                          "RTOSDemo"\r
+#define mainDEVICE_NICK_NAME           "windows_demo"\r
+\r
+/* Set the following constants to 1 or 0 to define which tasks to include and\r
+exclude:\r
+\r
+mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS:  When set to 1 two UDP client tasks\r
+and two UDP server tasks are created.  The clients talk to the servers.  One set\r
+of tasks use the standard sockets interface, and the other the zero copy sockets\r
+interface.  These tasks are self checking and will trigger a configASSERT() if\r
+they detect a difference in the data that is received from that which was sent.\r
+As these tasks use UDP, and can therefore loose packets, they will cause\r
+configASSERT() to be called when they are run in a less than perfect networking\r
+environment.\r
+\r
+mainCREATE_TCP_ECHO_TASKS_SINGLE:  When set to 1 a set of tasks are created that\r
+send TCP echo requests to the standard echo port (port 7), then wait for and\r
+verify the echo reply, from within the same task (Tx and Rx are performed in the\r
+same RTOS task).  The IP address of the echo server must be configured using the\r
+configECHO_SERVER_ADDR0 to configECHO_SERVER_ADDR3 constants in\r
+FreeRTOSConfig.h.\r
+\r
+mainCREATE_TCP_ECHO_SERVER_TASK:  When set to 1 a task is created that accepts\r
+connections on the standard echo port (port 7), then echos back any data\r
+received on that connection.\r
+*/\r
+#define mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS      1\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Just seeds the simple pseudo random number generator.\r
+ */\r
+static void prvSRand( UBaseType_t ulSeed );\r
+\r
+/*\r
+ * Miscellaneous initialisation including preparing the logging and seeding the\r
+ * random number generator.\r
+ */\r
+static void prvMiscInitialisation( void );\r
+\r
+/* The default IP and MAC address used by the demo.  The address configuration\r
+defined here will be used if ipconfigUSE_DHCP is 0, or if ipconfigUSE_DHCP is\r
+1 but a DHCP server could not be contacted.  See the online documentation for\r
+more information. */\r
+static const uint8_t ucIPAddress[ 4 ] = { configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 };\r
+static const uint8_t ucNetMask[ 4 ] = { configNET_MASK0, configNET_MASK1, configNET_MASK2, configNET_MASK3 };\r
+static const uint8_t ucGatewayAddress[ 4 ] = { configGATEWAY_ADDR0, configGATEWAY_ADDR1, configGATEWAY_ADDR2, configGATEWAY_ADDR3 };\r
+static const uint8_t ucDNSServerAddress[ 4 ] = { configDNS_SERVER_ADDR0, configDNS_SERVER_ADDR1, configDNS_SERVER_ADDR2, configDNS_SERVER_ADDR3 };\r
+\r
+/* Set the following constant to pdTRUE to log using the method indicated by the\r
+name of the constant, or pdFALSE to not log using the method indicated by the\r
+name of the constant.  Options include to standard out (xLogToStdout), to a disk\r
+file (xLogToFile), and to a UDP port (xLogToUDP).  If xLogToUDP is set to pdTRUE\r
+then UDP messages are sent to the IP address configured as the echo server\r
+address (see the configECHO_SERVER_ADDR0 definitions in FreeRTOSConfig.h) and\r
+the port number set by configPRINT_PORT in FreeRTOSConfig.h. */\r
+const BaseType_t xLogToStdout = pdTRUE, xLogToFile = pdFALSE, xLogToUDP = pdFALSE;\r
+\r
+/* Default MAC address configuration.  The demo creates a virtual network\r
+connection that uses this MAC address by accessing the raw Ethernet data\r
+to and from a real network connection on the host PC.  See the\r
+configNETWORK_INTERFACE_TO_USE definition for information on how to configure\r
+the real network connection to use. */\r
+const uint8_t ucMACAddress[ 6 ] = { configMAC_ADDR0, configMAC_ADDR1, configMAC_ADDR2, configMAC_ADDR3, configMAC_ADDR4, configMAC_ADDR5 };\r
+\r
+/* Use by the pseudo random number generator. */\r
+static UBaseType_t ulNextRand;\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+int main( void )\r
+{\r
+const uint32_t ulLongTime_ms = pdMS_TO_TICKS( 1000UL );\r
+\r
+       /*\r
+        * Instructions for using this project are provided on:\r
+        * http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html\r
+        */\r
+\r
+       /* Miscellaneous initialisation including preparing the logging and seeding\r
+       the random number generator. */\r
+       prvMiscInitialisation();\r
+\r
+       /* Initialise the network interface.\r
+\r
+       ***NOTE*** Tasks that use the network are created in the network event hook\r
+       when the network is connected and ready for use (see the definition of\r
+       vApplicationIPNetworkEventHook() below).  The address values passed in here\r
+       are used if ipconfigUSE_DHCP is set to 0, or if ipconfigUSE_DHCP is set to 1\r
+       but a DHCP server cannot be     contacted. */\r
+       FreeRTOS_debug_printf( ( "FreeRTOS_IPInit\n" ) );\r
+       FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );\r
+\r
+       /* Start the RTOS scheduler. */\r
+       FreeRTOS_debug_printf( ("vTaskStartScheduler\n") );\r
+       vTaskStartScheduler();\r
+\r
+       /* If all is well, the scheduler will now be running, and the following\r
+       line will never be reached.  If the following line does execute, then\r
+       there was insufficient FreeRTOS heap memory available for the idle and/or\r
+       timer tasks     to be created.  See the memory management section on the\r
+       FreeRTOS web site for more details (this is standard text that is not not\r
+       really applicable to the Win32 simulator port). */\r
+       for( ;; )\r
+       {\r
+               Sleep( ulLongTime_ms );\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+void vApplicationIdleHook( void )\r
+{\r
+const uint32_t ulMSToSleep = 1;\r
+\r
+       /* This is just a trivial example of an idle hook.  It is called on each\r
+       cycle of the idle task if configUSE_IDLE_HOOK is set to 1 in\r
+       FreeRTOSConfig.h.  It must *NOT* attempt to block.  In this case the\r
+       idle task just sleeps to lower the CPU usage. */\r
+       Sleep( ulMSToSleep );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+void vAssertCalled( const char *pcFile, uint32_t ulLine )\r
+{\r
+const uint32_t ulLongSleep = 1000UL;\r
+volatile uint32_t ulBlockVariable = 0UL;\r
+volatile char *pcFileName = ( volatile char *  ) pcFile;\r
+volatile uint32_t ulLineNumber = ulLine;\r
+\r
+       ( void ) pcFileName;\r
+       ( void ) ulLineNumber;\r
+\r
+       FreeRTOS_debug_printf( ( "vAssertCalled( %s, %ld\n", pcFile, ulLine ) );\r
+\r
+       /* Setting ulBlockVariable to a non-zero value in the debugger will allow\r
+       this function to be exited. */\r
+       taskDISABLE_INTERRUPTS();\r
+       {\r
+               while( ulBlockVariable == 0UL )\r
+               {\r
+                       Sleep( ulLongSleep );\r
+               }\r
+       }\r
+       taskENABLE_INTERRUPTS();\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/* Called by FreeRTOS+TCP when the network connects or disconnects.  Disconnect\r
+events are only received if implemented in the MAC driver. */\r
+void vApplicationIPNetworkEventHook( eIPCallbackEvent_t eNetworkEvent )\r
+{\r
+uint32_t ulIPAddress, ulNetMask, ulGatewayAddress, ulDNSServerAddress;\r
+char cBuffer[ 16 ];\r
+static BaseType_t xTasksAlreadyCreated = pdFALSE;\r
+\r
+       /* If the network has just come up...*/\r
+       if( eNetworkEvent == eNetworkUp )\r
+       {\r
+               /* Create the tasks that use the IP stack if they have not already been\r
+               created. */\r
+               if( xTasksAlreadyCreated == pdFALSE )\r
+               {\r
+                       /* See the comments above the definitions of these pre-processor\r
+                       macros at the top of this file for a description of the individual\r
+                       demo tasks. */\r
+                       #if( mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS == 1 )\r
+                       {\r
+                               vStartSimpleUDPClientServerTasks( configMINIMAL_STACK_SIZE, mainSIMPLE_UDP_CLIENT_SERVER_PORT, mainSIMPLE_UDP_CLIENT_SERVER_TASK_PRIORITY );\r
+                       }\r
+                       #endif /* mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS */\r
+\r
+                       #if( mainCREATE_TCP_ECHO_TASKS_SINGLE == 1 )\r
+                       {\r
+                               vStartTCPEchoClientTasks_SingleTasks( mainECHO_CLIENT_TASK_STACK_SIZE, mainECHO_CLIENT_TASK_PRIORITY );\r
+                       }\r
+                       #endif /* mainCREATE_TCP_ECHO_TASKS_SINGLE */\r
+\r
+                       #if( mainCREATE_TCP_ECHO_SERVER_TASK == 1 )\r
+                       {\r
+                               vStartSimpleTCPServerTasks( mainECHO_SERVER_TASK_STACK_SIZE, mainECHO_SERVER_TASK_PRIORITY );\r
+                       }\r
+                       #endif\r
+\r
+                       xTasksAlreadyCreated = pdTRUE;\r
+               }\r
+\r
+               /* Print out the network configuration, which may have come from a DHCP\r
+               server. */\r
+               FreeRTOS_GetAddressConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress );\r
+               FreeRTOS_inet_ntoa( ulIPAddress, cBuffer );\r
+               FreeRTOS_printf( ( "\r\n\r\nIP Address: %s\r\n", cBuffer ) );\r
+\r
+               FreeRTOS_inet_ntoa( ulNetMask, cBuffer );\r
+               FreeRTOS_printf( ( "Subnet Mask: %s\r\n", cBuffer ) );\r
+\r
+               FreeRTOS_inet_ntoa( ulGatewayAddress, cBuffer );\r
+               FreeRTOS_printf( ( "Gateway Address: %s\r\n", cBuffer ) );\r
+\r
+               FreeRTOS_inet_ntoa( ulDNSServerAddress, cBuffer );\r
+               FreeRTOS_printf( ( "DNS Server Address: %s\r\n\r\n\r\n", cBuffer ) );\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+void vApplicationMallocFailedHook( void )\r
+{\r
+       /* Called if a call to pvPortMalloc() fails because there is insufficient\r
+       free memory available in the FreeRTOS heap.  pvPortMalloc() is called\r
+       internally by FreeRTOS API functions that create tasks, queues, software\r
+       timers, and semaphores.  The size of the FreeRTOS heap is set by the\r
+       configTOTAL_HEAP_SIZE configuration constant in FreeRTOSConfig.h. */\r
+       vAssertCalled( __FILE__, __LINE__ );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+UBaseType_t uxRand( void )\r
+{\r
+const uint32_t ulMultiplier = 0x015a4e35UL, ulIncrement = 1UL;\r
+\r
+       /* Utility function to generate a pseudo random number. */\r
+\r
+       ulNextRand = ( ulMultiplier * ulNextRand ) + ulIncrement;\r
+       return( ( int ) ( ulNextRand >> 16UL ) & 0x7fffUL );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvSRand( UBaseType_t ulSeed )\r
+{\r
+       /* Utility function to seed the pseudo random number generator. */\r
+    ulNextRand = ulSeed;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvMiscInitialisation( void )\r
+{\r
+time_t xTimeNow;\r
+uint32_t ulLoggingIPAddress;\r
+\r
+       ulLoggingIPAddress = FreeRTOS_inet_addr_quick( configECHO_SERVER_ADDR0, configECHO_SERVER_ADDR1, configECHO_SERVER_ADDR2, configECHO_SERVER_ADDR3 );\r
+       vLoggingInit( xLogToStdout, xLogToFile, xLogToUDP, ulLoggingIPAddress, configPRINT_PORT );\r
+\r
+       /* Seed the random number generator. */\r
+       time( &xTimeNow );\r
+       FreeRTOS_debug_printf( ( "Seed for randomiser: %lu\n", xTimeNow ) );\r
+       prvSRand( ( uint32_t ) xTimeNow );\r
+       FreeRTOS_debug_printf( ( "Random numbers: %08X %08X %08X %08X\n", ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32() ) );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+#if( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 ) || ( ipconfigDHCP_REGISTER_HOSTNAME == 1 )\r
+\r
+       const char *pcApplicationHostnameHook( void )\r
+       {\r
+               /* Assign the name "FreeRTOS" to this network node.  This function will\r
+               be called during the DHCP: the machine will be registered with an IP\r
+               address plus this name. */\r
+               return mainHOST_NAME;\r
+       }\r
+\r
+#endif\r
+/*-----------------------------------------------------------*/\r
+\r
+#if( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 )\r
+\r
+       BaseType_t xApplicationDNSQueryHook( const char *pcName )\r
+       {\r
+       BaseType_t xReturn;\r
+\r
+               /* Determine if a name lookup is for this node.  Two names are given\r
+               to this node: that returned by pcApplicationHostnameHook() and that set\r
+               by mainDEVICE_NICK_NAME. */\r
+               if( _stricmp( pcName, pcApplicationHostnameHook() ) == 0 )\r
+               {\r
+                       xReturn = pdPASS;\r
+               }\r
+               else if( _stricmp( pcName, mainDEVICE_NICK_NAME ) == 0 )\r
+               {\r
+                       xReturn = pdPASS;\r
+               }\r
+               else\r
+               {\r
+                       xReturn = pdFAIL;\r
+               }\r
+\r
+               return xReturn;\r
+       }\r
+\r
+#endif\r
+\r
+/*\r
+ * Callback that provides the inputs necessary to generate a randomized TCP\r
+ * Initial Sequence Number per RFC 6528.  THIS IS ONLY A DUMMY IMPLEMENTATION\r
+ * THAT RETURNS A PSEUDO RANDOM NUMBER SO IS NOT INTENDED FOR USE IN PRODUCTION\r
+ * SYSTEMS.\r
+ */\r
+extern uint32_t ulApplicationGetNextSequenceNumber( uint32_t ulSourceAddress,\r
+                                                                                                       uint16_t usSourcePort,\r
+                                                                                                       uint32_t ulDestinationAddress,\r
+                                                                                                       uint16_t usDestinationPort )\r
+{\r
+       ( void ) ulSourceAddress;\r
+       ( void ) usSourcePort;\r
+       ( void ) ulDestinationAddress;\r
+       ( void ) usDestinationPort;\r
+\r
+       return uxRand();\r
+}\r
+\r
diff --git a/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/printf-stdarg.c b/FreeRTOS-Plus/Demo/FreeRTOS_Plus_IoT_SDK/task_pool/printf-stdarg.c
new file mode 100644 (file)
index 0000000..5505535
--- /dev/null
@@ -0,0 +1,667 @@
+/*\r
+       Copyright 2001, 2002 Georges Menie (www.menie.org)\r
+       stdarg version contributed by Christian Ettinger\r
+\r
+       This program is free software; you can redistribute it and/or modify\r
+       it under the terms of the GNU Lesser General Public License as published by\r
+       the Free Software Foundation; either version 2 of the License, or\r
+       (at your option) any later version.\r
+\r
+       Changes for the FreeRTOS ports:\r
+\r
+       - The dot in "%-8.8s"\r
+       - The specifiers 'l' (long) and 'L' (long long)\r
+       - The specifier 'u' for unsigned\r
+       - Dot notation for IP addresses:\r
+         sprintf("IP = %xip\n", 0xC0A80164);\r
+      will produce "IP = 192.168.1.100\n"\r
+*/\r
+\r
+#include <stdarg.h>\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+\r
+#include "FreeRTOS.h"\r
+\r
+#define PAD_RIGHT 1\r
+#define PAD_ZERO 2\r
+\r
+/*\r
+ * Return 1 for readable, 2 for writeable, 3 for both.\r
+ * Function must be provided by the application.\r
+ */\r
+extern BaseType_t xApplicationMemoryPermissions( uint32_t aAddress );\r
+\r
+extern void vOutputChar( const char cChar, const TickType_t xTicksToWait  );\r
+static const TickType_t xTicksToWait = pdMS_TO_TICKS( 20 );\r
+\r
+struct xPrintFlags\r
+{\r
+       int base;\r
+       int width;\r
+       int printLimit;\r
+       unsigned\r
+               pad : 8,\r
+               letBase : 8,\r
+               isSigned : 1,\r
+               isNumber : 1,\r
+               long32 : 1,\r
+               long64 : 1;\r
+};\r
+\r
+struct SStringBuf\r
+{\r
+       char *str;\r
+       const char *orgStr;\r
+       const char *nulPos;\r
+       int curLen;\r
+       struct xPrintFlags flags;\r
+};\r
+\r
+static void strbuf_init( struct SStringBuf *apStr, char *apBuf, const char *apMaxStr )\r
+{\r
+       apStr->str = apBuf;\r
+       apStr->orgStr = apBuf;\r
+       apStr->nulPos = apMaxStr-1;\r
+       apStr->curLen = 0;\r
+\r
+       memset( &apStr->flags, '\0', sizeof( apStr->flags ) );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static BaseType_t strbuf_printchar( struct SStringBuf *apStr, int c )\r
+{\r
+       if( apStr->str == NULL )\r
+       {\r
+               vOutputChar( ( char ) c, xTicksToWait );\r
+               apStr->curLen++;\r
+               return pdTRUE;\r
+       }\r
+       if( apStr->str < apStr->nulPos )\r
+       {\r
+               *( apStr->str++ ) = c;\r
+               apStr->curLen++;\r
+               return pdTRUE;\r
+       }\r
+       if( apStr->str == apStr->nulPos )\r
+       {\r
+               *( apStr->str++ ) = '\0';\r
+       }\r
+       return pdFALSE;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static portINLINE BaseType_t strbuf_printchar_inline( struct SStringBuf *apStr, int c )\r
+{\r
+       if( apStr->str == NULL )\r
+       {\r
+               vOutputChar( ( char ) c, xTicksToWait );\r
+               if( c == 0 )\r
+               {\r
+                       return pdFALSE;\r
+               }\r
+               apStr->curLen++;\r
+               return pdTRUE;\r
+       }\r
+       if( apStr->str < apStr->nulPos )\r
+       {\r
+               *(apStr->str++) = c;\r
+               if( c == 0 )\r
+               {\r
+                       return pdFALSE;\r
+               }\r
+               apStr->curLen++;\r
+               return pdTRUE;\r
+       }\r
+       if( apStr->str == apStr->nulPos )\r
+       {\r
+               *( apStr->str++ ) = '\0';\r
+       }\r
+       return pdFALSE;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static portINLINE int i2hex( int aCh )\r
+{\r
+int iResult;\r
+\r
+       if( aCh < 10 )\r
+       {\r
+               iResult = '0' + aCh;\r
+       }\r
+       else\r
+       {\r
+               iResult = 'A' + aCh - 10;\r
+       }\r
+\r
+       return iResult;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static BaseType_t prints(struct SStringBuf *apBuf, const char *apString )\r
+{\r
+       register int padchar = ' ';\r
+       int i,len;\r
+\r
+       if( xApplicationMemoryPermissions( ( uint32_t )apString ) == 0 )\r
+       {\r
+               /* The user has probably made a mistake with the parameter\r
+               for '%s', the memory is not readbale. */\r
+               apString = "INV_MEM";\r
+       }\r
+\r
+       if( apBuf->flags.width > 0 )\r
+       {\r
+               register int len = 0;\r
+               register const char *ptr;\r
+               for( ptr = apString; *ptr; ++ptr )\r
+               {\r
+                       ++len;\r
+               }\r
+\r
+               if( len >= apBuf->flags.width )\r
+               {\r
+                       apBuf->flags.width = 0;\r
+               }\r
+               else\r
+               {\r
+                       apBuf->flags.width -= len;\r
+               }\r
+\r
+               if( apBuf->flags.pad & PAD_ZERO )\r
+               {\r
+                       padchar = '0';\r
+               }\r
+       }\r
+       if( ( apBuf->flags.pad & PAD_RIGHT ) == 0 )\r
+       {\r
+               for( ; apBuf->flags.width > 0; --apBuf->flags.width )\r
+               {\r
+                       if( strbuf_printchar( apBuf, padchar ) == 0 )\r
+                       {\r
+                               return pdFALSE;\r
+                       }\r
+               }\r
+       }\r
+       if( ( apBuf->flags.isNumber == pdTRUE ) && ( apBuf->flags.pad == pdTRUE ) )\r
+       {\r
+               /* The string to print represents an integer number.\r
+                * In this case, printLimit is the min number of digits to print\r
+                * If the length of the number to print is less than the min nb of i\r
+                * digits to display, we add 0 before printing the number\r
+                */\r
+               len = strlen( apString );\r
+\r
+               if( len < apBuf->flags.printLimit )\r
+               {\r
+                       i = apBuf->flags.printLimit - len;\r
+                       for( ; i; i-- )\r
+                       {\r
+                               if( strbuf_printchar( apBuf, '0' )  == 0 )\r
+                               {\r
+                                       return pdFALSE;\r
+                               }\r
+                       }\r
+               }\r
+       }\r
+       /* The string to print is not the result of a number conversion to ascii.\r
+        * For a string, printLimit is the max number of characters to display\r
+        */\r
+       for( ; apBuf->flags.printLimit && *apString ; ++apString, --apBuf->flags.printLimit )\r
+       {\r
+               if( !strbuf_printchar( apBuf, *apString ) )\r
+               {\r
+                       return pdFALSE;\r
+               }\r
+       }\r
+\r
+       for( ; apBuf->flags.width > 0; --apBuf->flags.width )\r
+       {\r
+               if( !strbuf_printchar( apBuf, padchar ) )\r
+               {\r
+                       return pdFALSE;\r
+               }\r
+       }\r
+\r
+       return pdTRUE;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/* the following should be enough for 32 bit int */\r
+#define PRINT_BUF_LEN 12       /* to print 4294967296 */\r
+\r
+#if    SPRINTF_LONG_LONG\r
+#warning 64-bit libraries will be included as well\r
+static BaseType_t printll( struct SStringBuf *apBuf, long long i )\r
+{\r
+       char print_buf[ 2 * PRINT_BUF_LEN ];\r
+       register char *s;\r
+       register int t, neg = 0;\r
+       register unsigned long long u = i;\r
+       lldiv_t lldiv_result;\r
+\r
+/* typedef struct\r
+ * {\r
+ *     long long int quot; // quotient\r
+ *     long long int rem;  // remainder\r
+ * } lldiv_t;\r
+ */\r
+\r
+       apBuf->flags.isNumber = pdTRUE; /* Parameter for prints */\r
+       if( i == 0LL )\r
+       {\r
+               print_buf[ 0 ] = '0';\r
+               print_buf[ 1 ] = '\0';\r
+               return prints( apBuf, print_buf );\r
+       }\r
+\r
+       if( ( apBuf->flags.isSigned == pdTRUE ) && ( apBuf->flags.base == 10 ) && ( i < 0LL ) )\r
+       {\r
+               neg = 1;\r
+               u = -i;\r
+       }\r
+\r
+       s = print_buf + sizeof( print_buf ) - 1;\r
+\r
+       *s = '\0';\r
+       /* 18446744073709551616 */\r
+       while( u != 0 )\r
+       {\r
+               lldiv_result = lldiv( u, ( unsigned long long ) apBuf->flags.base );\r
+               t = lldiv_result.rem;\r
+               if( t >= 10 )\r
+               {\r
+                       t += apBuf->flags.letBase - '0' - 10;\r
+               }\r
+               *( --s ) = t + '0';\r
+               u = lldiv_result.quot;\r
+       }\r
+\r
+       if( neg != 0 )\r
+       {\r
+               if( ( apBuf->flags.width != 0 ) && ( apBuf->flags.pad & PAD_ZERO ) )\r
+               {\r
+                       if( !strbuf_printchar( apBuf, '-' ) )\r
+                       {\r
+                               return pdFALSE;\r
+                       }\r
+                       --apBuf->flags.width;\r
+               }\r
+               else\r
+               {\r
+                       *( --s ) = '-';\r
+               }\r
+       }\r
+\r
+       return prints( apBuf, s );\r
+}\r
+#endif /* SPRINTF_LONG_LONG */\r
+/*-----------------------------------------------------------*/\r
+\r
+static BaseType_t printi( struct SStringBuf *apBuf, int i )\r
+{\r
+       char print_buf[ PRINT_BUF_LEN ];\r
+       register char *s;\r
+       register int t, neg = 0;\r
+       register unsigned int u = i;\r
+       register unsigned base = apBuf->flags.base;\r
+\r
+       apBuf->flags.isNumber = pdTRUE; /* Parameter for prints */\r
+\r
+       if( i == 0 )\r
+       {\r
+               print_buf[ 0 ] = '0';\r
+               print_buf[ 1 ] = '\0';\r
+               return prints( apBuf, print_buf );\r
+       }\r
+\r
+       if( ( apBuf->flags.isSigned == pdTRUE ) && ( base == 10 ) && ( i < 0 ) )\r
+       {\r
+               neg = 1;\r
+               u = -i;\r
+       }\r
+\r
+       s = print_buf + sizeof( print_buf ) - 1;\r
+\r
+       *s = '\0';\r
+       switch( base )\r
+       {\r
+       case 16:\r
+               while( u != 0 )\r
+               {\r
+                       t = u & 0xF;\r
+                       if( t >= 10 )\r
+                       {\r
+                               t += apBuf->flags.letBase - '0' - 10;\r
+                       }\r
+                       *( --s ) = t + '0';\r
+                       u >>= 4;\r
+               }\r
+               break;\r
+\r
+       case 8:\r
+       case 10:\r
+               /* GCC compiles very efficient */\r
+               while( u )\r
+               {\r
+                       t = u % base;\r
+                       *( --s ) = t + '0';\r
+                       u /= base;\r
+               }\r
+               break;\r
+/*\r
+       // The generic case, not yet in use\r
+       default:\r
+               while( u )\r
+               {\r
+                       t = u % base;\r
+                       if( t >= 10)\r
+                       {\r
+                               t += apBuf->flags.letBase - '0' - 10;\r
+                       }\r
+                       *( --s ) = t + '0';\r
+                       u /= base;\r
+               }\r
+               break;\r
+*/\r
+       }\r
+\r
+       if( neg != 0 )\r
+       {\r
+               if( apBuf->flags.width && (apBuf->flags.pad & PAD_ZERO ) )\r
+               {\r
+                       if( strbuf_printchar( apBuf, '-' ) == 0 )\r
+                       {\r
+                               return pdFALSE;\r
+                       }\r
+                       --apBuf->flags.width;\r
+               }\r
+               else\r
+               {\r
+                       *( --s ) = '-';\r
+               }\r
+       }\r
+\r
+       return prints( apBuf, s );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static BaseType_t printIp(struct SStringBuf *apBuf, unsigned i )\r
+{\r
+       char print_buf[16];\r
+\r
+       sprintf( print_buf, "%u.%u.%u.%u",\r
+               i >> 24,\r
+               ( i >> 16 ) & 0xff,\r
+               ( i >> 8 ) & 0xff,\r
+               i & 0xff );\r
+       apBuf->flags.isNumber = pdTRUE; /* Parameter for prints */\r
+       prints( apBuf, print_buf );\r
+\r
+       return pdTRUE;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void tiny_print( struct SStringBuf *apBuf, const char *format, va_list args )\r
+{\r
+       char scr[2];\r
+\r
+       for( ; ; )\r
+       {\r
+               int ch = *( format++ );\r
+\r
+               if( ch != '%' )\r
+               {\r
+                       do\r
+                       {\r
+                               /* Put the most like flow in a small loop */\r
+                               if( strbuf_printchar_inline( apBuf, ch ) == 0 )\r
+                               {\r
+                                       return;\r
+                               }\r
+                               ch = *( format++ );\r
+                       } while( ch != '%' );\r
+               }\r
+               ch = *( format++ );\r
+               /* Now ch has character after '%', format pointing to next */\r
+\r
+               if( ch == '\0' )\r
+               {\r
+                       break;\r
+               }\r
+               if( ch == '%' )\r
+               {\r
+                       if( strbuf_printchar( apBuf, ch ) == 0 )\r
+                       {\r
+                               return;\r
+                       }\r
+                       continue;\r
+               }\r
+               memset( &apBuf->flags, '\0', sizeof( apBuf->flags ) );\r
+\r
+               if( ch == '-' )\r
+               {\r
+                       ch = *( format++ );\r
+                       apBuf->flags.pad = PAD_RIGHT;\r
+               }\r
+               while( ch == '0' )\r
+               {\r
+                       ch = *( format++ );\r
+                       apBuf->flags.pad |= PAD_ZERO;\r
+               }\r
+               if( ch == '*' )\r
+               {\r
+                       ch = *( format++ );\r
+                       apBuf->flags.width = va_arg( args, int );\r
+               }\r
+               else\r
+               {\r
+                       while( ch >= '0' && ch <= '9' )\r
+                       {\r
+                               apBuf->flags.width *= 10;\r
+                               apBuf->flags.width += ch - '0';\r
+                               ch = *( format++ );\r
+                       }\r
+               }\r
+               if( ch == '.' )\r
+               {\r
+                       ch = *( format++ );\r
+                       if( ch == '*' )\r
+                       {\r
+                               apBuf->flags.printLimit = va_arg( args, int );\r
+                               ch = *( format++ );\r
+                       }\r
+                       else\r
+                       {\r
+                               while( ch >= '0' && ch <= '9' )\r
+                               {\r
+                                       apBuf->flags.printLimit *= 10;\r
+                                       apBuf->flags.printLimit += ch - '0';\r
+                                       ch = *( format++ );\r
+                               }\r
+                       }\r
+               }\r
+               if( apBuf->flags.printLimit == 0 )\r
+               {\r
+                       apBuf->flags.printLimit--;  /* -1: make it unlimited */\r
+               }\r
+               if( ch == 's' )\r
+               {\r
+                       register char *s = ( char * )va_arg( args, int );\r
+                       if( prints( apBuf, s ? s : "(null)" ) == 0 )\r
+                       {\r
+                               break;\r
+                       }\r
+                       continue;\r
+               }\r
+               if( ch == 'c' )\r
+               {\r
+                       /* char are converted to int then pushed on the stack */\r
+                       scr[0] = ( char ) va_arg( args, int );\r
+\r
+                       if( strbuf_printchar( apBuf, scr[0] )  == 0 )\r
+                       {\r
+                               return;\r
+                       }\r
+\r
+                       continue;\r
+               }\r
+               if( ch == 'l' )\r
+               {\r
+                       ch = *( format++ );\r
+                       apBuf->flags.long32 = 1;\r
+                       /* Makes not difference as u32 == long */\r
+               }\r
+               if( ch == 'L' )\r
+               {\r
+                       ch = *( format++ );\r
+                       apBuf->flags.long64 = 1;\r
+                       /* Does make a difference */\r
+               }\r
+               apBuf->flags.base = 10;\r
+               apBuf->flags.letBase = 'a';\r
+\r
+               if( ch == 'd' || ch == 'u' )\r
+               {\r
+                       apBuf->flags.isSigned = ( ch == 'd' );\r
+#if    SPRINTF_LONG_LONG\r
+                       if( apBuf->flags.long64 != pdFALSE )\r
+                       {\r
+                               if( printll( apBuf, va_arg( args, long long ) ) == 0 )\r
+                               {\r
+                                       break;\r
+                               }\r
+                       } else\r
+#endif /* SPRINTF_LONG_LONG */\r
+                       if( printi( apBuf, va_arg( args, int ) ) == 0 )\r
+                       {\r
+                               break;\r
+                       }\r
+                       continue;\r
+               }\r
+\r
+               apBuf->flags.base = 16;         /* From here all hexadecimal */\r
+\r
+               if( ch == 'x' && format[0] == 'i' && format[1] == 'p' )\r
+               {\r
+                       format += 2;    /* eat the "xi" of "xip" */\r
+                       /* Will use base 10 again */\r
+                       if( printIp( apBuf, va_arg( args, int ) ) == 0 )\r
+                       {\r
+                               break;\r
+                       }\r
+                       continue;\r
+               }\r
+               if( ch == 'x' || ch == 'X' || ch == 'p' || ch == 'o' )\r
+               {\r
+                       if( ch == 'X' )\r
+                       {\r
+                               apBuf->flags.letBase = 'A';\r
+                       }\r
+                       else if( ch == 'o' )\r
+                       {\r
+                               apBuf->flags.base = 8;\r
+                       }\r
+#if    SPRINTF_LONG_LONG\r
+                       if( apBuf->flags.long64 != pdFALSE )\r
+                       {\r
+                               if( printll( apBuf, va_arg( args, long long ) ) == 0 )\r
+                               {\r
+                                       break;\r
+                               }\r
+                       } else\r
+#endif /* SPRINTF_LONG_LONG */\r
+                       if( printi( apBuf, va_arg( args, int ) ) == 0 )\r
+                       {\r
+                               break;\r
+                       }\r
+                       continue;\r
+               }\r
+       }\r
+       strbuf_printchar( apBuf, '\0' );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+int vsnprintf( char *apBuf, size_t aMaxLen, const char *apFmt, va_list args )\r
+{\r
+       struct SStringBuf strBuf;\r
+       strbuf_init( &strBuf, apBuf, ( const char* )apBuf + aMaxLen );\r
+       tiny_print( &strBuf, apFmt, args );\r
+\r
+       return strBuf.curLen;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+int snprintf( char *apBuf, size_t aMaxLen, const char *apFmt, ... )\r
+{\r
+       va_list args;\r
+\r
+       va_start( args,  apFmt );\r
+       struct SStringBuf strBuf;\r
+       strbuf_init( &strBuf, apBuf, ( const char* )apBuf + aMaxLen );\r
+       tiny_print( &strBuf, apFmt, args );\r
+       va_end( args );\r
+\r
+       return strBuf.curLen;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+int sprintf( char *apBuf, const char *apFmt, ... )\r
+{\r
+       va_list args;\r
+\r
+       va_start( args,  apFmt );\r
+       struct SStringBuf strBuf;\r
+       strbuf_init( &strBuf, apBuf, ( const char * )apBuf + 1024 );\r
+       tiny_print( &strBuf, apFmt, args );\r
+       va_end( args );\r
+\r
+       return strBuf.curLen;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+int vsprintf( char *apBuf, const char *apFmt, va_list args )\r
+{\r
+       struct SStringBuf strBuf;\r
+       strbuf_init( &strBuf, apBuf, ( const char* ) apBuf + 1024 );\r
+       tiny_print( &strBuf, apFmt, args );\r
+\r
+       return strBuf.curLen;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+const char *mkSize (unsigned long long aSize, char *apBuf, int aLen)\r
+{\r
+static char retString[33];\r
+size_t gb, mb, kb, sb;\r
+\r
+       if (apBuf == NULL) {\r
+               apBuf = retString;\r
+               aLen = sizeof( retString );\r
+       }\r
+       gb = aSize / (1024*1024*1024);\r
+       aSize -= gb * (1024*1024*1024);\r
+       mb = aSize / (1024*1024);\r
+       aSize -= mb * (1024*1024);\r
+       kb = aSize / (1024);\r
+       aSize -= kb * (1024);\r
+       sb = aSize;\r
+       if( gb )\r
+       {\r
+               snprintf (apBuf, aLen, "%u.%02u GB", ( unsigned ) gb, ( unsigned ) ( ( 100 * mb ) / 1024ul ) );\r
+       }\r
+       else if( mb )\r
+       {\r
+               snprintf (apBuf, aLen, "%u.%02u MB", ( unsigned ) mb, ( unsigned ) ( ( 100 * kb) / 1024ul ) );\r
+       }\r
+       else if( kb != 0ul )\r
+       {\r
+               snprintf (apBuf, aLen, "%u.%02u KB", ( unsigned ) kb, ( unsigned ) ( ( 100 * sb) / 1024ul ) );\r
+       }\r
+       else\r
+       {\r
+               snprintf (apBuf, aLen, "%u bytes", ( unsigned ) sb);\r
+       }\r
+       return apBuf;\r
+}\r