View Source: ssl(3) - Waikato Linux Users Group

Edit PageHistory Diff Info LikePages
ssl
!!!ssl
NAME
SYNOPSIS
DESCRIPTION
DATA STRUCTURES
HEADER FILES
API FUNCTIONS
SEE ALSO
HISTORY
----
!!NAME


SSL - OpenSSL SSL/TLS library
!!SYNOPSIS
!!DESCRIPTION


The OpenSSL __ssl__ library implements the Secure
Sockets Layer ( SSL v2/v3) and Transport Layer
Security ( TLS v1) protocols. It provides a
rich API which is documented
here.


At first the library must be initialized; see
''SSL_library_init''(3).


Then an __SSL_CTX__ object is created as
a framework to establish TLS/SSL enabled
connections (see ''SSL_CTX_new''(3)). Various options
regarding certificates, algorithms etc. can be set in this
object.


When a network connection has been created, it can be
assigned to an __SSL__ object. After the
__SSL__ object has been created using
''SSL_new''(3), ''SSL_set_fd''(3) or
''SSL_set_bio''(3) can be used to associate the network
connection with the object.


Then the TLS/SSL handshake is performed
using ''SSL_accept''(3) or ''SSL_connect''(3)
respectively. ''SSL_read''(3) and ''SSL_write''(3) are
used to read and write data on the TLS/SSL
connection. ''SSL_shutdown''(3) can be used to shut
down the TLS/SSL connection.
!!DATA STRUCTURES


Currently the OpenSSL __ssl__ library functions
deals with the following data structures:


__SSL_METHOD__ ( SSL
Method)


That's a dispatch structure describing the internal
__ssl__ library methods/functions which implement the
various protocol versions (SSLv1, SSLv2 and TLSv1). It's
needed to create an __SSL_CTX__
.


__SSL_CIPHER__ ( SSL
Cipher)


This structure holds the algorithm information for a
particular cipher which are a core part of the SSL/TLS
protocol. The available ciphers are configured on
a __SSL_CTX__ basis and the actually used ones
are then part of the __SSL_SESSION__
.


__SSL_CTX__ ( SSL
Context)


That's the global context structure which is created by
a server or client once per program life-time and which
holds mainly default values for the __SSL__
structures which are later created for the
connections.


__SSL_SESSION__ ( SSL
Session)


This is a structure containing the current
TLS/SSL session details for a connection:
__SSL_CIPHER__ s, client and server certificates,
keys, etc.


__SSL__ ( SSL
Connection)


That's the main SSL/TLS structure which is
created by a server or client per established connection.
This actually is the core structure in the SSL API
. Under run-time the application usually deals with
this structure which has links to mostly all other
structures.
!!HEADER FILES


Currently the OpenSSL __ssl__ library provides the
following C header files containing the prototypes for the
data structures and and functions:


__ssl.h__


That's the common header file for the SSL/TLS API
. Include it into your program to make the API
of the __ssl__ library available. It internally
includes both more private SSL headers and
headers from the __crypto__ library. Whenever you need
hard-core details on the internals of the SSL API
, look inside this header file.


__ssl2.h__


That's the sub header file dealing with the SSLv2
protocol only. ''Usually you don't have to include it
explicitly because it's already included by
ssl.h''.


__ssl3.h__


That's the sub header file dealing with the SSLv3
protocol only. ''Usually you don't have to include it
explicitly because it's already included by
ssl.h''.


__ssl23.h__


That's the sub header file dealing with the combined
use of the SSLv2 and SSLv3 protocols. ''Usually you don't
have to include it explicitly because it's already included
by ssl.h''.


__tls1.h__


That's the sub header file dealing with the TLSv1
protocol only. ''Usually you don't have to include it
explicitly because it's already included by
ssl.h''.
!!API FUNCTIONS


Currently the OpenSSL __ssl__ library exports
214 API functions. They are documented in the
following:


__DEALING WITH PROTOCOL METHODS__


Here we document the various API functions
which deal with the SSL/TLS protocol methods
defined in __SSL_METHOD__
structures.


