1 files changed, 51 insertions, 364 deletions

diff --git a/src/lib/libssl/ssl_lib.c b/src/lib/libssl/ssl_lib.c
index 065411aea8..0f4b7a475b 100644
--- a/src/lib/libssl/ssl_lib.c
+++ b/src/lib/libssl/ssl_lib.c
@@ -110,11 +110,7 @@
  * 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.
- */
+
 
 #ifdef REF_CHECK
 #  include <assert.h>
@@ -125,11 +121,7 @@
 #include <openssl/objects.h>
 #include <openssl/lhash.h>
 #include <openssl/x509v3.h>
-#include <openssl/rand.h>
-#include <openssl/ocsp.h>
-#ifndef OPENSSL_NO_DH
-#include <openssl/dh.h>
-#endif
+#include <openssl/fips.h>
 
 const char *SSL_version_str=OPENSSL_VERSION_TEXT;
 
@@ -140,14 +132,7 @@ SSL3_ENC_METHOD ssl3_undef_enc_method={
         ssl_undefined_function,
         (int (*)(SSL *, unsigned char *, unsigned char *, int))ssl_undefined_function,
         (int (*)(SSL*, int))ssl_undefined_function,
-        (int (*)(SSL *, EVP_MD_CTX *, EVP_MD_CTX *, const char*, int, unsigned char *))ssl_undefined_function,
-        0,      /* finish_mac_length */
-        (int (*)(SSL *, EVP_MD_CTX *, unsigned char *))ssl_undefined_function,
-        NULL,   /* client_finished_label */
-        0,      /* client_finished_label_len */
-        NULL,   /* server_finished_label */
-        0,      /* server_finished_label_len */
-        (int (*)(int))ssl_undefined_function
+        (int (*)(SSL *, EVP_MD_CTX *, EVP_MD_CTX *, const char*, int, unsigned char *))ssl_undefined_function
         };
 
 int SSL_clear(SSL *s)
@@ -287,40 +272,19 @@ SSL *SSL_new(SSL_CTX *ctx)
         s->msg_callback=ctx->msg_callback;
         s->msg_callback_arg=ctx->msg_callback_arg;
         s->verify_mode=ctx->verify_mode;
-#if 0
         s->verify_depth=ctx->verify_depth;
-#endif
         s->sid_ctx_length=ctx->sid_ctx_length;
         OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
         memcpy(&s->sid_ctx,&ctx->sid_ctx,sizeof(s->sid_ctx));
         s->verify_callback=ctx->default_verify_callback;
         s->generate_session_id=ctx->generate_session_id;
-
-        s->param = X509_VERIFY_PARAM_new();
-        if (!s->param)
-                goto err;
-        X509_VERIFY_PARAM_inherit(s->param, ctx->param);
-#if 0
         s->purpose = ctx->purpose;
         s->trust = ctx->trust;
-#endif
         s->quiet_shutdown=ctx->quiet_shutdown;
 
         CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
         s->ctx=ctx;
-#ifndef OPENSSL_NO_TLSEXT
-        s->tlsext_debug_cb = 0;
-        s->tlsext_debug_arg = NULL;
-        s->tlsext_ticket_expected = 0;
-        s->tlsext_status_type = -1;
-        s->tlsext_status_expected = 0;
-        s->tlsext_ocsp_ids = NULL;
-        s->tlsext_ocsp_exts = NULL;
-        s->tlsext_ocsp_resp = NULL;
-        s->tlsext_ocsp_resplen = -1;
-        CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
-        s->initial_ctx=ctx;
-#endif
+
         s->verify_result=X509_V_OK;
 
         s->method=ctx->method;
@@ -429,22 +393,22 @@ int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
 
 int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
         {
-        return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
+        return X509_PURPOSE_set(&s->purpose, purpose);
         }
 
 int SSL_set_purpose(SSL *s, int purpose)
         {
-        return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
+        return X509_PURPOSE_set(&s->purpose, purpose);
         }
 
 int SSL_CTX_set_trust(SSL_CTX *s, int trust)
         {
-        return X509_VERIFY_PARAM_set_trust(s->param, trust);
+        return X509_TRUST_set(&s->trust, trust);
         }
 
 int SSL_set_trust(SSL *s, int trust)
         {
-        return X509_VERIFY_PARAM_set_trust(s->param, trust);
+        return X509_TRUST_set(&s->trust, trust);
         }
 
 void SSL_free(SSL *s)
