@yanglaofish/fishtools 0.5.1 → 0.5.3

package/node_modules/undici/lib/web/websocket/connection.js

@@ -1,29 +1,40 @@
 'use strict'
 
 const { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require('./constants')
-const { parseExtensions, isClosed, isClosing, isEstablished, isConnecting, validateCloseCodeAndReason } = require('./util')
+const {
+  kReadyState,
+  kSentClose,
+  kByteParser,
+  kReceivedClose,
+  kResponse
+} = require('./symbols')
+const { fireEvent, failWebsocketConnection, isClosing, isClosed, isEstablished, parseExtensions } = require('./util')
+const { channels } = require('../../core/diagnostics')
+const { CloseEvent } = require('./events')
 const { makeRequest } = require('../fetch/request')
 const { fetching } = require('../fetch/index')
 const { Headers, getHeadersList } = require('../fetch/headers')
 const { getDecodeSplit } = require('../fetch/util')
 const { WebsocketFrameSend } = require('./frame')
-const assert = require('node:assert')
-const { runtimeFeatures } = require('../../util/runtime-features')
 
-const crypto = runtimeFeatures.has('crypto')
-  ? require('node:crypto')
-  : null
+/** @type {import('crypto')} */
+let crypto
+try {
+  crypto = require('node:crypto')
+/* c8 ignore next 3 */
+} catch {
 
-let warningEmitted = false
+}
 
 /**
  * @see https://websockets.spec.whatwg.org/#concept-websocket-establish
  * @param {URL} url
  * @param {string|string[]} protocols
- * @param {import('./websocket').Handler} handler
- * @param {Partial<import('../../../types/websocket').WebSocketInit>} options
+ * @param {import('./websocket').WebSocket} ws
+ * @param {(response: any, extensions: string[] | undefined) => void} onEstablish
+ * @param {Partial<import('../../types/websocket').WebSocketInit>} options
  */
-function establishWebSocketConnection (url, protocols, client, handler, options) {
+function establishWebSocketConnection (url, protocols, client, ws, onEstablish, options) {
   // 1. Let requestURL be a copy of url, with its scheme set to "http", if url’s
   //    scheme is "ws", and to "https" otherwise.
   const requestURL = url
@@ -33,7 +44,7 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
   // 2. Let request be a new request, whose URL is requestURL, client is client,
   //    service-workers mode is "none", referrer is "no-referrer", mode is
   //    "websocket", credentials mode is "include", cache mode is "no-store" ,
-  //    redirect mode is "error", and use-URL-credentials flag is set.
+  //    and redirect mode is "error".
   const request = makeRequest({
     urlList: [requestURL],
     client,
@@ -42,8 +53,7 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
     mode: 'websocket',
     credentials: 'include',
     cache: 'no-store',
-    redirect: 'error',
-    useURLCredentials: true
+    redirect: 'error'
   })
 
   // Note: undici extension, allow setting custom headers.
@@ -65,17 +75,17 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
 
   // 6. Append (`Sec-WebSocket-Key`, keyValue) to request’s
   //    header list.
-  request.headersList.append('sec-websocket-key', keyValue, true)
+  request.headersList.append('sec-websocket-key', keyValue)
 
   // 7. Append (`Sec-WebSocket-Version`, `13`) to request’s
   //    header list.
-  request.headersList.append('sec-websocket-version', '13', true)
+  request.headersList.append('sec-websocket-version', '13')
 
   // 8. For each protocol in protocols, combine
   //    (`Sec-WebSocket-Protocol`, protocol) in request’s header
   //    list.
   for (const protocol of protocols) {
-    request.headersList.append('sec-websocket-protocol', protocol, true)
+    request.headersList.append('sec-websocket-protocol', protocol)
   }
 
   // 9. Let permessageDeflate be a user-agent defined
@@ -85,7 +95,7 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
 
   // 10. Append (`Sec-WebSocket-Extensions`, permessageDeflate) to
   //     request’s header list.
-  request.headersList.append('sec-websocket-extensions', permessageDeflate, true)
+  request.headersList.append('sec-websocket-extensions', permessageDeflate)
 
   // 11. Fetch request with useParallelQueue set to true, and
   //     processResponse given response being these steps:
@@ -96,25 +106,9 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
     processResponse (response) {
       // 1. If response is a network error or its status is not 101,
       //    fail the WebSocket connection.
-      // if (response.type === 'error' || ((response.socket?.session != null && response.status !== 200) && response.status !== 101)) {
       if (response.type === 'error' || response.status !== 101) {
-        // The presence of a session property on the socket indicates HTTP2
-        // HTTP1
-        if (response.socket?.session == null) {
-          failHandshake(handler, response, 1002, 'Received network error or non-101 status code.', response.error)
-          return
-        }
-
-        // HTTP2
-        if (response.status !== 200) {
-          failHandshake(handler, response, 1002, 'Received network error or non-200 status code.', response.error)
-          return
-        }
-      }
-
-      if (warningEmitted === false && response.socket?.session != null) {
-        process.emitWarning('WebSocket over HTTP2 is experimental, and subject to change.', 'ExperimentalWarning')
-        warningEmitted = true
+        failWebsocketConnection(ws, 'Received network error or non-101 status code.')
+        return
       }
 
       // 2. If protocols is not the empty list and extracting header
@@ -122,7 +116,7 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
       //    header list results in null, failure, or the empty byte
       //    sequence, then fail the WebSocket connection.
       if (protocols.length !== 0 && !response.headersList.get('Sec-WebSocket-Protocol')) {
-        failHandshake(handler, response, 1002, 'Server did not respond with sent protocols.')
+        failWebsocketConnection(ws, 'Server did not respond with sent protocols.')
         return
       }
 
@@ -136,9 +130,8 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
       //    header field contains a value that is not an ASCII case-
       //    insensitive match for the value "websocket", the client MUST
       //    _Fail the WebSocket Connection_.
-      //    For H2, no upgrade header is expected.
-      if (response.socket.session == null && response.headersList.get('Upgrade')?.toLowerCase() !== 'websocket') {
-        failHandshake(handler, response, 1002, 'Server did not set Upgrade header to "websocket".')
+      if (response.headersList.get('Upgrade')?.toLowerCase() !== 'websocket') {
+        failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".')
         return
       }
 
@@ -146,9 +139,8 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
       //    |Connection| header field doesn't contain a token that is an
       //    ASCII case-insensitive match for the value "Upgrade", the client
       //    MUST _Fail the WebSocket Connection_.
-      //    For H2, no connection header is expected.
-      if (response.socket.session == null && response.headersList.get('Connection')?.toLowerCase() !== 'upgrade') {
-        failHandshake(handler, response, 1002, 'Server did not set Connection header to "upgrade".')
+      if (response.headersList.get('Connection')?.toLowerCase() !== 'upgrade') {
+        failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".')
         return
       }
 
@@ -159,15 +151,11 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
       //    E914-47DA-95CA-C5AB0DC85B11" but ignoring any leading and
       //    trailing whitespace, the client MUST _Fail the WebSocket
       //    Connection_.
-      //    For H2, implementations "do not do the processing of the Sec-WebSocket-Key and
-      //    Sec-WebSocket-Accept header fields". https://datatracker.ietf.org/doc/html/rfc8441#section-5
-      if (response.socket.session == null) {
-        const secWSAccept = response.headersList.get('Sec-WebSocket-Accept')
-        const digest = crypto.hash('sha1', keyValue + uid, 'base64')
-        if (secWSAccept !== digest) {
-          failHandshake(handler, response, 1002, 'Incorrect hash received in Sec-WebSocket-Accept header.')
-          return
-        }
+      const secWSAccept = response.headersList.get('Sec-WebSocket-Accept')
+      const digest = crypto.createHash('sha1').update(keyValue + uid).digest('base64')
+      if (secWSAccept !== digest) {
+        failWebsocketConnection(ws, 'Incorrect hash received in Sec-WebSocket-Accept header.')
+        return
       }
 
       // 5. If the response includes a |Sec-WebSocket-Extensions| header
@@ -184,7 +172,7 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
         extensions = parseExtensions(secExtension)
 
         if (!extensions.has('permessage-deflate')) {
-          failHandshake(handler, response, 1002, 'Sec-WebSocket-Extensions header does not match.')
+          failWebsocketConnection(ws, 'Sec-WebSocket-Extensions header does not match.')
           return
         }
       }
@@ -205,61 +193,52 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
         // the selected subprotocol values in its response for the connection to
         // be established.
         if (requestProtocols === null || !requestProtocols.includes(secProtocol)) {
-          failHandshake(handler, response, 1002, 'Protocol was not set in the opening handshake.')
+          failWebsocketConnection(ws, 'Protocol was not set in the opening handshake.')
           return
         }
       }
 
-      // For H2, "Orderly TCP-level closures are represented as END_STREAM flags", so
-      // end our side of the stream when the server ends its side, as a TCP socket would.
-      // https://datatracker.ietf.org/doc/html/rfc8441#section-5
-      if (response.socket.session != null) {
-        response.socket.allowHalfOpen = false
-      }
+      response.socket.on('data', onSocketData)
+      response.socket.on('close', onSocketClose)
+      response.socket.on('error', onSocketError)
 
-      response.socket.on('data', handler.onSocketData)
-      response.socket.on('close', handler.onSocketClose)
-      response.socket.on('error', handler.onSocketError)
+      if (channels.open.hasSubscribers) {
+        channels.open.publish({
+          address: response.socket.address(),
+          protocol: secProtocol,
+          extensions: secExtension
+        })
+      }
 
-      handler.wasEverConnected = true
-      handler.onConnectionEstablished(response, extensions)
+      onEstablish(response, extensions)
     }
   })
 
   return controller
 }
 
-/**
- * @see https://whatpr.org/websockets/48.html#close-the-websocket
- * @param {import('./websocket').Handler} object
- * @param {number} [code=null]
- * @param {string} [reason='']
- */
-function closeWebSocketConnection (object, code, reason, validate = false) {
-  // 1. If code was not supplied, let code be null.
-  code ??= null
-
-  // 2. If reason was not supplied, let reason be the empty string.
-  reason ??= ''
-
-  // 3. Validate close code and reason with code and reason.
-  if (validate) validateCloseCodeAndReason(code, reason)
-
-  // 4. Run the first matching steps from the following list:
-  //     - If object’s ready state is CLOSING (2) or CLOSED (3)
-  //     - If the WebSocket connection is not yet established [WSP]
-  //     - If the WebSocket closing handshake has not yet been started [WSP]
-  //     - Otherwise
-  if (isClosed(object.readyState) || isClosing(object.readyState)) {
+function closeWebSocketConnection (ws, code, reason, reasonByteLength) {
+  if (isClosing(ws) || isClosed(ws)) {
+    // If this's ready state is CLOSING (2) or CLOSED (3)
     // Do nothing.
-  } else if (!isEstablished(object.readyState)) {
-    // Fail the WebSocket connection and set object’s ready state to CLOSING (2). [WSP]
-    failWebsocketConnection(object)
-    object.readyState = states.CLOSING
-  } else if (!object.closeState.has(sentCloseFrameState.SENT) && !object.closeState.has(sentCloseFrameState.RECEIVED)) {
-    // 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.
+  } else if (!isEstablished(ws)) {
+    // If the WebSocket connection is not yet established
+    // Fail the WebSocket connection and set this's ready state
+    // to CLOSING (2).
+    failWebsocketConnection(ws, 'Connection was closed before it was established.')
+    ws[kReadyState] = states.CLOSING
+  } else if (ws[kSentClose] === sentCloseFrameState.NOT_SENT) {
+    // If the WebSocket closing handshake has not yet been started
+    // Start the WebSocket closing handshake and set this's ready
+    // state to CLOSING (2).
+    // - If neither code nor reason is present, the WebSocket Close
+    //   message must not have a body.
+    // - If code is present, then the status code to use in the
+    //   WebSocket Close message must be the integer given by code.
+    // - If reason is also present, then reasonBytes must be
+    //   provided in the Close message after the status code.
+
+    ws[kSentClose] = sentCloseFrameState.PROCESSING
 
     const frame = new WebsocketFrameSend()
 
@@ -268,24 +247,13 @@ function closeWebSocketConnection (object, code, reason, validate = false) {
 
     // If code is present, then the status code to use in the
     // WebSocket Close message must be the integer given by code.
-    // If code is null and reason is the empty string, the WebSocket Close frame must not have a body.
-    // If reason is non-empty but code is null, then set code to 1000 ("Normal Closure").
-    if (reason.length !== 0 && code === null) {
-      code = 1000
-    }
-
-    // If code is set, then the status code to use in the WebSocket Close frame must be the integer given by code.
-    assert(code === null || Number.isInteger(code))
-
-    if (code === null && reason.length === 0) {
-      frame.frameData = emptyBuffer
-    } else if (code !== null && reason === null) {
+    if (code !== undefined && reason === undefined) {
       frame.frameData = Buffer.allocUnsafe(2)
       frame.frameData.writeUInt16BE(code, 0)
-    } else if (code !== null && reason !== null) {
+    } else if (code !== undefined && reason !== undefined) {
       // If reason is also present, then reasonBytes must be
       // provided in the Close message after the status code.
-      frame.frameData = Buffer.allocUnsafe(2 + Buffer.byteLength(reason))
+      frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength)
       frame.frameData.writeUInt16BE(code, 0)
       // the body MAY contain UTF-8-encoded data with value /reason/
       frame.frameData.write(reason, 2, 'utf-8')
@@ -293,58 +261,111 @@ function closeWebSocketConnection (object, code, reason, validate = false) {
       frame.frameData = emptyBuffer
     }
 
-    object.socket.write(frame.createFrame(opcodes.CLOSE))
+    /** @type {import('stream').Duplex} */
+    const socket = ws[kResponse].socket
+
+    socket.write(frame.createFrame(opcodes.CLOSE))
 
-    object.closeState.add(sentCloseFrameState.SENT)
+    ws[kSentClose] = 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.
-    object.readyState = states.CLOSING
+    ws[kReadyState] = states.CLOSING
   } else {
-    // Set object’s ready state to CLOSING (2).
-    object.readyState = states.CLOSING
+    // Otherwise
+    // Set this's ready state to CLOSING (2).
+    ws[kReadyState] = states.CLOSING
   }
 }
 
-function failHandshake (handler, response, code, reason, cause) {
-  // The H2 upgrade request has already completed and handed off its stream.
-  // Aborting the request cannot close that stream after handshake validation fails.
-  if (response.socket?.session != null && !response.socket.destroyed) {
-    response.socket.destroy()
+/**
+ * @param {Buffer} chunk
+ */
+function onSocketData (chunk) {
+  if (!this.ws[kByteParser].write(chunk)) {
+    this.pause()
   }
-
-  failWebsocketConnection(handler, code, reason, cause)
 }
 
 /**
- * @param {import('./websocket').Handler} handler
- * @param {number} code
- * @param {string|undefined} reason
- * @param {unknown} cause
- * @returns {void}
+ * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
+ * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4
  */
-function failWebsocketConnection (handler, code, reason, cause) {
-  // If _The WebSocket Connection is Established_ prior to the point where
-  // the endpoint is required to _Fail the WebSocket Connection_, the
-  // endpoint SHOULD send a Close frame with an appropriate status code
-  // (Section 7.4) before proceeding to _Close the WebSocket Connection_.
-  if (isEstablished(handler.readyState)) {
-    closeWebSocketConnection(handler, code, reason, false)
+function onSocketClose () {
+  const { ws } = this
+  const { [kResponse]: response } = ws
+
+  response.socket.off('data', onSocketData)
+  response.socket.off('close', onSocketClose)
+  response.socket.off('error', onSocketError)
+
+  // If the TCP connection was closed after the
+  // WebSocket closing handshake was completed, the WebSocket connection
+  // is said to have been closed _cleanly_.
+  const wasClean = ws[kSentClose] === sentCloseFrameState.SENT && ws[kReceivedClose]
+
+  let code = 1005
+  let reason = ''
+
+  const result = ws[kByteParser].closingInfo
+
+  if (result && !result.error) {
+    code = result.code ?? 1005
+    reason = result.reason
+  } else if (!ws[kReceivedClose]) {
+    // If _The WebSocket
+    // Connection is Closed_ and no Close control frame was received by the
+    // endpoint (such as could occur if the underlying transport connection
+    // is lost), _The WebSocket Connection Close Code_ is considered to be
+    // 1006.
+    code = 1006
+  }
+
+  // 1. Change the ready state to CLOSED (3).
+  ws[kReadyState] = states.CLOSED
+
+  // 2. If the user agent was required to fail the WebSocket
+  //    connection, or if the WebSocket connection was closed
+  //    after being flagged as full, fire an event named error
+  //    at the WebSocket object.
+  // TODO
+
+  // 3. Fire an event named close at the WebSocket object,
+  //    using CloseEvent, with the wasClean attribute
+  //    initialized to true if the connection closed cleanly
+  //    and false otherwise, the code attribute initialized to
+  //    the WebSocket connection close code, and the reason
+  //    attribute initialized to the result of applying UTF-8
+  //    decode without BOM to the WebSocket connection close
+  //    reason.
+  // TODO: process.nextTick
+  fireEvent('close', ws, (type, init) => new CloseEvent(type, init), {
+    wasClean, code, reason
+  })
+
+  if (channels.close.hasSubscribers) {
+    channels.close.publish({
+      websocket: ws,
+      code,
+      reason
+    })
   }
+}
 
-  handler.controller.abort()
+function onSocketError (error) {
+  const { ws } = this
 
-  if (isConnecting(handler.readyState)) {
-    // If the connection was not established, we must still emit an 'error' and 'close' events
-    handler.onSocketClose()
-  } else if (handler.socket?.destroyed === false) {
-    handler.socket.destroy()
+  ws[kReadyState] = states.CLOSING
+
+  if (channels.socketError.hasSubscribers) {
+    channels.socketError.publish(error)
   }
+
+  this.destroy()
 }
 
 module.exports = {
   establishWebSocketConnection,
-  failWebsocketConnection,
   closeWebSocketConnection
 }

package/node_modules/undici/lib/web/websocket/constants.js

@@ -1,32 +1,18 @@
 'use strict'
 
-/**
- * This is a Globally Unique Identifier unique used to validate that the
- * endpoint accepts websocket connections.
- * @see https://www.rfc-editor.org/rfc/rfc6455.html#section-1.3
- * @type {'258EAFA5-E914-47DA-95CA-C5AB0DC85B11'}
- */
+// This is a Globally Unique Identifier unique used
+// to validate that the endpoint accepts websocket
+// connections.
+// See https://www.rfc-editor.org/rfc/rfc6455.html#section-1.3
 const uid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
 
-/**
- * @type {PropertyDescriptor}
- */
+/** @type {PropertyDescriptor} */
 const staticPropertyDescriptors = {
   enumerable: true,
   writable: false,
   configurable: false
 }
 
-/**
- * The states of the WebSocket connection.
- *
- * @readonly
- * @enum
- * @property {0} CONNECTING
- * @property {1} OPEN
- * @property {2} CLOSING
- * @property {3} CLOSED
- */
 const states = {
   CONNECTING: 0,
   OPEN: 1,
@@ -34,31 +20,12 @@ const states = {
   CLOSED: 3
 }
 
-/**
- * @readonly
- * @enum
- * @property {0} NOT_SENT
- * @property {1} PROCESSING
- * @property {2} SENT
- */
 const sentCloseFrameState = {
-  SENT: 1,
-  RECEIVED: 2
+  NOT_SENT: 0,
+  PROCESSING: 1,
+  SENT: 2
 }
 
-/**
- * The WebSocket opcodes.
- *
- * @readonly
- * @enum
- * @property {0x0} CONTINUATION
- * @property {0x1} TEXT
- * @property {0x2} BINARY
- * @property {0x8} CLOSE
- * @property {0x9} PING
- * @property {0xA} PONG
- * @see https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
- */
 const opcodes = {
   CONTINUATION: 0x0,
   TEXT: 0x1,
@@ -68,23 +35,8 @@ const opcodes = {
   PONG: 0xA
 }
 
-/**
- * The maximum value for an unsigned 16-bit integer.
- *
- * @type {65535} 2 ** 16 - 1
- */
-const maxUnsigned16Bit = 65535
+const maxUnsigned16Bit = 2 ** 16 - 1 // 65535
 
-/**
- * The states of the parser.
- *
- * @readonly
- * @enum
- * @property {0} INFO
- * @property {2} PAYLOADLENGTH_16
- * @property {3} PAYLOADLENGTH_64
- * @property {4} READ_DATA
- */
 const parserStates = {
   INFO: 0,
   PAYLOADLENGTH_16: 2,
@@ -92,22 +44,10 @@ const parserStates = {
   READ_DATA: 4
 }
 
-/**
- * An empty buffer.
- *
- * @type {Buffer}
- */
 const emptyBuffer = Buffer.allocUnsafe(0)
 
-/**
- * @readonly
- * @property {1} text
- * @property {2} typedArray
- * @property {3} arrayBuffer
- * @property {4} blob
- */
 const sendHints = {
-  text: 1,
+  string: 1,
   typedArray: 2,
   arrayBuffer: 3,
   blob: 4