Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
ssl(3)                              OpenSSL                             ssl(3)

N
       SSL - OpenSSL SSL/TLS library

S
D
       The OpenSSL ssssll 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 SSSSLL_CCTTXX 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
       SSSSLL object. After the SSSSLL 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_con-
       nect(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.

D
       Currently the OpenSSL ssssll library functions deals with the following
       data structures:

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

       SSSSLL_CCIIPPHHEERR (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 SSSSLL_CCTTXX basis and the actually used
           ones are then part of the SSSSLL_SSEESSSSIIOONN.

       SSSSLL_CCTTXX (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 SSSSLL structures which are later created for the con-
           nections.

       SSSSLL_SSEESSSSIIOONN (SSL Session)
           This is a structure containing the current TLS/SSL session details
           for a connection: SSSSLL_CCIIPPHHEERRs, client and server certificates,
           keys, etc.

       SSSSLL (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 struc-
           ture in the SSL API.  Under run-time the application usually deals
           with this structure which has links to mostly all other structures.

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

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

       ssssll22..hh
           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.

       ssssll33..hh
           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.

       ssssll2233..hh
           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.

       ttllss11..hh
           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.

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

       DDEEAALLIINNGG WWIITTHH PPRROOTTOOCCOOLL MMEETTHHOODDSS

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

       SSL_METHOD *SSSSLLvv22_cclliieenntt_mmeetthhoodd(void);
           Constructor for the SSLv2 SSL_METHOD structure for a dedicated
           client.

       SSL_METHOD *SSSSLLvv22_sseerrvveerr_mmeetthhoodd(void);
           Constructor for the SSLv2 SSL_METHOD structure for a dedicated
           server.

       SSL_METHOD *SSSSLLvv22_mmeetthhoodd(void);
           Constructor for the SSLv2 SSL_METHOD structure for combined client
           and server.

       SSL_METHOD *SSSSLLvv33_cclliieenntt_mmeetthhoodd(void);
           Constructor for the SSLv3 SSL_METHOD structure for a dedicated
           client.

       SSL_METHOD *SSSSLLvv33_sseerrvveerr_mmeetthhoodd(void);
           Constructor for the SSLv3 SSL_METHOD structure for a dedicated
           server.

       SSL_METHOD *SSSSLLvv33_mmeetthhoodd(void);
           Constructor for the SSLv3 SSL_METHOD structure for combined client
           and server.

       SSL_METHOD *TTLLSSvv11_cclliieenntt_mmeetthhoodd(void);
           Constructor for the TLSv1 SSL_METHOD structure for a dedicated
           client.

       SSL_METHOD *TTLLSSvv11_sseerrvveerr_mmeetthhoodd(void);
           Constructor for the TLSv1 SSL_METHOD structure for a dedicated
           server.

       SSL_METHOD *TTLLSSvv11_mmeetthhoodd(void);
           Constructor for the TLSv1 SSL_METHOD structure for combined client
           and server.

       DDEEAALLIINNGG WWIITTHH CCIIPPHHEERRSS

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

       char *SSSSLL_CCIIPPHHEERR_ddeessccrriippttiioonn(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 SSSSLL_CCIIPPHHEERR_ggeett_bbiittss(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 gen-
           eral (stored to alg_bits) and the bits which are actually used (the
           return value).

       const char *SSSSLL_CCIIPPHHEERR_ggeett_nnaammee(SSL_CIPHER *cipher);
           Return the internal name of cipher as a string. These are the vari-
           ous strings defined by the SSL2_TXT_xxx, SSL3_TXT_xxx and
           TLS1_TXT_xxx definitions in the header files.

       char *SSSSLL_CCIIPPHHEERR_ggeett_vveerrssiioonn(SSL_CIPHER *cipher);
           Returns a string like ""TLSv1/SSLv3"" or ""SSLv2"" which indicates
           the SSL/TLS protocol version to which cipher belongs (i.e. where it
           was defined in the specification the first time).

       DDEEAALLIINNGG WWIITTHH PPRROOTTOOCCOOLL CCOONNTTEEXXTTSS

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

       int SSSSLL_CCTTXX_aadddd_cclliieenntt_CCAA(SSL_CTX *ctx, X509 *x);
       long SSSSLL_CCTTXX_aadddd_eexxttrraa_cchhaaiinn_cceerrtt(SSL_CTX *ctx, X509 *x509);
       int SSSSLL_CCTTXX_aadddd_sseessssiioonn(SSL_CTX *ctx, SSL_SESSION *c);
       int SSSSLL_CCTTXX_cchheecckk_pprriivvaattee_kkeeyy(SSL_CTX *ctx);
       long SSSSLL_CCTTXX_ccttrrll(SSL_CTX *ctx, int cmd, long larg, char *parg);
       void SSSSLL_CCTTXX_fflluusshh_sseessssiioonnss(SSL_CTX *s, long t);
       void SSSSLL_CCTTXX_ffrreeee(SSL_CTX *a);
       char *SSSSLL_CCTTXX_ggeett_aapppp_ddaattaa(SSL_CTX *ctx);
       X509_STORE *SSSSLL_CCTTXX_ggeett_cceerrtt_ssttoorree(SSL_CTX *ctx);
       STACK *SSSSLL_CCTTXX_ggeett_cclliieenntt_CCAA_lliisstt(SSL_CTX *ctx);
       int (*SSSSLL_CCTTXX_ggeett_cclliieenntt_cceerrtt_ccbb(SSL_CTX *ctx))(SSL *ssl, X509 **x509,
       EVP_PKEY **pkey);
       char *SSSSLL_CCTTXX_ggeett_eexx_ddaattaa(SSL_CTX *s, int idx);
       int SSSSLL_CCTTXX_ggeett_eexx_nneeww_iinnddeexx(long argl, char *argp, int
       (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
       void (*SSSSLL_CCTTXX_ggeett_iinnffoo_ccaallllbbaacckk(SSL_CTX *ctx))(SSL *ssl, int cb, int
       ret);
       int SSSSLL_CCTTXX_ggeett_qquuiieett_sshhuuttddoowwnn(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_ggeett_sseessssiioonn_ccaacchhee_mmooddee(SSL_CTX *ctx);
       long SSSSLL_CCTTXX_ggeett_ttiimmeeoouutt(SSL_CTX *ctx);
       int (*SSSSLL_CCTTXX_ggeett_vveerriiffyy_ccaallllbbaacckk(SSL_CTX *ctx))(int ok, X509_STORE_CTX
       *ctx);
       int SSSSLL_CCTTXX_ggeett_vveerriiffyy_mmooddee(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_llooaadd_vveerriiffyy_llooccaattiioonnss(SSL_CTX *ctx, char *CAfile, char
       *CApath);
       long SSSSLL_CCTTXX_nneeeedd_ttmmpp_RRSSAA(SSL_CTX *ctx);
       SSL_CTX *SSSSLL_CCTTXX_nneeww(SSL_METHOD *meth);
       int SSSSLL_CCTTXX_rreemmoovvee_sseessssiioonn(SSL_CTX *ctx, SSL_SESSION *c);
       int SSSSLL_CCTTXX_sseessss_aacccceepptt(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_aacccceepptt_ggoooodd(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_aacccceepptt_rreenneeggoottiiaattee(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_ccaacchhee_ffuullll(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_ccbb_hhiittss(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_ccoonnnneecctt(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_ccoonnnneecctt_ggoooodd(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_ccoonnnneecctt_rreenneeggoottiiaattee(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_ggeett_ccaacchhee_ssiizzee(SSL_CTX *ctx);
       SSL_SESSION *(*SSSSLL_CCTTXX_sseessss_ggeett_ggeett_ccbb(SSL_CTX *ctx))(SSL *ssl,
       unsigned char *data, int len, int *copy);
       int (*SSSSLL_CCTTXX_sseessss_ggeett_nneeww_ccbb(SSL_CTX *ctx)(SSL *ssl, SSL_SESSION
       *sess);
       void (*SSSSLL_CCTTXX_sseessss_ggeett_rreemmoovvee_ccbb(SSL_CTX *ctx)(SSL_CTX *ctx, SSL_SES-
       SION *sess);
       int SSSSLL_CCTTXX_sseessss_hhiittss(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_mmiisssseess(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseessss_nnuummbbeerr(SSL_CTX *ctx);
       void SSSSLL_CCTTXX_sseessss_sseett_ccaacchhee_ssiizzee(SSL_CTX *ctx,t);
       void SSSSLL_CCTTXX_sseessss_sseett_ggeett_ccbb(SSL_CTX *ctx, SSL_SESSION *(*cb)(SSL *ssl,
       unsigned char *data, int len, int *copy));
       void SSSSLL_CCTTXX_sseessss_sseett_nneeww_ccbb(SSL_CTX *ctx, int (*cb)(SSL *ssl, SSL_SES-
       SION *sess));
       void SSSSLL_CCTTXX_sseessss_sseett_rreemmoovvee_ccbb(SSL_CTX *ctx, void (*cb)(SSL_CTX *ctx,
       SSL_SESSION *sess));
       int SSSSLL_CCTTXX_sseessss_ttiimmeeoouuttss(SSL_CTX *ctx);
       LHASH *SSSSLL_CCTTXX_sseessssiioonnss(SSL_CTX *ctx);
       void SSSSLL_CCTTXX_sseett_aapppp_ddaattaa(SSL_CTX *ctx, void *arg);
       void SSSSLL_CCTTXX_sseett_cceerrtt_ssttoorree(SSL_CTX *ctx, X509_STORE *cs);
       void SSSSLL_CCTTXX_sseett_cceerrtt_vveerriiffyy_ccbb(SSL_CTX *ctx, int (*cb)(), char *arg)
       int SSSSLL_CCTTXX_sseett_cciipphheerr_lliisstt(SSL_CTX *ctx, char *str);
       void SSSSLL_CCTTXX_sseett_cclliieenntt_CCAA_lliisstt(SSL_CTX *ctx, STACK *list);
       void SSSSLL_CCTTXX_sseett_cclliieenntt_cceerrtt_ccbb(SSL_CTX *ctx, int (*cb)(SSL *ssl, X509
       **x509, EVP_PKEY **pkey));
       void SSSSLL_CCTTXX_sseett_ddeeffaauulltt_ppaasssswwdd_ccbb(SSL_CTX *ctx, int (*cb);(void))
       void SSSSLL_CCTTXX_sseett_ddeeffaauulltt_rreeaadd_aahheeaadd(SSL_CTX *ctx, int m);
       int SSSSLL_CCTTXX_sseett_ddeeffaauulltt_vveerriiffyy_ppaatthhss(SSL_CTX *ctx);
       int SSSSLL_CCTTXX_sseett_eexx_ddaattaa(SSL_CTX *s, int idx, char *arg);
       void SSSSLL_CCTTXX_sseett_iinnffoo_ccaallllbbaacckk(SSL_CTX *ctx, void (*cb)(SSL *ssl, int
       cb, int ret));
       void SSSSLL_CCTTXX_sseett_mmssgg_ccaallllbbaacckk(SSL_CTX *ctx, void (*cb)(int write_p, int
       version, int content_type, const void *buf, size_t len, SSL *ssl, void
       *arg));
       void SSSSLL_CCTTXX_sseett_mmssgg_ccaallllbbaacckk_aarrgg(SSL_CTX *ctx, void *arg);
       void SSSSLL_CCTTXX_sseett_ooppttiioonnss(SSL_CTX *ctx, unsigned long op);
       void SSSSLL_CCTTXX_sseett_qquuiieett_sshhuuttddoowwnn(SSL_CTX *ctx, int mode);
       void SSSSLL_CCTTXX_sseett_sseessssiioonn_ccaacchhee_mmooddee(SSL_CTX *ctx, int mode);
       int SSSSLL_CCTTXX_sseett_ssssll_vveerrssiioonn(SSL_CTX *ctx, SSL_METHOD *meth);
       void SSSSLL_CCTTXX_sseett_ttiimmeeoouutt(SSL_CTX *ctx, long t);
       long SSSSLL_CCTTXX_sseett_ttmmpp_ddhh(SSL_CTX* ctx, DH *dh);
       long SSSSLL_CCTTXX_sseett_ttmmpp_ddhh_ccaallllbbaacckk(SSL_CTX *ctx, DH *(*cb)(void));
       long SSSSLL_CCTTXX_sseett_ttmmpp_rrssaa(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 ""eexxppoorrtt"" flag will be set if the reason for need-
           ing a temp key is that an export ciphersuite is in use, in which
           case, ""kkeeyylleennggtthh"" will contain the required keylength in bits. Gen-
           erate a key of appropriate size (using ???) and return it.

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

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

       void SSSSLL_CCTTXX_sseett_vveerriiffyy(SSL_CTX *ctx, int mode, int (*cb);(void))
       int SSSSLL_CCTTXX_uussee_PPrriivvaatteeKKeeyy(SSL_CTX *ctx, EVP_PKEY *pkey);
       int SSSSLL_CCTTXX_uussee_PPrriivvaatteeKKeeyy_AASSNN11(int type, SSL_CTX *ctx, unsigned char
       *d, long len);
       int SSSSLL_CCTTXX_uussee_PPrriivvaatteeKKeeyy_ffiillee(SSL_CTX *ctx, char *file, int type);
       int SSSSLL_CCTTXX_uussee_RRSSAAPPrriivvaatteeKKeeyy(SSL_CTX *ctx, RSA *rsa);
       int SSSSLL_CCTTXX_uussee_RRSSAAPPrriivvaatteeKKeeyy_AASSNN11(SSL_CTX *ctx, unsigned char *d, long
       len);
       int SSSSLL_CCTTXX_uussee_RRSSAAPPrriivvaatteeKKeeyy_ffiillee(SSL_CTX *ctx, char *file, int type);
       int SSSSLL_CCTTXX_uussee_cceerrttiiffiiccaattee(SSL_CTX *ctx, X509 *x);
       int SSSSLL_CCTTXX_uussee_cceerrttiiffiiccaattee_AASSNN11(SSL_CTX *ctx, int len, unsigned char
       *d);
       int SSSSLL_CCTTXX_uussee_cceerrttiiffiiccaattee_ffiillee(SSL_CTX *ctx, char *file, int type);

       DDEEAALLIINNGG WWIITTHH SSEESSSSIIOONNSS

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

       int SSSSLL_SSEESSSSIIOONN_ccmmpp(SSL_SESSION *a, SSL_SESSION *b);
       void SSSSLL_SSEESSSSIIOONN_ffrreeee(SSL_SESSION *ss);
       char *SSSSLL_SSEESSSSIIOONN_ggeett_aapppp_ddaattaa(SSL_SESSION *s);
       char *SSSSLL_SSEESSSSIIOONN_ggeett_eexx_ddaattaa(SSL_SESSION *s, int idx);
       int SSSSLL_SSEESSSSIIOONN_ggeett_eexx_nneeww_iinnddeexx(long argl, char *argp, int
       (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
       long SSSSLL_SSEESSSSIIOONN_ggeett_ttiimmee(SSL_SESSION *s);
       long SSSSLL_SSEESSSSIIOONN_ggeett_ttiimmeeoouutt(SSL_SESSION *s);
       unsigned long SSSSLL_SSEESSSSIIOONN_hhaasshh(SSL_SESSION *a);
       SSL_SESSION *SSSSLL_SSEESSSSIIOONN_nneeww(void);
       int SSSSLL_SSEESSSSIIOONN_pprriinntt(BIO *bp, SSL_SESSION *x);
       int SSSSLL_SSEESSSSIIOONN_pprriinntt_ffpp(FILE *fp, SSL_SESSION *x);
       void SSSSLL_SSEESSSSIIOONN_sseett_aapppp_ddaattaa(SSL_SESSION *s, char *a);
       int SSSSLL_SSEESSSSIIOONN_sseett_eexx_ddaattaa(SSL_SESSION *s, int idx, char *arg);
       long SSSSLL_SSEESSSSIIOONN_sseett_ttiimmee(SSL_SESSION *s, long t);
       long SSSSLL_SSEESSSSIIOONN_sseett_ttiimmeeoouutt(SSL_SESSION *s, long t);

       DDEEAALLIINNGG WWIITTHH CCOONNNNEECCTTIIOONNSS

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

       int SSSSLL_aacccceepptt(SSL *ssl);
       int SSSSLL_aadddd_ddiirr_cceerrtt_ssuubbjjeeccttss_ttoo_ssttaacckk(STACK *stack, const char *dir);
       int SSSSLL_aadddd_ffiillee_cceerrtt_ssuubbjjeeccttss_ttoo_ssttaacckk(STACK *stack, const char
       *file);
       int SSSSLL_aadddd_cclliieenntt_CCAA(SSL *ssl, X509 *x);
       char *SSSSLL_aalleerrtt_ddeesscc_ssttrriinngg(int value);
       char *SSSSLL_aalleerrtt_ddeesscc_ssttrriinngg_lloonngg(int value);
       char *SSSSLL_aalleerrtt_ttyyppee_ssttrriinngg(int value);
       char *SSSSLL_aalleerrtt_ttyyppee_ssttrriinngg_lloonngg(int value);
       int SSSSLL_cchheecckk_pprriivvaattee_kkeeyy(SSL *ssl);
       void SSSSLL_cclleeaarr(SSL *ssl);
       long SSSSLL_cclleeaarr_nnuumm_rreenneeggoottiiaattiioonnss(SSL *ssl);
       int SSSSLL_ccoonnnneecctt(SSL *ssl);
       void SSSSLL_ccooppyy_sseessssiioonn_iidd(SSL *t, SSL *f);
       long SSSSLL_ccttrrll(SSL *ssl, int cmd, long larg, char *parg);
       int SSSSLL_ddoo_hhaannddsshhaakkee(SSL *ssl);
       SSL *SSSSLL_dduupp(SSL *ssl);
       STACK *SSSSLL_dduupp_CCAA_lliisstt(STACK *sk);
       void SSSSLL_ffrreeee(SSL *ssl);
       SSL_CTX *SSSSLL_ggeett_SSSSLL_CCTTXX(SSL *ssl);
       char *SSSSLL_ggeett_aapppp_ddaattaa(SSL *ssl);
       X509 *SSSSLL_ggeett_cceerrttiiffiiccaattee(SSL *ssl);
       const char *SSSSLL_ggeett_cciipphheerr(SSL *ssl);
       int SSSSLL_ggeett_cciipphheerr_bbiittss(SSL *ssl, int *alg_bits);
       char *SSSSLL_ggeett_cciipphheerr_lliisstt(SSL *ssl, int n);
       char *SSSSLL_ggeett_cciipphheerr_nnaammee(SSL *ssl);
       char *SSSSLL_ggeett_cciipphheerr_vveerrssiioonn(SSL *ssl);
       STACK *SSSSLL_ggeett_cciipphheerrss(SSL *ssl);
       STACK *SSSSLL_ggeett_cclliieenntt_CCAA_lliisstt(SSL *ssl);
       SSL_CIPHER *SSSSLL_ggeett_ccuurrrreenntt_cciipphheerr(SSL *ssl);
       long SSSSLL_ggeett_ddeeffaauulltt_ttiimmeeoouutt(SSL *ssl);
       int SSSSLL_ggeett_eerrrroorr(SSL *ssl, int i);
       char *SSSSLL_ggeett_eexx_ddaattaa(SSL *ssl, int idx);
       int SSSSLL_ggeett_eexx_ddaattaa_XX550099_SSTTOORREE_CCTTXX_iiddxx(void);
       int SSSSLL_ggeett_eexx_nneeww_iinnddeexx(long argl, char *argp, int (*new_func);(void),
       int (*dup_func)(void), void (*free_func)(void))
       int SSSSLL_ggeett_ffdd(SSL *ssl);
       void (*SSSSLL_ggeett_iinnffoo_ccaallllbbaacckk(SSL *ssl);)(void)
       STACK *SSSSLL_ggeett_ppeeeerr_cceerrtt_cchhaaiinn(SSL *ssl);
       X509 *SSSSLL_ggeett_ppeeeerr_cceerrttiiffiiccaattee(SSL *ssl);
       EVP_PKEY *SSSSLL_ggeett_pprriivvaatteekkeeyy(SSL *ssl);
       int SSSSLL_ggeett_qquuiieett_sshhuuttddoowwnn(SSL *ssl);
       BIO *SSSSLL_ggeett_rrbbiioo(SSL *ssl);
       int SSSSLL_ggeett_rreeaadd_aahheeaadd(SSL *ssl);
       SSL_SESSION *SSSSLL_ggeett_sseessssiioonn(SSL *ssl);
       char *SSSSLL_ggeett_sshhaarreedd_cciipphheerrss(SSL *ssl, char *buf, int len);
       int SSSSLL_ggeett_sshhuuttddoowwnn(SSL *ssl);
       SSL_METHOD *SSSSLL_ggeett_ssssll_mmeetthhoodd(SSL *ssl);
       int SSSSLL_ggeett_ssttaattee(SSL *ssl);
       long SSSSLL_ggeett_ttiimmee(SSL *ssl);
       long SSSSLL_ggeett_ttiimmeeoouutt(SSL *ssl);
       int (*SSSSLL_ggeett_vveerriiffyy_ccaallllbbaacckk(SSL *ssl);)(void)
       int SSSSLL_ggeett_vveerriiffyy_mmooddee(SSL *ssl);
       long SSSSLL_ggeett_vveerriiffyy_rreessuulltt(SSL *ssl);
       char *SSSSLL_ggeett_vveerrssiioonn(SSL *ssl);
       BIO *SSSSLL_ggeett_wwbbiioo(SSL *ssl);
       int SSSSLL_iinn_aacccceepptt_iinniitt(SSL *ssl);
       int SSSSLL_iinn_bbeeffoorree(SSL *ssl);
       int SSSSLL_iinn_ccoonnnneecctt_iinniitt(SSL *ssl);
       int SSSSLL_iinn_iinniitt(SSL *ssl);
       int SSSSLL_iiss_iinniitt_ffiinniisshheedd(SSL *ssl);
       STACK *SSSSLL_llooaadd_cclliieenntt_CCAA_ffiillee(char *file);
       void SSSSLL_llooaadd_eerrrroorr_ssttrriinnggss(void);
       SSL *SSSSLL_nneeww(SSL_CTX *ctx);
       long SSSSLL_nnuumm_rreenneeggoottiiaattiioonnss(SSL *ssl);
       int SSSSLL_ppeeeekk(SSL *ssl, void *buf, int num);
       int SSSSLL_ppeennddiinngg(SSL *ssl);
       int SSSSLL_rreeaadd(SSL *ssl, void *buf, int num);
       int SSSSLL_rreenneeggoottiiaattee(SSL *ssl);
       char *SSSSLL_rrssttaattee_ssttrriinngg(SSL *ssl);
       char *SSSSLL_rrssttaattee_ssttrriinngg_lloonngg(SSL *ssl);
       long SSSSLL_sseessssiioonn_rreeuusseedd(SSL *ssl);
       void SSSSLL_sseett_aacccceepptt_ssttaattee(SSL *ssl);
       void SSSSLL_sseett_aapppp_ddaattaa(SSL *ssl, char *arg);
       void SSSSLL_sseett_bbiioo(SSL *ssl, BIO *rbio, BIO *wbio);
       int SSSSLL_sseett_cciipphheerr_lliisstt(SSL *ssl, char *str);
       void SSSSLL_sseett_cclliieenntt_CCAA_lliisstt(SSL *ssl, STACK *list);
       void SSSSLL_sseett_ccoonnnneecctt_ssttaattee(SSL *ssl);
       int SSSSLL_sseett_eexx_ddaattaa(SSL *ssl, int idx, char *arg);
       int SSSSLL_sseett_ffdd(SSL *ssl, int fd);
       void SSSSLL_sseett_iinnffoo_ccaallllbbaacckk(SSL *ssl, void (*cb);(void))
       void SSSSLL_sseett_mmssgg_ccaallllbbaacckk(SSL *ctx, void (*cb)(int write_p, int ver-
       sion, int content_type, const void *buf, size_t len, SSL *ssl, void
       *arg));
       void SSSSLL_sseett_mmssgg_ccaallllbbaacckk_aarrgg(SSL *ctx, void *arg);
       void SSSSLL_sseett_ooppttiioonnss(SSL *ssl, unsigned long op);
       void SSSSLL_sseett_qquuiieett_sshhuuttddoowwnn(SSL *ssl, int mode);
       void SSSSLL_sseett_rreeaadd_aahheeaadd(SSL *ssl, int yes);
       int SSSSLL_sseett_rrffdd(SSL *ssl, int fd);
       int SSSSLL_sseett_sseessssiioonn(SSL *ssl, SSL_SESSION *session);
       void SSSSLL_sseett_sshhuuttddoowwnn(SSL *ssl, int mode);
       int SSSSLL_sseett_ssssll_mmeetthhoodd(SSL *ssl, SSL_METHOD *meth);
       void SSSSLL_sseett_ttiimmee(SSL *ssl, long t);
       void SSSSLL_sseett_ttiimmeeoouutt(SSL *ssl, long t);
       void SSSSLL_sseett_vveerriiffyy(SSL *ssl, int mode, int (*callback);(void))
       void SSSSLL_sseett_vveerriiffyy_rreessuulltt(SSL *ssl, long arg);
       int SSSSLL_sseett_wwffdd(SSL *ssl, int fd);
       int SSSSLL_sshhuuttddoowwnn(SSL *ssl);
       int SSSSLL_ssttaattee(SSL *ssl);
       char *SSSSLL_ssttaattee_ssttrriinngg(SSL *ssl);
       char *SSSSLL_ssttaattee_ssttrriinngg_lloonngg(SSL *ssl);
       long SSSSLL_ttoottaall_rreenneeggoottiiaattiioonnss(SSL *ssl);
       int SSSSLL_uussee_PPrriivvaatteeKKeeyy(SSL *ssl, EVP_PKEY *pkey);
       int SSSSLL_uussee_PPrriivvaatteeKKeeyy_AASSNN11(int type, SSL *ssl, unsigned char *d, long
       len);
       int SSSSLL_uussee_PPrriivvaatteeKKeeyy_ffiillee(SSL *ssl, char *file, int type);
       int SSSSLL_uussee_RRSSAAPPrriivvaatteeKKeeyy(SSL *ssl, RSA *rsa);
       int SSSSLL_uussee_RRSSAAPPrriivvaatteeKKeeyy_AASSNN11(SSL *ssl, unsigned char *d, long len);
       int SSSSLL_uussee_RRSSAAPPrriivvaatteeKKeeyy_ffiillee(SSL *ssl, char *file, int type);
       int SSSSLL_uussee_cceerrttiiffiiccaattee(SSL *ssl, X509 *x);
       int SSSSLL_uussee_cceerrttiiffiiccaattee_AASSNN11(SSL *ssl, int len, unsigned char *d);
       int SSSSLL_uussee_cceerrttiiffiiccaattee_ffiillee(SSL *ssl, char *file, int type);
       int SSSSLL_vveerrssiioonn(SSL *ssl);
       int SSSSLL_wwaanntt(SSL *ssl);
       int SSSSLL_wwaanntt_nnootthhiinngg(SSL *ssl);
       int SSSSLL_wwaanntt_rreeaadd(SSL *ssl);
       int SSSSLL_wwaanntt_wwrriittee(SSL *ssl);
       int SSSSLL_wwaanntt_xx550099_llooookkuupp(s);
       int SSSSLL_wwrriittee(SSL *ssl, const void *buf, int num);

S
       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_num-
       ber(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_ver-
       ify_callback(3), SSL_CTX_set_cipher_list(3),
       SSL_CTX_set_client_CA_list(3), SSL_CTX_set_client_cert_cb(3),
       SSL_CTX_set_default_passwd_cb(3), SSL_CTX_set_generate_session_id(3),
       SSL_CTX_set_info_callback(3), SSL_CTX_set_max_cert_list(3),
       SSL_CTX_set_mode(3), SSL_CTX_set_msg_callback(3),
       SSL_CTX_set_options(3), SSL_CTX_set_quiet_shutdown(3), SSL_CTX_set_ses-
       sion_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_do_handshake(3), SSL_get_SSL_CTX(3),
       SSL_get_ciphers(3), SSL_get_client_CA_list(3), SSL_get_default_time-
       out(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_ses-
       sion_reused(3), SSL_set_bio(3), SSL_set_connect_state(3),
       SSL_set_fd(3), SSL_set_session(3), SSL_set_shutdown(3), SSL_shut-
       down(3), SSL_state_string(3), SSL_want(3), SSL_write(3), SSL_SES-
       SION_free(3), SSL_SESSION_get_ex_new_index(3), SSL_SESSION_get_time(3),
       d2i_SSL_SESSION(3)

H
       The ssl(3) document appeared in OpenSSL 0.9.2

3rd Berkeley Distribution           0.9.7a                              ssl(3)

N | S | D | D | H | A | S | H

Want to link to this manual page? Use this URL:
<
https://www.freebsd.org/cgi/man.cgi?query=ssl&sektion=3&manpath=FreeBSD+6.2-RELEASE>

home | help