puma 3.12.0 → 5.3.1

data/lib/puma/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class IO
   # We need to use this for a jruby work around on both 1.8 and 1.9.
   # So this either creates the constant (on 1.8), or harmlessly
@@ -7,8 +9,8 @@ class IO
 end
 
 require 'puma/detect'
-require 'puma/delegation'
 require 'tempfile'
+require 'forwardable'
 
 if Puma::IS_JRUBY
   # We have to work around some OpenSSL buffer/io-readiness bugs
@@ -22,19 +24,24 @@ module Puma
   class ConnectionError < RuntimeError; end
 
   # An instance of this class represents a unique request from a client.
-  # For example a web request from a browser or from CURL. This
+  # For example, this could be a web request from a browser or from CURL.
   #
   # An instance of `Puma::Client` can be used as if it were an IO object
-  # for example it is passed into `IO.select` inside of the `Puma::Reactor`.
-  # This is accomplished by the `to_io` method which gets called on any
-  # non-IO objects being used with the IO api such as `IO.select.
+  # by the reactor. The reactor is expected to call `#to_io`
+  # on any non-IO objects it polls. For example, nio4r internally calls
+  # `IO::try_convert` (which may call `#to_io`) when a new socket is
+  # registered.
   #
   # Instances of this class are responsible for knowing if
   # the header and body are fully buffered via the `try_to_finish` method.
   # They can be used to "time out" a response via the `timeout_at` reader.
   class Client
+    # The object used for a request with no body. All requests with
+    # no body share this one object since it has no state.
+    EmptyBody = NullIO.new
+
     include Puma::Const
-    extend  Puma::Delegation
+    extend Forwardable
 
     def initialize(io, env=nil)
       @io = io
@@ -52,6 +59,7 @@ module Puma
       @ready = false
 
       @body = nil
+      @body_read_start = nil
       @buffer = nil
       @tempfile = nil
 
@@ -62,6 +70,10 @@ module Puma
 
       @peerip = nil
       @remote_addr_header = nil
+
+      @body_remain = 0
+
+      @in_last_chunk = false
     end
 
     attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
@@ -71,8 +83,15 @@ module Puma
 
     attr_accessor :remote_addr_header
 
-    forward :closed?, :@io
+    def_delegators :@io, :closed?
 
+    # Test to see if io meets a bare minimum of functioning, @to_io needs to be
+    # used for MiniSSL::Socket
+    def io_ok?
+      @to_io.is_a?(::BasicSocket) && !closed?
+    end
+
+    # @!attribute [r] inspect
     def inspect
       "#<Puma::Client:0x#{object_id.to_s(16)} @ready=#{@ready.inspect}>"
     end
@@ -84,12 +103,18 @@ module Puma
       env[HIJACK_IO] ||= @io
     end
 
+    # @!attribute [r] in_data_phase
     def in_data_phase
       !@read_header
     end
 
     def set_timeout(val)
