1 files changed, 539 insertions, 555 deletions

diff --git a/src/lib/libssl/ssl_sess.c b/src/lib/libssl/ssl_sess.c
index ad40fadd02..b29115862b 100644
--- a/src/lib/libssl/ssl_sess.c
+++ b/src/lib/libssl/ssl_sess.c
@@ -144,68 +144,74 @@
 #include "ssl_locl.h"
 
 static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s);
-static void SSL_SESSION_list_add(SSL_CTX *ctx,SSL_SESSION *s);
+static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s);
 static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck);
 
-SSL_SESSION *SSL_get_session(const SSL *ssl)
+SSL_SESSION
+*SSL_get_session(const SSL *ssl)
 /* aka SSL_get0_session; gets 0 objects, just returns a copy of the pointer */
-        {
-        return(ssl->session);
-        }
+{
+        return (ssl->session);
+}
 
-SSL_SESSION *SSL_get1_session(SSL *ssl)
+SSL_SESSION
+*SSL_get1_session(SSL *ssl)
 /* variant of SSL_get_session: caller really gets something */
-        {
+{
         SSL_SESSION *sess;
         /* Need to lock this all up rather than just use CRYPTO_add so that
          * somebody doesn't free ssl->session between when we check it's
          * non-null and when we up the reference count. */
         CRYPTO_w_lock(CRYPTO_LOCK_SSL_SESSION);
         sess = ssl->session;
-        if(sess)
+        if (sess)
                 sess->references++;
         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_SESSION);
-        return(sess);
-        }
+        return (sess);
+}
 
-int SSL_SESSION_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
-             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
-        {
+int
+SSL_SESSION_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
+    CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
+{
         return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_SESSION, argl, argp,
-                        new_func, dup_func, free_func);
-        }
+        new_func, dup_func, free_func);
+}
 
-int SSL_SESSION_set_ex_data(SSL_SESSION *s, int idx, void *arg)
-        {
-        return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
-        }
+int
+SSL_SESSION_set_ex_data(SSL_SESSION *s, int idx, void *arg)
+{
+        return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
+}
 
-void *SSL_SESSION_get_ex_data(const SSL_SESSION *s, int idx)
-        {
-        return(CRYPTO_get_ex_data(&s->ex_data,idx));
-        }
+void
+*SSL_SESSION_get_ex_data(const SSL_SESSION *s, int idx)
+{
+        return (CRYPTO_get_ex_data(&s->ex_data, idx));
+}
 
-SSL_SESSION *SSL_SESSION_new(void)
-        {
+SSL_SESSION
+*SSL_SESSION_new(void)
+{
         SSL_SESSION *ss;
 
-        ss=(SSL_SESSION *)OPENSSL_malloc(sizeof(SSL_SESSION));
-        if (ss == NULL)
-                {
-                SSLerr(SSL_F_SSL_SESSION_NEW,ERR_R_MALLOC_FAILURE);
-                return(0);
-                }
-        memset(ss,0,sizeof(SSL_SESSION));
+        ss = (SSL_SESSION *)OPENSSL_malloc(sizeof(SSL_SESSION));
+        if (ss == NULL) {
+                SSLerr(SSL_F_SSL_SESSION_NEW, ERR_R_MALLOC_FAILURE);
+                return (0);
+        }
+        memset(ss, 0, sizeof(SSL_SESSION));
 
         ss->verify_result = 1; /* avoid 0 (= X509_V_OK) just in case */
-        ss->references=1;
+        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;
+        ss->time = (unsigned long)time(NULL);
+        ss->prev = NULL;
+        ss->next = NULL;
+        ss->compress_meth = 0;
 #ifndef OPENSSL_NO_TLSEXT
-        ss->tlsext_hostname = NULL; 
+        ss->tlsext_hostname = NULL;
+
 #ifndef OPENSSL_NO_EC
         ss->tlsext_ecpointformatlist_length = 0;
         ss->tlsext_ecpointformatlist = NULL;
@@ -215,26 +221,28 @@ SSL_SESSION *SSL_SESSION_new(void)
 #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;
+        ss->psk_identity_hint = NULL;
+        ss->psk_identity = NULL;
 #endif
 #ifndef OPENSSL_NO_SRP
-        ss->srp_username=NULL;
+        ss->srp_username = NULL;
 #endif
-        return(ss);
-        }
+        return (ss);
+}
 
-const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s, unsigned int *len)
-        {
-        if(len)
+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;
-        }
+}
 
-unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION *s)
-        {
+unsigned int
+SSL_SESSION_get_compress_id(const SSL_SESSION *s)
+{
         return s->compress_meth;
-        }
+}
 
 /* Even with SSLv2, we have 16 bytes (128 bits) of session ID space. SSLv3/TLSv1
  * has 32 bytes (256 bits). As such, filling the ID with random gunk repeatedly
@@ -246,16 +254,17 @@ unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION *s)
  * store that many sessions is perhaps a more interesting question ... */
 
 #define MAX_SESS_ID_ATTEMPTS 10
-static int def_generate_session_id(const SSL *ssl, unsigned char *id,
-                                unsigned int *id_len)
+static int
+def_generate_session_id(const SSL *ssl, unsigned char *id,
+    unsigned int *id_len)
 {
         unsigned int retry = 0;
         do
-                if (RAND_pseudo_bytes(id, *id_len) <= 0)
-                        return 0;
-        while(SSL_has_matching_session_id(ssl, id, *id_len) &&
-                (++retry < MAX_SESS_ID_ATTEMPTS));
-        if(retry < MAX_SESS_ID_ATTEMPTS)
+        if (RAND_pseudo_bytes(id, *id_len) <= 0)
+                return 0;
+        while (SSL_has_matching_session_id(ssl, id, *id_len) &&
+        (++retry < MAX_SESS_ID_ATTEMPTS));
+        if (retry < MAX_SESS_ID_ATTEMPTS)
                 return 1;
         /* else - woops a session_id match */
         /* XXX We should also check the external cache --
@@ -269,120 +278,100 @@ static int def_generate_session_id(const SSL *ssl, unsigned char *id,
         return 0;
 }
 
-int ssl_get_new_session(SSL *s, int session)
-        {
+int
+ssl_get_new_session(SSL *s, int session)
+{
         /* This gets used by clients and servers. */
 
         unsigned int tmp;
-        SSL_SESSION *ss=NULL;
+        SSL_SESSION *ss = NULL;
         GEN_SESSION_CB cb = def_generate_session_id;
 
-        if ((ss=SSL_SESSION_new()) == NULL) return(0);
+        if ((ss = SSL_SESSION_new()) == NULL) return (0);
 
         /* If the context has a default timeout, use it */
         if (s->session_ctx->session_timeout == 0)
-                ss->timeout=SSL_get_default_timeout(s);
+                ss->timeout = SSL_get_default_timeout(s);
         else
-                ss->timeout=s->session_ctx->session_timeout;
+                ss->timeout = s->session_ctx->session_timeout;
 
-        if (s->session != NULL)
-                {
+        if (s->session != NULL) {
                 SSL_SESSION_free(s->session);
-                s->session=NULL;
-                }
+                s->session = NULL;
+        }
 
-        if (session)
-                {
-                if (s->version == SSL2_VERSION)
-                        {
-                        ss->ssl_version=SSL2_VERSION;
-                        ss->session_id_length=SSL2_SSL_SESSION_ID_LENGTH;
-                        }
-                else if (s->version == SSL3_VERSION)
-                        {
-                        ss->ssl_version=SSL3_VERSION;
-                        ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
-                        }
-                else if (s->version == TLS1_VERSION)
-                        {
-                        ss->ssl_version=TLS1_VERSION;
-                        ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
-                        }
-                else if (s->version == TLS1_1_VERSION)
-                        {
-                        ss->ssl_version=TLS1_1_VERSION;
-                        ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
-                        }
-                else if (s->version == TLS1_2_VERSION)
-                        {
-                        ss->ssl_version=TLS1_2_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;
-                        ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
-                        }
-                else
-                        {
-                        SSLerr(SSL_F_SSL_GET_NEW_SESSION,SSL_R_UNSUPPORTED_SSL_VERSION);
+        if (session) {
+                if (s->version == SSL2_VERSION) {
+                        ss->ssl_version = SSL2_VERSION;
+                        ss->session_id_length = SSL2_SSL_SESSION_ID_LENGTH;
+                } else if (s->version == SSL3_VERSION) {
+                        ss->ssl_version = SSL3_VERSION;
+                        ss->session_id_length = SSL3_SSL_SESSION_ID_LENGTH;
+                } else if (s->version == TLS1_VERSION) {
+                        ss->ssl_version = TLS1_VERSION;
+                        ss->session_id_length = SSL3_SSL_SESSION_ID_LENGTH;
+                } else if (s->version == TLS1_1_VERSION) {
+                        ss->ssl_version = TLS1_1_VERSION;
+                        ss->session_id_length = SSL3_SSL_SESSION_ID_LENGTH;
+                } else if (s->version == TLS1_2_VERSION) {
+                        ss->ssl_version = TLS1_2_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;
+                        ss->session_id_length = SSL3_SSL_SESSION_ID_LENGTH;
+                } else {
+                        SSLerr(SSL_F_SSL_GET_NEW_SESSION, SSL_R_UNSUPPORTED_SSL_VERSION);
                         SSL_SESSION_free(ss);
-                        return(0);
-                        }
+                        return (0);
+                }
 #ifndef OPENSSL_NO_TLSEXT
                 /* If RFC4507 ticket use empty session ID */
-                if (s->tlsext_ticket_expected)
-                        {
+                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)
+                if (s->generate_session_id)
                         cb = s->generate_session_id;
-                else if(s->session_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))
-                        {
+                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_R_SSL_SESSION_ID_CALLBACK_FAILED);
                         SSL_SESSION_free(ss);
-                        return(0);
-                        }
+                        return (0);
+                }
                 /* Don't allow the callback to set the session length to zero.
                  * nor set it higher than it was. */
