@fails-components/webtransport 0.3.1 → 1.0.1

package/lib/http2/parserbase.js

@@ -0,0 +1,139 @@
+import { Http2WebTransportStream } from './stream.js'
+
+/**
+ * @param{Number|bigint} int
+ * @returns {Number}
+ */
+export function lengthVarInt(int) {
+  if (BigInt(int) < 64n) return 1
+  if (BigInt(int) < 16384n) return 2
+  if (BigInt(int) < 1073741824n) return 4
+  /* if (BigInt(int) < 4611686018427387904 ) */
+  return 8
+}
+
+export class ParserBase {
+  static PADDING = 0x190b4d38
+  static WT_RESET_STREAM = 0x190b4d39
+  static WT_STOP_SENDING = 0x190b4d3a
+  static WT_STREAM_WOFIN = 0x190b4d3b
+  static WT_STREAM_WFIN = 0x190b4d3c
+  static WT_MAX_DATA = 0x190b4d3d
+  static WT_MAX_STREAM_DATA = 0x190b4d3e
+  static WT_MAX_STREAMS_BIDI = 0x190b4d3f
+  static WT_MAX_STREAMS_UNIDI = 0x190b4d40
+  static WT_DATA_BLOCKED = 0x190b4d41
+  static WT_STREAM_DATA_BLOCKED = 0x190b4d42
+  static WT_STREAMS_BLOCKED_UNIDI = 0x190b4d43
+  static WT_STREAMS_BLOCKED_BIDI = 0x190b4d44
+  static DATAGRAM = 0x00
+
+  /**
+   * @param {import('../types').ParserInit} arg
+   */
+  constructor({
+    nativesession,
+    isclient,
+    initialStreamSendWindowOffset,
+    initialStreamReceiveWindowOffset,
+    streamShouldAutoTuneReceiveWindow,
+    streamReceiveWindowSizeLimit
+  }) {
+    this.session = nativesession
+    this.isclient = isclient
+    /** @type {boolean} */
+    this.blocked = false
+
+    this.initialStreamSendWindowOffset = initialStreamSendWindowOffset
+    this.initialStreamReceiveWindowOffset = initialStreamReceiveWindowOffset
+    this.streamShouldAutoTuneReceiveWindow = streamShouldAutoTuneReceiveWindow
+    this.streamReceiveWindowSizeLimit = streamReceiveWindowSizeLimit
+
+    this.wtstreams = new Map()
+  }
+
+  /**
+   * @abstract
+   * @param {Buffer|Uint8Array} data
+   */
+  parseData(data) {
+    throw new Error('Implement parseData in derived Class')
+  }
+
+  /**
+   * @abstract
+   * @param{{type: Number, headerVints: Array<Number|bigint>, payload: Uint8Array|undefined}} bs
+   */
+  writeCapsule({ type, headerVints, payload }) {
+    throw new Error('Implement writeCapsule in derived Class')
+  }
+
+  /**
+   * @param{{code: Number, reason: string}}arg
+   */
+  sendClose({ code, reason }) {}
+
+  /**
+   * @param {Number} streamid
+   */
+  newStream(streamid) {
+    const stream = new Http2WebTransportStream({
+      streamid,
+      capsuleParser: this,
+      sendWindowOffset: this.initialStreamSendWindowOffset,
+      receiveWindowOffset: this.initialStreamReceiveWindowOffset,
+      shouldAutoTuneReceiveWindow: this.streamShouldAutoTuneReceiveWindow,
+      receiveWindowSizeLimit: this.streamReceiveWindowSizeLimit,
+      sessionFlowController: this.session.flowController
+    })
+    this.wtstreams.set(streamid, stream)
+    this.session.jsobj.onStream({
+      bidirectional: !(streamid & 0x2),
+      incoming: this.isclient ? !(streamid & 0x1) : !!(streamid & 0x1),
+      stream
+    })
+    return stream
+  }
+
+  drainWrites() {
+    for (const stream of this.wtstreams.values()) {
+      stream.drainWrites()
+    }
+  }
+
+  /**
+   * @param {bigint|undefined} val
+   */
+  onMaxData(val) {
+    if (val && this.session.flowController.updateSendWindowOffset(val))
+      this.drainWrites()
+  }
+
+  /**
+   * @param {bigint|undefined} streamid
+   * @param {bigint|undefined} offset
+   */
+  onMaxStreamData(streamid, offset) {
+    const object = this.wtstreams.get(Number(streamid))
+    if (object && offset) {
+      if (object.flowController.updateSendWindowOffset(offset))
+        object.drainWrites()
+    }
+  }
+
+  /**
+   * @param {bigint|undefined} val
+   */
+  onDataBlocked(val) {
+    this.session.flowController.reportBlocked(val)
+  }
+
+  /**
+   * @param {bigint|undefined} streamid
+   * @param {bigint|undefined} offset
+   */
+  onStreamDataBlocked(streamid, offset) {
+    const object = this.wtstreams.get(Number(streamid))
+    if (object && offset) object.flowController.reportBlocked(offset)
+  }
+}

