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

// ========== local headers ==========

#include "debug_utils-inl.h"

#include "env-inl.h"

#include "histogram-inl.h"

#include "memory_tracker-inl.h"

#include "node_binding.h"

#include "node_errors.h"

#include "node_internals.h"

#include "node_main_instance.h"

#include "node_metadata.h"

#include "node_native_module.h"

#include "node_options-inl.h"

#include "node_perf.h"

#include "node_process-inl.h"

#include "node_report.h"

#include "node_revert.h"

#include "node_snapshot_builder.h"

#include "node_v8_platform-inl.h"

#include "node_version.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_agent.h"

#include "inspector_io.h"

#endif

#if NODE_USE_V8_PLATFORM

#include "libplatform/libplatform.h"

#endif  // NODE_USE_V8_PLATFORM

#include "v8-profiler.h"

#if HAVE_INSPECTOR

#include "inspector/worker_inspector.h"  // ParentInspectorHandle

#endif

#include "large_pages/node_large_page.h"

#if defined(__APPLE__) || defined(__linux__) || defined(_WIN32)

#define NODE_USE_V8_WASM_TRAP_HANDLER 1

#else

#define NODE_USE_V8_WASM_TRAP_HANDLER 0

#endif

#if NODE_USE_V8_WASM_TRAP_HANDLER

#if defined(_WIN32)

#include "v8-wasm-trap-handler-win.h"

#else

#include <atomic>

#include "v8-wasm-trap-handler-posix.h"

#endif

#endif  // NODE_USE_V8_WASM_TRAP_HANDLER

// ========== global C headers ==========

#include <fcntl.h>  // _O_RDWR

#include <sys/types.h>

#if defined(NODE_HAVE_I18N_SUPPORT)

#include <unicode/uvernum.h>

#include <unicode/utypes.h>

#endif

#if defined(LEAK_SANITIZER)

#include <sanitizer/lsan_interface.h>

#endif

#if defined(_MSC_VER)

#include <direct.h>

#include <io.h>

#define STDIN_FILENO 0

#else

#include <pthread.h>

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

#include <termios.h>       // tcgetattr, tcsetattr

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

#endif

// ========== global C++ headers ==========

#include <cerrno>

#include <climits>  // PATH_MAX

#include <csignal>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <string>

#include <vector>

namespace node {

using native_module::NativeModuleLoader;

using v8::EscapableHandleScope;

using v8::Function;

using v8::Isolate;

using v8::Local;

using v8::MaybeLocal;

using v8::Object;

using v8::String;

using v8::Undefined;

using v8::V8;

using v8::Value;

namespace per_process {

// node_revert.h

// Bit flag used to track security reverts.

unsigned int reverted_cve = 0;

// util.h

// Tells whether the per-process V8::Initialize() is called and

// if it is safe to call v8::Isolate::TryGetCurrent().

bool v8_initialized = false;

// node_internals.h

// process-relative uptime base in nanoseconds, initialized in node::Start()

uint64_t node_start_time;

#if NODE_USE_V8_WASM_TRAP_HANDLER && defined(_WIN32)

PVOID old_vectored_exception_handler;

#endif

// node_v8_platform-inl.h

struct V8Platform v8_platform;

}  // namespace per_process

// The section in the OpenSSL configuration file to be loaded.

const char* conf_section_name = STRINGIFY(NODE_OPENSSL_CONF_NAME);

#ifdef __POSIX__

}

#endif  // __POSIX__

                                      const char* id,

                                      std::vector<Local<Value>>* arguments) {

  MaybeLocal<Function> maybe_fn =

  Local<Function> fn;

  }

  MaybeLocal<Value> result = fn->Call(env->context(),

                                      Undefined(env->isolate()),

  // If there was an error during bootstrap, it must be unrecoverable

  // (e.g. max call stack exceeded). Clear the stack so that the

  // AsyncCallbackScope destructor doesn't fail on the id check.

  // There are only two ways to have a stack size > 1: 1) the user manually

  // called MakeCallback or 2) user awaited during bootstrap, which triggered

  // _tickCallback().

  }

}

#if HAVE_INSPECTOR

    std::unique_ptr<inspector::ParentInspectorHandle> parent_handle) {

  } else {

  }

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

                          is_main);

  }

  }

}

#endif  // HAVE_INSPECTOR