-                if(!tmp || (tmp > ss->session_id_length))
-                        {
+                if (!tmp || (tmp > ss->session_id_length)) {
                         /* The callback set an illegal length */
                         SSLerr(SSL_F_SSL_GET_NEW_SESSION,
-                                SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH);
+                        SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH);
                         SSL_SESSION_free(ss);
-                        return(0);
-                        }
+                        return (0);
+                }
                 /* If the session length was shrunk and we're SSLv2, pad it */
-                if((tmp < ss->session_id_length) && (s->version == SSL2_VERSION))
+                if ((tmp < ss->session_id_length) && (s->version == SSL2_VERSION))
                         memset(ss->session_id + tmp, 0, ss->session_id_length - tmp);
                 else
                         ss->session_id_length = tmp;
                 /* Finally, check for a conflict */
-                if(SSL_has_matching_session_id(s, ss->session_id,
-                                                ss->session_id_length))
-                        {
+                if (SSL_has_matching_session_id(s, ss->session_id,
+                        ss->session_id_length)) {
                         SSLerr(SSL_F_SSL_GET_NEW_SESSION,
-                                SSL_R_SSL_SESSION_ID_CONFLICT);
+                        SSL_R_SSL_SESSION_ID_CONFLICT);
                         SSL_SESSION_free(ss);
-                        return(0);
-                        }
+                        return (0);
+                }
 #ifndef OPENSSL_NO_TLSEXT
                 sess_id_done:
                 if (s->tlsext_hostname) {
@@ -391,55 +380,50 @@ int ssl_get_new_session(SSL *s, int session)
                                 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)
-                                {
+                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)
-                                {
+                }
+                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;
-                }
+        } else {
+                ss->session_id_length = 0;
+        }
 
-        if (s->sid_ctx_length > sizeof ss->sid_ctx)
-                {
+        if (s->sid_ctx_length > sizeof ss->sid_ctx) {
                 SSLerr(SSL_F_SSL_GET_NEW_SESSION, ERR_R_INTERNAL_ERROR);
                 SSL_SESSION_free(ss);
                 return 0;
-                }
-        memcpy(ss->sid_ctx,s->sid_ctx,s->sid_ctx_length);
-        ss->sid_ctx_length=s->sid_ctx_length;
-        s->session=ss;
-        ss->ssl_version=s->version;
+        }
+        memcpy(ss->sid_ctx, s->sid_ctx, s->sid_ctx_length);
+        ss->sid_ctx_length = s->sid_ctx_length;
+        s->session = ss;
+        ss->ssl_version = s->version;
         ss->verify_result = X509_V_OK;
 
-        return(1);
-        }
+        return (1);
+}
 
 /* ssl_get_prev attempts to find an SSL_SESSION to be used to resume this
  * connection. It is only called by servers.
@@ -460,12 +444,13 @@ int ssl_get_new_session(SSL *s, int session)
  *   - Both for new and resumed sessions, s->tlsext_ticket_expected is set to 1
  *     if the server should issue a new session ticket (to 0 otherwise).
  */
