mirror of
https://github.com/FreeRTOS/FreeRTOS-Kernel.git
synced 2025-08-19 17:48: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,140 @@
|
|||
/*
|
||||
* 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_freertos.h
|
||||
* @brief Declares the network stack functions specified in aws_iot_network.h for
|
||||
* Amazon FreeRTOS Secure Sockets.
|
||||
*/
|
||||
|
||||
#ifndef _IOT_NETWORK_AFR_H_
|
||||
#define _IOT_NETWORK_AFR_H_
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdbool.h>
|
||||
|
||||
/* Platform network include. */
|
||||
#include "platform/iot_network.h"
|
||||
|
||||
/* Amazon FreeRTOS Secure Sockets include. */
|
||||
#include "iot_secure_sockets.h"
|
||||
|
||||
/**
|
||||
* @brief Represents a network connection that uses Amazon FreeRTOS Secure Sockets.
|
||||
*
|
||||
* This is an incomplete type. In application code, only pointers to this type
|
||||
* should be used.
|
||||
*/
|
||||
typedef struct _networkConnection IotNetworkConnectionAfr_t;
|
||||
|
||||
/**
|
||||
* @brief Provides a default value for an #IotNetworkConnectionAfr_t.
|
||||
*
|
||||
* All instances of #IotNetworkConnectionAfr_t should be initialized with
|
||||
* this constant.
|
||||
*
|
||||
* @warning Failing to initialize an #IotNetworkConnectionAfr_t with this
|
||||
* initializer may result in undefined behavior!
|
||||
* @note This initializer may change at any time in future versions, but its
|
||||
* name will remain the same.
|
||||
*/
|
||||
#define IOT_NETWORK_CONNECTION_AFR_INITIALIZER { 0 }
|
||||
|
||||
/**
|
||||
* @brief Generic initializer for an #IotNetworkServerInfo_t.
|
||||
*
|
||||
* @note This initializer may change at any time in future versions, but its
|
||||
* name will remain the same.
|
||||
*/
|
||||
#define IOT_NETWORK_SERVER_INFO_AFR_INITIALIZER { 0 }
|
||||
|
||||
/**
|
||||
* @brief Generic initializer for an #IotNetworkCredentials_t.
|
||||
*
|
||||
* @note This initializer may change at any time in future versions, but its
|
||||
* name will remain the same.
|
||||
*/
|
||||
#define IOT_NETWORK_CREDENTIALS_AFR_INITIALIZER { 0 }
|
||||
|
||||
/**
|
||||
* @brief Provides a pointer to an #IotNetworkInterface_t that uses the functions
|
||||
* declared in this file.
|
||||
*/
|
||||
#define IOT_NETWORK_INTERFACE_AFR ( &( IotNetworkAfr ) )
|
||||
|
||||
/**
|
||||
* @brief An implementation of #IotNetworkInterface_t::create for Amazon FreeRTOS
|
||||
* Secure Sockets.
|
||||
*/
|
||||
IotNetworkError_t IotNetworkAfr_Create( void * pConnectionInfo,
|
||||
void * pCredentialInfo,
|
||||
void ** const pConnection );
|
||||
|
||||
/**
|
||||
* @brief An implementation of #IotNetworkInterface_t::setReceiveCallback for
|
||||
* Amazon FreeRTOS Secure Sockets.
|
||||
*/
|
||||
IotNetworkError_t IotNetworkAfr_SetReceiveCallback( void * pConnection,
|
||||
IotNetworkReceiveCallback_t receiveCallback,
|
||||
void * pContext );
|
||||
|
||||
/**
|
||||
* @brief An implementation of #IotNetworkInterface_t::send for Amazon FreeRTOS
|
||||
* Secure Sockets.
|
||||
*/
|
||||
size_t IotNetworkAfr_Send( void * pConnection,
|
||||
const uint8_t * pMessage,
|
||||
size_t messageLength );
|
||||
|
||||
/**
|
||||
* @brief An implementation of #IotNetworkInterface_t::receive for Amazon FreeRTOS
|
||||
* Secure Sockets.
|
||||
*/
|
||||
size_t IotNetworkAfr_Receive( void * pConnection,
|
||||
uint8_t * pBuffer,
|
||||
size_t bytesRequested );
|
||||
|
||||
/**
|
||||
* @brief An implementation of #IotNetworkInterface_t::close for Amazon FreeRTOS
|
||||
* Secure Sockets.
|
||||
*/
|
||||
IotNetworkError_t IotNetworkAfr_Close( void * pConnection );
|
||||
|
||||
/**
|
||||
* @brief An implementation of #IotNetworkInterface_t::destroy for Amazon FreeRTOS
|
||||
* Secure Sockets.
|
||||
*/
|
||||
IotNetworkError_t IotNetworkAfr_Destroy( void * pConnection );
|
||||
|
||||
/**
|
||||
* @cond DOXYGEN_IGNORE
|
||||
* Doxygen should ignore this section.
|
||||
*
|
||||
* Declaration of a network interface struct using the functions in this file.
|
||||
*/
|
||||
extern const IotNetworkInterface_t IotNetworkAfr;
|
||||
/** @endcond */
|
||||
|
||||
#endif /* ifndef _IOT_NETWORK_AFR_H_ */
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
/*
|
||||
* 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_posix.h
|
||||
* @brief Definitions of platform layer types on POSIX systems.
|
||||
*/
|
||||
|
||||
#ifndef _IOT_PLATFORM_TYPES_AFR_H_
|
||||
#define _IOT_PLATFORM_TYPES_AFR_H_
|
||||
|
||||
#include "timers.h"
|
||||
|
||||
typedef struct iot_mutex_internal
|
||||
{
|
||||
StaticSemaphore_t xMutex; /**< FreeRTOS mutex. */
|
||||
BaseType_t recursive; /**< Type; used for indicating if this is reentrant or normal. */
|
||||
} iot_mutex_internal_t;
|
||||
|
||||
/**
|
||||
* @brief The native mutex type on AFR systems.
|
||||
*/
|
||||
typedef iot_mutex_internal_t _IotSystemMutex_t;
|
||||
|
||||
typedef struct iot_sem_internal
|
||||
{
|
||||
StaticSemaphore_t xSemaphore; /**< FreeRTOS semaphore. */
|
||||
} iot_sem_internal_t;
|
||||
|
||||
/**
|
||||
* @brief The native semaphore type on AFR systems.
|
||||
*/
|
||||
typedef iot_sem_internal_t _IotSystemSemaphore_t;
|
||||
|
||||
/**
|
||||
* @brief Holds information about an active detached thread so that we can
|
||||
* delete the FreeRTOS task when it completes
|
||||
*/
|
||||
typedef struct threadInfo
|
||||
{
|
||||
void * pArgument; /**< @brief Argument to `threadRoutine`. */
|
||||
void ( *threadRoutine )( void * );/**< @brief Thread function to run. */
|
||||
} threadInfo_t;
|
||||
|
||||
/**
|
||||
* @brief Holds information about an active timer.
|
||||
*/
|
||||
typedef struct timerInfo
|
||||
{
|
||||
TimerHandle_t timer; /**< @brief Underlying timer. */
|
||||
void ( *threadRoutine )( void * ); /**< @brief Thread function to run on timer expiration. */
|
||||
void * pArgument; /**< @brief First argument to threadRoutine. */
|
||||
StaticTimer_t xTimerBuffer; /**< Memory that holds the FreeRTOS timer. */
|
||||
TickType_t xTimerPeriod; /**< Period of this timer. */
|
||||
} timerInfo_t;
|
||||
|
||||
/**
|
||||
* @brief Represents an #IotTimer_t on AFR systems.
|
||||
*/
|
||||
typedef timerInfo_t _IotSystemTimer_t;
|
||||
|
||||
#endif /* ifndef _IOT_PLATFORM_TYPES_POSIX_H_ */
|
||||
|
|
@ -0,0 +1,224 @@
|
|||
/*
|
||||
* 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_freertos.c
|
||||
* @brief Implementation of the functions in iot_clock.h for Amazon FreeRTOS systems.
|
||||
*/
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdio.h>
|
||||
|
||||
/* Platform clock include. */
|
||||
#include "platform/iot_platform_types_freertos.h"
|
||||
#include "platform/iot_clock.h"
|
||||
#include "task.h"
|
||||
|
||||
/* Configure logs for the functions in this file. */
|
||||
#ifdef IOT_LOG_LEVEL_PLATFORM
|
||||
#define LIBRARY_LOG_LEVEL IOT_LOG_LEVEL_PLATFORM
|
||||
#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 ( "CLOCK" )
|
||||
#include "iot_logging_setup.h"
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Time conversion constants.
|
||||
*/
|
||||
#define _MILLISECONDS_PER_SECOND ( 1000 ) /**< @brief Milliseconds per second. */
|
||||
#define _MILLISECONDS_PER_TICK ( _MILLISECONDS_PER_SECOND / configTICK_RATE_HZ ) /**< Milliseconds per FreeRTOS tick. */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Private Callback function for timer expiry, delegate work to a Task to free
|
||||
* up the timer task for managing other timers */
|
||||
static void prvTimerCallback( TimerHandle_t xTimerHandle )
|
||||
{
|
||||
_IotSystemTimer_t * pxTimer = ( _IotSystemTimer_t * ) pvTimerGetTimerID( xTimerHandle );
|
||||
|
||||
/* The value of the timer ID, set in timer_create, should not be NULL. */
|
||||
configASSERT( pxTimer != NULL );
|
||||
|
||||
/* Restart the timer if it is periodic. */
|
||||
if( pxTimer->xTimerPeriod > 0 )
|
||||
{
|
||||
xTimerChangePeriod( xTimerHandle, pxTimer->xTimerPeriod, 0 );
|
||||
}
|
||||
|
||||
/* Call timer Callback from this task */
|
||||
pxTimer->threadRoutine( ( void * ) pxTimer->pArgument );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotClock_GetTimestring( char * pBuffer,
|
||||
size_t bufferSize,
|
||||
size_t * pTimestringLength )
|
||||
{
|
||||
uint64_t milliSeconds = IotClock_GetTimeMs();
|
||||
int timestringLength = 0;
|
||||
|
||||
configASSERT( pBuffer != NULL );
|
||||
configASSERT( pTimestringLength != NULL );
|
||||
|
||||
/* Convert the localTime struct to a string. */
|
||||
timestringLength = snprintf( pBuffer, bufferSize, "%llu", milliSeconds );
|
||||
|
||||
/* Check for error from no string */
|
||||
if( timestringLength == 0 )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Set the output parameter. */
|
||||
*pTimestringLength = timestringLength;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
uint64_t IotClock_GetTimeMs( void )
|
||||
{
|
||||
TimeOut_t xCurrentTime = { 0 };
|
||||
|
||||
/* This must be unsigned because the behavior of signed integer overflow is undefined. */
|
||||
uint64_t ullTickCount = 0ULL;
|
||||
|
||||
/* Get the current tick count and overflow count. vTaskSetTimeOutState()
|
||||
* is used to get these values because they are both static in tasks.c. */
|
||||
vTaskSetTimeOutState( &xCurrentTime );
|
||||
|
||||
/* Adjust the tick count for the number of times a TickType_t has overflowed. */
|
||||
ullTickCount = ( uint64_t ) ( xCurrentTime.xOverflowCount ) << ( sizeof( TickType_t ) * 8 );
|
||||
|
||||
/* Add the current tick count. */
|
||||
ullTickCount += xCurrentTime.xTimeOnEntering;
|
||||
|
||||
/* Return the ticks converted to Milliseconds */
|
||||
return ullTickCount * _MILLISECONDS_PER_TICK;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotClock_SleepMs( uint32_t sleepTimeMs )
|
||||
{
|
||||
vTaskDelay( pdMS_TO_TICKS( sleepTimeMs ) );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotClock_TimerCreate( IotTimer_t * pNewTimer,
|
||||
IotThreadRoutine_t expirationRoutine,
|
||||
void * pArgument )
|
||||
{
|
||||
_IotSystemTimer_t * pxTimer = ( _IotSystemTimer_t * ) pNewTimer;
|
||||
|
||||
configASSERT( pNewTimer != NULL );
|
||||
configASSERT( expirationRoutine != NULL );
|
||||
|
||||
IotLogDebug( "Creating new timer %p.", pNewTimer );
|
||||
|
||||
/* Set the timer expiration routine, argument and period */
|
||||
pxTimer->threadRoutine = expirationRoutine;
|
||||
pxTimer->pArgument = pArgument;
|
||||
pxTimer->xTimerPeriod = 0;
|
||||
|
||||
/* Create a new FreeRTOS timer. This call will not fail because the
|
||||
* memory for it has already been allocated, so the output parameter is
|
||||
* also set. */
|
||||
pxTimer->timer = ( TimerHandle_t ) xTimerCreateStatic( "timer", /* Timer name. */
|
||||
portMAX_DELAY, /* Initial timer period. Timers are created disarmed. */
|
||||
pdFALSE, /* Don't auto-reload timer. */
|
||||
( void * ) pxTimer, /* Timer id. */
|
||||
prvTimerCallback, /* Timer expiration callback. */
|
||||
&pxTimer->xTimerBuffer ); /* Pre-allocated memory for timer. */
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotClock_TimerDestroy( IotTimer_t * pTimer )
|
||||
{
|
||||
_IotSystemTimer_t * pTimerInfo = ( _IotSystemTimer_t * ) pTimer;
|
||||
|
||||
configASSERT( pTimerInfo != NULL );
|
||||
configASSERT( pTimerInfo->timer != NULL );
|
||||
|
||||
IotLogDebug( "Destroying timer %p.", pTimer );
|
||||
|
||||
if( xTimerIsTimerActive( pTimerInfo->timer ) == pdTRUE )
|
||||
{
|
||||
/* Stop the FreeRTOS timer. Because the timer is statically allocated, no call
|
||||
* to xTimerDelete is necessary. The timer is stopped so that it's not referenced
|
||||
* anywhere. xTimerStop will not fail when it has unlimited block time. */
|
||||
( void ) xTimerStop( pTimerInfo->timer, portMAX_DELAY );
|
||||
|
||||
/* Wait until the timer stop command is processed. */
|
||||
while( xTimerIsTimerActive( pTimerInfo->timer ) == pdTRUE )
|
||||
{
|
||||
vTaskDelay( 1 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotClock_TimerArm( IotTimer_t * pTimer,
|
||||
uint32_t relativeTimeoutMs,
|
||||
uint32_t periodMs )
|
||||
{
|
||||
_IotSystemTimer_t * pTimerInfo = ( _IotSystemTimer_t * ) pTimer;
|
||||
|
||||
configASSERT( pTimerInfo != NULL );
|
||||
|
||||
TimerHandle_t xTimerHandle = pTimerInfo->timer;
|
||||
|
||||
IotLogDebug( "Arming timer %p with timeout %llu and period %llu.",
|
||||
pTimer,
|
||||
relativeTimeoutMs,
|
||||
periodMs );
|
||||
|
||||
/* Set the timer period in ticks */
|
||||
pTimerInfo->xTimerPeriod = pdMS_TO_TICKS( periodMs );
|
||||
|
||||
/* Set the timer to expire after relativeTimeoutMs, and restart it. */
|
||||
( void ) xTimerChangePeriod( xTimerHandle, pdMS_TO_TICKS( relativeTimeoutMs ), portMAX_DELAY );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
|
@ -0,0 +1,627 @@
|
|||
/*
|
||||
* 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_freertos.c
|
||||
* @brief Implementation of the network-related functions from iot_network_freertos.h
|
||||
* for Amazon FreeRTOS secure sockets.
|
||||
*/
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <string.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "semphr.h"
|
||||
#include "event_groups.h"
|
||||
|
||||
/* Error handling include. */
|
||||
#include "private/iot_error.h"
|
||||
|
||||
/* Amazon FreeRTOS network include. */
|
||||
#include "platform/iot_network_freertos.h"
|
||||
|
||||
/* Configure logs for the functions in this file. */
|
||||
#ifdef IOT_LOG_LEVEL_NETWORK
|
||||
#define LIBRARY_LOG_LEVEL IOT_LOG_LEVEL_NETWORK
|
||||
#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 ( "NET" )
|
||||
#include "iot_logging_setup.h"
|
||||
|
||||
/* Provide a default value for the number of milliseconds for a socket poll.
|
||||
* This is a temporary workaround to deal with the lack of poll(). */
|
||||
#ifndef IOT_NETWORK_SOCKET_POLL_MS
|
||||
#define IOT_NETWORK_SOCKET_POLL_MS ( 1000 )
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief The event group bit to set when a connection's socket is shut down.
|
||||
*/
|
||||
#define _FLAG_SHUTDOWN ( 1 )
|
||||
|
||||
/**
|
||||
* @brief The event group bit to set when a connection's receive task exits.
|
||||
*/
|
||||
#define _FLAG_RECEIVE_TASK_EXITED ( 2 )
|
||||
|
||||
/**
|
||||
* @brief The event group bit to set when the connection is destroyed from the
|
||||
* receive task.
|
||||
*/
|
||||
#define _FLAG_CONNECTION_DESTROYED ( 4 )
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
typedef struct _networkConnection
|
||||
{
|
||||
Socket_t socket; /**< @brief Amazon FreeRTOS Secure Sockets handle. */
|
||||
StaticSemaphore_t socketMutex; /**< @brief Prevents concurrent threads from sending on a socket. */
|
||||
StaticEventGroup_t connectionFlags; /**< @brief Synchronizes with the receive task. */
|
||||
TaskHandle_t receiveTask; /**< @brief Handle of the receive task, if any. */
|
||||
IotNetworkReceiveCallback_t receiveCallback; /**< @brief Network receive callback, if any. */
|
||||
void * pReceiveContext; /**< @brief The context for the receive callback. */
|
||||
bool bufferedByteValid; /**< @brief Used to determine if the buffered byte is valid. */
|
||||
uint8_t bufferedByte; /**< @brief A single byte buffered from a receive, since AFR Secure Sockets does not have poll(). */
|
||||
} _networkConnection_t;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief An #IotNetworkInterface_t that uses the functions in this file.
|
||||
*/
|
||||
const IotNetworkInterface_t IotNetworkAfr =
|
||||
{
|
||||
.create = IotNetworkAfr_Create,
|
||||
.setReceiveCallback = IotNetworkAfr_SetReceiveCallback,
|
||||
.send = IotNetworkAfr_Send,
|
||||
.receive = IotNetworkAfr_Receive,
|
||||
.close = IotNetworkAfr_Close,
|
||||
.destroy = IotNetworkAfr_Destroy
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Destroys a network connection.
|
||||
*
|
||||
* @param[in] pNetworkConnection The connection to destroy.
|
||||
*/
|
||||
static void _destroyConnection( _networkConnection_t * pNetworkConnection )
|
||||
{
|
||||
/* Call Secure Sockets close function to free resources. */
|
||||
int32_t socketStatus = SOCKETS_Close( pNetworkConnection->socket );
|
||||
|
||||
if( socketStatus != SOCKETS_ERROR_NONE )
|
||||
{
|
||||
IotLogWarn( "Failed to destroy connection." );
|
||||
}
|
||||
|
||||
/* Free the network connection. */
|
||||
vPortFree( pNetworkConnection );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Task routine that waits on incoming network data.
|
||||
*
|
||||
* @param[in] pArgument The network connection.
|
||||
*/
|
||||
static void _networkReceiveTask( void * pArgument )
|
||||
{
|
||||
bool destroyConnection = false;
|
||||
int32_t socketStatus = 0;
|
||||
EventBits_t connectionFlags = 0;
|
||||
|
||||
/* Cast network connection to the correct type. */
|
||||
_networkConnection_t * pNetworkConnection = pArgument;
|
||||
|
||||
while( true )
|
||||
{
|
||||
/* No buffered byte should be in the connection. */
|
||||
configASSERT( pNetworkConnection->bufferedByteValid == false );
|
||||
|
||||
/* Block and wait for 1 byte of data. This simulates the behavior of poll().
|
||||
* THIS IS A TEMPORARY WORKAROUND AND DOES NOT PROVIDE THREAD-SAFETY AGAINST
|
||||
* MULTIPLE CALLS OF RECEIVE. */
|
||||
do
|
||||
{
|
||||
socketStatus = SOCKETS_Recv( pNetworkConnection->socket,
|
||||
&( pNetworkConnection->bufferedByte ),
|
||||
1,
|
||||
0 );
|
||||
|
||||
connectionFlags = xEventGroupGetBits( ( EventGroupHandle_t ) &( pNetworkConnection->connectionFlags ) );
|
||||
|
||||
if( ( connectionFlags & _FLAG_SHUTDOWN ) == _FLAG_SHUTDOWN )
|
||||
{
|
||||
socketStatus = SOCKETS_ECLOSED;
|
||||
}
|
||||
|
||||
/* Check for timeout. Some ports return 0, some return EWOULDBLOCK. */
|
||||
} while( ( socketStatus == 0 ) || ( socketStatus == SOCKETS_EWOULDBLOCK ) );
|
||||
|
||||
if( socketStatus <= 0 )
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
pNetworkConnection->bufferedByteValid = true;
|
||||
|
||||
/* Invoke the network callback. */
|
||||
pNetworkConnection->receiveCallback( pNetworkConnection,
|
||||
pNetworkConnection->pReceiveContext );
|
||||
|
||||
/* Check if the connection was destroyed by the receive callback. This
|
||||
* does not need to be thread-safe because the destroy connection function
|
||||
* may only be called once (per its API doc). */
|
||||
connectionFlags = xEventGroupGetBits( ( EventGroupHandle_t ) &( pNetworkConnection->connectionFlags ) );
|
||||
|
||||
if( ( connectionFlags & _FLAG_CONNECTION_DESTROYED ) == _FLAG_CONNECTION_DESTROYED )
|
||||
{
|
||||
destroyConnection = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
IotLogDebug( "Network receive task terminating." );
|
||||
|
||||
/* If necessary, destroy the network connection before exiting. */
|
||||
if( destroyConnection == true )
|
||||
{
|
||||
_destroyConnection( pNetworkConnection );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Set the flag to indicate that the receive task has exited. */
|
||||
( void ) xEventGroupSetBits( ( EventGroupHandle_t ) &( pNetworkConnection->connectionFlags ),
|
||||
_FLAG_RECEIVE_TASK_EXITED );
|
||||
}
|
||||
|
||||
vTaskDelete( NULL );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Set up a secured TLS connection.
|
||||
*
|
||||
* @param[in] pAfrCredentials Credentials for the secured connection.
|
||||
* @param[in] tcpSocket An initialized socket to secure.
|
||||
* @param[in] pHostName Remote server name for SNI.
|
||||
* @param[in] hostnameLength The length of `pHostName`.
|
||||
*
|
||||
* @return #IOT_NETWORK_SUCCESS or #IOT_NETWORK_SYSTEM_ERROR.
|
||||
*/
|
||||
static IotNetworkError_t _tlsSetup( const IotNetworkCredentials_t * pAfrCredentials,
|
||||
Socket_t tcpSocket,
|
||||
const char * pHostName,
|
||||
size_t hostnameLength )
|
||||
{
|
||||
IOT_FUNCTION_ENTRY( IotNetworkError_t, IOT_NETWORK_SUCCESS );
|
||||
int32_t socketStatus = SOCKETS_ERROR_NONE;
|
||||
|
||||
/* ALPN options for AWS IoT. */
|
||||
const char * ppcALPNProtos[] = { socketsAWS_IOT_ALPN_MQTT };
|
||||
|
||||
/* Set secured option. */
|
||||
socketStatus = SOCKETS_SetSockOpt( tcpSocket,
|
||||
0,
|
||||
SOCKETS_SO_REQUIRE_TLS,
|
||||
NULL,
|
||||
0 );
|
||||
|
||||
if( socketStatus != SOCKETS_ERROR_NONE )
|
||||
{
|
||||
IotLogError( "Failed to set secured option for new connection." );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_SYSTEM_ERROR );
|
||||
}
|
||||
|
||||
/* Set ALPN option. */
|
||||
if( pAfrCredentials->pAlpnProtos != NULL )
|
||||
{
|
||||
socketStatus = SOCKETS_SetSockOpt( tcpSocket,
|
||||
0,
|
||||
SOCKETS_SO_ALPN_PROTOCOLS,
|
||||
ppcALPNProtos,
|
||||
sizeof( ppcALPNProtos ) / sizeof( ppcALPNProtos[ 0 ] ) );
|
||||
|
||||
if( socketStatus != SOCKETS_ERROR_NONE )
|
||||
{
|
||||
IotLogError( "Failed to set ALPN option for new connection." );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_SYSTEM_ERROR );
|
||||
}
|
||||
}
|
||||
|
||||
/* Set SNI option. */
|
||||
if( pAfrCredentials->disableSni == false )
|
||||
{
|
||||
socketStatus = SOCKETS_SetSockOpt( tcpSocket,
|
||||
0,
|
||||
SOCKETS_SO_SERVER_NAME_INDICATION,
|
||||
pHostName,
|
||||
hostnameLength + 1 );
|
||||
|
||||
if( socketStatus != SOCKETS_ERROR_NONE )
|
||||
{
|
||||
IotLogError( "Failed to set SNI option for new connection." );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_SYSTEM_ERROR );
|
||||
}
|
||||
}
|
||||
|
||||
/* Set custom server certificate. */
|
||||
if( pAfrCredentials->pRootCa != NULL )
|
||||
{
|
||||
socketStatus = SOCKETS_SetSockOpt( tcpSocket,
|
||||
0,
|
||||
SOCKETS_SO_TRUSTED_SERVER_CERTIFICATE,
|
||||
pAfrCredentials->pRootCa,
|
||||
pAfrCredentials->rootCaSize );
|
||||
|
||||
if( socketStatus != SOCKETS_ERROR_NONE )
|
||||
{
|
||||
IotLogError( "Failed to set server certificate option for new connection." );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_SYSTEM_ERROR );
|
||||
}
|
||||
}
|
||||
|
||||
IOT_FUNCTION_EXIT_NO_CLEANUP();
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
IotNetworkError_t IotNetworkAfr_Create( void * pConnectionInfo,
|
||||
void * pCredentialInfo,
|
||||
void ** pConnection )
|
||||
{
|
||||
IOT_FUNCTION_ENTRY( IotNetworkError_t, IOT_NETWORK_SUCCESS );
|
||||
Socket_t tcpSocket = SOCKETS_INVALID_SOCKET;
|
||||
int32_t socketStatus = SOCKETS_ERROR_NONE;
|
||||
SocketsSockaddr_t serverAddress = { 0 };
|
||||
EventGroupHandle_t pConnectionFlags = NULL;
|
||||
SemaphoreHandle_t pConnectionMutex = NULL;
|
||||
const TickType_t receiveTimeout = pdMS_TO_TICKS( IOT_NETWORK_SOCKET_POLL_MS );
|
||||
_networkConnection_t * pNewNetworkConnection = NULL;
|
||||
|
||||
/* Cast function parameters to correct types. */
|
||||
const IotNetworkServerInfo_t * pServerInfo = pConnectionInfo;
|
||||
const IotNetworkCredentials_t * pAfrCredentials = pCredentialInfo;
|
||||
_networkConnection_t ** pNetworkConnection = ( _networkConnection_t ** ) pConnection;
|
||||
|
||||
/* Check host name length against the maximum length allowed by Secure
|
||||
* Sockets. */
|
||||
const size_t hostnameLength = strlen( pServerInfo->pHostName );
|
||||
|
||||
if( hostnameLength > ( size_t ) securesocketsMAX_DNS_NAME_LENGTH )
|
||||
{
|
||||
IotLogError( "Host name length exceeds %d, which is the maximum allowed.",
|
||||
securesocketsMAX_DNS_NAME_LENGTH );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_BAD_PARAMETER );
|
||||
}
|
||||
|
||||
pNewNetworkConnection = pvPortMalloc( sizeof( _networkConnection_t ) );
|
||||
|
||||
if( pNewNetworkConnection == NULL )
|
||||
{
|
||||
IotLogError( "Failed to allocate memory for new network connection." );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_NO_MEMORY );
|
||||
}
|
||||
|
||||
/* Clear the connection information. */
|
||||
( void ) memset( pNewNetworkConnection, 0x00, sizeof( _networkConnection_t ) );
|
||||
|
||||
/* Create a new TCP socket. */
|
||||
tcpSocket = SOCKETS_Socket( SOCKETS_AF_INET,
|
||||
SOCKETS_SOCK_STREAM,
|
||||
SOCKETS_IPPROTO_TCP );
|
||||
|
||||
if( tcpSocket == SOCKETS_INVALID_SOCKET )
|
||||
{
|
||||
IotLogError( "Failed to create new socket." );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_SYSTEM_ERROR );
|
||||
}
|
||||
|
||||
/* Set up connection encryption if credentials are provided. */
|
||||
if( pAfrCredentials != NULL )
|
||||
{
|
||||
status = _tlsSetup( pAfrCredentials, tcpSocket, pServerInfo->pHostName, hostnameLength );
|
||||
|
||||
if( status != IOT_NETWORK_SUCCESS )
|
||||
{
|
||||
IOT_GOTO_CLEANUP();
|
||||
}
|
||||
}
|
||||
|
||||
/* Establish connection. */
|
||||
serverAddress.ucSocketDomain = SOCKETS_AF_INET;
|
||||
serverAddress.usPort = SOCKETS_htons( pServerInfo->port );
|
||||
serverAddress.ulAddress = SOCKETS_GetHostByName( pServerInfo->pHostName );
|
||||
|
||||
/* Check for errors from DNS lookup. */
|
||||
if( serverAddress.ulAddress == 0 )
|
||||
{
|
||||
IotLogError( "Failed to resolve %s.", pServerInfo->pHostName );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_SYSTEM_ERROR );
|
||||
}
|
||||
|
||||
socketStatus = SOCKETS_Connect( tcpSocket,
|
||||
&serverAddress,
|
||||
sizeof( SocketsSockaddr_t ) );
|
||||
|
||||
if( socketStatus != SOCKETS_ERROR_NONE )
|
||||
{
|
||||
IotLogError( "Failed to establish new connection." );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_SYSTEM_ERROR );
|
||||
}
|
||||
|
||||
/* Set a long timeout for receive. */
|
||||
socketStatus = SOCKETS_SetSockOpt( tcpSocket,
|
||||
0,
|
||||
SOCKETS_SO_RCVTIMEO,
|
||||
&receiveTimeout,
|
||||
sizeof( TickType_t ) );
|
||||
|
||||
if( socketStatus != SOCKETS_ERROR_NONE )
|
||||
{
|
||||
IotLogError( "Failed to set socket receive timeout." );
|
||||
IOT_SET_AND_GOTO_CLEANUP( IOT_NETWORK_SYSTEM_ERROR );
|
||||
}
|
||||
|
||||
IOT_FUNCTION_CLEANUP_BEGIN();
|
||||
|
||||
/* Clean up on failure. */
|
||||
if( status != IOT_NETWORK_SUCCESS )
|
||||
{
|
||||
if( tcpSocket != SOCKETS_INVALID_SOCKET )
|
||||
{
|
||||
SOCKETS_Close( tcpSocket );
|
||||
}
|
||||
|
||||
/* Clear the connection information. */
|
||||
if( pNewNetworkConnection != NULL )
|
||||
{
|
||||
vPortFree( pNewNetworkConnection );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Set the socket. */
|
||||
pNewNetworkConnection->socket = tcpSocket;
|
||||
|
||||
/* Create the connection event flags and mutex. */
|
||||
pConnectionFlags = xEventGroupCreateStatic( &( pNewNetworkConnection->connectionFlags ) );
|
||||
pConnectionMutex = xSemaphoreCreateMutexStatic( &( pNewNetworkConnection->socketMutex ) );
|
||||
|
||||
/* Static event flags and mutex creation should never fail. The handles
|
||||
* should point inside the connection object. */
|
||||
configASSERT( pConnectionFlags == ( EventGroupHandle_t ) &( pNewNetworkConnection->connectionFlags ) );
|
||||
configASSERT( pConnectionMutex == ( SemaphoreHandle_t ) &( pNewNetworkConnection->socketMutex ) );
|
||||
|
||||
/* Set the output parameter. */
|
||||
*pNetworkConnection = pNewNetworkConnection;
|
||||
}
|
||||
|
||||
IOT_FUNCTION_CLEANUP_END();
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
IotNetworkError_t IotNetworkAfr_SetReceiveCallback( void * pConnection,
|
||||
IotNetworkReceiveCallback_t receiveCallback,
|
||||
void * pContext )
|
||||
{
|
||||
IotNetworkError_t status = IOT_NETWORK_SUCCESS;
|
||||
|
||||
/* Cast network connection to the correct type. */
|
||||
_networkConnection_t * pNetworkConnection = ( _networkConnection_t * ) pConnection;
|
||||
|
||||
/* Set the receive callback and context. */
|
||||
pNetworkConnection->receiveCallback = receiveCallback;
|
||||
pNetworkConnection->pReceiveContext = pContext;
|
||||
|
||||
/* No flags should be set. */
|
||||
configASSERT( xEventGroupGetBits( ( EventGroupHandle_t ) &( pNetworkConnection->connectionFlags ) ) == 0 );
|
||||
|
||||
/* Create task that waits for incoming data. */
|
||||
if( xTaskCreate( _networkReceiveTask,
|
||||
"NetRecv",
|
||||
IOT_NETWORK_RECEIVE_TASK_STACK_SIZE,
|
||||
pNetworkConnection,
|
||||
IOT_NETWORK_RECEIVE_TASK_PRIORITY,
|
||||
&( pNetworkConnection->receiveTask ) ) != pdPASS )
|
||||
{
|
||||
IotLogError( "Failed to create network receive task." );
|
||||
|
||||
status = IOT_NETWORK_SYSTEM_ERROR;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
size_t IotNetworkAfr_Send( void * pConnection,
|
||||
const uint8_t * pMessage,
|
||||
size_t messageLength )
|
||||
{
|
||||
size_t bytesSent = 0;
|
||||
int32_t socketStatus = SOCKETS_ERROR_NONE;
|
||||
|
||||
/* Cast network connection to the correct type. */
|
||||
_networkConnection_t * pNetworkConnection = ( _networkConnection_t * ) pConnection;
|
||||
|
||||
/* Only one thread at a time may send on the connection. Lock the socket
|
||||
* mutex to prevent other threads from sending. */
|
||||
if( xSemaphoreTake( ( QueueHandle_t ) &( pNetworkConnection->socketMutex ),
|
||||
portMAX_DELAY ) == pdTRUE )
|
||||
{
|
||||
socketStatus = SOCKETS_Send( pNetworkConnection->socket,
|
||||
pMessage,
|
||||
messageLength,
|
||||
0 );
|
||||
|
||||
if( socketStatus > 0 )
|
||||
{
|
||||
bytesSent = ( size_t ) socketStatus;
|
||||
}
|
||||
|
||||
xSemaphoreGive( ( QueueHandle_t ) &( pNetworkConnection->socketMutex ) );
|
||||
}
|
||||
|
||||
return bytesSent;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
size_t IotNetworkAfr_Receive( void * pConnection,
|
||||
uint8_t * pBuffer,
|
||||
size_t bytesRequested )
|
||||
{
|
||||
int32_t socketStatus = 0;
|
||||
size_t bytesReceived = 0, bytesRemaining = bytesRequested;
|
||||
|
||||
/* Cast network connection to the correct type. */
|
||||
_networkConnection_t * pNetworkConnection = ( _networkConnection_t * ) pConnection;
|
||||
|
||||
/* Write the buffered byte. THIS IS A TEMPORARY WORKAROUND AND ASSUMES THIS
|
||||
* FUNCTION IS ALWAYS CALLED FROM THE RECEIVE CALLBACK. */
|
||||
if( pNetworkConnection->bufferedByteValid == true )
|
||||
{
|
||||
*pBuffer = pNetworkConnection->bufferedByte;
|
||||
bytesReceived = 1;
|
||||
bytesRemaining--;
|
||||
pNetworkConnection->bufferedByteValid = false;
|
||||
}
|
||||
|
||||
/* Block and wait for incoming data. */
|
||||
while( bytesRemaining > 0 )
|
||||
{
|
||||
socketStatus = SOCKETS_Recv( pNetworkConnection->socket,
|
||||
pBuffer + bytesReceived,
|
||||
bytesRemaining,
|
||||
0 );
|
||||
|
||||
if( socketStatus == SOCKETS_EWOULDBLOCK )
|
||||
{
|
||||
/* The return value EWOULDBLOCK means no data was received within
|
||||
* the socket timeout. Ignore it and try again. */
|
||||
continue;
|
||||
}
|
||||
else if( socketStatus <= 0 )
|
||||
{
|
||||
IotLogError( "Error %ld while receiving data.", ( long int ) socketStatus );
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
bytesReceived += ( size_t ) socketStatus;
|
||||
bytesRemaining -= ( size_t ) socketStatus;
|
||||
|
||||
configASSERT( bytesReceived + bytesRemaining == bytesRequested );
|
||||
}
|
||||
}
|
||||
|
||||
if( bytesReceived < bytesRequested )
|
||||
{
|
||||
IotLogWarn( "Receive requested %lu bytes, but %lu bytes received instead.",
|
||||
( unsigned long ) bytesRequested,
|
||||
( unsigned long ) bytesReceived );
|
||||
}
|
||||
else
|
||||
{
|
||||
IotLogDebug( "Successfully received %lu bytes.",
|
||||
( unsigned long ) bytesRequested );
|
||||
}
|
||||
|
||||
return bytesReceived;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
IotNetworkError_t IotNetworkAfr_Close( void * pConnection )
|
||||
{
|
||||
int32_t socketStatus = SOCKETS_ERROR_NONE;
|
||||
|
||||
/* Cast network connection to the correct type. */
|
||||
_networkConnection_t * pNetworkConnection = ( _networkConnection_t * ) pConnection;
|
||||
|
||||
/* Call Secure Sockets shutdown function to close connection. */
|
||||
socketStatus = SOCKETS_Shutdown( pNetworkConnection->socket,
|
||||
SOCKETS_SHUT_RDWR );
|
||||
|
||||
if( socketStatus != SOCKETS_ERROR_NONE )
|
||||
{
|
||||
IotLogWarn( "Failed to close connection." );
|
||||
}
|
||||
|
||||
/* Set the shutdown flag. */
|
||||
( void ) xEventGroupSetBits( ( EventGroupHandle_t ) &( pNetworkConnection->connectionFlags ),
|
||||
_FLAG_SHUTDOWN );
|
||||
|
||||
return IOT_NETWORK_SUCCESS;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
IotNetworkError_t IotNetworkAfr_Destroy( void * pConnection )
|
||||
{
|
||||
/* Cast network connection to the correct type. */
|
||||
_networkConnection_t * pNetworkConnection = ( _networkConnection_t * ) pConnection;
|
||||
|
||||
/* Check if this function is being called from the receive task. */
|
||||
if( xTaskGetCurrentTaskHandle() == pNetworkConnection->receiveTask )
|
||||
{
|
||||
/* Set the flag specifying that the connection is destroyed. */
|
||||
( void ) xEventGroupSetBits( ( EventGroupHandle_t ) &( pNetworkConnection->connectionFlags ),
|
||||
_FLAG_CONNECTION_DESTROYED );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* If a receive task was created, wait for it to exit. */
|
||||
if( pNetworkConnection->receiveTask != NULL )
|
||||
{
|
||||
( void ) xEventGroupWaitBits( ( EventGroupHandle_t ) &( pNetworkConnection->connectionFlags ),
|
||||
_FLAG_RECEIVE_TASK_EXITED,
|
||||
pdTRUE,
|
||||
pdTRUE,
|
||||
portMAX_DELAY );
|
||||
}
|
||||
|
||||
_destroyConnection( pNetworkConnection );
|
||||
}
|
||||
|
||||
return IOT_NETWORK_SUCCESS;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
|
@ -0,0 +1,364 @@
|
|||
/*
|
||||
* 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_freertos.c
|
||||
* @brief Implementation of the functions in iot_threads.h for POSIX systems.
|
||||
*/
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
#include "semphr.h"
|
||||
|
||||
/* Platform threads include. */
|
||||
#include "platform/iot_platform_types_freertos.h"
|
||||
#include "platform/iot_threads.h"
|
||||
#include "types/iot_platform_types.h"
|
||||
|
||||
/* Configure logs for the functions in this file. */
|
||||
#ifdef IOT_LOG_LEVEL_PLATFORM
|
||||
#define LIBRARY_LOG_LEVEL IOT_LOG_LEVEL_PLATFORM
|
||||
#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 ( "THREAD" )
|
||||
#include "iot_logging_setup.h"
|
||||
|
||||
/*
|
||||
* Provide default values for undefined memory allocation functions based on
|
||||
* the usage of dynamic memory allocation.
|
||||
*/
|
||||
#ifndef IotThreads_Malloc
|
||||
#include <stdlib.h>
|
||||
|
||||
/**
|
||||
* @brief Memory allocation. This function should have the same signature
|
||||
* as [malloc](http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html).
|
||||
*/
|
||||
#define IotThreads_Malloc malloc
|
||||
#endif
|
||||
#ifndef IotThreads_Free
|
||||
#include <stdlib.h>
|
||||
|
||||
/**
|
||||
* @brief Free memory. This function should have the same signature as
|
||||
* [free](http://pubs.opengroup.org/onlinepubs/9699919799/functions/free.html).
|
||||
*/
|
||||
#define IotThreads_Free free
|
||||
#endif
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void _threadRoutineWrapper( void * pArgument )
|
||||
{
|
||||
threadInfo_t * pThreadInfo = ( threadInfo_t * ) pArgument;
|
||||
|
||||
/* Run the thread routine. */
|
||||
pThreadInfo->threadRoutine( pThreadInfo->pArgument );
|
||||
IotThreads_Free( pThreadInfo );
|
||||
|
||||
vTaskDelete( NULL );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool Iot_CreateDetachedThread( IotThreadRoutine_t threadRoutine,
|
||||
void * pArgument,
|
||||
int32_t priority,
|
||||
size_t stackSize )
|
||||
{
|
||||
bool status = true;
|
||||
|
||||
configASSERT( threadRoutine != NULL );
|
||||
|
||||
IotLogDebug( "Creating new thread." );
|
||||
threadInfo_t * pThreadInfo = IotThreads_Malloc( sizeof( threadInfo_t ) );
|
||||
|
||||
if( pThreadInfo == NULL )
|
||||
{
|
||||
IotLogDebug( "Unable to allocate memory for threadRoutine %p.", threadRoutine );
|
||||
status = false;
|
||||
}
|
||||
|
||||
/* Create the FreeRTOS task that will run the thread. */
|
||||
if( status )
|
||||
{
|
||||
pThreadInfo->threadRoutine = threadRoutine;
|
||||
pThreadInfo->pArgument = pArgument;
|
||||
|
||||
if( xTaskCreate( _threadRoutineWrapper,
|
||||
"iot_thread",
|
||||
( configSTACK_DEPTH_TYPE ) stackSize,
|
||||
pThreadInfo,
|
||||
priority,
|
||||
NULL ) != pdPASS )
|
||||
{
|
||||
/* Task creation failed. */
|
||||
IotLogWarn( "Failed to create thread." );
|
||||
IotThreads_Free( pThreadInfo );
|
||||
status = false;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotMutex_Create( IotMutex_t * pNewMutex,
|
||||
bool recursive )
|
||||
{
|
||||
_IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pNewMutex;
|
||||
|
||||
configASSERT( internalMutex != NULL );
|
||||
|
||||
IotLogDebug( "Creating new mutex %p.", pNewMutex );
|
||||
|
||||
if( recursive )
|
||||
{
|
||||
( void ) xSemaphoreCreateRecursiveMutexStatic( &internalMutex->xMutex );
|
||||
}
|
||||
else
|
||||
{
|
||||
( void ) xSemaphoreCreateMutexStatic( &internalMutex->xMutex );
|
||||
}
|
||||
|
||||
/* remember the type of mutex */
|
||||
if( recursive )
|
||||
{
|
||||
internalMutex->recursive = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
internalMutex->recursive = pdFALSE;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotMutex_Destroy( IotMutex_t * pMutex )
|
||||
{
|
||||
_IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pMutex;
|
||||
|
||||
configASSERT( internalMutex != NULL );
|
||||
|
||||
vSemaphoreDelete( ( SemaphoreHandle_t ) &internalMutex->xMutex );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool prIotMutexTimedLock( IotMutex_t * pMutex,
|
||||
TickType_t timeout )
|
||||
{
|
||||
_IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pMutex;
|
||||
BaseType_t lockResult;
|
||||
|
||||
configASSERT( internalMutex != NULL );
|
||||
|
||||
IotLogDebug( "Locking mutex %p.", internalMutex );
|
||||
|
||||
/* Call the correct FreeRTOS mutex take function based on mutex type. */
|
||||
if( internalMutex->recursive == pdTRUE )
|
||||
{
|
||||
lockResult = xSemaphoreTakeRecursive( ( SemaphoreHandle_t ) &internalMutex->xMutex, timeout );
|
||||
}
|
||||
else
|
||||
{
|
||||
lockResult = xSemaphoreTake( ( SemaphoreHandle_t ) &internalMutex->xMutex, timeout );
|
||||
}
|
||||
|
||||
return( lockResult == pdTRUE );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotMutex_Lock( IotMutex_t * pMutex )
|
||||
{
|
||||
prIotMutexTimedLock( pMutex, portMAX_DELAY );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotMutex_TryLock( IotMutex_t * pMutex )
|
||||
{
|
||||
return prIotMutexTimedLock( pMutex, 0 );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotMutex_Unlock( IotMutex_t * pMutex )
|
||||
{
|
||||
_IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pMutex;
|
||||
|
||||
configASSERT( internalMutex != NULL );
|
||||
|
||||
IotLogDebug( "Unlocking mutex %p.", internalMutex );
|
||||
|
||||
/* Call the correct FreeRTOS mutex unlock function based on mutex type. */
|
||||
if( internalMutex->recursive == pdTRUE )
|
||||
{
|
||||
( void ) xSemaphoreGiveRecursive( ( SemaphoreHandle_t ) &internalMutex->xMutex );
|
||||
}
|
||||
else
|
||||
{
|
||||
( void ) xSemaphoreGive( ( SemaphoreHandle_t ) &internalMutex->xMutex );
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotSemaphore_Create( IotSemaphore_t * pNewSemaphore,
|
||||
uint32_t initialValue,
|
||||
uint32_t maxValue )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pNewSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Creating new semaphore %p.", pNewSemaphore );
|
||||
|
||||
( void ) xSemaphoreCreateCountingStatic( maxValue, initialValue, &internalSemaphore->xSemaphore );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
uint32_t IotSemaphore_GetCount( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
UBaseType_t count = 0;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
count = uxSemaphoreGetCount( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore );
|
||||
|
||||
IotLogDebug( "Semaphore %p has count %d.", pSemaphore, count );
|
||||
|
||||
return ( uint32_t ) count;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotSemaphore_Destroy( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Destroying semaphore %p.", internalSemaphore );
|
||||
|
||||
vSemaphoreDelete( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotSemaphore_Wait( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Waiting on semaphore %p.", internalSemaphore );
|
||||
|
||||
/* Take the semaphore using the FreeRTOS API. */
|
||||
if( xSemaphoreTake( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore,
|
||||
portMAX_DELAY ) != pdTRUE )
|
||||
{
|
||||
IotLogWarn( "Failed to wait on semaphore %p.",
|
||||
pSemaphore );
|
||||
|
||||
/* Assert here, debugging we always want to know that this happened because you think
|
||||
* that you are waiting successfully on the semaphore but you are not */
|
||||
configASSERT( false );
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotSemaphore_TryWait( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Attempting to wait on semaphore %p.", internalSemaphore );
|
||||
|
||||
return IotSemaphore_TimedWait( pSemaphore, 0 );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotSemaphore_TimedWait( IotSemaphore_t * pSemaphore,
|
||||
uint32_t timeoutMs )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
/* Take the semaphore using the FreeRTOS API. Cast the calculation to 64 bit to avoid overflows*/
|
||||
if( xSemaphoreTake( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore,
|
||||
pdMS_TO_TICKS( timeoutMs ) ) != pdTRUE )
|
||||
{
|
||||
/* Only warn if timeout > 0 */
|
||||
if( timeoutMs > 0 )
|
||||
{
|
||||
IotLogWarn( "Timeout waiting on semaphore %p.",
|
||||
internalSemaphore );
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotSemaphore_Post( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Posting to semaphore %p.", internalSemaphore );
|
||||
/* Give the semaphore using the FreeRTOS API. */
|
||||
BaseType_t result = xSemaphoreGive( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore );
|
||||
|
||||
if( result == pdFALSE )
|
||||
{
|
||||
IotLogDebug( "Unable to give semaphore over maximum", internalSemaphore );
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
|
@ -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_ */
|
||||
|
|
@ -0,0 +1,342 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Secure Sockets V1.1.5
|
||||
* 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
|
||||
*/
|
||||
|
||||
/* Define _SECURE_SOCKETS_WRAPPER_NOT_REDEFINE to prevent secure sockets functions
|
||||
* from redefining in iot_secure_sockets_wrapper_metrics.h */
|
||||
#define _SECURE_SOCKETS_WRAPPER_NOT_REDEFINE
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "FreeRTOSIPConfig.h"
|
||||
#include "list.h"
|
||||
#include "semphr.h"
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_Sockets.h"
|
||||
#include "iot_secure_sockets.h"
|
||||
#include "task.h"
|
||||
|
||||
#undef _SECURE_SOCKETS_WRAPPER_NOT_REDEFINE
|
||||
|
||||
/* Internal context structure. */
|
||||
typedef struct SSOCKETContext
|
||||
{
|
||||
Socket_t xSocket;
|
||||
char * pcDestination;
|
||||
BaseType_t xSendFlags;
|
||||
BaseType_t xRecvFlags;
|
||||
BaseType_t xConnectAttempted;
|
||||
} SSOCKETContext_t, * SSOCKETContextPtr_t;
|
||||
|
||||
/*
|
||||
* Helper routines.
|
||||
*/
|
||||
|
||||
/*
|
||||
* @brief Network send callback.
|
||||
*/
|
||||
static BaseType_t prvNetworkSend( void * pvContext,
|
||||
const unsigned char * pucData,
|
||||
size_t xDataLength )
|
||||
{
|
||||
SSOCKETContextPtr_t pxContext = ( SSOCKETContextPtr_t ) pvContext; /*lint !e9087 cast used for portability. */
|
||||
|
||||
return FreeRTOS_send( pxContext->xSocket, pucData, xDataLength, pxContext->xSendFlags );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* @brief Network receive callback.
|
||||
*/
|
||||
static BaseType_t prvNetworkRecv( void * pvContext,
|
||||
unsigned char * pucReceiveBuffer,
|
||||
size_t xReceiveLength )
|
||||
{
|
||||
SSOCKETContextPtr_t pxContext = ( SSOCKETContextPtr_t ) pvContext; /*lint !e9087 cast used for portability. */
|
||||
|
||||
return FreeRTOS_recv( pxContext->xSocket, pucReceiveBuffer, xReceiveLength, pxContext->xRecvFlags );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Interface routines.
|
||||
*/
|
||||
|
||||
int32_t SOCKETS_Close( Socket_t xSocket )
|
||||
{
|
||||
SSOCKETContextPtr_t pxContext = ( SSOCKETContextPtr_t ) xSocket; /*lint !e9087 cast used for portability. */
|
||||
int32_t lReturn;
|
||||
|
||||
if( ( xSocket != SOCKETS_INVALID_SOCKET ) && ( NULL != pxContext ) )
|
||||
{
|
||||
/* Clean-up destination string. */
|
||||
if( NULL != pxContext->pcDestination )
|
||||
{
|
||||
vPortFree( pxContext->pcDestination );
|
||||
}
|
||||
|
||||
/* Close the underlying socket handle. */
|
||||
( void ) FreeRTOS_closesocket( pxContext->xSocket );
|
||||
|
||||
/* Free the context. */
|
||||
vPortFree( pxContext );
|
||||
lReturn = SOCKETS_ERROR_NONE;
|
||||
}
|
||||
else
|
||||
{
|
||||
lReturn = SOCKETS_EINVAL;
|
||||
}
|
||||
|
||||
return lReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
int32_t SOCKETS_Connect( Socket_t xSocket,
|
||||
SocketsSockaddr_t * pxAddress,
|
||||
Socklen_t xAddressLength )
|
||||
{
|
||||
int32_t lStatus = SOCKETS_ERROR_NONE;
|
||||
SSOCKETContextPtr_t pxContext = ( SSOCKETContextPtr_t ) xSocket; /*lint !e9087 cast used for portability. */
|
||||
struct freertos_sockaddr xTempAddress = { 0 };
|
||||
|
||||
if( ( pxContext != SOCKETS_INVALID_SOCKET ) && ( pxAddress != NULL ) )
|
||||
{
|
||||
/* A connection was attempted. If this function fails, then the socket is invalid and the user
|
||||
* must call SOCKETS_Close(), on this socket, and SOCKETS_Socket() to get a new socket. */
|
||||
pxContext->xConnectAttempted = pdTRUE;
|
||||
|
||||
/* Connect the wrapped socket. */
|
||||
xTempAddress.sin_addr = pxAddress->ulAddress;
|
||||
xTempAddress.sin_family = pxAddress->ucSocketDomain;
|
||||
xTempAddress.sin_len = ( uint8_t ) sizeof( xTempAddress );
|
||||
xTempAddress.sin_port = pxAddress->usPort;
|
||||
lStatus = FreeRTOS_connect( pxContext->xSocket, &xTempAddress, xAddressLength );
|
||||
}
|
||||
else
|
||||
{
|
||||
lStatus = SOCKETS_SOCKET_ERROR;
|
||||
}
|
||||
|
||||
return lStatus;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
uint32_t SOCKETS_GetHostByName( const char * pcHostName )
|
||||
{
|
||||
return FreeRTOS_gethostbyname( pcHostName );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
int32_t SOCKETS_Recv( Socket_t xSocket,
|
||||
void * pvBuffer,
|
||||
size_t xBufferLength,
|
||||
uint32_t ulFlags )
|
||||
{
|
||||
int32_t lStatus = SOCKETS_SOCKET_ERROR;
|
||||
SSOCKETContextPtr_t pxContext = ( SSOCKETContextPtr_t ) xSocket; /*lint !e9087 cast used for portability. */
|
||||
|
||||
if( ( xSocket != SOCKETS_INVALID_SOCKET ) &&
|
||||
( pvBuffer != NULL ) )
|
||||
{
|
||||
pxContext->xRecvFlags = ( BaseType_t ) ulFlags;
|
||||
|
||||
/* Receive unencrypted. */
|
||||
lStatus = prvNetworkRecv( pxContext, pvBuffer, xBufferLength );
|
||||
}
|
||||
else
|
||||
{
|
||||
lStatus = SOCKETS_EINVAL;
|
||||
}
|
||||
|
||||
return lStatus;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
int32_t SOCKETS_Send( Socket_t xSocket,
|
||||
const void * pvBuffer,
|
||||
size_t xDataLength,
|
||||
uint32_t ulFlags )
|
||||
{
|
||||
int32_t lStatus = SOCKETS_SOCKET_ERROR;
|
||||
SSOCKETContextPtr_t pxContext = ( SSOCKETContextPtr_t ) xSocket; /*lint !e9087 cast used for portability. */
|
||||
|
||||
if( ( xSocket != SOCKETS_INVALID_SOCKET ) &&
|
||||
( pvBuffer != NULL ) )
|
||||
{
|
||||
pxContext->xSendFlags = ( BaseType_t ) ulFlags;
|
||||
|
||||
/* Send unencrypted. */
|
||||
lStatus = prvNetworkSend( pxContext, pvBuffer, xDataLength );
|
||||
}
|
||||
else
|
||||
{
|
||||
lStatus = SOCKETS_EINVAL;
|
||||
}
|
||||
|
||||
return lStatus;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
int32_t SOCKETS_SetSockOpt( Socket_t xSocket,
|
||||
int32_t lLevel,
|
||||
int32_t lOptionName,
|
||||
const void * pvOptionValue,
|
||||
size_t xOptionLength )
|
||||
{
|
||||
int32_t lStatus = SOCKETS_ERROR_NONE;
|
||||
TickType_t xTimeout;
|
||||
SSOCKETContextPtr_t pxContext = ( SSOCKETContextPtr_t ) xSocket; /*lint !e9087 cast used for portability. */
|
||||
|
||||
if( ( xSocket != SOCKETS_INVALID_SOCKET ) && ( xSocket != NULL ) )
|
||||
{
|
||||
switch( lOptionName )
|
||||
{
|
||||
case SOCKETS_SO_NONBLOCK:
|
||||
xTimeout = 0;
|
||||
|
||||
/* Non-blocking connect is not supported. Socket may be set to nonblocking
|
||||
* only after a connection is made. */
|
||||
if( pdTRUE == pxContext->xConnectAttempted )
|
||||
{
|
||||
lStatus = FreeRTOS_setsockopt( pxContext->xSocket,
|
||||
lLevel,
|
||||
SOCKETS_SO_RCVTIMEO,
|
||||
&xTimeout,
|
||||
sizeof( xTimeout ) );
|
||||
|
||||
if( lStatus == SOCKETS_ERROR_NONE )
|
||||
{
|
||||
lStatus = FreeRTOS_setsockopt( pxContext->xSocket,
|
||||
lLevel,
|
||||
SOCKETS_SO_SNDTIMEO,
|
||||
&xTimeout,
|
||||
sizeof( xTimeout ) );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
lStatus = SOCKETS_EISCONN;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case SOCKETS_SO_RCVTIMEO:
|
||||
case SOCKETS_SO_SNDTIMEO:
|
||||
/* Comply with Berkeley standard - a 0 timeout is wait forever. */
|
||||
xTimeout = *( ( const TickType_t * ) pvOptionValue ); /*lint !e9087 pvOptionValue passed should be of TickType_t */
|
||||
|
||||
if( xTimeout == 0U )
|
||||
{
|
||||
xTimeout = portMAX_DELAY;
|
||||
}
|
||||
|
||||
lStatus = FreeRTOS_setsockopt( pxContext->xSocket,
|
||||
lLevel,
|
||||
lOptionName,
|
||||
&xTimeout,
|
||||
xOptionLength );
|
||||
break;
|
||||
|
||||
default:
|
||||
lStatus = FreeRTOS_setsockopt( pxContext->xSocket,
|
||||
lLevel,
|
||||
lOptionName,
|
||||
pvOptionValue,
|
||||
xOptionLength );
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
lStatus = SOCKETS_EINVAL;
|
||||
}
|
||||
|
||||
return lStatus;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
int32_t SOCKETS_Shutdown( Socket_t xSocket,
|
||||
uint32_t ulHow )
|
||||
{
|
||||
int32_t lReturn;
|
||||
SSOCKETContextPtr_t pxContext = ( SSOCKETContextPtr_t ) xSocket; /*lint !e9087 cast used for portability. */
|
||||
|
||||
if( ( xSocket != SOCKETS_INVALID_SOCKET ) && ( xSocket != NULL ) )
|
||||
{
|
||||
lReturn = FreeRTOS_shutdown( pxContext->xSocket, ( BaseType_t ) ulHow );
|
||||
}
|
||||
else
|
||||
{
|
||||
lReturn = SOCKETS_EINVAL;
|
||||
}
|
||||
|
||||
return lReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
Socket_t SOCKETS_Socket( int32_t lDomain,
|
||||
int32_t lType,
|
||||
int32_t lProtocol )
|
||||
{
|
||||
SSOCKETContextPtr_t pxContext = NULL;
|
||||
Socket_t xSocket;
|
||||
|
||||
/* Ensure that only supported values are supplied. */
|
||||
configASSERT( lDomain == SOCKETS_AF_INET );
|
||||
configASSERT( lType == SOCKETS_SOCK_STREAM );
|
||||
configASSERT( lProtocol == SOCKETS_IPPROTO_TCP );
|
||||
|
||||
/* Create the wrapped socket. */
|
||||
xSocket = FreeRTOS_socket( lDomain, lType, lProtocol );
|
||||
|
||||
if( xSocket != FREERTOS_INVALID_SOCKET )
|
||||
{
|
||||
/* Allocate the internal context structure. */
|
||||
if( NULL == ( pxContext = pvPortMalloc( sizeof( SSOCKETContext_t ) ) ) )
|
||||
{
|
||||
/* Need to close socket. */
|
||||
( void ) FreeRTOS_closesocket( xSocket );
|
||||
pxContext = SOCKETS_INVALID_SOCKET;
|
||||
}
|
||||
else
|
||||
{
|
||||
memset( pxContext, 0, sizeof( SSOCKETContext_t ) );
|
||||
pxContext->xSocket = xSocket;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pxContext = SOCKETS_INVALID_SOCKET;
|
||||
}
|
||||
|
||||
return pxContext;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
BaseType_t SOCKETS_Init( void )
|
||||
{
|
||||
/* Empty initialization for this port. */
|
||||
return pdPASS;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
|
@ -0,0 +1,609 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Secure Sockets V1.1.5
|
||||
* 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_secure_sockets.h
|
||||
* @brief Secure Sockets Interface.
|
||||
*
|
||||
* Secure sockets is a portable layer for establishing a TCP/IP
|
||||
* connection, with the option of using TLS.
|
||||
*
|
||||
* Secure sockets is based on the Berkeley sockets API.
|
||||
* A few difference general differences between Berkeley and SOCKETS are:
|
||||
* - SOCKETS has additional socket options to enable TLS, server name
|
||||
* indication, and per-socket root of trust server certificates. See
|
||||
* SOCKETS_SetSockOpt() for more information.
|
||||
* - SOCKETS API return an error code, rather than returning -1 and setting
|
||||
* a global errno value.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _AWS_SECURE_SOCKETS_H_
|
||||
#define _AWS_SECURE_SOCKETS_H_
|
||||
|
||||
/*
|
||||
#ifdef __cplusplus
|
||||
* extern "C" {
|
||||
#endif
|
||||
*/
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include "iot_secure_sockets_config.h"
|
||||
#include "iot_secure_sockets_config_defaults.h"
|
||||
#include "iot_secure_sockets_wrapper_metrics.h"
|
||||
#include "iot_lib_init.h"
|
||||
|
||||
/**
|
||||
* @ingroup SecureSockets_datatypes_handles
|
||||
* @brief The socket handle data type.
|
||||
*
|
||||
* For detail of socket, refer to [Network Sockets]
|
||||
* (https://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/socket.html)
|
||||
*
|
||||
* Data contained by the Socket_t type is port specific.
|
||||
*/
|
||||
typedef void * Socket_t;
|
||||
|
||||
/**
|
||||
* @brief The "size_t" of secure sockets.
|
||||
*
|
||||
* This type is used for compatibility with the expected Berkeley sockets
|
||||
* naming.
|
||||
*/
|
||||
#define Socklen_t uint32_t
|
||||
|
||||
/**
|
||||
* @anchor SocketsErrors
|
||||
* @name SocketsErrors
|
||||
* @brief Error codes returned by the SOCKETS API.
|
||||
*
|
||||
* Note that SOCKETS API may also propagate port-specific
|
||||
* error codes when they are more descriptive. See your
|
||||
* port's error codes for more details.
|
||||
* PORT_SPECIFIC_LINK
|
||||
*/
|
||||
/**@{ */
|
||||
|
||||
#define SOCKETS_ERROR_NONE ( 0 ) /*!< No error. */
|
||||
#define SOCKETS_SOCKET_ERROR ( -1 ) /*!< Catch-all sockets error code. */
|
||||
#define SOCKETS_EWOULDBLOCK ( -11 ) /*!< A resource is temporarily unavailable. */
|
||||
#define SOCKETS_ENOMEM ( -12 ) /*!< Memory allocation failed. */
|
||||
#define SOCKETS_EINVAL ( -22 ) /*!< Invalid argument. */
|
||||
#define SOCKETS_ENOPROTOOPT ( -109 ) /*!< A bad option was specified . */
|
||||
#define SOCKETS_ENOTCONN ( -126 ) /*!< The supplied socket is not connected. */
|
||||
#define SOCKETS_EISCONN ( -127 ) /*!< The supplied socket is already connected. */
|
||||
#define SOCKETS_ECLOSED ( -128 ) /*!< The supplied socket has already been closed. */
|
||||
#define SOCKETS_TLS_INIT_ERROR ( -1001 ) /*!< TLS initialization failed. */
|
||||
#define SOCKETS_TLS_HANDSHAKE_ERROR ( -1002 ) /*!< TLS handshake failed. */
|
||||
#define SOCKETS_TLS_SERVER_UNVERIFIED ( -1003 ) /*!< A connection was made but the server could not be verified. It is recommended that the socket be closed. */
|
||||
#define SOCKETS_TLS_RECV_ERROR ( -1004 ) /*!< TLS receive operation failed. */
|
||||
#define SOCKETS_TLS_SEND_ERROR ( -1005 ) /*!< TLS send operation failed. */
|
||||
#define SOCKETS_PERIPHERAL_RESET ( -1006 ) /*!< Communications peripheral has been reset. */
|
||||
/**@} */
|
||||
|
||||
/**
|
||||
* @brief Assigned to an Socket_t variable when the socket is not valid.
|
||||
*/
|
||||
#define SOCKETS_INVALID_SOCKET ( ( Socket_t ) ~0U )
|
||||
|
||||
/**
|
||||
* @anchor SocketDomains
|
||||
* @name SocketDomains
|
||||
*
|
||||
* @brief Options for the lDomain parameter of SOCKETS_Socket()
|
||||
* function.
|
||||
*
|
||||
* These select the protocol family to be used for communication.
|
||||
*/
|
||||
/**@{ */
|
||||
#define SOCKETS_AF_INET ( 2 ) /*!< IPv4 Internet Protocols. */
|
||||
#define SOCKETS_PF_INET SOCKETS_AF_INET /*!< IPv4 Internet Protocol. */
|
||||
#define SOCKETS_AF_INET6 ( 10 ) /*!< IPv6 Internet Protocols. This option is currently not supported. */
|
||||
/**@} */
|
||||
|
||||
/**
|
||||
* @anchor SocketTypes
|
||||
* @name SocketTypes
|
||||
*
|
||||
* @brief Options for the lType parameter of SOCKETS_Socket()
|
||||
* function.
|
||||
*
|
||||
* These specify the communication semantics.
|
||||
*/
|
||||
/**@{ */
|
||||
#define SOCKETS_SOCK_DGRAM ( 2 ) /*!< Datagram. */
|
||||
#define SOCKETS_SOCK_STREAM ( 1 ) /*!< Byte-stream. */
|
||||
/**@} */
|
||||
|
||||
/**
|
||||
* @anchor Protocols
|
||||
* @name Protocols
|
||||
*
|
||||
* @brief Options for the lProtocol parameter of SOCKETS_Socket() function.
|
||||
*
|
||||
*/
|
||||
/**@{ */
|
||||
#define SOCKETS_IPPROTO_UDP ( 17 ) /*!< UDP. This option is currently not supported. */
|
||||
#define SOCKETS_IPPROTO_TCP ( 6 ) /*!< TCP. */
|
||||
/**@} */
|
||||
|
||||
/**
|
||||
* @anchor SetSockOptOptions
|
||||
* @name SetSockOptOptions
|
||||
*
|
||||
* @brief Options for lOptionName in SOCKETS_SetSockOpt().
|
||||
*
|
||||
*/
|
||||
/**@{ */
|
||||
#define SOCKETS_SO_RCVTIMEO ( 0 ) /**< Set the receive timeout. */
|
||||
#define SOCKETS_SO_SNDTIMEO ( 1 ) /**< Set the send timeout. */
|
||||
#define SOCKETS_SO_SNDBUF ( 4 ) /**< Set the size of the send buffer (TCP only). */
|
||||
#define SOCKETS_SO_RCVBUF ( 5 ) /**< Set the size of the receive buffer (TCP only). */
|
||||
#define SOCKETS_SO_SERVER_NAME_INDICATION ( 6 ) /**< Toggle client use of TLS SNI. */
|
||||
#define SOCKETS_SO_TRUSTED_SERVER_CERTIFICATE ( 7 ) /**< Override default TLS server certificate trust. Must be PEM encoded and length must include null terminator. */
|
||||
#define SOCKETS_SO_REQUIRE_TLS ( 8 ) /**< Toggle client enforcement of TLS. */
|
||||
#define SOCKETS_SO_NONBLOCK ( 9 ) /**< Socket is nonblocking. */
|
||||
#define SOCKETS_SO_ALPN_PROTOCOLS ( 10 ) /**< Application protocol list to be included in TLS ClientHello. */
|
||||
#define SOCKETS_SO_WAKEUP_CALLBACK ( 17 ) /**< Set the callback to be called whenever there is data available on the socket for reading. */
|
||||
|
||||
/**@} */
|
||||
|
||||
/**
|
||||
* @anchor ShutdownFlags <br>
|
||||
* @name ShutdownFlags
|
||||
*
|
||||
* @brief Options for the ulHow parameter in SOCKETS_Shutdown().
|
||||
*/
|
||||
/**@{ */
|
||||
#define SOCKETS_SHUT_RD ( 0 ) /**< No further receives. */
|
||||
#define SOCKETS_SHUT_WR ( 1 ) /**< No further sends. */
|
||||
#define SOCKETS_SHUT_RDWR ( 2 ) /**< No further send or receive. */
|
||||
/**@} */
|
||||
|
||||
/**
|
||||
* @brief Maximum length of an ASCII DNS name.
|
||||
*/
|
||||
#define securesocketsMAX_DNS_NAME_LENGTH ( 253 )
|
||||
|
||||
/**
|
||||
* @ingroup SecureSockets_datatypes_paramstructs
|
||||
* @brief Socket address.
|
||||
*
|
||||
* \sa PORT_SPECIFIC_LINK
|
||||
*/
|
||||
typedef struct SocketsSockaddr
|
||||
{
|
||||
uint8_t ucLength; /**< Length of SocketsSockaddr structure. */
|
||||
uint8_t ucSocketDomain; /**< Only SOCKETS_AF_INET is supported. */
|
||||
uint16_t usPort; /**< Port number. Convention is to call this sin_port. */
|
||||
uint32_t ulAddress; /**< IP Address. Convention is to call this sin_addr. */
|
||||
} SocketsSockaddr_t;
|
||||
|
||||
/**
|
||||
* @brief Well-known port numbers.
|
||||
*/
|
||||
#define securesocketsDEFAULT_TLS_DESTINATION_PORT 443
|
||||
|
||||
/**
|
||||
* @brief Secure Sockets library initialization function.
|
||||
*
|
||||
* This function does general initialization and setup. It must be called once
|
||||
* and only once before calling any other function.
|
||||
*
|
||||
* @return
|
||||
* * `pdPASS` if everything succeeds
|
||||
* * `pdFAIL` otherwise.
|
||||
*/
|
||||
lib_initDECLARE_LIB_INIT( SOCKETS_Init );
|
||||
|
||||
/**
|
||||
* @brief Creates a TCP socket.
|
||||
*
|
||||
* See the [FreeRTOS+TCP networking tutorial]
|
||||
* (https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/TCP_Networking_Tutorial.html)
|
||||
* for more information on TCP sockets.
|
||||
*
|
||||
* See the [Berkeley Sockets API]
|
||||
* (https://en.wikipedia.org/wiki/Berkeley_sockets#Socket_API_functions)
|
||||
* in wikipedia
|
||||
*
|
||||
* @sa SOCKETS_Close()
|
||||
*
|
||||
* @param[in] lDomain Must be set to SOCKETS_AF_INET. See @ref SocketDomains.
|
||||
* @param[in] lType Set to SOCKETS_SOCK_STREAM to create a TCP socket.
|
||||
* No other value is valid. See @ref SocketTypes.
|
||||
* @param[in] lProtocol Set to SOCKETS_IPPROTO_TCP to create a TCP socket.
|
||||
* No other value is valid. See @ref Protocols.
|
||||
*
|
||||
* @return
|
||||
* * If a socket is created successfully, then the socket handle is
|
||||
* returned
|
||||
* * @ref SOCKETS_INVALID_SOCKET is returned if an error occurred.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This call allocates memory and claims a socket resource.
|
||||
*/
|
||||
/* @[declare_secure_sockets_socket] */
|
||||
Socket_t SOCKETS_Socket( int32_t lDomain,
|
||||
int32_t lType,
|
||||
int32_t lProtocol );
|
||||
/* @[declare_secure_sockets_socket] */
|
||||
|
||||
|
||||
/**
|
||||
* @brief Connects the socket to the specified IP address and port.
|
||||
*
|
||||
* The socket must first have been successfully created by a call to SOCKETS_Socket().
|
||||
*
|
||||
* \note To create a secure socket, SOCKETS_SetSockOpt() should be called with the
|
||||
* SOCKETS_SO_REQUIRE_TLS option \a before SOCKETS_Connect() is called.
|
||||
*
|
||||
* If this function returns an error the socket is considered invalid.
|
||||
*
|
||||
* \warning SOCKETS_Connect() is not safe to be called on the same socket
|
||||
* from multiple threads simultaneously with SOCKETS_Connect(),
|
||||
* SOCKETS_SetSockOpt(), SOCKETS_Shutdown(), SOCKETS_Close().
|
||||
*
|
||||
* See the [Berkeley Sockets API]
|
||||
* (https://en.wikipedia.org/wiki/Berkeley_sockets#Socket_API_functions)
|
||||
* in wikipedia
|
||||
*
|
||||
* @param[in] xSocket The handle of the socket to be connected.
|
||||
* @param[in] pxAddress A pointer to a SocketsSockaddr_t structure that contains the
|
||||
* the address to connect the socket to.
|
||||
* @param[in] xAddressLength Should be set to sizeof( @ref SocketsSockaddr_t ).
|
||||
*
|
||||
* @return
|
||||
* * @ref SOCKETS_ERROR_NONE if a connection is established.
|
||||
* * If an error occurred, a negative value is returned. @ref SocketsErrors
|
||||
*/
|
||||
/* @[declare_secure_sockets_connect] */
|
||||
int32_t SOCKETS_Connect( Socket_t xSocket,
|
||||
SocketsSockaddr_t * pxAddress,
|
||||
Socklen_t xAddressLength );
|
||||
/* @[declare_secure_sockets_connect] */
|
||||
|
||||
/**
|
||||
* @brief Receive data from a TCP socket.
|
||||
*
|
||||
* The socket must have already been created using a call to SOCKETS_Socket()
|
||||
* and connected to a remote socket using SOCKETS_Connect().
|
||||
*
|
||||
* See the [Berkeley Sockets API]
|
||||
* (https://en.wikipedia.org/wiki/Berkeley_sockets#Socket_API_functions)
|
||||
* in wikipedia
|
||||
*
|
||||
* @param[in] xSocket The handle of the socket from which data is being received.
|
||||
* @param[out] pvBuffer The buffer into which the received data will be placed.
|
||||
* @param[in] xBufferLength The maximum number of bytes which can be received.
|
||||
* pvBuffer must be at least xBufferLength bytes long.
|
||||
* @param[in] ulFlags Not currently used. Should be set to 0.
|
||||
*
|
||||
* @return
|
||||
* * If the receive was successful then the number of bytes received (placed in the
|
||||
* buffer pointed to by pvBuffer) is returned.
|
||||
* * If a timeout occurred before data could be received then 0 is returned (timeout
|
||||
* is set using @ref SOCKETS_SO_RCVTIMEO).
|
||||
* * If an error occurred, a negative value is returned. @ref SocketsErrors
|
||||
*/
|
||||
/* @[declare_secure_sockets_recv] */
|
||||
int32_t SOCKETS_Recv( Socket_t xSocket,
|
||||
void * pvBuffer,
|
||||
size_t xBufferLength,
|
||||
uint32_t ulFlags );
|
||||
/* @[declare_secure_sockets_recv] */
|
||||
|
||||
/**
|
||||
* @brief Transmit data to the remote socket.
|
||||
*
|
||||
* The socket must have already been created using a call to SOCKETS_Socket() and
|
||||
* connected to a remote socket using SOCKETS_Connect().
|
||||
*
|
||||
* See the [Berkeley Sockets API]
|
||||
* (https://en.wikipedia.org/wiki/Berkeley_sockets#Socket_API_functions)
|
||||
* in wikipedia
|
||||
*
|
||||
* @param[in] xSocket The handle of the sending socket.
|
||||
* @param[in] pvBuffer The buffer containing the data to be sent.
|
||||
* @param[in] xDataLength The length of the data to be sent.
|
||||
* @param[in] ulFlags Not currently used. Should be set to 0.
|
||||
*
|
||||
* @return
|
||||
* * On success, the number of bytes actually sent is returned.
|
||||
* * If an error occurred, a negative value is returned. @ref SocketsErrors
|
||||
*/
|
||||
/* @[declare_secure_sockets_send] */
|
||||
int32_t SOCKETS_Send( Socket_t xSocket,
|
||||
const void * pvBuffer,
|
||||
size_t xDataLength,
|
||||
uint32_t ulFlags );
|
||||
/* @[declare_secure_sockets_send] */
|
||||
|
||||
/**
|
||||
* @brief Closes all or part of a full-duplex connection on the socket.
|
||||
*
|
||||
* Disable reads and writes on a connected TCP socket. A connected TCP socket must be gracefully
|
||||
* shut down before it can be closed.
|
||||
*
|
||||
* See the [Berkeley Sockets API]
|
||||
* (https://en.wikipedia.org/wiki/Berkeley_sockets#Socket_API_functions)
|
||||
* in wikipedia
|
||||
*
|
||||
* \warning SOCKETS_Shutdown() is not safe to be called on the same socket
|
||||
* from multiple threads simultaneously with SOCKETS_Connect(),
|
||||
* SOCKETS_SetSockOpt(), SOCKETS_Shutdown(), SOCKETS_Close().
|
||||
*
|
||||
* @param[in] xSocket The handle of the socket to shutdown.
|
||||
* @param[in] ulHow SOCKETS_SHUT_RD, SOCKETS_SHUT_WR or SOCKETS_SHUT_RDWR.
|
||||
* @ref ShutdownFlags
|
||||
*
|
||||
* @return
|
||||
* * If the operation was successful, 0 is returned.
|
||||
* * If an error occurred, a negative value is returned. @ref SocketsErrors
|
||||
*/
|
||||
/* @[declare_secure_sockets_shutdown] */
|
||||
int32_t SOCKETS_Shutdown( Socket_t xSocket,
|
||||
uint32_t ulHow );
|
||||
/* @[declare_secure_sockets_shutdown] */
|
||||
|
||||
/**
|
||||
* @brief Closes the socket and frees the related resources.
|
||||
*
|
||||
* A socket should be shutdown gracefully before it is closed, and cannot be used after it has been closed.
|
||||
*
|
||||
* See the [Berkeley Sockets API]
|
||||
* (https://en.wikipedia.org/wiki/Berkeley_sockets#Socket_API_functions)
|
||||
* in wikipedia
|
||||
*
|
||||
* \warning SOCKETS_Close() is not safe to be called on the same socket
|
||||
* from multiple threads simultaneously with SOCKETS_Connect(),
|
||||
* SOCKETS_SetSockOpt(), SOCKETS_Shutdown(), SOCKETS_Close().
|
||||
*
|
||||
* @param[in] xSocket The handle of the socket to close.
|
||||
*
|
||||
* @return
|
||||
* * On success, 0 is returned.
|
||||
* * If an error occurred, a negative value is returned. @ref SocketsErrors
|
||||
*/
|
||||
/* @[declare_secure_sockets_close] */
|
||||
int32_t SOCKETS_Close( Socket_t xSocket );
|
||||
/* @[declare_secure_sockets_close] */
|
||||
|
||||
/**
|
||||
* @brief AWS IoT ALPN protocol name for MQTT over TLS on server port 443.
|
||||
*/
|
||||
#define socketsAWS_IOT_ALPN_MQTT "x-amzn-mqtt-ca"
|
||||
|
||||
/**
|
||||
* @brief Manipulates the options for the socket.
|
||||
*
|
||||
* See the [Berkeley Sockets API]
|
||||
* (https://en.wikipedia.org/wiki/Berkeley_sockets#Socket_API_functions)
|
||||
* in wikipedia
|
||||
*
|
||||
* @param[in] xSocket The handle of the socket to set the option for.
|
||||
* @param[in] lLevel Not currently used. Should be set to 0.
|
||||
* @param[in] lOptionName See @ref SetSockOptOptions.
|
||||
* @param[in] pvOptionValue A buffer containing the value of the option to set.
|
||||
* @param[in] xOptionLength The length of the buffer pointed to by pvOptionValue.
|
||||
*
|
||||
* \warning SOCKETS_Close() is not safe to be called on the same socket
|
||||
* from multiple threads simultaneously with SOCKETS_Connect(),
|
||||
* SOCKETS_SetSockOpt(), SOCKETS_Shutdown(), SOCKETS_Close().
|
||||
*
|
||||
* @note Socket option support and possible values vary by port. Please see
|
||||
* PORT_SPECIFIC_LINK to check the valid options and limitations of your device.
|
||||
*
|
||||
* - Berkeley Socket Options
|
||||
* - @ref SOCKETS_SO_RCVTIMEO
|
||||
* - Sets the receive timeout
|
||||
* - pvOptionValue (TickType_t) is the number of milliseconds that the
|
||||
* receive function should wait before timing out.
|
||||
* - Setting pvOptionValue = 0 causes receive to wait forever.
|
||||
* - See PORT_SPECIFIC_LINK for device limitations.
|
||||
* - @ref SOCKETS_SO_SNDTIMEO
|
||||
* - Sets the send timeout
|
||||
* - pvOptionValue (TickType_t) is the number of milliseconds that the
|
||||
* send function should wait before timing out.
|
||||
* - Setting pvOptionValue = 0 causes send to wait forever.
|
||||
* - See PORT_SPECIFIC_LINK for device limitations.
|
||||
* - Non-Standard Options
|
||||
* - @ref SOCKETS_SO_NONBLOCK
|
||||
* - Makes a socket non-blocking.
|
||||
* - Non-blocking connect is not supported - socket option should be
|
||||
* called after connect.
|
||||
* - pvOptionValue is ignored for this option.
|
||||
* - @ref SOCKETS_SO_WAKEUP_CALLBACK
|
||||
* - Set the callback to be called whenever there is data available on
|
||||
* the socket for reading
|
||||
* - This option provides an asynchronous way to handle received data
|
||||
* - pvOptionValue is a pointer to the callback function
|
||||
* - See PORT_SPECIFIC_LINK for device limitations.
|
||||
* - Security Sockets Options
|
||||
* - @ref SOCKETS_SO_REQUIRE_TLS
|
||||
* - Use TLS for all connect, send, and receive on this socket.
|
||||
* - This socket options MUST be set for TLS to be used, even
|
||||
* if other secure socket options are set.
|
||||
* - This socket option should be set before SOCKETS_Connect() is
|
||||
* called.
|
||||
* - pvOptionValue is ignored for this option.
|
||||
* - @ref SOCKETS_SO_TRUSTED_SERVER_CERTIFICATE
|
||||
* - Set the root of trust server certificate for the socket.
|
||||
* - This socket option only takes effect if @ref SOCKETS_SO_REQUIRE_TLS
|
||||
* is also set. If @ref SOCKETS_SO_REQUIRE_TLS is not set,
|
||||
* this option will be ignored.
|
||||
* - pvOptionValue is a pointer to the formatted server certificate.
|
||||
* TODO: Link to description of how to format certificates with \n
|
||||
* - xOptionLength (BaseType_t) is the length of the certificate
|
||||
* in bytes.
|
||||
* - @ref SOCKETS_SO_SERVER_NAME_INDICATION
|
||||
* - Use Server Name Indication (SNI)
|
||||
* - This socket option only takes effect if @ref SOCKETS_SO_REQUIRE_TLS
|
||||
* is also set. If @ref SOCKETS_SO_REQUIRE_TLS is not set,
|
||||
* this option will be ignored.
|
||||
* - pvOptionValue is a pointer to a string containing the hostname
|
||||
* - xOptionLength is the length of the hostname string in bytes.
|
||||
* - @ref SOCKETS_SO_ALPN_PROTOCOLS
|
||||
* - Negotiate an application protocol along with TLS.
|
||||
* - The ALPN list is expressed as an array of NULL-terminated ANSI
|
||||
* strings.
|
||||
* - xOptionLength is the number of items in the array.
|
||||
*
|
||||
* @return
|
||||
* * On success, 0 is returned.
|
||||
* * If an error occurred, a negative value is returned. @ref SocketsErrors
|
||||
*/
|
||||
/* @[declare_secure_sockets_setsockopt] */
|
||||
int32_t SOCKETS_SetSockOpt( Socket_t xSocket,
|
||||
int32_t lLevel,
|
||||
int32_t lOptionName,
|
||||
const void * pvOptionValue,
|
||||
size_t xOptionLength );
|
||||
/* @[declare_secure_sockets_setsockopt] */
|
||||
|
||||
/**
|
||||
* @brief Resolve a host name using Domain Name Service.
|
||||
*
|
||||
* See the [Berkeley Sockets API]
|
||||
* (https://en.wikipedia.org/wiki/Berkeley_sockets#Socket_API_functions)
|
||||
* in wikipedia
|
||||
*
|
||||
* @param[in] pcHostName The host name to resolve.
|
||||
* @return
|
||||
* * The IPv4 address of the specified host.
|
||||
* * If an error has occurred, 0 is returned.
|
||||
*/
|
||||
/* @[declare_secure_sockets_gethostbyname] */
|
||||
uint32_t SOCKETS_GetHostByName( const char * pcHostName );
|
||||
/* @[declare_secure_sockets_gethostbyname] */
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @brief Convert an unsigned thirty-two-bit value from host endianness to network
|
||||
* endianness.
|
||||
*
|
||||
* @param[in] usIn The unsigned thirty-two-bit value to convert.
|
||||
*/
|
||||
#if defined( socketsconfigBYTE_ORDER ) && ( socketsconfigBYTE_ORDER == pdLITTLE_ENDIAN )
|
||||
#define SOCKETS_htonl( ulIn ) ( ( uint32_t ) ( ( ( ulIn & 0xFF ) << 24 ) | ( ( ulIn & 0xFF00 ) << 8 ) | ( ( ulIn & 0xFF0000 ) >> 8 ) | ( ( ulIn & 0xFF000000 ) >> 24 ) ) )
|
||||
#else
|
||||
#define SOCKETS_htonl( usIn ) ( ( uint32_t ) ( usIn ) )
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Convert an unsigned thirty-two-bit value from network endianness to host
|
||||
* endianness.
|
||||
*
|
||||
* @param[in] usIn The unsigned thirty-two-bit value to convert.
|
||||
*/
|
||||
#define SOCKETS_ntohl( usIn ) SOCKETS_htonl( usIn )
|
||||
|
||||
|
||||
/**
|
||||
* @brief Convert an unsigned sixteen-bit value from host endianness to network
|
||||
* endianness.
|
||||
*
|
||||
* @param[in] usIn The unsigned sixteen-bit value to convert.
|
||||
*/
|
||||
|
||||
#if defined( socketsconfigBYTE_ORDER ) && ( socketsconfigBYTE_ORDER == pdLITTLE_ENDIAN )
|
||||
#define SOCKETS_htons( usIn ) ( ( uint16_t ) ( ( ( usIn ) << 8U ) | ( ( usIn ) >> 8U ) ) )
|
||||
#else
|
||||
#define SOCKETS_htons( usIn ) ( ( uint16_t ) ( usIn ) )
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* @brief Convert an unsigned sixteen-bit value from network endianness to host
|
||||
* endianness.
|
||||
*
|
||||
* @param[in] usIn The unsigned sixteen-bit value to convert.
|
||||
*/
|
||||
#define SOCKETS_ntohs( usIn ) SOCKETS_htons( usIn )
|
||||
|
||||
/**
|
||||
* @brief Convert an IP address expressed as four separate numeric octets into a an IP address expressed as a 32-bit number in network byte order
|
||||
* (for example 192, 168, 0, 100)
|
||||
*
|
||||
* @param[in] ucOctet0 0th IP Octet
|
||||
* @param[in] ucOctet1 1st IP Octet
|
||||
* @param[in] ucOctet2 2nd IP Octet
|
||||
* @param[in] ucOctet3 3rd IP Octet
|
||||
*/
|
||||
#if defined( socketsconfigBYTE_ORDER ) && ( socketsconfigBYTE_ORDER == pdLITTLE_ENDIAN )
|
||||
|
||||
#define SOCKETS_inet_addr_quick( ucOctet0, ucOctet1, ucOctet2, ucOctet3 ) \
|
||||
( ( ( ( uint32_t ) ( ucOctet3 ) ) << 24UL ) | \
|
||||
( ( ( uint32_t ) ( ucOctet2 ) ) << 16UL ) | \
|
||||
( ( ( uint32_t ) ( ucOctet1 ) ) << 8UL ) | \
|
||||
( ( uint32_t ) ( ucOctet0 ) ) )
|
||||
|
||||
/**
|
||||
* @brief Convert an IP address expressed as a 32-bit number in network byte order to a string in decimal dot notation.
|
||||
* (for example "192.168.0.100")
|
||||
*
|
||||
* @param[in] ulIPAddress An IP address expressed as a 32-bit value in network byte order.
|
||||
* @param[in] pucBuffer A pointer to a buffer into which the IP address will be written in decimal dot notation.
|
||||
*/
|
||||
#define SOCKETS_inet_ntoa( ulIPAddress, pucBuffer ) \
|
||||
sprintf( ( char * ) ( pucBuffer ), "%u.%u.%u.%u", \
|
||||
( ( unsigned ) ( ( ulIPAddress ) & 0xffUL ) ), \
|
||||
( ( unsigned ) ( ( ( ulIPAddress ) >> 8 ) & 0xffUL ) ), \
|
||||
( ( unsigned ) ( ( ( ulIPAddress ) >> 16 ) & 0xffUL ) ), \
|
||||
( ( unsigned ) ( ( ulIPAddress ) >> 24 ) ) )
|
||||
|
||||
#else /* socketsconfigBYTE_ORDER. */
|
||||
|
||||
#define SOCKETS_inet_addr_quick( ucOctet0, ucOctet1, ucOctet2, ucOctet3 ) \
|
||||
( ( ( ( uint32_t ) ( ucOctet0 ) ) << 24UL ) | \
|
||||
( ( ( uint32_t ) ( ucOctet1 ) ) << 16UL ) | \
|
||||
( ( ( uint32_t ) ( ucOctet2 ) ) << 8UL ) | \
|
||||
( ( uint32_t ) ( ucOctet3 ) ) )
|
||||
|
||||
/**
|
||||
* @brief Convert an IP address expressed as a 32-bit number in network byte order to a string in decimal dot notation.
|
||||
* (for example "192.168.0.100")
|
||||
*
|
||||
* @param[in] ulIPAddress An IP address expressed as a 32-bit value in network byte order.
|
||||
* @param[in] pucBuffer A pointer to a buffer into which the IP address will be written in decimal dot notation.
|
||||
*/
|
||||
#define SOCKETS_inet_ntoa( ulIPAddress, pucBuffer ) \
|
||||
sprintf( ( char * ) ( pucBuffer ), "%u.%u.%u.%u", \
|
||||
( ( unsigned ) ( ( ulIPAddress ) >> 24 ) ), \
|
||||
( ( unsigned ) ( ( ( ulIPAddress ) >> 16 ) & 0xffUL ) ), \
|
||||
( ( unsigned ) ( ( ( ulIPAddress ) >> 8 ) & 0xffUL ) ), \
|
||||
( ( unsigned ) ( ( ulIPAddress ) & 0xffUL ) ) )
|
||||
|
||||
#endif /* socketsconfigBYTE_ORDER. */
|
||||
|
||||
/*
|
||||
#ifdef __cplusplus
|
||||
* }
|
||||
#endif
|
||||
*/
|
||||
|
||||
#endif /* _AWS_SECURE_SOCKETS_H_ */
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Secure Sockets V1.1.5
|
||||
* 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_secure_sockets_config_defaults.h
|
||||
* @brief Ensures that the required sockets configuration options are supplied
|
||||
* and the optional ones are set to sane values if the user does not supply.
|
||||
*/
|
||||
|
||||
#ifndef AWS_INC_SECURE_SOCKETS_CONFIG_DEFAULTS_H_
|
||||
#define AWS_INC_SECURE_SOCKETS_CONFIG_DEFAULTS_H_
|
||||
|
||||
/**
|
||||
* @brief Byte order of the target MCU must be defined.
|
||||
*
|
||||
* Valid values are pdLITTLE_ENDIAN and pdBIG_ENDIAN.
|
||||
*/
|
||||
#ifndef socketsconfigBYTE_ORDER
|
||||
#error "socketsconfigBYTE_ORDER must be defined."
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Default socket send timeout.
|
||||
*
|
||||
* The user can change the send timeout for a socket using the SOCKETS_SetSockOpt API
|
||||
* with the SOCKETS_SO_SNDTIMEO option.
|
||||
*/
|
||||
#ifndef socketsconfigDEFAULT_SEND_TIMEOUT
|
||||
#define socketsconfigDEFAULT_SEND_TIMEOUT ( 10000 )
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Default socket receive timeout.
|
||||
*
|
||||
* The user can change the receive timeout for a socket using the SOCKETS_SetSockOpt API
|
||||
* with the SOCKETS_SO_RCVTIMEO option.
|
||||
*/
|
||||
#ifndef socketsconfigDEFAULT_RECV_TIMEOUT
|
||||
#define socketsconfigDEFAULT_RECV_TIMEOUT ( 10000 )
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief By default, metrics of secure socket is disabled.
|
||||
*
|
||||
*/
|
||||
#ifndef AWS_IOT_SECURE_SOCKETS_METRICS_ENABLED
|
||||
#define AWS_IOT_SECURE_SOCKETS_METRICS_ENABLED ( 0 )
|
||||
#endif
|
||||
|
||||
#endif /* AWS_INC_SECURE_SOCKETS_CONFIG_DEFAULTS_H_ */
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Secure Sockets V1.1.5
|
||||
* 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
|
||||
*/
|
||||
|
||||
#ifndef _AWS_SECURE_SOCKETS_WRAPPER_METRICS_
|
||||
#define _AWS_SECURE_SOCKETS_WRAPPER_METRICS_
|
||||
|
||||
/* This file redefines Secure Sockets functions to be called through a wrapper macro,
|
||||
* but only if metrics is enabled explicitly. */
|
||||
#if AWS_IOT_SECURE_SOCKETS_METRICS_ENABLED == 1
|
||||
|
||||
/* This macro is included in aws_secure_socket.c and aws_secure_socket_wrapper_metrics.c.
|
||||
* It will prevent the redefine in those source files. */
|
||||
#ifndef _SECURE_SOCKETS_WRAPPER_NOT_REDEFINE
|
||||
#define SOCKETS_Init Sockets_MetricsInit
|
||||
#define SOCKETS_Connect Sockets_MetricsConnect
|
||||
#define SOCKETS_Shutdown Sockets_MetricsShutdown
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* ifndef _AWS_SECURE_SOCKETS_WRAPPER_METRICS_ */
|
||||
Loading…
Add table
Add a link
Reference in a new issue