@fails-components/webtransport 0.1.5 → 0.2.0

package/src/http3wtstreamvisitor.h

@@ -34,7 +34,15 @@ namespace quic
         friend Http3WTStreamJS;
 
     public:
-        Http3WTStream(WebTransportStream *stream, Http3EventLoop *eventloop) : stream_(stream), eventloop_(eventloop), js_(nullptr)
+        Http3WTStream(WebTransportStream *stream, Http3EventLoop *eventloop) : 
+            stream_(stream),
+            eventloop_(eventloop), 
+            js_(nullptr), 
+            readpos_(0),
+            writepos_(0),
+            bufferlen_(0),
+            readbufsize_(0),
+            readbufdata_(nullptr)
         {
         }
 
@@ -90,10 +98,16 @@ namespace quic
             }
         }
 
+
+        inline bool readBufferFull() {
+            return !readbufdata_ || bufferlen_ >= readbufsize_;
+        }
+
         void tryRead()
         {
             pause_reading_ = false;
-            if (stream_ && ((stream_->ReadableBytes() > 0) || can_read_pending_))
+            if (stream_ && ((stream_->ReadableBytes() > 0) || can_read_pending_)
+               && !readBufferFull())
             {
                 can_read_pending_ = false;
                 doCanRead();
@@ -113,6 +127,17 @@ namespace quic
             return !stream_;
         }
 
+        void setReadBuffer(void * data, size_t length) {
+            std::function<void()> task = [this, data, length]()
+            {
+                readbufsize_ = length;
+                readbufdata_ = data;
+                tryRead();
+            };
+            eventloop_->Schedule(task);
+        }
+
+
     protected:
         // internal functions called by js object
         void startReadingInt()
@@ -137,6 +162,13 @@ namespace quic
             eventloop_->Schedule(task);
         }
 
+        void updateReadPosIntJS(size_t readbytes, uint32_t readpos)
+        {
+            std::function<void()> task = [this, readpos, readbytes]()
+            { updateReadPosInt(readbytes, readpos); };
+            eventloop_->Schedule(task);
+        }
+
         void streamFinalInt()
         {
             std::function<void()> task = [this]()
@@ -202,6 +234,17 @@ namespace quic
             tryWrite();
         }
 
+        void updateReadPosInt(size_t readbytes, uint32_t readpos)
+        {
+            if (!stream_)
+            {
+                return;
+            }
+            readpos_ = readpos;
+            bufferlen_ -= readbytes;
+            tryRead();
+        }
+
         void cancelWrite(Napi::ObjectReference *handle);
 
     private:
@@ -217,6 +260,13 @@ namespace quic
         bool can_read_pending_ = false;
         bool stream_was_reset_ = false;
         std::deque<WChunks> chunks_;
+
+        //reading stream
+        uint32_t readpos_;
+        uint32_t writepos_;
+        uint32_t bufferlen_;
+        size_t readbufsize_;
+        void * readbufdata_;
     };
 
     class Http3WTStreamJS : public Napi::ObjectWrap<Http3WTStreamJS>, public LifetimeHelper
@@ -254,6 +304,31 @@ namespace quic
             wtstream_->writeChunkIntJS(buffer, len, bufferhandle);
         }
 
