feedc0de/wolfssl
1
0
Fork 0
forked from wolfSSL/wolfssl
Code Pull Requests Activity

Merge pull request #6686 from dgarske/fix_cond

Browse Source 
Fixes for wolfSSL conditional porting
This commit is contained in:
JacobBarthelmeh
2023-08-09 12:08:05 -06:00
committed by GitHub
parent 35f4a1a09d 737e12a1bd
commit 12685d7713
11 changed files with 183 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/multi-compiler.yml vendored
View File

@@ -26,7 +26,7 @@ jobs:
CXX: clang++-14
runs-on: ubuntu-latest
# This should be a safe limit for the tests to run.
timeout-minutes: 2
timeout-minutes: 4
steps:
- uses: actions/checkout@v3
- name: Build

25
examples/benchmark/tls_bench.c
View File

@@ -416,9 +416,9 @@ static int ServerMemSend(info_t* info, char* buf, int sz)
XMEMCPY(&info->to_client.buf[info->to_client.write_idx], buf, sz);
info->to_client.write_idx += sz;
info->to_client.write_bytes += sz;
THREAD_CHECK_RET(wc_UnLockMutex(&info->to_client.mutex));
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_client.cond));
THREAD_CHECK_RET(wc_UnLockMutex(&info->to_client.mutex));
#ifdef BENCH_USE_NONBLOCK
if (sz == 0) {
@@ -436,8 +436,9 @@ static int ServerMemRecv(info_t* info, char* buf, int sz)
#ifndef BENCH_USE_NONBLOCK
while (info->to_server.write_idx - info->to_server.read_idx < sz &&
!info->to_client.done) {
THREAD_CHECK_RET(wolfSSL_CondWait(&info->to_server.cond,
&info->to_server.mutex));
THREAD_CHECK_RET(wc_UnLockMutex(&info->to_server.mutex));
THREAD_CHECK_RET(wolfSSL_CondWait(&info->to_server.cond));
THREAD_CHECK_RET(wc_LockMutex(&info->to_server.mutex));
}
#else
if (info->to_server.write_idx - info->to_server.read_idx < sz) {
@@ -492,8 +493,8 @@ static int ClientMemSend(info_t* info, char* buf, int sz)
info->to_server.write_idx += sz;
info->to_server.write_bytes += sz;
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
THREAD_CHECK_RET(wc_UnLockMutex(&info->to_server.mutex));
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
#ifdef BENCH_USE_NONBLOCK
if (sz == 0) {
@@ -511,8 +512,9 @@ static int ClientMemRecv(info_t* info, char* buf, int sz)
#ifndef BENCH_USE_NONBLOCK
while (info->to_client.write_idx - info->to_client.read_idx < sz &&
!info->to_server.done) {
THREAD_CHECK_RET(wolfSSL_CondWait(&info->to_client.cond,
&info->to_client.mutex));
THREAD_CHECK_RET(wc_UnLockMutex(&info->to_client.mutex));
THREAD_CHECK_RET(wolfSSL_CondWait(&info->to_client.cond));
THREAD_CHECK_RET(wc_LockMutex(&info->to_client.mutex));
}
#else
if (info->to_client.write_idx - info->to_client.read_idx < sz) {
@@ -1054,8 +1056,9 @@ static int bench_tls_client(info_t* info)
if (info->doDTLS && !info->clientOrserverOnly) {
THREAD_CHECK_RET(wc_LockMutex(&info->dtls_mutex));
if (info->serverReady != 1) {
THREAD_CHECK_RET(wolfSSL_CondWait(&info->dtls_cond,
&info->dtls_mutex));
THREAD_CHECK_RET(wc_UnLockMutex(&info->dtls_mutex));
THREAD_CHECK_RET(wolfSSL_CondWait(&info->dtls_cond));
THREAD_CHECK_RET(wc_LockMutex(&info->dtls_mutex));
}
/* for next loop */
info->serverReady = 0;
@@ -1201,9 +1204,9 @@ static THREAD_RETURN WOLFSSL_THREAD_NO_JOIN client_thread(void* args)
ret = bench_tls_client(info);
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
info->to_client.done = 1;
info->client.ret = ret;
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
WOLFSSL_RETURN_FROM_THREAD(NULL);
}
@@ -1291,8 +1294,8 @@ static int SocketWaitClient(info_t* info)
if (!info->clientOrserverOnly) {
THREAD_CHECK_RET(wc_LockMutex(&info->dtls_mutex));
info->serverReady = 1;
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->dtls_cond));
THREAD_CHECK_RET(wc_UnLockMutex(&info->dtls_mutex));
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->dtls_cond));
}
#endif
connd = (int)recvfrom(info->listenFd, (char *)msg, sizeof(msg),
@@ -1659,9 +1662,9 @@ static THREAD_RETURN WOLFSSL_THREAD_NO_JOIN server_thread(void* args)
}
}
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_client.cond));
info->to_server.done = 1;
info->server.ret = ret;
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_client.cond));
WOLFSSL_RETURN_FROM_THREAD(NULL);
}

