@kungfu-tech/libnode-win32-x64 0.0.0-bootstrap.0 → 22.22.3-kf.1

package/dist/node/include/node_http2_state.h

@@ -0,0 +1,159 @@
+#ifndef SRC_NODE_HTTP2_STATE_H_
+#define SRC_NODE_HTTP2_STATE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_buffer.h"
+
+struct nghttp2_rcbuf;
+
+namespace node {
+namespace http2 {
+
+  enum Http2SettingsIndex {
+    IDX_SETTINGS_HEADER_TABLE_SIZE,
+    IDX_SETTINGS_ENABLE_PUSH,
+    IDX_SETTINGS_INITIAL_WINDOW_SIZE,
+    IDX_SETTINGS_MAX_FRAME_SIZE,
+    IDX_SETTINGS_MAX_CONCURRENT_STREAMS,
+    IDX_SETTINGS_MAX_HEADER_LIST_SIZE,
+    IDX_SETTINGS_ENABLE_CONNECT_PROTOCOL,
+    IDX_SETTINGS_COUNT
+  };
+
+  // number of max additional settings, thus settings not implemented by nghttp2
+  const size_t MAX_ADDITIONAL_SETTINGS = 10;
+
+  enum Http2SessionStateIndex {
+    IDX_SESSION_STATE_EFFECTIVE_LOCAL_WINDOW_SIZE,
+    IDX_SESSION_STATE_EFFECTIVE_RECV_DATA_LENGTH,
+    IDX_SESSION_STATE_NEXT_STREAM_ID,
+    IDX_SESSION_STATE_LOCAL_WINDOW_SIZE,
+    IDX_SESSION_STATE_LAST_PROC_STREAM_ID,
+    IDX_SESSION_STATE_REMOTE_WINDOW_SIZE,
+    IDX_SESSION_STATE_OUTBOUND_QUEUE_SIZE,
+    IDX_SESSION_STATE_HD_DEFLATE_DYNAMIC_TABLE_SIZE,
+    IDX_SESSION_STATE_HD_INFLATE_DYNAMIC_TABLE_SIZE,
+    IDX_SESSION_STATE_COUNT
+  };
+
+  enum Http2StreamStateIndex {
+    IDX_STREAM_STATE,
+    IDX_STREAM_STATE_WEIGHT,
+    IDX_STREAM_STATE_SUM_DEPENDENCY_WEIGHT,
+    IDX_STREAM_STATE_LOCAL_CLOSE,
+    IDX_STREAM_STATE_REMOTE_CLOSE,
+    IDX_STREAM_STATE_LOCAL_WINDOW_SIZE,
+    IDX_STREAM_STATE_COUNT
+  };
+
+  enum Http2OptionsIndex {
+    IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE,
+    IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS,
+    IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH,
+    IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS,
+    IDX_OPTIONS_PADDING_STRATEGY,
+    IDX_OPTIONS_MAX_HEADER_LIST_PAIRS,
+    IDX_OPTIONS_MAX_OUTSTANDING_PINGS,
+    IDX_OPTIONS_MAX_OUTSTANDING_SETTINGS,
+    IDX_OPTIONS_MAX_SESSION_MEMORY,
+    IDX_OPTIONS_MAX_SETTINGS,
+    IDX_OPTIONS_STREAM_RESET_RATE,
+    IDX_OPTIONS_STREAM_RESET_BURST,
+    IDX_OPTIONS_STRICT_HTTP_FIELD_WHITESPACE_VALIDATION,
+    IDX_OPTIONS_FLAGS
+  };
+
+  enum Http2StreamStatisticsIndex {
+    IDX_STREAM_STATS_ID,
+    IDX_STREAM_STATS_TIMETOFIRSTBYTE,
+    IDX_STREAM_STATS_TIMETOFIRSTHEADER,
+    IDX_STREAM_STATS_TIMETOFIRSTBYTESENT,
+    IDX_STREAM_STATS_SENTBYTES,
+    IDX_STREAM_STATS_RECEIVEDBYTES,
+    IDX_STREAM_STATS_COUNT
+  };
+
+  enum Http2SessionStatisticsIndex {
+    IDX_SESSION_STATS_TYPE,
+    IDX_SESSION_STATS_PINGRTT,
+    IDX_SESSION_STATS_FRAMESRECEIVED,
+    IDX_SESSION_STATS_FRAMESSENT,
+    IDX_SESSION_STATS_STREAMCOUNT,
+    IDX_SESSION_STATS_STREAMAVERAGEDURATION,
+    IDX_SESSION_STATS_DATA_SENT,
+    IDX_SESSION_STATS_DATA_RECEIVED,
+    IDX_SESSION_STATS_MAX_CONCURRENT_STREAMS,
+    IDX_SESSION_STATS_COUNT
+  };
+
+class Http2State : public BaseObject {
+ public:
+  Http2State(Realm* realm, v8::Local<v8::Object> obj)
+      : BaseObject(realm, obj),
+        root_buffer(realm->isolate(), sizeof(http2_state_internal)),
+        session_state_buffer(
+            realm->isolate(),
+            offsetof(http2_state_internal, session_state_buffer),
+            IDX_SESSION_STATE_COUNT,
+            root_buffer),
+        stream_state_buffer(realm->isolate(),
+                            offsetof(http2_state_internal, stream_state_buffer),
+                            IDX_STREAM_STATE_COUNT,
+                            root_buffer),
+        stream_stats_buffer(realm->isolate(),
+                            offsetof(http2_state_internal, stream_stats_buffer),
+                            IDX_STREAM_STATS_COUNT,
+                            root_buffer),
+        session_stats_buffer(
+            realm->isolate(),
+            offsetof(http2_state_internal, session_stats_buffer),
+            IDX_SESSION_STATS_COUNT,
+            root_buffer),
+        options_buffer(realm->isolate(),
+                       offsetof(http2_state_internal, options_buffer),
+                       IDX_OPTIONS_FLAGS + 1,
+                       root_buffer),
+        settings_buffer(
+            realm->isolate(),
+            offsetof(http2_state_internal, settings_buffer),
+            IDX_SETTINGS_COUNT + 1 + 1 + 2 * MAX_ADDITIONAL_SETTINGS,
+            root_buffer) {}
+
+  AliasedUint8Array root_buffer;
+  AliasedFloat64Array session_state_buffer;
+  AliasedFloat64Array stream_state_buffer;
+  AliasedFloat64Array stream_stats_buffer;
+  AliasedFloat64Array session_stats_buffer;
+  AliasedUint32Array options_buffer;
+  AliasedUint32Array settings_buffer;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(Http2State)
+  SET_MEMORY_INFO_NAME(Http2State)
+
+  SET_BINDING_ID(http2_binding_data)
+
+ private:
+  struct http2_state_internal {
+    // doubles first so that they are always sizeof(double)-aligned
+    double session_state_buffer[IDX_SESSION_STATE_COUNT];
+    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 options_buffer[IDX_OPTIONS_FLAGS + 1];
+    // first + 1: number of actual nghttp2 supported settings
+    // second + 1: number of additional settings not supported by nghttp2
+    // 2 * MAX_ADDITIONAL_SETTINGS: settings id and value for each
+    // additional setting
+    uint32_t settings_buffer[IDX_SETTINGS_COUNT + 1 + 1 +
+                             2 * MAX_ADDITIONAL_SETTINGS];
+  };
+};
+
+}  // namespace http2
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_HTTP2_STATE_H_

package/dist/node/include/node_http_common-inl.h

@@ -0,0 +1,202 @@
+#ifndef SRC_NODE_HTTP_COMMON_INL_H_
+#define SRC_NODE_HTTP_COMMON_INL_H_
+
+#include "node_http_common.h"
+#include "node.h"
+#include "node_mem-inl.h"
+#include "env-inl.h"
+#include "v8.h"
+
+#include <algorithm>
+#include "nbytes.h"
+
+namespace node {
+
+template <typename T>
+NgHeaders<T>::NgHeaders(Environment* env, v8::Local<v8::Array> headers) {
+  v8::Local<v8::Value> header_string =
+      headers->Get(env->context(), 0).ToLocalChecked();
+  v8::Local<v8::Value> header_count =
+      headers->Get(env->context(), 1).ToLocalChecked();
+  CHECK(header_count->IsUint32());
+  CHECK(header_string->IsString());
+  count_ = header_count.As<v8::Uint32>()->Value();
+  int header_string_len = header_string.As<v8::String>()->Length();
+
+  if (count_ == 0) {
+    CHECK_EQ(header_string_len, 0);
+    return;
+  }
+
+  buf_.AllocateSufficientStorage((alignof(nv_t) - 1) +
+                                 count_ * sizeof(nv_t) +
+                                 header_string_len);
+
+  char* start = nbytes::AlignUp(buf_.out(), alignof(nv_t));
+  char* header_contents = start + (count_ * sizeof(nv_t));
+  nv_t* const nva = reinterpret_cast<nv_t*>(start);
+
+  CHECK_LE(header_contents + header_string_len, *buf_ + buf_.length());
+  CHECK_EQ(header_string.As<v8::String>()->WriteOneByte(
+               env->isolate(),
+               reinterpret_cast<uint8_t*>(header_contents),
+               0,
+               header_string_len,
+               v8::String::NO_NULL_TERMINATION),
+           header_string_len);
+
+  size_t n = 0;
+  char* p;
+  for (p = header_contents; p < header_contents + header_string_len; n++) {
+    if (n >= count_) {
+      static uint8_t zero = '\0';
+      nva[0].name = nva[0].value = &zero;
+      nva[0].namelen = nva[0].valuelen = 1;
+      count_ = 1;
+      return;
+    }
+
+    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++;
+  }
+}
+
+size_t GetClientMaxHeaderPairs(size_t max_header_pairs) {
+  static constexpr size_t min_header_pairs = 1;
+  return std::max(max_header_pairs, min_header_pairs);
+}
+
+size_t GetServerMaxHeaderPairs(size_t max_header_pairs) {
+  static constexpr size_t min_header_pairs = 4;
+  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,
+    NgHeader<T>::rcbuf_t* value) {
+  return IsZeroLength(-1, name, value);
+}
+
+template <typename T>
+bool NgHeader<T>::IsZeroLength(
+    int32_t token,
+    NgHeader<T>::rcbuf_t* name,
+    NgHeader<T>::rcbuf_t* value) {
+
+  if (NgHeader<T>::rcbufferpointer_t::IsZeroLength(value))
+    return true;
+
+  const char* header_name = T::ToHttpHeaderName(token);
+  return header_name != nullptr ||
+      NgHeader<T>::rcbufferpointer_t::IsZeroLength(name);
+}
+
+template <typename T>
+NgHeader<T>::NgHeader(
+    Environment* env,
+    NgHeader<T>::rcbuf_t* name,
+    NgHeader<T>::rcbuf_t* value,
+    uint8_t flags)
+    : NgHeader<T>(env, -1, name, value, flags) {}
+
+template <typename T>
+NgHeader<T>::NgHeader(
+    Environment* env,
+    int32_t token,
+    NgHeader<T>::rcbuf_t* name,
+    NgHeader<T>::rcbuf_t* value,
+    uint8_t flags) : env_(env), token_(token), flags_(flags) {
+  if (token == -1) {
+    CHECK_NOT_NULL(name);
+    name_.reset(name, true);  // Internalizable
+  }
+  CHECK_NOT_NULL(value);
+  name_.reset(name, true);  // Internalizable
+  value_.reset(value);
+}
+
+template <typename T>
+NgHeader<T>::NgHeader(NgHeader<T>&& other) noexcept
+    : env_(other.env_),
+      name_(std::move(other.name_)),
+      value_(std::move(other.value_)),
+      token_(other.token_),
+      flags_(other.flags_) {
+  other.token_ = -1;
+  other.flags_ = 0;
+  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 {
+
+  // Not all instances will support using token id's for header names.
+  // HTTP/2 specifically does not support it.
+  const char* header_name = T::ToHttpHeaderName(token_);
+
+  // 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()->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);
+      eternal.Set(env_->isolate(), str);
+      return str;
+    }
+    return eternal.Get(env_->isolate());
+  }
+  return rcbufferpointer_t::External::New(allocator, name_);
+}
+
+template <typename T>
+v8::MaybeLocal<v8::String> NgHeader<T>::GetValue(
+    NgHeader<T>::allocator_t* allocator) const {
+  return rcbufferpointer_t::External::New(allocator, value_);
+}
+
+template <typename T>
+std::string NgHeader<T>::name() const {
+  return name_.str();
+}
+
+template <typename T>
+std::string NgHeader<T>::value() const {
+  return value_.str();
+}
+
+template <typename T>
+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_