#include "node_options.h"  // NOLINT(build/include_inline)

#include "node_options-inl.h"

#include "env-inl.h"

#include "node_binding.h"

#include "node_internals.h"

#include <errno.h>

#include <sstream>

#include <limits>

#include <algorithm>

#include <cstdlib>  // strtoul, errno

using v8::Boolean;

using v8::Context;

using v8::FunctionCallbackInfo;

using v8::Integer;

using v8::Isolate;

using v8::Local;

using v8::Map;

using v8::Number;

using v8::Object;

using v8::Undefined;

using v8::Value;

namespace node {

namespace per_process {

Mutex cli_options_mutex;

std::shared_ptr<PerProcessOptions> cli_options{new PerProcessOptions()};

}  // namespace per_process

#if !NODE_USE_V8_PLATFORM && !HAVE_INSPECTOR

  if (inspector_enabled) {

    errors->push_back("Inspector is not available when Node is compiled "

                      "--without-v8-platform and --without-inspector.");

  }

#endif

                      "are invalid. Please use `node --inspect` and "

                      "`node --inspect-brk` instead.");

  }

  std::vector<std::string> destinations =

    } else {

                        "stderr or http");

    }

  }

#if HAVE_OPENSSL

                      "used, not both");

  }

  // Any value less than 2 disables use of the secure heap.

            static_cast<int64_t>(std::numeric_limits<int>::max())});

  }

#endif

  }

                      "--experimental-policy be enabled");

  }

  }

    }

  }

        "invalid value for --experimental-specifier-resolution");

    }

  }

  }

  }

                      "used, not both");

  }

  }

#if HAVE_INSPECTOR

    }

    }

    // We can't catch the case where the value passed is the default value,

    // then the option just becomes a noop which is fine.

    }

  }

    }

    }

    }

    // We can't catch the case where the value passed is the default value,

    // then the option just becomes a noop which is fine.

    }

  }

  }

#endif  // HAVE_INSPECTOR

namespace options_parser {

class DebugOptionsParser : public OptionsParser<DebugOptions> {

 public:

  DebugOptionsParser();

};

class EnvironmentOptionsParser : public OptionsParser<EnvironmentOptions> {

 public:

  EnvironmentOptionsParser();

};

class PerIsolateOptionsParser : public OptionsParser<PerIsolateOptions> {

 public:

  PerIsolateOptionsParser() = delete;

  explicit PerIsolateOptionsParser(const EnvironmentOptionsParser& eop);

};

class PerProcessOptionsParser : public OptionsParser<PerProcessOptions> {

 public:

  PerProcessOptionsParser() = delete;

  explicit PerProcessOptionsParser(const PerIsolateOptionsParser& iop);

};

#if HAVE_INSPECTOR

const DebugOptionsParser _dop_instance{};

const EnvironmentOptionsParser _eop_instance{_dop_instance};

// This Parse is not dead code. It is used by embedders (e.g., Electron).

template <>

  StringVector* const args, StringVector* const exec_args,

  StringVector* const v8_args,

  DebugOptions* const options,

  OptionEnvvarSettings required_env_settings, StringVector* const errors) {

    args, exec_args, v8_args, options, required_env_settings, errors);

}

#else

const EnvironmentOptionsParser _eop_instance{};

#endif  // HAVE_INSPECTOR

const PerIsolateOptionsParser _piop_instance{_eop_instance};

const PerProcessOptionsParser _ppop_instance{_piop_instance};

template <>

  StringVector* const args, StringVector* const exec_args,

  StringVector* const v8_args,

  PerIsolateOptions* const options,

  OptionEnvvarSettings required_env_settings, StringVector* const errors) {

    args, exec_args, v8_args, options, required_env_settings, errors);

template <>

  StringVector* const args, StringVector* const exec_args,

  StringVector* const v8_args,

  PerProcessOptions* const options,

  OptionEnvvarSettings required_env_settings, StringVector* const errors) {

    args, exec_args, v8_args, options, required_env_settings, errors);

// XXX: If you add an option here, please also add it to doc/node.1 and

// doc/api/cli.md

