LCOM1920-T02G10

/* ssl/ssl.h */

/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

 * All rights reserved.

 *

 * This package is an SSL implementation written

 * by Eric Young (eay@cryptsoft.com).

 * The implementation was written so as to conform with Netscapes SSL.

 *

 * This library is free for commercial and non-commercial use as long as

 * the following conditions are aheared to.  The following conditions

 * apply to all code found in this distribution, be it the RC4, RSA,

 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

 * included with this distribution is covered by the same copyright terms

 * except that the holder is Tim Hudson (tjh@cryptsoft.com).

 *

 * Copyright remains Eric Young's, and as such any Copyright notices in

 * the code are not to be removed.

 * If this package is used in a product, Eric Young should be given attribution

 * as the author of the parts of the library used.

 * This can be in the form of a textual message at program startup or

 * in documentation (online or textual) provided with the package.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *    "This product includes cryptographic software written by

 *     Eric Young (eay@cryptsoft.com)"

 *    The word 'cryptographic' can be left out if the rouines from the library

 *    being used are not cryptographic related :-).

 * 4. If you include any Windows specific code (or a derivative thereof) from

 *    the apps directory (application code) you must include an acknowledgement:

 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

 *

 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 * The licence and distribution terms for any publically available version or

 * derivative of this code cannot be changed.  i.e. this code cannot simply be

 * copied and put under another distribution licence

 * [including the GNU Public Licence.]

 */

/* ====================================================================

 * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in

 *    the documentation and/or other materials provided with the

 *    distribution.

 *

 * 3. All advertising materials mentioning features or use of this

 *    software must display the following acknowledgment:

 *    "This product includes software developed by the OpenSSL Project

 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"

 *

 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to

 *    endorse or promote products derived from this software without

 *    prior written permission. For written permission, please contact

 *    openssl-core@openssl.org.

 *

 * 5. Products derived from this software may not be called "OpenSSL"

 *    nor may "OpenSSL" appear in their names without prior written

 *    permission of the OpenSSL Project.

 *

 * 6. Redistributions of any form whatsoever must retain the following

 *    acknowledgment:

 *    "This product includes software developed by the OpenSSL Project

 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"

 *

 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY

 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR

 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

 * OF THE POSSIBILITY OF SUCH DAMAGE.

 * ====================================================================

 *

 * This product includes cryptographic software written by Eric Young

 * (eay@cryptsoft.com).  This product includes software written by Tim

 * Hudson (tjh@cryptsoft.com).

 *

 */

/* ====================================================================

 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.

 * ECC cipher suite support in OpenSSL originally developed by

 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.

 */

/* ====================================================================

 * Copyright 2005 Nokia. All rights reserved.

 *

 * The portions of the attached software ("Contribution") is developed by

 * Nokia Corporation and is licensed pursuant to the OpenSSL open source

 * license.

 *

 * The Contribution, originally written by Mika Kousa and Pasi Eronen of

 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites

 * support (see RFC 4279) to OpenSSL.

 *

 * No patent licenses or other rights except those expressly stated in

 * the OpenSSL open source license shall be deemed granted or received

 * expressly, by implication, estoppel, or otherwise.

 *

 * No assurances are provided by Nokia that the Contribution does not

 * infringe the patent or other intellectual property rights of any third

 * party or that the license provides you with all the necessary rights

 * to make use of the Contribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN

 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA

 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY

 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR

 * OTHERWISE.

 */

#ifndef HEADER_SSL_H

# define HEADER_SSL_H

# include <openssl/e_os2.h>

# ifndef OPENSSL_NO_COMP

#  include <openssl/comp.h>

# endif

# ifndef OPENSSL_NO_BIO

#  include <openssl/bio.h>

# endif

# ifndef OPENSSL_NO_DEPRECATED

#  ifndef OPENSSL_NO_X509

#   include <openssl/x509.h>

#  endif

#  include <openssl/crypto.h>

#  include <openssl/lhash.h>

#  include <openssl/buffer.h>

# endif

# include <openssl/pem.h>

# include <openssl/hmac.h>

# include <openssl/kssl.h>

# include <openssl/safestack.h>

# include <openssl/symhacks.h>

#ifdef  __cplusplus

