@encharm/cws 4.5.1 → 4.5.2

package/src/headers/24/js_native_api_v8_internals.h

@@ -0,0 +1,45 @@
+#ifndef SRC_JS_NATIVE_API_V8_INTERNALS_H_
+#define SRC_JS_NATIVE_API_V8_INTERNALS_H_
+
+// The V8 implementation of N-API, including `js_native_api_v8.h` uses certain
+// idioms which require definition here. For example, it uses a variant of
+// persistent references which need not be reset in the constructor. It is the
+// responsibility of this file to define these idioms. Optionally, this file
+// may also define `NAPI_VERSION` and set it to the version of N-API to be
+// exposed.
+
+// In the case of the Node.js implementation of N-API some of the idioms are
+// imported directly from Node.js by including `node_internals.h` below. Others
+// are bridged to remove references to the `node` namespace. `node_version.h`,
+// included below, defines `NAPI_VERSION`.
+
+#include "node_version.h"
+
+#include "env.h"
+#include "gtest/gtest_prod.h"
+#include "node_errors.h"
+#include "node_internals.h"
+
+#define NAPI_ARRAYSIZE(array) node::arraysize((array))
+
+#define NAPI_FIXED_ONE_BYTE_STRING(isolate, string)                            \
+  node::FIXED_ONE_BYTE_STRING((isolate), (string))
+
+#define NAPI_PRIVATE_KEY(context, suffix)                                      \
+  (node::Environment::GetCurrent((context))->napi_##suffix())
+
+namespace v8impl {
+
+template <typename T>
+using Persistent = v8::Global<T>;
+
+using PersistentToLocal = node::PersistentToLocal;
+
+[[noreturn]] inline void OnFatalError(const char* location,
+                                      const char* message) {
+  node::OnFatalError(location, message);
+}
+
+}  // end of namespace v8impl
+
+#endif  // SRC_JS_NATIVE_API_V8_INTERNALS_H_

package/src/headers/24/js_stream.h

@@ -0,0 +1,52 @@
+#ifndef SRC_JS_STREAM_H_
+#define SRC_JS_STREAM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "stream_base.h"
+
+namespace node {
+
+class Environment;
+
+class JSStream : public AsyncWrap, public StreamBase {
+ public:
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context,
+                         void* priv);
+
+  bool IsAlive() override;
+  bool IsClosing() override;
+  int ReadStart() override;
+  int ReadStop() override;
+
+  int DoShutdown(ShutdownWrap* req_wrap) override;
+  int DoWrite(WriteWrap* w,
+              uv_buf_t* bufs,
+              size_t count,
+              uv_stream_t* send_handle) override;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(JSStream)
+  SET_SELF_SIZE(JSStream)
+
+ protected:
+  JSStream(Environment* env, v8::Local<v8::Object> obj);
+
+  AsyncWrap* GetAsyncWrap() override;
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void EmitEOF(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  template <class Wrap>
+  static void Finish(const v8::FunctionCallbackInfo<v8::Value>& args);
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_JS_STREAM_H_

package/src/headers/24/json_parser.h

@@ -0,0 +1,40 @@
+#ifndef SRC_JSON_PARSER_H_
+#define SRC_JSON_PARSER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+// This is intended to be used to get some top-level fields out of a JSON
+// without having to spin up a full Node.js environment that unnecessarily
+// complicates things.
+class JSONParser {
+ public:
+  using StringDict = std::unordered_map<std::string, std::string>;
+  JSONParser();
+  ~JSONParser() = default;
+  bool Parse(const std::string& content);
+  std::optional<std::string> GetTopLevelStringField(std::string_view field);
+  std::optional<bool> GetTopLevelBoolField(std::string_view field);
+  std::optional<StringDict> GetTopLevelStringDict(std::string_view field);
+
+ private:
+  // We might want a lighter-weight JSON parser for this use case. But for now
+  // using V8 is good enough.
+  RAIIIsolateWithoutEntering isolate_;
+
+  v8::Global<v8::Context> context_;
+  v8::Global<v8::Object> content_;
+  bool parsed_ = false;
+};
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_JSON_PARSER_H_

package/src/headers/24/json_utils.h

@@ -0,0 +1,172 @@
+#ifndef SRC_JSON_UTILS_H_
+#define SRC_JSON_UTILS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <iomanip>
+#include <limits>
+#include <ostream>
+#include <string>
+#include <string_view>
+
+namespace node {
+
+constexpr bool NeedsJsonEscape(std::string_view str) {
+  for (const char c : str) {
+    if (c == '\\' || c == '"' || c < 0x20) return true;
+  }
+  return false;
+}
+
+std::string EscapeJsonChars(std::string_view str);
+std::string Reindent(const std::string& str, int indentation);
+
+// JSON compiler definitions.
+class JSONWriter {
+ public:
+  JSONWriter(std::ostream& out, bool compact)
+    : out_(out), compact_(compact) {}
+
+ private:
+  inline void indent() { indent_ += 2; }
+  inline void deindent() { indent_ -= 2; }
+  inline void advance() {
+    if (compact_) return;
+    for (int i = 0; i < indent_; i++) out_ << ' ';
+  }
+  inline void write_one_space() {
+    if (compact_) return;
+    out_ << ' ';
+  }
+  inline void write_new_line() {
+    if (compact_) return;
+    out_ << '\n';
+  }
+
+ public:
+  inline void json_start() {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    out_ << '{';
+    indent();
+    state_ = kObjectStart;
+  }
+
+  inline void json_end() {
+    write_new_line();
+    deindent();
+    advance();
+    out_ << '}';
+    state_ = kAfterValue;
+  }
+  template <typename T>
+  inline void json_objectstart(T key) {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    write_string(key);
+    out_ << ':';
+    write_one_space();
+    out_ << '{';
+    indent();
+    state_ = kObjectStart;
+  }
+
+  template <typename T>
+  inline void json_arraystart(T key) {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    write_string(key);
+    out_ << ':';
+    write_one_space();
+    out_ << '[';
+    indent();
+    state_ = kObjectStart;
+  }
+  inline void json_objectend() {
+    write_new_line();
+    deindent();
+    advance();
+    out_ << '}';
+    if (indent_ == 0) {
+      // Top-level object is complete, so end the line.
+      out_ << '\n';
+    }
+    state_ = kAfterValue;
+  }
+
+  inline void json_arrayend() {
+    write_new_line();
+    deindent();
+    advance();
+    out_ << ']';
+    state_ = kAfterValue;
+  }
+  template <typename T, typename U>
+  inline void json_keyvalue(const T& key, const U& value) {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    write_string(key);
+    out_ << ':';
+    write_one_space();
+    write_value(value);
+    state_ = kAfterValue;
+  }
+
+  template <typename U>
+  inline void json_element(const U& value) {
+    if (state_ == kAfterValue) out_ << ',';
+    write_new_line();
+    advance();
+    write_value(value);
+    state_ = kAfterValue;
+  }
+
+  struct Null {};  // Usable as a JSON value.
+
+  struct ForeignJSON {
+    std::string as_string;
+  };
+
+ private:
+  template <typename T,
+            typename test_for_number = typename std::
+                enable_if<std::numeric_limits<T>::is_specialized, bool>::type>
+  inline void write_value(T number) {
+    if constexpr (std::is_same<T, bool>::value)
+      out_ << (number ? "true" : "false");
+    else
+      out_ << number;
+  }
+
+  inline void write_value(Null null) { out_ << "null"; }
+  inline void write_value(std::string_view str) { write_string(str); }
+
+  inline void write_value(const ForeignJSON& json) {
+    out_ << Reindent(json.as_string, indent_);
+  }
+
+  inline void write_string(std::string_view str) {
+    out_ << '"';
+    if (NeedsJsonEscape(str))  // only create temporary std::string if necessary
+      out_ << EscapeJsonChars(str);
+    else
+      out_ << str;
+    out_ << '"';
+  }
+
+  enum JSONState { kObjectStart, kAfterValue };
+  std::ostream& out_;
+  bool compact_;
+  int indent_ = 0;
+  int state_ = kObjectStart;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_JSON_UTILS_H_

package/src/headers/24/logstream.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <async_wrap.h>
+#include <base_object.h>
+#include <env.h>
+#include <stream_base.h>
+#include <deque>
+
+namespace node::quic {
+
+// The LogStream is a utility that the QUIC impl uses to publish both QLog
+// and Keylog diagnostic data (one instance for each).
+class LogStream : public AsyncWrap, public StreamBase {
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  static BaseObjectPtr<LogStream> Create(Environment* env);
+
+  LogStream(Environment* env, v8::Local<v8::Object> obj);
+
+  enum class EmitOption {
+    NONE,
+    FIN,
+  };
+
+  void Emit(const uint8_t* data,
+            size_t len,
+            EmitOption option = EmitOption::NONE);
+
+  void Emit(const std::string_view line, EmitOption option = EmitOption::NONE);
+
+  void End();
+
+  int ReadStart() override;
+
+  int ReadStop() override;
+
+  // We do not use either of these.
+  int DoShutdown(ShutdownWrap* req_wrap) override;
+  int DoWrite(WriteWrap* w,
+              uv_buf_t* bufs,
+              size_t count,
+              uv_stream_t* send_handle) override;
+
+  bool IsAlive() override;
+  bool IsClosing() override;
+  AsyncWrap* GetAsyncWrap() override;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(LogStream)
+  SET_SELF_SIZE(LogStream)
+
+ private:
+  struct Chunk {
+    // len will be <= buf.len
+    size_t len;
+    uv_buf_t buf;
+  };
+  size_t total_ = 0;
+  bool fin_seen_ = false;
+  bool ended_ = false;
+  bool reading_ = false;
+  std::deque<Chunk> buffer_;
+
+  // The value here is fairly arbitrary. Once we get everything
+  // fully implemented and start working with this, we might
+  // tune this number further.
+  static constexpr size_t kMaxLogStreamBuffer = 1024 * 10;
+
+  // The LogStream buffer enforces a maximum size of kMaxLogStreamBuffer.
+  void ensure_space(size_t amt);
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/main_thread_interface.h

@@ -0,0 +1,116 @@
+#ifndef SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_
+#define SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "inspector_agent.h"
+#include "node_mutex.h"
+
+#include <atomic>
+#include <deque>
+#include <memory>
+#include <unordered_map>
+
+namespace v8_inspector {
+class StringBuffer;
+class StringView;
+}  // namespace v8_inspector
+
+namespace node {
+namespace inspector {
+class MainThreadInterface;
+
+class Request {
+ public:
+  virtual void Call(MainThreadInterface*) = 0;
+  virtual ~Request() = default;
+};
+
+class Deletable {
+ public:
+  virtual ~Deletable() = default;
+};
+
+std::unique_ptr<v8_inspector::StringBuffer> Utf8ToStringView(
+    const std::string_view message);
+
+using MessageQueue = std::deque<std::unique_ptr<Request>>;
+
+class MainThreadHandle : public std::enable_shared_from_this<MainThreadHandle> {
+ public:
+  explicit MainThreadHandle(MainThreadInterface* main_thread)
+                            : main_thread_(main_thread) {
+  }
+  ~MainThreadHandle() {
+    Mutex::ScopedLock scoped_lock(block_lock_);
+    CHECK_NULL(main_thread_);  // main_thread_ should have called Reset
+  }
+  std::unique_ptr<InspectorSession> Connect(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+  int newObjectId() {
+    return ++next_object_id_;
+  }
+  bool Post(std::unique_ptr<Request> request);
+  std::unique_ptr<InspectorSessionDelegate> MakeDelegateThreadSafe(
+      std::unique_ptr<InspectorSessionDelegate> delegate);
+  bool Expired();
+  void SetTargetSessionId(int target_session_id) {
+    target_session_id_ = target_session_id;
+  }
+  std::optional<int> GetTargetSessionId() { return target_session_id_; }
+
+ private:
+  void Reset();
+
+  MainThreadInterface* main_thread_;
+  Mutex block_lock_;
+  int next_session_id_ = 0;
+  std::atomic_int next_object_id_ = {1};
+  std::optional<int> target_session_id_ = std::nullopt;
+
+  friend class MainThreadInterface;
+};
+
+class MainThreadInterface :
+    public std::enable_shared_from_this<MainThreadInterface> {
+ public:
+  explicit MainThreadInterface(Agent* agent);
+  ~MainThreadInterface();
+
+  void DispatchMessages();
+  void Post(std::unique_ptr<Request> request);
+  bool WaitForFrontendEvent();
+  void StopWaitingForFrontendEvent();
+  std::shared_ptr<MainThreadHandle> GetHandle();
+  Agent* inspector_agent() {
+    return agent_;
+  }
+  void AddObject(int handle, std::unique_ptr<Deletable> object);
+  Deletable* GetObject(int id);
+  Deletable* GetObjectIfExists(int id);
+  void RemoveObject(int handle);
+
+ private:
+  MessageQueue requests_;
+  Mutex requests_lock_;   // requests_ live across threads
+  // This queue is to maintain the order of the messages for the cases
+  // when we reenter the DispatchMessages function.
+  MessageQueue dispatching_message_queue_;
+  bool dispatching_messages_ = false;
+  // This flag indicates an internal request to exit the loop in
+  // WaitForFrontendEvent(). It's set to true by calling
+  // StopWaitingForFrontendEvent().
+  bool stop_waiting_for_frontend_event_requested_ = false;
+  ConditionVariable incoming_message_cond_;
+  // Used from any thread
+  Agent* const agent_;
+  std::shared_ptr<MainThreadHandle> handle_;
+  std::unordered_map<int, std::unique_ptr<Deletable>> managed_objects_;
+};
+
+}  // namespace inspector
+}  // namespace node
+#endif  // SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_