Bring in a minimum subset of the IoT SDK - at this time just a subset of the library dependencies rather than the libraries themselves.

FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/c_sdk/standard/common/include/iot_atomic.h

@@ -0,0 +1,39 @@
+/*
+ * Amazon FreeRTOS Common V1.0.0
+ * Copyright (C) 2018 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://aws.amazon.com/freertos
+ * http://www.FreeRTOS.org
+ */
+
+/**
+ * @file iot_atomic.h
+ * @brief Chooses the appropriate atomic operations header.
+ *
+ * On FreeRTOS, this file chooses the atomic header provided with the FreeRTOS
+ * kernel.
+ */
+
+#ifndef IOT_ATOMIC_H_
+#define IOT_ATOMIC_H_
+
+#include "atomic.h"
+
+#endif /* ifndef IOT_ATOMIC_H_ */

FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/c_sdk/standard/common/include/iot_init.h

@@ -0,0 +1,67 @@
+/*
+ * Amazon FreeRTOS Common V1.0.0
+ * Copyright (C) 2018 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://aws.amazon.com/freertos
+ * http://www.FreeRTOS.org
+ */
+
+/**
+ * @file iot_init.h
+ * @brief Provides function signatures for common intialization and cleanup of
+ * this SDK.
+ */
+
+#ifndef IOT_INIT_H_
+#define IOT_INIT_H_
+
+/* The config header is always included first. */
+#include "iot_config.h"
+
+/* Standard includes. */
+#include <stdbool.h>
+
+/**
+ * @brief One-time initialization function for this SDK.
+ *
+ * This function initializes common libraries, such as static memory and task
+ * pool. <b>It must be called once (and only once) before calling any other
+ * function in this SDK.</b> Calling this function more than once without first
+ * calling `IotSdk_Cleanup` may result in a crash.
+ *
+ * @return `true` if initialization succeeded; `false` otherwise. Logs may be
+ * printed in case of failure.
+ *
+ * @warning No thread-safety guarantees are provided for this function.
+ */
+bool IotSdk_Init( void );
+
+/**
+ * @brief One-time deinitialization function for all common libraries.
+ *
+ * This function frees resources taken in `IotSdk_Init`. No other function
+ * in this SDK may be called after calling this function unless `IotSdk_Init`
+ * is called again.
+ *
+ * @warning No thread-safety guarantees are provided for this function.
+ */
+void IotSdk_Cleanup( void );
+
+#endif /* IOT_INIT_H_ */

FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/c_sdk/standard/common/include/iot_logging_setup.h

@@ -0,0 +1,223 @@
+/*
+ * Amazon FreeRTOS Common V1.0.0
+ * Copyright (C) 2018 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://aws.amazon.com/freertos
+ * http://www.FreeRTOS.org
+ */
+
+/**
+ * @file iot_logging_setup.h
+ * @brief Defines the logging macro #IotLog.
+ */
+
+#ifndef IOT_LOGGING_SETUP_H_
+#define IOT_LOGGING_SETUP_H_
+
+/* The config header is always included first. */
+#include "iot_config.h"
+
+/* Logging include. Because it's included here, iot_logging.h never needs
+ * to be included in source. */
+#include "private/iot_logging.h"
+
+/**
+ * @functionpage{IotLog,logging,log}
+ * @functionpage{IotLog_PrintBuffer,logging,printbuffer}
+ */
+
+/**
+ * @def IotLog( messageLevel, pLogConfig, ... )
+ * @brief Logging function for a specific library. In most cases, this is the
+ * logging function to call.
+ *
+ * This function prints a single log message. It is available when @ref
+ * LIBRARY_LOG_LEVEL is not #IOT_LOG_NONE. Log messages automatically
+ * include the [log level](@ref logging_constants_levels), [library name]
+ * (@ref LIBRARY_LOG_NAME), and time. An optional @ref IotLogConfig_t may
+ * be passed to this function to hide information for a single log message.
+ *
+ * The logging library must be set up before this function may be called. See
+ * @ref logging_setup_use for more information.
+ *
+ * This logging function also has the following abbreviated forms that can be used
+ * when an #IotLogConfig_t isn't needed.
+ *
+ * Name         | Equivalent to
+ * ----         | -------------
+ * #IotLogError | @code{c} IotLog( IOT_LOG_ERROR, NULL, ... ) @endcode
+ * #IotLogWarn  | @code{c} IotLog( IOT_LOG_WARN, NULL, ... ) @endcode
+ * #IotLogInfo  | @code{c} IotLog( IOT_LOG_INFO, NULL, ... ) @endcode
+ * #IotLogDebug | @code{c} IotLog( IOT_LOG_DEBUG, NULL, ... ) @endcode
+ *
+ * @param[in] messageLevel Log level of this message. Must be one of the
+ * @ref logging_constants_levels.
+ * @param[in] pLogConfig Pointer to an #IotLogConfig_t. Optional; pass `NULL`
+ * to ignore.
+ * @param[in] ... Message and format specification.
+ *
+ * @return No return value. On errors, it prints nothing.
+ *
+ * @note This function may be implemented as a macro.
+ * @see @ref logging_function_generic for the generic (not library-specific)
+ * logging function.
+ */
+
+/**
+ * @def IotLog_PrintBuffer( pHeader, pBuffer, bufferSize )
+ * @brief Log the contents of buffer as bytes. Only available when @ref
+ * LIBRARY_LOG_LEVEL is #IOT_LOG_DEBUG.
+ *
+ * This function prints the bytes located at a given memory address. It is
+ * intended for debugging only, and is therefore only available when @ref
+ * LIBRARY_LOG_LEVEL is #IOT_LOG_DEBUG.
+ *
+ * Log messages printed by this function <b>always</b> include the [log level]
+ * (@ref logging_constants_levels), [library name](@ref LIBRARY_LOG_NAME),
+ * and time.  In addition, this function may print an optional header `pHeader`
+ * before it prints the contents of the buffer. This function does not have an
+ * #IotLogConfig_t parameter.
+ *
+ * The logging library must be set up before this function may be called. See
+ * @ref logging_setup_use for more information.
+ *
+ * @param[in] pHeader A message to log before the buffer. Optional; pass `NULL`
+ * to ignore.
+ * @param[in] pBuffer Pointer to start of buffer.
+ * @param[in] bufferSize Size of `pBuffer`.
+ *
+ * @return No return value. On errors, it prints nothing.
+ *
+ * @note This function may be implemented as a macro.
+ * @note To conserve memory, @ref logging_function_genericprintbuffer (the underlying
+ * implementation) only allocates enough memory for a single line of output. Therefore,
+ * in multithreaded systems, its output may appear "fragmented" if other threads are
+ * logging simultaneously.
+ * @see @ref logging_function_genericprintbuffer for the generic (not library-specific)
+ * buffer logging function.
+ *
+ * <b>Example</b>
+ * @code{c}
+ * const uint8_t pBuffer[] = { 0x00, 0x01, 0x02, 0x03 };
+ *
+ * IotLog_PrintBuffer( "This buffer contains:",
+ *                     pBuffer,
+ *                     4 );
+ * @endcode
+ * The code above prints something like the following:
+ * @code{c}
+ * [DEBUG][LIB_NAME][2018-01-01 12:00:00] This buffer contains:
+ * 00 01 02 03
+ * @endcode
+ */
+
+/**
+ * @def IotLogError( ...  )
+ * @brief Abbreviated logging macro for level #IOT_LOG_ERROR.
+ *
+ * Equivalent to:
+ * @code{c}
+ * IotLog( IOT_LOG_ERROR, NULL, ... )
+ * @endcode
+ */
+
+/**
+ * @def IotLogWarn( ...  )
+ * @brief Abbreviated logging macro for level #IOT_LOG_WARN.
+ *
+ * Equivalent to:
+ * @code{c}
+ * IotLog( IOT_LOG_WARN, NULL, ... )
+ * @endcode
+ */
+
+/**
+ * @def IotLogInfo( ...  )
+ * @brief Abbreviated logging macro for level #IOT_LOG_INFO.
+ *
+ * Equivalent to:
+ * @code{c}
+ * IotLog( IOT_LOG_INFO, NULL, ... )
+ * @endcode
+ */
+
+/**
+ * @def IotLogDebug( ...  )
+ * @brief Abbreviated logging macro for level #IOT_LOG_DEBUG.
+ *
+ * Equivalent to:
+ * @code{c}
+ * IotLog( IOT_LOG_DEBUG, NULL, ... )
+ * @endcode
+ */
+
+/* Check that LIBRARY_LOG_LEVEL is defined and has a valid value. */
+#if !defined( LIBRARY_LOG_LEVEL ) ||            \
+    ( LIBRARY_LOG_LEVEL != IOT_LOG_NONE &&  \
+      LIBRARY_LOG_LEVEL != IOT_LOG_ERROR && \
+      LIBRARY_LOG_LEVEL != IOT_LOG_WARN &&  \
+      LIBRARY_LOG_LEVEL != IOT_LOG_INFO &&  \
+      LIBRARY_LOG_LEVEL != IOT_LOG_DEBUG )
+    #error "Please define LIBRARY_LOG_LEVEL as either IOT_LOG_NONE, IOT_LOG_ERROR, IOT_LOG_WARN, IOT_LOG_INFO, or IOT_LOG_DEBUG."
+/* Check that LIBRARY_LOG_NAME is defined and has a valid value. */
+#elif !defined( LIBRARY_LOG_NAME )
+    #error "Please define LIBRARY_LOG_NAME."
+#else
+    /* Define IotLog if the log level is greater than "none". */
+    #if LIBRARY_LOG_LEVEL > IOT_LOG_NONE
+        #define IotLog( messageLevel, pLogConfig, ... )   \
+                IotLog_Generic( LIBRARY_LOG_LEVEL,        \
+                                LIBRARY_LOG_NAME,        \
+                                messageLevel,             \
+                                pLogConfig,               \
+                                __VA_ARGS__ )
+
+        /* Define the abbreviated logging macros. */
+        #define IotLogError( ...  )    IotLog( IOT_LOG_ERROR, NULL, __VA_ARGS__ )
+        #define IotLogWarn( ... )      IotLog( IOT_LOG_WARN, NULL, __VA_ARGS__ )
+        #define IotLogInfo( ... )      IotLog( IOT_LOG_INFO, NULL, __VA_ARGS__ )
+        #define IotLogDebug( ... )     IotLog( IOT_LOG_DEBUG, NULL, __VA_ARGS__ )
+
+        /* If log level is DEBUG, enable the function to print buffers. */
+        #if LIBRARY_LOG_LEVEL >= IOT_LOG_DEBUG
+        #define IotLog_PrintBuffer( pHeader, pBuffer, bufferSize )    \
+                IotLog_GenericPrintBuffer( LIBRARY_LOG_NAME,         \
+                                           pHeader,                   \
+                                           pBuffer,                   \
+                                           bufferSize )
+        #else
+        #define IotLog_PrintBuffer( pHeader, pBuffer, bufferSize )
+        #endif
+    /* Remove references to IotLog from the source code if logging is disabled. */
+    #else
+        /* @[declare_logging_log] */
+        #define IotLog( messageLevel, pLogConfig, ... )
+        /* @[declare_logging_log] */
+        /* @[declare_logging_printbuffer] */
+        #define IotLog_PrintBuffer( pHeader, pBuffer, bufferSize )
+        /* @[declare_logging_printbuffer] */
+        #define IotLogError( ...  )
+        #define IotLogWarn( ... )
+        #define IotLogInfo( ... )
+        #define IotLogDebug( ... )
+    #endif
+#endif
+
+#endif /* ifndef IOT_LOGGING_SETUP_H_ */

FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/c_sdk/standard/common/include/private/iot_error.h

@@ -0,0 +1,117 @@
+/*
+ * Amazon FreeRTOS Common V1.0.0
+ * Copyright (C) 2018 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://aws.amazon.com/freertos
+ * http://www.FreeRTOS.org
+ */
+
+/**
+ * @file iot_error.h
+ * @brief Provides macros for error checking and function cleanup.
+ *
+ * The macros in this file are generic. They may be customized by each library
+ * by setting the library prefix.
+ */
+
+#ifndef IOT_ERROR_H_
+#define IOT_ERROR_H_
+
+/* The config header is always included first. */
+#include "iot_config.h"
+
+/**
+ * @brief Declare the status variable and an initial value.
+ *
+ * This macro should be at the beginning of any functions that use cleanup sections.
+ *
+ * @param[in] statusType The type of the status variable for this function.
+ * @param[in] initialValue The initial value to assign to the status variable.
+ */
+#define IOT_FUNCTION_ENTRY( statusType, initialValue )    statusType status = initialValue
+
+/**
+ * @brief Declares the label that begins a cleanup section.
+ *
+ * This macro should be placed at the end of a function and followed by
+ * #IOT_FUNCTION_CLEANUP_END.
+ */
+#define IOT_FUNCTION_CLEANUP_BEGIN()                      iotCleanup:
+
+/**
+ * @brief Declares the end of a cleanup section.
+ *
+ * This macro should be placed at the end of a function and preceded by
+ * #IOT_FUNCTION_CLEANUP_BEGIN.
+ */
+#define IOT_FUNCTION_CLEANUP_END()                        return status
+
+/**
+ * @brief Declares an empty cleanup section.
+ *
+ * This macro should be placed at the end of a function to exit on error if no
+ * cleanup is required.
+ */
+#define IOT_FUNCTION_EXIT_NO_CLEANUP()                    IOT_FUNCTION_CLEANUP_BEGIN(); IOT_FUNCTION_CLEANUP_END()
+
+/**
+ * @brief Jump to the cleanup section.
+ */
+#define IOT_GOTO_CLEANUP()                                goto iotCleanup
+
+/**
+ * @brief Assign a value to the status variable and jump to the cleanup section.
+ *
+ * @param[in] statusValue The value to assign to the status variable.
+ */
+#define IOT_SET_AND_GOTO_CLEANUP( statusValue )           { status = ( statusValue ); IOT_GOTO_CLEANUP(); }
+
+/**
+ * @brief Jump to the cleanup section if a condition is `false`.
+ *
+ * This macro may be used in place of `assert` to exit a function is a condition
+ * is `false`.
+ *
+ * @param[in] condition The condition to check.
+ */
+#define IOT_GOTO_CLEANUP_IF_FALSE( condition )            { if( ( condition ) == false ) { IOT_GOTO_CLEANUP(); } }
+
+/**
+ * @brief Assign a value to the status variable and jump to the cleanup section
+ * if a condition is `false`.
+ *
+ * @param[in] statusValue The value to assign to the status variable.
+ * @param[in] condition The condition to check.
+ */
+#define IOT_SET_AND_GOTO_CLEANUP_IF_FALSE( statusValue, condition ) \
+    if( ( condition ) == false )                                    \
+        IOT_SET_AND_GOTO_CLEANUP( statusValue )
+
+/**
+ * @brief Check a condition; if `false`, assign the "Bad parameter" status value
+ * and jump to the cleanup section.
+ *
+ * @param[in] libraryPrefix The library prefix of the status variable.
+ * @param[in] condition The condition to check.
+ */
+#define IOT_VALIDATE_PARAMETER( libraryPrefix, condition ) \
+    IOT_SET_AND_GOTO_CLEANUP_IF_FALSE( libraryPrefix ## _BAD_PARAMETER, condition )
+
+#endif /* ifndef IOT_ERROR_H_ */

FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/c_sdk/standard/common/include/private/iot_logging.h

@@ -0,0 +1,229 @@
+/*
+ * Amazon FreeRTOS Common V1.0.0
+ * Copyright (C) 2018 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://aws.amazon.com/freertos
+ * http://www.FreeRTOS.org
+ */
+
+/**
+ * @file iot_logging.h
+ * @brief Generic logging function header file.
+ *
+ * Declares the generic logging function and the log levels. This file never
+ * needs to be included in source code. The header iot_logging_setup.h should
+ * be included instead.
+ *
+ * @see iot_logging_setup.h
+ */
+
+#ifndef IOT_LOGGING_H_
+#define IOT_LOGGING_H_
+
+/* The config header is always included first. */
+#include "iot_config.h"
+
+/* Standard includes. */
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * @constantspage{logging,logging library}
+ *
+ * @section logging_constants_levels Log levels
+ * @brief Log levels for the libraries in this SDK.
+ *
+ * Each library should specify a log level by setting @ref LIBRARY_LOG_LEVEL.
+ * All log messages with a level at or below the specified level will be printed
+ * for that library.
+ *
+ * Currently, there are 4 log levels. In the order of lowest to highest, they are:
+ * - #IOT_LOG_NONE <br>
+ *   @copybrief IOT_LOG_NONE
+ * - #IOT_LOG_ERROR <br>
+ *   @copybrief IOT_LOG_ERROR
+ * - #IOT_LOG_WARN <br>
+ *   @copybrief IOT_LOG_WARN
+ * - #IOT_LOG_INFO <br>
+ *   @copybrief IOT_LOG_INFO
+ * - #IOT_LOG_DEBUG <br>
+ *   @copybrief IOT_LOG_DEBUG
+ */
+
+/**
+ * @brief No log messages.
+ *
+ * Log messages with this level will be silently discarded. When @ref
+ * LIBRARY_LOG_LEVEL is #IOT_LOG_NONE, logging is disabled and no [logging functions]
+ * (@ref logging_functions) can be called.
+ */
+#define IOT_LOG_NONE     0
+
+/**
+ * @brief Only critical, unrecoverable errors.
+ *
+ * Log messages with this level will be printed when a library encounters an
+ * error from which it cannot easily recover.
+ */
+#define IOT_LOG_ERROR    1
+
+/**
+ * @brief Message about an abnormal but recoverable event.
+ *
+ * Log messages with this level will be printed when a library encounters an
+ * abnormal event that may be indicative of an error. Libraries should continue
+ * execution after logging a warning.
+ */
+#define IOT_LOG_WARN     2
+
+/**
+ * @brief A helpful, informational message.
+ *
+ * Log messages with this level may indicate the normal status of a library
+ * function. They should be used to track how far a program has executed.
+ */
+#define IOT_LOG_INFO     3
+
+/**
+ * @brief Detailed and excessive debug information.
+ *
+ * Log messages with this level are intended for developers. They may contain
+ * excessive information such as internal variables, buffers, or other specific
+ * information.
+ */
+#define IOT_LOG_DEBUG    4
+
+/**
+ * @paramstructs{logging,logging}
+ */
+
+/**
+ * @ingroup logging_datatypes_paramstructs
+ * @brief Log message configuration struct.
+ *
+ * @paramfor @ref logging_function_log, @ref logging_function_generic
+ *
+ * By default, log messages print the library name, log level, and a timestring.
+ * This struct can be passed to @ref logging_function_generic to disable one of
+ * the above components in the log message.
+ *
+ * <b>Example:</b>
+ *
+ * @code{c}
+ * IotLog_Generic( IOT_LOG_DEBUG, "SAMPLE", IOT_LOG_DEBUG, NULL, "Hello world!" );
+ * @endcode
+ * The code above prints the following message:
+ * @code
+ * [DEBUG][SAMPLE][2018-01-01 12:00:00] Hello world!
+ * @endcode
+ *
+ * The timestring can be disabled as follows:
+ * @code
+ * IotLogConfig_t logConfig = { .hideLogLevel = false, .hideLibraryName = false, .hideTimestring = true};
+ * IotLog_Generic( IOT_LOG_DEBUG, "SAMPLE", IOT_LOG_DEBUG, &logConfig, "Hello world!" );
+ * @endcode
+ * The resulting log message will be:
+ * @code
+ * [DEBUG][SAMPLE] Hello world!
+ * @endcode
+ */
+typedef struct IotLogConfig
+{
+    bool hideLogLevel;    /**< @brief Don't print the log level string for this message. */
+    bool hideLibraryName; /**< @brief Don't print the library name for this message. */
+    bool hideTimestring;  /**< @brief Don't print the timestring for this message. */
+} IotLogConfig_t;
+
+/**
+ * @functionspage{logging,logging library}
+ *
+ * - @functionname{logging_function_log}
+ * - @functionname{logging_function_printbuffer}
+ * - @functionname{logging_function_generic}
+ * - @functionname{logging_function_genericprintbuffer}
+ */
+
+/**
+ * @functionpage{IotLog_Generic,logging,generic}
+ * @functionpage{IotLog_PrintBuffer,logging,genericprintbuffer}
+ */
+
+/**
+ * @brief Generic logging function that prints a single message.
+ *
+ * This function is the generic logging function shared across all libraries.
+ * The library-specific logging function @ref logging_function_log is implemented
+ * using this function. Like @ref logging_function_log, this function is only
+ * available when @ref LIBRARY_LOG_LEVEL is #IOT_LOG_NONE.
+ *
+ * In most cases, the library-specific logging function @ref logging_function_log
+ * should be called instead of this function.
+ *
+ * @param[in] libraryLogSetting The log level setting of the library, used to
+ * determine if the log message should be printed. Must be one of the @ref
+ * logging_constants_levels.
+ * @param[in] pLibraryName The library name to print. See @ref LIBRARY_LOG_NAME.
+ * @param[in] messageLevel The log level of the this message. See @ref LIBRARY_LOG_LEVEL.
+ * @param[in] pLogConfig Pointer to a #IotLogConfig_t. Optional; pass `NULL` to ignore.
+ * @param[in] pFormat Format string for the log message.
+ * @param[in] ... Arguments for format specification.
+ *
+ * @return No return value. On errors, it prints nothing.
+ */
+/* @[declare_logging_generic] */
+void IotLog_Generic( int libraryLogSetting,
+                     const char * const pLibraryName,
+                     int messageLevel,
+                     const IotLogConfig_t * const pLogConfig,
+                     const char * const pFormat,
+                     ... );
+/* @[declare_logging_generic] */
+
+/**
+ * @brief Generic function to log the contents of a buffer as bytes.
+ *
+ * This function is the generic buffer logging function shared across all libraries.
+ * The library-specific buffer logging function @ref logging_function_printbuffer is
+ * implemented using this function. Like @ref logging_function_printbuffer, this
+ * function is only available when @ref LIBRARY_LOG_LEVEL is #IOT_LOG_DEBUG.
+ *
+ * In most cases, the library-specific buffer logging function @ref
+ * logging_function_printbuffer should be called instead of this function.
+ *
+ * @param[in] pLibraryName The library name to print with the log. See @ref LIBRARY_LOG_NAME.
+ * @param[in] pHeader A message to print before printing the buffer.
+ * @param[in] pBuffer The buffer to print.
+ * @param[in] bufferSize The number of bytes in `pBuffer` to print.
+ *
+ * @return No return value. On errors, it prints nothing.
+ *
+ * @note To conserve memory, this function only allocates enough memory for a
+ * single line of output. Therefore, in multithreaded systems, its output may
+ * appear "fragmented" if other threads are logging simultaneously.
+ */
+/* @[declare_logging_genericprintbuffer] */
+void IotLog_GenericPrintBuffer( const char * const pLibraryName,
+                                const char * const pHeader,
+                                const uint8_t * const pBuffer,
+                                size_t bufferSize );
+/* @[declare_logging_genericprintbuffer] */
+
+#endif /* ifndef IOT_LOGGING_H_ */

FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/c_sdk/standard/common/include/private/iot_static_memory.h

@@ -0,0 +1,250 @@
+/*
+ * Amazon FreeRTOS Common V1.0.0
+ * Copyright (C) 2018 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://aws.amazon.com/freertos
+ * http://www.FreeRTOS.org
+ */
+
+/**
+ * @file iot_static_memory.h
+ * @brief Common functions for managing static buffers. Only used when
+ * @ref IOT_STATIC_MEMORY_ONLY is `1`.
+ */
+
+/* The config header is always included first. */
+#include "iot_config.h"
+
+/* The functions in this file should only exist in static memory only mode, hence
+ * the check for IOT_STATIC_MEMORY_ONLY in the double inclusion guard. */
+#if !defined( IOT_STATIC_MEMORY_H_ ) && ( IOT_STATIC_MEMORY_ONLY == 1 )
+#define IOT_STATIC_MEMORY_H_
+
+/* Standard includes. */
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * @functionspage{static_memory,static memory component}
+ * - @functionname{static_memory_function_init}
+ * - @functionname{static_memory_function_cleanup}
+ * - @functionname{static_memory_function_findfree}
+ * - @functionname{static_memory_function_returninuse}
+ * - @functionname{static_memory_function_messagebuffersize}
+ * - @functionname{static_memory_function_mallocmessagebuffer}
+ * - @functionname{static_memory_function_freemessagebuffer}
+ */
+
+/*----------------------- Initialization and cleanup ------------------------*/
+
+/**
+ * @functionpage{IotStaticMemory_Init,static_memory,init}
+ * @functionpage{IotStaticMemory_Cleanup,static_memory,cleanup}
+ */
+
+/**
+ * @brief One-time initialization function for static memory.
+ *
+ * This function performs internal setup of static memory. <b>It must be called
+ * once (and only once) before calling any other static memory function.</b>
+ * Calling this function more than once without first calling
+ * @ref static_memory_function_cleanup may result in a crash.
+ *
+ * @return `true` if initialization succeeded; `false` otherwise.
+ *
+ * @attention This function is called by `IotSdk_Init` and does not need to be
+ * called by itself.
+ *
+ * @warning No thread-safety guarantees are provided for this function.
+ *
+ * @see static_memory_function_cleanup
+ */
+/* @[declare_static_memory_init] */
+bool IotStaticMemory_Init( void );
+/* @[declare_static_memory_init] */
+
+/**
+ * @brief One-time deinitialization function for static memory.
+ *
+ * This function frees resources taken in @ref static_memory_function_init.
+ * It should be called after to clean up static memory. After this function
+ * returns, @ref static_memory_function_init must be called again before
+ * calling any other static memory function.
+ *
+ * @attention This function is called by `IotSdk_Cleanup` and does not need
+ * to be called by itself.
+ *
+ * @warning No thread-safety guarantees are provided for this function.
+ *
+ * @see static_memory_function_init
+ */
+/* @[declare_static_memory_cleanup] */
+void IotStaticMemory_Cleanup( void );
+/* @[declare_static_memory_cleanup] */
+
+/*------------------------- Buffer allocation and free ----------------------*/
+
+/**
+ * @functionpage{IotStaticMemory_FindFree,static_memory,findfree}
+ * @functionpage{IotStaticMemory_ReturnInUse,static_memory,returninuse}
+ */
+
+/**
+ * @brief Find a free buffer using the "in-use" flags.
+ *
+ * If a free buffer is found, this function marks the buffer in-use. This function
+ * is common to the static memory implementation.
+ *
+ * @param[in] pInUse The "in-use" flags to search.
+ * @param[in] limit How many flags to check, i.e. the size of `pInUse`.
+ *
+ * @return The index of a free buffer; `-1` if no free buffers are available.
+ *
+ * <b>Example</b>:
+ * @code{c}
+ * // To use this function, first declare two arrays. One provides the statically-allocated
+ * // objects, the other provides flags to determine which objects are in-use.
+ * #define NUMBER_OF_OBJECTS    ...
+ * #define OBJECT_SIZE          ...
+ * static bool _pInUseObjects[ NUMBER_OF_OBJECTS ] = { 0 };
+ * static uint8_t _pObjects[ NUMBER_OF_OBJECTS ][ OBJECT_SIZE ] = { { 0 } }; // Placeholder for objects.
+ *
+ * // The function to statically allocate objects. Must have the same signature
+ * // as malloc().
+ * void * Iot_MallocObject( size_t size )
+ * {
+ *     int32_t freeIndex = -1;
+ *     void * pNewObject = NULL;
+ *
+ *     // Check that sizes match. 
+ *     if( size != OBJECT_SIZE )
+ *     {
+ *         // Get the index of a free object.
+ *         freeIndex = IotStaticMemory_FindFree( _pInUseMessageBuffers,
+ *                                               IOT_MESSAGE_BUFFERS );
+ *
+ *         if( freeIndex != -1 )
+ *         {
+ *             pNewBuffer = &( _pMessageBuffers[ freeIndex ][ 0 ] );
+ *         }
+ *     }
+ *
+ *     return pNewBuffer;
+ * }
+ * @endcode
+ */
+/* @[declare_static_memory_findfree] */
+int32_t IotStaticMemory_FindFree( bool * pInUse,
+                                  size_t limit );
+/* @[declare_static_memory_findfree] */
+
+/**
+ * @brief Return an "in-use" buffer.
+ *
+ * This function is common to the static memory implementation.
+ *
+ * @param[in] ptr Pointer to the buffer to return.
+ * @param[in] pPool The pool of buffers that the in-use buffer was allocated from.
+ * @param[in] pInUse The "in-use" flags for pPool.
+ * @param[in] limit How many buffers (and flags) to check while searching for ptr.
+ * @param[in] elementSize The size of a single element in pPool.
+ *
+ * <b>Example</b>:
+ * @code{c}
+ * // To use this function, first declare two arrays. One provides the statically-allocated
+ * // objects, the other provides flags to determine which objects are in-use.
+ * #define NUMBER_OF_OBJECTS    ...
+ * #define OBJECT_SIZE          ...
+ * static bool _pInUseObjects[ NUMBER_OF_OBJECTS ] = { 0 };
+ * static uint8_t _pObjects[ NUMBER_OF_OBJECTS ][ OBJECT_SIZE ] = { { 0 } }; // Placeholder for objects.
+ *
+ * // The function to free statically-allocated objects. Must have the same signature
+ * // as free().
+ * void Iot_FreeObject( void * ptr )
+ * {
+ *     IotStaticMemory_ReturnInUse( ptr,
+ *                                 _pObjects,
+ *                                 _pInUseObjects,
+ *                                 NUMBER_OF_OBJECTS,
+ *                                 OBJECT_SIZE );
+ * }
+ * @endcode
+ */
+/* @[declare_static_memory_returninuse] */
+void IotStaticMemory_ReturnInUse( void * ptr,
+                                  void * pPool,
+                                  bool * pInUse,
+                                  size_t limit,
+                                  size_t elementSize );
+/* @[declare_static_memory_returninuse] */
+
+/*------------------------ Message buffer management ------------------------*/
+
+/**
+ * @functionpage{Iot_MessageBufferSize,static_memory,messagebuffersize}
+ * @functionpage{Iot_MallocMessageBuffer,static_memory,mallocmessagebuffer}
+ * @functionpage{Iot_FreeMessageBuffer,static_memory,freemessagebuffer}
+ */
+
+/**
+ * @brief Get the fixed size of a message buffer.
+ *
+ * The size of the message buffers are known at compile time, but it is a [constant]
+ * (@ref IOT_MESSAGE_BUFFER_SIZE) that may not be visible to all source files.
+ * This function allows other source files to know the size of a message buffer.
+ *
+ * @return The size, in bytes, of a single message buffer.
+ */
+/* @[declare_static_memory_messagebuffersize] */
+size_t Iot_MessageBufferSize( void );
+/* @[declare_static_memory_messagebuffersize] */
+
+/**
+ * @brief Get an empty message buffer.
+ *
+ * This function is the analog of [malloc]
+ * (http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html)
+ * for message buffers.
+ *
+ * @param[in] size Requested size for a message buffer.
+ *
+ * @return Pointer to the start of a message buffer. If the `size` argument is larger
+ * than the [fixed size of a message buffer](@ref IOT_MESSAGE_BUFFER_SIZE)
+ * or no message buffers are available, `NULL` is returned.
+ */
+/* @[declare_static_memory_mallocmessagebuffer] */
+void * Iot_MallocMessageBuffer( size_t size );
+/* @[declare_static_memory_mallocmessagebuffer] */
+
+/**
+ * @brief Free an in-use message buffer.
+ *
+ * This function is the analog of [free]
+ * (http://pubs.opengroup.org/onlinepubs/9699919799/functions/free.html)
+ * for message buffers.
+ *
+ * @param[in] ptr Pointer to the message buffer to free.
+ */
+/* @[declare_static_memory_freemessagebuffer] */
+void Iot_FreeMessageBuffer( void * ptr );
+/* @[declare_static_memory_freemessagebuffer] */
+ 
+#endif /* if !defined( IOT_STATIC_MEMORY_H_ ) && ( IOT_STATIC_MEMORY_ONLY == 1 ) */

FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/c_sdk/standard/common/include/private/iot_taskpool_internal.h

@@ -0,0 +1,294 @@
+/*
+ * Amazon FreeRTOS Common V1.0.0
+ * Copyright (C) 2018 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://aws.amazon.com/freertos
+ * http://www.FreeRTOS.org
+ */
+
+/**
+ * @file iot_taskpool_internal.h
+ * @brief Internal header of task pool library. This header should not be included in
+ * typical application code.
+ */
+
+#ifndef IOT_TASKPOOL_INTERNAL_H_
+#define IOT_TASKPOOL_INTERNAL_H_
+
+/* The config header is always included first. */
+#include "iot_config.h"
+
+/* Task pool include. */
+#include "private/iot_error.h"
+#include "iot_taskpool.h"
+
+/* FreeRTOS includes. */
+#include "FreeRTOS.h"
+#include "semphr.h"
+#include "timers.h"
+
+/* Establish a few convenience macros to handle errors in a standard way. */
+
+/**
+ * @brief Every public API return an enumeration value with an undelying value of 0 in case of success.
+ */
+#define TASKPOOL_SUCCEEDED( x )               ( ( x ) == IOT_TASKPOOL_SUCCESS )
+
+/**
+ * @brief Every public API returns an enumeration value with an undelying value different than 0 in case of success.
+ */
+#define TASKPOOL_FAILED( x )                  ( ( x ) != IOT_TASKPOOL_SUCCESS )
+
+/**
+ * @brief Jump to the cleanup area.
+ */
+#define TASKPOOL_GOTO_CLEANUP()               IOT_GOTO_CLEANUP()
+
+/**
+ * @brief Declare the storage for the error status variable.
+ */
+#define  TASKPOOL_FUNCTION_ENTRY( result )    IOT_FUNCTION_ENTRY( IotTaskPoolError_t, result )
+
+/**
+ * @brief Check error and leave in case of failure.
+ */
+#define TASKPOOL_ON_ERROR_GOTO_CLEANUP( expr )                           \
+    { if( TASKPOOL_FAILED( status = ( expr ) ) ) { IOT_GOTO_CLEANUP(); } \
+    }
+
+/**
+ * @brief Exit if an argument is NULL.
+ */
+#define TASKPOOL_ON_NULL_ARG_GOTO_CLEANUP( ptr )      IOT_VALIDATE_PARAMETER( IOT_TASKPOOL, ( ptr != NULL ) )
+
+/**
+ * @brief Exit if an argument is NULL.
+ */
+#define TASKPOOL_ON_ARG_ERROR_GOTO_CLEANUP( expr )    IOT_VALIDATE_PARAMETER( IOT_TASKPOOL, ( ( expr ) == false ) )
+
+/**
+ * @brief Set error and leave.
+ */
+#define TASKPOOL_SET_AND_GOTO_CLEANUP( expr )         IOT_SET_AND_GOTO_CLEANUP( expr )
+
+/**
+ * @brief Initialize error and declare start of cleanup area.
+ */
+#define TASKPOOL_FUNCTION_CLEANUP()                   IOT_FUNCTION_CLEANUP_BEGIN()
+
+/**
+ * @brief Initialize error and declare end of cleanup area.
+ */
+#define TASKPOOL_FUNCTION_CLEANUP_END()               IOT_FUNCTION_CLEANUP_END()
+
+/**
+ * @brief Create an empty cleanup area.
+ */
+#define TASKPOOL_NO_FUNCTION_CLEANUP()                IOT_FUNCTION_EXIT_NO_CLEANUP()
+
+/**
+ * @brief Does not create a cleanup area.
+ */
+#define TASKPOOL_NO_FUNCTION_CLEANUP_NOLABEL()        return status
+
+/**
+ * @def IotTaskPool_Assert( expression )
+ * @brief Assertion macro for the Task pool library.
+ *
+ * Set @ref IOT_TASKPOOL_ENABLE_ASSERTS to `1` to enable assertions in the Task pool
+ * library.
+ *
+ * @param[in] expression Expression to be evaluated.
+ */
+#if IOT_TASKPOOL_ENABLE_ASSERTS == 1
+    #ifndef IotTaskPool_Assert
+        #include <assert.h>
+        #define IotTaskPool_Assert( expression )    assert( expression )
+    #endif
+#else
+    #define IotTaskPool_Assert( expression )
+#endif
+
+/* Configure logs for TASKPOOL functions. */
+#ifdef IOT_LOG_LEVEL_TASKPOOL
+    #define LIBRARY_LOG_LEVEL        IOT_LOG_LEVEL_TASKPOOL
+#else
+    #ifdef IOT_LOG_LEVEL_GLOBAL
+        #define LIBRARY_LOG_LEVEL    IOT_LOG_LEVEL_GLOBAL
+    #else
+        #define LIBRARY_LOG_LEVEL    IOT_LOG_NONE
+    #endif
+#endif
+
+#define LIBRARY_LOG_NAME    ( "TASKPOOL" )
+#include "iot_logging_setup.h"
+
+/*
+ * Provide default values for undefined memory allocation functions based on
+ * the usage of dynamic memory allocation.
+ */
+#if IOT_STATIC_MEMORY_ONLY == 1
+    #include "private/iot_static_memory.h"
+
+/**
+ * @brief Allocate an #_taskPool_t. This function should have the
+ * same signature as [malloc].
+ */
+    void * IotTaskPool_MallocTaskPool( size_t size );
+
+/**
+ * @brief Free an #_taskPool_t. This function should have the
+ * same signature as [malloc].
+ */
+    void IotTaskPool_FreeTaskPool( void * ptr );
+
+/**
+ * @brief Allocate an #IotTaskPoolJob_t. This function should have the
+ * same signature as [malloc].
+ */
+    void * IotTaskPool_MallocJob( size_t size );
+
+/**
+ * @brief Free an #IotTaskPoolJob_t. This function should have the same
+ * same signature as [malloc].
+ * (http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html).
+ */
+    void IotTaskPool_FreeJob( void * ptr );
+
+/**
+ * @brief Allocate an #_taskPoolTimerEvent_t. This function should have the
+ * same signature as [malloc].
+ */
+    void * IotTaskPool_MallocTimerEvent( size_t size );
+
+/**
+ * @brief Free an #_taskPoolTimerEvent_t. This function should have the
+ * same signature as[ free ].
+ */
+    void IotTaskPool_FreeTimerEvent( void * ptr );
+
+#else /* if IOT_STATIC_MEMORY_ONLY == 1 */
+    #include <stdlib.h>
+
+    #ifndef IotTaskPool_MallocTaskPool
+        #define IotTaskPool_MallocTaskPool    malloc
+    #endif
+
+    #ifndef IotTaskPool_FreeTaskPool
+        #define IotTaskPool_FreeTaskPool    free
+    #endif
+
+    #ifndef IotTaskPool_MallocJob
+        #define IotTaskPool_MallocJob    malloc
+    #endif
+
+    #ifndef IotTaskPool_FreeJob
+        #define IotTaskPool_FreeJob    free
+    #endif
+
+    #ifndef IotTaskPool_MallocTimerEvent
+        #define IotTaskPool_MallocTimerEvent    malloc
+    #endif
+
+    #ifndef IotTaskPool_FreeTimerEvent
+        #define IotTaskPool_FreeTimerEvent    free
+    #endif
+
+#endif /* if IOT_STATIC_MEMORY_ONLY == 1 */
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @cond DOXYGEN_IGNORE
+ * Doxygen should ignore this section.
+ *
+ * A macros to manage task pool memory allocation.
+ */
+#define IOT_TASK_POOL_INTERNAL_STATIC    ( ( uint32_t ) 0x00000001 )      /* Flag to mark a job as user-allocated. */
+/** @endcond */
+
+/**
+ * @brief Task pool jobs cache.
+ *
+ * @warning This is a system-level data type that should not be modified or used directly in any application.
+ * @warning This is a system-level data type that can and will change across different versions of the platform, with no regards for backward compatibility.
+ *
+ */
+typedef struct _taskPoolCache
+{
+    IotListDouble_t freeList; /**< @brief A list ot hold cached jobs. */
+
+    uint32_t freeCount;       /**< @brief A counter to track the number of jobs in the cache. */
+} _taskPoolCache_t;
+
+/**
+ * @brief The task pool data structure keeps track of the internal state and the signals for the dispatcher threads.
+ * The task pool is a thread safe data structure.
+ *
+ * @warning This is a system-level data type that should not be modified or used directly in any application.
+ * @warning This is a system-level data type that can and will change across different versions of the platform, with no regards for backward compatibility.
+ *
+ */
+typedef struct _taskPool
+{
+    IotDeQueue_t dispatchQueue;              /**< @brief The queue for the jobs waiting to be executed. */
+    IotListDouble_t timerEventsList;         /**< @brief The timeouts queue for all deferred jobs waiting to be executed. */
+    _taskPoolCache_t jobsCache;              /**< @brief A cache to re-use jobs in order to limit memory allocations. */
+    uint32_t activeThreads;                  /**< @brief The number of threads in the task pool at any given time. */
+    int32_t priority;                        /**< @brief The priority for all task pool threads. */
+    SemaphoreHandle_t dispatchSignal;        /**< @brief The synchronization object on which threads are waiting for incoming jobs. */
+    StaticSemaphore_t dispatchSignalBuffer;  /**< @brief The semaphore buffer. */
+    SemaphoreHandle_t startStopSignal;       /**< @brief The synchronization object for threads to signal start and stop condition. */
+    StaticSemaphore_t startStopSignalBuffer; /**< @brief The semaphore buffer. */
+    TimerHandle_t timer;                     /**< @brief The timer for deferred jobs. */
+    StaticTimer_t timerBuffer;               /**< @brief The timer buffer. */
+    bool running;                            /**< @brief A flag to track whether the task pool is operational or should shut down. */
+} _taskPool_t;
+
+/**
+ * @brief The job data structure keeps track of the user callback and context, as well as the status of the job.
+ *
+ * @warning This is a system-level data type that should not be modified or used directly in any application.
+ * @warning This is a system-level data type that can and will change across different versions of the platform, with no regards for backward compatibility.
+ *
+ */
+typedef struct _taskPoolJob
+{
+    IotLink_t link;                    /**< @brief The link to insert the job in the dispatch queue. */
+    IotTaskPoolRoutine_t userCallback; /**< @brief The user provided callback. */
+    void * pUserContext;               /**< @brief The user provided context. */
+    uint32_t flags;                    /**< @brief Internal flags. */
+    IotTaskPoolJobStatus_t status;     /**< @brief The status for the job. */
+} _taskPoolJob_t;
+
+/**
+ * @brief Represents an operation that is subject to a timer.
+ *
+ * These events are queued per MQTT connection. They are sorted by their
+ * expiration time.
+ */
+typedef struct _taskPoolTimerEvent
+{
+    IotLink_t link;            /**< @brief List link member. */
+    TickType_t expirationTime; /**< @brief When this event should be processed. */
+    IotTaskPoolJob_t job;      /**< @brief The task pool job associated with this event. */
+} _taskPoolTimerEvent_t;
+
+#endif /* ifndef IOT_TASKPOOL_INTERNAL_H_ */