First pass at applying KNF to the OpenSSL code, which almost makes it

readable. This pass is whitespace only and can readily be verified using
tr and md5.

9 files changed, 1339 insertions, 1516 deletions

diff --git a/src/lib/libssl/s23_clnt.c b/src/lib/libssl/s23_clnt.c
index 6315e9d876..0fd388a05a 100644
--- a/src/lib/libssl/s23_clnt.c
+++ b/src/lib/libssl/s23_clnt.c
@@ -119,160 +119,163 @@
 static const SSL_METHOD *ssl23_get_client_method(int ver);
 static int ssl23_client_hello(SSL *s);
 static int ssl23_get_server_hello(SSL *s);
-static const SSL_METHOD *ssl23_get_client_method(int ver)
-        {
+static const SSL_METHOD
+*ssl23_get_client_method(int ver)
+{
 #ifndef OPENSSL_NO_SSL2
         if (ver == SSL2_VERSION)
-                return(SSLv2_client_method());
+                return (SSLv2_client_method());
 #endif
         if (ver == SSL3_VERSION)
-                return(SSLv3_client_method());
+                return (SSLv3_client_method());
         else if (ver == TLS1_VERSION)
-                return(TLSv1_client_method());
+                return (TLSv1_client_method());
         else if (ver == TLS1_1_VERSION)
-                return(TLSv1_1_client_method());
+                return (TLSv1_1_client_method());
         else if (ver == TLS1_2_VERSION)
-                return(TLSv1_2_client_method());
+                return (TLSv1_2_client_method());
         else
-                return(NULL);
-        }
+                return (NULL);
+}
 
 IMPLEMENT_ssl23_meth_func(SSLv23_client_method,
-                        ssl_undefined_function,
-                        ssl23_connect,
-                        ssl23_get_client_method)
-
-int ssl23_connect(SSL *s)
-        {
-        BUF_MEM *buf=NULL;
-        unsigned long Time=(unsigned long)time(NULL);
-        void (*cb)(const SSL *ssl,int type,int val)=NULL;
-        int ret= -1;
-        int new_state,state;
-
-        RAND_add(&Time,sizeof(Time),0);
+    ssl_undefined_function, ssl23_connect, ssl23_get_client_method)
+
+int
+ssl23_connect(SSL *s)
+{
+        BUF_MEM *buf = NULL;
+        unsigned long Time = (unsigned long)time(NULL);
+        void (*cb)(const SSL *ssl, int type, int val) = NULL;
+        int ret = -1;
+        int new_state, state;
+
+        RAND_add(&Time, sizeof(Time), 0);
         ERR_clear_error();
         errno = 0;
 
         if (s->info_callback != NULL)
-                cb=s->info_callback;
+                cb = s->info_callback;
         else if (s->ctx->info_callback != NULL)
-                cb=s->ctx->info_callback;
-        
+                cb = s->ctx->info_callback;
+
         s->in_handshake++;
-        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
+        if (!SSL_in_init(s) || SSL_in_before(s))
+                SSL_clear(s);
 
-        for (;;)
-                {
-                state=s->state;
+        for (;;) {
+                state = s->state;
 
-                switch(s->state)
-                        {
+                switch (s->state) {
                 case SSL_ST_BEFORE:
                 case SSL_ST_CONNECT:
                 case SSL_ST_BEFORE|SSL_ST_CONNECT:
                 case SSL_ST_OK|SSL_ST_CONNECT:
 
-                        if (s->session != NULL)
-                                {
-                                SSLerr(SSL_F_SSL23_CONNECT,SSL_R_SSL23_DOING_SESSION_ID_REUSE);
-                                ret= -1;
+                        if (s->session != NULL) {
+                                SSLerr(SSL_F_SSL23_CONNECT, SSL_R_SSL23_DOING_SESSION_ID_REUSE);
+                                ret = -1;
                                 goto end;
-                                }
-                        s->server=0;
-                        if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
+                        }
+                        s->server = 0;
+                        if (cb != NULL)
+                                cb(s, SSL_CB_HANDSHAKE_START, 1);
 
                         /* s->version=TLS1_VERSION; */
-                        s->type=SSL_ST_CONNECT;
+                        s->type = SSL_ST_CONNECT;
 
-                        if (s->init_buf == NULL)
-                                {
-                                if ((buf=BUF_MEM_new()) == NULL)
-                                        {
-                                        ret= -1;
+                        if (s->init_buf == NULL) {
+                                if ((buf = BUF_MEM_new()) == NULL) {
+                                        ret = -1;
                                         goto end;
-                                        }
-                                if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
-                                        {
-                                        ret= -1;
+                                }
+                                if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) {
+                                        ret = -1;
                                         goto end;
-                                        }
-                                s->init_buf=buf;
-                                buf=NULL;
                                 }
+                                s->init_buf = buf;
+                                buf = NULL;
+                        }
 
-                        if (!ssl3_setup_buffers(s)) { ret= -1; goto end; }
+                        if (!ssl3_setup_buffers(s)) {
+                                ret = -1;
+                                goto end;
+                        }
 
                         ssl3_init_finished_mac(s);
 
-                        s->state=SSL23_ST_CW_CLNT_HELLO_A;
+                        s->state = SSL23_ST_CW_CLNT_HELLO_A;
                         s->ctx->stats.sess_connect++;
-                        s->init_num=0;
+                        s->init_num = 0;
                         break;
 
                 case SSL23_ST_CW_CLNT_HELLO_A:
                 case SSL23_ST_CW_CLNT_HELLO_B:
 
-                        s->shutdown=0;
-                        ret=ssl23_client_hello(s);
-                        if (ret <= 0) goto end;
-                        s->state=SSL23_ST_CR_SRVR_HELLO_A;
-                        s->init_num=0;
+                        s->shutdown = 0;
+                        ret = ssl23_client_hello(s);
+                        if (ret <= 0)
+                                goto end;
+                        s->state = SSL23_ST_CR_SRVR_HELLO_A;
+                        s->init_num = 0;
 
                         break;
 
                 case SSL23_ST_CR_SRVR_HELLO_A:
                 case SSL23_ST_CR_SRVR_HELLO_B:
-                        ret=ssl23_get_server_hello(s);
-                        if (ret >= 0) cb=NULL;
+                        ret = ssl23_get_server_hello(s);
+                        if (ret >= 0)
+                                cb = NULL;
                         goto end;
                         /* break; */
 
                 default:
-                        SSLerr(SSL_F_SSL23_CONNECT,SSL_R_UNKNOWN_STATE);
-                        ret= -1;
+                        SSLerr(SSL_F_SSL23_CONNECT, SSL_R_UNKNOWN_STATE);
+                        ret = -1;
                         goto end;
                         /* break; */
-                        }
+                }
 
-                if (s->debug) { (void)BIO_flush(s->wbio); }
+                if (s->debug) {
+                        (void)BIO_flush(s->wbio);
+                }
 
-                if ((cb != NULL) && (s->state != state))
-                        {
-                        new_state=s->state;
-                        s->state=state;
-                        cb(s,SSL_CB_CONNECT_LOOP,1);
-                        s->state=new_state;
-                        }
+                if ((cb != NULL) && (s->state != state)) {
+                        new_state = s->state;
+                        s->state = state;
+                        cb(s, SSL_CB_CONNECT_LOOP, 1);
+                        s->state = new_state;
                 }
+        }
 end:
         s->in_handshake--;
         if (buf != NULL)
                 BUF_MEM_free(buf);
         if (cb != NULL)
-                cb(s,SSL_CB_CONNECT_EXIT,ret);
-        return(ret);
-        }
+                cb(s, SSL_CB_CONNECT_EXIT, ret);
+        return (ret);
+}
 
-static int ssl23_no_ssl2_ciphers(SSL *s)
-        {
+static int
+ssl23_no_ssl2_ciphers(SSL *s)
+{
         SSL_CIPHER *cipher;
         STACK_OF(SSL_CIPHER) *ciphers;
         int i;
         ciphers = SSL_get_ciphers(s);
-        for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++)
-                {
+        for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
                 cipher = sk_SSL_CIPHER_value(ciphers, i);
                 if (cipher->algorithm_ssl == SSL_SSLV2)
                         return 0;
-                }
-        return 1;
         }
+        return 1;
+}
 
 /* Fill a ClientRandom or ServerRandom field of length len. Returns <= 0
  * on failure, 1 on success. */
-int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len)
-        {
+int
+ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len)
+{
         int send_time = 0;
 
         if (len < 4)
@@ -281,22 +284,21 @@ int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len)
                 send_time = (s->mode & SSL_MODE_SEND_SERVERHELLO_TIME) != 0;
         else
                 send_time = (s->mode & SSL_MODE_SEND_CLIENTHELLO_TIME) != 0;
-        if (send_time)
-                {
+        if (send_time) {
                 unsigned long Time = (unsigned long)time(NULL);
                 unsigned char *p = result;
                 l2n(Time, p);
-                return RAND_pseudo_bytes(p, len-4);
-                }
-        else
+                return RAND_pseudo_bytes(p, len - 4);
+        } else
                 return RAND_pseudo_bytes(result, len);
-        }
+}
 
-static int ssl23_client_hello(SSL *s)
-        {
+static int
+ssl23_client_hello(SSL *s)
+{
         unsigned char *buf;
-        unsigned char *p,*d;
-        int i,ch_len;
+        unsigned char *p, *d;
+        int i, ch_len;
         unsigned long l;
         int ssl2_compat;
         int version = 0, version_major, version_minor;
@@ -320,14 +322,14 @@ static int ssl23_client_hello(SSL *s)
          * TLS1>=1, it would be insufficient to pass SSL_NO_TLSv1, the
          * answer is SSL_OP_NO_TLSv1|SSL_OP_NO_SSLv3|SSL_OP_NO_SSLv2.
          */
-        mask =  SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1
+        mask = SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1
 #if !defined(OPENSSL_NO_SSL3)
-                |SSL_OP_NO_SSLv3
+        |SSL_OP_NO_SSLv3
 #endif
 #if !defined(OPENSSL_NO_SSL2)
-                |(ssl2_compat?SSL_OP_NO_SSLv2:0)
+        |(ssl2_compat ? SSL_OP_NO_SSLv2 : 0)
 #endif
-                ;
+        ;
 #if !defined(OPENSSL_NO_TLS1_2_CLIENT)
         version = TLS1_2_VERSION;
 
@@ -351,8 +353,7 @@ static int ssl23_client_hello(SSL *s)
 #endif
 
 #ifndef OPENSSL_NO_TLSEXT
-        if (version != SSL2_VERSION)
-                {
+        if (version != SSL2_VERSION) {
                 /* have to disable SSL 2.0 compatibility if we need TLS extensions */
 
                 if (s->tlsext_hostname != NULL)
@@ -363,67 +364,53 @@ static int ssl23_client_hello(SSL *s)
                 if (s->ctx->tlsext_opaque_prf_input_callback != 0 || s->tlsext_opaque_prf_input != NULL)
                         ssl2_compat = 0;
 #endif
-                }
+        }
 #endif
 
-        buf=(unsigned char *)s->init_buf->data;
-        if (s->state == SSL23_ST_CW_CLNT_HELLO_A)
-                {
+        buf = (unsigned char *)s->init_buf->data;
+        if (s->state == SSL23_ST_CW_CLNT_HELLO_A) {
 #if 0
                 /* don't reuse session-id's */
-                if (!ssl_get_new_session(s,0))
-                        {
-                        return(-1);
-                        }
+                if (!ssl_get_new_session(s, 0)) {
+                        return (-1);
+                }
 #endif
 
-                p=s->s3->client_random;
+                p = s->s3->client_random;
                 if (ssl_fill_hello_random(s, 0, p, SSL3_RANDOM_SIZE) <= 0)
                         return -1;
 
-                if (version == TLS1_2_VERSION)
-                        {
+                if (version == TLS1_2_VERSION) {
                         version_major = TLS1_2_VERSION_MAJOR;
                         version_minor = TLS1_2_VERSION_MINOR;
-                        }
-                else if (version == TLS1_1_VERSION)
-                        {
+                } else if (version == TLS1_1_VERSION) {
                         version_major = TLS1_1_VERSION_MAJOR;
                         version_minor = TLS1_1_VERSION_MINOR;
-                        }
-                else if (version == TLS1_VERSION)
-                        {
+                } else if (version == TLS1_VERSION) {
                         version_major = TLS1_VERSION_MAJOR;
                         version_minor = TLS1_VERSION_MINOR;
-                        }
+                }
 #ifdef OPENSSL_FIPS
-                else if(FIPS_mode())
-                        {
+                else if (FIPS_mode()) {
                         SSLerr(SSL_F_SSL23_CLIENT_HELLO,
-                                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
+                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
                         return -1;
-                        }
+                }
 #endif
-                else if (version == SSL3_VERSION)
-                        {
+                else if (version == SSL3_VERSION) {
                         version_major = SSL3_VERSION_MAJOR;
                         version_minor = SSL3_VERSION_MINOR;
-                        }
-                else if (version == SSL2_VERSION)
-                        {
+                } else if (version == SSL2_VERSION) {
                         version_major = SSL2_VERSION_MAJOR;
                         version_minor = SSL2_VERSION_MINOR;
-                        }
-                else
-                        {
-                        SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_PROTOCOLS_AVAILABLE);
-                        return(-1);
-                        }
+                } else {
+                        SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_PROTOCOLS_AVAILABLE);
+                        return (-1);
+                }
 
                 s->client_version = version;
 
-                if (ssl2_compat)
-                        {
+                if (ssl2_compat) {
                         /* create SSL 2.0 compatible Client Hello */
 
                         /* two byte record header will be written last */
@@ -433,28 +420,27 @@ static int ssl23_client_hello(SSL *s)
                         *(d++) = SSL2_MT_CLIENT_HELLO;
                         *(d++) = version_major;
                         *(d++) = version_minor;
-                        
+
                         /* Ciphers supported */
-                        i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),p,0);
-                        if (i == 0)
-                                {
+                        i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), p, 0);
+                        if (i == 0) {
                                 /* no ciphers */
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE);
                                 return -1;
-                                }
-                        s2n(i,d);
-                        p+=i;
-                        
+                        }
+                        s2n(i, d);
+                        p += i;
+
                         /* put in the session-id length (zero since there is no reuse) */
 #if 0
-                        s->session->session_id_length=0;
+                        s->session->session_id_length = 0;
 #endif
-                        s2n(0,d);
+                        s2n(0, d);
 
                         if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG)
-                                ch_len=SSL2_CHALLENGE_LENGTH;
+                                ch_len = SSL2_CHALLENGE_LENGTH;
                         else
-                                ch_len=SSL2_MAX_CHALLENGE_LENGTH;
+                                ch_len = SSL2_MAX_CHALLENGE_LENGTH;
 
                         /* write out sslv2 challenge */
                         /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32),
@@ -462,34 +448,32 @@ static int ssl23_client_hello(SSL *s)
                            or SSL2_MAX_CHALLENGE_LENGTH (16), but leave the
                            check in for futurproofing */
                         if (SSL3_RANDOM_SIZE < ch_len)
-                                i=SSL3_RANDOM_SIZE;
+                                i = SSL3_RANDOM_SIZE;
                         else
-                                i=ch_len;
-                        s2n(i,d);
-                        memset(&(s->s3->client_random[0]),0,SSL3_RANDOM_SIZE);
-                        if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i) <= 0)
+                                i = ch_len;
+                        s2n(i, d);
+                        memset(&(s->s3->client_random[0]), 0, SSL3_RANDOM_SIZE);
+                        if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i) <= 0)
                                 return -1;
 
-                        memcpy(p,&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
-                        p+=i;
+                        memcpy(p, &(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i);
+                        p += i;
 
-                        i= p- &(buf[2]);
-                        buf[0]=((i>>8)&0xff)|0x80;
-                        buf[1]=(i&0xff);
+                        i = p- &(buf[2]);
+                        buf[0] = ((i >> 8)&0xff)|0x80;
+                        buf[1] = (i&0xff);
 
                         /* number of bytes to write */
-                        s->init_num=i+2;
-                        s->init_off=0;
+                        s->init_num = i + 2;
+                        s->init_off = 0;
 
-                        ssl3_finish_mac(s,&(buf[2]),i);
-                        }
-                else
-                        {
+                        ssl3_finish_mac(s, &(buf[2]), i);
+                } else {
                         /* create Client Hello in SSL 3.0/TLS 1.0 format */
 
                         /* do the record header (5 bytes) and handshake message header (4 bytes) last */
                         d = p = &(buf[9]);
-                        
+
                         *(p++) = version_major;
                         *(p++) = version_minor;
 
@@ -501,73 +485,68 @@ static int ssl23_client_hello(SSL *s)
                         *(p++) = 0;
 
                         /* Ciphers supported (using SSL 3.0/TLS 1.0 format) */
-                        i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),&(p[2]),ssl3_put_cipher_by_char);
-                        if (i == 0)
-                                {
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);
+                        i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), &(p[2]), ssl3_put_cipher_by_char);
+                        if (i == 0) {
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE);
                                 return -1;
-                                }
+                        }
 #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
                         /* Some servers hang if client hello > 256 bytes
                          * as hack workaround chop number of supported ciphers
                          * to keep it well below this if we use TLS v1.2
                          */
-                        if (TLS1_get_version(s) >= TLS1_2_VERSION
-                                && i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)
+                        if (TLS1_get_version(s) >= TLS1_2_VERSION &&
+                            i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)
                                 i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
 #endif
