// 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_binding.h"

#include "node_buffer.h"

#include "node_constants.h"

#include "node_context_data.h"

#include "node_errors.h"

#include "node_internals.h"

#include "node_metadata.h"

#include "node_native_module.h"

#include "node_options-inl.h"

#include "node_perf.h"

#include "node_platform.h"

#include "node_revert.h"

#include "node_version.h"

#include "tracing/traced_value.h"

#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

#include "async_wrap-inl.h"

#include "env-inl.h"

#include "handle_wrap.h"

#include "req_wrap-inl.h"

#include "string_bytes.h"

#include "tracing/agent.h"

#include "tracing/node_trace_writer.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"

#ifdef NODE_ENABLE_VTUNE_PROFILING

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

#endif

#ifdef NODE_ENABLE_LARGE_CODE_PAGES

#include "large_pages/node_large_page.h"

#endif

#include <errno.h>

#include <fcntl.h> // _O_RDWR

#include <limits.h> // PATH_MAX

#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>

#else

#include <pthread.h>

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

#include <unistd.h> // STDIN_FILENO, STDERR_FILENO

#endif

namespace node {

using options_parser::kAllowedInEnvironment;

using options_parser::kDisallowedInEnvironment;

using v8::Array;

using v8::Boolean;

using v8::Context;

using v8::DEFAULT;

using v8::EscapableHandleScope;

using v8::Exception;

using v8::Function;

using v8::FunctionCallbackInfo;

using v8::HandleScope;

using v8::Int32;

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::MicrotasksPolicy;

using v8::NewStringType;

using v8::None;

using v8::Nothing;

using v8::Object;

using v8::ObjectTemplate;

using v8::Script;

using v8::ScriptOrigin;

using v8::SealHandleScope;

using v8::SideEffectType;

using v8::String;

using v8::TracingController;

using v8::Undefined;

using v8::V8;

using v8::Value;

static bool v8_is_profiling = false;

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

unsigned int reverted = 0;

bool v8_initialized = false;

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

double prog_start_time;

Mutex per_process_opts_mutex;

std::shared_ptr<PerProcessOptions> per_process_opts {

new PerProcessOptions() };

static Mutex node_isolate_mutex;

static Isolate* node_isolate;

// Ensures that __metadata trace events are only emitted

// when tracing is enabled.

class NodeTraceStateObserver :

public TracingController::TraceStateObserver {

public:

void OnTraceEnabled() override {

char name_buffer[512];

if (uv_get_process_title(name_buffer, sizeof(name_buffer)) == 0) {

// Only emit the metadata event if the title can be retrieved

// successfully. Ignore it otherwise.

TRACE_EVENT_METADATA1("__metadata", "process_name",

"name", TRACE_STR_COPY(name_buffer));

}

TRACE_EVENT_METADATA1("__metadata", "version",

"node", NODE_VERSION_STRING);

TRACE_EVENT_METADATA1("__metadata", "thread_name",

"name", "JavaScriptMainThread");

auto trace_process = tracing::TracedValue::Create();

trace_process->BeginDictionary("versions");

#define V(key) \

trace_process->SetString(#key, per_process::metadata.versions.key.c_str());

NODE_VERSIONS_KEYS(V)

#undef V

trace_process->EndDictionary();

trace_process->SetString("arch", NODE_ARCH);

trace_process->SetString("platform", NODE_PLATFORM);

trace_process->BeginDictionary("release");

trace_process->SetString("name", NODE_RELEASE);

#if NODE_VERSION_IS_LTS

trace_process->SetString("lts", NODE_VERSION_LTS_CODENAME);

#endif

trace_process->EndDictionary();

TRACE_EVENT_METADATA1("__metadata", "node",

"process", std::move(trace_process));

// This only runs the first time tracing is enabled

controller_->RemoveTraceStateObserver(this);

delete this;

}

void OnTraceDisabled() override {

// Do nothing here. This should never be called because the

// observer removes itself when OnTraceEnabled() is called.

UNREACHABLE();

}

explicit NodeTraceStateObserver(TracingController* controller) :

controller_(controller) {}

~NodeTraceStateObserver() override {}

private:

TracingController* controller_;

};

static struct {

#if NODE_USE_V8_PLATFORM

void Initialize(int thread_pool_size) {

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

node::tracing::TraceEventHelper::SetAgent(tracing_agent_.get());

auto controller = tracing_agent_->GetTracingController();

controller->AddTraceStateObserver(new NodeTraceStateObserver(controller));

StartTracingAgent();

// Tracing must be initialized before platform threads are created.

platform_ = new NodePlatform(thread_pool_size, controller);

V8::InitializePlatform(platform_);

}

void Dispose() {

platform_->Shutdown();

delete platform_;

platform_ = nullptr;

// Destroy tracing after the platform (and platform threads) have been

// stopped.

tracing_agent_.reset(nullptr);

}

void DrainVMTasks(Isolate* isolate) {

platform_->DrainTasks(isolate);

}

void CancelVMTasks(Isolate* isolate) {

platform_->CancelPendingDelayedTasks(isolate);

}

#if HAVE_INSPECTOR

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

// 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(

script_path == nullptr ? "" : script_path,

env->options()->debug_options(),

env->inspector_host_port(),

true);

}

bool InspectorStarted(Environment* env) {

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

}

#endif // HAVE_INSPECTOR

void StartTracingAgent() {

if (per_process_opts->trace_event_categories.empty()) {

tracing_file_writer_ = tracing_agent_->DefaultHandle();

} else {

tracing_file_writer_ = tracing_agent_->AddClient(

ParseCommaSeparatedSet(per_process_opts->trace_event_categories),

std::unique_ptr<tracing::AsyncTraceWriter>(

new tracing::NodeTraceWriter(

per_process_opts->trace_event_file_pattern)),

tracing::Agent::kUseDefaultCategories);

}

}

void StopTracingAgent() {

tracing_file_writer_.reset();

}

tracing::AgentWriterHandle* GetTracingAgentWriter() {

return &tracing_file_writer_;

}

NodePlatform* Platform() {

return platform_;

}

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

tracing::AgentWriterHandle tracing_file_writer_;

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

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

return true;

}

void StartTracingAgent() {

if (!trace_enabled_categories.empty()) {

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

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

}

}

void StopTracingAgent() {}

tracing::AgentWriterHandle* GetTracingAgentWriter() {

return nullptr;

}

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;

tracing::AgentWriterHandle* GetTracingAgentWriter() {

return v8_platform.GetTracingAgentWriter();

}

#ifdef __POSIX__

static const unsigned kMaxSignal = 32;

#endif

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

}

}

void* ArrayBufferAllocator::Allocate(size_t size) {

if (zero_fill_field_ || per_process_opts->zero_fill_all_buffers)

return UncheckedCalloc(size);

else

return UncheckedMalloc(size);

}

namespace {

bool ShouldAbortOnUncaughtException(Isolate* isolate) {

HandleScope scope(isolate);

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

return env != nullptr &&

env->should_abort_on_uncaught_toggle()[0] &&

!env->inside_should_not_abort_on_uncaught_scope();

}

} // anonymous namespace

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

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

CHECK_NOT_NULL(env);

env->AddPromiseHook(fn, arg);

}

void AddEnvironmentCleanupHook(Isolate* isolate,

void (*fun)(void* arg),

void* arg) {

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

CHECK_NOT_NULL(env);

env->AddCleanupHook(fun, arg);

}

void RemoveEnvironmentCleanupHook(Isolate* isolate,

void (*fun)(void* arg),

void* arg) {

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

CHECK_NOT_NULL(env);

env->RemoveCleanupHook(fun, arg);

}

MaybeLocal<Value> InternalMakeCallback(Environment* env,

Local<Object> recv,

const Local<Function> callback,

int argc,

Local<Value> argv[],

async_context asyncContext) {

CHECK(!recv.IsEmpty());

InternalCallbackScope scope(env, recv, asyncContext);

if (scope.Failed()) {

return MaybeLocal<Value>();

}

Local<Function> domain_cb = env->domain_callback();

MaybeLocal<Value> ret;

if (asyncContext.async_id != 0 || domain_cb.IsEmpty() || recv.IsEmpty()) {

ret = callback->Call(env->context(), recv, argc, argv);

} else {

std::vector<Local<Value>> args(1 + argc);

args[0] = callback;

std::copy(&argv[0], &argv[argc], args.begin() + 1);

ret = domain_cb->Call(env->context(), recv, args.size(), &args[0]);

}

if (ret.IsEmpty()) {

scope.MarkAsFailed();

return MaybeLocal<Value>();

}

scope.Close();

if (scope.Failed()) {

return MaybeLocal<Value>();

}

return ret;

}

