passenger 3.0.7 → 3.0.8

data/ext/oxt/tracable_exception.cpp

@@ -52,7 +52,9 @@ tracable_exception::tracable_exception() {
 	}
 }
 
-tracable_exception::tracable_exception(const tracable_exception &other) {
+tracable_exception::tracable_exception(const tracable_exception &other)
+	: std::exception()
+{
 	list<trace_point *>::const_iterator it;
 	for (it = other.backtrace_copy.begin(); it != other.backtrace_copy.end(); it++) {
 		trace_point *p = new trace_point(

data/ext/ruby/extconf.rb

@@ -35,6 +35,7 @@ end
 
 have_header('alloca.h')
 have_header('ruby/io.h')
+have_func('rb_reserved_fd_p')
 
 with_cflags($CFLAGS) do
 	create_makefile('passenger_native_support')

data/ext/ruby/passenger_native_support.c

@@ -276,6 +276,9 @@ close_all_file_descriptors(VALUE self, VALUE exceptions) {
 	
 	for (i = sysconf(_SC_OPEN_MAX) - 1; i >= 0; i--) {
 		int is_exception = 0;
+		#ifdef HAVE_RB_RESERVED_FD_P
+			is_exception = rb_reserved_fd_p(i);
+		#endif
 		for (j = 0; j < RARRAY_LEN(exceptions) && !is_exception; j++) {
 			long fd = NUM2INT(rb_ary_entry(exceptions, j));
 			is_exception = i == fd;

data/helper-scripts/prespawn

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #  Phusion Passenger - http://www.modrails.com/
-#  Copyright (c) 2010 Phusion
+#  Copyright (c) 2010, 2011 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #
@@ -26,38 +26,120 @@ STDOUT.sync = true
 STDERR.sync = true
 
 require 'uri'
-url = ARGV[0]
-begin
-	uri = URI.parse(url)
-rescue URI::InvaludURIError
-	STDERR.puts "*** ERROR: '#{url}' is not a valid URL."
-	exit 1
+require 'socket'
+
+class PrespawnLocation
+	class InvalidURLError < RuntimeError
+		def initialize(url)
+			@url = url
+		end
+
+		def to_s
+			message
+		end
+
+		def message
+			"'#{@url}' is not a valid URL."
+		end
+	end
+
+	def self.parse(url)
+		uri = uri_for(url)
+
+		location = if uri.host == 'unix'
+			UNIXPrespawnLocation.new(uri)
+		else
+			case uri.scheme
+				when 'http'
+					TCPPrespawnLocation.new(uri)
+				when 'https'
+					SSLPrespawnLocation.new(uri)
+			end
+		end
+
+		unless location
+			raise InvalidURLError, url
+		end
+
+		location
+	end
+
+	def self.uri_for(url)
+		URI.parse(url)
+	rescue URI::InvalidURIError
+		raise InvalidURLError, url
+	end
+
+	def initialize(uri)
+		@uri = uri
+	end
+
+	def request_path
+		@uri.path.empty? ? '/' : @uri.path
+	end
+
+	def request_host
+		@uri.host
+	end
+
+	def socket
+		@socket ||= connect
+	end
+
+	def head_request
+		socket.write("HEAD #{request_path} HTTP/1.1\r\n")
+		socket.write("Host: #{request_host}\r\n")
+		socket.write("Connection: close\r\n")
+		socket.write("\r\n")
+
+		socket.read
+	end
 end
-if uri.scheme.nil? || uri.host.nil? || uri.port.nil? || uri.path.nil?
-	STDERR.puts "*** ERROR: '#{url}' is not a valid URL."
-	exit 1
+
+class TCPPrespawnLocation < PrespawnLocation
+	def request_port
+		@uri.port
+	end
+
+	def connect
+		TCPSocket.new(request_host, request_port)
+	end
 end
 
-require 'socket'
-path = uri.path.empty? ? "/" : uri.path
-socket = TCPSocket.new('127.0.0.1', uri.port)
-if uri.scheme == 'https'
-	require 'openssl'
-	socket = OpenSSL::SSL::SSLSocket.new(socket)
-	socket.sync_close = true
-	socket.connect
+class SSLPrespawnLocation < TCPPrespawnLocation
+	def connect
+		require 'openssl'
+		socket = OpenSSL::SSL::SSLSocket.new(super)
+		socket.sync_close = true
+		socket.connect
+		socket
+	end
 end
-begin
-	socket.write("HEAD #{path} HTTP/1.1\r\n")
-	socket.write("Host: #{uri.host}\r\n")
-	socket.write("Connection: close\r\n")
-	socket.write("\r\n")
-	if socket.respond_to?(:close_write)
-		socket.close_write
-		socket.read
-	else
-		socket.readline
+
+class UNIXPrespawnLocation < PrespawnLocation
+	def request_path
+		super.split(':', 2).last
 	end
-ensure
-	socket.close
-end
+
+	def request_host
+		'_'
+	end
+
+	def socket_path
+		@uri.path.split(':', 2).first
+	end
+
+	def connect
+		UNIXSocket.new(socket_path)
+	end
+end
+
+url = ARGV[0]
+begin
+	prespawn_location = PrespawnLocation.parse(url)
+rescue PrespawnLocation::InvalidURLError => e
+	STDERR.puts "*** ERROR: #{e}"
+	exit 1
+end
+
+prespawn_location.head_request

data/lib/phusion_passenger.rb

@@ -25,9 +25,9 @@ module PhusionPassenger
 	###### Version numbers ######
 	
 	# Phusion Passenger version number. Don't forget to edit ext/common/Constants.h too.
-	VERSION_STRING = '3.0.7'
+	VERSION_STRING = '3.0.8'
 	
-	PREFERRED_NGINX_VERSION = '1.0.0'
+	PREFERRED_NGINX_VERSION = '1.0.5'
 	PREFERRED_PCRE_VERSION  = '8.12'
 	STANDALONE_INTERFACE_VERSION  = 1
 	

data/lib/phusion_passenger/standalone/runtime_installer.rb

@@ -307,7 +307,7 @@ private
 			if !File.directory?(dir)
 				FileUtils.mkdir_p(dir)
 			end
-			FileUtils.install(filename, "#{target}/#{filename}")
+			FileUtils.install(filename, "#{target}/#{filename}", :mode => File.stat(filename).mode)
 			yield(i + 1, files.size)
 		end
 	end
@@ -317,7 +317,7 @@ private
 	end
 	
 	def run_rake_task!(target)
-		total_lines = `#{rake} #{target} --dry-run`.split("\n").size - 1
+		total_lines = `#{rake} #{target} --dry-run STDERR_TO_STDOUT=1`.split("\n").size - 1
 		backlog = ""
 		
 		IO.popen("#{rake} #{target} --trace STDERR_TO_STDOUT=1", "r") do |io|
@@ -437,6 +437,7 @@ private
 			# work around the problem by configure Nginx with prefix
 			# /tmp.
 			command = "sh ./configure --prefix=/tmp " <<
+				"--with-cc-opt='-Wno-error' " <<
 				"--without-pcre " <<
 				"--without-http_rewrite_module " <<
 				"--without-http_fastcgi_module " <<

data/lib/phusion_passenger/standalone/start_command.rb

@@ -267,10 +267,6 @@ private
 		return !@options[:daemonize] && @options[:log_file] != "/dev/null"
 	end
 	
-	def listening_on_unix_domain_socket?
-		return !!@options[:socket_file]
-	end
-	
 	# Returns the URL that Nginx will be listening on.
 	def listen_url
 		if @options[:socket_file]
@@ -408,16 +404,20 @@ private
 		end
 		
 		IO.popen("tail -f -n #{backward} \"#{log_file}\"", "rb") do |f|
-			while true
-				begin
-					line = f.readline
-					@console_mutex.synchronize do
-						STDOUT.write(line)
-						STDOUT.flush
+			begin
+				while true
+					begin
+						line = f.readline
+						@console_mutex.synchronize do
+							STDOUT.write(line)
+							STDOUT.flush
+						end
+					rescue EOFError
+						break
 					end
-				rescue EOFError
-					break
 				end
+			ensure
+				Process.kill('TERM', f.pid)
 			end
 		end
 	end

data/test/cxx/DechunkerTest.cpp

@@ -0,0 +1,216 @@
+#include "TestSupport.h"
+#include <algorithm>
+#include <string>
+#include <Utils/Dechunker.h>
+#include <Utils/StrIntUtils.h>
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct DechunkerTest {
+		Dechunker dechunker;
+		string input;
+		vector<string> chunks;
+		
+		DechunkerTest() {
+			dechunker.onData = onData;
+			dechunker.userData = this;
+		}
+		
+		void addChunk(const string &data) {
+			input.append(integerToHex(data.size()));
+			input.append("\r\n");
+			input.append(data);
+			input.append("\r\n");
+		}
+		
+		static void onData(const char *data, size_t len, void *userData) {
+			DechunkerTest *self = (DechunkerTest *) userData;
+			self->chunks.push_back(string(data, len));
+		}
+	};
+	
+	DEFINE_TEST_GROUP(DechunkerTest);
+	
+	TEST_METHOD(1) {
+		// Test initial state.
+		ensure(dechunker.acceptingInput());
+		ensure(!dechunker.hasError());
+		ensure_equals(dechunker.getErrorMessage(), (const char *) NULL);
+	}
+	
+	TEST_METHOD(2) {
+		// Test feeding a complete stream everything in one go.
+		addChunk("hello");
+		addChunk("world");
+		addChunk("");
+		ensure_equals(dechunker.feed(input.data(), input.size()), input.size());
+		ensure(!dechunker.acceptingInput());
+		ensure(!dechunker.hasError());
+		ensure_equals(chunks.size(), 2u);
+		ensure_equals(chunks[0], "hello");
+		ensure_equals(chunks[1], "world");
+	}
+	
+	TEST_METHOD(3) {
+		// Test feeding a complete stream byte by byte.
+		addChunk("hel");
+		addChunk("lo");
+		addChunk("");
+		
+		const char *pos = input.data();
+		const char *end = input.data() + input.size();
+		while (pos < end) {
+			ensure(dechunker.acceptingInput());
+			ensure(!dechunker.hasError());
+			ensure_equals(dechunker.feed(pos, 1), 1u);
+			pos++;
+		}
+		
+		ensure(!dechunker.acceptingInput());
+		ensure(!dechunker.hasError());
+		ensure_equals(chunks.size(), 5u);
+		ensure_equals(chunks[0], "h");
+		ensure_equals(chunks[1], "e");
+		ensure_equals(chunks[2], "l");
+		ensure_equals(chunks[3], "l");
+		ensure_equals(chunks[4], "o");
+	}
+	
+	TEST_METHOD(4) {
+		// Test feeding a complete stream in pieces of 2 bytes.
+		addChunk("hello");
+		addChunk("world");
+		addChunk("");
+		
+		const char *pos = input.data();
+		const char *end = input.data() + input.size();
+		while (pos < end) {
+			ensure(dechunker.acceptingInput());
+			ensure(!dechunker.hasError());
+			size_t size = std::min<size_t>(2, end - pos);
+			ensure_equals(dechunker.feed(pos, size), size);
+			pos += 2;
+		}
+		
+		ensure(!dechunker.acceptingInput());
+		ensure(!dechunker.hasError());
+		ensure_equals(chunks.size(), 6u);
+		ensure_equals(chunks[0], "h");
+		ensure_equals(chunks[1], "el");
+		ensure_equals(chunks[2], "lo");
+		ensure_equals(chunks[3], "w");
+		ensure_equals(chunks[4], "or");
+		ensure_equals(chunks[5], "ld");
+	}
+	
+	TEST_METHOD(5) {
+		// Test feeding a complete stream in pieces of 3 bytes.
+		addChunk("hello");
+		addChunk("world");
+		addChunk("");
+		
+		const char *pos = input.data();
+		const char *end = input.data() + input.size();
+		while (pos < end) {
+			ensure(dechunker.acceptingInput());
+			ensure(!dechunker.hasError());
+			size_t size = std::min<size_t>(3, end - pos);
+			ensure_equals(dechunker.feed(pos, size), size);
+			pos += 3;
+		}
+		
+		ensure(!dechunker.acceptingInput());
+		ensure(!dechunker.hasError());
+		ensure_equals(chunks.size(), 4u);
+		ensure_equals(chunks[0], "hel");
+		ensure_equals(chunks[1], "lo");
+		ensure_equals(chunks[2], "wo");
+		ensure_equals(chunks[3], "rld");
+	}
+	
+	TEST_METHOD(6) {
+		// Test support for chunk extensions.
+		input = "2;foobar\r\n"
+			"xy\r\n"
+			"0\r\n"
+			"\r\n";
+		ensure_equals(dechunker.feed(input.data(), input.size()), input.size());
+		ensure(!dechunker.acceptingInput());
+		ensure(!dechunker.hasError());
+		ensure_equals(chunks.size(), 1u);
+		ensure_equals(chunks[0], "xy");
+	}
+	
+	TEST_METHOD(20) {
+		// It refuses to accept any more data after EOF until reset is called.
+		addChunk("hello");
+		addChunk("");
+		
+		dechunker.feed(input.data(), input.size());
+		ensure_equals(dechunker.feed(input.data(), input.size()), 0u);
+		dechunker.reset();
+		ensure_equals(dechunker.feed(input.data(), input.size()), input.size());
+		ensure(!dechunker.acceptingInput());
+		ensure(!dechunker.hasError());
+		
+		ensure_equals(chunks.size(), 2u);
+		ensure_equals(chunks[0], "hello");
+		ensure_equals(chunks[1], "hello");
+	}
+	
+	TEST_METHOD(21) {
+		// Test invalid size string.
+		input = "12x\r\n";
+		ensure_equals(dechunker.feed(input.data(), input.size()), 2u);
+		ensure(!dechunker.acceptingInput());
+		ensure(dechunker.hasError());
+	}
+	
+	TEST_METHOD(22) {
+		// Test invalid chunk header terminator.
+		input = "12\r\t";
+		ensure_equals(dechunker.feed(input.data(), input.size()), 3u);
+		ensure(!dechunker.acceptingInput());
+		ensure(dechunker.hasError());
+	}
+	
+	TEST_METHOD(23) {
+		// Test invalid chunk header terminator when chunk extensions are involved.
+		input = "12;foo\r\t";
+		ensure_equals(dechunker.feed(input.data(), input.size()), 7u);
+		ensure(!dechunker.acceptingInput());
+		ensure(dechunker.hasError());
+	}
+	
+	TEST_METHOD(24) {
+		// Test invalid chunk terminator.
+		input = "2\r\n"
+			"xyz";
+		ensure_equals(dechunker.feed(input.data(), input.size()), 5u);
+		ensure(!dechunker.acceptingInput());
+		ensure(dechunker.hasError());
+	}
+	
+	TEST_METHOD(25) {
+		// Test invalid terminating chunk terminator.
+		input = "2\r\n"
+			"xy\r\n"
+			"0\r\n"
+			"\rx";
+		ensure_equals(dechunker.feed(input.data(), input.size()), 11u);
+		ensure(!dechunker.acceptingInput());
+		ensure(dechunker.hasError());
+	}
+	
+	TEST_METHOD(26) {
+		// Test garbage.
+		for (int i = 0; i < 256; i++) {
+			input.append(1, (char) i);
+		}
+		dechunker.feed(input.data(), input.size());
+		ensure(!dechunker.acceptingInput());
+		ensure(dechunker.hasError());
+	}
+}