ssl(3) OpenSSL ssl(3)

NAME
       SSL - OpenSSL SSL/TLS library

SYNOPSIS
DESCRIPTION
       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 SSLlibraryinit(3).

       Then an SSSSLLCCTTXX object is created as a framework to establish TLS/SSL
       enabled connections (see SSLCTXnew(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 SSLnew(3),
       SSLsetfd(3) or SSLsetbio(3) can be used to associate the network
       connection with the object.

       Then the TLS/SSL handshake is performed using SSLaccept(3) or
       SSLconnect(3) respectively.  SSLread(3) and SSLwrite(3) are used to
       read and write data on the TLS/SSL connection.  SSLshutdown(3) can be
       used to shut down the TLS/SSL connection.

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

       SSSSLLMMEETTHHOODD (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 SSSSLLCCTTXX.

       SSSSLLCCIIPPHHEERR (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 SSSSLLCCTTXX basis and the actually used
           ones are then part of the SSSSLLSSEESSSSIIOONN.

       SSSSLLCCTTXX (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
           connections.

       SSSSLLSSEESSSSIIOONN (SSL Session)
           This is a structure containing the current TLS/SSL session details
           for a connection: SSSSLLCCIIPPHHEERRs, 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
           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 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.

AAPPII FFUUNNCCTTIIOONNSS
       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 SSSSLLMMEETTHHOODD structures.

       SSLMETHOD *SSSSLLvv22cclliieennttmmeetthhoodd(void);
           Constructor for the SSLv2 SSLMETHOD structure for a dedicated
           client.

       SSLMETHOD *SSSSLLvv22sseerrvveerrmmeetthhoodd(void);
           Constructor for the SSLv2 SSLMETHOD structure for a dedicated
           server.

       SSLMETHOD *SSSSLLvv22mmeetthhoodd(void);
           Constructor for the SSLv2 SSLMETHOD structure for combined client
           and server.

       SSLMETHOD *SSSSLLvv33cclliieennttmmeetthhoodd(void);
           Constructor for the SSLv3 SSLMETHOD structure for a dedicated
           client.

       SSLMETHOD *SSSSLLvv33sseerrvveerrmmeetthhoodd(void);
           Constructor for the SSLv3 SSLMETHOD structure for a dedicated
           server.

       SSLMETHOD *SSSSLLvv33mmeetthhoodd(void);
           Constructor for the SSLv3 SSLMETHOD structure for combined client
           and server.

       SSLMETHOD *TTLLSSvv11cclliieennttmmeetthhoodd(void);
           Constructor for the TLSv1 SSLMETHOD structure for a dedicated
           client.

       SSLMETHOD *TTLLSSvv11sseerrvveerrmmeetthhoodd(void);
           Constructor for the TLSv1 SSLMETHOD structure for a dedicated
           server.

       SSLMETHOD *TTLLSSvv11mmeetthhoodd(void);
           Constructor for the TLSv1 SSLMETHOD 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 SSSSLLCCIIPPHHEERR structures.

       char *SSSSLLCCIIPPHHEERRddeessccrriippttiioonn(SSLCIPHER *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 SSSSLLCCIIPPHHEERRggeettbbiittss(SSLCIPHER *cipher, int *algbits);
           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 algbits) and the bits which are actually used
           (the return value).

       const char *SSSSLLCCIIPPHHEERRggeettnnaammee(SSLCIPHER *cipher);
           Return the internal name of cipher as a string. These are the
           various strings defined by the SSL2TXTxxx, SSL3TXTxxx and
           TLS1TXTxxx definitions in the header files.

       char *SSSSLLCCIIPPHHEERRggeettvveerrssiioonn(SSLCIPHER *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 SSSSLLCCTTXX structure.

       int SSSSLLCCTTXXaaddddcclliieennttCCAA(SSLCTX *ctx, X509 *x);
       long SSSSLLCCTTXXaaddddeexxttrraacchhaaiinncceerrtt(SSLCTX *ctx, X509 *x509);
       int SSSSLLCCTTXXaaddddsseessssiioonn(SSLCTX *ctx, SSLSESSION *c);
       int SSSSLLCCTTXXcchheecckkpprriivvaatteekkeeyy(const SSLCTX *ctx);
       long SSSSLLCCTTXXccttrrll(SSLCTX *ctx, int cmd, long larg, char *parg);
       void SSSSLLCCTTXXfflluusshhsseessssiioonnss(SSLCTX *s, long t);
       void SSSSLLCCTTXXffrreeee(SSLCTX *a);
       char *SSSSLLCCTTXXggeettaappppddaattaa(SSLCTX *ctx);
       X509STORE *SSSSLLCCTTXXggeettcceerrttssttoorree(SSLCTX *ctx);
       STACK *SSSSLLCCTTXXggeettcclliieennttCCAAlliisstt(const SSLCTX *ctx);
       int (*SSSSLLCCTTXXggeettcclliieennttcceerrttccbb(SSLCTX *ctx))(SSL *ssl, X509 **x509,
       EVPPKEY **pkey);
       char *SSSSLLCCTTXXggeetteexxddaattaa(const SSLCTX *s, int idx);
       int SSSSLLCCTTXXggeetteexxnneewwiinnddeexx(long argl, char *argp, int
       (*newfunc);(void), int (*dupfunc)(void), void (*freefunc)(void))
       void (*SSSSLLCCTTXXggeettiinnffooccaallllbbaacckk(SSLCTX *ctx))(SSL *ssl, int cb, int
       ret);
       int SSSSLLCCTTXXggeettqquuiieettsshhuuttddoowwnn(const SSLCTX *ctx);
       int SSSSLLCCTTXXggeettsseessssiioonnccaacchheemmooddee(SSLCTX *ctx);
       long SSSSLLCCTTXXggeettttiimmeeoouutt(const SSLCTX *ctx);
       int (*SSSSLLCCTTXXggeettvveerriiffyyccaallllbbaacckk(const SSLCTX *ctx))(int ok,
       X509STORECTX *ctx);
       int SSSSLLCCTTXXggeettvveerriiffyymmooddee(SSLCTX *ctx);
       int SSSSLLCCTTXXllooaaddvveerriiffyyllooccaattiioonnss(SSLCTX *ctx, char *CAfile, char
       *CApath);
       long SSSSLLCCTTXXnneeeeddttmmppRRSSAA(SSLCTX *ctx);
       SSLCTX *SSSSLLCCTTXXnneeww(SSLMETHOD *meth);
       int SSSSLLCCTTXXrreemmoovveesseessssiioonn(SSLCTX *ctx, SSLSESSION *c);
       int SSSSLLCCTTXXsseessssaacccceepptt(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssaacccceeppttggoooodd(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssaacccceeppttrreenneeggoottiiaattee(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssccaacchheeffuullll(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssccbbhhiittss(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssccoonnnneecctt(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssccoonnnneeccttggoooodd(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssccoonnnneeccttrreenneeggoottiiaattee(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssggeettccaacchheessiizzee(SSLCTX *ctx);
       SSLSESSION *(*SSSSLLCCTTXXsseessssggeettggeettccbb(SSLCTX *ctx))(SSL *ssl,
       unsigned char *data, int len, int *copy);
       int (*SSSSLLCCTTXXsseessssggeettnneewwccbb(SSLCTX *ctx)(SSL *ssl, SSLSESSION
       *sess);
       void (*SSSSLLCCTTXXsseessssggeettrreemmoovveeccbb(SSLCTX *ctx)(SSLCTX *ctx,
       SSLSESSION *sess);
       int SSSSLLCCTTXXsseesssshhiittss(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssmmiisssseess(SSLCTX *ctx);
       int SSSSLLCCTTXXsseessssnnuummbbeerr(SSLCTX *ctx);
       void SSSSLLCCTTXXsseesssssseettccaacchheessiizzee(SSLCTX *ctx,t);
       void SSSSLLCCTTXXsseesssssseettggeettccbb(SSLCTX *ctx, SSLSESSION *(*cb)(SSL *ssl,
       unsigned char *data, int len, int *copy));
       void SSSSLLCCTTXXsseesssssseettnneewwccbb(SSLCTX *ctx, int (*cb)(SSL *ssl,
       SSLSESSION *sess));
       void SSSSLLCCTTXXsseesssssseettrreemmoovveeccbb(SSLCTX *ctx, void (*cb)(SSLCTX *ctx,
       SSLSESSION *sess));
       int SSSSLLCCTTXXsseessssttiimmeeoouuttss(SSLCTX *ctx);
       LHASH *SSSSLLCCTTXXsseessssiioonnss(SSLCTX *ctx);
       void SSSSLLCCTTXXsseettaappppddaattaa(SSLCTX *ctx, void *arg);
       void SSSSLLCCTTXXsseettcceerrttssttoorree(SSLCTX *ctx, X509STORE *cs);
       void SSSSLLCCTTXXsseettcceerrttvveerriiffyyccbb(SSLCTX *ctx, int (*cb)(), char *arg)
       int SSSSLLCCTTXXsseettcciipphheerrlliisstt(SSLCTX *ctx, char *str);
       void SSSSLLCCTTXXsseettcclliieennttCCAAlliisstt(SSLCTX *ctx, STACK *list);
       void SSSSLLCCTTXXsseettcclliieennttcceerrttccbb(SSLCTX *ctx, int (*cb)(SSL *ssl, X509
       **x509, EVPPKEY **pkey));
       void SSSSLLCCTTXXsseettddeeffaauullttppaasssswwddccbb(SSLCTX *ctx, int (*cb);(void))
       void SSSSLLCCTTXXsseettddeeffaauullttrreeaaddaahheeaadd(SSLCTX *ctx, int m);
       int SSSSLLCCTTXXsseettddeeffaauullttvveerriiffyyppaatthhss(SSLCTX *ctx);
       int SSSSLLCCTTXXsseetteexxddaattaa(SSLCTX *s, int idx, char *arg);
       void SSSSLLCCTTXXsseettiinnffooccaallllbbaacckk(SSLCTX *ctx, void (*cb)(SSL *ssl, int
       cb, int ret));
       void SSSSLLCCTTXXsseettmmssggccaallllbbaacckk(SSLCTX *ctx, void (*cb)(int writep, int
       version, int contenttype, const void *buf, sizet len, SSL *ssl, void
       *arg));
       void SSSSLLCCTTXXsseettmmssggccaallllbbaacckkaarrgg(SSLCTX *ctx, void *arg);
       void SSSSLLCCTTXXsseettooppttiioonnss(SSLCTX *ctx, unsigned long op);
       void SSSSLLCCTTXXsseettqquuiieettsshhuuttddoowwnn(SSLCTX *ctx, int mode);
       void SSSSLLCCTTXXsseettsseessssiioonnccaacchheemmooddee(SSLCTX *ctx, int mode);
       int SSSSLLCCTTXXsseettssssllvveerrssiioonn(SSLCTX *ctx, SSLMETHOD *meth);
       void SSSSLLCCTTXXsseettttiimmeeoouutt(SSLCTX *ctx, long t);
       long SSSSLLCCTTXXsseettttmmppddhh(SSLCTX* ctx, DH *dh);
       long SSSSLLCCTTXXsseettttmmppddhhccaallllbbaacckk(SSLCTX *ctx, DH *(*cb)(void));
       long SSSSLLCCTTXXsseettttmmpprrssaa(SSLCTX *ctx, RSA *rsa);
       SSLCTXsettmprsacallback
           "long SSLCTXsettmprsacallback(SSLCTX *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
           needing a temp key is that an export ciphersuite is in use, in
           which case, ""kkeeyylleennggtthh"" will contain the required keylength in
           bits. Generate a key of appropriate size (using ???) and return it.

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

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

       void SSSSLLCCTTXXsseettvveerriiffyy(SSLCTX *ctx, int mode, int (*cb);(void))
       int SSSSLLCCTTXXuusseePPrriivvaatteeKKeeyy(SSLCTX *ctx, EVPPKEY *pkey);
       int SSSSLLCCTTXXuusseePPrriivvaatteeKKeeyyAASSNN11(int type, SSLCTX *ctx, unsigned char
       *d, long len);
       int SSSSLLCCTTXXuusseePPrriivvaatteeKKeeyyffiillee(SSLCTX *ctx, char *file, int type);
       int SSSSLLCCTTXXuusseeRRSSAAPPrriivvaatteeKKeeyy(SSLCTX *ctx, RSA *rsa);
       int SSSSLLCCTTXXuusseeRRSSAAPPrriivvaatteeKKeeyyAASSNN11(SSLCTX *ctx, unsigned char *d, long
       len);
       int SSSSLLCCTTXXuusseeRRSSAAPPrriivvaatteeKKeeyyffiillee(SSLCTX *ctx, char *file, int type);
       int SSSSLLCCTTXXuusseecceerrttiiffiiccaattee(SSLCTX *ctx, X509 *x);
       int SSSSLLCCTTXXuusseecceerrttiiffiiccaatteeAASSNN11(SSLCTX *ctx, int len, unsigned char
       *d);
       int SSSSLLCCTTXXuusseecceerrttiiffiiccaatteeffiillee(SSLCTX *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 SSSSLLSSEESSSSIIOONN structures.

       int SSSSLLSSEESSSSIIOONNccmmpp(const SSLSESSION *a, const SSLSESSION *b);
       void SSSSLLSSEESSSSIIOONNffrreeee(SSLSESSION *ss);
       char *SSSSLLSSEESSSSIIOONNggeettaappppddaattaa(SSLSESSION *s);
       char *SSSSLLSSEESSSSIIOONNggeetteexxddaattaa(const SSLSESSION *s, int idx);
       int SSSSLLSSEESSSSIIOONNggeetteexxnneewwiinnddeexx(long argl, char *argp, int
       (*newfunc);(void), int (*dupfunc)(void), void (*freefunc)(void))
       long SSSSLLSSEESSSSIIOONNggeettttiimmee(const SSLSESSION *s);
       long SSSSLLSSEESSSSIIOONNggeettttiimmeeoouutt(const SSLSESSION *s);
       unsigned long SSSSLLSSEESSSSIIOONNhhaasshh(const SSLSESSION *a);
       SSLSESSION *SSSSLLSSEESSSSIIOONNnneeww(void);
       int SSSSLLSSEESSSSIIOONNpprriinntt(BIO *bp, const SSLSESSION *x);
       int SSSSLLSSEESSSSIIOONNpprriinnttffpp(FILE *fp, const SSLSESSION *x);
       void SSSSLLSSEESSSSIIOONNsseettaappppddaattaa(SSLSESSION *s, char *a);
       int SSSSLLSSEESSSSIIOONNsseetteexxddaattaa(SSLSESSION *s, int idx, char *arg);
       long SSSSLLSSEESSSSIIOONNsseettttiimmee(SSLSESSION *s, long t);
       long SSSSLLSSEESSSSIIOONNsseettttiimmeeoouutt(SSLSESSION *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 SSSSLLaacccceepptt(SSL *ssl);
       int SSSSLLaaddddddiirrcceerrttssuubbjjeeccttssttoossttaacckk(STACK *stack, const char *dir);
       int SSSSLLaaddddffiilleecceerrttssuubbjjeeccttssttoossttaacckk(STACK *stack, const char
       *file);
       int SSSSLLaaddddcclliieennttCCAA(SSL *ssl, X509 *x);
       char *SSSSLLaalleerrttddeessccssttrriinngg(int value);
       char *SSSSLLaalleerrttddeessccssttrriinngglloonngg(int value);
       char *SSSSLLaalleerrttttyyppeessttrriinngg(int value);
       char *SSSSLLaalleerrttttyyppeessttrriinngglloonngg(int value);
       int SSSSLLcchheecckkpprriivvaatteekkeeyy(const SSL *ssl);
       void SSSSLLcclleeaarr(SSL *ssl);
       long SSSSLLcclleeaarrnnuummrreenneeggoottiiaattiioonnss(SSL *ssl);
       int SSSSLLccoonnnneecctt(SSL *ssl);
       void SSSSLLccooppyysseessssiioonniidd(SSL *t, const SSL *f);
       long SSSSLLccttrrll(SSL *ssl, int cmd, long larg, char *parg);
       int SSSSLLddoohhaannddsshhaakkee(SSL *ssl);
       SSL *SSSSLLdduupp(SSL *ssl);
       STACK *SSSSLLdduuppCCAAlliisstt(STACK *sk);
       void SSSSLLffrreeee(SSL *ssl);
       SSLCTX *SSSSLLggeettSSSSLLCCTTXX(const SSL *ssl);
       char *SSSSLLggeettaappppddaattaa(SSL *ssl);
       X509 *SSSSLLggeettcceerrttiiffiiccaattee(const SSL *ssl);
       const char *SSSSLLggeettcciipphheerr(const SSL *ssl);
       int SSSSLLggeettcciipphheerrbbiittss(const SSL *ssl, int *algbits);
       char *SSSSLLggeettcciipphheerrlliisstt(const SSL *ssl, int n);
       char *SSSSLLggeettcciipphheerrnnaammee(const SSL *ssl);
       char *SSSSLLggeettcciipphheerrvveerrssiioonn(const SSL *ssl);
       STACK *SSSSLLggeettcciipphheerrss(const SSL *ssl);
       STACK *SSSSLLggeettcclliieennttCCAAlliisstt(const SSL *ssl);
       SSLCIPHER *SSSSLLggeettccuurrrreennttcciipphheerr(SSL *ssl);
       long SSSSLLggeettddeeffaauullttttiimmeeoouutt(const SSL *ssl);
       int SSSSLLggeetteerrrroorr(const SSL *ssl, int i);
       char *SSSSLLggeetteexxddaattaa(const SSL *ssl, int idx);
       int SSSSLLggeetteexxddaattaaXX550099SSTTOORREECCTTXXiiddxx(void);
       int SSSSLLggeetteexxnneewwiinnddeexx(long argl, char *argp, int (*newfunc);(void),
       int (*dupfunc)(void), void (*freefunc)(void))
       int SSSSLLggeettffdd(const SSL *ssl);
       void (*SSSSLLggeettiinnffooccaallllbbaacckk(const SSL *ssl);)()
       STACK *SSSSLLggeettppeeeerrcceerrttcchhaaiinn(const SSL *ssl);
       X509 *SSSSLLggeettppeeeerrcceerrttiiffiiccaattee(const SSL *ssl);
       EVPPKEY *SSSSLLggeettpprriivvaatteekkeeyy(SSL *ssl);
       int SSSSLLggeettqquuiieettsshhuuttddoowwnn(const SSL *ssl);
       BIO *SSSSLLggeettrrbbiioo(const SSL *ssl);
       int SSSSLLggeettrreeaaddaahheeaadd(const SSL *ssl);
       SSLSESSION *SSSSLLggeettsseessssiioonn(const SSL *ssl);
       char *SSSSLLggeettsshhaarreeddcciipphheerrss(const SSL *ssl, char *buf, int len);
       int SSSSLLggeettsshhuuttddoowwnn(const SSL *ssl);
       SSLMETHOD *SSSSLLggeettssssllmmeetthhoodd(SSL *ssl);
       int SSSSLLggeettssttaattee(const SSL *ssl);
       long SSSSLLggeettttiimmee(const SSL *ssl);
       long SSSSLLggeettttiimmeeoouutt(const SSL *ssl);
       int (*SSSSLLggeettvveerriiffyyccaallllbbaacckk(const SSL *ssl))(int,X509STORECTX *)
       int SSSSLLggeettvveerriiffyymmooddee(const SSL *ssl);
       long SSSSLLggeettvveerriiffyyrreessuulltt(const SSL *ssl);
       char *SSSSLLggeettvveerrssiioonn(const SSL *ssl);
       BIO *SSSSLLggeettwwbbiioo(const SSL *ssl);
       int SSSSLLiinnaacccceeppttiinniitt(SSL *ssl);
       int SSSSLLiinnbbeeffoorree(SSL *ssl);
       int SSSSLLiinnccoonnnneeccttiinniitt(SSL *ssl);
       int SSSSLLiinniinniitt(SSL *ssl);
       int SSSSLLiissiinniittffiinniisshheedd(SSL *ssl);
       STACK *SSSSLLllooaaddcclliieennttCCAAffiillee(char *file);
       void SSSSLLllooaaddeerrrroorrssttrriinnggss(void);
       SSL *SSSSLLnneeww(SSLCTX *ctx);
       long SSSSLLnnuummrreenneeggoottiiaattiioonnss(SSL *ssl);
       int SSSSLLppeeeekk(SSL *ssl, void *buf, int num);
       int SSSSLLppeennddiinngg(const SSL *ssl);
       int SSSSLLrreeaadd(SSL *ssl, void *buf, int num);
       int SSSSLLrreenneeggoottiiaattee(SSL *ssl);
       char *SSSSLLrrssttaatteessttrriinngg(SSL *ssl);
       char *SSSSLLrrssttaatteessttrriinngglloonngg(SSL *ssl);
       long SSSSLLsseessssiioonnrreeuusseedd(SSL *ssl);
       void SSSSLLsseettaacccceeppttssttaattee(SSL *ssl);
       void SSSSLLsseettaappppddaattaa(SSL *ssl, char *arg);
       void SSSSLLsseettbbiioo(SSL *ssl, BIO *rbio, BIO *wbio);
       int SSSSLLsseettcciipphheerrlliisstt(SSL *ssl, char *str);
       void SSSSLLsseettcclliieennttCCAAlliisstt(SSL *ssl, STACK *list);
       void SSSSLLsseettccoonnnneeccttssttaattee(SSL *ssl);
       int SSSSLLsseetteexxddaattaa(SSL *ssl, int idx, char *arg);
       int SSSSLLsseettffdd(SSL *ssl, int fd);
       void SSSSLLsseettiinnffooccaallllbbaacckk(SSL *ssl, void (*cb);(void))
       void SSSSLLsseettmmssggccaallllbbaacckk(SSL *ctx, void (*cb)(int writep, int
       version, int contenttype, const void *buf, sizet len, SSL *ssl, void
       *arg));
       void SSSSLLsseettmmssggccaallllbbaacckkaarrgg(SSL *ctx, void *arg);
       void SSSSLLsseettooppttiioonnss(SSL *ssl, unsigned long op);
       void SSSSLLsseettqquuiieettsshhuuttddoowwnn(SSL *ssl, int mode);
       void SSSSLLsseettrreeaaddaahheeaadd(SSL *ssl, int yes);
       int SSSSLLsseettrrffdd(SSL *ssl, int fd);
       int SSSSLLsseettsseessssiioonn(SSL *ssl, SSLSESSION *session);
       void SSSSLLsseettsshhuuttddoowwnn(SSL *ssl, int mode);
       int SSSSLLsseettssssllmmeetthhoodd(SSL *ssl, SSLMETHOD *meth);
       void SSSSLLsseettttiimmee(SSL *ssl, long t);
       void SSSSLLsseettttiimmeeoouutt(SSL *ssl, long t);
       void SSSSLLsseettvveerriiffyy(SSL *ssl, int mode, int (*callback);(void))
       void SSSSLLsseettvveerriiffyyrreessuulltt(SSL *ssl, long arg);
       int SSSSLLsseettwwffdd(SSL *ssl, int fd);
       int SSSSLLsshhuuttddoowwnn(SSL *ssl);
       int SSSSLLssttaattee(const SSL *ssl);
       char *SSSSLLssttaatteessttrriinngg(const SSL *ssl);
       char *SSSSLLssttaatteessttrriinngglloonngg(const SSL *ssl);
       long SSSSLLttoottaallrreenneeggoottiiaattiioonnss(SSL *ssl);
       int SSSSLLuusseePPrriivvaatteeKKeeyy(SSL *ssl, EVPPKEY *pkey);
       int SSSSLLuusseePPrriivvaatteeKKeeyyAASSNN11(int type, SSL *ssl, unsigned char *d, long
       len);
       int SSSSLLuusseePPrriivvaatteeKKeeyyffiillee(SSL *ssl, char *file, int type);
       int SSSSLLuusseeRRSSAAPPrriivvaatteeKKeeyy(SSL *ssl, RSA *rsa);
       int SSSSLLuusseeRRSSAAPPrriivvaatteeKKeeyyAASSNN11(SSL *ssl, unsigned char *d, long len);
       int SSSSLLuusseeRRSSAAPPrriivvaatteeKKeeyyffiillee(SSL *ssl, char *file, int type);
       int SSSSLLuusseecceerrttiiffiiccaattee(SSL *ssl, X509 *x);
       int SSSSLLuusseecceerrttiiffiiccaatteeAASSNN11(SSL *ssl, int len, unsigned char *d);
       int SSSSLLuusseecceerrttiiffiiccaatteeffiillee(SSL *ssl, char *file, int type);
       int SSSSLLvveerrssiioonn(const SSL *ssl);
       int SSSSLLwwaanntt(const SSL *ssl);
       int SSSSLLwwaannttnnootthhiinngg(const SSL *ssl);
       int SSSSLLwwaannttrreeaadd(const SSL *ssl);
       int SSSSLLwwaannttwwrriittee(const SSL *ssl);
       int SSSSLLwwaannttxx550099llooookkuupp(const SSL *ssl);
       int SSSSLLwwrriittee(SSL *ssl, const void *buf, int num);

SEE ALSO
       openssl(1), crypto(3), SSLaccept(3), SSLclear(3), SSLconnect(3),
       SSLCIPHERgetname(3), SSLCOMPaddcompressionmethod(3),
       SSLCTXaddextrachaincert(3), SSLCTXaddsession(3),
       SSLCTXctrl(3), SSLCTXflushsessions(3),
       SSLCTXgetexnewindex(3), SSLCTXgetverifymode(3),
       SSLCTXloadverifylocations(3) SSLCTXnew(3),
       SSLCTXsessnumber(3), SSLCTXsesssetcachesize(3),
       SSLCTXsesssetgetcb(3), SSLCTXsessions(3),
       SSLCTXsetcertstore(3), SSLCTXsetcertverifycallback(3),
       SSLCTXsetcipherlist(3), SSLCTXsetclientCAlist(3),
       SSLCTXsetclientcertcb(3), SSLCTXsetdefaultpasswdcb(3),
       SSLCTXsetgeneratesessionid(3), SSLCTXsetinfocallback(3),
       SSLCTXsetmaxcertlist(3), SSLCTXsetmode(3),
       SSLCTXsetmsgcallback(3), SSLCTXsetoptions(3),
       SSLCTXsetquietshutdown(3), SSLCTXsetsessioncachemode(3),
       SSLCTXsetsessionidcontext(3), SSLCTXsetsslversion(3),
       SSLCTXsettimeout(3), SSLCTXsettmprsacallback(3),
       SSLCTXsettmpdhcallback(3), SSLCTXsetverify(3),
       SSLCTXusecertificate(3), SSLalerttypestring(3),
       SSLdohandshake(3), SSLgetSSLCTX(3), SSLgetciphers(3),
       SSLgetclientCAlist(3), SSLgetdefaulttimeout(3),
       SSLgeterror(3), SSLgetexdataX509STORECTXidx(3),
       SSLgetexnewindex(3), SSLgetfd(3), SSLgetpeercertchain(3),
       SSLgetrbio(3), SSLgetsession(3), SSLgetverifyresult(3),
       SSLgetversion(3), SSLlibraryinit(3), SSLloadclientCAfile(3),
       SSLnew(3), SSLpending(3), SSLread(3), SSLrstatestring(3),
       SSLsessionreused(3), SSLsetbio(3), SSLsetconnectstate(3),
       SSLsetfd(3), SSLsetsession(3), SSLsetshutdown(3),
       SSLshutdown(3), SSLstatestring(3), SSLwant(3), SSLwrite(3),
       SSLSESSIONfree(3), SSLSESSIONgetexnewindex(3),
       SSLSESSIONgettime(3), d2iSSLSESSION(3)

HISTORY
       The ssl(3) document appeared in OpenSSL 0.9.2



0.9.7l                            2005-03-30                            ssl(3)