package/lib/http2/parserbasehttp2.js

@@ -0,0 +1,128 @@
+import { ParserBase } from './parserbase.js'
+
+/**
+ * @typedef {import('node:http2').Http2Stream} Http2Stream
+ */
+
+/**
+ * @param{{offset: Number, buffer: Buffer, size: Number}} bs
+ */
+export function readVarInt(bs) {
+  if (bs.offset + 1 > bs.size) return undefined
+  let val = BigInt(bs.buffer.readUInt8(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.readUInt8(bs.offset))
+    bs.offset++
+  }
+  return val
+}
+
+/**
+ * @param{{offset: Number, buffer: Buffer, size: Number}} bs
+ * @param{Number|bigint} int
+ */
+export function writeVarInt(bs, int) {
+  let numbytes = 8n
+  let msb = 0xc0n
+  const bint = BigInt(int)
+  if (bint < 64) {
+    numbytes = 1n
+    msb = 0x0n
+  } else if (bint < 16384) {
+    numbytes = 2n
+    msb = 0x40n
+  } else if (bint < 1073741824) {
+    numbytes = 4n
+    msb = 0x80n
+  }
+  bs.buffer.writeUInt8(
+    Number(msb | ((bint >> ((numbytes - 1n) * 8n)) & 0xffn)),
+    bs.offset
+  )
+  bs.offset++
+
+  for (let i = numbytes - 2n; i >= 0; i--) {
+    bs.buffer.writeUInt8(Number((bint >> (i * 8n)) & 0xffn), bs.offset)
+    bs.offset++
+  }
+}
+
+export class ParserBaseHttp2 extends ParserBase {
+  /**
+   * @param {import('../types').ParserHttp2Init} stream
+   */
+  constructor({
+    stream,
+    nativesession,
+    isclient,
+    initialStreamSendWindowOffset,
+    initialStreamReceiveWindowOffset,
+    streamShouldAutoTuneReceiveWindow,
+    streamReceiveWindowSizeLimit
+  }) {
+    super({
+      nativesession,
+      isclient,
+      initialStreamSendWindowOffset,
+      initialStreamReceiveWindowOffset,
+      streamShouldAutoTuneReceiveWindow,
+      streamReceiveWindowSizeLimit
+    })
+    this.stream = stream
+    this.session = nativesession
+    this.isclient = isclient
+
+    this.stream.on('readable', () => {
+      let data
+      while ((data = this.stream.read()) !== null) {
+        this.parseData(data)
+      }
+    })
+
+    this.stream.on('end', () => {
+      // readable end
+    })
+
+    this.stream.on(
+      'error',
+      /**
+       * @param {Error} error
+       */ (error) => {
+        // readable error
+        this.session.jsobj.onClose({
+          errorcode: this.stream.rstCode,
+          error: error.toString()
+        })
+      }
+    )
+
+    this.stream.on('drain', () => {
+      // writable, can write more data
+      this.blocked = false
+      this.drainWrites()
+    })
+
+    this.stream.on('close', () => {
+      if (
+        !(
+          this.session.jsobj.state === 'failed' ||
+          this.session.jsobj.state === 'closed'
+        )
+      ) {
+        // writable close
+        this.session.jsobj.onClose({
+          errorcode: this.stream.rstCode || 0,
+          error: ''
+        })
+      }
+    })
+  }
+}

package/lib/http2/session.js

