raptor 0.23.0 → 0.25.0

data/lib/raptor/http1.rb

@@ -43,6 +43,7 @@ module Raptor
     BAD_REQUEST_RESPONSE = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
     CONTENT_TOO_LARGE_RESPONSE = "HTTP/1.1 413 Content Too Large\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
     INTERNAL_SERVER_ERROR_RESPONSE = "HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+    NOT_IMPLEMENTED_RESPONSE = "HTTP/1.1 501 Not Implemented\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
     CHUNKED_TERMINATOR = "0\r\n\r\n"
 
     CONNECTION_CLOSE = "close"
@@ -75,31 +76,29 @@ module Raptor
       !http_host || http_host.empty? || http_host.include?(",")
     end
 
-    # Returns true when the message framing shows a request-smuggling vector
-    # per RFC 9112 section 6.3: a `Transfer-Encoding` where `chunked` is
-    # missing, not the final encoding, or duplicated; a `Transfer-Encoding`
-    # paired with a `Content-Length`; or a `Content-Length` containing any
-    # non-digit character.
+    # Rejects ambiguous message framing per RFC 9112 section 6.3 and
+    # transfer codings other than a single `chunked`.
     #
     # @param env [Hash] the Rack environment after header parsing
-    # @return [Boolean]
+    # @return [Symbol, nil] `:malformed`, `:unsupported_encoding`, or nil
     #
-    # @rbs (Hash[String, untyped] env) -> bool
-    def self.request_smuggling?(env)
+    # @rbs (Hash[String, untyped] env) -> Symbol?
+    def self.framing_error(env)
       transfer_encoding = env[HTTP_TRANSFER_ENCODING]
       content_length = env[Http::CONTENT_LENGTH]
 
       if transfer_encoding
-        return true if content_length
+        return :malformed if content_length
 
-        encodings = transfer_encoding.downcase.split(",").map(&:strip)
-        return true if encodings.last != TRANSFER_ENCODING_CHUNKED
-        return true if encodings.count(TRANSFER_ENCODING_CHUNKED) > 1
+        encodings = transfer_encoding.downcase.split(",", -1).map(&:strip)
+        return :malformed if encodings.any?(&:empty?) || encodings.last != TRANSFER_ENCODING_CHUNKED
+        return :malformed if encodings.count(TRANSFER_ENCODING_CHUNKED) > 1
+        return :unsupported_encoding if encodings.size > 1
       elsif content_length
-        return true if content_length.match?(/[^\d]/)
+        return :malformed unless content_length.match?(/\A[0-9]+\z/)
       end
 
-      false
+      nil
     end
 
     # Returns any pipelined bytes following the request, or nil if none remain.
@@ -144,9 +143,9 @@ module Raptor
     # Advances an HTTP/1.x request parse from the state hash's buffered
     # bytes. A complete well-formed request returns with `:complete` set
     # plus populated `:env` and `:body`, and records any bytes after it in
-    # the parse data's `:pipelined`; malformed or oversized input flips
-    # `:malformed` or `:too_large`; incomplete input returns the state
-    # so the reactor can wait for more.
+    # the parse data's `:pipelined`. Rejected input sets `:malformed`,
+    # `:too_large`, or `:unsupported_encoding`; incomplete input returns
+    # the state so the reactor can wait for more.
     #
     # @param data [Hash] the current parse state
     # @param env_template [Hash] the Rack env template to seed the request with
@@ -170,8 +169,9 @@ module Raptor
       parse_data[:parse_count] += 1
 
       message = if parser.finished?
-        if invalid_host?(env) || request_smuggling?(env)
-          data.merge(env: env, body: nil, parse_data: parse_data, complete: true, malformed: true)
+        error = invalid_host?(env) ? :malformed : framing_error(env)
+        if error
+          data.merge(env: env, body: nil, parse_data: parse_data, complete: true, error => true)
         elsif parser.has_body?
           body_buffer = data[:buffer].byteslice(nread..-1) || ""
 
@@ -325,6 +325,9 @@ module Raptor
       when :malformed
         reject_malformed(socket)
         return
+      when :unsupported_encoding
+        reject_unsupported_encoding(socket)
+        return
       end
 
       thread_pool << proc do
@@ -354,6 +357,12 @@ module Raptor
         return
       end
 
+      if parsed_request[:unsupported_encoding]
+        socket = reactor.remove(parsed_request[:id])
+        reject_unsupported_encoding(socket) if socket
+        return
+      end
+
       if parsed_request[:complete]
         socket = reactor.remove(parsed_request[:id])
         request_count = (parsed_request[:request_count] || 0) + 1
@@ -444,6 +453,9 @@ module Raptor
         when :malformed
           reject_malformed(socket)
           return
