From 30f92658fa4e1357cfcee9c077a21e928970d290 Mon Sep 17 00:00:00 2001 From: jsing <> Date: Mon, 14 Apr 2014 15:15:33 +0000 Subject: 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. --- src/lib/libssl/s23_srvr.c | 564 +++++++++++++++++++++------------------------- 1 file changed, 260 insertions(+), 304 deletions(-) (limited to 'src/lib/libssl/s23_srvr.c') 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; ipacket+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); +} -- cgit v1.2.3-55-g6feb