aws-crt 0.1.5 → 0.1.6

data/aws-crt-ffi/crt/aws-c-common/tests/json_test.c

@@ -0,0 +1,134 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/testing/aws_test_harness.h>
+
+#include <aws/common/byte_buf.h>
+#include <aws/common/string.h>
+
+#include <aws/common/json.h>
+
+static char *s_test_json = "{\"array\":[1,2,3],\"boolean\":true,\"color\":\"gold\",\"null\":null,\"number\":123,"
+                           "\"object\":{\"a\":\"b\",\"c\":\"d\"}}";
+
+AWS_TEST_CASE(test_json_parse_from_string, s_test_json_parse_from_string)
+static int s_test_json_parse_from_string(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+
+    aws_common_library_init(allocator);
+    struct aws_json_value *root = aws_json_value_new_from_string(allocator, aws_byte_cursor_from_c_str(s_test_json));
+
+    ASSERT_NOT_NULL(root);
+    ASSERT_TRUE(aws_json_value_is_object(root));
+
+    // Testing valid array
+    struct aws_json_value *array_node = aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("array"));
+    ASSERT_NOT_NULL(array_node);
+    ASSERT_TRUE(aws_json_value_is_array(array_node));
+    ASSERT_TRUE(aws_json_get_array_size(array_node) == 3);
+    struct aws_json_value *array_node_one = aws_json_get_array_element(array_node, 0);
+    ASSERT_NOT_NULL(array_node_one);
+    ASSERT_TRUE(aws_json_value_is_number(array_node_one));
+    double double_check_value = 0;
+    ASSERT_INT_EQUALS(AWS_OP_SUCCESS, aws_json_value_get_number(array_node_one, &double_check_value));
+    ASSERT_NOT_NULL(double_check_value);
+    ASSERT_TRUE(double_check_value == (double)1);
+
+    // Testing valid boolean
+    struct aws_json_value *boolean_node = aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("boolean"));
+    ASSERT_NOT_NULL(boolean_node);
+    ASSERT_TRUE(aws_json_value_is_boolean(boolean_node));
+    bool bool_check_value = false;
+    aws_json_value_get_boolean(boolean_node, &bool_check_value);
+    ASSERT_TRUE(bool_check_value);
+
+    // Testing valid string
+    struct aws_json_value *string_node = aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("color"));
+    ASSERT_NOT_NULL(string_node);
+    ASSERT_TRUE(aws_json_value_is_string(string_node));
+    struct aws_byte_cursor str_string_check_value;
+    aws_json_value_get_string(string_node, &str_string_check_value);
+    struct aws_string *tmp_str = aws_string_new_from_cursor(allocator, &str_string_check_value);
+    ASSERT_TRUE(strcmp(aws_string_c_str(tmp_str), "gold") == 0);
+    aws_string_destroy_secure(tmp_str);
+
+    // Testing valid number
+    struct aws_json_value *number_node = aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("number"));
+    ASSERT_NOT_NULL(number_node);
+    ASSERT_TRUE(aws_json_value_is_number(number_node));
+    double double_test_two = 0;
+    aws_json_value_get_number(number_node, &double_test_two);
+    ASSERT_TRUE(double_test_two == (double)123);
+
+    // Testing valid object
+    struct aws_json_value *object_node = aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("object"));
+    ASSERT_NOT_NULL(object_node);
+    ASSERT_TRUE(aws_json_value_is_object(object_node));
+    struct aws_json_value *sub_object_node =
+        aws_json_value_get_from_object(object_node, aws_byte_cursor_from_c_str("a"));
+    ASSERT_NOT_NULL(sub_object_node);
+    ASSERT_TRUE(aws_json_value_is_string(sub_object_node));
+    struct aws_byte_cursor str_a_value_cursor;
+    aws_json_value_get_string(sub_object_node, &str_a_value_cursor);
+    struct aws_string *sub_a_string = aws_string_new_from_cursor(allocator, &str_a_value_cursor);
+    ASSERT_TRUE(strcmp(aws_string_c_str(sub_a_string), "b") == 0);
+    aws_string_destroy_secure(sub_a_string);
+
+    // Testing invalid object
+    struct aws_json_value *invalid_object = aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("invalid"));
+    ASSERT_NULL(invalid_object);
+    ASSERT_INT_EQUALS(aws_json_value_get_number(invalid_object, NULL), AWS_OP_ERR);
+    // Test getting invalid type of data
+    ASSERT_INT_EQUALS(aws_json_value_get_number(string_node, NULL), AWS_OP_ERR);
+
+    aws_json_value_destroy(root);
+    aws_common_library_clean_up();
+
+    return AWS_OP_SUCCESS;
+}
+
+AWS_TEST_CASE(test_json_parse_to_string, s_test_json_parse_to_string)
+static int s_test_json_parse_to_string(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+
+    aws_common_library_init(allocator);
+    struct aws_json_value *root = aws_json_value_new_object(allocator);
+
+    struct aws_json_value *array = aws_json_value_new_array(allocator);
+    aws_json_value_add_array_element(array, aws_json_value_new_number(allocator, 1));
+    aws_json_value_add_array_element(array, aws_json_value_new_number(allocator, 2));
+    aws_json_value_add_array_element(array, aws_json_value_new_number(allocator, 3));
+    aws_json_value_add_to_object(root, aws_byte_cursor_from_c_str("array"), array);
+
+    aws_json_value_add_to_object(
+        root, aws_byte_cursor_from_c_str("boolean"), aws_json_value_new_boolean(allocator, true));
+    aws_json_value_add_to_object(
+        root,
+        aws_byte_cursor_from_c_str("color"),
+        aws_json_value_new_string(allocator, aws_byte_cursor_from_c_str("gold")));
+    aws_json_value_add_to_object(root, aws_byte_cursor_from_c_str("null"), aws_json_value_new_null(allocator));
+    aws_json_value_add_to_object(root, aws_byte_cursor_from_c_str("number"), aws_json_value_new_number(allocator, 123));
+
+    struct aws_json_value *object = aws_json_value_new_object(allocator);
+    aws_json_value_add_to_object(
+        object, aws_byte_cursor_from_c_str("a"), aws_json_value_new_string(allocator, aws_byte_cursor_from_c_str("b")));
+    aws_json_value_add_to_object(
+        object, aws_byte_cursor_from_c_str("c"), aws_json_value_new_string(allocator, aws_byte_cursor_from_c_str("d")));
+    aws_json_value_add_to_object(root, aws_byte_cursor_from_c_str("object"), object);
+
+    struct aws_byte_buf result_string_buf;
+    aws_byte_buf_init(&result_string_buf, allocator, 0);
+
+    ASSERT_INT_EQUALS(AWS_OP_SUCCESS, aws_byte_buf_append_json_string(root, &result_string_buf));
+    struct aws_string *result_string = aws_string_new_from_buf(allocator, &result_string_buf);
+    ASSERT_STR_EQUALS(s_test_json, aws_string_c_str(result_string));
+    aws_byte_buf_clean_up_secure(&result_string_buf);
+    aws_string_destroy_secure(result_string);
+
+    aws_json_value_destroy(root);
+    aws_common_library_clean_up();
+
+    return AWS_OP_SUCCESS;
+}

