Module: Rack::Utils

# File 'lib/rack/utils.rb', line 65

attr_accessor :multipart_file_limit

# File 'lib/rack/utils.rb', line 69

alias multipart_part_limit multipart_file_limit

# File 'lib/rack/utils.rb', line 63

attr_accessor :multipart_total_part_limit

# File 'lib/rack/utils.rb', line 82

def self.param_depth_limit
  default_query_parser.param_depth_limit
end

# File 'lib/rack/utils.rb', line 86

def self.param_depth_limit=(v)
  self.default_query_parser = self.default_query_parser.new_depth_limit(v)
end

# File 'lib/rack/utils.rb', line 120

def build_nested_query(value, prefix = nil)
  case value
  when Array
    value.map { |v|
      build_nested_query(v, "#{prefix}[]")
    }.join("&")
  when Hash
    value.map { |k, v|
      build_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
    }.delete_if(&:empty?).join('&')
  when nil
    escape(prefix)
  else
    raise ArgumentError, "value must be a Hash" if prefix.nil?
    "#{escape(prefix)}=#{escape(value)}"
  end
end

# File 'lib/rack/utils.rb', line 110

def build_query(params)
  params.map { |k, v|
    if v.class == Array
      build_query(v.map { |x| [k, x] })
    else
      v.nil? ? escape(k) : "#{escape(k)}=#{escape(v)}"
    end
  }.join("&")
end

# File 'lib/rack/utils.rb', line 492

def byte_ranges(env, size, max_ranges: 100)
  get_byte_ranges env['HTTP_RANGE'], size, max_ranges: max_ranges
end

# File 'lib/rack/utils.rb', line 692

def clean_path_info(path_info)
  parts = path_info.split PATH_SEPS

  clean = []

  parts.each do |part|
    next if part.empty? || part == '.'
    part == '..' ? clean.pop : clean << part
  end

  clean_path = clean.join(::File::SEPARATOR)
  clean_path.prepend("/") if parts.empty? || parts.first.empty?
  clean_path
end

# File 'lib/rack/utils.rb', line 96

def clock_time
  Process.clock_gettime(Process::CLOCK_MONOTONIC)
end

# File 'lib/rack/utils.rb', line 450

def delete_cookie_header!(headers, key, value = {})
  headers[SET_COOKIE] = delete_set_cookie_header!(headers[SET_COOKIE], key, value)

  return nil
end

# File 'lib/rack/utils.rb', line 446

def delete_set_cookie_header(key, value = {})
  set_cookie_header(key, value.merge(max_age: '0', expires: Time.at(0), value: ''))
end

# File 'lib/rack/utils.rb', line 474

def delete_set_cookie_header!(header, key, value = {})
  if header
    header = Array(header)
    header << delete_set_cookie_header(key, value)
  else
    header = delete_set_cookie_header(key, value)
  end

  return header
end

# File 'lib/rack/utils.rb', line 40

def escape(s)
  URI.encode_www_form_component(s)
end

# File 'lib/rack/utils.rb', line 250

def escape_html(string)
  CGI.escapeHTML(string.to_s)
end

# File 'lib/rack/utils.rb', line 46

def escape_path(s)
  URI_PARSER.escape s
end

# File 'lib/rack/utils.rb', line 152

