5553 permits access to :authority HTTP/2 pseudo header value

And fix the `HttpServerRequest#autority()` javadoc, which was incorrect.
And have a single source of authority truth between the Http2ServerStream and Http2ServerRequest

Author: NilsRenaud

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

@@ -117,14 +117,26 @@ default boolean isSSL() {
   String scheme();
 
   /**
-   * @return the request authority. For HTTP/2 the {@literal :authority} pseudo header is returned, for HTTP/1.x the
-   *         {@literal Host} header is returned or {@code null} when no such header is present. When the authority
-   *         string does not carry a port, the {@link HostAndPort#port()} returns {@code -1} to indicate the
-   *         scheme port is prevalent.
+   * @return the request authority.
+   *         <ul>
+   *           <li>HTTP/2: the {@literal :authority} pseudo header is returned if present, otherwise the {@literal Host}
+   *           header value is returned.
+   *           <li>HTTP/1.x: the {@literal Host} header is returned
+   *           <li>or {@code null} when no such header is present
+   *         </ul>
+   *         When the authority string does not carry a port, the {@link HostAndPort#port()} returns {@code -1} to
+   *         indicate the scheme port is prevalent.
    */
   @Nullable
   HostAndPort authority();
 
+  /**
+   * @param real whether to return the value of the real HTTP/2 {@literal :authority} header, or the computed one.
+   * @return the authority, either computed or real. May be null when {@literal real} is {@code true}.
+   */
+  @Nullable
+  HostAndPort authority(boolean real);
+
   /**
    * @return the total number of bytes read for the body of the request.
    */

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

@@ -282,6 +282,11 @@ public HostAndPort authority() {
     return authority;
   }
 
+  @Override
+  public HostAndPort authority(boolean real) {
+    return real ? null : authority();
+  }
+
   @Override
   public long bytesRead() {
     synchronized (conn) {

vertx-core/src/main/java/io/vertx/core/http/impl/http2/Http2HeadersMultiMap.java

@@ -57,7 +57,8 @@ private Http2HeadersMultiMap(boolean mutable, Headers<CharSequence, CharSequence
 
   private Integer status;
   private HttpMethod method;
-  private HostAndPort authority;
+  private HostAndPort computedAuthority;
+  private HostAndPort realAuthority;
   private String uri;
   private String scheme;
 
@@ -75,24 +76,25 @@ public boolean validate(boolean isRequest) {
       CharSequence pathHeader = headers.get(HttpHeaders.PSEUDO_PATH);
       String uri = pathHeader != null ? pathHeader.toString() : null;
 
-      HostAndPort authority = null;
+      HostAndPort currentAuthority = null;
       String authorityHeaderAsString;
       CharSequence authorityHeader = headers.get(HttpHeaders.PSEUDO_AUTHORITY);
       if (authorityHeader != null) {
         authorityHeaderAsString = authorityHeader.toString();
-        authority = HostAndPort.parseAuthority(authorityHeaderAsString, -1);
+        this.realAuthority = HostAndPort.parseAuthority(authorityHeaderAsString, -1);
+        currentAuthority = this.realAuthority;
       }
 
       CharSequence hostHeader = headers.get(HttpHeaders.HOST);
-      if (authority == null) {
+      if (currentAuthority == null) {
         headers.remove(HttpHeaders.HOST);
         if (hostHeader != null) {
-          authority = HostAndPort.parseAuthority(hostHeader.toString(), -1);
+          currentAuthority = HostAndPort.parseAuthority(hostHeader.toString(), -1);
         }
       }
 
       if (method == HttpMethod.CONNECT) {
-        if (scheme != null || uri != null || authority == null) {
+        if (scheme != null || uri != null || currentAuthority == null) {
           return false;
         }
       } else {
@@ -103,20 +105,20 @@ public boolean validate(boolean isRequest) {
 
       boolean hasAuthority = authorityHeader != null || hostHeader != null;
       if (hasAuthority) {
-        if (authority == null) {
+        if (currentAuthority == null) {
           return false;
         }
         if (hostHeader != null) {
           HostAndPort host = HostAndPort.parseAuthority(hostHeader.toString(), -1);
-          if (host == null || (!authority.host().equals(host.host()) || authority.port() != host.port())) {
+          if (host == null || (!currentAuthority.host().equals(host.host()) || currentAuthority.port() != host.port())) {
             return false;
           }
         }
       }
 
       this.method = method;
       this.uri = uri;
-      this.authority = authority;
+      this.computedAuthority = currentAuthority;
       this.scheme = scheme;
 
       return true;
@@ -156,8 +158,8 @@ public Http2HeadersMultiMap prepare() {
     if (scheme != null) {
       headers.set(HttpHeaders.PSEUDO_SCHEME, scheme);
     }
-    if (authority != null) {
-      headers.set(HttpHeaders.PSEUDO_AUTHORITY, authority.toString(ssl));
+    if (computedAuthority != null) {
+      headers.set(HttpHeaders.PSEUDO_AUTHORITY, computedAuthority.toString(ssl));
     }
     if (scheme != null) {
       headers.set(HttpHeaders.PSEUDO_SCHEME, scheme);
@@ -205,12 +207,16 @@ public HttpMethod method() {
   }
 
   public Http2HeadersMultiMap authority(HostAndPort authority) {
-    this.authority = authority;
+    this.computedAuthority = authority;
     return this;
   }
 
   public HostAndPort authority() {
-    return authority;
+    return computedAuthority;
+  }
+
+  public HostAndPort authority(boolean real) {
+    return real ? realAuthority : computedAuthority;
   }
 
   public String scheme() {

vertx-core/src/main/java/io/vertx/core/http/impl/http2/Http2ServerRequest.java

@@ -348,6 +348,11 @@ public String scheme() {
     return stream.authority();
   }
 
+  @Override
+  public @Nullable HostAndPort authority(boolean real) {
+    return stream.authority(real);
+  }
+
   @Override
   public long bytesRead() {
     return stream.bytesRead();

vertx-core/src/main/java/io/vertx/core/http/impl/http2/Http2ServerStream.java

@@ -39,7 +39,6 @@ public class Http2ServerStream extends Http2StreamBase {
   private String scheme;
   private HttpMethod method;
   private String uri;
-  private HostAndPort authority;
   private Http2ServerStreamHandler handler;
 
   // Observability
@@ -67,7 +66,6 @@ public Http2ServerStream(Http2ServerConnection connection,
     this.method = method;
     this.uri = uri;
     this.scheme = null;
-    this.authority = null;
     this.tracingPolicy = tracingPolicy;
     this.serverMetrics = serverMetrics;
     this.socketMetric = socketMetric;
@@ -88,7 +86,7 @@ public Http2ServerStream(Http2ServerConnection connection,
 
   private HttpRequest observableRequest() {
     if (observableRequest == null) {
-      observableRequest = new HttpRequestHead(method, uri, requestHeaders, authority, null, null);
+      observableRequest = new HttpRequestHead(method, uri, requestHeaders, requestHeaders.authority(), null, null);
     }
     return observableRequest;
   }
@@ -127,7 +125,11 @@ public String scheme() {
   }
 
   public HostAndPort authority() {
-    return authority;
+    return requestHeaders.authority(false);
+  }
+
+  public HostAndPort authority(boolean real) {
+    return requestHeaders.authority(real);
   }
 
   public Object metric() {
@@ -143,7 +145,6 @@ public void onHeaders(Http2HeadersMultiMap headers) {
 
     this.method = headers.method();
     this.uri = headers.path();
-    this.authority = headers.authority();
     this.scheme = headers.scheme();
     this.requestHeaders = headers;
 

vertx-core/src/main/java/io/vertx/core/internal/http/HttpServerRequestWrapper.java

@@ -101,6 +101,11 @@ public HostAndPort authority() {
     return delegate.authority();
   }
 
+  @Override
+  public @Nullable HostAndPort authority(boolean real) {
+    return delegate.authority(real);
+  }
+
   @Override
   public boolean isValidAuthority() {
     return delegate.isValidAuthority();

vertx-core/src/test/java/io/vertx/tests/http/Http2ClientTest.java

@@ -366,6 +366,7 @@ public void testOverrideAuthority() throws Exception {
     server.requestHandler(req -> {
       assertEquals("localhost", req.authority().host());
       assertEquals(4444, req.authority().port());
+      assertEquals(req.authority(), req.authority(true));
       req.response().end();
     });
     startServer(testAddress);
@@ -380,26 +381,19 @@ public void testOverrideAuthority() throws Exception {
 
   @Test
   public void testNoAuthority() throws Exception {
-    ServerBootstrap bootstrap = createH2Server((decoder, encoder) -> new Http2EventAdapter() {
-      @Override
-      public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream) throws Http2Exception {
-        vertx.runOnContext(v -> {
-          assertNull(headers.authority());
-          encoder.writeHeaders(ctx, streamId, new DefaultHttp2Headers().status("200"), 0, true, ctx.newPromise());
-          ctx.flush();
-        });
-      }
+    server.requestHandler(req -> {
+      assertEquals("fromHost", req.authority().host());
+      assertEquals(1234, req.authority().port());
+      assertNull(req.authority(true));
+      req.response().end();
     });
-    ChannelFuture s = bootstrap.bind(DEFAULT_HTTPS_HOST, DEFAULT_HTTPS_PORT).sync();
+    startServer(testAddress);
     client.request(new RequestOptions().setServer(testAddress)
-        .setPort(4444)
-        .setHost("localhost")
-      )
-      .compose(request -> {
-        request.authority(null);
-        return request.send();
-      })
-      .onComplete(onSuccess(resp -> testComplete()));
+                                       .addHeader("Host", "fromHost:1234")
+          )
+          .onSuccess(req -> req.authority(null))
+          .compose(HttpClientRequest::send)
+          .onComplete(onSuccess(resp -> testComplete()));
     await();
   }