Fusion RTOS porting round 3

IDE/VisualDSP++/include.am

@@ -0,0 +1,6 @@
+# vim:ft=automake
+# included from Top Level Makefile.am
+# All paths should be given relative to the root
+
+EXTRA_DIST+= IDE/VisualDSP++/user_settings.h
+EXTRA_DIST+= IDE/VisualDSP++/wolf-tasks.c

IDE/VisualDSP++/user_settings.h

@@ -0,0 +1,752 @@
+/* user_settings.h
+ *
+ * Copyright (C) 2006-2021 wolfSSL Inc.
+ *
+ * This file is part of wolfSSL.
+ *
+ * wolfSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+/* Custom wolfSSL user settings for FIPS VALIDATION START */
+
+#ifndef WOLFSSL_USER_SETTINGS_H
+#define WOLFSSL_USER_SETTINGS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "fusioncfg.h"
+
+/* ------------------------------------------------------------------------- */
+/* Platform */
+/* ------------------------------------------------------------------------- */
+#undef  WOLFSSL_GENERAL_ALIGNMENT
+#define WOLFSSL_GENERAL_ALIGNMENT   4
+
+#undef  SINGLE_THREADED
+#define SINGLE_THREADED
+
+#undef  WOLFSSL_SMALL_STACK
+//#define WOLFSSL_SMALL_STACK
+
+#undef  WOLFSSL_USER_IO
+// #define WOLFSSL_USER_IO
+
+#define HAVE_PKCS8
+
+/* ------------------------------------------------------------------------- */
+/* Math Configuration */
+/* ------------------------------------------------------------------------- */
+#undef  SIZEOF_LONG_LONG
+#define SIZEOF_LONG_LONG 8
+
+#undef USE_FAST_MATH
+#if 1
+    #define USE_FAST_MATH
+
+    #undef  TFM_TIMING_RESISTANT
+    #define TFM_TIMING_RESISTANT
+
+    /* Optimizations */
+    //#define TFM_ARM
+#endif
+
+/* Wolf Single Precision Math */
+#undef WOLFSSL_SP
+#if 0
+    #define WOLFSSL_SP
+    //#define WOLFSSL_SP_SMALL      /* use smaller version of code */
+    #define WOLFSSL_HAVE_SP_RSA
+    #define WOLFSSL_HAVE_SP_DH
+    #define WOLFSSL_HAVE_SP_ECC
+    #define WOLFSSL_SP_CACHE_RESISTANT
+    //#define WOLFSSL_SP_MATH     /* only SP math - eliminates fast math code */
+
+    /* 64 or 32 bit version */
+    //#define WOLFSSL_SP_ASM      /* required if using the ASM versions */
+    //#define WOLFSSL_SP_ARM32_ASM
+    //#define WOLFSSL_SP_ARM64_ASM
+#endif
+
+/* ------------------------------------------------------------------------- */
+/* FIPS - Requires eval or license from wolfSSL */
+/* ------------------------------------------------------------------------- */
+#undef  HAVE_FIPS
+#if 1
+    #define HAVE_FIPS
+
+    #undef  HAVE_FIPS_VERSION
+    #define HAVE_FIPS_VERSION 2
+
+    #ifdef SINGLE_THREADED
+        #undef  NO_THREAD_LS
+        #define NO_THREAD_LS
+    #endif
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Crypto */
+/* ------------------------------------------------------------------------- */
+/* RSA */
+#undef NO_RSA
+#if 1
+    #ifdef USE_FAST_MATH
+        /* Maximum math bits (Max RSA key bits * 2) */
+        #undef  FP_MAX_BITS
+        #define FP_MAX_BITS     8192
+    #endif
+
+    /* half as much memory but twice as slow */
+    #undef  RSA_LOW_MEM
+    //#define RSA_LOW_MEM
+
+    /* Enables blinding mode, to prevent timing attacks */
+    #if 1
+        #undef  WC_RSA_BLINDING
+        #define WC_RSA_BLINDING
+    #else
+        #undef  WC_NO_HARDEN
+        #define WC_NO_HARDEN
+    #endif
+
+    /* RSA PSS Support */
+    #if 1
+        #define WC_RSA_PSS
+    #endif
+
+    #if 1
+        #define WC_RSA_NO_PADDING
+    #endif
+#else
+    #define NO_RSA
+#endif
+
+/* ECC */
+#undef HAVE_ECC
+#if 1
+    #define HAVE_ECC
+
+    /* Manually define enabled curves */
+    #undef  ECC_USER_CURVES
+    //#define ECC_USER_CURVES
+
+    #ifdef ECC_USER_CURVES
+        /* Manual Curve Selection */
+        //#define HAVE_ECC192
+        //#define HAVE_ECC224
+        #undef NO_ECC256
+        //#define HAVE_ECC384
+        //#define HAVE_ECC521
+    #endif
+
+    /* Fixed point cache (speeds repeated operations against same private key) */
+    #undef  FP_ECC
+    //#define FP_ECC
+    #ifdef FP_ECC
+        /* Bits / Entries */
+        #undef  FP_ENTRIES
+        #define FP_ENTRIES  2
+        #undef  FP_LUT
+        #define FP_LUT      4
+    #endif
+
+    /* Optional ECC calculation method */
+    /* Note: doubles heap usage, but slightly faster */
+    #undef  ECC_SHAMIR
+    #define ECC_SHAMIR
+
+    /* Reduces heap usage, but slower */
+    #undef  ECC_TIMING_RESISTANT
+    #define ECC_TIMING_RESISTANT
+
+    /* Enable cofactor support */
+    #ifdef HAVE_FIPS
+        #undef  HAVE_ECC_CDH
+        #define HAVE_ECC_CDH
+        
+        #define NO_STRICT_ECDSA_LEN
+    #endif
+
+    /* Validate import */
+    #ifdef HAVE_FIPS
+        #undef  WOLFSSL_VALIDATE_ECC_IMPORT
+        #define WOLFSSL_VALIDATE_ECC_IMPORT
+    #endif
+
+    /* Compressed Key Support */
+    #undef  HAVE_COMP_KEY
+    //#define HAVE_COMP_KEY
+
+    /* Use alternate ECC size for ECC math */
+    #ifdef USE_FAST_MATH
+        #ifdef NO_RSA
+            /* Custom fastmath size if not using RSA */
+            /* MAX = ROUND32(ECC BITS 256) + SIZE_OF_MP_DIGIT(32) */
+            #undef  FP_MAX_BITS
+            #define FP_MAX_BITS     (256 + 32)
+        #else
+            #undef  ALT_ECC_SIZE
+            #define ALT_ECC_SIZE
+        #endif
+
+        /* Speedups specific to curve */
+        #ifndef NO_ECC256
+            #undef  TFM_ECC256
+            #define TFM_ECC256
+        #endif
+    #endif
+#endif
+
+/* DH */
+#undef  NO_DH
+#if 1
+    /* Use table for DH instead of -lm (math) lib dependency */
+    #if 0
+        #define WOLFSSL_DH_CONST
+        #define HAVE_FFDHE_2048
+        #define HAVE_FFDHE_4096
+        #define HAVE_DH_DEFAULT_PARAMS
+        //#define HAVE_FFDHE_6144
+        //#define HAVE_FFDHE_8192
+    #endif
+
+    #ifdef HAVE_FIPS
+        #define WOLFSSL_VALIDATE_FFC_IMPORT
+        #define HAVE_FFDHE_Q
+    #endif
+#else
+    #define NO_DH
+#endif
+
+
+/* AES */
+#undef NO_AES
+#if 1
+    #undef  HAVE_AES_CBC
+    #define HAVE_AES_CBC
+
+    #undef  HAVE_AESGCM
+    #define HAVE_AESGCM
+
+    /* GCM Method: GCM_SMALL, GCM_WORD32 or GCM_TABLE */
+    #define GCM_SMALL
+
+    #undef  WOLFSSL_AES_DIRECT
+    #define WOLFSSL_AES_DIRECT
+
+    #undef  HAVE_AES_ECB
+    #define HAVE_AES_ECB
+
+    #undef  WOLFSSL_AES_COUNTER
+    #define WOLFSSL_AES_COUNTER
+
+    #undef  HAVE_AESCCM
+    #define HAVE_AESCCM
+#else
+    #define NO_AES
+#endif
+
+
+/* DES3 */
+#undef NO_DES3
+#if 1
+#else
+    #define NO_DES3
+#endif
+
+/* ChaCha20 / Poly1305 */
+#undef HAVE_CHACHA
+#undef HAVE_POLY1305
+#if 0
+    #define HAVE_CHACHA
+    #define HAVE_POLY1305
+
+    /* Needed for Poly1305 */
+    #undef  HAVE_ONE_TIME_AUTH
+    #define HAVE_ONE_TIME_AUTH
+#endif
+
+/* Ed25519 / Curve25519 */
+#undef HAVE_CURVE25519
+#undef HAVE_ED25519
+#if 0
+    #define HAVE_CURVE25519
+    #define HAVE_ED25519 /* ED25519 Requires SHA512 */
+
+    /* Optionally use small math (less flash usage, but much slower) */
+    #if 1
+        #define CURVED25519_SMALL
+    #endif
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Hashing */
+/* ------------------------------------------------------------------------- */
+/* Sha */
+#undef NO_SHA
+#if 1
+    /* 1k smaller, but 25% slower */
+    //#define USE_SLOW_SHA
+#else
+    #define NO_SHA
+#endif
+
+/* Sha256 */
+#undef NO_SHA256
+#if 1
+    /* not unrolled - ~2k smaller and ~25% slower */
+    //#define USE_SLOW_SHA256
+
+    /* Sha224 */
+    #if 1
+        #define WOLFSSL_SHA224
+    #endif
+#else
+    #define NO_SHA256
+#endif
+
+/* Sha512 */
+#undef WOLFSSL_SHA512
+#if 1
+    #define WOLFSSL_SHA512
+
+    /* Sha384 */
+    #undef  WOLFSSL_SHA384
+    #if 1
+        #define WOLFSSL_SHA384
+    #endif
+
+    /* over twice as small, but 50% slower */
+    //#define USE_SLOW_SHA512
+#endif
+
+/* Sha3 */
+#undef WOLFSSL_SHA3
+#if 1
+    #define WOLFSSL_SHA3
+    #ifdef HAVE_FIPS
+        #define WOLFSSL_NO_SHAKE256
+    #endif
+#endif
+
+/* MD5 */
+#undef  NO_MD5
+#if 1
+
+#else
+    #define NO_MD5
+#endif
+
+/* HKDF */
+#undef HAVE_HKDF
+#if 1
+    #define HAVE_HKDF
+#endif
+
+/* CMAC */
+#undef WOLFSSL_CMAC
+#if 1
+    #define WOLFSSL_CMAC
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Benchmark / Test */
+/* ------------------------------------------------------------------------- */
+/* Use reduced benchmark / test sizes */
+#undef  BENCH_EMBEDDED
+#define BENCH_EMBEDDED
+
+#undef  USE_CERT_BUFFERS_2048
+//#define USE_CERT_BUFFERS_2048
+
+//#undef  USE_CERT_BUFFERS_1024
+//#define USE_CERT_BUFFERS_1024
+
+#undef  USE_CERT_BUFFERS_256
+//#define USE_CERT_BUFFERS_256
+
+
+/* ------------------------------------------------------------------------- */
+/* Debugging */
+/* ------------------------------------------------------------------------- */
+
+#undef DEBUG_WOLFSSL
+#undef NO_ERROR_STRINGS
+#if 1 //for debug wolfssl_init.
+    #define DEBUG_WOLFSSL
+#else
+    #if 0
+        #define NO_ERROR_STRINGS
+    #endif
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Memory */
+/* ------------------------------------------------------------------------- */
+
+/* Override Memory API's */
+#if 1
+    #undef  XMALLOC_OVERRIDE
+    #define XMALLOC_OVERRIDE
+
+    #include <fclstdlib.h>
+
+    #define XMALLOC(n, h, t)     FCL_MALLOC(n)
+    #define XFREE(p, h, t)       FCL_FREE(p)
+    #define XREALLOC(p, n, h, t) FCL_REALLOC(p, n)
+
+    #define XATOI(s)     FCL_ATOI(s)
+#endif
+
+#if 0
+    /* Static memory requires fast math */
+    #define WOLFSSL_STATIC_MEMORY
+
+    /* Disable fallback malloc/free */
+    #define WOLFSSL_NO_MALLOC
+    #if 0
+        #define WOLFSSL_MALLOC_CHECK /* trap malloc failure */
+    #endif
+#endif
+
+/* Memory callbacks */
+#if 0
+    #undef  USE_WOLFSSL_MEMORY
+    #define USE_WOLFSSL_MEMORY
+
+    /* Use this to measure / print heap usage */
+    #if 0
+        #undef  WOLFSSL_TRACK_MEMORY
+        #define WOLFSSL_TRACK_MEMORY
+
+        #undef  WOLFSSL_DEBUG_MEMORY
+        #define WOLFSSL_DEBUG_MEMORY
+    #endif
+#else
+    #ifndef WOLFSSL_STATIC_MEMORY
+        #define NO_WOLFSSL_MEMORY
+        /* Otherwise we will use stdlib malloc, free and realloc */
+    #endif
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Port */
+/* ------------------------------------------------------------------------- */
+
+/* Override Current Time */
+/* Allows custom "custom_time()" function to be used for benchmark */
+//#define WOLFSSL_USER_CURRTIME
+//#define WOLFSSL_GMTIME
+//#define USER_TICKS
+//extern unsigned long my_time(unsigned long* timer);
+//#define XTIME my_time
+#if 1
+    #include "fcltime.h"
+    #define time_t fclTime_t
+    #define USER_TIME
+    time_t fclTime( time_t* tod );
+    #define XTIME fclTime
+    #define XCTIME fclCtime
+    #define HAVE_TIME_T_TYPE
+#endif
+
+/* ------------------------------------------------------------------------- */
+/* RNG */
+/* ------------------------------------------------------------------------- */
+
+/* Seed Source */
+/* Size of returned HW RNG value */
+#if 0   
+    #define CUSTOM_RAND_TYPE      unsigned int
+    extern unsigned int my_rng_seed_gen(void);
+    #undef  CUSTOM_RAND_GENERATE
+    #define CUSTOM_RAND_GENERATE  my_rng_seed_gen
+#endif
+
+/* Choose RNG method */
+#if 1
+    /* Use built-in P-RNG (SHA256 based) with HW RNG */
+    /* P-RNG + HW RNG (P-RNG is ~8K) */
+    #undef  HAVE_HASHDRBG
+    #define HAVE_HASHDRBG
+#else
+    #undef  WC_NO_HASHDRBG
+    #define WC_NO_HASHDRBG
+    /* Bypass P-RNG and use only HW RNG */
+    extern int my_rng_gen_block(unsigned char* output, unsigned int sz);
+    #undef  CUSTOM_RAND_GENERATE_BLOCK
+    #define CUSTOM_RAND_GENERATE_BLOCK  my_rng_gen_block
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Custom Standard Lib */
+/* ------------------------------------------------------------------------- */
+/* Allows override of all standard library functions */
+#undef STRING_USER
+#if 1
+    #define STRING_USER
+
+    #include <fclstring.h>
+
+    #undef  USE_WOLF_STRSEP
+    #define USE_WOLF_STRSEP
+    #define XSTRSEP(s1,d)     wc_strsep((s1),(d))
+
+    #undef  USE_WOLF_STRTOK
+    #define USE_WOLF_STRTOK
+    #define XSTRTOK(s1,d,ptr) wc_strtok((s1),(d),(ptr))
+
+    // TBD drowe: add a new FCL_STRNSTR and implement the new fclStrnstr code in common/clib/string/fclstrstr.c
+    // For now use the unsafe version
+    #define XSTRNSTR(s1,s2,n) FCL_STRSTR((s1),(s2))
+
+    #define XMEMCPY(d,s,l)    FCL_MEMCPY((d),(s),(l))
+    #define XMEMSET(b,c,l)    FCL_MEMSET((b),(c),(l))
+    #define XMEMCMP(s1,s2,n)  FCL_MEMCMP((s1),(s2),(n))
+    #define XMEMMOVE(d,s,l)   FCL_MEMMOVE((d),(s),(l))
+
+    #define XSTRLEN(s1)       FCL_STRLEN((s1))
+    #define XSTRNCPY(s1,s2,n) FCL_STRNCPY((s1),(s2),(n))
+    #define XSTRSTR(s1,s2)    FCL_STRSTR((s1),(s2))
+
+    #define XSTRNCMP(s1,s2,n)     FCL_STRNCMP((s1),(s2),(n))
+    #define XSTRNCAT(s1,s2,n)     FCL_STRNCAT((s1),(s2),(n))
+    #define XSTRNCASECMP(s1,s2,n) FCL_STRNCASECMP((s1),(s2),(n))
+
+    #define XSNPRINTF FCL_SNPRINTF
+#endif
+
+
+
+/* ------------------------------------------------------------------------- */
+/* Enable Features */
+/* ------------------------------------------------------------------------- */
+#undef WOLFSSL_TLS13
+#if 0
+    #define WOLFSSL_TLS13
+#endif
+
+#undef WOLFSSL_KEY_GEN
+#if 1
+    #define WOLFSSL_KEY_GEN
+#endif
+
+#if defined(HAVE_FIPS) && !defined(WOLFSSL_KEY_GEN)
+    #define WOLFSSL_OLD_PRIME_CHECK
+#endif
+
+#undef  KEEP_PEER_CERT
+//#define KEEP_PEER_CERT
+
+#undef  HAVE_COMP_KEY
+//#define HAVE_COMP_KEY
+
+#undef  HAVE_TLS_EXTENSIONS
+//#define HAVE_TLS_EXTENSIONS
+
+#undef  HAVE_SUPPORTED_CURVES
+#define HAVE_SUPPORTED_CURVES
+
+#undef  WOLFSSL_BASE64_ENCODE
+#define WOLFSSL_BASE64_ENCODE
+
+/* TLS Session Cache */
+#if 0
+    #define SMALL_SESSION_CACHE
+#else
+ //   #define NO_SESSION_CACHE
+#endif
+
+
+#undef WOLFSSL_ALLOW_SSLV3
+#define WOLFSSL_ALLOW_SSLV3
+
+#undef WOLFSSL_ALLOW_TLSV10
+#define WOLFSSL_ALLOW_TLSV10
+
+
+/* ------------------------------------------------------------------------- */
+/* Disable Features */
+/* ------------------------------------------------------------------------- */
+#undef  NO_WOLFSSL_SERVER
+//#define NO_WOLFSSL_SERVER
+
+#undef  NO_WOLFSSL_CLIENT
+//#define NO_WOLFSSL_CLIENT
+
+#undef  NO_CRYPT_TEST
+//#define NO_CRYPT_TEST
+
+#undef  NO_CRYPT_BENCHMARK
+//#define NO_CRYPT_BENCHMARK
+
+#undef  WOLFCRYPT_ONLY
+//#define WOLFCRYPT_ONLY
+
+/* In-lining of misc.c functions */
+/* If defined, must include wolfcrypt/src/misc.c in build */
+/* Slower, but about 1k smaller */
+#undef  NO_INLINE
+//#define NO_INLINE
+
+#undef  NO_FILESYSTEM
+//#define NO_FILESYSTEM
+
+#undef  NO_WRITEV
+#define NO_WRITEV
+
+#undef  NO_MAIN_DRIVER
+#define NO_MAIN_DRIVER
+
+#undef  NO_DEV_RANDOM
+//#define NO_DEV_RANDOM
+
+#undef  NO_DSA
+//#define NO_DSA
+
+#undef  NO_RC4
+#define NO_RC4
+
+#undef  NO_OLD_TLS
+//#define NO_OLD_TLS
+
+#undef  NO_HC128
+#define NO_HC128
+
+#undef  NO_RABBIT
+#define NO_RABBIT
+
+#undef  NO_PSK
+#define NO_PSK
+
+#undef  NO_MD4
+#define NO_MD4
+
+#undef  NO_PWDBASED
+//#define NO_PWDBASED
+
+#undef  NO_CODING
+//#define NO_CODING
+
+#undef  NO_ASN_TIME
+//#define NO_ASN_TIME
+
+#undef  NO_CERTS
+//#define NO_CERTS
+
+#undef  NO_SIG_WRAPPER
+//#define NO_SIG_WRAPPER
+
+#undef NO_MAIN_DRIVER
+#define NO_MAIN_DRIVER
+
+#undef BLACKFIN_BUILD
+#define BLACKFIN_BUILD
+
+#ifdef BLACKFIN_BUILD
+
+    #include <builtins.h>
+
+    #undef WOLFSSL_HAVE_MAX
+    #define WOLFSSL_HAVE_MAX
+
+    #undef WOLFSSL_HAVE_MIN
+    #define WOLFSSL_HAVE_MIN
+
+    #include <fss_telnet_shell.h>
+
+    #define XMALLOC_OVERRIDE /* Need to use FCL stdlib instead of stdlib.h */
+
+    extern void *          fclMalloc   (unsigned int size);
+    extern void            fclFree     (void * memoryPointer);
+    extern void *          fclRealloc  (void * memoryPointer, unsigned int size);
+    #define XMALLOC(a, b, c) fclMalloc(a)
+    #define XFREE(a, b, c) fclFree(a)
+    #define XREALLOC(a, b, c, d) fclRealloc(a, b)
+
+    /*************************************************************
+     * wolfSSL testing
+     */
+
+    typedef struct wolfArgs {
+        int argc;
+        char** argv;
+        int return_code;
+        struct fssShellInfo* info;  
+    } wolfArgs;
+
+    #define printf FCL_PRINTF
+
+    /* CAVP TESTING */
+    #define NO_WOLFCAVP_MAIN_DRIVER
+    #define WOLFSSL_BASE16
+    #define USE_UART_READ_LINE
+    #define USE_NORMAL_PRINTF
+    #define VERIFY_GENERATED_PSS_SIGS
+    #define NO_ATTRIBUTE_CONSTRUCTOR
+
+    extern int aes_test_for_fips_hash(void);
+    int wolfcrypt_test_taskEnter(void *args);
+    int wolfcrypt_harness_taskEnter(void *args);
+    int wolf_task_start(void* voidinfo, char* argline);
+    int wolf_task_results(void* voidinfo, char* argline);
+    void wolfFIPS_Module_start(void);
+
+    /* For op testing */
+   #define USE_CERT_BUFFERS_2048
+   #define USE_CERT_BUFFERS_256
+   //#define NO_FILESYSTEM
+   
+// #define HAVE_FORCE_FIPS_FAILURE
+
+   #define OPENSSL_EXTRA  //to test if iprgw project need it. AES_xxx wolfSSL_AES_xxx Aes_EncryptDirect
+   #define OPENSSL_ALL
+   #define HAVE_EX_DATA
+    #define WOLFSSL_EVP_DECRYPT_LEGACY
+
+   
+   /* TLS 1.3 support */
+   
+   #define WOLFSSL_TLS13
+   #define HAVE_TLS_EXTENSIONS
+   #define HAVE_SUPPORTED_CURVES
+   #define HAVE_ECC
+   #define HAVE_HKDF
+   #define HAVE_FFDHE_4096
+   #define WC_RSA_PSS
+   
+   /* for static ciphers */
+   #define WOLFSSL_STATIC_RSA
+    #define WOLFSSL_STATIC_PSK
+    #define WOLFSSL_STATIC_EPHEMERAL
+   #define WOLFSSL_SNIFFER
+   
+   /* TEMPORARY */
+   #define USING_JTAG
+#endif /* BLACKFIN_BUILD */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WOLFSSL_USER_SETTINGS_H */
+

