pitchfork 0.1.0

data/lib/pitchfork/http_parser.rb

@@ -0,0 +1,206 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# no stable API here
+require 'pitchfork/pitchfork_http'
+
+module Pitchfork
+  class HttpParser
+
+    # default parameters we merge into the request env for Rack handlers
+    DEFAULTS = {
+      "rack.errors" => $stderr,
+      "rack.multiprocess" => true,
+      "rack.multithread" => false,
+      "rack.run_once" => false,
+      "rack.version" => [1, 2],
+      "rack.hijack?" => true,
+      "SCRIPT_NAME" => "",
+
+      # this is not in the Rack spec, but some apps may rely on it
+      "SERVER_SOFTWARE" => "Pitchfork #{Pitchfork::Const::UNICORN_VERSION}"
+    }
+
+    NULL_IO = StringIO.new("")
+
+    # :stopdoc:
+    HTTP_RESPONSE_START = [ 'HTTP'.freeze, '/1.1 '.freeze ]
+    EMPTY_ARRAY = [].freeze
+    @@input_class = Pitchfork::TeeInput
+    @@check_client_connection = false
+    @@tcpi_inspect_ok = Socket.const_defined?(:TCP_INFO)
+
+    def self.input_class
+      @@input_class
+    end
+
+    def self.input_class=(klass)
+      @@input_class = klass
+    end
+
+    def self.check_client_connection
+      @@check_client_connection
+    end
+
+    def self.check_client_connection=(bool)
+      @@check_client_connection = bool
+    end
+
+    # :startdoc:
+
+    # Does the majority of the IO processing.  It has been written in
+    # Ruby using about 8 different IO processing strategies.
+    #
+    # It is currently carefully constructed to make sure that it gets
+    # the best possible performance for the common case: GET requests
+    # that are fully complete after a single read(2)
+    #
+    # Anyone who thinks they can make it faster is more than welcome to
+    # take a crack at it.
+    #
+    # returns an environment hash suitable for Rack if successful
+    # This does minimal exception trapping and it is up to the caller
+    # to handle any socket errors (e.g. user aborted upload).
+    def read(socket)
+      e = env
+
+      # From https://www.ietf.org/rfc/rfc3875:
+      # "Script authors should be aware that the REMOTE_ADDR and
+      #  REMOTE_HOST meta-variables (see sections 4.1.8 and 4.1.9)
+      #  may not identify the ultimate source of the request.  They
+      #  identify the client for the immediate request to the server;
+      #  that client may be a proxy, gateway, or other intermediary
+      #  acting on behalf of the actual source client."
+      address = socket.remote_address
+      e['REMOTE_ADDR'] = if address.unix?
+        "127.0.0.1"
+      else
+        address.ip_address
+      end
+
+      # short circuit the common case with small GET requests first
+      socket.readpartial(16384, buf)
+      if parse.nil?
+        # Parser is not done, queue up more data to read and continue parsing
+        # an Exception thrown from the parser will throw us out of the loop
+        false until add_parse(socket.readpartial(16384))
+      end
+
+      check_client_connection(socket) if @@check_client_connection
+
+      e['rack.input'] = 0 == content_length ?
+                        NULL_IO : @@input_class.new(socket, self)
+
+      # for Rack hijacking in Rack 1.5 and later
+      e['pitchfork.socket'] = socket
+      e['rack.hijack'] = self
+
+      e.merge!(DEFAULTS)
+    end
+
+    # for rack.hijack, we respond to this method so no extra allocation
+    # of a proc object
+    def call
+      hijacked!
+      env['rack.hijack_io'] = env['pitchfork.socket']
+    end
+
+    def hijacked?
+      env.include?('rack.hijack_io'.freeze)
+    end
+
+    if Raindrops.const_defined?(:TCP_Info)
+      TCPI = Raindrops::TCP_Info.allocate
+
+      def check_client_connection(socket) # :nodoc:
+        if TCPSocket === socket
+          # Raindrops::TCP_Info#get!, #state (reads struct tcp_info#tcpi_state)
+          raise Errno::EPIPE, "client closed connection".freeze,
+                EMPTY_ARRAY if closed_state?(TCPI.get!(socket).state)
+        else
+          write_http_header(socket)
+        end
+      end
+
+      if Raindrops.const_defined?(:TCP)
+        # raindrops 0.18.0+ supports FreeBSD + Linux using the same names
+        # Evaluate these hash lookups at load time so we can
+        # generate an opt_case_dispatch instruction
+        eval <<-EOS
+        def closed_state?(state) # :nodoc:
+          case state
+          when #{Raindrops::TCP[:ESTABLISHED]}
+            false
+          when #{Raindrops::TCP.values_at(
+                :CLOSE_WAIT, :TIME_WAIT, :CLOSE, :LAST_ACK, :CLOSING).join(',')}
+            true
+          else
+            false
+          end
+        end
+        EOS
+      else
+        # raindrops before 0.18 only supported TCP_INFO under Linux
+        def closed_state?(state) # :nodoc:
+          case state
+          when 1 # ESTABLISHED
+            false
+          when 8, 6, 7, 9, 11 # CLOSE_WAIT, TIME_WAIT, CLOSE, LAST_ACK, CLOSING
+            true
+          else
+            false
+          end
+        end
+      end
+    else
+
+      # Ruby 2.2+ can show struct tcp_info as a string Socket::Option#inspect.
+      # Not that efficient, but probably still better than doing unnecessary
+      # work after a client gives up.
+      def check_client_connection(socket) # :nodoc:
+        if TCPSocket === socket && @@tcpi_inspect_ok
+          opt = socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_INFO).inspect
+          if opt =~ /\bstate=(\S+)/
+            raise Errno::EPIPE, "client closed connection".freeze,
+                  EMPTY_ARRAY if closed_state_str?($1)
+          else
+            @@tcpi_inspect_ok = false
+            write_http_header(socket)
+          end
+          opt.clear
+        else
+          write_http_header(socket)
+        end
+      end
+
+      def closed_state_str?(state)
+        case state
+        when 'ESTABLISHED'
+          false
+        # not a typo, ruby maps TCP_CLOSE (no 'D') to state=CLOSED (w/ 'D')
+        when 'CLOSE_WAIT', 'TIME_WAIT', 'CLOSED', 'LAST_ACK', 'CLOSING'
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def write_http_header(socket) # :nodoc:
+      if headers?
+        self.response_start_sent = true
+        HTTP_RESPONSE_START.each { |c| socket.write(c) }
+      end
+    end
+
+    # called by ext/pitchfork_http/pitchfork_http.rl via rb_funcall
+    def self.is_chunked?(v) # :nodoc:
+      vals = v.split(/[ \t]*,[ \t]*/).map!(&:downcase)
+      if vals.pop == 'chunked'.freeze
+        return true unless vals.include?('chunked'.freeze)
+        raise Pitchfork::HttpParserError, 'double chunked', []
+      end
+      return false unless vals.include?('chunked'.freeze)
+      raise Pitchfork::HttpParserError, 'chunked not last', []
+    end
+  end
+end