def forwarded_values(forwarded_header)
  return unless forwarded_header
  header = forwarded_header.to_s.tr("\n", ";")
  header.sub!(/\A[\s;,]+/, '')
  num_params = num_escapes = 0
  max_params = max_escapes = 1024
  params = {}

  # Parse parameter list
  while i = header.index('=')
    # Only parse up to max parameters, to avoid potential denial of service
    num_params += 1
    return if num_params > max_params

    # Found end of parameter name, ensure forward progress in loop
    param = header.slice!(0, i+1)

    # Remove ending equals and preceding whitespace from parameter name
    param.chomp!('=')
    param.strip!
    param.downcase!
    return unless param = ALLOWED_FORWARDED_PARAMS[param]

    if header[0] == '"'
      # Parameter value is quoted, parse it, handling backslash escapes
      header.slice!(0, 1)
      value = String.new

      while i = header.index(/(["\\])/)
        c = $1

        # Append all content until ending quote or escape
        value << header.slice!(0, i)

        # Remove either backslash or ending quote,
        # ensures forward progress in loop
        header.slice!(0, 1)

        # stop parsing parameter value if found ending quote
        break if c == '"'

        # Only allow up to max escapes, to avoid potential denial of service
        num_escapes += 1
        return if num_escapes > max_escapes
        escaped_char = header.slice!(0, 1)
        value << escaped_char
      end
    else
      if i = header.index(/[;,]/)
        # Parameter value unquoted (which may be invalid), value ends at comma or semicolon
        value = header.slice!(0, i)
        value.sub!(/[\s;,]+\z/, '')
      else
        # If no ending semicolon, assume remainder of line is value and stop parsing
        header.strip!
        value = header
        header = ''
      end
      value.lstrip!
    end

    (params[param] ||= []) << value

    # skip trailing semicolons/commas/whitespace, to proceed to next parameter
    header.sub!(/\A[\s;,]+/, '') unless header.empty?
  end

  params
end

# File 'lib/rack/utils.rb', line 496

def get_byte_ranges(http_range, size, max_ranges: 100)
  # See <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35>
  # Ignore Range when file size is 0 to avoid a 416 error.
  return nil if size.zero?
  return nil unless http_range && http_range =~ /bytes=([^;]+)/
  byte_range = $1
  return nil if byte_range.count(',') >= max_ranges
  ranges = []
  byte_range.split(/,[ \t]*/).each do |range_spec|
    return nil unless range_spec.include?('-')
    range = range_spec.split('-')
    r0, r1 = range[0], range[1]
    if r0.nil? || r0.empty?
      return nil if r1.nil?
      # suffix-byte-range-spec, represents trailing suffix of file
      r0 = size - r1.to_i
      r0 = 0  if r0 < 0
      r1 = size - 1
    else
      r0 = r0.to_i
      if r1.nil?
        r1 = size - 1
      else
        r1 = r1.to_i
        return nil  if r1 < r0  # backwards range is syntactically invalid
        r1 = size - 1  if r1 >= size
      end
    end
    ranges << (r0..r1)  if r0 <= r1
  end

  return [] if ranges.map(&:size).sum > size

  ranges
end

# File 'lib/rack/utils.rb', line 347

def parse_cookies(env)
  parse_cookies_header env[HTTP_COOKIE]
end

# File 'lib/rack/utils.rb', line 328

def parse_cookies_header(value)
  return {} unless value

  value.split(/; */n).each_with_object({}) do |cookie, cookies|
    next if cookie.empty?
    key, value = cookie.split('=', 2)
    cookies[key] = (unescape(value) rescue value) unless cookies.key?(key)
  end
end

# File 'lib/rack/utils.rb', line 106

def parse_nested_query(qs, d = nil)
  Rack::Utils.default_query_parser.parse_nested_query(qs, d)
end

# File 'lib/rack/utils.rb', line 102

def parse_query(qs, d = nil, &unescaper)
  Rack::Utils.default_query_parser.parse_query(qs, d, &unescaper)
end

# File 'lib/rack/utils.rb', line 138

def q_values(q_value_header)
  q_value_header.to_s.split(',').map do |part|
    value, parameters = part.split(';', 2).map(&:strip)
    quality = 1.0
    if parameters && (md = /\Aq=([\d.]+)/.match(parameters))
      quality = md[1].to_f
    end
    [value, quality]
  end
end

# File 'lib/rack/utils.rb', line 485

def rfc2822(time)
  time.rfc2822
end

# File 'lib/rack/utils.rb', line 547

def secure_compare(a, b)
  return false unless a.bytesize == b.bytesize

  OpenSSL.fixed_length_secure_compare(a, b)
end

# File 'lib/rack/utils.rb', line 274

def select_best_encoding(available_encodings, accept_encoding)
  # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html

  # Only process the first 16 encodings
  accept_encoding = accept_encoding[0...16]
  expanded_accept_encoding = []
  wildcard_seen = false

  accept_encoding.each do |m, q|
    preference = available_encodings.index(m) || available_encodings.size

    if m == "*"
      unless wildcard_seen
        (available_encodings - accept_encoding.map(&:first)).each do |m2|
          expanded_accept_encoding << [m2, q, preference]
        end
        wildcard_seen = true
      end
    else
      expanded_accept_encoding << [m, q, preference]
    end
  end

  encoding_candidates = expanded_accept_encoding
    .sort do |(_, q1, p1), (_, q2, p2)|
      if r = (q1 <=> q2).nonzero?
        -r
      else
        (p1 <=> p2).nonzero? || 0
      end
    end
    .map!(&:first)

  unless encoding_candidates.include?("identity")
    encoding_candidates.push("identity")
  end

  expanded_accept_encoding.each do |m, q|
    encoding_candidates.delete(m) if q == 0.0
  end

  (encoding_candidates & available_encodings)[0]
end

# File 'lib/rack/utils.rb', line 376

def set_cookie_header(key, value)
  unless key =~ VALID_COOKIE_KEY
    raise ArgumentError, "invalid cookie key: #{key.inspect}"
  end

  case value
  when Hash
    domain  = "; domain=#{value[:domain]}"   if value[:domain]
    path    = "; path=#{value[:path]}"       if value[:path]
    max_age = "; max-age=#{value[:max_age]}" if value[:max_age]
    expires = "; expires=#{value[:expires].httpdate}" if value[:expires]
    secure = "; secure"  if value[:secure]
    httponly = "; httponly" if (value.key?(:httponly) ? value[:httponly] : value[:http_only])
    same_site =
      case value[:same_site]
      when false, nil
        nil
      when :none, 'None', :None
        '; samesite=none'
      when :lax, 'Lax', :Lax
        '; samesite=lax'
      when true, :strict, 'Strict', :Strict
        '; samesite=strict'
      else
        raise ArgumentError, "Invalid :same_site value: #{value[:same_site].inspect}"
      end
    partitioned = "; partitioned" if value[:partitioned]
    value = value[:value]
  end

  value = [value] unless Array === value

  return "#{key}=#{value.map { |v| escape v }.join('&')}#{domain}" \
    "#{path}#{max_age}#{expires}#{secure}#{httponly}#{same_site}#{partitioned}"
end

# File 'lib/rack/utils.rb', line 420

def set_cookie_header!(headers, key, value)
  if header = headers[SET_COOKIE]
    if header.is_a?(Array)
      header << set_cookie_header(key, value)
    else
      headers[SET_COOKIE] = [header, set_cookie_header(key, value)]
    end
  else
    headers[SET_COOKIE] = set_cookie_header(key, value)
  end
end

# File 'lib/rack/utils.rb', line 674

def status_code(status)
  if status.is_a?(Symbol)
    SYMBOL_TO_STATUS_CODE.fetch(status) do
      fallback_code = OBSOLETE_SYMBOLS_TO_STATUS_CODES.fetch(status) { raise ArgumentError, "Unrecognized status code #{status.inspect}" }
      message = "Status code #{status.inspect} is deprecated and will be removed in a future version of Rack."
      if canonical_symbol = OBSOLETE_SYMBOL_MAPPINGS[status]
        message = "#{message} Please use #{canonical_symbol.inspect} instead."
      end
      warn message, uplevel: 3
      fallback_code
    end
  else
    status.to_i
  end
end

# File 'lib/rack/utils.rb', line 58

def unescape(s, encoding = Encoding::UTF_8)
  URI.decode_www_form_component(s, encoding)
end

# File 'lib/rack/utils.rb', line 52

def unescape_path(s)
  URI_PARSER.unescape s
end

# File 'lib/rack/utils.rb', line 709

def valid_path?(path)
  path.valid_encoding? && !path.include?(NULL_BYTE)
end