@fails-components/webtransport 0.1.7 → 0.2.0

package/src/http3clientsession.cc

@@ -12,45 +12,54 @@
 
 #include <utility>
 
-namespace quic {
-
-Http3ClientSession::Http3ClientSession(
-    const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
-    QuicConnection* connection, const QuicServerId& server_id,
-    QuicCryptoClientConfig* crypto_config,
-    QuicClientPushPromiseIndex* push_promise_index, bool drop_response_body)
-    : Http3ClientSession(config, supported_versions, connection, server_id,
-                              crypto_config, push_promise_index,
-                              drop_response_body,
-                              /*enable_web_transport=*/false) {}
-
-Http3ClientSession::Http3ClientSession(
-    const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
-    QuicConnection* connection, const QuicServerId& server_id,
-    QuicCryptoClientConfig* crypto_config,
-    QuicClientPushPromiseIndex* push_promise_index, bool drop_response_body,
-    bool enable_web_transport)
-    : QuicSpdyClientSession(config, supported_versions, connection, server_id,
-                            crypto_config, push_promise_index),
-      drop_response_body_(drop_response_body),
-      enable_web_transport_(enable_web_transport) {}
-
-std::unique_ptr<QuicSpdyClientStream>
-Http3ClientSession::CreateClientStream() {
-  auto stream =  std::make_unique<Http3ClientStream>(
-      GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL,
-      drop_response_body_);
-  stream->set_on_interim_headers(on_interim_headers_);
-  return stream;
-}
-
-bool Http3ClientSession::ShouldNegotiateWebTransport() {
-  return enable_web_transport_;
-}
-
-HttpDatagramSupport Http3ClientSession::LocalHttpDatagramSupport() {
-  return enable_web_transport_ ? HttpDatagramSupport::kDraft04
-                               : HttpDatagramSupport::kNone;
-}
-
-}  // namespace quic
+namespace quic
+{
+
+  Http3ClientSession::Http3ClientSession(
+      const QuicConfig &config, const ParsedQuicVersionVector &supported_versions,
+      QuicConnection *connection, const QuicServerId &server_id,
+      QuicCryptoClientConfig *crypto_config,
+      QuicClientPushPromiseIndex *push_promise_index, bool drop_response_body)
+      : Http3ClientSession(config, supported_versions, connection, server_id,
+                           crypto_config, push_promise_index,
+                           drop_response_body,
+                           /*enable_web_transport=*/false)
+  {
+  }
+
+  Http3ClientSession::Http3ClientSession(
+      const QuicConfig &config, const ParsedQuicVersionVector &supported_versions,
+      QuicConnection *connection, const QuicServerId &server_id,
+      QuicCryptoClientConfig *crypto_config,
+      QuicClientPushPromiseIndex *push_promise_index, bool drop_response_body,
+      bool enable_web_transport)
+      : QuicSpdyClientSession(config, supported_versions, connection, server_id,
+                              crypto_config, push_promise_index),
+        drop_response_body_(drop_response_body),
+        enable_web_transport_(enable_web_transport) {}
+
+  std::unique_ptr<QuicSpdyClientStream>
+  Http3ClientSession::CreateClientStream()
+  {
+    auto stream = std::make_unique<Http3ClientStream>(
+        GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL,
+        drop_response_body_);
+    stream->set_on_interim_headers(on_interim_headers_);
+    return stream;
+  }
+
+  WebTransportHttp3VersionSet Http3ClientSession::LocallySupportedWebTransportVersions()
+      const
+  {
+    return enable_web_transport_
+               ? kDefaultSupportedWebTransportVersions
+               : WebTransportHttp3VersionSet();
+  }
+
+  HttpDatagramSupport Http3ClientSession::LocalHttpDatagramSupport()
+  {
+    return enable_web_transport_ ? HttpDatagramSupport::kRfcAndDraft04
+                                 : HttpDatagramSupport::kNone;
+  }
+
+} // namespace quic

package/src/http3clientsession.h

@@ -17,40 +17,44 @@
 #include "quiche/quic/core/http/quic_spdy_client_session.h"
 #include "src/http3clientstream.h"
 