-int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
-                        const unsigned char *limit)
-        {
+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;
+        SSL_SESSION *ret = NULL;
         int fatal = 0;
         int try_session_cache = 1;
 #ifndef OPENSSL_NO_TLSEXT
@@ -480,8 +465,7 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
 
 #ifndef OPENSSL_NO_TLSEXT
         r = tls1_process_ticket(s, session_id, len, limit, &ret); /* sets s->tlsext_ticket_expected */
-        switch (r)
-                {
+        switch (r) {
         case -1: /* Error during processing */
                 fatal = 1;
                 goto err;
@@ -494,39 +478,35 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
                 break;
         default:
                 abort();
-                }
+        }
 #endif
 
         if (try_session_cache &&
-            ret == NULL &&
-            !(s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
-                {
+                ret == NULL &&
+        !(s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP)) {
                 SSL_SESSION data;
-                data.ssl_version=s->version;
-                data.session_id_length=len;
+                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=lh_SSL_SESSION_retrieve(s->session_ctx->sessions,&data);
-                if (ret != NULL)
-                        {
+                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_add(&ret->references, 1, CRYPTO_LOCK_SSL_SESSION);
+                }
                 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
                 if (ret == NULL)
                         s->session_ctx->stats.sess_miss++;
-                }
+        }
 
         if (try_session_cache &&
-            ret == NULL &&
-            s->session_ctx->get_session_cb != NULL)
-                {
-                int copy=1;
-        
-                if ((ret=s->session_ctx->get_session_cb(s,session_id,len,&copy)))
-                        {
+                ret == NULL &&
+        s->session_ctx->get_session_cb != NULL) {
+                int copy = 1;
+
+                if ((ret = s->session_ctx->get_session_cb(s, session_id, len, &copy))) {
                         s->session_ctx->stats.sess_cb_hit++;
 
                         /* Increment reference count now if the session callback
@@ -535,16 +515,16 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
                          * 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);
+                                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->session_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->session_ctx,ret);
-                        }
+                        SSL_CTX_add_session(s->session_ctx, ret);
                 }
+        }
 
         if (ret == NULL)
                 goto err;
@@ -552,15 +532,13 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
         /* 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))
-                {
+                || memcmp(ret->sid_ctx, s->sid_ctx, ret->sid_ctx_length)) {
                 /* We have the session requested by the client, but we don't
                  * want to use it in this context. */
                 goto err; /* treat like cache miss */
-                }
-        
-        if((s->verify_mode & SSL_VERIFY_PEER) && s->sid_ctx_length == 0)
-                {
+        }
+
+        if ((s->verify_mode & SSL_VERIFY_PEER) && s->sid_ctx_length == 0) {
                 /* We can't be sure if this session is being used out of
                  * context, which is especially important for SSL_VERIFY_PEER.
                  * The application should have used SSL[_CTX]_set_session_id_context.
@@ -570,87 +548,83 @@ int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len,
                  * applications to effectively disable the session cache by
                  * accident without anyone noticing).
                  */
-                
-                SSLerr(SSL_F_SSL_GET_PREV_SESSION,SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED);
+
+                SSLerr(SSL_F_SSL_GET_PREV_SESSION, SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED);
                 fatal = 1;
                 goto err;
-                }
+        }
 
-        if (ret->cipher == NULL)
-                {
-                unsigned char buf[5],*p;
+        if (ret->cipher == NULL) {
+                unsigned char buf[5], *p;
                 unsigned long l;
 
-                p=buf;
-                l=ret->cipher_id;
-                l2n(l,p);
-                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]));
+                p = buf;
+                l = ret->cipher_id;
+                l2n(l, p);
+                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]));
                 if (ret->cipher == NULL)
                         goto err;
-                }
+        }
 
         if (ret->timeout < (long)(time(NULL) - ret->time)) /* timeout */
-                {
+        {
                 s->session_ctx->stats.sess_timeout++;
-                if (try_session_cache)
-                        {
+                if (try_session_cache) {
                         /* session was from the cache, so remove it */
-                        SSL_CTX_remove_session(s->session_ctx,ret);
-                        }
-                goto err;
+                        SSL_CTX_remove_session(s->session_ctx, ret);
                 }
+                goto err;
+        }
 
         s->session_ctx->stats.sess_hit++;
 
         if (s->session != NULL)
                 SSL_SESSION_free(s->session);
-        s->session=ret;
+        s->session = ret;
         s->verify_result = s->session->verify_result;
         return 1;
 
- err:
-        if (ret != NULL)
-                {
+        err:
+        if (ret != NULL) {
                 SSL_SESSION_free(ret);
 #ifndef OPENSSL_NO_TLSEXT
-                if (!try_session_cache)
-                        {
+                if (!try_session_cache) {
                         /* The session was from a ticket, so we should
                          * issue a ticket for the new session */
                         s->tlsext_ticket_expected = 1;
-                        }
-#endif
                 }
+#endif
+        }
         if (fatal)
                 return -1;
         else
                 return 0;
-        }
+}
 
-int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
-        {
-        int ret=0;
+int
+SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
+{
+        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);
+        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=lh_SSL_SESSION_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)
-                {
+        if (s != NULL && s != c) {
                 /* We *are* in trouble ... */
-                SSL_SESSION_list_remove(ctx,s);
+                SSL_SESSION_list_remove(ctx, s);
                 SSL_SESSION_free(s);
                 /* ... so pretend the other session did not exist in cache
                  * (we cannot handle two SSL_SESSION structures with identical
@@ -658,114 +632,117 @@ int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
                  * two threads concurrently obtain the same session from an external
                  * cache) */
                 s = NULL;
-                }
+        }
 
