@fails-components/webtransport 0.3.1 → 1.0.1

package/lib/http2/flowcontroller.js

@@ -0,0 +1,371 @@
+import { logger } from '../utils.js'
+
+/**
+ * @typedef {import('../types').FlowControlable} FlowControlable
+ */
+
+const pid = typeof process !== 'undefined' ? process.pid : 0
+const log = logger(`webtransport:flowcontroller(${pid})`)
+// Ported from libquiche, QuicFlowController so their license applies to the original in C++ and this javascript translation
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export class FlowController {
+  static kSessionFlowControlMultiplier = 1.5
+
+  /**
+   * @param {{tocontrol: FlowControlable
+   * sendWindowOffset: number,
+   * receiveWindowOffset: number,
+   * shouldAutoTuneReceiveWindow: boolean
+   * receiveWindowSizeLimit: number,
+   * sessionFlowController?: FlowController}} arg
+   */
+
+  constructor({
+    tocontrol,
+    sendWindowOffset,
+    receiveWindowOffset,
+    receiveWindowSizeLimit,
+    shouldAutoTuneReceiveWindow,
+    sessionFlowController
+  }) {
+    this.tocontrol = tocontrol
+    this.bytesSent = 0n
+    this.sendWindowOffset = BigInt(sendWindowOffset)
+    this.bytesConsumed = 0n
+    this.highestReceivedByteOffset = 0n
+    this.receiveWindowOffset = BigInt(receiveWindowOffset)
+    this.receiveWindowSize = BigInt(receiveWindowOffset)
+    this.receiveWindowSizeLimit = BigInt(receiveWindowSizeLimit)
+    this.autoTuneReceiveWindow = shouldAutoTuneReceiveWindow
+    this.sessionFlowController = sessionFlowController
+    this.lastBlockedSendWindowOffset = 0n
+    this.prevWindowUpdateTime = undefined
+
+    log(
+      'Created flow controller ' +
+        ', setting initial receive window offset to: ' +
+        this.receiveWindowOffset +
+        ', max receive window to: ' +
+        this.receiveWindowSize +
+        ', max receive window limit to: ' +
+        this.receiveWindowSizeLimit +
+        ', setting send window offset to: ' +
+        this.sendWindowOffset
+    )
+  }
+
+  /**
+   * @param {Number} bytesConsumed
+   */
+  addBytesConsumed(bytesConsumed) {
+    this.bytesConsumed += BigInt(bytesConsumed)
+    log(' consumed ' + bytesConsumed + ' bytes.')
+
+    this.maybeSendWindowUpdate()
+  }
+
+  /**
+   * @param {Number} increaseOffset
+   */
+  updateHighestReceivedOffset(increaseOffset) {
+    // Only update if offset has increased.
+    /* if (newOffset <= this.highestReceivedByteOffset) {
+      return false
+    } */
+
+    log(
+      ' highest byte offset increased from ' + this.highestReceivedByteOffset,
+      ' to ',
+      this.highestReceivedByteOffset + BigInt(increaseOffset)
+    )
+    this.highestReceivedByteOffset += BigInt(increaseOffset)
+    return true
+  }
+
+  /**
+   * @param {Number} nbytesSent
+   */
+  addBytesSent(nbytesSent) {
+    const bytesSent = BigInt(nbytesSent)
+    if (this.bytesSent + bytesSent > this.sendWindowOffset) {
+      log(
+        ' Trying to send an extra ' +
+          bytesSent +
+          ' bytes, when bytes_sent = ' +
+          this.bytesSent +
+          ', and send_window_offset_ = ' +
+          this.sendWindowOffset
+      )
+      this.bytesSent = this.sendWindowOffset
+
+      // This is an error on our side, close the connection as soon as possible.
+      this.tocontrol.closeConnection({
+        code: 63, // QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA,
+        reason:
+          this.sendWindowOffset -
+          (this.bytesSent + bytesSent) +
+          'bytes over send window offset'
+      })
+      return
+    }
+    this.bytesSent += bytesSent
+    log(' sent ' + bytesSent + ' bytes.')
+  }
+
+  flowControlViolation() {
+    if (this.highestReceivedByteOffset > this.receiveWindowOffset) {
+      log(
+        'Flow control violation on ' +
+          ', receive window offset: ' +
+          this.receiveWindowOffset +
+          ', highest received byte offset: ' +
+          this.highestReceivedByteOffset
+      )
+      return true
+    }
+    return false
+  }
+
+  maybeIncreaseMaxWindowSize() {
+    // Core of receive window auto tuning.  This method should be called before a
+    // WINDOW_UPDATE frame is sent.  Ideally, window updates should occur close to
+    // once per RTT.  If a window update happens much faster than RTT, it implies
+    // that the flow control window is imposing a bottleneck.  To prevent this,
+    // this method will increase the receive window size (subject to a reasonable
+    // upper bound).  For simplicity this algorithm is deliberately asymmetric, in
+    // that it may increase window size but never decreases.
+
+    // Keep track of timing between successive window updates.
+    const now = Date.now()
+    const prev = this.prevWindowUpdateTime
+    this.prevWindowUpdateTime = now
+    if (!prev) {
+      log('first window update for ')
+      return
+    }
+
+    if (!this.autoTuneReceiveWindow) {
+      return
+    }
+
+    // TODO port need a replacement for this
+    // Get outbound RTT.
+    const rtt = this.tocontrol.smoothedRtt()
+    if (rtt === 0) {
+      log('rtt zero for ')
+      return
+    }
+
+    // Now we can compare timing of window updates with RTT.
+    const sinceLast = now - prev
+    const twoRtt = 2 * rtt
+
+    if (sinceLast >= twoRtt) {
+      // If interval between window updates is sufficiently large, there
+      // is no need to increase receive_window_size_.
+      return
+    }
+    const oldWindow = this.receiveWindowSize
+    this.increaseWindowSize()
+
+    if (this.receiveWindowSize > oldWindow) {
+      log(
+        'New max window increase for ' +
+          +' after ' +
+          sinceLast +
+          ' us, and RTT is ' +
+          rtt +
+          'us. max wndw: ' +
+          this.receiveWindowSize
+      )
+      if (this.sessionFlowController !== undefined) {
+        this.sessionFlowController.ensureWindowAtLeast(
+          BigInt(
+            FlowController.kSessionFlowControlMultiplier *
+              Number(this.receiveWindowSize)
+          )
+        )
+      }
+    } else {
+      // TODO(ckrasic) - add a varz to track this (?).
+      log(
+        'Max window at limit for ' +
+          ' after ' +
+          sinceLast +
+          ' us, and RTT is ' +
+          rtt +
+          'us. Limit size: ' +
+          this.receiveWindowSize
+      )
+    }
+  }
+
+  increaseWindowSize() {
+    this.receiveWindowSize *= 2n
+    this.receiveWindowSize =
+      this.receiveWindowSize > this.receiveWindowSizeLimit
+        ? this.receiveWindowSizeLimit
+        : this.receiveWindowSize
+  }
+
+  windowUpdateThreshold() {
+    return this.receiveWindowSize / 2n
+  }
+
+  maybeSendWindowUpdate() {
+    if (!this.tocontrol.connected()) {
+      return
+    }
+    // Send WindowUpdate to increase receive window if
+    // (receive window offset - consumed bytes) < (max window / 2).
+    // This is behaviour copied from SPDY.
+
+    const availableWindow = this.receiveWindowOffset - this.bytesConsumed
+    const threshold = this.windowUpdateThreshold()
+
+    if (!this.prevWindowUpdateTime) {
+      // Treat the initial window as if it is a window update, so if 1/2 the
+      // window is used in less than 2 RTTs, the window is increased.
+      this.prevWindowUpdateTime = Date.now()
+    }
+
+    if (availableWindow >= threshold) {
+      log(
+        'Not sending WindowUpdate for ' +
+          ', available window: ' +
+          availableWindow +
+          ' >= threshold: ' +
+          threshold
+      )
+      return
+    }
+
+    this.maybeIncreaseMaxWindowSize()
+    this.updateReceiveWindowOffsetAndSendWindowUpdate(availableWindow)
+  }
+
+  /**
+   * @param {bigint} availableWindow
+   */
+  updateReceiveWindowOffsetAndSendWindowUpdate(availableWindow) {
+    // Update our receive window.
+    this.receiveWindowOffset += this.receiveWindowSize - availableWindow
+
+    log(
+      'Sending WindowUpdate frame for ' +
+        ', consumed bytes: ' +
+        this.bytesConsumed +
+        ', available window: ' +
+        availableWindow +
+        ', and threshold: ' +
+        this.windowUpdateThreshold() +
+        ', and receive window size: ' +
+        this.receiveWindowSize +
+        '. New receive window offset is: ' +
+        this.receiveWindowOffset
+    )
+
+    this.sendWindowUpdate()
+  }
+
+  maybeSendBlocked() {
+    if (
+      this.sendWindowSize() !== 0 ||
+      this.lastBlockedSendWindowOffset >= this.sendWindowOffset
+    ) {
+      return
+    }
+    log(
+      ' is flow control blocked. ' +
+        'Send window: ' +
+        this.sendWindowSize() +
+        ', bytes sent: ' +
+        this.bytesSent +
+        ', send limit: ' +
+        this.sendWindowOffset
+    )
+    // The entire send_window has been consumed, we are now flow control
+    // blocked.
+
+    // Keep track of when we last sent a BLOCKED frame so that we only send one
+    // at a given send offset.
+    this.lastBlockedSendWindowOffset = this.sendWindowOffset
+    this.tocontrol.sendBlocked(this.lastBlockedSendWindowOffset)
+  }
+
+  /**
+   * @param {bigint} newSendWindowOffset
+   */
+  updateSendWindowOffset(newSendWindowOffset) {
+    // Only update if send window has increased.
+    if (newSendWindowOffset <= this.sendWindowOffset) {
+      return false
+    }
+
+    log(
+      'UpdateSendWindowOffset for ' +
+        ' with new offset ' +
+        newSendWindowOffset +
+        ' current offset: ' +
+        this.sendWindowOffset +
+        ' bytes_sent: ' +
+        this.bytesSent
+    )
+
+    // The flow is now unblocked but could have also been unblocked
+    // before.  Return true iff this update caused a change from blocked
+    // to unblocked.
+    const wasPreviouslyBlocked = this.isBlocked()
+    this.sendWindowOffset = newSendWindowOffset
+    return wasPreviouslyBlocked
+  }
+
+  /**
+   * @param {bigint} windowSize
+   */
+  ensureWindowAtLeast(windowSize) {
+    if (this.receiveWindowSizeLimit >= windowSize) {
+      return
+    }
+
+    const availableWindow = this.receiveWindowOffset - this.bytesConsumed
+    this.increaseWindowSize()
+    this.updateReceiveWindowOffsetAndSendWindowUpdate(availableWindow)
+  }
+
+  isBlocked() {
+    return this.sendWindowSize() === 0n
+  }
+
+  sendWindowSize() {
+    if (this.bytesSent > this.sendWindowOffset) {
+      return 0
+    }
+    return this.sendWindowOffset - this.bytesSent
+  }
+
+  /**
+   * @param {bigint} size
+   */
+  updateReceiveWindowSize(size) {
+    log('UpdateReceiveWindowSize for ' + ': ' + size)
+    if (this.receiveWindowSize !== this.receiveWindowOffset) {
+      log(
+        'receive_window_size_:' +
+          this.receiveWindowSize +
+          ' != receive_window_offset:' +
+          this.receiveWindowOffset
+      )
+      return
+    }
+    this.receiveWindowSize = size
+    this.receiveWindowOffset = size
+  }
+
+  sendWindowUpdate() {
+    this.tocontrol.sendWindowUpdate(this.receiveWindowOffset)
+  }
+}