data/lib/pitchfork/http_response.rb

@@ -0,0 +1,63 @@
+# -*- encoding: binary -*-
+# :enddoc:
+
+module Pitchfork
+  # Writes a Rack response to your client using the HTTP/1.1 specification.
+  # You use it by simply doing:
+  #
+  #   status, headers, body = rack_app.call(env)
+  #   http_response_write(socket, status, headers, body)
+  #
+  # Most header correctness (including Content-Length and Content-Type)
+  # is the job of Rack, with the exception of the "Date" and "Status" header.
+  module HttpResponse
+    STATUS_CODES = defined?(Rack::Utils::HTTP_STATUS_CODES) ?
+                   Rack::Utils::HTTP_STATUS_CODES : {}
+
+    # internal API, code will always be common-enough-for-even-old-Rack
+    def err_response(code, response_start_sent)
+      "#{response_start_sent ? '' : 'HTTP/1.1 '}" \
+        "#{code} #{STATUS_CODES[code]}\r\n\r\n"
+    end
+
+    # writes the rack_response to socket as an HTTP response
+    def http_response_write(socket, status, headers, body,
+                            req = Pitchfork::HttpParser.new)
+      hijack = nil
+
+      if headers
+        code = status.to_i
+        msg = STATUS_CODES[code]
+        start = req.response_start_sent ? ''.freeze : 'HTTP/1.1 '.freeze
+        buf = "#{start}#{msg ? %Q(#{code} #{msg}) : status}\r\n" \
+              "Date: #{httpdate}\r\n" \
+              "Connection: close\r\n"
+        headers.each do |key, value|
+          case key
+          when %r{\A(?:Date|Connection)\z}i
+            next
+          when "rack.hijack"
+            # This should only be hit under Rack >= 1.5, as this was an illegal
+            # key in Rack < 1.5
+            hijack = value
+          else
+            if value =~ /\n/
+              # avoiding blank, key-only cookies with /\n+/
+              value.split(/\n+/).each { |v| buf << "#{key}: #{v}\r\n" }
+            else
+              buf << "#{key}: #{value}\r\n"
+            end
+          end
+        end
+        socket.write(buf << "\r\n".freeze)
+      end
+
+      if hijack
+        req.hijacked!
+        hijack.call(socket)
+      else
+        body.each { |chunk| socket.write(chunk) }
+      end
+    end
+  end
+end