-namespace quic {
-
-class Http3ClientSession : public QuicSpdyClientSession {
- public:
-  Http3ClientSession(const QuicConfig& config,
-                          const ParsedQuicVersionVector& supported_versions,
-                          QuicConnection* connection,
-                          const QuicServerId& server_id,
-                          QuicCryptoClientConfig* crypto_config,
-                          QuicClientPushPromiseIndex* push_promise_index,
-                          bool drop_response_body);
-  Http3ClientSession(const QuicConfig& config,
-                          const ParsedQuicVersionVector& supported_versions,
-                          QuicConnection* connection,
-                          const QuicServerId& server_id,
-                          QuicCryptoClientConfig* crypto_config,
-                          QuicClientPushPromiseIndex* push_promise_index,
-                          bool drop_response_body, bool enable_web_transport);
-
-  std::unique_ptr<QuicSpdyClientStream> CreateClientStream() override;
-  bool ShouldNegotiateWebTransport() override;
-  HttpDatagramSupport LocalHttpDatagramSupport() override;
-
-  void set_on_interim_headers(
-      std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers) {
-    on_interim_headers_ = std::move(on_interim_headers);
-  }
-
- private:
-  std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers_;
-  const bool drop_response_body_;
-  const bool enable_web_transport_;
-};
-
-}  // namespace quic
-
-#endif  // QUICHE_QUIC_TOOLS_QUIC_SIMPLE_CLIENT_SESSION_H_
+namespace quic
+{
+
+  class Http3ClientSession : public QuicSpdyClientSession
+  {
+  public:
+    Http3ClientSession(const QuicConfig &config,
+                       const ParsedQuicVersionVector &supported_versions,
+                       QuicConnection *connection,
+                       const QuicServerId &server_id,
+                       QuicCryptoClientConfig *crypto_config,
+                       QuicClientPushPromiseIndex *push_promise_index,
+                       bool drop_response_body);
+    Http3ClientSession(const QuicConfig &config,
+                       const ParsedQuicVersionVector &supported_versions,
+                       QuicConnection *connection,
+                       const QuicServerId &server_id,
+                       QuicCryptoClientConfig *crypto_config,
+                       QuicClientPushPromiseIndex *push_promise_index,
+                       bool drop_response_body, bool enable_web_transport);
+
+    std::unique_ptr<QuicSpdyClientStream> CreateClientStream() override;
+    WebTransportHttp3VersionSet LocallySupportedWebTransportVersions()
+        const override;
+    HttpDatagramSupport LocalHttpDatagramSupport() override;
+
+    void set_on_interim_headers(
+        std::function<void(const spdy::Http2HeaderBlock &)> on_interim_headers)
+    {
+      on_interim_headers_ = std::move(on_interim_headers);
+    }
+
+  private:
+    std::function<void(const spdy::Http2HeaderBlock &)> on_interim_headers_;
+    const bool drop_response_body_;
+    const bool enable_web_transport_;
+  };
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_TOOLS_QUIC_SIMPLE_CLIENT_SESSION_H_

package/src/http3eventloop.cc

@@ -149,13 +149,14 @@ namespace quic
       progress_->Send(&report, 1);
   }
 
-  void Http3EventLoop::informAboutStreamRead(Http3WTStream *streamobj, std::string *data, bool fin)
+  void Http3EventLoop::informAboutStreamRead(Http3WTStream *streamobj, uint32_t buffergrow, bool fin, bool success)
   {
     Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamRead;
     report.streamobj = streamobj;
-    report.para = data;
     report.fin = fin;
+    report.buffergrow = buffergrow;
+    report.success = success;
     if (progress_)
       progress_->Send(&report, 1);
   }
@@ -210,6 +211,15 @@ namespace quic
       progress_->Send(&report, 1);
   }
 
+  void Http3EventLoop::informGoawayReceived(Http3WTSession *sessionobj)
+  {
+    Http3ProgressReport report;
+    report.type = Http3ProgressReport::GoawayReceived;
+    report.sessionobj = sessionobj;
+    if (progress_)
+      progress_->Send(&report, 1);
+  }
+
   void Http3EventLoop::informUnref(LifetimeHelper *obj)
   {
     Http3ProgressReport report;
@@ -354,6 +364,13 @@ namespace quic
     Http3WTStreamJS *strjs = Napi::ObjectWrap<Http3WTStreamJS>::Unwrap(strobj);
     strjs->setObj(stream);
     if (!stream->gone()) strjs->Ref();
+   
+    if (incom || bidi) { // we have a read stream
+      // same size of a pipe in chromium, but the WT Pipe thre is 256 kbyte, the default 64 kbyte
+      Napi::ArrayBuffer arraybuf = Napi::ArrayBuffer::New(qw_->Env(),  64 * 1024);
+      strobj.Set("readbuffer", arraybuf); // so the lifecycle is bound to the JS Obj!
+      stream->setReadBuffer(arraybuf.Data(), arraybuf.ByteLength());
+    }
     stream->setJS(strjs);
 
     Napi::Object objVal = sessionobj->getJS()->Value();
@@ -409,19 +426,12 @@ namespace quic
     cbstream_.Call({retObj});
   }
 
