aws-crt 0.1.9 → 0.2.0

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

@@ -11,6 +11,7 @@
 #include <aws/http/private/h1_stream.h>
 #include <aws/http/private/request_response_impl.h>
 #include <aws/http/status_code.h>
+#include <aws/io/event_loop.h>
 #include <aws/io/logging.h>
 
 #include <inttypes.h>
@@ -535,6 +536,7 @@ static int s_aws_http1_switch_protocols(struct aws_h1_connection *connection) {
 static void s_stream_complete(struct aws_h1_stream *stream, int error_code) {
     struct aws_h1_connection *connection =
         AWS_CONTAINER_OF(stream->base.owning_connection, struct aws_h1_connection, base);
+    AWS_ASSERT(aws_channel_thread_is_callers_thread(connection->base.channel_slot->channel));
 
     /*
      * If this is the end of a successful CONNECT request, mark ourselves as pass-through since the proxy layer
@@ -547,6 +549,14 @@ static void s_stream_complete(struct aws_h1_stream *stream, int error_code) {
         }
     }
 
+    if (stream->base.client_data && stream->base.client_data->response_first_byte_timeout_task.fn != NULL) {
+        /* There is an outstanding response timeout task, but stream completed, we can cancel it now. We are
+         * safe to do it as we always on connection thread to schedule the task or cancel it */
+        struct aws_event_loop *connection_loop = aws_channel_get_event_loop(connection->base.channel_slot->channel);
+        /* The task will be zeroed out within the call */
+        aws_event_loop_cancel_task(connection_loop, &stream->base.client_data->response_first_byte_timeout_task);
+    }
+
     if (error_code != AWS_ERROR_SUCCESS) {
         if (stream->base.client_data && stream->is_incoming_message_done) {
             /* As a request that finished receiving the response, we ignore error and
@@ -721,6 +731,87 @@ static void s_client_update_incoming_stream_ptr(struct aws_h1_connection *connec
     s_set_incoming_stream_ptr(connection, desired);
 }
 
+static void s_http_stream_response_first_byte_timeout_task(
+    struct aws_task *task,
+    void *arg,
+    enum aws_task_status status) {
+    (void)task;
+    struct aws_h1_stream *stream = arg;
+    struct aws_http_connection *connection_base = stream->base.owning_connection;
+    /* zero-out task to indicate that it's no longer scheduled */
+    AWS_ZERO_STRUCT(stream->base.client_data->response_first_byte_timeout_task);
+
+    if (status == AWS_TASK_STATUS_CANCELED) {
+        return;
+    }
+
+    struct aws_h1_connection *connection = AWS_CONTAINER_OF(connection_base, struct aws_h1_connection, base);
+    /* Timeout happened, close the connection */
+    uint64_t response_first_byte_timeout_ms = stream->base.client_data->response_first_byte_timeout_ms == 0
+                                                  ? connection_base->client_data->response_first_byte_timeout_ms
+                                                  : stream->base.client_data->response_first_byte_timeout_ms;
+    AWS_LOGF_INFO(
+        AWS_LS_HTTP_CONNECTION,
+        "id=%p: Closing connection as timeout after request sent to the first byte received happened. "
+        "response_first_byte_timeout_ms is %" PRIu64 ".",
+        (void *)connection_base,
+        response_first_byte_timeout_ms);
+
+    /* Don't stop reading/writing immediately, let that happen naturally during the channel shutdown process. */
+    s_stop(
+        connection,
+        false /*stop_reading*/,
+        false /*stop_writing*/,
+        true /*schedule_shutdown*/,
+        AWS_ERROR_HTTP_RESPONSE_FIRST_BYTE_TIMEOUT);
+}
+
+static void s_set_outgoing_message_done(struct aws_h1_stream *stream) {
+    struct aws_http_connection *connection = stream->base.owning_connection;
+    struct aws_channel *channel = aws_http_connection_get_channel(connection);
+    AWS_ASSERT(aws_channel_thread_is_callers_thread(channel));
+
+    if (stream->is_outgoing_message_done) {
+        /* Already did the job */
+        return;
+    }
+
+    stream->is_outgoing_message_done = true;
+    AWS_ASSERT(stream->base.metrics.send_end_timestamp_ns == -1);
+    aws_high_res_clock_get_ticks((uint64_t *)&stream->base.metrics.send_end_timestamp_ns);
+    AWS_ASSERT(stream->base.metrics.send_start_timestamp_ns != -1);
+    AWS_ASSERT(stream->base.metrics.send_end_timestamp_ns >= stream->base.metrics.send_start_timestamp_ns);
+    stream->base.metrics.sending_duration_ns =
+        stream->base.metrics.send_end_timestamp_ns - stream->base.metrics.send_start_timestamp_ns;
+    if (stream->base.metrics.receive_start_timestamp_ns == -1) {
+        /* We haven't receive any message, schedule the response timeout task */
+
+        uint64_t response_first_byte_timeout_ms = 0;
+        if (stream->base.client_data != NULL && connection->client_data != NULL) {
+            response_first_byte_timeout_ms = stream->base.client_data->response_first_byte_timeout_ms == 0
+                                                 ? connection->client_data->response_first_byte_timeout_ms
+                                                 : stream->base.client_data->response_first_byte_timeout_ms;
+        }
+        if (response_first_byte_timeout_ms != 0) {
+            /* The task should not be initialized before. */
+            AWS_ASSERT(stream->base.client_data->response_first_byte_timeout_task.fn == NULL);
+            aws_task_init(
+                &stream->base.client_data->response_first_byte_timeout_task,
+                s_http_stream_response_first_byte_timeout_task,
+                stream,
+                "http_stream_response_first_byte_timeout_task");
+            uint64_t now_ns = 0;
+            aws_channel_current_clock_time(channel, &now_ns);
+            struct aws_event_loop *connection_loop = aws_channel_get_event_loop(channel);
+            aws_event_loop_schedule_task_future(
+                connection_loop,
+                &stream->base.client_data->response_first_byte_timeout_task,
+                now_ns + aws_timestamp_convert(
+                             response_first_byte_timeout_ms, AWS_TIMESTAMP_MILLIS, AWS_TIMESTAMP_NANOS, NULL));
+        }
+    }
+}
+
 /**
  * If necessary, update `outgoing_stream` so it is pointing at a stream
  * with data to send, or NULL if all streams are done sending data.
@@ -735,13 +826,7 @@ static struct aws_h1_stream *s_update_outgoing_stream_ptr(struct aws_h1_connecti
 
     /* If current stream is done sending data... */
     if (current && !aws_h1_encoder_is_message_in_progress(&connection->thread_data.encoder)) {
-        current->is_outgoing_message_done = true;
-        AWS_ASSERT(current->base.metrics.send_end_timestamp_ns == -1);
-        aws_high_res_clock_get_ticks((uint64_t *)&current->base.metrics.send_end_timestamp_ns);
-        AWS_ASSERT(current->base.metrics.send_start_timestamp_ns != -1);
-        AWS_ASSERT(current->base.metrics.send_end_timestamp_ns >= current->base.metrics.send_start_timestamp_ns);
-        current->base.metrics.sending_duration_ns =
-            current->base.metrics.send_end_timestamp_ns - current->base.metrics.send_start_timestamp_ns;
+        s_set_outgoing_message_done(current);
 
         /* RFC-7230 section 6.6: Tear-down.
          * If this was the final stream, don't allows any further streams to be sent */
@@ -1124,16 +1209,7 @@ static int s_decoder_on_header(const struct aws_h1_decoded_header *header, void
                         AWS_LS_HTTP_STREAM,
                         "id=%p: Received 'Connection: close' header, no more request data will be sent.",
                         (void *)&incoming_stream->base);
-                    incoming_stream->is_outgoing_message_done = true;
-                    AWS_ASSERT(incoming_stream->base.metrics.send_end_timestamp_ns == -1);
-                    aws_high_res_clock_get_ticks((uint64_t *)&incoming_stream->base.metrics.send_end_timestamp_ns);
-                    AWS_ASSERT(incoming_stream->base.metrics.send_start_timestamp_ns != -1);
-                    AWS_ASSERT(
-                        incoming_stream->base.metrics.send_end_timestamp_ns >=
-                        incoming_stream->base.metrics.send_start_timestamp_ns);
-                    incoming_stream->base.metrics.sending_duration_ns =
-                        incoming_stream->base.metrics.send_end_timestamp_ns -
-                        incoming_stream->base.metrics.send_start_timestamp_ns;
+                    s_set_outgoing_message_done(incoming_stream);
                 }
                 /* Stop writing right now.
                  * Shutdown will be scheduled after we finishing parsing the response */
@@ -1856,6 +1932,15 @@ static int s_try_process_next_stream_read_message(struct aws_h1_connection *conn
     if (incoming_stream->base.metrics.receive_start_timestamp_ns == -1) {
         /* That's the first time for the stream receives any message */
         aws_high_res_clock_get_ticks((uint64_t *)&incoming_stream->base.metrics.receive_start_timestamp_ns);
+        if (incoming_stream->base.client_data &&
+            incoming_stream->base.client_data->response_first_byte_timeout_task.fn != NULL) {
+            /* There is an outstanding response timeout task, as we already received the data, we can cancel it now. We
+             * are safe to do it as we always on connection thread to schedule the task or cancel it */
+            struct aws_event_loop *connection_loop = aws_channel_get_event_loop(connection->base.channel_slot->channel);
+            /* The task will be zeroed out within the call */
+            aws_event_loop_cancel_task(
+                connection_loop, &incoming_stream->base.client_data->response_first_byte_timeout_task);
+        }
     }
 
     /* As decoder runs, it invokes the internal s_decoder_X callbacks, which in turn invoke user callbacks.

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

@@ -407,6 +407,7 @@ struct aws_h1_stream *aws_h1_stream_new_request(
 
     stream->base.client_data = &stream->base.client_or_server_data.client;
     stream->base.client_data->response_status = AWS_HTTP_STATUS_CODE_UNKNOWN;
+    stream->base.client_data->response_first_byte_timeout_ms = options->response_first_byte_timeout_ms;
     stream->base.on_metrics = options->on_metrics;
 
     /* Validate request and cache info that the encoder will eventually need */

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

@@ -148,6 +148,9 @@ static struct aws_error_info s_errors[] = {
     AWS_DEFINE_ERROR_INFO_HTTP(
         AWS_ERROR_HTTP_MANUAL_WRITE_HAS_COMPLETED,
         "Manual write failed because manual writes are already completed."),
+    AWS_DEFINE_ERROR_INFO_HTTP(
+        AWS_ERROR_HTTP_RESPONSE_FIRST_BYTE_TIMEOUT,
+        "The server does not begin responding within the configuration after a request is fully sent."),
 };
 /* clang-format on */
 

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

@@ -39,7 +39,7 @@ AWS_STATIC_STRING_FROM_LITERAL(s_proxy_no_verify_peer_env_var, "AWS_PROXY_NO_VER
 #endif
 
 static struct aws_http_proxy_system_vtable s_default_vtable = {
-    .setup_client_tls = &aws_channel_setup_client_tls,
+    .aws_channel_setup_client_tls = &aws_channel_setup_client_tls,
 };
 
 static struct aws_http_proxy_system_vtable *s_vtable = &s_default_vtable;
@@ -772,7 +772,7 @@ static void s_aws_http_on_stream_complete_tunnel_proxy(
             last_slot = last_slot->adj_right;
         }
 
-        if (s_vtable->setup_client_tls(last_slot, context->original_tls_options)) {
+        if (s_vtable->aws_channel_setup_client_tls(last_slot, context->original_tls_options)) {
             AWS_LOGF_ERROR(
                 AWS_LS_HTTP_CONNECTION,
                 "(%p) Proxy connection failed to start TLS negotiation with error %d(%s)",

data/aws-crt-ffi/crt/aws-c-http/tests/CMakeLists.txt

@@ -144,6 +144,8 @@ add_test_case(h1_client_switching_protocols_fails_subsequent_requests)
 add_test_case(h1_client_switching_protocols_requires_downstream_handler)
 add_test_case(h1_client_connection_close_before_request_finishes)
 add_test_case(h1_client_response_close_connection_before_request_finishes)
+add_test_case(h1_client_response_first_byte_timeout_connection)
+add_test_case(h1_client_response_first_byte_timeout_request_override)
 
 add_test_case(strutil_trim_http_whitespace)
 add_test_case(strutil_is_http_token)

data/aws-crt-ffi/crt/aws-c-http/tests/test_connection_manager.c

@@ -155,7 +155,7 @@ static int s_cm_tester_init(struct cm_tester_options *options) {
 
     aws_io_clock_fn *clock_fn = &aws_high_res_clock_get_ticks;
     if (options->mock_table) {
-        clock_fn = options->mock_table->get_monotonic_time;
+        clock_fn = options->mock_table->aws_high_res_clock_get_ticks;
     }
 
     tester->event_loop_group = aws_event_loop_group_new(tester->allocator, clock_fn, 1, s_new_event_loop, NULL, NULL);
@@ -304,7 +304,7 @@ release:
 
             if (close_first) {
                 if (tester->mock_table) {
-                    tester->mock_table->close_connection(connection);
+                    tester->mock_table->aws_http_connection_close(connection);
                 } else {
                     aws_http_connection_close(connection);
                 }
@@ -809,14 +809,14 @@ static enum aws_http_version s_aws_http_connection_manager_connection_get_versio
 }
 
 static struct aws_http_connection_manager_system_vtable s_synchronous_mocks = {
-    .create_connection = s_aws_http_connection_manager_create_connection_sync_mock,
-    .release_connection = s_aws_http_connection_manager_release_connection_sync_mock,
-    .close_connection = s_aws_http_connection_manager_close_connection_sync_mock,
-    .is_connection_available = s_aws_http_connection_manager_is_connection_available_sync_mock,
-    .get_monotonic_time = aws_high_res_clock_get_ticks,
-    .connection_get_channel = s_aws_http_connection_manager_connection_get_channel_sync_mock,
-    .is_callers_thread = s_aws_http_connection_manager_is_callers_thread_sync_mock,
-    .connection_get_version = s_aws_http_connection_manager_connection_get_version_sync_mock,
+    .aws_http_client_connect = s_aws_http_connection_manager_create_connection_sync_mock,
+    .aws_http_connection_release = s_aws_http_connection_manager_release_connection_sync_mock,
+    .aws_http_connection_close = s_aws_http_connection_manager_close_connection_sync_mock,
+    .aws_http_connection_new_requests_allowed = s_aws_http_connection_manager_is_connection_available_sync_mock,
+    .aws_high_res_clock_get_ticks = aws_high_res_clock_get_ticks,
+    .aws_http_connection_get_channel = s_aws_http_connection_manager_connection_get_channel_sync_mock,
+    .aws_channel_thread_is_callers_thread = s_aws_http_connection_manager_is_callers_thread_sync_mock,
+    .aws_http_connection_get_version = s_aws_http_connection_manager_connection_get_version_sync_mock,
 };
 
 static int s_test_connection_manager_acquire_release_mix_synchronous(struct aws_allocator *allocator, void *ctx) {
@@ -934,14 +934,14 @@ static int s_test_connection_manager_proxy_setup_shutdown(struct aws_allocator *
 AWS_TEST_CASE(test_connection_manager_proxy_setup_shutdown, s_test_connection_manager_proxy_setup_shutdown);
 
 static struct aws_http_connection_manager_system_vtable s_idle_mocks = {
-    .create_connection = s_aws_http_connection_manager_create_connection_sync_mock,
-    .release_connection = s_aws_http_connection_manager_release_connection_sync_mock,
-    .close_connection = s_aws_http_connection_manager_close_connection_sync_mock,
-    .is_connection_available = s_aws_http_connection_manager_is_connection_available_sync_mock,
-    .get_monotonic_time = s_tester_get_mock_time,
-    .connection_get_channel = s_aws_http_connection_manager_connection_get_channel_sync_mock,
-    .is_callers_thread = s_aws_http_connection_manager_is_callers_thread_sync_mock,
-    .connection_get_version = s_aws_http_connection_manager_connection_get_version_sync_mock,
+    .aws_http_client_connect = s_aws_http_connection_manager_create_connection_sync_mock,
+    .aws_http_connection_release = s_aws_http_connection_manager_release_connection_sync_mock,
+    .aws_http_connection_close = s_aws_http_connection_manager_close_connection_sync_mock,
+    .aws_http_connection_new_requests_allowed = s_aws_http_connection_manager_is_connection_available_sync_mock,
+    .aws_high_res_clock_get_ticks = s_tester_get_mock_time,
+    .aws_http_connection_get_channel = s_aws_http_connection_manager_connection_get_channel_sync_mock,
+    .aws_channel_thread_is_callers_thread = s_aws_http_connection_manager_is_callers_thread_sync_mock,
+    .aws_http_connection_get_version = s_aws_http_connection_manager_connection_get_version_sync_mock,
 };
 
 static int s_register_acquired_connections(struct aws_array_list *seen_connections) {

data/aws-crt-ffi/crt/aws-c-http/tests/test_h1_client.c

@@ -4241,6 +4241,9 @@ H1_CLIENT_TEST_CASE(h1_client_response_close_connection_before_request_finishes)
     (void)ctx;
     struct tester tester;
     ASSERT_SUCCESS(s_tester_init(&tester, allocator));
+    /* Okay to set a timeout */
+    size_t connection_response_first_byte_timeout_ms = 200;
+    tester.connection->client_data->response_first_byte_timeout_ms = connection_response_first_byte_timeout_ms;
 
     /* set up request whose body won't send immediately */
     struct slow_body_sender body_sender;
@@ -4269,7 +4272,7 @@ H1_CLIENT_TEST_CASE(h1_client_response_close_connection_before_request_finishes)
     testing_channel_run_currently_queued_tasks(&tester.testing_channel);
 
     /* Ensure the request can be destroyed after request is sent */
-    aws_http_message_destroy(request);
+    aws_http_message_release(request);
     aws_input_stream_release(body_stream);
 
     /* send close connection response */
@@ -4297,3 +4300,110 @@ H1_CLIENT_TEST_CASE(h1_client_response_close_connection_before_request_finishes)
     ASSERT_SUCCESS(s_tester_clean_up(&tester));
     return AWS_OP_SUCCESS;
 }
+
+H1_CLIENT_TEST_CASE(h1_client_response_first_byte_timeout_connection) {
+    (void)ctx;
+    struct tester tester;
+    ASSERT_SUCCESS(s_tester_init(&tester, allocator));
+    /* with test channel, we don't use bootstrap to propagate the settings. Hack around it by set the setting directly
+     */
+    size_t connection_response_first_byte_timeout_ms = 200;
+    tester.connection->client_data->response_first_byte_timeout_ms = connection_response_first_byte_timeout_ms;
+
+    /* send request */
+    struct aws_http_header headers[] = {
+        {
+            .name = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("Host"),
+            .value = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("example.com"),
+        },
+        {
+            .name = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("Accept"),
+            .value = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("*/*"),
+        },
+    };
+
+    struct aws_http_message *request = s_new_default_get_request(allocator);
+    ASSERT_NOT_NULL(request);
+    ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
+    struct client_stream_tester stream_tester;
+    ASSERT_SUCCESS(s_stream_tester_init(&stream_tester, &tester, request));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+
+    /* Sleep to trigger the timeout */
+    aws_thread_current_sleep(aws_timestamp_convert(
+        connection_response_first_byte_timeout_ms + 1, AWS_TIMESTAMP_MILLIS, AWS_TIMESTAMP_NANOS, NULL));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+    /* Check if the testing channel has shut down. */
+    ASSERT_TRUE(testing_channel_is_shutdown_completed(&tester.testing_channel));
+    ASSERT_TRUE(testing_channel_is_shutdown_completed(&tester.testing_channel));
+
+    ASSERT_TRUE(stream_tester.complete);
+    ASSERT_INT_EQUALS(AWS_ERROR_HTTP_RESPONSE_FIRST_BYTE_TIMEOUT, stream_tester.on_complete_error_code);
+
+    /* clean up */
+    aws_http_message_release(request);
+    client_stream_tester_clean_up(&stream_tester);
+
+    ASSERT_SUCCESS(s_tester_clean_up(&tester));
+    return AWS_OP_SUCCESS;
+}
+
+H1_CLIENT_TEST_CASE(h1_client_response_first_byte_timeout_request_override) {
+    (void)ctx;
+    struct tester tester;
+    ASSERT_SUCCESS(s_tester_init(&tester, allocator));
+    /* with test channel, we don't use bootstrap to propagate the settings. Hack around it by set the setting directly
+     */
+    size_t connection_response_first_byte_timeout_ms = 1000;
+    tester.connection->client_data->response_first_byte_timeout_ms = connection_response_first_byte_timeout_ms;
+
+    /* send request */
+    struct aws_http_header headers[] = {
+        {
+            .name = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("Host"),
+            .value = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("example.com"),
+        },
+        {
+            .name = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("Accept"),
+            .value = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("*/*"),
+        },
+    };
+
+    struct aws_http_message *request = s_new_default_get_request(allocator);
+    ASSERT_NOT_NULL(request);
+    ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
+
+    size_t response_first_byte_timeout_ms = 100;
+
+    int completion_error_code = 0;
+    struct aws_http_make_request_options opt = {
+        .self_size = sizeof(opt),
+        .request = request,
+        .response_first_byte_timeout_ms = response_first_byte_timeout_ms,
+        .on_complete = s_on_complete,
+        .user_data = &completion_error_code,
+    };
+    struct aws_http_stream *stream = aws_http_connection_make_request(tester.connection, &opt);
+    ASSERT_NOT_NULL(stream);
+    ASSERT_SUCCESS(aws_http_stream_activate(stream));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+
+    aws_thread_current_sleep(
+        aws_timestamp_convert(response_first_byte_timeout_ms + 1, AWS_TIMESTAMP_MILLIS, AWS_TIMESTAMP_NANOS, NULL));
+
+    testing_channel_drain_queued_tasks(&tester.testing_channel);
+    /* Check if the testing channel has shut down. */
+    ASSERT_TRUE(testing_channel_is_shutdown_completed(&tester.testing_channel));
+
+    ASSERT_INT_EQUALS(AWS_ERROR_HTTP_RESPONSE_FIRST_BYTE_TIMEOUT, completion_error_code);
+
+    /* clean up */
+    aws_http_message_release(request);
+    aws_http_stream_release(stream);
+
+    ASSERT_SUCCESS(s_tester_clean_up(&tester));
+    return AWS_OP_SUCCESS;
+}

data/aws-crt-ffi/crt/aws-c-http/tests/test_proxy.c

@@ -141,7 +141,7 @@ static int s_test_proxy_setup_client_tls(
 }
 
 struct aws_http_proxy_system_vtable s_proxy_table_for_tls = {
-    .setup_client_tls = s_test_proxy_setup_client_tls,
+    .aws_channel_setup_client_tls = s_test_proxy_setup_client_tls,
 };
 
 /*
@@ -208,7 +208,7 @@ static int s_test_aws_proxy_new_socket_channel(struct aws_socket_channel_bootstr
 }
 
 struct aws_http_connection_system_vtable s_proxy_connection_system_vtable = {
-    .new_socket_channel = s_test_aws_proxy_new_socket_channel,
+    .aws_client_bootstrap_new_socket_channel = s_test_aws_proxy_new_socket_channel,
 };
 
 struct mocked_proxy_test_options {

data/aws-crt-ffi/crt/aws-c-http/tests/test_stream_manager.c

@@ -692,9 +692,9 @@ static int s_sm_tester_offer_waiting_connections(void) {
 
 static struct aws_http_connection_manager_system_vtable s_mocks;
 
-static void s_override_cm_connect_function(aws_http_connection_manager_create_connection_fn *fn) {
+static void s_override_cm_connect_function(int (*fn)(const struct aws_http_client_connection_options *options)) {
     s_mocks = *g_aws_http_connection_manager_default_system_vtable_ptr;
-    s_mocks.create_connection = fn;
+    s_mocks.aws_http_client_connect = fn;
     s_tester.connection_manager = s_tester.stream_manager->connection_manager;
     aws_http_connection_manager_set_system_vtable(s_tester.connection_manager, &s_mocks);
 }

data/aws-crt-ffi/crt/aws-c-io/include/aws/io/retry_strategy.h

@@ -110,7 +110,7 @@ struct aws_exponential_backoff_retry_options {
     struct aws_event_loop_group *el_group;
     /** Max retries to allow. The default value is 10 */
     size_t max_retries;
-    /** Scaling factor to add for the backoff. Default is 25ms */
+    /** Scaling factor to add for the backoff. Default is 500ms */
     uint32_t backoff_scale_factor_ms;
     /** Max retry backoff in seconds. Default is 20 seconds */
     uint32_t max_backoff_secs;

data/aws-crt-ffi/crt/aws-c-io/source/exponential_backoff_retry_strategy.c

@@ -373,7 +373,7 @@ struct aws_retry_strategy *aws_retry_strategy_new_exponential_backoff(
     }
 
     if (!exponential_backoff_strategy->config.backoff_scale_factor_ms) {
-        exponential_backoff_strategy->config.backoff_scale_factor_ms = 25;
+        exponential_backoff_strategy->config.backoff_scale_factor_ms = 500;
     }
 
     if (!exponential_backoff_strategy->config.max_backoff_secs) {

data/aws-crt-ffi/crt/aws-c-io/source/pkcs11_tls_op_handler.c

@@ -183,10 +183,8 @@ struct aws_custom_key_op_handler *aws_pkcs11_tls_op_handler_new(
         goto done;
     }
 
-    if (pkcs_user_pin != NULL) {
-        if (aws_pkcs11_lib_login_user(pkcs11_handler->lib, pkcs11_handler->session_handle, pkcs_user_pin)) {
-            goto done;
-        }
+    if (aws_pkcs11_lib_login_user(pkcs11_handler->lib, pkcs11_handler->session_handle, pkcs_user_pin)) {
+        goto done;
     }
 
     if (aws_pkcs11_lib_find_private_key(

data/aws-crt-ffi/crt/aws-lc/CMakeLists.txt

@@ -33,6 +33,7 @@ if(FIPS)
 
   if(ENABLE_FIPS_ENTROPY_CPU_JITTER)
     add_definitions(-DFIPS_ENTROPY_SOURCE_JITTER_CPU)
+    add_subdirectory(third_party/jitterentropy)
     message(STATUS "FIPS entropy source method configured: CPU Jitter")
   else()
     add_definitions(-DFIPS_ENTROPY_SOURCE_PASSIVE)
@@ -629,8 +630,13 @@ if(UBSAN)
 endif()
 
 if(GCOV)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage -O0")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage -O0")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+endif()
+
+if(KEEP_ASM_LOCAL_SYMBOLS)
+  set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -Wa,-L")
 endif()
 
 if(FIPS)
@@ -647,8 +653,6 @@ if(FIPS)
     message(FATAL_ERROR "Windows Debug build is not supported with FIPS, use Release or RelWithDebInfo")
   endif()
 
-  add_subdirectory(third_party/jitterentropy)
-
   add_definitions(-DBORINGSSL_FIPS)
   if(FIPS_BREAK_TEST)
     add_definitions("-DBORINGSSL_FIPS_BREAK_${FIPS_BREAK_TEST}=1")
@@ -701,7 +705,11 @@ endif()
 
 TEST_BIG_ENDIAN(BIG_ENDIAN)
 if(BIG_ENDIAN)
-  message(FATAL_ERROR "Big Endian is not supported.")
+  if(ENABLE_EXPERIMENTAL_BIG_ENDIAN_SUPPORT)
+    message(STATUS "Continuing with experimental support on big endian platform")
+  else()
+    message(FATAL_ERROR "Big Endian is not supported.")
+  endif()
 endif()
 
 if(OPENSSL_NO_SSE2_FOR_TESTING)
@@ -741,7 +749,7 @@ elseif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "riscv64")
 elseif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "loongarch64")
   set(ARCH "loongarch64")
 else()
-  message(STATUS "Unknown processor found. Using generic implementations. Processor:" ${CMAKE_SYSTEM_PROCESSOR})
+  message(STATUS "Unknown processor found. Using generic implementations. Processor: " ${CMAKE_SYSTEM_PROCESSOR})
   set(ARCH "generic")
 endif()
 
@@ -1051,7 +1059,7 @@ if(BUILD_TESTING)
     add_custom_target(
         run_tests_valgrind
         COMMAND ${GO_EXECUTABLE} run util/all_tests.go -build-dir
-                ${PROJECT_BINARY_DIR} -valgrind=true -valgrind-supp-dir "tests/ci"
+                ${PROJECT_BINARY_DIR} -valgrind=true -valgrind-supp-dir="tests/ci"
         WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
         DEPENDS all_tests
         ${MAYBE_USES_TERMINAL})
@@ -1059,7 +1067,7 @@ if(BUILD_TESTING)
     add_custom_target(
         run_tests_with_sde
         COMMAND ${GO_EXECUTABLE} run util/all_tests.go -build-dir
-                ${PROJECT_BINARY_DIR} -sde true -sde-path "$ENV{SDEROOT}/sde"
+                ${PROJECT_BINARY_DIR} -sde=true -sde-path="$ENV{SDEROOT}/sde"
         WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
         DEPENDS all_tests
         ${MAYBE_USES_TERMINAL})

data/aws-crt-ffi/crt/aws-lc/cmake/go.cmake

@@ -41,6 +41,12 @@ function(go_executable dest package)
     string(SUBSTRING "${CMAKE_CURRENT_BINARY_DIR}" ${root_dir_length} -1 target)
     set(target "${target}/${dest}")
 
+    if(CMAKE_VERSION VERSION_GREATER "3.19")
+      # Silences warning about CMP0116:
+      # https://cmake.org/cmake/help/latest/policy/CMP0116.html
+      cmake_policy(SET CMP0116 OLD)
+    endif()
+
     set(depfile "${CMAKE_CURRENT_BINARY_DIR}/${dest}.d")
     add_custom_command(OUTPUT ${dest}
                        COMMAND ${GO_EXECUTABLE} build

data/aws-crt-ffi/crt/aws-lc/crypto/CMakeLists.txt

@@ -142,7 +142,7 @@ else()
   if(DEFINED ASSEMBLY_SOURCE)
     if(EXISTS ${ASSEMBLY_SOURCE})
       message("Copying platform assembly files from ${ASSEMBLY_SOURCE} to ${CMAKE_CURRENT_BINARY_DIR}")
-      file(COPY ${ASSEMBLY_SOURCE}/ DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+      file(COPY ${ASSEMBLY_SOURCE}/ DESTINATION ${CMAKE_CURRENT_BINARY_DIR} NO_SOURCE_PERMISSIONS)
     else()
       message(STATUS "${ASSEMBLY_SOURCE} assembly files do not exist.")
     endif()
@@ -532,7 +532,9 @@ target_include_directories(crypto_objects BEFORE PRIVATE ${PROJECT_BINARY_DIR}/s
 target_include_directories(crypto_objects PRIVATE ${PROJECT_SOURCE_DIR}/include)
 
 function(build_libcrypto name module_source)
-  if(FIPS)
+  if(FIPS AND ENABLE_FIPS_ENTROPY_CPU_JITTER)
+    # If the jitter cpu entropy source is enabled add an object dependency to
+    # the libcrypto target.
     add_library(${name} $<TARGET_OBJECTS:crypto_objects> ${CRYPTO_FIPS_OBJECTS} ${module_source} $<TARGET_OBJECTS:jitterentropy>)
   else()
     add_library(${name} $<TARGET_OBJECTS:crypto_objects> ${CRYPTO_FIPS_OBJECTS} ${module_source})
@@ -679,13 +681,6 @@ if(BUILD_TESTING)
     fipsmodule/rand/urandom_test.cc
   )
 
-  # When using CPU Jitter as the entropy source (only in FIPS build)
-  # urandom_test should not be performed so we pass the compilation flag
-  # and handle it in urandom_test.cc
-  if(JITTER_ENTROPY)
-    target_compile_options(${RANDOM_TEST_EXEC} PUBLIC -DJITTER_ENTROPY)
-  endif()
-
   add_dependencies(${RANDOM_TEST_EXEC} boringssl_prefix_symbols)
   target_link_libraries(${RANDOM_TEST_EXEC} test_support_lib boringssl_gtest crypto)
   target_include_directories(${RANDOM_TEST_EXEC} BEFORE PRIVATE ${PROJECT_BINARY_DIR}/symbol_prefix_include)
@@ -717,12 +712,14 @@ if(BUILD_TESTING)
     digest_extra/digest_test.cc
     dilithium/p_dilithium_test.cc
     dsa/dsa_test.cc
+    endian_test.cc
     err/err_test.cc
     evp_extra/evp_extra_test.cc
     evp_extra/evp_test.cc
     evp_extra/scrypt_test.cc
     fipsmodule/aes/aes_test.cc
     fipsmodule/bn/bn_test.cc
+    fipsmodule/bn/bn_assert_test.cc
     fipsmodule/cmac/cmac_test.cc
     fipsmodule/ec/ec_test.cc
     fipsmodule/ec/p256-nistz_test.cc