Ignore:
Timestamp:
Jun 22, 2021, 9:00:19 PM (3 years ago)
Author:
coas-nagasima
Message:

WolfSSLとAzure IoT SDKを更新

Location:
azure_iot_hub_f767zi/trunk/wolfssl-4.7.0
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • azure_iot_hub_f767zi/trunk/wolfssl-4.7.0/wolfcrypt/src/wc_port.c

    r457 r464  
    4747#endif
    4848
    49 #if defined(WOLFSSL_ATMEL) || defined(WOLFSSL_ATECC508A)
     49#ifdef WOLFSSL_PSOC6_CRYPTO
     50    #include <wolfssl/wolfcrypt/port/cypress/psoc6_crypto.h>
     51#endif
     52
     53#if defined(WOLFSSL_ATMEL) || defined(WOLFSSL_ATECC508A) || \
     54    defined(WOLFSSL_ATECC608A)
    5055    #include <wolfssl/wolfcrypt/port/atmel/atmel.h>
    5156#endif
    … …  
    6974    defined(WOLFSSL_IMX6_CAAM_BLOB)
    7075    #include <wolfssl/wolfcrypt/port/caam/wolfcaam.h>
     76#endif
     77
     78#ifdef WOLFSSL_IMXRT_DCP
     79    #include <wolfssl/wolfcrypt/port/nxp/dcp_port.h>
    7180#endif
    7281
    … …  
    105114{
    106115    int ret = 0;
    107 
    108116    if (initRefCount == 0) {
    109117        WOLFSSL_ENTER("wolfCrypt_Init");
    … …  
    181189    #endif
    182190
    183     #if defined(WOLFSSL_ATMEL) || defined(WOLFSSL_ATECC508A)
     191    #if defined(WOLFSSL_ATMEL) || defined(WOLFSSL_ATECC508A) || \
     192        defined(WOLFSSL_ATECC608A)
    184193        ret = atmel_init();
    185194        if (ret != 0) {
    … …  
    200209    #endif
    201210
     211    #if defined(WOLFSSL_PSOC6_CRYPTO)
     212        ret = psoc6_crypto_port_init();
     213        if (ret != 0) {
     214            WOLFSSL_MSG("PSoC6 crypto engine init failed");
     215            return ret;
     216        }
     217    #endif
     218
     219    #ifdef WOLFSSL_SILABS_SE_ACCEL
     220        /* init handles if it is already initialized */
     221        ret = sl_se_init();
     222    #endif
     223
    202224    #ifdef WOLFSSL_ARMASM
    203225        WOLFSSL_MSG("Using ARM hardware acceleration");
    … …  
    220242
    221243#ifdef HAVE_ECC
     244    #ifdef FP_ECC
     245        wc_ecc_fp_init();
     246    #endif
    222247    #ifdef ECC_CACHE_CURVE
    223248        if ((ret = wc_ecc_curve_cache_init()) != 0) {
    … …  
    248273#endif
    249274
     275#ifdef WOLFSSL_IMXRT_DCP
     276        if ((ret = wc_dcp_init()) != 0) {
     277            return ret;
     278        }
     279#endif
     280
    250281#if defined(WOLFSSL_DSP) && !defined(WOLFSSL_DSP_BUILD)
    251282        if ((ret = wolfSSL_InitHandle()) != 0) {
    … …  
    260291}
    261292
     293#ifdef WOLFSSL_TRACK_MEMORY_VERBOSE
     294long wolfCrypt_heap_peakAllocs_checkpoint(void) {
     295    long ret = ourMemStats.peakAllocsTripOdometer;
     296    ourMemStats.peakAllocsTripOdometer = ourMemStats.totalAllocs -
     297        ourMemStats.totalDeallocs;
     298    return ret;
     299}
     300long wolfCrypt_heap_peakBytes_checkpoint(void) {
     301    long ret = ourMemStats.peakBytesTripOdometer;
     302    ourMemStats.peakBytesTripOdometer = ourMemStats.currentBytes;
     303    return ret;
     304}
     305#endif
    262306
    263307/* return success value is the same as wolfCrypt_Init */
    … …  
    303347        cc310_Free();
    304348    #endif
     349    #ifdef WOLFSSL_SILABS_SE_ACCEL
     350        ret = sl_se_deinit();
     351    #endif
    305352    #if defined(WOLFSSL_RENESAS_TSIP_CRYPT)
    306353        tsip_Close();
    … …  
    315362}
    316363
    317 #if !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR) && \
    318         !defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)
     364#ifndef NO_FILESYSTEM
     365
     366/* Helpful function to load file into allocated buffer */
     367int wc_FileLoad(const char* fname, unsigned char** buf, size_t* bufLen,
     368    void* heap)
     369{
     370    int ret;
     371    size_t fileSz;
     372    XFILE f;
     373
     374    if (fname == NULL || buf == NULL || bufLen == NULL) {
     375        return BAD_FUNC_ARG;
     376    }
     377
     378    /* set defaults */
     379    *buf = NULL;
     380    *bufLen = 0;
     381
     382    /* open file (read-only binary) */
     383    f = XFOPEN(fname, "rb");
     384    if (!f) {
     385        WOLFSSL_MSG("wc_LoadFile file load error");
     386        return BAD_PATH_ERROR;
     387    }
     388
     389    XFSEEK(f, 0, XSEEK_END);
     390    fileSz = XFTELL(f);
     391    XREWIND(f);
     392    if (fileSz > 0) {
     393        *bufLen = fileSz;
     394        *buf = (byte*)XMALLOC(*bufLen, heap, DYNAMIC_TYPE_TMP_BUFFER);
     395        if (*buf == NULL) {
     396            WOLFSSL_MSG("wc_LoadFile memory error");
     397            ret = MEMORY_E;
     398        }
     399        else {
     400            size_t readLen = XFREAD(*buf, 1, *bufLen, f);
     401
     402            /* check response code */
     403            ret = (readLen == *bufLen) ? 0 : -1;
     404        }
     405    }
     406    else {
     407        ret = BUFFER_E;
     408    }
     409    XFCLOSE(f);
     410
     411    (void)heap;
     412
     413    return ret;
     414}
     415
     416#if !defined(NO_WOLFSSL_DIR) && \
     417    !defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)
    319418
    320419/* File Handling Helpers */
    … …  
    615714}
    616715
    617 #endif /* !NO_FILESYSTEM && !NO_WOLFSSL_DIR */
     716#endif /* !NO_WOLFSSL_DIR */
     717#endif /* !NO_FILESYSTEM */
    618718
    619719#if !defined(NO_FILESYSTEM) && defined(WOLFSSL_ZEPHYR)
    … …  
    622722    XFILE file;
    623723
    624     file = XMALLOC(sizeof(*file), NULL, DYNAMIC_TYPE_FILE);
     724    file = (XFILE)XMALLOC(sizeof(*file), NULL, DYNAMIC_TYPE_FILE);
    625725    if (file != NULL) {
    626726        if (fs_open(file, filename) != 0) {
    … …  
    648748#endif /* !NO_FILESYSTEM && !WOLFSSL_ZEPHYR */
    649749
    650 
     750#if !defined(WOLFSSL_USER_MUTEX)
    651751wolfSSL_Mutex* wc_InitAndAllocMutex(void)
    652752{
    … …  
    666766    return m;
    667767}
     768#endif
    668769
    669770#ifdef USE_WOLF_STRTOK
    … …  
    753854static int wcCryptHwMutexInit = 0;
    754855
    755 int wolfSSL_CryptHwMutexInit(void) {
     856int wolfSSL_CryptHwMutexInit(void)
     857{
    756858    int ret = 0;
    757     if(wcCryptHwMutexInit == 0) {
     859    if (wcCryptHwMutexInit == 0) {
    758860        ret = wc_InitMutex(&wcCryptHwMutex);
    759         if(ret == 0) {
     861        if (ret == 0) {
    760862            wcCryptHwMutexInit = 1;
    761863        }
    … …  
    763865    return ret;
    764866}
    765 
    766 int wolfSSL_CryptHwMutexLock(void) {
     867int wolfSSL_CryptHwMutexLock(void)
     868{
    767869    int ret = BAD_MUTEX_E;
    768 
    769870    /* Make sure HW Mutex has been initialized */
    770     wolfSSL_CryptHwMutexInit();
    771 
    772     if(wcCryptHwMutexInit) {
     871    ret = wolfSSL_CryptHwMutexInit();
     872    if (ret == 0) {
    773873        ret = wc_LockMutex(&wcCryptHwMutex);
    774874    }
    775875    return ret;
    776876}
    777 
    778 int wolfSSL_CryptHwMutexUnLock(void) {
     877int wolfSSL_CryptHwMutexUnLock(void)
     878{
    779879    int ret = BAD_MUTEX_E;
    780 
    781     if(wcCryptHwMutexInit) {
     880    if (wcCryptHwMutexInit) {
    782881        ret = wc_UnLockMutex(&wcCryptHwMutex);
    783882    }
    … …  
    886985    }
    887986
     987#elif defined(RTTHREAD)
     988
     989    int wc_InitMutex(wolfSSL_Mutex* m)
     990    {
     991        int iReturn;
     992
     993        *m = ( wolfSSL_Mutex ) rt_mutex_create("mutex",RT_IPC_FLAG_FIFO);
     994        if( *m != NULL )
     995            iReturn = 0;
     996        else
     997            iReturn = BAD_MUTEX_E;
     998
     999
     1000        return iReturn;
     1001    }
     1002
     1003    int wc_FreeMutex(wolfSSL_Mutex* m)
     1004    {
     1005        rt_mutex_delete( *m );
     1006        return 0;
     1007    }
     1008
     1009
     1010    int wc_LockMutex(wolfSSL_Mutex* m)
     1011    {
     1012        /* Assume an infinite block, or should there be zero block? */
     1013        return rt_mutex_take( *m, RT_WAITING_FOREVER );
     1014    }
     1015
     1016    int wc_UnLockMutex(wolfSSL_Mutex* m)
     1017    {
     1018        return rt_mutex_release( *m );
     1019    }
     1020
    8881021#elif defined(WOLFSSL_SAFERTOS)
    8891022
    … …  
    9801113        else
    9811114            return BAD_MUTEX_E;
     1115    }
     1116
     1117#elif defined(WOLFSSL_KTHREADS)
     1118
     1119    /* Linux kernel mutex routines are voids, alas. */
     1120
     1121    int wc_InitMutex(wolfSSL_Mutex* m)
     1122    {
     1123        mutex_init(m);
     1124        return 0;
     1125    }
     1126
     1127    int wc_FreeMutex(wolfSSL_Mutex* m)
     1128    {
     1129        mutex_destroy(m);
     1130        return 0;
     1131    }
     1132
     1133    int wc_LockMutex(wolfSSL_Mutex* m)
     1134    {
     1135        mutex_lock(m);
     1136        return 0;
     1137    }
     1138
     1139
     1140    int wc_UnLockMutex(wolfSSL_Mutex* m)
     1141    {
     1142        mutex_unlock(m);
     1143        return 0;
    9821144    }
    9831145
    … …  
    11261288
    11271289#elif defined(MICRIUM)
     1290    #if (OS_VERSION < 50000)
     1291        #define MICRIUM_ERR_TYPE OS_ERR
     1292        #define MICRIUM_ERR_NONE OS_ERR_NONE
     1293        #define MICRIUM_ERR_CODE(err) err
     1294    #else
     1295        #define MICRIUM_ERR_TYPE RTOS_ERR
     1296        #define MICRIUM_ERR_NONE RTOS_ERR_NONE
     1297        #define MICRIUM_ERR_CODE(err)    RTOS_ERR_CODE_GET(err)
     1298    #endif
    11281299
    11291300    int wc_InitMutex(wolfSSL_Mutex* m)
    11301301    {
    1131         OS_ERR err;
     1302        MICRIUM_ERR_TYPE err;
    11321303
    11331304        OSMutexCreate(m, "wolfSSL Mutex", &err);
    11341305
    1135         if (err == OS_ERR_NONE)
     1306        if (MICRIUM_ERR_CODE(err) == MICRIUM_ERR_NONE)
    11361307            return 0;
    11371308        else
    … …  
    11421313    {
    11431314        #if (OS_CFG_MUTEX_DEL_EN == DEF_ENABLED)
    1144             OS_ERR err;
     1315            MICRIUM_ERR_TYPE err;
    11451316
    11461317            OSMutexDel(m, OS_OPT_DEL_ALWAYS, &err);
    11471318
    1148             if (err == OS_ERR_NONE)
     1319            if (MICRIUM_ERR_CODE(err) == MICRIUM_ERR_NONE)
    11491320                return 0;
    11501321            else
    11511322                return BAD_MUTEX_E;
    11521323        #else
     1324            (void)m;
    11531325            return 0;
    11541326        #endif
    … …  
    11571329    int wc_LockMutex(wolfSSL_Mutex* m)
    11581330    {
    1159         OS_ERR err;
     1331        MICRIUM_ERR_TYPE err;
    11601332
    11611333        OSMutexPend(m, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
    11621334
    1163         if (err == OS_ERR_NONE)
     1335        if (MICRIUM_ERR_CODE(err) == MICRIUM_ERR_NONE)
    11641336            return 0;
    11651337        else
    … …  
    11691341    int wc_UnLockMutex(wolfSSL_Mutex* m)
    11701342    {
    1171         OS_ERR err;
     1343        MICRIUM_ERR_TYPE err;
    11721344
    11731345        OSMutexPost(m, OS_OPT_POST_NONE, &err);
    11741346
    1175         if (err == OS_ERR_NONE)
     1347        if (MICRIUM_ERR_CODE(err) == MICRIUM_ERR_NONE)
    11761348            return 0;
    11771349        else
    … …  
    18462018    }
    18472019
     2020#elif defined(WOLFSSL_USER_MUTEX)
     2021
     2022    /* Use user own mutex */
     2023   
     2024    /*
     2025    int wc_InitMutex(wolfSSL_Mutex* m) { ... }
     2026    int wc_FreeMutex(wolfSSL_Mutex *m) { ... }
     2027    int wc_LockMutex(wolfSSL_Mutex *m) { ... }
     2028    int wc_UnLockMutex(wolfSSL_Mutex *m) { ... }
     2029    */
     2030
    18482031#else
    18492032    #warning No mutex handling defined
    … …  
    19372120
    19382121    ret->tm_mday  = (int)++dayno;
     2122#ifndef WOLFSSL_LINUXKM
    19392123    ret->tm_isdst = 0;
     2124#endif
    19402125
    19412126    return ret;
    … …  
    19792164    DWORD sec = 0;
    19802165#else
    1981     uint32_t sec = 0;
     2166    word32 sec = 0;
    19822167#endif
    19832168    time_t localTime;
    … …  
    20022187time_t deos_time(time_t* timer)
    20032188{
    2004     const uint32_t systemTickTimeInHz = 1000000 / systemTickInMicroseconds();
    2005     uint32_t *systemTickPtr = systemTickPointer();
     2189    const word32 systemTickTimeInHz = 1000000 / systemTickInMicroseconds();
     2190    word32 *systemTickPtr = systemTickPointer();
    20062191
    20072192    if (timer != NULL)
    … …  
    20712256#include "xrtcpsu.h"
    20722257
    2073 time_t XTIME(time_t * timer)
     2258time_t xilinx_time(time_t * timer)
    20742259{
    20752260    time_t sec = 0;
    … …  
    21802365    #endif /* !NO_CRYPT_BENCHMARK */
    21812366#endif /* WOLFSSL_TELIT_M2MB */
     2367
     2368
     2369#if defined(WOLFSSL_LINUXKM)
     2370time_t time(time_t * timer)
     2371{
     2372    time_t ret;
     2373#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
     2374    struct timespec ts;
     2375    getnstimeofday(&ts);
     2376    ret = ts.tv_sec * 1000000000LL + ts.tv_nsec;
     2377#else
     2378    ret = ktime_get_real_seconds();
     2379#endif
     2380    if (timer)
     2381        *timer = ret;
     2382    return ret;
     2383}
     2384#endif /* WOLFSSL_LINUXKM */
    21822385
    21832386#endif /* !NO_ASN_TIME */
    … …  
    22622465#endif /* WOLFSSL_NUCLEUS_1_2 */
    22632466
     2467#ifdef WOLFSSL_LINUXKM
     2468#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
     2469    /* adapted from kvrealloc() draft by Changli Gao, 2010-05-13 */
     2470    void *lkm_realloc(void *ptr, size_t newsize) {
     2471        void *nptr;
     2472        size_t oldsize;
     2473
     2474        if (unlikely(newsize == 0)) {
     2475            kvfree(ptr);
     2476            return ZERO_SIZE_PTR;
     2477        }
     2478
     2479        if (unlikely(ptr == NULL))
     2480            return kvmalloc(newsize, GFP_KERNEL);
     2481
     2482        if (is_vmalloc_addr(ptr)) {
     2483            /* no way to discern the size of the old allocation,
     2484             * because the kernel doesn't export find_vm_area().  if
     2485             * it did, we could then call get_vm_area_size() on the
     2486             * returned struct vm_struct.
     2487             */
     2488            return NULL;
     2489        } else {
     2490            struct page *page;
     2491
     2492            page = virt_to_head_page(ptr);
     2493            if (PageSlab(page) || PageCompound(page)) {
     2494                if (newsize < PAGE_SIZE)
     2495                    return krealloc(ptr, newsize, GFP_KERNEL);
     2496                oldsize = ksize(ptr);
     2497            } else {
     2498                oldsize = page->private;
     2499                if (newsize <= oldsize)
     2500                    return ptr;
     2501            }
     2502        }
     2503
     2504        nptr = kvmalloc(newsize, GFP_KERNEL);
     2505        if (nptr != NULL) {
     2506            memcpy(nptr, ptr, oldsize);
     2507            kvfree(ptr);
     2508        }
     2509
     2510        return nptr;
     2511    }
     2512#endif /* >= 4.12 */
     2513#endif /* WOLFSSL_LINUXKM */
     2514
    22642515#if defined(WOLFSSL_TI_CRYPT) || defined(WOLFSSL_TI_HASH)
    22652516    #include <wolfcrypt/src/port/ti/ti-ccm.c>  /* initialize and Mutex for TI Crypt Engine */
Note: See TracChangeset for help on using the changeset viewer.