#include "node.h"

#include "node_buffer.h"

#include "node_constants.h"

#include "node_file.h"

#include "node_http_parser.h"

#include "node_javascript.h"

#include "node_version.h"

#include "node_internals.h"

#if defined HAVE_PERFCTR

#include "node_counters.h"

#endif

#if HAVE_OPENSSL

#include "node_crypto.h"

#endif

#if defined(NODE_HAVE_I18N_SUPPORT)

#include "node_i18n.h"

#endif

#if defined HAVE_DTRACE || defined HAVE_ETW

#include "node_dtrace.h"

#endif

#if defined HAVE_LTTNG

#include "node_lttng.h"

#endif

#include "ares.h"

#include "async-wrap.h"

#include "async-wrap-inl.h"

#include "env.h"

#include "env-inl.h"

#include "handle_wrap.h"

#include "req-wrap.h"

#include "req-wrap-inl.h"

#include "string_bytes.h"

#include "util.h"

#include "uv.h"

#include "libplatform/libplatform.h"

#include "v8-debug.h"

#include "v8-profiler.h"

#include "zlib.h"

#include <errno.h>

#include <limits.h> // PATH_MAX

#include <locale.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#if defined(_MSC_VER)

#include <direct.h>

#include <io.h>

#include <process.h>

#define strcasecmp _stricmp

#define getpid _getpid

#define umask _umask

typedef int mode_t;

#else

#include <sys/resource.h> // getrlimit, setrlimit

#include <unistd.h> // setuid, getuid

#endif

#if defined(__POSIX__) && !defined(__ANDROID__)

#include <pwd.h> // getpwnam()

#include <grp.h> // getgrnam()

#endif

#ifdef __APPLE__

#include <crt_externs.h>

#define environ (*_NSGetEnviron())

#elif !defined(_MSC_VER)

extern char **environ;

#endif

