port.c

00001 /* port.c
00002  *
00003  * Copyright (C) 2006-2014 wolfSSL Inc.
00004  *
00005  * This file is part of CyaSSL.
00006  *
00007  * CyaSSL is free software; you can redistribute it and/or modify
00008  * it under the terms of the GNU General Public License as published by
00009  * the Free Software Foundation; either version 2 of the License, or
00010  * (at your option) any later version.
00011  *
00012  * CyaSSL is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  * GNU General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU General Public License
00018  * along with this program; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
00020  */
00021 
00022 #ifdef HAVE_CONFIG_H
00023     #include <config.h>
00024 #endif
00025 
00026 #include <cyassl/ctaocrypt/settings.h>
00027 #include <cyassl/ctaocrypt/types.h>
00028 #include <cyassl/ctaocrypt/error-crypt.h>
00029 
00030 
00031 #ifdef _MSC_VER
00032     /* 4996 warning to use MS extensions e.g., strcpy_s instead of strncpy */
00033     #pragma warning(disable: 4996)
00034 #endif
00035 
00036 
00037 
00038 #ifdef SINGLE_THREADED
00039 
00040 int InitMutex(CyaSSL_Mutex* m)
00041 {
00042     (void)m;
00043     return 0;
00044 }
00045 
00046 
00047 int FreeMutex(CyaSSL_Mutex *m)
00048 {
00049     (void)m;
00050     return 0;
00051 }
00052 
00053 
00054 int LockMutex(CyaSSL_Mutex *m)
00055 {
00056     (void)m;
00057     return 0;
00058 }
00059 
00060 
00061 int UnLockMutex(CyaSSL_Mutex *m)
00062 {
00063     (void)m;
00064     return 0;
00065 }
00066 
00067 #else /* MULTI_THREAD */
00068 
00069     #if defined(FREERTOS)
00070 
00071         int InitMutex(CyaSSL_Mutex* m)
00072         {
00073             int iReturn;
00074 
00075             *m = ( CyaSSL_Mutex ) xSemaphoreCreateMutex();
00076             if( *m != NULL )
00077                 iReturn = 0;
00078             else
00079                 iReturn = BAD_MUTEX_E;
00080 
00081             return iReturn;
00082         }
00083 
00084         int FreeMutex(CyaSSL_Mutex* m)
00085         {
00086             vSemaphoreDelete( *m );
00087             return 0;
00088         }
00089 
00090         int LockMutex(CyaSSL_Mutex* m)
00091         {
00092             /* Assume an infinite block, or should there be zero block? */
00093             xSemaphoreTake( *m, portMAX_DELAY );
00094             return 0;
00095         }
00096 
00097         int UnLockMutex(CyaSSL_Mutex* m)
00098         {
00099             xSemaphoreGive( *m );
00100             return 0;
00101         }
00102 
00103     #elif defined(CYASSL_SAFERTOS)
00104 
00105         int InitMutex(CyaSSL_Mutex* m)
00106         {
00107             vSemaphoreCreateBinary(m->mutexBuffer, m->mutex);
00108             if (m->mutex == NULL)
00109                 return BAD_MUTEX_E;
00110 
00111             return 0;
00112         }
00113 
00114         int FreeMutex(CyaSSL_Mutex* m)
00115         {
00116             (void)m;
00117             return 0;
00118         }
00119 
00120         int LockMutex(CyaSSL_Mutex* m)
00121         {
00122             /* Assume an infinite block */
00123             xSemaphoreTake(m->mutex, portMAX_DELAY);
00124             return 0;
00125         }
00126 
00127         int UnLockMutex(CyaSSL_Mutex* m)
00128         {
00129             xSemaphoreGive(m->mutex);
00130             return 0;
00131         }
00132 
00133 
00134     #elif defined(USE_WINDOWS_API)
00135 
00136         int InitMutex(CyaSSL_Mutex* m)
00137         {
00138             InitializeCriticalSection(m);
00139             return 0;
00140         }
00141 
00142 
00143         int FreeMutex(CyaSSL_Mutex* m)
00144         {
00145             DeleteCriticalSection(m);
00146             return 0;
00147         }
00148 
00149 
00150         int LockMutex(CyaSSL_Mutex* m)
00151         {
00152             EnterCriticalSection(m);
00153             return 0;
00154         }
00155 
00156 
00157         int UnLockMutex(CyaSSL_Mutex* m)
00158         {
00159             LeaveCriticalSection(m);
00160             return 0;
00161         }
00162 
00163     #elif defined(CYASSL_PTHREADS)
00164 
00165         int InitMutex(CyaSSL_Mutex* m)
00166         {
00167             if (pthread_mutex_init(m, 0) == 0)
00168                 return 0;
00169             else
00170                 return BAD_MUTEX_E;
00171         }
00172 
00173 
00174         int FreeMutex(CyaSSL_Mutex* m)
00175         {
00176             if (pthread_mutex_destroy(m) == 0)
00177                 return 0;
00178             else
00179                 return BAD_MUTEX_E;
00180         }
00181 
00182 
00183         int LockMutex(CyaSSL_Mutex* m)
00184         {
00185             if (pthread_mutex_lock(m) == 0)
00186                 return 0;
00187             else
00188                 return BAD_MUTEX_E;
00189         }
00190 
00191 
00192         int UnLockMutex(CyaSSL_Mutex* m)
00193         {
00194             if (pthread_mutex_unlock(m) == 0)
00195                 return 0;
00196             else
00197                 return BAD_MUTEX_E;
00198         }
00199 
00200     #elif defined(THREADX)
00201 
00202         int InitMutex(CyaSSL_Mutex* m)
00203         {
00204             if (tx_mutex_create(m, "CyaSSL Mutex", TX_NO_INHERIT) == 0)
00205                 return 0;
00206             else
00207                 return BAD_MUTEX_E;
00208         }
00209 
00210 
00211         int FreeMutex(CyaSSL_Mutex* m)
00212         {
00213             if (tx_mutex_delete(m) == 0)
00214                 return 0;
00215             else
00216                 return BAD_MUTEX_E;
00217         }
00218 
00219 
00220         int LockMutex(CyaSSL_Mutex* m)
00221         {
00222             if (tx_mutex_get(m, TX_WAIT_FOREVER) == 0)
00223                 return 0;
00224             else
00225                 return BAD_MUTEX_E;
00226         }
00227 
00228 
00229         int UnLockMutex(CyaSSL_Mutex* m)
00230         {
00231             if (tx_mutex_put(m) == 0)
00232                 return 0;
00233             else
00234                 return BAD_MUTEX_E;
00235         }
00236 
00237     #elif defined(MICRIUM)
00238 
00239         int InitMutex(CyaSSL_Mutex* m)
00240         {
00241             #if (NET_SECURE_MGR_CFG_EN == DEF_ENABLED)
00242                 if (NetSecure_OS_MutexCreate(m) == 0)
00243                     return 0;
00244                 else
00245                     return BAD_MUTEX_E;
00246             #else
00247                 return 0;
00248             #endif
00249         }
00250 
00251 
00252         int FreeMutex(CyaSSL_Mutex* m)
00253         {
00254             #if (NET_SECURE_MGR_CFG_EN == DEF_ENABLED)
00255                 if (NetSecure_OS_FreeMutex(m) == 0)
00256                     return 0;
00257                 else
00258                     return BAD_MUTEX_E;
00259             #else
00260                 return 0;
00261             #endif
00262         }
00263 
00264 
00265         int LockMutex(CyaSSL_Mutex* m)
00266         {
00267             #if (NET_SECURE_MGR_CFG_EN == DEF_ENABLED)
00268                 if (NetSecure_OS_LockMutex(m) == 0)
00269                     return 0;
00270                 else
00271                     return BAD_MUTEX_E;
00272             #else
00273                 return 0;
00274             #endif
00275         }
00276 
00277 
00278         int UnLockMutex(CyaSSL_Mutex* m)
00279         {
00280             #if (NET_SECURE_MGR_CFG_EN == DEF_ENABLED)
00281                 if (NetSecure_OS_UnLockMutex(m) == 0)
00282                     return 0;
00283                 else
00284                     return BAD_MUTEX_E;
00285             #else
00286                 return 0;
00287             #endif
00288 
00289         }
00290 
00291     #elif defined(EBSNET)
00292 
00293         int InitMutex(CyaSSL_Mutex* m)
00294         {
00295             if (rtp_sig_mutex_alloc(m, "CyaSSL Mutex") == -1)
00296                 return BAD_MUTEX_E;
00297             else
00298                 return 0;
00299         }
00300 
00301         int FreeMutex(CyaSSL_Mutex* m)
00302         {
00303             rtp_sig_mutex_free(*m);
00304             return 0;
00305         }
00306 
00307         int LockMutex(CyaSSL_Mutex* m)
00308         {
00309             if (rtp_sig_mutex_claim_timed(*m, RTIP_INF) == 0)
00310                 return 0;
00311             else
00312                 return BAD_MUTEX_E;
00313         }
00314 
00315         int UnLockMutex(CyaSSL_Mutex* m)
00316         {
00317             rtp_sig_mutex_release(*m);
00318             return 0;
00319         }
00320 
00321     #elif defined(FREESCALE_MQX)
00322 
00323         int InitMutex(CyaSSL_Mutex* m)
00324         {
00325             if (_mutex_init(m, NULL) == MQX_EOK)
00326                 return 0;
00327             else
00328                 return BAD_MUTEX_E;
00329         }
00330 
00331         int FreeMutex(CyaSSL_Mutex* m)
00332         {
00333             if (_mutex_destroy(m) == MQX_EOK)
00334                 return 0;
00335             else
00336                 return BAD_MUTEX_E;
00337         }
00338 
00339         int LockMutex(CyaSSL_Mutex* m)
00340         {
00341             if (_mutex_lock(m) == MQX_EOK)
00342                 return 0;
00343             else
00344                 return BAD_MUTEX_E;
00345         }
00346 
00347         int UnLockMutex(CyaSSL_Mutex* m)
00348         {
00349             if (_mutex_unlock(m) == MQX_EOK)
00350                 return 0;
00351             else
00352                 return BAD_MUTEX_E;
00353         }
00354         
00355     #elif defined(CYASSL_MDK_ARM)|| defined(CYASSL_CMSIS_RTOS)
00356     
00357         #if defined(CYASSL_CMSIS_RTOS)
00358             #include "cmsis_os.h"
00359             #define CMSIS_NMUTEX 10
00360             osMutexDef(CyaSSL_mt0) ;  osMutexDef(CyaSSL_mt1) ;  osMutexDef(CyaSSL_mt2) ;
00361             osMutexDef(CyaSSL_mt3) ;  osMutexDef(CyaSSL_mt4) ;  osMutexDef(CyaSSL_mt5) ;  
00362             osMutexDef(CyaSSL_mt6) ;  osMutexDef(CyaSSL_mt7) ;  osMutexDef(CyaSSL_mt8) ;  
00363             osMutexDef(CyaSSL_mt9) ;  
00364             
00365             static const osMutexDef_t *CMSIS_mutex[] = { osMutex(CyaSSL_mt0),   
00366                 osMutex(CyaSSL_mt1),    osMutex(CyaSSL_mt2),   osMutex(CyaSSL_mt3),    
00367                 osMutex(CyaSSL_mt4),    osMutex(CyaSSL_mt5),   osMutex(CyaSSL_mt6),
00368                 osMutex(CyaSSL_mt7),    osMutex(CyaSSL_mt8),    osMutex(CyaSSL_mt9) } ;                 
00369             
00370             static osMutexId CMSIS_mutexID[CMSIS_NMUTEX] = {0} ;
00371 
00372             int InitMutex(CyaSSL_Mutex* m)
00373             {
00374                 int i ;
00375                 for (i=0; i<CMSIS_NMUTEX; i++) {
00376                     if(CMSIS_mutexID[i] == 0) {
00377                         CMSIS_mutexID[i] = osMutexCreate(CMSIS_mutex[i]) ;
00378                         (*m) = CMSIS_mutexID[i] ;
00379                     return 0 ;
00380                     }
00381                 }
00382                 return -1 ;
00383             }
00384 
00385             int FreeMutex(CyaSSL_Mutex* m)
00386             {
00387                 int i ;
00388                 osMutexDelete   (*m) ;
00389                 for (i=0; i<CMSIS_NMUTEX; i++) {
00390                     if(CMSIS_mutexID[i] == (*m)) {
00391                         CMSIS_mutexID[i] = 0 ;
00392                         return(0) ;
00393                     }
00394                 }
00395                 return(-1) ;
00396             }
00397             
00398             int LockMutex(CyaSSL_Mutex* m)
00399             {
00400                 osMutexWait(*m, osWaitForever) ;
00401                 return(0) ;
00402             }
00403 
00404             int UnLockMutex(CyaSSL_Mutex* m)
00405             {
00406                 osMutexRelease (*m);
00407                 return 0;
00408             }
00409         #else
00410 
00411         int InitMutex(CyaSSL_Mutex* m)
00412         {
00413             os_mut_init (m); 
00414             return 0;
00415         }
00416 
00417         int FreeMutex(CyaSSL_Mutex* m)
00418         {
00419             return(0) ;
00420         }
00421 
00422         int LockMutex(CyaSSL_Mutex* m)
00423         {
00424             os_mut_wait (m, 0xffff);
00425             return(0) ;
00426         }
00427 
00428         int UnLockMutex(CyaSSL_Mutex* m)
00429         {
00430             os_mut_release (m);
00431             return 0;
00432         }
00433         #endif
00434     #endif /* USE_WINDOWS_API */
00435 #endif /* SINGLE_THREADED */
00436 
00437