@fails-components/webtransport 1.0.8 → 1.0.9

package/lib/http2/session.js

@@ -1,9 +1,11 @@
 /**
  * @typedef {import('http2').Http2Stream} Http2Stream
+ * @typedef {import('../dom.js').WebTransportSendGroup} WebTransportSendGroup
  */
 import { ParserBase } from './parserbase.js'
 import { FlowController } from './flowcontroller.js'
 import { logger } from '../utils.js'
+import { StreamIdManager } from './streamidmanager.js'
 
 const pid = typeof process !== 'undefined' ? process.pid : 0
 const log = logger(`webtransport:http2webtransportsession(${pid})`)
@@ -20,7 +22,11 @@ export class Http2WebTransportSession {
    * sendWindowOffset: Number,
    * receiveWindowOffset: Number,
    * shouldAutoTuneReceiveWindow: boolean
-   * receiveWindowSizeLimit: Number}} args
+   * receiveWindowSizeLimit: Number,
+   * initialBidirectionalSendStreams: Number,
+   * initialBidirectionalReceiveStreams: Number,
+   * initialUnidirectionalSendStreams: Number,
+   * initialUnidirectionalReceiveStreams: Number}} args
    * */
   constructor({
     stream,
@@ -30,7 +36,11 @@ export class Http2WebTransportSession {
     sendWindowOffset,
     receiveWindowOffset,
     shouldAutoTuneReceiveWindow,
-    receiveWindowSizeLimit
+    receiveWindowSizeLimit,
+    initialBidirectionalSendStreams,
+    initialBidirectionalReceiveStreams,
+    initialUnidirectionalSendStreams,
+    initialUnidirectionalReceiveStreams
   }) {
     // @ts-ignore
     this.jsobj = undefined // the creator will set this
@@ -40,8 +50,6 @@ export class Http2WebTransportSession {
       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,
@@ -50,6 +58,22 @@ export class Http2WebTransportSession {
       shouldAutoTuneReceiveWindow,
       receiveWindowSizeLimit
     })
+    this.streamIdMngrUni = new StreamIdManager({
+      delegate: this,
+      unidirectional: true,
+      isclient,
+      maxAllowedIncomingStreams: initialUnidirectionalReceiveStreams,
+      maxAllowedOutgoingStreams: initialUnidirectionalSendStreams
+    })
+    this.streamIdMngrBi = new StreamIdManager({
+      delegate: this,
+      unidirectional: false,
+      isclient,
+      maxAllowedIncomingStreams: initialBidirectionalReceiveStreams,
+      maxAllowedOutgoingStreams: initialBidirectionalSendStreams
+    })
+    this.orderUniStreams = 0
+    this.orderBiStreams = 0
     if (stream) {
       if (isclient) {
         stream.on('response', (headers) => {
@@ -75,16 +99,8 @@ export class Http2WebTransportSession {
 
   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
-    })
+    this.streamIdMngrBi.sendMaxStreamsFrameInitial()
+    this.streamIdMngrUni.sendMaxStreamsFrameInitial()
   }
 
   /**
@@ -101,28 +117,66 @@ export class Http2WebTransportSession {
     })
   }
 
-  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++
+  trySendingUnidirectionalStreams() {
+    while (
+      this.orderUniStreams > 0 &&
+      this.streamIdMngrUni.canOpenNextOutgoingStream()
+    ) {
+      const streamid = this.streamIdMngrUni.getNextOutgoingStreamId()
+      this.capsParser.writeCapsule({
+        type: ParserBase.WT_STREAM_WOFIN,
+        headerVints: [streamid],
+        payload: undefined
+      })
+      this.capsParser.newStream(streamid)
+      this.orderUniStreams--
+    }
   }
 
-  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++
+  /**
+   * @param {{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean}} opts
+   */
+  orderUnidiStream({ sendGroup, sendOrder, waitUntilAvailable }) {
+    const canopen = this.streamIdMngrUni.canOpenNextOutgoingStream()
+    const maxset = this.streamIdMngrUni.isMaxStreamSet() // we block if the maxsetting did not arrive
+
+    if (canopen || waitUntilAvailable || !maxset) {
+      this.orderUniStreams++
+      this.trySendingUnidirectionalStreams()
+      return true
+    }
+    return false
+  }
+
+  trySendingBidirectionalStreams() {
+    while (
+      this.orderBiStreams > 0 &&
+      this.streamIdMngrBi.canOpenNextOutgoingStream()
+    ) {
+      const streamid = this.streamIdMngrBi.getNextOutgoingStreamId()
+      this.capsParser.writeCapsule({
+        type: ParserBase.WT_STREAM_WOFIN,
+        headerVints: [streamid],
+        payload: undefined
+      })
+      this.capsParser.newStream(streamid)
+      this.orderBiStreams--
+    }
+  }
+
+  /**
+   * @param {{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean}} opts
+   */
+  orderBidiStream({ sendGroup, sendOrder, waitUntilAvailable }) {
+    const canopen = this.streamIdMngrBi.canOpenNextOutgoingStream()
+    const maxset = this.streamIdMngrBi.isMaxStreamSet() // we block if the maxsetting did not arrive
+
+    if (canopen || waitUntilAvailable || !maxset) {
+      this.orderBiStreams++
+      this.trySendingBidirectionalStreams()
+      return true
+    }
+    return false
   }
 
   orderSessionStats() {
@@ -218,4 +272,25 @@ export class Http2WebTransportSession {
       return navigator?.connection?.rtt || 26
     }
   }
+
+  /**
+   * @returns {boolean}
+   */
+  canSendMaxStreams() {
+    return true
+  }
+
+  /**
+   * @param {bigint} maxStreams
+   * @param {boolean} unidirectional
+   */
+  sendMaxStreams(maxStreams, unidirectional) {
+    this.capsParser.writeCapsule({
+      type: unidirectional
+        ? ParserBase.WT_MAX_STREAMS_UNIDI
+        : ParserBase.WT_MAX_STREAMS_BIDI,
+      headerVints: [maxStreams],
+      payload: undefined
+    })
+  }
 }

package/lib/http2/stream.js

@@ -12,7 +12,8 @@ const log = logger(`webtransport:http2webtransportstream(${pid})`)
  * @typedef {import('../types').StreamWriteEvent} StreamWriteEvent
  * @typedef {import('../types').StreamNetworkFinishEvent} StreamNetworkFinishEvent
  *
- *  @typedef {import('../types').ReadDataInt} ReadDataInt
+ * @typedef {import('../types').ReadDataInt} ReadDataInt
+ * @typedef {import('./streamidmanager.js').StreamIdManager} StreamIdManager
  */
 
 let processnextTick = (/** @type {{ (): void;  }} */ func) =>
@@ -22,21 +23,28 @@ if (typeof process !== 'undefined') processnextTick = process.nextTick
 
 export class Http2WebTransportStream {
   /**
-   * @param {{streamid: Number, capsuleParser: ParserBase
+   * @param {{streamid: bigint,
+   * unidirectional: boolean,
+   * incoming: boolean,
+   * capsuleParser: ParserBase
    * sendWindowOffset: Number,
    * receiveWindowOffset: Number,
    * shouldAutoTuneReceiveWindow: boolean
    * receiveWindowSizeLimit: Number,
-   * sessionFlowController: FlowController}} args
+   * sessionFlowController: FlowController,
+   * streamIdManager: StreamIdManager}} args
    * */
   constructor({
     streamid,
+    unidirectional,
+    incoming,
     capsuleParser,
     sendWindowOffset,
     receiveWindowOffset,
     shouldAutoTuneReceiveWindow,
     receiveWindowSizeLimit,
-    sessionFlowController
+    sessionFlowController,
+    streamIdManager
   }) {
     /** @type {import('../stream').HttpWTStream} */
     // @ts-ignore
@@ -58,11 +66,22 @@ export class Http2WebTransportStream {
       sessionFlowController
     })
     this.sessionFlowController = sessionFlowController
+    this.streamIdManager = streamIdManager
 
     this.final = false
     this.stopReading_ = true
     this.drainReads_ = true
     this.recvBytes = 0
+
+    this.outgoingClosed_ = false
+    this.incomingClosed_ = false
+    if (unidirectional) {
+      if (incoming) {
+        this.outgoingClosed_ = true
+      } else {
+        this.incomingClosed_ = true
+      }
+    }
   }
 
   sendInitialParameters() {
@@ -71,12 +90,12 @@ export class Http2WebTransportStream {
 
   /**
    * @param {Object} obj
-   * @param {Uint8Array} obj.data
+   * @param {Uint8Array|undefined} obj.data
    * @param {Boolean} obj.fin
    */
   recvData({ data, fin }) {
     this.incomdata.push({ data, fin })
-    if (data?.byteLength > 0) {
+    if (data && data?.byteLength > 0) {
       const checkstream = this.flowController.updateHighestReceivedOffset(
         data?.byteLength
       )
@@ -115,13 +134,13 @@ export class Http2WebTransportStream {
     ) {
       if (!buffer) {
         const bytes = this.incomdata.reduce(
-          (prevVal, val) => prevVal + val.data?.byteLength,
+          (prevVal, val) => prevVal + ((val && val.data?.byteLength) || 0),
           0
         )
         if (bytes > 0) {
           buffer = this.jsobj.getReadBuffer({
             byteSize: this.incomdata.reduce(
-              (prevVal, val) => prevVal + val.data?.byteLength,
+              (prevVal, val) => prevVal + ((val && val.data?.byteLength) || 0),
               0
             )
           })
@@ -194,10 +213,40 @@ export class Http2WebTransportStream {
     this.stopReading_ = true
   }
 
+  /**
+   * @param {'resetStream'|'stopSending'} type
+   */
+  onStreamSignal(type) {
+    switch (type) {
+      case 'resetStream':
+        this.closeIncoming()
+        break
+      case 'stopSending':
+        this.closeOutgoing()
+        break
+    }
+  }
+
+  closeIncoming() {
+    this.incomingClosed_ = true
+    if (this.outgoingClosed_) this.onClose()
+  }
+
+  closeOutgoing() {
+    this.outgoingClosed_ = true
+    if (this.incomingClosed_) this.onClose()
+  }
+
+  onClose() {
+    // ok, inform our session id manager
+    this.streamIdManager.onStreamClosed(this.streamid)
+  }
+
   /**
    * @param {Number} code
    */
   stopSending(code) {
+    this.closeIncoming()
     this.capsuleParser.writeCapsule({
       type: ParserBase.WT_STOP_SENDING,
       headerVints: [this.streamid, code],
@@ -210,10 +259,15 @@ export class Http2WebTransportStream {
     )
   }
 
+  onFin() {
+    this.closeIncoming()
+  }
+
   /**
    * @param {Number} code
    */
   resetStream(code) {
+    this.closeOutgoing()
     this.capsuleParser.writeCapsule({
       type: ParserBase.WT_RESET_STREAM,
       headerVints: [this.streamid, code],
@@ -238,8 +292,8 @@ export class Http2WebTransportStream {
     while (
       this.outgochunks.length > 0 &&
       (!this.capsuleParser.blocked || this.final) &&
-      this.flowController.sendWindowSize() > 0 &&
-      this.sessionFlowController.sendWindowSize() > 0
+      this.flowController.sendWindowSize() > 0n &&
+      this.sessionFlowController.sendWindowSize() > 0n
     ) {
       const cur = this.outgochunks.shift()
       if (cur) {
@@ -308,6 +362,7 @@ export class Http2WebTransportStream {
    * @param {bigint} windowOffset
    */
   sendWindowUpdate(windowOffset) {
+    log('sendwindow offset stream:', windowOffset)
     this.capsuleParser.writeCapsule({
       type: ParserBase.WT_MAX_STREAM_DATA,
       headerVints: [this.streamid, windowOffset],

package/lib/http2/streamidmanager.js

@@ -0,0 +1,316 @@
+import { logger } from '../utils.js'
+
+/**
+ * @typedef {import('../types').StreamIdClient} StreamIdClient
+ */
+
+function GetMaxStreamCount() {
+  return (0xffffffffn >> 2n) + 1n
+}
+
+const pid = typeof process !== 'undefined' ? process.pid : 0
+const log = logger(`webtransport:streamidmanager(${pid})`)
+// Ported from libquiche, QuicStreamIdManager so their license applies to the original in C++ and this javascript translation
+// Copyright (c) 2018 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 StreamIdManager {
+  /**
+   * @param {{delegate: StreamIdClient
+   * unidirectional: boolean,
+   * isclient: boolean,
+   * maxAllowedOutgoingStreams: number,
+   * maxAllowedIncomingStreams: number}} arg
+   */
+  constructor({
+    delegate,
+    unidirectional,
+    isclient,
+    maxAllowedOutgoingStreams,
+    maxAllowedIncomingStreams
+  }) {
+    this.delegate = delegate
+    this.unidirectional = unidirectional
+    this.isclient = isclient
+
+    this.outgoingMaxStreams = BigInt(maxAllowedOutgoingStreams)
+
+    // The ID to use for the next outgoing stream.
+    this.nextOutgoingStreamId = this.getFirstOutgoingStreamId()
+
+    // The number of outgoing streams that have ever been opened, including those
+    // that have been closed. This number must never be larger than
+    // outgoing_max_streams_.
+    this.outgoingStreamCount = 0n
+
+    // FOR INCOMING STREAMS
+
+    // The actual maximum number of streams that can be opened by the peer.
+    this.incomingActualMaxStreams = BigInt(maxAllowedIncomingStreams)
+    // Max incoming stream number that has been advertised to the peer and is <=
+    // incoming_actual_max_streams_. It is set to incoming_actual_max_streams_
+    // when a MAX_STREAMS is sent.
+    this.incomingAdvertisedMaxStreams = BigInt(maxAllowedIncomingStreams)
+
+    // Initial maximum on the number of open streams allowed.
+    this.incomingInitialMaxOpenStreams = BigInt(maxAllowedIncomingStreams)
+
+    // The number of streams that have been created, including open ones and
+    // closed ones.
+    this.incomingStreamCount = 0n
+
+    // Set of stream ids that are less than the largest stream id that has been
+    // received, but are nonetheless available to be created.
+    this.availableStreams = new Set()
+
+    this.largestPeerCreatedStreamId = BigInt(Number.MAX_SAFE_INTEGER)
+
+    // If true, then the stream limit will never be increased.
+    this.stopIncreasingIncomingMaxStreams = false
+  }
+
+  /**
+   * @param {bigint} streamCount
+   */
+  onStreamsBlockedFrame(streamCount) {
+    if (streamCount > this.incomingAdvertisedMaxStreams) {
+      // Peer thinks it can send more streams that we've told it.
+      return {
+        error:
+          "StreamsBlockedFrame's stream count " +
+          streamCount +
+          ' exceeds incoming max stream ' +
+          this.incomingAdvertisedMaxStreams
+      }
+    }
+    if (this.incomingAdvertisedMaxStreams === this.incomingActualMaxStreams) {
+      // We have told peer about current max.
+      return { success: true }
+    }
+    if (
+      streamCount < this.incomingActualMaxStreams &&
+      this.delegate.canSendMaxStreams()
+    ) {
+      // Peer thinks it's blocked on a stream count that is less than our current
+      // max. Inform the peer of the correct stream count.
+      this.sendMaxStreamsFrame()
+    }
+    return { success: true }
+  }
+
+  /**
+   * @param {bigint} maxOpenStreams
+   */
+  maybeAllowNewOutgoingStreams(maxOpenStreams) {
+    if (maxOpenStreams <= this.outgoingMaxStreams) {
+      // Only update the stream count if it would increase the limit.
+      return false
+    }
+
+    // This implementation only supports 32 bit Stream IDs, so limit max streams
+    // if it would exceed the max 32 bits can express.
+    const maxStreamCount = GetMaxStreamCount()
+    if (maxOpenStreams < maxStreamCount)
+      this.outgoingMaxStreams = maxOpenStreams
+    else this.outgoingMaxStreams = maxStreamCount
+
+    return true
+  }
+
+  /**
+   * @param {bigint} maxOpenStreams
+   */
+  setMaxOpenIncomingStreams(maxOpenStreams) {
+    if (this.incomingStreamCount > 0)
+      throw new Error(
+        'non-zero incoming stream count ' +
+          this.incomingStreamCount +
+          +' when setting max incoming stream to ' +
+          maxOpenStreams
+      )
+    if (this.incomingInitialMaxOpenStreams !== maxOpenStreams)
+      log(
+        this.unidirectional ? 'unidirectional ' : 'bidirectional: ',
+        'incoming stream limit changed from ',
+        this.incomingInitialMaxOpenStreams,
+        ' to ',
+        maxOpenStreams
+      )
+    this.incomingActualMaxStreams = maxOpenStreams
+    this.incomingAdvertisedMaxStreams = maxOpenStreams
+    this.incomingInitialMaxOpenStreams = maxOpenStreams
+  }
+
+  maybeSendMaxStreamsFrame() {
+    const divisor = 2n // may be modify
+
+    if (divisor > 0n) {
+      if (
+        this.incomingAdvertisedMaxStreams - this.incomingStreamCount >
+        this.incomingInitialMaxOpenStreams / divisor
+      ) {
+        // window too large, no advertisement
+        return
+      }
+    }
+    if (
+      this.delegate.canSendMaxStreams() &&
+      this.incomingAdvertisedMaxStreams < this.incomingActualMaxStreams
+    ) {
+      this.sendMaxStreamsFrame()
+    }
+  }
+
+  sendMaxStreamsFrame() {
+    if (this.incomingAdvertisedMaxStreams >= this.incomingActualMaxStreams)
+      throw new Error(
+        'this.incomingAdvertisedMaxStreams >= this.incomingActualMaxStreams' +
+          this.incomingAdvertisedMaxStreams +
+          'vs.' +
+          this.incomingActualMaxStreams
+      )
+    this.incomingAdvertisedMaxStreams = this.incomingActualMaxStreams
+    this.delegate.sendMaxStreams(
+      this.incomingAdvertisedMaxStreams,
+      this.unidirectional
+    )
+  }
+
+  sendMaxStreamsFrameInitial() {
+    this.delegate.sendMaxStreams(
+      this.incomingAdvertisedMaxStreams,
+      this.unidirectional
+    )
+  }
+
+  /**
+   * @param {bigint} streamId
+   */
+  onStreamClosed(streamId) {
+    // Nothing to do for outgoing streams.
+    if (
+      (this.isclient && streamId & 0x1n) ||
+      (!this.isclient && !(streamId & 0x1n))
+    )
+      return
+
+    // If the stream is inbound, we can increase the actual stream limit and maybe
+    // advertise the new limit to the peer.
+    if (this.incomingActualMaxStreams === GetMaxStreamCount()) {
+      // Reached the maximum stream id value that the implementation
+      // supports. Nothing can be done here.
+      return
+    }
+    if (!this.stopIncreasingIncomingMaxStreams) {
+      // One stream closed, and another one can be opened.
+      this.incomingActualMaxStreams++
+      this.maybeSendMaxStreamsFrame()
+    }
+  }
+
+  getNextOutgoingStreamId() {
+    if (this.outgoingStreamCount >= this.outgoingMaxStreams)
+      throw new Error(
+        'Attempt to allocate a new outgoing stream that would exceed the ' +
+          'limit (' +
+          +Number(this.outgoingMaxStreams) +
+          ')'
+      )
+    const id = this.nextOutgoingStreamId
+    this.nextOutgoingStreamId += 1n << 2n
+    this.outgoingStreamCount++
+    return id
+  }
+
+  canOpenNextOutgoingStream() {
+    return this.outgoingStreamCount < this.outgoingMaxStreams
+  }
+
+  isMaxStreamSet() {
+    return this.outgoingMaxStreams > 0n
+  }
+
+  /**
+   * @param {bigint} streamId
+   */
+  maybeIncreaseLargestPeerStreamId(streamId) {
+    // |stream_id| must be an incoming stream of the right directionality.
+
+    if (this.availableStreams.has(streamId)) {
+      this.availableStreams.delete(streamId)
+      // stream_id is available.
+      return true
+    }
+
+    // Calculate increment of incoming_stream_count_ by creating stream_id.
+    const delta = 1n << 2n
+    const leastNewStreamId =
+      this.largestPeerCreatedStreamId === BigInt(Number.MAX_SAFE_INTEGER)
+        ? this.getFirstIncomingStreamId()
+        : this.largestPeerCreatedStreamId + delta
+    const streamCountIncrement = (streamId - leastNewStreamId) / delta + 1n
+
+    if (
+      this.incomingStreamCount + streamCountIncrement >
+      this.incomingAdvertisedMaxStreams
+    ) {
+      log(
+        'Failed to create a new incoming stream with id:' +
+          streamId +
+          ', reaching MAX_STREAMS limit: ' +
+          this.incomingAdvertisedMaxStreams +
+          '.'
+      )
+      return {
+        error:
+          'Stream id ' +
+          streamId +
+          ' would exceed stream count limit ' +
+          this.incomingAdvertisedMaxStreams
+      }
+    }
+
+    for (let id = leastNewStreamId; id < streamId; id += delta) {
+      this.availableStreams.add(id)
+    }
+    this.incomingStreamCount += streamCountIncrement
+    this.largestPeerCreatedStreamId = streamId
+    return true
+  }
+
+  /**
+   * @param {number} id
+   */
+  isAvailableStream(id) {
+    if ((this.isclient && id & 0x1) || (!this.isclient && !(id & 0x1))) {
+      // Stream IDs under next_ougoing_stream_id_ are either open or previously
+      // open but now closed.
+      return id >= this.nextOutgoingStreamId
+    }
+    // For peer created streams, we also need to consider available streams.
+    return (
+      this.largestPeerCreatedStreamId === BigInt(Number.MAX_SAFE_INTEGER) ||
+      id > this.largestPeerCreatedStreamId ||
+      this.availableStreams.has(id)
+    )
+  }
+
+  getFirstOutgoingStreamId() {
+    let streamid = 0n
+    if (this.isclient) streamid |= 0x1n
+    if (this.unidirectional) streamid |= 0x2n
+    return streamid
+  }
+
+  getFirstIncomingStreamId() {
+    let streamid = 0n
+    if (!this.isclient) streamid |= 0x1n
+    if (this.unidirectional) streamid |= 0x2n
+    return streamid
+  }
+
+  get availableIncomingStreams() {
+    return this.incomingAdvertisedMaxStreams - this.incomingStreamCount
+  }
+}