@encharm/cws 4.4.1 → 4.5.1

package/package.json

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

package/src/Addon.h

@@ -1,4 +1,4 @@
-#define NODE_API_DEFAULT_MODULE_API_VERSION 115
+#define NODE_API_DEFAULT_MODULE_API_VERSION 127
 
 #include <node.h>
 #include <node_buffer.h>
@@ -7,38 +7,23 @@
 #include <uv.h>
 #include <cstring>
 
-// TODO: remove below
-#if NODE_MAJOR_VERSION>=10
 #define NODE_WANT_INTERNALS 1
 
-#if NODE_MAJOR_VERSION==14
-  #include "headers/14/tls_wrap.h"
-  #include "headers/14/base_object-inl.h"
-#endif
-
-#if NODE_MAJOR_VERSION==16
-  #include "headers/16/crypto/crypto_tls.h"
-  #include "headers/16/base_object-inl.h"
-#endif
-
-#if NODE_MAJOR_VERSION==18
-  #include "headers/18/crypto/crypto_tls.h"
-  #include "headers/18/base_object-inl.h"
-#endif
-
 #if NODE_MAJOR_VERSION==20
   #include "headers/20/crypto/crypto_tls.h"
   #include "headers/20/base_object-inl.h"
 #endif
 
+#if NODE_MAJOR_VERSION==22
+  #include "headers/22/crypto/crypto_tls.h"
+  #include "headers/22/base_object-inl.h"
+#endif
+
 #include <tcp_wrap.h>
 
 using BaseObject = node::BaseObject;
-#if NODE_MAJOR_VERSION==16 || NODE_MAJOR_VERSION==18 || NODE_MAJOR_VERSION==20
 using TLSWrap = node::crypto::TLSWrap;
