// Copyright Joyent, Inc. and other Node 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.

#include "node_buffer.h"

#include "node_constants.h"

#include "node_javascript.h"

#include "node_platform.h"

#include "node_version.h"

#include "node_internals.h"

#include "node_revert.h"

#include "node_debug_options.h"

#include "node_perf.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 HAVE_INSPECTOR

#include "inspector_io.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-inl.h"

#include "env-inl.h"

#include "handle_wrap.h"

#include "http_parser.h"

#include "nghttp2/nghttp2ver.h"

#include "req_wrap-inl.h"

#include "string_bytes.h"

#include "tracing/agent.h"

#include "util.h"

#include "uv.h"

#if NODE_USE_V8_PLATFORM

#include "libplatform/libplatform.h"

#endif // NODE_USE_V8_PLATFORM

#include "v8-profiler.h"

#include "zlib.h"

#ifdef NODE_ENABLE_VTUNE_PROFILING

#include "../deps/v8/src/third_party/vtune/v8-vtune.h"

#endif

#include <errno.h>

#include <fcntl.h> // _O_RDWR

#include <limits.h> // PATH_MAX

#include <locale.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <string>

#include <vector>

#if defined(NODE_HAVE_I18N_SUPPORT)

#include <unicode/uvernum.h>

#endif

#if defined(LEAK_SANITIZER)

#include <sanitizer/lsan_interface.h>

#endif

#if defined(_MSC_VER)

#include <direct.h>

#include <io.h>

#define umask _umask

typedef int mode_t;

#else

#include <pthread.h>

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

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

#endif

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

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

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

#endif

#if defined(__POSIX__)

#include <dlfcn.h>

#endif

#ifdef __APPLE__

#include <crt_externs.h>

#define environ (*_NSGetEnviron())

#elif !defined(_MSC_VER)

extern char **environ;

#endif

// This is used to load built-in modules. Instead of using

// __attribute__((constructor)), we call the _register_<modname>

// function for each built-in modules explicitly in

// node::RegisterBuiltinModules(). This is only forward declaration.

// The definitions are in each module's implementation when calling

// the NODE_BUILTIN_MODULE_CONTEXT_AWARE.

#define V(modname) void _register_##modname();

NODE_BUILTIN_MODULES(V)

#undef V