extern "C" {

#endif

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

/*-

 * Version 0 - initial version

 * Version 1 - added the optional peer certificate

 */

# define SSL_SESSION_ASN1_VERSION 0x0001

/* 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

/*

 * VRS Additional Kerberos5 entries

 */

# define SSL_TXT_KRB5_DES_64_CBC_SHA   SSL3_TXT_KRB5_DES_64_CBC_SHA

# define SSL_TXT_KRB5_DES_192_CBC3_SHA SSL3_TXT_KRB5_DES_192_CBC3_SHA

# define SSL_TXT_KRB5_RC4_128_SHA      SSL3_TXT_KRB5_RC4_128_SHA

# define SSL_TXT_KRB5_IDEA_128_CBC_SHA SSL3_TXT_KRB5_IDEA_128_CBC_SHA

# define SSL_TXT_KRB5_DES_64_CBC_MD5   SSL3_TXT_KRB5_DES_64_CBC_MD5

# define SSL_TXT_KRB5_DES_192_CBC3_MD5 SSL3_TXT_KRB5_DES_192_CBC3_MD5

# define SSL_TXT_KRB5_RC4_128_MD5      SSL3_TXT_KRB5_RC4_128_MD5

# define SSL_TXT_KRB5_IDEA_128_CBC_MD5 SSL3_TXT_KRB5_IDEA_128_CBC_MD5

# define SSL_TXT_KRB5_DES_40_CBC_SHA   SSL3_TXT_KRB5_DES_40_CBC_SHA

# define SSL_TXT_KRB5_RC2_40_CBC_SHA   SSL3_TXT_KRB5_RC2_40_CBC_SHA

# define SSL_TXT_KRB5_RC4_40_SHA       SSL3_TXT_KRB5_RC4_40_SHA

# define SSL_TXT_KRB5_DES_40_CBC_MD5   SSL3_TXT_KRB5_DES_40_CBC_MD5

# define SSL_TXT_KRB5_RC2_40_CBC_MD5   SSL3_TXT_KRB5_RC2_40_CBC_MD5

# define SSL_TXT_KRB5_RC4_40_MD5       SSL3_TXT_KRB5_RC4_40_MD5

# define SSL_TXT_KRB5_DES_40_CBC_SHA   SSL3_TXT_KRB5_DES_40_CBC_SHA

# define SSL_TXT_KRB5_DES_40_CBC_MD5   SSL3_TXT_KRB5_DES_40_CBC_MD5

# define SSL_TXT_KRB5_DES_64_CBC_SHA   SSL3_TXT_KRB5_DES_64_CBC_SHA

# define SSL_TXT_KRB5_DES_64_CBC_MD5   SSL3_TXT_KRB5_DES_64_CBC_MD5

# define SSL_TXT_KRB5_DES_192_CBC3_SHA SSL3_TXT_KRB5_DES_192_CBC3_SHA

# define SSL_TXT_KRB5_DES_192_CBC3_MD5 SSL3_TXT_KRB5_DES_192_CBC3_MD5

# define SSL_MAX_KRB5_PRINCIPAL_LENGTH  256

# 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

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

# define SSL_TXT_EXP40           "EXPORT40"

# define SSL_TXT_EXP56           "EXPORT56"

# define SSL_TXT_LOW             "LOW"

# define SSL_TXT_MEDIUM          "MEDIUM"

# define SSL_TXT_HIGH            "HIGH"

# define SSL_TXT_FIPS            "FIPS"

# define SSL_TXT_kFZA            "kFZA"/* unused! */

# define SSL_TXT_aFZA            "aFZA"/* unused! */

# define SSL_TXT_eFZA            "eFZA"/* unused! */

# define SSL_TXT_FZA             "FZA"/* unused! */

# define SSL_TXT_aNULL           "aNULL"

# define SSL_TXT_eNULL           "eNULL"

# define SSL_TXT_NULL            "NULL"

# define SSL_TXT_kRSA            "kRSA"

# define SSL_TXT_kDHr            "kDHr"/* no such ciphersuites supported! */

# define SSL_TXT_kDHd            "kDHd"/* no such ciphersuites supported! */

# define SSL_TXT_kDH             "kDH"/* no such ciphersuites supported! */

# define SSL_TXT_kEDH            "kEDH"

# define SSL_TXT_kKRB5           "kKRB5"

# define SSL_TXT_kECDHr          "kECDHr"

# define SSL_TXT_kECDHe          "kECDHe"

# define SSL_TXT_kECDH           "kECDH"

# define SSL_TXT_kEECDH          "kEECDH"

# define SSL_TXT_kPSK            "kPSK"

# define SSL_TXT_kGOST           "kGOST"

# define SSL_TXT_kSRP            "kSRP"

# define SSL_TXT_aRSA            "aRSA"

# define SSL_TXT_aDSS            "aDSS"

# define SSL_TXT_aDH             "aDH"/* no such ciphersuites supported! */

# define SSL_TXT_aECDH           "aECDH"

# define SSL_TXT_aKRB5           "aKRB5"

# define SSL_TXT_aECDSA          "aECDSA"

# define SSL_TXT_aPSK            "aPSK"

# define SSL_TXT_aGOST94 "aGOST94"

# define SSL_TXT_aGOST01 "aGOST01"

# define SSL_TXT_aGOST  "aGOST"

# define SSL_TXT_aSRP            "aSRP"

# define SSL_TXT_DSS             "DSS"

# define SSL_TXT_DH              "DH"

# define SSL_TXT_EDH             "EDH"/* same as "kEDH:-ADH" */

# define SSL_TXT_ADH             "ADH"

# define SSL_TXT_RSA             "RSA"

# define SSL_TXT_ECDH            "ECDH"

# define SSL_TXT_EECDH           "EECDH"/* same as "kEECDH:-AECDH" */

# define SSL_TXT_AECDH           "AECDH"

# define SSL_TXT_ECDSA           "ECDSA"

# define SSL_TXT_KRB5            "KRB5"

# define SSL_TXT_PSK             "PSK"

# define SSL_TXT_SRP             "SRP"

# define SSL_TXT_DES             "DES"

# define SSL_TXT_3DES            "3DES"

# define SSL_TXT_RC4             "RC4"

# define SSL_TXT_RC2             "RC2"

# define SSL_TXT_IDEA            "IDEA"

# define SSL_TXT_SEED            "SEED"

# define SSL_TXT_AES128          "AES128"

# define SSL_TXT_AES256          "AES256"

# define SSL_TXT_AES             "AES"

# define SSL_TXT_AES_GCM         "AESGCM"

# define SSL_TXT_CAMELLIA128     "CAMELLIA128"

# define SSL_TXT_CAMELLIA256     "CAMELLIA256"

# define SSL_TXT_CAMELLIA        "CAMELLIA"

# define SSL_TXT_MD5             "MD5"

# define SSL_TXT_SHA1            "SHA1"

# define SSL_TXT_SHA             "SHA"/* same as "SHA1" */

# define SSL_TXT_GOST94          "GOST94"

# define SSL_TXT_GOST89MAC               "GOST89MAC"

# define SSL_TXT_SHA256          "SHA256"

# define SSL_TXT_SHA384          "SHA384"

# define SSL_TXT_SSLV2           "SSLv2"

# define SSL_TXT_SSLV3           "SSLv3"

# define SSL_TXT_TLSV1           "TLSv1"

# define SSL_TXT_TLSV1_1         "TLSv1.1"

# define SSL_TXT_TLSV1_2         "TLSv1.2"

# define SSL_TXT_EXP             "EXP"

# define SSL_TXT_EXPORT          "EXPORT"

# define SSL_TXT_ALL             "ALL"

/*-

 * COMPLEMENTOF* definitions. These identifiers are used to (de-select)

 * ciphers normally not being used.

 * Example: "RC4" will activate all ciphers using RC4 including ciphers

 * without authentication, which would normally disabled by DEFAULT (due

 * the "!ADH" being part of default). Therefore "RC4:!COMPLEMENTOFDEFAULT"

 * will make sure that it is also disabled in the specific selection.

 * COMPLEMENTOF* identifiers are portable between version, as adjustments

 * to the default cipher setup will also be included here.

 *

 * COMPLEMENTOFDEFAULT does not experience the same special treatment that

 * DEFAULT gets, as only selection is being done and no sorting as needed

 * for DEFAULT.

 */

# define SSL_TXT_CMPALL          "COMPLEMENTOFALL"

# define SSL_TXT_CMPDEF          "COMPLEMENTOFDEFAULT"

/*

 * The following cipher list is used by default. It also is substituted when

 * an application-defined cipher list string starts with 'DEFAULT'.

 */

# define SSL_DEFAULT_CIPHER_LIST "ALL:!EXPORT:!aNULL:!eNULL:!SSLv2"

/*

 * As of OpenSSL 1.0.0, ssl_create_cipher_list() in ssl/ssl_ciph.c always

 * starts with a reasonable order, and all we have to do for DEFAULT is

 * throwing out anonymous and unencrypted ciphersuites! (The latter are not

 * actually enabled by ALL, but "ALL:RSA" would enable some of them.)

 */

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

# define SSL_SENT_SHUTDOWN       1

# define SSL_RECEIVED_SHUTDOWN   2

#ifdef __cplusplus

}