namespace node {

using v8::Array;

using v8::ArrayBuffer;

using v8::Boolean;

using v8::Context;

using v8::EscapableHandleScope;

using v8::Exception;

using v8::Function;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::Handle;

using v8::HandleScope;

using v8::HeapStatistics;

using v8::Integer;

using v8::Isolate;

using v8::Local;

using v8::Locker;

using v8::Message;

using v8::Number;

using v8::Object;

using v8::ObjectTemplate;

using v8::Promise;

using v8::PromiseRejectMessage;

using v8::PropertyCallbackInfo;

using v8::SealHandleScope;

using v8::StackFrame;

using v8::StackTrace;

using v8::String;

using v8::TryCatch;

using v8::Uint32;

using v8::Uint32Array;

using v8::V8;

using v8::Value;

static bool print_eval = false;

static bool force_repl = false;

static bool trace_deprecation = false;

static bool throw_deprecation = false;

static bool abort_on_uncaught_exception = false;

static bool trace_sync_io = false;

static bool track_heap_objects = false;

static const char* eval_string = nullptr;

static unsigned int preload_module_count = 0;

static const char** preload_modules = nullptr;

static bool use_debug_agent = false;

static bool debug_wait_connect = false;

static int debug_port = 5858;

static bool v8_is_profiling = false;

static bool node_is_initialized = false;

static node_module* modpending;

static node_module* modlist_builtin;

static node_module* modlist_linked;

static node_module* modlist_addon;

#if defined(NODE_HAVE_I18N_SUPPORT)

// Path to ICU data (for i18n / Intl)

static const char* icu_data_dir = nullptr;

#endif

// used by C++ modules as well

bool no_deprecation = false;

// process-relative uptime base, initialized at start-up

static double prog_start_time;

static bool debugger_running;

static uv_async_t dispatch_debug_messages_async;

static Isolate* node_isolate = nullptr;

static v8::Platform* default_platform;

class ArrayBufferAllocator : public ArrayBuffer::Allocator {

public:

// Impose an upper limit to avoid out of memory errors that bring down

// the process.

static const size_t kMaxLength = 0x3fffffff;

static ArrayBufferAllocator the_singleton;

virtual ~ArrayBufferAllocator() = default;

virtual void* Allocate(size_t length) override;

virtual void* AllocateUninitialized(size_t length) override;

virtual void Free(void* data, size_t length) override;

private:

ArrayBufferAllocator() = default;

DISALLOW_COPY_AND_ASSIGN(ArrayBufferAllocator);

};

ArrayBufferAllocator ArrayBufferAllocator::the_singleton;

void* ArrayBufferAllocator::Allocate(size_t length) {

return calloc(length, 1);

}

void* ArrayBufferAllocator::AllocateUninitialized(size_t length) {

return malloc(length);

}

void ArrayBufferAllocator::Free(void* data, size_t length) {

free(data);

}

static void CheckImmediate(uv_check_t* handle) {

Environment* env = Environment::from_immediate_check_handle(handle);

HandleScope scope(env->isolate());

Context::Scope context_scope(env->context());

MakeCallback(env, env->process_object(), env->immediate_callback_string());

}

static void IdleImmediateDummy(uv_idle_t* handle) {

// Do nothing. Only for maintaining event loop.

// TODO(bnoordhuis) Maybe make libuv accept nullptr idle callbacks.

}

static inline const char *errno_string(int errorno) {

#define ERRNO_CASE(e) case e: return #e;

switch (errorno) {

#ifdef EACCES

ERRNO_CASE(EACCES);

#endif

#ifdef EADDRINUSE

ERRNO_CASE(EADDRINUSE);

#endif

#ifdef EADDRNOTAVAIL

ERRNO_CASE(EADDRNOTAVAIL);

#endif

#ifdef EAFNOSUPPORT

ERRNO_CASE(EAFNOSUPPORT);

#endif

#ifdef EAGAIN

ERRNO_CASE(EAGAIN);

#endif

#ifdef EWOULDBLOCK

# if EAGAIN != EWOULDBLOCK

ERRNO_CASE(EWOULDBLOCK);

# endif

#endif

#ifdef EALREADY

ERRNO_CASE(EALREADY);

#endif

#ifdef EBADF

ERRNO_CASE(EBADF);

#endif

#ifdef EBADMSG

ERRNO_CASE(EBADMSG);

#endif

#ifdef EBUSY

ERRNO_CASE(EBUSY);

#endif

#ifdef ECANCELED

ERRNO_CASE(ECANCELED);

#endif

#ifdef ECHILD

ERRNO_CASE(ECHILD);

#endif

#ifdef ECONNABORTED

ERRNO_CASE(ECONNABORTED);

#endif

#ifdef ECONNREFUSED

ERRNO_CASE(ECONNREFUSED);

#endif

#ifdef ECONNRESET

ERRNO_CASE(ECONNRESET);

#endif

#ifdef EDEADLK

ERRNO_CASE(EDEADLK);

#endif

#ifdef EDESTADDRREQ

ERRNO_CASE(EDESTADDRREQ);

#endif

#ifdef EDOM

ERRNO_CASE(EDOM);

#endif

#ifdef EDQUOT

ERRNO_CASE(EDQUOT);

#endif

#ifdef EEXIST

ERRNO_CASE(EEXIST);

#endif

#ifdef EFAULT

ERRNO_CASE(EFAULT);

#endif

#ifdef EFBIG

ERRNO_CASE(EFBIG);

#endif

#ifdef EHOSTUNREACH

ERRNO_CASE(EHOSTUNREACH);

#endif

#ifdef EIDRM

ERRNO_CASE(EIDRM);

#endif

#ifdef EILSEQ

ERRNO_CASE(EILSEQ);

#endif

#ifdef EINPROGRESS

ERRNO_CASE(EINPROGRESS);

#endif

#ifdef EINTR

ERRNO_CASE(EINTR);

#endif

#ifdef EINVAL

ERRNO_CASE(EINVAL);

#endif

#ifdef EIO

ERRNO_CASE(EIO);

#endif

#ifdef EISCONN

ERRNO_CASE(EISCONN);

#endif

#ifdef EISDIR

ERRNO_CASE(EISDIR);

#endif

#ifdef ELOOP

ERRNO_CASE(ELOOP);

#endif

#ifdef EMFILE

ERRNO_CASE(EMFILE);

#endif

#ifdef EMLINK

ERRNO_CASE(EMLINK);

#endif

#ifdef EMSGSIZE

ERRNO_CASE(EMSGSIZE);

#endif

#ifdef EMULTIHOP

ERRNO_CASE(EMULTIHOP);

#endif

#ifdef ENAMETOOLONG

ERRNO_CASE(ENAMETOOLONG);

#endif

#ifdef ENETDOWN

ERRNO_CASE(ENETDOWN);

#endif

#ifdef ENETRESET

ERRNO_CASE(ENETRESET);

#endif

#ifdef ENETUNREACH

ERRNO_CASE(ENETUNREACH);

#endif

#ifdef ENFILE

ERRNO_CASE(ENFILE);

#endif

#ifdef ENOBUFS

ERRNO_CASE(ENOBUFS);

#endif

#ifdef ENODATA

ERRNO_CASE(ENODATA);

#endif

#ifdef ENODEV

ERRNO_CASE(ENODEV);

#endif

#ifdef ENOENT

ERRNO_CASE(ENOENT);

#endif

#ifdef ENOEXEC

ERRNO_CASE(ENOEXEC);

#endif

#ifdef ENOLINK

ERRNO_CASE(ENOLINK);

#endif

#ifdef ENOLCK

# if ENOLINK != ENOLCK

ERRNO_CASE(ENOLCK);

# endif

#endif

#ifdef ENOMEM

ERRNO_CASE(ENOMEM);

#endif

#ifdef ENOMSG

ERRNO_CASE(ENOMSG);

#endif

#ifdef ENOPROTOOPT

ERRNO_CASE(ENOPROTOOPT);

#endif

#ifdef ENOSPC

ERRNO_CASE(ENOSPC);

#endif

#ifdef ENOSR

ERRNO_CASE(ENOSR);

#endif

#ifdef ENOSTR

ERRNO_CASE(ENOSTR);

#endif

#ifdef ENOSYS

ERRNO_CASE(ENOSYS);

#endif

#ifdef ENOTCONN

ERRNO_CASE(ENOTCONN);

#endif

#ifdef ENOTDIR

ERRNO_CASE(ENOTDIR);

#endif

#ifdef ENOTEMPTY

ERRNO_CASE(ENOTEMPTY);

#endif

#ifdef ENOTSOCK

ERRNO_CASE(ENOTSOCK);

#endif

#ifdef ENOTSUP

ERRNO_CASE(ENOTSUP);

#else

# ifdef EOPNOTSUPP

ERRNO_CASE(EOPNOTSUPP);

# endif

#endif

#ifdef ENOTTY

ERRNO_CASE(ENOTTY);

#endif

#ifdef ENXIO

ERRNO_CASE(ENXIO);

#endif

#ifdef EOVERFLOW

ERRNO_CASE(EOVERFLOW);

#endif

#ifdef EPERM

ERRNO_CASE(EPERM);

#endif

#ifdef EPIPE

ERRNO_CASE(EPIPE);

#endif

#ifdef EPROTO

ERRNO_CASE(EPROTO);

#endif

#ifdef EPROTONOSUPPORT

ERRNO_CASE(EPROTONOSUPPORT);

#endif

#ifdef EPROTOTYPE

ERRNO_CASE(EPROTOTYPE);

#endif

#ifdef ERANGE

ERRNO_CASE(ERANGE);

#endif

#ifdef EROFS

ERRNO_CASE(EROFS);

#endif

#ifdef ESPIPE

ERRNO_CASE(ESPIPE);

#endif

#ifdef ESRCH

ERRNO_CASE(ESRCH);

#endif

#ifdef ESTALE

ERRNO_CASE(ESTALE);

#endif

#ifdef ETIME

ERRNO_CASE(ETIME);

#endif

#ifdef ETIMEDOUT

ERRNO_CASE(ETIMEDOUT);

#endif

#ifdef ETXTBSY

ERRNO_CASE(ETXTBSY);

#endif

#ifdef EXDEV

ERRNO_CASE(EXDEV);

#endif

default: return "";

}

}

const char *signo_string(int signo) {

#define SIGNO_CASE(e) case e: return #e;

switch (signo) {

#ifdef SIGHUP

SIGNO_CASE(SIGHUP);

#endif

#ifdef SIGINT

SIGNO_CASE(SIGINT);

#endif

#ifdef SIGQUIT

SIGNO_CASE(SIGQUIT);

#endif

#ifdef SIGILL

SIGNO_CASE(SIGILL);

#endif

#ifdef SIGTRAP

SIGNO_CASE(SIGTRAP);

#endif

#ifdef SIGABRT

SIGNO_CASE(SIGABRT);

#endif

#ifdef SIGIOT

# if SIGABRT != SIGIOT

SIGNO_CASE(SIGIOT);

# endif

#endif

#ifdef SIGBUS

SIGNO_CASE(SIGBUS);

#endif

#ifdef SIGFPE

SIGNO_CASE(SIGFPE);

#endif

#ifdef SIGKILL

SIGNO_CASE(SIGKILL);

#endif

#ifdef SIGUSR1

SIGNO_CASE(SIGUSR1);

#endif

#ifdef SIGSEGV

SIGNO_CASE(SIGSEGV);

#endif

#ifdef SIGUSR2

SIGNO_CASE(SIGUSR2);

#endif

#ifdef SIGPIPE

SIGNO_CASE(SIGPIPE);

#endif

#ifdef SIGALRM

SIGNO_CASE(SIGALRM);

#endif

SIGNO_CASE(SIGTERM);

#ifdef SIGCHLD

SIGNO_CASE(SIGCHLD);

#endif

#ifdef SIGSTKFLT

SIGNO_CASE(SIGSTKFLT);

#endif

#ifdef SIGCONT

SIGNO_CASE(SIGCONT);

#endif

#ifdef SIGSTOP

SIGNO_CASE(SIGSTOP);

#endif

#ifdef SIGTSTP

SIGNO_CASE(SIGTSTP);

#endif

#ifdef SIGBREAK

SIGNO_CASE(SIGBREAK);

#endif

#ifdef SIGTTIN

SIGNO_CASE(SIGTTIN);

#endif

#ifdef SIGTTOU

SIGNO_CASE(SIGTTOU);

#endif

#ifdef SIGURG

SIGNO_CASE(SIGURG);

#endif

#ifdef SIGXCPU

SIGNO_CASE(SIGXCPU);

#endif

#ifdef SIGXFSZ

SIGNO_CASE(SIGXFSZ);

#endif

#ifdef SIGVTALRM

SIGNO_CASE(SIGVTALRM);

#endif

#ifdef SIGPROF

SIGNO_CASE(SIGPROF);

#endif

#ifdef SIGWINCH

SIGNO_CASE(SIGWINCH);

#endif

#ifdef SIGIO

SIGNO_CASE(SIGIO);

#endif

#ifdef SIGPOLL

# if SIGPOLL != SIGIO

SIGNO_CASE(SIGPOLL);

# endif

#endif

#ifdef SIGLOST

SIGNO_CASE(SIGLOST);

#endif

#ifdef SIGPWR

# if SIGPWR != SIGLOST

SIGNO_CASE(SIGPWR);

# endif

#endif

#ifdef SIGSYS

SIGNO_CASE(SIGSYS);

#endif

default: return "";

}

}

// Convenience methods

void ThrowError(v8::Isolate* isolate, const char* errmsg) {

Environment::GetCurrent(isolate)->ThrowError(errmsg);

}

void ThrowTypeError(v8::Isolate* isolate, const char* errmsg) {

Environment::GetCurrent(isolate)->ThrowTypeError(errmsg);

}

void ThrowRangeError(v8::Isolate* isolate, const char* errmsg) {

Environment::GetCurrent(isolate)->ThrowRangeError(errmsg);

}

void ThrowErrnoException(v8::Isolate* isolate,

int errorno,

const char* syscall,

const char* message,

const char* path) {

Environment::GetCurrent(isolate)->ThrowErrnoException(errorno,

syscall,

message,

path);

}

void ThrowUVException(v8::Isolate* isolate,

int errorno,

const char* syscall,

const char* message,

const char* path,

const char* dest) {

Environment::GetCurrent(isolate)

->ThrowUVException(errorno, syscall, message, path, dest);

}

Local<Value> ErrnoException(Isolate* isolate,

int errorno,

const char *syscall,

const char *msg,

const char *path) {

Environment* env = Environment::GetCurrent(isolate);

Local<Value> e;

Local<String> estring = OneByteString(env->isolate(), errno_string(errorno));

if (msg == nullptr || msg[0] == '\0') {

msg = strerror(errorno);

}

Local<String> message = OneByteString(env->isolate(), msg);

Local<String> cons =

String::Concat(estring, FIXED_ONE_BYTE_STRING(env->isolate(), ", "));

cons = String::Concat(cons, message);

Local<String> path_string;

if (path != nullptr) {

// FIXME(bnoordhuis) It's questionable to interpret the file path as UTF-8.

path_string = String::NewFromUtf8(env->isolate(), path);

}

if (path_string.IsEmpty() == false) {

cons = String::Concat(cons, FIXED_ONE_BYTE_STRING(env->isolate(), " '"));

cons = String::Concat(cons, path_string);

cons = String::Concat(cons, FIXED_ONE_BYTE_STRING(env->isolate(), "'"));

}

e = Exception::Error(cons);

Local<Object> obj = e->ToObject(env->isolate());

obj->Set(env->errno_string(), Integer::New(env->isolate(), errorno));

obj->Set(env->code_string(), estring);

if (path_string.IsEmpty() == false) {

obj->Set(env->path_string(), path_string);

}

if (syscall != nullptr) {

obj->Set(env->syscall_string(), OneByteString(env->isolate(), syscall));

}

return e;

}

static Local<String> StringFromPath(Isolate* isolate, const char* path) {

#ifdef _WIN32

if (strncmp(path, "\\\\?\\UNC\\", 8) == 0) {

return String::Concat(FIXED_ONE_BYTE_STRING(isolate, "\\\\"),

String::NewFromUtf8(isolate, path + 8));

} else if (strncmp(path, "\\\\?\\", 4) == 0) {

return String::NewFromUtf8(isolate, path + 4);

}

#endif

return String::NewFromUtf8(isolate, path);

}

Local<Value> UVException(Isolate* isolate,

int errorno,

const char* syscall,

const char* msg,

const char* path) {

return UVException(isolate, errorno, syscall, msg, path, nullptr);

}

Local<Value> UVException(Isolate* isolate,

int errorno,

const char* syscall,

const char* msg,

const char* path,

const char* dest) {

Environment* env = Environment::GetCurrent(isolate);

if (!msg || !msg[0])

msg = uv_strerror(errorno);

Local<String> js_code = OneByteString(isolate, uv_err_name(errorno));

Local<String> js_syscall = OneByteString(isolate, syscall);

Local<String> js_path;

Local<String> js_dest;

Local<String> js_msg = js_code;

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, ": "));

