@fails-components/webtransport 1.6.7 → 1.6.9

package/lib/http2/parserbase.js

@@ -5,18 +5,6 @@ import { PriorityScheduler } from './priorityscheduler.js'
 const pid = typeof process !== 'undefined' ? process.pid : 0
 const log = logger(`webtransport:parserbase(${pid})`)
 
-/**
- * @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
@@ -66,7 +54,7 @@ export class ParserBase {
 
   /**
    * @abstract
-   * @param {Buffer|Uint8Array} data
+   * @param {Uint8Array[]} data
    */
   // eslint-disable-next-line no-unused-vars
   parseData(data) {
@@ -282,10 +270,17 @@ export class ParserBase {
    * @param {{code:  number, reason: string}} opts
    */
   onCloseWebTransportSession({ code, reason }) {
-    this.session.jsobj.onClose({
-      errorcode: code,
-      error: reason
-    })
+    if (
+      !(
+        this.session.jsobj.state === 'failed' ||
+        this.session.jsobj.state === 'closed'
+      )
+    ) {
+      this.session.jsobj.onClose({
+        errorcode: code,
+        error: reason
+      })
+    }
     this.closeHttp2Stream(code) // is this necessary
   }
 

package/lib/http2/parserbasehttp2.js

@@ -4,68 +4,6 @@ import { ParserBase } from './parserbase.js'
  * @typedef {import('node:http2').Http2Stream} Http2Stream
  */
 
-/**
- * @param{{offset: Number, buffer: Buffer, size: Number}} bs
- */
-
-export function readUint32(bs) {
-  if (bs.offset + 4 > bs.size) return undefined
-  const toret = bs.buffer.readUInt32BE(bs.offset)
-  bs.offset += 4
-  return toret
-}
-
-/**
- * @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
@@ -96,7 +34,7 @@ export class ParserBaseHttp2 extends ParserBase {
     this.stream.on('readable', () => {
       let data
       while ((data = this.stream.read()) !== null) {
-        this.parseData(data)
+        this.parseData([data])
       }
     })
 
@@ -110,10 +48,17 @@ export class ParserBaseHttp2 extends ParserBase {
        * @param {Error} error
        */ (error) => {
         // readable error
-        this.session.jsobj.onClose({
-          errorcode: this.stream.rstCode,
-          error: error.toString()
-        })
+        if (
+          !(
+            this.session.jsobj.state === 'failed' ||
+            this.session.jsobj.state === 'closed'
+          )
+        ) {
+          this.session.jsobj.onClose({
+            errorcode: this.stream.rstCode,
+            error: error.toString()
+          })
+        }
       }
     )
 

package/lib/http2/stream.js

@@ -92,17 +92,26 @@ export class Http2WebTransportStream {
 
   /**
    * @param {Object} obj
-   * @param {Uint8Array|undefined} obj.data
+   * @param {Uint8Array[]|undefined} obj.data
    * @param {Boolean} obj.fin
    */
   recvData({ data, fin }) {
-    this.incomdata.push({ data, fin })
-    if (data && data?.byteLength > 0) {
-      const checkstream = this.flowController.updateHighestReceivedOffset(
-        data?.byteLength
-      )
+    let datasize = 0
+    if (data) {
+      const newincomdata = data.map((el, ind, array) => ({
+        data: el,
+        fin: fin && ind + 1 === array.length
+      }))
+      datasize = data.reduce((acc, curVal) => acc + curVal.byteLength, 0)
+      this.incomdata.push(...newincomdata)
+    } else if (fin) {
+      this.incomdata.push({ data: undefined, fin })
+    }
+    if (datasize > 0) {
+      const checkstream =
+        this.flowController.updateHighestReceivedOffset(datasize)
       const checksession =
-        this.sessionFlowController.updateHighestReceivedOffset(data?.byteLength)
+        this.sessionFlowController.updateHighestReceivedOffset(datasize)
       if (checksession && checkstream) {
         // As the highest received offset has changed, check to see if this is a
         // violation of flow control.

package/lib/session.js

@@ -388,39 +388,41 @@ export class HttpWTSession {
   }
 
   /**
-   * @param {WebTransportSendStream} stream
-   * @param {WritableStreamDefaultController} controller
+   * @param {HttpWTStream} streamobj
    */
-  addSendStream(stream, controller) {
-    this.sendStreams.add(stream)
-    this.sendStreamsController.add(controller)
+  addSendStream(streamobj) {
+    this.sendStreams.add(streamobj.writable)
+    this.sendStreamsController.add(streamobj.writableController)
   }
 
   /**
-   * @param {WebTransportSendStream} stream
-   * @param {WritableStreamDefaultController} controller
+   * @param {HttpWTStream} streamobj
    */
-  removeSendStream(stream, controller) {
-    this.sendStreams.delete(stream)
-    this.sendStreamsController.delete(controller)
+  removeSendStream(streamobj) {
+    this.sendStreams.delete(streamobj.writable)
+    this.sendStreamsController.delete(streamobj.writableController)
+    if (!streamobj.readable || !this.receiveStreams.has(streamobj.readable)) {
+      this.streamObjs.delete(streamobj)
+    }
   }
 
   /**
-   * @param {WebTransportReceiveStream } stream
-   * @param {ReadableStreamDefaultController} controller
+   * @param {HttpWTStream} streamobj
    */
-  addReceiveStream(stream, controller) {
-    this.receiveStreams.add(stream)
-    this.receiveStreamsController.add(controller)
+  addReceiveStream(streamobj) {
+    this.receiveStreams.add(streamobj.readable)
+    this.receiveStreamsController.add(streamobj.readableController)
   }
 
   /**
-   * @param {WebTransportReceiveStream } stream
-   * @param {ReadableStreamDefaultController} controller
+   * @param {HttpWTStream} streamobj
    */
-  removeReceiveStream(stream, controller) {
-    this.receiveStreams.delete(stream)
-    this.receiveStreamsController.delete(controller)
+  removeReceiveStream(streamobj) {
+    this.receiveStreams.delete(streamobj.readable)
+    this.receiveStreamsController.delete(streamobj.readableController)
+    if (!streamobj.writable || !this.sendStreams.has(streamobj.writable)) {
+      this.streamObjs.delete(streamobj)
+    }
   }
 
   /**

package/lib/stream.js

@@ -102,10 +102,7 @@ export class HttpWTStream {
             else code = reason.code
           }
           this.readableclosed = true
-          this.parentobj.removeReceiveStream(
-            this.readable,
-            this.readableController
-          )
+          this.parentobj.removeReceiveStream(this)
           this.objint.stopSending(code)
           return promise
         },
@@ -129,8 +126,7 @@ export class HttpWTStream {
           bytesRead: 0n
         })
       }
-      // @ts-ignore
-      this.parentobj.addReceiveStream(this.readable, this.readableController)
+      this.parentobj.addReceiveStream(this)
     }
     if (this.bidirectional || !this.incoming) {
       /** @type {WebTransportSendStream} */
@@ -173,10 +169,7 @@ export class HttpWTStream {
             }
             this.writableclosed = true
             this.objint.streamFinal()
-            this.parentobj.removeSendStream(
-              this.writable,
-              this.writableController
-            )
+            this.parentobj.removeSendStream(this)
             // eslint-disable-next-line no-unused-vars
             this.pendingoperation = new Promise((resolve, reject) => {
               this.pendingres = resolve
@@ -197,10 +190,7 @@ export class HttpWTStream {
               else if (reason.code > 255) code = 255
               else code = reason.code
             }
-            this.parentobj.removeSendStream(
-              this.writable,
-              this.writableController
-            )
+            this.parentobj.removeSendStream(this)
             /** @type {Promise<void>} */
             // eslint-disable-next-line no-unused-vars
             const promise = new Promise((resolve, reject) => {
@@ -250,8 +240,7 @@ export class HttpWTStream {
           }
         }
       })
-      // @ts-ignore
-      this.parentobj.addSendStream(this.writable, this.writableController)
+      this.parentobj.addSendStream(this)
     }
 
     /** @type {(() => void) | null} */
@@ -321,10 +310,7 @@ export class HttpWTStream {
       if (parentstate === 'closed' || parentstate === 'failed') {
         log('no parent cleanup for fin as parent was closed or failed')
       } else {
-        this.parentobj.removeReceiveStream(
-          this.readable,
-          this.readableController
-        )
+        this.parentobj.removeReceiveStream(this)
       }
       if (!this.readableclosed) {
         this.readableController.close()
@@ -361,11 +347,7 @@ export class HttpWTStream {
       case 'resetStream':
         if (this.readable) {
           this.finalDrain()
-          if (parentcleanup)
-            this.parentobj.removeReceiveStream(
-              this.readable,
-              this.readableController
-            )
+          if (parentcleanup) this.parentobj.removeReceiveStream(this)
           if (!this.readableclosed) {
             this.readableclosed = true
             this.readableController.error(
@@ -379,11 +361,7 @@ export class HttpWTStream {
 
       case 'stopSending':
         if (this.writable) {
-          if (parentcleanup)
-            this.parentobj.removeSendStream(
-              this.writable,
-              this.writableController
-            )
+          if (parentcleanup) this.parentobj.removeSendStream(this)
           if (!this.writableclosed) {
             this.writableclosed = true
             this.writableController.error(
@@ -457,16 +435,8 @@ export class HttpWTStream {
           const res = this.abortres
           this.abortres = null
           res()
-          if (this.readable)
-            this.parentobj.removeReceiveStream(
-              this.readable,
-              this.readableController
-            )
-          if (this.writable)
-            this.parentobj.removeSendStream(
-              this.writable,
-              this.writableController
-            )
+          if (this.readable) this.parentobj.removeReceiveStream(this)
+          if (this.writable) this.parentobj.removeSendStream(this)
           this.readableclosed = true
           this.parentobj.removeStreamObj(this)
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "1.6.7",
+  "version": "1.6.9",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "exports": {
     ".": {