passenger-jmazzi 2.2.9

data/lib/jeweler_spec.rb

@@ -0,0 +1,86 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "passenger-jmazzi"
+    gemspec.summary = "Passenger with backtraces removed"
+    gemspec.description = "Passenger with backtraces removed"
+    gemspec.email = "incoming1@mailheist.com"
+    gemspec.homepage = "http://github.com/jmazzi/passenger"
+    gemspec.authors = ["Phusion - http://www.phusion.nl/", "Justin Mazzi"]
+    gemspec.platform = Gem::Platform::RUBY
+    gemspec.requirements << "fastthread" << "Apache 2 with development headers"
+    gemspec.require_paths = ["lib", "ext"]
+    gemspec.add_dependency 'rake', '>= 0.8.1'
+    gemspec.add_dependency 'fastthread', '>= 1.0.1'
+    gemspec.add_dependency 'rack'
+    gemspec.extensions << 'ext/phusion_passenger/extconf.rb'
+    gemspec.files = FileList[
+      'Rakefile',
+      'README',
+      'DEVELOPERgemspec.TXT',
+      'LICENSE',
+      'INSTALL',
+      'NEWS',
+      'lib/**/*.rb',
+      'lib/**/*.py',
+      'lib/phusion_passenger/templates/*',
+      'lib/phusion_passenger/templates/apache2/*',
+      'lib/phusion_passenger/templates/nginx/*',
+      'bin/*',
+      'doc/*',
+
+      # If you're running 'rake package' for the first time, then these
+      # files don't exist yet, and so won't be matched by the above glob.
+      # So we add these filenames manually.
+      'doc/Users guide Apache.html',
+      'doc/Users guide Nginx.html',
+      'doc/Security of user switching support.html',
+
+      'doc/*/*',
+      'doc/*/*/*',
+      'doc/*/*/*/*',
+      'doc/*/*/*/*/*',
+      'doc/*/*/*/*/*/*',
+      'man/*',
+      'debian/*',
+      'ext/common/*.{cpp,c,h,hpp}',
+      'ext/apache2/*.{cpp,h,c,TXT}',
+      'ext/nginx/*.{c,cpp,h}',
+      'ext/nginx/config',
+      'ext/boost/*.{hpp,TXT}',
+      'ext/boost/**/*.{hpp,cpp,pl,inl,ipp}',
+      'ext/oxt/*.hpp',
+      'ext/oxt/*.cpp',
+      'ext/oxt/detail/*.hpp',
+      'ext/phusion_passenger/*.{c,rb}',
+      'benchmark/*.{cpp,rb}',
+      'misc/*',
+      'misc/*/*',
+      'test/*.{rb,cpp,example}',
+      'test/support/*.{cpp,h,rb}',
+      'test/oxt/*.cpp',
+      'test/ruby/**/*',
+      'test/integration_tests/**/*',
+      'test/stub/**/*'
+    ]
+    gemspec.executables = [
+      'passenger-spawn-server',
+      'passenger-install-apache2-module',
+      'passenger-install-nginx-module',
+      'passenger-config',
+      'passenger-memory-stats',
+      'passenger-make-enterprisey',
+      'passenger-status',
+      'passenger-stress-test'
+    ]
+    gemspec.has_rdoc = true
+    gemspec.extra_rdoc_files = ['README']
+    gemspec.rdoc_options <<
+      "-S" << "-N" << "-p" << "-H" <<
+      '--main' << 'README' <<
+      '--title' << 'Passenger Ruby API'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/lib/phusion_passenger/abstract_installer.rb

