X-Git-Url: https://git.openssl.org/?a=blobdiff_plain;f=ssl%2Fstatem%2Fstatem.c;h=bc3fc54fabf3b86ec115ff779e131f722db7236e;hb=a0f63828e3e542ba71b166b3d0cac05833591065;hp=f0bb26d49c74ebd126e2621c9dff3e5f192a351b;hpb=d78052cf4f3b8def0ebbd89d3ecc0098190ee20f;p=openssl.git diff --git a/ssl/statem/statem.c b/ssl/statem/statem.c index f0bb26d49c..bc3fc54fab 100644 --- a/ssl/statem/statem.c +++ b/ssl/statem/statem.c @@ -187,6 +187,33 @@ void ossl_statem_set_in_init(SSL *s, int init) s->statem.in_init = init; } +int ossl_statem_get_in_handshake(SSL *s) +{ + return s->statem.in_handshake; +} + +void ossl_statem_set_in_handshake(SSL *s, int inhand) +{ + if (inhand) + s->statem.in_handshake++; + else + s->statem.in_handshake--; +} + +void ossl_statem_set_hello_verify_done(SSL *s) +{ + s->statem.state = MSG_FLOW_UNINITED; + s->statem.in_init = 1; + /* + * This will get reset (briefly) back to TLS_ST_BEFORE when we enter + * state_machine() because |state| is MSG_FLOW_UNINITED, but until then any + * calls to SSL_in_before() will return false. Also calls to + * SSL_state_string() and SSL_state_string_long() will return something + * sensible. + */ + s->statem.hand_state = TLS_ST_SR_CLNT_HELLO; +} + int ossl_statem_connect(SSL *s) { return state_machine(s, 0); } @@ -196,6 +223,16 @@ int ossl_statem_accept(SSL *s) return state_machine(s, 1); } +static void (*get_callback(SSL *s))(const SSL *, int, int) +{ + if (s->info_callback != NULL) + return s->info_callback; + else if (s->ctx->info_callback != NULL) + return s->ctx->info_callback; + + return NULL; +} + /* * The main message flow state machine. We start in the MSG_FLOW_UNINITED or * MSG_FLOW_RENEGOTIATE state and finish in MSG_FLOW_FINISHED. Valid states and @@ -241,12 +278,9 @@ static int state_machine(SSL *s, int server) { ERR_clear_error(); clear_sys_error(); - if (s->info_callback != NULL) - cb = s->info_callback; - else if (s->ctx->info_callback != NULL) - cb = s->ctx->info_callback; + cb = get_callback(s); - s->in_handshake++; + st->in_handshake++; if (!SSL_in_init(s) || SSL_in_before(s)) { if (!SSL_clear(s)) return -1; @@ -259,7 +293,7 @@ static int state_machine(SSL *s, int server) { * identifier other than 0. Will be ignored if no SCTP is used. */ BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE, - s->in_handshake, NULL); + st->in_handshake, NULL); } #endif @@ -426,7 +460,7 @@ static int state_machine(SSL *s, int server) { ret = 1; end: - s->in_handshake--; + st->in_handshake--; #ifndef OPENSSL_NO_SCTP if (SSL_IS_DTLS(s)) { @@ -435,7 +469,7 @@ static int state_machine(SSL *s, int server) { * identifier other than 0. Will be ignored if no SCTP is used. */ BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE, - s->in_handshake, NULL); + st->in_handshake, NULL); } #endif @@ -488,29 +522,26 @@ static void init_read_state_machine(SSL *s) static SUB_STATE_RETURN read_state_machine(SSL *s) { OSSL_STATEM *st = &s->statem; int ret, mt; - unsigned long len; + unsigned long len = 0; int (*transition)(SSL *s, int mt); PACKET pkt; - enum MSG_PROCESS_RETURN (*process_message)(SSL *s, PACKET *pkt); - enum WORK_STATE (*post_process_message)(SSL *s, enum WORK_STATE wst); + MSG_PROCESS_RETURN (*process_message)(SSL *s, PACKET *pkt); + WORK_STATE (*post_process_message)(SSL *s, WORK_STATE wst); unsigned long (*max_message_size)(SSL *s); void (*cb) (const SSL *ssl, int type, int val) = NULL; - if (s->info_callback != NULL) - cb = s->info_callback; - else if (s->ctx->info_callback != NULL) - cb = s->ctx->info_callback; + cb = get_callback(s); if(s->server) { - transition = server_read_transition; - process_message = server_process_message; - max_message_size = server_max_message_size; - post_process_message = server_post_process_message; + transition = ossl_statem_server_read_transition; + process_message = ossl_statem_server_process_message; + max_message_size = ossl_statem_server_max_message_size; + post_process_message = ossl_statem_server_post_process_message; } else { - transition = client_read_transition; - process_message = client_process_message; - max_message_size = client_max_message_size; - post_process_message = client_post_process_message; + transition = ossl_statem_client_read_transition; + process_message = ossl_statem_client_process_message; + max_message_size = ossl_statem_client_max_message_size; + post_process_message = ossl_statem_client_post_process_message; } if (st->read_state_first_init) { @@ -690,27 +721,24 @@ static SUB_STATE_RETURN write_state_machine(SSL *s) { OSSL_STATEM *st = &s->statem; int ret; - enum WRITE_TRAN (*transition)(SSL *s); - enum WORK_STATE (*pre_work)(SSL *s, enum WORK_STATE wst); - enum WORK_STATE (*post_work)(SSL *s, enum WORK_STATE wst); + WRITE_TRAN (*transition)(SSL *s); + WORK_STATE (*pre_work)(SSL *s, WORK_STATE wst); + WORK_STATE (*post_work)(SSL *s, WORK_STATE wst); int (*construct_message)(SSL *s); void (*cb) (const SSL *ssl, int type, int val) = NULL; - if (s->info_callback != NULL) - cb = s->info_callback; - else if (s->ctx->info_callback != NULL) - cb = s->ctx->info_callback; + cb = get_callback(s); if(s->server) { - transition = server_write_transition; - pre_work = server_pre_work; - post_work = server_post_work; - construct_message = server_construct_message; + transition = ossl_statem_server_write_transition; + pre_work = ossl_statem_server_pre_work; + post_work = ossl_statem_server_post_work; + construct_message = ossl_statem_server_construct_message; } else { - transition = client_write_transition; - pre_work = client_pre_work; - post_work = client_post_work; - construct_message = client_construct_message; + transition = ossl_statem_client_write_transition; + pre_work = ossl_statem_client_pre_work; + post_work = ossl_statem_client_post_work; + construct_message = ossl_statem_client_construct_message; } while(1) { @@ -856,7 +884,7 @@ void ossl_statem_set_sctp_read_sock(SSL *s, int read_sock) * 1: Yes (we are in the read sock state) * 0: No (we are not in the read sock state) */ -int statem_in_sctp_read_sock(SSL *s) +int ossl_statem_in_sctp_read_sock(SSL *s) { return s->statem.in_sctp_read_sock; }