js_msg = String::Concat(js_msg, OneByteString(isolate, msg));

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, ", "));

js_msg = String::Concat(js_msg, js_syscall);

if (path != nullptr) {

js_path = StringFromPath(isolate, path);

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, " '"));

js_msg = String::Concat(js_msg, js_path);

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, "'"));

}

if (dest != nullptr) {

js_dest = StringFromPath(isolate, dest);

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, " -> '"));

js_msg = String::Concat(js_msg, js_dest);

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, "'"));

}

Local<Object> e = Exception::Error(js_msg)->ToObject(isolate);

// TODO(piscisaureus) errno should probably go; the user has no way of

// knowing which uv errno value maps to which error.

e->Set(env->errno_string(), Integer::New(isolate, errorno));

e->Set(env->code_string(), js_code);

e->Set(env->syscall_string(), js_syscall);

if (!js_path.IsEmpty())

e->Set(env->path_string(), js_path);

if (!js_dest.IsEmpty())

e->Set(env->dest_string(), js_dest);

return e;

}

// Look up environment variable unless running as setuid root.

inline const char* secure_getenv(const char* key) {

#ifndef _WIN32

if (getuid() != geteuid() || getgid() != getegid())

return nullptr;

#endif

return getenv(key);

}

#ifdef _WIN32

