@encharm/cws 4.4.0 → 4.5.1

package/src/headers/14/node_http2_state.h

@@ -1,149 +0,0 @@
-#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
-  };
-
-  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_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(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 options_buffer;
-  AliasedUint32Array settings_buffer;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_SELF_SIZE(Http2State)
-  SET_MEMORY_INFO_NAME(Http2State)
-
-  static constexpr FastStringKey binding_data_name { "http2" };
-
- 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];
-    uint32_t settings_buffer[IDX_SETTINGS_COUNT + 1];
-  };
-};
-
-}  // namespace http2
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_HTTP2_STATE_H_

package/src/headers/14/node_http_common-inl.h

@@ -1,194 +0,0 @@
-#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>
-
-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 = 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].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;
-  }
-}
-
-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
-    : 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();
-}
-
-}  // namespace node
-
-#endif  // SRC_NODE_HTTP_COMMON_INL_H_