sprokovuln 0.2.0

data/vendor/ruby/gems/rack-2.0.5/lib/rack/response.rb

@@ -0,0 +1,235 @@
+require 'rack/request'
+require 'rack/utils'
+require 'rack/body_proxy'
+require 'rack/media_type'
+require 'time'
+
+module Rack
+  # Rack::Response provides a convenient interface to create a Rack
+  # response.
+  #
+  # It allows setting of headers and cookies, and provides useful
+  # defaults (an OK response with empty headers and body).
+  #
+  # You can use Response#write to iteratively generate your response,
+  # but note that this is buffered by Rack::Response until you call
+  # +finish+.  +finish+ however can take a block inside which calls to
+  # +write+ are synchronous with the Rack response.
+  #
+  # Your application's +call+ should end returning Response#finish.
+
+  class Response
+    attr_accessor :length, :status, :body
+    attr_reader :header
+    alias headers header
+
+    CHUNKED = 'chunked'.freeze
+
+    def initialize(body=[], status=200, header={})
+      @status = status.to_i
+      @header = Utils::HeaderHash.new.merge(header)
+
+      @writer  = lambda { |x| @body << x }
+      @block   = nil
+      @length  = 0
+
+      @body = []
+
+      if body.respond_to? :to_str
+        write body.to_str
+      elsif body.respond_to?(:each)
+        body.each { |part|
+          write part.to_s
+        }
+      else
+        raise TypeError, "stringable or iterable required"
+      end
+
+      yield self  if block_given?
+    end
+
+    def redirect(target, status=302)
+      self.status = status
+      self.location = target
+    end
+
+    def chunked?
+      CHUNKED == get_header(TRANSFER_ENCODING)
+    end
+
+    def finish(&block)
+      @block = block
+
+      if [204, 304].include?(status.to_i)
+        delete_header CONTENT_TYPE
+        delete_header CONTENT_LENGTH
+        close
+        [status.to_i, header, []]
+      else
+        [status.to_i, header, BodyProxy.new(self){}]
+      end
+    end
+    alias to_a finish           # For *response
+    alias to_ary finish         # For implicit-splat on Ruby 1.9.2
+
+    def each(&callback)
+      @body.each(&callback)
+      @writer = callback
+      @block.call(self)  if @block
+    end
+
+    # Append to body and update Content-Length.
+    #
+    # NOTE: Do not mix #write and direct #body access!
+    #
+    def write(str)
+      s = str.to_s
+      @length += s.bytesize unless chunked?
+      @writer.call s
+
+      set_header(CONTENT_LENGTH, @length.to_s) unless chunked?
+      str
+    end
+
+    def close
+      body.close if body.respond_to?(:close)
+    end
+
+    def empty?
+      @block == nil && @body.empty?
+    end
+
+    def has_header?(key);   headers.key? key;   end
+    def get_header(key);    headers[key];       end
+    def set_header(key, v); headers[key] = v;   end
+    def delete_header(key); headers.delete key; end
+
+    alias :[] :get_header
+    alias :[]= :set_header
+
+    module Helpers
+      def invalid?;             status < 100 || status >= 600;        end
+
+      def informational?;       status >= 100 && status < 200;        end
+      def successful?;          status >= 200 && status < 300;        end
+      def redirection?;         status >= 300 && status < 400;        end
+      def client_error?;        status >= 400 && status < 500;        end
+      def server_error?;        status >= 500 && status < 600;        end
+
+      def ok?;                  status == 200;                        end
+      def created?;             status == 201;                        end
+      def accepted?;            status == 202;                        end
+      def no_content?;          status == 204;                        end
+      def moved_permanently?;   status == 301;                        end
+      def bad_request?;         status == 400;                        end
+      def unauthorized?;        status == 401;                        end
+      def forbidden?;           status == 403;                        end
+      def not_found?;           status == 404;                        end
+      def method_not_allowed?;  status == 405;                        end
+      def precondition_failed?; status == 412;                        end
+      def unprocessable?;       status == 422;                        end
+
+      def redirect?;            [301, 302, 303, 307, 308].include? status; end
+
+      def include?(header)
+        has_header? header
+      end
+
+      # Add a header that may have multiple values.
+      #
+      # Example:
+      #   response.add_header 'Vary', 'Accept-Encoding'
+      #   response.add_header 'Vary', 'Cookie'
+      #
+      #   assert_equal 'Accept-Encoding,Cookie', response.get_header('Vary')
+      #
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+      def add_header key, v
+        if v.nil?
+          get_header key
+        elsif has_header? key
+          set_header key, "#{get_header key},#{v}"
+        else
+          set_header key, v
+        end
+      end
+
+      def content_type
+        get_header CONTENT_TYPE
+      end
+
+      def media_type
+        MediaType.type(content_type)
+      end
+
+      def media_type_params
+        MediaType.params(content_type)
+      end
+
+      def content_length
+        cl = get_header CONTENT_LENGTH
+        cl ? cl.to_i : cl
+      end
+
+      def location
+        get_header "Location"
+      end
+
+      def location=(location)
+        set_header "Location", location
+      end
+
+      def set_cookie(key, value)
+        cookie_header = get_header SET_COOKIE
+        set_header SET_COOKIE, ::Rack::Utils.add_cookie_to_header(cookie_header, key, value)
+      end
+
+      def delete_cookie(key, value={})
+        set_header SET_COOKIE, ::Rack::Utils.add_remove_cookie_to_header(get_header(SET_COOKIE), key, value)
+      end
+
+      def set_cookie_header
+        get_header SET_COOKIE
+      end
+
+      def set_cookie_header= v
+        set_header SET_COOKIE, v
+      end
+
+      def cache_control
+        get_header CACHE_CONTROL
+      end
+
+      def cache_control= v
+        set_header CACHE_CONTROL, v
+      end
+
+      def etag
+        get_header ETAG
+      end
+
+      def etag= v
+        set_header ETAG, v
+      end
+    end
+
+    include Helpers
+
+    class Raw
+      include Helpers
+
+      attr_reader :headers
+      attr_accessor :status
+
+      def initialize status, headers
+        @status = status
+        @headers = headers
+      end
+
+      def has_header?(key);   headers.key? key;   end
+      def get_header(key);    headers[key];       end
+      def set_header(key, v); headers[key] = v;   end
+      def delete_header(key); headers.delete key; end
+    end
+  end
+end