-                        s2n(i,p);
-                        p+=i;
+                        s2n(i, p);
+                        p += i;
 
                         /* COMPRESSION */
 #ifdef OPENSSL_NO_COMP
-                        *(p++)=1;
+                        *(p++) = 1;
 #else
-                        if ((s->options & SSL_OP_NO_COMPRESSION)
-                                                || !s->ctx->comp_methods)
-                                j=0;
+                        if ((s->options & SSL_OP_NO_COMPRESSION) ||
+                            !s->ctx->comp_methods)
+                                j = 0;
                         else
-                                j=sk_SSL_COMP_num(s->ctx->comp_methods);
-                        *(p++)=1+j;
-                        for (i=0; i<j; i++)
-                                {
-                                comp=sk_SSL_COMP_value(s->ctx->comp_methods,i);
-                                *(p++)=comp->id;
-                                }
+                                j = sk_SSL_COMP_num(s->ctx->comp_methods);
+                        *(p++) = 1 + j;
+                        for (i = 0; i < j; i++) {
+                                comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);
+                                *(p++) = comp->id;
+                        }
 #endif
                         *(p++)=0; /* Add the NULL method */
 
 #ifndef OPENSSL_NO_TLSEXT
                         /* TLS extensions*/
-                        if (ssl_prepare_clienthello_tlsext(s) <= 0)
-                                {
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_CLIENTHELLO_TLSEXT);
+                        if (ssl_prepare_clienthello_tlsext(s) <= 0) {
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
                                 return -1;
-                                }
-                        if ((p = ssl_add_clienthello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH)) == NULL)
-                                {
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR);
+                        }
+                        if ((p = ssl_add_clienthello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH)) == NULL) {
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
                                 return -1;
-                                }
+                        }
 #endif
-                        
-                        l = p-d;
+
+                        l = p - d;
 
                         /* fill in 4-byte handshake header */
-                        d=&(buf[5]);
-                        *(d++)=SSL3_MT_CLIENT_HELLO;
-                        l2n3(l,d);
+                        d = &(buf[5]);
+                        *(d++) = SSL3_MT_CLIENT_HELLO;
+                        l2n3(l, d);
 
                         l += 4;
 
-                        if (l > SSL3_RT_MAX_PLAIN_LENGTH)
-                                {
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR);
+                        if (l > SSL3_RT_MAX_PLAIN_LENGTH) {
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
                                 return -1;
-                                }
-                        
+                        }
+
                         /* fill in 5-byte record header */
-                        d=buf;
+                        d = buf;
                         *(d++) = SSL3_RT_HANDSHAKE;
                         *(d++) = version_major;
                         /* Some servers hang if we use long client hellos
@@ -577,54 +556,54 @@ static int ssl23_client_hello(SSL *s)
                                 *(d++) = 1;
                         else
                                 *(d++) = version_minor;
-                        s2n((int)l,d);
+                        s2n((int)l, d);
 
                         /* number of bytes to write */
-                        s->init_num=p-buf;
-                        s->init_off=0;
-
-                        ssl3_finish_mac(s,&(buf[5]), s->init_num - 5);
-                        }
+                        s->init_num = p - buf;
+                        s->init_off = 0;
 
-                s->state=SSL23_ST_CW_CLNT_HELLO_B;
-                s->init_off=0;
+                        ssl3_finish_mac(s, &(buf[5]), s->init_num - 5);
                 }
 
+                s->state = SSL23_ST_CW_CLNT_HELLO_B;
+                s->init_off = 0;
+        }
+
         /* SSL3_ST_CW_CLNT_HELLO_B */
         ret = ssl23_write_bytes(s);
 
-        if ((ret >= 2) && s->msg_callback)
-                {
+        if ((ret >= 2) && s->msg_callback) {
                 /* Client Hello has been sent; tell msg_callback */
 
                 if (ssl2_compat)
-                        s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data+2, ret-2, s, s->msg_callback_arg);
+                        s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data + 2, ret - 2, s, s->msg_callback_arg);
                 else
-                        s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data+5, ret-5, s, s->msg_callback_arg);
-                }
+                        s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data + 5, ret - 5, s, s->msg_callback_arg);
+        }
 
         return ret;
-        }
+}
 
-static int ssl23_get_server_hello(SSL *s)
-        {
+static int
+ssl23_get_server_hello(SSL *s)
+{
         char buf[8];
         unsigned char *p;
         int i;
         int n;
 
-        n=ssl23_read_bytes(s,7);
+        n = ssl23_read_bytes(s, 7);
 
-        if (n != 7) return(n);
-        p=s->packet;
+        if (n != 7)
+                return (n);
+        p = s->packet;
 
-        memcpy(buf,p,n);
+        memcpy(buf, p, n);
 
         if ((p[0] & 0x80) && (p[2] == SSL2_MT_SERVER_HELLO) &&
-                (p[5] == 0x00) && (p[6] == 0x02))
-                {
+                (p[5] == 0x00) && (p[6] == 0x02)) {
 #ifdef OPENSSL_NO_SSL2
-                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL);
                 goto err;
 #else
                 /* we are talking sslv2 */
@@ -632,169 +611,150 @@ static int ssl23_get_server_hello(SSL *s)
                  * sslv2 stuff. */
                 int ch_len;
 
-                if (s->options & SSL_OP_NO_SSLv2)
-                        {
-                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+                if (s->options & SSL_OP_NO_SSLv2) {
+                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL);
                         goto err;
-                        }
-                if (s->s2 == NULL)
-                        {
+                }
+                if (s->s2 == NULL) {
                         if (!ssl2_new(s))
                                 goto err;
-                        }
-                else
+                } else
                         ssl2_clear(s);
 
                 if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG)
-                        ch_len=SSL2_CHALLENGE_LENGTH;
+                        ch_len = SSL2_CHALLENGE_LENGTH;
                 else
-                        ch_len=SSL2_MAX_CHALLENGE_LENGTH;
+                        ch_len = SSL2_MAX_CHALLENGE_LENGTH;
 
                 /* write out sslv2 challenge */
                 /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32), because
                    it is one of SSL2_MAX_CHALLENGE_LENGTH (32) or
                    SSL2_MAX_CHALLENGE_LENGTH (16), but leave the check in for
                    futurproofing */
-                i=(SSL3_RANDOM_SIZE < ch_len)
-                        ?SSL3_RANDOM_SIZE:ch_len;
-                s->s2->challenge_length=i;
+                i = (SSL3_RANDOM_SIZE < ch_len) ? SSL3_RANDOM_SIZE : ch_len;
+                s->s2->challenge_length = i;
                 memcpy(s->s2->challenge,
-                        &(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
+                    &(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i);
 
-                if (s->s3 != NULL) ssl3_free(s);
+                if (s->s3 != NULL)
+                        ssl3_free(s);
 
                 if (!BUF_MEM_grow_clean(s->init_buf,
-                        SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER))
-                        {
-                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,ERR_R_BUF_LIB);
+                    SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) {
+                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, ERR_R_BUF_LIB);
                         goto err;
-                        }
+                }
 
-                s->state=SSL2_ST_GET_SERVER_HELLO_A;
+                s->state = SSL2_ST_GET_SERVER_HELLO_A;
                 if (!(s->client_version == SSL2_VERSION))
                         /* use special padding (SSL 3.0 draft/RFC 2246, App. E.2) */
-                        s->s2->ssl2_rollback=1;
+                        s->s2->ssl2_rollback = 1;
 
                 /* setup the 7 bytes we have read so we get them from
                  * the sslv2 buffer */
-                s->rstate=SSL_ST_READ_HEADER;
-                s->packet_length=n;
-                s->packet= &(s->s2->rbuf[0]);
-                memcpy(s->packet,buf,n);
-                s->s2->rbuf_left=n;
-                s->s2->rbuf_offs=0;
+                s->rstate = SSL_ST_READ_HEADER;
+                s->packet_length = n;
+                s->packet = &(s->s2->rbuf[0]);
+                memcpy(s->packet, buf, n);
+                s->s2->rbuf_left = n;
+                s->s2->rbuf_offs = 0;
 
                 /* we have already written one */
-                s->s2->write_sequence=1;
+                s->s2->write_sequence = 1;
 
-                s->method=SSLv2_client_method();
-                s->handshake_func=s->method->ssl_connect;
+                s->method = SSLv2_client_method();
+                s->handshake_func = s->method->ssl_connect;
 #endif
-                }
-        else if (p[1] == SSL3_VERSION_MAJOR &&
-                 p[2] <= TLS1_2_VERSION_MINOR &&
-                 ((p[0] == SSL3_RT_HANDSHAKE && p[5] == SSL3_MT_SERVER_HELLO) ||
-                  (p[0] == SSL3_RT_ALERT && p[3] == 0 && p[4] == 2)))
-                {
+        } else if (p[1] == SSL3_VERSION_MAJOR &&
+            p[2] <= TLS1_2_VERSION_MINOR &&
+            ((p[0] == SSL3_RT_HANDSHAKE && p[5] == SSL3_MT_SERVER_HELLO) ||
+            (p[0] == SSL3_RT_ALERT && p[3] == 0 && p[4] == 2))) {
                 /* we have sslv3 or tls1 (server hello or alert) */
 
                 if ((p[2] == SSL3_VERSION_MINOR) &&
-                        !(s->options & SSL_OP_NO_SSLv3))
-                        {
+                    !(s->options & SSL_OP_NO_SSLv3)) {
 #ifdef OPENSSL_FIPS
-                        if(FIPS_mode())
-                                {
+                        if (FIPS_mode()) {
                                 SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,
-                                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
+                                SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
                                 goto err;
-                                }
-#endif
-                        s->version=SSL3_VERSION;
-                        s->method=SSLv3_client_method();
-                        }
-                else if ((p[2] == TLS1_VERSION_MINOR) &&
-                        !(s->options & SSL_OP_NO_TLSv1))
-                        {
-                        s->version=TLS1_VERSION;
-                        s->method=TLSv1_client_method();
                         }
-                else if ((p[2] == TLS1_1_VERSION_MINOR) &&
-                        !(s->options & SSL_OP_NO_TLSv1_1))
-                        {
-                        s->version=TLS1_1_VERSION;
-                        s->method=TLSv1_1_client_method();
-                        }
-                else if ((p[2] == TLS1_2_VERSION_MINOR) &&
-                        !(s->options & SSL_OP_NO_TLSv1_2))
-                        {
-                        s->version=TLS1_2_VERSION;
-                        s->method=TLSv1_2_client_method();
-                        }
-                else
-                        {
-                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+#endif
+                        s->version = SSL3_VERSION;
+                        s->method = SSLv3_client_method();
+                } else if ((p[2] == TLS1_VERSION_MINOR) &&
+                    !(s->options & SSL_OP_NO_TLSv1)) {
+                        s->version = TLS1_VERSION;
+                        s->method = TLSv1_client_method();
+                } else if ((p[2] == TLS1_1_VERSION_MINOR) &&
+                    !(s->options & SSL_OP_NO_TLSv1_1)) {
+                        s->version = TLS1_1_VERSION;
+                        s->method = TLSv1_1_client_method();
+                } else if ((p[2] == TLS1_2_VERSION_MINOR) &&
+                    !(s->options & SSL_OP_NO_TLSv1_2)) {
+                        s->version = TLS1_2_VERSION;
+                        s->method = TLSv1_2_client_method();
+                } else {
+                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL);
                         goto err;
-                        }
+                }
 
-                if (p[0] == SSL3_RT_ALERT && p[5] != SSL3_AL_WARNING)
-                        {
+                if (p[0] == SSL3_RT_ALERT && p[5] != SSL3_AL_WARNING) {
                         /* fatal alert */
 
-                        void (*cb)(const SSL *ssl,int type,int val)=NULL;
+                        void (*cb)(const SSL *ssl, int type, int val) = NULL;
                         int j;
 
                         if (s->info_callback != NULL)
-                                cb=s->info_callback;
+                                cb = s->info_callback;
                         else if (s->ctx->info_callback != NULL)
-                                cb=s->ctx->info_callback;
- 
-                        i=p[5];
-                        if (cb != NULL)
-                                {
-                                j=(i<<8)|p[6];
-                                cb(s,SSL_CB_READ_ALERT,j);
-                                }
-                        
+                                cb = s->ctx->info_callback;
+
+                        i = p[5];
+                        if (cb != NULL) {
+                                j = (i << 8) | p[6];
+                                cb(s, SSL_CB_READ_ALERT, j);
+                        }
+
                         if (s->msg_callback)
-                                s->msg_callback(0, s->version, SSL3_RT_ALERT, p+5, 2, s, s->msg_callback_arg);
+                                s->msg_callback(0, s->version, SSL3_RT_ALERT, p + 5, 2, s, s->msg_callback_arg);
 
-                        s->rwstate=SSL_NOTHING;
-                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_AD_REASON_OFFSET+p[6]);
+                        s->rwstate = SSL_NOTHING;
+                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_AD_REASON_OFFSET + p[6]);
                         goto err;
-                        }
+                }
 
-                if (!ssl_init_wbio_buffer(s,1)) goto err;
+                if (!ssl_init_wbio_buffer(s, 1))
+                        goto err;
 
                 /* we are in this state */
-                s->state=SSL3_ST_CR_SRVR_HELLO_A;
+                s->state = SSL3_ST_CR_SRVR_HELLO_A;
 
                 /* put the 7 bytes we have read into the input buffer
                  * for SSLv3 */
-                s->rstate=SSL_ST_READ_HEADER;
-                s->packet_length=n;
+                s->rstate = SSL_ST_READ_HEADER;
+                s->packet_length = n;
                 if (s->s3->rbuf.buf == NULL)
                         if (!ssl3_setup_read_buffer(s))
                                 goto err;
-                s->packet= &(s->s3->rbuf.buf[0]);
-                memcpy(s->packet,buf,n);
-                s->s3->rbuf.left=n;
-                s->s3->rbuf.offset=0;
-
-                s->handshake_func=s->method->ssl_connect;
-                }
-        else
-                {
-                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNKNOWN_PROTOCOL);
+                s->packet = &(s->s3->rbuf.buf[0]);
+                memcpy(s->packet, buf, n);
+                s->s3->rbuf.left = n;
+                s->s3->rbuf.offset = 0;
+
+                s->handshake_func = s->method->ssl_connect;
+        } else {
+                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNKNOWN_PROTOCOL);
                 goto err;
-                }
-        s->init_num=0;
+        }
+        s->init_num = 0;
 
         /* Since, if we are sending a ssl23 client hello, we are not
          * reusing a session-id */
-        if (!ssl_get_new_session(s,0))
+        if (!ssl_get_new_session(s, 0))
                 goto err;
 
-        return(SSL_connect(s));
+        return (SSL_connect(s));
 err:
-        return(-1);
-        }
+        return (-1);
+}
diff --git a/src/lib/libssl/s23_lib.c b/src/lib/libssl/s23_lib.c
index a6285b767f..3a4d5a6ecb 100644
--- a/src/lib/libssl/s23_lib.c
+++ b/src/lib/libssl/s23_lib.c
@@ -60,128 +60,126 @@
 #include <openssl/objects.h>
 #include "ssl_locl.h"
 
-long ssl23_default_timeout(void)
-        {
-        return(300);
-        }
+long
+ssl23_default_timeout(void)
+{
+        return (300);
+}
 
-int ssl23_num_ciphers(void)
-        {
+int
+ssl23_num_ciphers(void)
+{
         return(ssl3_num_ciphers()
 #ifndef OPENSSL_NO_SSL2
-               + ssl2_num_ciphers()
+        + ssl2_num_ciphers()
 #endif
-            );
-        }
+        );
+}
 
-const SSL_CIPHER *ssl23_get_cipher(unsigned int u)
-        {
-        unsigned int uu=ssl3_num_ciphers();
+const SSL_CIPHER
+*ssl23_get_cipher(unsigned int u)
+{
+        unsigned int uu = ssl3_num_ciphers();
 
         if (u < uu)
-                return(ssl3_get_cipher(u));
+                return (ssl3_get_cipher(u));
         else
 #ifndef OPENSSL_NO_SSL2
-                return(ssl2_get_cipher(u-uu));
+        return (ssl2_get_cipher(u - uu));
 #else
-                return(NULL);
+        return (NULL);
 #endif
-        }
+}
 
 /* This function needs to check if the ciphers required are actually
  * available */
-const SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p)
-        {
+const SSL_CIPHER
+*ssl23_get_cipher_by_char(const unsigned char *p)
+{
         const SSL_CIPHER *cp;
 
-        cp=ssl3_get_cipher_by_char(p);
+        cp = ssl3_get_cipher_by_char(p);
 #ifndef OPENSSL_NO_SSL2
         if (cp == NULL)
-                cp=ssl2_get_cipher_by_char(p);
+                cp = ssl2_get_cipher_by_char(p);
 #endif
-        return(cp);
-        }
+        return (cp);
+}
 
