@fails-components/webtransport 0.0.5 → 0.0.6

package/CMakeLists.txt

@@ -240,8 +240,6 @@ third_party/quiche/quiche/common/platform/api/quiche_reference_counted.h
 third_party/quiche/quiche/common/platform/api/quiche_thread_local.h
 third_party/quiche/quiche/common/platform/api/quiche_time_utils.h
 third_party/quiche/quiche/common/platform/api/quiche_url_utils.h
-third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quic_flags_impl.cc
-third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quic_flags_impl.h
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flag_utils_impl.h
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.cc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "main": "src/webtransport.js",
   "module": "src/webtransport.js",
@@ -12,6 +12,7 @@
     "start": "node test/echoserver.js",
     "test": "node test/test.js",
     "install": "node build.js install",
+    "build": "node build.js build",
     "rebuild": "node build.js rebuild",
     "rebuild-debug": "node build.js rebuild-debug -D",
     "build-debug": "node build.js build-debug"

package/src/http3client.cc

@@ -44,6 +44,42 @@ using spdy::Http2HeaderBlock;
 namespace quic
 {
 
+// taken from libquiche
+namespace
+{
+
+    // For level-triggered I/O, we need to manually rearm the kSocketEventWritable
+    // listener whenever the socket gets blocked.
+    class LevelTriggeredPacketWriter : public QuicDefaultPacketWriter
+    {
+    public:
+        explicit LevelTriggeredPacketWriter(int fd, QuicEventLoop *event_loop)
+            : QuicDefaultPacketWriter(fd), event_loop_(event_loop)
+        {
+            QUICHE_DCHECK(!event_loop->SupportsEdgeTriggered());
+        }
+
+        WriteResult WritePacket(const char *buffer, size_t buf_len,
+                                const QuicIpAddress &self_address,
+                                const QuicSocketAddress &peer_address,
+                                PerPacketOptions *options) override
+        {
+            WriteResult result = QuicDefaultPacketWriter::WritePacket(
+                buffer, buf_len, self_address, peer_address, options);
+            if (IsWriteBlockedStatus(result.status))
+            {
+                bool success = event_loop_->RearmSocket(fd(), kSocketEventWritable);
+                QUICHE_DCHECK(success);
+            }
+            return result;
+        }
+
+    private:
+        QuicEventLoop *event_loop_;
+    };
+
+} // namespace
+
     // taken from chromium to behave like the browser
     // A version of WebTransportFingerprintProofVerifier that enforces
     // Chromium-specific policies.
@@ -168,7 +204,7 @@ namespace quic
 
     void Http3Client::SendRequest(const std::string &uri)
     {
-        spdy::SpdyHeaderBlock headers;
+        spdy::Http2HeaderBlock headers;
         if (!PopulateHeaderBlockFromUrl(uri, &headers))
         {
             return;
@@ -178,7 +214,7 @@ namespace quic
 
     void Http3Client::SendRequestAndRstTogether(const std::string &uri)
     {
-        spdy::SpdyHeaderBlock headers;
+        spdy::Http2HeaderBlock headers;
         if (!PopulateHeaderBlockFromUrl(uri, &headers))
         {
             return;
@@ -194,7 +230,7 @@ namespace quic
     }
 
     void Http3Client::GetOrCreateStreamAndSendRequest(
-        const spdy::SpdyHeaderBlock *headers, absl::string_view body, bool fin)
+        const spdy::Http2HeaderBlock *headers, absl::string_view body, bool fin)
     {
         if (headers)
         {
@@ -206,8 +242,8 @@ namespace quic
             if (rv == QUIC_PENDING)
             {
                 // May need to retry request if asynchronous rendezvous fails.
-                std::unique_ptr<spdy::SpdyHeaderBlock> new_headers(
-                    new spdy::SpdyHeaderBlock(headers->Clone()));
+                std::unique_ptr<spdy::Http2HeaderBlock> new_headers(
+                    new spdy::Http2HeaderBlock(headers->Clone()));
                 push_promise_data_to_resend_ = std::make_unique<Http3ClientDataToResend>(
                     std::move(new_headers), body, fin, this);
                 return;
@@ -218,7 +254,7 @@ namespace quic
         bool hasheaders = false;
         if (headers != nullptr)
         {
-            spdy_headers = std::make_shared<spdy::SpdyHeaderBlock>(headers->Clone());
+            spdy_headers = std::make_shared<spdy::Http2HeaderBlock>(headers->Clone());
             hasheaders = true;
         }
 
@@ -252,13 +288,13 @@ namespace quic
             });
     }
 
-    void Http3Client::SendMessageAsync(const spdy::SpdyHeaderBlock &headers,
+    void Http3Client::SendMessageAsync(const spdy::Http2HeaderBlock &headers,
                                        absl::string_view body)
     {
         return SendMessageAsync(headers, body, /*fin=*/true);
     }
 
-    void Http3Client::SendMessageAsync(const spdy::SpdyHeaderBlock &headers,
+    void Http3Client::SendMessageAsync(const spdy::Http2HeaderBlock &headers,
                                        absl::string_view body, bool fin)
     {
         // Always force creation of a stream for SendMessage.
@@ -667,7 +703,7 @@ namespace quic
 
     void Http3Client::openWTSessionInt(absl::string_view path)
     {
-        spdy::SpdyHeaderBlock headers;
+        spdy::Http2HeaderBlock headers;
         headers[":scheme"] = "https";
         headers[":authority"] = "localhost";
         headers[":path"] = path;
@@ -691,7 +727,7 @@ namespace quic
     {
         QUICHE_DCHECK(initialized_);
         QUICHE_DCHECK(!connected());
-        QuicPacketWriter *writer = new QuicDefaultPacketWriter(GetLatestFD());
+        QuicPacketWriter *writer = new LevelTriggeredPacketWriter(GetLatestFD(), eventloop_->getQuicEventLoop());
         ParsedQuicVersion mutual_version = UnsupportedQuicVersion();
         const bool can_reconnect_with_different_version =
             CanReconnectWithDifferentVersion(&mutual_version);
@@ -895,15 +931,10 @@ namespace quic
                 QUICHE_DCHECK(success);
             }
         }
-        bool writeblocked = false;
         if (connected() && (events & kSocketEventWritable))
         {
             writer_->SetWritable();
             session_->connection()->OnCanWrite();
-            if (writer_->IsWriteBlocked())
-            {
-                writeblocked = true;           
-            }
         }
 
         if (handleConnecting())
@@ -912,16 +943,6 @@ namespace quic
                 event_loop->ArtificiallyNotifyEvent(fd, kSocketEventReadable);
             QUICHE_DCHECK(success);
         }
-        if (writer_->IsWriteBlocked())
-        {
-             writeblocked = true;           
-        }
-        if (!event_loop->SupportsEdgeTriggered() && writeblocked)
-        {
-            bool success = event_loop->RearmSocket(fd, kSocketEventWritable);
-            QUICHE_DCHECK(success);
-            
-        }
     }
 
     void Http3Client::ProcessPacket(
@@ -943,7 +964,7 @@ namespace quic
         return response_headers_complete_;
     }
 
-    const spdy::SpdyHeaderBlock *Http3Client::response_headers() const
+    const spdy::Http2HeaderBlock *Http3Client::response_headers() const
     {
         for (std::pair<QuicStreamId, QuicSpdyClientStream *> stream : open_streams_)
         {
@@ -956,7 +977,7 @@ namespace quic
         return &response_headers_;
     }
 
-    const spdy::SpdyHeaderBlock *Http3Client::preliminary_headers() const
+    const spdy::Http2HeaderBlock *Http3Client::preliminary_headers() const
     {
         for (std::pair<QuicStreamId, QuicSpdyClientStream *> stream : open_streams_)
         {
@@ -971,7 +992,7 @@ namespace quic
         return &preliminary_headers_;
     }
 
-    const spdy::SpdyHeaderBlock &Http3Client::response_trailers() const
+    const spdy::Http2HeaderBlock &Http3Client::response_trailers() const
     {
         return response_trailers_;
     }
@@ -1080,9 +1101,9 @@ namespace quic
     }
 
     bool Http3Client::CheckVary(
-        const spdy::SpdyHeaderBlock & /*client_request*/,
-        const spdy::SpdyHeaderBlock & /*promise_request*/,
-        const spdy::SpdyHeaderBlock & /*promise_response*/)
+        const spdy::Http2HeaderBlock & /*client_request*/,
+        const spdy::Http2HeaderBlock & /*promise_request*/,
+        const spdy::Http2HeaderBlock & /*promise_response*/)
     {
         return true;
     }
@@ -1174,7 +1195,7 @@ namespace quic
     }
 
     Http3Client::Http3ClientDataToResend::Http3ClientDataToResend(
-        std::unique_ptr<spdy::SpdyHeaderBlock> headers, absl::string_view body,
+        std::unique_ptr<spdy::Http2HeaderBlock> headers, absl::string_view body,
         bool fin, Http3Client *client)
         : headers_(std::move(headers)), body_(body), fin_(fin),
           client_(client) {}
@@ -1202,9 +1223,9 @@ namespace quic
     Http3Client::PerStreamState::PerStreamState(
         QuicRstStreamErrorCode stream_error, bool response_complete,
         bool response_headers_complete,
-        const spdy::SpdyHeaderBlock &response_headers,
-        const spdy::SpdyHeaderBlock &preliminary_headers,
-        const std::string &response, const spdy::SpdyHeaderBlock &response_trailers,
+        const spdy::Http2HeaderBlock &response_headers,
+        const spdy::Http2HeaderBlock &preliminary_headers,
+        const std::string &response, const spdy::Http2HeaderBlock &response_trailers,
         uint64_t bytes_read, uint64_t bytes_written, int64_t response_body_size)
         : stream_error(stream_error),
           response_complete(response_complete),
@@ -1220,7 +1241,7 @@ namespace quic
     Http3Client::PerStreamState::~PerStreamState() = default;
 
     bool Http3Client::PopulateHeaderBlockFromUrl(
-        const std::string &uri, spdy::SpdyHeaderBlock *headers)
+        const std::string &uri, spdy::Http2HeaderBlock *headers)
     {
         std::string url;
         if (absl::StartsWith(uri, "https://") || absl::StartsWith(uri, "http://"))

package/src/http3client.h

@@ -133,12 +133,12 @@ namespace quic
 
         // Sends a request containing |headers| and |body| and returns the number of
         // bytes sent (the size of the serialized request headers and body).
-        void SendMessageAsync(const spdy::SpdyHeaderBlock &headers,
+        void SendMessageAsync(const spdy::Http2HeaderBlock &headers,
                               absl::string_view body);
         // Sends a request containing |headers| and |body| with the fin bit set to
         // |fin| and returns the number of bytes sent (the size of the serialized
         // request headers and body).
-        void SendMessageAsync(const spdy::SpdyHeaderBlock &headers,
+        void SendMessageAsync(const spdy::Http2HeaderBlock &headers,
                               absl::string_view body, bool fin);
 
         void SendConnectivityProbing();
@@ -173,14 +173,14 @@ namespace quic
         // is received. 2) returns state of the oldest active stream which have
         // received partial response (if any).
         // Group 1.
-        const spdy::SpdyHeaderBlock &response_trailers() const;
+        const spdy::Http2HeaderBlock &response_trailers() const;
         bool response_complete() const;
         int64_t response_body_size() const;
         const std::string &response_body() const;
         // Group 2.
         bool response_headers_complete() const;
-        const spdy::SpdyHeaderBlock *response_headers() const;
-        const spdy::SpdyHeaderBlock *preliminary_headers() const;
+        const spdy::Http2HeaderBlock *response_headers() const;
+        const spdy::Http2HeaderBlock *preliminary_headers() const;
         int64_t response_size() const;
         size_t bytes_read() const;
         size_t bytes_written() const;
@@ -221,9 +221,9 @@ namespace quic
             const std::string &response_body);
 
         // From QuicClientPushPromiseIndex::Delegate
-        bool CheckVary(const spdy::SpdyHeaderBlock &client_request,
-                       const spdy::SpdyHeaderBlock &promise_request,
-                       const spdy::SpdyHeaderBlock &promise_response) override;
+        bool CheckVary(const spdy::Http2HeaderBlock &client_request,
+                       const spdy::Http2HeaderBlock &promise_request,
+                       const spdy::Http2HeaderBlock &promise_response) override;
         void OnRendezvousResult(QuicSpdyStream *) override;
 
         // Returns nullptr if the maximum number of streams have already been created.
@@ -235,7 +235,7 @@ namespace quic
         // stores the request in case it needs to be resent.  If |headers| is
         // null, only the body will be sent on the stream.
         void GetOrCreateStreamAndSendRequest(
-            const spdy::SpdyHeaderBlock *headers, absl::string_view body, bool fin);
+            const spdy::Http2HeaderBlock *headers, absl::string_view body, bool fin);
 
         QuicRstStreamErrorCode stream_error() { return stream_error_; }
         QuicErrorCode connection_error() const;
@@ -272,7 +272,7 @@ namespace quic
         // request. If |uri| is a relative URL, the QuicServerId will be
         // use to specify the authority.
         bool PopulateHeaderBlockFromUrl(const std::string &uri,
-                                        spdy::SpdyHeaderBlock *headers);
+                                        spdy::Http2HeaderBlock *headers);
 
         QuicSpdyClientStream *latest_created_stream()
         {
@@ -300,7 +300,7 @@ namespace quic
         {
         public:
             Http3ClientDataToResend(
-                std::unique_ptr<spdy::SpdyHeaderBlock> headers, absl::string_view body,
+                std::unique_ptr<spdy::Http2HeaderBlock> headers, absl::string_view body,
                 bool fin, Http3Client *client);
 
             ~Http3ClientDataToResend();
@@ -320,10 +320,10 @@ namespace quic
             PerStreamState(const PerStreamState &other);
             PerStreamState(QuicRstStreamErrorCode stream_error, bool response_complete,
                            bool response_headers_complete,
-                           const spdy::SpdyHeaderBlock &response_headers,
-                           const spdy::SpdyHeaderBlock &preliminary_headers,
+                           const spdy::Http2HeaderBlock &response_headers,
+                           const spdy::Http2HeaderBlock &preliminary_headers,
                            const std::string &response,
-                           const spdy::SpdyHeaderBlock &response_trailers,
+                           const spdy::Http2HeaderBlock &response_trailers,
                            uint64_t bytes_read, uint64_t bytes_written,
                            int64_t response_body_size);
             ~PerStreamState();
@@ -331,10 +331,10 @@ namespace quic
             QuicRstStreamErrorCode stream_error;
             bool response_complete;
             bool response_headers_complete;
-            spdy::SpdyHeaderBlock response_headers;
-            spdy::SpdyHeaderBlock preliminary_headers;
+            spdy::Http2HeaderBlock response_headers;
+            spdy::Http2HeaderBlock preliminary_headers;
             std::string response;
-            spdy::SpdyHeaderBlock response_trailers;
+            spdy::Http2HeaderBlock response_trailers;
             uint64_t bytes_read;
             uint64_t bytes_written;
             int64_t response_body_size;
@@ -396,11 +396,11 @@ namespace quic
 
         bool response_complete_;
         bool response_headers_complete_;
-        mutable spdy::SpdyHeaderBlock preliminary_headers_;
-        mutable spdy::SpdyHeaderBlock response_headers_;
+        mutable spdy::Http2HeaderBlock preliminary_headers_;
+        mutable spdy::Http2HeaderBlock response_headers_;
 
         // Parsed response trailers (if present), copied from the stream in OnClose.
-        spdy::SpdyHeaderBlock response_trailers_;
+        spdy::Http2HeaderBlock response_trailers_;
 
         spdy::SpdyPriority priority_;
         std::string response_;

package/src/http3serverbackend.h

@@ -15,7 +15,7 @@
 
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/web_transport_interface.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic
 {

package/src/http3wtsessionvisitor.cc

@@ -25,7 +25,7 @@ namespace quic
         session_->eventloop_->informSessionClosed(session_, error_code, error_message);
     }
 
-    void Http3WTSession::Visitor::OnSessionReady(const spdy::SpdyHeaderBlock &)
+    void Http3WTSession::Visitor::OnSessionReady(const spdy::Http2HeaderBlock &)
     {
         session_->eventloop_->informSessionReady(session_);
 

package/src/http3wtsessionvisitor.h

@@ -62,7 +62,7 @@ namespace quic
 
             ~Visitor();
 
-            void OnSessionReady(const spdy::SpdyHeaderBlock &) override;
+            void OnSessionReady(const spdy::Http2HeaderBlock &) override;
 
             void OnSessionClosed(WebTransportSessionError error_code,
                                  const std::string &error_message) override;

package/src/webtransport.js

@@ -24,6 +24,7 @@ if (
 ) {
   wtpath = buildpath + '/Debug/webtransport.node'
 }
+console.log('load webtransport binary:', wtpath)
 
 const wtrouter = require(wtpath)
 

package/platform/quiche_platform_impl/quic_flags_impl.h

@@ -1,9 +0,0 @@
-// from envoy so LICENSE.envoy applies
-#ifndef QUIC_FLAGS_IMPL
-#define QUIC_FLAGS_IMPL
-
-
-#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quic_flags_impl.h"
-
-
-#endif