data/vendor/ruby/gems/rack-2.0.5/lib/rack/rewindable_input.rb

@@ -0,0 +1,93 @@
+# -*- encoding: binary -*-
+require 'tempfile'
+require 'rack/utils'
+
+module Rack
+  # Class which can make any IO object rewindable, including non-rewindable ones. It does
+  # this by buffering the data into a tempfile, which is rewindable.
+  #
+  # rack.input is required to be rewindable, so if your input stream IO is non-rewindable
+  # by nature (e.g. a pipe or a socket) then you can wrap it in an object of this class
+  # to easily make it rewindable.
+  #
+  # Don't forget to call #close when you're done. This frees up temporary resources that
+  # RewindableInput uses, though it does *not* close the original IO object.
+  class RewindableInput
+    def initialize(io)
+      @io = io
+      @rewindable_io = nil
+      @unlinked = false
+    end
+
+    def gets
+      make_rewindable unless @rewindable_io
+      @rewindable_io.gets
+    end
+
+    def read(*args)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.read(*args)
+    end
+
+    def each(&block)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.each(&block)
+    end
+
+    def rewind
+      make_rewindable unless @rewindable_io
+      @rewindable_io.rewind
+    end
+
+    # Closes this RewindableInput object without closing the originally
+    # wrapped IO oject. Cleans up any temporary resources that this RewindableInput
+    # has created.
+    #
+    # This method may be called multiple times. It does nothing on subsequent calls.
+    def close
+      if @rewindable_io
+        if @unlinked
+          @rewindable_io.close
+        else
+          @rewindable_io.close!
+        end
+        @rewindable_io = nil
+      end
+    end
+
+    private
+
+    def make_rewindable
+      # Buffer all data into a tempfile. Since this tempfile is private to this
+      # RewindableInput object, we chmod it so that nobody else can read or write
+      # it. On POSIX filesystems we also unlink the file so that it doesn't
+      # even have a file entry on the filesystem anymore, though we can still
+      # access it because we have the file handle open.
+      @rewindable_io = Tempfile.new('RackRewindableInput')
+      @rewindable_io.chmod(0000)
+      @rewindable_io.set_encoding(Encoding::BINARY) if @rewindable_io.respond_to?(:set_encoding)
+      @rewindable_io.binmode
+      if filesystem_has_posix_semantics?
+        raise 'Unlink failed. IO closed.' if @rewindable_io.closed?
+        @unlinked = true
+      end
+
+      buffer = ""
+      while @io.read(1024 * 4, buffer)
+        entire_buffer_written_out = false
+        while !entire_buffer_written_out
+          written = @rewindable_io.write(buffer)
+          entire_buffer_written_out = written == buffer.bytesize
+          if !entire_buffer_written_out
+            buffer.slice!(0 .. written - 1)
+          end
+        end
+      end
+      @rewindable_io.rewind
+    end
+
+    def filesystem_has_posix_semantics?
+      RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
+    end
+  end
+end