-int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
-        {
+int
+ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
+{
         long l;
 
         /* We can write SSLv2 and SSLv3 ciphers */
-        if (p != NULL)
-                {
-                l=c->id;
-                p[0]=((unsigned char)(l>>16L))&0xFF;
-                p[1]=((unsigned char)(l>> 8L))&0xFF;
-                p[2]=((unsigned char)(l     ))&0xFF;
-                }
-        return(3);
+        if (p != NULL) {
+                l = c->id;
+                p[0] = ((unsigned char)(l >> 16L))&0xFF;
+                p[1] = ((unsigned char)(l >> 8L))&0xFF;
+                p[2] = ((unsigned char)(l     ))&0xFF;
         }
+        return (3);
+}
 
-int ssl23_read(SSL *s, void *buf, int len)
-        {
+int
+ssl23_read(SSL *s, void *buf, int len)
+{
         int n;
 
         errno = 0;
-        if (SSL_in_init(s) && (!s->in_handshake))
-                {
-                n=s->handshake_func(s);
-                if (n < 0) return(n);
-                if (n == 0)
-                        {
-                        SSLerr(SSL_F_SSL23_READ,SSL_R_SSL_HANDSHAKE_FAILURE);
-                        return(-1);
-                        }
-                return(SSL_read(s,buf,len));
+        if (SSL_in_init(s) && (!s->in_handshake)) {
+                n = s->handshake_func(s);
+                if (n < 0)
+                        return (n);
+                if (n == 0) {
+                        SSLerr(SSL_F_SSL23_READ, SSL_R_SSL_HANDSHAKE_FAILURE);
+                        return (-1);
                 }
-        else
-                {
+                return (SSL_read(s, buf, len));
+        } else {
                 ssl_undefined_function(s);
-                return(-1);
-                }
+                return (-1);
         }
+}
 
-int ssl23_peek(SSL *s, void *buf, int len)
-        {
+int
+ssl23_peek(SSL *s, void *buf, int len)
+{
         int n;
 
         errno = 0;
-        if (SSL_in_init(s) && (!s->in_handshake))
-                {
-                n=s->handshake_func(s);
-                if (n < 0) return(n);
-                if (n == 0)
-                        {
-                        SSLerr(SSL_F_SSL23_PEEK,SSL_R_SSL_HANDSHAKE_FAILURE);
-                        return(-1);
-                        }
-                return(SSL_peek(s,buf,len));
+        if (SSL_in_init(s) && (!s->in_handshake)) {
+                n = s->handshake_func(s);
+                if (n < 0)
+                        return (n);
+                if (n == 0) {
+                        SSLerr(SSL_F_SSL23_PEEK, SSL_R_SSL_HANDSHAKE_FAILURE);
+                        return (-1);
                 }
-        else
-                {
+                return (SSL_peek(s, buf, len));
+        } else {
                 ssl_undefined_function(s);
-                return(-1);
-                }
+                return (-1);
         }
+}
 
-int ssl23_write(SSL *s, const void *buf, int len)
-        {
+int
+ssl23_write(SSL *s, const void *buf, int len)
+{
         int n;
 
         errno = 0;
-        if (SSL_in_init(s) && (!s->in_handshake))
-                {
-                n=s->handshake_func(s);
-                if (n < 0) return(n);
-                if (n == 0)
-                        {
-                        SSLerr(SSL_F_SSL23_WRITE,SSL_R_SSL_HANDSHAKE_FAILURE);
-                        return(-1);
-                        }
-                return(SSL_write(s,buf,len));
+        if (SSL_in_init(s) && (!s->in_handshake)) {
+                n = s->handshake_func(s);
+                if (n < 0)
+                        return (n);
+                if (n == 0) {
+                        SSLerr(SSL_F_SSL23_WRITE, SSL_R_SSL_HANDSHAKE_FAILURE);
+                        return (-1);
                 }
-        else
-                {
+                return (SSL_write(s, buf, len));
+        } else {
                 ssl_undefined_function(s);
-                return(-1);
-                }
+                return (-1);
         }
+}
diff --git a/src/lib/libssl/s23_pkt.c b/src/lib/libssl/s23_pkt.c
index eba8d9d8fc..28d07a2212 100644
--- a/src/lib/libssl/s23_pkt.c
+++ b/src/lib/libssl/s23_pkt.c
@@ -62,55 +62,53 @@
 #include <openssl/evp.h>
 #include <openssl/buffer.h>
 
-int ssl23_write_bytes(SSL *s)
-        {
-        int i,num,tot;
+int
+ssl23_write_bytes(SSL *s)
+{
+        int i, num, tot;
         char *buf;
 
-        buf=s->init_buf->data;
-        tot=s->init_off;
-        num=s->init_num;
-        for (;;)
-                {
-                s->rwstate=SSL_WRITING;
-                i=BIO_write(s->wbio,&(buf[tot]),num);
-                if (i <= 0)
-                        {
-                        s->init_off=tot;
-                        s->init_num=num;
-                        return(i);
-                        }
-                s->rwstate=SSL_NOTHING;
-                if (i == num) return(tot+i);
-
-                num-=i;
-                tot+=i;
+        buf = s->init_buf->data;
+        tot = s->init_off;
+        num = s->init_num;
+        for (;;) {
+                s->rwstate = SSL_WRITING;
+                i = BIO_write(s->wbio, &(buf[tot]), num);
+                if (i <= 0) {
+                        s->init_off = tot;
+                        s->init_num = num;
+                        return (i);
                 }
+                s->rwstate = SSL_NOTHING;
+                if (i == num)
+                        return (tot + i);
+
+                num -= i;
+                tot += i;
         }
+}
 
 /* return regularly only when we have read (at least) 'n' bytes */
-int ssl23_read_bytes(SSL *s, int n)
-        {
+int
+ssl23_read_bytes(SSL *s, int n)
+{
         unsigned char *p;
         int j;
 
-        if (s->packet_length < (unsigned int)n)
-                {
-                p=s->packet;
+        if (s->packet_length < (unsigned int)n) {
+                p = s->packet;
 
-                for (;;)
-                        {
-                        s->rwstate=SSL_READING;
-                        j=BIO_read(s->rbio,(char *)&(p[s->packet_length]),
-                                n-s->packet_length);
+                for (;;) {
+                        s->rwstate = SSL_READING;
+                        j = BIO_read(s->rbio,(char *)&(p[s->packet_length]),
+                        n - s->packet_length);
                         if (j <= 0)
-                                return(j);
-                        s->rwstate=SSL_NOTHING;
-                        s->packet_length+=j;
+                                return (j);
+                        s->rwstate = SSL_NOTHING;
+                        s->packet_length += j;
                         if (s->packet_length >= (unsigned int)n)
-                                return(s->packet_length);
-                        }
+                                return (s->packet_length);
                 }
-        return(n);
         }
-
+        return (n);
+}
diff --git a/src/lib/libssl/s23_srvr.c b/src/lib/libssl/s23_srvr.c
index 2ac8786c62..35db7b4992 100644
--- a/src/lib/libssl/s23_srvr.c
+++ b/src/lib/libssl/s23_srvr.c
@@ -121,227 +121,209 @@
 
 static const SSL_METHOD *ssl23_get_server_method(int ver);
 int ssl23_get_client_hello(SSL *s);
-static const SSL_METHOD *ssl23_get_server_method(int ver)
-        {
+static const SSL_METHOD
+*ssl23_get_server_method(int ver)
+{
 #ifndef OPENSSL_NO_SSL2
         if (ver == SSL2_VERSION)
-                return(SSLv2_server_method());
+                return (SSLv2_server_method());
 #endif
         if (ver == SSL3_VERSION)
-                return(SSLv3_server_method());
+                return (SSLv3_server_method());
         else if (ver == TLS1_VERSION)
-                return(TLSv1_server_method());
+                return (TLSv1_server_method());
         else if (ver == TLS1_1_VERSION)
-                return(TLSv1_1_server_method());
+                return (TLSv1_1_server_method());
         else if (ver == TLS1_2_VERSION)
-                return(TLSv1_2_server_method());
+                return (TLSv1_2_server_method());
         else
-                return(NULL);
-        }
+                return (NULL);
+}
 
 IMPLEMENT_ssl23_meth_func(SSLv23_server_method,
-                        ssl23_accept,
-                        ssl_undefined_function,
-                        ssl23_get_server_method)
+    ssl23_accept, ssl_undefined_function, ssl23_get_server_method)
 
-int ssl23_accept(SSL *s)
-        {
+int
+ssl23_accept(SSL *s)
+{
         BUF_MEM *buf;
-        unsigned long Time=(unsigned long)time(NULL);
-        void (*cb)(const SSL *ssl,int type,int val)=NULL;
-        int ret= -1;
-        int new_state,state;
+        unsigned long Time = (unsigned long)time(NULL);
+        void (*cb)(const SSL *ssl, int type, int val) = NULL;
+        int ret = -1;
+        int new_state, state;
 
-        RAND_add(&Time,sizeof(Time),0);
+        RAND_add(&Time, sizeof(Time), 0);
         ERR_clear_error();
         errno = 0;
 
         if (s->info_callback != NULL)
-                cb=s->info_callback;
+                cb = s->info_callback;
         else if (s->ctx->info_callback != NULL)
-                cb=s->ctx->info_callback;
-        
+                cb = s->ctx->info_callback;
+
         s->in_handshake++;
-        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
+        if (!SSL_in_init(s) || SSL_in_before(s))
+                SSL_clear(s);
 
-        for (;;)
-                {
-                state=s->state;
+        for (;;) {
+                state = s->state;
 
-                switch(s->state)
-                        {
+                switch (s->state) {
                 case SSL_ST_BEFORE:
                 case SSL_ST_ACCEPT:
                 case SSL_ST_BEFORE|SSL_ST_ACCEPT:
                 case SSL_ST_OK|SSL_ST_ACCEPT:
 
-                        s->server=1;
-                        if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
+                        s->server = 1;
+                        if (cb != NULL)
+                                cb(s, SSL_CB_HANDSHAKE_START, 1);
 
                         /* s->version=SSL3_VERSION; */
-                        s->type=SSL_ST_ACCEPT;
+                        s->type = SSL_ST_ACCEPT;
 
-                        if (s->init_buf == NULL)
-                                {
-                                if ((buf=BUF_MEM_new()) == NULL)
-                                        {
-                                        ret= -1;
+                        if (s->init_buf == NULL) {
+                                if ((buf = BUF_MEM_new()) == NULL) {
+                                        ret = -1;
                                         goto end;
-                                        }
-                                if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
-                                        {
-                                        ret= -1;
+                                }
+                                if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) {
+                                        ret = -1;
                                         goto end;
-                                        }
-                                s->init_buf=buf;
                                 }
+                                s->init_buf = buf;
+                        }
 
                         ssl3_init_finished_mac(s);
 
-                        s->state=SSL23_ST_SR_CLNT_HELLO_A;
+                        s->state = SSL23_ST_SR_CLNT_HELLO_A;
                         s->ctx->stats.sess_accept++;
-                        s->init_num=0;
+                        s->init_num = 0;
                         break;
 
                 case SSL23_ST_SR_CLNT_HELLO_A:
                 case SSL23_ST_SR_CLNT_HELLO_B:
 
-                        s->shutdown=0;
-                        ret=ssl23_get_client_hello(s);
-                        if (ret >= 0) cb=NULL;
+                        s->shutdown = 0;
+                        ret = ssl23_get_client_hello(s);
+                        if (ret >= 0)
+                                cb = NULL;
                         goto end;
                         /* break; */
 
                 default:
-                        SSLerr(SSL_F_SSL23_ACCEPT,SSL_R_UNKNOWN_STATE);
-                        ret= -1;
+                        SSLerr(SSL_F_SSL23_ACCEPT, SSL_R_UNKNOWN_STATE);
+                        ret = -1;
                         goto end;
                         /* break; */
-                        }
+                }
 
-                if ((cb != NULL) && (s->state != state))
-                        {
-                        new_state=s->state;
-                        s->state=state;
-                        cb(s,SSL_CB_ACCEPT_LOOP,1);
-                        s->state=new_state;
-                        }
+                if ((cb != NULL) && (s->state != state)) {
+                        new_state = s->state;
+                        s->state = state;
+                        cb(s, SSL_CB_ACCEPT_LOOP, 1);
+                        s->state = new_state;
                 }
+        }
 end:
         s->in_handshake--;
         if (cb != NULL)
-                cb(s,SSL_CB_ACCEPT_EXIT,ret);
-        return(ret);
-        }
+                cb(s, SSL_CB_ACCEPT_EXIT, ret);
+        return (ret);
+}
 
 
-int ssl23_get_client_hello(SSL *s)
-        {
+int
+ssl23_get_client_hello(SSL *s)
+{
         char buf_space[11]; /* Request this many bytes in initial read.
-                             * We can detect SSL 3.0/TLS 1.0 Client Hellos
-                             * ('type == 3') correctly only when the following
-                             * is in a single record, which is not guaranteed by
-                             * the protocol specification:
-                             * Byte  Content
-                             *  0     type            \
+        * We can detect SSL 3.0/TLS 1.0 Client Hellos
+        * ('type == 3') correctly only when the following
+        * is in a single record, which is not guaranteed by
+        * the protocol specification:
+        * Byte  Content
+        *  0     type            \
                              *  1/2   version          > record header
-                             *  3/4   length          /
-                             *  5     msg_type        \
+        *  3/4   length          /
+        *  5     msg_type        \
                              *  6-8   length           > Client Hello message
-                             *  9/10  client_version  /
+        *  9/10  client_version  /
                              */
-        char *buf= &(buf_space[0]);
-        unsigned char *p,*d,*d_len,*dd;
+        char *buf = &(buf_space[0]);
+        unsigned char *p, *d, *d_len, *dd;
         unsigned int i;
-        unsigned int csl,sil,cl;
-        int n=0,j;
-        int type=0;
+        unsigned int csl, sil, cl;
+        int n = 0, j;
+        int type = 0;
         int v[2];
 
-        if (s->state == SSL23_ST_SR_CLNT_HELLO_A)
-                {
+        if (s->state == SSL23_ST_SR_CLNT_HELLO_A) {
                 /* read the initial header */
-                v[0]=v[1]=0;
+                v[0] = v[1] = 0;
 
-                if (!ssl3_setup_buffers(s)) goto err;
+                if (!ssl3_setup_buffers(s))
+                        goto err;
 
-                n=ssl23_read_bytes(s, sizeof buf_space);
-                if (n != sizeof buf_space) return(n); /* n == -1 || n == 0 */
+                n = ssl23_read_bytes(s, sizeof buf_space);
+                if (n != sizeof buf_space)
+                        return(n); /* n == -1 || n == 0 */
 
-                p=s->packet;
+                p = s->packet;
 
-                memcpy(buf,p,n);
+                memcpy(buf, p, n);
 
-                if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO))
-                        {
+                if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO)) {
                         /*
                          * SSLv2 header
                          */
-                        if ((p[3] == 0x00) && (p[4] == 0x02))
-                                {
-                                v[0]=p[3]; v[1]=p[4];
+                        if ((p[3] == 0x00) && (p[4] == 0x02)) {
+                                v[0] = p[3];
+                                v[1] = p[4];
                                 /* SSLv2 */
                                 if (!(s->options & SSL_OP_NO_SSLv2))
-                                        type=1;
-                                }
-                        else if (p[3] == SSL3_VERSION_MAJOR)
-                                {
-                                v[0]=p[3]; v[1]=p[4];
+                                        type = 1;
+                        } else if (p[3] == SSL3_VERSION_MAJOR) {
+                                v[0] = p[3];
+                                v[1] = p[4];
                                 /* SSLv3/TLSv1 */
-                                if (p[4] >= TLS1_VERSION_MINOR)
-                                        {
+                                if (p[4] >= TLS1_VERSION_MINOR) {
                                         if (p[4] >= TLS1_2_VERSION_MINOR &&
-                                           !(s->options & SSL_OP_NO_TLSv1_2))
-                                                {
-                                                s->version=TLS1_2_VERSION;
-                                                s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                                }
-                                        else if (p[4] >= TLS1_1_VERSION_MINOR &&
-                                           !(s->options & SSL_OP_NO_TLSv1_1))
-                                                {
-                                                s->version=TLS1_1_VERSION;
+                                            !(s->options & SSL_OP_NO_TLSv1_2)) {
+                                                s->version = TLS1_2_VERSION;
+                                                s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                        } else if (p[4] >= TLS1_1_VERSION_MINOR &&
+                                            !(s->options & SSL_OP_NO_TLSv1_1)) {
+                                                s->version = TLS1_1_VERSION;
                                                 /* type=2; */ /* done later to survive restarts */
-                                                s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                                }
-                                        else if (!(s->options & SSL_OP_NO_TLSv1))
-                                                {
-                                                s->version=TLS1_VERSION;
+                                                s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                        } else if (!(s->options & SSL_OP_NO_TLSv1)) {
+                                                s->version = TLS1_VERSION;
                                                 /* type=2; */ /* done later to survive restarts */
-                                                s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                                }
-                                        else if (!(s->options & SSL_OP_NO_SSLv3))
-                                                {
-                                                s->version=SSL3_VERSION;
+                                                s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                        } else if (!(s->options & SSL_OP_NO_SSLv3)) {
+                                                s->version = SSL3_VERSION;
                                                 /* type=2; */
-                                                s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                                }
-                                        else if (!(s->options & SSL_OP_NO_SSLv2))
-                                                {
-                                                type=1;
-                                                }
+                                                s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                        } else if (!(s->options & SSL_OP_NO_SSLv2)) {
+                                                type = 1;
                                         }
-                                else if (!(s->options & SSL_OP_NO_SSLv3))
-                                        {
-                                        s->version=SSL3_VERSION;
+                                } else if (!(s->options & SSL_OP_NO_SSLv3)) {
+                                        s->version = SSL3_VERSION;
                                         /* type=2; */
-                                        s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                        }
-                                else if (!(s->options & SSL_OP_NO_SSLv2))
-                                        type=1;
+                                        s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                } else if (!(s->options & SSL_OP_NO_SSLv2))
+                                        type = 1;
 
-                                }
                         }
-                else if ((p[0] == SSL3_RT_HANDSHAKE) &&
-                         (p[1] == SSL3_VERSION_MAJOR) &&
-                         (p[5] == SSL3_MT_CLIENT_HELLO) &&
-                         ((p[3] == 0 && p[4] < 5 /* silly record length? */)
-                                || (p[9] >= p[1])))
-                        {
+                } else if ((p[0] == SSL3_RT_HANDSHAKE) &&
+                    (p[1] == SSL3_VERSION_MAJOR) &&
+                    (p[5] == SSL3_MT_CLIENT_HELLO) &&
+                    ((p[3] == 0 && p[4] < 5 /* silly record length? */)
+                    || (p[9] >= p[1]))) {
                         /*
                          * SSLv3 or tls1 header
                          */
-                        
-                        v[0]=p[1]; /* major version (= SSL3_VERSION_MAJOR) */
+
+                        v[0] = p[1]; /* major version (= SSL3_VERSION_MAJOR) */
                         /* We must look at client_version inside the Client Hello message
                          * to get the correct minor version.
                          * However if we have only a pathologically small fragment of the
@@ -350,127 +332,108 @@ int ssl23_get_client_hello(SSL *s)
                          * No known SSL 3.0 client fragments ClientHello like this,
                          * so we simply assume TLS 1.0 to avoid protocol version downgrade
                          * attacks. */
-                        if (p[3] == 0 && p[4] < 6)
-                                {
+                        if (p[3] == 0 && p[4] < 6) {
 #if 0
-                                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_SMALL);
+                                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_TOO_SMALL);
                                 goto err;
 #else
                                 v[1] = TLS1_VERSION_MINOR;
 #endif
-                                }
+                        }
                         /* if major version number > 3 set minor to a value
                          * which will use the highest version 3 we support.
                          * If TLS 2.0 ever appears we will need to revise
                          * this....
                          */
                         else if (p[9] > SSL3_VERSION_MAJOR)
-                                v[1]=0xff;
+                                v[1] = 0xff;
                         else
-                                v[1]=p[10]; /* minor version according to client_version */
-                        if (v[1] >= TLS1_VERSION_MINOR)
-                                {
+                                v[1] = p[10]; /* minor version according to client_version */
+                        if (v[1] >= TLS1_VERSION_MINOR) {
                                 if (v[1] >= TLS1_2_VERSION_MINOR &&
-                                        !(s->options & SSL_OP_NO_TLSv1_2))
-                                        {
-                                        s->version=TLS1_2_VERSION;
-                                        type=3;
-                                        }
-                                else if (v[1] >= TLS1_1_VERSION_MINOR &&
-                                        !(s->options & SSL_OP_NO_TLSv1_1))
-                                        {
-                                        s->version=TLS1_1_VERSION;
-                                        type=3;
-                                        }
-                                else if (!(s->options & SSL_OP_NO_TLSv1))
-                                        {
-                                        s->version=TLS1_VERSION;
-                                        type=3;
-                                        }
-                                else if (!(s->options & SSL_OP_NO_SSLv3))
-                                        {
-                                        s->version=SSL3_VERSION;
-                                        type=3;
-                                        }
+                                    !(s->options & SSL_OP_NO_TLSv1_2)) {
+                                        s->version = TLS1_2_VERSION;
+                                        type = 3;
+                                } else if (v[1] >= TLS1_1_VERSION_MINOR &&
+                                    !(s->options & SSL_OP_NO_TLSv1_1)) {
+                                        s->version = TLS1_1_VERSION;
+                                        type = 3;
+                                } else if (!(s->options & SSL_OP_NO_TLSv1)) {
+                                        s->version = TLS1_VERSION;
+                                        type = 3;
+                                } else if (!(s->options & SSL_OP_NO_SSLv3)) {
+                                        s->version = SSL3_VERSION;
+                                        type = 3;
                                 }
-                        else
-                                {
+                        } else {
                                 /* client requests SSL 3.0 */
-                                if (!(s->options & SSL_OP_NO_SSLv3))
-                                        {
-                                        s->version=SSL3_VERSION;
-                                        type=3;
-                                        }
-                                else if (!(s->options & SSL_OP_NO_TLSv1))
-                                        {
+                                if (!(s->options & SSL_OP_NO_SSLv3)) {
+                                        s->version = SSL3_VERSION;
+                                        type = 3;
+                                } else if (!(s->options & SSL_OP_NO_TLSv1)) {
                                         /* we won't be able to use TLS of course,
                                          * but this will send an appropriate alert */
-                                        s->version=TLS1_VERSION;
-                                        type=3;
-                                        }
+                                        s->version = TLS1_VERSION;
+                                        type = 3;
                                 }
                         }
-                else if ((strncmp("GET ", (char *)p,4) == 0) ||
-                         (strncmp("POST ",(char *)p,5) == 0) ||
-                         (strncmp("HEAD ",(char *)p,5) == 0) ||
-                         (strncmp("PUT ", (char *)p,4) == 0))
-                        {
-                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTP_REQUEST);
+                }
+                else if ((strncmp("GET ", (char *)p, 4) == 0) ||
+                    (strncmp("POST ",(char *)p, 5) == 0) ||
+                    (strncmp("HEAD ",(char *)p, 5) == 0) ||
+                    (strncmp("PUT ", (char *)p, 4) == 0)) {
+                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_HTTP_REQUEST);
                         goto err;
-                        }
-                else if (strncmp("CONNECT",(char *)p,7) == 0)
-                        {
-                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTPS_PROXY_REQUEST);
+                } else if (strncmp("CONNECT", (char *)p, 7) == 0) {
+                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_HTTPS_PROXY_REQUEST);
                         goto err;
-                        }
                 }
+        }
 
 #ifdef OPENSSL_FIPS
-        if (FIPS_mode() && (s->version < TLS1_VERSION))
-                {
+        if (FIPS_mode() && (s->version < TLS1_VERSION)) {
                 SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,
-                                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
+                    SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
                 goto err;
-                }
+        }
 #endif
 
-        if (s->state == SSL23_ST_SR_CLNT_HELLO_B)
-                {
+        if (s->state == SSL23_ST_SR_CLNT_HELLO_B) {
                 /* we have SSLv3/TLSv1 in an SSLv2 header
                  * (other cases skip this state) */
 
-                type=2;
-                p=s->packet;
+                type = 2;
+                p = s->packet;
                 v[0] = p[3]; /* == SSL3_VERSION_MAJOR */
                 v[1] = p[4];
 
-                n=((p[0]&0x7f)<<8)|p[1];
-                if (n > (1024*4))
-                        {
-                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE);
+                n = ((p[0] & 0x7f) << 8) | p[1];
+                if (n > (1024 * 4)) {
+                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_TOO_LARGE);
                         goto err;
-                        }
+                }
 
-                j=ssl23_read_bytes(s,n+2);
-                if (j <= 0) return(j);
+                j = ssl23_read_bytes(s, n + 2);
+                if (j <= 0)
+                        return (j);
 
-                ssl3_finish_mac(s, s->packet+2, s->packet_length-2);
+                ssl3_finish_mac(s, s->packet + 2, s->packet_length - 2);
                 if (s->msg_callback)
-                        s->msg_callback(0, SSL2_VERSION, 0, s->packet+2, s->packet_length-2, s, s->msg_callback_arg); /* CLIENT-HELLO */
-
-                p=s->packet;
-                p+=5;
-                n2s(p,csl);
-                n2s(p,sil);
-                n2s(p,cl);
-                d=(unsigned char *)s->init_buf->data;
-                if ((csl+sil+cl+11) != s->packet_length) /* We can't have TLS extensions in SSL 2.0 format
-                                                          * Client Hello, can we? Error condition should be
+                        s->msg_callback(0, SSL2_VERSION, 0, s->packet + 2, s->packet_length-2, s, s->msg_callback_arg); /* CLIENT-HELLO */
+
+                p = s->packet;
+                p += 5;
+                n2s(p, csl);
+                n2s(p, sil);
+                n2s(p, cl);
+                d = (unsigned char *)s->init_buf->data;
+                if ((csl + sil + cl + 11) != s->packet_length) /* We can't have TLS extensions in SSL 2.0 format
+                        * Client Hello, can we ? Error condition should be
                                                           * '>' otherweise */
-                        {
-                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_LENGTH_MISMATCH);
+                {
+                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_LENGTH_MISMATCH);
                         goto err;
-                        }
+                }
 
                 /* record header: msg_type ... */
                 *(d++) = SSL3_MT_CLIENT_HELLO;
@@ -484,130 +447,122 @@ int ssl23_get_client_hello(SSL *s)
 
                 /* lets populate the random area */
                 /* get the challenge_length */
-                i=(cl > SSL3_RANDOM_SIZE)?SSL3_RANDOM_SIZE:cl;
-                memset(d,0,SSL3_RANDOM_SIZE);
-                memcpy(&(d[SSL3_RANDOM_SIZE-i]),&(p[csl+sil]),i);
-                d+=SSL3_RANDOM_SIZE;
+                i = (cl > SSL3_RANDOM_SIZE) ? SSL3_RANDOM_SIZE : cl;
+                memset(d, 0, SSL3_RANDOM_SIZE);
+                memcpy(&(d[SSL3_RANDOM_SIZE - i]), &(p[csl + sil]), i);
+                d += SSL3_RANDOM_SIZE;
 
                 /* no session-id reuse */
-                *(d++)=0;
+                *(d++) = 0;
 
                 /* ciphers */
-                j=0;
-                dd=d;
-                d+=2;
-                for (i=0; i<csl; i+=3)
-                        {
-                        if (p[i] != 0) continue;
-                        *(d++)=p[i+1];
-                        *(d++)=p[i+2];
-                        j+=2;
-                        }
-                s2n(j,dd);
+                j = 0;
+                dd = d;
+                d += 2;
+                for (i = 0; i < csl; i += 3) {
+                        if (p[i] != 0)
+                                continue;
+                        *(d++) = p[i + 1];
+                        *(d++) = p[i + 2];
+                        j += 2;
+                }
+                s2n(j, dd);
 
                 /* COMPRESSION */
-                *(d++)=1;
-                *(d++)=0;
-                
+                *(d++) = 1;
+                *(d++) = 0;
+
 #if 0
-                /* copy any remaining data with may be extensions */
-                p = p+csl+sil+cl;
-                while (p <  s->packet+s->packet_length)
-                        {
+                /* copy any remaining data with may be extensions */
+                p = p + csl + sil + cl;
+                while (p <  s->packet + s->packet_length) {
                         *(d++)=*(p++);
-                        }
+                }
 #endif
 
-                i = (d-(unsigned char *)s->init_buf->data) - 4;
+                i = (d - (unsigned char *)s->init_buf->data) - 4;
                 l2n3((long)i, d_len);
 
                 /* get the data reused from the init_buf */
-                s->s3->tmp.reuse_message=1;
-                s->s3->tmp.message_type=SSL3_MT_CLIENT_HELLO;
-                s->s3->tmp.message_size=i;
-                }
+                s->s3->tmp.reuse_message = 1;
+                s->s3->tmp.message_type = SSL3_MT_CLIENT_HELLO;
+                s->s3->tmp.message_size = i;
+        }
 
         /* imaginary new state (for program structure): */
         /* s->state = SSL23_SR_CLNT_HELLO_C */
 
-        if (type == 1)
-                {
+        if (type == 1) {
 #ifdef OPENSSL_NO_SSL2
-                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_UNSUPPORTED_PROTOCOL);
                 goto err;
 #else
                 /* we are talking sslv2 */
                 /* we need to clean up the SSLv3/TLSv1 setup and put in the
                  * sslv2 stuff. */
 
-                if (s->s2 == NULL)
-                        {
+                if (s->s2 == NULL) {
                         if (!ssl2_new(s))
                                 goto err;
-                        }
-                else
+                } else
                         ssl2_clear(s);
 
-                if (s->s3 != NULL) ssl3_free(s);
+                if (s->s3 != NULL)
+                        ssl3_free(s);
 
                 if (!BUF_MEM_grow_clean(s->init_buf,
-                        SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER))
-                        {
+                        SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) {
                         goto err;
-                        }
+                }
 
-                s->state=SSL2_ST_GET_CLIENT_HELLO_A;
+                s->state = SSL2_ST_GET_CLIENT_HELLO_A;
                 if (s->options & SSL_OP_NO_TLSv1 && s->options & SSL_OP_NO_SSLv3)
-                        s->s2->ssl2_rollback=0;
+                        s->s2->ssl2_rollback = 0;
                 else
                         /* reject SSL 2.0 session if client supports SSL 3.0 or TLS 1.0
                          * (SSL 3.0 draft/RFC 2246, App. E.2) */
-                        s->s2->ssl2_rollback=1;
+                s->s2->ssl2_rollback = 1;
 
                 /* setup the n bytes we have read so we get them from
                  * the sslv2 buffer */
-                s->rstate=SSL_ST_READ_HEADER;
-                s->packet_length=n;
-                s->packet= &(s->s2->rbuf[0]);
-                memcpy(s->packet,buf,n);
-                s->s2->rbuf_left=n;
-                s->s2->rbuf_offs=0;
-
-                s->method=SSLv2_server_method();
-                s->handshake_func=s->method->ssl_accept;
+                s->rstate = SSL_ST_READ_HEADER;
+                s->packet_length = n;
+                s->packet = &(s->s2->rbuf[0]);
+                memcpy(s->packet, buf, n);
+                s->s2->rbuf_left = n;
+                s->s2->rbuf_offs = 0;
+
+                s->method = SSLv2_server_method();
+                s->handshake_func = s->method->ssl_accept;
 #endif
-                }
+        }
 
-        if ((type == 2) || (type == 3))
-                {
+        if ((type == 2) || (type == 3)) {
                 /* we have SSLv3/TLSv1 (type 2: SSL2 style, type 3: SSL3/TLS style) */
 
-                if (!ssl_init_wbio_buffer(s,1)) goto err;
+                if (!ssl_init_wbio_buffer(s, 1)) goto err;
 
                 /* we are in this state */
-                s->state=SSL3_ST_SR_CLNT_HELLO_A;
+                s->state = SSL3_ST_SR_CLNT_HELLO_A;
 
-                if (type == 3)
-                        {
+                if (type == 3) {
                         /* put the 'n' bytes we have read into the input buffer
                          * for SSLv3 */
-                        s->rstate=SSL_ST_READ_HEADER;
-                        s->packet_length=n;
+                        s->rstate = SSL_ST_READ_HEADER;
+                        s->packet_length = n;
                         if (s->s3->rbuf.buf == NULL)
                                 if (!ssl3_setup_read_buffer(s))
                                         goto err;
 
-                        s->packet= &(s->s3->rbuf.buf[0]);
-                        memcpy(s->packet,buf,n);
-                        s->s3->rbuf.left=n;
-                        s->s3->rbuf.offset=0;
-                        }
-                else
-                        {
-                        s->packet_length=0;
-                        s->s3->rbuf.left=0;
-                        s->s3->rbuf.offset=0;
-                        }
+                        s->packet = &(s->s3->rbuf.buf[0]);
+                        memcpy(s->packet, buf, n);
+                        s->s3->rbuf.left = n;
+                        s->s3->rbuf.offset = 0;
+                } else {
+                        s->packet_length = 0;
+                        s->s3->rbuf.left = 0;
+                        s->s3->rbuf.offset = 0;
+                }
                 if (s->version == TLS1_2_VERSION)
                         s->method = TLSv1_2_server_method();
                 else if (s->version == TLS1_1_VERSION)
@@ -617,22 +572,23 @@ int ssl23_get_client_hello(SSL *s)
                 else
                         s->method = SSLv3_server_method();
 #if 0 /* ssl3_get_client_hello does this */
-                s->client_version=(v[0]<<8)|v[1];
+                s->client_version = (v[0]<<8)|v[1];
 #endif
-                s->handshake_func=s->method->ssl_accept;
-                }
-        
-        if ((type < 1) || (type > 3))
-                {
+                s->handshake_func = s->method->ssl_accept;
+        }
+
+        if ((type < 1) || (type > 3)) {
                 /* bad, very bad */
-                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNKNOWN_PROTOCOL);
+                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
                 goto err;
-                }
-        s->init_num=0;
+        }
+        s->init_num = 0;
 
