rack 1.0.1 → 2.2.21

data/lib/rack/files.rb

@@ -0,0 +1,218 @@
+# 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("/etc") 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 "#{self.class}\#response_body is no longer supported."
+      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, "Method Not Allowed", { 'Allow' => ALLOW_HEADER })
+      end
+
+      path_info = Utils.unescape_path request.path_info
+      return fail(400, "Bad Request") 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) && ::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, "File not found: #{path_info}")
+      end
+    end
+
+    def serving(request, path)
+      if request.options?
+        return [200, { 'Allow' => ALLOW_HEADER, CONTENT_LENGTH => '0' }, []]
+      end
+      last_modified = ::File.mtime(path).httpdate
+      return [304, {}, []] if request.get_header('HTTP_IF_MODIFIED_SINCE') == last_modified
+
+      headers = { "Last-Modified" => 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, "Byte range unsatisfiable")
+        response[1]["Content-Range"] = "bytes */#{size}"
+        return response
+      elsif ranges.size >= 1
+        # Partial content
+        partial_content = true
+
+        if ranges.size == 1
+          range = ranges[0]
+          headers["Content-Range"] = "bytes #{range.begin}-#{range.end}/#{size}"
+        else
+          headers[CONTENT_TYPE] = "multipart/byteranges; boundary=#{MULTIPART_BOUNDARY}"
+        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, "rb") do |file|
+          ranges.each do |range|
+            yield multipart_heading(range) if multipart?
+
+            each_range_part(file, range) do |part|
+              yield part
+            end
+          end
+
+          yield "\r\n--#{MULTIPART_BOUNDARY}--\r\n" 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 += "\r\n--#{MULTIPART_BOUNDARY}--\r\n".bytesize if multipart?
+        size
+      end
+
+      def close; end
+
+      private
+
+      def multipart?
+        ranges.size > 1
+      end
+
+      def multipart_heading(range)
+<<-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 > 0
+          part = file.read([8192, remaining_len].min)
+          break unless part
+          remaining_len -= part.length
+
+          yield part
+        end
+      end
+    end
+
+    class Iterator < BaseIterator
+      alias :to_path :path
+    end
+
+    private
+
+    def fail(status, body, headers = {})
+      body += "\n"
+
+      [
+        status,
+        {
+          CONTENT_TYPE   => "text/plain",
+          CONTENT_LENGTH => body.size.to_s,
+          "X-Cascade" => "pass"
+        }.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

data/lib/rack/handler/cgi.rb

@@ -1,34 +1,32 @@
-require 'rack/content_length'
+# frozen_string_literal: true
 
 module Rack
   module Handler
     class CGI
-      def self.run(app, options=nil)
+      def self.run(app, **options)
+        $stdin.binmode
         serve app
       end
 
       def self.serve(app)
-        app = ContentLength.new(app)
-
         env = ENV.to_hash
         env.delete "HTTP_CONTENT_LENGTH"
 
-        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
-
-        env.update({"rack.version" => [1,0],
-                     "rack.input" => $stdin,
-                     "rack.errors" => $stderr,
-
-                     "rack.multithread" => false,
-                     "rack.multiprocess" => true,
-                     "rack.run_once" => true,
+        env[SCRIPT_NAME] = ""  if env[SCRIPT_NAME] == "/"
 
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
-                   })
+        env.update(
+          RACK_VERSION      => Rack::VERSION,
+          RACK_INPUT        => Rack::RewindableInput.new($stdin),
+          RACK_ERRORS       => $stderr,
+          RACK_MULTITHREAD  => false,
+          RACK_MULTIPROCESS => true,
+          RACK_RUNONCE      => true,
+          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
+        )
 
-        env["QUERY_STRING"] ||= ""
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["REQUEST_PATH"] ||= "/"
+        env[QUERY_STRING] ||= ""
+        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
+        env[REQUEST_PATH] ||= "/"
 
         status, headers, body = app.call(env)
         begin
@@ -40,20 +38,20 @@ module Rack
       end
 
       def self.send_headers(status, headers)
-        STDOUT.print "Status: #{status}\r\n"
+        $stdout.print "Status: #{status}\r\n"
         headers.each { |k, vs|
           vs.split("\n").each { |v|
-            STDOUT.print "#{k}: #{v}\r\n"
+            $stdout.print "#{k}: #{v}\r\n"
           }
         }
-        STDOUT.print "\r\n"
-        STDOUT.flush
+        $stdout.print "\r\n"
+        $stdout.flush
       end
 
       def self.send_body(body)
         body.each { |part|
-          STDOUT.print part
-          STDOUT.flush
+          $stdout.print part
+          $stdout.flush
         }
       end
     end

data/lib/rack/handler/fastcgi.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 require 'fcgi'
 require 'socket'
-require 'rack/content_length'
-require 'rack/rewindable_input'
 
 if defined? FCGI::Stream
   class FCGI::Stream
     alias _rack_read_without_buffer read
 
-    def read(n, buffer=nil)
+    def read(n, buffer = nil)
       buf = _rack_read_without_buffer n
       buffer.replace(buf.to_s)  if buffer
       buf
@@ -18,39 +18,49 @@ end
 module Rack
   module Handler
     class FastCGI
-      def self.run(app, options={})
-        file = options[:File] and STDIN.reopen(UNIXServer.new(file))
-        port = options[:Port] and STDIN.reopen(TCPServer.new(port))
+      def self.run(app, **options)
+        if options[:File]
+          STDIN.reopen(UNIXServer.new(options[:File]))
+        elsif options[:Port]
+          STDIN.reopen(TCPServer.new(options[:Host], options[:Port]))
+        end
         FCGI.each { |request|
           serve request, app
         }
       end
 
-      def self.serve(request, app)
-        app = Rack::ContentLength.new(app)
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+          "File=PATH" => "Creates a Domain socket at PATH instead of a TCP socket. Ignores Host and Port if set.",
+        }
+      end
 
