wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-07-29 18:27:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #7760 from douzzer/20240718-BIO_DGRAM-memory-leak

Browse Source 
20240718-BIO_DGRAM-memory-leak
This commit is contained in:
David Garske
2024-07-19 14:24:30 -07:00
committed by GitHub
parent 16a2d2e71d 787397b28e
commit 4d8a6b84fb
7 changed files with 183 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
src/bio.c
View File

@ -161,7 +161,7 @@ static int wolfSSL_BIO_MEMORY_read(WOLFSSL_BIO* bio, void* buf, int len)
bio->wrSz = 0;
bio->mem_buf->length = 0;
}
bio->ptr = bio->mem_buf->data;
bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
}
else if (bio->rdIdx >= WOLFSSL_BIO_RESIZE_THRESHOLD &&
!(bio->flags & BIO_FLAGS_MEM_RDONLY)) {
@ -180,7 +180,7 @@ static int wolfSSL_BIO_MEMORY_read(WOLFSSL_BIO* bio, void* buf, int len)
return WOLFSSL_BIO_ERROR;
}
bio->mem_buf->length = (size_t)bio->wrSz;
bio->ptr = bio->mem_buf->data;
bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
}
}
else {
@ -217,11 +217,11 @@ static int wolfSSL_BIO_SSL_read(WOLFSSL_BIO* bio, void* buf,
return WOLFSSL_FATAL_ERROR;
bio->flags &= ~(WOLFSSL_BIO_FLAG_RETRY); /* default no retry */
ret = wolfSSL_read((WOLFSSL*)bio->ptr, buf, len);
ret = wolfSSL_read(bio->ptr.ssl, buf, len);
if (ret == 0)
front->eof = 1;
else if (ret < 0) {
int err = wolfSSL_get_error((WOLFSSL*)bio->ptr, 0);
int err = wolfSSL_get_error(bio->ptr.ssl, 0);
if ( !(err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE) ) {
front->eof = 1;
}
@ -235,15 +235,15 @@ static int wolfSSL_BIO_SSL_read(WOLFSSL_BIO* bio, void* buf,
static int wolfSSL_BIO_MD_read(WOLFSSL_BIO* bio, void* buf, int sz)
{
if (wolfSSL_EVP_MD_CTX_type((WOLFSSL_EVP_MD_CTX*)bio->ptr) == NID_hmac) {
if (wolfSSL_EVP_DigestSignUpdate((WOLFSSL_EVP_MD_CTX*)bio->ptr, buf,
if (wolfSSL_EVP_MD_CTX_type(bio->ptr.md_ctx) == NID_hmac) {
if (wolfSSL_EVP_DigestSignUpdate(bio->ptr.md_ctx, buf,
(unsigned int)sz) != WOLFSSL_SUCCESS)
{
return WOLFSSL_FATAL_ERROR;
}
}
else {
if (wolfSSL_EVP_DigestUpdate((WOLFSSL_EVP_MD_CTX*)bio->ptr, buf, (size_t)sz)
if (wolfSSL_EVP_DigestUpdate(bio->ptr.md_ctx, buf, (size_t)sz)
!= WOLFSSL_SUCCESS) {
return WOLFSSL_FATAL_ERROR;
}
@ -314,13 +314,13 @@ int wolfSSL_BIO_read(WOLFSSL_BIO* bio, void* buf, int len)
break;
case WOLFSSL_BIO_FILE:
#ifndef NO_FILESYSTEM
if (bio->ptr) {
ret = (int)XFREAD(buf, 1, (size_t)len, (XFILE)bio->ptr);
if (bio->ptr.fh) {
ret = (int)XFREAD(buf, 1, (size_t)len, bio->ptr.fh);
}
else {
#if defined(XREAD) && !defined(NO_WOLFSSL_DIR) && \
!defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)
ret = (int)XREAD(bio->num, buf, (size_t)len);
ret = (int)XREAD(bio->num.fd, buf, (size_t)len);
#else
WOLFSSL_MSG("No file pointer and XREAD not enabled");
ret = NOT_COMPILED_IN;
@ -352,7 +352,7 @@ int wolfSSL_BIO_read(WOLFSSL_BIO* bio, void* buf, int len)
/* BIO requires built-in socket support
* (cannot be used with WOLFSSL_USER_IO) */
bio->flags &= ~WOLFSSL_BIO_FLAG_RETRY;
ret = wolfIO_Recv(bio->num, (char*)buf, len, 0);
ret = wolfIO_Recv(bio->num.fd, (char*)buf, len, 0);
if (ret == WOLFSSL_CBIO_ERR_WANT_READ) {
bio->flags |= WOLFSSL_BIO_FLAG_RETRY;
}
@ -371,10 +371,11 @@ int wolfSSL_BIO_read(WOLFSSL_BIO* bio, void* buf, int len)
* (cannot be used with WOLFSSL_USER_IO) */
bio->flags &= ~WOLFSSL_BIO_FLAG_RETRY;
if (bio->connected)
ret = wolfIO_Recv(bio->num, (char*)buf, len, 0);
ret = wolfIO_Recv(bio->num.fd, (char*)buf, len, 0);
else {
wolfSSL_BIO_ADDR_clear(&bio->peer_addr);
ret = wolfIO_RecvFrom(bio->num, &bio->peer_addr, (char*)buf, len, 0);
ret = wolfIO_RecvFrom(bio->num.fd, &bio->peer_addr,
(char*)buf, len, 0);
}
if (ret == WOLFSSL_CBIO_ERR_WANT_READ) {
bio->flags |= WOLFSSL_BIO_FLAG_RETRY;
@ -511,16 +512,16 @@ static int wolfSSL_BIO_SSL_write(WOLFSSL_BIO* bio, const void* data,
WOLFSSL_ENTER("wolfSSL_BIO_SSL_write");
if (bio->ptr == NULL) {
if (bio->ptr.ssl == NULL) {
return BAD_FUNC_ARG;
}
bio->flags &= ~(WOLFSSL_BIO_FLAG_RETRY); /* default no retry */
ret = wolfSSL_write((WOLFSSL*)bio->ptr, data, len);
ret = wolfSSL_write(bio->ptr.ssl, data, len);
if (ret == 0)
front->eof = 1;
else if (ret < 0) {
int err = wolfSSL_get_error((WOLFSSL*)bio->ptr, 0);
int err = wolfSSL_get_error(bio->ptr.ssl, 0);
if ( !(err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE) ) {
front->eof = 1;
}
@ -619,8 +620,8 @@ static int wolfSSL_BIO_MEMORY_write(WOLFSSL_BIO* bio, const void* data,
}
XMEMCPY(bio->mem_buf->data + bio->wrSz, data, len);
bio->ptr = bio->mem_buf->data;
bio->num = (int)bio->mem_buf->max;
bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
bio->num.length = bio->mem_buf->max;
bio->wrSz += len;
bio->wrIdx += len;
@ -641,14 +642,14 @@ static int wolfSSL_BIO_MD_write(WOLFSSL_BIO* bio, const void* data, int len)
return BAD_FUNC_ARG;
}
if (wolfSSL_EVP_MD_CTX_type((WOLFSSL_EVP_MD_CTX*)bio->ptr) == NID_hmac) {
if (wolfSSL_EVP_DigestSignUpdate((WOLFSSL_EVP_MD_CTX*)bio->ptr, data,
if (wolfSSL_EVP_MD_CTX_type(bio->ptr.md_ctx) == NID_hmac) {
if (wolfSSL_EVP_DigestSignUpdate(bio->ptr.md_ctx, data,
(unsigned int)len) != WOLFSSL_SUCCESS) {
ret = WOLFSSL_BIO_ERROR;
}
}
else {
if (wolfSSL_EVP_DigestUpdate((WOLFSSL_EVP_MD_CTX*)bio->ptr, data, (size_t)len)
if (wolfSSL_EVP_DigestUpdate(bio->ptr.md_ctx, data, (size_t)len)
!= WOLFSSL_SUCCESS) {
ret = WOLFSSL_BIO_ERROR;
}
@ -727,13 +728,13 @@ int wolfSSL_BIO_write(WOLFSSL_BIO* bio, const void* data, int len)
break;
case WOLFSSL_BIO_FILE:
#ifndef NO_FILESYSTEM
if (bio->ptr) {
ret = (int)XFWRITE(data, 1, (size_t)len, (XFILE)bio->ptr);
if (bio->ptr.fh) {
ret = (int)XFWRITE(data, 1, (size_t)len, bio->ptr.fh);
}
else {
#if defined(XWRITE) && !defined(NO_WOLFSSL_DIR) && \
!defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)
ret = (int)XWRITE(bio->num, data, (size_t)len);
ret = (int)XWRITE(bio->num.fd, data, (size_t)len);
#else
WOLFSSL_MSG("No file pointer and XWRITE not enabled");
ret = NOT_COMPILED_IN;
@ -775,7 +776,7 @@ int wolfSSL_BIO_write(WOLFSSL_BIO* bio, const void* data, int len)
/* BIO requires built-in socket support
* (cannot be used with WOLFSSL_USER_IO) */
bio->flags &= ~WOLFSSL_BIO_FLAG_RETRY;
ret = wolfIO_Send(bio->num, (char*)data, len, 0);
ret = wolfIO_Send(bio->num.fd, (char*)data, len, 0);
if (ret == WOLFSSL_CBIO_ERR_WANT_WRITE) {
bio->flags |= WOLFSSL_BIO_FLAG_RETRY;
}
@ -794,11 +795,11 @@ int wolfSSL_BIO_write(WOLFSSL_BIO* bio, const void* data, int len)
* (cannot be used with WOLFSSL_USER_IO) */
bio->flags &= ~WOLFSSL_BIO_FLAG_RETRY;
if (bio->connected)
ret = wolfIO_Send(bio->num, (char*)data, len, 0);
ret = wolfIO_Send(bio->num.fd, (char*)data, len, 0);
else if (bio->peer_addr.sa.sa_family == AF_UNSPEC)
ret = SOCKET_ERROR_E;
else
ret = wolfIO_SendTo(bio->num, &bio->peer_addr, (char*)data, len, 0);
ret = wolfIO_SendTo(bio->num.fd, &bio->peer_addr, (char*)data, len, 0);
if (ret == WOLFSSL_CBIO_ERR_WANT_WRITE) {
bio->flags |= WOLFSSL_BIO_FLAG_RETRY;
}
@ -1059,15 +1060,15 @@ int wolfSSL_BIO_gets(WOLFSSL_BIO* bio, char* buf, int sz)
switch (bio->type) {
#ifndef NO_FILESYSTEM
case WOLFSSL_BIO_FILE:
if (((XFILE)bio->ptr) == XBADFILE) {
if (bio->ptr.fh == 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, (XFILE)bio->ptr);
ret = XFGETS(buf, sz, bio->ptr.fh);
#else
if (XFGETS(buf, sz, (XFILE)bio->ptr) != NULL) {
if (XFGETS(buf, sz, bio->ptr.fh) != NULL) {
ret = (int)XSTRLEN(buf);
}
else {
@ -1143,13 +1144,13 @@ int wolfSSL_BIO_gets(WOLFSSL_BIO* bio, char* buf, int sz)
#ifndef WOLFCRYPT_ONLY
/* call final on hash */
case WOLFSSL_BIO_MD:
if (wolfSSL_EVP_MD_CTX_size((WOLFSSL_EVP_MD_CTX*)bio->ptr) > sz) {
if (wolfSSL_EVP_MD_CTX_size(bio->ptr.md_ctx) > sz) {
WOLFSSL_MSG("Output buffer was too small for digest");
ret = WOLFSSL_FAILURE;
}
else {
unsigned int szOut = 0;
ret = wolfSSL_EVP_DigestFinal((WOLFSSL_EVP_MD_CTX*)bio->ptr,
ret = wolfSSL_EVP_DigestFinal(bio->ptr.md_ctx,
(unsigned char*)buf, &szOut);
if (ret == WOLFSSL_SUCCESS) {
ret = (int)szOut;
@ -1304,8 +1305,8 @@ size_t wolfSSL_BIO_ctrl_pending(WOLFSSL_BIO *bio)
}
#ifndef WOLFCRYPT_ONLY
if (bio->type == WOLFSSL_BIO_SSL && bio->ptr != NULL) {
return (long)wolfSSL_pending((WOLFSSL*)bio->ptr);
if (bio->type == WOLFSSL_BIO_SSL && bio->ptr.ssl != NULL) {
return (long)wolfSSL_pending(bio->ptr.ssl);
}
#endif
@ -1379,8 +1380,8 @@ long wolfSSL_BIO_get_mem_ptr(WOLFSSL_BIO *bio, WOLFSSL_BUF_MEM **ptr)
bio->wrSz = (int)bio->mem_buf->length;
bio->wrSzReset = bio->wrSz;
bio->num = (int)bio->mem_buf->max;
bio->ptr = bio->mem_buf->data;
bio->num.length = bio->mem_buf->max;
bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
bio->wrIdx = 0;
bio->rdIdx = 0;
@ -1413,15 +1414,16 @@ int wolfSSL_BIO_set_write_buf_size(WOLFSSL_BIO *bio, long size)
return WOLFSSL_FAILURE;
}
if (bio->ptr != NULL) {
XFREE(bio->ptr, bio->heap, DYNAMIC_TYPE_OPENSSL);
if (bio->ptr.mem_buf_data != NULL) {
XFREE(bio->ptr.mem_buf_data, bio->heap, DYNAMIC_TYPE_OPENSSL);
}
bio->ptr = (byte*)XMALLOC(size, bio->heap, DYNAMIC_TYPE_OPENSSL);
if (bio->ptr == NULL) {
bio->ptr.mem_buf_data = (byte*)XMALLOC(size, bio->heap,
DYNAMIC_TYPE_OPENSSL);
if (bio->ptr.mem_buf_data == NULL) {
WOLFSSL_MSG("Memory allocation error");
bio->wrSz = 0;
bio->num = 0;
bio->num.length = 0;
bio->wrIdx = 0;
bio->rdIdx = 0;
if (bio->mem_buf != NULL) {
@ -1432,13 +1434,13 @@ int wolfSSL_BIO_set_write_buf_size(WOLFSSL_BIO *bio, long size)
return WOLFSSL_FAILURE;
}
bio->wrSz = (int)size;
bio->num = (int)size;
bio->num.length = size;
bio->wrIdx = 0;
bio->rdIdx = 0;
if (bio->mem_buf != NULL) {
bio->mem_buf->data = (char*)bio->ptr;
bio->mem_buf->length = (size_t)bio->num;
bio->mem_buf->max = (size_t)bio->num;
bio->mem_buf->data = (char*)bio->ptr.mem_buf_data;
bio->mem_buf->length = bio->num.length;
bio->mem_buf->max = bio->num.length;
}
return WOLFSSL_SUCCESS;
@ -1466,12 +1468,12 @@ int wolfSSL_BIO_make_bio_pair(WOLFSSL_BIO *b1, WOLFSSL_BIO *b2)
}
/* set default write size if not already set */
if (b1->ptr == NULL && wolfSSL_BIO_set_write_buf_size(b1,
if (b1->ptr.mem_buf_data == NULL && wolfSSL_BIO_set_write_buf_size(b1,
WOLFSSL_BIO_SIZE) != WOLFSSL_SUCCESS) {
return WOLFSSL_FAILURE;
}
if (b2->ptr == NULL && wolfSSL_BIO_set_write_buf_size(b2,
if (b2->ptr.mem_buf_data == NULL && wolfSSL_BIO_set_write_buf_size(b2,
WOLFSSL_BIO_SIZE) != WOLFSSL_SUCCESS) {
return WOLFSSL_FAILURE;
}
@ -1512,7 +1514,7 @@ int wolfSSL_BIO_nread0(WOLFSSL_BIO *bio, char **buf)
WOLFSSL_BIO* pair = bio->pair;
/* case where have wrapped around write buffer */
*buf = (char*)pair->ptr + pair->rdIdx;
*buf = (char*)pair->ptr.mem_buf_data + pair->rdIdx;
if (pair->wrIdx > 0 && pair->rdIdx >= pair->wrIdx) {
return pair->wrSz - pair->rdIdx;
}
@ -1544,7 +1546,7 @@ int wolfSSL_BIO_nread(WOLFSSL_BIO *bio, char **buf, int num)
if (bio->pair != NULL) {
/* special case if asking to read 0 bytes */
if (num == 0) {
*buf = (char*)bio->pair->ptr + bio->pair->rdIdx;
*buf = (char*)bio->pair->ptr.mem_buf_data + bio->pair->rdIdx;
return 0;
}
@ -1598,7 +1600,7 @@ int wolfSSL_BIO_nwrite(WOLFSSL_BIO *bio, char **buf, int num)
if (bio->pair != NULL) {
if (num == 0) {
*buf = (char*)bio->ptr + bio->wrIdx;
*buf = (char*)bio->ptr.mem_buf_data + bio->wrIdx;
return 0;
}
@ -1637,7 +1639,7 @@ int wolfSSL_BIO_nwrite(WOLFSSL_BIO *bio, char **buf, int num)
if (num < sz) {
sz = num;
}
*buf = (char*)bio->ptr + bio->wrIdx;
*buf = (char*)bio->ptr.mem_buf_data + bio->wrIdx;
bio->wrIdx += sz;
#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
bio->bytes_written += (word32)sz;
@ -1699,7 +1701,7 @@ int wolfSSL_BIO_reset(WOLFSSL_BIO *bio)
switch (bio->type) {
#ifndef NO_FILESYSTEM
case WOLFSSL_BIO_FILE:
if (XFSEEK((XFILE)bio->ptr, 0, XSEEK_SET) != 0)
if (XFSEEK(bio->ptr.fh, 0, XSEEK_SET) != 0)
return WOLFSSL_BIO_ERROR;
else
return 0;
@ -1718,9 +1720,9 @@ int wolfSSL_BIO_reset(WOLFSSL_BIO *bio)
}
else {
bio->wrSz = 0;
XFREE(bio->ptr, bio->heap, DYNAMIC_TYPE_OPENSSL);
bio->ptr = NULL;
bio->num = 0;
XFREE(bio->ptr.mem_buf_data, bio->heap, DYNAMIC_TYPE_OPENSSL);
bio->ptr.mem_buf_data = NULL;
bio->num.length = 0;
if (bio->mem_buf != NULL) {
bio->mem_buf->data = NULL;
bio->mem_buf->length = 0;
@ -1731,12 +1733,12 @@ int wolfSSL_BIO_reset(WOLFSSL_BIO *bio)
#ifndef WOLFCRYPT_ONLY
case WOLFSSL_BIO_MD:
if (bio->ptr != NULL) {
if (bio->ptr.md_ctx != NULL) {
const WOLFSSL_EVP_MD* md =
wolfSSL_EVP_MD_CTX_md((WOLFSSL_EVP_MD_CTX*)bio->ptr);
wolfSSL_EVP_MD_CTX_cleanup((WOLFSSL_EVP_MD_CTX*)bio->ptr);
wolfSSL_EVP_MD_CTX_init((WOLFSSL_EVP_MD_CTX*)bio->ptr);
wolfSSL_EVP_DigestInit((WOLFSSL_EVP_MD_CTX*)bio->ptr, md);
wolfSSL_EVP_MD_CTX_md(bio->ptr.md_ctx);
wolfSSL_EVP_MD_CTX_cleanup(bio->ptr.md_ctx);
wolfSSL_EVP_MD_CTX_init(bio->ptr.md_ctx);
wolfSSL_EVP_DigestInit(bio->ptr.md_ctx, md);
}
return 0;
#endif /* WOLFCRYPT_ONLY */
@ -1788,7 +1790,7 @@ long wolfSSL_BIO_set_fp(WOLFSSL_BIO *bio, XFILE fp, int c)
}
bio->shutdown = (byte)c;
bio->ptr = (XFILE)fp;
bio->ptr.fh = fp;
return WOLFSSL_SUCCESS;
}
@ -1806,7 +1808,7 @@ long wolfSSL_BIO_get_fp(WOLFSSL_BIO *bio, XFILE* fp)
return WOLFSSL_FAILURE;
}
*fp = (XFILE)bio->ptr;
*fp = bio->ptr.fh;
return WOLFSSL_SUCCESS;
}
@ -1821,8 +1823,8 @@ int wolfSSL_BIO_write_filename(WOLFSSL_BIO *bio, char *name)
}
if (bio->type == WOLFSSL_BIO_FILE) {
if (((XFILE)bio->ptr) != XBADFILE && bio->shutdown == BIO_CLOSE) {
XFCLOSE((XFILE)bio->ptr);
if (bio->ptr.fh != XBADFILE && bio->shutdown == BIO_CLOSE) {
XFCLOSE(bio->ptr.fh);
}
/* 'b' flag is ignored on POSIX targets, but on Windows it assures
@ -1830,8 +1832,8 @@ int wolfSSL_BIO_write_filename(WOLFSSL_BIO *bio, char *name)
* between the size and contents of the representation in memory and on
* disk.
*/
bio->ptr = XFOPEN(name, "wb");
if (((XFILE)bio->ptr) == XBADFILE) {
bio->ptr.fh = XFOPEN(name, "wb");
if (bio->ptr.fh == XBADFILE) {
return WOLFSSL_FAILURE;
}
bio->shutdown = BIO_CLOSE;
@ -1853,7 +1855,7 @@ int wolfSSL_BIO_seek(WOLFSSL_BIO *bio, int ofs)
/* offset ofs from beginning of file */
if (bio->type == WOLFSSL_BIO_FILE &&
XFSEEK((XFILE)bio->ptr, ofs, SEEK_SET) < 0) {
XFSEEK(bio->ptr.fh, ofs, SEEK_SET) < 0) {
return -1;
}
@ -1878,7 +1880,7 @@ int wolfSSL_BIO_tell(WOLFSSL_BIO* bio)
return 0;
}
pos = (int)XFTELL((XFILE)bio->ptr);
pos = (int)XFTELL(bio->ptr.fh);
if (pos < 0)
return -1;
else
@ -2011,12 +2013,12 @@ long wolfSSL_BIO_set_nbio(WOLFSSL_BIO* bio, long on)
#ifdef XFCNTL
{
int ret;
int flag = XFCNTL(bio->num, F_GETFL, 0);
int flag = XFCNTL(bio->num.fd, F_GETFL, 0);
if (on) {
ret = XFCNTL(bio->num, F_SETFL, flag | O_NONBLOCK);
ret = XFCNTL(bio->num.fd, F_SETFL, flag | O_NONBLOCK);
}
else {
ret = XFCNTL(bio->num, F_SETFL, flag & ~O_NONBLOCK);
ret = XFCNTL(bio->num.fd, F_SETFL, flag & ~O_NONBLOCK);
}
if (ret == -1) {
@ -2027,7 +2029,7 @@ long wolfSSL_BIO_set_nbio(WOLFSSL_BIO* bio, long on)
break;
case WOLFSSL_BIO_SSL:
#ifdef WOLFSSL_DTLS
wolfSSL_dtls_set_using_nonblock((WOLFSSL*)bio->ptr, (int)on);
wolfSSL_dtls_set_using_nonblock(bio->ptr.ssl, (int)on);
#endif
break;
@ -2175,7 +2177,7 @@ int wolfSSL_BIO_get_mem_data(WOLFSSL_BIO* bio, void* p)
}
if (p) {
*(byte**)p = (byte*)mem_bio->ptr + mem_bio->rdIdx;
*(byte**)p = mem_bio->ptr.mem_buf_data + mem_bio->rdIdx;
}
return mem_bio->wrSz - mem_bio->rdIdx;
@ -2200,7 +2202,7 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
}
else if (bio->type == WOLFSSL_BIO_FILE) {
#if !defined(NO_FILESYSTEM) && defined(XFFLUSH)
if (XFFLUSH((FILE *)bio->ptr) != 0)
if (XFFLUSH(bio->ptr.fh) != 0)
return WOLFSSL_FAILURE;
#endif /* !NO_FILESYSTEM && XFFLUSH */
@ -2227,7 +2229,7 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
int ret = WOLFSSL_FAILURE;
if ((bio != NULL) && (mdcp != NULL)) {
*mdcp = (WOLFSSL_EVP_MD_CTX*)bio->ptr;
*mdcp = bio->ptr.md_ctx;
ret = WOLFSSL_SUCCESS;
}
@ -2319,7 +2321,7 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
if (bio) {
bio->type = WOLFSSL_BIO_SOCKET;
bio->shutdown = (byte)closeF;
bio->num = sfd;
bio->num.fd = (SOCKET_T)sfd;
}
return bio;
}
@ -2345,7 +2347,7 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
if (bio) {
bio->type = WOLFSSL_BIO_DGRAM;
bio->shutdown = (byte)closeF;
bio->num = fd;
bio->num.fd = (SOCKET_T)fd;
}
return bio;
}
@ -2468,7 +2470,7 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
return WOLFSSL_FAILURE;
}
b->num = (int)sfd;
b->num.fd = sfd;
b->shutdown = BIO_CLOSE;
return WOLFSSL_SUCCESS;
}
@ -2492,17 +2494,17 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
return WOLFSSL_FAILURE;
}
if (b->num == WOLFSSL_BIO_ERROR) {
if (b->num.fd == SOCKET_INVALID) {
if (wolfIO_TcpBind(&sfd, b->port) < 0) {
WOLFSSL_MSG("wolfIO_TcpBind error");
return WOLFSSL_FAILURE;
}
b->num = (int)sfd;
b->num.fd = sfd;
b->shutdown = BIO_CLOSE;
}
else {
WOLFSSL_BIO* new_bio;
int newfd = wolfIO_TcpAccept(b->num, NULL, NULL);
int newfd = wolfIO_TcpAccept(b->num.fd, NULL, NULL);
if (newfd < 0) {
WOLFSSL_MSG("wolfIO_TcpBind error");
return WOLFSSL_FAILURE;
@ -2559,8 +2561,8 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
WOLFSSL_MSG("Bad parameter");
return WOLFSSL_FAILURE;
}
if (b->type == WOLFSSL_BIO_SSL && b->ptr != NULL) {
return wolfSSL_negotiate((WOLFSSL*)b->ptr);
if (b->type == WOLFSSL_BIO_SSL && b->ptr.ssl != NULL) {
return wolfSSL_negotiate(b->ptr.ssl);
}
else {
WOLFSSL_MSG("Not SSL BIO or no SSL object set");
@ -2585,12 +2587,12 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
return;
}
if (b->ptr != NULL) {
int rc = wolfSSL_shutdown((WOLFSSL*)b->ptr);
if (b->ptr.ssl != NULL) {
int rc = wolfSSL_shutdown(b->ptr.ssl);
if (rc == SSL_SHUTDOWN_NOT_DONE) {
/* In this case, call again to give us a chance to read the
* close notify alert from the other end. */
wolfSSL_shutdown((WOLFSSL*)b->ptr);
wolfSSL_shutdown(b->ptr.ssl);
}
}
else {
@ -2605,7 +2607,7 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
WOLFSSL_ENTER("wolfSSL_BIO_set_ssl");
if (b != NULL) {
b->ptr = ssl;
b->ptr.ssl = ssl;
b->shutdown = (byte)closeF;
if (b->next != NULL)
wolfSSL_set_bio(ssl, b->next, b->next);
@ -2633,7 +2635,7 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
return WOLFSSL_FAILURE;
}
*ssl = (WOLFSSL*)bio->ptr;
*ssl = bio->ptr.ssl;
return WOLFSSL_SUCCESS;
}
@ -2777,7 +2779,7 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
WOLFSSL_ENTER("wolfSSL_BIO_set_fd");
if (b != NULL) {
b->num = fd;
b->num.fd = (SOCKET_T)fd;
b->shutdown = (byte)closeF;
}
@ -2821,7 +2823,14 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
bio->method = method;
#endif
bio->shutdown = BIO_CLOSE; /* default to close things */
bio->num = WOLFSSL_BIO_ERROR;
if ((bio->type == WOLFSSL_BIO_SOCKET) ||
(bio->type == WOLFSSL_BIO_DGRAM))
{
bio->num.fd = SOCKET_INVALID;
} else {
bio->num.length = 0;
}
bio->init = 1;
#if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)
@ -2853,8 +2862,8 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
}
if (method->type == WOLFSSL_BIO_MD) {
bio->ptr = wolfSSL_EVP_MD_CTX_new();
if (bio->ptr == NULL) {
bio->ptr.md_ctx = wolfSSL_EVP_MD_CTX_new();
if (bio->ptr.md_ctx == NULL) {
WOLFSSL_MSG("Memory error");
wolfSSL_BIO_free(bio);
return NULL;
@ -2893,11 +2902,11 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
return NULL;
}
bio->num = (int)bio->mem_buf->max;
bio->num.length = bio->mem_buf->max;
bio->wrSz = len;
bio->ptr = bio->mem_buf->data;
if (len > 0 && bio->ptr != NULL) {
XMEMCPY(bio->ptr, buf, len);
bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
if (len > 0 && bio->ptr.mem_buf_data != NULL) {
XMEMCPY(bio->ptr.mem_buf_data, buf, len);
bio->flags |= BIO_FLAGS_MEM_RDONLY;
bio->wrSzReset = bio->wrSz;
}
@ -2965,39 +2974,48 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
}
if (bio->shutdown) {
if (bio->type == WOLFSSL_BIO_SSL && bio->ptr)
wolfSSL_free((WOLFSSL*)bio->ptr);
if (bio->type == WOLFSSL_BIO_SSL && bio->ptr.ssl)
wolfSSL_free(bio->ptr.ssl);
#ifdef CloseSocket
if ((bio->type == WOLFSSL_BIO_SOCKET) && (bio->num > 0))
CloseSocket(bio->num);
if (((bio->type == WOLFSSL_BIO_SOCKET) ||
(bio->type == WOLFSSL_BIO_DGRAM)) &&
(bio->num.fd != SOCKET_INVALID))
{
CloseSocket(bio->num.fd);
}
#endif
}
#ifndef NO_FILESYSTEM
if (bio->type == WOLFSSL_BIO_FILE && bio->shutdown == BIO_CLOSE) {
if (bio->ptr) {
XFCLOSE((XFILE)bio->ptr);
if (bio->ptr.fh) {
XFCLOSE(bio->ptr.fh);
}
#if !defined(USE_WINDOWS_API) && !defined(NO_WOLFSSL_DIR)\
&& !defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)
else if (bio->num != WOLFSSL_BIO_ERROR) {
XCLOSE(bio->num);
else if (bio->num.fd != SOCKET_INVALID) {
XCLOSE(bio->num.fd);
}
#endif
}
#endif
if (bio->shutdown != BIO_NOCLOSE) {
if (bio->type == WOLFSSL_BIO_MEMORY && bio->ptr != NULL) {
if (bio->type == WOLFSSL_BIO_MEMORY &&
bio->ptr.mem_buf_data != NULL)
{
if (bio->mem_buf != NULL) {
if (bio->mem_buf->data != (char*)bio->ptr) {
XFREE(bio->ptr, bio->heap, DYNAMIC_TYPE_OPENSSL);
bio->ptr = NULL;
if ((byte *)bio->mem_buf->data != bio->ptr.mem_buf_data)
{
XFREE(bio->ptr.mem_buf_data, bio->heap,
DYNAMIC_TYPE_OPENSSL);
bio->ptr.mem_buf_data = NULL;
}
}
else {
XFREE(bio->ptr, bio->heap, DYNAMIC_TYPE_OPENSSL);
bio->ptr = NULL;
XFREE(bio->ptr.mem_buf_data, bio->heap,
DYNAMIC_TYPE_OPENSSL);
bio->ptr.mem_buf_data = NULL;
}
}
if (bio->mem_buf != NULL) {
@ -3007,7 +3025,7 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
}
if (bio->type == WOLFSSL_BIO_MD) {
wolfSSL_EVP_MD_CTX_free((WOLFSSL_EVP_MD_CTX*)bio->ptr);
wolfSSL_EVP_MD_CTX_free(bio->ptr.md_ctx);
}
XFREE(bio, 0, DYNAMIC_TYPE_OPENSSL);
@ -3046,8 +3064,8 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
}
/* SSL BIO's should use the next object in the chain for IO */
if (top->type == WOLFSSL_BIO_SSL && top->ptr)
wolfSSL_set_bio((WOLFSSL*)top->ptr, append, append);
if (top->type == WOLFSSL_BIO_SSL && top->ptr.ssl)
wolfSSL_set_bio(top->ptr.ssl, append, append);
return top;
}
@ -3151,9 +3169,11 @@ int wolfSSL_BIO_get_fd(WOLFSSL_BIO *bio, int* fd)
WOLFSSL_ENTER("wolfSSL_BIO_get_fd");
if (bio != NULL) {
if (bio->num.fd == SOCKET_INVALID)
return WOLFSSL_BIO_ERROR;
if (fd != NULL)
*fd = bio->num;
return bio->num;
*fd = (int)bio->num.fd;
return (int)bio->num.fd;
}
return WOLFSSL_BIO_ERROR;
@ -3228,10 +3248,10 @@ int wolfSSL_BIO_vprintf(WOLFSSL_BIO* bio, const char* format, va_list args)
switch (bio->type) {
#if !defined(NO_FILESYSTEM)
case WOLFSSL_BIO_FILE:
if (bio->ptr == NULL) {
if (bio->ptr.fh == XBADFILE) {
return -1;
}
ret = XVFPRINTF((XFILE)bio->ptr, format, args);
ret = XVFPRINTF(bio->ptr.fh, format, args);
break;
#endif

10
src/ocsp.c
View File

@ -952,18 +952,18 @@ OcspResponse* wolfSSL_d2i_OCSP_RESPONSE_bio(WOLFSSL_BIO* bio,
long fcur;
long flen;
if (bio->ptr == NULL)
if (bio->ptr.fh == NULL)
return NULL;
fcur = XFTELL((XFILE)bio->ptr);
fcur = XFTELL(bio->ptr.fh);
if (fcur < 0)
return NULL;
if(XFSEEK((XFILE)bio->ptr, 0, SEEK_END) != 0)
if(XFSEEK(bio->ptr.fh, 0, SEEK_END) != 0)
return NULL;
flen = XFTELL((XFILE)bio->ptr);
flen = XFTELL(bio->ptr.fh);
if (flen < 0)
return NULL;
if (XFSEEK((XFILE)bio->ptr, fcur, SEEK_SET) != 0)
if (XFSEEK(bio->ptr.fh, fcur, SEEK_SET) != 0)
return NULL;
/* check calculated length */

6
src/wolfio.c
View File

@ -301,7 +301,8 @@ int BioReceive(WOLFSSL* ssl, char* buf, int sz, void* ctx)
return WOLFSSL_CBIO_ERR_CONN_CLOSE;
}
#ifdef USE_WOLFSSL_IO
recvd = TranslateIoReturnCode(recvd, ssl->biord->num, SOCKET_RECEIVING);
recvd = TranslateIoReturnCode(recvd, ssl->biord->num.fd,
SOCKET_RECEIVING);
#endif
return recvd;
}
@ -346,7 +347,8 @@ int BioSend(WOLFSSL* ssl, char *buf, int sz, void *ctx)
if (sent <= 0) {
if (ssl->biowr->type == WOLFSSL_BIO_SOCKET) {
#ifdef USE_WOLFSSL_IO
sent = TranslateIoReturnCode(sent, ssl->biowr->num, SOCKET_SENDING);
sent = TranslateIoReturnCode(sent, ssl->biowr->num.fd,
SOCKET_SENDING);
#endif
return sent;
}

8
tests/api.c
View File

@ -601,14 +601,14 @@ static int testDevId = INVALID_DEVID;
static int wolfssl_bio_s_fixed_mem_write(WOLFSSL_BIO* bio, const char* data,
int len)
{
if ((bio == NULL) || (bio->ptr == NULL) || (data == NULL)) {
if ((bio == NULL) || (bio->ptr.mem_buf_data == NULL) || (data == NULL)) {
len = 0;
}
else {
if (bio->wrSz - bio->wrIdx < len) {
len = bio->wrSz - bio->wrIdx;
}
XMEMCPY((char*)bio->ptr + bio->wrIdx, data, len);
XMEMCPY(bio->ptr.mem_buf_data + bio->wrIdx, data, len);
bio->wrIdx += len;
}
@ -617,14 +617,14 @@ static int wolfssl_bio_s_fixed_mem_write(WOLFSSL_BIO* bio, const char* data,
static int wolfssl_bio_s_fixed_mem_read(WOLFSSL_BIO* bio, char* data, int len)
{
if ((bio == NULL) || (bio->ptr == NULL) || (data == NULL)) {
if ((bio == NULL) || (bio->ptr.mem_buf_data == NULL) || (data == NULL)) {
len = 0;
}
else {
if (bio->wrSz - bio->rdIdx < len) {
len = bio->wrSz - bio->rdIdx;
}
XMEMCPY(data, (char*)bio->ptr + bio->rdIdx, len);
XMEMCPY(data, bio->ptr.mem_buf_data + bio->rdIdx, len);
bio->rdIdx += len;
}

16
wolfssl/internal.h
View File

@ -2753,7 +2753,16 @@ struct WOLFSSL_BIO {
WOLFSSL_BIO* next; /* next in chain */
WOLFSSL_BIO* pair; /* BIO paired with */
void* heap; /* user heap hint */
void* ptr; /* WOLFSSL, file descriptor, MD, or mem buf */
union {
byte* mem_buf_data;
#ifndef WOLFCRYPT_ONLY
WOLFSSL* ssl;
WOLFSSL_EVP_MD_CTX* md_ctx;
#endif
#ifndef NO_FILESYSTEM
XFILE fh;
#endif
} ptr;
void* usrCtx; /* user set pointer */
char* ip; /* IP address for wolfIO_TcpConnect */
word16 port; /* Port for wolfIO_TcpConnect */
@ -2764,7 +2773,10 @@ struct WOLFSSL_BIO {
int wrIdx; /* current index for write buffer */
int rdIdx; /* current read index */
int readRq; /* read request */
int num; /* socket num or length */
union {
SOCKET_T fd;
size_t length;
} num;
int eof; /* eof flag */
int flags;
byte type; /* method type */

19
wolfssl/wolfcrypt/wc_port.h
View File

@ -859,6 +859,25 @@ WOLFSSL_ABI WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XSPRINTF sprintf
#endif
#ifdef USE_WINDOWS_API
#ifndef SOCKET_T
#ifdef __MINGW64__
typedef size_t SOCKET_T;
#else
typedef unsigned int SOCKET_T;
#endif
#endif
#ifndef SOCKET_INVALID
#define SOCKET_INVALID INVALID_SOCKET
#endif
#else
#ifndef SOCKET_T
typedef int SOCKET_T;
#endif
#ifndef SOCKET_INVALID
#define SOCKET_INVALID (-1)
#endif
#endif
/* MIN/MAX MACRO SECTION */
/* Windows API defines its own min() macro. */

16
wolfssl/wolfio.h
View File

@ -404,22 +404,6 @@
#endif
#endif
#ifdef USE_WINDOWS_API
#if defined(__MINGW64__)
typedef size_t SOCKET_T;
#else
typedef unsigned int SOCKET_T;
#endif
#ifndef SOCKET_INVALID
#define SOCKET_INVALID INVALID_SOCKET
#endif
#else
typedef int SOCKET_T;
#ifndef SOCKET_INVALID
#define SOCKET_INVALID (-1)
#endif
#endif
#ifndef WOLFSSL_NO_SOCK
#ifndef XSOCKLENT
#ifdef USE_WINDOWS_API