@fails-components/webtransport 0.0.6 → 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,41 +45,41 @@ 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
+    // taken from libquiche
+    namespace
     {
-    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
+        // For level-triggered I/O, we need to manually rearm the kSocketEventWritable
+        // listener whenever the socket gets blocked.
+        class LevelTriggeredPacketWriter : public QuicDefaultPacketWriter
         {
-            WriteResult result = QuicDefaultPacketWriter::WritePacket(
-                buffer, buf_len, self_address, peer_address, options);
-            if (IsWriteBlockedStatus(result.status))
+        public:
+            explicit LevelTriggeredPacketWriter(int fd, QuicEventLoop *event_loop)
+                : QuicDefaultPacketWriter(fd), event_loop_(event_loop)
             {
-                bool success = event_loop_->RearmSocket(fd(), kSocketEventWritable);
-                QUICHE_DCHECK(success);
+                QUICHE_DCHECK(!event_loop->SupportsEdgeTriggered());
             }
-            return result;
-        }
 
-    private:
-        QuicEventLoop *event_loop_;
-    };
+            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
+    } // namespace
 
     // taken from chromium to behave like the browser
     // A version of WebTransportFingerprintProofVerifier that enforces
@@ -480,6 +481,9 @@ namespace
         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())
         {
@@ -528,10 +532,13 @@ namespace
         }
         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)
@@ -687,8 +694,8 @@ namespace
                         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));
@@ -753,7 +760,7 @@ namespace
 
         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 */);
 
@@ -924,7 +931,7 @@ namespace
                 bool success =
                     event_loop->ArtificiallyNotifyEvent(fd, kSocketEventReadable);
                 QUICHE_DCHECK(success);
-            } 
+            }
             if (!event_loop->SupportsEdgeTriggered())
             {
                 bool success = event_loop->RearmSocket(fd, kSocketEventReadable);
@@ -1292,8 +1299,7 @@ namespace
         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";
@@ -1310,39 +1316,41 @@ namespace
             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())
@@ -1362,40 +1370,45 @@ namespace
                                 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;
                     }
                 }
             }
@@ -1412,7 +1425,7 @@ namespace
         else
         {
             Napi::Error::New(env, "No eventloop arguments passed to Http3Client").ThrowAsJavaScriptException();
-            return ;
+            return;
         }
 
         std::unique_ptr<QuicConnectionHelperInterface> helper =
@@ -1430,13 +1443,14 @@ namespace
                 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;
@@ -1463,7 +1477,7 @@ namespace
                             << gai_strerror(result);
             info_list = nullptr;
             Napi::Error::New(env, "URL host lookup failed").ThrowAsJavaScriptException();
-            return ;
+            return;
         }
 
         QUICHE_CHECK(info_list != nullptr);
@@ -1471,7 +1485,7 @@ namespace
         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);
@@ -1483,11 +1497,10 @@ namespace
             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
@@ -1501,13 +1514,14 @@ namespace
             };
             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
@@ -1515,8 +1529,8 @@ namespace
         {
             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"
@@ -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);
 
@@ -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;
 

package/src/http3server.cc

@@ -7,6 +7,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "absl/cleanup/cleanup.h"
 #include "src/http3server.h"
 #include "src/http3dispatcher.h"
 #include "src/http3wtsessionvisitor.h"
@@ -39,7 +40,8 @@ namespace quic
                        std::move(proof_source),
                        KeyExchangeSource::Default()),
         expected_server_connection_id_length_(kQuicDefaultConnectionIdLength),
-        js_(nullptr)
+        js_(nullptr),
+        connection_id_generator_(expected_server_connection_id_length_)
   {
   }
 
@@ -59,6 +61,8 @@ namespace quic
       QUIC_LOG(ERROR) << "CreateSocket() failed: " << strerror(errno);
       return false;
     }
+    auto closer = absl::MakeCleanup([this]
+                                    { { QuicUdpSocketApi api;api.Destroy(fd_); } });
 
     overflow_supported_ = socket_api.EnableDroppedPacketCount(fd_);
     socket_api.EnableReceiveTimestamp(fd_);