package/lib/http2/node/capsuleparser.js

@@ -0,0 +1,291 @@
+import { ParserBaseHttp2, readVarInt, writeVarInt } from '../parserbasehttp2.js'
+import { lengthVarInt } from '../parserbase.js'
+
+export class Http2CapsuleParser extends ParserBaseHttp2 {
+  /**
+   * @param {import('../../types.js').ParserHttp2Init} stream
+   */
+  constructor({
+    stream,
+    nativesession,
+    isclient,
+    initialStreamSendWindowOffset,
+    initialStreamReceiveWindowOffset,
+    streamShouldAutoTuneReceiveWindow,
+    streamReceiveWindowSizeLimit
+  }) {
+    super({
+      stream,
+      nativesession,
+      isclient,
+      initialStreamSendWindowOffset,
+      initialStreamReceiveWindowOffset,
+      streamShouldAutoTuneReceiveWindow,
+      streamReceiveWindowSizeLimit
+    })
+    this.mode = 's' // capsule start
+    /** @type {Buffer|undefined} */
+    this.saveddata = undefined
+    /** @type {Number|undefined} */
+    this.rtype = undefined
+  }
+
+  /**
+   * @param {Buffer} data
+   */
+  parseData(data) {
+    let cdata = data
+    if (this.saveddata) {
+      cdata = Buffer.concat([this.saveddata, cdata])
+      delete this.saveddata
+    }
+    const bufferstate = { offset: 0, size: cdata.length, buffer: cdata }
+    while (bufferstate.size - bufferstate.offset > 0) {
+      switch (this.mode) {
+        case 's':
+          {
+            const capsulestart =
+              bufferstate.offset + bufferstate.buffer.byteOffset
+            const capsulemaxlength =
+              bufferstate.buffer.byteLength - bufferstate.offset
+            // we are at capsule start
+            if (bufferstate.size < 2 + bufferstate.offset) {
+              this.saveddata = Buffer.from(
+                bufferstate.buffer.buffer,
+                capsulestart,
+                capsulemaxlength
+              )
+              return
+            }
+            const type = Number(readVarInt(bufferstate))
+            if (
+              typeof type === 'undefined' ||
+              bufferstate.size < 1 + bufferstate.offset
+            ) {
+              this.saveddata = Buffer.from(
+                bufferstate.buffer.buffer,
+                capsulestart,
+                capsulemaxlength
+              )
+              return
+            }
+            const length = Number(readVarInt(bufferstate))
+            if (typeof length === 'undefined') {
+              this.saveddata = Buffer.from(
+                bufferstate.buffer.buffer,
+                capsulestart,
+                capsulemaxlength
+              )
+              return
+            }
+            let checklength = length // we want to read most times the full capsule
+            const offsetend = Math.min(
+              bufferstate.offset + length,
+              bufferstate.size
+            )
+            const offsetbegin = bufferstate.offset
+            if (
+              type === Http2CapsuleParser.PADDING ||
+              type === Http2CapsuleParser.WT_STREAM_WOFIN ||
+              type ===
+                Http2CapsuleParser.WT_STREAM_WFIN /* || type === Http2CapsuleParser.DATAGRAM */
+            ) {
+              checklength = Math.min(length, 64) // stream id + some Data
+            }
+            if (
+              checklength >
+                4 * Number(this.session.flowController.receiveWindowSize) ||
+              length > 8 * Number(this.session.flowController.receiveWindowSize)
+            ) {
+              // too long abort, could be an attack vector
+              this.session.closeConnection({
+                code: 63, // QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA, // probably the right one...
+                reason: 'Frame length too big :' + length
+              })
+              return
+            }
+            if (bufferstate.size < checklength + bufferstate.offset) {
+              this.saveddata = Buffer.from(
+                bufferstate.buffer.buffer,
+                capsulestart,
+                capsulemaxlength
+              )
+              return
+            }
+            let streamid
+            switch (type) {
+              case Http2CapsuleParser.PADDING:
+                // only padding do nothing
+                break
+              case Http2CapsuleParser.WT_RESET_STREAM:
+              case Http2CapsuleParser.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 === Http2CapsuleParser.WT_RESET_STREAM
+                          ? 'resetStream'
+                          : 'stopSending'
+                    })
+                }
+                break
+              case Http2CapsuleParser.WT_STREAM_WOFIN:
+              case Http2CapsuleParser.WT_STREAM_WFIN:
+                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:
+                        offsetend - bufferstate.offset > 0
+                          ? new Uint8Array(
+                              bufferstate.buffer.buffer,
+                              bufferstate.buffer.byteOffset +
+                                bufferstate.offset,
+                              offsetend - bufferstate.offset
+                            )
+                          : undefined,
+                      fin:
+                        type === Http2CapsuleParser.WT_STREAM_WFIN &&
+                        bufferstate.size >= length + offsetbegin
+                    })
+                  }
+                }
+                break
+              case Http2CapsuleParser.WT_MAX_DATA:
+                this.onMaxData(readVarInt(bufferstate))
+                break
+              case Http2CapsuleParser.WT_MAX_STREAM_DATA:
+                this.onMaxStreamData(
+                  readVarInt(bufferstate),
+                  readVarInt(bufferstate)
+                )
+                break
+              case Http2CapsuleParser.WT_MAX_STREAMS_BIDI:
+                // this.recvSession({ maxstreams: readVarInt(bufferstate), type })
+                break
+              case Http2CapsuleParser.WT_MAX_STREAMS_UNIDI:
+                // this.recvSession({ maxstreams: readVarInt(bufferstate), type })
+                break
+              case Http2CapsuleParser.WT_DATA_BLOCKED:
+                this.onDataBlocked(readVarInt(bufferstate))
+                break
+              case Http2CapsuleParser.WT_STREAM_DATA_BLOCKED:
+                this.onStreamDataBlocked(
+                  readVarInt(bufferstate),
+                  readVarInt(bufferstate)
+                )
+                break
+              case Http2CapsuleParser.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 Http2CapsuleParser.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 Http2CapsuleParser.DATAGRAM:
+                this.session.jsobj.onDatagramReceived({
+                  datagram: new Uint8Array(
+                    bufferstate.buffer.buffer,
+                    bufferstate.buffer.byteOffset + bufferstate.offset,
+                    offsetend - bufferstate.offset
+                  )
+                })
+                break
+              default:
+              // do nothing
+            }
+
+            if (bufferstate.size < length + offsetbegin) {
+              this.remainlength = length + offsetbegin - bufferstate.size
+              this.mode = 'c'
+              if (streamid) {
+                this.rstreamid = streamid
+                this.rfin = type === Http2CapsuleParser.WT_STREAM_WFIN
+              }
+            }
+            bufferstate.offset = offsetend
+          }
+          break
+        case 'c':
+          {
+            const clength = Math.min(
+              bufferstate.size - bufferstate.offset,
+              this.remainlength
+            )
+            if (this.rstreamid) {
+              // TODO submitData
+              const object = this.wtstreams.get(this.rstreamid)
+              // TODO submit data
+              object.recvData({
+                data: new Uint8Array(
+                  bufferstate.buffer.buffer,
+                  bufferstate.buffer.byteOffset + bufferstate.offset,
+                  clength
+                ),
+                fin:
+                  this.rtype === Http2CapsuleParser.WT_STREAM_WFIN &&
+                  this.remainlength === clength
+              })
+            }
+
+            this.remainlength = this.remainlength - clength
+            bufferstate.offset += clength
+            if (this.remainlength === 0) {
+              this.mode = 's'
+              delete this.rfin
+              delete this.rstreamid
+            }
+          }
+          break
+      }
+    }
+  }
+
+  /**
+   * @param{{type: Number, headerVints: Array<Number>, payload: Uint8Array|undefined}} bs
+   */
+  writeCapsule({ type, headerVints, payload }) {
+    let length = 0
+    for (const ind in headerVints) length += lengthVarInt(headerVints[ind])
+    let headlength = length
+    if (payload) length += payload.byteLength
+    headlength += lengthVarInt(length) + lengthVarInt(type)
+    const cdata = Buffer.alloc(headlength)
+    const bufferstate = { offset: 0, size: cdata.length, buffer: cdata }
+    writeVarInt(bufferstate, type)
+    writeVarInt(bufferstate, length)
+    for (const ind in headerVints) writeVarInt(bufferstate, headerVints[ind])
+    if (!this.stream) return
+    let blocked = !this.stream.write(cdata)
+    if (payload) blocked = !this.stream.write(payload) || blocked
+    // do something if blocked
+    if (blocked) this.blocked = true
+    return blocked
+  }
+}