@encharm/cws 4.5.2 → 4.6.0

package/src/headers/26/quic/bindingdata.h

@@ -0,0 +1,440 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <base_object.h>
+#include <env.h>
+#include <memory_tracker.h>
+#include <nghttp3/nghttp3.h>
+#include <ngtcp2/ngtcp2.h>
+#include <ngtcp2/ngtcp2_crypto.h>
+#include <node.h>
+#include <node_mem.h>
+#include <uv.h>
+#include <v8.h>
+#include <functional>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+#include "defs.h"
+
+namespace node::quic {
+
+class Endpoint;
+class Packet;
+class Session;
+class SessionManager;
+
+// ============================================================================
+
+// The FunctionTemplates the BindingData will store for us.
+#define QUIC_CONSTRUCTORS(V)                                                   \
+  V(endpoint)                                                                  \
+  V(session)                                                                   \
+  V(stream)                                                                    \
+  V(udp)
+
+// The callbacks are persistent v8::Function references that are set in the
+// quic::BindingState used to communicate data and events back out to the JS
+// environment. They are set once from the JavaScript side when the
+// internalBinding('quic') is first loaded.
+#define QUIC_JS_CALLBACKS(V)                                                   \
+  V(endpoint_close, EndpointClose)                                             \
+  V(session_close, SessionClose)                                               \
+  V(session_application, SessionApplication)                                   \
+  V(session_early_data_rejected, SessionEarlyDataRejected)                     \
+  V(session_goaway, SessionGoaway)                                             \
+  V(session_datagram, SessionDatagram)                                         \
+  V(session_datagram_status, SessionDatagramStatus)                            \
+  V(session_handshake, SessionHandshake)                                       \
+  V(session_keylog, SessionKeyLog)                                             \
+  V(session_qlog, SessionQlog)                                                 \
+  V(session_new, SessionNew)                                                   \
+  V(session_new_token, SessionNewToken)                                        \
+  V(session_origin, SessionOrigin)                                             \
+  V(session_path_validation, SessionPathValidation)                            \
+  V(session_ticket, SessionTicket)                                             \
+  V(session_version_negotiation, SessionVersionNegotiation)                    \
+  V(stream_blocked, StreamBlocked)                                             \
+  V(stream_close, StreamClose)                                                 \
+  V(stream_created, StreamCreated)                                             \
+  V(stream_drain, StreamDrain)                                                 \
+  V(stream_headers, StreamHeaders)                                             \
+  V(stream_reset, StreamReset)                                                 \
+  V(stream_stop_sending, StreamStopSending)                                    \
+  V(stream_trailers, StreamTrailers)
+
+// The various JS strings the implementation uses.
+#define QUIC_STRINGS(V)                                                        \
+  V(abandoned, "abandoned")                                                    \
+  V(aborted, "aborted")                                                        \
+  V(acknowledged, "acknowledged")                                              \
+  V(ack_delay_exponent, "ackDelayExponent")                                    \
+  V(active_connection_id_limit, "activeConnectionIDLimit")                     \
+  V(address_lru_size, "addressLRUSize")                                        \
+  V(allow, "allow")                                                            \
+  V(application, "application")                                                \
+  V(authoritative, "authoritative")                                            \
+  V(bbr, "bbr")                                                                \
+  V(ca, "ca")                                                                  \
+  V(cc_algorithm, "cc")                                                        \
+  V(certificate_compression, "certificateCompression")                         \
+  V(certs, "certs")                                                            \
+  V(code, "code")                                                              \
+  V(ciphers, "ciphers")                                                        \
+  V(crl, "crl")                                                                \
+  V(cubic, "cubic")                                                            \
+  V(datagram_drop_policy, "datagramDropPolicy")                                \
+  V(deny, "deny")                                                              \
+  V(disable_stateless_reset, "disableStatelessReset")                          \
+  V(draining_period_multiplier, "drainingPeriodMultiplier")                    \
+  V(enable_connect_protocol, "enableConnectProtocol")                          \
+  V(enable_early_data, "enableEarlyData")                                      \
+  V(enable_datagrams, "enableDatagrams")                                       \
+  V(enable_tls_trace, "tlsTrace")                                              \
+  V(endpoint, "Endpoint")                                                      \
+  V(endpoint_udp, "Endpoint::UDP")                                             \
+  V(failure, "failure")                                                        \
+  V(groups, "groups")                                                          \
+  V(handshake_timeout, "handshakeTimeout")                                     \
+  V(http3_alpn, &NGHTTP3_ALPN_H3[1])                                           \
+  V(initial_rtt, "initialRtt")                                                 \
+  V(keep_alive_timeout, "keepAlive")                                           \
+  V(initial_max_data, "initialMaxData")                                        \
+  V(initial_max_stream_data_bidi_local, "initialMaxStreamDataBidiLocal")       \
+  V(initial_max_stream_data_bidi_remote, "initialMaxStreamDataBidiRemote")     \
+  V(initial_max_stream_data_uni, "initialMaxStreamDataUni")                    \
+  V(initial_max_streams_bidi, "initialMaxStreamsBidi")                         \
+  V(initial_max_streams_uni, "initialMaxStreamsUni")                           \
+  V(ipv6_only, "ipv6Only")                                                     \
+  V(reuse_port, "reusePort")                                                   \
+  V(keylog, "keylog")                                                          \
+  V(keys, "keys")                                                              \
+  V(lost, "lost")                                                              \
+  V(max_ack_delay, "maxAckDelay")                                              \
+  V(max_connections_per_host, "maxConnectionsPerHost")                         \
+  V(max_connections_total, "maxConnectionsTotal")                              \
+  V(max_datagram_frame_size, "maxDatagramFrameSize")                           \
+  V(max_datagram_send_attempts, "maxDatagramSendAttempts")                     \
+  V(stream_idle_timeout, "streamIdleTimeout")                                  \
+  V(max_field_section_size, "maxFieldSectionSize")                             \
+  V(max_header_length, "maxHeaderLength")                                      \
+  V(max_header_pairs, "maxHeaderPairs")                                        \
+  V(idle_timeout, "idleTimeout")                                               \
+  V(max_idle_timeout, "maxIdleTimeout")                                        \
+  V(max_payload_size, "maxPayloadSize")                                        \
+  V(retry_rate, "retryRate")                                                   \
+  V(retry_burst, "retryBurst")                                                 \
+  V(stateless_reset_rate, "statelessResetRate")                                \
+  V(stateless_reset_burst, "statelessResetBurst")                              \
+  V(version_negotiation_rate, "versionNegotiationRate")                        \
+  V(version_negotiation_burst, "versionNegotiationBurst")                      \
+  V(immediate_close_rate, "immediateCloseRate")                                \
+  V(immediate_close_burst, "immediateCloseBurst")                              \
+  V(session_creation_rate, "sessionCreationRate")                              \
+  V(session_creation_burst, "sessionCreationBurst")                            \
+  V(block_list, "blockList")                                                   \
+  V(block_list_policy, "blockListPolicy")                                      \
+  V(max_stream_window, "maxStreamWindow")                                      \
+  V(max_window, "maxWindow")                                                   \
+  V(min_version, "minVersion")                                                 \
+  V(port, "port")                                                              \
+  V(preferred_address_ipv4, "preferredAddressIpv4")                            \
+  V(preferred_address_ipv6, "preferredAddressIpv6")                            \
+  V(preferred_address_strategy, "preferredAddressPolicy")                      \
+  V(alpn, "alpn")                                                              \
+  V(qlog, "qlog")                                                              \
+  V(qpack_blocked_streams, "qpackBlockedStreams")                              \
+  V(qpack_encoder_max_dtable_capacity, "qpackEncoderMaxDTableCapacity")        \
+  V(qpack_max_dtable_capacity, "qpackMaxDTableCapacity")                       \
+  V(reason, "reason")                                                          \
+  V(reject_unauthorized, "rejectUnauthorized")                                 \
+  V(reno, "reno")                                                              \
+  V(reset_token_secret, "resetTokenSecret")                                    \
+  V(retry_token_expiration, "retryTokenExpiration")                            \
+  V(rx_loss, "rxDiagnosticLoss")                                               \
+  V(servername, "servername")                                                  \
+  V(session, "Session")                                                        \
+  V(sni, "sni")                                                                \
+  V(stream, "Stream")                                                          \
+  V(success, "success")                                                        \
+  V(tls_options, "tls")                                                        \
+  V(token, "token")                                                            \
+  V(token_expiration, "tokenExpiration")                                       \
+  V(token_secret, "tokenSecret")                                               \
+  V(transport, "transport")                                                    \
+  V(transport_params, "transportParams")                                       \
+  V(type, "type")                                                              \
+  V(tx_loss, "txDiagnosticLoss")                                               \
+  V(udp_receive_buffer_size, "udpReceiveBufferSize")                           \
+  V(udp_send_buffer_size, "udpSendBufferSize")                                 \
+  V(udp_ttl, "udpTTL")                                                         \
+  V(unacknowledged_packet_threshold, "unacknowledgedPacketThreshold")          \
+  V(validate_address, "validateAddress")                                       \
+  V(verify_client, "verifyClient")                                             \
+  V(verify_hostname, "verifyHostname")                                         \
+  V(verify_peer_strict, "verifyPeerStrict")                                    \
+  V(verify_private_key, "verifyPrivateKey")                                    \
+  V(version, "version")
+
+// =============================================================================
+// Lightweight wrappers around uv_check_t that ensure safe handle closure.
+// The check handle is embedded in a heap-allocated CheckWrap whose destruction
+// is deferred until the uv_close callback fires, preventing use-after-free
+// when the owning object is destroyed before libuv finishes closing the handle.
+// Follows the same two-layer pattern as TimerWrap / TimerWrapHandle
+// (see timer_wrap.h).
+// TODO(@jasnell): Consider moving it out to a separate file like timer_wrap.h.
+class CheckWrap final : public MemoryRetainer {
+ public:
+  using CheckCb = std::function<void()>;
+
+  template <typename... Args>
+  explicit CheckWrap(Environment* env, Args&&... args)
+      : env_(env), fn_(std::forward<Args>(args)...) {
+    uv_check_init(env->event_loop(), &check_);
+    check_.data = this;
+  }
+
+  DISALLOW_COPY_AND_MOVE(CheckWrap)
+
+  inline Environment* env() const { return env_; }
+
+  void Start();
+  void Stop();
+  void Close();
+  void Ref();
+  void Unref();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(CheckWrap)
+  SET_SELF_SIZE(CheckWrap)
+
+ private:
+  static void OnCheck(uv_check_t* check);
+  static void CheckClosedCb(uv_handle_t* handle);
+  ~CheckWrap() = default;
+
+  Environment* env_;
+  CheckCb fn_;
+  uv_check_t check_;
+
+  friend std::unique_ptr<CheckWrap>::deleter_type;
+};
+
+class CheckWrapHandle : public MemoryRetainer {
+ public:
+  template <typename... Args>
+  explicit CheckWrapHandle(Environment* env, Args&&... args)
+      : check_(new CheckWrap(env, std::forward<Args>(args)...)) {
+    env->AddCleanupHook(CleanupHook, this);
+  }
+
+  DISALLOW_COPY_AND_MOVE(CheckWrapHandle)
+
+  ~CheckWrapHandle() { Close(); }
+
+  inline operator bool() const { return check_ != nullptr; }
+
+  void Start();
+  void Stop();
+  void Close();
+  void Ref();
+  void Unref();
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+
+  SET_MEMORY_INFO_NAME(CheckWrapHandle)
+  SET_SELF_SIZE(CheckWrapHandle)
+
+ private:
+  static void CleanupHook(void* data);
+  CheckWrap* check_;
+};
+
+// =============================================================================
+// The BindingState object holds state for the internalBinding('quic') binding
+// instance. It is mostly used to hold the persistent constructors, strings, and
+// callback references used for the rest of the implementation.
+//
+// TODO(@jasnell): Make this snapshotable?
+class BindingData final
+    : public BaseObject,
+      public mem::NgLibMemoryManager<BindingData, ngtcp2_mem> {
+ public:
+  SET_BINDING_ID(quic_binding_data)
+  static void InitPerContext(Realm* realm, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static BindingData& Get(Environment* env);
+  static inline BindingData& Get(Realm* realm) { return Get(realm->env()); }
+
+  BindingData(Realm* realm, v8::Local<v8::Object> object);
+  ~BindingData() override;
+  DISALLOW_COPY_AND_MOVE(BindingData)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(BindingData)
+  SET_SELF_SIZE(BindingData)
+
+  // NgLibMemoryManager — the base class provides CheckAllocatedSize,
+  // IncreaseAllocatedSize, DecreaseAllocatedSize, and StopTrackingMemory.
+  // Actual allocations go through the thread-local allocators below.
+  void CheckAllocatedSize(size_t previous_size) const;
+  void IncreaseAllocatedSize(size_t size);
+  void DecreaseAllocatedSize(size_t size);
+
+  // Thread-local allocators that outlive BindingData destruction.
+  // Both ngtcp2 and nghttp3 store the allocator pointer inside every
+  // object they allocate; some of those objects (e.g., nghttp3 rcbufs
+  // backing V8 external strings) can be freed after BindingData is gone.
+  ngtcp2_mem* ngtcp2_allocator();
+  nghttp3_mem* nghttp3_allocator();
+
+  // Installs the set of JavaScript callback functions that are used to
+  // bridge out to the JS API.
+  JS_METHOD(SetCallbacks);
+
+  // Lazily-created per-Realm SessionManager. Centralizes CID -> Session
+  // routing so that any endpoint can route packets to any session.
+  SessionManager& session_manager();
+
+  // Schedule a session for deferred SendPendingData. Sessions are accumulated
+  // during the I/O poll phase (via Endpoint::Receive -> Session::ReadPacket)
+  // and flushed in a uv_check callback immediately after poll completes.
+  // This batches multiple received packets before generating responses,
+  // allowing ngtcp2 to make better ACK coalescing decisions.
+  void ScheduleSessionFlush(const BaseObjectPtr<Session>& session);
+
+  std::unordered_map<Endpoint*, BaseObjectPtr<BaseObject>> listening_endpoints;
+
+  v8::Local<v8::String> error_name_string(const char* name);
+
+  size_t current_ngtcp2_memory_ = 0;
+
+  // The following set up various storage and accessors for common strings,
+  // construction templates, and callbacks stored on the BindingData. These
+  // are all defined in defs.h
+
+#define V(name)                                                                \
+  void set_##name##_constructor_template(                                      \
+      v8::Local<v8::FunctionTemplate> tmpl);                                   \
+  v8::Local<v8::FunctionTemplate> name##_constructor_template() const;
+  QUIC_CONSTRUCTORS(V)
+#undef V
+
+  void set_transport_params_template(v8::Local<v8::DictionaryTemplate> tmpl);
+  v8::Local<v8::DictionaryTemplate> transport_params_template() const;
+
+  void set_application_options_template(v8::Local<v8::DictionaryTemplate> tmpl);
+  v8::Local<v8::DictionaryTemplate> application_options_template() const;
+
+#define V(name, _)                                                             \
+  void set_##name##_callback(v8::Local<v8::Function> fn);                      \
+  v8::Local<v8::Function> name##_callback() const;
+  QUIC_JS_CALLBACKS(V)
+#undef V
+
+#define V(name, _) v8::Local<v8::String> name##_string() const;
+  QUIC_STRINGS(V)
+#undef V
+
+#define V(name, _) v8::Local<v8::String> on_##name##_string() const;
+  QUIC_JS_CALLBACKS(V)
+#undef V
+
+#define V(name) v8::Global<v8::FunctionTemplate> name##_constructor_template_;
+  QUIC_CONSTRUCTORS(V)
+#undef V
+
+  v8::Global<v8::DictionaryTemplate> transport_params_template_;
+  v8::Global<v8::DictionaryTemplate> application_options_template_;
+
+#define V(name, _) v8::Global<v8::Function> name##_callback_;
+  QUIC_JS_CALLBACKS(V)
+#undef V
+
+#define V(name, _) mutable v8::Eternal<v8::String> name##_string_;
+  QUIC_STRINGS(V)
+#undef V
+
+#define V(name, _) mutable v8::Eternal<v8::String> on_##name##_string_;
+  QUIC_JS_CALLBACKS(V)
+#undef V
+
+  // Lazy cache backing error_name_string()
+  std::unordered_map<const char*, v8::Eternal<v8::String>> error_name_strings_;
+
+  std::unique_ptr<SessionManager> session_manager_;
+
+  // Type-erased arena storage. The concrete AliasedStructArena<T> types
+  // are only complete in the .cc files where Stream::State etc. are defined.
+  // Each .cc file provides typed accessor methods. The deleters are set
+  // when the arenas are created so that ~BindingData destroys them correctly.
+  using ArenaDeleter = void (*)(void*);
+  using ArenaPtr = std::unique_ptr<void, ArenaDeleter>;
+  ArenaPtr stream_state_arena_{nullptr, +[](void*) {}};
+  ArenaPtr stream_stats_arena_{nullptr, +[](void*) {}};
+  ArenaPtr session_state_arena_{nullptr, +[](void*) {}};
+  ArenaPtr session_stats_arena_{nullptr, +[](void*) {}};
+  ArenaPtr endpoint_state_arena_{nullptr, +[](void*) {}};
+  ArenaPtr endpoint_stats_arena_{nullptr, +[](void*) {}};
+
+  // Deferred send flush state. The CheckWrapHandle fires immediately after
+  // the I/O poll phase in the same event loop tick, allowing batched
+  // receive processing: all packets are read during poll, then
+  // SendPendingData is called once per dirty session in the check callback.
+  CheckWrapHandle flush_check_;
+  std::vector<BaseObjectPtr<Session>> pending_flush_sessions_;
+  bool flush_check_started_ = false;
+
+  void OnFlushCheck();
+};
+
+JS_METHOD_IMPL(IllegalConstructor);
+
+// The ngtcp2 and nghttp3 callbacks have certain restrictions
+// that forbid re-entry. We provide the following scopes for
+// use in those to help protect against it.
+// These callback scopes are per-session, not per-environment. This ensures
+// that one session's ngtcp2/nghttp3 callback does not block an unrelated
+// session from sending packets. A BaseObjectPtr prevents the Session from
+// being prematurely freed while the scope is alive on the stack.
+struct NgTcp2CallbackScope final {
+  BaseObjectPtr<Session> session;
+  explicit NgTcp2CallbackScope(Session* session);
+  DISALLOW_COPY_AND_MOVE(NgTcp2CallbackScope)
+  ~NgTcp2CallbackScope();
+};
+
+struct NgHttp3CallbackScope final {
+  BaseObjectPtr<Session> session;
+  explicit NgHttp3CallbackScope(Session* session);
+  DISALLOW_COPY_AND_MOVE(NgHttp3CallbackScope)
+  ~NgHttp3CallbackScope();
+};
+
+struct CallbackScopeBase {
+  Environment* env;
+  v8::Context::Scope context_scope;
+  v8::TryCatch try_catch;
+
+  explicit CallbackScopeBase(Environment* env);
+  DISALLOW_COPY_AND_MOVE(CallbackScopeBase)
+  ~CallbackScopeBase();
+};
+
+// Maintains a strong reference to BaseObject type ptr to keep it alive during
+// a MakeCallback during which it might be destroyed.
+template <typename T>
+struct CallbackScope final : public CallbackScopeBase {
+  BaseObjectPtr<T> ref;
+  explicit CallbackScope(const T* ptr)
+      : CallbackScopeBase(ptr->env()), ref(ptr) {}
+  DISALLOW_COPY_AND_MOVE(CallbackScope)
+  explicit CallbackScope(T* ptr) : CallbackScopeBase(ptr->env()), ref(ptr) {}
+};
+
+}  // namespace node::quic
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/26/quic/cid.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <memory_tracker.h>
+#include <ngtcp2/ngtcp2.h>
+#include <string>
+#include "defs.h"
+
+namespace node::quic {
+
+// CIDS are used to identify endpoints participating in a QUIC session.
+// Once created, CID instances are immutable.
+//
+// CIDs contain between 1 to 20 bytes. Most typically they are selected
+// randomly but there is a spec for creating "routable" CIDs that encode
+// a specific structure that is meaningful only to the side that creates
+// the CID. For most purposes, CIDs should be treated as opaque tokens.
+//
+// Each peer in a QUIC session generates one or more CIDs that the *other*
+// peer will use to identify the session. When a QUIC client initiates a
+// brand new session, it will initially generate a CID of its own (its
+// source CID) and a random placeholder CID for the server (the original
+// destination CID). When the server receives the initial packet, it will
+// generate its own source CID and use the client's source CID as the
+// server's destination CID.
+//
+//       Client                 Server
+// -------------------------------------------
+//     Source CID   <====> Destination CID
+//  Destination CID <====>   Source CID
+//
+// While the connection is being established, or even while the connection
+// is active, it is possible for either peer to generate additional CIDs that
+// are also associated with the connection.
+class CID final : public MemoryRetainer {
+ public:
+  static constexpr size_t kMinLength = NGTCP2_MIN_CIDLEN;
+  static constexpr size_t kMaxLength = NGTCP2_MAX_CIDLEN;
+
+  // Copy the given ngtcp2_cid.
+  explicit CID(const ngtcp2_cid& cid);
+
+  // Copy the given buffer as a CID. The len must be within
+  // kMinLength and kMaxLength.
+  explicit CID(const uint8_t* data, size_t len);
+
+  // Wrap the given ngtcp2_cid. The CID does not take ownership
+  // of the underlying ngtcp2_cid.
+  explicit CID(const ngtcp2_cid* cid);
+
+  CID(const CID& other);
+  CID& operator=(const CID& other);
+
+  struct Hash final {
+    size_t operator()(const CID& cid) const;
+  };
+
+  bool operator==(const CID& other) const noexcept;
+  bool operator!=(const CID& other) const noexcept;
+
+  operator const uint8_t*() const;
+  operator const ngtcp2_cid&() const;
+  operator const ngtcp2_cid*() const;
+
+  // True if the CID length is at least kMinLength;
+  operator bool() const;
+  size_t length() const;
+
+  // Returns a hex-encoded string representation of the CID useful
+  // for debugging.
+  std::string ToString() const;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(CID)
+  SET_SELF_SIZE(CID)
+
+  template <typename T>
+  using Map = std::unordered_map<const CID, T, CID::Hash>;
+
+  // A CID::Factory, as the name suggests, is used to create new CIDs.
+  // Per https://datatracker.ietf.org/doc/draft-ietf-quic-load-balancers/, QUIC
+  // implementations MAY use the Connection ID associated with a QUIC session
+  // as a routing mechanism, with each CID instance securely encoding the
+  // routing information. By default, our implementation creates CIDs randomly
+  // but will allow user code to provide their own CID::Factory implementation.
+  class Factory;
+
+  static const CID kInvalid;
+
+  // The default constructor creates an empty, zero-length CID.
+  // Zero-length CIDs are not usable. We use them as a placeholder
+  // for a missing or empty CID value. This is public only because
+  // it is required for the CID::Map implementation. It should not
+  // be used directly. Use kInvalid instead.
+  CID();
+
+ private:
+  ngtcp2_cid cid_;
+  const ngtcp2_cid* ptr_;
+
+  friend struct Hash;
+};
+
+class CID::Factory {
+ public:
+  virtual ~Factory() = default;
+
+  // Generate a new CID. The length_hint must be between CID::kMinLength
+  // and CID::kMaxLength. The implementation can choose to ignore the length.
+  virtual const CID Generate(size_t length_hint = CID::kMaxLength) const = 0;
+
+  // Generate a new CID into the given ngtcp2_cid. This variation of
+  // Generate should be used far less commonly.
+  virtual const CID GenerateInto(
+      ngtcp2_cid* cid, size_t length_hint = CID::kMaxLength) const = 0;
+
+  // The default random CID generator instance.
+  static const Factory& random();
+
+  // TODO(@jasnell): This will soon also include additional implementations
+  // of CID::Factory that implement the QUIC Load Balancers spec.
+};
+
+}  // namespace node::quic
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS