Allow to access the SSLEngine for a QuicChannel (java-native-access#277)

Motivation:

We should allow to access the SSLEngine for a QuicChannel as it may contain interesting infos for the user like the application protocol / ciphers etc

Modifications:

- Add sslEngine() method to QuicChannel
- Adjust testcase to check if we can access the engine and if it contains the application protocol

Result:

Be able to access the engine

src/main/java/io/netty/incubator/codec/quic/QuicChannel.java

@@ -24,6 +24,7 @@
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.Promise;
 
+import javax.net.ssl.SSLEngine;
 import java.net.SocketAddress;
 
 /**
@@ -148,6 +149,13 @@ default ChannelPromise voidPromise() {
     @Override
     QuicChannelConfig config();
 
+    /**
+     * Returns the used {@link SSLEngine} or {@code null} if none is used (yet).
+     *
+     * @return the engine.
+     */
+    SSLEngine sslEngine();
+
     /**
      * Returns the number of streams that can be created before stream creation will fail
      * with {@link QuicError#STREAM_LIMIT} error.

src/main/java/io/netty/incubator/codec/quic/QuicheQuicChannel.java

@@ -42,6 +42,7 @@
 import io.netty.util.internal.logging.InternalLogger;
 import io.netty.util.internal.logging.InternalLoggerFactory;
 
+import javax.net.ssl.SSLEngine;
 import java.io.File;
 import java.net.ConnectException;
 import java.net.InetSocketAddress;
@@ -50,9 +51,7 @@
 import java.nio.channels.AlreadyConnectedException;
 import java.nio.channels.ClosedChannelException;
 import java.nio.channels.ConnectionPendingException;
-import java.util.ArrayDeque;
 import java.util.Map;
-import java.util.Queue;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
@@ -111,7 +110,7 @@ public void operationComplete(ChannelFuture future) {
     private final TimeoutHandler timeoutHandler = new TimeoutHandler();
     private final InetSocketAddress remote;
 
-    private QuicheQuicConnection connection;
+    private volatile QuicheQuicConnection connection;
     private boolean inFireChannelReadCompleteQueue;
     private boolean fireChannelReadCompletePending;
     private ByteBuf finBuffer;
@@ -179,6 +178,12 @@ static QuicheQuicChannel forServer(Channel parent, ByteBuffer key, InetSocketAdd
                 streamHandler, streamOptionsArray, streamAttrsArray);
     }
 
+    @Override
+    public SSLEngine sslEngine() {
+        QuicheQuicConnection connection = this.connection;
+        return connection == null ? null : connection.engine();
+    }
+
     @Override
     public long peerAllowedStreams(QuicStreamType type) {
         switch (type) {

src/main/java/io/netty/incubator/codec/quic/QuicheQuicConnection.java

@@ -19,10 +19,12 @@
 
 final class QuicheQuicConnection {
     private final ReferenceCounted refCnt;
+    private final QuicheQuicSslEngine engine;
     private long connection;
 
-    QuicheQuicConnection(long connection, ReferenceCounted refCnt) {
+    QuicheQuicConnection(long connection, QuicheQuicSslEngine engine, ReferenceCounted refCnt) {
         this.connection = connection;
+        this.engine = engine;
         this.refCnt = refCnt;
     }
 
@@ -39,6 +41,10 @@ void free() {
         }
     }
 
+    QuicheQuicSslEngine engine() {
+        return engine;
+    }
+
     long address() {
         assert connection != -1;
         return connection;

src/main/java/io/netty/incubator/codec/quic/QuicheQuicSslContext.java

@@ -169,7 +169,7 @@ QuicheQuicConnection createConnection(LongFunction<Long> connectionCreator, Quic
             return null;
         }
         // The connection will call nativeSslContext.release() once it is freed.
-        return new QuicheQuicConnection(connection, nativeSslContext);
+        return new QuicheQuicConnection(connection, engine, nativeSslContext);
     }
 
     @Override

src/test/java/io/netty/incubator/codec/quic/QuicChannelConnectTest.java

@@ -285,6 +285,7 @@ public int maxTokenLength() {
             stream.writeAndFlush(Unpooled.directBuffer().writeZero(numBytes)).sync();
             clientLatch.await();
 
+            assertEquals(QuicTestUtils.PROTOS[0], quicChannel.sslEngine().getApplicationProtocol());
             stream.close().sync();
             quicChannel.close().sync();
             ChannelFuture closeFuture = quicChannel.closeFuture().await();