mirror of
https://github.com/FreeRTOS/FreeRTOS-Kernel.git
synced 2025-08-18 09:08:33 -04:00
Rename \FreeRTOS-Plus\Source\FreeRTOS-Plus-IoT-SDK to \FreeRTOS-Plus\Source\FreeRTOS-IoT-Libraries.
This commit is contained in:
Gaurav Aggarwal
parent
7af8756c97
commit
9dd72d4b44
45 changed files with 0 additions and 0 deletions
|
|
@ -0,0 +1,216 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Platform V1.0.0
|
||||
* Copyright (C) 2019 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_clock.h
|
||||
* @brief Time-related functions used by libraries in this SDK.
|
||||
*/
|
||||
|
||||
#ifndef IOT_CLOCK_H_
|
||||
#define IOT_CLOCK_H_
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/* Platform layer types include. */
|
||||
#include "types/iot_platform_types.h"
|
||||
|
||||
/**
|
||||
* @functionspage{platform_clock,platform clock component,Clock}
|
||||
* - @functionname{platform_clock_function_gettimestring}
|
||||
* - @functionname{platform_clock_function_gettimems}
|
||||
* - @functionname{platform_clock_function_sleepms}
|
||||
* - @functionname{platform_clock_function_timercreate}
|
||||
* - @functionname{platform_clock_function_timerdestroy}
|
||||
* - @functionname{platform_clock_function_timerarm}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @functionpage{IotClock_GetTimestring,platform_clock,gettimestring}
|
||||
* @functionpage{IotClock_GetTimeMs,platform_clock,gettimems}
|
||||
* @functionpage{IotClock_SleepMs,platform_clock,sleepms}
|
||||
* @functionpage{IotClock_TimerCreate,platform_clock,timercreate}
|
||||
* @functionpage{IotClock_TimerDestroy,platform_clock,timerdestroy}
|
||||
* @functionpage{IotClock_TimerArm,platform_clock,timerarm}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Generates a human-readable timestring, such as "01 Jan 2018 12:00".
|
||||
*
|
||||
* This function uses the system clock to generate a human-readable timestring.
|
||||
* This timestring is printed by the [logging functions](@ref logging_functions).
|
||||
*
|
||||
* @param[out] pBuffer A buffer to store the timestring in.
|
||||
* @param[in] bufferSize The size of `pBuffer`.
|
||||
* @param[out] pTimestringLength The actual length of the timestring stored in
|
||||
* `pBuffer`.
|
||||
*
|
||||
* @return `true` if a timestring was successfully generated; `false` otherwise.
|
||||
*
|
||||
* @warning The implementation of this function must not call any [logging functions]
|
||||
* (@ref logging_functions).
|
||||
*
|
||||
* <b>Example</b>
|
||||
* @code{c}
|
||||
* char timestring[ 32 ];
|
||||
* size_t timestringLength = 0;
|
||||
*
|
||||
* if( IotClock_GetTimestring( timestring, 32, ×tringLength ) == true )
|
||||
* {
|
||||
* printf( "Timestring: %.*s", timestringLength, timestring );
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
/* @[declare_platform_clock_gettimestring] */
|
||||
bool IotClock_GetTimestring( char * pBuffer,
|
||||
size_t bufferSize,
|
||||
size_t * pTimestringLength );
|
||||
/* @[declare_platform_clock_gettimestring] */
|
||||
|
||||
/**
|
||||
* @brief Returns a nonzero, monotonically-increasing system time in milliseconds.
|
||||
*
|
||||
* This function reads a millisecond-resolution system clock. The clock should
|
||||
* always be monotonically-increasing; therefore, real-time clocks that may be
|
||||
* set by another process are not suitable for this function's implementation.
|
||||
*
|
||||
* @return The value of the system clock. This function is not expected to fail.
|
||||
*
|
||||
* <b>Example</b>
|
||||
* @code{c}
|
||||
* // Get current time.
|
||||
* uint64_t currentTime = IotClock_GetTimeMs();
|
||||
* @endcode
|
||||
*/
|
||||
/* @[declare_platform_clock_gettimems] */
|
||||
uint64_t IotClock_GetTimeMs( void );
|
||||
/* @[declare_platform_clock_gettimems] */
|
||||
|
||||
/**
|
||||
* @brief Delay for the given number of milliseconds.
|
||||
*
|
||||
* This function suspends its calling thread for at least `sleepTimeMs` milliseconds.
|
||||
*
|
||||
* @param[in] sleepTimeMs Sleep time (in milliseconds).
|
||||
*/
|
||||
/* @[declare_platform_clock_sleepms] */
|
||||
void IotClock_SleepMs( uint32_t sleepTimeMs );
|
||||
/* @[declare_platform_clock_sleepms] */
|
||||
|
||||
/**
|
||||
* @brief Create a new timer.
|
||||
*
|
||||
* This function creates a new, unarmed timer. It must be called on an uninitialized
|
||||
* #IotTimer_t. This function must not be called on an already-initialized #IotTimer_t.
|
||||
*
|
||||
* @param[out] pNewTimer Set to a new timer handle on success.
|
||||
* @param[in] expirationRoutine The function to run when this timer expires. This
|
||||
* function should be called in its own <i>detached</i> thread.
|
||||
* @param[in] pArgument The argument to pass to `expirationRoutine`.
|
||||
*
|
||||
* @return `true` if the timer is successfully created; `false` otherwise.
|
||||
*
|
||||
* @see @ref platform_clock_function_timerdestroy, @ref platform_clock_function_timerarm
|
||||
*/
|
||||
/* @[declare_platform_clock_timercreate] */
|
||||
bool IotClock_TimerCreate( IotTimer_t * pNewTimer,
|
||||
IotThreadRoutine_t expirationRoutine,
|
||||
void * pArgument );
|
||||
/* @[declare_platform_clock_timercreate] */
|
||||
|
||||
/**
|
||||
* @brief Free resources used by a timer.
|
||||
*
|
||||
* This function frees resources used by a timer. It must be called on an initialized
|
||||
* #IotTimer_t. No other timer functions should be called on `pTimer` after calling
|
||||
* this function (unless the timer is re-created).
|
||||
*
|
||||
* This function will stop the `pTimer` if it is armed.
|
||||
*
|
||||
* @param[in] pTimer The timer to destroy.
|
||||
*
|
||||
* @see @ref platform_clock_function_timercreate, @ref platform_clock_function_timerarm
|
||||
*/
|
||||
/* @[declare_platform_clock_timerdestroy] */
|
||||
void IotClock_TimerDestroy( IotTimer_t * pTimer );
|
||||
/* @[declare_platform_clock_timerdestroy] */
|
||||
|
||||
/**
|
||||
* @brief Arm a timer to expire at the given relative timeout.
|
||||
*
|
||||
* This function arms a timer to run its expiration routine at the given time.
|
||||
*
|
||||
* If `periodMs` is nonzero, the timer should expire periodically at intervals
|
||||
* such as:
|
||||
* - `relativeTimeoutMs`
|
||||
* - `relativeTimeoutMs + periodMs`
|
||||
* - `relativeTimeoutMs + 2 * periodMs`
|
||||
* - Etc. (subject to some jitter).
|
||||
*
|
||||
* Setting `periodMs` to `0` arms a one-shot, non-periodic timer.
|
||||
*
|
||||
* @param[in] pTimer The timer to arm.
|
||||
* @param[in] relativeTimeoutMs When the timer should expire, relative to the time
|
||||
* this function is called.
|
||||
* @param[in] periodMs How often the timer should expire again after `relativeTimerMs`.
|
||||
*
|
||||
* @return `true` if the timer was successfully armed; `false` otherwise.
|
||||
*
|
||||
* @see @ref platform_clock_function_timercreate, @ref platform_clock_function_timerdestroy
|
||||
*
|
||||
* <b>Example</b>
|
||||
* @code{c}
|
||||
*
|
||||
* void timerExpirationRoutine( void * pArgument );
|
||||
*
|
||||
* void timerExample( void )
|
||||
* {
|
||||
* IotTimer_t timer;
|
||||
*
|
||||
* if( IotClock_TimerCreate( &timer, timerExpirationRoutine, NULL ) == true )
|
||||
* {
|
||||
* // Set the timer to periodically expire every 10 seconds.
|
||||
* if( IotClock_TimerArm( &timer, 10000, 10000 ) == true )
|
||||
* {
|
||||
* // Wait for timer to expire.
|
||||
* }
|
||||
*
|
||||
* IotClock_TimerDestroy( &timer );
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
/* @[declare_platform_clock_timerarm] */
|
||||
bool IotClock_TimerArm( IotTimer_t * pTimer,
|
||||
uint32_t relativeTimeoutMs,
|
||||
uint32_t periodMs );
|
||||
/* @[declare_platform_clock_timerarm] */
|
||||
|
||||
#endif /* ifndef IOT_CLOCK_H_ */
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Platform V1.0.0
|
||||
* Copyright (C) 2019 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_metrics.h
|
||||
* @brief Functions for retrieving [Device Defender](@ref defender) metrics.
|
||||
*
|
||||
* The functions in this header are only required by Device Defender. They do not
|
||||
* need to be implemented if Device Defender is not used.
|
||||
*/
|
||||
|
||||
#ifndef IOT_METRICS_H_
|
||||
#define IOT_METRICS_H_
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdbool.h>
|
||||
|
||||
/* Linear containers (lists and queues) include. */
|
||||
#include "iot_linear_containers.h"
|
||||
|
||||
/**
|
||||
* @functionspage{platform_metrics,platform metrics component,Metrics}
|
||||
* - @functionname{platform_metrics_function_init}
|
||||
* - @functionname{platform_metrics_function_cleanup}
|
||||
* - @functionname{platform_metrics_function_gettcpconnections}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @functionpage{IotMetrics_Init,platform_metrics,init}
|
||||
* @functionpage{IotMetrics_Cleanup,platform_metrics,cleanup}
|
||||
* @functionpage{IotMetrics_GetTcpConnections,platform_metrics,gettcpconnections}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief One-time initialization function for the platform metrics component.
|
||||
*
|
||||
* This function initializes the platform metrics component. <b>It must be called
|
||||
* once (and only once) before calling any other metrics or [Device Defender function]
|
||||
* (@ref defender_functions).</b> Calling this function more than once without first
|
||||
* calling @ref platform_metrics_function_cleanup may result in a crash.
|
||||
*
|
||||
* @return `true` is initialization succeeded; `false` otherwise.
|
||||
*
|
||||
* @warning No thread-safety guarantees are provided for this function.
|
||||
*/
|
||||
/* @[declare_platform_metrics_init] */
|
||||
bool IotMetrics_Init( void );
|
||||
/* @[declare_platform_metrics_init] */
|
||||
|
||||
/**
|
||||
* @brief One-time deinitialization function for the platform metrics component.
|
||||
*
|
||||
* This function frees resources taken in @ref platform_metrics_function_init.
|
||||
* No other metrics or [Device Defender functions](@ref defender_functions) may
|
||||
* be called unless @ref platform_metrics_function_init is called again.
|
||||
*
|
||||
* @warning No thread-safety guarantees are provided for this function.
|
||||
*/
|
||||
/* @[declare_platform_metrics_cleanup] */
|
||||
void IotMetrics_Cleanup( void );
|
||||
/* @[declare_platform_metrics_cleanup] */
|
||||
|
||||
/**
|
||||
* @brief Retrieve a list of active TCP connections from the system.
|
||||
*
|
||||
* The provided connections are reported by Device Defender.
|
||||
*
|
||||
* @param[in] pContext Context passed as the first parameter of `metricsCallback`.
|
||||
* @param[in] metricsCallback Called by this function to provide the list of TCP
|
||||
* connections. The list given by this function is should not be used after the
|
||||
* callback returns.
|
||||
*/
|
||||
/* @[declare_platform_metrics_gettcpconnections] */
|
||||
void IotMetrics_GetTcpConnections( void * pContext,
|
||||
void ( * metricsCallback )( void *, const IotListDouble_t * ) );
|
||||
/* @[declare_platform_metrics_gettcpconnections] */
|
||||
|
||||
#endif /* ifndef IOT_METRICS_H_ */
|
||||
|
|
@ -0,0 +1,294 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Platform V1.0.0
|
||||
* Copyright (C) 2019 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_network.h
|
||||
* @brief Abstraction of network functions used by libraries in this SDK.
|
||||
*/
|
||||
|
||||
#ifndef IOT_NETWORK_H_
|
||||
#define IOT_NETWORK_H_
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/**
|
||||
* @ingroup platform_datatypes_enums
|
||||
* @brief Return codes for [network functions](@ref platform_network_functions).
|
||||
*/
|
||||
typedef enum IotNetworkError
|
||||
{
|
||||
IOT_NETWORK_SUCCESS = 0, /**< Function successfully completed. */
|
||||
IOT_NETWORK_FAILURE, /**< Generic failure not covered by other values. */
|
||||
IOT_NETWORK_BAD_PARAMETER, /**< At least one parameter was invalid. */
|
||||
IOT_NETWORK_NO_MEMORY, /**< Memory allocation failed. */
|
||||
IOT_NETWORK_SYSTEM_ERROR /**< An error occurred when calling a system API. */
|
||||
} IotNetworkError_t;
|
||||
|
||||
/**
|
||||
* @page platform_network_functions Networking
|
||||
* @brief Functions of the network abstraction component.
|
||||
*
|
||||
* The network abstraction component does not declare functions, but uses function
|
||||
* pointers instead. This allows multiple network stacks to be used at the same time.
|
||||
* Libraries that require the network will request an #IotNetworkInterface_t
|
||||
* parameter. The members of the #IotNetworkInterface_t will be called whenever
|
||||
* the library interacts with the network.
|
||||
*
|
||||
* The following function pointers are associated with an #IotNetworkInterface_t.
|
||||
* Together, they represent a network stack.
|
||||
* - @functionname{platform_network_function_create}
|
||||
* - @functionname{platform_network_function_setreceivecallback}
|
||||
* - @functionname{platform_network_function_send}
|
||||
* - @functionname{platform_network_function_receive}
|
||||
* - @functionname{platform_network_function_close}
|
||||
* - @functionname{platform_network_function_destroy}
|
||||
* - @functionname{platform_network_function_receivecallback}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @functionpage{IotNetworkInterface_t::create,platform_network,create}
|
||||
* @functionpage{IotNetworkInterface_t::setReceiveCallback,platform_network,setreceivecallback}
|
||||
* @functionpage{IotNetworkInterface_t::send,platform_network,send}
|
||||
* @functionpage{IotNetworkInterface_t::receive,platform_network,receive}
|
||||
* @functionpage{IotNetworkInterface_t::close,platform_network,close}
|
||||
* @functionpage{IotNetworkInterface_t::destroy,platform_network,destroy}
|
||||
* @functionpage{IotNetworkReceiveCallback_t,platform_network,receivecallback}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Provide an asynchronous notification of incoming network data.
|
||||
*
|
||||
* A function with this signature may be set with @ref platform_network_function_setreceivecallback
|
||||
* to be invoked when data is available on the network.
|
||||
*
|
||||
* @param[in] pConnection The connection on which data is available, defined by
|
||||
* the network stack.
|
||||
* @param[in] pContext The third argument passed to @ref platform_network_function_setreceivecallback.
|
||||
*/
|
||||
/* @[declare_platform_network_receivecallback] */
|
||||
typedef void ( * IotNetworkReceiveCallback_t )( void * pConnection,
|
||||
void * pContext );
|
||||
/* @[declare_platform_network_receivecallback] */
|
||||
|
||||
/**
|
||||
* @ingroup platform_datatypes_paramstructs
|
||||
* @brief Represents the functions of a network stack.
|
||||
*
|
||||
* Functions that match these signatures should be implemented against a system's
|
||||
* network stack. See the `platform` directory for existing implementations.
|
||||
*/
|
||||
typedef struct IotNetworkInterface
|
||||
{
|
||||
/**
|
||||
* @brief Create a new network connection.
|
||||
*
|
||||
* This function allocates resources and establishes a new network connection.
|
||||
* @param[in] pConnectionInfo Represents information needed to set up the
|
||||
* new connection, defined by the network stack.
|
||||
* @param[in] pCredentialInfo Represents information needed to secure the
|
||||
* new connection, defined by the network stack.
|
||||
* @param[out] pConnection Set to represent a new connection, defined by the
|
||||
* network stack.
|
||||
*
|
||||
* @return Any #IotNetworkError_t, as defined by the network stack.
|
||||
*/
|
||||
/* @[declare_platform_network_create] */
|
||||
IotNetworkError_t ( * create )( void * pConnectionInfo,
|
||||
void * pCredentialInfo,
|
||||
void ** pConnection );
|
||||
/* @[declare_platform_network_create] */
|
||||
|
||||
/**
|
||||
* @brief Register an @ref platform_network_function_receivecallback.
|
||||
*
|
||||
* Sets an @ref platform_network_function_receivecallback to be called
|
||||
* asynchronously when data arrives on the network. The network stack
|
||||
* should invoke this function "as if" it were the thread routine of a
|
||||
* detached thread.
|
||||
*
|
||||
* Each network connection may only have one receive callback at any time.
|
||||
* @ref platform_network_function_close is expected to remove any active
|
||||
* receive callbacks.
|
||||
*
|
||||
* @param[in] pConnection The connection to associate with the receive callback.
|
||||
* @param[in] receiveCallback The function to invoke for incoming network data.
|
||||
* @param[in] pContext A value to pass as the first parameter to the receive callback.
|
||||
*
|
||||
* @return Any #IotNetworkError_t, as defined by the network stack.
|
||||
*
|
||||
* @see platform_network_function_receivecallback
|
||||
*/
|
||||
/* @[declare_platform_network_setreceivecallback] */
|
||||
IotNetworkError_t ( * setReceiveCallback )( void * pConnection,
|
||||
IotNetworkReceiveCallback_t receiveCallback,
|
||||
void * pContext );
|
||||
/* @[declare_platform_network_setreceivecallback] */
|
||||
|
||||
/**
|
||||
* @brief Send data over a return connection.
|
||||
*
|
||||
* Attempts to transmit `messageLength` bytes of `pMessage` across the
|
||||
* connection represented by `pConnection`. Returns the number of bytes
|
||||
* actually sent, `0` on failure.
|
||||
*
|
||||
* @param[in] pConnection The connection used to send data, defined by the
|
||||
* network stack.
|
||||
* @param[in] pMessage The message to send.
|
||||
* @param[in] messageLength The length of `pMessage`.
|
||||
*
|
||||
* @return The number of bytes successfully sent, `0` on failure.
|
||||
*/
|
||||
/* @[declare_platform_network_send] */
|
||||
size_t ( * send )( void * pConnection,
|
||||
const uint8_t * pMessage,
|
||||
size_t messageLength );
|
||||
/* @[declare_platform_network_send] */
|
||||
|
||||
/**
|
||||
* @brief Block and wait for incoming network data.
|
||||
*
|
||||
* Wait for a message of size `bytesRequested` to arrive on the network and
|
||||
* place it in `pBuffer`.
|
||||
*
|
||||
* @param[in] pConnection The connection to wait on, defined by the network
|
||||
* stack.
|
||||
* @param[out] pBuffer Where to place the incoming network data. This buffer
|
||||
* must be at least `bytesRequested` in size.
|
||||
* @param[in] bytesRequested How many bytes to wait for. `pBuffer` must be at
|
||||
* least this size.
|
||||
*
|
||||
* @return The number of bytes successfully received. This should be
|
||||
* `bytesRequested` when successful. Any other value may indicate an error.
|
||||
*/
|
||||
/* @[declare_platform_network_receive] */
|
||||
size_t ( * receive )( void * pConnection,
|
||||
uint8_t * pBuffer,
|
||||
size_t bytesRequested );
|
||||
/* @[declare_platform_network_receive] */
|
||||
|
||||
/**
|
||||
* @brief Close a network connection.
|
||||
*
|
||||
* This function closes the connection, but does not release the resources
|
||||
* used by the connection. This allows calls to other networking functions
|
||||
* to return an error and handle a closed connection without the risk of
|
||||
* crashing. Once it can be guaranteed that `pConnection` will no longer be
|
||||
* used, the connection can be destroyed with @ref platform_network_function_destroy.
|
||||
*
|
||||
* In addition to closing the connection, this function should also remove
|
||||
* any active [receive callback](@ref platform_network_function_receivecallback).
|
||||
*
|
||||
* @param[in] pConnection The network connection to close, defined by the
|
||||
* network stack.
|
||||
*
|
||||
* @return Any #IotNetworkError_t, as defined by the network stack.
|
||||
*
|
||||
* @note It must be safe to call this function on an already-closed connection.
|
||||
*/
|
||||
/* @[declare_platform_network_close] */
|
||||
IotNetworkError_t ( * close )( void * pConnection );
|
||||
/* @[declare_platform_network_close] */
|
||||
|
||||
/**
|
||||
* @brief Free resources used by a network connection.
|
||||
*
|
||||
* This function releases the resources of a closed connection. It should be
|
||||
* called after @ref platform_network_function_close.
|
||||
*
|
||||
* @param[in] pConnection The network connection to destroy, defined by
|
||||
* the network stack.
|
||||
*
|
||||
* @return Any #IotNetworkError_t, as defined by the network stack.
|
||||
*
|
||||
* @attention No function should be called on the network connection after
|
||||
* calling this function. This function must be safe to call from a
|
||||
* [receive callback](@ref platform_network_function_receivecallback).
|
||||
*/
|
||||
/* @[declare_platform_network_destroy] */
|
||||
IotNetworkError_t ( * destroy )( void * pConnection );
|
||||
/* @[declare_platform_network_destroy] */
|
||||
} IotNetworkInterface_t;
|
||||
|
||||
/**
|
||||
* @ingroup platform_datatypes_paramstructs
|
||||
* @brief Information on the remote server for connection setup.
|
||||
*
|
||||
* May be passed to #IotNetworkInterface_t.create as `pConnectionInfo`. This
|
||||
* structure contains commonly-used parameters, but may be replaced with an
|
||||
* alternative.
|
||||
*/
|
||||
typedef struct IotNetworkServerInfo
|
||||
{
|
||||
const char * pHostName; /**< @brief Server host name. Must be NULL-terminated. */
|
||||
uint16_t port; /**< @brief Server port in host-order. */
|
||||
} IotNetworkServerInfo_t;
|
||||
|
||||
/**
|
||||
* @ingroup platform_datatypes_paramstructs
|
||||
* @brief Contains the credentials necessary for connection setup.
|
||||
*
|
||||
* May be passed to #IotNetworkInterface_t.create as `pCredentialInfo`. This
|
||||
* structure contains commonly-used parameters, but may be replaced with an
|
||||
* alternative.
|
||||
*/
|
||||
typedef struct IotNetworkCredentials
|
||||
{
|
||||
/**
|
||||
* @brief Set this to a non-NULL value to use ALPN.
|
||||
*
|
||||
* This string must be NULL-terminated.
|
||||
*
|
||||
* See [this link]
|
||||
* (https://aws.amazon.com/blogs/iot/mqtt-with-tls-client-authentication-on-port-443-why-it-is-useful-and-how-it-works/)
|
||||
* for more information.
|
||||
*/
|
||||
const char * pAlpnProtos;
|
||||
|
||||
/**
|
||||
* @brief Set this to a non-zero value to use TLS max fragment length
|
||||
* negotiation (TLS MFLN).
|
||||
*
|
||||
* @note The network stack may have a minimum value for this parameter and
|
||||
* may return an error if this parameter is too small.
|
||||
*/
|
||||
size_t maxFragmentLength;
|
||||
|
||||
/**
|
||||
* @brief Disable server name indication (SNI) for a TLS session.
|
||||
*/
|
||||
bool disableSni;
|
||||
|
||||
const char * pRootCa; /**< @brief String representing a trusted server root certificate. */
|
||||
size_t rootCaSize; /**< @brief Size associated with #IotNetworkCredentials_t.pRootCa. */
|
||||
const char * pClientCert; /**< @brief String representing the client certificate. */
|
||||
size_t clientCertSize; /**< @brief Size associated with #IotNetworkCredentials_t.pClientCert. */
|
||||
const char * pPrivateKey; /**< @brief String representing the client certificate's private key. */
|
||||
size_t privateKeySize; /**< @brief Size associated with #IotNetworkCredentials_t.pPrivateKey. */
|
||||
} IotNetworkCredentials_t;
|
||||
|
||||
#endif /* ifndef IOT_NETWORK_H_ */
|
||||
|
|
@ -0,0 +1,355 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Platform V1.0.0
|
||||
* Copyright (C) 2019 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_threads.h
|
||||
* @brief Threading and synchronization functions used by libraries in this SDK.
|
||||
*/
|
||||
|
||||
#ifndef IOT_THREADS_H_
|
||||
#define IOT_THREADS_H_
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/* Platform layer types include. */
|
||||
#include "types/iot_platform_types.h"
|
||||
|
||||
/**
|
||||
* @functionspage{platform_threads,platform thread management,Thread Management}
|
||||
* - @functionname{platform_threads_function_createdetachedthread}
|
||||
* - @functionname{platform_threads_function_mutexcreate}
|
||||
* - @functionname{platform_threads_function_mutexdestroy}
|
||||
* - @functionname{platform_threads_function_mutexlock}
|
||||
* - @functionname{platform_threads_function_mutextrylock}
|
||||
* - @functionname{platform_threads_function_mutexunlock}
|
||||
* - @functionname{platform_threads_function_semaphorecreate}
|
||||
* - @functionname{platform_threads_function_semaphoredestroy}
|
||||
* - @functionname{platform_threads_function_semaphoregetcount}
|
||||
* - @functionname{platform_threads_function_semaphorewait}
|
||||
* - @functionname{platform_threads_function_semaphoretrywait}
|
||||
* - @functionname{platform_threads_function_semaphoretimedwait}
|
||||
* - @functionname{platform_threads_function_semaphorepost}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @functionpage{Iot_CreateDetachedThread,platform_threads,createdetachedthread}
|
||||
* @functionpage{IotMutex_Create,platform_threads,mutexcreate}
|
||||
* @functionpage{IotMutex_Destroy,platform_threads,mutexdestroy}
|
||||
* @functionpage{IotMutex_Lock,platform_threads,mutexlock}
|
||||
* @functionpage{IotMutex_TryLock,platform_threads,mutextrylock}
|
||||
* @functionpage{IotMutex_Unlock,platform_threads,mutexunlock}
|
||||
* @functionpage{IotSemaphore_Create,platform_threads,semaphorecreate}
|
||||
* @functionpage{IotSemaphore_Destroy,platform_threads,semaphoredestroy}
|
||||
* @functionpage{IotSemaphore_GetCount,platform_threads,semaphoregetcount}
|
||||
* @functionpage{IotSemaphore_Wait,platform_threads,semaphorewait}
|
||||
* @functionpage{IotSemaphore_TryWait,platform_threads,semaphoretrywait}
|
||||
* @functionpage{IotSemaphore_TimedWait,platform_threads,semaphoretimedwait}
|
||||
* @functionpage{IotSemaphore_Post,platform_threads,semaphorepost}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Create a new detached thread, i.e. a thread that cleans up after itself.
|
||||
*
|
||||
* This function creates a new thread. Threads created by this function exit
|
||||
* upon returning from the thread routine. Any resources taken must be freed
|
||||
* by the exiting thread.
|
||||
*
|
||||
* @param[in] threadRoutine The function this thread should run.
|
||||
* @param[in] pArgument The argument passed to `threadRoutine`.
|
||||
* @param[in] priority Represents the priority of the new thread, as defined by
|
||||
* the system. The value #IOT_THREAD_DEFAULT_PRIORITY (i.e. `0`) must be used to
|
||||
* represent the system default for thread priority.
|
||||
* @param[in] stackSize Represents the stack size of the new thread, as defined
|
||||
* by the system. The value #IOT_THREAD_DEFAULT_STACK_SIZE (i.e. `0`) must be used
|
||||
* to represent the system default for stack size.
|
||||
*
|
||||
* @return `true` if the new thread was successfully created; `false` otherwise.
|
||||
*
|
||||
* @code{c}
|
||||
* // Thread routine.
|
||||
* void threadRoutine( void * pArgument );
|
||||
*
|
||||
* // Run threadRoutine in a detached thread, using default priority and stack size.
|
||||
* if( Iot_CreateDetachedThread( threadRoutine,
|
||||
* NULL,
|
||||
* IOT_THREAD_DEFAULT_PRIORITY,
|
||||
* IOT_THREAD_DEFAULT_STACK_SIZE ) == true )
|
||||
* {
|
||||
* // Success
|
||||
* }
|
||||
* else
|
||||
* {
|
||||
* // Failure, no thread was created.
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
/* @[declare_platform_threads_createdetachedthread] */
|
||||
bool Iot_CreateDetachedThread( IotThreadRoutine_t threadRoutine,
|
||||
void * pArgument,
|
||||
int32_t priority,
|
||||
size_t stackSize );
|
||||
/* @[declare_platform_threads_createdetachedthread] */
|
||||
|
||||
/**
|
||||
* @brief Create a new mutex.
|
||||
*
|
||||
* This function creates a new, unlocked mutex. It must be called on an uninitialized
|
||||
* #IotMutex_t. This function must not be called on an already-initialized #IotMutex_t.
|
||||
*
|
||||
* @param[in] pNewMutex Pointer to the memory that will hold the new mutex.
|
||||
* @param[in] recursive Set to `true` to create a recursive mutex, i.e. a mutex that
|
||||
* may be locked multiple times by the same thread. If the system does not support
|
||||
* recursive mutexes, this function should do nothing and return `false`.
|
||||
*
|
||||
* @return `true` if mutex creation succeeds; `false` otherwise.
|
||||
*
|
||||
* @see @ref platform_threads_function_mutexdestroy
|
||||
*
|
||||
* <b>Example</b>
|
||||
* @code{c}
|
||||
* IotMutex_t mutex;
|
||||
*
|
||||
* // Create non-recursive mutex.
|
||||
* if( IotMutex_Create( &mutex, false ) == true )
|
||||
* {
|
||||
* // Lock and unlock the mutex...
|
||||
*
|
||||
* // Destroy the mutex when it's no longer needed.
|
||||
* IotMutex_Destroy( &mutex );
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
/* @[declare_platform_threads_mutexcreate] */
|
||||
bool IotMutex_Create( IotMutex_t * pNewMutex, bool recursive );
|
||||
/* @[declare_platform_threads_mutexcreate] */
|
||||
|
||||
/**
|
||||
* @brief Free resources used by a mutex.
|
||||
*
|
||||
* This function frees resources used by a mutex. It must be called on an initialized
|
||||
* #IotMutex_t. No other mutex functions should be called on `pMutex` after calling
|
||||
* this function (unless the mutex is re-created).
|
||||
*
|
||||
* @param[in] pMutex The mutex to destroy.
|
||||
*
|
||||
* @warning This function must not be called on a locked mutex.
|
||||
* @see @ref platform_threads_function_mutexcreate
|
||||
*/
|
||||
/* @[declare_platform_threads_mutexdestroy] */
|
||||
void IotMutex_Destroy( IotMutex_t * pMutex );
|
||||
/* @[declare_platform_threads_mutexdestroy] */
|
||||
|
||||
/**
|
||||
* @brief Lock a mutex. This function should only return when the mutex is locked;
|
||||
* it is not expected to fail.
|
||||
*
|
||||
* This function blocks and waits until a mutex is available. It waits forever
|
||||
* (deadlocks) if `pMutex` is already locked and never unlocked.
|
||||
*
|
||||
* @param[in] pMutex The mutex to lock.
|
||||
*
|
||||
* @see @ref platform_threads_function_mutextrylock for a nonblocking lock.
|
||||
*/
|
||||
/* @[declare_platform_threads_mutexlock] */
|
||||
void IotMutex_Lock( IotMutex_t * pMutex );
|
||||
/* @[declare_platform_threads_mutexlock] */
|
||||
|
||||
/**
|
||||
* @brief Attempt to lock a mutex. Return immediately if the mutex is not available.
|
||||
*
|
||||
* If `pMutex` is available, this function immediately locks it and returns.
|
||||
* Otherwise, this function returns without locking `pMutex`.
|
||||
*
|
||||
* @param[in] pMutex The mutex to lock.
|
||||
*
|
||||
* @return `true` if the mutex was successfully locked; `false` if the mutex was
|
||||
* not available.
|
||||
*
|
||||
* @see @ref platform_threads_function_mutexlock for a blocking lock.
|
||||
*/
|
||||
/* @[declare_platform_threads_mutextrylock] */
|
||||
bool IotMutex_TryLock( IotMutex_t * pMutex );
|
||||
/* @[declare_platform_threads_mutextrylock] */
|
||||
|
||||
/**
|
||||
* @brief Unlock a mutex. This function should only return when the mutex is unlocked;
|
||||
* it is not expected to fail.
|
||||
*
|
||||
* Unlocks a locked mutex. `pMutex` must have been locked by the thread calling
|
||||
* this function.
|
||||
*
|
||||
* @param[in] pMutex The mutex to unlock.
|
||||
*
|
||||
* @note This function should not be called on a mutex that is already unlocked.
|
||||
*/
|
||||
/* @[declare_platform_threads_mutexunlock] */
|
||||
void IotMutex_Unlock( IotMutex_t * pMutex );
|
||||
/* @[declare_platform_threads_mutexunlock] */
|
||||
|
||||
/**
|
||||
* @brief Create a new counting semaphore.
|
||||
*
|
||||
* This function creates a new counting semaphore with a given intial and
|
||||
* maximum value. It must be called on an uninitialized #IotSemaphore_t.
|
||||
* This function must not be called on an already-initialized #IotSemaphore_t.
|
||||
*
|
||||
* @param[in] pNewSemaphore Pointer to the memory that will hold the new semaphore.
|
||||
* @param[in] initialValue The semaphore should be initialized with this value.
|
||||
* @param[in] maxValue The maximum value the semaphore will reach.
|
||||
*
|
||||
* @return `true` if semaphore creation succeeds; `false` otherwise.
|
||||
*
|
||||
* @see @ref platform_threads_function_semaphoredestroy
|
||||
*
|
||||
* <b>Example</b>
|
||||
* @code{c}
|
||||
* IotSemaphore_t sem;
|
||||
*
|
||||
* // Create a locked binary semaphore.
|
||||
* if( IotSemaphore_Create( &sem, 0, 1 ) == true )
|
||||
* {
|
||||
* // Unlock the semaphore.
|
||||
* IotSemaphore_Post( &sem );
|
||||
*
|
||||
* // Destroy the semaphore when it's no longer needed.
|
||||
* IotSemaphore_Destroy( &sem );
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
/* @[declare_platform_threads_semaphorecreate] */
|
||||
bool IotSemaphore_Create( IotSemaphore_t * pNewSemaphore,
|
||||
uint32_t initialValue,
|
||||
uint32_t maxValue );
|
||||
/* @[declare_platform_threads_semaphorecreate] */
|
||||
|
||||
/**
|
||||
* @brief Free resources used by a semaphore.
|
||||
*
|
||||
* This function frees resources used by a semaphore. It must be called on an initialized
|
||||
* #IotSemaphore_t. No other semaphore functions should be called on `pSemaphore` after
|
||||
* calling this function (unless the semaphore is re-created).
|
||||
*
|
||||
* @param[in] pSemaphore The semaphore to destroy.
|
||||
*
|
||||
* @warning This function must not be called on a semaphore with waiting threads.
|
||||
* @see @ref platform_threads_function_semaphorecreate
|
||||
*/
|
||||
/* @[declare_platform_threads_semaphoredestroy] */
|
||||
void IotSemaphore_Destroy( IotSemaphore_t * pSemaphore );
|
||||
/* @[declare_platform_threads_semaphoredestroy] */
|
||||
|
||||
/**
|
||||
* @brief Query the current count of the semaphore.
|
||||
*
|
||||
* This function queries a counting semaphore for its current value. A counting
|
||||
* semaphore's value is always 0 or positive.
|
||||
*
|
||||
* @param[in] pSemaphore The semaphore to query.
|
||||
*
|
||||
* @return The current count of the semaphore. This function should not fail.
|
||||
*/
|
||||
/* @[declare_platform_threads_semaphoregetcount] */
|
||||
uint32_t IotSemaphore_GetCount( IotSemaphore_t * pSemaphore );
|
||||
/* @[declare_platform_threads_semaphoregetcount] */
|
||||
|
||||
/**
|
||||
* @brief Wait on (lock) a semaphore. This function should only return when the
|
||||
* semaphore wait succeeds; it is not expected to fail.
|
||||
*
|
||||
* This function blocks and waits until a counting semaphore is positive. It
|
||||
* waits forever (deadlocks) if `pSemaphore` has a count `0` that is never
|
||||
* [incremented](@ref platform_threads_function_semaphorepost).
|
||||
*
|
||||
* @param[in] pSemaphore The semaphore to lock.
|
||||
*
|
||||
* @see @ref platform_threads_function_semaphoretrywait for a nonblocking wait;
|
||||
* @ref platform_threads_function_semaphoretimedwait for a wait with timeout.
|
||||
*/
|
||||
/* @[declare_platform_threads_semaphorewait] */
|
||||
void IotSemaphore_Wait( IotSemaphore_t * pSemaphore );
|
||||
/* @[declare_platform_threads_semaphorewait] */
|
||||
|
||||
/**
|
||||
* @brief Attempt to wait on (lock) a semaphore. Return immediately if the semaphore
|
||||
* is not available.
|
||||
*
|
||||
* If the count of `pSemaphore` is positive, this function immediately decrements
|
||||
* the semaphore and returns. Otherwise, this function returns without decrementing
|
||||
* `pSemaphore`.
|
||||
*
|
||||
* @param[in] pSemaphore The semaphore to lock.
|
||||
*
|
||||
* @return `true` if the semaphore wait succeeded; `false` if the semaphore has
|
||||
* a count of `0`.
|
||||
*
|
||||
* @see @ref platform_threads_function_semaphorewait for a blocking wait;
|
||||
* @ref platform_threads_function_semaphoretimedwait for a wait with timeout.
|
||||
*/
|
||||
/* @[declare_platform_threads_semaphoretrywait] */
|
||||
bool IotSemaphore_TryWait( IotSemaphore_t * pSemaphore );
|
||||
/* @[declare_platform_threads_semaphoretrywait] */
|
||||
|
||||
/**
|
||||
* @brief Attempt to wait on (lock) a semaphore with a timeout.
|
||||
*
|
||||
* This function blocks and waits until a counting semaphore is positive
|
||||
* <i>or</i> its timeout expires (whichever is sooner). It decrements
|
||||
* `pSemaphore` and returns `true` if the semaphore is positive at some
|
||||
* time during the wait. If `pSemaphore` is always `0` during the wait,
|
||||
* this function returns `false`.
|
||||
*
|
||||
* @param[in] pSemaphore The semaphore to lock.
|
||||
* @param[in] timeoutMs Relative timeout of semaphore lock. This function returns
|
||||
* false if the semaphore couldn't be locked within this timeout.
|
||||
*
|
||||
* @return `true` if the semaphore wait succeeded; `false` if it timed out.
|
||||
*
|
||||
* @see @ref platform_threads_function_semaphoretrywait for a nonblocking wait;
|
||||
* @ref platform_threads_function_semaphorewait for a blocking wait.
|
||||
*/
|
||||
/* @[declare_platform_threads_semaphoretimedwait] */
|
||||
bool IotSemaphore_TimedWait( IotSemaphore_t * pSemaphore,
|
||||
uint32_t timeoutMs );
|
||||
/* @[declare_platform_threads_semaphoretimedwait] */
|
||||
|
||||
/**
|
||||
* @brief Post to (unlock) a semaphore. This function should only return when the
|
||||
* semaphore post succeeds; it is not expected to fail.
|
||||
*
|
||||
* This function increments the count of a semaphore. Any thread may call this
|
||||
* function to increment a semaphore's count.
|
||||
*
|
||||
* @param[in] pSemaphore The semaphore to unlock.
|
||||
*/
|
||||
/* @[declare_platform_threads_semaphorepost] */
|
||||
void IotSemaphore_Post( IotSemaphore_t * pSemaphore );
|
||||
/* @[declare_platform_threads_semaphorepost] */
|
||||
|
||||
#endif /* ifndef IOT_THREADS_H_ */
|
||||
|
|
@ -0,0 +1,158 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Platform V1.0.0
|
||||
* Copyright (C) 2019 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_platform_types.h
|
||||
* @brief Types of the platform layer.
|
||||
*/
|
||||
|
||||
#ifndef IOT_PLATFORM_TYPES_H_
|
||||
#define IOT_PLATFORM_TYPES_H_
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Linear containers (lists and queues) include for metrics types. */
|
||||
#include "iot_linear_containers.h"
|
||||
|
||||
/*------------------------- Thread management types -------------------------*/
|
||||
|
||||
/**
|
||||
* @brief A value representing the system default for new thread priority.
|
||||
*/
|
||||
#ifndef IOT_THREAD_DEFAULT_PRIORITY
|
||||
#define IOT_THREAD_DEFAULT_PRIORITY 0
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief A value representhing the system default for new thread stack size.
|
||||
*/
|
||||
#ifndef IOT_THREAD_DEFAULT_STACK_SIZE
|
||||
#define IOT_THREAD_DEFAULT_STACK_SIZE 0
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @ingroup platform_datatypes_handles
|
||||
* @brief The type used to represent mutexes, configured with the type
|
||||
* `_IotSystemMutex_t`.
|
||||
*
|
||||
* <span style="color:red;font-weight:bold">
|
||||
* `_IotSystemMutex_t` will be automatically configured during build and generally
|
||||
* does not need to be defined.
|
||||
* </span>
|
||||
*
|
||||
* Mutexes should only be released by the threads that take them.
|
||||
*
|
||||
* <b>Example</b> <br>
|
||||
* To change the type of #IotMutex_t to `long`:
|
||||
* @code{c}
|
||||
* typedef long _IotSystemMutex_t;
|
||||
* #include "iot_threads.h"
|
||||
* @endcode
|
||||
*/
|
||||
typedef _IotSystemMutex_t IotMutex_t;
|
||||
|
||||
/**
|
||||
* @ingroup platform_datatypes_handles
|
||||
* @brief The type used to represent semaphores, configured with the type
|
||||
* `_IotSystemSemaphore_t`.
|
||||
*
|
||||
* <span style="color:red;font-weight:bold">
|
||||
* `_IotSystemSemaphore_t` will be automatically configured during build and
|
||||
* generally does not need to be defined.
|
||||
* </span>
|
||||
*
|
||||
* Semaphores must be counting, and any thread may take (wait on) or release
|
||||
* (post to) a semaphore.
|
||||
*
|
||||
* <b>Example</b> <br>
|
||||
* To change the type of #IotSemaphore_t to `long`:
|
||||
* @code{c}
|
||||
* typedef long _IotSystemSemaphore_t;
|
||||
* #include "iot_threads.h"
|
||||
* @endcode
|
||||
*/
|
||||
typedef _IotSystemSemaphore_t IotSemaphore_t;
|
||||
|
||||
/**
|
||||
* @brief Thread routine function.
|
||||
*
|
||||
* @param[in] void * The argument passed to the @ref
|
||||
* platform_threads_function_createdetachedthread. For application use.
|
||||
*/
|
||||
typedef void ( * IotThreadRoutine_t )( void * );
|
||||
|
||||
/*-------------------------- Clock and timer types --------------------------*/
|
||||
|
||||
/**
|
||||
* @ingroup platform_datatypes_handles
|
||||
* @brief The type used to represent timers, configured with the type
|
||||
* `_IotSystemTimer_t`.
|
||||
*
|
||||
* <span style="color:red;font-weight:bold">
|
||||
* `_IotSystemTimer_t` will be automatically configured during build and generally
|
||||
* does not need to be defined.
|
||||
* </span>
|
||||
*
|
||||
* <b>Example</b> <br>
|
||||
* To change the type of #IotTimer_t to `long`:
|
||||
* @code{c}
|
||||
* typedef long _IotSystemTimer_t;
|
||||
* #include "iot_clock.h"
|
||||
* @endcode
|
||||
*/
|
||||
typedef _IotSystemTimer_t IotTimer_t;
|
||||
|
||||
/*------------------------------ Metrics types ------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief The length of the buffer used to store IP addresses for metrics.
|
||||
*
|
||||
* This is the length of the longest IPv6 address plus space for the port number
|
||||
* and NULL terminator.
|
||||
*/
|
||||
#define IOT_METRICS_IP_ADDRESS_LENGTH 54
|
||||
|
||||
/**
|
||||
* @brief Represents a TCP connection to a remote IPv4 server.
|
||||
*
|
||||
* A list of these is provided by @ref platform_metrics_function_gettcpconnections.
|
||||
*/
|
||||
typedef struct IotMetricsTcpConnection
|
||||
{
|
||||
IotLink_t link; /**< @brief List link member. */
|
||||
void * pNetworkContext; /**< @brief Context that may be used by metrics or Defender. */
|
||||
size_t addressLength; /**< @brief The length of the address stored in #IotMetricsTcpConnection_t.pRemoteAddress. */
|
||||
|
||||
/**
|
||||
* @brief NULL-terminated IP address and port in text format.
|
||||
*
|
||||
* IPv4 addresses will be in the format `xxx.xxx.xxx.xxx:port`.
|
||||
* IPv6 addresses will be in the format `[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx]:port`.
|
||||
*/
|
||||
char pRemoteAddress[ IOT_METRICS_IP_ADDRESS_LENGTH ];
|
||||
} IotMetricsTcpConnection_t;
|
||||
|
||||
#endif /* ifndef IOT_PLATFORM_TYPES_H_ */
|
||||
Loading…
Add table
Add a link
Reference in a new issue