@@ -467,9 +431,6 @@ void SSL_free(SSL *s)
                 }
 #endif
 
-        if (s->param)
-                X509_VERIFY_PARAM_free(s->param);
-
         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
 
         if (s->bbio != NULL)
@@ -506,16 +467,7 @@ void SSL_free(SSL *s)
         /* Free up if allocated */
 
         if (s->ctx) SSL_CTX_free(s->ctx);
-#ifndef OPENSSL_NO_TLSEXT
-        if (s->initial_ctx) SSL_CTX_free(s->initial_ctx);
-        if (s->tlsext_ocsp_exts)
-                sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
-                                                X509_EXTENSION_free);
-        if (s->tlsext_ocsp_ids)
-                sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
-        if (s->tlsext_ocsp_resp)
-                OPENSSL_free(s->tlsext_ocsp_resp);
-#endif
+
         if (s->client_CA != NULL)
                 sk_X509_NAME_pop_free(s->client_CA,X509_NAME_free);
 
@@ -691,7 +643,7 @@ int SSL_get_verify_mode(const SSL *s)
 
 int SSL_get_verify_depth(const SSL *s)
         {
-        return X509_VERIFY_PARAM_get_depth(s->param);
+        return(s->verify_depth);
         }
 
 int (*SSL_get_verify_callback(const SSL *s))(int,X509_STORE_CTX *)
@@ -706,7 +658,7 @@ int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
 
 int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
         {
-        return X509_VERIFY_PARAM_get_depth(ctx->param);
+        return(ctx->verify_depth);
         }
 
 int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int,X509_STORE_CTX *)
@@ -724,7 +676,7 @@ void SSL_set_verify(SSL *s,int mode,
 
 void SSL_set_verify_depth(SSL *s,int depth)
         {
-        X509_VERIFY_PARAM_set_depth(s->param, depth);
+        s->verify_depth=depth;
         }
 
 void SSL_set_read_ahead(SSL *s,int yes)
@@ -898,7 +850,7 @@ int SSL_peek(SSL *s,void *buf,int num)
         {
         if (s->handshake_func == 0)
                 {
-                SSLerr(SSL_F_SSL_PEEK, SSL_R_UNINITIALIZED);
+                SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
                 return -1;
                 }
 
@@ -989,19 +941,12 @@ long SSL_ctrl(SSL *s,int cmd,long larg,void *parg)
                 l=s->max_cert_list;
                 s->max_cert_list=larg;
                 return(l);
-        case SSL_CTRL_SET_MTU:
-                if (SSL_version(s) == DTLS1_VERSION)
-                        {
-                        s->d1->mtu = larg;
-                        return larg;
-                        }
-                return 0;
         default:
                 return(s->method->ssl_ctrl(s,cmd,larg,parg));
                 }
         }
 
-long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
+long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)())
         {
         switch(cmd)
                 {
@@ -1089,7 +1034,7 @@ long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,void *parg)
                 }
         }
 
-long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
+long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)())
         {
         switch(cmd)
                 {
@@ -1223,36 +1168,33 @@ int SSL_set_cipher_list(SSL *s,const char *str)
 /* works well for SSLv2, not so good for SSLv3 */
 char *SSL_get_shared_ciphers(const SSL *s,char *buf,int len)
         {
-        char *p;
+        char *end;
         STACK_OF(SSL_CIPHER) *sk;
         SSL_CIPHER *c;
+        size_t curlen = 0;
         int i;
 
         if ((s->session == NULL) || (s->session->ciphers == NULL) ||
                 (len < 2))
                 return(NULL);
 
-        p=buf;
         sk=s->session->ciphers;
+        buf[0] = '\0';
         for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
                 {
-                int n;
-
                 c=sk_SSL_CIPHER_value(sk,i);
-                n=strlen(c->name);
-                if (n+1 > len)
+                end = buf + curlen;
+                if (strlcat(buf, c->name, len) >= len ||
+                    (curlen = strlcat(buf, ":", len)) >= len)
                         {
-                        if (p != buf)
-                                --p;
-                        *p='\0';
-                        return buf;
+                        /* remove truncated cipher from list */
+                        *end = '\0';
+                        break;
                         }
-                strcpy(p,c->name);
-                p+=n;
-                *(p++)=':';
-                len-=n+1;
                 }
-        p[-1]='\0';
+        /* remove trailing colon */
+        if ((end = strrchr(buf, ':')) != NULL)
+                *end = '\0';
         return(buf);
         }
 
@@ -1327,29 +1269,6 @@ err:
         return(NULL);
         }
 
-#ifndef OPENSSL_NO_TLSEXT
-/** return a servername extension value if provided in Client Hello, or NULL.
- * So far, only host_name types are defined (RFC 3546).
- */
-
-const char *SSL_get_servername(const SSL *s, const int type)
-        {
-        if (type != TLSEXT_NAMETYPE_host_name)
-                return NULL;
-
-        return s->session && !s->tlsext_hostname ?
-                s->session->tlsext_hostname :
-                s->tlsext_hostname;
-        }
-
-int SSL_get_servername_type(const SSL *s)
-        {
-        if (s->session && (!s->tlsext_hostname ? s->session->tlsext_hostname : s->tlsext_hostname))
-                return TLSEXT_NAMETYPE_host_name;
-        return -1;
-        }
-#endif
-
 unsigned long SSL_SESSION_hash(const SSL_SESSION *a)
         {
         unsigned long l;
@@ -1393,6 +1312,14 @@ SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
                 return(NULL);
                 }
 
+#ifdef OPENSSL_FIPS
+        if (FIPS_mode() && (meth->version < TLS1_VERSION))      
+                {
+                SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
+                return NULL;
+                }
+#endif
+
         if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0)
                 {
                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
@@ -1441,9 +1368,7 @@ SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
         ret->msg_callback=0;
         ret->msg_callback_arg=NULL;
         ret->verify_mode=SSL_VERIFY_NONE;
-#if 0
         ret->verify_depth=-1; /* Don't impose a limit (but x509_lu.c does) */
-#endif
         ret->sid_ctx_length=0;
         ret->default_verify_callback=NULL;
         if ((ret->cert=ssl_cert_new()) == NULL)
@@ -1452,8 +1377,6 @@ SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
         ret->default_passwd_callback=0;
         ret->default_passwd_callback_userdata=NULL;
         ret->client_cert_cb=0;
-        ret->app_gen_cookie_cb=0;
-        ret->app_verify_cookie_cb=0;
 
         ret->sessions=lh_new(LHASH_HASH_FN(SSL_SESSION_hash),
                         LHASH_COMP_FN(SSL_SESSION_cmp));
@@ -1471,10 +1394,6 @@ SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
                 goto err2;
                 }
 
-        ret->param = X509_VERIFY_PARAM_new();
-        if (!ret->param)
-                goto err;
-
         if ((ret->rsa_md5=EVP_get_digestbyname("ssl2-md5")) == NULL)
                 {
                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES);
@@ -1499,20 +1418,6 @@ SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
         ret->extra_certs=NULL;
         ret->comp_methods=SSL_COMP_get_compression_methods();
 
-#ifndef OPENSSL_NO_TLSEXT
-        ret->tlsext_servername_callback = 0;
-        ret->tlsext_servername_arg = NULL;
-        /* Setup RFC4507 ticket keys */
-        if ((RAND_pseudo_bytes(ret->tlsext_tick_key_name, 16) <= 0)
-                || (RAND_bytes(ret->tlsext_tick_hmac_key, 16) <= 0)
-                || (RAND_bytes(ret->tlsext_tick_aes_key, 16) <= 0))
-                ret->options |= SSL_OP_NO_TICKET;
-
-        ret->tlsext_status_cb = 0;
-        ret->tlsext_status_arg = NULL;
-
-#endif
-
         return(ret);
 err:
         SSLerr(SSL_F_SSL_CTX_NEW,ERR_R_MALLOC_FAILURE);
@@ -1545,9 +1450,6 @@ void SSL_CTX_free(SSL_CTX *a)
                 }
 #endif
 
-        if (a->param)
-                X509_VERIFY_PARAM_free(a->param);
-
         /*
          * Free internal session cache. However: the remove_cb() may reference
          * the ex_data of SSL_CTX, thus the ex_data store can only be removed
@@ -1610,7 +1512,7 @@ void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int (*cb)(int, X509_STORE_CTX *))
 
 void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth)
         {
-        X509_VERIFY_PARAM_set_depth(ctx->param, depth);
+        ctx->verify_depth=depth;
         }
 
 void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher)
@@ -1620,13 +1522,6 @@ void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher)
         int rsa_enc_export,dh_rsa_export,dh_dsa_export;
         int rsa_tmp_export,dh_tmp_export,kl;
         unsigned long mask,emask;
-        int have_ecc_cert, ecdh_ok, ecdsa_ok, ecc_pkey_size;
-#ifndef OPENSSL_NO_ECDH
-        int have_ecdh_tmp;
-#endif
-        X509 *x = NULL;
-        EVP_PKEY *ecc_pkey = NULL;
-        int signature_nid = 0;
 
         if (c == NULL) return;
 
@@ -1647,9 +1542,6 @@ void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher)
         dh_tmp=dh_tmp_export=0;
 #endif
 
-#ifndef OPENSSL_NO_ECDH
-        have_ecdh_tmp=(c->ecdh_tmp != NULL || c->ecdh_tmp_cb != NULL);
-#endif
         cpk= &(c->pkeys[SSL_PKEY_RSA_ENC]);
         rsa_enc= (cpk->x509 != NULL && cpk->privatekey != NULL);
         rsa_enc_export=(rsa_enc && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
@@ -1664,8 +1556,7 @@ void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher)
 /* FIX THIS EAY EAY EAY */
         dh_dsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
         dh_dsa_export=(dh_dsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
-        cpk= &(c->pkeys[SSL_PKEY_ECC]);
-        have_ecc_cert= (cpk->x509 != NULL && cpk->privatekey != NULL);
+
         mask=0;
         emask=0;
 
@@ -1722,127 +1613,11 @@ void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher)
         emask|=SSL_kKRB5|SSL_aKRB5;
 #endif
 
-        /* An ECC certificate may be usable for ECDH and/or
-         * ECDSA cipher suites depending on the key usage extension.
-         */
-        if (have_ecc_cert)
-                {
-                /* This call populates extension flags (ex_flags) */
-                x = (c->pkeys[SSL_PKEY_ECC]).x509;
-                X509_check_purpose(x, -1, 0);
-                ecdh_ok = (x->ex_flags & EXFLAG_KUSAGE) ?
-                    (x->ex_kusage & X509v3_KU_KEY_AGREEMENT) : 1;
-                ecdsa_ok = (x->ex_flags & EXFLAG_KUSAGE) ?
-                    (x->ex_kusage & X509v3_KU_DIGITAL_SIGNATURE) : 1;
-                ecc_pkey = X509_get_pubkey(x);
-                ecc_pkey_size = (ecc_pkey != NULL) ? 
-                    EVP_PKEY_bits(ecc_pkey) : 0;
-                EVP_PKEY_free(ecc_pkey);
-                if ((x->sig_alg) && (x->sig_alg->algorithm))
-                        signature_nid = OBJ_obj2nid(x->sig_alg->algorithm);
-#ifndef OPENSSL_NO_ECDH
-                if (ecdh_ok)
-                        {
-                        if ((signature_nid == NID_md5WithRSAEncryption) ||
-                            (signature_nid == NID_md4WithRSAEncryption) ||
-                            (signature_nid == NID_md2WithRSAEncryption))
-                                {
-                                mask|=SSL_kECDH|SSL_aRSA;
-                                if (ecc_pkey_size <= 163)
-                                        emask|=SSL_kECDH|SSL_aRSA;
-                                }
-                        if (signature_nid == NID_ecdsa_with_SHA1)
-                                {
-                                mask|=SSL_kECDH|SSL_aECDSA;
-                                if (ecc_pkey_size <= 163)
-                                        emask|=SSL_kECDH|SSL_aECDSA;
-                                }
-                        }
-#endif
-#ifndef OPENSSL_NO_ECDSA
-                if (ecdsa_ok)
-                        {
-                        mask|=SSL_aECDSA;
-                        emask|=SSL_aECDSA;
-                        }
-#endif
-                }
-
-#ifndef OPENSSL_NO_ECDH
-        if (have_ecdh_tmp)
-                {
-                mask|=SSL_kECDHE;
-                emask|=SSL_kECDHE;
-                }
-#endif
         c->mask=mask;
         c->export_mask=emask;
         c->valid=1;
         }
 
