Add support for HA Proxy Protocol TLV's

TLV's are supported in netty, but currently not accessible to vert.x
users.
Here the TLV's are exposed in `NetSocket#tlvs`

Author: damianorenfer

vertx-core/src/main/java/io/vertx/core/http/HttpConnection.java

@@ -23,6 +23,7 @@
 import java.time.Duration;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -298,4 +299,11 @@ default List<Certificate> peerCertificates() throws SSLPeerUnverifiedException {
    */
   String indicatedServerName();
 
+  /**
+   * @return the type-length-values present in the TCP header as map where the key contains the TLV type and
+   * the value contains the TLV value, mainly used for HA Proxy Protocol v2
+   */
+  @GenIgnore()
+  Map<Buffer, Buffer> tlvs();
+
 }

vertx-core/src/main/java/io/vertx/core/http/impl/HttpNetSocket.java

@@ -16,7 +16,6 @@
 import io.vertx.core.Handler;
 import io.vertx.core.buffer.Buffer;
 import io.vertx.core.http.HttpClosedException;
-import io.vertx.core.http.StreamResetException;
 import io.vertx.core.internal.ContextInternal;
 import io.vertx.core.net.NetSocket;
 import io.vertx.core.net.SSLOptions;
@@ -26,6 +25,7 @@
 
 import javax.net.ssl.SSLSession;
 import java.time.Duration;
+import java.util.Map;
 
 /**
  * @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
@@ -229,6 +229,11 @@ public SocketAddress localAddress(boolean real) {
     return stream.connection().localAddress(real);
   }
 
+  @Override
+  public Map<Buffer, Buffer> tlvs() {
+    return stream.connection().tlvs();
+  }
+
   @Override
   public Future<Void> close() {
     return end();

vertx-core/src/main/java/io/vertx/core/http/impl/UnpooledHttpClientConnection.java

@@ -26,7 +26,7 @@
 import java.time.Duration;
 import java.util.ArrayDeque;
 import java.util.Deque;
-import java.util.concurrent.TimeUnit;
+import java.util.Map;
 
 /**
  * An un-pooled HTTP client connection that maintains a queue for pending requests that cannot be served
@@ -207,6 +207,11 @@ public String indicatedServerName() {
     return actual.indicatedServerName();
   }
 
+  @Override
+  public Map<Buffer, Buffer> tlvs() {
+    return actual.tlvs();
+  }
+
   /**
    * Create an HTTP stream.
    *

vertx-core/src/main/java/io/vertx/core/http/impl/http3/Http3Connection.java

@@ -33,7 +33,6 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
 
 /**
  * @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
@@ -332,4 +331,9 @@ public HttpConnection pingHandler(@Nullable Handler<Buffer> handler) {
   public HttpConnection exceptionHandler(Handler<Throwable> handler) {
     return this;
   }
+
+  @Override
+  public Map<Buffer, Buffer> tlvs() {
+    return connection.tlvs();
+  }
 }

vertx-core/src/main/java/io/vertx/core/http/impl/tcp/Http2UpgradeClientConnection.java

@@ -34,10 +34,11 @@
 import io.vertx.core.net.HostAndPort;
 import io.vertx.core.net.SocketAddress;
 import io.vertx.core.spi.metrics.ClientMetrics;
-import io.vertx.core.spi.metrics.HttpClientMetrics;
+
 
 import javax.net.ssl.SSLSession;
 import java.time.Duration;
+import java.util.Map;
 
 /**
  * A connection that attempts to perform a protocol upgrade to H2C. The connection might use HTTP/1 or H2C
@@ -901,6 +902,11 @@ public String indicatedServerName() {
     return current.indicatedServerName();
   }
 
+  @Override
+  public Map<Buffer, Buffer> tlvs() {
+    return current.tlvs();
+  }
+
   @Override
   public String toString() {
     return getClass().getSimpleName() + "[current=" + current.getClass().getSimpleName() + "]";

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

@@ -18,7 +18,6 @@
 import io.vertx.codegen.annotations.VertxGen;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
-import io.vertx.core.VertxException;
 import io.vertx.core.buffer.Buffer;
 import io.vertx.core.streams.ReadStream;
 import io.vertx.core.streams.WriteStream;
@@ -29,6 +28,7 @@
 import java.time.Duration;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Represents a socket-like interface to a TCP connection on either the
@@ -316,5 +316,12 @@ default List<Certificate> peerCertificates() throws SSLPeerUnverifiedException {
    */
   String applicationLayerProtocol();
 
+  /**
+   * @return the type-length-values present in the TCP header as map where the key contains the TLV type and
+   * the value contains the TLV value, mainly used for HA Proxy Protocol v2
+   */
+  @GenIgnore()
+  Map<Buffer, Buffer> tlvs();
+
 }
 

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

@@ -18,6 +18,7 @@
 
 import javax.net.ssl.SSLSession;
 import java.time.Duration;
+import java.util.Map;
 
 /**
  * <p>A Quic connection between a client and a server, providing support for handling or creating Quic {@link QuicStream streams}</p>
@@ -176,4 +177,11 @@ default Future<Void> shutdown(Duration timeout) {
    */
   SocketAddress localAddress();
 
