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

package/src/librarymain.h

@@ -0,0 +1,42 @@
+// 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 LIBARAY_MAIN_H_
+#define LIBARAY_MAIN_H_
+
+#include <napi.h>
+
+namespace quic
+{
+  enum NetworkTask
+  {
+    resetStream,
+    stopSending,
+    streamFinal
+  };
+
+  enum NetworkStatus
+  {
+    NetError,
+    NetClose,
+    NetListening
+  };
+
+  struct Http3Constructors
+  {
+    Napi::FunctionReference stream;
+    Napi::FunctionReference session;
+    Napi::FunctionReference napialarm;
+    Napi::FunctionReference quicheInit;
+  };
+
+
+}
+#endif

package/src/napialarmfactory.cc

@@ -0,0 +1,51 @@
+// 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.
+
+#include "src/napialarmfactory.h"
+#include "quiche/quic/core/quic_alarm.h"
+
+namespace quic
+{
+  Napi::FunctionReference NapiAlarmJS::FAILSsetTimeoutAlarm_;
+  Napi::FunctionReference NapiAlarmJS::clearTimeout_;
+
+  void NapiAlarmJS::fireJS(const Napi::CallbackInfo &info)
+  {
+    alarm_->FireJS();
+  }
+
+  QuicAlarm *NapiAlarmFactory::CreateAlarm(
+      QuicAlarm::Delegate *delegate)
+  {
+    Http3Constructors *constr = envg_->getEnv().GetInstanceData<Http3Constructors>();
+    Napi::Object alarmobj = constr->napialarm.New({});
+    NapiAlarmJS *napialarmjs = Napi::ObjectWrap<NapiAlarmJS>::Unwrap(alarmobj);
+
+    NapiAlarm *alarm = new NapiAlarm(napialarmjs, clock_,
+                                     QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
+    return alarm;
+  }
+
+  QuicArenaScopedPtr<QuicAlarm> NapiAlarmFactory::CreateAlarm(
+      QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+      QuicConnectionArena *arena)
+  {
+    Http3Constructors *constr = envg_->getEnv().GetInstanceData<Http3Constructors>();
+    Napi::Object alarmobj = constr->napialarm.New({});
+    NapiAlarmJS *napialarmjs = Napi::ObjectWrap<NapiAlarmJS>::Unwrap(alarmobj);
+    if (arena != nullptr)
+    {
+      return arena->New<NapiAlarm>(napialarmjs, clock_, std::move(delegate));
+    }
+    return QuicArenaScopedPtr<QuicAlarm>(
+        new NapiAlarm(napialarmjs, clock_, std::move(delegate)));
+  }
+
+}

package/src/napialarmfactory.h

@@ -0,0 +1,165 @@
+// 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 NAPI_ALARM_FACTORY_H_
+#define NAPI_ALARM_FACTORY_H_
+
+#include "src/librarymain.h"
+#include "quiche/quic/core/quic_clock.h"
+#include "quiche/quic/core/quic_alarm.h"
+#include "quiche/quic/core/quic_alarm_factory.h"
+#include <napi.h>
+
+namespace quic
+{
+
+  class NapiAlarm;
+
+  class EnvGetter
+  {
+  public:
+    virtual Napi::Env getEnv() = 0;
+    virtual Napi::Object getValue() = 0;
+  };
+
+  class NapiAlarmFactory : public QuicAlarmFactory
+  {
+  public:
+    NapiAlarmFactory(QuicClock *clock, EnvGetter *envg) : clock_(clock), envg_(envg)
+    {
+    }
+
+    // QuicAlarmFactory interface.
+    QuicAlarm *CreateAlarm(QuicAlarm::Delegate *delegate) override;
+    QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
+        QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+        QuicConnectionArena *arena) override;
+
+  private:
+    QuicClock *clock_;
+    EnvGetter *envg_;
+  };
+
+  class NapiAlarmJS : public Napi::ObjectWrap<NapiAlarmJS>
+  {
+  friend class NapiAlarm;
+  public:
+    NapiAlarmJS(const Napi::CallbackInfo &info) : Napi::ObjectWrap<NapiAlarmJS>(info), alarm_()
+    {
+      if (FAILSsetTimeoutAlarm_.IsEmpty()) {
+        FAILSsetTimeoutAlarm_ = Napi::Persistent(Env().Global().Get("FAILSsetTimeoutAlarm").As<Napi::Function>());
+        FAILSsetTimeoutAlarm_.SuppressDestruct();
+      }
+      if (clearTimeout_.IsEmpty()) {
+        clearTimeout_ = Napi::Persistent(Env().Global().Get("clearTimeout").As<Napi::Function>());
+        clearTimeout_.SuppressDestruct();
+      }
+    }
+
+    void setAlarm(NapiAlarm *alarm)
+    {
+      alarm_ = alarm;
+    }
+
+    void fireJS(const Napi::CallbackInfo &info);
+    static void InitExports(Napi::Env env, Napi::Object exports, Http3Constructors *constr)
+    {
+      Napi::Function tplna =
+          DefineClass(env, "NapiAlarmJS",
+                      {InstanceMethod<&NapiAlarmJS::fireJS>("fireJS")});
+      constr->napialarm = Napi::Persistent(tplna);
+      exports.Set("NapiAlarmJS", tplna);
+    }
+
+    NapiAlarm *alarm()
+    {
+      return alarm_;
+    }
+
+  protected:
+    NapiAlarm* alarm_; // unowned
+    static Napi::FunctionReference FAILSsetTimeoutAlarm_;
+    static Napi::FunctionReference clearTimeout_;
+  };
+
+  class NapiAlarm : public QuicAlarm
+  {
+  public:
+    NapiAlarm(NapiAlarmJS *alarmjs, QuicClock *clock, QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
+        : alarmjs_(alarmjs), clock_(clock), QuicAlarm(std::move(delegate)), timerset_(false)
+    {
+      alarmjs->setAlarm(this);
+      alarmjs->Ref();
+    }
+
+    ~NapiAlarm()
+    {
+      if (timerset_)
+      {
+        NapiAlarmJS::clearTimeout_.Call({alarmref_.Value()});
+        alarmref_.Unref();
+        timerset_ = false;
+      }
+      if (alarmjs_)
+      {
+        alarmjs_->setAlarm(nullptr);
+        alarmjs_->Unref();
+        alarmjs_ = nullptr;
+      }
+
+    }
+
+    void FireJS()
+    {
+      Fire();
+    }
+
+  protected:
+    void SetImpl() override
+    {
+      if (!alarmjs_)
+        return;
+      absl::Duration timeout =
+          absl::Microseconds((deadline() - clock_->Now()).ToMicroseconds());
+      double timedelay = absl::ToDoubleMilliseconds(timeout);
+      if (timerset_)
+      {
+        alarmref_.Unref();
+        timerset_ = false;
+      }
+
+      Napi::Value timeoutobj = NapiAlarmJS::FAILSsetTimeoutAlarm_.Call({
+          alarmjs_->Value().As<Napi::Object>(),
+          Napi::Value::From(alarmjs_->Env(), timedelay),
+      });
+      alarmref_ = Napi::Reference<Napi::Object>::New(timeoutobj.As<Napi::Object>(), 1);
+      timerset_ = true;
+    }
+
+    void CancelImpl() override
+    {
+      if (timerset_)
+      {
+        NapiAlarmJS::clearTimeout_.Call({alarmref_.Value()});
+        alarmref_.Unref();
+        timerset_ = false;
+      }
+    }
+
+  private:
+    NapiAlarmJS *alarmjs_;
+    Napi::ObjectReference alarmref_;
+    QuicClock *clock_;
+    bool timerset_;
+  };
+
+}
+
+#endif

package/src/socketjswriter.cc

@@ -0,0 +1,46 @@
+// 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/socketjswriter.h"
+
+namespace quic
+{
+    WriteResult SocketJSWriter::WritePacket(const char *buffer, size_t buf_len,
+                                            const QuicIpAddress &self_address,
+                                            const QuicSocketAddress &peer_address,
+                                            PerPacketOptions *options,
+                                            const QuicPacketWriterParams &params)
+    {
+        Napi::Object retObj = Napi::Object::New(eg_->getEnv());
+
+        Napi::Buffer<char> nbuffer = Napi::Buffer<char>::New(eg_->getEnv(), buf_len);
+        memcpy(nbuffer.Data(), buffer, buf_len);
+
+        retObj.Set("msg", nbuffer);
+        retObj.Set("length", buf_len);
+        retObj.Set("offset", 0);
+        retObj.Set("port", peer_address.port());
+        retObj.Set("address", peer_address.host().ToString());
+
+        Napi::Object objVal = eg_->getValue().Get("socket").As<Napi::Object>();
+        Napi::Value fretVal = objVal.Get("sendPacket").As<Napi::Function>().Call(objVal, {retObj});
+
+        if (!fretVal.As<Napi::Boolean>().Value())
+        {
+            // Not blocked
+            return WriteResult(WRITE_STATUS_OK, 0);
+        }
+        else
+        {
+            // Blocked
+            return WriteResult(WRITE_STATUS_BLOCKED, 0);
+        }
+    }
+
+}

package/src/socketjswriter.h

@@ -0,0 +1,100 @@
+// 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.
+
+#ifndef WT_SOCKETJS_WRITER_H
+#define WT_SOCKETJS_WRITER_H
+
+#include "quiche/quic/core/quic_packet_writer.h"
+#include "quiche/quic/core/quic_udp_socket.h"
+#include "src/napialarmfactory.h"
+
+#include <napi.h>
+
+namespace quic
+{
+    class Http3ServerJS;
+    class SocketJSWriter : public QuicPacketWriter
+    {
+    public:
+        SocketJSWriter(EnvGetter *eg) : writeBlocked_(false), eg_(eg)
+        {
+        }
+
+        ~SocketJSWriter()  override {
+        }
+
+        void setCanWrite()
+        {
+            writeBlocked_ = false;
+        }
+
+        // QuicPacketWriter
+        bool SupportsEcn() const override
+        {
+            return false;
+        }
+
+        bool IsBatchMode() const override
+        {
+            return false;
+        }
+
+        bool IsWriteBlocked() const override
+        {
+            return writeBlocked_;
+        }
+
+        bool SupportsReleaseTime() const override
+        {
+            return false;
+        }
+
+        void SetWritable() override
+        {
+            writeBlocked_ = false;
+        }
+
+        absl::optional<int> MessageTooBigErrorCode() const override
+        {
+            return kSocketErrorMsgSize;
+        }
+
+        QuicByteCount GetMaxPacketSize(
+            const QuicSocketAddress & /*peer_address*/) const override
+        {
+            return kMaxOutgoingPacketSize;
+        }
+
+        WriteResult WritePacket(const char *buffer, size_t buf_len,
+                                const QuicIpAddress &self_address,
+                                const QuicSocketAddress &peer_address,
+                                PerPacketOptions *options,
+                                const QuicPacketWriterParams &params) override;
+
+        QuicPacketBuffer GetNextWriteLocation(
+            const QuicIpAddress &self_address,
+            const QuicSocketAddress &peer_address) override
+        {
+            return {nullptr, nullptr};
+        }
+
+        WriteResult Flush() override
+        {
+            return WriteResult(WRITE_STATUS_OK, 0);
+        }
+
+    protected:
+        bool writeBlocked_;
+        EnvGetter *eg_; // unowned
+    };
+
+
+}
+
+#endif