SSL_METHOD
*__SSLv2_client_method__(void);


Constructor for the SSLv2 SSL_METHOD
structure for a dedicated client.


SSL_METHOD
*__SSLv2_server_method__(void);


Constructor for the SSLv2 SSL_METHOD
structure for a dedicated server.


SSL_METHOD
*__SSLv2_method__(void);


Constructor for the SSLv2 SSL_METHOD
structure for combined client and
server.


SSL_METHOD
*__SSLv3_client_method__(void);


Constructor for the SSLv3 SSL_METHOD
structure for a dedicated client.


SSL_METHOD
*__SSLv3_server_method__(void);


Constructor for the SSLv3 SSL_METHOD
structure for a dedicated server.


SSL_METHOD
*__SSLv3_method__(void);


Constructor for the SSLv3 SSL_METHOD
structure for combined client and
server.


SSL_METHOD
*__TLSv1_client_method__(void);


Constructor for the TLSv1 SSL_METHOD
structure for a dedicated client.


SSL_METHOD
*__TLSv1_server_method__(void);


Constructor for the TLSv1 SSL_METHOD
structure for a dedicated server.


SSL_METHOD
*__TLSv1_method__(void);


Constructor for the TLSv1 SSL_METHOD
structure for combined client and
server.


__DEALING WITH CIPHERS__


Here we document the various API functions
which deal with the SSL/TLS ciphers defined
in __SSL_CIPHER__
structures.


char *__SSL_CIPHER_description__( SSL_CIPHER
*cipher, char *buf, int len);


Write a string to ''buf'' (with a maximum size of
''len'') containing a human readable description of
''cipher''. Returns ''buf''.


int __SSL_CIPHER_get_bits__( SSL_CIPHER
*cipher, int *alg_bits);


Determine the number of bits in ''cipher''. Because
of export crippled ciphers there are two bits: The bits the
algorithm supports in general (stored to ''alg_bits'')
and the bits which are actually used (the return
value).


const char *__SSL_CIPHER_get_name__(
SSL_CIPHER *cipher);


Return the internal name of ''cipher'' as a string.
These are the various strings defined by the
''SSL2_TXT_xxx'', ''SSL3_TXT_xxx'' and
''TLS1_TXT_xxx'' definitions in the header
files.


char *__SSL_CIPHER_get_version__( SSL_CIPHER
*cipher);


Returns a string like TLSv1/SSLv3`` or
''SSLv2 SSL/TLS
protocol version to which ''cipher'' belongs (i.e.
where it was defined in the specification the first
time).


__DEALING WITH PROTOCOL CONTEXTS__


Here we document the various API functions
which deal with the SSL/TLS protocol context
defined in the __SSL_CTX__
structure.


int __SSL_CTX_add_client_CA__( SSL_CTX
*ctx, X509 *x);


long __SSL_CTX_add_extra_chain_cert__( SSL_CTX
*ctx, X509 *x509);


int __SSL_CTX_add_session__( SSL_CTX
*ctx, SSL_SESSION *c);


int __SSL_CTX_check_private_key__( SSL_CTX
*ctx);


long __SSL_CTX_ctrl__( SSL_CTX *ctx, int
cmd, long larg, char *parg);


void __SSL_CTX_flush_sessions__( SSL_CTX
*s, long t);


void __SSL_CTX_free__( SSL_CTX
*a);


char *__SSL_CTX_get_app_data__( SSL_CTX
*ctx);


X509_STORE *__SSL_CTX_get_cert_store__(
SSL_CTX *ctx);


STACK *__SSL_CTX_get_client_CA_list__( SSL_CTX
*ctx);


int (*__SSL_CTX_get_client_cert_cb__( SSL_CTX
*ctx))( SSL *ssl, X509 **x509,
EVP_PKEY **pkey);


char *__SSL_CTX_get_ex_data__( SSL_CTX
*s, int idx);


int __SSL_CTX_get_ex_new_index__(long argl, char
*argp, int (*new_func);(void), int (*dup_func)(void), void
(*free_func)(void))


