RSA BSAFE Micro Edition Suite	Streamlined security for mobile and embedded devices

---

ssl.h

Go to the documentation of this file.

/* $Id: ssl.h,v 1.517.4.2 2005/10/12 05:05:22 hpriddle Exp $ */

/*
 * Copyright (C) 1999-2003 RSA Security Inc. All rights reserved.
 *
 * This work contains proprietary information of RSA Security.
 * Distribution is limited to authorized licensees of RSA
 * Security. Any unauthorized reproduction, distribution or
 * modification of this work is strictly prohibited.
 */

#ifndef HEADER_SSL_H
#define HEADER_SSL_H

#ifdef  __cplusplus
extern "C" {
#endif

#include "r_lib.h"

/* text strings for the ciphers */

#define SSL_TXT_NULL_WITH_MD5                SSL2_TXT_NULL_WITH_MD5
#define SSL_TXT_RC4_128_WITH_MD5             SSL2_TXT_RC4_128_WITH_MD5
#define SSL_TXT_RC4_128_EXPORT40_WITH_MD5    SSL2_TXT_RC4_128_EXPORT40_WITH_MD5
#define SSL_TXT_RC2_128_CBC_WITH_MD5         SSL2_TXT_RC2_128_CBC_WITH_MD5
#define SSL_TXT_RC2_128_CBC_EXPORT40_WITH_MD5 \
                                        SSL2_TXT_RC2_128_CBC_EXPORT40_WITH_MD5
#define SSL_TXT_IDEA_128_CBC_WITH_MD5        SSL2_TXT_IDEA_128_CBC_WITH_MD5
#define SSL_TXT_DES_64_CBC_WITH_MD5          SSL2_TXT_DES_64_CBC_WITH_MD5
#define SSL_TXT_DES_64_CBC_WITH_SHA          SSL2_TXT_DES_64_CBC_WITH_SHA
#define SSL_TXT_DES_192_EDE3_CBC_WITH_MD5    SSL2_TXT_DES_192_EDE3_CBC_WITH_MD5
#define SSL_TXT_DES_192_EDE3_CBC_WITH_SHA    SSL2_TXT_DES_192_EDE3_CBC_WITH_SHA

#define SSL_MAX_SSL_SESSION_ID_LENGTH        32
#define SSL_MAX_SID_CTX_LENGTH               32

#define SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES    (512/8)
#define SSL_MAX_KEY_ARG_LENGTH            8
#define SSL_MAX_MASTER_KEY_LENGTH        48

/*
 * Maximum size has increased at the EVP interface to support AES, SHA-256 etc.
 * Since SSLC-ME now supports AES their is no need of an SSLC_SMALL_CODE define
 * here, unless to save space when AES is not being used in SSLC-ME.
 */
#ifdef SSLC_SMALL_CODE
#ifdef NO_AES
#define SSL_MAX_MD_SIZE      20
#define SSL_MAX_KEY_LENGTH   24
#define SSL_MAX_IV_LENGTH    8
#endif /* NO_AES */
#endif /* SSLC_SMALL_CODE */

#ifndef SSL_MAX_MD_SIZE
#ifndef EVP_MAX_MD_SIZE
#define SSL_MAX_MD_SIZE      64
#define SSL_MAX_KEY_LENGTH   32
#define SSL_MAX_IV_LENGTH    32
#else
#define SSL_MAX_MD_SIZE      EVP_MAX_MD_SIZE
#define SSL_MAX_KEY_LENGTH   EVP_MAX_KEY_LENGTH
#define SSL_MAX_IV_LENGTH    EVP_MAX_IV_LENGTH
#endif /* EVP_MAX_MD_SIZE */
#endif /* SSL_MAX_MD_SIZE */

/* These are used to specify which ciphers to use and not to use */

#define SSL_TXT_LOW        "LOW"
#define SSL_TXT_MEDIUM     "MEDIUM"
#define SSL_TXT_HIGH       "HIGH"

#define SSL_TXT_kFZA       "kFZA"
#define SSL_TXT_aFZA       "aFZA"
#define SSL_TXT_eFZA       "eFZA"
#define SSL_TXT_FZA        "FZA"

#define SSL_TXT_aNULL      "aNULL"
#define SSL_TXT_eNULL      "eNULL"
#define SSL_TXT_NULL       "NULL"

#define SSL_TXT_TLSV1      "TLSv1"

#define SSL_TXT_kRSA       "kRSA"

#define SSL_TXT_kDHr       "kDHr"
#define SSL_TXT_kDHd       "kDHd"
#define SSL_TXT_kEDH       "kEDH"
#define SSL_TXT_aDSS       "aDSS"
#define SSL_TXT_aDH        "aDH"
#define SSL_TXT_DSS        "DSS"
#define SSL_TXT_DH         "DH"
#define SSL_TXT_EDH        "EDH"
#define SSL_TXT_ADH        "ADH"
#define SSL_TXT_DES        "DES"
#define SSL_TXT_3DES       "3DES"
#define SSL_TXT_RC2        "RC2"
#define SSL_TXT_IDEA       "IDEA"
#define SSL_TXT_SHA        "SHA"
#define SSL_TXT_SSLV2      "SSLv2"

#define SSL_TXT_aRSA        "aRSA"
#define SSL_TXT_RSA         "RSA"
#define SSL_TXT_RC4         "RC4"
#define SSL_TXT_MD5         "MD5"
#define SSL_TXT_SHA1        "SHA1"
#define SSL_TXT_EXP         "EXP"
#define SSL_TXT_EXPORT      "EXPORT"

#define SSL_TXT_SSLV3       "SSLv3"

#define SSL_TXT_AES         "AES"

#define SSL_TXT_ALL         "ALL"

/* SSL features - run time controlled features */
#define SSL_FEATURE_DH                0x00000001

#define SSL_FEATURE_DSA               0x00000002

#define SSL_FEATURE_ALLOW_ENULL       0x00000004

#define SSL_FEATURE_ALLOW_ANULL       0x00000008

#define SSL_FEATURE_ALLOW_ADH         SSL_FEATURE_ALLOW_ANULL

#define SSL_TMP_512_RSA        0x0001

#define SSL_TMP_512_DH         0x0002

#define SSL_TMP_1024_DH        0x0004

#define SSL_TMP_2048_DH        0x0008

#define SSL_TMP_1024_RSA       0x0010

#define SSL_TMP_GENERATE_NOW        0

#define SSL_TMP_GENERATE_LATER      1

#define SSL_FILETYPE_ASN1    X509_FILETYPE_ASN1

#ifndef NO_PEM

#endif

#define SSL_FILETYPE_PEM     X509_FILETYPE_PEM

#define SSL_FILETYPE_HARDWARE 4

/* Options for setting the message size for handshake certificates */

#define SSL_SZ_CERT_ALL       100

#define SSL_SZ_CLIENT_CERT    101

#define SSL_SZ_SERVER_CERT    102

#if defined(MSDOS) && !defined(WIN32)

#define SSL_SZ_CERT_DEFAULT_SZ     30720
#else

#define SSL_SZ_CERT_DEFAULT_SZ    102400
#endif

/* version number for ASN.1 encoding of the session information */

/*
 * Version 0 - initial version                     - pre SSL-C 1.0
 * Version 1 - added the optional peer certificate - SSL-C 1.0
 */

#define SSL_SESSION_ASN1_VERSION 0x0001

#define SSL_OP_MICROSOFT_SESS_ID_BUG             0x00000001L

#define SSL_OP_NETSCAPE_CHALLENGE_BUG            0x00000002L

#define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG  0x00000008L

#define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG       0x00000010L

#define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER        0x00000020L

#define SSL_OP_MSIE_SSLV2_RSA_PADDING            0x00000040L

#define SSL_OP_SSLEAY_080_CLIENT_DH_BUG          0x00000080L

#define SSL_OP_TLS_D5_BUG                        0x00000100L

#define SSL_OP_TLS_BLOCK_PADDING_BUG             0x00000200L

#define SSL_OP_TLS_ROLLBACK_BUG                  0x00000400L

#define SSL_OP_MS_SGC                            0x00000800L

#define SSL_OP_DHANON_NULL_SIGNATURE_OK          0x00001000L

#define SSL_OP_ALL                               0x0000FFFFL

#define SSL_OP_MULTIPRIME_TMP_RSA_KEYS           0x00010000L

#define SSL_OP_QUIET_SHUTDOWN                    0x00020000L

#define SSL_OP_ANYTIME_SHUTDOWN                  0x00040000L

#define SSL_OP_SSLC2_DH_BUG                      0x00080000L

#define SSL_OP_SINGLE_DH_USE                     0x00100000L

#define SSL_OP_EPHEMERAL_RSA                     0x00200000L

#define SSL_OP_REUSE_DELAY_CLIENT_FINISHED       0x00400000L

#define SSL_OP_DELAY_READ_SERVER_FINISHED        0x00800000L

#define SSL_OP_NO_SSLv2                          0x01000000L

#define SSL_OP_NO_SSLv3                          0x02000000L

#define SSL_OP_NO_TLSv1                          0x04000000L

#define SSL_OP_PKCS1_CHECK_1                     0x08000000L

#define SSL_OP_PKCS1_CHECK_2                     0x10000000L

#define SSL_OP_NETSCAPE_CA_DN_BUG                0x20000000L

#define SSL_OP_NON_EXPORT_FIRST                  0x40000000L

#define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG   0x80000000L

#ifndef NO_SESSION_CACHE

#define SSL_SESS_CACHE_OFF               0x0000

#define SSL_SESS_CACHE_CLIENT            0x0001

#define SSL_SESS_CACHE_SERVER            0x0002

#define SSL_SESS_CACHE_BOTH    (SSL_SESS_CACHE_CLIENT|SSL_SESS_CACHE_SERVER)

#define SSL_SESS_CACHE_NO_AUTO_CLEAR     0x0080

#ifndef SSLC_SMALL_CODE

#define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP    0x0100
#endif /* !SSLC_SMALL_CODE */

#define SSL_SESS_CACHE_OFF_NON_ZERO_ID       0x0200

#define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT    (1024*20)
/* end group SSL_SESS_CACHE_MODE_DEF */
#define SSL_EXT_SESS_CACHE_ADD   1

#define SSL_EXT_SESS_CACHE_DEL   2

#define SSL_EXT_SESS_CACHE_FIND  3
/* end group SSL_EXT_SESS_DEF */
#endif /* !NO_SESSION_CACHE  */


#define SSL_NOTHING        1

#define SSL_WRITING        2

#define SSL_READING        3

#define SSL_X509_LOOKUP    4
/* end group SSL Non-Blocking IO States */
/* take out SSL v2 for SSL-C ME and small code builds */
#if !defined(NO_SSL2) || defined(NO_SSL2IMPL)
#include "ssl2.h"
#include "ssl23.h"
#endif /* !NO_SSL2 && !NO_SSL2IMPL */
#include "ssl3.h"
#include "tls1.h" /* mostly sslv3 with some modifications */

#define SSL_ST_CONNECT            0x1000

#define SSL_ST_ACCEPT             0x2000

#define SSL_ST_MASK               0x0FFF

#define SSL_ST_INIT               (SSL_ST_CONNECT|SSL_ST_ACCEPT)

#define SSL_ST_BEFORE             0x4000

#define SSL_ST_OK                 0x03

#define SSL_ST_RENEGOTIATE        (0x04|SSL_ST_INIT)

#define SSL_CB_LOOP               0x01

#define SSL_CB_EXIT               0x02

#define SSL_CB_READ               0x04

#define SSL_CB_WRITE              0x08

#define SSL_CB_ALERT              0x4000

#define SSL_CB_READ_ALERT         (SSL_CB_ALERT|SSL_CB_READ)

#define SSL_CB_WRITE_ALERT        (SSL_CB_ALERT|SSL_CB_WRITE)

#define SSL_CB_ACCEPT_LOOP        (SSL_ST_ACCEPT|SSL_CB_LOOP)

#define SSL_CB_ACCEPT_EXIT        (SSL_ST_ACCEPT|SSL_CB_EXIT)

#define SSL_CB_CONNECT_LOOP       (SSL_ST_CONNECT|SSL_CB_LOOP)

#define SSL_CB_CONNECT_EXIT       (SSL_ST_CONNECT|SSL_CB_EXIT)

#define SSL_CB_HANDSHAKE_START    0x10

#define SSL_CB_HANDSHAKE_DONE     0x20
/* end group SSL_PROTOCOL_STATE_IDS */
/*
 * The following 2 states are kept in ssl->rstate when reads fail,
 * you should not need these
 */

#define SSL_ST_READ_HEADER          0xF0
#define SSL_ST_READ_BODY            0xF1
#define SSL_ST_READ_DONE            0xF2

#define SSL_VERIFY_NONE                 0x00

#define SSL_VERIFY_PEER                 0x01

#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02

#define SSL_VERIFY_CLIENT_ONCE          0x04
/* end group SSL_VERIFY_MODE_DEF */
#define SSL_FLUSH_ALL        0

#define SSL_FLUSH_OLD        1

#define SSL_AD_REASON_OFFSET              1000

/* These alert types are for SSLv3 and TLSv1 */

#define SSL_AD_CLOSE_NOTIFY            SSL3_AD_CLOSE_NOTIFY

#define SSL_AD_UNEXPECTED_MESSAGE      SSL3_AD_UNEXPECTED_MESSAGE

#define SSL_AD_BAD_RECORD_MAC          SSL3_AD_BAD_RECORD_MAC
#define SSL_AD_DECRYPTION_FAILED       TLS1_AD_DECRYPTION_FAILED
#define SSL_AD_RECORD_OVERFLOW         TLS1_AD_RECORD_OVERFLOW

#define SSL_AD_DECOMPRESSION_FAILURE   SSL3_AD_DECOMPRESSION_FAILURE

#define SSL_AD_HANDSHAKE_FAILURE       SSL3_AD_HANDSHAKE_FAILURE

#define SSL_AD_NO_CERTIFICATE          SSL3_AD_NO_CERTIFICATE
#define SSL_AD_BAD_CERTIFICATE         SSL3_AD_BAD_CERTIFICATE
#define SSL_AD_UNSUPPORTED_CERTIFICATE SSL3_AD_UNSUPPORTED_CERTIFICATE
#define SSL_AD_CERTIFICATE_REVOKED     SSL3_AD_CERTIFICATE_REVOKED
#define SSL_AD_CERTIFICATE_EXPIRED     SSL3_AD_CERTIFICATE_EXPIRED
#define SSL_AD_CERTIFICATE_UNKNOWN     SSL3_AD_CERTIFICATE_UNKNOWN

#define SSL_AD_ILLEGAL_PARAMETER       SSL3_AD_ILLEGAL_PARAMETER

#define SSL_AD_UNKNOWN_CA              TLS1_AD_UNKNOWN_CA

#define SSL_AD_ACCESS_DENIED           TLS1_AD_ACCESS_DENIED

#define SSL_AD_DECODE_ERROR            TLS1_AD_DECODE_ERROR
#define SSL_AD_DECRYPT_ERROR           TLS1_AD_DECRYPT_ERROR

#define SSL_AD_EXPORT_RESTRICION       TLS1_AD_EXPORT_RESTRICION

#define SSL_AD_PROTOCOL_VERSION        TLS1_AD_PROTOCOL_VERSION

#define SSL_AD_INSUFFICIENT_SECURITY   TLS1_AD_INSUFFICIENT_SECURITY

#define SSL_AD_INTERNAL_ERROR          TLS1_AD_INTERNAL_ERROR
#define SSL_AD_USER_CANCLED            TLS1_AD_USER_CANCLED
#define SSL_AD_NO_RENEGOTIATION        TLS1_AD_NO_RENEGOTIATION

#define SSL_ERROR_NONE                    0

#define SSL_ERROR_SSL                     1

#define SSL_ERROR_WANT_READ               2

#define SSL_ERROR_WANT_WRITE              3

#define SSL_ERROR_WANT_X509_LOOKUP        4

#define SSL_ERROR_SYSCALL                 5

#define SSL_ERROR_ZERO_RETURN             6

#define SSL_ERROR_WANT_CONNECT            7
/* end group SSL_ERROR_CODE_DEF */
#define SSL_CTRL_NEED_TMP_RSA                1
#define SSL_CTRL_SET_TMP_RSA                 2
#define SSL_CTRL_SET_TMP_DH                  3
#define SSL_CTRL_SET_TMP_RSA_CB              4
#define SSL_CTRL_SET_TMP_DH_CB               5

/* #define SSL_CTRL_GET_SESSION_REUSED          6 */

#define SSL_CTRL_GET_CLIENT_CERT_REQUEST     7
#define SSL_CTRL_GET_NUM_RENEGOTIATIONS      8
#define SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS    9
#define SSL_CTRL_GET_TOTAL_RENEGOTIATIONS   10
#define SSL_CTRL_GET_FLAGS                  11
#define SSL_CTRL_EXTRA_CHAIN_CERT           12
#define SSL_CTRL_NEED_TMP_RSA512            13
#define SSL_CTRL_NEED_TMP_RSA1024           14
#define SSL_CTRL_SET_TMP_RSA512             15
#define SSL_CTRL_SET_TMP_RSA1024            16
#define SSL_CTRL_ADD_EXPLICIT_CERT_CHAIN    17
#define SSL_CTRL_CLEAR_EXPLICIT_CERT_CHAIN  18

/* Stats */

#define SSL_CTRL_SESS_NUMBER                20
#define SSL_CTRL_SESS_CONNECT               21
#define SSL_CTRL_SESS_CONNECT_GOOD          22
#define SSL_CTRL_SESS_CONNECT_RENEGOTIATE   23
#define SSL_CTRL_SESS_ACCEPT                24
#define SSL_CTRL_SESS_ACCEPT_GOOD           25
#define SSL_CTRL_SESS_ACCEPT_RENEGOTIATE    26
#define SSL_CTRL_SESS_HIT                   27
#define SSL_CTRL_SESS_CB_HIT                28
#define SSL_CTRL_SESS_MISSES                29
#define SSL_CTRL_SESS_TIMEOUTS              30
#define SSL_CTRL_SESS_CACHE_FULL            31
#define SSL_CTRL_OPTIONS                    32

#define SSL_CTRL_SET_SESS_CACHE_SIZE        42
#define SSL_CTRL_GET_SESS_CACHE_SIZE        43
#define SSL_CTRL_SET_SESS_CACHE_MODE        44
#define SSL_CTRL_GET_SESS_CACHE_MODE        45
#define SSL_CTRL_SET_MESSAGE_SIZE           46
#define SSL_CTRL_GET_MESSAGE_SIZE           47

#define SSL_CTRL_SET_WRITE_BUFFER_SIZE      50
#define SSL_CTRL_GET_WRITE_BUFFER_SIZE      51

#define SSL_CTRL_SET_DEBUG                  52

#define SSL_CTRL_SET_READ_BUFFER_SIZE       53
#define SSL_CTRL_GET_READ_BUFFER_SIZE       54

#define SSL_CTRL_GET_REFERENCES             55

#define SSL_CTRL_SET_RSA_BLINDING_MODE      56

#define SSL_CTRL_SET_MAX_RSA_N_SIZE         57
#define SSL_CTRL_SET_MAX_RSA_E_SIZE         58


/*
 * 'DEFAULT' at the start of the cipher list insert the following string
 * in addition to this being the default cipher string
 *
 */

#ifdef SSLC_SMALL_CODE

#define SSL_DEFAULT_CIPHER_LIST "AES256-SHA:AES128-SHA:DES-CBC3-SHA:DES-CBC-SHA:RC4-SHA:RC4-MD5:EXP-DES-CBC-SHA:EXP-RC4-MD5:NULL-SHA:NULL-MD5"

#else /* !SSLC_SMALL_CODE */

#ifndef NO_RSA
#define SSL_DEFAULT_CIPHER_LIST  \
                              "ALL:!ADH:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP"
#else /* !NO_RSA */
#ifdef SSL_ALLOW_ADH
#define SSL_DEFAULT_CIPHER_LIST "HIGH:MEDIUM:LOW:ADH+3DES:ADH+RC4:ADH+DES:+EXP"
#else /* !SSL_ALLOW_ADH */
#define SSL_DEFAULT_CIPHER_LIST "HIGH:MEDIUM:LOW:+EXP"
#endif /* SSL_ALLOW_ADH */
#endif /* NO_RSA */

#endif /* SSLC_SMALL_CODE */

/* Used in SSL_set_shutdown() / SSL_get_shutdown(); */

#define SSL_SENT_SHUTDOWN     1

#define SSL_RECEIVED_SHUTDOWN 2

/* Take out headers not needed for small code build, such as SSL-C ME */
#ifndef SSLC_SMALL_CODE
#include "vercfg.h"
#else /* SSLC_SMALL_CODE */
#include "r_time.h"
#endif /* SSLC_SMALL_CODE */

/* data types are opaque for the library-internal functions when
 * compiling user code - there are typedefs for all the required
 * datatypes referenced in the ssl structures (which
 * remain visible for compatibility)
 */
#ifndef HEADER_COMMON_STACK_H_TYPEDEF_DEF
#define HEADER_COMMON_STACK_H_TYPEDEF_DEF
typedef struct stack_st STACK;
#endif

#ifndef HEADER_COMMON_EVP_H_TYPEDEF_DEF
#define HEADER_COMMON_EVP_H_TYPEDEF_DEF
typedef struct evp_md_st EVP_MD;
typedef struct evp_md_ctx_st EVP_MD_CTX;
typedef struct evp_cipher_st EVP_CIPHER;
typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;

typedef struct evp_pkey_st EVP_PKEY;

/* To remove a dependence of the old evp on ASN.1 definitions */
typedef void EVP_ASN1_TYPE;
#endif /* HEADER_COMMON_EVP_H */

#ifndef HEADER_COMMON_E_ENCODE_H
#define HEADER_COMMON_E_ENCODE_H
typedef struct evp_encode_ctx_st EVP_ENCODE_CTX;
#endif /* HEADER_COMMON_E_ENCODE_H */

#ifndef HEADER_COMMON_DH_H_TYPEDEF_DEF
#define HEADER_COMMON_DH_H_TYPEDEF_DEF
typedef struct dh_st DH;
#endif /* HEADER_COMMON_DH_H_TYPEDEF_DEF */

#ifndef HEADER_COMMON_RSA_H_TYPEDEF_DEF
#define HEADER_COMMON_RSA_H_TYPEDEF_DEF
typedef struct rsa_surrender_st RSA_SURRENDER;
typedef struct rsa_st RSA;
#endif /* HEADER_COMMON_RSA_H_TYPEDEF_DEF */

#ifndef HEADER_COMMON_RSA_H
typedef struct rsa_meth_st RSA_METHOD;

RSA        * R_CDECL RSA_new(void);
void R_CDECL RSA_free(RSA *rsa);
RSA * R_CDECL RSA_dup(RSA *rsa);
int R_CDECL RSA_size(RSA *rsa);

RSA_METHOD * R_CDECL RSA_default_method(void);
RSA        * R_CDECL RSA_new_method(RSA_METHOD *method);
void R_CDECL RSA_set_default_method(RSA_METHOD *method);
#endif /* HEADER_COMMON_RSA_H */

#include "cert.h"

#ifndef HEADER_COMMON_RSA_H_TYPEDEF_DEF
#define HEADER_COMMON_RSA_H_TYPEDEF_DEF
typedef struct rsa_surrender_st RSA_SURRENDER;
typedef struct rsa_st RSA;
#endif /* HEADER_COMMON_RSA_H_TYPEDEF_DEF */

#ifndef HEADER_PEM_H_TYPEDEF_DEF
#define HEADER_PEM_H_TYPEDEF_DEF
typedef int  R_CDECL PEM_PASSWORD_CB_T(char *buf, int len, int flag);
#endif /* HEADER_PEM_H_TYPEDEF_DEF */

typedef struct ssl_ctx_st SSL_CTX;

#ifndef HEADER_SSL_H_TYPEDEF_DEF
#define HEADER_SSL_H_TYPEDEF_DEF

typedef struct ssl_st SSL;
#endif /* HEADER_SSL_H_TYPEDEF_DEF*/


typedef struct ssl_cipher_st SSL_CIPHER;

typedef struct ssl_method_st SSL_METHOD;


typedef struct ssl_session_st SSL_SESSION;
typedef struct ssl_simple_session_cache_st SSL_SIMPLE_SESSION_CACHE;

#ifndef HEADER_X509_H_TYPEDEF_DEF
#define HEADER_X509_H_TYPEDEF_DEF
typedef struct x509_st X509;
typedef struct X509_name_entry_st X509_NAME_ENTRY;
typedef struct x509_store_st X509_STORE;
typedef struct x509_store_state_st X509_STORE_CTX;
#ifdef X509_NAME
/*
 * wincrypt.h defines this name as well
 */
#undef X509_NAME
#endif /* X509_NAME */
typedef struct X509_name_st X509_NAME;
#endif /* HEADER_X509_H_TYPEDEF_DEF */


SSL_SESSION * R_CDECL SSL_SESSION_new(void);
unsigned long R_CDECL SSL_SESSION_hash(SSL_SESSION *sess);
int R_CDECL SSL_SESSION_cmp(SSL_SESSION *sessa, SSL_SESSION *sessb);
void R_CDECL SSL_SESSION_free(SSL_SESSION *sess);
int R_CDECL i2d_SSL_SESSION(SSL_SESSION *in, unsigned char **pp);
void R_CDECL SSL_SESSION_reference_inc(SSL_SESSION *sess);
int R_CDECL SSL_set_session(SSL *ssl, SSL_SESSION *sess);
SSL_SESSION * R_CDECL d2i_SSL_SESSION(SSL_SESSION **sess,
                             unsigned char **pp, long length);
R_TIME_T * R_CDECL SSL_SESSION_get_time(SSL_SESSION *sess, R_TIME_T *stime);
R_TIME_T * R_CDECL SSL_SESSION_set_time(SSL_SESSION *sess, R_TIME_T *stime);
long R_CDECL SSL_SESSION_get_timeout(SSL_SESSION *sess);
long R_CDECL SSL_SESSION_set_timeout(SSL_SESSION *sess, long tmout);
void R_CDECL SSL_copy_session(SSL *to,SSL *from);
SSLCERT * R_CDECL SSL_SESSION_get_peer_certificate(SSL_SESSION *sess);
int R_CDECL SSL_SESSION_get_master_key_length(SSL_SESSION *sess);
unsigned char * R_CDECL SSL_SESSION_get_master_key(SSL_SESSION *sess);
unsigned int R_CDECL SSL_SESSION_get_session_id_length(SSL_SESSION *sess);
unsigned char * R_CDECL SSL_SESSION_get_session_id(SSL_SESSION *sess);
int R_CDECL SSL_SESSION_set_not_reusable(SSL_SESSION *sess);
int R_CDECL SSL_SESSION_get_not_reusable(SSL_SESSION *sess);
/* end group SESSION_MANAGEMENT_FUNCS */
#if defined(HEADER_COMMON_BIO_H) || defined(DOXYGEN)

BIO_METHOD * R_CDECL BIO_f_ssl(void);
BIO * R_CDECL BIO_new_ssl(SSL_CTX *ctx,int client);
BIO * R_CDECL BIO_new_ssl_connect(SSL_CTX *ctx);
BIO * R_CDECL BIO_new_buffer_ssl_connect(SSL_CTX *ctx);
int R_CDECL BIO_ssl_copy_session(BIO *to,BIO *from);
int R_CDECL BIO_ssl_shutdown(BIO *bio);
/* end group BIO_SSL_FUNCS */
int R_CDECL SSL_SESSION_print(BIO *bio, SSL_SESSION *sess);
SSL_SESSION * R_CDECL d2i_SSL_SESSION_bio(BIO *bio, unsigned char **s_id);
int R_CDECL i2d_SSL_SESSION_bio(BIO *bio, SSL_SESSION *sess);
int R_CDECL PEM_write_bio_SSL_SESSION(BIO *bio, SSL_SESSION *sess);
SSL_SESSION * R_CDECL PEM_read_bio_SSL_SESSION(BIO *bio, SSL_SESSION **sess,
    PEM_PASSWORD_CB_T *callback);

#ifndef NO_FP_API
int R_CDECL SSL_SESSION_print_fp(FILE *fp, SSL_SESSION *sess);
SSL_SESSION * R_CDECL PEM_read_SSL_SESSION(FILE *fp, SSL_SESSION **sess,
    PEM_PASSWORD_CB_T *callback);
int R_CDECL PEM_write_SSL_SESSION(FILE *fp, SSL_SESSION *sess);
#endif /* !NO_FP_API */

/* end group SESSION_MANAGEMENT_FUNCS */
#endif /* (HEADER_COMMON_BIO_H) || (DOXYGEN) */

#define SSL_is_init_finished(ssl) (SSL_state(ssl) == SSL_ST_OK)

#define SSL_in_init(ssl)          (SSL_state(ssl)&SSL_ST_INIT)

#define SSL_in_before(ssl)        (SSL_state(ssl)&SSL_ST_BEFORE)

#define SSL_in_connect_init(ssl)  (SSL_state(ssl)&SSL_ST_CONNECT)

#define SSL_in_accept_init(ssl)   (SSL_state(ssl)&SSL_ST_ACCEPT)

/* end group SSL_PROTOCOL_FUNCS */
#define SSL_add_explicit_cert_chain(ssl,x509) \
    SSL_ctrl((ssl),SSL_CTRL_ADD_EXPLICIT_CERT_CHAIN,0,(char *)x509)

 #define SSL_set_max_rsa_n_size(ssl,size) \
    SSL_ctrl((ssl),SSL_CTRL_SET_MAX_RSA_N_SIZE,(size),NULL)

 #define SSL_set_max_rsa_e_size(ssl,size) \
    SSL_ctrl((ssl),SSL_CTRL_SET_MAX_RSA_E_SIZE,(size),NULL)


#define SSL_clear_explicit_cert_chain(ssl) \
    SSL_ctrl((ssl),SSL_CTRL_CLEAR_EXPLICIT_CERT_CHAIN,0,NULL)
/* end group SSL_CONNECTION_STATUS_FUNCS */
#define SSL_CTX_sess_set_cache_size(ctx, csize) \
    SSL_CTX_ctrl((ctx), SSL_CTRL_SET_SESS_CACHE_SIZE, (csize), NULL)

#define SSL_CTX_sess_get_cache_size(ctx) \
    SSL_CTX_ctrl((ctx), SSL_CTRL_GET_SESS_CACHE_SIZE, 0, NULL)

#define SSL_CTX_set_session_cache_mode(ctx,mode) \
    (int)SSL_CTX_ctrl((ctx), SSL_CTRL_SET_SESS_CACHE_MODE, (mode), NULL)

#define SSL_CTX_get_session_cache_mode(ctx) \
    (int)SSL_CTX_ctrl((ctx), SSL_CTRL_GET_SESS_CACHE_MODE, 0, NULL)

 #define SSL_CTX_set_max_rsa_n_size(ssl,size) \
    SSL_CTX_ctrl((ssl_ctx),SSL_CTRL_SET_MAX_RSA_N_SIZE,(size),NULL)

 #define SSL_CTX_set_max_rsa_e_size(ssl,size) \
    SSL_CTX_ctrl((ssl_ctx),SSL_CTRL_SET_MAX_RSA_E_SIZE,(size),NULL)




typedef int  R_CDECL SSL_SESS_NEW_CB_T(SSL *ssl, SSL_SESSION *session);
void R_CDECL SSL_CTX_sess_set_new_cb(SSL_CTX *ctx, SSL_SESS_NEW_CB_T *new_session_cb);
SSL_SESS_NEW_CB_T * R_CDECL SSL_CTX_sess_get_new_cb(SSL_CTX *ctx);

typedef void  R_CDECL SSL_SESS_REMOVE_CB_T(SSL_CTX *ssl, SSL_SESSION *session);
void R_CDECL SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
    SSL_SESS_REMOVE_CB_T *remove_session_cb);
