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 ci-
	   pher	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 in-
	   ternally includes both more private SSL headers and headers from
	   the ccrryyppttoo library.	Whenever you need hard-core details on the in-
	   ternals 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	al-
	   ready 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	al-
	   ready 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	al-
	   ready 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 hu-
	   man 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 *CA-
       path);
       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, un-
       signed 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 SSSSLL_CCTTXX_sseett_ttmmpp_rrssaa_ccaallllbbaacckk((SSSSLL_CCTTXX **ccttxx,, RRSSAA	**((**ccbb))((SSSSLL
	   **ssssll,, iinntt eexxppoorrtt,, iinntt kkeeyylleennggtthh))));;""

	   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_in-
       dex(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), SSL_CTX_set_tmp_rsa_callback(3),
       SSL_CTX_set_tmp_dh_callback(3), SSL_CTX_set_verify(3), SSL_CTX_use_cer-
       tificate(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_pend-
       ing(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_ses-
       sion(3),	SSL_set_shutdown(3), SSL_shutdown(3), SSL_state_string(3),
       SSL_want(3), SSL_write(3), SSL_SESSION_free(3), SSL_SES-
       SION_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.4-RELEASE>

home | help