passenger 4.0.20 → 4.0.21

data/ext/nginx/ConfigurationCommands.c

@@ -242,7 +242,7 @@
 {
 	
 	ngx_string("passenger_set_cgi_param"),
-	NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_TAKE2,
+	NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_TAKE2,
 	set_null_terminated_keyval_slot,
 	NGX_HTTP_LOC_CONF_OFFSET,
 	offsetof(passenger_loc_conf_t, vars_source),

data/ext/nginx/ConfigurationCommands.c.erb

@@ -57,7 +57,7 @@ end
 
 def context_for(option)
 	context = option.fetch(:context, [:main, :srv, :loc, :lif])
-	return context.map{ |c| "NGX_HTTP_#{c.upcase}_CONF" }.join(" | ")
+	return context.map{ |c| "NGX_HTTP_#{c.to_s.upcase}_CONF" }.join(" | ")
 end
 
 def take_type_for(option)
@@ -89,6 +89,8 @@ def setter_function_for(option)
 		return "ngx_conf_set_str_array_slot"
 	when :string_keyval
 		return "set_null_terminated_keyval_slot"
+	when :path
+		return "ngx_conf_set_path_slot"
 	else
 		raise "Unknown type #{option[:type].inspect} for option #{option[:name]}"
 	end

data/ext/nginx/ContentHandler.c

@@ -1225,6 +1225,7 @@ passenger_content_handler(ngx_http_request_t *r)
     u_char                 page_cache_file_str[NGX_MAX_PATH + 1];
     ngx_str_t              page_cache_file;
     passenger_context_t   *context;
+    PP_Error               error;
 
     if (passenger_main_conf.root_dir.len == 0) {
         return NGX_DECLINED;
@@ -1303,18 +1304,40 @@ passenger_content_handler(ngx_http_request_t *r)
         return passenger_static_content_handler(r, &page_cache_file);
     }
     
+    pp_error_init(&error);
     if (slcf->app_root.data == NULL) {
         context->app_type = pp_app_type_detector_check_document_root(
             pp_app_type_detector,
             (const char *) context->public_dir.data, context->public_dir.len,
-            context->base_uri.len != 0);
+            context->base_uri.len != 0,
+            &error);
     } else {
         context->app_type = pp_app_type_detector_check_app_root(
             pp_app_type_detector,
-            (const char *) slcf->app_root.data, slcf->app_root.len);
+            (const char *) slcf->app_root.data, slcf->app_root.len,
+            &error);
     }
     if (context->app_type == PAT_NONE) {
         return NGX_DECLINED;
+    } else if (context->app_type == PAT_ERROR) {
+        if (error.errnoCode == EACCES) {
+            ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
+                          "%s; This error means that the Nginx worker process (PID %d, "
+                          "running as UID %d) does not have permission to access this file. "
+                          "Please read the manual to learn how to fix this problem: "
+                          "section 'Troubleshooting' -> 'Upon accessing the web app, Nginx "
+                          "reports a \"Permission denied\" error'; Extra info",
+                          error.message,
+                          (int) getpid(),
+                          (int) getuid());
+        } else {
+            ngx_log_error(NGX_LOG_ALERT, r->connection->log,
+                          (error.errnoCode == PP_NO_ERRNO) ? 0 : error.errnoCode,
+                          "%s",
+                          error.message);
+        }
+        pp_error_destroy(&error);
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
     }
     
     

data/ext/nginx/CreateLocationConfig.c

@@ -148,3 +148,4 @@
 	
 		conf->request_queue_overflow_status_code = NGX_CONF_UNSET;
 	
+

data/ext/nginx/CreateLocationConfig.c.erb

@@ -67,4 +67,4 @@ end
 	<% else %>
 		<% raise "Unknown option type #{option[:type].inspect} for option #{option[:name]}" %>
 	<% end %>
-<% end %>
+<% end %>

data/ext/nginx/MergeLocationConfig.c

@@ -170,3 +170,4 @@
 			prev->request_queue_overflow_status_code,
 			NGX_CONF_UNSET);
 	
+

data/ext/nginx/MergeLocationConfig.c.erb

@@ -69,4 +69,4 @@ end
 	<% else %>
 		<% raise "Unknown option type #{option[:type].inspect} for option #{option[:name]}" %>
 	<% end %>