#endif

#ifdef  __cplusplus

extern "C" {

#endif

# if (defined(OPENSSL_NO_RSA) || defined(OPENSSL_NO_MD5)) && !defined(OPENSSL_NO_SSL2)

#  define OPENSSL_NO_SSL2

# endif

# define SSL_FILETYPE_ASN1       X509_FILETYPE_ASN1

# define SSL_FILETYPE_PEM        X509_FILETYPE_PEM

/*

 * This is needed to stop compilers complaining about the 'struct ssl_st *'

 * function parameters used to prototype callbacks in SSL_CTX.

 */

typedef struct ssl_st *ssl_crock_st;

typedef struct tls_session_ticket_ext_st TLS_SESSION_TICKET_EXT;

typedef struct ssl_method_st SSL_METHOD;

typedef struct ssl_cipher_st SSL_CIPHER;

typedef struct ssl_session_st SSL_SESSION;

DECLARE_STACK_OF(SSL_CIPHER)

/* SRTP protection profiles for use with the use_srtp extension (RFC 5764)*/

typedef struct srtp_protection_profile_st {

    const char *name;

    unsigned long id;

} SRTP_PROTECTION_PROFILE;

DECLARE_STACK_OF(SRTP_PROTECTION_PROFILE)

typedef int (*tls_session_ticket_ext_cb_fn) (SSL *s,

                                             const unsigned char *data,

                                             int len, void *arg);

typedef int (*tls_session_secret_cb_fn) (SSL *s, void *secret,

                                         int *secret_len,

                                         STACK_OF(SSL_CIPHER) *peer_ciphers,

                                         SSL_CIPHER **cipher, void *arg);

# ifndef OPENSSL_NO_SSL_INTERN

/* used to hold info on the particular ciphers used */

struct ssl_cipher_st {

    int valid;

    const char *name;           /* text name */

    unsigned long id;           /* id, 4 bytes, first is version */

    /*

     * changed in 0.9.9: these four used to be portions of a single value

     * 'algorithms'

     */

    unsigned long algorithm_mkey; /* key exchange algorithm */

    unsigned long algorithm_auth; /* server authentication */

    unsigned long algorithm_enc; /* symmetric encryption */

    unsigned long algorithm_mac; /* symmetric authentication */

    unsigned long algorithm_ssl; /* (major) protocol version */

    unsigned long algo_strength; /* strength and export flags */

    unsigned long algorithm2;   /* Extra flags */

    int strength_bits;          /* Number of bits really used */

    int alg_bits;               /* Number of bits for algorithm */

};

/* Used to hold functions for SSLv2 or SSLv3/TLSv1 functions */

struct ssl_method_st {

    int version;

    int (*ssl_new) (SSL *s);

    void (*ssl_clear) (SSL *s);

    void (*ssl_free) (SSL *s);

    int (*ssl_accept) (SSL *s);

    int (*ssl_connect) (SSL *s);

    int (*ssl_read) (SSL *s, void *buf, int len);

    int (*ssl_peek) (SSL *s, void *buf, int len);

    int (*ssl_write) (SSL *s, const void *buf, int len);

    int (*ssl_shutdown) (SSL *s);

    int (*ssl_renegotiate) (SSL *s);

    int (*ssl_renegotiate_check) (SSL *s);

    long (*ssl_get_message) (SSL *s, int st1, int stn, int mt, long

                             max, int *ok);

    int (*ssl_read_bytes) (SSL *s, int type, unsigned char *buf, int len,

                           int peek);

    int (*ssl_write_bytes) (SSL *s, int type, const void *buf_, int len);

    int (*ssl_dispatch_alert) (SSL *s);

    long (*ssl_ctrl) (SSL *s, int cmd, long larg, void *parg);

    long (*ssl_ctx_ctrl) (SSL_CTX *ctx, int cmd, long larg, void *parg);

    const SSL_CIPHER *(*get_cipher_by_char) (const unsigned char *ptr);

    int (*put_cipher_by_char) (const SSL_CIPHER *cipher, unsigned char *ptr);

    int (*ssl_pending) (const SSL *s);

    int (*num_ciphers) (void);

    const SSL_CIPHER *(*get_cipher) (unsigned ncipher);

    const struct ssl_method_st *(*get_ssl_method) (int version);

    long (*get_timeout) (void);

    struct ssl3_enc_method *ssl3_enc; /* Extra SSLv3/TLS stuff */

    int (*ssl_version) (void);

    long (*ssl_callback_ctrl) (SSL *s, int cb_id, void (*fp) (void));

    long (*ssl_ctx_callback_ctrl) (SSL_CTX *s, int cb_id, void (*fp) (void));

};

/*-

 * Lets make this into an ASN.1 type structure as follows

 * SSL_SESSION_ID ::= SEQUENCE {

 *      version                 INTEGER,        -- structure version number

 *      SSLversion              INTEGER,        -- SSL version number

 *      Cipher                  OCTET STRING,   -- the 3 byte cipher ID

 *      Session_ID              OCTET STRING,   -- the Session ID

 *      Master_key              OCTET STRING,   -- the master key

 *      KRB5_principal          OCTET STRING    -- optional Kerberos principal

 *      Key_Arg [ 0 ] IMPLICIT  OCTET STRING,   -- the optional Key argument

 *      Time [ 1 ] EXPLICIT     INTEGER,        -- optional Start Time

 *      Timeout [ 2 ] EXPLICIT  INTEGER,        -- optional Timeout ins seconds

 *      Peer [ 3 ] EXPLICIT     X509,           -- optional Peer Certificate

 *      Session_ID_context [ 4 ] EXPLICIT OCTET STRING,   -- the Session ID context

 *      Verify_result [ 5 ] EXPLICIT INTEGER,   -- X509_V_... code for `Peer'

 *      HostName [ 6 ] EXPLICIT OCTET STRING,   -- optional HostName from servername TLS extension

 *      PSK_identity_hint [ 7 ] EXPLICIT OCTET STRING, -- optional PSK identity hint

 *      PSK_identity [ 8 ] EXPLICIT OCTET STRING,  -- optional PSK identity

 *      Ticket_lifetime_hint [9] EXPLICIT INTEGER, -- server's lifetime hint for session ticket

 *      Ticket [10]             EXPLICIT OCTET STRING, -- session ticket (clients only)

 *      Compression_meth [11]   EXPLICIT OCTET STRING, -- optional compression method

 *      SRP_username [ 12 ] EXPLICIT OCTET STRING -- optional SRP username

 *      }

 * Look in ssl/ssl_asn1.c for more details

 * I'm using EXPLICIT tags so I can read the damn things using asn1parse :-).

 */

struct ssl_session_st {

    int ssl_version;            /* what ssl version session info is being

                                 * kept in here? */

    /* only really used in SSLv2 */

    unsigned int key_arg_length;

    unsigned char key_arg[SSL_MAX_KEY_ARG_LENGTH];

    int master_key_length;

    unsigned char master_key[SSL_MAX_MASTER_KEY_LENGTH];

    /* session_id - valid? */

    unsigned int session_id_length;

    unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH];

    /*

     * this is used to determine whether the session is being reused in the

     * appropriate context. It is up to the application to set this, via

     * SSL_new

     */

    unsigned int sid_ctx_length;

    unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];

