puma 5.0.4-java → 5.2.2-java

data/lib/puma/minissl.rb

@@ -73,7 +73,6 @@ module Puma
 
       def engine_read_all
         output = @engine.read
-        raise SSLError.exception "HTTP connection?" if bad_tlsv1_3?
         while output and additional_output = @engine.read
           output << additional_output
         end
@@ -100,6 +99,7 @@ module Puma
             # ourselves.
             raise IO::EAGAINWaitReadable
           elsif data.nil?
+            raise SSLError.exception "HTTP connection?" if bad_tlsv1_3?
             return nil
           end
 
@@ -117,22 +117,23 @@ module Puma
       def write(data)
         return 0 if data.empty?
 
-        need = data.bytesize
+        data_size = data.bytesize
+        need = data_size
 
         while true
           wrote = @engine.write data
-          enc = @engine.extract
 
-          while enc
-            @socket.write enc
-            enc = @engine.extract
+          enc_wr = ''.dup
+          while (enc = @engine.extract)
+            enc_wr << enc
           end
+          @socket.write enc_wr unless enc_wr.empty?
 
           need -= wrote
 
-          return data.bytesize if need == 0
+          return data_size if need == 0
 
-          data = data[wrote..-1]
+          data = data.byteslice(wrote..-1)
         end
       end
 
@@ -245,6 +246,7 @@ module Puma
         attr_reader :cert
         attr_reader :ca
         attr_accessor :ssl_cipher_filter
+        attr_accessor :verification_flags
 
         def key=(key)
           raise ArgumentError, "No such key file '#{key}'" unless File.exist? key
@@ -287,33 +289,58 @@ module Puma
     VERIFY_PEER = 1
     VERIFY_FAIL_IF_NO_PEER_CERT = 2
 
+    # https://github.com/openssl/openssl/blob/master/include/openssl/x509_vfy.h.in
+    # /* Certificate verify flags */
+    VERIFICATION_FLAGS = {
+      "USE_CHECK_TIME"       => 0x2,
+      "CRL_CHECK"            => 0x4,
+      "CRL_CHECK_ALL"        => 0x8,
+      "IGNORE_CRITICAL"      => 0x10,
+      "X509_STRICT"          => 0x20,
+      "ALLOW_PROXY_CERTS"    => 0x40,
+      "POLICY_CHECK"         => 0x80,
+      "EXPLICIT_POLICY"      => 0x100,
+      "INHIBIT_ANY"          => 0x200,
+      "INHIBIT_MAP"          => 0x400,
+      "NOTIFY_POLICY"        => 0x800,
+      "EXTENDED_CRL_SUPPORT" => 0x1000,
+      "USE_DELTAS"           => 0x2000,
+      "CHECK_SS_SIGNATURE"   => 0x4000,
+      "TRUSTED_FIRST"        => 0x8000,
+      "SUITEB_128_LOS_ONLY"  => 0x10000,
+      "SUITEB_192_LOS"       => 0x20000,
+      "SUITEB_128_LOS"       => 0x30000,
+      "PARTIAL_CHAIN"        => 0x80000,
+      "NO_ALT_CHAINS"        => 0x100000,
+      "NO_CHECK_TIME"        => 0x200000
+    }.freeze
+
     class Server
       def initialize(socket, ctx)
         @socket = socket
         @ctx = ctx
-      end
-
-      # @!attribute [r] to_io
-      def to_io
-        @socket
+        @eng_ctx = IS_JRUBY ? @ctx : SSLContext.new(ctx)
       end
 
       def accept
         @ctx.check
         io = @socket.accept
-        engine = Engine.server @ctx
-
+        engine = Engine.server @eng_ctx
         Socket.new io, engine
       end
 
       def accept_nonblock
         @ctx.check
         io = @socket.accept_nonblock
-        engine = Engine.server @ctx
-
+        engine = Engine.server @eng_ctx
         Socket.new io, engine
       end
 
+      # @!attribute [r] to_io
+      def to_io
+        @socket
+      end
+
       # @!attribute [r] addr
       # @version 5.0.0
       def addr
@@ -323,6 +350,10 @@ module Puma
       def close
         @socket.close unless @socket.closed?       # closed? call is for Windows
       end
+
+      def closed?
+        @socket.closed?
+      end
     end
   end
 end

data/lib/puma/minissl/context_builder.rb

@@ -62,6 +62,12 @@ module Puma
                             end
         end
 
+        if params['verification_flags']
+          ctx.verification_flags = params['verification_flags'].split(',').
+            map { |flag| MiniSSL::VERIFICATION_FLAGS.fetch(flag) }.
+            inject { |sum, flag| sum ? sum | flag : flag }
+        end
+
         ctx
       end
 