IDE/VisualDSP++/wolf-tasks.c

@@ -0,0 +1,117 @@
+/* wolf-tasks.c
+ *
+ * Copyright (C) 2006-2021 wolfSSL Inc.
+ *
+ * This file is part of wolfSSL.
+ *
+ * wolfSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+#include <wolfssl/wolfcrypt/settings.h>
+#include <wolfcrypt/test/test.h>
+#include <wolfssl/wolfcrypt/error-crypt.h>
+#include <wolfssl/wolfcrypt/fips_test.h>
+#ifdef FUSION_RTOS
+#include <fcl_os.h>
+
+#define RESULT_BUF_SIZE  1024
+
+typedef struct {
+   int   isRunning;
+   u8    buf[RESULT_BUF_SIZE];
+   int   len;
+} wolf_result_t;
+
+static wolf_result_t _result = {0};
+
+static void myFipsCb(int ok, int err, const char* hash);
+
+static void myFipsCb(int ok, int err, const char* hash)
+{
+
+    FCL_PRINTF("in my Fips callback, ok = %d, err = %d\n", ok, err);
+    FCL_PRINTF("message = %s\n", wc_GetErrorString(err));
+    FCL_PRINTF("hash = %s\n", hash);
+
+    if (err == IN_CORE_FIPS_E) {
+        FCL_PRINTF("In core integrity hash check failure, copy above hash\n");
+        FCL_PRINTF("into verifyCore[] in fips_test.c and rebuild\n");
+    }
+}
+
+static fclThreadHandle _task = NULL;
+#define WOLF_TASK_STACK_SIZE (1024 * 100)
+fclThreadPriority WOLF_TASK_PRIORITY = (fclThreadPriority) (FCL_THREAD_PRIORITY_TIME_CRITICAL+1);
+
+int wolfcrypt_test_taskEnter(void *args)
+{
+    int ret;
+
+    wolfCrypt_SetCb_fips(myFipsCb);
+
+    ret = wolfcrypt_test(args);
+
+    printf("Result of test was %d\n", ret);
+
+    _result.isRunning = 0;
+    fosTaskDelete(_task);
+    return 0;
+}
+
+/* Was only needed for CAVP testing purposes, not required for release.
+int wolfcrypt_harness_taskEnter(void *args)
+{
+    wolfCrypt_SetCb_fips(myFipsCb);
+    wolfcrypt_harness(args);
+    _result.isRunning = 0;
+    fosTaskDelete(_task);
+    return 0;
+}
+*/
+
+int wolf_task_start(void* voidinfo, char* argline)
+{
+    char optionA[] = "wolfcrypt_test";
+    fssShellInfo *info = (fssShellInfo*)voidinfo;
+    struct wolfArgs args;
+
+    if (_result.isRunning) {
+        fssShellPuts(info, "previous task still running\r\n");
+        return 1;
+    }
+
+    _result.isRunning = 1;
+
+    if (FCL_STRNCMP(argline, optionA, FCL_STRLEN(optionA)) == 0) {
+         _task = fclThreadCreate(wolfcrypt_test_taskEnter,
+                                 &args,
+                                 WOLF_TASK_STACK_SIZE,
+                                 WOLF_TASK_PRIORITY);
+    } else if (FCL_STRNCMP(argline, optionB, FCL_STRLEN(optionB)) == 0) {
+        _task = fclThreadCreate(wolfcrypt_harness_taskEnter,
+                                &args,
+                                WOLF_TASK_STACK_SIZE,
+                                WOLF_TASK_PRIORITY);
+    } else {
+        printf("Invalid input: %s\n", argline);
+        printf("Please try with either wolfcrypt_test or wolfcrypt_harness\n");
+        return -1;
+    }
+
+    FCL_ASSERT(_task != FCL_THREAD_HANDLE_INVALID);
+
+    return 0;
+}
+#endif /* FUSION_RTOS */

