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 );
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
Loading…
Add table
Add a link
Reference in a new issue