raptor 0.6.0 → 0.8.0

data/lib/raptor/{request.rb → http1.rb}

@@ -8,6 +8,7 @@ require "tempfile"
 require "atomic-ruby/atomic_boolean"
 require "rack"
 
+require_relative "http"
 require_relative "raptor_http"
 
 module Raptor
@@ -16,11 +17,11 @@ module Raptor
   # with the reactor for requests that need more data before they
   # can be handled.
   #
-  class Request
+  class Http1
     BODY_BUFFER_THRESHOLD = 256 * 1024
     FILE_CHUNK_SIZE = 64 * 1024
+    MAX_CHUNK_OVERHEAD = 16 * 1024
     READ_BUFFER_SIZE = 64 * 1024
-    WRITE_TIMEOUT = 5
     KEEPALIVE_READ_TIMEOUT = 0.001
     MAX_KEEPALIVE_REQUESTS = 100
 
@@ -35,16 +36,19 @@ module Raptor
       h[status] = "HTTP/1.1 #{status}#{reason ? " #{reason}" : ""}\r\n".freeze
     end
 
-    STATUS_WITH_NO_ENTITY_BODY = Set.new([204, 304, *100..199]).freeze
+    STATUS_WITH_NO_ENTITY_BODY = [204, 304, *100..199].freeze
+    CONTINUE_RESPONSE = "HTTP/1.1 100 Continue\r\n\r\n"
     BAD_REQUEST_RESPONSE = "HTTP/1.1 400 Bad Request\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"
     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"
 
     CONNECTION_CLOSE = "close"
     CONNECTION_KEEPALIVE = "keep-alive"
+    EXPECT_100_CONTINUE = "100-continue"
     TRANSFER_ENCODING_CHUNKED = "chunked"
 
     HTTP_CONNECTION = "HTTP_CONNECTION"
+    HTTP_EXPECT = "HTTP_EXPECT"
     HTTP_TRANSFER_ENCODING = "HTTP_TRANSFER_ENCODING"
     RACK_HEADER_PREFIX = "rack."
     RACK_HIJACKED = "rack.hijacked"