SSL_SESS_REMOVE_CB_T * R_CDECL SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx);

typedef SSL_SESSION  * R_CDECL SSL_SESS_GET_CB_T(SSL *ssl, unsigned char *sess_id,
    int id_len, int *copyflag);
void R_CDECL SSL_CTX_sess_set_get_cb(SSL_CTX *ctx, SSL_SESS_GET_CB_T *get_session_cb);
SSL_SESS_GET_CB_T * R_CDECL SSL_CTX_sess_get_get_cb(SSL_CTX *ctx);
int R_CDECL SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *sess);
int R_CDECL SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *sess);
int R_CDECL SSL_CTX_flush_sessions(SSL_CTX *ctx, int timeout);
/* end group SSL_SESSION_CACHE_FUNCS */
typedef void  R_CDECL SSL_INFO_CB_T(SSL *ssl, int where, int ret);

void R_CDECL SSL_CTX_set_info_cb(SSL_CTX *ctx, SSL_INFO_CB_T *cb);
SSL_INFO_CB_T * R_CDECL SSL_CTX_get_info_cb(SSL_CTX *ctx);
#define SSL_get_references(ssl) \
    SSL_ctrl((ssl), SSL_CTRL_GET_REFERENCES, 0, NULL)

#define SSL_CTX_get_references(ctx) \
    SSL_CTX_ctrl((ctx), SSL_CTRL_GET_REFERENCES, 0, NULL)