// TODO(addaleax): Make that unnecessary.

            "set host:port for inspector",

            &DebugOptions::host_port,

            kAllowedInEnvironment);

            "activate inspector on host:port (default: 127.0.0.1:9229)",

            &DebugOptions::inspector_enabled,

            kAllowedInEnvironment);

            "activate inspector on host:port and break at start of user script",

            &DebugOptions::break_first_line,

            kAllowedInEnvironment);

            "comma separated list of destinations for inspector uid"

            "(default: stderr,http)",

            &DebugOptions::inspect_publish_uid_string,

            kAllowedInEnvironment);

            "additional user conditions for conditional exports and imports",

            &EnvironmentOptions::conditions,

            kAllowedInEnvironment);

            "set dir for all output files"

            " (default: current working directory)",

            &EnvironmentOptions::diagnostic_dir,

            kAllowedInEnvironment);

            "set default value of verbatim in dns.lookup. Options are "

            "'ipv4first' (IPv4 addresses are placed before IPv6 addresses) "

            "'verbatim' (addresses are in the order the DNS resolver "

            "returned)",

            &EnvironmentOptions::dns_result_order,

            kAllowedInEnvironment);

            "Source Map V3 support for stack traces",

            &EnvironmentOptions::enable_source_maps,

            kAllowedInEnvironment);

            "experimental JSON interop support for the ES Module loader",

            &EnvironmentOptions::experimental_json_modules,

            kAllowedInEnvironment);

            "use the specified module as a custom loader",

            &EnvironmentOptions::userland_loader,

            kAllowedInEnvironment);

            "",

            &EnvironmentOptions::experimental_modules,

            kAllowedInEnvironment);

            "experimental ES Module support for webassembly modules",

            &EnvironmentOptions::experimental_wasm_modules,

            kAllowedInEnvironment);

            "experimental ES Module import.meta.resolve() support",

            &EnvironmentOptions::experimental_import_meta_resolve,

            kAllowedInEnvironment);

            "use the specified file as a "

            "security policy",

            &EnvironmentOptions::experimental_policy,

            kAllowedInEnvironment);

            "",

            &EnvironmentOptions::has_policy_integrity_string);

            "ensure the security policy contents match "

            "the specified integrity",

            &EnvironmentOptions::experimental_policy_integrity,

            kAllowedInEnvironment);

            "experimental await keyword support in REPL",

            &EnvironmentOptions::experimental_repl_await,

            kAllowedInEnvironment,

            true);

            "experimental ES Module support in vm module",

            &EnvironmentOptions::experimental_vm_modules,

            kAllowedInEnvironment);

            "experimental WASI support",

            &EnvironmentOptions::experimental_wasi,

            kAllowedInEnvironment);

            "experimental frozen intrinsics support",

            &EnvironmentOptions::frozen_intrinsics,

            kAllowedInEnvironment);

            "Generate heap snapshot on specified signal",

            &EnvironmentOptions::heap_snapshot_signal,

            kAllowedInEnvironment);

            "Generate heap snapshots whenever V8 is approaching "

            "the heap limit. No more than the specified number of "

            "heap snapshots will be generated.",

            &EnvironmentOptions::heap_snapshot_near_heap_limit,

            kAllowedInEnvironment);

            "use an insecure HTTP parser that accepts invalid HTTP headers",

            &EnvironmentOptions::insecure_http_parser,

            kAllowedInEnvironment);

            "set module type for string input",

            &EnvironmentOptions::module_type,

            kAllowedInEnvironment);

            "Select extension resolution algorithm for es modules; "

            "either 'explicit' (default) or 'node'",

            &EnvironmentOptions::experimental_specifier_resolution,

            kAllowedInEnvironment);

           "--experimental-specifier-resolution");

            "silence deprecation warnings",

            &EnvironmentOptions::deprecation,

            kAllowedInEnvironment,

            true);

            "disable checks for async_hooks",

            &EnvironmentOptions::force_async_hooks_checks,

            kAllowedInEnvironment,

            true);

            "disable loading native addons",

            &EnvironmentOptions::allow_native_addons,

            kAllowedInEnvironment,

            true);

            "silence all process warnings",

            &EnvironmentOptions::warnings,

            kAllowedInEnvironment,

            true);

            "disable loading non-context-aware addons",

            &EnvironmentOptions::force_context_aware,

            kAllowedInEnvironment);

            "emit pending deprecation warnings",

            &EnvironmentOptions::pending_deprecation,

            kAllowedInEnvironment);

            "preserve symbolic links when resolving",

            &EnvironmentOptions::preserve_symlinks,

            kAllowedInEnvironment);

            "preserve symbolic links when resolving the main module",

            &EnvironmentOptions::preserve_symlinks_main,

            kAllowedInEnvironment);

            "Generate V8 profiler output.",

            "process V8 profiler output generated using --prof",

            &EnvironmentOptions::prof_process);

  // Options after --prof-process are passed through to the prof processor.

