@fails-components/webtransport 0.1.5 → 0.2.0

package/src/http3clientsession.cc

@@ -12,43 +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() {
-  return std::make_unique<Http3ClientStream>(
-      GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL,
-      drop_response_body_);
-}
-
-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

@@ -11,37 +11,50 @@
 #ifndef HTTP3_CLIENT_SESSION_H
 #define HTTP3_CLIENT_SESSION_H
 
+#include <functional>
+#include <utility>
+
 #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;
-
- private:
-  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/http3clientstream.cc

@@ -9,6 +9,7 @@
 // found in the LICENSE file.
 
 #include "src/http3clientstream.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 
 namespace quic {
 
@@ -32,4 +33,20 @@ void Http3ClientStream::OnBodyAvailable() {
   }
 }
 
+bool Http3ClientStream::ParseAndValidateStatusCode() {
+  const size_t num_previous_interim_headers = preliminary_headers().size();
+  if (!QuicSpdyClientStream::ParseAndValidateStatusCode()) {
+    return false;
+  }
+  // The base ParseAndValidateStatusCode() may have added a preliminary header.
+  if (preliminary_headers().size() > num_previous_interim_headers) {
+    QUICHE_DCHECK_EQ(preliminary_headers().size(),
+                     num_previous_interim_headers + 1);
+    if (on_interim_headers_) {
+      on_interim_headers_(preliminary_headers().back());
+    }
+  }
+  return true;
+}
+
 }  // namespace quic

package/src/http3clientstream.h

@@ -23,7 +23,17 @@ class Http3ClientStream : public QuicSpdyClientStream {
         drop_response_body_(drop_response_body) {}
   void OnBodyAvailable() override;
 
+  void set_on_interim_headers(
+      std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers) {
+    on_interim_headers_ = std::move(on_interim_headers);
+  }
+
+ protected:
+  bool ParseAndValidateStatusCode() override;
+
+
  private:
+  std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers_;
   const bool drop_response_body_;
 };
 

package/src/http3eventloop.cc

@@ -17,19 +17,16 @@
 #include "quiche/common/platform/api/quiche_reference_counted.h"
 #include "quiche/quic/core/quic_default_clock.h"
 #include "quiche/quic/bindings/quic_libevent.h"
+#include "quiche/common/platform/api/quiche_command_line_flags.h"
+
+#include "absl/log/initialize.h"
+#include "absl/strings/string_view.h"
 
 using namespace Napi;
 
 namespace quic
 {
 
-#ifdef WIN32
-
-  bool initSockets();
-  bool destroySockets();
-
-#endif
-
   // hack since the header is faulty
   QUICHE_NO_EXPORT QuicEventLoopFactory *GetDefaultEventLoop();
 
@@ -40,9 +37,6 @@ namespace quic
   Http3EventLoop::~Http3EventLoop()
   {
     printf("Destructor eventloop\n");
-#ifdef WIN32
-    destroySockets();
-#endif
   }
 
   void Http3EventLoop::Init(Napi::Env env, Napi::Object exports)
@@ -61,7 +55,6 @@ namespace quic
     Http3ClientJS::InitExports(env, exports);
     Http3WTSessionJS::InitExports(env, exports, constr);
     Http3WTStreamJS::InitExports(env, exports, constr);
-    Napi::ObjectReference *exportref = new Napi::ObjectReference();
 
     env.SetInstanceData<Http3Constructors>(constr);
   }
@@ -116,7 +109,7 @@ namespace quic
 
   void Http3EventLoop::informAboutStream(bool incom, bool bidir, Http3WTSession *sessionobj, Http3WTStream *stream)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     if (incom)
     {
       if (bidir)
@@ -147,7 +140,7 @@ namespace quic
 
   void Http3EventLoop::informStreamRecvSignal(Http3WTStream *streamobj, WebTransportStreamError error_code, NetworkTask task)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamRecvSignal;
     report.streamobj = streamobj;
     report.wtscode = error_code;
@@ -156,20 +149,21 @@ 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)
   {
-    struct Http3ProgressReport report;
+    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);
   }
 
   void Http3EventLoop::informAboutStreamWrite(Http3WTStream *streamobj, Napi::ObjectReference *bufferhandle, bool success)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamWrite;
     report.streamobj = streamobj;
     report.bufferhandle = bufferhandle;