/* API cleanups */
#include "ssl_lib.h"


/* These will only be used when doing non-blocking I/O */
#define SSL_want_nothing(ssl)     (SSL_want(ssl) == SSL_NOTHING)

#define SSL_want_read(ssl)        (SSL_want(ssl) == SSL_READING)


#define SSL_want_write(ssl)       (SSL_want(ssl) == SSL_WRITING)

#define SSL_want_x509_lookup(ssl) (SSL_want(ssl) == SSL_X509_LOOKUP)
/* end group SSL_PROTOCOL_FUNCS */


#define SSL_BLINDING_MODE_OFF           0x00

#define SSL_BLINDING_MODE_NO_UPDATE     0x01

#define SSL_BLINDING_MODE_FULL_UPDATE   0x02

#define SSL_DEFAULT_MAX_RSA_N_SIZE      8192

#define SSL_DEFAULT_MAX_RSA_E_SIZE      128

#define SSL_DEFAULT_MAX_RSA_N_SIZE      8192

#define SSL_DEFAULT_MAX_RSA_E_SIZE      128

SSL_CTX * R_CDECL SSL_CTX_new(SSL_METHOD *meth);
void R_CDECL SSL_CTX_free(SSL_CTX *ctx);
int R_CDECL SSL_CTX_set_cipher_list(SSL_CTX *ctx, char *str);

typedef int SSL_CTX_INFO;
int R_CDECL SSL_CTX_set_info(SSL_CTX *ssl_ctx, SSL_CTX_INFO info_id, void *value);
int R_CDECL SSL_CTX_get_info(SSL_CTX *ssl_ctx, SSL_CTX_INFO info_id, void *value);
int R_CDECL SSL_CTX_set_R_LIB_CTX(SSL_CTX *ssl_ctx, R_LIB_CTX *lib_ctx, int mode);

