Fixes for building with WOLFSSL_USER_IO (with no built-in socket support). Related to issue #3998.

examples/benchmark/tls_bench.c

@@ -42,7 +42,7 @@ bench_tls(args);
 #include <wolfssl/ssl.h>
 #include <wolfssl/wolfcrypt/hash.h> /* WC_MAX_DIGEST_SIZE */
 #include <wolfssl/test.h>
-
+#include <wolfssl/wolfio.h>
 #include <examples/benchmark/tls_bench.h>
 
 /* force certificate test buffers to be included via headers */
@@ -121,7 +121,7 @@ bench_tls(args);
 #define SHOW_VERBOSE        0 /* Default output is tab delimited format */
 
 #if (!defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER)) && \
-    !defined(WOLFCRYPT_ONLY)
+    !defined(WOLFCRYPT_ONLY) && defined(USE_WOLFSSL_IO)
 
 /* shutdown message - nice signal to server, we are done */
 static const char* kShutdown = "shutdown";
@@ -1930,7 +1930,7 @@ exit:
 
     return ret;
 }
-#endif /* (!NO_WOLFSSL_CLIENT || !NO_WOLFSSL_SERVER) && !WOLFCRYPT_ONLY */
+#endif /* (!NO_WOLFSSL_CLIENT || !NO_WOLFSSL_SERVER) && !WOLFCRYPT_ONLY && USE_WOLFSSL_IO */
 
 #ifndef NO_MAIN_DRIVER
 
@@ -1942,7 +1942,8 @@ int main(int argc, char** argv)
     args.argv = argv;
     args.return_code = 0;
 
-#if (!defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER)) && !defined(WOLFCRYPT_ONLY)
+#if (!defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER)) && \
+    !defined(WOLFCRYPT_ONLY) && defined(USE_WOLFSSL_IO)
     bench_tls(&args);
 #endif
 

examples/client/client.c

@@ -2478,7 +2478,9 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
         wolfSSL_CTX_SetMinVersion(ctx, minVersion);
     }
     if (simulateWantWrite) {
+    #ifdef USE_WOLFSSL_IO
         wolfSSL_CTX_SetIOSend(ctx, SimulateWantWriteIOSendCb);
+    #endif
     }
 
 #ifdef SINGLE_THREADED