IDE/include.am

@@ -35,6 +35,7 @@ include IDE/M68K/include.am
 include IDE/HEXAGON/include.am
 include IDE/RISCV/include.am
 include IDE/XilinxSDK/include.am
+include IDE/VisualDSP++/include.am
 
 EXTRA_DIST+= IDE/IAR-EWARM IDE/MDK-ARM IDE/MDK5-ARM IDE/MYSQL IDE/LPCXPRESSO IDE/HEXIWEAR IDE/Espressif IDE/zephyr
 EXTRA_DIST+= IDE/OPENSTM32/README.md

src/internal.c

@@ -77,8 +77,13 @@
 #if defined(DEBUG_WOLFSSL) || defined(SHOW_SECRETS) || \
     defined(CHACHA_AEAD_TEST) || defined(WOLFSSL_SESSION_EXPORT_DEBUG)
     #ifndef NO_STDIO_FILESYSTEM
+        #ifndef FUSION_RTOS
         #include <stdio.h>
     #endif
+        #ifdef FUSION_RTOS
+          #include <fclstdio.h>
+         #endif
+    #endif
 #endif
 
 #ifdef __sun

src/sniffer.c

@@ -25,6 +25,38 @@
 #endif
 
 #include <wolfssl/wolfcrypt/settings.h>
