Quic API and implementation - this is a work in progress.

Author: vietj

vertx-core/pom.xml

@@ -70,6 +70,16 @@
       <groupId>io.netty</groupId>
       <artifactId>netty-codec-http2</artifactId>
     </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-codec-http3</artifactId>
+      <exclusions>
+        <exclusion>
+          <groupId>org.bouncycastle</groupId>
+          <artifactId>*</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-resolver</artifactId>
@@ -98,6 +108,16 @@
       <artifactId>netty-transport-classes-kqueue</artifactId>
       <optional>true</optional>
     </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-codec-classes-quic</artifactId>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-codec-native-quic</artifactId>
+      <optional>true</optional>
+    </dependency>
 
     <!-- Jackson -->
     <dependency>
@@ -880,6 +900,12 @@
           <classifier>linux-x86_64</classifier>
           <scope>test</scope>
         </dependency>
+        <dependency>
+          <groupId>io.netty</groupId>
+          <artifactId>netty-codec-native-quic</artifactId>
+          <classifier>linux-x86_64</classifier>
+          <scope>test</scope>
+        </dependency>
       </dependencies>
     </profile>
 
@@ -904,6 +930,12 @@
           <classifier>linux-x86_64</classifier>
           <scope>test</scope>
         </dependency>
+        <dependency>
+          <groupId>io.netty</groupId>
+          <artifactId>netty-codec-native-quic</artifactId>
+          <classifier>linux-x86_64</classifier>
+          <scope>test</scope>
+        </dependency>
       </dependencies>
     </profile>
 
@@ -928,6 +960,12 @@
           <classifier>linux-aarch_64</classifier>
           <scope>test</scope>
         </dependency>
+        <dependency>
+          <groupId>io.netty</groupId>
+          <artifactId>netty-codec-native-quic</artifactId>
+          <classifier>linux-aarch_64</classifier>
+          <scope>test</scope>
+        </dependency>
       </dependencies>
     </profile>
 
@@ -952,6 +990,12 @@
           <classifier>osx-x86_64</classifier>
           <scope>test</scope>
         </dependency>
+        <dependency>
+          <groupId>io.netty</groupId>
+          <artifactId>netty-codec-native-quic</artifactId>
+          <classifier>osx-x86_64</classifier>
+          <scope>test</scope>
+        </dependency>
       </dependencies>
     </profile>
 
@@ -976,6 +1020,12 @@
           <classifier>osx-aarch_64</classifier>
           <scope>test</scope>
         </dependency>
+        <dependency>
+          <groupId>io.netty</groupId>
+          <artifactId>netty-codec-native-quic</artifactId>
+          <classifier>osx-aarch_64</classifier>
+          <scope>test</scope>
+        </dependency>
       </dependencies>
     </profile>
 

vertx-core/src/main/java/io/vertx/core/internal/net/SslChannelProvider.java

@@ -83,7 +83,7 @@ private SslHandler createServerSslHandler(boolean useAlpn, long sslHandshakeTime
 
   private SniHandler createSniHandler(boolean useAlpn, long sslHandshakeTimeout, TimeUnit sslHandshakeTimeoutUnit, HostAndPort remoteAddress) {
     Executor delegatedTaskExec = sslContextProvider.useWorkerPool() ? workerPool : ImmediateExecutor.INSTANCE;
-    return new VertxSniHandler(sslContextProvider.serverNameMapping(delegatedTaskExec, useAlpn), sslHandshakeTimeoutUnit.toMillis(sslHandshakeTimeout), delegatedTaskExec, remoteAddress);
+    return new VertxSniHandler(sslContextProvider.serverNameAsyncMapping(delegatedTaskExec, useAlpn), sslHandshakeTimeoutUnit.toMillis(sslHandshakeTimeout), delegatedTaskExec, remoteAddress);
   }
 
 }

vertx-core/src/main/java/io/vertx/core/internal/quic/QuicConnectionInternal.java

@@ -0,0 +1,10 @@
+package io.vertx.core.internal.quic;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.vertx.core.quic.QuicConnection;
+
+public interface QuicConnectionInternal extends QuicConnection {
+
+  ChannelHandlerContext channelHandlerContext();
+
+}

vertx-core/src/main/java/io/vertx/core/internal/quic/QuicEndpointInternal.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2011-2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+ * which is available at https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+ */
+package io.vertx.core.internal.quic;
+
+import io.netty.handler.codec.quic.FlushStrategy;
+import io.vertx.core.quic.QuicEndpoint;
+
+public interface QuicEndpointInternal extends QuicEndpoint {
+
+  QuicEndpointInternal flushStrategy(FlushStrategy flushStrategy);
+
+}

vertx-core/src/main/java/io/vertx/core/internal/quic/QuicStreamInternal.java

@@ -0,0 +1,47 @@
+package io.vertx.core.internal.quic;
+
+import io.vertx.codegen.annotations.Nullable;
+import io.vertx.core.Handler;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.internal.net.SocketInternal;
+import io.vertx.core.quic.QuicStream;
+
+public interface QuicStreamInternal extends QuicStream, SocketInternal {
+
+  @Override
+  QuicStreamInternal messageHandler(Handler<Object> handler);
+
+  @Override
+  QuicStreamInternal readCompletionHandler(Handler<Void> handler);
+
+  @Override
+  QuicStreamInternal eventHandler(Handler<Object> handler);
+
+  @Override
+  QuicStreamInternal exceptionHandler(@Nullable Handler<Throwable> handler);
+
+  @Override
+  QuicStreamInternal handler(@Nullable Handler<Buffer> handler);
+
+  @Override
+  QuicStreamInternal pause();
+
+  @Override
+  QuicStreamInternal resume();
+
+  @Override
+  QuicStreamInternal fetch(long amount);
+
+  @Override
+  QuicStreamInternal endHandler(@Nullable Handler<Void> endHandler);
+
+  @Override
+  QuicStreamInternal setWriteQueueMaxSize(int maxSize);
+
+  @Override
+  QuicStreamInternal drainHandler(@Nullable Handler<Void> handler);
+
+  @Override
+  QuicStreamInternal closeHandler(@Nullable Handler<Void> handler);
+
+}

