aws-crt 0.1.5 → 0.1.6

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

@@ -54,6 +54,7 @@ static struct aws_http_stream *s_connection_make_request(
     struct aws_http_connection *client_connection,
     const struct aws_http_make_request_options *options);
 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 void s_connection_update_window(struct aws_http_connection *connection_base, uint32_t increment_size);
@@ -68,7 +69,7 @@ static int s_connection_send_ping(
     const struct aws_byte_cursor *optional_opaque_data,
     aws_http2_on_ping_complete_fn *on_completed,
     void *user_data);
-static int s_connection_send_goaway(
+static void s_connection_send_goaway(
     struct aws_http_connection *connection_base,
     uint32_t http2_error,
     bool allow_more_streams,
@@ -146,6 +147,8 @@ struct aws_h2err s_decoder_on_goaway(
     uint32_t error_code,
     struct aws_byte_cursor debug_data,
     void *userdata);
+static void s_reset_statistics(struct aws_channel_handler *handler);
+static void s_gather_statistics(struct aws_channel_handler *handler, struct aws_array_list *stats);
 
 static struct aws_http_connection_vtable s_h2_connection_vtable = {
     .channel_handler_vtable =
@@ -157,6 +160,8 @@ static struct aws_http_connection_vtable s_h2_connection_vtable = {
             .initial_window_size = s_handler_initial_window_size,
             .message_overhead = s_handler_message_overhead,
             .destroy = s_handler_destroy,
+            .reset_statistics = s_reset_statistics,
+            .gather_statistics = s_gather_statistics,
         },
 
     .on_channel_handler_installed = s_handler_installed,
@@ -164,6 +169,7 @@ static struct aws_http_connection_vtable s_h2_connection_vtable = {
     .new_server_request_handler_stream = NULL,
     .stream_send_response = NULL,
     .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,
     .update_window = s_connection_update_window,
@@ -219,6 +225,14 @@ static void s_release_stream_and_connection_lock(struct aws_h2_stream *stream, s
     (void)err;
 }
 
+static void s_add_time_measurement_to_stats(uint64_t start_ns, uint64_t end_ns, uint64_t *output_ms) {
+    if (end_ns > start_ns) {
+        *output_ms += aws_timestamp_convert(end_ns - start_ns, AWS_TIMESTAMP_NANOS, AWS_TIMESTAMP_MILLIS, NULL);
+    } else {
+        *output_ms = 0;
+    }
+}
+
 /**
  * Internal function for bringing connection to a stop.
  * Invoked multiple times, including when:
@@ -331,6 +345,7 @@ static struct aws_h2_connection *s_connection_new(
     aws_linked_list_init(&connection->thread_data.pending_settings_queue);
     aws_linked_list_init(&connection->thread_data.pending_ping_queue);
     aws_linked_list_init(&connection->thread_data.stalled_window_streams_list);
+    aws_linked_list_init(&connection->thread_data.waiting_streams_list);
     aws_linked_list_init(&connection->thread_data.outgoing_frames_queue);
 
     if (aws_mutex_init(&connection->synced_data.lock)) {
@@ -366,12 +381,15 @@ static struct aws_h2_connection *s_connection_new(
     memcpy(connection->synced_data.settings_peer, aws_h2_settings_initial, sizeof(aws_h2_settings_initial));
     memcpy(connection->synced_data.settings_self, aws_h2_settings_initial, sizeof(aws_h2_settings_initial));
 
-    connection->thread_data.window_size_peer = aws_h2_settings_initial[AWS_HTTP2_SETTINGS_INITIAL_WINDOW_SIZE];
-    connection->thread_data.window_size_self = aws_h2_settings_initial[AWS_HTTP2_SETTINGS_INITIAL_WINDOW_SIZE];
+    connection->thread_data.window_size_peer = AWS_H2_INIT_WINDOW_SIZE;
+    connection->thread_data.window_size_self = AWS_H2_INIT_WINDOW_SIZE;
 
     connection->thread_data.goaway_received_last_stream_id = AWS_H2_STREAM_ID_MAX;
     connection->thread_data.goaway_sent_last_stream_id = AWS_H2_STREAM_ID_MAX;
 
+    aws_crt_statistics_http2_channel_init(&connection->thread_data.stats);
+    connection->thread_data.stats.was_inactive = true; /* Start with non active streams */
+
     connection->synced_data.is_open = true;
     connection->synced_data.new_stream_error_code = AWS_ERROR_SUCCESS;
 
@@ -453,6 +471,7 @@ static void s_handler_destroy(struct aws_channel_handler *handler) {
         !aws_hash_table_is_valid(&connection->thread_data.active_streams_map) ||
         aws_hash_table_get_entry_count(&connection->thread_data.active_streams_map) == 0);
 
+    AWS_ASSERT(aws_linked_list_empty(&connection->thread_data.waiting_streams_list));
     AWS_ASSERT(aws_linked_list_empty(&connection->thread_data.stalled_window_streams_list));
     AWS_ASSERT(aws_linked_list_empty(&connection->thread_data.outgoing_streams_list));
     AWS_ASSERT(aws_linked_list_empty(&connection->synced_data.pending_stream_list));
@@ -548,10 +567,9 @@ static struct aws_h2_pending_goaway *s_new_pending_goaway(
     }
     struct aws_h2_pending_goaway *pending_goaway;
     void *debug_data_storage;
-    if (!aws_mem_acquire_many(
-            allocator, 2, &pending_goaway, sizeof(struct aws_h2_pending_goaway), &debug_data_storage, debug_data.len)) {
-        return NULL;
-    }
+    /* mem acquire cannot fail anymore */
+    aws_mem_acquire_many(
+        allocator, 2, &pending_goaway, sizeof(struct aws_h2_pending_goaway), &debug_data_storage, debug_data.len);
     if (debug_data.len) {
         memcpy(debug_data_storage, debug_data.ptr, debug_data.len);
         debug_data.ptr = debug_data_storage;
@@ -793,7 +811,11 @@ static int s_encode_data_from_outgoing_streams(struct aws_h2_connection *connect
 
     AWS_PRECONDITION(aws_channel_thread_is_callers_thread(connection->base.channel_slot->channel));
     struct aws_linked_list *outgoing_streams_list = &connection->thread_data.outgoing_streams_list;
+    if (aws_linked_list_empty(outgoing_streams_list)) {
+        return AWS_OP_SUCCESS;
+    }
     struct aws_linked_list *stalled_window_streams_list = &connection->thread_data.stalled_window_streams_list;
+    struct aws_linked_list *waiting_streams_list = &connection->thread_data.waiting_streams_list;
 
     /* If a stream stalls, put it in this list until the function ends so we don't keep trying to read from it.
      * We put it back at the end of function. */
@@ -813,7 +835,7 @@ static int s_encode_data_from_outgoing_streams(struct aws_h2_connection *connect
                 "Peer connection's flow-control window is too small now %zu. Connection will stop sending DATA until "
                 "WINDOW_UPDATE is received.",
                 connection->thread_data.window_size_peer);
-            break;
+            goto done;
         }
 
         /* Stop looping if message is so full it's not worth the bother */
@@ -851,9 +873,13 @@ static int s_encode_data_from_outgoing_streams(struct aws_h2_connection *connect
             case AWS_H2_DATA_ENCODE_ONGOING:
                 aws_linked_list_push_back(outgoing_streams_list, node);
                 break;
-            case AWS_H2_DATA_ENCODE_ONGOING_BODY_STALLED:
+            case AWS_H2_DATA_ENCODE_ONGOING_BODY_STREAM_STALLED:
                 aws_linked_list_push_back(&stalled_streams_list, node);
                 break;
+            case AWS_H2_DATA_ENCODE_ONGOING_WAITING_FOR_WRITES:
+                stream->thread_data.waiting_for_writes = true;
+                aws_linked_list_push_back(waiting_streams_list, node);
+                break;
             case AWS_H2_DATA_ENCODE_ONGOING_WINDOW_STALLED:
                 aws_linked_list_push_back(stalled_window_streams_list, node);
                 AWS_H2_STREAM_LOG(
@@ -878,6 +904,16 @@ done:
         return aws_raise_error(aws_error_code);
     }
 
+    if (aws_linked_list_empty(outgoing_streams_list)) {
+        /* transition from something to write -> nothing to write */
+        uint64_t now_ns = 0;
+        aws_channel_current_clock_time(connection->base.channel_slot->channel, &now_ns);
+        s_add_time_measurement_to_stats(
+            connection->thread_data.outgoing_timestamp_ns,
+            now_ns,
+            &connection->thread_data.stats.pending_outgoing_stream_ms);
+    }
+
     return AWS_OP_SUCCESS;
 }
 
@@ -1199,34 +1235,28 @@ struct aws_h2err s_decoder_on_data_begin(
             return err;
         }
     }
-
-    if (total_padding_bytes != 0 && connection->conn_manual_window_management) {
-        /**
-         * Automatically update the flow-window to account for padding, even if "manual window management"
+    /* Handle automatic updates of the connection flow window */
+    uint32_t auto_window_update;
+    if (connection->conn_manual_window_management) {
+        /* Automatically update the flow-window to account for padding, even though "manual window management"
          * is enabled. We do this because the current API doesn't have any way to inform the user about padding,
-         * so we can't expect them to manage it themselves.
-         */
-        if (s_connection_send_update_window(connection, total_padding_bytes)) {
-            return aws_h2err_from_last_error();
-        }
-        CONNECTION_LOGF(
-            DEBUG,
-            connection,
-            "DATA with %" PRIu32
-            " padding. Updating the window for padding and one byte for padding length automatically.",
-            total_padding_bytes - 1 /* one byte for padding length */);
+         * so we can't expect them to manage it themselves. */
+        auto_window_update = total_padding_bytes;
+    } else {
+        /* Automatically update the full amount we just received */
+        auto_window_update = payload_len;
     }
 
-    /* if conn_manual_window_management is false, we will automatically maintain the connection self window size */
-    if (payload_len != 0 && !connection->conn_manual_window_management) {
-        if (s_connection_send_update_window(connection, payload_len)) {
+    if (auto_window_update != 0) {
+        if (s_connection_send_update_window(connection, auto_window_update)) {
             return aws_h2err_from_last_error();
         }
         CONNECTION_LOGF(
             TRACE,
             connection,
-            "Connection with no manual window management, updating window with size %" PRIu32 " automatically.",
-            payload_len);
+            "Automatically updating connection window by %" PRIu32 "(%" PRIu32 " due to padding).",
+            auto_window_update,
+            total_padding_bytes);
     }
 
     return AWS_H2ERR_SUCCESS;
@@ -1722,6 +1752,17 @@ static void s_handler_installed(struct aws_channel_handler *handler, struct aws_
     /* enqueue the initial settings frame here */
     aws_linked_list_push_back(&connection->thread_data.outgoing_frames_queue, &init_settings_frame->node);
 
+    /* If not manual connection window management, update the connection window to max. */
+    if (!connection->conn_manual_window_management) {
+        uint32_t initial_window_update_size = AWS_H2_WINDOW_UPDATE_MAX - AWS_H2_INIT_WINDOW_SIZE;
+        struct aws_h2_frame *connection_window_update_frame =
+            aws_h2_frame_new_window_update(connection->base.alloc, 0 /* stream_id */, initial_window_update_size);
+        AWS_ASSERT(connection_window_update_frame);
+        /* enqueue the windows update frame here */
+        aws_linked_list_push_back(
+            &connection->thread_data.outgoing_frames_queue, &connection_window_update_frame->node);
+        connection->thread_data.window_size_self += initial_window_update_size;
+    }
     aws_h2_try_write_outgoing_frames(connection);
     return;
 
@@ -1750,11 +1791,21 @@ static void s_stream_complete(struct aws_h2_connection *connection, struct aws_h
         aws_linked_list_remove(&stream->node);
     }
 
-    /* Invoke callback */
-    if (stream->base.on_complete) {
-        stream->base.on_complete(&stream->base, error_code, stream->base.user_data);
+    if (aws_hash_table_get_entry_count(&connection->thread_data.active_streams_map) == 0 &&
+        connection->thread_data.incoming_timestamp_ns != 0) {
+        uint64_t now_ns = 0;
+        aws_channel_current_clock_time(connection->base.channel_slot->channel, &now_ns);
+        /* transition from something to read -> nothing to read and nothing to write */
+        s_add_time_measurement_to_stats(
+            connection->thread_data.incoming_timestamp_ns,
+            now_ns,
+            &connection->thread_data.stats.pending_incoming_stream_ms);
+        connection->thread_data.stats.was_inactive = true;
+        connection->thread_data.incoming_timestamp_ns = 0;
     }
 
+    aws_h2_stream_complete(stream, error_code);
+
     /* release connection's hold on stream */
     aws_http_stream_release(&stream->base);
 }
@@ -1848,15 +1899,28 @@ static void s_move_stream_to_thread(
         goto error;
     }
 
-    bool has_outgoing_data = false;
-    if (aws_h2_stream_on_activated(stream, &has_outgoing_data)) {
+    enum aws_h2_stream_body_state body_state = AWS_H2_STREAM_BODY_STATE_NONE;
+    if (aws_h2_stream_on_activated(stream, &body_state)) {
         goto error;
     }
 
-    if (has_outgoing_data) {
-        aws_linked_list_push_back(&connection->thread_data.outgoing_streams_list, &stream->node);
+    if (aws_hash_table_get_entry_count(&connection->thread_data.active_streams_map) == 1) {
+        /* transition from nothing to read -> something to read */
+        uint64_t now_ns = 0;
+        aws_channel_current_clock_time(connection->base.channel_slot->channel, &now_ns);
+        connection->thread_data.incoming_timestamp_ns = now_ns;
     }
 
+    switch (body_state) {
+        case AWS_H2_STREAM_BODY_STATE_WAITING_WRITES:
+            aws_linked_list_push_back(&connection->thread_data.waiting_streams_list, &stream->node);
+            break;
+        case AWS_H2_STREAM_BODY_STATE_ONGOING:
+            aws_linked_list_push_back(&connection->thread_data.outgoing_streams_list, &stream->node);
+            break;
+        default:
+            break;
+    }
     return;
 error:
     /* If the stream got into any datastructures, s_stream_complete() will remove it */
@@ -1943,6 +2007,7 @@ static void s_cross_thread_work_task(struct aws_channel_task *task, void *arg, e
         s_send_goaway(connection, goaway->http2_error, goaway->allow_more_streams, &goaway->debug_data);
         aws_mem_release(connection->base.alloc, goaway);
     }
+
     /* It's likely that frames were queued while processing cross-thread work.
      * If so, try writing them now */
     aws_h2_try_write_outgoing_frames(connection);
@@ -2064,6 +2129,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_h2_connection *connection = AWS_CONTAINER_OF(connection_base, struct aws_h2_connection, base);
+
+    { /* BEGIN CRITICAL SECTION */
+        s_lock_synced_data(connection);
+        if (!connection->synced_data.new_stream_error_code) {
+            connection->synced_data.new_stream_error_code = AWS_ERROR_HTTP_CONNECTION_CLOSED;
+        }
+        s_unlock_synced_data(connection);
+    } /* END CRITICAL SECTION */
+}
+
 static bool s_connection_is_open(const struct aws_http_connection *connection_base) {
     struct aws_h2_connection *connection = AWS_CONTAINER_OF(connection_base, struct aws_h2_connection, base);
     bool is_open;
@@ -2294,7 +2371,7 @@ closed:
     return aws_raise_error(AWS_ERROR_INVALID_STATE);
 }
 
-static int s_connection_send_goaway(
+static void s_connection_send_goaway(
     struct aws_http_connection *connection_base,
     uint32_t http2_error,
     bool allow_more_streams,
@@ -2304,11 +2381,6 @@ static int s_connection_send_goaway(
     struct aws_h2_pending_goaway *pending_goaway =
         s_new_pending_goaway(connection->base.alloc, http2_error, allow_more_streams, optional_debug_data);
 
-    if (!pending_goaway) {
-        /* error happened during acquire memory. Error code raised there and skip logging. */
-        return AWS_OP_ERR;
-    }
-
     bool was_cross_thread_work_scheduled = false;
     bool connection_open;
     { /* BEGIN CRITICAL SECTION */
@@ -2319,7 +2391,7 @@ static int s_connection_send_goaway(
             s_unlock_synced_data(connection);
             CONNECTION_LOG(DEBUG, connection, "Goaway not sent, connection is closed or closing.");
             aws_mem_release(connection->base.alloc, pending_goaway);
-            goto done;
+            return;
         }
         was_cross_thread_work_scheduled = connection->synced_data.is_cross_thread_work_task_scheduled;
         connection->synced_data.is_cross_thread_work_task_scheduled = true;
@@ -2340,8 +2412,6 @@ static int s_connection_send_goaway(
         CONNECTION_LOG(TRACE, connection, "Scheduling cross-thread work task");
         aws_channel_schedule_task_now(connection->base.channel_slot->channel, &connection->cross_thread_work_task);
     }
-done:
-    return AWS_OP_SUCCESS;
 }
 
 static void s_get_settings_general(
@@ -2732,3 +2802,49 @@ static size_t s_handler_message_overhead(struct aws_channel_handler *handler) {
     /* "All frames begin with a fixed 9-octet header followed by a variable-length payload" (RFC-7540 4.1) */
     return 9;
 }
+
+static void s_reset_statistics(struct aws_channel_handler *handler) {
+    struct aws_h2_connection *connection = handler->impl;
+    aws_crt_statistics_http2_channel_reset(&connection->thread_data.stats);
+    if (aws_hash_table_get_entry_count(&connection->thread_data.active_streams_map) == 0) {
+        /* Check the current state */
+        connection->thread_data.stats.was_inactive = true;
+    }
+    return;
+}
+
+static void s_gather_statistics(struct aws_channel_handler *handler, struct aws_array_list *stats) {
+
+    struct aws_h2_connection *connection = handler->impl;
+    AWS_PRECONDITION(aws_channel_thread_is_callers_thread(connection->base.channel_slot->channel));
+
+    /* TODO: Need update the way we calculate statistics, to account for user-controlled pauses.
+     * If user is adding chunks 1 by 1, there can naturally be a gap in the upload.
+     * If the user lets the stream-window go to zero, there can naturally be a gap in the download. */
+    uint64_t now_ns = 0;
+    if (aws_channel_current_clock_time(connection->base.channel_slot->channel, &now_ns)) {
+        return;
+    }
+
+    if (!aws_linked_list_empty(&connection->thread_data.outgoing_streams_list)) {
+        s_add_time_measurement_to_stats(
+            connection->thread_data.outgoing_timestamp_ns,
+            now_ns,
+            &connection->thread_data.stats.pending_outgoing_stream_ms);
+
+        connection->thread_data.outgoing_timestamp_ns = now_ns;
+    }
+    if (aws_hash_table_get_entry_count(&connection->thread_data.active_streams_map) != 0) {
+        s_add_time_measurement_to_stats(
+            connection->thread_data.incoming_timestamp_ns,
+            now_ns,
+            &connection->thread_data.stats.pending_incoming_stream_ms);
+
+        connection->thread_data.incoming_timestamp_ns = now_ns;
+    } else {
+        connection->thread_data.stats.was_inactive = true;
+    }
+
+    void *stats_base = &connection->thread_data.stats;
+    aws_array_list_push_back(stats, &stats_base);
+}

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

@@ -8,6 +8,7 @@
 #include <aws/http/private/strutil.h>
 
 #include <aws/common/string.h>
+#include <aws/http/status_code.h>
 #include <aws/io/logging.h>
 
 #include <inttypes.h>
@@ -259,6 +260,8 @@ struct aws_h2_decoder {
          * We continue decoding and report that it's malformed in on_headers_end(). */
         bool malformed;
 
+        bool body_headers_forbidden;
+
         /* Buffer up cookie header fields to concatenate separate ones */
         struct aws_byte_buf cookies;
         /* If separate cookie fields have different compression types, the concatenated cookie uses the strictest type.
@@ -1178,9 +1181,16 @@ static struct aws_h2err s_flush_pseudoheaders(struct aws_h2_decoder *decoder) {
                 DECODER_LOG(ERROR, decoder, "Informational (1xx) response cannot END_STREAM");
                 goto malformed;
             }
+            current_block->body_headers_forbidden = true;
         } else {
             current_block->block_type = AWS_HTTP_HEADER_BLOCK_MAIN;
         }
+        /**
+         * RFC-9110 8.6.
+         * A server MUST NOT send a Content-Length header field in any response with a status code of 1xx
+         * (Informational) or 204 (No Content).
+         */
+        current_block->body_headers_forbidden |= status_code == AWS_HTTP_STATUS_CODE_204_NO_CONTENT;
 
     } else {
         /* Trailing header block. */
@@ -1339,18 +1349,37 @@ static struct aws_h2err s_process_header_field(
                 if (aws_byte_buf_append_dynamic(&current_block->cookies, &header_field->value)) {
                     return aws_h2err_from_last_error();
                 }
+                /* Early return */
+                return AWS_H2ERR_SUCCESS;
+            case AWS_HTTP_HEADER_TRANSFER_ENCODING:
+            case AWS_HTTP_HEADER_UPGRADE:
+            case AWS_HTTP_HEADER_KEEP_ALIVE:
+            case AWS_HTTP_HEADER_PROXY_CONNECTION: {
+                /* connection-specific header field are treated as malformed (RFC9113 8.2.2) */
+                DECODER_LOGF(
+                    ERROR,
+                    decoder,
+                    "Connection-specific header ('" PRInSTR "') found, not allowed in HTTP/2",
+                    AWS_BYTE_CURSOR_PRI(name));
+                goto malformed;
+            } break;
+
+            case AWS_HTTP_HEADER_CONTENT_LENGTH:
+                if (current_block->body_headers_forbidden) {
+                    /* The content-length are forbidden */
+                    DECODER_LOG(ERROR, decoder, "Unexpected Content-Length header found");
+                    goto malformed;
+                }
                 break;
-            /* TODO: Validate connection-specific header field (RFC7540 8.1.2.2) */
             default:
-                /* Deliver header-field via callback */
-                if (current_block->is_push_promise) {
-                    DECODER_CALL_VTABLE_STREAM_ARGS(decoder, on_push_promise_i, header_field, name_enum);
-                } else {
-                    DECODER_CALL_VTABLE_STREAM_ARGS(
-                        decoder, on_headers_i, header_field, name_enum, current_block->block_type);
-                }
                 break;
         }
+        /* Deliver header-field via callback */
+        if (current_block->is_push_promise) {
+            DECODER_CALL_VTABLE_STREAM_ARGS(decoder, on_push_promise_i, header_field, name_enum);
+        } else {
+            DECODER_CALL_VTABLE_STREAM_ARGS(decoder, on_headers_i, header_field, name_enum, current_block->block_type);
+        }
     }
 
     return AWS_H2ERR_SUCCESS;

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

@@ -31,7 +31,7 @@ const uint32_t aws_h2_settings_initial[AWS_HTTP2_SETTINGS_END_RANGE] = {
     [AWS_HTTP2_SETTINGS_HEADER_TABLE_SIZE] = 4096,
     [AWS_HTTP2_SETTINGS_ENABLE_PUSH] = 1,
     [AWS_HTTP2_SETTINGS_MAX_CONCURRENT_STREAMS] = UINT32_MAX, /* "Initially there is no limit to this value" */
-    [AWS_HTTP2_SETTINGS_INITIAL_WINDOW_SIZE] = 65535,
+    [AWS_HTTP2_SETTINGS_INITIAL_WINDOW_SIZE] = AWS_H2_INIT_WINDOW_SIZE,
     [AWS_HTTP2_SETTINGS_MAX_FRAME_SIZE] = 16384,
     [AWS_HTTP2_SETTINGS_MAX_HEADER_LIST_SIZE] = UINT32_MAX, /* "The initial value of this setting is unlimited" */
 };
@@ -227,6 +227,7 @@ static void s_frame_priority_settings_encode(
     writes_ok &= aws_byte_buf_write_u8(output, priority->weight);
 
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
 }
 
 /***********************************************************************************************************************
@@ -279,6 +280,7 @@ static void s_frame_prefix_encode(
     writes_ok &= aws_byte_buf_write_be32(output, stream_id);
 
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
 }
 
 /***********************************************************************************************************************
@@ -444,6 +446,7 @@ int aws_h2_encode_data_frame(
     *stream_window_size_peer -= (int32_t)payload_len;
 
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
     return AWS_OP_SUCCESS;
 
 handle_waiting_for_more_space:
@@ -501,6 +504,8 @@ static struct aws_h2_frame *s_frame_new_headers_or_push_promise(
     const struct aws_h2_frame_priority_settings *optional_priority,
     uint32_t promised_stream_id) {
 
+    /* TODO: Host and ":authority" are no longer permitted to disagree. Should we enforce it here or sent it as
+     * requested, let the server side reject the request? */
     AWS_PRECONDITION(allocator);
     AWS_PRECONDITION(frame_type == AWS_H2_FRAME_T_HEADERS || frame_type == AWS_H2_FRAME_T_PUSH_PROMISE);
     AWS_PRECONDITION(headers);
@@ -721,6 +726,7 @@ static void s_encode_single_header_block_frame(
     }
 
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
 
     /* Success! Wrote entire frame. It's safe to change state now */
     frame->state =
@@ -887,6 +893,7 @@ static int s_frame_prebuilt_encode(
     struct aws_byte_cursor chunk = aws_byte_cursor_advance(&frame->cursor, chunk_len);
     writes_ok &= aws_byte_buf_write_from_whole_cursor(output, chunk);
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
 
     if (frame->cursor.len == 0) {
         *complete = true;
@@ -966,6 +973,7 @@ struct aws_h2_frame *aws_h2_frame_new_rst_stream(
     bool writes_ok = true;
     writes_ok &= aws_byte_buf_write_be32(&frame->encoded_buf, error_code);
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
 
     return &frame->base;
 }
@@ -1026,6 +1034,7 @@ struct aws_h2_frame *aws_h2_frame_new_settings(
         writes_ok &= aws_byte_buf_write_be32(&frame->encoded_buf, settings_array[i].value);
     }
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
 
     return &frame->base;
 }
@@ -1059,6 +1068,7 @@ struct aws_h2_frame *aws_h2_frame_new_ping(
     bool writes_ok = true;
     writes_ok &= aws_byte_buf_write(&frame->encoded_buf, opaque_data, AWS_HTTP2_PING_DATA_SIZE);
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
 
     /* PING responses SHOULD be given higher priority than any other frame */
     frame->base.high_priority = ack;
@@ -1117,6 +1127,7 @@ struct aws_h2_frame *aws_h2_frame_new_goaway(
     writes_ok &= aws_byte_buf_write_be32(&frame->encoded_buf, error_code);
     writes_ok &= aws_byte_buf_write_from_whole_cursor(&frame->encoded_buf, debug_data);
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
 
     return &frame->base;
 }
@@ -1165,6 +1176,7 @@ struct aws_h2_frame *aws_h2_frame_new_window_update(
     bool writes_ok = true;
     writes_ok &= aws_byte_buf_write_be32(&frame->encoded_buf, window_size_increment);
     AWS_ASSERT(writes_ok);
+    (void)writes_ok;
 
     return &frame->base;
 }