Address PR wolfSSL#334 review feedback

- Add native JNI wrapper for wolfSSL_SNI_GetFromBuffer(), switch
  SSLEngine SNI extraction to use it with Java fallback for
  NOT_COMPILED_IN builds
- Add clearPendingAppData() helper, clear stale pending app data on
  unwrap() exception paths, closeInbound(), and closeOutbound()
- Reset pendingNetConsumed when stashing new decrypted data
- Move getBytes() length validation before allocation
- Add TLS-only clarifying comment on record-header underflow check
- Detect peer closing connection during handshake (SSLHandshakeException)
- Store verifyException on hostname verification failure paths
- Add debug logging in setNativeTimeout catch block
- Move word32 dropCount declarations before (void) casts for C89
- Re-interrupt thread on InterruptedException in session context tests
- Add restoreClientSessionCacheProperty() test helper

Author: JeremiahM37

native/com_wolfssl_WolfSSL.c

@@ -2625,3 +2625,80 @@ JNIEXPORT jint JNICALL Java_com_wolfssl_WolfSSL_getErrno
     return 0;
 #endif
 }
+
+JNIEXPORT jint JNICALL Java_com_wolfssl_WolfSSL_getSNIFromBuffer
+  (JNIEnv* jenv, jclass jcl, jbyteArray clientHello, jint helloSz,
+   jbyte type, jbyteArray sni, jintArray inOutSz)
+{
+    int ret = BAD_FUNC_ARG;
+#if defined(HAVE_SNI) && !defined(NO_WOLFSSL_SERVER)
+    jbyte* clientHelloBuf = NULL;
+    jbyte* sniBuf = NULL;
+    jint* sizeBuf = NULL;
+    jsize clientHelloLen = 0;
+    jsize sniLen = 0;
+    jsize sizeLen = 0;
+    unsigned int sniOutSz = 0;
+
+    (void)jcl;
+
+    if (jenv == NULL || clientHello == NULL || sni == NULL ||
+        inOutSz == NULL || helloSz < 0) {
+        return ret;
+    }
+
+    clientHelloLen = (*jenv)->GetArrayLength(jenv, clientHello);
+    sniLen = (*jenv)->GetArrayLength(jenv, sni);
+    sizeLen = (*jenv)->GetArrayLength(jenv, inOutSz);
+    if (helloSz > clientHelloLen || sizeLen < 1) {
+        return ret;
+    }
+
+    sizeBuf = (*jenv)->GetIntArrayElements(jenv, inOutSz, NULL);
+    if (sizeBuf == NULL) {
+        return MEMORY_E;
+    }
+
+    if (sizeBuf[0] < 0 || sizeBuf[0] > sniLen) {
+        (*jenv)->ReleaseIntArrayElements(jenv, inOutSz, sizeBuf, JNI_ABORT);
+        return ret;
+    }
+    sniOutSz = (unsigned int)sizeBuf[0];
+
+    clientHelloBuf = (*jenv)->GetByteArrayElements(jenv, clientHello, NULL);
+    if (clientHelloBuf == NULL) {
+        (*jenv)->ReleaseIntArrayElements(jenv, inOutSz, sizeBuf, JNI_ABORT);
+        return MEMORY_E;
+    }
+
+    sniBuf = (*jenv)->GetByteArrayElements(jenv, sni, NULL);
+    if (sniBuf == NULL) {
+        (*jenv)->ReleaseByteArrayElements(jenv, clientHello, clientHelloBuf,
+                                          JNI_ABORT);
+        (*jenv)->ReleaseIntArrayElements(jenv, inOutSz, sizeBuf, JNI_ABORT);
+        return MEMORY_E;
+    }
+
+    ret = wolfSSL_SNI_GetFromBuffer((const unsigned char*)clientHelloBuf,
+                                    (unsigned int)helloSz,
+                                    (unsigned char)type,
+                                    (unsigned char*)sniBuf, &sniOutSz);
+
+    sizeBuf[0] = (jint)sniOutSz;
+    (*jenv)->ReleaseByteArrayElements(jenv, sni, sniBuf, 0);
+    (*jenv)->ReleaseByteArrayElements(jenv, clientHello, clientHelloBuf,
+                                      JNI_ABORT);
+    (*jenv)->ReleaseIntArrayElements(jenv, inOutSz, sizeBuf, 0);
+#else
+    (void)jenv;
+    (void)jcl;
+    (void)clientHello;
+    (void)helloSz;
+    (void)type;
+    (void)sni;
+    (void)inOutSz;
+    ret = NOT_COMPILED_IN;
+#endif
+
+    return ret;
+}

native/com_wolfssl_WolfSSL.h