+  /**
+   * @return the type-length-values present in the TCP header as map where the key contains the TLV type and
+   * the value contains the TLV value, mainly used for HA Proxy Protocol v2
+   */
+  @GenIgnore()
+  Map<Buffer, Buffer> tlvs();
+
 }

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

@@ -19,6 +19,7 @@
 import io.netty.util.AttributeKey;
 import io.netty.util.concurrent.FutureListener;
 import io.vertx.core.*;
+import io.vertx.core.buffer.Buffer;
 import io.vertx.core.internal.ContextInternal;
 import io.vertx.core.internal.PromiseInternal;
 import io.vertx.core.internal.VertxInternal;
@@ -32,6 +33,7 @@
 
 import javax.net.ssl.SSLSession;
 import java.net.InetSocketAddress;
+import java.util.Map;
 
 /**
  * Abstract base class for connections managed by a vertx instance. This base implementation does not handle
@@ -53,6 +55,7 @@ public abstract class ConnectionBase {
   public static final VertxException CLOSED_EXCEPTION = NetSocketInternal.CLOSED_EXCEPTION;
   public static final AttributeKey<SocketAddress> REMOTE_ADDRESS_OVERRIDE = AttributeKey.valueOf("RemoteAddressOverride");
   public static final AttributeKey<SocketAddress> LOCAL_ADDRESS_OVERRIDE = AttributeKey.valueOf("LocalAddressOverride");
+  public static final AttributeKey<Map<Buffer, Buffer>> TLVS = AttributeKey.valueOf("TLVS");
   private static final Logger log = LoggerFactory.getLogger(ConnectionBase.class);
 
   protected final VertxInternal vertx;
@@ -426,4 +429,8 @@ public SocketAddress localAddress(boolean real) {
     }
   }
 
+  public Map<Buffer, Buffer> tlvs() {
+    return channel.hasAttr(TLVS) ? channel.attr(TLVS).getAndSet(null) : null;
+  }
+
 }

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

@@ -1,19 +1,25 @@
 package io.vertx.core.net.impl;
 
+import io.netty.buffer.ByteBufUtil;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.MessageToMessageDecoder;
 import io.netty.handler.codec.haproxy.HAProxyMessage;
 import io.netty.handler.codec.haproxy.HAProxyProxiedProtocol;
+import io.netty.handler.codec.haproxy.HAProxyTLV;
 import io.netty.handler.timeout.IdleState;
 import io.netty.handler.timeout.IdleStateEvent;
 import io.netty.util.concurrent.Promise;
+import io.vertx.core.buffer.Buffer;
 import io.vertx.core.internal.logging.Logger;
 import io.vertx.core.internal.logging.LoggerFactory;
 import io.vertx.core.net.SocketAddress;
 
 import java.io.IOException;
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
 
 public class HAProxyMessageCompletionHandler extends MessageToMessageDecoder<HAProxyMessage> {
   //Public because its used in tests
@@ -71,6 +77,11 @@ protected void decode(ChannelHandlerContext ctx, HAProxyMessage msg, List<Object
           ctx.channel().attr(ConnectionBase.LOCAL_ADDRESS_OVERRIDE)
             .set(createAddress(protocol, msg.destinationAddress(), msg.destinationPort()));
         }
+
+        if (msg.tlvs() != null) {
+          ctx.channel().attr(ConnectionBase.TLVS)
+            .set(createTLVs(msg.tlvs()));
+        }
       }
       ctx.pipeline().remove(this);
       promise.setSuccess(ctx.channel());
@@ -103,4 +114,11 @@ private SocketAddress createAddress(HAProxyProxiedProtocol protocol, String sour
         throw new IllegalStateException("Should never happen");
     }
   }
+
+  private Map<Buffer, Buffer> createTLVs(List<HAProxyTLV> haProxyTLVs) {
+    return haProxyTLVs.stream()
+      .filter(Objects::nonNull)
+      .collect(Collectors.toMap(tlv -> Buffer.buffer().appendByte(tlv.typeByteValue()),
+        tlv -> Buffer.buffer(ByteBufUtil.getBytes(tlv.content()))));
+  }
 }

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2011-2026 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.net.impl;
+
+import io.netty.buffer.ByteBufUtil;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.net.TLV;
+
+public class HAProxyTLV implements TLV {
+
+  private final Buffer type;
+  private final Buffer value;
+
+  public HAProxyTLV(Buffer type, Buffer value) {
+    this.type = type;
+    this.value = value;
+  }
+
+  public static TLV from(io.netty.handler.codec.haproxy.HAProxyTLV haProxyTLV) {
+    Buffer type = Buffer.buffer().appendByte(haProxyTLV.typeByteValue());
+    Buffer value = Buffer.buffer(ByteBufUtil.getBytes(haProxyTLV.content()));
+    return new HAProxyTLV(type, value);
+  }
+
+  @Override
+  public Buffer type() {
+    return type;
+  }
+
+  @Override
+  public Buffer value() {
+    return value;
+  }
+}