meta: merge node/master into node-chakracore/master

Merge 0300565 as of 2017-11-06 This commit was automatically generated. For any problems, please contact jackhorton Reviewed-By: Jack Horton <[email protected]>
nodejs · Nov 8, 2017 · 1615778 · 1615778
2 parents a9a7dd0 + 0300565
commit 1615778
Show file tree

Hide file tree

Showing 285 changed files with 9,461 additions and 8,909 deletions.
diff --git a/doc/api/errors.md b/doc/api/errors.md
@@ -754,6 +754,11 @@ more headers.
 Used when an invalid character is found in an HTTP response status message
 (reason phrase).
 
+<a id="ERR_HTTP_INVALID_HEADER_VALUE"></a>
+### ERR_HTTP_INVALID_HEADER_VALUE
+
+Used to indicate that an invalid HTTP header value has been specified.
+
 <a id="ERR_HTTP_INVALID_STATUS_CODE"></a>
 ### ERR_HTTP_INVALID_STATUS_CODE
 
@@ -837,7 +842,7 @@ requests and responses.
 <a id="ERR_HTTP2_INVALID_HEADER_VALUE"></a>
 ### ERR_HTTP2_INVALID_HEADER_VALUE
 
-Used to indicate that an invalid HTTP/2 header value has been specified.
+Used to indicate that an invalid HTTP2 header value has been specified.
 
 <a id="ERR_HTTP2_INVALID_INFO_STATUS"></a>
 ### ERR_HTTP2_INVALID_INFO_STATUS

diff --git a/doc/api/events.md b/doc/api/events.md
@@ -77,7 +77,7 @@ myEmitter.emit('event', 'a', 'b');
 
 ## Asynchronous vs. Synchronous
 
-The `EventListener` calls all listeners synchronously in the order in which
+The `EventEmitter` calls all listeners synchronously in the order in which
 they were registered. This is important to ensure the proper sequencing of
 events and to avoid race conditions or logic errors. When appropriate,
 listener functions can switch to an asynchronous mode of operation using
@@ -268,7 +268,7 @@ property can be used. If this value is not a positive number, a `TypeError`
 will be thrown.
 
 Take caution when setting the `EventEmitter.defaultMaxListeners` because the
-change effects *all* `EventEmitter` instances, including those created before
+change affects *all* `EventEmitter` instances, including those created before
 the change is made. However, calling [`emitter.setMaxListeners(n)`][] still has
 precedence over `EventEmitter.defaultMaxListeners`.
 

diff --git a/doc/api/stream.md b/doc/api/stream.md
@@ -316,7 +316,7 @@ reader.pipe(writer);
 added: v0.9.4
 -->
 
-* `src` {[Readable][] Stream} The source stream that
+* `src` {stream.Readable} The source stream that
   [unpiped][`stream.unpipe()`] this writable
 
 The `'unpipe'` event is emitted when the [`stream.unpipe()`][] method is called

diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
@@ -437,16 +437,7 @@ function _storeHeader(firstLine, headers) {
 
 function storeHeader(self, state, key, value, validate) {
   if (validate) {
-    if (typeof key !== 'string' || !key || !checkIsHttpToken(key)) {
-      throw new errors.TypeError(
-        'ERR_INVALID_HTTP_TOKEN', 'Header name', key);
-    }
-    if (value === undefined) {
-      throw new errors.TypeError('ERR_MISSING_ARGS', `header "${key}"`);
-    } else if (checkInvalidHeaderChar(value)) {
-      debug('Header "%s" contains invalid characters', key);
-      throw new errors.TypeError('ERR_INVALID_CHAR', 'header content', key);
-    }
+    validateHeader(key, value);
   }
   state.header += key + ': ' + escapeHeaderValue(value) + CRLF;
   matchHeader(self, state, key, value);
@@ -494,20 +485,27 @@ function matchHeader(self, state, field, value) {
   }
 }
 
-function validateHeader(msg, name, value) {
-  if (typeof name !== 'string' || !name || !checkIsHttpToken(name))
-    throw new errors.TypeError('ERR_INVALID_HTTP_TOKEN', 'Header name', name);
-  if (value === undefined)
-    throw new errors.TypeError('ERR_MISSING_ARGS', 'value');
-  if (msg._header)
-    throw new errors.Error('ERR_HTTP_HEADERS_SENT', 'set');
-  if (checkInvalidHeaderChar(value)) {
+function validateHeader(name, value) {
+  let err;
+  if (typeof name !== 'string' || !name || !checkIsHttpToken(name)) {
+    err = new errors.TypeError('ERR_INVALID_HTTP_TOKEN', 'Header name', name);
+  } else if (value === undefined) {
+    err = new errors.TypeError('ERR_HTTP_INVALID_HEADER_VALUE', value, name);
+  } else if (checkInvalidHeaderChar(value)) {
     debug('Header "%s" contains invalid characters', name);
-    throw new errors.TypeError('ERR_INVALID_CHAR', 'header content', name);
+    err = new errors.TypeError('ERR_INVALID_CHAR', 'header content', name);
+  }
+  if (err !== undefined) {
+    Error.captureStackTrace(err, validateHeader);
+    throw err;
   }
 }
+
 OutgoingMessage.prototype.setHeader = function setHeader(name, value) {
-  validateHeader(this, name, value);
+  if (this._header) {
+    throw new errors.Error('ERR_HTTP_HEADERS_SENT', 'set');
+  }
+  validateHeader(name, value);
 
   if (!this[outHeadersKey])
     this[outHeadersKey] = {};

diff --git a/lib/internal/errors.js b/lib/internal/errors.js
@@ -280,7 +280,7 @@ E('ERR_HTTP2_INFO_STATUS_NOT_ALLOWED',
   'Informational status codes cannot be used');
 E('ERR_HTTP2_INVALID_CONNECTION_HEADERS',
   'HTTP/1 Connection specific headers are forbidden: "%s"');
-E('ERR_HTTP2_INVALID_HEADER_VALUE', 'Value must not be undefined or null');
+E('ERR_HTTP2_INVALID_HEADER_VALUE', 'Invalid value "%s" for header "%s"');
 E('ERR_HTTP2_INVALID_INFO_STATUS',
   (code) => `Invalid informational status code: ${code}`);
 E('ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH',
@@ -317,6 +317,7 @@ E('ERR_HTTP2_UNSUPPORTED_PROTOCOL',
 E('ERR_HTTP_HEADERS_SENT',
   'Cannot %s headers after they are sent to the client');
 E('ERR_HTTP_INVALID_CHAR', 'Invalid character in statusMessage.');
+E('ERR_HTTP_INVALID_HEADER_VALUE', 'Invalid value "%s" for header "%s"');
 E('ERR_HTTP_INVALID_STATUS_CODE',
   (originalStatusCode) => `Invalid status code: ${originalStatusCode}`);
 E('ERR_HTTP_TRAILER_INVALID',

diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
@@ -40,12 +40,18 @@ let statusMessageWarned = false;
 // close as possible to the current require('http') API
 
 function assertValidHeader(name, value) {
-  if (name === '' || typeof name !== 'string')
-    throw new errors.TypeError('ERR_INVALID_HTTP_TOKEN', 'Header name', name);
-  if (isPseudoHeader(name))
-    throw new errors.Error('ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED');
-  if (value === undefined || value === null)
-    throw new errors.TypeError('ERR_HTTP2_INVALID_HEADER_VALUE');
+  let err;
+  if (name === '' || typeof name !== 'string') {
+    err = new errors.TypeError('ERR_INVALID_HTTP_TOKEN', 'Header name', name);
+  } else if (isPseudoHeader(name)) {
+    err = new errors.Error('ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED');
+  } else if (value === undefined || value === null) {
+    err = new errors.TypeError('ERR_HTTP2_INVALID_HEADER_VALUE', value, name);
+  }
+  if (err !== undefined) {
+    Error.captureStackTrace(err, assertValidHeader);
+    throw err;
+  }
 }
 
 function isPseudoHeader(name) {

diff --git a/src/inspector_agent.h b/src/inspector_agent.h
@@ -10,6 +10,7 @@
 #endif
 
 #include "node_debug_options.h"
+#include "node_platform.h"
 #include "v8.h"
 
 namespace v8_inspector {
@@ -19,7 +20,6 @@ class StringView;
 namespace node {
 // Forward declaration to break recursive dependency chain with src/env.h.
 class Environment;
-class NodePlatform;
 
 namespace inspector {
 

diff --git a/src/module_wrap.cc b/src/module_wrap.cc
@@ -310,17 +310,21 @@ std::string ReadFile(uv_file file) {
   uv_fs_t req;
   char buffer_memory[4096];
   uv_buf_t buf = uv_buf_init(buffer_memory, sizeof(buffer_memory));
+  int r;
+
   do {
-    uv_fs_read(uv_default_loop(),
-               &req,
-               file,
-               &buf,
-               1,
-               contents.length(),  // offset
-               nullptr);
-    if (req.result <= 0)
+    r = uv_fs_read(uv_default_loop(),
+                   &req,
+                   file,
+                   &buf,
+                   1,
+                   contents.length(),  // offset
+                   nullptr);
+    uv_fs_req_cleanup(&req);
+
+    if (r <= 0)
       break;
-    contents.append(buf.base, req.result);
+    contents.append(buf.base, r);
   } while (true);
   return contents;
 }
@@ -337,20 +341,29 @@ Maybe<uv_file> CheckFile(const URL& search,
   if (path.empty()) {
     return Nothing<uv_file>();
   }
-  uv_fs_open(nullptr, &fs_req, path.c_str(), O_RDONLY, 0, nullptr);
-  uv_file fd = fs_req.result;
+
+  uv_file fd = uv_fs_open(nullptr, &fs_req, path.c_str(), O_RDONLY, 0, nullptr);
+  uv_fs_req_cleanup(&fs_req);
+
   if (fd < 0) {
     return Nothing<uv_file>();
   }
 
   uv_fs_fstat(nullptr, &fs_req, fd, nullptr);
-  if (fs_req.statbuf.st_mode & S_IFDIR) {
+  uint64_t is_directory = fs_req.statbuf.st_mode & S_IFDIR;
+  uv_fs_req_cleanup(&fs_req);
+
+  if (is_directory) {
     uv_fs_close(nullptr, &fs_req, fd, nullptr);
+    uv_fs_req_cleanup(&fs_req);
     return Nothing<uv_file>();
   }
 
-  if (opt == CLOSE_AFTER_CHECK)
+  if (opt == CLOSE_AFTER_CHECK) {
     uv_fs_close(nullptr, &fs_req, fd, nullptr);
+    uv_fs_req_cleanup(&fs_req);
+  }
+
   return Just(fd);
 }
 
@@ -395,6 +408,7 @@ Maybe<URL> ResolveMain(Environment* env, const URL& search) {
   std::string pkg_src = ReadFile(check.FromJust());
   uv_fs_t fs_req;
   uv_fs_close(nullptr, &fs_req, check.FromJust(), nullptr);
+  uv_fs_req_cleanup(&fs_req);
 
   // It's not okay for the called of this method to not be able to tell
   // whether an exception is pending or not.

diff --git a/src/node_contextify.cc b/src/node_contextify.cc
@@ -139,7 +139,6 @@ class ContextifyContext {
     EscapableHandleScope scope(env->isolate());
     Local<FunctionTemplate> function_template =
         FunctionTemplate::New(env->isolate());
-    function_template->SetHiddenPrototype(true);
 
     function_template->SetClassName(sandbox_obj->GetConstructorName());
 

diff --git a/src/node_zlib.cc b/src/node_zlib.cc
@@ -461,6 +461,16 @@ class ZCtx : public AsyncWrap {
 
   // just pull the ints out of the args and call the other Init
   static void Init(const FunctionCallbackInfo<Value>& args) {
+    // Refs: https://github.com/nodejs/node/issues/16649
+    // Refs: https://github.com/nodejs/node/issues/14161
+    if (args.Length() == 5) {
+      fprintf(stderr,
+          "WARNING: You are likely using a version of node-tar or npm that "
+          "is incompatible with this version of Node.js.\nPlease use "
+          "either the version of npm that is bundled with Node.js, or "
+          "a version of npm (> 5.5.1 or < 5.4.0) or node-tar (> 4.0.1) "
+          "that is compatible with Node.js 9 and above.\n");
+    }
     CHECK(args.Length() == 7 &&
       "init(windowBits, level, memLevel, strategy, writeResult, writeCallback,"
       " dictionary)");

diff --git a/test/abort/test-zlib-invalid-internals-usage.js b/test/abort/test-zlib-invalid-internals-usage.js
@@ -0,0 +1,20 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const os = require('os');
+const cp = require('child_process');
+
+if (process.argv[2] === 'child') {
+  // This is the heart of the test.
+  new (process.binding('zlib').Zlib)(0).init(1, 2, 3, 4, 5);
+} else {
+  const child = cp.spawnSync(`${process.execPath}`, [`${__filename}`, 'child']);
+
+  assert.strictEqual(child.stdout.toString(), '');
+  assert.ok(child.stderr.includes(
+    'WARNING: You are likely using a version of node-tar or npm that ' +
+    'is incompatible with this version of Node.js.' + os.EOL +
+    'Please use either the version of npm that is bundled with Node.js, or ' +
+    'a version of npm (> 5.5.1 or < 5.4.0) or node-tar (> 4.0.1) that is ' +
+    'compatible with Node.js 9 and above.' + os.EOL));
+}
diff --git a/...l/test-cluster-disconnect-suicide-race.js → ...-disconnect-exitedAfterDisconnect-race.js b/...l/test-cluster-disconnect-suicide-race.js → ...-disconnect-exitedAfterDisconnect-race.js
@@ -1,8 +1,9 @@
 'use strict';
 
+const common = require('../common');
+
 // Test should fail in Node.js 5.4.1 and pass in later versions.
 
-const common = require('../common');
 const assert = require('assert');
 const cluster = require('cluster');
 
@@ -19,7 +20,7 @@ let eventFired = false;
 cluster.worker.disconnect();
 
 process.nextTick(common.mustCall(() => {
-  assert.strictEqual(eventFired, false, 'disconnect event should wait for ack');
+  assert.ok(!eventFired, 'disconnect event should wait for ack');
 }));
 
 cluster.worker.on('disconnect', common.mustCall(() => {

diff --git a/test/parallel/test-fs-realpath-buffer-encoding.js b/test/parallel/test-fs-realpath-buffer-encoding.js
@@ -1,9 +1,10 @@
 'use strict';
 const common = require('../common');
+const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const fs = require('fs');
 
-const string_dir = fs.realpathSync(common.fixturesDir);
+const string_dir = fs.realpathSync(fixtures.fixturesDir);
 const buffer_dir = Buffer.from(string_dir);
 
 const encodings = ['ascii', 'utf8', 'utf16le', 'ucs2',

diff --git a/test/parallel/test-http-mutable-headers.js b/test/parallel/test-http-mutable-headers.js
@@ -61,9 +61,9 @@ const s = http.createServer(common.mustCall((req, res) => {
       common.expectsError(
         () => res.setHeader('someHeader'),
         {
-          code: 'ERR_MISSING_ARGS',
+          code: 'ERR_HTTP_INVALID_HEADER_VALUE',
           type: TypeError,
-          message: 'The "value" argument must be specified'
+          message: 'Invalid value "undefined" for header "someHeader"'
         }
       );
       common.expectsError(

diff --git a/test/parallel/test-http-outgoing-proto.js b/test/parallel/test-http-outgoing-proto.js
@@ -34,9 +34,9 @@ assert.throws(() => {
   const outgoingMessage = new OutgoingMessage();
   outgoingMessage.setHeader('test');
 }, common.expectsError({
-  code: 'ERR_MISSING_ARGS',
+  code: 'ERR_HTTP_INVALID_HEADER_VALUE',
   type: TypeError,
-  message: 'The "value" argument must be specified'
+  message: 'Invalid value "undefined" for header "test"'
 }));
 
 assert.throws(() => {

diff --git a/test/parallel/test-http-write-head.js b/test/parallel/test-http-write-head.js
@@ -44,9 +44,9 @@ const s = http.createServer(common.mustCall((req, res) => {
   common.expectsError(
     () => res.setHeader('foo', undefined),
     {
-      code: 'ERR_MISSING_ARGS',
+      code: 'ERR_HTTP_INVALID_HEADER_VALUE',
       type: TypeError,
-      message: 'The "value" argument must be specified'
+      message: 'Invalid value "undefined" for header "foo"'
     }
   );
 

diff --git a/test/parallel/test-http2-client-upload.js b/test/parallel/test-http2-client-upload.js
@@ -8,9 +8,9 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const http2 = require('http2');
 const fs = require('fs');
-const path = require('path');
+const fixtures = require('../common/fixtures');
 
-const loc = path.join(common.fixturesDir, 'person.jpg');
+const loc = fixtures.path('person.jpg');
 let fileData;
 
 assert(fs.existsSync(loc));

diff --git a/test/parallel/test-http2-compat-serverresponse-headers.js b/test/parallel/test-http2-compat-serverresponse-headers.js
@@ -85,14 +85,14 @@ server.listen(0, common.mustCall(function() {
     }, common.expectsError({
       code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
       type: TypeError,
-      message: 'Value must not be undefined or null'
+      message: 'Invalid value "null" for header "foo-bar"'
     }));
     assert.throws(function() {
       response.setHeader(real, undefined);
     }, common.expectsError({
       code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
       type: TypeError,
-      message: 'Value must not be undefined or null'
+      message: 'Invalid value "undefined" for header "foo-bar"'
     }));
     common.expectsError(
       () => response.setHeader(), // header name undefined

diff --git a/test/parallel/test-http2-compat-serverresponse-trailers.js b/test/parallel/test-http2-compat-serverresponse-trailers.js
@@ -28,15 +28,15 @@ server.listen(0, common.mustCall(() => {
       {
         code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
         type: TypeError,
-        message: 'Value must not be undefined or null'
+        message: 'Invalid value "undefined" for header "test"'
       }
     );
     common.expectsError(
       () => response.setTrailer('test', null),
       {
         code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
         type: TypeError,
-        message: 'Value must not be undefined or null'
+        message: 'Invalid value "null" for header "test"'
       }
     );
     common.expectsError(