namespace node {

using v8::Array;

using v8::ArrayBuffer;

using v8::Boolean;

using v8::Context;

using v8::EscapableHandleScope;

using v8::Exception;

using v8::Float64Array;

using v8::Function;

using v8::FunctionCallbackInfo;

using v8::HandleScope;

using v8::HeapStatistics;

using v8::Integer;

using v8::Isolate;

using v8::Just;

using v8::Local;

using v8::Locker;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Message;

using v8::Name;

using v8::NamedPropertyHandlerConfiguration;

using v8::Nothing;

using v8::Null;

using v8::Number;

using v8::Object;

using v8::ObjectTemplate;

using v8::Promise;

using v8::PromiseRejectMessage;

using v8::PropertyCallbackInfo;

using v8::ScriptOrigin;

using v8::SealHandleScope;

using v8::String;

using v8::TryCatch;

using v8::Uint32Array;

using v8::Undefined;

using v8::V8;

using v8::Value;

using AsyncHooks = node::Environment::AsyncHooks;

static bool print_eval = false;

static bool force_repl = false;

static bool syntax_check_only = false;

static bool trace_deprecation = false;

static bool throw_deprecation = false;

static bool trace_sync_io = false;

static bool no_force_async_hooks_checks = false;

static bool track_heap_objects = false;

static const char* eval_string = nullptr;

static std::vector<std::string> preload_modules;

static const int v8_default_thread_pool_size = 4;

static int v8_thread_pool_size = v8_default_thread_pool_size;

static bool prof_process = false;

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_internal;

static node_module* modlist_linked;

static node_module* modlist_addon;

static bool trace_enabled = false;

static std::string trace_enabled_categories; // NOLINT(runtime/string)

static bool abort_on_uncaught_exception = false;

// Bit flag used to track security reverts (see node_revert.h)

unsigned int reverted = 0;

#if defined(NODE_HAVE_I18N_SUPPORT)

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

std::string icu_data_dir; // NOLINT(runtime/string)

#endif

// used by C++ modules as well

bool no_deprecation = false;

#if HAVE_OPENSSL

// use OpenSSL's cert store instead of bundled certs

bool ssl_openssl_cert_store =

#if defined(NODE_OPENSSL_CERT_STORE)

true;

#else

false;

#endif

# if NODE_FIPS_MODE

// used by crypto module

bool enable_fips_crypto = false;

bool force_fips_crypto = false;

# endif // NODE_FIPS_MODE

std::string openssl_config; // NOLINT(runtime/string)

#endif // HAVE_OPENSSL

// true if process warnings should be suppressed

bool no_process_warnings = false;

bool trace_warnings = false;

// Set in node.cc by ParseArgs when --preserve-symlinks is used.

// Used in node_config.cc to set a constant on process.binding('config')

// that is used by lib/module.js

bool config_preserve_symlinks = false;

// Set in node.cc by ParseArgs when --experimental-modules is used.

// Used in node_config.cc to set a constant on process.binding('config')

// that is used by lib/module.js

bool config_experimental_modules = false;

// Set in node.cc by ParseArgs when --loader is used.

// Used in node_config.cc to set a constant on process.binding('config')

// that is used by lib/internal/bootstrap_node.js

std::string config_userland_loader; // NOLINT(runtime/string)

// Set by ParseArgs when --pending-deprecation or NODE_PENDING_DEPRECATION

// is used.

bool config_pending_deprecation = false;

// Set in node.cc by ParseArgs when --redirect-warnings= is used.

std::string config_warning_file; // NOLINT(runtime/string)

// Set in node.cc by ParseArgs when --expose-internals or --expose_internals is

// used.

// Used in node_config.cc to set a constant on process.binding('config')

// that is used by lib/internal/bootstrap_node.js

bool config_expose_internals = false;

bool v8_initialized = false;

bool linux_at_secure = false;

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

static double prog_start_time;

static Mutex node_isolate_mutex;

static v8::Isolate* node_isolate;

node::DebugOptions debug_options;

static struct {

#if NODE_USE_V8_PLATFORM

void Initialize(int thread_pool_size) {

if (trace_enabled) {

tracing_agent_.reset(new tracing::Agent());

platform_ = new NodePlatform(thread_pool_size,

tracing_agent_->GetTracingController());

V8::InitializePlatform(platform_);

tracing::TraceEventHelper::SetTracingController(

tracing_agent_->GetTracingController());

} else {

tracing_agent_.reset(nullptr);

platform_ = new NodePlatform(thread_pool_size, nullptr);

V8::InitializePlatform(platform_);

tracing::TraceEventHelper::SetTracingController(

new v8::TracingController());

}

}

void Dispose() {

platform_->Shutdown();

delete platform_;

platform_ = nullptr;

tracing_agent_.reset(nullptr);

}

void DrainVMTasks(Isolate* isolate) {

platform_->DrainBackgroundTasks(isolate);

}

void CancelVMTasks(Isolate* isolate) {

platform_->CancelPendingDelayedTasks(isolate);

}

#if HAVE_INSPECTOR

bool StartInspector(Environment *env, const char* script_path,

const node::DebugOptions& options) {

// Inspector agent can't fail to start, but if it was configured to listen

// right away on the websocket port and fails to bind/etc, this will return

// false.

return env->inspector_agent()->Start(platform_, script_path, options);

}

bool InspectorStarted(Environment *env) {

return env->inspector_agent()->IsStarted();

}

#endif // HAVE_INSPECTOR

void StartTracingAgent() {

tracing_agent_->Start(trace_enabled_categories);

}

void StopTracingAgent() {

tracing_agent_->Stop();

}

NodePlatform* Platform() {

return platform_;

}

std::unique_ptr<tracing::Agent> tracing_agent_;

NodePlatform* platform_;

#else // !NODE_USE_V8_PLATFORM

void Initialize(int thread_pool_size) {}

void Dispose() {}

void DrainVMTasks(Isolate* isolate) {}

void CancelVMTasks(Isolate* isolate) {}

bool StartInspector(Environment *env, const char* script_path,

const node::DebugOptions& options) {

env->ThrowError("Node compiled with NODE_USE_V8_PLATFORM=0");

return true;

}

void StartTracingAgent() {

fprintf(stderr, "Node compiled with NODE_USE_V8_PLATFORM=0, "

"so event tracing is not available.\n");

}

void StopTracingAgent() {}

NodePlatform* Platform() {

return nullptr;

}

#endif // !NODE_USE_V8_PLATFORM

#if !NODE_USE_V8_PLATFORM || !HAVE_INSPECTOR

bool InspectorStarted(Environment *env) {

return false;

}

#endif // !NODE_USE_V8_PLATFORM || !HAVE_INSPECTOR

} v8_platform;

#ifdef __POSIX__

static const unsigned kMaxSignal = 32;

#endif

static void PrintErrorString(const char* format, ...) {

va_list ap;

va_start(ap, format);

#ifdef _WIN32

HANDLE stderr_handle = GetStdHandle(STD_ERROR_HANDLE);

// Check if stderr is something other than a tty/console

if (stderr_handle == INVALID_HANDLE_VALUE ||

stderr_handle == nullptr ||

uv_guess_handle(_fileno(stderr)) != UV_TTY) {

vfprintf(stderr, format, ap);

va_end(ap);

return;

}

// Fill in any placeholders

int n = _vscprintf(format, ap);

std::vector<char> out(n + 1);

vsprintf(out.data(), format, ap);

// Get required wide buffer size

n = MultiByteToWideChar(CP_UTF8, 0, out.data(), -1, nullptr, 0);

std::vector<wchar_t> wbuf(n);

MultiByteToWideChar(CP_UTF8, 0, out.data(), -1, wbuf.data(), n);

// Don't include the null character in the output

CHECK_GT(n, 0);

WriteConsoleW(stderr_handle, wbuf.data(), n - 1, nullptr, nullptr);

#else

vfprintf(stderr, format, ap);

#endif

va_end(ap);

}

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

# if SIGLOST != SIGABRT

SIGNO_CASE(SIGLOST);

# endif

#endif

#ifdef SIGPWR

# if SIGPWR != SIGLOST

SIGNO_CASE(SIGPWR);

# endif

#endif

#ifdef SIGINFO

# if !defined(SIGPWR) || SIGINFO != SIGPWR

SIGNO_CASE(SIGINFO);

# endif

#endif

#ifdef SIGSYS

SIGNO_CASE(SIGSYS);

#endif

default: return "";

}

}

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.As<Object>();

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);

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.

