@encharm/cws 4.5.2 → 4.6.0

package/src/headers/26/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/src/headers/26/quic/application.h

@@ -0,0 +1,279 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <optional>
+#include <variant>
+
+#include "base_object.h"
+#include "bindingdata.h"
+#include "defs.h"
+#include "session.h"
+#include "sessionticket.h"
+#include "streams.h"
+
+namespace node::quic {
+
+// Parsed session ticket application data, produced by
+// Application::ParseTicketData() before ALPN negotiation and consumed
+// by Application::ApplySessionTicketData() after.
+struct DefaultTicketData {};
+struct Http3TicketData {
+  uint64_t max_field_section_size;
+  uint64_t qpack_max_dtable_capacity;
+  uint64_t qpack_encoder_max_dtable_capacity;
+  uint64_t qpack_blocked_streams;
+  bool enable_connect_protocol;
+  bool enable_datagrams;
+};
+using PendingTicketAppData =
+    std::variant<std::monostate, DefaultTicketData, Http3TicketData>;
+
+// 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)
+
+  // Get the active options for this application. These may differ from the
+  // options passed at construction time since some options can be negotiated.
+  virtual const Options& options() const = 0;
+
+  // The type of Application, exposed via the session state so JS
+  // can observe which Application was selected after ALPN negotiation.
+  // This is used primarily for testing/debugging.
+  enum class Type : uint8_t {
+    NONE = 0,     // Not yet selected (server pre-negotiation)
+    DEFAULT = 1,  // DefaultApplication (non-h3 ALPN)
+    HTTP3 = 2,    // Http3ApplicationImpl (h3 / h3-XX ALPN)
+  };
+  virtual Type type() const = 0;
+
+  virtual bool Start();
+
+  // Returns true if Start() has been called successfully.
+  virtual bool is_started() const { return false; }
+
+  // Called when the server rejects 0-RTT early data. The application
+  // must destroy all streams that were opened during the 0-RTT phase
+  // since ngtcp2 has already discarded their internal state.
+  virtual void EarlyDataRejected() = 0;
+
+  // The "no error code" is the application-level error code that signals
+  // "no error". Per the QUIC spec, this can vary by application protocol
+  // and is not necessarily 0.
+  virtual error_code GetNoErrorCode() const = 0;
+
+  // The "internal error code" is the application-level error code used
+  // to signal a non-specific failure when no more specific code has
+  // been provided by the caller. For example, `writer.fail(reason)` on
+  // the JS side uses this code when `reason` is not a `QuicError`
+  // carrying an explicit code. For HTTP/3 this is
+  // `NGHTTP3_H3_INTERNAL_ERROR` (0x102); for raw QUIC applications
+  // there is no defined application code so we fall back to
+  // NGTCP2_INTERNAL_ERROR (0x1).
+  virtual error_code GetInternalErrorCode() const = 0;
+
+  // The "request rejected" code is sent on RESET_STREAM when an incoming
+  // request stream is rejected without any application processing (e.g.
+  // the session has no consumer for it), so the peer learns the request
+  // was not processed. For HTTP/3 this is NGHTTP3_H3_REQUEST_REJECTED
+  // (0x10b); other applications have no such semantic and reuse the
+  // "no error" code.
+  virtual error_code GetRequestRejectedCode() const = 0;
+
+  // Called after Session::Receive processes a packet, outside all callback
+  // scopes. Applications can use this to handle deferred operations that
+  // require calling into JS (e.g., HTTP/3 GOAWAY processing).
+  virtual void PostReceive() {}
+
+  // Called when ngtcp2 notifies us that a new remote stream has been
+  // opened. The Application decides whether to create a Stream object
+  // (and fire the JS onstream callback) based on the stream type. For
+  // example, HTTP/3 only creates Stream objects for bidi streams since
+  // uni streams are managed internally by nghttp3.
+  virtual bool ReceiveStreamOpen(stream_id id) = 0;
+
+  // 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_id id,
+                                 const uint8_t* data,
+                                 size_t datalen,
+                                 const Stream::ReceiveDataFlags& flags,
+                                 void* stream_user_data) = 0;
+
+  // Session will forward all data acknowledgements for a stream to the
+  // Application.
+  virtual bool AcknowledgeStreamData(stream_id id, 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) {
+    return false;
+  }
+
+  // Called when ngtcp2 reports NGTCP2_ERR_STREAM_SHUT_WR for a stream.
+  // Applications that manage their own framing (e.g., HTTP/3) must inform
+  // their protocol layer that the stream's write side is shut so it stops
+  // queuing data for that stream. The default is a no-op.
+  virtual void StreamWriteShut(stream_id id) {}
+
+  // 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(stream_id id) {}
+
+  // Called when the session determines that there is outbound data available
+  // to send for the given stream.
+  virtual void ResumeStream(stream_id 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) {}
+
+  // Returns true if the application manages stream FIN internally (e.g.,
+  // HTTP/3 uses nghttp3 which sends FIN via the fin flag in writev_stream).
+  // When true, the stream infrastructure must NOT call
+  // ngtcp2_conn_shutdown_stream_write when the JS write side ends —
+  // the application protocol layer handles it.
+  virtual bool stream_fin_managed_by_application() const { return false; }
+
+  // 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) {
+    Debug(session_, "Application extending max stream data");
+    // By default do nothing.
+  }
+
+  // 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). The first byte written MUST be the Application::Type enum value.
+  // By default, writes just the type byte.
+  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);
+
+  // Validates parsed ticket data against current application options.
+  // Returns false if the stored settings are more permissive than the
+  // current config (e.g., a feature was enabled when the ticket was
+  // issued but is now disabled).
+  static bool ValidateTicketData(const PendingTicketAppData& data,
+                                 const Application_Options& options);
+
+  // Parse session ticket app data before ALPN negotiation. Reads the
+  // type byte and dispatches to the appropriate application-specific
+  // parser. Returns std::nullopt if parsing fails.
+  static std::optional<PendingTicketAppData> ParseTicketData(
+      const uv_buf_t& data);
+
+  // Called after ALPN negotiation to validate and apply previously
+  // parsed session ticket app data. Returns false if the data is
+  // incompatible (e.g., type mismatch or settings downgrade), which
+  // causes the handshake to fail.
+  virtual bool ApplySessionTicketData(const PendingTicketAppData& data) = 0;
+
+  // Notifies the Application that the identified stream has been closed.
+  virtual void ReceiveStreamClose(Stream* stream,
+                                  QuicError&& error = QuicError());
+
+  // Notifies the Application that the identified stream has been reset.
+  virtual void ReceiveStreamReset(Stream* stream,
+                                  uint64_t final_size,
+                                  QuicError&& error = QuicError());
+
+  // Notifies the Application that the identified stream should stop sending.
+  virtual void ReceiveStreamStopSending(Stream* stream,
+                                        QuicError&& error = QuicError());
+
+  // 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) {
+    return false;
+  }
+
+  // Returns true if the application protocol supports sending and
+  // receiving headers on streams (e.g. HTTP/3). Applications that
+  // do not support headers should return false (the default).
+  virtual bool SupportsHeaders() const { return false; }
+
+  // True if this application dispatches the session-level stream
+  // callbacks (onheaders et al) for incoming streams when they are
+  // registered on the session.
+  virtual bool SupportsStreamCallbacks() const { return false; }
+
+  // Initiates application-level graceful shutdown signaling (e.g.,
+  // HTTP/3 GOAWAY). Called when Session::Close(GRACEFUL) is invoked.
+  virtual void BeginShutdown() {}
+
+  // Completes the application-level graceful shutdown. Called from
+  // FinishClose() before CONNECTION_CLOSE is sent. For HTTP/3, this
+  // sends the final GOAWAY with the actual last accepted stream ID.
+  virtual void CompleteShutdown() {}
+
+  // 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::NON_INCREMENTAL) {}
+
+  struct StreamPriorityResult {
+    StreamPriority priority;
+    StreamPriorityFlags flags;
+  };
+
+  // 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 StreamPriorityResult GetStreamPriority(const Stream& stream) {
+    return {StreamPriority::DEFAULT, StreamPriorityFlags::NON_INCREMENTAL};
+  }
+
+  virtual int GetStreamData(StreamData* data) = 0;
+  virtual bool StreamCommit(StreamData* data, size_t datalen) = 0;
+
+  inline Environment* env() const { return session().env(); }
+
+  inline Session& session() {
+    CHECK_NOT_NULL(session_);
+    return *session_;
+  }
+  inline const Session& session() const {
+    CHECK_NOT_NULL(session_);
+    return *session_;
+  }
+
+ private:
+  Session* session_ = nullptr;
+};
+
+// Create a DefaultApplication for the given session.
+std::unique_ptr<Session::Application> CreateDefaultApplication(
+    Session* session, const Session::Application_Options& options);
+
+}  // namespace node::quic
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS