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);
}
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
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;
* 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
ret = 1;
end:
- s->in_handshake--;
+ st->in_handshake--;
#ifndef OPENSSL_NO_SCTP
if (SSL_IS_DTLS(s)) {
* 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
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) {
{
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) {
* 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;
}