Convert enums to typedefs

Various enums were introduced as part of the state machine rewrite. As a
matter of style it is preferred for these to be typedefs.

Reviewed-by: Tim Hudson <tjh@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org>

diff --git a/ssl/statem/statem.c b/ssl/statem/statem.c
index b9e6fc0fa46b1c7a6e0491b158ad022c30dbe8b3..24efd03043cc4e98472133da459609c4c9077484 100644 (file)
--- a/ssl/statem/statem.c
+++ b/ssl/statem/statem.c
@@ -525,8 +525,8 @@ static SUB_STATE_RETURN read_state_machine(SSL *s) {
     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;
 
@@ -721,9 +721,9 @@ 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;
 

diff --git a/ssl/statem/statem.h b/ssl/statem/statem.h
index 2c5184dde5ca011ed3fba5685f3c93b1c0d4f874..1350967d56d98dbdaebfad8c29ee920e2e77ca23 100644 (file)
--- a/ssl/statem/statem.h
+++ b/ssl/statem/statem.h
@@ -63,7 +63,7 @@
  * Valid return codes used for functions performing work prior to or after
  * sending or receiving a message
  */
-enum WORK_STATE {
+typedef enum {
     /* Something went wrong */
     WORK_ERROR,
     /* We're done working and there shouldn't be anything else to do after */
@@ -74,20 +74,20 @@ enum WORK_STATE {
     WORK_MORE_A,
     /* We're working on phase B */
     WORK_MORE_B
-};
+} WORK_STATE;
 
 /* Write transition return codes */
-enum WRITE_TRAN {
+typedef enum {
     /* Something went wrong */
     WRITE_TRAN_ERROR,
     /* A transition was successfully completed and we should continue */
     WRITE_TRAN_CONTINUE,
     /* There is no more write work to be done */
     WRITE_TRAN_FINISHED
-};
+} WRITE_TRAN;
 
 /* Message flow states */
-enum MSG_FLOW_STATE {
+typedef enum {
     /* No handshake in progress */
     MSG_FLOW_UNINITED,
     /* A permanent error with this connection */
@@ -100,22 +100,22 @@ enum MSG_FLOW_STATE {
     MSG_FLOW_WRITING,
     /* Handshake has finished */
     MSG_FLOW_FINISHED
-};
+} MSG_FLOW_STATE;
 
 /* Read states */
-enum READ_STATE {
+typedef enum {
     READ_STATE_HEADER,
     READ_STATE_BODY,
     READ_STATE_POST_PROCESS
-};
+} READ_STATE;
 
 /* Write states */
-enum WRITE_STATE {
+typedef enum {
     WRITE_STATE_TRANSITION,
     WRITE_STATE_PRE_WORK,
     WRITE_STATE_SEND,
     WRITE_STATE_POST_WORK
-};
+} WRITE_STATE;
 
 
 /*****************************************************************************
@@ -127,11 +127,11 @@ enum WRITE_STATE {
  *****************************************************************************/
 
 struct ossl_statem_st {
-    enum MSG_FLOW_STATE state;
-    enum WRITE_STATE write_state;
-    enum WORK_STATE write_state_work;
-    enum READ_STATE read_state;
-    enum WORK_STATE read_state_work;
+    MSG_FLOW_STATE state;
+    WRITE_STATE write_state;
+    WORK_STATE write_state_work;
+    READ_STATE read_state;
+    WORK_STATE read_state_work;
     OSSL_HANDSHAKE_STATE hand_state;
     int in_init;
     int read_state_first_init;

diff --git a/ssl/statem/statem_clnt.c b/ssl/statem/statem_clnt.c
index d0c6b1292ede75cc3ca383185aae392e73a0280b..1218b19efd98b9497a49d6be926d4bc88fb88d90 100644 (file)
--- a/ssl/statem/statem_clnt.c
+++ b/ssl/statem/statem_clnt.c
@@ -391,7 +391,7 @@ int client_read_transition(SSL *s, int mt)
  * client_write_transition() works out what handshake state to move to next
  * when the client is writing messages to be sent to the server.
  */
-enum WRITE_TRAN client_write_transition(SSL *s)
+WRITE_TRAN client_write_transition(SSL *s)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -495,7 +495,7 @@ enum WRITE_TRAN client_write_transition(SSL *s)
  * Perform any pre work that needs to be done prior to sending a message from
  * the client to the server.
  */
-enum WORK_STATE client_pre_work(SSL *s, enum WORK_STATE wst)
+WORK_STATE client_pre_work(SSL *s, WORK_STATE wst)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -542,7 +542,7 @@ enum WORK_STATE client_pre_work(SSL *s, enum WORK_STATE wst)
  * Perform any work that needs to be done after sending a message from the
  * client to the server.
  */
-enum WORK_STATE client_post_work(SSL *s, enum WORK_STATE wst)
+WORK_STATE client_post_work(SSL *s, WORK_STATE wst)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -733,7 +733,7 @@ unsigned long client_max_message_size(SSL *s)
 /*
  * Process a message that the client has been received from the server.
  */
-enum MSG_PROCESS_RETURN client_process_message(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN client_process_message(SSL *s, PACKET *pkt)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -780,7 +780,7 @@ enum MSG_PROCESS_RETURN client_process_message(SSL *s, PACKET *pkt)
  * Perform any further processing required following the receipt of a message
  * from the server
  */
-enum WORK_STATE client_post_process_message(SSL *s, enum WORK_STATE wst)
+WORK_STATE client_post_process_message(SSL *s, WORK_STATE wst)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -1093,7 +1093,7 @@ int tls_construct_client_hello(SSL *s)
     return 0;
 }
 
-enum MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt)
 {
     int al;
     unsigned int cookie_len;
@@ -1127,7 +1127,7 @@ enum MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt)
     return MSG_PROCESS_ERROR;
 }
 
-enum MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, PACKET *pkt)
 {
     STACK_OF(SSL_CIPHER) *sk;
     const SSL_CIPHER *c;
@@ -1467,7 +1467,7 @@ enum MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, PACKET *pkt)
     return MSG_PROCESS_ERROR;
 }
 
