@encharm/cws 4.4.1 → 4.5.1

package/src/headers/{18 → 22}/node_file-inl.h

@@ -86,13 +86,22 @@ template <typename NativeT, typename V8T>
 void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
                     const uv_stat_t* s,
                     const size_t offset) {
-#define SET_FIELD_WITH_STAT(stat_offset, stat)                               \
-  fields->SetValue(offset + static_cast<size_t>(FsStatsOffset::stat_offset), \
+#define SET_FIELD_WITH_STAT(stat_offset, stat)                                 \
+  fields->SetValue(offset + static_cast<size_t>(FsStatsOffset::stat_offset),   \
                    static_cast<NativeT>(stat))
 
-#define SET_FIELD_WITH_TIME_STAT(stat_offset, stat)                          \
-  /* NOLINTNEXTLINE(runtime/int) */                                          \
+// On win32, time is stored in uint64_t and starts from 1601-01-01.
+// libuv calculates tv_sec and tv_nsec from it and converts to signed long,
+// which causes Y2038 overflow. On the other platforms it is safe to treat
+// negative values as pre-epoch time.
+#ifdef _WIN32
+#define SET_FIELD_WITH_TIME_STAT(stat_offset, stat)                            \
+  /* NOLINTNEXTLINE(runtime/int) */                                            \
   SET_FIELD_WITH_STAT(stat_offset, static_cast<unsigned long>(stat))
+#else
+#define SET_FIELD_WITH_TIME_STAT(stat_offset, stat)                            \
+  SET_FIELD_WITH_STAT(stat_offset, static_cast<double>(stat))
+#endif  // _WIN32
 
   SET_FIELD_WITH_STAT(kDev, s->st_dev);
   SET_FIELD_WITH_STAT(kMode, s->st_mode);
@@ -135,6 +144,38 @@ v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
   }
 }
 
+template <typename NativeT, typename V8T>
+void FillStatFsArray(AliasedBufferBase<NativeT, V8T>* fields,
+                     const uv_statfs_t* s) {
+#define SET_FIELD(field, stat)                                                 \
+  fields->SetValue(static_cast<size_t>(FsStatFsOffset::field),                 \
+                   static_cast<NativeT>(stat))
+
+  SET_FIELD(kType, s->f_type);
+  SET_FIELD(kBSize, s->f_bsize);
+  SET_FIELD(kBlocks, s->f_blocks);
+  SET_FIELD(kBFree, s->f_bfree);
+  SET_FIELD(kBAvail, s->f_bavail);
+  SET_FIELD(kFiles, s->f_files);
+  SET_FIELD(kFFree, s->f_ffree);
+
+#undef SET_FIELD
+}
+
+v8::Local<v8::Value> FillGlobalStatFsArray(BindingData* binding_data,
+                                           const bool use_bigint,
+                                           const uv_statfs_t* s) {
+  if (use_bigint) {
+    auto* const arr = &binding_data->statfs_field_bigint_array;
+    FillStatFsArray(arr, s);
+    return arr->GetJSArray();
+  } else {
+    auto* const arr = &binding_data->statfs_field_array;
+    FillStatFsArray(arr, s);
+    return arr->GetJSArray();
+  }
+}
+
 template <typename AliasedBufferT>
 FSReqPromise<AliasedBufferT>*
 FSReqPromise<AliasedBufferT>::New(BindingData* binding_data,
@@ -156,31 +197,39 @@ FSReqPromise<AliasedBufferT>::New(BindingData* binding_data,
 
 template <typename AliasedBufferT>
 FSReqPromise<AliasedBufferT>::~FSReqPromise() {
-  // Validate that the promise was explicitly resolved or rejected.
-  CHECK(finished_);
+  // Validate that the promise was explicitly resolved or rejected but only if
+  // the Isolate is not terminating because in this case the promise might have
+  // not finished.
+  CHECK_IMPLIES(!finished_, !env()->can_call_into_js());
 }
 
 template <typename AliasedBufferT>
-FSReqPromise<AliasedBufferT>::FSReqPromise(
-    BindingData* binding_data,
-    v8::Local<v8::Object> obj,
-    bool use_bigint)
-  : FSReqBase(binding_data,
-              obj,
-              AsyncWrap::PROVIDER_FSREQPROMISE,
-              use_bigint),
-    stats_field_array_(
-        env()->isolate(),
-        static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)) {}
+FSReqPromise<AliasedBufferT>::FSReqPromise(BindingData* binding_data,
+                                           v8::Local<v8::Object> obj,
+                                           bool use_bigint)
+    : FSReqBase(
+          binding_data, obj, AsyncWrap::PROVIDER_FSREQPROMISE, use_bigint),
+      stats_field_array_(
+          env()->isolate(),
+          static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)),
+      statfs_field_array_(
+          env()->isolate(),
+          static_cast<size_t>(FsStatFsOffset::kFsStatFsFieldsNumber)) {}
 
 template <typename AliasedBufferT>
 void FSReqPromise<AliasedBufferT>::Reject(v8::Local<v8::Value> reject) {
   finished_ = true;
   v8::HandleScope scope(env()->isolate());
   InternalCallbackScope callback_scope(this);
-  v8::Local<v8::Value> value =
-      object()->Get(env()->context(),
-                    env()->promise_string()).ToLocalChecked();
+  v8::Local<v8::Value> value;
+  if (!object()
+           ->Get(env()->context(), env()->promise_string())
+           .ToLocal(&value)) {
+    // If we hit this, getting the value from the object failed and
+    // an error was likely scheduled. We could try to reject the promise
+    // but let's just allow the error to propagate.
+    return;
+  }
   v8::Local<v8::Promise::Resolver> resolver = value.As<v8::Promise::Resolver>();
   USE(resolver->Reject(env()->context(), reject).FromJust());
 }
