@fails-components/webtransport 0.3.0 → 1.0.0-rc.1

package/lib/client.js

@@ -1,29 +1,30 @@
-import { Http3WebTransport } from './transport.js'
 import { WebTransportError } from './error.js'
 import { logger } from './utils.js'
 
-const log = logger(`webtransport:http3client(${process.pid})`)
+const pid = typeof process !== 'undefined' ? process.pid : 0
+const log = logger(`webtransport:httpclient(${pid})`)
 
 /**
- * @typedef {import('./session').Http3WTSession} Http3WTSession
- * @typedef {import('./types').Http3ClientInit} Http3ClientInit
+ * @typedef {import('./session').HttpWTSession} HttpWTSession
+ * @typedef {import('./types').HttpClientInit} HttpClientInit
  *
  * Http3Client events
- * @typedef {import('./types').Http3ClientEventHandler} Http3ClientEventHandler
+ * @typedef {import('./types').HttpClientEventHandler} HttpClientEventHandler
  * @typedef {import('./types').ClientConnectedEvent} ClientConnectedEvent
  * @typedef {import('./types').ClientWebtransportSupportEvent} ClientWebtransportSupportEvent
- * @typedef {import('./types').Http3WTSessionVisitorEvent} Http3WTSessionVisitorEvent
+ * @typedef {import('./types').HttpWTSessionVisitorEvent} HttpWTSessionVisitorEvent
  */
 
 /**
- * @implements {Http3ClientEventHandler}
+ * @implements {HttpClientEventHandler}
  */
-export class Http3Client extends Http3WebTransport {
+export class HttpClient {
   /**
-   * @param {Http3ClientInit} args
+   * @param {HttpClientInit} args
    */
   constructor(args) {
-    super(args, 'client')
+    /** @type {HttpClientInit| undefined} */
+    this.args = args
 
     /** @type {{ resolve: (value?: any) => void, reject: (err?: Error) => void} | null | undefined} */
     this.sessionProm = null
@@ -32,7 +33,7 @@ export class Http3Client extends Http3WebTransport {
     this.sessionobj = new Promise((resolve, reject) => {
       this.sessionProm = { resolve, reject }
     }).catch(() => {}) // add default handler if no one cares
-    /** @type {Http3WTSession | null | undefined} */
+    /** @type {HttpWTSession | null | undefined} */
     this.sessionobjint = null
     this.closeHookSession = this.closeHookSession.bind(this)
 
@@ -45,8 +46,13 @@ export class Http3Client extends Http3WebTransport {
     this._webTransportConnectTimeout = args.webTransportConnectTimeout ?? 2000
   }
 
-  async handleConnection() {
-    this.createTransportInt()
+  /**
+   * @param {Object} args
+   * @param {boolean} args.createTransport
+   * @param {string} args.path
+   */
+  async handleConnection({ createTransport, path }) {
+    if (createTransport) this.createTransportInt({ path })
 
     this.quicconnected = new Promise((resolve, reject) => {
       this.quicconnectedProm = { resolve, reject }
@@ -64,13 +70,15 @@ export class Http3Client extends Http3WebTransport {
         delete this.quicconnectedProm
       }
     }, this._quicConnectTimeout)
-
-    await this.quicconnected
-    clearTimeout(timeout)
+    try {
+      await this.quicconnected
+    } finally {
+      clearTimeout(timeout)
+    }
   }
 
   /**
-   * @param {Http3WTSession} sessionobj
+   * @param {HttpWTSession} sessionobj
    * @param {string} path
    * @returns
    */
@@ -108,10 +116,20 @@ export class Http3Client extends Http3WebTransport {
     this.stopped = true
   }
 
+  /**
+   * @param {import('./types').SessionCloseEvent} args
+   */
+  onClientError(args) {
+    if (this.sessionobjint != null) {
+      this.sessionobjint.onClose(args)
+    }
+  }
+
   /**
    * @param {ClientConnectedEvent} args
    */
   onClientConnected(args) {
+    this.transportIntSwitchToReliable = undefined
     if (this.quicconnectedProm) {
       if (args.success) this.quicconnectedProm.resolve()
       else
@@ -119,7 +137,7 @@ export class Http3Client extends Http3WebTransport {
           new WebTransportError('Opening handshake failed.')
         )
       delete this.quicconnectedProm
-    } else
+    } else if (args.success)
       throw new WebTransportError('Client connected with no pending promise')
   }
 
@@ -134,12 +152,12 @@ export class Http3Client extends Http3WebTransport {
   }
 
   /**
-   * @param {Http3WTSessionVisitorEvent} args
+   * @param {HttpWTSessionVisitorEvent} args
    */
-  onHttp3WTSessionVisitor(args) {
-    // create Http3 Visitor
+  onHttpWTSessionVisitor(args) {
+    // create Http Visitor
     if (args.session && this.sessionProm && this.sessionobjint) {
-      this.sessionobjint.setSessionObj(args.session)
+      this.sessionobjint.setSessionObj(args.session, !!args.reliable)
       args.session.jsobj.closeHook = this.closeHookSession
       delete this.sessionobjint
       this.sessionProm.resolve(args.session)
@@ -152,26 +170,49 @@ export class Http3Client extends Http3WebTransport {
   }
 
   /**
-   * @param {ClientConnectedEvent | ClientWebtransportSupportEvent | Http3WTSessionVisitorEvent} args
-   */
-  customCallback(args) {
-    log('callback', args?.purpose)
-    log.trace(args)
-    if (args.purpose) {
-      switch (args.purpose) {
-        case 'ClientConnected':
-          this.onClientConnected(args)
-          break
-        case 'ClientWebtransportSupport':
-          this.onClientWebTransportSupport(args)
-          break
-        case 'Http3WTSessionVisitor':
-          this.onHttp3WTSessionVisitor(args)
-          break
-        default: {
-          throw new WebTransportError('unknown purpose')
+   * @param{{path: string}} [args]
+   **/
+  createTransportInt(args) {
+    const path = args?.path
+    if (this.transportInt != null) {
+      return
+    }
+
+    try {
+      // @ts-ignore
+      if (this.args?.forceReliable || !this.args.createUnreliableClient) {
+        // internal option for unit tests only
+        // @ts-ignore
+        this.transportInt = this.args.createReliableClient(this)
+      } else {
+        // @ts-ignore
+        this.transportInt = this.args.createUnreliableClient(this)
+        if (!this.args?.requireUnreliable) {
+          const args = this.args
+          this.transportIntSwitchToReliable = () => {
+            if (this.transportInt != null) {
+              this.transportInt.closeClient()
+            }
+            // @ts-ignore
+            this.transportInt = args.createReliableClient(this)
+            this.transportInt.jsobj = this
+            if (this.transportInt.createTransport) {
+              this.transportInt.createTransport({ path })
+            }
+            this.transportIntSwitchToReliable = undefined
+          }
         }
       }
+    } catch (/** @type {any} */ err) {
+      const error = new WebTransportError('Opening handshake failed.')
+      error.stack = err.stack
+
+      throw error
+    }
+    delete this.args
+    this.transportInt.jsobj = this
+    if (this.transportInt.createTransport) {
+      this.transportInt.createTransport({ path })
     }
   }
 }

package/lib/dom.ts

@@ -1,5 +1,3 @@
-import type { ReadableStream } from 'node:stream/web'
-
 // Types taken from https://www.w3.org/TR/webtransport
 // These can be removed when they are added to the default typescript types
 
@@ -79,18 +77,18 @@ export interface WebTransportOptions {
   serverCertificateHashes?: WebTransportHash[]
 
   /**
-   * Nonstandard option - when a new connection is opened, how long to wait for the quic handshake to complete in ms before rejecting
+   * Nonstandard option - when a new connection is opened, how long to wait for the quic handshake to complete in ms before rejecting or switching to http2
    */
   quicConnectTimeout?: number
 
    /**
-    * Nonstandard option - when a new connection is opened, how long to wait for the webtransport handshake to complete in ms before rejecting
+    * Nonstandard option - when a new connection is opened, how long to wait for the webtransport handshake to complete in ms before rejecting or switching to http2
     */
   webTransportConnectTimeout?: number
   congestionControl?: WebTransportCongestionControl
 }
 
-export interface WebTransport {
+export interface WebTransportSession {
   getStats: () => Promise<WebTransportStats>
   readonly ready: Promise<void>
   readonly reliability: WebTransportReliabilityMode
@@ -109,6 +107,10 @@ export interface WebTransport {
   readonly incomingUnidirectionalStreams: ReadableStream<WebTransportReceiveStream>
 }
 
+export interface WebTransport extends WebTransportSession {
+  readonly supportsReliableOnly: boolean
+}
+
 export type WebTransportReliabilityMode = 'pending' | 'reliable-only' | 'supports-unreliable'
 export type WebTransportCongestionControl = 'default' | 'throughput' | 'low-latency';
 

package/lib/http2/browser/browser.js

@@ -0,0 +1,168 @@
+import { Http2WebTransportSession } from '../session.js'
+import { BrowserParser } from './browserparser.js'
+import { supportedVersions } from '../websocketcommon.js'
+import { logger } from '../../utils.js'
+
+const log = logger(`webtransport:http2:browser`)
+
+export class Http2WebTransportBrowser {
+  /**
+   * @param {import('../../types.js').NativeClientOptions} args
+   */
+  constructor(args) {
+    this.port = args?.port || 443
+    this.hostname = args?.host || 'localhost'
+    this.initialStreamFlowControlWindow =
+      args?.initialStreamFlowControlWindow || 16 * 1024 // 16 KB
+    this.initialSessionFlowControlWindow =
+      args?.initialSessionFlowControlWindow || 16 * 1024 // 16 KB
+
+    this.streamShouldAutoTuneReceiveWindow =
+      args.streamShouldAutoTuneReceiveWindow || false
+    this.streamFlowControlWindowSizeLimit =
+      args?.streamFlowControlWindowSizeLimit || 6 * 1024 * 1024
+
+    this.sessionShouldAutoTuneReceiveWindow =
+      args.sessionShouldAutoTuneReceiveWindow || false
+    this.sessionFlowControlWindowSizeLimit =
+      args?.sessionFlowControlWindowSizeLimit || 15 * 1024 * 1024
+    /** @type {import('../../session.js').HttpClient} */
+    // @ts-ignore
+    this.jsobj = undefined // the transport will set this
+    /** @type {WebSocket} */
+    // @ts-ignore
+    this.clientInt = undefined
+  }
+
+  /**
+   * @param {{path: string}} arg
+   */
+  createTransport({ path }) {
+    try {
+      let url = 'wss://' + this.hostname + ':' + this.port
+      if (path) url = url + '/' + path
+      // eslint-disable-next-line no-undef
+      this.clientInt = new WebSocket(
+        url,
+        supportedVersions.map(
+          (/** @type {string} */ el) => 'webtransport_' + el
+        )
+      )
+    } catch (error) {
+      log('Failed on WebTransport/Websocket:', error)
+      this.jsobj.onClientConnected({
+        success: false
+      })
+
+      return
+    }
+    this.clientInt.binaryType = 'arraybuffer'
+
+    this.clientInt.addEventListener('open', (event) => {
+      const protocol = this.clientInt?.protocol
+      if (!protocol) {
+        if (this.clientInt) this.clientInt.close()
+        this.jsobj.onClientConnected({
+          success: false
+        })
+      }
+      const aprotocol = protocol.split('_')
+      if (
+        aprotocol.length !== 2 ||
+        aprotocol[0] !== 'webtransport' ||
+        !supportedVersions.includes(aprotocol[1])
+      ) {
+        if (this.clientInt) this.clientInt.close()
+        this.jsobj.onClientConnected({
+          success: false
+        })
+      } else {
+        this.jsobj.onClientWebTransportSupport({})
+        this.jsobj.onClientConnected({
+          success: true
+        })
+      }
+    })
+
+    this.clientInt.addEventListener('error', (error) => {
+      log('Failed on WebTransport/Websocket:', error)
+      if (
+        !this.jsobj?.sessionobjint ||
+        this.jsobj?.sessionobjint?.state === 'connecting'
+      )
+        this.jsobj.onClientConnected({
+          success: false
+        })
+      else {
+        if (this?.jsobj?.sessionobjint?.objint)
+          this.jsobj.sessionobjint.close({
+            closeCode: 0,
+            reason: error.toString()
+          })
+      }
+    })
+  }
+
+  /**
+   * @param {string} path
+   */
+  openWTSession(path) {
+    if (!this.clientInt) throw new Error('clientInt not present')
+    let sessobj
+
+    const retObj = {
+      session: new Http2WebTransportSession({
+        ws: this.clientInt,
+        isclient: true,
+        createParser: (
+          /** @type {Http2WebTransportSession} */ nativesession
+        ) => {
+          sessobj = nativesession
+          const session = new BrowserParser({
+            ws: this.clientInt,
+            nativesession,
+            isclient: true,
+            initialStreamSendWindowOffset: this.initialStreamFlowControlWindow,
+            initialStreamReceiveWindowOffset:
+              this.initialStreamFlowControlWindow,
+            streamShouldAutoTuneReceiveWindow:
+              this.streamShouldAutoTuneReceiveWindow,
+            streamReceiveWindowSizeLimit: this.streamFlowControlWindowSizeLimit
+          })
+          if (this.clientInt)
+            this.clientInt.addEventListener('close', (event) => {
+              let code = event.code
+              let error = 'Session WebSocket closed'
+              if (event.reason) {
+                let tokens = event.reason.split(':')
+                if (tokens.length > 1) {
+                  code = parseInt(tokens[0])
+                  tokens = tokens.slice(1)
+                }
+                error = tokens.join(':')
+              }
+              nativesession.jsobj.onClose({
+                errorcode: code,
+                error
+              })
+            })
+          return session
+        },
+        sendWindowOffset: this.sessionFlowControlWindowSizeLimit,
+        receiveWindowOffset: this.sessionFlowControlWindowSizeLimit,
+        shouldAutoTuneReceiveWindow: this.sessionShouldAutoTuneReceiveWindow,
+        receiveWindowSizeLimit: this.sessionFlowControlWindowSizeLimit
+      }),
+      reliable: true
+    }
+    this.jsobj.onHttpWTSessionVisitor(retObj)
+
+    // @ts-ignore
+    sessobj.jsobj.onReady({})
+  }
+
+  closeClient() {
+    if (this.clientInt && this.clientInt.readyState === 1)
+      this.clientInt.close()
+  }
+}

package/lib/http2/browser/browserparser.js

@@ -0,0 +1,248 @@
+import { ParserBase, lengthVarInt } from '../parserbase.js'
+import { logger } from '../../utils.js'
+
+const log = logger(`webtransport:http2:browserparser`)
+/**
+ * @param{{offset: Number, buffer: Uint8Array, size: Number}} bs
+ */
+function readVarInt(bs) {
+  if (bs.offset + 1 > bs.size) return undefined
+  let val = BigInt(bs.buffer[bs.offset])
+  bs.offset++
+  const prefix = Number(val) >>> 6
+  const intlength = 1 << prefix
+
+  if (bs.offset + intlength - 1 > bs.size) {
+    return undefined
+  }
+  val = val & 0x3fn
+  for (let i = 0; i < intlength - 1; i++) {
+    val = (val << 8n) | BigInt(bs.buffer[bs.offset])
+    bs.offset++
+  }
+  return val
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array, size: Number}} bs
+ * @param{Number|bigint} int
+ */
+export function writeVarInt(bs, int) {
+  let numbytes = 8n
+  let msb = 0xc0n
+  const bint = BigInt(int)
+  if (bint < 64n) {
+    numbytes = 1n
+    msb = 0x0n
+  } else if (bint < 16384n) {
+    numbytes = 2n
+    msb = 0x40n
+  } else if (bint < 1073741824n) {
+    numbytes = 4n
+    msb = 0x80n
+  }
+  bs.buffer[bs.offset] = Number(
+    msb | ((bint >> ((numbytes - 1n) * 8n)) & 0xffn)
+  )
+  bs.offset++
+
+  for (let i = numbytes - 2n; i >= 0n; i--) {
+    bs.buffer[bs.offset] = Number((bint >> (i * 8n)) & 0xffn)
+    bs.offset++
+  }
+}
+
+export class BrowserParser extends ParserBase {
+  static WS_CONTINUE = 0x0
+  static WS_TEXT = 0x1
+  static WS_BINARY = 0x2
+  static WS_CLOSE = 0x8
+  static WS_PING = 0x9
+  static WS_PONG = 0xa
+  /**
+   * @param {import('../../types.js').ParserWebsocketInit} stream
+   */
+  constructor({
+    ws,
+    nativesession,
+    isclient,
+    initialStreamSendWindowOffset,
+    initialStreamReceiveWindowOffset,
+    streamShouldAutoTuneReceiveWindow,
+    streamReceiveWindowSizeLimit
+  }) {
+    super({
+      nativesession,
+      isclient,
+      initialStreamSendWindowOffset,
+      initialStreamReceiveWindowOffset,
+      streamShouldAutoTuneReceiveWindow,
+      streamReceiveWindowSizeLimit
+    })
+    this.ws = ws
+    /** @type {Buffer|undefined} */
+    this.saveddata = undefined
+    /** @type {Number|undefined} */
+    this.rtype = undefined
+
+    this.closesend = false
+
+    this.ws.addEventListener('message', (event) => {
+      if (event.data instanceof ArrayBuffer) {
+        // binary frame
+        this.parseData(new Uint8Array(event.data, 0, event.data.byteLength))
+      } else {
+        // text frame
+        log('Illegal text frame', event.data)
+      }
+    })
+  }
+
+  /**
+   * @param {Uint8Array} data
+   */
+  parseData(data) {
+    const bufferstate = { offset: 0, size: data.byteLength, buffer: data }
+
+    const offsetend = bufferstate.size
+
+    const type = Number(readVarInt(bufferstate))
+
+    switch (type) {
+      case ParserBase.PADDING:
+        // only padding do nothing
+        break
+      case ParserBase.WT_RESET_STREAM:
+      case ParserBase.WT_STOP_SENDING:
+        {
+          const streamid = readVarInt(bufferstate)
+          const stream = this.wtstreams.get(streamid)
+          const code = readVarInt(bufferstate)
+          if (stream && typeof code !== 'undefined')
+            stream.jsobj.onStreamRecvSignal({
+              code,
+              nettask:
+                type === ParserBase.WT_RESET_STREAM
+                  ? 'resetStream'
+                  : 'stopSending'
+            })
+        }
+        break
+      case ParserBase.WT_STREAM_WOFIN:
+      case ParserBase.WT_STREAM_WFIN:
+        {
+          const streamid = Number(readVarInt(bufferstate))
+
+          if (typeof streamid !== 'undefined') {
+            let object = this.wtstreams.get(streamid)
+            if (!object) {
+              object = this.newStream(streamid)
+            }
+            // TODO submit data
+            if (offsetend - bufferstate.offset >= 0) {
+              object.recvData({
+                data: new Uint8Array(
+                  bufferstate.buffer.buffer,
+                  bufferstate.buffer.byteOffset + bufferstate.offset,
+                  offsetend - bufferstate.offset
+                ),
+                fin: type === ParserBase.WT_STREAM_WFIN
+              })
+            }
+          }
+        }
+        break
+      case ParserBase.WT_MAX_DATA:
+        this.onMaxData(readVarInt(bufferstate))
+        break
+      case ParserBase.WT_MAX_STREAM_DATA:
+        this.onMaxStreamData(readVarInt(bufferstate), readVarInt(bufferstate))
+        break
+      case ParserBase.WT_MAX_STREAMS_BIDI:
+        // this.recvSession({ maxstreams: readVarInt(bufferstate), type })
+        break
+      case ParserBase.WT_MAX_STREAMS_UNIDI:
+        // this.recvSession({ maxstreams: readVarInt(bufferstate), type })
+        break
+      case ParserBase.WT_DATA_BLOCKED:
+        this.onDataBlocked(readVarInt(bufferstate))
+        break
+      case ParserBase.WT_STREAM_DATA_BLOCKED:
+        this.onStreamDataBlocked(
+          readVarInt(bufferstate),
+          readVarInt(bufferstate)
+        )
+        break
+      case ParserBase.WT_STREAMS_BLOCKED_UNIDI:
+        /* {
+                 const streamid = readVarInt(bufferstate)
+                  const object = this.wtstreams.get(streamid)
+                  if (object)
+                    this.recvStream({
+                      maxstreams: readVarInt(bufferstate),
+                      type,
+                      object
+                    })
+                } */
+        break
+      case ParserBase.WT_STREAMS_BLOCKED_BIDI:
+        /* {
+                  const streamid = readVarInt(bufferstate)
+                  const object = this.wtstreams.get(streamid)
+                  if (object)
+                    this.recvStream({
+                      maxstreams: readVarInt(bufferstate),
+                      type,
+                      streamid
+                    })
+                } */
+        break
+      case ParserBase.DATAGRAM:
+        this.session.jsobj.onDatagramReceived({
+          datagram: new Uint8Array(
+            bufferstate.buffer.buffer,
+            bufferstate.buffer.byteOffset + bufferstate.offset,
+            offsetend - bufferstate.offset
+          )
+        })
+
+        break
+      default:
+      // do nothing
+    }
+
+    bufferstate.offset = offsetend
+  }
+
+  /**
+   * @param{{type: Number, headerVints: Array<Number|bigint>, payload: Uint8Array|undefined}} bs
+   */
+  writeCapsule({ type, headerVints, payload }) {
+    let plength = 0
+    for (const ind in headerVints) plength += lengthVarInt(headerVints[ind])
+    plength += lengthVarInt(type)
+    const hlength = plength
+    if (payload) plength += payload.byteLength
+
+    const cdata = new Uint8Array(plength)
+    const bufferstate = { offset: 0, size: cdata.length, buffer: cdata }
+    writeVarInt(bufferstate, type)
+    for (const ind in headerVints) writeVarInt(bufferstate, headerVints[ind])
+    const dest = new Uint8Array(cdata.buffer, cdata.byteOffset + hlength)
+    if (payload) dest.set(payload)
+    this.ws.send(cdata)
+
+    /* const blocked = this.ws.bufferedAmount > 1024 * 256
+    // do something if blocked
+    if (blocked) this.blocked = true
+    return blocked */
+    return false
+  }
+
+  /**
+   * @param{{code: Number, reason: string}}arg
+   */
+  sendClose({ code, reason }) {
+    this.ws.close(1000, code.toString() + ':' + reason)
+  }
+}