passenger 2.2.2 → 2.2.3

data/ext/boost/mpl/apply.hpp

@@ -135,7 +135,10 @@ struct apply
 
 ///// iteration, depth == 1
 
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
 
 #   define i_ BOOST_PP_FRAME_ITERATION(1)
 
@@ -222,4 +225,5 @@ struct apply_chooser<i_>
 
 #   undef i_
 
+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif // BOOST_PP_IS_ITERATING

data/ext/boost/mpl/apply_wrap.hpp

@@ -78,7 +78,10 @@ namespace boost { namespace mpl {
 
 ///// iteration, depth == 1
 
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else
+#if BOOST_PP_ITERATION_DEPTH() == 1
 
 #   define i_ BOOST_PP_FRAME_ITERATION(1)
 
@@ -196,5 +199,5 @@ struct BOOST_PP_CAT(apply_wrap_impl,i_)<
 };
 
 #   undef j_
-
+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif // BOOST_PP_IS_ITERATING

data/ext/boost/mpl/aux_/full_lambda.hpp

@@ -227,7 +227,10 @@ BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda)
 
 ///// iteration, depth == 1
 
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
 #define i_ BOOST_PP_FRAME_ITERATION(1)
 
 #if i_ > 0
@@ -347,4 +350,5 @@ struct lambda<
 };
 
 #undef i_
+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif // BOOST_PP_IS_ITERATING

data/ext/boost/mpl/bind.hpp

