diff --git a/tests/unit.c b/tests/unit.c
index 1f1bfd327..825c5550f 100644
--- a/tests/unit.c
+++ b/tests/unit.c
@@ -291,7 +291,7 @@ void wait_tcp_ready(func_args* args)
 }
 
 
-void start_thread(THREAD_FUNC fun, func_args* args, THREAD_TYPE* thread)
+void start_thread(THREAD_CB fun, func_args* args, THREAD_TYPE* thread)
 {
 #if defined(SINGLE_THREADED)
     (void)fun;
diff --git a/testsuite/testsuite.c b/testsuite/testsuite.c
index 910e19730..7b227531a 100644
--- a/testsuite/testsuite.c
+++ b/testsuite/testsuite.c
@@ -269,14 +269,14 @@ static int test_crl_monitor(void)
     char buf[128];
     char tmpDir[16];
     char rounds[4];
-    char* serverArgv[] = {
+    const char* serverArgv[] = {
         "testsuite",
         "-A", "certs/ca-cert.pem",
         "--crl-dir", tmpDir,
         "-C", rounds,
         "-x"
     };
-    char* clientArgv[] = {
+    const char* clientArgv[] = {
         "testsuite",
         "-C",
         "-c", "certs/server-cert.pem",
@@ -297,10 +297,10 @@ static int test_crl_monitor(void)
         goto cleanup;
     }
 
-    server_args.argv = serverArgv;
+    server_args.argv = (char**)serverArgv;
     server_args.argc = sizeof(serverArgv) / sizeof(*serverArgv);
     client_args.signal = server_args.signal = &ready;
-    client_args.argv = clientArgv;
+    client_args.argv = (char**)clientArgv;
     client_args.argc = sizeof(clientArgv) / sizeof(*clientArgv);
 
     InitTcpReady(&ready);
@@ -675,14 +675,18 @@ void join_thread(THREAD_TYPE thread)
 #endif
 }
 
+#ifndef NO_FILESYSTEM
+
+#ifdef _MSC_VER
 #include <direct.h>
+#endif
 
 #define TMP_DIR_PREFIX "tmpDir-"
 /* len is length of tmpDir name, assuming
  * len does not include null terminating character */
 char* create_tmp_dir(char *tmpDir, int len)
 {
-    if (len < XSTR_SIZEOF(TMP_DIR_PREFIX))
+    if (len < (int)XSTR_SIZEOF(TMP_DIR_PREFIX))
         return NULL;
 
     XMEMCPY(tmpDir, TMP_DIR_PREFIX, XSTR_SIZEOF(TMP_DIR_PREFIX));
@@ -690,23 +694,38 @@ char* create_tmp_dir(char *tmpDir, int len)
     if (mymktemp(tmpDir, len, len - XSTR_SIZEOF(TMP_DIR_PREFIX)) == NULL)
         return NULL;
 
+#ifdef _MSC_VER
     if (_mkdir(tmpDir) != 0)
         return NULL;
+#else
+    if (mkdir(tmpDir, 0700) != 0)
+        return NULL;
+#endif
 
     return tmpDir;
 }
 
 int rem_dir(const char* dirName)
 {
+#ifdef _MSC_VER
     if (_rmdir(dirName) != 0)
         return -1;
+#else
+    if (rmdir(dirName) != 0)
+        return -1;
+#endif
     return 0;
 }
 
 int rem_file(const char* fileName)
 {
+#ifdef _MSC_VER
     if (_unlink(fileName) != 0)
         return -1;
+#else
+    if (unlink(fileName) != 0)
+        return -1;
+#endif
     return 0;
 }
 
@@ -743,6 +762,7 @@ cleanup:
         XFCLOSE(outFile);
     return ret;
 }
+#endif /* !NO_FILESYSTEM */
 
 #ifndef NO_SHA256
 /* Create SHA-256 hash of the file based on filename.
diff --git a/wolfcrypt/src/wc_port.c b/wolfcrypt/src/wc_port.c
index 10d41bb0e..84c96af4f 100644
--- a/wolfcrypt/src/wc_port.c
+++ b/wolfcrypt/src/wc_port.c
@@ -3374,16 +3374,19 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
 
     int wolfSSL_JoinThread(THREAD_TYPE thread)
     {
+        int ret = 0;
+
         if (thread == INVALID_THREAD_VAL)
             return BAD_FUNC_ARG;
 
+        /* We still want to attempt to close the thread handle even on error */
         if (WaitForSingleObject((HANDLE)thread, INFINITE) == WAIT_FAILED)
-            return MEMORY_ERROR;
+            ret = MEMORY_ERROR;
 
         if (CloseHandle((HANDLE)thread) == 0)
-            return MEMORY_ERROR;
+            ret = MEMORY_ERROR;
 
-        return 0;
+        return ret;
     }
 
 #ifdef WOLFSSL_COND
@@ -3438,6 +3441,79 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
 
 #else /* pthread */
 
