1 files changed, 32 insertions, 221 deletions

diff --git a/src/lib/libssl/ssl_sess.c b/src/lib/libssl/ssl_sess.c
index 8e5d8a0972..8391d62212 100644
--- a/src/lib/libssl/ssl_sess.c
+++ b/src/lib/libssl/ssl_sess.c
@@ -55,85 +55,6 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
-/* ====================================================================
- * Copyright (c) 1998-2006 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 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.
- */
 
 #include <stdio.h>
 #include <openssl/lhash.h>
@@ -206,18 +127,8 @@ SSL_SESSION *SSL_SESSION_new(void)
         ss->compress_meth=0;
 #ifndef OPENSSL_NO_TLSEXT
         ss->tlsext_hostname = NULL; 
-#ifndef OPENSSL_NO_EC
-        ss->tlsext_ecpointformatlist_length = 0;
-        ss->tlsext_ecpointformatlist = NULL;
-        ss->tlsext_ellipticcurvelist_length = 0;
-        ss->tlsext_ellipticcurvelist = NULL;
-#endif
 #endif
         CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data);
-#ifndef OPENSSL_NO_PSK
-        ss->psk_identity_hint=NULL;
-        ss->psk_identity=NULL;
-#endif
         return(ss);
         }
 
@@ -272,10 +183,10 @@ int ssl_get_new_session(SSL *s, int session)
         if ((ss=SSL_SESSION_new()) == NULL) return(0);
 
         /* If the context has a default timeout, use it */
-        if (s->session_ctx->session_timeout == 0)
+        if (s->ctx->session_timeout == 0)
                 ss->timeout=SSL_get_default_timeout(s);
         else
-                ss->timeout=s->session_ctx->session_timeout;
+                ss->timeout=s->ctx->session_timeout;
 
         if (s->session != NULL)
                 {
@@ -300,11 +211,6 @@ int ssl_get_new_session(SSL *s, int session)
                         ss->ssl_version=TLS1_VERSION;
                         ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
                         }
-                else if (s->version == DTLS1_BAD_VER)
-                        {
-                        ss->ssl_version=DTLS1_BAD_VER;
-                        ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
-                        }
                 else if (s->version == DTLS1_VERSION)
                         {
                         ss->ssl_version=DTLS1_VERSION;
@@ -328,8 +234,8 @@ int ssl_get_new_session(SSL *s, int session)
                 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
                 if(s->generate_session_id)
                         cb = s->generate_session_id;
-                else if(s->session_ctx->generate_session_id)
-                        cb = s->session_ctx->generate_session_id;
+                else if(s->ctx->generate_session_id)
+                        cb = s->ctx->generate_session_id;
                 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
                 /* Choose a session ID */
                 tmp = ss->session_id_length;
@@ -375,32 +281,6 @@ int ssl_get_new_session(SSL *s, int session)
                                 return 0;
                                 }
                         }
-#ifndef OPENSSL_NO_EC
-                if (s->tlsext_ecpointformatlist)
-                        {
-                        if (ss->tlsext_ecpointformatlist != NULL) OPENSSL_free(ss->tlsext_ecpointformatlist);
-                        if ((ss->tlsext_ecpointformatlist = OPENSSL_malloc(s->tlsext_ecpointformatlist_length)) == NULL)
-                                {
-                                SSLerr(SSL_F_SSL_GET_NEW_SESSION, ERR_R_MALLOC_FAILURE);
-                                SSL_SESSION_free(ss);
-                                return 0;
-                                }
-                        ss->tlsext_ecpointformatlist_length = s->tlsext_ecpointformatlist_length;
-                        memcpy(ss->tlsext_ecpointformatlist, s->tlsext_ecpointformatlist, s->tlsext_ecpointformatlist_length);
-                        }
-                if (s->tlsext_ellipticcurvelist)
-                        {
-                        if (ss->tlsext_ellipticcurvelist != NULL) OPENSSL_free(ss->tlsext_ellipticcurvelist);
-                        if ((ss->tlsext_ellipticcurvelist = OPENSSL_malloc(s->tlsext_ellipticcurvelist_length)) == NULL)
-                                {
-                                SSLerr(SSL_F_SSL_GET_NEW_SESSION, ERR_R_MALLOC_FAILURE);
-                                SSL_SESSION_free(ss);
-                                return 0;
-                                }
-                        ss->tlsext_ellipticcurvelist_length = s->tlsext_ellipticcurvelist_length;
-                        memcpy(ss->tlsext_ellipticcurvelist, s->tlsext_ellipticcurvelist, s->tlsext_ellipticcurvelist_length);
-                        }
-#endif
 #endif
                 }
         else
