passenger 3.0.21 → 3.9.1.beta

data/ext/common/Utils.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2010 Phusion
+ *  Copyright (c) 2010, 2011, 2012 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -41,6 +41,7 @@
 #include <limits.h>
 #include <unistd.h>
 #include <signal.h>
+#include <vector>
 #include <FileDescriptor.h>
 #include <MessageServer.h>
 #include <ResourceLocator.h>
@@ -236,7 +237,7 @@ canonicalizePath(const string &path) {
 }
 
 string
-resolveSymlink(const string &path) {
+resolveSymlink(const StaticString &path) {
 	char buf[PATH_MAX];
 	ssize_t size;
 	
@@ -247,7 +248,7 @@ resolveSymlink(const string &path) {
 		} else {
 			int e = errno;
 			string message = "Cannot resolve possible symlink '";
-			message.append(path);
+			message.append(path.c_str(), path.size());
 			message.append("'");
 			throw FileSystemException(message, e, path);
 		}
@@ -255,7 +256,7 @@ resolveSymlink(const string &path) {
 		buf[size] = '\0';
 		if (buf[0] == '\0') {
 			string message = "The file '";
-			message.append(path);
+			message.append(path.c_str(), path.size());
 			message.append("' is a symlink, and it refers to an empty filename. This is not allowed.");
 			throw FileSystemException(message, ENOENT, path);
 		} else if (buf[0] == '/') {
@@ -439,6 +440,63 @@ parseModeString(const StaticString &mode) {
 	return modeBits;
 }
 
+string
+absolutizePath(const StaticString &path, const StaticString &workingDir) {
+	vector<string> components;
+	if (!startsWith(path, "/")) {
+		if (workingDir.empty()) {
+			char buffer[PATH_MAX];
+			getcwd(buffer, sizeof(buffer));
+			split(buffer + 1, '/', components);
+		} else {
+			string absoluteWorkingDir = absolutizePath(workingDir);
+			split(StaticString(absoluteWorkingDir.data() + 1, absoluteWorkingDir.size() - 1),
+				'/', components);
+		}
+	}
+
+	const char *begin = path.data();
+	const char *end = path.data() + path.size();
+
+	// Skip leading slashes.
+	while (begin < end && *begin == '/') {
+		begin++;
+	}
+
+	while (begin < end) {
+		const char *next = (const char *) memchr(begin, '/', end - begin);
+		if (next == NULL) {
+			next = end;
+		}
+
+		StaticString component(begin, next - begin);
+		if (component == "..") {
+			if (!components.empty()) {
+				components.pop_back();
+			}
+		} else if (component != ".") {
+			components.push_back(component);
+		}
+
+		// Skip slashes until beginning of next path component.
+		begin = next + 1;
+		while (begin < end && *begin == '/') {
+			begin++;
+		}
+	}
+
+	string result;
+	vector<string>::const_iterator c_it, c_end = components.end();
+	for (c_it = components.begin(); c_it != c_end; c_it++) {
+		result.append("/");
+		result.append(*c_it);
+	}
+	if (result.empty()) {
+		result = "/";
+	}
+	return result;
+}
+
 const char *
 getSystemTempDir() {
 	const char *temp_dir = getenv("PASSENGER_TEMP_DIR");
@@ -528,27 +586,54 @@ makeDirTree(const string &path, const StaticString &mode, uid_t owner, gid_t gro
 
 void
 removeDirTree(const string &path) {
-	char command[PATH_MAX + 30];
-	int result;
-	
-	snprintf(command, sizeof(command), "chmod -R u+rwx \"%s\" 2>/dev/null", path.c_str());
-	command[sizeof(command) - 1] = '\0';
-	do {
-		result = ::system(command);
-	} while (result == -1 && errno == EINTR);
-	
-	snprintf(command, sizeof(command), "rm -rf \"%s\"", path.c_str());
-	command[sizeof(command) - 1] = '\0';
-	do {
-		result = ::system(command);
-	} while (result == -1 && errno == EINTR);
-	if (result == -1) {
-		char message[1024];
+	this_thread::disable_interruption di;
+	this_thread::disable_syscall_interruption dsi;
+	const char *c_path = path.c_str();
+	pid_t pid;
+
+	pid = syscalls::fork();
+	if (pid == 0) {
+		resetSignalHandlersAndMask();
+		disableMallocDebugging();
+		int devnull = open("/dev/null", O_RDONLY);
+		if (devnull != -1) {
+			dup2(devnull, 2);
+		}
+		closeAllFileDescriptors(2);
+		execlp("chmod", "chmod", "-R", "u+rwx", c_path, (char * const) 0);
+		perror("Cannot execute chmod");
+		_exit(1);
+
+	} else if (pid == -1) {
 		int e = errno;
-		
-		snprintf(message, sizeof(message) - 1, "Cannot remove directory '%s'", path.c_str());
-		message[sizeof(message) - 1] = '\0';
-		throw FileSystemException(message, e, path);
+		throw SystemException("Cannot fork a new process", e);
+
+	} else {
+		this_thread::restore_interruption ri(di);
+		this_thread::restore_syscall_interruption rsi(dsi);
+		syscalls::waitpid(pid, NULL, 0);
+	}
+
+	pid = syscalls::fork();
+	if (pid == 0) {
+		resetSignalHandlersAndMask();
+		disableMallocDebugging();
+		closeAllFileDescriptors(2);
+		execlp("rm", "rm", "-rf", c_path, (char * const) 0);
+		perror("Cannot execute rm");
+		_exit(1);
+
+	} else if (pid == -1) {
+		int e = errno;
+		throw SystemException("Cannot fork a new process", e);
+
+	} else {
+		this_thread::restore_interruption ri(di);
+		this_thread::restore_syscall_interruption rsi(dsi);
+		int status;
+		if (syscalls::waitpid(pid, &status, 0) == -1 || status != 0) {
+			throw RuntimeException("Cannot remove directory '" + path + "'");
+		}
 	}
 }
 
@@ -765,6 +850,65 @@ resetSignalHandlersAndMask() {
 	sigaction(SIGUSR2, &action, NULL);
 }
 
+void
+disableMallocDebugging() {
+	unsetenv("MALLOC_FILL_SPACE");
+	unsetenv("MALLOC_PROTECT_BEFORE");
+	unsetenv("MallocGuardEdges");
+	unsetenv("MallocScribble");
+	unsetenv("MallocPreScribble");
+	unsetenv("MallocCheckHeapStart");
+	unsetenv("MallocCheckHeapEach");
+	unsetenv("MallocCheckHeapAbort");
+	unsetenv("MallocBadFreeAbort");
+	unsetenv("MALLOC_CHECK_");
+
+	const char *libs = getenv("DYLD_INSERT_LIBRARIES");
+	if (libs != NULL && strstr(libs, "/usr/lib/libgmalloc.dylib")) {
+		string newLibs = libs;
+		string::size_type pos = newLibs.find("/usr/lib/libgmalloc.dylib");
+		size_t len = strlen("/usr/lib/libgmalloc.dylib");
+
+		// Erase all leading ':' too.
+		while (pos > 0 && newLibs[pos - 1] == ':') {
+			pos--;
+			len++;
+		}
+		// Erase all trailing ':' too.
+		while (pos + len < newLibs.size() && newLibs[pos + len] == ':') {
+			len++;
+		}
+
+		newLibs.erase(pos, len);
+		if (newLibs.empty()) {
+			unsetenv("DYLD_INSERT_LIBRARIES");
+		} else {
+			setenv("DYLD_INSERT_LIBRARIES", newLibs.c_str(), 1);
+		}
+	}
+}
+
+int
+runShellCommand(const StaticString &command) {
+	pid_t pid = fork();
+	if (pid == 0) {
+		resetSignalHandlersAndMask();
+		disableMallocDebugging();
+		closeAllFileDescriptors(2);
+		execlp("/bin/sh", "/bin/sh", "-c", command.data(), (char * const) 0);
+		_exit(1);
+	} else if (pid == -1) {
+		return -1;
+	} else {
+		int status;
+		if (waitpid(pid, &status, 0) == -1) {
+			return -1;
+		} else {
+			return status;
+		}
+	}
+}
+
 // Async-signal safe way to get the current process's hard file descriptor limit.
 static int
 getFileDescriptorLimit() {

data/ext/common/Utils.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2010 Phusion
+ *  Copyright (c) 2010, 2011, 2012 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -160,13 +160,16 @@ string canonicalizePath(const string &path);
  * If <em>path</em> doesn't refer to a symlink then this method will return
  * <em>path</em>.
  *
+ * <em>path</em> MUST be null-terminated!
+ *
  * @throws FileSystemException Something went wrong.
  * @ingroup Support
  */
-string resolveSymlink(const string &path);
+string resolveSymlink(const StaticString &path);
 
 /**
  * Given a path, extracts its directory name.
+ * <em>path</em> MUST be null-terminated!
  *
  * @ingroup Support
  */
@@ -174,6 +177,7 @@ string extractDirName(const StaticString &path);
 
 /**
  * Given a path, extracts its base name.
+ * <em>path</em> MUST be null-terminated!
  *
  * @ingroup Support
  */
@@ -216,6 +220,12 @@ string getProcessUsername();
  */
 mode_t parseModeString(const StaticString &mode);
 
+/**
+ * Turns the given path into an absolute path. Unlike realpath(), this function does
+ * not resolve symlinks.
+ */
+string absolutizePath(const StaticString &path, const StaticString &workingDir = "");
+
 /**
  * Return the path name for the directory in which the system stores general
  * temporary files. This is usually "/tmp", but might be something else depending
@@ -297,7 +307,7 @@ void makeDirTree(const string &path, const StaticString &mode = "u=rwx,g=,o=",
  * Remove an entire directory tree recursively. If the directory doesn't exist then this
  * function does nothing.
  *
- * @throws FileSystemException Something went wrong.
+ * @throws RuntimeException Something went wrong.
  */
 void removeDirTree(const string &path);
 
@@ -376,6 +386,18 @@ string getSignalName(int sig);
  */
 void resetSignalHandlersAndMask();
 
+/**
+ * Disables malloc() debugging facilities on OS X.
+ */
+void disableMallocDebugging();
+
+/**
+ * Like system(), but properly resets the signal handler mask,
+ * disables malloc debugging and closes file descriptors > 2.
+ * _command_ must be null-terminated.
+ */
+int runShellCommand(const StaticString &command);
+
 /**
  * Close all file descriptors that are higher than <em>lastToKeepOpen</em>.
  * This function is async-signal safe. But make sure there are no other

data/ext/common/Utils/CachedFileStat.hpp

@@ -37,6 +37,8 @@
 #include <oxt/system_calls.hpp>
 
 #include "SystemTime.h"
+#include "StaticString.h"
+#include "Utils/HashMap.h"
 
 namespace Passenger {
 
@@ -139,7 +141,7 @@ public:
 	
 	typedef shared_ptr<Entry> EntryPtr;
 	typedef list<EntryPtr> EntryList;
-	typedef map<string, EntryList::iterator> EntryMap;
+	typedef HashMap<string, EntryList::iterator, StaticString::Hash> EntryMap;
 	
 	unsigned int maxSize;
 	EntryList entries;
@@ -200,8 +202,7 @@ public:
 			entry = *it->second;
 			
 			// Mark this cache item as most recently used.
-			entries.erase(it->second);
-			entries.push_front(entry);
+			entries.splice(entries.begin(), entries, it->second);
 			cache[filename] = entries.begin();
 		}
 		ret = entry->refresh(throttleRate);

data/ext/common/Utils/FileChangeChecker.h

@@ -162,7 +162,7 @@ public:
 		} else {
 			// The file's information was already in the file list.
 			if (ret == -1 && errno == ENOENT) {
-				result = entry->lastMtime != 0 || entry->lastCtime != 0;
+				result = false;
 				entry->lastMtime = 0;
 				entry->lastCtime = 0;
 			} else if (ret == -1) {
@@ -175,7 +175,7 @@ public:
 			return result;
 		}
 	}
-	
+
 	/**
 	 * Change the maximum size of the internal file list.
 	 *

data/ext/common/Utils/HashMap.h

@@ -0,0 +1,50 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2010 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.
+ */
+
+#ifndef _PASSENGER_HASH_MAP_H_
+#define _PASSENGER_HASH_MAP_H_
+
+/*
+ * There are too many ways to include hash_map/unordered_map!
+ * This header autodetects the correct method.
+ */
+#if defined(HAS_TR1_UNORDERED_MAP)
+	#include <tr1/unordered_map>
+	#define HashMap std::tr1::unordered_map
+#elif defined(HASH_NAMESPACE) && defined(HASH_MAP_HEADER)
+	#include HASH_MAP_HEADER
+	#define HashMap HASH_NAMESPACE::hash_map
+#elif defined(__GNUC__)
+	#include <ext/hash_map>
+	#define HashMap __gnu_cxx::hash_map
+#elif defined(_MSC_VER)
+	#include <hash_map>
+	#define HashMap stdext::hash_map
+#else
+	#include <tr/unordered_map>
+	#define HashMap std::tr1::unordered_map;
+#endif
+
+#endif /* _PASSENGER_HASH_MAP_H_ */

data/ext/common/Utils/IOUtils.cpp

@@ -43,20 +43,31 @@
 #include <netdb.h>
 #include <unistd.h>
 #include <fcntl.h>
-#include <limits.h>
+#include <limits.h> // Also for __GLIBC__ macro.
+#include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cerrno>
 #include <cmath>
 
 #ifdef __linux__
+	// For accept4 macros
 	#include <sys/syscall.h>
+	#include <linux/net.h>
 #endif
 
-#include "Timer.h"
-#include "IOUtils.h"
-#include "StrIntUtils.h"
-#include "../Exceptions.h"
+#if defined(__APPLE__)
+	#define HAVE_FPURGE
+#elif defined(__GLIBC__)
+	#include <stdio_ext.h>
+	#define HAVE___FPURGE
+#endif
+
+#include <Exceptions.h>
+#include <Utils/Timer.h>
+#include <Utils/IOUtils.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/ScopeGuard.h>
 
 namespace Passenger {
 
@@ -74,6 +85,19 @@ using namespace oxt;
 static WritevFunction writevFunction = syscalls::writev;
 
 
+bool
+purgeStdio(FILE *f) {
+	#if defined(HAVE_FPURGE)
+		fpurge(f);
+		return true;
+	#elif defined(HAVE___FPURGE)
+		__fpurge(f);
+		return true;
+	#else
+		return false;
+	#endif
+}
+
 ServerAddressType
 getSocketAddressType(const StaticString &address) {
 	const char *data = address.c_str();
@@ -155,24 +179,17 @@ setNonBlocking(int fd) {
 }
 
 int
-tryAccept4(int sock, struct sockaddr *addr, socklen_t *addr_len, int options) {
-	#if defined(__linux__) && defined(__x86_64__)
-		int ret;
-		do {
-			ret = syscall(288, sock, addr, addr_len, options);
-		} while (ret == -1 && errno == EINTR);
-		return ret;
-	#elif defined(__linux__) && defined(__i386__)
+callAccept4(int sock, struct sockaddr *addr, socklen_t *addr_len, int options) {
+	#if defined(__NR_accept4) || defined(SYS_ACCEPT4)
 		int ret;
 		do {
-			ret = syscall(__NR_socketcall, 18,
-				sock, addr, addr_len, options);
+			ret = ::accept4(sock, addr, addr_len, options);
 		} while (ret == -1 && errno == EINTR);
 		return ret;
-	#elif defined(SYS_ACCEPT4)
+	#elif defined(__linux__) && defined(__x86_64__)
 		int ret;
 		do {
-			ret = ::accept4(sock, addr, addr_len, options);
+			ret = syscall(288, sock, addr, addr_len, options);
 		} while (ret == -1 && errno == EINTR);
 		return ret;
 	#else
@@ -252,6 +269,7 @@ createUnixServer(const StaticString &filename, unsigned int backlogSize, bool au
 		throw SystemException("Cannot create a Unix socket file descriptor", e);
 	}
 	
+	FdGuard guard(fd, true);
 	addr.sun_family = AF_LOCAL;
 	strncpy(addr.sun_path, filename.c_str(), filename.size());
 	addr.sun_path[filename.size()] = '\0';
@@ -262,30 +280,19 @@ createUnixServer(const StaticString &filename, unsigned int backlogSize, bool au
 		} while (ret == -1 && errno == EINTR);
 	}
 	
-	try {
-		ret = syscalls::bind(fd, (const struct sockaddr *) &addr, sizeof(addr));
-	} catch (...) {
-		safelyClose(fd, true);
-		throw;
-	}
+	ret = syscalls::bind(fd, (const struct sockaddr *) &addr, sizeof(addr));
 	if (ret == -1) {
 		int e = errno;
 		string message = "Cannot bind Unix socket '";
 		message.append(filename.toString());
 		message.append("'");
-		safelyClose(fd, true);
 		throw SystemException(message, e);
 	}
 	
 	if (backlogSize == 0) {
 		backlogSize = 1024;
 	}
-	try {
-		ret = syscalls::listen(fd, backlogSize);
-	} catch (...) {
-		safelyClose(fd, true);
-		throw;
-	}
+	ret = syscalls::listen(fd, backlogSize);
 	if (ret == -1) {
 		int e = errno;
 		string message = "Cannot listen on Unix socket '";
@@ -295,6 +302,7 @@ createUnixServer(const StaticString &filename, unsigned int backlogSize, bool au
 		throw SystemException(message, e);
 	}
 	
+	guard.clear();
 	return fd;
 }
 
@@ -326,53 +334,40 @@ createTcpServer(const char *address, unsigned short port, unsigned int backlogSi
 		throw SystemException("Cannot create a TCP socket file descriptor", e);
 	}
 	
-	try {
-		ret = syscalls::bind(fd, (const struct sockaddr *) &addr, sizeof(addr));
-	} catch (...) {
-		safelyClose(fd, true);
-		throw;
-	}
+	FdGuard guard(fd, true);
+	ret = syscalls::bind(fd, (const struct sockaddr *) &addr, sizeof(addr));
 	if (ret == -1) {
 		int e = errno;
 		string message = "Cannot bind a TCP socket on address '";
 		message.append(address);
 		message.append("' port ");
 		message.append(toString(port));
-		safelyClose(fd, true);
 		throw SystemException(message, e);
 	}
 	
 	optval = 1;
-	try {
-		if (syscalls::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
-			&optval, sizeof(optval)) == -1) {
-				printf("so_reuseaddr failed: %s\n", strerror(errno));
-			}
-	} catch (...) {
-		safelyClose(fd, true);
-		throw;
+	if (syscalls::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
+		&optval, sizeof(optval)) == -1)
+	{
+		int e = errno;
+		fprintf(stderr, "so_reuseaddr failed: %s\n", strerror(e));
 	}
-	// Ignore SO_REUSEPORT error, it's not fatal.
+	// Ignore SO_REUSEADDR error, it's not fatal.
 	
 	if (backlogSize == 0) {
 		backlogSize = 1024;
 	}
-	try {
-		ret = syscalls::listen(fd, backlogSize);
-	} catch (...) {
-		safelyClose(fd, true);
-		throw;
-	}
+	ret = syscalls::listen(fd, backlogSize);
 	if (ret == -1) {
 		int e = errno;
 		string message = "Cannot listen on TCP socket '";
 		message.append(address);
 		message.append("' port ");
 		message.append(toString(port));
-		safelyClose(fd, true);
 		throw SystemException(message, e);
 	}
 	
+	guard.clear();
 	return fd;
 }
 
@@ -396,22 +391,23 @@ connectToServer(const StaticString &address) {
 
 int
 connectToUnixServer(const StaticString &filename) {
-	int fd, ret;
+	int fd = syscalls::socket(PF_UNIX, SOCK_STREAM, 0);
+	if (fd == -1) {
+		int e = errno;
+		throw SystemException("Cannot create a Unix socket file descriptor", e);
+	}
+
+	FdGuard guard(fd, true);
+	int ret;
 	struct sockaddr_un addr;
 	
 	if (filename.size() > sizeof(addr.sun_path) - 1) {
 		string message = "Cannot connect to Unix socket '";
-		message.append(filename.toString());
+		message.append(filename.data(), filename.size());
 		message.append("': filename is too long.");
 		throw RuntimeException(message);
 	}
 	
-	fd = syscalls::socket(PF_UNIX, SOCK_STREAM, 0);
-	if (fd == -1) {
-		int e = errno;
-		throw SystemException("Cannot create a Unix socket file descriptor", e);
-	}
-	
 	addr.sun_family = AF_UNIX;
 	memcpy(addr.sun_path, filename.c_str(), filename.size());
 	addr.sun_path[filename.size()] = '\0';
@@ -419,12 +415,7 @@ connectToUnixServer(const StaticString &filename) {
 	bool retry = true;
 	int counter = 0;
 	while (retry) {
-		try {
-			ret = syscalls::connect(fd, (const sockaddr *) &addr, sizeof(addr));
-		} catch (...) {
-			safelyClose(fd, true);
-			throw;
-		}
+		ret = syscalls::connect(fd, (const sockaddr *) &addr, sizeof(addr));
 		if (ret == -1) {
 			#if defined(sun) || defined(__sun)
 				/* Solaris has this nice kernel bug where connecting to
@@ -446,10 +437,10 @@ connectToUnixServer(const StaticString &filename) {
 				string message("Cannot connect to Unix socket '");
 				message.append(filename.toString());
 				message.append("'");
-				safelyClose(fd, true);
 				throw SystemException(message, e);
 			}
 		} else {
+			guard.clear();
 			return fd;
 		}
 	}
@@ -457,6 +448,51 @@ connectToUnixServer(const StaticString &filename) {
 	return -1; // Shut up compiler warning.
 }
 
+void
+setupNonBlockingUnixSocket(NUnix_State &state, const StaticString &filename) {
+	state.fd = syscalls::socket(PF_UNIX, SOCK_STREAM, 0);
+	if (state.fd == -1) {
+		int e = errno;
+		throw SystemException("Cannot create a Unix socket file descriptor", e);
+	}
+
+	state.filename = filename;
+	setNonBlocking(state.fd);
+}
+
+bool
+connectToUnixServer(NUnix_State &state) {
+	struct sockaddr_un addr;
+	int ret;
+	
+	if (state.filename.size() > sizeof(addr.sun_path) - 1) {
+		string message = "Cannot connect to Unix socket '";
+		message.append(state.filename.data(), state.filename.size());
+		message.append("': filename is too long.");
+		throw RuntimeException(message);
+	}
+
+	addr.sun_family = AF_UNIX;
+	memcpy(addr.sun_path, state.filename.data(), state.filename.size());
+	addr.sun_path[state.filename.size()] = '\0';
+
+	ret = syscalls::connect(state.fd, (const sockaddr *) &addr, sizeof(addr));
+	if (ret == -1) {
+		if (errno == EINPROGRESS || errno == EWOULDBLOCK) {
+			return false;
+		} else if (errno == EISCONN) {
+			return true;
+		} else {
+			int e = errno;
+			string message = "Cannot connect to Unix socket '";
+			message.append(state.filename.data(), state.filename.size());
+			throw SystemException(message, e);
+		}
+	} else {
+		return true;
+	}
+}
+
 int
 connectToTcpServer(const StaticString &hostname, unsigned int port) {
 	struct addrinfo hints, *res;
@@ -510,6 +546,97 @@ connectToTcpServer(const StaticString &hostname, unsigned int port) {
 	return fd;
 }
 
+void
+setupNonBlockingTcpSocket(NTCP_State &state, const StaticString &hostname, int port) {
+	int ret;
+
+	memset(&state.hints, 0, sizeof(state.hints));
+	state.hints.ai_family   = PF_UNSPEC;
+	state.hints.ai_socktype = SOCK_STREAM;
+	ret = getaddrinfo(hostname.toString().c_str(), toString(port).c_str(),
+		&state.hints, &state.res);
+	if (ret != 0) {
+		string message = "Cannot resolve IP address '";
+		message.append(hostname.data(), hostname.size());
+		message.append(":");
+		message.append(toString(port));
+		message.append("': ");
+		message.append(gai_strerror(ret));
+		throw IOException(message);
+	}
+
+	state.fd = syscalls::socket(PF_INET, SOCK_STREAM, 0);
+	if (state.fd == -1) {
+		int e = errno;
+		throw SystemException("Cannot create a TCP socket file descriptor", e);
+	}
+
+	state.hostname = hostname;
+	state.port = port;
+	setNonBlocking(state.fd);
+}
+
+bool
+connectToTcpServer(NTCP_State &state) {
+	int ret;
+
+	ret = syscalls::connect(state.fd, state.res->ai_addr, state.res->ai_addrlen);
+	if (ret == -1) {
+		if (errno == EINPROGRESS || errno == EWOULDBLOCK) {
+			return false;
+		} else if (errno == EISCONN) {
+			freeaddrinfo(state.res);
+			state.res = NULL;
+			return true;
+		} else {
+			int e = errno;
+			string message = "Cannot connect to TCP socket '";
+			message.append(state.hostname);
+			message.append(":");
+			message.append(toString(state.port));
+			message.append("'");
+			throw SystemException(message, e);
+		}
+	} else {
+		freeaddrinfo(state.res);
+		state.res = NULL;
+		return true;
+	}
+}
+
+void
+setupNonBlockingSocket(NConnect_State &state, const StaticString &address) {
+	TRACE_POINT();
+	state.type = getSocketAddressType(address);
+	switch (state.type) {
+	case SAT_UNIX:
+		setupNonBlockingUnixSocket(state.s_unix, parseUnixSocketAddress(address));
+		break;
+	case SAT_TCP: {
+		string host;
+		unsigned short port;
+		
+		parseTcpSocketAddress(address, host, port);
+		setupNonBlockingTcpSocket(state.s_tcp, host, port);
+		break;
+	}
+	default:
+		throw ArgumentException(string("Unknown address type for '") + address + "'");
+	}
+}
+
+bool
+connectToServer(NConnect_State &state) {
+	switch (state.type) {
+	case SAT_UNIX:
+		return connectToUnixServer(state.s_unix);
+	case SAT_TCP:
+		return connectToTcpServer(state.s_tcp);
+	default:
+		throw RuntimeException("Unknown address type");
+	}
+}
+
 SocketPair
 createUnixSocketPair() {
 	int fds[2];
@@ -996,5 +1123,39 @@ safelyClose(int fd, bool ignoreErrors) {
 	}
 }
 
+string
+readAll(const string &filename) {
+	FILE *f = fopen(filename.c_str(), "rb");
+	if (f != NULL) {
+		StdioGuard guard(f);
+		return readAll(fileno(f));
+	} else {
+		int e = errno;
+		throw FileSystemException("Cannot open '" + filename + "' for reading",
+			e, filename);
+	}
+}
+
+string
+readAll(int fd) {
+	string result;
+	char buf[1024 * 32];
+	ssize_t ret;
+	while (true) {
+		do {
+			ret = read(fd, buf, sizeof(buf));
+		} while (ret == -1 && errno == EINTR);
+		if (ret == 0) {
+			break;
+		} else if (ret == -1) {
+			int e = errno;
+			throw SystemException("Cannot read from file descriptor", e);
+		} else {
+			result.append(buf, ret);
+		}
+	}
+	return result;
+}
+
 
 } // namespace Passenger