#define SSL_CTX_set_rsa_blinding_mode(ctx,mode) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SET_RSA_BLINDING_MODE,mode,NULL)

/* end group SSL_CTX_FUNCS */
#define SSLC_FIPS140_SSL_MODE                         R_LIB_CTX_FIPS140_MODE

#define SSLC_NON_FIPS140_MODE                         R_LIB_CTX_STANDARD_MODE

#define SSLC_HARDWARE_MODE                            R_LIB_CTX_HARDWARE_MODE

#define SSLC_SOFTWARE_MODE                            R_LIB_CTX_SOFTWARE_MODE

#define SSL_CTX_INFO_R_LIB_CTX                          1

#ifndef NO_FIPS

#endif
#define SSL_CTX_INFO_FIPS140_MODE                             2

/* end-SSL_CTX_INFO_TYPE */
#define SSL_CTX_INFO_R_CR_CTX                                 3
#define SSL_CTX_INFO_METH_DATA                                4

#define SSL_INFO_R_LIB_CTX                      SSL_CTX_INFO_R_LIB_CTX

#ifndef NO_FIPS

#endif /* NO_FIPS */
#define SSL_INFO_FIPS140_MODE                   SSL_CTX_INFO_FIPS140_MODE

/* end-SSL_INFO_TYPE */
#define SSL_INFO_R_CR_CTX                       SSL_CTX_INFO_R_CR_CTX
#define SSL_INFO_METH_DATA                      SSL_CTX_INFO_METH_DATA

int R_CDECL SSL_set_cipher_list(SSL *ssl, char *str);
char * R_CDECL SSL_get_cipher_list(SSL *ssl,int idx);
char * R_CDECL SSL_get_shared_ciphers(SSL *ssl, char *buffer, int len);
STACK * R_CDECL SSL_get_ciphers(SSL *ssl);

void R_CDECL SSL_set_connect_state(SSL *ssl);
void R_CDECL SSL_set_accept_state(SSL *ssl);

int R_CDECL SSL_get_peer_cert_chain_count(SSL *ssl);
SSLCERT * R_CDECL SSL_get_peer_cert_chain_item(SSL *ssl, int n);
int R_CDECL SSL_get_ciphers_count(SSL *ssl);
SSL_CIPHER * R_CDECL SSL_get_ciphers_item(SSL *ssl, int n);

int R_CDECL SSL_pending(SSL *ssl);
char * R_CDECL SSL_get_version(SSL *ssl);

SSLCERT * R_CDECL SSL_get_certificate(SSL *ssl);
SSLCERT_PKEY * R_CDECL SSL_get_privatekey(SSL *ssl);
SSL_CIPHER * R_CDECL SSL_get_current_cipher(SSL *ssl);
int R_CDECL SSL_CIPHER_get_bits(SSL_CIPHER *cipher, int *alg_bits);
unsigned long R_CDECL SSL_CIPHER_get_id(SSL_CIPHER *cipher);
char * R_CDECL SSL_CIPHER_get_version(SSL_CIPHER *cipher);
char * R_CDECL SSL_CIPHER_get_name(SSL_CIPHER *cipher);
int R_CDECL SSL_CIPHER_get_valid(SSL_CIPHER *cipher);
char * R_CDECL SSL_CIPHER_description(SSL_CIPHER *cipher, char *buffer, int size);
/* end group SSL_CIPHER_MANAGEMENT_FUNCS */
#ifndef NO_SOCK
int R_CDECL SSL_set_fd(SSL *ssl, int fd);
int R_CDECL SSL_set_rfd(SSL *ssl, int fd);
int R_CDECL SSL_set_wfd(SSL *ssl, int fd);
#endif /* NO_SOCK */
int R_CDECL SSL_get_fd(SSL *ssl);
SSLCERT * R_CDECL SSL_get_peer_certificate(SSL *ssl);
STACK * R_CDECL SSL_get_peer_cert_chain(SSL *ssl);
char * R_CDECL SSL_CTX_get_version(SSL_CTX *ssl_ctx);

long R_CDECL SSL_CTX_set_timeout(SSL_CTX *ctx,long tmout);
long R_CDECL SSL_CTX_get_timeout(SSL_CTX *ctx);
#ifndef NO_X509_STORE

SSLCERT_STORE * R_CDECL SSL_CTX_get_cert_store(SSL_CTX *ctx);
void R_CDECL SSL_CTX_set_cert_store(SSL_CTX *,SSLCERT_STORE *);
#endif /* !NO_X509_STORE */

#if defined(HEADER_COMMON_BIO_H) || defined(DOXYGEN)

void R_CDECL SSL_set_bio(SSL *ssl, BIO *rbio, BIO *wbio);
#endif /* (HEADER_COMMON_BIO_H) || (DOXYGEN) */

void R_CDECL ERR_load_SSL_strings(void);

void R_CDECL SSL_load_error_strings(void);
char * R_CDECL SSL_state_string(SSL *ssl);
char * R_CDECL SSL_rstate_string(SSL *ssl);
char * R_CDECL SSL_state_string_long(SSL *ssl);
char * R_CDECL SSL_rstate_string_long(SSL *ssl);
void R_CDECL SSL_CTX_set_verify_depth(SSL_CTX *ssl_ctx, int depth);
int R_CDECL SSL_CTX_get_verify_depth(SSL_CTX *ssl_ctx);

int R_CDECL SSL_CTX_get_verify_mode(SSL_CTX *ctx);
void R_CDECL SSL_CTX_set_verify_mode(SSL_CTX *ctx,int mode);

typedef int  R_CDECL SSL_CTX_CERT_VERIFY_CB_T(SSLCERT_STORE_CTX *store_ctx,
                                              char *arg);
void R_CDECL SSL_CTX_set_cert_verify_cb(SSL_CTX *ctx,
                                        SSL_CTX_CERT_VERIFY_CB_T *cb,
                                        char *arg);

typedef int  R_CDECL SSL_CTX_APP_VERIFY_CB_T(SSL *ssl, SSLCERT **certs, int num,
                                             char *arg, long *verify_result);

void R_CDECL SSL_CTX_set_app_verify_cb(SSL_CTX *ctx,
                                       SSL_CTX_APP_VERIFY_CB_T *cb, char *arg);
SSL_CTX_APP_VERIFY_CB_T * R_CDECL SSL_CTX_get_app_verify_cb(SSL_CTX *ctx);
char * R_CDECL SSL_CTX_get_app_verify_cb_arg(SSL_CTX *ctx);

#ifndef NO_PEM

void R_CDECL SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, PEM_PASSWORD_CB_T *cb);
#endif /* NO_PEM */

int R_CDECL SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);
int R_CDECL SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, unsigned char *d, long len);
int R_CDECL SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);
int R_CDECL SSL_CTX_use_PrivateKey_ASN1(SSL_CTX *ctx, unsigned char *key, long len,
                                int type);
int R_CDECL SSL_CTX_check_private_key(SSL_CTX *ctx);
int R_CDECL SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);
int R_CDECL SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *buffer, long len);
int R_CDECL SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);
int R_CDECL SSL_use_PrivateKey_ASN1(SSL *ssl, unsigned char *data,
                            long len, int type);
int R_CDECL SSL_check_private_key(SSL *ctx);

EVP_PKEY * R_CDECL PEM_read_bio_PrivateKey(BIO *bio, EVP_PKEY **x,
                                  PEM_PASSWORD_CB_T *callback);

#ifndef NO_STDIO
int R_CDECL SSL_use_RSAPrivateKey_file(SSL *ssl, char *file, int type);
int R_CDECL SSL_use_PrivateKey_file(SSL *ssl, char *file, int type);
int R_CDECL SSL_use_RSAPrivateKey_nFast(SSL *ssl, void *app_handle, void *key_id,
                                int num_bits);
int R_CDECL SSL_CTX_use_RSAPrivateKey_nFast(SSL_CTX *ctx, void *app_handle,
                                    void *key_id, int num_bits);

int R_CDECL SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, char *file, int type);
int R_CDECL SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, char *file, int type);
int R_CDECL SSL_CTX_use_RSAPrivateKey_nFast(SSL_CTX *ctx, void *app_handle,
                                    void *key_id, int num_bits);
#endif /* !NO_STDIO */

int R_CDECL SSL_CTX_use_certificate(SSL_CTX *ctx, SSLCERT *x509);
int R_CDECL SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, unsigned char *cert, long len);

int R_CDECL SSL_use_certificate(SSL *ssl, SSLCERT *x509);
int R_CDECL SSL_use_certificate_ASN1(SSL *ssl, unsigned char *buffer, long len);

#ifndef NO_STDIO
int R_CDECL SSL_use_certificate_file(SSL *ssl, char *file, int type);
int R_CDECL SSL_CTX_use_certificate_file(SSL_CTX *ctx, char *file, int type);

#endif /* NO_STDIO */
/* end group SSL_CERTIFICATE_MANAGEMENT_FUNCS */
SSL * R_CDECL SSL_new(SSL_CTX *ctx);
int R_CDECL SSL_clear(SSL *ssl);
void R_CDECL SSL_free(SSL *ssl);
SSL * R_CDECL SSL_dup(SSL *ssl);
typedef int SSL_INFO;
int R_CDECL SSL_set_info(SSL *ssl, SSL_INFO info_id, void *value);
int R_CDECL SSL_get_info(SSL *ssl, SSL_INFO info_id, void *value);
int R_CDECL SSL_set_R_LIB_CTX(SSL *ssl, R_LIB_CTX *lib_ctx, int mode);

int R_CDECL SSL_do_handshake(SSL *ssl);
int R_CDECL SSL_renegotiate(SSL *ssl);
int R_CDECL SSL_shutdown(SSL *ssl);
int R_CDECL SSL_accept(SSL *ssl);
int R_CDECL SSL_connect(SSL *ssl);
int R_CDECL SSL_read(SSL *ssl,char *buffer, int num);
int R_CDECL SSL_peek(SSL *ssl,char *buffer, int num);
int R_CDECL SSL_write(SSL *ssl,char *buffer, int num);
long R_CDECL SSL_ctrl(SSL *ssl,int cmd, long larg, char *parg);
long R_CDECL SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, char *parg);

int R_CDECL SSL_get_error(SSL *ssl, int ret_code);
/* sets the 'default' SSL version that SSL_new() will create */
int R_CDECL SSL_CTX_set_ssl_version(SSL_CTX *ctx, SSL_METHOD *meth);

/* SSLv2 */
SSL_METHOD * R_CDECL SSLv2_method(void);
SSL_METHOD * R_CDECL SSLv2_server_method(void);
SSL_METHOD * R_CDECL SSLv2_client_method(void);

/* SSLv3 */
SSL_METHOD * R_CDECL SSLv3_server_method(void);
SSL_METHOD * R_CDECL SSLv3_client_method(void);
SSL_METHOD * R_CDECL SSLv3_method(void);

/* SSLv3 but can rollback to v2 */
SSL_METHOD * R_CDECL SSLv23_method(void);
SSL_METHOD * R_CDECL SSLv23_server_method(void);
SSL_METHOD * R_CDECL SSLv23_client_method(void);

/* TLSv1.0 */
SSL_METHOD * R_CDECL TLSv1_method(void);
SSL_METHOD * R_CDECL TLSv1_server_method(void);
SSL_METHOD * R_CDECL TLSv1_client_method(void);

int R_CDECL SSL_set_ssl_method(SSL *ssl,SSL_METHOD *meth);
/* end group SSL_METHOD_FUNCS */
char * R_CDECL SSL_alert_type_string_long(int value);
char * R_CDECL SSL_alert_type_string(int value);
char * R_CDECL SSL_alert_desc_string_long(int value);
char * R_CDECL SSL_alert_desc_string(int value);
#ifndef NO_CA_LIST

