luna - wolfssl/wolfssl/wolfcrypt/wc

   1/* wc_port.h
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22/*!
  23    \file wolfssl/wolfcrypt/wc_port.h
  24*/
  25
  26#ifndef WOLF_CRYPT_PORT_H
  27#define WOLF_CRYPT_PORT_H
  28
  29#include <wolfssl/wolfcrypt/settings.h>
  30#include <wolfssl/wolfcrypt/visibility.h>
  31
  32#ifdef __cplusplus
  33    extern "C" {
  34#endif
  35
  36/* Detect if compiler supports C99. "NO_WOLF_C99" can be defined in
  37 * user_settings.h to disable checking for C99 support. */
  38#if !defined(WOLF_C99) && defined(__STDC_VERSION__) && \
  39    !defined(WOLFSSL_ARDUINO) && !defined(NO_WOLF_C99)
  40    #if __STDC_VERSION__ >= 199901L
  41        #define WOLF_C99
  42    #endif
  43#endif
  44
  45
  46/* GENERIC INCLUDE SECTION */
  47#if defined(FREESCALE_MQX) || defined(FREESCALE_KSDK_MQX)
  48    #include <mqx.h>
  49    #if (defined(MQX_USE_IO_OLD) && MQX_USE_IO_OLD) || \
  50        defined(FREESCALE_MQX_5_0)
  51        #include <fio.h>
  52    #else
  53        #include <nio.h>
  54    #endif
  55#endif
  56
  57#if defined(WOLFSSL_MAX3266X) || defined(WOLFSSL_MAX3266X_OLD)
  58    #include <wolfssl/wolfcrypt/port/maxim/max3266x.h>
  59#endif
  60
  61#ifdef WOLFSSL_LINUXKM
  62    #include "../../linuxkm/linuxkm_wc_port.h"
  63#elif defined(WOLFSSL_BSDKM)
  64    #include "../../bsdkm/bsdkm_wc_port.h"
  65#endif /* WOLFSSL_LINUXKM */
  66
  67#ifndef WARN_UNUSED_RESULT
  68    #if defined(WOLFSSL_LINUXKM) && defined(__must_check)
  69        #define WARN_UNUSED_RESULT __must_check
  70    #elif (defined(__GNUC__) && (__GNUC__ >= 4)) || \
  71        (defined(__IAR_SYSTEMS_ICC__) && (__VER__ >= 9040001))
  72        #define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
  73    #else
  74        #define WARN_UNUSED_RESULT
  75    #endif
  76#endif /* !WARN_UNUSED_RESULT */
  77
  78#ifndef WC_MAYBE_UNUSED
  79    #if (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__clang__) || \
  80            defined(__IAR_SYSTEMS_ICC__)
  81        #define WC_MAYBE_UNUSED __attribute__((unused))
  82    #else
  83        #define WC_MAYBE_UNUSED
  84    #endif
  85#endif /* !WC_MAYBE_UNUSED */
  86
  87#ifndef WC_DEPRECATED
  88    #ifdef WOLFSSL_ZEPHYR
  89        #define WC_DEPRECATED(msg) /* null expansion */
  90    #elif ((defined(__GNUC__) && \
  91            ((__GNUC__ >= 5) || \
  92            ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))) ||  \
  93          defined(__clang__)
  94        #define WC_DEPRECATED(msg) __attribute__((deprecated(msg)))
  95    #elif defined(__WATCOMC__)
  96          /* Watcom macro needs to expand to something, here just a comment: */
  97          #define WC_DEPRECATED(msg) /* null expansion */
  98    #elif (defined(_MSC_VER) && _MSC_VER >= 1400) || defined(__MINGW32__) || \
  99          defined(__CYGWIN__) || defined(_WIN32_WCE)
 100        #define WC_DEPRECATED(msg) __declspec(deprecated(msg))
 101    #elif (defined(__GNUC__) && (__GNUC__ >= 4)) || \
 102          defined(__IAR_SYSTEMS_ICC__)
 103        #define WC_DEPRECATED(msg) __attribute__((deprecated))
 104    #else
 105        #define WC_DEPRECATED(msg) /* null expansion */
 106    #endif
 107#endif /* !WC_DEPRECATED */
 108
 109/* use inlining if compiler allows */
 110#ifndef WC_INLINE
 111#ifndef NO_INLINE
 112    #ifdef _MSC_VER
 113        #define WC_INLINE __inline
 114    #elif defined(__GNUC__)
 115           #ifdef WOLFSSL_VXWORKS
 116               #define WC_INLINE __inline__
 117           #else
 118               #define WC_INLINE inline
 119           #endif
 120    #elif defined(__IAR_SYSTEMS_ICC__)
 121        #define WC_INLINE inline
 122    #elif defined(THREADX)
 123        #define WC_INLINE _Inline
 124    #elif defined(__ghc__)
 125        #ifndef __cplusplus
 126            #define WC_INLINE __inline
 127        #else
 128            #define WC_INLINE inline
 129        #endif
 130    #elif defined(__CCRX__)
 131        #define WC_INLINE inline
 132    #elif defined(__DCC__)
 133        #ifndef __cplusplus
 134            #define WC_INLINE __inline__
 135        #else
 136            #define WC_INLINE inline
 137        #endif
 138    #else
 139        #define WC_INLINE WC_MAYBE_UNUSED
 140    #endif
 141#else
 142    #define WC_INLINE WC_MAYBE_UNUSED
 143#endif
 144#endif
 145
 146#ifndef WC_NO_INLINE
 147    #ifdef noinline
 148        #define WC_NO_INLINE noinline
 149    #elif defined(_MSC_VER)
 150        #define WC_NO_INLINE __declspec(noinline)
 151    #elif defined(__ICCARM__) || defined(__IAR_SYSTEMS_ICC__)
 152        #define WC_NO_INLINE _Pragma("inline = never")
 153    #elif defined(__GNUC__) || defined(__KEIL__) || defined(__DCC__)
 154        #define WC_NO_INLINE __attribute__((noinline))
 155    #else
 156        #define WC_NO_INLINE
 157    #endif
 158#endif
 159
 160#ifndef WC_OMIT_FRAME_POINTER
 161    #if defined(__GNUC__)
 162        #define WC_OMIT_FRAME_POINTER  \
 163            __attribute__((optimize("-fomit-frame-pointer")))
 164    #else
 165        #define WC_OMIT_FRAME_POINTER
 166    #endif
 167#endif
 168
 169/* THREADING/MUTEX SECTION */
 170#if defined(SINGLE_THREADED) && defined(NO_FILESYSTEM)
 171    /* No system headers required for build. */
 172#elif defined(__WATCOMC__)
 173    #if defined(SINGLE_THREADED)
 174        #if defined(USE_WINDOWS_API)
 175            #define _WINSOCKAPI_ /* block inclusion of winsock.h header file */
 176            #include <windows.h>
 177            #undef _WINSOCKAPI_ /* undefine it for MINGW winsock2.h header */
 178            #ifndef WOLFSSL_USER_IO
 179                #include <winsock2.h>
 180                #include <ws2tcpip.h> /* required for InetPton */
 181            #endif
 182        #elif defined(__OS2__)
 183            #include <os2.h>
 184        #endif
 185    #else
 186        #if defined(USE_WINDOWS_API)
 187            #define _WINSOCKAPI_ /* block inclusion of winsock.h header file */
 188            #include <windows.h>
 189            #undef _WINSOCKAPI_ /* undefine it for MINGW winsock2.h header */
 190            #include <process.h>
 191            #ifndef WOLFSSL_USER_IO
 192                #include <winsock2.h>
 193                #include <ws2tcpip.h> /* required for InetPton */
 194            #endif
 195        #elif defined(__NT__)
 196            #define _WINSOCKAPI_ /* block inclusion of winsock.h header file */
 197            #include <windows.h>
 198            #undef _WINSOCKAPI_ /* undefine it for MINGW winsock2.h header file */
 199        #elif defined(__OS2__)
 200            #define INCL_DOSSEMAPHORES
 201            #define INCL_DOSPROCESS
 202            #include <os2.h>
 203            #include <process.h>
 204        #else
 205            #ifndef WOLFSSL_USER_MUTEX
 206                #define WOLFSSL_PTHREADS
 207            #endif
 208            #if defined(WOLFSSL_PTHREADS)
 209                #include <pthread.h>
 210            #endif
 211        #endif
 212    #endif
 213#elif defined(USE_WINDOWS_API)
 214    #if defined(WOLFSSL_PTHREADS)
 215        #include <pthread.h>
 216    #endif
 217    #ifdef WOLFSSL_GAME_BUILD
 218        #include "system/xtl.h"
 219    #else
 220        #ifndef WIN32_LEAN_AND_MEAN
 221            #define WIN32_LEAN_AND_MEAN
 222        #endif
 223        #if !defined(WOLFSSL_SGX) && !defined(WOLFSSL_NOT_WINDOWS_API)
 224            #define _WINSOCKAPI_ /* block inclusion of winsock.h header file. */
 225            #include <windows.h>
 226            #undef _WINSOCKAPI_ /* undefine it for MINGW winsock2.h header */
 227            #ifndef WOLFSSL_USER_IO
 228                #include <winsock2.h>
 229                #include <ws2tcpip.h> /* required for InetPton */
 230            #endif
 231        #endif /* WOLFSSL_SGX */
 232    #endif
 233    #if !defined(SINGLE_THREADED) && !defined(_WIN32_WCE)
 234        #include <process.h>
 235    #endif
 236#elif defined(THREADX)
 237    #ifndef SINGLE_THREADED
 238        #ifdef NEED_THREADX_TYPES
 239            #include <types.h>
 240        #endif
 241        #include <tx_api.h>
 242    #endif
 243#elif defined(WOLFSSL_DEOS)
 244    #include "mutexapi.h"
 245#elif defined(MICRIUM)
 246    /* do nothing, just don't pick Unix */
 247#elif defined(FREERTOS) || defined(FREERTOS_TCP) || defined(WOLFSSL_SAFERTOS)
 248    /* do nothing */
 249#elif defined(RTTHREAD)
 250    /* do nothing */
 251#elif defined(EBSNET)
 252    /* do nothing */
 253#elif defined(FREESCALE_MQX) || defined(FREESCALE_KSDK_MQX)
 254    /* do nothing */
 255#elif defined(FREESCALE_FREE_RTOS)
 256    #include "fsl_os_abstraction.h"
 257#elif defined(WOLFSSL_VXWORKS)
 258    #include <semLib.h>
 259    #ifdef WOLFSSL_VXWORKS_6_x
 260        #ifndef SEM_ID_NULL
 261            #define SEM_ID_NULL ((SEM_ID)NULL)
 262        #endif
 263    #endif
 264#elif defined(WOLFSSL_uITRON4)
 265    #include "stddef.h"
 266    #include "kernel.h"
 267#elif  defined(WOLFSSL_uTKERNEL2)
 268    #include "tk/tkernel.h"
 269#elif defined(WOLFSSL_CMSIS_RTOS)
 270    #include "cmsis_os.h"
 271#elif defined(WOLFSSL_CMSIS_RTOSv2)
 272    #include "cmsis_os2.h"
 273#elif defined(WOLFSSL_MDK_ARM)
 274    #if defined(WOLFSSL_MDK5)
 275        #include "cmsis_os.h"
 276    #else
 277        #include <rtl.h>
 278    #endif
 279#elif defined(WOLFSSL_CMSIS_RTOS)
 280    #include "cmsis_os.h"
 281#elif defined(MBED)
 282    /* do nothing */
 283#elif defined(WOLFSSL_TIRTOS)
 284    #include <ti/sysbios/BIOS.h>
 285    #include <ti/sysbios/knl/Task.h>
 286    #include <ti/sysbios/knl/Semaphore.h>
 287#elif defined(WOLFSSL_FROSTED)
 288    #include <semaphore.h>
 289#elif defined(INTIME_RTOS)
 290    #include <rt.h>
 291    #include <io.h>
 292#elif defined(WOLFSSL_NUCLEUS_1_2)
 293    /* NU_DEBUG needed struct access in nucleus_realloc */
 294    #define NU_DEBUG
 295    #include "plus/nucleus.h"
 296    #include "nucleus.h"
 297#elif defined(WOLFSSL_APACHE_MYNEWT)
 298    /* do nothing */
 299#elif defined(WOLFSSL_ZEPHYR)
 300    #ifdef __cplusplus
 301        }  /* extern "C" */
 302    #endif
 303
 304    #ifdef __has_include
 305        #if __has_include(<zephyr/version.h>)
 306            #include <zephyr/version.h>
 307        #else
 308            #include <version.h>
 309        #endif
 310    #else
 311        #include <version.h>
 312    #endif
 313    /* Include sys/types.h early so host libc sets __timer_t_defined
 314     * before Zephyr's posix_types.h can define a conflicting timer_t */
 315    #include <sys/types.h>
 316    #ifndef SINGLE_THREADED
 317        #if !defined(CONFIG_PTHREAD_IPC) && !defined(CONFIG_POSIX_THREADS)
 318            #error "Threading needs CONFIG_PTHREAD_IPC / CONFIG_POSIX_THREADS"
 319        #endif
 320        #if KERNEL_VERSION_NUMBER >= 0x30100
 321            #include <zephyr/kernel.h>
 322            #ifndef CONFIG_ARCH_POSIX
 323                #include <zephyr/posix/posix_types.h>
 324                #include <zephyr/posix/pthread.h>
 325            #endif
 326        #else
 327            #include <kernel.h>
 328            #ifndef CONFIG_ARCH_POSIX
 329                #include <posix/posix_types.h>
 330                #include <posix/pthread.h>
 331            #endif
 332        #endif
 333    #endif
 334
 335    #ifdef __cplusplus
 336        extern "C" {
 337    #endif
 338#elif defined(WOLFSSL_TELIT_M2MB)
 339
 340    /* Telit SDK uses C++ compile option (--cpp), which causes link issue
 341        to API's if wrapped in extern "C" */
 342    #ifdef __cplusplus
 343        }  /* extern "C" */
 344    #endif
 345
 346    #include "m2mb_types.h"
 347    #include "m2mb_os_types.h"
 348    #include "m2mb_os_api.h"
 349    #include "m2mb_os.h"
 350    #include "m2mb_os_mtx.h"
 351    #ifndef NO_ASN_TIME
 352    #include "m2mb_rtc.h"
 353    #endif
 354    #ifndef NO_FILESYSTEM
 355    #include "m2mb_fs_posix.h"
 356    #endif
 357
 358    #undef kB /* eliminate conflict in asn.h */
 359
 360    #ifdef __cplusplus
 361        extern "C" {
 362    #endif
 363#elif defined(WOLFSSL_EMBOS)
 364    /* do nothing */
 365#else
 366    #ifndef SINGLE_THREADED
 367        #ifndef WOLFSSL_USER_MUTEX
 368            #if defined(WOLFSSL_LINUXKM)
 369                /* definitions are in linuxkm/linuxkm_wc_port.h */
 370            #elif defined(WOLFSSL_BSDKM)
 371                /* definitions are in bsdkm/bsdkm_wc_port.h */
 372            #else
 373                #define WOLFSSL_PTHREADS
 374                #include <pthread.h>
 375            #endif
 376        #endif
 377    #endif
 378    #if (defined(OPENSSL_EXTRA) || defined(GOAHEAD_WS)) && \
 379        !defined(NO_FILESYSTEM)
 380        #ifdef FUSION_RTOS
 381            #include <fclunistd.h>
 382        #else
 383            #include <unistd.h>      /* for close of BIO */
 384        #endif
 385    #endif
 386#endif
 387
 388#ifdef WOLFSSL_API_PREFIX_MAP
 389    #define InitMutex   wc_InitMutex
 390    #define FreeMutex   wc_FreeMutex
 391    #define LockMutex   wc_LockMutex
 392    #define UnLockMutex wc_UnLockMutex
 393#elif defined(HAVE_FIPS)
 394    /* For FIPS keep the function names the same */
 395    #define wc_InitMutex   InitMutex
 396    #define wc_FreeMutex   FreeMutex
 397    #define wc_LockMutex   LockMutex
 398    #define wc_UnLockMutex UnLockMutex
 399#endif /* HAVE_FIPS */
 400
 401#ifdef SINGLE_THREADED
 402    typedef int wolfSSL_Mutex;
 403#else /* MULTI_THREADED */
 404    /* FREERTOS comes first to enable use of FreeRTOS Windows simulator only */
 405    #if defined(FREERTOS)
 406        #if defined(ESP_IDF_VERSION_MAJOR) && (ESP_IDF_VERSION_MAJOR >= 4)
 407            typedef SemaphoreHandle_t wolfSSL_Mutex;
 408        #else
 409            typedef xSemaphoreHandle wolfSSL_Mutex;
 410        #endif
 411    #elif defined(FREERTOS_TCP)
 412        #include "FreeRTOS.h"
 413        #include "semphr.h"
 414        typedef SemaphoreHandle_t  wolfSSL_Mutex;
 415    #elif defined (RTTHREAD)
 416        #include "rtthread.h"
 417        typedef rt_mutex_t wolfSSL_Mutex;
 418    #elif defined(WOLFSSL_SAFERTOS)
 419        typedef struct wolfSSL_Mutex {
 420            signed char mutexBuffer[portQUEUE_OVERHEAD_BYTES];
 421            xSemaphoreHandle mutex;
 422        } wolfSSL_Mutex;
 423    #elif defined(USE_WINDOWS_API) && !defined(WOLFSSL_PTHREADS)
 424        typedef CRITICAL_SECTION wolfSSL_Mutex;
 425    #elif defined(MAXQ10XX_MUTEX)
 426        #include <sys/mman.h>
 427        #include <fcntl.h>
 428        #include <pthread.h>
 429        typedef pthread_mutex_t wolfSSL_Mutex;
 430        int maxq_CryptHwMutexTryLock(void);
 431    #elif defined(WOLFSSL_PTHREADS)
 432        #ifdef WOLFSSL_USE_RWLOCK
 433            typedef pthread_rwlock_t wolfSSL_RwLock;
 434        #endif
 435        typedef pthread_mutex_t wolfSSL_Mutex;
 436        #define WOLFSSL_MUTEX_INITIALIZER(lockname) PTHREAD_MUTEX_INITIALIZER
 437    #elif defined(THREADX)
 438        typedef TX_MUTEX wolfSSL_Mutex;
 439    #elif defined(WOLFSSL_DEOS)
 440        typedef mutex_handle_t wolfSSL_Mutex;
 441    #elif defined(MICRIUM)
 442        typedef OS_MUTEX wolfSSL_Mutex;
 443    #elif defined(EBSNET)
 444        #if (defined(RTPLATFORM) && (RTPLATFORM != 0))
 445            typedef RTP_MUTEX wolfSSL_Mutex;
 446        #else
 447            typedef KS_RTIPSEM wolfSSL_Mutex;
 448        #endif
 449    #elif defined(FREESCALE_MQX) || defined(FREESCALE_KSDK_MQX)
 450        typedef MUTEX_STRUCT wolfSSL_Mutex;
 451    #elif defined(FREESCALE_FREE_RTOS)
 452        typedef mutex_t wolfSSL_Mutex;
 453    #elif defined(WOLFSSL_VXWORKS)
 454        typedef SEM_ID wolfSSL_Mutex;
 455    #elif defined(WOLFSSL_uITRON4)
 456        typedef struct wolfSSL_Mutex {
 457            T_CSEM sem ;
 458            ID     id ;
 459        } wolfSSL_Mutex;
 460    #elif defined(WOLFSSL_uTKERNEL2)
 461        typedef struct wolfSSL_Mutex {
 462            T_CSEM sem ;
 463            ID     id ;
 464        } wolfSSL_Mutex;
 465    #elif defined(WOLFSSL_MDK_ARM)
 466        #if defined(WOLFSSL_CMSIS_RTOS)
 467            typedef osMutexId wolfSSL_Mutex;
 468        #else
 469            typedef OS_MUT wolfSSL_Mutex;
 470        #endif
 471    #elif defined(WOLFSSL_CMSIS_RTOS)
 472        typedef osMutexId wolfSSL_Mutex;
 473    #elif defined(WOLFSSL_CMSIS_RTOSv2)
 474        typedef osMutexId_t wolfSSL_Mutex;
 475    #elif defined(WOLFSSL_TIRTOS)
 476        typedef ti_sysbios_knl_Semaphore_Handle wolfSSL_Mutex;
 477    #elif defined(WOLFSSL_FROSTED)
 478        typedef mutex_t * wolfSSL_Mutex;
 479    #elif defined(INTIME_RTOS)
 480        typedef RTHANDLE wolfSSL_Mutex;
 481    #elif defined(WOLFSSL_NUCLEUS_1_2)
 482        typedef NU_SEMAPHORE wolfSSL_Mutex;
 483    #elif defined(WOLFSSL_ZEPHYR)
 484        typedef struct k_mutex wolfSSL_Mutex;
 485    #elif defined(WOLFSSL_TELIT_M2MB)
 486        typedef M2MB_OS_MTX_HANDLE wolfSSL_Mutex;
 487    #elif defined(WOLFSSL_EMBOS)
 488        typedef OS_MUTEX wolfSSL_Mutex;
 489    #elif defined(WOLFSSL_USER_MUTEX)
 490        /* typedef User_Mutex wolfSSL_Mutex; */
 491    #elif defined(WOLFSSL_LINUXKM)
 492        /* definitions are in linuxkm/linuxkm_wc_port.h */
 493    #elif defined(WOLFSSL_BSDKM)
 494        /* definitions are in bsdkm/bsdkm_wc_port.h */
 495    #elif defined(__WATCOMC__)
 496        /* OS/2 */
 497        typedef ULONG wolfSSL_Mutex;
 498    #else
 499        #error Need a mutex type in multithreaded mode
 500    #endif /* USE_WINDOWS_API */
 501
 502#endif /* SINGLE_THREADED */
 503
 504#ifdef WOLFSSL_TEST_NO_MUTEX_INITIALIZER
 505    #undef WOLFSSL_MUTEX_INITIALIZER
 506#endif
 507
 508#ifdef WOLFSSL_MUTEX_INITIALIZER
 509    #define WOLFSSL_MUTEX_INITIALIZER_CLAUSE(lockname) = WOLFSSL_MUTEX_INITIALIZER(lockname)
 510#else
 511    #define WOLFSSL_MUTEX_INITIALIZER_CLAUSE(lockname) /* null expansion */
 512#endif
 513
 514#if !defined(WOLFSSL_USE_RWLOCK) || defined(SINGLE_THREADED) || \
 515    (defined(WC_MUTEX_OPS_INLINE) && !defined(WC_RWLOCK_OPS_INLINE))
 516    typedef wolfSSL_Mutex wolfSSL_RwLock;
 517#endif
 518
 519#ifndef WOLFSSL_NO_ATOMICS
 520    #if defined(WOLFSSL_USER_DEFINED_ATOMICS)
 521        /* user-supplied bindings for wolfSSL_Atomic_Int etc. */
 522        #if !defined(WOLFSSL_ATOMIC_INITIALIZER) || \
 523            !defined(WOLFSSL_ATOMIC_LOAD) || \
 524            !defined(WOLFSSL_ATOMIC_STORE)
 525            #error WOLFSSL_USER_DEFINED_ATOMICS is set but macro(s) are missing.
 526        #else
 527            #define WOLFSSL_ATOMIC_OPS
 528        #endif
 529    #elif defined(SINGLE_THREADED)
 530        typedef int wolfSSL_Atomic_Int;
 531        typedef unsigned int wolfSSL_Atomic_Uint;
 532        #define WOLFSSL_ATOMIC_INITIALIZER(x) (x)
 533        #define WOLFSSL_ATOMIC_LOAD(x) (x)
 534        #define WOLFSSL_ATOMIC_STORE(x, val) (x) = (val)
 535        #define WOLFSSL_ATOMIC_OPS
 536    #elif defined(WOLFSSL_BSDKM)
 537    /* Note: <stdatomic.h> can be safely included in both linux kernel and
 538     * userspace builds. In FreeBSD kernel however it does nothing and
 539     * should not be included. Use FreeBSD <machine/atomic.h> instead.
 540     * definitions are in bsdkm/bsdkm_wc_port.h */
 541    #elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H) && \
 542        !defined(__cplusplus) && \
 543        !(defined(__clang__) && defined(WOLFSSL_KERNEL_MODE))
 544        /* Default C Implementation */
 545        #include <stdatomic.h>
 546        typedef atomic_int wolfSSL_Atomic_Int;
 547        typedef atomic_uint wolfSSL_Atomic_Uint;
 548        #define WOLFSSL_ATOMIC_INITIALIZER(x) (x)
 549        #define WOLFSSL_ATOMIC_LOAD(x) atomic_load(&(x))
 550        #define WOLFSSL_ATOMIC_STORE(x, val) atomic_store(&(x), val)
 551        #define WOLFSSL_ATOMIC_OPS
 552    #elif defined(__GNUC__) && defined(__ATOMIC_CONSUME)
 553        /* direct calls using gcc-style compiler built-ins */
 554        typedef volatile int wolfSSL_Atomic_Int;
 555        typedef volatile unsigned int wolfSSL_Atomic_Uint;
 556        #define WOLFSSL_ATOMIC_INITIALIZER(x) (x)
 557        #define WOLFSSL_ATOMIC_LOAD(x) __atomic_load_n(&(x), \
 558                                                       __ATOMIC_CONSUME)
 559        #define WOLFSSL_ATOMIC_STORE(x, val) __atomic_store_n(&(x), \
 560                                                  val, __ATOMIC_RELEASE)
 561        #define WOLFSSL_ATOMIC_OPS
 562    #elif defined(_MSC_VER) && !defined(WOLFSSL_NOT_WINDOWS_API)
 563        /* Use MSVC compiler intrinsics for atomic ops */
 564        #ifdef _WIN32_WCE
 565            #include <armintr.h>
 566        #else
 567            #include <intrin.h>
 568        #endif
 569        typedef volatile long wolfSSL_Atomic_Int;
 570        typedef volatile unsigned long wolfSSL_Atomic_Uint;
 571        #define WOLFSSL_ATOMIC_INITIALIZER(x) (x)
 572        #define WOLFSSL_ATOMIC_LOAD(x) (x)
 573        #define WOLFSSL_ATOMIC_STORE(x, val) (x) = (val)
 574        #define WOLFSSL_ATOMIC_OPS
 575    #endif
 576
 577    /* If we weren't able to implement atomics above, disable them here. */
 578    #ifndef WOLFSSL_ATOMIC_OPS
 579        #define WOLFSSL_NO_ATOMICS
 580    #endif
 581#endif /* !WOLFSSL_NO_ATOMICS */
 582
 583#ifdef WOLFSSL_NO_ATOMICS
 584    #define WOLFSSL_ATOMIC_INITIALIZER(x) (x)
 585    #define WOLFSSL_ATOMIC_LOAD(x) (x)
 586    #define WOLFSSL_ATOMIC_STORE(x, val) (x) = (val)
 587#endif /* WOLFSSL_NO_ATOMICS */
 588
 589/* WOLFSSL_ATOMIC_COERCE_INT() needs to accept either a regular int or a
 590 * wolfSSL_Atomic_Int as its argument, and evaluate to a regular int.
 591 * Allows a user-supplied override definition with type introspection.
 592 */
 593#ifndef WOLFSSL_ATOMIC_COERCE_INT
 594    #define WOLFSSL_ATOMIC_COERCE_INT(x) ((int)(x))
 595#endif
 596#ifndef WOLFSSL_ATOMIC_COERCE_UINT
 597    #define WOLFSSL_ATOMIC_COERCE_UINT(x) ((unsigned int)(x))
 598#endif
 599
 600#ifdef WOLFSSL_USER_DEFINED_ATOMICS
 601    /* user-supplied bindings for wolfSSL_Atomic_Int_Init(),
 602     * wolfSSL_Atomic_Int_FetchAdd(), etc.
 603     */
 604#elif defined(WOLFSSL_ATOMIC_OPS) && !defined(SINGLE_THREADED)
 605    WOLFSSL_API void wolfSSL_Atomic_Int_Init(wolfSSL_Atomic_Int* c, int i);
 606    WOLFSSL_API void wolfSSL_Atomic_Uint_Init(
 607        wolfSSL_Atomic_Uint* c, unsigned int i);
 608    /* FetchOp functions return the value of the counter immediately preceding
 609     * the effects of the operation.
 610     * OpFetch functions return the value of the counter immediately after
 611     * the effects of the operation.
 612     */
 613    WOLFSSL_API int wolfSSL_Atomic_Int_FetchAdd(wolfSSL_Atomic_Int* c, int i);
 614    WOLFSSL_API int wolfSSL_Atomic_Int_FetchSub(wolfSSL_Atomic_Int* c, int i);
 615    WOLFSSL_API int wolfSSL_Atomic_Int_AddFetch(wolfSSL_Atomic_Int* c, int i);
 616    WOLFSSL_API int wolfSSL_Atomic_Int_SubFetch(wolfSSL_Atomic_Int* c, int i);
 617    WOLFSSL_API int wolfSSL_Atomic_Int_Exchange(
 618        wolfSSL_Atomic_Int* c, int new_i);
 619    WOLFSSL_API int wolfSSL_Atomic_Int_CompareExchange(
 620        wolfSSL_Atomic_Int* c, int *expected_i, int new_i);
 621    WOLFSSL_API unsigned int wolfSSL_Atomic_Uint_FetchAdd(
 622        wolfSSL_Atomic_Uint* c, unsigned int i);
 623    WOLFSSL_API unsigned int wolfSSL_Atomic_Uint_FetchSub(
 624        wolfSSL_Atomic_Uint* c, unsigned int i);
 625    WOLFSSL_API unsigned int wolfSSL_Atomic_Uint_AddFetch(
 626        wolfSSL_Atomic_Uint* c, unsigned int i);
 627    WOLFSSL_API unsigned int wolfSSL_Atomic_Uint_SubFetch(
 628        wolfSSL_Atomic_Uint* c, unsigned int i);
 629    WOLFSSL_API int wolfSSL_Atomic_Uint_CompareExchange(
 630        wolfSSL_Atomic_Uint* c, unsigned int *expected_i, unsigned int new_i);
 631    WOLFSSL_API int wolfSSL_Atomic_Ptr_CompareExchange(
 632        void* volatile * c, void **expected_ptr, void *new_ptr);
 633#else
 634    /* Code using these fallback implementations in non-SINGLE_THREADED builds
 635     * needs to arrange its own explicit fallback to int for wolfSSL_Atomic_Int
 636     * and unsigned int for wolfSSL_Atomic_Uint, which is not defined if
 637     * !defined(WOLFSSL_ATOMIC_OPS) && !defined(SINGLE_THREADED).  This forces
 638     * local awareness of thread-unsafe semantics.
 639     */
 640    #define wolfSSL_Atomic_Int_Init(c, i) (*(c) = (i))
 641    #define wolfSSL_Atomic_Uint_Init(c, i) (*(c) = (i))
 642    static WC_INLINE int wolfSSL_Atomic_Int_FetchAdd(int *c, int i) {
 643        int ret = *c;
 644        *c += i;
 645        return ret;
 646    }
 647    static WC_INLINE int wolfSSL_Atomic_Int_FetchSub(int *c, int i) {
 648        int ret = *c;
 649        *c -= i;
 650        return ret;
 651    }
 652    static WC_INLINE int wolfSSL_Atomic_Int_AddFetch(int *c, int i) {
 653        return (*c += i);
 654    }
 655    static WC_INLINE int wolfSSL_Atomic_Int_SubFetch(int *c, int i) {
 656        return (*c -= i);
 657    }
 658    static WC_INLINE int wolfSSL_Atomic_Int_Exchange(
 659        int *c, int new_i)
 660    {
 661        int ret = *c;
 662        *c = new_i;
 663        return ret;
 664    }
 665    static WC_INLINE int wolfSSL_Atomic_Int_CompareExchange(
 666        int *c, int *expected_i, int new_i)
 667    {
 668        if (*c == *expected_i) {
 669            *c = new_i;
 670            return 1;
 671        }
 672        else {
 673            *expected_i = *c;
 674            return 0;
 675        }
 676    }
 677    static WC_INLINE int wolfSSL_Atomic_Ptr_CompareExchange(
 678        void * volatile *c, void **expected_ptr, void *new_ptr)
 679    {
 680        if (*(char * volatile *)c == *(char **)expected_ptr) {
 681            *(char * volatile *)c = (char *)new_ptr;
 682            return 1;
 683        }
 684        else {
 685            *(char * volatile *)expected_ptr = *(char * volatile *)c;
 686            return 0;
 687        }
 688    }
 689    static WC_INLINE unsigned int wolfSSL_Atomic_Uint_FetchAdd(
 690        unsigned int *c, unsigned int i)
 691    {
 692        unsigned int ret = *c;
 693        *c += i;
 694        return ret;
 695    }
 696    static WC_INLINE unsigned int wolfSSL_Atomic_Uint_FetchSub(
 697        unsigned int *c, unsigned int i)
 698    {
 699        unsigned int ret = *c;
 700        *c -= i;
 701        return ret;
 702    }
 703    static WC_INLINE unsigned int wolfSSL_Atomic_Uint_AddFetch(
 704        unsigned int *c, unsigned int i)
 705    {
 706        return (*c += i);
 707    }
 708    static WC_INLINE unsigned int wolfSSL_Atomic_Uint_SubFetch(
 709        unsigned int *c, unsigned int i)
 710    {
 711        return (*c -= i);
 712    }
 713    static WC_INLINE int wolfSSL_Atomic_Uint_CompareExchange(
 714        unsigned int *c, unsigned int *expected_i, unsigned int new_i)
 715    {
 716        if (*c == *expected_i) {
 717            *c = new_i;
 718            return 1;
 719        }
 720        else {
 721            *expected_i = *c;
 722            return 0;
 723        }
 724    }
 725#endif
 726
 727/* Reference counting. */
 728typedef struct wolfSSL_RefWithMutex {
 729#if !defined(SINGLE_THREADED)
 730    wolfSSL_Mutex mutex;
 731#endif
 732    int count;
 733} wolfSSL_RefWithMutex;
 734#define wolfSSL_RefWithMutexCur(ref) ((ref).count)
 735#if defined(WOLFSSL_ATOMIC_OPS) && !defined(SINGLE_THREADED)
 736typedef struct wolfSSL_Ref {
 737    wolfSSL_Atomic_Int count;
 738} wolfSSL_Ref;
 739#define wolfSSL_RefCur(ref) WOLFSSL_ATOMIC_LOAD((ref).count)
 740#else
 741typedef struct wolfSSL_RefWithMutex wolfSSL_Ref;
 742#define wolfSSL_RefCur(ref) wolfSSL_RefWithMutexCur(ref)
 743#endif
 744
 745#if defined(SINGLE_THREADED) || defined(WOLFSSL_ATOMIC_OPS)
 746
 747#define wolfSSL_RefInit(ref, err)            \
 748    do {                                     \
 749        wolfSSL_Atomic_Int_Init(&(ref)->count, 1); \
 750        *(err) = 0;                          \
 751    } while(0)
 752#define wolfSSL_RefFree(ref)                 \
 753    do {                                     \
 754        wolfSSL_Atomic_Int_Init(&(ref)->count, 0); \
 755    } while(0)
 756#define wolfSSL_RefInc(ref, err)             \
 757    do {                                     \
 758        (void)wolfSSL_Atomic_Int_FetchAdd(&(ref)->count, 1); \
 759        *(err) = 0;                          \
 760    } while(0)
 761#define wolfSSL_RefInc2(ref, new_count, err) \
 762    do {                                     \
 763        *(new_count) = wolfSSL_Atomic_Int_AddFetch(&(ref)->count, 1); \
 764        *(err) = 0;                          \
 765    } while(0)
 766#define wolfSSL_RefDec(ref, isZero, err)     \
 767    do {                                     \
 768        int __prev = wolfSSL_Atomic_Int_FetchSub(&(ref)->count, 1); \
 769        /* __prev holds the value of count before subtracting 1 */ \
 770        *(isZero) = (__prev == 1);     \
 771        *(err) = 0;                          \
 772    } while(0)
 773#define wolfSSL_RefDec2(ref, new_count, err) \
 774    do {                                     \
 775        *(new_count) = wolfSSL_Atomic_Int_SubFetch(&(ref)->count, 1);    \
 776        *(err) = 0;                          \
 777    } while(0)
 778
 779#else
 780
 781#define WOLFSSL_REFCNT_ERROR_RETURN
 782
 783#define wolfSSL_RefInit wolfSSL_RefWithMutexInit
 784#define wolfSSL_RefFree wolfSSL_RefWithMutexFree
 785#define wolfSSL_RefInc wolfSSL_RefWithMutexInc
 786#define wolfSSL_RefInc2 wolfSSL_RefWithMutexInc2
 787#define wolfSSL_RefDec wolfSSL_RefWithMutexDec
 788#define wolfSSL_RefDec2 wolfSSL_RefWithMutexDec2
 789
 790#endif
 791
 792#if defined(SINGLE_THREADED)
 793
 794#define wolfSSL_RefWithMutexInit wolfSSL_RefInit
 795#define wolfSSL_RefWithMutexFree wolfSSL_RefFree
 796#define wolfSSL_RefWithMutexInc wolfSSL_RefInc
 797#define wolfSSL_RefWithMutexInc2 wolfSSL_RefInc2
 798#define wolfSSL_RefWithMutexLock(ref) 0
 799#define wolfSSL_RefWithMutexUnlock(ref) 0
 800#define wolfSSL_RefWithMutexDec wolfSSL_RefDec
 801#define wolfSSL_RefWithMutexDec2 wolfSSL_RefDec2
 802
 803#else
 804
 805WOLFSSL_LOCAL void wolfSSL_RefWithMutexInit(wolfSSL_RefWithMutex* ref,
 806                                            int* err);
 807WOLFSSL_LOCAL void wolfSSL_RefWithMutexFree(wolfSSL_RefWithMutex* ref);
 808WOLFSSL_LOCAL void wolfSSL_RefWithMutexInc(wolfSSL_RefWithMutex* ref,
 809                                            int* err);
 810WOLFSSL_LOCAL void wolfSSL_RefWithMutexInc2(wolfSSL_RefWithMutex* ref,
 811                                            int *new_count,
 812                                            int* err);
 813WOLFSSL_LOCAL int wolfSSL_RefWithMutexLock(wolfSSL_RefWithMutex* ref);
 814WOLFSSL_LOCAL int wolfSSL_RefWithMutexUnlock(wolfSSL_RefWithMutex* ref);
 815WOLFSSL_LOCAL void wolfSSL_RefWithMutexDec(wolfSSL_RefWithMutex* ref,
 816                                            int* isZero, int* err);
 817WOLFSSL_LOCAL void wolfSSL_RefWithMutexDec2(wolfSSL_RefWithMutex* ref,
 818                                            int* new_count, int* err);
 819
 820#endif
 821
 822
 823/* Enable crypt HW mutex for Freescale MMCAU, PIC32MZ or STM32 */
 824#if defined(FREESCALE_MMCAU) || defined(WOLFSSL_MICROCHIP_PIC32MZ) || \
 825    defined(STM32_CRYPTO) || defined(STM32_HASH) || defined(STM32_RNG) || \
 826    defined(WOLFSSL_MAX3266X) || defined(WOLFSSL_MAX3266X_OLD)
 827    #ifndef WOLFSSL_CRYPT_HW_MUTEX
 828        #define WOLFSSL_CRYPT_HW_MUTEX  1
 829    #endif
 830#endif /* FREESCALE_MMCAU */
 831
 832#ifndef WOLFSSL_CRYPT_HW_MUTEX
 833    #define WOLFSSL_CRYPT_HW_MUTEX  0
 834#endif
 835
 836#if WOLFSSL_CRYPT_HW_MUTEX
 837    /* wolfSSL_CryptHwMutexInit is called on first wolfSSL_CryptHwMutexLock,
 838       however it's recommended to call this directly on Hw init to avoid possible
 839       race condition where two calls to wolfSSL_CryptHwMutexLock are made at
 840       the same time. */
 841    WOLFSSL_LOCAL int wolfSSL_CryptHwMutexInit(void);
 842    WOLFSSL_LOCAL int wolfSSL_CryptHwMutexLock(void);
 843    WOLFSSL_LOCAL int wolfSSL_CryptHwMutexUnLock(void);
 844#else
 845    /* Define stubs, since HW mutex is disabled */
 846    #define wolfSSL_CryptHwMutexInit()      0 /* Success */
 847    #define wolfSSL_CryptHwMutexLock()      0 /* Success */
 848    #define wolfSSL_CryptHwMutexUnLock()    (void)0 /* Success */
 849#endif /* WOLFSSL_CRYPT_HW_MUTEX */
 850
 851#if defined(WOLFSSL_ALGO_HW_MUTEX) && (defined(NO_RNG_MUTEX) && \
 852        defined(NO_AES_MUTEX) && defined(NO_HASH_MUTEX) && defined(NO_PK_MUTEX))
 853        #error WOLFSSL_ALGO_HW_MUTEX does not support having all mutexes off
 854#endif
 855/* To support HW that can do different Crypto in parallel */
 856#if WOLFSSL_CRYPT_HW_MUTEX && defined(WOLFSSL_ALGO_HW_MUTEX)
 857    typedef enum {
 858        #ifndef NO_RNG_MUTEX
 859        rng_mutex,
 860        #endif
 861        #ifndef NO_AES_MUTEX
 862        aes_mutex,
 863        #endif
 864        #ifndef NO_HASH_MUTEX
 865        hash_mutex,
 866        #endif
 867        #ifndef NO_PK_MUTEX
 868        pk_mutex,
 869        #endif
 870    } hw_mutex_algo;
 871#endif
 872
 873/* If algo mutex is off, or WOLFSSL_ALGO_HW_MUTEX is not define, default */
 874/* to using the generic wolfSSL_CryptHwMutex */
 875#if (!defined(NO_RNG_MUTEX) && defined(WOLFSSL_ALGO_HW_MUTEX)) && \
 876    WOLFSSL_CRYPT_HW_MUTEX
 877    WOLFSSL_LOCAL int wolfSSL_HwRngMutexInit(void);
 878    WOLFSSL_LOCAL int wolfSSL_HwRngMutexLock(void);
 879    WOLFSSL_LOCAL int wolfSSL_HwRngMutexUnLock(void);
 880#else
 881    #define wolfSSL_HwRngMutexInit    wolfSSL_CryptHwMutexInit
 882    #define wolfSSL_HwRngMutexLock    wolfSSL_CryptHwMutexLock
 883    #define wolfSSL_HwRngMutexUnLock  wolfSSL_CryptHwMutexUnLock
 884#endif /* !defined(NO_RNG_MUTEX) && defined(WOLFSSL_ALGO_HW_MUTEX) */
 885
 886#if (!defined(NO_AES_MUTEX) && defined(WOLFSSL_ALGO_HW_MUTEX)) && \
 887    WOLFSSL_CRYPT_HW_MUTEX
 888    WOLFSSL_LOCAL int wolfSSL_HwAesMutexInit(void);
 889    WOLFSSL_LOCAL int wolfSSL_HwAesMutexLock(void);
 890    WOLFSSL_LOCAL int wolfSSL_HwAesMutexUnLock(void);
 891#else
 892    #define wolfSSL_HwAesMutexInit    wolfSSL_CryptHwMutexInit
 893    #define wolfSSL_HwAesMutexLock    wolfSSL_CryptHwMutexLock
 894    #define wolfSSL_HwAesMutexUnLock  wolfSSL_CryptHwMutexUnLock
 895#endif /* !defined(NO_AES_MUTEX) && defined(WOLFSSL_ALGO_HW_MUTEX) */
 896
 897#if (!defined(NO_HASH_MUTEX) && defined(WOLFSSL_ALGO_HW_MUTEX)) && \
 898    WOLFSSL_CRYPT_HW_MUTEX
 899    WOLFSSL_LOCAL int wolfSSL_HwHashMutexInit(void);
 900    WOLFSSL_LOCAL int wolfSSL_HwHashMutexLock(void);
 901    WOLFSSL_LOCAL int wolfSSL_HwHashMutexUnLock(void);
 902#else
 903    #define wolfSSL_HwHashMutexInit   wolfSSL_CryptHwMutexInit
 904    #define wolfSSL_HwHashMutexLock   wolfSSL_CryptHwMutexLock
 905    #define wolfSSL_HwHashMutexUnLock wolfSSL_CryptHwMutexUnLock
 906#endif /* !defined(NO_HASH_MUTEX) && defined(WOLFSSL_ALGO_HW_MUTEX) */
 907
 908#if (!defined(NO_PK_MUTEX) && defined(WOLFSSL_ALGO_HW_MUTEX)) && \
 909    WOLFSSL_CRYPT_HW_MUTEX
 910    WOLFSSL_LOCAL int wolfSSL_HwPkMutexInit(void);
 911    WOLFSSL_LOCAL int wolfSSL_HwPkMutexLock(void);
 912    WOLFSSL_LOCAL int wolfSSL_HwPkMutexUnLock(void);
 913#else
 914    #define wolfSSL_HwPkMutexInit     wolfSSL_CryptHwMutexInit
 915    #define wolfSSL_HwPkMutexLock     wolfSSL_CryptHwMutexLock
 916    #define wolfSSL_HwPkMutexUnLock   wolfSSL_CryptHwMutexUnLock
 917#endif /* !defined(NO_PK_MUTEX) && defined(WOLFSSL_ALGO_HW_MUTEX) */
 918
 919/* Mutex functions */
 920#ifndef WC_MUTEX_OPS_INLINE
 921    WOLFSSL_API int wc_InitMutex(wolfSSL_Mutex* m);
 922    WOLFSSL_API int wc_FreeMutex(wolfSSL_Mutex* m);
 923    WOLFSSL_API int wc_LockMutex(wolfSSL_Mutex* m);
 924    WOLFSSL_API int wc_UnLockMutex(wolfSSL_Mutex* m);
 925#endif
 926WOLFSSL_API wolfSSL_Mutex* wc_InitAndAllocMutex(void);
 927#ifndef WC_RWLOCK_OPS_INLINE
 928    /* RwLock functions. Fallback to Mutex when not implemented explicitly. */
 929    WOLFSSL_API int wc_InitRwLock(wolfSSL_RwLock* m);
 930    WOLFSSL_API int wc_FreeRwLock(wolfSSL_RwLock* m);
 931    WOLFSSL_API int wc_LockRwLock_Wr(wolfSSL_RwLock* m);
 932    WOLFSSL_API int wc_LockRwLock_Rd(wolfSSL_RwLock* m);
 933    WOLFSSL_API int wc_UnLockRwLock(wolfSSL_RwLock* m);
 934#endif
 935#if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER)
 936/* dynamically set which mutex to use. unlock / lock is controlled by flag */
 937typedef void (mutex_cb)(int flag, int type, const char* file, int line);
 938
 939WOLFSSL_API int wc_LockMutex_ex(int flag, int type, const char* file, int line);
 940WOLFSSL_API int wc_SetMutexCb(mutex_cb* cb);
 941WOLFSSL_API mutex_cb* wc_GetMutexCb(void);
 942#endif
 943
 944/* main crypto initialization function */
 945WOLFSSL_ABI WOLFSSL_API int wolfCrypt_Init(void);
 946WOLFSSL_ABI WOLFSSL_API int wolfCrypt_Cleanup(void);
 947
 948#ifdef WOLFSSL_TRACK_MEMORY_VERBOSE
 949    WOLFSSL_API long wolfCrypt_heap_peakAllocs_checkpoint(void);
 950    WOLFSSL_API long wolfCrypt_heap_peakBytes_checkpoint(void);
 951#endif
 952
 953
 954/* FILESYSTEM SECTION */
 955/* filesystem abstraction layer, used by ssl.c */
 956#ifndef NO_FILESYSTEM
 957
 958#if defined(EBSNET)
 959    #include "vfapi.h"
 960    #include "vfile.h"
 961
 962    int ebsnet_fseek(int a, long b, int c); /* Not prototyped in vfile.h per
 963                                             * EBSnet feedback */
 964
 965    #define XFILE                    int
 966    #define XFOPEN(NAME, MODE)       vf_open((const char *)NAME, VO_RDONLY, 0)
 967    #define XFSEEK                   ebsnet_fseek
 968    #define XFTELL                   vf_tell
 969    #define XFREAD(BUF, SZ, AMT, FD) vf_read(FD, BUF, SZ*AMT)
 970    #define XFWRITE(BUF, SZ, AMT, FD) vf_write(FD, BUF, SZ*AMT)
 971    #define XFCLOSE                  vf_close
 972    #define XSEEK_SET                VSEEK_SET
 973    #define XSEEK_END                VSEEK_END
 974    #define XBADFILE                 -1
 975    #define XFGETS(b,s,f)            -2 /* Not ported yet */
 976    #define XSNPRINTF rtp_snprintf
 977    #define XFPRINTF fprintf
 978
 979#elif defined(LSR_FS)
 980    #include <fs.h>
 981    #define XFILE                   struct fs_file*
 982    #define XFOPEN(NAME, MODE)      fs_open((char*)NAME)
 983    #define XFSEEK(F, O, W)         (void)F
 984    #define XFTELL(F)               (F)->len
 985    #define XFREAD(BUF, SZ, AMT, F) fs_read(F, (char*)BUF, SZ*AMT)
 986    #define XFWRITE(BUF, SZ, AMT, F) fs_write(F, (char*)BUF, SZ*AMT)
 987    #define XFCLOSE                 fs_close
 988    #define XSEEK_SET               0
 989    #define XSEEK_END               0
 990    #define XBADFILE                NULL
 991    #define XFGETS(b,s,f)           -2 /* Not ported yet */
 992
 993#elif defined(FREESCALE_MQX) || defined(FREESCALE_KSDK_MQX)
 994    #define XFILE                   MQX_FILE_PTR
 995    #define XFOPEN                  fopen
 996    #define XFSEEK                  fseek
 997    #define XFTELL                  ftell
 998    #define XFREAD                  fread
 999    #define XFWRITE                 fwrite
