@encharm/cws 4.1.0 → 4.2.0

package/package.json

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

package/src/Addon.h

@@ -32,8 +32,13 @@
   #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
+
 using BaseObject = node::BaseObject;
-#if NODE_MAJOR_VERSION==16
+#if NODE_MAJOR_VERSION==16 || NODE_MAJOR_VERSION==18
 using TLSWrap = node::crypto::TLSWrap;
 #else
 using TLSWrap = node::TLSWrap;
@@ -125,14 +130,26 @@ class NativeString {
     } else if (value->IsTypedArray()) {
       Local<ArrayBufferView> arrayBufferView =
           Local<ArrayBufferView>::Cast(value);
+#if NODE_MAJOR_VERSION == 18
+      std::shared_ptr<v8::BackingStore> contents = arrayBufferView->Buffer()->GetBackingStore();
+      length = arrayBufferView->ByteLength();
+      data = (char *)contents->Data();
+#else
       ArrayBuffer::Contents contents = arrayBufferView->Buffer()->GetContents();
       length = contents.ByteLength();
       data = (char *)contents.Data();
+#endif
     } else if (value->IsArrayBuffer()) {
       Local<ArrayBuffer> arrayBuffer = Local<ArrayBuffer>::Cast(value);
+#if NODE_MAJOR_VERSION == 18
+      std::shared_ptr<v8::BackingStore> contents = arrayBuffer->GetBackingStore();
+      length = arrayBuffer->ByteLength();
+      data = (char *)contents->Data();
+#else
       ArrayBuffer::Contents contents = arrayBuffer->GetContents();
       length = contents.ByteLength();
       data = (char *)contents.Data();
+#endif
     } else {
       static char empty[] = "";
       data = empty;
@@ -187,7 +204,12 @@ inline Local<Value> wrapMessage(const char *message, size_t length,
                                 cWS::OpCode opCode, Isolate *isolate) {
 
   if (opCode == cWS::OpCode::BINARY) {
-    return (Local<Value>)ArrayBuffer::New(isolate, (char *)message, length);
+    // return (Local<Value>)ArrayBuffer::New(isolate, (char *)message, length);
+    std::unique_ptr<v8::BackingStore> backing = v8::ArrayBuffer::NewBackingStore((char*)message,
+                                       length,
+                                       [](void*, size_t, void*){},
+                                       nullptr);
+    return (Local<Value>)v8::ArrayBuffer::New(isolate, std::move(backing));
   }
 
   #if NODE_MAJOR_VERSION >= 13

package/src/HTTPSocket.cpp

@@ -247,7 +247,7 @@ void HttpSocket<isServer>::upgrade(const char *secKey, const char *extensions, s
             memcpy(upgradeBuffer + upgradeResponseLength + 24 + subprotocolLength, "\r\n", 2);
             upgradeResponseLength += 24 + subprotocolLength + 2;
         }
-        static char stamp[] = "Sec-WebSocket-Version: 13\r\nWebSocket-Server: cWebSockets\r\n\r\n";
+        static char stamp[] = "Sec-WebSocket-Version: 13\r\n\r\n";
         memcpy(upgradeBuffer + upgradeResponseLength, stamp, sizeof(stamp) - 1);
         upgradeResponseLength += sizeof(stamp) - 1;
 

package/src/headers/{13 → 18}/aliased_buffer.h

@@ -9,6 +9,8 @@
 
 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.
@@ -32,9 +34,15 @@ template <class NativeT,
           typename = std::enable_if_t<std::is_scalar<NativeT>::value>>
 class AliasedBufferBase {
  public:
-  AliasedBufferBase(v8::Isolate* isolate, const size_t count)
-      : isolate_(isolate), count_(count), byte_offset_(0) {
+  AliasedBufferBase(v8::Isolate* isolate,
+                    const size_t count,
+                    const AliasedBufferIndex* index = nullptr)
+      : 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);
@@ -62,10 +70,17 @@ class AliasedBufferBase {
       v8::Isolate* isolate,
       const size_t byte_offset,
       const size_t count,
-      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer)
-      : isolate_(isolate), count_(count), byte_offset_(byte_offset) {
+      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer,
+      const AliasedBufferIndex* index = nullptr)
+      : 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)
@@ -86,10 +101,33 @@ class AliasedBufferBase {
         count_(that.count_),
         byte_offset_(that.byte_offset_),
         buffer_(that.buffer_) {
+    DCHECK_NULL(index_);
     js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
   }
 
+  AliasedBufferIndex Serialize(v8::Local<v8::Context> context,
+                              v8::SnapshotCreator* creator) {
+    DCHECK_NULL(index_);
+    return creator->AddData(context, GetJSArray());
+  }
+
+  inline void 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()->GetBackingStore()->Data());
+    buffer_ = reinterpret_cast<NativeT*>(raw + byte_offset_);
+    js_array_.Reset(isolate_, arr);
+    index_ = nullptr;
+  }
+
   AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept {
+    DCHECK_NULL(index_);
     this->~AliasedBufferBase();
     isolate_ = that.isolate_;
     count_ = that.count_;
@@ -155,9 +193,15 @@ class AliasedBufferBase {
    *  Get the underlying v8 TypedArray overlayed on top of the native buffer
    */
   v8::Local<V8T> GetJSArray() const {
+    DCHECK_NULL(index_);
     return js_array_.Get(isolate_);
   }
 
+  void Release() {
+    DCHECK_NULL(index_);
+    js_array_.Reset();
+  }
+
   /**
   *  Get the underlying v8::ArrayBuffer underlying the TypedArray and
   *  overlaying the native buffer
@@ -171,6 +215,7 @@ class AliasedBufferBase {
    *  through the GetValue/SetValue/operator[] methods
    */
   inline const NativeT* GetNativeBuffer() const {
+    DCHECK_NULL(index_);
     return buffer_;
   }
 
@@ -186,6 +231,7 @@ class AliasedBufferBase {
    */
   inline void SetValue(const size_t index, NativeT value) {
     DCHECK_LT(index, count_);
+    DCHECK_NULL(index_);
     buffer_[index] = value;
   }
 
@@ -193,6 +239,7 @@ class AliasedBufferBase {
    *  Get value at position index
    */
   inline const NativeT GetValue(const size_t index) const {
+    DCHECK_NULL(index_);
     DCHECK_LT(index, count_);
     return buffer_[index];
   }
@@ -201,6 +248,7 @@ class AliasedBufferBase {
    *  Effectively, a synonym for GetValue/SetValue
    */
   Reference operator[](size_t index) {
+    DCHECK_NULL(index_);
     return Reference(this, index);
   }
 
@@ -216,6 +264,7 @@ class AliasedBufferBase {
   // 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) {
+    DCHECK_NULL(index_);
     DCHECK_GE(new_capacity, count_);
     DCHECK_EQ(byte_offset_, 0);
     const v8::HandleScope handle_scope(isolate_);
@@ -244,11 +293,14 @@ class AliasedBufferBase {
   }
 
  private:
-  v8::Isolate* isolate_;
-  size_t count_;
-  size_t byte_offset_;
-  NativeT* buffer_;
+  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;
 };
 
 typedef AliasedBufferBase<int32_t, v8::Int32Array> AliasedInt32Array;

package/src/headers/18/aliased_struct-inl.h

@@ -0,0 +1,54 @@
+#ifndef SRC_ALIASED_STRUCT_INL_H_
+#define SRC_ALIASED_STRUCT_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_struct.h"
+#include "v8.h"
+#include <memory>
+
+namespace node {
+
+template <typename T>
+template <typename... Args>
+AliasedStruct<T>::AliasedStruct(v8::Isolate* isolate, Args&&... args)
+    : isolate_(isolate) {
+  const v8::HandleScope handle_scope(isolate);
+
+  store_ = v8::ArrayBuffer::NewBackingStore(isolate, sizeof(T));
+  ptr_ = new (store_->Data()) T(std::forward<Args>(args)...);
+  DCHECK_NOT_NULL(ptr_);
+
+  v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, store_);
+  buffer_ = v8::Global<v8::ArrayBuffer>(isolate, buffer);
+}
+
+template <typename T>
+AliasedStruct<T>::AliasedStruct(const AliasedStruct& that)
+    : AliasedStruct(that.isolate_, *that) {}
+
+template <typename T>
+AliasedStruct<T>& AliasedStruct<T>::operator=(
+    AliasedStruct<T>&& that) noexcept {
+  this->~AliasedStruct();
+  isolate_ = that.isolate_;
+  store_ = that.store_;
+  ptr_ = that.ptr_;
+
+  buffer_ = std::move(that.buffer_);
+
+  that.ptr_ = nullptr;
+  that.store_.reset();
+  return *this;
+}
+
+template <typename T>
+AliasedStruct<T>::~AliasedStruct() {
+  if (ptr_ != nullptr) ptr_->~T();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ALIASED_STRUCT_INL_H_

package/src/headers/18/aliased_struct.h

@@ -0,0 +1,63 @@
+#ifndef SRC_ALIASED_STRUCT_H_
+#define SRC_ALIASED_STRUCT_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+#include "v8.h"
+#include <memory>
+
+namespace node {
+
+// AliasedStruct is a utility that allows uses a V8 Backing Store
+// to be exposed to the C++/C side as a struct and to the
+// JavaScript side as an ArrayBuffer to efficiently share
+// data without marshalling. It is similar in nature to
+// AliasedBuffer.
+//
+//   struct Foo { int x; }
+//
+//   AliasedStruct<Foo> foo;
+//   foo->x = 1;
+//
+//   Local<ArrayBuffer> ab = foo.GetArrayBuffer();
+template <typename T>
+class AliasedStruct final {
+ public:
+  template <typename... Args>
+  explicit AliasedStruct(v8::Isolate* isolate, Args&&... args);
+
+  inline AliasedStruct(const AliasedStruct& that);
+
+  inline ~AliasedStruct();
+
+  inline AliasedStruct& operator=(AliasedStruct&& that) noexcept;
+
+  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const {
+    return buffer_.Get(isolate_);
+  }
+
+  const T* Data() const { return ptr_; }
+
+  T* Data() { return ptr_; }
+
+  const T& operator*() const { return *ptr_; }
+
+  T& operator*()  { return *ptr_; }
+
+  const T* operator->() const { return ptr_; }
+
+  T* operator->() { return ptr_; }
+
+ private:
+  v8::Isolate* isolate_;
+  std::shared_ptr<v8::BackingStore> store_;
+  T* ptr_;
+  v8::Global<v8::ArrayBuffer> buffer_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ALIASED_STRUCT_H_

package/src/headers/{12 → 18}/async_wrap.h

@@ -38,6 +38,7 @@ namespace node {
   V(ELDHISTOGRAM)                                                             \
   V(FILEHANDLE)                                                               \
   V(FILEHANDLECLOSEREQ)                                                       \
+  V(FIXEDSIZEBLOBCOPY)                                                        \
   V(FSEVENTWRAP)                                                              \
   V(FSREQCALLBACK)                                                            \
   V(FSREQPROMISE)                                                             \
@@ -51,6 +52,7 @@ namespace node {
   V(HTTPINCOMINGMESSAGE)                                                      \
   V(HTTPCLIENTREQUEST)                                                        \
   V(JSSTREAM)                                                                 \
+  V(JSUDPWRAP)                                                                \
   V(MESSAGEPORT)                                                              \
   V(PIPECONNECTWRAP)                                                          \
   V(PIPESERVERWRAP)                                                           \
@@ -76,11 +78,20 @@ namespace node {
 
 #if HAVE_OPENSSL
 #define NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)                                   \
+  V(CHECKPRIMEREQUEST)                                                        \
   V(PBKDF2REQUEST)                                                            \
   V(KEYPAIRGENREQUEST)                                                        \
+  V(KEYGENREQUEST)                                                            \
+  V(KEYEXPORTREQUEST)                                                         \
+  V(CIPHERREQUEST)                                                            \
+  V(DERIVEBITSREQUEST)                                                        \
+  V(HASHREQUEST)                                                              \
   V(RANDOMBYTESREQUEST)                                                       \
+  V(RANDOMPRIMEREQUEST)                                                       \
   V(SCRYPTREQUEST)                                                            \
-  V(TLSWRAP)
+  V(SIGNREQUEST)                                                              \
+  V(TLSWRAP)                                                                  \
+  V(VERIFYREQUEST)
 #else
 #define NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)
 #endif  // HAVE_OPENSSL
@@ -99,6 +110,7 @@ namespace node {
 
 class Environment;
 class DestroyParam;
+class ExternalReferenceRegistry;
 
 class AsyncWrap : public BaseObject {
  public:
@@ -128,6 +140,7 @@ class AsyncWrap : public BaseObject {
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);
 
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
   static void Initialize(v8::Local<v8::Object> target,
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context,
@@ -136,10 +149,16 @@ class AsyncWrap : public BaseObject {
   static void GetAsyncId(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void PushAsyncContext(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void PopAsyncContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ExecutionAsyncResource(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ClearAsyncIdStack(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   static void AsyncReset(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetProviderType(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void QueueDestroyAsyncId(
     const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetCallbackTrampoline(
+    const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void EmitAsyncInit(Environment* env,
                             v8::Local<v8::Object> object,
@@ -208,11 +227,16 @@ class AsyncWrap : public BaseObject {
             ProviderType provider,
             double execution_async_id,
             bool silent);
+  AsyncWrap(Environment* env,
+            v8::Local<v8::Object> promise,
+            ProviderType provider,
+            double execution_async_id,
+            double trigger_async_id);
   ProviderType provider_type_ = PROVIDER_NONE;
   bool init_hook_ran_ = false;
   // Because the values may be Reset(), cannot be made const.
   double async_id_ = kInvalidAsyncId;
-  double trigger_async_id_;
+  double trigger_async_id_ = kInvalidAsyncId;
 };
 
 }  // namespace node