void R_CDECL SSL_set_client_CA_list(SSL *ssl, STACK *sk);
void R_CDECL SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK *sk);
STACK * R_CDECL SSL_get_client_CA_list(SSL *ssl);
STACK * R_CDECL SSL_CTX_get_client_CA_list(SSL_CTX *ctx);
int R_CDECL SSL_add_client_CA(SSL *ssl, SSLCERT *x509);
int R_CDECL SSL_CTX_add_client_CA(SSL_CTX *ctx, SSLCERT *x509);
#ifndef NO_STDIO
STACK * R_CDECL SSL_load_client_CA_file(char *file);
#endif /* !NO_STDIO */

/* end group SSL_CERTIFICATE_STORE_FUNCS */
#endif /* !NO_CA_LIST */


long R_CDECL SSL_get_default_timeout(SSL *ssl);
#include "ssl_algs.h"

/*
 * @defgroup SSL_UTILITY_FUNCS Utility Functions
 * This section describes the functions used to support an SSL
 * connection.
 *
 * @{
 */
/*
 * @}
 */

/* Define these quiet shutdown functions for those who are already using
 * them
 */

#define SSL_CTX_set_quiet_shutdown(ctx, mode) \
    if (mode) SSL_CTX_set_options(ctx,SSL_OP_QUIET_SHUTDOWN);\
    else SSL_CTX_set_options(ctx,!SSL_OP_QUIET_SHUTDOWN);

#define SSL_CTX_get_quiet_shutdown(ctx) \
    ((SSL_CTX_get_options(ctx) & SSL_OP_QUIET_SHUTDOWN) != 0)

#define SSL_set_quiet_shutdown(ssl,mode) \
     if (mode) SSL_set_options(ssl,SSL_OP_QUIET_SHUTDOWN);\
     else SSL_set_options(ssl,!SSL_OP_QUIET_SHUTDOWN);

#define SSL_get_quiet_shutdown(ssl) \
    ((SSL_get_options(ssl) & SSL_OP_QUIET_SHUTDOWN) != 0)

/* Define the anytime shutdown functions for IMODE */

#define SSL_CTX_set_anytime_shutdown(ctx, mode) \
   if (mode) SSL_CTX_set_options(ctx,SSL_OP_ANYTIME_SHUTDOWN);\
   else SSL_CTX_set_options(ctx,!SSL_OP_ANYTIME_SHUTDOWN)

#define SSL_CTX_get_anytime_shutdown(ctx) \
    ((SSL_CTX_get_options(ctx) & SSL_OP_ANYTIME_SHUTDOWN) != 0)

#define SSL_set_anytime_shutdown(ssl,mode) \
    if (mode) SSL_set_options(ssl,SSL_OP_ANYTIME_SHUTDOWN);\
    else SSL_set_options(ssl,!SSL_OP_ANYTIME_SHUTDOWN)

#define SSL_get_anytime_shutdown(ssl) \
    ((SSL_get_options(ssl) & SSL_OP_ANYTIME_SHUTDOWN) != 0)

#define SSL_set_debug(ssl) \
    SSL_ctrl((ssl), SSL_CTRL_SET_DEBUG, 1, NULL)

/* end group SSL_SHUTDOWN_FUNCS */
int R_CDECL SSL_CTX_set_default_verify_paths(SSL_CTX *ctx);
int R_CDECL SSL_CTX_load_verify_locations(SSL_CTX *ctx, char *CAfile, char *CApath);
int R_CDECL SSL_CTX_add_certificate_to_store(SSL_CTX *ctx, SSLCERT *cert);
#ifndef NO_CA_LIST

int R_CDECL SSL_get_client_CA_list_count(SSL *ssl);
SSLCERT_NAME * R_CDECL SSL_get_client_CA_list_item(SSL *ssl, int n);
int R_CDECL SSL_CTX_get_client_CA_list_count(SSL_CTX *ctx);
SSLCERT_NAME * R_CDECL SSL_CTX_get_client_CA_list_item(SSL_CTX *ctx, int n);
/* end group SSL_CERTIFICATE_MANAGEMENT_FUNCS */
#endif /* !NO_CA_LIST */

typedef int  R_CDECL SSL_CTX_CLIENT_CERT_CB_T(SSL *ssl, void **cpp, EVP_PKEY **kpp);

void R_CDECL SSL_CTX_set_client_cert_cb(SSL_CTX *ctx, SSL_CTX_CLIENT_CERT_CB_T *cb);
SSL_CTX_CLIENT_CERT_CB_T * R_CDECL SSL_CTX_get_client_cert_cb(SSL_CTX *ctx);
/* end group SSL_CERTIFICATE_MANAGEMENT_FUNCS */
#define SSL_CTX_set_tmp_rsa_callback(ctx,cb) \
    SSL_CTX_set_tmp_rsa_cb(ctx,cb)
#define SSL_CTX_set_tmp_dh_callback(ctx,dh) \
    SSL_CTX_set_tmp_dh_cb(ctx,dh)
#define SSL_set_tmp_rsa_callback(ssl,cb) \
    SSL_set_tmp_rsa_cb(ssl,cb)
#define SSL_set_tmp_dh_callback(ssl,dh) \
    SSL_set_tmp_dh_cb(ssl,dh)

#define SSL_CTX_need_tmp_RSA(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_NEED_TMP_RSA,0,NULL)

#define SSL_CTX_set_tmp_rsa(ctx,rsa) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_RSA,0,(char *)rsa)
#define SSL_CTX_set_tmp_rsa512(ctx,rsa) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_RSA512,0,(char *)rsa)
#define SSL_CTX_set_tmp_rsa1024(ctx,rsa) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_RSA1024,0,(char *)rsa)

#define SSL_CTX_set_tmp_dh(ctx,dh) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH,0,(char *)dh)

typedef RSA  * R_CDECL SSL_TMP_RSA_CB_T(SSL *ssl, int export_type);

#define SSL_CTX_set_tmp_rsa_cb(ctx,cb) \
    SSL_CTX_ctrl((ctx), SSL_CTRL_SET_TMP_RSA_CB, 0, (char *)(cb))

SSL_TMP_RSA_CB_T * R_CDECL SSL_CTX_get_tmp_rsa_cb(SSL_CTX *ctx);

typedef DH  * R_CDECL SSL_TMP_DH_CB_T(SSL *ssl, int export_type);

#define SSL_CTX_set_tmp_dh_cb(ctx, cb) \
    SSL_CTX_ctrl((ctx), SSL_CTRL_SET_TMP_DH_CB, 0, (char *)(cb))

SSL_TMP_DH_CB_T * R_CDECL SSL_CTX_get_tmp_dh_cb(SSL_CTX *ctx);

#define SSL_set_tmp_rsa_cb(ssl, callback) \
    SSL_ctrl((ssl), SSL_CTRL_SET_TMP_RSA_CB, 0, (char *)(callback))

SSL_TMP_RSA_CB_T * R_CDECL SSL_get_tmp_rsa_cb(SSL *ssl);

#define SSL_set_tmp_dh_cb(ssl, callback) \
    SSL_ctrl((ssl), SSL_CTRL_SET_TMP_DH_CB, 0, (char *)(callback))

SSL_TMP_DH_CB_T * R_CDECL SSL_get_tmp_dh_cb(SSL *ssl);

int R_CDECL SSL_CTX_set_tmp_key_mode(SSL_CTX *ctx, int type, int mode);

#ifndef SSLC_SMALL_CODE

#define SSL_CTX_set_alert_info_callback(x,y,z) \
    SSL_CTX_set_alert_info_cb(x,y,z)
#define SSL_CTX_get_alert_info_callback(x) \
    SSL_CTX_get_alert_info_cb(x)
#define SSL_CTX_get_alert_info_callback_arg(x) \
    SSL_CTX_get_alert_info_cb_arg(x)

#define SSL_set_alert_info_callback(x,y,z) \
    SSL_set_alert_info_cb(x,y,z)
#define SSL_get_alert_info_callback(x) \
    SSL_get_alert_info_cb(x)
#define SSL_get_alert_info_callback_arg(x) \
    SSL_get_alert_info_cb_arg(x)

#define SSL_CTX_sess_number(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_NUMBER,0,NULL)
#define SSL_CTX_sess_connect(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT,0,NULL)
#define SSL_CTX_sess_connect_good(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_GOOD,0,NULL)
#define SSL_CTX_sess_connect_renegotiate(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_RENEGOTIATE,0,NULL)
#define SSL_CTX_sess_accept(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT,0,NULL)
#define SSL_CTX_sess_accept_renegotiate(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_RENEGOTIATE,0,NULL)
#define SSL_CTX_sess_accept_good(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_GOOD,0,NULL)
#define SSL_CTX_sess_hits(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_HIT,0,NULL)
#define SSL_CTX_sess_cb_hits(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CB_HIT,0,NULL)
#define SSL_CTX_sess_misses(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_MISSES,0,NULL)
#define SSL_CTX_sess_timeouts(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_TIMEOUTS,0,NULL)
#define SSL_CTX_sess_cache_full(ctx) \
    SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CACHE_FULL,0,NULL)

#define SSL_num_renegotiations(ssl) \
    SSL_ctrl((ssl),SSL_CTRL_GET_NUM_RENEGOTIATIONS,0,NULL)
#define SSL_clear_num_renegotiations(ssl) \
    SSL_ctrl((ssl),SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS,0,NULL)
#define SSL_total_renegotiations(ssl) \
    SSL_ctrl((ssl),SSL_CTRL_GET_TOTAL_RENEGOTIATIONS,0,NULL)

/* Is the SSL_connection established? */
#define SSL_get_state(a)         SSL_state(a)

#define SSL_CTX_set_verify(ctx,mode,cb) SSL_CTX_set_verify_cb((ctx), \
                                        (SSL_VERIFY_CB_T *)(cb)); \
                                        SSL_CTX_set_verify_mode((ctx), (mode))

#define SSL_set_verify(ssl,mode,cb) SSL_set_verify_cb((ssl), \
                                    (SSL_VERIFY_CB_T *)(cb)); \
                                    SSL_set_verify_mode((ssl),(mode))

typedef void  R_CDECL SSL_ALERT_INFO_CB_T(SSL *s, int where, int ret, char *arg);

void R_CDECL SSL_CTX_set_alert_info_cb(SSL_CTX *ctx, SSL_ALERT_INFO_CB_T *cb,
                               char *arg);
SSL_ALERT_INFO_CB_T * R_CDECL SSL_CTX_get_alert_info_cb(SSL_CTX *ctx);
char * R_CDECL SSL_CTX_get_alert_info_cb_arg(SSL_CTX *ctx);

SSL_ALERT_INFO_CB_T * R_CDECL SSL_get_alert_info_cb(SSL *ssl);
void R_CDECL SSL_set_alert_info_cb(SSL *ssl,SSL_ALERT_INFO_CB_T *cb, char *arg);
char * R_CDECL SSL_get_alert_info_cb_arg(SSL *ssl);
/* end group DIAGNOSTIC_CALLBACK_FUNCS */
typedef int  R_CDECL SSL_VERIFY_CB_T(int ok, SSLCERT_STORE_CTX *store_ctx);

void R_CDECL SSL_CTX_set_verify_cb(SSL_CTX *ctx, SSL_VERIFY_CB_T *cb);
SSL_VERIFY_CB_T * R_CDECL SSL_CTX_get_verify_cb(SSL_CTX *ctx);
void R_CDECL SSL_set_verify_cb(SSL *s, SSL_VERIFY_CB_T *cb);
SSL_VERIFY_CB_T * R_CDECL SSL_get_verify_cb(SSL *ssl);
int R_CDECL SSL_feature_set(long feature);
int R_CDECL SSL_feature_clear(long feature);
int R_CDECL SSL_feature_test(long feature);
int R_CDECL SSL_feature_reset(void);
void R_CDECL SSL_set_info_cb(SSL *ssl, SSL_INFO_CB_T *info_cb);
SSL_INFO_CB_T * R_CDECL SSL_get_info_cb(SSL *ssl);
SSL_METHOD * R_CDECL SSL_get_ssl_method(SSL *ssl);
void R_CDECL SSL_set_shutdown(SSL *ssl,int mode);
int R_CDECL SSL_get_shutdown(SSL *ssl);
#if defined(HEADER_COMMON_BIO_H) || defined(DOXYGEN)

