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

package/src/http3sessioncache.h

@@ -0,0 +1,59 @@
+// modifications
+// 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.
+
+// original copyright, see LICENSE.chromium
+// Copyright (c) 2019 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.
+
+
+#ifndef HTTP3_SESSION_CACHE_H
+#define HTTP3_SESSION_CACHE_H
+
+#include <memory>
+
+#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
+#include "quiche/quic/core/crypto/transport_parameters.h"
+
+namespace quic {
+
+// Http3SessionCache provides a simple implementation of SessionCache that
+// stores only one QuicResumptionState per QuicServerId. No limit is placed on
+// the total number of entries in the cache. When Lookup is called, if a cache
+// entry exists for the provided QuicServerId, the entry will be removed from
+// the cached when it is returned.
+// TODO(fayang): Remove Http3SessionCache by using QuicClientSessionCache.
+class Http3SessionCache : public SessionCache {
+ public:
+  Http3SessionCache() = default;
+  ~Http3SessionCache() override = default;
+
+  void Insert(const QuicServerId& server_id,
+              bssl::UniquePtr<SSL_SESSION> session,
+              const TransportParameters& params,
+              const ApplicationState* application_state) override;
+  std::unique_ptr<QuicResumptionState> Lookup(const QuicServerId& server_id,
+                                              QuicWallTime now,
+                                              const SSL_CTX* ctx) override;
+  void ClearEarlyData(const QuicServerId& server_id) override;
+  void OnNewTokenReceived(const QuicServerId& server_id,
+                          absl::string_view token) override;
+  void RemoveExpiredEntries(QuicWallTime now) override;
+  void Clear() override;
+
+ private:
+  struct Entry {
+    bssl::UniquePtr<SSL_SESSION> session;
+    std::unique_ptr<TransportParameters> params;
+    std::unique_ptr<ApplicationState> application_state;
+    std::string token;
+  };
+  std::map<QuicServerId, Entry> cache_entries_;
+};
+
+
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_CACHE_H_

package/src/http3wtsessionvisitor.cc

@@ -0,0 +1,312 @@
+// 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.
+
+#include "src/http3wtsessionvisitor.h"
+
+namespace quic
+{
+
+    Http3WTSession::Visitor::~Visitor()
+    {
+        // printf("~Visitor %d %x %x\n", getpid(), this, session_);
+        Http3WTSessionJS *sessobj = session_->getJS();
+        if (sessobj) {
+            session_->getJS()->Unref();
+        } else
+            delete session_;
+        session_ = nullptr;
+    }
+
+    void Http3WTSession::Visitor::OnSessionClosed(WebTransportSessionError error_code,
+                                                const std::string &error_message)
+    {
+        // printf("OnSessionClosed %d %x %x\n", getpid(), this, session_);
+        session_->session_ = nullptr;
+        session_->getJS()->processSessionClose(error_code, error_message);
+    }
+                        
+
+    void Http3WTSession::Visitor::OnIncomingBidirectionalStreamAvailable()
+    {
+        if (!session_->session_)
+            return;
+        while (true)
+        {
+            WebTransportStream *stream =
+                session_->session_->AcceptIncomingBidirectionalStream();
+            if (stream == nullptr)
+            {
+                return;
+            }
+            Http3WTStream *wtstream = new Http3WTStream(stream);
+            QUIC_DVLOG(1)
+                << "Http3WTSession received a bidirectional stream "
+                << stream->GetStreamId();
+            stream->SetVisitor(
+                std::make_unique<Http3WTStream::Visitor>(wtstream));
+            session_->getJS()->processStream(true, true, static_cast<Http3WTStream *>(wtstream));
+            stream->visitor()->OnCanRead();
+        }
+    }
+
+    void Http3WTSession::Visitor::OnIncomingUnidirectionalStreamAvailable()
+    {
+        if (!session_->session_)
+            return;
+        while (true)
+        {
+            WebTransportStream *stream =
+                session_->session_->AcceptIncomingUnidirectionalStream();
+            if (stream == nullptr)
+            {
+                return;
+            }
+            Http3WTStream *wtstream = new Http3WTStream(stream);
+            QUIC_DVLOG(1)
+                << "Http3WTSession received a unidirectional stream";
+            stream->SetVisitor(
+                std::make_unique<Http3WTStream::Visitor>(wtstream));
+            session_->getJS()->processStream(true, false, static_cast<Http3WTStream *>(wtstream));
+            stream->visitor()->OnCanRead();
+        }
+    }
+
+    void Http3WTSession::Visitor::OnDatagramReceived(absl::string_view datagram)
+    {
+        // printf("OnDatagramReceived %d %x %x\n", getpid(), this, session_);
+        session_->getJS()->processDatagramReceived(new std::string(datagram));
+        /*auto buffer = MakeUniqueBuffer(&allocator_, datagram.size());
+        memcpy(buffer.get(), datagram.data(), datagram.size());
+        quiche::QuicheMemSlice slice(std::move(buffer), datagram.size());
+        session_->SendOrQueueDatagram(std::move(slice));*/
+    }
+
+    void Http3WTSession::init(WebTransportSession *session)
+    {
+        session_ = session;
+        if (session_)
+        {
+            session_->SetOnDraining([this]()
+                                    { getJS()->processGoawayReceived(); });
+        }
+    }
+
+    void Http3WTSession::orderSessionStatsInt()
+    {
+        if (session_)
+            getJS()->processSessionStats(session_->GetSessionStats());
+    }
+
+    void Http3WTSession::orderDatagramStatsInt()
+    {
+        if (session_)
+            getJS()->processDatagramStats(session_->GetDatagramStats());
+    }
+
+    void Http3WTSession::TrySendingBidirectionalStreams()
+    {
+        if (!session_)
+            return;
+        while (ordBidiStreams > 0 &&
+               session_->CanOpenNextOutgoingBidirectionalStream())
+        {
+            QUIC_DVLOG(1)
+                << "Http3WTSessionVisitor opens a bidirectional stream";
+            WebTransportStream *stream = session_->OpenOutgoingBidirectionalStream();
+            Http3WTStream *wtstream = new Http3WTStream(stream);
+            stream->SetVisitor(
+                std::make_unique<Http3WTStream::Visitor>(wtstream));
+            getJS()->processStream(false, true, static_cast<Http3WTStream *>(wtstream));
+            stream->visitor()->OnCanWrite();
+            ordBidiStreams--;
+        }
+    }
+
+    void Http3WTSession::Visitor::OnSessionReady()
+    {
+        if (!session_->session_) return;
+
+        session_->getJS()->processSessionReady();
+
+        if (session_->session_->CanOpenNextOutgoingBidirectionalStream())
+        {
+            OnCanCreateNewOutgoingBidirectionalStream();
+        }
+        if (session_->session_->CanOpenNextOutgoingUnidirectionalStream())
+        {
+            OnCanCreateNewOutgoingUnidirectionalStream();
+        }
+    }
+
+    void Http3WTSession::TrySendingUnidirectionalStreams()
+    {
+        if (!session_)
+            return;
+        // move to some where else?
+        while (ordUnidiStreams > 0 &&
+               session_->CanOpenNextOutgoingUnidirectionalStream())
+        {
+            QUIC_DVLOG(1)
+                << "Http3WTSessionVisitor opened a unidirectional stream";
+            WebTransportStream *stream = session_->OpenOutgoingUnidirectionalStream();
+            Http3WTStream *wtstream = new Http3WTStream(stream);
+            stream->SetVisitor(
+                std::make_unique<Http3WTStream::Visitor>(wtstream));
+
+            getJS()->processStream(false, false, static_cast<Http3WTStream *>(wtstream));
+            stream->visitor()->OnCanWrite();
+            ordUnidiStreams--;
+        }
+    }
+
+    void Http3WTSession::writeDatagramInt(char *buffer, size_t len, Napi::ObjectReference *bufferhandle)
+    {
+        // printf("Datagram write %d %x %x\n", getpid(), this, session_ );
+        if (!session_)
+        {
+            // printf("Datagram session gone %d %x %x\n", getpid(), this, session_);
+            getJS()->processDatagramSend(bufferhandle);
+            return;
+        }
+        auto status = session_->SendOrQueueDatagram(absl::string_view(buffer, len));
+        // printf("Datagram status %d %d %s %x %x\n", getpid(), status.code, status.error_message.c_str(), this, session_);
+        getJS()->processDatagramSend(bufferhandle);
+    }
+
+    void Http3WTSessionJS::processStream(bool incom, bool bidi, Http3WTStream *stream)
+    {
+        Napi::HandleScope scope(Env());
+        Http3Constructors *constr = Env().GetInstanceData<Http3Constructors>();
+        Napi::Object strobj = constr->stream.New({});
+        Http3WTStreamJS *strjs = Napi::ObjectWrap<Http3WTStreamJS>::Unwrap(strobj);
+        strjs->setObj(stream);
+        if (!stream->gone())
+            strjs->Ref();
+
+        stream->setJS(strjs);
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        retObj.Set("stream", strobj);
+        retObj.Set("incoming", incom);
+        retObj.Set("bidirectional", bidi);
+
+        objVal.Get("onStream").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTSessionJS::processGoawayReceived()
+    {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        objVal.Get("onGoAwayReceived").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTSessionJS::processSessionStats(webtransport::SessionStats sessstats)
+    {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        //  expiredOutgoing: bigint
+        // lostOutgoing: bigint
+
+        // non Datagram
+        //  minRtt: number
+        //  smoothedRtt: number
+        //  rttVariation: number
+        // estimatedSendRateBps: bigint
+        retObj.Set("timestamp", absl::ToDoubleMilliseconds(absl::Duration())); // absl::Duration
+        // datagram
+        retObj.Set("expiredOutgoing", Napi::BigInt::New(Env(), sessstats.datagram_stats.expired_outgoing)); // uint64_t
+        retObj.Set("lostOutgoing", Napi::BigInt::New(Env(), sessstats.datagram_stats.lost_outgoing));       // uint64_t
+
+        // non Datagram
+        retObj.Set("minRtt", absl::ToDoubleMilliseconds(sessstats.min_rtt));             // absl::Duration
+        retObj.Set("smoothedRtt", absl::ToDoubleMilliseconds(sessstats.smoothed_rtt));   // absl::Duration
+        retObj.Set("rttVariation", absl::ToDoubleMilliseconds(sessstats.rtt_variation)); // absl::Duration
+        retObj.Set("estimatedSendRateBps", sessstats.estimated_send_rate_bps);           // absl::Duration
+
+        objVal.Get("onSessionStats").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTSessionJS::processDatagramStats(webtransport::DatagramStats datastats)
+    {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        retObj.Set("timestamp", absl::ToDoubleMilliseconds(absl::Duration())); // absl::Duration
+        // datagram
+        retObj.Set("expiredOutgoing", Napi::BigInt::New(Env(), datastats.expired_outgoing)); // uint64_t
+        retObj.Set("lostOutgoing", Napi::BigInt::New(Env(), datastats.lost_outgoing));       // uint64_t
+
+        objVal.Get("onDatagramStats").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTSessionJS::processDatagramSend(Napi::ObjectReference *bufferhandle)
+    {
+        bufferhandle->Unref(); // release the outgoing buffer
+        delete bufferhandle;   // free the handle object
+
+        Napi::HandleScope scope(Env());
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        Napi::Object retObj = Napi::Object::New(Env());
+
+        objVal.Get("onDatagramSend").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTSessionJS::processSessionReady()
+    {
+        Napi::HandleScope scope(Env());
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        Napi::Object retObj = Napi::Object::New(Env());
+
+        objVal.Get("onReady").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTSessionJS::processSessionClose(uint32_t errorcode, const std::string &error)
+    {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        retObj.Set("error", error);
+        retObj.Set("errorcode", errorcode);
+
+        objVal.Get("onClose").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTSessionJS::processDatagramReceived(std::string *datagram)
+    {
+        Napi::HandleScope scope(Env());
+        Napi::Object datagramVal =
+            Napi::Uint8Array::New(Env(),
+                                  datagram->length(),
+                                  Napi::ArrayBuffer::New(Env(), &(*datagram)[0], datagram->length(),
+                                                         freeData, datagram),
+                                  0);
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        retObj.Set("datagram", datagramVal);
+
+        objVal.Get("onDatagramReceived").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTSessionJS::freeData(Napi::Env env, void *data, std::string *hint)
+    {
+        // ok free data is actually using a string object
+        delete hint;
+    }
+}

package/src/http3wtsessionvisitor.h

@@ -0,0 +1,257 @@
+// modifications
+// 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.
+
+// original copyright, see LICENSE.chromium
+// Copyright (c) 2021 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.
+
+#ifndef HTTP3_WT_SESSION_VISITOR_H_
+#define HTTP3_WT_SESSION_VISITOR_H_
+
+#include <napi.h>
+
+#include <atomic>
+
+#include <string>
+
+#include "src/librarymain.h"
+#include "src/http3wtstreamvisitor.h"
+#include "src/http3wtsessionvisitor.h"
+
+#include "quiche/quic/core/web_transport_interface.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/quiche_circular_deque.h"
+#include "quiche/common/platform/api/quiche_mem_slice.h"
+
+namespace quic
+{
+    // class Http3Server;
+    class Http3WTSessionJS;
+
+    class Http3WTSession
+    {
+        friend Http3WTSessionJS;
+
+    public:
+        Http3WTSession()
+            : ordBidiStreams(0), ordUnidiStreams(0), session_(nullptr), js_(nullptr)
+        {
+        }
+
+        ~Http3WTSession()
+        {
+            // printf("session destruct %x\n", this);
+        }
+
+        // need to be called immediately after new
+        void init(WebTransportSession *session);
+
+        class Visitor : public WebTransportVisitor
+        {
+        public:
+            Visitor(Http3WTSession *session) : session_(session) {}
+
+            ~Visitor();
+
+            void OnSessionReady() override;
+
+            void OnSessionClosed(WebTransportSessionError error_code,
+                                 const std::string &error_message) override;
+
+            void OnIncomingBidirectionalStreamAvailable() override;
+
+            void OnIncomingUnidirectionalStreamAvailable() override;
+
+            void OnDatagramReceived(absl::string_view datagram) override;
+
+            void OnCanCreateNewOutgoingBidirectionalStream() override
+            {
+                // unclear how we can stich this together?
+                session_->TrySendingBidirectionalStreams();
+            }
+
+            void OnCanCreateNewOutgoingUnidirectionalStream() override
+            {
+                session_->TrySendingUnidirectionalStreams();
+            }
+
+        protected:
+            Http3WTSession *session_;
+        };
+
+        void
+        tryOpenBidiStream()
+        {
+            ordBidiStreams++;
+            TrySendingBidirectionalStreams();
+        }
+
+        void tryOpenUnidiStream()
+        {
+            ordUnidiStreams++;
+            TrySendingUnidirectionalStreams();
+        }
+
+        void TrySendingBidirectionalStreams();
+
+        void TrySendingUnidirectionalStreams();
+
+        Http3WTSessionJS *getJS() { return js_; };
+        void setJS(Http3WTSessionJS *js)
+        {
+            js_ = js;
+        };
+
+    private:
+        Http3WTSessionJS *js_;
+
+        void notifySessionDrainingInt()
+        {
+            if (session_)
+                session_->NotifySessionDraining();
+        }
+
+        void orderSessionStatsInt();
+
+        void orderDatagramStatsInt();
+
+        void closeInt(int code, std::string &reason)
+        {
+            if (session_)
+                session_->CloseSession(code, reason);
+        }
+
+        void writeDatagramInt(char *buffer, size_t len, Napi::ObjectReference *bufferhandle);
+
+        WebTransportSession *session_;
+        bool echo_stream_opened_ = false;
+        uint32_t ordBidiStreams;
+        uint32_t ordUnidiStreams;
+    };
+
+    class Http3WTSessionJS : public Napi::ObjectWrap<Http3WTSessionJS>
+    {
+        friend class Http3WTSession;
+        friend class Http3WTSession::Visitor;
+
+    public:
+        Http3WTSessionJS(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Http3WTSessionJS>(info)
+        {
+        }
+
+        void setObj(Http3WTSession *wtsession)
+        {
+            wtsession_ = std::unique_ptr<Http3WTSession>(wtsession);
+        }
+
+        Http3WTSession *getObj()
+        {
+            return wtsession_.get();
+        }
+
+        void orderBidiStream(const Napi::CallbackInfo &info)
+        {
+            wtsession_->tryOpenBidiStream();
+        }
+
+        void orderUnidiStream(const Napi::CallbackInfo &info)
+        {
+            wtsession_->tryOpenUnidiStream();
+        }
+
+        void writeDatagram(const Napi::CallbackInfo &info)
+        {
+            if (!info[0].IsUndefined())
+            {
+                Napi::Object bufferlocal = info[0].ToObject();
+                Napi::ObjectReference *bufferhandle = new Napi::ObjectReference();
+                *bufferhandle = Napi::Persistent(bufferlocal);
+                char *buffer = bufferlocal.As<Napi::Buffer<char>>().Data();
+                size_t len = bufferlocal.As<Napi::Buffer<char>>().Length();
+                wtsession_->writeDatagramInt(buffer, len, bufferhandle);
+            }
+        }
+
+        void notifySessionDraining(const Napi::CallbackInfo &info)
+        {
+            wtsession_->notifySessionDrainingInt();
+        }
+
+        void orderSessionStats(const Napi::CallbackInfo &info)
+        {
+            wtsession_->orderSessionStatsInt();
+        }
+
+        void orderDatagramStats(const Napi::CallbackInfo &info)
+        {
+            wtsession_->orderDatagramStatsInt();
+        }
+
+        void close(const Napi::CallbackInfo &info)
+        {
+            int code = 0;
+            std::string reason("unknown reason");
+
+            if (!info[0].IsUndefined())
+            {
+                Napi::Object obj = info[0].ToObject();
+                if (!obj.IsEmpty())
+                {
+                    if (obj.Has("code") && !(obj).Get("code").IsEmpty())
+                    {
+                        Napi::Value codeValue = (obj).Get("code");
+                        code = codeValue.As<Napi::Number>().Int32Value();
+                    }
+                    if (obj.Has("reason") && !(obj).Get("reason").IsEmpty())
+                    {
+                        Napi::Value reasonValue = (obj).Get("reason");
+                        reason = reasonValue.ToString().Utf8Value();
+                    }
+                }
+            }
+
+            wtsession_->closeInt(code, reason);
+        }
+
+        static void InitExports(Napi::Env env, Napi::Object exports, Http3Constructors *constr)
+        {
+            Napi::Function tplwt =
+                ObjectWrap<Http3WTSessionJS>::DefineClass(env, "Http3WTSessionVisitor",
+                                                          {InstanceMethod<&Http3WTSessionJS::orderBidiStream>("orderBidiStream",
+                                                                                                              static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                           InstanceMethod<&Http3WTSessionJS::orderUnidiStream>("orderUnidiStream",
+                                                                                                               static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                           InstanceMethod<&Http3WTSessionJS::writeDatagram>("writeDatagram",
+                                                                                                            static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                           InstanceMethod<&Http3WTSessionJS::notifySessionDraining>("notifySessionDraining",
+                                                                                                                    static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                           InstanceMethod<&Http3WTSessionJS::orderSessionStats>("orderSessionStats",
+                                                                                                                static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                           InstanceMethod<&Http3WTSessionJS::orderDatagramStats>("orderDatagramStats",
+                                                                                                                 static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                           InstanceMethod<&Http3WTSessionJS::close>("close",
+                                                                                                    static_cast<napi_property_attributes>(napi_writable | napi_configurable))});
+            constr->session = Napi::Persistent(tplwt);
+            exports.Set("Http3WTSessionVisitor", tplwt);
+        }
+
+    protected:
+        std::unique_ptr<Http3WTSession> wtsession_;
+
+        static void freeData(Napi::Env env, void *data, std::string *hint);
+
+        void processStream(bool incom, bool bidi, Http3WTStream *stream);
+        void processSessionStats(webtransport::SessionStats sessstats);
+        void processDatagramStats(webtransport::DatagramStats datastats);
+        void processGoawayReceived();
+        void processDatagramSend(Napi::ObjectReference *bufferhandle);
+        void processDatagramReceived(std::string *datagram);
+        void processSessionReady();
+        void processSessionClose(uint32_t errorcode, const std::string &error);
+    };
+
+}
+#endif