-        /* Put at the head of the queue unless it is already in the cache */
+        /* Put at the head of the queue unless it is already in the cache */
         if (s == NULL)
-                SSL_SESSION_list_add(ctx,c);
+                SSL_SESSION_list_add(ctx, c);
 
-        if (s != NULL)
-                {
+        if (s != NULL) {
                 /* existing cache entry -- decrement previously incremented reference
                  * count because it already takes into account the cache */
 
                 SSL_SESSION_free(s); /* s == c */
-                ret=0;
-                }
-        else
-                {
+                ret = 0;
+        } else {
                 /* new cache entry -- remove old ones if cache has become too large */
-                
-                ret=1;
 
-                if (SSL_CTX_sess_get_cache_size(ctx) > 0)
-                        {
+                ret = 1;
+
+                if (SSL_CTX_sess_get_cache_size(ctx) > 0) {
                         while (SSL_CTX_sess_number(ctx) >
-                                SSL_CTX_sess_get_cache_size(ctx))
-                                {
+                        SSL_CTX_sess_get_cache_size(ctx)) {
                                 if (!remove_session_lock(ctx,
                                         ctx->session_cache_tail, 0))
-                                        break;
+                                break;
                                 else
                                         ctx->stats.sess_cache_full++;
-                                }
                         }
                 }
-        CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
-        return(ret);
         }
+        CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
+        return (ret);
+}
 
-int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
+int
+SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
 {
         return remove_session_lock(ctx, c, 1);
 }
 
-static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
-        {
+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 = lh_SSL_SESSION_retrieve(ctx->sessions,c)) == c)
-                        {
-                        ret=1;
-                        r=lh_SSL_SESSION_delete(ctx->sessions,c);
-                        SSL_SESSION_list_remove(ctx,c);
-                        }
+        int ret = 0;
+
+        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) {
+                        ret = 1;
+                        r = lh_SSL_SESSION_delete(ctx->sessions, c);
+                        SSL_SESSION_list_remove(ctx, c);
+                }
 
-                if(lck) CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
+                if (lck)
+                        CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
 
-                if (ret)
-                        {
-                        r->not_resumable=1;
+                if (ret) {
+                        r->not_resumable = 1;
                         if (ctx->remove_session_cb != NULL)
-                                ctx->remove_session_cb(ctx,r);
+                                ctx->remove_session_cb(ctx, r);
                         SSL_SESSION_free(r);
-                        }
                 }
-        else
-                ret=0;
-        return(ret);
-        }
+        } else
+                ret = 0;
+        return (ret);
+}
 
-void SSL_SESSION_free(SSL_SESSION *ss)
-        {
+void
+SSL_SESSION_free(SSL_SESSION *ss)
+{
         int i;
 
-        if(ss == NULL)
-            return;
+        if (ss == NULL)
+                return;
 
-        i=CRYPTO_add(&ss->references,-1,CRYPTO_LOCK_SSL_SESSION);
+        i = CRYPTO_add(&ss->references, -1, CRYPTO_LOCK_SSL_SESSION);
 #ifdef REF_PRINT
-        REF_PRINT("SSL_SESSION",ss);
+        REF_PRINT("SSL_SESSION", ss);
 #endif
-        if (i > 0) return;
+        if (i > 0)
+                return;
 #ifdef REF_CHECK
-        if (i < 0)
-                {
-                fprintf(stderr,"SSL_SESSION_free, bad reference count\n");
+        if (i < 0) {
+                fprintf(stderr, "SSL_SESSION_free, bad reference count\n");
                 abort(); /* ok */
-                }
+        }
 #endif
 
         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data);
 
-        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);
+        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);
+        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);
+        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);
+        if (ss->tlsext_ellipticcurvelist != NULL)
+                OPENSSL_free(ss->tlsext_ellipticcurvelist);
 #endif /* OPENSSL_NO_EC */
 #endif
 #ifndef OPENSSL_NO_PSK
@@ -778,382 +755,389 @@ void SSL_SESSION_free(SSL_SESSION *ss)
         if (ss->srp_username != NULL)
                 OPENSSL_free(ss->srp_username);
 #endif
-        OPENSSL_cleanse(ss,sizeof(*ss));
+        OPENSSL_cleanse(ss, sizeof(*ss));
         OPENSSL_free(ss);
-        }
+}
 
-int SSL_set_session(SSL *s, SSL_SESSION *session)
-        {
-        int ret=0;
+int
+SSL_set_session(SSL *s, SSL_SESSION *session)
+{
+        int ret = 0;
         const SSL_METHOD *meth;
 
-        if (session != NULL)
-                {
-                meth=s->ctx->method->get_ssl_method(session->ssl_version);
+        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);
-                        }
+                        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);
+                }
 