@@ -0,0 +1,225 @@
+/**
+ * @typedef {import('http2').Http2Stream} Http2Stream
+ */
+import { ParserBase } from './parserbase.js'
+import { FlowController } from './flowcontroller.js'
+import { logger } from '../utils.js'
+
+const pid = typeof process !== 'undefined' ? process.pid : 0
+const log = logger(`webtransport:http2webtransportsession(${pid})`)
+
+let processnextTick = (/** @type {{ (args: any[]): any }} */ func) =>
+  setTimeout(func, 0)
+// @ts-ignore
+if (typeof process !== 'undefined') processnextTick = process.nextTick
+
+export class Http2WebTransportSession {
+  /**
+   * @param {{stream?: Http2Stream, ws?: WebSocket, isclient:boolean,
+   * createParser:import('../types.js').CreateParserFunction
+   * sendWindowOffset: Number,
+   * receiveWindowOffset: Number,
+   * shouldAutoTuneReceiveWindow: boolean
+   * receiveWindowSizeLimit: Number}} args
+   * */
+  constructor({
+    stream,
+    ws,
+    isclient,
+    createParser,
+    sendWindowOffset,
+    receiveWindowOffset,
+    shouldAutoTuneReceiveWindow,
+    receiveWindowSizeLimit
+  }) {
+    // @ts-ignore
+    this.jsobj = undefined // the creator will set this
+    if (stream) {
+      this.stream = stream
+    } else if (ws) {
+      this.ws = ws
+    } else throw new Error('Neither stream or websocket supplied')
+    this.capsParser = createParser(this)
+    this.unidiId = 0
+    this.bidiId = 0
+    this.isclient = isclient
+    this.flowController = new FlowController({
+      tocontrol: this,
+      sendWindowOffset,
+      receiveWindowOffset,
+      shouldAutoTuneReceiveWindow,
+      receiveWindowSizeLimit
+    })
+    if (stream) {
+      if (isclient) {
+        stream.on('response', (headers) => {
+          processnextTick(() => {
+            if (headers[':status'] === 200) {
+              // on ready
+              this.jsobj.onReady({})
+            } else {
+              this.jsobj.onClose({
+                errorcode: headers[':status'],
+                error: 'Session stream errored'
+              })
+            }
+          })
+        })
+      } else {
+        processnextTick(() => {
+          this.jsobj.onReady({})
+        })
+      }
+    }
+  }
+
+  sendInitialParameters() {
+    this.flowController.sendWindowUpdate()
+    this.capsParser.writeCapsule({
+      type: ParserBase.WT_MAX_STREAMS_BIDI,
+      headerVints: [0xffffff],
+      payload: undefined
+    })
+    this.capsParser.writeCapsule({
+      type: ParserBase.WT_MAX_STREAMS_UNIDI,
+      headerVints: [0xffffff],
+      payload: undefined
+    })
+  }
+
+  /**
+   * @param {Uint8Array} chunk
+   */
+  writeDatagram(chunk) {
+    this.capsParser.writeCapsule({
+      type: ParserBase.DATAGRAM,
+      headerVints: [],
+      payload: chunk
+    })
+    processnextTick(() => {
+      this.jsobj.onDatagramSend({})
+    })
+  }
+
+  orderUnidiStream() {
+    let streamid = 0x2 | (this.unidiId << 2)
+    if (this.isclient) streamid = streamid | 0x1
+    this.capsParser.writeCapsule({
+      type: ParserBase.WT_STREAM_WOFIN,
+      headerVints: [streamid],
+      payload: undefined
+    })
+    this.capsParser.newStream(streamid)
+    this.unidiId++
+  }
+
+  orderBidiStream() {
+    let streamid = 0x0 | (this.bidiId << 2)
+    if (this.isclient) streamid = streamid | 0x1
+    this.capsParser.writeCapsule({
+      type: ParserBase.WT_STREAM_WOFIN,
+      headerVints: [streamid],
+      payload: undefined
+    })
+    this.capsParser.newStream(streamid)
+    this.bidiId++
+  }
+
+  orderSessionStats() {
+    this.jsobj.onSessionStats({
+      timestamp: 0,
+      expiredOutgoing: 0n,
+      lostOutgoing: 0n,
+      // non Datagram
+      minRtt: 0,
+      smoothedRtt: 0,
+      rttVariation: 0,
+      estimatedSendRateBps: 0n
+    })
+  }
+
+  orderDatagramStats() {
+    this.jsobj.onDatagramStats({
+      timestamp: 0,
+      expiredOutgoing: 0n,
+      lostOutgoing: 0n
+    })
+  }
+
+  /*
+   * @returns {void}
+   */
+  notifySessionDraining() {}
+  /**
+   * @param {{ code: number, reason: string }} arg
+   */
+  close({ code, reason }) {
+    this.capsParser.sendClose({ code, reason }) // this includes for ws closing the session!
+    // what to do with the reason
+    if (this.stream) {
+      if (this.stream.close) {
+        this.stream.close(code)
+        this.stream.destroy()
+      } else if (this.stream.end) this.stream.end()
+      else throw new Error('http2:session not close method')
+    }
+  }
+
+  /**
+   * @param {bigint} windowOffset
+   */
+  sendWindowUpdate(windowOffset) {
+    this.capsParser.writeCapsule({
+      type: ParserBase.WT_MAX_DATA,
+      headerVints: [windowOffset],
+      payload: undefined
+    })
+  }
+
+  /**
+   * @param {bigint} pos
+   */
+  reportBlocked(pos) {
+    log('Session was blocked at:', pos)
+  }
+
+  /**
+   * @param {bigint} windowOffset
+   */
+  sendBlocked(windowOffset) {
+    this.capsParser.writeCapsule({
+      type: ParserBase.WT_DATA_BLOCKED,
+      headerVints: [windowOffset],
+      payload: undefined
+    })
+  }
+
+  connected() {
+    return this.jsobj.state === 'connected'
+  }
+
+  /**
+   * @param {{ code: number, reason: string }} arg
+   */
+  closeConnection({ code, reason }) {
+    console.trace()
+    // called in case of failure in parsing or flowcontrol
+    this.jsobj.onClose({
+      errorcode: code,
+      error: reason
+    })
+    this.close({ code, reason })
+  }
+
+  smoothedRtt() {
+    if (this.stream) {
+      // we are on node
+      // @ts-ignore
+      return this.stream.session?.WTrtt || 26
+    } else if (this.ws) {
+      // we are at the Browser, so we use the connection rtt?
+      // @ts-ignore
+      return navigator?.connection?.rtt || 26
+    }
+  }
+}