#if HAVE_INSPECTOR

            "Start the V8 CPU profiler on start up, and write the CPU profile "

            "to disk before exit. If --cpu-prof-dir is not specified, write "

            "the profile to the current working directory.",

            &EnvironmentOptions::cpu_prof);

            "specified file name of the V8 CPU profile generated with "

            "--cpu-prof",

            &EnvironmentOptions::cpu_prof_name);

            "specified sampling interval in microseconds for the V8 CPU "

            "profile generated with --cpu-prof. (default: 1000)",

            &EnvironmentOptions::cpu_prof_interval);

            "Directory where the V8 profiles generated by --cpu-prof will be "

            "placed. Does not affect --prof.",

            &EnvironmentOptions::cpu_prof_dir);

      "--heap-prof",

      "Start the V8 heap profiler on start up, and write the heap profile "

      "to disk before exit. If --heap-prof-dir is not specified, write "

      "the profile to the current working directory.",

      &EnvironmentOptions::heap_prof);

            "specified file name of the V8 heap profile generated with "

            "--heap-prof",

            &EnvironmentOptions::heap_prof_name);

            "Directory where the V8 heap profiles generated by --heap-prof "

            "will be placed.",

            &EnvironmentOptions::heap_prof_dir);

            "specified sampling interval in bytes for the V8 heap "

            "profile generated with --heap-prof. (default: 512 * 1024)",

            &EnvironmentOptions::heap_prof_interval);

#endif  // HAVE_INSPECTOR

            "set the maximum size of HTTP headers (default: 16384 (16KB))",

            &EnvironmentOptions::max_http_header_size,

            kAllowedInEnvironment);

            "write warnings to file instead of stderr",

            &EnvironmentOptions::redirect_warnings,

            kAllowedInEnvironment);

            &EnvironmentOptions::test_udp_no_try_send);

            "throw an exception on deprecations",

            &EnvironmentOptions::throw_deprecation,

            kAllowedInEnvironment);

            "trace Atomics.wait() operations",

            &EnvironmentOptions::trace_atomics_wait,

            kAllowedInEnvironment);

            "show stack traces on deprecations",

            &EnvironmentOptions::trace_deprecation,

            kAllowedInEnvironment);

            "show stack trace when an environment exits",

            &EnvironmentOptions::trace_exit,

            kAllowedInEnvironment);

            "show stack trace when use of sync IO is detected after the "

            "first tick",

            &EnvironmentOptions::trace_sync_io,

            kAllowedInEnvironment);

            "prints TLS packet trace information to stderr",

            &EnvironmentOptions::trace_tls,

            kAllowedInEnvironment);

            "show stack traces for the `throw` behind uncaught exceptions",

            &EnvironmentOptions::trace_uncaught,

            kAllowedInEnvironment);

            "show stack traces on process warnings",

            &EnvironmentOptions::trace_warnings,

            kAllowedInEnvironment);

            "hide extra information on fatal exception that causes exit",

            &EnvironmentOptions::extra_info_on_fatal_exception,

            kAllowedInEnvironment,

            true);

            "define unhandled rejections behavior. Options are 'strict' "

            "(always raise an error), 'throw' (raise an error unless "

            "'unhandledRejection' hook is set), 'warn' (log a warning), 'none' "

            "(silence warnings), 'warn-with-error-code' (log a warning and set "

            "exit code 1 unless 'unhandledRejection' hook is set). (default: "

            "throw)",

            &EnvironmentOptions::unhandled_rejections,

            kAllowedInEnvironment);

            "", /* undocumented, only for debugging */

            &EnvironmentOptions::verify_base_objects,

            kAllowedInEnvironment);

            "syntax check script without executing",

            &EnvironmentOptions::syntax_check_only);

  // This option is only so that we can tell --eval with an empty string from

  // no eval at all. Having it not start with a dash makes it inaccessible

  // from the parser itself, but available for using Implies().

  // TODO(addaleax): When moving --help over to something generated from the

  // programmatic descriptions, this will need some special care.

  // (See also [ssl_openssl_cert_store] below.)

            "evaluate script and print result",

            &EnvironmentOptions::print_eval);

            "module to preload (option can be repeated)",

            &EnvironmentOptions::preload_modules,

            kAllowedInEnvironment);

            "always enter the REPL even if stdin does not appear "

            "to be a terminal",

            &EnvironmentOptions::force_repl);

            "log TLS decryption keys to named file for traffic analysis",

            &EnvironmentOptions::tls_keylog, kAllowedInEnvironment);

            "set default TLS minimum to TLSv1.0 (default: TLSv1.2)",

            &EnvironmentOptions::tls_min_v1_0,

            kAllowedInEnvironment);

            "set default TLS minimum to TLSv1.1 (default: TLSv1.2)",

            &EnvironmentOptions::tls_min_v1_1,

            kAllowedInEnvironment);

            "set default TLS minimum to TLSv1.2 (default: TLSv1.2)",

            &EnvironmentOptions::tls_min_v1_2,

            kAllowedInEnvironment);

            "set default TLS minimum to TLSv1.3 (default: TLSv1.2)",

            &EnvironmentOptions::tls_min_v1_3,

            kAllowedInEnvironment);

            "set default TLS maximum to TLSv1.2 (default: TLSv1.3)",

            &EnvironmentOptions::tls_max_v1_2,

            kAllowedInEnvironment);

  // Current plan is:

  // - 11.x and below: TLS1.3 is opt-in with --tls-max-v1.3

  // - 12.x: TLS1.3 is opt-out with --tls-max-v1.2

  // In either case, support both options they are uniformly available.

            "set default TLS maximum to TLSv1.3 (default: TLSv1.3)",

            &EnvironmentOptions::tls_max_v1_3,

            kAllowedInEnvironment);

            "track heap object allocations for heap snapshots",

            &PerIsolateOptions::track_heap_objects,

            kAllowedInEnvironment);

            "",  // It's a debug-only option.

            &PerIsolateOptions::node_snapshot,

            kAllowedInEnvironment);

  // Explicitly add some V8 flags to mark them as allowed in NODE_OPTIONS.

            "aborting instead of exiting causes a core file to be generated "

            "for analysis",

            kAllowedInEnvironment);

            "help system profilers to translate JavaScript interpreted frames",

            "",

            kAllowedInEnvironment);

            "",

            kAllowedInEnvironment);

            "disallow eval and friends",

            kAllowedInEnvironment);

             "increase default maximum heap size on machines with 16GB memory "

             "or more",

             kAllowedInEnvironment);

             "disable runtime allocation of executable memory",

             kAllowedInEnvironment);

            "generate diagnostic report on uncaught exceptions",

            &PerIsolateOptions::report_uncaught_exception,

            kAllowedInEnvironment);

            "generate diagnostic report upon receiving signals",

            &PerIsolateOptions::report_on_signal,

            kAllowedInEnvironment);

            "causes diagnostic report to be produced on provided signal,"

            " unsupported in Windows. (default: SIGUSR2)",

            &PerIsolateOptions::report_signal,

            kAllowedInEnvironment);

            "",

            &PerIsolateOptions::experimental_top_level_await,

            kAllowedInEnvironment);

            "the process title to use on startup",

            &PerProcessOptions::title,

            kAllowedInEnvironment);

            "comma separated list of trace event categories to record",

            &PerProcessOptions::trace_event_categories,

            kAllowedInEnvironment);

            "Template string specifying the filepath for the trace-events "

            "data, it supports ${rotation} and ${pid}.",

            &PerProcessOptions::trace_event_file_pattern,

            kAllowedInEnvironment);

            "set V8's thread pool size",

            &PerProcessOptions::v8_thread_pool_size,

            kAllowedInEnvironment);

            "automatically zero-fill all newly allocated Buffer and "

            "SlowBuffer instances",

            &PerProcessOptions::zero_fill_all_buffers,

            kAllowedInEnvironment);

            "", /* undocumented, only for debugging */

            &PerProcessOptions::debug_arraybuffer_allocations,

            kAllowedInEnvironment);

            "disable Object.prototype.__proto__",

            &PerProcessOptions::disable_proto,

            kAllowedInEnvironment);

  // 12.x renamed this inadvertently, so alias it for consistency within the

  // release line, while using the original name for consistency with older

  // release lines.

            "print source-able bash completion script",

            &PerProcessOptions::print_bash_completion);

            "print node command line options",

            &PerProcessOptions::print_help);

      "--version", "print Node.js version", &PerProcessOptions::print_version);

            "print V8 command line options",

            &PerProcessOptions::print_v8_help);

            "output compact single-line JSON",

            &PerProcessOptions::report_compact,

            kAllowedInEnvironment);

            "define custom report pathname."

            " (default: current working directory)",

            &PerProcessOptions::report_directory,

            kAllowedInEnvironment);

            "define custom report file name."

            " (default: YYYYMMDD.HHMMSS.PID.SEQUENCE#.txt)",

            &PerProcessOptions::report_filename,

            kAllowedInEnvironment);

              "generate diagnostic report on fatal (internal) errors",

              &PerProcessOptions::report_on_fatalerror,

              kAllowedInEnvironment);

