-/* ssl/statem/statem.c */
/*
* Written by Matt Caswell for the OpenSSL project.
*/
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;
* 1: Success
* <=0: NBIO or error
*/
-static int state_machine(SSL *s, int server) {
+static int state_machine(SSL *s, int server)
+{
BUF_MEM *buf = NULL;
unsigned long Time = (unsigned long)time(NULL);
void (*cb) (const SSL *ssl, int type, int val) = NULL;
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
goto end;
}
} else {
- if ((s->version >> 8) != SSL3_VERSION_MAJOR
- && s->version != TLS_ANY_VERSION) {
+ if ((s->version >> 8) != SSL3_VERSION_MAJOR) {
SSLerr(SSL_F_STATE_MACHINE, ERR_R_INTERNAL_ERROR);
goto end;
}
}
- if (!SSL_IS_DTLS(s)) {
- if (s->version != TLS_ANY_VERSION &&
- !ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL)) {
- SSLerr(SSL_F_STATE_MACHINE, SSL_R_VERSION_TOO_LOW);
- goto end;
- }
+ if (!ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL)) {
+ SSLerr(SSL_F_STATE_MACHINE, SSL_R_VERSION_TOO_LOW);
+ goto end;
}
if (s->init_buf == NULL) {
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
* READ_STATE_POST_PROCESS is an optional step that may occur if some post
* processing activity performed on the message may block.
*
- * Any of the above states could result in an NBIO event occuring in which case
+ * Any of the above states could result in an NBIO event occurring in which case
* control returns to the calling application. When this function is recalled we
* will resume in the same state where we left off.
*/
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;
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) {
* WRITE_STATE_TRANSITION transitions the state of the handshake state machine
* WRITE_STATE_PRE_WORK performs any work necessary to prepare the later
- * sending of the message. This could result in an NBIO event occuring in
+ * sending of the message. This could result in an NBIO event occurring in
* which case control returns to the calling application. When this function
* is recalled we will resume in the same state where we left off.
*
{
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;
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;
}