-  void Http3EventLoop::processStreamRead(Http3WTStream *streamobj, std::string *data, bool fin)
+  void Http3EventLoop::processStreamRead(Http3WTStream *streamobj, size_t buffergrow, bool fin, bool success)
   {
     if (!checkQw())
       return;
     HandleScope scope(qw_->Env());
 
-    Napi::Object dataVal =
-        Napi::Uint8Array::New(qw_->Env(),
-                              data->length(),
-                              Napi::ArrayBuffer::New(qw_->Env(), &(*data)[0], data->length(),
-                                                     freeData, data),
-                              0);
-
     auto stream = streamobj->getJS();
     if (!stream)
       return;
@@ -430,8 +440,9 @@ namespace quic
     Napi::Object retObj = Napi::Object::New(qw_->Env());
     retObj.Set("purpose", "StreamRead");
     retObj.Set("fin", fin);
-    retObj.Set("data", dataVal);
+    retObj.Set("buffergrow", buffergrow);
     retObj.Set("object", objVal);
+    retObj.Set("success", success);
 
     cbstream_.Call({retObj});
   }
@@ -562,6 +573,24 @@ namespace quic
     cbsession_.Call({retObj});
   }
 
+  void Http3EventLoop::processGoawayReceived(Http3WTSession *sessionobj)
+  {
+    if (!checkQw())
+      return;
+    HandleScope scope(qw_->Env());
+   
+
+    auto session = sessionobj->getJS();
+    if (!session)
+      return;
+    Napi::Object objVal = session->Value();
+
+    Napi::Object retObj = Napi::Object::New(qw_->Env());
+    retObj.Set("purpose", "GoawayReceived");
+    retObj.Set("object", objVal);
+    cbsession_.Call({retObj});
+  }
+
   void Http3EventLoop::processNewSessionRequest(Http3Server *serverobj, WebTransportSession *session, spdy::Http2HeaderBlock *reqheadcopy, WebTransportRespPromisePtr *promise)
   {
     if (!checkQw())
@@ -820,8 +849,7 @@ namespace quic
       break;
       case Http3ProgressReport::StreamRead:
       {
-        processStreamRead(cur.streamobj, cur.para, cur.fin);
-        cur.para = nullptr; // take ownership of the data
+        processStreamRead(cur.streamobj, cur.buffergrow, cur.fin, cur.success);
       }
       break;
       case Http3ProgressReport::StreamWrite:
@@ -850,6 +878,11 @@ namespace quic
         processDatagramSend(cur.sessionobj, cur.bufferhandle);
       }
       break;
+      case Http3ProgressReport::GoawayReceived:
+      {
+        processGoawayReceived(cur.sessionobj);
+      }
+      break;
       case Http3ProgressReport::Unref:
       {
         cur.obj->doUnref();

package/src/http3eventloop.h

@@ -93,6 +93,7 @@ namespace quic
             StreamNetworkFinish,
             DatagramReceived,
             DatagramSend,
+            GoawayReceived,
             Unref
         } type;
         union
@@ -109,6 +110,7 @@ namespace quic
             NetworkTask nettask;
             NetworkStatus status;
             WebTransportSession *webtsession;
+            uint32_t buffergrow;
         };
         union
         {
@@ -209,7 +211,7 @@ namespace quic
 
         void informAboutStream(bool incom, bool bidir, Http3WTSession *sessionobj, Http3WTStream *stream);
         void informStreamRecvSignal(Http3WTStream *streamobj, WebTransportStreamError error_code, NetworkTask task);
-        void informAboutStreamRead(Http3WTStream *streamobj, std::string *data, bool fin);
+        void informAboutStreamRead(Http3WTStream *streamobj, uint32_t buffergrow, bool fin, bool success);
         void informAboutStreamWrite(Http3WTStream *streamobj, Napi::ObjectReference *bufferhandle, bool success);
         void informAboutStreamReset(Http3WTStream *streamobj);
         void informAboutStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task);