@@ -2607,7 +2609,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
 
 #ifdef HAVE_OCSP
     if (useOcsp) {
-    #ifdef HAVE_IO_TIMEOUT
+    #if defined(HAVE_IO_TIMEOUT) && defined(HAVE_HTTP_CLIENT)
         wolfIO_SetTimeout(DEFAULT_TIMEOUT_SEC);
     #endif
 
@@ -3165,7 +3167,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
 
 #ifdef HAVE_CRL
     if (disableCRL == 0 && !useVerifyCb) {
-    #ifdef HAVE_IO_TIMEOUT
+    #if defined(HAVE_IO_TIMEOUT) && defined(HAVE_HTTP_CLIENT)
         wolfIO_SetTimeout(DEFAULT_TIMEOUT_SEC);
     #endif
 

examples/server/server.c

@@ -152,7 +152,7 @@ static void err_sys_ex(int out, const char* msg)
 }
 
 
-#ifdef WOLFSSL_DTLS
+#if defined(WOLFSSL_DTLS) && defined(USE_WOLFSSL_IO)
 
 /* Translates return codes returned from
  * send() and recv() if need be.
@@ -277,8 +277,7 @@ static int TestEmbedSendTo(WOLFSSL* ssl, char *buf, int sz, void *ctx)
 
     return sent;
 }
-
+#endif /* WOLFSSL_DTLS && USE_WOLFSSL_IO */
-#endif /* WOLFSSL_DTLS */
 
 #ifdef WOLFSSL_WOLFSENTRY_HOOKS
 
@@ -1173,7 +1172,7 @@ THREAD_RETURN WOLFSSL_THREAD server_test(void* args)
 #endif
     int    dtlsSCTP = 0;
     int    doMcast = 0;
-#ifdef WOLFSSL_DTLS
+#if defined(WOLFSSL_DTLS) && defined(USE_WOLFSSL_IO)
     int    doBlockSeq = 0;
     WOLFSSL_TEST_DTLS_CTX dtlsCtx;
 #endif
@@ -1773,7 +1772,7 @@ THREAD_RETURN WOLFSSL_THREAD server_test(void* args)
                 break;
 
             case '4' :
-                #ifdef WOLFSSL_DTLS
+                #if defined(WOLFSSL_DTLS) && defined(USE_WOLFSSL_IO)
                     XMEMSET(&dtlsCtx, 0, sizeof(dtlsCtx));
                     doBlockSeq = 1;
                     dtlsCtx.blockSeq = atoi(myoptarg);
@@ -2065,7 +2064,9 @@ THREAD_RETURN WOLFSSL_THREAD server_test(void* args)
 
     if (simulateWantWrite)
     {
+    #ifdef USE_WOLFSSL_IO
         wolfSSL_CTX_SetIOSend(ctx, SimulateWantWriteIOSendCb);
+    #endif
     }
 
 #if defined(HAVE_SESSION_TICKET) && defined(WOLFSSL_NO_DEF_TICKET_ENC_CB) && \
@@ -2418,7 +2419,7 @@ THREAD_RETURN WOLFSSL_THREAD server_test(void* args)
     }
 
     if (doDTLS && dtlsUDP) {
-#ifdef WOLFSSL_DTLS
+#if defined(WOLFSSL_DTLS) && defined(USE_WOLFSSL_IO)
         if (doBlockSeq) {
             wolfSSL_CTX_SetIOSend(ctx, TestEmbedSendTo);
         }
@@ -2730,7 +2731,7 @@ THREAD_RETURN WOLFSSL_THREAD server_test(void* args)
         }
 #endif
 
-#ifdef WOLFSSL_DTLS
+#if defined(WOLFSSL_DTLS) && defined(USE_WOLFSSL_IO)
         if (doDTLS && dtlsUDP) {
             byte          b[1500];
             int           n;

src/bio.c

@@ -261,7 +261,13 @@ int wolfSSL_BIO_read(WOLFSSL_BIO* bio, void* buf, int len)
             #endif
                 break;
             case WOLFSSL_BIO_SOCKET:
+            #ifdef USE_WOLFSSL_IO
+                /* BIO requires built-in socket support 
+                 *  (cannot be used with WOLFSSL_USER_IO) */
                 ret = wolfIO_Recv(bio->num, (char*)buf, len, 0);
+            #else
+                ret = NOT_COMPILED_IN;
+            #endif
                 break;
             } /* switch */
         }
@@ -635,7 +641,13 @@ int wolfSSL_BIO_write(WOLFSSL_BIO* bio, const void* data, int len)
             #endif
                 break;
             case WOLFSSL_BIO_SOCKET:
+            #ifdef USE_WOLFSSL_IO
+                /* BIO requires built-in socket support 
+                 *  (cannot be used with WOLFSSL_USER_IO) */
                 ret = wolfIO_Send(bio->num, (char*)data, len, 0);
+            #else
+                ret = NOT_COMPILED_IN;
+            #endif                
                 break;
             } /* switch */
         }

src/ssl.c

@@ -6296,7 +6296,7 @@ int wolfSSL_CertManagerEnableCRL(WOLFSSL_CERT_MANAGER* cm, int options)
                 return WOLFSSL_FAILURE;
             }
 
-        #ifdef HAVE_CRL_IO
+        #if defined(HAVE_CRL_IO) && defined(USE_WOLFSSL_IO)
             cm->crl->crlIOCb = EmbedCrlLookup;
         #endif
         }

src/wolfio.c

@@ -47,7 +47,7 @@ Possible IO enable options:
  * WOLFSSL_USER_IO:     Disables default Embed* callbacks and     default: off
                         allows user to define their own using
                         wolfSSL_CTX_SetIORecv and wolfSSL_CTX_SetIOSend
