puma 7.2.2-java → 8.0.0-java

data/ext/puma_http11/org/jruby/puma/MiniSSL.java

@@ -383,41 +383,36 @@ public class MiniSSL extends RubyObject { // MiniSSL::Engine
       }
 
       MiniSSLBuffer inboundAppData = new MiniSSLBuffer(engine.getSession().getApplicationBufferSize());
-      int consumedTo;
-      do {
-        consumedTo = inboundNetData.position();
-        doOp(SSLOperation.UNWRAP, inboundNetData, inboundAppData);
-
-        HandshakeStatus handshakeStatus = engine.getHandshakeStatus();
-        boolean done = false;
-        while (!done) {
-          SSLEngineResult res;
-          switch (handshakeStatus) {
-            case NEED_WRAP:
-              res = doOp(SSLOperation.WRAP, inboundAppData, outboundNetData);
-              handshakeStatus = res.getHandshakeStatus();
-              break;
-            case NEED_UNWRAP:
-              res = doOp(SSLOperation.UNWRAP, inboundNetData, inboundAppData);
-              if (res.getStatus() == Status.BUFFER_UNDERFLOW) {
-                // need more data before we can shake more hands
-                done = true;
-              }
-              handshakeStatus = res.getHandshakeStatus();
-              break;
-            case NEED_TASK:
-              Runnable runnable;
-              while ((runnable = engine.getDelegatedTask()) != null) {
-                runnable.run();
-              }
-              handshakeStatus = engine.getHandshakeStatus();
-              break;
-            default:
+      doOp(SSLOperation.UNWRAP, inboundNetData, inboundAppData);
+
+      HandshakeStatus handshakeStatus = engine.getHandshakeStatus();
+      boolean done = false;
+      while (!done) {
+        SSLEngineResult res;
+        switch (handshakeStatus) {
+          case NEED_WRAP:
+            res = doOp(SSLOperation.WRAP, inboundAppData, outboundNetData);
+            handshakeStatus = res.getHandshakeStatus();
+            break;
+          case NEED_UNWRAP:
+            res = doOp(SSLOperation.UNWRAP, inboundNetData, inboundAppData);
+            if (res.getStatus() == Status.BUFFER_UNDERFLOW) {
+              // need more data before we can shake more hands
               done = true;
-          }
+            }
+            handshakeStatus = res.getHandshakeStatus();
+            break;
+          case NEED_TASK:
+            Runnable runnable;
+            while ((runnable = engine.getDelegatedTask()) != null) {
+              runnable.run();
+            }
+            handshakeStatus = engine.getHandshakeStatus();
+            break;
+          default:
+            done = true;
         }
-      } while (inboundAppData.position() == 0 && !closed &&
-               inboundNetData.hasRemaining() && inboundNetData.position() > consumedTo);
+      }
 
       if (inboundNetData.hasRemaining()) {
         inboundNetData.compact();
@@ -487,19 +482,14 @@ public class MiniSSL extends RubyObject { // MiniSSL::Engine
 
   @JRubyMethod
   public IRubyObject shutdown() {
-    // The peer may be speaking plain HTTP if the handshake did not finish.
-    if (closed || !handshake || engine.isInboundDone() && engine.isOutboundDone()) {
-      return getRuntime().getTrue();
-    }
-
-    // Generate close_notify for MiniSSL::Socket#close to send.
-    engine.closeOutbound();
-    try {
-      doOp(SSLOperation.WRAP, outboundAppData, outboundNetData);
-    } catch (SSLException e) {
+    if (closed || engine.isInboundDone() && engine.isOutboundDone()) {
+      if (engine.isOutboundDone()) {
+        engine.closeOutbound();
+      }
       return getRuntime().getTrue();
+    } else {
+      return getRuntime().getFalse();
     }
-    return getRuntime().getFalse();
   }
 
   private static RubyClass getSSLError(Ruby runtime) {

data/ext/puma_http11/puma_http11.c

@@ -385,8 +385,7 @@ static VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE st
   long dlen = 0;
 
   from = FIX2INT(start);
-  dptr = RSTRING_PTR(data);
-  dlen = (long)RSTRING_LEN(data);
+  RSTRING_GETMEM(data, dptr, dlen);
 
   if(from >= dlen) {
     rb_raise(eHttpParserError, "%s", "Requested start is after data buffer end.");
@@ -399,7 +398,7 @@ static VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE st
     if(puma_parser_has_error(http)) {
       rb_raise(eHttpParserError, "%s", "Invalid HTTP format, parsing fails. Are you trying to open an SSL connection to a non-SSL Puma?");
     } else {
-      return SIZET2NUM(puma_parser_nread(http));
+      return INT2FIX(puma_parser_nread(http));
     }
   }
 }
@@ -445,7 +444,7 @@ static VALUE HttpParser_nread(VALUE self)
 {
   puma_parser *http = HttpParser_unwrap(self);
 
-  return SIZET2NUM(http->nread);
+  return INT2FIX(http->nread);
 }
 
 /**

data/lib/puma/cli.rb

@@ -148,7 +148,7 @@ module Puma
 
           o.on "-p", "--port PORT", "Define the TCP port to bind to",
             "Use -b for more advanced options" do |arg|
-            user_config.bind "tcp://#{Configuration::DEFAULTS[:tcp_host]}:#{arg}"
+            user_config.port arg, Configuration.default_tcp_host
           end
 
           o.on "--pidfile PATH", "Use PATH as a pidfile" do |arg|

data/lib/puma/client.rb

@@ -2,6 +2,7 @@
 
 require_relative 'detect'
 require_relative 'io_buffer'
+require_relative 'client_env'
 require 'tempfile'
 
 if Puma::IS_JRUBY
@@ -20,8 +21,8 @@ module Puma
   #———————————————————————— DO NOT USE — this class is for internal use only ———
 
 
-  # An instance of this class represents a unique request from a client.
-  # For example, this could be a web request from a browser or from CURL.
+  # An instance of this class wraps a connection/socket.
+  # For example, this could be an http request from a browser or from CURL.
   #
   # An instance of `Puma::Client` can be used as if it were an IO object
   # by the reactor. The reactor is expected to call `#to_io`
@@ -29,12 +30,18 @@ module Puma
   # `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.
+  # Instances of this class are responsible for knowing if the request line,
+  # headers and body are fully buffered and verified via the `try_to_finish` method.
+  # All verification of each request is done in the `Client` object.
   # They can be used to "time out" a response via the `timeout_at` reader.
   #
+  # Most of the code for env processing and verification is contained
+  # in `Puma::ClientEnv`, which is included.
+  #
   class Client # :nodoc:
 
+    include ClientEnv
+
     # this tests all values but the last, which must be chunked
     ALLOWED_TRANSFER_ENCODING = %w[compress deflate gzip].freeze
 
@@ -47,8 +54,6 @@ module Puma
     # chunk header.
     MAX_CHUNK_HEADER_SIZE = 4096
 
-    SHUTDOWN_READ_GRACE = 1
-
     # The maximum amount of excess data the client sends
     # using chunk size extensions before we abort the connection.
     MAX_CHUNK_EXCESS = 16 * 1024
@@ -67,7 +72,13 @@ module Puma
     # no body share this one object since it has no state.
     EmptyBody = NullIO.new
 
-    include Puma::Const
+    attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
+                :tempfile, :io_buffer, :http_content_length_limit_exceeded,
+                :requests_served, :error_status_code
+
+    attr_writer :peerip, :http_content_length_limit, :supported_http_methods
+
+    attr_accessor :remote_addr_header, :listener, :env_set_http_version
 
     def initialize(io, env=nil)
       @io = io
@@ -93,9 +104,8 @@ module Puma
       @hijacked = false
 
       @http_content_length_limit = nil
-      @http_content_length_limit_exceeded = false
-
-      @reactor_error = nil
+      @http_content_length_limit_exceeded = nil
+      @error_status_code = nil
 
       @peerip = nil
       @peer_family = nil
@@ -104,8 +114,6 @@ module Puma
       @expect_proxy_proto = false
 
       @body_remain = 0
-      @bytes_read = 0
-      @pending_write = nil
 
       @in_last_chunk = false
 
@@ -113,15 +121,6 @@ module Puma
       @read_buffer = String.new # rubocop: disable Performance/UnfreezeString
     end
 
-    attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
-                :tempfile, :io_buffer, :http_content_length_limit_exceeded,
-                :requests_served, :bytes_read
-
-    attr_writer :peerip, :http_content_length_limit
-
-    attr_accessor :remote_addr_header, :listener,
-                  :reactor_error
-
     # Remove in Puma 7?
     def closed?
       @to_io.closed?
@@ -164,14 +163,15 @@ module Puma
       @parser.reset
       @io_buffer.reset
       @read_header = true
-      @read_proxy = !!@expect_proxy_proto && @requests_served.zero?
+      @read_proxy = !!@expect_proxy_proto
       @env = @proto_env.dup
       @parsed_bytes = 0
       @ready = false
       @body_remain = 0
       @peerip = nil if @remote_addr_header
       @in_last_chunk = false
-      @http_content_length_limit_exceeded = false
+      @http_content_length_limit_exceeded = nil
+      @error_status_code = nil
     end
 
     # only used with back-to-back requests contained in the buffer
@@ -181,12 +181,7 @@ module Puma
 
         @parsed_bytes = parser_execute
 
-        if @parser.finished?
-          return setup_body
-        elsif @parsed_bytes >= MAX_HEADER
-          raise HttpParserError,
-            "HEADER is longer than allowed, aborting client early."
-        end
+        @parser.finished? ? process_env_body : false
       end
     end
 
@@ -218,56 +213,27 @@ module Puma
     def try_to_parse_proxy_protocol
       if @read_proxy
         if @expect_proxy_proto == :v1
-          crlf_index = @buffer.index "\r\n"
-
-          unless crlf_index
-            if "PROXY ".start_with? @buffer
-              return false
-            elsif @buffer.start_with? "PROXY "
-              if @buffer.bytesize >= PROXY_PROTOCOL_V1_MAX_LENGTH
-                raise ConnectionError, "PROXY protocol v1 line is too long"
+          if @buffer.include? "\r\n"
+            if md = PROXY_PROTOCOL_V1_REGEX.match(@buffer)
+              if md[1]
+                @peerip = md[1].split(" ")[0]
               end
-              return false
+              @buffer = md.post_match
             end
-
+            # if the buffer has a \r\n but doesn't have a PROXY protocol
+            # request, this is just HTTP from a non-PROXY client; move on
             @read_proxy = false
-            return true
-          end
-
-          if @buffer.start_with?("PROXY ") && crlf_index + 2 > PROXY_PROTOCOL_V1_MAX_LENGTH
-            raise ConnectionError, "PROXY protocol v1 line is too long"
-          end
-
-          if md = PROXY_PROTOCOL_V1_REGEX.match(@buffer)
-            if md[1]
-              @peerip = md[1].split(" ")[0]
-            end
-            @buffer = md.post_match
+            return @buffer.size > 0
+          else
+            return false
           end
-          # if the buffer has a \r\n but doesn't have a PROXY protocol
-          # request, this is just HTTP from a non-PROXY client; move on
-          @read_proxy = false
-          return @buffer.size > 0
         end
       end
       true
     end
 
-    def try_to_finish(&deadline)
-      return false unless flush_pending_write
-
-      if env[CONTENT_LENGTH] && above_http_content_limit(env[CONTENT_LENGTH].to_i)
-        @http_content_length_limit_exceeded = true
-      end
-
-      if @http_content_length_limit_exceeded
-        @buffer = nil
-        @body = EmptyBody
-        set_ready
-        return true
-      end
-
-      return read_body(&deadline) if in_data_phase
+    def try_to_finish
+      return read_body if in_data_phase
 
       data = nil
       begin
@@ -287,7 +253,6 @@ module Puma
         raise EOFError
       end
 
-      @bytes_read += data.bytesize
       if @buffer
         @buffer << data
       else
@@ -298,74 +263,32 @@ module Puma
 
       @parsed_bytes = parser_execute
 
-      if @parser.finished? && above_http_content_limit(@parser.body.bytesize)
-        @http_content_length_limit_exceeded = true
-      end
-
-      if @parser.finished?
-        setup_body
-      elsif @parsed_bytes >= MAX_HEADER
-        raise HttpParserError,
-          "HEADER is longer than allowed, aborting client early."
-      else
-        false
-      end
+      @parser.finished? ? process_env_body : false
     end
 
-    def eagerly_finish(&deadline)
+    def eagerly_finish
       return true if @ready
-      while !write_pending? && @to_io.wait_readable(0)
-        read = @bytes_read
-        return true if try_to_finish(&deadline)
-        check_deadline(&deadline) if deadline
-        return false if @bytes_read == read
+      while @to_io.wait_readable(0) # rubocop: disable Style/WhileUntilModifier
+        return true if try_to_finish
       end
       false
     end
 
-    def finish(timeout, &deadline)
+    def finish(timeout)
       return if @ready
-      set_timeout timeout
-      read = @bytes_read
-      until try_to_finish(&deadline)
-        if @bytes_read > read
-          set_timeout timeout
-          read = @bytes_read
-        elsif self.timeout == 0
-          timeout!
-        end
-        if deadline
-          check_deadline(&deadline)
-          limit = yield
-          wait = [self.timeout, limit ? limit - Process.clock_gettime(Process::CLOCK_MONOTONIC) : 0.1].min
-          wait_io(wait) if wait > 0
-        else
-          wait_io(self.timeout) || timeout!
-        end
-      end
-    end
-
-    def write_pending?
-      !@pending_write.nil? || (@io.respond_to?(:write_pending?) && @io.write_pending?)
+      @to_io.wait_readable(timeout) || timeout! until try_to_finish
     end
 
-    def take_pending_write
-      str = @pending_write
-      @pending_write = nil
-      str
-    end
-
-    def wait_io(timeout)
-      return @to_io.wait_readable(timeout) unless write_pending?
-      @to_io.wait_writable(timeout)
-    end
-    private :wait_io
-
     # Wraps `@parser.execute` and adds meaningful error messages
     # @return [Integer] bytes of buffer read by parser
     #
     def parser_execute
-      @parser.execute(@env, @buffer, @parsed_bytes)
+      ret = @parser.execute(@env, @buffer, @parsed_bytes)
+
+      if @env[REQUEST_METHOD] && @supported_http_methods != :any && !@supported_http_methods.key?(@env[REQUEST_METHOD])
+        raise HttpParserError501, "#{@env[REQUEST_METHOD]} method is not supported"
+      end
+      ret
     rescue => e
       @env[HTTP_CONNECTION] = 'close'
       raise e unless HttpParserError === e && e.message.include?('non-SSL')
@@ -399,6 +322,15 @@ module Puma
       end
     end
 
+    # processes the `env` and the request body
+    def process_env_body
+      temp = setup_body
+      normalize_env
+      req_env_post_parse
+      raise HttpParserError if @error_status_code
+      temp
+    end
+
     def timeout!
       write_error(408) if in_data_phase
       raise ConnectionError
@@ -406,51 +338,21 @@ module Puma
 
     def write_error(status_code)
       begin
-        write_interim ERROR_RESPONSE[status_code]
+        @io << ERROR_RESPONSE[status_code]
       rescue StandardError
       end
     end
 
-    def write_interim(str)
-      if @pending_write
-        @pending_write << str
-        return flush_pending_write
-      end
-
-      n = @io.write_nonblock(str, exception: false)
-      if n == :wait_writable
-        @pending_write = +str unless @io.respond_to?(:write_pending?) && @io.write_pending?
-      elsif n < str.bytesize
-        @pending_write = str.byteslice(n..-1)
-      end
-    rescue SystemCallError, IOError
-      raise ConnectionError, "Connection error detected during write"
-    end
-    private :write_interim
-
-    def flush_pending_write
-      return true unless @pending_write
-
-      n = @io.write_nonblock(@pending_write, exception: false)
-      return false if n == :wait_writable
-
-      @pending_write = n == @pending_write.bytesize ? nil : @pending_write.byteslice(n..-1)
-      @pending_write.nil?
-    rescue SystemCallError, IOError
-      raise ConnectionError, "Connection error detected during write"
-    end
-    private :flush_pending_write
-
     def peerip
       return @peerip if @peerip
 
       if @remote_addr_header
-        hdr = (@env[@remote_addr_header] || @io.peeraddr.last).split(/[\s,]/).first
+        hdr = (@env[@remote_addr_header] || socket_peerip).split(/[\s,]/).first
         @peerip = hdr
         return hdr
       end
 
-      @peerip ||= @io.peeraddr.last
+      @peerip ||= socket_peerip
     end
 
     def peer_family
@@ -485,18 +387,36 @@ module Puma
 
     private
 
+    IPV4_MAPPED_IPV6_PREFIX = "::ffff:"
+    private_constant :IPV4_MAPPED_IPV6_PREFIX
+
+    def socket_peerip
+      unmap_ipv6(@io.peeraddr.last)
+    end
+
+    # Converts IPv4-mapped IPv6 addresses (e.g. ::ffff:127.0.0.1) back to
+    # their IPv4 form. These addresses appear when IPv4 clients connect to
+    # a dual-stack IPv6 socket.
+    def unmap_ipv6(addr)
+      addr.delete_prefix(IPV4_MAPPED_IPV6_PREFIX)
+    end
+
+    # Checks the request `Transfer-Encoding` and/or `Content-Length` to see if
+    # they are valid.  Raises errors if not, otherwise reads the body.
+    # @return [Boolean] true if the body can be completely read, false otherwise
+    #
     def setup_body
       @body_read_start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
 
       if @env[HTTP_EXPECT] == CONTINUE
-        # TODO allow a hook here to check the headers before
-        # going forward
-        write_interim HTTP_11_100
+        # TODO allow a hook here to check the headers before going forward
+        @io << HTTP_11_100
+        @io.flush
       end
 
       @read_header = false
 
-      body = @parser.body
+      parser_body = @parser.body
 
       te = @env[TRANSFER_ENCODING2]
       if te
@@ -513,10 +433,10 @@ module Puma
             raise HttpParserError501, "#{TE_ERR_MSG}, unknown value: '#{te}'"
           end
           @env.delete TRANSFER_ENCODING2
-          return setup_chunked_body body
+          return setup_chunked_body parser_body
         elsif te_lwr == CHUNKED
           @env.delete TRANSFER_ENCODING2
-          return setup_chunked_body body
+          return setup_chunked_body parser_body
         elsif ALLOWED_TRANSFER_ENCODING.include? te_lwr
           raise HttpParserError     , "#{TE_ERR_MSG}, single value must be chunked: '#{te}'"
         else
@@ -531,10 +451,12 @@ module Puma
       if cl
         # cannot contain characters that are not \d, or be empty
         if CONTENT_LENGTH_VALUE_INVALID.match?(cl) || cl.empty?
+          @error_status_code = 400
+          @env[HTTP_CONNECTION] = 'close'
           raise HttpParserError, "Invalid Content-Length: #{cl.inspect}"
         end
       else
-        @buffer = body.empty? ? nil : body
+        @buffer = parser_body.empty? ? nil : parser_body
         @body = EmptyBody
         set_ready
         return true
@@ -542,23 +464,25 @@ module Puma
 
       content_length = cl.to_i
 
-      remain = content_length - body.bytesize
+      raise_above_http_content_limit if @http_content_length_limit&.< content_length
+
+      remain = content_length - parser_body.bytesize
 
       if remain <= 0
-        # Part of the body is a pipelined request OR garbage. We'll deal with that later.
+        # Part of the parser_body is a pipelined request OR garbage. We'll deal with that later.
         if content_length == 0
           @body = EmptyBody
-          if body.empty?
+          if parser_body.empty?
             @buffer = nil
           else
-            @buffer = body
+            @buffer = parser_body
           end
         elsif remain == 0
-          @body = StringIO.new body
+          @body = StringIO.new parser_body
           @buffer = nil
         else
-          @body = StringIO.new(body[0,content_length])
-          @buffer = body[content_length..-1]
+          @body = StringIO.new(parser_body[0,content_length])
+          @buffer = parser_body[content_length..-1]
         end
         set_ready
         return true
@@ -570,21 +494,21 @@ module Puma
         @body.binmode
         @tempfile = @body
       else
-        # The body[0,0] trick is to get an empty string in the same
-        # encoding as body.
-        @body = StringIO.new body[0,0]
+        # The parser_body[0,0] trick is to get an empty string in the same
+        # encoding as parser_body.
+        @body = StringIO.new parser_body[0,0]
       end
 
-      @body.write body
+      @body.write parser_body
 
       @body_remain = remain
 
       false
     end
 
-    def read_body(&deadline)
+    def read_body
       if @chunked_body
-        return read_chunked_body(&deadline)
+        return read_chunked_body
       end
 
       # Read an odd sized chunk so we can read even sized ones
@@ -609,7 +533,6 @@ module Puma
           raise EOFError
         end
 
-        @bytes_read += chunk.bytesize
         remain -= @body.write(chunk)
       end
 
@@ -624,7 +547,7 @@ module Puma
       end
     end
 
-    def read_chunked_body(&deadline)
+    def read_chunked_body
       while true
         begin
           chunk = @io.read_nonblock(CHUNK_SIZE, @read_buffer)
@@ -642,27 +565,13 @@ module Puma
           raise EOFError
         end
 
-        @bytes_read += chunk.bytesize
         if decode_chunk(chunk)
           @env[CONTENT_LENGTH] = @chunked_content_length.to_s
           return true
         end
-
-        check_deadline(&deadline) if deadline
       end
     end
 
-    def check_deadline
-      limit = yield
-      return unless limit
-
-      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      return if now < limit
-      return if now < limit + SHUTDOWN_READ_GRACE && @to_io.wait_readable(0)
-
-      timeout!
-    end
-
     def setup_chunked_body(body)
       @chunked_body = true
       @partial_part_left = 0
@@ -683,6 +592,10 @@ module Puma
 
     # @version 5.0.0
     def write_chunk(str)
+      if @http_content_length_limit&.< @chunked_content_length + str.bytesize
+        raise_above_http_content_limit
+      end
+
       @chunked_content_length += @body.write(str)
     end
 
@@ -815,8 +728,13 @@ module Puma
       @ready = true
     end
 
-    def above_http_content_limit(value)
-      @http_content_length_limit&.< value
+    def raise_above_http_content_limit
+      @http_content_length_limit_exceeded = true
+      @buffer = nil
+      @body = EmptyBody
+      @error_status_code = 413
+      @env[HTTP_CONNECTION] = 'close'
+      raise HttpParserError, "Payload Too Large"
     end
   end
 end