Change to kick info callback when state transition occurs.

src/internal.c

@@ -9046,6 +9046,7 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
 
             if (ret == 0 && ssl->options.side == WOLFSSL_CLIENT_END) {
                 ssl->options.serverState = SERVER_CERT_COMPLETE;
+                ssl->options.handShakeState = SERVER_CERT_COMPLETE;
             }
 
             if (IsEncryptionOn(ssl, 0)) {
@@ -9391,6 +9392,7 @@ int DoFinished(WOLFSSL* ssl, const byte* input, word32* inOutIdx, word32 size,
 
     if (ssl->options.side == WOLFSSL_CLIENT_END) {
         ssl->options.serverState = SERVER_FINISHED_COMPLETE;
+        ssl->options.handShakeState = SERVER_FINISHED_COMPLETE;
         if (!ssl->options.resuming) {
         #ifdef OPENSSL_EXTRA
         if (ssl->CBIS != NULL) {
@@ -9799,6 +9801,17 @@ static int DoHandShakeMsgType(WOLFSSL* ssl, byte* input, word32* inOutIdx,
         if (ret != 0) return ret;
     }
 
+#ifdef OPENSSL_EXTRA
+    if (ssl->CBIS != NULL){
+        if (ssl->options.side == WOLFSSL_SERVER_END){
+            ssl->CBIS(ssl, SSL_CB_ACCEPT_LOOP, SSL_SUCCESS);
+        }
+        else {
+            ssl->CBIS(ssl, SSL_CB_CONNECT_LOOP, SSL_SUCCESS);
+        }
+    }
+#endif
+ 
     switch (type) {
 
     case hello_request:
@@ -9942,6 +9955,18 @@ static int DoHandShakeMsg(WOLFSSL* ssl, byte* input, word32* inOutIdx,
         if (GetHandShakeHeader(ssl,input,inOutIdx,&type, &size, totalSz) != 0)
             return PARSE_ERROR;
 
+#ifdef OPENSSL_EXTRA
+        if (ssl->CBIS != NULL){
+            if (ssl->options.side == WOLFSSL_SERVER_END){
+                ssl->CBIS(ssl, SSL_CB_ACCEPT_LOOP, SSL_SUCCESS);
+            }
+            else {
+                ssl->CBIS(ssl, SSL_CB_CONNECT_LOOP, SSL_SUCCESS);
+            }
+        }
+#endif
+        ssl->options.handShakeState = type;
+
         return DoHandShakeMsgType(ssl, input, inOutIdx, type, size, totalSz);
     }
 
@@ -13396,10 +13421,10 @@ int SendCertificate(WOLFSSL* ssl)
             if (ssl->options.dtls)
                 ssl->keys.dtls_handshake_number++;
         #endif
-        if (ssl->options.side == WOLFSSL_SERVER_END)
+        if (ssl->options.side == WOLFSSL_SERVER_END){
             ssl->options.serverState = SERVER_CERT_COMPLETE;
+        }
     }
-
     return ret;
 }
 
@@ -16787,6 +16812,7 @@ void PickHashSigAlgo(WOLFSSL* ssl, const byte* hashSigAlgo,
         #endif
 
         ssl->options.clientState = CLIENT_HELLO_COMPLETE;
+        ssl->options.handShakeState = CLIENT_HELLO_COMPLETE;
 
 #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
         if (ssl->hsInfoOn) AddPacketName(ssl, "ClientHello");
@@ -16845,6 +16871,7 @@ void PickHashSigAlgo(WOLFSSL* ssl, const byte* hashSigAlgo,
         }
 
         ssl->options.serverState = SERVER_HELLOVERIFYREQUEST_COMPLETE;
+        ssl->options.handShakeState = SERVER_HELLOVERIFYREQUEST_COMPLETE;
         return 0;
     }
 
@@ -17191,6 +17218,7 @@ void PickHashSigAlgo(WOLFSSL* ssl, const byte* hashSigAlgo,
 #endif
 
         ssl->options.serverState = SERVER_HELLO_COMPLETE;
+        ssl->options.handShakeState = SERVER_HELLO_COMPLETE;
 
         if (IsEncryptionOn(ssl, 0)) {
             *inOutIdx += ssl->keys.padSz;
@@ -18379,6 +18407,7 @@ static int DoServerKeyExchange(WOLFSSL* ssl, const byte* input,
             *inOutIdx = args->idx;
 
             ssl->options.serverState = SERVER_KEYEXCHANGE_COMPLETE;
+            ssl->options.handShakeState = SERVER_KEYEXCHANGE_COMPLETE;
             break;
         }
         default:
@@ -23547,6 +23576,7 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
                     WRITE_PROTO, ssl->heap);
     #endif
         ssl->options.serverState = SERVER_HELLODONE_COMPLETE;
+        ssl->options.handShakeState = SERVER_HELLODONE_COMPLETE;
 
         ssl->buffers.outputBuffer.length += sendSz;
 

src/ssl.c

@@ -19073,85 +19073,158 @@ const char* wolfSSL_state_string_long(const WOLFSSL* ssl)
 {
     WOLFSSL_ENTER("wolfSSL_state_string_long");
 
+    char state_msg[100];
+
     if (ssl == NULL) {
         WOLFSSL_MSG("Null argument passed in");
         return NULL;
     }
 
+    /* Get SSL version */
+    XMEMSET(state_msg, 0, sizeof(state_msg));
+    switch (ssl->version.major){
+        case SSLv3_MAJOR:
+            switch (ssl->version.minor){
+            case TLSv1_MINOR:
+                XSTRNCPY(state_msg, "TLSv1", 5);
+            break;
+            case TLSv1_1_MINOR:
+                XSTRNCPY(state_msg, "TLSv1_1", 7);
+            break;
+            case TLSv1_2_MINOR:
+                XSTRNCPY(state_msg, "TLSv1_2", 7);
+            break;
+            case SSLv3_MINOR:
+                XSTRNCPY(state_msg, "SSLv3", 5);
+            break;
+            default:
+                XSTRNCPY(state_msg, "Unknown Protocol", 16);
+            }
+        break;
+        case DTLS_MAJOR:
+            switch (ssl->version.minor){
+                case DTLS_MINOR: 
+                    XSTRNCPY(state_msg, "DTLSv1", 6);
+                break;
+                case DTLSv1_2_MINOR:
+                    XSTRNCPY(state_msg, "DTLSv1_2", 8);
+                break;
+                default:
+                    XSTRNCPY(state_msg, "Unknown Protocol", 16);
+            }
+        break;
+        default:
+            XSTRNCPY(state_msg, "Unknown Protocol", 16);
+    }
+
     switch (wolfSSL_get_state(ssl)) {
         case NULL_STATE:
             {
-                static const char NL_ST[] = "Null State";
+                static char NL_ST[100];
+                const char* state = " Null State";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(NL_ST, state_msg, sizeof(state_msg));
                 return NL_ST;
             }
 
         case SERVER_HELLOVERIFYREQUEST_COMPLETE:
             {
-                static const char SHVC_ST[] =
+                static char SHVC_ST[100];
-                    "Server Hello Verify Request Complete";
+                const char* state = " Server Hello Verify Request Complete";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(SHVC_ST, state_msg, sizeof(state_msg));
                 return SHVC_ST;
             }
 
         case SERVER_HELLO_COMPLETE:
             {
-                static const char SHC_ST[] =
+                static char SHC_ST[100];
-                    "Server Hello Complete";
+                const char* state = " Server Hello Complete";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(SHC_ST, state_msg, sizeof(state_msg));
                 return SHC_ST;
             }
 
         case SERVER_CERT_COMPLETE:
             {
-                static const char SCC_ST[] =
+                static char SCC_ST[100];
-                    "Server Certificate Complete";
+                const char* state = " Server Certificate Complete";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(SCC_ST, state_msg, sizeof(state_msg));
                 return SCC_ST;
             }
 
         case SERVER_KEYEXCHANGE_COMPLETE:
             {
-                static const char SKC_ST[] =
+                static char SKC_ST[100];
-                    "Server Key Exchange Complete";
+                const char* state = " Server Key Exchange Complete";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(SKC_ST, state_msg, sizeof(state_msg));
                 return SKC_ST;
             }
 
         case SERVER_HELLODONE_COMPLETE:
             {
-                static const char SHDC_ST[] =
+                static char SHDC_ST[100];
-                    "Server Hello Done Complete";
+                const char* state = " Server Hello Done Complete";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(SHDC_ST, state_msg, sizeof(state_msg));
                 return SHDC_ST;
             }
 
         case SERVER_FINISHED_COMPLETE:
             {
-                static const char SFC_ST[] =
+                static char SFC_ST[100];
-                    "Server Finished Complete";
+                const char* state = " Server Finished Complete";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(SFC_ST, state_msg, sizeof(state_msg));
                 return SFC_ST;
             }
 
         case CLIENT_HELLO_COMPLETE:
             {
-                static const char CHC_ST[] =
+                static char CHC_ST[100];
-                    "Client Hello Complete";
+                const char* state = " Client Hello Complete";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(CHC_ST, state_msg, sizeof(state_msg));
                 return CHC_ST;
             }
 
         case CLIENT_KEYEXCHANGE_COMPLETE:
             {
-                static const char CKC_ST[] =
+                static char CKC_ST[100];
-                    "Client Key Exchange Complete";
+                const char* state = " Client Key Exchange Complete";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(CKC_ST, state_msg, sizeof(state_msg));
                 return CKC_ST;
             }
 
         case CLIENT_FINISHED_COMPLETE:
             {
-                static const char CFC_ST[] =
+                static char CFC_ST[100];
-                    "Client Finished Complete";
+                const char* state = " Client Finished Complete";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(CFC_ST, state_msg, sizeof(state_msg));
                 return CFC_ST;
             }
 
         case HANDSHAKE_DONE:
             {
-                static const char HD_ST[] =
+                static char HD_ST[100];
-                    "Handshake Done";
+                const char* state = " Handshake Done";
+
+                XSTRNCAT(state_msg, state, XSTRLEN(state) + 1);
+                XSTRNCPY(HD_ST, state_msg, sizeof(state_msg));
                 return HD_ST;
             }
 
@@ -19161,7 +19234,6 @@ const char* wolfSSL_state_string_long(const WOLFSSL* ssl)
     }
 }
 
-
 #ifndef NO_WOLFSSL_STUB
 int wolfSSL_PEM_def_callback(char* name, int num, int w, void* key)
 {