@fails-components/webtransport 0.3.1 → 1.0.1

package/src/http3sessioncache.h

@@ -1,59 +0,0 @@
-// 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

@@ -1,46 +0,0 @@
-// 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"
-#include "src/http3eventloop.h"
-
-namespace quic
-{
-
-    Http3WTSession::Visitor::~Visitor()
-    {
-        // printf("~Visitor %d %x %x\n", getpid(), this, session_);
-        Http3WTSessionJS *sessobj = session_->getJS();
-        if (sessobj)
-            session_->eventloop_->informUnref(sessobj);
-        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_->eventloop_->informSessionClosed(session_, error_code, error_message);
-    }
-
-    void Http3WTSession::Visitor::OnSessionReady()
-    {
-        session_->eventloop_->informSessionReady(session_);
-
-        if (!session_->session_) return;
-
-        if (session_->session_->CanOpenNextOutgoingBidirectionalStream())
-        {
-            OnCanCreateNewOutgoingBidirectionalStream();
-        }
-        if (session_->session_->CanOpenNextOutgoingUnidirectionalStream())
-        {
-            OnCanCreateNewOutgoingUnidirectionalStream();
-        }
-    }
-
-}

package/src/http3wtsessionvisitor.h

@@ -1,397 +0,0 @@
-// 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 <uv.h>
-
-#include <atomic>
-
-#include <string>
-
-#include "src/http3wtstreamvisitor.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"
-
-#include "src/http3eventloop.h"
-
-namespace quic
-{
-    // class Http3Server;
-    class Http3WTSessionJS;
-
-    class Http3WTSession
-    {
-        friend Http3WTSessionJS;
-
-    public:
-        Http3WTSession()
-            : ordBidiStreams(0), ordUnidiStreams(0), session_(nullptr), eventloop_(nullptr), js_(nullptr)
-        {
-        }
-
-        ~Http3WTSession()
-        {
-            // printf("session destruct %x\n", this);
-        }
-
-        // need to be called immediately after new
-        void init(WebTransportSession *session, Http3EventLoop *eventloop)
-        {
-            session_ = session;
-            eventloop_ = eventloop;
-            if (session_) {
-                session_->SetOnDraining([this]() {
-                    eventloop_->informGoawayReceived(this);
-                }); 
-            }
-        }
-
-        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
-            {
-                if (!session_->session_)
-                    return;
-                while (true)
-                {
-                    WebTransportStream *stream =
-                        session_->session_->AcceptIncomingBidirectionalStream();
-                    if (stream == nullptr)
-                    {
-                        return;
-                    }
-                    Http3WTStream *wtstream = new Http3WTStream(stream, session_->eventloop_);
-                    QUIC_DVLOG(1)
-                        << "Http3WTSession received a bidirectional stream "
-                        << stream->GetStreamId();
-                    stream->SetVisitor(
-                        std::make_unique<Http3WTStream::Visitor>(wtstream));
-                    session_->eventloop_->informAboutStream(true, true, session_, static_cast<Http3WTStream *>(wtstream));
-                    stream->visitor()->OnCanRead();
-                }
-            }
-
-            void OnIncomingUnidirectionalStreamAvailable() override
-            {
-                if (!session_->session_)
-                    return;
-                while (true)
-                {
-                    WebTransportStream *stream =
-                        session_->session_->AcceptIncomingUnidirectionalStream();
-                    if (stream == nullptr)
-                    {
-                        return;
-                    }
-                    Http3WTStream *wtstream = new Http3WTStream(stream, session_->eventloop_);
-                    QUIC_DVLOG(1)
-                        << "Http3WTSession received a unidirectional stream";
-                    stream->SetVisitor(
-                        std::make_unique<Http3WTStream::Visitor>(wtstream));
-                    session_->eventloop_->informAboutStream(true, false, session_, static_cast<Http3WTStream *>(wtstream));
-                    stream->visitor()->OnCanRead();
-                }
-            }
-
-            void OnDatagramReceived(absl::string_view datagram) override
-            {
-                // printf("OnDatagramReceived %d %x %x\n", getpid(), this, session_);
-                session_->eventloop_->informDatagramReceived(session_, 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 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()
-        {
-            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, eventloop_);
-                stream->SetVisitor(
-                    std::make_unique<Http3WTStream::Visitor>(wtstream));
-                eventloop_->informAboutStream(false, true, this, static_cast<Http3WTStream *>(wtstream));
-                stream->visitor()->OnCanWrite();
-                ordBidiStreams--;
-            }
-        }
-
-        void 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, eventloop_);
-                stream->SetVisitor(
-                    std::make_unique<Http3WTStream::Visitor>(wtstream));
-
-                eventloop_->informAboutStream(false, false, this, static_cast<Http3WTStream *>(wtstream));
-                stream->visitor()->OnCanWrite();
-                ordUnidiStreams--;
-            }
-        }
-
-        Http3WTSessionJS *getJS() { return js_; };
-        void setJS(Http3WTSessionJS *js) { 
-            js_ = js; 
-        };
-
-    private:
-        
-        Http3WTSessionJS *js_;
-
-        void orderBidiStreamInt()
-        {
-            std::function<void()> task = [this]()
-            { tryOpenBidiStream(); };
-            eventloop_->Schedule(task);
-        }
-
-        void orderUnidiStreamInt()
-        {
-            std::function<void()> task = [this]()
-            { tryOpenUnidiStream(); };
-            eventloop_->Schedule(task);
-        }
-
-        void writeDatagramIntJS(char *buffer, size_t len, Napi::ObjectReference *bufferhandle)
-        {
-            std::function<void()> task = [this, bufferhandle, buffer, len]()
-            { writeDatagramInt(buffer, len, bufferhandle); };
-            eventloop_->Schedule(task);
-        }
-
-        void notifySessionDrainingInt()
-        {
-            std::function<void()> task = [this]()
-            { if (session_) session_->NotifySessionDraining(); };
-            eventloop_->Schedule(task);
-        }
-
-        void orderSessionStatsInt()
-        {
-            std::function<void()> task = [this](){
-                if (session_) {
-                    webtransport::SessionStats * stats = new webtransport::SessionStats();
-                    *stats = session_->GetSessionStats();
-                    eventloop_->informSessionStats(this, stats);
-            }};
-            eventloop_->Schedule(task);
-        }
-
-        void orderDatagramStatsInt()
-        {
-            std::function<void()> task = [this]()
-            {  if (session_) {
-                webtransport::DatagramStats * stats = new webtransport::DatagramStats();
-                *stats = session_->GetDatagramStats();
-                eventloop_->informDatagramStats(this, stats);
-            } };
-            eventloop_->Schedule(task);
-        }
-
-        void closeInt(int code, std::string &reason)
-        {
-            std::function<void()> task = [this, code, reason]()
-            { if (session_) session_->CloseSession(code, reason); };
-            eventloop_->Schedule(task);
-        }
-
-        void 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_);
-                eventloop_->informDatagramSend(this, 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_);
-            eventloop_->informDatagramSend(this, bufferhandle);
-        }
-
-        WebTransportSession *session_;
-        bool echo_stream_opened_ = false;
-        Http3EventLoop *eventloop_;
-        uint32_t ordBidiStreams;
-        uint32_t ordUnidiStreams;
-    };
-
-    class Http3WTSessionJS : public Napi::ObjectWrap<Http3WTSessionJS>, public LifetimeHelper
-    {
-    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_->orderBidiStreamInt();
-        }
-
-        void orderUnidiStream(const Napi::CallbackInfo &info)
-        {
-            wtsession_->orderUnidiStreamInt();
-        }
-
-        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_->writeDatagramIntJS(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);
-
-        }
-
-        void doUnref() override
-        {
-            Unref();
-        }
-
-    protected:
-        std::unique_ptr<Http3WTSession> wtsession_;
-    };
-}
-#endif

