lib/unicorn/http_request.rb

   1 # -*- encoding: binary -*-
   2 # :enddoc:
   3 # no stable API here
   4 require 'unicorn_http'
   5 require 'raindrops'
   6
   7 # TODO: remove redundant names
   8 Unicorn.const_set(:HttpRequest, Unicorn::HttpParser)
   9 class Unicorn::HttpParser
  10
  11   # default parameters we merge into the request env for Rack handlers
  12   DEFAULTS = {
  13     "rack.errors" => $stderr,
  14     "rack.multiprocess" => true,
  15     "rack.multithread" => false,
  16     "rack.run_once" => false,
  17     "rack.version" => [1, 2],
  18     "rack.hijack?" => true,
  19     "SCRIPT_NAME" => "",
  20
  21     # this is not in the Rack spec, but some apps may rely on it
  22     "SERVER_SOFTWARE" => "Unicorn #{Unicorn::Const::UNICORN_VERSION}"
  23   }
  24
  25   NULL_IO = StringIO.new("")
  26
  27   # :stopdoc:
  28   HTTP_RESPONSE_START = [ 'HTTP'.freeze, '/1.1 '.freeze ]
  29   EMPTY_ARRAY = [].freeze
  30   @@input_class = Unicorn::TeeInput
  31   @@check_client_connection = false
  32   @@tcpi_inspect_ok = nil
  33
  34   def self.input_class
  35     @@input_class
  36   end
  37
  38   def self.input_class=(klass)
  39     @@input_class = klass
  40   end
  41
  42   def self.check_client_connection
  43     @@check_client_connection
  44   end
  45
  46   def self.check_client_connection=(bool)
  47     @@check_client_connection = bool
  48   end
  49
  50   # :startdoc:
  51
  52   # Does the majority of the IO processing.  It has been written in
  53   # Ruby using about 8 different IO processing strategies.
  54   #
  55   # It is currently carefully constructed to make sure that it gets
  56   # the best possible performance for the common case: GET requests
  57   # that are fully complete after a single read(2)
  58   #
  59   # Anyone who thinks they can make it faster is more than welcome to
  60   # take a crack at it.
  61   #
  62   # returns an environment hash suitable for Rack if successful
  63   # This does minimal exception trapping and it is up to the caller
  64   # to handle any socket errors (e.g. user aborted upload).
  65   def read(socket)
  66     clear
  67     e = env
  68
  69     # From http://www.ietf.org/rfc/rfc3875:
  70     # "Script authors should be aware that the REMOTE_ADDR and
  71     #  REMOTE_HOST meta-variables (see sections 4.1.8 and 4.1.9)
  72     #  may not identify the ultimate source of the request.  They
  73     #  identify the client for the immediate request to the server;
  74     #  that client may be a proxy, gateway, or other intermediary
  75     #  acting on behalf of the actual source client."
  76     e['REMOTE_ADDR'] = socket.kgio_addr
  77
  78     # short circuit the common case with small GET requests first
  79     socket.kgio_read!(16384, buf)
  80     if parse.nil?
  81       # Parser is not done, queue up more data to read and continue parsing
  82       # an Exception thrown from the parser will throw us out of the loop
  83       false until add_parse(socket.kgio_read!(16384))
  84     end
  85
  86     check_client_connection(socket) if @@check_client_connection
  87
  88     e['rack.input'] = 0 == content_length ?
  89                       NULL_IO : @@input_class.new(socket, self)
  90
  91     # for Rack hijacking in Rack 1.5 and later
  92     e['unicorn.socket'] = socket
  93     e['rack.hijack'] = self
  94
  95     e.merge!(DEFAULTS)
  96   end
  97
  98   # for rack.hijack, we respond to this method so no extra allocation
  99   # of a proc object
 100   def call
 101     env['rack.hijack_io'] = env['unicorn.socket']
 102   end
 103
 104   def hijacked?
 105     env.include?('rack.hijack_io'.freeze)
 106   end
 107
 108   if Raindrops.const_defined?(:TCP_Info)
 109     TCPI = Raindrops::TCP_Info.allocate
 110
 111     def check_client_connection(socket) # :nodoc:
 112       if Unicorn::TCPClient === socket
 113         # Raindrops::TCP_Info#get!, #state (reads struct tcp_info#tcpi_state)
 114         raise Errno::EPIPE, "client closed connection".freeze,
 115               EMPTY_ARRAY if closed_state?(TCPI.get!(socket).state)
 116       else
 117         write_http_header(socket)
 118       end
 119     end
 120
 121     if Raindrops.const_defined?(:TCP)
 122       # raindrops 0.18.0+ supports FreeBSD + Linux using the same names
 123       # Evaluate these hash lookups at load time so we can
 124       # generate an opt_case_dispatch instruction
 125       eval <<-EOS
 126       def closed_state?(state) # :nodoc:
 127         case state
 128         when #{Raindrops::TCP[:ESTABLISHED]}
 129           false
 130         when #{Raindrops::TCP.values_at(
 131               :CLOSE_WAIT, :TIME_WAIT, :CLOSE, :LAST_ACK, :CLOSING).join(',')}
 132           true
 133         else
 134           false
 135         end
 136       end
 137       EOS
 138     else
 139       # raindrops before 0.18 only supported TCP_INFO under Linux
 140       def closed_state?(state) # :nodoc:
 141         case state
 142         when 1 # ESTABLISHED
 143           false
 144         when 8, 6, 7, 9, 11 # CLOSE_WAIT, TIME_WAIT, CLOSE, LAST_ACK, CLOSING
 145           true
 146         else
 147           false
 148         end
 149       end
 150     end
 151   else
 152
 153     # Ruby 2.2+ can show struct tcp_info as a string Socket::Option#inspect.
 154     # Not that efficient, but probably still better than doing unnecessary
 155     # work after a client gives up.
 156     def check_client_connection(socket) # :nodoc:
 157       if Unicorn::TCPClient === socket && @@tcpi_inspect_ok != false
 158         if @@tcpi_inspect_ok
 159           opt = socket.getsockopt(:IPPROTO_TCP, :TCP_INFO).inspect
 160         else
 161           @@tcpi_inspect_ok = true
 162           opt = begin
 163             socket.getsockopt(:IPPROTO_TCP, :TCP_INFO)
 164           rescue SocketError
 165             @@tcpi_inspect_ok = false
 166             return write_http_header(socket)
 167           end.inspect
 168         end
 169
 170         if opt =~ /\bstate=(\S+)/
 171           raise Errno::EPIPE, "client closed connection".freeze,
 172                 EMPTY_ARRAY if closed_state_str?($1)
 173         else
 174           @@tcpi_inspect_ok = false
 175           write_http_header(socket)
 176         end
 177         opt.clear
 178       else
 179         write_http_header(socket)
 180       end
 181     end
 182
 183     def closed_state_str?(state)
 184       case state
 185       when 'ESTABLISHED'
 186         false
 187       # not a typo, ruby maps TCP_CLOSE (no 'D') to state=CLOSED (w/ 'D')
 188       when 'CLOSE_WAIT', 'TIME_WAIT', 'CLOSED', 'LAST_ACK', 'CLOSING'
 189         true
 190       else
 191         false
 192       end
 193     end
 194   end
 195
 196   def write_http_header(socket) # :nodoc:
 197     if headers?
 198       self.response_start_sent = true
 199       HTTP_RESPONSE_START.each { |c| socket.write(c) }
 200     end
 201   end
 202 end