+#include <wolfssl/wolfcrypt/wc_port.h>
+
+/* xctime - should it move to wc_port.h? */
+#ifndef XCTIME
+   #define XCTIME ctime
+#endif
+
+/* should next ifdef move to wc_port.h? */
+#ifdef FUSION_RTOS
+    #include <fcl_network.h>
+    #define XINET_NTOA FNS_INET_NTOA
+    #define XINET_ATON FNS_INET_ATON
+    #define XINET_PTON(a,b,c,d) FNS_INET_PTON((a),(b),(c),(d),NULL)
+    #define XINET_NTOP(a,b,c,d) FNS_INET_NTOP((a),(b),(c),(d),NULL)
+    #define XINET_ADDR FNS_INET_ADDR
+    #define XHTONS FNS_HTONS
+    #define XNTOHS FNS_NTOHS
+    #define XHTONL FNS_HTONL
+    #define XNTOHL FNS_NTOHL
+    #define XINADDR_NONE FNS_INADDR_NONE
+#else
+    #define XINET_NTOA inet_ntoa
+    #define XINET_ATON inet_aton
+    #define XINET_PTON(a,b,c) inet_pton((a),(b),(c))
+    #define XINET_NTOP inet_ntop
+    #define XINET_ADDR inet_addr
+    #define XHTONS htons
+    #define XNTOHS ntohs
+    #define XHTONL htonl
+    #define XNTOHL ntohl
+    #define XINADDR_NONE INADDR_NONE
+#endif
 
 #if !defined(WOLFCRYPT_ONLY) && !defined(NO_FILESYSTEM)
 #ifdef WOLFSSL_SNIFFER
@@ -32,10 +64,17 @@
 #include <assert.h>
 #include <time.h>
 
-#ifndef _WIN32
-  #include <arpa/inet.h>
+#ifdef FUSION_RTOS
+    #include <fns_inet.h>
+    #ifdef TCP_PROTOCOL
+        #undef TCP_PROTOCOL
+    #endif
 #else
-  #include <WS2tcpip.h>
+    #ifndef _WIN32
+        #include <arpa/inet.h>
+    #else
+        #include <WS2tcpip.h>
+    #endif
 #endif
 
 #ifdef _WIN32
@@ -95,7 +134,7 @@ enum {
     EXT_TYPE_SZ        = 2,   /* Extension type length */
     MAX_INPUT_SZ       = MAX_RECORD_SIZE + COMP_EXTRA + MAX_MSG_EXTRA +
                          MTU_EXTRA,  /* Max input sz of reassembly */
-    
+
     /* TLS Extensions */
     EXT_SERVER_NAME                = 0x0000, /* a.k.a. SNI  */
     EXT_MAX_FRAGMENT_LENGTH        = 0x0001,
@@ -160,7 +199,7 @@ BOOL APIENTRY DllMain( HMODULE hModule,
 
 
 static WOLFSSL_GLOBAL int TraceOn = 0;         /* Trace is off by default */
-static WOLFSSL_GLOBAL FILE* TraceFile = 0;
+static WOLFSSL_GLOBAL XFILE TraceFile = 0;
 
 
 /* windows uses .rc table for this */
@@ -716,7 +755,7 @@ void ssl_FreeSniffer(void)
 
     if (TraceFile) {
         TraceOn = 0;
-        fclose(TraceFile);
+        XFCLOSE(TraceFile);
         TraceFile = NULL;
     }
 
@@ -955,9 +994,9 @@ static void Trace(int idx)
     if (TraceOn) {
         char myBuffer[MAX_ERROR_LEN];
         GetError(idx, myBuffer);
-        fprintf(TraceFile, "\t%s\n", myBuffer);
+        XFPRINTF(TraceFile, "\t%s\n", myBuffer);
 #ifdef DEBUG_SNIFFER
-        fprintf(stderr,    "\t%s\n", myBuffer);
+        XFPRINTF(stderr,    "\t%s\n", myBuffer);
 #endif
     }
 }
@@ -967,8 +1006,8 @@ static void Trace(int idx)
 static void TraceHeader(void)
 {
     if (TraceOn) {
-        time_t ticks = time(NULL);
-        fprintf(TraceFile, "\n%s", ctime(&ticks));
+        time_t ticks = XTIME(NULL);
+        XFPRINTF(TraceFile, "\n%s", XCTIME(&ticks));
     }
 }
 
@@ -977,8 +1016,8 @@ static void TraceHeader(void)
 static void TraceSetServer(const char* srv, int port, const char* keyFile)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tTrying to install a new Sniffer Server with\n");
-        fprintf(TraceFile, "\tserver: %s, port: %d, keyFile: %s\n", srv, port,
+        XFPRINTF(TraceFile, "\tTrying to install a new Sniffer Server with\n");
+        XFPRINTF(TraceFile, "\tserver: %s, port: %d, keyFile: %s\n", srv, port,
                                                                     keyFile);
     }
 }
@@ -991,8 +1030,8 @@ static void TraceSetNamedServer(const char* name,
                                  const char* srv, int port, const char* keyFile)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tTrying to install a new Sniffer Server with\n");