#  ifndef OPENSSL_NO_KRB5

    unsigned int krb5_client_princ_len;

    unsigned char krb5_client_princ[SSL_MAX_KRB5_PRINCIPAL_LENGTH];

#  endif                        /* OPENSSL_NO_KRB5 */

#  ifndef OPENSSL_NO_PSK

    char *psk_identity_hint;

    char *psk_identity;

#  endif

    /*

     * Used to indicate that session resumption is not allowed. Applications

     * can also set this bit for a new session via not_resumable_session_cb

     * to disable session caching and tickets.

     */

    int not_resumable;

    /* The cert is the certificate used to establish this connection */

    struct sess_cert_st /* SESS_CERT */ *sess_cert;

    /*

     * This is the cert for the other end. On clients, it will be the same as

     * sess_cert->peer_key->x509 (the latter is not enough as sess_cert is

     * not retained in the external representation of sessions, see

     * ssl_asn1.c).

     */

    X509 *peer;

    /*

     * when app_verify_callback accepts a session where the peer's

     * certificate is not ok, we must remember the error for session reuse:

     */

    long verify_result;         /* only for servers */

    int references;

    long timeout;

    long time;

    unsigned int compress_meth; /* Need to lookup the method */

    const SSL_CIPHER *cipher;

    unsigned long cipher_id;    /* when ASN.1 loaded, this needs to be used

                                 * to load the 'cipher' structure */

    STACK_OF(SSL_CIPHER) *ciphers; /* shared ciphers? */

    CRYPTO_EX_DATA ex_data;     /* application specific data */

    /*

     * These are used to make removal of session-ids more efficient and to

     * implement a maximum cache size.

     */

    struct ssl_session_st *prev, *next;

#  ifndef OPENSSL_NO_TLSEXT

    char *tlsext_hostname;

#   ifndef OPENSSL_NO_EC

    size_t tlsext_ecpointformatlist_length;

    unsigned char *tlsext_ecpointformatlist; /* peer's list */

    size_t tlsext_ellipticcurvelist_length;

    unsigned char *tlsext_ellipticcurvelist; /* peer's list */

#   endif                       /* OPENSSL_NO_EC */

    /* RFC4507 info */

    unsigned char *tlsext_tick; /* Session ticket */

    size_t tlsext_ticklen;      /* Session ticket length */

    long tlsext_tick_lifetime_hint; /* Session lifetime hint in seconds */

#  endif

#  ifndef OPENSSL_NO_SRP

    char *srp_username;

#  endif

};

# endif

# define SSL_OP_MICROSOFT_SESS_ID_BUG                    0x00000001L

# define SSL_OP_NETSCAPE_CHALLENGE_BUG                   0x00000002L

/* Allow initial connection to servers that don't support RI */

# define SSL_OP_LEGACY_SERVER_CONNECT                    0x00000004L

# define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG         0x00000008L

# define SSL_OP_TLSEXT_PADDING                           0x00000010L

# define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER               0x00000020L

# define SSL_OP_SAFARI_ECDHE_ECDSA_BUG                   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

/* Hasn't done anything since OpenSSL 0.9.7h, retained for compatibility */

# define SSL_OP_MSIE_SSLV2_RSA_PADDING                   0x0

/* Refers to ancient SSLREF and SSLv2, retained for compatibility */

# define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG              0x0

/*

 * Disable SSL 3.0/TLS 1.0 CBC vulnerability workaround that was added in

 * OpenSSL 0.9.6d.  Usually (depending on the application protocol) the

 * workaround is not needed.  Unfortunately some broken SSL/TLS

 * implementations cannot handle it at all, which is why we include it in

 * SSL_OP_ALL.

 */

/* added in 0.9.6e */

# define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS              0x00000800L

/*

 * SSL_OP_ALL: various bug workarounds that should be rather harmless.  This

 * used to be 0x000FFFFFL before 0.9.7.

 */

# define SSL_OP_ALL                                      0x80000BFFL