// Public MakeCallback()s

MaybeLocal<Value> MakeCallback(Isolate* isolate,

Local<Object> recv,

const char* method,

int argc,

Local<Value> argv[],

async_context asyncContext) {

Local<String> method_string =

String::NewFromUtf8(isolate, method, NewStringType::kNormal)

.ToLocalChecked();

return MakeCallback(isolate, recv, method_string, argc, argv, asyncContext);

}

MaybeLocal<Value> MakeCallback(Isolate* isolate,

Local<Object> recv,

Local<String> symbol,

int argc,

Local<Value> argv[],

async_context asyncContext) {

Local<Value> callback_v = recv->Get(isolate->GetCurrentContext(),

symbol).ToLocalChecked();

if (callback_v.IsEmpty()) return Local<Value>();

if (!callback_v->IsFunction()) return Local<Value>();

Local<Function> callback = callback_v.As<Function>();

return MakeCallback(isolate, recv, callback, argc, argv, asyncContext);

}

MaybeLocal<Value> MakeCallback(Isolate* isolate,

Local<Object> recv,

Local<Function> callback,

int argc,

Local<Value> argv[],

async_context asyncContext) {

// Observe the following two subtleties:

//

// 1. The environment is retrieved from the callback function's context.

// 2. The context to enter is retrieved from the environment.

//

// Because of the AssignToContext() call in src/node_contextify.cc,

// the two contexts need not be the same.

Environment* env = Environment::GetCurrent(callback->CreationContext());

CHECK_NOT_NULL(env);

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

MaybeLocal<Value> ret = InternalMakeCallback(env, recv, callback,

argc, argv, asyncContext);

if (ret.IsEmpty() && env->makecallback_depth() == 0) {

// This is only for legacy compatiblity and we may want to look into

// removing/adjusting it.

return Undefined(env->isolate());

}

return ret;

}

// Legacy MakeCallback()s

Local<Value> MakeCallback(Isolate* isolate,

Local<Object> recv,

const char* method,

int argc,

Local<Value>* argv) {

EscapableHandleScope handle_scope(isolate);

return handle_scope.Escape(

MakeCallback(isolate, recv, method, argc, argv, {0, 0})

.FromMaybe(Local<Value>()));

}

Local<Value> MakeCallback(Isolate* isolate,

Local<Object> recv,

Local<String> symbol,

int argc,

Local<Value>* argv) {

EscapableHandleScope handle_scope(isolate);

return handle_scope.Escape(

MakeCallback(isolate, recv, symbol, argc, argv, {0, 0})

.FromMaybe(Local<Value>()));

}

Local<Value> MakeCallback(Isolate* isolate,

Local<Object> recv,

Local<Function> callback,

int argc,

Local<Value>* argv) {

EscapableHandleScope handle_scope(isolate);

return handle_scope.Escape(

MakeCallback(isolate, recv, callback, argc, argv, {0, 0})

.FromMaybe(Local<Value>()));

}

static void WaitForInspectorDisconnect(Environment* env) {

#if HAVE_INSPECTOR

if (env->inspector_agent()->IsActive()) {

// Restore signal dispositions, the app is done and is no longer

// capable of handling signals.

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

struct sigaction act;

memset(&act, 0, sizeof(act));

for (unsigned nr = 1; nr < kMaxSignal; nr += 1) {

if (nr == SIGKILL || nr == SIGSTOP || nr == SIGPROF)

continue;

act.sa_handler = (nr == SIGPIPE) ? SIG_IGN : SIG_DFL;

CHECK_EQ(0, sigaction(nr, &act, nullptr));

}

#endif

env->inspector_agent()->WaitForDisconnect();

}

#endif

}

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

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

WaitForInspectorDisconnect(env);

v8_platform.StopTracingAgent();

int code = args[0]->Int32Value(env->context()).FromMaybe(0);

env->Exit(code);

}

