@fails-components/webtransport 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "main": "src/webtransport.js",
   "module": "src/webtransport.js",

package/readme.md

@@ -36,14 +36,12 @@ In this case you need to be authenticated against github.
 
 If you are running the install as root, you need to use `--unsafe-perm` as flag.
 Installing the package requires a full building environment including clang-9, perl6, golang,  ninja-build and protobuf-compiler and protobuf headers. See the `Dockerfile` or `Dockerfile.development` for required debian packages. 
-This should work for linux and Mac OS X. Windows is not supported, since cmake.js only works with msvc and some libraries require clang, I recommend a Docker container instead. Of course,  PR for patches and for compiling instructions and necessary changes are welcome for all possible environments. 
+This should work for linux and Mac OS X. Windows is currently not supported, since cmake.js only works with msvc and some libraries require clang, I recommend a Docker container instead. Of course,  PR for patches and for compiling instructions and necessary changes are welcome for all possible environments. 
 
 Warning the build time takes more than 10 minutes!
 
 In the directory `test` you find a simple echo server code. That answers to a series of WebTransport echos. Furthermore some example browser code and finally a unit test of the library including certificate generation. 
 
-In the directory `certs` some scripts for generating test certificates, originally taken from chromium, libquiche project are provided. However the certicate generation code in the unit test is recommended.
-
 When testing remember you might need to start chromium based browser with certain flags to accept your http/3 certificate with errors, e.g.:
 ```
 chrome --ignore-certificate-errors-spki-list=FINGERPRINTOFYOURCERTIFICATE --ignore-certificate-errors --v=2 --enable-logging=stderr --origin-to-force-quic-on=192.168.1.50:8080

package/src/http3eventloop.cc

@@ -89,8 +89,9 @@ namespace quic
     tplwtsv->SetClassName(Nan::New("Http3WTStream").ToLocalChecked());
     tplwtsv->InstanceTemplate()->SetInternalFieldCount(1);
     Nan::SetPrototypeMethod(tplwtsv, "writeChunk", Http3WTStream::writeChunk);
-    Nan::SetPrototypeMethod(tplwtsv, "closeStream", Http3WTStream::closeStream);
     Nan::SetPrototypeMethod(tplwtsv, "resetStream", Http3WTStream::resetStream);
+    Nan::SetPrototypeMethod(tplwtsv, "stopSending", Http3WTStream::stopSending);
+    Nan::SetPrototypeMethod(tplwtsv, "streamFinal", Http3WTStream::streamFinal);
     Nan::SetPrototypeMethod(tplwtsv, "startReading", Http3WTStream::startReading);
     Nan::SetPrototypeMethod(tplwtsv, "stopReading", Http3WTStream::stopReading);
 
@@ -177,12 +178,13 @@ namespace quic
       progress_->Send(&report, 1);
   }
 
-  void Http3EventLoop::informStreamClosed(Http3WTStream *streamobj, WebTransportStreamError code)
+  void Http3EventLoop::informStreamRecvSignal(Http3WTStream *streamobj, WebTransportStreamError error_code, NetworkTask task)
   {
     struct Http3ProgressReport report;
-    report.type = Http3ProgressReport::StreamClosed;
+    report.type = Http3ProgressReport::StreamRecvSignal;
     report.streamobj = streamobj;
-    report.wtscode = code;
+    report.wtscode = error_code;
+    report.nettask = task;
     if (progress_)
       progress_->Send(&report, 1);
   }
@@ -209,6 +211,17 @@ namespace quic
       progress_->Send(&report, 1);
   }
 
+  void Http3EventLoop::informAboutStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task)
+  {
+    struct Http3ProgressReport report;
+    report.type = Http3ProgressReport::StreamNetworkFinish;
+    report.streamobj = streamobj;
+    report.nettask = task;
+    if (progress_)
+      progress_->Send(&report, 1);
+
+  }
+
   void Http3EventLoop::informAboutStreamReset(Http3WTStream *streamobj)
   {
     struct Http3ProgressReport report;
@@ -399,22 +412,41 @@ namespace quic
     Nan::Call(*cbsession_, 1, argv);
   }
 
-  void Http3EventLoop::processStreamClosed(Http3WTStream *streamobj, WebTransportStreamError code)
+  void Http3EventLoop::processStreamRecvSignal(Http3WTStream *streamobj, WebTransportStreamError error_code, NetworkTask task)
   {
     HandleScope scope;
     v8::Local<v8::String> purposeProp = Nan::New("purpose").ToLocalChecked();
-    v8::Local<v8::String> purposeVal = Nan::New("StreamClosed").ToLocalChecked();
+    v8::Local<v8::String> purposeVal = Nan::New("StreamRecvSignal").ToLocalChecked();
     v8::Local<v8::String> codeProp = Nan::New("code").ToLocalChecked();
-    v8::Local<v8::Int32> codeVal = Nan::New(code);
+    v8::Local<v8::Int32> codeVal = Nan::New(error_code);
 
     v8::Local<v8::String> objProp = Nan::New("object").ToLocalChecked();
     v8::Local<v8::Object> objVal = streamobj->handle();
 
+    std::string nettaskstr;
+    switch (task)
+    {
+      case NetworkTask::resetStream: {
+        nettaskstr = "resetStream";
+      } break;
+      case NetworkTask::stopSending: {
+        nettaskstr = "stopSending";
+      } break;
+      case NetworkTask::streamFinal: {
+        nettaskstr = "streamFinal";
+      } break;
+      default: return;
+    };
+
+    v8::Local<v8::String> nettaskProp = Nan::New("nettask").ToLocalChecked();
+    v8::Local<v8::String> nettaskVal = Nan::New(nettaskstr).ToLocalChecked();
+
     auto context = GetCurrentContext();
     v8::Local<v8::Object> retObj = Nan::New<v8::Object>();
     retObj->Set(context, purposeProp, purposeVal).FromJust();
     retObj->Set(context, codeProp, codeVal).FromJust();
     retObj->Set(context, objProp, objVal).FromJust();
+    retObj->Set(context, nettaskProp, nettaskVal).FromJust();
 
     v8::Local<v8::Value> argv[] = {retObj};
     Nan::Call(*cbstream_, 1, argv);
@@ -489,6 +521,44 @@ namespace quic
     Nan::Call(*cbstream_, 1, argv);
   }
 
+  void Http3EventLoop::processStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task)
+  {
+    HandleScope scope;
+    v8::Local<v8::String> purposeProp = Nan::New("purpose").ToLocalChecked();
+    v8::Local<v8::String> purposeVal = Nan::New("StreamNetworkFinish").ToLocalChecked();
+
+    v8::Local<v8::String> objProp = Nan::New("object").ToLocalChecked();
+    v8::Local<v8::Object> objVal = streamobj->handle();
+
+    std::string nettaskstr;
+    switch (task)
+    {
+      case NetworkTask::resetStream: {
+        nettaskstr = "resetStream";
+      } break;
+      case NetworkTask::stopSending: {
+        nettaskstr = "stopSending";
+      } break;
+      case NetworkTask::streamFinal: {
+        nettaskstr = "streamFinal";
+      } break;
+      default: return;
+    };
+
+    v8::Local<v8::String> nettaskProp = Nan::New("nettask").ToLocalChecked();
+    v8::Local<v8::String> nettaskVal = Nan::New(nettaskstr).ToLocalChecked();
+
+
+    auto context = GetCurrentContext();
+    v8::Local<v8::Object> retObj = Nan::New<v8::Object>();
+    retObj->Set(context, purposeProp, purposeVal).FromJust();
+    retObj->Set(context, objProp, objVal).FromJust();
+    retObj->Set(context, nettaskProp, nettaskVal).FromJust();
+
+    v8::Local<v8::Value> argv[] = {retObj};
+    Nan::Call(*cbstream_, 1, argv);
+  }
+
   void Http3EventLoop::processDatagramBufferFree(Nan::Persistent<v8::Object> *bufferhandle)
   {
     bufferhandle->Reset(); // release the outgoing buffer
@@ -688,9 +758,9 @@ namespace quic
         processStream(false, false, cur.sessionobj, cur.stream);
       }
       break;
-      case Http3ProgressReport::StreamClosed:
+      case Http3ProgressReport::StreamRecvSignal:
       {
-        processStreamClosed(cur.streamobj, cur.wtscode);
+        processStreamRecvSignal(cur.streamobj, cur.wtscode, cur.nettask);
       }
       break;
       case Http3ProgressReport::StreamRead:
@@ -709,6 +779,10 @@ namespace quic
         processStreamReset(cur.streamobj);
       }
       break;
+      case Http3ProgressReport::StreamNetworkFinish:
+      {
+        processStreamNetworkFinish(cur.streamobj, cur.nettask);
+      } break;
       case Http3ProgressReport::DatagramReceived:
       {
         processDatagramReceived(cur.sessionobj, cur.para);

package/src/http3eventloop.h

@@ -37,6 +37,12 @@ namespace quic
         virtual void doUnref() = 0;
     };
 
+    enum NetworkTask {
+        resetStream,
+        stopSending,
+        streamFinal
+    };
+
 
     struct Http3ProgressReport
     {
@@ -53,10 +59,11 @@ namespace quic
             IncomUniDiStream,
             OutgoBiDiStream,
             OutgoUniDiStream,
-            StreamClosed,
+            StreamRecvSignal,
             StreamRead,
             StreamWrite,
             StreamReset,
+            StreamNetworkFinish,
             DatagramReceived,
             DatagramSend,
             DatagramBufferFree,
@@ -72,6 +79,7 @@ namespace quic
         union
         {
             WebTransportSessionError wtecode;
+            NetworkTask nettask;
         };
         union
         {
@@ -127,10 +135,11 @@ namespace quic
         void informSessionReady(Http3WTSession *sessionobj);
 
         void informAboutStream(bool incom, bool bidir, Http3WTSession *sessionobj, Http3WTStream *stream);
-        void informStreamClosed(Http3WTStream *streamobj, WebTransportStreamError error_code);
+        void informStreamRecvSignal(Http3WTStream *streamobj, WebTransportStreamError error_code, NetworkTask task);
         void informAboutStreamRead(Http3WTStream *streamobj, std::string *data, bool fin);
         void informAboutStreamWrite(Http3WTStream *streamobj, Nan::Persistent<v8::Object> *bufferhandle, bool success);
         void informAboutStreamReset(Http3WTStream *streamobj);
+        void informAboutStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task);
 
         void informDatagramReceived(Http3WTSession *sessionobj, absl::string_view datagram);
         void informDatagramBufferFree(Nan::Persistent<v8::Object> *bufferhandle);
@@ -177,10 +186,11 @@ namespace quic
         void processSessionReady(Http3WTSession *sessionobj);
 
         void processStream(bool incom, bool bidi, Http3WTSession *sessionobj, Http3WTStream *stream);
-        void processStreamClosed(Http3WTStream *streamobj, WebTransportStreamError error_code);
+        void processStreamRecvSignal(Http3WTStream *streamobj, WebTransportStreamError error_code, NetworkTask task);
         void processStreamRead(Http3WTStream *streamobj, std::string *data, bool fin);
         void processStreamWrite(Http3WTStream *streamobj, Nan::Persistent<v8::Object> *bufferhandle, bool success);
         void processStreamReset(Http3WTStream *streamobj);
+        void processStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task);
 
         void processDatagramReceived(Http3WTSession *sessionobj, std::string *datagram);
         void processDatagramSend(Http3WTSession *sessionobj);

package/src/http3server.cc

@@ -26,11 +26,12 @@ namespace quic
 
   const size_t kNumSessionsToCreatePerSocketEvent = 16;
 
-  Http3Server::Http3Server(Http3EventLoop * eventloop, std::string host, int port, std::unique_ptr<ProofSource> proof_source,
-                           const char *secret)
+  Http3Server::Http3Server(Http3EventLoop *eventloop, std::string host, int port, std::unique_ptr<ProofSource> proof_source,
+                           const char *secret, QuicConfig config)
       : port_(port), host_(host), fd_(-1), overflow_supported_(false),
-       eventloop_(eventloop),
-       http3_server_backend_(eventloop),
+        config_(config),
+        eventloop_(eventloop),
+        http3_server_backend_(eventloop),
         packet_reader_(new QuicPacketReader()),
         packets_dropped_(0),
         version_manager_({ParsedQuicVersion::RFCv1()}),
@@ -47,8 +48,6 @@ namespace quic
     // printf("server destruct %x\n", this);
   }
 
-
-
   bool Http3Server::CreateUDPSocketAndListen(const QuicSocketAddress &address)
   {
     QuicUdpSocketApi socket_api;
@@ -97,7 +96,7 @@ namespace quic
 
   bool Http3Server::stopServerInt()
   {
-    
+
     eventloop_->getEpollServer()->UnregisterFD(fd_);
 
     // if (!silent_close_) {
@@ -106,7 +105,6 @@ namespace quic
     dispatcher_->Shutdown();
     //}
 
-
     close(fd_);
     fd_ = -1;
     eventloop_->informUnref(this); // must be done on the other thread...
@@ -127,8 +125,6 @@ namespace quic
         &http3_server_backend_, expected_server_connection_id_length_);
   }
 
-
-
   NAN_METHOD(Http3Server::New)
   {
     if (info.IsConstructCall())
@@ -140,10 +136,10 @@ namespace quic
       std::string privkey;
       std::string host("localhost");
 
-
-
       v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
+
       
+      QuicConfig sconfig;
       if (!info[0]->IsUndefined())
       {
         v8::MaybeLocal<v8::Object> obj = info[0]->ToObject(context);
@@ -152,6 +148,7 @@ namespace quic
         v8::Local<v8::String> certProp = Nan::New("cert").ToLocalChecked();
         v8::Local<v8::String> hostProp = Nan::New("host").ToLocalChecked();
         v8::Local<v8::String> keyProp = Nan::New("privKey").ToLocalChecked();
+        v8::Local<v8::String> maxconnProp = Nan::New("maxConnections").ToLocalChecked();
         if (!obj.IsEmpty())
         {
           v8::Local<v8::Object> lobj = obj.ToLocalChecked();
@@ -192,6 +189,14 @@ namespace quic
           {
             return Nan::ThrowError("No privKey set for Http3Server");
           }
+           if (Nan::HasOwnProperty(lobj, maxconnProp).FromJust() && !Nan::Get(lobj, keyProp).IsEmpty())
+          {
+            v8::Local<v8::Value> maxconnValue = Nan::Get(lobj, keyProp).ToLocalChecked();
+            int maxconn = Nan::To<int>(maxconnValue).FromJust();
+            sconfig.SetMaxBidirectionalStreamsToSend(maxconn);
+            sconfig.SetMaxUnidirectionalStreamsToSend(maxconn); 
+          }
+          
         }
         // Callback *callback, int port, std::unique_ptr<ProofSource> proof_source,  const char *secret
 
@@ -207,20 +212,19 @@ namespace quic
         std::unique_ptr<ProofSourceX509> proofsource = ProofSourceX509::Create(chain, std::move(*certprivkey));
         if (proofsource == nullptr)
           return Nan::ThrowError("LoadPemFromStream cert failed for Http3Server");
-        Http3EventLoop * eventloop = nullptr;
+        Http3EventLoop *eventloop = nullptr;
         if (!info[1]->IsUndefined())
         {
           v8::MaybeLocal<v8::Object> obj = info[1]->ToObject(context);
           v8::Local<v8::Object> lobj = obj.ToLocalChecked();
           eventloop = Nan::ObjectWrap::Unwrap<Http3EventLoop>(lobj);
-        } 
-        else 
+        }
+        else
         {
           return Nan::ThrowError("No eventloop arguments passed to Http3Server");
         }
 
-        
-        Http3Server *object = new Http3Server(eventloop, host, port, std::move(proofsource), secret.c_str());
+        Http3Server *object = new Http3Server(eventloop, host, port, std::move(proofsource), secret.c_str(), sconfig);
         object->Wrap(info.This());
         info.GetReturnValue().Set(info.This());
       }
@@ -228,12 +232,11 @@ namespace quic
       {
         return Nan::ThrowError("No arguments passed to Http3Server");
       }
-     
     }
     else
     {
       const int argc = 2;
-      v8::Local<v8::Value> argv[argc] = {info[0],info[1]};
+      v8::Local<v8::Value> argv[argc] = {info[0], info[1]};
       v8::Local<v8::Function> cons = Nan::New(constructor());
       auto instance = Nan::NewInstance(cons, argc, argv);
       if (!instance.IsEmpty())
@@ -335,7 +338,6 @@ namespace quic
       printf("startServerInt failed for Http3Server\n");
     } };
     obj->eventloop_->Schedule(task);
-    
   }
 
   NAN_METHOD(Http3Server::stopServer)
@@ -348,7 +350,6 @@ namespace quic
       printf("stopServerInt failed for Http3Server\n");
     } };
     obj->eventloop_->Schedule(task);
-    
   }
 
   NAN_METHOD(Http3Server::addPath)
@@ -363,7 +364,6 @@ namespace quic
       std::string lpath(*v8::String::Utf8Value(isolate, info[0]->ToString(context).ToLocalChecked()));
       std::function<void()> task = [obj, lpath]()
       {
-
         obj->http3_server_backend_.addPath(lpath);
       };
       obj->eventloop_->Schedule(task);

package/src/http3server.h

@@ -29,30 +29,25 @@ namespace quic
 {
 
     class Http3EventLoop;
-    
 
     class Http3Server : public QuicEpollCallbackInterface, public Nan::ObjectWrap, public LifetimeHelper
     {
     public:
-        Http3Server(Http3EventLoop * eventloop, std::string host, int port, 
-            std::unique_ptr<ProofSource> proof_source,
-                           const char *secret);
+        Http3Server(Http3EventLoop *eventloop, std::string host, int port,
+                    std::unique_ptr<ProofSource> proof_source,
+                    const char *secret,
+                    QuicConfig config);
 
         Http3Server(const Http3Server &) = delete;
         Http3Server &operator=(const Http3Server &) = delete;
 
         ~Http3Server();
 
-
         bool CreateUDPSocketAndListen(const QuicSocketAddress &address);
 
-       
-
-
         // From EpollCallbackInterface
         std::string Name() const override { return "Http3Server"; }
 
-        
         void OnRegistration(QuicEpollServer * /*eps*/,
                             int /*fd*/,
                             int /*event_mask*/) override {}
@@ -70,26 +65,21 @@ namespace quic
 
         static NAN_METHOD(addPath);
 
-        
         static inline Nan::Persistent<v8::Function> &constructor()
         {
             static Nan::Persistent<v8::Function> my_constructor;
             return my_constructor;
         }
 
-        void doUnref() override {
+        void doUnref() override
+        {
             Unref();
         }
-       
-
 
     private:
-
         bool startServerInt();
         bool stopServerInt();
 
-
-
         QuicUdpSocketFd fd_;
         bool overflow_supported_;
         int port_;
@@ -115,10 +105,7 @@ namespace quic
 
         QuicDispatcher *CreateQuicDispatcher();
 
-        Http3EventLoop * eventloop_;
-
-        
-
+        Http3EventLoop *eventloop_;
     };
 
 }

package/src/http3wtstreamvisitor.cc

@@ -24,15 +24,33 @@ namespace quic
         strobj->eventloop_->informUnref(strobj);
     }
 
-     void Http3WTStream::Visitor::OnWriteSideInDataRecvdState() 
-     {
-         if (stream_->send_fin_)  stream_->eventloop_->informStreamClosed(stream_, lasterror); // may be move below
-     }
+    void Http3WTStream::Visitor::OnWriteSideInDataRecvdState() // called if everything is written to the client and it is closed
+    {
+        if (stream_->send_fin_)
+            stream_->eventloop_->informAboutStreamNetworkFinish(stream_, NetworkTask::streamFinal);
+    }
+
+    void Http3WTStream::Visitor::OnResetStreamReceived(WebTransportStreamError error)
+    {
+        // should this be removed
+        /*
+
+        // Send FIN in response to a stream reset.  We want to test that we can
+        // operate one side of the stream cleanly while the other is reset, thus
+        // replying with a FIN rather than a RESET_STREAM is more appropriate here.
+        stream_->send_fin_ = true;
+        OnCanWrite();*/
+        lasterror = error;
+        stream_->eventloop_->informStreamRecvSignal(stream_, error, NetworkTask::resetStream); // may be move below
+    }
 
     void Http3WTStream::Visitor::OnStopSendingReceived(WebTransportStreamError error)
     {
         stream_->stop_sending_received_ = true;
-        stream_->eventloop_->informStreamClosed(stream_, error); // may be move below
+        stream_->eventloop_->informStreamRecvSignal(stream_, error, NetworkTask::stopSending); // may be move below
+        // we should also finallize the stream, so send a fin
+        stream_->send_fin_ = true;
+        OnCanWrite();
     }
 
     void Http3WTStream::cancelWrite(Nan::Persistent<v8::Object> *handle)
@@ -42,7 +60,8 @@ namespace quic
 
     void Http3WTStream::doCanRead()
     {
-        if (pause_reading_) return ; // back pressure folks!
+        if (pause_reading_)
+            return; // back pressure folks!
         // first figure out if we have readable data
         size_t readable = stream_->ReadableBytes();
         if (readable > 0)
@@ -60,10 +79,11 @@ namespace quic
 
     void Http3WTStream::doCanWrite()
     {
-        if (stop_sending_received_ || pause_reading_)
-        {
-            return;
-        }
+        /* if (/* stop_sending_received_ || * pause_reading_)
+         {
+             return;
+         } */
+        if (fin_was_sent_) return;
 
         while (chunks_.size() > 0)
         {
@@ -85,6 +105,7 @@ namespace quic
         {
             bool success = stream_->SendFin();
             QUICHE_DCHECK(success);
+            fin_was_sent_ = true;
         }
     }
 

package/src/http3wtstreamvisitor.h

@@ -51,15 +51,8 @@ namespace quic
                 stream_->doCanWrite();
             }
 
-            void OnResetStreamReceived(WebTransportStreamError error) override
-            {
-                // Send FIN in response to a stream reset.  We want to test that we can
-                // operate one side of the stream cleanly while the other is reset, thus
-                // replying with a FIN rather than a RESET_STREAM is more appropriate here.
-                lasterror = error;
-                stream_->send_fin_ = true;
-                OnCanWrite();
-            }
+            void OnResetStreamReceived(WebTransportStreamError error) override;
+            
             void OnStopSendingReceived(WebTransportStreamError /*error*/) override;
             
             void OnWriteSideInDataRecvdState() override;
@@ -151,7 +144,7 @@ namespace quic
             }
         }
 
-        static NAN_METHOD(closeStream)
+        static NAN_METHOD(streamFinal)
         {
             Http3WTStream *obj = Nan::ObjectWrap::Unwrap<Http3WTStream>(info.Holder());
             std::function<void()> task = [obj]()
@@ -161,6 +154,30 @@ namespace quic
             obj->eventloop_->Schedule(task);
         }
 
+        static NAN_METHOD(stopSending)
+        {
+            Http3WTStream *obj = Nan::ObjectWrap::Unwrap<Http3WTStream>(info.Holder());
+            int code = 0;
+            v8::Isolate *isolate = info.GetIsolate();
+            unsigned int reason = 0;
+
+            if (!info[0]->IsUndefined())
+            {
+                v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
+                v8::Local<v8::Int32> reasonl = info[0]->ToInt32(context).ToLocalChecked();
+                reason = Nan::To<unsigned int>(reasonl).FromJust();
+                
+            }
+
+            std::function<void()> task = [obj,reason]()
+            { if (obj->stream_) {
+                obj->stream_->SendStopSending(reason);
+                obj->eventloop_->informAboutStreamNetworkFinish(obj, NetworkTask::stopSending);
+                }
+             };
+            obj->eventloop_->Schedule(task);
+        }
+
         static NAN_METHOD(resetStream)
         {
             Http3WTStream *obj = Nan::ObjectWrap::Unwrap<Http3WTStream>(info.Holder());
@@ -177,7 +194,11 @@ namespace quic
             }
 
             std::function<void()> task = [obj,reason]()
-            { if (obj->stream_) obj->stream_->ResetWithUserCode(reason); };
+            { if (obj->stream_) {
+                obj->stream_->ResetWithUserCode(reason); 
+                obj->eventloop_->informAboutStreamNetworkFinish(obj, NetworkTask::resetStream);
+            }
+            };
             obj->eventloop_->Schedule(task);
         }
 
@@ -230,6 +251,11 @@ namespace quic
 
         void writeChunkInt(char *buffer, size_t len, Nan::Persistent<v8::Object> *bufferhandle)
         {
+            if (fin_was_sent_ || send_fin_)
+            {
+                cancelWrite(bufferhandle);
+                return;
+            }
             if (!stream_)
             {
                 cancelWrite(bufferhandle);
@@ -249,6 +275,7 @@ namespace quic
         WebTransportStream *stream_;
         Http3EventLoop *eventloop_;
         bool send_fin_ = false;
+        bool fin_was_sent_ = false;
         bool stop_sending_received_ = false;
         bool pause_reading_ = false;
         std::deque<WChunks> chunks_;