passenger 2.2.15 → 3.0.0.pre1

data/ext/common/EventedMessageServer.h

@@ -0,0 +1,327 @@
+/*
+ *  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_EVENTED_MESSAGE_SERVER_H_
+#define _PASSENGER_EVENTED_MESSAGE_SERVER_H_
+
+#include <boost/shared_ptr.hpp>
+#include <ev++.h>
+#include <cstdarg>
+#include "EventedServer.h"
+#include "MessageReadersWriters.h"
+#include "AccountsDatabase.h"
+#include "Constants.h"
+#include "Utils.h"
+
+namespace Passenger {
+
+using namespace boost;
+
+/* This source file follows the security guidelines written in Account.h. */
+
+struct EventedMessageClientContext {
+	enum State {
+		MS_READING_USERNAME,
+		MS_READING_PASSWORD,
+		MS_READING_MESSAGE,
+		MS_PROCESSING_MESSAGE
+	};
+	
+	State state;
+	AccountPtr account;
+	
+	ev::timer authenticationTimer;
+	ScalarMessage scalarReader;
+	ArrayMessage arrayReader;
+	string username;
+	
+	EventedMessageClientContext() {
+		state = MS_READING_USERNAME;
+	}
+	
+	~EventedMessageClientContext() {
+		/* Its buffer might contain password data so make sure
+		 * it's properly zeroed out. */
+		scalarReader.reset(true);
+	}
+};
+
+class EventedMessageClient: public EventedClient {
+public:
+	EventedMessageClientContext messageServer;
+	
+	EventedMessageClient(struct ev_loop *loop, const FileDescriptor &fd)
+		: EventedClient(loop, fd)
+	{
+		messageServer.authenticationTimer.set(loop);
+	}
+	
+	void writeArrayMessage(const char *name, ...) {
+		va_list ap;
+		unsigned int count = 0;
+		
+		va_start(ap, name);
+		while (va_arg(ap, const char *) != NULL) {
+			count++;
+		}
+		va_end(ap);
+		
+		StaticString args[count + 1];
+		unsigned int i = 1;
+		
+		args[0] = name;
+		va_start(ap, name);
+		while (true) {
+			const char *arg = va_arg(ap, const char *);
+			if (arg != NULL) {
+				args[i] = arg;
+				i++;
+			} else {
+				break;
+			}
+		}
+		va_end(ap);
+		
+		writeArrayMessage(args, count + 1);
+	}
+	
+	void writeArrayMessage(StaticString args[], unsigned int count) {
+		char headerBuf[sizeof(uint16_t)];
+		unsigned int outSize = ArrayMessage::outputSize(count);
+		StaticString out[outSize];
+		
+		ArrayMessage::generate(args, count, headerBuf, out, outSize);
+		write(out, outSize);
+	}
+};
+
+/**
+ * Note when overriding onNewClient: call the parent method first! It does
+ * some initialization but might disconnect the client if that initialization
+ * fails. The override should check for this.
+ */
+class EventedMessageServer: public EventedServer {
+protected:
+	AccountsDatabasePtr accountsDatabase;
+	
+	
+	/******** Overrided hooks and methods ********/
+	
+	virtual EventedClient *createClient(const FileDescriptor &fd) {
+		return new EventedMessageClient(getLoop(), fd);
+	}
+	
+	virtual void onNewClient(EventedClient *_client) {
+		EventedMessageClient *client = (EventedMessageClient *) _client;
+		EventedMessageClientContext *context = &client->messageServer;
+		
+		context->authenticationTimer.set
+			<&EventedMessageServer::onAuthenticationTimeout>(client);
+		context->authenticationTimer.start(10);
+		
+		context->arrayReader.reserve(5);
+		context->scalarReader.setMaxSize(MESSAGE_SERVER_MAX_USERNAME_SIZE);
+		
+		client->writeArrayMessage("version", protocolVersion(), NULL);
+	}
+	
+	virtual void onClientReadable(EventedClient *_client) {
+		EventedMessageClient *client = (EventedMessageClient *) _client;
+		this_thread::disable_syscall_interruption dsi;
+		int i = 0;
+		bool done = false;
+		
+		// read() from the client at most 10 times on every read readiness event
+		// in order to give other events the chance to be processed.
+		while (i < 10 && !done) {
+			char buf[1024 * 8];
+			ssize_t ret;
+			
+			ret = syscalls::read(client->fd, buf, sizeof(buf));
+			if (ret == -1) {
+				if (errno != EAGAIN) {
+					int e = errno;
+					client->disconnect(true);
+					logSystemError(client, "Cannot read data from client", e);
+				}
+				done = true;
+			} else if (ret == 0) {
+				done = true;
+				ScopeGuard guard(boost::bind(&EventedClient::disconnect,
+					client, false));
+				onEndOfStream(client);
+			} else {
+				onDataReceived(client, buf, ret);
+			}
+			i++;
+			done = done || !client->ioAllowed();
+		}
+	}
+	
+	
+	/******** New EventedMessageServer overridable hooks and API methods ********/
+	
+	virtual void onClientAuthenticated(EventedMessageClient *client) {
+		// Do nothing.
+	}
+	
+	virtual bool onMessageReceived(EventedMessageClient *client, const vector<StaticString> &args) {
+		return true;
+	}
+	
+	virtual void onEndOfStream(EventedMessageClient *client) {
+		// Do nothing.
+	}
+	
+	virtual pair<size_t, bool> onOtherDataReceived(EventedMessageClient *client,
+		const char *data, size_t size)
+	{
+		abort();
+	}
+	
+	virtual const char *protocolVersion() const {
+		return "1";
+	}
+	
+	void discardReadData() {
+		readDataDiscarded = true;
+	}
+
+private:
+	bool readDataDiscarded;
+	
+	static void onAuthenticationTimeout(ev::timer &t, int revents) {
+		EventedMessageClient *client = (EventedMessageClient *) t.data;
+		client->disconnect();
+	}
+	
+	void onDataReceived(EventedMessageClient *client, char *data, size_t size) {
+		EventedMessageClientContext *context = &client->messageServer;
+		size_t consumed = 0;
+		
+		readDataDiscarded = false;
+		while (consumed < size && client->ioAllowed() && !readDataDiscarded) {
+			char *current = data + consumed;
+			size_t rest = size - consumed;
+			
+			switch (context->state) {
+			case EventedMessageClientContext::MS_READING_USERNAME:
+				consumed += context->scalarReader.feed(current, rest);
+				if (context->scalarReader.hasError()) {
+					client->writeArrayMessage(
+						"The supplied username is too long.",
+						NULL);
+					client->disconnect();
+				} else if (context->scalarReader.done()) {
+					context->username = context->scalarReader.value();
+					context->scalarReader.reset();
+					context->scalarReader.setMaxSize(MESSAGE_SERVER_MAX_PASSWORD_SIZE);
+					context->state = EventedMessageClientContext::MS_READING_PASSWORD;
+				}
+				break;
+				
+			case EventedMessageClientContext::MS_READING_PASSWORD: {
+				size_t locallyConsumed;
+				
+				locallyConsumed = context->scalarReader.feed(current, rest);
+				consumed += locallyConsumed;
+				
+				// The buffer contains password data so make sure we zero
+				// it out when we're done.
+				MemZeroGuard passwordGuard(current, locallyConsumed);
+				
+				if (context->scalarReader.hasError()) {
+					context->scalarReader.reset(true);
+					client->writeArrayMessage(
+						"The supplied password is too long.",
+						NULL);
+					client->disconnect();
+				} else if (context->scalarReader.done()) {
+					context->authenticationTimer.stop();
+					context->account = accountsDatabase->authenticate(
+						context->username, context->scalarReader.value());
+					passwordGuard.zeroNow();
+					context->username.clear();
+					if (context->account) {
+						context->scalarReader.reset(true);
+						context->state = EventedMessageClientContext::MS_READING_MESSAGE;
+						client->writeArrayMessage("ok", NULL);
+						onClientAuthenticated(client);
+					} else {
+						context->scalarReader.reset(true);
+						client->writeArrayMessage(
+							"Invalid username or password.",
+							NULL);
+						client->disconnect();
+					}
+				}
+				break;
+			}
+			
+			case EventedMessageClientContext::MS_READING_MESSAGE:
+				consumed += context->arrayReader.feed(current, rest);
+				if (context->arrayReader.hasError()) {
+					client->disconnect();
+				} else if (context->arrayReader.done()) {
+					context->state = EventedMessageClientContext::MS_PROCESSING_MESSAGE;
+					if (context->arrayReader.value().empty()) {
+						logError(client, "Client sent an empty message.");
+						client->disconnect();
+					} else if (onMessageReceived(client, context->arrayReader.value())
+					   && context->state == EventedMessageClientContext::MS_PROCESSING_MESSAGE) {
+						context->state = EventedMessageClientContext::MS_READING_MESSAGE;
+					}
+					context->arrayReader.reset();
+				}
+				break;
+			
+			case EventedMessageClientContext::MS_PROCESSING_MESSAGE: {
+				pair<size_t, bool> ret = onOtherDataReceived(client, current, rest);
+				consumed += ret.first;
+				if (ret.second && context->state == EventedMessageClientContext::MS_PROCESSING_MESSAGE) {
+					context->state = EventedMessageClientContext::MS_READING_MESSAGE;
+				}
+				break;
+			}
+			
+			default:
+				// Never reached.
+				abort();
+			}
+		}
+	}
+
+public:
+	EventedMessageServer(struct ev_loop *loop, FileDescriptor fd,
+		const AccountsDatabasePtr &accountsDatabase)
+		: EventedServer(loop, fd)
+	{
+		this->accountsDatabase = accountsDatabase;
+	}
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_EVENTED_MESSAGE_SERVER_H_ */

data/ext/common/EventedServer.h

@@ -0,0 +1,295 @@
+/*
+ *  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_EVENTED_SERVER_H_
+#define _PASSENGER_EVENTED_SERVER_H_
+
+#include <ev++.h>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <oxt/system_calls.hpp>
+#include <oxt/macros.hpp>
+#include <algorithm>
+#include <string>
+#include <set>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <sys/uio.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <cerrno>
+#include "EventedClient.h"
+#include "FileDescriptor.h"
+#include "StaticString.h"
+#include "Logging.h"
+#include "Utils/ScopeGuard.h"
+#include "Utils/StrIntUtils.h"
+
+namespace Passenger {
+
+using namespace std;
+using namespace boost;
+using namespace oxt;
+
+
+/**
+ * A base class for writing single-threaded, evented servers that use non-blocking I/O.
+ * It uses libev for its event loop. EventedServer handles much of the situps regarding
+ * client connection management and output buffering and tries to make it easy to
+ * implement a zero-copy architecture.
+ *
+ * <h2>Basic usage</h2>
+ * Derived classes can override the onClientReadable() method, which is called every time
+ * a specific client becomes readable. It is passed a Client object which contains information
+ * about the client, such as its file descriptor. One can use the read() system call in
+ * that method to receive data from the client. Please note that client file descriptors
+ * are always set to non-blocking mode so you need to handle this gracefully.
+ *
+ * EventedServer provides the write() method for sending data to the client. This method
+ * will attempt to send the data to the client immediately; if it fails with EAGAIN then
+ * EventedServer will take care of scheduling the send at a later time when the client
+ * is ready again to receive data.
+ *
+ * To disconnect the client, call disconnect(). The connection might not be actually
+ * closed until all pending outgoing data have been sent out, but all the gory details
+ * is taken care of for you.
+ *
+ * <h2>Keeping per-client information</h2>
+ * If you need to keep per-client information then you can override the createClient()
+ * method and make it return an object that's a subclass of EventedServer::Client. This
+ * object is passed to onClientReadable(), so in there you can just cast the client object
+ * to your subclass.
+ *
+ * <h2>Client object life times</h2>
+ * All client objects are destroyed along with the EventedServer. Disconnecting
+ * a client also causes it to be destroyed after the current event handler has
+ * run or a short period of time after that.
+ */
+class EventedServer {
+protected:
+	typedef set<EventedClient *> ClientSet;
+	
+	const ClientSet &getClients() const {
+		return clients;
+	}
+	
+	string getClientName(const EventedClient *client) const {
+		return toString(client);
+	}
+	
+	void logError(const EventedClient *client, const string &message) {
+		P_ERROR("Error in client " << getClientName(client) << ": " << message);
+	}
+	
+	void logSystemError(const EventedClient *client, const string &message, int errorCode) {
+		P_ERROR("Error in client " << getClientName(client) << ": " <<
+			message << ": " << strerror(errorCode) << " (" << errorCode << ")");
+	}
+	
+	void logSystemError(const string &message, int errorCode) {
+		P_ERROR(message << ": " << strerror(errorCode) << " (" << errorCode << ")");
+	}
+	
+	virtual EventedClient *createClient(const FileDescriptor &fd) {
+		return new EventedClient(loop, fd);
+	}
+	
+	virtual void onNewClient(EventedClient *client) { }
+	virtual void onClientReadable(EventedClient *client) { }
+	
+	/**
+	 * Called when a client has been disconnected. This may either be triggered
+	 * immediately by disconnect() or triggered after pending data has been sent
+	 * out. This means that if you call disconnect() from onClientReadable() you
+	 * need take care of the possibility that control returns to onClientReadable()
+	 * after this method is done.
+	 *
+	 * Please note that when EventedServer is being destroyed,
+	 * onClientDisconnected() is *not* triggered.
+	 */
+	virtual void onClientDisconnected(EventedClient *client) { }
+
+private:
+	struct ev_loop *loop;
+	FileDescriptor fd;
+	ev::io acceptWatcher;
+	ClientSet clients;
+	
+	void removeClient(EventedClient *client) {
+		clients.erase(client);
+	}
+	
+	void freeAllClients() {
+		ClientSet::iterator it;
+		ClientSet::iterator end = clients.end();
+		
+		for (it = clients.begin(); it != clients.end(); it++) {
+			(*it)->unref();
+		}
+		clients.clear();
+	}
+	
+	static void _onReadable(EventedClient *client) {
+		EventedServer *server = (EventedServer *) client->userData;
+		client->ref();
+		ScopeGuard guard(boost::bind(&EventedClient::unref, client));
+		server->onClientReadable((EventedClient *) client);
+	}
+	
+	static void _onDisconnect(EventedClient *client) {
+		EventedServer *server = (EventedServer *) client->userData;
+		ScopeGuard guard1(boost::bind(&EventedClient::unref, client));
+		
+		client->ref();
+		ScopeGuard guard2(boost::bind(&EventedClient::unref, client));
+		
+		server->removeClient(client);
+		server->onClientDisconnected((EventedClient *) client);
+	}
+	
+	static void _onDetach(EventedClient *client) {
+		EventedServer *server = (EventedServer *) client->userData;
+		ScopeGuard guard1(boost::bind(&EventedClient::unref, client));
+		
+		client->ref();
+		ScopeGuard guard2(boost::bind(&EventedClient::unref, client));
+		
+		server->removeClient(client);
+	}
+	
+	static void _onSystemError(EventedClient *client, const string &message, int code) {
+		EventedServer *server = (EventedServer *) client->userData;
+		server->logSystemError(client, message, code);
+	}
+	
+	void exceptionThrownWhileInitializingClient(EventedClient *client, ClientSet::iterator it) {
+		if (!client->ioAllowed()) {
+			// onNewClient() disconnected or detached the
+			// client, so client refcount == 1
+			client->unref();
+		} else {
+			// client refcount == 2
+			client->unref();
+			client->unref();
+			clients.erase(it);
+		}
+		// Now client refcount == 0
+	}
+	
+	void onAcceptable(ev::io &w, int revents) {
+		this_thread::disable_syscall_interruption dsi;
+		int i = 0;
+		bool done = false;
+		
+		// Accept at most 10 connections on every accept readiness event
+		// in order to give other events the chance to be processed.
+		while (i < 10 && !done) {
+			// Reserve enough space to hold both a Unix domain socket
+			// address and an IP socket address.
+			union {
+				struct sockaddr_un local;
+				struct sockaddr_in inet;
+			} addr;
+			socklen_t len = sizeof(addr);
+			
+			int clientfd = syscalls::accept(fd, (struct sockaddr *) &addr, &len);
+			if (clientfd == -1) {
+				if (errno != EAGAIN && errno != EWOULDBLOCK) {
+					int e = errno;
+					logSystemError("Cannot accept new client", e);
+				}
+				done = true;
+			} else {
+				FileDescriptor clientfdGuard = clientfd;
+				int optval = 1;
+				
+				setNonBlocking(clientfdGuard);
+				syscalls::setsockopt(clientfd, SOL_SOCKET, SO_KEEPALIVE,
+					&optval, sizeof(optval));
+				
+				EventedClient *client = createClient(clientfdGuard);
+				client->onReadable    = _onReadable;
+				client->onDisconnect  = _onDisconnect;
+				client->onDetach      = _onDetach;
+				client->onSystemError = _onSystemError;
+				client->userData      = this;
+				client->notifyReads(true);
+				
+				pair<ClientSet::iterator, bool> p = clients.insert(client);
+				
+				client->ref();
+				// client refcount == 2
+				{
+					ScopeGuard g(boost::bind(
+						&EventedServer::exceptionThrownWhileInitializingClient,
+						this,
+						client,
+						p.first));
+					onNewClient(client);
+					g.clear();
+					// If exception occurred: client refcount == 0
+				}
+				
+				/* No exception occured.
+				 * If onNewClient() disconnected or detached the client:
+				 *     client refcount == 1
+				 *     We want the refcount to become 0.
+				 * If not:
+				 *     client refcount == 2
+				 *     We want the refcount to become 1.
+				 */
+				client->unref();
+			}
+			i++;
+		}
+	}
+	
+public:
+	EventedServer(struct ev_loop *_loop, FileDescriptor serverFd)
+		: loop(_loop),
+		  acceptWatcher(_loop)
+	{
+		fd = serverFd;
+		setNonBlocking(serverFd);
+		acceptWatcher.set<EventedServer, &EventedServer::onAcceptable>(this);
+		acceptWatcher.start(fd, ev::READ);
+	}
+	
+	virtual ~EventedServer() {
+		freeAllClients();
+	}
+	
+	struct ev_loop *getLoop() const {
+		return loop;
+	}
+	
+	FileDescriptor getServerFd() const {
+		return fd;
+	}
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_EVENTED_SERVER_H_ */