Class: Puma::Client

# File 'lib/puma/client.rb', line 372

def can_close?
  # Allow connection to close if we're not in the middle of parsing a request.
  @parsed_bytes == 0
end

# File 'lib/puma/client.rb', line 125

def closed?
  @to_io.closed?
end

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 81

attr_accessor :remote_addr_header, :listener, :env_set_http_version

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 377

def expect_proxy_proto=(val)
  if val
    if @read_header
      @read_proxy = true
    end
  else
    @read_proxy = false
  end
  @expect_proxy_proto = val
end

# File 'lib/puma/client.rb', line 190

def has_back_to_back_requests?
  !(@buffer.nil? || @buffer.empty?)
end

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 79

attr_writer :peerip, :http_content_length_limit, :supported_http_methods

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 148

def in_data_phase
  !(@read_header || @read_proxy)
end

# File 'lib/puma/client.rb', line 136

def inspect
  "#<Puma::Client:0x#{object_id.to_s(16)} @ready=#{@ready.inspect}>"
end

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 131

def io_ok?
  @to_io.is_a?(::BasicSocket) && !closed?
end

# File 'lib/puma/client.rb', line 81

attr_accessor :remote_addr_header, :listener, :env_set_http_version

# File 'lib/puma/client.rb', line 346

def peerip
  return @peerip if @peerip

  if @remote_addr_header
    hdr = (@env[@remote_addr_header] || @io.peeraddr.last).split(/[\s,]/).first
    @peerip = hdr
    return hdr
  end

  @peerip ||= @io.peeraddr.last
end

# File 'lib/puma/client.rb', line 79

attr_writer :peerip, :http_content_length_limit, :supported_http_methods

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 81

attr_accessor :remote_addr_header, :listener, :env_set_http_version

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 79

attr_writer :peerip, :http_content_length_limit, :supported_http_methods

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 158