/* DTLS options */

# define SSL_OP_NO_QUERY_MTU                 0x00001000L

/* Turn on Cookie Exchange (on relevant for servers) */

# define SSL_OP_COOKIE_EXCHANGE              0x00002000L

/* Don't use RFC4507 ticket extension */

# define SSL_OP_NO_TICKET                    0x00004000L

/* Use Cisco's "speshul" version of DTLS_BAD_VER (as client)  */

# define SSL_OP_CISCO_ANYCONNECT             0x00008000L

/* As server, disallow session resumption on renegotiation */

# define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION   0x00010000L

/* Don't use compression even if supported */

# define SSL_OP_NO_COMPRESSION                           0x00020000L

/* Permit unsafe legacy renegotiation */

# define SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION        0x00040000L

/* If set, always create a new key when using tmp_ecdh parameters */

# define SSL_OP_SINGLE_ECDH_USE                          0x00080000L

/* If set, always create a new key when using tmp_dh parameters */

# define SSL_OP_SINGLE_DH_USE                            0x00100000L

/* Does nothing: retained for compatibiity */

# define SSL_OP_EPHEMERAL_RSA                            0x0

/*

 * Set on servers to choose the cipher according to the server's preferences

 */

# define SSL_OP_CIPHER_SERVER_PREFERENCE                 0x00400000L

/*

 * If set, a server will allow a client to issue a SSLv3.0 version number as

 * latest version supported in the premaster secret, even when TLSv1.0

 * (version 3.1) was announced in the client hello. Normally this is

 * forbidden to prevent version rollback attacks.

 */

# define SSL_OP_TLS_ROLLBACK_BUG                         0x00800000L

# define SSL_OP_NO_SSLv2                                 0x01000000L

# define SSL_OP_NO_SSLv3                                 0x02000000L

# define SSL_OP_NO_TLSv1                                 0x04000000L

# define SSL_OP_NO_TLSv1_2                               0x08000000L

# define SSL_OP_NO_TLSv1_1                               0x10000000L

/*

 * These next two were never actually used for anything since SSLeay zap so

 * we have some more flags.

 */

/*

 * The next flag deliberately changes the ciphertest, this is a check for the

 * PKCS#1 attack

 */

# define SSL_OP_PKCS1_CHECK_1                            0x0

# define SSL_OP_PKCS1_CHECK_2                            0x0

# define SSL_OP_NETSCAPE_CA_DN_BUG                       0x20000000L

# define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG          0x40000000L

/*

 * Make server add server-hello extension from early version of cryptopro

 * draft, when GOST ciphersuite is negotiated. Required for interoperability

 * with CryptoPro CSP 3.x

 */

# define SSL_OP_CRYPTOPRO_TLSEXT_BUG                     0x80000000L

/*

 * Allow SSL_write(..., n) to return r with 0 < r < n (i.e. report success

 * when just a single record has been written):

 */

# define SSL_MODE_ENABLE_PARTIAL_WRITE       0x00000001L

/*

 * Make it possible to retry SSL_write() with changed buffer location (buffer

 * contents must stay the same!); this is not the default to avoid the

 * misconception that non-blocking SSL_write() behaves like non-blocking

 * write():

 */

# define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002L

/*

 * Never bother the application with retries if the transport is blocking:

 */

# define SSL_MODE_AUTO_RETRY 0x00000004L

/* Don't attempt to automatically build certificate chain */

# define SSL_MODE_NO_AUTO_CHAIN 0x00000008L

/*

 * Save RAM by releasing read and write buffers when they're empty. (SSL3 and

 * TLS only.) "Released" buffers are put onto a free-list in the context or

 * just freed (depending on the context's setting for freelist_max_len).

 */

# define SSL_MODE_RELEASE_BUFFERS 0x00000010L

/*

 * Send the current time in the Random fields of the ClientHello and

 * ServerHello records for compatibility with hypothetical implementations

 * that require it.

 */

# define SSL_MODE_SEND_CLIENTHELLO_TIME 0x00000020L

# define SSL_MODE_SEND_SERVERHELLO_TIME 0x00000040L

/*

 * Send TLS_FALLBACK_SCSV in the ClientHello. To be set only by applications

 * that reconnect with a downgraded protocol version; see

 * draft-ietf-tls-downgrade-scsv-00 for details. DO NOT ENABLE THIS if your

 * application attempts a normal handshake. Only use this in explicit

 * fallback retries, following the guidance in

 * draft-ietf-tls-downgrade-scsv-00.

 */

# define SSL_MODE_SEND_FALLBACK_SCSV 0x00000080L

/*

 * Note: SSL[_CTX]_set_{options,mode} use |= op on the previous value, they

 * cannot be used to clear bits.

 */

# define SSL_CTX_set_options(ctx,op) \

        SSL_CTX_ctrl((ctx),SSL_CTRL_OPTIONS,(op),NULL)

# define SSL_CTX_clear_options(ctx,op) \

        SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_OPTIONS,(op),NULL)

# define SSL_CTX_get_options(ctx) \

        SSL_CTX_ctrl((ctx),SSL_CTRL_OPTIONS,0,NULL)

# define SSL_set_options(ssl,op) \

        SSL_ctrl((ssl),SSL_CTRL_OPTIONS,(op),NULL)

# define SSL_clear_options(ssl,op) \

        SSL_ctrl((ssl),SSL_CTRL_CLEAR_OPTIONS,(op),NULL)

# define SSL_get_options(ssl) \

        SSL_ctrl((ssl),SSL_CTRL_OPTIONS,0,NULL)

# define SSL_CTX_set_mode(ctx,op) \

        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,(op),NULL)

# define SSL_CTX_clear_mode(ctx,op) \

        SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_MODE,(op),NULL)

# define SSL_CTX_get_mode(ctx) \

        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,0,NULL)

# define SSL_clear_mode(ssl,op) \

        SSL_ctrl((ssl),SSL_CTRL_CLEAR_MODE,(op),NULL)

# define SSL_set_mode(ssl,op) \

        SSL_ctrl((ssl),SSL_CTRL_MODE,(op),NULL)