BIO * R_CDECL SSL_get_rbio(SSL *ssl);
BIO * R_CDECL SSL_get_wbio(SSL *ssl);
#endif /* (HEADER_COMMON_BIO_H) || (DOXYGEN) */

int R_CDECL SSL_version(SSL *ssl);
SSL_SESSION * R_CDECL SSL_get_session(SSL *ssl);
SSL_CTX * R_CDECL SSL_get_SSL_CTX(SSL *ssl);
int R_CDECL SSL_state(SSL *ssl);
int R_CDECL SSL_reuse(SSL *ssl);
void R_CDECL SSL_set_verify_result(SSL *ssl, long verify);
long R_CDECL SSL_get_verify_result(SSL *ssl);
int R_CDECL SSL_get_verify_depth(SSL *ssl);
void R_CDECL SSL_set_verify_depth(SSL *ssl, int depth);
int R_CDECL SSL_get_verify_mode(SSL * ssl);
void R_CDECL SSL_set_verify_mode(SSL *ssl, int mode);
int R_CDECL SSL_want(SSL *ssl);
  unsigned char * R_CDECL SSL_get_client_random(SSL *ssl);
  unsigned char * R_CDECL SSL_get_server_random(SSL *ssl);

#define SSL_CTX_add_extra_chain_cert(ctx,x509) \
    SSL_CTX_ctrl((ctx), SSL_CTRL_EXTRA_CHAIN_CERT, 0, (char *)(x509))

STACK * R_CDECL SSL_CTX_get_extra_certs(SSL_CTX *ctx);
void R_CDECL SSL_CTX_set_extra_certs(SSL_CTX *ctx,STACK *certs);

int R_CDECL SSL_CTX_set_session_id_context(SSL_CTX *ctx,const unsigned char *sid_ctx,
                   unsigned int sid_ctx_len);
int R_CDECL SSL_set_session_id_context(SSL *ssl,const unsigned char *sid_ctx,
                   unsigned int sid_ctx_len);

#define SSL_copy_session_id(a,b)        SSL_copy_session((a),(b))
#define BIO_ssl_copy_session_id(a,b)    BIO_ssl_copy_session((a),(b))

#define SSL_session_reused(s)   SSL_reuse(s)

/* @brief macro to aid migration from SSLeay to SSL-C */
#define SSLeay_add_ssl_algorithms()    SSL_library_evp_setup()

/* More backward compatibility */

#define SSL_get_cipher(s) \
        SSL_CIPHER_get_name(SSL_get_current_cipher(s))
#define SSL_get_cipher_bits(s,np) \
        SSL_CIPHER_get_bits(SSL_get_current_cipher(s),np)
#define SSL_get_cipher_version(s) \
        SSL_CIPHER_get_version(SSL_get_current_cipher(s))
#define SSL_get_cipher_name(s) \
        SSL_CIPHER_get_name(SSL_get_current_cipher(s))

#define SSL_get_time(a,b)    SSL_SESSION_get_time(a,b)
#define SSL_set_time(a,b)    SSL_SESSION_set_time((a),(b))
#define SSL_get_timeout(a)   SSL_SESSION_get_timeout(a)
#define SSL_set_timeout(a,b) SSL_SESSION_set_timeout((a),(b))

/* The VMS linker has a 31 char name limit */
#define SSL_CTX_set_cert_verify_callback(a,b,c) \
        SSL_CTX_set_cert_verify_cb((a),(b),(c))

/* macros for old names */
#define SSL_get_verify_callback(s) SSL_get_verify_cb(s)
#define SSL_CTX_get_verify_callback(x) SSL_CTX_get_verify_cb(x)
#define SSL_set_info_callback(x,y) SSL_set_info_cb(x,y)
#define SSL_get_info_callback(x) SSL_get_info_cb(x)
#define SSL_CTX_set_info_callback(x,y) SSL_CTX_set_info_cb(x,y)
#define SSL_CTX_get_info_callback(x) SSL_CTX_get_info_cb(x)


#define SSL_set_app_data_callback(x,y,z) SSL_set_app_data_cb(x,y,z)
#define SSL_get_app_data_callback(x) SSL_get_app_data_cb(x)
#define SSL_get_app_data_callback_arg(x) SSL_get_app_data_cb_arg(x)
#define SSL_CTX_set_app_data_callback(x,y,z) SSL_CTX_set_app_data_cb(x,y,z)
#define SSL_CTX_set_application_data_callback(x,y,z) \
    SSL_CTX_set_app_data_cb(x,y,z)
#define SSL_CTX_get_app_data_callback(x) SSL_CTX_get_app_data_cb(x)
#define SSL_CTX_get_application_data_callback(x) SSL_CTX_get_app_data_cb(x)
#define SSL_CTX_get_app_data_callback_arg(x) SSL_CTX_get_app_data_cb_arg(x)
#define SSL_CTX_get_application_data_callback_arg(x) \
    SSL_CTX_get_app_data_cb_arg(x)

#define SSL_CTX_set_application_verify_cb SSL_CTX_set_app_verify_cb
#define SSL_CTX_get_application_verify_cb SSL_CTX_get_app_verify_cb
#define SSL_CTX_get_application_verify_cb_arg SSL_CTX_get_app_verify_cb_arg

#define SSL_CTX_get_default_read_ahead(ctx) SSL_CTX_get_read_ahead(ctx)
#define SSL_CTX_set_default_read_ahead(ctx,m) SSL_CTX_set_read_ahead(ctx,m)

typedef void  R_CDECL SSL_APP_DATA_CB_T(SSL *s, int where, char *arg);

void R_CDECL SSL_CTX_set_app_data_cb(SSL_CTX *ctx, SSL_APP_DATA_CB_T *cb, char *arg);
SSL_APP_DATA_CB_T * R_CDECL SSL_CTX_get_app_data_cb(SSL_CTX *ctx);
char * R_CDECL SSL_CTX_get_app_data_cb_arg(SSL_CTX *ctx);

void R_CDECL SSL_set_app_data_cb(SSL *ssl,SSL_APP_DATA_CB_T *cb, char *arg);
SSL_APP_DATA_CB_T * R_CDECL SSL_get_app_data_cb(SSL *ssl);
char * R_CDECL SSL_get_app_data_cb_arg(SSL *ssl);

/* end group DIAGNOSTIC_CALLBACK_FUNCS */
#define SSL_CTX_set_ocsi_server_cb(ctx,cb)      ((ctx)->ocsi_server_callback=(cb))
#define SSL_CTX_get_ocsi_server_cb(ctx)         ((ctx)->ocsi_server_callback)
#define SSL_CTX_set_ocsi_server_cb_arg(ctx,arg) ((ctx)->ocsi_server_callback_arg=(arg))
#define SSL_CTX_get_ocsi_server_cb_arg(ctx)      ((ctx)->ocsi_server_callback_arg)

#endif /* !SSLC_SMALL_CODE */

#if (!defined(SSLC_SMALL_CODE) && !defined(NO_EX_DATA))
/*
 * @defgroup SSL_EXTRA_DATA Extra Data
 * This section details the methods for loading and managing extra data used
 * by the #SSL, #SSL_CTX or #SSL_SESSION structures.
 *
 * @{
 */
/*
 * @}
 */

/* compatibility */
#define SSL_set_app_data(s,arg)        (SSL_set_ex_data(s,0,(char *)arg))
#define SSL_get_app_data(s)            (SSL_get_ex_data(s,0))
#define SSL_SESSION_set_app_data(s,a)  (SSL_SESSION_set_ex_data(s,0,(char *)a))
#define SSL_SESSION_get_app_data(s)    (SSL_SESSION_get_ex_data(s,0))
#define SSL_CTX_get_app_data(ctx)      (SSL_CTX_get_ex_data(ctx,0))
#define SSL_CTX_set_app_data(ctx,arg)  (SSL_CTX_set_ex_data(ctx,0,(char *)arg))


typedef int  R_CDECL SSL_EX_DATA_NEW_CB_T(char *obj, char *item,
    char *ad, int index, long argl, char *argp);

typedef void  R_CDECL SSL_EX_DATA_FREE_CB_T(char *obj, char *item,
    char *ad, int index, long argl, char *argp);

typedef int  R_CDECL SSL_EX_DATA_DUP_CB_T(char *obj_to, char *obj_from, char **item,
    int index, long argl, char *argp);
int R_CDECL SSL_set_ex_data(SSL *ssl, int idx, char *data);
char * R_CDECL SSL_get_ex_data(SSL *ssl, int idx);
int R_CDECL SSL_get_ex_new_index(long argl, char *argp, SSL_EX_DATA_NEW_CB_T *new_func,
    SSL_EX_DATA_DUP_CB_T *dup_func, SSL_EX_DATA_FREE_CB_T *free_func);
int R_CDECL SSL_get_ex_data_SSLCERT_STORE_CTX_idx(void);
/* Compatibility macro for old name */
#define SSL_get_ex_data_X509_STORE_CTX_idx SSL_get_ex_data_SSLCERT_STORE_CTX_idx

int R_CDECL SSL_SESSION_set_ex_data(SSL_SESSION *sess, int idx, char *data);
char * R_CDECL SSL_SESSION_get_ex_data(SSL_SESSION *sess, int idx);
int R_CDECL SSL_SESSION_get_ex_new_index(long argl, char *argp,
    SSL_EX_DATA_NEW_CB_T *new_func, SSL_EX_DATA_DUP_CB_T *dup_func,
    SSL_EX_DATA_FREE_CB_T *free_func);
int R_CDECL SSL_CTX_set_ex_data(SSL_CTX *ssl, int idx,char *data);
char * R_CDECL SSL_CTX_get_ex_data(SSL_CTX *ssl, int idx);
int R_CDECL SSL_CTX_get_ex_new_index(long argl, char *argp,
    SSL_EX_DATA_NEW_CB_T *new_func, SSL_EX_DATA_DUP_CB_T *dup_func,
    SSL_EX_DATA_FREE_CB_T *free_func);
#endif /* (!defined(SSLC_SMALL_CODE) && !defined(NO_EX_DATA)) */

#ifdef SSLC_SMALL_CODE

typedef int  R_CDECL SSL_SESSION_CACHE_CB_T(SSL_CTX *ctx, int cmd, SSL_SESSION **sess,
    void *arg);

int R_CDECL SSL_CTX_set_session_cache_cb(SSL_CTX *ctx, SSL_SESSION_CACHE_CB_T *cb);
SSL_SESSION_CACHE_CB_T * R_CDECL SSL_CTX_get_session_cache_cb(SSL_CTX *ctx);
int R_CDECL SSL_CTX_set_session_cache_cb_arg(SSL_CTX *ctx,void *cb_arg);
void * R_CDECL SSL_CTX_get_session_cache_cb_arg(SSL_CTX *ctx);
int R_CDECL SSL_CTX_simple_session_cb(SSL_CTX *ctx,int cmd,SSL_SESSION **sess_ptr,
    void *arg);
int R_CDECL SSL_CTX_simple_session_init(SSL_SIMPLE_SESSION_CACHE **cache_ptr);
int R_CDECL SSL_CTX_simple_session_final(SSL_SIMPLE_SESSION_CACHE **cache_ptr);

/* SSLC small code macro replacements - for use within library */
/* SSL feature tests */
extern int SSLC_ssl_features;
#ifdef SSLC

#else /* !SSLC */

#endif /* SSLC */
#define SSL_feature_set(feature)   ((SSLC_ssl_features|=feature),1)

