338 lines
16 KiB
Groff
Executable File
338 lines
16 KiB
Groff
Executable File
.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16)
|
|
.\"
|
|
.\" Standard preamble:
|
|
.\" ========================================================================
|
|
.de Sp \" Vertical space (when we can't use .PP)
|
|
.if t .sp .5v
|
|
.if n .sp
|
|
..
|
|
.de Vb \" Begin verbatim text
|
|
.ft CW
|
|
.nf
|
|
.ne \\$1
|
|
..
|
|
.de Ve \" End verbatim text
|
|
.ft R
|
|
.fi
|
|
..
|
|
.\" Set up some character translations and predefined strings. \*(-- will
|
|
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
|
|
.\" double quote, and \*(R" will give a right double quote. \*(C+ will
|
|
.\" give a nicer C++. Capital omega is used to do unbreakable dashes and
|
|
.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff,
|
|
.\" nothing in troff, for use with C<>.
|
|
.tr \(*W-
|
|
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
|
|
.ie n \{\
|
|
. ds -- \(*W-
|
|
. ds PI pi
|
|
. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
|
|
. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch
|
|
. ds L" ""
|
|
. ds R" ""
|
|
. ds C` ""
|
|
. ds C' ""
|
|
'br\}
|
|
.el\{\
|
|
. ds -- \|\(em\|
|
|
. ds PI \(*p
|
|
. ds L" ``
|
|
. ds R" ''
|
|
'br\}
|
|
.\"
|
|
.\" Escape single quotes in literal strings from groff's Unicode transform.
|
|
.ie \n(.g .ds Aq \(aq
|
|
.el .ds Aq '
|
|
.\"
|
|
.\" If the F register is turned on, we'll generate index entries on stderr for
|
|
.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
|
|
.\" entries marked with X<> in POD. Of course, you'll have to process the
|
|
.\" output yourself in some meaningful fashion.
|
|
.ie \nF \{\
|
|
. de IX
|
|
. tm Index:\\$1\t\\n%\t"\\$2"
|
|
..
|
|
. nr % 0
|
|
. rr F
|
|
.\}
|
|
.el \{\
|
|
. de IX
|
|
..
|
|
.\}
|
|
.\"
|
|
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
|
|
.\" Fear. Run. Save yourself. No user-serviceable parts.
|
|
. \" fudge factors for nroff and troff
|
|
.if n \{\
|
|
. ds #H 0
|
|
. ds #V .8m
|
|
. ds #F .3m
|
|
. ds #[ \f1
|
|
. ds #] \fP
|
|
.\}
|
|
.if t \{\
|
|
. ds #H ((1u-(\\\\n(.fu%2u))*.13m)
|
|
. ds #V .6m
|
|
. ds #F 0
|
|
. ds #[ \&
|
|
. ds #] \&
|
|
.\}
|
|
. \" simple accents for nroff and troff
|
|
.if n \{\
|
|
. ds ' \&
|
|
. ds ` \&
|
|
. ds ^ \&
|
|
. ds , \&
|
|
. ds ~ ~
|
|
. ds /
|
|
.\}
|
|
.if t \{\
|
|
. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
|
|
. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
|
|
. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
|
|
. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
|
|
. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
|
|
. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
|
|
.\}
|
|
. \" troff and (daisy-wheel) nroff accents
|
|
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
|
|
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
|
|
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
|
|
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
|
|
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
|
|
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
|
|
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
|
|
.ds ae a\h'-(\w'a'u*4/10)'e
|
|
.ds Ae A\h'-(\w'A'u*4/10)'E
|
|
. \" corrections for vroff
|
|
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
|
|
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
|
|
. \" for low resolution devices (crt and lpr)
|
|
.if \n(.H>23 .if \n(.V>19 \
|
|
\{\
|
|
. ds : e
|
|
. ds 8 ss
|
|
. ds o a
|
|
. ds d- d\h'-1'\(ga
|
|
. ds D- D\h'-1'\(hy
|
|
. ds th \o'bp'
|
|
. ds Th \o'LP'
|
|
. ds ae ae
|
|
. ds Ae AE
|
|
.\}
|
|
.rm #[ #] #H #V #F C
|
|
.\" ========================================================================
|
|
.\"
|
|
.IX Title "ASYNC_WAIT_CTX_NEW 3"
|
|
.TH ASYNC_WAIT_CTX_NEW 3 "2020-03-02" "3.0.0-dev" "OpenSSL"
|
|
.\" For nroff, turn off justification. Always turn off hyphenation; it makes
|
|
.\" way too many mistakes in technical documents.
|
|
.if n .ad l
|
|
.nh
|
|
.SH "NAME"
|
|
ASYNC_WAIT_CTX_new, ASYNC_WAIT_CTX_free, ASYNC_WAIT_CTX_set_wait_fd,
|
|
ASYNC_WAIT_CTX_get_fd, ASYNC_WAIT_CTX_get_all_fds,
|
|
ASYNC_WAIT_CTX_get_changed_fds, ASYNC_WAIT_CTX_clear_fd,
|
|
ASYNC_WAIT_CTX_set_callback, ASYNC_WAIT_CTX_get_callback,
|
|
ASYNC_WAIT_CTX_set_status, ASYNC_WAIT_CTX_get_status, ASYNC_callback_fn,
|
|
ASYNC_STATUS_UNSUPPORTED, ASYNC_STATUS_ERR, ASYNC_STATUS_OK,
|
|
ASYNC_STATUS_EAGAIN
|
|
\&\- functions to manage waiting for asynchronous jobs to complete
|
|
.SH "SYNOPSIS"
|
|
.IX Header "SYNOPSIS"
|
|
.Vb 1
|
|
\& #include <openssl/async.h>
|
|
\&
|
|
\& #define ASYNC_STATUS_UNSUPPORTED 0
|
|
\& #define ASYNC_STATUS_ERR 1
|
|
\& #define ASYNC_STATUS_OK 2
|
|
\& #define ASYNC_STATUS_EAGAIN 3
|
|
\& typedef int (*ASYNC_callback_fn)(void *arg);
|
|
\& ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void);
|
|
\& void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx);
|
|
\& int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key,
|
|
\& OSSL_ASYNC_FD fd,
|
|
\& void *custom_data,
|
|
\& void (*cleanup)(ASYNC_WAIT_CTX *, const void *,
|
|
\& OSSL_ASYNC_FD, void *));
|
|
\& int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key,
|
|
\& OSSL_ASYNC_FD *fd, void **custom_data);
|
|
\& int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *fd,
|
|
\& size_t *numfds);
|
|
\& int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *addfd,
|
|
\& size_t *numaddfds, OSSL_ASYNC_FD *delfd,
|
|
\& size_t *numdelfds);
|
|
\& int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key);
|
|
\& int ASYNC_WAIT_CTX_set_callback(ASYNC_WAIT_CTX *ctx,
|
|
\& ASYNC_callback_fn callback,
|
|
\& void *callback_arg);
|
|
\& int ASYNC_WAIT_CTX_get_callback(ASYNC_WAIT_CTX *ctx,
|
|
\& ASYNC_callback_fn *callback,
|
|
\& void **callback_arg);
|
|
\& int ASYNC_WAIT_CTX_set_status(ASYNC_WAIT_CTX *ctx, int status);
|
|
\& int ASYNC_WAIT_CTX_get_status(ASYNC_WAIT_CTX *ctx);
|
|
.Ve
|
|
.SH "DESCRIPTION"
|
|
.IX Header "DESCRIPTION"
|
|
For an overview of how asynchronous operations are implemented in OpenSSL see
|
|
\&\fIASYNC_start_job\fR\|(3). An \fB\s-1ASYNC_WAIT_CTX\s0\fR object represents an asynchronous
|
|
\&\*(L"session\*(R", i.e. a related set of crypto operations. For example in \s-1SSL\s0 terms
|
|
this would have a one-to-one correspondence with an \s-1SSL\s0 connection.
|
|
.PP
|
|
Application code must create an \fB\s-1ASYNC_WAIT_CTX\s0\fR using the \fIASYNC_WAIT_CTX_new()\fR
|
|
function prior to calling \fIASYNC_start_job()\fR (see \fIASYNC_start_job\fR\|(3)). When
|
|
the job is started it is associated with the \fB\s-1ASYNC_WAIT_CTX\s0\fR for the duration
|
|
of that job. An \fB\s-1ASYNC_WAIT_CTX\s0\fR should only be used for one \fB\s-1ASYNC_JOB\s0\fR at
|
|
any one time, but can be reused after an \fB\s-1ASYNC_JOB\s0\fR has finished for a
|
|
subsequent \fB\s-1ASYNC_JOB\s0\fR. When the session is complete (e.g. the \s-1SSL\s0 connection
|
|
is closed), application code cleans up with \fIASYNC_WAIT_CTX_free()\fR.
|
|
.PP
|
|
\&\fB\s-1ASYNC_WAIT_CTX\s0\fRs can have \*(L"wait\*(R" file descriptors associated with them.
|
|
Calling \fIASYNC_WAIT_CTX_get_all_fds()\fR and passing in a pointer to an
|
|
\&\fB\s-1ASYNC_WAIT_CTX\s0\fR in the \fIctx\fR parameter will return the wait file descriptors
|
|
associated with that job in \fI*fd\fR. The number of file descriptors returned will
|
|
be stored in \fI*numfds\fR. It is the caller's responsibility to ensure that
|
|
sufficient memory has been allocated in \fI*fd\fR to receive all the file
|
|
descriptors. Calling \fIASYNC_WAIT_CTX_get_all_fds()\fR with a \s-1NULL\s0 \fIfd\fR value will
|
|
return no file descriptors but will still populate \fI*numfds\fR. Therefore
|
|
application code is typically expected to call this function twice: once to get
|
|
the number of fds, and then again when sufficient memory has been allocated. If
|
|
only one asynchronous engine is being used then normally this call will only
|
|
ever return one fd. If multiple asynchronous engines are being used then more
|
|
could be returned.
|
|
.PP
|
|
The function \fIASYNC_WAIT_CTX_get_changed_fds()\fR can be used to detect if any fds
|
|
have changed since the last call time \fIASYNC_start_job()\fR returned \fB\s-1ASYNC_PAUSE\s0\fR
|
|
(or since the \fB\s-1ASYNC_WAIT_CTX\s0\fR was created if no \fB\s-1ASYNC_PAUSE\s0\fR result has
|
|
been received). The \fInumaddfds\fR and \fInumdelfds\fR parameters will be populated
|
|
with the number of fds added or deleted respectively. \fI*addfd\fR and \fI*delfd\fR
|
|
will be populated with the list of added and deleted fds respectively. Similarly
|
|
to \fIASYNC_WAIT_CTX_get_all_fds()\fR either of these can be \s-1NULL\s0, but if they are not
|
|
\&\s-1NULL\s0 then the caller is responsible for ensuring sufficient memory is allocated.
|
|
.PP
|
|
Implementors of async aware code (e.g. engines) are encouraged to return a
|
|
stable fd for the lifetime of the \fB\s-1ASYNC_WAIT_CTX\s0\fR in order to reduce the
|
|
\&\*(L"churn\*(R" of regularly changing fds \- although no guarantees of this are provided
|
|
to applications.
|
|
.PP
|
|
Applications can wait for the file descriptor to be ready for \*(L"read\*(R" using a
|
|
system function call such as select or poll (being ready for \*(L"read\*(R" indicates
|
|
that the job should be resumed). If no file descriptor is made available then an
|
|
application will have to periodically \*(L"poll\*(R" the job by attempting to restart it
|
|
to see if it is ready to continue.
|
|
.PP
|
|
Async aware code (e.g. engines) can get the current \fB\s-1ASYNC_WAIT_CTX\s0\fR from the
|
|
job via \fIASYNC_get_wait_ctx\fR\|(3) and provide a file descriptor to use for
|
|
waiting on by calling \fIASYNC_WAIT_CTX_set_wait_fd()\fR. Typically this would be done
|
|
by an engine immediately prior to calling \fIASYNC_pause_job()\fR and not by end user
|
|
code. An existing association with a file descriptor can be obtained using
|
|
\&\fIASYNC_WAIT_CTX_get_fd()\fR and cleared using \fIASYNC_WAIT_CTX_clear_fd()\fR. Both of
|
|
these functions requires a \fIkey\fR value which is unique to the async aware
|
|
code. This could be any unique value but a good candidate might be the
|
|
\&\fB\s-1ENGINE\s0 *\fR for the engine. The \fIcustom_data\fR parameter can be any value, and
|
|
will be returned in a subsequent call to \fIASYNC_WAIT_CTX_get_fd()\fR. The
|
|
\&\fIASYNC_WAIT_CTX_set_wait_fd()\fR function also expects a pointer to a \*(L"cleanup\*(R"
|
|
routine. This can be \s-1NULL\s0 but if provided will automatically get called when
|
|
the \fB\s-1ASYNC_WAIT_CTX\s0\fR is freed, and gives the engine the opportunity to close
|
|
the fd or any other resources. Note: The \*(L"cleanup\*(R" routine does not get called
|
|
if the fd is cleared directly via a call to \fIASYNC_WAIT_CTX_clear_fd()\fR.
|
|
.PP
|
|
An example of typical usage might be an async capable engine. User code would
|
|
initiate cryptographic operations. The engine would initiate those operations
|
|
asynchronously and then call \fIASYNC_WAIT_CTX_set_wait_fd()\fR followed by
|
|
\&\fIASYNC_pause_job()\fR to return control to the user code. The user code can then
|
|
perform other tasks or wait for the job to be ready by calling \*(L"select\*(R" or other
|
|
similar function on the wait file descriptor. The engine can signal to the user
|
|
code that the job should be resumed by making the wait file descriptor
|
|
\&\*(L"readable\*(R". Once resumed the engine should clear the wake signal on the wait
|
|
file descriptor.
|
|
.PP
|
|
As well as a file descriptor, user code may also be notified via a callback. The
|
|
callback and data pointers are stored within the \fB\s-1ASYNC_WAIT_CTX\s0\fR along with an
|
|
additional status field that can be used for the notification of retries from an
|
|
engine. This additional method can be used when the user thinks that a file
|
|
descriptor is too costly in terms of \s-1CPU\s0 cycles or in some context where a file
|
|
descriptor is not appropriate.
|
|
.PP
|
|
\&\fIASYNC_WAIT_CTX_set_callback()\fR sets the callback and the callback argument. The
|
|
callback will be called to notify user code when an engine completes a
|
|
cryptography operation. It is a requirement that the callback function is small
|
|
and non-blocking as it will be run in the context of a polling mechanism or an
|
|
interrupt.
|
|
.PP
|
|
\&\fIASYNC_WAIT_CTX_get_callback()\fR returns the callback set in the \fB\s-1ASYNC_WAIT_CTX\s0\fR
|
|
structure.
|
|
.PP
|
|
\&\fIASYNC_WAIT_CTX_set_status()\fR allows an engine to set the current engine status.
|
|
The possible status values are the following:
|
|
.IP "\fB\s-1ASYNC_STATUS_UNSUPPORTED\s0\fR" 4
|
|
.IX Item "ASYNC_STATUS_UNSUPPORTED"
|
|
The engine does not support the callback mechanism. This is the default value.
|
|
The engine must call \fIASYNC_WAIT_CTX_set_status()\fR to set the status to some value
|
|
other than \fB\s-1ASYNC_STATUS_UNSUPPORTED\s0\fR if it intends to enable the callback
|
|
mechanism.
|
|
.IP "\fB\s-1ASYNC_STATUS_ERR\s0\fR" 4
|
|
.IX Item "ASYNC_STATUS_ERR"
|
|
The engine has a fatal problem with this request. The user code should clean up
|
|
this session.
|
|
.IP "\fB\s-1ASYNC_STATUS_OK\s0\fR" 4
|
|
.IX Item "ASYNC_STATUS_OK"
|
|
The request has been successfully submitted.
|
|
.IP "\fB\s-1ASYNC_STATUS_EAGAIN\s0\fR" 4
|
|
.IX Item "ASYNC_STATUS_EAGAIN"
|
|
The engine has some problem which will be recovered soon, such as a buffer is
|
|
full, so user code should resume the job.
|
|
.PP
|
|
\&\fIASYNC_WAIT_CTX_get_status()\fR allows user code to obtain the current status value.
|
|
If the status is any value other than \fB\s-1ASYNC_STATUS_OK\s0\fR then the user code
|
|
should not expect to receive a callback from the engine even if one has been
|
|
set.
|
|
.PP
|
|
An example of the usage of the callback method might be the following. User
|
|
code would initiate cryptographic operations, and the engine code would dispatch
|
|
this operation to hardware, and if the dispatch is successful, then the engine
|
|
code would call \fIASYNC_pause_job()\fR to return control to the user code. After
|
|
that, user code can perform other tasks. When the hardware completes the
|
|
operation, normally it is detected by a polling function or an interrupt, as the
|
|
user code set a callback by calling \fIASYNC_WAIT_CTX_set_callback()\fR previously,
|
|
then the registered callback will be called.
|
|
.SH "RETURN VALUES"
|
|
.IX Header "RETURN VALUES"
|
|
\&\fIASYNC_WAIT_CTX_new()\fR returns a pointer to the newly allocated \fB\s-1ASYNC_WAIT_CTX\s0\fR
|
|
or \s-1NULL\s0 on error.
|
|
.PP
|
|
ASYNC_WAIT_CTX_set_wait_fd, ASYNC_WAIT_CTX_get_fd, ASYNC_WAIT_CTX_get_all_fds,
|
|
ASYNC_WAIT_CTX_get_changed_fds, ASYNC_WAIT_CTX_clear_fd,
|
|
ASYNC_WAIT_CTX_set_callback, ASYNC_WAIT_CTX_get_callback and
|
|
ASYNC_WAIT_CTX_set_status all return 1 on success or 0 on error.
|
|
\&\fIASYNC_WAIT_CTX_get_status()\fR returns the engine status.
|
|
.SH "NOTES"
|
|
.IX Header "NOTES"
|
|
On Windows platforms the openssl/async.h header is dependent on some
|
|
of the types customarily made available by including windows.h. The
|
|
application developer is likely to require control over when the latter
|
|
is included, commonly as one of the first included headers. Therefore
|
|
it is defined as an application developer's responsibility to include
|
|
windows.h prior to async.h.
|
|
.SH "SEE ALSO"
|
|
.IX Header "SEE ALSO"
|
|
\&\fIcrypto\fR\|(7), \fIASYNC_start_job\fR\|(3)
|
|
.SH "HISTORY"
|
|
.IX Header "HISTORY"
|
|
\&\fIASYNC_WAIT_CTX_new()\fR, \fIASYNC_WAIT_CTX_free()\fR, \fIASYNC_WAIT_CTX_set_wait_fd()\fR,
|
|
\&\fIASYNC_WAIT_CTX_get_fd()\fR, \fIASYNC_WAIT_CTX_get_all_fds()\fR,
|
|
\&\fIASYNC_WAIT_CTX_get_changed_fds()\fR and \fIASYNC_WAIT_CTX_clear_fd()\fR
|
|
were added in OpenSSL 1.1.0.
|
|
.PP
|
|
\&\fIASYNC_WAIT_CTX_set_callback()\fR, \fIASYNC_WAIT_CTX_get_callback()\fR,
|
|
\&\fIASYNC_WAIT_CTX_set_status()\fR, and \fIASYNC_WAIT_CTX_get_status()\fR
|
|
were added in OpenSSL 3.0.
|
|
.SH "COPYRIGHT"
|
|
.IX Header "COPYRIGHT"
|
|
Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
|
|
.PP
|
|
Licensed under the Apache License 2.0 (the \*(L"License\*(R"). You may not use
|
|
this file except in compliance with the License. You can obtain a copy
|
|
in the file \s-1LICENSE\s0 in the source distribution or at
|
|
<https://www.openssl.org/source/license.html>.
|