mirror/openssl
2
0
Fork 0
mirror of https://github.com/openssl/openssl.git synced 2024-12-21 06:09:35 +08:00
Code Issues Packages Projects Releases Wiki Activity
1d6c86709c
openssl/test/asynctest.c

435 lines
13 KiB
C
Raw Normal View History

Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
/*
Update copyright year Reviewed-by: Nicola Tuveri <nic.tuv@gmail.com> (Merged from https://github.com/openssl/openssl/pull/12463)
2020-07-16 20:47:04 +08:00
* Copyright 2015-2020 The OpenSSL Project Authors. All Rights Reserved.
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
*
Following the license change, modify the boilerplates in test/ Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/7767)
2018-12-06 20:05:25 +08:00
* Licensed under the Apache License 2.0 (the "License"). You may not use
Copyright consolidation 02/10 Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-05-18 02:20:24 +08:00
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
*/
include/openssl: don't include <windows.h> in public headers. If application uses any of Windows-specific interfaces, make it application developer's respondibility to include <windows.h>. Rationale is that <windows.h> is quite "toxic" and is sensitive to inclusion order (most notably in relation to <winsock2.h>). It's only natural to give complete control to the application developer. Reviewed-by: Rich Salz <rsalz@openssl.org> Reviewed-by: Matt Caswell <matt@openssl.org>
2016-06-26 19:40:15 +08:00
#ifdef _WIN32
# include <windows.h>
#endif
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
#include <stdio.h>
#include <string.h>
#include <openssl/async.h>
#include <openssl/crypto.h>
static int ctr = 0;
static ASYNC_JOB *currjob = NULL;
static int only_pause(void *args)
{
ASYNC_pause_job();
return 1;
}
static int add_two(void *args)
{
ctr++;
ASYNC_pause_job();
ctr++;
return 2;
}
static int save_current(void *args)
{
currjob = ASYNC_get_current_job();
ASYNC_pause_job();
return 1;
}
Add a test to make sure ASYNC aware code gets the right default libctx Even if a fibre changes the default libctx - or the main application code changes it, the "current" default libctx should remain consistent. Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/12228)
2020-06-26 18:02:29 +08:00
static int change_deflt_libctx(void *args)
{
OPENSSL_CTX *libctx = OPENSSL_CTX_new();
OPENSSL_CTX *oldctx, *tmpctx;
int ret = 0;
if (libctx == NULL)
return 0;
oldctx = OPENSSL_CTX_set0_default(libctx);
ASYNC_pause_job();
/* Check the libctx is set up as we expect */
tmpctx = OPENSSL_CTX_set0_default(oldctx);
if (tmpctx != libctx)
goto err;
/* Set it back again to continue to use our own libctx */
oldctx = OPENSSL_CTX_set0_default(libctx);
ASYNC_pause_job();
/* Check the libctx is set up as we expect */
tmpctx = OPENSSL_CTX_set0_default(oldctx);
if (tmpctx != libctx)
goto err;
ret = 1;
err:
OPENSSL_CTX_free(libctx);
return ret;
}
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
#define MAGIC_WAIT_FD ((OSSL_ASYNC_FD)99)
static int waitfd(void *args)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
{
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_JOB *job;
ASYNC_WAIT_CTX *waitctx;
job = ASYNC_get_current_job();
if (job == NULL)
return 0;
waitctx = ASYNC_get_wait_ctx(job);
if (waitctx == NULL)
return 0;
Add test to show wrong behavior of ASYNC_WAIT_CTX This happens when a fd is added and then immediately removed from the ASYNC_WAIT_CTX before pausing the job. Reviewed-by: Rich Salz <rsalz@openssl.org> Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/2581)
2017-01-26 11:17:54 +08:00
/* First case: no fd added or removed */
ASYNC_pause_job();
/* Second case: one fd added */
Fix a few if(, for(, while( inside code. Fix some indentation at the same time Reviewed-by: Matt Caswell <matt@openssl.org> Reviewed-by: Rich Salz <rsalz@openssl.org> (Merged from https://github.com/openssl/openssl/pull/1292)
2016-06-29 06:18:50 +08:00
if (!ASYNC_WAIT_CTX_set_wait_fd(waitctx, waitctx, MAGIC_WAIT_FD, NULL, NULL))
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
return 0;
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
ASYNC_pause_job();
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
Add test to show wrong behavior of ASYNC_WAIT_CTX This happens when a fd is added and then immediately removed from the ASYNC_WAIT_CTX before pausing the job. Reviewed-by: Rich Salz <rsalz@openssl.org> Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/2581)
2017-01-26 11:17:54 +08:00
/* Third case: all fd removed */
if (!ASYNC_WAIT_CTX_clear_fd(waitctx, waitctx))
return 0;
ASYNC_pause_job();
/* Last case: fd added and immediately removed */
if (!ASYNC_WAIT_CTX_set_wait_fd(waitctx, waitctx, MAGIC_WAIT_FD, NULL, NULL))
return 0;
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
if (!ASYNC_WAIT_CTX_clear_fd(waitctx, waitctx))
return 0;
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
return 1;
}
Add ASYNC_block_pause and ASYNC_unblock_pause There are potential deadlock situations that can occur if code executing within the context of a job aquires a lock, and then pauses the job. This adds an ability to temporarily block pauses from occuring whilst performing work and holding a lock. Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-11-12 18:42:08 +08:00
static int blockpause(void *args)
{
ASYNC_block_pause();
ASYNC_pause_job();
ASYNC_unblock_pause();
ASYNC_pause_job();
return 1;
}
Use void in all function definitions that do not take any arguments Reviewed-by: Rich Salz <rsalz@openssl.org> GH: #6208
2018-05-09 23:09:50 +08:00
static int test_ASYNC_init_thread(void)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
{
ASYNC_JOB *job1 = NULL, *job2 = NULL, *job3 = NULL;
int funcret1, funcret2, funcret3;
Fix use before init warnings in asynctest If the tests fail early before an ASYNC_WAIT_CTX is created then there can be a use before init problem in asynctest. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-29 21:07:28 +08:00
ASYNC_WAIT_CTX *waitctx = NULL;
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
if ( !ASYNC_init_thread(2, 0)
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| (waitctx = ASYNC_WAIT_CTX_new()) == NULL
|| ASYNC_start_job(&job1, waitctx, &funcret1, only_pause, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_PAUSE
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job2, waitctx, &funcret2, only_pause, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_PAUSE
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job3, waitctx, &funcret3, only_pause, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_NO_JOBS
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job1, waitctx, &funcret1, only_pause, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_FINISH
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job3, waitctx, &funcret3, only_pause, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_PAUSE
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job2, waitctx, &funcret2, only_pause, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_FINISH
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job3, waitctx, &funcret3, only_pause, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_FINISH
|| funcret1 != 1
|| funcret2 != 1
|| funcret3 != 1) {
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
fprintf(stderr, "test_ASYNC_init_thread() failed\n");
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
return 0;
}
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
return 1;
}
add an additional async notification communication method based on callback Reviewed-by: Matt Caswell <matt@openssl.org> Reviewed-by: Paul Yang <yang.yang@baishancloud.com> Signed-off-by: Ping Yu <ping.yu@intel.com> Signed-off-by: Steven Linsell <stevenx.linsell@intel.com> (Merged from https://github.com/openssl/openssl/pull/7573)
2018-11-06 04:41:01 +08:00
static int test_callback(void *arg)
{
printf("callback test pass\n");
return 1;
}
static int test_ASYNC_callback_status(void)
{
ASYNC_WAIT_CTX *waitctx = NULL;
int set_arg = 100;
ASYNC_callback_fn get_callback;
void *get_arg;
int set_status = 1;
if ( !ASYNC_init_thread(1, 0)
|| (waitctx = ASYNC_WAIT_CTX_new()) == NULL
|| ASYNC_WAIT_CTX_set_callback(waitctx, test_callback, (void*)&set_arg)
!= 1
|| ASYNC_WAIT_CTX_get_callback(waitctx, &get_callback, &get_arg)
!= 1
|| test_callback != get_callback
|| get_arg != (void*)&set_arg
|| (*get_callback)(get_arg) != 1
|| ASYNC_WAIT_CTX_set_status(waitctx, set_status) != 1
|| set_status != ASYNC_WAIT_CTX_get_status(waitctx)) {
fprintf(stderr, "test_ASYNC_callback_status() failed\n");
ASYNC_WAIT_CTX_free(waitctx);
ASYNC_cleanup_thread();
return 0;
}
ASYNC_WAIT_CTX_free(waitctx);
ASYNC_cleanup_thread();
return 1;
}
Use void in all function definitions that do not take any arguments Reviewed-by: Rich Salz <rsalz@openssl.org> GH: #6208
2018-05-09 23:09:50 +08:00
static int test_ASYNC_start_job(void)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
{
ASYNC_JOB *job = NULL;
int funcret;
Fix use before init warnings in asynctest If the tests fail early before an ASYNC_WAIT_CTX is created then there can be a use before init problem in asynctest. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-29 21:07:28 +08:00
ASYNC_WAIT_CTX *waitctx = NULL;
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
ctr = 0;
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
if ( !ASYNC_init_thread(1, 0)
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| (waitctx = ASYNC_WAIT_CTX_new()) == NULL
|| ASYNC_start_job(&job, waitctx, &funcret, add_two, NULL, 0)
!= ASYNC_PAUSE
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
|| ctr != 1
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job, waitctx, &funcret, add_two, NULL, 0)
!= ASYNC_FINISH
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
|| ctr != 2
|| funcret != 2) {
fprintf(stderr, "test_ASYNC_start_job() failed\n");
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
return 0;
}
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
return 1;
}
Use void in all function definitions that do not take any arguments Reviewed-by: Rich Salz <rsalz@openssl.org> GH: #6208
2018-05-09 23:09:50 +08:00
static int test_ASYNC_get_current_job(void)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
{
ASYNC_JOB *job = NULL;
int funcret;
Fix use before init warnings in asynctest If the tests fail early before an ASYNC_WAIT_CTX is created then there can be a use before init problem in asynctest. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-29 21:07:28 +08:00
ASYNC_WAIT_CTX *waitctx = NULL;
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
currjob = NULL;
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
if ( !ASYNC_init_thread(1, 0)
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| (waitctx = ASYNC_WAIT_CTX_new()) == NULL
|| ASYNC_start_job(&job, waitctx, &funcret, save_current, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_PAUSE
|| currjob != job
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job, waitctx, &funcret, save_current, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_FINISH
|| funcret != 1) {
fprintf(stderr, "test_ASYNC_get_current_job() failed\n");
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
return 0;
}
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
return 1;
}
Use void in all function definitions that do not take any arguments Reviewed-by: Rich Salz <rsalz@openssl.org> GH: #6208
2018-05-09 23:09:50 +08:00
static int test_ASYNC_WAIT_CTX_get_all_fds(void)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
{
ASYNC_JOB *job = NULL;
Swap to using proper windows pipes We were using _pipe to create a pipe on windows. This uses the "int" type for its file descriptor for compatibility. However most windows functions expect to use a "HANDLE". Probably we could get away with just casting but it seems more robust to use the proper type and main stream windows functions. Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-11-13 19:22:21 +08:00
int funcret;
Fix use before init warnings in asynctest If the tests fail early before an ASYNC_WAIT_CTX is created then there can be a use before init problem in asynctest. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-29 21:07:28 +08:00
ASYNC_WAIT_CTX *waitctx = NULL;
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
OSSL_ASYNC_FD fd = OSSL_BAD_ASYNC_FD, delfd = OSSL_BAD_ASYNC_FD;
size_t numfds, numdelfds;
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
if ( !ASYNC_init_thread(1, 0)
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| (waitctx = ASYNC_WAIT_CTX_new()) == NULL
/* On first run we're not expecting any wait fds */
|| ASYNC_start_job(&job, waitctx, &funcret, waitfd, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_PAUSE
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| !ASYNC_WAIT_CTX_get_all_fds(waitctx, NULL, &numfds)
|| numfds != 0
|| !ASYNC_WAIT_CTX_get_changed_fds(waitctx, NULL, &numfds, NULL,
&numdelfds)
|| numfds != 0
|| numdelfds != 0
/* On second run we're expecting one added fd */
|| ASYNC_start_job(&job, waitctx, &funcret, waitfd, NULL, 0)
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
!= ASYNC_PAUSE
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| !ASYNC_WAIT_CTX_get_all_fds(waitctx, NULL, &numfds)
|| numfds != 1
|| !ASYNC_WAIT_CTX_get_all_fds(waitctx, &fd, &numfds)
|| fd != MAGIC_WAIT_FD
|| (fd = OSSL_BAD_ASYNC_FD, 0) /* Assign to something else */
|| !ASYNC_WAIT_CTX_get_changed_fds(waitctx, NULL, &numfds, NULL,
Add test to show wrong behavior of ASYNC_WAIT_CTX This happens when a fd is added and then immediately removed from the ASYNC_WAIT_CTX before pausing the job. Reviewed-by: Rich Salz <rsalz@openssl.org> Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/2581)
2017-01-26 11:17:54 +08:00
&numdelfds)
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| numfds != 1
|| numdelfds != 0
|| !ASYNC_WAIT_CTX_get_changed_fds(waitctx, &fd, &numfds, NULL,
&numdelfds)
|| fd != MAGIC_WAIT_FD
Add test to show wrong behavior of ASYNC_WAIT_CTX This happens when a fd is added and then immediately removed from the ASYNC_WAIT_CTX before pausing the job. Reviewed-by: Rich Salz <rsalz@openssl.org> Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/2581)
2017-01-26 11:17:54 +08:00
/* On third run we expect one deleted fd */
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job, waitctx, &funcret, waitfd, NULL, 0)
Add test to show wrong behavior of ASYNC_WAIT_CTX This happens when a fd is added and then immediately removed from the ASYNC_WAIT_CTX before pausing the job. Reviewed-by: Rich Salz <rsalz@openssl.org> Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/2581)
2017-01-26 11:17:54 +08:00
!= ASYNC_PAUSE
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| !ASYNC_WAIT_CTX_get_all_fds(waitctx, NULL, &numfds)
|| numfds != 0
|| !ASYNC_WAIT_CTX_get_changed_fds(waitctx, NULL, &numfds, NULL,
&numdelfds)
|| numfds != 0
|| numdelfds != 1
|| !ASYNC_WAIT_CTX_get_changed_fds(waitctx, NULL, &numfds, &delfd,
&numdelfds)
|| delfd != MAGIC_WAIT_FD
Add test to show wrong behavior of ASYNC_WAIT_CTX This happens when a fd is added and then immediately removed from the ASYNC_WAIT_CTX before pausing the job. Reviewed-by: Rich Salz <rsalz@openssl.org> Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/2581)
2017-01-26 11:17:54 +08:00
/* On last run we are not expecting any wait fd */
|| ASYNC_start_job(&job, waitctx, &funcret, waitfd, NULL, 0)
!= ASYNC_FINISH
|| !ASYNC_WAIT_CTX_get_all_fds(waitctx, NULL, &numfds)
|| numfds != 0
|| !ASYNC_WAIT_CTX_get_changed_fds(waitctx, NULL, &numfds, NULL,
&numdelfds)
|| numfds != 0
|| numdelfds != 0
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
|| funcret != 1) {
fprintf(stderr, "test_ASYNC_get_wait_fd() failed\n");
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
return 0;
}
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
return 1;
}
Add ASYNC_block_pause and ASYNC_unblock_pause There are potential deadlock situations that can occur if code executing within the context of a job aquires a lock, and then pauses the job. This adds an ability to temporarily block pauses from occuring whilst performing work and holding a lock. Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-11-12 18:42:08 +08:00
Use void in all function definitions that do not take any arguments Reviewed-by: Rich Salz <rsalz@openssl.org> GH: #6208
2018-05-09 23:09:50 +08:00
static int test_ASYNC_block_pause(void)
Add ASYNC_block_pause and ASYNC_unblock_pause There are potential deadlock situations that can occur if code executing within the context of a job aquires a lock, and then pauses the job. This adds an ability to temporarily block pauses from occuring whilst performing work and holding a lock. Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-11-12 18:42:08 +08:00
{
ASYNC_JOB *job = NULL;
int funcret;
Fix use before init warnings in asynctest If the tests fail early before an ASYNC_WAIT_CTX is created then there can be a use before init problem in asynctest. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-29 21:07:28 +08:00
ASYNC_WAIT_CTX *waitctx = NULL;
Add ASYNC_block_pause and ASYNC_unblock_pause There are potential deadlock situations that can occur if code executing within the context of a job aquires a lock, and then pauses the job. This adds an ability to temporarily block pauses from occuring whilst performing work and holding a lock. Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-11-12 18:42:08 +08:00
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
if ( !ASYNC_init_thread(1, 0)
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| (waitctx = ASYNC_WAIT_CTX_new()) == NULL
|| ASYNC_start_job(&job, waitctx, &funcret, blockpause, NULL, 0)
Add ASYNC_block_pause and ASYNC_unblock_pause There are potential deadlock situations that can occur if code executing within the context of a job aquires a lock, and then pauses the job. This adds an ability to temporarily block pauses from occuring whilst performing work and holding a lock. Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-11-12 18:42:08 +08:00
!= ASYNC_PAUSE
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
|| ASYNC_start_job(&job, waitctx, &funcret, blockpause, NULL, 0)
Add ASYNC_block_pause and ASYNC_unblock_pause There are potential deadlock situations that can occur if code executing within the context of a job aquires a lock, and then pauses the job. This adds an ability to temporarily block pauses from occuring whilst performing work and holding a lock. Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-11-12 18:42:08 +08:00
!= ASYNC_FINISH
|| funcret != 1) {
fprintf(stderr, "test_ASYNC_block_pause() failed\n");
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC_block_pause and ASYNC_unblock_pause There are potential deadlock situations that can occur if code executing within the context of a job aquires a lock, and then pauses the job. This adds an ability to temporarily block pauses from occuring whilst performing work and holding a lock. Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-11-12 18:42:08 +08:00
return 0;
}
Refactor the async wait fd logic Implementation experience has shown that the original plan for async wait fds was too simplistic. Originally the async logic created a pipe internally and user/engine code could then get access to it via API calls. It is more flexible if the engine is able to create its own fd and provide it to the async code. Another issue is that there can be a lot of churn in the fd value within the context of (say) a single SSL connection leading to continually adding and removing fds from (say) epoll. It is better if we can provide some stability of the fd value across a whole SSL connection. This is problematic because an engine has no concept of an SSL connection. This commit refactors things to introduce an ASYNC_WAIT_CTX which acts as a proxy for an SSL connection down at the engine layer. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-01-25 23:28:57 +08:00
ASYNC_WAIT_CTX_free(waitctx);
Auto init/deinit libcrypto This builds on the previous commit to auto initialise/deinitialise libcrypto. Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-02-09 00:43:03 +08:00
ASYNC_cleanup_thread();
Add ASYNC_block_pause and ASYNC_unblock_pause There are potential deadlock situations that can occur if code executing within the context of a job aquires a lock, and then pauses the job. This adds an ability to temporarily block pauses from occuring whilst performing work and holding a lock. Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-11-12 18:42:08 +08:00
return 1;
}
Add a test to make sure ASYNC aware code gets the right default libctx Even if a fibre changes the default libctx - or the main application code changes it, the "current" default libctx should remain consistent. Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/12228)
2020-06-26 18:02:29 +08:00
static int test_ASYNC_start_job_with_libctx(void)
{
ASYNC_JOB *job = NULL;
int funcret;
ASYNC_WAIT_CTX *waitctx = NULL;
OPENSSL_CTX *libctx = OPENSSL_CTX_new();
OPENSSL_CTX *oldctx, *tmpctx, *globalctx;
int ret = 0;
if (libctx == NULL) {
fprintf(stderr,
"test_ASYNC_start_job_with_libctx() failed to create libctx\n");
goto err;
}
globalctx = oldctx = OPENSSL_CTX_set0_default(libctx);
if ((waitctx = ASYNC_WAIT_CTX_new()) == NULL
|| ASYNC_start_job(&job, waitctx, &funcret, change_deflt_libctx,
NULL, 0)
!= ASYNC_PAUSE) {
fprintf(stderr,
"test_ASYNC_start_job_with_libctx() failed to start job\n");
goto err;
}
/* Reset the libctx temporarily to find out what it is*/
tmpctx = OPENSSL_CTX_set0_default(oldctx);
oldctx = OPENSSL_CTX_set0_default(tmpctx);
if (tmpctx != libctx) {
fprintf(stderr,
"test_ASYNC_start_job_with_libctx() failed - unexpected libctx\n");
goto err;
}
if (ASYNC_start_job(&job, waitctx, &funcret, change_deflt_libctx, NULL, 0)
!= ASYNC_PAUSE) {
fprintf(stderr,
"test_ASYNC_start_job_with_libctx() - restarting job failed\n");
goto err;
}
/* Reset the libctx and continue with the global default libctx */
tmpctx = OPENSSL_CTX_set0_default(oldctx);
if (tmpctx != libctx) {
fprintf(stderr,
"test_ASYNC_start_job_with_libctx() failed - unexpected libctx\n");
goto err;
}
if (ASYNC_start_job(&job, waitctx, &funcret, change_deflt_libctx, NULL, 0)
!= ASYNC_FINISH
|| funcret != 1) {
fprintf(stderr,
"test_ASYNC_start_job_with_libctx() - finishing job failed\n");
goto err;
}
/* Reset the libctx temporarily to find out what it is*/
tmpctx = OPENSSL_CTX_set0_default(libctx);
OPENSSL_CTX_set0_default(tmpctx);
if (tmpctx != globalctx) {
fprintf(stderr,
"test_ASYNC_start_job_with_libctx() failed - global libctx check failed\n");
goto err;
}
ret = 1;
err:
ASYNC_WAIT_CTX_free(waitctx);
OPENSSL_CTX_free(libctx);
return ret;
}
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
int main(int argc, char **argv)
{
Some platforms provide getcontext() but it does not work Some platforms claim to be POSIX but their getcontext() implementation does not work. Therefore we update the ASYNC_is_capable() function to test for this. RT#4366 Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-03-16 18:38:39 +08:00
if (!ASYNC_is_capable()) {
fprintf(stderr,
"OpenSSL build is not ASYNC capable - skipping async tests\n");
} else {
Deprecate most of debug-memory Fixes #8322 The leak-checking (and backtrace option, on some platforms) provided by crypto-mdebug and crypto-mdebug-backtrace have been mostly neutered; only the "make malloc fail" capability remains. OpenSSL recommends using the compiler's leak-detection instead. The OPENSSL_DEBUG_MEMORY environment variable is no longer used. CRYPTO_mem_ctrl(), CRYPTO_set_mem_debug(), CRYPTO_mem_leaks(), CRYPTO_mem_leaks_fp() and CRYPTO_mem_leaks_cb() return a failure code. CRYPTO_mem_debug_{malloc,realloc,free}() have been removed. All of the above are now deprecated. Merge (now really small) mem_dbg.c into mem.c Reviewed-by: Paul Dale <paul.dale@oracle.com> Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/10572)
2019-12-05 02:15:08 +08:00
if (!test_ASYNC_init_thread()
add an additional async notification communication method based on callback Reviewed-by: Matt Caswell <matt@openssl.org> Reviewed-by: Paul Yang <yang.yang@baishancloud.com> Signed-off-by: Ping Yu <ping.yu@intel.com> Signed-off-by: Steven Linsell <stevenx.linsell@intel.com> (Merged from https://github.com/openssl/openssl/pull/7573)
2018-11-06 04:41:01 +08:00
|| !test_ASYNC_callback_status()
Some platforms provide getcontext() but it does not work Some platforms claim to be POSIX but their getcontext() implementation does not work. Therefore we update the ASYNC_is_capable() function to test for this. RT#4366 Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-03-16 18:38:39 +08:00
|| !test_ASYNC_start_job()
|| !test_ASYNC_get_current_job()
|| !test_ASYNC_WAIT_CTX_get_all_fds()
Add a test to make sure ASYNC aware code gets the right default libctx Even if a fibre changes the default libctx - or the main application code changes it, the "current" default libctx should remain consistent. Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/12228)
2020-06-26 18:02:29 +08:00
|| !test_ASYNC_block_pause()
|| !test_ASYNC_start_job_with_libctx()) {
Some platforms provide getcontext() but it does not work Some platforms claim to be POSIX but their getcontext() implementation does not work. Therefore we update the ASYNC_is_capable() function to test for this. RT#4366 Reviewed-by: Richard Levitte <levitte@openssl.org>
2016-03-16 18:38:39 +08:00
return 1;
}
Add ASYNC tests Add a suite of tests for the ASYNC_* functions Reviewed-by: Rich Salz <rsalz@openssl.org>
2015-10-06 02:41:58 +08:00
}
printf("PASS\n");
return 0;
}
Reference in New Issue Copy Permalink