@encharm/cws 4.5.3 → 4.8.0

package/src/headers/26/inspector/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_

package/src/headers/26/inspector/network_agent.h

@@ -0,0 +1,110 @@
+#ifndef SRC_INSPECTOR_NETWORK_AGENT_H_
+#define SRC_INSPECTOR_NETWORK_AGENT_H_
+
+#include "env.h"
+#include "io_agent.h"
+#include "network_requests_buffer.h"
+#include "network_resource_manager.h"
+#include "node/inspector/protocol/Network.h"
+
+#include <map>
+#include <memory>
+#include <unordered_map>
+
+namespace node {
+namespace inspector {
+
+class NetworkInspector;
+
+class NetworkAgent : public protocol::Network::Backend {
+ public:
+  explicit NetworkAgent(
+      NetworkInspector* inspector,
+      v8_inspector::V8Inspector* v8_inspector,
+      Environment* env,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
+
+  void Wire(protocol::UberDispatcher* dispatcher);
+
+  protocol::DispatchResponse enable(
+      std::optional<int> in_maxTotalBufferSize,
+      std::optional<int> in_maxResourceBufferSize) override;
+
+  protocol::DispatchResponse disable() override;
+
+  protocol::DispatchResponse getRequestPostData(
+      const protocol::String& in_requestId,
+      protocol::String* out_postData) override;
+
+  protocol::DispatchResponse getResponseBody(
+      const protocol::String& in_requestId,
+      protocol::String* out_body,
+      bool* out_base64Encoded) override;
+
+  protocol::DispatchResponse streamResourceContent(
+      const protocol::String& in_requestId,
+      protocol::Binary* out_bufferedData) override;
+
+  protocol::DispatchResponse loadNetworkResource(
+      const protocol::String& in_url,
+      std::unique_ptr<protocol::Network::LoadNetworkResourcePageResult>*
+          out_resource) override;
+
+  void emitNotification(v8::Local<v8::Context> context,
+                        const protocol::String& event,
+                        v8::Local<v8::Object> params);
+
+  void requestWillBeSent(v8::Local<v8::Context> context,
+                         v8::Local<v8::Object> params);
+
+  void responseReceived(v8::Local<v8::Context> context,
+                        v8::Local<v8::Object> params);
+
+  void loadingFailed(v8::Local<v8::Context> context,
+                     v8::Local<v8::Object> params);
+
+  void loadingFinished(v8::Local<v8::Context> context,
+                       v8::Local<v8::Object> params);
+
+  void dataSent(v8::Local<v8::Context> context, v8::Local<v8::Object> params);
+
+  void dataReceived(v8::Local<v8::Context> context,
+                    v8::Local<v8::Object> params);
+
+  void webSocketCreated(v8::Local<v8::Context> context,
+                        v8::Local<v8::Object> params);
+  void webSocketClosed(v8::Local<v8::Context> context,
+                       v8::Local<v8::Object> params);
+  void webSocketHandshakeResponseReceived(v8::Local<v8::Context> context,
+                                          v8::Local<v8::Object> params);
+
+ private:
+  std::unique_ptr<protocol::Network::Headers> createHeadersFromObject(
+      v8::Local<v8::Context> context, v8::Local<v8::Object> headers_obj);
+  std::unique_ptr<protocol::Network::Request> createRequestFromObject(
+      v8::Local<v8::Context> context, v8::Local<v8::Object> request);
+  std::unique_ptr<protocol::Network::Response> createResponseFromObject(
+      v8::Local<v8::Context> context, v8::Local<v8::Object> response);
+  std::unique_ptr<protocol::Network::WebSocketResponse> createWebSocketResponse(
+      v8::Local<v8::Context> context, v8::Local<v8::Object> response);
+
+  NetworkInspector* inspector_;
+  v8_inspector::V8Inspector* v8_inspector_;
+  std::shared_ptr<protocol::Network::Frontend> frontend_;
+
+  using EventNotifier = void (NetworkAgent::*)(v8::Local<v8::Context> context,
+                                               v8::Local<v8::Object>);
+  std::unordered_map<protocol::String, EventNotifier> event_notifier_map_;
+  Environment* env_;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
+
+  // Per-resource buffer size in bytes to use when preserving network payloads
+  // (XHRs, etc).
+  size_t max_resource_buffer_size_ = 5 * 1024 * 1024;  // 5MB
+  RequestsBuffer requests_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NETWORK_AGENT_H_

package/src/headers/26/inspector/network_inspector.h

@@ -0,0 +1,45 @@
+#ifndef SRC_INSPECTOR_NETWORK_INSPECTOR_H_
+#define SRC_INSPECTOR_NETWORK_INSPECTOR_H_
+
+#include <memory>
+#include "env.h"
+#include "network_agent.h"
+#include "network_resource_manager.h"
+
+namespace node {
+class Environment;
+
+namespace inspector {
+
+class NetworkInspector {
+ public:
+  explicit NetworkInspector(
+      Environment* env,
+      v8_inspector::V8Inspector* v8_inspector,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
+  ~NetworkInspector();
+
+  void Wire(protocol::UberDispatcher* dispatcher);
+
+  bool canEmit(const std::string& domain);
+
+  void emitNotification(v8::Local<v8::Context> context,
+                        const std::string& domain,
+                        const std::string& method,
+                        v8::Local<v8::Object> params);
+
+  void Enable();
+  void Disable();
+  bool IsEnabled() const { return enabled_; }
+
+ private:
+  bool enabled_;
+  Environment* env_;
+  std::unique_ptr<NetworkAgent> network_agent_;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NETWORK_INSPECTOR_H_

package/src/headers/26/inspector/network_requests_buffer.h

@@ -0,0 +1,195 @@
+#ifndef SRC_INSPECTOR_NETWORK_REQUESTS_BUFFER_H_
+#define SRC_INSPECTOR_NETWORK_REQUESTS_BUFFER_H_
+
+#include <list>
+#include <map>
+#include <vector>
+
+#include "inspector/node_string.h"
+
+namespace node {
+namespace inspector {
+
+// Supported charsets for devtools frontend on request/response data.
+// If the charset is kUTF8, the data is expected to be text and can be
+// formatted on the frontend.
+enum class Charset {
+  kUTF8,
+  kBinary,
+};
+
+struct RequestEntry {
+  double timestamp;
+  bool is_request_finished = false;
+  bool is_response_finished = false;
+  bool is_streaming = false;
+  Charset request_charset;
+  Charset response_charset = Charset::kBinary;
+
+  size_t max_resource_buffer_size;
+  size_t buffer_size() const {
+    return request_data_size_ + response_data_size_;
+  }
+
+  const std::vector<protocol::Binary> request_data_blobs() const {
+    return request_data_blobs_;
+  }
+  const std::vector<protocol::Binary> response_data_blobs() const {
+    return response_data_blobs_;
+  }
+
+  void push_request_data_blob(const protocol::Binary& blob) {
+    if (buffer_size() + blob.size() > max_resource_buffer_size) {
+      // Exceed the per-resource buffer size limit, ignore the blob.
+      return;
+    }
+    request_data_blobs_.push_back(blob);
+    request_data_size_ += blob.size();
+  }
+  void push_response_data_blob(const protocol::Binary& blob) {
+    if (buffer_size() + blob.size() > max_resource_buffer_size) {
+      // Exceed the per-resource buffer size limit, ignore the blob.
+      return;
+    }
+    response_data_blobs_.push_back(blob);
+    response_data_size_ += blob.size();
+  }
+
+  void clear_response_data_blobs() {
+    response_data_blobs_.clear();
+    response_data_size_ = 0;
+  }
+
+  RequestEntry(double timestamp,
+               Charset request_charset,
+               bool has_request_body,
+               size_t max_resource_buffer_size)
+      : timestamp(timestamp),
+        is_request_finished(!has_request_body),
+        request_charset(request_charset),
+        max_resource_buffer_size(max_resource_buffer_size) {}
+
+ private:
+  size_t request_data_size_ = 0;
+  std::vector<protocol::Binary> request_data_blobs_;
+  size_t response_data_size_ = 0;
+  std::vector<protocol::Binary> response_data_blobs_;
+};
+
+class RequestsBuffer {
+  using key_value_pair_t = typename std::pair<protocol::String, RequestEntry>;
+  using list_iterator = typename std::list<key_value_pair_t>::iterator;
+  using const_list_iterator =
+      typename std::list<key_value_pair_t>::const_iterator;
+
+ public:
+  struct mutable_iterator {
+    list_iterator it;
+    size_t buffer_size;
+    RequestsBuffer* parent;
+
+    key_value_pair_t& operator*() { return *it; }
+    key_value_pair_t* operator->() { return &(*it); }
+    bool operator==(const const_list_iterator& other) const {
+      return it == other;
+    }
+    bool operator!=(const const_list_iterator& other) const {
+      return it != other;
+    }
+
+    mutable_iterator(std::nullptr_t, RequestsBuffer* parent)
+        : it(parent->list_.end()), buffer_size(0), parent(parent) {}
+
+    mutable_iterator(list_iterator it, RequestsBuffer* parent)
+        : it(it), buffer_size(it->second.buffer_size()), parent(parent) {}
+    ~mutable_iterator() {
+      if (it == parent->list_.end()) return;
+      // The entry must not have been erased.
+      DCHECK(parent->lookup_map_.contains(it->first));
+      // Update the total buffer size if the buffer size has changed.
+      if (buffer_size == it->second.buffer_size()) {
+        return;
+      }
+      parent->total_buffer_size_ += it->second.buffer_size();
+      DCHECK_GE(parent->total_buffer_size_, buffer_size);
+      parent->total_buffer_size_ -= buffer_size;
+      parent->enforceBufferLimits();
+    }
+  };
+
+  explicit RequestsBuffer(size_t max_total_buffer_size)
+      : max_total_buffer_size_(max_total_buffer_size) {}
+
+  size_t max_total_buffer_size() const { return max_total_buffer_size_; }
+  size_t total_buffer_size() const { return total_buffer_size_; }
+
+  const_list_iterator begin() const { return list_.begin(); }
+  const_list_iterator end() const { return list_.end(); }
+
+  // Get a mutable iterator to the entry with the given key.
+  // The iterator will update the total buffer size when it is destroyed.
+  mutable_iterator find(const protocol::String& key) {
+    auto it = lookup_map_.find(key);
+    if (it == lookup_map_.end()) {
+      return mutable_iterator(nullptr, this);
+    }
+    return mutable_iterator(it->second, this);
+  }
+  const_list_iterator cfind(const protocol::String& key) const {
+    auto it = lookup_map_.find(key);
+    if (it == lookup_map_.end()) {
+      return list_.end();
+    }
+    return it->second;
+  }
+
+  bool contains(const protocol::String& key) const {
+    return lookup_map_.contains(key);
+  }
+
+  bool emplace(const protocol::String& key, RequestEntry&& value) {
+    if (lookup_map_.contains(key)) {
+      return false;
+    }
+    list_.emplace_front(key, std::move(value));
+    lookup_map_[key] = list_.begin();
+    // No buffer yet.
+    DCHECK_EQ(begin()->second.buffer_size(), 0u);
+    return true;
+  }
+
+  void erase(const protocol::String& key) {
+    auto it = lookup_map_.find(key);
+    if (it == lookup_map_.end()) {
+      return;
+    }
+    erase(it->second);
+  }
+
+  void erase(const_list_iterator it) {
+    DCHECK(it != list_.end());
+    DCHECK_GE(total_buffer_size_, it->second.buffer_size());
+    total_buffer_size_ -= it->second.buffer_size();
+    lookup_map_.erase(it->first);
+    list_.erase(it);
+  }
+
+ private:
+  void enforceBufferLimits() {
+    while (total_buffer_size_ > max_total_buffer_size_ && !list_.empty()) {
+      auto last_it = --list_.end();
+      erase(last_it);
+    }
+  }
+
+  size_t max_total_buffer_size_;
+  size_t total_buffer_size_ = 0;
+
+  std::list<key_value_pair_t> list_;
+  std::map<protocol::String, list_iterator> lookup_map_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NETWORK_REQUESTS_BUFFER_H_

package/src/headers/26/inspector/network_resource_manager.h

@@ -0,0 +1,29 @@
+// network_resource_manager.h
+#ifndef SRC_INSPECTOR_NETWORK_RESOURCE_MANAGER_H_
+#define SRC_INSPECTOR_NETWORK_RESOURCE_MANAGER_H_
+
+#include <atomic>
+#include <string>
+#include <unordered_map>
+#include "node_mutex.h"
+
+namespace node {
+namespace inspector {
+
+class NetworkResourceManager {
+ public:
+  void Put(const std::string& url, const std::string& data);
+  std::string Get(const std::string& url);
+
+  // Erase resource and mapping by stream id
+  void Erase(const std::string& stream_id);
+
+ private:
+  std::unordered_map<std::string, std::string> resources_;
+  Mutex mutex_;  // Protects access to resources_
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NETWORK_RESOURCE_MANAGER_H_

package/src/headers/26/inspector/node_json.h

@@ -0,0 +1,24 @@
+#ifndef SRC_INSPECTOR_NODE_JSON_H_
+#define SRC_INSPECTOR_NODE_JSON_H_
+
+#include "node/inspector/protocol/Protocol.h"
+
+namespace node {
+namespace inspector {
+
+struct JsonUtil {
+  // Parse s JSON string into protocol::Value.
+  static std::unique_ptr<protocol::Value> ParseJSON(const uint8_t* chars,
+                                                    size_t size);
+  static std::unique_ptr<protocol::Value> ParseJSON(const uint16_t* chars,
+                                                    size_t size);
+
+  static std::unique_ptr<protocol::Value> parseJSON(const std::string_view);
+  static std::unique_ptr<protocol::Value> parseJSON(
+      v8_inspector::StringView view);
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NODE_JSON_H_

package/src/headers/26/inspector/node_string.h

@@ -0,0 +1,101 @@
+// Bridges V8 Inspector generated code with the std::string used by the Node
+// Compare to V8 counterpart - deps/v8/src/inspector/string-util.h
+#ifndef SRC_INSPECTOR_NODE_STRING_H_
+#define SRC_INSPECTOR_NODE_STRING_H_
+
+#include <cstring>
+#include <sstream>
+#include <string>
+#include "crdtp/protocol_core.h"
+#include "util.h"
+#include "v8-inspector.h"
+
+namespace node::inspector::protocol {
+class Binary;
+}
+
+namespace crdtp {
+
+template <>
+struct ProtocolTypeTraits<std::string> {
+  static bool Deserialize(DeserializerState* state, std::string* value);
+  static void Serialize(const std::string& value, std::vector<uint8_t>* bytes);
+};
+
+template <>
+struct ProtocolTypeTraits<node::inspector::protocol::Binary> {
+  static bool Deserialize(DeserializerState* state,
+                          node::inspector::protocol::Binary* value);
+  static void Serialize(const node::inspector::protocol::Binary& value,
+                        std::vector<uint8_t>* bytes);
+};
+
+}  // namespace crdtp
+
+namespace node {
+namespace inspector {
+namespace protocol {
+
+class Value;
+
+using String = std::string;
+using StringBuilder = std::ostringstream;
+using ProtocolMessage = std::string;
+
+// Implements StringUtil methods used in `inspector_protocol/lib/`.
+// Refer to
+// https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/inspector/v8_inspector_string.h;l=40;drc=2b15d6974a49d3a14d3d67ae099a649d523a828d
+// for more details about the interface.
+struct StringUtil {
+  // Convert Utf16 in local endianness to Utf8 if needed.
+  static String StringViewToUtf8(v8_inspector::StringView view);
+  static String fromUTF16(const uint16_t* data, size_t length);
+
+  static String fromUTF8(const uint8_t* data, size_t length);
+  static String fromUTF16LE(const uint16_t* data, size_t length);
+  static const uint8_t* CharactersUTF8(const std::string_view s);
+  static size_t CharacterCount(const std::string_view s);
+
+  // Unimplemented. The generated code will fall back to CharactersUTF8().
+  inline static uint8_t* CharactersLatin1(const std::string_view s) {
+    return nullptr;
+  }
+  inline static const uint16_t* CharactersUTF16(const std::string_view s) {
+    return nullptr;
+  }
+};
+
+// A read-only sequence of uninterpreted bytes with reference-counted storage.
+class Binary {
+ public:
+  Binary() : bytes_(std::make_shared<std::vector<uint8_t>>()) {}
+
+  const uint8_t* data() const { return bytes_->data(); }
+  size_t size() const { return bytes_->size(); }
+
+  String toBase64() const;
+
+  static Binary concat(const std::vector<Binary>& binaries);
+
+  static Binary fromBase64(const String& base64, bool* success);
+  static Binary fromUint8Array(v8::Local<v8::Uint8Array> data);
+  static Binary fromSpan(const uint8_t* data, size_t size) {
+    return Binary::fromSpan(crdtp::span<uint8_t>(data, size));
+  }
+  static Binary fromSpan(crdtp::span<uint8_t> span) {
+    return Binary(
+        std::make_shared<std::vector<uint8_t>>(span.begin(), span.end()));
+  }
+
+ private:
+  std::shared_ptr<std::vector<uint8_t>> bytes_;
+
+  explicit Binary(std::shared_ptr<std::vector<uint8_t>> bytes)
+      : bytes_(bytes) {}
+};
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NODE_STRING_H_

package/src/headers/26/inspector/notification_emitter.h

@@ -0,0 +1,38 @@
+#ifndef SRC_INSPECTOR_NOTIFICATION_EMITTER_H_
+#define SRC_INSPECTOR_NOTIFICATION_EMITTER_H_
+
+#include <string>
+#include <unordered_map>
+#include "v8.h"
+
+namespace node {
+namespace inspector {
+
+class NotificationEmitter {
+ public:
+  using EventKey = std::string;
+  using EventNotifier =
+      std::function<void(v8::Local<v8::Context>, v8::Local<v8::Object>)>;
+
+  NotificationEmitter();
+  virtual ~NotificationEmitter() = default;
+
+  void emitNotification(v8::Local<v8::Context> context,
+                        const EventKey& event,
+                        v8::Local<v8::Object> params);
+  virtual bool canEmit(const std::string& domain) = 0;
+
+  NotificationEmitter(const NotificationEmitter&) = delete;
+  NotificationEmitter& operator=(const NotificationEmitter&) = delete;
+
+ protected:
+  void addEventNotifier(const EventKey& event, EventNotifier notifier);
+
+ private:
+  std::unordered_map<EventKey, EventNotifier> event_notifier_map_ = {};
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NOTIFICATION_EMITTER_H_

package/src/headers/26/inspector/protocol_helper.h

@@ -0,0 +1,27 @@
+#ifndef SRC_INSPECTOR_PROTOCOL_HELPER_H_
+#define SRC_INSPECTOR_PROTOCOL_HELPER_H_
+
+#include "node/inspector/protocol/Protocol.h"
+#include "util.h"
+#include "v8-inspector.h"
+
+namespace node::inspector {
+
+// Convert a V8 string to v8_inspector StringBuffer, encoded in UTF16.
+inline std::unique_ptr<v8_inspector::StringBuffer> ToInspectorString(
+    v8::Isolate* isolate, v8::Local<v8::Value> value) {
+  TwoByteValue buffer(isolate, value);
+  return v8_inspector::StringBuffer::create(
+      v8_inspector::StringView(*buffer, buffer.length()));
+}
+
+// Convert a V8 string to node::inspector::protocol::String, encoded in UTF8.
+inline protocol::String ToProtocolString(v8::Isolate* isolate,
+                                         v8::Local<v8::Value> value) {
+  Utf8Value buffer(isolate, value);
+  return buffer.ToString();
+}
+
+}  // namespace node::inspector
+
+#endif  // SRC_INSPECTOR_PROTOCOL_HELPER_H_