@@ -0,0 +1,196 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 Phusion
+#
+#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+#
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to deal
+#  in the Software without restriction, including without limitation the rights
+#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#  copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#  THE SOFTWARE.
+
+require 'phusion_passenger/constants'
+require 'phusion_passenger/packaging'
+require 'phusion_passenger/console_text_template'
+
+module PhusionPassenger
+
+# Abstract base class for installers. Used by passenger-install-apache2-module
+# and passenger-install-nginx-module.
+class AbstractInstaller
+	PASSENGER_WEBSITE = "http://www.modrails.com/"
+	PHUSION_WEBSITE = "www.phusion.nl"
+
+	def initialize(options = {})
+		options.each_pair do |key, value|
+			instance_variable_set(:"@#{key}", value)
+		end
+	end
+	
+	def start
+		install!
+	ensure
+		reset_terminal_colors
+	end
+
+private
+	def reset_terminal_colors
+		STDOUT.write("\e[0m")
+		STDOUT.flush
+	end
+	
+	def color_print(text)
+		STDOUT.write(ConsoleTextTemplate.new(:text => text).result)
+		STDOUT.flush
+	end
+	
+	def color_puts(text)
+		color_print("#{text}\n")
+	end
+	
+	def render_template(name, options = {})
+		puts ConsoleTextTemplate.new({ :file => name }, options).result
+	end
+	
+	def new_screen
+		puts
+		line
+		puts
+	end
+	
+	def line
+		puts "--------------------------------------------"
+	end
+	
+	def prompt(message)
+		done = false
+		while !done
+			color_print "#{message}: "
+			begin
+				result = STDIN.readline
+			rescue EOFError
+				exit 2
+			end
+			result.strip!
+			done = !block_given? || yield(result)
+		end
+		return result
+	rescue Interrupt
+		exit 2
+	end
+	
+	def wait(timeout = nil)
+		return if @auto
+		begin
+			if timeout
+				require 'timeout' unless defined?(Timeout)
+				begin
+					Timeout.timeout(timeout) do
+						STDIN.readline
+					end
+				rescue Timeout::Error
+					# Do nothing.
+				end
+			else
+				STDIN.readline
+			end
+		rescue Interrupt
+			exit 2
+		end
+	end
+	
+	def sh(*args)
+		puts "# #{args.join(' ')}"
+		result = system(*args)
+		if result
+			return true
+		elsif $?.signaled? && $?.termsig == Signal.list["INT"]
+			raise Interrupt
+		else
+			return false
+		end
+	end
+	
+	def dependencies
+		return []
+	end
+	
+	def check_dependencies
+		new_screen
+		missing_dependencies = []
+		color_puts "<banner>Checking for required software...</banner>"
+		puts
+		dependencies.each do |dep|
+			color_print " * #{dep.name}... "
+			result = dep.check
+			if result.found?
+				if result.found_at
+					color_puts "<green>found at #{result.found_at}</green>"
+				else
+					color_puts "<green>found</green>"
+				end
+			else
+				color_puts "<red>not found</red>"
+				missing_dependencies << dep
+			end
+		end
+		
+		if missing_dependencies.empty?
+			return true
+		else
+			puts
+			color_puts "<red>Some required software is not installed.</red>"
+			color_puts "But don't worry, this installer will tell you how to install them.\n"
+			color_puts "<b>Press Enter to continue, or Ctrl-C to abort.</b>"
+			if PhusionPassenger.natively_packaged?
+				wait(10)
+			else
+				wait
+			end
+			
+			line
+			puts
+			color_puts "<banner>Installation instructions for required software</banner>"
+			puts
+			missing_dependencies.each do |dep|
+				print_dependency_installation_instructions(dep)
+				puts
+			end
+			color_puts "If the aforementioned instructions didn't solve your problem, then please take"
+			color_puts "a look at the Users Guide:"
+			puts
+			color_puts "  <yellow>#{users_guide}</yellow>"
+			return false
+		end
+	end
+	
+	def print_dependency_installation_instructions(dep)
+		color_puts " * To install <yellow>#{dep.name}</yellow>:"
+		if !dep.install_command.nil?
+			color_puts "   Please run <b>#{dep.install_command}</b> as root."
+		elsif !dep.install_instructions.nil?
+			color_puts "   " << dep.install_instructions
+		elsif !dep.website.nil?
+			color_puts "   Please download it from <b>#{dep.website}</b>"
+			if !dep.website_comments.nil?
+				color_puts "   (#{dep.website_comments})"
+			end
+		else
+			color_puts "   Search Google."
+		end
+	end
+end
+
+end # module PhusionPassenger

data/lib/phusion_passenger/abstract_request_handler.rb

