@encharm/cws 4.5.1 → 4.5.2

package/binding.gyp

@@ -32,7 +32,7 @@
                 ['OS=="mac"', {
                     'xcode_settings': {
                         'MACOSX_DEPLOYMENT_TARGET': '10.7',
-                        'CLANG_CXX_LANGUAGE_STANDARD': 'c++17',
+                        'CLANG_CXX_LANGUAGE_STANDARD': 'c++20',
                         'CLANG_CXX_LIBRARY': 'libc++',
                         'GCC_GENERATE_DEBUGGING_SYMBOLS': 'NO',
                         'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@encharm/cws",
-  "version": "4.5.1",
+  "version": "4.5.2",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "description": "cWS - fast C++ WebSocket implementation for Node.js",

package/src/Addon.h

@@ -19,6 +19,11 @@
   #include "headers/22/base_object-inl.h"
 #endif
 
+#if NODE_MAJOR_VERSION==24
+  #include "headers/24/crypto/crypto_tls.h"
+  #include "headers/24/base_object-inl.h"
+#endif
+
 #include <tcp_wrap.h>
 
 using BaseObject = node::BaseObject;
@@ -672,4 +677,4 @@ struct Namespace {
 
     object->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "group").ToLocalChecked(), group);
   }
-};
+};

package/src/headers/24/acorn_version.h

@@ -0,0 +1,6 @@
+// This is an auto generated file, please do not edit.
+// Refer to tools/dep_updaters/update-acorn.sh
+#ifndef SRC_ACORN_VERSION_H_
+#define SRC_ACORN_VERSION_H_
+#define ACORN_VERSION "8.15.0"
+#endif  // SRC_ACORN_VERSION_H_

package/src/headers/24/addon_permission.h

@@ -0,0 +1,31 @@
+#ifndef SRC_PERMISSION_ADDON_PERMISSION_H_
+#define SRC_PERMISSION_ADDON_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <string>
+#include "permission/permission_base.h"
+
+namespace node {
+
+namespace permission {
+
+class AddonPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             const std::vector<std::string>& allow,
+             PermissionScope scope) override;
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  const std::string_view& param = "") const override;
+
+ private:
+  bool deny_all_;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_ADDON_PERMISSION_H_

package/src/headers/24/agent.h