data/lib/puma/null_io.rb

@@ -9,6 +9,10 @@ module Puma
       nil
     end
 
+    def string
+      ""
+    end
+
     def each
     end
 
@@ -32,6 +36,10 @@ module Puma
       true
     end
 
+    def sync
+      true
+    end
+
     def sync=(v)
     end
 
@@ -40,5 +48,9 @@ module Puma
 
     def write(*ary)
     end
+
+    def flush
+      self
+    end
   end
 end

data/lib/puma/reactor.rb

@@ -3,6 +3,8 @@
 require 'puma/queue_close' unless ::Queue.instance_methods.include? :close
 
 module Puma
+  class UnsupportedBackend < StandardError; end
+
   # Monitors a collection of IO objects, calling a block whenever
   # any monitored object either receives data or times out, or when the Reactor shuts down.
   #
@@ -18,9 +20,12 @@ module Puma
     # Create a new Reactor to monitor IO objects added by #add.
     # The provided block will be invoked when an IO has data available to read,
     # its timeout elapses, or when the Reactor shuts down.
-    def initialize(&block)
+    def initialize(backend, &block)
       require 'nio'
-      @selector = NIO::Selector.new
+      unless backend == :auto || NIO::Selector.backends.include?(backend)
+        raise "unsupported IO selector backend: #{backend} (available backends: #{NIO::Selector.backends.join(', ')})"
+      end
+      @selector = backend == :auto ? NIO::Selector.new : NIO::Selector.new(backend)
       @input = Queue.new
       @timeouts = []
       @block = block
@@ -38,11 +43,11 @@ module Puma
       end
     end
 
-    # Add a new IO object to monitor.
+    # Add a new client to monitor.
     # The object must respond to #timeout and #timeout_at.
     # Returns false if the reactor is already shut down.
-    def add(io)
-      @input << io
+    def add(client)
+      @input << client
       @selector.wakeup
       true
     rescue ClosedQueueError
@@ -92,17 +97,19 @@ module Puma
     end
 
     # Start monitoring the object.
-    def register(io)
-      @selector.register(io, :r).value = io
-      @timeouts << io
+    def register(client)
+      @selector.register(client.to_io, :r).value = client
+      @timeouts << client
+    rescue ArgumentError
+      # unreadable clients raise error when processed by NIO
     end
 
     # 'Wake up' a monitored object by calling the provided block.
     # Stop monitoring the object if the block returns `true`.
-    def wakeup!(io)
-      if @block.call(io)
-        @selector.deregister(io)
-        @timeouts.delete(io)
+    def wakeup!(client)
+      if @block.call client
+        @selector.deregister client.to_io
+        @timeouts.delete client
       end
     end
   end

data/lib/puma/request.rb

@@ -30,7 +30,7 @@ module Puma
     #
     def handle_request(client, lines)
       env = client.env
-      io = client.io
+      io  = client.io   # io may be a MiniSSL::Socket
 
       return false if closed_socket?(io)
 
@@ -282,13 +282,20 @@ module Puma
     end
     # private :normalize_env
 
+    # @param header_key [#to_s]
+    # @return [Boolean]
+    #
+    def illegal_header_key?(header_key)
+      !!(ILLEGAL_HEADER_KEY_REGEX =~ header_key.to_s)
+    end
+
     # @param header_value [#to_s]
     # @return [Boolean]
     #
-    def possible_header_injection?(header_value)
-      !!(HTTP_INJECTION_REGEX =~ header_value.to_s)
+    def illegal_header_value?(header_value)
+      !!(ILLEGAL_HEADER_VALUE_REGEX =~ header_value.to_s)
     end
-    private :possible_header_injection?
+    private :illegal_header_key?, :illegal_header_value?
 
     # Fixup any headers with `,` in the name to have `_` now. We emit
     # headers with `,` in them during the parse phase to avoid ambiguity
@@ -334,9 +341,11 @@ module Puma
     def str_early_hints(headers)
       eh_str = "HTTP/1.1 103 Early Hints\r\n".dup
       headers.each_pair do |k, vs|
+        next if illegal_header_key?(k)
+
         if vs.respond_to?(:to_s) && !vs.to_s.empty?
           vs.to_s.split(NEWLINE).each do |v|
-            next if possible_header_injection?(v)
+            next if illegal_header_value?(v)
             eh_str << "#{k}: #{v}\r\n"
           end
         else
@@ -399,9 +408,11 @@ module Puma
       res_info[:response_hijack] = nil
 
       headers.each do |k, vs|
+        next if illegal_header_key?(k)
+
         case k.downcase
         when CONTENT_LENGTH2
-          next if possible_header_injection?(vs)
+          next if illegal_header_value?(vs)
           res_info[:content_length] = vs
           next
         when TRANSFER_ENCODING
@@ -410,11 +421,13 @@ module Puma
         when HIJACK
           res_info[:response_hijack] = vs
           next
+        when BANNED_HEADER_KEY
+          next
         end
 
         if vs.respond_to?(:to_s) && !vs.to_s.empty?
           vs.to_s.split(NEWLINE).each do |v|
-            next if possible_header_injection?(v)
+            next if illegal_header_value?(v)
             lines.append k, colon, v, line_ending
           end
         else

data/lib/puma/runner.rb

@@ -55,11 +55,11 @@ module Puma
       app = Puma::App::Status.new @launcher, token
 
       control = Puma::Server.new app, @launcher.events,
-        { min_threads: 0, max_threads: 1 }
+        { min_threads: 0, max_threads: 1, queue_requests: false }
 
       control.binder.parse [str], self, 'Starting control server'
 
-      control.run
+      control.run thread_name: 'control'
       @control = control
     end
 
@@ -86,9 +86,16 @@ module Puma
       max_t = @options[:max_threads]
 
       log "Puma starting in #{mode} mode..."
-      log "* Version #{Puma::Const::PUMA_VERSION} (#{ruby_engine}), codename: #{Puma::Const::CODE_NAME}"
-      log "* Min threads: #{min_t}, max threads: #{max_t}"
-      log "* Environment: #{ENV['RACK_ENV']}"
+      log "* Puma version: #{Puma::Const::PUMA_VERSION} (#{ruby_engine}) (\"#{Puma::Const::CODE_NAME}\")"
+      log "*  Min threads: #{min_t}"
+      log "*  Max threads: #{max_t}"
+      log "*  Environment: #{ENV['RACK_ENV']}"
+
+      if mode == "cluster"
+        log "*   Master PID: #{Process.pid}"
+      else
+        log "*          PID: #{Process.pid}"
+      end
     end
 
     def redirected_io?
@@ -106,8 +113,8 @@ module Puma
         end
 
         STDOUT.reopen stdout, (append ? "a" : "w")
-        STDOUT.sync = true
         STDOUT.puts "=== puma startup: #{Time.now} ==="
+        STDOUT.flush unless STDOUT.sync
       end
 
       if stderr
@@ -116,8 +123,13 @@ module Puma
         end
 
         STDERR.reopen stderr, (append ? "a" : "w")
-        STDERR.sync = true
         STDERR.puts "=== puma startup: #{Time.now} ==="
+        STDERR.flush unless STDERR.sync
+      end
+
+      if @options[:mutate_stdout_and_stderr_to_sync_on_write]
+        STDOUT.sync = true
+        STDERR.sync = true
       end
     end
 

data/lib/puma/server.rb

@@ -84,12 +84,14 @@ module Puma
 
       @options = options
 
-      @early_hints        = options.fetch :early_hints, nil
-      @first_data_timeout = options.fetch :first_data_timeout, FIRST_DATA_TIMEOUT
-      @min_threads        = options.fetch :min_threads, 0
-      @max_threads        = options.fetch :max_threads , (Puma.mri? ? 5 : 16)
-      @persistent_timeout = options.fetch :persistent_timeout, PERSISTENT_TIMEOUT
-      @queue_requests     = options.fetch :queue_requests, true
+      @early_hints         = options.fetch :early_hints, nil
+      @first_data_timeout  = options.fetch :first_data_timeout, FIRST_DATA_TIMEOUT
+      @min_threads         = options.fetch :min_threads, 0
+      @max_threads         = options.fetch :max_threads , (Puma.mri? ? 5 : 16)
+      @persistent_timeout  = options.fetch :persistent_timeout, PERSISTENT_TIMEOUT
+      @queue_requests      = options.fetch :queue_requests, true
+      @max_fast_inline     = options.fetch :max_fast_inline, MAX_FAST_INLINE
+      @io_selector_backend = options.fetch :io_selector_backend, :auto
 
       temp = !!(@options[:environment] =~ /\A(development|test)\z/)
       @leak_stack_on_error = @options[:environment] ? temp : true
@@ -118,17 +120,13 @@ module Puma
       # :nodoc:
       # @version 5.0.0
       def tcp_cork_supported?
-        RbConfig::CONFIG['host_os'] =~ /linux/ &&
-          Socket.const_defined?(:IPPROTO_TCP) &&
-          Socket.const_defined?(:TCP_CORK)
+        Socket.const_defined?(:TCP_CORK) && Socket.const_defined?(:IPPROTO_TCP)
       end
 
       # :nodoc:
       # @version 5.0.0
       def closed_socket_supported?