-                if (meth != s->method)
-                        {
-                        if (!SSL_set_ssl_method(s,meth))
-                                return(0);
-                        }
+                if (meth != s->method) {
+                        if (!SSL_set_ssl_method(s, meth))
+                                return (0);
+                }
 
 #ifndef OPENSSL_NO_KRB5
-                if (s->kssl_ctx && !s->kssl_ctx->client_princ &&
-                    session->krb5_client_princ_len > 0)
-                {
-                    s->kssl_ctx->client_princ = (char *)OPENSSL_malloc(session->krb5_client_princ_len + 1);
-                    memcpy(s->kssl_ctx->client_princ,session->krb5_client_princ,
-                            session->krb5_client_princ_len);
-                    s->kssl_ctx->client_princ[session->krb5_client_princ_len] = '\0';
-                }
+                if (s->kssl_ctx && !s->kssl_ctx->client_princ &&
+                        session->krb5_client_princ_len > 0) {
+                        s->kssl_ctx->client_princ = (char *)OPENSSL_malloc(session->krb5_client_princ_len + 1);
+                        memcpy(s->kssl_ctx->client_princ, session->krb5_client_princ,
+                        session->krb5_client_princ_len);
+                        s->kssl_ctx->client_princ[session->krb5_client_princ_len] = '\0';
+                }
 #endif /* OPENSSL_NO_KRB5 */
 
                 /* CRYPTO_w_lock(CRYPTO_LOCK_SSL);*/
-                CRYPTO_add(&session->references,1,CRYPTO_LOCK_SSL_SESSION);
+                CRYPTO_add(&session->references, 1, CRYPTO_LOCK_SSL_SESSION);
                 if (s->session != NULL)
                         SSL_SESSION_free(s->session);
-                s->session=session;
+                s->session = session;
                 s->verify_result = s->session->verify_result;
                 /* CRYPTO_w_unlock(CRYPTO_LOCK_SSL);*/
-                ret=1;
-                }
-        else
-                {
-                if (s->session != NULL)
-                        {
+                ret = 1;
+        } else {
+                if (s->session != NULL) {
                         SSL_SESSION_free(s->session);
-                        s->session=NULL;
-                        }
+                        s->session = NULL;
+                }
 
-                meth=s->ctx->method;
-                if (meth != s->method)
-                        {
-                        if (!SSL_set_ssl_method(s,meth))
-                                return(0);
-                        }
-                ret=1;
+                meth = s->ctx->method;
+                if (meth != s->method) {
+                        if (!SSL_set_ssl_method(s, meth))
+                                return (0);
                 }
-        return(ret);
+                ret = 1;
         }
+        return (ret);
+}
 
-long SSL_SESSION_set_timeout(SSL_SESSION *s, long t)
-        {
-        if (s == NULL) return(0);
-        s->timeout=t;
-        return(1);
-        }
+long
+SSL_SESSION_set_timeout(SSL_SESSION *s, long t)
+{
+        if (s == NULL)
+                return (0);
+        s->timeout = t;
+        return (1);
+}
 
-long SSL_SESSION_get_timeout(const SSL_SESSION *s)
-        {
-        if (s == NULL) return(0);
-        return(s->timeout);
-        }
+long
+SSL_SESSION_get_timeout(const SSL_SESSION *s)
+{
+        if (s == NULL)
+                return (0);
+        return (s->timeout);
+}
 
-long SSL_SESSION_get_time(const SSL_SESSION *s)
-        {
-        if (s == NULL) return(0);
-        return(s->time);
-        }
+long
+SSL_SESSION_get_time(const SSL_SESSION *s)
+{
+        if (s == NULL)
+                return (0);
+        return (s->time);
+}
 
-long SSL_SESSION_set_time(SSL_SESSION *s, long t)
-        {
-        if (s == NULL) return(0);
-        s->time=t;
-        return(t);
-        }
+long
+SSL_SESSION_set_time(SSL_SESSION *s, long t)
+{
+        if (s == NULL)
+                return (0);
+        s->time = t;
+        return (t);
+}
 
-X509 *SSL_SESSION_get0_peer(SSL_SESSION *s)
-        {
+X509
+*SSL_SESSION_get0_peer(SSL_SESSION *s)
+{
         return s->peer;
-        }
+}
 