void (*__SSL_CTX_get_info_callback__( SSL_CTX
*ctx))( SSL *ssl, int cb, int
ret);


int __SSL_CTX_get_quiet_shutdown__( SSL_CTX
*ctx);


int __SSL_CTX_get_session_cache_mode__(
SSL_CTX *ctx);


long __SSL_CTX_get_timeout__( SSL_CTX
*ctx);


int (*__SSL_CTX_get_verify_callback__( SSL_CTX
*ctx))(int ok, X509_STORE_CTX *ctx);


int __SSL_CTX_get_verify_mode__( SSL_CTX
*ctx);


int __SSL_CTX_load_verify_locations__( SSL_CTX
*ctx, char *CAfile, char *CApath);


long __SSL_CTX_need_tmp_RSA__( SSL_CTX
*ctx);


SSL_CTX *__SSL_CTX_new__( SSL_METHOD
*meth);


int __SSL_CTX_remove_session__( SSL_CTX
*ctx, SSL_SESSION *c);


int __SSL_CTX_sess_accept__( SSL_CTX
*ctx);


int __SSL_CTX_sess_accept_good__( SSL_CTX
*ctx);


int __SSL_CTX_sess_accept_renegotiate__(
SSL_CTX *ctx);


int __SSL_CTX_sess_cache_full__( SSL_CTX
*ctx);


int __SSL_CTX_sess_cb_hits__( SSL_CTX
*ctx);


int __SSL_CTX_sess_connect__( SSL_CTX
*ctx);


int __SSL_CTX_sess_connect_good__( SSL_CTX
*ctx);


int __SSL_CTX_sess_connect_renegotiate__(
SSL_CTX *ctx);


int __SSL_CTX_sess_get_cache_size__( SSL_CTX
*ctx);


SSL_SESSION *(*__SSL_CTX_sess_get_get_cb__(
SSL_CTX *ctx))( SSL *ssl, unsigned char
*data, int len, int *copy);