@@ -83,12 +87,16 @@ namespace quic
 
     const int kEpollFlags = kSocketEventReadable | kSocketEventWritable;
 
-    eventloop_->getQuicEventLoop()->RegisterSocket(fd_, kEpollFlags, this);
-    // eventloop_->SetNonblocking(fd_); // eventuelly should be part of register socket.
-    dispatcher_.reset(CreateQuicDispatcher());
-    dispatcher_->InitializeWithWriter(new QuicDefaultPacketWriter(fd_));
+    if (eventloop_->getQuicEventLoop()->RegisterSocket(fd_, kEpollFlags, this))
+    {
+      // eventloop_->SetNonblocking(fd_); // eventuelly should be part of register socket.
+      dispatcher_.reset(CreateQuicDispatcher());
+      dispatcher_->InitializeWithWriter(new QuicDefaultPacketWriter(fd_));
+      std::move(closer).Cancel();
+      return true;
+    }
 
-    return true;
+    return false;
   }
 
   bool Http3Server::stopServerInt()
@@ -119,7 +127,7 @@ namespace quic
             new QuicSimpleCryptoServerStreamHelper()),
         std::unique_ptr<QuicAlarmFactory>(
             eventloop_->getQuicEventLoop()->CreateAlarmFactory()),
-        &http3_server_backend_, expected_server_connection_id_length_);
+        &http3_server_backend_, expected_server_connection_id_length_, connection_id_generator_);
   }
 
   Http3ServerJS::Http3ServerJS(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Http3ServerJS>(info)
@@ -149,7 +157,7 @@ namespace quic
         else
         {
           Napi::Error::New(Env(), "No secret set for Http3Server").ThrowAsJavaScriptException();
-          return ;
+          return;
         }
         if (lobj.Has("host") && !(lobj).Get("host").IsEmpty())
         {
@@ -183,6 +191,20 @@ namespace quic
           sconfig.SetMaxBidirectionalStreamsToSend(maxconn);
           sconfig.SetMaxUnidirectionalStreamsToSend(maxconn);
         }
+
+        if (lobj.Has("initialStreamFlowControlWindow") && !(lobj).Get("initialStreamFlowControlWindow").IsEmpty())
+        {
+          Napi::Value initialStreamFlowControlWindowValue = (lobj).Get("initialStreamFlowControlWindow");
+          int initialStreamFlowControlWindow = initialStreamFlowControlWindowValue.As<Napi::Number>().Int32Value();
+          sconfig.SetInitialStreamFlowControlWindowToSend(initialStreamFlowControlWindow);
+        }
+
+        if (lobj.Has("initialSessionFlowControlWindow") && !(lobj).Get("initialSessionFlowControlWindow").IsEmpty())
+        {
+          Napi::Value initialSessionFlowControlWindowValue = (lobj).Get("initialSessionFlowControlWindow");
+          int initialSessionFlowControlWindow = initialSessionFlowControlWindowValue.As<Napi::Number>().Int32Value();
+          sconfig.SetInitialSessionFlowControlWindowToSend(initialSessionFlowControlWindow);
+        }
       }
       // Callback *callback, int port, std::unique_ptr<ProofSource> proof_source,  const char *secret
 
@@ -202,7 +224,7 @@ namespace quic
       if (proofsource == nullptr)
       {
         Napi::Error::New(Env(), "LoadPemFromStream cert failed for Http3Server").ThrowAsJavaScriptException();
-        return ;
+        return;
       }
       Http3EventLoop *eventloop = nullptr;
       if (!info[1].IsUndefined())
@@ -213,7 +235,7 @@ namespace quic
       else
       {
         Napi::Error::New(Env(), "No eventloop arguments passed to Http3Server").ThrowAsJavaScriptException();
-        return ;
+        return;
       }
 
       server_ = std::make_unique<Http3Server>(eventloop, host, port, std::move(proofsource), secret.c_str(), sconfig);
@@ -270,6 +292,21 @@ namespace quic
       freeaddrinfo(servinfo);
     }
 
+    const uint32_t kInitialSessionFlowControlWindow = 1 * 1024 * 1024; // 1 MB
+    const uint32_t kInitialStreamFlowControlWindow = 64 * 1024;        // 64 KB
+    if (config_.GetInitialStreamFlowControlWindowToSend() ==
+        kDefaultFlowControlSendWindow)
+    {
+      config_.SetInitialStreamFlowControlWindowToSend(
+          kInitialStreamFlowControlWindow);
+    }
+    if (config_.GetInitialSessionFlowControlWindowToSend() ==
+        kDefaultFlowControlSendWindow)
+    {
+      config_.SetInitialSessionFlowControlWindowToSend(
+          kInitialSessionFlowControlWindow);
+    }
+
     QuicSocketAddress address(ipaddress, port_);
     if (!CreateUDPSocketAndListen(address))
       return false; // move to this class

package/src/http3server.h

@@ -18,6 +18,7 @@
 #include "src/http3serverbackend.h"
 #include "src/http3eventloop.h"
 #include "quiche/quic/core/crypto/quic_crypto_server_config.h"
+#include "quiche/quic/core/deterministic_connection_id_generator.h"
 #include "quiche/quic/core/quic_udp_socket.h"
 #include "quiche/quic/core/quic_dispatcher.h"
 #include "quiche/quic/core/quic_packet_reader.h"
@@ -61,7 +62,6 @@ namespace quic
             exports.Set("Http3WebTransportServer", tplsrv);
         }
 
-
         void doUnref() override
         {
             Unref();
@@ -127,6 +127,7 @@ namespace quic
         QuicDispatcher *CreateQuicDispatcher();
 
         Http3EventLoop *eventloop_;
+        DeterministicConnectionIdGenerator connection_id_generator_;
     };
 
 }

package/test/testsuite.js

@@ -123,7 +123,7 @@ export async function echoTestsConnection(transport) {
   refArray1.set(data2, data1.length)
 
   const resultArray1 = new Uint8Array(i)
-  console.log("TEST 1: start")
+  console.log('TEST 1: start')
 
   while (true && i > 0) {
     const { done, value } = await reader.read()
@@ -155,8 +155,8 @@ export async function echoTestsConnection(transport) {
   testArraysEqual(refArray1, resultArray1)
 
   console.log('webtransport sending bidistream success')
-  console.log("TEST 1: finish")
-  console.log("TEST 2: start")
+  console.log('TEST 1: finish')
+  console.log('TEST 2: start')
   const bidiReader = transport.incomingBidirectionalStreams.getReader()
   const incombidi = await bidiReader.read()
   if (incombidi.value) {
@@ -204,9 +204,9 @@ export async function echoTestsConnection(transport) {
     }
     testArraysEqual(refArray2, resultArray2)
   }
-  console.log("TEST 2: finish")
+  console.log('TEST 2: finish')
 
-  console.log("TEST 3: start")
+  console.log('TEST 3: start')
   console.log('now unidirectional tests')
   const unidioutstream = await transport.createUnidirectionalStream()
   const unidiwrite = unidioutstream.getWriter()
@@ -262,8 +262,8 @@ export async function echoTestsConnection(transport) {
       throw new Error('incoming unidi stream test failed')
     }
   }
-  console.log("TEST 3: finish")
-  console.log("TEST 4: start")
+  console.log('TEST 3: finish')
+  console.log('TEST 4: start')
   console.log('finally test datagrams')
   const datawrite = await transport.datagrams.writable.getWriter()
   const data7 = new Uint8Array([83, 84, 85])
@@ -300,6 +300,6 @@ export async function echoTestsConnection(transport) {
     throw new Error('datagram stream test failed')
   }
   console.log('test datagrams finished')
-  console.log("TEST 4: finish")
+  console.log('TEST 4: finish')
   console.log('start close stream tests')
 }