-enum MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, PACKET *pkt)
 {
     int al, i, ret = MSG_PROCESS_ERROR, exp_idx;
     unsigned long cert_list_len, cert_len;
@@ -1590,7 +1590,7 @@ enum MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, PACKET *pkt)
     return ret;
 }
 
-enum MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s, PACKET *pkt)
 {
 #ifndef OPENSSL_NO_RSA
     unsigned char *q, md_buf[EVP_MAX_MD_SIZE * 2];
@@ -2045,7 +2045,7 @@ enum MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s, PACKET *pkt)
     return MSG_PROCESS_ERROR;
 }
 
-enum MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s, PACKET *pkt)
 {
     int ret = MSG_PROCESS_ERROR;
     unsigned int list_len, ctype_num, i, name_len;
@@ -2168,7 +2168,7 @@ static int ca_dn_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
     return (X509_NAME_cmp(*a, *b));
 }
 
-enum MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, PACKET *pkt)
 {
     int al;
     unsigned int ticklen;
@@ -2255,7 +2255,7 @@ enum MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, PACKET *pkt)
     return MSG_PROCESS_ERROR;
 }
 
-enum MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt)
 {
     int al;
     unsigned long resplen;
@@ -2307,7 +2307,7 @@ enum MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt)
     return MSG_PROCESS_ERROR;
 }
 
-enum MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt)
 {
     if (PACKET_remaining(pkt) > 0) {
         /* should contain no data */
@@ -3154,7 +3154,7 @@ static int ssl3_check_client_certificate(SSL *s)
     return 1;
 }
 
-enum WORK_STATE tls_prepare_client_certificate(SSL *s, enum WORK_STATE wst)
+WORK_STATE tls_prepare_client_certificate(SSL *s, WORK_STATE wst)
 {
     X509 *x509 = NULL;
     EVP_PKEY *pkey = NULL;

diff --git a/ssl/statem/statem_dtls.c b/ssl/statem/statem_dtls.c
index 34fd8b20085abd8f1985a809613dc844c92f5490..58a09594c98bb09f80b15da7f7bd35722dc3307b 100644 (file)
--- a/ssl/statem/statem_dtls.c
+++ b/ssl/statem/statem_dtls.c
@@ -973,7 +973,7 @@ int dtls_construct_change_cipher_spec(SSL *s)
 }
 
 #ifndef OPENSSL_NO_SCTP
-enum WORK_STATE dtls_wait_for_dry(SSL *s)
+WORK_STATE dtls_wait_for_dry(SSL *s)
 {
     int ret;
 

diff --git a/ssl/statem/statem_lib.c b/ssl/statem/statem_lib.c
index dbfe278a5f103f85a93c29e993cb9bb81f2f00c0..f2a2925deb5a678c950b8bacc291054f3588632c 100644 (file)
--- a/ssl/statem/statem_lib.c
+++ b/ssl/statem/statem_lib.c
@@ -225,7 +225,7 @@ static void ssl3_take_mac(SSL *s)
 }
 #endif
 
-enum MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, PACKET *pkt)
 {
     int al;
     long remain;
@@ -292,7 +292,7 @@ enum MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, PACKET *pkt)
     return MSG_PROCESS_ERROR;
 }
 
-enum MSG_PROCESS_RETURN tls_process_finished(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_finished(SSL *s, PACKET *pkt)
 {
     int al, i;
 
@@ -370,13 +370,13 @@ unsigned long ssl3_output_cert_chain(SSL *s, CERT_PKEY *cpk)
     return l + SSL_HM_HEADER_LENGTH(s);
 }
 
-enum WORK_STATE tls_finish_handshake(SSL *s, enum WORK_STATE wst)
+WORK_STATE tls_finish_handshake(SSL *s, WORK_STATE wst)
 {
     void (*cb) (const SSL *ssl, int type, int val) = NULL;
 
 #ifndef OPENSSL_NO_SCTP
     if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s))) {
-        enum WORK_STATE ret;
+        WORK_STATE ret;
         ret = dtls_wait_for_dry(s);
         if (ret != WORK_FINISHED_CONTINUE)
             return ret;

diff --git a/ssl/statem/statem_locl.h b/ssl/statem/statem_locl.h
index 65787bd5b4c82e69fa92928ebd7e794eedaa358d..93fed35340c0471a1c64bea306e80c2dcbc5ee9f 100644 (file)
--- a/ssl/statem/statem_locl.h
+++ b/ssl/statem/statem_locl.h
@@ -72,7 +72,7 @@
 #define FINISHED_MAX_LENGTH             64
 
 /* Message processing return codes */
-enum MSG_PROCESS_RETURN {
+typedef enum {
     /* Something bad happened */
     MSG_PROCESS_ERROR,
     /* We've finished reading - swap to writing */
@@ -84,7 +84,7 @@ enum MSG_PROCESS_RETURN {
     MSG_PROCESS_CONTINUE_PROCESSING,
     /* We've finished this message - read the next message */
     MSG_PROCESS_CONTINUE_READING
-};
+} MSG_PROCESS_RETURN;
 
 /* Flush the write BIO */
 int statem_flush(SSL *s);
@@ -93,25 +93,25 @@ int statem_flush(SSL *s);
  * TLS/DTLS client state machine functions
  */
 int client_read_transition(SSL *s, int mt);
-enum WRITE_TRAN client_write_transition(SSL *s);
-enum WORK_STATE client_pre_work(SSL *s, enum WORK_STATE wst);
-enum WORK_STATE client_post_work(SSL *s, enum WORK_STATE wst);
+WRITE_TRAN client_write_transition(SSL *s);
+WORK_STATE client_pre_work(SSL *s, WORK_STATE wst);
+WORK_STATE client_post_work(SSL *s, WORK_STATE wst);
 int client_construct_message(SSL *s);
 unsigned long client_max_message_size(SSL *s);
-enum MSG_PROCESS_RETURN client_process_message(SSL *s, PACKET *pkt);
-enum WORK_STATE client_post_process_message(SSL *s, enum WORK_STATE wst);
+MSG_PROCESS_RETURN client_process_message(SSL *s, PACKET *pkt);
+WORK_STATE client_post_process_message(SSL *s, WORK_STATE wst);
 
 /*
  * TLS/DTLS server state machine functions
  */
 int server_read_transition(SSL *s, int mt);
-enum WRITE_TRAN server_write_transition(SSL *s);
-enum WORK_STATE server_pre_work(SSL *s, enum WORK_STATE wst);
-enum WORK_STATE server_post_work(SSL *s, enum WORK_STATE wst);
+WRITE_TRAN server_write_transition(SSL *s);
+WORK_STATE server_pre_work(SSL *s, WORK_STATE wst);
+WORK_STATE server_post_work(SSL *s, WORK_STATE wst);
 int server_construct_message(SSL *s);
 unsigned long server_max_message_size(SSL *s);
-enum MSG_PROCESS_RETURN server_process_message(SSL *s, PACKET *pkt);
-enum WORK_STATE server_post_process_message(SSL *s, enum WORK_STATE wst);
+MSG_PROCESS_RETURN server_process_message(SSL *s, PACKET *pkt);
+WORK_STATE server_post_process_message(SSL *s, WORK_STATE wst);
 
 /* Functions for getting new message data */
 __owur int tls_get_message_header(SSL *s, int *mt);
@@ -119,48 +119,41 @@ __owur int tls_get_message_body(SSL *s, unsigned long *len);
 __owur int dtls_get_message(SSL *s, int *mt, unsigned long *len);
 
 /* Message construction and processing functions */
-__owur enum MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s,
-                                                              PACKET *pkt);
-__owur enum MSG_PROCESS_RETURN tls_process_finished(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_finished(SSL *s, PACKET *pkt);
 __owur int tls_construct_change_cipher_spec(SSL *s);
 __owur int dtls_construct_change_cipher_spec(SSL *s);
 
 __owur int tls_construct_finished(SSL *s, const char *sender, int slen);
-__owur enum WORK_STATE tls_finish_handshake(SSL *s, enum WORK_STATE wst);
-__owur enum WORK_STATE dtls_wait_for_dry(SSL *s);
+__owur WORK_STATE tls_finish_handshake(SSL *s, WORK_STATE wst);
+__owur WORK_STATE dtls_wait_for_dry(SSL *s);
 
 /* some client-only functions */
 __owur int tls_construct_client_hello(SSL *s);
-__owur enum MSG_PROCESS_RETURN tls_process_server_hello(SSL *s,
-                                                        PACKET *pkt);
-__owur enum MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s,
-                                                               PACKET *pkt);
-__owur enum MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s,
-                                                              PACKET *pkt);
-__owur enum MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt);
-__owur enum MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt);
 __owur int tls_construct_client_verify(SSL *s);