- * USE_WOLFSSL_IO:      Enables the wolfSSL IO functions          default: off
+ * USE_WOLFSSL_IO:      Enables the wolfSSL IO functions          default: on
  * HAVE_HTTP_CLIENT:    Enables HTTP client API's                 default: off
                                      (unless HAVE_OCSP or HAVE_CRL_IO defined)
  * HAVE_IO_TIMEOUT:     Enables support for connect timeout       default: off
@@ -106,8 +106,38 @@ static WC_INLINE int wolfSSL_LastError(int err)
 #endif
 }
 
-#endif /* USE_WOLFSSL_IO || HAVE_HTTP_CLIENT */
+static int TranslateIoError(int err)
+{
+    if (err > 0)
+        return err;
 
+    err = wolfSSL_LastError(err);
+#if SOCKET_EWOULDBLOCK != SOCKET_EAGAIN
+    if ((err == SOCKET_EWOULDBLOCK) || (err == SOCKET_EAGAIN))
+#else
+    if (err == SOCKET_EWOULDBLOCK)
+#endif
+    {
+        WOLFSSL_MSG("\tWould block");
+        return WOLFSSL_CBIO_ERR_WANT_READ;
+    }
+    else if (err == SOCKET_ECONNRESET) {
+        WOLFSSL_MSG("\tConnection reset");
+        return WOLFSSL_CBIO_ERR_CONN_RST;
+    }
+    else if (err == SOCKET_EINTR) {
+        WOLFSSL_MSG("\tSocket interrupted");
+        return WOLFSSL_CBIO_ERR_ISR;
+    }
+    else if (err == SOCKET_ECONNABORTED) {
+        WOLFSSL_MSG("\tConnection aborted");
+        return WOLFSSL_CBIO_ERR_CONN_CLOSE;
+    }
+
+    WOLFSSL_MSG("\tGeneral error");
+    return WOLFSSL_CBIO_ERR_GENERAL;
+}
+#endif /* USE_WOLFSSL_IO || HAVE_HTTP_CLIENT */
 
 #ifdef OPENSSL_EXTRA
 #ifndef NO_BIO
@@ -140,34 +170,14 @@ int BioReceive(WOLFSSL* ssl, char* buf, int sz, void* ctx)
             return WOLFSSL_CBIO_ERR_WANT_READ;
         }
         else if (ssl->biord->type == WOLFSSL_BIO_SOCKET) {
-            int err;
-
             if (recvd == 0) {
                 WOLFSSL_MSG("BioReceive connection closed");
                 return WOLFSSL_CBIO_ERR_CONN_CLOSE;
             }
-
+        #ifdef USE_WOLFSSL_IO
-            err = wolfSSL_LastError(recvd);
+            recvd = TranslateIoError(recvd);
-            if (err == SOCKET_EWOULDBLOCK || err == SOCKET_EAGAIN) {
+        #endif
-                WOLFSSL_MSG("\tWould block");
+            return recvd;
-                return WOLFSSL_CBIO_ERR_WANT_READ;
-            }
-            else if (err == SOCKET_ECONNRESET) {
-                WOLFSSL_MSG("\tConnection reset");
-                return WOLFSSL_CBIO_ERR_CONN_RST;
-            }
-            else if (err == SOCKET_EINTR) {
-                WOLFSSL_MSG("\tSocket interrupted");
-                return WOLFSSL_CBIO_ERR_ISR;
-            }
-            else if (err == SOCKET_ECONNABORTED) {
-                WOLFSSL_MSG("\tConnection aborted");
-                return WOLFSSL_CBIO_ERR_CONN_CLOSE;
-            }
-            else {
-                WOLFSSL_MSG("\tGeneral error");
-                return WOLFSSL_CBIO_ERR_GENERAL;
-            }
         }
 
         WOLFSSL_MSG("BIO general error");