5
examples/echoserver/echoserver.c
View File

@@ -74,13 +74,8 @@ static void SignalReady(void* args, word16 port)
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
ready->ready = 1;
ready->port = port;
#ifdef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#endif
THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#endif
#endif /* NO_MAIN_DRIVER && WOLFSSL_COND */
(void)args;
(void)port;

32
src/bio.c
View File

@@ -1963,10 +1963,10 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_md(void)
{
static WOLFSSL_BIO_METHOD meth;
static WOLFSSL_BIO_METHOD meth =
WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_MD);
WOLFSSL_ENTER("wolfSSL_BIO_f_md");
meth.type = WOLFSSL_BIO_MD;
return &meth;
}
@@ -1986,10 +1986,10 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_buffer(void)
{
static WOLFSSL_BIO_METHOD meth;
static WOLFSSL_BIO_METHOD meth =
WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_BUFFER);
WOLFSSL_ENTER("wolfSSL_BIO_f_buffer");
meth.type = WOLFSSL_BIO_BUFFER;
return &meth;
}
@@ -2017,10 +2017,10 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_bio(void)
{
static WOLFSSL_BIO_METHOD bio_meth;
static WOLFSSL_BIO_METHOD bio_meth =
WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_BIO);
WOLFSSL_ENTER("wolfSSL_BIO_s_bio");
bio_meth.type = WOLFSSL_BIO_BIO;
return &bio_meth;
}
@@ -2029,10 +2029,10 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
#ifndef NO_FILESYSTEM
WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_file(void)
{
static WOLFSSL_BIO_METHOD file_meth;
static WOLFSSL_BIO_METHOD file_meth =
WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_FILE);
WOLFSSL_ENTER("wolfSSL_BIO_s_file");
file_meth.type = WOLFSSL_BIO_FILE;
return &file_meth;
}
@@ -2041,10 +2041,10 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_ssl(void)
{
static WOLFSSL_BIO_METHOD meth;
static WOLFSSL_BIO_METHOD meth =
WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_SSL);
WOLFSSL_ENTER("wolfSSL_BIO_f_ssl");
meth.type = WOLFSSL_BIO_SSL;
return &meth;
}
@@ -2052,10 +2052,10 @@ int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
WOLFSSL_BIO_METHOD *wolfSSL_BIO_s_socket(void)
{
static WOLFSSL_BIO_METHOD meth;
static WOLFSSL_BIO_METHOD meth =
WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_SOCKET);
WOLFSSL_ENTER("wolfSSL_BIO_s_socket");
meth.type = WOLFSSL_BIO_SOCKET;
return &meth;
}
@@ -2803,10 +2803,10 @@ WOLFSSL_BIO* wolfSSL_BIO_pop(WOLFSSL_BIO* bio)
WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_mem(void)
{
static WOLFSSL_BIO_METHOD meth;
static WOLFSSL_BIO_METHOD meth =
WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_MEMORY);
WOLFSSL_ENTER("wolfSSL_BIO_s_mem");
meth.type = WOLFSSL_BIO_MEMORY;
return &meth;
}
@@ -2814,10 +2814,10 @@ WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_mem(void)
WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_base64(void)
{
static WOLFSSL_BIO_METHOD meth;
static WOLFSSL_BIO_METHOD meth =
WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_BASE64);
WOLFSSL_ENTER("wolfSSL_BIO_f_base64");
meth.type = WOLFSSL_BIO_BASE64;
return &meth;
}