#define ATOMIC_WAIT_EVENTS(V)                                               \

  V(kStartWait,           "started")                                        \

  V(kWokenUp,             "was woken up by another thread")                 \

  V(kTimedOut,            "timed out")                                      \

  V(kTerminatedExecution, "was stopped by terminated execution")            \

  V(kAPIStopped,          "was stopped through the embedder API")           \

  V(kNotEqual,            "did not wait because the values mismatched")     \

                                Local<v8::SharedArrayBuffer> array_buffer,

                                size_t offset_in_bytes, int64_t value,

                                double timeout_in_ms,

                                Isolate::AtomicsWaitWakeHandle* stop_handle,

                                void* data) {

#define V(key, msg)                         \

    case Isolate::AtomicsWaitEvent::key:    \

      message = msg;                        \

      break;

#undef V

  }

          "(node:%d) [Thread %" PRIu64 "] Atomics.wait(%p + %zx, %" PRId64

          ", %.f) %s\n",

          env->thread_id(),

          array_buffer->Data(),

          offset_in_bytes,

          value,

          timeout_in_ms,

          message);

      Environment::BuildEmbedderGraph, this);

                                       this);

  }

  }

  // Arguments must match the parameters specified in

  // NativeModuleLoader::LookupAndCompile().

  std::vector<Local<Value>> loaders_args = {

      process_object(),

          .ToLocalChecked(),

          .ToLocalChecked(),

  // Bootstrap internal loaders

  Local<Value> loader_exports;

  }

  Local<Value> internal_binding_loader =

  Local<Value> require =

}

  // Arguments must match the parameters specified in

  // NativeModuleLoader::LookupAndCompile().

  // process, require, internalBinding, primordials

  std::vector<Local<Value>> node_args = {

      process_object(),

      native_module_require(),

      internal_binding_loader(),

  MaybeLocal<Value> result =

  }

    result =

    }

  }

  // TODO(joyeecheung): skip these in the snapshot building for workers.

  auto thread_switch_id =

  }

  auto process_state_switch_id =

  }

  Local<Object> env_var_proxy;

  }

}

  }

  Local<Value> result;

  }

  // Make sure that no request or handle is created during bootstrap -

  // if necessary those should be done in pre-execution.

  // Usually, doing so would trigger the checks present in the ReqWrap and

  // HandleWrap classes, so this is only a consistency check.

}

static

  // Arguments must match the parameters specified in

  // NativeModuleLoader::LookupAndCompile().

  std::vector<Local<Value>> arguments = {env->process_object(),

                                         env->native_module_require(),

                                         env->internal_binding_loader(),

  return scope.EscapeMaybe(

}

  InternalCallbackScope callback_scope(

      env,

      Object::New(env->isolate()),

      { 1, 0 },

    StartExecutionCallbackInfo info = {

    };

  }

  // TODO(joyeecheung): move these conditions into JS land and let the

  // deserialize main function take precedence. For workers, we need to

  // move the pre-execution part into a different file that can be

  // reused when dealing with user-defined main functions.

  }

  }

  }

  }

  }

  }

  }

  // -e/--eval without -i/--interactive

  }

  }

  }

  }

  }

}

#ifdef __POSIX__

typedef void (*sigaction_cb)(int signo, siginfo_t* info, void* ucontext);

#endif

#if NODE_USE_V8_WASM_TRAP_HANDLER

#if defined(_WIN32)

static LONG TrapWebAssemblyOrContinue(EXCEPTION_POINTERS* exception) {

  if (v8::TryHandleWebAssemblyTrapWindows(exception)) {

    return EXCEPTION_CONTINUE_EXECUTION;

  }

  return EXCEPTION_CONTINUE_SEARCH;

}

#else

static std::atomic<sigaction_cb> previous_sigsegv_action;

    } else {

      // Reset to the default signal handler, i.e. cause a hard crash.

      struct sigaction sa;

    }

  }

#endif  // defined(_WIN32)

#endif  // NODE_USE_V8_WASM_TRAP_HANDLER

#ifdef __POSIX__

                           sigaction_cb handler,

                           bool reset_handler) {

#if NODE_USE_V8_WASM_TRAP_HANDLER

  }

#endif  // NODE_USE_V8_WASM_TRAP_HANDLER

  struct sigaction sa;

}

#endif  // __POSIX__

#ifdef __POSIX__

static struct {

  int flags;

  bool isatty;

  struct stat stat;

  struct termios termios;

} stdio[1 + STDERR_FILENO];

#endif  // __POSIX__

#ifdef __POSIX__

  // Restore signal dispositions, the parent process may have changed them.

  struct sigaction act;

  // The hard-coded upper limit is because NSIG is not very reliable; on Linux,

  // it evaluates to 32, 34 or 64, depending on whether RT signals are enabled.

  // Counting up to SIGRTMIN doesn't work for the same reason.

  }

#endif  // __POSIX__

static std::atomic<uint64_t> init_process_flags = 0;

  // init_process_flags is accessed in ResetStdio(),

  // which can be called from signal handlers.

  init_process_flags.store(flags);

  }

#ifdef __POSIX__

    // Disable stdio buffering, it interacts poorly with printf()

    // calls elsewhere in the program (e.g., any logging from V8.)

    // Make sure file descriptors 0-2 are valid before we start logging

    // anything.

      // Anything but EBADF means something is seriously wrong.  We don't

      // have to special-case EINTR, fstat() is not interruptible.

    }

  }

#if HAVE_INSPECTOR

    sigset_t sigmask;

#endif  // HAVE_INSPECTOR

  }

    // Record the state of the stdio file descriptors so we can restore it

    // on exit.  Needs to happen before installing signal handlers because

    // they make use of that information.

      int err;

    }

  }