data/aws-crt-ffi/crt/aws-c-common/tests/memtrace_test.c

@@ -147,10 +147,16 @@ static int s_test_memtrace_stacks(struct aws_allocator *allocator, void *ctx) {
     char s_alloc_2_addr[32];
     char s_alloc_3_addr[32];
     char s_alloc_4_addr[32];
+#    if defined(_MSC_VER)
+#        pragma warning(push)
+#        pragma warning(disable : 4054) /* type cast function pointer to data pointer */
     snprintf(s_alloc_1_addr, AWS_ARRAY_SIZE(s_alloc_1_addr), "0x%tx", (uintptr_t)(void *)s_alloc_1);
     snprintf(s_alloc_2_addr, AWS_ARRAY_SIZE(s_alloc_2_addr), "0x%tx", (uintptr_t)(void *)s_alloc_2);
     snprintf(s_alloc_3_addr, AWS_ARRAY_SIZE(s_alloc_3_addr), "0x%tx", (uintptr_t)(void *)s_alloc_3);
     snprintf(s_alloc_4_addr, AWS_ARRAY_SIZE(s_alloc_4_addr), "0x%tx", (uintptr_t)(void *)s_alloc_4);
+#        pragma warning(pop)
+#    endif /* defined(_MSC_VER) */
+
     const char *log_buffer = (const char *)test_logger->log_buffer.buffer;
     ASSERT_TRUE(strstr(log_buffer, "s_alloc_1") || strstr(log_buffer, s_alloc_1_addr));
     ASSERT_TRUE(strstr(log_buffer, "s_alloc_2") || strstr(log_buffer, s_alloc_2_addr));
@@ -188,14 +194,12 @@ static int s_test_memtrace_none(struct aws_allocator *allocator, void *ctx) {
     struct aws_allocator *tracer = aws_mem_tracer_new(allocator, NULL, AWS_MEMTRACE_NONE, 0);
 
     void *allocs[NUM_ALLOCS] = {0};
-    size_t total = 0;
 
     for (size_t idx = 0; idx < AWS_ARRAY_SIZE(allocs); ++idx) {
         uint32_t size = 0;
         aws_device_random_u32(&size);
         size = (size % 1024) + 1; /* not necessary to allocate a gajillion bytes */
         allocs[idx] = aws_mem_acquire(tracer, size);
-        total += size;
     }
 
     ASSERT_UINT_EQUALS(0, aws_mem_tracer_bytes(tracer));

data/aws-crt-ffi/crt/aws-c-event-stream/README.md

@@ -10,61 +10,44 @@ This library is licensed under the Apache 2.0 License.
 
 ### Building
 
-#### Building s2n (Linux Only)
+CMake 3.1+ is required to build.
 
-If you are building on Linux, you will need to build s2n before being able to build aws-c-io.  For our CRT's, we build s2n at a specific commit, and recommend doing the same when using it with this library.  That commit hash can be found [here](https://github.com/awslabs/aws-crt-cpp/tree/main/crt).  The commands below will build s2n using OpenSSL 1.1.1.  For using other versions of OpenSSL, there is additional information in the [s2n Usage Guide](https://github.com/awslabs/s2n/blob/main/docs/USAGE-GUIDE.md).
+`<install-path>` must be an absolute path in the following instructions.
+
+#### Linux-Only Dependencies
+
+If you are building on Linux, you will need to build aws-lc and s2n-tls first.
 
 ```
-git clone git@github.com:awslabs/s2n.git
-cd s2n
-git checkout <s2n-commit-hash-used-by-aws-crt-cpp>
-
-# We keep the build artifacts in the -build directory
-cd libcrypto-build
-
-# Download the latest version of OpenSSL
-curl -LO https://www.openssl.org/source/openssl-1.1.1-latest.tar.gz
-tar -xzvf openssl-1.1.1-latest.tar.gz
-
-# Build openssl libcrypto.  Note that the install path specified here must be absolute.
-cd `tar ztf openssl-1.1.1-latest.tar.gz | head -n1 | cut -f1 -d/`
-./config -fPIC no-shared              \
-         no-md2 no-rc5 no-rfc3779 no-sctp no-ssl-trace no-zlib     \
-         no-hw no-mdc2 no-seed no-idea enable-ec_nistp_64_gcc_128 no-camellia\
-         no-bf no-ripemd no-dsa no-ssl2 no-ssl3 no-capieng                  \
-         -DSSL_FORBID_ENULL -DOPENSSL_NO_DTLS1 -DOPENSSL_NO_HEARTBEATS      \
-         --prefix=<absolute-install-path>
-make
-make install
-
-# Build s2n
-cd ../../../
-cmake -DCMAKE_PREFIX_PATH=<install-path> -DCMAKE_INSTALL_PREFIX=<install-path> -S s2n -B s2n/build
-cmake --build s2n/build --target install
+git clone git@github.com:awslabs/aws-lc.git
+cmake -S aws-lc -B aws-lc/build -DCMAKE_INSTALL_PREFIX=<install-path>
+cmake --build aws-lc/build --target install
+
+git clone git@github.com:aws/s2n-tls.git
+cmake -S s2n-tls -B s2n-tls/build -DCMAKE_INSTALL_PREFIX=<install-path> -DCMAKE_PREFIX_PATH=<install-path>
+cmake --build s2n-tls/build --target install
 ```
 
 #### Building aws-c-event-stream and Remaining Dependencies
 
-Note that aws-c-event-stream has several dependencies:
-
 ```
 git clone git@github.com:awslabs/aws-c-common.git
-cmake -DCMAKE_PREFIX_PATH=<install-path> -DCMAKE_INSTALL_PREFIX=<install-path> -S aws-c-common -B aws-c-common/build
+cmake -S aws-c-common -B aws-c-common/build -DCMAKE_INSTALL_PREFIX=<install-path>
 cmake --build aws-c-common/build --target install
 
 git clone git@github.com:awslabs/aws-checksums.git
-cmake -DCMAKE_PREFIX_PATH=<install-path> -DCMAKE_INSTALL_PREFIX=<install-path> -S aws-checksums -B aws-checksums/build
+cmake -S aws-checksums -B aws-checksums/build -DCMAKE_INSTALL_PREFIX=<install-path> -DCMAKE_PREFIX_PATH=<install-path>
 cmake --build aws-checksums/build --target install
 
 git clone git@github.com:awslabs/aws-c-cal.git
-cmake -DCMAKE_PREFIX_PATH=<install-path> -DCMAKE_INSTALL_PREFIX=<install-path> -S aws-c-cal -B aws-c-cal/build
+cmake -S aws-c-cal -B aws-c-cal/build -DCMAKE_INSTALL_PREFIX=<install-path> -DCMAKE_PREFIX_PATH=<install-path>
 cmake --build aws-c-cal/build --target install
 
 git clone git@github.com:awslabs/aws-c-io.git
-cmake -DCMAKE_PREFIX_PATH=<install-path> -DCMAKE_INSTALL_PREFIX=<install-path> -S aws-c-io -B aws-c-io/build
+cmake -S aws-c-io -B aws-c-io/build -DCMAKE_INSTALL_PREFIX=<install-path> -DCMAKE_PREFIX_PATH=<install-path>
 cmake --build aws-c-io/build --target install
 
 git clone git@github.com:awslabs/aws-c-event-stream.git
-cmake -DCMAKE_PREFIX_PATH=<install-path> -DCMAKE_INSTALL_PREFIX=<install-path> -S aws-c-event-stream -B aws-c-event-stream/build
+cmake -S aws-c-event-stream -B aws-c-event-stream/build -DCMAKE_INSTALL_PREFIX=<install-path> -DCMAKE_PREFIX_PATH=<install-path>
 cmake --build aws-c-event-stream/build --target install
 ```

data/aws-crt-ffi/crt/aws-c-event-stream/include/aws/event-stream/event_stream.h

@@ -20,6 +20,9 @@
 /* max header size is 128kb */
 #define AWS_EVENT_STREAM_MAX_HEADERS_SIZE (128 * 1024)
 
+/* Max header name length is 127 bytes */
+#define AWS_EVENT_STREAM_HEADER_NAME_LEN_MAX (INT8_MAX)
+
 enum aws_event_stream_errors {
     AWS_ERROR_EVENT_STREAM_BUFFER_LENGTH_MISMATCH = AWS_ERROR_ENUM_BEGIN_RANGE(AWS_C_EVENT_STREAM_PACKAGE_ID),
     AWS_ERROR_EVENT_STREAM_INSUFFICIENT_BUFFER_LEN,
@@ -54,8 +57,7 @@ struct aws_event_stream_message_prelude {
 
 struct aws_event_stream_message {
     struct aws_allocator *alloc;
-    uint8_t *message_buffer;
-    uint8_t owns_buffer;
+    struct aws_byte_buf message_buffer;
 };
 
 #define AWS_EVENT_STREAM_PRELUDE_LENGTH (uint32_t)(sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t))
@@ -76,6 +78,7 @@ enum aws_event_stream_header_value_type {
     AWS_EVENT_STREAM_HEADER_UUID
 };
 
+static const uint16_t UUID_LEN = 16U;
 struct aws_event_stream_header_value_pair {
     uint8_t header_name_len;
     char header_name[INT8_MAX];
@@ -244,6 +247,22 @@ AWS_EVENT_STREAM_API const uint8_t *aws_event_stream_message_buffer(const struct
 AWS_EVENT_STREAM_API uint32_t
     aws_event_stream_compute_headers_required_buffer_len(const struct aws_array_list *headers);
 
+/**
+ * Writes headers to buf assuming buf is large enough to hold the data. Prefer this function over the unsafe variant
+ * 'aws_event_stream_write_headers_to_buffer'.
+ *
+ * Returns AWS_OP_SUCCESS if the headers were successfully and completely written and AWS_OP_ERR otherwise.
+ */
+AWS_EVENT_STREAM_API int aws_event_stream_write_headers_to_buffer_safe(
+    const struct aws_array_list *headers,
+    struct aws_byte_buf *buf);
+
+/**
+ * Deprecated in favor of 'aws_event_stream_write_headers_to_buffer_safe' as this API is unsafe.
+ *
+ * Writes headers to buffer and returns the length of bytes written to buffer. Assumes buffer is large enough to
+ * store the headers.
+ */
 AWS_EVENT_STREAM_API size_t
     aws_event_stream_write_headers_to_buffer(const struct aws_array_list *headers, uint8_t *buffer);
 

data/aws-crt-ffi/crt/aws-c-event-stream/include/aws/event-stream/event_stream_rpc_client.h

@@ -51,8 +51,20 @@ typedef void(aws_event_stream_rpc_client_on_connection_shutdown_fn)(
     void *user_data);
 
 /**
- * Invoked when a connection attempt completes. error_code of 0 indicates success, anything else indicates failure.
- * If the connection attempt fails, aws_event_stream_rpc_client_on_connection_shutdown_fn will not be invoked. *
+ * Invoked when a connection attempt completes.
+ *
+ * If the attempt was unsuccessful, the error_code will be non-zero and the connection pointer will be NULL,
+ * and aws_event_stream_rpc_client_on_connection_shutdown_fn will not be invoked.
+ *
+ * If the attempt was successful, error_code will be 0 and the connection pointer will be valid.
+ * You must call aws_event_stream_rpc_client_connection_acquire()
+ * to prevent the pointer's memory from being destroyed before you are ready.
+ * When you are completely done with the connection pointer you must call
+ * aws_event_stream_rpc_client_connection_release() or its memory will leak.
+ * aws_event_stream_rpc_client_on_connection_shutdown_fn will be invoked
+ * when the network connection has closed. If you are done with the connection,
+ * but it is still open, you must call aws_aws_event_stream_rpc_client_close()
+ * or network connection will remain open, even if you call release().
  */
 typedef void(aws_event_stream_rpc_client_on_connection_setup_fn)(
     struct aws_event_stream_rpc_client_connection *connection,

data/aws-crt-ffi/crt/aws-c-event-stream/include/aws/event-stream/event_stream_rpc_server.h

@@ -46,6 +46,12 @@ typedef void(aws_event_stream_rpc_server_connection_protocol_message_fn)(
 /**
  * Invoked when a new stream has been received on the connection. If you return AWS_OP_SUCCESS (0),
  * You must fill in the fields for continuation options or the program will assert and exit.
+ *
+ * A failure path MUST leave the ref count of the continuation alone.
+ *
+ * A success path should probably take a ref which will leave the continuation (assuming no other interference)
+ * at two AFTER creation is complete: 1 for the connection's continuation table, and one for the callback
+ * recipient which is presumably tracking it as well.
  */
 typedef int(aws_event_stream_rpc_server_on_incoming_stream_fn)(
     struct aws_event_stream_rpc_server_connection *connection,
@@ -128,6 +134,13 @@ AWS_EVENT_STREAM_API void aws_event_stream_rpc_server_listener_acquire(
 AWS_EVENT_STREAM_API void aws_event_stream_rpc_server_listener_release(
     struct aws_event_stream_rpc_server_listener *listener);
 
+/**
+ * Get the local port which the listener's socket is bound to.
+ */
+AWS_EVENT_STREAM_API
+uint16_t aws_event_stream_rpc_server_listener_get_bound_port(
+    const struct aws_event_stream_rpc_server_listener *listener);
+
 /**
  * Bypasses server, and creates a connection on an already existing channel. No connection lifetime callbacks will be
  * invoked on the returned connection. Returns NULL if an error occurs. If and only if, you use this API, the returned

data/aws-crt-ffi/crt/aws-c-event-stream/include/aws/event-stream/private/event_stream_rpc_priv.h

@@ -29,25 +29,25 @@ static const struct aws_byte_cursor s_json_content_type_value =
 
 static const struct aws_byte_cursor s_invalid_stream_id_error =
     AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("{ \"message\": \"non-zero stream-id field is only allowed for messages of "
-                                          "type APPLICATION_MESSAGE. The stream id max value is INT32_MAX.\"; }");
+                                          "type APPLICATION_MESSAGE. The stream id max value is INT32_MAX.\" }");
 
 static const struct aws_byte_cursor s_invalid_client_stream_id_error =
     AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("{ \"message\": \"stream-id values must be monotonically incrementing. A "
-                                          "stream-id arrived that was lower than the last seen stream-id.\"; }");
+                                          "stream-id arrived that was lower than the last seen stream-id.\" }");
 
 static const struct aws_byte_cursor s_invalid_new_client_stream_id_error =
     AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("{ \"message\": \"stream-id values must be monotonically incrementing. A new "
-                                          "stream-id arrived that was incremented by more than 1.\"; }");
+                                          "stream-id arrived that was incremented by more than 1.\" }");
 
-static const struct aws_byte_cursor s_invalid_message_type_error = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL(
-    "{ \"message\": \"an invalid value for message-type field was received.\"; }");
+static const struct aws_byte_cursor s_invalid_message_type_error =
+    AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("{ \"message\": \"an invalid value for message-type field was received.\" }");
 
 static const struct aws_byte_cursor s_invalid_message_error = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL(
     "{ \"message\": \"A message was received with missing required fields. Check that your client is sending at least, "
-    ":message-type, :message-flags, and :stream-id\"; }");
+    ":message-type, :message-flags, and :stream-id\" }");
 
 static const struct aws_byte_cursor s_internal_error = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL(
-    "{ \"message\": \"An error occurred on the peer endpoint. This is not likely caused by your endpoint.\"; }");
+    "{ \"message\": \"An error occurred on the peer endpoint. This is not likely caused by your endpoint.\" }");
 
 static const struct aws_byte_cursor s_connect_not_completed_error = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL(
     "{ \"message\": \"A CONNECT message must be received, and the CONNECT_ACK must be sent in response, before any "