1000    #define XFCLOSE                 fclose
1001    #define XSEEK_SET               IO_SEEK_SET
1002    #define XSEEK_END               IO_SEEK_END
1003    #define XBADFILE                NULL
1004    #define XFGETS                  fgets
1005    #define XFPRINTF                fprintf
1006
1007#elif defined(WOLFSSL_DEOS)
1008    #define NO_FILESYSTEM
1009    #warning "TODO - DDC-I Certifiable Fast File System for Deos is not integrated"
1010#elif defined(MICRIUM)
1011    #include <fs_api.h>
1012    #define XFILE      FS_FILE*
1013    #define XFOPEN     fs_fopen
1014    #define XFSEEK     fs_fseek
1015    #define XFTELL     fs_ftell
1016    #define XFREAD     fs_fread
1017    #define XFWRITE    fs_fwrite
1018    #define XFCLOSE    fs_fclose
1019    #define XSEEK_SET  FS_SEEK_SET
1020    #define XSEEK_END  FS_SEEK_END
1021    #define XBADFILE   NULL
1022    #define XFGETS(b,s,f) -2 /* Not ported yet */
1023
1024#elif defined(WOLFSSL_NUCLEUS_1_2)
1025    #include "fal/inc/fal.h"
1026    #define XFILE      FILE*
1027    #define XFOPEN     fopen
1028    #define XFSEEK     fseek
1029    #define XFTELL     ftell
1030    #define XFREAD     fread
1031    #define XFWRITE    fwrite
1032    #define XFCLOSE    fclose
1033    #define XSEEK_SET  PSEEK_SET
1034    #define XSEEK_END  PSEEK_END
1035    #define XBADFILE   NULL
1036
1037#elif defined(WOLFSSL_APACHE_MYNEWT)
1038    #include <fs/fs.h>
1039    #define XFILE  struct fs_file*
1040
1041    #define XFOPEN     mynewt_fopen
1042    #define XFSEEK     mynewt_fseek
1043    #define XFTELL     mynewt_ftell
1044    #define XFREAD     mynewt_fread
1045    #define XFWRITE    mynewt_fwrite
1046    #define XFCLOSE    mynewt_fclose
1047    #define XSEEK_SET  0
1048    #define XSEEK_END  2
1049    #define XBADFILE   NULL
1050    #define XFGETS(b,s,f) -2 /* Not ported yet */
1051
1052#elif defined(WOLFSSL_ZEPHYR)
1053    #ifdef __cplusplus
1054        }  /* extern "C" */
1055    #endif
1056
1057    #include <zephyr/fs/fs.h>
1058
1059    #ifdef __cplusplus
1060        extern "C" {
1061    #endif
1062
1063    #define XFILE      struct fs_file_t*
1064
1065    /* These are our wrappers for opening and closing files to
1066     * make the API more POSIX like. */
1067    XFILE z_fs_open(const char* filename, const char* mode);
1068    int z_fs_close(XFILE file);
1069    int z_fs_rewind(XFILE file);
1070
1071    #define XFOPEN              z_fs_open
1072    #define XFCLOSE             z_fs_close
1073    #define XFFLUSH             fs_sync
1074    #define XFSEEK              fs_seek
1075    #define XFTELL              fs_tell
1076    #define XFREWIND            z_fs_rewind
1077    #define XFREAD(P,S,N,F)     fs_read(F, P, S*N)
1078    #define XFWRITE(P,S,N,F)    fs_write(F, P, S*N)
1079    #define XSEEK_SET           FS_SEEK_SET
1080    #define XSEEK_END           FS_SEEK_END
1081    #define XBADFILE            NULL
1082    #define XBADFD              (-1)
1083    #define XFGETS(b,s,f)       -2 /* Not ported yet */
1084
1085    #define XSTAT               fs_stat
1086    #define XSTAT_TYPE          struct fs_dirent
1087    #define XS_ISREG(s)         (s == FS_DIR_ENTRY_FILE)
1088    #define SEPARATOR_CHAR      ':'
1089
1090#elif defined(WOLFSSL_TELIT_M2MB)
1091    #define XFILE                    INT32
1092    #define XFOPEN(NAME, MODE)       m2mb_fs_open((NAME), 0, (MODE))
1093    #define XFSEEK(F, O, W)          m2mb_fs_lseek((F), (O), (W))
1094    #define XFTELL(F)                m2mb_fs_lseek((F), 0, M2MB_SEEK_END)
1095    #define XFREAD(BUF, SZ, AMT, F)  m2mb_fs_read((F), (BUF), (SZ)*(AMT))
1096    #define XFWRITE(BUF, SZ, AMT, F) m2mb_fs_write((F), (BUF), (SZ)*(AMT))
1097    #define XFCLOSE                  m2mb_fs_close
1098    #define XSEEK_SET                M2MB_SEEK_SET
1099    #define XSEEK_END                M2MB_SEEK_END
1100    #define XBADFILE                 -1
1101    #define XFGETS(b,s,f)            -2 /* Not ported yet */
1102
1103#elif defined (WOLFSSL_XILINX)
1104    #include "xsdps.h"
1105    #include "ff.h"
1106
1107    /* workaround to declare variable and provide type */
1108    #define XFILE                    FIL curFile; FIL*
1109    #define XFOPEN(NAME, MODE)       ({ FRESULT res; res = f_open(&curFile, (NAME), (FA_OPEN_ALWAYS | FA_WRITE | FA_READ)); (res == FR_OK) ? &curFile : NULL; })
1110    #define XFSEEK(F, O, W)          f_lseek((F), (O))
1111    #define XFTELL(F)                f_tell((F))
1112    #define XFREAD(BUF, SZ, AMT, F)  ({ FRESULT res; UINT br; res = f_read((F), (BUF), (SZ)*(AMT), &br); (void)br; res; })
1113    #define XFWRITE(BUF, SZ, AMT, F) ({ FRESULT res; UINT written; res = f_write((F), (BUF), (SZ)*(AMT), &written); (void)written; res; })
1114    #define XFCLOSE(F)               f_close((F))
1115    #define XSEEK_SET                0
1116    #define XSEEK_END                0
1117    #define XBADFILE                 NULL
1118    #define XFGETS(b,s,f)            f_gets((b), (s), (f))
1119#elif defined (_WIN32_WCE)
1120    /* stdio, WINCE case */
1121    #include <stdio.h>
1122    #define XFILE      FILE*
1123    #define XFOPEN     fopen
1124    #define XFDOPEN    fdopen
1125    #define XFSEEK     fseek
1126    #define XFTELL     ftell
1127    #define XFREAD     fread
1128    #define XFWRITE    fwrite
1129    #define XFCLOSE    fclose
1130    #define XSEEK_SET  SEEK_SET
1131    #define XSEEK_END  SEEK_END
1132    #define XBADFILE   NULL
1133    #define XFGETS     fgets
1134    #define XVSNPRINTF _vsnprintf
1135
1136#elif defined(FUSION_RTOS)
1137    #include <fclstdio.h>
1138    #include <fclunistd.h>
1139    #include <fcldirent.h>
1140    #include <sys/fclstat.h>
1141    #include <fclstring.h>
1142    #include <fcl_os.h>
1143    #define XFILE     FCL_FILE*
1144    #define XFOPEN    FCL_FOPEN
1145    #define XFSEEK    FCL_FSEEK
1146    #define XFTELL    FCL_FTELL
1147    #define XFREAD    FCL_FREAD
1148    #define XFWRITE   FCL_FWRITE
1149    #define XFCLOSE   FCL_FCLOSE
1150    #define XSEEK_SET SEEK_SET
1151    #define XSEEK_END SEEK_END
1152    #define XBADFILE  NULL
1153    #define XFGETS    FCL_FGETS
1154    #define XFPUTS    FCL_FPUTS
1155    #define XFPRINTF  FCL_FPRINTF
1156    #define XVFPRINTF FCL_VFPRINTF
1157    #define XVSNPRINTF  FCL_VSNPRINTF
1158    #define XSNPRINTF  FCL_SNPRINTF
1159    #define XSPRINTF  FCL_SPRINTF
1160    #define DIR       FCL_DIR
1161    #define stat      FCL_STAT
1162    #define opendir   FCL_OPENDIR
1163    #define closedir  FCL_CLOSEDIR
1164    #define readdir   FCL_READDIR
1165    #define dirent    fclDirent
1166    #define strncasecmp FCL_STRNCASECMP
1167
1168    /* FUSION SPECIFIC ERROR CODE */
1169    #define FUSION_IO_SEND_E FCL_EWOULDBLOCK
1170
1171#elif defined(WOLFSSL_USER_FILESYSTEM)
1172    /* To be defined in user_settings.h */
1173#else
1174    /* stdio, default case */
1175    #include <stdio.h>
1176    #define XFILE      FILE*
1177    #if defined(WOLFSSL_MDK_ARM)
1178        extern FILE * wolfSSL_fopen(const char *name, const char *mode) ;
1179        #define XFOPEN     wolfSSL_fopen
1180    #else
1181        #define XFOPEN     fopen
1182    #endif
1183    #define XFDOPEN    fdopen
1184    #define XFSEEK     fseek
1185    #define XFTELL     ftell
1186    #define XFREAD     fread
1187    #define XFWRITE    fwrite
1188    #define XFCLOSE    fclose
1189    #define XSEEK_SET  SEEK_SET
1190    #define XSEEK_END  SEEK_END
1191    #define XBADFILE   NULL
1192    #define XBADFD     (-1)
1193    #define XFGETS     fgets
1194    #define XFPRINTF   fprintf
1195    #define XFFLUSH    fflush
1196    #define XFEOF(fp)  feof(fp)
1197    #define XFERROR(fp) ferror(fp)
1198    #define XCLEARERR(fp) clearerr(fp)
1199
1200    #if !defined(NO_WOLFSSL_DIR)\
1201        && !defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)
1202        #if defined(__WATCOMC__)
1203            #include <unistd.h>
1204            #include <sys/stat.h>
1205            #define XWRITE      write
1206            #define XREAD       read
1207            #define XCLOSE      close
1208            #define XSTAT       stat
1209            #define XS_ISREG(s) S_ISREG(s)
1210            #if defined(__UNIX__)
1211                #include <dirent.h>
1212                #define SEPARATOR_CHAR ':'
1213            #else
1214                #include <direct.h>
1215                #define SEPARATOR_CHAR ';'
1216            #endif
1217            #if defined(__NT__)
1218                #define XALTHOMEVARNAME "USERPROFILE"
1219            #endif
1220        #elif defined(USE_WINDOWS_API)
1221            #include <io.h>
1222            #include <sys/stat.h>
1223            #ifndef XSTAT
1224                #define XSTAT       _stat
1225            #endif
1226            #define XS_ISREG(s) (s & _S_IFREG)
1227            #define SEPARATOR_CHAR ';'
1228            #define XWRITE      _write
1229            #define XREAD       _read
1230            #define XALTHOMEVARNAME "USERPROFILE"
1231
1232        #elif defined(ARDUINO)
1233            #ifndef XSTAT
1234                #define XSTAT       _stat
1235            #endif
1236            #define XS_ISREG(s) (s & _S_IFREG)
1237            #define SEPARATOR_CHAR ';'
1238
1239        #elif defined(INTIME_RTOS)
1240            #include <sys/stat.h>
1241            #ifndef XSTAT
1242            #define XSTAT _stat64
1243            #endif
1244            #define XS_ISREG(s) S_ISREG(s)
1245            #define SEPARATOR_CHAR ';'
1246            #define XWRITE      write
1247            #define XREAD       read
1248            #define XCLOSE      close
1249
1250        #elif defined(WOLFSSL_TELIT_M2MB)
1251            #ifndef XSTAT
1252            #define XSTAT       m2mb_fs_stat
1253            #endif
1254            #define XS_ISREG(s) (s & M2MB_S_IFREG)
1255            #define SEPARATOR_CHAR ':'
1256
1257        #else
1258            #include <dirent.h>
1259            #include <unistd.h>
1260            #include <sys/stat.h>
1261            #define XWRITE      write
1262            #define XREAD       read
1263            #define XCLOSE      close
1264            #ifndef XSTAT
1265            #define XSTAT       stat
1266            #endif
1267            #define XS_ISREG(s) S_ISREG(s)
1268            #define SEPARATOR_CHAR ':'
1269        #endif
1270
1271        #ifndef XSTAT_TYPE
1272            #define XSTAT_TYPE struct XSTAT
1273        #endif
1274    #endif /* !NO_WOLFSSL_DIR !WOLFSSL_NUCLEUS !WOLFSSL_NUCLEUS_1_2 */
1275#endif
1276
1277    #ifndef MAX_FILENAME_SZ
1278        #define MAX_FILENAME_SZ (260 + 1) /* max file name length */
1279    #endif
1280    #ifndef MAX_PATH
1281        #define MAX_PATH (260 + 1)
1282    #endif
1283    #ifndef XFEOF
1284        #define XFEOF(fp)  0
1285    #endif
1286    #ifndef XFERROR
1287        #define XFERROR(fp) 0
1288    #endif
1289    #ifndef XCLEARERR
1290        #define XCLEARERR(fp) WC_DO_NOTHING
1291    #endif
1292
1293    WOLFSSL_API int wc_FileLoad(const char* fname, unsigned char** buf,
1294        size_t* bufLen, void* heap);
1295
1296#if !defined(NO_WOLFSSL_DIR) && !defined(WOLFSSL_NUCLEUS) && \
1297    !defined(WOLFSSL_NUCLEUS_1_2)
1298    typedef struct ReadDirCtx {
1299    #ifdef USE_WINDOWS_API
1300        WIN32_FIND_DATAA FindFileData;
1301        HANDLE hFind;
1302        XSTAT_TYPE s;
1303    #elif defined(WOLFSSL_ZEPHYR)
1304        struct fs_dirent entry;
1305        struct fs_dir_t  dir;
1306        struct fs_dirent s;
1307        struct fs_dir_t* dirp;
1308
1309    #elif defined(WOLFSSL_TELIT_M2MB)
1310        M2MB_DIR_T* dir;
1311        struct M2MB_DIRENT* entry;
1312        struct M2MB_STAT s;
1313    #elif defined(INTIME_RTOS)
1314        struct stat64 s;
1315        struct _find64 FindFileData;
1316        #define IntimeFindFirst(name, data) (0 == _findfirst64(name, data))
1317        #define IntimeFindNext(data)  (0 == _findnext64(data))
1318        #define IntimeFindClose(data) (0 == _findclose64(data))
1319        #define IntimeFilename(ctx)   ctx->FindFileData.f_filename
1320    #elif defined(ARDUINO)
1321        /* TODO: board specific features */
1322    #else
1323        struct dirent* entry;
1324        DIR*   dir;
1325        XSTAT_TYPE s;
1326    #endif
1327        char name[MAX_FILENAME_SZ];
1328    } ReadDirCtx;
1329
1330    #define WC_READDIR_NOFILE (-1)
1331
1332    WOLFSSL_API int wc_ReadDirFirst(ReadDirCtx* ctx, const char* path, char** name);
1333    WOLFSSL_API int wc_ReadDirNext(ReadDirCtx* ctx, const char* path, char** name);
1334    WOLFSSL_API void wc_ReadDirClose(ReadDirCtx* ctx);
1335#endif /* !NO_WOLFSSL_DIR */
1336    #define WC_ISFILEEXIST_NOFILE (-1)
1337
1338    WOLFSSL_API int wc_FileExists(const char* fname);
1339
1340#endif /* !NO_FILESYSTEM */
1341
1342/* Defaults, user may over-ride with user_settings.h or in a porting section
1343 * above
1344 */
1345#ifndef XVFPRINTF
1346    #define XVFPRINTF  vfprintf
1347#endif
1348#ifndef XVSNPRINTF
1349    #define XVSNPRINTF vsnprintf
1350#endif
1351#ifndef XFPUTS
1352    #define XFPUTS     fputs
1353#endif
1354#ifndef XSPRINTF
1355    #define XSPRINTF   sprintf
1356#endif
1357
1358#ifdef USE_WINDOWS_API
1359    #ifndef SOCKET_T
1360        #ifdef __MINGW64__
1361            typedef size_t SOCKET_T;
1362        #else
1363            typedef unsigned int SOCKET_T;
1364        #endif
1365    #endif
1366    #ifndef SOCKET_INVALID
1367        #define SOCKET_INVALID INVALID_SOCKET
1368    #endif
1369#else
1370    #ifndef SOCKET_T
1371        typedef int SOCKET_T;
1372    #endif
1373    #ifndef SOCKET_INVALID
1374        #define SOCKET_INVALID (-1)
1375    #endif
1376#endif
1377
1378/* MIN/MAX MACRO SECTION */
1379/* Windows API defines its own min() macro. */
1380#if defined(USE_WINDOWS_API)
1381    #if defined(min) || defined(WOLFSSL_MYSQL_COMPATIBLE)
1382        #undef  WOLFSSL_HAVE_MIN
1383        #define WOLFSSL_HAVE_MIN
1384    #endif /* min */
1385    #if defined(max) || defined(WOLFSSL_MYSQL_COMPATIBLE)
1386        #undef  WOLFSSL_HAVE_MAX
1387        #define WOLFSSL_HAVE_MAX
1388    #endif /* max */
1389#endif /* USE_WINDOWS_API */
1390
1391#ifdef __QNXNTO__
1392    #define WOLFSSL_HAVE_MIN
1393    #define WOLFSSL_HAVE_MAX
1394#endif
1395
1396/* TIME SECTION */
1397/* Time functions */
1398#ifndef NO_ASN_TIME
1399#if defined(USER_TIME)
1400    /* Use our gmtime and time_t/struct tm types.
1401       Only needs seconds since EPOCH using XTIME function.
1402       time_t XTIME(time_t * timer) {}
1403    */
1404    #define WOLFSSL_GMTIME
1405    #ifndef HAVE_TM_TYPE
1406        #define USE_WOLF_TM
1407    #endif
1408    #ifndef HAVE_TIME_T_TYPE
1409        #define USE_WOLF_TIME_T
1410    #endif
1411
1412#elif defined(TIME_OVERRIDES)
1413    /* Override XTIME() and XGMTIME() functionality.
1414       Requires user to provide these functions:
1415        time_t XTIME(time_t * timer) {}
1416        struct tm* XGMTIME(const time_t* timer, struct tm* tmp) {}
1417    */
1418    #ifndef HAVE_TIME_T_TYPE
1419        #define USE_WOLF_TIME_T
1420    #endif
1421    #ifndef HAVE_TM_TYPE
1422        #define USE_WOLF_TM
1423    #endif
1424    #define NEED_TMP_TIME
1425
1426#elif defined(WOLFSSL_XILINX)
1427    #ifndef XTIME
1428        #define XTIME(t1)       xilinx_time((t1))
1429    #endif
1430    #include <time.h>
1431    time_t xilinx_time(time_t * timer);
1432
1433#elif defined(HAVE_RTP_SYS)
1434    #include "os.h"           /* dc_rtc_api needs    */
1435    #include "dc_rtc_api.h"   /* to get current time */
1436
1437    /* uses partial <time.h> structures */
1438    #define XTIME(tl)       (0)
1439    #define XGMTIME(c, t)   rtpsys_gmtime((c))
1440
1441#elif defined(WOLFSSL_DEOS) || defined(WOLFSSL_DEOS_RTEMS)
1442    #include <time.h>
1443        #ifndef XTIME
1444            extern time_t deos_time(time_t* timer);
1445            #define XTIME(t1) deos_time((t1))
1446        #endif
1447#elif defined(MICRIUM)
1448    #include <clk.h>
1449    #include <time.h>
1450    #define XTIME(t1)       micrium_time((t1))
1451    #define WOLFSSL_GMTIME
1452
1453#elif defined(MICROCHIP_TCPIP_V5) || defined(MICROCHIP_TCPIP)
1454    #include <time.h>
1455    extern time_t pic32_time(time_t* timer);
1456    #define XTIME(t1)       pic32_time((t1))
1457    #define XGMTIME(c, t)   gmtime((c))
1458
1459#elif defined(FREESCALE_RTC)
1460    #include <time.h>
1461        #include "fsl_rtc.h"
1462        #ifndef XTIME
1463        #define XTIME(t1) fsl_time((t1))
1464    #endif
1465#elif defined(FREESCALE_SNVS_RTC)
1466    #include <time.h>
1467    #include "fsl_snvs_hp.h"
1468    time_t fsl_time(time_t* t);
1469    #ifndef XTIME
1470        #define XTIME(t1) fsl_time((t1))
1471    #endif
1472#elif defined(FREESCALE_MQX) || defined(FREESCALE_KSDK_MQX)
1473    #ifdef FREESCALE_MQX_4_0
1474        #include <time.h>
1475        extern time_t mqx_time(time_t* timer);
1476    #else
1477        #define HAVE_GMTIME_R
1478    #endif
1479    #define XTIME(t1)       mqx_time((t1))
1480
1481#elif defined(FREESCALE_KSDK_BM) || defined(FREESCALE_FREE_RTOS) || defined(FREESCALE_KSDK_FREERTOS)
1482    #include <time.h>
1483    #ifndef XTIME
1484        /*extern time_t ksdk_time(time_t* timer);*/
1485        #define XTIME(t1)   ksdk_time((t1))
1486    #endif
1487    #define XGMTIME(c, t)   gmtime((c))
1488
1489#elif defined(WOLFSSL_ATMEL) && defined(WOLFSSL_ATMEL_TIME)
1490    #define XTIME(t1)       atmel_get_curr_time_and_date((t1))
1491    #define WOLFSSL_GMTIME
1492    #define USE_WOLF_TM
1493    #define USE_WOLF_TIME_T
1494
1495#elif defined(WOLFSSL_WICED)
1496    #include <time.h>
1497    time_t wiced_pseudo_unix_epoch_time(time_t * timer);
1498    #define XTIME(t1)       wiced_pseudo_unix_epoch_time((t1))
1499    #define HAVE_GMTIME_R
1500
1501#elif defined(IDIRECT_DEV_TIME)
1502    /*Gets the timestamp from cloak software owned by VT iDirect
1503    in place of time() from <time.h> */
1504    #include <time.h>
1505    #define XTIME(t1)       idirect_time((t1))
1506    #define XGMTIME(c, t)   gmtime((c))
1507
1508#elif defined(_WIN32_WCE)
1509    #define _WINSOCKAPI_ /* block inclusion of winsock.h header file */
1510    #include <windows.h>
1511    #undef _WINSOCKAPI_ /* undefine it for MINGW winsock2.h header file */
1512    #include <stdlib.h> /* For file system */
1513
1514    time_t windows_time(time_t* timer);
1515
1516    #define FindNextFileA(h, d) FindNextFile(h, (LPWIN32_FIND_DATAW) d)
1517    #define FindFirstFileA(fn, d) FindFirstFile((LPCWSTR) fn, \
1518                                                (LPWIN32_FIND_DATAW) d)
1519    #define XTIME(t1)       windows_time((t1))
1520    #define WOLFSSL_GMTIME
1521
1522    /* if struct tm is not defined in WINCE SDK */
1523    #ifndef _TM_DEFINED
1524        struct tm {
1525            int tm_sec;     /* seconds */
1526            int tm_min;     /* minutes */
1527            int tm_hour;    /* hours */
1528            int tm_mday;    /* day of month (month specific) */
1529            int tm_mon;     /* month */
1530            int tm_year;    /* year */
1531            int tm_wday;    /* day of week (out of 1-7)*/
1532            int tm_yday;    /* day of year (out of 365) */
1533            int tm_isdst;   /* is it daylight savings */
1534            };
1535            #define _TM_DEFINED
1536    #endif
1537
1538#elif defined(WOLFSSL_APACHE_MYNEWT)
1539    #include "os/os_time.h"
1540    typedef long time_t;
1541    extern time_t mynewt_time(time_t* timer);
1542    #define XTIME(t1)       mynewt_time((t1))
1543    #define WOLFSSL_GMTIME
1544    #define USE_WOLF_TM
1545    #define USE_WOLF_TIME_T
1546
1547#elif defined(WOLFSSL_ZEPHYR)
1548    #ifdef __cplusplus
1549        }  /* extern "C" */
1550    #endif
1551
1552    #if KERNEL_VERSION_NUMBER >= 0x40300
1553        #include <time.h>
1554    #elif KERNEL_VERSION_NUMBER >= 0x30100
1555        #include <zephyr/posix/time.h>
1556    #else
1557        #include <posix/time.h>
1558    #endif
1559
1560    #ifndef CLOCK_REALTIME
1561        #ifdef SYS_CLOCK_REALTIME
1562            #define CLOCK_REALTIME  SYS_CLOCK_REALTIME
1563            #define clock_gettime   sys_clock_gettime
1564            #define clock_settime   sys_clock_settime
1565        #endif
1566    #endif
1567
1568    #if defined(CONFIG_RTC)
1569        #if defined(CONFIG_PICOLIBC) || defined(CONFIG_NEWLIB_LIBC)
1570            #include <zephyr/drivers/rtc.h>
1571        #else
1572            #warning "RTC support needs picolibc or newlib (nano)"
1573        #endif
1574    #endif
1575
1576    #ifdef __cplusplus
1577        extern "C" {
1578    #endif
1579
1580    time_t z_time(time_t *timer);
1581
1582    #define XTIME(tl)       z_time((tl))
1583    #define XGMTIME(c, t)   gmtime((c))
1584
1585#elif defined(WOLFSSL_TELIT_M2MB)
1586    typedef long time_t;
1587    extern time_t m2mb_xtime(time_t * timer);
1588    #define XTIME(tl)       m2mb_xtime((tl))
1589    #ifdef WOLFSSL_TLS13
1590        extern time_t m2mb_xtime_ms(time_t * timer);
1591        #define XTIME_MS(tl)    m2mb_xtime_ms((tl))
1592    #endif
1593    #ifndef NO_CRYPT_BENCHMARK
1594        extern double m2mb_xtime_bench(int reset);
1595        #define WOLFSSL_CURRTIME_REMAP m2mb_xtime_bench
1596    #endif
1597    #define XGMTIME(c, t)   gmtime((c))
1598    #define WOLFSSL_GMTIME
1599    #define USE_WOLF_TM
1600
1601#elif defined(WOLFSSL_LINUXKM)
1602
1603    /* definitions are in linuxkm/linuxkm_wc_port.h */
1604
1605#elif defined(WOLFSSL_BSDKM)
1606
1607    /* definitions are in bsdkm/bsdkm_wc_port.h */
1608
1609#elif defined(HAL_RTC_MODULE_ENABLED)
1610    #include <time.h>
1611    WOLFSSL_LOCAL time_t stm32_hal_time(time_t* t1);
1612    #define XTIME(t1) stm32_hal_time(t1)
1613    #define WOLFSSL_GMTIME
1614#else
1615    /* default */
1616    /* uses complete <time.h> facility */
1617    #include <time.h>
1618    #if defined(HAVE_SYS_TIME_H)
1619        #include <sys/time.h>
1620    #endif
1621
1622    /* PowerPC time_t is int */
1623    #if defined(__PPC__) || defined(__ppc__)
1624        #define TIME_T_NOT_64BIT
1625    #endif
1626
1627    #define XMKTIME(tm) mktime(tm)
1628    #define XDIFFTIME(to, from) difftime(to, from)
1629#endif
1630
1631#ifdef SIZEOF_TIME_T
1632    /* check if size of time_t from autoconf is less than 8 bytes (64bits) */
1633    #if SIZEOF_TIME_T < 8
1634        #undef  TIME_T_NOT_64BIT
1635        #define TIME_T_NOT_64BIT
1636    #endif
1637#endif
1638#ifdef TIME_T_NOT_LONG
1639    /* one old reference to TIME_T_NOT_LONG in GCC-ARM example README
1640     * this keeps support for the old macro name */
1641    #undef  TIME_T_NOT_64BIT
1642    #define TIME_T_NOT_64BIT
1643#endif
1644
1645/* Map default time functions */
1646#if !defined(XTIME) && !defined(TIME_OVERRIDES) && !defined(USER_TIME)
1647    #ifdef TEST_BEFORE_DATE
1648    #define XTIME(tl)       (946681200UL) /* Jan 1, 2000 */
1649    #else
1650    #define XTIME(tl)       time((tl))
1651    #endif
1652#endif
1653
1654#if defined(WOLFSSL_GMTIME) && !defined(HAVE_GMTIME_R)
1655    #define HAVE_GMTIME_R
1656#endif
1657
1658#if !defined(XGMTIME) && !defined(TIME_OVERRIDES)
1659    /* Always use gmtime_r if available. */
1660    #if defined(HAVE_GMTIME_S)
1661        /* reentrant version */
1662        #define XGMTIME(c, t)   gmtime_s((c), (t))
1663        #define NEED_TMP_TIME
1664    #elif defined(HAVE_GMTIME_R)
1665        #define XGMTIME(c, t)   gmtime_r((c), (t))
1666        #define NEED_TMP_TIME
1667    #else
1668        #define XGMTIME(c, t)   gmtime((c))
1669    #endif
1670#endif
1671#if !defined(XVALIDATE_DATE) && !defined(HAVE_VALIDATE_DATE)
1672    #define USE_WOLF_VALIDDATE
1673    #define XVALIDATE_DATE(d, f, t, l) wc_ValidateDate((d), (f), (t), (l))
1674#endif
1675
1676/* wolf struct tm and time_t */
1677#if defined(USE_WOLF_TM)
1678    struct tm {
1679        int  tm_sec;     /* seconds after the minute [0-60] */
1680        int  tm_min;     /* minutes after the hour [0-59] */
1681        int  tm_hour;    /* hours since midnight [0-23] */
1682        int  tm_mday;    /* day of the month [1-31] */
1683        int  tm_mon;     /* months since January [0-11] */
1684        int  tm_year;    /* years since 1900 */
1685        int  tm_wday;    /* days since Sunday [0-6] */
1686        int  tm_yday;    /* days since January 1 [0-365] */
1687        int  tm_isdst;   /* Daylight Savings Time flag */
1688        long tm_gmtoff;  /* offset from CUT in seconds */
1689        char *tm_zone;   /* timezone abbreviation */
1690    };
1691#endif /* USE_WOLF_TM */
1692#if defined(USE_WOLF_TIME_T)
1693    typedef long time_t;
1694#endif
1695#if defined(USE_WOLF_SUSECONDS_T)
1696    typedef long suseconds_t;
1697#endif
1698#if defined(USE_WOLF_TIMEVAL_T)
1699    struct timeval
1700    {
1701        time_t tv_sec;
1702        suseconds_t tv_usec;
1703    };
1704#endif
1705
1706    /* forward declarations */
1707#if defined(USER_TIME)
1708    struct tm* gmtime(const time_t* timer);
1709    extern time_t XTIME(time_t * timer);
1710
1711    #ifdef STACK_TRAP
1712        /* for stack trap tracking, don't call os gmtime on OS X/linux,
1713           uses a lot of stack spce */
1714        extern time_t time(time_t * timer);
1715        #define XTIME(tl)  time((tl))
1716    #endif /* STACK_TRAP */
1717
1718#elif defined(TIME_OVERRIDES)
1719    extern time_t XTIME(time_t * timer);
1720    extern struct tm* XGMTIME(const time_t* timer, struct tm* tmp);
1721#elif defined(WOLFSSL_GMTIME)
1722    struct tm* gmtime(const time_t* timer);
1723    struct tm* gmtime_r(const time_t* timer, struct tm *ret);
1724#endif
1725#endif /* !NO_ASN_TIME */
1726
1727
1728#if (!defined(WOLFSSL_LEANPSK) && !defined(STRING_USER)) || \
1729    defined(USE_WOLF_STRNSTR)
1730    #ifndef NO_STDDEF_H
1731        #include <stddef.h> /* for size_t */
1732    #endif /* NO_STDDEF_H */
1733    WOLFSSL_TEST_VIS char* wolfSSL_strnstr(const char* s1, const char* s2, size_t n);
1734#endif
1735
1736#ifndef FILE_BUFFER_SIZE
1737    /* default static file buffer size for input, will use dynamic buffer if
1738     * not big enough */
1739    #ifdef WOLFSSL_CERT_EXT
1740    #define FILE_BUFFER_SIZE (3*1024)
1741    #else
1742    #define FILE_BUFFER_SIZE (1*1024)
1743    #endif
1744#endif
1745
1746#ifdef HAVE_CAVIUM_OCTEON_SYNC
1747    /* By default, the OCTEON's global variables are all thread local. This
1748     * tag allows them to be shared between threads. */
1749    #include "cvmx-platform.h"
1750    #define WC_THREADSHARED CVMX_SHARED
1751#else
1752    #define WC_THREADSHARED
1753#endif
1754
1755#ifdef WOLFSSL_DSP
1756    #include "wolfssl_dsp.h"
1757
1758    /* callbacks for setting handle */
1759    typedef int (*wolfSSL_DSP_Handle_cb)(remote_handle64 *handle, int finished,
1760                                         void *ctx);
1761    WOLFSSL_API int wolfSSL_GetHandleCbSet();
1762    WOLFSSL_API int wolfSSL_SetHandleCb(wolfSSL_DSP_Handle_cb in);
1763    WOLFSSL_LOCAL int wolfSSL_InitHandle();
1764    WOLFSSL_LOCAL void wolfSSL_CleanupHandle();
1765#endif
1766
1767#ifdef WOLFSSL_SCE
1768    #ifndef WOLFSSL_SCE_GSCE_HANDLE
1769        #define WOLFSSL_SCE_GSCE_HANDLE g_sce
1770    #endif
1771#endif
1772
1773#ifdef WOLF_C99
1774    /* use alternate keyword for compatibility with -std=c99 */
1775    #define XASM_VOLATILE(a) __asm__ volatile(a)
1776#elif defined(__IAR_SYSTEMS_ICC__)
1777    #define XASM_VOLATILE(a) asm volatile(a)
1778#elif defined(__KEIL__)
1779    #define XASM_VOLATILE(a) __asm volatile(a)
1780#else
1781    #define XASM_VOLATILE(a) __asm__ __volatile__(a)
1782#endif
1783
1784#ifndef WOLFSSL_NO_FENCE
1785    #ifdef XFENCE
1786        /* use user-supplied XFENCE definition. */
1787    #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1788          !defined(__STDC_NO_ATOMICS__)
1789        #ifdef WOLFSSL_NO_ATOMIC
1790            #define XFENCE() WC_DO_NOTHING
1791        #else
1792            #include <stdatomic.h>
1793            #define XFENCE() atomic_thread_fence(memory_order_seq_cst)
1794        #endif
1795    #elif defined(__GNUC__) && (__GNUC__ == 4) && \
1796          defined(__GNUC_MINOR__) && (__GNUC_MINOR__ >= 1)
1797        #define XFENCE() __sync_synchronize()
1798    #elif (defined(__GNUC__) && (__GNUC__ >= 5)) || defined (__clang__)
1799        #define XFENCE() __atomic_thread_fence(__ATOMIC_SEQ_CST)
1800    #elif defined(WOLFSSL_NO_ASM)
1801        #define XFENCE() WC_DO_NOTHING
1802    #elif defined (__i386__) || defined(__x86_64__)
1803        #define XFENCE() XASM_VOLATILE("lfence")
1804    #elif defined (__arm__) && (__ARM_ARCH > 6)
1805        #define XFENCE() XASM_VOLATILE("isb")
1806    #elif defined(__aarch64__)
1807        /* Change ".inst 0xd50330ff" to "sb" when compilers support it. */
1808        #ifdef WOLFSSL_ARMASM_BARRIER_SB
1809            #define XFENCE() XASM_VOLATILE(".inst 0xd50330ff")
1810        #elif defined(WOLFSSL_ARMASM_BARRIER_DETECT)
1811            extern int aarch64_use_sb;
1812            #define XFENCE()                                \
1813                do {                                        \
1814                    if (aarch64_use_sb)                     \
1815                        XASM_VOLATILE(".inst 0xd50330ff");  \
1816                    else                                    \
1817                        XASM_VOLATILE("isb");               \
1818                } while (0)
1819        #else
1820            #define XFENCE() XASM_VOLATILE("isb")
1821        #endif
1822    #elif defined(__riscv)
1823        #define XFENCE() XASM_VOLATILE("fence")
1824    #elif defined(__PPC__) || defined(__POWERPC__)
1825        #define XFENCE() XASM_VOLATILE("isync; sync")
1826    #else
1827        #define XFENCE() WC_DO_NOTHING
1828    #endif
1829#else
1830    #define XFENCE() WC_DO_NOTHING
1831#endif
1832
1833#ifdef WC_BARRIER
1834    /* use user-supplied WC_BARRIER() definition. */
1835#elif defined(__GNUC__) && !defined(WOLFSSL_NO_ASM)
1836    #define WC_BARRIER() __asm__ __volatile__("" ::: "memory")
1837#else
1838    /* XFENCE() is a no-op on some targets.  The fallback construct uses C89
1839     * intrinsics as an additional (but weak) portable barrier.
1840     */
1841    #define WC_BARRIER() do { volatile byte _xfence = 0; (void)_xfence; XFENCE(); \
1842        } while(0)
1843#endif
1844
1845
1846    /* AFTER user_settings.h is loaded,
1847    ** determine if POSIX multi-threaded: HAVE_PTHREAD  */
1848    #if defined(SINGLE_THREADED) || defined(__MINGW32__)
1849        /* Never HAVE_PTHREAD in single thread, or non-POSIX mode.
1850        ** Reminder: MING32 is win32 threads, not POSIX threads */
1851        #undef HAVE_PTHREAD
1852    #else
1853        /* _POSIX_THREADS is defined by unistd.h so this check needs to happen
1854         * after we include all the platform relevant libs. */
1855        #ifdef _POSIX_THREADS
1856            /* HAVE_PTHREAD == POSIX threads capable and enabled. */
1857            #undef HAVE_PTHREAD
1858            #define HAVE_PTHREAD 1
1859        #endif
1860    #endif
1861
1862#if defined(WC_RNG_SEED_CB) && !defined(WC_GENERATE_SEED_DEFAULT)
1863    #define WC_GENERATE_SEED_DEFAULT wc_GenerateSeed
1864#endif
1865
1866#if (defined(__unix__) || defined(__APPLE__)) && \
1867    !defined(WOLFSSL_LINUXKM) && !defined(WOLFSSL_ZEPHYR)
1868    WOLFSSL_LOCAL void wc_set_cloexec(int fd);
1869    WOLFSSL_LOCAL int wc_open_cloexec(const char* path, int flags);
1870    WOLFSSL_LOCAL int wc_socket_cloexec(int domain, int type, int protocol);
1871    WOLFSSL_LOCAL int wc_accept_cloexec(int sockfd, void* addr, void* addrlen);
1872#else
1873    /* Platforms without POSIX close-on-exec semantics (Windows, OS/2 OW,
1874     * Linux kernel module, Zephyr, etc.): pass through to plain syscalls
1875     * where the underlying headers are available in the caller. */
1876    #define wc_set_cloexec(fd) ((void)(fd))
1877    #define wc_open_cloexec(path, flags) open((path), (flags))
1878    #define wc_socket_cloexec(domain, type, protocol) \
1879        socket((domain), (type), (protocol))
1880    #define wc_accept_cloexec(sockfd, addr, addrlen) \
1881        accept((sockfd), (addr), (addrlen))
1882#endif
1883
1884#ifdef __cplusplus
1885    }  /* extern "C" */
1886#endif
1887
1888#endif /* WOLF_CRYPT_PORT_H */