# define SSL_get_mode(ssl) \

        SSL_ctrl((ssl),SSL_CTRL_MODE,0,NULL)

# define SSL_set_mtu(ssl, mtu) \

        SSL_ctrl((ssl),SSL_CTRL_SET_MTU,(mtu),NULL)

# define DTLS_set_link_mtu(ssl, mtu) \

        SSL_ctrl((ssl),DTLS_CTRL_SET_LINK_MTU,(mtu),NULL)

# define DTLS_get_link_min_mtu(ssl) \

        SSL_ctrl((ssl),DTLS_CTRL_GET_LINK_MIN_MTU,0,NULL)

# define SSL_get_secure_renegotiation_support(ssl) \

        SSL_ctrl((ssl), SSL_CTRL_GET_RI_SUPPORT, 0, NULL)

# ifndef OPENSSL_NO_HEARTBEATS

#  define SSL_heartbeat(ssl) \

        SSL_ctrl((ssl),SSL_CTRL_TLS_EXT_SEND_HEARTBEAT,0,NULL)

# endif

void SSL_CTX_set_msg_callback(SSL_CTX *ctx,

                              void (*cb) (int write_p, int version,

                                          int content_type, const void *buf,

                                          size_t len, SSL *ssl, void *arg));

void SSL_set_msg_callback(SSL *ssl,

                          void (*cb) (int write_p, int version,

                                      int content_type, const void *buf,

                                      size_t len, SSL *ssl, void *arg));

# define SSL_CTX_set_msg_callback_arg(ctx, arg) SSL_CTX_ctrl((ctx), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))

# define SSL_set_msg_callback_arg(ssl, arg) SSL_ctrl((ssl), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))

# ifndef OPENSSL_NO_SRP

#  ifndef OPENSSL_NO_SSL_INTERN

typedef struct srp_ctx_st {

    /* param for all the callbacks */

    void *SRP_cb_arg;

    /* set client Hello login callback */

    int (*TLS_ext_srp_username_callback) (SSL *, int *, void *);

    /* set SRP N/g param callback for verification */

    int (*SRP_verify_param_callback) (SSL *, void *);

    /* set SRP client passwd callback */

    char *(*SRP_give_srp_client_pwd_callback) (SSL *, void *);

    char *login;

    BIGNUM *N, *g, *s, *B, *A;

    BIGNUM *a, *b, *v;

    char *info;

    int strength;

    unsigned long srp_Mask;

} SRP_CTX;

#  endif

/* see tls_srp.c */

int SSL_SRP_CTX_init(SSL *s);

int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx);

int SSL_SRP_CTX_free(SSL *ctx);

int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx);

int SSL_srp_server_param_with_username(SSL *s, int *ad);

int SRP_generate_server_master_secret(SSL *s, unsigned char *master_key);

int SRP_Calc_A_param(SSL *s);

int SRP_generate_client_master_secret(SSL *s, unsigned char *master_key);

# endif

# if defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_WIN32)

#  define SSL_MAX_CERT_LIST_DEFAULT 1024*30

                                          /* 30k max cert list :-) */

# else

#  define SSL_MAX_CERT_LIST_DEFAULT 1024*100

                                           /* 100k max cert list :-) */

# endif

# define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT      (1024*20)

/*

 * This callback type is used inside SSL_CTX, SSL, and in the functions that

 * set them. It is used to override the generation of SSL/TLS session IDs in

 * a server. Return value should be zero on an error, non-zero to proceed.

 * Also, callbacks should themselves check if the id they generate is unique

 * otherwise the SSL handshake will fail with an error - callbacks can do

 * this using the 'ssl' value they're passed by;

 * SSL_has_matching_session_id(ssl, id, *id_len) The length value passed in

 * is set at the maximum size the session ID can be. In SSLv2 this is 16

 * bytes, whereas SSLv3/TLSv1 it is 32 bytes. The callback can alter this

 * length to be less if desired, but under SSLv2 session IDs are supposed to

 * be fixed at 16 bytes so the id will be padded after the callback returns

 * in this case. It is also an error for the callback to set the size to

 * zero.

 */

typedef int (*GEN_SESSION_CB) (const SSL *ssl, unsigned char *id,

                               unsigned int *id_len);

typedef struct ssl_comp_st SSL_COMP;

# ifndef OPENSSL_NO_SSL_INTERN

struct ssl_comp_st {

    int id;

    const char *name;

#  ifndef OPENSSL_NO_COMP

    COMP_METHOD *method;

#  else

    char *method;

#  endif

};

DECLARE_STACK_OF(SSL_COMP)

DECLARE_LHASH_OF(SSL_SESSION);

struct ssl_ctx_st {

    const SSL_METHOD *method;

    STACK_OF(SSL_CIPHER) *cipher_list;

    /* same as above but sorted for lookup */

    STACK_OF(SSL_CIPHER) *cipher_list_by_id;

    struct x509_store_st /* X509_STORE */ *cert_store;

    LHASH_OF(SSL_SESSION) *sessions;

    /*

     * Most session-ids that will be cached, default is

     * SSL_SESSION_CACHE_MAX_SIZE_DEFAULT. 0 is unlimited.

     */

    unsigned long session_cache_size;

    struct ssl_session_st *session_cache_head;

    struct ssl_session_st *session_cache_tail;

    /*

     * This can have one of 2 values, ored together, SSL_SESS_CACHE_CLIENT,

     * SSL_SESS_CACHE_SERVER, Default is SSL_SESSION_CACHE_SERVER, which

     * means only SSL_accept which cache SSL_SESSIONS.

     */

    int session_cache_mode;

    /*

     * If timeout is not 0, it is the default timeout value set when

     * SSL_new() is called.  This has been put in to make life easier to set

     * things up

     */

    long session_timeout;

    /*

     * If this callback is not null, it will be called each time a session id

     * is added to the cache.  If this function returns 1, it means that the

     * callback will do a SSL_SESSION_free() when it has finished using it.

     * Otherwise, on 0, it means the callback has finished with it. If

     * remove_session_cb is not null, it will be called when a session-id is

     * removed from the cache.  After the call, OpenSSL will

     * SSL_SESSION_free() it.

     */

    int (*new_session_cb) (struct ssl_st *ssl, SSL_SESSION *sess);

