@encharm/cws 4.5.1 → 4.5.2

package/src/headers/24/http3.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <base_object.h>
+#include <env.h>
+#include <memory_tracker.h>
+#include "session.h"
+
+namespace node::quic {
+// Provides an implementation of the HTTP/3 Application implementation
+class Http3Application final : public Session::ApplicationProvider {
+ public:
+  static bool HasInstance(Environment* env, v8::Local<v8::Value> value);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void InitPerIsolate(IsolateData* isolate_data,
+                             v8::Local<v8::ObjectTemplate> target);
+  static void InitPerContext(Realm* realm, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  Http3Application(Environment* env,
+                   v8::Local<v8::Object> object,
+                   const Session::Application_Options& options);
+
+  std::unique_ptr<Session::Application> Create(Session* session) override;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(Http3Application)
+  SET_MEMORY_INFO_NAME(Http3Application)
+
+  std::string ToString() const;
+
+ private:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  Session::Application_Options options_;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/inspector_agent.h

@@ -0,0 +1,165 @@
+#pragma once
+
+#include "inspector/network_resource_manager.h"
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "node_options.h"
+#include "v8.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace v8_inspector {
+class StringView;
+}  // namespace v8_inspector
+
+namespace node {
+// Forward declaration to break recursive dependency chain with src/env.h.
+class Environment;
+struct ContextInfo;
+
+namespace inspector {
+class InspectorIo;
+class ParentInspectorHandle;
+class NodeInspectorClient;
+class WorkerManager;
+
+class InspectorSession {
+ public:
+  virtual ~InspectorSession() = default;
+  virtual void Dispatch(const v8_inspector::StringView& message) = 0;
+};
+
+class InspectorSessionDelegate {
+ public:
+  virtual ~InspectorSessionDelegate() = default;
+  virtual void SendMessageToFrontend(const v8_inspector::StringView& message)
+                                     = 0;
+};
+
+class Agent {
+ public:
+  explicit Agent(node::Environment* env);
+  ~Agent();
+
+  // Create client_, may create io_ if option enabled
+  bool Start(const std::string& path,
+             const DebugOptions& options,
+             std::shared_ptr<ExclusiveAccess<HostPort>> host_port,
+             bool is_main);
+  // Stop and destroy io_
+  void Stop();
+
+  bool IsListening() { return io_ != nullptr; }
+  // Returns true if the Node inspector is actually in use. It will be true
+  // if either the user explicitly opted into inspector (e.g. with the
+  // --inspect command line flag) or if inspector JS API had been used.
+  bool IsActive();
+
+  // Blocks till frontend connects and sends "runIfWaitingForDebugger"
+  void WaitForConnect();
+  bool WaitForConnectByOptions();
+  void StopIfWaitingForConnect();
+
+  // Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
+  void WaitForDisconnect();
+  void ReportUncaughtException(v8::Local<v8::Value> error,
+                               v8::Local<v8::Message> message);
+
+  void EmitProtocolEvent(v8::Local<v8::Context> context,
+                         const v8_inspector::StringView& event,
+                         v8::Local<v8::Object> params);
+
+  void SetupNetworkTracking(v8::Local<v8::Function> enable_function,
+                            v8::Local<v8::Function> disable_function);
+  void EnableNetworkTracking();
+  void DisableNetworkTracking();
+
+  // Async stack traces instrumentation.
+  void AsyncTaskScheduled(const v8_inspector::StringView& taskName, void* task,
+                          bool recurring);
+  void AsyncTaskCanceled(void* task);
+  void AsyncTaskStarted(void* task);
+  void AsyncTaskFinished(void* task);
+  void AllAsyncTasksCanceled();
+
+  void RegisterAsyncHook(v8::Isolate* isolate,
+    v8::Local<v8::Function> enable_function,
+    v8::Local<v8::Function> disable_function);
+  void EnableAsyncHook();
+  void DisableAsyncHook();
+
+  void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
+  std::unique_ptr<ParentInspectorHandle> GetParentHandle(uint64_t thread_id,
+                                                         std::string_view url,
+                                                         std::string_view name);
+
+  // Called to create inspector sessions that can be used from the same thread.
+  // The inspector responds by using the delegate to send messages back.
+  std::unique_ptr<InspectorSession> Connect(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+
+  // Called from the worker to create inspector sessions that is connected
+  // to the main thread.
+  // The inspector responds by using the delegate to send messages back.
+  std::unique_ptr<InspectorSession> ConnectToMainThread(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+
+  void PauseOnNextJavascriptStatement(const std::string& reason);
+
+  std::string GetWsUrl() const;
+
+  // Can only be called from the main thread.
+  bool StartIoThread();
+
+  // Calls StartIoThread() from off the main thread.
+  void RequestIoThreadStart();
+
+  const DebugOptions& options() { return debug_options_; }
+  std::shared_ptr<ExclusiveAccess<HostPort>> host_port() { return host_port_; }
+  void ContextCreated(v8::Local<v8::Context> context, const ContextInfo& info);
+
+  // Interface for interacting with inspectors in worker threads
+  std::shared_ptr<WorkerManager> GetWorkerManager();
+
+  inline Environment* env() const { return parent_env_; }
+  std::shared_ptr<NetworkResourceManager> GetNetworkResourceManager();
+
+ private:
+  void ToggleAsyncHook(v8::Isolate* isolate, v8::Local<v8::Function> fn);
+  void ToggleNetworkTracking(v8::Isolate* isolate, v8::Local<v8::Function> fn);
+
+  node::Environment* parent_env_;
+  // Encapsulates majority of the Inspector functionality
+  std::shared_ptr<NodeInspectorClient> client_;
+  // Interface for transports, e.g. WebSocket server
+  std::unique_ptr<InspectorIo> io_;
+  std::unique_ptr<ParentInspectorHandle> parent_handle_;
+  std::string path_;
+
+  // This is a copy of the debug options parsed from CLI in the Environment.
+  // Do not use the host_port in that, instead manipulate the shared host_port_
+  // pointer which is meant to store the actual host and port of the inspector
+  // server.
+  DebugOptions debug_options_;
+  std::shared_ptr<ExclusiveAccess<HostPort>> host_port_;
+
+  bool pending_enable_async_hook_ = false;
+  bool pending_disable_async_hook_ = false;
+
+  bool network_tracking_enabled_ = false;
+  bool pending_enable_network_tracking = false;
+  bool pending_disable_network_tracking = false;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/inspector_io.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "inspector_socket_server.h"
+#include "node_mutex.h"
+
+#include "uv.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace node {
+// Forward declaration to break recursive dependency chain with src/env.h.
+class Environment;
+namespace inspector {
+
+class MainThreadHandle;
+class RequestQueue;
+
+class InspectorIo {
+ public:
+  // Start the inspector agent thread, waiting for it to initialize
+  // bool Start();
+  // Returns empty pointer if thread was not started
+  static std::unique_ptr<InspectorIo> Start(
+      std::shared_ptr<MainThreadHandle> main_thread,
+      const std::string& path,
+      std::shared_ptr<ExclusiveAccess<HostPort>> host_port,
+      const InspectPublishUid& inspect_publish_uid);
+
+  // Will block till the transport thread shuts down
+  ~InspectorIo();
+
+  void StopAcceptingNewConnections();
+  std::string GetWsUrl() const;
+
+ private:
+  InspectorIo(std::shared_ptr<MainThreadHandle> handle,
+              const std::string& path,
+              std::shared_ptr<ExclusiveAccess<HostPort>> host_port,
+              const InspectPublishUid& inspect_publish_uid);
+
+  // Wrapper for agent->ThreadMain()
+  static void ThreadMain(void* agent);
+
+  // Runs a uv_loop_t
+  void ThreadMain();
+
+  // This is a thread-safe object that will post async tasks. It lives as long
+  // as an Inspector object lives (almost as long as an Isolate).
+  std::shared_ptr<MainThreadHandle> main_thread_;
+  // Used to post on a frontend interface thread, lives while the server is
+  // running
+  std::shared_ptr<RequestQueue> request_queue_;
+  std::shared_ptr<ExclusiveAccess<HostPort>> host_port_;
+  InspectPublishUid inspect_publish_uid_;
+
+  // The IO thread runs its own uv_loop to implement the TCP server off
+  // the main thread.
+  uv_thread_t thread_;
+
+  // For setting up interthread communications
+  Mutex thread_start_lock_;
+  ConditionVariable thread_start_condition_;
+  std::string script_name_;
+  // May be accessed from any thread
+  const std::string id_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/inspector_permission.h

@@ -0,0 +1,31 @@
+#ifndef SRC_PERMISSION_INSPECTOR_PERMISSION_H_
+#define SRC_PERMISSION_INSPECTOR_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <string>
+#include "permission/permission_base.h"
+
+namespace node {
+
+namespace permission {
+
+class InspectorPermission 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_INSPECTOR_PERMISSION_H_

package/src/headers/24/inspector_profiler.h

@@ -0,0 +1,149 @@
+#ifndef SRC_INSPECTOR_PROFILER_H_
+#define SRC_INSPECTOR_PROFILER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include <optional>
+#include <unordered_set>
+#include "inspector_agent.h"
+#include "simdjson.h"
+
+namespace node {
+// Forward declaration to break recursive dependency chain with src/env.h.
+class Environment;
+
+namespace profiler {
+
+class V8ProfilerConnection {
+ public:
+  class V8ProfilerSessionDelegate : public inspector::InspectorSessionDelegate {
+   public:
+    explicit V8ProfilerSessionDelegate(V8ProfilerConnection* connection)
+        : connection_(connection) {}
+
+    void SendMessageToFrontend(
+        const v8_inspector::StringView& message) override;
+
+   private:
+    V8ProfilerConnection* connection_;
+  };
+
+  explicit V8ProfilerConnection(Environment* env);
+  virtual ~V8ProfilerConnection() = default;
+
+  Environment* env() const { return env_; }
+
+  // Dispatch a protocol message, and returns the id of the message.
+  // `method` does not need to be surrounded by quotes.
+  // The optional `params` should be formatted in JSON.
+  // The strings should be in one byte characters - which is enough for
+  // the commands we use here.
+  uint64_t DispatchMessage(const char* method,
+                           const char* params = nullptr,
+                           bool is_profile_request = false);
+
+  // Use DispatchMessage() to dispatch necessary inspector messages
+  // to start and end the profiling.
+  virtual void Start() = 0;
+  virtual void End() = 0;
+
+  // Return a descriptive name of the profile for debugging.
+  virtual const char* type() const = 0;
+  // Return if the profile is ending and the response can be parsed.
+  virtual bool ending() const = 0;
+  // Return the directory where the profile should be placed.
+  virtual std::string GetDirectory() const = 0;
+  // Return the filename the profile should be written as.
+  virtual std::string GetFilename() const = 0;
+  // Return the profile object parsed from `message.result`,
+  // which will be then written as a JSON.
+  virtual std::optional<std::string_view> GetProfile(
+      simdjson::ondemand::object* result);
+  virtual void WriteProfile(simdjson::ondemand::object* result);
+
+  bool HasProfileId(uint64_t id) const { return profile_ids_.contains(id); }
+
+  void RemoveProfileId(uint64_t id) { profile_ids_.erase(id); }
+
+ private:
+  uint64_t next_id() { return id_++; }
+  std::unique_ptr<inspector::InspectorSession> session_;
+  uint64_t id_ = 1;
+  std::unordered_set<uint64_t> profile_ids_;
+
+ protected:
+  simdjson::ondemand::parser json_parser_;
+  Environment* env_ = nullptr;
+};
+
+class V8CoverageConnection : public V8ProfilerConnection {
+ public:
+  explicit V8CoverageConnection(Environment* env) : V8ProfilerConnection(env) {}
+
+  void Start() override;
+  void End() override;
+
+  const char* type() const override { return "coverage"; }
+  bool ending() const override { return ending_; }
+
+  std::string GetDirectory() const override;
+  std::string GetFilename() const override;
+  std::optional<std::string_view> GetProfile(
+      simdjson::ondemand::object* result) override;
+  void WriteProfile(simdjson::ondemand::object* result) override;
+  void WriteSourceMapCache();
+  void TakeCoverage();
+  void StopCoverage();
+
+ private:
+  std::unique_ptr<inspector::InspectorSession> session_;
+  bool ending_ = false;
+};
+
+class V8CpuProfilerConnection : public V8ProfilerConnection {
+ public:
+  explicit V8CpuProfilerConnection(Environment* env)
+      : V8ProfilerConnection(env) {}
+
+  void Start() override;
+  void End() override;
+
+  const char* type() const override { return "CPU"; }
+  bool ending() const override { return ending_; }
+
+  std::string GetDirectory() const override;
+  std::string GetFilename() const override;
+
+ private:
+  std::unique_ptr<inspector::InspectorSession> session_;
+  bool ending_ = false;
+};
+
+class V8HeapProfilerConnection : public V8ProfilerConnection {
+ public:
+  explicit V8HeapProfilerConnection(Environment* env)
+      : V8ProfilerConnection(env) {}
+
+  void Start() override;
+  void End() override;
+
+  const char* type() const override { return "heap"; }
+  bool ending() const override { return ending_; }
+
+  std::string GetDirectory() const override;
+  std::string GetFilename() const override;
+
+ private:
+  std::unique_ptr<inspector::InspectorSession> session_;
+  bool ending_ = false;
+};
+
+}  // namespace profiler
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_INSPECTOR_PROFILER_H_

package/src/headers/24/inspector_socket.h

@@ -0,0 +1,60 @@
+#ifndef SRC_INSPECTOR_SOCKET_H_
+#define SRC_INSPECTOR_SOCKET_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+#include "uv.h"
+
+#include <string>
+#include <vector>
+
+namespace node {
+namespace inspector {
+
+class ProtocolHandler;
+
+// HTTP Wrapper around a uv_tcp_t
+class InspectorSocket {
+ public:
+  class Delegate {
+   public:
+    virtual void OnHttpGet(const std::string& host,
+                           const std::string& path) = 0;
+    virtual void OnSocketUpgrade(const std::string& host,
+                                 const std::string& path,
+                                 const std::string& accept_key) = 0;
+    virtual void OnWsFrame(const std::vector<char>& frame) = 0;
+    virtual ~Delegate() = default;
+  };
+
+  using DelegatePointer = std::unique_ptr<Delegate>;
+  using Pointer = std::unique_ptr<InspectorSocket>;
+
+  static Pointer Accept(uv_stream_t* server, DelegatePointer delegate);
+
+  ~InspectorSocket();
+
+  void AcceptUpgrade(const std::string& accept_key);
+  void CancelHandshake();
+  void Write(const char* data, size_t len);
+  void SwitchProtocol(ProtocolHandler* handler);
+  std::string GetHost();
+
+  InspectorSocket(const InspectorSocket&) = delete;
+  InspectorSocket& operator=(const InspectorSocket&) = delete;
+
+ private:
+  static void Shutdown(ProtocolHandler*);
+  InspectorSocket() = default;
+
+  DeleteFnPtr<ProtocolHandler, Shutdown> protocol_handler_;
+};
+
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_INSPECTOR_SOCKET_H_

package/src/headers/24/inspector_socket_server.h

@@ -0,0 +1,110 @@
+#ifndef SRC_INSPECTOR_SOCKET_SERVER_H_
+#define SRC_INSPECTOR_SOCKET_SERVER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "inspector_agent.h"
+#include "inspector_socket.h"
+#include "uv.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+namespace node {
+namespace inspector {
+
+std::string FormatWsAddress(const std::string& host, int port,
+                            const std::string& target_id,
+                            bool include_protocol);
+
+class InspectorSocketServer;
+class SocketSession;
+class ServerSocket;
+
+class SocketServerDelegate {
+ public:
+  virtual void AssignServer(InspectorSocketServer* server) = 0;
+  virtual void StartSession(int session_id, const std::string& target_id) = 0;
+  virtual void EndSession(int session_id) = 0;
+  virtual void MessageReceived(int session_id, const std::string& message) = 0;
+  virtual std::vector<std::string> GetTargetIds() = 0;
+  virtual std::string GetTargetTitle(const std::string& id) = 0;
+  virtual std::string GetTargetUrl(const std::string& id) = 0;
+  virtual ~SocketServerDelegate() = default;
+};
+
+// HTTP Server, writes messages requested as TransportActions, and responds
+// to HTTP requests and WS upgrades.
+
+class InspectorSocketServer {
+ public:
+  InspectorSocketServer(std::unique_ptr<SocketServerDelegate> delegate,
+                        uv_loop_t* loop,
+                        const std::string& host,
+                        int port,
+                        const InspectPublishUid& inspect_publish_uid,
+                        FILE* out = stderr);
+  ~InspectorSocketServer();
+
+  // Start listening on host/port
+  bool Start();
+
+  // Called by the TransportAction sent with InspectorIo::Write():
+  //   kKill and kStop
+  void Stop();
+  //   kSendMessage
+  void Send(int session_id, const std::string& message);
+  //   kKill
+  void TerminateConnections();
+  int Port() const;
+
+  // Session connection lifecycle
+  void Accept(int server_port, uv_stream_t* server_socket);
+  bool HandleGetRequest(int session_id, const std::string& host,
+                        const std::string& path);
+  void SessionStarted(int session_id, const std::string& target_id,
+                      const std::string& ws_id);
+  void SessionTerminated(int session_id);
+  void MessageReceived(int session_id, const std::string& message) {
+    delegate_->MessageReceived(session_id, message);
+  }
+  SocketSession* Session(int session_id);
+  bool done() const {
+    return server_sockets_.empty() && connected_sessions_.empty();
+  }
+
+  static void CloseServerSocket(ServerSocket*);
+  using ServerSocketPtr = DeleteFnPtr<ServerSocket, CloseServerSocket>;
+
+ private:
+  void SendListResponse(InspectorSocket* socket, const std::string& host,
+                        SocketSession* session);
+  std::string GetFrontendURL(bool is_compat,
+                             const std::string &formatted_address);
+  bool TargetExists(const std::string& id);
+
+  enum class ServerState {kNew, kRunning, kStopped};
+  uv_loop_t* loop_;
+  std::unique_ptr<SocketServerDelegate> delegate_;
+  const std::string host_;
+  int port_;
+  InspectPublishUid inspect_publish_uid_;
+  std::vector<ServerSocketPtr> server_sockets_;
+  std::map<int, std::pair<std::string, std::unique_ptr<SocketSession>>>
+      connected_sessions_;
+  int next_session_id_;
+  FILE* out_;
+  ServerState state_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_INSPECTOR_SOCKET_SERVER_H_

package/src/headers/24/io_agent.h

@@ -0,0 +1,30 @@
+#ifndef SRC_INSPECTOR_IO_AGENT_H_
+#define SRC_INSPECTOR_IO_AGENT_H_
+
+#include <memory>
+#include "inspector/network_resource_manager.h"
+#include "node/inspector/protocol/IO.h"
+
+namespace node::inspector::protocol {
+
+class IoAgent : public IO::Backend {
+ public:
+  explicit IoAgent(
+      std::shared_ptr<NetworkResourceManager> network_resource_manager)
+      : network_resource_manager_(std::move(network_resource_manager)) {}
+  void Wire(UberDispatcher* dispatcher);
+  DispatchResponse read(const String& in_handle,
+                        std::optional<int> in_offset,
+                        std::optional<int> in_size,
+                        String* out_data,
+                        bool* out_eof) override;
+  DispatchResponse close(const String& in_handle) override;
+
+ private:
+  std::shared_ptr<IO::Frontend> frontend_;
+  std::unordered_map<std::string, int> offset_map_ =
+      {};  // Maps stream_id to offset
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
+};
+}  // namespace node::inspector::protocol
+#endif  // SRC_INSPECTOR_IO_AGENT_H_