-        if (buf != buf_space) OPENSSL_free(buf);
-        return(SSL_accept(s));
+        if (buf != buf_space)
+                OPENSSL_free(buf);
+        return (SSL_accept(s));
 err:
-        if (buf != buf_space) OPENSSL_free(buf);
-        return(-1);
-        }
+        if (buf != buf_space)
+                OPENSSL_free(buf);
+        return (-1);
+}
diff --git a/src/lib/libssl/src/ssl/s23_clnt.c b/src/lib/libssl/src/ssl/s23_clnt.c
index 6315e9d876..0fd388a05a 100644
--- a/src/lib/libssl/src/ssl/s23_clnt.c
+++ b/src/lib/libssl/src/ssl/s23_clnt.c
@@ -119,160 +119,163 @@
 static const SSL_METHOD *ssl23_get_client_method(int ver);
 static int ssl23_client_hello(SSL *s);
 static int ssl23_get_server_hello(SSL *s);
-static const SSL_METHOD *ssl23_get_client_method(int ver)
-        {
+static const SSL_METHOD
+*ssl23_get_client_method(int ver)
+{
 #ifndef OPENSSL_NO_SSL2
         if (ver == SSL2_VERSION)
-                return(SSLv2_client_method());
+                return (SSLv2_client_method());
 #endif
         if (ver == SSL3_VERSION)
-                return(SSLv3_client_method());
+                return (SSLv3_client_method());
         else if (ver == TLS1_VERSION)
-                return(TLSv1_client_method());
+                return (TLSv1_client_method());
         else if (ver == TLS1_1_VERSION)
-                return(TLSv1_1_client_method());
+                return (TLSv1_1_client_method());
         else if (ver == TLS1_2_VERSION)
-                return(TLSv1_2_client_method());
+                return (TLSv1_2_client_method());
         else
-                return(NULL);
-        }
+                return (NULL);
+}
 
 IMPLEMENT_ssl23_meth_func(SSLv23_client_method,
-                        ssl_undefined_function,
-                        ssl23_connect,
-                        ssl23_get_client_method)
-
-int ssl23_connect(SSL *s)
-        {
-        BUF_MEM *buf=NULL;
-        unsigned long Time=(unsigned long)time(NULL);
-        void (*cb)(const SSL *ssl,int type,int val)=NULL;
-        int ret= -1;
-        int new_state,state;
-
-        RAND_add(&Time,sizeof(Time),0);
+    ssl_undefined_function, ssl23_connect, ssl23_get_client_method)
+
+int
+ssl23_connect(SSL *s)
+{
+        BUF_MEM *buf = NULL;
+        unsigned long Time = (unsigned long)time(NULL);
+        void (*cb)(const SSL *ssl, int type, int val) = NULL;
+        int ret = -1;
+        int new_state, state;
+
+        RAND_add(&Time, sizeof(Time), 0);
         ERR_clear_error();
         errno = 0;
 
         if (s->info_callback != NULL)
-                cb=s->info_callback;
+                cb = s->info_callback;
         else if (s->ctx->info_callback != NULL)
-                cb=s->ctx->info_callback;
-        
+                cb = s->ctx->info_callback;
+
         s->in_handshake++;
-        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
+        if (!SSL_in_init(s) || SSL_in_before(s))
+                SSL_clear(s);
 
-        for (;;)
-                {
-                state=s->state;
+        for (;;) {
+                state = s->state;
 
-                switch(s->state)
-                        {
+                switch (s->state) {
                 case SSL_ST_BEFORE:
                 case SSL_ST_CONNECT:
                 case SSL_ST_BEFORE|SSL_ST_CONNECT:
                 case SSL_ST_OK|SSL_ST_CONNECT:
 
-                        if (s->session != NULL)
-                                {
-                                SSLerr(SSL_F_SSL23_CONNECT,SSL_R_SSL23_DOING_SESSION_ID_REUSE);
-                                ret= -1;
+                        if (s->session != NULL) {
+                                SSLerr(SSL_F_SSL23_CONNECT, SSL_R_SSL23_DOING_SESSION_ID_REUSE);
+                                ret = -1;
                                 goto end;
-                                }
-                        s->server=0;
-                        if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
+                        }
+                        s->server = 0;
+                        if (cb != NULL)
+                                cb(s, SSL_CB_HANDSHAKE_START, 1);
 
                         /* s->version=TLS1_VERSION; */
-                        s->type=SSL_ST_CONNECT;
+                        s->type = SSL_ST_CONNECT;
 
-                        if (s->init_buf == NULL)
-                                {
-                                if ((buf=BUF_MEM_new()) == NULL)
-                                        {
-                                        ret= -1;
+                        if (s->init_buf == NULL) {
+                                if ((buf = BUF_MEM_new()) == NULL) {
+                                        ret = -1;
                                         goto end;
-                                        }
-                                if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
-                                        {
-                                        ret= -1;
+                                }
+                                if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) {
+                                        ret = -1;
                                         goto end;
-                                        }
-                                s->init_buf=buf;
-                                buf=NULL;
                                 }
+                                s->init_buf = buf;
+                                buf = NULL;
+                        }
 
-                        if (!ssl3_setup_buffers(s)) { ret= -1; goto end; }
+                        if (!ssl3_setup_buffers(s)) {
+                                ret = -1;
+                                goto end;
+                        }
 
                         ssl3_init_finished_mac(s);
 
-                        s->state=SSL23_ST_CW_CLNT_HELLO_A;
+                        s->state = SSL23_ST_CW_CLNT_HELLO_A;
                         s->ctx->stats.sess_connect++;
-                        s->init_num=0;
+                        s->init_num = 0;
                         break;
 
                 case SSL23_ST_CW_CLNT_HELLO_A:
                 case SSL23_ST_CW_CLNT_HELLO_B:
 
-                        s->shutdown=0;
-                        ret=ssl23_client_hello(s);
-                        if (ret <= 0) goto end;
-                        s->state=SSL23_ST_CR_SRVR_HELLO_A;
-                        s->init_num=0;
+                        s->shutdown = 0;
+                        ret = ssl23_client_hello(s);
+                        if (ret <= 0)
+                                goto end;
+                        s->state = SSL23_ST_CR_SRVR_HELLO_A;
+                        s->init_num = 0;
 
                         break;
 
                 case SSL23_ST_CR_SRVR_HELLO_A:
                 case SSL23_ST_CR_SRVR_HELLO_B:
-                        ret=ssl23_get_server_hello(s);
-                        if (ret >= 0) cb=NULL;
+                        ret = ssl23_get_server_hello(s);
+                        if (ret >= 0)
+                                cb = NULL;
                         goto end;
                         /* break; */
 
                 default:
-                        SSLerr(SSL_F_SSL23_CONNECT,SSL_R_UNKNOWN_STATE);
-                        ret= -1;
+                        SSLerr(SSL_F_SSL23_CONNECT, SSL_R_UNKNOWN_STATE);
+                        ret = -1;
                         goto end;
                         /* break; */
-                        }
+                }
 
-                if (s->debug) { (void)BIO_flush(s->wbio); }
+                if (s->debug) {
+                        (void)BIO_flush(s->wbio);
+                }
 
-                if ((cb != NULL) && (s->state != state))
-                        {
-                        new_state=s->state;
-                        s->state=state;
-                        cb(s,SSL_CB_CONNECT_LOOP,1);
-                        s->state=new_state;
-                        }
+                if ((cb != NULL) && (s->state != state)) {
+                        new_state = s->state;
+                        s->state = state;
+                        cb(s, SSL_CB_CONNECT_LOOP, 1);
+                        s->state = new_state;
                 }
+        }
 end:
         s->in_handshake--;
         if (buf != NULL)
                 BUF_MEM_free(buf);
         if (cb != NULL)
-                cb(s,SSL_CB_CONNECT_EXIT,ret);
-        return(ret);
-        }
+                cb(s, SSL_CB_CONNECT_EXIT, ret);
+        return (ret);
+}
 