    void (*remove_session_cb) (struct ssl_ctx_st *ctx, SSL_SESSION *sess);

    SSL_SESSION *(*get_session_cb) (struct ssl_st *ssl,

                                    unsigned char *data, int len, int *copy);

    struct {

        int sess_connect;       /* SSL new conn - started */

        int sess_connect_renegotiate; /* SSL reneg - requested */

        int sess_connect_good;  /* SSL new conne/reneg - finished */

        int sess_accept;        /* SSL new accept - started */

        int sess_accept_renegotiate; /* SSL reneg - requested */

        int sess_accept_good;   /* SSL accept/reneg - finished */

        int sess_miss;          /* session lookup misses */

        int sess_timeout;       /* reuse attempt on timeouted session */

        int sess_cache_full;    /* session removed due to full cache */

        int sess_hit;           /* session reuse actually done */

        int sess_cb_hit;        /* session-id that was not in the cache was

                                 * passed back via the callback.  This

                                 * indicates that the application is

                                 * supplying session-id's from other

                                 * processes - spooky :-) */

    } stats;

    int references;

    /* if defined, these override the X509_verify_cert() calls */

    int (*app_verify_callback) (X509_STORE_CTX *, void *);

    void *app_verify_arg;

    /*

     * before OpenSSL 0.9.7, 'app_verify_arg' was ignored

     * ('app_verify_callback' was called with just one argument)

     */

    /* Default password callback. */

    pem_password_cb *default_passwd_callback;

    /* Default password callback user data. */

    void *default_passwd_callback_userdata;

    /* get client cert callback */

    int (*client_cert_cb) (SSL *ssl, X509 **x509, EVP_PKEY **pkey);

    /* cookie generate callback */

    int (*app_gen_cookie_cb) (SSL *ssl, unsigned char *cookie,

                              unsigned int *cookie_len);

    /* verify cookie callback */

    int (*app_verify_cookie_cb) (SSL *ssl, unsigned char *cookie,

                                 unsigned int cookie_len);

    CRYPTO_EX_DATA ex_data;

    const EVP_MD *rsa_md5;      /* For SSLv2 - name is 'ssl2-md5' */

    const EVP_MD *md5;          /* For SSLv3/TLSv1 'ssl3-md5' */

    const EVP_MD *sha1;         /* For SSLv3/TLSv1 'ssl3->sha1' */

    STACK_OF(X509) *extra_certs;

    STACK_OF(SSL_COMP) *comp_methods; /* stack of SSL_COMP, SSLv3/TLSv1 */

    /* Default values used when no per-SSL value is defined follow */

    /* used if SSL's info_callback is NULL */

    void (*info_callback) (const SSL *ssl, int type, int val);

    /* what we put in client cert requests */

    STACK_OF(X509_NAME) *client_CA;

    /*

     * Default values to use in SSL structures follow (these are copied by

     * SSL_new)

     */

    unsigned long options;

    unsigned long mode;

    long max_cert_list;

    struct cert_st /* CERT */ *cert;

    int read_ahead;

    /* callback that allows applications to peek at protocol messages */

    void (*msg_callback) (int write_p, int version, int content_type,

                          const void *buf, size_t len, SSL *ssl, void *arg);

    void *msg_callback_arg;

    int verify_mode;

    unsigned int sid_ctx_length;

    unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];

    /* called 'verify_callback' in the SSL */

    int (*default_verify_callback) (int ok, X509_STORE_CTX *ctx);

    /* Default generate session ID callback. */

    GEN_SESSION_CB generate_session_id;

    X509_VERIFY_PARAM *param;

#  if 0

    int purpose;                /* Purpose setting */

    int trust;                  /* Trust setting */

#  endif

    int quiet_shutdown;

    /*

     * Maximum amount of data to send in one fragment. actual record size can

     * be more than this due to padding and MAC overheads.

     */

    unsigned int max_send_fragment;

#  ifndef OPENSSL_NO_ENGINE

    /*

     * Engine to pass requests for client certs to

     */

    ENGINE *client_cert_engine;

#  endif

#  ifndef OPENSSL_NO_TLSEXT

    /* TLS extensions servername callback */

    int (*tlsext_servername_callback) (SSL *, int *, void *);

    void *tlsext_servername_arg;

    /* RFC 4507 session ticket keys */

    unsigned char tlsext_tick_key_name[16];

    unsigned char tlsext_tick_hmac_key[16];

    unsigned char tlsext_tick_aes_key[16];

    /* Callback to support customisation of ticket key setting */

    int (*tlsext_ticket_key_cb) (SSL *ssl,

                                 unsigned char *name, unsigned char *iv,

                                 EVP_CIPHER_CTX *ectx,

                                 HMAC_CTX *hctx, int enc);

    /* certificate status request info */

    /* Callback for status request */

    int (*tlsext_status_cb) (SSL *ssl, void *arg);

    void *tlsext_status_arg;

    /* draft-rescorla-tls-opaque-prf-input-00.txt information */

    int (*tlsext_opaque_prf_input_callback) (SSL *, void *peerinput,

                                             size_t len, void *arg);

    void *tlsext_opaque_prf_input_callback_arg;

#  endif

#  ifndef OPENSSL_NO_PSK

    char *psk_identity_hint;

    unsigned int (*psk_client_callback) (SSL *ssl, const char *hint,

                                         char *identity,

                                         unsigned int max_identity_len,

                                         unsigned char *psk,

                                         unsigned int max_psk_len);

    unsigned int (*psk_server_callback) (SSL *ssl, const char *identity,

                                         unsigned char *psk,

                                         unsigned int max_psk_len);

#  endif

#  ifndef OPENSSL_NO_BUF_FREELISTS

#   define SSL_MAX_BUF_FREELIST_LEN_DEFAULT 32

    unsigned int freelist_max_len;

    struct ssl3_buf_freelist_st *wbuf_freelist;

    struct ssl3_buf_freelist_st *rbuf_freelist;

#  endif

#  ifndef OPENSSL_NO_SRP

    SRP_CTX srp_ctx;            /* ctx for SRP authentication */

#  endif

#  ifndef OPENSSL_NO_TLSEXT