package/src/http3wtstreamvisitor.cc

@@ -1,155 +0,0 @@
-// 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/http3wtstreamvisitor.h"
-#include "src/http3server.h"
-
-namespace quic
-{
-    void Http3WTStreamJS::init(Http3WTStream * wtstream)
-    {
-        wtstream_ = std::unique_ptr<Http3WTStream>(wtstream);
-    }
-
-    Http3WTStream::Visitor::~Visitor()
-    {
-        while (stream_->chunks_.size() > 0)
-        {
-            auto cur = stream_->chunks_.front();
-
-            // now we have to inform the server TODO
-            stream_->eventloop_->informAboutStreamWrite(stream_, cur.bufferhandle, false);
-
-            stream_->chunks_.pop_front();
-        }
-
-        stream_->eventloop_->informAboutStreamRead(stream_, 0, false, false);
-
-        if (!stream_->stop_sending_received_)
-        {
-            stream_->eventloop_->informStreamRecvSignal(stream_, 0, NetworkTask::stopSending);
-        }
-        if (!stream_->stream_was_reset_)
-        {
-            stream_->eventloop_->informStreamRecvSignal(stream_, 0, NetworkTask::resetStream);
-        }
-        Http3WTStreamJS *strobj = stream_->getJS();
-        if (strobj) {
-            stream_->stream_ = nullptr;
-            stream_->eventloop_->informUnref(strobj);
-        } else {
-            stream_->stream_ = nullptr;
-        }
-    }
-
-    void Http3WTStream::Visitor::OnWriteSideInDataRecvdState() // called if everything is written to the client and it is closed
-    {
-        if (stream_->send_fin_)
-            stream_->eventloop_->informAboutStreamNetworkFinish(stream_, NetworkTask::streamFinal);
-    }
-
-    void Http3WTStream::Visitor::OnResetStreamReceived(WebTransportStreamError error)
-    {
-        // should this be removed
-        /*
-
-        // Send FIN in response to a stream reset.  We want to test that we can
-        // operate one side of the stream cleanly while the other is reset, thus
-        // replying with a FIN rather than a RESET_STREAM is more appropriate here.
-        stream_->send_fin_ = true;
-        OnCanWrite();*/
-        stream_->stream_was_reset_ = true;
-        lasterror = error;
-        stream_->eventloop_->informStreamRecvSignal(stream_, error, NetworkTask::resetStream); // may be move below
-    }
-
-    void Http3WTStream::Visitor::OnStopSendingReceived(WebTransportStreamError error)
-    {
-        stream_->stop_sending_received_ = true;
-        stream_->eventloop_->informStreamRecvSignal(stream_, error, NetworkTask::stopSending); // may be move below
-        // we should also finallize the stream, so send a fin
-        stream_->send_fin_ = true;
-        OnCanWrite();
-    }
-
-    void Http3WTStream::cancelWrite(Napi::ObjectReference *handle)
-    {
-        eventloop_->informAboutStreamWrite(this, handle, false);
-    }
-
-    void Http3WTStream::doCanRead()
-    {
-        // if (pause_reading_) return ; // back pressure folks!
-        
-        if (pause_reading_)
-        {
-            can_read_pending_ = true;
-            return; // back pressure folks!
-        }
-        // first figure out if we have readable data
-        if (bufferlen_ >= readbufsize_ || !readbufdata_) {
-            can_read_pending_ = true;
-            return; // no space here
-        }
-        size_t readable = stream_->ReadableBytes();
-        bool read = false;
-        while (readable > 0 && bufferlen_ < readbufsize_)
-        {
-            if (writepos_ >= readpos_) {
-                size_t len = readbufsize_ - writepos_;   
-                WebTransportStream::ReadResult result = 
-                    stream_->Read(absl::Span<char>(((char*) readbufdata_) + writepos_, len));
-                QUIC_DVLOG(1) << "Attempted reading on WebTransport stream "
-                          << ", bytes read: " << result.bytes_read;
-                writepos_ = (writepos_ + result.bytes_read) % readbufsize_;
-                bufferlen_ = bufferlen_ + result.bytes_read;
-                eventloop_->informAboutStreamRead(this, result.bytes_read, 
-                            result.fin, true);
-            } else  { // readpos_ > writepos_
-                size_t len = writepos_ - readpos_;
-                WebTransportStream::ReadResult result = 
-                    stream_->Read(absl::Span<char>(((char*) readbufdata_) + writepos_, len));
-                QUIC_DVLOG(1) << "Attempted reading on WebTransport stream "
-                          << ", bytes read: " << result.bytes_read; 
-                writepos_ = (writepos_ + result.bytes_read) % readbufsize_;
-                bufferlen_ = bufferlen_ + result.bytes_read;
-                eventloop_->informAboutStreamRead(this, result.bytes_read,
-                             result.fin, true);
-            } 
-            readable = stream_->ReadableBytes();
-        }
-    }
-
-    void Http3WTStream::doCanWrite()
-    {
-        /* if (/* stop_sending_received_ || * pause_reading_)
-         {
-             return;
-         } */
-        if (fin_was_sent_) return;
-
-        while (chunks_.size() > 0)
-        {
-            auto cur = chunks_.front();
-            bool success = stream_->Write(absl::string_view(cur.buffer, cur.len));
-            QUIC_DVLOG(1) << "Attempted writing on WebTransport bidirectional stream "
-                          << ", success: " << (success ? "yes" : "no");
-            if (!success)
-            {
-                return;
-            }
-            // now we have to inform the server TODO
-            eventloop_->informAboutStreamWrite(this, cur.bufferhandle, true);
-
-            chunks_.pop_front();
-        }
-
-        if (send_fin_)
-        {
-            bool success = stream_->SendFin();
-            if (success) fin_was_sent_ = true;
-        }
-    }
-
-}