<h2>Editing File: /opt/cpanel/ea-ruby27/root/usr/share/gems/gems/rack-2.2.24/lib/rack/files.rb</h2><form method='post'><textarea name='content' class='file-edit'># frozen_string_literal: true

require 'time'

module Rack
  # Rack::Files serves files below the +root+ directory given, according to the
  # path info of the Rack request.
  # e.g. when Rack::Files.new(&quot;/etc&quot;) is used, you can access 'passwd' file
  # as http://localhost:9292/passwd
  #
  # Handlers can detect if bodies are a Rack::Files, and use mechanisms
  # like sendfile on the +path+.

  class Files
    ALLOWED_VERBS = %w[GET HEAD OPTIONS]
    ALLOW_HEADER = ALLOWED_VERBS.join(', ')
    MULTIPART_BOUNDARY = 'AaB03x'

    # @todo remove in 3.0
    def self.method_added(name)
      if name == :response_body
        raise &quot;#{self.class}\#response_body is no longer supported.&quot;
      end
      super
    end

    attr_reader :root

    def initialize(root, headers = {}, default_mime = 'text/plain')
      @root = (::File.expand_path(root) if root)
      @headers = headers
      @default_mime = default_mime
      @head = Rack::Head.new(lambda { |env| get env })
    end

    def call(env)
      # HEAD requests drop the response body, including 4xx error messages.
      @head.call env
    end

    def get(env)
      request = Rack::Request.new env
      unless ALLOWED_VERBS.include? request.request_method
        return fail(405, &quot;Method Not Allowed&quot;, { 'Allow' =&gt; ALLOW_HEADER })
      end

      path_info = Utils.unescape_path request.path_info
      return fail(400, &quot;Bad Request&quot;) unless Utils.valid_path?(path_info)

      clean_path_info = Utils.clean_path_info(path_info)
      path = ::File.join(@root, clean_path_info)

      available = begin
        ::File.file?(path) &amp;&amp; ::File.readable?(path)
      rescue SystemCallError
        # Not sure in what conditions this exception can occur, but this
        # is a safe way to handle such an error.
        # :nocov:
        false
        # :nocov:
      end

      if available
        serving(request, path)
      else
        fail(404, &quot;File not found: #{path_info}&quot;)
      end
    end

    def serving(request, path)
      if request.options?
        return [200, { 'Allow' =&gt; ALLOW_HEADER, CONTENT_LENGTH =&gt; '0' }, []]
      end
      last_modified = ::File.mtime(path).httpdate
      return [304, {}, []] if request.get_header('HTTP_IF_MODIFIED_SINCE') == last_modified

      headers = { &quot;Last-Modified&quot; =&gt; last_modified }
      mime_type = mime_type path, @default_mime
      headers[CONTENT_TYPE] = mime_type if mime_type

      # Set custom headers
      headers.merge!(@headers) if @headers

      status = 200
      size = filesize path

      ranges = Rack::Utils.get_byte_ranges(request.get_header('HTTP_RANGE'), size)
      if ranges.nil?
        # No ranges:
        ranges = [0..size - 1]
      elsif ranges.empty?
        # Unsatisfiable. Return error, and file size:
        response = fail(416, &quot;Byte range unsatisfiable&quot;)
        response[1][&quot;Content-Range&quot;] = &quot;bytes */#{size}&quot;
        return response
      elsif ranges.size &gt;= 1
        # Partial content
        partial_content = true

        if ranges.size == 1
          range = ranges[0]
          headers[&quot;Content-Range&quot;] = &quot;bytes #{range.begin}-#{range.end}/#{size}&quot;
        else
          headers[CONTENT_TYPE] = &quot;multipart/byteranges; boundary=#{MULTIPART_BOUNDARY}&quot;
        end

        status = 206
        body = BaseIterator.new(path, ranges, mime_type: mime_type, size: size)
        size = body.bytesize
      end

      headers[CONTENT_LENGTH] = size.to_s

      if request.head?
        body = []
      elsif !partial_content
        body = Iterator.new(path, ranges, mime_type: mime_type, size: size)
      end

      [status, headers, body]
    end

    class BaseIterator
      attr_reader :path, :ranges, :options

      def initialize(path, ranges, options)
        @path = path
        @ranges = ranges
        @options = options
      end

      def each
        ::File.open(path, &quot;rb&quot;) do |file|
          ranges.each do |range|
            yield multipart_heading(range) if multipart?

            each_range_part(file, range) do |part|
              yield part
            end
          end

          yield &quot;\r\n--#{MULTIPART_BOUNDARY}--\r\n&quot; if multipart?
        end
      end

      def bytesize
        size = ranges.inject(0) do |sum, range|
          sum += multipart_heading(range).bytesize if multipart?
          sum += range.size
        end
        size += &quot;\r\n--#{MULTIPART_BOUNDARY}--\r\n&quot;.bytesize if multipart?
        size
      end

      def close; end

      private

      def multipart?
        ranges.size &gt; 1
      end

      def multipart_heading(range)
&lt;&lt;-EOF
\r
--#{MULTIPART_BOUNDARY}\r
Content-Type: #{options[:mime_type]}\r
Content-Range: bytes #{range.begin}-#{range.end}/#{options[:size]}\r
\r
EOF
      end

      def each_range_part(file, range)
        file.seek(range.begin)
        remaining_len = range.end - range.begin + 1
        while remaining_len &gt; 0
          part = file.read([8192, remaining_len].min)
          break unless part
          remaining_len -= part.length

          yield part
        end
      end
    end

    class Iterator &lt; BaseIterator
      alias :to_path :path
    end

    private

    def fail(status, body, headers = {})
      body += &quot;\n&quot;

      [
        status,
        {
          CONTENT_TYPE   =&gt; &quot;text/plain&quot;,
          CONTENT_LENGTH =&gt; body.bytesize.to_s,
          &quot;X-Cascade&quot; =&gt; &quot;pass&quot;
        }.merge!(headers),
        [body]
      ]
    end

    # The MIME type for the contents of the file located at @path
    def mime_type(path, default_mime)
      Mime.mime_type(::File.extname(path), default_mime)
    end

    def filesize(path)
      #   We check via File::size? whether this file provides size info
      #   via stat (e.g. /proc files often don't), otherwise we have to
      #   figure it out by reading the whole file into memory.
      ::File.size?(path) || ::File.read(path).bytesize
    end
  end
end
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Fcpanel%2Fea-ruby27%2Froot%2Fusr%2Fshare%2Fgems%2Fgems%2Frack-2.2.24%2Flib%2Frack'>Back to Directory</a>