@@ -53,17 +57,39 @@ module Raptor
     ILLEGAL_HEADER_KEY_REGEX = /[\x00-\x20\(\)<>@,;:\\"\/\[\]\?=\{\}\x7F]/
     ILLEGAL_HEADER_VALUE_REGEX = /[\x00-\x08\x0A-\x1F]/
 
-    class Error < StandardError; end
-    class WriteError < Error
-      # @rbs () -> String
-      def message = "could not write response"
+    # 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.
+    #
+    # @param env [Hash] the Rack environment after header parsing
+    # @return [Boolean]
+    #
+    # @rbs (Hash[String, untyped] env) -> bool
+    def self.request_smuggling?(env)
+      transfer_encoding = env[HTTP_TRANSFER_ENCODING]
+      content_length = env[Http::CONTENT_LENGTH]
+
+      if transfer_encoding
+        return true 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
+      elsif content_length
+        return true if content_length.match?(/[^\d]/)
+      end
+
+      false
     end
 
     # Decodes a chunked transfer-encoded body buffer.
     #
     # Returns the decoded bytes and a state symbol: `:complete` when the
     # terminating zero-length chunk was found, `:too_large` when the decoded
-    # size would exceed `max_size`, or `:incomplete` otherwise.
+    # size would exceed `max_size`, `:malformed` when chunk framing overhead
+    # exceeds `MAX_CHUNK_OVERHEAD`, or `:incomplete` otherwise.
     #
     # @param buffer [String] the raw body buffer to decode
     # @param max_size [Integer, nil] maximum decoded body size, or nil for unlimited
@@ -73,6 +99,7 @@ module Raptor
     def self.decode_chunked(buffer, max_size = nil)
       decoded = String.new
       offset = 0
+      overhead = 0
 
       while offset < buffer.bytesize
         crlf = buffer.index("\r\n", offset)
@@ -80,7 +107,10 @@ module Raptor
 
         chunk_size = buffer.byteslice(offset, crlf - offset).to_i(16)
         return [decoded, :complete] if chunk_size == 0
-        return [decoded, :too_large] if max_size && decoded.bytesize + chunk_size > max_size
+        return [decoded, :too_large] if max_size && (decoded.bytesize + chunk_size) > max_size
+
+        overhead += (crlf - offset) + 4
+        return [decoded, :malformed] if overhead > (decoded.bytesize + chunk_size + MAX_CHUNK_OVERHEAD)
 
         offset = crlf + 2
         decoded << buffer.byteslice(offset, chunk_size)
@@ -90,58 +120,56 @@ module Raptor
       [decoded, :incomplete]
     end
 
-    # Writes `string` in full, retrying on partial writes. Bounded by
-    # `WRITE_TIMEOUT` so a slow client can't pin the writing thread.
-    #
-    # @param socket [TCPSocket] the socket to write to
-    # @param string [String] the data to write
-    # @return [void]
-    # @raise [WriteError] if the socket is not writable within the timeout or raises IOError
-    #
-    # @rbs (TCPSocket socket, String string) -> void
-    def self.socket_write(socket, string)
-      bytes = 0
-      byte_size = string.bytesize
-
-      while bytes < byte_size
-        begin
-          bytes += socket.write_nonblock(bytes.zero? ? string : string.byteslice(bytes..-1))
-        rescue IO::WaitWritable
-          raise WriteError unless socket.wait_writable(WRITE_TIMEOUT)
-          retry
-        rescue IOError
-          raise WriteError
-        end
-      end
-    end
-
     # @rbs @app: ^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped]
     # @rbs @server_port: Integer
+    # @rbs @write_timeout: Integer
     # @rbs @max_body_size: Integer?
     # @rbs @body_spool_threshold: Integer?
+    # @rbs @max_keepalive_requests: Integer
+    # @rbs @access_log_io: IO?
     # @rbs @on_error: ^(Hash[String, untyped]?, Exception) -> void | nil
     # @rbs @running: AtomicBoolean
 
-    # Creates a new Request handler.
+    # Creates a new Http1 handler.
     #
     # @param app [#call] the Rack application to dispatch complete requests to
     # @param server_port [Integer] port number used to populate SERVER_PORT in the Rack env
-    # @param client_options [Hash] client limits configuration
-    # @option client_options [Integer, nil] :max_body_size maximum request body size in bytes
-    # @option client_options [Integer, nil] :body_spool_threshold spool bodies larger than this to a tempfile
+    # @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
+    # @option connection_options [Integer, nil] :body_spool_threshold spool bodies larger than this to a tempfile
+    # @param http1_options [Hash] HTTP/1.1-specific settings
+    # @option http1_options [Integer] :max_keepalive_requests maximum requests per HTTP/1.1 keep-alive connection
+    # @param access_log_io [IO, nil] IO to write Common Log Format access entries to, or nil to disable
     # @param on_error [#call, nil] callback invoked with (env, exception) when the Rack app raises
     # @return [void]
     #
-    # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, Integer server_port, ?client_options: Hash[Symbol, untyped], ?on_error: ^(Hash[String, untyped]?, Exception) -> void | nil) -> void
-    def initialize(app, server_port, client_options: {}, on_error: nil)
+    # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, Integer server_port, ?connection_options: Hash[Symbol, untyped], ?http1_options: Hash[Symbol, untyped], ?access_log_io: IO?, ?on_error: ^(Hash[String, untyped]?, Exception) -> void | nil) -> void
+    def initialize(app, server_port, connection_options: {}, http1_options: {}, access_log_io: nil, on_error: nil)
       @app = app
       @server_port = server_port
-      @max_body_size = client_options[:max_body_size]
-      @body_spool_threshold = client_options[:body_spool_threshold]
+      @write_timeout = connection_options[:write_timeout] || Http::WRITE_TIMEOUT
+      @max_body_size = connection_options[:max_body_size]
+      @body_spool_threshold = connection_options[:body_spool_threshold]
+      @max_keepalive_requests = http1_options[:max_keepalive_requests] || MAX_KEEPALIVE_REQUESTS
+      @access_log_io = access_log_io
       @on_error = on_error
       @running = AtomicBoolean.new(true)
     end
 
+    # Instance-level wrapper around {Http.socket_write} that applies the
+    # configured `write_timeout`.
+    #
+    # @param socket [TCPSocket] the socket to write to
+    # @param string [String] the data to write
+    # @return [void]
+    # @raise [Http::WriteError] if the socket is not writable within the timeout or raises IOError
+    #
+    # @rbs (TCPSocket socket, String string) -> void
+    def socket_write(socket, string)
+      Http.socket_write(socket, string, timeout: @write_timeout)
+    end
+
     # Signals eager keep-alive loops to stop processing further requests on
     # their connections. In-flight requests complete normally.
     #
@@ -202,6 +230,9 @@ module Raptor
       if !parser.finished?
         fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, 0, remote_addr, url_scheme, persisted: false)
         return
+      elsif Http1.request_smuggling?(env)
+        reject_malformed(socket)
+        return
       elsif parser.has_body?
         if @max_body_size && parser.content_length > @max_body_size
           reject_oversized(socket)
@@ -211,13 +242,16 @@ module Raptor
         body = buffer.byteslice(nread..-1) || ""
 
         if env[HTTP_TRANSFER_ENCODING]&.include?(TRANSFER_ENCODING_CHUNKED)
-          body, chunked_state = Request.decode_chunked(body, @max_body_size)
+          body, chunked_state = Http1.decode_chunked(body, @max_body_size)
           case chunked_state
           when :complete
             env.delete(HTTP_TRANSFER_ENCODING)
           when :too_large
             reject_oversized(socket)
             return
+          when :malformed
+            reject_malformed(socket)
+            return
           else
             fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, 0, remote_addr, url_scheme, persisted: false)
             return
@@ -263,13 +297,15 @@ module Raptor
         parse_data[:parse_count] += 1
 
         message = if parser.finished?
-          if parser.has_body?
+          if Raptor::Http1.request_smuggling?(env)
+            data.merge(env: env, body: nil, parse_data: parse_data, complete: true, malformed: true)
+          elsif parser.has_body?
             body_buffer = data[:buffer].byteslice(nread..-1) || ""
 
             if max_body_size && parser.content_length > max_body_size
               data.merge(env: env, body: nil, parse_data: parse_data, complete: true, too_large: true)
             elsif env[HTTP_TRANSFER_ENCODING]&.include?(TRANSFER_ENCODING_CHUNKED)
-              decoded_body, chunked_state = Raptor::Request.decode_chunked(body_buffer, max_body_size)
+              decoded_body, chunked_state = Raptor::Http1.decode_chunked(body_buffer, max_body_size)
 
               case chunked_state
               when :complete
@@ -277,6 +313,8 @@ module Raptor
                 data.merge(env: env, body: decoded_body, parse_data: parse_data, complete: true)
               when :too_large
                 data.merge(env: env, body: nil, parse_data: parse_data, complete: true, too_large: true)
+              when :malformed
+                data.merge(env: env, body: nil, parse_data: parse_data, complete: true, malformed: true)
               else
                 data.merge(env: env, parse_data: parse_data)
               end
@@ -320,6 +358,7 @@ module Raptor
       end
 
       unless parsed_request[:complete]
+        parsed_request = send_continue_if_expected(parsed_request, reactor)
         reactor.update_state(parsed_request)
       else
         socket = reactor.remove(parsed_request[:id])
@@ -346,6 +385,41 @@ module Raptor
 
     private
 
