Fix 2xx status check, add indeterminate-length unit tests, minor cleanups

- Fix code_val/200==1 to code_val/100==2 (matched 200-399 instead of 200-299)
- Add unit tests for indeterminate-length response body:
  - h1_client_response_indeterminate_length_body (multi-chunk body)
  - h1_client_response_indeterminate_length_empty_body (empty body edge case)
  - h1_client_response_204_no_indeterminate_length (negative case)
- Fix typo: 'response lien' -> 'response line'
- Reset body_headers_ignored_on_2xx in s_reset_state() for consistency
- Fix inconsistent Server header in mock server ('echo-server' -> 'crt-local-server')

Author: TingDaoK

source/h1_decoder.c

@@ -217,6 +217,7 @@ static void s_reset_state(struct aws_h1_decoder *decoder) {
     decoder->doing_trailers = false;
     decoder->is_done = false;
     decoder->body_headers_ignored = false;
+    decoder->body_headers_ignored_on_2xx = false;
     decoder->body_headers_forbidden = false;
     decoder->content_length_received = false;
     decoder->response_body_indeterminate_length = false;
@@ -382,7 +383,7 @@ static int s_linestate_header(struct aws_h1_decoder *decoder, struct aws_byte_cu
                 !decoder->is_decoding_requests && !decoder->content_length_received &&
                 !decoder->body_headers_forbidden && !decoder->body_headers_ignored_on_2xx) {
                 /* RFC-7230 3.3.3: If a message is received without Transfer-Encoding and without Content-Length and NOT
-                 * determined by the response lien to have no body, then the message body length is determined by
+                 * determined by the response line to have no body, then the message body length is determined by
                  * reading the stream until connection closure. Note: This only applies to responses. A request without
                  * Content-Length or Transfer-Encoding has no message body (per RFC 7230 section 3.3.3). */
                 /* The failure response for CONNECT with body is undefined, and since the client will handle the CONNECT
@@ -715,7 +716,7 @@ static int s_linestate_response(struct aws_h1_decoder *decoder, struct aws_byte_
     /* RFC-7230 section 3.3 Message Body */
     decoder->body_headers_ignored |= code_val == AWS_HTTP_STATUS_CODE_304_NOT_MODIFIED;
     if (decoder->body_headers_ignored_on_2xx) {
-        decoder->body_headers_ignored |= code_val / 200 == 1;
+        decoder->body_headers_ignored |= code_val / 100 == 2;
     }
     decoder->body_headers_forbidden = code_val == AWS_HTTP_STATUS_CODE_204_NO_CONTENT || code_val / 100 == 1;
 

tests/CMakeLists.txt

@@ -157,6 +157,9 @@ add_test_case(h1_client_connection_close_before_request_finishes_with_buffer)
 add_test_case(h1_client_connection_close_before_request_finishes_with_buffer_incomplete_response)
 add_test_case(h1_client_connection_close_before_request_finishes_with_buffer_force_shutdown)
 add_test_case(h1_client_connection_close_before_request_finishes_with_buffer_stream_cancel)
+add_test_case(h1_client_response_indeterminate_length_body)
+add_test_case(h1_client_response_indeterminate_length_empty_body)
+add_test_case(h1_client_response_204_no_indeterminate_length)
 
 add_test_case(strutil_trim_http_whitespace)
 add_test_case(strutil_is_http_token)

tests/mock_server/h11mock_server.py

@@ -198,7 +198,7 @@ async def send_response(wrapper, request):
         # Build the raw HTTP response
         response_lines = [
             b"HTTP/1.1 200 OK",
-            b"Server: echo-server",
+            b"Server: crt-local-server",
             b"Content-Type: text/plain; charset=utf-8",
             b"Connection: close",
             b"",  # Empty line separates headers from body
@@ -212,7 +212,7 @@ async def send_response(wrapper, request):
         # We simulate the response flow through h11's state machine without actually sending bytes
         wrapper.info("Updating h11 state to MUST_CLOSE after raw response with Connection: close")
         headers = [
-            ("Server", "echo-server"),
+            ("Server", "crt-local-server"),
             ("Content-Type", "text/plain; charset=utf-8"),
             ("Connection", "close"),
         ]

tests/test_h1_client.c

@@ -5141,3 +5141,126 @@ H1_CLIENT_TEST_CASE(h1_client_connection_close_before_request_finishes_with_buff
     (void)ctx;
     return s_h1_client_connection_close_before_request_finishes_with_buffer_force_shutdown_helper(allocator, false);
 }
+
+/* Test: Response with no Content-Length or Transfer-Encoding has its body determined by connection closure */
+H1_CLIENT_TEST_CASE(h1_client_response_indeterminate_length_body) {
+    (void)ctx;
+    struct tester tester;
+    ASSERT_SUCCESS(s_tester_init(&tester, allocator));
+
+    /* send request */
+    struct aws_http_message *request = s_new_default_get_request(allocator);
+
+    struct client_stream_tester stream_tester;
+    ASSERT_SUCCESS(s_stream_tester_init(&stream_tester, &tester, request));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+    aws_http_message_destroy(request);
+
+    /* send response with no Content-Length or Transfer-Encoding */
+    ASSERT_SUCCESS(testing_channel_push_read_str(
+        &tester.testing_channel,
+        "HTTP/1.1 200 OK\r\n"
+        "Connection: close\r\n"
+        "\r\n"
+        "hello "));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+
+    /* stream should NOT be complete yet - waiting for connection close */
+    ASSERT_FALSE(stream_tester.complete);
+    ASSERT_UINT_EQUALS(6, stream_tester.response_body.len);
+
+    /* send more body data */
+    ASSERT_SUCCESS(testing_channel_push_read_str(&tester.testing_channel, "world"));
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+
+    ASSERT_FALSE(stream_tester.complete);
+    ASSERT_UINT_EQUALS(11, stream_tester.response_body.len);
+
+    /* close the connection - this should complete the stream */
+    aws_channel_shutdown(tester.testing_channel.channel, AWS_ERROR_SUCCESS);
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+
+    ASSERT_TRUE(stream_tester.complete);
+    ASSERT_INT_EQUALS(AWS_ERROR_SUCCESS, stream_tester.on_complete_error_code);
+    ASSERT_INT_EQUALS(200, stream_tester.response_status);
+    ASSERT_TRUE(aws_byte_buf_eq_c_str(&stream_tester.response_body, "hello world"));
+
+    /* clean up */
+    client_stream_tester_clean_up(&stream_tester);
+    ASSERT_SUCCESS(s_tester_clean_up(&tester));
+    return AWS_OP_SUCCESS;
+}
+
+/* Test: Response with no Content-Length and empty body - connection closes right after headers */
+H1_CLIENT_TEST_CASE(h1_client_response_indeterminate_length_empty_body) {
+    (void)ctx;
+    struct tester tester;
+    ASSERT_SUCCESS(s_tester_init(&tester, allocator));
+
+    struct aws_http_message *request = s_new_default_get_request(allocator);
+
+    struct client_stream_tester stream_tester;
+    ASSERT_SUCCESS(s_stream_tester_init(&stream_tester, &tester, request));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+    aws_http_message_destroy(request);
+
+    /* send response headers only, no body, no Content-Length */
+    ASSERT_SUCCESS(testing_channel_push_read_str(
+        &tester.testing_channel,
+        "HTTP/1.1 200 OK\r\n"
+        "\r\n"));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+
+    /* stream should NOT be complete yet */
+    ASSERT_FALSE(stream_tester.complete);
+
+    /* close connection */
+    aws_channel_shutdown(tester.testing_channel.channel, AWS_ERROR_SUCCESS);
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+
+    ASSERT_TRUE(stream_tester.complete);
+    ASSERT_INT_EQUALS(AWS_ERROR_SUCCESS, stream_tester.on_complete_error_code);
+    ASSERT_INT_EQUALS(200, stream_tester.response_status);
+    ASSERT_UINT_EQUALS(0, stream_tester.response_body.len);
+
+    client_stream_tester_clean_up(&stream_tester);
+    ASSERT_SUCCESS(s_tester_clean_up(&tester));
+    return AWS_OP_SUCCESS;
+}
+
+/* Test: 1xx and 204 responses must NOT enter indeterminate-length mode (body_headers_forbidden) */
+H1_CLIENT_TEST_CASE(h1_client_response_204_no_indeterminate_length) {
+    (void)ctx;
+    struct tester tester;
+    ASSERT_SUCCESS(s_tester_init(&tester, allocator));
+
+    struct aws_http_message *request = s_new_default_get_request(allocator);
+
+    struct client_stream_tester stream_tester;
+    ASSERT_SUCCESS(s_stream_tester_init(&stream_tester, &tester, request));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+    aws_http_message_destroy(request);
+
+    /* 204 with no Content-Length should complete immediately, not wait for connection close */
+    ASSERT_SUCCESS(testing_channel_push_read_str(
+        &tester.testing_channel,
+        "HTTP/1.1 204 No Content\r\n"
+        "\r\n"));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+
+    /* stream should be complete immediately - 204 has no body */
+    ASSERT_TRUE(stream_tester.complete);
+    ASSERT_INT_EQUALS(AWS_ERROR_SUCCESS, stream_tester.on_complete_error_code);
+    ASSERT_INT_EQUALS(204, stream_tester.response_status);
+    ASSERT_UINT_EQUALS(0, stream_tester.response_body.len);
+
+    client_stream_tester_clean_up(&stream_tester);
+    ASSERT_SUCCESS(s_tester_clean_up(&tester));
+    return AWS_OP_SUCCESS;
+}