-static int ssl23_no_ssl2_ciphers(SSL *s)
-        {
+static int
+ssl23_no_ssl2_ciphers(SSL *s)
+{
         SSL_CIPHER *cipher;
         STACK_OF(SSL_CIPHER) *ciphers;
         int i;
         ciphers = SSL_get_ciphers(s);
-        for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++)
-                {
+        for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
                 cipher = sk_SSL_CIPHER_value(ciphers, i);
                 if (cipher->algorithm_ssl == SSL_SSLV2)
                         return 0;
-                }
-        return 1;
         }
+        return 1;
+}
 
 /* Fill a ClientRandom or ServerRandom field of length len. Returns <= 0
  * on failure, 1 on success. */
-int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len)
-        {
+int
+ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len)
+{
         int send_time = 0;
 
         if (len < 4)
@@ -281,22 +284,21 @@ int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len)
                 send_time = (s->mode & SSL_MODE_SEND_SERVERHELLO_TIME) != 0;
         else
                 send_time = (s->mode & SSL_MODE_SEND_CLIENTHELLO_TIME) != 0;
-        if (send_time)
-                {
+        if (send_time) {
                 unsigned long Time = (unsigned long)time(NULL);
                 unsigned char *p = result;
                 l2n(Time, p);
-                return RAND_pseudo_bytes(p, len-4);
-                }
-        else
+                return RAND_pseudo_bytes(p, len - 4);
+        } else
                 return RAND_pseudo_bytes(result, len);
-        }
+}
 
-static int ssl23_client_hello(SSL *s)
-        {
+static int
+ssl23_client_hello(SSL *s)
+{
         unsigned char *buf;
-        unsigned char *p,*d;
-        int i,ch_len;
+        unsigned char *p, *d;
+        int i, ch_len;
         unsigned long l;
         int ssl2_compat;
         int version = 0, version_major, version_minor;
@@ -320,14 +322,14 @@ static int ssl23_client_hello(SSL *s)
          * TLS1>=1, it would be insufficient to pass SSL_NO_TLSv1, the
          * answer is SSL_OP_NO_TLSv1|SSL_OP_NO_SSLv3|SSL_OP_NO_SSLv2.
          */
-        mask =  SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1
+        mask = SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1
 #if !defined(OPENSSL_NO_SSL3)
-                |SSL_OP_NO_SSLv3
+        |SSL_OP_NO_SSLv3
 #endif
 #if !defined(OPENSSL_NO_SSL2)
-                |(ssl2_compat?SSL_OP_NO_SSLv2:0)
+        |(ssl2_compat ? SSL_OP_NO_SSLv2 : 0)
 #endif
-                ;
+        ;
 #if !defined(OPENSSL_NO_TLS1_2_CLIENT)
         version = TLS1_2_VERSION;
 
@@ -351,8 +353,7 @@ static int ssl23_client_hello(SSL *s)
 #endif
 
 #ifndef OPENSSL_NO_TLSEXT
-        if (version != SSL2_VERSION)
-                {
+        if (version != SSL2_VERSION) {
                 /* have to disable SSL 2.0 compatibility if we need TLS extensions */
 
                 if (s->tlsext_hostname != NULL)
@@ -363,67 +364,53 @@ static int ssl23_client_hello(SSL *s)
                 if (s->ctx->tlsext_opaque_prf_input_callback != 0 || s->tlsext_opaque_prf_input != NULL)
                         ssl2_compat = 0;
 #endif
-                }
+        }
 #endif
 
-        buf=(unsigned char *)s->init_buf->data;
-        if (s->state == SSL23_ST_CW_CLNT_HELLO_A)
-                {
+        buf = (unsigned char *)s->init_buf->data;
+        if (s->state == SSL23_ST_CW_CLNT_HELLO_A) {
 #if 0
                 /* don't reuse session-id's */
-                if (!ssl_get_new_session(s,0))
-                        {
-                        return(-1);
-                        }
+                if (!ssl_get_new_session(s, 0)) {
+                        return (-1);
+                }
 #endif
 
-                p=s->s3->client_random;
+                p = s->s3->client_random;
                 if (ssl_fill_hello_random(s, 0, p, SSL3_RANDOM_SIZE) <= 0)
                         return -1;
 
-                if (version == TLS1_2_VERSION)
-                        {
+                if (version == TLS1_2_VERSION) {
                         version_major = TLS1_2_VERSION_MAJOR;
                         version_minor = TLS1_2_VERSION_MINOR;
-                        }
-                else if (version == TLS1_1_VERSION)
-                        {
+                } else if (version == TLS1_1_VERSION) {
                         version_major = TLS1_1_VERSION_MAJOR;
                         version_minor = TLS1_1_VERSION_MINOR;
-                        }
-                else if (version == TLS1_VERSION)
-                        {
+                } else if (version == TLS1_VERSION) {
                         version_major = TLS1_VERSION_MAJOR;
                         version_minor = TLS1_VERSION_MINOR;
-                        }
+                }
 #ifdef OPENSSL_FIPS
-                else if(FIPS_mode())
-                        {
+                else if (FIPS_mode()) {
                         SSLerr(SSL_F_SSL23_CLIENT_HELLO,
-                                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
+                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
                         return -1;
-                        }
+                }
 #endif
-                else if (version == SSL3_VERSION)
-                        {
+                else if (version == SSL3_VERSION) {
                         version_major = SSL3_VERSION_MAJOR;
                         version_minor = SSL3_VERSION_MINOR;
-                        }
-                else if (version == SSL2_VERSION)
-                        {
+                } else if (version == SSL2_VERSION) {
                         version_major = SSL2_VERSION_MAJOR;
                         version_minor = SSL2_VERSION_MINOR;
-                        }
-                else
-                        {
-                        SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_PROTOCOLS_AVAILABLE);
-                        return(-1);
-                        }
+                } else {
+                        SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_PROTOCOLS_AVAILABLE);
+                        return (-1);
+                }
 
                 s->client_version = version;
 
-                if (ssl2_compat)
-                        {
+                if (ssl2_compat) {
                         /* create SSL 2.0 compatible Client Hello */
 
                         /* two byte record header will be written last */
@@ -433,28 +420,27 @@ static int ssl23_client_hello(SSL *s)
                         *(d++) = SSL2_MT_CLIENT_HELLO;
                         *(d++) = version_major;
                         *(d++) = version_minor;
-                        
+
                         /* Ciphers supported */
-                        i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),p,0);
-                        if (i == 0)
-                                {
+                        i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), p, 0);
+                        if (i == 0) {
                                 /* no ciphers */
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE);
                                 return -1;
-                                }
-                        s2n(i,d);
-                        p+=i;
-                        
+                        }
+                        s2n(i, d);
+                        p += i;
+
                         /* put in the session-id length (zero since there is no reuse) */
 #if 0
-                        s->session->session_id_length=0;
+                        s->session->session_id_length = 0;
 #endif
-                        s2n(0,d);
+                        s2n(0, d);
 
                         if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG)
-                                ch_len=SSL2_CHALLENGE_LENGTH;
+                                ch_len = SSL2_CHALLENGE_LENGTH;
                         else
-                                ch_len=SSL2_MAX_CHALLENGE_LENGTH;
+                                ch_len = SSL2_MAX_CHALLENGE_LENGTH;
 
                         /* write out sslv2 challenge */
                         /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32),
@@ -462,34 +448,32 @@ static int ssl23_client_hello(SSL *s)
                            or SSL2_MAX_CHALLENGE_LENGTH (16), but leave the
                            check in for futurproofing */
                         if (SSL3_RANDOM_SIZE < ch_len)
-                                i=SSL3_RANDOM_SIZE;
+                                i = SSL3_RANDOM_SIZE;
                         else
-                                i=ch_len;
-                        s2n(i,d);
-                        memset(&(s->s3->client_random[0]),0,SSL3_RANDOM_SIZE);
-                        if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i) <= 0)
+                                i = ch_len;
+                        s2n(i, d);
+                        memset(&(s->s3->client_random[0]), 0, SSL3_RANDOM_SIZE);
+                        if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i) <= 0)
                                 return -1;
 
-                        memcpy(p,&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
-                        p+=i;
+                        memcpy(p, &(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i);
+                        p += i;
 
-                        i= p- &(buf[2]);
-                        buf[0]=((i>>8)&0xff)|0x80;
-                        buf[1]=(i&0xff);
+                        i = p- &(buf[2]);
+                        buf[0] = ((i >> 8)&0xff)|0x80;
+                        buf[1] = (i&0xff);
 
                         /* number of bytes to write */
-                        s->init_num=i+2;
-                        s->init_off=0;
+                        s->init_num = i + 2;
+                        s->init_off = 0;
 
-                        ssl3_finish_mac(s,&(buf[2]),i);
-                        }
-                else
-                        {
+                        ssl3_finish_mac(s, &(buf[2]), i);
+                } else {
                         /* create Client Hello in SSL 3.0/TLS 1.0 format */
 
                         /* do the record header (5 bytes) and handshake message header (4 bytes) last */
                         d = p = &(buf[9]);
-                        
+
                         *(p++) = version_major;
                         *(p++) = version_minor;
 
@@ -501,73 +485,68 @@ static int ssl23_client_hello(SSL *s)
                         *(p++) = 0;
 
                         /* Ciphers supported (using SSL 3.0/TLS 1.0 format) */
-                        i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),&(p[2]),ssl3_put_cipher_by_char);
-                        if (i == 0)
-                                {
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);
+                        i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), &(p[2]), ssl3_put_cipher_by_char);
+                        if (i == 0) {
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE);
                                 return -1;
-                                }
+                        }
 #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
                         /* Some servers hang if client hello > 256 bytes
                          * as hack workaround chop number of supported ciphers
                          * to keep it well below this if we use TLS v1.2
                          */
-                        if (TLS1_get_version(s) >= TLS1_2_VERSION
-                                && i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)
+                        if (TLS1_get_version(s) >= TLS1_2_VERSION &&
+                            i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)
                                 i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
 #endif
-                        s2n(i,p);
-                        p+=i;
+                        s2n(i, p);
+                        p += i;
 
                         /* COMPRESSION */
 #ifdef OPENSSL_NO_COMP
-                        *(p++)=1;
+                        *(p++) = 1;
 #else
-                        if ((s->options & SSL_OP_NO_COMPRESSION)
-                                                || !s->ctx->comp_methods)
-                                j=0;
+                        if ((s->options & SSL_OP_NO_COMPRESSION) ||
+                            !s->ctx->comp_methods)
+                                j = 0;
                         else
-                                j=sk_SSL_COMP_num(s->ctx->comp_methods);
-                        *(p++)=1+j;
-                        for (i=0; i<j; i++)
-                                {
-                                comp=sk_SSL_COMP_value(s->ctx->comp_methods,i);
-                                *(p++)=comp->id;
-                                }
+                                j = sk_SSL_COMP_num(s->ctx->comp_methods);
+                        *(p++) = 1 + j;
+                        for (i = 0; i < j; i++) {
+                                comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);
+                                *(p++) = comp->id;
+                        }
 #endif
                         *(p++)=0; /* Add the NULL method */
 
 #ifndef OPENSSL_NO_TLSEXT
                         /* TLS extensions*/