static Maybe<bool> ProcessEmitWarningGeneric(Environment* env,

const char* warning,

const char* type = nullptr,

const char* code = nullptr) {

HandleScope handle_scope(env->isolate());

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

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

Local<Value> emit_warning;

if (!process->Get(env->context(),

env->emit_warning_string()).ToLocal(&emit_warning)) {

return Nothing<bool>();

}

if (!emit_warning->IsFunction()) return Just(false);

int argc = 0;

Local<Value> args[3]; // warning, type, code

// The caller has to be able to handle a failure anyway, so we might as well

// do proper error checking for string creation.

if (!String::NewFromUtf8(env->isolate(),

warning,

NewStringType::kNormal).ToLocal(&args[argc++])) {

return Nothing<bool>();

}

if (type != nullptr) {

if (!String::NewFromOneByte(env->isolate(),

reinterpret_cast<const uint8_t*>(type),

NewStringType::kNormal)

.ToLocal(&args[argc++])) {

return Nothing<bool>();

}

if (code != nullptr &&

!String::NewFromOneByte(env->isolate(),

reinterpret_cast<const uint8_t*>(code),

NewStringType::kNormal)

.ToLocal(&args[argc++])) {

return Nothing<bool>();

}

}

// MakeCallback() unneeded because emitWarning is internal code, it calls

// process.emit('warning', ...), but does so on the nextTick.

if (emit_warning.As<Function>()->Call(env->context(),

process,

argc,

args).IsEmpty()) {

return Nothing<bool>();

}

return Just(true);

}

// Call process.emitWarning(str), fmt is a snprintf() format string

Maybe<bool> ProcessEmitWarning(Environment* env, const char* fmt, ...) {

char warning[1024];

va_list ap;

va_start(ap, fmt);

vsnprintf(warning, sizeof(warning), fmt, ap);

va_end(ap);

return ProcessEmitWarningGeneric(env, warning);

}

Maybe<bool> ProcessEmitDeprecationWarning(Environment* env,

const char* warning,

const char* deprecation_code) {

return ProcessEmitWarningGeneric(env,

warning,

"DeprecationWarning",

deprecation_code);

}

static void OnMessage(Local<Message> message, Local<Value> error) {

Isolate* isolate = message->GetIsolate();

switch (message->ErrorLevel()) {

case Isolate::MessageErrorLevel::kMessageWarning: {

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

if (!env) {

break;

}

Utf8Value filename(isolate,

message->GetScriptOrigin().ResourceName());

// (filename):(line) (message)

std::stringstream warning;

warning << *filename;

warning << ":";

warning << message->GetLineNumber(env->context()).FromMaybe(-1);

warning << " ";

v8::String::Utf8Value msg(isolate, message->Get());

warning << *msg;

USE(ProcessEmitWarningGeneric(env, warning.str().c_str(), "V8"));

break;

}

case Isolate::MessageErrorLevel::kMessageError:

FatalException(isolate, error, message);

break;

}

}

static Local<Object> GetFeatures(Environment* env) {

EscapableHandleScope scope(env->isolate());

Local<Object> obj = Object::New(env->isolate());

#if defined(DEBUG) && DEBUG

Local<Value> debug = True(env->isolate());

#else

Local<Value> debug = False(env->isolate());

#endif // defined(DEBUG) && DEBUG

obj->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "debug"),

debug).FromJust();

obj->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "uv"),

True(env->isolate())).FromJust();

// TODO(bnoordhuis) ping libuv

obj->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "ipv6"),

True(env->isolate())).FromJust();

#ifdef HAVE_OPENSSL

Local<Boolean> have_openssl = True(env->isolate());

#else

Local<Boolean> have_openssl = False(env->isolate());

#endif

obj->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "tls_alpn"),

have_openssl).FromJust();

obj->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "tls_sni"),

have_openssl).FromJust();

obj->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "tls_ocsp"),

have_openssl).FromJust();

obj->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "tls"),

have_openssl).FromJust();

return scope.Escape(obj);

}

static void DebugProcess(const FunctionCallbackInfo<Value>& args);

static void DebugEnd(const FunctionCallbackInfo<Value>& args);

