mirror of
https://github.com/FreeRTOS/FreeRTOS-Kernel.git
synced 2025-04-22 06:21:58 -04:00
657 lines
16 KiB
C
657 lines
16 KiB
C
/* port.c
|
|
*
|
|
* Copyright (C) 2006-2015 wolfSSL Inc.
|
|
*
|
|
* This file is part of wolfSSL. (formerly known as CyaSSL)
|
|
*
|
|
* wolfSSL is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* wolfSSL is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <wolfssl/wolfcrypt/settings.h>
|
|
#include <wolfssl/wolfcrypt/types.h>
|
|
#include <wolfssl/wolfcrypt/error-crypt.h>
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
/* 4996 warning to use MS extensions e.g., strcpy_s instead of strncpy */
|
|
#pragma warning(disable: 4996)
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef SINGLE_THREADED
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
(void)m;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int FreeMutex(wolfSSL_Mutex *m)
|
|
{
|
|
(void)m;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int LockMutex(wolfSSL_Mutex *m)
|
|
{
|
|
(void)m;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int UnLockMutex(wolfSSL_Mutex *m)
|
|
{
|
|
(void)m;
|
|
return 0;
|
|
}
|
|
|
|
#else /* MULTI_THREAD */
|
|
|
|
#if defined(FREERTOS)
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
int iReturn;
|
|
|
|
*m = ( wolfSSL_Mutex ) xSemaphoreCreateMutex();
|
|
if( *m != NULL )
|
|
iReturn = 0;
|
|
else
|
|
iReturn = BAD_MUTEX_E;
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
vSemaphoreDelete( *m );
|
|
return 0;
|
|
}
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
/* Assume an infinite block, or should there be zero block? */
|
|
xSemaphoreTake( *m, portMAX_DELAY );
|
|
return 0;
|
|
}
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
xSemaphoreGive( *m );
|
|
return 0;
|
|
}
|
|
|
|
#elif defined(WOLFSSL_SAFERTOS)
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
vSemaphoreCreateBinary(m->mutexBuffer, m->mutex);
|
|
if (m->mutex == NULL)
|
|
return BAD_MUTEX_E;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
(void)m;
|
|
return 0;
|
|
}
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
/* Assume an infinite block */
|
|
xSemaphoreTake(m->mutex, portMAX_DELAY);
|
|
return 0;
|
|
}
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
xSemaphoreGive(m->mutex);
|
|
return 0;
|
|
}
|
|
|
|
|
|
#elif defined(USE_WINDOWS_API)
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
InitializeCriticalSection(m);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
DeleteCriticalSection(m);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
EnterCriticalSection(m);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
LeaveCriticalSection(m);
|
|
return 0;
|
|
}
|
|
|
|
#elif defined(WOLFSSL_PTHREADS)
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (pthread_mutex_init(m, 0) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (pthread_mutex_destroy(m) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (pthread_mutex_lock(m) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (pthread_mutex_unlock(m) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
#elif defined(THREADX)
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (tx_mutex_create(m, "wolfSSL Mutex", TX_NO_INHERIT) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (tx_mutex_delete(m) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (tx_mutex_get(m, TX_WAIT_FOREVER) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (tx_mutex_put(m) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
#elif defined(MICRIUM)
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
#if (NET_SECURE_MGR_CFG_EN == DEF_ENABLED)
|
|
if (NetSecure_OS_MutexCreate(m) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
#if (NET_SECURE_MGR_CFG_EN == DEF_ENABLED)
|
|
if (NetSecure_OS_FreeMutex(m) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
#if (NET_SECURE_MGR_CFG_EN == DEF_ENABLED)
|
|
if (NetSecure_OS_LockMutex(m) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
#if (NET_SECURE_MGR_CFG_EN == DEF_ENABLED)
|
|
if (NetSecure_OS_UnLockMutex(m) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
|
|
}
|
|
|
|
#elif defined(EBSNET)
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (rtp_sig_mutex_alloc(m, "wolfSSL Mutex") == -1)
|
|
return BAD_MUTEX_E;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
rtp_sig_mutex_free(*m);
|
|
return 0;
|
|
}
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (rtp_sig_mutex_claim_timed(*m, RTIP_INF) == 0)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
rtp_sig_mutex_release(*m);
|
|
return 0;
|
|
}
|
|
|
|
#elif defined(FREESCALE_MQX)
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (_mutex_init(m, NULL) == MQX_EOK)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (_mutex_destroy(m) == MQX_EOK)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (_mutex_lock(m) == MQX_EOK)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
if (_mutex_unlock(m) == MQX_EOK)
|
|
return 0;
|
|
else
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
#elif defined (WOLFSSL_TIRTOS)
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
Semaphore_Params params;
|
|
|
|
Semaphore_Params_init(¶ms);
|
|
params.mode = Semaphore_Mode_BINARY;
|
|
|
|
*m = Semaphore_create(1, ¶ms, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
Semaphore_delete(m);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
Semaphore_pend(*m, BIOS_WAIT_FOREVER);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
Semaphore_post(*m);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#elif defined(WOLFSSL_uITRON4)
|
|
#include "kernel.h"
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
int iReturn;
|
|
m->sem.sematr = TA_TFIFO ;
|
|
m->sem.isemcnt = 1 ;
|
|
m->sem.maxsem = 1 ;
|
|
m->sem.name = NULL ;
|
|
|
|
m->id = acre_sem(&m->sem);
|
|
if( m->id != NULL )
|
|
iReturn = 0;
|
|
else
|
|
iReturn = BAD_MUTEX_E;
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
del_sem( m->id );
|
|
return 0;
|
|
}
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
wai_sem(m->id);
|
|
return 0;
|
|
}
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
sig_sem(m->id);
|
|
return 0;
|
|
}
|
|
|
|
/**** uITRON malloc/free ***/
|
|
static ID ID_wolfssl_MPOOL = 0 ;
|
|
static T_CMPL wolfssl_MPOOL = {TA_TFIFO, 0, NULL, "wolfSSL_MPOOL"};
|
|
|
|
int uITRON4_minit(size_t poolsz) {
|
|
ER ercd;
|
|
wolfssl_MPOOL.mplsz = poolsz ;
|
|
ercd = acre_mpl(&wolfssl_MPOOL);
|
|
if (ercd > 0) {
|
|
ID_wolfssl_MPOOL = ercd;
|
|
return 0;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
void *uITRON4_malloc(size_t sz) {
|
|
ER ercd;
|
|
void *p ;
|
|
ercd = get_mpl(ID_wolfssl_MPOOL, sz, (VP)&p);
|
|
if (ercd == E_OK) {
|
|
return p;
|
|
} else {
|
|
return 0 ;
|
|
}
|
|
}
|
|
|
|
void *uITRON4_realloc(void *p, size_t sz) {
|
|
ER ercd;
|
|
void *newp ;
|
|
if(p) {
|
|
ercd = get_mpl(ID_wolfssl_MPOOL, sz, (VP)&newp);
|
|
if (ercd == E_OK) {
|
|
memcpy(newp, p, sz) ;
|
|
ercd = rel_mpl(ID_wolfssl_MPOOL, (VP)p);
|
|
if (ercd == E_OK) {
|
|
return newp;
|
|
}
|
|
}
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
void uITRON4_free(void *p) {
|
|
ER ercd;
|
|
ercd = rel_mpl(ID_wolfssl_MPOOL, (VP)p);
|
|
if (ercd == E_OK) {
|
|
return ;
|
|
} else {
|
|
return ;
|
|
}
|
|
}
|
|
|
|
#elif defined(WOLFSSL_uTKERNEL2)
|
|
#include "tk/tkernel.h"
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
int iReturn;
|
|
m->sem.sematr = TA_TFIFO ;
|
|
m->sem.isemcnt = 1 ;
|
|
m->sem.maxsem = 1 ;
|
|
|
|
m->id = tk_cre_sem(&m->sem);
|
|
if( m->id != NULL )
|
|
iReturn = 0;
|
|
else
|
|
iReturn = BAD_MUTEX_E;
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
tk_del_sem( m->id );
|
|
return 0;
|
|
}
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
tk_wai_sem(m->id, 1, TMO_FEVR);
|
|
return 0;
|
|
}
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
tk_sig_sem(m->id, 1);
|
|
return 0;
|
|
}
|
|
|
|
/**** uT-Kernel malloc/free ***/
|
|
static ID ID_wolfssl_MPOOL = 0 ;
|
|
static T_CMPL wolfssl_MPOOL =
|
|
{(void *)NULL,
|
|
TA_TFIFO , 0, "wolfSSL_MPOOL"};
|
|
|
|
int uTKernel_init_mpool(unsigned int sz) {
|
|
ER ercd;
|
|
wolfssl_MPOOL.mplsz = sz ;
|
|
ercd = tk_cre_mpl(&wolfssl_MPOOL);
|
|
if (ercd > 0) {
|
|
ID_wolfssl_MPOOL = ercd;
|
|
return 0;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
void *uTKernel_malloc(unsigned int sz) {
|
|
ER ercd;
|
|
void *p ;
|
|
ercd = tk_get_mpl(ID_wolfssl_MPOOL, sz, (VP)&p, TMO_FEVR);
|
|
if (ercd == E_OK) {
|
|
return p;
|
|
} else {
|
|
return 0 ;
|
|
}
|
|
}
|
|
|
|
void *uTKernel_realloc(void *p, unsigned int sz) {
|
|
ER ercd;
|
|
void *newp ;
|
|
if(p) {
|
|
ercd = tk_get_mpl(ID_wolfssl_MPOOL, sz, (VP)&newp, TMO_FEVR);
|
|
if (ercd == E_OK) {
|
|
memcpy(newp, p, sz) ;
|
|
ercd = tk_rel_mpl(ID_wolfssl_MPOOL, (VP)p);
|
|
if (ercd == E_OK) {
|
|
return newp;
|
|
}
|
|
}
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
void uTKernel_free(void *p) {
|
|
ER ercd;
|
|
ercd = tk_rel_mpl(ID_wolfssl_MPOOL, (VP)p);
|
|
if (ercd == E_OK) {
|
|
return ;
|
|
} else {
|
|
return ;
|
|
}
|
|
}
|
|
|
|
#elif defined(WOLFSSL_MDK_ARM)|| defined(WOLFSSL_CMSIS_RTOS)
|
|
|
|
#if defined(WOLFSSL_CMSIS_RTOS)
|
|
#include "cmsis_os.h"
|
|
#define CMSIS_NMUTEX 10
|
|
osMutexDef(wolfSSL_mt0) ; osMutexDef(wolfSSL_mt1) ; osMutexDef(wolfSSL_mt2) ;
|
|
osMutexDef(wolfSSL_mt3) ; osMutexDef(wolfSSL_mt4) ; osMutexDef(wolfSSL_mt5) ;
|
|
osMutexDef(wolfSSL_mt6) ; osMutexDef(wolfSSL_mt7) ; osMutexDef(wolfSSL_mt8) ;
|
|
osMutexDef(wolfSSL_mt9) ;
|
|
|
|
static const osMutexDef_t *CMSIS_mutex[] = { osMutex(wolfSSL_mt0),
|
|
osMutex(wolfSSL_mt1), osMutex(wolfSSL_mt2), osMutex(wolfSSL_mt3),
|
|
osMutex(wolfSSL_mt4), osMutex(wolfSSL_mt5), osMutex(wolfSSL_mt6),
|
|
osMutex(wolfSSL_mt7), osMutex(wolfSSL_mt8), osMutex(wolfSSL_mt9) } ;
|
|
|
|
static osMutexId CMSIS_mutexID[CMSIS_NMUTEX] = {0} ;
|
|
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
int i ;
|
|
for (i=0; i<CMSIS_NMUTEX; i++) {
|
|
if(CMSIS_mutexID[i] == 0) {
|
|
CMSIS_mutexID[i] = osMutexCreate(CMSIS_mutex[i]) ;
|
|
(*m) = CMSIS_mutexID[i] ;
|
|
return 0 ;
|
|
}
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
int i ;
|
|
osMutexDelete (*m) ;
|
|
for (i=0; i<CMSIS_NMUTEX; i++) {
|
|
if(CMSIS_mutexID[i] == (*m)) {
|
|
CMSIS_mutexID[i] = 0 ;
|
|
return(0) ;
|
|
}
|
|
}
|
|
return(-1) ;
|
|
}
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
osMutexWait(*m, osWaitForever) ;
|
|
return(0) ;
|
|
}
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
osMutexRelease (*m);
|
|
return 0;
|
|
}
|
|
#else
|
|
int InitMutex(wolfSSL_Mutex* m)
|
|
{
|
|
os_mut_init (m);
|
|
return 0;
|
|
}
|
|
|
|
int FreeMutex(wolfSSL_Mutex* m)
|
|
{
|
|
return(0) ;
|
|
}
|
|
|
|
int LockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
os_mut_wait (m, 0xffff);
|
|
return(0) ;
|
|
}
|
|
|
|
int UnLockMutex(wolfSSL_Mutex* m)
|
|
{
|
|
os_mut_release (m);
|
|
return 0;
|
|
}
|
|
#endif
|
|
#endif /* USE_WINDOWS_API */
|
|
|
|
#endif /* SINGLE_THREADED */
|
|
|
|
#if defined(WOLFSSL_TI_CRYPT) || defined(WOLFSSL_TI_HASH)
|
|
#include <wolfcrypt/src/port/ti/ti-ccm.c> /* initialize and Mutex for TI Crypt Engine */
|
|
#include <wolfcrypt/src/port/ti/ti-hash.c> /* md5, sha1, sha224, sha256 */
|
|
#endif
|