@encharm/cws 4.5.1 → 4.5.2

package/src/headers/24/tcp_wrap.h

@@ -0,0 +1,105 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_TCP_WRAP_H_
+#define SRC_TCP_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "connection_wrap.h"
+
+namespace node {
+
+class ExternalReferenceRegistry;
+class Environment;
+
+class TCPWrap : public ConnectionWrap<TCPWrap, uv_tcp_t> {
+ public:
+  enum SocketType {
+    SOCKET,
+    SERVER
+  };
+
+  static v8::MaybeLocal<v8::Object> Instantiate(Environment* env,
+                                                AsyncWrap* parent,
+                                                SocketType type);
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context,
+                         void* priv);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  SET_NO_MEMORY_INFO()
+  SET_SELF_SIZE(TCPWrap)
+  const char* MemoryInfoName() const override {
+    switch (provider_type()) {
+      case ProviderType::PROVIDER_TCPWRAP:
+        return "TCPSocketWrap";
+      case ProviderType::PROVIDER_TCPSERVERWRAP:
+        return "TCPServerWrap";
+      default:
+        UNREACHABLE();
+    }
+  }
+
+ private:
+  typedef uv_tcp_t HandleType;
+
+  template <typename T,
+            int (*F)(const typename T::HandleType*, sockaddr*, int*)>
+  friend void GetSockOrPeerName(const v8::FunctionCallbackInfo<v8::Value>&);
+
+  TCPWrap(Environment* env, v8::Local<v8::Object> object,
+          ProviderType provider);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetNoDelay(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetKeepAlive(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Bind(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Bind6(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Listen(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Connect(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Connect6(const v8::FunctionCallbackInfo<v8::Value>& args);
+  template <typename T>
+  static void Connect(const v8::FunctionCallbackInfo<v8::Value>& args,
+      std::function<int(const char* ip_address, T* addr)> uv_ip_addr);
+  static void Open(const v8::FunctionCallbackInfo<v8::Value>& args);
+  template <typename T>
+  static void Bind(
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      int family,
+      std::function<int(const char* ip_address, int port, T* addr)> uv_ip_addr);
+  static void Reset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  int Reset(v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());
+
+#ifdef _WIN32
+  static void SetSimultaneousAccepts(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+#endif
+};
+
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TCP_WRAP_H_

package/src/headers/24/threadpoolwork-inl.h

@@ -0,0 +1,70 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_THREADPOOLWORK_INL_H_
+#define SRC_THREADPOOLWORK_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+#include "tracing/trace_event.h"
+#include "util-inl.h"
+
+namespace node {
+
+void ThreadPoolWork::ScheduleWork() {
+  env_->IncreaseWaitingRequestCounter();
+  TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(
+      TRACING_CATEGORY_NODE2(threadpoolwork, async), type_, this);
+  int status = uv_queue_work(
+      env_->event_loop(),
+      &work_req_,
+      [](uv_work_t* req) {
+        ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
+        TRACE_EVENT_BEGIN0(TRACING_CATEGORY_NODE2(threadpoolwork, sync),
+                           self->type_);
+        self->DoThreadPoolWork();
+        TRACE_EVENT_END0(TRACING_CATEGORY_NODE2(threadpoolwork, sync),
+                         self->type_);
+      },
+      [](uv_work_t* req, int status) {
+        ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
+        self->env_->DecreaseWaitingRequestCounter();
+        TRACE_EVENT_NESTABLE_ASYNC_END1(
+            TRACING_CATEGORY_NODE2(threadpoolwork, async),
+            self->type_,
+            self,
+            "result",
+            status);
+        self->AfterThreadPoolWork(status);
+      });
+  CHECK_EQ(status, 0);
+}
+
+int ThreadPoolWork::CancelWork() {
+  return uv_cancel(reinterpret_cast<uv_req_t*>(&work_req_));
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_THREADPOOLWORK_INL_H_

package/src/headers/24/timer_wrap-inl.h

@@ -0,0 +1,32 @@
+#ifndef SRC_TIMER_WRAP_INL_H_
+#define SRC_TIMER_WRAP_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "timer_wrap.h"
+
+#include <utility>
+
+#include "env.h"
+#include "uv.h"
+
+namespace node {
+
+template <typename... Args>
+inline TimerWrap::TimerWrap(Environment* env, Args&&... args)
+    : env_(env), fn_(std::forward<Args>(args)...) {
+  uv_timer_init(env->event_loop(), &timer_);
+  timer_.data = this;
+}
+
+template <typename... Args>
+inline TimerWrapHandle::TimerWrapHandle(Environment* env, Args&&... args) {
+  timer_ = new TimerWrap(env, std::forward<Args>(args)...);
+  env->AddCleanupHook(CleanupHook, this);
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMER_WRAP_INL_H_

package/src/headers/24/timer_wrap.h

@@ -0,0 +1,87 @@
+#ifndef SRC_TIMER_WRAP_H_
+#define SRC_TIMER_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "memory_tracker.h"
+#include "env.h"
+#include "uv.h"
+
+#include <functional>
+
+namespace node {
+
+// Utility class that makes working with libuv timers a bit easier.
+class TimerWrap final : public MemoryRetainer {
+ public:
+  using TimerCb = std::function<void()>;
+
+  template <typename... Args>
+  explicit inline TimerWrap(Environment* env, Args&&... args);
+
+  TimerWrap(const TimerWrap&) = delete;
+
+  inline Environment* env() const { return env_; }
+
+  // Stop calling the timer callback.
+  void Stop();
+  // Render the timer unusable and delete this object.
+  void Close();
+
+  // Starts / Restarts the Timer
+  void Update(uint64_t interval, uint64_t repeat = 0);
+
+  void Ref();
+  void Unref();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(TimerWrap)
+  SET_SELF_SIZE(TimerWrap)
+
+ private:
+  static void TimerClosedCb(uv_handle_t* handle);
+  static void OnTimeout(uv_timer_t* timer);
+  ~TimerWrap() = default;
+
+  Environment* env_;
+  TimerCb fn_;
+  uv_timer_t timer_;
+
+  friend std::unique_ptr<TimerWrap>::deleter_type;
+};
+
+class TimerWrapHandle : public MemoryRetainer  {
+ public:
+  template <typename... Args>
+  explicit inline TimerWrapHandle(Environment* env, Args&&... args);
+
+  TimerWrapHandle(const TimerWrapHandle&) = delete;
+
+  ~TimerWrapHandle() { Close(); }
+
+  void Update(uint64_t interval, uint64_t repeat = 0);
+
+  inline operator bool() const { return timer_ != nullptr; }
+
+  void Ref();
+  void Unref();
+
+  void Stop();
+  void Close();
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+
+  SET_MEMORY_INFO_NAME(TimerWrapHandle)
+  SET_SELF_SIZE(TimerWrapHandle)
+
+ private:
+  static void CleanupHook(void* data);
+
+  TimerWrap* timer_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMER_WRAP_H_

package/src/headers/24/timers.h

@@ -0,0 +1,75 @@
+#ifndef SRC_TIMERS_H_
+#define SRC_TIMERS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "node_snapshotable.h"
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace timers {
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* env, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SET_BINDING_ID(timers_binding_data)
+  SERIALIZABLE_OBJECT_METHODS()
+
+  SET_NO_MEMORY_INFO()
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void SetupTimers(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void SlowGetLibuvNow(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static double FastGetLibuvNow(v8::Local<v8::Value> receiver);
+  static double GetLibuvNowImpl(BindingData* data);
+
+  static void SlowScheduleTimer(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastScheduleTimer(v8::Local<v8::Object> unused,
+                                v8::Local<v8::Object> receiver,
+                                int64_t duration);
+  static void ScheduleTimerImpl(BindingData* data, int64_t duration);
+
+  static void SlowToggleTimerRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleTimerRef(v8::Local<v8::Object> unused,
+                                 v8::Local<v8::Object> receiver,
+                                 bool ref);
+  static void ToggleTimerRefImpl(BindingData* data, bool ref);
+
+  static void SlowToggleImmediateRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleImmediateRef(v8::Local<v8::Object> unused,
+                                     v8::Local<v8::Object> receiver,
+                                     bool ref);
+  static void ToggleImmediateRefImpl(BindingData* data, bool ref);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterTimerExternalReferences(
+      ExternalReferenceRegistry* registry);
+
+ private:
+  static v8::CFunction fast_get_libuv_now_;
+  static v8::CFunction fast_schedule_timer_;
+  static v8::CFunction fast_toggle_timer_ref_;
+  static v8::CFunction fast_toggle_immediate_ref_;
+};
+
+}  // namespace timers
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMERS_H_

package/src/headers/24/tlscontext.h

@@ -0,0 +1,228 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <base_object.h>
+#include <crypto/crypto_context.h>
+#include <crypto/crypto_keys.h>
+#include <memory_tracker.h>
+#include <ncrypto.h>
+#include <ngtcp2/ngtcp2_crypto.h>
+#include "bindingdata.h"
+#include "data.h"
+#include "defs.h"
+#include "sessionticket.h"
+
+namespace node::quic {
+
+class Session;
+class TLSContext;
+
+// Every QUIC Session has exactly one TLSSession that maintains the state
+// of the TLS handshake and negotiated keys after the handshake has been
+// completed. It is separated out from the main Session class only as a
+// convenience to help make the code more maintainable and understandable.
+// A TLSSession is created from a TLSContext and maintains a reference to
+// the context.
+class TLSSession final : public MemoryRetainer {
+ public:
+  static const TLSSession& From(const SSL* ssl);
+
+  // The constructor is public in order to satisfy the call to std::make_unique
+  // in TLSContext::NewSession. It should not be called directly.
+  TLSSession(Session* session,
+             std::shared_ptr<TLSContext> context,
+             const std::optional<SessionTicket>& maybeSessionTicket);
+  DISALLOW_COPY_AND_MOVE(TLSSession)
+  ~TLSSession();
+
+  inline operator bool() const { return ssl_ != nullptr; }
+  inline Session& session() const { return *session_; }
+  inline TLSContext& context() const { return *context_; }
+
+  // Returns true if the handshake has been completed and early data was
+  // accepted by the TLS session. This will assert if the handshake has
+  // not been completed.
+  bool early_data_was_accepted() const;
+
+  v8::MaybeLocal<v8::Object> cert(Environment* env) const;
+  v8::MaybeLocal<v8::Object> peer_cert(Environment* env) const;
+  v8::MaybeLocal<v8::Object> ephemeral_key(Environment* env) const;
+  v8::MaybeLocal<v8::Value> cipher_name(Environment* env) const;
+  v8::MaybeLocal<v8::Value> cipher_version(Environment* env) const;
+
+  // The SNI (server name) negotiated for the session
+  const std::string_view servername() const;
+
+  // The ALPN (protocol name) negotiated for the session
+  const std::string_view protocol() const;
+
+  // Triggers key update to begin. This will fail and return false if either a
+  // previous key update is in progress or if the initial handshake has not yet
+  // been confirmed.
+  bool InitiateKeyUpdate();
+
+  struct PeerIdentityValidationError {
+    v8::MaybeLocal<v8::Value> reason;
+    v8::MaybeLocal<v8::Value> code;
+  };
+
+  // Checks the peer identity against the configured CA and CRL. If the peer
+  // certificate is valid, std::nullopt is returned. Otherwise a
+  // PeerIdentityValidationError is returned with the reason and code for the
+  // failure.
+  std::optional<PeerIdentityValidationError> VerifyPeerIdentity(
+      Environment* env);
+
+  inline const std::string_view validation_error() const {
+    return validation_error_;
+  }
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(TLSSession)
+  SET_SELF_SIZE(TLSSession)
+
+ private:
+  operator SSL*() const;
+  ncrypto::SSLPointer Initialize(
+      const std::optional<SessionTicket>& maybeSessionTicket);
+
+  static ngtcp2_conn* connection(ngtcp2_crypto_conn_ref* ref);
+
+  ngtcp2_crypto_conn_ref ref_;
+  std::shared_ptr<TLSContext> context_;
+  Session* session_;
+  ncrypto::SSLPointer ssl_;
+  ncrypto::BIOPointer bio_trace_;
+  std::string validation_error_ = "";
+  bool in_key_update_ = false;
+};
+
+// The TLSContext is used to create a TLSSession. For the client, there is
+// typically only a single TLSContext for each TLSSession. For the server,
+// there is a single TLSContext for the server and a TLSSession for every
+// QUIC session created by that server.
+class TLSContext final : public MemoryRetainer,
+                         public std::enable_shared_from_this<TLSContext> {
+ public:
+  static constexpr auto DEFAULT_CIPHERS = "TLS_AES_128_GCM_SHA256:"
+                                          "TLS_AES_256_GCM_SHA384:"
+                                          "TLS_CHACHA20_POLY1305_"
+                                          "SHA256:TLS_AES_128_CCM_SHA256";
+  static constexpr auto DEFAULT_GROUPS = "X25519:P-256:P-384:P-521";
+
+  struct Options final : public MemoryRetainer {
+    // The SNI servername to use for this session. This option is only used by
+    // the client.
+    std::string servername = "localhost";
+
+    // The ALPN (protocol name) to use for this session. This option is only
+    // used by the client.
+    std::string protocol = NGHTTP3_ALPN_H3;
+
+    // The list of TLS ciphers to use for this session.
+    std::string ciphers = DEFAULT_CIPHERS;
+
+    // The list of TLS groups to use for this session.
+    std::string groups = DEFAULT_GROUPS;
+
+    // When true, enables keylog output for the session.
+    bool keylog = false;
+
+    // When true, the peer certificate is verified against the list of supplied
+    // CA. If verification fails, the connection will be refused. When set,
+    // instructs the server session to request a client auth certificate. This
+    // option is only used by the server side.
+    bool verify_client = false;
+
+    // When true, enables TLS tracing for the session. This should only be used
+    // for debugging.
+    // JavaScript option name "tlsTrace".
+    bool enable_tls_trace = false;
+
+    // When true, causes the private key passed in for the session to be
+    // verified.
+    // JavaScript option name "verifyPrivateKey"
+    bool verify_private_key = false;
+
+    // The TLS private key(s) to use for this session.
+    // JavaScript option name "keys"
+    std::vector<crypto::KeyObjectData> keys;
+
+    // Collection of certificates to use for this session.
+    // JavaScript option name "certs"
+    std::vector<Store> certs;
+
+    // Optional certificate authority overrides to use.
+    // JavaScript option name "ca"
+    std::vector<Store> ca;
+
+    // Optional certificate revocation lists to use.
+    // JavaScript option name "crl"
+    std::vector<Store> crl;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(TLSContext::Options)
+    SET_SELF_SIZE(Options)
+
+    // The default TLS configuration.
+    static const Options kDefault;
+
+    static v8::Maybe<Options> From(Environment* env,
+                                   v8::Local<v8::Value> value);
+
+    std::string ToString() const;
+  };
+
+  static std::shared_ptr<TLSContext> CreateClient(const Options& options);
+  static std::shared_ptr<TLSContext> CreateServer(const Options& options);
+
+  TLSContext(Side side, const Options& options);
+  DISALLOW_COPY_AND_MOVE(TLSContext)
+
+  // Each QUIC Session has exactly one TLSSession. Each TLSSession maintains
+  // a reference to the TLSContext used to create it.
+  std::unique_ptr<TLSSession> NewSession(
+      Session* session, const std::optional<SessionTicket>& maybeSessionTicket);
+
+  inline Side side() const { return side_; }
+  inline const Options& options() const { return options_; }
+  inline operator bool() const { return ctx_ != nullptr; }
+
+  inline const std::string_view validation_error() const {
+    return validation_error_;
+  }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(TLSContext)
+  SET_SELF_SIZE(TLSContext)
+
+ private:
+  ncrypto::SSLCtxPointer Initialize();
+  operator SSL_CTX*() const;
+
+  static void OnKeylog(const SSL* ssl, const char* line);
+  static int OnNewSession(SSL* ssl, SSL_SESSION* session);
+  static int OnSelectAlpn(SSL* ssl,
+                          const unsigned char** out,
+                          unsigned char* outlen,
+                          const unsigned char* in,
+                          unsigned int inlen,
+                          void* arg);
+  static int OnVerifyClientCertificate(int preverify_ok, X509_STORE_CTX* ctx);
+
+  Side side_;
+  Options options_;
+  ncrypto::X509Pointer cert_;
+  ncrypto::X509Pointer issuer_;
+  ncrypto::SSLCtxPointer ctx_;
+  std::string validation_error_ = "";
+
+  friend class TLSSession;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS