passenger 3.0.0 → 3.0.1

data/ext/common/Utils.h

@@ -356,6 +356,23 @@ string getHostName();
  */
 string getSignalName(int sig);
 
+/**
+ * Resets the current process's signal handler disposition and signal mask
+ * to default values. One should call this every time one forks a child process;
+ * non-default signal masks/handler dispositions can cause all kinds of weird quirks,
+ * like waitpid() malfunctioning on OS X.
+ *
+ * This function is async-signal safe.
+ */
+void resetSignalHandlersAndMask();
+
+/**
+ * Close all file descriptors that are higher than <em>lastToKeepOpen</em>.
+ * This function is async-signal safe. But make sure there are no other
+ * threads running that might open file descriptors!
+ */
+void closeAllFileDescriptors(int lastToKeepOpen);
+
 
 /**
  * Represents a buffered upload file.

data/ext/common/Utils/BufferedIO.h

@@ -0,0 +1,196 @@
+#ifndef _PASSENGER_BUFFERED_IO_H_
+#define _PASSENGER_BUFFERED_IO_H_
+
+#include <string>
+#include <utility>
+#include <algorithm>
+#include <boost/function.hpp>
+#include <oxt/system_calls.hpp>
+#include <oxt/macros.hpp>
+#include <cstring>
+#include <FileDescriptor.h>
+#include <Exceptions.h>
+#include <StaticString.h>
+#include <Utils/IOUtils.h>
+
+namespace Passenger {
+
+using namespace std;
+using namespace oxt;
+
+
+/**
+ * Provides buffered I/O for arbitrary file descriptors. Supports features not
+ * found in C++'s iostream or libc's stdio:
+ * - All functions have timeout support.
+ * - The readLine() method returns a C++ string, so no need to worry about
+ *   buffer management. A size limit can be imposed.
+ * - Read buffer is infinite in size.
+ * - Unreading (pushing back) arbitrary amount of data.
+ */
+class BufferedIO {
+private:
+	FileDescriptor fd;
+	string buffer;
+	
+	static pair<unsigned int, bool> nReadOrEofReached(const char *data,
+		unsigned int size, void *output, unsigned int goalSize, unsigned int *alreadyRead)
+	{
+		char *current = (char *) output + *alreadyRead;
+		unsigned int remaining = goalSize - *alreadyRead;
+		unsigned int consumed = min(remaining, size);
+		memcpy(current, data, consumed);
+		*alreadyRead += consumed;
+		return make_pair(consumed, *alreadyRead == goalSize);
+	}
+	
+	static pair<unsigned int, bool> eofReached(const char *data,
+		unsigned int size, string *output)
+	{
+		output->append(data, size);
+		return make_pair(size, false);
+	}
+	
+	static pair<unsigned int, bool> newlineFound(const char *data,
+		unsigned int size, string *output, unsigned int max)
+	{
+		const char *newline = (const char *) memchr(data, '\n', size);
+		if (newline != NULL) {
+			unsigned int accepted = newline - data + 1;
+			if (output->size() + accepted > max) {
+				throw SecurityException("Line too long");
+			}
+			output->append(data, accepted);
+			return make_pair(accepted, true);
+		} else {
+			if (output->size() + size > max) {
+				throw SecurityException("Line too long");
+			}
+			output->append(data, size);
+			return make_pair(size, false);
+		}
+	}
+	
+public:
+	typedef function< pair<unsigned int, bool>(const char *data, unsigned int size) > AcceptFunction;
+	
+	BufferedIO() { }
+	
+	BufferedIO(const FileDescriptor &_fd)
+		: fd(_fd)
+		{ }
+	
+	FileDescriptor getFd() const {
+		return fd;
+	}
+	
+	const string &getBuffer() const {
+		return buffer;
+	}
+	
+	/**
+	 * This method keeps reading data in a loop, feeding each chunk to the given
+	 * acceptor function, until the function says that it has consumed all data
+	 * that it needs. Leftover data that has been read from the file descriptor
+	 * but not consumed by the acceptor function will be put in the buffer, making
+	 * it available for future read operations.
+	 *
+	 * The acceptor function accepts (data, size) as arguments and returns a
+	 * (consumed, done) pair, where 'consumed' indicates the number of bytes
+	 * from 'data' that it has consumed. 'done' indicates whether the acceptor
+	 * function is done consuming (true), or whether it expects more data (false).
+	 *
+	 * readUntil() can be used for e.g. reading data until a newline is encountered.
+	 *
+	 * If the acceptor function throws an exception then the BufferedIO instance
+	 * will be left in an undefined state, making it unusable.
+	 *
+	 * @throws RuntimeException The acceptor function returned an invalid result.
+	 * @throws SystemException
+	 * @throws TimeoutException
+	 * @throws boost::thread_interrupted
+	 */
+	unsigned int readUntil(const AcceptFunction &acceptor, unsigned long long *timeout = NULL) {
+		pair<unsigned int, bool> acceptResult;
+		unsigned int totalRead = 0;
+		
+		if (!buffer.empty()) {
+			acceptResult = acceptor(buffer.c_str(), buffer.size());
+			if (OXT_UNLIKELY(!acceptResult.second && acceptResult.first < buffer.size())) {
+				throw RuntimeException("Acceptor function cannot return (x,false) where x is smaller than the input size");
+			} else if (OXT_UNLIKELY(acceptResult.first > buffer.size())) {
+				throw RuntimeException("Acceptor function cannot return a larger accept count than the input size");
+			}
+			buffer.erase(0, acceptResult.first);
+			totalRead = acceptResult.first;
+			if (acceptResult.second) {
+				return totalRead;
+			}
+		}
+		
+		while (true) {
+			if (OXT_UNLIKELY(timeout != NULL && !waitUntilReadable(fd, timeout))) {
+				throw TimeoutException("Read timeout");
+			}
+			
+			char tmp[1024 * 8];
+			ssize_t ret = syscalls::read(fd, tmp, sizeof(tmp));
+			if (ret == 0) {
+				return totalRead;
+			} else if (OXT_UNLIKELY(ret == -1)) {
+				if (errno != EAGAIN) {
+					int e = errno;
+					throw SystemException("read() failed", e);
+				}
+			} else {
+				acceptResult = acceptor(tmp, ret);
+				totalRead += acceptResult.first;
+				if (OXT_UNLIKELY(!acceptResult.second && acceptResult.first < (unsigned int) ret)) {
+					throw RuntimeException("Acceptor function cannot return (x,false) where x is smaller than the input size");
+				} else if (OXT_UNLIKELY(acceptResult.first > (unsigned int) ret)) {
+					throw RuntimeException("Acceptor function cannot return a larger accept count than the input size");
+				}
+				if (acceptResult.second) {
+					buffer.assign(tmp + acceptResult.first, ret - acceptResult.first);
+					return totalRead;
+				}
+			}
+		}
+	}
+	
+	unsigned int read(void *buf, unsigned int size, unsigned long long *timeout = NULL) {
+		unsigned int counter = 0;
+		return readUntil(
+			boost::bind(nReadOrEofReached, _1, _2, buf, size, &counter),
+			timeout);
+	}
+	
+	string readAll(unsigned long long *timeout = NULL) {
+		string output;
+		readUntil(boost::bind(eofReached, _1, _2, &output), timeout);
+		return output;
+	}
+	
+	string readLine(unsigned int max = 1024, unsigned long long *timeout = NULL) {
+		string output;
+		readUntil(boost::bind(newlineFound, _1, _2, &output, max), timeout);
+		return output;
+	}
+	
+	void unread(const void *buf, unsigned int size) {
+		string newBuffer;
+		newBuffer.reserve(size + buffer.size());
+		newBuffer.append((const char *) buf, (string::size_type) size);
+		newBuffer.append(buffer);
+		buffer = newBuffer;
+	}
+	
+	void unread(const StaticString &str) {
+		unread(str.c_str(), str.size());
+	}
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_BUFFERED_IO_H_ */

data/ext/common/Utils/IOUtils.cpp

@@ -49,6 +49,11 @@
 #include <cerrno>
 #include <cmath>
 
+#ifdef __linux__
+	#include <sys/syscall.h>
+#endif
+
+#include "Timer.h"
 #include "IOUtils.h"
 #include "StrIntUtils.h"
 #include "../Exceptions.h"
@@ -149,6 +154,33 @@ 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__)
+		int ret;
+		do {
+			ret = syscall(__NR_socketcall, 18,
+				sock, addr, addr_len, options);
+		} while (ret == -1 && errno == EINTR);
+		return ret;
+	#elif defined(SYS_ACCEPT4)
+		int ret;
+		do {
+			ret = ::accept4(sock, addr, addr_len, options);
+		} while (ret == -1 && errno == EINTR);
+		return ret;
+	#else
+		errno = ENOSYS;
+		return -1;
+	#endif
+}
+
 vector<string>
 resolveHostname(const string &hostname, unsigned int port, bool shuffle) {
 	string portString = toString(port);
@@ -504,6 +536,116 @@ connectToTcpServer(const StaticString &hostname, unsigned int port) {
 	return fd;
 }
 
+SocketPair
+createUnixSocketPair() {
+	int fds[2];
+	FileDescriptor sockets[2];
+	
+	if (syscalls::socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1) {
+		int e = errno;
+		throw SystemException("Cannot create a Unix socket pair", e);
+	} else {
+		sockets[0] = fds[0];
+		sockets[1] = fds[1];
+		return SocketPair(sockets[0], sockets[1]);
+	}
+}
+
+Pipe
+createPipe() {
+	int fds[2];
+	FileDescriptor p[2];
+	
+	if (syscalls::pipe(fds) == -1) {
+		int e = errno;
+		throw SystemException("Cannot create a pipe", e);
+	} else {
+		p[0] = fds[0];
+		p[1] = fds[1];
+		return Pipe(p[0], p[1]);
+	}
+}
+
+static bool
+waitUntilIOEvent(int fd, short event, unsigned long long *timeout) {
+	struct pollfd pfd;
+	int ret;
+	
+	pfd.fd = fd;
+	pfd.events = event;
+	pfd.revents = 0;
+	
+	Timer timer;
+	ret = syscalls::poll(&pfd, 1, *timeout / 1000);
+	if (ret == -1) {
+		int e = errno;
+		throw SystemException("poll() failed", e);
+	} else {
+		unsigned long long elapsed = timer.usecElapsed();
+		if (elapsed > *timeout) {
+			*timeout = 0;
+		} else {
+			*timeout -= elapsed;
+		}
+		return ret != 0;
+	}
+}
+
+bool
+waitUntilReadable(int fd, unsigned long long *timeout) {
+	return waitUntilIOEvent(fd, POLLIN, timeout);
+}
+
+bool
+waitUntilWritable(int fd, unsigned long long *timeout) {
+	return waitUntilIOEvent(fd, POLLOUT | POLLHUP, timeout);
+}
+
+unsigned int
+readExact(int fd, void *buf, unsigned int size, unsigned long long *timeout) {
+	ssize_t ret;
+	unsigned int alreadyRead = 0;
+	
+	while (alreadyRead < size) {
+		if (timeout != NULL && !waitUntilReadable(fd, timeout)) {
+			throw TimeoutException("Cannot read enough data within the specified timeout");
+		}
+		ret = syscalls::read(fd, (char *) buf + alreadyRead, size - alreadyRead);
+		if (ret == -1) {
+			int e = errno;
+			throw SystemException("read() failed", e);
+		} else if (ret == 0) {
+			return alreadyRead;
+		} else {
+			alreadyRead += ret;
+		}
+	}
+	return alreadyRead;
+}
+
+void
+writeExact(int fd, const void *data, unsigned int size, unsigned long long *timeout) {
+	ssize_t ret;
+	unsigned int written = 0;
+	while (written < size) {
+		if (timeout != NULL && !waitUntilWritable(fd, timeout)) {
+			throw TimeoutException("Cannot write enough data within the specified timeout");
+		}
+		ret = syscalls::write(fd, (const char *) data + written, size - written);
+		if (ret == -1) {
+			int e = errno;
+			throw SystemException("write() failed", e);
+		} else {
+			written += ret;
+		}
+	}
+}
+
+void
+writeExact(int fd, const StaticString &data, unsigned long long *timeout) {
+	writeExact(fd, data.c_str(), data.size(), timeout);
+}
+
 /**
  * Converts an array of StaticStrings to a corresponding array of iovec structures,
  * returning the size sum in bytes of all StaticStrings.
@@ -750,5 +892,22 @@ setWritevFunction(WritevFunction func) {
 	}
 }
 
+void
+safelyClose(int fd) {
+	if (syscalls::close(fd) == -1) {
+		/* FreeBSD has a kernel bug which can cause close() to return ENOTCONN.
+		 * This is harmless, ignore it. We check for this problem on all
+		 * platforms because some OSes might borrow Unix domain socket
+		 * code from FreeBSD.
+		 * http://www.freebsd.org/cgi/query-pr.cgi?pr=79138
+		 * http://www.freebsd.org/cgi/query-pr.cgi?pr=144061
+		 */
+		if (errno != ENOTCONN) {
+			int e = errno;
+			throw SystemException("Cannot close file descriptor", e);
+		}
+	}
+}
+
 
 } // namespace Passenger

