File Explorer

1/**2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.3 * SPDX-License-Identifier: Apache-2.0.4 */5 6#include "auth.h"7#include "checksums.h"8#include "crypto.h"9#include "event_stream.h"10#include "http_connection.h"11#include "http_connection_manager.h"12#include "http_headers.h"13#include "http_message.h"14#include "http_stream.h"15#include "io.h"16#include "logger.h"17#include "mqtt5_client.h"18#include "mqtt_client.h"19#include "mqtt_client_connection.h"20#include "mqtt_request_response.h"21 22#include <aws/cal/cal.h>23 24#include <aws/common/clock.h>25#include <aws/common/environment.h>26#include <aws/common/logging.h>27#include <aws/common/mutex.h>28#include <aws/common/ref_count.h>29#include <aws/common/rw_lock.h>30#include <aws/common/system_info.h>31 32#include <aws/event-stream/event_stream.h>33 34#include <aws/io/event_loop.h>35#include <aws/io/tls_channel_handler.h>36 37#include <aws/http/http.h>38 39#include <aws/auth/auth.h>40 41#include <uv.h>42 43/*44 * This is a multi-line comment to ensure that the static assert does not collide with the static asserts in45 * aws/common/macro.h.46 *47 */48AWS_STATIC_ASSERT(NAPI_VERSION >= 4);49 50#define AWS_DEFINE_ERROR_INFO_CRT_NODEJS(CODE, STR) AWS_DEFINE_ERROR_INFO(CODE, STR, "aws-crt-nodejs")51 52/* TODO:53 * Hardcoded enum value for `napi_no_external_buffers_allowed`.54 * The enum `napi_no_external_buffers_allowed` is introduced in node21 and backport55 * to node 14.21.2, 16.19.0, 18.13.0.56 * Use `napi_no_external_buffers_allowed` for external buffer related changes after bump to node 21 */57#define NAPI_NO_EXTERNAL_BUFFER_ENUM_VALUE 2258 59static bool s_tsfn_enabled = false;60static struct aws_rw_lock s_tsfn_lock;61 62/* clang-format off */63static struct aws_error_info s_errors[] = {64    AWS_DEFINE_ERROR_INFO_CRT_NODEJS(65        AWS_CRT_NODEJS_ERROR_THREADSAFE_FUNCTION_NULL_NAPI_ENV,66        "There was an attempt to execute a thread-safe napi function binding with a null napi environment.  This is usually due to the function binding being released by a shutdown/cleanup process while the execution is waiting in the queue."),67    AWS_DEFINE_ERROR_INFO_CRT_NODEJS(68        AWS_CRT_NODEJS_ERROR_NAPI_FAILURE,69        "A N-API API call failed"),70    AWS_DEFINE_ERROR_INFO_CRT_NODEJS(71        AWS_CRT_NODEJS_ERROR_EVENT_STREAM_USER_CLOSE,72        "User invoked close on an eventstream connection."),73};74/* clang-format on */75 76static struct aws_error_info_list s_error_list = {77    .error_list = s_errors,78    .count = sizeof(s_errors) / sizeof(struct aws_error_info),79};80 81static struct aws_log_subject_info s_log_subject_infos[] = {82    DEFINE_LOG_SUBJECT_INFO(AWS_LS_NODEJS_CRT_GENERAL, "node", "General Node/N-API events"),83};84 85static struct aws_log_subject_info_list s_log_subject_list = {86    .subject_list = s_log_subject_infos,87    .count = AWS_ARRAY_SIZE(s_log_subject_infos),88};89 90static uv_loop_t *s_node_uv_loop = NULL;91static struct aws_event_loop *s_node_uv_event_loop = NULL;92static struct aws_event_loop_group *s_node_uv_elg = NULL;93static struct aws_host_resolver *s_default_host_resolver = NULL;94static struct aws_client_bootstrap *s_default_client_bootstrap = NULL;95 96int aws_napi_attach_object_property_boolean(napi_value object, napi_env env, const char *key_name, bool value) {97    if (key_name == NULL) {98        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);99    }100 101    napi_value napi_boolean = NULL;102 103    AWS_NAPI_CALL(env, napi_get_boolean(env, value, &napi_boolean), {104        return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);105    });106    AWS_NAPI_CALL(env, napi_set_named_property(env, object, key_name, napi_boolean), {107        return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);108    });109 110    return AWS_OP_SUCCESS;111}112 113int aws_napi_attach_object_property_optional_boolean(114    napi_value object,115    napi_env env,116    const char *key_name,117    const bool *value) {118    if (value == NULL) {119        return AWS_OP_SUCCESS;120    }121 122    return aws_napi_attach_object_property_boolean(object, env, key_name, *value);123}124 125/*126 * IEEE fp double analysis says 2 ^ 53 is the maximum sequential value we could support, but the napi docs for127 * napi_create_int64() say (2 ^ 53 - 1) so we'll use their more conservative bound.128 */129#define MAX_ALLOWED_UINT64_T_TO_DOUBLE ((((uint64_t)1) << 53) - 1)130 131int aws_napi_attach_object_property_u64(napi_value object, napi_env env, const char *key_name, uint64_t value) {132    if (key_name == NULL) {133        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);134    }135 136    if (value > MAX_ALLOWED_UINT64_T_TO_DOUBLE) {137        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);138    }139 140    napi_value napi_i64 = NULL;141 142    AWS_NAPI_CALL(env, napi_create_int64(env, (int64_t)value, &napi_i64), {143        return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);144    });145    AWS_NAPI_CALL(env, napi_set_named_property(env, object, key_name, napi_i64), {146        return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);147    });148 149    return AWS_OP_SUCCESS;150}151 152int aws_napi_attach_object_property_optional_u64(153    napi_value object,154    napi_env env,155    const char *key_name,156    const uint64_t *value) {157    if (value == NULL) {158        return AWS_OP_SUCCESS;159    }160 161    return aws_napi_attach_object_property_u64(object, env, key_name, *value);162}163 164int aws_napi_attach_object_property_u32(napi_value object, napi_env env, const char *key_name, uint32_t value) {165    if (key_name == NULL) {166        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);167    }168 169    napi_value napi_u32 = NULL;170 171    AWS_NAPI_CALL(172        env, napi_create_uint32(env, value, &napi_u32), { return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE); });173    AWS_NAPI_CALL(env, napi_set_named_property(env, object, key_name, napi_u32), {174        return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);175    });176 177    return AWS_OP_SUCCESS;178}179 180int aws_napi_attach_object_property_optional_u32(181    napi_value object,182    napi_env env,183    const char *key_name,184    const uint32_t *value) {185    if (value == NULL) {186        return AWS_OP_SUCCESS;187    }188 189    return aws_napi_attach_object_property_u32(object, env, key_name, *value);190}191 192int aws_napi_attach_object_property_i32(napi_value object, napi_env env, const char *key_name, int32_t value) {193    if (key_name == NULL) {194        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);195    }196 197    napi_value napi_i32 = NULL;198 199    AWS_NAPI_CALL(200        env, napi_create_int32(env, value, &napi_i32), { return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE); });201    AWS_NAPI_CALL(env, napi_set_named_property(env, object, key_name, napi_i32), {202        return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);203    });204 205    return AWS_OP_SUCCESS;206}207 208int aws_napi_attach_object_property_u16(napi_value object, napi_env env, const char *key_name, uint16_t value) {209    return aws_napi_attach_object_property_u32(object, env, key_name, (uint32_t)value);210}211 212int aws_napi_attach_object_property_optional_u16(213    napi_value object,214    napi_env env,215    const char *key_name,216    const uint16_t *value) {217    if (value == NULL) {218        return AWS_OP_SUCCESS;219    }220 221    return aws_napi_attach_object_property_u16(object, env, key_name, *value);222}223 224int aws_napi_attach_object_property_string(225    napi_value object,226    napi_env env,227    const char *key_name,228    struct aws_byte_cursor value) {229 230    if (key_name == NULL) {231        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);232    }233 234    napi_value napi_string = NULL;235 236    AWS_NAPI_CALL(env, napi_create_string_utf8(env, (const char *)(value.ptr), value.len, &napi_string), {237        return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);238    });239    AWS_NAPI_CALL(env, napi_set_named_property(env, object, key_name, napi_string), {240        return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);241    });242 243    return AWS_OP_SUCCESS;244}245 246int aws_napi_attach_object_property_optional_string(247    napi_value object,248    napi_env env,249    const char *key_name,250    const struct aws_byte_cursor *value) {251    if (value == NULL) {252        return AWS_OP_SUCCESS;253    }254 255    return aws_napi_attach_object_property_string(object, env, key_name, *value);256}257 258static void s_finalize_external_binary_byte_buf(napi_env env, void *finalize_data, void *finalize_hint) {259    (void)env;260    (void)finalize_data;261 262    struct aws_byte_buf *buffer = finalize_hint;263    if (buffer == NULL) {264        return;265    }266 267    struct aws_allocator *allocator = buffer->allocator;268    aws_byte_buf_clean_up(buffer);269    aws_mem_release(allocator, buffer);270}271 272int aws_napi_attach_object_property_binary_as_finalizable_external(273    napi_value object,274    napi_env env,275    const char *key_name,276    struct aws_byte_buf *data_buffer) {277 278    if (key_name == NULL) {279        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);280    }281 282    napi_value napi_binary = NULL;283 284    AWS_NAPI_ENSURE(285        env,286        aws_napi_create_external_arraybuffer(287            env,288            data_buffer->buffer,289            data_buffer->len,290            s_finalize_external_binary_byte_buf,291            data_buffer,292            &napi_binary));293 294    AWS_NAPI_CALL(env, napi_set_named_property(env, object, key_name, napi_binary), {295        return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);296    });297 298    return AWS_OP_SUCCESS;299}300 301enum aws_napi_get_named_property_result aws_napi_get_named_property(302    napi_env env,303    napi_value object,304    const char *name,305    napi_valuetype type,306    napi_value *result) {307 308    if (name == NULL) {309        return AWS_NGNPR_NO_VALUE;310    }311 312    bool has_property = false;313    if (napi_has_named_property(env, object, name, &has_property) || !has_property) {314        return AWS_NGNPR_NO_VALUE;315    }316 317    napi_value property = NULL;318    if (napi_get_named_property(env, object, name, &property)) {319        return AWS_NGNPR_NO_VALUE;320    }321 322    if (type != napi_undefined) {323        napi_valuetype property_type = napi_undefined;324        if (napi_typeof(env, property, &property_type)) {325            return AWS_NGNPR_INVALID_VALUE;326        }327 328        if (property_type != type) {329            return AWS_NGNPR_INVALID_VALUE;330        }331    }332 333    *result = property;334    return AWS_NGNPR_VALID_VALUE;335}336 337enum aws_napi_get_named_property_result aws_napi_get_named_property_as_uint16(338    napi_env env,339    napi_value object,340    const char *name,341    uint16_t *result) {342 343    napi_value node_result;344    enum aws_napi_get_named_property_result get_property_result =345        aws_napi_get_named_property(env, object, name, napi_number, &node_result);346    if (get_property_result != AWS_NGNPR_VALID_VALUE) {347        return get_property_result;348    }349 350    int64_t int_value = 0;351    AWS_NAPI_CALL(env, napi_get_value_int64(env, node_result, &int_value), { return AWS_NGNPR_INVALID_VALUE; });352 353    if (int_value < 0 || int_value > UINT16_MAX) {354        return AWS_NGNPR_INVALID_VALUE;355    }356 357    *result = (uint16_t)int_value;358    return AWS_NGNPR_VALID_VALUE;359}360 361enum aws_napi_get_named_property_result aws_napi_get_named_property_as_uint32(362    napi_env env,363    napi_value object,364    const char *name,365    uint32_t *result) {366 367    napi_value node_result;368    enum aws_napi_get_named_property_result get_property_result =369        aws_napi_get_named_property(env, object, name, napi_number, &node_result);370    if (get_property_result != AWS_NGNPR_VALID_VALUE) {371        return get_property_result;372    }373 374    int64_t int_value = 0;375    AWS_NAPI_CALL(env, napi_get_value_int64(env, node_result, &int_value), { return AWS_NGNPR_INVALID_VALUE; });376 377    if (int_value < 0 || int_value > UINT32_MAX) {378        return AWS_NGNPR_INVALID_VALUE;379    }380 381    *result = (uint32_t)int_value;382    return AWS_NGNPR_VALID_VALUE;383}384 385enum aws_napi_get_named_property_result aws_napi_get_named_property_as_uint64(386    napi_env env,387    napi_value object,388    const char *name,389    uint64_t *result) {390 391    napi_value node_result;392    enum aws_napi_get_named_property_result get_property_result =393        aws_napi_get_named_property(env, object, name, napi_number, &node_result);394    if (get_property_result != AWS_NGNPR_VALID_VALUE) {395        return get_property_result;396    }397 398    int64_t int_value = 0;399    AWS_NAPI_CALL(env, napi_get_value_int64(env, node_result, &int_value), { return AWS_NGNPR_INVALID_VALUE; });400 401    if (int_value < 0) {402        return AWS_NGNPR_INVALID_VALUE;403    }404 405    *result = (uint64_t)int_value;406    return AWS_NGNPR_VALID_VALUE;407}408 409enum aws_napi_get_named_property_result aws_napi_get_named_property_as_uint8(410    napi_env env,411    napi_value object,412    const char *name,413    uint8_t *result) {414 415    napi_value node_result;416    enum aws_napi_get_named_property_result get_property_result =417        aws_napi_get_named_property(env, object, name, napi_number, &node_result);418    if (get_property_result != AWS_NGNPR_VALID_VALUE) {419        return get_property_result;420    }421 422    int64_t int_value = 0;423    AWS_NAPI_CALL(env, napi_get_value_int64(env, node_result, &int_value), { return AWS_NGNPR_INVALID_VALUE; });424 425    if (int_value < 0 || int_value > UINT8_MAX) {426        return AWS_NGNPR_INVALID_VALUE;427    }428 429    *result = (uint8_t)int_value;430    return AWS_NGNPR_VALID_VALUE;431}432 433enum aws_napi_get_named_property_result aws_napi_get_named_property_as_int8(434    napi_env env,435    napi_value object,436    const char *name,437    int8_t *result) {438 439    napi_value node_result;440    enum aws_napi_get_named_property_result get_property_result =441        aws_napi_get_named_property(env, object, name, napi_number, &node_result);442    if (get_property_result != AWS_NGNPR_VALID_VALUE) {443        return get_property_result;444    }445 446    int64_t int_value = 0;447    AWS_NAPI_CALL(env, napi_get_value_int64(env, node_result, &int_value), { return AWS_NGNPR_INVALID_VALUE; });448 449    if (int_value < INT8_MIN || int_value > INT8_MAX) {450        return AWS_NGNPR_INVALID_VALUE;451    }452 453    *result = (int8_t)int_value;454    return AWS_NGNPR_VALID_VALUE;455}456 457enum aws_napi_get_named_property_result aws_napi_get_named_property_as_int16(458    napi_env env,459    napi_value object,460    const char *name,461    int16_t *result) {462 463    napi_value node_result;464    enum aws_napi_get_named_property_result get_property_result =465        aws_napi_get_named_property(env, object, name, napi_number, &node_result);466    if (get_property_result != AWS_NGNPR_VALID_VALUE) {467        return get_property_result;468    }469 470    int64_t int_value = 0;471    AWS_NAPI_CALL(env, napi_get_value_int64(env, node_result, &int_value), { return AWS_NGNPR_INVALID_VALUE; });472 473    if (int_value < INT16_MIN || int_value > INT16_MAX) {474        return AWS_NGNPR_INVALID_VALUE;475    }476 477    *result = (int16_t)int_value;478    return AWS_NGNPR_VALID_VALUE;479}480 481enum aws_napi_get_named_property_result aws_napi_get_named_property_as_int32(482    napi_env env,483    napi_value object,484    const char *name,485    int32_t *result) {486 487    napi_value node_result;488    enum aws_napi_get_named_property_result get_property_result =489        aws_napi_get_named_property(env, object, name, napi_number, &node_result);490    if (get_property_result != AWS_NGNPR_VALID_VALUE) {491        return get_property_result;492    }493 494    int64_t int_value = 0;495    AWS_NAPI_CALL(env, napi_get_value_int64(env, node_result, &int_value), { return AWS_NGNPR_INVALID_VALUE; });496 497    if (int_value < INT32_MIN || int_value > INT32_MAX) {498        return AWS_NGNPR_INVALID_VALUE;499    }500 501    *result = (int32_t)int_value;502    return AWS_NGNPR_VALID_VALUE;503}504 505enum aws_napi_get_named_property_result aws_napi_get_named_property_as_int64(506    napi_env env,507    napi_value object,508    const char *name,509    int64_t *result) {510 511    napi_value node_result;512    enum aws_napi_get_named_property_result get_property_result =513        aws_napi_get_named_property(env, object, name, napi_number, &node_result);514    if (get_property_result != AWS_NGNPR_VALID_VALUE) {515        return get_property_result;516    }517 518    AWS_NAPI_CALL(env, napi_get_value_int64(env, node_result, result), { return AWS_NGNPR_INVALID_VALUE; });519 520    return AWS_NGNPR_VALID_VALUE;521}522 523enum aws_napi_get_named_property_result aws_napi_get_named_property_as_boolean(524    napi_env env,525    napi_value object,526    const char *name,527    bool *result) {528    napi_value node_result;529    enum aws_napi_get_named_property_result get_property_result =530        aws_napi_get_named_property(env, object, name, napi_boolean, &node_result);531    if (get_property_result != AWS_NGNPR_VALID_VALUE) {532        return get_property_result;533    }534 535    AWS_NAPI_CALL(env, napi_get_value_bool(env, node_result, result), { return AWS_NGNPR_INVALID_VALUE; });536 537    return AWS_NGNPR_VALID_VALUE;538}539 540enum aws_napi_get_named_property_result aws_napi_get_named_property_boolean_as_uint8(541    napi_env env,542    napi_value object,543    const char *name,544    uint8_t *result) {545    napi_value node_result;546    enum aws_napi_get_named_property_result get_property_result =547        aws_napi_get_named_property(env, object, name, napi_boolean, &node_result);548    if (get_property_result != AWS_NGNPR_VALID_VALUE) {549        return get_property_result;550    }551 552    bool bool_result = false;553    AWS_NAPI_CALL(env, napi_get_value_bool(env, node_result, &bool_result), { return AWS_NGNPR_INVALID_VALUE; });554 555    *result = bool_result ? 1 : 0;556 557    return AWS_NGNPR_VALID_VALUE;558}559 560enum aws_napi_get_named_property_result aws_napi_get_named_property_as_bytebuf(561    napi_env env,562    napi_value object,563    const char *name,564    napi_valuetype type,565    struct aws_byte_buf *result) {566 567    napi_value node_result;568    enum aws_napi_get_named_property_result get_property_result =569        aws_napi_get_named_property(env, object, name, type, &node_result);570    if (get_property_result != AWS_NGNPR_VALID_VALUE) {571        return get_property_result;572    }573 574    AWS_NAPI_CALL(env, aws_byte_buf_init_from_napi(result, env, node_result), { return AWS_NGNPR_INVALID_VALUE; });575 576    return AWS_NGNPR_VALID_VALUE;577}578 579enum aws_napi_get_named_property_result aws_napi_get_named_property_buffer_length(580    napi_env env,581    napi_value object,582    const char *name,583    napi_valuetype type,584    size_t *length_out) {585 586    struct aws_byte_buf buffer;587    AWS_ZERO_STRUCT(buffer);588 589    enum aws_napi_get_named_property_result result =590        aws_napi_get_named_property_as_bytebuf(env, object, name, type, &buffer);591    if (result == AWS_NGNPR_VALID_VALUE) {592        *length_out = buffer.len;593    }594 595    aws_byte_buf_clean_up(&buffer);596 597    return result;598}599 600static int s_typed_array_element_type_to_byte_length(napi_typedarray_type type, size_t *element_length) {601    switch (type) {602        case napi_int8_array:603        case napi_uint8_array:604        case napi_uint8_clamped_array:605            *element_length = 1;606            return AWS_OP_SUCCESS;607 608        case napi_int16_array:609        case napi_uint16_array:610            *element_length = 2;611            return AWS_OP_SUCCESS;612 613        case napi_int32_array:614        case napi_uint32_array:615        case napi_float32_array:616            *element_length = 4;617            return AWS_OP_SUCCESS;618 619        case napi_float64_array:620        case 9:  /*napi_bigint64_array */621        case 10: /*napi_biguint64_array*/622            *element_length = 8;623            return AWS_OP_SUCCESS;624    }625 626    return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);627}628 629napi_status aws_byte_buf_init_from_napi(struct aws_byte_buf *buf, napi_env env, napi_value node_str) {630 631    AWS_ASSERT(buf);632 633    napi_valuetype type = napi_undefined;634    AWS_NAPI_CALL(env, napi_typeof(env, node_str, &type), { return status; });635 636    if (type == napi_string) {637 638        size_t length = 0;639        AWS_NAPI_CALL(env, napi_get_value_string_utf8(env, node_str, NULL, 0, &length), { return status; });640 641        /* Node requires that the null terminator be written */642        if (aws_byte_buf_init(buf, aws_napi_get_allocator(), length + 1)) {643            return napi_generic_failure;644        }645 646        AWS_NAPI_CALL(env, napi_get_value_string_utf8(env, node_str, (char *)buf->buffer, buf->capacity, &buf->len), {647            return status;648        });649        AWS_ASSERT(length == buf->len);650        return napi_ok;651 652    } else if (type == napi_object) {653 654        bool is_expected = false;655 656        /* Try ArrayBuffer */657        AWS_NAPI_CALL(env, napi_is_arraybuffer(env, node_str, &is_expected), { return status; });658        if (is_expected) {659            napi_status status = napi_get_arraybuffer_info(env, node_str, (void **)&buf->buffer, &buf->len);660            buf->capacity = buf->len;661            return status;662        }663 664        /* Try DataView */665        AWS_NAPI_CALL(env, napi_is_dataview(env, node_str, &is_expected), { return status; });666        if (is_expected) {667            napi_status status = napi_get_dataview_info(env, node_str, &buf->len, (void **)&buf->buffer, NULL, NULL);668            buf->capacity = buf->len;669            return status;670        }671 672        /* Try TypedArray */673        AWS_NAPI_CALL(env, napi_is_typedarray(env, node_str, &is_expected), { return status; });674        if (is_expected) {675            napi_typedarray_type array_type = napi_uint8_array;676            size_t length = 0;677            AWS_NAPI_CALL(678                env, napi_get_typedarray_info(env, node_str, &array_type, &length, (void **)&buf->buffer, NULL, NULL), {679                    return status;680                });681 682            size_t element_size = 0;683            if (s_typed_array_element_type_to_byte_length(array_type, &element_size)) {684                return napi_invalid_arg;685            }686 687            buf->len = length * element_size;688            buf->capacity = buf->len;689 690            return napi_ok;691        }692    }693 694    return napi_invalid_arg;695}696 697int aws_napi_value_get_storage_length(napi_env env, napi_value value, size_t *storage_length) {698 699    napi_valuetype type = napi_undefined;700    AWS_NAPI_CALL(env, napi_typeof(env, value, &type), { return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE); });701 702    if (type == napi_string) {703        AWS_NAPI_CALL(env, napi_get_value_string_utf8(env, value, NULL, 0, storage_length), {704            return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);705        });706 707        return AWS_OP_SUCCESS;708    } else if (type == napi_object) {709        /* Try ArrayBuffer */710        bool is_array_buffer = false;711        AWS_NAPI_CALL(env, napi_is_arraybuffer(env, value, &is_array_buffer), {712            return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);713        });714        if (is_array_buffer) {715            void *buffer = NULL;716            AWS_NAPI_CALL(env, napi_get_arraybuffer_info(env, value, &buffer, storage_length), {717                return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);718            });719 720            return AWS_OP_SUCCESS;721        }722 723        /* Try DataView */724        bool is_data_view = false;725        AWS_NAPI_CALL(env, napi_is_dataview(env, value, &is_data_view), {726            return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);727        });728        if (is_data_view) {729            AWS_NAPI_CALL(env, napi_get_dataview_info(env, value, storage_length, NULL, NULL, NULL), {730                return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);731            });732 733            return AWS_OP_SUCCESS;734        }735 736        /* Try TypedArray */737        bool is_typed_array = false;738        AWS_NAPI_CALL(env, napi_is_typedarray(env, value, &is_typed_array), {739            return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);740        });741        if (is_typed_array) {742            napi_typedarray_type array_type = napi_uint8_array;743            size_t length = 0;744            AWS_NAPI_CALL(env, napi_get_typedarray_info(env, value, &array_type, &length, NULL, NULL, NULL), {745                return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);746            });747 748            size_t element_size = 0;749            if (s_typed_array_element_type_to_byte_length(array_type, &element_size)) {750                return napi_invalid_arg;751            }752 753            *storage_length = length * element_size;754 755            return AWS_OP_SUCCESS;756        }757    }758 759    return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);760}761 762int aws_napi_value_bytebuf_append(763    napi_env env,764    napi_value value,765    struct aws_byte_buf *output_buffer,766    struct aws_byte_cursor *bytes_written_cursor) {767 768    AWS_ZERO_STRUCT(*bytes_written_cursor);769 770    napi_valuetype type = napi_undefined;771    AWS_NAPI_CALL(env, napi_typeof(env, value, &type), { return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT); });772 773    size_t open_bytes = output_buffer->capacity - output_buffer->len;774    uint8_t *open_space = output_buffer->buffer + output_buffer->len;775 776    if (type == napi_string) {777        size_t bytes_written = 0;778        AWS_NAPI_CALL(env, napi_get_value_string_utf8(env, value, (char *)open_space, open_bytes, &bytes_written), {779            return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);780        });781 782        /* technically, we might have been truncated, but there's no way to tell */783        bytes_written_cursor->ptr = open_space;784        bytes_written_cursor->len = bytes_written;785        output_buffer->len += bytes_written;786 787        return AWS_OP_SUCCESS;788    } else if (type == napi_object) {789        /* Try ArrayBuffer */790        bool is_array_buffer = false;791        AWS_NAPI_CALL(env, napi_is_arraybuffer(env, value, &is_array_buffer), {792            return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);793        });794        if (is_array_buffer) {795            void *buffer = NULL;796            size_t buffer_length = 0;797            AWS_NAPI_CALL(env, napi_get_arraybuffer_info(env, value, &buffer, &buffer_length), {798                return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);799            });800 801            bytes_written_cursor->ptr = buffer;802            bytes_written_cursor->len = buffer_length;803 804            return aws_byte_buf_append_and_update(output_buffer, bytes_written_cursor);805        }806 807        /* Try DataView */808        bool is_data_view = false;809        AWS_NAPI_CALL(env, napi_is_dataview(env, value, &is_data_view), {810            return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);811        });812        if (is_data_view) {813            void *buffer = NULL;814            size_t buffer_length = 0;815            AWS_NAPI_CALL(env, napi_get_dataview_info(env, value, &buffer_length, &buffer, NULL, NULL), {816                return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);817            });818 819            bytes_written_cursor->ptr = buffer;820            bytes_written_cursor->len = buffer_length;821 822            return aws_byte_buf_append_and_update(output_buffer, bytes_written_cursor);823        }824 825        bool is_typed_array = false;826        AWS_NAPI_CALL(env, napi_is_typedarray(env, value, &is_typed_array), {827            return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);828        });829        if (is_typed_array) {830            napi_typedarray_type array_type = napi_uint8_array;831            size_t length = 0;832            uint8_t *buffer = NULL;833            AWS_NAPI_CALL(834                env, napi_get_typedarray_info(env, value, &array_type, &length, (void **)&buffer, NULL, NULL), {835                    return aws_raise_error(AWS_CRT_NODEJS_ERROR_NAPI_FAILURE);836                });837 838            size_t element_size = 0;839            if (s_typed_array_element_type_to_byte_length(array_type, &element_size)) {840                return napi_invalid_arg;841            }842 843            bytes_written_cursor->ptr = buffer;844            bytes_written_cursor->len = element_size * length;845 846            return aws_byte_buf_append_and_update(output_buffer, bytes_written_cursor);847        }848    }849 850    return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);851}852 853struct aws_string *aws_string_new_from_napi(napi_env env, napi_value node_str) {854 855    struct aws_byte_buf temp_buf;856    if (aws_byte_buf_init_from_napi(&temp_buf, env, node_str)) {857        return NULL;858    }859 860    struct aws_string *string = aws_string_new_from_array(aws_napi_get_allocator(), temp_buf.buffer, temp_buf.len);861    aws_byte_buf_clean_up(&temp_buf);862    return string;863}864 865napi_status aws_napi_create_dataview_from_byte_cursor(866    napi_env env,867    const struct aws_byte_cursor *cur,868    napi_value *result) {869 870    void *data = NULL;871    napi_value arraybuffer;872    AWS_NAPI_CALL(env, napi_create_arraybuffer(env, cur->len, &data, &arraybuffer), { return status; });873 874    struct aws_byte_buf arraybuffer_buf = aws_byte_buf_from_empty_array(data, cur->len);875    struct aws_byte_cursor input = *cur;876    if (!aws_byte_buf_write_from_whole_cursor(&arraybuffer_buf, input)) {877        return napi_generic_failure;878    }879 880    AWS_NAPI_CALL(env, napi_create_dataview(env, cur->len, arraybuffer, 0, result), { return status; });881 882    return napi_ok;883}884 885bool aws_napi_is_null_or_undefined(napi_env env, napi_value value) {886 887    napi_valuetype type = napi_undefined;888    if (napi_ok != napi_typeof(env, value, &type)) {889        return true;890    }891 892    return type == napi_null || type == napi_undefined;893}894 895int aws_napi_get_property_array_size(896    napi_env env,897    napi_value object,898    const char *property_name,899    size_t *array_size_out) {900    napi_value napi_array = NULL;901    enum aws_napi_get_named_property_result get_result =902        aws_napi_get_named_property(env, object, property_name, napi_object, &napi_array);903    if (get_result == AWS_NGNPR_NO_VALUE) {904        *array_size_out = 0;905        return AWS_OP_SUCCESS;906    } else if (get_result == AWS_NGNPR_INVALID_VALUE) {907        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);908    }909 910    uint32_t array_size = 0;911    AWS_NAPI_CALL(env, napi_get_array_length(env, napi_array, &array_size), {912        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);913    });914 915    *array_size_out = (size_t)array_size;916 917    return AWS_OP_SUCCESS;918}919 920void s_aws_enable_threadsafe_function(void) {921    aws_rw_lock_wlock(&s_tsfn_lock);922    s_tsfn_enabled = true;923    aws_rw_lock_wunlock(&s_tsfn_lock);924}925 926void s_aws_disable_threadsafe_function(void) {927    aws_rw_lock_wlock(&s_tsfn_lock);928    s_tsfn_enabled = false;929    aws_rw_lock_wunlock(&s_tsfn_lock);930}931 932napi_value aws_napi_disable_threadsafe_function(napi_env env, napi_callback_info info) {933    (void)info;934    if (env == NULL) {935        aws_raise_error(AWS_CRT_NODEJS_ERROR_THREADSAFE_FUNCTION_NULL_NAPI_ENV);936        return NULL;937    }938    s_aws_disable_threadsafe_function();939    return NULL;940}941 942void aws_napi_throw_last_error(napi_env env) {943    const int error_code = aws_last_error();944    napi_throw_error(env, aws_error_str(error_code), aws_error_debug_str(error_code));945}946 947void aws_napi_throw_last_error_with_context(napi_env env, const char *context) {948    const int error_code = aws_last_error();949 950    char full_msg[1024];951    snprintf(952        full_msg,953        AWS_ARRAY_SIZE(full_msg),954        "%s : (%s - %s)",955        context,956        aws_error_str(error_code),957        aws_error_debug_str(error_code));958    napi_throw_error(env, aws_error_str(error_code), full_msg);959}960 961struct uv_loop_s *aws_napi_get_node_uv_loop(void) {962    return s_node_uv_loop;963}964 965struct aws_event_loop *aws_napi_get_node_event_loop(void) {966    return s_node_uv_event_loop;967}968 969struct aws_event_loop_group *aws_napi_get_node_elg(void) {970    return s_node_uv_elg;971}972 973struct aws_client_bootstrap *aws_napi_get_default_client_bootstrap(void) {974    return s_default_client_bootstrap;975}976 977/* The napi_status enum has grown, and is not bound by N-API versioning */978#if defined(__clang__) || defined(__GNUC__)979#    pragma GCC diagnostic push980#    pragma GCC diagnostic ignored "-Wswitch"981#endif982 983const char *aws_napi_status_to_str(napi_status status) {984    const char *reason = "UNKNOWN";985    switch (status) {986        case napi_ok:987            reason = "OK";988            break;989        case napi_invalid_arg:990            reason = "napi_invalid_arg: an invalid argument was supplied";991            break;992        case napi_object_expected:993            reason = "napi_object_expected";994            break;995        case napi_string_expected:996            reason = "napi_name_expected";997            break;998        case napi_name_expected:999            reason = "napi_name_expected";1000            break;1001        case napi_function_expected:1002            reason = "napi_function_expected";1003            break;1004        case napi_number_expected:1005            reason = "napi_number_expected";1006            break;1007        case napi_boolean_expected:1008            reason = "napi_boolean_expected";1009            break;1010        case napi_array_expected:1011            reason = "napi_array_expected";1012            break;1013        case napi_generic_failure:1014            reason = "napi_generic_failure";1015            break;1016        case napi_pending_exception:1017            reason = "napi_pending_exception";1018            break;1019        case napi_cancelled:1020            reason = "napi_cancelled";1021            break;1022        case napi_escape_called_twice:1023            reason = "napi_escape_called_twice";1024            break;1025        case napi_handle_scope_mismatch:1026            reason = "napi_handle_scope_mismatch";1027            break;1028        case napi_callback_scope_mismatch:1029            reason = "napi_callback_scope_mismatch";1030            break;1031        case napi_queue_full:1032            reason = "napi_queue_full";1033            break;1034        case napi_closing:1035            reason = "napi_closing";1036            break;1037        case napi_bigint_expected:1038            reason = "napi_bigint_expected";1039            break;1040        case NAPI_NO_EXTERNAL_BUFFER_ENUM_VALUE:1041            reason = "napi_no_external_buffers_allowed";1042            break;1043    }1044    return reason;1045}1046 1047#if defined(__clang__) || defined(__GNUC__)1048#    pragma GCC diagnostic pop1049#endif1050 1051static void s_handle_failed_callback(napi_env env, napi_value function, napi_status reason) {1052    /* Figure out if there's an exception pending, if so, no callbacks will ever succeed again until it's cleared */1053    bool pending_exception = reason == napi_pending_exception;1054    AWS_NAPI_ENSURE(env, napi_is_exception_pending(env, &pending_exception));1055    /* if there's no pending exception, but failure occurred, log what we can find and get out */1056    if (!pending_exception) {1057        const napi_extended_error_info *node_error_info = NULL;1058        AWS_NAPI_ENSURE(env, napi_get_last_error_info(env, &node_error_info));1059        AWS_NAPI_LOGF_ERROR(1060            "Extended error info: engine_error_code=%u error_code=%s error_message=%s",1061            node_error_info->engine_error_code,1062            aws_napi_status_to_str(node_error_info->error_code),1063            node_error_info->error_message);1064        return;1065    }1066    /* get the current exception and report it, and clear it so that execution can continue */1067    napi_value node_exception = NULL;1068    AWS_NAPI_ENSURE(env, napi_get_and_clear_last_exception(env, &node_exception));1069 1070    /* figure out what the exception is */1071    bool is_error = false;1072    AWS_NAPI_ENSURE(env, napi_is_error(env, node_exception, &is_error));1073 1074    /*1075     * Convert the function to a string. If it's a lambda, this will produce the source of the lambda, if1076     * it's a class function or free function, it will produce the name1077     */1078    napi_value node_function_str = NULL;1079    AWS_NAPI_ENSURE(env, napi_coerce_to_string(env, function, &node_function_str));1080    struct aws_string *function_str = aws_string_new_from_napi(env, node_function_str);1081    if (function_str) {1082        AWS_NAPI_LOGF_ERROR("Calling %s", aws_string_c_str(function_str));1083    }1084 1085    /* If it's an Error, extract info from it and log it */1086    if (is_error) {1087        /* get the Error.message field */1088        napi_value node_message = NULL;1089        AWS_NAPI_ENSURE(env, napi_get_named_property(env, node_exception, "message", &node_message));1090 1091        /* extract and log the message */1092        struct aws_string *message = aws_string_new_from_napi(env, node_message);1093        if (message) {1094            AWS_NAPI_LOGF_ERROR("Error: %s", aws_string_bytes(message));1095            aws_string_destroy(message);1096        } else {1097            AWS_NAPI_LOGF_ERROR("aws_string_new_from_napi(exception.message) failed");1098            return;1099        }1100 1101        /* get the Error.stack field */1102        napi_value node_stack = NULL;1103        AWS_NAPI_ENSURE(env, napi_get_named_property(env, node_exception, "stack", &node_stack));1104 1105        /* extract and log the stack trace */1106        struct aws_string *stacktrace = aws_string_new_from_napi(env, node_stack);1107        if (stacktrace) {1108            AWS_NAPI_LOGF_ERROR("Stack:\n%s", aws_string_bytes(stacktrace));1109            aws_string_destroy(stacktrace);1110        } else {1111            AWS_NAPI_LOGF_ERROR("aws_string_new_from_napi(exception.stack) failed");1112            return;1113        }1114 1115        /* the Error has been reported and cleared, that's all we can do */1116        return;1117    }1118 1119    /* The last thing thrown was some other sort of object/primitive, so convert it to a string and log it */1120    napi_value node_error_str = NULL;1121    AWS_NAPI_ENSURE(env, napi_coerce_to_string(env, node_exception, &node_error_str));1122 1123    struct aws_string *error_str = aws_string_new_from_napi(env, node_error_str);1124    if (error_str) {1125        AWS_NAPI_LOGF_ERROR("Error: %s", aws_string_bytes(error_str));1126    } else {1127        AWS_NAPI_LOGF_ERROR("aws_string_new_from_napi(ToString(exception)) failed");1128        return;1129    }1130}1131 1132napi_status aws_napi_create_external_arraybuffer(1133    napi_env env,1134    void *external_data,1135    size_t byte_length,1136    napi_finalize finalize_cb,1137    void *finalize_hint,1138    napi_value *result) {1139 1140    napi_status external_buffer_status =1141        napi_create_external_arraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, result);1142 1143    if (external_buffer_status == NAPI_NO_EXTERNAL_BUFFER_ENUM_VALUE) {1144 1145        // The external buffer is disabled, manually copy the external_data into Node1146        void *napi_buf_data = NULL;1147        napi_status create_arraybuffer_status = napi_create_arraybuffer(env, byte_length, &napi_buf_data, result);1148 1149        if (create_arraybuffer_status != napi_ok) {1150            AWS_NAPI_LOGF_ERROR(1151                "napi_create_arraybuffer (in aws_napi_create_external_arraybuffer) failed with : %s",1152                aws_napi_status_to_str(create_arraybuffer_status));1153            return create_arraybuffer_status;1154        }1155 1156        memcpy(napi_buf_data, external_data, byte_length);1157 1158        // As the data has been copied into the Node, invoke the finalize callback to make sure the1159        // data is released.1160        finalize_cb(env, finalize_hint, finalize_hint);1161    }1162 1163    return napi_ok;1164}1165 1166napi_status aws_napi_dispatch_threadsafe_function(1167    napi_env env,1168    napi_threadsafe_function tsfn,1169    napi_value this_ptr,1170    napi_value function,1171    size_t argc,1172    napi_value *argv) {1173 1174    aws_rw_lock_rlock(&s_tsfn_lock);1175    napi_status result = napi_ok;1176    if (s_tsfn_enabled) {1177        napi_status call_status = napi_ok;1178        if (!this_ptr) {1179            AWS_NAPI_ENSURE(env, napi_get_undefined(env, &this_ptr));1180        }1181        AWS_NAPI_CALL(env, napi_call_function(env, this_ptr, function, argc, argv, NULL), {1182            call_status = status;1183            s_handle_failed_callback(env, function, status);1184        });1185        /* main thread can exit now */1186        napi_unref_threadsafe_function(env, tsfn);1187        /* Must always decrement the ref count, or the function will be pinned */1188        napi_status release_status = napi_release_threadsafe_function(tsfn, napi_tsfn_release);1189        result = (call_status != napi_ok) ? call_status : release_status;1190    }1191    aws_rw_lock_runlock(&s_tsfn_lock);1192    return result;1193}1194 1195napi_status aws_napi_create_threadsafe_function(1196    napi_env env,1197    napi_value function,1198    const char *name,1199    napi_threadsafe_function_call_js call_js,1200    void *context,1201    napi_threadsafe_function *result) {1202 1203    napi_value resource_name = NULL;1204    AWS_NAPI_ENSURE(env, napi_create_string_utf8(env, name, NAPI_AUTO_LENGTH, &resource_name));1205 1206    return napi_create_threadsafe_function(1207        env,1208        function,1209        NULL /*async_resource*/,1210        resource_name,1211        0 /*max_queue_size - 0 means no limit*/,1212        1 /*initial_thread_count*/,1213        NULL /*thread_finalize_data*/,1214        NULL /*thread_finalize_cb*/,1215        context,1216        call_js,1217        result);1218}1219 1220napi_status aws_napi_release_threadsafe_function(1221    napi_threadsafe_function function,1222    napi_threadsafe_function_release_mode mode) {1223    napi_status result = napi_ok;1224    aws_rw_lock_rlock(&s_tsfn_lock);1225    if (s_tsfn_enabled && function) {1226        result = napi_release_threadsafe_function(function, mode);1227    }1228    aws_rw_lock_runlock(&s_tsfn_lock);1229    return result;1230}1231 1232napi_status aws_napi_acquire_threadsafe_function(napi_threadsafe_function function) {1233    napi_status result = napi_ok;1234    aws_rw_lock_rlock(&s_tsfn_lock);1235    if (s_tsfn_enabled && function) {1236        result = napi_acquire_threadsafe_function(function);1237    }1238    aws_rw_lock_runlock(&s_tsfn_lock);1239    return result;1240}1241 1242napi_status aws_napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function function) {1243    napi_status result = napi_ok;1244    aws_rw_lock_rlock(&s_tsfn_lock);1245    if (s_tsfn_enabled && function) {1246        result = napi_unref_threadsafe_function(env, function);1247    }1248    aws_rw_lock_runlock(&s_tsfn_lock);1249    return result;1250}1251 1252napi_status aws_napi_queue_threadsafe_function(napi_threadsafe_function function, void *user_data) {1253    napi_status result = napi_ok;1254    aws_rw_lock_rlock(&s_tsfn_lock);1255    if (s_tsfn_enabled && function) {1256        /* increase the ref count, gets decreased when the call completes */1257        AWS_NAPI_ENSURE(NULL, napi_acquire_threadsafe_function(function));1258        result = napi_call_threadsafe_function(function, user_data, napi_tsfn_nonblocking);1259    }1260    aws_rw_lock_runlock(&s_tsfn_lock);1261    return result;1262}1263 1264AWS_STATIC_STRING_FROM_LITERAL(s_mem_tracing_env_var, "AWS_CRT_MEMORY_TRACING");1265static struct aws_allocator *s_allocator = NULL;1266struct aws_allocator *aws_napi_get_allocator(void) {1267    if (AWS_UNLIKELY(s_allocator == NULL)) {1268        struct aws_string *value = NULL;1269        if (aws_get_environment_value(aws_default_allocator(), s_mem_tracing_env_var, &value) || value == NULL) {1270            return s_allocator = aws_default_allocator();1271        }1272 1273        int level = atoi(aws_string_c_str(value));1274        if (level < AWS_MEMTRACE_NONE || level > AWS_MEMTRACE_STACKS) {1275            /* this can't go through logging, because it happens before logging is set up */1276            fprintf(1277                stderr,1278                "AWS_CRT_MEMORY_TRACING is set to invalid value: %s, must be 0 (none), 1 (bytes), or 2 (stacks)",1279                aws_string_bytes(value));1280            level = AWS_MEMTRACE_NONE;1281        }1282        s_allocator = aws_mem_tracer_new(aws_default_allocator(), NULL, level, 16);1283    }1284    return s_allocator;1285}1286 1287napi_value aws_napi_native_memory(napi_env env, napi_callback_info info) {1288    (void)info;1289    napi_value node_allocated = NULL;1290    size_t allocated = 0;1291    if (aws_napi_get_allocator() != aws_default_allocator()) {1292        allocated = aws_mem_tracer_bytes(aws_napi_get_allocator());1293    }1294    AWS_NAPI_CALL(env, napi_create_int64(env, allocated, &node_allocated), { return NULL; });1295    return node_allocated;1296}1297 1298napi_value aws_napi_native_memory_dump(napi_env env, napi_callback_info info) {1299    (void)info;1300    (void)env;1301    if (aws_napi_get_allocator() != aws_default_allocator()) {1302        aws_mem_tracer_dump(aws_napi_get_allocator());1303    }1304    return NULL;1305}1306 1307#if defined(_WIN32)1308#    include <windows.h>1309static LONG WINAPI s_print_stack_trace(struct _EXCEPTION_POINTERS *exception_pointers) {1310    aws_backtrace_print(stderr, exception_pointers);1311    return EXCEPTION_EXECUTE_HANDLER;1312}1313#elif defined(AWS_HAVE_EXECINFO)1314#    include <signal.h>1315static void s_print_stack_trace(int sig, siginfo_t *sig_info, void *user_data) {1316    (void)sig;1317    (void)sig_info;1318    (void)user_data;1319    aws_backtrace_print(stderr, sig_info);1320    exit(-1);1321}1322#endif1323 1324static void s_install_crash_handler(void) {1325#if defined(_WIN32)1326    SetUnhandledExceptionFilter(s_print_stack_trace);1327#elif defined(AWS_HAVE_EXECINFO)1328    struct sigaction sa;1329    memset(&sa, 0, sizeof(struct sigaction));1330    sigemptyset(&sa.sa_mask);1331 1332    sa.sa_flags = SA_NODEFER;1333    sa.sa_sigaction = s_print_stack_trace;1334 1335    sigaction(SIGSEGV, &sa, NULL);1336    sigaction(SIGABRT, &sa, NULL);1337    sigaction(SIGILL, &sa, NULL);1338    sigaction(SIGBUS, &sa, NULL);1339#endif1340}1341 1342static void s_uninstall_crash_handler(void) {1343#if defined(_WIN32)1344    SetUnhandledExceptionFilter(NULL);1345#elif defined(AWS_HAVE_EXECINFO)1346    sigaction(SIGSEGV, NULL, NULL);1347    sigaction(SIGABRT, NULL, NULL);1348    sigaction(SIGILL, NULL, NULL);1349    sigaction(SIGBUS, NULL, NULL);1350#endif1351}1352 1353static struct aws_mutex s_module_lock = AWS_MUTEX_INIT;1354static uint32_t s_module_initialize_count = 0;1355 1356static void s_napi_context_finalize(napi_env env, void *user_data, void *finalize_hint) {1357    (void)env;1358    (void)finalize_hint;1359 1360    aws_mutex_lock(&s_module_lock);1361    AWS_FATAL_ASSERT(s_module_initialize_count > 0);1362    --s_module_initialize_count;1363 1364    if (s_module_initialize_count == 0) {1365 1366        aws_client_bootstrap_release(s_default_client_bootstrap);1367        s_default_client_bootstrap = NULL;1368 1369        aws_host_resolver_release(s_default_host_resolver);1370        s_default_host_resolver = NULL;1371 1372        aws_event_loop_group_release(s_node_uv_elg);1373        s_node_uv_elg = NULL;1374 1375        aws_thread_join_all_managed();1376 1377        aws_unregister_log_subject_info_list(&s_log_subject_list);1378        aws_unregister_error_info(&s_error_list);1379        aws_event_stream_library_clean_up();1380        aws_auth_library_clean_up();1381        aws_mqtt_library_clean_up();1382 1383        s_uninstall_crash_handler();1384        // clean up threadsafe function lock1385        aws_rw_lock_clean_up(&s_tsfn_lock);1386    }1387 1388    struct aws_napi_context *ctx = user_data;1389    aws_napi_logger_destroy(ctx->logger);1390    struct aws_allocator *ctx_allocator = ctx->allocator;1391    aws_mem_release(ctx->allocator, ctx);1392 1393    if (s_module_initialize_count == 0) {1394        if (ctx_allocator != aws_default_allocator()) {1395            if (s_allocator == ctx_allocator) {1396                s_allocator = NULL;1397            }1398            aws_mem_tracer_destroy(ctx_allocator);1399        }1400    }1401    aws_mutex_unlock(&s_module_lock);1402}1403 1404static struct aws_napi_context *s_napi_context_new(struct aws_allocator *allocator, napi_env env, napi_value exports) {1405    struct aws_napi_context *ctx = aws_mem_calloc(allocator, 1, sizeof(struct aws_napi_context));1406    AWS_FATAL_ASSERT(ctx && "Failed to initialize napi context");1407    ctx->allocator = allocator;1408 1409    /* bind the context to exports, thus binding its lifetime to that object */1410    AWS_NAPI_ENSURE(env, napi_wrap(env, exports, ctx, s_napi_context_finalize, NULL, NULL));1411 1412    ctx->logger = aws_napi_logger_new(allocator, env);1413 1414    return ctx;1415}1416 1417/** Helper for creating and registering a function */1418static bool s_create_and_register_function(1419    napi_env env,1420    napi_value exports,1421    napi_callback fn,1422    const char *fn_name,1423    size_t fn_name_len) {1424 1425    napi_value napi_fn;1426    AWS_NAPI_CALL(env, napi_create_function(env, fn_name, fn_name_len, fn, NULL, &napi_fn), {1427        napi_throw_error(env, NULL, "Unable to wrap native function");1428        return false;1429    });1430 1431    AWS_NAPI_CALL(env, napi_set_named_property(env, exports, fn_name, napi_fn), {1432        napi_throw_error(env, NULL, "Unable to populate exports");1433        return false;1434    });1435 1436    return true;1437}1438 1439#if defined(__clang__) || defined(__GNUC__)1440/* Suppress compiler warnings about NAPI_MODULE_INIT().1441 * See: https://github.com/nodejs/node/pull/49103 */1442#    pragma GCC diagnostic ignored "-Wstrict-prototypes"1443#endif1444 1445/* napi_value */ NAPI_MODULE_INIT() /* (napi_env env, napi_value exports) */ {1446 1447    aws_mutex_lock(&s_module_lock);1448 1449    struct aws_allocator *allocator = aws_napi_get_allocator();1450 1451    if (s_module_initialize_count == 0) {1452        aws_rw_lock_init(&s_tsfn_lock);1453        s_aws_enable_threadsafe_function();1454 1455        s_install_crash_handler();1456 1457        aws_mqtt_library_init(allocator);1458        aws_auth_library_init(allocator);1459        aws_event_stream_library_init(allocator);1460        aws_register_error_info(&s_error_list);1461        aws_register_log_subject_info_list(&s_log_subject_list);1462 1463        /* Initialize the event loop group */1464        /*1465         * We don't currently support multi-init of the module, but we should.1466         * Things that would need to be solved:1467         *    (1) global objects (event loop group, logger, allocator, more)1468         *    (2) multi-init/multi-cleanup of aws-c-*1469         *    (3) allocator cross-talk/lifetimes1470         */1471        AWS_FATAL_ASSERT(s_node_uv_elg == NULL);1472        s_node_uv_elg = aws_event_loop_group_new_default(allocator, 1, NULL);1473        AWS_FATAL_ASSERT(s_node_uv_elg != NULL);1474 1475        /*1476         * Default host resolver and client bootstrap to use if none specific at the javascript level.  In most1477         * cases the user doesn't even need to know about these, so let's let them leave it out completely.1478         */1479        AWS_FATAL_ASSERT(s_default_host_resolver == NULL);1480 1481        struct aws_host_resolver_default_options resolver_options = {1482            .max_entries = 64,1483            .el_group = s_node_uv_elg,1484        };1485        s_default_host_resolver = aws_host_resolver_new_default(allocator, &resolver_options);1486        AWS_FATAL_ASSERT(s_default_host_resolver != NULL);1487 1488        AWS_FATAL_ASSERT(s_default_client_bootstrap == NULL);1489 1490        struct aws_client_bootstrap_options bootstrap_options = {1491            .event_loop_group = s_node_uv_elg,1492            .host_resolver = s_default_host_resolver,1493        };1494 1495        s_default_client_bootstrap = aws_client_bootstrap_new(allocator, &bootstrap_options);1496 1497        AWS_FATAL_ASSERT(s_default_client_bootstrap != NULL);1498    }1499 1500    ++s_module_initialize_count;1501 1502    aws_mutex_unlock(&s_module_lock);1503 1504    /* context is bound to exports, will be cleaned up by finalizer */1505    s_napi_context_new(allocator, env, exports);1506 1507    napi_value null;1508    napi_get_null(env, &null);1509 1510#define CREATE_AND_REGISTER_FN(fn)                                                                                     \1511    if (!s_create_and_register_function(env, exports, aws_napi_##fn, #fn, sizeof(#fn))) {                              \1512        return null;                                                                                                   \1513    }1514 1515    /* Common */1516    CREATE_AND_REGISTER_FN(native_memory)1517    CREATE_AND_REGISTER_FN(native_memory_dump)1518    CREATE_AND_REGISTER_FN(error_code_to_string)1519    CREATE_AND_REGISTER_FN(error_code_to_name)1520    CREATE_AND_REGISTER_FN(disable_threadsafe_function)1521 1522    /* IO */1523    CREATE_AND_REGISTER_FN(io_logging_enable)1524    CREATE_AND_REGISTER_FN(is_alpn_available)1525    CREATE_AND_REGISTER_FN(io_client_bootstrap_new)1526    CREATE_AND_REGISTER_FN(io_tls_cipher_preference_is_supported)1527    CREATE_AND_REGISTER_FN(io_tls_ctx_new)1528    CREATE_AND_REGISTER_FN(io_tls_connection_options_new);1529    CREATE_AND_REGISTER_FN(io_socket_options_new)1530    CREATE_AND_REGISTER_FN(io_input_stream_new)1531    CREATE_AND_REGISTER_FN(io_input_stream_append)1532    CREATE_AND_REGISTER_FN(io_pkcs11_lib_new)1533    CREATE_AND_REGISTER_FN(io_pkcs11_lib_close)1534 1535    /* MQTT Request Response */1536    CREATE_AND_REGISTER_FN(mqtt_request_response_client_new_from_5)1537    CREATE_AND_REGISTER_FN(mqtt_request_response_client_new_from_311)1538    CREATE_AND_REGISTER_FN(mqtt_request_response_client_close)1539    CREATE_AND_REGISTER_FN(mqtt_request_response_client_submit_request)1540    CREATE_AND_REGISTER_FN(mqtt_streaming_operation_new)1541    CREATE_AND_REGISTER_FN(mqtt_streaming_operation_open)1542    CREATE_AND_REGISTER_FN(mqtt_streaming_operation_close)1543 1544    /* MQTT5 Client */1545    CREATE_AND_REGISTER_FN(mqtt5_client_new)1546    CREATE_AND_REGISTER_FN(mqtt5_client_start)1547    CREATE_AND_REGISTER_FN(mqtt5_client_stop)1548    CREATE_AND_REGISTER_FN(mqtt5_client_subscribe)1549    CREATE_AND_REGISTER_FN(mqtt5_client_unsubscribe)1550    CREATE_AND_REGISTER_FN(mqtt5_client_publish)1551    CREATE_AND_REGISTER_FN(mqtt5_client_get_queue_statistics)1552    CREATE_AND_REGISTER_FN(mqtt5_client_invoke_publish_acknowledgement)1553    CREATE_AND_REGISTER_FN(mqtt5_client_close)1554 1555    /* MQTT Client */1556    CREATE_AND_REGISTER_FN(mqtt_client_new)1557 1558    /* MQTT Client Connection */1559    CREATE_AND_REGISTER_FN(mqtt_client_connection_new)1560    CREATE_AND_REGISTER_FN(mqtt_client_connection_connect)1561    CREATE_AND_REGISTER_FN(mqtt_client_connection_reconnect)1562    CREATE_AND_REGISTER_FN(mqtt_client_connection_publish)1563    CREATE_AND_REGISTER_FN(mqtt_client_connection_subscribe)1564    CREATE_AND_REGISTER_FN(mqtt_client_connection_on_message)1565    CREATE_AND_REGISTER_FN(mqtt_client_connection_on_closed)1566    CREATE_AND_REGISTER_FN(mqtt_client_connection_unsubscribe)1567    CREATE_AND_REGISTER_FN(mqtt_client_connection_disconnect)1568    CREATE_AND_REGISTER_FN(mqtt_client_connection_close)1569    CREATE_AND_REGISTER_FN(mqtt_client_connection_get_queue_statistics)1570 1571    /* Crypto */1572    CREATE_AND_REGISTER_FN(hash_md5_new)1573    CREATE_AND_REGISTER_FN(hash_sha1_new)1574    CREATE_AND_REGISTER_FN(hash_sha256_new)1575    CREATE_AND_REGISTER_FN(hash_update)1576    CREATE_AND_REGISTER_FN(hash_digest)1577    CREATE_AND_REGISTER_FN(hash_md5_compute)1578    CREATE_AND_REGISTER_FN(hash_sha1_compute)1579    CREATE_AND_REGISTER_FN(hash_sha256_compute)1580    CREATE_AND_REGISTER_FN(hmac_sha256_new)1581    CREATE_AND_REGISTER_FN(hmac_update)1582    CREATE_AND_REGISTER_FN(hmac_digest)1583    CREATE_AND_REGISTER_FN(hmac_sha256_compute)1584 1585    /* Checksums */1586    CREATE_AND_REGISTER_FN(checksums_crc32)1587    CREATE_AND_REGISTER_FN(checksums_crc32c)1588    CREATE_AND_REGISTER_FN(checksums_crc64nvme)1589 1590    /* HTTP */1591    CREATE_AND_REGISTER_FN(http_proxy_options_new)1592    CREATE_AND_REGISTER_FN(http_connection_new)1593    CREATE_AND_REGISTER_FN(http_connection_close)1594    CREATE_AND_REGISTER_FN(http_stream_new)1595    CREATE_AND_REGISTER_FN(http_stream_activate)1596    CREATE_AND_REGISTER_FN(http_stream_close)1597    CREATE_AND_REGISTER_FN(http_connection_manager_new)1598    CREATE_AND_REGISTER_FN(http_connection_manager_close)1599    CREATE_AND_REGISTER_FN(http_connection_manager_acquire)1600    CREATE_AND_REGISTER_FN(http_connection_manager_release)1601 1602    /* Event stream */1603    CREATE_AND_REGISTER_FN(event_stream_client_connection_new)1604    CREATE_AND_REGISTER_FN(event_stream_client_connection_connect)1605    CREATE_AND_REGISTER_FN(event_stream_client_connection_close)1606    CREATE_AND_REGISTER_FN(event_stream_client_connection_close_internal)1607    CREATE_AND_REGISTER_FN(event_stream_client_connection_send_protocol_message)1608    CREATE_AND_REGISTER_FN(event_stream_client_stream_new)1609    CREATE_AND_REGISTER_FN(event_stream_client_stream_close)1610    CREATE_AND_REGISTER_FN(event_stream_client_stream_activate)1611    CREATE_AND_REGISTER_FN(event_stream_client_stream_send_message)1612 1613#undef CREATE_AND_REGISTER_FN1614 1615    AWS_NAPI_ENSURE(env, aws_napi_http_headers_bind(env, exports));1616    AWS_NAPI_ENSURE(env, aws_napi_http_message_bind(env, exports));1617    AWS_NAPI_ENSURE(env, aws_napi_auth_bind(env, exports));1618 1619    return exports;1620}1621