@encharm/cws 4.1.0 → 4.2.0

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

@@ -5,6 +5,8 @@
 
 #include "aliased_buffer.h"
 
+struct nghttp2_rcbuf;
+
 namespace node {
 namespace http2 {
 
@@ -56,13 +58,6 @@ namespace http2 {
     IDX_OPTIONS_FLAGS
   };
 
-  enum Http2PaddingBufferFields {
-    PADDING_BUF_FRAME_LENGTH,
-    PADDING_BUF_MAX_PAYLOAD_LENGTH,
-    PADDING_BUF_RETURN_VALUE,
-    PADDING_BUF_FIELD_COUNT
-  };
-
   enum Http2StreamStatisticsIndex {
     IDX_STREAM_STATS_ID,
     IDX_STREAM_STATS_TIMETOFIRSTBYTE,
@@ -86,58 +81,54 @@ namespace http2 {
     IDX_SESSION_STATS_COUNT
   };
 
-class Http2State {
+class Http2State : public BaseObject {
  public:
-  explicit Http2State(v8::Isolate* isolate) :
-    root_buffer(
-      isolate,
-      sizeof(http2_state_internal)),
-    session_state_buffer(
-      isolate,
-      offsetof(http2_state_internal, session_state_buffer),
-      IDX_SESSION_STATE_COUNT,
-      root_buffer),
-    stream_state_buffer(
-      isolate,
-      offsetof(http2_state_internal, stream_state_buffer),
-      IDX_STREAM_STATE_COUNT,
-      root_buffer),
-    stream_stats_buffer(
-      isolate,
-      offsetof(http2_state_internal, stream_stats_buffer),
-      IDX_STREAM_STATS_COUNT,
-      root_buffer),
-    session_stats_buffer(
-      isolate,
-      offsetof(http2_state_internal, session_stats_buffer),
-      IDX_SESSION_STATS_COUNT,
-      root_buffer),
-    padding_buffer(
-      isolate,
-      offsetof(http2_state_internal, padding_buffer),
-      PADDING_BUF_FIELD_COUNT,
-      root_buffer),
-    options_buffer(
-      isolate,
-      offsetof(http2_state_internal, options_buffer),
-      IDX_OPTIONS_FLAGS + 1,
-      root_buffer),
-    settings_buffer(
-      isolate,
-      offsetof(http2_state_internal, settings_buffer),
-      IDX_SETTINGS_COUNT + 1,
-      root_buffer) {
-  }
+  Http2State(Environment* env, v8::Local<v8::Object> obj)
+      : BaseObject(env, obj),
+        root_buffer(env->isolate(), sizeof(http2_state_internal)),
+        session_state_buffer(
+            env->isolate(),
+            offsetof(http2_state_internal, session_state_buffer),
+            IDX_SESSION_STATE_COUNT,
+            root_buffer),
+        stream_state_buffer(
+            env->isolate(),
+            offsetof(http2_state_internal, stream_state_buffer),
+            IDX_STREAM_STATE_COUNT,
+            root_buffer),
+        stream_stats_buffer(
+            env->isolate(),
+            offsetof(http2_state_internal, stream_stats_buffer),
+            IDX_STREAM_STATS_COUNT,
+            root_buffer),
+        session_stats_buffer(
+            env->isolate(),
+            offsetof(http2_state_internal, session_stats_buffer),
+            IDX_SESSION_STATS_COUNT,
+            root_buffer),
+        options_buffer(env->isolate(),
+                        offsetof(http2_state_internal, options_buffer),
+                        IDX_OPTIONS_FLAGS + 1,
+                        root_buffer),
+        settings_buffer(env->isolate(),
+                        offsetof(http2_state_internal, settings_buffer),
+                        IDX_SETTINGS_COUNT + 1,
+                        root_buffer) {}
 
   AliasedUint8Array root_buffer;
   AliasedFloat64Array session_state_buffer;
   AliasedFloat64Array stream_state_buffer;
   AliasedFloat64Array stream_stats_buffer;
   AliasedFloat64Array session_stats_buffer;
-  AliasedUint32Array padding_buffer;
   AliasedUint32Array options_buffer;
   AliasedUint32Array settings_buffer;
 
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(Http2State)
+  SET_MEMORY_INFO_NAME(Http2State)
+
+  static constexpr FastStringKey type_name { "http2" };
+
  private:
   struct http2_state_internal {
     // doubles first so that they are always sizeof(double)-aligned
@@ -145,7 +136,6 @@ class Http2State {
     double stream_state_buffer[IDX_STREAM_STATE_COUNT];
     double stream_stats_buffer[IDX_STREAM_STATS_COUNT];
     double session_stats_buffer[IDX_SESSION_STATS_COUNT];
-    uint32_t padding_buffer[PADDING_BUF_FIELD_COUNT];
     uint32_t options_buffer[IDX_OPTIONS_FLAGS + 1];
     uint32_t settings_buffer[IDX_SETTINGS_COUNT + 1];
   };

package/src/headers/{13 → 18}/node_http_common-inl.h

@@ -31,8 +31,7 @@ NgHeaders<T>::NgHeaders(Environment* env, v8::Local<v8::Array> headers) {
                                  count_ * sizeof(nv_t) +
                                  header_string_len);
 
-  char* start = reinterpret_cast<char*>(
-      RoundUp(reinterpret_cast<uintptr_t>(*buf_), alignof(nv_t)));
+  char* start = AlignUp(buf_.out(), alignof(nv_t));
   char* header_contents = start + (count_ * sizeof(nv_t));
   nv_t* const nva = reinterpret_cast<nv_t*>(start);
 
@@ -56,13 +55,14 @@ NgHeaders<T>::NgHeaders(Environment* env, v8::Local<v8::Array> headers) {
       return;
     }
 
-    nva[n].flags = T::kNoneFlag;
     nva[n].name = reinterpret_cast<uint8_t*>(p);
     nva[n].namelen = strlen(p);
     p += nva[n].namelen + 1;
     nva[n].value = reinterpret_cast<uint8_t*>(p);
     nva[n].valuelen = strlen(p);
     p += nva[n].valuelen + 1;
+    nva[n].flags = *p;
+    p++;
   }
 }
 
@@ -76,6 +76,14 @@ size_t GetServerMaxHeaderPairs(size_t max_header_pairs) {
   return std::max(max_header_pairs, min_header_pairs);
 }
 
+template <typename allocator_t>
+std::string NgHeaderBase<allocator_t>::ToString() const {
+  std::string ret = name();
+  ret += " = ";
+  ret += value();
+  return ret;
+}
+
 template <typename T>
 bool NgHeader<T>::IsZeroLength(
     NgHeader<T>::rcbuf_t* name,
@@ -123,7 +131,8 @@ NgHeader<T>::NgHeader(
 
 template <typename T>
 NgHeader<T>::NgHeader(NgHeader<T>&& other) noexcept
-    : name_(std::move(other.name_)),
+    : env_(other.env_),
+      name_(std::move(other.name_)),
       value_(std::move(other.value_)),
       token_(other.token_),
       flags_(other.flags_) {
@@ -132,6 +141,12 @@ NgHeader<T>::NgHeader(NgHeader<T>&& other) noexcept
   other.env_ = nullptr;
 }
 
+template <typename T>
+void NgHeader<T>::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("name", name_);
+  tracker->TrackField("value", value_);
+}
+
 template <typename T>
 v8::MaybeLocal<v8::String> NgHeader<T>::GetName(
     NgHeader<T>::allocator_t* allocator) const {
@@ -143,7 +158,7 @@ v8::MaybeLocal<v8::String> NgHeader<T>::GetName(
   // If header_name is not nullptr, then it is a known header with
   // a statically defined name. We can safely internalize it here.
   if (header_name != nullptr) {
-    auto& static_str_map = env_->isolate_data()->http_static_strs;
+    auto& static_str_map = env_->isolate_data()->static_str_map;
     v8::Eternal<v8::String> eternal = static_str_map[header_name];
     if (eternal.IsEmpty()) {
       v8::Local<v8::String> str = OneByteString(env_->isolate(), header_name);
@@ -176,6 +191,11 @@ size_t NgHeader<T>::length() const {
   return name_.len() + value_.len();
 }
 
+template <typename T>
+uint8_t NgHeader<T>::flags() const {
+  return flags_;
+}
+
 }  // namespace node
 
 #endif  // SRC_NODE_HTTP_COMMON_INL_H_

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

@@ -196,7 +196,7 @@ enum http_status_codes {
 // Unlike the HTTP/1 implementation, the HTTP/2 implementation is not limited
 // to a fixed number of known supported HTTP methods. These constants, therefore
 // are provided strictly as a convenience to users and are exposed via the
-// require('http2').constants object.
+// require('node:http2').constants object.
 #define HTTP_KNOWN_METHODS(V)                                                 \
   V(ACL, "ACL")                                                               \
   V(BASELINE_CONTROL, "BASELINE-CONTROL")                                     \
@@ -270,7 +270,7 @@ class NgHeaders {
   MaybeStackBuffer<char, 3000> buf_;
 };
 
-// The ng libraries (nghttp2 and nghttp3) each use nearly identical
+// The ng libraries use nearly identical
 // reference counted structures for retaining header name and value
 // information in memory until the application is done with it.
 // The NgRcBufPointer is an intelligent pointer capable of working
@@ -409,7 +409,7 @@ class NgRcBufPointer : public MemoryRetainer {
         NgRcBufPointer<T> ptr) {
       Environment* env = allocator->env();
       if (ptr.IsStatic()) {
-        auto& static_str_map = env->isolate_data()->http_static_strs;
+        auto& static_str_map = env->isolate_data()->static_str_map;
         const char* header_name = reinterpret_cast<const char*>(ptr.data());
         v8::Eternal<v8::String>& eternal = static_str_map[header_name];
         if (eternal.IsEmpty()) {
@@ -453,6 +453,17 @@ class NgRcBufPointer : public MemoryRetainer {
   bool internalizable_ = false;
 };
 
+template <typename allocator_t>
+struct NgHeaderBase : public MemoryRetainer {
+  virtual v8::MaybeLocal<v8::String> GetName(allocator_t* allocator) const = 0;
+  virtual v8::MaybeLocal<v8::String> GetValue(allocator_t* allocator) const = 0;
+  virtual std::string name() const = 0;
+  virtual std::string value() const = 0;
+  virtual size_t length() const = 0;
+  virtual uint8_t flags() const = 0;
+  virtual std::string ToString() const;
+};
+
 // The ng libraries use nearly identical structs to represent
 // received http headers. The NgHeader class wraps those in a
 // consistent way and allows converting the name and value to
@@ -461,7 +472,7 @@ class NgRcBufPointer : public MemoryRetainer {
 // memory tracking, and implementation of static utility functions.
 // See Http2HeaderTraits in node_http2.h for an example.
 template <typename T>
-class NgHeader : public MemoryRetainer {
+class NgHeader final : public NgHeaderBase<typename T::allocator_t> {
  public:
   typedef typename T::rcbufferpointer_t rcbufferpointer_t;
   typedef typename T::rcbufferpointer_t::rcbuf_t rcbuf_t;
@@ -487,28 +498,21 @@ class NgHeader : public MemoryRetainer {
   // object to the v8 string. Once the v8 string is garbage collected,
   // the reference counter will be decremented.
 
-  inline v8::MaybeLocal<v8::String> GetName(allocator_t* allocator) const;
-  inline v8::MaybeLocal<v8::String> GetValue(allocator_t* allocator) const;
+  inline v8::MaybeLocal<v8::String> GetName(
+      allocator_t* allocator) const override;
+  inline v8::MaybeLocal<v8::String> GetValue(
+      allocator_t* allocator) const override;
 
-  inline std::string name() const;
-  inline std::string value() const;
-  inline size_t length() const;
+  inline std::string name() const override;
+  inline std::string value() const override;
+  inline size_t length() const override;
+  inline uint8_t flags() const override;
 
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("name", name_);
-    tracker->TrackField("value", value_);
-  }
+  void MemoryInfo(MemoryTracker* tracker) const override;
 
   SET_MEMORY_INFO_NAME(NgHeader)
   SET_SELF_SIZE(NgHeader)
 
-  std::string ToString() const {
-    std::string ret = name();
-    ret += " = ";
-    ret += value();
-    return ret;
-  }
-
  private:
   Environment* env_;
   rcbufferpointer_t name_;

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

@@ -36,11 +36,12 @@
 #include <string>
 
 namespace node {
-
 namespace i18n {
 
 bool InitializeICUDirectory(const std::string& path);
 
+void SetDefaultTimeZone(const char* tzid);
+
 enum idna_mode {
   // Default mode for maximum compatibility.
   IDNA_DEFAULT,

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

@@ -39,11 +39,6 @@
 #include <string>
 #include <vector>
 
-// Custom constants used by both node_constants.cc and node_zlib.cc
-#define Z_MIN_WINDOWBITS 8
-#define Z_MAX_WINDOWBITS 15
-#define Z_DEFAULT_WINDOWBITS 15
-
 struct sockaddr;
 
 namespace node {
@@ -55,7 +50,6 @@ class NativeModuleLoader;
 namespace per_process {
 extern Mutex env_var_mutex;
 extern uint64_t node_start_time;
-extern bool v8_is_profiling;
 }  // namespace per_process
 
 // Forward declaration
@@ -64,7 +58,7 @@ class Environment;
 // Convert a struct sockaddr to a { address: '1.2.3.4', port: 1234 } JS object.
 // Sets address and port properties on the info object and returns it.
 // If |info| is omitted, a new object is returned.
-v8::Local<v8::Object> AddressToJS(
+v8::MaybeLocal<v8::Object> AddressToJS(
     Environment* env,
     const sockaddr* addr,
     v8::Local<v8::Object> info = v8::Local<v8::Object>());
@@ -91,22 +85,15 @@ void PrintCaughtException(v8::Isolate* isolate,
                           const v8::TryCatch& try_catch);
 
 void ResetStdio();  // Safe to call more than once and from signal handlers.
-void SignalExit(int signo);
 #ifdef __POSIX__
-void RegisterSignalHandler(int signal,
-                           void (*handler)(int signal),
-                           bool reset_handler = false);
+void SignalExit(int signal, siginfo_t* info, void* ucontext);
 #endif
 
 std::string GetProcessTitle(const char* default_title);
 std::string GetHumanReadableProcessName();
 
-void InitializeContextRuntime(v8::Local<v8::Context>);
-bool InitializePrimordials(v8::Local<v8::Context> context);
-
-namespace task_queue {
-void PromiseRejectCallback(v8::PromiseRejectMessage message);
-}  // namespace task_queue
+v8::Maybe<bool> InitializeContextRuntime(v8::Local<v8::Context> context);
+v8::Maybe<bool> InitializePrimordials(v8::Local<v8::Context> context);
 
 class NodeArrayBufferAllocator : public ArrayBufferAllocator {
  public:
@@ -115,7 +102,7 @@ class NodeArrayBufferAllocator : public ArrayBufferAllocator {
   void* Allocate(size_t size) override;  // Defined in src/node.cc
   void* AllocateUninitialized(size_t size) override;
   void Free(void* data, size_t size) override;
-  virtual void* Reallocate(void* data, size_t old_size, size_t size);
+  void* Reallocate(void* data, size_t old_size, size_t size) override;
   virtual void RegisterPointer(void* data, size_t size) {
     total_mem_usage_.fetch_add(size, std::memory_order_relaxed);
   }
@@ -163,8 +150,7 @@ v8::MaybeLocal<v8::Object> New(Environment* env,
 // ArrayBuffer::Allocator().
 v8::MaybeLocal<v8::Object> New(Environment* env,
                                char* data,
-                               size_t length,
-                               bool uses_malloc);
+                               size_t length);
 // Creates a Buffer instance over an existing ArrayBuffer.
 v8::MaybeLocal<v8::Uint8Array> New(Environment* env,
                                    v8::Local<v8::ArrayBuffer> ab,
@@ -186,7 +172,7 @@ static v8::MaybeLocal<v8::Object> New(Environment* env,
   const size_t len_in_bytes = buf->length() * sizeof(buf->out()[0]);
 
   if (buf->IsAllocated())
-    ret = New(env, src, len_in_bytes, true);
+    ret = New(env, src, len_in_bytes);
   else if (!buf->IsInvalidated())
     ret = Copy(env, src, len_in_bytes);
 
@@ -209,6 +195,12 @@ v8::MaybeLocal<v8::Value> InternalMakeCallback(
     v8::Local<v8::Value> argv[],
     async_context asyncContext);
 
+v8::MaybeLocal<v8::Value> MakeSyncCallback(v8::Isolate* isolate,
+                                           v8::Local<v8::Object> recv,
+                                           v8::Local<v8::Function> callback,
+                                           int argc,
+                                           v8::Local<v8::Value> argv[]);
+
 class InternalCallbackScope {
  public:
   enum Flags {
@@ -291,7 +283,7 @@ class ThreadPoolWork {
 
 #if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
 #define NODE_IMPLEMENTS_POSIX_CREDENTIALS 1
-#endif  // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__)
+#endif  // defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
 
 namespace credentials {
 bool SafeGetenv(const char* key, std::string* text, Environment* env = nullptr);
@@ -301,8 +293,10 @@ void DefineZlibConstants(v8::Local<v8::Object> target);
 v8::Isolate* NewIsolate(v8::Isolate::CreateParams* params,
                         uv_loop_t* event_loop,
                         MultiIsolatePlatform* platform);
+// This overload automatically picks the right 'main_script_id' if no callback
+// was provided by the embedder.
 v8::MaybeLocal<v8::Value> StartExecution(Environment* env,
-                                         const char* main_script_id);
+                                         StartExecutionCallback cb = nullptr);
 v8::MaybeLocal<v8::Object> GetPerContextExports(v8::Local<v8::Context> context);
 v8::MaybeLocal<v8::Value> ExecuteBootstrapper(
     Environment* env,
@@ -317,8 +311,23 @@ struct InitializationResult {
   std::vector<std::string> exec_args;
   bool early_return = false;
 };
-InitializationResult InitializeOncePerProcess(int argc, char** argv);
-void TearDownOncePerProcess();
+
+enum InitializationSettingsFlags : uint64_t {
+  kDefaultInitialization = 1 << 0,
+  kInitializeV8 = 1 << 1,
+  kRunPlatformInit = 1 << 2,
+  kInitOpenSSL = 1 << 3
+};
+
+// TODO(codebytere): eventually document and expose to embedders.
+InitializationResult NODE_EXTERN_PRIVATE InitializeOncePerProcess(int argc,
+                                                                  char** argv);
+InitializationResult NODE_EXTERN_PRIVATE InitializeOncePerProcess(
+    int argc,
+    char** argv,
+    InitializationSettingsFlags flags,
+    ProcessFlags::Flags process_flags = ProcessFlags::kNoFlags);
+void NODE_EXTERN_PRIVATE TearDownOncePerProcess();
 void SetIsolateErrorHandlers(v8::Isolate* isolate, const IsolateSettings& s);
 void SetIsolateMiscHandlers(v8::Isolate* isolate, const IsolateSettings& s);
 void SetIsolateCreateParamsForNode(v8::Isolate::CreateParams* params);
@@ -370,22 +379,9 @@ class DiagnosticFilename {
   std::string filename_;
 };
 
-class TraceEventScope {
- public:
-  TraceEventScope(const char* category,
-                  const char* name,
-                  void* id) : category_(category), name_(name), id_(id) {
-    TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(category_, name_, id_);
-  }
-  ~TraceEventScope() {
-    TRACE_EVENT_NESTABLE_ASYNC_END0(category_, name_, id_);
-  }
-
- private:
-  const char* category_;
-  const char* name_;
-  void* id_;
-};
+namespace heap {
+v8::Maybe<void> WriteSnapshot(Environment* env, const char* filename);
+}
 
 namespace heap {
 
@@ -401,6 +397,8 @@ namespace fs {
 std::string Basename(const std::string& str, const std::string& extension);
 }  // namespace fs
 
+node_module napi_module_to_node_module(const napi_module* mod);
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

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

@@ -13,6 +13,10 @@
 
 namespace node {
 
+class ExternalReferenceRegistry;
+struct EnvSerializeInfo;
+struct SnapshotData;
+
 // TODO(joyeecheung): align this with the Worker/WorkerThreadData class.
 // We may be able to create an abstract class to reuse some of the routines.
 class NodeMainInstance {
@@ -45,30 +49,22 @@ class NodeMainInstance {
   void Dispose();
 
   // Create a main instance that owns the isolate
-  NodeMainInstance(
-      v8::Isolate::CreateParams* params,
-      uv_loop_t* event_loop,
-      MultiIsolatePlatform* platform,
-      const std::vector<std::string>& args,
-      const std::vector<std::string>& exec_args,
-      const std::vector<size_t>* per_isolate_data_indexes = nullptr);
+  NodeMainInstance(const SnapshotData* snapshot_data,
+                   uv_loop_t* event_loop,
+                   MultiIsolatePlatform* platform,
+                   const std::vector<std::string>& args,
+                   const std::vector<std::string>& exec_args);
   ~NodeMainInstance();
 
   // Start running the Node.js instances, return the exit code when finished.
   int Run();
+  void Run(int* exit_code, Environment* env);
 
   IsolateData* isolate_data() { return isolate_data_.get(); }
 
-  // TODO(joyeecheung): align this with the CreateEnvironment exposed in node.h
-  // and the environment creation routine in workers somehow.
-  std::unique_ptr<Environment> CreateMainEnvironment(int* exit_code);
-
-  // If nullptr is returned, the binary is not built with embedded
-  // snapshot.
-  static const std::vector<size_t>* GetIsolateDataIndexes();
-  static v8::StartupData* GetEmbeddedSnapshotBlob();
+  DeleteFnPtr<Environment, FreeEnvironment> CreateMainEnvironment(
+      int* exit_code);
 
-  static const size_t kNodeContextIndex = 0;
   NodeMainInstance(const NodeMainInstance&) = delete;
   NodeMainInstance& operator=(const NodeMainInstance&) = delete;
   NodeMainInstance(NodeMainInstance&&) = delete;
@@ -81,14 +77,15 @@ class NodeMainInstance {
                    const std::vector<std::string>& args,
                    const std::vector<std::string>& exec_args);
 
+  static std::unique_ptr<ExternalReferenceRegistry> registry_;
   std::vector<std::string> args_;
   std::vector<std::string> exec_args_;
   std::unique_ptr<ArrayBufferAllocator> array_buffer_allocator_;
   v8::Isolate* isolate_;
   MultiIsolatePlatform* platform_;
   std::unique_ptr<IsolateData> isolate_data_;
-  bool owns_isolate_ = false;
-  bool deserialize_mode_ = false;
+  std::unique_ptr<v8::Isolate::CreateParams> isolate_params_;
+  const SnapshotData* snapshot_data_ = nullptr;
 };
 
 }  // namespace node

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

@@ -8,7 +8,7 @@
 namespace node {
 namespace mem {
 
-// Both ngtcp2 and nghttp2 allow custom allocators that
+// nghttp2 allows custom allocators that
 // follow exactly the same structure and behavior, but
 // use different struct names. To allow for code re-use,
 // the NgLibMemoryManager template class can be used for both.