-#else
-using TLSWrap = node::TLSWrap;
-#endif
+
 class TLSWrapSSLGetter : public TLSWrap {
 public:
     void setSSL(const v8::FunctionCallbackInfo<v8::Value> &info){
@@ -67,7 +52,7 @@ public:
 #endif
 
  #undef NODE_WANT_INTERNALS
-#endif
+
 
 using namespace std;
 using namespace v8;

package/src/Socket.h

@@ -407,7 +407,6 @@ protected:
                 }
             }
         } else {
-            printf("Enqueue\n");
             Queue::Message *messagePtr = allocMessage(estimatedLength - sizeof(Queue::Message));
             messagePtr->length = T::transform(message, (char *) messagePtr->data, length, transformData);
             messagePtr->callback = callback;

package/src/headers/22/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.14.0"
+#endif  // SRC_ACORN_VERSION_H_

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

@@ -0,0 +1,243 @@
+#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 "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_

package/src/headers/22/aliased_buffer.h

@@ -0,0 +1,206 @@
+#ifndef SRC_ALIASED_BUFFER_H_
+#define SRC_ALIASED_BUFFER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "memory_tracker.h"
+#include "v8.h"
+
+namespace node {
+
+typedef size_t AliasedBufferIndex;
+
+/**
+ * Do not use this class directly when creating instances of it - use the
+ * Aliased*Array defined at the end of this file instead.
+ *
+ * This class encapsulates the technique of having a native buffer mapped to
+ * a JS object. Writes to the native buffer can happen efficiently without
+ * going through JS, and the data is then available to user's via the exposed
+ * JS object.
+ *
+ * While this technique is computationally efficient, it is effectively a
+ * write to JS program state w/out going through the standard
+ * (monitored) API. Thus any VM capabilities to detect the modification are
+ * circumvented.
+ *
+ * The encapsulation herein provides a placeholder where such writes can be
+ * observed. Any notification APIs will be left as a future exercise.
+ */
+template <class NativeT, class V8T>
+class AliasedBufferBase : public MemoryRetainer {
+ public:
+  static_assert(std::is_scalar<NativeT>::value);
+
+  AliasedBufferBase(v8::Isolate* isolate,
+                    const size_t count,
+                    const AliasedBufferIndex* index = nullptr);
+
+  /**
+   * Create an AliasedBufferBase over a sub-region of another aliased buffer.
+   * The two will share a v8::ArrayBuffer instance &
+   * a native buffer, but will each read/write to different sections of the
+   * native buffer.
+   *
+   *  Note that byte_offset must by aligned by sizeof(NativeT).
+   */
+  // TODO(refack): refactor into a non-owning `AliasedBufferBaseView`
+  AliasedBufferBase(
+      v8::Isolate* isolate,
+      const size_t byte_offset,
+      const size_t count,
+      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer,
+      const AliasedBufferIndex* index = nullptr);
+
+  AliasedBufferBase(const AliasedBufferBase& that);
+
+  AliasedBufferIndex Serialize(v8::Local<v8::Context> context,
+                               v8::SnapshotCreator* creator);
+
+  inline void Deserialize(v8::Local<v8::Context> context);
+
+  AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept;
+
+  /**
+   * Helper class that is returned from operator[] to support assignment into
+   * a specified location.
+   */
+  class Reference {
+   public:
+    Reference(AliasedBufferBase<NativeT, V8T>* aliased_buffer, size_t index)
+        : aliased_buffer_(aliased_buffer), index_(index) {}
+
+    Reference(const Reference& that)
+        : aliased_buffer_(that.aliased_buffer_),
+          index_(that.index_) {
+    }
+
+    inline Reference& operator=(const NativeT& val) {
+      aliased_buffer_->SetValue(index_, val);
+      return *this;
+    }
+
+    inline Reference& operator=(const Reference& val) {
+      return *this = static_cast<NativeT>(val);
+    }
+
+    operator NativeT() const {
+      return aliased_buffer_->GetValue(index_);
+    }
+
+    inline Reference& operator+=(const NativeT& val) {
+      const NativeT current = aliased_buffer_->GetValue(index_);
+      aliased_buffer_->SetValue(index_, current + val);
+      return *this;
+    }
+
+    inline Reference& operator+=(const Reference& val) {
+      return this->operator+=(static_cast<NativeT>(val));
+    }
+
+    inline Reference& operator-=(const NativeT& val) {
+      const NativeT current = aliased_buffer_->GetValue(index_);
+      aliased_buffer_->SetValue(index_, current - val);
+      return *this;
+    }
+
+   private:
+    AliasedBufferBase<NativeT, V8T>* aliased_buffer_;
+    size_t index_;
+  };
+
+  /**
+   *  Get the underlying v8 TypedArray overlaid on top of the native buffer
+   */
+  v8::Local<V8T> GetJSArray() const;
+
+  void Release();
+
+  /**
+   * Make the global reference to the typed array weak. The caller must make
+   * sure that no operation can be done on the AliasedBuffer when the typed
+   * array becomes unreachable. Usually this means the caller must maintain
+   * a JS reference to the typed array from JS object.
+   */
+  inline void MakeWeak();
+
+  /**
+  *  Get the underlying v8::ArrayBuffer underlying the TypedArray and
+  *  overlaying the native buffer
+  */
+  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const;
+
+  /**
+   *  Get the underlying native buffer. Note that all reads/writes should occur
+   *  through the GetValue/SetValue/operator[] methods
+   */
+  inline const NativeT* GetNativeBuffer() const;
+
+  /**
+   *  Synonym for GetBuffer()
+   */
+  inline const NativeT* operator*() const;
+
+  /**
+   *  Set position index to given value.
+   */
+  inline void SetValue(const size_t index, NativeT value);
+
+  /**
+   *  Get value at position index
+   */
+  inline const NativeT GetValue(const size_t index) const;
+
+  /**
+   *  Effectively, a synonym for GetValue/SetValue
+   */
+  Reference operator[](size_t index);
+
+  NativeT operator[](size_t index) const;
+
+  size_t Length() const;
+
+  // Should only be used to extend the array.
+  // Should only be used on an owning array, not one created as a sub array of
+  // an owning `AliasedBufferBase`.
+  void reserve(size_t new_capacity);
+
+  inline size_t SelfSize() const override;
+
+  inline const char* MemoryInfoName() const override;
+  inline void MemoryInfo(node::MemoryTracker* tracker) const override;
+
+ private:
+  inline bool is_valid() const;
+  v8::Isolate* isolate_ = nullptr;
+  size_t count_ = 0;
+  size_t byte_offset_ = 0;
+  NativeT* buffer_ = nullptr;
+  v8::Global<V8T> js_array_;
+
+  // Deserialize data
+  const AliasedBufferIndex* index_ = nullptr;
+};
+
+#define ALIASED_BUFFER_LIST(V)                                                 \
+  V(int8_t, Int8Array)                                                         \
+  V(uint8_t, Uint8Array)                                                       \
+  V(int16_t, Int16Array)                                                       \
+  V(uint16_t, Uint16Array)                                                     \
+  V(int32_t, Int32Array)                                                       \
+  V(uint32_t, Uint32Array)                                                     \
+  V(float, Float32Array)                                                       \
+  V(double, Float64Array)                                                      \
+  V(int64_t, BigInt64Array)
+
+#define V(NativeT, V8T)                                                        \
+  typedef AliasedBufferBase<NativeT, v8::V8T> Aliased##V8T;
+ALIASED_BUFFER_LIST(V)
+#undef V
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ALIASED_BUFFER_H_

package/src/headers/{18 → 22}/async_wrap-inl.h

@@ -49,6 +49,9 @@ inline double AsyncWrap::get_trigger_async_id() const {
   return trigger_async_id_;
 }
 
+inline v8::Local<v8::Value> AsyncWrap::context_frame() const {
+  return context_frame_.Get(env()->isolate());
+}
 
 inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
     const v8::Local<v8::String> symbol,
@@ -80,12 +83,11 @@ inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
   return MakeCallback(cb_v.As<v8::Function>(), argc, argv);
 }
 
-
-// Defined here to avoid a circular dependency with env-inl.h.
-inline AsyncHooks::DefaultTriggerAsyncIdScope ::DefaultTriggerAsyncIdScope(
-    AsyncWrap* async_wrap)
-    : DefaultTriggerAsyncIdScope(async_wrap->env(),
-                                 async_wrap->get_async_id()) {}
+// static
+inline v8::Local<v8::FunctionTemplate> AsyncWrap::GetConstructorTemplate(
+    Environment* env) {
+  return GetConstructorTemplate(env->isolate_data());
+}
 
 }  // namespace node