void SetupProcessObject(Environment* env,

const std::vector<std::string>& args,

const std::vector<std::string>& exec_args) {

Isolate* isolate = env->isolate();

HandleScope scope(isolate);

Local<Context> context = env->context();

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

auto title_string = FIXED_ONE_BYTE_STRING(env->isolate(), "title");

CHECK(process->SetAccessor(

env->context(),

title_string,

ProcessTitleGetter,

env->is_main_thread() ? ProcessTitleSetter : nullptr,

env->as_external(),

DEFAULT,

None,

SideEffectType::kHasNoSideEffect).FromJust());

// process.version

READONLY_PROPERTY(process,

"version",

FIXED_ONE_BYTE_STRING(env->isolate(), NODE_VERSION));

// process.versions

Local<Object> versions = Object::New(env->isolate());

READONLY_PROPERTY(process, "versions", versions);

#define V(key) \

if (!per_process::metadata.versions.key.empty()) { \

READONLY_STRING_PROPERTY( \

versions, #key, per_process::metadata.versions.key); \

}

NODE_VERSIONS_KEYS(V)

#undef V

// process.arch

READONLY_PROPERTY(process, "arch", OneByteString(env->isolate(), NODE_ARCH));

// process.platform

READONLY_PROPERTY(process,

"platform",

OneByteString(env->isolate(), NODE_PLATFORM));

// process.release

Local<Object> release = Object::New(env->isolate());

READONLY_PROPERTY(process, "release", release);

READONLY_PROPERTY(release, "name",

OneByteString(env->isolate(), NODE_RELEASE));

#if NODE_VERSION_IS_LTS

READONLY_PROPERTY(release, "lts",

OneByteString(env->isolate(), NODE_VERSION_LTS_CODENAME));

#endif

// if this is a release build and no explicit base has been set

// substitute the standard release download URL

#ifndef NODE_RELEASE_URLBASE

# if NODE_VERSION_IS_RELEASE

# define NODE_RELEASE_URLBASE "https://nodejs.org/download/release/"

# endif

#endif

#if defined(NODE_RELEASE_URLBASE)

# define NODE_RELEASE_URLPFX NODE_RELEASE_URLBASE "v" NODE_VERSION_STRING "/"

# define NODE_RELEASE_URLFPFX NODE_RELEASE_URLPFX "node-v" NODE_VERSION_STRING

READONLY_PROPERTY(release,

"sourceUrl",

OneByteString(env->isolate(),

NODE_RELEASE_URLFPFX ".tar.gz"));

READONLY_PROPERTY(release,

"headersUrl",

OneByteString(env->isolate(),

NODE_RELEASE_URLFPFX "-headers.tar.gz"));

# ifdef _WIN32

READONLY_PROPERTY(release,

"libUrl",

OneByteString(env->isolate(),

strcmp(NODE_ARCH, "ia32") ? NODE_RELEASE_URLPFX "win-"

NODE_ARCH "/node.lib"

: NODE_RELEASE_URLPFX

"win-x86/node.lib"));

# endif

#endif

// process.argv

Local<Array> arguments = Array::New(env->isolate(), args.size());

for (size_t i = 0; i < args.size(); ++i) {

arguments->Set(env->context(), i,

String::NewFromUtf8(env->isolate(), args[i].c_str(),

NewStringType::kNormal).ToLocalChecked())

.FromJust();

}

process->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "argv"),

arguments).FromJust();

// process.execArgv

Local<Array> exec_arguments = Array::New(env->isolate(), exec_args.size());

for (size_t i = 0; i < exec_args.size(); ++i) {

exec_arguments->Set(env->context(), i,

String::NewFromUtf8(env->isolate(), exec_args[i].c_str(),

NewStringType::kNormal).ToLocalChecked())

.FromJust();

}

process->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "execArgv"),

exec_arguments).FromJust();

// create process.env

process

->Set(env->context(),

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

CreateEnvVarProxy(context, isolate, env->as_external()))

.FromJust();

READONLY_PROPERTY(process, "pid",

Integer::New(env->isolate(), uv_os_getpid()));

READONLY_PROPERTY(process, "features", GetFeatures(env));

CHECK(process->SetAccessor(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "ppid"),

GetParentProcessId).FromJust());

// -e, --eval

// TODO(addaleax): Remove this.

if (env->options()->has_eval_string) {

READONLY_PROPERTY(process,

"_eval",

String::NewFromUtf8(

env->isolate(),

env->options()->eval_string.c_str(),

NewStringType::kNormal).ToLocalChecked());

}

// -p, --print

// TODO(addaleax): Remove this.

if (env->options()->print_eval) {

READONLY_PROPERTY(process, "_print_eval", True(env->isolate()));

}

// -c, --check

// TODO(addaleax): Remove this.

if (env->options()->syntax_check_only) {

READONLY_PROPERTY(process, "_syntax_check_only", True(env->isolate()));

}

// -i, --interactive

// TODO(addaleax): Remove this.

if (env->options()->force_repl) {

READONLY_PROPERTY(process, "_forceRepl", True(env->isolate()));

}