@@ -190,9 +239,13 @@ void FSReqPromise<AliasedBufferT>::Resolve(v8::Local<v8::Value> value) {
   finished_ = true;
   v8::HandleScope scope(env()->isolate());
   InternalCallbackScope callback_scope(this);
-  v8::Local<v8::Value> val =
-      object()->Get(env()->context(),
-                    env()->promise_string()).ToLocalChecked();
+  v8::Local<v8::Value> val;
+  if (!object()->Get(env()->context(), env()->promise_string()).ToLocal(&val)) {
+    // If we hit this, getting the value from the object failed and
+    // an error was likely scheduled. We could try to reject the promise
+    // but let's just allow the error to propagate.
+    return;
+  }
   v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
   USE(resolver->Resolve(env()->context(), value).FromJust());
 }
@@ -203,12 +256,22 @@ void FSReqPromise<AliasedBufferT>::ResolveStat(const uv_stat_t* stat) {
   Resolve(stats_field_array_.GetJSArray());
 }
 
+template <typename AliasedBufferT>
+void FSReqPromise<AliasedBufferT>::ResolveStatFs(const uv_statfs_t* stat) {
+  FillStatFsArray(&statfs_field_array_, stat);
+  Resolve(statfs_field_array_.GetJSArray());
+}
+
 template <typename AliasedBufferT>
 void FSReqPromise<AliasedBufferT>::SetReturnValue(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::Local<v8::Value> val =
-      object()->Get(env()->context(),
-                    env()->promise_string()).ToLocalChecked();
+  v8::Local<v8::Value> val;
+  if (!object()->Get(env()->context(), env()->promise_string()).ToLocal(&val)) {
+    // If we hit this, getting the value from the object failed and
+    // an error was likely scheduled. We could try to reject the promise
+    // but let's just allow the error to propagate.
+    return;
+  }
   v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
   args.GetReturnValue().Set(resolver->GetPromise());
 }
@@ -217,6 +280,7 @@ template <typename AliasedBufferT>
 void FSReqPromise<AliasedBufferT>::MemoryInfo(MemoryTracker* tracker) const {
   FSReqBase::MemoryInfo(tracker);
   tracker->TrackField("stats_field_array", stats_field_array_);
+  tracker->TrackField("statfs_field_array", statfs_field_array_);
 }
 
 FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
@@ -227,11 +291,12 @@ FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
     return Unwrap<FSReqBase>(value.As<v8::Object>());
   }
 
-  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
-  Environment* env = binding_data->env();
-  if (value->StrictEquals(env->fs_use_promises_symbol())) {
+  Realm* realm = Realm::GetCurrent(args);
+  BindingData* binding_data = realm->GetBindingData<BindingData>();
+
+  if (value->StrictEquals(realm->isolate_data()->fs_use_promises_symbol())) {
     if (use_bigint) {
-      return FSReqPromise<AliasedBigUint64Array>::New(binding_data, use_bigint);
+      return FSReqPromise<AliasedBigInt64Array>::New(binding_data, use_bigint);
     } else {
       return FSReqPromise<AliasedFloat64Array>::New(binding_data, use_bigint);
     }
@@ -298,6 +363,38 @@ int SyncCall(Environment* env, v8::Local<v8::Value> ctx,
   return err;
 }
 
+// Similar to SyncCall but throws immediately if there is an error.
+template <typename Predicate, typename Func, typename... Args>
+int SyncCallAndThrowIf(Predicate should_throw,
+                       Environment* env,
+                       FSReqWrapSync* req_wrap,
+                       Func fn,
+                       Args... args) {
+  env->PrintSyncTrace();
+  int result = fn(nullptr, &(req_wrap->req), args..., nullptr);
+  if (should_throw(result)) {
+    env->ThrowUVException(result,
+                          req_wrap->syscall_p,
+                          nullptr,
+                          req_wrap->path_p,
+                          req_wrap->dest_p);
+  }
+  return result;
+}
+
+constexpr bool is_uv_error(int result) {
+  return result < 0;
+}
+
+// Similar to SyncCall but throws immediately if there is an error.
+template <typename Func, typename... Args>
+int SyncCallAndThrowOnError(Environment* env,
+                            FSReqWrapSync* req_wrap,
+                            Func fn,
+                            Args... args) {
+  return SyncCallAndThrowIf(is_uv_error, env, req_wrap, fn, args...);
+}
+
 }  // namespace fs
 }  // namespace node
 

package/src/headers/{16 → 22}/node_file.h

@@ -3,6 +3,7 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include <optional>
 #include "aliased_buffer.h"
 #include "node_messaging.h"
 #include "node_snapshotable.h"
@@ -13,24 +14,94 @@ namespace fs {
 
 class FileHandleReadWrap;
 
+enum class FsStatsOffset {
+  kDev = 0,
+  kMode,
+  kNlink,
+  kUid,
+  kGid,
+  kRdev,
+  kBlkSize,
+  kIno,
+  kSize,
+  kBlocks,
+  kATimeSec,
+  kATimeNsec,
+  kMTimeSec,
+  kMTimeNsec,
+  kCTimeSec,
+  kCTimeNsec,
+  kBirthTimeSec,
+  kBirthTimeNsec,
+  kFsStatsFieldsNumber
+};
+
+// Stat fields buffers contain twice the number of entries in an uv_stat_t
+// because `fs.StatWatcher` needs room to store 2 `fs.Stats` instances.
+constexpr size_t kFsStatsBufferLength =
+    static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber) * 2;
+
+enum class FsStatFsOffset {
+  kType = 0,
+  kBSize,
+  kBlocks,
+  kBFree,
+  kBAvail,
+  kFiles,
+  kFFree,
+  kFsStatFsFieldsNumber
+};
+
+constexpr size_t kFsStatFsBufferLength =
+    static_cast<size_t>(FsStatFsOffset::kFsStatFsFieldsNumber);
+
 class BindingData : public SnapshotableObject {
  public:
-  explicit BindingData(Environment* env, v8::Local<v8::Object> wrap);
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex stats_field_array;
+    AliasedBufferIndex stats_field_bigint_array;
+    AliasedBufferIndex statfs_field_array;
+    AliasedBufferIndex statfs_field_bigint_array;
+  };
+
+  enum class FilePathIsFileReturnType {
+    kIsFile = 0,
+    kIsNotFile,
+    kThrowInsufficientPermissions
+  };
+
+  explicit BindingData(Realm* realm,
+                       v8::Local<v8::Object> wrap,
+                       InternalFieldInfo* info = nullptr);
 
   AliasedFloat64Array stats_field_array;
-  AliasedBigUint64Array stats_field_bigint_array;
+  AliasedBigInt64Array stats_field_bigint_array;
+
+  AliasedFloat64Array statfs_field_array;
+  AliasedBigInt64Array statfs_field_bigint_array;
 
   std::vector<BaseObjectPtr<FileHandleReadWrap>>
       file_handle_read_wrap_freelist;
 
   SERIALIZABLE_OBJECT_METHODS()
-  static constexpr FastStringKey type_name{"node::fs::BindingData"};
-  static constexpr EmbedderObjectType type_int =
-      EmbedderObjectType::k_fs_binding_data;
+  SET_BINDING_ID(fs_binding_data)
+
+  static void LegacyMainResolve(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> ctor);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_SELF_SIZE(BindingData)
   SET_MEMORY_INFO_NAME(BindingData)
+
+ private:
+  InternalFieldInfo* internal_field_info_ = nullptr;
+
+  static FilePathIsFileReturnType FilePathIsFile(Environment* env,
+                                                 const std::string& file_path);
 };
 
 // structure used to store state during a complex operation, e.g., mkdirp.
@@ -81,6 +152,7 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
   virtual void Reject(v8::Local<v8::Value> reject) = 0;
   virtual void Resolve(v8::Local<v8::Value> value) = 0;
   virtual void ResolveStat(const uv_stat_t* stat) = 0;
+  virtual void ResolveStatFs(const uv_statfs_t* stat) = 0;
   virtual void SetReturnValue(
       const v8::FunctionCallbackInfo<v8::Value>& args) = 0;
 
@@ -89,8 +161,10 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
   enum encoding encoding() const { return encoding_; }
   bool use_bigint() const { return use_bigint_; }
   bool is_plain_open() const { return is_plain_open_; }
+  bool with_file_types() const { return with_file_types_; }
 
   void set_is_plain_open(bool value) { is_plain_open_ = value; }