def timeout
  [@timeout_at - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max
end

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 75

attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
            :tempfile, :io_buffer, :http_content_length_limit_exceeded,
            :requests_served, :error_status_code

# File 'lib/puma/client.rb', line 194

def close
  tempfile_close
  begin
    @io.close
  rescue IOError, Errno::EBADF
  end
end

# File 'lib/puma/client.rb', line 597

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 @prev_chunk.empty?
    io = StringIO.new(chunk)
  else
    io = StringIO.new(@prev_chunk+chunk)
    @prev_chunk = ""
  end

  while !io.eof?
    line = io.gets
    if line.end_with?(CHUNK_VALID_ENDING)
      # Puma doesn't process chunk extensions, but should parse if they're
      # present, which is the reason for the semicolon regex
      chunk_hex = line.strip[/\A[^;]+/]
      if CHUNK_SIZE_INVALID.match? chunk_hex
        raise HttpParserError, "Invalid chunk size: '#{chunk_hex}'"
      end
      len = chunk_hex.to_i(16)
      if len == 0
        @in_last_chunk = true
        @body.rewind
        rest = io.read
        if rest.bytesize < CHUNK_VALID_ENDING_SIZE
          @buffer = nil
          @partial_part_left = CHUNK_VALID_ENDING_SIZE - rest.bytesize
          return false
        else
          # if the next character is a CRLF, set buffer to everything after that CRLF
          start_of_rest = if rest.start_with?(CHUNK_VALID_ENDING)
            CHUNK_VALID_ENDING_SIZE
          else # we have started a trailer section, which we do not support. skip it!
            rest.index(CHUNK_VALID_ENDING*2) + CHUNK_VALID_ENDING_SIZE*2
          end

          @buffer = rest[start_of_rest..-1]
          @buffer = nil if @buffer.empty?
          set_ready
          return true
        end
      end

      # Track the excess as a function of the size of the
      # header vs the size of the actual data. Excess can
      # go negative (and is expected to) when the body is
      # significant.
      # The additional of chunk_hex.size and 2 compensates
      # for a client sending 1 byte in a chunked body over
      # a long period of time, making sure that that client
      # isn't accidentally eventually punished.
      @excess_cr += (line.size - len - chunk_hex.size - 2)

      if @excess_cr >= MAX_CHUNK_EXCESS
        raise HttpParserError, "Maximum chunk excess detected"
      end

      len += 2

      part = io.read(len)

      unless part
        @partial_part_left = len
        next
      end

      got = part.size

      case
      when got == len
        # proper chunked segment must end with "\r\n"
        if part.end_with? CHUNK_VALID_ENDING
          write_chunk(part[0..-3]) # to skip the ending \r\n
        else
          raise HttpParserError, "Chunk size mismatch"
        end
      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
      if @prev_chunk.size + line.size >= MAX_CHUNK_HEADER_SIZE
        raise HttpParserError, "maximum size of chunk header exceeded"
      end

      @prev_chunk = line
      return false
    end
  end

  if @in_last_chunk
    set_ready
    true
  else
    false
  end
end

# File 'lib/puma/client.rb', line 269

def eagerly_finish
  return true if @ready
  while @to_io.wait_readable(0) # rubocop: disable Style/WhileUntilModifier
    return true if try_to_finish
  end
  false
end

# File 'lib/puma/client.rb', line 277

def finish(timeout)
  return if @ready
  @to_io.wait_readable(timeout) || timeout! until try_to_finish
end

# File 'lib/puma/client.rb', line 142

def full_hijack
  @hijacked = true
  env[HIJACK_IO] ||= @io
end

# File 'lib/puma/client.rb', line 285

def parser_execute
  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')

  req, _ = @buffer.split "\r\n\r\n"
  request_line, headers = req.split "\r\n", 2

  # below checks for request issues and changes error message accordingly
  if !@env.key? REQUEST_METHOD
    if request_line.count(' ') != 2
       # maybe this is an SSL connection ?
      raise e
    else
      method = request_line[/\A[^ ]+/]
      raise e, "Invalid HTTP format, parsing fails. Bad method #{method}"
    end
  elsif !@env.key? REQUEST_PATH
    path = request_line[/\A[^ ]+ +([^ ?\r\n]+)/, 1]
    raise e, "Invalid HTTP format, parsing fails. Bad path #{path}"
  elsif request_line.match?(/\A[^ ]+ +[^ ?\r\n]+\?/) && !@env.key?(QUERY_STRING)
    query = request_line[/\A[^ ]+ +[^? ]+\?([^ ]+)/, 1]
    raise e, "Invalid HTTP format, parsing fails. Bad query #{query}"
  elsif !@env.key? SERVER_PROTOCOL
    # protocol is bad
    text = request_line[/[^ ]*\z/]
    raise HttpParserError, "Invalid HTTP format, parsing fails. Bad protocol #{text}"
  elsif !headers.empty?
    # headers are bad
    hdrs = headers.split("\r\n").map { |h| h.gsub "\n", '\n'}.join "\n"
    raise HttpParserError, "Invalid HTTP format, parsing fails. Bad headers\n#{hdrs}"
  end
end

# File 'lib/puma/client.rb', line 358

def peer_family
  return @peer_family if @peer_family

  @peer_family ||= begin
                     @io.local_address.afamily
                   rescue
                     Socket::AF_INET
                   end
end

# File 'lib/puma/client.rb', line 178

def process_back_to_back_requests
  if @buffer
    return false unless try_to_parse_proxy_protocol

    @parsed_bytes = parser_execute

    @parser.finished? ? process_env_body : false
  end
end

# File 'lib/puma/client.rb', line 326

def process_env_body
  temp = setup_body
  normalize_env
  req_env_post_parse
  raise HttpParserError if @error_status_code
  temp
end

# File 'lib/puma/client.rb', line 501

def read_body
  if @chunked_body
    return read_chunked_body
  end

  # Read an odd sized chunk so we can read even sized ones
  # after this
  remain = @body_remain

  # don't bother with reading zero bytes
  unless remain.zero?
    begin
      chunk = @io.read_nonblock(remain.clamp(0, CHUNK_SIZE), @read_buffer)
    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

    remain -= @body.write(chunk)
  end

  if remain <= 0
    @body.rewind
    @buffer = nil
    set_ready
    true
  else
    @body_remain = remain
    false
  end
end

# File 'lib/puma/client.rb', line 542

def read_chunked_body
  while true
    begin
      chunk = @io.read_nonblock(CHUNK_SIZE, @read_buffer)
    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

# File 'lib/puma/client.rb', line 162

def reset
  @parser.reset
  @io_buffer.reset
  @read_header = true
  @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 = nil
  @error_status_code = nil
end

# File 'lib/puma/client.rb', line 718

def set_ready
  if @body_read_start
    @env['puma.request_body_wait'] = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - @body_read_start
  end
  @requests_served += 1
  @ready = true
end

# File 'lib/puma/client.rb', line 152

def set_timeout(val)
  @timeout_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + val
end

# File 'lib/puma/client.rb', line 394

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
    @io << HTTP_11_100
    @io.flush
  end

  @read_header = false

  parser_body = @parser.body

  te = @env[TRANSFER_ENCODING2]
  if te
    te_lwr = te.downcase
    if te.include? ','
      te_ary = te_lwr.split(',').each { |te| te.gsub!(STRIP_OWS, "") }
      te_count = te_ary.count CHUNKED
      te_valid = te_ary[0..-2].all? { |e| ALLOWED_TRANSFER_ENCODING.include? e }
      if te_count > 1
        raise HttpParserError   , "#{TE_ERR_MSG}, multiple chunked: '#{te}'"
      elsif te_ary.last != CHUNKED
        raise HttpParserError   , "#{TE_ERR_MSG}, last value must be chunked: '#{te}'"
      elsif !te_valid
        raise HttpParserError501, "#{TE_ERR_MSG}, unknown value: '#{te}'"
      end
      @env.delete TRANSFER_ENCODING2
      return setup_chunked_body parser_body
    elsif te_lwr == CHUNKED
      @env.delete TRANSFER_ENCODING2
      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
      raise HttpParserError501  , "#{TE_ERR_MSG}, unknown value: '#{te}'"
    end
  end

  @chunked_body = false

  cl = @env[CONTENT_LENGTH]

  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 = parser_body.empty? ? nil : parser_body
    @body = EmptyBody
    set_ready
    return true
  end

  content_length = cl.to_i

  if above_http_content_limit(content_length)
    @buffer = nil
    @body = EmptyBody
    @error_status_code = 413
    @env[HTTP_CONNECTION] = 'close'
    raise HttpParserError, "Payload Too Large"
  end

  remain = content_length - parser_body.bytesize

  if remain <= 0
    # Part of the parser_body is a pipelined request OR garbage. We'll deal with that later.
    if content_length == 0
      @body = EmptyBody
      if parser_body.empty?
        @buffer = nil
      else
        @buffer = parser_body
      end
    elsif remain == 0
      @body = StringIO.new parser_body
      @buffer = nil
    else
      @body = StringIO.new(parser_body[0,content_length])
      @buffer = parser_body[content_length..-1]
    end
    set_ready
    return true
  end

  if remain > MAX_BODY
    @body = Tempfile.create(Const::PUMA_TMP_BASE)
    File.unlink @body.path unless IS_WINDOWS
    @body.binmode
    @tempfile = @body
  else
    # 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 parser_body

  @body_remain = remain

  false
end

# File 'lib/puma/client.rb', line 567

def setup_chunked_body(body)
  @chunked_body = true
  @partial_part_left = 0
  @prev_chunk = ""
  @excess_cr = 0

  @body = Tempfile.create(Const::PUMA_TMP_BASE)
  File.unlink @body.path unless IS_WINDOWS
  @body.binmode
  @tempfile = @body
  @chunked_content_length = 0

  if decode_chunk(body)
    @env[CONTENT_LENGTH] = @chunked_content_length.to_s
    return true
  end
end

# File 'lib/puma/client.rb', line 202

def tempfile_close
  tf_path = @tempfile&.path
  @tempfile&.close
  File.unlink(tf_path) if tf_path
  @tempfile = nil
  @body = nil
rescue Errno::ENOENT, IOError
end

# File 'lib/puma/client.rb', line 334

def timeout!
  write_error(408) if in_data_phase
  raise ConnectionError
end

# File 'lib/puma/client.rb', line 235

def try_to_finish
  return read_body if in_data_phase

  data = nil
  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

  # No data means a closed socket
  unless data
    @buffer = nil
    set_ready
    raise EOFError
  end

  if @buffer
    @buffer << data
  else
    @buffer = data
  end

  return false unless try_to_parse_proxy_protocol

  @parsed_bytes = parser_execute

  @parser.finished? ? process_env_body : false
end

# File 'lib/puma/client.rb', line 213

def try_to_parse_proxy_protocol
  if @read_proxy
    if @expect_proxy_proto == :v1
      if @buffer.include? "\r\n"
        if md = PROXY_PROTOCOL_V1_REGEX.match(@buffer)
          if md[1]
            @peerip = md[1].split(" ")[0]
          end
          @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 @buffer.size > 0
      else
        return false
      end
    end
  end
  true
end

# File 'lib/puma/client.rb', line 586

def write_chunk(str)
  if above_http_content_limit(@chunked_content_length + str.bytesize)
    @buffer = nil
    @body = EmptyBody
    @error_status_code = 413
    @env[HTTP_CONNECTION] = 'close'
    raise HttpParserError, "Payload Too Large"
  end
  @chunked_content_length += @body.write(str)
end

# File 'lib/puma/client.rb', line 339

def write_error(status_code)
  begin
    @io << ERROR_RESPONSE[status_code]
  rescue StandardError
  end
end