@fails-components/webtransport 1.6.7 → 1.6.9

package/lib/http2/browser/browserparser.js

@@ -1,72 +1,17 @@
-import { ParserBase, lengthVarInt } from '../parserbase.js'
+import { ParserBase } from '../parserbase.js'
+import {
+  lengthVarInt,
+  readUint32,
+  readVarInt,
+  writeVarInt,
+  getUint8ArrayfromBuffer,
+  getUint8ArraysfromBuffer,
+  advanceBufferToOffset,
+  detachReadBuffers
+} from '../bufferHelper.js'
 import { logger } from '../../utils.js'
 
 const log = logger(`webtransport:http2:browserparser`)
-/**
- * @param{{offset: Number, buffer: Uint8Array, size: Number}} bs
- */
-function readVarInt(bs) {
-  if (bs.offset + 1 > bs.size) return undefined
-  let val = BigInt(bs.buffer[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[bs.offset])
-    bs.offset++
-  }
-  return val
-}
-
-/**
- * @param{{offset: Number, buffer: Uint8Array, size: Number}} bs
- */
-function readUint32(bs) {
-  if (bs.offset + 4 > bs.size) return undefined
-  let val = bs.buffer[bs.offset]
-  bs.offset++
-  val = (val << 8) | bs.buffer[bs.offset]
-  bs.offset++
-  val = (val << 8) | bs.buffer[bs.offset]
-  bs.offset++
-  val = (val << 8) | bs.buffer[bs.offset]
-  bs.offset++
-  return val
-}
-
-/**
- * @param{{offset: Number, buffer: Uint8Array, size: Number}} bs
- * @param{Number|bigint} int
- */
-export function writeVarInt(bs, int) {
-  let numbytes = 8n
-  let msb = 0xc0n
-  const bint = BigInt(int)
-  if (bint < 64n) {
-    numbytes = 1n
-    msb = 0x0n
-  } else if (bint < 16384n) {
-    numbytes = 2n
-    msb = 0x40n
-  } else if (bint < 1073741824n) {
-    numbytes = 4n
-    msb = 0x80n
-  }
-  bs.buffer[bs.offset] = Number(
-    msb | ((bint >> ((numbytes - 1n) * 8n)) & 0xffn)
-  )
-  bs.offset++
-
-  for (let i = numbytes - 2n; i >= 0n; i--) {
-    bs.buffer[bs.offset] = Number((bint >> (i * 8n)) & 0xffn)
-    bs.offset++
-  }
-}
 
 export class BrowserParser extends ParserBase {
   static WS_CONTINUE = 0x0
@@ -98,8 +43,18 @@ export class BrowserParser extends ParserBase {
       streamReceiveWindowSizeLimit
     })
     this.ws = ws
-    /** @type {Buffer|undefined} */
-    this.saveddata = undefined
+    this.bufferstate = {
+      /** @type {number} */
+      offset: 0,
+      /** @type {number} */
+      size: 0,
+      /** @type {Uint8Array[]} */
+      buffer: [],
+      /** @type {number} */
+      curBuf: 0,
+      /** @type {number} */
+      curBufOffset: 0
+    }
     /** @type {Number|undefined} */
     this.rtype = undefined
 
@@ -108,7 +63,7 @@ export class BrowserParser extends ParserBase {
     this.ws.addEventListener('message', (event) => {
       if (event.data instanceof ArrayBuffer) {
         // binary frame
-        this.parseData(new Uint8Array(event.data, 0, event.data.byteLength))
+        this.parseData([new Uint8Array(event.data, 0, event.data.byteLength)])
       } else {
         // text frame
         log('Illegal text frame', event.data)
@@ -117,10 +72,12 @@ export class BrowserParser extends ParserBase {
   }
 
   /**
-   * @param {Uint8Array} data
+   * @param {Uint8Array[]} data
    */
   parseData(data) {
-    const bufferstate = { offset: 0, size: data.byteLength, buffer: data }
+    const bufferstate = this.bufferstate
+    bufferstate.buffer.push(...data)
+    bufferstate.size += data.reduce((sum, chunk) => sum + chunk.byteLength, 0)
 
     const offsetend = bufferstate.size
 
@@ -175,9 +132,8 @@ export class BrowserParser extends ParserBase {
               const fin = type === ParserBase.WT_STREAM_WFIN
               if (fin) object.onFin()
               object.recvData({
-                data: new Uint8Array(
-                  bufferstate.buffer.buffer,
-                  bufferstate.buffer.byteOffset + bufferstate.offset,
+                data: getUint8ArraysfromBuffer(
+                  bufferstate,
                   offsetend - bufferstate.offset
                 ),
                 fin
@@ -224,13 +180,15 @@ export class BrowserParser extends ParserBase {
         {
           const code = readUint32(bufferstate) || 0
           const decoder = new TextDecoder()
-          const reason = decoder.decode(
-            new Uint8Array(
-              bufferstate.buffer.buffer,
-              bufferstate.buffer.byteOffset + bufferstate.offset,
-              offsetend - bufferstate.offset
-            )
-          )
+          const reason =
+            offsetend - bufferstate.offset > 0
+              ? decoder.decode(
+                  getUint8ArrayfromBuffer(
+                    bufferstate,
+                    offsetend - bufferstate.offset
+                  )
+                )
+              : ''
           this.onCloseWebTransportSession({ code, reason })
         }
         break
@@ -239,19 +197,19 @@ export class BrowserParser extends ParserBase {
         break
       case ParserBase.DATAGRAM:
         this.session.jsobj.onDatagramReceived({
-          datagram: new Uint8Array(
-            bufferstate.buffer.buffer,
-            bufferstate.buffer.byteOffset + bufferstate.offset,
-            offsetend - bufferstate.offset
-          )
+          datagram:
+            getUint8ArrayfromBuffer(
+              bufferstate,
+              offsetend - bufferstate.offset
+            ) || new Uint8Array(0)
         })
 
         break
       default:
       // do nothing
     }
-
-    bufferstate.offset = offsetend
+    advanceBufferToOffset(bufferstate, offsetend)
+    detachReadBuffers(bufferstate)
   }
 
   /**
@@ -265,7 +223,13 @@ export class BrowserParser extends ParserBase {
     if (payload) plength += payload.byteLength
 
     const cdata = new Uint8Array(plength)
-    const bufferstate = { offset: 0, size: cdata.length, buffer: cdata }
+    const bufferstate = {
+      offset: 0,
+      size: cdata.length,
+      buffer: [cdata],
+      curBuf: 0,
+      curBufOffset: 0
+    }
     writeVarInt(bufferstate, type)
     for (const ind in headerVints) writeVarInt(bufferstate, headerVints[ind])
     const dest = new Uint8Array(cdata.buffer, cdata.byteOffset + hlength)

package/lib/http2/bufferHelper.js

@@ -0,0 +1,269 @@
+/**
+ * @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
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ */
+export function advanceBuffer(bs) {
+  bs.curBufOffset++
+  if (bs.curBufOffset === bs.buffer[bs.curBuf].byteLength) {
+    bs.curBufOffset = 0
+    bs.curBuf++
+  }
+  bs.offset++
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @param{number} offset
+ */
+export function advanceBufferToOffset(bs, offset) {
+  if (bs.offset >= offset) return
+  let remainConsume = offset - bs.offset
+  while (remainConsume > 0) {
+    const curBufferSpace = bs.buffer[bs.curBuf].byteLength - bs.curBufOffset
+    if (curBufferSpace > remainConsume) {
+      bs.curBufOffset += remainConsume
+      bs.offset += remainConsume
+      return // done last buffer to touch
+    }
+    remainConsume -= curBufferSpace
+    bs.offset += curBufferSpace
+    bs.curBufOffset = 0
+    bs.curBuf++
+  }
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @param{number} length
+ */
+export function advanceBufferBy(bs, length) {
+  return advanceBufferToOffset(bs, bs.offset + length)
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ */
+export function detachReadBuffers(bs) {
+  while (bs.buffer.length > 1 && bs.buffer[0].byteLength < bs.offset) {
+    const curBuf = bs.buffer.shift()
+    // @ts-ignore
+    const curBufSize = curBuf.byteLength
+    bs.size -= curBufSize
+    bs.offset -= curBufSize
+    bs.curBuf--
+  }
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @param {number} length
+ */
+export function getUint8ArraysfromBuffer(bs, length) {
+  /** @type {Uint8Array[]} */
+  const retArr = new Array()
+  let remainLen = length
+  let curBufOffset = bs.curBufOffset // note this does not advance the buffer
+  let curBuf = bs.curBuf
+  while (remainLen > 0) {
+    const curbuf = bs.buffer[curBuf]
+    const avail = Math.min(curbuf.byteLength - curBufOffset, remainLen)
+    if (avail !== 0) {
+      retArr.push(
+        new Uint8Array(curbuf.buffer, curbuf.byteOffset + curBufOffset, avail)
+      )
+    }
+    curBufOffset = 0
+    curBuf++
+    remainLen -= avail
+  }
+  if (retArr.length === 0) return undefined
+  return retArr
+}
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @param {number} length
+ */
+export function getUint8ArrayfromBuffer(bs, length) {
+  const chunks = getUint8ArraysfromBuffer(bs, length)
+
+  if (typeof chunks === 'undefined') return undefined
+
+  const totalLength = chunks.reduce((acc, c) => acc + c.length, 0)
+  const result = new Uint8Array(totalLength)
+
+  let offset = 0
+  for (let i = 0; i < chunks.length; i++) {
+    result.set(chunks[i], offset)
+    offset += chunks[i].length
+  }
+  return result
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ */
+
+export function readUInt8(bs) {
+  return bs.buffer[bs.curBuf][bs.curBufOffset]
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @returns {number}
+ */
+export function readUInt16BE(bs) {
+  const highByte = readUInt8(bs)
+  advanceBuffer(bs)
+  const lowByte = readUInt8(bs)
+  advanceBuffer(bs)
+
+  return (highByte << 8) | lowByte
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @param {number} length
+ * @returns {string}
+ */
+export function readString(bs, length) {
+  const data = getUint8ArrayfromBuffer(bs, length)
+  advanceBufferBy(bs, length)
+  const utf8decoder = new TextDecoder('utf-8')
+  return utf8decoder.decode(data)
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @param{Number} value
+ */
+export function writeUInt8(bs, value) {
+  bs.buffer[bs.curBuf][bs.curBufOffset] = value
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ */
+export function readVarInt(bs) {
+  if (bs.offset + 1 > bs.size) return undefined
+
+  let val = BigInt(readUInt8(bs))
+  advanceBuffer(bs)
+  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(readUInt8(bs))
+    advanceBuffer(bs)
+  }
+  return val
+}
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ */
+export function readUint32(bs) {
+  if (bs.offset + 4 > bs.size) return undefined
+  let val = readUInt8(bs)
+  advanceBuffer(bs)
+  val = (val << 8) | readUInt8(bs)
+  advanceBuffer(bs)
+  val = (val << 8) | readUInt8(bs)
+  advanceBuffer(bs)
+  val = (val << 8) | readUInt8(bs)
+  advanceBuffer(bs)
+  return val
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @param{number} value
+ */
+export function writeUint16BE(bs, value) {
+  writeUInt8(bs, (value >> 8) & 0xff)
+  advanceBuffer(bs)
+  writeUInt8(bs, value & 0xff)
+  advanceBuffer(bs)
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @param{number} value
+ */
+export function writeUint32BE(bs, value) {
+  writeUInt8(bs, (value >>> 24) & 0xff)
+  advanceBuffer(bs)
+  writeUInt8(bs, (value >>> 16) & 0xff)
+  advanceBuffer(bs)
+  writeUInt8(bs, (value >>> 8) & 0xff)
+  advanceBuffer(bs)
+  writeUInt8(bs, value & 0xff)
+  advanceBuffer(bs)
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: Number}} bs
+ * @param{bigint} value
+ */
+export function writeBigInt64BE(bs, value) {
+  const val = BigInt(value)
+
+  writeUInt8(bs, Number((val >> 56n) & 0xffn))
+  advanceBuffer(bs)
+  writeUInt8(bs, Number((val >> 48n) & 0xffn))
+  advanceBuffer(bs)
+  writeUInt8(bs, Number((val >> 40n) & 0xffn))
+  advanceBuffer(bs)
+  writeUInt8(bs, Number((val >> 32n) & 0xffn))
+  advanceBuffer(bs)
+  writeUInt8(bs, Number((val >> 24n) & 0xffn))
+  advanceBuffer(bs)
+  writeUInt8(bs, Number((val >> 16n) & 0xffn))
+  advanceBuffer(bs)
+  writeUInt8(bs, Number((val >> 8n) & 0xffn))
+  advanceBuffer(bs)
+  writeUInt8(bs, Number(val & 0xffn))
+  advanceBuffer(bs)
+}
+
+/**
+ * @param{{offset: Number, buffer: Uint8Array[], size: Number, curBuf: Number, curBufOffset: 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
+  }
+  writeUInt8(bs, Number(msb | ((bint >> ((numbytes - 1n) * 8n)) & 0xffn)))
+  advanceBuffer(bs)
+
+  for (let i = numbytes - 2n; i >= 0; i--) {
+    writeUInt8(bs, Number((bint >> (i * 8n)) & 0xffn))
+    advanceBuffer(bs)
+  }
+}