@@ -180,7 +174,7 @@ namespace quic
 
   void Http3EventLoop::informAboutStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamNetworkFinish;
     report.streamobj = streamobj;
     report.nettask = task;
@@ -190,7 +184,7 @@ namespace quic
 
   void Http3EventLoop::informAboutStreamReset(Http3WTStream *streamobj)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamReset;
     report.streamobj = streamobj;
     if (progress_)
@@ -199,7 +193,7 @@ namespace quic
 
   void Http3EventLoop::informDatagramReceived(Http3WTSession *sessionobj, absl::string_view datagram)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::DatagramReceived;
     report.sessionobj = sessionobj;
     report.para = new std::string(datagram);
@@ -207,28 +201,28 @@ namespace quic
       progress_->Send(&report, 1);
   }
 
-  void Http3EventLoop::informDatagramSend(Http3WTSession *sessionobj)
+  void Http3EventLoop::informDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::DatagramSend;
     report.sessionobj = sessionobj;
+    report.bufferhandle = bufferhandle;
     if (progress_)
       progress_->Send(&report, 1);
   }
 
-  void Http3EventLoop::informDatagramBufferFree(Napi::ObjectReference *bufferhandle)
+  void Http3EventLoop::informGoawayReceived(Http3WTSession *sessionobj)
   {
-    struct Http3ProgressReport report;
-    report.type = Http3ProgressReport::DatagramBufferFree;
-    report.bufferhandle = bufferhandle;
-
+    Http3ProgressReport report;
+    report.type = Http3ProgressReport::GoawayReceived;
+    report.sessionobj = sessionobj;
     if (progress_)
       progress_->Send(&report, 1);
   }
 
   void Http3EventLoop::informUnref(LifetimeHelper *obj)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::Unref;
     report.obj = obj;
 
@@ -238,7 +232,7 @@ namespace quic
 
   void Http3EventLoop::informAboutClientConnected(Http3Client *client, bool success)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::ClientConnected;
     report.clientobj = client;
     report.success = success;
@@ -248,7 +242,7 @@ namespace quic
 
   void Http3EventLoop::informClientWebtransportSupport(Http3Client *client)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::ClientWebTransportSupport;
     report.clientobj = client;
     if (progress_)
@@ -257,7 +251,7 @@ namespace quic
 
   void Http3EventLoop::informAboutNewSessionRequest(Http3Server *server, WebTransportSession *session, spdy::Http2HeaderBlock *reqheadcopy, WebTransportRespPromisePtr promise)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::NewSessionRequest;
     report.webtsession = session;
     report.serverobj = server;
@@ -269,7 +263,7 @@ namespace quic
 
   void Http3EventLoop::informAboutNewSession(Http3Server *server, Http3WTSession *session, absl::string_view path, Napi::Reference<Napi::Value> *header)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::NewSession;
     report.serverobj = server;
     report.session = session;
@@ -281,7 +275,7 @@ namespace quic
 
   void Http3EventLoop::informNewClientSession(Http3Client *client, Http3WTSession *session)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::NewClientSession;
     report.clientobj = client;
     report.session = session;
@@ -292,7 +286,7 @@ namespace quic
   void Http3EventLoop::informSessionClosed(Http3WTSession *sessionobj, WebTransportSessionError error_code,
                                            absl::string_view error_message)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::SessionClosed;
     report.sessionobj = sessionobj;
     report.para = new std::string(error_message);
@@ -303,7 +297,7 @@ namespace quic
 
   void Http3EventLoop::informSessionReady(Http3WTSession *sessionobj)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::SessionReady;
     report.sessionobj = sessionobj;
     if (progress_)
@@ -312,7 +306,7 @@ namespace quic
 
   void Http3EventLoop::informServerStatus(Http3Server *serverobj, NetworkStatus status, ServerStatusDetails *details)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::ServerStatus;
     report.serverobj = serverobj;
     report.status = status;
@@ -370,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();
@@ -425,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;
@@ -446,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});
   }
@@ -534,12 +529,6 @@ namespace quic
     cbstream_.Call({retObj});
   }
 
-  void Http3EventLoop::processDatagramBufferFree(Napi::ObjectReference *bufferhandle)
-  {
-    bufferhandle->Unref(); // release the outgoing buffer
-    delete bufferhandle;   // free the handle object
-  }
-
   void Http3EventLoop::processDatagramReceived(Http3WTSession *sessionobj, std::string *datagram)
   {
     if (!checkQw())
@@ -565,8 +554,10 @@ namespace quic
     cbsession_.Call({retObj});
   }
 
