diff --git a/src/bio.c b/src/bio.c
index 18d0baa33..9129e2f0b 100644
--- a/src/bio.c
+++ b/src/bio.c
@@ -139,11 +139,11 @@ static int wolfSSL_BIO_SSL_read(WOLFSSL_BIO* bio, void* buf,
     if ((front == NULL) || front->eof)
         return WOLFSSL_FATAL_ERROR;
 
-    ret = wolfSSL_read(bio->ssl, buf, len);
+    ret = wolfSSL_read((WOLFSSL*)bio->ptr, buf, len);
     if (ret == 0)
         front->eof = 1;
     else if (ret < 0) {
-        int err = wolfSSL_get_error(bio->ssl, 0);
+        int err = wolfSSL_get_error((WOLFSSL*)bio->ptr, 0);
         if ( !(err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) )
             front->eof = 1;
     }
@@ -205,7 +205,7 @@ int wolfSSL_BIO_read(WOLFSSL_BIO* bio, void* buf, int len)
 
     #ifndef NO_FILESYSTEM
         if (bio && bio->type == WOLFSSL_BIO_FILE) {
-            ret = (int)XFREAD(buf, 1, len, bio->file);
+            ret = (int)XFREAD(buf, 1, len, (XFILE)bio->ptr);
         }
     #endif
 
@@ -303,13 +303,15 @@ static int wolfSSL_BIO_SSL_write(WOLFSSL_BIO* bio, const void* data,
 
     WOLFSSL_ENTER("wolfSSL_BIO_SSL_write");
 
-    if (bio->ssl == 0) return BAD_FUNC_ARG;
+    if (bio->ptr == NULL) {
+        return BAD_FUNC_ARG;
+    }
 
-    ret = wolfSSL_write(bio->ssl, data, len);
+    ret = wolfSSL_write((WOLFSSL*)bio->ptr, data, len);
     if (ret == 0)
         front->eof = 1;
     else if (ret < 0) {
-        int err = wolfSSL_get_error(bio->ssl, 0);
+        int err = wolfSSL_get_error((WOLFSSL*)bio->ptr, 0);
         if ( !(err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) )
             front->eof = 1;
     }
@@ -510,7 +512,7 @@ int wolfSSL_BIO_write(WOLFSSL_BIO* bio, const void* data, int len)
 
     #ifndef NO_FILESYSTEM
         if (bio && bio->type == WOLFSSL_BIO_FILE) {
-            ret = (int)XFWRITE(data, 1, len, bio->file);
+            ret = (int)XFWRITE(data, 1, len, (XFILE)bio->ptr);
         }
     #endif
 
@@ -643,15 +645,15 @@ int wolfSSL_BIO_gets(WOLFSSL_BIO* bio, char* buf, int sz)
     switch (bio->type) {
 #ifndef NO_FILESYSTEM
         case WOLFSSL_BIO_FILE:
-            if (bio->file == XBADFILE) {
+            if (((XFILE)bio->ptr) == XBADFILE) {
                 return WOLFSSL_BIO_ERROR;
             }
 
             #if defined(MICRIUM) || defined(LSR_FS) || defined(EBSNET)
             WOLFSSL_MSG("XFGETS not ported for this system yet");
-            ret = XFGETS(buf, sz, bio->file);
+            ret = XFGETS(buf, sz, (XFILE)bio->ptr);
             #else
-            if (XFGETS(buf, sz, bio->file) != NULL) {
+            if (XFGETS(buf, sz, (XFILE)bio->ptr) != NULL) {
                 ret = (int)XSTRLEN(buf);
             }
             else {
@@ -818,11 +820,6 @@ size_t wolfSSL_BIO_wpending(const WOLFSSL_BIO *bio)
     if (bio == NULL)
         return 0;
 
-    if (bio->ssl != NULL) {
-        /* not supported case */
-        return 0;
-    }
-
     if (bio->type == WOLFSSL_BIO_MEMORY) {
         return bio->wrSz;
     }
@@ -844,8 +841,8 @@ size_t wolfSSL_BIO_ctrl_pending(WOLFSSL_BIO *bio)
         return 0;
     }
 
-    if (bio->ssl != NULL) {
-        return (long)wolfSSL_pending(bio->ssl);
+    if (bio->type == WOLFSSL_BIO_SSL && bio->ptr != NULL) {
+        return (long)wolfSSL_pending((WOLFSSL*)bio->ptr);
     }
 
     if (bio->type == WOLFSSL_BIO_MEMORY) {
@@ -878,8 +875,8 @@ long wolfSSL_BIO_get_mem_ptr(WOLFSSL_BIO *bio, WOLFSSL_BUF_MEM **ptr)
         return WOLFSSL_FAILURE;
     }
 
-    if (bio->type == WOLFSSL_BIO_FILE || bio->type == WOLFSSL_BIO_SOCKET) {
-        WOLFSSL_MSG("NO memory buffer for FILE type");
+    if (bio->type != WOLFSSL_BIO_MEMORY) {
+        WOLFSSL_MSG("BIO is not memory buffer type");
         return SSL_FAILURE;
     }
 
@@ -1157,7 +1154,7 @@ int wolfSSL_BIO_reset(WOLFSSL_BIO *bio)
     switch (bio->type) {
         #ifndef NO_FILESYSTEM
         case WOLFSSL_BIO_FILE:
-            XREWIND(bio->file);
+            XREWIND((XFILE)bio->ptr);
             return 0;
         #endif
 
@@ -1201,7 +1198,7 @@ long wolfSSL_BIO_set_fp(WOLFSSL_BIO *bio, XFILE fp, int c)
     }
 
     bio->shutdown = (byte)c;
-    bio->file  = fp;
+    bio->ptr = (XFILE)fp;
 
     return WOLFSSL_SUCCESS;
 }
@@ -1219,7 +1216,7 @@ long wolfSSL_BIO_get_fp(WOLFSSL_BIO *bio, XFILE* fp)
         return SSL_FAILURE;
     }
 
-    *fp = bio->file;
+    *fp = (XFILE)bio->ptr;
 
     return WOLFSSL_SUCCESS;
 }
@@ -1234,12 +1231,12 @@ int wolfSSL_BIO_write_filename(WOLFSSL_BIO *bio, char *name)
     }
 
     if (bio->type == WOLFSSL_BIO_FILE) {
-        if (bio->file != XBADFILE && bio->shutdown == BIO_CLOSE) {
-            XFCLOSE(bio->file);
+        if (((XFILE)bio->ptr) != XBADFILE && bio->shutdown == BIO_CLOSE) {
+            XFCLOSE((XFILE)bio->ptr);
         }
 
-        bio->file = XFOPEN(name, "w");
-        if (bio->file == XBADFILE) {
+        bio->ptr = XFOPEN(name, "w");
+        if (((XFILE)bio->ptr) == XBADFILE) {
             return WOLFSSL_FAILURE;
         }
         bio->shutdown = BIO_CLOSE;
@@ -1261,7 +1258,7 @@ int wolfSSL_BIO_seek(WOLFSSL_BIO *bio, int ofs)
 
       /* offset ofs from beginning of file */
       if (bio->type == WOLFSSL_BIO_FILE &&
-              XFSEEK(bio->file, ofs, SEEK_SET) < 0) {
+              XFSEEK((XFILE)bio->ptr, ofs, SEEK_SET) < 0) {
           return -1;
       }
 
@@ -1372,7 +1369,7 @@ long wolfSSL_BIO_set_nbio(WOLFSSL_BIO* bio, long on)
             break;
         case WOLFSSL_BIO_SSL:
         #ifdef WOLFSSL_DTLS
-            wolfSSL_dtls_set_using_nonblock(bio->ssl, (int)on);
+            wolfSSL_dtls_set_using_nonblock((WOLFSSL*)bio->ptr, (int)on);
         #endif
             break;
 
diff --git a/src/ocsp.c b/src/ocsp.c
index a71652347..de9d6dce0 100644
--- a/src/ocsp.c
+++ b/src/ocsp.c
@@ -665,15 +665,18 @@ OcspResponse* wolfSSL_d2i_OCSP_RESPONSE_bio(WOLFSSL_BIO* bio,
         long i;
         long l;
 
-        i = XFTELL(bio->file);
+        if (bio->ptr == NULL)
+            return NULL;
+
+        i = XFTELL((XFILE)bio->ptr);
         if (i < 0)
             return NULL;
-        if(XFSEEK(bio->file, 0, SEEK_END) != 0)
+        if(XFSEEK((XFILE)bio->ptr, 0, SEEK_END) != 0)
             return NULL;
-        l = XFTELL(bio->file);
+        l = XFTELL((XFILE)bio->ptr);
         if (l < 0)
             return NULL;
-        if (XFSEEK(bio->file, i, SEEK_SET) != 0)
+        if (XFSEEK((XFILE)bio->ptr, i, SEEK_SET) != 0)
             return NULL;
 
         /* check calculated length */
diff --git a/src/ssl.c b/src/ssl.c
index 089325ff8..dced558c7 100644
--- a/src/ssl.c
+++ b/src/ssl.c
@@ -7050,7 +7050,7 @@ WOLFSSL_PKCS8_PRIV_KEY_INFO* wolfSSL_d2i_PKCS8_PKEY_bio(WOLFSSL_BIO* bio,
 {
     WOLFSSL_PKCS8_PRIV_KEY_INFO* pkcs8 = NULL;
 #ifdef WOLFSSL_PEM_TO_DER
-    unsigned char* mem;
+    unsigned char* mem = NULL;
     int memSz;
     int keySz;
     word32 algId;
@@ -14041,7 +14041,7 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
         WOLFSSL_ENTER("wolfSSL_BIO_set_ssl");
 
         if (b != NULL) {
-            b->ssl   = ssl;
+            b->ptr   = ssl;
             b->shutdown = (byte)closeF;
     /* add to ssl for bio free if SSL_free called before/instead of free_all? */
         }
@@ -14050,12 +14050,12 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
     }
 
 #ifndef NO_FILESYSTEM
-    long wolfSSL_BIO_set_fd(WOLFSSL_BIO* b, XFILE fd, int closeF)
+    long wolfSSL_BIO_set_fd(WOLFSSL_BIO* b, int fd, int closeF)
     {
         WOLFSSL_ENTER("wolfSSL_BIO_set_fd");
 
         if (b != NULL) {
-            b->file = fd;
+            b->num = fd;
             b->shutdown = (byte)closeF;
         }
 
@@ -14102,6 +14102,7 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
     }
 
 
+    /* this compatibility function can be used for multiple BIO types */
     int wolfSSL_BIO_get_mem_data(WOLFSSL_BIO* bio, void* p)
     {
         WOLFSSL_ENTER("wolfSSL_BIO_get_mem_data");
@@ -14178,8 +14179,8 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
             }
 
             if (bio->shutdown) {
-                if (bio->ssl)
-                    wolfSSL_free(bio->ssl);
+                if (bio->type == WOLFSSL_BIO_SSL && bio->ptr)
+                    wolfSSL_free((WOLFSSL*)bio->ptr);
             #ifdef CloseSocket
                 if (bio->type == WOLFSSL_BIO_SOCKET && bio->num)
                     CloseSocket(bio->num);
@@ -14188,14 +14189,14 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
 
         #ifndef NO_FILESYSTEM
             if (bio->type == WOLFSSL_BIO_FILE && bio->shutdown == BIO_CLOSE) {
-                if (bio->file) {
-                    XFCLOSE(bio->file);
+                if (bio->ptr) {
+                    XFCLOSE((XFILE)bio->ptr);
                 }
             }
         #endif
 
             if (bio->shutdown != BIO_NOCLOSE) {
-                if (bio->ptr != NULL) {
+                if (bio->type == WOLFSSL_BIO_MEMORY && bio->ptr != NULL) {
                     if (bio->mem_buf != NULL) {
                         if (bio->mem_buf->data != (char*)bio->ptr) {
                             XFREE(bio->ptr, bio->heap, DYNAMIC_TYPE_OPENSSL);
@@ -19160,10 +19161,11 @@ const char*  wolfSSL_CIPHER_get_version(const WOLFSSL_CIPHER* cipher)
     return wolfSSL_get_version(cipher->ssl);
 }
 
+#ifndef NO_WOLFSSL_STUB
 char* wolfSSL_CIPHER_get_rfc_name(const WOLFSSL_CIPHER* cipher)
 {
     char* rfcName = NULL;
-    WOLFSSL_ENTER("SSL_CIPHER_get_rfc_name");
+    WOLFSSL_STUB("SSL_CIPHER_get_rfc_name");
 
     if (cipher == NULL || cipher->ssl == NULL) {
         return NULL;
@@ -19171,6 +19173,7 @@ char* wolfSSL_CIPHER_get_rfc_name(const WOLFSSL_CIPHER* cipher)
 
     return rfcName;
 }
+#endif
 
 const char* wolfSSL_SESSION_CIPHER_get_name(WOLFSSL_SESSION* session)
 {
@@ -25626,7 +25629,9 @@ int wolfSSL_BIO_printf(WOLFSSL_BIO* bio, const char* format, ...)
     va_start(args, format);
     switch (bio->type) {
         case WOLFSSL_BIO_FILE:
-            ret = vfprintf(bio->file, format, args);
+            if (bio->ptr == NULL)
+                return -1;
+            ret = vfprintf((XFILE)bio->ptr, format, args);
             break;
 
         case WOLFSSL_BIO_MEMORY:
@@ -25674,7 +25679,7 @@ int wolfSSL_BIO_dump(WOLFSSL_BIO *bio, const char *buf, int length)
         char line[80];
 
         if (!buf) {
-            return fputs("\tNULL", bio->file);
+            return fputs("\tNULL", (XFILE)bio->ptr);
         }
 
         sprintf(line, "\t");
@@ -25691,7 +25696,7 @@ int wolfSSL_BIO_dump(WOLFSSL_BIO *bio, const char *buf, int length)
                      "%c", 31 < buf[i] && buf[i] < 127 ? buf[i] : '.');
             }
         }
-        ret += fputs(line, bio->file);
+        ret += fputs(line, (XFILE)bio->ptr);
 
         if (length > LINE_LEN)
             ret += wolfSSL_BIO_dump(bio, buf + LINE_LEN, length - LINE_LEN);
@@ -35928,15 +35933,15 @@ void* wolfSSL_GetDhAgreeCtx(WOLFSSL* ssl)
         else if (bp->type == WOLFSSL_BIO_FILE) {
 #ifndef NO_FILESYSTEM
             /* Read in next certificate from file but no more. */
-            i = XFTELL(bp->file);
+            i = XFTELL((XFILE)bp->ptr);
             if (i < 0)
                 return NULL;
-            if (XFSEEK(bp->file, 0, XSEEK_END) != 0)
+            if (XFSEEK((XFILE)bp->ptr, 0, XSEEK_END) != 0)
                 return NULL;
-            l = XFTELL(bp->file);
+            l = XFTELL((XFILE)bp->ptr);
             if (l < 0)
                 return NULL;
-            if (XFSEEK(bp->file, i, SEEK_SET) != 0)
+            if (XFSEEK((XFILE)bp->ptr, i, SEEK_SET) != 0)
                 return NULL;
 
             /* check calculated length */
@@ -38847,10 +38852,10 @@ WOLFSSL_DH *wolfSSL_PEM_read_bio_DHparams(WOLFSSL_BIO *bio, WOLFSSL_DH **x,
     }
     else if (bio->type == WOLFSSL_BIO_FILE) {
         /* Read whole file into a new buffer. */
-        if(XFSEEK(bio->file, 0, SEEK_END) != 0)
+        if(XFSEEK((XFILE)bio->ptr, 0, SEEK_END) != 0)
             goto end;
-        sz = XFTELL(bio->file);
-        if(XFSEEK(bio->file, 0, SEEK_SET) != 0)
+        sz = XFTELL((XFILE)bio->ptr);
+        if(XFSEEK((XFILE)bio->ptr, 0, SEEK_SET) != 0)
             goto end;
         if (sz <= 0L)
             goto end;
diff --git a/wolfssl/ssl.h b/wolfssl/ssl.h
index 9578023ea..73bd00c38 100644
--- a/wolfssl/ssl.h
+++ b/wolfssl/ssl.h
@@ -457,15 +457,11 @@ typedef long (*wolf_bio_info_cb)(WOLFSSL_BIO *bio, int event, const char *parg,
 struct WOLFSSL_BIO {
     WOLFSSL_BUF_MEM* mem_buf;
     WOLFSSL_BIO_METHOD* method;
-    WOLFSSL*     ssl;           /* possible associated ssl */
-#ifndef NO_FILESYSTEM
-    XFILE        file;          /* file descriptor */
-#endif
     WOLFSSL_BIO* prev;          /* previous in chain */
     WOLFSSL_BIO* next;          /* next in chain */
     WOLFSSL_BIO* pair;          /* BIO paired with */
     void*        heap;          /* user heap hint */
-    void*        ptr;           /* memory buffer */
+    void*        ptr;           /* WOLFSSL, file descriptor or memory buffer */
     void*        usrCtx;        /* user set pointer */
     char*        infoArg;       /* BIO callback argument */
     wolf_bio_info_cb infoCb;    /* BIO callback */
@@ -473,7 +469,7 @@ struct WOLFSSL_BIO {
     int          wrIdx;         /* current index for write buffer */
     int          rdIdx;         /* current read index */
     int          readRq;        /* read request */
-    int          num;           /* length */
+    int          num;           /* socket num or length */
     int          eof;           /* eof flag */
     int          flags;
     byte         type;          /* method type */
@@ -1172,7 +1168,7 @@ WOLFSSL_API WOLFSSL_BIO* wolfSSL_BIO_new_mem_buf(void* buf, int len);
 
 WOLFSSL_API long wolfSSL_BIO_set_ssl(WOLFSSL_BIO*, WOLFSSL*, int flag);
 #ifndef NO_FILESYSTEM
-WOLFSSL_API long wolfSSL_BIO_set_fd(WOLFSSL_BIO* b, XFILE fd, int flag);
+WOLFSSL_API long wolfSSL_BIO_set_fd(WOLFSSL_BIO* b, int fd, int flag);
 #endif
 WOLFSSL_API void wolfSSL_set_bio(WOLFSSL*, WOLFSSL_BIO* rd, WOLFSSL_BIO* wr);