aws-crt 0.1.5 → 0.1.6

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

@@ -552,7 +552,7 @@ struct aws_http_message *aws_http_message_release(struct aws_http_message *messa
         }
 
         aws_http_headers_release(message->headers);
-
+        aws_input_stream_release(message->body_stream);
         aws_mem_release(message->allocator, message);
     } else {
         AWS_ASSERT(prev_refcount != 0);
@@ -727,7 +727,13 @@ int aws_http_message_set_response_status(struct aws_http_message *response_messa
 
 void aws_http_message_set_body_stream(struct aws_http_message *message, struct aws_input_stream *body_stream) {
     AWS_PRECONDITION(message);
+    /* release previous stream, if any */
+    aws_input_stream_release(message->body_stream);
+
     message->body_stream = body_stream;
+    if (message->body_stream) {
+        aws_input_stream_acquire(message->body_stream);
+    }
 }
 
 int aws_http1_stream_write_chunk(struct aws_http_stream *http1_stream, const struct aws_http1_chunk_options *options) {
@@ -745,6 +751,17 @@ int aws_http1_stream_write_chunk(struct aws_http_stream *http1_stream, const str
     return http1_stream->vtable->http1_write_chunk(http1_stream, options);
 }
 
+int aws_http2_stream_write_data(
+    struct aws_http_stream *http2_stream,
+    const struct aws_http2_stream_write_data_options *options) {
+    AWS_PRECONDITION(http2_stream);
+    AWS_PRECONDITION(http2_stream->vtable);
+    AWS_PRECONDITION(http2_stream->vtable->http2_write_data);
+    AWS_PRECONDITION(options);
+
+    return http2_stream->vtable->http2_write_data(http2_stream, options);
+}
+
 int aws_http1_stream_add_chunked_trailer(
     struct aws_http_stream *http1_stream,
     const struct aws_http_headers *trailing_headers) {
@@ -767,7 +784,7 @@ struct aws_input_stream *aws_http_message_get_body_stream(const struct aws_http_
     return message->body_stream;
 }
 
-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) {
     AWS_PRECONDITION(message);
     return message->headers;
 }
@@ -835,8 +852,8 @@ struct aws_http_stream *aws_http_connection_make_request(
 }
 
 struct aws_http_message *aws_http2_message_new_from_http1(
-    struct aws_http_message *http1_msg,
-    struct aws_allocator *alloc) {
+    struct aws_allocator *alloc,
+    const struct aws_http_message *http1_msg) {
 
     struct aws_http_headers *old_headers = aws_http_message_get_headers(http1_msg);
     struct aws_http_header header_iter;
@@ -844,11 +861,12 @@ struct aws_http_message *aws_http2_message_new_from_http1(
     AWS_ZERO_STRUCT(lower_name_buf);
     struct aws_http_message *message = aws_http_message_is_request(http1_msg) ? aws_http2_message_new_request(alloc)
                                                                               : aws_http2_message_new_response(alloc);
-    struct aws_http_headers *copied_headers = message->headers;
     if (!message) {
         return NULL;
     }
-    AWS_LOGF_TRACE(AWS_LS_HTTP_GENERAL, "Creating HTTP/2 message from HTTP/1 message id: %p", (void *)http1_msg)
+    struct aws_http_headers *copied_headers = message->headers;
+    AWS_LOGF_TRACE(AWS_LS_HTTP_GENERAL, "Creating HTTP/2 message from HTTP/1 message id: %p", (void *)http1_msg);
+
     /* Set pseudo headers from HTTP/1.1 message */
     if (aws_http_message_is_request(http1_msg)) {
         struct aws_byte_cursor method;
@@ -861,7 +879,7 @@ struct aws_http_message *aws_http2_message_new_from_http1(
             aws_raise_error(AWS_ERROR_HTTP_INVALID_METHOD);
             goto error;
         }
-        /* Use add intead of set method to avoid push front to the array list */
+        /* Use add instead of set method to avoid push front to the array list */
         if (aws_http_headers_add(copied_headers, aws_http_header_method, method)) {
             goto error;
         }
@@ -887,7 +905,28 @@ struct aws_http_message *aws_http2_message_new_from_http1(
             aws_http_header_scheme.ptr,
             (int)scheme_cursor.len,
             scheme_cursor.ptr);
-        /* :authority SHOULD NOT be created when translating HTTP/1 request.(RFC 7540 8.1.2.3) */
+
+        /**
+         * An intermediary that forwards a request over HTTP/2 MUST construct an ":authority" pseudo-header field using
+         * the authority information from the control data of the original request. (RFC=9113 8.3.1)
+         */
+        struct aws_byte_cursor host_value;
+        AWS_ZERO_STRUCT(host_value);
+        if (aws_http_headers_get(http1_msg->headers, aws_byte_cursor_from_c_str("host"), &host_value) ==
+            AWS_OP_SUCCESS) {
+            if (aws_http_headers_add(copied_headers, aws_http_header_authority, host_value)) {
+                goto error;
+            }
+            AWS_LOGF_TRACE(
+                AWS_LS_HTTP_GENERAL,
+                "Added header to new HTTP/2 header - \"%.*s\": \"%.*s\" ",
+                (int)aws_http_header_authority.len,
+                aws_http_header_authority.ptr,
+                (int)host_value.len,
+                host_value.ptr);
+        }
+        /* TODO: If the host headers is missing, the target URI could be the other source of the authority information
+         */
 
         struct aws_byte_cursor path_cursor;
         if (aws_http_message_get_request_path(http1_msg, &path_cursor)) {
@@ -935,6 +974,8 @@ struct aws_http_message *aws_http2_message_new_from_http1(
         goto error;
     }
     for (size_t iter = 0; iter < aws_http_headers_count(old_headers); iter++) {
+        aws_byte_buf_reset(&lower_name_buf, false);
+        bool copy_header = true;
         /* name should be converted to lower case */
         if (aws_http_headers_get_index(old_headers, iter, &header_iter)) {
             goto error;
@@ -942,23 +983,42 @@ struct aws_http_message *aws_http2_message_new_from_http1(
         /* append lower case name to the buffer */
         aws_byte_buf_append_with_lookup(&lower_name_buf, &header_iter.name, aws_lookup_table_to_lower_get());
         struct aws_byte_cursor lower_name_cursor = aws_byte_cursor_from_buf(&lower_name_buf);
+        enum aws_http_header_name name_enum = aws_http_lowercase_str_to_header_name(lower_name_cursor);
+        switch (name_enum) {
+            case AWS_HTTP_HEADER_TRANSFER_ENCODING:
+            case AWS_HTTP_HEADER_UPGRADE:
+            case AWS_HTTP_HEADER_KEEP_ALIVE:
+            case AWS_HTTP_HEADER_PROXY_CONNECTION:
+                /**
+                 * An intermediary transforming an HTTP/1.x message to HTTP/2 MUST remove connection-specific header
+                 * fields as discussed in Section 7.6.1 of [HTTP]. (RFC=9113 8.2.2)
+                 */
+                AWS_LOGF_TRACE(
+                    AWS_LS_HTTP_GENERAL,
+                    "Skip connection-specific headers - \"%.*s\" ",
+                    (int)lower_name_cursor.len,
+                    lower_name_cursor.ptr);
+                copy_header = false;
+                break;
 
-        /* TODO: handle connection-specific header field (RFC7540 8.1.2.2) */
-        if (aws_http_headers_add(copied_headers, lower_name_cursor, header_iter.value)) {
-            goto error;
+            default:
+                break;
+        }
+        if (copy_header) {
+            if (aws_http_headers_add(copied_headers, lower_name_cursor, header_iter.value)) {
+                goto error;
+            }
+            AWS_LOGF_TRACE(
+                AWS_LS_HTTP_GENERAL,
+                "Added header to new HTTP/2 header - \"%.*s\": \"%.*s\" ",
+                (int)lower_name_cursor.len,
+                lower_name_cursor.ptr,
+                (int)header_iter.value.len,
+                header_iter.value.ptr);
         }
-        AWS_LOGF_TRACE(
-            AWS_LS_HTTP_GENERAL,
-            "Added header to new HTTP/2 header - \"%.*s\": \"%.*s\" ",
-            (int)lower_name_cursor.len,
-            lower_name_cursor.ptr,
-            (int)header_iter.value.len,
-            header_iter.value.ptr);
-        aws_byte_buf_reset(&lower_name_buf, false);
     }
     aws_byte_buf_clean_up(&lower_name_buf);
     aws_http_message_set_body_stream(message, aws_http_message_get_body_stream(http1_msg));
-    /* TODO: Refcount the input stream of old message */
 
     return message;
 error:

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

@@ -22,3 +22,14 @@ void aws_crt_statistics_http1_channel_reset(struct aws_crt_statistics_http1_chan
     stats->current_outgoing_stream_id = 0;
     stats->current_incoming_stream_id = 0;
 }
+
+void aws_crt_statistics_http2_channel_init(struct aws_crt_statistics_http2_channel *stats) {
+    AWS_ZERO_STRUCT(*stats);
+    stats->category = AWSCRT_STAT_CAT_HTTP2_CHANNEL;
+}
+
+void aws_crt_statistics_http2_channel_reset(struct aws_crt_statistics_http2_channel *stats) {
+    stats->pending_outgoing_stream_ms = 0;
+    stats->pending_incoming_stream_ms = 0;
+    stats->was_inactive = false;
+}

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

@@ -246,6 +246,14 @@ add_test_case(hpack_dynamic_table_empty_value)
 add_test_case(hpack_dynamic_table_with_empty_header)
 add_test_case(hpack_dynamic_table_size_update_from_setting)
 
+if (ENABLE_LOCALHOST_INTEGRATION_TESTS)
+    # Tests should be named with localhost_integ_*
+    add_net_test_case(localhost_integ_hpack_stress)
+    add_net_test_case(localhost_integ_hpack_compression_stress)
+    add_net_test_case(localhost_integ_h2_upload_stress)
+    add_net_test_case(localhost_integ_h2_download_stress)
+endif()
+
 add_test_case(h2_header_empty_payload)
 add_one_byte_at_a_time_test_set(h2_header_ex_2_1)
 add_one_byte_at_a_time_test_set(h2_header_ex_2_2)
@@ -390,6 +398,7 @@ add_test_case(h2_client_stream_receive_trailing_headers)
 add_test_case(h2_client_stream_err_receive_trailing_before_main)
 add_test_case(h2_client_stream_receive_data)
 add_test_case(h2_client_stream_err_receive_data_before_headers)
+add_test_case(h2_client_stream_err_receive_data_not_match_content_length)
 add_test_case(h2_client_stream_send_data)
 add_test_case(h2_client_stream_send_lots_of_data)
 add_test_case(h2_client_stream_send_stalled_data)
@@ -445,6 +454,13 @@ add_test_case(h2_client_get_received_goaway)
 add_test_case(h2_client_request_apis_failed_after_connection_begin_shutdown)
 add_test_case(h2_client_get_local_settings)
 add_test_case(h2_client_get_remote_settings)
+add_test_case(h2_client_error_from_outgoing_body_callback_reset_stream)
+add_test_case(h2_client_error_from_incoming_headers_callback_reset_stream)
+add_test_case(h2_client_error_from_incoming_headers_done_callback_reset_stream)
+add_test_case(h2_client_error_from_incoming_body_callback_reset_stream)
+add_test_case(h2_client_manual_data_write)
+add_test_case(h2_client_manual_data_write_no_data)
+add_test_case(h2_client_manual_data_write_connection_close)
 
 add_test_case(server_new_destroy)
 add_test_case(connection_setup_shutdown)
@@ -592,15 +608,26 @@ add_net_test_case(h2_sm_mock_multiple_connections)
 add_net_test_case(h2_sm_mock_bad_connection_acquired)
 add_net_test_case(h2_sm_mock_connections_closed_before_request_made)
 add_net_test_case(h2_sm_mock_max_concurrent_streams_remote)
+add_net_test_case(h2_sm_mock_fetch_metric)
 add_net_test_case(h2_sm_mock_complete_stream)
 add_net_test_case(h2_sm_mock_ideal_num_streams)
 add_net_test_case(h2_sm_mock_large_ideal_num_streams)
 add_net_test_case(h2_sm_mock_goaway)
+add_net_test_case(h2_sm_connection_ping)
 
+# Tests against real world server
 add_net_test_case(h2_sm_acquire_stream)
 add_net_test_case(h2_sm_acquire_stream_multiple_connections)
-add_net_test_case(h2_sm_acquire_stream_stress)
 add_net_test_case(h2_sm_closing_before_connection_acquired)
+add_net_test_case(h2_sm_close_connection_on_server_error)
+# Tests against local server
+if (ENABLE_LOCALHOST_INTEGRATION_TESTS)
+    # Tests should be named with localhost_integ_*
+    add_net_test_case(localhost_integ_h2_sm_prior_knowledge)
+    add_net_test_case(localhost_integ_h2_sm_acquire_stream_stress)
+    add_net_test_case(localhost_integ_h2_sm_acquire_stream_stress_with_body)
+    add_net_test_case(localhost_integ_h2_sm_connection_monitor_kill_slow_connection)
+endif()
 
 add_test_case(random_access_set_sanitize_test)
 add_test_case(random_access_set_insert_test)

data/aws-crt-ffi/crt/aws-c-http/tests/fuzz/fuzz_h2_decoder_correct.c

@@ -42,8 +42,10 @@ static struct aws_http_headers *s_generate_headers(
         struct aws_http_header path = {.name = aws_http_header_path, .value = aws_byte_cursor_from_c_str("/")};
         aws_http_headers_add_header(headers, &path);
 
-        struct aws_http_header authority = {.name = aws_http_header_authority,
-                                            .value = aws_byte_cursor_from_c_str("example.com")};
+        struct aws_http_header authority = {
+            .name = aws_http_header_authority,
+            .value = aws_byte_cursor_from_c_str("example.com"),
+        };
         aws_http_headers_add_header(headers, &authority);
 
     } else if (header_style == HEADER_STYLE_RESPONSE) {
@@ -252,7 +254,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
             struct aws_stream_status body_status;
             aws_input_stream_get_status(body, &body_status);
             AWS_FATAL_ASSERT(body_complete == body_status.is_end_of_stream)
-            aws_input_stream_destroy(body);
+            aws_input_stream_release(body);
             break;
         }
         case AWS_H2_FRAME_T_HEADERS: {

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

@@ -261,7 +261,6 @@ static struct aws_h2err s_decoder_on_headers_end(
     bool malformed,
     enum aws_http_header_block block_type,
     void *userdata) {
-
     return s_on_headers_end(false /*is_push_promise*/, stream_id, malformed, block_type, userdata);
 }
 
@@ -611,7 +610,7 @@ int h2_fake_peer_send_data_frame_with_padding_length(
     ASSERT_TRUE(msg->message_data.len != 0);
 
     ASSERT_SUCCESS(testing_channel_push_read_message(peer->testing_channel, msg));
-    aws_input_stream_destroy(body_stream);
+    aws_input_stream_release(body_stream);
     return AWS_OP_SUCCESS;
 }
 
@@ -643,6 +642,8 @@ int h2_fake_peer_send_connection_preface_default_settings(struct h2_fake_peer *p
 /******************************************************************************/
 
 struct aws_input_stream_tester {
+    struct aws_input_stream base;
+    struct aws_allocator *allocator;
     /* aws_input_stream_byte_cursor provides our actual functionality  */
     struct aws_input_stream *cursor_stream;
 
@@ -655,12 +656,12 @@ static int s_aws_input_stream_tester_seek(
     int64_t offset,
     enum aws_stream_seek_basis basis) {
 
-    struct aws_input_stream_tester *impl = stream->impl;
+    struct aws_input_stream_tester *impl = AWS_CONTAINER_OF(stream, struct aws_input_stream_tester, base);
     return aws_input_stream_seek(impl->cursor_stream, offset, basis);
 }
 
 static int s_aws_input_stream_tester_read(struct aws_input_stream *stream, struct aws_byte_buf *dest) {
-    struct aws_input_stream_tester *impl = stream->impl;
+    struct aws_input_stream_tester *impl = AWS_CONTAINER_OF(stream, struct aws_input_stream_tester, base);
 
     if (impl->is_reading_broken) {
         return aws_raise_error(AWS_IO_STREAM_READ_FAILED);
@@ -678,21 +679,18 @@ static int s_aws_input_stream_tester_read(struct aws_input_stream *stream, struc
 }
 
 static int s_aws_input_stream_tester_get_status(struct aws_input_stream *stream, struct aws_stream_status *status) {
-    struct aws_input_stream_tester *impl = stream->impl;
+    struct aws_input_stream_tester *impl = AWS_CONTAINER_OF(stream, struct aws_input_stream_tester, base);
     return aws_input_stream_get_status(impl->cursor_stream, status);
 }
 
 static int s_aws_input_stream_tester_get_length(struct aws_input_stream *stream, int64_t *out_length) {
-    struct aws_input_stream_tester *impl = stream->impl;
+    struct aws_input_stream_tester *impl = AWS_CONTAINER_OF(stream, struct aws_input_stream_tester, base);
     return aws_input_stream_get_length(impl->cursor_stream, out_length);
 }
 
-static void s_aws_input_stream_tester_destroy(struct aws_input_stream *stream) {
-    if (stream) {
-        struct aws_input_stream_tester *impl = stream->impl;
-        aws_input_stream_destroy(impl->cursor_stream);
-        aws_mem_release(stream->allocator, stream);
-    }
+static void s_aws_input_stream_tester_destroy(struct aws_input_stream_tester *impl) {
+    aws_input_stream_release(impl->cursor_stream);
+    aws_mem_release(impl->allocator, impl);
 }
 
 static struct aws_input_stream_vtable s_aws_input_stream_tester_vtable = {
@@ -700,38 +698,144 @@ static struct aws_input_stream_vtable s_aws_input_stream_tester_vtable = {
     .read = s_aws_input_stream_tester_read,
     .get_status = s_aws_input_stream_tester_get_status,
     .get_length = s_aws_input_stream_tester_get_length,
-    .destroy = s_aws_input_stream_tester_destroy,
 };
 
 struct aws_input_stream *aws_input_stream_new_tester(struct aws_allocator *alloc, struct aws_byte_cursor cursor) {
 
-    struct aws_input_stream *stream = NULL;
-    struct aws_input_stream_tester *impl = NULL;
-    aws_mem_acquire_many(
-        alloc, 2, &stream, sizeof(struct aws_input_stream), &impl, sizeof(struct aws_input_stream_tester));
-    AWS_FATAL_ASSERT(stream);
-
-    AWS_ZERO_STRUCT(*stream);
-    AWS_ZERO_STRUCT(*impl);
-
-    stream->allocator = alloc;
-    stream->impl = impl;
-    stream->vtable = &s_aws_input_stream_tester_vtable;
+    struct aws_input_stream_tester *impl = aws_mem_calloc(alloc, 1, sizeof(struct aws_input_stream_tester));
+    AWS_FATAL_ASSERT(impl);
 
     impl->max_bytes_per_read = SIZE_MAX;
 
     impl->cursor_stream = aws_input_stream_new_from_cursor(alloc, &cursor);
     AWS_FATAL_ASSERT(impl->cursor_stream);
-
-    return stream;
+    impl->allocator = alloc;
+    impl->base.vtable = &s_aws_input_stream_tester_vtable;
+    aws_ref_count_init(
+        &impl->base.ref_count, impl, (aws_simple_completion_callback *)s_aws_input_stream_tester_destroy);
+    return &impl->base;
 }
 
 void aws_input_stream_tester_set_max_bytes_per_read(struct aws_input_stream *input_stream, size_t max_bytes) {
-    struct aws_input_stream_tester *impl = input_stream->impl;
+    struct aws_input_stream_tester *impl = AWS_CONTAINER_OF(input_stream, struct aws_input_stream_tester, base);
     impl->max_bytes_per_read = max_bytes;
 }
 
 void aws_input_stream_tester_set_reading_broken(struct aws_input_stream *input_stream, bool is_broken) {
-    struct aws_input_stream_tester *impl = input_stream->impl;
+    struct aws_input_stream_tester *impl = AWS_CONTAINER_OF(input_stream, struct aws_input_stream_tester, base);
     impl->is_reading_broken = is_broken;
 }
+
+struct aws_input_stream_tester_upload_impl {
+    struct aws_input_stream base;
+    size_t position;
+    size_t length;
+    size_t num_sentence_sent;
+    struct aws_allocator *allocator;
+};
+
+static int s_aws_input_stream_tester_upload_seek(
+    struct aws_input_stream *stream,
+    int64_t offset,
+    enum aws_stream_seek_basis basis) {
+    (void)stream;
+    (void)offset;
+    (void)basis;
+
+    /* Stream should never be seeked; all reads should be sequential. */
+    aws_raise_error(AWS_ERROR_UNKNOWN);
+    return AWS_OP_ERR;
+}
+
+const struct aws_byte_cursor s_test_string = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("This is CRT HTTP test.");
+
+static int s_aws_input_stream_tester_upload_read(struct aws_input_stream *stream, struct aws_byte_buf *dest) {
+    (void)stream;
+    (void)dest;
+
+    struct aws_input_stream_tester_upload_impl *test_input_stream =
+        AWS_CONTAINER_OF(stream, struct aws_input_stream_tester_upload_impl, base);
+
+    while (dest->len < dest->capacity && test_input_stream->length - test_input_stream->position > 0) {
+        size_t buffer_pos = test_input_stream->position % s_test_string.len;
+
+        struct aws_byte_cursor source_byte_cursor = {
+            .len = s_test_string.len - buffer_pos,
+            .ptr = s_test_string.ptr + buffer_pos,
+        };
+
+        size_t remaining_in_buffer =
+            aws_min_size(dest->capacity - dest->len, test_input_stream->length - test_input_stream->position);
+
+        if (remaining_in_buffer < source_byte_cursor.len) {
+            source_byte_cursor.len = remaining_in_buffer;
+        }
+
+        aws_byte_buf_append(dest, &source_byte_cursor);
+        buffer_pos += source_byte_cursor.len;
+
+        test_input_stream->position += source_byte_cursor.len;
+    }
+
+    return AWS_OP_SUCCESS;
+}
+
+static int s_aws_input_stream_tester_upload_get_status(
+    struct aws_input_stream *stream,
+    struct aws_stream_status *status) {
+    (void)stream;
+    (void)status;
+
+    struct aws_input_stream_tester_upload_impl *test_input_stream =
+        AWS_CONTAINER_OF(stream, struct aws_input_stream_tester_upload_impl, base);
+
+    status->is_end_of_stream = test_input_stream->position == test_input_stream->length;
+    status->is_valid = true;
+
+    return AWS_OP_SUCCESS;
+}
+
+static int s_aws_input_stream_tester_upload_get_length(struct aws_input_stream *stream, int64_t *out_length) {
+    AWS_ASSERT(stream != NULL);
+    struct aws_input_stream_tester_upload_impl *test_input_stream =
+        AWS_CONTAINER_OF(stream, struct aws_input_stream_tester_upload_impl, base);
+    *out_length = (int64_t)test_input_stream->length;
+    return AWS_OP_SUCCESS;
+}
+
+static void s_aws_input_stream_tester_upload_destroy(struct aws_input_stream_tester_upload_impl *test_input_stream) {
+    aws_mem_release(test_input_stream->allocator, test_input_stream);
+}
+
+static struct aws_input_stream_vtable s_aws_input_stream_tester_upload_vtable = {
+    .seek = s_aws_input_stream_tester_upload_seek,
+    .read = s_aws_input_stream_tester_upload_read,
+    .get_status = s_aws_input_stream_tester_upload_get_status,
+    .get_length = s_aws_input_stream_tester_upload_get_length,
+};
+
+struct aws_input_stream *aws_input_stream_tester_upload_new(struct aws_allocator *alloc, size_t length) {
+
+    struct aws_input_stream_tester_upload_impl *test_input_stream =
+        aws_mem_calloc(alloc, 1, sizeof(struct aws_input_stream_tester_upload_impl));
+    test_input_stream->base.vtable = &s_aws_input_stream_tester_upload_vtable;
+    aws_ref_count_init(
+        &test_input_stream->base.ref_count,
+        test_input_stream,
+        (aws_simple_completion_callback *)s_aws_input_stream_tester_upload_destroy);
+
+    struct aws_input_stream *input_stream = &test_input_stream->base;
+
+    test_input_stream->position = 0;
+    test_input_stream->length = length;
+    test_input_stream->allocator = alloc;
+    test_input_stream->num_sentence_sent = length / s_test_string.len;
+
+    return input_stream;
+}
+
+size_t aws_input_stream_tester_upload_get_num_sentence_sent(struct aws_input_stream *stream) {
+    struct aws_input_stream_tester_upload_impl *test_input_stream =
+        AWS_CONTAINER_OF(stream, struct aws_input_stream_tester_upload_impl, base);
+    return test_input_stream->num_sentence_sent;
+}

data/aws-crt-ffi/crt/aws-c-http/tests/h2_test_helper.h

@@ -268,4 +268,10 @@ void aws_input_stream_tester_set_max_bytes_per_read(struct aws_input_stream *inp
 
 void aws_input_stream_tester_set_reading_broken(struct aws_input_stream *input_stream, bool is_broken);
 
+/**
+ * Create input stream that can upload a certain length of stuff
+ */
+struct aws_input_stream *aws_input_stream_tester_upload_new(struct aws_allocator *alloc, size_t length);
+size_t aws_input_stream_tester_upload_get_num_sentence_sent(struct aws_input_stream *stream);
+
 #endif /* AWS_HTTP_H2_TEST_HELPER_H */

data/aws-crt-ffi/crt/aws-c-http/tests/py_localhost/README.md

@@ -0,0 +1,40 @@
+# Local server
+
+Local server based on [python-hyper/h2](https://github.com/python-hyper/h2).
+
+## How to run the server
+
+Python 3.5+ required.
+
+- Install hyper h2 python module. `python3 -m pip install h2`
+
+### TLS server
+
+- The code is based the [example](https://github.com/python-hyper/h2/blob/master/examples/asyncio/asyncio-server.py) from hyper h2 server.
+- Have the cert/key ready. The script now using `../resources/unittests.crt`, you can either just run the script within this directory, which will find the certificates and key from the related path, or you can use your own and change the code coordinately.
+- Run python. `python3 ./server.py`.
+
+#### Echo
+
+- Minor changed based on the example to response the headers of requests back within the headers from `/echo`.
+- To test the server runs correctly, you can do `curl -k -v -H "foo:bar" https://localhost:8443/echo` and check the result.
+
+#### Download test
+
+- To test download, when `:path` is `/downloadTest`, server will response a repeated string with length `self.download_test_length`, which is 2,500,000,000 now. It will be repeats of sting "This is CRT HTTP test."
+- To test the server runs correctly, you can do `curl -k -v -H "foo:bar" https://localhost:8443/downloadTest` and check the result.
+
+#### Slow Connection Test
+
+- Simulate a slow connection when `:path` is `/slowConnTest`. The speed is controlled by `out_bytes_per_second`. Default speed is 900 B/s, which will send 900 bytes of data and wait a sec to send new 900 bytes of data.
+
+#### Upload test
+
+- To test upload, when `:method` is `POST` or `PUT`, server will response the length received from response body
+- To test the server runs correctly, you can do `curl -k -X POST -F'data=@upload_test.txt' https://localhost:8443/upload_test` where `upload_test.txt` is file to upload.
+
+### Non-TLS server
+
+- The code is based the non-tls [example](http://python-hyper.org/projects/h2/en/stable/basic-usage.html) from hyper h2 server.
+- Run python. `python3 ./non_tls_server.py`.
+- To test the server runs correctly, you can do `curl -v --http2-prior-knowledge http://localhost:8080` and check the result.

data/aws-crt-ffi/crt/aws-c-http/tests/py_localhost/non_tls_server.py

@@ -0,0 +1,56 @@
+# example server from http://python-hyper.org/projects/h2/en/stable/basic-usage.html
+
+import json
+import socket
+
+import h2.connection
+import h2.events
+import h2.config
+
+
+def send_response(conn, event):
+    stream_id = event.stream_id
+    response_data = b"success"
+
+    conn.send_headers(
+        stream_id=stream_id,
+        headers=[
+            (':status', '200'),
+            ('content-length', str(len(response_data))),
+        ],
+    )
+    conn.send_data(
+        stream_id=stream_id,
+        data=response_data,
+        end_stream=True
+    )
+
+
+def handle(sock):
+    config = h2.config.H2Configuration(client_side=False)
+    conn = h2.connection.H2Connection(config=config)
+    conn.initiate_connection()
+    sock.sendall(conn.data_to_send())
+
+    while True:
+        data = sock.recv(65535)
+        if not data:
+            break
+
+        events = conn.receive_data(data)
+        for event in events:
+            if isinstance(event, h2.events.RequestReceived):
+                send_response(conn, event)
+
+        data_to_send = conn.data_to_send()
+        if data_to_send:
+            sock.sendall(data_to_send)
+
+
+sock = socket.socket()
+sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+sock.bind(('0.0.0.0', 8080))
+sock.listen(5)
+
+while True:
+    handle(sock.accept()[0])