@@ -203,27 +213,10 @@ int BioSend(WOLFSSL* ssl, char *buf, int sz, void *ctx)
     sent = wolfSSL_BIO_write(ssl->biowr, buf, sz);
     if (sent < 0) {
         if (ssl->biowr->type == WOLFSSL_BIO_SOCKET) {
-            int err = wolfSSL_LastError(sent);
+        #ifdef USE_WOLFSSL_IO
-            if (err == SOCKET_EWOULDBLOCK || err == SOCKET_EAGAIN) {
+            sent = TranslateIoError(sent);
-                WOLFSSL_MSG("\tWould Block");
+        #endif
-                return WOLFSSL_CBIO_ERR_WANT_WRITE;
+            return sent;
-            }
-            else if (err == SOCKET_ECONNRESET) {
-                WOLFSSL_MSG("\tConnection reset");
-                return WOLFSSL_CBIO_ERR_CONN_RST;
-            }
-            else if (err == SOCKET_EINTR) {
-                WOLFSSL_MSG("\tSocket interrupted");
-                return WOLFSSL_CBIO_ERR_ISR;
-            }
-            else if (err == SOCKET_EPIPE) {
-                WOLFSSL_MSG("\tSocket EPIPE");
-                return WOLFSSL_CBIO_ERR_CONN_CLOSE;
-            }
-            else {
-                WOLFSSL_MSG("\tGeneral error");
-                return WOLFSSL_CBIO_ERR_GENERAL;
-            }
         }
         return WOLFSSL_CBIO_ERR_GENERAL;
     }
