Manual Pages for UNIX Operating System command usage for man ssl

OpenSSL                                             ssl(3openssl)



NNNNAAAAMMMMEEEE
     SSL - OpenSSL SSL/TLS library

SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
  TeOeSLssssll irr mlmnsteScr okt ae
     (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 SSSSSSSSLLLL_CCCCTTTTXXXX 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 SSSSSSSSLLLL object. After the SSSSSSSSLLLL 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.

DDDDAAAATTTTAAAA SSSSTTTTRRRRUUUUCCCCTTTTUUUURRRREEEESSSS
  CretyteOeSLssssll irr ucin el ihte
     following data structures:

     SSSSSSSSLLLL_MMMMEEEETTTTHHHHOOOODDDD (SSL Method)
    Ta'  ipthsrcuedsrbn h nenlssssll
         library methods/functions which implement the various
         protocol versions (SSLv1, SSLv2 and TLSv1). It's needed
         to create an SSSSSSSSLLLL_CCCCTTTTXXXX.

     SSSSSSSSLLLL_CCCCIIIIPPPPHHHHEEEERRRR (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
         SSSSSSSSLLLL_CCCCTTTTXXXX basis and the actually used ones are then part
         of the SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN.

     SSSSSSSSLLLL_CCCCTTTTXXXX (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 SSSSSSSSLLLL structures which
         are later created for the connections.




30/Mar/2005            Last change: 0.9.8o                      1






OpenSSL                                             ssl(3openssl)



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

     SSSSSSSSLLLL (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.

HHHHEEEEAAAADDDDEEEERRRR FFFFIIIILLLLEEEESSSS
  CretyteOeSLssssll irr rvdstefloigC
     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.
    Icuei noyu rga omk h P ftessssll
         library available. It internally includes both more
         private SSL headers and headers from the ccccrrrryyyyppppttttoooo 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.

     ttttllllssss1111....hhhh
         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.

AAAAPPPPIIII FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS
  CretyteOeSLssssll irr xot 1 P ucin.
     They are documented in the following:





30/Mar/2005            Last change: 0.9.8o                      2






OpenSSL                                             ssl(3openssl)



     DDDDEEEEAAAALLLLIIIINNNNGGGG WWWWIIIITTTTHHHH PPPPRRRROOOOTTTTOOOOCCCCOOOOLLLL MMMMEEEETTTTHHHHOOOODDDDSSSS

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

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

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

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

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

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

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

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

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

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

     DDDDEEEEAAAALLLLIIIINNNNGGGG WWWWIIIITTTTHHHH CCCCIIIIPPPPHHHHEEEERRRRSSSS

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

len);
     char *SSSSSSSSLLLL_CCCCIIIIPPPPHHHHEEEERRRR_ddddeeeessssccccrrrriiiippppttttiiiioooonnnn(SSL_CIPHER *cipher, char *buf, int
         Write a string to buf (with a maximum size of len)
         containing a human readable description of cipher.
         Returns buf.



30/Mar/2005            Last change: 0.9.8o                      3






OpenSSL                                             ssl(3openssl)



     int SSSSSSSSLLLL_CCCCIIIIPPPPHHHHEEEERRRR_ggggeeeetttt_bbbbiiiittttssss(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 *SSSSSSSSLLLL_CCCCIIIIPPPPHHHHEEEERRRR_ggggeeeetttt_nnnnaaaammmmeeee(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 *SSSSSSSSLLLL_CCCCIIIIPPPPHHHHEEEERRRR_ggggeeeetttt_vvvveeeerrrrssssiiiioooonnnn(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).

     DDDDEEEEAAAALLLLIIIINNNNGGGG WWWWIIIITTTTHHHH PPPPRRRROOOOTTTTOOOOCCCCOOOOLLLL CCCCOOOONNNNTTTTEEEEXXXXTTTTSSSS

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

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

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

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

     int SSSSSSSSLLLL_CCCCTTTTXXXX_cccchhhheeeecccckkkk_pppprrrriiiivvvvaaaatttteeee_kkkkeeeeyyyy(const SSL_CTX *ctx);

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

     void SSSSSSSSLLLL_CCCCTTTTXXXX_fffflllluuuusssshhhh_sssseeeessssssssiiiioooonnnnssss(SSL_CTX *s, long t);

     void SSSSSSSSLLLL_CCCCTTTTXXXX_ffffrrrreeeeeeee(SSL_CTX *a);

     char *SSSSSSSSLLLL_CCCCTTTTXXXX_ggggeeeetttt_aaaapppppppp_ddddaaaattttaaaa(SSL_CTX *ctx);

     X509_STORE *SSSSSSSSLLLL_CCCCTTTTXXXX_ggggeeeetttt_cccceeeerrrrtttt_ssssttttoooorrrreeee(SSL_CTX *ctx);

     STACK *SSSSSSSSLLLL_CCCCTTTTXXXX_ggggeeeetttt_cccclllliiiieeeennnntttt_CCCCAAAA_lllliiiisssstttt(const SSL_CTX *ctx);

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

     char *SSSSSSSSLLLL_CCCCTTTTXXXX_ggggeeeetttt_eeeexxxx_ddddaaaattttaaaa(const SSL_CTX *s, int idx);

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



30/Mar/2005            Last change: 0.9.8o                      4






OpenSSL                                             ssl(3openssl)



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

     int SSSSSSSSLLLL_CCCCTTTTXXXX_ggggeeeetttt_qqqquuuuiiiieeeetttt_sssshhhhuuuuttttddddoooowwwwnnnn(const SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_ggggeeeetttt_sssseeeessssssssiiiioooonnnn_ccccaaaacccchhhheeee_mmmmooooddddeeee(SSL_CTX *ctx);

     long SSSSSSSSLLLL_CCCCTTTTXXXX_ggggeeeetttt_ttttiiiimmmmeeeeoooouuuutttt(const SSL_CTX *ctx);

X509_STORE_CTX *ctx);
     int (*SSSSSSSSLLLL_CCCCTTTTXXXX_ggggeeeetttt_vvvveeeerrrriiiiffffyyyy_ccccaaaallllllllbbbbaaaacccckkkk(const SSL_CTX *ctx))(int ok,

     int SSSSSSSSLLLL_CCCCTTTTXXXX_ggggeeeetttt_vvvveeeerrrriiiiffffyyyy_mmmmooooddddeeee(SSL_CTX *ctx);

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

     long SSSSSSSSLLLL_CCCCTTTTXXXX_nnnneeeeeeeedddd_ttttmmmmpppp_RRRRSSSSAAAA(SSL_CTX *ctx);

     SSL_CTX *SSSSSSSSLLLL_CCCCTTTTXXXX_nnnneeeewwww(SSL_METHOD *meth);

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

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_aaaacccccccceeeepppptttt(SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_aaaacccccccceeeepppptttt_ggggoooooooodddd(SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_aaaacccccccceeeepppptttt_rrrreeeennnneeeeggggoooottttiiiiaaaatttteeee(SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_ccccaaaacccchhhheeee_ffffuuuullllllll(SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_ccccbbbb_hhhhiiiittttssss(SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_ccccoooonnnnnnnneeeecccctttt(SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_ccccoooonnnnnnnneeeecccctttt_ggggoooooooodddd(SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_ccccoooonnnnnnnneeeecccctttt_rrrreeeennnneeeeggggoooottttiiiiaaaatttteeee(SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_ggggeeeetttt_ccccaaaacccchhhheeee_ssssiiiizzzzeeee(SSL_CTX *ctx);

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

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

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

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_hhhhiiiittttssss(SSL_CTX *ctx);




30/Mar/2005            Last change: 0.9.8o                      5






OpenSSL                                             ssl(3openssl)



     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_mmmmiiiisssssssseeeessss(SSL_CTX *ctx);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_nnnnuuuummmmbbbbeeeerrrr(SSL_CTX *ctx);

     void SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_sssseeeetttt_ccccaaaacccchhhheeee_ssssiiiizzzzeeee(SSL_CTX *ctx,t);

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

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

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

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssss_ttttiiiimmmmeeeeoooouuuuttttssss(SSL_CTX *ctx);

     LHASH *SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeessssssssiiiioooonnnnssss(SSL_CTX *ctx);

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

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

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

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

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

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

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

     void SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeetttt_ddddeeeeffffaaaauuuulllltttt_rrrreeeeaaaadddd_aaaahhhheeeeaaaadddd(SSL_CTX *ctx, int m);

     int SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeetttt_ddddeeeeffffaaaauuuulllltttt_vvvveeeerrrriiiiffffyyyy_ppppaaaatttthhhhssss(SSL_CTX *ctx);

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

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

write_p, int version, int content_type, const void *buf, size_t
len, SSL *ssl, void *arg));
     void SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeetttt_mmmmssssgggg_ccccaaaallllllllbbbbaaaacccckkkk(SSL_CTX *ctx, void (*cb)(int

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





30/Mar/2005            Last change: 0.9.8o                      6






OpenSSL                                             ssl(3openssl)



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

     void SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeetttt_qqqquuuuiiiieeeetttt_sssshhhhuuuuttttddddoooowwwwnnnn(SSL_CTX *ctx, int mode);

     void SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeetttt_sssseeeessssssssiiiioooonnnn_ccccaaaacccchhhheeee_mmmmooooddddeeee(SSL_CTX *ctx, int mode);

  itSSSSLL_CCTTXXsseett_ssssllvveerrssiioonn(S_T cx S_EHD*eh;
     void SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeetttt_ttttiiiimmmmeeeeoooouuuutttt(SSL_CTX *ctx, long t);

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

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

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

     SSL_CTX_set_tmp_rsa_callback
         long SSSSSSSSLLLL_CCCCTTTTXXXX_sssseeeetttt_ttttmmmmpppp_rrrrssssaaaa_ccccaaaallllllllbbbbaaaacccckkkk(SSL_CTX *ccccttttxxxx, RSA
    **ccbb(S ssssll,iteexxppoorrtt,itkkeeyylleennggtthh);
         Sets the callback which will be called when a temporary
         private key is required. The eeeexxxxppppoooorrrrtttt flag will be set if
         the reason for needing a temp key is that an export
         ciphersuite is in use, in which case, kkkkeeeeyyyylllleeeennnnggggtttthhhh will
         contain the required keylength in bits. Generate a key
         of appropriate size (using ???) and return it.

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

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

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

     int SSSSSSSSLLLL_CCCCTTTTXXXX_uuuusssseeee_PPPPrrrriiiivvvvaaaatttteeeeKKKKeeeeyyyy(SSL_CTX *ctx, EVP_PKEY *pkey);

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

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

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

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

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




30/Mar/2005            Last change: 0.9.8o                      7






OpenSSL                                             ssl(3openssl)



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

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

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

     DDDDEEEEAAAALLLLIIIINNNNGGGG WWWWIIIITTTTHHHH SSSSEEEESSSSSSSSIIIIOOOONNNNSSSS

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

     int SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_ccccmmmmpppp(const SSL_SESSION *a, const SSL_SESSION *b);

     void SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_ffffrrrreeeeeeee(SSL_SESSION *ss);

     char *SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_ggggeeeetttt_aaaapppppppp_ddddaaaattttaaaa(SSL_SESSION *s);

     char *SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_ggggeeeetttt_eeeexxxx_ddddaaaattttaaaa(const SSL_SESSION *s, int idx);

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

     long SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_ggggeeeetttt_ttttiiiimmmmeeee(const SSL_SESSION *s);

     long SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_ggggeeeetttt_ttttiiiimmmmeeeeoooouuuutttt(const SSL_SESSION *s);

     unsigned long SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_hhhhaaaasssshhhh(const SSL_SESSION *a);

     SSL_SESSION *SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_nnnneeeewwww(void);

     int SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_pppprrrriiiinnnntttt(BIO *bp, const SSL_SESSION *x);

     int SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_pppprrrriiiinnnntttt_ffffpppp(FILE *fp, const SSL_SESSION *x);

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

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

     long SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_sssseeeetttt_ttttiiiimmmmeeee(SSL_SESSION *s, long t);

     long SSSSSSSSLLLL_SSSSEEEESSSSSSSSIIIIOOOONNNN_sssseeeetttt_ttttiiiimmmmeeeeoooouuuutttt(SSL_SESSION *s, long t);

     DDDDEEEEAAAALLLLIIIINNNNGGGG WWWWIIIITTTTHHHH CCCCOOOONNNNNNNNEEEECCCCTTTTIIIIOOOONNNNSSSS

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

     int SSSSSSSSLLLL_aaaacccccccceeeepppptttt(SSL *ssl);




30/Mar/2005            Last change: 0.9.8o                      8






OpenSSL                                             ssl(3openssl)



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

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

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

     char *SSSSSSSSLLLL_aaaalllleeeerrrrtttt_ddddeeeesssscccc_ssssttttrrrriiiinnnngggg(int value);

     char *SSSSSSSSLLLL_aaaalllleeeerrrrtttt_ddddeeeesssscccc_ssssttttrrrriiiinnnngggg_lllloooonnnngggg(int value);

     char *SSSSSSSSLLLL_aaaalllleeeerrrrtttt_ttttyyyyppppeeee_ssssttttrrrriiiinnnngggg(int value);

     char *SSSSSSSSLLLL_aaaalllleeeerrrrtttt_ttttyyyyppppeeee_ssssttttrrrriiiinnnngggg_lllloooonnnngggg(int value);

     int SSSSSSSSLLLL_cccchhhheeeecccckkkk_pppprrrriiiivvvvaaaatttteeee_kkkkeeeeyyyy(const SSL *ssl);

     void SSSSSSSSLLLL_cccclllleeeeaaaarrrr(SSL *ssl);

     long SSSSSSSSLLLL_cccclllleeeeaaaarrrr_nnnnuuuummmm_rrrreeeennnneeeeggggoooottttiiiiaaaattttiiiioooonnnnssss(SSL *ssl);

     int SSSSSSSSLLLL_ccccoooonnnnnnnneeeecccctttt(SSL *ssl);

     void SSSSSSSSLLLL_ccccooooppppyyyy_sssseeeessssssssiiiioooonnnn_iiiidddd(SSL *t, const SSL *f);

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

     int SSSSSSSSLLLL_ddddoooo_hhhhaaaannnnddddsssshhhhaaaakkkkeeee(SSL *ssl);

     SSL *SSSSSSSSLLLL_dddduuuupppp(SSL *ssl);

     STACK *SSSSSSSSLLLL_dddduuuupppp_CCCCAAAA_lllliiiisssstttt(STACK *sk);

     void SSSSSSSSLLLL_ffffrrrreeeeeeee(SSL *ssl);

     SSL_CTX *SSSSSSSSLLLL_ggggeeeetttt_SSSSSSSSLLLL_CCCCTTTTXXXX(const SSL *ssl);

     char *SSSSSSSSLLLL_ggggeeeetttt_aaaapppppppp_ddddaaaattttaaaa(SSL *ssl);

     X509 *SSSSSSSSLLLL_ggggeeeetttt_cccceeeerrrrttttiiiiffffiiiiccccaaaatttteeee(const SSL *ssl);

     const char *SSSSSSSSLLLL_ggggeeeetttt_cccciiiipppphhhheeeerrrr(const SSL *ssl);

     int SSSSSSSSLLLL_ggggeeeetttt_cccciiiipppphhhheeeerrrr_bbbbiiiittttssss(const SSL *ssl, int *alg_bits);

     char *SSSSSSSSLLLL_ggggeeeetttt_cccciiiipppphhhheeeerrrr_lllliiiisssstttt(const SSL *ssl, int n);

     char *SSSSSSSSLLLL_ggggeeeetttt_cccciiiipppphhhheeeerrrr_nnnnaaaammmmeeee(const SSL *ssl);

     char *SSSSSSSSLLLL_ggggeeeetttt_cccciiiipppphhhheeeerrrr_vvvveeeerrrrssssiiiioooonnnn(const SSL *ssl);




30/Mar/2005            Last change: 0.9.8o                      9






OpenSSL                                             ssl(3openssl)



     STACK *SSSSSSSSLLLL_ggggeeeetttt_cccciiiipppphhhheeeerrrrssss(const SSL *ssl);

     STACK *SSSSSSSSLLLL_ggggeeeetttt_cccclllliiiieeeennnntttt_CCCCAAAA_lllliiiisssstttt(const SSL *ssl);

     SSL_CIPHER *SSSSSSSSLLLL_ggggeeeetttt_ccccuuuurrrrrrrreeeennnntttt_cccciiiipppphhhheeeerrrr(SSL *ssl);

     long SSSSSSSSLLLL_ggggeeeetttt_ddddeeeeffffaaaauuuulllltttt_ttttiiiimmmmeeeeoooouuuutttt(const SSL *ssl);

     int SSSSSSSSLLLL_ggggeeeetttt_eeeerrrrrrrroooorrrr(const SSL *ssl, int i);

     char *SSSSSSSSLLLL_ggggeeeetttt_eeeexxxx_ddddaaaattttaaaa(const SSL *ssl, int idx);

     int SSSSSSSSLLLL_ggggeeeetttt_eeeexxxx_ddddaaaattttaaaa_XXXX555500009999_SSSSTTTTOOOORRRREEEE_CCCCTTTTXXXX_iiiiddddxxxx(void);

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

     int SSSSSSSSLLLL_ggggeeeetttt_ffffdddd(const SSL *ssl);

     void (*SSSSSSSSLLLL_ggggeeeetttt_iiiinnnnffffoooo_ccccaaaallllllllbbbbaaaacccckkkk(const SSL *ssl);)()

     STACK *SSSSSSSSLLLL_ggggeeeetttt_ppppeeeeeeeerrrr_cccceeeerrrrtttt_cccchhhhaaaaiiiinnnn(const SSL *ssl);

     X509 *SSSSSSSSLLLL_ggggeeeetttt_ppppeeeeeeeerrrr_cccceeeerrrrttttiiiiffffiiiiccccaaaatttteeee(const SSL *ssl);

     EVP_PKEY *SSSSSSSSLLLL_ggggeeeetttt_pppprrrriiiivvvvaaaatttteeeekkkkeeeeyyyy(SSL *ssl);

     int SSSSSSSSLLLL_ggggeeeetttt_qqqquuuuiiiieeeetttt_sssshhhhuuuuttttddddoooowwwwnnnn(const SSL *ssl);

     BIO *SSSSSSSSLLLL_ggggeeeetttt_rrrrbbbbiiiioooo(const SSL *ssl);

     int SSSSSSSSLLLL_ggggeeeetttt_rrrreeeeaaaadddd_aaaahhhheeeeaaaadddd(const SSL *ssl);

     SSL_SESSION *SSSSSSSSLLLL_ggggeeeetttt_sssseeeessssssssiiiioooonnnn(const SSL *ssl);

     char *SSSSSSSSLLLL_ggggeeeetttt_sssshhhhaaaarrrreeeedddd_cccciiiipppphhhheeeerrrrssss(const SSL *ssl, char *buf, int len);

     int SSSSSSSSLLLL_ggggeeeetttt_sssshhhhuuuuttttddddoooowwwwnnnn(const SSL *ssl);

  SLMTO SSSSLL_ggeettssssll_mmeetthhooddSL*s)

     int SSSSSSSSLLLL_ggggeeeetttt_ssssttttaaaatttteeee(const SSL *ssl);

     long SSSSSSSSLLLL_ggggeeeetttt_ttttiiiimmmmeeee(const SSL *ssl);

     long SSSSSSSSLLLL_ggggeeeetttt_ttttiiiimmmmeeeeoooouuuutttt(const SSL *ssl);

*)
     int (*SSSSSSSSLLLL_ggggeeeetttt_vvvveeeerrrriiiiffffyyyy_ccccaaaallllllllbbbbaaaacccckkkk(const SSL *ssl))(int,X509_STORE_CTX





30/Mar/2005            Last change: 0.9.8o                     10






OpenSSL                                             ssl(3openssl)



     int SSSSSSSSLLLL_ggggeeeetttt_vvvveeeerrrriiiiffffyyyy_mmmmooooddddeeee(const SSL *ssl);

     long SSSSSSSSLLLL_ggggeeeetttt_vvvveeeerrrriiiiffffyyyy_rrrreeeessssuuuulllltttt(const SSL *ssl);

     char *SSSSSSSSLLLL_ggggeeeetttt_vvvveeeerrrrssssiiiioooonnnn(const SSL *ssl);

     BIO *SSSSSSSSLLLL_ggggeeeetttt_wwwwbbbbiiiioooo(const SSL *ssl);

     int SSSSSSSSLLLL_iiiinnnn_aaaacccccccceeeepppptttt_iiiinnnniiiitttt(SSL *ssl);

     int SSSSSSSSLLLL_iiiinnnn_bbbbeeeeffffoooorrrreeee(SSL *ssl);

     int SSSSSSSSLLLL_iiiinnnn_ccccoooonnnnnnnneeeecccctttt_iiiinnnniiiitttt(SSL *ssl);

     int SSSSSSSSLLLL_iiiinnnn_iiiinnnniiiitttt(SSL *ssl);

     int SSSSSSSSLLLL_iiiissss_iiiinnnniiiitttt_ffffiiiinnnniiiisssshhhheeeedddd(SSL *ssl);

     STACK *SSSSSSSSLLLL_llllooooaaaadddd_cccclllliiiieeeennnntttt_CCCCAAAA_ffffiiiilllleeee(char *file);

     void SSSSSSSSLLLL_llllooooaaaadddd_eeeerrrrrrrroooorrrr_ssssttttrrrriiiinnnnggggssss(void);

     SSL *SSSSSSSSLLLL_nnnneeeewwww(SSL_CTX *ctx);

     long SSSSSSSSLLLL_nnnnuuuummmm_rrrreeeennnneeeeggggoooottttiiiiaaaattttiiiioooonnnnssss(SSL *ssl);

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

     int SSSSSSSSLLLL_ppppeeeennnnddddiiiinnnngggg(const SSL *ssl);

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

     int SSSSSSSSLLLL_rrrreeeennnneeeeggggoooottttiiiiaaaatttteeee(SSL *ssl);

     char *SSSSSSSSLLLL_rrrrssssttttaaaatttteeee_ssssttttrrrriiiinnnngggg(SSL *ssl);

     char *SSSSSSSSLLLL_rrrrssssttttaaaatttteeee_ssssttttrrrriiiinnnngggg_lllloooonnnngggg(SSL *ssl);

     long SSSSSSSSLLLL_sssseeeessssssssiiiioooonnnn_rrrreeeeuuuusssseeeedddd(SSL *ssl);

     void SSSSSSSSLLLL_sssseeeetttt_aaaacccccccceeeepppptttt_ssssttttaaaatttteeee(SSL *ssl);

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

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

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

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

     void SSSSSSSSLLLL_sssseeeetttt_ccccoooonnnnnnnneeeecccctttt_ssssttttaaaatttteeee(SSL *ssl);




30/Mar/2005            Last change: 0.9.8o                     11






OpenSSL                                             ssl(3openssl)



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

     int SSSSSSSSLLLL_sssseeeetttt_ffffdddd(SSL *ssl, int fd);

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

version, int content_type, const void *buf, size_t len, SSL *ssl,
void *arg));
     void SSSSSSSSLLLL_sssseeeetttt_mmmmssssgggg_ccccaaaallllllllbbbbaaaacccckkkk(SSL *ctx, void (*cb)(int write_p, int

     void SSSSSSSSLLLL_sssseeeetttt_mmmmssssgggg_ccccaaaallllllllbbbbaaaacccckkkk_aaaarrrrgggg(SSL *ctx, void *arg);

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

     void SSSSSSSSLLLL_sssseeeetttt_qqqquuuuiiiieeeetttt_sssshhhhuuuuttttddddoooowwwwnnnn(SSL *ssl, int mode);

     void SSSSSSSSLLLL_sssseeeetttt_rrrreeeeaaaadddd_aaaahhhheeeeaaaadddd(SSL *ssl, int yes);

     int SSSSSSSSLLLL_sssseeeetttt_rrrrffffdddd(SSL *ssl, int fd);

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

     void SSSSSSSSLLLL_sssseeeetttt_sssshhhhuuuuttttddddoooowwwwnnnn(SSL *ssl, int mode);

  itSSSSLL_sseettssssll_mmeetthhooddSL*s,SLMTO mt)

     void SSSSSSSSLLLL_sssseeeetttt_ttttiiiimmmmeeee(SSL *ssl, long t);

     void SSSSSSSSLLLL_sssseeeetttt_ttttiiiimmmmeeeeoooouuuutttt(SSL *ssl, long t);

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

     void SSSSSSSSLLLL_sssseeeetttt_vvvveeeerrrriiiiffffyyyy_rrrreeeessssuuuulllltttt(SSL *ssl, long arg);

     int SSSSSSSSLLLL_sssseeeetttt_wwwwffffdddd(SSL *ssl, int fd);

     int SSSSSSSSLLLL_sssshhhhuuuuttttddddoooowwwwnnnn(SSL *ssl);

     int SSSSSSSSLLLL_ssssttttaaaatttteeee(const SSL *ssl);

     char *SSSSSSSSLLLL_ssssttttaaaatttteeee_ssssttttrrrriiiinnnngggg(const SSL *ssl);

     char *SSSSSSSSLLLL_ssssttttaaaatttteeee_ssssttttrrrriiiinnnngggg_lllloooonnnngggg(const SSL *ssl);

     long SSSSSSSSLLLL_ttttoooottttaaaallll_rrrreeeennnneeeeggggoooottttiiiiaaaattttiiiioooonnnnssss(SSL *ssl);

     int SSSSSSSSLLLL_uuuusssseeee_PPPPrrrriiiivvvvaaaatttteeeeKKKKeeeeyyyy(SSL *ssl, EVP_PKEY *pkey);

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





30/Mar/2005            Last change: 0.9.8o                     12






OpenSSL                                             ssl(3openssl)



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

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

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

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

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

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

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

     int SSSSSSSSLLLL_vvvveeeerrrrssssiiiioooonnnn(const SSL *ssl);

     int SSSSSSSSLLLL_wwwwaaaannnntttt(const SSL *ssl);

     int SSSSSSSSLLLL_wwwwaaaannnntttt_nnnnooootttthhhhiiiinnnngggg(const SSL *ssl);

     int SSSSSSSSLLLL_wwwwaaaannnntttt_rrrreeeeaaaadddd(const SSL *ssl);

     int SSSSSSSSLLLL_wwwwaaaannnntttt_wwwwrrrriiiitttteeee(const SSL *ssl);

     int SSSSSSSSLLLL_wwwwaaaannnntttt_xxxx555500009999_llllooooooookkkkuuuupppp(const SSL *ssl);

     int SSSSSSSSLLLL_wwwwrrrriiiitttteeee(SSL *ssl, const void *buf, int num);

SSSSEEEEEEEE AAAALLLLSSSSOOOO
     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_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_session_cache_mode(3),
     SSL_CTX_set_session_id_context(3),
     SSL_CTX_set_ssl_version(3), SSL_CTX_set_timeout(3),



30/Mar/2005            Last change: 0.9.8o                     13






OpenSSL                                             ssl(3openssl)



     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_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)

HHHHIIIISSSSTTTTOOOORRRRYYYY
     The ssl(3) document appeared in OpenSSL 0.9.2



































30/Mar/2005            Last change: 0.9.8o                     14






OpenSSL                                             ssl(3openssl)























































30/Mar/2005            Last change: 0.9.8o                     15