-        fprintf(TraceFile, "\tname: %s, server: %s, port: %d, keyFile: %s\n",
+        XFPRINTF(TraceFile, "\tTrying to install a new Sniffer Server with\n");
+        XFPRINTF(TraceFile, "\tname: %s, server: %s, port: %d, keyFile: %s\n",
 		name ? name : "",
 		srv ? srv : "",
 		port,
@@ -1008,7 +1047,7 @@ static void TracePacket(void)
 {
     if (TraceOn) {
         static word32 packetNumber = 0;
-        fprintf(TraceFile, "\tGot a Packet to decode, packet %u\n",
+        XFPRINTF(TraceFile, "\tGot a Packet to decode, packet %u\n",
                 ++packetNumber);
     }
 }
@@ -1017,7 +1056,7 @@ static void TracePacket(void)
 /* Convert network byte order address into human readable */
 static const char* IpToS(int version, void* src, char* dst)
 {
-    return inet_ntop(version, src, dst, TRACE_MSG_SZ);
+    return XINET_NTOP(version, src, dst, TRACE_MSG_SZ);
 }
 
 
@@ -1027,7 +1066,7 @@ static void TraceIP(IpHdr* iphdr)
     if (TraceOn) {
         char src[TRACE_MSG_SZ];
         char dst[TRACE_MSG_SZ];
-        fprintf(TraceFile, "\tdst:%s src:%s\n",
+        XFPRINTF(TraceFile, "\tdst:%s src:%s\n",
                 IpToS(AF_INET, &iphdr->dst, dst),
                 IpToS(AF_INET, &iphdr->src, src));
     }
@@ -1040,7 +1079,7 @@ static void TraceIP6(Ip6Hdr* iphdr)
     if (TraceOn) {
         char src[TRACE_MSG_SZ];
         char dst[TRACE_MSG_SZ];
-        fprintf(TraceFile, "\tdst: %s src: %s\n",
+        XFPRINTF(TraceFile, "\tdst: %s src: %s\n",
                 IpToS(AF_INET6, iphdr->dst, dst),
                 IpToS(AF_INET6, iphdr->src, src));
     }
@@ -1051,8 +1090,8 @@ static void TraceIP6(Ip6Hdr* iphdr)
 static void TraceTcp(TcpHdr* tcphdr)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tdstPort:%u srcPort:%u\n", ntohs(tcphdr->dstPort),
-                ntohs(tcphdr->srcPort));
+        XFPRINTF(TraceFile, "\tdstPort:%u srcPort:%u\n", XNTOHS(tcphdr->dstPort),
+                XNTOHS(tcphdr->srcPort));
     }
 }
 
@@ -1061,7 +1100,7 @@ static void TraceTcp(TcpHdr* tcphdr)
 static void TraceSequence(word32 seq, int len)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tSequence:%u, payload length:%d\n", seq, len);
+        XFPRINTF(TraceFile, "\tSequence:%u, payload length:%d\n", seq, len);
     }
 }
 
@@ -1070,7 +1109,7 @@ static void TraceSequence(word32 seq, int len)
 static void TraceAck(word32 ack, word32 expected)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tAck:%u Expected:%u\n", ack, expected);
+        XFPRINTF(TraceFile, "\tAck:%u Expected:%u\n", ack, expected);
     }
 }
 
@@ -1079,7 +1118,7 @@ static void TraceAck(word32 ack, word32 expected)
 static void TraceRelativeSequence(word32 expected, word32 got)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tExpected sequence:%u, received sequence:%u\n",
+        XFPRINTF(TraceFile, "\tExpected sequence:%u, received sequence:%u\n",
                 expected, got);
     }
 }
@@ -1089,7 +1128,7 @@ static void TraceRelativeSequence(word32 expected, word32 got)
 static void TraceServerSyn(word32 seq)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tServer SYN, Sequence Start:%u\n", seq);
+        XFPRINTF(TraceFile, "\tServer SYN, Sequence Start:%u\n", seq);
     }
 }
 
@@ -1098,7 +1137,7 @@ static void TraceServerSyn(word32 seq)
 static void TraceClientSyn(word32 seq)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tClient SYN, Sequence Start:%u\n", seq);
+        XFPRINTF(TraceFile, "\tClient SYN, Sequence Start:%u\n", seq);
     }
 }
 
@@ -1107,7 +1146,7 @@ static void TraceClientSyn(word32 seq)
 static void TraceClientFin(word32 finSeq, word32 relSeq)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tClient FIN capture:%u, current SEQ:%u\n",
+        XFPRINTF(TraceFile, "\tClient FIN capture:%u, current SEQ:%u\n",
                 finSeq, relSeq);
     }
 }
@@ -1117,7 +1156,7 @@ static void TraceClientFin(word32 finSeq, word32 relSeq)
 static void TraceServerFin(word32 finSeq, word32 relSeq)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tServer FIN capture:%u, current SEQ:%u\n",
+        XFPRINTF(TraceFile, "\tServer FIN capture:%u, current SEQ:%u\n",
                 finSeq, relSeq);
     }
 }
@@ -1127,7 +1166,7 @@ static void TraceServerFin(word32 finSeq, word32 relSeq)
 static void TraceGotData(int bytes)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\t%d bytes of SSL App data processed\n", bytes);
+        XFPRINTF(TraceFile, "\t%d bytes of SSL App data processed\n", bytes);
     }
 }
 
@@ -1136,7 +1175,7 @@ static void TraceGotData(int bytes)
 static void TraceAddedData(int newBytes, int existingBytes)
 {
     if (TraceOn) {
-        fprintf(TraceFile,
+        XFPRINTF(TraceFile,
                 "\t%d bytes added to %d existing bytes in User Buffer\n",
                 newBytes, existingBytes);
     }
@@ -1147,7 +1186,7 @@ static void TraceAddedData(int newBytes, int existingBytes)
 static void TraceStaleSession(void)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tFound a stale session\n");
+        XFPRINTF(TraceFile, "\tFound a stale session\n");
     }
 }
 
@@ -1156,7 +1195,7 @@ static void TraceStaleSession(void)
 static void TraceFindingStale(void)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tTrying to find Stale Sessions\n");
+        XFPRINTF(TraceFile, "\tTrying to find Stale Sessions\n");
     }
 }
 
@@ -1165,7 +1204,7 @@ static void TraceFindingStale(void)
 static void TraceRemovedSession(void)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tRemoved it\n");
+        XFPRINTF(TraceFile, "\tRemoved it\n");
     }
 }
 