-      @timeout_at = Time.now + val
+      @timeout_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + val
+    end
+
+    # Number of seconds until the timeout elapses.
+    def timeout
+      [@timeout_at - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max
     end
 
     def reset(fast_check=true)
@@ -100,6 +125,9 @@ module Puma
       @tempfile = nil
       @parsed_bytes = 0
       @ready = false
+      @body_remain = 0
+      @peerip = nil if @remote_addr_header
+      @in_last_chunk = false
 
       if @buffer
         @parsed_bytes = @parser.execute(@env, @buffer, @parsed_bytes)
@@ -112,9 +140,16 @@ module Puma
         end
 
         return false
-      elsif fast_check &&
-            IO.select([@to_io], nil, nil, FAST_TRACK_KA_TIMEOUT)
-        return try_to_finish
+      else
+        begin
+          if fast_check &&
+              IO.select([@to_io], nil, nil, FAST_TRACK_KA_TIMEOUT)
+            return try_to_finish
+          end
+        rescue IOError
+          # swallow it
+        end
+
       end
     end
 
@@ -126,108 +161,93 @@ module Puma
       end
     end
 
-    # The object used for a request with no body. All requests with
-    # no body share this one object since it has no state.
-    EmptyBody = NullIO.new
-
-    def setup_chunked_body(body)
-      @chunked_body = true
-      @partial_part_left = 0
-      @prev_chunk = ""
-
-      @body = Tempfile.new(Const::PUMA_TMP_BASE)
-      @body.binmode
-      @tempfile = @body
+    def try_to_finish
+      return read_body unless @read_header
 
-      return decode_chunk(body)
-    end
+      begin
+        data = @io.read_nonblock(CHUNK_SIZE)
+      rescue IO::WaitReadable
+        return false
+      rescue EOFError
+        # Swallow error, don't log
+      rescue SystemCallError, IOError
+        raise ConnectionError, "Connection error detected during read"
+      end
 
-    def decode_chunk(chunk)
-      if @partial_part_left > 0
-        if @partial_part_left <= chunk.size
-          @body << chunk[0..(@partial_part_left-3)] # skip the \r\n
-          chunk = chunk[@partial_part_left..-1]
-        else
-          @body << chunk
-          @partial_part_left -= chunk.size
-          return false
-        end
+      # No data means a closed socket
+      unless data
+        @buffer = nil
+        set_ready
+        raise EOFError
       end
 
-      if @prev_chunk.empty?
-        io = StringIO.new(chunk)
+      if @buffer
+        @buffer << data
       else
-        io = StringIO.new(@prev_chunk+chunk)
-        @prev_chunk = ""
+        @buffer = data
       end
 
-      while !io.eof?
-        line = io.gets
-        if line.end_with?("\r\n")
-          len = line.strip.to_i(16)
-          if len == 0
-            @body.rewind
-            rest = io.read
-            @buffer = rest.empty? ? nil : rest
-            @requests_served += 1
-            @ready = true
-            return true
-          end
-
-          len += 2
+      @parsed_bytes = @parser.execute(@env, @buffer, @parsed_bytes)
 
-          part = io.read(len)
+      if @parser.finished?
+        return setup_body
+      elsif @parsed_bytes >= MAX_HEADER
+        raise HttpParserError,
+          "HEADER is longer than allowed, aborting client early."
+      end
 
-          unless part
-            @partial_part_left = len
-            next
-          end
+      false
+    end
 
-          got = part.size
+    def eagerly_finish
+      return true if @ready
+      return false unless IO.select([@to_io], nil, nil, 0)
+      try_to_finish
+    end
 
-          case
-          when got == len
-            @body << part[0..-3] # to skip the ending \r\n
-          when got <= len - 2
-            @body << part
-            @partial_part_left = len - part.size
-          when got == len - 1 # edge where we get just \r but not \n
-            @body << part[0..-2]
-            @partial_part_left = len - part.size
-          end
-        else
-          @prev_chunk = line
-          return false
-        end
-      end
+    def finish(timeout)
+      return if @ready
+      IO.select([@to_io], nil, nil, timeout) || timeout! until try_to_finish
+    end
 
-      return false
+    def timeout!
+      write_error(408) if in_data_phase
+      raise ConnectionError
     end
 
-    def read_chunked_body
-      while true
-        begin
-          chunk = @io.read_nonblock(4096)
-        rescue Errno::EAGAIN
-          return false
-        rescue SystemCallError, IOError
-          raise ConnectionError, "Connection error detected during read"
-        end
+    def write_error(status_code)
+      begin
+        @io << ERROR_RESPONSE[status_code]
+      rescue StandardError
+      end
+    end
 
-        # No chunk means a closed socket
-        unless chunk
-          @body.close
-          @buffer = nil
-          @requests_served += 1
-          @ready = true
-          raise EOFError
-        end
+    def peerip
+      return @peerip if @peerip
 
-        return true if decode_chunk(chunk)
+      if @remote_addr_header
+        hdr = (@env[@remote_addr_header] || LOCALHOST_IP).split(/[\s,]/).first
+        @peerip = hdr
+        return hdr
       end
+
+      @peerip ||= @io.peeraddr.last
+    end
+
+    # Returns true if the persistent connection can be closed immediately
+    # without waiting for the configured idle/shutdown timeout.
+    # @version 5.0.0
+    #
+    def can_close?
+      # Allow connection to close if we're not in the middle of parsing a request.
+      @parsed_bytes == 0
     end
 
+    private
+
     def setup_body
+      @body_read_start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
       if @env[HTTP_EXPECT] == CONTINUE
         # TODO allow a hook here to check the headers before
         # going forward
@@ -241,8 +261,16 @@ module Puma
 
       te = @env[TRANSFER_ENCODING2]
 
-      if te && CHUNKED.casecmp(te) == 0
-        return setup_chunked_body(body)
+      if te
+        if te.include?(",")
+          te.split(",").each do |part|
+            if CHUNKED.casecmp(part.strip) == 0
+              return setup_chunked_body(body)
+            end
+          end
+        elsif CHUNKED.casecmp(te) == 0
+          return setup_chunked_body(body)
+        end
       end
 
       @chunked_body = false
@@ -252,8 +280,7 @@ module Puma
       unless cl
         @buffer = body.empty? ? nil : body
         @body = EmptyBody
-        @requests_served += 1
-        @ready = true
+        set_ready
         return true
       end
 
@@ -262,13 +289,13 @@ module Puma
       if remain <= 0
         @body = StringIO.new(body)
         @buffer = nil
-        @requests_served += 1
-        @ready = true
+        set_ready
         return true
       end
 
       if remain > MAX_BODY
         @body = Tempfile.new(Const::PUMA_TMP_BASE)
+        @body.unlink
         @body.binmode
         @tempfile = @body
       else
@@ -284,108 +311,6 @@ module Puma
       return false
     end
 
-    def try_to_finish
-      return read_body unless @read_header
-
-      begin
-        data = @io.read_nonblock(CHUNK_SIZE)
-      rescue Errno::EAGAIN
-        return false
-      rescue SystemCallError, IOError
-        raise ConnectionError, "Connection error detected during read"
-      end
-
-      # No data means a closed socket
-      unless data
-        @buffer = nil
-        @requests_served += 1
-        @ready = true
-        raise EOFError
-      end
-
-      if @buffer
-        @buffer << data
-      else
-        @buffer = data
-      end
-
-      @parsed_bytes = @parser.execute(@env, @buffer, @parsed_bytes)
-
-      if @parser.finished?
-        return setup_body
-      elsif @parsed_bytes >= MAX_HEADER
-        raise HttpParserError,
-          "HEADER is longer than allowed, aborting client early."
-      end
-
-      false
-    end
-
-    if IS_JRUBY
-      def jruby_start_try_to_finish
-        return read_body unless @read_header
-
-        begin
-          data = @io.sysread_nonblock(CHUNK_SIZE)
-        rescue OpenSSL::SSL::SSLError => e
-          return false if e.kind_of? IO::WaitReadable
-          raise e
-        end
-
-        # No data means a closed socket
-        unless data
-          @buffer = nil
-          @requests_served += 1
-          @ready = true
-          raise EOFError
-        end
-
-        if @buffer
-          @buffer << data
-        else
-          @buffer = data
-        end
-
-        @parsed_bytes = @parser.execute(@env, @buffer, @parsed_bytes)
-
-        if @parser.finished?
-          return setup_body
-        elsif @parsed_bytes >= MAX_HEADER
-          raise HttpParserError,
-            "HEADER is longer than allowed, aborting client early."
-        end
-
-        false
-      end
-
-      def eagerly_finish
-        return true if @ready
-
-        if @io.kind_of? OpenSSL::SSL::SSLSocket
-          return true if jruby_start_try_to_finish
-        end
-
-        return false unless IO.select([@to_io], nil, nil, 0)
-        try_to_finish
-      end
-
-    else
-
-      def eagerly_finish
-        return true if @ready
-        return false unless IO.select([@to_io], nil, nil, 0)
-        try_to_finish
-      end
-    end # IS_JRUBY
-
-    def finish
-      return true if @ready
-      until try_to_finish
-        IO.select([@to_io], nil, nil)
-      end
-      true
-    end
-
     def read_body
       if @chunked_body
         return read_chunked_body
@@ -403,7 +328,7 @@ module Puma
 
       begin
         chunk = @io.read_nonblock(want)
-      rescue Errno::EAGAIN
+      rescue IO::WaitReadable
         return false
       rescue SystemCallError, IOError
         raise ConnectionError, "Connection error detected during read"
@@ -413,8 +338,7 @@ module Puma
       unless chunk
         @body.close
         @buffer = nil
-        @requests_served += 1
-        @ready = true
+        set_ready
         raise EOFError
       end
 
@@ -423,8 +347,7 @@ module Puma
       if remain <= 0
         @body.rewind
         @buffer = nil
-        @requests_served += 1
-        @ready = true
+        set_ready
         return true
       end
 
@@ -433,37 +356,145 @@ module Puma
       false
     end
 
-    def write_400
-      begin
-        @io << ERROR_400_RESPONSE
-      rescue StandardError
+    def read_chunked_body
+      while true
+        begin
+          chunk = @io.read_nonblock(4096)
+        rescue IO::WaitReadable
+          return false
+        rescue SystemCallError, IOError
+          raise ConnectionError, "Connection error detected during read"
+        end
+
+        # No chunk means a closed socket
+        unless chunk
+          @body.close
+          @buffer = nil
+          set_ready
+          raise EOFError
+        end
+
+        if decode_chunk(chunk)
+          @env[CONTENT_LENGTH] = @chunked_content_length.to_s
+          return true
+        end
       end
     end
 
-    def write_408
-      begin
-        @io << ERROR_408_RESPONSE
-      rescue StandardError
+    def setup_chunked_body(body)
+      @chunked_body = true
+      @partial_part_left = 0
+      @prev_chunk = ""
+
+      @body = Tempfile.new(Const::PUMA_TMP_BASE)
+      @body.unlink
+      @body.binmode
+      @tempfile = @body
+      @chunked_content_length = 0
+
+      if decode_chunk(body)
+        @env[CONTENT_LENGTH] = @chunked_content_length.to_s
+        return true
       end
     end
 
-    def write_500
-      begin
-        @io << ERROR_500_RESPONSE
-      rescue StandardError
-      end
+    # @version 5.0.0
+    def write_chunk(str)
+      @chunked_content_length += @body.write(str)
     end
 
-    def peerip
-      return @peerip if @peerip
+    def decode_chunk(chunk)
+      if @partial_part_left > 0
+        if @partial_part_left <= chunk.size
+          if @partial_part_left > 2
+            write_chunk(chunk[0..(@partial_part_left-3)]) # skip the \r\n
+          end
+          chunk = chunk[@partial_part_left..-1]
+          @partial_part_left = 0
+        else
+          if @partial_part_left > 2
+            if @partial_part_left == chunk.size + 1
+              # Don't include the last \r
+              write_chunk(chunk[0..(@partial_part_left-3)])
+            else
+              # don't include the last \r\n
+              write_chunk(chunk)
+            end
+          end
+          @partial_part_left -= chunk.size
+          return false
+        end
+      end
 
-      if @remote_addr_header
-        hdr = (@env[@remote_addr_header] || LOCALHOST_ADDR).split(/[\s,]/).first
-        @peerip = hdr
-        return hdr
+      if @prev_chunk.empty?
+        io = StringIO.new(chunk)
+      else
+        io = StringIO.new(@prev_chunk+chunk)
+        @prev_chunk = ""
       end
 
-      @peerip ||= @io.peeraddr.last
+      while !io.eof?
+        line = io.gets
+        if line.end_with?("\r\n")
+          len = line.strip.to_i(16)
+          if len == 0
+            @in_last_chunk = true
+            @body.rewind
+            rest = io.read
+            last_crlf_size = "\r\n".bytesize
+            if rest.bytesize < last_crlf_size
+              @buffer = nil
+              @partial_part_left = last_crlf_size - rest.bytesize
+              return false
+            else
+              @buffer = rest[last_crlf_size..-1]
+              @buffer = nil if @buffer.empty?
+              set_ready
+              return true
+            end
+          end
+
+          len += 2
+
+          part = io.read(len)
+
+          unless part
+            @partial_part_left = len
+            next
+          end
+
+          got = part.size
+
+          case
+          when got == len
+            write_chunk(part[0..-3]) # to skip the ending \r\n
+          when got <= len - 2
+            write_chunk(part)
+            @partial_part_left = len - part.size
+          when got == len - 1 # edge where we get just \r but not \n
+            write_chunk(part[0..-2])
+            @partial_part_left = len - part.size
+          end
+        else
+          @prev_chunk = line
+          return false
+        end
+      end
+
+      if @in_last_chunk
+        set_ready
+        true
+      else
+        false
+      end
+    end
+
+    def set_ready
+      if @body_read_start
+        @env['puma.request_body_wait'] = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - @body_read_start
+      end
+      @requests_served += 1
+      @ready = true
     end
   end
 end