40
src/crl.c
View File

@@ -931,20 +931,17 @@ static int SignalSetup(WOLFSSL_CRL* crl, int status)
int ret;
/* signal to calling thread we're setup */
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
if (wc_LockMutex(&crl->crlLock) != 0) {
WOLFSSL_MSG("wc_LockMutex crlLock failed");
return BAD_MUTEX_E;
}
#endif
crl->setup = status;
if (wc_UnLockMutex(&crl->crlLock) != 0) {
WOLFSSL_MSG("wc_UnLockMutex crlLock failed");
return BAD_MUTEX_E;
}
ret = wolfSSL_CondSignal(&crl->cond);
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
wc_UnLockMutex(&crl->crlLock);
#endif
if (ret != 0)
return BAD_COND_E;
@@ -1491,31 +1488,38 @@ static int StartMonitorCRL(WOLFSSL_CRL* crl)
return THREAD_CREATE_E;
}
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
/* wait for setup to complete */
if (wc_LockMutex(&crl->crlLock) != 0) {
WOLFSSL_MSG("wc_LockMutex crlLock error");
WOLFSSL_MSG("wc_LockMutex crlLock failed");
return BAD_MUTEX_E;
}
#endif
while (crl->setup == 0) {
if (wolfSSL_CondWait(&crl->cond, &crl->crlLock) != 0) {
int condRet;
if (wc_UnLockMutex(&crl->crlLock) != 0) {
WOLFSSL_MSG("wc_UnLockMutex crlLock failed");
return BAD_MUTEX_E;
}
condRet = wolfSSL_CondWait(&crl->cond);
if (wc_LockMutex(&crl->crlLock) != 0) {
WOLFSSL_MSG("wc_LockMutex crlLock failed");
return BAD_MUTEX_E;
}
if (condRet != 0) {
ret = BAD_COND_E;
break;
}
}
if (crl->setup < 0)
if (ret >= 0 && crl->setup < 0)
ret = crl->setup; /* store setup error */
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
wc_UnLockMutex(&crl->crlLock);
#endif
if (ret < 0) {
WOLFSSL_MSG("DoMonitor setup failure");
crl->tid = INVALID_THREAD_VAL; /* thread already done */
}
if (wc_UnLockMutex(&crl->crlLock) != 0) {
WOLFSSL_MSG("wc_UnLockMutex crlLock failed");
return BAD_MUTEX_E;
}
return ret;
}

26
tests/utils.c
View File

@@ -322,31 +322,23 @@ void signal_ready(tcp_ready* ready)
{
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
ready->ready = 1;
#ifdef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#endif
THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#endif
}
#endif
void wait_tcp_ready(func_args* args)
{
#if !defined(SINGLE_THREADED) && defined(WOLFSSL_COND)
if (!args->signal->ready) {
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_LockMutex(&args->signal->mutex));
#endif
THREAD_CHECK_RET(wolfSSL_CondWait(&args->signal->cond,
&args->signal->mutex));
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&args->signal->mutex));
#endif
tcp_ready* ready = args->signal;
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
if (!ready->ready) {
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondWait(&ready->cond));
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
}
args->signal->ready = 0; /* reset */
ready->ready = 0; /* reset */
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#else
/* no threading wait or single threaded */
(void)args;
@@ -356,7 +348,7 @@ void wait_tcp_ready(func_args* args)
#ifndef SINGLE_THREADED
/* Start a thread.
*
* @param [in] fun Function to executre in thread.
* @param [in] fun Function to execute in thread.
* @param [in] args Object to send to function in thread.
* @param [out] thread Handle to thread.
*/