@@ -2761,11 +2761,11 @@ JNIEXPORT jint JNICALL Java_com_wolfssl_WolfSSLSession_sendHrrCookie
 JNIEXPORT jlong JNICALL Java_com_wolfssl_WolfSSLSession_getDtlsMacDropCount
   (JNIEnv* jenv, jobject jcl, jlong sslPtr)
 {
+    word32 dropCount = 0;
+
     (void)jenv;
     (void)jcl;
     (void)sslPtr;
-
-    word32 dropCount = 0;
 #if defined(WOLFSSL_DTLS) && defined(WOLFSSL_DTLS_DROP_STATS)
     int ret = 0;
     WOLFSSL* ssl = (WOLFSSL*)(uintptr_t)sslPtr;
@@ -2782,11 +2782,11 @@ JNIEXPORT jlong JNICALL Java_com_wolfssl_WolfSSLSession_getDtlsMacDropCount
 JNIEXPORT jlong JNICALL Java_com_wolfssl_WolfSSLSession_getDtlsReplayDropCount
   (JNIEnv* jenv, jobject jcl, jlong sslPtr)
 {
+    word32 dropCount = 0;
+
     (void)jenv;
     (void)jcl;
     (void)sslPtr;
-
-    word32 dropCount = 0;
 #if defined(WOLFSSL_DTLS) && defined(WOLFSSL_DTLS_DROP_STATS)
     int ret = 0;
     WOLFSSL* ssl = (WOLFSSL*)(uintptr_t)sslPtr;

native/com_wolfssl_WolfSSLSession.c

@@ -1850,6 +1850,25 @@ public static int cryptoCbUnRegisterDevice(int devId) {
      */
     public static native int getErrno();
 
+    /**
+     * Extract a requested SNI value from a raw ClientHello buffer.
+     *
+     * This delegates parsing to native wolfSSL, which already handles the
+     * protocol framing and bounds checks.
+     *
+     * @param clientHello raw ClientHello/TLS record bytes
+     * @param helloSz number of bytes in {@code clientHello} to parse
+     * @param type SNI type to fetch, for example {@code WOLFSSL_SNI_HOST_NAME}
+     * @param sni output buffer for the SNI value
+     * @param inOutSz input/output size array of length 1. On input this is the
+     *        available size of {@code sni}; on success it is updated with the
+     *        number of bytes written.
+     * @return {@code SSL_SUCCESS} on success, otherwise a native wolfSSL error
+     *         code or {@code NOT_COMPILED_IN} when unavailable
+     */
+    public static native int getSNIFromBuffer(byte[] clientHello, int helloSz,
+        byte type, byte[] sni, int[] inOutSz);
+
     /**
      * Gets the internal wolfSSL named group enum matching provided string.
      *

src/java/com/wolfssl/WolfSSL.java

@@ -771,6 +771,10 @@ protected void updateTimeouts(int in, int side) {
                     } catch (IllegalStateException e) {
                         /* Native WolfSSLSession has been freed,
                          * invalidate this session entry */
+                        WolfSSLDebug.log(getClass(), WolfSSLDebug.INFO,
+                            () -> "Native session freed while updating " +
+                                "timeout, invalidating cache entry: " +
+                                e.getMessage());
                         current.invalidate();
                     }
                 }

src/java/com/wolfssl/provider/jsse/WolfSSLAuthStore.java

@@ -338,16 +338,38 @@ protected synchronized void cacheRequestedServerNamesFromNetData() {
 
     private List<SNIServerName> parseRequestedServerNamesFromNetData() {
         ByteBuffer in;
+        byte[] clientHello;
+        byte[] sni;
+        int[] sniSz;
+        int ret;
+        List<SNIServerName> names;
 
         synchronized (netDataLock) {
             if (this.netData == null || this.netData.remaining() < 5) {
                 return null;
             }
             in = this.netData.asReadOnlyBuffer();
+            clientHello = new byte[in.remaining()];
+            in.get(clientHello);
         }
 
         try {
-            return parseRequestedServerNamesFromTlsRecord(in);
+            sni = new byte[clientHello.length];
+            sniSz = new int[] { sni.length };
+            ret = WolfSSL.getSNIFromBuffer(clientHello, clientHello.length,
+                (byte)WolfSSL.WOLFSSL_SNI_HOST_NAME, sni, sniSz);
+            if (ret == WolfSSL.SSL_SUCCESS && sniSz[0] > 0 &&
+                sniSz[0] <= sni.length) {
+
+                names = new ArrayList<SNIServerName>(1);
+                names.add(new SNIHostName(Arrays.copyOf(sni, sniSz[0])));
+                return names;
+            }
+
+            if (ret == WolfSSL.NOT_COMPILED_IN) {
+                return parseRequestedServerNamesFromTlsRecord(
+                    ByteBuffer.wrap(clientHello));
+            }
         } catch (IllegalArgumentException e) {
             WolfSSLDebug.log(getClass(), WolfSSLDebug.INFO,
                 () -> "Unable to parse SNI from pending input: " +
@@ -526,16 +548,24 @@ private static ByteBuffer sliceBytes(ByteBuffer in, int len) {
     }
 
     private static byte[] getBytes(ByteBuffer in, int len) {
-        byte[] out = new byte[len];
-
         if (len < 0 || len > in.remaining()) {
             throw new IllegalArgumentException("invalid TLS length");
         }
 
+        byte[] out = new byte[len];
         in.get(out);
         return out;
     }
 
+    private void clearPendingAppData() {
+        if (this.pendingAppData != null) {
+            Arrays.fill(this.pendingAppData, (byte)0);
+            this.pendingAppData = null;
+        }
+        this.pendingAppDataLen = 0;
+        this.pendingNetConsumed = 0;
+    }
+
     /**
      * Register I/O callbacks and contexts with WolfSSLSession and native
      * wolfSSL. Uses singleton pattern on callbacks.
@@ -1345,6 +1375,7 @@ private synchronized int RecvAppData(ByteBuffer[] out, int ofst, int length)
                 this.pendingAppData = new byte[ret];
                 System.arraycopy(tmp, 0, this.pendingAppData, 0, ret);
                 this.pendingAppDataLen = ret;
+                this.pendingNetConsumed = 0;
                 return 0; /* 0 bytes written to output */
             }
 
@@ -1546,8 +1577,10 @@ else if (hs == SSLEngineResult.HandshakeStatus.NEED_WRAP &&
                         ret = DoHandshake(false);
                     }
                     else {
-                        /* Check TLS record header for complete
-                         * record, return BUFFER_UNDERFLOW if not */
+                        /* TLS-only fast path: peek at the record header and
+                         * return BUFFER_UNDERFLOW before a JNI read when the
+                         * full record is not present. DTLS still relies on the
+                         * native WANT_READ path as the correctness fallback. */
                         boolean bufferUnderflow = false;
                         if (inRemaining > 0 && (this.ssl.dtls() == 0)) {
                             synchronized (netDataLock) {
@@ -1599,10 +1632,7 @@ else if (hs == SSLEngineResult.HandshakeStatus.NEED_WRAP &&
                                     in.position(in.position() +
                                         this.pendingNetConsumed);
                                 }
-                                Arrays.fill(this.pendingAppData, (byte) 0);
-                                this.pendingAppData = null;
-                                this.pendingAppDataLen = 0;
-                                this.pendingNetConsumed = 0;
+                                clearPendingAppData();
                             }
                             else {
                                 /* Still not enough output space */
@@ -1776,6 +1806,21 @@ else if (ret < 0 &&
                                 err);
                         }
                     }
+                    else if (!this.handshakeFinished && (ret == 0) &&
+                        (err == 0 || err == WolfSSL.SSL_ERROR_ZERO_RETURN)) {
+
+                        boolean gotCloseNotify = false;
+                        synchronized (ioLock) {
+                            gotCloseNotify = this.ssl.gotCloseNotify();
+                        }
+
+                        if (!gotCloseNotify && !this.closeNotifyReceived) {
+                            this.inBoundOpen = false;
+                            this.outBoundOpen = false;
+                            throw new SSLHandshakeException(
+                                "Peer closed connection during handshake");
+                        }
+                    }
 
                     /* Get DTLS drop count after data has been processed. To be
                      * used below when setting BUFFER_UNDERFLOW status. */
@@ -1908,6 +1953,9 @@ else if (ret < 0 &&
 
             return new SSLEngineResult(status, hs, consumed, produced);
 
+        } catch (SSLException | RuntimeException e) {
+            clearPendingAppData();
+            throw e;
         } finally {
             try {
                 /* Don't hold references to this SSLEngine object in
@@ -2060,6 +2108,8 @@ public synchronized void closeInbound() throws SSLException {
         WolfSSLDebug.log(getClass(), WolfSSLDebug.INFO,
             () -> "entered closeInbound");
 
+        clearPendingAppData();
+
         if (!inBoundOpen)
             return;
 
@@ -2084,6 +2134,8 @@ public synchronized boolean isInboundDone() {
     public synchronized void closeOutbound() {
         WolfSSLDebug.log(getClass(), WolfSSLDebug.INFO,
             () -> "entered closeOutbound, outBoundOpen = false");
+
+        clearPendingAppData();
         outBoundOpen = false;
 
         /* If handshake has not started yet, close inBound as well */

src/java/com/wolfssl/provider/jsse/WolfSSLEngine.java

@@ -172,6 +172,7 @@ else if (this.callingEngine != null &&
                     "passed, no endpoint identification configured)");
             }
         } catch (CertificateException e) {
+            this.verifyException = e;
             WolfSSLDebug.log(getClass(), WolfSSLDebug.INFO,
                 () -> "X509ExtendedTrustManager hostname verification " +
                 "failed: " + e.getMessage());
@@ -269,6 +270,8 @@ else if (this.callingSocket != null &&
         }
 
         if (peerHost == null || peerHost.isEmpty()) {
+            this.verifyException = new CertificateException(
+                "No peer host available for hostname verification");
             WolfSSLDebug.log(getClass(), WolfSSLDebug.INFO,
                 () -> "No peer host available for hostname verification");
             /* No peer host to verify against, fail verification since