-<% end %>
+<% end %>

data/ext/nginx/config

@@ -68,6 +68,18 @@ if [ $ngx_found = yes ]; then
     CORE_LIBS="$CORE_LIBS -lm"
 fi
 
+ngx_feature="POSIX realtime library"
+ngx_feature_name=
+ngx_feature_run=no
+ngx_feature_incs=
+ngx_feature_path=
+ngx_feature_libs="-lrt"
+ngx_feature_test=
+. auto/feature
+if [ $ngx_found = yes ]; then
+    CORE_LIBS="$CORE_LIBS -lrt"
+fi
+
 nginx_version=`grep 'NGINX_VERSION ' src/core/nginx.h | awk '{ print $3 }' | sed 's/"//g'`
 
 nginx_major_version=`echo "$nginx_version" | cut -d . -f 1`

data/ext/oxt/dynamic_thread_group.hpp

@@ -25,6 +25,7 @@
 #ifndef _OXT_DYNAMIC_THREAD_GROUP_HPP_
 #define _OXT_DYNAMIC_THREAD_GROUP_HPP_
 
+#include <vector>
 #include <list>
 #include <memory>
 
@@ -54,7 +55,7 @@ using namespace boost;
 class dynamic_thread_group {
 private:
 	struct thread_handle;
-	typedef shared_ptr<thread_handle> thread_handle_ptr;
+	typedef boost::shared_ptr<thread_handle> thread_handle_ptr;
 	
 	/** A container which aggregates a thread object
 	 * as well as the its own iterator in the 'thread_handles'
@@ -172,10 +173,11 @@ public:
 		list<thread_handle_ptr>::iterator it;
 		thread_handle_ptr handle;
 		unsigned int nthreads_copy = nthreads;
-		thread *threads[nthreads];
+		vector<thread *> threads;
 		unsigned int i = 0;
 		
 		// We make a copy so that the handles aren't destroyed prematurely.
+		threads.reserve(nthreads);
 		thread_handles_copy = thread_handles;
 		for (it = thread_handles.begin(); it != thread_handles.end(); it++, i++) {
 			handle = *it;
@@ -186,7 +188,7 @@ public:
 		nthreads = 0;
 		
 		l.unlock();
-		thread::interrupt_and_join_multiple(threads, nthreads_copy, interruptSyscalls);
+		thread::interrupt_and_join_multiple(&threads[0], nthreads_copy, interruptSyscalls);
 	}
 	
 	void join_all() {
@@ -196,10 +198,11 @@ public:
 		list<thread_handle_ptr>::iterator it;
 		thread_handle_ptr handle;
 		unsigned int nthreads_copy = nthreads;
-		thread *threads[nthreads];
+		vector<thread *> threads;
 		unsigned int i = 0;
 		
 		// We make a copy so that the handles aren't destroyed prematurely.
+		threads.reserve(nthreads);
 		thread_handles_copy = thread_handles;
 		for (it = thread_handles.begin(); it != thread_handles.end(); it++, i++) {
 			handle = *it;

data/ext/oxt/system_calls.cpp

@@ -72,6 +72,10 @@ oxt::setup_syscall_interruption_support() {
 
 void
 oxt::setup_random_failure_simulation(const ErrorChance *_errorChances, unsigned int n) {
+	if (n > OXT_MAX_ERROR_CHANCES) {
+		throw std::runtime_error("Number of error chances may not exceed OXT_MAX_ERROR_CHANCES");
+	}
+
 	ErrorChance *storage = new ErrorChance[n];
 	for (unsigned int i = 0; i < n; i++) {
 		storage[i] = _errorChances[i];
@@ -84,7 +88,7 @@ static bool
 shouldSimulateFailure() {
 	if (nErrorChances > 0) {
 		double number = random() / (double) RAND_MAX;
-		const ErrorChance *candidates[nErrorChances];
+		const ErrorChance *candidates[OXT_MAX_ERROR_CHANCES];
 		unsigned int i, n = 0;
 
 		for (i = 0; i < nErrorChances; i++) {

data/ext/oxt/system_calls.hpp

@@ -114,6 +114,7 @@
 
 namespace oxt {
 	static const int INTERRUPTION_SIGNAL = SIGUSR1; // SIGUSR2 is reserved by Valgrind...
+	#define OXT_MAX_ERROR_CHANCES 16
 	
 	struct ErrorChance {
 		double chance;
@@ -131,6 +132,8 @@ namespace oxt {
 	 * by oxt::thread::interrupt() or oxt::thread::interrupt_and_join().
 	 */
 	namespace syscalls {
+		using namespace std;
+
 		int open(const char *path, int oflag);
 		int open(const char *path, int oflag, mode_t mode);
 		ssize_t read(int fd, void *buf, size_t count);

data/helper-scripts/node-loader.js

@@ -23,243 +23,27 @@
  *  THE SOFTWARE.
  */
 
+module.paths.unshift(__dirname + "/../node_lib");
 var EventEmitter = require('events').EventEmitter;
 var net = require('net');
-GLOBAL.PhusionPassenger = new EventEmitter();
-
-/**
- * Class for reading a stream line-by-line.
- * Usage:
- *
- * reader = new LineReader(stream);
- * reader.readLine(function(line) {
- *     ...
- *     // When done:
- *     reader.close();
- * });
- */
-function LineReader(stream) {
-	var self = this;
-	this.stream = stream;
-
-	this.buffer = '';
-	this.lines = [];
-	this.callbacks = [];
-
-	function handleLineBuffer() {
-		if (self.lineBufferIsFull()) {
-			stream.pause();
-			self.paused = true;
-		}
-
-		while (self.buffer != undefined && self.lines.length > 0 && self.callbacks.length > 0) {
-			line = self.lines.shift();
-			callback = self.callbacks.shift();
-			callback(line);
-		}
-
-		if (self.buffer != undefined && !self.lineBufferIsFull() && self.paused) {
-			self.paused = false;
-			self.stream.resume();
-		}
-	}
-
-	function onData(data) {
-		var index, line, callback;
-
-		if (self.buffer == undefined) {
-			// Already closed.
-			return;
-		}
-
-		self.buffer += data;
-		while ((index = self.buffer.indexOf("\n")) != -1) {
-			line = self.buffer.substr(0, index + 1);
-			self.buffer = self.buffer.substr(index + 1);
-			self.lines.push(line);
-		}
-		handleLineBuffer();
-	}
-
-	function onEnd() {
-		if (self.buffer != undefined) {
-			self.lines.push(self.buffer);
-			self.buffer = '';
-			handleLineBuffer();
-			if (self.onEof) {
-				self.onEof();
-			}
-		}
-	}
-
-	this.onData = onData;
-	this.onEnd  = onEnd;
-	stream.on('data', onData);
-	stream.on('end', onEnd);
-	stream.resume();
-}
-
-LineReader.prototype.close = function() {
-	this.stream.pause();
-	this.stream.removeListener('data', this.onData);
-	this.stream.removeListener('end', this.onEnd);
-	this.buffer = undefined;
-	this.lines = undefined;
-}
-
-LineReader.prototype.lineBufferIsFull = function() {
-	return this.lines.length > 0;
-}
-
-LineReader.prototype.readLine = function(callback) {
-	if (this.lines.length > 0) {
-		var line = this.lines.shift();
-		if (!this.lineBufferIsFull() && this.paused) {
-			this.paused = false;
-			this.stream.resume();
-		}
-		callback(line);
-	} else {
-		this.callbacks.push(callback);
-	}
-}
-
-
-const
-	SPP_PARSING_SIZE = 0,
-	SPP_PARSING_HEADERS = 1,
-	SPP_DONE = 10,
-	SPP_ERROR = 11,
-	SPP_ENCODING = 'binary';
-
-function SessionProtocolParser() {
-	this.state = SPP_PARSING_SIZE;
-	this.processed = 0;
-	this.size = 0;
-	this.keys = [];
-}
-
-SessionProtocolParser.prototype.feed = function(buffer) {
-	var consumed = 0;
-	var locallyConsumed;
-
-	while (consumed < buffer.length && this.state != SPP_ERROR && this.state != SPP_DONE) {
-		switch (this.state) {
-		case SPP_PARSING_SIZE:
-			this.size += buffer[consumed] * Math.pow(256, 3 - this.processed);
-			locallyConsumed = 1;
-			this.processed++;
-			if (this.processed == 4) {
-				this.state = SPP_PARSING_HEADERS;
-				this.buffer = new Buffer(this.size);
-				this.processed = 0;
-			}
-			break;
-
-		case SPP_PARSING_HEADERS:
-			locallyConsumed = Math.min(buffer.length - consumed, this.buffer.length - this.processed);
-			buffer.copy(this.buffer, this.processed, consumed, consumed + locallyConsumed);
-			this.processed += locallyConsumed;
-			if (this.processed == this.buffer.length) {
-				this.state = SPP_DONE;
-				this.parse();
-			}
-			break;
-
-		default:
-			console.assert(false);
-			break;
-		}
-
-		consumed += locallyConsumed;
-	}
-
-	return consumed;
-}
-
-SessionProtocolParser.prototype.parse = function() {
-	function findZero(buffer, start) {
-		while (start < buffer.length) {
-			if (buffer[start] == 0) {
-				return start;
-			} else {
-				start++;
-			}
-		}
-		return -1;
-	}
-
-	var start = 0;
-	var key, value;
-
-	while (start < this.buffer.length) {
-		var keyEnd = findZero(this.buffer, start);
-		if (keyEnd != -1 && keyEnd + 1 < this.buffer.length) {
-			var valueStart = keyEnd + 1;
-			var valueEnd   = findZero(this.buffer, valueStart);
-			if (valueEnd != -1) {
-				key = this.buffer.toString(SPP_ENCODING, start, keyEnd);
-				value = this.buffer.toString(SPP_ENCODING, valueStart, valueEnd);
-				start = valueEnd + 1;
-				this.keys.push(key);
-				this[key] = value;
-			} else {
-				start = this.buffer.length;
-			}
-		} else {
-			start = this.buffer.length;
-		}
-	}
-}
-
-//var p = new SessionProtocolParser();
-//p.feed(new Buffer("\x00\x00\x00\x06hi\0ho\0"));
-//process.exit();
+var http = require('http');
 
+var LineReader = require('phusion_passenger/line_reader').LineReader;
+var RequestHandler = require('phusion_passenger/request_handler').RequestHandler;
+var HttplibEmulation = require('phusion_passenger/httplib_emulation');
 
-function RequestHandler(readyCallback, clientCallback) {
-	var self = this;
-
-	function handleNewClient(socket) {
-		var state = 'PARSING_HEADER';
-		var parser = new SessionProtocolParser();
-
-		function handleData(data) {
-			if (state == 'PARSING_HEADER') {
-				var consumed = parser.feed(data);
-				if (parser.state == SPP_DONE) {
-					state = 'HEADER_SEEN';
-					socket.removeListener('data', handleData);
-					PhusionPassenger.emit('request', parser, socket);
-					if (consumed != data.length) {
-						socket.emit('data', data.slice(consumed));
-					}
-				} else if (parser.state == SPP_ERROR) {
-					console.error('Header parse error');
-					socket.destroySoon();
-				}
-			} else {
-				// Do nothing.
-			}
-		}
+GLOBAL.PhusionPassenger = new EventEmitter();
+var stdinReader = new LineReader(process.stdin);
+beginHandshake();
+readInitializationHeader();
 
-		socket.on('data', handleData);
-	}
 
-	var server = net.createServer({ allowHalfOpen: true }, handleNewClient);
-	this.server = server;
-	server.listen(0, function() {
-		readyCallback(self);
-	});
+function beginHandshake() {
+	process.stdout.write("!> I have control 1.0\n");
 }
 
-
-/**************************/
-
-var reader = new LineReader(process.stdin);
-
 function readInitializationHeader() {
-	reader.readLine(function(line) {
+	stdinReader.readLine(function(line) {
 		if (line != "You have control 1.0\n") {
 			console.error('Invalid initialization header');
 			process.exit(1);
@@ -273,9 +57,9 @@ function readOptions() {
 	var options = {};
 
 	function readNextOption() {
-		reader.readLine(function(line) {
+		stdinReader.readLine(function(line) {
 			if (line == "\n") {
-				initialize(options);
+				setupEnvironment(options);
 			} else if (line == "") {
 				console.error("End of stream encountered while reading initialization options");
 				process.exit(1);
@@ -290,29 +74,113 @@ function readOptions() {
 	readNextOption();
 }
 
-function initialize(options) {
+function setupEnvironment(options) {
 	PhusionPassenger.options = options;
+	PhusionPassenger.configure = configure;
+	PhusionPassenger._requestHandler = new RequestHandler(loadApplication);
+	PhusionPassenger._appInstalled = false;
+	http.Server.prototype.originalListen = http.Server.prototype.listen;
+	http.Server.prototype.listen = installServer;
+
+	stdinReader.close();
+	stdinReader = undefined;
+	process.stdin.on('end', shutdown);
+	process.stdin.resume();
+}
 
-	PhusionPassenger.requestHandler = new RequestHandler(function() {
-		require(options.app_root + '/passenger_node.js');
-		process.stdout.write("!> Ready\n");
-		process.stdout.write("!> socket: main;tcp://127.0.0.1:" +
-			PhusionPassenger.requestHandler.server.address().port +
-			";session;0\n");
-		process.stdout.write("!> \n");
-	});
+/**
+ * PhusionPassenger.configure(options)
+ *
+ * Configures Phusion Passenger's behavior inside this Node application.
+ *
+ * Options:
+ *   autoInstall (boolean, default true)
+ *     Whether to install the first HttpServer object for which listen() is called,
+ *     as the Phusion Passenger request handler.
+ */
+function configure(_options) {
+	var options = {
+		autoInstall: true
+	};
+	for (var key in _options) {
+		options[key] = _options[key];
+	}
 
-	reader.close();
-	reader = undefined;
-	process.stdin.on('end', function() {
-		if (PhusionPassenger.listeners('exit').length == 0) {
-			process.exit(0);
+    if (!options.autoInstall) {
+		http.Server.prototype.listen = listenAndMaybeInstall;
+	}
+}
+
+function loadApplication() {
+	require(PhusionPassenger.options.app_root + '/app.js');
+}
+
+function extractCallback(args) {
+	if (args.length > 1 && typeof(args[args.length - 1]) == 'function') {
+		return args[args.length - 1];
+	}
+}
+
+function installServer() {
+	var server = this;
+	if (!PhusionPassenger._appInstalled) {
+		PhusionPassenger._appInstalled = true;
+		PhusionPassenger._server = server;
+		finalizeStartup();
+
+		PhusionPassenger.on('request', function(headers, socket, bodyBegin) {
+			var req = HttplibEmulation.createIncomingMessage(headers, socket, bodyBegin);
+			if (req.headers['upgrade']) {
+				if (EventEmitter.listenerCount(server, 'upgrade') > 0) {
+					server.emit('upgrade', req, socket, bodyBegin);
+				} else {
+					socket.destroy();
+				}
+			} else {
+				var res = HttplibEmulation.createServerResponse(req);
+				server.emit('request', req, res);
+			}
+		});
+
+		var callback = extractCallback(arguments);
+		if (callback) {
+			server.once('listening', callback);
+		}
+		server.emit('listening');
+	} else {
+		throw new Error("http.Server.listen() was called more than once, which " +
+			"is not allowed because Phusion Passenger is in auto-install mode. " +
+			"This means that the first http.Server object for which listen() is called, " +
+			"is automatically installed as the Phusion Passenger request handler. " +
+			"If you want to create and listen on multiple http.Server object then " +
+			"you should disable auto-install mode.");
+	}
+}
+
+function listenAndMaybeInstall(port) {
+	if (port === 'passenger') {
+		if (!PhusionPassenger._appInstalled) {
+			installServer.apply(this, arguments);
 		} else {
-			PhusionPassenger.emit('exit');
+			throw new Error("You may only call listen('passenger') once");
 		}
-	});
-	process.stdin.resume();
+	} else {
+		this.originalListen.apply(this, arguments);
+	}
 }
 
-process.stdout.write("!> I have control 1.0\n");
-readInitializationHeader();
+function finalizeStartup() {
+	process.stdout.write("!> Ready\n");
+	process.stdout.write("!> socket: main;tcp://127.0.0.1:" +
+		PhusionPassenger._requestHandler.server.address().port +
+		";session;0\n");
+	process.stdout.write("!> \n");
+}
+
+function shutdown() {
+	if (PhusionPassenger.listeners('exit').length == 0) {
+		process.exit(0);
+	} else {
+		PhusionPassenger.emit('exit');
+	}
+}