-  void Http3EventLoop::processDatagramSend(Http3WTSession *sessionobj)
+  void Http3EventLoop::processDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle)
   {
+     bufferhandle->Unref(); // release the outgoing buffer
+    delete bufferhandle;   // free the handle object
     if (!checkQw())
       return;
     HandleScope scope(qw_->Env());
@@ -582,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())
@@ -840,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:
@@ -867,12 +875,12 @@ namespace quic
       break;
       case Http3ProgressReport::DatagramSend:
       {
-        processDatagramSend(cur.sessionobj);
+        processDatagramSend(cur.sessionobj, cur.bufferhandle);
       }
       break;
-      case Http3ProgressReport::DatagramBufferFree:
+      case Http3ProgressReport::GoawayReceived:
       {
-        processDatagramBufferFree(cur.bufferhandle);
+        processGoawayReceived(cur.sessionobj);
       }
       break;
       case Http3ProgressReport::Unref:
@@ -891,10 +899,8 @@ namespace quic
         progress_(nullptr),
         quic_event_loop_(GetDefaultEventLoop()->Create(QuicDefaultClock::Get()))
   {
-#ifdef WIN32
-    initSockets();
-#endif
-
+    std::vector<std::string> quiche_cmd_line;
+    quiche_cmd_line.push_back(std::string("webtransport.node"));
     if (!info[0].IsUndefined() /*|| info[1].IsFunction()*/)
     {
       Napi::Object lobj = info[0].ToObject();
@@ -945,12 +951,26 @@ namespace quic
         Napi::Error::New(Env(), "No session callback").ThrowAsJavaScriptException();
         return;
       }
+      quiche_cmd_line.push_back(std::string("-v"));
+      if (lobj.Has("quicheLogVerbose") && lobj.Get("quicheLogVerbose").IsFunction())
+      {
+         Napi::Value verboseValue = (lobj).Get("quicheLogVerbose");
+         quiche_cmd_line.push_back(verboseValue.ToString().Utf8Value());
+      } else {
+         quiche_cmd_line.push_back(std::string("-1"));
+      }
     }
     else
     {
       Napi::Error::New(Env(), "Callback not passed to Http3EventLoop internal").ThrowAsJavaScriptException();
       return;
     }
+    std::vector<const char*> quiche_cmd_line_char;
+    for (auto cur= quiche_cmd_line.begin(); cur != quiche_cmd_line.end(); cur++) {
+      quiche_cmd_line_char.push_back((*cur).c_str());
+    } 
+
+    quiche::QuicheParseCommandLineFlags("No use instruction.", quiche_cmd_line.size(), &(*quiche_cmd_line_char.begin()));
   }
 
   void Http3EventLoop::startEventLoop(const Napi::CallbackInfo &info)

package/src/http3eventloop.h

@@ -93,7 +93,7 @@ namespace quic
             StreamNetworkFinish,
             DatagramReceived,
             DatagramSend,
-            DatagramBufferFree,
+            GoawayReceived,
             Unref
         } type;
         union
@@ -110,6 +110,7 @@ namespace quic
             NetworkTask nettask;
             NetworkStatus status;
             WebTransportSession *webtsession;
+            uint32_t buffergrow;
         };
         union
         {
@@ -210,14 +211,15 @@ 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);
 
         void informDatagramReceived(Http3WTSession *sessionobj, absl::string_view datagram);
-        void informDatagramBufferFree(Napi::ObjectReference *bufferhandle);
-        void informDatagramSend(Http3WTSession *sessionobj);
+        void informDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle);
+
+        void informGoawayReceived(Http3WTSession *sessionobj);
 
         void informUnref(LifetimeHelper *obj);
 
@@ -276,14 +278,15 @@ 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);
 
         void processDatagramReceived(Http3WTSession *sessionobj, std::string *datagram);
-        void processDatagramSend(Http3WTSession *sessionobj);
-        void processDatagramBufferFree(Napi::ObjectReference *bufferhandle);
+        void processDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle);
+
+        void processGoawayReceived(Http3WTSession *sessionobj);
 
         bool shutDownEventLoopInt();
 

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