aws-crt 0.1.5 → 0.1.6

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/private/http2_stream_manager_impl.h

@@ -25,12 +25,23 @@ enum aws_h2_sm_connection_state_type {
 /* Live with the streams opening, and if there no outstanding pending acquisition and no opening streams on the
  * connection, this structure should die */
 struct aws_h2_sm_connection {
+    struct aws_allocator *allocator;
     struct aws_http2_stream_manager *stream_manager;
     struct aws_http_connection *connection;
     uint32_t num_streams_assigned;   /* From a stream assigned to the connection until the stream completed
                                                      or failed to be created from the connection. */
     uint32_t max_concurrent_streams; /* lower bound between user configured and the other side */
 
+    /* task to send ping periodically from connection thread. */
+    struct aws_ref_count ref_count;
+    struct aws_channel_task ping_task;
+    struct aws_channel_task ping_timeout_task;
+    struct {
+        bool ping_received;
+        bool stopped_new_requests;
+        uint64_t next_ping_task_time;
+    } thread_data;
+
     enum aws_h2_sm_connection_state_type state;
 };
 
@@ -82,7 +93,13 @@ struct aws_http2_stream_manager {
     struct aws_ref_count internal_ref_count;
     struct aws_client_bootstrap *bootstrap;
 
+    /* Configurations */
     size_t max_connections;
+    /* Connection will be closed if 5xx response received from server. */
+    bool close_connection_on_server_error;
+
+    uint64_t connection_ping_period_ns;
+    uint64_t connection_ping_timeout_ns;
 
     /**
      * Default is no limit. 0 will be considered as using the default value.

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/private/http_impl.h

@@ -64,6 +64,9 @@ enum aws_http_header_name {
     AWS_HTTP_HEADER_RETRY_AFTER,
     AWS_HTTP_HEADER_VARY,
     AWS_HTTP_HEADER_WARNING,
+    AWS_HTTP_HEADER_UPGRADE,
+    AWS_HTTP_HEADER_KEEP_ALIVE,
+    AWS_HTTP_HEADER_PROXY_CONNECTION,
 
     AWS_HTTP_HEADER_COUNT, /* Number of enums */
 };

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/private/random_access_set.h

@@ -64,16 +64,23 @@ int aws_random_access_set_remove(struct aws_random_access_set *set, const void *
  * Get the pointer to a random element from the data structure. Fails when the data structure is empty.
  */
 AWS_HTTP_API
-int aws_random_access_set_random_get_ptr(struct aws_random_access_set *set, void **out);
+int aws_random_access_set_random_get_ptr(const struct aws_random_access_set *set, void **out);
 
 AWS_HTTP_API
-size_t aws_random_access_set_get_size(struct aws_random_access_set *set);
+size_t aws_random_access_set_get_size(const struct aws_random_access_set *set);
 
 /**
  * Check the element exist in the data structure or not.
  */
 AWS_HTTP_API
-int aws_random_access_set_exist(struct aws_random_access_set *set, const void *element, bool *exist);
+int aws_random_access_set_exist(const struct aws_random_access_set *set, const void *element, bool *exist);
+
+/**
+ * Get the pointer to an element that currently stored at that index. It may change if operations like remove and add
+ * happens. Helpful for debugging and iterating through the whole set.
+ */
+AWS_HTTP_API
+int aws_random_access_set_random_get_ptr_index(const struct aws_random_access_set *set, void **out, size_t index);
 
 AWS_EXTERN_C_END
 #endif /* AWS_HTTP_RANDOM_ACCESS_SET_H */

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/private/request_response_impl.h

@@ -23,6 +23,9 @@ struct aws_http_stream_vtable {
     int (*http2_reset_stream)(struct aws_http_stream *http2_stream, uint32_t http2_error);
     int (*http2_get_received_error_code)(struct aws_http_stream *http2_stream, uint32_t *http2_error);
     int (*http2_get_sent_error_code)(struct aws_http_stream *http2_stream, uint32_t *http2_error);
+    int (*http2_write_data)(
+        struct aws_http_stream *http2_stream,
+        const struct aws_http2_stream_write_data_options *options);
 };
 
 /**
@@ -62,21 +65,4 @@ struct aws_http_stream {
     struct aws_http_stream_server_data *server_data;
 };
 
-AWS_EXTERN_C_BEGIN
-
-/**
- * Create an HTTP/2 message from HTTP/1.1 message.
- * pseudo headers will be created from the context and added to the headers of new message.
- * Normal headers will be copied to the headers of new message.
- * Note: `host` will stay and `:authority` will not be set. (RFC-7540 8.1.2.3). Some sever don't support it.
- * TODO: (Maybe more, connection-specific header will be removed, etc...)
- * TODO: REFCOUNT INPUT_STREAMS!!! And make it public.
- */
-AWS_HTTP_API
-struct aws_http_message *aws_http2_message_new_from_http1(
-    struct aws_http_message *http1_msg,
-    struct aws_allocator *alloc);
-
-AWS_EXTERN_C_END
-
 #endif /* AWS_HTTP_REQUEST_RESPONSE_IMPL_H */

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/request_response.h

@@ -233,6 +233,12 @@ struct aws_http_make_request_options {
      * See `aws_http_on_stream_complete_fn`.
      */
     aws_http_on_stream_complete_fn *on_complete;
+
+    /**
+     * When using HTTP/2, request body data will be provided over time. The stream will only be polled for writing
+     * when data has been supplied via `aws_http2_stream_write_data`
+     */
+    bool http2_use_manual_data_writes;
 };
 
 struct aws_http_request_handler_options {
@@ -286,6 +292,21 @@ struct aws_http_request_handler_options {
     aws_http_on_stream_complete_fn *on_complete;
 };
 
+/**
+ * Invoked when the data stream of an outgoing HTTP write operation is no longer in use.
+ * This is always invoked on the HTTP connection's event-loop thread.
+ *
+ * @param stream        HTTP-stream this write operation was submitted to.
+ * @param error_code    If error_code is AWS_ERROR_SUCCESS (0), the data was successfully sent.
+ *                      Any other error_code indicates that the HTTP-stream is in the process of terminating.
+ *                      If the error_code is AWS_ERROR_HTTP_STREAM_HAS_COMPLETED,
+ *                      the stream's termination has nothing to do with this write operation.
+ *                      Any other non-zero error code indicates a problem with this particular write
+ *                      operation's data.
+ * @param user_data     User data for this write operation.
+ */
+typedef void aws_http_stream_write_complete_fn(struct aws_http_stream *stream, int error_code, void *user_data);
+
 /**
  * Invoked when the data of an outgoing HTTP/1.1 chunk is no longer in use.
  * This is always invoked on the HTTP connection's event-loop thread.
@@ -298,7 +319,7 @@ struct aws_http_request_handler_options {
  *                      Any other non-zero error code indicates a problem with this particular chunk's data.
  * @param user_data     User data for this chunk.
  */
-typedef void aws_http1_stream_write_chunk_complete_fn(struct aws_http_stream *stream, int error_code, void *user_data);
+typedef aws_http_stream_write_complete_fn aws_http1_stream_write_chunk_complete_fn;
 
 /**
  * HTTP/1.1 chunk extension for chunked encoding.
@@ -356,6 +377,50 @@ struct aws_http1_chunk_options {
     void *user_data;
 };
 
+/**
+ * Invoked when the data of an outgoing HTTP2 data frame is no longer in use.
+ * This is always invoked on the HTTP connection's event-loop thread.
+ *
+ * @param stream        HTTP2-stream this write was submitted to.
+ * @param error_code    If error_code is AWS_ERROR_SUCCESS (0), the data was successfully sent.
+ *                      Any other error_code indicates that the HTTP-stream is in the process of terminating.
+ *                      If the error_code is AWS_ERROR_HTTP_STREAM_HAS_COMPLETED,
+ *                      the stream's termination has nothing to do with this write.
+ *                      Any other non-zero error code indicates a problem with this particular write's data.
+ * @param user_data     User data for this write.
+ */
+typedef aws_http_stream_write_complete_fn aws_http2_stream_write_data_complete_fn;
+
+/**
+ * Encoding options for manual H2 data frame writes
+ */
+struct aws_http2_stream_write_data_options {
+    /**
+     * The data to be sent.
+     * Optional.
+     * If not set, input stream with length 0 will be used.
+     */
+    struct aws_input_stream *data;
+
+    /**
+     * Set true when it's the last chunk to be sent.
+     * After a write with end_stream, no more data write will be accepted.
+     */
+    bool end_stream;
+
+    /**
+     * Invoked when the data stream is no longer in use, whether or not it was successfully sent.
+     * Optional.
+     * See `aws_http2_stream_write_data_complete_fn`.
+     */
+    aws_http2_stream_write_data_complete_fn *on_complete;
+
+    /**
+     * User provided data passed to the on_complete callback on its invocation.
+     */
+    void *user_data;
+};
+
 #define AWS_HTTP_REQUEST_HANDLER_OPTIONS_INIT                                                                          \
     { .self_size = sizeof(struct aws_http_request_handler_options), }
 
@@ -612,6 +677,18 @@ struct aws_http_message *aws_http2_message_new_request(struct aws_allocator *all
 AWS_HTTP_API
 struct aws_http_message *aws_http2_message_new_response(struct aws_allocator *allocator);
 
+/**
+ * Create an HTTP/2 message from HTTP/1.1 message.
+ * pseudo headers will be created from the context and added to the headers of new message.
+ * Normal headers will be copied to the headers of new message.
+ * Note: if `host` exist, it will stay and `:authority` will be added using the information.
+ * `:scheme` is default to be "https". If a different scheme wants to be used, create the HTTP/2 message directly
+ */
+AWS_HTTP_API
+struct aws_http_message *aws_http2_message_new_from_http1(
+    struct aws_allocator *alloc,
+    const struct aws_http_message *http1_msg);
+
 /**
  * Acquire a hold on the object, preventing it from being deleted until
  * aws_http_message_release() is called by all those with a hold on it.
@@ -728,9 +805,37 @@ AWS_HTTP_API int aws_http1_stream_write_chunk(
     struct aws_http_stream *http1_stream,
     const struct aws_http1_chunk_options *options);
 
+/**
+ * The stream must have specified `http2_use_manual_data_writes` during request creation.
+ * For client streams, activate() must be called before any frames are submitted.
+ * For server streams, the response headers must be submitted before any frames.
+ * A write with options that has end_stream set to be true will end the stream and prevent any further write.
+ *
+ * @return AWS_OP_SUCCESS if the write was queued
+ *         AWS_OP_ERROR indicating the attempt raised an error code.
+ *              AWS_ERROR_INVALID_STATE will be raised for invalid usage.
+ *              AWS_ERROR_HTTP_STREAM_HAS_COMPLETED will be raised if the stream ended for reasons behind the scenes.
+ *
+ * Typical usage will be something like:
+ * options.http2_use_manual_data_writes = true;
+ * stream = aws_http_connection_make_request(connection, &options);
+ * aws_http_stream_activate(stream);
+ * ...
+ * struct aws_http2_stream_write_data_options write;
+ * aws_http2_stream_write_data(stream, &write);
+ * ...
+ * struct aws_http2_stream_write_data_options last_write;
+ * last_write.end_stream = true;
+ * aws_http2_stream_write_data(stream, &write);
+ * ...
+ * aws_http_stream_release(stream);
+ */
+AWS_HTTP_API int aws_http2_stream_write_data(
+    struct aws_http_stream *http2_stream,
+    const struct aws_http2_stream_write_data_options *options);
+
 /**
  * Add a list of headers to be added as trailing headers sent after the last chunk is sent.
- * The stream must have specified "chunked" in a "transfer-encoding" header. The stream should also have
  * a "Trailer" header field which indicates the fields present in the trailer.
  *
  * Certain headers are forbidden in the trailer (e.g., Transfer-Encoding, Content-Length, Host). See RFC-7541
@@ -750,13 +855,12 @@ AWS_HTTP_API int aws_http1_stream_add_chunked_trailer(
     const struct aws_http_headers *trailing_headers);
 
 /**
- * Get the message's aws_http_headers.
  *
  * This datastructure has more functions for inspecting and modifying headers than
  * are available on the aws_http_message datastructure.
  */
 AWS_HTTP_API
-struct aws_http_headers *aws_http_message_get_headers(struct aws_http_message *message);
+struct aws_http_headers *aws_http_message_get_headers(const struct aws_http_message *message);
 
 /**
  * Get the message's const aws_http_headers.

data/aws-crt-ffi/crt/aws-c-http/include/aws/http/statistics.h

@@ -12,6 +12,7 @@
 
 enum aws_crt_http_statistics_category {
     AWSCRT_STAT_CAT_HTTP1_CHANNEL = AWS_CRT_STATISTICS_CATEGORY_BEGIN_RANGE(AWS_C_HTTP_PACKAGE_ID),
+    AWSCRT_STAT_CAT_HTTP2_CHANNEL,
 };
 
 /**
@@ -28,6 +29,16 @@ struct aws_crt_statistics_http1_channel {
     uint32_t current_incoming_stream_id;
 };
 
+struct aws_crt_statistics_http2_channel {
+    aws_crt_statistics_category_t category;
+
+    uint64_t pending_outgoing_stream_ms;
+    uint64_t pending_incoming_stream_ms;
+
+    /* True if during the time of report, there has ever been no active streams on the connection */
+    bool was_inactive;
+};
+
 AWS_EXTERN_C_BEGIN
 
 /**
@@ -48,6 +59,17 @@ void aws_crt_statistics_http1_channel_cleanup(struct aws_crt_statistics_http1_ch
 AWS_HTTP_API
 void aws_crt_statistics_http1_channel_reset(struct aws_crt_statistics_http1_channel *stats);
 
+/**
+ * Initializes a HTTP/2 channel handler statistics struct
+ */
+AWS_HTTP_API
+void aws_crt_statistics_http2_channel_init(struct aws_crt_statistics_http2_channel *stats);
+/**
+ * Resets a HTTP/2 channel handler statistics struct's statistics
+ */
+AWS_HTTP_API
+void aws_crt_statistics_http2_channel_reset(struct aws_crt_statistics_http2_channel *stats);
+
 AWS_EXTERN_C_END
 
 #endif /* AWS_HTTP_STATISTICS_H */

data/aws-crt-ffi/crt/aws-c-http/source/connection.c

@@ -174,6 +174,7 @@ struct aws_http_connection *aws_http_connection_new_channel_handler(
         }
     } else {
         if (prior_knowledge_http2) {
+            AWS_LOGF_TRACE(AWS_LS_HTTP_CONNECTION, "Using prior knowledge to start HTTP/2 connection");
             version = AWS_HTTP_VERSION_2;
         }
     }
@@ -253,6 +254,11 @@ void aws_http_connection_close(struct aws_http_connection *connection) {
     connection->vtable->close(connection);
 }
 
+void aws_http_connection_stop_new_requests(struct aws_http_connection *connection) {
+    AWS_ASSERT(connection);
+    connection->vtable->stop_new_requests(connection);
+}
+
 bool aws_http_connection_is_open(const struct aws_http_connection *connection) {
     AWS_ASSERT(connection);
     return connection->vtable->is_open(connection);
@@ -295,7 +301,7 @@ int aws_http2_connection_ping(
     return http2_connection->vtable->send_ping(http2_connection, optional_opaque_data, on_ack, user_data);
 }
 
-int aws_http2_connection_send_goaway(
+void aws_http2_connection_send_goaway(
     struct aws_http_connection *http2_connection,
     uint32_t http2_error,
     bool allow_more_streams,
@@ -303,8 +309,7 @@ int aws_http2_connection_send_goaway(
     AWS_ASSERT(http2_connection);
     AWS_PRECONDITION(http2_connection->vtable);
     AWS_FATAL_ASSERT(http2_connection->http_version == AWS_HTTP_VERSION_2);
-    return http2_connection->vtable->send_goaway(
-        http2_connection, http2_error, allow_more_streams, optional_debug_data);
+    http2_connection->vtable->send_goaway(http2_connection, http2_error, allow_more_streams, optional_debug_data);
 }
 
 int aws_http2_connection_get_sent_goaway(

data/aws-crt-ffi/crt/aws-c-http/source/connection_manager.c

@@ -240,7 +240,7 @@ struct aws_http_connection_manager {
     /*
      * HTTP/2 specific.
      */
-    bool prior_knowledge_http2;
+    bool http2_prior_knowledge;
     struct aws_array_list *initial_settings;
     size_t max_closed_streams;
     bool http2_conn_manual_window_management;
@@ -812,6 +812,13 @@ struct aws_http_connection_manager *aws_http_connection_manager_new(
         return NULL;
     }
 
+    if (options->tls_connection_options && options->http2_prior_knowledge) {
+        AWS_LOGF_ERROR(
+            AWS_LS_HTTP_CONNECTION_MANAGER, "Invalid options - HTTP/2 prior knowledge cannot be set when TLS is used");
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        return NULL;
+    }
+
     struct aws_http_connection_manager *manager =
         aws_mem_calloc(allocator, 1, sizeof(struct aws_http_connection_manager));
     if (manager == NULL) {
@@ -876,7 +883,7 @@ struct aws_http_connection_manager *aws_http_connection_manager_new(
         }
         manager->proxy_ev_settings.tls_options = manager->proxy_ev_tls_options;
     }
-    manager->prior_knowledge_http2 = options->prior_knowledge_http2;
+    manager->http2_prior_knowledge = options->http2_prior_knowledge;
     if (options->num_initial_settings > 0) {
         manager->initial_settings = aws_mem_calloc(allocator, 1, sizeof(struct aws_array_list));
         aws_array_list_init_dynamic(
@@ -988,7 +995,7 @@ static int s_aws_http_connection_manager_new_connection(struct aws_http_connecti
     options.on_shutdown = s_aws_http_connection_manager_on_connection_shutdown;
     options.manual_window_management = manager->enable_read_back_pressure;
     options.proxy_ev_settings = &manager->proxy_ev_settings;
-    options.prior_knowledge_http2 = manager->prior_knowledge_http2;
+    options.prior_knowledge_http2 = manager->http2_prior_knowledge;
 
     struct aws_http2_connection_options h2_options;
     AWS_ZERO_STRUCT(h2_options);
@@ -1538,3 +1545,15 @@ static void s_cull_task(struct aws_task *task, void *arg, enum aws_task_status s
 
     s_schedule_connection_culling(manager);
 }
+
+void aws_http_connection_manager_fetch_metrics(
+    const struct aws_http_connection_manager *manager,
+    struct aws_http_manager_metrics *out_metrics) {
+    AWS_PRECONDITION(manager);
+    AWS_PRECONDITION(out_metrics);
+
+    AWS_FATAL_ASSERT(aws_mutex_lock((struct aws_mutex *)(void *)&manager->lock) == AWS_OP_SUCCESS);
+    out_metrics->available_concurrency = manager->idle_connection_count;
+    out_metrics->pending_concurrency_acquires = manager->pending_acquisition_count;
+    AWS_FATAL_ASSERT(aws_mutex_unlock((struct aws_mutex *)(void *)&manager->lock) == AWS_OP_SUCCESS);
+}

data/aws-crt-ffi/crt/aws-c-http/source/connection_monitor.c

@@ -32,13 +32,16 @@ static void s_process_statistics(
     uint64_t pending_write_interval_ms = 0;
     uint64_t bytes_read = 0;
     uint64_t bytes_written = 0;
-    uint32_t current_outgoing_stream_id = 0;
-    uint32_t current_incoming_stream_id = 0;
+    uint32_t h1_current_outgoing_stream_id = 0;
+    uint32_t h1_current_incoming_stream_id = 0;
 
     /*
      * Pull out the data needed to perform the throughput calculation
      */
     size_t stats_count = aws_array_list_length(stats_list);
+    bool h2 = false;
+    bool h2_was_inactive = false;
+
     for (size_t i = 0; i < stats_count; ++i) {
         struct aws_crt_statistics_base *stats_base = NULL;
         if (aws_array_list_get_at(stats_list, &stats_base, i)) {
@@ -54,13 +57,24 @@ static void s_process_statistics(
             }
 
             case AWSCRT_STAT_CAT_HTTP1_CHANNEL: {
+                AWS_ASSERT(!h2);
                 struct aws_crt_statistics_http1_channel *http1_stats =
                     (struct aws_crt_statistics_http1_channel *)stats_base;
                 pending_read_interval_ms = http1_stats->pending_incoming_stream_ms;
                 pending_write_interval_ms = http1_stats->pending_outgoing_stream_ms;
-                current_outgoing_stream_id = http1_stats->current_outgoing_stream_id;
-                current_incoming_stream_id = http1_stats->current_incoming_stream_id;
+                h1_current_outgoing_stream_id = http1_stats->current_outgoing_stream_id;
+                h1_current_incoming_stream_id = http1_stats->current_incoming_stream_id;
+
+                break;
+            }
 
+            case AWSCRT_STAT_CAT_HTTP2_CHANNEL: {
+                struct aws_crt_statistics_http2_channel *h2_stats =
+                    (struct aws_crt_statistics_http2_channel *)stats_base;
+                pending_read_interval_ms = h2_stats->pending_incoming_stream_ms;
+                pending_write_interval_ms = h2_stats->pending_outgoing_stream_ms;
+                h2_was_inactive |= h2_stats->was_inactive;
+                h2 = true;
                 break;
             }
 
@@ -110,17 +124,21 @@ static void s_process_statistics(
         bytes_per_second);
 
     /*
-     * Check throughput only if at least one stream exists and was observed in that role previously
-     *
-     * ToDo: This logic only makes sense from an h1 perspective.  A similar requirement could be placed on
-     * h2 stats by analyzing/tracking the min and max stream ids (per odd/even) at process timepoints.
+     * Check throughput only if the connection has active stream and no gap between.
      */
-    bool check_throughput =
-        (current_incoming_stream_id != 0 && current_incoming_stream_id == impl->last_incoming_stream_id) ||
-        (current_outgoing_stream_id != 0 && current_outgoing_stream_id == impl->last_outgoing_stream_id);
-
-    impl->last_outgoing_stream_id = current_outgoing_stream_id;
-    impl->last_incoming_stream_id = current_incoming_stream_id;
+    bool check_throughput = false;
+    if (h2) {
+        /* For HTTP/2, check throughput only if there always has any active stream on the connection */
+        check_throughput = !h2_was_inactive;
+    } else {
+        /* For HTTP/1, check throughput only if at least one stream exists and was observed in that role previously */
+        check_throughput =
+            (h1_current_incoming_stream_id != 0 && h1_current_incoming_stream_id == impl->last_incoming_stream_id) ||
+            (h1_current_outgoing_stream_id != 0 && h1_current_outgoing_stream_id == impl->last_outgoing_stream_id);
+
+        impl->last_outgoing_stream_id = h1_current_outgoing_stream_id;
+        impl->last_incoming_stream_id = h1_current_incoming_stream_id;
+    }
     impl->last_measured_throughput = bytes_per_second;
 
     if (!check_throughput) {

data/aws-crt-ffi/crt/aws-c-http/source/h1_connection.c

@@ -56,6 +56,7 @@ static struct aws_http_stream *s_new_server_request_handler_stream(
     const struct aws_http_request_handler_options *options);
 static int s_stream_send_response(struct aws_http_stream *stream, struct aws_http_message *response);
 static void s_connection_close(struct aws_http_connection *connection_base);
+static void s_connection_stop_new_request(struct aws_http_connection *connection_base);
 static bool s_connection_is_open(const struct aws_http_connection *connection_base);
 static bool s_connection_new_requests_allowed(const struct aws_http_connection *connection_base);
 static int s_decoder_on_request(
@@ -90,6 +91,7 @@ static struct aws_http_connection_vtable s_h1_connection_vtable = {
     .new_server_request_handler_stream = s_new_server_request_handler_stream,
     .stream_send_response = s_stream_send_response,
     .close = s_connection_close,
+    .stop_new_requests = s_connection_stop_new_request,
     .is_open = s_connection_is_open,
     .new_requests_allowed = s_connection_new_requests_allowed,
     .change_settings = NULL,
@@ -196,6 +198,18 @@ static void s_connection_close(struct aws_http_connection *connection_base) {
     s_stop(connection, false /*stop_reading*/, false /*stop_writing*/, true /*schedule_shutdown*/, AWS_ERROR_SUCCESS);
 }
 
+static void s_connection_stop_new_request(struct aws_http_connection *connection_base) {
+    struct aws_h1_connection *connection = AWS_CONTAINER_OF(connection_base, struct aws_h1_connection, base);
+
+    { /* BEGIN CRITICAL SECTION */
+        aws_h1_connection_lock_synced_data(connection);
+        if (!connection->synced_data.new_stream_error_code) {
+            connection->synced_data.new_stream_error_code = AWS_ERROR_HTTP_CONNECTION_CLOSED;
+        }
+        aws_h1_connection_unlock_synced_data(connection);
+    } /* END CRITICAL SECTION */
+}
+
 static bool s_connection_is_open(const struct aws_http_connection *connection_base) {
     struct aws_h1_connection *connection = AWS_CONTAINER_OF(connection_base, struct aws_h1_connection, base);
     bool is_open;

data/aws-crt-ffi/crt/aws-c-http/source/h1_encoder.c

@@ -243,6 +243,7 @@ static void s_write_headers(struct aws_byte_buf *dst, const struct aws_http_head
         wrote_all &= s_write_crlf(dst);
     }
     AWS_ASSERT(wrote_all);
+    (void)wrote_all;
 }
 
 int aws_h1_encoder_message_init_from_request(
@@ -255,7 +256,7 @@ int aws_h1_encoder_message_init_from_request(
 
     AWS_ZERO_STRUCT(*message);
 
-    message->body = aws_http_message_get_body_stream(request);
+    message->body = aws_input_stream_acquire(aws_http_message_get_body_stream(request));
     message->pending_chunk_list = pending_chunk_list;
 
     struct aws_byte_cursor method;
@@ -351,7 +352,7 @@ int aws_h1_encoder_message_init_from_response(
 
     AWS_ZERO_STRUCT(*message);
 
-    message->body = aws_http_message_get_body_stream(response);
+    message->body = aws_input_stream_acquire(aws_http_message_get_body_stream(response));
     message->pending_chunk_list = pending_chunk_list;
 
     struct aws_byte_cursor version = aws_http_version_to_str(AWS_HTTP_VERSION_1_1);
@@ -431,6 +432,7 @@ error:
 }
 
 void aws_h1_encoder_message_clean_up(struct aws_h1_encoder_message *message) {
+    aws_input_stream_release(message->body);
     aws_byte_buf_clean_up(&message->outgoing_head_buf);
     aws_h1_trailer_destroy(message->trailer);
     AWS_ZERO_STRUCT(*message);
@@ -506,6 +508,7 @@ static void s_populate_chunk_line_buffer(
     }
     wrote_chunk_line &= s_write_crlf(chunk_line);
     AWS_ASSERT(wrote_chunk_line);
+    (void)wrote_chunk_line;
 }
 
 struct aws_h1_trailer *aws_h1_trailer_new(
@@ -545,18 +548,18 @@ struct aws_h1_chunk *aws_h1_chunk_new(struct aws_allocator *allocator, const str
     }
 
     chunk->allocator = allocator;
-    chunk->data = options->chunk_data;
+    chunk->data = aws_input_stream_acquire(options->chunk_data);
     chunk->data_size = options->chunk_data_size;
     chunk->on_complete = options->on_complete;
     chunk->user_data = options->user_data;
     chunk->chunk_line = aws_byte_buf_from_empty_array(chunk_line_storage, chunk_line_size);
     s_populate_chunk_line_buffer(&chunk->chunk_line, options);
-
     return chunk;
 }
 
 void aws_h1_chunk_destroy(struct aws_h1_chunk *chunk) {
     AWS_PRECONDITION(chunk);
+    aws_input_stream_release(chunk->data);
     aws_mem_release(chunk->allocator, chunk);
 }