Implement Early hints response status, do not poll the encoding with HTTP 1xx codes (#12918)

Motivation:

Http 1xx codes should expect another response next

Modifications:

Replace code == 100 with code == 1xx

Result:

Fixes #12904

Author: cavallium

codec-http/src/main/java/io/netty/handler/codec/http/HttpClientCodec.java

@@ -266,8 +266,10 @@ protected boolean isContentAlwaysEmpty(HttpMessage msg) {
             // request / response pairs in sync.
             HttpMethod method = queue.poll();
 
-            final int statusCode = ((HttpResponse) msg).status().code();
-            if (statusCode >= 100 && statusCode < 200) {
+            final HttpResponseStatus status = ((HttpResponse) msg).status();
+            final HttpStatusClass statusClass = status.codeClass();
+            final int statusCode = status.code();
+            if (statusClass == HttpStatusClass.INFORMATIONAL) {
                 // An informational response should be excluded from paired comparison.
                 // Just delegate to super method which has all the needed handling.
                 return super.isContentAlwaysEmpty(msg);

codec-http/src/main/java/io/netty/handler/codec/http/HttpContentEncoder.java

@@ -63,7 +63,6 @@ private enum State {
 
     private static final CharSequence ZERO_LENGTH_HEAD = "HEAD";
     private static final CharSequence ZERO_LENGTH_CONNECT = "CONNECT";
-    private static final int CONTINUE_CODE = HttpResponseStatus.CONTINUE.code();
 
     private final Queue<CharSequence> acceptEncodingQueue = new ArrayDeque<CharSequence>();
     private EmbeddedChannel encoder;
@@ -112,10 +111,12 @@ protected void encode(ChannelHandlerContext ctx, HttpObject msg, List<Object> ou
 
                 final HttpResponse res = (HttpResponse) msg;
                 final int code = res.status().code();
+                final HttpStatusClass codeClass = res.status().codeClass();
                 final CharSequence acceptEncoding;
-                if (code == CONTINUE_CODE) {
-                    // We need to not poll the encoding when response with CONTINUE as another response will follow
-                    // for the issued request. See https://github.com/netty/netty/issues/4079
+                if (codeClass == HttpStatusClass.INFORMATIONAL) {
+                    // We need to not poll the encoding when response with 1xx codes as another response will follow
+                    // for the issued request.
+                    // See https://github.com/netty/netty/issues/12904 and https://github.com/netty/netty/issues/4079
                     acceptEncoding = null;
                 } else {
                     // Get the list of encodings accepted by the peer.

codec-http/src/main/java/io/netty/handler/codec/http/HttpObjectDecoder.java

@@ -522,14 +522,16 @@ public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exc
     protected boolean isContentAlwaysEmpty(HttpMessage msg) {
         if (msg instanceof HttpResponse) {
             HttpResponse res = (HttpResponse) msg;
-            int code = res.status().code();
+            final HttpResponseStatus status = res.status();
+            final int code = status.code();
+            final HttpStatusClass statusClass = status.codeClass();
 
             // Correctly handle return codes of 1xx.
             //
             // See:
             //     - https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html Section 4.4
             //     - https://github.com/netty/netty/issues/222
-            if (code >= 100 && code < 200) {
+            if (statusClass == HttpStatusClass.INFORMATIONAL) {
                 // One exception: Hixie 76 websocket handshake response
                 return !(code == 101 && !res.headers().contains(HttpHeaderNames.SEC_WEBSOCKET_ACCEPT)
                          && res.headers().contains(HttpHeaderNames.UPGRADE, HttpHeaderValues.WEBSOCKET, true));

codec-http/src/main/java/io/netty/handler/codec/http/HttpResponseStatus.java

@@ -48,6 +48,11 @@ public class HttpResponseStatus implements Comparable<HttpResponseStatus> {
      */
     public static final HttpResponseStatus PROCESSING = newStatus(102, "Processing");
 
+    /**
+     * 103 Early Hints (RFC 8297)
+     */
+    public static final HttpResponseStatus EARLY_HINTS = newStatus(103, "Early Hints");
+
     /**
      * 200 OK
      */
@@ -344,6 +349,8 @@ private static HttpResponseStatus valueOf0(int code) {
             return SWITCHING_PROTOCOLS;
         case 102:
             return PROCESSING;
+        case 103:
+            return EARLY_HINTS;
         case 200:
             return OK;
         case 201:

codec-http/src/test/java/io/netty/handler/codec/http/HttpContentCompressorTest.java

@@ -603,6 +603,96 @@ public void test100Continue() throws Exception {
         assertThat(ch.readOutbound(), is(nullValue()));
     }
 
+    @Test
+    public void testMultiple1xxInformationalResponse() throws Exception {
+        FullHttpRequest request = newRequest();
+        HttpUtil.set100ContinueExpected(request, true);
+
+        EmbeddedChannel ch = new EmbeddedChannel(new HttpContentCompressor());
+        ch.writeInbound(request);
+
+        FullHttpResponse continueResponse = new DefaultFullHttpResponse(
+            HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE, Unpooled.EMPTY_BUFFER);
+        ch.writeOutbound(continueResponse);
+
+        FullHttpResponse earlyHintsResponse = new DefaultFullHttpResponse(
+            HttpVersion.HTTP_1_1, HttpResponseStatus.EARLY_HINTS, Unpooled.EMPTY_BUFFER);
+        earlyHintsResponse.trailingHeaders().set(of("X-Test"), of("Netty"));
+        ch.writeOutbound(earlyHintsResponse);
+
+        FullHttpResponse res = new DefaultFullHttpResponse(
+            HttpVersion.HTTP_1_1, HttpResponseStatus.OK, Unpooled.EMPTY_BUFFER);
+        res.trailingHeaders().set(of("X-Test"), of("Netty"));
+        ch.writeOutbound(res);
+
+        Object o = ch.readOutbound();
+        assertThat(o, is(instanceOf(FullHttpResponse.class)));
+
+        res = (FullHttpResponse) o;
+        assertSame(continueResponse, res);
+        res.release();
+
+        o = ch.readOutbound();
+        assertThat(o, is(instanceOf(FullHttpResponse.class)));
+
+        res = (FullHttpResponse) o;
+        assertSame(earlyHintsResponse, res);
+        res.release();
+
+        o = ch.readOutbound();
+        assertThat(o, is(instanceOf(FullHttpResponse.class)));
+
+        res = (FullHttpResponse) o;
+        assertThat(res.headers().get(HttpHeaderNames.TRANSFER_ENCODING), is(nullValue()));
+
+        // Content encoding shouldn't be modified.
+        assertThat(res.headers().get(HttpHeaderNames.CONTENT_ENCODING), is(nullValue()));
+        assertThat(res.content().readableBytes(), is(0));
+        assertThat(res.content().toString(CharsetUtil.US_ASCII), is(""));
+        assertEquals("Netty", res.trailingHeaders().get(of("X-Test")));
+        assertEquals(DecoderResult.SUCCESS, res.decoderResult());
+        assertThat(ch.readOutbound(), is(nullValue()));
+    }
+
+    @Test
+    public void test103EarlyHintsResponse() throws Exception {
+        FullHttpRequest request = newRequest();
+
+        EmbeddedChannel ch = new EmbeddedChannel(new HttpContentCompressor());
+        ch.writeInbound(request);
+
+        FullHttpResponse earlyHintsResponse = new DefaultFullHttpResponse(
+            HttpVersion.HTTP_1_1, HttpResponseStatus.EARLY_HINTS, Unpooled.EMPTY_BUFFER);
+        earlyHintsResponse.trailingHeaders().set(of("X-Test"), of("Netty"));
+        ch.writeOutbound(earlyHintsResponse);
+
+        FullHttpResponse res = new DefaultFullHttpResponse(
+            HttpVersion.HTTP_1_1, HttpResponseStatus.OK, Unpooled.EMPTY_BUFFER);
+        res.trailingHeaders().set(of("X-Test"), of("Netty"));
+        ch.writeOutbound(res);
+
+        Object o = ch.readOutbound();
+        assertThat(o, is(instanceOf(FullHttpResponse.class)));
+
+        res = (FullHttpResponse) o;
+        assertSame(earlyHintsResponse, res);
+        res.release();
+
+        o = ch.readOutbound();
+        assertThat(o, is(instanceOf(FullHttpResponse.class)));
+
+        res = (FullHttpResponse) o;
+        assertThat(res.headers().get(HttpHeaderNames.TRANSFER_ENCODING), is(nullValue()));
+
+        // Content encoding shouldn't be modified.
+        assertThat(res.headers().get(HttpHeaderNames.CONTENT_ENCODING), is(nullValue()));
+        assertThat(res.content().readableBytes(), is(0));
+        assertThat(res.content().toString(CharsetUtil.US_ASCII), is(""));
+        assertEquals("Netty", res.trailingHeaders().get(of("X-Test")));
+        assertEquals(DecoderResult.SUCCESS, res.decoderResult());
+        assertThat(ch.readOutbound(), is(nullValue()));
+    }
+
     @Test
     public void testTooManyResponses() throws Exception {
         FullHttpRequest request = newRequest();

codec-http2/src/main/java/io/netty/handler/codec/http2/Http2StreamFrameToHttpObjectCodec.java

@@ -37,6 +37,7 @@
 import io.netty.handler.codec.http.HttpResponse;
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.HttpScheme;
+import io.netty.handler.codec.http.HttpStatusClass;
 import io.netty.handler.codec.http.HttpUtil;
 import io.netty.handler.codec.http.HttpVersion;
 import io.netty.handler.codec.http.LastHttpContent;
@@ -91,9 +92,9 @@ protected void decode(ChannelHandlerContext ctx, Http2StreamFrame frame, List<Ob
 
             final CharSequence status = headers.status();
 
-            // 100-continue response is a special case where Http2HeadersFrame#isEndStream=false
+            // 1xx response (excluding 101) is a special case where Http2HeadersFrame#isEndStream=false
             // but we need to decode it as a FullHttpResponse to play nice with HttpObjectAggregator.
-            if (null != status && HttpResponseStatus.CONTINUE.codeAsText().contentEquals(status)) {
+            if (null != status && isInformationalResponseHeaderFrame(status)) {
                 final FullHttpMessage fullMsg = newFullMessage(id, headers, ctx.alloc());
                 out.add(fullMsg);
                 return;
@@ -151,18 +152,22 @@ private void encodeLastContent(LastHttpContent last, List<Object> out) {
      */
     @Override
     protected void encode(ChannelHandlerContext ctx, HttpObject obj, List<Object> out) throws Exception {
-        // 100-continue is typically a FullHttpResponse, but the decoded
+        // 1xx (excluding 101) is typically a FullHttpResponse, but the decoded
         // Http2HeadersFrame should not be marked as endStream=true
         if (obj instanceof HttpResponse) {
             final HttpResponse res = (HttpResponse) obj;
-            if (res.status().equals(HttpResponseStatus.CONTINUE)) {
+            final HttpResponseStatus status = res.status();
+            final int code = status.code();
+            final HttpStatusClass statusClass = status.codeClass();
+            // An informational response using a 1xx status code other than 101 is
+            // transmitted as a HEADERS frame
+            if (statusClass == HttpStatusClass.INFORMATIONAL && code != 101) {
                 if (res instanceof FullHttpResponse) {
                     final Http2Headers headers = toHttp2Headers(ctx, res);
                     out.add(new DefaultHttp2HeadersFrame(headers, false));
                     return;
                 } else {
-                    throw new EncoderException(
-                            HttpResponseStatus.CONTINUE + " must be a FullHttpResponse");
+                    throw new EncoderException(status + " must be a FullHttpResponse");
                 }
             }
         }
@@ -247,4 +252,20 @@ private static Channel connectionChannel(ChannelHandlerContext ctx) {
         final Channel ch = ctx.channel();
         return ch instanceof Http2StreamChannel ? ch.parent() : ch;
     }
+
+    /**
+     *    An informational response using a 1xx status code other than 101 is
+     *    transmitted as a HEADERS frame
+     */
+    private static boolean isInformationalResponseHeaderFrame(CharSequence status) {
+        if (status.length() == 3) {
+            char char0 = status.charAt(0);
+            char char1 = status.charAt(1);
+            char char2 = status.charAt(2);
+            return char0 == '1'
+                && char1 >= '0' && char1 <= '9'
+                && char2 >= '0' && char2 <= '9' && char2 != '1';
+        }
+        return false;
+    }
 }

codec-http2/src/test/java/io/netty/handler/codec/http2/Http2StreamFrameToHttpObjectCodecTest.java

@@ -708,6 +708,38 @@ public void decode100ContinueHttp2HeadersAsFullHttpResponse() throws Exception {
         assertFalse(ch.finish());
     }
 
+    /**
+     *    An informational response using a 1xx status code other than 101 is
+     *    transmitted as a HEADERS frame, followed by zero or more CONTINUATION
+     *    frames.
+     *    Trailing header fields are sent as a header block after both the
+     *    request or response header block and all the DATA frames have been
+     *    sent.  The HEADERS frame starting the trailers header block has the
+     *    END_STREAM flag set.
+     */
+    @Test
+    public void decode103EarlyHintsHttp2HeadersAsFullHttpResponse() throws Exception {
+        EmbeddedChannel ch = new EmbeddedChannel(new Http2StreamFrameToHttpObjectCodec(false));
+        Http2Headers headers = new DefaultHttp2Headers();
+        headers.scheme(HttpScheme.HTTP.name());
+        headers.status(HttpResponseStatus.EARLY_HINTS.codeAsText());
+        headers.set("key", "value");
+
+        assertTrue(ch.writeInbound(new DefaultHttp2HeadersFrame(headers, false)));
+
+        final FullHttpResponse response = ch.readInbound();
+        try {
+            assertThat(response.status(), is(HttpResponseStatus.EARLY_HINTS));
+            assertThat(response.protocolVersion(), is(HttpVersion.HTTP_1_1));
+            assertThat(response.headers().get("key"), is("value"));
+        } finally {
+            response.release();
+        }
+
+        assertThat(ch.readInbound(), is(nullValue()));
+        assertFalse(ch.finish());
+    }
+
     @Test
     public void testDecodeResponseHeaders() throws Exception {
         EmbeddedChannel ch = new EmbeddedChannel(new Http2StreamFrameToHttpObjectCodec(false));