+    # Returns true if the request expects a 100 Continue response per
+    # RFC 7231 section 5.1.1.
+    #
+    # @param env [Hash] the parsed Rack environment (possibly incomplete)
+    # @return [Boolean]
+    #
+    # @rbs (Hash[String, untyped] env) -> bool
+    def expects_100_continue?(env)
+      (env[Rack::SERVER_PROTOCOL] == HTTP_11) && env[HTTP_EXPECT]&.casecmp?(EXPECT_100_CONTINUE)
+    end
+
+    # Sends an HTTP 100 Continue response when an HTTP/1.1 client requested
+    # `Expect: 100-continue` and the request body has not yet been received.
+    #
+    # Returns the state hash with `:continued` set when the response has been
+    # written. A write failure is silently ignored.
+    #
+    # @param state [Hash] the partially-parsed connection state
+    # @param reactor [Reactor] the reactor holding the connection's socket
+    # @return [Hash] the state, with `:continued` set if 100 was written
+    #
+    # @rbs (Hash[Symbol, untyped] state, Reactor reactor) -> Hash[Symbol, untyped]
+    def send_continue_if_expected(state, reactor)
+      return state if state[:continued]
+
+      env = state[:env]
+      return state unless env && expects_100_continue?(env)
+
+      socket = reactor.socket_for(state[:id])
+      return state unless socket
+
+      socket_write(socket, CONTINUE_RESPONSE) rescue nil
+      state.merge(continued: true)
+    end
+
     # Processes a client connection by handling the current request and,
     # if keep-alive, eagerly reading subsequent requests inline.
     #
@@ -400,10 +474,12 @@ module Raptor
           hijacked = headers.is_a?(Hash) && !!headers[Rack::RACK_HIJACK]
           streaming = body.respond_to?(:call) && !body.respond_to?(:each)
           keep_alive = (hijacked || streaming) ? false : keep_alive?(rack_env, request_count)
+          response_size = response_size(headers, body) unless hijacked
           response_started = true
           write_response(socket, rack_env, status, headers, body, keep_alive: keep_alive)
         end
 
+        write_access_log(rack_env, status, response_size, remote_addr) if @access_log_io && !hijacked
         call_response_finished(rack_env, status, headers, nil)
         keep_alive && !hijacked
       rescue => error
@@ -549,6 +625,9 @@ module Raptor
     #
     # @rbs (TCPSocket socket, Integer id, String buffer, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, Reactor reactor, Integer request_count, String remote_addr, String url_scheme, persisted: bool) -> void
     def fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, request_count, remote_addr, url_scheme, persisted: true)
+      continued = expects_100_continue?(env)
+      socket_write(socket, CONTINUE_RESPONSE) rescue nil if continued
+
       reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
       state = {
         id: id,
@@ -560,6 +639,7 @@ module Raptor
         url_scheme: url_scheme
       }
       state[:persisted] = true if persisted
+      state[:continued] = true if continued
       reactor.update_state(Ractor.make_shareable(state))
     end
 
@@ -603,7 +683,6 @@ module Raptor
     # @rbs (Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, TCPSocket socket, ?remote_addr: String, ?url_scheme: String) -> Hash[String, untyped]
     def build_rack_env(env, parse_data, body, socket, remote_addr: Server::DEFAULT_REMOTE_ADDR, url_scheme: Server::HTTP_SCHEME)
       env[Rack::RACK_VERSION] = Rack::VERSION
-      env[Rack::RACK_URL_SCHEME] = url_scheme
       env[Rack::RACK_INPUT] = build_rack_input(body)
       env[Rack::RACK_ERRORS] = $stderr
       env[Rack::RACK_RESPONSE_FINISHED] = []
@@ -625,10 +704,16 @@ module Raptor
       env[Rack::QUERY_STRING] = "" unless env.key?(Rack::QUERY_STRING)
 
       if (content_length = parse_data[:content_length]).positive?
-        env["CONTENT_LENGTH"] = content_length.to_s
+        env[Http::CONTENT_LENGTH] = content_length.to_s
       end
 
-      env["REMOTE_ADDR"] = remote_addr
+      env[Http::REMOTE_ADDR] = remote_addr
+      env[Http::SERVER_SOFTWARE] = Http::SERVER_SOFTWARE_VALUE
+      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
+      default_port = behind_tls_proxy ? "443" : @server_port.to_s
 
       http_host = env[Rack::HTTP_HOST]
       if http_host
@@ -639,10 +724,10 @@ module Raptor
           host, port = http_host.split(":", 2)
         end
         env[Rack::SERVER_NAME] ||= host