#define SSL_feature_clear(feature) ((SSLC_ssl_features&=(~feature)),1)

#define SSL_feature_test(feature)  (SSLC_ssl_features&=feature)

#ifdef SSLC

#else /* !SSLC */

#endif /* SSLC */
#define SSL_feature_reset()  ((SSLC_ssl_features=0),1)

#define SSL_set_info_cb(ssl, cb) ((ssl)->info_cb = (cb))

#ifndef NO_EX_DATA

#else /* NO_EX_DATA */

 #endif /* !NO_EX_DATA */
#define SSL_get_info_cb(ssl) ((ssl)->info_cb)

#define SSL_get_verify_mode(ssl) ((ssl)->verify_mode)

#define SSL_set_verify_mode(ssl, mode) ((ssl)->verify_mode = (mode))

#define SSL_get_verify_depth(ssl) ((ssl)->verify_depth)

#define SSL_set_verify_depth(ssl, depth) ((ssl)->verify_depth = (depth))

#define SSL_set_verify_result(ssl, verify) ((ssl)->verify_result = (verify))

#define SSL_get_verify_result(ssl) ((ssl)->verify_result)

#define SSL_get_ssl_method(ssl) ((ssl)->method)

#define SSL_set_shutdown(ssl, mode) ((ssl)->shutdown = (mode))

#define SSL_get_shutdown(ssl) ((ssl)->shutdown)

#if defined(HEADER_COMMON_BIO_H) || defined(DOXYGEN)

BIO * R_CDECL SSL_get_rbio(SSL *ssl);
/* can't use macro because doing so will break the build of eut unittests required
 * by FIPS140 builds
 * #define SSL_get_rbio(ssl) ((ssl)->rbio)
 */

BIO * R_CDECL SSL_get_wbio(SSL *ssl);
/* can't use macro because doing so will break the build of eut unittests required
 * by FIPS140 builds
 * #define SSL_get_wbio(ssl) ((ssl)->wbio)
 */

/* end group SSL_IO_OPERATION_FUNCS */

#endif /* (HEADER_COMMON_BIO_H) || (DOXYGEN) */


int R_CDECL SSL_version(SSL *ssl);
/* can't use macro because doing so will break the build of eut unittests required
 * by FIPS140 builds
 *
 * #define SSL_version(ssl) ((ssl)->version)
 */
#define SSL_get_session(ssl) ((ssl)->session)

#define SSL_get_SSL_CTX(ssl) ((ssl)->ctx)

#define SSL_state(ssl) ((ssl)->state)

#define SSL_reuse(ssl) ((ssl)->hit)

#define SSL_want(ssl) ((ssl)->rwstate)

#endif /* SSLC_SMALL_CODE */

/* BEGIN ERROR CODES */
/* Error codes for the SSL functions. */

/* Function codes. */
#define SSL_F_CLIENT_CERTIFICATE                         100
#define SSL_F_CLIENT_HELLO                               101
#define SSL_F_CLIENT_MASTER_KEY                          102
#define SSL_F_D2I_SSL_SESSION                            103
#define SSL_F_DO_SSL3_WRITE                              104
#define SSL_F_GET_CLIENT_FINISHED                        105
#define SSL_F_GET_CLIENT_HELLO                           106
#define SSL_F_GET_CLIENT_MASTER_KEY                      107
#define SSL_F_GET_SERVER_FINISHED                        108
#define SSL_F_GET_SERVER_HELLO                           109
#define SSL_F_GET_SERVER_VERIFY                          110
#define SSL_F_I2D_SSL_SESSION                            111
#define SSL_F_READ_N                                     112
#define SSL_F_REQUEST_CERTIFICATE                        113
#define SSL_F_SERVER_HELLO                               114
#define SSL_F_SSL23_ACCEPT                               115
#define SSL_F_SSL23_CLIENT_HELLO                         116
#define SSL_F_SSL23_CONNECT                              117
#define SSL_F_SSL23_GET_CLIENT_HELLO                     118
#define SSL_F_SSL23_GET_SERVER_HELLO                     119
#define SSL_F_SSL23_READ                                 120
#define SSL_F_SSL23_WRITE                                121
#define SSL_F_SSL2_ACCEPT                                122
#define SSL_F_SSL2_ALLOC_READ_BUF                        218
#define SSL_F_SSL2_CONNECT                               123
#define SSL_F_SSL2_ENC_INIT                              124
#define SSL_F_SSL2_READ                                  125
#define SSL_F_SSL2_SETUP_BUFFERS                         219
#define SSL_F_SSL2_SET_CERTIFICATE                       126
#define SSL_F_SSL2_WRITE                                 127
#define SSL_F_SSL3_ACCEPT                                128
#define SSL_F_SSL3_CHANGE_CIPHER_STATE                   129
#define SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM              130
#define SSL_F_SSL3_CLIENT_HELLO                          131
#define SSL_F_SSL3_CONNECT                               132
#define SSL_F_SSL3_CTRL                                  226
#define SSL_F_SSL3_CTX_CTRL                              217
#define SSL_F_SSL3_ENC                                   134
#define SSL_F_SSL3_GET_CERTIFICATE_REQUEST               135
#define SSL_F_SSL3_GET_CERT_VERIFY                       136
#define SSL_F_SSL3_GET_CLIENT_CERTIFICATE                137
#define SSL_F_SSL3_GET_CLIENT_HELLO                      138
#define SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE               139
#define SSL_F_SSL3_GET_FINISHED                          140
#define SSL_F_SSL3_GET_KEY_EXCHANGE                      141
#define SSL_F_SSL3_GET_MESSAGE                           142
#define SSL_F_SSL3_GET_RECORD                            143
#define SSL_F_SSL3_GET_SERVER_CERTIFICATE                144
#define SSL_F_SSL3_GET_SERVER_DONE                       145
#define SSL_F_SSL3_GET_SERVER_HELLO                      146
#define SSL_F_SSL3_NEW                                   147
#define SSL_F_SSL3_OUTPUT_CERT_CHAIN                     148
#define SSL_F_SSL3_READ_BYTES                            149
#define SSL_F_SSL3_READ_N                                150
#define SSL_F_SSL3_SEND_CERTIFICATE_REQUEST              151
#define SSL_F_SSL3_SEND_CLIENT_CERTIFICATE               152
#define SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE              153
#define SSL_F_SSL3_SEND_CLIENT_VERIFY                    154
#define SSL_F_SSL3_SEND_SERVER_CERTIFICATE               155
#define SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE              156
#define SSL_F_SSL3_SETUP_BUFFERS                         157
#define SSL_F_SSL3_SETUP_KEY_BLOCK                       158
#define SSL_F_SSL3_WRITE_BYTES                           159
#define SSL_F_SSL3_WRITE_PENDING                         160
#define SSL_F_SSL_BAD_METHOD                             161
#define SSL_F_SSL_BYTES_TO_CIPHER_LIST                   162
#define SSL_F_SSL_CERT_NEW                               163
#define SSL_F_SSL_CHECK_PRIVATE_KEY                      164
#define SSL_F_SSL_CIPHER_DESCRIPTION                     216
#define SSL_F_SSL_CLEAR                                  165
#define SSL_F_SSL_CREATE_CIPHER_LIST                     166
#define SSL_F_SSL_CTX_ADD_CERTIFICATE_TO_STORE           234
#define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY                  167
#define SSL_F_SSL_CTX_LOAD_VERIFY_LOCATIONS              220
#define SSL_F_SSL_CTX_NEW                                168
#define SSL_F_SSL_CTX_SET_DEFAULT_VERIFY_PATHS           221
#define SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT             222
#define SSL_F_SSL_CTX_USE_CERTIFICATE                    171
#define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1               172
#define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE               173
#define SSL_F_SSL_CTX_USE_PRIVATEKEY                     174
#define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1                175
#define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE                176
#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY                  177
#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1             178
#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE             179
#define SSL_F_SSL_DH_NEW                                 227
#define SSL_F_SSL_DH_SET_METH_DATA                       231
#define SSL_F_SSL_DO_HANDSHAKE                           180
#define SSL_F_SSL_DSA_NEW                                228
#define SSL_F_SSL_DSA_SET_METH_DATA                      232
#define SSL_F_SSL_GET_NEW_SESSION                        181
#define SSL_F_SSL_GET_SERVER_SEND_CERT                   182
#define SSL_F_SSL_GET_SIGN_PKEY                          183
#define SSL_F_SSL_INIT_WBIO_BUFFER                       184
#define SSL_F_SSL_LOAD_CLIENT_CA_FILE                    185
#define SSL_F_SSL_NEW                                    186
#define SSL_F_SSL_NFAST_SETUP_PKEY                       225
#define SSL_F_SSL_RSA_NEW                                230
#define SSL_F_SSL_RSA_PRIVATE_DECRYPT                    187
#define SSL_F_SSL_RSA_PUBLIC_ENCRYPT                     188
#define SSL_F_SSL_RSA_SET_METH_DATA                      233
#define SSL_F_SSL_SESSION_NEW                            189
#define SSL_F_SSL_SESSION_PRINT_FP                       190
#define SSL_F_SSL_SET_CERT                               191
#define SSL_F_SSL_SET_FD                                 193
#define SSL_F_SSL_SET_PKEY                               194
#define SSL_F_SSL_SET_RFD                                195
#define SSL_F_SSL_SET_SESSION                            196
#define SSL_F_SSL_SET_SESSION_ID_CONTEXT                 224
#define SSL_F_SSL_SET_WFD                                197
#define SSL_F_SSL_UNDEFINED_FUNCTION                     198
#define SSL_F_SSL_USE_CERTIFICATE                        199
#define SSL_F_SSL_USE_CERTIFICATE_ASN1                   200
#define SSL_F_SSL_USE_CERTIFICATE_FILE                   201
#define SSL_F_SSL_USE_PRIVATEKEY                         202
#define SSL_F_SSL_USE_PRIVATEKEY_ASN1                    203
#define SSL_F_SSL_USE_PRIVATEKEY_FILE                    204
#define SSL_F_SSL_USE_RSAPRIVATEKEY                      205
#define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1                 206
#define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE                 207
#define SSL_F_SSL_VERIFY_CERT_CHAIN                      208
#define SSL_F_SSL_WRITE                                  209
#define SSL_F_TLS1_CHANGE_CIPHER_STATE                   210
#define SSL_F_TLS1_SETUP_KEY_BLOCK                       212
#define SSL_F_WRITE_PENDING                              213
#define SSL_F_SSL3_SEND_SERVER_HELLO                     214