vertx-core/src/main/java/io/vertx/core/internal/tls/SslContextProvider.java

@@ -13,6 +13,7 @@
 import io.netty.handler.ssl.SniHandler;
 import io.netty.handler.ssl.SslContext;
 import io.netty.util.AsyncMapping;
+import io.netty.util.Mapping;
 import io.vertx.core.VertxException;
 import io.vertx.core.http.ClientAuth;
 import io.vertx.core.spi.tls.SslContextFactory;
@@ -147,12 +148,28 @@ public SslContext sslServerContext(boolean useAlpn) {
     }
   }
 
+  /**
+   *
+   * @param useAlpn
+   * @return
+   */
+  public Mapping<? super String, ? extends SslContext> serverNameMapping(boolean useAlpn) {
+    return (Mapping<String, SslContext>) serverName -> {
+      try {
+        return sslContext(serverName, useAlpn, true);
+      } catch (Exception e) {
+        // Log this
+        return null;
+      }
+    };
+  }
+
   /**
    * Server name {@link AsyncMapping} for {@link SniHandler}, mapping happens on a Vert.x worker thread.
    *
    * @return the {@link AsyncMapping}
    */
-  public AsyncMapping<? super String, ? extends SslContext> serverNameMapping(Executor workerPool, boolean useAlpn) {
+  public AsyncMapping<? super String, ? extends SslContext> serverNameAsyncMapping(Executor workerPool, boolean useAlpn) {
     return (AsyncMapping<String, SslContext>) (serverName, promise) -> {
       workerPool.execute(() -> {
         SslContext sslContext;

vertx-core/src/main/java/io/vertx/core/net/TcpOptions.java

@@ -54,7 +54,7 @@ void init() {
   }
 
   @Override
-  TcpOptions copy() {
+  protected TcpOptions copy() {
     return new TcpOptions(this);
   }
 

vertx-core/src/main/java/io/vertx/core/net/TransportOptions.java

@@ -15,6 +15,6 @@
  */
 public abstract class TransportOptions {
 
-  abstract TransportOptions copy();
+  protected abstract TransportOptions copy();
 
 }

vertx-core/src/main/java/io/vertx/core/net/impl/ConnectionBase.java

@@ -13,10 +13,10 @@
 
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.*;
+import io.netty.handler.codec.quic.QuicChannel;
 import io.netty.handler.ssl.SslHandler;
 import io.netty.handler.traffic.AbstractTrafficShapingHandler;
 import io.netty.util.AttributeKey;
-import io.netty.util.concurrent.EventExecutor;
 import io.netty.util.concurrent.FutureListener;
 import io.vertx.core.*;
 import io.vertx.core.internal.ContextInternal;
@@ -29,14 +29,14 @@
 import io.vertx.core.net.SocketAddress;
 import io.vertx.core.spi.metrics.NetworkMetrics;
 import io.vertx.core.spi.metrics.TCPMetrics;
+import io.vertx.core.spi.metrics.TransportMetrics;
 
 import javax.net.ssl.SSLPeerUnverifiedException;
 import javax.net.ssl.SSLSession;
 import java.net.InetSocketAddress;
 import java.security.cert.Certificate;
 import java.util.Arrays;
 import java.util.List;
-import java.util.concurrent.TimeUnit;
 
 /**
  * Abstract base class for connections managed by a vertx instance. This base implementation does not handle
@@ -187,8 +187,8 @@ protected void handleClosed() {
     if (metrics != null) {
       flushBytesRead();
       flushBytesWritten();
-      if (metrics instanceof TCPMetrics) {
-        ((TCPMetrics) metrics).disconnected(metric(), remoteAddress());
+      if (metrics instanceof TransportMetrics<?>) {
+        ((TransportMetrics<Object>) metrics).disconnected(metric(), remoteAddress());
       }
     }
     context.execute(() -> {
@@ -352,7 +352,12 @@ public String remoteName() {
   }
 
   private SocketAddress channelRemoteAddress() {
-    java.net.SocketAddress addr = channel.remoteAddress();
+    java.net.SocketAddress addr;
+    if (channel instanceof QuicChannel) {
+      addr = ((QuicChannel)channel).remoteSocketAddress();
+    } else {
+      addr = channel.remoteAddress();
+    }
     return addr != null ? vertx.transport().convert(addr) : null;
   }
 
@@ -393,7 +398,12 @@ public SocketAddress remoteAddress(boolean real) {
   }
 
   private SocketAddress channelLocalAddress() {
-    java.net.SocketAddress addr = channel.localAddress();
+    java.net.SocketAddress addr;
+    if (channel instanceof QuicChannel) {
+      addr = ((QuicChannel)channel).localSocketAddress();
+    } else {
+      addr = channel.localAddress();
+    }
     return addr != null ? vertx.transport().convert(addr) : null;
   }
 

vertx-core/src/main/java/io/vertx/core/quic/CongestionControlAlgorithm.java

@@ -0,0 +1,7 @@
+package io.vertx.core.quic;
+
+public enum CongestionControlAlgorithm {
+  RENO,
+  CUBIC,
+  BBR
+}