int (*__SSL_CTX_sess_get_new_cb__( SSL_CTX
*ctx)( SSL *ssl, SSL_SESSION
*sess);


void (*__SSL_CTX_sess_get_remove_cb__( SSL_CTX
*ctx)( SSL_CTX *ctx, SSL_SESSION
*sess);


int __SSL_CTX_sess_hits__( SSL_CTX
*ctx);


int __SSL_CTX_sess_misses__( SSL_CTX
*ctx);


int __SSL_CTX_sess_number__( SSL_CTX
*ctx);


void __SSL_CTX_sess_set_cache_size__( SSL_CTX
*ctx,t);


void __SSL_CTX_sess_set_get_cb__( SSL_CTX
*ctx, SSL_SESSION *(*cb)( SSL
*ssl, unsigned char *data, int len, int
*copy));


void __SSL_CTX_sess_set_new_cb__( SSL_CTX
*ctx, int (*cb)( SSL *ssl, SSL_SESSION
*sess));


void __SSL_CTX_sess_set_remove_cb__( SSL_CTX
*ctx, void (*cb)( SSL_CTX *ctx,
SSL_SESSION *sess));


int __SSL_CTX_sess_timeouts__( SSL_CTX
*ctx);


LHASH *__SSL_CTX_sessions__( SSL_CTX
*ctx);


void __SSL_CTX_set_app_data__( SSL_CTX
*ctx, void *arg);


void __SSL_CTX_set_cert_store__( SSL_CTX
*ctx, X509_STORE *cs);


void __SSL_CTX_set_cert_verify_cb__( SSL_CTX
*ctx, int (*cb)(), char *arg)


int __SSL_CTX_set_cipher_list__( SSL_CTX
*ctx, char *str);


void __SSL_CTX_set_client_CA_list__( SSL_CTX
*ctx, STACK *list);


void __SSL_CTX_set_client_cert_cb__( SSL_CTX
*ctx, int (*cb)( SSL *ssl, X509
**x509, EVP_PKEY **pkey));


void __SSL_CTX_set_default_passwd_cb__(
SSL_CTX *ctx, int (*cb);(void))


void __SSL_CTX_set_default_read_ahead__(
SSL_CTX *ctx, int m);


int __SSL_CTX_set_default_verify_paths__(
SSL_CTX *ctx);


int __SSL_CTX_set_ex_data__( SSL_CTX *s,
int idx, char *arg);


void __SSL_CTX_set_info_callback__( SSL_CTX
*ctx, void (*cb)( SSL *ssl, int cb, int
ret));


void __SSL_CTX_set_options__( SSL_CTX
*ctx, unsigned long op);


void __SSL_CTX_set_quiet_shutdown__( SSL_CTX
*ctx, int mode);


void __SSL_CTX_set_session_cache_mode__(
SSL_CTX *ctx, int mode);


int __SSL_CTX_set_ssl_version__( SSL_CTX
*ctx, SSL_METHOD *meth);


void __SSL_CTX_set_timeout__( SSL_CTX
*ctx, long t);


long __SSL_CTX_set_tmp_dh__(SSL_CTX* ctx, DH
*dh);


long __SSL_CTX_set_tmp_dh_callback__( SSL_CTX
*ctx, DH *(*cb)(void));


long __SSL_CTX_set_tmp_rsa__( SSL_CTX
*ctx, RSA *rsa);


SSL_CTX_set_tmp_rsa_callback


long SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx, RSA
*(*cb)(SSL *ssl, int export, int
keylength));


Sets the callback which will be called when a temporary
private key is required. The __export__ flag will be set
if the reason for needing a temp key is that an export
ciphersuite is in use, in which case, __keylength__ will
contain the required keylength in bits. Generate a key of
appropriate size (using ???) and return
it.


SSL_set_tmp_rsa_callback


long __SSL_set_tmp_rsa_callback__( SSL
*ssl, RSA *(*cb)( SSL *ssl, int
export, int keylength));


The same as ``SSL_CTX_set_tmp_rsa_callback'', except it
operates on an SSL session instead of a
context.


void __SSL_CTX_set_verify__( SSL_CTX
*ctx, int mode, int (*cb);(void))


int __SSL_CTX_use_!PrivateKey__( SSL_CTX
*ctx, EVP_PKEY *pkey);


int __SSL_CTX_use_!PrivateKey_ASN1__(int type,
SSL_CTX *ctx, unsigned char *d, long
len);


int __SSL_CTX_use_!PrivateKey_file__( SSL_CTX
*ctx, char *file, int type);


int __SSL_CTX_use_RSAPrivateKey__( SSL_CTX
*ctx, RSA *rsa);


int __SSL_CTX_use_RSAPrivateKey_ASN1__(
SSL_CTX *ctx, unsigned char *d, long
len);


int __SSL_CTX_use_RSAPrivateKey_file__(
SSL_CTX *ctx, char *file, int type);


int __SSL_CTX_use_certificate__( SSL_CTX
*ctx, X509 *x);


int __SSL_CTX_use_certificate_ASN1__( SSL_CTX
*ctx, int len, unsigned char *d);


int __SSL_CTX_use_certificate_file__( SSL_CTX
*ctx, char *file, int type);


__DEALING WITH SESSIONS__


Here we document the various API functions
which deal with the SSL/TLS sessions defined in
the __SSL_SESSION__
structures.


int __SSL_SESSION_cmp__( SSL_SESSION
*a, SSL_SESSION *b);


void __SSL_SESSION_free__( SSL_SESSION
*ss);


char *__SSL_SESSION_get_app_data__(
SSL_SESSION *s);


char *__SSL_SESSION_get_ex_data__( SSL_SESSION
*s, int idx);


int __SSL_SESSION_get_ex_new_index__(long argl, char
*argp, int (*new_func);(void), int (*dup_func)(void), void
(*free_func)(void))


long __SSL_SESSION_get_time__( SSL_SESSION
*s);


long __SSL_SESSION_get_timeout__( SSL_SESSION
*s);


unsigned long __SSL_SESSION_hash__(
SSL_SESSION *a);


SSL_SESSION
*__SSL_SESSION_new__(void);


int __SSL_SESSION_print__( BIO *bp,
SSL_SESSION *x);


int __SSL_SESSION_print_fp__( FILE
*fp, SSL_SESSION *x);


void __SSL_SESSION_set_app_data__( SSL_SESSION
*s, char *a);


int __SSL_SESSION_set_ex_data__( SSL_SESSION
*s, int idx, char *arg);


long __SSL_SESSION_set_time__( SSL_SESSION
*s, long t);


long __SSL_SESSION_set_timeout__( SSL_SESSION
*s, long t);


__DEALING WITH CONNECTIONS__


Here we document the various API functions
which deal with the SSL/TLS connection defined in
the __SSL__ structure.


int __SSL_accept__( SSL
*ssl);


int __SSL_add_dir_cert_subjects_to_stack__(
STACK *stack, const char *dir);


int __SSL_add_file_cert_subjects_to_stack__(
STACK *stack, const char *file);


int __SSL_add_client_CA__( SSL *ssl, X509
*x);


char *__SSL_alert_desc_string__(int
value);


char *__SSL_alert_desc_string_long__(int
value);


char *__SSL_alert_type_string__(int
value);


char *__SSL_alert_type_string_long__(int
value);


int __SSL_check_private_key__( SSL
*ssl);


void __SSL_clear__( SSL
*ssl);


long __SSL_clear_num_renegotiations__( SSL
*ssl);


int __SSL_connect__( SSL
*ssl);


void __SSL_copy_session_id__( SSL
*t, SSL *f);


long __SSL_ctrl__( SSL *ssl, int cmd,
long larg, char *parg);


int __SSL_do_handshake__( SSL
*ssl);


SSL *__SSL_dup__( SSL
*ssl);


STACK *__SSL_dup_CA_list__( STACK
*sk);


void __SSL_free__( SSL
*ssl);


SSL_CTX *__SSL_get_SSL_CTX__( SSL
*ssl);


char *__SSL_get_app_data__( SSL
*ssl);


X509 *__SSL_get_certificate__( SSL
*ssl);


const char *__SSL_get_cipher__( SSL
*ssl);


int __SSL_get_cipher_bits__( SSL *ssl,
int *alg_bits);


char *__SSL_get_cipher_list__( SSL *ssl,
int n);


char *__SSL_get_cipher_name__( SSL
*ssl);


char *__SSL_get_cipher_version__( SSL
*ssl);


STACK *__SSL_get_ciphers__( SSL
*ssl);


STACK *__SSL_get_client_CA_list__( SSL
*ssl);


SSL_CIPHER *__SSL_get_current_cipher__( SSL
*ssl);


long __SSL_get_default_timeout__( SSL
*ssl);


int __SSL_get_error__( SSL *ssl, int
i);


char *__SSL_get_ex_data__( SSL *ssl, int
idx);


int
__SSL_get_ex_data_X509_STORE_CTX_idx__(void);


int __SSL_get_ex_new_index__(long argl, char *argp,
int (*new_func);(void), int (*dup_func)(void), void
(*free_func)(void))


int __SSL_get_fd__( SSL
*ssl);


void (*__SSL_get_info_callback__( SSL
*ssl);)(void)


STACK *__SSL_get_peer_cert_chain__( SSL
*ssl);


X509 *__SSL_get_peer_certificate__( SSL
*ssl);


EVP_PKEY *__SSL_get_privatekey__( SSL
*ssl);


int __SSL_get_quiet_shutdown__( SSL
*ssl);


BIO *__SSL_get_rbio__( SSL
*ssl);


int __SSL_get_read_ahead__( SSL
*ssl);


SSL_SESSION *__SSL_get_session__( SSL
*ssl);


char *__SSL_get_shared_ciphers__( SSL
*ssl, char *buf, int len);


int __SSL_get_shutdown__( SSL
*ssl);


SSL_METHOD *__SSL_get_ssl_method__( SSL
*ssl);


int __SSL_get_state__( SSL
*ssl);


long __SSL_get_time__( SSL
*ssl);


long __SSL_get_timeout__( SSL
*ssl);


int (*__SSL_get_verify_callback__( SSL
*ssl);)(void)


int __SSL_get_verify_mode__( SSL
*ssl);


long __SSL_get_verify_result__( SSL
*ssl);


char *__SSL_get_version__( SSL
*ssl);


BIO *__SSL_get_wbio__( SSL
*ssl);


int __SSL_in_accept_init__( SSL
*ssl);


int __SSL_in_before__( SSL
*ssl);


int __SSL_in_connect_init__( SSL
*ssl);


int __SSL_in_init__( SSL
*ssl);


int __SSL_is_init_finished__( SSL
*ssl);


STACK *__SSL_load_client_CA_file__(char
*file);


void
__SSL_load_error_strings__(void);


SSL *__SSL_new__( SSL_CTX
*ctx);


long __SSL_num_renegotiations__( SSL
*ssl);


int __SSL_peek__( SSL *ssl, void *buf,
int num);


int __SSL_pending__( SSL
*ssl);


int __SSL_read__( SSL *ssl, void *buf,
int num);


int __SSL_renegotiate__( SSL
*ssl);


char *__SSL_rstate_string__( SSL
*ssl);


char *__SSL_rstate_string_long__( SSL
*ssl);


long __SSL_session_reused__( SSL
*ssl);


void __SSL_set_accept_state__( SSL
*ssl);


void __SSL_set_app_data__( SSL *ssl, char
*arg);


void __SSL_set_bio__( SSL *ssl, BIO
*rbio, BIO *wbio);


int __SSL_set_cipher_list__( SSL *ssl,
char *str);


void __SSL_set_client_CA_list__( SSL
*ssl, STACK *list);


void __SSL_set_connect_state__( SSL
*ssl);


int __SSL_set_ex_data__( SSL *ssl, int
idx, char *arg);


int __SSL_set_fd__( SSL *ssl, int
fd);


void __SSL_set_info_callback__( SSL *ssl,
void (*cb);(void))


void __SSL_set_options__( SSL *ssl,
unsigned long op);


void __SSL_set_quiet_shutdown__( SSL
*ssl, int mode);


void __SSL_set_read_ahead__( SSL *ssl,
int yes);


int __SSL_set_rfd__( SSL *ssl, int
fd);


int __SSL_set_session__( SSL *ssl,
SSL_SESSION *session);


void __SSL_set_shutdown__( SSL *ssl, int
mode);


int __SSL_set_ssl_method__( SSL
*ssl, SSL_METHOD *meth);


void __SSL_set_time__( SSL *ssl, long
t);


void __SSL_set_timeout__( SSL *ssl, long
t);


void __SSL_set_verify__( SSL *ssl, int
mode, int (*callback);(void))


void __SSL_set_verify_result__( SSL *ssl,
long arg);


int __SSL_set_wfd__( SSL *ssl, int
fd);


int __SSL_shutdown__( SSL
*ssl);


int __SSL_state__( SSL
*ssl);


char *__SSL_state_string__( SSL
*ssl);


char *__SSL_state_string_long__( SSL
*ssl);


long __SSL_total_renegotiations__( SSL
*ssl);


int __SSL_use_!PrivateKey__( SSL
*ssl, EVP_PKEY *pkey);


int __SSL_use_!PrivateKey_ASN1__(int type, SSL
*ssl, unsigned char *d, long len);


int __SSL_use_!PrivateKey_file__( SSL
*ssl, char *file, int type);


int __SSL_use_RSAPrivateKey__( SSL
*ssl, RSA *rsa);


int __SSL_use_RSAPrivateKey_ASN1__( SSL
*ssl, unsigned char *d, long len);


int __SSL_use_RSAPrivateKey_file__( SSL
*ssl, char *file, int type);


int __SSL_use_certificate__( SSL *ssl,
X509 *x);


int __SSL_use_certificate_ASN1__( SSL
*ssl, int len, unsigned char *d);


int __SSL_use_certificate_file__( SSL
*ssl, char *file, int type);


int __SSL_version__( SSL
*ssl);


int __SSL_want__( SSL
*ssl);


int __SSL_want_nothing__( SSL
*ssl);


int __SSL_want_read__( SSL
*ssl);


int __SSL_want_write__( SSL
*ssl);


int __SSL_want_x509_lookup__(s);


int __SSL_write__( SSL *ssl, const void
*buf, int num);
!!SEE ALSO


openssl(1), crypto(3),
''SSL_accept''(3), ''SSL_clear''(3),
''SSL_connect''(3), ''SSL_CIPHER_get_name''(3),
''SSL_COMP_add_compression_method''(3),
''SSL_CTX_add_extra_chain_cert''(3),
''SSL_CTX_add_session''(3), ''SSL_CTX_ctrl''(3),
''SSL_CTX_flush_sessions''(3),
''SSL_CTX_get_ex_new_index''(3),
''SSL_CTX_get_verify_mode''(3),
''SSL_CTX_load_verify_locations''(3)
''SSL_CTX_new''(3), ''SSL_CTX_sess_number''(3),
''SSL_CTX_sess_set_cache_size''(3),
''SSL_CTX_sess_set_get_cb''(3),
''SSL_CTX_sessions''(3),
''SSL_CTX_set_cert_store''(3),
''SSL_CTX_set_cert_verify_callback''(3),
''SSL_CTX_set_cipher_list''(3),
''SSL_CTX_set_client_CA_list''(3),
''SSL_CTX_set_default_passwd_cb''(3),
''SSL_CTX_set_info_callback''(3),
''SSL_CTX_set_mode''(3), ''SSL_CTX_set_options''(3),
''SSL_CTX_set_quiet_shutdown''(3),
''SSL_CTX_set_session_cache_mode''(3),
''SSL_CTX_set_session_id_context''(3),
''SSL_CTX_set_ssl_version''(3),
''SSL_CTX_set_timeout''(3),
''SSL_CTX_set_tmp_rsa_callback''(3),
''SSL_CTX_set_tmp_dh_callback''(3),
''SSL_CTX_set_verify''(3),
''SSL_CTX_use_certificate''(3),
''SSL_alert_type_string''(3), ''SSL_get_SSL_CTX''(3),
''SSL_get_ciphers''(3), ''SSL_get_client_CA_list''(3),
''SSL_get_default_timeout''(3), ''SSL_get_error''(3),
''SSL_get_ex_data_X509_STORE_CTX_idx''(3),
''SSL_get_ex_new_index''(3), ''SSL_get_fd''(3),
''SSL_get_peer_cert_chain''(3), ''SSL_get_rbio''(3),
''SSL_get_session''(3), ''SSL_get_verify_result''(3),
''SSL_get_version''(3), ''SSL_library_init''(3),
''SSL_load_client_CA_file''(3), ''SSL_new''(3),
''SSL_pending''(3), ''SSL_read''(3),
''SSL_rstate_string''(3), ''SSL_session_reused''(3),
''SSL_set_bio''(3), ''SSL_set_connect_state''(3),
''SSL_set_fd''(3), ''SSL_set_session''(3),
''SSL_set_shutdown''(3), ''SSL_shutdown''(3),
''SSL_state_string''(3), ''SSL_want''(3),
''SSL_write''(3), ''SSL_SESSION_free''(3),
''SSL_SESSION_get_ex_new_index''(3),
''SSL_SESSION_get_time''(3),
''d2i_SSL_SESSION''(3)
!!HISTORY


The ssl(3) document appeared in OpenSSL
0.9.2
----
3 pages link to ssl(3):
This page is a man page (or other imported legacy content). We are unable to automatically determine the license status of this page.
Last edited on Tuesday, June 4, 2002 12:24:35 am by "perry"
Edit PageHistory Diff Info LikePages