From 960252f6895eaa3719569caa74956088b0b7e0d9 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 8 Jul 2020 11:18:25 -0700
Subject: [PATCH 1/3] quic: use less specific error codes

Stop the madness. Only you can prevent excessive error code
proliferation.
---
 doc/api/errors.md                             | 131 +++------------
 doc/api/quic.md                               |   2 +-
 lib/internal/errors.js                        |  50 +-----
 lib/internal/quic/core.js                     | 158 ++++++++++--------
 lib/internal/quic/util.js                     |  18 +-
 test/parallel/test-quic-client-server.js      |  14 +-
 ...test-quic-errors-quicsession-openstream.js |   2 +-
 .../test-quic-errors-quicsocket-connect.js    |   2 +-
 .../test-quic-errors-quicsocket-listen.js     |   4 +-
 test/parallel/test-quic-ipv6only.js           |   2 +-
 ...t-quic-quicsession-server-destroy-early.js |   5 +-
 test/parallel/test-quic-quicsocket-close.js   |   3 +-
 test/parallel/test-quic-quicsocket.js         |   7 +-
 13 files changed, 138 insertions(+), 260 deletions(-)

diff --git a/doc/api/errors.md b/doc/api/errors.md
index 92715e1236bb96..d7254956feebe4 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1440,6 +1440,16 @@ type for one of its returned object properties on execution.
 Thrown in case a function option does not return an expected value
 type on execution, such as when a function is expected to return a promise.
 
+<a id="ERR_INVALID_STATE"></a>
+### `ERR_INVALID_STATE`
+<!-- YAML
+added: REPLACEME
+-->
+
+Indicates that an operation cannot be completed due to an invalid state.
+For instance, an object may have already been destroyed, or may be
+performing another operation.
+
 <a id="ERR_INVALID_SYNC_FORK_INPUT"></a>
 ### `ERR_INVALID_SYNC_FORK_INPUT`
 
@@ -1732,62 +1742,6 @@ Accessing `Object.prototype.__proto__` has been forbidden using
 [`Object.setPrototypeOf`][] should be used to get and set the prototype of an
 object.
 
-<a id="ERR_QUIC_CANNOT_SET_GROUPS"></a>
-### `ERR_QUIC_CANNOT_SET_GROUPS`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUIC_ERROR"></a>
-### `ERR_QUIC_ERROR`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUIC_TLS13_REQUIRED"></a>
-### `ERR_QUIC_TLS13_REQUIRED`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICCLIENTSESSION_FAILED"></a>
-### `ERR_QUICCLIENTSESSION_FAILED`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICCLIENTSESSION_FAILED_SETSOCKET"></a>
-### `ERR_QUICCLIENTSESSION_FAILED_SETSOCKET`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSESSION_DESTROYED"></a>
-### `ERR_QUICSESSION_DESTROYED`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSESSION_INVALID_DCID"></a>
-### `ERR_QUICSESSION_INVALID_DCID`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSESSION_UPDATEKEY"></a>
-### `ERR_QUICSESSION_UPDATEKEY`
-
-> Stability: 1 - Experimental
-
-TBD
-
 <a id="ERR_QUICSESSION_VERSION_NEGOTIATION"></a>
 ### `ERR_QUICSESSION_VERSION_NEGOTIATION`
 
@@ -1795,62 +1749,6 @@ TBD
 
 TBD
 
-<a id="ERR_QUICSOCKET_DESTROYED"></a>
-### `ERR_QUICSOCKET_DESTROYED`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSOCKET_INVALID_STATELESS_RESET_SECRET_LENGTH"></a>
-### `ERR_QUICSOCKET_INVALID_STATELESS_RESET_SECRET_LENGTH`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSOCKET_LISTENING"></a>
-### `ERR_QUICSOCKET_LISTENING`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSOCKET_UNBOUND"></a>
-### `ERR_QUICSOCKET_UNBOUND`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSTREAM_DESTROYED"></a>
-### `ERR_QUICSTREAM_DESTROYED`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSTREAM_INVALID_PUSH"></a>
-### `ERR_QUICSTREAM_INVALID_PUSH`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSTREAM_OPEN_FAILED"></a>
-### `ERR_QUICSTREAM_OPEN_FAILED`
-
-> Stability: 1 - Experimental
-
-TBD
-
-<a id="ERR_QUICSTREAM_UNSUPPORTED_PUSH"></a>
-### `ERR_QUICSTREAM_UNSUPPORTED_PUSH`
-
-> Stability: 1 - Experimental
-
-TBD
-
 <a id="ERR_REQUIRE_ESM"></a>
 ### `ERR_REQUIRE_ESM`
 
@@ -2482,6 +2380,15 @@ Used by the `N-API` when `Constructor.prototype` is not an object.
 A Node.js API was called in an unsupported manner, such as
 `Buffer.write(string, encoding, offset[, length])`.
 
+<a id="ERR_OPERATION_FAILED"></a>
+### `ERR_OPERATION_FAILED`
+<!-- YAML
+added: REPLACEME
+-->
+
+An operation failed. This is typically used to signal the general failure
+of an asynchronous operation.
+
 <a id="ERR_OUTOFMEMORY"></a>
 ### `ERR_OUTOFMEMORY`
 <!-- YAML
diff --git a/doc/api/quic.md b/doc/api/quic.md
index 6143d3995cfaa8..cc4ddd253d9d93 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -1250,7 +1250,7 @@ Migrates the `QuicClientSession` to the given `QuicSocket` instance. If the new
 `QuicSocket` has not yet been bound to a local UDP port, it will be bound prior
 to attempting the migration. If the `QuicClientSession` is not yet ready to
 migrate, the callback will be invoked with an `Error` using the code
-`ERR_QUICCLIENTSESSION_FAILED_SETSOCKET`.
+`ERR_OPERATION_FAILED`.
 
 ### Class: QuicServerSession extends QuicSession
 <!-- YAML
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index bda1f3f47112ad..587e48c3c202f7 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -1192,6 +1192,7 @@ E('ERR_INVALID_RETURN_VALUE', (input, name, value) => {
   return `Expected ${input} to be returned from the "${name}"` +
          ` function but got ${type}.`;
 }, TypeError);