@@ -0,0 +1,195 @@
+#ifndef SRC_TRACING_AGENT_H_
+#define SRC_TRACING_AGENT_H_
+
+#include "libplatform/v8-tracing.h"
+#include "uv.h"
+#include "util.h"
+#include "node_mutex.h"
+
+#include <list>
+#include <set>
+#include <string>
+#include <unordered_map>
+
+namespace v8 {
+class ConvertableToTraceFormat;
+class TracingController;
+}  // namespace v8
+
+namespace node {
+namespace tracing {
+
+using v8::platform::tracing::TraceConfig;
+using v8::platform::tracing::TraceObject;
+
+class Agent;
+
+class AsyncTraceWriter {
+ public:
+  virtual ~AsyncTraceWriter() = default;
+  virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
+  virtual void Flush(bool blocking) = 0;
+  virtual void InitializeOnThread(uv_loop_t* loop) {}
+};
+
+class TracingController : public v8::platform::tracing::TracingController {
+ public:
+  TracingController() : v8::platform::tracing::TracingController() {}
+
+  int64_t CurrentTimestampMicroseconds() override {
+    return uv_hrtime() / 1000;
+  }
+  void AddMetadataEvent(
+      const unsigned char* category_group_enabled,
+      const char* name,
+      int num_args,
+      const char** arg_names,
+      const unsigned char* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* convertable_values,
+      unsigned int flags);
+};
+
+class AgentWriterHandle {
+ public:
+  inline AgentWriterHandle() = default;
+  inline ~AgentWriterHandle() { reset(); }
+
+  inline AgentWriterHandle(AgentWriterHandle&& other);
+  inline AgentWriterHandle& operator=(AgentWriterHandle&& other);
+  inline bool empty() const { return agent_ == nullptr; }
+  inline void reset();
+
+  inline void Enable(const std::set<std::string>& categories);
+  inline void Disable(const std::set<std::string>& categories);
+
+  inline bool IsDefaultHandle();
+
+  inline Agent* agent() { return agent_; }
+
+  inline v8::TracingController* GetTracingController();
+
+  AgentWriterHandle(const AgentWriterHandle& other) = delete;
+  AgentWriterHandle& operator=(const AgentWriterHandle& other) = delete;
+
+ private:
+  inline AgentWriterHandle(Agent* agent, int id) : agent_(agent), id_(id) {}
+
+  Agent* agent_ = nullptr;
+  int id_ = 0;
+
+  friend class Agent;
+};
+
+class Agent {
+ public:
+  Agent();
+  ~Agent();
+
+  TracingController* GetTracingController() {
+    TracingController* controller = tracing_controller_.get();
+    CHECK_NOT_NULL(controller);
+    return controller;
+  }
+
+  enum UseDefaultCategoryMode {
+    kUseDefaultCategories,
+    kIgnoreDefaultCategories
+  };
+
+  // Destroying the handle disconnects the client
+  AgentWriterHandle AddClient(const std::set<std::string>& categories,
+                              std::unique_ptr<AsyncTraceWriter> writer,
+                              enum UseDefaultCategoryMode mode);
+  // A handle that is only used for managing the default categories
+  // (which can then implicitly be used through using `USE_DEFAULT_CATEGORIES`
+  // when adding a client later).
+  AgentWriterHandle DefaultHandle();
+
+  // Returns a comma-separated list of enabled categories.
+  std::string GetEnabledCategories() const;
+
+  // Writes to all writers registered through AddClient().
+  void AppendTraceEvent(TraceObject* trace_event);
+
+  void AddMetadataEvent(std::unique_ptr<TraceObject> event);
+  // Flushes all writers registered through AddClient().
+  void Flush(bool blocking);
+
+  TraceConfig* CreateTraceConfig() const;
+
+ private:
+  friend class AgentWriterHandle;
+
+  void InitializeWritersOnThread();
+
+  void Start();
+  void StopTracing();
+  void Disconnect(int client);
+
+  void Enable(int id, const std::set<std::string>& categories);
+  void Disable(int id, const std::set<std::string>& categories);
+
+  uv_thread_t thread_;
+  uv_loop_t tracing_loop_;
+
+  bool started_ = false;
+  class ScopedSuspendTracing;
+
+  // Each individual Writer has one id.
+  int next_writer_id_ = 1;
+  enum { kDefaultHandleId = -1 };
+  // These maps store the original arguments to AddClient(), by id.
+  std::unordered_map<int, std::multiset<std::string>> categories_;
+  std::unordered_map<int, std::unique_ptr<AsyncTraceWriter>> writers_;
+  std::unique_ptr<TracingController> tracing_controller_;
+
+  // Variables related to initializing per-event-loop properties of individual
+  // writers, such as libuv handles.
+  Mutex initialize_writer_mutex_;
+  ConditionVariable initialize_writer_condvar_;
+  uv_async_t initialize_writer_async_;
+  std::set<AsyncTraceWriter*> to_be_initialized_;
+
+  Mutex metadata_events_mutex_;
+  std::list<std::unique_ptr<TraceObject>> metadata_events_;
+};
+
+void AgentWriterHandle::reset() {
+  if (agent_ != nullptr)
+    agent_->Disconnect(id_);
+  agent_ = nullptr;
+}
+
+AgentWriterHandle& AgentWriterHandle::operator=(AgentWriterHandle&& other) {
+  reset();
+  agent_ = other.agent_;
+  id_ = other.id_;
+  other.agent_ = nullptr;
+  return *this;
+}
+
+AgentWriterHandle::AgentWriterHandle(AgentWriterHandle&& other) {
+  *this = std::move(other);
+}
+
+void AgentWriterHandle::Enable(const std::set<std::string>& categories) {
+  if (agent_ != nullptr) agent_->Enable(id_, categories);
+}
+
+void AgentWriterHandle::Disable(const std::set<std::string>& categories) {
+  if (agent_ != nullptr) agent_->Disable(id_, categories);
+}
+
+bool AgentWriterHandle::IsDefaultHandle() {
+  return agent_ != nullptr && id_ == Agent::kDefaultHandleId;
+}
+
+inline v8::TracingController* AgentWriterHandle::GetTracingController() {
+  return agent_ != nullptr ? agent_->GetTracingController() : nullptr;
+}
+
+}  // namespace tracing
+}  // namespace node
+
+#endif  // SRC_TRACING_AGENT_H_

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