+        void updateReadPos(const Napi::CallbackInfo &info)
+        {
+            // ok we have to get the buffer
+            uint32_t readpos = 0;
+            size_t readbytes = 0;
+
+            if (!info[0].IsUndefined())
+            {
+                Napi::Number readbytesl = info[0].ToNumber();
+                readbytes = readbytesl.Uint32Value();
+            } else {
+                return Napi::Error::New(Env(), "No readbytes passed").ThrowAsJavaScriptException();
+            }
+
+            if (!info[1].IsUndefined())
+            {
+                Napi::Number readposl = info[1].ToNumber();
+                readpos = readposl.Uint32Value();
+            } else {
+                return Napi::Error::New(Env(), "No readpos passed").ThrowAsJavaScriptException();
+            }
+
+            wtstream_->updateReadPosIntJS(readbytes, readpos);
+        }
+
         void streamFinal(const Napi::CallbackInfo &info)
         {
             wtstream_->streamFinalInt();
@@ -292,9 +367,12 @@ namespace quic
                 DefineClass(env, "Http3WTStreamVisitor",
                             {InstanceMethod<&Http3WTStreamJS::writeChunk>("writeChunk",
                                                                           static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                             InstanceMethod<&Http3WTStreamJS::updateReadPos>("updateReadPos",
+                                                                          static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                              InstanceMethod<&Http3WTStreamJS::resetStream>("resetStream",
                                                                            static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-                             InstanceMethod<&Http3WTStreamJS::stopSending>("stopSending", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&Http3WTStreamJS::streamFinal>("streamFinal", static_cast<napi_property_attributes>(napi_writable | napi_configurable)), InstanceMethod<&Http3WTStreamJS::startReading>("startReading", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                             InstanceMethod<&Http3WTStreamJS::stopSending>("stopSending", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                             InstanceMethod<&Http3WTStreamJS::streamFinal>("streamFinal", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                              InstanceMethod<&Http3WTStreamJS::startReading>("startReading",
                                                                            static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                              InstanceMethod<&Http3WTStreamJS::stopReading>("stopReading",

package/test/bidirectional-streams.spec.js

@@ -7,6 +7,7 @@ import { expect } from './fixtures/chai.js'
 import { readStream } from './fixtures/read-stream.js'
 import { writeStream } from './fixtures/write-stream.js'
 import { defer } from '../lib/utils.js'
+import * as ui8 from 'uint8arrays'
 
 /**
  * @template T
@@ -43,6 +44,7 @@ describe('bidirectional streams', function () {
     url = `https://${address.host}:${address.port}`
   })
 
+  // @ts-ignore
   afterEach(async () => {
     if (client != null) {
       client.close()
@@ -59,6 +61,7 @@ describe('bidirectional streams', function () {
     // server context - waits for the client to open a bidi stream and pipes it back to them
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('Got no session')
       const bidiStream = await getReaderValue(
         session.incomingBidirectionalStreams
       )
@@ -86,9 +89,9 @@ describe('bidirectional streams', function () {
     const stream = await client.createBidirectionalStream()
     await writeStream(stream.writable, input)
 
-    const output = await readStream(stream.readable)
-    expect(output).to.deep.equal(
-      input,
+    const output = await readStream(stream.readable, ui8.concat(input).length)
+    expect(ui8.concat(output)).to.deep.equal(
+      ui8.concat(input),
       'Did not receive the same bytes we sent'
     )
   })
@@ -106,12 +109,14 @@ describe('bidirectional streams', function () {
     // server context - waits for the client to connect, opens a bidi stream, sends some data and reads the response
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('Got no session')
       const stream = await session.createBidirectionalStream()
 
       await writeStream(stream.writable, input)
 
-      const output = await readStream(stream.readable)
+      const output = await readStream(stream.readable, ui8.concat(input).length)
       serverData.resolve(output)
+      await stream.readable.cancel() // cancel so that the client can progress
     })
 
     // client context - waits for the server to open a bidi stream then pipes it back to them
@@ -127,11 +132,15 @@ describe('bidirectional streams', function () {
 
     const bidiStream = await getReaderValue(client.incomingBidirectionalStreams)
     // redirect input to output
-    await bidiStream.readable.pipeTo(bidiStream.writable)
+    try {
+      await bidiStream.readable.pipeTo(bidiStream.writable)
+    } catch (error) {
+      console.log('Pipe to error (ignore)', error) // Actually all you can get is, that the fin is catched
+    }
 
     const received = await serverData.promise
-    expect(received).to.deep.equal(
-      input,
+    expect(ui8.concat(received)).to.deep.equal(
+      ui8.concat(input),
       'Did not receive the same bytes we sent'
     )
   })

package/test/datagrams.spec.js

@@ -6,7 +6,8 @@ import { WebTransport } from '../lib/index.js'
 import { expect } from './fixtures/chai.js'
 import { readStream } from './fixtures/read-stream.js'
 import { writeStream } from './fixtures/write-stream.js'
-import { defer } from '../lib/utils.js'
+import * as ui8 from 'uint8arrays'
+import { pTimeout } from './fixtures/p-timeout.js'
 
 /**
  * @template T
@@ -39,6 +40,7 @@ describe('datagrams', function () {
     url = `https://${address.host}:${address.port}`
   })
 
+  // @ts-ignore
   afterEach(async () => {
     if (client != null) {
       client.close()
@@ -79,7 +81,10 @@ describe('datagrams', function () {
 
     await writeStream(client.datagrams.writable, input)
 
-    const output = await readStream(client.datagrams.readable, input.length)
+    const output = await readStream(
+      client.datagrams.readable,
+      ui8.concat(input).length
+    )
     expect(output).to.deep.equal(
       input,
       'Did not receive the same bytes we sent'
@@ -88,25 +93,29 @@ describe('datagrams', function () {
 
   it('receives datagrams from the server', async () => {
     this.timeout(200)
-    /** @type {Deferred<Uint8Array[]>} */
-    const serverData = defer()
-    const input = [
-      Uint8Array.from([0, 1, 2, 3, 4]),
-      Uint8Array.from([5, 6, 7, 8, 9]),
-      Uint8Array.from([10, 11, 12, 13, 14])
-    ]
 
     // server context - waits for the client to connect, sends some datagrams and reads the response
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
 
-      await writeStream(session.datagrams.writable, input)
-
-      const output = await readStream(session.datagrams.readable, input.length)
+      let closed = false
+      const writer = session.datagrams.writable.getWriter()
+      Promise.resolve().then(async () => {
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (!closed) {
+          try {
+            await writer.ready
+            await writer.write(Uint8Array.from([0, 1, 2, 3, 4]))
+            await new Promise((resolve) => setTimeout(resolve, 1)) // do not flood everything
+          } catch {
+            // the session can be closed while we are writing
+          }
+        }
+      })
 
       // have to close the session to end the client's datagram stream
-      session.close()
-      serverData.resolve(output)
+      await session.closed
+      closed = true
     })
 
     // client context - pipes the server's datagrams back to them
@@ -120,13 +129,15 @@ describe('datagrams', function () {
     })
     await client.ready
 
-    // redirect input to output
-    await client.datagrams.readable.pipeTo(client.datagrams.writable)
+    // datagram transport is unreliable, at least one message should make it through
+    const expected = 1
 
-    const received = await serverData.promise
-    expect(received).to.deep.equal(
-      input,
-      'Did not receive the same bytes we sent'
+    const received = await pTimeout(
+      readStream(client.datagrams.readable, expected),
+      1000
     )
+    await client.close()
+    client = undefined
+    expect(received).to.have.lengthOf(expected)
   })
 })

package/test/fixtures/p-timeout.js

@@ -0,0 +1,33 @@
+class TimeoutError extends Error {
+  /**
+   * @param {string} message
+   */
+  constructor(message) {
+    super(message)
+
+    this.name = this[Symbol.toStringTag] = 'TimeoutError'
+  }
+}
+
+/**
+ * @template T
+ * @param {Promise<T>} promise
+ * @param {number} timeout
+ * @returns {Promise<T>}
+ */
+export async function pTimeout(promise, timeout) {
+  let ref
+
+  const value = await Promise.race([
+    promise,
+    new Promise((resolve, reject) => {
+      ref = setTimeout(() => {
+        reject(new TimeoutError('timeout'))
+      }, timeout)
+    })
+  ])
+
+  clearTimeout(ref)
+
+  return value
+}

package/test/fixtures/read-stream.js

@@ -12,6 +12,7 @@ export async function readStream(readable, expected) {
   try {
     /** @type {T[]} */
     const output = []
+    let outputlength = 0
 
     while (true) {
       const { done, value } = await reader.read()
@@ -21,10 +22,12 @@ export async function readStream(readable, expected) {
       }
 
       if (value != null) {
+        // @ts-ignore
+        outputlength += value.length
         output.push(value)
       }
 
-      if (expected != null && output.length === expected) {
+      if (expected != null && outputlength >= expected) {
         break
       }
     }

package/test/unidirectional-streams.spec.js

@@ -7,6 +7,7 @@ import { expect } from 'chai'
 import { readStream } from './fixtures/read-stream.js'
 import { writeStream } from './fixtures/write-stream.js'
 import { defer } from '../lib/utils.js'
+import * as ui8 from 'uint8arrays'
 
 /**
  * @template T
@@ -39,6 +40,7 @@ describe('unidirectional streams', function () {
     url = `https://${address.host}:${address.port}`
   })
 
+  // @ts-ignore
   afterEach(async () => {
     if (client != null) {
       client.close()
@@ -55,13 +57,21 @@ describe('unidirectional streams', function () {
     /** @type {Deferred<Uint8Array[]>} */
     const serverData = defer()
 
+    const input = [
+      Uint8Array.from([0, 1, 2, 3, 4]),
+      Uint8Array.from([5, 6, 7, 8, 9]),
+      Uint8Array.from([10, 11, 12, 13, 14])
+    ]
+
     // server context - waits for the client to open a bidi stream and pipes it back to them
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('no session')
       const stream = await getReaderValue(session.incomingUnidirectionalStreams)
 
-      const output = await readStream(stream)
+      const output = await readStream(stream, ui8.concat(input).length)
       serverData.resolve(output)
+      await stream.cancel() // cancel so that the client can progress
     })
 
     // client context - connects to the server, opens a bidi stream, sends some data and reads the response
@@ -75,18 +85,12 @@ describe('unidirectional streams', function () {
     })
     await client.ready
 
-    const input = [
-      Uint8Array.from([0, 1, 2, 3, 4]),
-      Uint8Array.from([5, 6, 7, 8, 9]),
-      Uint8Array.from([10, 11, 12, 13, 14])
-    ]
-
     const stream = await client.createUnidirectionalStream()
     await writeStream(stream, input)
 
     const received = await serverData.promise
-    expect(received).to.deep.equal(
-      input,
+    expect(ui8.concat(received)).to.deep.equal(
+      ui8.concat(input),
       'Server did not receive the same bytes we sent'
     )
   })
@@ -102,6 +106,7 @@ describe('unidirectional streams', function () {
     // server context - waits for the client to connect, opens a bidi stream, sends some data and reads the response
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('no session')
       const stream = await session.createUnidirectionalStream()
 
       await writeStream(stream, input)
@@ -119,9 +124,9 @@ describe('unidirectional streams', function () {
     await client.ready
 
     const stream = await getReaderValue(client.incomingUnidirectionalStreams)
-    const received = await readStream(stream)
-    expect(received).to.deep.equal(
-      input,
+    const received = await readStream(stream, ui8.concat(input).length)
+    expect(ui8.concat(received)).to.deep.equal(
+      ui8.concat(input),
       'Did not receive the same bytes we sent'
     )
   })
@@ -134,6 +139,7 @@ describe('unidirectional streams', function () {
 
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('Got no session')
       const stream = await getReaderValue(session.incomingUnidirectionalStreams)
 
       serverStream.resolve(stream)
@@ -171,9 +177,12 @@ describe('unidirectional streams', function () {
 
     await new Promise((resolve) => setTimeout(resolve, 1000))
 
-    const received = await readStream(await serverStream.promise)
-    expect(received).to.deep.equal(
-      input,
+    const received = await readStream(
+      await serverStream.promise,
+      ui8.concat(input).length
+    )
+    expect(ui8.concat(received)).to.deep.equal(
+      ui8.concat(input),
       'Did not receive the same bytes we sent'
     )
   })

package/platform/net/quiche/common/platform/impl/quiche_flags_impl.h

@@ -1,12 +0,0 @@
-// taken from chromium platfom impl
-
-// Copyright 2020 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.
-
-#ifndef NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAGS_IMPL_H_
-#define NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAGS_IMPL_H_
-
-#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h"
-
-#endif  // NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAGS_IMPL_H_

package/platform/poll.h

@@ -1,2 +0,0 @@
-// fakes poll.h
-#warning Fake poll.h is included to allow compilation on windows, upstream should solve this

package/platform/quiche/quic/core/io/quic_poll_event_loop.h

@@ -1,8 +0,0 @@
-// fake include file to fix problem in upstream
-#warning fake quic_poll_event_loop.h included
-
-#include "quiche/quic/bindings/quic_libevent.h"
-namespace quic
-{
-    typedef QuicLibeventEventLoopFactory QuicPollEventLoopFactory;
-}

package/platform/quiche_platform_impl/quic_testvalue_impl.h

@@ -1,19 +0,0 @@
-// from envoy so LICENSE.envoy applies
-#ifndef QUIC_TESTVALUE_IMPL_H
-#define QUIC_TESTVALUE_IMPL_H
-
-// NOLINT(namespace-envoy)
-
-// This file is part of the QUICHE platform implementation, and is not to be
-// consumed or referenced directly by other Envoy code. It serves purely as a
-// porting layer for QUICHE.
-
-#include "absl/strings/string_view.h"
-
-namespace quic {
-
-// NOLINTNEXTLINE(readability-identifier-naming)
-template <class T> void AdjustTestValueImpl(absl::string_view /*label*/, T* /*var*/) {}
-
-} // namespace quic
-#endif