+    int wolfSSL_NewThread(THREAD_TYPE* thread,
+        THREAD_CB cb, void* arg)
+    {
+        if (thread == NULL || cb == NULL)
+            return BAD_FUNC_ARG;
+
+        if (pthread_create(thread, NULL, cb, arg) != 0)
+            return MEMORY_ERROR;
+
+        return 0;
+    }
+
+    int wolfSSL_JoinThread(THREAD_TYPE thread)
+    {
+        if (thread == INVALID_THREAD_VAL)
+            return BAD_FUNC_ARG;
+
+        if (pthread_join(thread, NULL) != 0)
+            return MEMORY_ERROR;
+
+        return 0;
+    }
+
+#ifdef WOLFSSL_COND
+    int wolfSSL_CondInit(COND_TYPE* cond)
+    {
+        if (cond == NULL)
+            return BAD_FUNC_ARG;
+
+        if (pthread_cond_init(cond, NULL) != 0)
+            return MEMORY_ERROR;
+
+        return 0;
+    }
+
+    int wolfSSL_CondFree(COND_TYPE* cond)
+    {
+        if (cond == NULL)
+            return BAD_FUNC_ARG;
+
+        if (pthread_cond_destroy(cond) != 0)
+            return MEMORY_ERROR;
+
+        return 0;
+    }
+
+    int wolfSSL_CondSignal(COND_TYPE* cond)
+    {
+        if (cond == NULL)
+            return BAD_FUNC_ARG;
+
+        if (pthread_cond_signal(cond) != 0)
+            return MEMORY_ERROR;
+
+        return 0;
+    }
+
+    int wolfSSL_CondWait(COND_TYPE* cond,
+            wolfSSL_Mutex* mutex)
+    {
+        if (cond == NULL || mutex == NULL)
+            return BAD_FUNC_ARG;
+
+        /* mutex has to be locked on entry so we can't touch */
+
+        if (pthread_cond_wait(cond, mutex) != 0)
+            return MEMORY_ERROR;
+
+        return 0;
+    }
+
+#endif /* WOLFSSL_COND */
+
 #endif
 
 #endif /* SINGLE_THREADED */
diff --git a/wolfssl/wolfcrypt/types.h b/wolfssl/wolfcrypt/types.h
index 4318174c0..6354dd763 100644
--- a/wolfssl/wolfcrypt/types.h
+++ b/wolfssl/wolfcrypt/types.h
@@ -1359,8 +1359,9 @@ typedef struct w64wrapper {
         !defined(__MINGW32__)
         typedef void*         THREAD_RETURN;
         typedef pthread_t     THREAD_TYPE;
+        typedef pthread_cond_t COND_TYPE;
+        #define WOLFSSL_COND
         #define WOLFSSL_THREAD
-#error TODO implement threading with pthreads
     #elif defined(FREERTOS)
         typedef unsigned int   THREAD_RETURN;
         typedef TaskHandle_t   THREAD_TYPE;
@@ -1387,7 +1388,7 @@ typedef struct w64wrapper {
         typedef THREAD_RETURN (WOLFSSL_THREAD *THREAD_CB)(void* arg);
 
         #ifndef INVALID_THREAD_VAL
-            #define INVALID_THREAD_VAL (-1)
+            #define INVALID_THREAD_VAL ((THREAD_TYPE)(-1))
         #endif
 
         WOLFSSL_LOCAL int wolfSSL_NewThread(THREAD_TYPE* thread,
diff --git a/zephyr/samples/wolfssl_tls_sock/src/tls_sock.c b/zephyr/samples/wolfssl_tls_sock/src/tls_sock.c
index 8e71527db..d821f1edd 100644
--- a/zephyr/samples/wolfssl_tls_sock/src/tls_sock.c
+++ b/zephyr/samples/wolfssl_tls_sock/src/tls_sock.c
@@ -294,7 +294,7 @@ static void wolfssl_memstats(WOLFSSL* ssl)
 
 
 /* Start the server thread. */
-void start_thread(THREAD_FUNC func, func_args* args, THREAD_TYPE* thread)
+void start_thread(THREAD_CB func, func_args* args, THREAD_TYPE* thread)
 {
     k_thread_create(thread, server_stack, K_THREAD_STACK_SIZEOF(server_stack),
                     func, args, NULL, NULL, 5, 0, K_NO_WAIT);
diff --git a/zephyr/samples/wolfssl_tls_thread/src/tls_threaded.c b/zephyr/samples/wolfssl_tls_thread/src/tls_threaded.c
index 57990ab99..3a59669f8 100644
--- a/zephyr/samples/wolfssl_tls_thread/src/tls_threaded.c
+++ b/zephyr/samples/wolfssl_tls_thread/src/tls_threaded.c
@@ -517,7 +517,7 @@ static void wolfssl_memstats(WOLFSSL* ssl)
 
 
 /* Start the server thread. */
-void start_thread(THREAD_FUNC func, func_args* args, THREAD_TYPE* thread)
+void start_thread(THREAD_CB func, func_args* args, THREAD_TYPE* thread)
 {
     k_thread_create(thread, server_stack, K_THREAD_STACK_SIZEOF(server_stack),
                     func, args, NULL, NULL, 5, 0, K_NO_WAIT);