@fails-components/webtransport 0.0.5 → 0.0.7

package/src/http3client.cc

@@ -19,6 +19,7 @@
 
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
+#include "absl/cleanup/cleanup.h"
 #include "openssl/x509.h"
 #include "quiche/quic/core/crypto/proof_verifier.h"
 #include "quiche/quic/core/http/quic_spdy_client_stream.h"
@@ -44,6 +45,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 +205,7 @@ namespace quic
 
     void Http3Client::SendRequest(const std::string &uri)
     {
-        spdy::SpdyHeaderBlock headers;
+        spdy::Http2HeaderBlock headers;
         if (!PopulateHeaderBlockFromUrl(uri, &headers))
         {
             return;
@@ -178,7 +215,7 @@ namespace quic
 
     void Http3Client::SendRequestAndRstTogether(const std::string &uri)
     {
-        spdy::SpdyHeaderBlock headers;
+        spdy::Http2HeaderBlock headers;
         if (!PopulateHeaderBlockFromUrl(uri, &headers))
         {
             return;
@@ -194,7 +231,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 +243,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 +255,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 +289,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.
@@ -444,6 +481,9 @@ namespace quic
         overflow_supported_ = api.EnableDroppedPacketCount(fd);
         api.EnableReceiveTimestamp(fd);
 
+        auto closer = absl::MakeCleanup([fd]
+                                        { QuicUdpSocketApi api;api.Destroy(fd); });
+
         QuicSocketAddress client_address;
         if (bind_to_address.IsInitialized())
         {
@@ -492,10 +532,13 @@ namespace quic
         }
         const int kEpollFlags = kSocketEventReadable | kSocketEventWritable; // there is no analogue to EPOLLET in libuv hopefully not a problem
 
-        fd_address_map_[fd] = client_address;
-        eventloop_->getQuicEventLoop()->RegisterSocket(fd, kEpollFlags, this);
-        // eventloop_->SetNonblocking(fd); // eventuelly should be part of register socket.
-        return true;
+        if (eventloop_->getQuicEventLoop()->RegisterSocket(fd, kEpollFlags, this))
+        {
+            fd_address_map_[fd] = client_address;
+            std::move(closer).Cancel();
+            return true;
+        }
+        return false;
     }
 
     void Http3Client::CleanUpUDPSocket(int fd)
@@ -651,8 +694,8 @@ namespace quic
                         Http3WTSession *wtsessionobj =
                             new Http3WTSession();
                         wtsessionobj->init(
-                                static_cast<WebTransportSession *>(wtsession),
-                                eventloop_);
+                            static_cast<WebTransportSession *>(wtsession),
+                            eventloop_);
                         eventloop_->informNewClientSession(this, wtsessionobj);
                         auto visitor = std::make_unique<Http3WTSession::Visitor>(wtsessionobj);
                         wtsession->SetVisitor(std::move(visitor));
@@ -667,7 +710,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 +734,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);
@@ -717,7 +760,7 @@ namespace quic
 
         session_ = std::make_unique<Http3ClientSession>(
             config_, client_supported_versions, new QuicConnection(newconnid, QuicSocketAddress(), server_address_, helper_.get(), alarm_factory_.get(), writer,
-                                                                   /* owns_writer= */ false, Perspective::IS_CLIENT, client_supported_versions),
+                                                                   /* owns_writer= */ false, Perspective::IS_CLIENT, client_supported_versions, connection_id_generator_),
             server_id_, &crypto_config_,
             &push_promise_index_, false /*drop_response_body_*/, true /* enable_web_transport */);
 
@@ -888,22 +931,17 @@ namespace quic
                 bool success =
                     event_loop->ArtificiallyNotifyEvent(fd, kSocketEventReadable);
                 QUICHE_DCHECK(success);
-            } 
+            }
             if (!event_loop->SupportsEdgeTriggered())
             {
                 bool success = event_loop->RearmSocket(fd, kSocketEventReadable);
                 QUICHE_DCHECK(success);
             }
         }
-        bool writeblocked = false;
         if (connected() && (events & kSocketEventWritable))
         {
             writer_->SetWritable();
             session_->connection()->OnCanWrite();
-            if (writer_->IsWriteBlocked())
-            {
-                writeblocked = true;           
-            }
         }
 
         if (handleConnecting())
@@ -912,16 +950,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 +971,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 +984,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 +999,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 +1108,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 +1202,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 +1230,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 +1248,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://"))
@@ -1271,8 +1299,7 @@ namespace quic
         latest_created_stream_ = nullptr;
     }
 
