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

(cherry picked from commit 532e428)

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/Http2ServerConnection.java

@@ -84,7 +84,7 @@ private static boolean isMalformedRequest(Http2ServerStream request) {
     }
 
     if (request.method == HttpMethod.CONNECT) {
-      if (request.scheme != null || request.uri != null || request.authority == null) {
+      if (request.scheme != null || request.uri != null || request.authority() == null) {
         return true;
       }
     } else {
@@ -93,13 +93,13 @@ private static boolean isMalformedRequest(Http2ServerStream request) {
       }
     }
     if (request.hasAuthority) {
-      if (request.authority == null) {
+      if (request.authority() == null) {
         return true;
       }
       CharSequence hostHeader = request.headers.get(HttpHeaders.HOST);
       if (hostHeader != null) {
         HostAndPort host = HostAndPort.parseAuthority(hostHeader.toString(), -1);
-        return host == null || (!request.authority.host().equals(host.host()) || request.authority.port() != host.port());
+        return host == null || (!request.authority().host().equals(host.host()) || request.authority().port() != host.port());
       }
     }
     return false;
@@ -128,18 +128,20 @@ String determineContentEncoding(Http2Headers headers) {
 
   private Http2ServerStream createStream(Http2Headers headers, boolean streamEnded) {
     CharSequence schemeHeader = headers.getAndRemove(HttpHeaders.PSEUDO_SCHEME);
-    HostAndPort authority = null;
+    HostAndPort realAuthority = null;
+    HostAndPort computedAuthority = null;
     String authorityHeaderAsString;
     CharSequence authorityHeader = headers.getAndRemove(HttpHeaders.PSEUDO_AUTHORITY);
     if (authorityHeader != null) {
       authorityHeaderAsString = authorityHeader.toString();
-      authority = HostAndPort.parseAuthority(authorityHeaderAsString, -1);
+      realAuthority = HostAndPort.parseAuthority(authorityHeaderAsString, -1);
+      computedAuthority = realAuthority;
     }
     CharSequence hostHeader = null;
-    if (authority == null) {
+    if (computedAuthority == null) {
       hostHeader = headers.getAndRemove(HttpHeaders.HOST);
       if (hostHeader != null) {
-        authority = HostAndPort.parseAuthority(hostHeader.toString(), -1);
+        computedAuthority = HostAndPort.parseAuthority(hostHeader.toString(), -1);
       }
     }
     CharSequence pathHeader = headers.getAndRemove(HttpHeaders.PSEUDO_PATH);
@@ -150,7 +152,8 @@ private Http2ServerStream createStream(Http2Headers headers, boolean streamEnded
       headers,
       schemeHeader != null ? schemeHeader.toString() : null,
       authorityHeader != null || hostHeader != null,
-      authority,
+      realAuthority,
+      computedAuthority,
       methodHeader != null ? HttpMethod.valueOf(methodHeader.toString()) : null,
       pathHeader != null ? pathHeader.toString() : null,
       options.getTracingPolicy(), streamEnded);

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

@@ -321,7 +321,12 @@ public String scheme() {
 
   @Override
   public @Nullable HostAndPort authority() {
-    return stream.authority;
+    return stream.authority();
+  }
+
+  @Override
+  public @Nullable HostAndPort authority(boolean real) {
+    return stream.authority(real);
   }
 
   @Override

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

@@ -639,7 +639,7 @@ public Future<HttpServerResponse> push(HttpMethod method, HostAndPort authority,
       throw new IllegalStateException("A push response cannot promise another push");
     }
     if (authority == null) {
-      authority = stream.authority;
+      authority = stream.authority();
     }
     synchronized (conn) {
       checkValid();

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

@@ -39,7 +39,8 @@ class Http2ServerStream extends VertxHttp2Stream<Http2ServerConnection> {
   protected final HttpMethod method;
   protected final String uri;
   protected final boolean hasAuthority;
-  protected final HostAndPort authority;
+  private final HostAndPort computedAuthority;
+  private final HostAndPort realAuthority;
   private final TracingPolicy tracingPolicy;
   private Object metric;
   private Object trace;
@@ -62,7 +63,8 @@ class Http2ServerStream extends VertxHttp2Stream<Http2ServerConnection> {
     this.uri = uri;
     this.scheme = null;
     this.hasAuthority = false;
-    this.authority = null;
+    this.computedAuthority = null;
+    this.realAuthority = null;
     this.tracingPolicy = tracingPolicy;
     this.halfClosedRemote = halfClosedRemote;
   }
@@ -72,7 +74,8 @@ class Http2ServerStream extends VertxHttp2Stream<Http2ServerConnection> {
                     Http2Headers headers,
                     String scheme,
                     boolean hasAuthority,
-                    HostAndPort authority,
+                    HostAndPort realAuthority,
+                    HostAndPort computedAuthority,
                     HttpMethod method,
                     String uri,
                     TracingPolicy tracingPolicy,
@@ -82,7 +85,8 @@ class Http2ServerStream extends VertxHttp2Stream<Http2ServerConnection> {
     this.scheme = scheme;
     this.headers = headers;
     this.hasAuthority = hasAuthority;
-    this.authority = authority;
+    this.realAuthority = realAuthority;
+    this.computedAuthority = computedAuthority;
     this.uri = uri;
     this.method = method;
     this.tracingPolicy = tracingPolicy;
@@ -102,6 +106,14 @@ void registerMetrics() {
     }
   }
 
+  public HostAndPort authority() {
+    return computedAuthority;
+  }
+
+  public HostAndPort authority(boolean real) {
+    return real ? realAuthority : computedAuthority;
+  }
+
   @Override
   void onHeaders(Http2Headers headers, StreamPriority streamPriority) {
     if (streamPriority != null) {

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

@@ -365,6 +365,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);
@@ -379,26 +380,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();
   }