For some reason the dasync sha1 functions did not start with the
dasync prefix like all of the other functions do. Changed for
consistency.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Clarify that you must only call this after all async jobs have
completed - otherwise you could get memory leaks.
Reviewed-by: NRich Salz <rsalz@openssl.org>

OS-X complains if we don't have _XOPEN_SOURCE defined.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Make clang build without errors in the async code
Reviewed-by: NRich Salz <rsalz@openssl.org>

_longjmp/_setjmp do not manipulate the signal mask whilst
longjmp/setjmp may do. Online sources suggest this could result
in a significant speed up in the context switching.
Reviewed-by: NRich Salz <rsalz@openssl.org>

If config'd without -d (--debug), asynctest was crashing with:
*** longjmp causes uninitialized stack frame ***

This is because gcc will add certain checks for some functions
(including longjmp). The checks assume you can only longjmp down the
stack not up. However, if we are actually jumping to a different
fibre then it can appear as if we are going up the stack when we are
not really. This change disables the check.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Add some clarifications to the async documentation. Also changed
ASYNC_pause_job() so that it returns success if you are not within the
context of a job. This is so that engines can be used either asynchronously
or synchronously and can treat an error from ASYNC_pause_job() as a real
error.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Tidy up the libssl async calls and make sure all IO functions are covered.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Reviewed-by: NRich Salz <rsalz@openssl.org>

Add ASYNCerr support to give some meaningful error message in the event of
a failure.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Add a CHANGES entry for the new async code.
Reviewed-by: NRich Salz <rsalz@openssl.org>

s_server already had the ability to wait on an async file descriptor. This
adds it to s_client too.
Reviewed-by: NRich Salz <rsalz@openssl.org>

0 is a valid file descriptor so SSL_get_async_wait_fd should instead return
-1 on error.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Document the libssl and command line application aspects of async.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Tidied up the naming of functions and structures to be consistent
Reviewed-by: NRich Salz <rsalz@openssl.org>

Fix some warnings in the async code when compiling on windows.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Don't recreate a new ASYNC_CTX every time we call ASYNC_start_job() - the
same one can be used for the life of the thread. Instead we only free it
up when we call ASYNC_free_pool().
Reviewed-by: NRich Salz <rsalz@openssl.org>

The ASYNC null implementation has not kept pace with the rest of the async
development and so was failing to compile.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Add a suite of tests for the ASYNC_* functions
Reviewed-by: NRich Salz <rsalz@openssl.org>

The ASYNC_in_job() function is redundant. The same effect can be achieved by
using ASYNC_get_current_job().
Reviewed-by: NRich Salz <rsalz@openssl.org>

Reviewed-by: NRich Salz <rsalz@openssl.org>

Reviewed-by: NRich Salz <rsalz@openssl.org>

Port the async pool and notify code to windows.
Reviewed-by: NRich Salz <rsalz@openssl.org>

s_client was not freeing up the async pool if async mode was enabled.
Reviewed-by: NRich Salz <rsalz@openssl.org>

If an async event occurs during a renegotiation in SSL_read then s_server
was looping around, detecting we were in init and calling
init_ssl_connection instead of re-calling SSL_read.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Implement the ASYNC_JOB as a local thread pool. Remove the API support
for global pools.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Initial API implemented for notifying applications that an ASYNC_JOB
has completed. Currently only s_server is using this. The Dummy Async
engine "cheats" in that it notifies that it has completed *before* it
pauses the job. A normal async engine would not do that.

Only the posix version of this has been implemented so far, so it will
probably fail to compile on Windows at the moment.
Reviewed-by: NRich Salz <rsalz@openssl.org>

It is expensive to create the ASYNC_JOB objects due to the "makecontext"
call. This change adds support for pools of ASYNC_JOB objects so that we
don't have to create a new ASYNC_JOB every time we want to use one.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Where we can we should use longjmp and setjmp in preference to swapcontext/
setcontext as they seem to be more performant.
Reviewed-by: NRich Salz <rsalz@openssl.org>

The s_server option -WWW was not async aware, and therefore was not
handling SSL_ERROR_WANT_ASYNC conditions. This commit fixes that.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Removed the function ASYNC_job_is_waiting() as it was redundant. The only
time user code has a handle on a job is when one is waiting, so all they
need to do is check whether the job is NULL. Also did some cleanups to
make sure the job really is NULL after it has been freed!
Reviewed-by: NRich Salz <rsalz@openssl.org>

Some assembler code puts a lot of stuff on the stack, so up the stack size.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Create a "null" async implementation for platforms that lack support. This
just does nothing when called and therefore performs synchronously.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Reviewed-by: NRich Salz <rsalz@openssl.org>

Reviewed-by: NRich Salz <rsalz@openssl.org>

A new -async option is added which activates SSL_MODE_ASYNC. Also
SSL_WANT_ASYNC errors are handled appropriately.
Reviewed-by: NRich Salz <rsalz@openssl.org>

The following entry points have been made async aware:
SSL_accept
SSL_read
SSL_write

Also added is a new mode - SSL_MODE_ASYNC. Calling the above functions with
the async mode enabled will initiate a new async job. If an async pause is
encountered whilst executing the job (such as for example if using SHA1/RSA
with the Dummy Async engine), then the above functions return with
SSL_WANT_ASYNC. Calling the functions again (with exactly the same args
as per non-blocking IO), will resume the job where it left off.
Reviewed-by: NRich Salz <rsalz@openssl.org>

This engine is for developers of async aware applications. It simulates
asynchronous activity with external hardware. This initial version supports
SHA1 and RSA. Certain operations using those algorithms have async job
"pauses" in them - using the new libcrypto async capability.
Reviewed-by: NRich Salz <rsalz@openssl.org>

Provides support for running asynchronous jobs. Currently this is completely
stand alone. Future commits will integrate this into libssl and s_server/
s_client. An asynchronous capable engine will be required to see any benefit
from this capability.
Reviewed-by: NRich Salz <rsalz@openssl.org>

The forthcoming async code needs to use pthread thread local variables. This
updates the various Configurations to add the necessary flags. In many cases
this is an educated guess as I don't have access to most of these
environments! There is likely to be some tweaking needed.
Reviewed-by: NKurt Roeckx <kurt@openssl.org>