#if NODE_USE_V8_WASM_TRAP_HANDLER

#if defined(_WIN32)

    {

      constexpr ULONG first = TRUE;

      per_process::old_vectored_exception_handler =

          AddVectoredExceptionHandler(first, TrapWebAssemblyOrContinue);

    }

#else

    // Tell V8 to disable emitting WebAssembly

    // memory bounds checks. This means that we have

    // to catch the SIGSEGV in TrapWebAssemblyOrContinue

    // and pass the signal context to V8.

    {

      struct sigaction sa;

    }

#endif  // defined(_WIN32)

#endif  // NODE_USE_V8_WASM_TRAP_HANDLER

  }

    // Raise the open file descriptor limit.

    struct rlimit lim;

      // Do a binary search for the limit.

      // But if there's a defined upper bound, don't search, just set it.

      }

        } else {

        }

    }

  }

#endif  // __POSIX__

#ifdef _WIN32

  if (!(flags & ProcessInitializationFlags::kNoStdioInitialization)) {

    for (int fd = 0; fd <= 2; ++fd) {

      auto handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd));

      if (handle == INVALID_HANDLE_VALUE ||

          GetFileType(handle) == FILE_TYPE_UNKNOWN) {

        // Ignore _close result. If it fails or not depends on used Windows

        // version. We will just check _open result.

        _close(fd);

        if (fd != _open("nul", _O_RDWR)) ABORT();

      }

    }

  }

#endif  // _WIN32

// Safe to call more than once and from signal handlers.

  }

#ifdef __POSIX__

    struct stat tmp;

    }

    int flags;

    // Restore the O_NONBLOCK flag if it changed.

      int err;

    }

      sigset_t sa;

      int err;

      // We might be a background job that doesn't own the TTY so block SIGTTOU

      // before making the tcsetattr() call, otherwise that signal suspends us.

      // Normally we expect err == 0. But if macOS App Sandbox is enabled,

      // tcsetattr will fail with err == -1 and errno == EPERM.

    }

  }

#endif  // __POSIX__

}

                      std::vector<std::string>* exec_args,

                      std::vector<std::string>* errors,

                      OptionEnvvarSettings settings) {

  // Parse a few arguments which are specific to Node.

      args,

      exec_args,

      &v8_args,

      per_process::cli_options.get(),

      settings,

      errors);

    }

  }

  }

  // TODO(aduh95): remove this when the harmony-import-assertions flag

  // is removed in V8.

  }

  }

#ifdef __POSIX__

  // Block SIGPROF signals when sleeping in epoll_wait/kevent/etc.  Avoids the

  // performance penalty of frequent EINTR wakeups when the profiler is running.

  // Only do this for v8.log profiling, as it breaks v8::CpuProfiler users.

  }

#endif

  }

  // Anything that's still in v8_argv is not a V8 or a node option.

}

static std::atomic_bool init_called{false};

// TODO(addaleax): Turn this into a wrapper around InitializeOncePerProcess()

// (with the corresponding additional flags set), then eventually remove this.

                           std::vector<std::string>* exec_argv,

                           std::vector<std::string>* errors,

                           ProcessInitializationFlags::Flags flags) {

  // Make sure InitializeNodeWithArgs() is called only once.

  // Initialize node_start_time to get relative uptime.

  // Register built-in modules

  // Make inherited handles noninheritable.

  }

  // Cache the original command line to be

  // used in diagnostic reports.

#if defined(NODE_V8_OPTIONS)

  // Should come before the call to V8::SetFlagsFromCommandLine()

  // so the user can disable a flag --foo at run-time by passing

  // --no_foo from the command line.

  V8::SetFlagsFromString(NODE_V8_OPTIONS, sizeof(NODE_V8_OPTIONS) - 1);

#endif

#if !defined(NODE_WITHOUT_NODE_OPTIONS)

      std::vector<std::string> env_argv =

      // [0] is expected to be the program name, fill it in from the real argv.

                                              nullptr,

                                              errors,

                                              kAllowedInEnvironment);

    }

  }

#endif

                                            exec_argv,

                                            errors,

                                            kDisallowedInEnvironment);

  }

  // Set the process.title immediately after processing argv if --title is set.

#if defined(NODE_HAVE_I18N_SUPPORT)

    // If the parameter isn't given, use the env variable.

#ifdef NODE_ICU_DEFAULT_DATA_DIR

    // If neither the CLI option nor the environment variable was specified,

    // fall back to the configured default

    if (per_process::cli_options->icu_data_dir.empty()) {

      // Check whether the NODE_ICU_DEFAULT_DATA_DIR contains the right data

      // file and can be read.

      static const char full_path[] =

          NODE_ICU_DEFAULT_DATA_DIR "/" U_ICUDATA_NAME ".dat";

      FILE* f = fopen(full_path, "rb");

      if (f != nullptr) {

        fclose(f);

        per_process::cli_options->icu_data_dir = NODE_ICU_DEFAULT_DATA_DIR;

      }

    }