@@ -217,6 +219,8 @@ namespace quic
         void informDatagramReceived(Http3WTSession *sessionobj, absl::string_view datagram);
         void informDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle);
 
+        void informGoawayReceived(Http3WTSession *sessionobj);
+
         void informUnref(LifetimeHelper *obj);
 
         void Schedule(std::function<void()> action);
@@ -274,7 +278,7 @@ namespace quic
 
         void processStream(bool incom, bool bidi, Http3WTSession *sessionobj, Http3WTStream *stream);
         void processStreamRecvSignal(Http3WTStream *streamobj, WebTransportStreamError error_code, NetworkTask task);
-        void processStreamRead(Http3WTStream *streamobj, std::string *data, bool fin);
+        void processStreamRead(Http3WTStream *streamobj, size_t buffergrow, bool fin, bool success);
         void processStreamWrite(Http3WTStream *streamobj, Napi::ObjectReference *bufferhandle, bool success);
         void processStreamReset(Http3WTStream *streamobj);
         void processStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task);
@@ -282,6 +286,8 @@ namespace quic
         void processDatagramReceived(Http3WTSession *sessionobj, std::string *datagram);
         void processDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle);
 
+        void processGoawayReceived(Http3WTSession *sessionobj);
+
         bool shutDownEventLoopInt();
 
         const AsyncProgressQueueWorker<Http3ProgressReport>::ExecutionProgress *progress_;

package/src/http3server.cc

@@ -69,7 +69,7 @@ namespace quic
 
     if (!socket_api.Bind(fd_, address))
     {
-      QUIC_LOG(ERROR) << "Bind failed: " << strerror(errno) << "\n";
+      QUIC_LOG(ERROR) << "Bind failed: " << strerror(errno) << " for " << address.ToString() << "\n";
       return false;
     }
     QUIC_LOG(INFO) << "Listening on " << address.ToString() << "\n";

package/src/http3serversession.h

@@ -26,7 +26,7 @@
 #include "quiche/quic/core/http/quic_spdy_session.h"
 #include "quiche/quic/core/quic_crypto_server_stream_base.h"
 #include "quiche/quic/core/quic_packets.h"
-//#include "quic/tools/quic_backend_response.h"
+// #include "quic/tools/quic_backend_response.h"
 #include "src/http3serverbackend.h"
 #include "src/http3serverstream.h" // todo
 
@@ -36,7 +36,6 @@ namespace quic
   class Http3ServerSession : public QuicServerSessionBase
   {
   public:
-
     // Takes ownership of |connection|.
     Http3ServerSession(const QuicConfig &config,
                        const ParsedQuicVersionVector &supported_versions,
@@ -54,7 +53,6 @@ namespace quic
     // Override base class to detact client sending data on server push stream.
     void OnStreamFrame(const QuicStreamFrame &frame) override;
 
-
   protected:
     // QuicSession methods:
     QuicSpdyStream *CreateIncomingStream(QuicStreamId id) override;
@@ -72,11 +70,14 @@ namespace quic
       return http3_server_backend_;
     }
 
-
-    bool ShouldNegotiateWebTransport() override
+    WebTransportHttp3VersionSet LocallySupportedWebTransportVersions()
+        const override
     {
-      return http3_server_backend_->SupportsWebTransport();
+      return http3_server_backend_->SupportsWebTransport()
+                 ? kDefaultSupportedWebTransportVersions
+                 : WebTransportHttp3VersionSet();
     }
+
     HttpDatagramSupport LocalHttpDatagramSupport() override
     {
       if (ShouldNegotiateWebTransport())
@@ -85,7 +86,7 @@ namespace quic
       }
       return QuicServerSessionBase::LocalHttpDatagramSupport();
     }
-  
+
     Http3ServerBackend *http3_server_backend_; // Not owned.
   };
 

package/src/http3wtsessionvisitor.h

@@ -52,6 +52,11 @@ namespace quic
         {
             session_ = session;
             eventloop_ = eventloop;
+            if (session_) {
+                session_->SetOnDraining([this]() {
+                    eventloop_->informGoawayReceived(this);
+                }); 
+            }
         }
 
         class Visitor : public WebTransportVisitor