-/* This handy macro borrowed from crypto/x509v3/v3_purp.c */
-#define ku_reject(x, usage) \
-        (((x)->ex_flags & EXFLAG_KUSAGE) && !((x)->ex_kusage & (usage)))
-
-int check_srvr_ecc_cert_and_alg(X509 *x, SSL_CIPHER *cs)
-        {
-        unsigned long alg = cs->algorithms;
-        EVP_PKEY *pkey = NULL;
-        int keysize = 0;
-        int signature_nid = 0;
-
-        if (SSL_C_IS_EXPORT(cs))
-                {
-                /* ECDH key length in export ciphers must be <= 163 bits */
-                pkey = X509_get_pubkey(x);
-                if (pkey == NULL) return 0;
-                keysize = EVP_PKEY_bits(pkey);
-                EVP_PKEY_free(pkey);
-                if (keysize > 163) return 0;
-                }
-
-        /* This call populates the ex_flags field correctly */
-        X509_check_purpose(x, -1, 0);
-        if ((x->sig_alg) && (x->sig_alg->algorithm))
-                signature_nid = OBJ_obj2nid(x->sig_alg->algorithm);
-        if (alg & SSL_kECDH) 
-                {
-                /* key usage, if present, must allow key agreement */
-                if (ku_reject(x, X509v3_KU_KEY_AGREEMENT))
-                        {
-                        return 0;
-                        }
-                if (alg & SSL_aECDSA) 
-                        {
-                        /* signature alg must be ECDSA */
-                        if (signature_nid != NID_ecdsa_with_SHA1)
-                                {
-                                return 0;
-                                }
-                        }
-                if (alg & SSL_aRSA)
-                        {
-                        /* signature alg must be RSA */
-                        if ((signature_nid != NID_md5WithRSAEncryption) &&
-                            (signature_nid != NID_md4WithRSAEncryption) &&
-                            (signature_nid != NID_md2WithRSAEncryption))
-                                {
-                                return 0;
-                                }
-                        }
-                } 
-        else if (alg & SSL_aECDSA)
-                {
-                /* key usage, if present, must allow signing */
-                if (ku_reject(x, X509v3_KU_DIGITAL_SIGNATURE))
-                        {
-                        return 0;
-                        }
-                }
-
-        return 1;  /* all checks are ok */
-        }
-
 /* THIS NEEDS CLEANING UP */
 X509 *ssl_get_server_send_cert(SSL *s)
         {
@@ -1857,26 +1632,7 @@ X509 *ssl_get_server_send_cert(SSL *s)
         mask=is_export?c->export_mask:c->mask;
         kalg=alg&(SSL_MKEY_MASK|SSL_AUTH_MASK);
 
-        if (kalg & SSL_kECDH)
-                {
-                /* we don't need to look at SSL_kECDHE 
-                 * since no certificate is needed for
-                 * anon ECDH and for authenticated
-                 * ECDHE, the check for the auth 
-                 * algorithm will set i correctly
-                 * NOTE: For ECDH-RSA, we need an ECC
-                 * not an RSA cert but for ECDHE-RSA
-                 * we need an RSA cert. Placing the
-                 * checks for SSL_kECDH before RSA
-                 * checks ensures the correct cert is chosen.
-                 */
-                i=SSL_PKEY_ECC;
-                }
-        else if (kalg & SSL_aECDSA)
-                {
-                i=SSL_PKEY_ECC;
-                }
-        else if (kalg & SSL_kDHr)
+        if      (kalg & SSL_kDHr)
                 i=SSL_PKEY_DH_RSA;
         else if (kalg & SSL_kDHd)
                 i=SSL_PKEY_DH_DSA;
@@ -1900,7 +1656,6 @@ X509 *ssl_get_server_send_cert(SSL *s)
                 return(NULL);
                 }
         if (c->pkeys[i].x509 == NULL) return(NULL);
-
         return(c->pkeys[i].x509);
         }
 
@@ -1924,9 +1679,6 @@ EVP_PKEY *ssl_get_sign_pkey(SSL *s,SSL_CIPHER *cipher)
                 else
                         return(NULL);
                 }