+E('ERR_INVALID_STATE', 'Invalid state: %s', Error);
 E('ERR_INVALID_SYNC_FORK_INPUT',
   'Asynchronous forks do not support ' +
     'Buffer, TypedArray, DataView or string input: %s',
@@ -1287,6 +1288,7 @@ E('ERR_NO_CRYPTO',
   'Node.js is not compiled with OpenSSL crypto support', Error);
 E('ERR_NO_ICU',
   '%s is not supported on Node.js compiled without ICU', TypeError);
+E('ERR_OPERATION_FAILED', 'Operation failed: %s', Error);
 E('ERR_OUT_OF_RANGE',
   (str, range, input, replaceDefaultBoolean = false) => {
     assert(range, 'Missing "range" argument');
@@ -1317,14 +1319,6 @@ E('ERR_PACKAGE_PATH_NOT_EXPORTED', (pkgPath, subpath, base = undefined) => {
   return `Package subpath '${subpath}' is not defined by "exports" in ${
     pkgPath} imported from ${base}`;
 }, Error);
-E('ERR_QUICCLIENTSESSION_FAILED',
-  'Failed to create a new QuicClientSession: %s', Error);
-E('ERR_QUICCLIENTSESSION_FAILED_SETSOCKET',
-  'Failed to set the QuicSocket', Error);
-E('ERR_QUICSESSION_DESTROYED',
-  'Cannot call %s after a QuicSession has been destroyed', Error);
-E('ERR_QUICSESSION_INVALID_DCID', 'Invalid DCID value: %s', Error);
-E('ERR_QUICSESSION_UPDATEKEY', 'Unable to update QuicSession keys', Error);
 E('ERR_QUICSESSION_VERSION_NEGOTIATION',
   (version, requestedVersions, supportedVersions) => {
     return 'QUIC session received version negotiation from server. ' +
@@ -1332,46 +1326,6 @@ E('ERR_QUICSESSION_VERSION_NEGOTIATION',
       `Supported: ${supportedVersions.join(', ')}`;
   },
   Error);
-E('ERR_QUICSOCKET_DESTROYED',
-  'Cannot call %s after a QuicSocket has been destroyed', Error);
-E('ERR_QUICSOCKET_INVALID_STATELESS_RESET_SECRET_LENGTH',
-  'The stateResetToken must be exactly 16-bytes in length',
-  Error);
-E('ERR_QUICSOCKET_LISTENING',
-  'This QuicSocket is already listening', Error);
-E('ERR_QUICSOCKET_UNBOUND',
-  'Cannot call %s before a QuicSocket has been bound', Error);
-E('ERR_QUICSTREAM_DESTROYED',
-  'Cannot call %s after a QuicStream has been destroyed', Error);
-E('ERR_QUICSTREAM_INVALID_PUSH',
-  'Push streams are only supported on client-initiated, bidirectional streams',
-  Error);
-E('ERR_QUICSTREAM_OPEN_FAILED', 'Opening a new QuicStream failed', Error);
-E('ERR_QUICSTREAM_UNSUPPORTED_PUSH',
-  'Push streams are not supported on this QuicSession', Error);
-E('ERR_QUIC_ERROR', function(code, family) {
-  const {
-    constants: {
-      QUIC_ERROR_APPLICATION,
-      QUIC_ERROR_CRYPTO,
-      QUIC_ERROR_SESSION,
-    }
-  } = internalBinding('quic');
-  let familyType = 'unknown';
-  switch (family) {
-    case QUIC_ERROR_APPLICATION:
-      familyType = 'application';
-      break;
-    case QUIC_ERROR_CRYPTO:
-      familyType = 'crypto';
-      break;
-    case QUIC_ERROR_SESSION:
-      familyType = 'session';
-      break;
-  }
-  return `QUIC session closed with ${familyType} error code ${code}`;
-}, Error);
-E('ERR_QUIC_TLS13_REQUIRED', 'QUIC requires TLS version 1.3', Error);
 E('ERR_REQUIRE_ESM',
   (filename, parentPath = null, packageJsonPath = null) => {
     let msg = `Must use import to load ES Module: ${filename}`;
diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index 9b3d0f85da4817..cca9c6f64a499e 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -99,17 +99,9 @@ const {
   codes: {
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_CALLBACK,
-    ERR_QUICSESSION_DESTROYED,
+    ERR_INVALID_STATE,
+    ERR_OPERATION_FAILED,
     ERR_QUICSESSION_VERSION_NEGOTIATION,
-    ERR_QUICSOCKET_DESTROYED,
-    ERR_QUICSOCKET_LISTENING,
-    ERR_QUICCLIENTSESSION_FAILED,
-    ERR_QUICCLIENTSESSION_FAILED_SETSOCKET,
-    ERR_QUICSESSION_UPDATEKEY,
-    ERR_QUICSTREAM_DESTROYED,
-    ERR_QUICSTREAM_INVALID_PUSH,
-    ERR_QUICSTREAM_UNSUPPORTED_PUSH,
-    ERR_QUICSTREAM_OPEN_FAILED,
     ERR_TLS_DH_PARAM_SIZE,
   },
   errnoException,
@@ -761,79 +753,79 @@ class QuicEndpoint {
 
   setTTL(ttl) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('setTTL');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicEndpoint is already destroyed');
     state.udpSocket.setTTL(ttl);
     return this;
   }
 
   setMulticastTTL(ttl) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('setMulticastTTL');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicEndpoint is already destroyed');
     state.udpSocket.setMulticastTTL(ttl);
     return this;
   }
 
   setBroadcast(on = true) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('setBroadcast');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicEndpoint is already destroyed');
     state.udpSocket.setBroadcast(on);
     return this;
   }
 
   setMulticastLoopback(on = true) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('setMulticastLoopback');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicEndpoint is already destroyed');
     state.udpSocket.setMulticastLoopback(on);
     return this;
   }
 
   setMulticastInterface(iface) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('setMulticastInterface');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicEndpoint is already destroyed');
     state.udpSocket.setMulticastInterface(iface);
     return this;
   }
 
   addMembership(address, iface) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('addMembership');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicEndpoint is already destroyed');
     state.udpSocket.addMembership(address, iface);
     return this;
   }
 
   dropMembership(address, iface) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('dropMembership');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicEndpoint is already destroyed');
     state.udpSocket.dropMembership(address, iface);
     return this;
   }
 
   ref() {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('ref');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicEndpoint is already destroyed');
     state.udpSocket.ref();
     return this;
   }
 
   unref() {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('unref');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicEndpoint is already destroyed');
     state.udpSocket.unref();
     return this;
   }
 
   destroy(error) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
+    if (this.destroyed)
       return;
     state.state = kSocketDestroyed;
     this[kDestroy](error);
@@ -1095,8 +1087,8 @@ class QuicSocket extends EventEmitter {
 
   addEndpoint(options = {}) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('listen');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicSocket is already destroyed');
 
     // TODO(@jasnell): Also forbid adding an endpoint if
     // the QuicSocket is closing.
@@ -1224,12 +1216,12 @@ class QuicSocket extends EventEmitter {
   // function.
   listen(options, callback) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed ||
-        state.state === kSocketClosing) {
-      throw new ERR_QUICSOCKET_DESTROYED('listen');
-    }
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicSocket is already destroyed');
+    if (this.closing)
+      throw new ERR_INVALID_STATE('QuicSocket is closing');
     if (this.listening || state.listenPending)
-      throw new ERR_QUICSOCKET_LISTENING();
+      throw new ERR_INVALID_STATE('QuicSocket is already listening');
     if (typeof options === 'function') {
       callback = options;
       options = {};
@@ -1300,8 +1292,10 @@ class QuicSocket extends EventEmitter {
   // Creates and returns a new QuicClientSession.
   connect(options, callback) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed || state.state === kSocketClosing)
-      throw new ERR_QUICSOCKET_DESTROYED('connect');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicSocket is already destroyed');
+    if (this.closing)
+      throw new ERR_INVALID_STATE('QuicSocket is closing');
 
     if (typeof options === 'function') {
       callback = options;
@@ -1364,8 +1358,8 @@ class QuicSocket extends EventEmitter {
   // immediately.
   close(callback) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('close');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicSocket is already destroyed');
 
     // If a callback function is specified, it is registered as a
     // handler for the once('close') event. If the close occurs
@@ -1452,8 +1446,8 @@ class QuicSocket extends EventEmitter {
 
   ref() {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('ref');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicSocket is already destroyed');
     for (const endpoint of state.endpoints)
       endpoint.ref();
     return this;
@@ -1461,8 +1455,8 @@ class QuicSocket extends EventEmitter {
 
   unref() {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('unref');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicSocket is already destroyed');
     for (const endpoint of state.endpoints)
       endpoint.unref();
     return this;
@@ -1510,8 +1504,8 @@ class QuicSocket extends EventEmitter {
   // connection attempts to fail with a SERVER_BUSY CONNECTION_CLOSE.
   set serverBusy(on) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('serverBusy');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicSocket is already destroyed');
     validateBoolean(on, 'on');
     if (state.sharedState.serverBusy !== on) {
       state.sharedState.serverBusy = on;
@@ -1525,8 +1519,8 @@ class QuicSocket extends EventEmitter {
 
   set statelessResetDisabled(on) {
     const state = this[kInternalState];
-    if (state.state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('statelessResetDisabled');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicSocket is already destroyed');
     validateBoolean(on, 'on');
     if (state.sharedState.statelessResetDisabled !== on)
       state.sharedState.statelessResetDisabled = on;
@@ -1598,8 +1592,8 @@ class QuicSocket extends EventEmitter {
   // option is a number between 0 and 1 that identifies the possibility of
   // packet loss in the given direction.
   setDiagnosticPacketLoss(options) {
-    if (this[kInternalState].state === kSocketDestroyed)
-      throw new ERR_QUICSOCKET_DESTROYED('setDiagnosticPacketLoss');
+    if (this.destroyed)
+      throw new ERR_INVALID_STATE('QuicSocket is already destroyed');
     const {
       rx = 0.0,
       tx = 0.0
@@ -1864,8 +1858,10 @@ class QuicSession extends EventEmitter {
   // fail, and new streams from the peer will be rejected/ignored.
   close(callback) {
     const state = this[kInternalState];
-    if (state.destroyed)
-      throw new ERR_QUICSESSION_DESTROYED('close');
+    if (state.destroyed) {
+      throw new ERR_INVALID_STATE(
+        `${this.constructor.name} is already destroyed`);
+    }
 
     if (callback) {
       if (typeof callback !== 'function')
@@ -2048,8 +2044,10 @@ class QuicSession extends EventEmitter {
   }
 
   ping() {
-    if (!this[kHandle])
-      throw new ERR_QUICSESSION_DESTROYED('ping');
+    if (this.destroyed) {
+      throw new ERR_INVALID_STATE(
+        `${this.constructor.name} is already destroyed`);
+    }
     this[kHandle].ping();
   }
 
@@ -2084,8 +2082,14 @@ class QuicSession extends EventEmitter {
 
   openStream(options) {
     const state = this[kInternalState];
-    if (state.destroyed || state.closing)
-      throw new ERR_QUICSESSION_DESTROYED('openStream');
+    if (state.destroyed) {
+      throw new ERR_INVALID_STATE(
+        `${this.constructor.name} is already destroyed`);
+    }
+    if (state.closing) {
+      throw new ERR_INVALID_STATE(
+        `${this.constructor.name} is closing`);
+    }
     const {
       halfOpen,  // Unidirectional or Bidirectional
       highWaterMark,
@@ -2134,7 +2138,7 @@ class QuicSession extends EventEmitter {
         _openBidirectionalStream(this[kHandle]);
 
     if (handle === undefined) {
-      stream.destroy(new ERR_QUICSTREAM_OPEN_FAILED());
+      stream.destroy(new ERR_OPERATION_FAILED('Unable to create QuicStream'));
       return;
     }
 
@@ -2210,10 +2214,16 @@ class QuicSession extends EventEmitter {
   updateKey() {
     const state = this[kInternalState];
     // Initiates a key update for the connection.
-    if (state.destroyed || state.closing)
-      throw new ERR_QUICSESSION_DESTROYED('updateKey');
+    if (state.destroyed) {
+      throw new ERR_INVALID_STATE(
+        `${this.constructor.name} is already destroyed`);
+    }
+    if (state.closing) {
+      throw new ERR_INVALID_STATE(
+        `${this.constructor.name} is closing`);
+    }
     if (!state.handshakeConfirmed)
-      throw new ERR_QUICSESSION_UPDATEKEY();
+      throw new ERR_INVALID_STATE('Handshake is not yet confirmed');
     return this[kHandle].updateKey();
   }
 
@@ -2451,7 +2461,7 @@ class QuicClientSession extends QuicSession {
         default:
           reason = `${handle}`;
       }
-      this.destroy(new ERR_QUICCLIENTSESSION_FAILED(reason));
+      this.destroy(new ERR_OPERATION_FAILED(reason));
       return;
     }
 
@@ -2501,8 +2511,10 @@ class QuicClientSession extends QuicSession {
 
   startHandshake() {
     const state = this[kInternalClientState];
-    if (this.destroyed)
-      throw new ERR_QUICSESSION_DESTROYED('startHandshake');
+    if (this.destroyed) {
+      throw new ERR_INVALID_STATE(
+        `${this.constructor.name} is already destroyed`);
+    }
     if (state.handshakeStarted)
       return;
     state.handshakeStarted = true;
@@ -2521,12 +2533,12 @@ class QuicClientSession extends QuicSession {
 
   [kSetSocketAfterBind](socket, callback) {
     if (socket.destroyed) {
-      callback(new ERR_QUICSOCKET_DESTROYED('setSocket'));
+      callback(new ERR_INVALID_STATE('QuicSocket is already destroyed'));
       return;
     }
 
     if (!this[kHandle].setSocket(socket[kHandle])) {
-      callback(new ERR_QUICCLIENTSESSION_FAILED_SETSOCKET());
+      callback(new ERR_OPERATION_FAILED('Could not set the QuicSocket'));
       return;
     }
 
@@ -2982,7 +2994,7 @@ class QuicStream extends Duplex {
 
   pushStream(headers = {}, options = {}) {
     if (this.destroyed)
-      throw new ERR_QUICSTREAM_DESTROYED('push');
+      throw new ERR_INVALID_STATE('QuicStream is already destroyed');
 
     const state = this[kInternalState];
     const {
@@ -2999,8 +3011,11 @@ class QuicStream extends Duplex {
     // QUIC application protocol that has a similar
     // notion of push streams without this restriction,
     // then we'll need to check alpn value here also.
-    if (!this.clientInitiated && !this.bidirectional)
-      throw new ERR_QUICSTREAM_INVALID_PUSH();
+    if (!this.clientInitiated && !this.bidirectional) {
+      throw new ERR_INVALID_STATE(
+        'Push streams are only supported on client-initiated, ' +
+        'bidirectional streams');
+    }
 
     // TODO(@jasnell): The assertValidPseudoHeader validator
     // here is HTTP/3 specific. If we end up with another
@@ -3015,8 +3030,11 @@ class QuicStream extends Duplex {
     // or push streams are currently disabled/blocked. This
     // will typically be the case with HTTP/3 when the client
     // peer has disabled push.
-    if (handle === undefined)
-      throw new ERR_QUICSTREAM_UNSUPPORTED_PUSH();
+    if (handle === undefined) {
+      throw new ERR_INVALID_STATE(
+        'Push stream could not be opened on this QuicSession. ' +
+        'Push is either disabled or currently blocked.');
+    }
 
     const stream = new QuicStream({
       readable: false,
diff --git a/lib/internal/quic/util.js b/lib/internal/quic/util.js
index aff4f3cbc86afb..31087ef96e5000 100644
--- a/lib/internal/quic/util.js
+++ b/lib/internal/quic/util.js
@@ -12,8 +12,6 @@ const {
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_ARG_VALUE,
     ERR_OUT_OF_RANGE,
-    ERR_QUICSESSION_INVALID_DCID,
-    ERR_QUICSOCKET_INVALID_STATELESS_RESET_SECRET_LENGTH,
   },
 } = require('internal/errors');
 
@@ -409,7 +407,10 @@ function validateQuicClientSessionOptions(options = {}) {
       try {
         dcid = Buffer.from(dcid_value, 'hex');
       } catch {
-        throw new ERR_QUICSESSION_INVALID_DCID(dcid);
+        throw new ERR_INVALID_ARG_VALUE(
+          'options.dcid',
+          dcid,
+          'is not a valid QUIC connection ID');
       }
     }
 
@@ -420,7 +421,11 @@ function validateQuicClientSessionOptions(options = {}) {
 
     if (dcid_value.length > NGTCP2_MAX_CIDLEN ||
         dcid_value.length < NGTCP2_MIN_CIDLEN) {
-      throw new ERR_QUICSESSION_INVALID_DCID(dcid_value.toString('hex'));
+      throw new ERR_INVALID_ARG_VALUE(
+        'options.dcid',
+        dcid_value.toString('hex'),
+        'is not a valid QUIC connection ID'
+      );
     }
 
     dcid = dcid_value;
@@ -575,7 +580,10 @@ function validateQuicSocketOptions(options = {}) {
   if (statelessResetSecret !== undefined) {
     validateBuffer(statelessResetSecret, 'options.statelessResetSecret');
     if (statelessResetSecret.length !== 16)
-      throw new ERR_QUICSOCKET_INVALID_STATELESS_RESET_SECRET_LENGTH();
+      throw new ERR_INVALID_ARG_VALUE(
+        'options.statelessResetSecret',
+        statelessResetSecret,
+        'must be exactly 16 bytes in length');
   }
 
   return {
diff --git a/test/parallel/test-quic-client-server.js b/test/parallel/test-quic-client-server.js
index 82d55410c0f4cf..a78c7d7157d9a9 100644
--- a/test/parallel/test-quic-client-server.js
+++ b/test/parallel/test-quic-client-server.js
@@ -200,18 +200,12 @@ server.on('session', common.mustCall((session) => {
     assert.strictEqual(code, NGTCP2_NO_ERROR);
 
     const err = {
-      code: 'ERR_QUICSESSION_DESTROYED',
+      code: 'ERR_INVALID_STATE',
       name: 'Error'
     };
-    assert.throws(() => session.ping(), { ...err });
-    assert.throws(() => session.openStream(), {
-      ...err,
-      message: 'Cannot call openStream after a QuicSession has been destroyed'
-    });
-    assert.throws(() => session.updateKey(), {
-      ...err,
-      message: 'Cannot call updateKey after a QuicSession has been destroyed'
-    });
+    assert.throws(() => session.ping(), err);
+    assert.throws(() => session.openStream(), err);
+    assert.throws(() => session.updateKey(), err);
   }));
 }));
 
diff --git a/test/parallel/test-quic-errors-quicsession-openstream.js b/test/parallel/test-quic-errors-quicsession-openstream.js
index ef06ee364c17da..7492947e526e11 100644
--- a/test/parallel/test-quic-errors-quicsession-openstream.js
+++ b/test/parallel/test-quic-errors-quicsession-openstream.js
@@ -77,7 +77,7 @@ server.on('ready', common.mustCall(() => {
     highWaterMark: 10,
     defaultEncoding: 'utf16le'
   }).on('error', common.expectsError({
-    code: 'ERR_QUICSTREAM_OPEN_FAILED'
+    code: 'ERR_OPERATION_FAILED'
   })).on('error', common.mustCall(() => countdown.dec()));
 }));
 
diff --git a/test/parallel/test-quic-errors-quicsocket-connect.js b/test/parallel/test-quic-errors-quicsocket-connect.js
index cec0fb4563cbdc..7b545a4ad40a41 100644
--- a/test/parallel/test-quic-errors-quicsocket-connect.js
+++ b/test/parallel/test-quic-errors-quicsocket-connect.js
@@ -194,7 +194,7 @@ const client = createQuicSocket();
 // Test that connect cannot be called after QuicSocket is closed.
 client.close();
 assert.throws(() => client.connect(), {
-  code: 'ERR_QUICSOCKET_DESTROYED'
+  code: 'ERR_INVALID_STATE'
 });
 
 // TODO(@jasnell): Test additional options:
diff --git a/test/parallel/test-quic-errors-quicsocket-listen.js b/test/parallel/test-quic-errors-quicsocket-listen.js
index c3caa0a6bca9ec..97eb357bbc6f43 100644
--- a/test/parallel/test-quic-errors-quicsocket-listen.js
+++ b/test/parallel/test-quic-errors-quicsocket-listen.js
@@ -26,7 +26,7 @@ const { createQuicSocket } = require('net');
   const server = createQuicSocket();
   server.listen();
   assert.throws(() => server.listen(), {
-    code: 'ERR_QUICSOCKET_LISTENING'
+    code: 'ERR_INVALID_STATE'
   });
   server.close();
 }
@@ -36,7 +36,7 @@ const { createQuicSocket } = require('net');
   const server = createQuicSocket();
   server.close();
   assert.throws(() => server.listen(), {
-    code: 'ERR_QUICSOCKET_DESTROYED'
+    code: 'ERR_INVALID_STATE'
   });
 }
 
diff --git a/test/parallel/test-quic-ipv6only.js b/test/parallel/test-quic-ipv6only.js
index 4165ac3e809676..4c6695804e3231 100644
--- a/test/parallel/test-quic-ipv6only.js
+++ b/test/parallel/test-quic-ipv6only.js
@@ -130,7 +130,7 @@ async function mismatch() {
   });
 
   session.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.code, 'ERR_QUICCLIENTSESSION_FAILED');
+    assert.strictEqual(err.code, 'ERR_OPERATION_FAILED');
     client.close();
     server.close();
   }));
diff --git a/test/parallel/test-quic-quicsession-server-destroy-early.js b/test/parallel/test-quic-quicsession-server-destroy-early.js
index 1471790a27de9e..67907166b6a32e 100644
--- a/test/parallel/test-quic-quicsession-server-destroy-early.js
+++ b/test/parallel/test-quic-quicsession-server-destroy-early.js
@@ -44,9 +44,8 @@ server.on('session', common.mustCall((session) => {
     server.close();
 
     assert.throws(() => server.close(), {
-      code: 'ERR_QUICSOCKET_DESTROYED',
-      name: 'Error',
-      message: 'Cannot call close after a QuicSocket has been destroyed'
+      code: 'ERR_INVALID_STATE',
+      name: 'Error'
     });
   }));
   session.on('stream', common.mustNotCall());
diff --git a/test/parallel/test-quic-quicsocket-close.js b/test/parallel/test-quic-quicsocket-close.js
index a0bca264ba7d90..d3cd1ba6b46277 100644
--- a/test/parallel/test-quic-quicsocket-close.js
+++ b/test/parallel/test-quic-quicsocket-close.js
@@ -13,7 +13,6 @@ const { createQuicSocket } = require('net');
   socket.close(common.mustCall());
   socket.on('close', common.mustCall());
   assert.throws(() => socket.close(), {
-    code: 'ERR_QUICSOCKET_DESTROYED',
-    message: 'Cannot call close after a QuicSocket has been destroyed'
+    code: 'ERR_INVALID_STATE'
   });
 }
diff --git a/test/parallel/test-quic-quicsocket.js b/test/parallel/test-quic-quicsocket.js
index efbce64f8fd4a1..2099f507e339e6 100644
--- a/test/parallel/test-quic-quicsocket.js
+++ b/test/parallel/test-quic-quicsocket.js
@@ -97,7 +97,7 @@ socket.on('ready', common.mustCall(() => {
 
   // QuicSocket is already listening.
   assert.throws(() => socket.listen(), {
-    code: 'ERR_QUICSOCKET_LISTENING'
+    code: 'ERR_INVALID_STATE'
   });
 
   assert.strictEqual(typeof endpoint.address.address, 'string');
@@ -138,12 +138,11 @@ socket.on('close', common.mustCall(() => {
     'dropMembership'
   ].forEach((op) => {
     assert.throws(() => endpoint[op](), {
-      code: 'ERR_QUICSOCKET_DESTROYED',
-      message: `Cannot call ${op} after a QuicSocket has been destroyed`
+      code: 'ERR_INVALID_STATE'
     });
   });
 
   assert.throws(() => { socket.serverBusy = true; }, {
-    code: 'ERR_QUICSOCKET_DESTROYED'
+    code: 'ERR_INVALID_STATE'
   });
 }));

From 01c68f3ea15ed3437f1990ca7feca9ba3daf5312 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 9 Jul 2020 10:34:50 -0700
Subject: [PATCH 2/3] quic: use Number instead of BigInt for more stats

---
 doc/api/quic.md                           | 102 ++++++++++------------
 lib/internal/quic/core.js                 |  57 ++++++------
 test/parallel/test-quic-client-server.js  |  16 ++--
 test/parallel/test-quic-statelessreset.js |   2 +-
 4 files changed, 84 insertions(+), 93 deletions(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index cc4ddd253d9d93..f6628bf9803fb1 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -667,10 +667,9 @@ The `'stream'` event may be emitted multiple times.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the number of retransmissions caused by delayed
-acknowledgements.
+The number of retransmissions caused by delayed acknowledgements.
 
 #### quicsession.address
 <!-- YAML
@@ -716,20 +715,19 @@ representing the reason the peer certificate verification failed.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the total number of bidirectional streams
-created for this `QuicSession`.
+The total number of bidirectional streams created for this `QuicSession`.
 
 #### quicsession.blockCount
 <!-- YAML
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the total number of times the `QuicSession` has
-been blocked from sending stream data due to flow control.
+The total number of times the `QuicSession` has been blocked from sending
+stream data due to flow control.
 
 Such blocks indicate that transmitted stream data is not being consumed
 quickly enough by the connected peer.
@@ -749,18 +747,18 @@ to the connected peer.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the total number of bytes received from the peer.
+The total number of bytes received from the peer.
 
 #### quicsession.bytesSent
 <!-- YAML
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the total number of bytes sent to the peer.
+The total number of bytes sent to the peer.
 
 #### quicsession.cipher
 <!-- YAML
@@ -831,9 +829,9 @@ Set to `true` if the `QuicSession` has been destroyed.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the length of time the `QuicSession` was active.
+The length of time the `QuicSession` was active.
 
 #### quicsession.getCertificate()
 <!-- YAML
@@ -902,9 +900,9 @@ Set to `true` when the TLS handshake completion has been confirmed.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the length of time taken to complete the TLS handshake.
+The length of time taken to complete the TLS handshake.
 
 #### quicsession.idleTimeout
 <!-- YAML
@@ -920,17 +918,16 @@ Set to `true` if the `QuicSession` was closed due to an idle timeout.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the number of key update operations that have
-occured.
+The number of key update operations that have occured.
 
 #### quicsession.latestRTT
 <!-- YAML
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
 The most recently recorded RTT for this `QuicSession`.
 
@@ -939,10 +936,10 @@ The most recently recorded RTT for this `QuicSession`.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the number of lost-packet retransmissions that have been
-performed on this `QuicSession`.
+The number of lost-packet retransmissions that have been performed on
+this `QuicSession`.
 
 #### quicsession.maxDataLeft
 <!-- YAML
@@ -959,10 +956,9 @@ send to the connected peer.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the maximum number of in-flight bytes recorded
-for this `QuicSession`.
+The maximum number of in-flight bytes recorded for this `QuicSession`.
 
 #### quicsession.maxStreams
 <!-- YAML
@@ -983,7 +979,7 @@ of the `QuicSession` as the connected peer allows new streams to be created.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
 The minimum RTT recorded so far for this `QuicSession`.
 
@@ -1025,10 +1021,9 @@ of the `ping()` operation.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the total number of `QuicStreams` initiated by the
-connected peer.
+The total number of `QuicStreams` initiated by the connected peer.
 
 #### quicsession.qlog
 <!-- YAML
@@ -1061,10 +1056,9 @@ An object containing the remote address information for the connected peer.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the total number of `QuicStream` instances initiated
-by this `QuicSession`.
+The total number of `QuicStream` instances initiated by this `QuicSession`.
 
 #### quicsession.servername
 <!-- YAML
@@ -1080,7 +1074,7 @@ The SNI servername requested for this session by the client.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
 The modified RTT calculated for this `QuicSession`.
 
@@ -1107,10 +1101,9 @@ True if the `QuicSession` was closed due to QUIC stateless reset.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the total number of unidirectional streams
-created on this `QuicSession`.
+The total number of unidirectional streams created on this `QuicSession`.
 
 #### quicsession.updateKey()
 <!-- YAML
@@ -2123,20 +2116,18 @@ Set to `true` if the `QuicStream` is bidirectional.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the total number of bytes received for this
-`QuicStream`.
+The total number of bytes received for this `QuicStream`.
 
 #### quicstream.bytesSent
 <!-- YAML
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the total number of bytes sent by this
-`QuicStream`.
+The total number of bytes sent by this `QuicStream`.
 
 #### quicstream.clientInitiated
 <!-- YAML
@@ -2182,19 +2173,18 @@ TBD
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the length of time the `QuicStream` has been active.
+The length of time the `QuicStream` has been active.
 
 #### quicstream.finalSize
 <!-- YAML
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` specifying the total number of bytes successfully received by the
-`QuicStream`.
+The total number of bytes successfully received by the `QuicStream`.
 
 #### quicstream.id
 <!-- YAML
@@ -2210,29 +2200,27 @@ The numeric identifier of the `QuicStream`.
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the highest acknowledged data offset received
-for this `QuicStream`.
+The highest acknowledged data offset received for this `QuicStream`.
 
 #### quicstream.maxExtendedOffset
 <!-- YAML
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the maximum extended data offset that has been
-reported to the connected peer.
+The maximum extended data offset that has been reported to the connected peer.
 
 #### quicstream.maxReceivedOffset
 <!-- YAML
 added: REPLACEME
 -->
 
-* Type: {bigint}
+* Type: {number}
 
-A `BigInt` representing the maximum received offset for this `QuicStream`.
+The maximum received offset for this `QuicStream`.
 
 #### quicstream.pending
 <!-- YAML
diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index cca9c6f64a499e..6f48ea3a6509d5 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -1967,15 +1967,16 @@ class QuicSession extends EventEmitter {
   }
 
   get maxDataLeft() {
-    return this[kHandle] ? this[kInternalState].state.maxDataLeft : 0;
+    return Number(this[kHandle] ? this[kInternalState].state.maxDataLeft : 0);
   }
 
   get bytesInFlight() {
-    return this[kHandle] ? this[kInternalState].state.bytesInFlight : 0;
+    return Number(this[kHandle] ? this[kInternalState].state.bytesInFlight : 0);
   }
 
   get blockCount() {
-    return this[kHandle]?.stats[IDX_QUIC_SESSION_STATS_BLOCK_COUNT] || 0;
+    return Number(
+      this[kHandle]?.stats[IDX_QUIC_SESSION_STATS_BLOCK_COUNT] || 0);
   }
 
   get authenticated() {
@@ -2147,8 +2148,8 @@ class QuicSession extends EventEmitter {
   }
 
   get duration() {
-    return process.hrtime.bigint() -
-      getStats(this, IDX_QUIC_SESSION_STATS_CREATED_AT);
+    return Number(process.hrtime.bigint() -
+      getStats(this, IDX_QUIC_SESSION_STATS_CREATED_AT));
   }
 
   get handshakeDuration() {
@@ -2156,59 +2157,61 @@ class QuicSession extends EventEmitter {
       this.handshakeComplete ?
         getStats(this, IDX_QUIC_SESSION_STATS_HANDSHAKE_COMPLETED_AT) :
         process.hrtime.bigint();
-    return end - getStats(this, IDX_QUIC_SESSION_STATS_HANDSHAKE_START_AT);
+    return Number(
+      end - getStats(this, IDX_QUIC_SESSION_STATS_HANDSHAKE_START_AT));
   }
 
   get bytesReceived() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_BYTES_RECEIVED);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_BYTES_RECEIVED));
   }
 
   get bytesSent() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_BYTES_SENT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_BYTES_SENT));
   }
 
   get bidiStreamCount() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_BIDI_STREAM_COUNT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_BIDI_STREAM_COUNT));
   }
 
   get uniStreamCount() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_UNI_STREAM_COUNT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_UNI_STREAM_COUNT));
   }
 
   get maxInFlightBytes() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_MAX_BYTES_IN_FLIGHT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_MAX_BYTES_IN_FLIGHT));
   }
 
   get lossRetransmitCount() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_LOSS_RETRANSMIT_COUNT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_LOSS_RETRANSMIT_COUNT));
   }
 
   get ackDelayRetransmitCount() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_ACK_DELAY_RETRANSMIT_COUNT);
+    return Number(
+      getStats(this, IDX_QUIC_SESSION_STATS_ACK_DELAY_RETRANSMIT_COUNT));
   }
 
   get peerInitiatedStreamCount() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_STREAMS_IN_COUNT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_STREAMS_IN_COUNT));
   }
 
   get selfInitiatedStreamCount() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_STREAMS_OUT_COUNT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_STREAMS_OUT_COUNT));
   }
 
   get keyUpdateCount() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_KEYUPDATE_COUNT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_KEYUPDATE_COUNT));
   }
 
   get minRTT() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_MIN_RTT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_MIN_RTT));
   }
 
   get latestRTT() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_LATEST_RTT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_LATEST_RTT));
   }
 
   get smoothedRTT() {
-    return getStats(this, IDX_QUIC_SESSION_STATS_SMOOTHED_RTT);
+    return Number(getStats(this, IDX_QUIC_SESSION_STATS_SMOOTHED_RTT));
   }
 
   updateKey() {
@@ -3136,32 +3139,32 @@ class QuicStream extends Duplex {
   }
 
   get duration() {
-    return process.hrtime.bigint() -
-      getStats(this, IDX_QUIC_STREAM_STATS_CREATED_AT);
+    return Number(process.hrtime.bigint() -
+      getStats(this, IDX_QUIC_STREAM_STATS_CREATED_AT));
   }
 
   get bytesReceived() {
-    return getStats(this, IDX_QUIC_STREAM_STATS_BYTES_RECEIVED);
+    return Number(getStats(this, IDX_QUIC_STREAM_STATS_BYTES_RECEIVED));
   }
 
   get bytesSent() {
-    return getStats(this, IDX_QUIC_STREAM_STATS_BYTES_SENT);
+    return Number(getStats(this, IDX_QUIC_STREAM_STATS_BYTES_SENT));
   }
 
   get maxExtendedOffset() {
-    return getStats(this, IDX_QUIC_STREAM_STATS_MAX_OFFSET);
+    return Number(getStats(this, IDX_QUIC_STREAM_STATS_MAX_OFFSET));
   }
 
   get finalSize() {
-    return getStats(this, IDX_QUIC_STREAM_STATS_FINAL_SIZE);
+    return Number(getStats(this, IDX_QUIC_STREAM_STATS_FINAL_SIZE));
   }
 
   get maxAcknowledgedOffset() {
-    return getStats(this, IDX_QUIC_STREAM_STATS_MAX_OFFSET_ACK);
+    return Number(getStats(this, IDX_QUIC_STREAM_STATS_MAX_OFFSET_ACK));
   }
 
   get maxReceivedOffset() {
-    return getStats(this, IDX_QUIC_STREAM_STATS_MAX_OFFSET_RECV);
+    return Number(getStats(this, IDX_QUIC_STREAM_STATS_MAX_OFFSET_RECV));
   }
 }
 
diff --git a/test/parallel/test-quic-client-server.js b/test/parallel/test-quic-client-server.js
index a78c7d7157d9a9..06b045cd783fa5 100644
--- a/test/parallel/test-quic-client-server.js
+++ b/test/parallel/test-quic-client-server.js
@@ -140,7 +140,7 @@ server.on('session', common.mustCall((session) => {
     uni.on('end', common.mustCall());
     uni.on('data', common.mustNotCall());
     uni.on('close', common.mustCall(() => {
-      assert.strictEqual(uni.finalSize, 0n);
+      assert.strictEqual(uni.finalSize, 0);
     }));
     debug('Unidirectional, Server-initiated stream %d opened', uni.id);
   }));
@@ -183,11 +183,11 @@ server.on('session', common.mustCall((session) => {
     }));
     stream.on('finish', common.mustCall());
     stream.on('close', common.mustCall(() => {
-      assert.strictEqual(typeof stream.duration, 'bigint');
-      assert.strictEqual(typeof stream.bytesReceived, 'bigint');
-      assert.strictEqual(typeof stream.bytesSent, 'bigint');
-      assert.strictEqual(typeof stream.maxExtendedOffset, 'bigint');
-      assert.strictEqual(stream.finalSize, BigInt(filedata.length));
+      assert.strictEqual(typeof stream.duration, 'number');
+      assert.strictEqual(typeof stream.bytesReceived, 'number');
+      assert.strictEqual(typeof stream.bytesSent, 'number');
+      assert.strictEqual(typeof stream.maxExtendedOffset, 'number');
+      assert.strictEqual(stream.finalSize, filedata.length);
     }));
   }));
 
@@ -317,7 +317,7 @@ server.on('ready', common.mustCall(() => {
     }));
     stream.on('close', common.mustCall(() => {
       debug('Bidirectional, Client-initiated stream %d closed', stream.id);
-      assert.strictEqual(stream.finalSize, BigInt(filedata.length));
+      assert.strictEqual(stream.finalSize, filedata.length);
       countdown.dec();
     }));
     debug('Bidirectional, Client-initiated stream %d opened', stream.id);
@@ -334,7 +334,7 @@ server.on('ready', common.mustCall(() => {
     }));
     stream.on('close', common.mustCall(() => {
       debug('Unidirectional, Server-initiated stream %d closed', stream.id);
-      assert.strictEqual(stream.finalSize, 26n);
+      assert.strictEqual(stream.finalSize, 26);
       countdown.dec();
     }));
   }));
diff --git a/test/parallel/test-quic-statelessreset.js b/test/parallel/test-quic-statelessreset.js
index 370fbf15de9acf..fd7cf06a247a10 100644
--- a/test/parallel/test-quic-statelessreset.js
+++ b/test/parallel/test-quic-statelessreset.js
@@ -45,7 +45,7 @@ server.on('session', common.mustCall((session) => {
 server.on('close', common.mustCall(() => {
   // Verify stats recording
   console.log(server.statelessResetCount);
-  assert(server.statelessResetCount >= 1n);
+  assert(server.statelessResetCount >= 1);
 }));
 
 server.on('ready', common.mustCall(() => {

From ee73cd5cd696ecef5c2d1093a8312bb491189daa Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 9 Jul 2020 10:54:26 -0700
Subject: [PATCH 3/3] quic: set destroyed at timestamps for duration
 calculation

---
 lib/internal/quic/core.js    | 41 ++++++++++++++++++++++--------------
 src/quic/node_quic_session.h |  1 +
 src/quic/node_quic_socket.h  |  1 +
 src/quic/node_quic_stream.h  |  1 +
 4 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index 6f48ea3a6509d5..e46e2763241914 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -126,6 +126,7 @@ const {
     AF_INET6,
     NGTCP2_DEFAULT_MAX_PKTLEN,
     IDX_QUIC_SESSION_STATS_CREATED_AT,
+    IDX_QUIC_SESSION_STATS_DESTROYED_AT,
     IDX_QUIC_SESSION_STATS_HANDSHAKE_START_AT,
     IDX_QUIC_SESSION_STATS_BYTES_RECEIVED,
     IDX_QUIC_SESSION_STATS_BYTES_SENT,
@@ -143,6 +144,7 @@ const {
     IDX_QUIC_SESSION_STATS_SMOOTHED_RTT,
     IDX_QUIC_SESSION_STATS_LATEST_RTT,
     IDX_QUIC_STREAM_STATS_CREATED_AT,
+    IDX_QUIC_STREAM_STATS_DESTROYED_AT,
     IDX_QUIC_STREAM_STATS_BYTES_RECEIVED,
     IDX_QUIC_STREAM_STATS_BYTES_SENT,
     IDX_QUIC_STREAM_STATS_MAX_OFFSET,
@@ -150,6 +152,7 @@ const {
     IDX_QUIC_STREAM_STATS_MAX_OFFSET_ACK,
     IDX_QUIC_STREAM_STATS_MAX_OFFSET_RECV,
     IDX_QUIC_SOCKET_STATS_CREATED_AT,
+    IDX_QUIC_SOCKET_STATS_DESTROYED_AT,
     IDX_QUIC_SOCKET_STATS_BOUND_AT,
     IDX_QUIC_SOCKET_STATS_LISTEN_AT,
     IDX_QUIC_SOCKET_STATS_BYTES_RECEIVED,
@@ -1433,6 +1436,9 @@ class QuicSocket extends EventEmitter {
 
     // Mark the QuicSocket as being destroyed.
     state.state = kSocketDestroyed;
+    this[kHandle].stats[IDX_QUIC_SOCKET_STATS_DESTROYED_AT] =
+      process.hrtime.bigint();
+    state.stats = new BigInt64Array(this[kHandle].stats);
 
     // Immediately close any sessions that may be remaining.
     // If the udp socket is in a state where it is able to do so,
@@ -1531,24 +1537,21 @@ class QuicSocket extends EventEmitter {
   }
 
   get duration() {
-    // TODO(@jasnell): If the object is destroyed, it should
-    // use a fixed duration rather than calculating from now
-    return Number(process.hrtime.bigint() -
-      getStats(this, IDX_QUIC_SOCKET_STATS_CREATED_AT));
+    const end = getStats(this, IDX_QUIC_SOCKET_STATS_DESTROYED_AT) ||
+                process.hrtime.bigint();
+    return Number(end - getStats(this, IDX_QUIC_SOCKET_STATS_CREATED_AT));
   }
 
   get boundDuration() {
-    // TODO(@jasnell): If the object is destroyed, it should
-    // use a fixed duration rather than calculating from now
-    return Number(process.hrtime.bigint() -
-      getStats(this, IDX_QUIC_SOCKET_STATS_BOUND_AT));
+    const end = getStats(this, IDX_QUIC_SOCKET_STATS_DESTROYED_AT) ||
+                process.hrtime.bigint();
+    return Number(end - getStats(this, IDX_QUIC_SOCKET_STATS_BOUND_AT));
   }
 
   get listenDuration() {
-    // TODO(@jasnell): If the object is destroyed, it should
-    // use a fixed duration rather than calculating from now
-    return Number(process.hrtime.bigint() -
-      getStats(this, IDX_QUIC_SOCKET_STATS_LISTEN_AT));
+    const end = getStats(this, IDX_QUIC_SOCKET_STATS_DESTROYED_AT) ||
+                process.hrtime.bigint();
+    return Number(end - getStats(this, IDX_QUIC_SOCKET_STATS_LISTEN_AT));
   }
 
   get bytesReceived() {
@@ -1920,6 +1923,8 @@ class QuicSession extends EventEmitter {
     this[kHandle] = undefined;
     if (handle !== undefined) {
       // Copy the stats for use after destruction
+      handle.stats[IDX_QUIC_SESSION_STATS_DESTROYED_AT] =
+        process.hrtime.bigint();
       state.stats = new BigInt64Array(handle.stats);
       state.idleTimeout = this[kInternalState].state.idleTimeout;
 
@@ -2148,8 +2153,9 @@ class QuicSession extends EventEmitter {
   }
 
   get duration() {
-    return Number(process.hrtime.bigint() -
-      getStats(this, IDX_QUIC_SESSION_STATS_CREATED_AT));
+    const end = getStats(this, IDX_QUIC_SESSION_STATS_DESTROYED_AT) ||
+                process.hrtime.bigint();
+    return Number(end - getStats(this, IDX_QUIC_SESSION_STATS_CREATED_AT));
   }
 
   get handshakeDuration() {
@@ -2972,6 +2978,8 @@ class QuicStream extends Duplex {
     // object has been destroyed. Any attempt to use the object
     // will segfault and crash the process.
     if (handle !== undefined) {
+      handle.stats[IDX_QUIC_STREAM_STATS_DESTROYED_AT] =
+        process.hrtime.bigint();
       state.stats = new BigInt64Array(handle.stats);
       handle.destroy();
     }
@@ -3139,8 +3147,9 @@ class QuicStream extends Duplex {
   }
 
   get duration() {
-    return Number(process.hrtime.bigint() -
-      getStats(this, IDX_QUIC_STREAM_STATS_CREATED_AT));
+    const end = getStats(this, IDX_QUIC_STREAM_STATS_DESTROYED_AT) ||
+                process.hrtime.bigint();
+    return Number(end - getStats(this, IDX_QUIC_STREAM_STATS_CREATED_AT));
   }
 
   get bytesReceived() {
diff --git a/src/quic/node_quic_session.h b/src/quic/node_quic_session.h
index daa189d40d291c..ae5ec0754b8249 100644
--- a/src/quic/node_quic_session.h
+++ b/src/quic/node_quic_session.h
@@ -182,6 +182,7 @@ enum QuicSessionStateFields {
   V(SENT_AT, sent_at, "Last Sent At")                                          \
   V(RECEIVED_AT, received_at, "Last Received At")                              \
   V(CLOSING_AT, closing_at, "Closing")                                         \
+  V(DESTROYED_AT, destroyed_at, "Destroyed At")                                \
   V(BYTES_RECEIVED, bytes_received, "Bytes Received")                          \
   V(BYTES_SENT, bytes_sent, "Bytes Sent")                                      \
   V(BIDI_STREAM_COUNT, bidi_stream_count, "Bidi Stream Count")                 \
diff --git a/src/quic/node_quic_socket.h b/src/quic/node_quic_socket.h
index 41092c344c8f16..f108eb47901b81 100644
--- a/src/quic/node_quic_socket.h
+++ b/src/quic/node_quic_socket.h
@@ -71,6 +71,7 @@ enum QuicSocketStateFields {
   V(CREATED_AT, created_at, "Created At")                                      \
   V(BOUND_AT, bound_at, "Bound At")                                            \
   V(LISTEN_AT, listen_at, "Listen At")                                         \
+  V(DESTROYED_AT, destroyed_at, "Destroyed At")                                \
   V(BYTES_RECEIVED, bytes_received, "Bytes Received")                          \
   V(BYTES_SENT, bytes_sent, "Bytes Sent")                                      \
   V(PACKETS_RECEIVED, packets_received, "Packets Received")                    \
diff --git a/src/quic/node_quic_stream.h b/src/quic/node_quic_stream.h
index 53a8cdaea52d51..96727d8661b1ba 100644
--- a/src/quic/node_quic_stream.h
+++ b/src/quic/node_quic_stream.h
@@ -50,6 +50,7 @@ enum QuicStreamHeadersKind : int {
   V(RECEIVED_AT, received_at, "Last Received At")                              \
   V(ACKED_AT, acked_at, "Last Acknowledged At")                                \
   V(CLOSING_AT, closing_at, "Closing At")                                      \
+  V(DESTROYED_AT, destroyed_at, "Destroyed At")                                \
   V(BYTES_RECEIVED, bytes_received, "Bytes Received")                          \
   V(BYTES_SENT, bytes_sent, "Bytes Sent")                                      \
   V(MAX_OFFSET, max_offset, "Max Offset")                                      \