@fails-components/webtransport 1.0.6 → 1.0.9

package/lib/session.js

@@ -2,6 +2,7 @@ import { ReadableStream, WritableStream } from './webstreams.js'
 import { HttpWTStream } from './stream.js'
 import { WebTransportError } from './error.js'
 import { logger } from './utils.js'
+import { canByteStream } from './features.js'
 
 const pid = typeof process !== 'undefined' ? process.pid : 0
 const log = logger(`webtransport:httpwtsession(${pid})`)
@@ -21,6 +22,7 @@ const log = logger(`webtransport:httpwtsession(${pid})`)
  * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
  * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
  * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
+ * @typedef {import('./dom').WebTransportSendStreamOptions} WebTransportSendStreamOptions
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
  * @typedef {import('./dom').WebTransportDatagramDuplexStream} WebTransportDatagramDuplexStream
  * @typedef {import('./dom').WebTransportReliabilityMode} WebTransportReliabilityMode
@@ -113,19 +115,23 @@ export class HttpWTSession {
     this.writeDatagramRej = []
     /** @type {Array<Promise<void>>} */
     this.writeDatagramProm = []
-
+    const readableopts = {
+      start: (
+        /** @type {import("stream/web").ReadableByteStreamController} */ controller
+      ) => {
+        this.incomDatagramController = controller
+      },
+      type: 'bytes'
+    }
+    if (!canByteStream) {
+      // @ts-ignore
+      delete readableopts.type
+    }
     /** @type {WebTransportDatagramDuplexStream} */
     this.datagrams = {
       /** @type {ReadableStream<Uint8Array>} */
       // @ts-ignore
-      readable: new ReadableStream({
-        start: (
-          /** @type {import("stream/web").ReadableByteStreamController} */ controller
-        ) => {
-          this.incomDatagramController = controller
-        },
-        type: 'bytes'
-      }),
+      readable: new ReadableStream(readableopts),
       writable: new WritableStream({
         start: (controller) => {
           this.outgoDatagramController = controller
@@ -194,6 +200,9 @@ export class HttpWTSession {
       this.objint = object
       this.objint.jsobj = this
       this.reliable = !!reliable
+      if (this.objint.sendInitialParameters) {
+        this.objint.sendInitialParameters()
+      }
     }
   }
 
@@ -334,9 +343,10 @@ export class HttpWTSession {
   }
 
   /**
+   * @param {WebTransportSendStreamOptions} [opts]
    * @returns {Promise<WebTransportBidirectionalStream>}
    */
-  createBidirectionalStream() {
+  createBidirectionalStream(opts) {
     if (this.objint == null) {
       throw new Error('this.objint not set')
     }
@@ -345,14 +355,25 @@ export class HttpWTSession {
       this.resolveBiDi.push(resolve)
       this.rejectBiDi.push(reject)
     })
-    this.objint.orderBidiStream()
+    const notblocked = this.objint.orderBidiStream({
+      sendGroup: opts?.sendGroup || null, // maybe replace, when implemented
+      sendOrder: opts?.sendOrder || 0,
+      waitUntilAvailable: opts?.waitUntilAvailable || false
+    })
+    if (!notblocked) {
+      const rej = this.rejectBiDi.pop()
+      this.resolveBiDi.pop()
+      if (rej)
+        rej(new DOMException('No streams available', 'QuotaExceededError'))
+    }
     return prom
   }
 
   /**
-   *@returns {Promise<WebTransportSendStream>}
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportSendStream>}
    */
-  createUnidirectionalStream() {
+  createUnidirectionalStream(opts) {
     if (this.objint == null) {
       throw new Error('this.objint not set')
     }
@@ -361,7 +382,17 @@ export class HttpWTSession {
       this.resolveUniDi.push(resolve)
       this.rejectUniDi.push(reject)
     })
-    this.objint.orderUnidiStream()
+    const notblocked = this.objint.orderUnidiStream({
+      sendGroup: opts?.sendGroup || null, // maybe replace, when implemented
+      sendOrder: opts?.sendOrder || 0,
+      waitUntilAvailable: opts?.waitUntilAvailable || false
+    })
+    if (!notblocked) {
+      const rej = this.rejectUniDi.pop()
+      this.resolveUniDi.pop()
+      if (rej)
+        rej(new DOMException('No streams available', 'QuotaExceededError'))
+    }
     return prom
   }
 
@@ -548,8 +579,9 @@ export class HttpWTSession {
       )
       destview.set(args.datagram)
       byob.respond(args.datagram.byteLength)
+    } else {
+      this.incomDatagramController.enqueue(new Uint8Array(args.datagram))
     }
-    this.incomDatagramController.enqueue(new Uint8Array(args.datagram))
   }
 
   /**

package/lib/stream.js

@@ -1,6 +1,7 @@
 import { ReadableStream, WritableStream } from './webstreams.js'
 import { logger } from './utils.js'
 import { WebTransportError } from './error.js'
+import { canByteStream } from './features.js'
 
 const pid = typeof process !== 'undefined' ? process.pid : 0
 const log = logger(`webtransport:http3wtstream(${pid})`)
@@ -60,48 +61,54 @@ export class HttpWTStream {
     this.pendingresRead = null
 
     if (this.bidirectional || this.incoming) {
+      const readableopts = {
+        start: (
+          /** @type {import("stream/web").ReadableByteStreamController} */ controller
+        ) => {
+          this.readableController = controller
+          this.objint.startReading()
+        },
+        pull: async (
+          /** @type {import("stream/web").ReadableByteStreamController} */ controller
+        ) => {
+          if (this.readableclosed) {
+            return Promise.resolve()
+          }
+
+          this.pendingoperationRead = new Promise((resolve, reject) => {
+            this.pendingresRead = resolve
+          })
+          this.objint.startReading()
+          await this.pendingoperationRead
+        },
+        cancel: (/** @type {{ code: number; }} */ reason) => {
+          /** @type {Promise<void>} */
+          const promise = new Promise((resolve, reject) => {
+            this.cancelres = resolve
+          })
+          let code = 0
+          if (reason && reason.code) {
+            if (reason.code < 0) code = 0
+            else if (reason.code > 255) code = 255
+            else code = reason.code
+          }
+          this.readableclosed = true
+          this.objint.stopSending(code)
+          return promise
+        },
+        type: 'bytes',
+        autoAllocateChunkSize: 4096 // lets take this as buffer size
+      }
+
+      if (!canByteStream) {
+        // @ts-ignore
+        delete readableopts.type
+      }
       /** @type {WebTransportReceiveStream} */
       // @ts-expect-error `getStats` property is missing from ReadableStream
       this.readable = new ReadableStream(
-        {
-          start: (
-            /** @type {import("stream/web").ReadableByteStreamController} */ controller
-          ) => {
-            this.readableController = controller
-            this.objint.startReading()
-          },
-          pull: async (
-            /** @type {import("stream/web").ReadableByteStreamController} */ controller
-          ) => {
-            if (this.readableclosed) {
-              return Promise.resolve()
-            }
-
-            this.pendingoperationRead = new Promise((resolve, reject) => {
-              this.pendingresRead = resolve
-            })
-            this.objint.startReading()
-            await this.pendingoperationRead
-          },
-          cancel: (/** @type {{ code: number; }} */ reason) => {
-            /** @type {Promise<void>} */
-            const promise = new Promise((resolve, reject) => {
-              this.cancelres = resolve
-            })
-            let code = 0
-            if (reason && reason.code) {
-              if (reason.code < 0) code = 0
-              else if (reason.code > 255) code = 255
-              else code = reason.code
-            }
-            this.readableclosed = true
-            this.objint.stopSending(code)
-            return promise
-          },
-          type: 'bytes',
-          autoAllocateChunkSize: 4096 // lets take this as buffer size
-        }
-        // TODO fix stretegy
+        // @ts-ignore
+        readableopts
       )
       this.readable.getStats = () => {
         return Promise.resolve({

package/lib/types.ts

@@ -1,7 +1,8 @@
 import type {
   WebTransportSession,
   WebTransportHash,
-  WebTransportOptions
+  WebTransportOptions,
+  WebTransportSendGroup
 } from './dom'
 import type { IncomingHttpHeaders, Http2Stream } from 'http2'
 import { ParserBase } from './http2/parserbase'
@@ -15,8 +16,8 @@ export interface NativeHttpWTSession {
   jsobj: WebTransportSessionEventHandler
   sendInitialParameters?: () => void
   writeDatagram: (chunk: Uint8Array) => void
-  orderUnidiStream: () => void
-  orderBidiStream: () => void
+  orderUnidiStream: (opts:{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean}) => boolean
+  orderBidiStream: (opts:{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean})  => boolean
   orderSessionStats: () => void
   orderDatagramStats: () => void
   notifySessionDraining: () => void
@@ -47,12 +48,18 @@ export interface NativeServerOptions {
   certhttp2?: string // if http2 has a different cert
   privKey: string
   privKeyhttp2?: string // if http2 has a different cert
+  initialBidirectionalSendStreams?: number
+  initialBidirectionalReceiveStreams?: number
+  initialUnidirectionalSendStreams?: number
+  initialUnidirectionalReceiveStreams?: number
   initialStreamFlowControlWindow?: number
   streamShouldAutoTuneReceiveWindow?: boolean
   streamFlowControlWindowSizeLimit?: number
   initialSessionFlowControlWindow?: number
   sessionShouldAutoTuneReceiveWindow?: boolean
   sessionFlowControlWindowSizeLimit?: number
+  initialBidirectionalStreams?: number
+  initialUnidirectionalStreams?: number
 }
 
 export interface NativeClientOptions {
@@ -62,6 +69,10 @@ export interface NativeClientOptions {
   localPort: number
   allowPooling: boolean
   forceIpv6: boolean
+  initialBidirectionalSendStreams?: number
+  initialBidirectionalReceiveStreams?: number
+  initialUnidirectionalSendStreams?: number
+  initialUnidirectionalReceiveStreams?: number
   initialStreamFlowControlWindow?: number
   streamShouldAutoTuneReceiveWindow?: boolean
   streamFlowControlWindowSizeLimit?: number
@@ -78,6 +89,11 @@ export interface FlowControlable {
   smoothedRtt: () => number
 }
 
+export interface StreamIdClient {
+  canSendMaxStreams: () => boolean
+  sendMaxStreams: (maxStreams: bigint, unidirectional: boolean) => void
+}
+
 export interface ReadBuffer {
   buffer?: Uint8Array
   readBytes?: number
@@ -330,6 +346,6 @@ export interface ParserWebsocketInit extends ParserInit {
 }
 
 export interface ReadDataInt {
-  data: Uint8Array
+  data: Uint8Array|undefined
   fin: boolean
 }

package/lib/webtransport.browser.js

@@ -10,6 +10,8 @@ const log = logger(`webtransport:browser()`)
  * @typedef {import('./dom').WebTransport} WebTransport
  * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
  * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
+ * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
+ * @typedef {import('./dom').WebTransportSendStreamOptions} WebTransportSendStreamOptions
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
  * @typedef {import('./error').WebTransportError} WebTransportError
  */
@@ -307,13 +309,21 @@ export class WebTransportPolyfill {
     this.curtransport.close(closeinfo)
   }
 
-  async createBidirectionalStream() {
+  /**
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportBidirectionalStream>}
+   */
+  async createBidirectionalStream(opts) {
     await this.ready
-    return await this.curtransport.createBidirectionalStream()
+    return await this.curtransport.createBidirectionalStream(opts)
   }
 
-  async createUnidirectionalStream() {
+  /**
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportSendStream>}
+   */
+  async createUnidirectionalStream(opts) {
     await this.ready
-    return await this.curtransport.createUnidirectionalStream()
+    return await this.curtransport.createUnidirectionalStream(opts)
   }
 }

package/lib/webtransportbase.js

@@ -4,6 +4,8 @@
  * @typedef {import('./dom.js').WebTransportCloseInfo} WebTransportCloseInfo
  * @typedef {import('./dom.js').WebTransportBidirectionalStream} WebTransportBidirectionalStream
  * @typedef {import('./dom.js').WebTransportReceiveStream} WebTransportReceiveStream
+ * @typedef {import('./dom.js').WebTransportSendStream} WebTransportSendStream
+ * @typedef {import('./dom.js').WebTransportSendStreamOptions} WebTransportSendStreamOptions
  * @typedef {import('./session.js').HttpWTSession} HttpWTSession
  * @typedef { import('./session.js').HttpClient} HttpClient
  */
@@ -119,7 +121,11 @@ export class WebTransportBase {
     return session.close(closeinfo)
   }
 
-  createBidirectionalStream() {
+  /**
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportBidirectionalStream>}
+   */
+  createBidirectionalStream(opts) {
     const session = this.sessionint
 
     if (!session) {
@@ -127,10 +133,14 @@ export class WebTransportBase {
       throw new Error('Http3WTSession was undefined')
     }
 
-    return session.createBidirectionalStream()
+    return session.createBidirectionalStream(opts)
   }
 
-  createUnidirectionalStream() {
+  /**
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportSendStream>}
+   */
+  createUnidirectionalStream(opts) {
     const session = this.sessionint
 
     if (!session) {
@@ -138,6 +148,6 @@ export class WebTransportBase {
       throw new Error('Http3WTSession was undefined')
     }
 
-    return session.createUnidirectionalStream()
+    return session.createUnidirectionalStream(opts)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "exports": {
     ".": {
@@ -15,7 +15,7 @@
   "types": "./dist/lib/index.d.ts",
   "scripts": {
     "start": "node test/echoserver.js",
-    "test": "npm run test:node && npm run test:node:http2 && npm run test:chromium && npm run test:chromium:http2:polyfill && npm run test:chromium:http2:ponyfill && npm run test:firefox && npm run test:firefox:http2:polyfill && npm run test:firefox:http2:ponyfill",
+    "test": "npm run test:node && npm run test:node:http2 && npm run test:chromium && npm run test:chromium:http2:polyfill && npm run test:chromium:http2:ponyfill && npm run test:firefox:http2:polyfill && npm run test:firefox:http2:ponyfill && npm run test:webkit:http2:polyfill && npm run test:webkit:http2:ponyfill",
     "test:node": "node test/index.js node http3",
     "test:node:http2": "node test/index.js node http2",
     "test:chromium": "node test/index.js chromium http3",
@@ -24,6 +24,9 @@
     "test:firefox": "node test/index.js firefox http3",
     "test:firefox:http2:polyfill": "node test/index.js firefox http2 polyfill",
     "test:firefox:http2:ponyfill": "node test/index.js firefox http2 ponyfill",
+    "test:webkit": "node test/index.js webkit http3",
+    "test:webkit:http2:polyfill": "node test/index.js webkit http2 polyfill",
+    "test:webkit:http2:ponyfill": "node test/index.js webkit http2 ponyfill",
     "oldtest": "node old_test/test.js",
     "oldtesthttp2": "node old_test/test.js http2",
     "lint": "eslint lib test old_test"

package/readme.md

@@ -23,8 +23,6 @@ Note, that the client implementation only supports certificate checking via `cer
 It may be possible in the future to also support normal HTTP/3 with not so much effort, however, there is no intention from the author to implement this since it will not be needed by FAILS. However, PR requests are welcome and will be supported by advice from the author.
 The package for the HTTP/3 should be considered as a duct tape-style solution until a bulletproof native support of HTTP/3 and WebTransport is provided by node itself.
 
-If you need a ponyfill check out the sister package [https://github.com/fails-components/webtransport-ponyfill-websocket/](https://github.com/fails-components/webtransport-ponyfill-websocket/), which provides a mapping of the Webtransport interfaces to Websocket connections.
-
 ## Changes for Version 1.x.x
 
 The interface for version 1.x.x is not changed compared to 0.x.x.
@@ -37,12 +35,15 @@ Note, that it is only partially implemented and also some http2 features require
 Use for the server side either `HttpServer` for http/2 and http/3 support (including WebTransport over WebSocket), Http3Server for http/3 only and Http2Server for http/2 only.
 For the client side pass the options `forceReliable`, `requireUnreliable` etc. to force/select a type of transport.
 
- **Note, that the http/2 webtransport protocol (not supported by any browser yet), is implemented without the support of receiving initial settings, which can cause a problem with the initial flow control of the WebTransport streams. This is a current limitation in node.js. Note, that for sending the required initial setting you need a very recent (unreleased) version of node.js.** This limitation does not apply to the polyfill/ponyfill and the websocket protocol.
+ **Note, that the http/2 webtransport protocol (not supported by any browser yet), is implemented without the support of receiving initial settings, which can cause a problem with the initial flow control of the WebTransport streams. This is a current limitation in node.js, but a patch to add support will soon be part of new node versions. Note, that for sending the required initial setting you need a very recent version (>=21.6.1) of node.js.** This limitation does not apply to the polyfill/ponyfill and the webtransport over websocket protocol.
+
+ The current proposal for the WebTransport over WebSocket protocol can be found [here] (https://datatracker.ietf.org/doc/draft-richter-webtransport-websocket/).
 
 ### Ponyfill/Polyfill
 Together with an experimental http/2 implementation of WebTransport, the underlying http/2 capsule protocol had been mapped to the WebSocket protocol, so that the packages can also be used as a ponyfill/polyfill on the browser side.
 Please use `WebTransportPonyfill` for a WebSocket only or `WebTransportPolyfill` as a replacement for `WebTransport`, which automatically falls back to the browser's implementation, if the corresponding features are natively supported in the browser.
 
+The used WebSocket protocol is currently proprietary and described in detail [here](https://martenrichter.github.io/draft-ietf-webtransport-websocket/draft-richter-webtransport-websocket.html). 
 
 ## Installation and usage
 

package/test/fixtures/certificate.js

@@ -381,7 +381,7 @@ export async function generateWebTransportCertificate(attrs, options) {
       options.extensions || [
         {
           name: 'basicConstraints',
-          cA: true
+          cA: false
         },
         {
           name: 'keyUsage',
@@ -428,7 +428,6 @@ export async function generateWebTransportCertificate(attrs, options) {
     cert.signature = await cert.signature
 
     const pemcert = pki.certificateToPem(cert)
-
     const x509cert = new X509Certificate(pemcert)
 
     const certhash = Buffer.from(

package/test/fixtures/server.js

@@ -39,7 +39,7 @@ export async function createServer() {
   } else {
     server = new Http3Server({
       /*   port: 8080,
-    host: '0.0.0.0', */
+      host: '0.0.0.0', */
       port: 0,
       host: '127.0.0.1',
       secret: 'mysecret',
@@ -48,10 +48,15 @@ export async function createServer() {
     })
   }
 
+  let adjustlimit = 1
+  if (process.env.USE_HTTP2 === 'true') {
+    adjustlimit = 0
+  }
+
   server.ready
     .then(async () => {
       // set up listeners for the different server paths used by the tests
-
+      console.log('server ready')
       await Promise.all(
         [
           // echo server, initiated by remote
@@ -162,6 +167,104 @@ export async function createServer() {
             }
           },
 
+          // receive 100+ bidi streams and block
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/streamlimits_getbidis_wua')
+            )) {
+              try {
+                await session.ready
+                const bidistreams = []
+                while (bidistreams.length < 100 - adjustlimit) {
+                  bidistreams.push(
+                    await getReaderValue(session.incomingBidirectionalStreams)
+                  )
+                }
+                await getReaderValue(session.incomingUnidirectionalStreams)
+                await getReaderValue(session.incomingUnidirectionalStreams)
+                for (let i = 0; i < 50 + adjustlimit; i++) {
+                  /* const curstream = */ bidistreams.shift()
+                  // await curstream.writable.close() // canceled by client
+                }
+                while (bidistreams.length < 100 - adjustlimit) {
+                  bidistreams.push(
+                    await getReaderValue(session.incomingBidirectionalStreams)
+                  )
+                }
+                await getReaderValue(session.incomingUnidirectionalStreams)
+                await session.close()
+              } catch (error) {
+                // do not crash server, if a problem occurs...
+              }
+            }
+          },
+          // receive 100+ bidi streams and do not block
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/streamlimits_getbidis')
+            )) {
+              try {
+                await session.ready
+                const bidistreams = []
+                while (bidistreams.length < 150) {
+                  bidistreams.push(
+                    await getReaderValue(session.incomingBidirectionalStreams)
+                  )
+                }
+                await session.close()
+              } catch (error) {
+                // do not crash server, if a problem occurs...
+              }
+            }
+          },
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/streamlimits_getunidis_wua')
+            )) {
+              try {
+                await session.ready
+                const unidistreams = []
+                while (unidistreams.length < 100 - adjustlimit) {
+                  unidistreams.push(
+                    await getReaderValue(session.incomingUnidirectionalStreams)
+                  )
+                }
+                await getReaderValue(session.incomingBidirectionalStreams)
+                await getReaderValue(session.incomingBidirectionalStreams)
+                for (let i = 0; i < 50 + adjustlimit; i++) {
+                  unidistreams.shift()
+                }
+                while (unidistreams.length < 100 - adjustlimit) {
+                  unidistreams.push(
+                    await getReaderValue(session.incomingUnidirectionalStreams)
+                  )
+                }
+                await getReaderValue(session.incomingBidirectionalStreams)
+                await session.close()
+              } catch (error) {
+                // do not crash server, if a problem occurs...
+              }
+            }
+          },
+          // receive 100+ unidi streams and do not block
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/streamlimits_getunidis')
+            )) {
+              try {
+                await session.ready
+                const unidistreams = []
+                while (unidistreams.length < 150) {
+                  unidistreams.push(
+                    await getReaderValue(session.incomingUnidirectionalStreams)
+                  )
+                }
+                await session.close()
+              } catch (error) {
+                // do not crash server, if a problem occurs...
+              }
+            }
+          },
           // cleanly close remote sessions
           async () => {
             for await (const session of getReaderStream(
@@ -281,8 +384,10 @@ if (process.send)
     address: `https://${address.host}:${address.port}`,
     certificate: certificate.fingerprint
   })
-else console.error('No IPC channel')
-/* console.log({
-  address: `https://${address.host}:${address.port}`,
-  certificate: certificate.fingerprint
-}) */
+else {
+  console.error('No IPC channel')
+  console.log({
+    address: `https://${address.host}:${address.port}`,
+    certificate: certificate.fingerprint
+  })
+}

package/test/fixtures/webtransport.browser.js

@@ -6,7 +6,7 @@ import {
 /** @type {import('../../lib/dom').WebTransport} */
 // @ts-ignore
 // eslint-disable-next-line no-undef
-let webtransport = WebTransport
+let webtransport = globalThis.WebTransport
 if (process.env.USE_POLYFILL === 'true') {
   // @ts-ignore
   webtransport = WebTransportPolyfill

package/test/index.js

@@ -70,7 +70,7 @@ async function runTests(certificate, serverAddress) {
     })
 
     await tests
-  } else if (env === 'chromium' || env === 'firefox') {
+  } else if (env === 'chromium' || env === 'firefox' || env === 'webkit') {
     command = 'playwright-test'
     const otheropts = []
     if (polyfill || ponyfill || env === 'firefox')