aws-crt 0.1.9 → 0.2.0

data/aws-crt-ffi/crt/aws-c-cal/source/darwin/commoncrypto_aes.c

@@ -9,11 +9,18 @@
 #include <CommonCrypto/CommonHMAC.h>
 #include <CommonCrypto/CommonSymmetricKeywrap.h>
 
-#include "common_cryptor_spi.h"
-
-#if (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && (__MAC_OS_X_VERSION_MAX_ALLOWED >= 101300 /* macOS 10.13 */)) ||       \
-    (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && (__IPHONE_OS_VERSION_MAX_ALLOWED >= 110000 /* iOS v11 */))
-#    define USE_LATEST_CRYPTO_API 1
+#if !defined(AWS_APPSTORE_SAFE)
+/* CommonCrypto does not offer public APIs for doing AES GCM.
+ * There are private APIs for doing it (CommonCryptoSPI.h), but App Store
+ * submissions that reference these private symbols will be rejected. */
+
+#    define SUPPORT_AES_GCM_VIA_SPI 1
+#    include "common_cryptor_spi.h"
+
+#    if (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && (__MAC_OS_X_VERSION_MAX_ALLOWED >= 101300 /* macOS 10.13 */)) ||   \
+        (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && (__IPHONE_OS_VERSION_MAX_ALLOWED >= 110000 /* iOS v11 */))
+#        define USE_LATEST_CRYPTO_API 1
+#    endif
 #endif
 
 struct cc_aes_cipher {
@@ -353,43 +360,45 @@ struct aws_symmetric_cipher *aws_aes_ctr_256_new_impl(
     return &cc_cipher->cipher_base;
 }
 
+#ifdef SUPPORT_AES_GCM_VIA_SPI
+
 /*
  * Note that CCCryptorGCMFinal is deprecated in Mac 10.13. It also doesn't compare the tag with expected tag
  * https://opensource.apple.com/source/CommonCrypto/CommonCrypto-60118.1.1/include/CommonCryptorSPI.h.auto.html
  */
 static CCStatus s_cc_crypto_gcm_finalize(struct _CCCryptor *encryptor_handle, uint8_t *buffer, size_t tag_length) {
-#ifdef USE_LATEST_CRYPTO_API
+#    ifdef USE_LATEST_CRYPTO_API
     if (__builtin_available(macOS 10.13, iOS 11.0, *)) {
         return CCCryptorGCMFinalize(encryptor_handle, buffer, tag_length);
     } else {
 /* We would never hit this branch for newer macOS and iOS versions because of the __builtin_available check, so we can
  * suppress the compiler warning. */
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#        pragma clang diagnostic push
+#        pragma clang diagnostic ignored "-Wdeprecated-declarations"
         return CCCryptorGCMFinal(encryptor_handle, buffer, &tag_length);
-#    pragma clang diagnostic pop
+#        pragma clang diagnostic pop
     }
-#else
+#    else
     return CCCryptorGCMFinal(encryptor_handle, buffer, &tag_length);
 
-#endif
+#    endif
 }
 
 static CCCryptorStatus s_cc_cryptor_gcm_set_iv(struct _CCCryptor *encryptor_handle, uint8_t *buffer, size_t length) {
-#ifdef USE_LATEST_CRYPTO_API
+#    ifdef USE_LATEST_CRYPTO_API
     if (__builtin_available(macOS 10.13, iOS 11.0, *)) {
         return CCCryptorGCMSetIV(encryptor_handle, buffer, length);
     } else {
 /* We would never hit this branch for newer macOS and iOS versions because of the __builtin_available check, so we can
  * suppress the compiler warning. */
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#        pragma clang diagnostic push
+#        pragma clang diagnostic ignored "-Wdeprecated-declarations"
         return CCCryptorGCMAddIV(encryptor_handle, buffer, length);
-#    pragma clang diagnostic pop
+#        pragma clang diagnostic pop
     }
-#else
+#    else
     return CCCryptorGCMAddIV(encryptor_handle, buffer, length);
-#endif
+#    endif
 }
 
 static int s_finalize_gcm_encryption(struct aws_symmetric_cipher *cipher, struct aws_byte_buf *out) {
@@ -581,6 +590,26 @@ struct aws_symmetric_cipher *aws_aes_gcm_256_new_impl(
     return &cc_cipher->cipher_base;
 }
 
+#else /* !SUPPORT_AES_GCM_VIA_SPI */
+
+struct aws_symmetric_cipher *aws_aes_gcm_256_new_impl(
+    struct aws_allocator *allocator,
+    const struct aws_byte_cursor *key,
+    const struct aws_byte_cursor *iv,
+    const struct aws_byte_cursor *aad,
+    const struct aws_byte_cursor *tag) {
+
+    (void)allocator;
+    (void)key;
+    (void)iv;
+    (void)aad;
+    (void)tag;
+    aws_raise_error(AWS_ERROR_PLATFORM_NOT_SUPPORTED);
+    return NULL;
+}
+
+#endif /* SUPPORT_AES_GCM_VIA_SPI */
+
 static int s_keywrap_encrypt_decrypt(
     struct aws_symmetric_cipher *cipher,
     struct aws_byte_cursor input,

data/aws-crt-ffi/crt/aws-c-cal/source/unix/openssl_aes.c

@@ -4,6 +4,7 @@
  */
 #include <aws/cal/private/symmetric_cipher_priv.h>
 
+#define OPENSSL_SUPPRESS_DEPRECATED
 #include <openssl/evp.h>
 
 struct openssl_aes_cipher {

data/aws-crt-ffi/crt/aws-c-cal/source/unix/openssl_platform_init.c

@@ -13,6 +13,13 @@
 
 #include <aws/cal/private/opensslcrypto_common.h>
 
+/*
+ * OpenSSL 3 has a large amount of interface changes and many of the functions used
+ * throughout aws-c-cal have become deprecated.
+ * Lets disable deprecation warnings, so that we can atleast run CI, until we
+ * can move over to new functions.
+ */
+#define OPENSSL_SUPPRESS_DEPRECATED
 #include <openssl/crypto.h>
 
 static struct openssl_hmac_ctx_table hmac_ctx_table;

data/aws-crt-ffi/crt/aws-c-cal/source/unix/openssl_rsa.c

@@ -2,15 +2,17 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
  */
+#include <aws/cal/private/opensslcrypto_common.h>
 #include <aws/cal/private/rsa.h>
 
 #include <aws/cal/cal.h>
 #include <aws/common/encoding.h>
 
+#define OPENSSL_SUPPRESS_DEPRECATED
 #include <openssl/err.h>
 #include <openssl/evp.h>
 
-#if !defined(OPENSSL_IS_AWSLC) && !defined(OPENSSL_IS_BORINGSSL)
+#if defined(OPENSSL_IS_OPENSSL)
 /*Error defines were part of evp.h in 1.0.x and were moved to evperr.h in 1.1.0*/
 #    if OPENSSL_VERSION_NUMBER >= 0x10100000L
 #        include <openssl/evperr.h>
@@ -56,7 +58,7 @@ static int s_reinterpret_evp_error_as_crt(int evp_error, const char *function_na
     }
 
     /* AWS-LC/BoringSSL error code is uint32_t, but OpenSSL uses unsigned long. */
-#if !defined(OPENSSL_IS_AWSLC) && !defined(OPENSSL_IS_BORINGSSL)
+#if defined(OPENSSL_IS_OPENSSL)
     uint32_t error = ERR_peek_error();
 #else
     unsigned long error = ERR_peek_error();
@@ -142,7 +144,27 @@ static int s_rsa_encrypt(
         goto on_error;
     }
 
+    size_t needed_buffer_len = 0;
+    if (s_reinterpret_evp_error_as_crt(
+            EVP_PKEY_encrypt(ctx, NULL, &needed_buffer_len, plaintext.ptr, plaintext.len),
+            "EVP_PKEY_encrypt get length")) {
+        goto on_error;
+    }
+
     size_t ct_len = out->capacity - out->len;
+    if (needed_buffer_len > ct_len) {
+        /*
+         * OpenSSL 3 seems to no longer fail if the buffer is too short.
+         * Instead it seems to write out enough data to fill the buffer and then
+         * updates the out_len to full buffer. It does not seem to corrupt
+         * memory after the buffer, but behavior is non-ideal.
+         * Let get length needed for buffer from api first and then manually ensure that
+         * buffer we have is big enough.
+         */
+        aws_raise_error(AWS_ERROR_SHORT_BUFFER);
+        goto on_error;
+    }
+
     if (s_reinterpret_evp_error_as_crt(
             EVP_PKEY_encrypt(ctx, out->buffer + out->len, &ct_len, plaintext.ptr, plaintext.len), "EVP_PKEY_encrypt")) {
         goto on_error;
@@ -177,7 +199,23 @@ static int s_rsa_decrypt(
         goto on_error;
     }
 
+    size_t needed_buffer_len = 0;
+    if (s_reinterpret_evp_error_as_crt(
+            EVP_PKEY_decrypt(ctx, NULL, &needed_buffer_len, ciphertext.ptr, ciphertext.len),
+            "EVP_PKEY_decrypt get length")) {
+        goto on_error;
+    }
+
     size_t ct_len = out->capacity - out->len;
+    if (needed_buffer_len > ct_len) {
+        /*
+         * manual short buffer length check for OpenSSL 3.
+         * refer to encrypt implementation for more details
+         */
+        aws_raise_error(AWS_ERROR_SHORT_BUFFER);
+        goto on_error;
+    }
+
     if (s_reinterpret_evp_error_as_crt(
             EVP_PKEY_decrypt(ctx, out->buffer + out->len, &ct_len, ciphertext.ptr, ciphertext.len),
             "EVP_PKEY_decrypt")) {
@@ -251,7 +289,26 @@ static int s_rsa_sign(
         goto on_error;
     }
 
+    size_t needed_buffer_len = 0;
+    if (s_reinterpret_evp_error_as_crt(
+            EVP_PKEY_sign(ctx, NULL, &needed_buffer_len, digest.ptr, digest.len), "EVP_PKEY_sign get length")) {
+        goto on_error;
+    }
+
     size_t ct_len = out->capacity - out->len;
+    if (needed_buffer_len > ct_len) {
+        /*
+         * manual short buffer length check for OpenSSL 3.
+         * refer to encrypt implementation for more details.
+         * OpenSSL3 actually does throw an error here, but error code comes from
+         * component that does not exist in OpenSSL 1.x. So check manually right
+         * now and we can figure out how to handle it better, once we can
+         * properly support OpenSSL 3.
+         */
+        aws_raise_error(AWS_ERROR_SHORT_BUFFER);
+        goto on_error;
+    }
+
     if (s_reinterpret_evp_error_as_crt(
             EVP_PKEY_sign(ctx, out->buffer + out->len, &ct_len, digest.ptr, digest.len), "EVP_PKEY_sign")) {
         goto on_error;

data/aws-crt-ffi/crt/aws-c-cal/source/unix/opensslcrypto_ecc.c

@@ -7,6 +7,7 @@
 #include <aws/cal/cal.h>
 #include <aws/cal/private/der.h>
 
+#define OPENSSL_SUPPRESS_DEPRECATED
 #include <openssl/bn.h>
 #include <openssl/ec.h>
 #include <openssl/ecdsa.h>

data/aws-crt-ffi/crt/aws-c-common/CMakeLists.txt

@@ -70,6 +70,7 @@ if (WIN32)
 
     file(GLOB AWS_COMMON_OS_SRC
         "source/windows/*.c"
+        "source/platform_fallback_stubs/system_info.c"
         )
 
     if (MSVC)
@@ -81,7 +82,10 @@ if (WIN32)
     endif ()
 
     list(APPEND PLATFORM_DEFINES WINDOWS_KERNEL_LIB=${WINDOWS_KERNEL_LIB})
-    list(APPEND PLATFORM_LIBS BCrypt ${WINDOWS_KERNEL_LIB} Ws2_32 Shlwapi)
+    # PSAPI_VERSION=1 is needed to support GetProcessMemoryInfo on both pre and
+    # post Win7 OS's. 
+    list(APPEND PLATFORM_DEFINES PSAPI_VERSION=1)
+    list(APPEND PLATFORM_LIBS BCrypt ${WINDOWS_KERNEL_LIB} Ws2_32 Shlwapi Psapi)
 else ()
     file(GLOB AWS_COMMON_OS_HEADERS
         "include/aws/common/posix/*"
@@ -108,19 +112,26 @@ else ()
         # Don't add the exact path to CoreFoundation as this would hardcode the SDK version
         list(APPEND PLATFORM_LIBS dl Threads::Threads "-framework CoreFoundation")
         list (APPEND AWS_COMMON_OS_SRC "source/darwin/*.c") # OS specific includes
+        list (APPEND AWS_COMMON_OS_SRC "source/platform_fallback_stubs/system_info.c")
     elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux") # Android does not link to libpthread nor librt, so this is fine
         list(APPEND PLATFORM_LIBS dl m Threads::Threads rt)
         list (APPEND AWS_COMMON_OS_SRC "source/linux/*.c") # OS specific includes
     elseif(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
         list(APPEND PLATFORM_LIBS dl m thr execinfo)
+        list (APPEND AWS_COMMON_OS_SRC "source/platform_fallback_stubs/system_info.c")
     elseif(CMAKE_SYSTEM_NAME STREQUAL "NetBSD")
         list(APPEND PLATFORM_LIBS dl m Threads::Threads execinfo)
+        list (APPEND AWS_COMMON_OS_SRC "source/platform_fallback_stubs/system_info.c")
     elseif(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
         list(APPEND PLATFORM_LIBS m Threads::Threads execinfo)
+        list (APPEND AWS_COMMON_OS_SRC "source/platform_fallback_stubs/system_info.c")
     elseif(CMAKE_SYSTEM_NAME STREQUAL "Android")
         list(APPEND PLATFORM_LIBS log)
         file(GLOB ANDROID_SRC "source/android/*.c")
         list(APPEND AWS_COMMON_OS_SRC "${ANDROID_SRC}")
+        list (APPEND AWS_COMMON_OS_SRC "source/platform_fallback_stubs/system_info.c")
+    else()
+        list (APPEND AWS_COMMON_OS_SRC "source/platform_fallback_stubs/system_info.c")
     endif()
 
 endif()
@@ -298,6 +309,7 @@ configure_file(${CONFIG_HEADER_TEMPLATE}
 if (ALLOW_CROSS_COMPILED_TESTS OR NOT CMAKE_CROSSCOMPILING)
     if (BUILD_TESTING)
         add_subdirectory(tests)
+        add_subdirectory(bin/system_info)
     endif()
 endif()
 

data/aws-crt-ffi/crt/aws-c-common/THIRD-PARTY-LICENSES.txt

@@ -1,12 +1,9 @@
 ** ittapi ittnotify.h; version v3.24.2 -- https://github.com/intel/ittapi/blob/master/include/ittnotify.h
-/*
-  Copyright (C) 2005-2019 Intel Corporation
+Copyright (C) 2005-2019 Intel Corporation
+SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
 
-  SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
-*/
-/*
-  Amazon.com has chosen to use this file under the terms of the BSD-3-Clause license.
-*/
+Amazon.com has chosen to use this file under the terms of the BSD-3-Clause
+license.
 
 Copyright (c) 2019 Intel Corporation. All rights reserved.
 
@@ -34,3 +31,27 @@ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+------
+
+** cJSON; version 1.7.16 -- https://github.com/DaveGamble/cJSON
+Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/aws-crt-ffi/crt/aws-c-common/bin/system_info/CMakeLists.txt

@@ -0,0 +1,18 @@
+project(print-sys-info C)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_INSTALL_PREFIX}/lib/cmake")
+
+file(GLOB SI_SRC
+        "*.c"
+        )
+
+set(SI_PROJECT_NAME print-sys-info)
+add_executable(${SI_PROJECT_NAME} ${SI_SRC})
+aws_set_common_properties(${SI_PROJECT_NAME})
+
+
+target_include_directories(${SI_PROJECT_NAME} PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>)
+
+target_link_libraries(${SI_PROJECT_NAME} PRIVATE aws-c-common)

data/aws-crt-ffi/crt/aws-c-common/bin/system_info/print_system_info.c

@@ -0,0 +1,48 @@
+
+
+#include <aws/common/byte_buf.h>
+#include <aws/common/logging.h>
+#include <aws/common/system_info.h>
+
+int main(void) {
+    struct aws_allocator *allocator = aws_default_allocator();
+    aws_common_library_init(allocator);
+    struct aws_logger_standard_options options = {
+        .file = stderr,
+        .level = AWS_LOG_LEVEL_TRACE,
+    };
+
+    struct aws_logger logger;
+    aws_logger_init_standard(&logger, allocator, &options);
+    aws_logger_set(&logger);
+
+    struct aws_system_environment *env = aws_system_environment_load(allocator);
+
+    fprintf(stdout, "crt-detected env: {\n");
+
+    struct aws_byte_cursor virtualization_vendor = aws_system_environment_get_virtualization_vendor(env);
+    fprintf(
+        stdout,
+        "  'virtualization vendor': '" PRInSTR "',\n",
+        (int)virtualization_vendor.len,
+        virtualization_vendor.ptr);
+    struct aws_byte_cursor product_name = aws_system_environment_get_virtualization_product_name(env);
+    fprintf(stdout, "  'product name': '" PRInSTR "',\n", (int)product_name.len, product_name.ptr);
+    fprintf(
+        stdout, "  'number of processors': '%lu',\n", (unsigned long)aws_system_environment_get_processor_count(env));
+    size_t numa_nodes = aws_system_environment_get_cpu_group_count(env);
+
+    if (numa_nodes > 1) {
+        fprintf(stdout, "  'numa architecture': 'true',\n");
+        fprintf(stdout, "  'number of numa nodes': '%lu'\n", (unsigned long)numa_nodes);
+    } else {
+        fprintf(stdout, "  'numa architecture': 'false'\n");
+    }
+
+    fprintf(stdout, "}\n");
+    aws_system_environment_release(env);
+    aws_logger_clean_up(&logger);
+
+    aws_common_library_clean_up();
+    return 0;
+}

data/aws-crt-ffi/crt/aws-c-common/include/aws/common/allocator.h

@@ -12,6 +12,22 @@
 AWS_PUSH_SANE_WARNING_LEVEL
 AWS_EXTERN_C_BEGIN
 
+/*
+ * Quick guide to allocators:
+ *  CRT offers several flavours of allocators:
+ * - default: basic allocator that invokes system one directly.
+ * - aligned: basic allocator that aligns small allocations on 8 byte
+ *   boundary and big buffers on 32/64 byte (system dependent) boundary.
+ *   Aligned mem can improve perf on some operations, like memcpy or hashes.
+ *   Depending on a system, can result in higher peak memory count in heavy
+ *   acquire/free scenarios (ex. s3), due to memory fragmentation related to how
+ *   aligned allocators work (over allocate, find aligned offset, release extra memory)
+ * - wrapped_cf: wraps MacOS's Security Framework allocator.
+ * - mem_tracer: wraps any allocator and provides tracing functionality to allocations
+ * - small_block_allocator: pools smaller allocations into preallocated buckets.
+ *   Not actively maintained. Avoid if possible.
+ */
+
 /* Allocator structure. An instance of this will be passed around for anything needing memory allocation */
 struct aws_allocator {
     void *(*mem_acquire)(struct aws_allocator *allocator, size_t size);
@@ -32,6 +48,13 @@ bool aws_allocator_is_valid(const struct aws_allocator *alloc);
 AWS_COMMON_API
 struct aws_allocator *aws_default_allocator(void);
 
+/*
+ * Allocator that align small allocations on 8 byte boundary and big allocations
+ * on 32/64 byte boundary.
+ */
+AWS_COMMON_API
+struct aws_allocator *aws_aligned_allocator(void);
+
 #ifdef __MACH__
 /* Avoid pulling in CoreFoundation headers in a header file. */
 struct __CFAllocator; /* NOLINT(bugprone-reserved-identifier) */

data/aws-crt-ffi/crt/aws-c-common/include/aws/common/byte_buf.h

@@ -135,6 +135,18 @@ AWS_COMMON_API int aws_byte_buf_init_copy(
 AWS_COMMON_API
 int aws_byte_buf_init_from_file(struct aws_byte_buf *out_buf, struct aws_allocator *alloc, const char *filename);
 
+/**
+ * Same as aws_byte_buf_init_from_file(), but for reading "special files" like /proc/cpuinfo.
+ * These files don't accurately report their size, so size_hint is used as initial buffer size,
+ * and the buffer grows until the while file is read.
+ */
+AWS_COMMON_API
+int aws_byte_buf_init_from_file_with_size_hint(
+    struct aws_byte_buf *out_buf,
+    struct aws_allocator *alloc,
+    const char *filename,
+    size_t size_hint);
+
 /**
  * Evaluates the set of properties that define the shape of all valid aws_byte_buf structures.
  * It is also a cheap check, in the sense it run in constant time (i.e., no loops or recursion).

data/aws-crt-ffi/crt/aws-c-common/include/aws/common/cross_process_lock.h

@@ -0,0 +1,35 @@
+#ifndef AWS_COMMON_CROSS_PROCESS_LOCK_H
+#define AWS_COMMON_CROSS_PROCESS_LOCK_H
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/common/byte_buf.h>
+#include <aws/common/common.h>
+
+struct aws_cross_process_lock;
+AWS_EXTERN_C_BEGIN
+
+/**
+ * Attempts to acquire a system-wide (not per process or per user) lock scoped by instance_nonce.
+ * For any given unique nonce, a lock will be returned by the first caller. Subsequent calls will
+ * return NULL and raise AWS_ERROR_MUTEX_CALLER_NOT_OWNER
+ * until the either the process owning the lock exits or the program owning the lock
+ * calls aws_cross_process_lock_release() explicitly.
+ *
+ * If the process exits before the lock is released, the kernel will unlock it for the next consumer.
+ */
+AWS_COMMON_API
+struct aws_cross_process_lock *aws_cross_process_lock_try_acquire(
+    struct aws_allocator *allocator,
+    struct aws_byte_cursor instance_nonce);
+
+/**
+ * Releases the lock so the next caller (may be another process) can get an instance of the lock.
+ */
+AWS_COMMON_API
+void aws_cross_process_lock_release(struct aws_cross_process_lock *instance_lock);
+
+AWS_EXTERN_C_END
+
+#endif /* AWS_COMMON_CROSS_PROCESS_LOCK_H */

data/aws-crt-ffi/crt/aws-c-common/include/aws/common/hash_table.h

@@ -276,6 +276,7 @@ int aws_hash_table_create(
  *
  * Returns AWS_OP_SUCCESS if an item was found or created.
  * Raises AWS_ERROR_OOM if hash table expansion was required and memory
+ * allocation failed.
  */
 AWS_COMMON_API
 int aws_hash_table_put(struct aws_hash_table *map, const void *key, void *value, int *was_created);

data/aws-crt-ffi/crt/aws-c-common/include/aws/common/priority_queue.h

@@ -162,6 +162,12 @@ int aws_priority_queue_remove(struct aws_priority_queue *queue, void *item, cons
 AWS_COMMON_API
 int aws_priority_queue_top(const struct aws_priority_queue *queue, void **item);
 
+/**
+ * Removes all elements from the queue, but does not free internal memory.
+ */
+AWS_COMMON_API
+void aws_priority_queue_clear(struct aws_priority_queue *queue);
+
 /**
  * Current number of elements in the queue
  */
@@ -175,6 +181,24 @@ size_t aws_priority_queue_size(const struct aws_priority_queue *queue);
 AWS_COMMON_API
 size_t aws_priority_queue_capacity(const struct aws_priority_queue *queue);
 
+/**
+ * Initializes a queue node to a default value that indicates the node is not in the queue.
+ *
+ * @param node priority queue node to initialize with a default value
+ */
+AWS_COMMON_API
+void aws_priority_queue_node_init(struct aws_priority_queue_node *node);
+
+/**
+ * Checks if a priority queue node is currently in a priority queue.
+ *
+ * @param node priority queue node to check usage for
+ *
+ * @return true if the node is in a queue, false otherwise
+ */
+AWS_COMMON_API
+bool aws_priority_queue_node_is_in_queue(const struct aws_priority_queue_node *node);
+
 AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 

data/aws-crt-ffi/crt/aws-c-common/include/aws/common/private/system_info_priv.h

@@ -0,0 +1,37 @@
+#ifndef AWS_COMMON_PRIVATE_SYSTEM_INFO_PRIV_H
+#define AWS_COMMON_PRIVATE_SYSTEM_INFO_PRIV_H
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/common/byte_buf.h>
+#include <aws/common/ref_count.h>
+#include <aws/common/string.h>
+#include <aws/common/system_info.h>
+
+struct aws_system_environment {
+    struct aws_allocator *allocator;
+    struct aws_ref_count ref_count;
+    struct aws_byte_buf virtualization_vendor;
+    struct aws_byte_buf product_name;
+    enum aws_platform_os os;
+    size_t cpu_count;
+    size_t cpu_group_count;
+    void *impl;
+};
+
+/**
+ * For internal implementors. Fill in info in env that you're able to grab, such as dmi info, os version strings etc...
+ * in here. The default just returns AWS_OP_SUCCESS. This is currently only implemented for linux.
+ *
+ * Returns AWS_OP_ERR if the implementation wasn't able to fill in required information for the platform.
+ */
+int aws_system_environment_load_platform_impl(struct aws_system_environment *env);
+
+/**
+ * For internal implementors. Cleans up anything allocated in aws_system_environment_load_platform_impl,
+ * but does not release the memory for env.
+ */
+void aws_system_environment_destroy_platform_impl(struct aws_system_environment *env);
+
+#endif // AWS_COMMON_PRIVATE_SYSTEM_INFO_PRIV_H

data/aws-crt-ffi/crt/aws-c-common/include/aws/common/system_info.h

@@ -6,6 +6,7 @@
  * SPDX-License-Identifier: Apache-2.0.
  */
 
+#include <aws/common/byte_buf.h>
 #include <aws/common/common.h>
 
 AWS_PUSH_SANE_WARNING_LEVEL
@@ -21,8 +22,54 @@ struct aws_cpu_info {
     bool suspected_hyper_thread;
 };
 
+struct aws_system_environment;
+
 AWS_EXTERN_C_BEGIN
 
+/**
+ * Allocates and initializes information about the system the current process is executing on.
+ * If successful returns an instance of aws_system_environment. If it fails, it will return NULL.
+ *
+ * Note: This api is used internally and is still early in its evolution.
+ * It may change in incompatible ways in the future.
+ */
+AWS_COMMON_API
+struct aws_system_environment *aws_system_environment_load(struct aws_allocator *allocator);
+
+AWS_COMMON_API
+struct aws_system_environment *aws_system_environment_acquire(struct aws_system_environment *env);
+
+AWS_COMMON_API
+void aws_system_environment_release(struct aws_system_environment *env);
+
+/**
+ * Returns the virtualization vendor for the specified compute environment, e.g. "Xen, Amazon EC2, etc..."
+ *
+ * The return value may be empty and in that case no vendor was detected.
+ */
+AWS_COMMON_API
+struct aws_byte_cursor aws_system_environment_get_virtualization_vendor(const struct aws_system_environment *env);
+
+/**
+ * Returns the product name for the specified compute environment. For example, the Amazon EC2 Instance type.
+ *
+ * The return value may be empty and in that case no vendor was detected.
+ */
+AWS_COMMON_API
+struct aws_byte_cursor aws_system_environment_get_virtualization_product_name(const struct aws_system_environment *env);
+
+/**
+ * Returns the number of processors for the specified compute environment.
+ */
+AWS_COMMON_API
+size_t aws_system_environment_get_processor_count(struct aws_system_environment *env);
+
+/**
+ * Returns the number of separate cpu groupings (multi-socket configurations or NUMA).
+ */
+AWS_COMMON_API
+size_t aws_system_environment_get_cpu_group_count(const struct aws_system_environment *env);
+
 /* Returns the OS this was built under */
 AWS_COMMON_API
 enum aws_platform_os aws_get_platform_build_os(void);