@@ -218,6 +223,13 @@ namespace quic
             eventloop_->Schedule(task);
         }
 
+        void notifySessionDrainingInt()
+        {
+            std::function<void()> task = [this]()
+            { if (session_) session_->NotifySessionDraining(); };
+            eventloop_->Schedule(task);
+        }
+
         void closeInt(int code, std::string &reason)
         {
             std::function<void()> task = [this, code, reason]()
@@ -283,6 +295,11 @@ namespace quic
             }
         }
 
+        void notifySessionDraining(const Napi::CallbackInfo &info)
+        {
+            wtsession_->notifySessionDrainingInt();
+        }
+
         void close(const Napi::CallbackInfo &info)
         {
             int code = 0;
@@ -319,6 +336,8 @@ namespace quic
                                                                                                                static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                                                            InstanceMethod<&Http3WTSessionJS::writeDatagram>("writeDatagram",
                                                                                                             static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                           InstanceMethod<&Http3WTSessionJS::notifySessionDraining>("notifySessionDraining",
+                                                                                                            static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                                                            InstanceMethod<&Http3WTSessionJS::close>("close",
                                                                                                     static_cast<napi_property_attributes>(napi_writable | napi_configurable))});
             constr->session  = Napi::Persistent(tplwt);                                                                                      

package/src/http3wtstreamvisitor.cc

@@ -23,6 +23,9 @@ namespace quic
 
             stream_->chunks_.pop_front();
         }
+
+        stream_->eventloop_->informAboutStreamRead(stream_, 0, false, false);
+
         if (!stream_->stop_sending_received_)
         {
             stream_->eventloop_->informStreamRecvSignal(stream_, 0, NetworkTask::stopSending);
@@ -77,21 +80,45 @@ namespace quic
 
     void Http3WTStream::doCanRead()
     {
+        // if (pause_reading_) return ; // back pressure folks!
+        
         if (pause_reading_)
         {
             can_read_pending_ = true;
             return; // back pressure folks!
         }
         // first figure out if we have readable data
+        if (bufferlen_ >= readbufsize_ || !readbufdata_) {
+            can_read_pending_ = true;
+            return; // no space here
+        }
         size_t readable = stream_->ReadableBytes();
-        // ok create a string obj to hold the data
-        std::string *data = new std::string();
-        data->resize(readable);
-        WebTransportStream::ReadResult result = stream_->Read(absl::Span<char>(&(*data)[0], readable));
-        data->resize(result.bytes_read);
-        QUIC_DVLOG(1) << "Attempted reading on WebTransport bidirectional stream "
-                      << ", bytes read: " << result.bytes_read;
-        eventloop_->informAboutStreamRead(this, data, result.fin);
+        bool read = false;
+        while (readable > 0 && bufferlen_ < readbufsize_)
+        {
+            if (writepos_ >= readpos_) {
+                size_t len = readbufsize_ - writepos_;   
+                WebTransportStream::ReadResult result = 
+                    stream_->Read(absl::Span<char>(((char*) readbufdata_) + writepos_, len));
+                QUIC_DVLOG(1) << "Attempted reading on WebTransport stream "
+                          << ", bytes read: " << result.bytes_read;
+                writepos_ = (writepos_ + result.bytes_read) % readbufsize_;
+                bufferlen_ = bufferlen_ + result.bytes_read;
+                eventloop_->informAboutStreamRead(this, result.bytes_read, 
+                            result.fin, true);
+            } else  { // readpos_ > writepos_
+                size_t len = writepos_ - readpos_;
+                WebTransportStream::ReadResult result = 
+                    stream_->Read(absl::Span<char>(((char*) readbufdata_) + writepos_, len));
+                QUIC_DVLOG(1) << "Attempted reading on WebTransport stream "
+                          << ", bytes read: " << result.bytes_read; 
+                writepos_ = (writepos_ + result.bytes_read) % readbufsize_;
+                bufferlen_ = bufferlen_ + result.bytes_read;
+                eventloop_->informAboutStreamRead(this, result.bytes_read,
+                             result.fin, true);
+            } 
+            readable = stream_->ReadableBytes();
+        }
     }
 
     void Http3WTStream::doCanWrite()

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",