@encharm/cws 4.5.2 → 4.6.0

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

@@ -0,0 +1,184 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <env.h>
+#include <memory_tracker.h>
+#include <ngtcp2/ngtcp2.h>
+#include <node_sockaddr.h>
+#include <optional>
+#include "bindingdata.h"
+#include "cid.h"
+#include "data.h"
+#include "tokens.h"
+
+namespace node::quic {
+
+class Endpoint;
+class Session;
+
+// The Transport Params are the set of configuration options that are sent to
+// the remote peer. They communicate the protocol options the other peer
+// should use when communicating with this session.
+class TransportParams final {
+ public:
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+
+  enum class Version : int {
+    V1 = NGTCP2_TRANSPORT_PARAMS_V1,
+  };
+
+  static constexpr uint64_t DEFAULT_MAX_STREAM_DATA = 256 * 1024;
+  static constexpr uint64_t DEFAULT_MAX_DATA = 1 * 1024 * 1024;
+  static constexpr uint64_t DEFAULT_MAX_IDLE_TIMEOUT = 10;  // seconds
+  static constexpr uint64_t DEFAULT_MAX_STREAMS_BIDI = 100;
+  static constexpr uint64_t DEFAULT_MAX_STREAMS_UNI = 3;
+  static constexpr uint64_t DEFAULT_ACTIVE_CONNECTION_ID_LIMIT = 2;
+
+  struct Config final {
+    Side side;
+    const CID& ocid;
+    const CID& retry_scid;
+    Config(Side side,
+           const CID& ocid = CID::kInvalid,
+           const CID& retry_scid = CID::kInvalid);
+  };
+
+  struct Options final : public MemoryRetainer {
+    Version transportParamsVersion = Version::V1;
+
+    // Set only on server Sessions, the preferred address communicates the IP
+    // address and port that the server would prefer the client to use when
+    // communicating with it. See the QUIC specification for more detail on how
+    // the preferred address mechanism works:
+    // https://www.rfc-editor.org/rfc/rfc9000.html#name-servers-preferred-address
+    std::optional<SocketAddress> preferred_address_ipv4{};
+    std::optional<SocketAddress> preferred_address_ipv6{};
+
+    // The initial size of the flow control window of locally initiated streams.
+    // This is the maximum number of bytes that the *remote* endpoint can send
+    // when the connection is started.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.16.1
+    uint64_t initial_max_stream_data_bidi_local = DEFAULT_MAX_STREAM_DATA;
+
+    // The initial size of the flow control window of remotely initiated
+    // streams. This is the maximum number of bytes that the remote endpoint can
+    // send when the connection is started.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.18.1
+    uint64_t initial_max_stream_data_bidi_remote = DEFAULT_MAX_STREAM_DATA;
+
+    // The initial size of the flow control window of remotely initiated
+    // unidirectional streams. This is the maximum number of bytes that the
+    // remote endpoint can send when the connection is started.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.20.1
+    uint64_t initial_max_stream_data_uni = DEFAULT_MAX_STREAM_DATA;
+
+    // The initial size of the session-level flow control window.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.14.1
+    uint64_t initial_max_data = DEFAULT_MAX_DATA;
+
+    // The initial maximum number of concurrent bidirectional streams the remote
+    // endpoint is permitted to open.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.22.1
+    uint64_t initial_max_streams_bidi = DEFAULT_MAX_STREAMS_BIDI;
+
+    // The initial maximum number of concurrent unidirectional streams the
+    // remote endpoint is permitted to open.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.24.1
+    uint64_t initial_max_streams_uni = DEFAULT_MAX_STREAMS_UNI;
+
+    // The maximum amount of time that a Session is permitted to remain idle
+    // before it is silently closed and state is discarded.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.4.1
+    uint64_t max_idle_timeout = DEFAULT_MAX_IDLE_TIMEOUT;
+
+    // The maximum number of Connection IDs that the peer can store. A single
+    // Session may have several connection IDs over it's lifetime.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-6.2.1
+    uint64_t active_connection_id_limit = DEFAULT_ACTIVE_CONNECTION_ID_LIMIT;
+
+    // Establishes the exponent used in ACK Delay field in the ACK frame. See
+    // the QUIC specification for details. This is an advanced option that
+    // should rarely be modified and only if there is really good reason.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.26.1
+    uint64_t ack_delay_exponent = NGTCP2_DEFAULT_ACK_DELAY_EXPONENT;
+
+    // The maximum amount of time by which the endpoint will delay sending
+    // acknowledgements. This is an advanced option that should rarely be
+    // modified and only if there is a really good reason. It is used to
+    // determine how long a Session will wait to determine that a packet has
+    // been lost.
+    // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.28.1
+    uint64_t max_ack_delay = NGTCP2_DEFAULT_MAX_ACK_DELAY;
+
+    // The maximum size of DATAGRAM frames that the endpoint will accept.
+    // Setting the value to 0 will disable DATAGRAM support.
+    // https://datatracker.ietf.org/doc/html/rfc9221#section-3
+    uint16_t max_datagram_frame_size = kDefaultMaxPacketLength;
+
+    // When true, communicates that the Session does not support active
+    static const Options kDefault;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(TransportParams::Options)
+    SET_SELF_SIZE(Options)
+
+    static v8::Maybe<Options> From(Environment* env,
+                                   v8::Local<v8::Value> value);
+
+    std::string ToString() const;
+  };
+
+  explicit TransportParams();
+
+  // Creates an instance of TransportParams wrapping an existing const
+  // ngtcp2_transport_params pointer. Instances created this way are
+  // immutable.
+  TransportParams(const ngtcp2_transport_params* ptr);
+
+  TransportParams(const Config& config, const Options& options);
+
+  // Creates an instance of TransportParams by decoding the given buffer.
+  // If the parameters cannot be successfully decoded, the bool() operator
+  // will be false.
+  TransportParams(const ngtcp2_vec& buf, Version version = Version::V1);
+
+  void GenerateSessionTokens(Session* session);
+
+  operator const ngtcp2_transport_params&() const;
+  operator const ngtcp2_transport_params*() const;
+
+  operator bool() const;
+
+  uint64_t initial_max_streams_bidi() const;
+  uint64_t initial_max_streams_uni() const;
+
+  // Returns a Store containing the encoded transport parameters.
+  // If an error occurs during encoding, or if the parameters could
+  // not be encoded, an empty Store will be returned.
+  Store Encode(Environment* env, Version version = Version::V1) const;
+
+  // Returns the encoded size in bytes, or 0 on error.
+  ssize_t EncodedSize(Version version = Version::V1) const;
+
+  // Encode into a caller-provided buffer. Returns the number of bytes
+  // written, or a negative value on error.
+  ssize_t EncodeInto(uint8_t* buf,
+                     size_t len,
+                     Version version = Version::V1) const;
+
+  // Returns a JavaScript object representing the transport parameters.
+  v8::MaybeLocal<v8::Object> ToObject(Environment* env) const;
+
+ private:
+  void SetPreferredAddress(const SocketAddress& address);
+  void GeneratePreferredAddressToken(Session* session);
+  void GenerateStatelessResetToken(const Endpoint& endpoint, const CID& cid);
+
+  ngtcp2_transport_params params_{};
+  const ngtcp2_transport_params* ptr_;
+};
+
+}  // namespace node::quic
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/26/req_wrap-inl.h

