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

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
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:
<
http://www.freebsd.org/cgi/man.cgi?query=ssl&sektion=3&manpath=FreeBSD+6.2-RELEASE>

home | help