@@ -251,34 +244,8 @@ int EmbedReceive(WOLFSSL *ssl, char *buf, int sz, void *ctx)
 
     recvd = wolfIO_Recv(sd, buf, sz, ssl->rflags);
     if (recvd < 0) {
-        int err = wolfSSL_LastError(recvd);
         WOLFSSL_MSG("Embed Receive error");
-
+        return TranslateIoError(recvd);
-#if SOCKET_EWOULDBLOCK != SOCKET_EAGAIN
-        if ((err == SOCKET_EWOULDBLOCK) || (err == SOCKET_EAGAIN))
-#else
-        if (err == SOCKET_EWOULDBLOCK)
-#endif
-        {
-            WOLFSSL_MSG("\tWould block");
-            return WOLFSSL_CBIO_ERR_WANT_READ;
-        }
-        else if (err == SOCKET_ECONNRESET) {
-            WOLFSSL_MSG("\tConnection reset");
-            return WOLFSSL_CBIO_ERR_CONN_RST;
-        }
-        else if (err == SOCKET_EINTR) {
-            WOLFSSL_MSG("\tSocket interrupted");
-            return WOLFSSL_CBIO_ERR_ISR;
-        }
-        else if (err == SOCKET_ECONNABORTED) {
-            WOLFSSL_MSG("\tConnection aborted");
-            return WOLFSSL_CBIO_ERR_CONN_CLOSE;
-        }
-        else {
-            WOLFSSL_MSG("\tGeneral error");
-            return WOLFSSL_CBIO_ERR_GENERAL;
-        }
     }
     else if (recvd == 0) {
         WOLFSSL_MSG("Embed receive connection closed");
@@ -307,34 +274,8 @@ int EmbedSend(WOLFSSL* ssl, char *buf, int sz, void *ctx)
 
     sent = wolfIO_Send(sd, buf, sz, ssl->wflags);
     if (sent < 0) {
-        int err = wolfSSL_LastError(sent);
         WOLFSSL_MSG("Embed Send error");
-
+        return TranslateIoError(sent);
-#if SOCKET_EWOULDBLOCK != SOCKET_EAGAIN
-        if ((err == SOCKET_EWOULDBLOCK) || (err == SOCKET_EAGAIN))
-#else
-        if (err == SOCKET_EWOULDBLOCK)
-#endif
-        {
-            WOLFSSL_MSG("\tWould Block");
-            return WOLFSSL_CBIO_ERR_WANT_WRITE;
-        }
-        else if (err == SOCKET_ECONNRESET) {
-            WOLFSSL_MSG("\tConnection reset");
-            return WOLFSSL_CBIO_ERR_CONN_RST;
-        }
-        else if (err == SOCKET_EINTR) {
-            WOLFSSL_MSG("\tSocket interrupted");
-            return WOLFSSL_CBIO_ERR_ISR;
-        }
-        else if (err == SOCKET_EPIPE) {
-            WOLFSSL_MSG("\tSocket EPIPE");
-            return WOLFSSL_CBIO_ERR_CONN_CLOSE;
-        }
-        else {
-            WOLFSSL_MSG("\tGeneral error");
-            return WOLFSSL_CBIO_ERR_GENERAL;
-        }
     }
 
     return sent;
@@ -356,7 +297,6 @@ int EmbedReceiveFrom(WOLFSSL *ssl, char *buf, int sz, void *ctx)
 {
     WOLFSSL_DTLS_CTX* dtlsCtx = (WOLFSSL_DTLS_CTX*)ctx;
     int recvd;
-    int err;
     int sd = dtlsCtx->rfd;
     int dtls_timeout = wolfSSL_dtls_get_current_timeout(ssl);
     SOCKADDR_S peer;
@@ -401,35 +341,13 @@ int EmbedReceiveFrom(WOLFSSL *ssl, char *buf, int sz, void *ctx)
     recvd = TranslateReturnCode(recvd, sd);
 
     if (recvd < 0) {
-        err = wolfSSL_LastError(recvd);
         WOLFSSL_MSG("Embed Receive From error");
-
+        recvd = TranslateIoError(recvd);
-        if (err == SOCKET_EWOULDBLOCK || err == SOCKET_EAGAIN) {
+        if (recvd == WOLFSSL_CBIO_ERR_WANT_READ && 
-            if (wolfSSL_dtls_get_using_nonblock(ssl)) {
+            !wolfSSL_dtls_get_using_nonblock(ssl)) {
-                WOLFSSL_MSG("\tWould block");
+            recvd = WOLFSSL_CBIO_ERR_TIMEOUT;
-                return WOLFSSL_CBIO_ERR_WANT_READ;
-            }
-            else {
-                WOLFSSL_MSG("\tSocket timeout");
-                return WOLFSSL_CBIO_ERR_TIMEOUT;
-            }
-        }
-        else if (err == SOCKET_ECONNRESET) {
-            WOLFSSL_MSG("\tConnection reset");
-            return WOLFSSL_CBIO_ERR_CONN_RST;
-        }
-        else if (err == SOCKET_EINTR) {
-            WOLFSSL_MSG("\tSocket interrupted");
-            return WOLFSSL_CBIO_ERR_ISR;
-        }
-        else if (err == SOCKET_ECONNREFUSED) {
-            WOLFSSL_MSG("\tConnection refused");
-            return WOLFSSL_CBIO_ERR_WANT_READ;
-        }
-        else {
-            WOLFSSL_MSG("\tGeneral error");
-            return WOLFSSL_CBIO_ERR_GENERAL;
         }
+        return recvd;
     }
     else {
         if (dtlsCtx->peer.sz > 0
@@ -455,7 +373,6 @@ int EmbedSendTo(WOLFSSL* ssl, char *buf, int sz, void *ctx)
     WOLFSSL_DTLS_CTX* dtlsCtx = (WOLFSSL_DTLS_CTX*)ctx;
     int sd = dtlsCtx->wfd;
     int sent;
-    int err;
 
     WOLFSSL_ENTER("EmbedSendTo()");
 
@@ -466,29 +383,8 @@ int EmbedSendTo(WOLFSSL* ssl, char *buf, int sz, void *ctx)
     sent = TranslateReturnCode(sent, sd);
 
     if (sent < 0) {
-        err = wolfSSL_LastError(sent);
         WOLFSSL_MSG("Embed Send To error");
-
+        return TranslateIoError(sent);
-        if (err == SOCKET_EWOULDBLOCK || err == SOCKET_EAGAIN) {
-            WOLFSSL_MSG("\tWould Block");
-            return WOLFSSL_CBIO_ERR_WANT_WRITE;
-        }
-        else if (err == SOCKET_ECONNRESET) {
-            WOLFSSL_MSG("\tConnection reset");
-            return WOLFSSL_CBIO_ERR_CONN_RST;
-        }
-        else if (err == SOCKET_EINTR) {
-            WOLFSSL_MSG("\tSocket interrupted");
-            return WOLFSSL_CBIO_ERR_ISR;
-        }
-        else if (err == SOCKET_EPIPE) {
-            WOLFSSL_MSG("\tSocket EPIPE");
-            return WOLFSSL_CBIO_ERR_CONN_CLOSE;
-        }
-        else {
-            WOLFSSL_MSG("\tGeneral error");
-            return WOLFSSL_CBIO_ERR_GENERAL;
-        }
     }
 
     return sent;
@@ -504,7 +400,6 @@ int EmbedReceiveFromMcast(WOLFSSL *ssl, char *buf, int sz, void *ctx)
 {
     WOLFSSL_DTLS_CTX* dtlsCtx = (WOLFSSL_DTLS_CTX*)ctx;
     int recvd;
-    int err;
     int sd = dtlsCtx->rfd;
 
     WOLFSSL_ENTER("EmbedReceiveFromMcast()");
@@ -514,35 +409,13 @@ int EmbedReceiveFromMcast(WOLFSSL *ssl, char *buf, int sz, void *ctx)
     recvd = TranslateReturnCode(recvd, sd);
 
     if (recvd < 0) {
-        err = wolfSSL_LastError(recvd);
         WOLFSSL_MSG("Embed Receive From error");
-
+        recvd = TranslateIoError(recvd);
-        if (err == SOCKET_EWOULDBLOCK || err == SOCKET_EAGAIN) {
+        if (recvd == WOLFSSL_CBIO_ERR_WANT_READ && 
-            if (wolfSSL_dtls_get_using_nonblock(ssl)) {
+            !wolfSSL_dtls_get_using_nonblock(ssl)) {
-                WOLFSSL_MSG("\tWould block");
+            recvd = WOLFSSL_CBIO_ERR_TIMEOUT;
-                return WOLFSSL_CBIO_ERR_WANT_READ;
-            }
-            else {
-                WOLFSSL_MSG("\tSocket timeout");
-                return WOLFSSL_CBIO_ERR_TIMEOUT;
-            }
-        }
-        else if (err == SOCKET_ECONNRESET) {
-            WOLFSSL_MSG("\tConnection reset");
-            return WOLFSSL_CBIO_ERR_CONN_RST;
-        }
-        else if (err == SOCKET_EINTR) {
-            WOLFSSL_MSG("\tSocket interrupted");
-            return WOLFSSL_CBIO_ERR_ISR;
-        }
-        else if (err == SOCKET_ECONNREFUSED) {
-            WOLFSSL_MSG("\tConnection refused");
-            return WOLFSSL_CBIO_ERR_WANT_READ;
-        }
-        else {
-            WOLFSSL_MSG("\tGeneral error");
-            return WOLFSSL_CBIO_ERR_GENERAL;
         }
+        return recvd;
     }
 
     return recvd;

tests/api.c

@@ -29715,7 +29715,7 @@ static void test_wolfSSL_DTLS_either_side(void)
 
 static void test_generate_cookie(void)
 {
-#if defined(WOLFSSL_DTLS) && defined(OPENSSL_EXTRA)
+#if defined(WOLFSSL_DTLS) && defined(OPENSSL_EXTRA) && defined(USE_WOLFSSL_IO)
     SSL_CTX* ctx;
     SSL* ssl;
     byte    buf[FOURK_BUF] = {0};
@@ -32680,7 +32680,7 @@ static void test_wolfSSL_BIO_puts(void)
 
 #if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_CERTS) && \
     !defined(NO_RSA) && defined(HAVE_EXT_CACHE) && \
-    defined(HAVE_IO_TESTS_DEPENDENCIES)
+    defined(HAVE_IO_TESTS_DEPENDENCIES) && defined(USE_WOLFSSL_IO)
 static int forceWantRead(WOLFSSL *ssl, char *buf, int sz, void *ctx)
 {
     (void)ssl;
@@ -32695,7 +32695,7 @@ static void test_wolfSSL_BIO_should_retry(void)
 {
 #if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_CERTS) && \
     !defined(NO_RSA) && defined(HAVE_EXT_CACHE) && \
-    defined(HAVE_IO_TESTS_DEPENDENCIES)
+    defined(HAVE_IO_TESTS_DEPENDENCIES) && defined(USE_WOLFSSL_IO)
     tcp_ready ready;
     func_args server_args;
     THREAD_TYPE serverThread;
@@ -32779,7 +32779,7 @@ static void test_wolfSSL_BIO_should_retry(void)
 
 static void test_wolfSSL_BIO_connect(void)
 {
-#if defined(OPENSSL_ALL) && defined(HAVE_IO_TESTS_DEPENDENCIES)
+#if defined(OPENSSL_ALL) && defined(HAVE_IO_TESTS_DEPENDENCIES) && defined(HAVE_HTTP_CLIENT)
     tcp_ready ready;
     func_args server_args;
     THREAD_TYPE serverThread;
@@ -35823,7 +35823,7 @@ static void test_wolfSSL_EC_KEY_dup(void)
 
 static void test_wolfSSL_EVP_PKEY_set1_get1_DSA(void)
 {
-#if !defined(NO_DSA)
+#if !defined (NO_DSA) && !defined(HAVE_SELFTEST) && defined(WOLFSSL_KEY_GEN)
     DSA       *dsa  = NULL;
     DSA       *setDsa  = NULL;
     EVP_PKEY  *pkey = NULL;
@@ -35909,7 +35909,7 @@ static void test_wolfSSL_EVP_PKEY_set1_get1_DSA(void)
     DSA_free(setDsa);
     EVP_PKEY_free(pkey);
     EVP_PKEY_free(set1Pkey);
-#endif /* NO_DSA */
+#endif /* !NO_DSA && !HAVE_SELFTEST && WOLFSSL_KEY_GEN */
 } /* END test_EVP_PKEY_set1_get1_DSA */
 
 static void test_wolfSSL_EVP_PKEY_set1_get1_EC_KEY (void)

wolfssl/test.h

@@ -12,10 +12,14 @@
 #endif
 #include <assert.h>
 #include <ctype.h>
+#ifdef HAVE_ERRNO_H
+    #include <errno.h>
+#endif
 #include <wolfssl/wolfcrypt/types.h>
 #include <wolfssl/wolfcrypt/error-crypt.h>
 #include <wolfssl/wolfcrypt/random.h>
 #include <wolfssl/wolfcrypt/mem_track.h>
+#include <wolfssl/wolfio.h>
 #if defined(SHOW_CERTS) && \
     (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL))
     #include <wolfssl/wolfcrypt/asn.h> /* for domain component NID value */
@@ -3895,6 +3899,7 @@ static WC_INLINE void SetupPkCallbackContexts(WOLFSSL* ssl, void* myCtx)
 
 #endif /* HAVE_PK_CALLBACKS */
 
+#ifdef USE_WOLFSSL_IO
 static WC_INLINE int SimulateWantWriteIOSendCb(WOLFSSL *ssl, char *buf, int sz, void *ctx)
 {
     static int wantWriteFlag = 1;
@@ -3937,6 +3942,7 @@ static WC_INLINE int SimulateWantWriteIOSendCb(WOLFSSL *ssl, char *buf, int sz,
         return WOLFSSL_CBIO_ERR_WANT_WRITE;
     }
 }
+#endif /* USE_WOLFSSL_IO */
 
 #if defined(__hpux__) || defined(__MINGW32__) || defined (WOLFSSL_TIRTOS) \
                       || defined(_MSC_VER)