passenger 3.0.8 → 3.0.9

data/ext/common/MessageClient.h

@@ -26,12 +26,14 @@
 #define _PASSENGER_MESSAGE_CLIENT_H_
 
 #include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
 #include <string>
 
 #include "StaticString.h"
-#include "MessageChannel.h"
 #include "Exceptions.h"
+#include "Utils/MessageIO.h"
 #include "Utils/IOUtils.h"
+#include "Utils/ScopeGuard.h"
 
 
 namespace Passenger {
@@ -42,17 +44,16 @@ using namespace boost;
 class MessageClient {
 protected:
 	FileDescriptor fd;
-	MessageChannel channel;
 	bool shouldAutoDisconnect;
 	
 	/* sendUsername() and sendPassword() exist and are virtual in order to facilitate unit testing. */
 	
-	virtual void sendUsername(MessageChannel &channel, const string &username) {
-		channel.writeScalar(username);
+	virtual void sendUsername(int fd, const StaticString &username, unsigned long long *timeout) {
+		writeScalarMessage(fd, username);
 	}
 	
-	virtual void sendPassword(MessageChannel &channel, const StaticString &userSuppliedPassword) {
-		channel.writeScalar(userSuppliedPassword.c_str(), userSuppliedPassword.size());
+	virtual void sendPassword(int fd, const StaticString &userSuppliedPassword, unsigned long long *timeout) {
+		writeScalarMessage(fd, userSuppliedPassword);
 	}
 	
 	/**
@@ -64,13 +65,15 @@ protected:
 	 * @throws boost::thread_interrupted
 	 * @pre <tt>channel</tt> is connected.
 	 */
-	void authenticate(const string &username, const StaticString &userSuppliedPassword) {
+	void authenticate(const StaticString &username, const StaticString &userSuppliedPassword,
+		unsigned long long *timeout)
+	{
 		vector<string> args;
 		
-		sendUsername(channel, username);
-		sendPassword(channel, userSuppliedPassword);
+		sendUsername(fd, username, timeout);
+		sendPassword(fd, userSuppliedPassword, timeout);
 		
-		if (!channel.read(args)) {
+		if (!readArrayMessage(fd, args, timeout)) {
 			throw IOException("The message server did not send an authentication response.");
 		} else if (args.size() != 1) {
 			throw IOException("The authentication response that the message server sent is not valid.");
@@ -79,11 +82,15 @@ protected:
 		}
 	}
 	
+	void checkConnection() {
+		if (!connected()) {
+			throw IOException("Not connected");
+		}
+	}
+	
 	void autoDisconnect() {
 		if (shouldAutoDisconnect) {
-			// Closes the connection without throwing close exceptions.
-			fd = FileDescriptor();
-			channel = MessageChannel();
+			fd.close(false);
 		}
 	}
 	
@@ -122,48 +129,35 @@ public:
 	 * @throws boost::thread_interrupted
 	 * @post connected()
 	 */
-	MessageClient *connect(const string &serverAddress, const string &username,
+	MessageClient *connect(const string &serverAddress, const StaticString &username,
 		const StaticString &userSuppliedPassword)
 	{
 		TRACE_POINT();
-		try {
-			fd = connectToServer(serverAddress.c_str());
-			channel = MessageChannel(fd);
-			
-			vector<string> args;
-			if (!read(args)) {
-				throw IOException("The message server closed the connection before sending a version identifier.");
-			}
-			if (args.size() != 2 || args[0] != "version") {
-				throw IOException("The message server didn't sent a valid version identifier.");
-			}
-			if (args[1] != "1") {
-				string message = string("Unsupported message server protocol version ") +
-					args[1] + ".";
-				throw IOException(message);
-			}
-			
-			authenticate(username, userSuppliedPassword);
-			return this;
-		} catch (const RuntimeException &) {
-			autoDisconnect();
-			throw;
-		} catch (const SystemException &) {
-			autoDisconnect();
-			throw;
-		} catch (const IOException &) {
-			autoDisconnect();
-			throw;
-		} catch (const boost::thread_interrupted &) {
-			autoDisconnect();
-			throw;
+		ScopeGuard g(boost::bind(&MessageClient::autoDisconnect, this));
+		
+		fd = connectToServer(serverAddress.c_str());
+		
+		vector<string> args;
+		if (!readArrayMessage(fd, args)) {
+			throw IOException("The message server closed the connection before sending a version identifier.");
 		}
+		if (args.size() != 2 || args[0] != "version") {
+			throw IOException("The message server didn't sent a valid version identifier.");
+		}
+		if (args[1] != "1") {
+			string message = string("Unsupported message server protocol version ") +
+				args[1] + ".";
+			throw IOException(message);
+		}
+		
+		authenticate(username, userSuppliedPassword, NULL);
+		
+		g.clear();
+		return this;
 	}
 	
 	void disconnect() {
 		fd.close();
-		fd = FileDescriptor();
-		channel = MessageChannel();
 	}
 	
 	bool connected() const {
@@ -180,15 +174,24 @@ public:
 	
 	/**
 	 * @throws SystemException
+	 * @throws TimeoutException
 	 * @throws boost::thread_interrupted
 	 */
-	bool read(vector<string> &args) {
-		try {
-			return channel.read(args);
-		} catch (const SystemException &e) {
-			autoDisconnect();
-			throw;
-		}
+	bool read(vector<string> &args, unsigned long long *timeout = NULL) {
+		return readArray(args);
+	}
+	
+	/**
+	 * @throws SystemException
+	 * @throws TimeoutException
+	 * @throws boost::thread_interrupted
+	 */
+	bool readArray(vector<string> &args, unsigned long long *timeout = NULL) {
+		checkConnection();
+		ScopeGuard g(boost::bind(&MessageClient::autoDisconnect, this));
+		bool result = readArrayMessage(fd, args, timeout);
+		g.clear();
+		return result;
 	}
 	
 	/**
@@ -198,17 +201,15 @@ public:
 	 * @throws boost::thread_interrupted
 	 */
 	bool readScalar(string &output, unsigned int maxSize = 0, unsigned long long *timeout = NULL) {
+		checkConnection();
+		ScopeGuard g(boost::bind(&MessageClient::autoDisconnect, this));
 		try {
-			return channel.readScalar(output, maxSize, timeout);
-		} catch (const SystemException &) {
-			autoDisconnect();
-			throw;
-		} catch (const SecurityException &) {
-			autoDisconnect();
-			throw;
-		} catch (const TimeoutException &) {
-			autoDisconnect();
-			throw;
+			output = readScalarMessage(fd, maxSize, timeout);
+			g.clear();
+			return true;
+		} catch (const EOFException &) {
+			g.clear();
+			return false;
 		}
 	}
 	
@@ -218,15 +219,16 @@ public:
 	 * @throws boost::thread_interrupted
 	 */
 	int readFileDescriptor(bool negotiate = true) {
-		try {
-			return channel.readFileDescriptor(negotiate);
-		} catch (const SystemException &) {
-			autoDisconnect();
-			throw;
-		} catch (const IOException &) {
-			autoDisconnect();
-			throw;
+		checkConnection();
+		ScopeGuard g(boost::bind(&MessageClient::autoDisconnect, this));
+		int result;
+		if (negotiate) {
+			result = Passenger::readFileDescriptorWithNegotiation(fd);
+		} else {
+			result = Passenger::readFileDescriptor(fd);
 		}
+		g.clear();
+		return result;
 	}
 	
 	/**
@@ -234,11 +236,12 @@ public:
 	 * @throws boost::thread_interrupted
 	 */
 	void write(const char *name, ...) {
+		checkConnection();
 		va_list ap;
 		va_start(ap, name);
 		try {
 			try {
-				channel.write(name, ap);
+				writeArrayMessage(fd, name, ap);
 			} catch (const SystemException &) {
 				autoDisconnect();
 				throw;
@@ -252,28 +255,26 @@ public:
 	
 	/**
 	 * @throws SystemException
+	 * @throws TimeoutException
 	 * @throws boost::thread_interrupted
 	 */
-	void writeScalar(const char *data, unsigned int size) {
-		try {
-			channel.writeScalar(data, size);
-		} catch (const SystemException &) {
-			autoDisconnect();
-			throw;
-		}
+	void writeScalar(const char *data, unsigned int size, unsigned long long *timeout = NULL) {
+		checkConnection();
+		ScopeGuard g(boost::bind(&MessageClient::autoDisconnect, this));
+		writeScalarMessage(fd, data, size, timeout);
+		g.clear();
 	}
 	
 	/**
 	 * @throws SystemException
+	 * @throws TimeoutException
 	 * @throws boost::thread_interrupted
 	 */
-	void writeScalar(const StaticString &data) {
-		try {
-			channel.writeScalar(data.c_str(), data.size());
-		} catch (const SystemException &) {
-			autoDisconnect();
-			throw;
-		}
+	void writeScalar(const StaticString &data, unsigned long long *timeout = NULL) {
+		checkConnection();
+		ScopeGuard g(boost::bind(&MessageClient::autoDisconnect, this));
+		writeScalarMessage(fd, data, timeout);
+		g.clear();
 	}
 	
 	/**
@@ -281,12 +282,14 @@ public:
 	 * @throws boost::thread_interrupted
 	 */
 	void writeFileDescriptor(int fileDescriptor, bool negotiate = true) {
-		try {
-			channel.writeFileDescriptor(fileDescriptor, negotiate);
-		} catch (const SystemException &) {
-			autoDisconnect();
-			throw;
+		checkConnection();
+		ScopeGuard g(boost::bind(&MessageClient::autoDisconnect, this));
+		if (negotiate) {
+			Passenger::writeFileDescriptorWithNegotiation(fd, fileDescriptor);
+		} else {
+			Passenger::writeFileDescriptor(fd, fileDescriptor);
 		}
+		g.clear();
 	}
 };
 

data/ext/common/Utils/IOUtils.cpp

@@ -860,7 +860,7 @@ eraseBeginningOfIoVec(struct iovec *iov, size_t count, size_t index, size_t offs
 }
 
 void
-gatheredWrite(int fd, const StaticString data[], unsigned int count) {
+gatheredWrite(int fd, const StaticString data[], unsigned int count, unsigned long long *timeout) {
 	struct iovec iov[count];
 	size_t total, iovCount;
 	size_t written = 0;
@@ -868,6 +868,9 @@ gatheredWrite(int fd, const StaticString data[], unsigned int count) {
 	total = staticStringArrayToIoVec(data, count, iov, iovCount);
 	
 	while (written < total) {
+		if (timeout != NULL && !waitUntilWritable(fd, timeout)) {
+			throw TimeoutException("Cannot write enough data within the specified timeout");
+		}
 		ssize_t ret = writevFunction(fd, iov, std::min(iovCount, (size_t) IOV_MAX));
 		if (ret == -1) {
 			int e = errno;
@@ -892,6 +895,116 @@ setWritevFunction(WritevFunction func) {
 	}
 }
 
+int
+readFileDescriptor(int fd, unsigned long long *timeout) {
+	if (timeout != NULL && !waitUntilReadable(fd, timeout)) {
+		throw TimeoutException("Cannot receive file descriptor within the specified timeout");
+	}
+	
+	struct msghdr msg;
+	struct iovec vec;
+	char dummy[1];
+	#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
+		// File descriptor passing macros (CMSG_*) seem to be broken
+		// on 64-bit MacOS X. This structure works around the problem.
+		struct {
+			struct cmsghdr header;
+			int fd;
+		} control_data;
+		#define EXPECTED_CMSG_LEN sizeof(control_data)
+	#else
+		char control_data[CMSG_SPACE(sizeof(int))];
+		#define EXPECTED_CMSG_LEN CMSG_LEN(sizeof(int))
+	#endif
+	struct cmsghdr *control_header;
+	int ret;
+	
+	msg.msg_name    = NULL;
+	msg.msg_namelen = 0;
+	
+	dummy[0]       = '\0';
+	vec.iov_base   = dummy;
+	vec.iov_len    = sizeof(dummy);
+	msg.msg_iov    = &vec;
+	msg.msg_iovlen = 1;
+	
+	msg.msg_control    = (caddr_t) &control_data;
+	msg.msg_controllen = sizeof(control_data);
+	msg.msg_flags      = 0;
+	
+	ret = syscalls::recvmsg(fd, &msg, 0);
+	if (ret == -1) {
+		throw SystemException("Cannot read file descriptor with recvmsg()", errno);
+	}
+	
+	control_header = CMSG_FIRSTHDR(&msg);
+	if (control_header == NULL) {
+		throw IOException("No valid file descriptor received.");
+	}
+	if (control_header->cmsg_len   != EXPECTED_CMSG_LEN
+	 || control_header->cmsg_level != SOL_SOCKET
+	 || control_header->cmsg_type  != SCM_RIGHTS) {
+		throw IOException("No valid file descriptor received.");
+	}
+	
+	#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
+		return control_data.fd;
+	#else
+		return *((int *) CMSG_DATA(control_header));
+	#endif
+}
+
+void
+writeFileDescriptor(int fd, int fdToSend, unsigned long long *timeout) {
+	if (timeout != NULL && !waitUntilWritable(fd, timeout)) {
+		throw TimeoutException("Cannot send file descriptor within the specified timeout");
+	}
+	
+	struct msghdr msg;
+	struct iovec vec;
+	char dummy[1];
+	#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
+		struct {
+			struct cmsghdr header;
+			int fd;
+		} control_data;
+	#else
+		char control_data[CMSG_SPACE(sizeof(int))];
+	#endif
+	struct cmsghdr *control_header;
+	int ret;
+	
+	msg.msg_name = NULL;
+	msg.msg_namelen = 0;
+	
+	/* Linux and Solaris require msg_iov to be non-NULL. */
+	dummy[0]       = '\0';
+	vec.iov_base   = dummy;
+	vec.iov_len    = sizeof(dummy);
+	msg.msg_iov    = &vec;
+	msg.msg_iovlen = 1;
+	
+	msg.msg_control    = (caddr_t) &control_data;
+	msg.msg_controllen = sizeof(control_data);
+	msg.msg_flags      = 0;
+	
+	control_header = CMSG_FIRSTHDR(&msg);
+	control_header->cmsg_level = SOL_SOCKET;
+	control_header->cmsg_type  = SCM_RIGHTS;
+	#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
+		control_header->cmsg_len = sizeof(control_data);
+		control_data.fd = fdToSend;
+	#else
+		control_header->cmsg_len = CMSG_LEN(sizeof(int));
+		memcpy(CMSG_DATA(control_header), &fdToSend, sizeof(int));
+	#endif
+	
+	ret = syscalls::sendmsg(fd, &msg, 0);
+	if (ret == -1) {
+		throw SystemException("Cannot send file descriptor with sendmsg()", errno);
+	}
+}
+
 void
 safelyClose(int fd) {
 	if (syscalls::close(fd) == -1) {

data/ext/common/Utils/IOUtils.h

@@ -345,10 +345,19 @@ ssize_t gatheredWrite(int fd, const StaticString data[], unsigned int dataCount,
  * @param fd The file descriptor to write to.
  * @param data An array of buffers to be written.
  * @param count Number of items in <em>data</em>.
+ * @param timeout A pointer to an integer, which specifies the maximum number of
+ *                microseconds that may be spent on writing all the 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.
  * @throws SystemException Something went wrong.
+ * @throws TimeoutException Unable to write all given data within
+ *                          <tt>timeout</tt> microseconds.
  * @throws boost::thread_interrupted
  */
-void    gatheredWrite(int fd, const StaticString data[], unsigned int dataCount);
+void    gatheredWrite(int fd, const StaticString data[], unsigned int dataCount, unsigned long long *timeout = NULL);
 
 /**
  * Sets a writev-emulating function that gatheredWrite() should call instead of the real writev().
@@ -356,6 +365,53 @@ void    gatheredWrite(int fd, const StaticString data[], unsigned int dataCount)
  */
 void setWritevFunction(WritevFunction func);
 
+/**
+ * Receive a file descriptor over the given Unix domain socket.
+ * This is a low-level function that directly wraps the Unix file
+ * descriptor passing system calls. You should not use this directly;
+ * instead you should use readFileDescriptorWithNegotiation() from MessageIO.h
+ * which is safer. See MessageIO.h for more information about the
+ * negotiation protocol for file descriptor passing.
+ *
+ * @param timeout A pointer to an integer, which specifies the maximum number of
+ *                microseconds that may be spent on receiving the file descriptor.
+ *                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 receiving will be deducted
+ *                from <tt>timeout</tt>.
+ *                Pass NULL if you do not want to enforce a timeout.
+ * @return The received file descriptor.
+ * @throws SystemException Something went wrong.
+ * @throws IOException Whatever was received doesn't seem to be a
+ *                     file descriptor.
+ * @throws TimeoutException Unable to receive a file descriptor within
+ *                          <tt>timeout</tt> microseconds.
+ * @throws boost::thread_interrupted
+ */
+int readFileDescriptor(int fd, unsigned long long *timeout = NULL);
+
+/**
+ * Pass the file descriptor 'fdToSend' over the Unix socket 'fd'.
+ * This is a low-level function that directly wraps the Unix file
+ * descriptor passing system calls. You should not use this directly;
+ * instead you should use writeFileDescriptorWithNegotiation() from MessageIO.h
+ * which is safer. See MessageIO.h for more information about the
+ * negotiation protocol for file descriptor passing.
+ *
+ * @param timeout A pointer to an integer, which specifies the maximum number of
+ *                microseconds that may be spent on trying to pass the file descriptor.
+ *                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.
+ * @throws SystemException Something went wrong.
+ * @throws TimeoutException Unable to pass the file descriptor within
+ *                          <tt>timeout</tt> microseconds.
+ * @throws boost::thread_interrupted
+ */
+void writeFileDescriptor(int fd, int fdToSend, unsigned long long *timeout = NULL);
+
 /**
  * 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.