-__owur enum WORK_STATE tls_prepare_client_certificate(SSL *s,
-                                                      enum WORK_STATE wst);
+__owur WORK_STATE tls_prepare_client_certificate(SSL *s, WORK_STATE wst);
 __owur int tls_construct_client_certificate(SSL *s);
 __owur int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey);
 __owur int tls_construct_client_key_exchange(SSL *s);
 __owur int tls_client_key_exchange_post_work(SSL *s);
 __owur int tls_construct_cert_status(SSL *s);
-__owur enum MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s,
+__owur MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s,
                                                         PACKET *pkt);
-__owur enum MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s,
-                                                              PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, PACKET *pkt);
 __owur int ssl3_check_cert_and_algorithm(SSL *s);
 #  ifndef OPENSSL_NO_NEXTPROTONEG
 __owur int tls_construct_next_proto(SSL *s);
 #  endif
-__owur enum MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt);
 
 /* some server-only functions */
-__owur enum MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt);
-__owur enum WORK_STATE tls_post_process_client_hello(SSL *s,
-                                                     enum WORK_STATE wst);
+__owur MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt);
+__owur WORK_STATE tls_post_process_client_hello(SSL *s, WORK_STATE wst);
 __owur int tls_construct_server_hello(SSL *s);
 __owur int tls_construct_hello_request(SSL *s);
 __owur int dtls_construct_hello_verify_request(SSL *s);
@@ -168,14 +161,11 @@ __owur int tls_construct_server_certificate(SSL *s);
 __owur int tls_construct_server_key_exchange(SSL *s);
 __owur int tls_construct_certificate_request(SSL *s);
 __owur int tls_construct_server_done(SSL *s);
-__owur enum MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s,
-                                                              PACKET *pkt);
-__owur enum MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s,
-                                                               PACKET *pkt);
-__owur enum WORK_STATE tls_post_process_client_key_exchange(SSL *s,
-    enum WORK_STATE wst);
-__owur enum MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt);
+__owur WORK_STATE tls_post_process_client_key_exchange(SSL *s, WORK_STATE wst);
+__owur MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt);
 #  ifndef OPENSSL_NO_NEXTPROTONEG
