undici 6.11.1 → 6.12.0

package/docs/docs/api/Dispatcher.md

@@ -969,6 +969,12 @@ Parameters:
 * **targets** `Array<Dispatcher>`
 * **error** `Error`
 
+Emitted when the dispatcher has been disconnected from the origin.
+
+> **Note**: For HTTP/2, this event is also emitted when the dispatcher has received the [GOAWAY Frame](https://webconcepts.info/concepts/http2-frame-type/0x7) with an Error with the message `HTTP/2: "GOAWAY" frame received` and the code `UND_ERR_INFO`.
+> Due to nature of the protocol of using binary frames, it is possible that requests gets hanging as a frame can be received between the `HEADER` and `DATA` frames.
+> It is recommended to handle this event and close the dispatcher to create a new HTTP/2 session.
+
 ### Event: `'connectionError'`
 
 Parameters:

package/lib/api/abort-signal.js

@@ -8,11 +8,14 @@ function abort (self) {
   if (self.abort) {
     self.abort(self[kSignal]?.reason)
   } else {
-    self.onError(self[kSignal]?.reason ?? new RequestAbortedError())
+    self.reason = self[kSignal]?.reason ?? new RequestAbortedError()
   }
+  removeSignal(self)
 }
 
 function addSignal (self, signal) {
+  self.reason = null
+
   self[kSignal] = null
   self[kListener] = null
 

package/lib/api/api-connect.js

@@ -1,7 +1,8 @@
 'use strict'
 
+const assert = require('node:assert')
 const { AsyncResource } = require('node:async_hooks')
-const { InvalidArgumentError, RequestAbortedError, SocketError } = require('../core/errors')
+const { InvalidArgumentError, SocketError } = require('../core/errors')
 const util = require('../core/util')
 const { addSignal, removeSignal } = require('./abort-signal')
 
@@ -32,10 +33,13 @@ class ConnectHandler extends AsyncResource {
   }
 
   onConnect (abort, context) {
-    if (!this.callback) {
-      throw new RequestAbortedError()
+    if (this.reason) {
+      abort(this.reason)
+      return
     }
 
+    assert(this.callback)
+
     this.abort = abort
     this.context = context
   }

package/lib/api/api-pipeline.js

@@ -147,12 +147,14 @@ class PipelineHandler extends AsyncResource {
   onConnect (abort, context) {
     const { ret, res } = this
 
-    assert(!res, 'pipeline cannot be retried')
-
-    if (ret.destroyed) {
-      throw new RequestAbortedError()
+    if (this.reason) {
+      abort(this.reason)
+      return
     }
 
+    assert(!res, 'pipeline cannot be retried')
+    assert(!ret.destroyed)
+
     this.abort = abort
     this.context = context
   }

package/lib/api/api-request.js

@@ -1,10 +1,8 @@
 'use strict'
 
+const assert = require('node:assert')
 const { Readable } = require('./readable')
-const {
-  InvalidArgumentError,
-  RequestAbortedError
-} = require('../core/errors')
+const { InvalidArgumentError } = require('../core/errors')
 const util = require('../core/util')
 const { getResolveErrorBodyCallback } = require('./util')
 const { AsyncResource } = require('node:async_hooks')
@@ -69,10 +67,13 @@ class RequestHandler extends AsyncResource {
   }
 
   onConnect (abort, context) {
-    if (!this.callback) {
-      throw new RequestAbortedError()
+    if (this.reason) {
+      abort(this.reason)
+      return
     }
 
+    assert(this.callback)
+
     this.abort = abort
     this.context = context
   }

package/lib/api/api-stream.js

@@ -1,11 +1,8 @@
 'use strict'
 
+const assert = require('node:assert')
 const { finished, PassThrough } = require('node:stream')
-const {
-  InvalidArgumentError,
-  InvalidReturnValueError,
-  RequestAbortedError
-} = require('../core/errors')
+const { InvalidArgumentError, InvalidReturnValueError } = require('../core/errors')
 const util = require('../core/util')
 const { getResolveErrorBodyCallback } = require('./util')
 const { AsyncResource } = require('node:async_hooks')
@@ -70,10 +67,13 @@ class StreamHandler extends AsyncResource {
   }
 
   onConnect (abort, context) {
-    if (!this.callback) {
-      throw new RequestAbortedError()
+    if (this.reason) {
+      abort(this.reason)
+      return
     }
 
+    assert(this.callback)
+
     this.abort = abort
     this.context = context
   }

package/lib/api/api-upgrade.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { InvalidArgumentError, RequestAbortedError, SocketError } = require('../core/errors')
+const { InvalidArgumentError, SocketError } = require('../core/errors')
 const { AsyncResource } = require('node:async_hooks')
 const util = require('../core/util')
 const { addSignal, removeSignal } = require('./abort-signal')
@@ -34,10 +34,13 @@ class UpgradeHandler extends AsyncResource {
   }
 
   onConnect (abort, context) {
-    if (!this.callback) {
-      throw new RequestAbortedError()
+    if (this.reason) {
+      abort(this.reason)
+      return
     }
 
+    assert(this.callback)
+
     this.abort = abort
     this.context = null
   }

package/lib/core/util.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const assert = require('node:assert')
-const { kDestroyed, kBodyUsed } = require('./symbols')
+const { kDestroyed, kBodyUsed, kListeners } = require('./symbols')
 const { IncomingMessage } = require('node:http')
 const stream = require('node:stream')
 const net = require('node:net')
@@ -22,13 +22,20 @@ function isStream (obj) {
 
 // based on https://github.com/node-fetch/fetch-blob/blob/8ab587d34080de94140b54f07168451e7d0b655e/index.js#L229-L241 (MIT License)
 function isBlobLike (object) {
-  return (Blob && object instanceof Blob) || (
-    object &&
-    typeof object === 'object' &&
-    (typeof object.stream === 'function' ||
-      typeof object.arrayBuffer === 'function') &&
-    /^(Blob|File)$/.test(object[Symbol.toStringTag])
-  )
+  if (object === null) {
+    return false
+  } else if (object instanceof Blob) {
+    return true
+  } else if (typeof object !== 'object') {
+    return false
+  } else {
+    const sTag = object[Symbol.toStringTag]
+
+    return (sTag === 'Blob' || sTag === 'File') && (
+      ('stream' in object && typeof object.stream === 'function') ||
+      ('arrayBuffer' in object && typeof object.arrayBuffer === 'function')
+    )
+  }
 }
 
 function buildURL (url, queryParams) {
@@ -534,6 +541,29 @@ function parseRangeHeader (range) {
     : null
 }
 
+function addListener (obj, name, listener) {
+  const listeners = (obj[kListeners] ??= [])
+  listeners.push([name, listener])
+  obj.on(name, listener)
+  return obj
+}
+
+function removeAllListeners (obj) {
+  for (const [name, listener] of obj[kListeners] ?? []) {
+    obj.removeListener(name, listener)
+  }
+  obj[kListeners] = null
+}
+
+function errorRequest (client, request, err) {
+  try {
+    request.onError(err)
+    assert(request.aborted)
+  } catch (err) {
+    client.emit('error', err)
+  }
+}
+
 const kEnumerableProperty = Object.create(null)
 kEnumerableProperty.enumerable = true
 
@@ -556,6 +586,9 @@ module.exports = {
   isDestroyed,
   headerNameToString,
   bufferToLowerCasedHeaderName,
+  addListener,
+  removeAllListeners,
+  errorRequest,
   parseRawHeaders,
   parseHeaders,
   parseKeepAliveTimeout,

package/lib/dispatcher/client-h1.js

@@ -47,7 +47,6 @@ const {
   kMaxRequests,
   kCounter,
   kMaxResponseSize,
-  kListeners,
   kOnError,
   kResume,
   kHTTPContext
@@ -56,23 +55,11 @@ const {
 const constants = require('../llhttp/constants.js')
 const EMPTY_BUF = Buffer.alloc(0)
 const FastBuffer = Buffer[Symbol.species]
+const addListener = util.addListener
+const removeAllListeners = util.removeAllListeners
 
 let extractBody
 
-function addListener (obj, name, listener) {
-  const listeners = (obj[kListeners] ??= [])
-  listeners.push([name, listener])
-  obj.on(name, listener)
-  return obj
-}
-
-function removeAllListeners (obj) {
-  for (const [name, listener] of obj[kListeners] ?? []) {
-    obj.removeListener(name, listener)
-  }
-  obj[kListeners] = null
-}
-
 async function lazyllhttp () {
   const llhttpWasmData = process.env.JEST_WORKER_ID ? require('../llhttp/llhttp-wasm.js') : undefined
 
@@ -719,14 +706,14 @@ async function connectH1 (client, socket) {
       const requests = client[kQueue].splice(client[kRunningIdx])
       for (let i = 0; i < requests.length; i++) {
         const request = requests[i]
-        errorRequest(client, request, err)
+        util.errorRequest(client, request, err)
       }
     } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
       // Fail head of pipeline.
       const request = client[kQueue][client[kRunningIdx]]
       client[kQueue][client[kRunningIdx]++] = null
 
-      errorRequest(client, request, err)
+      util.errorRequest(client, request, err)
     }
 
     client[kPendingIdx] = client[kRunningIdx]
@@ -831,15 +818,6 @@ function resumeH1 (client) {
   }
 }
 
-function errorRequest (client, request, err) {
-  try {
-    request.onError(err)
-    assert(request.aborted)
-  } catch (err) {
-    client.emit('error', err)
-  }
-}
-
 // https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
 function shouldSendContentLength (method) {
   return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT'
@@ -906,7 +884,7 @@ function writeH1 (client, request) {
   // A user agent may send a Content-Length header with 0 value, this should be allowed.
   if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
     if (client[kStrictContentLength]) {
-      errorRequest(client, request, new RequestContentLengthMismatchError())
+      util.errorRequest(client, request, new RequestContentLengthMismatchError())
       return false
     }
 
@@ -915,22 +893,24 @@ function writeH1 (client, request) {
 
   const socket = client[kSocket]
 
-  try {
-    request.onConnect((err) => {
-      if (request.aborted || request.completed) {
-        return
-      }
+  const abort = (err) => {
+    if (request.aborted || request.completed) {
+      return
+    }
 
-      errorRequest(client, request, err || new RequestAbortedError())
+    util.errorRequest(client, request, err || new RequestAbortedError())
 
-      util.destroy(socket, new InformationalError('aborted'))
-    })
+    util.destroy(body)
+    util.destroy(socket, new InformationalError('aborted'))
+  }
+
+  try {
+    request.onConnect(abort)
   } catch (err) {
-    errorRequest(client, request, err)
+    util.errorRequest(client, request, err)
   }
 
   if (request.aborted) {
-    util.destroy(body)
     return false
   }
 
@@ -998,35 +978,19 @@ function writeH1 (client, request) {
 
   /* istanbul ignore else: assertion */
   if (!body || bodyLength === 0) {
-    if (contentLength === 0) {
-      socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1')
-    } else {
-      assert(contentLength === null, 'no body must not have content length')
-      socket.write(`${header}\r\n`, 'latin1')
-    }
-    request.onRequestSent()
+    writeBuffer({ abort, body: null, client, request, socket, contentLength, header, expectsPayload })
   } else if (util.isBuffer(body)) {
-    assert(contentLength === body.byteLength, 'buffer body must have content length')
-
-    socket.cork()
-    socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
-    socket.write(body)
-    socket.uncork()
-    request.onBodySent(body)
-    request.onRequestSent()
-    if (!expectsPayload) {
-      socket[kReset] = true
-    }
+    writeBuffer({ abort, body, client, request, socket, contentLength, header, expectsPayload })
   } else if (util.isBlobLike(body)) {
     if (typeof body.stream === 'function') {
-      writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload })
+      writeIterable({ abort, body: body.stream(), client, request, socket, contentLength, header, expectsPayload })
     } else {
-      writeBlob({ body, client, request, socket, contentLength, header, expectsPayload })
+      writeBlob({ abort, body, client, request, socket, contentLength, header, expectsPayload })
     }
   } else if (util.isStream(body)) {
-    writeStream({ body, client, request, socket, contentLength, header, expectsPayload })
+    writeStream({ abort, body, client, request, socket, contentLength, header, expectsPayload })
   } else if (util.isIterable(body)) {
-    writeIterable({ body, client, request, socket, contentLength, header, expectsPayload })
+    writeIterable({ abort, body, client, request, socket, contentLength, header, expectsPayload })
   } else {
     assert(false)
   }
@@ -1034,12 +998,12 @@ function writeH1 (client, request) {
   return true
 }
 
-function writeStream ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
+function writeStream ({ abort, body, client, request, socket, contentLength, header, expectsPayload }) {
   assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined')
 
   let finished = false
 
-  const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header })
+  const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header })
 
   const onData = function (chunk) {
     if (finished) {
@@ -1137,7 +1101,37 @@ function writeStream ({ h2stream, body, client, request, socket, contentLength,
   }
 }
 
-async function writeBlob ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
+async function writeBuffer ({ abort, body, client, request, socket, contentLength, header, expectsPayload }) {
+  try {
+    if (!body) {
+      if (contentLength === 0) {
+        socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1')
+      } else {
+        assert(contentLength === null, 'no body must not have content length')
+        socket.write(`${header}\r\n`, 'latin1')
+      }
+    } else if (util.isBuffer(body)) {
+      assert(contentLength === body.byteLength, 'buffer body must have content length')
+
+      socket.cork()
+      socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
+      socket.write(body)
+      socket.uncork()
+      request.onBodySent(body)
+
+      if (!expectsPayload) {
+        socket[kReset] = true
+      }
+    }
+    request.onRequestSent()
+
+    client[kResume]()
+  } catch (err) {
+    abort(err)
+  }
+}
+
+async function writeBlob ({ abort, body, client, request, socket, contentLength, header, expectsPayload }) {
   assert(contentLength === body.size, 'blob body must have content length')
 
   try {
@@ -1161,11 +1155,11 @@ async function writeBlob ({ h2stream, body, client, request, socket, contentLeng
 
     client[kResume]()
   } catch (err) {
-    util.destroy(socket, err)
+    abort(err)
   }
 }
 
-async function writeIterable ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
+async function writeIterable ({ abort, body, client, request, socket, contentLength, header, expectsPayload }) {
   assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
 
   let callback = null
@@ -1191,7 +1185,7 @@ async function writeIterable ({ h2stream, body, client, request, socket, content
     .on('close', onDrain)
     .on('drain', onDrain)
 
-  const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header })
+  const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header })
   try {
     // It's up to the user to somehow abort the async iterable.
     for await (const chunk of body) {
@@ -1215,7 +1209,7 @@ async function writeIterable ({ h2stream, body, client, request, socket, content
 }
 
 class AsyncWriter {
-  constructor ({ socket, request, contentLength, client, expectsPayload, header }) {
+  constructor ({ abort, socket, request, contentLength, client, expectsPayload, header }) {
     this.socket = socket
     this.request = request
     this.contentLength = contentLength
@@ -1223,6 +1217,7 @@ class AsyncWriter {
     this.bytesWritten = 0
     this.expectsPayload = expectsPayload
     this.header = header
+    this.abort = abort
 
     socket[kWriting] = true
   }
@@ -1338,13 +1333,13 @@ class AsyncWriter {
   }
 
   destroy (err) {
-    const { socket, client } = this
+    const { socket, client, abort } = this
 
     socket[kWriting] = false
 
     if (err) {
       assert(client[kRunning] <= 1, 'pipeline should only contain this request')
-      util.destroy(socket, err)
+      abort(err)
     }
   }
 }

package/lib/dispatcher/client-h2.js

@@ -22,7 +22,6 @@ const {
   kSocket,
   kStrictContentLength,
   kOnError,
-  // HTTP2
   kMaxConcurrentStreams,
   kHTTP2Session,
   kResume
@@ -55,14 +54,20 @@ const {
 } = http2
 
 function parseH2Headers (headers) {
-  // set-cookie is always an array. Duplicates are added to the array.
-  // For duplicate cookie headers, the values are joined together with '; '.
-  headers = Object.entries(headers).flat(2)
-
   const result = []
 
-  for (const header of headers) {
-    result.push(Buffer.from(header))
+  for (const [name, value] of Object.entries(headers)) {
+    // h2 may concat the header value by array
+    // e.g. Set-Cookie
+    if (Array.isArray(value)) {
+      for (const subvalue of value) {
+        // we need to provide each header value of header name
+        // because the headers handler expect name-value pair
+        result.push(Buffer.from(name), Buffer.from(subvalue))
+      }
+    } else {
+      result.push(Buffer.from(name), Buffer.from(value))
+    }
   }
 
   return result
@@ -86,16 +91,18 @@ async function connectH2 (client, socket) {
   session[kOpenStreams] = 0
   session[kClient] = client
   session[kSocket] = socket
-  session.on('error', onHttp2SessionError)
-  session.on('frameError', onHttp2FrameError)
-  session.on('end', onHttp2SessionEnd)
-  session.on('goaway', onHTTP2GoAway)
-  session.on('close', function () {
+
+  util.addListener(session, 'error', onHttp2SessionError)
+  util.addListener(session, 'frameError', onHttp2FrameError)
+  util.addListener(session, 'end', onHttp2SessionEnd)
+  util.addListener(session, 'goaway', onHTTP2GoAway)
+  util.addListener(session, 'close', function () {
     const { [kClient]: client } = this
 
-    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+    const err = this[kSocket][kError] || new SocketError('closed', util.getSocketInfo(this))
 
     client[kSocket] = null
+    client[kHTTP2Session] = null
 
     assert(client[kPending] === 0)
 
@@ -103,7 +110,7 @@ async function connectH2 (client, socket) {
     const requests = client[kQueue].splice(client[kRunningIdx])
     for (let i = 0; i < requests.length; i++) {
       const request = requests[i]
-      errorRequest(client, request, err)
+      util.errorRequest(client, request, err)
     }
 
     client[kPendingIdx] = client[kRunningIdx]
@@ -114,19 +121,21 @@ async function connectH2 (client, socket) {
 
     client[kResume]()
   })
+
   session.unref()
 
   client[kHTTP2Session] = session
   socket[kHTTP2Session] = session
 
-  socket.on('error', function (err) {
+  util.addListener(socket, 'error', function (err) {
     assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
 
     this[kError] = err
 
     this[kClient][kOnError](err)
   })
-  socket.on('end', function () {
+
+  util.addListener(socket, 'end', function () {
     util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
   })
 
@@ -166,67 +175,42 @@ function onHttp2SessionError (err) {
   assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
 
   this[kSocket][kError] = err
-
   this[kClient][kOnError](err)
 }
 
 function onHttp2FrameError (type, code, id) {
-  const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)
-
   if (id === 0) {
+    const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)
     this[kSocket][kError] = err
     this[kClient][kOnError](err)
   }
 }
 
 function onHttp2SessionEnd () {
-  this.destroy(new SocketError('other side closed'))
-  util.destroy(this[kSocket], new SocketError('other side closed'))
+  const err = new SocketError('other side closed', util.getSocketInfo(this[kSocket]))
+  this.destroy(err)
+  util.destroy(this[kSocket], err)
 }
 
+/**
+ * This is the root cause of #3011
+ * We need to handle GOAWAY frames properly, and trigger the session close
+ * along with the socket right away
+ * Find a way to trigger the close cycle from here on.
+ */
 function onHTTP2GoAway (code) {
-  const client = this[kClient]
   const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`)
-  client[kSocket] = null
-  client[kHTTP2Session] = null
 
-  if (client.destroyed) {
-    assert(this[kPending] === 0)
-
-    // Fail entire queue.
-    const requests = client[kQueue].splice(client[kRunningIdx])
-    for (let i = 0; i < requests.length; i++) {
-      const request = requests[i]
-      errorRequest(this, request, err)
-    }
-  } else if (client[kRunning] > 0) {
-    // Fail head of pipeline.
-    const request = client[kQueue][client[kRunningIdx]]
-    client[kQueue][client[kRunningIdx]++] = null
-
-    errorRequest(client, request, err)
-  }
-
-  client[kPendingIdx] = client[kRunningIdx]
-
-  assert(client[kRunning] === 0)
-
-  client.emit('disconnect',
-    client[kUrl],
-    [client],
-    err
-  )
-
-  client[kResume]()
-}
+  // We need to trigger the close cycle right away
+  // We need to destroy the session and the socket
+  // Requests should be failed with the error after the current one is handled
+  this[kSocket][kError] = err
+  this[kClient][kOnError](err)
 
-function errorRequest (client, request, err) {
-  try {
-    request.onError(err)
-    assert(request.aborted)
-  } catch (err) {
-    client.emit('error', err)
-  }
+  this.unref()
+  // We send the GOAWAY frame response as no error
+  this.destroy()
+  util.destroy(this[kSocket], err)
 }
 
 // https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
@@ -239,7 +223,7 @@ function writeH2 (client, request) {
   const { body, method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request
 
   if (upgrade) {
-    errorRequest(client, request, new Error('Upgrade not supported for H2'))
+    util.errorRequest(client, request, new Error('Upgrade not supported for H2'))
     return false
   }
 
@@ -292,10 +276,10 @@ function writeH2 (client, request) {
         }
       }
 
-      errorRequest(client, request, err)
+      util.errorRequest(client, request, err)
     })
   } catch (err) {
-    errorRequest(client, request, err)
+    util.errorRequest(client, request, err)
   }
 
   if (method === 'CONNECT') {
@@ -370,7 +354,7 @@ function writeH2 (client, request) {
   // A user agent may send a Content-Length header with 0 value, this should be allowed.
   if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) {
     if (client[kStrictContentLength]) {
-      errorRequest(client, request, new RequestContentLengthMismatchError())
+      util.errorRequest(client, request, new RequestContentLengthMismatchError())
       return false
     }
 
@@ -412,7 +396,7 @@ function writeH2 (client, request) {
     // as there's no value to keep it open.
     if (request.aborted || request.completed) {
       const err = new RequestAbortedError()
-      errorRequest(client, request, err)
+      util.errorRequest(client, request, err)
       util.destroy(stream, err)
       return
     }
@@ -446,13 +430,12 @@ function writeH2 (client, request) {
     }
 
     const err = new InformationalError('HTTP/2: stream half-closed (remote)')
-    errorRequest(client, request, err)
+    util.errorRequest(client, request, err)
     util.destroy(stream, err)
   })
 
   stream.once('close', () => {
     session[kOpenStreams] -= 1
-    // TODO(HTTP/2): unref only if current streams count is 0
     if (session[kOpenStreams] === 0) {
       session.unref()
     }
@@ -461,13 +444,14 @@ function writeH2 (client, request) {
   stream.once('error', function (err) {
     if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
       session[kOpenStreams] -= 1
+      util.errorRequest(client, request, err)
       util.destroy(stream, err)
     }
   })
 
   stream.once('frameError', (type, code) => {
     const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)
-    errorRequest(client, request, err)
+    util.errorRequest(client, request, err)
 
     if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
       session[kOpenStreams] -= 1

package/lib/dispatcher/client.js

@@ -338,7 +338,7 @@ class Client extends DispatcherBase {
       const requests = this[kQueue].splice(this[kPendingIdx])
       for (let i = 0; i < requests.length; i++) {
         const request = requests[i]
-        errorRequest(this, request, err)
+        util.errorRequest(this, request, err)
       }
 
       const callback = () => {
@@ -378,7 +378,7 @@ function onError (client, err) {
     const requests = client[kQueue].splice(client[kRunningIdx])
     for (let i = 0; i < requests.length; i++) {
       const request = requests[i]
-      errorRequest(client, request, err)
+      util.errorRequest(client, request, err)
     }
     assert(client[kSize] === 0)
   }
@@ -502,7 +502,7 @@ async function connect (client) {
       assert(client[kRunning] === 0)
       while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
         const request = client[kQueue][client[kPendingIdx]++]
-        errorRequest(client, request, err)
+        util.errorRequest(client, request, err)
       }
     } else {
       onError(client, err)
@@ -581,7 +581,10 @@ function _resume (client, sync) {
       }
 
       client[kServerName] = request.servername
-      client[kHTTPContext]?.destroy(new InformationalError('servername changed'))
+      client[kHTTPContext]?.destroy(new InformationalError('servername changed'), () => {
+        client[kHTTPContext] = null
+        resume(client)
+      })
     }
 
     if (client[kConnecting]) {
@@ -609,13 +612,4 @@ function _resume (client, sync) {
   }
 }
 
-function errorRequest (client, request, err) {
-  try {
-    request.onError(err)
-    assert(request.aborted)
-  } catch (err) {
-    client.emit('error', err)
-  }
-}
-
 module.exports = Client

package/lib/dispatcher/proxy-agent.js

@@ -64,19 +64,19 @@ class ProxyAgent extends DispatcherBase {
     this[kAgent] = new Agent({
       ...opts,
       connect: async (opts, callback) => {
-        let requestedHost = opts.host
+        let requestedPath = opts.host
         if (!opts.port) {
-          requestedHost += `:${defaultProtocolPort(opts.protocol)}`
+          requestedPath += `:${defaultProtocolPort(opts.protocol)}`
         }
         try {
           const { socket, statusCode } = await this[kClient].connect({
             origin,
             port,
-            path: requestedHost,
+            path: requestedPath,
             signal: opts.signal,
             headers: {
               ...this[kProxyHeaders],
-              host: requestedHost
+              host: opts.host
             },
             servername: this[kProxyTls]?.servername || proxyHostname
           })
@@ -108,16 +108,18 @@ class ProxyAgent extends DispatcherBase {
   }
 
   dispatch (opts, handler) {
-    const { host } = new URL(opts.origin)
     const headers = buildHeaders(opts.headers)
     throwIfProxyAuthIsSent(headers)
+
+    if (headers && !('host' in headers) && !('Host' in headers)) {
+      const { host } = new URL(opts.origin)
+      headers.host = host
+    }
+
     return this[kAgent].dispatch(
       {
         ...opts,
-        headers: {
-          ...headers,
-          host
-        }
+        headers
       },
       handler
     )

package/lib/mock/mock-interceptor.js

@@ -90,7 +90,7 @@ class MockInterceptor {
     this[kContentLength] = false
   }
 
-  createMockScopeDispatchData (statusCode, data, responseOptions = {}) {
+  createMockScopeDispatchData ({ statusCode, data, responseOptions }) {
     const responseData = getResponseData(data)
     const contentLength = this[kContentLength] ? { 'content-length': responseData.length } : {}
     const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }
@@ -99,14 +99,11 @@ class MockInterceptor {
     return { statusCode, data, headers, trailers }
   }
 
-  validateReplyParameters (statusCode, data, responseOptions) {
-    if (typeof statusCode === 'undefined') {
+  validateReplyParameters (replyParameters) {
+    if (typeof replyParameters.statusCode === 'undefined') {
       throw new InvalidArgumentError('statusCode must be defined')
     }
-    if (typeof data === 'undefined') {
-      throw new InvalidArgumentError('data must be defined')
-    }
-    if (typeof responseOptions !== 'object' || responseOptions === null) {
+    if (typeof replyParameters.responseOptions !== 'object' || replyParameters.responseOptions === null) {
       throw new InvalidArgumentError('responseOptions must be an object')
     }
   }
@@ -114,28 +111,28 @@ class MockInterceptor {
   /**
    * Mock an undici request with a defined reply.
    */
-  reply (replyData) {
+  reply (replyOptionsCallbackOrStatusCode) {
     // Values of reply aren't available right now as they
     // can only be available when the reply callback is invoked.
-    if (typeof replyData === 'function') {
+    if (typeof replyOptionsCallbackOrStatusCode === 'function') {
       // We'll first wrap the provided callback in another function,
       // this function will properly resolve the data from the callback
       // when invoked.
       const wrappedDefaultsCallback = (opts) => {
         // Our reply options callback contains the parameter for statusCode, data and options.
-        const resolvedData = replyData(opts)
+        const resolvedData = replyOptionsCallbackOrStatusCode(opts)
 
         // Check if it is in the right format
-        if (typeof resolvedData !== 'object') {
+        if (typeof resolvedData !== 'object' || resolvedData === null) {
           throw new InvalidArgumentError('reply options callback must return an object')
         }
 
-        const { statusCode, data = '', responseOptions = {} } = resolvedData
-        this.validateReplyParameters(statusCode, data, responseOptions)
+        const replyParameters = { data: '', responseOptions: {}, ...resolvedData }
+        this.validateReplyParameters(replyParameters)
         // Since the values can be obtained immediately we return them
         // from this higher order function that will be resolved later.
         return {
-          ...this.createMockScopeDispatchData(statusCode, data, responseOptions)
+          ...this.createMockScopeDispatchData(replyParameters)
         }
       }
 
@@ -148,11 +145,15 @@ class MockInterceptor {
     // we should have 1-3 parameters. So we spread the arguments of
     // this function to obtain the parameters, since replyData will always
     // just be the statusCode.
-    const [statusCode, data = '', responseOptions = {}] = [...arguments]
-    this.validateReplyParameters(statusCode, data, responseOptions)
+    const replyParameters = {
+      statusCode: replyOptionsCallbackOrStatusCode,
+      data: arguments[1] === undefined ? '' : arguments[1],
+      responseOptions: arguments[2] === undefined ? {} : arguments[2]
+    }
+    this.validateReplyParameters(replyParameters)
 
     // Send in-already provided data like usual
-    const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions)
+    const dispatchData = this.createMockScopeDispatchData(replyParameters)
     const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData)
     return new MockScope(newMockDispatch)
   }

package/lib/mock/mock-utils.js

@@ -8,7 +8,7 @@ const {
   kOrigin,
   kGetNetConnect
 } = require('./mock-symbols')
-const { buildURL, nop } = require('../core/util')
+const { buildURL } = require('../core/util')
 const { STATUS_CODES } = require('node:http')
 const {
   types: {
@@ -285,10 +285,10 @@ function mockDispatch (opts, handler) {
     const responseHeaders = generateKeyValues(headers)
     const responseTrailers = generateKeyValues(trailers)
 
-    handler.abort = nop
-    handler.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode))
-    handler.onData(Buffer.from(responseData))
-    handler.onComplete(responseTrailers)
+    handler.onConnect?.(err => handler.onError(err), null)
+    handler.onHeaders?.(statusCode, responseHeaders, resume, getStatusText(statusCode))
+    handler.onData?.(Buffer.from(responseData))
+    handler.onComplete?.(responseTrailers)
     deleteMockDispatch(mockDispatches, key)
   }
 

package/lib/web/fetch/constants.js

@@ -14,8 +14,8 @@ const badPorts = [
   '87', '95', '101', '102', '103', '104', '109', '110', '111', '113', '115', '117', '119', '123', '135', '137',
   '139', '143', '161', '179', '389', '427', '465', '512', '513', '514', '515', '526', '530', '531', '532',
   '540', '548', '554', '556', '563', '587', '601', '636', '989', '990', '993', '995', '1719', '1720', '1723',
-  '2049', '3659', '4045', '5060', '5061', '6000', '6566', '6665', '6666', '6667', '6668', '6669', '6697',
-  '10080'
+  '2049', '3659', '4045', '4190', '5060', '5061', '6000', '6566', '6665', '6666', '6667', '6668', '6669', '6679',
+  '6697', '10080'
 ]
 
 const badPortsSet = new Set(badPorts)

package/lib/web/websocket/receiver.js

@@ -4,7 +4,7 @@ const { Writable } = require('node:stream')
 const { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require('./constants')
 const { kReadyState, kSentClose, kResponse, kReceivedClose } = require('./symbols')
 const { channels } = require('../../core/diagnostics')
-const { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require('./util')
+const { isValidStatusCode, failWebsocketConnection, websocketMessageReceived, utf8Decode } = require('./util')
 const { WebsocketFrameSend } = require('./frame')
 
 // This code was influenced by ws released under the MIT license.
@@ -314,8 +314,7 @@ class ByteParser extends Writable {
     }
 
     try {
-      // TODO: optimize this
-      reason = new TextDecoder('utf-8', { fatal: true }).decode(reason)
+      reason = utf8Decode(reason)
     } catch {
       return null
     }

package/lib/web/websocket/util.js

@@ -3,6 +3,7 @@
 const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require('./symbols')
 const { states, opcodes } = require('./constants')
 const { MessageEvent, ErrorEvent } = require('./events')
+const { isUtf8 } = require('node:buffer')
 
 /* globals Blob */
 
@@ -87,7 +88,7 @@ function websocketMessageReceived (ws, type, data) {
     // -> type indicates that the data is Text
     //      a new DOMString containing data
     try {
-      dataForEvent = new TextDecoder('utf-8', { fatal: true }).decode(data)
+      dataForEvent = utf8Decode(data)
     } catch {
       failWebsocketConnection(ws, 'Received invalid UTF-8 in text frame.')
       return
@@ -200,6 +201,33 @@ function failWebsocketConnection (ws, reason) {
   }
 }
 
+// https://nodejs.org/api/intl.html#detecting-internationalization-support
+const hasIntl = typeof process.versions.icu === 'string'
+const fatalDecoder = hasIntl ? new TextDecoder('utf-8', { fatal: true }) : undefined
+
+/**
+ * Converts a Buffer to utf-8, even on platforms without icu.
+ * @param {Buffer} buffer
+ */
+function utf8Decode (buffer) {
+  if (hasIntl) {
+    return fatalDecoder.decode(buffer)
+  } else {
+    if (!isUtf8?.(buffer)) {
+      // TODO: remove once node 18 or < node v18.14.0 is dropped
+      if (!isUtf8) {
+        process.emitWarning('ICU is not supported and no fallback exists. Please upgrade to at least Node v18.14.0.', {
+          code: 'UNDICI-WS-NO-ICU'
+        })
+      }
+
+      throw new TypeError('Invalid utf-8 received.')
+    }
+
+    return buffer.toString('utf-8')
+  }
+}
+
 module.exports = {
   isConnecting,
   isEstablished,
@@ -209,5 +237,6 @@ module.exports = {
   isValidSubprotocol,
   isValidStatusCode,
   failWebsocketConnection,
-  websocketMessageReceived
+  websocketMessageReceived,
+  utf8Decode
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "6.11.1",
+  "version": "6.12.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -68,20 +68,25 @@
     "lint": "standard | snazzy",
     "lint:fix": "standard --fix | snazzy",
     "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE=  npm run test:typescript",
-    "test:javascript": "node scripts/generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:fetch && npm run test:cookies && npm run test:eventsource && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:jest",
-    "test:javascript:withoutintl": "node scripts/generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:fetch:nobuild && npm run test:cookies && npm run test:eventsource:nobuild && npm run test:wpt:withoutintl && npm run test:node-test",
+    "test:javascript": "node scripts/generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:cache && npm run test:interceptors && npm run test:fetch && npm run test:cookies && npm run test:eventsource && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:jest",
+    "test:javascript:withoutintl": "node scripts/generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:fetch:nobuild && npm run test:cache && npm run test:interceptors && npm run test:cookies && npm run test:eventsource:nobuild && npm run test:wpt:withoutintl && npm run test:node-test",
+    "test:busboy": "borp -p \"test/busboy/*.js\"",
+    "test:cache": "borp -p \"test/cache/*.js\"",
     "test:cookies": "borp -p \"test/cookie/*.js\"",
-    "test:node-fetch": "borp -p \"test/node-fetch/**/*.js\"",
     "test:eventsource": "npm run build:node && npm run test:eventsource:nobuild",
     "test:eventsource:nobuild": "borp --expose-gc -p \"test/eventsource/*.js\"",
+    "test:fuzzing": "node test/fuzzing/fuzzing.test.js",
     "test:fetch": "npm run build:node && npm run test:fetch:nobuild",
-    "test:fetch:nobuild": "borp --expose-gc -p \"test/fetch/*.js\" && borp -p \"test/webidl/*.js\" && borp -p \"test/busboy/*.js\"",
+    "test:fetch:nobuild": "borp --expose-gc -p \"test/fetch/*.js\" && npm run test:webidl && npm run test:busboy",
+    "test:interceptors": "borp -p \"test/interceptors/*.js\"",
     "test:jest": "cross-env NODE_V8_COVERAGE= jest",
     "test:unit": "borp --expose-gc -p \"test/*.js\"",
+    "test:node-fetch": "borp -p \"test/node-fetch/**/*.js\"",
     "test:node-test": "borp -p \"test/node-test/**/*.js\"",
     "test:tdd": "borp --expose-gc -p \"test/*.js\"",
     "test:tdd:node-test": "borp -p \"test/node-test/**/*.js\" -w",
     "test:typescript": "tsd && tsc --skipLibCheck test/imports/undici-import.ts",
+    "test:webidl": "borp -p \"test/webidl/*.js\"",
     "test:websocket": "borp -p \"test/websocket/*.js\"",
     "test:wpt": "node test/wpt/start-fetch.mjs && node test/wpt/start-FileAPI.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-websockets.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
     "test:wpt:withoutintl": "node test/wpt/start-fetch.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
@@ -92,8 +97,7 @@
     "coverage:report:ci": "c8 report",
     "bench": "echo \"Error: Benchmarks have been moved to '/benchmarks'\" && exit 1",
     "serve:website": "echo \"Error: Documentation has been moved to '/docs'\" && exit 1",
-    "prepare": "husky install && node ./scripts/platform-shell.js",
-    "fuzz": "jsfuzz test/fuzzing/fuzz.js corpus"
+    "prepare": "husky install && node ./scripts/platform-shell.js"
   },
   "devDependencies": {
     "@matteo.collina/tspl": "^0.1.1",
@@ -104,13 +108,13 @@
     "c8": "^9.1.0",
     "cross-env": "^7.0.3",
     "dns-packet": "^5.4.0",
+    "fast-check": "^3.17.1",
     "form-data": "^4.0.0",
     "formdata-node": "^6.0.3",
     "https-pem": "^3.0.0",
     "husky": "^9.0.7",
     "jest": "^29.0.2",
     "jsdom": "^24.0.0",
-    "jsfuzz": "^1.0.15",
     "node-forge": "^1.3.1",
     "pre-commit": "^1.2.2",
     "proxy": "^2.1.1",

package/types/dispatcher.d.ts

@@ -225,7 +225,7 @@ declare namespace Dispatcher {
     /** Invoked when response is received, before headers have been read. **/
     onResponseStarted?(): void;
     /** Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. */
-    onHeaders?(statusCode: number, headers: Buffer[] | string[] | null, resume: () => void, statusText: string): boolean;
+    onHeaders?(statusCode: number, headers: Buffer[], resume: () => void, statusText: string): boolean;
     /** Invoked when response payload data is received. */
     onData?(chunk: Buffer): boolean;
     /** Invoked when response payload and trailers have been received and the request has completed. */

package/types/fetch.d.ts

@@ -163,7 +163,7 @@ export declare class Request extends BodyMixin {
   readonly method: string
   readonly mode: RequestMode
   readonly redirect: RequestRedirect
-  readonly referrerPolicy: string
+  readonly referrerPolicy: ReferrerPolicy
   readonly url: string
 
   readonly keepalive: boolean