+        when :unsupported_encoding
+          reject_unsupported_encoding(socket)
+          return
         end
 
         request_count += 1
@@ -530,11 +542,13 @@ module Raptor
     # @param parser [HttpParser] the parser holding the finished parse state
     # @param nread [Integer] the byte offset where the body begins in `buffer`
     # @return [String, nil, Symbol] body, nil when absent, or `:incomplete`,
-    #   `:too_large`, or `:malformed`
+    #   `:too_large`, `:malformed`, or `:unsupported_encoding`
     #
     # @rbs (String buffer, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, HttpParser parser, Integer nread) -> (String | Symbol)?
     def extract_body(buffer, env, parse_data, parser, nread)
-      return :malformed if Http1.invalid_host?(env) || Http1.request_smuggling?(env)
+      return :malformed if Http1.invalid_host?(env)
+      error = Http1.framing_error(env)
+      return error if error
 
       unless parser.has_body?
         parse_data[:pipelined] = Http1.pipelined_bytes(buffer, nread)
@@ -809,6 +823,17 @@ module Raptor
       socket.close rescue nil
     end
 
+    # Writes a 501 response and closes the socket.
+    #
+    # @param socket [TCPSocket] the client socket
+    # @return [void]
+    #
+    # @rbs (TCPSocket socket) -> void
+    def reject_unsupported_encoding(socket)
+      socket.write(NOT_IMPLEMENTED_RESPONSE) rescue nil
+      socket.close rescue nil
+    end
+
     # Builds a Rack environment hash from parsed HTTP request data.
     #
     # @param env [Hash] partial env hash from the HTTP parser
@@ -855,7 +880,6 @@ module Raptor
       end
 
       env[Http::REMOTE_ADDR] = remote_addr
-      env[Http::HTTP_VERSION] = env[Rack::SERVER_PROTOCOL]
 
       behind_tls_proxy = (url_scheme == Server::HTTP_SCHEME) && forwarded_https?(env)
       env[Rack::RACK_URL_SCHEME] = behind_tls_proxy ? Server::HTTPS_SCHEME : url_scheme
@@ -890,7 +914,8 @@ module Raptor
 
     # Builds the `rack.input` IO object for the request body. Returns an
     # in-memory StringIO for bodies up to the spool threshold, or a Tempfile
-    # for larger bodies to bound per-worker memory.
+    # for larger bodies. The complete body is already buffered at this point,
+    # so spooling does not bound peak receive memory.
     #
     # @param body [String, nil] decoded request body
     # @return [IO] an IO-like object positioned at the start of the body
@@ -934,13 +959,10 @@ module Raptor
     def keep_alive?(env, request_count)
       return false if request_count >= @max_keepalive_requests
 
-      connection_header = env[HTTP_CONNECTION]
+      connection_tokens = env[HTTP_CONNECTION].to_s.downcase.split(",").map(&:strip)
+      return false if connection_tokens.include?(CONNECTION_CLOSE)
 
-      if env[Rack::SERVER_PROTOCOL] == HTTP_11
-        !connection_header&.casecmp?(CONNECTION_CLOSE)
-      else
-        connection_header&.casecmp?(CONNECTION_KEEPALIVE) || false
-      end
+      env[Rack::SERVER_PROTOCOL] == HTTP_11 || connection_tokens.include?(CONNECTION_KEEPALIVE)
     end
 
     # Sends an HTTP 103 Early Hints response, skipping any entries with
@@ -1159,7 +1181,7 @@ module Raptor
     #
     # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, untyped body, String http_version) -> void
     def write_full_response(socket, response, headers, body, http_version)
-      if body.respond_to?(:call)
+      if body.respond_to?(:call) && !body.respond_to?(:each)
         HttpParser.format_headers(response, headers)
         response << "\r\n"
         socket_write(socket, response)

data/lib/raptor/http2.rb

@@ -455,7 +455,7 @@ module Raptor
     # updated connection state along with any outgoing protocol frames and
     # completed stream requests.
     #
-    # @param data [Hash] the connection state including buffer and HPACK table
+    # @param data [Hash] the connection state including buffer, HPACK table and body-size limit
     # @return [Hash] updated state with outgoing_frames and completed_requests
     #
     # @rbs (Hash[Symbol, untyped] data) -> Hash[Symbol, untyped]
@@ -474,6 +474,7 @@ module Raptor
       preface_received = data[:http2_preface_received] || false
       last_client_stream_id = data[:http2_last_client_stream_id] || 0
       pending_headers = data[:http2_pending_headers]
+      max_body_size = data[:max_body_size]
       goaway_error = nil
 
       unless preface_received