@@ -0,0 +1,475 @@
+# encoding: binary
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 Phusion
+#
+#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+#
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to deal
+#  in the Software without restriction, including without limitation the rights
+#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#  copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#  THE SOFTWARE.
+
+require 'socket'
+require 'fcntl'
+require 'phusion_passenger/message_channel'
+require 'phusion_passenger/utils'
+require 'phusion_passenger/constants'
+module PhusionPassenger
+
+# The request handler is the layer which connects Apache with the underlying application's
+# request dispatcher (i.e. either Rails's Dispatcher class or Rack).
+# The request handler's job is to process incoming HTTP requests using the
+# currently loaded Ruby on Rails application. HTTP requests are forwarded
+# to the request handler by the web server. HTTP responses generated by the
+# RoR application are forwarded to the web server, which, in turn, sends the
+# response back to the HTTP client.
+#
+# AbstractRequestHandler is an abstract base class for easing the implementation
+# of request handlers for Rails and Rack.
+#
+# == Design decisions
+#
+# Some design decisions are made because we want to decrease system
+# administrator maintenance overhead. These decisions are documented
+# in this section.
+#
+# === Owner pipes
+#
+# Because only the web server communicates directly with a request handler,
+# we want the request handler to exit if the web server has also exited.
+# This is implemented by using a so-called _owner pipe_. The writable part
+# of the pipe will be passed to the web server* via a Unix socket, and the web
+# server will own that part of the pipe, while AbstractRequestHandler owns
+# the readable part of the pipe. AbstractRequestHandler will continuously
+# check whether the other side of the pipe has been closed. If so, then it
+# knows that the web server has exited, and so the request handler will exit
+# as well. This works even if the web server gets killed by SIGKILL.
+#
+# * It might also be passed to the ApplicationPoolServerExecutable, if the web
+#   server's using ApplicationPoolServer instead of StandardApplicationPool.
+#
+#
+# == Request format
+#
+# Incoming "HTTP requests" are not true HTTP requests, i.e. their binary
+# representation do not conform to RFC 2616. Instead, the request format
+# is based on CGI, and is similar to that of SCGI.
+#
+# The format consists of 3 parts:
+# - A 32-bit big-endian integer, containing the size of the transformed
+#   headers.
+# - The transformed HTTP headers.
+# - The verbatim (untransformed) HTTP request body.
+#
+# HTTP headers are transformed to a format that satisfies the following
+# grammar:
+#
+#  headers ::= header*
+#  header ::= name NUL value NUL
+#  name ::= notnull+
+#  value ::= notnull+
+#  notnull ::= "\x01" | "\x02" | "\x02" | ... | "\xFF"
+#  NUL = "\x00"
+#
+# The web server transforms the HTTP request to the aforementioned format,
+# and sends it to the request handler.
+class AbstractRequestHandler
+	# Signal which will cause the Rails application to exit immediately.
+	HARD_TERMINATION_SIGNAL = "SIGTERM"
+	# Signal which will cause the Rails application to exit as soon as it's done processing a request.
+	SOFT_TERMINATION_SIGNAL = "SIGUSR1"
+	BACKLOG_SIZE    = 100
+	MAX_HEADER_SIZE = 128 * 1024
+	
+	# String constants which exist to relieve Ruby's garbage collector.
+	IGNORE              = 'IGNORE'              # :nodoc:
+	DEFAULT             = 'DEFAULT'             # :nodoc:
+	NULL                = "\0"                  # :nodoc:
+	X_POWERED_BY        = 'X-Powered-By'        # :nodoc:
+	REQUEST_METHOD      = 'REQUEST_METHOD'      # :nodoc:
+	PING                = 'ping'                # :nodoc:
+	
+	# The name of the socket on which the request handler accepts
+	# new connections. At this moment, this value is always the filename
+	# of a Unix domain socket.
+	#
+	# See also #socket_type.
+	attr_reader :socket_name
+	
+	# The type of socket that #socket_name refers to. At the moment, the
+	# value is always 'unix', which indicates a Unix domain socket.
+	attr_reader :socket_type
+	
+	# Specifies the maximum allowed memory usage, in MB. If after having processed
+	# a request AbstractRequestHandler detects that memory usage has risen above
+	# this limit, then it will gracefully exit (that is, exit after having processed
+	# all pending requests).
+	#
+	# A value of 0 (the default) indicates that there's no limit.
+	attr_accessor :memory_limit
+	
+	# The number of times the main loop has iterated so far. Mostly useful
+	# for unit test assertions.
+	attr_reader :iterations
+	
+	# Number of requests processed so far. This includes requests that raised
+	# exceptions.
+	attr_reader :processed_requests
+	
+	# Create a new RequestHandler with the given owner pipe.
+	# +owner_pipe+ must be the readable part of a pipe IO object.
+	#
+	# Additionally, the following options may be given:
+	# - memory_limit: Used to set the +memory_limit+ attribute.
+	def initialize(owner_pipe, options = {})
+		if should_use_unix_sockets?
+			create_unix_socket_on_filesystem
+		else
+			create_tcp_socket
+		end
+		@socket.close_on_exec!
+		@owner_pipe = owner_pipe
+		@previous_signal_handlers = {}
+		@main_loop_generation  = 0
+		@main_loop_thread_lock = Mutex.new
+		@main_loop_thread_cond = ConditionVariable.new
+		@memory_limit = options["memory_limit"] || 0
+		@iterations = 0
+		@processed_requests = 0
+		@main_loop_running = false
+	end
+	
+	# Clean up temporary stuff created by the request handler.
+	#
+	# If the main loop was started by #main_loop, then this method may only
+	# be called after the main loop has exited.
+	#
+	# If the main loop was started by #start_main_loop_thread, then this method
+	# may be called at any time, and it will stop the main loop thread.
+	def cleanup
+		if @main_loop_thread
+			@main_loop_thread_lock.synchronize do
+				@graceful_termination_pipe[1].close rescue nil
+			end
+			@main_loop_thread.join
+		end
+		@socket.close rescue nil
+		@owner_pipe.close rescue nil
+		File.unlink(@socket_name) rescue nil
+	end
+	
+	# Check whether the main loop's currently running.
+	def main_loop_running?
+		return @main_loop_running
+	end
+	
+	# Enter the request handler's main loop.
+	def main_loop
+		reset_signal_handlers
+		begin
+			@graceful_termination_pipe = IO.pipe
+			@graceful_termination_pipe[0].close_on_exec!
+			@graceful_termination_pipe[1].close_on_exec!
+			
+			@main_loop_thread_lock.synchronize do
+				@main_loop_generation += 1
+				@main_loop_running = true
+				@main_loop_thread_cond.broadcast
+			end
+			
+			install_useful_signal_handlers
+			
+			while true
+				@iterations += 1
+				client = accept_connection
+				if client.nil?
+					break
+				end
+				begin
+					headers, input = parse_request(client)
+					if headers
+						if headers[REQUEST_METHOD] == PING
+							process_ping(headers, input, client)
+						else
+							process_request(headers, input, client)
+						end
+					end
+				rescue IOError, SocketError, SystemCallError => e
+					print_exception("Passenger RequestHandler", e)
+				ensure
+					# 'input' is the same as 'client' so we don't
+					# need to close that.
+					# The 'close_write' here prevents forked child
+					# processes from unintentionally keeping the
+					# connection open.
+					client.close_write rescue nil
+					client.close rescue nil
+				end
+				@processed_requests += 1
+			end
+		rescue EOFError
+			# Exit main loop.
+		rescue Interrupt
+			# Exit main loop.
+		rescue SignalException => signal
+			if signal.message != HARD_TERMINATION_SIGNAL &&
+			   signal.message != SOFT_TERMINATION_SIGNAL
+				raise
+			end
+		ensure
+			revert_signal_handlers
+			@main_loop_thread_lock.synchronize do
+				@graceful_termination_pipe[0].close rescue nil
+				@graceful_termination_pipe[1].close rescue nil
+				@main_loop_generation += 1
+				@main_loop_running = false
+				@main_loop_thread_cond.broadcast
+			end
+		end
+	end
+	
+	# Start the main loop in a new thread. This thread will be stopped by #cleanup.
+	def start_main_loop_thread
+		current_generation = @main_loop_generation
+		@main_loop_thread = Thread.new do
+			main_loop
+		end
+		@main_loop_thread_lock.synchronize do
+			while @main_loop_generation == current_generation
+				@main_loop_thread_cond.wait(@main_loop_thread_lock)
+			end
+		end
+	end
+
+private
+	include Utils
+	
+	def should_use_unix_sockets?
+		# There seems to be a bug in MacOS X w.r.t. Unix sockets.
+		# When the Unix socket subsystem is under high stress, a
+		# recv()/read() on a Unix socket can return 0 even when EOF is
+		# not reached. We work around this by using TCP sockets on
+		# MacOS X.
+		return RUBY_PLATFORM !~ /darwin/
+	end
+
+	def create_unix_socket_on_filesystem
+		done = false
+		while !done
+			begin
+				if defined?(NativeSupport)
+					unix_path_max = NativeSupport::UNIX_PATH_MAX
+				else
+					unix_path_max = 100
+				end
+				@socket_name = "#{passenger_tmpdir}/backends/backend.#{generate_random_id(:base64)}"
+				@socket_name = @socket_name.slice(0, unix_path_max - 1)
+				@socket = UNIXServer.new(@socket_name)
+				@socket.listen(BACKLOG_SIZE)
+				@socket_type = "unix"
+				File.chmod(0600, @socket_name)
+				
+				# The SpawnManager class will set tighter permissions on the
+				# socket later on. See sendSpawnCommand in SpawnManager.h.
+				
+				done = true
+			rescue Errno::EADDRINUSE
+				# Do nothing, try again with another name.
+			end
+		end
+	end
+	
+	def create_tcp_socket
+		# We use "127.0.0.1" as address in order to force
+		# TCPv4 instead of TCPv6.
+		@socket = TCPServer.new('127.0.0.1', 0)
+		@socket.listen(BACKLOG_SIZE)
+		@socket_name = "127.0.0.1:#{@socket.addr[1]}"
+		@socket_type = "tcp"
+	end
+
+	# Reset signal handlers to their default handler, and install some
+	# special handlers for a few signals. The previous signal handlers
+	# will be put back by calling revert_signal_handlers.
+	def reset_signal_handlers
+		Signal.list_trappable.each_key do |signal|
+			begin
+				prev_handler = trap(signal, DEFAULT)
+				if prev_handler != DEFAULT
+					@previous_signal_handlers[signal] = prev_handler
+				end
+			rescue ArgumentError
+				# Signal cannot be trapped; ignore it.
+			end
+		end
+		trap('HUP', IGNORE)
+	end
+	
+	def install_useful_signal_handlers
+		trappable_signals = Signal.list_trappable
+		
+		trap(SOFT_TERMINATION_SIGNAL) do
+			@graceful_termination_pipe[1].close rescue nil
+		end if trappable_signals.has_key?(SOFT_TERMINATION_SIGNAL.sub(/^SIG/, ''))
+		
+		trap('ABRT') do
+			raise SignalException, "SIGABRT"
+		end if trappable_signals.has_key?('ABRT')
+		
+		trap('QUIT') do
+			if Kernel.respond_to?(:caller_for_all_threads)
+				output = "========== Process #{Process.pid}: backtrace dump ==========\n"
+				caller_for_all_threads.each_pair do |thread, stack|
+					output << ("-" * 60) << "\n"
+					output << "# Thread: #{thread.inspect}, "
+					if thread == Thread.main
+						output << "[main thread], "
+					else
+						output << "[current thread], "
+					end
+					output << "alive = #{thread.alive?}\n"
+					output << ("-" * 60) << "\n"
+					output << "    " << stack.join("\n    ")
+					output << "\n\n"
+				end
+			else
+				output = "========== Process #{Process.pid}: backtrace dump ==========\n"
+				output << ("-" * 60) << "\n"
+				output << "# Current thread: #{Thread.current.inspect}\n"
+				output << ("-" * 60) << "\n"
+				output << "    " << caller.join("\n    ")
+			end
+			STDERR.puts(output)
+			STDERR.flush
+		end if trappable_signals.has_key?('QUIT')
+	end
+	
+	def revert_signal_handlers
+		@previous_signal_handlers.each_pair do |signal, handler|
+			trap(signal, handler)
+		end
+	end
+	
+	def accept_connection
+		ios = select([@socket, @owner_pipe, @graceful_termination_pipe[0]]).first
+		if ios.include?(@socket)
+			client = @socket.accept
+			client.close_on_exec!
+			
+			# Some people report that sometimes their Ruby (MRI/REE)
+			# processes get stuck with 100% CPU usage. Upon further
+			# inspection with strace, it turns out that these Ruby
+			# processes are continuously calling lseek() on a socket,
+			# which of course returns ESPIPE as error. gdb reveals
+			# lseek() is called by fwrite(), which in turn is called
+			# by rb_fwrite(). The affected socket is the
+			# AbstractRequestHandler client socket.
+			#
+			# I inspected the MRI source code and didn't find
+			# anything that would explain this behavior. This makes
+			# me think that it's a glibc bug, but that's very
+			# unlikely.
+			#
+			# The rb_fwrite() implementation takes an entirely
+			# different code path if I set 'sync' to true: it will
+			# skip fwrite() and use write() instead. So here we set
+			# 'sync' to true in the hope that this will work around
+			# the problem.
+			client.sync = true
+			
+			# We monkeypatch the 'sync=' method to a no-op so that
+			# sync mode can't be disabled.
+			def client.sync=(value)
+			end
+			
+			# The real input stream is not seekable (calling _seek_
+			# or _rewind_ on it will raise an exception). But some
+			# frameworks (e.g. Merb) call _rewind_ if the object
+			# responds to it. So we simply undefine _seek_ and
+			# _rewind_.
+			client.instance_eval do
+				undef seek if respond_to?(:seek)
+				undef rewind if respond_to?(:rewind)
+			end
+			
+			# There's no need to set the encoding for Ruby 1.9 because this
+			# source file is tagged with 'encoding: binary'.
+			
+			return client
+		else
+			# The other end of the owner pipe has been closed, or the
+			# graceful termination pipe has been closed. This is our
+			# call to gracefully terminate (after having processed all
+			# incoming requests).
+			return nil
+		end
+	end
+	
+	# Read the next request from the given socket, and return
+	# a pair [headers, input_stream]. _headers_ is a Hash containing
+	# the request headers, while _input_stream_ is an IO object for
+	# reading HTTP POST data.
+	#
+	# Returns nil if end-of-stream was encountered.
+	def parse_request(socket)
+		channel = MessageChannel.new(socket)
+		headers_data = channel.read_scalar(MAX_HEADER_SIZE)
+		if headers_data.nil?
+			return
+		end
+		headers = Hash[*headers_data.split(NULL)]
+		return [headers, socket]
+	rescue SecurityError => e
+		STDERR.puts("*** Passenger RequestHandler: HTTP header size exceeded maximum.")
+		STDERR.flush
+		print_exception("Passenger RequestHandler", e)
+	end
+	
+	def process_ping(env, input, output)
+		output.write("pong")
+	end
+	
+	# Generate a long, cryptographically secure random ID string, which
+	# is also a valid filename.
+	def generate_random_id(method)
+		case method
+		when :base64
+			require 'base64' unless defined?(Base64)
+			data = Base64.encode64(File.read("/dev/urandom", 64))
+			data.gsub!("\n", '')
+			data.gsub!("+", '')
+			data.gsub!("/", '')
+			data.gsub!(/==$/, '')
+		when :hex
+			data = File.read("/dev/urandom", 64).unpack('H*')[0]
+		end
+		return data
+	end
+	
+	def self.determine_passenger_header
+		header = "Phusion Passenger (mod_rails/mod_rack) #{VERSION_STRING}"
+		if File.exist?("#{File.dirname(__FILE__)}/../../enterprisey.txt") ||
+		   File.exist?("/etc/passenger_enterprisey.txt")
+			header << ", Enterprise Edition"
+		end
+		return header
+	end
+
+public
+	PASSENGER_HEADER = determine_passenger_header
+end
+
+end # module PhusionPassenger