-                        if (ssl_prepare_clienthello_tlsext(s) <= 0)
-                                {
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_CLIENTHELLO_TLSEXT);
+                        if (ssl_prepare_clienthello_tlsext(s) <= 0) {
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
                                 return -1;
-                                }
-                        if ((p = ssl_add_clienthello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH)) == NULL)
-                                {
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR);
+                        }
+                        if ((p = ssl_add_clienthello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH)) == NULL) {
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
                                 return -1;
-                                }
+                        }
 #endif
-                        
-                        l = p-d;
+
+                        l = p - d;
 
                         /* fill in 4-byte handshake header */
-                        d=&(buf[5]);
-                        *(d++)=SSL3_MT_CLIENT_HELLO;
-                        l2n3(l,d);
+                        d = &(buf[5]);
+                        *(d++) = SSL3_MT_CLIENT_HELLO;
+                        l2n3(l, d);
 
                         l += 4;
 
-                        if (l > SSL3_RT_MAX_PLAIN_LENGTH)
-                                {
-                                SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR);
+                        if (l > SSL3_RT_MAX_PLAIN_LENGTH) {
+                                SSLerr(SSL_F_SSL23_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
                                 return -1;
-                                }
-                        
+                        }
+
                         /* fill in 5-byte record header */
-                        d=buf;
+                        d = buf;
                         *(d++) = SSL3_RT_HANDSHAKE;
                         *(d++) = version_major;
                         /* Some servers hang if we use long client hellos
@@ -577,54 +556,54 @@ static int ssl23_client_hello(SSL *s)
                                 *(d++) = 1;
                         else
                                 *(d++) = version_minor;
-                        s2n((int)l,d);
+                        s2n((int)l, d);
 
                         /* number of bytes to write */
-                        s->init_num=p-buf;
-                        s->init_off=0;
-
-                        ssl3_finish_mac(s,&(buf[5]), s->init_num - 5);
-                        }
+                        s->init_num = p - buf;
+                        s->init_off = 0;
 
-                s->state=SSL23_ST_CW_CLNT_HELLO_B;
-                s->init_off=0;
+                        ssl3_finish_mac(s, &(buf[5]), s->init_num - 5);
                 }
 
+                s->state = SSL23_ST_CW_CLNT_HELLO_B;
+                s->init_off = 0;
+        }
+
         /* SSL3_ST_CW_CLNT_HELLO_B */
         ret = ssl23_write_bytes(s);
 
-        if ((ret >= 2) && s->msg_callback)
-                {
+        if ((ret >= 2) && s->msg_callback) {
                 /* Client Hello has been sent; tell msg_callback */
 
                 if (ssl2_compat)
-                        s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data+2, ret-2, s, s->msg_callback_arg);
+                        s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data + 2, ret - 2, s, s->msg_callback_arg);
                 else
-                        s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data+5, ret-5, s, s->msg_callback_arg);
-                }
+                        s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data + 5, ret - 5, s, s->msg_callback_arg);
+        }
 
         return ret;
-        }
+}
 
-static int ssl23_get_server_hello(SSL *s)
-        {
+static int
+ssl23_get_server_hello(SSL *s)
+{
         char buf[8];
         unsigned char *p;
         int i;
         int n;
 
-        n=ssl23_read_bytes(s,7);
+        n = ssl23_read_bytes(s, 7);
 
-        if (n != 7) return(n);
-        p=s->packet;
+        if (n != 7)
+                return (n);
+        p = s->packet;
 
-        memcpy(buf,p,n);
+        memcpy(buf, p, n);
 
         if ((p[0] & 0x80) && (p[2] == SSL2_MT_SERVER_HELLO) &&
-                (p[5] == 0x00) && (p[6] == 0x02))
-                {
+                (p[5] == 0x00) && (p[6] == 0x02)) {
 #ifdef OPENSSL_NO_SSL2
-                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL);
                 goto err;
 #else
                 /* we are talking sslv2 */
@@ -632,169 +611,150 @@ static int ssl23_get_server_hello(SSL *s)
                  * sslv2 stuff. */
                 int ch_len;
 
-                if (s->options & SSL_OP_NO_SSLv2)
-                        {
-                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+                if (s->options & SSL_OP_NO_SSLv2) {
+                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL);
                         goto err;
-                        }
-                if (s->s2 == NULL)
-                        {
+                }
+                if (s->s2 == NULL) {
                         if (!ssl2_new(s))
                                 goto err;
-                        }
-                else
+                } else
                         ssl2_clear(s);
 
                 if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG)
-                        ch_len=SSL2_CHALLENGE_LENGTH;
+                        ch_len = SSL2_CHALLENGE_LENGTH;
                 else
-                        ch_len=SSL2_MAX_CHALLENGE_LENGTH;
+                        ch_len = SSL2_MAX_CHALLENGE_LENGTH;
 
                 /* write out sslv2 challenge */
                 /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32), because
                    it is one of SSL2_MAX_CHALLENGE_LENGTH (32) or
                    SSL2_MAX_CHALLENGE_LENGTH (16), but leave the check in for
                    futurproofing */
-                i=(SSL3_RANDOM_SIZE < ch_len)
-                        ?SSL3_RANDOM_SIZE:ch_len;
-                s->s2->challenge_length=i;
+                i = (SSL3_RANDOM_SIZE < ch_len) ? SSL3_RANDOM_SIZE : ch_len;
+                s->s2->challenge_length = i;
                 memcpy(s->s2->challenge,
-                        &(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
+                    &(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i);
 
-                if (s->s3 != NULL) ssl3_free(s);
+                if (s->s3 != NULL)
+                        ssl3_free(s);
 
                 if (!BUF_MEM_grow_clean(s->init_buf,
-                        SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER))
-                        {
-                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,ERR_R_BUF_LIB);
+                    SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) {
+                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, ERR_R_BUF_LIB);
                         goto err;
-                        }
+                }
 
-                s->state=SSL2_ST_GET_SERVER_HELLO_A;
+                s->state = SSL2_ST_GET_SERVER_HELLO_A;
                 if (!(s->client_version == SSL2_VERSION))
                         /* use special padding (SSL 3.0 draft/RFC 2246, App. E.2) */
-                        s->s2->ssl2_rollback=1;
+                        s->s2->ssl2_rollback = 1;
 
                 /* setup the 7 bytes we have read so we get them from
                  * the sslv2 buffer */
-                s->rstate=SSL_ST_READ_HEADER;
-                s->packet_length=n;
-                s->packet= &(s->s2->rbuf[0]);
-                memcpy(s->packet,buf,n);
-                s->s2->rbuf_left=n;
-                s->s2->rbuf_offs=0;
+                s->rstate = SSL_ST_READ_HEADER;
+                s->packet_length = n;
+                s->packet = &(s->s2->rbuf[0]);
+                memcpy(s->packet, buf, n);
+                s->s2->rbuf_left = n;
+                s->s2->rbuf_offs = 0;
 
                 /* we have already written one */
-                s->s2->write_sequence=1;
+                s->s2->write_sequence = 1;
 
-                s->method=SSLv2_client_method();
-                s->handshake_func=s->method->ssl_connect;
+                s->method = SSLv2_client_method();
+                s->handshake_func = s->method->ssl_connect;
 #endif
-                }
-        else if (p[1] == SSL3_VERSION_MAJOR &&
-                 p[2] <= TLS1_2_VERSION_MINOR &&
-                 ((p[0] == SSL3_RT_HANDSHAKE && p[5] == SSL3_MT_SERVER_HELLO) ||
-                  (p[0] == SSL3_RT_ALERT && p[3] == 0 && p[4] == 2)))
-                {
+        } else if (p[1] == SSL3_VERSION_MAJOR &&
+            p[2] <= TLS1_2_VERSION_MINOR &&
+            ((p[0] == SSL3_RT_HANDSHAKE && p[5] == SSL3_MT_SERVER_HELLO) ||
+            (p[0] == SSL3_RT_ALERT && p[3] == 0 && p[4] == 2))) {
                 /* we have sslv3 or tls1 (server hello or alert) */
 
                 if ((p[2] == SSL3_VERSION_MINOR) &&
-                        !(s->options & SSL_OP_NO_SSLv3))
-                        {
+                    !(s->options & SSL_OP_NO_SSLv3)) {
 #ifdef OPENSSL_FIPS
-                        if(FIPS_mode())
-                                {
+                        if (FIPS_mode()) {
                                 SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,
-                                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
+                                SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
                                 goto err;
-                                }
-#endif
-                        s->version=SSL3_VERSION;
-                        s->method=SSLv3_client_method();
-                        }
-                else if ((p[2] == TLS1_VERSION_MINOR) &&
-                        !(s->options & SSL_OP_NO_TLSv1))
-                        {
-                        s->version=TLS1_VERSION;
-                        s->method=TLSv1_client_method();
                         }
-                else if ((p[2] == TLS1_1_VERSION_MINOR) &&
-                        !(s->options & SSL_OP_NO_TLSv1_1))
-                        {
-                        s->version=TLS1_1_VERSION;
-                        s->method=TLSv1_1_client_method();
-                        }
-                else if ((p[2] == TLS1_2_VERSION_MINOR) &&
-                        !(s->options & SSL_OP_NO_TLSv1_2))
-                        {
-                        s->version=TLS1_2_VERSION;
-                        s->method=TLSv1_2_client_method();
-                        }
-                else
-                        {
-                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+#endif
+                        s->version = SSL3_VERSION;
+                        s->method = SSLv3_client_method();
+                } else if ((p[2] == TLS1_VERSION_MINOR) &&
+                    !(s->options & SSL_OP_NO_TLSv1)) {
+                        s->version = TLS1_VERSION;
+                        s->method = TLSv1_client_method();
+                } else if ((p[2] == TLS1_1_VERSION_MINOR) &&
+                    !(s->options & SSL_OP_NO_TLSv1_1)) {
+                        s->version = TLS1_1_VERSION;
+                        s->method = TLSv1_1_client_method();
+                } else if ((p[2] == TLS1_2_VERSION_MINOR) &&
+                    !(s->options & SSL_OP_NO_TLSv1_2)) {
+                        s->version = TLS1_2_VERSION;
+                        s->method = TLSv1_2_client_method();
+                } else {
+                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL);
                         goto err;
-                        }
+                }
 
-                if (p[0] == SSL3_RT_ALERT && p[5] != SSL3_AL_WARNING)
-                        {
+                if (p[0] == SSL3_RT_ALERT && p[5] != SSL3_AL_WARNING) {
                         /* fatal alert */
 
-                        void (*cb)(const SSL *ssl,int type,int val)=NULL;
+                        void (*cb)(const SSL *ssl, int type, int val) = NULL;
                         int j;
 
                         if (s->info_callback != NULL)
-                                cb=s->info_callback;
+                                cb = s->info_callback;
                         else if (s->ctx->info_callback != NULL)
-                                cb=s->ctx->info_callback;
- 
-                        i=p[5];
-                        if (cb != NULL)
-                                {
-                                j=(i<<8)|p[6];
-                                cb(s,SSL_CB_READ_ALERT,j);
-                                }
-                        
+                                cb = s->ctx->info_callback;
+
+                        i = p[5];
+                        if (cb != NULL) {
+                                j = (i << 8) | p[6];
+                                cb(s, SSL_CB_READ_ALERT, j);
+                        }
+
                         if (s->msg_callback)
-                                s->msg_callback(0, s->version, SSL3_RT_ALERT, p+5, 2, s, s->msg_callback_arg);
+                                s->msg_callback(0, s->version, SSL3_RT_ALERT, p + 5, 2, s, s->msg_callback_arg);
 
-                        s->rwstate=SSL_NOTHING;
-                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_AD_REASON_OFFSET+p[6]);
+                        s->rwstate = SSL_NOTHING;
+                        SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_AD_REASON_OFFSET + p[6]);
                         goto err;
-                        }
+                }
 
-                if (!ssl_init_wbio_buffer(s,1)) goto err;
+                if (!ssl_init_wbio_buffer(s, 1))
+                        goto err;
 
                 /* we are in this state */
-                s->state=SSL3_ST_CR_SRVR_HELLO_A;
+                s->state = SSL3_ST_CR_SRVR_HELLO_A;
 
                 /* put the 7 bytes we have read into the input buffer
                  * for SSLv3 */
-                s->rstate=SSL_ST_READ_HEADER;
-                s->packet_length=n;
+                s->rstate = SSL_ST_READ_HEADER;
+                s->packet_length = n;
                 if (s->s3->rbuf.buf == NULL)
                         if (!ssl3_setup_read_buffer(s))
                                 goto err;
-                s->packet= &(s->s3->rbuf.buf[0]);
-                memcpy(s->packet,buf,n);
-                s->s3->rbuf.left=n;
-                s->s3->rbuf.offset=0;
-
-                s->handshake_func=s->method->ssl_connect;
-                }
-        else
-                {
-                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNKNOWN_PROTOCOL);
+                s->packet = &(s->s3->rbuf.buf[0]);
+                memcpy(s->packet, buf, n);
+                s->s3->rbuf.left = n;
+                s->s3->rbuf.offset = 0;
+
+                s->handshake_func = s->method->ssl_connect;
+        } else {
+                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNKNOWN_PROTOCOL);
                 goto err;
-                }
-        s->init_num=0;
+        }
+        s->init_num = 0;
 
         /* Since, if we are sending a ssl23 client hello, we are not
          * reusing a session-id */
-        if (!ssl_get_new_session(s,0))
+        if (!ssl_get_new_session(s, 0))
                 goto err;
 
-        return(SSL_connect(s));
+        return (SSL_connect(s));
 err:
-        return(-1);
-        }
+        return (-1);
+}
diff --git a/src/lib/libssl/src/ssl/s23_lib.c b/src/lib/libssl/src/ssl/s23_lib.c
index a6285b767f..3a4d5a6ecb 100644
--- a/src/lib/libssl/src/ssl/s23_lib.c
+++ b/src/lib/libssl/src/ssl/s23_lib.c
@@ -60,128 +60,126 @@
 #include <openssl/objects.h>
 #include "ssl_locl.h"
 
-long ssl23_default_timeout(void)
-        {
-        return(300);
-        }
+long
+ssl23_default_timeout(void)
+{
+        return (300);
+}
 
-int ssl23_num_ciphers(void)
-        {
+int
+ssl23_num_ciphers(void)
+{
         return(ssl3_num_ciphers()
 #ifndef OPENSSL_NO_SSL2
-               + ssl2_num_ciphers()
+        + ssl2_num_ciphers()
 #endif
-            );
-        }
+        );
+}
 
-const SSL_CIPHER *ssl23_get_cipher(unsigned int u)
-        {
-        unsigned int uu=ssl3_num_ciphers();
+const SSL_CIPHER
+*ssl23_get_cipher(unsigned int u)
+{
+        unsigned int uu = ssl3_num_ciphers();
 
         if (u < uu)
-                return(ssl3_get_cipher(u));
+                return (ssl3_get_cipher(u));
         else
 #ifndef OPENSSL_NO_SSL2
-                return(ssl2_get_cipher(u-uu));
+        return (ssl2_get_cipher(u - uu));
 #else
-                return(NULL);
+        return (NULL);
 #endif
-        }
+}
 
 /* This function needs to check if the ciphers required are actually
  * available */
-const SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p)
-        {
+const SSL_CIPHER
+*ssl23_get_cipher_by_char(const unsigned char *p)
+{
         const SSL_CIPHER *cp;
 
-        cp=ssl3_get_cipher_by_char(p);
+        cp = ssl3_get_cipher_by_char(p);
 #ifndef OPENSSL_NO_SSL2
         if (cp == NULL)
-                cp=ssl2_get_cipher_by_char(p);
+                cp = ssl2_get_cipher_by_char(p);
 #endif
-        return(cp);
-        }
+        return (cp);
+}
 