// Does about the same as strerror(),

// but supports all windows error messages

static const char *winapi_strerror(const int errorno, bool* must_free) {

char *errmsg = nullptr;

FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, errorno,

MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&errmsg, 0, nullptr);

if (errmsg) {

*must_free = true;

// Remove trailing newlines

for (int i = strlen(errmsg) - 1;

i >= 0 && (errmsg[i] == '\n' || errmsg[i] == '\r'); i--) {

errmsg[i] = '\0';

}

return errmsg;

} else {

// FormatMessage failed

*must_free = false;

return "Unknown error";

}

}

Local<Value> WinapiErrnoException(Isolate* isolate,

int errorno,

const char* syscall,

const char* msg,

const char* path) {

Environment* env = Environment::GetCurrent(isolate);

Local<Value> e;

bool must_free = false;

if (!msg || !msg[0]) {

msg = winapi_strerror(errorno, &must_free);

}

Local<String> message = OneByteString(env->isolate(), msg);

if (path) {

Local<String> cons1 =

String::Concat(message, FIXED_ONE_BYTE_STRING(isolate, " '"));

Local<String> cons2 =

String::Concat(cons1, String::NewFromUtf8(isolate, path));

Local<String> cons3 =

String::Concat(cons2, FIXED_ONE_BYTE_STRING(isolate, "'"));

e = Exception::Error(cons3);

} else {

e = Exception::Error(message);

}

Local<Object> obj = e->ToObject(env->isolate());

obj->Set(env->errno_string(), Integer::New(isolate, errorno));

if (path != nullptr) {

obj->Set(env->path_string(), String::NewFromUtf8(isolate, path));

}

if (syscall != nullptr) {

obj->Set(env->syscall_string(), OneByteString(isolate, syscall));

}

if (must_free)

LocalFree((HLOCAL)msg);

return e;

}

