@shopify/cli-kit 3.38.0 → 3.40.0

package/assets/cli-ruby/vendor/deps/webrick/lib/webrick/httprequest.rb

@@ -0,0 +1,636 @@
+# frozen_string_literal: true
+#
+# httprequest.rb -- HTTPRequest Class
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: httprequest.rb,v 1.64 2003/07/13 17:18:22 gotoyuzo Exp $
+
+require 'fiber'
+require 'uri'
+require_relative 'httpversion'
+require_relative 'httpstatus'
+require_relative 'httputils'
+require_relative 'cookie'
+
+module WEBrick
+
+  ##
+  # An HTTP request.  This is consumed by service and do_* methods in
+  # WEBrick servlets
+
+  class HTTPRequest
+
+    BODY_CONTAINABLE_METHODS = [ "POST", "PUT" ] # :nodoc:
+
+    # :section: Request line
+
+    ##
+    # The complete request line such as:
+    #
+    #   GET / HTTP/1.1
+
+    attr_reader :request_line
+
+    ##
+    # The request method, GET, POST, PUT, etc.
+
+    attr_reader :request_method
+
+    ##
+    # The unparsed URI of the request
+
+    attr_reader :unparsed_uri
+
+    ##
+    # The HTTP version of the request
+
+    attr_reader :http_version
+
+    # :section: Request-URI
+
+    ##
+    # The parsed URI of the request
+
+    attr_reader :request_uri
+
+    ##
+    # The request path
+
+    attr_reader :path
+
+    ##
+    # The script name (CGI variable)
+
+    attr_accessor :script_name
+
+    ##
+    # The path info (CGI variable)
+
+    attr_accessor :path_info
+
+    ##
+    # The query from the URI of the request
+
+    attr_accessor :query_string
+
+    # :section: Header and entity body
+
+    ##
+    # The raw header of the request
+
+    attr_reader :raw_header
+
+    ##
+    # The parsed header of the request
+
+    attr_reader :header
+
+    ##
+    # The parsed request cookies
+
+    attr_reader :cookies
+
+    ##
+    # The Accept header value
+
+    attr_reader :accept
+
+    ##
+    # The Accept-Charset header value
+
+    attr_reader :accept_charset
+
+    ##
+    # The Accept-Encoding header value
+
+    attr_reader :accept_encoding
+
+    ##
+    # The Accept-Language header value
+
+    attr_reader :accept_language
+
+    # :section:
+
+    ##
+    # The remote user (CGI variable)
+
+    attr_accessor :user
+
+    ##
+    # The socket address of the server
+
+    attr_reader :addr
+
+    ##
+    # The socket address of the client
+
+    attr_reader :peeraddr
+
+    ##
+    # Hash of request attributes
+
+    attr_reader :attributes
+
+    ##
+    # Is this a keep-alive connection?
+
+    attr_reader :keep_alive
+
+    ##
+    # The local time this request was received
+
+    attr_reader :request_time
+
+    ##
+    # Creates a new HTTP request.  WEBrick::Config::HTTP is the default
+    # configuration.
+
+    def initialize(config)
+      @config = config
+      @buffer_size = @config[:InputBufferSize]
+      @logger = config[:Logger]
+
+      @request_line = @request_method =
+        @unparsed_uri = @http_version = nil
+
+      @request_uri = @host = @port = @path = nil
+      @script_name = @path_info = nil
+      @query_string = nil
+      @query = nil
+      @form_data = nil
+
+      @raw_header = Array.new
+      @header = nil
+      @cookies = []
+      @accept = []
+      @accept_charset = []
+      @accept_encoding = []
+      @accept_language = []
+      @body = +""
+
+      @addr = @peeraddr = nil
+      @attributes = {}
+      @user = nil
+      @keep_alive = false
+      @request_time = nil
+
+      @remaining_size = nil
+      @socket = nil
+
+      @forwarded_proto = @forwarded_host = @forwarded_port =
+        @forwarded_server = @forwarded_for = nil
+    end
+
+    ##
+    # Parses a request from +socket+.  This is called internally by
+    # WEBrick::HTTPServer.
+
+    def parse(socket=nil)
+      @socket = socket
+      begin
+        @peeraddr = socket.respond_to?(:peeraddr) ? socket.peeraddr : []
+        @addr = socket.respond_to?(:addr) ? socket.addr : []
+      rescue Errno::ENOTCONN
+        raise HTTPStatus::EOFError
+      end
+
+      read_request_line(socket)
+      if @http_version.major > 0
+        read_header(socket)
+        @header['cookie'].each{|cookie|
+          @cookies += Cookie::parse(cookie)
+        }
+        @accept = HTTPUtils.parse_qvalues(self['accept'])
+        @accept_charset = HTTPUtils.parse_qvalues(self['accept-charset'])
+        @accept_encoding = HTTPUtils.parse_qvalues(self['accept-encoding'])
+        @accept_language = HTTPUtils.parse_qvalues(self['accept-language'])
+      end
+      return if @request_method == "CONNECT"
+      return if @unparsed_uri == "*"
+
+      begin
+        setup_forwarded_info
+        @request_uri = parse_uri(@unparsed_uri)
+        @path = HTTPUtils::unescape(@request_uri.path)
+        @path = HTTPUtils::normalize_path(@path)
+        @host = @request_uri.host
+        @port = @request_uri.port
+        @query_string = @request_uri.query
+        @script_name = ""
+        @path_info = @path.dup
+      rescue
+        raise HTTPStatus::BadRequest, "bad URI `#{@unparsed_uri}'."
+      end
+
+      if /\Aclose\z/io =~ self["connection"]
+        @keep_alive = false
+      elsif /\Akeep-alive\z/io =~ self["connection"]
+        @keep_alive = true
+      elsif @http_version < "1.1"
+        @keep_alive = false
+      else
+        @keep_alive = true
+      end
+    end
+
+    ##
+    # Generate HTTP/1.1 100 continue response if the client expects it,
+    # otherwise does nothing.
+
+    def continue # :nodoc:
+      if self['expect'] == '100-continue' && @config[:HTTPVersion] >= "1.1"
+        @socket << "HTTP/#{@config[:HTTPVersion]} 100 continue#{CRLF}#{CRLF}"
+        @header.delete('expect')
+      end
+    end
+
+    ##
+    # Returns the request body.
+
+    def body(&block) # :yields: body_chunk
+      block ||= Proc.new{|chunk| @body << chunk }
+      read_body(@socket, block)
+      @body.empty? ? nil : @body
+    end
+
+    ##
+    # Prepares the HTTPRequest object for use as the
+    # source for IO.copy_stream
+
+    def body_reader
+      @body_tmp = []
+      @body_rd = Fiber.new do
+        body do |buf|
+          @body_tmp << buf
+          Fiber.yield
+        end
+      end
+      @body_rd.resume # grab the first chunk and yield
+      self
+    end
+
+    # for IO.copy_stream.
+    def readpartial(size, buf = ''.b) # :nodoc
+      res = @body_tmp.shift or raise EOFError, 'end of file reached'
+      if res.length > size
+        @body_tmp.unshift(res[size..-1])
+        res = res[0..size - 1]
+      end
+      buf.replace(res)
+      res.clear
+      # get more chunks - check alive? because we can take a partial chunk
+      @body_rd.resume if @body_rd.alive?
+      buf
+    end
+
+    ##
+    # Request query as a Hash
+
+    def query
+      unless @query
+        parse_query()
+      end
+      @query
+    end
+
+    ##
+    # The content-length header
+
+    def content_length
+      return Integer(self['content-length'])
+    end
+
+    ##
+    # The content-type header
+
+    def content_type
+      return self['content-type']
+    end
+
+    ##
+    # Retrieves +header_name+
+
+    def [](header_name)
+      if @header
+        value = @header[header_name.downcase]
+        value.empty? ? nil : value.join(", ")
+      end
+    end
+
+    ##
+    # Iterates over the request headers
+
+    def each
+      if @header
+        @header.each{|k, v|
+          value = @header[k]
+          yield(k, value.empty? ? nil : value.join(", "))
+        }
+      end
+    end
+
+    ##
+    # The host this request is for
+
+    def host
+      return @forwarded_host || @host
+    end
+
+    ##
+    # The port this request is for
+
+    def port
+      return @forwarded_port || @port
+    end
+
+    ##
+    # The server name this request is for
+
+    def server_name
+      return @forwarded_server || @config[:ServerName]
+    end
+
+    ##
+    # The client's IP address
+
+    def remote_ip
+      return self["client-ip"] || @forwarded_for || @peeraddr[3]
+    end
+
+    ##
+    # Is this an SSL request?
+
+    def ssl?
+      return @request_uri.scheme == "https"
+    end
+
+    ##
+    # Should the connection this request was made on be kept alive?
+
+    def keep_alive?
+      @keep_alive
+    end
+
+    def to_s # :nodoc:
+      ret = @request_line.dup
+      @raw_header.each{|line| ret << line }
+      ret << CRLF
+      ret << body if body
+      ret
+    end
+
+    ##
+    # Consumes any remaining body and updates keep-alive status
+
+    def fixup() # :nodoc:
+      begin
+        body{|chunk| }   # read remaining body
+      rescue HTTPStatus::Error => ex
+        @logger.error("HTTPRequest#fixup: #{ex.class} occurred.")
+        @keep_alive = false
+      rescue => ex
+        @logger.error(ex)
+        @keep_alive = false
+      end
+    end
+
+    # This method provides the metavariables defined by the revision 3
+    # of "The WWW Common Gateway Interface Version 1.1"
+    # To browse the current document of CGI Version 1.1, see below:
+    # http://tools.ietf.org/html/rfc3875
+
+    def meta_vars
+      meta = Hash.new
+
+      cl = self["Content-Length"]
+      ct = self["Content-Type"]
+      meta["CONTENT_LENGTH"]    = cl if cl.to_i > 0
+      meta["CONTENT_TYPE"]      = ct.dup if ct
+      meta["GATEWAY_INTERFACE"] = "CGI/1.1"
+      meta["PATH_INFO"]         = @path_info ? @path_info.dup : ""
+     #meta["PATH_TRANSLATED"]   = nil      # no plan to be provided
+      meta["QUERY_STRING"]      = @query_string ? @query_string.dup : ""
+      meta["REMOTE_ADDR"]       = @peeraddr[3]
+      meta["REMOTE_HOST"]       = @peeraddr[2]
+     #meta["REMOTE_IDENT"]      = nil      # no plan to be provided
+      meta["REMOTE_USER"]       = @user
+      meta["REQUEST_METHOD"]    = @request_method.dup
+      meta["REQUEST_URI"]       = @request_uri.to_s
+      meta["SCRIPT_NAME"]       = @script_name.dup
+      meta["SERVER_NAME"]       = @host
+      meta["SERVER_PORT"]       = @port.to_s
+      meta["SERVER_PROTOCOL"]   = "HTTP/" + @config[:HTTPVersion].to_s
+      meta["SERVER_SOFTWARE"]   = @config[:ServerSoftware].dup
+
+      self.each{|key, val|
+        next if /^content-type$/i =~ key
+        next if /^content-length$/i =~ key
+        name = "HTTP_" + key
+        name.gsub!(/-/o, "_")
+        name.upcase!
+        meta[name] = val
+      }
+
+      meta
+    end
+
+    private
+
+    # :stopdoc:
+
+    MAX_URI_LENGTH = 2083 # :nodoc:
+
+    # same as Mongrel, Thin and Puma
+    MAX_HEADER_LENGTH = (112 * 1024) # :nodoc:
+
+    def read_request_line(socket)
+      @request_line = read_line(socket, MAX_URI_LENGTH) if socket
+      raise HTTPStatus::EOFError unless @request_line
+
+      @request_bytes = @request_line.bytesize
+      if @request_bytes >= MAX_URI_LENGTH and @request_line[-1, 1] != LF
+        raise HTTPStatus::RequestURITooLarge
+      end
+
+      @request_time = Time.now
+      if /^(\S+)\s+(\S++)(?:\s+HTTP\/(\d+\.\d+))?\r?\n/mo =~ @request_line
+        @request_method = $1
+        @unparsed_uri   = $2
+        @http_version   = HTTPVersion.new($3 ? $3 : "0.9")
+      else
+        rl = @request_line.sub(/\x0d?\x0a\z/o, '')
+        raise HTTPStatus::BadRequest, "bad Request-Line `#{rl}'."
+      end
+    end
+
+    def read_header(socket)
+      if socket
+        while line = read_line(socket)
+          break if /\A(#{CRLF}|#{LF})\z/om =~ line
+          if (@request_bytes += line.bytesize) > MAX_HEADER_LENGTH
+            raise HTTPStatus::RequestEntityTooLarge, 'headers too large'
+          end
+          @raw_header << line
+        end
+      end
+      @header = HTTPUtils::parse_header(@raw_header.join)
+    end
+
+    def parse_uri(str, scheme="http")
+      if @config[:Escape8bitURI]
+        str = HTTPUtils::escape8bit(str)
+      end
+      str.sub!(%r{\A/+}o, '/')
+      uri = URI::parse(str)
+      return uri if uri.absolute?
+      if @forwarded_host
+        host, port = @forwarded_host, @forwarded_port
+      elsif self["host"]
+        pattern = /\A(#{URI::REGEXP::PATTERN::HOST})(?::(\d+))?\z/n
+        host, port = *self['host'].scan(pattern)[0]
+      elsif @addr.size > 0
+        host, port = @addr[2], @addr[1]
+      else
+        host, port = @config[:ServerName], @config[:Port]
+      end
+      uri.scheme = @forwarded_proto || scheme
+      uri.host = host
+      uri.port = port ? port.to_i : nil
+      return URI::parse(uri.to_s)
+    end
+
+    def read_body(socket, block)
+      return unless socket
+      if tc = self['transfer-encoding']
+        case tc
+        when /\Achunked\z/io then read_chunked(socket, block)
+        else raise HTTPStatus::NotImplemented, "Transfer-Encoding: #{tc}."
+        end
+      elsif self['content-length'] || @remaining_size
+        @remaining_size ||= self['content-length'].to_i
+        while @remaining_size > 0
+          sz = [@buffer_size, @remaining_size].min
+          break unless buf = read_data(socket, sz)
+          @remaining_size -= buf.bytesize
+          block.call(buf)
+        end
+        if @remaining_size > 0 && @socket.eof?
+          raise HTTPStatus::BadRequest, "invalid body size."
+        end
+      elsif BODY_CONTAINABLE_METHODS.member?(@request_method) && !@socket.eof
+        raise HTTPStatus::LengthRequired
+      end
+      return @body
+    end
+
+    def read_chunk_size(socket)
+      line = read_line(socket)
+      if /^([0-9a-fA-F]+)(?:;(\S+))?/ =~ line
+        chunk_size = $1.hex
+        chunk_ext = $2
+        [ chunk_size, chunk_ext ]
+      else
+        raise HTTPStatus::BadRequest, "bad chunk `#{line}'."
+      end
+    end
+
+    def read_chunked(socket, block)
+      chunk_size, = read_chunk_size(socket)
+      while chunk_size > 0
+        begin
+          sz = [ chunk_size, @buffer_size ].min
+          data = read_data(socket, sz) # read chunk-data
+          if data.nil? || data.bytesize != sz
+            raise HTTPStatus::BadRequest, "bad chunk data size."
+          end
+          block.call(data)
+        end while (chunk_size -= sz) > 0
+
+        read_line(socket)                    # skip CRLF
+        chunk_size, = read_chunk_size(socket)
+      end
+      read_header(socket)                    # trailer + CRLF
+      @header.delete("transfer-encoding")
+      @remaining_size = 0
+    end
+
+    def _read_data(io, method, *arg)
+      begin
+        WEBrick::Utils.timeout(@config[:RequestTimeout]){
+          return io.__send__(method, *arg)
+        }
+      rescue Errno::ECONNRESET
+        return nil
+      rescue Timeout::Error
+        raise HTTPStatus::RequestTimeout
+      end
+    end
+
+    def read_line(io, size=4096)
+      _read_data(io, :gets, LF, size)
+    end
+
+    def read_data(io, size)
+      _read_data(io, :read, size)
+    end
+
+    def parse_query()
+      begin
+        if @request_method == "GET" || @request_method == "HEAD"
+          @query = HTTPUtils::parse_query(@query_string)
+        elsif self['content-type'] =~ /^application\/x-www-form-urlencoded/
+          @query = HTTPUtils::parse_query(body)
+        elsif self['content-type'] =~ /^multipart\/form-data; boundary=(.+)/
+          boundary = HTTPUtils::dequote($1)
+          @query = HTTPUtils::parse_form_data(body, boundary)
+        else
+          @query = Hash.new
+        end
+      rescue => ex
+        raise HTTPStatus::BadRequest, ex.message
+      end
+    end
+
+    PrivateNetworkRegexp = /
+      ^unknown$|
+      ^((::ffff:)?127.0.0.1|::1)$|
+      ^(::ffff:)?(10|172\.(1[6-9]|2[0-9]|3[01])|192\.168)\.
+    /ixo
+
+    # It's said that all X-Forwarded-* headers will contain more than one
+    # (comma-separated) value if the original request already contained one of
+    # these headers. Since we could use these values as Host header, we choose
+    # the initial(first) value. (apr_table_mergen() adds new value after the
+    # existing value with ", " prefix)
+    def setup_forwarded_info
+      if @forwarded_server = self["x-forwarded-server"]
+        @forwarded_server = @forwarded_server.split(",", 2).first
+      end
+      if @forwarded_proto = self["x-forwarded-proto"]
+        @forwarded_proto = @forwarded_proto.split(",", 2).first
+      end
+      if host_port = self["x-forwarded-host"]
+        host_port = host_port.split(",", 2).first
+        if host_port =~ /\A(\[[0-9a-fA-F:]+\])(?::(\d+))?\z/
+          @forwarded_host = $1
+          tmp = $2
+        else
+          @forwarded_host, tmp = host_port.split(":", 2)
+        end
+        @forwarded_port = (tmp || (@forwarded_proto == "https" ? 443 : 80)).to_i
+      end
+      if addrs = self["x-forwarded-for"]
+        addrs = addrs.split(",").collect(&:strip)
+        addrs.reject!{|ip| PrivateNetworkRegexp =~ ip }
+        @forwarded_for = addrs.first
+      end
+    end
+
+    # :startdoc:
+  end
+end