-__owur enum MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt);
 #  endif
 __owur int tls_construct_new_session_ticket(SSL *s);

diff --git a/ssl/statem/statem_srvr.c b/ssl/statem/statem_srvr.c
index a5c38622c303b340f03d7efc8474b1506bceeb13..64bbee9392fc01d99dca065c5ccd30f87e655248 100644 (file)
--- a/ssl/statem/statem_srvr.c
+++ b/ssl/statem/statem_srvr.c
@@ -402,7 +402,7 @@ static inline int send_certificate_request(SSL *s)
  * server_write_transition() works out what handshake state to move to next
  * when the server is writing messages to be sent to the client.
  */
-enum WRITE_TRAN server_write_transition(SSL *s)
+WRITE_TRAN server_write_transition(SSL *s)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -520,7 +520,7 @@ enum WRITE_TRAN server_write_transition(SSL *s)
  * Perform any pre work that needs to be done prior to sending a message from
  * the server to the client.
  */
-enum WORK_STATE server_pre_work(SSL *s, enum WORK_STATE wst)
+WORK_STATE server_pre_work(SSL *s, WORK_STATE wst)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -599,7 +599,7 @@ enum WORK_STATE server_pre_work(SSL *s, enum WORK_STATE wst)
  * Perform any work that needs to be done after sending a message from the
  * server to the client.
  */
-enum WORK_STATE server_post_work(SSL *s, enum WORK_STATE wst)
+WORK_STATE server_post_work(SSL *s, WORK_STATE wst)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -806,7 +806,7 @@ unsigned long server_max_message_size(SSL *s)
 /*
  * Process a message that the server has received from the client.
  */
-enum MSG_PROCESS_RETURN server_process_message(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN server_process_message(SSL *s, PACKET *pkt)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -846,7 +846,7 @@ enum MSG_PROCESS_RETURN server_process_message(SSL *s, PACKET *pkt)
  * Perform any further processing required following the receipt of a message
  * from the client
  */
-enum WORK_STATE server_post_process_message(SSL *s, enum WORK_STATE wst)
+WORK_STATE server_post_process_message(SSL *s, WORK_STATE wst)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -976,7 +976,7 @@ int dtls_construct_hello_verify_request(SSL *s)
     return 1;
 }
 
-enum MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt)
 {
     int i, al = SSL_AD_INTERNAL_ERROR;
     unsigned int j, complen = 0;
@@ -1516,7 +1516,7 @@ enum MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt)
 
 }
 
-enum WORK_STATE tls_post_process_client_hello(SSL *s, enum WORK_STATE wst)
+WORK_STATE tls_post_process_client_hello(SSL *s, WORK_STATE wst)
 {
     int al = SSL_AD_HANDSHAKE_FAILURE;
     SSL_CIPHER *cipher;
@@ -2266,7 +2266,7 @@ int tls_construct_certificate_request(SSL *s)
     return 0;
 }
 
-enum MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt)
 {
     int al;
     unsigned int i;
@@ -2894,8 +2894,7 @@ enum MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt)
     return MSG_PROCESS_ERROR;
 }
 
-enum WORK_STATE tls_post_process_client_key_exchange(SSL *s,
-                                                      enum WORK_STATE wst)
+WORK_STATE tls_post_process_client_key_exchange(SSL *s, WORK_STATE wst)
 {
 #ifndef OPENSSL_NO_SCTP
     if (wst == WORK_MORE_A) {
@@ -3005,7 +3004,7 @@ enum WORK_STATE tls_post_process_client_key_exchange(SSL *s,
     return WORK_FINISHED_CONTINUE;
 }
 
-enum MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt)
 {
     EVP_PKEY *pkey = NULL;
     unsigned char *sig, *data;
@@ -3181,7 +3180,7 @@ enum MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt)
     return ret;
 }
 
-enum MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt)
 {
     int i, al = SSL_AD_INTERNAL_ERROR, ret = MSG_PROCESS_ERROR;
     X509 *x = NULL;
@@ -3501,7 +3500,7 @@ int tls_construct_cert_status(SSL *s)
  * tls_process_next_proto reads a Next Protocol Negotiation handshake message.
  * It sets the next_proto member in s if found
  */
-enum MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt)
 {
     PACKET next_proto, padding;
     size_t next_proto_len;