undici 6.20.0 → 7.0.0-alpha.2

package/lib/web/websocket/events.js

@@ -3,7 +3,6 @@
 const { webidl } = require('../fetch/webidl')
 const { kEnumerableProperty } = require('../../core/util')
 const { kConstruct } = require('../../core/symbols')
-const { MessagePort } = require('node:worker_threads')
 
 /**
  * @see https://html.spec.whatwg.org/multipage/comms.html#messageevent
@@ -215,7 +214,10 @@ Object.defineProperties(ErrorEvent.prototype, {
   error: kEnumerableProperty
 })
 
-webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort)
+webidl.converters.MessagePort = webidl.interfaceConverter(
+  webidl.is.MessagePort,
+  'MessagePort'
+)
 
 webidl.converters['sequence<MessagePort>'] = webidl.sequenceConverter(
   webidl.converters.MessagePort

package/lib/web/websocket/frame.js

@@ -1,8 +1,8 @@
 'use strict'
 
-const { maxUnsigned16Bit } = require('./constants')
+const { maxUnsigned16Bit, opcodes } = require('./constants')
 
-const BUFFER_SIZE = 16386
+const BUFFER_SIZE = 8 * 1024
 
 /** @type {import('crypto')} */
 let crypto
@@ -27,7 +27,7 @@ try {
 function generateMask () {
   if (bufIdx === BUFFER_SIZE) {
     bufIdx = 0
-    crypto.randomFillSync((buffer ??= Buffer.allocUnsafe(BUFFER_SIZE)), 0, BUFFER_SIZE)
+    crypto.randomFillSync((buffer ??= Buffer.allocUnsafeSlow(BUFFER_SIZE)), 0, BUFFER_SIZE)
   }
   return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]]
 }
@@ -89,6 +89,48 @@ class WebsocketFrameSend {
 
     return buffer
   }