-int SSL_SESSION_set1_id_context(SSL_SESSION *s,const unsigned char *sid_ctx,
-                               unsigned int sid_ctx_len)
-        {
-        if(sid_ctx_len > SSL_MAX_SID_CTX_LENGTH)
-                {
-                SSLerr(SSL_F_SSL_SESSION_SET1_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
+int
+SSL_SESSION_set1_id_context(SSL_SESSION *s, const unsigned char *sid_ctx,
+    unsigned int sid_ctx_len)
+{
+        if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
+                SSLerr(SSL_F_SSL_SESSION_SET1_ID_CONTEXT, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
                 return 0;
-                }
-        s->sid_ctx_length=sid_ctx_len;
-        memcpy(s->sid_ctx,sid_ctx,sid_ctx_len);
+        }
+        s->sid_ctx_length = sid_ctx_len;
+        memcpy(s->sid_ctx, sid_ctx, sid_ctx_len);
 
         return 1;
-        }
+}
 
-long SSL_CTX_set_timeout(SSL_CTX *s, long t)
-        {
+long
+SSL_CTX_set_timeout(SSL_CTX *s, long t)
+{
         long l;
-        if (s == NULL) return(0);
-        l=s->session_timeout;
-        s->session_timeout=t;
-        return(l);
-        }
+        if (s == NULL)
+                return (0);
+        l = s->session_timeout;
+        s->session_timeout = t;
+        return (l);
+}
 
-long SSL_CTX_get_timeout(const SSL_CTX *s)
-        {
-        if (s == NULL) return(0);
-        return(s->session_timeout);
-        }
+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);
+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);
-        }
+        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);
+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);
-        }
+        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)
-                        {
+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)
-                        {
+                if (!s->tlsext_session_ticket) {
                         SSLerr(SSL_F_SSL_SET_SESSION_TICKET_EXT, ERR_R_MALLOC_FAILURE);
                         return 0;
-                        }
+                }
 
-                if (ext_data)
-                        {
+                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
-                        {
+                } 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
-        {
+typedef struct timeout_param_st {
         SSL_CTX *ctx;
         long time;
         LHASH_OF(SSL_SESSION) *cache;
-        } TIMEOUT_PARAM;
+} TIMEOUT_PARAM;
 
-static void timeout_doall_arg(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 */
-                (void)lh_SSL_SESSION_delete(p->cache,s);
-                SSL_SESSION_list_remove(p->ctx,s);
-                s->not_resumable=1;
+                (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);
+                        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)
-        {
+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;
+        tp.ctx = s;
+        tp.cache = s->sessions;
+        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;
+        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;
+        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) &&
+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);
-                return(1);
-                }
-        else
-                return(0);
-        }
+        !(SSL_in_init(s) || SSL_in_before(s))) {
+                SSL_CTX_remove_session(s->ctx, s->session);
+                return (1);
+        } else
+                return (0);
+}
 
 /* locked by SSL_CTX in the calling function */
-static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s)
-        {
-        if ((s->next == NULL) || (s->prev == NULL)) return;
+static void
+SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s)
+{
+        if ((s->next == NULL)
+                || (s->prev == NULL)) return;
 
         if (s->next == (SSL_SESSION *)&(ctx->session_cache_tail))
-                { /* last element in list */
+                        { /* last element in list */
                 if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head))
-                        { /* only one element in list */
-                        ctx->session_cache_head=NULL;
-                        ctx->session_cache_tail=NULL;
-                        }
-                else
-                        {
-                        ctx->session_cache_tail=s->prev;
-                        s->prev->next=(SSL_SESSION *)&(ctx->session_cache_tail);
-                        }
+                                { /* only one element in list */
+                        ctx->session_cache_head = NULL;
+                        ctx->session_cache_tail = NULL;
+                } else {
+                        ctx->session_cache_tail = s->prev;
+                        s->prev->next = (SSL_SESSION *)&(ctx->session_cache_tail);
                 }
-        else
-                {
+        } else {
                 if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head))
-                        { /* first element in list */
-                        ctx->session_cache_head=s->next;
-                        s->next->prev=(SSL_SESSION *)&(ctx->session_cache_head);
-                        }
-                else
-                        { /* middle of list */
-                        s->next->prev=s->prev;
-                        s->prev->next=s->next;
-                        }
+                                { /* first element in list */
+                        ctx->session_cache_head = s->next;
+                        s->next->prev = (SSL_SESSION *)&(ctx->session_cache_head);
+                } else
+                                { /* middle of list */
+                        s->next->prev = s->prev;
+                        s->prev->next = s->next;
                 }
-        s->prev=s->next=NULL;
         }
+        s->prev = s->next = NULL;
+}
 