bool SafeGetenv(const char* key, std::string* text) {

#if !defined(__CloudABI__) && !defined(_WIN32)

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

goto fail;

#endif

if (const char* value = getenv(key)) {

*text = value;

return true;

}

fail:

text->clear();

return false;

}

#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.As<Object>();

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* ArrayBufferAllocator::Allocate(size_t size) {

if (zero_fill_field_ || zero_fill_all_buffers)

return node::UncheckedCalloc(size);

else

return node::UncheckedMalloc(size);

}

namespace {

bool ShouldAbortOnUncaughtException(Isolate* isolate) {

HandleScope scope(isolate);

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

return env->should_abort_on_uncaught_toggle()[0] &&

!env->inside_should_not_abort_on_uncaught_scope();

}

Local<Value> GetDomainProperty(Environment* env, Local<Object> object) {

Local<Value> domain_v =

object->GetPrivate(env->context(), env->domain_private_symbol())

.ToLocalChecked();

if (domain_v->IsObject()) {

return domain_v;

}

return object->Get(env->context(), env->domain_string()).ToLocalChecked();

}

void DomainEnter(Environment* env, Local<Object> object) {

Local<Value> domain_v = GetDomainProperty(env, object);

if (domain_v->IsObject()) {

Local<Object> domain = domain_v.As<Object>();

Local<Value> enter_v = domain->Get(env->enter_string());

if (enter_v->IsFunction()) {

if (enter_v.As<Function>()->Call(domain, 0, nullptr).IsEmpty()) {

FatalError("node::AsyncWrap::MakeCallback",

"domain enter callback threw, please report this");

}

}

}

}

void DomainExit(Environment* env, v8::Local<v8::Object> object) {

Local<Value> domain_v = GetDomainProperty(env, object);

if (domain_v->IsObject()) {

Local<Object> domain = domain_v.As<Object>();

Local<Value> exit_v = domain->Get(env->exit_string());

if (exit_v->IsFunction()) {

if (exit_v.As<Function>()->Call(domain, 0, nullptr).IsEmpty()) {

FatalError("node::AsyncWrap::MakeCallback",

"domain exit callback threw, please report this");

}

}

}

}

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());