+
+  /**
+   * @param {Uint8Array} buffer
+   */
+  static createFastTextFrame (buffer) {
+    const maskKey = generateMask()
+
+    const bodyLength = buffer.length
+
+    // mask body
+    for (let i = 0; i < bodyLength; ++i) {
+      buffer[i] ^= maskKey[i & 3]
+    }
+
+    let payloadLength = bodyLength
+    let offset = 6
+
+    if (bodyLength > maxUnsigned16Bit) {
+      offset += 8 // payload length is next 8 bytes
+      payloadLength = 127
+    } else if (bodyLength > 125) {
+      offset += 2 // payload length is next 2 bytes
+      payloadLength = 126
+    }
+    const head = Buffer.allocUnsafeSlow(offset)
+
+    head[0] = 0x80 /* FIN */ | opcodes.TEXT /* opcode TEXT */
+    head[1] = payloadLength | 0x80 /* MASK */
+    head[offset - 4] = maskKey[0]
+    head[offset - 3] = maskKey[1]
+    head[offset - 2] = maskKey[2]
+    head[offset - 1] = maskKey[3]
+
+    if (payloadLength === 126) {
+      head.writeUInt16BE(bodyLength, 2)
+    } else if (payloadLength === 127) {
+      head[2] = head[3] = 0
+      head.writeUIntBE(bodyLength, 4, 6)
+    }
+
+    return [head, buffer]
+  }
 }
 
 module.exports = {

package/lib/web/websocket/receiver.js

@@ -3,7 +3,6 @@
 const { Writable } = require('node:stream')
 const assert = require('node:assert')
 const { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require('./constants')
-const { kReadyState, kSentClose, kResponse, kReceivedClose } = require('./symbols')
 const { channels } = require('../../core/diagnostics')
 const {
   isValidStatusCode,
@@ -16,7 +15,6 @@ const {
   isContinuationFrame
 } = require('./util')
 const { WebsocketFrameSend } = require('./frame')
-const { closeWebSocketConnection } = require('./connection')
 const { PerMessageDeflate } = require('./permessage-deflate')
 
 // This code was influenced by ws released under the MIT license.
@@ -37,10 +35,13 @@ class ByteParser extends Writable {
   /** @type {Map<string, PerMessageDeflate>} */
   #extensions
 
-  constructor (ws, extensions) {
+  /** @type {import('./websocket').Handler} */
+  #handler
+
+  constructor (handler, extensions) {
     super()
 
-    this.ws = ws
+    this.#handler = handler
     this.#extensions = extensions == null ? new Map() : extensions
 
     if (this.#extensions.has('permessage-deflate')) {
@@ -86,12 +87,12 @@ class ByteParser extends Writable {
         const rsv3 = buffer[0] & 0x10
 
         if (!isValidOpcode(opcode)) {
-          failWebsocketConnection(this.ws, 'Invalid opcode received')
+          failWebsocketConnection(this.#handler, 1002, 'Invalid opcode received')
           return callback()
         }
 
         if (masked) {
-          failWebsocketConnection(this.ws, 'Frame cannot be masked')
+          failWebsocketConnection(this.#handler, 1002, 'Frame cannot be masked')
           return callback()
         }
 
@@ -105,43 +106,43 @@ class ByteParser extends Writable {
         // WebSocket connection where a PMCE is in use, this bit indicates
         // whether a message is compressed or not.
         if (rsv1 !== 0 && !this.#extensions.has('permessage-deflate')) {
-          failWebsocketConnection(this.ws, 'Expected RSV1 to be clear.')
+          failWebsocketConnection(this.#handler, 1002, 'Expected RSV1 to be clear.')
           return
         }
 
         if (rsv2 !== 0 || rsv3 !== 0) {
-          failWebsocketConnection(this.ws, 'RSV1, RSV2, RSV3 must be clear')
+          failWebsocketConnection(this.#handler, 1002, 'RSV1, RSV2, RSV3 must be clear')
           return
         }
 
         if (fragmented && !isTextBinaryFrame(opcode)) {
           // Only text and binary frames can be fragmented
-          failWebsocketConnection(this.ws, 'Invalid frame type was fragmented.')
+          failWebsocketConnection(this.#handler, 1002, 'Invalid frame type was fragmented.')
           return
         }
 
         // If we are already parsing a text/binary frame and do not receive either
         // a continuation frame or close frame, fail the connection.
         if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) {
-          failWebsocketConnection(this.ws, 'Expected continuation frame')
+          failWebsocketConnection(this.#handler, 1002, 'Expected continuation frame')
           return
         }
 
         if (this.#info.fragmented && fragmented) {
           // A fragmented frame can't be fragmented itself
-          failWebsocketConnection(this.ws, 'Fragmented frame exceeded 125 bytes.')
+          failWebsocketConnection(this.#handler, 1002, 'Fragmented frame exceeded 125 bytes.')
           return
         }
 
         // "All control frames MUST have a payload length of 125 bytes or less
         // and MUST NOT be fragmented."
         if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) {
-          failWebsocketConnection(this.ws, 'Control frame either too large or fragmented')
+          failWebsocketConnection(this.#handler, 1002, 'Control frame either too large or fragmented')
           return
         }
 
         if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) {
-          failWebsocketConnection(this.ws, 'Unexpected continuation frame')
+          failWebsocketConnection(this.#handler, 1002, 'Unexpected continuation frame')
           return
         }
 
@@ -187,7 +188,7 @@ class ByteParser extends Writable {
         // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/common/globals.h;drc=1946212ac0100668f14eb9e2843bdd846e510a1e;bpv=1;bpt=1;l=1275
         // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/js-array-buffer.h;l=34;drc=1946212ac0100668f14eb9e2843bdd846e510a1e
         if (upper > 2 ** 31 - 1) {
-          failWebsocketConnection(this.ws, 'Received payload length > 2^31 bytes.')
+          failWebsocketConnection(this.#handler, 1009, 'Received payload length > 2^31 bytes.')
           return
         }
 
@@ -215,7 +216,7 @@ class ByteParser extends Writable {
             // parsing continuation frames, not here.
             if (!this.#info.fragmented && this.#info.fin) {
               const fullMessage = Buffer.concat(this.#fragments)
-              websocketMessageReceived(this.ws, this.#info.binaryType, fullMessage)
+              websocketMessageReceived(this.#handler, this.#info.binaryType, fullMessage)
               this.#fragments.length = 0
             }
 
@@ -223,7 +224,7 @@ class ByteParser extends Writable {
           } else {
             this.#extensions.get('permessage-deflate').decompress(body, this.#info.fin, (error, data) => {
               if (error) {
-                closeWebSocketConnection(this.ws, 1007, error.message, error.message.length)
+                failWebsocketConnection(this.#handler, 1007, error.message)
                 return
               }
 
@@ -236,7 +237,7 @@ class ByteParser extends Writable {
                 return
               }
 
-              websocketMessageReceived(this.ws, this.#info.binaryType, Buffer.concat(this.#fragments))
+              websocketMessageReceived(this.#handler, this.#info.binaryType, Buffer.concat(this.#fragments))
 
               this.#loop = true
               this.#state = parserStates.INFO
@@ -339,7 +340,7 @@ class ByteParser extends Writable {
 
     if (opcode === opcodes.CLOSE) {
       if (payloadLength === 1) {
-        failWebsocketConnection(this.ws, 'Received close frame with a 1-byte body.')
+        failWebsocketConnection(this.#handler, 1002, 'Received close frame with a 1-byte body.')
         return false
       }
 
@@ -348,12 +349,13 @@ class ByteParser extends Writable {
       if (this.#info.closeInfo.error) {
         const { code, reason } = this.#info.closeInfo
 
-        closeWebSocketConnection(this.ws, code, reason, reason.length)
-        failWebsocketConnection(this.ws, reason)
+        failWebsocketConnection(this.#handler, code, reason)
         return false
       }
 
-      if (this.ws[kSentClose] !== sentCloseFrameState.SENT) {
+      // Upon receiving such a frame, the other peer sends a
+      // Close frame in response, if it hasn't already sent one.
+      if (!this.#handler.closeState.has(sentCloseFrameState.SENT) && !this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
         // If an endpoint receives a Close frame and did not previously send a
         // Close frame, the endpoint MUST send a Close frame in response.  (When
         // sending a Close frame in response, the endpoint typically echos the
@@ -365,21 +367,15 @@ class ByteParser extends Writable {
         }
         const closeFrame = new WebsocketFrameSend(body)
 
-        this.ws[kResponse].socket.write(
-          closeFrame.createFrame(opcodes.CLOSE),
-          (err) => {
-            if (!err) {
-              this.ws[kSentClose] = sentCloseFrameState.SENT
-            }
-          }
-        )
+        this.#handler.socket.write(closeFrame.createFrame(opcodes.CLOSE))
+        this.#handler.closeState.add(sentCloseFrameState.SENT)
       }
 
       // Upon either sending or receiving a Close control frame, it is said
       // that _The WebSocket Closing Handshake is Started_ and that the
       // WebSocket connection is in the CLOSING state.
-      this.ws[kReadyState] = states.CLOSING
-      this.ws[kReceivedClose] = true
+      this.#handler.readyState = states.CLOSING
+      this.#handler.closeState.add(sentCloseFrameState.RECEIVED)
 
       return false
     } else if (opcode === opcodes.PING) {
@@ -388,10 +384,10 @@ class ByteParser extends Writable {
       // A Pong frame sent in response to a Ping frame must have identical
       // "Application data"
 
-      if (!this.ws[kReceivedClose]) {
+      if (!this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
         const frame = new WebsocketFrameSend(body)
 
-        this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG))
+        this.#handler.socket.write(frame.createFrame(opcodes.PONG))
 
         if (channels.ping.hasSubscribers) {
           channels.ping.publish({

package/lib/web/websocket/sender.js

@@ -4,9 +4,6 @@ const { WebsocketFrameSend } = require('./frame')
 const { opcodes, sendHints } = require('./constants')
 const FixedQueue = require('../../dispatcher/fixed-queue')
 
-/** @type {typeof Uint8Array} */
-const FastBuffer = Buffer[Symbol.species]
-
 /**
  * @typedef {object} SendQueueNode
  * @property {Promise<void> | null} promise
@@ -34,16 +31,25 @@ class SendQueue {
 
   add (item, cb, hint) {
     if (hint !== sendHints.blob) {
-      const frame = createFrame(item, hint)
       if (!this.#running) {
-        // fast-path
-        this.#socket.write(frame, cb)
+        // TODO(@tsctx): support fast-path for string on running
+        if (hint === sendHints.text) {
+          // special fast-path for string
+          const { 0: head, 1: body } = WebsocketFrameSend.createFastTextFrame(item)
+          this.#socket.cork()
+          this.#socket.write(head)
+          this.#socket.write(body, cb)
+          this.#socket.uncork()
+        } else {
+          // direct writing
+          this.#socket.write(createFrame(item, hint), cb)
+        }
       } else {
         /** @type {SendQueueNode} */
         const node = {
           promise: null,
           callback: cb,
-          frame
+          frame: createFrame(item, hint)
         }
         this.#queue.push(node)
       }
@@ -86,18 +92,17 @@ class SendQueue {
 }
 
 function createFrame (data, hint) {
-  return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY)
+  return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.text ? opcodes.TEXT : opcodes.BINARY)
 }
 
 function toBuffer (data, hint) {
   switch (hint) {
-    case sendHints.string:
-      return Buffer.from(data)
+    case sendHints.text:
+    case sendHints.typedArray:
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
     case sendHints.arrayBuffer:
     case sendHints.blob:
-      return new FastBuffer(data)
-    case sendHints.typedArray:
-      return new FastBuffer(data.buffer, data.byteOffset, data.byteLength)
+      return new Uint8Array(data)
   }
 }
 

package/lib/web/websocket/stream/websocketerror.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const { webidl } = require('../../fetch/webidl')
+const { validateCloseCodeAndReason } = require('../util')
+const { kConstruct } = require('../../../core/symbols')
+const { kEnumerableProperty } = require('../../../core/util')
+
+class WebSocketError extends DOMException {
+  #closeCode
+  #reason
+
+  constructor (message = '', init = undefined) {
+    message = webidl.converters.DOMString(message, 'WebSocketError', 'message')
+
+    // 1. Set this 's name to " WebSocketError ".
+    // 2. Set this 's message to message .
+    super(message, 'WebSocketError')
+
+    if (init === kConstruct) {
+      return
+    } else if (init !== null) {
+      init = webidl.converters.WebSocketCloseInfo(init)
+    }
+
+    // 3. Let code be init [" closeCode "] if it exists , or null otherwise.
+    let code = init.closeCode ?? null
+
+    // 4. Let reason be init [" reason "] if it exists , or the empty string otherwise.
+    const reason = init.reason ?? ''
+
+    // 5. Validate close code and reason with code and reason .
+    validateCloseCodeAndReason(code, reason)
+
+    // 6. If reason is non-empty, but code is not set, then set code to 1000 ("Normal Closure").
+    if (reason.length !== 0 && code === null) {
+      code = 1000
+    }
+
+    // 7. Set this 's closeCode to code .
+    this.#closeCode = code
+
+    // 8. Set this 's reason to reason .
+    this.#reason = reason
+  }
+
+  get closeCode () {
+    return this.#closeCode
+  }
+
+  get reason () {
+    return this.#reason
+  }
+
+  /**
+   * @param {string} message
+   * @param {number|null} code
+   * @param {string} reason
+   */
+  static createUnvalidatedWebSocketError (message, code, reason) {
+    const error = new WebSocketError(message, kConstruct)
+    error.#closeCode = code
+    error.#reason = reason
+    return error
+  }
+}
+
+const { createUnvalidatedWebSocketError } = WebSocketError
+delete WebSocketError.createUnvalidatedWebSocketError
+
+Object.defineProperties(WebSocketError.prototype, {
+  closeCode: kEnumerableProperty,
+  reason: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'WebSocketError',
+    writable: false,
+    enumerable: false,
+    configurable: true
+  }
+})
+
+webidl.is.WebSocketError = webidl.util.MakeTypeAssertion(WebSocketError.prototype)
+
+module.exports = { WebSocketError, createUnvalidatedWebSocketError }