-        env[Rack::SERVER_PORT] ||= port || @server_port.to_s
+        env[Rack::SERVER_PORT] ||= port || default_port
       else
         env[Rack::SERVER_NAME] ||= Server::DEFAULT_SERVER_NAME
-        env[Rack::SERVER_PORT] ||= @server_port.to_s
+        env[Rack::SERVER_PORT] ||= default_port
       end
 
       env
@@ -668,6 +753,21 @@ module Raptor
       end
     end
 
+    # Returns true when an upstream proxy signals that it terminated TLS for
+    # this request via `X-Forwarded-Proto`, `X-Forwarded-Scheme`, or
+    # `X-Forwarded-Ssl`. Only the first comma-separated value is consulted.
+    #
+    # @param env [Hash] the Rack environment
+    # @return [Boolean]
+    #
+    # @rbs (Hash[String, untyped] env) -> bool
+    def forwarded_https?(env)
+      proto = env["HTTP_X_FORWARDED_PROTO"] || env["HTTP_X_FORWARDED_SCHEME"]
+      return true if proto && proto.split(",").first&.strip&.casecmp?(Server::HTTPS_SCHEME)
+
+      env["HTTP_X_FORWARDED_SSL"]&.casecmp?("on") || false
+    end
+
     # Determines whether the connection should be kept alive after the response.
     #
     # Returns false if the request limit has been reached. For HTTP/1.1, keep-alive
@@ -680,7 +780,7 @@ module Raptor
     #
     # @rbs (Hash[String, untyped] env, Integer request_count) -> bool
     def keep_alive?(env, request_count)
-      return false if request_count >= MAX_KEEPALIVE_REQUESTS
+      return false if request_count >= @max_keepalive_requests
 
       connection_header = env[HTTP_CONNECTION]
 
@@ -716,7 +816,7 @@ module Raptor
       end
       response << "\r\n"
 
-      Request.socket_write(socket, response)
+      socket_write(socket, response)
     end
 
     # Writes a complete HTTP response to the socket.
@@ -849,7 +949,7 @@ module Raptor
     def write_hijacked_response(socket, response, headers, response_hijack)
       response << format_headers(headers)
       response << "\r\n"
-      Request.socket_write(socket, response)
+      socket_write(socket, response)
       uncork_socket(socket)
       response_hijack.call(socket)
     end
@@ -874,7 +974,7 @@ module Raptor
 
       response << format_headers(headers)
       response << "\r\n"
-      Request.socket_write(socket, response)
+      socket_write(socket, response)
     end
 
     # Writes a complete response with a body.
@@ -896,7 +996,7 @@ module Raptor
       if body.respond_to?(:call)
         response << format_headers(headers)
         response << "\r\n"
-        Request.socket_write(socket, response)
+        socket_write(socket, response)
         uncork_socket(socket)
         body.call(socket)
         return
@@ -933,7 +1033,7 @@ module Raptor
         raise TypeError, "body must respond to each, to_ary, or to_path"
       end
 
-      Request.socket_write(socket, "0\r\n\r\n") if use_chunked
+      socket_write(socket, "0\r\n\r\n") if use_chunked
     end
 
     # Calculates content length from an array or file body without consuming it.
@@ -947,7 +1047,7 @@ module Raptor
     def calculate_content_length(body)
       if body.respond_to?(:to_ary)
         array = body.to_ary
-        return nil unless array.is_a?(Array)
+        return unless array.is_a?(Array)
 
         array.sum { |chunk| chunk.is_a?(String) ? chunk.bytesize : 0 }
       elsif body.respond_to?(:to_path) && (path = body.to_path) && File.readable?(path)
@@ -973,15 +1073,15 @@ module Raptor
     def write_file_body(socket, response, path, content_length, use_chunked)
       File.open(path, "rb") do |file|
         if use_chunked
-          Request.socket_write(socket, response)
+          socket_write(socket, response)
           while (chunk = file.read(FILE_CHUNK_SIZE))
-            Request.socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
+            socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
           end
         elsif content_length && content_length < BODY_BUFFER_THRESHOLD
           response << file.read(content_length)