// Do a little housekeeping.

env->process_object()->Delete(

env->context(),

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

}

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

args.GetIsolate()->RunMicrotasks();

}

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

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

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

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

env->process_object()->Delete(

env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "_setupProcessObject")).FromJust();

}

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

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

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

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

env->process_object()->Delete(

env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "_setupNextTick")).FromJust();

v8::Local<v8::Function> run_microtasks_fn =

env->NewFunctionTemplate(RunMicrotasks)->GetFunction(env->context())

.ToLocalChecked();

run_microtasks_fn->SetName(

FIXED_ONE_BYTE_STRING(env->isolate(), "runMicrotasks"));

Local<Array> ret = Array::New(env->isolate(), 2);

ret->Set(env->context(), 0,

env->tick_info()->fields().GetJSArray()).FromJust();

ret->Set(env->context(), 1, run_microtasks_fn).FromJust();

args.GetReturnValue().Set(ret);

}

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);

Local<Value> args[] = { event, promise, value };

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

callback->Call(process, arraysize(args), args);

}

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

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

Isolate* isolate = env->isolate();

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

isolate->SetPromiseRejectCallback(PromiseRejectCallback);

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

env->process_object()->Delete(

env->context(),

FIXED_ONE_BYTE_STRING(isolate, "_setupPromises")).FromJust();

}

} // anonymous namespace

void AddPromiseHook(v8::Isolate* isolate, promise_hook_func fn, void* arg) {

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

env->AddPromiseHook(fn, arg);

}

CallbackScope::CallbackScope(Isolate* isolate,

Local<Object> object,

async_context asyncContext)

: private_(new InternalCallbackScope(Environment::GetCurrent(isolate),

object,

asyncContext)),

try_catch_(isolate) {

try_catch_.SetVerbose(true);

}

CallbackScope::~CallbackScope() {

if (try_catch_.HasCaught())

private_->MarkAsFailed();

delete private_;

}

InternalCallbackScope::InternalCallbackScope(AsyncWrap* async_wrap)

: InternalCallbackScope(async_wrap->env(),

async_wrap->object(),

{ async_wrap->get_async_id(),

async_wrap->get_trigger_async_id() }) {}

InternalCallbackScope::InternalCallbackScope(Environment* env,

Local<Object> object,

const async_context& asyncContext,

ResourceExpectation expect)

: env_(env),

async_context_(asyncContext),

object_(object),

callback_scope_(env) {

if (expect == kRequireResource) {

CHECK(!object.IsEmpty());

}

HandleScope handle_scope(env->isolate());

// If you hit this assertion, you forgot to enter the v8::Context first.

CHECK_EQ(Environment::GetCurrent(env->isolate()), env);

if (asyncContext.async_id == 0 && env->using_domains() &&

!object_.IsEmpty()) {

DomainEnter(env, object_);

}

if (asyncContext.async_id != 0) {

// No need to check a return value because the application will exit if

// an exception occurs.

AsyncWrap::EmitBefore(env, asyncContext.async_id);

}

env->async_hooks()->push_async_ids(async_context_.async_id,

async_context_.trigger_async_id);

pushed_ids_ = true;

}

InternalCallbackScope::~InternalCallbackScope() {

Close();

}

void InternalCallbackScope::Close() {

if (closed_) return;

closed_ = true;

HandleScope handle_scope(env_->isolate());

if (pushed_ids_)

env_->async_hooks()->pop_async_id(async_context_.async_id);

if (failed_) return;

if (async_context_.async_id != 0) {

AsyncWrap::EmitAfter(env_, async_context_.async_id);