@@ -586,12 +587,29 @@ module Raptor
           stream = streams[stream_id]
           next unless stream
 
+          if stream[:too_large]
+            streams.delete(stream_id) if frame[:flags].anybits?(FLAG_END_STREAM)
+            next
+          end
+
+          body = stream[:body] || ""
+          if max_body_size && body.bytesize + chunk.bytesize > max_body_size
+            headers = parser.encode_headers([[":status", "413"], ["content-length", "0"]])
+            outgoing_frames << parser.build_frame(:headers, FLAG_END_HEADERS | FLAG_END_STREAM, stream_id, headers)
+            if frame[:flags].anybits?(FLAG_END_STREAM)
+              streams.delete(stream_id)
+            else
+              streams[stream_id] = { too_large: true }
+            end
+            next
+          end
+
           stream_window_used = (stream[:window_used] || 0) + frame[:length]
           if stream_window_used >= DEFAULT_WINDOW_SIZE / 2 && frame[:flags].nobits?(FLAG_END_STREAM)
             outgoing_frames << parser.build_frame(:window_update, 0, stream_id, [stream_window_used].pack("N"))
             stream_window_used = 0
           end
-          stream = stream.merge(body: (stream[:body] || "") + chunk, window_used: stream_window_used)
+          stream = stream.merge(body: body + chunk, window_used: stream_window_used)
 
           if frame[:flags].anybits?(FLAG_END_STREAM)
             stream_headers = stream[:headers] || []
@@ -714,11 +732,13 @@ module Raptor
         outgoing_frames << parser.build_frame(:rst_stream, 0, stream_id, [ERROR_PROTOCOL_ERROR].pack("N"))
       elsif trailers
         stream = streams.delete(stream_id)
-        completed_requests << {
-          stream_id: stream_id,
-          headers: stream[:headers],
-          body: stream[:body] || ""
-        }
+        unless stream[:too_large]
+          completed_requests << {
+            stream_id: stream_id,
+            headers: stream[:headers],
+            body: stream[:body] || ""
+          }
+        end
       else
         streams, completed_requests = finalize_headers(streams, completed_requests, stream_id, decoded_headers, end_stream)
       end
@@ -783,6 +803,7 @@ module Raptor
         id: data[:id],
         protocol: :http2,
         buffer: buffer || "",
+        max_body_size: data[:max_body_size],
         hpack_table: hpack_table,
         http2_streams: streams,
         http2_window: connection_window,
@@ -806,6 +827,7 @@ module Raptor
     # @rbs @app: ^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped]
     # @rbs @server_port_string: String
     # @rbs @write_timeout: Integer
+    # @rbs @max_body_size: Integer?
     # @rbs @access_log_io: IO?
     # @rbs @clean_thread_locals: bool
     # @rbs @clean_fiber_locals: bool
@@ -819,6 +841,7 @@ module Raptor
     # @param server_port [Integer] port number used to populate SERVER_PORT in the Rack env
     # @param connection_options [Hash] per-connection settings shared across protocols
     # @option connection_options [Integer] :write_timeout per-write socket timeout in seconds
+    # @option connection_options [Integer, nil] :max_body_size maximum request body size in bytes
     # @param http2_options [Hash] HTTP/2-specific settings
     # @option http2_options [Integer] :max_concurrent_streams maximum HTTP/2 concurrent streams per connection
     # @param access_log_io [IO, nil] IO to write Common Log Format access entries to, or nil to disable
@@ -832,6 +855,7 @@ module Raptor
       @app = app
       @server_port_string = server_port.to_s.freeze
       @write_timeout = connection_options[:write_timeout] || Http::WRITE_TIMEOUT
+      @max_body_size = connection_options[:max_body_size]
       @access_log_io = access_log_io
       @clean_thread_locals = clean_thread_locals
       @clean_fiber_locals = clean_fiber_locals
@@ -902,6 +926,7 @@ module Raptor
       initial_state = {
         id: id,
         protocol: :http2,
+        max_body_size: @max_body_size,
         remote_addr: remote_addr,
         url_scheme: url_scheme
       }
@@ -1140,11 +1165,6 @@ module Raptor
         trailers: env[RESPONSE_TRAILERS],
         request_method: env[Rack::REQUEST_METHOD]
       ) { response_started = true }
-      if response_body.is_a?(DetachedBody)
-        response_body.finish(:closed)
-      elsif response_body.respond_to?(:close)
-        response_body.close
-      end
       write_access_log(env, status, response_size, remote_addr) if @access_log_io
       Http.call_response_finished(env, status, response_headers, nil)
     rescue StreamClosedError => error