+      def self.serve(request, app)
         env = request.env
         env.delete "HTTP_CONTENT_LENGTH"
 
-        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
-        
-        rack_input = RewindableInput.new(request.in)
+        env[SCRIPT_NAME] = ""  if env[SCRIPT_NAME] == "/"
 
-        env.update({"rack.version" => [1,0],
-                     "rack.input" => rack_input,
-                     "rack.errors" => request.err,
-
-                     "rack.multithread" => false,
-                     "rack.multiprocess" => true,
-                     "rack.run_once" => false,
+        rack_input = RewindableInput.new(request.in)
 
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
-                   })
+        env.update(
+          RACK_VERSION      => Rack::VERSION,
+          RACK_INPUT        => rack_input,
+          RACK_ERRORS       => request.err,
+          RACK_MULTITHREAD  => false,
+          RACK_MULTIPROCESS => true,
+          RACK_RUNONCE      => false,
+          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http"
+        )
 
-        env["QUERY_STRING"] ||= ""
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["REQUEST_PATH"] ||= "/"
-        env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
+        env[QUERY_STRING] ||= ""
+        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
+        env[REQUEST_PATH] ||= "/"
         env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
         env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
 

data/lib/rack/handler/lsws.rb

@@ -1,36 +1,35 @@
+# frozen_string_literal: true
+
 require 'lsapi'
-require 'rack/content_length'
 
 module Rack
   module Handler
     class LSWS
-      def self.run(app, options=nil)
+      def self.run(app, **options)
         while LSAPI.accept != nil
           serve app
         end
       end
       def self.serve(app)
-        app = Rack::ContentLength.new(app)
-
         env = ENV.to_hash
         env.delete "HTTP_CONTENT_LENGTH"
-        env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
+        env[SCRIPT_NAME] = "" if env[SCRIPT_NAME] == "/"
 
         rack_input = RewindableInput.new($stdin.read.to_s)
 
         env.update(
-          "rack.version" => [1,0],
-          "rack.input" => rack_input,
-          "rack.errors" => $stderr,
-          "rack.multithread" => false,
-          "rack.multiprocess" => true,
-          "rack.run_once" => false,
-          "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+          RACK_VERSION      => Rack::VERSION,
+          RACK_INPUT        => rack_input,
+          RACK_ERRORS       => $stderr,
+          RACK_MULTITHREAD  => false,
+          RACK_MULTIPROCESS => true,
+          RACK_RUNONCE      => false,
+          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
         )
 