data/ext/common/Utils/IOUtils.h

@@ -30,7 +30,8 @@
 #include <unistd.h>
 #include <string>
 #include <vector>
-#include "../StaticString.h"
+#include <StaticString.h>
+#include <FileDescriptor.h>
 
 namespace Passenger {
 
@@ -92,6 +93,12 @@ bool isLocalSocketAddress(const StaticString &address);
  */
 void setNonBlocking(int fd);
 
+/**
+ * Try to call the Linux accept4() system call. If the system call is
+ * not available, then -1 is returned and errno is set to ENOSYS.
+ */
+int callAccept4(int sock, struct sockaddr *addr, socklen_t *addr_len, int options);
+
 /**
  * Resolves the given host name and returns a list of IP addresses.
  * <em>hostname</em> may also be an IP address, in which case it is
@@ -193,6 +200,107 @@ int connectToUnixServer(const StaticString &filename);
  */
 int connectToTcpServer(const StaticString &hostname, unsigned int port);
 
+/**
+ * Creates a Unix domain socket pair.
+ *
+ * @throws SystemException
+ * @throws boost::thread_interrupted
+ */
+SocketPair createUnixSocketPair();
+
+/**
+ * Creates a pipe.
+ *
+ * @throws SystemException
+ * @throws boost::thread_interrupted
+ */
+Pipe createPipe();
+
+/**
+ * Waits at most <tt>*timeout</tt> microseconds for the file descriptor to become readable.
+ * Returns true if it become readable within the timeout, false if the timeout expired.
+ *
+ * <tt>*timeout</tt> may be 0, in which case this method will check whether the file
+ * descriptor is readable, and immediately returns without waiting.
+ *
+ * If no exception is thrown, this method deducts the number of microseconds that has
+ * passed from <tt>*timeout</tt>.
+ *
+ * @throws SystemException
+ * @throws boost::thread_interrupted
+ */
+bool waitUntilReadable(int fd, unsigned long long *timeout);
+
+/**
+ * Waits at most <tt>*timeout</tt> microseconds for the file descriptor to become writable.
+ * Returns true if it become writable within the timeout, false if the timeout expired.
+ *
+ * <tt>*timeout</tt> may be 0, in which case this method will check whether the file
+ * descriptor is writable, and immediately returns without waiting.
+ *
+ * If no exception is thrown, this method deducts the number of microseconds that has
+ * passed from <tt>*timeout</tt>.
+ *
+ * @throws SystemException
+ * @throws boost::thread_interrupted
+ */
+bool waitUntilWritable(int fd, unsigned long long *timeout);
+
+/**
+ * Attempts to read exactly <tt>size</tt> bytes of data from the given file
+ * descriptor, and put the result in <tt>buf</tt>. On non-blocking sockets
+ * this function will block by poll()ing the socket.
+ *
+ * @param buf The buffer to place the read data in. This buffer must be at least
+ *            <tt>size</tt> bytes long.
+ * @param size The number of bytes to read.
+ * @param timeout A pointer to an integer, which specifies the maximum number of
+ *                microseconds that may be spent on reading the <tt>size</tt> bytes
+ *                of data. If the timeout expired then TimeoutException will be
+ *                thrown.
+ *                If this function returns without throwing an exception, then the
+ *                total number of microseconds spent on reading will be deducted
+ *                from <tt>timeout</tt>.
+ *                Pass NULL if you do not want to enforce a timeout.
+ * @return The number of bytes read. This is exactly equal to <em>size</em>,
+ *         except when EOF is encountered prematurely.
+ * @pre buf != NULL
+ * @throws SystemException
+ * @throws TimeoutException Unable to read <tt>size</tt> bytes of data within
+ *                          <tt>timeout</tt> microseconds.
+ * @throws boost::thread_interrupted
+ */
+unsigned int readExact(int fd, void *buf, unsigned int size, unsigned long long *timeout = NULL);
+
+/**
+ * Writes a block of data to the given file descriptor and blocks until everything
+ * is written, even for non-blocking sockets. If not everything can be written (e.g.
+ * because the peer closed the connection before accepting everything) then an
+ * exception will be thrown.
+ *
+ * @note Security guarantee: this method will not copy the data in memory,
+ *       so it's safe to use this method to write passwords to the underlying
+ *       file descriptor.
+ *
+ * @param data The data to send.
+ * @param size The number of bytes in <tt>data</tt>.
+ * @param timeout A pointer to an integer, which specifies the maximum number of
+ *                microseconds that may be spent on writing the <tt>size</tt> bytes
+ *                of data. If the timeout expired then TimeoutException will be
+ *                thrown.
+ *                If this function returns without throwing an exception, then the
+ *                total number of microseconds spent on writing will be deducted
+ *                from <tt>timeout</tt>.
+ *                Pass NULL if you do not want to enforce a timeout.
+ * @pre data != NULL
+ * @throws SystemException
+ * @throws TimeoutException Unable to write <tt>size</tt> bytes of data within
+ *                          <tt>timeout</tt> microseconds.
+ * @throws boost::thread_interrupted
+ */
+void writeExact(int fd, const void *data, unsigned int size, unsigned long long *timeout = NULL);
+void writeExact(int fd, const StaticString &data, unsigned long long *timeout = NULL);
+
 /**
  * Writes a bunch of data to the given file descriptor using a gathering I/O interface.
  * Instead of accepting a single buffer, this function accepts multiple buffers plus
@@ -248,6 +356,15 @@ void    gatheredWrite(int fd, const StaticString data[], unsigned int dataCount)
  */
 void setWritevFunction(WritevFunction func);
 
+/**
+ * Closes the given file descriptor and throws an exception if anything goes wrong.
+ * This function also works around certain close() bugs on certain operating systems.
+ *
+ * @throws SystemException
+ * @throws boost::thread_interrupted
+ */
+void safelyClose(int fd);
+
 } // namespace Passenger
 
 #endif /* _PASSENGER_IO_UTILS_H_ */