-static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s)
-        {
+static void
+SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s)
+{
         if ((s->next != NULL) && (s->prev != NULL))
-                SSL_SESSION_list_remove(ctx,s);
-
-        if (ctx->session_cache_head == NULL)
-                {
-                ctx->session_cache_head=s;
-                ctx->session_cache_tail=s;
-                s->prev=(SSL_SESSION *)&(ctx->session_cache_head);
-                s->next=(SSL_SESSION *)&(ctx->session_cache_tail);
-                }
-        else
-                {
-                s->next=ctx->session_cache_head;
-                s->next->prev=s;
-                s->prev=(SSL_SESSION *)&(ctx->session_cache_head);
-                ctx->session_cache_head=s;
-                }
+                SSL_SESSION_list_remove(ctx, s);
+
+        if (ctx->session_cache_head == NULL) {
+                ctx->session_cache_head = s;
+                ctx->session_cache_tail = s;
+                s->prev = (SSL_SESSION *)&(ctx->session_cache_head);
+                s->next = (SSL_SESSION *)&(ctx->session_cache_tail);
+        } else {
+                s->next = ctx->session_cache_head;
+                s->next->prev = s;
+                s->prev = (SSL_SESSION *)&(ctx->session_cache_head);
+                ctx->session_cache_head = s;
         }
+}
 
-void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,
-        int (*cb)(struct ssl_st *ssl,SSL_SESSION *sess))
-        {
-        ctx->new_session_cb=cb;
-        }
+void
+SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,
+    int (*cb)(struct ssl_st *ssl, SSL_SESSION *sess)) {
+        ctx->new_session_cb = cb;
+}
 
 int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx))(SSL *ssl, SSL_SESSION *sess)
-        {
+{
         return ctx->new_session_cb;
-        }
+}
 
-void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
-        void (*cb)(SSL_CTX *ctx,SSL_SESSION *sess))
-        {
-        ctx->remove_session_cb=cb;
-        }
+void
+SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
+    void (*cb)(SSL_CTX *ctx, SSL_SESSION *sess))
+{
+        ctx->remove_session_cb = cb;
+}
 
-void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(SSL_CTX * ctx,SSL_SESSION *sess)
-        {
+void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(SSL_CTX * ctx, SSL_SESSION *sess)
+{
         return ctx->remove_session_cb;
-        }
+}
 
-void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,
-        SSL_SESSION *(*cb)(struct ssl_st *ssl,
-                 unsigned char *data,int len,int *copy))
-        {
-        ctx->get_session_cb=cb;
-        }
+void
+SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,
+    SSL_SESSION *(*cb)(struct ssl_st *ssl,
+unsigned char *data, int len, int *copy))
+{
+        ctx->get_session_cb = cb;
+}
 
 SSL_SESSION * (*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx))(SSL *ssl,
-                 unsigned char *data,int len,int *copy)
-        {
+    unsigned char *data, int len, int *copy)
+{
         return ctx->get_session_cb;
-        }
+}
 
-void SSL_CTX_set_info_callback(SSL_CTX *ctx, 
-        void (*cb)(const SSL *ssl,int type,int val))
-        {
-        ctx->info_callback=cb;
-        }
+void
+SSL_CTX_set_info_callback(SSL_CTX *ctx,
+    void (*cb)(const SSL *ssl, int type, int val))
+{
+        ctx->info_callback = cb;
+}
 
-void (*SSL_CTX_get_info_callback(SSL_CTX *ctx))(const SSL *ssl,int type,int val)
-        {
+void (*SSL_CTX_get_info_callback(SSL_CTX *ctx))(const SSL *ssl, int type, int val)
+{
         return ctx->info_callback;
-        }
+}
 
-void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,
-        int (*cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey))
-        {
-        ctx->client_cert_cb=cb;
-        }
+void
+SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,
+    int (*cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey))
+{
+        ctx->client_cert_cb = cb;
+}
 
 int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx))(SSL * ssl, X509 ** x509 , EVP_PKEY **pkey)
-        {
+{
         return ctx->client_cert_cb;
-        }
+}
 
 #ifndef OPENSSL_NO_ENGINE
-int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e)
-        {
-        if (!ENGINE_init(e))
-                {
+int
+SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e)
+{
+        if (!ENGINE_init(e)) {
                 SSLerr(SSL_F_SSL_CTX_SET_CLIENT_CERT_ENGINE, ERR_R_ENGINE_LIB);
                 return 0;
-                }
-        if(!ENGINE_get_ssl_client_cert_function(e))
-                {
+        }
+        if (!ENGINE_get_ssl_client_cert_function(e)) {
                 SSLerr(SSL_F_SSL_CTX_SET_CLIENT_CERT_ENGINE, SSL_R_NO_CLIENT_CERT_METHOD);
                 ENGINE_finish(e);
                 return 0;
-                }
+        }
         ctx->client_cert_engine = e;
         return 1;
-        }
+}
 #endif
 
-void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,
-        int (*cb)(SSL *ssl, unsigned char *cookie, unsigned int *cookie_len))
-        {
-        ctx->app_gen_cookie_cb=cb;
-        }
+void
+SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,
+    int (*cb)(SSL *ssl, unsigned char *cookie, unsigned int *cookie_len))
+{
+        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;
-        }
+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)