@@ -1230,6 +1250,12 @@ module Raptor
       stream.close
 
       stream.bytes_written.to_s
+    ensure
+      if body.is_a?(DetachedBody)
+        body.finish($! ? :cancelled : :closed)
+      elsif body.respond_to?(:close)
+        body.close
+      end
     end
 
     # Sends an HTTP 103 Early Hints response.
@@ -1298,6 +1324,7 @@ module Raptor
     # @rbs (Array[[String, String]] headers, String body, TCPSocket | OpenSSL::SSL::SSLSocket socket, Writer writer, FlowControl flow_control, Integer stream_id, remote_addr: String) -> Hash[String, untyped]
     def build_rack_env(headers, body, socket, writer, flow_control, stream_id, remote_addr:)
       env = {}
+      underscored_headers = nil
 
       headers.each do |name, value|
         if name.start_with?(":")
@@ -1316,6 +1343,13 @@ module Raptor
           env[Http::CONTENT_LENGTH] = value
         else
           rack_key = "HTTP_#{name.upcase.tr("-", "_")}"
+          if name.include?("_")
+            next if env.key?(rack_key) && !underscored_headers&.key?(rack_key)
+
+            (underscored_headers ||= {})[rack_key] = true
+          elsif underscored_headers&.delete(rack_key)
+            env.delete(rack_key)
+          end
           if (existing = env[rack_key])
             separator = rack_key == Rack::HTTP_COOKIE ? "; " : ", "
             env[rack_key] = "#{existing}#{separator}#{value}"
@@ -1345,7 +1379,6 @@ module Raptor
 
       env[Http::REMOTE_ADDR] = remote_addr
       env[Http::SERVER_SOFTWARE] = Http::SERVER_SOFTWARE_VALUE
-      env[Http::HTTP_VERSION] = SERVER_PROTOCOL
       env[RESPONSE_TRAILERS] = {}
 
       populate_server_name_and_port(env)

data/lib/raptor/plugin.rb

@@ -0,0 +1,98 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Raptor
+  # An extension, loaded from `raptor/plugin/<name>` or
+  # registered explicitly by application code.
+  #
+  class Plugin
+    class UnknownPlugin < LoadError; end
+
+    # @rbs self.@registry: Hash[String, singleton(Plugin)]
+    @registry = {}
+
+    # Registers a plugin class under a name.
+    #
+    # @rbs (String | Symbol name, singleton(Plugin) plugin) -> void
+    def self.register(name, plugin)
+      @registry[name.to_s] = plugin
+    end
+
+    # Defines and registers a plugin without a named subclass.
+    #
+    # @rbs (String | Symbol name) { () -> void } -> singleton(Plugin)
+    def self.create(name, &block)
+      plugin = Class.new(self, &block)
+      register(name, plugin)
+      plugin
+    end
+
+    # Loads a registered plugin, requiring its conventional path if needed.
+    #
+    # @rbs (String | Symbol name) -> Plugin
+    def self.load(name)
+      name = name.to_s
+      path = "raptor/plugin/#{name}"
+      unless @registry.key?(name)
+        begin
+          require path
+        rescue LoadError => error
+          raise UnknownPlugin, "Unable to find plugin #{name.inspect}" if error.path == path
+
+          raise
+        end
+      end
+
+      plugin = @registry[name]
+      raise UnknownPlugin, "#{path} did not register plugin #{name.inspect}" unless plugin
+
+      plugin.new
+    end
+
+    # @rbs @threads: Array[Thread]?
+
+    # Starts in the master before workers fork. Override to open resources
+    # and append callbacks to the cluster's lifecycle hook arrays.
+    #
+    # @rbs (Cluster cluster) -> void
+    def start(cluster)
+    end
+
+    # Stops in the master after workers exit, including before hot restart.
+    # Also called if startup fails, so resources may be only partly opened.
+    #
+    # @rbs () -> void
+    def stop
+    end
+
+    # Runs a block on a master-owned thread. Raptor stops and joins these
+    # threads after calling `stop`; use `ensure` in the block for cleanup.
+    #
+    # @rbs () { () -> void } -> Thread
+    def in_background(&block)
+      @threads ||= []
+      @threads << Thread.new do
+        Thread.current.name = "Plugin #{self.class}"
+        block.call
+      end
+      @threads.last
+    end
+
+    # Calls the plugin's stop callback and joins its background threads.
+    #
+    # @rbs () -> void
+    def shutdown
+      stop
+    ensure
+      threads = @threads || []
+      threads.each(&:kill)
+      error = nil
+      threads.each do |thread|
+        thread.join
+      rescue StandardError => thread_error
+        error ||= thread_error
+      end
+      raise error if error
+    end
+  end
+end