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

package/dist/node/include/permission/permission_base.h

@@ -0,0 +1,65 @@
+#ifndef SRC_PERMISSION_PERMISSION_BASE_H_
+#define SRC_PERMISSION_PERMISSION_BASE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <map>
+#include <string>
+#include <string_view>
+#include "v8.h"
+
+namespace node {
+
+class Environment;
+
+namespace permission {
+
+#define FILESYSTEM_PERMISSIONS(V)                                              \
+  V(FileSystem, "fs", PermissionsRoot, "")                                     \
+  V(FileSystemRead, "fs.read", FileSystem, "--allow-fs-read")                  \
+  V(FileSystemWrite, "fs.write", FileSystem, "--allow-fs-write")
+
+#define CHILD_PROCESS_PERMISSIONS(V)                                           \
+  V(ChildProcess, "child", PermissionsRoot, "--allow-child-process")
+
+#define WASI_PERMISSIONS(V) V(WASI, "wasi", PermissionsRoot, "--allow-wasi")
+
+#define WORKER_THREADS_PERMISSIONS(V)                                          \
+  V(WorkerThreads, "worker", PermissionsRoot, "--allow-worker")
+
+#define INSPECTOR_PERMISSIONS(V) V(Inspector, "inspector", PermissionsRoot, "")
+
+#define ADDON_PERMISSIONS(V)                                                   \
+  V(Addon, "addon", PermissionsRoot, "--allow-addons")
+
+#define PERMISSIONS(V)                                                         \
+  FILESYSTEM_PERMISSIONS(V)                                                    \
+  CHILD_PROCESS_PERMISSIONS(V)                                                 \
+  WASI_PERMISSIONS(V)                                                          \
+  WORKER_THREADS_PERMISSIONS(V)                                                \
+  INSPECTOR_PERMISSIONS(V)                                                     \
+  ADDON_PERMISSIONS(V)
+
+#define V(name, _, __, ___) k##name,
+enum class PermissionScope {
+  kPermissionsRoot = -1,
+  PERMISSIONS(V) kPermissionsCount
+};
+#undef V
+
+class PermissionBase {
+ public:
+  virtual void Apply(Environment* env,
+                     const std::vector<std::string>& allow,
+                     PermissionScope scope) = 0;
+  virtual bool is_granted(Environment* env,
+                          PermissionScope perm,
+                          const std::string_view& param = "") const = 0;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_PERMISSION_BASE_H_

package/dist/node/include/permission/wasi_permission.h

@@ -0,0 +1,31 @@
+#ifndef SRC_PERMISSION_WASI_PERMISSION_H_
+#define SRC_PERMISSION_WASI_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <vector>
+#include "permission/permission_base.h"
+
+namespace node {
+
+namespace permission {
+
+class WASIPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             const std::vector<std::string>& allow,
+             PermissionScope scope) override;
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  const std::string_view& param = "") const override;
+
+ private:
+  bool deny_all_;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_WASI_PERMISSION_H_

package/dist/node/include/permission/worker_permission.h

@@ -0,0 +1,31 @@
+#ifndef SRC_PERMISSION_WORKER_PERMISSION_H_
+#define SRC_PERMISSION_WORKER_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <vector>
+#include "permission/permission_base.h"
+
+namespace node {
+
+namespace permission {
+
+class WorkerPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             const std::vector<std::string>& allow,
+             PermissionScope scope) override;
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  const std::string_view& param = "") const override;
+
+ private:
+  bool deny_all_;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_WORKER_PERMISSION_H_

package/dist/node/include/pipe_wrap.h

@@ -0,0 +1,80 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_PIPE_WRAP_H_
+#define SRC_PIPE_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "connection_wrap.h"
+
+namespace node {
+
+class ExternalReferenceRegistry;
+class Environment;
+
+class PipeWrap : public ConnectionWrap<PipeWrap, uv_pipe_t> {
+ public:
+  enum SocketType {
+    SOCKET,
+    SERVER,
+    IPC
+  };
+
+  static v8::MaybeLocal<v8::Object> Instantiate(Environment* env,
+                                                AsyncWrap* parent,
+                                                SocketType type);
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context,
+                         void* priv);
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(PipeWrap)
+  SET_SELF_SIZE(PipeWrap)
+
+ private:
+  PipeWrap(Environment* env,
+           v8::Local<v8::Object> object,
+           ProviderType provider,
+           bool ipc);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Bind(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Listen(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Connect(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Open(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+#ifdef _WIN32
+  static void SetPendingInstances(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+#endif
+  static void Fchmod(const v8::FunctionCallbackInfo<v8::Value>& args);
+};
+
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_PIPE_WRAP_H_

package/dist/node/include/quic/application.h

@@ -0,0 +1,159 @@
+#pragma once
+
+#include "quic/defs.h"
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include "bindingdata.h"
+#include "defs.h"
+#include "session.h"
+#include "sessionticket.h"
+#include "streams.h"
+
+namespace node::quic {
+
+// An Application implements the ALPN-protocol specific semantics on behalf
+// of a QUIC Session.
+class Session::Application : public MemoryRetainer {
+ public:
+  using Options = Session::Application_Options;
+
+  Application(Session* session, const Options& options);
+  DISALLOW_COPY_AND_MOVE(Application)
+
+  virtual bool Start();
+
+  // Session will forward all received stream data immediately on to the
+  // Application. The only additional processing the Session does is to
+  // automatically adjust the session-level flow control window. It is up to
+  // the Application to do the same for the Stream-level flow control.
+  virtual bool ReceiveStreamData(Stream* stream,
+                                 const uint8_t* data,
+                                 size_t datalen,
+                                 Stream::ReceiveDataFlags flags) = 0;
+
+  // Session will forward all data acknowledgements for a stream to the
+  // Application.
+  virtual void AcknowledgeStreamData(Stream* stream, size_t datalen);
+
+  // Called to determine if a Header can be added to this application.
+  // Applications that do not support headers will always return false.
+  virtual bool CanAddHeader(size_t current_count,
+                            size_t current_headers_length,
+                            size_t this_header_length);
+
+  // Called to mark the identified stream as being blocked. Not all
+  // Application types will support blocked streams, and those that do will do
+  // so differently.
+  virtual void BlockStream(int64_t id);
+
+  // Called when the session determines that there is outbound data available
+  // to send for the given stream.
+  virtual void ResumeStream(int64_t id);
+
+  // Called when the Session determines that the maximum number of
+  // remotely-initiated unidirectional streams has been extended. Not all
+  // Application types will require this notification so the default is to do
+  // nothing.
+  virtual void ExtendMaxStreams(EndpointLabel label,
+                                Direction direction,
+                                uint64_t max_streams);
+
+  // Called when the Session determines that the flow control window for the
+  // given stream has been expanded. Not all Application types will require
+  // this notification so the default is to do nothing.
+  virtual void ExtendMaxStreamData(Stream* stream, uint64_t max_data);
+
+  // Different Applications may wish to set some application data in the
+  // session ticket (e.g. http/3 would set server settings in the application
+  // data). By default, there's nothing to set.
+  virtual void CollectSessionTicketAppData(
+      SessionTicket::AppData* app_data) const;
+
+  // Different Applications may set some application data in the session
+  // ticket (e.g. http/3 would set server settings in the application data).
+  // By default, there's nothing to get.
+  virtual SessionTicket::AppData::Status ExtractSessionTicketAppData(
+      const SessionTicket::AppData& app_data,
+      SessionTicket::AppData::Source::Flag flag);
+
+  // Notifies the Application that the identified stream has been closed.
+  virtual void StreamClose(Stream* stream, QuicError error = QuicError());
+
+  // Notifies the Application that the identified stream has been reset.
+  virtual void StreamReset(Stream* stream,
+                           uint64_t final_size,
+                           QuicError error);
+
+  // Notifies the Application that the identified stream should stop sending.
+  virtual void StreamStopSending(Stream* stream, QuicError error);
+
+  // Submits an outbound block of headers for the given stream. Not all
+  // Application types will support headers, in which case this function
+  // should return false.
+  virtual bool SendHeaders(const Stream& stream,
+                           HeadersKind kind,
+                           const v8::Local<v8::Array>& headers,
+                           HeadersFlags flags = HeadersFlags::NONE);
+
+  // Signals to the Application that it should serialize and transmit any
+  // pending session and stream packets it has accumulated.
+  void SendPendingData();
+
+  // Set the priority level of the stream if supported by the application. Not
+  // all applications support priorities, in which case this function is a
+  // non-op.
+  virtual void SetStreamPriority(
+      const Stream& stream,
+      StreamPriority priority = StreamPriority::DEFAULT,
+      StreamPriorityFlags flags = StreamPriorityFlags::NONE);
+
+  // Get the priority level of the stream if supported by the application. Not
+  // all applications support priorities, in which case this function returns
+  // the default stream priority.
+  virtual StreamPriority GetStreamPriority(const Stream& stream);
+
+  struct StreamData;
+
+  virtual int GetStreamData(StreamData* data) = 0;
+  virtual bool StreamCommit(StreamData* data, size_t datalen) = 0;
+  virtual bool ShouldSetFin(const StreamData& data) = 0;
+
+  inline Environment* env() const { return session_->env(); }
+  inline Session& session() { return *session_; }
+  inline const Session& session() const { return *session_; }
+
+ private:
+  Packet* CreateStreamDataPacket();
+
+  // Write the given stream_data into the buffer.
+  ssize_t WriteVStream(PathStorage* path,
+                       uint8_t* buf,
+                       ssize_t* ndatalen,
+                       size_t max_packet_size,
+                       const StreamData& stream_data);
+
+  Session* session_;
+};
+
+struct Session::Application::StreamData final {
+  // The actual number of vectors in the struct, up to kMaxVectorCount.
+  size_t count = 0;
+  size_t remaining = 0;
+  // The stream identifier. If this is a negative value then no stream is
+  // identified.
+  int64_t id = -1;
+  int fin = 0;
+  ngtcp2_vec data[kMaxVectorCount]{};
+  ngtcp2_vec* buf = data;
+  BaseObjectPtr<Stream> stream;
+
+  inline operator nghttp3_vec() const { return {data[0].base, data[0].len}; }
+
+  std::string ToString() const;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/dist/node/include/quic/bindingdata.h

@@ -0,0 +1,272 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#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 <v8.h>
+#include <unordered_map>
+#include <vector>
+#include "defs.h"
+
+namespace node::quic {
+
+class Endpoint;
+class Packet;
+
+// ============================================================================
+
+// The FunctionTemplates the BindingData will store for us.
+#define QUIC_CONSTRUCTORS(V)                                                   \
+  V(endpoint)                                                                  \
+  V(logstream)                                                                 \
+  V(packet)                                                                    \
+  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_new, SessionNew)                                                   \
+  V(session_close, SessionClose)                                               \
+  V(session_datagram, SessionDatagram)                                         \
+  V(session_datagram_status, SessionDatagramStatus)                            \
+  V(session_handshake, SessionHandshake)                                       \
+  V(session_ticket, SessionTicket)                                             \
+  V(session_version_negotiation, SessionVersionNegotiation)                    \
+  V(session_path_validation, SessionPathValidation)                            \
+  V(stream_close, StreamClose)                                                 \
+  V(stream_created, StreamCreated)                                             \
+  V(stream_reset, StreamReset)                                                 \
+  V(stream_headers, StreamHeaders)                                             \
+  V(stream_blocked, StreamBlocked)                                             \
+  V(stream_trailers, StreamTrailers)
+
+// The various JS strings the implementation uses.
+#define QUIC_STRINGS(V)                                                        \
+  V(aborted, "aborted")                                                        \
+  V(acknowledged, "acknowledged")                                              \
+  V(ack_delay_exponent, "ackDelayExponent")                                    \
+  V(active_connection_id_limit, "activeConnectionIDLimit")                     \
+  V(address_lru_size, "addressLRUSize")                                        \
+  V(alpn, "alpn")                                                              \
+  V(application_options, "application")                                        \
+  V(bbr, "bbr")                                                                \
+  V(ca, "ca")                                                                  \
+  V(certs, "certs")                                                            \
+  V(cc_algorithm, "cc")                                                        \
+  V(crl, "crl")                                                                \
+  V(ciphers, "ciphers")                                                        \
+  V(cubic, "cubic")                                                            \
+  V(disable_active_migration, "disableActiveMigration")                        \
+  V(disable_stateless_reset, "disableStatelessReset")                          \
+  V(enable_connect_protocol, "enableConnectProtocol")                          \
+  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_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(keylog, "keylog")                                                          \
+  V(keys, "keys")                                                              \
+  V(logstream, "LogStream")                                                    \
+  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_field_section_size, "maxFieldSectionSize")                             \
+  V(max_header_length, "maxHeaderLength")                                      \
+  V(max_header_pairs, "maxHeaderPairs")                                        \
+  V(max_idle_timeout, "maxIdleTimeout")                                        \
+  V(max_payload_size, "maxPayloadSize")                                        \
+  V(max_retries, "maxRetries")                                                 \
+  V(max_stateless_resets, "maxStatelessResetsPerHost")                         \
+  V(max_stream_window, "maxStreamWindow")                                      \
+  V(max_window, "maxWindow")                                                   \
+  V(min_version, "minVersion")                                                 \
+  V(no_udp_payload_size_shaping, "noUdpPayloadSizeShaping")                    \
+  V(packetwrap, "PacketWrap")                                                  \
+  V(preferred_address_strategy, "preferredAddressPolicy")                      \
+  V(qlog, "qlog")                                                              \
+  V(qpack_blocked_streams, "qpackBlockedStreams")                              \
+  V(qpack_encoder_max_dtable_capacity, "qpackEncoderMaxDTableCapacity")        \
+  V(qpack_max_dtable_capacity, "qpackMaxDTableCapacity")                       \
+  V(reject_unauthorized, "rejectUnauthorized")                                 \
+  V(reno, "reno")                                                              \
+  V(retry_token_expiration, "retryTokenExpiration")                            \
+  V(reset_token_secret, "resetTokenSecret")                                    \
+  V(rx_loss, "rxDiagnosticLoss")                                               \
+  V(session, "Session")                                                        \
+  V(sni, "sni")                                                                \
+  V(stream, "Stream")                                                          \
+  V(success, "success")                                                        \
+  V(tls_options, "tls")                                                        \
+  V(token_expiration, "tokenExpiration")                                       \
+  V(token_secret, "tokenSecret")                                               \
+  V(transport_params, "transportParams")                                       \
+  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_private_key, "verifyPrivateKey")                                    \
+  V(version, "version")
+
+// =============================================================================
+// 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);
+
+  BindingData(Realm* realm, v8::Local<v8::Object> object);
+  DISALLOW_COPY_AND_MOVE(BindingData)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(BindingData)
+  SET_SELF_SIZE(BindingData)
+
+  // NgLibMemoryManager
+  operator ngtcp2_mem();
+  operator nghttp3_mem();
+  void CheckAllocatedSize(size_t previous_size) const;
+  void IncreaseAllocatedSize(size_t size);
+  void DecreaseAllocatedSize(size_t size);
+
+  // Installs the set of JavaScript callback functions that are used to
+  // bridge out to the JS API.
+  static void SetCallbacks(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  std::vector<Packet*> packet_freelist;
+
+  std::unordered_map<Endpoint*, BaseObjectPtr<BaseObject>> listening_endpoints;
+
+  // Purge the packet free list to free up memory.
+  static void FlushPacketFreelist(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  bool in_ngtcp2_callback_scope = false;
+  bool in_nghttp3_callback_scope = false;
+
+  // 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
+
+#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
+
+  size_t current_ngtcp2_memory_ = 0;
+
+#define V(name) v8::Global<v8::FunctionTemplate> name##_constructor_template_;
+  QUIC_CONSTRUCTORS(V)
+#undef V
+
+#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
+};
+
+void IllegalConstructor(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+// 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.
+struct NgTcp2CallbackScope {
+  Environment* env;
+  explicit NgTcp2CallbackScope(Environment* env);
+  DISALLOW_COPY_AND_MOVE(NgTcp2CallbackScope)
+  ~NgTcp2CallbackScope();
+  static bool in_ngtcp2_callback(Environment* env);
+};
+
+struct NgHttp3CallbackScope {
+  Environment* env;
+  explicit NgHttp3CallbackScope(Environment* env);
+  DISALLOW_COPY_AND_MOVE(NgHttp3CallbackScope)
+  ~NgHttp3CallbackScope();
+  static bool in_nghttp3_callback(Environment* env);
+};
+
+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  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS