Upgrade chrome's OpenSSL to same version Android ships with.

openssl/ssl/ssl_sess.c

 /* ssl/ssl_sess.c */
 /* 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
@@ skipping 37 matching lines @@
  * 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-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>
 #include <openssl/rand.h>
 #ifndef OPENSSL_NO_ENGINE
 #include <openssl/engine.h>
 #endif
 #include "ssl_locl.h"
 
 static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s);
@@ skipping 52 matching lines @@
 
         ss->verify_result = 1; /* avoid 0 (= X509_V_OK) just in case */
         ss->references=1;
         ss->timeout=60*5+4; /* 5 minute timeout by default */
         ss->time=(unsigned long)time(NULL);
         ss->prev=NULL;
         ss->next=NULL;
         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);
         }
 
 const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s, unsigned int *len)
         {
         if(len)
                 *len = s->session_id_length;
         return s->session_id;
         }
 
@@ skipping 23 matching lines @@
          * but the probability of a collision is negligible, and
          * we could not prevent the concurrent creation of sessions
          * with identical IDs since we currently don't have means
          * to atomically check whether a session ID already exists
          * and make a reservation for it if it does not
          * (this problem applies to the internal cache as well).
          */
         return 0;
 }
 
+void SSL_set_session_creation_enabled (SSL *s, int creation_enabled)
+        {
+        s->session_creation_enabled = creation_enabled;
+        }
+
 int ssl_get_new_session(SSL *s, int session)
         {
         /* This gets used by clients and servers. */
 
         unsigned int tmp;
         SSL_SESSION *ss=NULL;
         GEN_SESSION_CB cb = def_generate_session_id;
 
+        /* caller should check this if they can do better error handling */
+        if (!s->session_creation_enabled) return(0);
         if ((ss=SSL_SESSION_new()) == NULL) return(0);
 
         /* If the context has a default timeout, use it */
-        if (s->ctx->session_timeout == 0)
+        if (s->session_ctx->session_timeout == 0)
                 ss->timeout=SSL_get_default_timeout(s);
         else
-                ss->timeout=s->ctx->session_timeout;
+                ss->timeout=s->session_ctx->session_timeout;
 
         if (s->session != NULL)
                 {
                 SSL_SESSION_free(s->session);
                 s->session=NULL;
                 }
 
         if (session)
                 {
                 if (s->version == SSL2_VERSION)
@@ skipping 32 matching lines @@
                 if (s->tlsext_ticket_expected)
                         {
                         ss->session_id_length = 0;
                         goto sess_id_done;
                         }
 #endif
                 /* Choose which callback will set the session ID */
                 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
                 if(s->generate_session_id)
                         cb = s->generate_session_id;
-                else if(s->ctx->generate_session_id)
-                        cb = s->ctx->generate_session_id;
+                else if(s->session_ctx->generate_session_id)
+                        cb = s->session_ctx->generate_session_id;
                 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
                 /* Choose a session ID */
                 tmp = ss->session_id_length;
                 if(!cb(s, ss->session_id, &tmp))
                         {
                         /* The callback failed */
                         SSLerr(SSL_F_SSL_GET_NEW_SESSION,
                                 SSL_R_SSL_SESSION_ID_CALLBACK_FAILED);
                         SSL_SESSION_free(ss);
                         return(0);
@@ skipping 25 matching lines @@
 #ifndef OPENSSL_NO_TLSEXT
                 sess_id_done:
                 if (s->tlsext_hostname) {
                         ss->tlsext_hostname = BUF_strdup(s->tlsext_hostname);
                         if (ss->tlsext_hostname == NULL) {
                                 SSLerr(SSL_F_SSL_GET_NEW_SESSION, ERR_R_INTERNAL_ERROR);
                                 SSL_SESSION_free(ss);
                                 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
                 {
                 ss->session_id_length=0;
                 }
 
         if (s->sid_ctx_length > sizeof ss->sid_ctx)
                 {
                 SSLerr(SSL_F_SSL_GET_NEW_SESSION, ERR_R_INTERNAL_ERROR);
@@ skipping 12 matching lines @@
 int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
                         const unsigned char *limit)
         {
         /* This is used only by servers. */
 
         SSL_SESSION *ret=NULL;
         int fatal = 0;
 #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;
         else if (!ret && !(s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
 #else
         if (len == 0)
                 goto err;
-        if (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
+        if (!(s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
 #endif
                 {
                 SSL_SESSION data;
                 data.ssl_version=s->version;
                 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=(SSL_SESSION *)lh_retrieve(s->ctx->sessions,&data);
+                ret=lh_SSL_SESSION_retrieve(s->session_ctx->sessions,&data);
                 if (ret != NULL)
                     /* don't allow other threads to steal it: */
                     CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
                 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
                 }
 
         if (ret == NULL)
                 {
                 int copy=1;
         
-                s->ctx->stats.sess_miss++;
+                s->session_ctx->stats.sess_miss++;
                 ret=NULL;
-                if (s->ctx->get_session_cb != NULL
-                    && (ret=s->ctx->get_session_cb(s,session_id,len,&copy))
+                if (s->session_ctx->get_session_cb != NULL
+                    && (ret=s->session_ctx->get_session_cb(s,session_id,len,&copy))
                        != NULL)
                         {
-                        s->ctx->stats.sess_cb_hit++;
+                        s->session_ctx->stats.sess_cb_hit++;
 
                         /* Increment reference count now if the session callback
                          * asks us to do so (note that if the session structures
                          * returned by the callback are shared between threads,
                          * it must handle the reference count itself [i.e. copy == 0],
                          * or things won't be thread-safe). */
                         if (copy)
                                 CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
 
                         /* Add the externally cached session to the internal
                          * cache as well if and only if we are supposed to. */
-                        if(!(s->ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_STORE))
+                        if(!(s->session_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->ctx,ret);
+                                SSL_CTX_add_session(s->session_ctx,ret);
                         }
                 if (ret == NULL)
                         goto err;
                 }
 
         /* Now ret is non-NULL, and we own one of its reference counts. */
 
         if (ret->sid_ctx_length != s->sid_ctx_length
             || memcmp(ret->sid_ctx,s->sid_ctx,ret->sid_ctx_length))
                 {
@@ skipping 46 matching lines @@
 
         /* If a thread got the session, then 'swaped', and another got
          * it and then due to a time-out decided to 'OPENSSL_free' it we could
          * be in trouble.  So I'll increment it now, then double decrement
          * later - am I speaking rubbish?. */
         CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
 #endif
 
         if (ret->timeout < (long)(time(NULL) - ret->time)) /* timeout */
                 {
-                s->ctx->stats.sess_timeout++;
+                s->session_ctx->stats.sess_timeout++;
                 /* remove it from the cache */
-                SSL_CTX_remove_session(s->ctx,ret);
+                SSL_CTX_remove_session(s->session_ctx,ret);
                 goto err;
                 }
 
-        s->ctx->stats.sess_hit++;
+        s->session_ctx->stats.sess_hit++;
 
         /* ret->time=time(NULL); */ /* rezero timeout? */
         /* again, just leave the session 
          * if it is the same session, we have just incremented and
          * then decremented the reference count :-) */
         if (s->session != NULL)
                 SSL_SESSION_free(s->session);
         s->session=ret;
         s->verify_result = s->session->verify_result;
         return(1);
@@ skipping 12 matching lines @@
         int ret=0;
         SSL_SESSION *s;
 
         /* add just 1 reference count for the SSL_CTX's session cache
          * even though it has two ways of access: each session is in a
          * doubly linked list and an lhash */
         CRYPTO_add(&c->references,1,CRYPTO_LOCK_SSL_SESSION);
         /* if session c is in already in cache, we take back the increment later */
 
         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-        s=(SSL_SESSION *)lh_insert(ctx->sessions,c);
+        s=lh_SSL_SESSION_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
          * ctx->sessions), or we're in trouble. */
         if (s != NULL && s != c)
                 {
                 /* We *are* in trouble ... */
                 SSL_SESSION_list_remove(ctx,s);
                 SSL_SESSION_free(s);
                 /* ... so pretend the other session did not exist in cache
@@ skipping 45 matching lines @@
 }
 
 static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
         {
         SSL_SESSION *r;
         int ret=0;
 
         if ((c != NULL) && (c->session_id_length != 0))
                 {
                 if(lck) CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-                if ((r = (SSL_SESSION *)lh_retrieve(ctx->sessions,c)) == c)
+                if ((r = lh_SSL_SESSION_retrieve(ctx->sessions,c)) == c)
                         {
                         ret=1;
-                        r=(SSL_SESSION *)lh_delete(ctx->sessions,c);
+                        r=lh_SSL_SESSION_delete(ctx->sessions,c);
                         SSL_SESSION_list_remove(ctx,c);
                         }
 
                 if(lck) CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
 
                 if (ret)
                         {
                         r->not_resumable=1;
                         if (ctx->remove_session_cb != NULL)
                                 ctx->remove_session_cb(ctx,r);
@@ skipping 29 matching lines @@
 
         OPENSSL_cleanse(ss->key_arg,sizeof ss->key_arg);
         OPENSSL_cleanse(ss->master_key,sizeof ss->master_key);
         OPENSSL_cleanse(ss->session_id,sizeof ss->session_id);
         if (ss->sess_cert != NULL) ssl_sess_cert_free(ss->sess_cert);
         if (ss->peer != NULL) X509_free(ss->peer);
         if (ss->ciphers != NULL) sk_SSL_CIPHER_free(ss->ciphers);
 #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);
         }
 
 int SSL_set_session(SSL *s, SSL_SESSION *session)
         {
         int ret=0;
-        SSL_METHOD *meth;
+        const SSL_METHOD *meth;
 
         if (session != NULL)
                 {
                 meth=s->ctx->method->get_ssl_method(session->ssl_version);
                 if (meth == NULL)
                         meth=s->method->get_ssl_method(session->ssl_version);
                 if (meth == NULL)
                         {
                         SSLerr(SSL_F_SSL_SET_SESSION,SSL_R_UNABLE_TO_FIND_SSL_METHOD);
                         return(0);
@@ skipping 82 matching lines @@
         s->session_timeout=t;
         return(l);
         }
 
 long SSL_CTX_get_timeout(const SSL_CTX *s)
         {
         if (s == NULL) return(0);
         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 *cache;
+        LHASH_OF(SSL_SESSION) *cache;
         } TIMEOUT_PARAM;
 
-static void timeout(SSL_SESSION *s, TIMEOUT_PARAM *p)
+static void timeout_doall_arg(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 */
-                lh_delete(p->cache,s);
+                (void)lh_SSL_SESSION_delete(p->cache,s);
                 SSL_SESSION_list_remove(p->ctx,s);
                 s->not_resumable=1;
                 if (p->ctx->remove_session_cb != NULL)
                         p->ctx->remove_session_cb(p->ctx,s);
                 SSL_SESSION_free(s);
                 }
         }
 
-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)
         {
         unsigned long i;
         TIMEOUT_PARAM tp;
 
         tp.ctx=s;
         tp.cache=s->sessions;
         if (tp.cache == NULL) return;
         tp.time=t;
         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-        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;
+        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;
         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
         }
 
 int ssl_clear_bad_session(SSL *s)
         {
         if (    (s->session != NULL) &&
                 !(s->shutdown & SSL_SENT_SHUTDOWN) &&
                 !(SSL_in_init(s) || SSL_in_before(s)))
                 {
                 SSL_CTX_remove_session(s->ctx,s->session);
@@ skipping 139 matching lines @@
         {
         ctx->app_gen_cookie_cb=cb;
         }
 
 void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,
         int (*cb)(SSL *ssl, unsigned char *cookie, unsigned int cookie_len))
         {
         ctx->app_verify_cookie_cb=cb;
         }
 
+IMPLEMENT_PEM_rw(SSL_SESSION, SSL_SESSION, PEM_STRING_SSL_SESSION, SSL_SESSION)