#   ifndef OPENSSL_NO_NEXTPROTONEG

    /* Next protocol negotiation information */

    /* (for experimental NPN extension). */

    /*

     * For a server, this contains a callback function by which the set of

     * advertised protocols can be provided.

     */

    int (*next_protos_advertised_cb) (SSL *s, const unsigned char **buf,

                                      unsigned int *len, void *arg);

    void *next_protos_advertised_cb_arg;

    /*

     * For a client, this contains a callback function that selects the next

     * protocol from the list provided by the server.

     */

    int (*next_proto_select_cb) (SSL *s, unsigned char **out,

                                 unsigned char *outlen,

                                 const unsigned char *in,

                                 unsigned int inlen, void *arg);

    void *next_proto_select_cb_arg;

#   endif

    /* SRTP profiles we are willing to do from RFC 5764 */

    STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles;

#  endif

};

# endif

# 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

/* enough comments already ... see SSL_CTX_set_session_cache_mode(3) */

# define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP       0x0100

# define SSL_SESS_CACHE_NO_INTERNAL_STORE        0x0200

# define SSL_SESS_CACHE_NO_INTERNAL \

        (SSL_SESS_CACHE_NO_INTERNAL_LOOKUP|SSL_SESS_CACHE_NO_INTERNAL_STORE)

LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx);

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

void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,

                             int (*new_session_cb) (struct ssl_st *ssl,

                                                    SSL_SESSION *sess));

int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,

                                              SSL_SESSION *sess);

void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,

                                void (*remove_session_cb) (struct ssl_ctx_st

                                                           *ctx,

                                                           SSL_SESSION

                                                           *sess));

void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)) (struct ssl_ctx_st *ctx,

                                                  SSL_SESSION *sess);

void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,

                             SSL_SESSION *(*get_session_cb) (struct ssl_st

                                                             *ssl,

                                                             unsigned char

                                                             *data, int len,

                                                             int *copy));

SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,

                                                       unsigned char *Data,

                                                       int len, int *copy);

void SSL_CTX_set_info_callback(SSL_CTX *ctx,

                               void (*cb) (const SSL *ssl, int type,

                                           int val));

void (*SSL_CTX_get_info_callback(SSL_CTX *ctx)) (const SSL *ssl, int type,

                                                 int val);

void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,

                                int (*client_cert_cb) (SSL *ssl, X509 **x509,

                                                       EVP_PKEY **pkey));

int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx)) (SSL *ssl, X509 **x509,

                                                 EVP_PKEY **pkey);

# ifndef OPENSSL_NO_ENGINE

int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e);

# endif

void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,

                                    int (*app_gen_cookie_cb) (SSL *ssl,

                                                              unsigned char

                                                              *cookie,

                                                              unsigned int

                                                              *cookie_len));

void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,

                                  int (*app_verify_cookie_cb) (SSL *ssl,

                                                               unsigned char

                                                               *cookie,

                                                               unsigned int

                                                               cookie_len));

# ifndef OPENSSL_NO_NEXTPROTONEG

void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *s,

                                           int (*cb) (SSL *ssl,

                                                      const unsigned char

                                                      **out,

                                                      unsigned int *outlen,

                                                      void *arg), void *arg);

void SSL_CTX_set_next_proto_select_cb(SSL_CTX *s,

                                      int (*cb) (SSL *ssl,

                                                 unsigned char **out,

                                                 unsigned char *outlen,

                                                 const unsigned char *in,

                                                 unsigned int inlen,

                                                 void *arg), void *arg);

int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,

                          const unsigned char *in, unsigned int inlen,

                          const unsigned char *client,

                          unsigned int client_len);

void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,

                                    unsigned *len);

#  define OPENSSL_NPN_UNSUPPORTED 0

#  define OPENSSL_NPN_NEGOTIATED  1

#  define OPENSSL_NPN_NO_OVERLAP  2

# endif

# ifndef OPENSSL_NO_PSK

/*

 * the maximum length of the buffer given to callbacks containing the

 * resulting identity/psk

 */

#  define PSK_MAX_IDENTITY_LEN 128

#  define PSK_MAX_PSK_LEN 256

void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,

                                     unsigned int (*psk_client_callback) (SSL

                                                                          *ssl,

                                                                          const

                                                                          char

                                                                          *hint,

                                                                          char

                                                                          *identity,

                                                                          unsigned

                                                                          int

                                                                          max_identity_len,

                                                                          unsigned

                                                                          char

                                                                          *psk,

                                                                          unsigned

                                                                          int

                                                                          max_psk_len));

void SSL_set_psk_client_callback(SSL *ssl,

                                 unsigned int (*psk_client_callback) (SSL

                                                                      *ssl,

                                                                      const

                                                                      char

                                                                      *hint,

                                                                      char

                                                                      *identity,

                                                                      unsigned

                                                                      int

                                                                      max_identity_len,

                                                                      unsigned

                                                                      char

                                                                      *psk,

                                                                      unsigned

                                                                      int

                                                                      max_psk_len));

void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,

                                     unsigned int (*psk_server_callback) (SSL

                                                                          *ssl,

                                                                          const

                                                                          char

                                                                          *identity,

                                                                          unsigned

                                                                          char

                                                                          *psk,

                                                                          unsigned

                                                                          int

                                                                          max_psk_len));

void SSL_set_psk_server_callback(SSL *ssl,

                                 unsigned int (*psk_server_callback) (SSL

                                                                      *ssl,

                                                                      const

                                                                      char

                                                                      *identity,

                                                                      unsigned

                                                                      char

                                                                      *psk,

                                                                      unsigned

                                                                      int

                                                                      max_psk_len));

int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint);

int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint);

const char *SSL_get_psk_identity_hint(const SSL *s);

const char *SSL_get_psk_identity(const SSL *s);

# endif

# define SSL_NOTHING     1

# define SSL_WRITING     2

# define SSL_READING     3

# define SSL_X509_LOOKUP 4

/* These will only be used when doing non-blocking IO */

# define SSL_want_nothing(s)     (SSL_want(s) == SSL_NOTHING)

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

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

# define SSL_want_x509_lookup(s) (SSL_want(s) == SSL_X509_LOOKUP)