@@ -0,0 +1,175 @@
+#ifndef SRC_REQ_WRAP_INL_H_
+#define SRC_REQ_WRAP_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "req_wrap.h"
+#include "async_wrap-inl.h"
+#include "uv.h"
+
+namespace node {
+
+ReqWrapBase::ReqWrapBase(Environment* env) {
+  CHECK(env->has_run_bootstrapping_code());
+  env->req_wrap_queue()->PushBack(this);
+}
+
+template <typename T>
+ReqWrap<T>::ReqWrap(Environment* env,
+                    v8::Local<v8::Object> object,
+                    AsyncWrap::ProviderType provider)
+    : AsyncWrap(env, object, provider),
+      ReqWrapBase(env) {
+  MakeWeak();
+  Reset();
+}
+
+template <typename T>
+ReqWrap<T>::~ReqWrap() {}
+
+template <typename T>
+void ReqWrap<T>::Dispatched() {
+  req_.data = this;
+}
+
+template <typename T>
+void ReqWrap<T>::Reset() {
+  original_callback_ = nullptr;
+  req_.data = nullptr;
+}
+
+template <typename T>
+ReqWrap<T>* ReqWrap<T>::from_req(T* req) {
+  return ContainerOf(&ReqWrap<T>::req_, req);
+}
+
+template <typename T>
+void ReqWrap<T>::Cancel() {
+  if (req_.data == this)  // Only cancel if already dispatched.
+    uv_cancel(reinterpret_cast<uv_req_t*>(&req_));
+}
+
+template <typename T>
+bool ReqWrap<T>::IsDispatched() {
+  return req_.data != nullptr;
+}
+
+template <typename T>
+AsyncWrap* ReqWrap<T>::GetAsyncWrap() {
+  return this;
+}
+
+// Below is dark template magic designed to invoke libuv functions that
+// initialize uv_req_t instances in a unified fashion, to allow easier
+// tracking of active/inactive requests.
+
+// Invoke a generic libuv function that initializes uv_req_t instances.
+// This is, unfortunately, necessary since they come in three different
+// variants that can not all be invoked in the same way:
+// - int uv_foo(uv_loop_t* loop, uv_req_t* request, ...);
+// - int uv_foo(uv_req_t* request, ...);
+// - void uv_foo(uv_req_t* request, ...);
+template <typename ReqT, typename T>
+struct CallLibuvFunction;
+
+// Detect `int uv_foo(uv_loop_t* loop, uv_req_t* request, ...);`.
+template <typename ReqT, typename... Args>
+struct CallLibuvFunction<ReqT, int(*)(uv_loop_t*, ReqT*, Args...)> {
+  using T = int(*)(uv_loop_t*, ReqT*, Args...);
+  template <typename... PassedArgs>
+  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
+    return fn(loop, req, args...);
+  }
+};
+
+// Detect `int uv_foo(uv_req_t* request, ...);`.
+template <typename ReqT, typename... Args>
+struct CallLibuvFunction<ReqT, int(*)(ReqT*, Args...)> {
+  using T = int(*)(ReqT*, Args...);
+  template <typename... PassedArgs>
+  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
+    return fn(req, args...);
+  }
+};
+
+// Detect `void uv_foo(uv_req_t* request, ...);`.
+template <typename ReqT, typename... Args>
+struct CallLibuvFunction<ReqT, void(*)(ReqT*, Args...)> {
+  using T = void(*)(ReqT*, Args...);
+  template <typename... PassedArgs>
+  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
+    fn(req, args...);
+    return 0;
+  }
+};
+
+// This is slightly darker magic: This template is 'applied' to each parameter
+// passed to the libuv function. If the parameter type (aka `T`) is a
+// function type, it is assumed that this it is the request callback, and a
+// wrapper that calls the original callback is created.
+// If not, the parameter is passed through verbatim.
+template <typename ReqT, typename T>
+struct MakeLibuvRequestCallback {
+  static T For(ReqWrap<ReqT>* req_wrap, T v) {
+    static_assert(!IsCallable<T>, "MakeLibuvRequestCallback missed a callback");
+    return v;
+  }
+};
+
+// Match the `void callback(uv_req_t*, ...);` signature that all libuv
+// callbacks use.
+template <typename ReqT, typename... Args>
+struct MakeLibuvRequestCallback<ReqT, void(*)(ReqT*, Args...)> {
+  using F = void(*)(ReqT* req, Args... args);
+
+  static void Wrapper(ReqT* req, Args... args) {
+    BaseObjectPtr<ReqWrap<ReqT>> req_wrap{ReqWrap<ReqT>::from_req(req)};
+    req_wrap->Detach();
+    req_wrap->env()->DecreaseWaitingRequestCounter();
+    F original_callback = reinterpret_cast<F>(req_wrap->original_callback_);
+    original_callback(req, args...);
+  }
+
+  static F For(ReqWrap<ReqT>* req_wrap, F v) {
+    CHECK_NULL(req_wrap->original_callback_);
+    req_wrap->original_callback_ =
+        reinterpret_cast<typename ReqWrap<ReqT>::callback_t>(v);
+    return Wrapper;
+  }
+};
+
+template <typename T>
+template <typename LibuvFunction, typename... Args>
+int ReqWrap<T>::Dispatch(LibuvFunction fn, Args... args) {
+  Dispatched();
+  // This expands as:
+  //
+  // int err = fn(env()->event_loop(), req(), arg1, arg2, Wrapper, arg3, ...)
+  //              ^                                       ^        ^
+  //              |                                       |        |
+  //              \-- Omitted if `fn` has no              |        |
+  //                  first `uv_loop_t*` argument         |        |
+  //                                                      |        |
+  //        A function callback whose first argument      |        |
+  //        matches the libuv request type is replaced ---/        |
+  //        by the `Wrapper` method defined above                  |
+  //                                                               |
+  //               Other (non-function) arguments are passed  -----/
+  //               through verbatim
+  int err = CallLibuvFunction<T, LibuvFunction>::Call(
+      fn,
+      env()->event_loop(),
+      req(),
+      MakeLibuvRequestCallback<T, Args>::For(this, args)...);
+  if (err >= 0) {
+    ClearWeak();
+    env()->IncreaseWaitingRequestCounter();
+  }
+  return err;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_REQ_WRAP_INL_H_

package/src/headers/26/req_wrap.h

@@ -0,0 +1,79 @@
+#ifndef SRC_REQ_WRAP_H_
+#define SRC_REQ_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+
+class Environment;
+
+class ReqWrapBase {
+ public:
+  explicit inline ReqWrapBase(Environment* env);
+
+  virtual ~ReqWrapBase() = default;
+
+  virtual void Cancel() = 0;
+  virtual AsyncWrap* GetAsyncWrap() = 0;
+
+ private:
+  friend int GenDebugSymbols();
+  friend class Environment;
+
+  ListNode<ReqWrapBase> req_wrap_queue_;
+};
+
+template <typename T>
+class ReqWrap : public AsyncWrap, public ReqWrapBase {
+ public:
+  inline ReqWrap(Environment* env,
+                 v8::Local<v8::Object> object,
+                 AsyncWrap::ProviderType provider);
+  inline ~ReqWrap() override;
+  // Call this after the req has been dispatched, if that did not already
+  // happen by using Dispatch().
+  inline void Dispatched();
+  // Call this after a request has finished, if re-using this object is planned.
+  inline void Reset();
+  T* req() { return &req_; }
+  inline void Cancel() final;
+  inline AsyncWrap* GetAsyncWrap() override;
+
+  static ReqWrap* from_req(T* req);
+
+  template <typename LibuvFunction, typename... Args>
+  inline int Dispatch(LibuvFunction fn, Args... args);
+
+  inline bool IsDispatched();
+
+ private:
+  friend int GenDebugSymbols();
+
+  // Adding `friend struct MakeLibuvRequestCallback` is not enough anymore
+  // for some reason. Consider this private.
+ public:
+  typedef void (*callback_t)();
+  callback_t original_callback_ = nullptr;
+
+ protected:
+  // req_wrap_queue_ needs to be at a fixed offset from the start of the class
+  // because it is used by ContainerOf to calculate the address of the embedding
+  // ReqWrap. ContainerOf compiles down to simple, fixed pointer arithmetic. It
+  // is also used by src/node_postmortem_metadata.cc to calculate offsets and
+  // generate debug symbols for ReqWrap, which assumes that the position of
+  // members in memory are predictable. sizeof(req_) depends on the type of T,
+  // so req_wrap_queue_ would no longer be at a fixed offset if it came after
+  // req_. For more information please refer to
+  // `doc/contributing/node-postmortem-support.md`
+  T req_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_REQ_WRAP_H_

package/src/headers/26/spawn_sync.h

@@ -0,0 +1,243 @@
+// 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_SPAWN_SYNC_H_
+#define SRC_SPAWN_SYNC_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_buffer.h"
+#include "uv.h"
+#include "v8.h"
+
+namespace node {
+
+class ExternalReferenceRegistry;
+class SyncProcessOutputBuffer;
+class SyncProcessStdioPipe;
+class SyncProcessRunner;
+
+
+class SyncProcessOutputBuffer {
+  static const unsigned int kBufferSize = 65536;
+
+ public:
+  inline SyncProcessOutputBuffer() = default;
+
+  inline void OnAlloc(size_t suggested_size, uv_buf_t* buf) const;
+  inline void OnRead(const uv_buf_t* buf, size_t nread);
+
+  inline size_t Copy(char* dest) const;
+
+  inline unsigned int available() const;
+  inline unsigned int used() const;
+
+  inline SyncProcessOutputBuffer* next() const;
+  inline void set_next(SyncProcessOutputBuffer* next);
+
+ private:
+  // Use unsigned int because that's what `uv_buf_init` takes.
+  mutable char data_[kBufferSize];
+  unsigned int used_ = 0;
+
+  SyncProcessOutputBuffer* next_ = nullptr;
+};
+
+
+class SyncProcessStdioPipe {
+  enum Lifecycle {
+    kUninitialized = 0,
+    kInitialized,
+    kStarted,
+    kClosing,
+    kClosed
+  };
+
+ public:
+  SyncProcessStdioPipe(SyncProcessRunner* process_handler,
+                       bool readable,
+                       bool writable,
+                       uv_buf_t input_buffer);
+  ~SyncProcessStdioPipe();
+
+  int Initialize(uv_loop_t* loop);
+  int Start();
+  void Close();
+
+  v8::MaybeLocal<v8::Object> GetOutputAsBuffer(Environment* env) const;
+
+  inline bool readable() const;
+  inline bool writable() const;
+  inline uv_stdio_flags uv_flags() const;
+
+  inline uv_pipe_t* uv_pipe() const;
+  inline uv_stream_t* uv_stream() const;
+  inline uv_handle_t* uv_handle() const;
+
+ private:
+  inline size_t OutputLength() const;
+  inline void CopyOutput(char* dest) const;
+
+  inline void OnAlloc(size_t suggested_size, uv_buf_t* buf);
+  inline void OnRead(const uv_buf_t* buf, ssize_t nread);
+  inline void OnWriteDone(int result);
+  inline void OnShutdownDone(int result);
+  inline void OnClose();
+
+  inline void SetError(int error);
+
+  static void AllocCallback(uv_handle_t* handle,
+                            size_t suggested_size,
+                            uv_buf_t* buf);
+  static void ReadCallback(uv_stream_t* stream,
+                           ssize_t nread,
+                           const uv_buf_t* buf);
+  static void WriteCallback(uv_write_t* req, int result);
+  static void ShutdownCallback(uv_shutdown_t* req, int result);
+  static void CloseCallback(uv_handle_t* handle);
+
+  SyncProcessRunner* process_handler_;
+
+  bool readable_;
+  bool writable_;
+  uv_buf_t input_buffer_;
+
+  SyncProcessOutputBuffer* first_output_buffer_;
+  SyncProcessOutputBuffer* last_output_buffer_;
+
+  mutable uv_pipe_t uv_pipe_;
+  uv_write_t write_req_;
+  uv_shutdown_t shutdown_req_;
+
+  Lifecycle lifecycle_;
+};
+
+
+class SyncProcessRunner {
+  enum Lifecycle {
+    kUninitialized = 0,
+    kInitialized,
+    kHandlesClosed
+  };
+
+ public:
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context,
+                         void* priv);
+  static void Spawn(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ private:
+  friend class SyncProcessStdioPipe;
+
+  explicit SyncProcessRunner(Environment* env_);
+  ~SyncProcessRunner();
+
+  inline Environment* env() const;
+
+  v8::MaybeLocal<v8::Object> Run(v8::Local<v8::Value> options);
+  v8::Maybe<void> TryInitializeAndRunLoop(v8::Local<v8::Value> options);
+  void CloseHandlesAndDeleteLoop();
+
+  void CloseStdioPipes();
+  void CloseKillTimer();
+
+  void Kill();
+  void IncrementBufferSizeAndCheckOverflow(ssize_t length);
+
+  void OnExit(int64_t exit_status, int term_signal);
+  void OnKillTimerTimeout();
+
+  int GetError();
+  void SetError(int error);
+  void SetPipeError(int pipe_error);
+
+  v8::MaybeLocal<v8::Object> BuildResultObject();
+  v8::MaybeLocal<v8::Array> BuildOutputArray();
+
+  v8::Maybe<int> ParseOptions(v8::Local<v8::Value> js_value);
+  v8::Maybe<int> ParseStdioOptions(v8::Local<v8::Value> js_value);
+  v8::Maybe<int> ParseStdioOption(int child_fd,
+                                  v8::Local<v8::Object> js_stdio_option);
+
+  inline int AddStdioIgnore(uint32_t child_fd);
+  inline int AddStdioPipe(uint32_t child_fd,
+                          bool readable,
+                          bool writable,
+                          uv_buf_t input_buffer);
+  inline int AddStdioInheritFD(uint32_t child_fd, int inherit_fd);
+
+  static bool IsSet(v8::Local<v8::Value> value);
+  v8::Maybe<int> CopyJsString(v8::Local<v8::Value> js_value,
+                              const char** target);
+  v8::Maybe<int> CopyJsStringArray(v8::Local<v8::Value> js_value,
+                                   char** target);
+
+  static void ExitCallback(uv_process_t* handle,
+                           int64_t exit_status,
+                           int term_signal);
+  static void KillTimerCallback(uv_timer_t* handle);
+  static void KillTimerCloseCallback(uv_handle_t* handle);
+
+  double max_buffer_;
+  uint64_t timeout_;
+  int kill_signal_;
+
+  uv_loop_t* uv_loop_;
+
+  uint32_t stdio_count_;
+  std::vector<uv_stdio_container_t> uv_stdio_containers_;
+  std::vector<std::unique_ptr<SyncProcessStdioPipe>> stdio_pipes_;
+  bool stdio_pipes_initialized_;
+
+  uv_process_options_t uv_process_options_;
+  std::unique_ptr<const char[]> file_buffer_;
+  std::unique_ptr<char[]> args_buffer_;
+  std::unique_ptr<char[]> env_buffer_;
+  std::unique_ptr<const char[]> cwd_buffer_;
+
+  uv_process_t uv_process_;
+  bool killed_;
+
+  size_t buffered_output_size_;
+  int64_t exit_status_;
+  int term_signal_;
+
+  uv_timer_t uv_timer_;
+  bool kill_timer_initialized_;
+
+  // Errors that happen in one of the pipe handlers are stored in the
+  // `pipe_error` field. They are treated as "low-priority", only to be
+  // reported if no more serious errors happened.
+  int error_;
+  int pipe_error_;
+
+  Lifecycle lifecycle_;
+
+  Environment* env_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_SPAWN_SYNC_H_