passenger 3.0.9 → 3.0.10

data/ext/common/MessageReadersWriters.h

@@ -33,13 +33,13 @@
 #include <sys/types.h>
 #include <cstring>
 #include <arpa/inet.h>
-#include "StaticString.h"
-#include "Exceptions.h"
-#include "Utils/MemZeroGuard.h"
+#include <StaticString.h>
+#include <Exceptions.h>
+#include <Utils/MemZeroGuard.h>
 
 /**
  * This file provides a bunch of classes for reading and writing messages in the
- * MessageChannel format. Unlike MessageChannel, whose operations take control over
+ * MessageIO format. Unlike MessageIO functions, whose operations take control over
  * the I/O handle and may block, these classes act like parsers and data generators.
  * To read messages one must feed data to them. To write messages one must instruct
  * the classes to generate a bunch of data. These classes will never block, making

data/ext/common/MessageServer.h

@@ -70,7 +70,7 @@ using namespace oxt;
  * - Designed for simple request/response cycles. That is, a client sends a request, and
  *   the server may respond with arbitrary data. The server does not respond sporadically,
  *   i.e. it only responds after a request.
- * - Requests are discrete MessageChannel array messages, not byte streams.
+ * - Requests are MessageIO array messages.
  * - Connections are authenticated. Connecting clients must send a username and password,
  *   which are then checked against an accounts database. The associated account is known
  *   throughout the entire connection life time so that it's possible to implement
@@ -136,7 +136,7 @@ using namespace oxt;
  *       {
  *           if (args[0] == "ping") {
  *               MyContext *myContext = (MyContext *) specificContext.get();
- *               commonContext.channel.write("pong", toString(specificContext->count).c_str(), NULL);
+ *               writeArrayMessage(commonContext.fd, "pong", toString(specificContext->count).c_str(), NULL);
  *               specificContext->count++;
  *               return true;
  *           } else {
@@ -195,7 +195,7 @@ public:
 		
 		/** Returns a string representation for this client context. */
 		string name() {
-			return toString(channel.filenum());
+			return toString(fd);
 		}
 		
 		/**
@@ -210,10 +210,10 @@ public:
 		void requireRights(Account::Rights rights) {
 			if (!account->hasRights(rights)) {
 				P_TRACE(2, "Security error: insufficient rights to execute this command.");
-				channel.write("SecurityException", "Insufficient rights to execute this command.", NULL);
+				writeArrayMessage(fd, "SecurityException", "Insufficient rights to execute this command.", NULL);
 				throw SecurityException("Insufficient rights to execute this command.");
 			} else {
-				channel.write("Passed security", NULL);
+				writeArrayMessage(fd, "Passed security", NULL);
 			}
 		}
 	};
@@ -356,45 +356,45 @@ protected:
 	 *
 	 * @return A smart pointer to an Account object, or NULL if authentication failed.
 	 */
-	AccountPtr authenticate(FileDescriptor &client) {
-		MessageChannel channel(client);
+	AccountPtr authenticate(const FileDescriptor &client) {
 		string username, password;
 		MemZeroGuard passwordGuard(password);
 		unsigned long long timeout = loginTimeout;
 		
 		try {
-			channel.write("version", "1", NULL);
+			writeArrayMessage(client, &timeout, "version", "1", NULL);
 			
 			try {
-				if (!channel.readScalar(username, MESSAGE_SERVER_MAX_USERNAME_SIZE, &timeout)) {
+				if (!readScalarMessage(client, username, MESSAGE_SERVER_MAX_USERNAME_SIZE, &timeout)) {
 					return AccountPtr();
 				}
 			} catch (const SecurityException &) {
-				channel.write("The supplied username is too long.", NULL);
+				writeArrayMessage(client, &timeout, "The supplied username is too long.", NULL);
 				return AccountPtr();
 			}
 			
 			try {
-				if (!channel.readScalar(password, MESSAGE_SERVER_MAX_PASSWORD_SIZE, &timeout)) {
+				if (!readScalarMessage(client, password, MESSAGE_SERVER_MAX_PASSWORD_SIZE, &timeout)) {
 					return AccountPtr();
 				}
 			} catch (const SecurityException &) {
-				channel.write("The supplied password is too long.", NULL);
+				writeArrayMessage(client, &timeout, "The supplied password is too long.", NULL);
 				return AccountPtr();
 			}
 			
 			AccountPtr account = accountsDatabase->authenticate(username, password);
 			passwordGuard.zeroNow();
 			if (account == NULL) {
-				channel.write("Invalid username or password.", NULL);
+				writeArrayMessage(client, &timeout, "Invalid username or password.", NULL);
 				return AccountPtr();
 			} else {
-				channel.write("ok", NULL);
+				writeArrayMessage(client, &timeout, "ok", NULL);
 				return account;
 			}
 		} catch (const SystemException &) {
 			return AccountPtr();
 		} catch (const TimeoutException &) {
+			P_WARN("Login timeout");
 			return AccountPtr();
 		}
 	}
@@ -439,7 +439,7 @@ protected:
 	/**
 	 * The main function for a thread which handles a client.
 	 */
-	void clientHandlingMainLoop(FileDescriptor &client) {
+	void clientHandlingMainLoop(FileDescriptor client) {
 		TRACE_POINT();
 		vector<string> args;
 		
@@ -459,7 +459,7 @@ protected:
 			
 			while (!this_thread::interruption_requested()) {
 				UPDATE_TRACE_POINT();
-				if (!commonContext.channel.read(args)) {
+				if (!readArrayMessage(commonContext.fd, args)) {
 					// Client closed connection.
 					break;
 				}
@@ -503,7 +503,7 @@ public:
 	MessageServer(const string &socketFilename, AccountsDatabasePtr accountsDatabase) {
 		this->socketFilename   = socketFilename;
 		this->accountsDatabase = accountsDatabase;
-		loginTimeout = 2000;
+		loginTimeout = 2000000;
 		startListening();
 	}
 	
@@ -562,7 +562,7 @@ public:
 	}
 	
 	/**
-	 * Sets the maximum number of milliseconds that clients may spend on logging in.
+	 * Sets the maximum number of microseconds that clients may spend on logging in.
 	 * Clients that take longer are disconnected.
 	 *
 	 * @pre timeout != 0

data/ext/common/Process.h

@@ -36,11 +36,10 @@
 #include <unistd.h>
 #include <errno.h>
 
-#include "Session.h"
-#include "MessageChannel.h"
-#include "Exceptions.h"
-#include "Logging.h"
-#include "Utils.h"
+#include <Session.h>
+#include <Exceptions.h>
+#include <Logging.h>
+#include <Utils.h>
 
 namespace Passenger {
 

data/ext/common/Session.h

@@ -41,11 +41,11 @@
 #include <oxt/backtrace.hpp>
 #include <oxt/system_calls.hpp>
 
-#include "MessageChannel.h"
-#include "StaticString.h"
-#include "Exceptions.h"
-#include "Utils/StrIntUtils.h"
-#include "Utils/IOUtils.h"
+#include <StaticString.h>
+#include <Exceptions.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/IOUtils.h>
+#include <Utils/MessageIO.h>
 
 namespace Passenger {
 
@@ -159,7 +159,7 @@ public:
 				"because the I/O stream has already been closed or discarded.");
 		}
 		try {
-			MessageChannel(stream).writeScalar(headers, size);
+			writeScalarMessage(stream, headers, size);
 		} catch (SystemException &e) {
 			e.setBriefMessage("An error occured while writing headers "
 				"to the request handler");
@@ -222,32 +222,6 @@ public:
 	 */
 	virtual int getStream() const = 0;
 	
-	/**
-	 * Set the timeout value for reading data from the I/O channel.
-	 * If no data can be read within the timeout period, then the
-	 * read call will fail with error EAGAIN or EWOULDBLOCK.
-	 *
-	 * @pre The I/O channel hasn't been closed or discarded.
-	 * @pre initiated()
-	 * @param msec The timeout, in milliseconds. If 0 is given,
-	 *             there will be no timeout.
-	 * @throws SystemException Cannot set the timeout.
-	 */
-	virtual void setReaderTimeout(unsigned int msec) = 0;
-	
-	/**
-	 * Set the timeout value for writing data from the I/O channel.
-	 * If no data can be written within the timeout period, then the
-	 * write call will fail with error EAGAIN or EWOULDBLOCK.
-	 *
-	 * @pre The I/O channel hasn't been closed or discarded.
-	 * @pre initiated()
-	 * @param msec The timeout, in milliseconds. If 0 is given,
-	 *             there will be no timeout.
-	 * @throws SystemException Cannot set the timeout.
-	 */
-	virtual void setWriterTimeout(unsigned int msec) = 0;
-	
 	/**
 	 * Indicate that we don't want to read data anymore from the I/O channel.
 	 * Calling this method after closeStream()/discardStream() is called will
@@ -397,14 +371,6 @@ public:
 		return fd;
 	}
 	
-	virtual void setReaderTimeout(unsigned int msec) {
-		MessageChannel(fd).setReadTimeout(msec);
-	}
-	
-	virtual void setWriterTimeout(unsigned int msec) {
-		MessageChannel(fd).setWriteTimeout(msec);
-	}
-	
 	virtual void shutdownReader() {
 		TRACE_POINT();
 		if (fd != -1) {

data/ext/common/SpawnManager.h

@@ -45,18 +45,18 @@
 #include <pwd.h>
 #include <signal.h>
 
-#include "AbstractSpawnManager.h"
-#include "ServerInstanceDir.h"
-#include "FileDescriptor.h"
-#include "Constants.h"
-#include "MessageChannel.h"
-#include "AccountsDatabase.h"
-#include "RandomGenerator.h"
-#include "Exceptions.h"
-#include "Logging.h"
-#include "Utils/Base64.h"
-#include "Utils/SystemTime.h"
-#include "Utils/IOUtils.h"
+#include <AbstractSpawnManager.h>
+#include <ServerInstanceDir.h>
+#include <FileDescriptor.h>
+#include <Constants.h>
+#include <AccountsDatabase.h>
+#include <RandomGenerator.h>
+#include <Exceptions.h>
+#include <Logging.h>
+#include <Utils/Base64.h>
+#include <Utils/SystemTime.h>
+#include <Utils/IOUtils.h>
+#include <Utils/MessageIO.h>
 
 namespace Passenger {
 
@@ -268,9 +268,8 @@ private:
 	FileDescriptor connect() const {
 		TRACE_POINT();
 		FileDescriptor fd = connectToUnixServer(socketFilename.c_str());
-		MessageChannel channel(fd);
 		UPDATE_TRACE_POINT();
-		channel.writeScalar(socketPassword);
+		writeScalarMessage(fd, socketPassword);
 		return fd;
 	}
 	
@@ -286,13 +285,11 @@ private:
 	ProcessPtr sendSpawnCommand(const PoolOptions &options) {
 		TRACE_POINT();
 		FileDescriptor connection;
-		MessageChannel channel;
 		
 		P_DEBUG("Spawning a new application process for " << options.appRoot << "...");
 		
 		try {
 			connection = connect();
-			channel = MessageChannel(connection);
 		} catch (const SystemException &e) {
 			throw SpawnException(string("Could not connect to the spawn server: ") +
 				e.sys());
@@ -337,7 +334,7 @@ private:
 				args.push_back(Base64::encode(password));
 			}
 			
-			channel.write(args);
+			writeArrayMessage(connection, args);
 		} catch (const SystemException &e) {
 			throw SpawnException(string("Could not write 'spawn_application' "
 				"command to the spawn server: ") + e.sys());
@@ -346,7 +343,7 @@ private:
 		try {
 			UPDATE_TRACE_POINT();
 			// Read status.
-			if (!channel.read(args)) {
+			if (!readArrayMessage(connection, args)) {
 				throw SpawnException("The spawn server has exited unexpectedly.");
 			}
 			if (args.size() != 1) {
@@ -356,7 +353,7 @@ private:
 				UPDATE_TRACE_POINT();
 				string errorPage;
 				
-				if (!channel.readScalar(errorPage)) {
+				if (!readScalarMessage(connection, errorPage)) {
 					throw SpawnException("The spawn server has exited unexpectedly.");
 				}
 				throw SpawnException("An error occured while spawning the application.",
@@ -367,7 +364,7 @@ private:
 			
 			// Read application info.
 			UPDATE_TRACE_POINT();
-			if (!channel.read(args)) {
+			if (!readArrayMessage(connection, args)) {
 				throw SpawnException("The spawn server has exited unexpectedly.");
 			}
 			if (args.size() != 3) {
@@ -380,7 +377,7 @@ private:
 			
 			UPDATE_TRACE_POINT();
 			for (i = 0; i < nServerSockets; i++) {
-				if (!channel.read(args)) {
+				if (!readArrayMessage(connection, args)) {
 					throw SpawnException("The spawn server has exited unexpectedly.");
 				}
 				if (args.size() != 3) {
@@ -398,7 +395,7 @@ private:
 		
 		UPDATE_TRACE_POINT();
 		try {
-			ownerPipe = channel.readFileDescriptor();
+			ownerPipe = readFileDescriptorWithNegotiation(connection);
 		} catch (const SystemException &e) {
 			throw SpawnException(string("Could not receive the spawned "
 				"application's owner pipe from the spawn server: ") +
@@ -454,11 +451,9 @@ private:
 	void sendReloadCommand(const string &appRoot) {
 		TRACE_POINT();
 		FileDescriptor connection;
-		MessageChannel channel;
 		
 		try {
 			connection = connect();
-			channel = MessageChannel(connection);
 		} catch (SystemException &e) {
 			e.setBriefMessage("Could not connect to the spawn server");
 			throw;
@@ -468,7 +463,7 @@ private:
 		}
 		
 		try {
-			channel.write("reload", appRoot.c_str(), NULL);
+			writeArrayMessage(connection, "reload", appRoot.c_str(), NULL);
 		} catch (SystemException &e) {
 			e.setBriefMessage("Could not write 'reload' command to the spawn server");
 			throw;

data/ext/common/Utils.cpp

@@ -33,6 +33,7 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/resource.h>
+#include <sys/uio.h>
 #include <libgen.h>
 #include <fcntl.h>
 #include <poll.h>
@@ -41,7 +42,6 @@
 #include <unistd.h>
 #include <signal.h>
 #include <FileDescriptor.h>
-#include <MessageChannel.h>
 #include <MessageServer.h>
 #include <ResourceLocator.h>
 #include <Exceptions.h>

data/ext/common/Utils/Dechunker.h

@@ -229,4 +229,4 @@ public:
 
 } // namespace Passenger
 
-#endif _PASSENGER_DECHUNKER_H_
+#endif /* _PASSENGER_DECHUNKER_H_ */

data/ext/common/Utils/MessageIO.h

@@ -300,26 +300,28 @@ readArrayMessage(int fd, unsigned long long *timeout = NULL) {
  *                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.
- * @throws EOFException End-of-file was reached before a full integer could be read.
+ * @return True if a scalar message was read, false if EOF was encountered.
  * @throws SystemException Something went wrong.
  * @throws SecurityException The message body is larger than allowed by maxSize.
  * @throws TimeoutException Unable to read the necessary data within
  *                          <tt>timeout</tt> microseconds.
  * @throws boost::thread_interrupted
  */
-inline string
-readScalarMessage(int fd, unsigned int maxSize = 0, unsigned long long *timeout = NULL) {
+inline bool
+readScalarMessage(int fd, string &output, unsigned int maxSize = 0, unsigned long long *timeout = NULL) {
 	uint32_t size;
 	if (!readUint32(fd, size, timeout)) {
-		throw EOFException("EOF encountered before a 32-bit scalar message header could be read");
+		return false;
 	}
 	
 	if (maxSize != 0 && size > (uint32_t) maxSize) {
 		throw SecurityException("The scalar message body is larger than the size limit");
 	}
 	
-	string output;
 	unsigned int remaining = size;
+	if (OXT_UNLIKELY(!output.empty())) {
+		output.clear();
+	}
 	output.reserve(size);
 	if (OXT_LIKELY(remaining > 0)) {
 		char buf[1024 * 32];
@@ -329,13 +331,43 @@ readScalarMessage(int fd, unsigned int maxSize = 0, unsigned long long *timeout
 			unsigned int blockSize = min((unsigned int) sizeof(buf), remaining);
 			
 			if (readExact(fd, buf, blockSize, timeout) != blockSize) {
-				throw EOFException("EOF encountered before the full scalar message body could be read");
+				return false;
 			}
 			output.append(buf, blockSize);
 			remaining -= blockSize;
 		}
 	}
-	return output;
+	return true;
+}
+
+/**
+ * Reads a scalar message from the given file descriptor.
+ *
+ * @param maxSize The maximum number of bytes that may be read. If the
+ *                scalar to read is larger than this, then a SecurityException
+ *                will be thrown. Set to 0 for no size limit.
+ * @param timeout A pointer to an integer, which specifies the maximum number of
+ *                microseconds that may be spent on reading the necessary 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.
+ * @throws EOFException End-of-file was reached before a full integer could be read.
+ * @throws SystemException Something went wrong.
+ * @throws SecurityException The message body is larger than allowed by maxSize.
+ * @throws TimeoutException Unable to read the necessary data within
+ *                          <tt>timeout</tt> microseconds.
+ * @throws boost::thread_interrupted
+ */
+inline string
+readScalarMessage(int fd, unsigned int maxSize = 0, unsigned long long *timeout = NULL) {
+	string output;
+	if (readScalarMessage(fd, output, maxSize, timeout)) {
+		return output;
+	} else {
+		throw EOFException("EOF encountered before a full scalar message could be read");
+	}
 }
 
 
@@ -402,7 +434,7 @@ writeUint32(int fd, uint32_t value, unsigned long long *timeout = NULL) {
  */
 template<typename Collection>
 inline void
-writeArrayMessage(int fd, const Collection &args, unsigned long long *timeout = NULL) {
+writeArrayMessageEx(int fd, const Collection &args, unsigned long long *timeout = NULL) {
 	typename Collection::const_iterator it, end = args.end();
 	uint16_t bodySize = 0;
 	
@@ -425,20 +457,78 @@ writeArrayMessage(int fd, const Collection &args, unsigned long long *timeout =
 	writeExact(fd, data.get(), sizeof(uint16_t) + bodySize, timeout);
 }
 
+inline void
+writeArrayMessage(int fd, const vector<StaticString> &args, unsigned long long *timeout = NULL) {
+	writeArrayMessageEx(fd, args, timeout);
+}
+
+inline void
+writeArrayMessage(int fd, const vector<string> &args, unsigned long long *timeout = NULL) {
+	writeArrayMessageEx(fd, args, timeout);
+}
+
+inline void
+writeArrayMessage(int fd, const StaticString args[], unsigned int nargs, unsigned long long *timeout = NULL) {
+	unsigned int i;
+	uint16_t bodySize = 0;
+	
+	for (i = 0; i < nargs; i++) {
+		bodySize += args[i].size() + 1;
+	}
+	
+	scoped_array<char> data(new char[sizeof(uint16_t) + bodySize]);
+	uint16_t header = htons(bodySize);
+	memcpy(data.get(), &header, sizeof(uint16_t));
+	
+	char *dataEnd = data.get() + sizeof(uint16_t);
+	for (i = 0; i < nargs; i++) {
+		memcpy(dataEnd, args[i].data(), args[i].size());
+		dataEnd += args[i].size();
+		*dataEnd = '\0';
+		dataEnd++;
+	}
+	
+	writeExact(fd, data.get(), sizeof(uint16_t) + bodySize, timeout);
+}
+
 inline void
 writeArrayMessage(int fd, const StaticString &name, va_list &ap, unsigned long long *timeout = NULL) {
-	vector<StaticString> args;
+	StaticString args[10];
+	unsigned int nargs = 1;
+	bool done = false;
 	
-	args.push_back(name);
-	while (true) {
+	args[0] = name;
+	do {
 		const char *arg = va_arg(ap, const char *);
 		if (arg == NULL) {
-			break;
+			done = true;
 		} else {
-			args.push_back(arg);
+			args[nargs] = arg;
+			nargs++;
 		}
+	} while (!done && nargs < sizeof(args) / sizeof(StaticString));
+	
+	if (done) {
+		writeArrayMessage(fd, args, nargs, timeout);
+	} else {
+		// Arguments don't fit in static array. Use dynamic
+		// array instead.
+		vector<StaticString> dyn_args;
+		
+		for (unsigned int i = 0; i < nargs; i++) {
+			dyn_args.push_back(args[i]);
+		}
+		do {
+			const char *arg = va_arg(ap, const char *);
+			if (arg == NULL) {
+				done = true;
+			} else {
+				dyn_args.push_back(arg);
+			}
+		} while (!done);
+		
+		writeArrayMessage(fd, dyn_args, timeout);
 	}
-	writeArrayMessage(fd, args, timeout);
 }
 
 struct _VaGuard {
@@ -464,6 +554,11 @@ writeArrayMessage(int fd, const StaticString &name, ...) {
 	writeArrayMessage(fd, name, ap);
 }
 
+inline void
+writeArrayMessage(int fd, const char *name) {
+	abort();
+}
+
 /** Version of writeArrayMessage() that accepts a variadic list of 'const char *'
  * arguments as message elements, with timeout support. The list must be terminated
  * with a NULL.