-    Http3ClientJS::Http3ClientJS(const Napi::CallbackInfo &info) : 
-            Napi::ObjectWrap<Http3ClientJS>(info)
+    Http3ClientJS::Http3ClientJS(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Http3ClientJS>(info)
     {
 
         std::string port = "443";
@@ -1289,39 +1316,41 @@ namespace quic
             if (!lobj.IsEmpty())
             {
 
-                if (lobj.Has( "allowPooling") && !(lobj).Get("allowPooling").IsEmpty())
+                if (lobj.Has("allowPooling") && !(lobj).Get("allowPooling").IsEmpty())
                 {
                     Napi::Value poolValue = (lobj).Get("allowPooling");
                     allowPooling = poolValue.As<Napi::Boolean>().Value();
                 }
 
-                if (lobj.Has( "forceIpv6") && !(lobj).Get("forceIpv6").IsEmpty())
+                if (lobj.Has("forceIpv6") && !(lobj).Get("forceIpv6").IsEmpty())
                 {
                     Napi::Value ipv6Value = (lobj).Get("forceIpv6");
                     forceipv6 = ipv6Value.As<Napi::Boolean>().Value();
                 }
 
-                if (lobj.Has( "port") && !(lobj).Get("port").IsEmpty())
+                if (lobj.Has("port") && !(lobj).Get("port").IsEmpty())
                 {
                     Napi::Value portValue = (lobj).Get("port");
                     port = portValue.ToString().Utf8Value();
                 }
-                else {
+                else
+                {
                     Napi::Error::New(env, "no port specified").ThrowAsJavaScriptException();
-                    return ;
+                    return;
                 }
 
-                if (lobj.Has( "hostname") && !(lobj).Get("hostname").IsEmpty())
+                if (lobj.Has("hostname") && !(lobj).Get("hostname").IsEmpty())
                 {
                     Napi::Value hostnameValue = (lobj).Get("hostname");
                     hostname = hostnameValue.ToString().Utf8Value();
                 }
-                else {
+                else
+                {
                     Napi::Error::New(env, "no hostname specified").ThrowAsJavaScriptException();
-                    return ;
+                    return;
                 }
 
-                if (lobj.Has( "serverCertificateHashes") && !(lobj).Get("serverCertificateHashes").IsEmpty())
+                if (lobj.Has("serverCertificateHashes") && !(lobj).Get("serverCertificateHashes").IsEmpty())
                 {
                     Napi::Value hashValue = (lobj).Get("serverCertificateHashes");
                     if (hashValue.IsArray())
@@ -1341,40 +1370,45 @@ namespace quic
                                 size_t len = bufferlocal.As<Napi::Buffer<char>>().Length();
                                 curhash.value = std::string(buffer, len);
                             }
-                            else {
+                            else
+                            {
                                 Napi::Error::New(env, "serverCertificateHashes wrong format").ThrowAsJavaScriptException();
-                                return ;
+                                return;
                             }
                             if (hashobj.Has("algorithm") && !(hashobj).Get("algorithm").IsEmpty())
                             {
                                 Napi::Value algorithmValue = (hashobj).Get("algorithm");
                                 curhash.algorithm = algorithmValue.ToString().Utf8Value();
                             }
-                            else {
+                            else
+                            {
                                 Napi::Error::New(env, "serverCertificateHashes wrong format").ThrowAsJavaScriptException();
-                                return ;
+                                return;
                             }
-                            if (curhash.algorithm.compare(WebTransportHash::kSha256) != 0) {
+                            if (curhash.algorithm.compare(WebTransportHash::kSha256) != 0)
+                            {
                                 Napi::Error::New(env, "serverCertificateHashes unknown algorithm").ThrowAsJavaScriptException();
-                                return ;
+                                return;
                             }
                             serverCertificateHashes.push_back(curhash);
                         }
                     }
-                    else {
+                    else
+                    {
                         Napi::Error::New(env, "serverCertificateHashes is not an array").ThrowAsJavaScriptException();
-                        return ;
+                        return;
                     }
                 }
 
-                if (lobj.Has( "localPort") && !(lobj).Get("localPort").IsEmpty())
+                if (lobj.Has("localPort") && !(lobj).Get("localPort").IsEmpty())
                 {
                     Napi::Value localPortValue = (lobj).Get("localPort");
                     if (localPortValue.IsNumber())
                         local_port = localPortValue.As<Napi::Number>().Int32Value();
-                    else {
+                    else
+                    {
                         Napi::Error::New(env, "localPort is not a number").ThrowAsJavaScriptException();
-                        return ;
+                        return;
                     }
                 }
             }
@@ -1391,7 +1425,7 @@ namespace quic
         else
         {
             Napi::Error::New(env, "No eventloop arguments passed to Http3Client").ThrowAsJavaScriptException();
-            return ;
+            return;
         }
 
         std::unique_ptr<QuicConnectionHelperInterface> helper =
@@ -1409,13 +1443,14 @@ namespace quic
                 if (!verifier->AddFingerprint(*cur))
                 {
                     Napi::Error::New(env, "serverCertificateHashes is not valid fingerprint").ThrowAsJavaScriptException();
-                    return ;
+                    return;
                 }
             }
         }
-        else {
+        else
+        {
             Napi::Error::New(env, "No supported verification method included").ThrowAsJavaScriptException();
-            return ;
+            return;
         }
 
         std::unique_ptr<Http3SessionCache> cache;
@@ -1442,7 +1477,7 @@ namespace quic
                             << gai_strerror(result);
             info_list = nullptr;
             Napi::Error::New(env, "URL host lookup failed").ThrowAsJavaScriptException();
-            return ;
+            return;
         }
 
         QUICHE_CHECK(info_list != nullptr);
@@ -1450,7 +1485,7 @@ namespace quic
         freeaddrinfo(info_list);
 
         client_ = std::make_unique<Http3Client>(eventloop, address, hostname, local_port,
-                                  std::move(verifier), std::move(cache), std::move(helper));
+                                                std::move(verifier), std::move(cache), std::move(helper));
         client_->SetUserAgentID("fails-components/webtransport");
 
         client_->setJS(this);
@@ -1462,11 +1497,10 @@ namespace quic
             client_->Connect();
         };
         client_->eventloop_->Schedule(task);
-        return ;
+        return;
     }
 
-
-    void Http3ClientJS::openWTSession(const Napi::CallbackInfo& info)
+    void Http3ClientJS::openWTSession(const Napi::CallbackInfo &info)
     {
         Http3Client *obj = getObj();
         // got the object we can now start the server
@@ -1480,13 +1514,14 @@ namespace quic
             };
             obj->eventloop_->Schedule(task);
         }
-        else {
+        else
+        {
             Napi::Error::New(info.Env(), "openWTSession without path").ThrowAsJavaScriptException();
-            return ;
+            return;
         }
     }
 
-    void Http3ClientJS::closeClient(const Napi::CallbackInfo& info)
+    void Http3ClientJS::closeClient(const Napi::CallbackInfo &info)
     {
         Http3Client *obj = getObj();
         // got the object we can now start the server
@@ -1494,8 +1529,8 @@ namespace quic
         {
             if (!obj->closeClientInt())
             {
-                printf( "closeClientInt failed for Http3Client");
-                return ;
+                printf("closeClientInt failed for Http3Client");
+                return;
             }
         };
         obj->eventloop_->Schedule(task);

package/src/http3client.h

@@ -29,6 +29,7 @@
 #include "quiche/quic/core/quic_packet_reader.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
 #include "quiche/quic/core/proto/cached_network_parameters_proto.h"
+#include "quiche/quic/core/deterministic_connection_id_generator.h"
 #include "quiche/quic/core/quic_framer.h"
 #include "quiche/quic/core/quic_packet_creator.h"
 #include "quiche/quic/core/quic_packets.h"
@@ -133,12 +134,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 +174,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 +222,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 +236,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 +273,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 +301,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 +321,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 +332,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;
@@ -353,6 +354,8 @@ namespace quic
         // Returns true if the corresponding of this client has active requests.
         bool HasActiveRequests();
 
+        ConnectionIdGeneratorInterface &connection_id_generator();
+
         // Actually clean up |fd|.
         void CleanUpUDPSocketImpl(QuicUdpSocketFd fd);
 
@@ -396,11 +399,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_;
@@ -541,6 +544,9 @@ namespace quic
         // space than allowed on the stack.
         std::unique_ptr<QuicPacketReader> packet_reader_;
 
+        DeterministicConnectionIdGenerator connection_id_generator_{
+            kQuicDefaultConnectionIdLength};
+
         Http3EventLoop *eventloop_;
         // connection workflow
         bool wait_for_encryption_;

package/src/http3dispatcher.cc

@@ -23,14 +23,16 @@ Http3Dispatcher::Http3Dispatcher(
     std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
     std::unique_ptr<QuicAlarmFactory> alarm_factory,
     Http3ServerBackend* http3_server_backend,
-    uint8_t expected_server_connection_id_length)
+    uint8_t expected_server_connection_id_length,
+    ConnectionIdGeneratorInterface& generator)
     : QuicDispatcher(config,
                      crypto_config,
                      version_manager,
                      std::move(helper),
                      std::move(session_helper),
                      std::move(alarm_factory),
-                     expected_server_connection_id_length),
+                     expected_server_connection_id_length,
+                     generator),
       http3_server_backend_(http3_server_backend) {}
 
 Http3Dispatcher::~Http3Dispatcher() = default;
@@ -47,7 +49,7 @@ std::unique_ptr<QuicSession> Http3Dispatcher::CreateQuicSession(
       new QuicConnection(connection_id, self_address, peer_address, helper(),
                          alarm_factory(), writer(),
                          /* owns_writer= */ false, Perspective::IS_SERVER,
-                         ParsedQuicVersionVector{version});
+                         ParsedQuicVersionVector{version}, connection_id_generator());
 
   auto session = std::make_unique<Http3ServerSession>(
       config(), GetSupportedVersions(), connection, this, session_helper(),

package/src/http3dispatcher.h

@@ -30,7 +30,8 @@ namespace quic
         std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
         std::unique_ptr<QuicAlarmFactory> alarm_factory,
         Http3ServerBackend *http3_server_backend,
-        uint8_t expected_server_connection_id_length);
+        uint8_t expected_server_connection_id_length,
+        ConnectionIdGeneratorInterface& generator);
 
     ~Http3Dispatcher() override;