@@ -0,0 +1,244 @@
+#ifndef SRC_ALIASED_BUFFER_INL_H_
+#define SRC_ALIASED_BUFFER_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_buffer.h"
+#include "memory_tracker-inl.h"
+#include "util-inl.h"
+
+namespace node {
+
+typedef size_t AliasedBufferIndex;
+
+template <typename NativeT, typename V8T>
+AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
+    v8::Isolate* isolate, const size_t count, const AliasedBufferIndex* index)
+    : isolate_(isolate), count_(count), byte_offset_(0), index_(index) {
+  CHECK_GT(count, 0);
+  if (index != nullptr) {
+    // Will be deserialized later.
+    return;
+  }
+  const v8::HandleScope handle_scope(isolate_);
+  const size_t size_in_bytes =
+      MultiplyWithOverflowCheck(sizeof(NativeT), count);
+
+  // allocate v8 ArrayBuffer
+  v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate_, size_in_bytes);
+  buffer_ = static_cast<NativeT*>(ab->Data());
+
+  // allocate v8 TypedArray
+  v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
+  js_array_ = v8::Global<V8T>(isolate, js_array);
+}
+
+template <typename NativeT, typename V8T>
+AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
+    v8::Isolate* isolate,
+    const size_t byte_offset,
+    const size_t count,
+    const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer,
+    const AliasedBufferIndex* index)
+    : isolate_(isolate),
+      count_(count),
+      byte_offset_(byte_offset),
+      index_(index) {
+  if (index != nullptr) {
+    // Will be deserialized later.
+    return;
+  }
+  const v8::HandleScope handle_scope(isolate_);
+  v8::Local<v8::ArrayBuffer> ab = backing_buffer.GetArrayBuffer();
+
+  // validate that the byte_offset is aligned with sizeof(NativeT)
+  CHECK_EQ(byte_offset & (sizeof(NativeT) - 1), 0);
+  // validate this fits inside the backing buffer
+  CHECK_LE(MultiplyWithOverflowCheck(sizeof(NativeT), count),
+           ab->ByteLength() - byte_offset);
+
+  buffer_ = reinterpret_cast<NativeT*>(
+      const_cast<uint8_t*>(backing_buffer.GetNativeBuffer() + byte_offset));
+
+  v8::Local<V8T> js_array = V8T::New(ab, byte_offset, count);
+  js_array_ = v8::Global<V8T>(isolate, js_array);
+}
+
+template <typename NativeT, typename V8T>
+AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
+    const AliasedBufferBase& that)
+    : isolate_(that.isolate_),
+      count_(that.count_),
+      byte_offset_(that.byte_offset_),
+      buffer_(that.buffer_) {
+  js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
+  DCHECK(is_valid());
+}
+
+template <typename NativeT, typename V8T>
+AliasedBufferIndex AliasedBufferBase<NativeT, V8T>::Serialize(
+    v8::Local<v8::Context> context, v8::SnapshotCreator* creator) {
+  DCHECK(is_valid());
+  return creator->AddData(context, GetJSArray());
+}
+
+template <typename NativeT, typename V8T>
+inline void AliasedBufferBase<NativeT, V8T>::Deserialize(
+    v8::Local<v8::Context> context) {
+  DCHECK_NOT_NULL(index_);
+  v8::Local<V8T> arr =
+      context->GetDataFromSnapshotOnce<V8T>(*index_).ToLocalChecked();
+  // These may not hold true for AliasedBuffers that have grown, so should
+  // be removed when we expand the snapshot support.
+  DCHECK_EQ(count_, arr->Length());
+  DCHECK_EQ(byte_offset_, arr->ByteOffset());
+  uint8_t* raw = static_cast<uint8_t*>(arr->Buffer()->Data());
+  buffer_ = reinterpret_cast<NativeT*>(raw + byte_offset_);
+  js_array_.Reset(isolate_, arr);
+  index_ = nullptr;
+}
+
+template <typename NativeT, typename V8T>
+AliasedBufferBase<NativeT, V8T>& AliasedBufferBase<NativeT, V8T>::operator=(
+    AliasedBufferBase<NativeT, V8T>&& that) noexcept {
+  DCHECK(is_valid());
+  this->~AliasedBufferBase();
+  isolate_ = that.isolate_;
+  count_ = that.count_;
+  byte_offset_ = that.byte_offset_;
+  buffer_ = that.buffer_;
+
+  js_array_.Reset(isolate_, that.js_array_.Get(isolate_));
+
+  that.buffer_ = nullptr;
+  that.js_array_.Reset();
+  return *this;
+}
+
+template <typename NativeT, typename V8T>
+v8::Local<V8T> AliasedBufferBase<NativeT, V8T>::GetJSArray() const {
+  DCHECK(is_valid());
+  return js_array_.Get(isolate_);
+}
+
+template <typename NativeT, typename V8T>
+void AliasedBufferBase<NativeT, V8T>::Release() {
+  DCHECK_NULL(index_);
+  js_array_.Reset();
+}
+
+template <typename NativeT, typename V8T>
+inline void AliasedBufferBase<NativeT, V8T>::MakeWeak() {
+  DCHECK(is_valid());
+  js_array_.SetWeak();
+}
+
+template <typename NativeT, typename V8T>
+v8::Local<v8::ArrayBuffer> AliasedBufferBase<NativeT, V8T>::GetArrayBuffer()
+    const {
+  return GetJSArray()->Buffer();
+}
+
+template <typename NativeT, typename V8T>
+inline const NativeT* AliasedBufferBase<NativeT, V8T>::GetNativeBuffer() const {
+  DCHECK(is_valid());
+  return buffer_;
+}
+
+template <typename NativeT, typename V8T>
+inline const NativeT* AliasedBufferBase<NativeT, V8T>::operator*() const {
+  return GetNativeBuffer();
+}
+
+template <typename NativeT, typename V8T>
+inline void AliasedBufferBase<NativeT, V8T>::SetValue(const size_t index,
+                                                      NativeT value) {
+  DCHECK_LT(index, count_);
+  DCHECK(is_valid());
+  buffer_[index] = value;
+}
+
+template <typename NativeT, typename V8T>
+inline const NativeT AliasedBufferBase<NativeT, V8T>::GetValue(
+    const size_t index) const {
+  DCHECK(is_valid());
+  DCHECK_LT(index, count_);
+  return buffer_[index];
+}
+
+template <typename NativeT, typename V8T>
+typename AliasedBufferBase<NativeT, V8T>::Reference
+AliasedBufferBase<NativeT, V8T>::operator[](size_t index) {
+  DCHECK(is_valid());
+  return Reference(this, index);
+}
+
+template <typename NativeT, typename V8T>
+NativeT AliasedBufferBase<NativeT, V8T>::operator[](size_t index) const {
+  return GetValue(index);
+}
+
+template <typename NativeT, typename V8T>
+size_t AliasedBufferBase<NativeT, V8T>::Length() const {
+  return count_;
+}
+
+template <typename NativeT, typename V8T>
+void AliasedBufferBase<NativeT, V8T>::reserve(size_t new_capacity) {
+  DCHECK(is_valid());
+  DCHECK_GE(new_capacity, count_);
+  DCHECK_EQ(byte_offset_, 0);
+  const v8::HandleScope handle_scope(isolate_);
+
+  const size_t old_size_in_bytes = sizeof(NativeT) * count_;
+  const size_t new_size_in_bytes =
+      MultiplyWithOverflowCheck(sizeof(NativeT), new_capacity);
+
+  // allocate v8 new ArrayBuffer
+  v8::Local<v8::ArrayBuffer> ab =
+      v8::ArrayBuffer::New(isolate_, new_size_in_bytes);
+
+  // allocate new native buffer
+  NativeT* new_buffer = static_cast<NativeT*>(ab->Data());
+  // copy old content
+  memcpy(new_buffer, buffer_, old_size_in_bytes);
+
+  // allocate v8 TypedArray
+  v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, new_capacity);
+
+  // move over old v8 TypedArray
+  js_array_ = std::move(v8::Global<V8T>(isolate_, js_array));
+
+  buffer_ = new_buffer;
+  count_ = new_capacity;
+}
+
+template <typename NativeT, typename V8T>
+inline bool AliasedBufferBase<NativeT, V8T>::is_valid() const {
+  return index_ == nullptr && !js_array_.IsEmpty();
+}
+
+template <typename NativeT, typename V8T>
+inline size_t AliasedBufferBase<NativeT, V8T>::SelfSize() const {
+  return sizeof(*this);
+}
+
+#define VM(NativeT, V8T)                                                       \
+  template <>                                                                  \
+  inline const char* AliasedBufferBase<NativeT, v8::V8T>::MemoryInfoName()     \
+      const {                                                                  \
+    return "Aliased" #V8T;                                                     \
+  }                                                                            \
+  template <>                                                                  \
+  inline void AliasedBufferBase<NativeT, v8::V8T>::MemoryInfo(                 \
+      node::MemoryTracker* tracker) const {                                    \
+    tracker->TrackField("js_array", js_array_);                                \
+  }
+ALIASED_BUFFER_LIST(VM)
+#undef VM
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ALIASED_BUFFER_INL_H_