@@ -361,7 +361,10 @@ BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(
 
 ///// iteration, depth == 1
 
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
 
 #   define i_ BOOST_PP_FRAME_ITERATION(1)
 
@@ -544,4 +547,5 @@ struct bind_chooser<i_>
 #   endif
 #   undef j_
 
+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif // BOOST_PP_IS_ITERATING

data/ext/common/Application.h

@@ -283,7 +283,7 @@ private:
 			if (fd != -1) {
 				int ret = syscalls::shutdown(fd, SHUT_RD);
 				if (ret == -1) {
-					throw SystemException("Cannot shutdown the writer stream",
+					throw SystemException("Cannot shutdown the reader stream",
 						errno);
 				}
 			}
@@ -304,11 +304,16 @@ private:
 			TRACE_POINT();
 			if (fd != -1) {
 				int ret = syscalls::close(fd);
+				fd = -1;
 				if (ret == -1) {
-					throw SystemException("Cannot close the session stream",
-						errno);
+					if (errno == EIO) {
+						throw SystemException("A write operation on the session stream failed",
+							errno);
+					} else {
+						throw SystemException("Cannot close the session stream",
+							errno);
+					}
 				}
-				fd = -1;
 			}
 		}
 		
@@ -329,33 +334,7 @@ private:
 	
 	SessionPtr connectToUnixServer(const function<void()> &closeCallback) const {
 		TRACE_POINT();
-		int fd, ret;
-		
-		do {
-			fd = socket(PF_UNIX, SOCK_STREAM, 0);
-		} while (fd == -1 && errno == EINTR);
-		if (fd == -1) {
-			throw SystemException("Cannot create a new unconnected Unix socket", errno);
-		}
-		
-		struct sockaddr_un addr;
-		addr.sun_family = AF_UNIX;
-		strncpy(addr.sun_path, listenSocketName.c_str(), sizeof(addr.sun_path));
-		addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
-		do {
-			ret = ::connect(fd, (const sockaddr *) &addr, sizeof(addr));
-		} while (ret == -1 && errno == EINTR);
-		if (ret == -1) {
-			int e = errno;
-			string message("Cannot connect to Unix socket '");
-			message.append(listenSocketName);
-			message.append("'");
-			do {
-				ret = close(fd);
-			} while (ret == -1 && errno == EINTR);
-			throw SystemException(message, e);
-		}
-		
+		int fd = Passenger::connectToUnixServer(listenSocketName.c_str());
 		return ptr(new StandardSession(pid, closeCallback, fd));
 	}
 	
@@ -510,6 +489,7 @@ public:
 	 * @post this->getSessions() == old->getSessions() + 1
 	 * @throws SystemException Something went wrong during the connection process.
 	 * @throws IOException Something went wrong during the connection process.
+	 * @throws boost::thread_interrupted
 	 */
 	SessionPtr connect(const function<void()> &closeCallback) const {
 		TRACE_POINT();

data/ext/common/ApplicationPool.h

@@ -126,7 +126,8 @@ public:
 	 * @throw BusyException The application pool is too busy right now, and cannot
 	 *       satisfy the request. One should either abort, or try again later.
 	 * @throw IOException Something else went wrong.
-	 * @throw thread_interrupted
+	 * @throw boost::thread_interrupted
+	 * @throws Anything thrown by options.environmentVariables->getItems().
 	 * @note Applications are uniquely identified with the application root
 	 *       string. So although <tt>appRoot</tt> does not have to be absolute, it
 	 *       should be. If one calls <tt>get("/home/foo")</tt> and

data/ext/common/ApplicationPoolServer.h

@@ -216,7 +216,7 @@ private:
 			if (fd != -1) {
 				int ret = syscalls::shutdown(fd, SHUT_RD);
 				if (ret == -1) {
-					throw SystemException("Cannot shutdown the writer stream",
+					throw SystemException("Cannot shutdown the reader stream",
 						errno);
 				}
 			}
@@ -235,11 +235,16 @@ private:
 		virtual void closeStream() {
 			if (fd != -1) {
 				int ret = syscalls::close(fd);
+				fd = -1;
 				if (ret == -1) {
-					throw SystemException("Cannot close the session stream",
-						errno);
+					if (errno == EIO) {
+						throw SystemException("A write operation on the session stream failed",
+							errno);
+					} else {
+						throw SystemException("Cannot close the session stream",
+							errno);
+					}
 				}
-				fd = -1;
 			}
 		}
 		
@@ -380,12 +385,18 @@ private:
 			vector<string> args;
 			int stream;
 			bool result;
+			bool serverMightNeedEnvironmentVariables = true;
 			
+			/* Send a 'get' request to the ApplicationPool server.
+			 * For efficiency reasons, we do not send the data for
+			 * options.environmentVariables over the wire yet until
+			 * it's necessary.
+			 */
 			try {
 				vector<string> args;
 				
 				args.push_back("get");
-				options.toVector(args);
+				options.toVector(args, false);
 				channel.write(args);
 			} catch (const SystemException &e) {
 				UPDATE_TRACE_POINT();
@@ -395,22 +406,52 @@ private:
 				message.append(e.brief());
 				throw SystemException(message, e.code());
 			}
-			try {
-				UPDATE_TRACE_POINT();
-				result = channel.read(args);
-			} catch (const SystemException &e) {
-				UPDATE_TRACE_POINT();
-				data->disconnect();
-				throw SystemException("Could not read a message from "
-					"the ApplicationPool server", e.code());
-			}
-			if (!result) {
-				UPDATE_TRACE_POINT();
-				data->disconnect();
-				throw IOException("The ApplicationPool server unexpectedly "
-					"closed the connection while we're reading a response "
-					"for the 'get' command.");
+			
+			/* The first few replies from the server might be for requesting
+			 * environment variables in the pool options object, so keep handling
+			 * these requests until we receive a different reply.
+			 */
+			while (serverMightNeedEnvironmentVariables) {
+				try {
+					result = channel.read(args);
+				} catch (const SystemException &e) {
+					UPDATE_TRACE_POINT();
+					data->disconnect();
+					throw SystemException("Could not read a response from "
+						"the ApplicationPool server for the 'get' command", e.code());
+				}
+				if (!result) {
+					UPDATE_TRACE_POINT();
+					data->disconnect();
+					throw IOException("The ApplicationPool server unexpectedly "
+						"closed the connection while we're reading a response "
+						"for the 'get' command.");
+				}
+				
+				if (args[0] == "getEnvironmentVariables") {
+					try {
+						if (options.environmentVariables) {
+							UPDATE_TRACE_POINT();
+							channel.writeScalar(options.serializeEnvironmentVariables());
+						} else {
+							UPDATE_TRACE_POINT();
+							channel.writeScalar("");
+						}
+					} catch (const SystemException &e) {
+						data->disconnect();
+						throw SystemException("Could not send a response "
+							"for the 'getEnvironmentVariables' request "
+							"to the ApplicationPool server",
+							e.code());
+					}
+				} else {
+					serverMightNeedEnvironmentVariables = false;
+				}
 			}
+			
+			/* We've now received a reply other than "getEnvironmentVariables".
+			 * Handle this...
+			 */
 			if (args[0] == "ok") {
 				UPDATE_TRACE_POINT();
 				pid_t pid = (pid_t) atol(args[1]);

data/ext/common/ApplicationPoolServerExecutable.cpp

@@ -288,6 +288,131 @@ private:
 	/** Last used session ID. */
 	int lastSessionID;
 	
+	class ClientCommunicationError: public oxt::tracable_exception {
+	private:
+		string briefMessage;
+		string systemMessage;
+		string fullMessage;
+		int m_code;
+	public:
+		/**
+		 * Create a new ClientCommunicationError.
+		 *
+		 * @param briefMessage A brief message describing the error.
+		 * @param errorCode An optional error code, i.e. the value of errno right after the error occured, if applicable.
+		 * @note A system description of the error will be appended to the given message.
+		 *    For example, if <tt>errorCode</tt> is <tt>EBADF</tt>, and <tt>briefMessage</tt>
+		 *    is <em>"Something happened"</em>, then what() will return <em>"Something happened: Bad
+		 *    file descriptor (10)"</em> (if 10 is the number for EBADF).
+		 * @post code() == errorCode
+		 * @post brief() == briefMessage
+		 */
+		ClientCommunicationError(const string &briefMessage, int errorCode = -1) {
+			if (errorCode != -1) {
+				stringstream str;
+				
+				str << strerror(errorCode) << " (" << errorCode << ")";
+				systemMessage = str.str();
+			}
+			setBriefMessage(briefMessage);
+			m_code = errorCode;
+		}
+
+		virtual ~ClientCommunicationError() throw() {}
+
+		virtual const char *what() const throw() {
+			return fullMessage.c_str();
+		}
+
+		void setBriefMessage(const string &message) {
+			briefMessage = message;
+			if (systemMessage.empty()) {
+				fullMessage = briefMessage;
+			} else {
+				fullMessage = briefMessage + ": " + systemMessage;
+			}
+		}
+
+		/**
+		 * The value of <tt>errno</tt> at the time the error occured.
+		 */
+		int code() const throw() {
+			return m_code;
+		}
+
+		/**
+		 * Returns a brief version of the exception message. This message does
+		 * not include the system error description, and is equivalent to the
+		 * value of the <tt>message</tt> parameter as passed to the constructor.
+		 */
+		string brief() const throw() {
+			return briefMessage;
+		}
+
+		/**
+		 * Returns the system's error message. This message contains both the
+		 * content of <tt>strerror(errno)</tt> and the errno number itself.
+		 *
+		 * @post if code() == -1: result.empty()
+		 */
+		string sys() const throw() {
+			return systemMessage;
+		}
+	};
+	
+	/**
+	 * A StringListCreator which fetches its items from the client.
+	 * Used as an optimization for ApplicationPoolServer::Client.get():
+	 * environment variables are only serialized by the client process
+	 * if a new backend process is being spawned.
+	 */
+	class EnvironmentVariablesFetcher: public StringListCreator {
+	private:
+		MessageChannel &channel;
+		PoolOptions &options;
+	public:
+		EnvironmentVariablesFetcher(MessageChannel &theChannel, PoolOptions &theOptions)
+			: channel(theChannel),
+			  options(theOptions)
+		{ }
+		
+		/**
+		 * @throws ClientCommunicationError
+		 */
+		virtual const StringListPtr getItems() const {
+			string data;
+			
+			/* If an I/O error occurred while communicating with the client,
+			 * then throw a ClientCommunicationException, which will bubble
+			 * all the way up to the thread main loop, where the connection
+			 * with the client will be broken.
+			 */
+			try {
+				channel.write("getEnvironmentVariables", NULL);
+			} catch (const SystemException &e) {
+				throw ClientCommunicationError(
+					"Unable to send a 'getEnvironmentVariables' request to the client",
+					e.code());
+			}
+			try {
+				if (!channel.readScalar(data)) {
+					throw ClientCommunicationError("Unable to read a reply from the client for the 'getEnvironmentVariables' request.");
+				}
+			} catch (const SystemException &e) {
+				throw ClientCommunicationError(
+					"Unable to read a reply from the client for the 'getEnvironmentVariables' request",
+					e.code());
+			}
+			
+			if (!data.empty()) {
+				SimpleStringListCreator list(data);
+				return list.getItems();
+			} else {
+				return ptr(new StringList());
+			}
+		}
+	};
+	
 	void processGet(const vector<string> &args) {
 		TRACE_POINT();
 		Application::SessionPtr session;
@@ -295,6 +420,7 @@ private:
 		
 		try {
 			PoolOptions options(args, 1);
+			options.environmentVariables = ptr(new EnvironmentVariablesFetcher(channel, options));
 			session = server.pool->get(options);
 			sessions[lastSessionID] = session;
 			lastSessionID++;
@@ -331,12 +457,14 @@ private:
 				UPDATE_TRACE_POINT();
 				channel.write("ok", toString(session->getPid()).c_str(),
 					toString(lastSessionID - 1).c_str(), NULL);
+				UPDATE_TRACE_POINT();
 				channel.writeFileDescriptor(session->getStream());
-				session->closeStream();
-			} catch (const exception &) {
 				UPDATE_TRACE_POINT();
-				P_TRACE(3, "Client " << this << ": something went wrong "
-					"while sending 'ok' back to the client.");
+				session->closeStream();
+			} catch (const exception &e) {
+				P_TRACE(3, "Client " << this << ": could not send "
+					"'ok' back to the ApplicationPool client: " <<
+					e.what());
 				sessions.erase(lastSessionID - 1);
 				throw;
 			}

data/ext/common/ApplicationPoolStatusReporter.h

@@ -33,6 +33,8 @@
 
 #include <string>
 #include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
 #include <sys/stat.h>
 #include <cstdio>
 #include <unistd.h>
@@ -40,6 +42,7 @@
 
 #include "StandardApplicationPool.h"
 #include "MessageChannel.h"
+#include "Exceptions.h"
 #include "Logging.h"
 #include "Utils.h"
 
@@ -51,72 +54,176 @@ using namespace std;
 
 /**
  * An ApplicationPoolStatusReporter allows commandline admin tools to inspect
- * the status of a StandardApplicationPool. It does so by creating a FIFO
- * in the Passenger temp folder.
+ * the status of a StandardApplicationPool. It does so by creating a Unix socket
+ * in the Passenger temp folder, which tools can connect to to query for
+ * information.
  *
- * An ApplicationPoolStatusReporter creates a background thread, which
- * continuously sends new information through the FIFO. This thread will
- * be automatically cleaned up upon destroying the ApplicationPoolStatusReporter
- * object.
+ * An ApplicationPoolStatusReporter creates a background thread for handling
+ * connections on the socket. This thread will be automatically cleaned up upon
+ * destroying the ApplicationPoolStatusReporter object.
  */
 class ApplicationPoolStatusReporter {
 private:
+	/**
+	 * Wrapper class around a file descriptor integer, for RAII behavior.
+	 *
+	 * A FileDescriptor object behaves just like an int, so that you can pass it to
+	 * system calls such as read(). It performs reference counting. When the last
+	 * copy of a FileDescriptor has been destroyed, the underlying file descriptor
+	 * will be automatically closed.
+	 */
+	class FileDescriptor {
+	private:
+		struct SharedData {
+			int fd;
+
+			/**
+			 * Constructor to assign this file descriptor's handle.
+			 */
+			SharedData(int fd) {
+				this->fd = fd;
+			}
+
+			/**
+			 * Attempts to close this file descriptor. When created on the stack,
+			 * this destructor will automatically be invoked as a result of C++
+			 * semantics when exiting the scope this object was created in. This
+			 * ensures that stack created objects with destructors like these will
+			 * de-allocate their resources upon leaving their corresponding scope.
+			 * This pattern is also known Resource Acquisition Is Initialization (RAII).
+			 *
+			 * @throws SystemException File descriptor could not be closed.
+			 */
+			~SharedData() {
+				this_thread::disable_syscall_interruption dsi;
+				if (syscalls::close(fd) == -1) {
+					throw SystemException("Cannot close file descriptor", errno);
+				}
+			}
+		};
+
+		/* Shared pointer for reference counting on this file descriptor */
+		shared_ptr<SharedData> data;
+
+	public:
+		FileDescriptor() {
+			// Do nothing.
+		}
+
+		/**
+		 * Creates a new FileDescriptor instance with the given fd as a handle.
+		 */
+		FileDescriptor(int fd) {
+			data = ptr(new SharedData(fd));
+		}
+
+		/**
+		 * Overloads the integer cast operator so that it will return the file
+		 * descriptor handle as an integer.
+		 *
+		 * @return This file descriptor's handle as an integer.
+		 */
+		operator int () const {
+			return data->fd;
+		}
+	};
+	
 	/** The application pool to monitor. */
 	StandardApplicationPoolPtr pool;
 	
-	/** The FIFO's filename. */
+	/** The socket's filename. */
 	char filename[PATH_MAX];
 	
-	/** The background thread. */
-	oxt::thread *thr;
+	/** The socket's file descriptor. */
+	int serverFd;
+	
+	/** The main thread. */
+	oxt::thread *mainThread;
 	
-	void threadMain() {
+	/** The mutex which protects the 'threads' member. */
+	boost::mutex threadsLock;
+	
+	/** A map which maps a client file descriptor to its handling thread. */
+	map< int, shared_ptr<oxt::thread> > threads;
+	
+	void writeScalarAndIgnoreErrors(MessageChannel &channel, const string &data) {
+		try {
+			channel.writeScalar(data);
+		} catch (const SystemException &e) {
+			// Don't care about write errors.
+		}
+	}
+	
+	void mainThreadFunction() {
 		TRACE_POINT();
 		try {
 			while (!this_thread::interruption_requested()) {
-				struct stat buf;
-				int ret;
-				
 				UPDATE_TRACE_POINT();
-				do {
-					ret = stat(filename, &buf);
-				} while (ret == -1 && errno == EINTR);
-				if (ret == -1 || !S_ISFIFO(buf.st_mode)) {
-					// Something bad happened with the status
-					// report FIFO, so we bail out.
-					break;
-				}
+				sockaddr_un addr;
+				socklen_t addr_len = sizeof(addr);
 				
-				UPDATE_TRACE_POINT();
-				FILE *f = syscalls::fopen(filename, "w");
-				if (f == NULL) {
+				FileDescriptor fd(syscalls::accept(serverFd, (struct sockaddr *) &addr, &addr_len));
+				if (fd == -1) {
 					int e = errno;
-					P_ERROR("Cannot open status report FIFO " <<
-						filename << ": " <<
+					P_ERROR("Cannot accept new client on status reporter socket: " <<
 						strerror(e) << " (" << e << ")");
 					break;
 				}
 				
-				UPDATE_TRACE_POINT();
-				MessageChannel channel(fileno(f));
-				string report;
-				report.append("----------- Backtraces -----------\n");
-				report.append(oxt::thread::all_backtraces());
-				report.append("\n\n");
-				report.append(pool->toString());
+				boost::lock_guard<boost::mutex> l(threadsLock);
+				this_thread::disable_syscall_interruption dsi;
+				this_thread::disable_interruption di;
+				shared_ptr<oxt::thread> thread(new oxt::thread(
+					bind(&ApplicationPoolStatusReporter::clientThreadFunction, this, fd),
+					"Status reporter client thread " + toString(fd),
+					1024 * 128
+				));
+				threads[fd] = thread;
+			}
+		} catch (const boost::thread_interrupted &) {
+			P_TRACE(2, "Status reporter main thread interrupted.");
+		} catch (const exception &e) {
+			P_ERROR("Error in status reporter main thread: " << e.what());
+		}
+	}
+	
+	void clientThreadFunction(FileDescriptor fd) {
+		TRACE_POINT();
+		MessageChannel channel(fd);
+		
+		try {
+			while (!this_thread::interruption_requested()) {
+				vector<string> args;
 				
 				UPDATE_TRACE_POINT();
-				try {
-					channel.writeScalar(report);
-					channel.writeScalar(pool->toXml());
-				} catch (...) {
-					// Ignore write errors.
+				if (!channel.read(args) || args.size() < 1) {
+					break;
+				}
+				
+				if (args[0] == "backtraces") {
+					UPDATE_TRACE_POINT();
+					writeScalarAndIgnoreErrors(channel, oxt::thread::all_backtraces());
+				} else if (args[0] == "status") {
+					UPDATE_TRACE_POINT();
+					writeScalarAndIgnoreErrors(channel, pool->toString());
+				} else if (args[0] == "status_xml") {
+					UPDATE_TRACE_POINT();
+					writeScalarAndIgnoreErrors(channel, pool->toXml());
+				} else {
+					P_ERROR("Error in status reporter client thread: unknown query '" <<
+						args[0] << "'.");
 				}
-				syscalls::fclose(f);
 			}
 		} catch (const boost::thread_interrupted &) {
-			P_TRACE(2, "Status report thread interrupted.");
+			P_TRACE(2, "Status reporter client thread " << fd << " interrupted.");
+		} catch (const exception &e) {
+			P_ERROR("Error in status reporter client thread: " << e.what());
 		}
+		
+		boost::lock_guard<boost::mutex> l(threadsLock);
+		this_thread::disable_syscall_interruption dsi;
+		this_thread::disable_interruption di;
+		threads.erase(fd);
 	}
 
 public:
@@ -134,9 +241,11 @@ public:
 	 *            -1 if the current user should be set as owner.
 	 * @param gid The GID of the user who should own the FIFO file, or
 	 *            -1 if the current group should be set as group.
-	 * @throws SystemException An error occurred while creating the FIFO.
+	 * @throws RuntimeException An error occurred.
+	 * @throws SystemException An error occurred while creating the server socket.
 	 * @throws boost::thread_resource_error Something went wrong during
 	 *     creation of the thread.
+	 * @throws boost::thread_interrupted A system call has been interrupted.
 	 */
 	ApplicationPoolStatusReporter(StandardApplicationPoolPtr &pool,
 	                              bool userSwitching,
@@ -149,27 +258,17 @@ public:
 		createPassengerTempDir(getSystemTempDir(), userSwitching,
 			"nobody", geteuid(), getegid());
 		
-		snprintf(filename, sizeof(filename) - 1, "%s/info/status.fifo",
+		snprintf(filename, sizeof(filename) - 1, "%s/info/status.socket",
 			getPassengerTempDir().c_str());
 		filename[PATH_MAX - 1] = '\0';
+		serverFd = createUnixServer(filename, 10);
 		
-		do {
-			ret = mkfifo(filename, permissions);
-		} while (ret == -1 && errno == EINTR);
-		if (ret == -1 && errno != EEXIST) {
-			int e = errno;
-			string message("Cannot create FIFO '");
-			message.append(filename);
-			message.append("'");
-			throw SystemException(message, e);
-		}
-		
-		// It seems that the permissions passed to mkfifo()
-		// aren't respected, so here we chmod the file.
+		/* Set the socket file's permissions... */
 		do {
 			ret = chmod(filename, permissions);
 		} while (ret == -1 && errno == EINTR);
 		
+		/* ...and ownership. */
 		if (uid != (uid_t) -1 && gid != (gid_t) -1) {
 			do {
 				ret = chown(filename, uid, gid);
@@ -179,31 +278,56 @@ public:
 				char message[1024];
 				
 				snprintf(message, sizeof(message) - 1,
-					"Cannot set the FIFO file '%s' its owner to %lld and group to %lld",
+					"Cannot set the owner for socket file '%s' to %lld and its group to %lld",
 					filename, (long long) uid, (long long) gid);
 				message[sizeof(message) - 1] = '\0';
+				do {
+					ret = close(serverFd);
+				} while (ret == -1 && errno == EINTR);
 				throw SystemException(message, e);
 			}
 		}
 		
-		thr = new oxt::thread(
-			bind(&ApplicationPoolStatusReporter::threadMain, this),
-			"Status report thread",
-			1024 * 128
-		);
+		try {
+			mainThread = new oxt::thread(
+				bind(&ApplicationPoolStatusReporter::mainThreadFunction, this),
+				"Status reporter main thread",
+				1024 * 128
+			);
+		} catch (...) {
+			do {
+				ret = close(serverFd);
+			} while (ret == -1 && errno == EINTR);
+			throw;
+		}
 	}
 	
 	~ApplicationPoolStatusReporter() {
 		this_thread::disable_syscall_interruption dsi;
 		this_thread::disable_interruption di;
-		
-		thr->interrupt_and_join();
-		delete thr;
-		
 		int ret;
+		
 		do {
 			ret = unlink(filename);
 		} while (ret == -1 && errno == EINTR);
+		
+		mainThread->interrupt_and_join();
+		delete mainThread;
+		
+		do {
+			ret = close(serverFd);
+		} while (ret == -1 && errno == EINTR);
+		
+		/* We make a copy of the data structure here to avoid deadlocks. */
+		map< int, shared_ptr<oxt::thread> > threadsCopy;
+		{
+			boost::lock_guard<boost::mutex> l(threadsLock);
+			threadsCopy = threads;
+		}
+		map< int, shared_ptr<oxt::thread> >::iterator it;
+		for (it = threadsCopy.begin(); it != threadsCopy.end(); it++) {
+			it->second->interrupt_and_join();
+		}
 	}
 };