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

Merge pull request #6697 from julek-wolfssl/refactor-cond-again

Browse Source 
Refactor conditional code again
This commit is contained in:
JacobBarthelmeh
2023-08-10 13:49:46 -06:00
committed by GitHub
parent 26fcdbf348 c3fea8c930
commit 65401cfd35
8 changed files with 240 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
examples/benchmark/tls_bench.c
View File

@ -307,7 +307,6 @@ typedef struct {
int read_bytes;
int read_idx;
wolfSSL_Mutex mutex;
COND_TYPE cond;
int done;
@ -398,12 +397,12 @@ static double gettime_secs(int reset)
/* server send callback */
static int ServerMemSend(info_t* info, char* buf, int sz)
{
THREAD_CHECK_RET(wc_LockMutex(&info->to_client.mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_client.cond));
#ifndef BENCH_USE_NONBLOCK
/* check for overflow */
if (info->to_client.write_idx + sz > MEM_BUFFER_SZ) {
THREAD_CHECK_RET(wc_UnLockMutex(&info->to_client.mutex));
THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
fprintf(stderr, "ServerMemSend overflow\n");
return -1;
}
@ -416,9 +415,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(wolfSSL_CondEnd(&info->to_client.cond));
#ifdef BENCH_USE_NONBLOCK
if (sz == 0) {
@ -431,14 +430,12 @@ static int ServerMemSend(info_t* info, char* buf, int sz)
/* server recv callback */
static int ServerMemRecv(info_t* info, char* buf, int sz)
{
THREAD_CHECK_RET(wc_LockMutex(&info->to_server.mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_server.cond));
#ifndef BENCH_USE_NONBLOCK
while (info->to_server.write_idx - info->to_server.read_idx < sz &&
!info->to_client.done) {
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) {
@ -456,7 +453,7 @@ static int ServerMemRecv(info_t* info, char* buf, int sz)
info->to_server.write_bytes = info->to_server.write_idx = 0;
}
THREAD_CHECK_RET(wc_UnLockMutex(&info->to_server.mutex));
THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
if (info->to_client.done != 0) {
return -1;
@ -473,14 +470,14 @@ static int ServerMemRecv(info_t* info, char* buf, int sz)
/* client send callback */
static int ClientMemSend(info_t* info, char* buf, int sz)
{
THREAD_CHECK_RET(wc_LockMutex(&info->to_server.mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_server.cond));
#ifndef BENCH_USE_NONBLOCK
/* check for overflow */
if (info->to_server.write_idx + sz > MEM_BUFFER_SZ) {
fprintf(stderr, "ClientMemSend overflow %d %d %d\n",
info->to_server.write_idx, sz, MEM_BUFFER_SZ);
THREAD_CHECK_RET(wc_UnLockMutex(&info->to_server.mutex));
THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
return -1;
}
#else
@ -493,8 +490,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(wc_UnLockMutex(&info->to_server.mutex));
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
#ifdef BENCH_USE_NONBLOCK
if (sz == 0) {
@ -507,14 +504,12 @@ static int ClientMemSend(info_t* info, char* buf, int sz)
/* client recv callback */
static int ClientMemRecv(info_t* info, char* buf, int sz)
{
THREAD_CHECK_RET(wc_LockMutex(&info->to_client.mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_client.cond));
#ifndef BENCH_USE_NONBLOCK
while (info->to_client.write_idx - info->to_client.read_idx < sz &&
!info->to_server.done) {
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) {
@ -532,7 +527,7 @@ static int ClientMemRecv(info_t* info, char* buf, int sz)
info->to_client.write_bytes = info->to_client.write_idx = 0;
}
THREAD_CHECK_RET(wc_UnLockMutex(&info->to_client.mutex));
THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
if (info->to_server.done != 0) {
return -1;
@ -1054,15 +1049,13 @@ static int bench_tls_client(info_t* info)
#if !defined(SINGLE_THREADED) && defined(WOLFSSL_DTLS)
/* synchronize with server */
if (info->doDTLS && !info->clientOrserverOnly) {
THREAD_CHECK_RET(wc_LockMutex(&info->dtls_mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&info->dtls_cond));
if (info->serverReady != 1) {
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;
THREAD_CHECK_RET(wc_UnLockMutex(&info->dtls_mutex));
THREAD_CHECK_RET(wolfSSL_CondEnd(&info->dtls_cond));
}
#endif
/* perform connect */
@ -1204,9 +1197,11 @@ static THREAD_RETURN WOLFSSL_THREAD_NO_JOIN client_thread(void* args)
ret = bench_tls_client(info);
THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_server.cond));
info->to_client.done = 1;
info->client.ret = ret;
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
WOLFSSL_RETURN_FROM_THREAD(NULL);
}
@ -1292,10 +1287,10 @@ static int SocketWaitClient(info_t* info)
char msg[64];
#ifndef SINGLE_THREADED
if (!info->clientOrserverOnly) {
THREAD_CHECK_RET(wc_LockMutex(&info->dtls_mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&info->dtls_cond));
info->serverReady = 1;
THREAD_CHECK_RET(wc_UnLockMutex(&info->dtls_mutex));
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->dtls_cond));
THREAD_CHECK_RET(wolfSSL_CondEnd(&info->dtls_cond));
}
#endif
connd = (int)recvfrom(info->listenFd, (char *)msg, sizeof(msg),
@ -1662,9 +1657,11 @@ static THREAD_RETURN WOLFSSL_THREAD_NO_JOIN server_thread(void* args)
}
}
THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_client.cond));
info->to_server.done = 1;
info->server.ret = ret;
THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_client.cond));
THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
WOLFSSL_RETURN_FROM_THREAD(NULL);
}
@ -2127,8 +2124,6 @@ int bench_tls(void* args)
else {
#if !defined(SINGLE_THREADED) && defined(WOLFSSL_THREAD_NO_JOIN)
info->useLocalMem = argLocalMem;
THREAD_CHECK_RET(wc_InitMutex(&info->to_server.mutex));
THREAD_CHECK_RET(wc_InitMutex(&info->to_client.mutex));
#ifdef WOLFSSL_DTLS
THREAD_CHECK_RET(wc_InitMutex(&info->dtls_mutex));
THREAD_CHECK_RET(wolfSSL_CondInit(&info->dtls_cond));

65
examples/client/client.c
View File

@ -1066,6 +1066,55 @@ static int ClientRead(WOLFSSL* ssl, char* reply, int replyLen, int mustRead,
return err;
}
static int ClientWriteRead(WOLFSSL* ssl, const char* msg, int msgSz,
char* reply, int replyLen, int mustRead,
const char* str, int exitWithRet)
{
int ret = 0;
do {
ret = ClientWrite(ssl, msg, msgSz, str, exitWithRet);
if (ret != 0) {
if (!exitWithRet)
err_sys("ClientWrite failed");
else
break;
}
if (wolfSSL_dtls(ssl)) {
ret = tcp_select(wolfSSL_get_fd(ssl), DEFAULT_TIMEOUT_SEC);
if (ret == TEST_TIMEOUT) {
continue;
}
else if (ret == TEST_RECV_READY) {
/* Ready to read */
}
else {
LOG_ERROR("%s tcp_select error\n", str);
if (!exitWithRet)
err_sys("tcp_select failed");
else
ret = WOLFSSL_FATAL_ERROR;
break;
}
}
ret = ClientRead(ssl, reply, replyLen, mustRead, str, exitWithRet);
if (mustRead && ret != 0) {
if (!exitWithRet)
err_sys("ClientRead failed");
else
break;
}
break;
} while (1);
if (ret != 0) {
char buffer[WOLFSSL_MAX_ERROR_SZ];
LOG_ERROR("SSL_write%s msg error %d, %s\n", str, ret,
wolfSSL_ERR_error_string(ret, buffer));
}
return ret;
}
/* when adding new option, please follow the steps below: */
/* 1. add new option message in English section */
@ -4195,15 +4244,8 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
wolfSSL_update_keys(ssl);
#endif
err = ClientWrite(ssl, msg, msgSz, "", exitWithRet);
if (exitWithRet && (err != 0)) {
((func_args*)args)->return_code = err;
wolfSSL_free(ssl); ssl = NULL;
wolfSSL_CTX_free(ctx); ctx = NULL;
goto exit;
}
err = ClientRead(ssl, reply, sizeof(reply)-1, 1, "", exitWithRet);
err = ClientWriteRead(ssl, msg, msgSz, reply, sizeof(reply)-1, 1, "",
exitWithRet);
if (exitWithRet && (err != 0)) {
((func_args*)args)->return_code = err;
wolfSSL_free(ssl); ssl = NULL;
@ -4500,10 +4542,9 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
msgSz = (int)XSTRLEN(kResumeMsg);
XMEMCPY(msg, kResumeMsg, msgSz);
}
(void)ClientWrite(sslResume, msg, msgSz, " resume", 0);
(void)ClientRead(sslResume, reply, sizeof(reply)-1, sendGET,
"Server resume: ", 0);
(void)ClientWriteRead(sslResume, msg, msgSz, reply, sizeof(reply)-1,
sendGET, " resume", 0);
ret = wolfSSL_shutdown(sslResume);
if (wc_shutdown && ret == WOLFSSL_SHUTDOWN_NOT_DONE)

4
examples/echoserver/echoserver.c
View File

@ -71,11 +71,11 @@ static void SignalReady(void* args, word16 port)
/* signal ready to tcp_accept */
func_args* server_args = (func_args*)args;
tcp_ready* ready = server_args->signal;
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
ready->ready = 1;
ready->port = port;
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
#endif /* NO_MAIN_DRIVER && WOLFSSL_COND */
(void)args;
(void)port;

57
src/crl.c
View File

@ -928,24 +928,20 @@ int wolfSSL_X509_STORE_add_crl(WOLFSSL_X509_STORE *store, WOLFSSL_X509_CRL *newc
/* Signal Monitor thread is setup, save status to setup flag, 0 on success */
static int SignalSetup(WOLFSSL_CRL* crl, int status)
{
int ret;
int ret, condRet;
/* signal to calling thread we're setup */
if (wc_LockMutex(&crl->crlLock) != 0) {
WOLFSSL_MSG("wc_LockMutex crlLock failed");
return BAD_MUTEX_E;
}
crl->setup = status;
if (wc_UnLockMutex(&crl->crlLock) != 0) {
WOLFSSL_MSG("wc_UnLockMutex crlLock failed");
return BAD_MUTEX_E;
}
ret = wolfSSL_CondSignal(&crl->cond);
ret = wolfSSL_CondStart(&crl->cond);
if (ret != 0)
return BAD_COND_E;
return ret;
return 0;
crl->setup = status;
condRet = wolfSSL_CondSignal(&crl->cond);
ret = wolfSSL_CondEnd(&crl->cond);
if (ret != 0)
return ret;
return condRet;
}
@ -1248,18 +1244,9 @@ static THREAD_RETURN WOLFSSL_THREAD DoMonitor(void* arg)
}
}
#ifdef WOLFSSL_SMALL_STACK
buff = (char*)XMALLOC(8192, NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (buff == NULL)
return NULL;
#endif
/* signal to calling thread we're setup */
if (SignalSetup(crl, 1) != 0) {
#ifdef WOLFSSL_SMALL_STACK
XFREE(buff, NULL, DYNAMIC_TYPE_TMP_BUFFER);
#endif
if (wd > 0) {
if (inotify_rm_watch(notifyFd, wd) < 0)
WOLFSSL_MSG("inotify_rm_watch #1 failed in DoMonitor");
@ -1269,6 +1256,12 @@ static THREAD_RETURN WOLFSSL_THREAD DoMonitor(void* arg)
return NULL;
}
#ifdef WOLFSSL_SMALL_STACK
buff = (char*)XMALLOC(8192, NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (buff == NULL)
return NULL;
#endif
for (;;) {
fd_set readfds;
int result;
@ -1489,21 +1482,13 @@ static int StartMonitorCRL(WOLFSSL_CRL* crl)
}
/* wait for setup to complete */
if (wc_LockMutex(&crl->crlLock) != 0) {
WOLFSSL_MSG("wc_LockMutex crlLock failed");
if (wolfSSL_CondStart(&crl->cond) != 0) {
WOLFSSL_MSG("wolfSSL_CondStart failed");
return BAD_MUTEX_E;
}
while (crl->setup == 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;
@ -1516,8 +1501,8 @@ static int StartMonitorCRL(WOLFSSL_CRL* crl)
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");
if (wolfSSL_CondEnd(&crl->cond) != 0) {
WOLFSSL_MSG("wolfSSL_CondEnd failed");
return BAD_MUTEX_E;
}

10
tests/utils.c
View File

@ -320,10 +320,10 @@ int test_memio_setup(struct test_memio_ctx *ctx,
#if !defined(SINGLE_THREADED) && defined(WOLFSSL_COND)
void signal_ready(tcp_ready* ready)
{
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
ready->ready = 1;
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
}
#endif
@ -331,14 +331,12 @@ void wait_tcp_ready(func_args* args)
{
#if !defined(SINGLE_THREADED) && defined(WOLFSSL_COND)
tcp_ready* ready = args->signal;
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
if (!ready->ready) {
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondWait(&ready->cond));
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
}
ready->ready = 0; /* reset */
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
#else
/* no threading wait or single threaded */
(void)args;

147
wolfcrypt/src/wc_port.c
View File

@ -3462,10 +3462,16 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
if (cond == NULL)
return BAD_FUNC_ARG;
*cond = CreateEventA(NULL, FALSE, FALSE, NULL);
if (*cond == NULL)
cond->cond = CreateEventA(NULL, FALSE, FALSE, NULL);
if (cond->cond == NULL)
return MEMORY_E;
if (wc_InitMutex(&cond->mutex) != 0) {
if (CloseHandle(cond->cond) == 0)
return MEMORY_E;
return MEMORY_E;
}
return 0;
}
@ -3474,20 +3480,37 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
if (cond == NULL)
return BAD_FUNC_ARG;
if (CloseHandle(*cond) == 0)
if (CloseHandle(cond->cond) == 0)
return MEMORY_E;
return 0;
}
int wolfSSL_CondStart(COND_TYPE* cond)
{
if (cond == NULL)
return BAD_FUNC_ARG;
if (wc_LockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
return 0;
}
int wolfSSL_CondSignal(COND_TYPE* cond)
{
if (cond == NULL)
return BAD_FUNC_ARG;
if (SetEvent(*cond) == 0)
if (wc_UnLockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
if (SetEvent(cond->cond) == 0)
return MEMORY_E;
if (wc_LockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
return 0;
}
@ -3496,9 +3519,26 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
if (cond == NULL)
return BAD_FUNC_ARG;
if (WaitForSingleObject(*cond, INFINITE) == WAIT_FAILED)
if (wc_UnLockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
if (WaitForSingleObject(cond->cond, INFINITE) == WAIT_FAILED)
return MEMORY_E;
if (wc_LockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
return 0;
}
int wolfSSL_CondEnd(COND_TYPE* cond)
{
if (cond == NULL)
return BAD_FUNC_ARG;
if (wc_UnLockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
return 0;
}
#endif /* WOLFSSL_COND */
@ -3731,42 +3771,48 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
return ret;
}
int wolfSSL_CondSignal(COND_TYPE* cond)
int wolfSSL_CondStart(COND_TYPE* cond)
{
int ret = 0;
if (cond == NULL)
return BAD_FUNC_ARG;
if (pthread_mutex_lock(&cond->mutex) != 0)
return BAD_MUTEX_E;
return 0;
}
int wolfSSL_CondSignal(COND_TYPE* cond)
{
if (cond == NULL)
return BAD_FUNC_ARG;
if (pthread_cond_signal(&cond->cond) != 0)
ret = MEMORY_E;
return MEMORY_E;
if (pthread_mutex_unlock(&cond->mutex) != 0)
ret = MEMORY_E;
return ret;
return 0;
}
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;
return MEMORY_E;
return 0;
}
int wolfSSL_CondEnd(COND_TYPE* cond)
{
if (cond == NULL)
return BAD_FUNC_ARG;
if (pthread_mutex_unlock(&cond->mutex) != 0)
ret = MEMORY_E;
return BAD_MUTEX_E;
return ret;
return 0;
}
#else /* __MACH__ */
/* Apple style dispatch semaphore */
@ -3780,9 +3826,15 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
* dispatch_semaphore_create(). work around this by initing
* with 0, then incrementing it afterwards.
*/
*cond = dispatch_semaphore_create(0);
if (*cond == NULL)
cond->cond = dispatch_semaphore_create(0);
if (cond->cond == NULL)
return MEMORY_E;
if (wc_InitMutex(&cond->mutex) != 0) {
dispatch_release(cond->cond);
return MEMORY_E;
}
return 0;
}
@ -3791,8 +3843,24 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
if (cond == NULL)
return BAD_FUNC_ARG;
dispatch_release(*cond);
*cond = NULL;
dispatch_release(cond->cond);
cond->cond = NULL;
if (wc_FreeMutex(&cond->mutex) != 0) {
return MEMORY_E;
}
return 0;
}
int wolfSSL_CondStart(COND_TYPE* cond)
{
if (cond == NULL)
return BAD_FUNC_ARG;
if (wc_LockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
return 0;
}
@ -3801,7 +3869,14 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
if (cond == NULL)
return BAD_FUNC_ARG;
dispatch_semaphore_signal(*cond);
if (wc_UnLockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
dispatch_semaphore_signal(cond->cond);
if (wc_LockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
return 0;
}
@ -3810,7 +3885,25 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
if (cond == NULL)
return BAD_FUNC_ARG;
dispatch_semaphore_wait(*cond, DISPATCH_TIME_FOREVER);
if (wc_UnLockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
dispatch_semaphore_wait(cond->cond, DISPATCH_TIME_FOREVER);
if (wc_LockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
return 0;
}
int wolfSSL_CondEnd(COND_TYPE* cond)
{
if (cond == NULL)
return BAD_FUNC_ARG;
if (wc_UnLockMutex(&cond->mutex) != 0)
return BAD_MUTEX_E;
return 0;
}
#endif /* __MACH__ */

22
wolfssl/test.h
View File

@ -691,11 +691,9 @@ 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)
{
THREAD_CHECK_RET(wc_LockMutex(&srtp->mutex));
THREAD_CHECK_RET(wolfSSL_CondStart(&srtp->cond));
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));
}
*ekm = srtp->server_srtp_ekm;
*size = srtp->server_srtp_ekm_size;
@ -703,7 +701,7 @@ static WC_INLINE void srtp_helper_get_ekm(srtp_test_helper *srtp,
/* reset */
srtp->server_srtp_ekm = NULL;
srtp->server_srtp_ekm_size = 0;
THREAD_CHECK_RET(wc_UnLockMutex(&srtp->mutex));
THREAD_CHECK_RET(wolfSSL_CondEnd(&srtp->cond));
}
/**
@ -720,11 +718,11 @@ static WC_INLINE void srtp_helper_get_ekm(srtp_test_helper *srtp,
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));
THREAD_CHECK_RET(wolfSSL_CondStart(&srtp->cond));
srtp->server_srtp_ekm_size = size;
srtp->server_srtp_ekm = ekm;
THREAD_CHECK_RET(wc_UnLockMutex(&srtp->mutex));
THREAD_CHECK_RET(wolfSSL_CondSignal(&srtp->cond));
THREAD_CHECK_RET(wolfSSL_CondEnd(&srtp->cond));
}
static WC_INLINE void srtp_helper_free(srtp_test_helper *srtp)
@ -2218,13 +2216,15 @@ static WC_INLINE void udp_accept(SOCKET_T* sockfd, SOCKET_T* clientfd,
if (args != NULL && args->signal != NULL) {
#ifndef SINGLE_THREADED
tcp_ready* ready = args->signal;
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
#ifdef WOLFSSL_COND
THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
#endif
ready->ready = 1;
ready->port = port;
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#ifdef WOLFSSL_COND
/* signal ready to accept data */
THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
#endif
#endif /* !SINGLE_THREADED */
}
@ -2257,12 +2257,14 @@ static WC_INLINE void tcp_accept(SOCKET_T* sockfd, SOCKET_T* clientfd,
if (args)
ready = args->signal;
if (ready) {
THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
#ifdef WOLFSSL_COND
THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
#endif
ready->ready = 1;
ready->port = port;
THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
#ifdef WOLFSSL_COND
THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
#endif
}
#endif /* !SINGLE_THREADED */

12
wolfssl/wolfcrypt/types.h
View File

@ -1388,7 +1388,10 @@ typedef struct w64wrapper {
} COND_TYPE;
#else
#include <dispatch/dispatch.h>
typedef dispatch_semaphore_t COND_TYPE;
typedef struct COND_TYPE {
wolfSSL_Mutex mutex;
dispatch_semaphore_t cond;
} COND_TYPE;
#endif
typedef void* THREAD_RETURN;
typedef pthread_t THREAD_TYPE;
@ -1404,7 +1407,10 @@ typedef struct w64wrapper {
#elif defined(_MSC_VER)
typedef unsigned THREAD_RETURN;
typedef uintptr_t THREAD_TYPE;
typedef HANDLE COND_TYPE;
typedef struct COND_TYPE {
wolfSSL_Mutex mutex;
HANDLE cond;
} COND_TYPE;
#define WOLFSSL_COND
#define INVALID_THREAD_VAL ((THREAD_TYPE)(INVALID_HANDLE_VALUE))
#define WOLFSSL_THREAD __stdcall
@ -1482,6 +1488,8 @@ typedef struct w64wrapper {
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_API int wolfSSL_CondStart(COND_TYPE* cond);
WOLFSSL_API int wolfSSL_CondEnd(COND_TYPE* cond);
#endif
#else
#define WOLFSSL_RETURN_FROM_THREAD(x) return (THREAD_RETURN)(x)