#ifdef NODE_HAVE_I18N_SUPPORT

            "set ICU data load path to dir (overrides NODE_ICU_DATA)"

#ifndef NODE_HAVE_SMALL_ICU

            " (note: linked-in ICU data is present)"

#endif

            ,

            &PerProcessOptions::icu_data_dir,

            kAllowedInEnvironment);

#endif

#if HAVE_OPENSSL

            "load OpenSSL configuration from the specified file "

            "(overrides OPENSSL_CONF)",

            &PerProcessOptions::openssl_config,

            kAllowedInEnvironment);

            "use an alternative default TLS cipher list",

            &PerProcessOptions::tls_cipher_list,

            kAllowedInEnvironment);

            "use OpenSSL's default CA store"

#if defined(NODE_OPENSSL_CERT_STORE)

            " (default)"

#endif

            ,

            &PerProcessOptions::use_openssl_ca,

            kAllowedInEnvironment);

            "use bundled CA store"

#if !defined(NODE_OPENSSL_CERT_STORE)

            " (default)"

#endif

            ,

            &PerProcessOptions::use_bundled_ca,

            kAllowedInEnvironment);

  // Similar to [has_eval_string] above, except that the separation between

  // this and use_openssl_ca only exists for option validation after parsing.

  // This is not ideal.

            "",

            &PerProcessOptions::ssl_openssl_cert_store);

            "enable FIPS crypto at startup",

            &PerProcessOptions::enable_fips_crypto,

            kAllowedInEnvironment);

            "force FIPS crypto (cannot be disabled)",

            &PerProcessOptions::force_fips_crypto,

            kAllowedInEnvironment);

            "total size of the OpenSSL secure heap",

            &PerProcessOptions::secure_heap,

            kAllowedInEnvironment);

            "minimum allocation size from the OpenSSL secure heap",

            &PerProcessOptions::secure_heap_min,

            kAllowedInEnvironment);

#endif

            "Map the Node.js static code to large pages. Options are "

            "'off' (the default value, meaning do not map), "

            "'on' (map and ignore failure, reporting it to stderr), "

            "or 'silent' (map and silently ignore failure)",

            &PerProcessOptions::use_largepages,

            kAllowedInEnvironment);

            "enable printing JavaScript stacktrace on SIGINT",

            &PerProcessOptions::trace_sigint,

            kAllowedInEnvironment);

            "Run with extra debug checks for memory leaks in Node.js itself",

  else

}

                                std::vector<std::string>* errors) {

  char* endptr;

  const unsigned long result =                 // NOLINT(runtime/int)

  }

}

                      std::vector<std::string>* errors) {

  // remove_brackets only works if no port is specified

  // so if it has an effect only an IPv6 address was specified.

    // Either a port number or a host name.  Assume that

    // if it's not all decimal digits, it's a host name.

      }

    }

  }

  // Host and port found:

}

  out << "_node_complete() {\n"

         "  local cur_word options\n"

         "  cur_word=\"${COMP_WORDS[COMP_CWORD]}\"\n"

         "  if [[ \"${cur_word}\" == -* ]] ; then\n"

    }

  }

    }

  }

  }

  out << "' -- \"${cur_word}\") )\n"

         "    return 0\n"

         "  else\n"

         "    COMPREPLY=( $(compgen -f \"${cur_word}\") )\n"

         "    return 0\n"

         "  fi\n"

         "}\n"

         "complete -o filenames -o nospace -o bashdefault "

}

// Return a map containing all the options and their metadata as well

// as the aliases

    // No code because this is an assertion.

  }

  // Temporarily act as if the current Environment's/IsolateData's options were

  // the default options, i.e. like they are the ones we'd access for global

  // options parsing, so that all options are available from the main parser.

  }

    Local<Value> value;

      case kV8Option:

        // Special case for --abort-on-uncaught-exception which is also

        // respected by Node.js internals

        } else {

        }