@fails-components/webtransport-transport-http3-quiche 1.0.0-rc.1

package/src/http3client.cc

@@ -0,0 +1,1402 @@
+// Copyright (c) 2022 Marten Richter or other contributers (see commit). All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// portions taken from libquiche or Chromium, original copyright, see LICENSE.chromium
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/http3client.h"
+#include "src/http3clientsession.h"
+#include "src/http3wtsessionvisitor.h"
+#include "src/http3sessioncache.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#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"
+#include "quiche/quic/core/http/spdy_utils.h"
+#include "quiche/quic/core/http/web_transport_http3.h"
+#include "quiche/quic/core/web_transport_interface.h"
+#include "quiche/quic/core/quic_default_packet_writer.h"
+#include "quiche/quic/core/quic_default_connection_helper.h"
+#include "quiche/quic/core/quic_default_clock.h"
+#include "quiche/quic/core/quic_packet_writer_wrapper.h"
+#include "quiche/quic/core/quic_server_id.h"
+#include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/platform/api/quic_flags.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/platform/api/quic_stack_trace.h"
+// #include "quiche/quic/test_tools/crypto_test_utils.h"
+#include "quiche/quic/core/quic_udp_socket.h"
+#include "quiche/quic/tools/quic_url.h"
+#include "quiche/common/quiche_text_utils.h"
+
+using spdy::Http2HeaderBlock;
+
+namespace quic
+{
+
+    // taken from chromium to behave like the browser
+    // A version of WebTransportFingerprintProofVerifier that enforces
+    // Chromium-specific policies.
+    class ChromiumWebTransportFingerprintProofVerifier
+        : public quic::WebTransportFingerprintProofVerifier
+    {
+    public:
+        using WebTransportFingerprintProofVerifier::
+            WebTransportFingerprintProofVerifier;
+
+    protected:
+        bool IsKeyTypeAllowedByPolicy(
+            const quic::CertificateView &certificate) override
+        {
+            if (certificate.public_key_type() == quic::PublicKeyType::kRsa)
+            {
+                return false;
+            }
+            return WebTransportFingerprintProofVerifier::IsKeyTypeAllowedByPolicy(
+                certificate);
+        }
+    };
+
+    class NodeJSProofVerifier : public quic::ProofVerifier
+    {
+    public:
+
+        NodeJSProofVerifier(EnvGetter *envg) : envg_(envg)
+        {
+
+        }
+
+        QuicAsyncStatus VerifyProof(
+            const std::string& hostname, const uint16_t port,
+            const std::string& server_config, QuicTransportVersion transport_version,
+            absl::string_view chlo_hash, const std::vector<std::string>& certs,
+            const std::string& cert_sct, const std::string& signature,
+            const ProofVerifyContext* context, std::string* error_details,
+            std::unique_ptr<ProofVerifyDetails>* details,
+            std::unique_ptr<ProofVerifierCallback> callback) {
+                auto env = envg_->getEnv();
+                Napi::HandleScope scope(env);
+                
+                Napi::Object retObj = Napi::Object::New(env);
+                retObj.Set("hostname", hostname);
+                retObj.Set("port", port);
+                retObj.Set("serverconfig", server_config);
+                // todo certs
+
+                Napi::Array jscerts = Napi::Array::New(env, certs.size());
+                for (size_t i = 0; i < certs.size(); i++) {
+                    jscerts.Set(i, certs[i]);
+                }
+                retObj.Set("signature", signature);
+
+                Napi::Value verifyres = env.Global().Get("FAILSVerifyProof").As<Napi::Function>().Call({
+                    retObj });
+                if (verifyres.As<Napi::Boolean>().Value()) {
+                    return QUIC_SUCCESS;
+
+                } else {
+                    return QUIC_FAILURE;
+                }
+        }
+
+        QuicAsyncStatus VerifyCertChain(
+            const std::string& hostname, const uint16_t port,
+            const std::vector<std::string>& certs, const std::string& ocsp_response,
+            const std::string& cert_sct, const ProofVerifyContext* context,
+            std::string* error_details, std::unique_ptr<ProofVerifyDetails>* details,
+            uint8_t* out_alert, std::unique_ptr<ProofVerifierCallback> callback) {
+                auto env = envg_->getEnv();
+                Napi::HandleScope scope(env);
+                
+                Napi::Object retObj = Napi::Object::New(env);
+                retObj.Set("hostname", hostname);
+                retObj.Set("port", port);
+                // todo certs
+
+                Napi::Array jscerts = Napi::Array::New(env, certs.size());
+                for (size_t i = 0; i < certs.size(); i++) {
+                    jscerts.Set(i, certs[i]);
+                }
+                Napi::Value verifyres = env.Global().Get("FAILSVerifyProof").As<Napi::Function>().Call({
+                    retObj });
+                if (verifyres.As<Napi::Boolean>().Value()) {
+                    return QUIC_SUCCESS;
+
+                } else {
+                    return QUIC_FAILURE;
+                }
+        }
+
+        std::unique_ptr<ProofVerifyContext> CreateDefaultContext() {
+            return nullptr;
+        }
+  
+    private:
+        EnvGetter *envg_;
+    };
+
+    QuicStreamId GetNthClientInitiatedBidirectionalStreamId(
+        QuicTransportVersion version, int n)
+    {
+        int num = n;
+        if (!VersionUsesHttp3(version))
+        {
+            num++;
+        }
+        return QuicUtils::GetFirstBidirectionalStreamId(version,
+                                                        Perspective::IS_CLIENT) +
+               QuicUtils::StreamIdDelta(version) * num;
+    }
+
+    Http3Client::Http3Client(Http3ClientJS *js, 
+                             std::unique_ptr<ProofVerifier> proof_verifier,
+                             std::unique_ptr<SessionCache> session_cache,
+                             std::unique_ptr<QuicConnectionHelperInterface> helper,
+                             QuicConfig config) :
+          initialized_(false),
+          store_response_(false),
+          latest_response_code_(-1),
+          overflow_supported_(false),
+          packets_dropped_(0),
+          packet_reader_(new QuicPacketReader()),
+          config_(config),
+          crypto_config_(std::move(proof_verifier), std::move(session_cache)),
+          helper_(std::move(helper)),
+          alarm_factory_(new NapiAlarmFactory(QuicDefaultClock::Get(), js)),
+          supported_versions_({ParsedQuicVersion::RFCv1()}),
+          initial_max_packet_length_(0),
+          num_sent_client_hellos_(0),
+          js_(js),
+          connection_error_(QUIC_NO_ERROR),
+          connected_or_attempting_connect_(false),
+          server_connection_id_length_(kQuicDefaultConnectionIdLength),
+          client_connection_id_length_(0),
+          max_reads_per_loop_(std::numeric_limits<int>::max()),
+          wait_for_encryption_(false),
+          connection_in_progress_(false),
+          connectionrecheck_(false),
+          num_attempts_connect_(0),
+          webtransport_server_support_inform_(false),
+          connection_debug_visitor_(nullptr),
+          priority_(HttpStreamPriority())
+    {
+       
+    }
+
+    Http3Client::~Http3Client()
+    {
+        // printf("client destruct %x\n", this);
+    }
+
+    void Http3Client::setHostname(QuicSocketAddress server_address, const std::string &server_hostname)
+    {
+        server_id_ = QuicServerId(server_hostname, server_address.port(), false);
+        set_server_address(server_address);
+        Initialize();
+    }
+
+    bool Http3Client::closeClientInt()
+    {
+        for (std::pair<QuicStreamId, QuicSpdyClientStream *> stream : open_streams_)
+        {
+            stream.second->set_visitor(nullptr);
+        }
+        if (connected())
+        {
+            session_->connection()->CloseConnection(
+                QUIC_PEER_GOING_AWAY, "Client being torn down",
+                ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+        }
+        // We own the push promise index. We need to explicitly kill
+        // the session before the push promise index goes out of scope.
+        ResetSession();
+
+        this->getJS()->Unref();
+        return true;
+    }
+
+    void Http3Client::Initialize()
+    {
+        priority_ = QuicStreamPriority(HttpStreamPriority());
+        connect_attempted_ = false;
+        auto_reconnect_ = false;
+        buffer_body_ = true;
+        num_requests_ = 0;
+        num_responses_ = 0;
+        ClearPerConnectionState();
+        // As chrome will generally do this, we want it to be the default when it's
+        // not overridden.
+        if (!config_.HasSetBytesForConnectionIdToSend())
+        {
+            config_.SetBytesForConnectionIdToSend(0);
+        }
+    }
+
+    void Http3Client::SetUserAgentID(const std::string &user_agent_id)
+    {
+        crypto_config_.set_user_agent_id(user_agent_id);
+    }
+
+    void Http3Client::SendRequest(const std::string &uri)
+    {
+        spdy::Http2HeaderBlock headers;
+        if (!PopulateHeaderBlockFromUrl(uri, &headers))
+        {
+            return;
+        }
+        SendMessageAsync(headers, "");
+    }
+
+    void Http3Client::SendRequestAndRstTogether(const std::string &uri)
+    {
+        spdy::Http2HeaderBlock headers;
+        if (!PopulateHeaderBlockFromUrl(uri, &headers))
+        {
+            return;
+        }
+
+        QuicSpdyClientSession *session = session_.get();
+        QuicConnection::ScopedPacketFlusher flusher(session->connection());
+        SendMessageAsync(headers, "", /*fin=*/true);
+
+        QuicStreamId stream_id = GetNthClientInitiatedBidirectionalStreamId(
+            session->transport_version(), 0);
+        session->ResetStream(stream_id, QUIC_STREAM_CANCELLED);
+    }
+
+    void Http3Client::GetOrCreateStreamAndSendRequest(
+        const spdy::Http2HeaderBlock *headers, absl::string_view body, bool fin)
+    {
+        std::shared_ptr<spdy::Http2HeaderBlock> spdy_headers;
+        bool hasheaders = false;
+        if (headers != nullptr)
+        {
+            spdy_headers = std::make_shared<spdy::Http2HeaderBlock>(headers->Clone());
+            hasheaders = true;
+        }
+
+        // Maybe it's better just to overload this.  it's just that we need
+        // for the GetOrCreateStream function to call something else...which
+        // is icky and complicated, but maybe not worse than this.
+        RunOnStreamMaybeCreateStream(
+            [spdy_headers, hasheaders, body, fin, this](QuicSpdyClientStream *stream)
+            {
+                if (stream == nullptr)
+                {
+                    return;
+                }
+                // QuicSpdyStreamPeer::set_ack_listener(stream, ack_listener);
+
+                size_t ret = 0;
+                if (hasheaders)
+                {
+                    if ((*spdy_headers.get())[":authority"].as_string().empty())
+                    {
+                        (*spdy_headers.get())[":authority"] = server_id_.host();
+                    }
+                    ret = stream->SendRequest(std::move(*spdy_headers.get()), body, fin);
+                    ++num_requests_;
+                }
+                else
+                {
+                    stream->WriteOrBufferBody(std::string(body), fin);
+                    ret = body.length();
+                }
+            });
+    }
+
+    void Http3Client::SendMessageAsync(const spdy::Http2HeaderBlock &headers,
+                                       absl::string_view body)
+    {
+        return SendMessageAsync(headers, body, /*fin=*/true);
+    }
+
+    void Http3Client::SendMessageAsync(const spdy::Http2HeaderBlock &headers,
+                                       absl::string_view body, bool fin)
+    {
+        // Always force creation of a stream for SendMessage.
+        latest_created_stream_ = nullptr;
+
+        GetOrCreateStreamAndSendRequest(&headers, body, fin);
+    }
+
+    bool Http3Client::response_complete() const { return response_complete_; }
+
+    int64_t Http3Client::response_body_size() const
+    {
+        return response_body_size_;
+    }
+
+    bool Http3Client::buffer_body() const { return buffer_body_; }
+
+    void Http3Client::set_buffer_body(bool buffer_body)
+    {
+        buffer_body_ = buffer_body;
+    }
+
+    const std::string &Http3Client::response_body() const { return response_; }
+
+    void Http3Client::SendConnectivityProbing()
+    {
+        QuicConnection *connection = session_->connection();
+        connection->SendConnectivityProbingPacket(connection->writer(),
+                                                  connection->peer_address());
+    }
+
+    void Http3Client::SetLatestCreatedStream(QuicSpdyClientStream *stream)
+    {
+        latest_created_stream_ = stream;
+        if (latest_created_stream_ != nullptr)
+        {
+            open_streams_[stream->id()] = stream;
+            stream->set_visitor(this);
+        }
+    }
+
+    void Http3Client::CreateClientStream(std::function<void(QuicSpdyClientStream *)> finish)
+    {
+        if (!connected())
+        {
+            finish(nullptr);
+        }
+        finish_stream_open_.push(finish);
+
+        checkSession(); // check if it is already available
+        /*
+        if (VersionHasIetfQuicFrames(session_->transport_version()))
+        {
+            // Process MAX_STREAMS from peer or wait for liveness testing succeeds.
+            while (!session_->CanOpenNextOutgoingBidirectionalStream())
+            {
+                RunEventLoop();
+            }
+        }
+        auto *stream = static_cast<QuicSpdyClientStream *>(
+            session_->CreateOutgoingBidirectionalStream());
+        if (stream)
+        {
+            stream->set_visitor(this);
+        }
+        return stream; */
+    }
+
+    void Http3Client::RunOnStreamMaybeCreateStream(std::function<void(QuicSpdyClientStream *)> finish)
+    {
+        if (!connect_attempted_ || auto_reconnect_)
+        {
+            if (!connected())
+            {
+                Connect();
+            }
+            if (!connected())
+            {
+                finish(nullptr);
+                return;
+            }
+        }
+        if (open_streams_.empty())
+        {
+            ClearPerConnectionState();
+        }
+        if (!latest_created_stream_)
+        {
+            CreateClientStream(
+                [this, finish](QuicSpdyClientStream *stream)
+                {
+                    SetLatestCreatedStream(stream);
+                    if (latest_created_stream_)
+                    {
+                        latest_created_stream_->SetPriority(priority_);
+                    }
+                    finish(latest_created_stream_);
+                });
+        }
+        else
+        {
+            finish(latest_created_stream_);
+        }
+    }
+
+    QuicErrorCode Http3Client::connection_error() const
+    {
+        // Return the high-level error if there was one.  Otherwise, return the
+        // connection error from the last session.
+        if (connection_error_ != QUIC_NO_ERROR)
+        {
+            return connection_error_;
+        }
+        if (session_ == nullptr)
+        {
+            return QUIC_NO_ERROR;
+        }
+        return session_->error();
+    }
+
+    const QuicTagValueMap &Http3Client::GetServerConfig()
+    {
+        const QuicCryptoClientConfig::CachedState *state =
+            crypto_config_.LookupOrCreate(server_id_);
+        const CryptoHandshakeMessage *handshake_msg = state->GetServerConfig();
+        return handshake_msg->tag_value_map();
+    }
+
+    bool Http3Client::connected() const
+    {
+        return session_.get() && session_->connection() &&
+               session_->connection()->connected();
+    }
+
+    bool Http3Client::clientInitialize()
+    {
+        num_sent_client_hellos_ = 0;
+        connection_error_ = QUIC_NO_ERROR;
+        connected_or_attempting_connect_ = false;
+
+        // If an initial flow control window has not explicitly been set, then use the
+        // same values that Chrome uses.
+        const uint32_t kSessionMaxRecvWindowSize = 15 * 1024 * 1024; // 15 MB
+        const uint32_t kStreamMaxRecvWindowSize = 6 * 1024 * 1024;   //  6 MB
+        if (config_.GetInitialStreamFlowControlWindowToSend() ==
+            kDefaultFlowControlSendWindow)
+        {
+            config_.SetInitialStreamFlowControlWindowToSend(kStreamMaxRecvWindowSize);
+        }
+        if (config_.GetInitialSessionFlowControlWindowToSend() ==
+            kDefaultFlowControlSendWindow)
+        {
+            config_.SetInitialSessionFlowControlWindowToSend(
+                kSessionMaxRecvWindowSize);
+        }
+
+        initialized_ = true;
+        return true;
+    }
+
+    void Http3Client::Connect()
+    {
+        if (connected())
+        {
+            QUIC_BUG(quic_bug_10133_1) << "Cannot connect already-connected client";
+            return;
+        }
+        if (!connect_attempted_)
+        {
+            clientInitialize();
+        }
+
+        // If we've been asked to override SNI, set it now
+        if (override_sni_set_)
+        {
+            // This should only be set before the initial Connect()
+            server_id_ = QuicServerId(override_sni_, address().port(), false);
+        }
+        connection_in_progress_ = true;
+        connectionrecheck_ = true;
+        wait_for_encryption_ = false;
+    }
+
+    bool Http3Client::handleConnecting()
+    {
+        bool recheck = false;
+        if (connection_in_progress_)
+        {
+            if (!wait_for_encryption_)
+            {
+                if (!connected() && num_attempts_connect_ <= QuicCryptoClientStream::kMaxClientHellos)
+                {
+                    if (!connect_attempted_)
+                    {
+                        clientInitialize();
+                    }
+                    StartConnect();
+                    wait_for_encryption_ = true;
+                }
+                else if (session_ == nullptr && num_attempts_connect_ > QuicCryptoClientStream::kMaxClientHellos)
+                {
+                    connection_in_progress_ = false;
+                    connect_attempted_ = true;
+                    QUIC_BUG(quic_bug_10906_1) << "Missing session after Connect";
+                    getJS()->processClientConnected(false);
+                }
+            }
+            if (wait_for_encryption_)
+            {
+                if (EncryptionBeingEstablished())
+                    return false;
+                wait_for_encryption_ = false;
+                ParsedQuicVersion version = UnsupportedQuicVersion();
+                if (session_ != nullptr && !CanReconnectWithDifferentVersion(&version) && !session_->connection()->connected())
+                {
+                    // We've successfully created a session but we're not connected, and we
+                    // cannot reconnect with a different version.  Give up trying.
+                    connection_in_progress_ = false;
+                    connect_attempted_ = true;
+                    getJS()->processClientConnected(false);
+                }
+                else if (session_ != nullptr && session_->connection()->connected())
+                {
+                    connect_attempted_ = true;
+                    connection_in_progress_ = false;
+                    getJS()->processClientConnected(true);
+                    webtransport_server_support_inform_ = true;
+                    recheck = true;
+                }
+                else
+                {
+                    num_attempts_connect_++;
+                    recheck = true;
+                }
+            }
+        }
+        if (webtransport_server_support_inform_ && connected())
+        {
+            if (session_->SupportsWebTransport())
+            {
+                getJS()->processClientWebtransportSupport();
+                webtransport_server_support_inform_ = false;
+            }
+            else
+                recheck = true;
+        }
+
+        if (checkSession())
+        {
+            recheck = true;
+        }
+
+        return recheck;
+    }
+
+    bool Http3Client::checkSession()
+    {
+        while (finish_stream_open_.size() > 0 && session_->CanOpenNextOutgoingBidirectionalStream())
+        {
+            auto *stream = static_cast<QuicSpdyClientStream *>(
+                session_->CreateOutgoingBidirectionalStream());
+            if (stream)
+            {
+                stream->set_visitor(this);
+            }
+            finish_stream_open_.front()(stream);
+            if (stream != nullptr)
+            {
+                if (stream->web_transport() != nullptr)
+                {
+                    WebTransportSessionId id = stream->id();
+                    WebTransportHttp3 *wtsession = session_->GetWebTransportSession(id);
+                    if (wtsession == nullptr)
+                    {
+                        getJS()->processNewClientSession(nullptr);
+                        // may be throw error
+                    }
+                    else
+                    {
+                        // ok we have our session, do we wait for session ready, no set visitor immediatele
+                        Http3WTSession *wtsessionobj =
+                            new Http3WTSession();
+                        wtsessionobj->init(
+                            static_cast<WebTransportSession *>(wtsession));
+                        getJS()->processNewClientSession(wtsessionobj);
+                        auto visitor = std::make_unique<Http3WTSession::Visitor>(wtsessionobj);
+                        wtsession->SetVisitor(std::move(visitor));
+                    }
+                }
+            }
+            finish_stream_open_.pop();
+        }
+
+        return finish_stream_open_.size() > 0;
+    }
+
+    void Http3Client::openWTSessionInt(absl::string_view path)
+    {
+        spdy::Http2HeaderBlock headers;
+        headers[":scheme"] = "https";
+        headers[":authority"] = "localhost";
+        headers[":path"] = path;
+        headers[":method"] = "CONNECT";
+        headers[":protocol"] = "webtransport";
+
+        SendMessageAsync(headers, "", /*fin=*/false);
+    }
+
+    void Http3Client::StartConnect()
+    {
+        QUICHE_DCHECK(initialized_);
+        QUICHE_DCHECK(!connected());
+        QuicPacketWriter *writer = new SocketJSWriter(getJS());
+        ParsedQuicVersion mutual_version = UnsupportedQuicVersion();
+        const bool can_reconnect_with_different_version =
+            CanReconnectWithDifferentVersion(&mutual_version);
+        if (connected_or_attempting_connect_)
+        {
+            // Clear queued up data if client can not try to connect with a different
+            // version.
+            if (!can_reconnect_with_different_version)
+            {
+                ClearDataToResend();
+            }
+            // Before we destroy the last session and create a new one, gather its stats
+            // and update the stats for the overall connection.
+            // no stats for me!
+            // UpdateStats();
+        }
+        QuicConnectionId newconnid = QuicUtils::CreateRandomConnectionId(server_connection_id_length_);
+
+        const quic::ParsedQuicVersionVector client_supported_versions =
+            can_reconnect_with_different_version
+                ? ParsedQuicVersionVector{mutual_version}
+                : supported_versions_;
+
+        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, connection_id_generator_),
+            server_id_, &crypto_config_,
+            false /*drop_response_body_*/, true /* enable_web_transport */);
+
+        if (can_reconnect_with_different_version)
+        {
+            session_->set_client_original_supported_versions(supported_versions_);
+        }
+        if (connection_debug_visitor_ != nullptr)
+        {
+            session_->connection()->set_debug_visitor(connection_debug_visitor_);
+        }
+        session_->connection()->set_client_connection_id(
+            QuicUtils::CreateRandomConnectionId(client_connection_id_length_));
+        if (initial_max_packet_length_ != 0)
+        {
+            session_->connection()->SetMaxPacketLength(initial_max_packet_length_);
+        }
+        // Reset |writer()| after |session()| so that the old writer outlives the old
+        // session.
+        if (writer_.get() != writer)
+        {
+            writer_.reset(writer);
+        }
+        // set_writer(writer);
+        InitializeSession();
+        if (can_reconnect_with_different_version)
+        {
+            // This is a reconnect using server supported |mutual_version|.
+            session_->connection()->SetVersionNegotiated();
+        }
+        connected_or_attempting_connect_ = true;
+    }
+
+    void Http3Client::InitializeSession()
+    {
+        if (max_inbound_header_list_size_ > 0)
+        {
+            session_->set_max_inbound_header_list_size(
+                max_inbound_header_list_size_);
+        }
+        session_->Initialize();
+        session_->CryptoConnect();
+    }
+
+    bool Http3Client::CanReconnectWithDifferentVersion(
+        ParsedQuicVersion *version) const
+    {
+        if (session_ == nullptr || session_->connection() == nullptr ||
+            session_->error() != QUIC_INVALID_VERSION)
+        {
+            return false;
+        }
+
+        const auto &server_supported_versions =
+            session_->connection()->server_supported_versions();
+        if (server_supported_versions.empty())
+        {
+            return false;
+        }
+
+        for (const auto &client_version : supported_versions_)
+        {
+            if (std::find(server_supported_versions.begin(),
+                          server_supported_versions.end(),
+                          client_version) != server_supported_versions.end())
+            {
+                *version = client_version;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool Http3Client::EncryptionBeingEstablished()
+    {
+        return !session_->IsEncryptionEstablished() &&
+               session_->connection()->connected();
+    }
+
+    bool Http3Client::HasActiveRequests()
+    {
+        return session_->HasActiveRequestStreams();
+    }
+
+    void Http3Client::ClearPerRequestState()
+    {
+        stream_error_ = QUIC_STREAM_NO_ERROR;
+        response_ = "";
+        response_complete_ = false;
+        response_headers_complete_ = false;
+        response_headers_.clear();
+        response_trailers_.clear();
+        bytes_read_ = 0;
+        bytes_written_ = 0;
+        response_body_size_ = 0;
+    }
+
+    void Http3Client::ClearDataToResend()
+    {
+        data_to_resend_on_connect_.clear();
+    }
+
+    bool Http3Client::HaveActiveStream()
+    {
+        return !open_streams_.empty();
+    }
+
+    void Http3ClientJS::recvPaket(const Napi::CallbackInfo &info)
+    {
+        QuicTime now = QuicDefaultClock::Get()->Now();
+        // Got a packet replace OnSocketEvent for readable
+        if (info[0].IsUndefined())
+        {
+            Napi::Error::New(Env(), "No obj passed to recvPaket").ThrowAsJavaScriptException();
+        }
+        Napi::Object lobj = info[0].ToObject();
+        if (lobj.IsEmpty())
+        {
+            Napi::Error::New(Env(), "Obj for recvPaket is empty").ThrowAsJavaScriptException();
+        }
+        if (!lobj.Has("selfaddress"))
+        {
+            Napi::Error::New(Env(), "No Selfaddress for recvPaket").ThrowAsJavaScriptException();
+        }
+        Napi::Object selfaddress = (lobj).Get("selfaddress").As<Napi::Object>();
+        if (selfaddress.IsEmpty())
+        {
+            Napi::Error::New(Env(), "Selfaddress for recvPaket empty").ThrowAsJavaScriptException();
+        }
+        int port = selfaddress.Get("port").As<Napi::Number>().Int32Value();
+        std::string selfipaddress = selfaddress.Get("address").As<Napi::String>();
+
+        QuicIpAddress self_ip;
+        self_ip.FromString(selfipaddress);
+        QuicSocketAddress self_address(self_ip, port);
+
+        if (!lobj.Has("rinfo"))
+        {
+            Napi::Error::New(Env(), "No rinfo for recvPaket").ThrowAsJavaScriptException();
+        }
+
+        Napi::Object rinfo = (lobj).Get("rinfo").As<Napi::Object>();
+        if (rinfo.IsEmpty())
+        {
+            Napi::Error::New(Env(), "Rinfo for recvPaket empty").ThrowAsJavaScriptException();
+        }
+        int peerport = rinfo.Get("port").As<Napi::Number>().Int32Value();
+        std::string peeripaddress = rinfo.Get("address").As<Napi::String>();
+
+        QuicIpAddress peer_ip;
+        peer_ip.FromString(peeripaddress);
+        QuicSocketAddress peer_address(peer_ip, peerport);
+
+        Napi::Object bufferlocal = lobj.Get("msg").As<Napi::Object>();
+
+        QuicReceivedPacket packet(
+            bufferlocal.As<Napi::Buffer<char>>().Data(), rinfo.Get("size").As<Napi::Number>().Uint32Value(), now,
+            /*owns_buffer=*/false, 0 /*ttl*/, false /*has_ttl*/, nullptr /*headers*/, 0 /*headers_length*/,
+            /*owns_header_buffer=*/false, ECN_NOT_ECT);
+
+        client_->ProcessPacket(self_address, peer_address, packet);
+
+        if (client_->connectionrecheck_)
+        {
+            client_->connectionrecheck_ = !client_->handleConnecting();
+        }
+    }
+
+    void Http3ClientJS::onCanWrite(const Napi::CallbackInfo &info)
+    {
+        if (client_->connectionrecheck_)
+        {
+            client_->connectionrecheck_ = !client_->handleConnecting();
+        }
+        client_->OnCanWrite();
+    }
+
+    void Http3Client::OnCanWrite()
+    {
+        writer_->SetWritable();
+        if (connected())
+        {
+            session_->connection()->OnCanWrite();
+        }
+    }
+
+/*
+    void Http3Client::OnSocketEvent(QuicEventLoop *event_loop, QuicUdpSocketFd fd,
+                                    QuicSocketEventMask events)
+    {
+        /*if (events & kSocketEventReadable)
+        {
+            QUIC_DVLOG(1) << "Read packets on kSocketEventReadable";
+            int times_to_read = max_reads_per_loop_;
+            bool more_to_read = true;
+            QuicPacketCount packets_dropped = 0;
+            while (connected() && more_to_read && times_to_read > 0)
+            {
+                more_to_read = packet_reader_->ReadAndDispatchPackets(
+                    fd, GetLatestClientAddress().port(), *helper_->GetClock(),
+                    this, overflow_supported_ ? &packets_dropped : nullptr);
+                --times_to_read;
+            }
+            if (packets_dropped_ < packets_dropped)
+            {
+                QUIC_LOG(ERROR)
+                    << packets_dropped - packets_dropped_
+                    << " more packets are dropped in the socket receive buffer.";
+                packets_dropped_ = packets_dropped;
+            }
+            if (connected() && more_to_read)
+            {
+                // Register EPOLLIN event to consume buffered CHLO(s).
+                bool success =
+                    event_loop->ArtificiallyNotifyEvent(fd, kSocketEventReadable);
+                QUICHE_DCHECK(success);
+            }
+            else if (!event_loop->SupportsEdgeTriggered())
+            {
+                bool success = event_loop->RearmSocket(fd, kSocketEventReadable);
+                QUICHE_DCHECK(success);
+            }
+        }*/
+        /*if (connected() && (events & kSocketEventWritable))
+        {
+            writer_->SetWritable();
+            session_->connection()->OnCanWrite();
+        }
+
+        if (handleConnecting())
+        {
+            bool success =
+                event_loop->ArtificiallyNotifyEvent(fd, kSocketEventReadable);
+            QUICHE_DCHECK(success);
+        }
+    }*/
+
+    void Http3Client::ProcessPacket(
+        const QuicSocketAddress &self_address,
+        const QuicSocketAddress &peer_address, const QuicReceivedPacket &packet)
+    {
+        if (connected()) session_->ProcessUdpPacket(self_address, peer_address, packet);
+    }
+
+    bool Http3Client::response_headers_complete() const
+    {
+        for (std::pair<QuicStreamId, QuicSpdyClientStream *> stream : open_streams_)
+        {
+            if (stream.second->headers_decompressed())
+            {
+                return true;
+            }
+        }
+        return response_headers_complete_;
+    }
+
+    const spdy::Http2HeaderBlock *Http3Client::response_headers() const
+    {
+        for (std::pair<QuicStreamId, QuicSpdyClientStream *> stream : open_streams_)
+        {
+            if (stream.second->headers_decompressed())
+            {
+                response_headers_ = stream.second->response_headers().Clone();
+                break;
+            }
+        }
+        return &response_headers_;
+    }
+
+    const spdy::Http2HeaderBlock &Http3Client::response_trailers() const
+    {
+        return response_trailers_;
+    }
+
+    int64_t Http3Client::response_size() const { return bytes_read(); }
+
+    size_t Http3Client::bytes_read() const
+    {
+        for (std::pair<QuicStreamId, QuicSpdyClientStream *> stream : open_streams_)
+        {
+            size_t bytes_read = stream.second->total_body_bytes_read() +
+                                stream.second->header_bytes_read();
+            if (bytes_read > 0)
+            {
+                return bytes_read;
+            }
+        }
+        return bytes_read_;
+    }
+
+    size_t Http3Client::bytes_written() const
+    {
+        for (std::pair<QuicStreamId, QuicSpdyClientStream *> stream : open_streams_)
+        {
+            size_t bytes_written = stream.second->stream_bytes_written() +
+                                   stream.second->header_bytes_written();
+            if (bytes_written > 0)
+            {
+                return bytes_written;
+            }
+        }
+        return bytes_written_;
+    }
+
+    void Http3Client::OnCompleteResponse(
+        QuicStreamId id, const spdy::Http2HeaderBlock &response_headers,
+        const absl::string_view &response_body)
+    {
+        // implement
+    }
+
+    void Http3Client::OnClose(QuicSpdyStream *stream)
+    {
+        if (stream == nullptr)
+        {
+            return;
+        }
+        // Always close the stream, regardless of whether it was the last stream
+        // written.
+        QUICHE_DCHECK(stream != nullptr);
+        QuicSpdyClientStream *client_stream =
+            static_cast<QuicSpdyClientStream *>(stream);
+
+        const Http2HeaderBlock &response_headers = client_stream->response_headers();
+
+        OnCompleteResponse(stream->id(), response_headers, client_stream->data());
+
+        // Store response headers and body.
+        if (store_response_)
+        {
+            auto status = response_headers.find(":status");
+            if (status == response_headers.end())
+            {
+                QUIC_LOG(ERROR) << "Missing :status response header";
+            }
+            else if (!absl::SimpleAtoi(status->second, &latest_response_code_))
+            {
+                QUIC_LOG(ERROR) << "Invalid :status response header: " << status->second;
+            }
+            latest_response_headers_ = response_headers.DebugString();
+            for (const Http2HeaderBlock &headers :
+                 client_stream->preliminary_headers())
+            {
+                absl::StrAppend(&preliminary_response_headers_, headers.DebugString());
+            }
+            latest_response_header_block_ = response_headers.Clone();
+            latest_response_body_ = client_stream->data();
+            latest_response_trailers_ =
+                client_stream->received_trailers().DebugString();
+        }
+        ++num_responses_;
+        if (open_streams_.find(stream->id()) == open_streams_.end())
+        {
+            return;
+        }
+        if (latest_created_stream_ == stream)
+        {
+            latest_created_stream_ = nullptr;
+        }
+
+        QuicStreamId id = client_stream->id();
+        closed_stream_states_.insert(std::make_pair(
+            id,
+            PerStreamState(
+                // Set response_complete to true iff stream is closed while connected.
+                client_stream->stream_error(), connected(),
+                client_stream->headers_decompressed(),
+                client_stream->response_headers(),
+                (buffer_body() ? client_stream->data() : ""),
+                client_stream->received_trailers(),
+                // Use NumBytesConsumed to avoid counting retransmitted stream frames.
+                client_stream->total_body_bytes_read() +
+                    client_stream->header_bytes_read(),
+                client_stream->stream_bytes_written() +
+                    client_stream->header_bytes_written(),
+                client_stream->data().size())));
+        open_streams_.erase(id);
+    }
+
+    const QuicSocketAddress &Http3Client::address() const
+    {
+        return server_address_;
+    }
+
+    Http3Client::Http3ClientDataToResend::Http3ClientDataToResend(
+        std::unique_ptr<spdy::Http2HeaderBlock> headers, absl::string_view body,
+        bool fin, Http3Client *client)
+        : headers_(std::move(headers)), body_(body), fin_(fin),
+          client_(client) {}
+
+    Http3Client::Http3ClientDataToResend::~Http3ClientDataToResend() = default;
+
+    void Http3Client::Http3ClientDataToResend::Resend()
+    {
+        client_->GetOrCreateStreamAndSendRequest(headers_.get(), body_, fin_);
+        headers_.reset();
+    }
+
+    Http3Client::PerStreamState::PerStreamState(const PerStreamState &other)
+        : stream_error(other.stream_error),
+          response_complete(other.response_complete),
+          response_headers_complete(other.response_headers_complete),
+          response_headers(other.response_headers.Clone()),
+          response(other.response),
+          response_trailers(other.response_trailers.Clone()),
+          bytes_read(other.bytes_read),
+          bytes_written(other.bytes_written),
+          response_body_size(other.response_body_size) {}
+
+    Http3Client::PerStreamState::PerStreamState(
+        QuicRstStreamErrorCode stream_error, bool response_complete,
+        bool response_headers_complete,
+        const spdy::Http2HeaderBlock &response_headers,
+        const absl::string_view 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),
+          response_headers_complete(response_headers_complete),
+          response_headers(response_headers.Clone()),
+          response(response),
+          response_trailers(response_trailers.Clone()),
+          bytes_read(bytes_read),
+          bytes_written(bytes_written),
+          response_body_size(response_body_size) {}
+
+    Http3Client::PerStreamState::~PerStreamState() = default;
+
+    bool Http3Client::PopulateHeaderBlockFromUrl(
+        const std::string &uri, spdy::Http2HeaderBlock *headers)
+    {
+        std::string url;
+        if (absl::StartsWith(uri, "https://") || absl::StartsWith(uri, "http://"))
+        {
+            url = uri;
+        }
+        else if (uri[0] == '/')
+        {
+            url = "https://" + server_id_.host() + uri;
+        }
+        else
+        {
+            url = "https://" + uri;
+        }
+        return SpdyUtils::PopulateHeaderBlockFromUrl(url, headers);
+    }
+
+    /*
+        void Http3Client::ReadNextResponse()
+        {
+            if (closed_stream_states_.empty())
+            {
+                return;
+            }
+
+            PerStreamState state(closed_stream_states_.front().second);
+
+            stream_error_ = state.stream_error;
+            response_ = state.response;
+            response_complete_ = state.response_complete;
+            response_headers_complete_ = state.response_headers_complete;
+            response_headers_ = state.response_headers.Clone();
+            response_trailers_ = state.response_trailers.Clone();
+            bytes_read_ = state.bytes_read;
+            bytes_written_ = state.bytes_written;
+            response_body_size_ = state.response_body_size;
+
+            closed_stream_states_.pop_front();
+        }
+        */
+
+    void Http3Client::ClearPerConnectionState()
+    {
+        ClearPerRequestState();
+        open_streams_.clear();
+        closed_stream_states_.clear();
+        latest_created_stream_ = nullptr;
+    }
+
+    Http3ClientJS::Http3ClientJS(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Http3ClientJS>(info)
+    {
+        bool allowPooling = false;
+        std::vector<WebTransportHash> serverCertificateHashes;
+        std::string privkey;
+        QuicConfig cconfig;
+        auto env = info.Env();
+        if (!info[0].IsUndefined())
+        {
+            Napi::Object lobj = info[0].ToObject();
+            if (!lobj.IsEmpty())
+            {
+
+                if (lobj.Has("allowPooling") && !(lobj).Get("allowPooling").IsEmpty())
+                {
+                    Napi::Value poolValue = (lobj).Get("allowPooling");
+                    allowPooling = poolValue.As<Napi::Boolean>().Value();
+                }
+
+                if (lobj.Has("serverCertificateHashes") && !(lobj).Get("serverCertificateHashes").IsEmpty())
+                {
+                    Napi::Value hashValue = (lobj).Get("serverCertificateHashes");
+                    if (hashValue.IsArray())
+                    {
+                        Napi::Array hashArray = hashValue.As<Napi::Array>();
+                        int length = hashArray.Length();
+
+                        for (unsigned int i = 0; i < length; i++)
+                        {
+                            WebTransportHash curhash;
+                            Napi::Value hash = hashArray.Get(i);
+                            Napi::Object hashobj = hash.ToObject();
+                            if (hashobj.Has("value") && !(hashobj).Get("value").IsEmpty())
+                            {
+                                Napi::Object bufferlocal = (hashobj).Get("value").ToObject();
+                                char *buffer = bufferlocal.As<Napi::Buffer<char>>().Data();
+                                size_t len = bufferlocal.As<Napi::Buffer<char>>().Length();
+                                curhash.value = std::string(buffer, len);
+                            }
+                            else
+                            {
+                                Napi::Error::New(env, "serverCertificateHashes wrong format").ThrowAsJavaScriptException();
+                                return;
+                            }
+                            if (hashobj.Has("algorithm") && !(hashobj).Get("algorithm").IsEmpty())
+                            {
+                                Napi::Value algorithmValue = (hashobj).Get("algorithm");
+                                curhash.algorithm = algorithmValue.ToString().Utf8Value();
+                            }
+                            else
+                            {
+                                Napi::Error::New(env, "serverCertificateHashes wrong format").ThrowAsJavaScriptException();
+                                return;
+                            }
+                            if (curhash.algorithm.compare(WebTransportHash::kSha256) != 0)
+                            {
+                                Napi::Error::New(env, "serverCertificateHashes unknown algorithm").ThrowAsJavaScriptException();
+                                return;
+                            }
+                            serverCertificateHashes.push_back(curhash);
+                        }
+                    }
+                    else
+                    {
+                        Napi::Error::New(env, "serverCertificateHashes is not an array").ThrowAsJavaScriptException();
+                        return;
+                    }
+                }
+                if (lobj.Has("initialStreamFlowControlWindow") && !(lobj).Get("initialStreamFlowControlWindow").IsEmpty())
+                {
+                    Napi::Value initialStreamFlowControlWindowValue = (lobj).Get("initialStreamFlowControlWindow");
+                    int initialStreamFlowControlWindow = initialStreamFlowControlWindowValue.As<Napi::Number>().Int32Value();
+                    cconfig.SetInitialStreamFlowControlWindowToSend(initialStreamFlowControlWindow);
+                }
+
+                if (lobj.Has("initialSessionFlowControlWindow") && !(lobj).Get("initialSessionFlowControlWindow").IsEmpty())
+                {
+                    Napi::Value initialSessionFlowControlWindowValue = (lobj).Get("initialSessionFlowControlWindow");
+                    int initialSessionFlowControlWindow = initialSessionFlowControlWindowValue.As<Napi::Number>().Int32Value();
+                    cconfig.SetInitialSessionFlowControlWindowToSend(initialSessionFlowControlWindow);
+                }
+
+                if (lobj.Has("streamFlowControlWindowSizeLimit") && !(lobj).Get("streamFlowControlWindowSizeLimit").IsEmpty())
+                {
+                    Napi::Value streamFlowControlWindowSizeLimitValue = (lobj).Get("streamFlowControlWindowSizeLimit");
+                    int streamFlowControlWindowSizeLimitWindow = streamFlowControlWindowSizeLimitValue.As<Napi::Number>().Int32Value();
+                    cconfig.SetInitialMaxStreamDataBytesOutgoingBidirectionalToSend(streamFlowControlWindowSizeLimitWindow);
+                    cconfig.SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(streamFlowControlWindowSizeLimitWindow);
+                    cconfig.SetInitialMaxStreamDataBytesUnidirectionalToSend(streamFlowControlWindowSizeLimitWindow);
+                }
+            }
+        }
+
+        // Callback *callback, int port, std::unique_ptr<ProofSource> proof_source,  const char *secret
+
+        std::unique_ptr<QuicConnectionHelperInterface> helper =
+            std::make_unique<QuicDefaultConnectionHelper>();
+
+        std::unique_ptr<ProofVerifier> verifier;
+
+        if (serverCertificateHashes.size() > 0)
+        {
+            verifier = std::make_unique<ChromiumWebTransportFingerprintProofVerifier>(helper->GetClock(), 14);
+
+            for (auto cur = serverCertificateHashes.begin();
+                 cur != serverCertificateHashes.end(); cur++)
+            {
+                if (!static_cast<ChromiumWebTransportFingerprintProofVerifier*>(verifier.get())->AddFingerprint(*cur))
+                {
+                    Napi::Error::New(env, "serverCertificateHashes is not valid fingerprint").ThrowAsJavaScriptException();
+                    return;
+                }
+            }
+        }
+        else
+        {
+            verifier = std::make_unique<NodeJSProofVerifier>(this);
+        }
+
+        std::unique_ptr<Http3SessionCache> cache;
+
+        client_ = std::make_unique<Http3Client>(this, std::move(verifier), std::move(cache), std::move(helper), cconfig);
+        client_->SetUserAgentID("fails-components/webtransport");
+
+        Ref(); // do not garbage collect
+
+        client_->Connect();
+        return;
+    }
+
+    void Http3ClientJS::setHostname(const Napi::CallbackInfo &info) {
+        int port = 443;
+        std::string serveraddress;
+        std::string hostname = "localhost";
+        auto env = info.Env();
+        if (!info[0].IsUndefined())
+        {
+            Napi::Object lobj = info[0].ToObject();
+            if (!lobj.IsEmpty())
+            {
+
+               
+
+                if (lobj.Has("port") && !(lobj).Get("port").IsEmpty())
+                {
+                    Napi::Value portValue = (lobj).Get("port");
+                    port = portValue.As<Napi::Number>().Int32Value();
+                }
+                else
+                {
+                    Napi::Error::New(env, "no port specified").ThrowAsJavaScriptException();
+                    return;
+                }
+
+                if (lobj.Has("host") && !(lobj).Get("host").IsEmpty())
+                {
+                    Napi::Value hostnameValue = (lobj).Get("host");
+                    hostname = hostnameValue.ToString().Utf8Value();
+                }
+                else
+                {
+                    Napi::Error::New(env, "no hostname specified").ThrowAsJavaScriptException();
+                    return;
+                }
+
+                if (lobj.Has("serveraddress") && !(lobj).Get("serveraddress").IsEmpty())
+                {
+                    Napi::Value serveraddressValue = (lobj).Get("serveraddress");
+                    serveraddress = serveraddressValue.ToString().Utf8Value();
+                }
+                else
+                {
+                    Napi::Error::New(env, "no serveraddress specified").ThrowAsJavaScriptException();
+                    return;
+                }
+            }
+        }
+
+        QuicIpAddress server_ip;
+        server_ip.FromString(serveraddress);
+        QuicSocketAddress address(server_ip, port);
+
+        client_ ->setHostname(address, hostname);                            
+    }
+
+    void Http3ClientJS::openWTSession(const Napi::CallbackInfo &info)
+    {
+        Http3Client *obj = getObj();
+        // got the object we can now start the server
+
+        if (!info[0].IsUndefined())
+        {
+            std::string lpath(info[0].ToString().Utf8Value());
+
+            obj->openWTSessionInt(lpath);
+        }
+        else
+        {
+            Napi::Error::New(info.Env(), "openWTSession without path").ThrowAsJavaScriptException();
+            return;
+        }
+    }
+
+    void Http3ClientJS::closeClient(const Napi::CallbackInfo &info)
+    {
+        Http3Client *obj = getObj();
+        // got the object we can now start the server
+
+        if (!obj->closeClientInt())
+        {
+            printf("closeClientInt failed for Http3Client");
+            return;
+        }
+    }
+
+    void Http3ClientJS::processClientConnected(bool success)
+    {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+        Napi::Object retObj = Napi::Object::New(Env());
+        retObj.Set("success", success);
+
+        objVal.Get("onClientConnected")
+            .As<Napi::Function>()
+            .Call(objVal, {retObj.As<Napi::Value>()});
+    }
+
+    void Http3ClientJS::processClientWebtransportSupport()
+    {
+        Napi::HandleScope scope(Env());
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+        Napi::Object retObj = Napi::Object::New(Env());
+
+        objVal.Get("onClientWebTransportSupport")
+            .As<Napi::Function>()
+            .Call(objVal, {retObj});
+    }
+
+    void Http3ClientJS::processNewClientSession(Http3WTSession *session)
+    {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        if (session != nullptr)
+        {
+            Http3Constructors *constr = Env().GetInstanceData<Http3Constructors>();
+            Napi::Object sessionobj = constr->session.New({});
+            Http3WTSessionJS *sessionjs = Napi::ObjectWrap<Http3WTSessionJS>::Unwrap(sessionobj);
+            sessionjs->setObj(session);
+            sessionjs->Ref();
+            session->setJS(sessionjs);
+            Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+            retObj.Set("session", sessionobj);
+            objVal.Get("onHttpWTSessionVisitor")
+                .As<Napi::Function>()
+                .Call(objVal, {retObj});
+        }
+    }
+
+} // namespace quic