@@ -433,15 +313,15 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
 #ifndef OPENSSL_NO_TLSEXT
         int r;
 #endif
-
+  
         if (len > SSL_MAX_SSL_SESSION_ID_LENGTH)
                 goto err;
 #ifndef OPENSSL_NO_TLSEXT
-        r = tls1_process_ticket(s, session_id, len, limit, &ret);
+        r = tls1_process_ticket(s, session_id, len, limit, &ret);
         if (r == -1)
                 {
                 fatal = 1;
-                goto err;
+                goto err;
                 }
         else if (r == 0 || (!ret && !len))
                 goto err;
@@ -449,7 +329,7 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
 #else
         if (len == 0)
                 goto err;
-        if (!(s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
+        if (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
 #endif
                 {
                 SSL_SESSION data;
@@ -457,9 +337,9 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
                 data.session_id_length=len;
                 if (len == 0)
                         return 0;
-                memcpy(data.session_id,session_id,len);
+                memcpy(data.session_id,session_id,len);
                 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
-                ret=lh_SSL_SESSION_retrieve(s->session_ctx->sessions,&data);
+                ret=(SSL_SESSION *)lh_retrieve(s->ctx->sessions,&data);
                 if (ret != NULL)
                     /* don't allow other threads to steal it: */
                     CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
@@ -470,13 +350,13 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
                 {
                 int copy=1;
         
-                s->session_ctx->stats.sess_miss++;
+                s->ctx->stats.sess_miss++;
                 ret=NULL;
-                if (s->session_ctx->get_session_cb != NULL
-                    && (ret=s->session_ctx->get_session_cb(s,session_id,len,&copy))
+                if (s->ctx->get_session_cb != NULL
+                    && (ret=s->ctx->get_session_cb(s,session_id,len,&copy))
                        != NULL)
                         {
-                        s->session_ctx->stats.sess_cb_hit++;
+                        s->ctx->stats.sess_cb_hit++;
 
                         /* Increment reference count now if the session callback
                          * asks us to do so (note that if the session structures
@@ -488,10 +368,10 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
 
                         /* Add the externally cached session to the internal
                          * cache as well if and only if we are supposed to. */
-                        if(!(s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_STORE))
+                        if(!(s->ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_STORE))
                                 /* The following should not return 1, otherwise,
                                  * things are very strange */
-                                SSL_CTX_add_session(s->session_ctx,ret);
+                                SSL_CTX_add_session(s->ctx,ret);
                         }
                 if (ret == NULL)
                         goto err;
@@ -538,7 +418,7 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
                 p=buf;
                 l=ret->cipher_id;
                 l2n(l,p);
-                if ((ret->ssl_version>>8) >= SSL3_VERSION_MAJOR)
+                if ((ret->ssl_version>>8) == SSL3_VERSION_MAJOR)
                         ret->cipher=ssl_get_cipher_by_char(s,&(buf[2]));
                 else 
                         ret->cipher=ssl_get_cipher_by_char(s,&(buf[1]));
@@ -558,13 +438,13 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
 
         if (ret->timeout < (long)(time(NULL) - ret->time)) /* timeout */
                 {
-                s->session_ctx->stats.sess_timeout++;
+                s->ctx->stats.sess_timeout++;
                 /* remove it from the cache */
-                SSL_CTX_remove_session(s->session_ctx,ret);
+                SSL_CTX_remove_session(s->ctx,ret);
                 goto err;
                 }
 
-        s->session_ctx->stats.sess_hit++;
+        s->ctx->stats.sess_hit++;
 
         /* ret->time=time(NULL); */ /* rezero timeout? */
         /* again, just leave the session 
@@ -597,7 +477,7 @@ int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
         /* if session c is in already in cache, we take back the increment later */
 
         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-        s=lh_SSL_SESSION_insert(ctx->sessions,c);
+        s=(SSL_SESSION *)lh_insert(ctx->sessions,c);
         
         /* s != NULL iff we already had a session with the given PID.
          * In this case, s == c should hold (then we did not really modify
@@ -663,10 +543,10 @@ static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
         if ((c != NULL) && (c->session_id_length != 0))
                 {
                 if(lck) CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-                if ((r = lh_SSL_SESSION_retrieve(ctx->sessions,c)) == c)
+                if ((r = (SSL_SESSION *)lh_retrieve(ctx->sessions,c)) == c)
                         {
                         ret=1;
-                        r=lh_SSL_SESSION_delete(ctx->sessions,c);
+                        r=(SSL_SESSION *)lh_delete(ctx->sessions,c);
                         SSL_SESSION_list_remove(ctx,c);
                         }
 
@@ -716,18 +596,6 @@ void SSL_SESSION_free(SSL_SESSION *ss)
 #ifndef OPENSSL_NO_TLSEXT
         if (ss->tlsext_hostname != NULL) OPENSSL_free(ss->tlsext_hostname);
         if (ss->tlsext_tick != NULL) OPENSSL_free(ss->tlsext_tick);
-#ifndef OPENSSL_NO_EC
-        ss->tlsext_ecpointformatlist_length = 0;
-        if (ss->tlsext_ecpointformatlist != NULL) OPENSSL_free(ss->tlsext_ecpointformatlist);
-        ss->tlsext_ellipticcurvelist_length = 0;
-        if (ss->tlsext_ellipticcurvelist != NULL) OPENSSL_free(ss->tlsext_ellipticcurvelist);
-#endif /* OPENSSL_NO_EC */
-#endif
-#ifndef OPENSSL_NO_PSK
-        if (ss->psk_identity_hint != NULL)
-                OPENSSL_free(ss->psk_identity_hint);
-        if (ss->psk_identity != NULL)
-                OPENSSL_free(ss->psk_identity);
 #endif
         OPENSSL_cleanse(ss,sizeof(*ss));
         OPENSSL_free(ss);
@@ -736,7 +604,7 @@ void SSL_SESSION_free(SSL_SESSION *ss)
 int SSL_set_session(SSL *s, SSL_SESSION *session)
         {
         int ret=0;
-        const SSL_METHOD *meth;
+        SSL_METHOD *meth;
 
         if (session != NULL)
                 {
@@ -839,75 +707,20 @@ long SSL_CTX_get_timeout(const SSL_CTX *s)
         return(s->session_timeout);
         }
 
-#ifndef OPENSSL_NO_TLSEXT
-int SSL_set_session_secret_cb(SSL *s, int (*tls_session_secret_cb)(SSL *s, void *secret, int *secret_len,
-        STACK_OF(SSL_CIPHER) *peer_ciphers, SSL_CIPHER **cipher, void *arg), void *arg)
-        {
-        if (s == NULL) return(0);
-        s->tls_session_secret_cb = tls_session_secret_cb;
-        s->tls_session_secret_cb_arg = arg;
-        return(1);
-        }
-
-int SSL_set_session_ticket_ext_cb(SSL *s, tls_session_ticket_ext_cb_fn cb,
-                                  void *arg)
-        {
-        if (s == NULL) return(0);
-        s->tls_session_ticket_ext_cb = cb;
-        s->tls_session_ticket_ext_cb_arg = arg;
-        return(1);
-        }
-
-int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len)
-        {
-        if (s->version >= TLS1_VERSION)
-                {
-                if (s->tlsext_session_ticket)
-                        {
-                        OPENSSL_free(s->tlsext_session_ticket);
-                        s->tlsext_session_ticket = NULL;
-                        }
-
-                s->tlsext_session_ticket = OPENSSL_malloc(sizeof(TLS_SESSION_TICKET_EXT) + ext_len);
-                if (!s->tlsext_session_ticket)
-                        {
-                        SSLerr(SSL_F_SSL_SET_SESSION_TICKET_EXT, ERR_R_MALLOC_FAILURE);
-                        return 0;
-                        }
-
-                if (ext_data)
-                        {
-                        s->tlsext_session_ticket->length = ext_len;
-                        s->tlsext_session_ticket->data = s->tlsext_session_ticket + 1;
-                        memcpy(s->tlsext_session_ticket->data, ext_data, ext_len);
-                        }
-                else
-                        {
-                        s->tlsext_session_ticket->length = 0;
-                        s->tlsext_session_ticket->data = NULL;
-                        }
-
-                return 1;
-                }
-
-        return 0;
-        }
-#endif /* OPENSSL_NO_TLSEXT */
-
 typedef struct timeout_param_st
         {
         SSL_CTX *ctx;
         long time;
-        LHASH_OF(SSL_SESSION) *cache;
+        LHASH *cache;
         } TIMEOUT_PARAM;
 
-static void timeout_doall_arg(SSL_SESSION *s, TIMEOUT_PARAM *p)
+static void timeout(SSL_SESSION *s, TIMEOUT_PARAM *p)
         {
         if ((p->time == 0) || (p->time > (s->time+s->timeout))) /* timeout */
                 {
                 /* The reason we don't call SSL_CTX_remove_session() is to
                  * save on locking overhead */
-                (void)lh_SSL_SESSION_delete(p->cache,s);
+                lh_delete(p->cache,s);
                 SSL_SESSION_list_remove(p->ctx,s);
                 s->not_resumable=1;
                 if (p->ctx->remove_session_cb != NULL)
@@ -916,7 +729,7 @@ static void timeout_doall_arg(SSL_SESSION *s, TIMEOUT_PARAM *p)
                 }
         }
 
-static IMPLEMENT_LHASH_DOALL_ARG_FN(timeout, SSL_SESSION, TIMEOUT_PARAM)
+static IMPLEMENT_LHASH_DOALL_ARG_FN(timeout, SSL_SESSION *, TIMEOUT_PARAM *)
 
 void SSL_CTX_flush_sessions(SSL_CTX *s, long t)
         {
@@ -928,11 +741,10 @@ void SSL_CTX_flush_sessions(SSL_CTX *s, long t)
         if (tp.cache == NULL) return;
         tp.time=t;
         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-        i=CHECKED_LHASH_OF(SSL_SESSION, tp.cache)->down_load;
-        CHECKED_LHASH_OF(SSL_SESSION, tp.cache)->down_load=0;
-        lh_SSL_SESSION_doall_arg(tp.cache, LHASH_DOALL_ARG_FN(timeout),
-                                 TIMEOUT_PARAM, &tp);
-        CHECKED_LHASH_OF(SSL_SESSION, tp.cache)->down_load=i;
+        i=tp.cache->down_load;
+        tp.cache->down_load=0;
+        lh_doall_arg(tp.cache, LHASH_DOALL_ARG_FN(timeout), &tp);
+        tp.cache->down_load=i;
         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
         }
 
@@ -1092,4 +904,3 @@ void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,
         ctx->app_verify_cookie_cb=cb;
         }
 
-IMPLEMENT_PEM_rw(SSL_SESSION, SSL_SESSION, PEM_STRING_SSL_SESSION, SSL_SESSION)