-int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
-        {
+int
+ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
+{
         long l;
 
         /* We can write SSLv2 and SSLv3 ciphers */
-        if (p != NULL)
-                {
-                l=c->id;
-                p[0]=((unsigned char)(l>>16L))&0xFF;
-                p[1]=((unsigned char)(l>> 8L))&0xFF;
-                p[2]=((unsigned char)(l     ))&0xFF;
-                }
-        return(3);
+        if (p != NULL) {
+                l = c->id;
+                p[0] = ((unsigned char)(l >> 16L))&0xFF;
+                p[1] = ((unsigned char)(l >> 8L))&0xFF;
+                p[2] = ((unsigned char)(l     ))&0xFF;
         }
+        return (3);
+}
 
-int ssl23_read(SSL *s, void *buf, int len)
-        {
+int
+ssl23_read(SSL *s, void *buf, int len)
+{
         int n;
 
         errno = 0;
-        if (SSL_in_init(s) && (!s->in_handshake))
-                {
-                n=s->handshake_func(s);
-                if (n < 0) return(n);
-                if (n == 0)
-                        {
-                        SSLerr(SSL_F_SSL23_READ,SSL_R_SSL_HANDSHAKE_FAILURE);
-                        return(-1);
-                        }
-                return(SSL_read(s,buf,len));
+        if (SSL_in_init(s) && (!s->in_handshake)) {
+                n = s->handshake_func(s);
+                if (n < 0)
+                        return (n);
+                if (n == 0) {
+                        SSLerr(SSL_F_SSL23_READ, SSL_R_SSL_HANDSHAKE_FAILURE);
+                        return (-1);
                 }
-        else
-                {
+                return (SSL_read(s, buf, len));
+        } else {
                 ssl_undefined_function(s);
-                return(-1);
-                }
+                return (-1);
         }
+}
 
-int ssl23_peek(SSL *s, void *buf, int len)
-        {
+int
+ssl23_peek(SSL *s, void *buf, int len)
+{
         int n;
 
         errno = 0;
-        if (SSL_in_init(s) && (!s->in_handshake))
-                {
-                n=s->handshake_func(s);
-                if (n < 0) return(n);
-                if (n == 0)
-                        {
-                        SSLerr(SSL_F_SSL23_PEEK,SSL_R_SSL_HANDSHAKE_FAILURE);
-                        return(-1);
-                        }
-                return(SSL_peek(s,buf,len));
+        if (SSL_in_init(s) && (!s->in_handshake)) {
+                n = s->handshake_func(s);
+                if (n < 0)
+                        return (n);
+                if (n == 0) {
+                        SSLerr(SSL_F_SSL23_PEEK, SSL_R_SSL_HANDSHAKE_FAILURE);
+                        return (-1);
                 }
-        else
-                {
+                return (SSL_peek(s, buf, len));
+        } else {
                 ssl_undefined_function(s);
-                return(-1);
-                }
+                return (-1);
         }
+}
 
-int ssl23_write(SSL *s, const void *buf, int len)
-        {
+int
+ssl23_write(SSL *s, const void *buf, int len)
+{
         int n;
 
         errno = 0;
-        if (SSL_in_init(s) && (!s->in_handshake))
-                {
-                n=s->handshake_func(s);
-                if (n < 0) return(n);
-                if (n == 0)
-                        {
-                        SSLerr(SSL_F_SSL23_WRITE,SSL_R_SSL_HANDSHAKE_FAILURE);
-                        return(-1);
-                        }
-                return(SSL_write(s,buf,len));
+        if (SSL_in_init(s) && (!s->in_handshake)) {
+                n = s->handshake_func(s);
+                if (n < 0)
+                        return (n);
+                if (n == 0) {
+                        SSLerr(SSL_F_SSL23_WRITE, SSL_R_SSL_HANDSHAKE_FAILURE);
+                        return (-1);
                 }
-        else
-                {
+                return (SSL_write(s, buf, len));
+        } else {
                 ssl_undefined_function(s);
-                return(-1);
-                }
+                return (-1);
         }
+}
diff --git a/src/lib/libssl/src/ssl/s23_meth.c b/src/lib/libssl/src/ssl/s23_meth.c
index 40eae0f0be..ca1bb6819f 100644
--- a/src/lib/libssl/src/ssl/s23_meth.c
+++ b/src/lib/libssl/src/ssl/s23_meth.c
@@ -61,32 +61,31 @@
 #include "ssl_locl.h"
 
 static const SSL_METHOD *ssl23_get_method(int ver);
-static const SSL_METHOD *ssl23_get_method(int ver)
-        {
+static const SSL_METHOD
+*ssl23_get_method(int ver)
+{
 #ifndef OPENSSL_NO_SSL2
         if (ver == SSL2_VERSION)
-                return(SSLv2_method());
+                return (SSLv2_method());
         else
 #endif
 #ifndef OPENSSL_NO_SSL3
         if (ver == SSL3_VERSION)
-                return(SSLv3_method());
+                return (SSLv3_method());
         else
 #endif
 #ifndef OPENSSL_NO_TLS1
         if (ver == TLS1_VERSION)
-                return(TLSv1_method());
+                return (TLSv1_method());
         else if (ver == TLS1_1_VERSION)
-                return(TLSv1_1_method());
+                return (TLSv1_1_method());
         else if (ver == TLS1_2_VERSION)
-                return(TLSv1_2_method());
+                return (TLSv1_2_method());
         else
 #endif
-                return(NULL);
-        }
+        return (NULL);
+}
 
 IMPLEMENT_ssl23_meth_func(SSLv23_method,
-                        ssl23_accept,
-                        ssl23_connect,
-                        ssl23_get_method)
+    ssl23_accept, ssl23_connect, ssl23_get_method)
 
diff --git a/src/lib/libssl/src/ssl/s23_pkt.c b/src/lib/libssl/src/ssl/s23_pkt.c
index eba8d9d8fc..28d07a2212 100644
--- a/src/lib/libssl/src/ssl/s23_pkt.c
+++ b/src/lib/libssl/src/ssl/s23_pkt.c
@@ -62,55 +62,53 @@
 #include <openssl/evp.h>
 #include <openssl/buffer.h>
 
-int ssl23_write_bytes(SSL *s)
-        {
-        int i,num,tot;
+int
+ssl23_write_bytes(SSL *s)
+{
+        int i, num, tot;
         char *buf;
 
-        buf=s->init_buf->data;
-        tot=s->init_off;
-        num=s->init_num;
-        for (;;)
-                {
-                s->rwstate=SSL_WRITING;
-                i=BIO_write(s->wbio,&(buf[tot]),num);
-                if (i <= 0)
-                        {
-                        s->init_off=tot;
-                        s->init_num=num;
-                        return(i);
-                        }
-                s->rwstate=SSL_NOTHING;
-                if (i == num) return(tot+i);
-
-                num-=i;
-                tot+=i;
+        buf = s->init_buf->data;
+        tot = s->init_off;
+        num = s->init_num;
+        for (;;) {
+                s->rwstate = SSL_WRITING;
+                i = BIO_write(s->wbio, &(buf[tot]), num);
+                if (i <= 0) {
+                        s->init_off = tot;
+                        s->init_num = num;
+                        return (i);
                 }
+                s->rwstate = SSL_NOTHING;
+                if (i == num)
+                        return (tot + i);
+
+                num -= i;
+                tot += i;
         }
+}
 
 /* return regularly only when we have read (at least) 'n' bytes */
-int ssl23_read_bytes(SSL *s, int n)
-        {
+int
+ssl23_read_bytes(SSL *s, int n)
+{
         unsigned char *p;
         int j;
 
-        if (s->packet_length < (unsigned int)n)
-                {
-                p=s->packet;
+        if (s->packet_length < (unsigned int)n) {
+                p = s->packet;
 
-                for (;;)
-                        {
-                        s->rwstate=SSL_READING;
-                        j=BIO_read(s->rbio,(char *)&(p[s->packet_length]),
-                                n-s->packet_length);
+                for (;;) {
+                        s->rwstate = SSL_READING;
+                        j = BIO_read(s->rbio,(char *)&(p[s->packet_length]),
+                        n - s->packet_length);
                         if (j <= 0)
-                                return(j);
-                        s->rwstate=SSL_NOTHING;
-                        s->packet_length+=j;
+                                return (j);
+                        s->rwstate = SSL_NOTHING;
+                        s->packet_length += j;
                         if (s->packet_length >= (unsigned int)n)
-                                return(s->packet_length);
-                        }
+                                return (s->packet_length);
                 }
-        return(n);
         }
-
+        return (n);
+}
diff --git a/src/lib/libssl/src/ssl/s23_srvr.c b/src/lib/libssl/src/ssl/s23_srvr.c
index 2ac8786c62..35db7b4992 100644
--- a/src/lib/libssl/src/ssl/s23_srvr.c
+++ b/src/lib/libssl/src/ssl/s23_srvr.c
@@ -121,227 +121,209 @@
 
 static const SSL_METHOD *ssl23_get_server_method(int ver);
 int ssl23_get_client_hello(SSL *s);
-static const SSL_METHOD *ssl23_get_server_method(int ver)
-        {
+static const SSL_METHOD
+*ssl23_get_server_method(int ver)
+{
 #ifndef OPENSSL_NO_SSL2
         if (ver == SSL2_VERSION)
-                return(SSLv2_server_method());
+                return (SSLv2_server_method());
 #endif
         if (ver == SSL3_VERSION)
-                return(SSLv3_server_method());
+                return (SSLv3_server_method());
         else if (ver == TLS1_VERSION)
-                return(TLSv1_server_method());
+                return (TLSv1_server_method());
         else if (ver == TLS1_1_VERSION)
-                return(TLSv1_1_server_method());
+                return (TLSv1_1_server_method());
         else if (ver == TLS1_2_VERSION)
-                return(TLSv1_2_server_method());
+                return (TLSv1_2_server_method());
         else
-                return(NULL);
-        }
+                return (NULL);
+}
 
 IMPLEMENT_ssl23_meth_func(SSLv23_server_method,
-                        ssl23_accept,
-                        ssl_undefined_function,
-                        ssl23_get_server_method)
+    ssl23_accept, ssl_undefined_function, ssl23_get_server_method)
 
-int ssl23_accept(SSL *s)
-        {
+int
+ssl23_accept(SSL *s)
+{
         BUF_MEM *buf;
-        unsigned long Time=(unsigned long)time(NULL);
-        void (*cb)(const SSL *ssl,int type,int val)=NULL;
-        int ret= -1;
-        int new_state,state;
+        unsigned long Time = (unsigned long)time(NULL);
+        void (*cb)(const SSL *ssl, int type, int val) = NULL;
+        int ret = -1;
+        int new_state, state;
 
-        RAND_add(&Time,sizeof(Time),0);
+        RAND_add(&Time, sizeof(Time), 0);
         ERR_clear_error();
         errno = 0;
 
         if (s->info_callback != NULL)
-                cb=s->info_callback;
+                cb = s->info_callback;
         else if (s->ctx->info_callback != NULL)
-                cb=s->ctx->info_callback;
-        
+                cb = s->ctx->info_callback;
+
         s->in_handshake++;
-        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
+        if (!SSL_in_init(s) || SSL_in_before(s))
+                SSL_clear(s);
 
-        for (;;)
-                {
-                state=s->state;
+        for (;;) {
+                state = s->state;
 
-                switch(s->state)
-                        {
+                switch (s->state) {
                 case SSL_ST_BEFORE:
                 case SSL_ST_ACCEPT:
                 case SSL_ST_BEFORE|SSL_ST_ACCEPT:
                 case SSL_ST_OK|SSL_ST_ACCEPT:
 
-                        s->server=1;
-                        if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
+                        s->server = 1;
+                        if (cb != NULL)
+                                cb(s, SSL_CB_HANDSHAKE_START, 1);
 
                         /* s->version=SSL3_VERSION; */
-                        s->type=SSL_ST_ACCEPT;
+                        s->type = SSL_ST_ACCEPT;
 
-                        if (s->init_buf == NULL)
-                                {
-                                if ((buf=BUF_MEM_new()) == NULL)
-                                        {
-                                        ret= -1;
+                        if (s->init_buf == NULL) {
+                                if ((buf = BUF_MEM_new()) == NULL) {
+                                        ret = -1;
                                         goto end;
-                                        }
-                                if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
-                                        {
-                                        ret= -1;
+                                }
+                                if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) {
+                                        ret = -1;
                                         goto end;
-                                        }
-                                s->init_buf=buf;
                                 }
+                                s->init_buf = buf;
+                        }
 
                         ssl3_init_finished_mac(s);
 
-                        s->state=SSL23_ST_SR_CLNT_HELLO_A;
+                        s->state = SSL23_ST_SR_CLNT_HELLO_A;
                         s->ctx->stats.sess_accept++;
-                        s->init_num=0;
+                        s->init_num = 0;
                         break;
 
                 case SSL23_ST_SR_CLNT_HELLO_A:
                 case SSL23_ST_SR_CLNT_HELLO_B:
 
-                        s->shutdown=0;
-                        ret=ssl23_get_client_hello(s);
-                        if (ret >= 0) cb=NULL;
+                        s->shutdown = 0;
+                        ret = ssl23_get_client_hello(s);
+                        if (ret >= 0)
+                                cb = NULL;
                         goto end;
                         /* break; */
 
                 default:
-                        SSLerr(SSL_F_SSL23_ACCEPT,SSL_R_UNKNOWN_STATE);
-                        ret= -1;
+                        SSLerr(SSL_F_SSL23_ACCEPT, SSL_R_UNKNOWN_STATE);
+                        ret = -1;
                         goto end;
                         /* break; */
-                        }
+                }
 
-                if ((cb != NULL) && (s->state != state))
-                        {
-                        new_state=s->state;
-                        s->state=state;
-                        cb(s,SSL_CB_ACCEPT_LOOP,1);
-                        s->state=new_state;
-                        }
+                if ((cb != NULL) && (s->state != state)) {
+                        new_state = s->state;
+                        s->state = state;
+                        cb(s, SSL_CB_ACCEPT_LOOP, 1);
+                        s->state = new_state;
                 }
+        }
 end:
         s->in_handshake--;
         if (cb != NULL)
-                cb(s,SSL_CB_ACCEPT_EXIT,ret);
-        return(ret);
-        }
+                cb(s, SSL_CB_ACCEPT_EXIT, ret);
+        return (ret);
+}
 
 
-int ssl23_get_client_hello(SSL *s)
-        {
+int
+ssl23_get_client_hello(SSL *s)
+{
         char buf_space[11]; /* Request this many bytes in initial read.
-                             * We can detect SSL 3.0/TLS 1.0 Client Hellos
-                             * ('type == 3') correctly only when the following
-                             * is in a single record, which is not guaranteed by
-                             * the protocol specification:
-                             * Byte  Content
-                             *  0     type            \
+        * We can detect SSL 3.0/TLS 1.0 Client Hellos
+        * ('type == 3') correctly only when the following
+        * is in a single record, which is not guaranteed by
+        * the protocol specification:
+        * Byte  Content
+        *  0     type            \
                              *  1/2   version          > record header
-                             *  3/4   length          /
-                             *  5     msg_type        \
+        *  3/4   length          /
+        *  5     msg_type        \
                              *  6-8   length           > Client Hello message
-                             *  9/10  client_version  /
+        *  9/10  client_version  /
                              */
-        char *buf= &(buf_space[0]);
-        unsigned char *p,*d,*d_len,*dd;
+        char *buf = &(buf_space[0]);
+        unsigned char *p, *d, *d_len, *dd;
         unsigned int i;
-        unsigned int csl,sil,cl;
-        int n=0,j;
-        int type=0;
+        unsigned int csl, sil, cl;
+        int n = 0, j;
+        int type = 0;
         int v[2];
 
-        if (s->state == SSL23_ST_SR_CLNT_HELLO_A)
-                {
+        if (s->state == SSL23_ST_SR_CLNT_HELLO_A) {
                 /* read the initial header */
-                v[0]=v[1]=0;
+                v[0] = v[1] = 0;
 
-                if (!ssl3_setup_buffers(s)) goto err;
+                if (!ssl3_setup_buffers(s))
+                        goto err;
 
-                n=ssl23_read_bytes(s, sizeof buf_space);
-                if (n != sizeof buf_space) return(n); /* n == -1 || n == 0 */
+                n = ssl23_read_bytes(s, sizeof buf_space);
+                if (n != sizeof buf_space)
+                        return(n); /* n == -1 || n == 0 */
 
-                p=s->packet;
+                p = s->packet;
 
-                memcpy(buf,p,n);
+                memcpy(buf, p, n);
 
-                if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO))
-                        {
+                if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO)) {
                         /*
                          * SSLv2 header
                          */
-                        if ((p[3] == 0x00) && (p[4] == 0x02))
-                                {
-                                v[0]=p[3]; v[1]=p[4];
+                        if ((p[3] == 0x00) && (p[4] == 0x02)) {
+                                v[0] = p[3];
+                                v[1] = p[4];
                                 /* SSLv2 */
                                 if (!(s->options & SSL_OP_NO_SSLv2))
-                                        type=1;
-                                }
-                        else if (p[3] == SSL3_VERSION_MAJOR)
-                                {
-                                v[0]=p[3]; v[1]=p[4];
+                                        type = 1;
+                        } else if (p[3] == SSL3_VERSION_MAJOR) {
+                                v[0] = p[3];
+                                v[1] = p[4];
                                 /* SSLv3/TLSv1 */
-                                if (p[4] >= TLS1_VERSION_MINOR)
-                                        {
+                                if (p[4] >= TLS1_VERSION_MINOR) {
                                         if (p[4] >= TLS1_2_VERSION_MINOR &&
-                                           !(s->options & SSL_OP_NO_TLSv1_2))
-                                                {
-                                                s->version=TLS1_2_VERSION;
-                                                s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                                }
-                                        else if (p[4] >= TLS1_1_VERSION_MINOR &&
-                                           !(s->options & SSL_OP_NO_TLSv1_1))
-                                                {
-                                                s->version=TLS1_1_VERSION;
+                                            !(s->options & SSL_OP_NO_TLSv1_2)) {
+                                                s->version = TLS1_2_VERSION;
+                                                s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                        } else if (p[4] >= TLS1_1_VERSION_MINOR &&
+                                            !(s->options & SSL_OP_NO_TLSv1_1)) {
+                                                s->version = TLS1_1_VERSION;
                                                 /* type=2; */ /* done later to survive restarts */
-                                                s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                                }
-                                        else if (!(s->options & SSL_OP_NO_TLSv1))
-                                                {
-                                                s->version=TLS1_VERSION;
+                                                s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                        } else if (!(s->options & SSL_OP_NO_TLSv1)) {
+                                                s->version = TLS1_VERSION;
                                                 /* type=2; */ /* done later to survive restarts */
-                                                s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                                }
-                                        else if (!(s->options & SSL_OP_NO_SSLv3))
-                                                {
-                                                s->version=SSL3_VERSION;
+                                                s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                        } else if (!(s->options & SSL_OP_NO_SSLv3)) {
+                                                s->version = SSL3_VERSION;
                                                 /* type=2; */
-                                                s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                                }
-                                        else if (!(s->options & SSL_OP_NO_SSLv2))
-                                                {
-                                                type=1;
-                                                }
+                                                s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                        } else if (!(s->options & SSL_OP_NO_SSLv2)) {
+                                                type = 1;
                                         }
-                                else if (!(s->options & SSL_OP_NO_SSLv3))
-                                        {
-                                        s->version=SSL3_VERSION;
+                                } else if (!(s->options & SSL_OP_NO_SSLv3)) {
+                                        s->version = SSL3_VERSION;
                                         /* type=2; */
-                                        s->state=SSL23_ST_SR_CLNT_HELLO_B;
-                                        }
-                                else if (!(s->options & SSL_OP_NO_SSLv2))
-                                        type=1;
+                                        s->state = SSL23_ST_SR_CLNT_HELLO_B;
+                                } else if (!(s->options & SSL_OP_NO_SSLv2))
+                                        type = 1;
 
-                                }
                         }
-                else if ((p[0] == SSL3_RT_HANDSHAKE) &&
-                         (p[1] == SSL3_VERSION_MAJOR) &&
-                         (p[5] == SSL3_MT_CLIENT_HELLO) &&
-                         ((p[3] == 0 && p[4] < 5 /* silly record length? */)
-                                || (p[9] >= p[1])))
-                        {
+                } else if ((p[0] == SSL3_RT_HANDSHAKE) &&
+                    (p[1] == SSL3_VERSION_MAJOR) &&
+                    (p[5] == SSL3_MT_CLIENT_HELLO) &&
+                    ((p[3] == 0 && p[4] < 5 /* silly record length? */)
+                    || (p[9] >= p[1]))) {
                         /*
                          * SSLv3 or tls1 header
                          */
-                        
-                        v[0]=p[1]; /* major version (= SSL3_VERSION_MAJOR) */
+
+                        v[0] = p[1]; /* major version (= SSL3_VERSION_MAJOR) */
                         /* We must look at client_version inside the Client Hello message
                          * to get the correct minor version.
                          * However if we have only a pathologically small fragment of the
@@ -350,127 +332,108 @@ int ssl23_get_client_hello(SSL *s)
                          * No known SSL 3.0 client fragments ClientHello like this,
                          * so we simply assume TLS 1.0 to avoid protocol version downgrade
                          * attacks. */
-                        if (p[3] == 0 && p[4] < 6)
-                                {
+                        if (p[3] == 0 && p[4] < 6) {
 #if 0
-                                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_SMALL);
+                                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_TOO_SMALL);
                                 goto err;
 #else
                                 v[1] = TLS1_VERSION_MINOR;
 #endif
-                                }
+                        }
                         /* if major version number > 3 set minor to a value
                          * which will use the highest version 3 we support.
                          * If TLS 2.0 ever appears we will need to revise
                          * this....
                          */
                         else if (p[9] > SSL3_VERSION_MAJOR)
-                                v[1]=0xff;
+                                v[1] = 0xff;
                         else
-                                v[1]=p[10]; /* minor version according to client_version */
-                        if (v[1] >= TLS1_VERSION_MINOR)
-                                {
+                                v[1] = p[10]; /* minor version according to client_version */
+                        if (v[1] >= TLS1_VERSION_MINOR) {
                                 if (v[1] >= TLS1_2_VERSION_MINOR &&
-                                        !(s->options & SSL_OP_NO_TLSv1_2))
-                                        {
-                                        s->version=TLS1_2_VERSION;
-                                        type=3;
-                                        }
-                                else if (v[1] >= TLS1_1_VERSION_MINOR &&
-                                        !(s->options & SSL_OP_NO_TLSv1_1))
-                                        {
-                                        s->version=TLS1_1_VERSION;
-                                        type=3;
-                                        }
-                                else if (!(s->options & SSL_OP_NO_TLSv1))
-                                        {
-                                        s->version=TLS1_VERSION;
-                                        type=3;
-                                        }
-                                else if (!(s->options & SSL_OP_NO_SSLv3))
-                                        {
-                                        s->version=SSL3_VERSION;
-                                        type=3;
-                                        }
+                                    !(s->options & SSL_OP_NO_TLSv1_2)) {
+                                        s->version = TLS1_2_VERSION;
+                                        type = 3;
+                                } else if (v[1] >= TLS1_1_VERSION_MINOR &&
+                                    !(s->options & SSL_OP_NO_TLSv1_1)) {
+                                        s->version = TLS1_1_VERSION;
+                                        type = 3;
+                                } else if (!(s->options & SSL_OP_NO_TLSv1)) {
+                                        s->version = TLS1_VERSION;
+                                        type = 3;
+                                } else if (!(s->options & SSL_OP_NO_SSLv3)) {
+                                        s->version = SSL3_VERSION;
+                                        type = 3;
                                 }
-                        else
-                                {
+                        } else {
                                 /* client requests SSL 3.0 */
-                                if (!(s->options & SSL_OP_NO_SSLv3))
-                                        {
-                                        s->version=SSL3_VERSION;
-                                        type=3;
-                                        }
-                                else if (!(s->options & SSL_OP_NO_TLSv1))
-                                        {
+                                if (!(s->options & SSL_OP_NO_SSLv3)) {
+                                        s->version = SSL3_VERSION;
+                                        type = 3;
+                                } else if (!(s->options & SSL_OP_NO_TLSv1)) {
                                         /* we won't be able to use TLS of course,
                                          * but this will send an appropriate alert */
-                                        s->version=TLS1_VERSION;
-                                        type=3;
-                                        }
+                                        s->version = TLS1_VERSION;
+                                        type = 3;
                                 }
                         }
-                else if ((strncmp("GET ", (char *)p,4) == 0) ||
-                         (strncmp("POST ",(char *)p,5) == 0) ||
-                         (strncmp("HEAD ",(char *)p,5) == 0) ||
-                         (strncmp("PUT ", (char *)p,4) == 0))
-                        {
-                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTP_REQUEST);
+                }
+                else if ((strncmp("GET ", (char *)p, 4) == 0) ||
+                    (strncmp("POST ",(char *)p, 5) == 0) ||
+                    (strncmp("HEAD ",(char *)p, 5) == 0) ||
+                    (strncmp("PUT ", (char *)p, 4) == 0)) {
+                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_HTTP_REQUEST);
                         goto err;
-                        }
-                else if (strncmp("CONNECT",(char *)p,7) == 0)
-                        {
-                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTPS_PROXY_REQUEST);
+                } else if (strncmp("CONNECT", (char *)p, 7) == 0) {
+                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_HTTPS_PROXY_REQUEST);
                         goto err;
-                        }
                 }
+        }
 
 #ifdef OPENSSL_FIPS
-        if (FIPS_mode() && (s->version < TLS1_VERSION))
-                {
+        if (FIPS_mode() && (s->version < TLS1_VERSION)) {
                 SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,
-                                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
+                    SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
                 goto err;
-                }
+        }
 #endif
 
-        if (s->state == SSL23_ST_SR_CLNT_HELLO_B)
-                {
+        if (s->state == SSL23_ST_SR_CLNT_HELLO_B) {
                 /* we have SSLv3/TLSv1 in an SSLv2 header
                  * (other cases skip this state) */
 
-                type=2;
-                p=s->packet;
+                type = 2;
+                p = s->packet;
                 v[0] = p[3]; /* == SSL3_VERSION_MAJOR */
                 v[1] = p[4];
 
-                n=((p[0]&0x7f)<<8)|p[1];
-                if (n > (1024*4))
-                        {
-                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE);
+                n = ((p[0] & 0x7f) << 8) | p[1];
+                if (n > (1024 * 4)) {
+                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_TOO_LARGE);
                         goto err;
-                        }
+                }
 
-                j=ssl23_read_bytes(s,n+2);
-                if (j <= 0) return(j);
+                j = ssl23_read_bytes(s, n + 2);
+                if (j <= 0)
+                        return (j);
 
-                ssl3_finish_mac(s, s->packet+2, s->packet_length-2);
+                ssl3_finish_mac(s, s->packet + 2, s->packet_length - 2);
                 if (s->msg_callback)
-                        s->msg_callback(0, SSL2_VERSION, 0, s->packet+2, s->packet_length-2, s, s->msg_callback_arg); /* CLIENT-HELLO */
-
-                p=s->packet;
-                p+=5;
-                n2s(p,csl);
-                n2s(p,sil);
-                n2s(p,cl);
-                d=(unsigned char *)s->init_buf->data;
-                if ((csl+sil+cl+11) != s->packet_length) /* We can't have TLS extensions in SSL 2.0 format
-                                                          * Client Hello, can we? Error condition should be
+                        s->msg_callback(0, SSL2_VERSION, 0, s->packet + 2, s->packet_length-2, s, s->msg_callback_arg); /* CLIENT-HELLO */
+
+                p = s->packet;
+                p += 5;
+                n2s(p, csl);
+                n2s(p, sil);
+                n2s(p, cl);
+                d = (unsigned char *)s->init_buf->data;
+                if ((csl + sil + cl + 11) != s->packet_length) /* We can't have TLS extensions in SSL 2.0 format
+                        * Client Hello, can we ? Error condition should be
                                                           * '>' otherweise */
-                        {
-                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_LENGTH_MISMATCH);
+                {
+                        SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_LENGTH_MISMATCH);
                         goto err;
-                        }
+                }
 
                 /* record header: msg_type ... */
                 *(d++) = SSL3_MT_CLIENT_HELLO;
@@ -484,130 +447,122 @@ int ssl23_get_client_hello(SSL *s)
 
                 /* lets populate the random area */
                 /* get the challenge_length */
-                i=(cl > SSL3_RANDOM_SIZE)?SSL3_RANDOM_SIZE:cl;
-                memset(d,0,SSL3_RANDOM_SIZE);
-                memcpy(&(d[SSL3_RANDOM_SIZE-i]),&(p[csl+sil]),i);
-                d+=SSL3_RANDOM_SIZE;
+                i = (cl > SSL3_RANDOM_SIZE) ? SSL3_RANDOM_SIZE : cl;
+                memset(d, 0, SSL3_RANDOM_SIZE);
+                memcpy(&(d[SSL3_RANDOM_SIZE - i]), &(p[csl + sil]), i);
+                d += SSL3_RANDOM_SIZE;
 
                 /* no session-id reuse */
-                *(d++)=0;
+                *(d++) = 0;
 
                 /* ciphers */
-                j=0;
-                dd=d;
-                d+=2;
-                for (i=0; i<csl; i+=3)
-                        {
-                        if (p[i] != 0) continue;
-                        *(d++)=p[i+1];
-                        *(d++)=p[i+2];
-                        j+=2;
-                        }
-                s2n(j,dd);
+                j = 0;
+                dd = d;
+                d += 2;
+                for (i = 0; i < csl; i += 3) {
+                        if (p[i] != 0)
+                                continue;
+                        *(d++) = p[i + 1];
+                        *(d++) = p[i + 2];
+                        j += 2;
+                }
+                s2n(j, dd);
 
                 /* COMPRESSION */
-                *(d++)=1;
-                *(d++)=0;
-                
+                *(d++) = 1;
+                *(d++) = 0;
+
 #if 0
-                /* copy any remaining data with may be extensions */
-                p = p+csl+sil+cl;
-                while (p <  s->packet+s->packet_length)
-                        {
+                /* copy any remaining data with may be extensions */
+                p = p + csl + sil + cl;
+                while (p <  s->packet + s->packet_length) {
                         *(d++)=*(p++);
-                        }
+                }
 #endif
 
-                i = (d-(unsigned char *)s->init_buf->data) - 4;
+                i = (d - (unsigned char *)s->init_buf->data) - 4;
                 l2n3((long)i, d_len);
 
                 /* get the data reused from the init_buf */
-                s->s3->tmp.reuse_message=1;
-                s->s3->tmp.message_type=SSL3_MT_CLIENT_HELLO;
-                s->s3->tmp.message_size=i;
-                }
+                s->s3->tmp.reuse_message = 1;
+                s->s3->tmp.message_type = SSL3_MT_CLIENT_HELLO;
+                s->s3->tmp.message_size = i;
+        }
 
         /* imaginary new state (for program structure): */
         /* s->state = SSL23_SR_CLNT_HELLO_C */
 
-        if (type == 1)
-                {
+        if (type == 1) {
 #ifdef OPENSSL_NO_SSL2
-                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_UNSUPPORTED_PROTOCOL);
                 goto err;
 #else
                 /* we are talking sslv2 */
                 /* we need to clean up the SSLv3/TLSv1 setup and put in the
                  * sslv2 stuff. */
 
-                if (s->s2 == NULL)
-                        {
+                if (s->s2 == NULL) {
                         if (!ssl2_new(s))
                                 goto err;
-                        }
-                else
+                } else
                         ssl2_clear(s);
 
-                if (s->s3 != NULL) ssl3_free(s);
+                if (s->s3 != NULL)
+                        ssl3_free(s);
 
                 if (!BUF_MEM_grow_clean(s->init_buf,
-                        SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER))
-                        {
+                        SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) {
                         goto err;
-                        }
+                }
 
-                s->state=SSL2_ST_GET_CLIENT_HELLO_A;
+                s->state = SSL2_ST_GET_CLIENT_HELLO_A;
                 if (s->options & SSL_OP_NO_TLSv1 && s->options & SSL_OP_NO_SSLv3)
-                        s->s2->ssl2_rollback=0;
+                        s->s2->ssl2_rollback = 0;
                 else
                         /* reject SSL 2.0 session if client supports SSL 3.0 or TLS 1.0
                          * (SSL 3.0 draft/RFC 2246, App. E.2) */
-                        s->s2->ssl2_rollback=1;
+                s->s2->ssl2_rollback = 1;
 
                 /* setup the n bytes we have read so we get them from
                  * the sslv2 buffer */
-                s->rstate=SSL_ST_READ_HEADER;
-                s->packet_length=n;
-                s->packet= &(s->s2->rbuf[0]);
-                memcpy(s->packet,buf,n);
-                s->s2->rbuf_left=n;
-                s->s2->rbuf_offs=0;
-
-                s->method=SSLv2_server_method();
-                s->handshake_func=s->method->ssl_accept;
+                s->rstate = SSL_ST_READ_HEADER;
+                s->packet_length = n;
+                s->packet = &(s->s2->rbuf[0]);
+                memcpy(s->packet, buf, n);
+                s->s2->rbuf_left = n;
+                s->s2->rbuf_offs = 0;
+
+                s->method = SSLv2_server_method();
+                s->handshake_func = s->method->ssl_accept;
 #endif
-                }
+        }
 