@@ -1175,7 +1214,7 @@ static void TraceSessionInfo(SSLInfo* sslInfo)
 {
     if (TraceOn) {
         if (sslInfo != NULL && sslInfo->isValid) {
-            fprintf(TraceFile,
+            XFPRINTF(TraceFile,
                     "\tver:(%u %u) suiteId:(%02x %02x) suiteName:(%s) "
                     #ifdef HAVE_SNI
                     "sni:(%s) "
@@ -1201,7 +1240,7 @@ static void TraceSessionInfo(SSLInfo* sslInfo)
 static void TraceStat(const char* name, int add)
 {
     if (TraceOn) {
-        fprintf(TraceFile, "\tAdding %d to %s\n", add, name);
+        XFPRINTF(TraceFile, "\tAdding %d to %s\n", add, name);
     }
 }
 
@@ -1368,7 +1407,7 @@ static word32 SessionHash(IpInfo* ipInfo, TcpInfo* tcpInfo)
 static SnifferSession* GetSnifferSession(IpInfo* ipInfo, TcpInfo* tcpInfo)
 {
     SnifferSession* session;
-    time_t          currTime = time(NULL);
+    time_t          currTime = XTIME(NULL);
     word32          row = SessionHash(ipInfo, tcpInfo);
 
     assert(row <= HASH_SIZE);
@@ -1581,9 +1620,14 @@ static int SetNamedPrivateKey(const char* name, const char* address, int port,
 #endif
 
     serverIp.version = IPV4;
-    serverIp.ip4 = inet_addr(address);
-    if (serverIp.ip4 == INADDR_NONE) {
-        if (inet_pton(AF_INET6, address, serverIp.ip6) == 1) {
+    serverIp.ip4 = XINET_ADDR(address);
+    if (serverIp.ip4 == XINADDR_NONE) {
+    #ifdef FUSION_RTOS
+        if (XINET_PTON(AF_INET6, address, serverIp.ip6,
+                       sizeof(serverIp.ip4)) == 1) {
+    #else
+        if (XINET_PTON(AF_INET6, address, serverIp.ip6) == 1) {
+    #endif
             serverIp.version = IPV6;
         }
     }
@@ -1896,7 +1940,7 @@ static int CheckIp6Hdr(Ip6Hdr* iphdr, IpInfo* info, int length, char* error)
 #endif
 
     info->length = exthdrsz;
-    info->total = ntohs(iphdr->length) + info->length;
+    info->total = XNTOHS(iphdr->length) + info->length;
     /* IPv6 doesn't include its own header size in the length like v4. */
     info->src.version = IPV6;
     XMEMCPY(info->src.ip6, iphdr->src, sizeof(info->src.ip6));
@@ -1938,7 +1982,7 @@ static int CheckIpHdr(IpHdr* iphdr, IpInfo* info, int length, char* error)
 #endif
 
     info->length  = IP_HL(iphdr);
-    info->total   = ntohs(iphdr->length);
+    info->total   = XNTOHS(iphdr->length);
     info->src.version = IPV4;
     info->src.ip4 = iphdr->src;
     info->dst.version = IPV4;
@@ -1957,16 +2001,16 @@ static int CheckTcpHdr(TcpHdr* tcphdr, TcpInfo* info, char* error)
 {
     TraceTcp(tcphdr);
     Trace(TCP_CHECK_STR);
-    info->srcPort   = ntohs(tcphdr->srcPort);
-    info->dstPort   = ntohs(tcphdr->dstPort);
+    info->srcPort   = XNTOHS(tcphdr->srcPort);
+    info->dstPort   = XNTOHS(tcphdr->dstPort);
     info->length    = TCP_LEN(tcphdr);
-    info->sequence  = ntohl(tcphdr->sequence);
+    info->sequence  = XNTOHL(tcphdr->sequence);
     info->fin       = tcphdr->flags & TCP_FIN;
     info->rst       = tcphdr->flags & TCP_RST;
     info->syn       = tcphdr->flags & TCP_SYN;
     info->ack       = tcphdr->flags & TCP_ACK;
     if (info->ack)
-        info->ackNumber = ntohl(tcphdr->ack);
+        info->ackNumber = XNTOHL(tcphdr->ack);
 
 #ifndef WOLFSSL_SNIFFER_WATCH
     if (!IsPortRegistered(info->srcPort) && !IsPortRegistered(info->dstPort)) {
@@ -4010,7 +4054,7 @@ static void RemoveStaleSessions(void)
         session = SessionTable[i];
         while (session) {
             SnifferSession* next = session->next;
-            if (time(NULL) >= session->lastUsed + WOLFSSL_SNIFFER_TIMEOUT) {
+            if (XTIME(NULL) >= session->lastUsed + WOLFSSL_SNIFFER_TIMEOUT) {
                 TraceStaleSession();
                 RemoveSession(session, NULL, NULL, i);
             }
@@ -4059,7 +4103,7 @@ static SnifferSession* CreateSession(IpInfo* ipInfo, TcpInfo* tcpInfo,
     session->cliPort = (word16)tcpInfo->srcPort;
     session->cliSeqStart = tcpInfo->sequence;
     session->cliExpected = 1;  /* relative */
-    session->lastUsed= time(NULL);
+    session->lastUsed= XTIME(NULL);
     session->keySz = 0;
 #ifdef HAVE_SNI
     session->sni = NULL;

src/ssl.c

@@ -29,6 +29,7 @@
     /* turn on GNU extensions for XVASPRINTF with wolfSSL_BIO_printf */
     #undef  _GNU_SOURCE
     #define _GNU_SOURCE
+    #include <stdarg.h>
 #endif
 
 #if !defined(WOLFCRYPT_ONLY) || defined(OPENSSL_EXTRA) || \
@@ -547,7 +548,7 @@ WOLFSSL* wolfSSL_new(WOLFSSL_CTX* ctx)
 
     ssl = (WOLFSSL*) XMALLOC(sizeof(WOLFSSL), ctx->heap, DYNAMIC_TYPE_SSL);
     if (ssl)
-        if (InitSSL(ssl, ctx, 0) < 0) {
+        if ( (ret = InitSSL(ssl, ctx, 0)) < 0) {
             FreeSSL(ssl, ctx->heap);
             ssl = 0;
         }
@@ -3967,7 +3968,7 @@ void wolfSSL_ERR_print_errors_fp(XFILE fp, int err)
 
     WOLFSSL_ENTER("wolfSSL_ERR_print_errors_fp");
     SetErrorString(err, data);
-    fprintf(fp, "%s", data);
+    XFPRINTF(fp, "%s", data);
 }
 
 #if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)
@@ -5103,7 +5104,7 @@ static int ProcessBufferTryDecode(WOLFSSL_CTX* ctx, WOLFSSL* ssl, DerBuffer* der
         if (key == NULL)
             return MEMORY_E;
     #endif
-
+        
         ret = wc_InitRsaKey_ex(key, heap, devId);
         if (ret == 0) {
             *idx = 0;
@@ -15669,6 +15670,7 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
         WOLFSSL_ENTER("BIO_set_write_buffer_size");
         WOLFSSL_STUB("BIO_set_write_buffer_size");
         (void)bio;
+        /* return 1 if the buffer was successfully resized or 0 for failure. */
         return size;
     }
     #endif
@@ -15977,8 +15979,15 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
                     wolfSSL_free((WOLFSSL*)bio->ptr);
             #ifdef CloseSocket
                 if (bio->type == WOLFSSL_BIO_SOCKET && bio->num)
+                {
+                #ifdef FUSION_RTOS
+                    int err;
+                    CloseSocket(bio->num, &err);
+                #else
                     CloseSocket(bio->num);
-            #endif
+                #endif
+                }
+             #endif
             }
 
         #ifndef NO_FILESYSTEM
@@ -29095,7 +29104,7 @@ int wolfSSL_BIO_vprintf(WOLFSSL_BIO* bio, const char* format, va_list args)
                 va_end(args);
                 return -1;
             }
-            ret = vfprintf((XFILE)bio->ptr, format, args);
+            ret = XVFPRINTF((XFILE)bio->ptr, format, args);
             break;
 
         case WOLFSSL_BIO_MEMORY:
@@ -29109,15 +29118,20 @@ int wolfSSL_BIO_vprintf(WOLFSSL_BIO* bio, const char* format, va_list args)
                 char* pt = NULL;
                 va_list copy;
 
-                va_copy(copy, args);
-                count = vsnprintf(NULL, 0, format, args);
+                #ifdef FUSION_RTOS
+                   copy = args;    /* hack, depends on internal implementation
+                                    * of va_list in VisualDSP++ */
+                #else
+                    va_copy(copy, args);
+                #endif
+                count = XVSNPRINTF(NULL, 0, format, args);
                 if (count >= 0)
                 {
                     pt = (char*)XMALLOC(count + 1, bio->heap,
                                         DYNAMIC_TYPE_TMP_BUFFER);
                     if (pt != NULL)
                     {
-                        count = vsnprintf(pt, count + 1, format, copy);
+                        count = XVSNPRINTF(pt, count + 1, format, copy);
                         if (count >= 0)
                         {
                             ret = wolfSSL_BIO_write(bio, pt, count);
@@ -29173,24 +29187,24 @@ int wolfSSL_BIO_dump(WOLFSSL_BIO *bio, const char *buf, int length)
         char line[80];
 
         if (!buf) {
-            return fputs("\tNULL", (XFILE)bio->ptr);
+            return XFPUTS("\tNULL", (XFILE)bio->ptr);
         }
 
-        sprintf(line, "\t");
+        XSPRINTF(line, "\t");
         for (i = 0; i < LINE_LEN; i++) {
             if (i < length)
-                sprintf(line + 1 + i * 3,"%02x ", buf[i]);
+                XSPRINTF(line + 1 + i * 3,"%02x ", buf[i]);
             else
-                sprintf(line + 1 + i * 3, "   ");
+                XSPRINTF(line + 1 + i * 3, "   ");
         }
-        sprintf(line + 1 + LINE_LEN * 3, "| ");
+        XSPRINTF(line + 1 + LINE_LEN * 3, "| ");
         for (i = 0; i < LINE_LEN; i++) {
             if (i < length) {
-                sprintf(line + 3 + LINE_LEN * 3 + i,
+                XSPRINTF(line + 3 + LINE_LEN * 3 + i,
                      "%c", 31 < buf[i] && buf[i] < 127 ? buf[i] : '.');
             }
         }
-        ret += fputs(line, (XFILE)bio->ptr);
+        ret += XFPUTS(line, (XFILE)bio->ptr);
 
         if (length > LINE_LEN)
             ret += wolfSSL_BIO_dump(bio, buf + LINE_LEN, length - LINE_LEN);
@@ -31486,7 +31500,8 @@ int SetDhInternal(WOLFSSL_DH* dh)
     return ret;
 }
 
-#if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL) || defined(WOLFSSL_OPENSSH))
+#if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL) \
+    || defined(WOLFSSL_OPENSSH))
 
 #ifdef WOLFSSL_DH_EXTRA
 WOLFSSL_DH* wolfSSL_DH_dup(WOLFSSL_DH* dh)
@@ -36090,6 +36105,7 @@ WOLFSSL_BIGNUM *wolfSSL_EC_POINT_point2bn(const WOLFSSL_EC_GROUP *group,
 
     return ret;
 }
+#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
 
 #ifdef USE_ECC_B_PARAM
 int wolfSSL_EC_POINT_is_on_curve(const WOLFSSL_EC_GROUP *group,
@@ -36113,7 +36129,6 @@ int wolfSSL_EC_POINT_is_on_curve(const WOLFSSL_EC_GROUP *group,
             == MP_OKAY ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
 }
 #endif /* USE_ECC_B_PARAM */
-#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
 
 WOLFSSL_EC_POINT *wolfSSL_EC_POINT_new(const WOLFSSL_EC_GROUP *group)
 {
@@ -49917,7 +49932,7 @@ int wolfSSL_BN_print_fp(XFILE fp, const WOLFSSL_BIGNUM *bn)
         return WOLFSSL_FAILURE;
     }
 
-    fprintf(fp, "%s", buf);
+    XFPRINTF(fp, "%s", buf);
     XFREE(buf, NULL, DYNAMIC_TYPE_OPENSSL);
 
     return WOLFSSL_SUCCESS;

src/tls13.c

@@ -1371,9 +1371,14 @@ end:
     word32 TimeNowInMilliseconds(void)
     {
         struct timeval now;
-
+#ifdef FUSION_RTOS
+        if (FCL_GETTIMEOFDAY(&now, 0) < 0)
+            return (word32)GETTIME_ERROR;
+            //TODO research why negative error code returns as word32
+#else
         if (gettimeofday(&now, 0) < 0)
-            return GETTIME_ERROR;
+            return (word32)GETTIME_ERROR;
+#endif
         /* Convert to milliseconds number. */
         return (word32)(now.tv_sec * 1000 + now.tv_usec / 1000);
     }

src/wolfio.c

@@ -98,6 +98,9 @@ static WC_INLINE int wolfSSL_LastError(int err)
     return xn_getlasterror();
 #elif defined(WOLFSSL_LINUXKM)
     return err; /* Return provided error value */
+#elif defined(FUSION_RTOS)
+    #include <fclerrno.h>
+    return FCL_GET_ERRNO;
 #else
     return errno;
 #endif
@@ -694,7 +697,24 @@ int wolfIO_Recv(SOCKET_T sd, char *buf, int sz, int rdFlags)
 {
     int recvd;
 
+#ifdef FUSION_RTOS
+    int err;
+retry:
+    recvd = (int)RECV_FUNCTION(sd, buf, sz, rdFlags, &err);
+
+    if(recvd < 0) {
+       if(err==63)
+       {
+           UARTF("FUSION IO RETRY %d\r\n", err);
+           fclThreadSleep(10);
+           goto retry; 
+       }
+       UARTF("FUSION IO ERROR %d\r\n", err);
+    }
+    //TODO handle return value in err
+#else
     recvd = (int)RECV_FUNCTION(sd, buf, sz, rdFlags);
+#endif
     recvd = TranslateReturnCode(recvd, sd);
 
     return recvd;
@@ -703,8 +723,22 @@ int wolfIO_Recv(SOCKET_T sd, char *buf, int sz, int rdFlags)
 int wolfIO_Send(SOCKET_T sd, char *buf, int sz, int wrFlags)
 {
     int sent;
-
+#ifdef FUSION_RTOS
+    int err;
+retry:
+    sent = (int)SEND_FUNCTION(sd, buf, sz, wrFlags, &err);
+    if(sent < 0) {
+       if(err==63)
+       {
+           UARTF("FUSION IO SEND RETRY %d\r\n", err);
+           fclThreadSleep(10);
+           goto retry; 
+       }
+       UARTF("FUSION IO SEND ERROR %d\r\n", err);
+    }
+#else
     sent = (int)SEND_FUNCTION(sd, buf, sz, wrFlags);
+#endif
     sent = TranslateReturnCode(sent, sd);
 
     return sent;
@@ -785,6 +819,8 @@ int wolfIO_Send(SOCKET_T sd, char *buf, int sz, int wrFlags)
                 }
             }
         }
+                    WOLFSSL_MSG("Select error");
+
         return SOCKET_ERROR_E;
     }
 #endif /* HAVE_IO_TIMEOUT */
@@ -1462,8 +1498,14 @@ int EmbedOcspLookup(void* ctx, const char* url, int urlSz,
                 ret = wolfIO_HttpProcessResponseOcsp(sfd, ocspRespBuf, httpBuf,
                                                  HTTP_SCRATCH_BUFFER_SIZE, ctx);
             }
-            if (sfd != SOCKET_INVALID)
+            if (sfd != SOCKET_INVALID) {
+            #ifdef FUSION_RTOS
+                int err;
+                CloseSocket(sfd, &err);
+            #else
                 CloseSocket(sfd);
+            #endif
+            }
             XFREE(httpBuf, ctx, DYNAMIC_TYPE_OCSP);
         }
     }

wolfcrypt/src/evp.c

@@ -41,7 +41,6 @@
     #include <wolfssl/wolfcrypt/aes.h>
 #endif
 
-
 #include <wolfssl/openssl/ecdsa.h>
 #include <wolfssl/openssl/evp.h>
 

wolfcrypt/src/logging.c

@@ -266,8 +266,12 @@ void WOLFSSL_TIME(int count)
     #include "xil_printf.h"
 #elif defined(WOLFSSL_LINUXKM)
     /* the requisite linux/kernel.h is included in wc_port.h, with incompatible warnings masked out. */
+#elif defined(FUSION_RTOS)
+    #include <fclstdio.h>
+    #include <wolfssl/wolfcrypt/wc_port.h>
+    #define fprintf FCL_FPRINTF
 #else
-    #include <stdio.h>   /* for default printf stuff */
+    #include <stdio.h>/* for default printf stuff */
 #endif
 
 #if defined(THREADX) && !defined(THREADX_NO_DC_PRINTF)
@@ -856,7 +860,7 @@ void wc_ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u),
         while (current != NULL)
         {
             next = current->next;
-            cb(current->error, strlen(current->error), u);
+            cb(current->error, XSTRLEN(current->error), u);
             XFREE(current, current->heap, DYNAMIC_TYPE_LOG);
             current = next;
         }

wolfssl/internal.h

@@ -199,7 +199,11 @@
         #endif
     #endif
     #if defined(OPENSSL_EXTRA) && !defined(NO_FILESYSTEM)
-        #include <unistd.h>      /* for close of BIO */
+        #ifdef FUSION_RTOS
+           #include <fclunistd.h>
+        #else
+            #include <unistd.h>      /* for close of BIO */
+        #endif
     #endif
 #endif
 

wolfssl/ssl.h

@@ -1852,7 +1852,11 @@ enum {
 #if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM)
 /* wolfSSL extension, provide last error from SSL_get_error
    since not using thread storage error queue */
-#include <stdio.h>
+#ifdef FUSION_RTOS
+    #include <fclstdio.h>
+#else
+    #include <stdio.h>
+#endif
 WOLFSSL_API void  wolfSSL_ERR_print_errors_fp(XFILE, int err);
 #if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)
 WOLFSSL_API void wolfSSL_ERR_dump_errors_fp(XFILE fp);

wolfssl/test.h

@@ -3,8 +3,13 @@
 #ifndef wolfSSL_TEST_H
 #define wolfSSL_TEST_H
 
-#include <stdio.h>
-#include <stdlib.h>
+#ifdef FUSION_RTOS
+    #include <fclstdio.h>
+    #include <fclstdlib.h>
+#else
+    #include <stdio.h>
+    #include <stdlib.h>
+#endif
 #include <assert.h>
 #include <ctype.h>
 #include <wolfssl/wolfcrypt/types.h>

wolfssl/wolfcrypt/wc_port.h

@@ -323,7 +323,11 @@
     #endif
     #if (defined(OPENSSL_EXTRA) || defined(GOAHEAD_WS)) && \
         !defined(NO_FILESYSTEM)
-        #include <unistd.h>      /* for close of BIO */
+        #ifdef FUSION_RTOS
+            #include <fclunistd.h>
+        #else
+            #include <unistd.h>      /* for close of BIO */
+        #endif
     #endif
 #endif
 
@@ -487,6 +491,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XSEEK_END                VSEEK_END
     #define XBADFILE                 -1
     #define XFGETS(b,s,f)            -2 /* Not ported yet */
+    #define XVFPRINTF                vfprintf
+    #define XVSNPRINTF               vsnprintf
+    #define XFPUTS                   fputs
+    #define XSPRINTF                 sprintf
+
 #elif defined(LSR_FS)
     #include <fs.h>
     #define XFILE                   struct fs_file*
@@ -499,7 +508,12 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XFCLOSE                 fs_close
     #define XSEEK_END               0
     #define XBADFILE                NULL
-    #define XFGETS(b,s,f)            -2 /* Not ported yet */
+    #define XFGETS(b,s,f)           -2 /* Not ported yet */
+    #define XVFPRINTF               vfprintf
+    #define XVSNPRINTF              vsnprintf
+    #define XFPUTS                  fputs
+    #define XSPRINTF                sprintf
+
 #elif defined(FREESCALE_MQX) || defined(FREESCALE_KSDK_MQX)
     #define XFILE                   MQX_FILE_PTR
     #define XFOPEN                  fopen
@@ -512,10 +526,19 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XSEEK_END               IO_SEEK_END
     #define XBADFILE                NULL
     #define XFGETS                  fgets
+    #define XVFPRINTF               vfprintf
+    #define XVSNPRINTF              vsnprintf
+    #define XFPUTS                  fputs
+    #define XSPRINTF                sprintf
+
 #elif defined(WOLFSSL_DEOS)
     #define NO_FILESYSTEM
     #warning "TODO - DDC-I Certifiable Fast File System for Deos is not integrated"
-    //#define XFILE      bfd *
+    /* #define XFILE      bfd * */
+    #define XVFPRINTF  vfprintf
+    #define XVSNPRINTF vsnprintf
+    #define XFPUTS     fputs
+    #define XSPRINTF   sprintf
 
 #elif defined(MICRIUM)
     #include <fs_api.h>
@@ -530,6 +553,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XSEEK_END  FS_SEEK_END
     #define XBADFILE   NULL
     #define XFGETS(b,s,f) -2 /* Not ported yet */
+    #define XVFPRINTF  vfprintf
+    #define XVSNPRINTF vsnprintf
+    #define XFPUTS     fputs
+    #define XSPRINTF   sprintf
+
 #elif defined(WOLFSSL_NUCLEUS_1_2)
     #include "fal/inc/fal.h"
     #define XFILE      FILE*
@@ -542,6 +570,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XFCLOSE    fclose
     #define XSEEK_END  PSEEK_END
     #define XBADFILE   NULL
+    #define XVFPRINTF  vfprintf
+    #define XVSNPRINTF vsnprintf
+    #define XFPUTS     fputs
+    #define XSPRINTF   sprintf
+
 #elif defined(WOLFSSL_APACHE_MYNEWT)
     #include <fs/fs.h>
     #define XFILE  struct fs_file*
@@ -556,6 +589,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XSEEK_END  2
     #define XBADFILE   NULL
     #define XFGETS(b,s,f) -2 /* Not ported yet */
+    #define XVFPRINTF  vfprintf
+    #define XVSNPRINTF vsnprintf
+    #define XFPUTS     fputs
+    #define XSPRINTF   sprintf
+
 #elif defined(WOLFSSL_ZEPHYR)
     #include <fs.h>
 
@@ -576,6 +614,10 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XSEEK_END           FS_SEEK_END
     #define XBADFILE            NULL
     #define XFGETS(b,s,f)       -2 /* Not ported yet */
+    #define XVFPRINTF           vfprintf
+    #define XVSNPRINTF          vsnprintf
+    #define XFPUTS              fputs
+    #define XSPRINTF            sprintf
 
 #elif defined(WOLFSSL_TELIT_M2MB)
     #define XFILE                    INT32
@@ -589,6 +631,10 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XSEEK_END                M2MB_SEEK_END
     #define XBADFILE                 -1
     #define XFGETS(b,s,f)            -2 /* Not ported yet */
+    #define XVFPRINTF  vfprintf
+    #define XVSNPRINTF               vsnprintf
+    #define XFPUTS                   fputs
+    #define XSPRINTF                 sprintf
 
 #elif defined (WOLFSSL_XILINX)
     #include "xsdps.h"
@@ -606,6 +652,42 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XSEEK_END                0
     #define XBADFILE                 NULL
     #define XFGETS(b,s,f)            f_gets((b), (s), (f))
+    #define XVFPRINTF  vfprintf
+    #define XVSNPRINTF               vsnprintf
+    #define XFPUTS                   fputs
+    #define XSPRINTF                 sprintf
+
+#elif defined(FUSION_RTOS)
+    #include <fclstdio.h>
+    #include <fclunistd.h>
+    #include <fcldirent.h>
+    #include <sys/fclstat.h>
+   #include <fclstring.h>
+   #include <fcl_os.h>
+    #define XFILE     FCL_FILE*
+    #define XFOPEN    FCL_FOPEN
+    #define XFSEEK    FCL_FSEEK
+    #define XFTELL    FCL_FTELL
+    #define XREWIND   FCL_REWIND
+    #define XFREAD    FCL_FREAD
+    #define XFWRITE   FCL_FWRITE
+    #define XFCLOSE   FCL_FCLOSE
+    #define XSEEK_END SEEK_END
+    #define XBADFILE  NULL
+    #define XFGETS    FCL_FGETS
+    #define XFPUTS    FCL_FPUTS
+    #define XFPRINTF  FCL_FPRINTF
+    #define XVFPRINTF FCL_VFPRINTF
+    #define XVSNPRINTF  FCL_VSNPRINTF
+    #define XSNPRINTF  FCL_SNPRINTF
+    #define XSPRINTF  FCL_SPRINTF
+    #define DIR       FCL_DIR
+    #define stat      FCL_STAT
+    #define opendir   FCL_OPENDIR
+    #define closedir  FCL_CLOSEDIR
+    #define readdir   FCL_READDIR
+    #define dirent    fclDirent 
+    #define strncasecmp FCL_STRNCASECMP
 
 #elif defined(WOLFSSL_USER_FILESYSTEM)
     /* To be defined in user_settings.h */
@@ -629,6 +711,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
     #define XSEEK_END  SEEK_END
     #define XBADFILE   NULL
     #define XFGETS     fgets
+    #define XFPRINTF   fprintf
+    #define XVFPRINTF  vfprintf
+    #define XVSNPRINTF vsnprintf
+    #define XFPUTS     fputs
+    #define XSPRINTF   sprintf
 
     #if !defined(USE_WINDOWS_API) && !defined(NO_WOLFSSL_DIR)\
         && !defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)

wolfssl/wolfio.h

@@ -133,6 +133,10 @@
     #elif defined(HAVE_NETX)
         #include "nx_api.h"
         #include "errno.h"
+    #elif defined(FUSION_RTOS)
+        #include <sys/fcltypes.h>
+        #include <fclerrno.h>
+        #include <fclfcntl.h>
     #elif !defined(WOLFSSL_NO_SOCK)
         #include <sys/types.h>
         #include <errno.h>
@@ -259,6 +263,14 @@
     #define SOCKET_EPIPE       NX_NOT_CONNECTED
     #define SOCKET_ECONNREFUSED NX_NOT_CONNECTED
     #define SOCKET_ECONNABORTED NX_NOT_CONNECTED
+#elif defined(FUSION_RTOS)
+    #define SOCKET_EWOULDBLOCK FCL_EWOULDBLOCK
+    #define SOCKET_EAGAIN      FCL_EAGAIN
+    #define SOCKET_ECONNRESET  FNS_ECONNRESET
+    #define SOCKET_EINTR       FCL_EINTR
+    #define SOCKET_EPIPE       FCL_EPIPE
+    #define SOCKET_ECONNREFUSED FCL_ECONNREFUSED
+    #define SOCKET_ECONNABORTED FNS_ECONNABORTED
 #else
     #define SOCKET_EWOULDBLOCK EWOULDBLOCK
     #define SOCKET_EAGAIN      EAGAIN
@@ -290,6 +302,9 @@
 #elif defined(WOLFSSL_NUCLEUS_1_2)
     #define SEND_FUNCTION NU_Send
     #define RECV_FUNCTION NU_Recv
+#elif defined(FUSION_RTOS)
+    #define SEND_FUNCTION FNS_SEND
+    #define RECV_FUNCTION FNS_RECV
 #elif defined(WOLFSSL_ZEPHYR)
     #ifndef WOLFSSL_MAX_SEND_SZ
         #define WOLFSSL_MAX_SEND_SZ       256
@@ -372,6 +387,10 @@ WOLFSSL_API  int wolfIO_Recv(SOCKET_T sd, char *buf, int sz, int rdFlags);
         #define CloseSocket(s) closesocket(s)
     #endif
     #define StartTCP()
+#elif defined(FUSION_RTOS)
+    #ifndef CloseSocket
+        #define CloseSocket FNS_CLOSE
+    #endif
 #else
     #ifndef CloseSocket
         #define CloseSocket(s) close(s)