-          Request.socket_write(socket, response)
+          socket_write(socket, response)
         else
-          Request.socket_write(socket, response)
+          socket_write(socket, response)
           IO.copy_stream(file, socket)
         end
       end
@@ -1024,12 +1124,12 @@ module Raptor
 
       if use_chunked
         response << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
-        Request.socket_write(socket, response)
+        socket_write(socket, response)
       elsif chunk.bytesize < BODY_BUFFER_THRESHOLD
-        Request.socket_write(socket, response << chunk)
+        socket_write(socket, response << chunk)
       else
-        Request.socket_write(socket, response)
-        Request.socket_write(socket, chunk)
+        socket_write(socket, response)
+        socket_write(socket, chunk)
       end
     end
 
@@ -1045,13 +1145,13 @@ module Raptor
     # @rbs (TCPSocket socket, String response, Array[String] body_array, bool use_chunked) -> void
     def write_multiple_chunks(socket, response, body_array, use_chunked)
       if use_chunked
-        Request.socket_write(socket, response)
+        socket_write(socket, response)
         body_array.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
           next if chunk.empty?
 
-          Request.socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
+          socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
         end
       else
         body_array.each do |chunk|
@@ -1059,7 +1159,7 @@ module Raptor
 
           response << chunk
         end
-        Request.socket_write(socket, response)
+        socket_write(socket, response)
       end
     end
 
@@ -1075,13 +1175,13 @@ module Raptor
     # @rbs (TCPSocket socket, String response, untyped body, bool use_chunked) -> void
     def write_enumerable_body(socket, response, body, use_chunked)
       if use_chunked
-        Request.socket_write(socket, response)
+        socket_write(socket, response)
         body.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
           next if chunk.empty?
 
-          Request.socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
+          socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
         end
       else
         body.each do |chunk|
@@ -1089,7 +1189,7 @@ module Raptor
 
           response << chunk
         end
-        Request.socket_write(socket, response)
+        socket_write(socket, response)
       end
     end
 
@@ -1127,16 +1227,10 @@ module Raptor
       headers.each do |name, value|
         next if illegal_header_key?(name)
 
-        if value.is_a?(Array)
-          value.each do |header_value|
-            next if illegal_header_value?(header_value.to_s)
-
-            result << "#{name}: #{header_value}\r\n"
-          end
-        else
-          next if illegal_header_value?(value.to_s)
+        Array(value).flat_map { |entry| entry.to_s.split("\n") }.each do |header_value|
+          next if illegal_header_value?(header_value)
 
-          result << "#{name}: #{value}\r\n"
+          result << "#{name}: #{header_value}\r\n"
         end
       end
       result
@@ -1162,6 +1256,33 @@ module Raptor
       end
     end
 
+    # Instance-level wrapper around {Http.write_access_log} that routes to
+    # the configured `@access_log_io`.
+    #
+    # @param env [Hash] the Rack environment
+    # @param status [Integer] the response status code
+    # @param size [String] the response body size in bytes, or `-` if unknown
+    # @param remote_addr [String] the client IP address
+    # @return [void]
+    #
+    # @rbs (Hash[String, untyped] env, Integer status, String size, String remote_addr) -> void
+    def write_access_log(env, status, size, remote_addr)
+      Http.write_access_log(@access_log_io, env, status, size, remote_addr)
+    end
+
+    # Returns the response body size as a String for the access log, taken
+    # from the `content-length` header when set, computed from the body
+    # otherwise, or `-` when the size cannot be determined upfront.
+    #
+    # @param headers [Hash] the response headers
+    # @param body [Object] the response body
+    # @return [String]
+    #
+    # @rbs (Hash[String, String | Array[String]] headers, untyped body) -> String
+    def response_size(headers, body)
+      headers[Rack::CONTENT_LENGTH] || calculate_content_length(body)&.to_s || "-"
+    end
+
     if Socket.const_defined?(:TCP_CORK)
       # Enables TCP_CORK on the socket to batch outgoing packets into fewer segments.
       #