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

package/src/http3wtstreamvisitor.cc

@@ -0,0 +1,286 @@
+// 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()
+    {
+        // printf("stream ~Visitor %d %x %x\n", getpid(), this, stream_);
+        while (stream_->chunks_.size() > 0)
+        {
+            auto cur = stream_->chunks_.front();
+
+            // now we have to inform the server TODO
+            stream_->getJS()->processStreamWrite(cur.bufferhandle, false);
+
+            stream_->chunks_.pop_front();
+        }
+
+        if (!stream_->stop_sending_received_)
+        {
+            stream_->getJS()->processStreamRecvSignal(0, NetworkTask::stopSending);
+        }
+        if (!stream_->stream_was_reset_)
+        {
+            stream_->getJS()->processStreamRecvSignal(0, NetworkTask::resetStream);
+        }
+        Http3WTStreamJS *strobj = stream_->getJS();
+        if (strobj)
+        {
+            stream_->stream_ = nullptr;
+            strobj->Unref();
+        }
+        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_->getJS()->processStreamNetworkFinish(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_->getJS()->processStreamRecvSignal(error, NetworkTask::resetStream); // may be move below
+    }
+
+    void Http3WTStream::Visitor::OnStopSendingReceived(WebTransportStreamError error)
+    {
+        stream_->stop_sending_received_ = true;
+        stream_->getJS()->processStreamRecvSignal(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)
+    {
+        getJS()->processStreamWrite(handle, false);
+    }
+
+    void Http3WTStream::doCanRead()
+    {
+        // if (pause_reading_) return ; // back pressure folks!
+
+        if (pause_reading_ && !drain_reads_)
+        {
+            can_read_pending_ = true;
+            return; // back pressure folks!
+        }
+        size_t readable = stream_->ReadableBytes();
+        bool read = false;
+        while (readable > 0)
+        {
+            Http3WTStreamJS::StreamReadBuffer rbuf(js_);
+            rbuf.getBuffer(readable);
+
+            size_t remainSize = rbuf.bufferSize();
+            uint32_t writepos = 0;
+
+            while (readable > 0 && remainSize > 0) {
+                size_t len = remainSize;
+                WebTransportStream::ReadResult result =
+                    stream_->Read(absl::Span<char>(((char *)rbuf.bufferData()) + writepos, len));
+                QUIC_DVLOG(1) << "Attempted reading on WebTransport stream "
+                              << ", bytes read: " << result.bytes_read;
+                writepos += result.bytes_read;
+                remainSize -= result.bytes_read;
+                readable = stream_->ReadableBytes();
+                if (result.fin) rbuf.setFin();
+            }
+            rbuf.commitBuffer(writepos, readable == 0);
+        }
+    }
+
+    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
+            getJS()->processStreamWrite(cur.bufferhandle, true);
+
+            chunks_.pop_front();
+        }
+
+        if (send_fin_)
+        {
+            bool success = stream_->SendFin();
+            if (success)
+                fin_was_sent_ = true;
+        }
+    }
+
+    void Http3WTStream::stopSendingInt(unsigned int reason)
+    {
+        if (stream_)
+        {
+            stream_->SendStopSending(reason);
+            getJS()->processStreamNetworkFinish(NetworkTask::stopSending);
+        }
+    }
+
+    void Http3WTStream::resetStreamInt(unsigned int reason)
+    {
+        if (stream_)
+        {
+            stream_->ResetWithUserCode(reason);
+            getJS()->processStreamNetworkFinish(NetworkTask::resetStream);
+        }
+    }
+
+    void Http3WTStreamJS::processStreamNetworkFinish(NetworkTask task)
+    {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        std::string nettaskstr;
+        switch (task)
+        {
+        case NetworkTask::resetStream:
+        {
+            nettaskstr = "resetStream";
+        }
+        break;
+        case NetworkTask::stopSending:
+        {
+            nettaskstr = "stopSending";
+        }
+        break;
+        case NetworkTask::streamFinal:
+        {
+            nettaskstr = "streamFinal";
+        }
+        break;
+        default:
+            return;
+        };
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        retObj.Set("nettask", nettaskstr);
+
+        objVal.Get("onStreamNetworkFinish").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTStreamJS::processStreamRecvSignal(WebTransportStreamError error_code, NetworkTask task)
+    {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+
+        std::string nettaskstr;
+        switch (task)
+        {
+        case NetworkTask::resetStream:
+        {
+            nettaskstr = "resetStream";
+        }
+        break;
+        case NetworkTask::stopSending:
+        {
+            nettaskstr = "stopSending";
+        }
+        break;
+        case NetworkTask::streamFinal:
+        {
+            nettaskstr = "streamFinal";
+        }
+        break;
+        default:
+            return;
+        };
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        retObj.Set("purpose", "StreamRecvSignal");
+        retObj.Set("code", error_code);
+        retObj.Set("nettask", nettaskstr);
+
+        objVal.Get("onStreamRecvSignal").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void Http3WTStreamJS::processStreamWrite(Napi::ObjectReference *bufferhandle, bool success)
+    {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
+        bufferhandle->Unref(); // release the outgoing buffer
+        delete bufferhandle;   // free the handle object
+
+        Napi::Object retObj = Napi::Object::New(Env());
+        retObj.Set("success", success);
+
+        objVal.Get("onStreamWrite").As<Napi::Function>().Call(objVal, {retObj});
+    }
+
+    void  Http3WTStreamJS::StreamReadBuffer::getBuffer(size_t reqsize) {
+        Napi::HandleScope scope(jsobj_->Env());
+        Napi::Object objVal = jsobj_->Value().Get("jsobj").As<Napi::Object>();
+
+        Napi::Object argObj = Napi::Object::New(jsobj_->Env());
+        argObj.Set("byteSize", reqsize);
+
+        Napi::Value bufferVal = objVal.Get("getReadBuffer").As<Napi::Function>().Call(objVal, {argObj});
+        bufferObj = Napi::Persistent(bufferVal.As<Napi::Object>());
+        Napi::Object locBuf = bufferVal.As<Napi::Object>();
+        fin = locBuf.Get("fin").As<Napi::Boolean>();
+        if (locBuf.Has("buffer")) {
+            Napi::Uint8Array buffer = locBuf.Get("buffer").As<Napi::Uint8Array>();
+            buffer_ = buffer.Data();
+            buffersize_ =buffer.ByteLength();
+        }
+        // buffer
+        // byob
+        // readBytes
+        // fin
+    }
+
+    void  Http3WTStreamJS::StreamReadBuffer::commitBuffer(uint32_t readbytes, bool drained) {
+        Napi::HandleScope scope(jsobj_->Env());
+        Napi::Object objVal = jsobj_->Value().Get("jsobj").As<Napi::Object>();
+
+        bufferObj.Set("fin", fin);
+        bufferObj.Set("readBytes", Napi::Value::From(jsobj_->Env(),readbytes));
+        bufferObj.Set("drained", drained);
+        Napi::Value bufferVal = objVal.Get("commitReadBuffer").As<Napi::Function>().Call(objVal, {bufferObj.Value()});
+
+
+    }
+
+}

package/src/http3wtstreamvisitor.h

@@ -0,0 +1,323 @@
+// 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 used only portions, 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_STREAM_VISITOR_H_
+#define HTTP3_WT_STREAM_VISITOR_H_
+
+#include <napi.h>
+
+#include <string>
+
+#include "src/librarymain.h"
+#include "quiche/common/simple_buffer_allocator.h"
+#include "quiche/quic/core/web_transport_interface.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/quiche_circular_deque.h"
+
+namespace quic
+{
+    class Http3EventLoop;
+
+    class Http3WTStreamJS;
+
+    class Http3WTStream
+    {
+        friend Http3WTStreamJS;
+
+    public:
+        Http3WTStream(WebTransportStream *stream) : stream_(stream),
+                                                    js_(nullptr)
+        {
+        }
+
+        ~Http3WTStream(){/*printf("stream destruct %x\n", this);*/};
+
+        class Visitor : public WebTransportStreamVisitor
+        {
+        public:
+            Visitor(Http3WTStream *stream) : stream_(stream), lasterror(0) {}
+
+            ~Visitor();
+
+            void OnCanRead() override
+            {
+                stream_->doCanRead();
+            }
+
+            void OnCanWrite() override
+            {
+                stream_->doCanWrite();
+            }
+
+            void OnResetStreamReceived(WebTransportStreamError error) override;
+
+            void OnStopSendingReceived(WebTransportStreamError /*error*/) override;
+
+            void OnWriteSideInDataRecvdState() override;
+
+        protected:
+            Http3WTStream *stream_;
+            WebTransportStreamError lasterror;
+        };
+
+        void doCanRead();
+
+        void doCanWrite();
+
+        void doStopReading()
+        {
+            pause_reading_ = true;
+        }
+
+        void doDrainReads()
+        {
+            pause_reading_ = false;
+            drain_reads_ = true;
+        }
+
+        void tryWrite()
+        {
+            if (stream_ && stream_->CanWrite())
+            {
+                doCanWrite();
+            }
+        }
+
+        void tryRead()
+        {
+            pause_reading_ = false;
+            if (stream_ && ((stream_->ReadableBytes() > 0) || can_read_pending_))
+            {
+                can_read_pending_ = false;
+                doCanRead();
+            }
+        }
+
+        Http3WTStreamJS *getJS()
+        {
+            return js_;
+        }
+
+        void setJS(Http3WTStreamJS *js)
+        {
+            js_ = js;
+        };
+
+        bool gone()
+        {
+            return !stream_;
+        }
+
+    protected:
+        // internal functions called by js object
+
+        void streamFinalInt()
+        {
+            send_fin_ = true;
+            tryWrite();
+        }
+
+        void stopSendingInt(unsigned int reason);
+        void resetStreamInt(unsigned int reason);
+
+        WebTransportStream *stream() { return stream_; }
+
+        struct WChunks
+        {
+            char *buffer;
+            size_t len;
+            Napi::ObjectReference *bufferhandle;
+        };
+
+        void writeChunkInt(char *buffer, size_t len, Napi::ObjectReference *bufferhandle)
+        {
+            if (fin_was_sent_ || send_fin_)
+            {
+                cancelWrite(bufferhandle);
+                return;
+            }
+            if (!stream_)
+            {
+                cancelWrite(bufferhandle);
+                return;
+            }
+            WChunks cur;
+            cur.buffer = buffer;
+            cur.len = len;
+            cur.bufferhandle = bufferhandle;
+            chunks_.push_back(cur);
+            tryWrite();
+        }
+
+        void cancelWrite(Napi::ObjectReference *handle);
+
+    private:
+        Http3WTStreamJS *js_;
+
+        WebTransportStream *stream_;
+        bool send_fin_ = false;
+        bool fin_was_sent_ = false;
+        bool stop_sending_received_ = false;
+        bool pause_reading_ = false;
+        bool drain_reads_ = false;
+        bool can_read_pending_ = false;
+        bool stream_was_reset_ = false;
+        std::deque<WChunks> chunks_;
+    };
+
+    class Http3WTStreamJS : public Napi::ObjectWrap<Http3WTStreamJS>
+    {
+        friend Http3WTStream;
+        friend Http3WTStream::Visitor;
+
+    public:
+        class StreamReadBuffer
+        {
+        public:
+            StreamReadBuffer(Http3WTStreamJS *jsobj) : fin(false), jsobj_(jsobj),
+                                                 buffer_(nullptr), buffersize_(0)
+            {
+            }
+
+            void getBuffer(size_t reqsize);
+
+
+           
+            unsigned char * bufferData() { return buffer_;};
+            size_t bufferSize() { return buffersize_;};
+
+            bool hasBuffer() {return buffer_ != nullptr;}
+
+            void commitBuffer(uint32_t readbytes, bool drained);
+
+            void setFin() { fin = true;}
+
+
+        protected:
+            Napi::ObjectReference bufferObj;
+            unsigned char *buffer_;
+            size_t buffersize_;
+            // buffer?: Uint8Array
+            // byob?
+            bool fin;
+            Http3WTStreamJS *jsobj_; // unowned
+        };
+
+        public: 
+        
+        Http3WTStreamJS(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Http3WTStreamJS>(info)
+        {
+        }
+
+        void init(Http3WTStream *wtstream);
+
+        // nan stuff
+
+        void startReading(const Napi::CallbackInfo &info)
+        {
+            wtstream_->tryRead();
+        }
+
+        void stopReading(const Napi::CallbackInfo &info)
+        {
+            wtstream_->doStopReading();
+        }
+
+        void drainReads(const Napi::CallbackInfo &info)
+        {
+            wtstream_->doDrainReads();
+        }
+
+        void writeChunk(const Napi::CallbackInfo &info)
+        {
+            // ok we have to get the buffer
+
+            const 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();
+
+            wtstream_->writeChunkInt(buffer, len, bufferhandle);
+        }
+
+        void streamFinal(const Napi::CallbackInfo &info)
+        {
+            wtstream_->streamFinalInt();
+        }
+
+        void stopSending(const Napi::CallbackInfo &info)
+        {
+            unsigned int reason = 0;
+
+            if (!info[0].IsUndefined())
+            {
+                Napi::Number reasonl = info[0].ToNumber();
+                reason = reasonl.Int32Value();
+            }
+
+            wtstream_->stopSendingInt(reason);
+        }
+
+        void resetStream(const Napi::CallbackInfo &info)
+        {
+            int code = 0;
+            unsigned int reason = 0;
+
+            if (!info[0].IsUndefined())
+            {
+                Napi::Number reasonl = info[0].ToNumber();
+                reason = reasonl.Int32Value();
+            }
+
+            wtstream_->resetStreamInt(reason);
+        }
+
+        static void InitExports(Napi::Env env, Napi::Object exports, Http3Constructors *constr)
+        {
+            Napi::Function tplwtsv =
+                DefineClass(env, "Http3WTStreamVisitor",
+                            {InstanceMethod<&Http3WTStreamJS::writeChunk>("writeChunk",
+                                                                          static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                             InstanceMethod<&Http3WTStreamJS::resetStream>("resetStream",
+                                                                           static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                             InstanceMethod<&Http3WTStreamJS::stopSending>("stopSending", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                             InstanceMethod<&Http3WTStreamJS::streamFinal>("streamFinal", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                             InstanceMethod<&Http3WTStreamJS::startReading>("startReading",
+                                                                            static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                             InstanceMethod<&Http3WTStreamJS::startReading>("drainReads",
+                                                                            static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                             InstanceMethod<&Http3WTStreamJS::stopReading>("stopReading",
+                                                                           static_cast<napi_property_attributes>(napi_writable | napi_configurable))});
+            constr->stream = Napi::Persistent(tplwtsv);
+            exports.Set("Http3WTStreamVisitor", tplwtsv);
+        }
+
+        void setObj(Http3WTStream *wtstream)
+        {
+            wtstream_ = std::unique_ptr<Http3WTStream>(wtstream);
+        }
+
+        Http3WTStream *getObj()
+        {
+            return wtstream_.get();
+        }
+
+    protected:
+        std::unique_ptr<Http3WTStream> wtstream_;
+
+        void processStreamWrite(Napi::ObjectReference *bufferhandle, bool success);
+        void processStreamNetworkFinish(NetworkTask task);
+        void processStreamRecvSignal(WebTransportStreamError error_code, NetworkTask task);
+    };
+}
+
+#endif

package/src/librarymain.cc

@@ -0,0 +1,86 @@
+// 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, original copyright, see LICENSE.chromium
+// Copyright (c)  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/librarymain.h"
+#include "src/http3server.h"
+#include "src/http3client.h"
+#include "src/http3dispatcher.h"
+#include "src/http3wtsessionvisitor.h"
+#include "src/napialarmfactory.h"
+#include "quiche/common/platform/api/quiche_command_line_flags.h"
+
+#include "absl/log/initialize.h"
+#include "absl/strings/string_view.h"
+
+using namespace Napi;
+
+namespace quic
+{
+  bool hasSetLogging = false;
+
+  void quicheInit(const Napi::CallbackInfo &info)
+  {
+    std::vector<std::string> quiche_cmd_line;
+    quiche_cmd_line.push_back(std::string("webtransport.node"));
+    if (!info[0].IsUndefined() /*|| info[1].IsFunction()*/)
+    {
+      Napi::Object lobj = info[0].ToObject();
+      if (lobj.IsEmpty())
+      {
+        Napi::Error::New(info.Env(), "No callback obj for Http3Transport").ThrowAsJavaScriptException();
+        return;
+      }
+
+      quiche_cmd_line.push_back(std::string("-v"));
+      if (lobj.Has("quicheLogVerbose") && lobj.Get("quicheLogVerbose").IsFunction())
+      {
+        Napi::Value verboseValue = (lobj).Get("quicheLogVerbose");
+        quiche_cmd_line.push_back(verboseValue.ToString().Utf8Value());
+      }
+      else
+      {
+        quiche_cmd_line.push_back(std::string("-1"));
+      }
+    }
+    else
+    {
+      Napi::Error::New(info.Env(), "Callback not passed to Webtransport library internals").ThrowAsJavaScriptException();
+      return;
+    }
+    std::vector<const char *> quiche_cmd_line_char;
+    for (auto cur = quiche_cmd_line.begin(); cur != quiche_cmd_line.end(); cur++)
+    {
+      quiche_cmd_line_char.push_back((*cur).c_str());
+    }
+    if (!hasSetLogging)
+    {
+      quiche::QuicheParseCommandLineFlags("No use instruction.", quiche_cmd_line.size(), &(*quiche_cmd_line_char.begin()));
+      hasSetLogging = true;
+    }
+  }
+
+  Napi::Object Init(Napi::Env env, Napi::Object exports)
+  {
+    Http3Constructors *constr = new Http3Constructors();
+
+    Http3ServerJS::InitExports(env, exports);
+    Http3ClientJS::InitExports(env, exports);
+    Http3WTSessionJS::InitExports(env, exports, constr);
+    Http3WTStreamJS::InitExports(env, exports, constr);
+    NapiAlarmJS::InitExports(env, exports, constr);
+    Napi::Function qinitna = Function::New<quicheInit>(env);
+    constr->quicheInit = Napi::Persistent(qinitna);
+    exports.Set("quicheInit", qinitna);
+
+    env.SetInstanceData<Http3Constructors>(constr);
+    return exports;
+  }
+
+  NODE_API_MODULE(webtransport, Init)
+}