-        else if ((alg & SSL_aECDSA) &&
-                 (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
-                return(c->pkeys[SSL_PKEY_ECC].privatekey);
         else /* if (alg & SSL_aNULL) */
                 {
                 SSLerr(SSL_F_SSL_GET_SIGN_PKEY,ERR_R_INTERNAL_ERROR);
@@ -2132,12 +1884,6 @@ int ssl_undefined_function(SSL *s)
         return(0);
         }
 
-int ssl_undefined_void_function(void)
-        {
-        SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
-        return(0);
-        }
-
 int ssl_undefined_const_function(const SSL *s)
         {
         SSLerr(SSL_F_SSL_UNDEFINED_CONST_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
@@ -2253,8 +1999,8 @@ SSL *SSL_dup(SSL *s)
         ret->rstate=s->rstate;
         ret->init_num = 0; /* would have to copy ret->init_buf, ret->init_msg, ret->init_num, ret->init_off */
         ret->hit=s->hit;
-
-        X509_VERIFY_PARAM_inherit(ret->param, s->param);
+        ret->purpose=s->purpose;
+        ret->trust=s->trust;
 
         /* dup the cipher_list and cipher_list_by_id stacks */
         if (s->cipher_list != NULL)
@@ -2306,7 +2052,6 @@ void ssl_clear_cipher_ctx(SSL *s)
                 OPENSSL_free(s->enc_write_ctx);
                 s->enc_write_ctx=NULL;
                 }
-#ifndef OPENSSL_NO_COMP
         if (s->expand != NULL)
                 {
                 COMP_CTX_free(s->expand);
@@ -2317,7 +2062,6 @@ void ssl_clear_cipher_ctx(SSL *s)
                 COMP_CTX_free(s->compress);
                 s->compress=NULL;
                 }
-#endif
         }
 
 /* Fix this function so that it takes an optional type parameter */
@@ -2344,31 +2088,6 @@ SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
                 return(s->session->cipher);
         return(NULL);
         }
-#ifdef OPENSSL_NO_COMP
-const void *SSL_get_current_compression(SSL *s)
-        {
-        return NULL;
-        }
-const void *SSL_get_current_expansion(SSL *s)
-        {
-        return NULL;
-        }
-#else
-
-const COMP_METHOD *SSL_get_current_compression(SSL *s)
-        {
-        if (s->compress != NULL)
-                return(s->compress->meth);
-        return(NULL);
-        }
-
-const COMP_METHOD *SSL_get_current_expansion(SSL *s)
-        {
-        if (s->expand != NULL)
-                return(s->expand->meth);
-        return(NULL);
-        }
-#endif
 
 int ssl_init_wbio_buffer(SSL *s,int push)
         {
@@ -2462,24 +2181,6 @@ SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
         return(ssl->ctx);
         }
 
-SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx)
-        {
-        if (ssl->ctx == ctx)
-                return ssl->ctx;
-#ifndef OPENSSL_NO_TLSEXT
-        if (ctx == NULL)
-                ctx = ssl->initial_ctx;
-#endif
-        if (ssl->cert != NULL)
-                ssl_cert_free(ssl->cert);
-        ssl->cert = ssl_cert_dup(ctx->cert);
-        CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
-        if (ssl->ctx != NULL)
-                SSL_CTX_free(ssl->ctx); /* decrement reference count */
-        ssl->ctx = ctx;
-        return(ssl->ctx);
-        }
-
 #ifndef OPENSSL_NO_STDIO
 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
         {
@@ -2489,19 +2190,19 @@ int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
 int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
                 const char *CApath)
         {
-        return(X509_STORE_load_locations(ctx->cert_store,CAfile,CApath));
+        int r;
+        r=X509_STORE_load_locations(ctx->cert_store,CAfile,CApath);
+        return r;
         }
 #endif
 
 void SSL_set_info_callback(SSL *ssl,
-        void (*cb)(const SSL *ssl,int type,int val))
+                           void (*cb)(const SSL *ssl,int type,int val))
         {
         ssl->info_callback=cb;
         }
 
-/* One compiler (Diab DCC) doesn't like argument names in returned
-   function pointer.  */
-void (*SSL_get_info_callback(const SSL *ssl))(const SSL * /*ssl*/,int /*type*/,int /*val*/) 
+void (*SSL_get_info_callback(const SSL *ssl))(const SSL *ssl,int type,int val)
         {
         return ssl->info_callback;
         }
@@ -2588,14 +2289,14 @@ void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,
                                                           int is_export,
                                                           int keylength))
     {
-    SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
+    SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,(void (*)())cb);
     }
 
 void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,
                                                   int is_export,
                                                   int keylength))
     {
-    SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
+    SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,(void (*)())cb);
     }
 #endif
 
@@ -2624,38 +2325,24 @@ RSA *cb(SSL *ssl,int is_export,int keylength)
 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int is_export,
                                                         int keylength))
         {
-        SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
+        SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,(void (*)())dh);
         }
 
 void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int is_export,
                                                 int keylength))
         {
-        SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
-        }
-#endif
-
-#ifndef OPENSSL_NO_ECDH
-void SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
-                                                        int keylength))
-        {
-        SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
-        }
-
-void SSL_set_tmp_ecdh_callback(SSL *ssl,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
-                                                int keylength))
-        {
-        SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
+        SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,(void (*)())dh);
         }
 #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))
         {
-        SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
+        SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)())cb);
         }
 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))
         {
-        SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
+        SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)())cb);
         }