data/vendor/ruby/gems/rack-2.0.5/lib/rack/runtime.rb

@@ -0,0 +1,32 @@
+require 'rack/utils'
+
+module Rack
+  # Sets an "X-Runtime" response header, indicating the response
+  # time of the request, in seconds
+  #
+  # You can put it right before the application to see the processing
+  # time, or before all the other middlewares to include time for them,
+  # too.
+  class Runtime
+    FORMAT_STRING = "%0.6f".freeze # :nodoc:
+    HEADER_NAME = "X-Runtime".freeze # :nodoc:
+
+    def initialize(app, name = nil)
+      @app = app
+      @header_name = HEADER_NAME
+      @header_name += "-#{name}" if name
+    end
+
+    def call(env)
+      start_time = Utils.clock_time
+      status, headers, body = @app.call(env)
+      request_time = Utils.clock_time - start_time
+
+      unless headers.has_key?(@header_name)
+        headers[@header_name] = FORMAT_STRING % request_time
+      end
+
+      [status, headers, body]
+    end
+  end
+end

data/vendor/ruby/gems/rack-2.0.5/lib/rack/sendfile.rb

@@ -0,0 +1,158 @@
+require 'rack/file'
+require 'rack/body_proxy'
+
+module Rack
+
+  # = Sendfile
+  #
+  # The Sendfile middleware intercepts responses whose body is being
+  # served from a file and replaces it with a server specific X-Sendfile
+  # header. The web server is then responsible for writing the file contents
+  # to the client. This can dramatically reduce the amount of work required
+  # by the Ruby backend and takes advantage of the web server's optimized file
+  # delivery code.
+  #
+  # In order to take advantage of this middleware, the response body must
+  # respond to +to_path+ and the request must include an X-Sendfile-Type
+  # header. Rack::File and other components implement +to_path+ so there's
+  # rarely anything you need to do in your application. The X-Sendfile-Type
+  # header is typically set in your web servers configuration. The following
+  # sections attempt to document
+  #
+  # === Nginx
+  #
+  # Nginx supports the X-Accel-Redirect header. This is similar to X-Sendfile
+  # but requires parts of the filesystem to be mapped into a private URL
+  # hierarchy.
+  #
+  # The following example shows the Nginx configuration required to create
+  # a private "/files/" area, enable X-Accel-Redirect, and pass the special
+  # X-Sendfile-Type and X-Accel-Mapping headers to the backend:
+  #
+  #   location ~ /files/(.*) {
+  #     internal;
+  #     alias /var/www/$1;
+  #   }
+  #
+  #   location / {
+  #     proxy_redirect     off;
+  #
+  #     proxy_set_header   Host                $host;
+  #     proxy_set_header   X-Real-IP           $remote_addr;
+  #     proxy_set_header   X-Forwarded-For     $proxy_add_x_forwarded_for;
+  #
+  #     proxy_set_header   X-Sendfile-Type     X-Accel-Redirect;
+  #     proxy_set_header   X-Accel-Mapping     /var/www/=/files/;
+  #
+  #     proxy_pass         http://127.0.0.1:8080/;
+  #   }
+  #
+  # Note that the X-Sendfile-Type header must be set exactly as shown above.
+  # The X-Accel-Mapping header should specify the location on the file system,
+  # followed by an equals sign (=), followed name of the private URL pattern
+  # that it maps to. The middleware performs a simple substitution on the
+  # resulting path.
+  #
+  # See Also: http://wiki.codemongers.com/NginxXSendfile
+  #
+  # === lighttpd
+  #
+  # Lighttpd has supported some variation of the X-Sendfile header for some
+  # time, although only recent version support X-Sendfile in a reverse proxy
+  # configuration.
+  #
+  #   $HTTP["host"] == "example.com" {
+  #      proxy-core.protocol = "http"
+  #      proxy-core.balancer = "round-robin"
+  #      proxy-core.backends = (
+  #        "127.0.0.1:8000",
+  #        "127.0.0.1:8001",
+  #        ...
+  #      )
+  #
+  #      proxy-core.allow-x-sendfile = "enable"
+  #      proxy-core.rewrite-request = (
+  #        "X-Sendfile-Type" => (".*" => "X-Sendfile")
+  #      )
+  #    }
+  #
+  # See Also: http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModProxyCore
+  #
+  # === Apache
+  #
+  # X-Sendfile is supported under Apache 2.x using a separate module:
+  #
+  # https://tn123.org/mod_xsendfile/
+  #
+  # Once the module is compiled and installed, you can enable it using
+  # XSendFile config directive:
+  #
+  #   RequestHeader Set X-Sendfile-Type X-Sendfile
+  #   ProxyPassReverse / http://localhost:8001/
+  #   XSendFile on
+  #
+  # === Mapping parameter
+  #
+  # The third parameter allows for an overriding extension of the
+  # X-Accel-Mapping header. Mappings should be provided in tuples of internal to
+  # external. The internal values may contain regular expression syntax, they
+  # will be matched with case indifference.
+
+  class Sendfile
+    def initialize(app, variation=nil, mappings=[])
+      @app = app
+      @variation = variation
+      @mappings = mappings.map do |internal, external|
+        [/^#{internal}/i, external]
+      end
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      if body.respond_to?(:to_path)
+        case type = variation(env)
+        when 'X-Accel-Redirect'
+          path = ::File.expand_path(body.to_path)
+          if url = map_accel_path(env, path)
+            headers[CONTENT_LENGTH] = '0'
+            headers[type] = url
+            obody = body
+            body = Rack::BodyProxy.new([]) do
+              obody.close if obody.respond_to?(:close)
+            end
+          else
+            env[RACK_ERRORS].puts "X-Accel-Mapping header missing"
+          end
+        when 'X-Sendfile', 'X-Lighttpd-Send-File'
+          path = ::File.expand_path(body.to_path)
+          headers[CONTENT_LENGTH] = '0'
+          headers[type] = path
+          obody = body
+          body = Rack::BodyProxy.new([]) do
+            obody.close if obody.respond_to?(:close)
+          end
+        when '', nil
+        else
+          env[RACK_ERRORS].puts "Unknown x-sendfile variation: '#{type}'.\n"
+        end
+      end
+      [status, headers, body]
+    end
+
+    private
+    def variation(env)
+      @variation ||
+        env['sendfile.type'] ||
+        env['HTTP_X_SENDFILE_TYPE']
+    end
+
+    def map_accel_path(env, path)
+      if mapping = @mappings.find { |internal,_| internal =~ path }
+        path.sub(*mapping)
+      elsif mapping = env['HTTP_X_ACCEL_MAPPING']
+        internal, external = mapping.split('=', 2).map(&:strip)
+        path.sub(/^#{internal}/i, external)
+      end
+    end
+  end
+end