-        RbConfig::CONFIG['host_os'] =~ /linux/ &&
-          Socket.const_defined?(:IPPROTO_TCP) &&
-          Socket.const_defined?(:TCP_INFO)
+        Socket.const_defined?(:TCP_INFO) && Socket.const_defined?(:IPPROTO_TCP)
       end
       private :tcp_cork_supported?
       private :closed_socket_supported?
@@ -136,6 +134,7 @@ module Puma
 
     # On Linux, use TCP_CORK to better control how the TCP stack
     # packetizes our stream. This improves both latency and throughput.
+    # socket parameter may be an MiniSSL::Socket, so use to_io
     #
     if tcp_cork_supported?
       UNPACK_TCP_STATE_FROM_TCP_INFO = "C".freeze
@@ -144,16 +143,18 @@ module Puma
       # 3 == TCP_CORK
       # 1/0 == turn on/off
       def cork_socket(socket)
+        skt = socket.to_io
         begin
-          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_CORK, 1) if socket.kind_of? TCPSocket
+          skt.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_CORK, 1) if skt.kind_of? TCPSocket
         rescue IOError, SystemCallError
           Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
         end
       end
 
       def uncork_socket(socket)
+        skt = socket.to_io
         begin
-          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_CORK, 0) if socket.kind_of? TCPSocket
+          skt.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_CORK, 0) if skt.kind_of? TCPSocket
         rescue IOError, SystemCallError
           Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
         end
@@ -218,7 +219,7 @@ module Puma
     # up in the background to handle requests. Otherwise requests
     # are handled synchronously.
     #
-    def run(background=true)
+    def run(background=true, thread_name: 'server')
       BasicSocket.do_not_reverse_lookup = true
 
       @events.fire :state, :booting
@@ -236,7 +237,7 @@ module Puma
       @thread_pool.clean_thread_locals = @options[:clean_thread_locals]
 
       if @queue_requests
-        @reactor = Reactor.new(&method(:reactor_wakeup))
+        @reactor = Reactor.new(@io_selector_backend, &method(:reactor_wakeup))
         @reactor.run
       end
 
@@ -254,7 +255,7 @@ module Puma
 
       if background
         @thread = Thread.new do
-          Puma.set_thread_name "server"
+          Puma.set_thread_name thread_name
           handle_servers
         end
         return @thread
@@ -442,11 +443,11 @@ module Puma
 
             check_for_more_data = @status == :run
 
-            if requests >= MAX_FAST_INLINE
+            if requests >= @max_fast_inline
               # This will mean that reset will only try to use the data it already
               # has buffered and won't try to read more data. What this means is that
               # every client, independent of their request speed, gets treated like a slow
-              # one once every MAX_FAST_INLINE requests.
+              # one once every max_fast_inline requests.
               check_for_more_data = false
             end
 
@@ -493,62 +494,6 @@ module Puma
 
     # :nocov:
 
-    # Given the request +env+ from +client+ and the partial body +body+
-    # plus a potential Content-Length value +cl+, finish reading
-    # the body and return it.
-    #
-    # If the body is larger than MAX_BODY, a Tempfile object is used
-    # for the body, otherwise a StringIO is used.
-    # @deprecated 6.0.0
-    #
-    def read_body(env, client, body, cl)
-      content_length = cl.to_i
-
-      remain = content_length - body.bytesize
-
-      return StringIO.new(body) if remain <= 0
-
-      # Use a Tempfile if there is a lot of data left
-      if remain > MAX_BODY
-        stream = Tempfile.new(Const::PUMA_TMP_BASE)
-        stream.binmode
-      else
-        # The body[0,0] trick is to get an empty string in the same
-        # encoding as body.
-        stream = StringIO.new body[0,0]
-      end
-
-      stream.write body
-
-      # Read an odd sized chunk so we can read even sized ones
-      # after this
-      chunk = client.readpartial(remain % CHUNK_SIZE)
-
-      # No chunk means a closed socket
-      unless chunk
-        stream.close
-        return nil
-      end
-
-      remain -= stream.write(chunk)
-
-      # Read the rest of the chunks
-      while remain > 0
-        chunk = client.readpartial(CHUNK_SIZE)
-        unless chunk
-          stream.close
-          return nil
-        end
-
-        remain -= stream.write(chunk)
-      end
-
-      stream.rewind
-
-      return stream
-    end
-    # :nocov:
-
     # Handle various error types thrown by Client I/O operations.
     def client_error(e, client)
       # Swallow, do not log