#endif

void SetupDomainUse(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

if (env->using_domains())

return;

env->set_using_domains(true);

HandleScope scope(env->isolate());

Local<Object> process_object = env->process_object();

Local<String> tick_callback_function_key = env->tick_domain_cb_string();

Local<Function> tick_callback_function =

process_object->Get(tick_callback_function_key).As<Function>();

if (!tick_callback_function->IsFunction()) {

fprintf(stderr, "process._tickDomainCallback assigned to non-function\n");

abort();

}

process_object->Set(env->tick_callback_string(), tick_callback_function);

env->set_tick_callback_function(tick_callback_function);

CHECK(args[0]->IsArray());

env->set_domain_array(args[0].As<Array>());

// Do a little housekeeping.

env->process_object()->Delete(

FIXED_ONE_BYTE_STRING(args.GetIsolate(), "_setupDomainUse"));

uint32_t* const fields = env->domain_flag()->fields();

uint32_t const fields_count = env->domain_flag()->fields_count();

Local<ArrayBuffer> array_buffer =

ArrayBuffer::New(env->isolate(), fields, sizeof(*fields) * fields_count);

args.GetReturnValue().Set(Uint32Array::New(array_buffer, 0, fields_count));

}

void RunMicrotasks(const FunctionCallbackInfo<Value>& args) {

args.GetIsolate()->RunMicrotasks();

}

void SetupNextTick(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

CHECK(args[0]->IsFunction());

CHECK(args[1]->IsObject());

env->set_tick_callback_function(args[0].As<Function>());

env->SetMethod(args[1].As<Object>(), "runMicrotasks", RunMicrotasks);

// Do a little housekeeping.

env->process_object()->Delete(

FIXED_ONE_BYTE_STRING(args.GetIsolate(), "_setupNextTick"));

// Values use to cross communicate with processNextTick.

uint32_t* const fields = env->tick_info()->fields();

uint32_t const fields_count = env->tick_info()->fields_count();

Local<ArrayBuffer> array_buffer =

ArrayBuffer::New(env->isolate(), fields, sizeof(*fields) * fields_count);

args.GetReturnValue().Set(Uint32Array::New(array_buffer, 0, fields_count));

}

void PromiseRejectCallback(PromiseRejectMessage message) {

Local<Promise> promise = message.GetPromise();

Isolate* isolate = promise->GetIsolate();

Local<Value> value = message.GetValue();

Local<Integer> event = Integer::New(isolate, message.GetEvent());

Environment* env = Environment::GetCurrent(isolate);

Local<Function> callback = env->promise_reject_function();

if (value.IsEmpty())

value = Undefined(isolate);