/* Reason codes. */
#define SSL_R_APP_DATA_IN_HANDSHAKE                      100
#define SSL_R_BAD_ALERT_RECORD                           101
#define SSL_R_BAD_AUTHENTICATION_TYPE                    102
#define SSL_R_BAD_CHANGE_CIPHER_SPEC                     103
#define SSL_R_BAD_CHECKSUM                               104
#define SSL_R_BAD_CLIENT_REQUEST                         105
#define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK              106
#define SSL_R_BAD_DECOMPRESSION                          107
#define SSL_R_BAD_DH_G_LENGTH                            108
#define SSL_R_BAD_DH_PUB_KEY_LENGTH                      109
#define SSL_R_BAD_DH_P_LENGTH                            110
#define SSL_R_BAD_DIGEST_LENGTH                          111
#define SSL_R_BAD_DSA_SIGNATURE                          112
#define SSL_R_BAD_LENGTH                                 1103
#define SSL_R_BAD_MAC_DECODE                             113
#define SSL_R_BAD_MESSAGE_TYPE                           114
#define SSL_R_BAD_PACKET_LENGTH                          115
#define SSL_R_BAD_RESPONSE_ARGUMENT                      117
#define SSL_R_BAD_RSA_DECRYPT                            118
#define SSL_R_BAD_RSA_ENCRYPT                            119
#define SSL_R_BAD_RSA_E_LENGTH                           120
#define SSL_R_BAD_RSA_E_VALUE                            1200
#define SSL_R_BAD_RSA_MODULUS_LENGTH                     121
#define SSL_R_BAD_RSA_SIGNATURE                          122
#define SSL_R_BAD_SIGNATURE                              123
#define SSL_R_BAD_SSL_FILETYPE                           124
#define SSL_R_BAD_SSL_SESSION_ID_LENGTH                  125
#define SSL_R_BAD_STATE                                  126
#define SSL_R_BAD_WRITE_RETRY                            127
#define SSL_R_BIO_NOT_SET                                128
#define SSL_R_BLOCK_CIPHER_PAD_IS_WRONG                  129
#define SSL_R_CA_DN_LENGTH_MISMATCH                      131
#define SSL_R_CA_DN_TOO_LONG                             132
#define SSL_R_CCS_RECEIVED_EARLY                         133
#define SSL_R_CERTIFICATE_VERIFY_FAILED                  134
#define SSL_R_CERT_LENGTH_MISMATCH                       135
#define SSL_R_CHALLENGE_IS_DIFFERENT                     136
#define SSL_R_CIPHER_CODE_WRONG_LENGTH                   137
#define SSL_R_CIPHER_OR_HASH_UNAVAILABLE                 138
#define SSL_R_CIPHER_TABLE_SRC_ERROR                     139
#define SSL_R_COMPRESSED_LENGTH_TOO_LONG                 140
#define SSL_R_COMPRESSION_FAILURE                        141
#define SSL_R_COMPRESSION_LIBRARY_ERROR                  142
#define SSL_R_CONNECTION_ID_IS_DIFFERENT                 143
#define SSL_R_CONNECTION_TYPE_NOT_SET                    144
#define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED              145
#define SSL_R_DATA_LENGTH_TOO_LONG                       146
#define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG            148
#define SSL_R_DIGEST_CHECK_FAILED                        149
#define SSL_R_ENCRYPTED_LENGTH_TOO_LONG                  150
#define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST              151
#define SSL_R_EXCESSIVE_MESSAGE_SIZE                     152
#define SSL_R_EXTRA_DATA_IN_MESSAGE                      153
#define SSL_R_GOT_A_FIN_BEFORE_A_CCS                     154
#define SSL_R_HTTPS_PROXY_REQUEST                        155
#define SSL_R_HTTP_REQUEST                               156
#define SSL_R_INTERNAL_ERROR                             157
#define SSL_R_INVALID_CHALLENGE_LENGTH                   158
#define SSL_R_INVALID_CONNECTION_ID_LENGTH               1110
#define SSL_R_INVALID_KEY_ARG_LENGTH                     1111
#define SSL_R_INVALID_MASTER_KEY_LENGTH                  1112
#define SSL_R_LENGTH_MISMATCH                            159
#define SSL_R_LENGTH_TOO_SHORT                           160
#define SSL_R_LIBRARY_HAS_NO_CIPHERS                     161
#define SSL_R_MISSING_DH_DSA_CERT                        162
#define SSL_R_MISSING_DH_KEY                             163
#define SSL_R_MISSING_DH_RSA_CERT                        164
#define SSL_R_MISSING_DSA_SIGNING_CERT                   165
#define SSL_R_MISSING_EXPORT_TMP_DH_KEY                  166
#define SSL_R_MISSING_EXPORT_TMP_RSA_KEY                 167
#define SSL_R_MISSING_RSA_CERTIFICATE                    168
#define SSL_R_MISSING_RSA_ENCRYPTING_CERT                169
#define SSL_R_MISSING_RSA_SIGNING_CERT                   170
#define SSL_R_MISSING_TMP_DH_KEY                         171
#define SSL_R_MISSING_TMP_RSA_KEY                        172
#define SSL_R_MISSING_TMP_RSA_PKEY                       173
#define SSL_R_MISSING_VERIFY_MESSAGE                     174
#define SSL_R_NON_SSLV2_INITIAL_PACKET                   175
#define SSL_R_NO_CERTIFICATES_RETURNED                   176
#define SSL_R_NO_CERTIFICATE_ASSIGNED                    177
#define SSL_R_NO_CERTIFICATE_RETURNED                    178
#define SSL_R_NO_CERTIFICATE_SET                         179
#define SSL_R_NO_CERTIFICATE_SPECIFIED                   180
#define SSL_R_NO_CIPHERS_AVAILABLE                       181
#define SSL_R_NO_CIPHERS_LOADED                          1108
#define SSL_R_NO_CIPHERS_PASSED                          182
#define SSL_R_NO_CIPHERS_SPECIFIED                       183
#define SSL_R_NO_CIPHER_LIST                             184
#define SSL_R_NO_CIPHER_MATCH                            185
#define SSL_R_NO_CLIENT_CERT_RECEIVED                    186
#define SSL_R_NO_COMPRESSION_SPECIFIED                   187
#define SSL_R_NO_METHOD_SPECIFIED                        188
#define SSL_R_NO_PRIVATEKEY                              189
#define SSL_R_NO_PRIVATE_KEY_ASSIGNED                    190
#define SSL_R_NO_PROTOCOLS_AVAILABLE                     191
#define SSL_R_NO_PUBLICKEY                               192
#define SSL_R_NO_SHARED_CIPHER                           193
#define SSL_R_NO_SSL_MESSAGE_DIGEST                      1107
#define SSL_R_NO_VERIFY_CALLBACK                         194
#define SSL_R_NULL_SSL_CTX                               195
#define SSL_R_NULL_SSL_METHOD_PASSED                     196
#define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED            197
#define SSL_R_PACKET_LENGTH_TOO_LONG                     198
#define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE          199
#define SSL_R_PEER_ERROR                                 200
#define SSL_R_PEER_ERROR_CERTIFICATE                     201
#define SSL_R_PEER_ERROR_NO_CERTIFICATE                  202
#define SSL_R_PEER_ERROR_NO_CIPHER                       203
#define SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE    204
#define SSL_R_PRE_MAC_LENGTH_TOO_LONG                    205
#define SSL_R_PROBLEMS_MAPPING_CIPHER_FUNCTIONS          206
#define SSL_R_PROTOCOL_IS_SHUTDOWN                       207
#define SSL_R_PUBLIC_KEY_ENCRYPT_ERROR                   208
#define SSL_R_PUBLIC_KEY_IS_NOT_RSA                      209
#define SSL_R_PUBLIC_KEY_NOT_RSA                         210
#define SSL_R_READ_BIO_NOT_SET                           211
#define SSL_R_READ_WRONG_PACKET_TYPE                     212
#define SSL_R_RECORD_LENGTH_MISMATCH                     213
#define SSL_R_RECORD_TOO_LARGE                           214
#define SSL_R_REQUIRED_CIPHER_MISSING                    215
#define SSL_R_REUSE_CERT_LENGTH_NOT_ZERO                 216
#define SSL_R_REUSE_CERT_TYPE_NOT_ZERO                   217
#define SSL_R_REUSE_CIPHER_LIST_NOT_ZERO                 218
#define SSL_R_R_RAND_FAILURE                             1116
#define SSL_R_SHORT_READ                                 219
#define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE      220
#define SSL_R_SSL23_DOING_SESSION_ID_REUSE               221
#define SSL_R_SSL3_SESSION_ID_TOO_LONG                   1105
#define SSL_R_SSL3_SESSION_ID_TOO_SHORT                  222
#define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE                1042
#define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC                 1020
#define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED            1045
#define SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED            1044
#define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN            1046
#define SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE          1030
#define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE              1040
#define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER              1047
#define SSL_R_SSLV3_ALERT_NO_CERTIFICATE                 1041
#define SSL_R_SSLV3_ALERT_PEER_ERROR_CERTIFICATE         223
#define SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CERTIFICATE      224
#define SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CIPHER           225
#define SSL_R_SSLV3_ALERT_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE 226
#define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE             1010
#define SSL_R_SSLV3_ALERT_UNKNOWN_REMOTE_ERROR_TYPE      227
#define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE        1043
#define SSL_R_SSL_CERT_IS_DEFAULT                        1109
#define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION         228
#define SSL_R_SSL_HANDSHAKE_FAILURE                      229
#define SSL_R_SSL_MODE_NOT_SET                           1101
#define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG            1106
#define SSL_R_SSL_SESSION_ID_IS_DIFFERENT                231
#define SSL_R_TLSV1_ALERT_ACCESS_DENIED                  1049
#define SSL_R_TLSV1_ALERT_DECODE_ERROR                   1050
#define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED              1021
#define SSL_R_TLSV1_ALERT_DECRYPT_ERROR                  1051
#define SSL_R_TLSV1_ALERT_EXPORT_RESTRICION              1060
#define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY          1071
#define SSL_R_TLSV1_ALERT_INTERNAL_ERROR                 1080
#define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION               1100
#define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION               1070
#define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW                1022
#define SSL_R_TLSV1_ALERT_UNKNOWN_CA                     1048
#define SSL_R_TLSV1_ALERT_USER_CANCLED                   1090
#define SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER       232
#define SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST 233
#define SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG    234
#define SSL_R_TRIED_TO_USE_UNSUPPORTED_CIPHER            235
#define SSL_R_UNABLE_TO_DECODE_DH_CERTS                  236
#define SSL_R_UNABLE_TO_EXTRACT_PUBLIC_KEY               237
#define SSL_R_UNABLE_TO_FIND_DH_PARAMETERS               238
#define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS       239
#define SSL_R_UNABLE_TO_FIND_SSL_METHOD                  240
#define SSL_R_UNABLE_TO_LOAD_DSA_SHA1_ROUTINES           1102
#define SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES           241
#define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES           242
#define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES          243
#define SSL_R_UNEXPECTED_MESSAGE                         244
#define SSL_R_UNEXPECTED_RECORD                          245
#define SSL_R_UNKNOWN_ALERT_TYPE                         246
#define SSL_R_UNKNOWN_CERTIFICATE_TYPE                   247
#define SSL_R_UNKNOWN_CIPHER_RETURNED                    248
#define SSL_R_UNKNOWN_CIPHER_TYPE                        249
#define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE                  250
#define SSL_R_UNKNOWN_PKEY_TYPE                          251
#define SSL_R_UNKNOWN_PROTOCOL                           252
#define SSL_R_UNKNOWN_REMOTE_ERROR_TYPE                  253
#define SSL_R_UNKNOWN_SSL_VERSION                        254
#define SSL_R_UNKNOWN_STATE                              255
#define SSL_R_UNSUPPORTED_CIPHER                         256
#define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM          257
#define SSL_R_UNSUPPORTED_PROTOCOL                       258
#define SSL_R_UNSUPPORTED_SSL_VERSION                    259
#define SSL_R_WRITE_BIO_NOT_SET                          260
#define SSL_R_WRONG_CIPHER_RETURNED                      261
#define SSL_R_WRONG_MESSAGE_TYPE                         262
#define SSL_R_WRONG_SIGNATURE_LENGTH                     264
#define SSL_R_WRONG_SIGNATURE_SIZE                       265
#define SSL_R_WRONG_SSL_VERSION                          266
#define SSL_R_WRONG_VERSION_NUMBER                       267
#define SSL_R_X509_LIB                                   268
#define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS           269
#define SSL_R_INVALID_PUBLIC_KEY_FIELD_SIZE              270
#define SSL_R_INVALID_BUFFER_SIZE                        1117
#define SSL_R_HARDWARE_FAILURE                           1118
#define SSL_R_ERROR_PARSING_FILE_PARAM                   1119
#define SSL_R_DUPLICATE_FIELDS_IN_FILE_PARAM             1120

#ifdef  __cplusplus
}
#endif
#endif

---

Copyright (c) 1999-2005 RSA Security Inc. All rights reserved. 072-001001-2100-001-000 - 2.1