109
wolfcrypt/src/wc_port.c
View File

@@ -3491,11 +3491,8 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
return 0;
}
int wolfSSL_CondWait(COND_TYPE* cond,
wolfSSL_Mutex* mutex)
int wolfSSL_CondWait(COND_TYPE* cond)
{
(void)mutex;
if (cond == NULL)
return BAD_FUNC_ARG;
@@ -3698,14 +3695,94 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
}
#ifdef WOLFSSL_COND
#ifndef __MACH__
/* Generic POSIX conditional */
int wolfSSL_CondInit(COND_TYPE* cond)
{
if (cond == NULL)
return BAD_FUNC_ARG;
if (pthread_cond_init(cond, NULL) != 0)
if (pthread_mutex_init(&cond->mutex, NULL) != 0)
return MEMORY_E;
if (pthread_cond_init(&cond->cond, NULL) != 0) {
/* Keep compilers happy that we are using the return code */
if (pthread_mutex_destroy(&cond->mutex) != 0)
return MEMORY_E;
return MEMORY_E;
}
return 0;
}
int wolfSSL_CondFree(COND_TYPE* cond)
{
int ret = 0;
if (cond == NULL)
return BAD_FUNC_ARG;
if (pthread_mutex_destroy(&cond->mutex) != 0)
ret = MEMORY_E;
if (pthread_cond_destroy(&cond->cond) != 0)
ret = MEMORY_E;
return ret;
}
int wolfSSL_CondSignal(COND_TYPE* cond)
{
int ret = 0;
if (cond == NULL)
return BAD_FUNC_ARG;
if (pthread_mutex_lock(&cond->mutex) != 0)
return BAD_MUTEX_E;
if (pthread_cond_signal(&cond->cond) != 0)
ret = MEMORY_E;
if (pthread_mutex_unlock(&cond->mutex) != 0)
ret = MEMORY_E;
return ret;
}
int wolfSSL_CondWait(COND_TYPE* cond)
{
int ret = 0;
if (cond == NULL)
return BAD_FUNC_ARG;
if (pthread_mutex_lock(&cond->mutex) != 0)
return BAD_MUTEX_E;
if (pthread_cond_wait(&cond->cond, &cond->mutex) != 0)
ret = MEMORY_E;
if (pthread_mutex_unlock(&cond->mutex) != 0)
ret = MEMORY_E;
return ret;
}
#else /* __MACH__ */
/* Apple style dispatch semaphore */
int wolfSSL_CondInit(COND_TYPE* cond)
{
if (cond == NULL)
return BAD_FUNC_ARG;
/* dispatch_release() fails hard, with Trace/BPT trap signal, if the
* sem's internal count is less than the value passed in with
* dispatch_semaphore_create(). work around this by initing
* with 0, then incrementing it afterwards.
*/
*cond = dispatch_semaphore_create(0);
if (*cond == NULL)
return MEMORY_E;
return 0;
}
@@ -3714,9 +3791,8 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
if (cond == NULL)
return BAD_FUNC_ARG;
if (pthread_cond_destroy(cond) != 0)
return MEMORY_E;
dispatch_release(*cond);
*cond = NULL;
return 0;
}
@@ -3725,26 +3801,19 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
if (cond == NULL)
return BAD_FUNC_ARG;
if (pthread_cond_signal(cond) != 0)
return MEMORY_E;
dispatch_semaphore_signal(*cond);
return 0;
}
int wolfSSL_CondWait(COND_TYPE* cond,
wolfSSL_Mutex* mutex)
int wolfSSL_CondWait(COND_TYPE* cond)
{
if (cond == NULL || mutex == NULL)
if (cond == 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_E;
dispatch_semaphore_wait(*cond, DISPATCH_TIME_FOREVER);
return 0;
}
#endif /* __MACH__ */
#endif /* WOLFSSL_COND */
#endif

2
wolfssl/quic.h
View File

@@ -52,7 +52,7 @@ typedef struct wolfssl_quic_method_t WOLFSSL_QUIC_METHOD;
struct wolfssl_quic_method_t {
/**
* Provide secrets to the QUIC stack when they becaome available in the SSL
* Provide secrets to the QUIC stack when they become available in the SSL
* instance during handshake processing. read/write secrets have the same
* length. A call may only provide one, passing NULL as the other.
*/

3
wolfssl/ssl.h
View File

@@ -525,6 +525,9 @@ struct WOLFSSL_BIO_METHOD {
wolfssl_BIO_meth_ctrl_info_cb ctrlInfoCb;
};
#define WOLFSSL_BIO_METHOD_INIT(bio_type) \
{ bio_type, { 0 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
/* wolfSSL BIO type */
typedef long (*wolf_bio_info_cb)(WOLFSSL_BIO *bio, int event, const char *parg,
int iarg, long larg, long return_value);

52
wolfssl/test.h
View File

@@ -551,11 +551,9 @@ static WC_INLINE void InitTcpReady(tcp_ready* ready)
ready->srfName = NULL;
#ifndef SINGLE_THREADED
THREAD_CHECK_RET(wc_InitMutex(&ready->mutex));
#ifdef WOLFSSL_COND
THREAD_CHECK_RET(wc_InitMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondInit(&ready->cond));
#else /* No signaling available, rely only on the mutex */
THREAD_CHECK_RET(wc_InitMutex(&ready->mutex));
#endif
#endif
}
@@ -567,11 +565,9 @@ static WC_INLINE void InitTcpReady(tcp_ready* ready)
static WC_INLINE void FreeTcpReady(tcp_ready* ready)
{
#ifndef SINGLE_THREADED
THREAD_CHECK_RET(wc_FreeMutex(&ready->mutex));
#ifdef WOLFSSL_COND
THREAD_CHECK_RET(wc_FreeMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondFree(&ready->cond));
#else /* No signaling available, rely only on the mutex */
THREAD_CHECK_RET(wc_FreeMutex(&ready->mutex));
#endif
#else
(void)ready;
@@ -695,24 +691,18 @@ static WC_INLINE void srtp_helper_init(srtp_test_helper *srtp)
static WC_INLINE void srtp_helper_get_ekm(srtp_test_helper *srtp,
uint8_t **ekm, size_t *size)
{
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_LockMutex(&srtp->mutex));
#endif
if (srtp->server_srtp_ekm == NULL)
THREAD_CHECK_RET(wolfSSL_CondWait(&srtp->cond, &srtp->mutex));
#ifdef COND_NO_REQUIRE_LOCKED_MUTEX
if (srtp->server_srtp_ekm == NULL) {
THREAD_CHECK_RET(wc_UnLockMutex(&srtp->mutex));
THREAD_CHECK_RET(wolfSSL_CondWait(&srtp->cond));
THREAD_CHECK_RET(wc_LockMutex(&srtp->mutex));
#endif
}
*ekm = srtp->server_srtp_ekm;
*size = srtp->server_srtp_ekm_size;
/* reset */
srtp->server_srtp_ekm = NULL;
srtp->server_srtp_ekm_size = 0;
THREAD_CHECK_RET(wc_UnLockMutex(&srtp->mutex));
}
@@ -731,17 +721,10 @@ static WC_INLINE void srtp_helper_set_ekm(srtp_test_helper *srtp,
uint8_t *ekm, size_t size)
{
THREAD_CHECK_RET(wc_LockMutex(&srtp->mutex));
srtp->server_srtp_ekm_size = size;
srtp->server_srtp_ekm = ekm;
#ifdef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&srtp->mutex));
#endif
THREAD_CHECK_RET(wolfSSL_CondSignal(&srtp->cond));
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&srtp->mutex));
#endif
}
static WC_INLINE void srtp_helper_free(srtp_test_helper *srtp)
@@ -750,7 +733,8 @@ static WC_INLINE void srtp_helper_free(srtp_test_helper *srtp)
THREAD_CHECK_RET(wolfSSL_CondFree(&srtp->cond));
}
#endif /* WOLFSSL_SRTP && !SINGLE_THREADED && POSIX_THREADS */
#endif /* WOLFSSL_SRTP && WOLFSSL_COND */
/**
*
@@ -2237,19 +2221,12 @@ static WC_INLINE void udp_accept(SOCKET_T* sockfd, SOCKET_T* clientfd,
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
ready->ready = 1;
ready->port = port;
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#ifdef WOLFSSL_COND
/* signal ready to accept data */
#ifdef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#endif
THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#endif
#else
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#endif
#endif
#endif /* !SINGLE_THREADED */
}
else {
fprintf(stderr, "args or args->signal was NULL. Not setting ready info.");
@@ -2283,17 +2260,12 @@ static WC_INLINE void tcp_accept(SOCKET_T* sockfd, SOCKET_T* clientfd,
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
ready->ready = 1;
ready->port = port;
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#ifdef WOLFSSL_COND
#ifdef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#endif
THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
#ifndef COND_NO_REQUIRE_LOCKED_MUTEX
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#endif
#endif
}
#endif
#endif /* !SINGLE_THREADED */
if (ready_file) {
#if !defined(NO_FILESYSTEM) || defined(FORCE_BUFFER_TEST) && \

17
wolfssl/wolfcrypt/types.h
View File

@@ -1380,9 +1380,18 @@ typedef struct w64wrapper {
#define WOLFSSL_THREAD
#elif (defined(_POSIX_THREADS) || defined(HAVE_PTHREAD)) && \
!defined(__MINGW32__)
#ifndef __MACH__
#include <pthread.h>
typedef struct COND_TYPE {
pthread_mutex_t mutex;
pthread_cond_t cond;
} COND_TYPE;
#else
#include <dispatch/dispatch.h>
typedef dispatch_semaphore_t COND_TYPE;
#endif
typedef void* THREAD_RETURN;
typedef pthread_t THREAD_TYPE;
typedef pthread_cond_t COND_TYPE;
#define WOLFSSL_COND
#define WOLFSSL_THREAD
#ifndef HAVE_SELFTEST
@@ -1398,7 +1407,6 @@ typedef struct w64wrapper {
typedef HANDLE COND_TYPE;
#define WOLFSSL_COND
#define INVALID_THREAD_VAL ((THREAD_TYPE)(INVALID_HANDLE_VALUE))
#define COND_NO_REQUIRE_LOCKED_MUTEX
#define WOLFSSL_THREAD __stdcall
#define WOLFSSL_THREAD_NO_JOIN __cdecl
#else
@@ -1433,8 +1441,6 @@ typedef struct w64wrapper {
* thread callbacks that don't require cleanup
* WOLFSSL_COND - defined if this system suports signaling
* COND_TYPE - type that should be passed into the signaling API
* COND_NO_REQUIRE_LOCKED_MUTEX - defined if the signaling doesn't
* require locking a mutex
* WOLFSSL_THREAD_VOID_RETURN - defined if the thread callback has a
* void return
* WOLFSSL_RETURN_FROM_THREAD - define used to correctly return from a
@@ -1475,8 +1481,7 @@ typedef struct w64wrapper {
WOLFSSL_API int wolfSSL_CondInit(COND_TYPE* cond);
WOLFSSL_API int wolfSSL_CondFree(COND_TYPE* cond);
WOLFSSL_API int wolfSSL_CondSignal(COND_TYPE* cond);
WOLFSSL_API int wolfSSL_CondWait(COND_TYPE* cond,
wolfSSL_Mutex* mutex);
WOLFSSL_API int wolfSSL_CondWait(COND_TYPE* cond);
#endif
#else
#define WOLFSSL_RETURN_FROM_THREAD(x) return (THREAD_RETURN)(x)