-        env["QUERY_STRING"] ||= ""
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["REQUEST_PATH"] ||= "/"
+        env[QUERY_STRING] ||= ""
+        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
+        env[REQUEST_PATH] ||= "/"
         status, headers, body = app.call(env)
         begin
           send_headers status, headers
@@ -38,6 +37,8 @@ module Rack
         ensure
           body.close if body.respond_to? :close
         end
+      ensure
+        rack_input.close
       end
       def self.send_headers(status, headers)
         print "Status: #{status}\r\n"

data/lib/rack/handler/scgi.rb

@@ -1,50 +1,59 @@
+# frozen_string_literal: true
+
 require 'scgi'
 require 'stringio'
-require 'rack/content_length'
-require 'rack/chunked'
 
 module Rack
   module Handler
     class SCGI < ::SCGI::Processor
       attr_accessor :app
-      
-      def self.run(app, options=nil)
-        new(options.merge(:app=>app,
-                          :host=>options[:Host],
-                          :port=>options[:Port],
-                          :socket=>options[:Socket])).listen
+
+      def self.run(app, **options)
+        options[:Socket] = UNIXServer.new(options[:File]) if options[:File]
+        new(options.merge(app: app,
+                          host: options[:Host],
+                          port: options[:Port],
+                          socket: options[:Socket])).listen
       end
-      
+
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
+
       def initialize(settings = {})
-        @app = Rack::Chunked.new(Rack::ContentLength.new(settings[:app]))
-        @log = Object.new
-        def @log.info(*args); end
-        def @log.error(*args); end
+        @app = settings[:app]
         super(settings)
       end
-        
+
       def process_request(request, input_body, socket)
-        env = {}.replace(request)
+        env = Hash[request]
         env.delete "HTTP_CONTENT_TYPE"
         env.delete "HTTP_CONTENT_LENGTH"
-        env["REQUEST_PATH"], env["QUERY_STRING"] = env["REQUEST_URI"].split('?', 2)
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["PATH_INFO"] = env["REQUEST_PATH"]
-        env["QUERY_STRING"] ||= ""
-        env["SCRIPT_NAME"] = ""
+        env[REQUEST_PATH], env[QUERY_STRING] = env["REQUEST_URI"].split('?', 2)
+        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
+        env[PATH_INFO] = env[REQUEST_PATH]
+        env[QUERY_STRING] ||= ""
+        env[SCRIPT_NAME] = ""
 
         rack_input = StringIO.new(input_body)
-        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
+        rack_input.set_encoding(Encoding::BINARY)
 
-        env.update({"rack.version" => [1,0],
-                     "rack.input" => rack_input,
-                     "rack.errors" => $stderr,
-                     "rack.multithread" => true,
-                     "rack.multiprocess" => true,
-                     "rack.run_once" => false,
+        env.update(
+          RACK_VERSION      => Rack::VERSION,
+          RACK_INPUT        => rack_input,
+          RACK_ERRORS       => $stderr,
+          RACK_MULTITHREAD  => true,
+          RACK_MULTIPROCESS => true,
+          RACK_RUNONCE      => false,
+          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http"
+        )
 
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
-                   })
         status, headers, body = app.call(env)
         begin
           socket.write("Status: #{status}\r\n")

data/lib/rack/handler/thin.rb

@@ -1,18 +1,34 @@
+# frozen_string_literal: true
+
 require "thin"
-require "rack/content_length"
-require "rack/chunked"
+require "thin/server"
+require "thin/logging"
+require "thin/backends/tcp_server"
 
 module Rack
   module Handler
     class Thin
-      def self.run(app, options={})
-        app = Rack::Chunked.new(Rack::ContentLength.new(app))
-        server = ::Thin::Server.new(options[:Host] || '0.0.0.0',
-                                    options[:Port] || 8080,
-                                    app)
+      def self.run(app, **options)
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        host = options.delete(:Host) || default_host
+        port = options.delete(:Port) || 8080
+        args = [host, port, app, options]
+        server = ::Thin::Server.new(*args)
         yield server if block_given?
         server.start
       end
+
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
     end
   end
 end