-        if ((type == 2) || (type == 3))
-                {
+        if ((type == 2) || (type == 3)) {
                 /* we have SSLv3/TLSv1 (type 2: SSL2 style, type 3: SSL3/TLS style) */
 
-                if (!ssl_init_wbio_buffer(s,1)) goto err;
+                if (!ssl_init_wbio_buffer(s, 1)) goto err;
 
                 /* we are in this state */
-                s->state=SSL3_ST_SR_CLNT_HELLO_A;
+                s->state = SSL3_ST_SR_CLNT_HELLO_A;
 
-                if (type == 3)
-                        {
+                if (type == 3) {
                         /* put the 'n' bytes we have read into the input buffer
                          * for SSLv3 */
-                        s->rstate=SSL_ST_READ_HEADER;
-                        s->packet_length=n;
+                        s->rstate = SSL_ST_READ_HEADER;
+                        s->packet_length = n;
                         if (s->s3->rbuf.buf == NULL)
                                 if (!ssl3_setup_read_buffer(s))
                                         goto err;
 
-                        s->packet= &(s->s3->rbuf.buf[0]);
-                        memcpy(s->packet,buf,n);
-                        s->s3->rbuf.left=n;
-                        s->s3->rbuf.offset=0;
-                        }
-                else
-                        {
-                        s->packet_length=0;
-                        s->s3->rbuf.left=0;
-                        s->s3->rbuf.offset=0;
-                        }
+                        s->packet = &(s->s3->rbuf.buf[0]);
+                        memcpy(s->packet, buf, n);
+                        s->s3->rbuf.left = n;
+                        s->s3->rbuf.offset = 0;
+                } else {
+                        s->packet_length = 0;
+                        s->s3->rbuf.left = 0;
+                        s->s3->rbuf.offset = 0;
+                }
                 if (s->version == TLS1_2_VERSION)
                         s->method = TLSv1_2_server_method();
                 else if (s->version == TLS1_1_VERSION)
@@ -617,22 +572,23 @@ int ssl23_get_client_hello(SSL *s)
                 else
                         s->method = SSLv3_server_method();
 #if 0 /* ssl3_get_client_hello does this */
-                s->client_version=(v[0]<<8)|v[1];
+                s->client_version = (v[0]<<8)|v[1];
 #endif
-                s->handshake_func=s->method->ssl_accept;
-                }
-        
-        if ((type < 1) || (type > 3))
-                {
+                s->handshake_func = s->method->ssl_accept;
+        }
+
+        if ((type < 1) || (type > 3)) {
                 /* bad, very bad */
-                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNKNOWN_PROTOCOL);
+                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
                 goto err;
-                }
-        s->init_num=0;
+        }
+        s->init_num = 0;
 
-        if (buf != buf_space) OPENSSL_free(buf);
-        return(SSL_accept(s));
+        if (buf != buf_space)
+                OPENSSL_free(buf);
+        return (SSL_accept(s));
 err:
-        if (buf != buf_space) OPENSSL_free(buf);
-        return(-1);
-        }
+        if (buf != buf_space)
+                OPENSSL_free(buf);
+        return (-1);
+}