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] 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'
   });
 }));