parser.add_option('--without-node-options',

action='store_true',

dest='without_node_options',

help='build without NODE_OPTIONS support')

o['variables']['node_without_node_options'] = b(options.without_node_options)

if options.without_node_options:

o['defines'] += ['NODE_WITHOUT_NODE_OPTIONS']

`options...` are interpreted as if they had been specified on the command line

before the actual command line (so they can be overriden). Node will exit with

an error if an option that is not allowed in the environment is used, such as

`-p` or a script file.

Node options that are allowed are:

- `--enable-fips`

- `--force-fips`

- `--icu-data-dir`

- `--no-deprecation`

- `--no-warnings`

- `--openssl-config`

- `--prof-process`

- `--redirect-warnings`

- `--require`, `-r`

- `--throw-deprecation`

- `--trace-deprecation`

- `--trace-events-enabled`

- `--trace-sync-io`

- `--trace-warnings`

- `--track-heap-objects`

- `--use-bundled-ca`

- `--use-openssl-ca`

- `--v8-pool-size`

- `--zero-fill-buffers`

V8 options that are allowed are:

- `--max_old_space_size`

.TP

\fBoptions...\fR are interpreted as if they had been specified on the command

line before the actual command line (so they can be overriden). Node will exit

with an error if an option that is not allowed in the environment is used, such

as \fB-p\fR or a script file.

#if !defined(NODE_WITHOUT_NODE_OPTIONS)

"NODE_OPTIONS set CLI options in the environment\n"

#endif

static void CheckIfAllowedInEnv(const char* exe, bool is_env,

const char* arg) {

if (!is_env)

return;

// Find the arg prefix when its --some_arg=val

const char* eq = strchr(arg, '=');

size_t arglen = eq ? eq - arg : strlen(arg);

static const char* whitelist[] = {

// Node options

"-r", "--require",

"--no-deprecation",

"--no-warnings",

"--trace-warnings",

"--redirect-warnings",

"--trace-deprecation",

"--trace-sync-io",

"--track-heap-objects",

"--throw-deprecation",

"--zero-fill-buffers",

"--v8-pool-size",

"--use-openssl-ca",

"--use-bundled-ca",

"--enable-fips",

"--force-fips",

"--openssl-config",

"--icu-data-dir",

// V8 options

"--max_old_space_size",

};

for (unsigned i = 0; i < arraysize(whitelist); i++) {

const char* allowed = whitelist[i];

if (strlen(allowed) == arglen && strncmp(allowed, arg, arglen) == 0)

return;

}

fprintf(stderr, "%s: %s is not allowed in NODE_OPTIONS\n", exe, arg);

exit(9);

}

const char*** v8_argv,

bool is_env) {

CheckIfAllowedInEnv(argv[0], is_env, arg);

if (is_env && args_left) {

fprintf(stderr, "%s: %s is not supported in NODE_OPTIONS\n",

argv[0], argv[index]);

exit(9);

}

void ProcessArgv(int* argc,

const char** argv,

int* exec_argc,

const char*** exec_argv,

bool is_env = false) {

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

int v8_argc;

const char** v8_argv;

ParseArgs(argc, argv, exec_argc, exec_argv, &v8_argc, &v8_argv, is_env);

// TODO(bnoordhuis) Intercept --prof arguments and start the CPU profiler

// manually? That would give us a little more control over its runtime

// behavior but it could also interfere with the user's intentions in ways

// we fail to anticipate. Dillema.

for (int i = 1; i < v8_argc; ++i) {

if (strncmp(v8_argv[i], "--prof", sizeof("--prof") - 1) == 0) {

v8_is_profiling = true;

break;

}

}

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

if (v8_is_profiling) {

uv_loop_configure(uv_default_loop(), UV_LOOP_BLOCK_SIGNAL, SIGPROF);

}

#endif

// The const_cast doesn't violate conceptual const-ness. V8 doesn't modify

// the argv array or the elements it points to.

if (v8_argc > 1)

V8::SetFlagsFromCommandLine(&v8_argc, const_cast<char**>(v8_argv), true);

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

for (int i = 1; i < v8_argc; i++) {

fprintf(stderr, "%s: bad option: %s\n", argv[0], v8_argv[i]);

}

delete[] v8_argv;

v8_argv = nullptr;

if (v8_argc > 1) {

exit(9);

}

}

#if !defined(NODE_WITHOUT_NODE_OPTIONS)

std::string node_options;

if (SafeGetenv("NODE_OPTIONS", &node_options)) {

// Smallest tokens are 2-chars (a not space and a space), plus 2 extra

// pointers, for the prepended executable name, and appended NULL pointer.

size_t max_len = 2 + (node_options.length() + 1) / 2;

const char** argv_from_env = new const char*[max_len];

int argc_from_env = 0;

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

argv_from_env[argc_from_env++] = argv[0];

char* cstr = strdup(node_options.c_str());

char* initptr = cstr;

char* token;

while ((token = strtok(initptr, " "))) { // NOLINT(runtime/threadsafe_fn)

initptr = nullptr;

argv_from_env[argc_from_env++] = token;

argv_from_env[argc_from_env] = nullptr;

int exec_argc_;

const char** exec_argv_ = nullptr;

ProcessArgv(&argc_from_env, argv_from_env, &exec_argc_, &exec_argv_, true);

delete[] exec_argv_;

delete[] argv_from_env;

free(cstr);

ProcessArgv(argc, argv, exec_argc, exec_argv);

const common = require('../common');

if (process.config.variables.node_without_node_options)

return common.skip('missing NODE_OPTIONS support');

const assert = require('assert');

const exec = require('child_process').execFile;

function disallow(opt) {

const options = {env: {NODE_OPTIONS: opt}};

exec(process.execPath, options, common.mustCall(function(err) {

const message = err.message.split(/\r?\n/)[1];

const expect = process.execPath + ': ' + opt +

' is not allowed in NODE_OPTIONS';

assert.strictEqual(err.code, 9);

assert.strictEqual(message, expect);

}));

const printA = require.resolve('../fixtures/printA.js');

expect('-r ' + printA, 'A\nB\n');

expect('--no-deprecation', 'B\n');

expect('--no-warnings', 'B\n');

expect('--trace-warnings', 'B\n');

expect('--trace-deprecation', 'B\n');

expect('--trace-sync-io', 'B\n');

expect('--track-heap-objects', 'B\n');

expect('--throw-deprecation', 'B\n');

expect('--zero-fill-buffers', 'B\n');

expect('--v8-pool-size=10', 'B\n');

expect('--use-openssl-ca', 'B\n');

expect('--use-bundled-ca', 'B\n');

expect('--openssl-config=_ossl_cfg', 'B\n');

expect('--icu-data-dir=_d', 'B\n');

// V8 options

expect('--max_old_space_size=0', 'B\n');

function expect(opt, want) {

const printB = require.resolve('../fixtures/printB.js');

const argv = [printB];

const opts = {

env: {NODE_OPTIONS: opt},

maxBuffer: 1000000000,

};

exec(process.execPath, argv, opts, common.mustCall(function(err, stdout) {

assert.ifError(err);

if (!RegExp(want).test(stdout)) {

console.error('For %j, failed to find %j in: <\n%s\n>',

opt, expect, stdout);

assert(false, 'Expected ' + expect);

}

}));