+  void set_with_file_types(bool value) { with_file_types_ = value; }
 
   FSContinuationData* continuation_data() const {
     return continuation_data_.get();
@@ -116,6 +190,7 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
   bool has_data_ = false;
   bool use_bigint_ = false;
   bool is_plain_open_ = false;
+  bool with_file_types_ = false;
   const char* syscall_ = nullptr;
 
   BaseObjectPtr<BindingData> binding_data_;
@@ -134,6 +209,7 @@ class FSReqCallback final : public FSReqBase {
   void Reject(v8::Local<v8::Value> reject) override;
   void Resolve(v8::Local<v8::Value> value) override;
   void ResolveStat(const uv_stat_t* stat) override;
+  void ResolveStatFs(const uv_statfs_t* stat) override;
   void SetReturnValue(const v8::FunctionCallbackInfo<v8::Value>& args) override;
 
   SET_MEMORY_INFO_NAME(FSReqCallback)
@@ -153,6 +229,14 @@ inline v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
                                                  const uv_stat_t* s,
                                                  const bool second = false);
 
+template <typename NativeT, typename V8T>
+void FillStatFsArray(AliasedBufferBase<NativeT, V8T>* fields,
+                     const uv_statfs_t* s);
+
+inline v8::Local<v8::Value> FillGlobalStatFsArray(BindingData* binding_data,
+                                                  const bool use_bigint,
+                                                  const uv_statfs_t* s);
+
 template <typename AliasedBufferT>
 class FSReqPromise final : public FSReqBase {
  public:
@@ -163,6 +247,7 @@ class FSReqPromise final : public FSReqBase {
   inline void Reject(v8::Local<v8::Value> reject) override;
   inline void Resolve(v8::Local<v8::Value> value) override;
   inline void ResolveStat(const uv_stat_t* stat) override;
+  inline void ResolveStatFs(const uv_statfs_t* stat) override;
   inline void SetReturnValue(
       const v8::FunctionCallbackInfo<v8::Value>& args) override;
   inline void MemoryInfo(MemoryTracker* tracker) const override;
@@ -182,6 +267,7 @@ class FSReqPromise final : public FSReqBase {
 
   bool finished_ = false;
   AliasedBufferT stats_field_array_;
+  AliasedBufferT statfs_field_array_;
 };
 
 class FSReqAfterScope final {
@@ -242,13 +328,17 @@ class FileHandle final : public AsyncWrap, public StreamBase {
 
   static FileHandle* New(BindingData* binding_data,
                          int fd,
-                         v8::Local<v8::Object> obj = v8::Local<v8::Object>());
+                         v8::Local<v8::Object> obj = v8::Local<v8::Object>(),
+                         std::optional<int64_t> maybeOffset = std::nullopt,
+                         std::optional<int64_t> maybeLength = std::nullopt);
   ~FileHandle() override;
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   int GetFD() override { return fd_; }
 
+  int Release();
+
   // Will asynchronously close the FD and return a Promise that will
   // be resolved once closing is complete.
   static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -283,7 +373,7 @@ class FileHandle final : public AsyncWrap, public StreamBase {
   FileHandle(const FileHandle&&) = delete;
   FileHandle& operator=(const FileHandle&&) = delete;
 
-  TransferMode GetTransferMode() const override;
+  BaseObject::TransferMode GetTransferMode() const override;
   std::unique_ptr<worker::TransferData> TransferForMessaging() override;
 
  private:
@@ -367,10 +457,22 @@ int MKDirpSync(uv_loop_t* loop,
 
 class FSReqWrapSync {
  public:
-  FSReqWrapSync() = default;
+  FSReqWrapSync(const char* syscall = nullptr,
+                const char* path = nullptr,
+                const char* dest = nullptr)
+      : syscall_p(syscall), path_p(path), dest_p(dest) {}
   ~FSReqWrapSync() { uv_fs_req_cleanup(&req); }
+
   uv_fs_t req;
+  const char* syscall_p;
+  const char* path_p;
+  const char* dest_p;
 
+  FSReqWrapSync(const FSReqWrapSync&) = delete;
+  FSReqWrapSync& operator=(const FSReqWrapSync&) = delete;
+
+  // TODO(joyeecheung): move these out of FSReqWrapSync and into a special
+  // class for mkdirp
   FSContinuationData* continuation_data() const {
     return continuation_data_.get();
   }
@@ -378,9 +480,6 @@ class FSReqWrapSync {
     continuation_data_ = std::move(data);
   }
 
-  FSReqWrapSync(const FSReqWrapSync&) = delete;
-  FSReqWrapSync& operator=(const FSReqWrapSync&) = delete;
-
  private:
   std::unique_ptr<FSContinuationData> continuation_data_;
 };
@@ -417,6 +516,18 @@ inline int SyncCall(Environment* env, v8::Local<v8::Value> ctx,
                     FSReqWrapSync* req_wrap, const char* syscall,
                     Func fn, Args... args);
 
+// Similar to SyncCall but throws immediately if there is an error.
+template <typename Predicate, typename Func, typename... Args>
+int SyncCallAndThrowIf(Predicate should_throw,
+                       Environment* env,
+                       FSReqWrapSync* req_wrap,
+                       Func fn,
+                       Args... args);
+template <typename Func, typename... Args>
+int SyncCallAndThrowOnError(Environment* env,
+                            FSReqWrapSync* req_wrap,
+                            Func fn,
+                            Args... args);
 }  // namespace fs
 
 }  // namespace node

package/src/headers/{18 → 22}/node_http2.h

@@ -3,8 +3,9 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-// FIXME(joyeecheung): nghttp2.h needs stdint.h to compile on Windows
-#include <cstdint>
+// clang-format off
+#include "node.h"  // nghttp2.h needs ssize_t
+// clang-format on
 #include "nghttp2/nghttp2.h"
 
 #include "env.h"
@@ -626,6 +627,15 @@ class Http2Session : public AsyncWrap,
     flags_ |= kSessionStateClosed;
   }
 
+  struct custom_settings_state {
+    size_t number;
+    nghttp2_settings_entry entries[MAX_ADDITIONAL_SETTINGS];
+  };
+
+  custom_settings_state& custom_settings(bool local) {
+    return local ? local_custom_settings_ : remote_custom_settings_;
+  }
+
 #define IS_FLAG(name, flag)                                                    \
   bool is_##name() const { return flags_ & flag; }                             \
   void set_##name(bool on = true) {                                            \
@@ -714,7 +724,7 @@ class Http2Session : public AsyncWrap,
   static void AltSvc(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Origin(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  template <get_setting fn>
+  template <get_setting fn, bool local>
   static void RefreshSettings(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   uv_loop_t* event_loop() const {
@@ -738,6 +748,9 @@ class Http2Session : public AsyncWrap,
     current_session_memory_ -= amount;
   }
 
+  void UpdateLocalCustomSettings(size_t count_,
+                                 nghttp2_settings_entry* entries_);
+
   // Tell our custom memory allocator that this rcbuf is independent of
   // this session now, and may outlive it.
   void StopTrackingRcbuf(nghttp2_rcbuf* buf);
@@ -775,6 +788,8 @@ class Http2Session : public AsyncWrap,
  private:
   void EmitStatistics();
 
+  void FetchAllowedRemoteCustomSettings();
+
   // Frame Padding Strategies
   ssize_t OnDWordAlignedPadding(size_t frameLength,
                                 size_t maxPayloadLen);
@@ -842,11 +857,11 @@ class Http2Session : public AsyncWrap,
       const nghttp2_frame* frame,
       size_t maxPayloadLen,
       void* user_data);
-  static int OnNghttpError(
-      nghttp2_session* session,
-      const char* message,
-      size_t len,
-      void* user_data);
+  static int OnNghttpError(nghttp2_session* session,
+                           int lib_error_code,
+                           const char* message,
+                           size_t len,
+                           void* user_data);
   static int OnSendData(
       nghttp2_session* session,
       nghttp2_frame* frame,
@@ -914,6 +929,9 @@ class Http2Session : public AsyncWrap,
   size_t max_outstanding_settings_ = kDefaultMaxSettings;
   std::queue<BaseObjectPtr<Http2Settings>> outstanding_settings_;
 
+  struct custom_settings_state local_custom_settings_;
+  struct custom_settings_state remote_custom_settings_;
+
   std::vector<NgHttp2StreamWrite> outgoing_buffers_;
   std::vector<uint8_t> outgoing_storage_;
   size_t outgoing_length_ = 0;
@@ -1017,8 +1035,7 @@ class Http2Settings : public AsyncWrap {
   static void RefreshDefaults(Http2State* http2_state);
 
   // Update the local or remote settings for the given session
-  static void Update(Http2Session* session,
-                     get_setting fn);
+  static void Update(Http2Session* session, get_setting fn, bool local);
 
  private:
   static size_t Init(
@@ -1034,7 +1051,7 @@ class Http2Settings : public AsyncWrap {
   v8::Global<v8::Function> callback_;
   uint64_t startTime_;
   size_t count_ = 0;
-  nghttp2_settings_entry entries_[IDX_SETTINGS_COUNT];
+  nghttp2_settings_entry entries_[IDX_SETTINGS_COUNT + MAX_ADDITIONAL_SETTINGS];
 };
 
 class Origins {

package/src/headers/{16 → 22}/node_http2_state.h

@@ -21,6 +21,9 @@ namespace http2 {
     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,
@@ -55,6 +58,8 @@ namespace http2 {
     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_FLAGS
   };
 
@@ -83,37 +88,36 @@ namespace http2 {
 
 class Http2State : public BaseObject {
  public:
-  Http2State(Environment* env, v8::Local<v8::Object> obj)
-      : BaseObject(env, obj),
-        root_buffer(env->isolate(), sizeof(http2_state_internal)),
+  Http2State(Realm* realm, v8::Local<v8::Object> obj)
+      : BaseObject(realm, obj),
+        root_buffer(realm->isolate(), sizeof(http2_state_internal)),
         session_state_buffer(
-            env->isolate(),
+            realm->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),
+        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(
-            env->isolate(),
+            realm->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) {}
+        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;
@@ -127,7 +131,7 @@ class Http2State : public BaseObject {
   SET_SELF_SIZE(Http2State)
   SET_MEMORY_INFO_NAME(Http2State)
 
-  static constexpr FastStringKey type_name { "http2" };
+  SET_BINDING_ID(http2_binding_data)
 
  private:
   struct http2_state_internal {
@@ -137,7 +141,12 @@ class Http2State : public BaseObject {
     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];
+    // 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];
   };
 };